Come faccio a convertire una matrice Swift in una stringa?

So come farlo a livello di codice, ma sono sicuro che esiste un modo integrato ...

Ogni lingua che ho usato ha una sorta di rappresentazione testuale predefinita per una raccolta di oggetti che sputerà quando proverai a concatenare l'array con una stringa o passarlo a una funzione print (), ecc. Il linguaggio Swift di Apple avere un modo integrato di trasformare facilmente un array in una stringa o dobbiamo sempre essere espliciti quando si stringe un array?

Se l'array contiene stringhe, è possibile utilizzare il String's joinmetodo:

var array = ["1", "2", "3"]

let stringRepresentation = "-".join(array) // "1-2-3"

In Swift 2 :

var array = ["1", "2", "3"]

let stringRepresentation = array.joinWithSeparator("-") // "1-2-3"

Questo può essere utile se si desidera utilizzare un separatore specifico (hypen, blank, virgola, ecc.).

Altrimenti puoi semplicemente usare la descriptionproprietà, che restituisce una rappresentazione in formato stringa dell'array:

let stringRepresentation = [1, 2, 3].description // "[1, 2, 3]"

Suggerimento: qualsiasi oggetto che implementa il Printableprotocollo ha una descriptionproprietà. Se adotti quel protocollo nelle tue classi / strutture, rendi anche loro facili da stampare

In Swift 3

• joindiventa joined, ad esempio[nil, "1", "2"].flatMap({$0}).joined()
• joinWithSeparatordiventa joined(separator:)(disponibile solo per Array of Strings)

In Swift 4

var array = ["1", "2", "3"]
array.joined(separator:"-")

Con Swift 5, in base alle tue esigenze, puoi scegliere uno dei seguenti codici di esempio Playground per risolvere il tuo problema.

Trasformando una matrice di Characters in una Stringsenza separatore:

let characterArray: [Character] = ["J", "o", "h", "n"]
let string = String(characterArray)

print(string)
// prints "John"

Trasformando una matrice di Strings in una Stringsenza separatore:

let stringArray = ["Bob", "Dan", "Bryan"]
let string = stringArray.joined(separator: "")

print(string) // prints: "BobDanBryan"

Trasformando una matrice di Strings in a Stringcon un separatore tra le parole:

let stringArray = ["Bob", "Dan", "Bryan"]
let string = stringArray.joined(separator: " ")

print(string) // prints: "Bob Dan Bryan"

Trasformando una matrice di Strings in a Stringcon un separatore tra i caratteri:

let stringArray = ["car", "bike", "boat"]
let characterArray = stringArray.flatMap { $0 }
let stringArray2 = characterArray.map { String($0) }
let string = stringArray2.joined(separator: ", ")

print(string) // prints: "c, a, r, b, i, k, e, b, o, a, t"

Trasformando una matrice di Floats in a Stringcon un separatore tra numeri:

let floatArray = [12, 14.6, 35]
let stringArray = floatArray.map { String($0) }
let string = stringArray.joined(separator: "-")

print(string)
// prints "12.0-14.6-35.0"

Swift 2.0 Xcode 7.0 beta 6 in poi utilizza joinWithSeparator()invece di join():

var array = ["1", "2", "3"]
let stringRepresentation = array.joinWithSeparator("-") // "1-2-3"

joinWithSeparator è definito come un'estensione attivata SequenceType

extension SequenceType where Generator.Element == String {
    /// Interpose the `separator` between elements of `self`, then concatenate
    /// the result.  For example:
    ///
    ///     ["foo", "bar", "baz"].joinWithSeparator("-|-") // "foo-|-bar-|-baz"
    @warn_unused_result
    public func joinWithSeparator(separator: String) -> String
}

Swift 3

["I Love","Swift"].joined(separator:" ") // previously joinWithSeparator(" ")

In Swift 4

let array:[String] = ["Apple", "Pear ","Orange"]

array.joined(separator: " ")

Dal momento che nessuno ha menzionato ridurre, eccolo qui:

[0, 1, 1, 0].map {"\($0)"}.reduce("") {$0 + $1 } // "0110"

Nello spirito della programmazione funzionale 🤖

Per modificare una matrice di stringhe opzionali / non opzionali

//Array of optional Strings
let array : [String?] = ["1",nil,"2","3","4"]

//Separator String
let separator = ","

//flatMap skips the nil values and then joined combines the non nil elements with the separator
let joinedString = array.flatMap{ $0 }.joined(separator: separator)


//Use Compact map in case of **Swift 4**
    let joinedString = array.compactMap{ $0 }.joined(separator: separator

print(joinedString)

Qui flatMap , compactMap salta i valori zero nella matrice e aggiunge gli altri valori per dare una stringa unita.

Il mio funziona su NSMutableArray con componentiJoinedByString

var array = ["1", "2", "3"]
let stringRepresentation = array.componentsJoinedByString("-") // "1-2-3"

In Swift 2.2 potrebbe essere necessario eseguire il cast dell'array su NSArray per utilizzare componentsJoinedByString (",")

let stringWithCommas = (yourArray as NSArray).componentsJoinedByString(",")

Se si desidera eliminare le stringhe vuote nell'array.

["Jet", "Fire"].filter { !$0.isEmpty }.joined(separator: "-")

Se si desidera filtrare anche i valori zero:

["Jet", nil, "", "Fire"].flatMap { $0 }.filter { !$0.isEmpty }.joined(separator: "-")

let arrayTemp :[String] = ["Mani","Singh","iOS Developer"]
    let stringAfterCombining = arrayTemp.componentsJoinedByString(" ")
   print("Result will be >>>  \(stringAfterCombining)")

Il risultato sarà >>> Mani Singh Sviluppatore iOS

L'equivalente di Swift a quello che stai descrivendo è l'interpolazione di stringhe. Se stai pensando a cose come JavaScript "x" + array, l'equivalente in Swift è"x\(array)" .

Come nota generale, esiste un'importante differenza tra l'interpolazione di stringhe e il Printableprotocollo. Solo alcune classi sono conformi Printable. Ogni classe può essere in qualche modo interpolata in stringa. È utile quando si scrivono funzioni generiche. Non devi limitarti alle Printablelezioni.

È possibile stampare qualsiasi oggetto utilizzando la funzione di stampa

oppure usa \(name)per convertire qualsiasi oggetto in una stringa.

Esempio:

let array = [1,2,3,4]

print(array) // prints "[1,2,3,4]"

let string = "\(array)" // string == "[1,2,3,4]"
print(string) // prints "[1,2,3,4]"

Crea un'estensione per un Array:

extension Array {

    var string: String? {

        do {

            let data = try JSONSerialization.data(withJSONObject: self, options: [.prettyPrinted])

            return String(data: data, encoding: .utf8)

        } catch {

            return nil
        }
    }
}

Un separatore può essere una cattiva idea per alcune lingue come l'ebraico o il giapponese. Prova questo:

// Array of Strings
let array: [String] = ["red", "green", "blue"]
let arrayAsString: String = array.description
let stringAsData = arrayAsString.data(using: String.Encoding.utf16)
let arrayBack: [String] = try! JSONDecoder().decode([String].self, from: stringAsData!)

Per altri tipi di dati rispettivamente:

// Set of Doubles
let set: Set<Double> = [1, 2.0, 3]
let setAsString: String = set.description
let setStringAsData = setAsString.data(using: String.Encoding.utf16)
let setBack: Set<Double> = try! JSONDecoder().decode(Set<Double>.self, from: setStringAsData!)

se si dispone di un elenco di array di stringhe, quindi convertirlo in Int

let arrayList = list.map { Int($0)!} 
     arrayList.description

ti darà valore stringa

per qualsiasi tipo di elemento

extension Array {

    func joined(glue:()->Element)->[Element]{
        var result:[Element] = [];
        result.reserveCapacity(count * 2);
        let last = count - 1;
        for (ix,item) in enumerated() {
            result.append(item);
            guard ix < last else{ continue }
            result.append(glue());
        }
        return result;
    }
}

Prova questo:

let categories = dictData?.value(forKeyPath: "listing_subcategories_id") as! NSMutableArray
                        let tempArray = NSMutableArray()
                        for dc in categories
                        {
                            let dictD = dc as? NSMutableDictionary
                            tempArray.add(dictD?.object(forKey: "subcategories_name") as! String)
                        }
                        let joinedString = tempArray.componentsJoined(by: ",")

PER SWIFT 3:

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    if textField == phoneField
    {
        let newString = NSString(string: textField.text!).replacingCharacters(in: range, with: string)
        let components = newString.components(separatedBy: NSCharacterSet.decimalDigits.inverted)

        let decimalString = NSString(string: components.joined(separator: ""))
        let length = decimalString.length
        let hasLeadingOne = length > 0 && decimalString.character(at: 0) == (1 as unichar)

        if length == 0 || (length > 10 && !hasLeadingOne) || length > 11
        {
            let newLength = NSString(string: textField.text!).length + (string as NSString).length - range.length as Int

            return (newLength > 10) ? false : true
        }
        var index = 0 as Int
        let formattedString = NSMutableString()

        if hasLeadingOne
        {
            formattedString.append("1 ")
            index += 1
        }
        if (length - index) > 3
        {
            let areaCode = decimalString.substring(with: NSMakeRange(index, 3))
            formattedString.appendFormat("(%@)", areaCode)
            index += 3
        }
        if length - index > 3
        {
            let prefix = decimalString.substring(with: NSMakeRange(index, 3))
            formattedString.appendFormat("%@-", prefix)
            index += 3
        }

        let remainder = decimalString.substring(from: index)
        formattedString.append(remainder)
        textField.text = formattedString as String
        return false
    }
    else
    {
        return true
    }
}

Se la domanda è qualcosa del genere: tobeFormattedString = ["a", "b", "c"] Output = "abc"

String(tobeFormattedString)