Wie konvertiere ich ein Swift-Array in einen String?

Mit Swift 3 können Sie je nach Bedarf einen der folgenden Codeblöcke auswählen.

Ein Array von Character in ein String ohne Trennzeichen umwandeln:

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

print(string)
// prints "John"

Ein Array von String in ein String ohne Trennzeichen umwandeln:

let stringArray = ["Foo", "Bar", "Baz"]
let characterArray = stringArray.flatMap { String.CharacterView($0) }
//let characterArray = stringArray.flatMap { $0.characters } // also works
let string = String(characterArray)

print(string)
// prints "FooBarBaz"

Verwandeln eines Arrays von String in eine String mit einem Trennzeichen zwischen Wörtern:

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

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

Verwandeln eines Arrays von String in eine String mit einem Trennzeichen zwischen Zeichen:

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

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

Verwandeln eines Arrays von Float in eine String mit einem Trennzeichen zwischen Zahlen:

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

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

Swift 2.0 Xcode 7.0 Beta 6 verwendet joinWithSeparator() anstelle von join():

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

joinWithSeparator ist als Erweiterung für SequenceType definiert.

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

So ändern Sie ein Array von optionalen/nicht optionalen Zeichenfolgen

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

Hier flatMap , compactMap überspringt die Nullwerte im Array und hängt die anderen Werte an, um einen verbundenen String zu erhalten.

Da niemand die Reduktion erwähnt hat, hier ist es:

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

Im Geiste der funktionalen Programmierung ????

Meine arbeitet auf NSMutableArray mit KomponentenJoinedByString

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

In Swift 2.2 müssen Sie Ihr Array möglicherweise in NSArray umwandeln, um die KomponentenJoinedByString (",") verwenden zu können.

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

Wenn Sie leere Zeichenfolgen in das Array aufnehmen möchten.

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

Wenn Sie auch Nullwerte filtern möchten:

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

Das Ergebnis ist >>> Mani Singh iOS Developer

Das Swift-Äquivalent zu dem, was Sie beschreiben, ist die Interpolation von Strings. Wenn Sie über Dinge wie JavaScript nachdenken, das "x" + array verwendet, ist das Äquivalent in Swift "x\(array)".

Als allgemeine Anmerkung gibt es einen wichtigen Unterschied zwischen der String-Interpolation und dem Printable-Protokoll. Nur bestimmte Klassen entsprechen Printable. Jede Klasse kann irgendwie string interpoliert werden. Das ist hilfreich beim Schreiben von generischen Funktionen. Sie müssen sich nicht auf Printable-Klassen beschränken.

Erstellen Sie eine Erweiterung für eine 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
        }
    }
}

Versuche dies:

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

für jeden Elementtyp

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

wenn Sie eine String-Array-Liste haben, konvertieren Sie sie in Int 

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

es wird Ihnen einen Stringwert geben 

Sie können jedes Objekt mit der Druckfunktion drucken

oder verwenden Sie \(name), um ein beliebiges Objekt in einen String zu konvertieren.

Beispiel:

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

Ein Trennzeichen kann für einige Sprachen wie Hebräisch oder Japanisch eine schlechte Idee sein.

// 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!)

Für andere Datentypen jeweils:

// 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!)