# Déclaration de Variables > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/lo69pCHl8H8?si=qL0AU4TDCx-36rRH" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## Introduction En algorithmique, la manipulation de données est fondamentale. Pour stocker et référencer ces données de manière efficace, nous utilisons des **variables**. Alors que les algorigrammes représentent le flux logique et les opérations sur les données, les variables sont les conteneurs concrets qui permettent de matérialiser ces données au sein d'un algorithme exécutable. Ce chapitre introduit le concept de variable, ses attributs essentiels et les règles de sa déclaration. ## 1. Qu'est-ce qu'une Variable ? > [!definition] Définition > Une **variable** est un emplacement nommé dans la mémoire de l'ordinateur, utilisé pour stocker une valeur qui peut être modifiée au cours de l'exécution d'un algorithme. Chaque variable possède un **nom**, un **type** et une **valeur**. - **Nom** : Un identifiant unique permettant de référencer la variable. - **Type** : Définit la nature des données que la variable peut stocker (nombre entier, texte, etc.) et les opérations qui peuvent être effectuées sur elle. - **Valeur** : La donnée actuellement stockée dans la variable. Cette valeur peut changer. ## 2. Types de Données Fondamentaux Le type d'une variable est crucial car il détermine l'espace mémoire alloué et les opérations permises. > [!note] Remarque > La *Logique Combinatoire* est un prérequis essentiel pour comprendre le type booléen, qui représente des états logiques VRAI ou FAUX. Voici les types de données les plus courants en algorithmique : - **Entier (Integer)** : Représente les nombres entiers, positifs ou négatifs, sans partie décimale. - *Exemple mathématique* : $x \in \mathbb{Z}$ - *Pseudo-code typique* : `ENTIER` - **Réel (Float/Real)** : Représente les nombres à virgule flottante, permettant de stocker des valeurs avec une partie décimale. - *Exemple mathématique* : $y \in \mathbb{R}$ - *Pseudo-code typique* : `RÉEL` - **Caractère (Character)** : Représente un seul caractère (lettre, chiffre, symbole). - *Pseudo-code typique* : `CARACTÈRE` - **Chaîne de caractères (String)** : Représente une séquence de caractères. - *Pseudo-code typique* : `CHAÎNE` - **Booléen (Boolean)** : Représente une valeur logique qui ne peut être que `VRAI` (True) ou `FAUX` (False). Essentiel pour les conditions et les boucles. - *Pseudo-code typique* : `BOOLÉEN` > [!tip] Astuce > En programmation, d'autres types plus complexes (tableaux, structures, objets) existent, mais les types fondamentaux ci-dessus sont la base de toute manipulation de données. ## 3. Déclaration et Initialisation La **déclaration** d'une variable est l'acte de la nommer et de lui attribuer un type avant de l'utiliser. L'**initialisation** consiste à lui donner une première valeur. ### 3.1. Syntaxe de Déclaration (Pseudo-code) La syntaxe peut varier, mais une forme courante est : ``` nom_variable DE TYPE TypeDeDonnée ``` Ou parfois : ``` TypeDeDonnée nom_variable ``` > [!example] Exemple de déclaration > ``` > age DE TYPE ENTIER > prix_unitaire DE TYPE RÉEL > prenom DE TYPE CHAÎNE > est_majeur DE TYPE BOOLÉEN > ``` ### 3.2. Initialisation Il est fortement recommandé d'initialiser une variable dès sa déclaration ou juste après, pour éviter d'utiliser une valeur indéfinie (souvent appelée "valeur aléatoire" ou "garbage value"). ``` nom_variable DE TYPE TypeDeDonnée nom_variable <- valeur_initiale ``` Ou combiné : ``` nom_variable DE TYPE TypeDeDonnée <- valeur_initiale ``` > [!example] Exemple d'initialisation > ``` > compteur DE TYPE ENTIER <- 0 > temperature DE TYPE RÉEL <- 25.5 > message DE TYPE CHAÎNE <- "Bonjour le monde" > est_active DE TYPE BOOLÉEN <- VRAI > ``` > [!warning] Attention > Tenter d'utiliser une variable non déclarée ou non initialisée peut entraîner des erreurs d'exécution ou des comportements imprévus de l'algorithme. ## 4. Règles de Nommage des Variables Pour garantir la clarté et la maintenabilité de l'algorithme, des règles et conventions de nommage doivent être suivies : - **Caractères autorisés** : Généralement des lettres (a-z, A-Z), des chiffres (0-9) et le tiret bas (`_`). - **Premier caractère** : Doit être une lettre ou un tiret bas (jamais un chiffre). - **Interdictions** : Les espaces, les caractères spéciaux ($, #, %, &, etc.) et les mots-clés réservés du langage (ex: `SI`, `ALORS`, `FIN_SI`) sont interdits. - **Sens sémantique** : Le nom doit être explicite et refléter le rôle de la variable. - *Bon exemple* : `nombre_etudiants`, `total_ventes` - *Mauvais exemple* : `x`, `truc` (sauf pour des compteurs très simples comme `i`, `j` dans des boucles courtes) - **Convention de casse** : - `camelCase` (ex: `monCompteur`) - `snake_case` (ex: `mon_compteur`) - Ces conventions varient selon les langages de programmation (par exemple, Python préfère `snake_case`). ## 5. Portée des Variables La **portée** d'une variable définit les parties de l'algorithme où elle est accessible et utilisable. - **Variable locale** : Déclarée à l'intérieur d'un bloc spécifique (ex: une fonction, une procédure). Elle n'est accessible qu'à l'intérieur de ce bloc. - **Variable globale** : Déclarée au niveau de l'algorithme principal. Elle est accessible depuis n'importe quelle partie de l'algorithme. > [!note] Remarque > L'utilisation excessive de variables globales est souvent déconseillée car elle peut rendre l'algorithme plus difficile à comprendre et à déboguer. Nous reviendrons sur ce concept plus en détail lors de l'étude des fonctions et procédures. ## Résumé La déclaration de variables est une étape fondamentale en algorithmique. Elle permet de : - **Réserver un espace mémoire** pour stocker des données. - **Définir le type** de données que la variable peut contenir. - **Nommer** cet espace pour le référencer facilement. Comprendre les types de données, les règles de déclaration et de nommage est crucial pour écrire des algorithmes clairs, corrects et efficaces. Ces concepts serviront de base solide pour l'apprentissage de langages de programmation spécifiques comme Python, où la syntaxe et les mécanismes de typage seront appliqués concrètement. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]