<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>Terms</key>
	<dict>
		<key>Alpha</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Alpha, ou *canal alpha*, indique l’opacité d’une couleur, allant de `0` (transparence totale) à `1` (opacité totale). La donnée alpha est un double (nombre décimal) situé entre 0 et 1.</string>
				<key>Title</key>
				<string>alpha</string>
			</dict>
		</dict>
		<key>Boolean</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un type qui possède une valeur `true` ou `false`. Par exemple, `9 &lt; 7` renvoie une valeur booléenne `false`, car `9` n’est pas inférieur à `7`.
```
var isRunning = false
```</string>
				<key>Title</key>
				<string>Booléen</string>
			</dict>
		</dict>
		<key>Double</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un type stockant les nombres possédant un composant fractionnel, par exemple : 3.14.
Remarque : Swift Playgrounds utilise un point (.) pour séparer les décimales, et non la virgule (,) que l’on utilise habituellement en français.</string>
				<key>Title</key>
				<string>Double</string>
			</dict>
		</dict>
		<key>ForEach</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Structure qui effectue une [itération](glossary://iteration) sur une [collection](glossary://collection) de données (comme un tableau) pour créer des vues pour chaque élément de la collection. 

La structure `ForEach` requiert que chaque élément fournisse un `id`, soit explicitement dans l’[initialiseur](glossary://initialization) `ForEach`, soit en se conformant au protocole `Identifiable`. Cela permet à SwiftUI d’identifier et de mettre à jour chaque vue générée à partir de `ForEach` indépendamment les unes des autres.

```
ForEach(symbols) { symbol in 
    Text(symbol.name)
}
```
</string>
				<key>Title</key>
				<string>ForEach</string>
			</dict>
		</dict>
		<key>Int</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un type qui contient un nombre entier (sans décimale), comme `10` ou `-42`.</string>
				<key>Title</key>
				<string>Int</string>
			</dict>
		</dict>
		<key>String</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un type qui contient une série de caractères, comme `"hello, world"` ou `"dancing kittens."`</string>
				<key>Title</key>
				<string>String</string>
			</dict>
		</dict>
		<key>Swift</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Langage de programmation d’Apple servant à écrire des apps pour iPhone, iPad, Mac, Apple Watch et Apple TV.</string>
				<key>Title</key>
				<string>Swift</string>
			</dict>
		</dict>
		<key>SwiftUI</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>SwiftUI est un moyen moderne de déclarer des interfaces utilisateur pour toute plateforme Apple. Il fournit des vues, des commandes et des structures de mise en page pour la déclaration de l’interface utilisateur de ton app. Le framework fournit des gestionnaires d’évènements pour transmettre des touchers, des gestes et d’autres types d’entrées à ton app, et des outils pour gérer le flux de données des modèles de ton app vers les vues et les commandes que les utilisateurs verront et avec lesquels ils interagiront.</string>
				<key>Title</key>
				<string>SwiftUI</string>
			</dict>
		</dict>
		<key>absolute value</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La valeur non signée d’un nombre. Par exemple, la valeur absolue de -12 est 12, et la valeur absolue de 23.4 est 23.4.</string>
				<key>Title</key>
				<string>valeur absolue</string>
			</dict>
		</dict>
		<key>abstraction</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une version simplifiée de quelque chose de plus complexe.   Une abstraction masque des détails pour que tu puisses réfléchir à des éléments de ton code et les associer plus simplement.   Par exemple, un [type](glossary://type) est une abstraction qui masque la configuration, les propriétés et les méthodes de l’instance de ce type.</string>
				<key>Title</key>
				<string>abstraction</string>
			</dict>
		</dict>
		<key>accelerometer</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Capteur qui mesure lʼaccélération de ton appareil en trois dimensions : vers le haut et le bas, vers lʼavant et lʼarrière et vers la gauche et la droite.

Quand ton appareil est posé sur une surface plane en orientation paysage, les mouvements vers le haut et le bas mesurent lʼaccélération sur lʼaxe z, les mouvements vers la droite et la gauche mesurent lʼaccélération sur lʼaxe y et les mouvements vers lʼarrière et lʼavant mesurent lʼaccélération sur lʼaxe x.</string>
				<key>Title</key>
				<string>accéléromètre</string>
			</dict>
		</dict>
		<key>adopt</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Pour adopter un protocole, un type fournit un ensemble de ses propres implémentations pour les exigences du protocole, telles que les méthodes et les propriétés énumérées.</string>
				<key>Title</key>
				<string>adopter</string>
			</dict>
		</dict>
		<key>algorithm</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un ensemble d’instructions à suivre pas à pas pour résoudre un problème. Par exemple, la liste des étapes permettant de faire une tasse de thé peut être considérée comme un algorithme.</string>
				<key>Title</key>
				<string>algorithme</string>
			</dict>
		</dict>
		<key>append</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Ajouter un élément à la fin de quelque chose. Par exemple, tu peux ajouter une chaîne à la fin d’une autre chaîne, ou ajouter un élément à un tableau d’éléments.
</string>
				<key>Title</key>
				<string>ajouter</string>
			</dict>
		</dict>
		<key>application</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un logiciel, composé de code, qui te permet d’effectuer des tâches spécifiques. Par exemple, tu utilises l’application (app) Messages pour envoyer et recevoir des messages.</string>
				<key>Title</key>
				<string>application</string>
			</dict>
		</dict>
		<key>argument</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une valeur d’entrée transmise à une fonction pour personnaliser son comportement. Par exemple, dans l’appel à la fonction `move(distance: 3)`, le chiffre `3` est un argument qui indique de combien d’espaces se déplacer.</string>
				<key>Title</key>
				<string>argument</string>
			</dict>
		</dict>
		<key>arithmetic operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un symbole, tel que `+`, `-`, `*` ou `/`, qui effectue une opération mathématique basique impliquant un ou plusieurs nombres. Par exemple, `42 / 7` et `17 - 5` utilisent des opérateurs arithmétiques.</string>
				<key>Title</key>
				<string>opérateur arithmétique</string>
			</dict>
		</dict>
		<key>array</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une collection qui stocke une liste ordonnée d’éléments du même type. Le même élément peut apparaître plusieurs fois à différents endroits.

Dans le code ci-dessous : `highScores` est un tableau de [nombres entiers](glossary://Int) et `greetings` est un tableau de [chaînes](glossary://String).
```
let highScores = [37, 34, 29, 29, 26]
let greetings = ["hi", "bye", "good day"]
```</string>
				<key>Title</key>
				<string>tableau</string>
			</dict>
		</dict>
		<key>aspect ratio</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le ration largeur/hauteur d’une image ou d’un écran.

Par exemple, un image avec des proportions de 2:1 possède une largeur qui est deux fois supérieure à sa hauteur. Une image avec des proportions de 1:1 possède une largeur et une hauteur égales.</string>
				<key>Title</key>
				<string>proportions</string>
			</dict>
		</dict>
		<key>asset</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les ressources sont les images, les sons et les autres éléments que ton app utilise. Tu peux importer des ressources dans Swift Playgrounds à partir d’autres apps, telles que Fichiers et Photos.</string>
				<key>Title</key>
				<string>ressource</string>
			</dict>
		</dict>
		<key>assignment</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une action qui définit la valeur d’une variable ou d’une constante.</string>
				<key>Title</key>
				<string>attribution</string>
			</dict>
		</dict>
		<key>assignment operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le symbole `=` qui sert à définir la valeur d’une variable. Par exemple, `greeting = "bonjour"` définit la valeur de `greeting` sur `"bonjour"`.</string>
				<key>Title</key>
				<string>opérateur d’attribution</string>
			</dict>
		</dict>
		<key>asynchronous process</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un bloc de code qui peut s’exécuter pendant que le reste de ton app ou de ton programme poursuit son exécution. Contrairement à un processus synchrone, qui bloque l’exécution du programme jusqu’à sa fin, un processus asynchrone peut s’exécuter simultanément avec le reste du code de ton app.</string>
				<key>Title</key>
				<string>processus asynchrone</string>
			</dict>
		</dict>
		<key>asynchronous stream</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une [séquence](glossary://sequence) dont les valeurs ne sont pas disponibles toutes en même temps, mais sont produites à certains intervalles de temps sous forme de flux de valeurs. Pour effectuer une itération sur un flux asynchrone, tu dois attendre chaque nouvelle valeur avant d’effectuer des opérations sur celle-ci.
				
Un flux asynchrone est souvent utilisé pour des données qui arrivent au fil du temps, par exemple des secousses sismiques ou des images vidéo.</string>
				<key>Title</key>
				<string>flux asynchrone</string>
			</dict>
		</dict>
		<key>binding</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Ajoute le [wrapper de propriété](glossary://property%20wrapper) `@Binding` pour créer une connexion bidirectionnelle entre une propriété qui stocke des données, et une vue qui affiche et modifie les données. Une association connecte une propriété à une source de vérité stockée ailleurs, plutôt que de stocker uniquement des données. 

Par exemple, un bouton qui permet de basculer entre lecture et pause peut créer une association avec une propriété de sa [vue de conteneur](glossary://container) en utilisant le wrapper de propriété `@Binding`.
</string>
				<key>Title</key>
				<string>association</string>
			</dict>
		</dict>
		<key>body</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le corps d’une [vue](glossary://view) est l’endroit où tu fournis le contenu de la vue, composé d’au moins une [vue intégrée](glossary://built-in%20view) fournie par SwiftUI, ou de [vues composées](glossary://composed%20view) que tu as déjà créées.</string>
				<key>Title</key>
				<string>corps</string>
			</dict>
		</dict>
		<key>bounds</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans un tableau, l’étendue des valeurs que peuvent avoir le tableau ou un index. Par exemple, le tableau `[17, 42, 95]` peut avoir des valeurs d’index de 0 à 2. La vérification des limites correspond à regarder si une valeur d’index se trouve bien dans les limites du tableau.</string>
				<key>Title</key>
				<string>limites</string>
			</dict>
		</dict>
		<key>brightness</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La quantité de lumière qui arrive dans l’appareil photo, allant de `0` (aucune lumière) à `1` (pleine lumière). La luminosité est un [double](glossary://Double) (nombre décimal) compris entre `0` et `1`.</string>
				<key>Title</key>
				<string>luminosité</string>
			</dict>
		</dict>
		<key>bug</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une erreur dans le code qui empêche une application de s’exécuter comme elle devrait le faire. 
</string>
				<key>Title</key>
				<string>bogue</string>
			</dict>
		</dict>
		<key>built-in view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une [vue](glossary://view) fournie par le framework [SwiftUI](glossary://SwiftUI), telle qu’une vue `Button`, `Text` ou `Image`. Les vues intégrées sont utilisées comme des composantes de base pour créer des [vues composées](glossary://composed%20view) plus complexes dans ton [interface utilisateur](glossary://user%20interface).</string>
				<key>Title</key>
				<string>vue intégrée</string>
			</dict>
		</dict>
		<key>bundle</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une app stocke son code, ainsi que toute ressource dont elle a besoin (fichiers de données, images, sons) dans un paquet. Chaque app dispose d’un paquet principal et peut avoir d’autres paquets nommés. Un paquet est un dossier sur un disque, et les ressources qu’il contient sont organisées dans des sous-dossiers bien définis. La structure du paquet varie, en fonction de la plateforme et du type de paquet.</string>
				<key>Title</key>
				<string>paquet</string>
			</dict>
		</dict>
		<key>call</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Lorsque l’on appelle une fonction dans du code, on lui indique de s’exécuter et d’effectuer les actions qui sont définies en elle.</string>
				<key>Title</key>
				<string>appeler</string>
			</dict>
		</dict>
		<key>callback</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Parfois, il se peut quʼune fonction ou un objet doive vous rappeler pour fournir des données ou pour vous indiquer quʼun évènement important sʼest produit pendant son exécution. Pour ce faire, tu dois lui transmettre une fonction ou un objet [délégué](glossary://delegate), lui permettant dʼeffectuer un rappel.

Les rappels sont souvent utilisés pour gérer des processus [asynchrones](glossary://asynchronous%20process).</string>
				<key>Title</key>
				<string>rappel</string>
			</dict>
		</dict>
		<key>chaining</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Technique permettant d’[appeler](glossary://call) une série de [fonctions](glossary://function) dans laquelle chaque fonction renvoie un objet, qui est à son tour utilisé par la fonction suivante. Les appels de fonction sont enchaînés dans une instruction unique. 
				
Par exemple, tu peux enchaîner les [modificateurs](glossary://modifier) SwiftUI, puisqu’un modificateur est une [méthode](glossary://method) qui prend une [vue](glossary://view), applique des changements et renvoie une autre vue.</string>
				<key>Title</key>
				<string>chaînage</string>
			</dict>
		</dict>
		<key>class</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une classe est un conteneur pour du code qui se comporte comme un modèle permettant de créer plusieurs [instances](glossary://instance) du même type d’élément. De la même façon qu’un modèle peut définir les fonctionnalités et les comportements d’un objet, comme une bicyclette, une classe les définit comme étant des [propriétés](glossary://property) et des [méthodes](glossary://method).

Quand tu crées une instance de la classe, elle contient toutes les propriétés et les méthodes définies dans ton modèle. Chaque instance partage les mêmes propriétés et méthodes, mais les valeurs de ses propriétés peuvent être changées de façon indépendante, ce qui te permet de personnaliser chaque instance que tu crées, ou instancies, depuis la classe. Par exemple, la classe d’une bicyclette peut posséder une propriété de couleur, ce qui te permet de créer des bicyclettes rouges et bleues.

Une classe est similaire à une [structure](glossary://structure), mais diffère en deux aspects importants : une classe est un [type de référence](glossary://reference%20type), c’est-à-dire qu’elle est toujours copiée par référence ; une classe peut récupérer sa définition chez une autre classe.</string>
				<key>Title</key>
				<string>classe</string>
			</dict>
		</dict>
		<key>classification</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans le domaine de l’apprentissage automatique, une classification est un algorithme qui tire son apprentissage d’un ensemble de données labellisé et qui fait appel à ces apprentissages pour classifier de nouvelles observations.

Par exemple, un classificateur de races de chiens apprend d’images étiquetées de races de chiens. Si tu montres une nouvelle image d’un chien à ce classificateur, il peut classifier cette entrée parmi une de ces races.</string>
				<key>Title</key>
				<string>classification</string>
			</dict>
		</dict>
		<key>closed range</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un intervalle allant d’une limite inférieure jusqu’à une limite supérieure et contenant cette dernière.

Dans Swift, la valeur de la plage 1-3 peut être écrite sous la forme 1...3. Dans ce cas, la plage contiendra la limite inférieure de 1 et ira jusqu’à la limité supérieure 3.
```
let closedRange = 1...3
for i in closedRange { 
	print(i) // 1 2 3
}
```</string>
				<key>Title</key>
				<string>plage fermée</string>
			</dict>
		</dict>
		<key>closure</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les clôtures sont des [fonctions](glossary://function) qui s’exécutent sans avoir besoin de porter de nom.
					
```
scene.setOnStartHandler {
    // Corps de la clôture
}
```
                    
Les clôtures peuvent récupérer et stocker des références à n’importe quelles constantes et variables du contexte dans lequel elles sont définies. On appelle ceci la clôture de ces constantes et variables.</string>
				<key>Title</key>
				<string>clôture</string>
			</dict>
		</dict>
		<key>code comment</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un commentaire de code est utilisé par les programmeurs pour documenter leur code.   Tu peux commencer un commentaire d’une ligne avec deux barres obliques suivies d’une espace ; par exemple « // Voici mon commentaire. ».   Lorsque tu exécutes ton code, les commentaires de ce code ne s’exécutent pas.</string>
				<key>Title</key>
				<string>commentaire de code</string>
			</dict>
		</dict>
		<key>code expression</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un extrait de code qui peut être évalué pour renvoyer une valeur. Par exemple si `months` est un tableau contenant 12 éléments, l’expression de code `months.count - 1` renvoie la valeur `11`.</string>
				<key>Title</key>
				<string>expression de code</string>
			</dict>
		</dict>
		<key>coding</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>L’action consistant à composer des commandes, des structures de code et des algorithmes de façon à créer une application informatique.</string>
				<key>Title</key>
				<string>codage</string>
			</dict>
		</dict>
		<key>collection</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une structure de données, comme un [tableau](glossary://array) ou une [plage](glossary://range) utilisés pour stocker plusieurs éléments de données. 
```
let heights = [1, 5, 7]
let closedRange = 1...8
```</string>
				<key>Title</key>
				<string>collection</string>
			</dict>
		</dict>
		<key>command</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Du code qui indique à une application d’effectuer une action spécifique. </string>
				<key>Title</key>
				<string>commande</string>
			</dict>
		</dict>
		<key>comment out</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Empêcher qu’une ligne de code s’exécute en la transformant en [commentaire de code](glossary://code%20comment). Tu peux effectuer cette opération en ajoutant `//` devant n’importe quelle ligne de code. Par exemple :
                
`// level.run()`</string>
				<key>Title</key>
				<string>commenter</string>
			</dict>
		</dict>
		<key>comparison operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un symbole, tel que `==`, `!=`, `&lt;`, `&gt;`, `&lt;=` ou `&gt;=`, servant à comparer deux valeurs. On peut utiliser un opérateur de comparaison dans une condition d’une instruction `if` ou d’une boucle `while` pour renvoyer une valeur booléenne qui indique si une comparaison est `true`. Par exemple, `6 &gt; 8` compare `6` et `8` et renvoie `false`.</string>
				<key>Title</key>
				<string>opérateur de comparaison</string>
			</dict>
		</dict>
		<key>compiler error</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les erreurs de compilation sont dues à des inexactitudes dans le code. Elles s’affichent sous forme de point rouge dans la marge de gauche et dans la barre d’outils.</string>
				<key>Title</key>
				<string>erreur de compilation</string>
			</dict>
		</dict>
		<key>composed view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une [vue](glossary://view) créée en combinant une ou plusieurs vues [intégrées](glossary://built-in%20view) ou composées.
</string>
				<key>Title</key>
				<string>vue composée</string>
			</dict>
		</dict>
		<key>composition</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le processus consistant à associer de petites parties d’une application pour former des éléments plus importants qui sont plus simples à utiliser et à comprendre.</string>
				<key>Title</key>
				<string>composition</string>
			</dict>
		</dict>
		<key>compound assignment operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un opérateur qui associe l’attribution (la définition de la valeur d’une variable) à une autre opération, comme une addition ou une soustraction. Par exemple, si la valeur actuelle de `a` est `1`, utiliser `a += 3` ajoute `3` à `1` et attribue le résultat à `a`, pour que la valeur de `a` passe à `4`.</string>
				<key>Title</key>
				<string>opérateur d’attribution composée</string>
			</dict>
		</dict>
		<key>computed property</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Au lieu de stocker une valeur directement, une propriété calculée calcule une valeur en fonction de l’état actuel d’autres valeurs connexes au moment de la récupération.

Dans l’exemple ci-dessous, la surface est une propriété calculée, tandis que la largeur `width` et la hauteur `height` sont des propriétés stockées :

```
struct RectangleCalculator { 
    var width = 10.0
    var height = 10.0
    
    var area : Double { 
        return width * height
    }
} 
```</string>
				<key>Title</key>
				<string>propriété calculée</string>
			</dict>
		</dict>
		<key>condition</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans un bloc de [code conditionnel](glossary://conditional%20code), comme une [instruction if](glossary://if%20statement), la condition est une valeur [booléenne](glossary://Boolean) qui détermine si le code qui se trouve dans le bloc est exécuté ou non. 

Si la condition est `true`, le bloc de code sera exécuté. Si elle est `false`, le code conditionnel sera ignoré.
```
let x = 4

if x &lt; 5 { 
	// Condition is true, code in if block runs. 
}

if x &gt; 5 { 
	// la condition est false, le code du bloc if ne s'exécute pas. 
}
```</string>
				<key>Title</key>
				<string>condition</string>
			</dict>
		</dict>
		<key>conditional code</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Du code qui s’exécute uniquement lorsque certaines conditions sont satisfaites. Par exemple, les [instructions if](glossary://if%20statement) et les [boucles while](glossary://while%20loop) contiennent du code conditionnel qui s’exécute uniquement lorsqu’une condition est `true`.
```
if x &gt; 5 { 
	// Le code est exécuté uniquement si x est supérieur à 5
}
```</string>
				<key>Title</key>
				<string>code conditionnel</string>
			</dict>
		</dict>
		<key>confidence</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans le domaine de l’apprentissage automatique, la confiance correspond à la probabilité de [prédiction](glossary://prediction) d’un modèle d’apprentissage automatique. La confiance d’une prédiction permet de connaître le niveau de performances du modèle d’apprentissage automatique.</string>
				<key>Title</key>
				<string>confiance</string>
			</dict>
		</dict>
		<key>conform</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un type est dit conforme à un protocole lorsqu’il fournit sa propre implémentation des exigences de ce protocole.</string>
				<key>Title</key>
				<string>conforme</string>
			</dict>
		</dict>
		<key>console</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un endroit où tu peux voir une sortie de débogage de ton code pendant son exécution. Lorsque tu appelles `print(_:)` dans ton code, la valeur que tu transmets s’affiche dans la console.</string>
				<key>Title</key>
				<string>console</string>
			</dict>
		</dict>
		<key>constant</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un conteneur désigné qui contient une valeur ne pouvant pas être modifiée.</string>
				<key>Title</key>
				<string>constante</string>
			</dict>
		</dict>
		<key>container</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un conteneur est une vue qui contient d’autres vues.</string>
				<key>Title</key>
				<string>conteneur</string>
			</dict>
		</dict>
		<key>coordinates</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un ensemble de nombres qui déterminent une position unique dans un espace. Par exemple, (100, -200) sont les coordonnées d’un point dans un espace 2D où la coordonnée x est 100 et la coordonnée y est -200.</string>
				<key>Title</key>
				<string>coordonnées</string>
			</dict>
		</dict>
		<key>data</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Informations traitées ou stockées par un ordinateur et différentes du code qui s’y applique.</string>
				<key>Title</key>
				<string>données</string>
			</dict>
		</dict>
		<key>data cleaning</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le processus consistant à examiner un ensemble de données et à supprimer ou modifier des données qui sont incorrectes, incomplètes, en doublon ou mal formatées.

Le nettoyage de données peut améliorer la précision d’un modèle d’apprentissage automatique en assurant qu’il [s’entraîne](glossary://training) uniquement sur les données correctes les plus pertinentes qui sont disponibles.</string>
				<key>Title</key>
				<string>nettoyage de données</string>
			</dict>
		</dict>
		<key>data flow</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le mouvement des données à travers ton app et la manière dont les changements dans ces données entraînent des changements de l’état ou de l’interface utilisateur de ton app.</string>
				<key>Title</key>
				<string>flux de données</string>
			</dict>
		</dict>
		<key>data model</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Représentation sous forme de code des données utilisées dans ton app qui reflète l’organisation des données. Ton [interface utilisateur](glossary://user%20interface) peut afficher les données du modèle de données et peut interagir avec celui-ci pour modifier les données. Ton modèle de données agit en tant que [source de vérité](glossary://source%20of%20truth) pour ton app.</string>
				<key>Title</key>
				<string>modèle de données</string>
			</dict>
		</dict>
		<key>data separation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le concept selon lequel le [modèle de données](glossary://data%20model) d’une app doit être défini séparément de l’[interface utilisateur](glossary://user%20interface) utilisée pour afficher les données et interagir avec celles-ci. La séparation des données te permet de modifier le modèle de données et l’interface utilisateur indépendamment l’un de l’autre, facilite la compréhension du fonctionnement de ton app et améliore la testabilité de ton app.</string>
				<key>Title</key>
				<string>séparation des données</string>
			</dict>
		</dict>
		<key>debug</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Trouver et corriger des erreurs dans le code qui empêchent une application de s’exécuter correctement. </string>
				<key>Title</key>
				<string>débogage</string>
			</dict>
		</dict>
		<key>declaration</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un extrait de code qui crée quelque chose de nouveau dans ton application, comme une fonction, une variable ou un type personnalisé. Par exemple, `let planet = “Earth”` déclare une nouvelle constante, `planet`, et lui attribue une valeur de `"Earth"`.

Le code ci-dessous déclare une variable, `data`, du type `AppData`, mais ne donne pas de valeur initiale.

```
var data : AppData
```</string>
				<key>Title</key>
				<string>déclaration</string>
			</dict>
		</dict>
		<key>decode</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Transformer des données d’un format de stockage efficace, tel que JSON, en un format plus facile à utiliser dans le code.</string>
				<key>Title</key>
				<string>décoder</string>
			</dict>
		</dict>
		<key>decomposition</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le processus consistant à répartir un gros problème en plus petits éléments plus faciles à gérer.</string>
				<key>Title</key>
				<string>décomposition</string>
			</dict>
		</dict>
		<key>decrement</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Réduire une valeur par un entier, souvent 1.</string>
				<key>Title</key>
				<string>décrémenter</string>
			</dict>
		</dict>
		<key>define</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Fournir la valeur explicite ou le comportement d’un extrait de code nouvellement créé, comme une fonction, une variable ou un type personnalisé. Par exemple, tu définis une fonction en ajoutant un ensemble de commandes à l’intérieur de la fonction pour lui indiquer ce qu’il faut faire.</string>
				<key>Title</key>
				<string>définir</string>
			</dict>
		</dict>
		<key>delegate</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Objet spécial fourni à un autre objet pour t’avertir lorsque des évènements importants se produisent. L’objet délégué se conforme généralement à un [protocole](glossary://protocol), avec des fonctions qui peuvent être appelées pour communiquer en retour avec ton code. Lorsqu’une fonction déléguée est appelée, on parle de [rappel](glossary://callback) de délégué.

La délégation est un modèle fréquent utilisé pour communiquer entre des objets, en particulier dans les processus [asynchrones](glossary://asynchronous%20process).</string>
				<key>Title</key>
				<string>délégué</string>
			</dict>
		</dict>
		<key>destination view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La vue qui est affichée après quʼun [utilisateur](glossary://user) clique ou touche un `NavigationLink` dans une `NavigationStack` ou une `NavigationSplitView`.</string>
				<key>Title</key>
				<string>vue de destination</string>
			</dict>
		</dict>
		<key>dot notation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une forme de syntaxe servant à accéder aux propriétés ou à appeler les méthodes d’une instance. Par exemple, `expert.toggleSwitch()` appelle la méthode `toggleSwitch()` dans l’instance `expert`.</string>
				<key>Title</key>
				<string>notation par points</string>
			</dict>
		</dict>
		<key>edge case</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une situation, prédite ou non, qui se produit dans de rares circonstances ou si un paramètre de fonctionnement a atteint une de ses valeurs extrêmes. 

Par exemple, lors de la création d’une app pour iPad, ton app plante quand tu mets à jour la langue de ton appareil pour définir une langue qui utilise une écriture de droite à gauche, comme lʼarabe. </string>
				<key>Title</key>
				<string>cas limite</string>
			</dict>
		</dict>
		<key>efficiency</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une mesure de la qualité d’un morceau de code, sa capacité à exécuter ce pour quoi il a été conçu rapidement en utilisant le moins de ressources (mémoire et puissance) possible.</string>
				<key>Title</key>
				<string>efficacité</string>
			</dict>
		</dict>
		<key>element</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un élément d’une [collection](glossary://collection), comme un [tableau](glossary:///array) ou une [plage](glossary://range).

```
let letters = ["a", "b", "c"] // "a" est le premier élément, "b" le deuxième et "c" le troisième. 
```</string>
				<key>Title</key>
				<string>élément</string>
			</dict>
		</dict>
		<key>else block</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le dernier bloc de code dans une instruction `if`. Le bloc `else` s’exécute si toutes les autres conditions de l’instruction `if` sont `false`.

```
if hopper.isFacingStep { 
	// if block
} else if hopper.isFacingUpdraft { 
	// else if block
} else { 
	// else block
}
```</string>
				<key>Title</key>
				<string>bloc else</string>
			</dict>
		</dict>
		<key>else if block</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un bloc de code dans une instruction `if`, servant à vérifier une condition qui n’est pas vérifiée par le [bloc if](glossary://if%20block) ou tout autre bloc `else if`.

```
if hopper.isFacingStep { 
	// if block
} else if hopper.isFacingUpdraft { 
	// else if block
} else { 
	// else block
}
``</string>
				<key>Title</key>
				<string>bloc else if</string>
			</dict>
		</dict>
		<key>encode</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Transformer des données d’un format qui est facile à utiliser dans le code en un format de stockage efficace, tel que JSON.</string>
				<key>Title</key>
				<string>encoder</string>
			</dict>
		</dict>
		<key>enumeration</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un type qui définit un ensemble de valeurs associées que l'on appelle des *cas*.

 Par exemple, l'énumération `Direction` définit des cas pour chaque direction : `north`, `south`, `east` et `west`. 
```
enum Direction { 
	case north, south, east, west
}
```
 Quand tu [transmets](glossary://pass%20in) une valeur d'énumération, tu choisis toujours un seul de ses cas. Par exemple :
 ```
 moveIn(direction: .north)
```</string>
				<key>Title</key>
				<string>énumération</string>
			</dict>
		</dict>
		<key>environment</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>L’environnement d’une vue donne accès à une collection définie de valeurs. Certaines d’entre elles reflètent automatiquement l’état du système, les réglages de l’utilisateur ou l’état d’une vue. Il s’agit par exemple du schéma de couleurs, du style de texte ou de l’état de la mise au point de la vue. D’autres fournissent des valeurs par défaut utiles, telles qu’un nombre limite de lignes pour les champs de texte. Tu peux lire les valeurs de l’environnement en y accédant par le [wrapper de propriété](glossary://property%20wrapper) `@Environment`. Une liste complète des valeurs d’environnement est disponible [ici](doc://com.apple.documentation/documentation/swiftui/environmentvalues).</string>
				<key>Title</key>
				<string>environnement</string>
			</dict>
		</dict>
		<key>environment object</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Ajoute le [wrapper de propriété](glossary://property%20wrapper) `@EnvironmentObject` pour déclarer une propriété d’objet observable fournie par une vue de conteneur ou une vue ancêtre. Si tu déclares une propriété en tant qu’objet d’environnement, assure-toi de définir une instance de modèle correspondante sur une vue ancêtre en appelant son modificateur `environmentObject(_:)`.</string>
				<key>Title</key>
				<string>objet d’environnement</string>
			</dict>
		</dict>
		<key>event</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une action qui peut être détectée par une application pour ordinateur. La saisie, comme appuyer sur un bouton ou faire pivoter l’écran, déclenche un évènement.</string>
				<key>Title</key>
				<string>évènement</string>
			</dict>
		</dict>
		<key>event handler</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une fonction appelée après l’apparition d’un évènement, pour le gérer.</string>
				<key>Title</key>
				<string>gestionnaire d’évènements</string>
			</dict>
		</dict>
		<key>extension</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un moyen d’ajouter une nouvelle fonctionnalité à un [type](glossary://type) existant, comme une [class](glossary://class), une [structure](glossary://structure), une [énumération](glossary://enumeration) ou un [protocole](glossary://protocol).

Une extension te permet d’ajouter des [méthodes](glossary://method) et des [propriété](glossary://property) à un type existant. Le code ci-dessous ajoute la méthode `cubed()` et la propriété `isOdd` au type `Int` :

```
extension Int { 
	func cubed() -&gt; Int { 
        return self * self * self
    }
    
    var isOdd : Bool { 
        return self % 2 == 1
    }
}

let two : Int = 2
print(two.cubed()) // 8
print(two.isOdd) // false
```</string>
				<key>Title</key>
				<string>extension</string>
			</dict>
		</dict>
		<key>filtering</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Traitement des données dans une collection ou une structure de données pour produire un nouvel ensemble.</string>
				<key>Title</key>
				<string>filtrage</string>
			</dict>
		</dict>
		<key>focus state</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Valeur représentant la disponibilité d’une vue à recevoir une entrée de l’utilisateur, comme une saisie dans un champ de texte. Utilise le [wrapper de propriété](glossary://property%20wrapper) `@FocusState` avec les modificateurs `focused(_:equals:)` et `focused(_:)` pour créer une vue dont la valeur de mise au point se mettra à jour automatiquement en fonction de l’interaction utilisateur et peut également être mise au point ou non, par programmation, à un moment donné.</string>
				<key>Title</key>
				<string>état de la mise au point</string>
			</dict>
		</dict>
		<key>font</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un ensemble de caractères textuels dans un style visuel, un poids et une taille spécifiques. Le style visuel d’une police est appelé *police de caractères*, et les variations de ce style forment une *famille*. Par exemple, HelveticaNeue est une police de caractères, et HelveticaNeue-Bold 10 points est une police.</string>
				<key>Title</key>
				<string>police</string>
			</dict>
		</dict>
		<key>for loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un bloc de code répété qui s’exécute un certain nombre de fois. 

Une boucle peut [effectuer une itération](glossary://iterate) sur n’importe quelle [collection](glossary://collection) de données, comme une [plage](glossary://range%20value) ou un [tableau](glossary://array), en exécutant le bloc de la boucle pour chaque élément de la collection.

Dans l’exemple ci-dessous, la boucle définit une variable de boucle, `value`, qui te permet d’accéder à la valeur de l’élément actuel dans la collection :
```
for value in 1...4 { 
	byte.moveForward()
	byte.jump(height: value)
}
```</string>
				<key>Title</key>
				<string>boucle for</string>
			</dict>
		</dict>
		<key>framework</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un framework est un répertoire qui contient des ressources partagées. Ces ressources peuvent inclure des fichiers sources, des fichiers images, des chaînes localisées, de la documentation de référence et plus encore, dans un paquet unique. Plusieurs applications peuvent utiliser toutes ces ressources simultanément. Le système les charge en mémoire selon les besoins et partage la copie unique de la ressource entre toutes les applications lorsque cela est possible.</string>
				<key>Title</key>
				<string>cadre dʼapplication</string>
			</dict>
		</dict>
		<key>full function name</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le nom complet d’une fonction, notamment les noms de ses paramètres séparés par des deux-points (`:`) ; par exemple, `move(to:duration:)`.</string>
				<key>Title</key>
				<string>nom complet de la fonction</string>
			</dict>
		</dict>
		<key>function</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Bloc de code doté d’un nom qui s’exécute lorsqu’il est [appelé](glossary://call) par son nom. Une fonction peut recevoir des données sous la forme de [paramètres](glossary://parameter), et peut éventuellement [renvoyer](glossary://return) des données lorsque l’exécution de son code est terminée. Une fonction qui est définie dans un type est appelée une [méthode](glossary://method).

Ci-dessous se trouve un exemple d’une définition de la fonction `turnRight()`. Tu peux appeler cette fonction en écrivant `turnRight()`. Le code s’exécutera alors, en exécutant trois fois `turnLeft()`.

```
func turnRight() { 
	turnLeft()
	turnLeft()
	turnLeft()
}
```</string>
				<key>Title</key>
				<string>fonction</string>
			</dict>
		</dict>
		<key>function definition</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La définition d’une fonction décrit ce qu’elle permet de faire, ce qu’elle s’attend à recevoir et ce qu’elle renvoie une fois qu’elle a terminé.</string>
				<key>Title</key>
				<string>définition de fonction</string>
			</dict>
		</dict>
		<key>fuzzy autocomplete</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Méthode pour l’autocomplétion de code qui utilise une recherche de chaîne floue pour trouver des variables, constantes, types et autres symboles correspondants. Une recherche de chaîne floue n’est pas exacte, mais elle trouve des correspondances pertinentes en fonction des caractères que tu saisis. 

Par exemple, si tu recherches un [modificateur de vue](glossary://modifier) en rapport avec « scale », tu peux simplement commencer à saisir `.scale`, ce qui te renvoie des options d’autocomplétion qui commencent par `.scale`, telles que `.scaledToFill` et `.scaleEffect`, mais aussi des correspondances plus « floues » comme `.imageScale` et `.grayscale`.
</string>
				<key>Title</key>
				<string>autocomplétion floue</string>
			</dict>
		</dict>
		<key>g</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une unité de mesure pour l’accélération ou la pression par unité de masse. Un g, ou g-force, est égal à l’accélération de la gravité sur Terre, ce qui correspond à peu près à 9,8 mètres par seconde carrée.</string>
				<key>Title</key>
				<string> g</string>
			</dict>
		</dict>
		<key>global function</key>
		<dict>
			<key>FirstUse</key>
			<dict>
				<key>PageReference</key>
				<string></string>
				<key>_LOCALIZABLE_</key>
				<dict>
					<key>Title</key>
					<string></string>
				</dict>
			</dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une fonction à laquelle il est possible d’accéder depuis n’importe quel fichier de ton projet.</string>
				<key>Title</key>
				<string>fonction globale</string>
			</dict>
		</dict>
		<key>global scope</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Symboles qui sont accessibles depuis le code de n’importe quel fichier source du même [module](glossary://module). Les instances, types ou fonctions définis au niveau supérieur d’un fichier source ont une portée globale par défaut. </string>
				<key>Title</key>
				<string>portée globale</string>
			</dict>
		</dict>
		<key>global variable</key>
		<dict>
			<key>FirstUse</key>
			<dict>
				<key>PageReference</key>
				<string></string>
				<key>_LOCALIZABLE_</key>
				<dict>
					<key>Title</key>
					<string></string>
				</dict>
			</dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une variable à laquelle il est possible d’accéder depuis n’importe quel fichier de ton projet.</string>
				<key>Title</key>
				<string>variable globale</string>
			</dict>
		</dict>
		<key>grayscale</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un dégradé de gris, allant du blanc au noir.</string>
				<key>Title</key>
				<string>échelle de gris</string>
			</dict>
		</dict>
		<key>gyroscope</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un capteur qui mesure l’orientation de ton appareil en trois dimensions : son inclinaison d’avant en arrière, son inclinaison de gauche à droite et sa rotation autour de son centre.</string>
				<key>Title</key>
				<string>gyroscope</string>
			</dict>
		</dict>
		<key>half open range</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un intervalle demi ouvert allant d’une limite inférieure jusqu’à une limite supérieure, mais qui ne contient pas cette dernière.

Dans Swift, la valeur de la plage 1-3 peut être écrite comme 1..&lt;4. Dans ce cas, la plage contiendra la limite inférieure de 1 et ira jusqu’à 4, mais sans contenir la valeur 4.
```
let halfOpenRange = 1..&lt;4
for i in halfOpenRange { 
	print(i) // 1 2 3
}
```</string>
				<key>Title</key>
				<string>plage demi ouverte</string>
			</dict>
		</dict>
		<key>hertz</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le Hertz (Hz) correspond à un cycle par seconde. Lorsque cette mesure est appliquée aux vibrations sonores, 1 Hz correspond à une onde sonore par seconde. Les humains sont capables d’entendre des sons compris entre 20 Hz et 16 000 Hz.</string>
				<key>Title</key>
				<string>hertz</string>
			</dict>
		</dict>
		<key>hue</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le ton d’une couleur dans la roue des couleurs. Il s’agit d’un double (nombre décimal) compris entre `0` et `1`.</string>
				<key>Title</key>
				<string>teinte</string>
			</dict>
		</dict>
		<key>if block</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le premier bloc de code dans une instruction `if`. Le bloc `if` s’exécute si la condition dans l’instruction `if` est `true`.
```
if blu.isFacingStep { 
	blu.jump()
}
```</string>
				<key>Title</key>
				<string>bloc if</string>
			</dict>
		</dict>
		<key>if statement</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une structure de code servant à exécuter du code en fonction de la valeur d’une ou plusieurs conditions. Le premier bloc de code dans une instruction `if` est le bloc `if`.
```
if blu.isFacingStep { 
	blu.jump()
}
```
 Une instruction `if` peut également contenir d’autres blocs qui fournissent des vérifications supplémentaires, comme un bloc `else` et un bloc `else if`.
```
if blu.isFacingStep { 
	blu.jump()
} else if blu.isFacingHole { 
	blu.shapeShift(into: .bridge)
} else { 
	blu.moveForward()
}
```</string>
				<key>Title</key>
				<string>instruction if</string>
			</dict>
		</dict>
		<key>import</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans Swift, une [déclaration](glossary://declaration) `import` te permet d’accéder à des symboles, tels que des types, fonctions, propriétés et méthodes, qui sont définis en dehors du fichier actuel. Tu peux importer les symboles dans un [module](glossary://module) ou un [framework](glossary://framework) comme [SwiftUI](doc://com.apple.documentation/documentation/swiftui) ou [CoreMotion](doc://com.apple.documentation/documentation/coremotion). Par exemple, pour utiliser le framework SwiftUI, tu places la déclaration suivante en haut du fichier : 

```
import SwiftUI
```
</string>
				<key>Title</key>
				<string>importer</string>
			</dict>
		</dict>
		<key>increment</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Augmenter une valeur par un entier, souvent 1.</string>
				<key>Title</key>
				<string>incrémenter</string>
			</dict>
		</dict>
		<key>index</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un numéro représentant la position d’un élément dans un [tableau](glossary://array).</string>
				<key>Title</key>
				<string>index</string>
			</dict>
		</dict>
		<key>index out of range error</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une erreur qui survient lorsque l’on essaie d’accéder à un tableau en utilisant un index qui se trouve en dehors des limites de ce tableau. Par exemple, l’index `2` se trouve en dehors des limites du tableau suivant : `[17, 42]`.</string>
				<key>Title</key>
				<string>erreur d’index hors limites</string>
			</dict>
		</dict>
		<key>initialization</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>L’action consistant à créer une nouvelle instance d’un type, ce qui comprend la définition de valeurs initiales pour toute propriété du type.</string>
				<key>Title</key>
				<string>initialisation</string>
			</dict>
		</dict>
		<key>initializer</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Appelle un initialiseur pour créer une nouvelle [instance](glossary://instance) d’un type. L’initialiseur doit s’assurer que les propriétés du type disposent toutes de valeurs initiales, et contient souvent d’autres codes de configuration.</string>
				<key>Title</key>
				<string>initialiseur</string>
			</dict>
		</dict>
		<key>inner loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un bloc de code se répétant (une boucle) et étant imbriqué dans une autre boucle (extérieure).</string>
				<key>Title</key>
				<string>boucle intérieure</string>
			</dict>
		</dict>
		<key>instance</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une valeur d’un certain [type](glossary://type). Par exemple, dans `let motion = MotionSensor()`, `motion` est une instance du type `MotionSensor`.</string>
				<key>Title</key>
				<string>instance</string>
			</dict>
		</dict>
		<key>integer</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un nombre entier, comme `2` ou `-5`.</string>
				<key>Title</key>
				<string>entier</string>
			</dict>
		</dict>
		<key>iterate</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Pour répéter un bloc de code pour chaque [élément](glossary://element) d’une [collection](glossary://collection), comme un tableau ou une plage.

Dans l’exemple ci-dessous, la boucle for effectue une itération dans le tableau `days`, en imprimant un jour de la semaine à la fois :
```
let days = ["Monday", "Tuesday", "Wednesday"]

for value in days { 
	print(value)
}

//Première itération : imprime "Monday"
// Deuxième itération : imprime "Tuesday"
// Troisième itération : imprime "Wednesday"
```</string>
				<key>Title</key>
				<string>effectuer une itération</string>
			</dict>
		</dict>
		<key>iteration</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>L’action consistant à répéter un processus, comme effectuer la même opération pour chaque élément d’un tableau.</string>
				<key>Title</key>
				<string>itération</string>
			</dict>
		</dict>
		<key>label</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La représentation visuelle d’un élément de l’interface utilisateur, créée sous la forme d’une [vue](glossary://view).

De nombreuses [vues intégrées](glossary://built-in%20view) SwiftUI disposent à la fois d’une étiquette (une représentation visuelle) et d’autres points de personnalisation, comme une [vue de destination](glossary://destination%20view) pour un `NavigationLink` ou un [rappel](glossary://callback) d’action pour un `Button`.</string>
				<key>Title</key>
				<string>étiquette</string>
			</dict>
		</dict>
		<key>lag</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une diminution de la vitesse ou de la réactivité de l’app en raison de la demande de traitement, de la puissance de traitement ou des deux.</string>
				<key>Title</key>
				<string>lag</string>
			</dict>
		</dict>
		<key>leading edge</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le bord avant, lorsque ce terme est utilisé en référence au contenu d’une vue, fait référence à la position horizontale du début du contenu. La position du bord avant dépend de tes préférences, et est généralement fondée sur tes paramètres régionaux et linguistiques.
                    Par exemple, avec les langues qui sont lues de gauche à droite, telles que l’anglais et le français, le bord avant se trouve à gauche. Avec les langues qui se lisent de droite à gauche, telles que l’arabe ou l’hébreu, le bord avant est situé à droite.</string>
				<key>Title</key>
				<string>bord avant</string>
			</dict>
		</dict>
		<key>literal</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les littéraux te permettent d’intégrer des images et de la couleur directement dans ton code à l’aide de la bibliothèque d’images ou du sélecteur de couleur. Les littéraux sont les valeurs de tes données représentées dans leur format natif, directement dans l’éditeur.</string>
				<key>Title</key>
				<string>littéral</string>
			</dict>
		</dict>
		<key>local scope</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une portée locale est formée à chaque nouveau niveau de l’organisation du code sous la [portée globale](glossary://global%20scope). Par exemple, un nouveau [type](glossary://type) forme une nouvelle portée locale, et des fonctions et blocs de code à l’intérieur de ce type forment leur propre niveau de [portée](glossary://scope). En fonction de l’endroit où un symbole est déclaré, il n’est accessible que depuis le code qui se trouve au même niveau ou à un niveau inférieur de portée.

Par exemple, si une variable est définie dans un type, cette variable est accessible dans toutes les fonctions et tous les blocs de code de type. Cependant, une constante définie dans une méthode est uniquement accessible dans la définition de la méthode.</string>
				<key>Title</key>
				<string>portée locale</string>
			</dict>
		</dict>
		<key>logical AND operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un symbole (`&amp;&amp;`) qui associe deux valeurs booléennes. Les deux valeurs doivent être vraies pour que l’ensemble du code le soit aussi. Par exemple, `a &amp;&amp; b` est uniquement vrai si `a` et `b` sont `true`.</string>
				<key>Title</key>
				<string>opérateur logique ET</string>
			</dict>
		</dict>
		<key>logical NOT operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un symbole (`!`) qui inverse la valeur booléenne d’un extrait de code. Par exemple, si `a` est `true`, alors `!a` est `false`.</string>
				<key>Title</key>
				<string>opérateur logique PAS</string>
			</dict>
		</dict>
		<key>logical OR operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un symbole (`||`) qui associe deux valeurs booléennes. Une seule valeur doit être vraie pour que l’ensemble du code le soit aussi. Par exemple, `a || b` est `true` si `a` ou `b` est `true` (ou si les deux sont `true`).</string>
				<key>Title</key>
				<string>opérateur logique OU</string>
			</dict>
		</dict>
		<key>logical operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un symbole, tel que `&amp;&amp;`, `||` ou `!`, qui modifie ou associe les valeurs logiques booléennes `true` et `false`.</string>
				<key>Title</key>
				<string>opérateur logique</string>
			</dict>
		</dict>
		<key>loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un bloc de code qui se répète un certain nombre de fois (comme une boucle `for`) ou jusqu’à ce qu’une condition soit satisfaite (par exemple, une boucle `while`).</string>
				<key>Title</key>
				<string>boucle</string>
			</dict>
		</dict>
		<key>loop variable</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans une [boucle for](glossary://for%20loop), la valeur de l’élément actuel dans la [collection](glossary://collection) dans lequel vous effectuez une [itération](glosssary://iterate).

Une variable de boucle stocke cette valeur, ce qui te permet l'utiliser dans le corps de la boucle `for`. 

Dans l'exemple suivant, `value` et `letter` sont des variables de boucle :
```
for value in 1...4 { 
	print(value) // 1 2 3 4
}

for letter in ["c", "o", "d", "e"] { 
	print(letter) // c o d e 
}
```</string>
				<key>Title</key>
				<string>variable de boucle</string>
			</dict>
		</dict>
		<key>lower bound</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans une [plage](glossary://range), la valeur de départ depuis laquelle le décompte est effectué.

```
let closedRange = 1...5 // Lower bound is 1, upper bound is 5
for i in closedRange { 
	print(i) // 1 2 3 4 5
}
```</string>
				<key>Title</key>
				<string>limite inférieure</string>
			</dict>
		</dict>
		<key>machine learning</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un domaine de la science informatique qui se concentre sur le développement d’[algorithmes](glossary://algorithm) et qui utilise un grand nombre de données pour apprendre aux machines à apprendre et améliorer un processus spécifique. 

Par exemple, apprendre à une machine à reconnaître un type de fleur en utilisant un [classificateur](glossary://classification) d’images et en fournissant un gros ensemble de données contenant des images de fleurs.</string>
				<key>Title</key>
				<string>apprentissage automatique</string>
			</dict>
		</dict>
		<key>machine learning model</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un type de [modèle de données](glossary://data%20model) que tu crées en appliquant un [algorithme](glossary://algorithm) d’apprentissage automatique à un [ensemble de données d’apprentissage](glossary://training%20dataset). Les modèles d’apprentissage automatique, ou modèles d’AA, sont utilisés pour faire des [prédictions](glossary://prediction) à partir d’une entrée.</string>
				<key>Title</key>
				<string>modèle d’apprentissage automatique</string>
			</dict>
		</dict>
		<key>magnitude</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La taille d’une valeur, qu’elle soit positive ou négative. On parle aussi de [valeur absolue](glossary://absolute%value) d’un nombre. 

Par exemple, la magnitude de `5` et `-5` est `5` pour les deux.</string>
				<key>Title</key>
				<string>magnitude</string>
			</dict>
		</dict>
		<key>memory</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La partie d’un ordinateur qui stocke le code d’une application et les données qu’elle utilise, temporairement ou de façon permanente.</string>
				<key>Title</key>
				<string>mémoire</string>
			</dict>
		</dict>
		<key>metadata</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Informations supplémentaires concernant des données. Par exemple, une photo peut contenir des métadonnées à propos du lieu où elle a été prise.</string>
				<key>Title</key>
				<string>métadonnées</string>
			</dict>
		</dict>
		<key>method</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Bloc de code doté d’un nom qui s’exécute lorsqu’il est [appelé](glossary://call) par son nom. 

Une méthode est une [fonction](glossary://function), mais elle est définie à l’intérieur d’un [type](glossary://type). 

Ce code appelle la méthode, `moveForward()`, depuis une [instance](glossary://instance) nommée `byte`:
```
let byte = Byte()

byte.moveForward()
```</string>
				<key>Title</key>
				<string>méthode</string>
			</dict>
		</dict>
		<key>miter</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un style de jointure entre deux traits dont les coins sont pointus et non arrondis ou biseautés.</string>
				<key>Title</key>
				<string>anglet</string>
			</dict>
		</dict>
		<key>modifier</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans SwiftUI, un modificateur sert à personnaliser l’aspect ou le comportement d’une vue.

					Dans le code ci-dessous, le modificateur `foregroundColor` change la couleur de la vue `Rectangle` en bleu.
					```
					Rectangle()
							.foregroundColor(.blue)
					```

					Pour que les modificateurs soient plus facilement lisibles, chacun d’entre eux est placé sur une ligne individuelle sous la vue qu’il modifie. Dans cet exemple, le modificateur `foregroundColor(.blue)` sera appliqué en premier, suivi par `border(.green)`.
					```
					Rectangle()
							.foregroundColor(.blue)
							.border(.green)
					```
					
					Étant donné que les modificateurs sont appliqués dans l’ordre, si tu changes leur position, cela peut modifier l’aspect ou le comportement de la vue résultante. 
				</string>
				<key>Title</key>
				<string>modificateur</string>
			</dict>
		</dict>
		<key>modularity</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Principe consistant à séparer ton app en éléments indépendants, chacun d’entre eux contenant tout ce dont cette partie a besoin pour exécuter une fonctionnalité unique de ton app, comme l’affichage d’une seule partie de ton interface ou le stockage des données de ton app.

La modularité est un principe important de la création d’apps, car elle te permet de mieux comprendre et d’utiliser des fonctionnalités individuelles. Cela te permet de détecter plus facilement à quel endroit un problème s’est produit lorsque ton app présente un bogue.</string>
				<key>Title</key>
				<string>modulaire</string>
			</dict>
		</dict>
		<key>module</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Unité unique de distribution de code, un [framework](glossary://framework) ou une application, qui est construite et envoyée en tant qu’unité unique et qui peut être importée par un autre module avec le mot clé d’[importation](glossary://import) de Swift.</string>
				<key>Title</key>
				<string>module</string>
			</dict>
		</dict>
		<key>modulo operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un symbole (`%`) qui renvoie le reste une fois qu’un nombre a été divisé par un autre. Par exemple, `17 % 5` renvoie `2`.</string>
				<key>Title</key>
				<string>opérateur modulo</string>
			</dict>
		</dict>
		<key>navigation bar</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une interface de navigation te permet d’effectuer un choix par écran jusqu’à ce que tu atteignes une destination. Pour accéder à une autre destination, tu dois revenir en arrière ou recommencer depuis le début et faire des choix différents. La barre de navigation située en haut de l’écran affiche un titre pour t’aider à te rappeler où tu te trouves. Elle te fournit également un bouton de retour pour que tu puisses revenir à l’écran précédent.</string>
				<key>Title</key>
				<string>barre de navigation</string>
			</dict>
		</dict>
		<key>navigation link</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>[Vue intégrée](glossary://built-in%20view) SwiftUI qui conduit à une [vue de destination](glossary://destination%20view) lorsqu’un utilisateur la touche. Un lien de navigation dispose également d’une [étiquette](glossary://label) qui détermine son apparence visuelle.</string>
				<key>Title</key>
				<string>lien de navigation</string>
			</dict>
		</dict>
		<key>nest</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Placer un bloc de code qui se répète, tel qu’une boucle, à l’intérieur d’un autre.</string>
				<key>Title</key>
				<string>imbriquer</string>
			</dict>
		</dict>
		<key>normalization</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Processus de mise à lʼéchelle dʼun ensemble de données permettant de situer les valeurs mises à lʼéchelle entre `0` et `1`.</string>
				<key>Title</key>
				<string>normalisation</string>
			</dict>
		</dict>
		<key>observable object</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Lorsqu’une classe est [conforme](glossary://conform) au protocole `ObservableObject`, toute modification de ses valeurs publiées entraînera la mise à jour automatique de toutes les vues qui utilisent ces valeurs afin de refléter les modifications.</string>
				<key>Title</key>
				<string>objet observable</string>
			</dict>
		</dict>
		<key>observe</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Surveiller un objet afin de détecter une [modification de son état](glossary://state%20change).</string>
				<key>Title</key>
				<string>observer</string>
			</dict>
		</dict>
		<key>observed object</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans une [vue](glossary://view), SwiftUI surveille les changements apportés à toute [propriété](glossary://property) qui utilise le [wrapper de propriété](glossary://property%20wrapper) `@ObservedObject`. Si sa valeur change, SwiftUI met la vue à jour.

Le type de la propriété d’un objet observé doit être [conforme](glossary://conform) au protocole `ObservableObject`.
				</string>
				<key>Title</key>
				<string>objet observé</string>
			</dict>
		</dict>
		<key>observer</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>En ce qui concerne un [objet observable](glossary://observable%20object), un observateur est toute vue ou tout objet qui utilise les données de l’objet observable. Lorsque les données de l’objet observable changent, SwiftUI reconnaît le changement et indique aux observateurs de se mettre à jour.</string>
				<key>Title</key>
				<string>observateur</string>
			</dict>
		</dict>
		<key>operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un symbole, tel que `+`, `-` ou `&amp;&amp;`, qui représente une action effectuée sur une ou plusieurs valeurs. Par exemple, dans `1 + 2`, l’opérateur d’addition (`+`) ajoute les nombres `1` et `2`.</string>
				<key>Title</key>
				<string>opérateur</string>
			</dict>
		</dict>
		<key>optional</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un type qui représente soit une valeur enveloppée, soit aucune valeur. Un type facultatif est généralement indiqué par un point d’interrogation final (`?`).
				
Par exemple, une variable de type `Int?` peut contenir une valeur `Int` enveloppée de `-43` ou `6`, ou sa valeur peut être `nil`, auquel cas aucune valeur ne lui est attribuée.</string>
				<key>Title</key>
				<string>facultatif</string>
			</dict>
		</dict>
		<key>outer loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un bloc de code se répétant (une boucle) et contenant une autre boucle (intérieure).</string>
				<key>Title</key>
				<string>boucle extérieure</string>
			</dict>
		</dict>
		<key>overfitting</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans le domaine de l’apprentissage automatique, la production d’un modèle qui correspond trop à un certain ensemble de données. 

Par exemple, si ton modèle est un [classificateur](glossary://classification) qui détecte des images de mammifères, et si ton [ensemble de données d’apprentissage](glossary://training%20dataset) ne contient que des images de chiens, le modèle va surapprendre pour reconnaître des chiens au détriment des autres mammifères, comme les lapins ou les biches.</string>
				<key>Title</key>
				<string>surapprentissage</string>
			</dict>
		</dict>
		<key>parameter</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une valeur servant à personnaliser le comportement d’une [fonction](glossary://function). Quand tu [appelles](glossary://call) la fonction, tu peux transmettre différentes valeurs pour modifier son comportement.

Dans la fonction ci-dessous, `distance` est un paramètre qui accepte une valeur du type `Int`:
```
func move(distance: Int) { 
	for i in 1...distance { 
		moveForward()
	}
}
```
La valeur du paramètre (`distance`) peut être utilisée dans le corps de la fonction pour influencer son comportement. Dans ce cas, tu peux appeler la fonction avec différentes valeurs intègres, comme `move(distance: 2)` ou `move(distance: 5)` pour parcourir diverses distances.</string>
				<key>Title</key>
				<string>paramètre</string>
			</dict>
		</dict>
		<key>pass in</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Fournir une valeur à un des [paramètres](glossary://parameter) d’une fonction. 

Dans l’exemple ci-dessous, le code transmet la valeur "Bonjour" au paramètre `text`.
```
speak(text: "Hello")
```</string>
				<key>Title</key>
				<string>transmettre</string>
			</dict>
		</dict>
		<key>pattern</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Mot anglais utilisé en programmation pour définir un ensemble de circonstances ou de données se répétant.
Note : les termes français motif, modèle, structure ou patron sont parfois également rencontrés pour désigner ce concept.</string>
				<key>Title</key>
				<string>pattern</string>
			</dict>
		</dict>
		<key>persistence</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le processus de stockage des données utilisateur de sorte qu’elles puissent être rechargées à chaque lancement de l’app. Sans la persistance, l’état et les données de ton app se réinitialisent chaque fois que l’app est relancée.</string>
				<key>Title</key>
				<string>persistance</string>
			</dict>
		</dict>
		<key>pi</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Pi (π) est une constante mathématique qui équivaut à peu près à 3,14. Il sʼagit du ratio entre la circonférence dʼun cercle et son diamètre.</string>
				<key>Title</key>
				<string>pi</string>
			</dict>
		</dict>
		<key>pitch</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Mesure de la rotation ou de lʼinclinaison dʼun appareil vers la droite et vers la gauche quand ce dernier est en orientation paysage.   En mathématiques, le tangage est la rotation autour de lʼaxe x de lʼappareil. Elle est mesurée en radians et est comprise entre `-π/2` et `π/2`.</string>
				<key>Title</key>
				<string>tangage</string>
			</dict>
		</dict>
		<key>pitch audio</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La tonalité d’un son dépend de la fréquence de la vibration des ondes sonores. Plus il y a d’ondes sonores produites pendant un certain laps de temps, plus la tonalité est élevée. 

					Dans le domaine de la musique, la tonalité indique si une note sera « grave » ou « aigüe ». Par exemple, le chant des oiseaux possède une tonalité élevée et le rugissement d’un lion possède une tonalité grave.</string>
				<key>Title</key>
				<string>tangage</string>
			</dict>
		</dict>
		<key>placeholder view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une vue qui s’affiche temporairement pour indiquer à quel endroit un contenu final sera chargé ou saisi. Il peut s’agir d’une `ProgressView` utilisée pour montrer une image en cours de chargement ou un rectangle grisé à l’endroit où du texte peut être saisi.</string>
				<key>Title</key>
				<string>vue de paramètre fictif</string>
			</dict>
		</dict>
		<key>prediction</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans le domaine de l’apprentissage automatique, une prédiction est le résultat issu du modèle d’apprentissage automatique lorsqu’on lui donne une entrée. 

Par exemple, un golden retriever peut représenter une prédiction valide d’un modèle d’apprentissage automatique qui a été entraîné à reconnaître différentes races de chiens.</string>
				<key>Title</key>
				<string>prédiction</string>
			</dict>
		</dict>
		<key>private</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le mot-clé private rend le code disponible uniquement au sein de ce fichier source précis.
- callout(Exemple):
`private class MyApp: App { }`</string>
				<key>Title</key>
				<string>privé</string>
			</dict>
		</dict>
		<key>property</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une variable (un conteneur nommé qui stocke une valeur) définie à l’intérieur d’un [type](glossary://type).

Une propriété peut être accessible via une [instance](glossary://instance) du type à l’aide de la [notation par points](glossary://dot%20notation). Dans le code ci-dessous, `isFacingHole` est une propriété du type `Hopper`.
```
if hopper.isFacingHole { 
	// code 
}
```</string>
				<key>Title</key>
				<string>propriété</string>
			</dict>
		</dict>
		<key>property wrapper</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un wrapper de propriété est un moyen simple d’appliquer un pattern commun de comportement à une propriété. Ce wrapper est une manière d’annoter la propriété qui définit de quelle manière elle sera stockée ou calculée à la lecture.   Par exemple, le wrapper de propriété `@State` indique à SwiftUI de gérer le stockage d’une valeur et, dès que cette valeur change, de mettre à jour toute partie d’une vue qui l’utilise.</string>
				<key>Title</key>
				<string>wrapper de propriété</string>
			</dict>
		</dict>
		<key>protocol</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un ensemble d’exigences, telles que des méthodes et des propriétés, qui peuvent être adoptées (ou suivies) par un type, tel qu’une classe, une structure ou une énumération.   Lorsqu’un type adopte un protocole, il fournit sa propre implémentation des exigences du protocole, et il est dit conforme à ce protocole.</string>
				<key>Title</key>
				<string>protocole</string>
			</dict>
		</dict>
		<key>pseudocode</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La description d’un algorithme facile à lire, généralement écrite avec un mélange de langue courante et de code.</string>
				<key>Title</key>
				<string>pseudo-code</string>
			</dict>
		</dict>
		<key>public</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le mot-clé public rend le code disponible pour n’importe quel fichier de ton projet.
                        
- callout(Exemple):
`public func decorateWithSticker(space: Space) { }`
                    </string>
				<key>Title</key>
				<string>public</string>
			</dict>
		</dict>
		<key>publish</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Pour diffuser une notification auprès de tous les [observateurs](glossary://observer) d’un [objet observable](glossary://observable%20object) quand la valeur d’une [propriété publiée](glossary://published%20value) spécifiée change.</string>
				<key>Title</key>
				<string>publier</string>
			</dict>
		</dict>
		<key>published value</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Ajoute le [wrapper de propriété](glossary://property%20wrapper) `@Published` pour déclarer une propriété qui avertit tous les [observateurs](glossary://observer) lorsque sa valeur est sur le point de changer. Lorsque la valeur change, SwiftUI met à jour toutes les vues qui utilisent cette donnée.</string>
				<key>Title</key>
				<string>valeur publiée</string>
			</dict>
		</dict>
		<key>radians</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le radian est une unité de mesure pour les angles, comme les degrés. Lʼangle en radians est égal au ratio entre la longueur de lʼarc et le rayon dʼun cercle dessiné autour de cet angle. Un radian est égal à 180 degrés divisés par [pi](glossary://pi).</string>
				<key>Title</key>
				<string>radians</string>
			</dict>
		</dict>
		<key>range</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un intervalle entre une [limite inférieure](glossary://lower%20bound) et une [limite supérieure](glossary://upper%20bound). 

Il existe plusieurs moyens de créer une plage, y compris une [plage fermée](glossary://closed%20range) et une [plage demi fermée](glossary://half%20open%20range).

```
let closedRange = 1...4 
for i in closedRange { 
	print(i) // 1 2 3 4
}

let halfOpenRange = 1..&lt;4 
for i in halfOpenRange { 
	print(i) // 1 2 3
}
```</string>
				<key>Title</key>
				<string>plage</string>
			</dict>
		</dict>
		<key>reference type</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Quand tu crées une [instance](glossary://instance) d’un type de référence, comme une classe ou un acteur, ses données sont stockées dans la mémoire partagée. En conséquence, l’instance contient uniquement une référence aux données au lieu de sa propre copie unique. Si tu [attribues](glossary://assignment) l’instance à une variable, ou si tu la transmets comme [argument](glossary://argument) à une fonction, Swift crée simplement une autre référence aux même données.

L’instance est copiée par référence, comme indiqué dans l’exemple ci-dessous :

```
class Bicycle {
  var color: Color
   init(color: Color) {
     self.color = color
   }
}

var redBike = Bicycle(color: .red)
var blueBike = redBike
blueBike.color = .blue
print(redBike.color) // =&gt; blue
print(blueBike.color) // =&gt; blue
// redBike et blueBike partagent une référence aux mêmes données
```</string>
				<key>Title</key>
				<string>type de référence</string>
			</dict>
		</dict>
		<key>responsive</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Ton code ou ton interface utilisateur est réactif s’il/elle réagit rapidement à une [interaction utilisateur](glossary://user%20interaction), ou s’adapte de manière appropriée aux changements de son environnement, comme une modification de la taille d’une vue.</string>
				<key>Title</key>
				<string>réactif</string>
			</dict>
		</dict>
		<key>return</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Retourner une valeur à l’appelant d’une [fonction](glossary://function). Par exemple, la fonction `contains(3)`, lorsqu’elle est exécutée sur le tableau `[0,1,2]`, renvoie une valeur booléenne `false`, puisque le tableau ne contient pas la valeur `3`.</string>
				<key>Title</key>
				<string>renvoyer</string>
			</dict>
		</dict>
		<key>return type</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Lorsque tu définis une fonction, tu peux également choisir de définir un type de valeur que la fonction retransmet comme sortie une fois l’opération terminée. On appelle cela son type de renvoi.</string>
				<key>Title</key>
				<string>type de renvoi</string>
			</dict>
		</dict>
		<key>reusability</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une caractéristique du code lui permettant d’être utilisé dans différentes situations au sein d’une application.</string>
				<key>Title</key>
				<string>réutilisabilité</string>
			</dict>
		</dict>
		<key>roll</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Mesure de la rotation ou de lʼinclinaison dʼun appareil vers l’avant et vers l’arrière quand ce dernier est en orientation paysage.   En mathématiques, il sʼagit de la rotation autour de lʼaxe y de lʼappareil. Elle est mesurée en radians et est comprise entre `-π` et `π`.</string>
				<key>Title</key>
				<string>roulis</string>
			</dict>
		</dict>
		<key>root view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une vue dans laquelle sont placées toutes les autres vues. Également appelée [vue au plus haut niveau](glossary://top-level%20view), cette vue se trouve en haut d’une [hiérarchie de vue](glossary://view%20hierarchy) et agit en tant que [vue de conteneur](glossary://container) pour toutes les [sous-vues](glossary://subview) de la hiérarchie.</string>
				<key>Title</key>
				<string>vue racine</string>
			</dict>
		</dict>
		<key>rubber ducky method</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Méthode d’apprentissage dans laquelle tu expliques un concept de manière très détaillée à un objet inanimé, comme un canard en plastique. Pour réaliser cette technique, procure-toi un objet inanimé et commence à lui expliquer le concept à voix haute, en t’assurant d’inclure toutes les informations nécessaires pour que le canard comprenne. Au cours de ton explication, si tu te rends compte qu’il te manque des informations, prends-en note et tu les rechercheras par la suite. Tu peux inclure tes nouvelles découvertes dans les explications ultérieures que tu feras au canard en plastique.</string>
				<key>Title</key>
				<string>méthode du canard en plastique</string>
			</dict>
		</dict>
		<key>saturation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>L’intensité de la teinte, allant d’un ton gris à la couleur réelle. La saturation est un double (nombre décimal) compris entre `0` et `1`.</string>
				<key>Title</key>
				<string>saturation</string>
			</dict>
		</dict>
		<key>scope</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les sections de ton projet à partir desquelles tu peux accéder à une valeur ou à un type. Tandis que les symboles définis à une [portée globale](glossary://global%20scope) sont accessibles par tout fichier du [module](glossary://module), ceux définis à une [portée locale](glossary://local%20scope) sont disponibles dans le code qui est au même niveau ou à un niveau inférieur à la portée locale.</string>
				<key>Title</key>
				<string>portée</string>
			</dict>
		</dict>
		<key>sensor</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un capteur est un appareil qui détecte des évènements, comme une modification de la chaleur, de la lumière, du son ou du mouvement, et renvoie une valeur.</string>
				<key>Title</key>
				<string>capteur</string>
			</dict>
		</dict>
		<key>sequence</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Liste de valeurs que tu peux parcourir une par une, à l’aide d’une [itération](glossary://iteration).

Tu peux utiliser une boucle `for`-`in` pour effectuer une itération sur une séquence telle que le tableau `healthySnacks` dans l’exemple suivant :
```
let healthySnacks = ["apple", "pear", "banana"]
for snack in healthySnacks {
	eat(snack)
}
```</string>
				<key>Title</key>
				<string>séquence</string>
			</dict>
		</dict>
		<key>source of truth</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>En matière de conception d’app, un emplacement unique où toutes les données sont modifiées. Toutes les autres connexions à ces données se font par référence uniquement, ce qui évite la duplication de leurs informations dans d’autres emplacements. </string>
				<key>Title</key>
				<string>source de vérité</string>
			</dict>
		</dict>
		<key>speech synthesis</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Génération par un ordinateur de sons, généralement à partir de texte, qui ressemblent à un discours humain.</string>
				<key>Title</key>
				<string>synthèse de la parole</string>
			</dict>
		</dict>
		<key>state</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les informations stockées dans une variable, une application ou un système à un moment donné. Par exemple, si une variable `level` contient une valeur de `4`, son état actuel est `4`.</string>
				<key>Title</key>
				<string>état</string>
			</dict>
		</dict>
		<key>state change</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Modification des informations stockées dans une variable, une application ou un système. Par exemple, si la valeur de la variable `level` passe de `4` à `5`, son état a changé.</string>
				<key>Title</key>
				<string>modification d’état</string>
			</dict>
		</dict>
		<key>state object</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Ajoute le [wrapper de propriété](glossary://property%20wrapper) `@StateObject` pour déclarer un objet d’état et fournis une valeur initiale conforme au [protocole](glossary://protocol) `ObservableObject`. SwiftUI gère le stockage pour un objet d’état et met à jour toutes les sous-vues qui utilisent la valeur chaque fois que ses valeurs publiées changent.</string>
				<key>Title</key>
				<string>objet d’état</string>
			</dict>
		</dict>
		<key>state property</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Ajoute `@State` avant une [propriété](glossary://property) d’une vue pour indiquer à SwiftUI de gérer le stockage d’une valeur. Lorsque la valeur change, SwiftUI met à jour toute partie de la vue qui utilise la valeur.

```
@State var isOn = false
```
</string>
				<key>Title</key>
				<string>propriété d’état</string>
			</dict>
		</dict>
		<key>state value</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Ajoute `@State` avant une variable pour indiquer à SwiftUI de gérer le stockage d’une valeur. Lorsque la valeur change, SwiftUI met à jour toute partie de la vue qui utilise la valeur.</string>
				<key>Title</key>
				<string>valeur d’état</string>
			</dict>
		</dict>
		<key>statement</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une structure, comme une boucle ou une instruction `if`, qui organise le code dans une application.</string>
				<key>Title</key>
				<string>instruction</string>
			</dict>
		</dict>
		<key>string component</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une partie (ou sous-chaîne) d’une chaîne, après que la chaîne a été divisée par un séparateur. Par exemple, si la chaîne `"chien+chat+poisson"` est divisée par un séparateur `"+"`, les composants créés seront les chaînes `"chien"`, `"chat"` et `"poisson"`.</string>
				<key>Title</key>
				<string>composant de chaîne</string>
			</dict>
		</dict>
		<key>string concatenation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le regroupement de chaînes en les ajoutant les unes à la suite des autres. Par exemple, la concaténation de `«foot»` et `«ball»` est `«football»`.</string>
				<key>Title</key>
				<string>concaténation de chaîne</string>
			</dict>
		</dict>
		<key>string interpolation</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>L’utilisation de constantes, de variables ou d’expressions de code dans une chaîne plus longue, à remplacer par leurs valeurs réelles lors de l’évaluation de la chaîne. Par exemple, dans la chaîne `"Lili a mangé un \(fruit)."`, si `fruit` est une variable dont la valeur correspond à `"pêche"`, alors `\(fruit)` est remplacé par `"pêche"` lors de l’évaluation de la chaîne. Celle-ci devient `"Lili a mangé une pêche."`</string>
				<key>Title</key>
				<string>interpolation de chaîne</string>
			</dict>
		</dict>
		<key>structure</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une structure est un conteneur pour du code qui se comporte comme un modèle permettant de créer plusieurs [instances](glossary://instance) du même type d’élément. De la même façon qu’un modèle peut définir les fonctionnalités et les comportements d’un objet, comme une bicyclette, une structure les définit comme étant des [propriétés](glossary://property) et des [méthodes](glossary://method).

Quand tu crées une instance de la structure, elle contient toutes les propriétés et les méthodes définies dans ton modèle. Chaque instance partage les mêmes propriétés et méthodes, mais les valeurs de ses propriétés peuvent être changées de façon indépendante, ce qui te permet de personnaliser chaque instance que tu crées, ou instancies, depuis la structure. Par exemple, la structure d’une bicyclette peut posséder une propriété de couleur, ce qui te permet de créer des bicyclettes rouges et bleues.

Une structure est similaire à une [classe](glossary://class), mais diffère en deux aspects importants : une structure est un [type de valeur](glossary://value%20type), c’est-à-dire qu’elle est toujours copiée par valeur ; une structure ne peut pas hériter d’une autre structure.

```
struct Bicycle { 
	var color : Color 
	var type : BikeCategory
}
```</string>
				<key>Title</key>
				<string>structure</string>
			</dict>
		</dict>
		<key>subview</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une vue qui est contenue dans une vue de [conteneur](glossary://container). Un conteneur peut disposer d’un nombre illimité de sous-vues, chacune d’elle pouvant contenir ses propres sous-vues, et ainsi de suite. Une vue et l’ensemble de ses descendants constituent une [hiérarchie de vue](glossary://view%20hierarchy).</string>
				<key>Title</key>
				<string>sous-vue</string>
			</dict>
		</dict>
		<key>syntax</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les règles pour l’écriture de code que les ordinateurs peuvent comprendre et exécuter.</string>
				<key>Title</key>
				<string>syntaxe</string>
			</dict>
		</dict>
		<key>task</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les tâches sont utiles pour gérer des unités de travail distinctes dans ton app, de sorte que ton code puisse continuer à réaliser des choses importantes, comme la gestion de l’IU. Lorsque tu crées une tâche, elle exécute son code de manière [asynchrone](glossary://asynchronous%20process) dans le cadre de ton programme. Cela permet au reste de ton code de s’occuper d’autres choses. Les parties de ton code qui ont besoin des données de cette tâche peuvent `await` le résultats de la tâche.</string>
				<key>Title</key>
				<string>tâche</string>
			</dict>
		</dict>
		<key>ternary conditional operator</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une manière abrégée spéciale de rédiger une instruction conditionnelle. L’[opérateur](glossary://operator) est composé de trois parties et prend la forme `condition ? trueValue : falseValue`. C’est comme une [instruction `if`](glossary://if%20statement), qui renvoie `trueValue` si la `condition` est `true` et si `falseValue` est `false`. 

In the code below, if `isOn` is `true` the rectangle will be green. If `isOn` is `false`, the rectangle will be red.

```
Rectangle()
     .foregroundColor(isOn ? .green : .red)
```

The code above can be read as: if the value `isOn` is `true`, return the value `.green`, otherwise, return the value `.red`.
</string>
				<key>Title</key>
				<string>opérateur conditionnel ternaire</string>
			</dict>
		</dict>
		<key>toolbar</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une bande d’icônes servant à effectuer certaines fonctions. Tu peux fournir l’ensemble des éléments de barres d’outils dont le modificateur de barre d’outils a besoin en ajoutant une collection de vues.</string>
				<key>Title</key>
				<string>barre d’outils</string>
			</dict>
		</dict>
		<key>top-level view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une vue dans laquelle sont placées toutes les autres vues. Également appelée [vue racine](glossary://root%20view), cette vue se trouve en haut d’une [hiérarchie de vue](glossary://view%20hierarchy) et agit en tant que [vue de conteneur](glossary://container) pour toutes les [sous-vues](glossary://subview) de la hiérarchie.</string>
				<key>Title</key>
				<string>vue au plus haut niveau</string>
			</dict>
		</dict>
		<key>trailing edge</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le bord arrière, lorsque ce terme est utilisé en référence au contenu d’une vue, fait référence à la position horizontale de la fin du contenu. La position du bord arrière dépend de tes préférences, et est généralement fondée sur tes paramètres régionaux et linguistiques.
                    Par exemple, avec les langues qui sont lues de gauche à droite, telles que l’anglais et le français, le bord arrière se trouve à droite. Avec les langues qui se lisent de droite à gauche, telles que l’arabe ou l’hébreu, le bord arrière est situé à gauche.</string>
				<key>Title</key>
				<string>bord arrière</string>
			</dict>
		</dict>
		<key>training</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans le domaine de l’apprentissage automatique, un processus pendant lequel un algorithme d’apprentissage automatique apprend à partir dʼun ensemble de données. 

Lors de l’entraînement supervisé, le modèle tente de créer la relation mathématique la plus précise possible entre les fonctionnalités des données et l’étiquette de ces données. Lors de l’entraînement non supervisé, le modèle tente de trouver la relation entre les fonctionnalités des données elle-mêmes.</string>
				<key>Title</key>
				<string>entraînement</string>
			</dict>
		</dict>
		<key>training dataset</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La collection de données avec lequel un modèle d’apprentissage automatique s’[entraîne](glossary://training) pour générer ses [prédictions](glossary://prediction).</string>
				<key>Title</key>
				<string>ensemble de données d’apprentissage</string>
			</dict>
		</dict>
		<key>type</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un regroupement nommé de propriétés (les fonctionnalités) et de méthodes (les comportements) d’un type de données.

Un type est un moyen de créer un ensemble de fonctionnalités connexes afin d’y accéder plus facilement.

```
struct Person { 
	var name : Int
	var age : String 

	func greet() { 
		print("Hello, friend!")
	}
}
```</string>
				<key>Title</key>
				<string>type</string>
			</dict>
		</dict>
		<key>typography</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>L’art et la technique d’arranger les caractères pour que la langue écrite soit lisible et agréable à l’œil une fois à l’écran.</string>
				<key>Title</key>
				<string>typographie</string>
			</dict>
		</dict>
		<key>unwrap</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Extraire la valeur enveloppée d’une [instance](glossary://instance) d’un type [facultatif](glossary://optional). 
				
Une manière fréquente de ne plus envelopper la valeur dans un type facultatif est d’utiliser `if`-`let` :
```
var count: Int? = 48
if let unwrappedCount = count {
	print(unwrappedCount)
} else {
	print("count has no value")
}
```</string>
				<key>Title</key>
				<string>ne plus envelopper</string>
			</dict>
		</dict>
		<key>upper bound</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Dans une [plage](glossary://range%20value), la valeur finale depuis laquelle le décompte est effectué.

```
let closedRange = 1...5 // La limite inférieure est 1, la limite supérieure est 5
for i in closedRange { 
	print(i) // 1 2 3 4 5
}
```</string>
				<key>Title</key>
				<string>limite supérieure</string>
			</dict>
		</dict>
		<key>user</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Quelqu’un qui utilise ton app.</string>
				<key>Title</key>
				<string>utilisateur</string>
			</dict>
		</dict>
		<key>user input</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les informations qu’une application obtient de son interaction avec l’utilisateur, comme quand celui-ci touche l’écran, saisit du texte sur le clavier ou parle dans le micro. 
</string>
				<key>Title</key>
				<string>saisie utilisateur</string>
			</dict>
		</dict>
		<key>user interaction</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Action effectuée par un [utilisateur](glossary://user) à l’aide de ton app. Appuyer sur un bouton, balayer l’écran vers la gauche, faire pivoter l’appareil, choisir une couleur dans un `ColorPicker` et saisir des caractères dans un champ de texte sont des exemples d’interaction utilisateur.</string>
				<key>Title</key>
				<string>interaction utilisateur</string>
			</dict>
		</dict>
		<key>user interface</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Les moyens dont un utilisateur dispose pour contrôler une app. Également appelé « IU », ce terme est souvent utilisé pour décrire la portion visuelle d’une app avec laquelle l’utilisateur interagit. Elle comporte des éléments tels que des images, du texte, des boutons, des curseurs, des vues défilantes et plus encore.</string>
				<key>Title</key>
				<string>interface utilisateur</string>
			</dict>
		</dict>
		<key>validation dataset</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un exemple de données non incluses dans l’[ensemble de données d’apprentissage](glossary://training%20dataset) du modèle d’apprentissage de ta machine. Le modèle utilise l’ensemble de données de validation pour évaluer la précision de ses prédictions.</string>
				<key>Title</key>
				<string>ensemble de données de validation</string>
			</dict>
		</dict>
		<key>value type</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Quand tu crées une [instance](glossary://instance) d’un type de valeur, comme une [structure](glossary://structure), ses données sont stockées dans l’instance elle-même. Si tu [attribues](glossary://assignment) l’instance à une variable ou la transmets comme [argument](glossary://argument) à une fonction, Swift crée une nouvelle instance avec une copie indépendante de données.

L’instance est copiée par valeur, comme décrit dans l’exemple ci-dessous :

```
struct Bicycle {
  var color: Color
}

var redBike = Bicycle(color: .red)
var blueBike = redBike
blueBike.color = .blue
print(redBike.color) // =&gt; red
print(blueBike.color) // =&gt; blue
// redBike et blueBike possèdent chacun leur propre copie des données
```</string>
				<key>Title</key>
				<string>type de valeur</string>
			</dict>
		</dict>
		<key>variable</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un conteneur nommé qui stocke une valeur pouvant être modifiée.

Une variable peut stocker différents [types](glossary://type) de valeurs, comme des [nombres entiers](glossary://Int), des [chaînes](glossary://String) et des [plages](glossary://range).  
```
var favoriteNumber = 7 // Stocke un nombre entier
var greeting = "Hello" // Stocke une chaîne
var repetitions = 1...5 // Stocke une plage
```
</string>
				<key>Title</key>
				<string>variable</string>
			</dict>
		</dict>
		<key>velocity</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>La vitesse d’un élément dans une direction donnée.</string>
				<key>Title</key>
				<string>vélocité</string>
			</dict>
		</dict>
		<key>view</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une vue est la composante de base de l’interface utilisateur de ton app, et représente tout élément visuel [conforme](glossary://conform) au [protocole](glossary://protocol) `View`.

Quelques exemples de vues dans SwiftUI sont les vues de texte, les vues d’image, les curseurs, les grilles, les boutons et les formes.</string>
				<key>Title</key>
				<string>vue</string>
			</dict>
		</dict>
		<key>view hierarchy</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Une structure qui définit la disposition des vues par rapport aux autres vues, avec une référence à une instance de la vue au plus haut niveau en haut de la hiérarchie. La vue au plus haut niveau peut contenir un nombre illimité de sous-vues, dont chacune peut contenir ses propres sous-vues, et ainsi de suite.</string>
				<key>Title</key>
				<string>hiérarchie de vue</string>
			</dict>
		</dict>
		<key>volume</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Volume correspond au niveau sonore du son détecté par le [capteur](glossary://sensor). Il est compris entre 0 et 1.</string>
				<key>Title</key>
				<string>volume</string>
			</dict>
		</dict>
		<key>while loop</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Un bloc de code qui s’exécute tant qu’une condition indiquée est `true`. Lorsqu’une condition devient `false`, la boucle ne s’exécute plus.</string>
				<key>Title</key>
				<string>boucle while</string>
			</dict>
		</dict>
		<key>wireframe</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Le contour d’un élément du monde en puzzle, comme une gemme, un interrupteur ou un bloc. Un fil de fer indique la possibilité que l’élément pourrait apparaître de manière aléatoire chaque fois que l’on exécute le puzzle.</string>
				<key>Title</key>
				<string>fil de fer</string>
			</dict>
		</dict>
		<key>yaw</key>
		<dict>
			<key>_LOCALIZABLE_</key>
			<dict>
				<key>Definition</key>
				<string>Mesure de la rotation autour du point central d’un appareil qui est posé sur une surface plane.   En mathématiques, il sʼagit de la rotation autour de lʼaxe z de lʼappareil. Elle est mesurée en radians et est comprise entre `-π` et `π`.</string>
				<key>Title</key>
				<string>lacet</string>
			</dict>
		</dict>
	</dict>
</dict>
</plist>
