¿Cómo crear una cadena con formato?

Necesito crear una cadena con formato que pueda convertir los tipos int, long, double, etc. en string. Usando Obj-C, puedo hacerlo de la siguiente manera.

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

¿Cómo hacer lo mismo con Swift?

Creo que esto podría ayudarte:

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

Resultado de ejemplo:

timeNow in hex: 5cdc9c8d

nada especial

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

Actualización: escribí esta respuesta antes de que Swift String(format:)agregara a su API. Use el método dado por la respuesta superior .

No se NSStringrequiere!

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)

Yo diría que ambos

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

y

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

son aceptables ya que el usuario preguntó sobre el formato y ambos casos se ajustan a lo que están pidiendo:

Necesito crear una cadena con formato que pueda convertir los tipos int, long, double, etc. en string.

Obviamente, el primero permite un control más fino sobre el formato que el segundo, pero eso no significa que el segundo no sea una respuesta aceptable.

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

Lea primero la documentación oficial para el lenguaje Swift.

La respuesta debería ser

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

aquí

1) Cualquier valor de coma flotante por defecto double

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

-> Si desea mostrar el valor de coma flotante, entonces necesita definir explícitamente como

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

Esto es mucho más claro.

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

Sé que ha pasado mucho tiempo desde esta publicación, pero he caído en una situación similar y creo una clase simple para simplificar mi vida.

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
    }

}

El siguiente enlace se envía al código fuente completo: https://gist.github.com/dedeexe/d9a43894081317e7c418b96d1d081b25

Esta solución se basó en este artículo: http://vojtastavik.com/2015/03/29/real-time-formatting-in-uitextfield-swift-basics/

Hay una solución simple que aprendí con "We <3 Swift" si no puede importar Foundation , use round () y / o no quiere una String :

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

resultado: 31.726

Use este siguiente código:

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

Éxito para probarlo:

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