webentwicklung-frage-antwort-db.com.de

Wie erstelle ich einen String mit Format?

Ich muss eine Zeichenfolge mit Format erstellen, die int-, long-, double-Typen usw. in Zeichenfolgen konvertieren kann. Mit Obj-C kann ich das wie folgt machen.

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

Wie mache ich dasselbe mit swift?

169
Apurv

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
357
realityone

nichts Besonderes

let str = NSString(format:"%d , %f, %ld, %@", INT_VALUE, FLOAT_VALUE, LONG_VALUE, STRING_VALUE)
73
Bryan Chen
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.

40
John Estropia

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)
35
Durul Dalkanat

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.

14
Lance Clark
var str = "\(INT_VALUE) , \(FLOAT_VALUE) , \(DOUBLE_VALUE), \(STRING_VALUE)"
5
Apple

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.

5
iPatel
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);
2
Awais Chatha

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

1

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/

1
dede.exe

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