¿Cómo convierto una matriz rápida en una cadena?

Sé cómo hacerlo programáticamente, pero estoy seguro de que hay una forma integrada ...

Todos los idiomas que he usado tienen algún tipo de representación textual predeterminada para una colección de objetos que escupirá cuando intentes concatenar la matriz con una cadena, o pasarla a una función print (), etc. ¿El lenguaje Swift de Apple tenemos una forma integrada de convertir fácilmente una matriz en una cadena, o ¿siempre tenemos que ser explícitos al encadenar una matriz?

Si la matriz contiene cadenas, puede usar el método String's join:

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

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

En Swift 2 :

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

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

Esto puede ser útil si desea utilizar un separador específico (hypen, blank, coma, etc.).

De lo contrario, simplemente puede usar la descriptionpropiedad, que devuelve una representación de cadena de la matriz:

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

Sugerencia: cualquier objeto que implemente el Printableprotocolo tiene undescription propiedad. Si adopta ese protocolo en sus propias clases / estructuras, también puede imprimirlas

En Swift 3

• joinse convierte joined, ejemplo[nil, "1", "2"].flatMap({$0}).joined()
• joinWithSeparatorse convierte joined(separator:)(solo disponible para Array of Strings)

En Swift 4

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

Con Swift 5, de acuerdo con sus necesidades, puede elegir uno de los siguientes códigos de muestra de Playground para resolver su problema.

Convirtiendo una matriz de Characters en un Stringsin separador:

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

print(string)
// prints "John"

Convirtiendo una matriz de Strings en un Stringsin separador:

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

print(string) // prints: "BobDanBryan"

Convertir una matriz de Strings en un Stringcon un separador entre palabras:

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

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

Convertir una matriz de Strings en un Stringcon un 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"

Convirtiendo una matriz de Floats en un Stringcon un 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"

Swift 2.0 Xcode 7.0 beta 6 utiliza joinWithSeparator()en adelante en lugar de join():

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

joinWithSeparator se define como una extensión en 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(" ")

En Swift 4

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

array.joined(separator: " ")

Como nadie ha mencionado reducir, aquí está:

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

En el espíritu de la programación funcional 🤖

Para cambiar una matriz de cadenas opcionales / no opcionales

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

Aquí flatMap , compactMap omite los valores nulos en la matriz y agrega los otros valores para dar una cadena unida.

La mía funciona en NSMutableArray con componentsJoinedByString

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

En Swift 2.2 puede que tenga que convertir su matriz a NSArray para usar componentsJoinedByString (",")

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

Si desea deshacerse de cadenas vacías en la matriz.

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

Si también desea filtrar valores nulos:

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

El resultado será >>> Mani Singh iOS Developer

El equivalente rápido de lo que estás describiendo es la interpolación de cadenas. Si está pensando en cosas como JavaScript "x" + array, el equivalente en Swift es "x\(array)".

Como nota general, existe una diferencia importante entre la interpolación de cadenas y el Printableprotocolo. Solo ciertas clases se ajustan a Printable. Cada clase puede ser interpolada en cadena de alguna manera. Eso es útil al escribir funciones genéricas. No tienes que limitarte a las Printableclases.

Puede imprimir cualquier objeto usando la función de impresión

o usar \(name) para convertir cualquier objeto en una cadena.

Ejemplo:

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

Crear extensión para un 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 separador puede ser una mala idea para algunos idiomas como el hebreo o el japonés. Prueba esto:

// 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 otros tipos de datos 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!)

si tiene una lista de matriz de cadenas, luego conviértala a Int

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

te dará un valor de cadena

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

Prueba esto:

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

Si tiene alguna pregunta como esta: tobeFormattedString = ["a", "b", "c"] Salida = "abc"

String(tobeFormattedString)