Swift Language
Chaînes et caractères

Syntaxe

• String.characters // Retourne un tableau des caractères de la chaîne
• String.characters.count // Retourne le nombre de caractères
• String.utf8 // Une String.UTF8View renvoie les points de caractère UTF-8 dans la chaîne.
• String.utf16 // Une String.UTF16View, renvoie les points de caractère UTF-16 dans la chaîne.
• String.unicodeScalars // Un String.UnicodeScalarView, renvoie les points de caractère UTF-32 dans la chaîne
• String.isEmpty // Renvoie true si la chaîne ne contient aucun texte
• String.hasPrefix (String) // Renvoie true si la chaîne est préfixée par l'argument
• String.hasSuffix (String) // Renvoie true si la chaîne est suffixée avec l'argument
• String.startIndex // Renvoie l'index correspondant au premier caractère de la chaîne
• String.endIndex // Retourne l'index qui correspond au spot après le dernier caractère de la chaîne
• String.components (sépare: String) // Retourne un tableau contenant les sous-chaînes séparées par la chaîne de séparation donnée
• String.append (Character) // Ajoute le caractère (donné en argument) à la chaîne

Remarques

Littérature et caractères

Les littéraux de chaîne dans Swift sont délimités par des guillemets ( " ):

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

Les caractères peuvent être initialisés à partir de littéraux de chaîne, à condition que le littéral ne contienne qu’un seul cluster de graphèmes:

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

Interpolation de chaîne

L'interpolation de chaînes permet d'injecter une expression directement dans un littéral de chaîne. Cela peut être fait avec tous les types de valeurs, y compris les chaînes, les entiers, les nombres à virgule flottante et plus encore.

La syntaxe est une barre oblique inverse suivie de parenthèses qui entourent la valeur: \(value) . Toute expression valide peut apparaître entre parenthèses, y compris les appels de fonction.

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.

Pour les types personnalisés, le comportement par défaut de l'interpolation de chaîne est que "\(myobj)" est équivalent à String(myobj) , la même représentation utilisée par print(myobj) . Vous pouvez personnaliser ce comportement en implémentant le protocole CustomStringConvertible pour votre type.

Caractères spéciaux

Certains caractères nécessitent une séquence d'échappement spéciale pour les utiliser dans les littéraux de chaîne:

Exemple:

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

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

Concaténer des chaînes

Concaténer des chaînes avec l'opérateur + pour produire une nouvelle chaîne:

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

Ajouter à une chaîne mutable à l'aide de l' opérateur d'attribution composé += ou en utilisant une méthode:

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"

Ajouter un seul caractère à une chaîne modifiable:

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

Ajouter plusieurs caractères à une chaîne modifiable

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

Joignez une séquence de chaînes pour former une nouvelle chaîne à l'aide de joinWithSeparator(_:) :

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

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

Examinez et comparez les chaînes

Vérifiez si une chaîne est vide:

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

Vérifiez si deux chaînes sont égales (au sens de l' équivalence canonique 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

Vérifiez si une chaîne commence / se termine par une autre chaîne:

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

Codage et décomposition de chaînes

Une chaîne Swift est constituée de points de code Unicode . Il peut être décomposé et encodé de différentes manières.

let str = "ที่👌①!"

Cordes de décomposition

Une chaîne de characters sont Unicode groupes de graphèmes étendus :

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

Les unicodeScalars sont les points de code Unicode qui constituent une chaîne (notez que ที่ est un groupe de graphèmes, mais que 3 points de code - 3607, 3637, 3656 - la longueur du tableau résultant est différente de celle des characters ):

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

Vous pouvez encoder et décomposer des chaînes en UTF-8 (une séquence d' UInt8 s) ou en UTF-16 (une séquence d' 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]

Longueur de la chaîne et itération

Une chaîne de characters , unicodeScalars , utf8 et utf16 sont tous Collection s, afin que vous puissiez obtenir leur count et itérer sur eux:

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

Réglage des valeurs

Utiliser Unicode directement

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

Utiliser des valeurs hexadécimales

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

Notez que le Character rapide peut être composé de plusieurs points de code Unicode, mais semble être un seul caractère. C'est ce qu'on appelle un cluster Grapheme étendu.

Conversions

String -> Hex

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

Hex -> String

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‼🐱

Notez que pour UTF-8 et UTF-16, la conversion n'est pas toujours aussi simple car les choses comme les emoji ne peuvent pas être encodées avec une seule valeur UTF-16. Il faut une paire de substitution.

Cordes d'inversion

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)

Chaînes majuscules et minuscules

Pour que tous les caractères d'une chaîne soient en majuscule ou en minuscule:

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"

Vérifier si la chaîne contient des caractères d'un ensemble défini

Des lettres

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 nouvelle structure CharacterSet également reliée à la classe Objective-C NSCharacterSet définit plusieurs ensembles prédéfinis comme NSCharacterSet :

• decimalDigits
• capitalizedLetters
• alphanumerics
• controlCharacters
• illegalCharacters
• et plus vous pouvez trouver dans la référence NSCharacterSet .

Vous pouvez également définir votre propre jeu de caractères:

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

Vous pouvez également inclure la plage:

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

Compter les occurrences d'un personnage dans une chaîne

Étant donné une String et un Character

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

Nous pouvons compter le nombre de fois que le Character apparaît dans la String utilisant

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

Supprimer des caractères d'une chaîne non définie dans 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)

Chaînes de formatage

Zéros de tête

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

Nombres après décimal

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

Décimal à hexadécimal

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

On peut aussi utiliser un initialiseur spécialisé qui fait la même chose:

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

Décimal à un nombre avec une base arbitraire

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

Radix est Int dans [2, 36] .

Conversion d'une chaîne Swift en un type numérique

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

Notez que cela retourne une valeur Optional , qui doit être déballée en conséquence avant d'être utilisée.

Itération de chaîne

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

Et, par exemple, si vous voulez aller dans l'autre sens:

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

Remarque: Index est un type d'objet, et non un Int . Vous ne pouvez pas accéder à un caractère de chaîne comme suit:

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

Mais vous pouvez obtenir un index spécifique comme suit:

index = string.startIndex.advanceBy(2)

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

Et peut revenir en arrière comme ceci:

index = string.endIndex.advancedBy(-2)

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

Si vous pouvez dépasser les limites de la chaîne, ou si vous souhaitez spécifier une limite, vous pouvez utiliser:

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

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

Alternativement, on peut simplement parcourir les caractères d'une chaîne, mais cela peut être moins utile selon le contexte:

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

Supprimer les WhiteSpace et NewLine de début et de fin

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  "

Note: toutes ces méthodes appartiennent à Foundation . Utilisez import Foundation si Foundation n'est pas déjà importé via d'autres bibliothèques comme Cocoa ou UIKit.

Convertir une chaîne depuis et vers Data / NSData

Pour convertir une chaîne vers et depuis Data / NSData, nous devons encoder cette chaîne avec un codage spécifique. Le plus connu est UTF-8 une représentation à 8 bits de caractères Unicode, adaptée à la transmission ou au stockage par des systèmes ASCII. Voici une liste de tous les String Encodings disponibles

String de Data / NSData

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

let data = string.dataUsingEncoding(NSUTF8StringEncoding)

Data / NSData en String

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

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

Fractionnement d'une chaîne en un tableau

Dans Swift, vous pouvez facilement séparer une chaîne en un tableau en le découpant à un certain caractère:

let startDate = "23:51"

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

let startDate = "23:51"

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

Ou quand le séparateur n'est pas présent:

let myText = "MyText"

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

let myText = "MyText"

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