Jak utworzyć ciąg znaków w formacie?

Muszę utworzyć ciąg znaków w formacie, który może konwertować typy int, long, double itp. Na string. Za pomocą Obj-C mogę to zrobić poniżej.

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

Jak zrobić to samo z szybkim?

Myślę, że to może ci pomóc:

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

Przykładowy wynik:

timeNow in hex: 5cdc9c8d

nic specjalnego

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

Aktualizacja: Napisałem tę odpowiedź, zanim Swift String(format:)dodał do swojego API. Użyj metody podanej w górnej odpowiedzi .

Nie NSStringwymagane!

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

lub

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

Twierdziłbym, że jedno i drugie

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

i

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

są dopuszczalne, ponieważ użytkownik zapytał o formatowanie, a oba przypadki pasują do tego, o co proszą:

Muszę utworzyć ciąg znaków w formacie, który może konwertować typy int, long, double itp. Na string.

Oczywiście ta pierwsza umożliwia lepszą kontrolę nad formatowaniem niż druga, ale to nie znaczy, że druga nie jest akceptowalną odpowiedzią.

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

Najpierw przeczytaj oficjalną dokumentację dla języka Swift.

Odpowiedź powinna być

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

Tutaj

1) Domyślnie dowolna wartość zmiennoprzecinkowa double

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

-> Jeśli chcesz wyświetlić wartość zmiennoprzecinkową, musisz jawnie zdefiniować takie jak

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

Jest to o wiele bardziej jasne.

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

Wiem, że minęło dużo czasu od tej publikacji, ale wpadłem w podobną sytuację i stworzyłem klasę uproszczoną, aby uprościć moje życie.

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
    }

}

Poniższy link wyślij do pełnego kodu źródłowego: https://gist.github.com/dedeexe/d9a43894081317e7c418b96d1d081b25

To rozwiązanie zostało oparte na tym artykule: http://vojtastavik.com/2015/03/29/real-time-formatting-in-uitextfield-swift-basics/

Jest proste rozwiązanie, którego nauczyłem się z „We <3 Swift”, jeśli nie możesz zaimportować Foundation , użyć round () i / lub nie chcesz String :

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

wynik: 31,726

Użyj następującego kodu:

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

Sukces, aby spróbować:

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