Comment puis-je convertir rapidement un Tableau à une Chaîne de caractères?

Si le tableau contient des chaînes, vous pouvez utiliser le String's join mé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 voulez utiliser un séparateur (tiret, vide, virgule, etc).

Sinon, vous pouvez simplement utiliser la description propriété, qui renvoie une représentation sous forme de chaîne de la matrice:

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

Conseil: n'importe quel objet la mise en œuvre de la Printable protocole a une description de la propriété. Si vous adoptez ce protocole dans vos propres classes/struct vous rendre imprimable, ainsi

Dans Swift 3

• join devient joined, exemple [nil, "1", "2"].flatMap({$0}).joined()
• joinWithSeparator devient joined(separator:) (disponible uniquement pour Tableau de Chaînes de caractères)

Dans Swift 4

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

Swift 2.0 Xcode 7.0 beta 6 à partir de utilise joinWithSeparator() au lieu 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
}

Dans Swift 4

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

array.joined(separator: " ")

Pour modifier un tableau d'Option/Non Optionnel Chaînes

//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 le néant des valeurs du tableau et ajoute les autres valeurs de donner un joint de chaîne.

Dans Swift 2.2 vous pouvez avoir à jeter votre tableau de NSArray à utiliser componentsJoinedByString(",")

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

Si vous voulez le fossé des chaînes vides dans le tableau.

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

Si vous souhaitez filtrer néant valeurs ainsi:

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

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

ou de l'utilisation \(name) de convertir n'importe quel objet à une 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]"

Séparateur peut être une mauvaise idée pour certaines langues comme l'hébreu ou le Japonais.
Essayez ceci:

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

pour n'importe quel type d'Élément de

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

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