Wie erstelle ich einen String mit Format?

nichts Besonderes

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)"

Update: Ich habe diese Antwort geschrieben, bevor Swift String(format:) zu seiner API hinzugefügt wurde. Wenden Sie die Methode an, die durch beste Antwort angegeben wird.

Nein NSString erforderlich!

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

oder

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

Ich würde das beide argumentieren

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

und

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

sind beide akzeptabel, da der Benutzer nach der Formatierung gefragt hat und beide Fälle den Anforderungen entsprechen:

Ich muss eine Zeichenfolge mit Format erstellen, die int-, long-, double-Typen usw. in Zeichenfolgen konvertieren kann.

Ersteres erlaubt natürlich eine genauere Kontrolle über die Formatierung als Letzteres, was jedoch nicht bedeutet, dass Letzteres keine akzeptable Antwort ist.

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

Lesen Sie zuerst Offizielle Dokumentation für Swift Sprache.

Antwort sollte sein

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

Hier

1) Standardmäßig ein beliebiger Gleitkommawert double

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

-> Wenn Sie Gleitkommawerte anzeigen möchten, müssen Sie explizit solche wie a definieren

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

Das ist viel klarer.

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);

Es gibt eine einfache Lösung, die ich mit "We <3 Swift" gelernt habe, wenn Sie entweder nicht Foundation importieren, round () verwenden können und/oder kein - wollen. String:

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

Ergebnis: 31.726

Ich weiß, dass seit dieser Veröffentlichung viel Zeit vergangen ist, aber ich bin in eine ähnliche Situation geraten und habe eine Simples-Klasse erstellt, um mein Leben zu vereinfachen.

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
    }

}

Über den folgenden Link senden Sie den vollständigen Quellcode an: https://Gist.github.com/dedeexe/d9a43894081317e7c418b96d1d081b25

Diese Lösung basiert auf folgendem Artikel: http://vojtastavik.com/2015/03/29/real-time-formatting-in-uitextfield-Swift-basics/

Verwenden Sie diesen folgenden Code:

    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) "