ios - bar - ¿Cómo convierto una matriz de Swift a una cadena?
uinavigationitem title color (18)
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?
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
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"
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
}
}
}
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 .
En Swift 2.2 es posible que tenga que convertir su matriz a NSArray para usar componentsJoinedByString (",")
let stringWithCommas = (yourArray as NSArray).componentsJoinedByString(",")
En Swift 4
let array:[String] = ["Apple", "Pear ","Orange"]
array.joined(separator: " ")
La mina funciona en NSMutableArray con componentesJoinedByString
var array = ["1", "2", "3"]
let stringRepresentation = array.componentsJoinedByString("-") // "1-2-3"
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
}
}
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.
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]"
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: "-")
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
-
joinsejoined, ejemplo[nil, "1", "2"].flatMap({$0}).joined() -
joinWithSeparatorsejoined(separator:)(solo disponible para Array of Strings)
En Swift 4
var array = ["1", "2", "3"]
array.joined(separator:"-")
Si la pregunta es algo como esto: tobeFormattedString = ["a", "b", "c"] Salida = "abc"
String(tobeFormattedString)
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
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
}
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!)
Swift 3
["I Love","Swift"].joined(separator:" ") // previously joinWithSeparator(" ")
let arrayTemp :[String] = ["Mani","Singh","iOS Developer"]
let stringAfterCombining = arrayTemp.componentsJoinedByString(" ")
print("Result will be >>> /(stringAfterCombining)")
El resultado será >>> Mani Singh iOS Developer