Chaînes et caractères

Chaînes littérales, le type String

let someString = "Une valeur littérale de chaîne"

Swift déduit un type String pour la constante someString sans qu'il ne soit précisé. On dit qu'il s'agit d'un type implicite.

let multilineString = """
Une autre chaîne ou String
"""
// Utilisez les triples guillemets pour une chaîne sur plusieurs lignes

Si vous souhaitez utiliser des sauts de lignes pour rendre votre code source plus facile à lire, mais que vous ne voulez pas que les sauts de lignes fassent partie de la valeur de la chaîne, écrivez une barre oblique inverse \ à la fin de ces lignes :

let softWrappedQuotation = """
Être ou ne pas être \
Hamlet, Acte III, Scène 1
"""

Caractères spéciaux

Utilisez le caractère échappatoire \ pour afficher un symbole dans une chaîne de caractères.

let motSage = "\"L'imagination est plus importante que la connaissance\" - Einstein"
// "L'imagination est plus importante que la connaissance" - Einstein
// Le caractère échappatoire \ permet d'afficher les guillemets

let dollarSign = "\u{24}"        // $,  Unicode scalar U+0024
let blackHeart = "\u{2665}"      // ♥,  Unicode scalar U+2665

Initialisation d'une chaîne vide

var emptyString = ""               // empty string literal
var anotherEmptyString = String()  // initializer syntax
// Les deux String sont vide et équivalent

Vérifiez si une valeur String est vide en vérifiant sa propriété booléenne isEmpty

if emptyString.isEmpty {
    print("Le String est vide")
}
// Prints "Le String est vide"

Mutabilité

var variableString = "Le cheval"
variableString += " et le chariot"
// variableString a pour valeur "Le cheval et le chariot"

let constantString = "Un chat"
constantString += " et un chien"
// Compile-time error - Une constante ne peut être modifiée

Le type Caractère

let exclamationMark: Character = "!"

Vous pouvez accéder aux valeurs individuelles de type Character pour un String en itérant cette chaîne avec une boucle for- in :

for character in "Doogy"
    print(character)
}
// D, o, o, g, y

Les valeurs String peuvent être construites en passant un tableau de valeurs de Character comme argument à son initialiseur :

let catCharacters: [Character] = ["C", "h", "a", "t", "!"]
let catString = String(catCharacters)
print(catString)
// Prints "Chat!"

Concaténation de chaînes et de caractères

let string1 = "Bonjour"
let string2 = " à tous"
var welcome = string1 + string2
// welcome a pour valeur : "Bonjour à tous"

var instruction = "Bonne année"
instruction += string2
// instruction a pour valeur "Bonne année à tous"

let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// On ajoute le caractère ! à la fin du String
// welcome a pour valeur "Bonjour à tous!"

Interpolation de chaînes de caractères

let multiplier = 3
let message = "\(multiplier) fois 2.5 font \(Double(multiplier) * 2.5)"
// message a pour valeur : "3 fois 2.5 font 7.5"

Dans l'exemple ci-dessus, la valeur de multiplier est insérée dans une chaîne littérale par l'interpolation \(multiplier).

On peut utiliser des délimiteurs de chaînes étendus pour créer des chaînes contenant des caractères qui seraient traités normalement et non comme une interpolation de chaînes à l'aide du symbole #.

print(#"Écrivez une chaîne interpolée dans Swift en utilisant \(multiplier)."#)
// Prints "Écrivez une chaîne interpolée dans Swift en utilisant \(multiplier)."

La norme Unicode

Unicode est une norme internationale pour l'encodage, la représentation et le traitement de texte dans différents systèmes d'écriture. Il permet de représenter n'importe quel caractère de n'importe quelle langue dans une forme standardisée, et de lire et écrire ces caractères vers et depuis une source externe telle qu'un fichier texte ou une page Web.

let eAcute: Character = "\u{E9}"    
// Le caractère : é

let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
// regionalIndicatorForUS a pour valeur : 🇺🇸

La méthode Count

La méthode Count permet de compter le nombre de caractères, espaces compris, contenus dans une chaîne.

let menagerie = "Chat, Chien, Poule, Vache"
print("menagerie a \(unusualMenagerie.count) caractères")
// Cela va afficher : "menagerie a 25 caractères"

Accès et modification de chaîne

Vous accédez et modifiez une chaîne via ses méthodes et propriétés, ou en utilisant la syntaxe d'indice.

Chaque valeur String est associée a un type d'index, String.Index, qui correspond à la position de chaque Character (type) dans la chaîne.

Utilisez la propriété startIndex pour accéder à la position du premier Character d'un String. La propriété endIndex est la position après le dernier caractère dans un String. Si un String est vide startIndex et endIndex sont égaux.

Vous accédez aux index avant et après un index donné à l'aide des méthodes index(before:) et index(after:) d'un String. Pour accéder à un index plus éloigné de l'index donné, vous pouvez utiliser la méthode index(_:offsetBy:) au lieu d'appeler l'une de ces méthodes plusieurs fois.

let greeting = "Guten Tag!"
greeting[greeting.startIndex]   // G
greeting[greeting.index(before: greeting.endIndex)]   // !
greeting[greeting.index(after: greeting.startIndex)]   // u
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index]   // a

Utilisez la propriété indice pour accéder à tous les index de caractères individuels dans une chaîne :

for index in greeting.indices {
    print("\(greeting[index]) ", terminator: "")
}
// Cela va afficher :  "G u t e n   T a g ! "

Insertion et retrait

Pour insérer un seul caractère dans une chaîne à un index spécifié, utilisez la méthode insert(_:at:). Pour insérer le contenu d'une autre chaîne à un index spécifié, utilisez la méthode insert(contentsOf:at:).

var welcome = "Bonjour"
welcome.insert("!", at: welcome.endIndex)
// welcome a pour valeur : "Bonjour!"

welcome.insert(contentsOf: " à tous", at: welcome.index(before: welcome.endIndex))
// welcome a pour valeur : "Bonjour à tous!"

Pour supprimer un seul caractère d'une chaîne à un index spécifié, utilisez la méthode remove(at:) et pour supprimer une sous-chaîne à une plage spécifiée, utilisez la méthode removeSubrange(_:) :

welcome.remove(at: welcome.index(before: welcome.endIndex))
// welcome a pour valeur "Bonjour à tous"
// On a supprimé le dernier caractère (!)

let range = welcome.index(welcome.endIndex, offsetBy: -7)..<welcome.endIndex
welcome.removeSubrange(range)
// welcome a pour valeur "Bonjour"

Sous-chaîne

Lorsque vous obtenez une sous-chaîne à partir d'une chaîne (par exemple, en utilisant un indice ou une méthode comme prefix(_:)), le résultat est une instance de Substring, et pas une autre chaîne.

Les sous-chaînes dans Swift ont pour la plupart les mêmes méthodes que les chaînes, ce qui signifie que vous pouvez travailler avec des sous-chaînes de la même manière que vous travaillez avec des chaînes.

Cependant, contrairement aux chaînes, vous n'utilisez des sous-chaînes que pendant une courte période lors de l'exécution d'actions sur une chaîne. Lorsque vous êtes prêt à stocker le résultat plus longtemps, vous convertissez la sous-chaîne en une instance de String.

let greeting = "Hello, world!"
let index = greeting.firstIndex(of: ",") ?? greeting.endIndex
let beginning = greeting[..<index]
// beginning a pour valeur : "Hello"

let newString = String(beginning)
// Convertissez le résultat en une chaîne pour un stockage à long terme.

Comme mentionné ci-dessus, les sous-chaînes ne sont pas adaptées au stockage à long terme, car elles réutilisent le stockage de la chaîne d'origine, la chaîne d'origine entière doit être conservée en mémoire tant que l'une de ses sous-chaînes est utilisée.

Dans l'exemple ci-dessus, greeting est une chaîne, ce qui signifie qu'elle a une région de mémoire où les caractères qui composent la chaîne sont stockés. Pour beginning, il s'agit d'une sous-chaîne de greeting, il réutilise la mémoire que greeting utilise. En revanche, newString est une chaîne : lorsqu'elle est créée à partir de la sous-chaîne, elle possède son propre stockage.

Comparaison de chaînes

Swift propose trois façons de comparer les valeurs textuelles : égalité de chaînes et de caractères, égalité de préfixes et égalité de suffixes.

Egalité de chaînes et de caractères

L'égalité de chaînes et de caractères est vérifiée avec l'opérateur "égal à" == et l'opérateur "différent de" !=

let quotation = "Voulez-vous un café ?"
let sameQuotation = "Voulez-vous un café ?"
if quotation == sameQuotation {
    print("Ces deux chaînes sont considérées comme égales")
}
// Cela va afficher : "Ces deux chaînes sont considérées comme égales"

Égalité des préfixes et des suffixes

Pour vérifier si une chaîne a un préfixe ou un suffixe de chaîne particulier, appelez les méthodes hasPrefix(_:) et de la chaîne hasSuffix(_:), qui prennent toutes deux un seul argument de type String et renvoient une valeur booléenne.

let romeoAndJuliet = [
    "Acte 1 Scène 1 : Vérone, Une place publique",
    "Acte 1 Scène 2 : Le manoir de Capulet",
    "Acte 1 Scène 3 : Une chambre dans le manoir de Capulet",
    "Acte 1 Scène 4 : Une rue devant le manoir de Capulet",
    "Acte 1 Scène 5 : La Grande Salle du manoir de Capulet",
    "Acte 2 Scène 1 : Devant le manoir de Capulet",
    "Acte 2 Scène 2 : Le verger de Capulet",
    "Acte 2 Scène 3 : À l'extérieur de la cellule du frère Laurent",
    "Acte 2 Scène 4 : Une rue de Vérone",
    "Acte 2 Scène 5 : Le manoir de Capulet",
    "Acte 2 Scène 6 : Cellule du frère Laurent"
]

var act1SceneCount = 0
for scene in romeoAndJuliet {
    if scene.hasPrefix("Acte 1 ") {
        act1SceneCount += 1
    }
}
print("Il y a \(act1SceneCount) scène dans l'Acte 1")
// Cela va afficher "Il y a 5 scène dans l'Acte 1"

var mansionCount = 0
var cellCount = 0
for scene in romeoAndJuliet {
    if scene.hasSuffix("Le manoir de Capulet") {
        mansionCount += 1
    } else if scene.hasSuffix("Cellule du frère Laurent") {
        cellCount += 1
    }
}
print("\(mansionCount) scènes de manoir; \(cellCount) scènes de cellule")
// Cela va afficher "6 scènes de manoir; 2 scènes de cellule"