Swift Language
Cuerdas y personajes

Sintaxis

• String.characters // devuelve una matriz de los caracteres en la cadena
• String.characters.count // Devuelve el número de caracteres
• String.utf8 // A String.UTF8View, devuelve los puntos de caracteres UTF-8 en la cadena
• String.utf16 // A String.UTF16View, devuelve los puntos de caracteres UTF-16 en la cadena
• String.unicodeScalars // A String.UnicodeScalarView, devuelve los puntos de caracteres UTF-32 en la cadena
• String.isEmpty // Devuelve true si la cadena no contiene ningún texto
• String.hasPrefix (String) // Devuelve true si la cadena tiene un prefijo con el argumento
• String.hasSuffix (String) // Devuelve true si String tiene el sufijo del argumento
• String.startIndex // Devuelve el índice que corresponde al primer carácter de la cadena
• String.endIndex // Devuelve el índice que corresponde al punto después del último carácter en la cadena
• String.components (SeparadoBy: String) // Devuelve una matriz que contiene las subcadenas separadas por la cadena separadora dada
• String.append (Character) // Agrega el carácter (dado como argumento) a la cadena

Observaciones

Literales de cuerdas y personajes

Los literales de cadena en Swift están delimitados con comillas dobles ( " ):

let greeting = "Hello!"  // greeting's type is String

Los caracteres se pueden inicializar a partir de literales de cadena, siempre que el literal contenga solo un grupo de grafemas:

let chr: Character = "H" // valid
let chr2: Character = "😊" // valid
let chr3: Character = "abc" // invalid - multiple grapheme clusters

Interpolación de cuerdas

La interpolación de cadenas permite inyectar una expresión directamente en un literal de cadena. Esto se puede hacer con todos los tipos de valores, incluidas cadenas, enteros, números de punto flotante y más.

La sintaxis es una barra invertida seguida de paréntesis que envuelven el valor: \(value) . Cualquier expresión válida puede aparecer entre paréntesis, incluidas las llamadas a funciones.

let number = 5
let interpolatedNumber = "\(number)"  // string is "5"
let fortyTwo = "\(6 * 7)"             // string is "42"

let example = "This post has \(number) view\(number == 1 ? "" : "s")"
// It will output "This post has 5 views" for the above example.
// If the variable number had the value 1, it would output "This post has 1 view" instead.

Para los tipos personalizados, el comportamiento predeterminado de la interpolación de cadenas es que "\(myobj)" es equivalente a String(myobj) , la misma representación utilizada por print(myobj) . Puede personalizar este comportamiento implementando el protocolo CustomStringConvertible para su tipo.

Caracteres especiales

Ciertos caracteres requieren una secuencia de escape especial para usarlos en literales de cadena:

Ejemplo:

let message = "Then he said, \"I \u{1F496} you!\""

print(message) // Then he said, "I 💖 you!"

Cuerdas de concatenación

Concatene cadenas con el operador + para producir una nueva cadena:

let name = "John"
let surname = "Appleseed"
let fullName = name + " " + surname  // fullName is "John Appleseed"

Agregue a una cadena mutable usando el operador de asignación compuesto += , o usando un método:

let str2 = "there"
var instruction = "look over"
instruction += " " + str2  // instruction is now "look over there"

var instruction = "look over"
instruction.append(" " + str2)  // instruction is now "look over there"

Agregue un solo carácter a una cadena mutable:

var greeting: String = "Hello"
let exclamationMark: Character = "!"
greeting.append(exclamationMark) 
// produces a modified String (greeting) = "Hello!"

Agregar varios caracteres a una cadena mutable

var alphabet:String = "my ABCs: "
alphabet.append(contentsOf: (0x61...0x7A).map(UnicodeScalar.init)
                                         .map(Character.init) )
// produces a modified string (alphabet) = "my ABCs: abcdefghijklmnopqrstuvwxyz"

Unir una secuencia de cadenas para formar una nueva cadena utilizando joinWithSeparator(_:) :

let words = ["apple", "orange", "banana"]
let str = words.joinWithSeparator(" & ")

print(str)   // "apple & orange & banana"

Examina y compara cuerdas

Compruebe si una cadena está vacía:

if str.isEmpty {
    // do something if the string is empty
}

// If the string is empty, replace it with a fallback:
let result = str.isEmpty ? "fallback string" : str

Compruebe si dos cadenas son iguales (en el sentido de equivalencia canónica de Unicode ):

"abc" == "def"          // false
"abc" == "ABC"          // false
"abc" == "abc"          // true

// "LATIN SMALL LETTER A WITH ACUTE" == "LATIN SMALL LETTER A" + "COMBINING ACUTE ACCENT"
"\u{e1}" == "a\u{301}"  // true

Compruebe si una cadena comienza / termina con otra cadena:

"fortitude".hasPrefix("fort")      // true
"Swift Language".hasSuffix("age")  // true

Codificación y descomposición de cadenas

Una cadena Swift está hecha de puntos de código Unicode . Se puede descomponer y codificar de diferentes maneras.

let str = "ที่👌①!"

Cuerdas en descomposición

Los characters una cadena son agrupamientos de grafemas extendidos Unicode:

Array(str.characters)  // ["ที่", "👌", "①", "!"]

Los unicodeScalars son los puntos de código Unicode que forman una cadena (observe que ที่ es un grupo de grafemas, pero 3 puntos de código - 3607, 3637, 3656 - por lo que la longitud de la matriz resultante no es la misma que con los characters ):

str.unicodeScalars.map{ $0.value }  // [3607, 3637, 3656, 128076, 9312, 33]

Puede codificar y descomponer cadenas como UTF-8 (una secuencia de UInt8 s) o UTF-16 (una secuencia de UInt16 s):

Array(str.utf8)   // [224, 184, 151, 224, 184, 181, 224, 185, 136, 240, 159, 145, 140, 226, 145, 160, 33]
Array(str.utf16)  // [3607, 3637, 3656, 55357, 56396, 9312, 33]

Longitud de la cuerda y la iteración

Los characters una cadena, unicodeScalars , utf8 y utf16 son todos Collection s, por lo que puede obtener su count e iterar sobre ellos:

// NOTE: These operations are NOT necessarily fast/cheap! 

str.characters.count     // 4
str.unicodeScalars.count // 6
str.utf8.count           // 17
str.utf16.count          // 7

for c in str.characters { // ...
for u in str.unicodeScalars { // ...
for byte in str.utf8 { // ...
for byte in str.utf16 { // ...

Unicode

Estableciendo valores

Usando Unicode directamente

var str: String = "I want to visit 北京, Москва, मुंबई, القاهرة, and 서울시. 😊"
var character: Character = "🌍"

Usando valores hexadecimales

var str: String = "\u{61}\u{5927}\u{1F34E}\u{3C0}" // a大🍎π
var character: Character = "\u{65}\u{301}" // é = "e" + accent mark

Tenga en cuenta que el Character Swift puede estar compuesto por varios puntos de código Unicode, pero parece ser un solo carácter. Esto se llama un Clúster Grapheme Extendido.

Conversiones

Cuerda -> Hexagonal

// Accesses views of different Unicode encodings of `str`
str.utf8
str.utf16
str.unicodeScalars // UTF-32

Hexagonal -> Cuerda

let value0: UInt8 = 0x61
let value1: UInt16 = 0x5927
let value2: UInt32 = 0x1F34E

let string0 = String(UnicodeScalar(value0)) // a
let string1 = String(UnicodeScalar(value1)) // 大
let string2 = String(UnicodeScalar(value2)) // 🍎

// convert hex array to String
let myHexArray = [0x43, 0x61, 0x74, 0x203C, 0x1F431] // an Int array
var myString = ""
for hexValue in myHexArray {
    myString.append(UnicodeScalar(hexValue))
}
print(myString) // Cat‼🐱

Tenga en cuenta que para UTF-8 y UTF-16, la conversión no siempre es tan fácil porque cosas como emoji no pueden codificarse con un solo valor UTF-16. Se necesita una pareja sustituta.

Cuerdas de inversión

let aString = "This is a test string."

// first, reverse the String's characters 
let reversedCharacters = aString.characters.reverse()

// then convert back to a String with the String() initializer
let reversedString = String(reversedCharacters)

print(reversedString) // ".gnirts tset a si sihT"

let reversedCharacters = aString.characters.reversed()
let reversedString = String(reversedCharacters)

Cadenas mayúsculas y minúsculas

Para hacer todos los caracteres en una cadena mayúscula o minúscula:

let text = "AaBbCc"
let uppercase = text.uppercaseString // "AABBCC"
let lowercase = text.lowercaseString // "aabbcc"

let text = "AaBbCc"
let uppercase = text.uppercased() // "AABBCC"
let lowercase = text.lowercased() // "aabbcc"

Compruebe si la cadena contiene caracteres de un conjunto definido

Letras

let letters = CharacterSet.letters

let phrase = "Test case"
let range = phrase.rangeOfCharacter(from: letters)

// range will be nil if no letters is found
if let test = range {
   print("letters found")
}
else {
   print("letters not found")
}

let letters = NSCharacterSet.letterCharacterSet()

let phrase = "Test case"
let range = phrase.rangeOfCharacterFromSet(letters)

// range will be nil if no letters is found
if let test = range {
   print("letters found")
}
else {
  print("letters not found")
}

La nueva estructura CharacterSet que también está NSCharacterSet clase Objective-C NSCharacterSet define varios conjuntos predefinidos como:

• decimalDigits
• capitalizedLetters
• alphanumerics
• controlCharacters
• illegalCharacters
• Y más puede encontrar en la referencia NSCharacterSet .

También puedes definir tu propio conjunto de caracteres:

let phrase = "Test case"
let charset = CharacterSet(charactersIn: "t")

if let _ = phrase.rangeOfCharacter(from: charset, options: .caseInsensitive) {
   print("yes") 
}
else {
   print("no")
}

let charset = NSCharacterSet(charactersInString: "t")

if let _ = phrase.rangeOfCharacterFromSet(charset, options: .CaseInsensitiveSearch, range: nil) {
   print("yes")
}
else {
    print("no")
}

También puede incluir rango:

let phrase = "Test case"
let charset = CharacterSet(charactersIn: "t")

if let _ = phrase.rangeOfCharacter(from: charset, options: .caseInsensitive, range: phrase.startIndex..<phrase.endIndex)) {
   print("yes") 
}
else {
   print("no")
}

Contar las ocurrencias de un personaje en una cadena

Dada una String y un Character

let text = "Hello World"
let char: Character = "o"

Podemos contar el número de veces que el Character aparece en la String usando

let sensitiveCount = text.characters.filter { $0 == char }.count // case-sensitive
let insensitiveCount = text.lowercaseString.characters.filter { $0 == Character(String(char).lowercaseString) } // case-insensitive

Eliminar caracteres de una cadena no definida en Set

func removeCharactersNotInSetFromText(text: String, set: Set<Character>) -> String {
   return String(text.characters.filter { set.contains( $0) })
}

let text = "Swift 3.0 Come Out"
var chars = Set([Character]("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLKMNOPQRSTUVWXYZ".characters))
let newText = removeCharactersNotInSetFromText(text, set: chars) // "SwiftComeOut"

func removeCharactersNotInSetFromText(text: String, set: Set<Character>) -> String {
  return String(text.characters.filter { set.contains( $0) })
}

let text = "Swift 3.0 Come Out"
var chars = Set([Character]("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLKMNOPQRSTUVWXYZ".characters))
let newText = removeCharactersNotInSetFromText(text: text, set: chars)

Formato de cadenas

Ceros a la izquierda

let number: Int = 7
let str1 = String(format: "%03d", number) // 007
let str2 = String(format: "%05d", number) // 00007

Números despues de decimal

let number: Float = 3.14159
let str1 = String(format: "%.2f", number) // 3.14
let str2 = String(format: "%.4f", number) // 3.1416 (rounded)

Decimal a hexadecimal

let number: Int = 13627
let str1 = String(format: "%2X", number) // 353B
let str2 = String(format: "%2x", number) // 353b (notice the lowercase b)

Alternativamente, se podría usar un inicializador especializado que haga lo mismo:

let number: Int = 13627
let str1 = String(number, radix: 16, uppercase: true) //353B
let str2 = String(number, radix: 16) // 353b

Decimal a un número con radix arbitrario

let number: Int = 13627
let str1 = String(number, radix: 36) // aij

Radix es Int en [2, 36] .

Convertir una cadena Swift a un tipo de número

Int("123") // Returns 123 of Int type
Int("abcd") // Returns nil
Int("10") // Returns 10 of Int type
Int("10", radix: 2) // Returns 2 of Int type
Double("1.5") // Returns 1.5 of Double type
Double("abcd") // Returns nil

Tenga en cuenta que al hacer esto, se devuelve un valor Optional , que debe ser desempaquetado en consecuencia antes de ser utilizado.

Iteración de cuerdas

let string = "My fantastic string"
var index = string.startIndex

while index != string.endIndex {
    print(string[index])
    index = index.successor()
}

let string = "My fantastic string"
var currentIndex = string.startIndex

while currentIndex != string.endIndex {
    print(string[currentIndex])
    currentIndex = string.index(after: currentIndex)
}

Y, por ejemplo, si quieres ir por el otro lado:

var index:String.Index? = string.endIndex.predecessor()

while index != nil {
    print(string[index!])
    if index != string.startIndex {
        index = index.predecessor()
    }
    else {
        index = nil
    }
}

var currentIndex: String.Index? = string.index(before: string.endIndex)

while currentIndex != nil {
    print(string[currentIndex!])
    if currentIndex != string.startIndex {
        currentIndex = string.index(before: currentIndex!)
    }
    else {
        currentIndex = nil
    }
}

Tenga en cuenta que el Index es un tipo de objeto y no un Int . No puede acceder a un carácter de cadena de la siguiente manera:

let string = "My string"
string[2] // can't do this
string.characters[2] // and also can't do this

Pero puede obtener un índice específico de la siguiente manera:

index = string.startIndex.advanceBy(2)

currentIndex = string.index(string.startIndex, offsetBy: 2)

Y puede ir hacia atrás así:

index = string.endIndex.advancedBy(-2)

currentIndex = string.index(string.endIndex, offsetBy: -2)

Si puede exceder los límites de la cadena, o si desea especificar un límite, puede usar:

index = string.startIndex.advanceBy(20, limit: string.endIndex)

currentIndex = string.index(string.startIndex, offsetBy: 20, limitedBy: string.endIndex)

Alternativamente, uno solo puede iterar a través de los caracteres en una cadena, pero esto podría ser menos útil dependiendo del contexto:

for c in string.characters {
    print(c)
}

Eliminar WhiteSpace y NewLine iniciales y finales

let someString = "  Swift Language  \n"
let trimmedString = someString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())
// "Swift Language"

let trimmedWhiteSpace = someString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())
// "Swift Language  \n"

let trimmedNewLine = someString.stringByTrimmingCharactersInSet(NSCharacterSet.newlineCharacterSet())
// "  Swift Language  "

let someString = "  Swift Language  \n"

let trimmedString = someString.trimmingCharacters(in: .whitespacesAndNewlines)
// "Swift Language"

let trimmedWhiteSpace = someString.trimmingCharacters(in: .whitespaces)
// "Swift Language  \n"

let trimmedNewLine = someString.trimmingCharacters(in: .newlines)
// "  Swift Language  "

Nota: todos estos métodos pertenecen a la Foundation . Use la import Foundation si la Fundación ya no se ha importado a través de otras bibliotecas como Cocoa o UIKit.

Convertir cadena a / desde datos / NSData

Para convertir String ay desde Data / NSData necesitamos codificar esta cadena con una codificación específica. El más famoso es UTF-8 que es una representación de 8 bits de caracteres Unicode, adecuada para la transmisión o el almacenamiento mediante sistemas basados ​​en ASCII. Aquí está una lista de todas las String Encodings disponibles

String a Data / NSData

let data = string.data(using: .utf8)

let data = string.dataUsingEncoding(NSUTF8StringEncoding)

Data / NSData a String

let string = String(data: data, encoding: .utf8)

let string = String(data: data, encoding: NSUTF8StringEncoding)

Dividir una cadena en una matriz

En Swift, puedes separar fácilmente una Cadena en una matriz cortándola en un determinado carácter:

let startDate = "23:51"

let startDateAsArray = startDate.components(separatedBy: ":") // ["23", "51"]`

let startDate = "23:51"

let startArray = startDate.componentsSeparatedByString(":") // ["23", "51"]`

O cuando el separador no está presente:

let myText = "MyText"

let myTextArray = myText.components(separatedBy: " ") // myTextArray is ["MyText"]

let myText = "MyText"

let myTextArray = myText.componentsSeparatedByString(" ") // myTextArray is ["MyText"]