Wie erstelle ich einen String mit Format?

Ich muss eine Zeichenfolge mit Format erstellen, die int-, long-, double- usw. Typen in Zeichenfolgen konvertieren kann. Mit Obj-C kann ich es über den folgenden Weg tun.

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

Wie mache ich das mit Swift?

Ich denke, das könnte dir helfen:

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

Beispielergebnis:

timeNow in hex: 5cdc9c8d

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:)die API hinzugefügt hat. Verwenden Sie die in der oberen Antwort angegebene Methode .

Nicht NSStringerforderlich!

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 beides 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 zu den Anforderungen passen:

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

Ersteres ermöglicht natürlich eine feinere Kontrolle über die Formatierung als Letzteres, aber das bedeutet nicht, dass Letzteres keine akzeptable Antwort ist.

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

Lesen Sie zuerst die offizielle Dokumentation für die 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 einen Gleitkommawert anzeigen möchten, müssen Sie diesen explizit 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);

Ich weiß, dass seit dieser Veröffentlichung viel Zeit vergangen ist, aber ich bin in eine ähnliche Situation geraten und habe eine einfache 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
    }

}

Der folgende Link wird an den vollständigen Quellcode gesendet: https://gist.github.com/dedeexe/d9a43894081317e7c418b96d1d081b25

Diese Lösung basierte auf diesem Artikel: http://vojtastavik.com/2015/03/29/real-time-formatting-in-uitextfield-swift-basics/

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

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

Ergebnis: 31.726

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

Erfolg, es zu versuchen:

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