Comment faire pour formater un Double dans la Monnaie - Swift 3

Je suis nouveau sur Swift programmation et j'ai été la création d'un simple calculateur de pourboire application dans Xcode 8.2, j'ai mes calculs mis en place au sein de mon IBAction ci-dessous. Mais quand j'exécute mon application et d'entrée d'un montant à calculer (comme 23h45), il est livré avec plus de 2 décimales. Comment puis-je formater .currency dans ce cas?

@IBAction func calculateButtonTapped(_ sender: Any) {

    var tipPercentage: Double {

        if tipAmountSegmentedControl.selectedSegmentIndex == 0 {
            return 0.05
        } else if tipAmountSegmentedControl.selectedSegmentIndex == 1 {
            return 0.10
        } else {
            return 0.2
        }
    }

    let billAmount: Double? = Double(userInputTextField.text!)

    if let billAmount = billAmount {
        let tipAmount = billAmount * tipPercentage
        let totalBillAmount = billAmount + tipAmount

        tipAmountLabel.text = "Tip Amount: $\(tipAmount)"
        totalBillAmountLabel.text = "Total Bill Amount: $\(totalBillAmount)"
    }
}

InformationsquelleAutor Gar | 2017-01-09

77

Vous pouvez utiliser cette chaîne d'initialiseur si vous voulez de la force de la devise en dollars:
```
String(format: "Tip Amount: $%.02f", tipAmount)
```
Si vous voulez qu'il soit entièrement dépendante de la configuration locale de l'appareil, vous devez utiliser un NumberFormatter. Cela permettra de prendre en compte le nombre de décimales pour la monnaie ainsi que le positionnement du symbole de la monnaie correctement. E. g. la double valeur de 2,4 sera de retour "2,40 €" pour l'locale es_ES et "¥ 2" pour la jp_JP locale.
```
let formatter = NumberFormatter()
formatter.locale = Locale.current //Change this to another locale if you want to force a specific locale, otherwise this is redundant as the current locale is the default already
formatter.numberStyle = .currency
if let formattedTipAmount = formatter.string(from: tipAmount as NSNumber) {
    tipAmountLabel.text = "Tip Amount: \(formattedTipAmount)"
}
```
- FYI - aucun besoin d'installer le module de formatage du locale à Locale.current puisque c'est la valeur par défaut.
- Ouais, je sais, j'ai ajouté un commentaire pour dire que c'est redondant. Voulais le garder là pour montrer qu'il peut être facilement changé.
InformationsquelleAutor silicon_valley

Comment faire dans Swift 4:

let myDouble = 9999.99
let currencyFormatter = NumberFormatter()
currencyFormatter.usesGroupingSeparator = true
currencyFormatter.numberStyle = .currency
//localize to your grouping and decimal separator
currencyFormatter.locale = Locale.current

//We'll force unwrap with the !, if you've got defined data you may need more error checking

let priceString = currencyFormatter.string(from: NSNumber(value: myDouble))!
print(priceString) // Displays $9,999.99 in the US locale

InformationsquelleAutor Camilo Ortegón

9

La meilleure façon de le faire est de créer un NSNumberFormatter. (NumberFormatter dans Swift 3.) Vous pouvez demander de la monnaie et il va mettre en place la chaîne de suivre l'utilisateur des paramètres de localisation, ce qui est utile.

Si vous voulez forcer un format AMÉRICAIN en dollars et en cents chaîne de caractères, vous pouvez le formater de cette manière:
```
let amount: Double = 123.45

let amountString = String(format: "$%.02f", amount)
```
InformationsquelleAutor Duncan C
9

En plus de la NumberFormatter ou String(format:) discuté par d'autres, vous pouvez envisager d'utiliser Decimal ou NSDecimalNumber et de contrôle de l'arrondissement de vous-même, ainsi éviter virgule flottante questions. Si vous êtes en train de faire un simple calculateur de pourboire, ce n'est probablement pas nécessaire. Mais si vous faites quelque chose comme additionnant les conseils à la fin de la journée, si vous n'avez pas arrondir les nombres et/ou faire des mathématiques à l'aide de nombres décimaux, vous pouvez introduire des erreurs.

Donc, aller de l'avant et de configurer votre formateur:
```
let formatter: NumberFormatter = {
    let _formatter = NumberFormatter()
    _formatter.numberStyle = .decimal
    _formatter.minimumFractionDigits = 2
    _formatter.maximumFractionDigits = 2
    _formatter.generatesDecimalNumbers = true
    return _formatter
}()
```
et ensuite, utiliser des nombres décimaux:
```
let string = "2.03"
let tipRate = Decimal(sign: .plus, exponent: -3, significand: 125) //12.5%
guard let billAmount = formatter.number(from: string) as? Decimal else { return }
let tip = (billAmount * tipRate).rounded(2)

guard let output = formatter.string(from: tip as NSDecimalNumber) else { return }
print("\(output)")
```
Où
```
extension Decimal {

    ///Round `Decimal` number to certain number of decimal places.
    ///
    ///- Parameters:
    ///  - scale: How many decimal places.
    ///  - roundingMode: How should number be rounded. Defaults to `.plain`.
    ///- Returns: The new rounded number.

    func rounded(_ scale: Int, roundingMode: RoundingMode = .plain) -> Decimal {
        var value = self
        var result: Decimal = 0
        NSDecimalRound(&result, &value, scale, roundingMode)
        return result
    }
}
```
Évidemment, vous pouvez remplacer tous les "2 décimale" références avec ce numéro est approprié pour la devise que vous utilisez (ou peut-être utiliser une variable pour le nombre de décimales).
- Pourquoi ne pas utiliser la monnaie de style pour la NumberFormatter? Pas toutes les monnaies utiliser 2 chiffres après la virgule.
- Oui, vous pouvez le faire. Et vous pouvez même ensuite, regardez le nombre de décimales à qui vous devez ronde. Certes, à l'aide de .currency introduit d'autres problèmes (par exemple, l'analyse des cordes devient persnickety; il suppose que vous ne voyagez pas et de traiter avec d'autres devises, etc.). Selon l'application, il est parfois plus facile de permettre à l'utilisateur de spécifier le nombre de décimales et être fait avec elle. De plus, mon point n'était pas le formatage, mais plutôt l'avocat-conseil pour éviter de calcul en virgule flottante avec des monnaies.
- Une autre approche du problème d'arrondi est de multiplier les "dollars et en cents" (ou en euros, ou de shekels ou quoi que ce soit) quantité par 100 (ou par le nombre de fractions de parts dans l'ensemble de l'unité, pour les monnaies qui n'ont pas de 100 cents). Ensuite, utilisez entier mathématiques, et tout simplement le format de sortie manuellement pour insérer un séparateur décimal. Cette approche permet également d'éviter à virgule flottante erreurs.
- Eh bien, Decimal est beaucoup plus complexe que la simple integersinteger. Il représente les valeurs décimales à l'aide de BCD, et ne les mathématiques un chiffre décimal à un moment plutôt qu'à l'aide de mathématiques binaires et de conversion. Il prend également en charge des valeurs fractionnaires. En conséquence, il est BEAUCOUP plus lent que l'binaire à virgule flottante entier ou en mathématiques. Pour les calculs simples, la différence de vitesse n'a pas d'importance, mais si vous êtes en train de faire un grand nombre de calculs, la différence peut être très importante.
- Je suis d'accord que décimales peuvent être moins efficaces (mais pas observable donc, pour la grande majorité des demandes), mais à mon humble avis, c'est le droit de l'abstraction de la question de "comment faire des maths avec des monnaies.”
InformationsquelleAutor Rob

Vous pouvez convertir comme ça: ce func convertir les garder pour vous maximumFractionDigits chaque fois que vous voulez faire

static func df2so(_ price: Double) -> String{
        let numberFormatter = NumberFormatter()
        numberFormatter.groupingSeparator = ","
        numberFormatter.groupingSize = 3
        numberFormatter.usesGroupingSeparator = true
        numberFormatter.decimalSeparator = "."
        numberFormatter.numberStyle = .decimal
        numberFormatter.maximumFractionDigits = 2
        return numberFormatter.string(from: price as NSNumber)!
    }

j'ai créer dans le Modèle de classe
puis, quand vous appelez , vous pouvez accecpt il une autre classe , comme ceci

 print("InitData: result convert string " + Model.df2so(1008977.72))
//InitData: result convert string "1,008,977.72"

si vous souhaitez définir un séparateur dans tous les 3 chiffres donc, supprimer le numéro de style dans le code ci-dessus.

InformationsquelleAutor Chung Nguyen

vous pouvez créer une Extension pour en string ou Int, je voudrais montrer un exemple avec de la Ficelle

extension String{
     func toCurrencyFormat() -> String {
        if let intValue = Int(self){
           let numberFormatter = NumberFormatter()
           numberFormatter.locale = Locale(identifier: "ig_NG")/* Using Nigeria's Naira here or you can use Locale.current to get current locale, please change to your locale, link below to get all locale identifier.*/ 
           numberFormatter.numberStyle = NumberFormatter.Style.currency
           return numberFormatter.string(from: NSNumber(value: intValue)) ?? ""
      }
    return ""
  }
}

lien pour obtenir tous identificateur de paramètres régionaux

Vous pouvez également utiliser Locale.current pour obtenir le courant de l'appareil paramètres régionaux.

InformationsquelleAutor king_T

0
```
extension Float {
    var localeCurrency: String {
        let formatter = NumberFormatter()
        formatter.numberStyle = .currency
        formatter.locale = .current
        return formatter.string(from: self as NSNumber)!
    }
}
    amount = 200.02
    print("Amount Saved Value ",String(format:"%.2f", amountSaving. localeCurrency))
```
Pour moi Son retour 0.00!
Me semble Extenstion Parfait lorsque vous accédez au retour 0.00! Pourquoi?
- localeCurrency est déjà une chaîne de caractères. Pourquoi essayez-vous de le nourrir à travers une chaîne d'initialiseur?
- Alors pourquoi tu fais ça?
- Je n'ai pas de vérifier que le type de retour correctement!
- Alors, allez-vous résoudre ce problème?
- Il est toujours là... String(format:"%.2f", amountSaving. localeCurrency)
InformationsquelleAutor KkMIW
-2

Voici comment:
```
    let currentLocale = Locale.current
    let currencySymbol = currentLocale.currencySymbol
    let outputString = "\(currencySymbol)\(String(format: "%.2f", totalBillAmount))"
```
1ère ligne: Vous obtenez les paramètres régionaux en cours

2e ligne: Vous obtenez la currencySymbol pour que locale. (le$, le £, etc)

3ème ligne: en Utilisant le format de l'initialiseur de tronquer votre Double à 2 décimales.
- Ne pas le faire. Utilisation NumberFormatter. Cette approche a de nombreux problèmes qui sont facilement évitées par l'utilisation de NumberFormatter.
InformationsquelleAutor Atharva Vaidya

Vous devez vous connecter pour publier un commentaire.