Como converter uma matriz Swift em uma string?

Eu sei como fazê-lo programaticamente, mas tenho certeza de que há uma maneira integrada ...

Todo idioma que eu usei tem algum tipo de representação textual padrão para uma coleção de objetos que ele cuspirá quando você tentar concatenar o Array com uma string ou passá-lo para uma função print () etc. O idioma Swift da Apple tem uma maneira interna de transformar facilmente uma matriz em uma string ou sempre precisamos ser explícitos ao stringing uma matriz?

Se a matriz contiver seqüências de caracteres, você poderá usar o método String's join:

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

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

No Swift 2 :

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

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

Isso pode ser útil se você quiser usar um separador específico (hifen, espaço em branco, vírgula etc.).

Caso contrário, você pode simplesmente usar a descriptionpropriedade, que retorna uma representação de string da matriz:

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

Dica: qualquer objeto que implemente o Printableprotocolo possui uma descriptionpropriedade. Se você adotar esse protocolo em suas próprias classes / estruturas, também as tornará amigáveis ​​à impressão

Em Swift 3

• jointorna-se joined, exemplo[nil, "1", "2"].flatMap({$0}).joined()
• joinWithSeparatortorna-se joined(separator:)(disponível apenas para Array of Strings)

Em Swift 4

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

Com o Swift 5, de acordo com suas necessidades, você pode escolher um dos seguintes códigos de amostra do Playground para resolver seu problema.

Transformando uma matriz de Characters em uma Stringsem separador:

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

print(string)
// prints "John"

Transformando uma matriz de Strings em uma Stringsem separador:

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

print(string) // prints: "BobDanBryan"

Transformando uma matriz de Strings em a Stringcom um separador entre palavras:

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

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

Transformando uma matriz de Strings em um Stringcom um separador entre caracteres:

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"

Transformando uma matriz de Floats em a Stringcom um separador entre números:

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"

O Swift 2.0 Xcode 7.0 beta 6 em diante usa em joinWithSeparator()vez de join():

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

joinWithSeparator é definido como uma extensão em 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(" ")

Em Swift 4

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

array.joined(separator: " ")

Como ninguém mencionou reduzir, aqui está:

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

No espírito da programação funcional 🤖

Para alterar uma matriz de cadeias opcionais / não opcionais

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

Aqui flatMap , compactMap ignora os valores nulos na matriz e acrescenta os outros valores para fornecer uma sequência de caracteres unida.

O meu funciona no NSMutableArray com componentesJoinedByString

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

No Swift 2.2, pode ser necessário converter sua matriz no NSArray para usar componentsJoinedByString (",")

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

Se você deseja descartar cadeias vazias na matriz.

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

Se você deseja filtrar valores nulos também:

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

O resultado será >>> Mani Singh iOS Developer

O equivalente Swift ao que você está descrevendo é a interpolação de strings. Se você está pensando em coisas como JavaScript "x" + array, o equivalente no Swift é"x\(array)" .

Como uma observação geral, há uma diferença importante entre a interpolação de strings e o Printableprotocolo. Somente determinadas classes estão em conformidade Printable. Toda classe pode ser interpolada de alguma forma. Isso é útil ao escrever funções genéricas. Você não precisa se limitar às Printableaulas.

Você pode imprimir qualquer objeto usando a função de impressão

ou use \(name) para converter qualquer objeto em uma string.

Exemplo:

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

Crie uma extensão para 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
        }
    }
}

Um separador pode ser uma má ideia para alguns idiomas, como hebraico ou japonês. Tente o seguinte:

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

Para outros tipos de dados, respectivamente:

// 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 você tiver uma lista de matrizes de string, converta para Int

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

isso lhe dará um valor de string

para qualquer tipo de 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;
    }
}

Tente isto:

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

PARA 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 você pergunta é algo como isto: tobeFormattedString = ["a", "b", "c"] Output = "abc"

String(tobeFormattedString)