Wie konvertiere ich ein Swift-Array in einen String?

Ich weiß, wie man es programmgesteuert macht, aber ich bin mir sicher, dass es einen eingebauten Weg gibt ...

Jede Sprache, die ich verwendet habe, verfügt über eine Standardtextdarstellung für eine Sammlung von Objekten, die ausgespuckt wird, wenn Sie versuchen, das Array mit einer Zeichenfolge zu verketten oder an eine print () -Funktion usw. zu übergeben Haben Sie eine integrierte Methode, um ein Array einfach in einen String umzuwandeln, oder müssen wir beim Stringifizieren eines Arrays immer explizit sein?

Wenn das Array Strings enthält, können Sie die Verwendung Strings‘ joinMethode:

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"

Dies kann nützlich sein, wenn Sie ein bestimmtes Trennzeichen (Bindestrich, Leerzeichen, Komma usw.) verwenden möchten.

Andernfalls können Sie einfach die descriptionEigenschaft verwenden, die eine Zeichenfolgendarstellung des Arrays zurückgibt:

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

Hinweis: Jedes Objekt, das das PrintableProtokoll implementiert , hat eine descriptionEigenschaft. Wenn Sie dieses Protokoll in Ihre eigenen Klassen / Strukturen übernehmen, machen Sie sie auch druckfreundlich

In Swift 3

• joinwird zum joinedBeispiel[nil, "1", "2"].flatMap({$0}).joined()
• joinWithSeparatorwird joined(separator:)(nur für Array of Strings verfügbar)

In Swift 4

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

Mit Swift 5 können Sie je nach Bedarf einen der folgenden Beispielcodes für Spielplätze auswählen, um Ihr Problem zu lösen.

Ein Array von Characters in ein Array Stringohne Trennzeichen verwandeln:

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

print(string)
// prints "John"

Ein Array von Strings in ein Array Stringohne Trennzeichen verwandeln:

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

print(string) // prints: "BobDanBryan"

Verwandeln eines Arrays von Strings in ein Array Stringmit 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 Strings in ein Array Stringmit einem Trennzeichen zwischen Zeichen:

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"

Verwandeln eines Arrays von Floats in ein Array Stringmit einem Trennzeichen zwischen Zahlen:

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 ab verwendet joinWithSeparator()anstelle von join():

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

joinWithSeparator ist als Erweiterung auf definiert 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: " ")

Da niemand erwähnt hat, reduzieren, hier ist es:

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

Im Sinne der funktionalen Programmierung 🤖

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 überspringt flatMap , compactMap die Nullwerte im Array und hängt die anderen Werte an, um eine verknüpfte Zeichenfolge zu erhalten.

Meins funktioniert auf NSMutableArray mit componentsJoinedByString

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 componentsJoinedByString (",") zu verwenden.

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

Wenn Sie leere Zeichenfolgen im Array entfernen möchten.

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

Wenn Sie auch keine Werte 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)")

Ergebnis wird >>> Mani Singh iOS Developer sein

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

Generell gibt es einen wichtigen Unterschied zwischen der String-Interpolation und dem PrintableProtokoll. Nur bestimmte Klassen entsprechen Printable. Jede Klasse kann irgendwie stringinterpoliert werden. Dies ist hilfreich beim Schreiben allgemeiner Funktionen. Sie müssen sich nicht auf PrintableKlassen beschränken.

Sie können jedes Objekt mit der Druckfunktion drucken

oder verwenden \(name) , um ein Objekt in eine Zeichenfolge 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]"

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

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

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

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

Wenn Sie eine String-Array-Liste haben, konvertieren Sie in Int

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

Sie erhalten einen Zeichenfolgenwert

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

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

Wenn Sie eine Frage stellen, die ungefähr so ​​lautet: tobeFormattedString = ["a", "b", "c"] Output = "abc"

String(tobeFormattedString)