Come creare una stringa con il formato?

Devo creare una stringa con un formato in grado di convertire tipi int, long, double, ecc. In stringa. Usando Obj-C, posso farlo tramite il modo seguente.

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

Come fare lo stesso con swift?

Penso che questo potrebbe aiutarti:

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

Risultato di esempio:

timeNow in hex: 5cdc9c8d

niente di speciale

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

Aggiornamento: ho scritto questa risposta prima che Swift avesse String(format:)aggiunto alla sua API. Utilizzare il metodo fornito dalla risposta principale .

Non NSStringrichiesto!

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

o

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

Direi che entrambi

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

e

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

sono entrambi accettabili poiché l'utente ha chiesto informazioni sulla formattazione ed entrambi i casi si adattano a ciò che stanno chiedendo:

Devo creare una stringa con un formato in grado di convertire tipi int, long, double, ecc. In stringa.

Ovviamente il primo consente un controllo più preciso della formattazione rispetto al secondo, ma ciò non significa che il secondo non sia una risposta accettabile.

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

Prima lettura documentazione ufficiale per la lingua Swift.

La risposta dovrebbe essere

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

Qui

1) Qualsiasi valore in virgola mobile per impostazione predefinita double

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

-> Se si desidera visualizzare un valore in virgola mobile, è necessario definire esplicitamente come ad esempio un

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

Questo è molto più chiaro.

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

So che è passato molto tempo da questa pubblicazione, ma sono caduto in una situazione simile e ho creato una classe semplice per semplificarmi la vita.

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
    }

}

Il seguente link invia al codice sorgente completo: https://gist.github.com/dedeexe/d9a43894081317e7c418b96d1d081b25

Questa soluzione era basata su questo articolo: http://vojtastavik.com/2015/03/29/real-time-formatting-in-uitextfield-swift-basics/

C'è una soluzione semplice che ho imparato con "We <3 Swift" se non puoi importare Foundation , usare round () e / o non vuoi una stringa :

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

risultato: 31.726

Usa questo codice seguente:

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

Successo per provarlo:

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