Salut, habrozhiteli! Le langage rapide est jeune, il grandit, se développe et change, bien que les approches de base de la programmation et du développement soient déjà formées. Dans la nouvelle cinquième édition du livre, la première partie du livre a été complètement révisée, ce qui rend la connaissance de la langue Swift plus confortable, et le texte entier est mis à jour conformément aux capacités de Swift 5. Au cours d'une communication longue et fructueuse avec les lecteurs, de nombreuses idées sont apparues, grâce auxquelles la nouvelle édition est devenue des supports pédagogiques encore plus utiles et riches. Maintenant, vous apprendrez non seulement Swift, mais vous obtiendrez également des informations initiales sur les principes de développement d'applications à part entière. Le monde de Swift est en constante évolution, les gens avec un stock important de connaissances et d'expérience n'existent pas encore en raison de l'âge de la langue, vous pouvez donc devenir l'un des premiers spécialistes.
Extrait. Chapitre 6. Tuples
Vous n'avez peut-être jamais rencontré un concept tel que les tuples en programmation, cependant, c'est l'une des fonctionnalités très utiles disponibles dans Swift. Les tuples, par exemple, peuvent être utilisés pour travailler avec des coordonnées. D'accord, il est beaucoup plus pratique d'utiliser une construction (x, y, z) écrite dans une variable que de créer une variable distincte pour chaque axe de coordonnées.
6.1. Bases du tuple
Un tuple est un objet qui regroupe des valeurs de différents types au sein d'une même valeur composite.
Les tuples sont le moyen le plus simple pour Swift de combiner des valeurs de types arbitraires. Chaque valeur individuelle dans le tuple peut avoir son propre type de données, qui ne dépend d'aucune façon des autres.
Littéral du cortège
Un tuple peut être créé à l'aide du
littéral tuple .
Syntaxe
(_1, _2, ..., _N)
• value: Any - la valeur suivante d'un type de données arbitraire, incluse dans le tuple.
Le littéral de tuple renvoie la valeur qui y est définie en tant que tuple. Un littéral est entouré de parenthèses et se compose d'un ensemble de valeurs indépendantes, séparées par des virgules. Le nombre d'éléments peut être arbitraire, mais il n'est pas recommandé d'en utiliser plus de sept.
REMARQUE
Plus loin dans le texte, il y aura un grand nombre de blocs de syntaxe. Ils décrivent comment les constructions en question peuvent être utilisées dans des programmes réels. Avant de procéder à ces blocs, il est nécessaire de décrire la structure de ce bloc, ainsi que les éléments utilisés.
La première ligne déterminera toujours directement la syntaxe elle-même qui décrit l'utilisation de la construction dans le code du programme. Dans ce cas, des éléments conditionnels peuvent être utilisés (par exemple, valeur_1, valeur_2 et valeur_N dans la syntaxe ci-dessus). Habituellement, ils sont écrits sous forme de texte pour comprendre leur objectif.
Des descriptions détaillées des éléments conditionnels peuvent suivre. Dans certains cas, les éléments peuvent être regroupés (comme dans la syntaxe ci-dessus, où au lieu des éléments valeur_1, valeur_2, etc., une valeur d'élément est décrite, dont les exigences s'appliquent à tous les éléments portant un nom donné).
Après le nom de l'élément conditionnel, son type de données peut être indiqué. De plus, si une valeur spécifique d'un certain type (par exemple, chaîne, numérique, logique, etc.) doit être utilisée comme élément, alors le type est séparé par deux points (:). Si, toutefois, une expression peut être utilisée comme élément (par exemple, a + b ou r> 100), le type sera indiqué après le tiret et le crochet à angle droit représentant la flèche (->). Il peut être défini comme un (par exemple, Int) et plusieurs types de données (par exemple, Int, String).
La syntaxe ci-dessus utilise Any comme pointeur vers un type de données. N'importe quel type de données. Au cours de l'apprentissage, vous rencontrerez de plus en plus de types qui peuvent être spécifiés dans ce bloc de syntaxe.
Une description détaillée de la syntaxe, ainsi qu'un exemple de son utilisation, peuvent suivre.
Je vous conseille de mettre cette page en signet afin que si nécessaire
revenez toujours ici.
Un tuple est stocké dans des variables et des constantes de la même manière que les valeurs des types de données fondamentaux.
Syntaxe
let = (_1, _2, ..., _N) var = (_1, _2, ..., _N)
Déclarer une variable et une constante et l'initialiser avec un littéral de tuple composé de N éléments comme valeur. Pour écrire un tuple dans une variable, vous devez utiliser l'instruction var et pour écrire dans une constante, vous devez utiliser l'instruction let.
Prenons l'exemple suivant. Nous déclarons une constante et l'initialisons avec un tuple composé de trois éléments de type: Int, String et Bool (Listing 6.1).
Listing 6.1
let myProgramStatus = (200, "In Work", true) myProgramStatus
Dans cet exemple, myProgramStatus est une constante contenant un tuple comme valeur qui décrit l'état d'un certain programme et se compose de trois éléments:
- 200 - entier de type Int, code d'état du programme;
- «In work» - une chaîne littérale de type String, une description textuelle de l'état du programme;
- true - une valeur logique de type Bool, la possibilité de continuer le fonctionnement du programme.
Ce tuple regroupe les valeurs de trois types de données différents au sein d'une seule constante initialisée.
Type de données de tuple
Mais si un tuple regroupe les valeurs de divers types de données en un seul, alors quel est le type de données du tuple lui-même et le paramètre qui stocke sa valeur?
Un type de données tuple est une séquence fixe et ordonnée de noms de type de données pour les éléments tuple.
Syntaxe
(____1, ____2, ..., ____N)
Le type de données est placé entre parenthèses et les noms des types d'élément sont séparés par des virgules. L'ordre des noms de type doit nécessairement correspondre à l'ordre des éléments dans le tuple.
Exemple
(Int, Int, Double)
Le type de données du tuple myProgramStatus du Listing 6.1 est (Int, String, Bool). Le type de données est implicitement défini, car il est automatiquement déterminé en fonction des éléments du tuple. Étant donné que l'ordre de spécification des types de données doit correspondre à l'ordre des éléments dans le tuple, le type (Bool, String, Int) est différent de (Int, String, Bool).
Le listing 6.2 compare les types de données des différents tuples.
Listing 6.2
var tuple1 = (200, "In Work", true) var tuple2 = (true, "On Work", 200) print( type(of:tuple1) == type(of:tuple2) )
La console
false
Pour comparer les types de données des tuples, les valeurs renvoyées par le type de fonction globale (de :), qui détermine le type de l'objet qui lui est transmis, sont utilisées.
Supposons que dans le tuple myProgramStatus, le premier élément doit être une valeur flottante au lieu d'un entier. Dans ce cas, vous pouvez déterminer explicitement le type de données du tuple (deux points après le nom du paramètre) (Listing 6.3).
Listing 6.3
Vous n'êtes pas limité à un nombre spécifique d'éléments de tuple. Un tuple peut contenir autant d'éléments que nécessaire (mais n'oubliez pas qu'il n'est pas recommandé d'utiliser plus de sept éléments). Le listing 6.4 montre un exemple de création d'un tuple de quatre éléments du même type. Il utilise un alias du type de données Int, ce qui n'est pas interdit.
Listing 6.4
6.2. Interaction avec les éléments de tuple
Un tuple est destiné non seulement à définir et à stocker un certain ensemble de valeurs, mais également à interagir avec ces valeurs. Dans cette section, nous verrons comment interagir avec les valeurs des éléments de tuple.
Initialisation des valeurs aux paramètres
Vous pouvez déclarer de nouveaux paramètres avec une seule expression et initialiser les valeurs de tous les éléments du tuple qu'ils contiennent. Pour ce faire, après le mot clé var (ou laissez, si vous déclarez des constantes) entre crochets et une virgule, vous devez spécifier les noms des nouveaux paramètres, et après l'opérateur d'initialisation, passer le tuple. Notez que le nombre de paramètres déclarés doit correspondre au nombre d'éléments de tuple (Listing 6.5).
Listing 6.5
Console:
— 200 — In Work — true
En utilisant cette syntaxe, vous pouvez facilement initialiser des valeurs arbitraires à plusieurs paramètres à la fois. Pour ce faire, à droite de l'expression, après l'opérateur d'initialisation, il faut passer non pas le paramètre contenant le tuple, mais le littéral du tuple (Listing 6.6).
Listing 6.6
var (myName, myAge) = ("", 140)
Console:
, 140
Les variables myName et myAge sont initialisées avec les valeurs correspondantes des éléments tuple (Troll, 140). En utilisant cette syntaxe, vous pouvez ignorer les éléments de tuple arbitraires. Pour ce faire, vous devez spécifier le caractère de soulignement comme nom de la variable correspondant à l'élément à ignorer (Listing 6.7).
Listing 6.7
var (statusCode, _, _) = myProgramStatus
Par conséquent, la valeur du premier élément du tuple, myProgramStatus, est écrite dans la variable statusCode. Les autres valeurs seront ignorées.
REMARQUE
Le trait de soulignement dans Swift indique ignorer le paramètre. Ce n'est pas le seul exemple où il peut être utilisé. À l'avenir, lorsque vous étudierez le contenu du livre, vous le rencontrerez plus d'une fois.
Accéder aux éléments de tuple via des index
Chaque élément du tuple, en plus de la valeur, contient un index entier qui peut être utilisé pour accéder à cet élément. Les index sont toujours classés dans l'ordre, à partir de zéro. Ainsi, dans un tuple de N éléments, l'indice du premier élément sera 0, et le dernier est accessible à l'aide de l'indice N-1.
Lors de l'accès à un seul élément, l'index est indiqué par le point après le nom du paramètre dans lequel le tuple est stocké. Le Listing 6.8 montre un exemple d'accès aux éléments individuels d'un tuple.
Listing 6.8
Console:
— 200 — In Work — true
Accéder aux éléments de tuple via des noms
En plus de l'index, chaque élément du tuple peut recevoir un nom unique. Les noms d'éléments ne sont pas obligatoires et ne sont utilisés que pour la commodité de l'utilisation de tuples. Des noms peuvent être donnés à tout le monde et à des parties d'éléments. Le nom de l'élément peut être défini à la fois dans le littéral de tuple et en définissant explicitement son type.
Le Listing 6.9 montre un exemple de détermination des noms d'éléments de tuple via un littéral.
Listing 6.9
let statusTuple = (statusCode: 200, statusText: "In Work", statusConnect: true)
Les noms d'éléments spécifiés peuvent être utilisés pour obtenir les valeurs de ces éléments. Dans ce cas, la même syntaxe est utilisée que lors de l'accès via des index, lorsque l'index a été spécifié via le point après le nom du paramètre. La définition de noms ne vous empêche pas d'utiliser des index. Les index d'un tuple peuvent toujours être utilisés.
Le listing 6.10 montre comment les noms d'élément sont utilisés conjointement avec les index.
Listing 6.10
Console:
— 200 — In Work — true
L'accès aux éléments à l'aide de noms est plus pratique et visuel que l'accès via des index.
Comme mentionné précédemment, les noms d'élément peuvent être spécifiés non seulement dans le littéral de tuple, mais également lors de la détermination explicite du type de données. Le listing 6.11 montre l'exemple correspondant.
Listing 6.11
let anotherStatusTuple: (statusCode: Int, statusText: String, statusConnect: Bool) = (200, "In Work", true)
Édition de tuple
Pour les tuples du même type, l'opération d'initialisation de la valeur d'un tuple dans un autre peut être effectuée. Prenons l'exemple du Listing 6.12.
Listing 6.12
var myFirstTuple: (Int, String) = (0, "0") var mySecondTuple = (100, "")
Les tuples myFirstTuple et mySecondTuple ont le même type de données, de sorte que la valeur de l'un peut être initialisée à un autre. Le premier type est défini explicitement, et le second via la valeur initialisée.
Les index et les noms peuvent être utilisés pour modifier les valeurs des éléments individuels dans un tuple (Listing 6.13).
Listing 6.13
Les tuples sont très répandus dans Swift. Par exemple, avec leur aide, vous pouvez facilement renvoyer non pas une, mais plusieurs valeurs de votre fonction (nous nous familiariserons avec les fonctions un peu plus tard).
REMARQUE
Les tuples ne vous permettent pas de créer des structures de données complexes, leur seul but est de regrouper un certain ensemble de paramètres hétérogènes ou similaires et de les transférer à l'emplacement souhaité. Pour créer des structures complexes, vous devez utiliser les outils de programmation orientée objet (POO), et plus spécifiquement, les classes ou les structures. Nous les connaîtrons plus tard.
»Plus d'informations sur le livre sont disponibles sur
le site Web de l'éditeur»
Contenu»
Extrait25% de réduction sur le coupon pour Swabbrookers -
SwiftLors du paiement de la version papier du livre, un livre électronique est envoyé par e-mail.