Comment créer une chaîne au format?

J'ai besoin de créer une chaîne avec un format qui peut convertir les types int, long, double, etc. en chaîne. En utilisant Obj-C, je peux le faire via ci-dessous.

NSString *str = [NSString stringWithFormat:@"%d , %f, %ld, %@", INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, STRING_VALUE];

Comment faire de même avec Swift?

Je pense que cela pourrait vous aider:

let timeNow = time(nil)
let aStr = String(format: "%@%x", "timeNow in hex: ", timeNow)
print(aStr)

Exemple de résultat:

timeNow in hex: 5cdc9c8d

rien de spécial

let str = NSString(format:"%d , %f, %ld, %@", INT_VALUE, FLOAT_VALUE, LONG_VALUE, STRING_VALUE)

let str = "\(INT_VALUE), \(FLOAT_VALUE), \(DOUBLE_VALUE), \(STRING_VALUE)"

Mise à jour: j'ai écrit cette réponse avant que Swift n'ait String(format:)ajouté à son API. Utilisez la méthode donnée par la première réponse .

Non NSStringrequis!

String(format: "Value: %3.2f\tResult: %3.2f", arguments: [2.7, 99.8])

ou

String(format:"Value: %3.2f\tResult: %3.2f", 2.7, 99.8)

Je dirais que les deux

let str = String(format:"%d, %f, %ld", INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE)

et

let str = "\(INT_VALUE), \(FLOAT_VALUE), \(DOUBLE_VALUE)"

sont tous deux acceptables car l'utilisateur a posé des questions sur le formatage et les deux cas correspondent à ce qu'ils demandent:

J'ai besoin de créer une chaîne avec un format qui peut convertir les types int, long, double, etc. en chaîne.

Évidemment, le premier permet un contrôle plus fin sur le formatage que le second, mais cela ne signifie pas que le second n'est pas une réponse acceptable.

var str = "\(INT_VALUE) , \(FLOAT_VALUE) , \(DOUBLE_VALUE), \(STRING_VALUE)"

Première lecture documentation officielle du langage Swift.

La réponse devrait être

var str = "\(INT_VALUE) , \(FLOAT_VALUE) , \(DOUBLE_VALUE), \(STRING_VALUE)"
println(str)

Ici

1) Toute valeur à virgule flottante par défaut double

EX.
 var myVal = 5.2 // its double by default;

-> Si vous souhaitez afficher une valeur en virgule flottante, vous devez définir explicitement comme un

 EX.
     var myVal:Float = 5.2 // now its float value;

C'est beaucoup plus clair.

let INT_VALUE=80
let FLOAT_VALUE:Double= 80.9999
let doubleValue=65.0
let DOUBLE_VALUE:Double= 65.56
let STRING_VALUE="Hello"

let str = NSString(format:"%d , %f, %ld, %@", INT_VALUE, FLOAT_VALUE, DOUBLE_VALUE, STRING_VALUE);
 println(str);

Je sais que beaucoup de temps s'est écoulé depuis cette publication, mais je suis tombé dans une situation similaire et j'ai créé une classe simple pour simplifier ma vie.

public struct StringMaskFormatter {

    public var pattern              : String    = ""
    public var replecementChar      : Character = "*"
    public var allowNumbers         : Bool      = true
    public var allowText            : Bool      = false


    public init(pattern:String, replecementChar:Character="*", allowNumbers:Bool=true, allowText:Bool=true)
    {
        self.pattern            = pattern
        self.replecementChar    = replecementChar
        self.allowNumbers       = allowNumbers
        self.allowText          = allowText
    }


    private func prepareString(string:String) -> String {

        var charSet : NSCharacterSet!

        if allowText && allowNumbers {
            charSet = NSCharacterSet.alphanumericCharacterSet().invertedSet
        }
        else if allowText {
            charSet = NSCharacterSet.letterCharacterSet().invertedSet
        }
        else if allowNumbers {
            charSet = NSCharacterSet.decimalDigitCharacterSet().invertedSet
        }

        let result = string.componentsSeparatedByCharactersInSet(charSet)
        return result.joinWithSeparator("")
    }

    public func createFormattedStringFrom(text:String) -> String
    {
        var resultString = ""
        if text.characters.count > 0 && pattern.characters.count > 0
        {

            var finalText   = ""
            var stop        = false
            let tempString  = prepareString(text)

            var formatIndex = pattern.startIndex
            var tempIndex   = tempString.startIndex

            while !stop
            {
                let formattingPatternRange = formatIndex ..< formatIndex.advancedBy(1)

                if pattern.substringWithRange(formattingPatternRange) != String(replecementChar) {
                    finalText = finalText.stringByAppendingString(pattern.substringWithRange(formattingPatternRange))
                }
                else if tempString.characters.count > 0 {
                    let pureStringRange = tempIndex ..< tempIndex.advancedBy(1)
                    finalText = finalText.stringByAppendingString(tempString.substringWithRange(pureStringRange))
                    tempIndex = tempIndex.advancedBy(1)
                }

                formatIndex = formatIndex.advancedBy(1)

                if formatIndex >= pattern.endIndex || tempIndex >= tempString.endIndex {
                    stop = true
                }

                resultString = finalText

            }
        }

        return resultString
    }

}

Le lien suivant envoie au code source complet: https://gist.github.com/dedeexe/d9a43894081317e7c418b96d1d081b25

Cette solution était basée sur cet article: http://vojtastavik.com/2015/03/29/real-time-formatting-in-uitextfield-swift-basics/

Il existe une solution simple que j'ai apprise avec "We <3 Swift" si vous ne pouvez pas importer Foundation , utilisez round () et / ou ne voulez pas de String :

var number = 31.726354765
var intNumber = Int(number * 1000.0)
var roundedNumber = Double(intNumber) / 1000.0

résultat: 31.726

Utilisez ce code suivant:

    let intVal=56
    let floatval:Double=56.897898
    let doubleValue=89.0
    let explicitDaouble:Double=89.56
    let stringValue:"Hello"

    let stringValue="String:\(stringValue) Integer:\(intVal) Float:\(floatval) Double:\(doubleValue) ExplicitDouble:\(explicitDaouble) "

Succès pour l'essayer:

 var letters:NSString = "abcdefghijkl"
        var strRendom = NSMutableString.stringWithCapacity(strlength)
        for var i=0; i<strlength; i++ {
            let rndString = Int(arc4random() % 12)
            //let strlk = NSString(format: <#NSString#>, <#CVarArg[]#>)
            let strlk = NSString(format: "%c", letters.characterAtIndex(rndString))
            strRendom.appendString(String(strlk))
        }