added shadowing, scope, ...

variables.md

@@ -35,7 +35,6 @@ height:
 - Pour *déclarer* une variable il faut utiliser la forme:
 	
 	`let symbole = valeur`{.rust}.
-
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let x = 5; // entier 32 bits
@@ -45,12 +44,10 @@ fn main() {
     println!("La valeur de y est: {}", y); // affichage
 }
 </code></pre>
-
 - En rust le type d'une variable est **inféré** (quand c'est possible).
 - Sinon il faut le donner explicitement:
 
 	`let symbole: type = valeur`{.rust}.
-
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let x: i32 = 5; // entier 32 bits
@@ -58,26 +55,31 @@ fn main() {
 }
 </code></pre>
 
-## Quelques règles
+## Quelques règles (1/2)
 
 - Les mot-clés du langage sont interdits pour nommer les variables.
-
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let if = 7;
 }
 </code></pre>
-
-- Une variable ne peut pas être utilisée si elle n'est pas déclarée.
-
+- Une variable ne peut pas être utilisée si elle n'est pas *déclarée*.
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     println!("La valeur de x est: {}", x); // affichage
 }
 </code></pre>
 
-- On peut déclarer une variable, puis l'initialiser.
+## Quelques règles (2/2)
 
+- Une variable ne peut pas être utilisée si elle n'est pas *initialisée*.
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let x: i32;
+    println!("La valeur de x est: {}", x); // affichage
+}
+</code></pre>
+- On peut déclarer une variable, puis l'initialiser en 2 étapes.
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let x; // Déclaration
@@ -89,17 +91,51 @@ fn main() {
 }
 </code></pre>
 
-- On peut explicit
+## Portée (1/2)
+
+- La portée d'une variable est le *bloc* dans lequel elle est déclarée (et tous les blocs inclus).
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let x = 5; 
+    {
+        println!("La valeur de x est: {}", x);
+    }
+}
+</code></pre>
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    {
+        let x = 5; 
+        println!("La valeur de x est: {}", x);
+    }
+
+    println!("La valeur de x est: {}", x);
+}
+</code></pre>
+
+## Portée (2/2)
+
+- En redéclarant une variable dans un bloc intérieur on peut **masquer** la variable extérieure.
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let x = 1000; 
+    {
+        let x = 5; 
+        println!("La valeur de x est: {}", x);
+    }
+
+    println!("La valeur de x est: {}", x);
+}
+</code></pre>
 
 ## Mutabilité/**Immutabilité**
 
 - Les variables sont **immutables** par défaut.
 - Une variable immutable **ne peut pas** être modifiée.
 - Si on essaie le compilateur refuser de compiler le programme.
-
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
-    let x = 5; // 
+    let x = 5;
     println!("La valeur de x est: {}", x);
 
     x = 6;
@@ -111,10 +147,8 @@ fn main() {
 
 - Pour rendre une variable **mutable** il faut utilise la forme:
 
- `let mut symbole = valeur`{.rust}.
-
+    `let mut symbole = valeur`{.rust}.
 - Une variable mutable **peut** être modifiée.
-
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let mut x = 5;
@@ -130,7 +164,37 @@ fn main() {
 - Les variables immutables ressemblent aux *constantes*.
 - On les déclare avec la forme:
 
-`const SYMBOLE: type = valeur;`{.rust}
-
+    `const SYMBOLE: type = valeur;`{.rust}
 - Plusieurs différences notables:
-	1. On ne peut pas utiliser `mut`{.rust}
+	1. On ne peut pas utiliser `mut`{.rust}
\ No newline at end of file
+    2. On doit explicitement déclarer le *type* d'une constante.
+    3. La valeur d'une constante doit être déterminée à la compilation.
+    4. Valides durant toute la durée d'un programme.
+<pre><code data-trim="hljs rust" class="lang-rust">
+const PI: f64 = 3.14159265359;
+fn main() {
+    println!("La valeur de pi est: {}", PI);
+}
+</code></pre>
+
+## Masquage
+
+- Possibilité de déclarer une variable avec le même nom qu'une variable précédente.
+- La nouvelle déclaration **masque** la précédente.
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let x = 5;
+    let x = x + 1;
+    println!("La valeur de x est: {}", x);
+}
+</code></pre>
+- La nouvelle variable n'a pas forcément le même type que la variable d'origine.
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let x = "La variable d'origine";
+    println!("La valeur de x est: {}", x);
+    let x = x.len();
+    println!("La valeur de x est: {}", x);
+}
+</code></pre>
+