Swift Calculator - Cannot enter Zero after decimal - swift

Question

I am exploring a Swift Calculator Code and everything works fine except that I am not able to input a Zero after the decimal sign (for ex.: 12,001 or 1,301) and I cannot find the solution. I tried already a few things and unfortunately I cannot find a question solving this issue.
Thanks a lot for your help!
Here are the main parts of the code.
private var total: Double = 0
private var temp: Double = 0
private var operating = false
private var decimal = false
private var operation: OperationType = .none
private let kDecimalSeparator = Locale.current.decimalSeparator!
private let kMaxLength = 11
private let kTotal = "total"
private enum OperationType {
case none, addition, substraction, multiplication, division, percent
}
// Format
private let auxFormatter: NumberFormatter = {
let formatter = NumberFormatter()
let locale = Locale.current
formatter.decimalSeparator = locale.decimalSeparator
formatter.numberStyle = .decimal
formatter.maximumIntegerDigits = 100
formatter.minimumFractionDigits = 0
formatter.maximumFractionDigits = 100
return formatter
}()
// Format result
private let auxTotalFormatter: NumberFormatter = {
let formatter = NumberFormatter()
let locale = Locale.current
formatter.decimalSeparator = locale.decimalSeparator
formatter.numberStyle = .decimal
formatter.maximumIntegerDigits = 100
formatter.minimumFractionDigits = 0
formatter.maximumFractionDigits = 100
return formatter
}()
// Default screen format
private let printFormatter: NumberFormatter = {
let formatter = NumberFormatter()
let locale = Locale.current
formatter.decimalSeparator = locale.decimalSeparator
formatter.numberStyle = .decimal
formatter.maximumIntegerDigits = 9
formatter.minimumFractionDigits = 0
formatter.maximumFractionDigits = 8
return formatter
}()
#IBAction func numberDecimalAction(_ sender: UIButton) {
let currentTemp = auxTotalFormatter.string(from: NSNumber(value: temp))!
if resultLabel.text?.contains(kDecimalSeparator) ?? false || (!operating && currentTemp.count >= kMaxLength) {
return
}
resultLabel.text = resultLabel.text! + kDecimalSeparator
decimal = true
selectVisualOperation()
sender.shine()
}
#IBAction func numberAction(_ sender: UIButton) {
operatorAC.setTitle("C", for: .normal)
var currentTemp = auxTotalFormatter.string(from: NSNumber(value: temp))!
if !operating && currentTemp.count >= kMaxLength {
return
}
currentTemp = auxFormatter.string(from: NSNumber(value: temp))!
// After selecting an operation
if operating {
total = total == 0 ? temp : total
resultLabel.text = ""
currentTemp = ""
operating = false
}
// After selecting decimal
if decimal {
currentTemp = "\(currentTemp)\(kDecimalSeparator)"
decimal = false
}
if resultLabel.text?.contains(kDecimalSeparator) ?? true {
let number = String(sender.tag-1)
let currentTemp1 = currentTemp.replacingOccurrences(of: ".", with: "", options: .literal, range: nil)
let currentTemp2 = currentTemp1.replacingOccurrences(of: ",", with: ".", options: .literal, range: nil)
temp = Double(currentTemp2 + String(number))!
resultLabel.text = printFormatter.string(from: NSNumber(value: temp))
selectVisualOperation()
sender.shine()
}
else {
let number = String(sender.tag-1)
temp = Double(currentTemp.replacingOccurrences(of: ".", with: "", options: .literal, range: nil) + String(number))!
resultLabel.text = printFormatter.string(from: NSNumber(value: temp))
selectVisualOperation()
sender.shine()
}
}
// Clear
private func clear() {
if operation == .none {
total = 0
}
operation = .none
operatorAC.setTitle("AC", for: .normal)
if temp != 0 {
temp = 0
resultLabel.text = "0"
} else {
total = 0
result()
}
}
`

Answer 1

Let’s assume that you’re doing the traditional calculator style input with buttons for the digits, a decimal separator button and a clear button. The problem with your algorithm is that NumberFormatter with a minimumFractionalDigits of zero will drop trailing digits. So if you try to enter “1.000”, it will say “ok the value is 1, so the string representation of that with zero fraction digits is ‘1’”. The effect of this is that trailing zeros will never appear in the resulting string.
One approach is to adjust minimumFractionalDigits based upon how many fractional digits have been entered thus far. To facilitate that, you need to be able to keep track of how fractional digits have been entered.
There are a number of ways of doing that. One way is through “state management” (e.g. have properties to keep track of whether decimal has been entered already and how many fractional digits have been entered thus far, etc.). To keep it simple, I’m just going to calculate this from the raw user string input:
class ViewController: UIViewController {
let decimalSeparator = Locale.current.decimalSeparator ?? "."
/// The number formatter
///
/// Note, we don't need to set the decimal separator, as it defaults to the current separator.
let formatter: NumberFormatter = {
let formatter = NumberFormatter()
formatter.numberStyle = .decimal
return formatter
}()
/// The label containing the formatted number
#IBOutlet weak var resultLabel: UILabel!
/// This is the user's raw input, just digits and 0 or one decimal separator, not the formatted number in the label
private var input: String = ""
/// Just add keystroke to `input` string and then format the label.
#IBAction func didTapDigit(_ button: UIButton) {
let digit = ... // determine the numeric value associated with the button that the user tapped; personally I wouldn’t use the `tag` number, but I don’t want to drag us down a tangent, so just do this however you want
addCharacterToInput("\(digit)")
updateLabel()
}
#IBAction func didTapClear(_ sender: UIButton) {
resetInput()
resultLabel.text = "0"
}
/// Only add decimal separator if there's not one there already.
#IBAction func didTapDecimal(_ sender: UIButton) {
if !hasDecimalSeparator() {
addCharacterToInput(".")
}
updateLabel()
}
}
private extension ViewController {
func addCharacterToInput(_ string: String) {
input += String(string)
}
func resetInput() {
input = ""
}
/// How many decimal places in user input.
///
/// - Returns: Returns `nil` if no decimal separator has been entered yet. Otherwise it returns the number of characters after the decimal separator.
func decimalPlaces() -> Int? {
guard let range = input.range(of: decimalSeparator) else {
return nil
}
return input.distance(from: range.upperBound, to: input.endIndex)
}
/// Does the user input include a decimal separator?
/// - Returns: Returns `true` if decimal separator present. Returns `false` if not.
func hasDecimalSeparator() -> Bool {
input.contains(decimalSeparator)
}
/// Update the label on the basis of the `input` string of the raw user input.
func updateLabel() {
let fractionalDigits = decimalPlaces() // figure out decimal places from `input` string
formatter.minimumFractionDigits = fractionalDigits ?? 0 // set formatter accordingly
guard
let value = Double(input), // safely get value from user input ...
var string = formatter.string(for: value) // ...and build base string from that.
else {
resultLabel.text = "Error"
return
}
if fractionalDigits == 0 { // Note, if not `nil` and is zero, that means the user hit decimal separator but has entered no digits yet; we need to manually add decimal separator in output in this scenario
string += decimalSeparator
}
resultLabel.text = string
}
}
That yields: