ios - bar - ¿Cómo convierto una matriz de Swift a una cadena?

uinavigationitem title color

Question

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

Cada idioma que he usado tiene algún tipo de representación textual predeterminada para una colección de objetos que escupirá cuando intente concatenar el Array con una cadena, o pasarlo a una función print (), etc. ¿Tiene una forma integrada de convertir fácilmente un Array en una Cadena, o siempre tenemos que ser explícitos al estrechar un array?

Answer 1

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

Answer 2

Con Swift 3, de acuerdo con sus necesidades, puede elegir uno de los siguientes bloques de código.

Convertir una matriz de Character en una String sin separador:

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

print(string)
// prints "John"

Convertir una matriz de String en una String sin separador:

let stringArray = ["Foo", "Bar", "Baz"]
let characterArray = stringArray.flatMap { String.CharacterView($0) }
//let characterArray = stringArray.flatMap { $0.characters } // also works
let string = String(characterArray)

print(string)
// prints "FooBarBaz"

Convertir una matriz de String en una String con un separador entre palabras:

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

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

Convertir una matriz de String en una String con un separador entre caracteres:

let stringArray = ["car", "bike", "boat"]
let stringArray2 = stringArray.flatMap { String.CharacterView($0) }.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 Float en una String con un separador entre números:

let floatArray = [12, 14.6, 35]
let stringArray = floatArray.flatMap { String($0) }
let string = stringArray.joined(separator: "-")

print(string)
// prints "12.0-14.6-35.0"

Answer 3

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

Answer 4

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

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

Answer 5

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

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

Answer 6

En Swift 4

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

array.joined(separator: " ")

Answer 7

La mina funciona en NSMutableArray con componentesJoinedByString

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

Answer 8

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

Answer 9

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.

Answer 10

Puedes imprimir cualquier objeto utilizando la función de impresión.

o use /(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]"

Answer 11

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

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

Si quieres filtrar valores nulos también:

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

Answer 12

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

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 usar un separador específico (hipo, espacio en blanco, coma, etc.).

De lo contrario, simplemente puede usar la propiedad de description , 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 protocolo de Printable tiene una propiedad de description . Si adopta ese protocolo en sus propias clases / estructuras, también los hace fáciles de imprimir

En Swift 3

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

En Swift 4

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

Answer 13

Si la pregunta es algo como esto: tobeFormattedString = ["a", "b", "c"] Salida = "abc"

String(tobeFormattedString)

Answer 14

Si tiene una lista de cadenas de cadenas, entonces convierta a Int

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

te dará valor de cadena

Answer 15

Swift 2.0 Xcode 7.0 beta 6 en adelante usa joinWithSeparator() 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
}

Answer 16

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

Answer 17

Swift 3

["I Love","Swift"].joined(separator:" ") // previously joinWithSeparator(" ")

Answer 18

let arrayTemp :[String] = ["Mani","Singh","iOS Developer"]
    let stringAfterCombining = arrayTemp.componentsJoinedByString(" ")
   print("Result will be >>>  /(stringAfterCombining)")

El resultado será >>> Mani Singh iOS Developer