Comment convertir un tableau Swift en chaîne?

Je sais comment le faire par programmation, mais je suis sûr qu'il existe une méthode intégrée ...

Chaque langue que j'ai utilisée a une sorte de représentation textuelle par défaut pour une collection d'objets qu'elle crache lorsque vous essayez de concaténer le tableau avec une chaîne, ou de la passer à une fonction print (), etc. Est-ce que le langage Swift d'Apple avoir un moyen intégré de transformer facilement un tableau en chaîne, ou devons-nous toujours être explicites lors de la chaîne d'un tableau?

Si le tableau contient des chaînes, vous pouvez utiliser la Stringde » joinméthode:

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

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

Dans Swift 2 :

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

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

Cela peut être utile si vous souhaitez utiliser un séparateur spécifique (hypen, vide, virgule, etc.).

Sinon, vous pouvez simplement utiliser la descriptionpropriété, qui renvoie une représentation sous forme de chaîne du tableau:

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

Astuce: tout objet implémentant le Printableprotocole a undescription propriété. Si vous adoptez ce protocole dans vos propres classes / structures, vous les rendez également imprimables

Dans Swift 3

• joindevient joined, exemple[nil, "1", "2"].flatMap({$0}).joined()
• joinWithSeparatordevient joined(separator:)(uniquement disponible pour Array of Strings)

Dans Swift 4

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

Avec Swift 5, selon vos besoins, vous pouvez choisir l'un des exemples de codes Playground suivants afin de résoudre votre problème.

Transformer un tableau de Characters en un Stringsans séparateur:

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

print(string)
// prints "John"

Transformer un tableau de Strings en un Stringsans séparateur:

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

print(string) // prints: "BobDanBryan"

Transformer un tableau de Strings en un Stringavec un séparateur entre les mots:

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

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

Transformer un tableau de Strings en un Stringavec un séparateur entre les caractères:

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"

Transformer un tableau de Floats en un Stringavec un séparateur entre les nombres:

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 bêta 6 utilise à la joinWithSeparator()place de join():

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

joinWithSeparator est défini comme une extension sur 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(" ")

Dans Swift 4

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

array.joined(separator: " ")

Puisque personne n'a mentionné réduire, voici:

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

Dans l'esprit de la programmation fonctionnelle 🤖

Pour modifier un tableau de chaînes facultatives / non facultatives

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

Ici flatMap , compactMap ignore les valeurs nulles dans le tableau et ajoute les autres valeurs pour donner une chaîne jointe.

Le mien fonctionne sur NSMutableArray avec componentsJoinedByString

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

Dans Swift 2.2, vous devrez peut-être convertir votre tableau en NSArray pour utiliser componentsJoinedByString (",")

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

Si vous souhaitez abandonner les chaînes vides dans le tableau.

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

Si vous souhaitez également filtrer les valeurs nulles:

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

Le résultat sera >>> Mani Singh Développeur iOS

L'équivalent Swift de ce que vous décrivez est l'interpolation de chaînes. Si vous pensez à des choses comme JavaScript "x" + array, l'équivalent dans Swift est"x\(array)" .

En règle générale, il existe une différence importante entre l'interpolation de chaînes et le Printableprotocole. Seules certaines classes sont conformes Printable. Chaque classe peut être interpolée en quelque sorte. Cela est utile lors de l'écriture de fonctions génériques. Vous n'avez pas à vous limiter aux Printablecours.

Vous pouvez imprimer n'importe quel objet à l'aide de la fonction d'impression

ou utilisez \(name)pour convertir n'importe quel objet en chaîne.

Exemple:

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

Créer une extension pour 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 séparateur peut être une mauvaise idée pour certaines langues comme l'hébreu ou le japonais. Essaye ça:

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

Pour les autres types de données respectivement:

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

si vous avez une liste de tableaux de chaînes, convertissez-la en Int

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

cela vous donnera une valeur de chaîne

pour tout type d'élément

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

Essaye ça:

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

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

Si vous vous demandez quelque chose comme ceci: tobeFormattedString = ["a", "b", "c"] Output = "abc"

String(tobeFormattedString)