Correction des erreurs
This commit is contained in:
parent
be535bc8c0
commit
9d7aeb3116
@ -4,7 +4,7 @@
|
|||||||
|
|
||||||
Le terme de **constante** vient, tout comme le celui de [variable](./Variables.md), des mathématiques. Les *constantes* sont des éléments qui peuvent contenir une valeur, à la différence des *variables*, les *constantes* ne change **JAMAIS** de valeur. On les retrouve essentiellement dans les sciences naturelles tel qu'en physique avec la [constante d'Avogadro](https://fr.wikipedia.org/wiki/Nombre_d%27Avogadro "wikipedia.org").
|
Le terme de **constante** vient, tout comme le celui de [variable](./Variables.md), des mathématiques. Les *constantes* sont des éléments qui peuvent contenir une valeur, à la différence des *variables*, les *constantes* ne change **JAMAIS** de valeur. On les retrouve essentiellement dans les sciences naturelles tel qu'en physique avec la [constante d'Avogadro](https://fr.wikipedia.org/wiki/Nombre_d%27Avogadro "wikipedia.org").
|
||||||
|
|
||||||
En développement, nous utilisons également les *constantes* dans certains programmes. Elles se basent sur les mêmes principes de fonctionnement, tel que le fait qu'elles **ne peuvent pas changer de valeur** durant l'exécution. Si dans un programme, vous essayez de changer la valeur d'une constante (*Ce qui, pour rappel, n'est pas valide*), le programme s'arrêtera et renverra une [erreur](/ "Erreurs").
|
En développement, nous utilisons également les *constantes* dans certains programmes. Elles se basent sur les mêmes principes de fonctionnement, tel que le fait qu'elles **ne peuvent pas changer de valeur** durant l'exécution. Si dans un programme, vous essayez de changer la valeur d'une constante (*Ce qui, pour rappel, n'est pas valide*), le programme s'arrêtera et renverra une [erreur](../Chapter_6/README.md "Erreurs").
|
||||||
|
|
||||||
### Comment déclarer une constante ?
|
### Comment déclarer une constante ?
|
||||||
|
|
||||||
|
|||||||
@ -23,13 +23,13 @@ let arr = [1, 2, 3];
|
|||||||
let str1, str2, str3;
|
let str1, str2, str3;
|
||||||
```
|
```
|
||||||
|
|
||||||
La déclaration de variable en <img src="../../../assets/img/js.png" width="20px"> **javascript** est très simple, comme vous pouvez le voir dans la **1ere** ligne, pour déclarer il vous faudra respecter un syntaxe précise.
|
La déclaration de variable en <img src="../../../assets/img/js.png" width="20px"> **javascript** est très simple, comme vous pouvez le voir dans la **1ere** ligne, pour déclarer il vous faudra respecter une syntaxe précise.
|
||||||
|
|
||||||
> Premièrement, un **mot-clé** est présent en <u>_début de ligne_</u>, il est là pour préciser l'action que nous faisons, dans le cas présent déclarer une variable. Ici, nous avons **`let`** et **`var`** qui sont les mots-clés valide. Pour aller plus loin vous pouvez voir la [différence entre let et var](#diff-let-var) à la fin.
|
> Premièrement, un **mot-clé** est présent en <u>_début de ligne_</u>, il est là pour préciser l'action que nous faisons, dans le cas présent déclarer une variable. Ici, nous avons **`let`** et **`var`** qui sont les mots-clés valides. Pour aller plus loin vous pouvez voir la [différence entre let et var](#diff-let-var) à la fin.
|
||||||
|
|
||||||
> En second temps, nous pouvons voir **`nomVariable`**, celui-ci est libre, tant qu'il *respect quelques règles*. Une variable <u>n'accepte pas les espaces</u>. Elle doivent <u>commencer uniquement par un `lettre`, `$` ou</u> `_`. Sans oublier qu'elle doit être <u>unique</u>
|
> En second temps, nous pouvons voir **`nomVariable`**, celui-ci est libre, tant qu'il *respect quelques règles*. Une variable <u>n'accepte pas les espaces</u>. Elle doivent <u>commencer uniquement par un `lettre`, `$` ou</u> `_`. Sans oublier qu'elle doit être <u>unique</u>
|
||||||
|
|
||||||
> Ensuite, vous avez le choix **d'attribuer une valeur** ou non. Si vous *souhaitez attribuer* une valeur, un simple `=` permet de dire que l'on assigne une valeur à la variable, suivi de la valeur, dépendante du [type de données](../../../../Types.md) souhaité. Si vous *ne souhaitez pas assigner* de valeur dans l'immédiat vous pouvez simplement passé à la ligne suivante de votre programme.
|
> Ensuite, vous avez le choix **d'attribuer une valeur** ou non. Si vous *souhaitez attribuer* une valeur, un simple `=` permet de dire que l'on assigne une valeur à la variable, suivi de la valeur, dépendante du [type de données](../../Types.md) souhaité. Si vous *ne souhaitez pas assigner* de valeur dans l'immédiat vous pouvez simplement passé à la ligne suivante de votre programme.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
@ -53,10 +53,6 @@ En <img src="../../../assets/img/js.png" width="20px"> **javascript**, nous avon
|
|||||||
|
|
||||||
> Pour finir, vous devez **atribuer une valeur** cela se fait après le symbole **`=`** et devez vous baser sur les [types de données](../../../../Types.md) pour choisir la valeur que vous souhaitez utiliser.
|
> Pour finir, vous devez **atribuer une valeur** cela se fait après le symbole **`=`** et devez vous baser sur les [types de données](../../../../Types.md) pour choisir la valeur que vous souhaitez utiliser.
|
||||||
|
|
||||||
Vous pouvez aller voir des [exemples](./constantes.js), pour mieux comprendre leur utilisation et subilités.
|
|
||||||
|
|
||||||
Félictation, vous savez dès à présent déclarer des constantes en **javascript**. Vous pouvez réaliser les [exercices]() suivant afin de vous entrainer et vérifier que vous avez bien compris les notions.
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
#### Différence `var` vs `let`<a name="diff-var-let"></a>
|
#### Différence `var` vs `let`<a name="diff-var-let"></a>
|
||||||
@ -65,5 +61,3 @@ Comme vous avez pu le constater, il existe deux **mots-clés** pour déclarer un
|
|||||||
|
|
||||||
La **porté** ou **scope** de **`let`** est une porté de bloc, c'est à dire que la variable est accessible uniquement dans le bloc de code dans lequel elle est déclarée.
|
La **porté** ou **scope** de **`let`** est une porté de bloc, c'est à dire que la variable est accessible uniquement dans le bloc de code dans lequel elle est déclarée.
|
||||||
À la différence du **`var`**, qui lui a un **scope** de fonction, autrement dit, la variable peut être appelé dans toute la fonction dans laquelle elle est déclarée.
|
À la différence du **`var`**, qui lui a un **scope** de fonction, autrement dit, la variable peut être appelé dans toute la fonction dans laquelle elle est déclarée.
|
||||||
|
|
||||||
Pour les exemples vous pouvez vous rendre dans le [fichier variables.js](./variables.js)
|
|
||||||
@ -20,15 +20,14 @@ $bool = true;
|
|||||||
$arr = [1, 2, 3];
|
$arr = [1, 2, 3];
|
||||||
```
|
```
|
||||||
|
|
||||||
La déclaration de variable en <img src="../../../assets/img/PHP.png" width="30px"> **Php** est très simple, comme le montre la **1ere** ligne, pour déclarer une variable il faudrat suivre des règles spécifique.
|
La déclaration de variable en <img src="../../../assets/img/PHP.png" width="30px"> **Php** est très simple, comme le montre la **1ere** ligne, pour déclarer une variable il vous faudra suivre des règles spécifiques.
|
||||||
|
|
||||||
> Premièrement, nous avons le symbole **`$`** qui est la pour initialiser la déclaration.
|
> Premièrement, nous avons le symbole **`$`** qui est la pour initialiser la déclaration.
|
||||||
|
|
||||||
> Ensuite il faut directement indiquer le **nom de variable**, ce dernier doit respecter les éléments suivant, <u>ne commence pas par un chiffre</u>, <u>doit commencer par `$`</u>, <u>peut contenir uniquement des valeurs [alphanumérique](https://www.larousse.fr/dictionnaires/francais/alphanum%C3%A9rique/2523 "Larousse.fr")</u>. Les noms de variables sont sensibles à la casse, c'est à dire que les noms de variables peuvent prendre de majuscule ou non. Vu qu'un exemple vaut mieux que mille mots : `$age` et `$Age` sont des **variables différentes**, car leurs syntaxe et sensiblement différente (*pas de majuscule et majuscule au début*). N'omettons pas le fait que le nom de variables doit être <u>unique</u>.
|
> Ensuite il faut directement indiquer le **nom de variable**, ce dernier doit respecter les éléments suivant, <u>ne commence pas par un chiffre</u>, <u>doit commencer par `$`</u>, <u>peut contenir uniquement des valeurs [alphanumérique](https://www.larousse.fr/dictionnaires/francais/alphanum%C3%A9rique/2523 "Larousse.fr")</u>. Les noms de variables sont sensibles à la casse, c'est à dire que les noms de variables peuvent prendre de majuscule ou non. Vu qu'un exemple vaut mieux que mille mots : `$age` et `$Age` sont des **variables différentes**, car leur syntaxe et sensiblement différente (*pas de majuscule et majuscule au début*). N'omettons pas le fait que le nom de variable doit être <u>unique</u>.
|
||||||
|
|
||||||
> Pour finir, il faut **attribuer une valeur** à la variable. Pour cela, rien de plus simple, mettez le symbole **`=`** et ensuite indiquez la valeur que vous souhaitez donnée à la variable. Pour faire cela, basez-vous sur les [types de données](./../../../Types.md).
|
> Pour finir, il faut **attribuer une valeur** à la variable. Pour cela, rien de plus simple, mettez le symbole **`=`** et ensuite indiquez la valeur que vous souhaitez donnée à la variable. Pour faire cela, basez-vous sur les [types de données](./../../../Types.md).
|
||||||
|
|
||||||
Vous connaissez désormais la façon pour déclarer une variable en php, pour des exemples plus approfondi, rendez-vous [ici](./variables.php).
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
@ -46,6 +45,4 @@ define(Arr, ["valeur1", "valeur2", "valeur3"]);
|
|||||||
|
|
||||||
Le <img src="../../../assets/img/PHP.png" width="30px"> **php** permet l'utilisation de constantes et leur syntaxe est différente de celle des variables. Vous pouvez apercevoir la structure de la déclaration en **1ere** ligne de l'exemple.
|
Le <img src="../../../assets/img/PHP.png" width="30px"> **php** permet l'utilisation de constantes et leur syntaxe est différente de celle des variables. Vous pouvez apercevoir la structure de la déclaration en **1ere** ligne de l'exemple.
|
||||||
|
|
||||||
> La déclaration se passe dans le fonction **`define()`**, la fonction prend en *premier paramètre* le **nom de constante** qui doit respecter les mêmes règles les [variables](#example-variables). En *second paramètre*, vous mettrais la valeur que vous souhaitez **attribuer** à la constantes.
|
> La déclaration se passe dans le fonction **`define()`**, la fonction prend en *premier paramètre* le **nom de constante** qui doit respecter les mêmes règles les [variables](#example-variables). En *second paramètre*, vous mettrais la valeur que vous souhaitez **attribuer** à la constante.
|
||||||
|
|
||||||
Pour plus d'exemples sur les constantes, vous pouvez vous rendre sur les [exemples en code](./constantes.php).
|
|
||||||
@ -7,9 +7,9 @@
|
|||||||
</details>
|
</details>
|
||||||
<br>
|
<br>
|
||||||
|
|
||||||
> Dans ce chapitre, nous verrons les principes de bases pour comprendre la manipulation de donnée, en programmation. Nous **ne toucherons pas** aux [bases de données](https://fr.wikipedia.org/wiki/Base_de_donn%C3%A9es "Wikipédia.org") ici. Nous verrons simplement les éléments importants pour bien commencer.
|
> Dans ce chapitre, nous verrons les principes de bases pour comprendre la manipulation de données, en programmation. Nous **ne toucherons pas** aux [bases de données](https://fr.wikipedia.org/wiki/Base_de_donn%C3%A9es "Wikipédia.org") ici. Nous verrons simplement les éléments importants pour bien commencer.
|
||||||
|
|
||||||
> Des exemples sont aussi à votre disposition, pour mieux comprendre le fonctionnement des notions. Les exemples sont données dans certains langages, si vous souhaitez en ajouter pour un langage absent, vous pouvez proposer vos exemple via [pull request](https://github.com/Skycel9/basics-course-of-programming/pulls).
|
> Des exemples sont aussi à votre disposition, pour mieux comprendre le fonctionnement des notions. Les exemples sont données dans certains langages, si vous souhaitez en ajouter pour un langage absent, vous pouvez proposer vos exemples via [pull request](https://github.com/Skycel9/basics-course-of-programming/pulls).
|
||||||
|
|
||||||
<details open="open"><summary><b>Exemples</b></summary>
|
<details open="open"><summary><b>Exemples</b></summary>
|
||||||
<ul>
|
<ul>
|
||||||
|
|||||||
@ -12,7 +12,7 @@ Exemple → `'c'`
|
|||||||
Exemple → `12` ou `-3`
|
Exemple → `12` ou `-3`
|
||||||
- Nous avons aussi le type **Float** (*nombre flottant ou réel*), ce type accepte tout le [nombres réels](https://fr.wikipedia.org/wiki/Nombre_r%C3%A9el), c'est à dire la totalité des nombres ayant un nombre fini ou infini de décimal(s). Il ne possède pas d'abrévation particulière et reste donc _**`float`**_
|
- Nous avons aussi le type **Float** (*nombre flottant ou réel*), ce type accepte tout le [nombres réels](https://fr.wikipedia.org/wiki/Nombre_r%C3%A9el), c'est à dire la totalité des nombres ayant un nombre fini ou infini de décimal(s). Il ne possède pas d'abrévation particulière et reste donc _**`float`**_
|
||||||
Exemple → `1.453` ou `1.33333...`
|
Exemple → `1.453` ou `1.33333...`
|
||||||
- Ensuite un type basé sur la logique, le type **Boolean**<a name="types-bool"> (*booléen*), ce type est un type que l'on peut appeler _logique_. Il peut prendre **uniquement 2 valeurs**, les valeurs possibles sont _True_ ou _False_, autrement dit _1_ ou _0_. Une abrévation lui appartient, _**`bool`**_
|
- Ensuite un type basé sur la logique, le type **Boolean**<a name="types-bool"></a> (*booléen*), ce type est un type que l'on peut appeler _logique_. Il peut prendre **uniquement 2 valeurs**, les valeurs possibles sont _True_ ou _False_, autrement dit _1_ ou _0_. Une abrévation lui appartient, _**`bool`**_
|
||||||
Exemple → `false`
|
Exemple → `false`
|
||||||
- Pour finir nous avons les **Array**<a name="types-arr">(_Tableaux_), qui est un type de *[données paramétrées](https://fr.wikipedia.org/wiki/Type_%28informatique%29#Types_param%C3%A9tr%C3%A9s)*. Contrairement au précédent, ce type **peut prendre plusieurs données différentes**, et s'écrit généralement entre `[ ]`. Il peut accepter divers types de données dans certains langages mais pas la totalité, il est donc préférable d'avoir un tableau le même type de données pour toutes ses valeurs. Son abréviation est _**`arr`**_. À noter : Les index des tableaux commence à la valeur **0**.
|
- Pour finir nous avons les **Array**<a name="types-arr"></a>(_Tableaux_), qui est un type de *[données paramétrées](https://fr.wikipedia.org/wiki/Type_%28informatique%29#Types_param%C3%A9tr%C3%A9s)*. Contrairement aux précédents, ce type **peut prendre plusieurs données différentes**, et s'écrit généralement entre `[ ]`. Il peut accepter divers types de données dans certains langages mais pas la totalité, il est donc préférable d'avoir un tableau de même type de données pour toutes ses valeurs. Son abréviation est _**`arr`**_. À noter : Les index des tableaux commence à la valeur **0**.
|
||||||
Exemple → `["Valeur1", "Valeur2, "Valeur3"]` ou `[1, 2, 3]`
|
Exemple → `["Valeur1", "Valeur2, "Valeur3"]` ou `[1, 2, 3]`
|
||||||
@ -2,7 +2,7 @@
|
|||||||
|
|
||||||
### Définition
|
### Définition
|
||||||
|
|
||||||
**Variable** est un terme qui vient des [mathématiques](https://fr.wikipedia.org/wiki/Math%C3%A9matiques "wikipedia.org"), d'après le site [stephonsays.com](https://fr.strephonsays.com/variable-and-vs-constant-8185 "stephonsays.com"), les *variables* mathématiques sont des éléments qui peuvent contenir une valeur qui peut être modifiée. Les principales utilisations de *variables* sont les [équations](https://fr.wikipedia.org/wiki/%C3%89quation "wikipedia.org") et les [fonctions mathématiques](https://www.maths-cours.fr/cours/fonction "maths-cours.fr").
|
**Variable** est un terme qui vient des [mathématiques](https://fr.wikipedia.org/wiki/Math%C3%A9matiques "wikipedia.org"). D'après le site [stephonsays.com](https://fr.strephonsays.com/variable-and-vs-constant-8185 "stephonsays.com"), les *variables* mathématiques sont des éléments qui peuvent contenir une valeur qui peut être modifiée. Les principales utilisations de *variables* sont les [équations](https://fr.wikipedia.org/wiki/%C3%89quation "wikipedia.org") et les [fonctions mathématiques](https://www.maths-cours.fr/cours/fonction "maths-cours.fr").
|
||||||
Dans l'exemple ci-contre, **x** est une variable réprésentant l'inconnu → `x² - 2x + 4 = 0`.
|
Dans l'exemple ci-contre, **x** est une variable réprésentant l'inconnu → `x² - 2x + 4 = 0`.
|
||||||
|
|
||||||
En **programmation**, une variable fonctionne plus ou moins de la même manière. C'est un élément qui, avant ou au cours de l'exécution d'un programme, peut changer de valeur sans causer de bogue.
|
En **programmation**, une variable fonctionne plus ou moins de la même manière. C'est un élément qui, avant ou au cours de l'exécution d'un programme, peut changer de valeur sans causer de bogue.
|
||||||
|
|||||||
@ -8,11 +8,11 @@ La liste des opérateurs de comparaisons est disponible ci-dessous.
|
|||||||
|
|
||||||
| Opérateur | Syntaxe | Exemple| Résultat | Fonctionnement |
|
| Opérateur | Syntaxe | Exemple| Résultat | Fonctionnement |
|
||||||
| :-----: | :-----: | :-----: | :-----: | :-----: |
|
| :-----: | :-----: | :-----: | :-----: | :-----: |
|
||||||
| Egal | == | a == b | Renvoie _TRUE_ si a et b sont **EGAUX** | `==` vérifie que les deux éléments ont le même valeur |
|
| Egal | == | a == b | Renvoie _TRUE_ si a et b sont **EGAUX** | `==` vérifie que les deux éléments **ont la même valeur** |
|
||||||
| Identique | === | a === b | Renvoie _TRUE_ si a et b sont **EGAUX** et **DE MÊME TYPE** | `===` vérifie que les deux éléments **ont la même valeur** et sont **de même type** |
|
| Identique | === | a === b | Renvoie _TRUE_ si a et b sont **EGAUX** et **DE MÊME TYPE** | `===` vérifie que les deux éléments **ont la même valeur** et sont **de même type** |
|
||||||
| Différent | != | a != b | Renvoie _TRUE_ si a et b sont **DIFFERENT** | `!=` vérifie que les deux éléments ne possède **pas la même valeur** |
|
| Différent | != | a != b | Renvoie _TRUE_ si a et b sont **DIFFERENT** | `!=` vérifie que les deux éléments ne possède **pas la même valeur** |
|
||||||
| Différent | !== | a !== b | Renvoie _TRUE_ si a et b sont **DIFFERENT** et de **TYPE DIFFERENT** | `!==` vérifie que les éléments ne possède **ni la même valeur ni le même type** |
|
| Différent | !== | a !== b | Renvoie _TRUE_ si a et b sont **DIFFERENT** et de **TYPE DIFFERENT** | `!==` vérifie que les éléments ne possède **ni la même valeur ni le même type** |
|
||||||
| Inférieur | < | a < b | Renvoie _TRUE_ si a est **INFERIEUR** à b | `<` vérifie que le premier élément est **strictement inférieur** au second |
|
| Inférieur | < | a < b | Renvoie _TRUE_ si a est **INFERIEUR** à b | `<` vérifie que le premier élément est **strictement inférieur** au second |
|
||||||
| Inférieur ou égal | <= | a <= b | Renvoie _TRUE_ si a est **INFERIEUR OU EGAL** à b | `<=` vérifie que le premier élément est **inférieur ou égal** au second |
|
| Inférieur ou égal | <= | a <= b | Renvoie _TRUE_ si a est **INFERIEUR OU EGAL** à b | `<=` vérifie que le premier élément est **inférieur ou égal** au second |
|
||||||
| Supérieur | > | a > b | Renvoie _TRUE_ si a est **SUPERIEUR** à b | `>` vérfie que le premier élément est **strictement suprieur** au second |
|
| Supérieur | > | a > b | Renvoie _TRUE_ si a est **SUPERIEUR** à b | `>` vérfie que le premier élément est **strictement supérieur** au second |
|
||||||
| Supérieur ou égal | >= | a >= b | Renvoie _TRUE_ si a est **SUPERIEUR OU EGAL** à b | `>=` vérifie que le premier est **supérieur ou égal** au second |
|
| Supérieur ou égal | >= | a >= b | Renvoie _TRUE_ si a est **SUPERIEUR OU EGAL** à b | `>=` vérifie que le premier élément est **supérieur ou égal** au second |
|
||||||
@ -6,4 +6,4 @@
|
|||||||
</details>
|
</details>
|
||||||
<br>
|
<br>
|
||||||
|
|
||||||
> Ce chapitre va porté sur les **opérateurs** que nous utilisons le plus en programmation. Les opérateurs que nous verrons ici nous *serons utile* dans un futur chapitre, il est donc essentielle de bien comprendre ce que nous verrons.
|
> Ce chapitre va porter sur les **opérateurs** que nous utilisons le plus en programmation. Les opérateurs que nous verrons ici nous *serons utiles* dans un futur chapitre, il est donc essentiel de bien comprendre ce que nous verrons.
|
||||||
@ -2,7 +2,7 @@
|
|||||||
|
|
||||||
### Définition
|
### Définition
|
||||||
|
|
||||||
Les **conditons** ou **instruction conditionnel** est une fonction qui effectue différentes action en fonction du résultat d'une condition [booleenne](../Chapter_1/Types.md#types-bool). En programmation, elles sont très souvent utilisé car elles permettent de vérifier des éléments avant d'exécuter du code.
|
Les **conditons** ou **instruction conditionnel** ou **boucle alternative** est une fonction qui effectue différentes actions en fonction du résultat d'une condition [booleenne](../Chapter_1/Types.md#types-bool). En programmation, elles sont très souvent utilisé car elles permettent de vérifier des éléments avant d'exécuter du code.
|
||||||
|
|
||||||
En général, la structure des conditions ressemble à celle ci-dessous.
|
En général, la structure des conditions ressemble à celle ci-dessous.
|
||||||
|
|
||||||
|
|||||||
@ -24,11 +24,11 @@ if (i > 0) {
|
|||||||
|
|
||||||
La **condition** <img src="../../../assets/img/js.png" width="20px"> javascript est très simple, elle suit la structure habituelle des conditions, rien de compliqué.
|
La **condition** <img src="../../../assets/img/js.png" width="20px"> javascript est très simple, elle suit la structure habituelle des conditions, rien de compliqué.
|
||||||
|
|
||||||
> Tout d'abord un mot clé **if**, suivi par l'**opération booléenne** entre parenthèses. L'opération _de comparaison_ utilisée ici vérifie si la valeur de `i` est <u>supérieur</u> à 0. Ensuite, à l'intérieur du bloc de code (_entre `{ }`_), se trouve le code exécuter si la condition est vrai.
|
> Tout d'abord un mot clé **if**, suivi par l'**opération booléenne** entre parenthèses. L'*[opération _de comparaison_](../../../Chapter_2/Comparison.md)* utilisé ici vérifie si la valeur de `i` est <u>supérieur</u> à 0. Ensuite, à l'intérieur du bloc de code (_entre `{ }`_), se trouve le code exécuter si la condition est vrai.
|
||||||
|
|
||||||
> Ce qui suit est facultatif, on retrouve le mot-clé **else**, à nouveau suivi de la structure précédement énnoncée. Ce morceau permet d'exécuter le code entre accolade, si la **première** condition n'est pas rempli et si la **seconde** l'est.
|
> Ce qui suit est facultatif, on retrouve le mot-clé **else**, à nouveau suivi de la structure précédement énnoncée. Ce morceau permet d'exécuter le code entre accolade, si la **première** condition n'est pas rempli et si la **seconde** l'est.
|
||||||
|
|
||||||
> Ici aussi le morceau est facultatif, il commence par le mot-clé **else** et suivi directement par le bloc de code. Il permet d'exécuter le code si aucune des conditions n'est validé.
|
> Ici aussi le morceau est facultatif, il commence par le mot-clé **else** et suivi directement par le bloc de code. Il permet d'exécuter le code si aucune des conditions n'est validée.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
@ -53,4 +53,8 @@ switch (i) {
|
|||||||
|
|
||||||
Le **switch** en <img src="../../../assets/img/js.png" width="20px"> javascript possède une syntaxe globalement similaire à celle d'autres langages, ce qui facilite sont apprentissage et son utilisation.
|
Le **switch** en <img src="../../../assets/img/js.png" width="20px"> javascript possède une syntaxe globalement similaire à celle d'autres langages, ce qui facilite sont apprentissage et son utilisation.
|
||||||
|
|
||||||
> Pour commencer, on voit le mot-clé **switch** qui initialise l'utilisation du switch. Ensuite nous mettons se que nous voulons tester, dans le cas présent `i`. On ouvre un bloc de code, et on y place un **case**, qui est ce à quoi i doit être égal pour être validé. Si ce n'est pas le cas le code continue et va check les autres case. Si un des case renvoie _TRUE_, le code va être exécuté. Si aucun ne l'est et qu'un **default** est présent, c'est le code dans le default qui sera exécuté. Lorsque l'exécution arrive sur un **break**, le switch sera arrêté. <u>À noter</u> que le break n'est pas obligatoire.
|
> Pour commencer, on voit le mot-clé **switch** qui initialise l'utilisation du switch.
|
||||||
|
|
||||||
|
> Ensuite nous mettons se que nous voulons tester, dans le cas présent `i`.
|
||||||
|
|
||||||
|
> On ouvre un bloc de code, et on y place un **case**, qui est ce à quoi i doit être égal pour être validé. Si ce n'est pas le cas le code continue et va check les autres case. Si un des case renvoie _TRUE_, le code va être exécuté. Si aucun ne l'est et qu'un **default** est présent, c'est le code dans le default qui sera exécuté. Lorsque l'exécution arrive sur un **break**, le switch sera arrêté. <u>À noter</u> que le break n'est pas obligatoire.
|
||||||
|
|||||||
@ -24,11 +24,11 @@ if ($i > 0) {
|
|||||||
|
|
||||||
La **condition** <img src="../../../assets/img/PHP.png" width="30px"> php est très simple, elle suit la structure habituelle des conditions, rien de compliqué.
|
La **condition** <img src="../../../assets/img/PHP.png" width="30px"> php est très simple, elle suit la structure habituelle des conditions, rien de compliqué.
|
||||||
|
|
||||||
> Tout d'abord un mot clé **if**, suivi par l'**opération booléenne** entre parenthèses. L'opération _de comparaison_ utilisée ici vérifie si la valeur de `i` est <u>supérieur</u> à 0. Ensuite, à l'intérieur du bloc de code (_entre `{ }`_), se trouve le code exécuter si la condition est vrai.
|
> Tout d'abord un mot clé **if**, suivi par l'**opération booléenne** entre parenthèses. L'[opération _de comparaison_](../../../Chapter_2/Comparison.md) utilisé ici vérifie si la valeur de `i` est <u>supérieur</u> à 0. Ensuite, à l'intérieur du bloc de code (_entre `{ }`_), se trouve le code exécuter si la condition est vrai.
|
||||||
|
|
||||||
> Ce qui suit est facultatif, on retrouve le mot-clé **else**, à nouveau suivi de la structure précédement énnoncée. Ce morceau permet d'exécuter le code entre accolade, si la **première** condition n'est pas rempli et si la **seconde** l'est.
|
> Ce qui suit est facultatif, on retrouve le mot-clé **else**, à nouveau suivi de la structure précédement énnoncée. Ce morceau permet d'exécuter le code entre accolade, si la **première** condition n'est pas rempli et si la **seconde** l'est.
|
||||||
|
|
||||||
> Ici aussi le morceau est facultatif, il commence par le mot-clé **else** et suivi directement par le bloc de code. Il permet d'exécuter le code si aucune des conditions n'est validé.
|
> Ici aussi le morceau est facultatif, il commence par le mot-clé **else** et suivi directement par le bloc de code. Il permet d'exécuter le code si aucune des conditions n'est validée.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
@ -51,6 +51,10 @@ switch ($i) {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
Le **switch** en <img src="../../../assets/img/php.png" width="30px"> javascript possède une syntaxe globalement similaire à celle d'autres langages, ce qui facilite sont apprentissage et son utilisation.
|
Le **switch** en <img src="../../../assets/img/php.png" width="30px"> php possède une syntaxe globalement similaire à celle d'autres langages, ce qui facilite sont apprentissage et son utilisation.
|
||||||
|
|
||||||
> Pour commencer, on voit le mot-clé **switch** qui initialise l'utilisation du switch. Ensuite nous mettons se que nous voulons tester, dans le cas présent `i`. On ouvre un bloc de code, et on y place un **case**, qui est ce à quoi i doit être égal pour être validé. Si ce n'est pas le cas le code continue et va check les autres case. Si un des case renvoie _TRUE_, le code va être exécuté. Si aucun ne l'est et qu'un **default** est présent, c'est le code dans le default qui sera exécuté. Lorsque l'exécution arrive sur un **break**, le switch sera arrêté. <u>À noter</u> que le break n'est pas obligatoire.
|
> Pour commencer, on voit le mot-clé **switch** qui initialise l'utilisation du switch.
|
||||||
|
|
||||||
|
> Ensuite nous mettons se que nous voulons tester, dans le cas présent `i`.
|
||||||
|
|
||||||
|
> On ouvre un bloc de code, et on y place un **case**, qui est ce à quoi i doit être égal pour être validé. Si ce n'est pas le cas le code continue et va check les autres case. Si un des case renvoie _TRUE_, le code va être exécuté. Si aucun ne l'est et qu'un **default** est présent, c'est le code dans le default qui sera exécuté. Lorsque l'exécution arrive sur un **break**, le switch sera arrêté. <u>À noter</u> que le break n'est pas obligatoire.
|
||||||
@ -7,9 +7,9 @@
|
|||||||
</details>
|
</details>
|
||||||
<br>
|
<br>
|
||||||
|
|
||||||
> Dans ce chapitre nous aborderons le sujet des **condtion**, des **switch** ainsi que des **opérations ternaire**. Toutes ces notions sont intimement liées, mais contiennent toutes des différences, il est donc important de passé sur toutes.
|
> Dans ce chapitre nous aborderons le sujet des **condtions**, des **switch** ainsi que des **opérations ternaires**. Toutes ces notions sont intimement liées, mais contiennent toutes des différences, il est donc important de passer sur toutes.
|
||||||
|
|
||||||
> Des exemples sont aussi à votre disposition, pour mieux comprendre le fonctionnement des notions. Les exemples sont données dans certains langages, si vous souhaitez en ajouter pour un langage absent, vous pouvez proposer vos exemple via [pull request](https://github.com/Skycel9/basics-course-of-programming/pulls).
|
> Des exemples sont aussi à votre disposition, pour mieux comprendre le fonctionnement des notions. Les exemples sont données dans certains langages, si vous souhaitez en ajouter pour un langage absent, vous pouvez proposer vos exemples via [pull request](https://github.com/Skycel9/basics-course-of-programming/pulls).
|
||||||
|
|
||||||
<details open="open"><summary><b>Exemples</b></summary>
|
<details open="open"><summary><b>Exemples</b></summary>
|
||||||
<ul>
|
<ul>
|
||||||
|
|||||||
@ -2,7 +2,7 @@
|
|||||||
|
|
||||||
### Définition
|
### Définition
|
||||||
|
|
||||||
Le **Switch** est également une fonction semblable aux [conditions](./Conditions.md). Il permet d'exécuter des actions en fonction du résultat, mais permet un syntaxe moins répétitive qu'une simple conditions.
|
Le **Switch** est également une fonction semblable aux [conditions](./Conditions.md). Il permet d'exécuter des actions en fonction du résultat, mais permet un syntaxe moins répétitive qu'une simple condition.
|
||||||
|
|
||||||
La plupart des langages permettent l'utilisation du **switch** / **case**, qui respect en règles générales cette structure.
|
La plupart des langages permettent l'utilisation du **switch** / **case**, qui respect en règles générales cette structure.
|
||||||
|
|
||||||
@ -23,8 +23,14 @@ switch (expression) {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
Analysons l'exemple présent ci-dessus, en premier temps, on trouve l'instruction **`switch`**, elle permet d'initialiser. Entre parenthèses, se trouve l'expression a utiliser. Chaque **`case`** contient la vérification à faire sur l'élément de l'expression. Pour finir, **`break`** permet de mettre fin à l'instruction switch (_ou non_) dans le case précédent. **`default`** est une instruction qui sera exécuter si aucun des _case_ n'est vérifié.
|
> Analysons l'exemple présent ci-dessus, en premier temps, on trouve l'instruction **`switch`**, elle permet d'initialiser. Entre parenthèses, se trouve l'expression a utiliser.
|
||||||
|
|
||||||
La **vérification des cases** se fait les unes après les autres dans le sens d'écriture (_haut vers le bas_).
|
> Chaque **`case`** contient la vérification à faire sur l'élément de l'expression.
|
||||||
|
|
||||||
|
> Pour finir, **`break`** permet de mettre fin à l'instruction switch (_ou non_) dans le case précédent.
|
||||||
|
|
||||||
|
> **`default`** est une instruction qui sera exécuter si aucun des _case_ n'est vérifiés.
|
||||||
|
|
||||||
|
La **vérification des case** se fait les unes après les autres dans le sens d'écriture (_haut vers le bas_).
|
||||||
|
|
||||||
Des différences existent entre langages, il vous est donc conseillé de regarder les [exemples](./Practice/Examples) ou de regarder la documentation du langage utilisé.
|
Des différences existent entre langages, il vous est donc conseillé de regarder les [exemples](./Practice/Examples) ou de regarder la documentation du langage utilisé.
|
||||||
@ -9,4 +9,4 @@ La syntaxe de ces opérations est la même dans tout les langages qui les accept
|
|||||||
condition ? expression1 : expression2
|
condition ? expression1 : expression2
|
||||||
```
|
```
|
||||||
|
|
||||||
La condition est **l'opération** qui sera vérifiée, si la condition est rempli, le code **renvoie l'expression1**, sinon c'est **l'expression2 qui sera utilisé**.
|
La condition est **l'opération** qui sera vérifiée, si la condition est rempli, le code **renvoie l'expression1**, sinon c'est **l'expression2 qui sera utilisée**.
|
||||||
@ -1,6 +1,6 @@
|
|||||||
<center><h1>Chapitre 4.3 - Boucle Do-while</h1></center>
|
<center><h1>Chapitre 4.3 - Boucle Do-while</h1></center>
|
||||||
|
|
||||||
Le fonctionnement de la boucle **do-while** est le même que que celui de la boucle [while](./While.md), à la différence que la condition est vérifé après le bloque d'instruction de la boucle ce qui assure _**une**_ exécution.
|
Le fonctionnement de la boucle **do-while** est le même que que celui de la boucle [while](./While.md), à la différence que la condition est vérifée après le bloc d'instruction de la boucle ce qui assure _**une**_ exécution.
|
||||||
|
|
||||||
La syntaxe de cette boucle est la suivante
|
La syntaxe de cette boucle est la suivante
|
||||||
|
|
||||||
@ -18,4 +18,4 @@ Le début de l'instruction est **do** c'est lui qui initialise la boucle, à la
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
Ensuite nous mettons le mot clé **while** le même que pour la boucle [_while_](#while), enfin la **condition** est présente pour vérifier lorsque la boucle doit être arrêté.
|
Ensuite nous mettons le mot clé **while** le même que pour la boucle [_while_](./While.md), enfin la **condition** est présente pour vérifier lorsque la boucle doit être arrêtée.
|
||||||
@ -2,9 +2,9 @@
|
|||||||
|
|
||||||
Cette boucle est une boucle qui s'exécute le nombre de fois prédéfini. On retrouve trois éléments qui constituent la structure de cette boucle.
|
Cette boucle est une boucle qui s'exécute le nombre de fois prédéfini. On retrouve trois éléments qui constituent la structure de cette boucle.
|
||||||
|
|
||||||
- Un élément **d'itinitialisation**, exéuter **avant toutes** les boucles
|
- Une **variable**, défini **avant** la première occurence
|
||||||
- Une **condition**, qui est vérifié **avant chaque** boucle
|
- Une **condition**, qui est vérifié **avant chaque** boucle
|
||||||
- Une **instruction**, _[Incrémentation](https://www.larousse.fr/dictionnaires/francais/incr%C3%A9mentation/42414)_ ou _[Décrémentation](https://www.larousse.fr/dictionnaires/francais/d%C3%A9cr%C3%A9menter/22436)_ exécuter **après chaque** boucle
|
- Une **instruction**, _[Incrémentation](https://www.larousse.fr/dictionnaires/francais/incr%C3%A9mentation/42414)_ ou _[Décrémentation](https://www.larousse.fr/dictionnaires/francais/d%C3%A9cr%C3%A9menter/22436)_ exécutée **après chaque** boucle
|
||||||
|
|
||||||
```
|
```
|
||||||
for (defVariable; condition; instruction) {
|
for (defVariable; condition; instruction) {
|
||||||
|
|||||||
@ -1,5 +1,5 @@
|
|||||||
<center><h1>Chapitre 4.4 - Boucle Foreach</h1></center>
|
<center><h1>Chapitre 4.4 - Boucle Foreach</h1></center>
|
||||||
|
|
||||||
La dernière des boucles est la boucle forEach. Comme le dit son nom, elle permet de parcourir tout les éléments d'un [tableau](../Chpater_1/Types.md#types-arr).
|
La dernière des boucles est la boucle forEach. Comme le dit son nom, elle permet de parcourir tout les éléments d'un [tableau](../Chapter_1/Types.md#types-arr).
|
||||||
|
|
||||||
Sa structure diffère un peu d'un langage à l'autre, nous vous conseillons donc de vous renseigner pour le langage que vous souhaitez utiliser si ce dernier ne fait pas parti des langages supports de ce cours.
|
Sa structure diffère un peu d'un langage à l'autre, nous vous conseillons donc de vous renseigner pour le langage que vous souhaitez utiliser si ce dernier ne fait pas parti des langages supports de ce cours.
|
||||||
@ -25,13 +25,13 @@ for (let i = 0; i <= 3; i++) {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
La boucle **for** en <img src="../../../assets/img/js.png" width="20px"> **javascript** suit la syntaxe visible dans le commentaire de bloc.
|
La boucle **for** en <img src="../../../assets/img/js.png" width="20px"> javascript suit la syntaxe visible dans le commentaire de bloc.
|
||||||
|
|
||||||
> En premier temps, nous trouvons **`for`**, l'élément **d'initialisation** de la boucle, il est semblable dans tout les langages acceptant la boucle for.
|
> En premier temps, nous trouvons **`for`**, l'élément **d'initialisation** de la boucle, il est semblable dans tout les langages acceptant la boucle for.
|
||||||
|
|
||||||
> Par la suite, il faut **déclarer la variable et sa valeur**, elle sera utilisé dans la condition.
|
> Par la suite, il faut **déclarer la variable et sa valeur**, elle sera utilisée dans la condition.
|
||||||
|
|
||||||
> Après le `;` nous devons **définir la condition**, qui tant que validé effectuera une nouvelle occurence de la boucle.
|
> Après le `;` nous devons **définir la condition**, qui tant que validée effectuera une nouvelle occurence de la boucle.
|
||||||
|
|
||||||
> Pour finir, plaçons **l'opération**, cette dernière et le changement qui affectera la variable à la fin de chaque occurence de la boucle.
|
> Pour finir, plaçons **l'opération**, cette dernière et le changement qui affectera la variable à la fin de chaque occurence de la boucle.
|
||||||
|
|
||||||
@ -60,7 +60,7 @@ while (i < 3) {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
La boucle **while** en <img src="../../../assets/img/js.png" width="20px"> **javascript** suit une syntaxe disponible dans le commentaire de bloc.
|
La boucle **while** en <img src="../../../assets/img/js.png" width="20px"> javascript suit une syntaxe disponible dans le commentaire de bloc.
|
||||||
|
|
||||||
> Pour commencer, il faut **initialiser** la boucle, cela se fait avec **`while`**.
|
> Pour commencer, il faut **initialiser** la boucle, cela se fait avec **`while`**.
|
||||||
|
|
||||||
@ -90,7 +90,7 @@ do {
|
|||||||
|
|
||||||
} while (i < 3)
|
} while (i < 3)
|
||||||
```
|
```
|
||||||
La boucle **do-while** en <img src="../../../assets/img/js.png" width="20px"> **javascript** suit une syntaxe disponible dans le commentaire de bloc.
|
La boucle **do-while** en <img src="../../../assets/img/js.png" width="20px"> javascript suit une syntaxe disponible dans le commentaire de bloc.
|
||||||
|
|
||||||
> Tout d'abord, nous retrouvons **l'initialisateur** qui est l'instruction **`do`**
|
> Tout d'abord, nous retrouvons **l'initialisateur** qui est l'instruction **`do`**
|
||||||
|
|
||||||
@ -103,13 +103,13 @@ La boucle **do-while** en <img src="../../../assets/img/js.png" width="20px"> **
|
|||||||
---
|
---
|
||||||
### Exemple de boucle ForEach<a name="example-foreach"></a>
|
### Exemple de boucle ForEach<a name="example-foreach"></a>
|
||||||
```js
|
```js
|
||||||
// Boucle forEach pour un tableau contenant tous les chiffres de 1 à 9
|
|
||||||
/*
|
/*
|
||||||
arr.forEach(value=> {
|
arr.forEach(value=> {
|
||||||
console.log(value);
|
console.log(value);
|
||||||
}
|
}
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
// Boucle forEach pour un tableau contenant tous les chiffres de 1 à 9
|
||||||
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
|
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
|
||||||
|
|
||||||
arr.forEach(value=> {
|
arr.forEach(value=> {
|
||||||
@ -117,7 +117,7 @@ arr.forEach(value=> {
|
|||||||
})
|
})
|
||||||
```
|
```
|
||||||
|
|
||||||
La boucle **forEach** en <img src="../../../assets/img/js.png" width="20px"> **javascript** est une boucle qui s'effectue sur les tableaux, et suit la syntaxe présente dans le commentaire de bloc ci-dessus.
|
La boucle **forEach** en <img src="../../../assets/img/js.png" width="20px"> javascript est une boucle qui s'effectue sur les tableaux, et suit la syntaxe présente dans le commentaire de bloc ci-dessus.
|
||||||
|
|
||||||
> Pour commencer, nous retrouvons le **tableau** sur lequel nous voulons utiliser la boucle.
|
> Pour commencer, nous retrouvons le **tableau** sur lequel nous voulons utiliser la boucle.
|
||||||
|
|
||||||
|
|||||||
@ -9,10 +9,10 @@
|
|||||||
</ul>
|
</ul>
|
||||||
</details>
|
</details>
|
||||||
|
|
||||||
> Vous trouverez ici-même les différents exemples en javascript pour les notions vu dans le chapitre 4.
|
> Vous trouverez ici-même les différents exemples en php pour les notions vu dans le chapitre 4.
|
||||||
---
|
---
|
||||||
### Exemple de boucle For<a name="example-for"></a>
|
### Exemple de boucle For<a name="example-for"></a>
|
||||||
```js
|
```php
|
||||||
/*
|
/*
|
||||||
for (variable; condition; opération) {
|
for (variable; condition; opération) {
|
||||||
code...
|
code...
|
||||||
@ -26,13 +26,13 @@ for ($i = 0; i <= 3; i++) {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
La boucle **for** en <img src="../../../assets/img/php.png" width="30px"> **php** suit la syntaxe visible dans le commentaire de bloc.
|
La boucle **for** en <img src="../../../assets/img/php.png" width="30px"> php suit la syntaxe visible dans le commentaire de bloc.
|
||||||
|
|
||||||
> En premier temps, nous trouvons **`for`**, l'élément **d'initialisation** de la boucle, il est semblable dans tout les langages acceptant la boucle for.
|
> En premier temps, nous trouvons **`for`**, l'élément **d'initialisation** de la boucle, il est semblable dans tout les langages acceptant la boucle for.
|
||||||
|
|
||||||
> Par la suite, il faut **déclarer la variable et sa valeur**, elle sera utilisé dans la condition.
|
> Par la suite, il faut **déclarer la variable et sa valeur**, elle sera utilisée dans la condition.
|
||||||
|
|
||||||
> Après le `;` nous devons **définir la condition**, qui tant que validé effectuera une nouvelle occurence de la boucle.
|
> Après le `;` nous devons **définir la condition**, qui tant que validée effectuera une nouvelle occurence de la boucle.
|
||||||
|
|
||||||
> Pour finir, plaçons **l'opération**, cette dernière et le changement qui affectera la variable à la fin de chaque occurence de la boucle.
|
> Pour finir, plaçons **l'opération**, cette dernière et le changement qui affectera la variable à la fin de chaque occurence de la boucle.
|
||||||
|
|
||||||
@ -61,7 +61,7 @@ while ($i < 3) {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
La boucle **while** en <img src="../../../assets/img/php.png" width="30px"> **php** suit une syntaxe disponible dans le commentaire de bloc.
|
La boucle **while** en <img src="../../../assets/img/php.png" width="30px"> php suit une syntaxe disponible dans le commentaire de bloc.
|
||||||
|
|
||||||
> Pour commencer, il faut **initialiser** la boucle, cela se fait avec **`while`**.
|
> Pour commencer, il faut **initialiser** la boucle, cela se fait avec **`while`**.
|
||||||
|
|
||||||
@ -91,7 +91,7 @@ do {
|
|||||||
|
|
||||||
} while ($i < 3)
|
} while ($i < 3)
|
||||||
```
|
```
|
||||||
La boucle **do-while** en <img src="../../../assets/img/php.png" width="30px"> **php** suit une syntaxe disponible dans le commentaire de bloc.
|
La boucle **do-while** en <img src="../../../assets/img/php.png" width="30px"> php suit une syntaxe disponible dans le commentaire de bloc.
|
||||||
|
|
||||||
> Tout d'abord, nous retrouvons **l'initialisateur** qui est l'instruction **`do`**
|
> Tout d'abord, nous retrouvons **l'initialisateur** qui est l'instruction **`do`**
|
||||||
|
|
||||||
@ -118,11 +118,11 @@ foreach($arr as $value) {
|
|||||||
})
|
})
|
||||||
```
|
```
|
||||||
|
|
||||||
La boucle **forEach** en <img src="../../../assets/img/php.png" width="30px"> **php** est une boucle qui s'effectue sur les tableaux, et suit la syntaxe présente dans le commentaire de bloc ci-dessus.
|
La boucle **forEach** en <img src="../../../assets/img/php.png" width="30px"> php est une boucle qui s'effectue sur les tableaux, et suit la syntaxe présente dans le commentaire de bloc ci-dessus.
|
||||||
|
|
||||||
> Tout d'abord, nous avons l'initialisateur **`foreach`**
|
> Tout d'abord, nous avons l'initialisateur **`foreach`**
|
||||||
|
|
||||||
> Suivi par le tableau, qui sera utilisé pour la boucle forEach. Directement à la suit enous avons un mot clé **`as`** pour attribuer à chaque itération la variable donné après ce mot clé.
|
> Suivi par le tableau, qui sera utilisé pour la boucle forEach. Directement à la suite nous avons un mot clé **`as`** pour attribuer à chaque itération la variable donnée après ce mot clé.
|
||||||
|
|
||||||
|
|
||||||
> Enfin, nous plaçons le **code** à exécuter pour chaque occurrence
|
> Enfin, nous plaçons le **code** à exécuter pour chaque occurrence
|
||||||
@ -8,9 +8,9 @@
|
|||||||
</details>
|
</details>
|
||||||
<br>
|
<br>
|
||||||
|
|
||||||
> Ce chapitre portera sur les différentes boucles existantes en informatique, mais avant tout, il faut savoir ce qu'en une boucle. Une boucle est un élément de programmation qui permet d'exécuter un code plusieurs fois de suite, sans pour autant à ajouter le code plusieurs fois.
|
> Ce chapitre portera sur les différentes boucles existantes en informatique, mais avant tout, il faut savoir ce qu'est une boucle. Une boucle est un élément de programmation qui permet d'exécuter un code plusieurs fois de suite, sans pour autant ajouter le code plusieurs fois.
|
||||||
|
|
||||||
> Des exemples sont aussi à votre disposition, pour mieux comprendre le fonctionnement des notions. Les exemples sont données dans certains langages, si vous souhaitez en ajouter pour un langage absent, vous pouvez proposer vos exemple via [pull request](https://github.com/Skycel9/basics-course-of-programming/pulls).
|
> Des exemples sont aussi à votre disposition, pour mieux comprendre le fonctionnement des notions. Les exemples sont données dans certains langages, si vous souhaitez en ajouter pour un langage absent, vous pouvez proposer vos exemples via [pull request](https://github.com/Skycel9/basics-course-of-programming/pulls).
|
||||||
|
|
||||||
<details open="open"><summary><b>Exemples</b></summary>
|
<details open="open"><summary><b>Exemples</b></summary>
|
||||||
<ul>
|
<ul>
|
||||||
|
|||||||
@ -10,4 +10,4 @@ while (condition) {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
Le mot clé **while** permet de commencer l'usage de la boucle while, ensuite on retrouve la **condition** qui, tant que validé, fera exécuter le code à l'intérieur de la boucle.
|
Le mot clé **while** permet de commencer l'usage de la boucle while, ensuite on retrouve la **condition** qui, tant que validée, fera exécuter le code à l'intérieur de la boucle.
|
||||||
@ -2,6 +2,6 @@
|
|||||||
|
|
||||||
### Définition
|
### Définition
|
||||||
|
|
||||||
Une **fonction**, en informatique, est un parti d'un code qui effectue une tâche ou un calcul de façon indépendante au reste du programme. Elle permettent notamment d'executer une partie de code plusieurs fois, sans avoir besoin de réecrire le code en question.
|
Une **fonction**, en informatique, est un parti d'un code qui effectue une tâche ou un calcul de façon indépendante au reste du programme. Elle permettent notamment d'exécuter une partie de code plusieurs fois, sans avoir besoin de réecrire le code en question.
|
||||||
|
|
||||||
> Selon le langage informatique que vous utiliser, la syntaxe des fonctions peut parfois grandement changer. C'est pourquoi nous vous invitons à vous rendre dans la partie [d'exemple](./Practice/Examples) si vous souhaitez savoir pour votre langage.
|
> Selon le langage informatique que vous utiliser, la syntaxe des fonctions peut parfois grandement changer. C'est pourquoi nous vous invitons à vous rendre dans la partie [d'exemple](./Practice/Examples) ou sur la documentation de votre langage si vous souhaitez en savoir plus.
|
||||||
@ -32,21 +32,21 @@ let isOdd = function() {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
Ci-dessus la syntaxe pour **déclarer** une fonction en <img src="../../../assets/img/js.png" width="20px"> **javascript**.
|
Ci-dessus la syntaxe pour **déclarer** une fonction en <img src="../../../assets/img/js.png" width="20px"> javascript.
|
||||||
|
|
||||||
> Les fonctions sont **initialisées** par le mot clé **`function`**. C'est lui qui va dire que l'on commence la déclaration d'une fonction.
|
> Les fonctions sont **initialisées** par le mot clé **`function`**. C'est lui qui va dire que l'on commence la déclaration d'une fonction.
|
||||||
|
|
||||||
> Ensuite, la fonction doit être **nommée**, les mêmes règles que les noms pour les variables s'appliquent pour les fonctions.
|
> Ensuite, la fonction doit être **nommée**, les mêmes règles que les noms pour les variables s'appliquent pour les fonctions.
|
||||||
|
|
||||||
> Entre parenthèses, un ou plusieurs **paramètres** seront utilisés, un paramètres est, en quelques sortes, une variable qui sera donnée lors de l'usage de la fonction. À noter que les paramètres peuvent êtres limité à un certain nombre ou peuvent êtres illimités. Il se peut également qu'aucun paramètre soit utilisé.
|
> Entre parenthèses, un ou plusieurs **paramètres** seront utilisés, un paramètres est, en quelques sortes, une variable qui sera donnée lors de l'usage de la fonction. À noter que les paramètres peuvent êtres limités à un certain nombre ou peuvent êtres illimités. Il se peut également qu'aucun paramètre soit utilisé.
|
||||||
|
|
||||||
```js
|
```js
|
||||||
// Fonction sans paramètres
|
// Fonction sans paramètres
|
||||||
function noParameters() {
|
function noParameters() {
|
||||||
return console.log("Cette fonction n'utilise aucun paramètres");
|
return console.log("Cette fonction n'utilise aucun paramètre");
|
||||||
}
|
}
|
||||||
|
|
||||||
// Fonction acceptant un nombre de paramètres limités
|
// Fonction acceptant un nombre de paramètres limité
|
||||||
function someParameters(first, second) {
|
function someParameters(first, second) {
|
||||||
return console.log("Cette fonction accepte 2 paramètres");
|
return console.log("Cette fonction accepte 2 paramètres");
|
||||||
}
|
}
|
||||||
@ -68,7 +68,7 @@ let nomFonction = paramètres => code...
|
|||||||
*/
|
*/
|
||||||
|
|
||||||
let isEven = number => Number.isInteger(number/2)?true:false
|
let isEven = number => Number.isInteger(number/2)?true:false
|
||||||
// Ici nous avons cumuler une fonction fléchée avec une opération ternaire pour optimiser le code
|
// Ici nous avons cumulé une fonction fléchée avec une opération ternaire pour optimiser le code
|
||||||
```
|
```
|
||||||
|
|
||||||
Les **fonctions fléchées** en <img src="../../../assets/img/js.png" width="20px"> **javascript** sont utilisées pour simplifier la syntaxe de déclaration de fonctions.
|
Les **fonctions fléchées** en <img src="../../../assets/img/js.png" width="20px"> javascript sont utilisées pour simplifier la syntaxe de déclaration de fonctions.
|
||||||
@ -26,7 +26,7 @@ isEven(4); // Renvoi true
|
|||||||
isEven(9); // Renvoi false
|
isEven(9); // Renvoi false
|
||||||
```
|
```
|
||||||
|
|
||||||
Ci-dessus la syntaxe pour **déclarer** une fonction en <img src="../../../assets/img/php.png" width="30px"> **php**.
|
Ci-dessus la syntaxe pour **déclarer** une fonction en <img src="../../../assets/img/php.png" width="30px"> php.
|
||||||
|
|
||||||
> Les fonctions sont **initialisées** par le mot clé **`function`**. C'est lui qui va dire que l'on commence la déclaration d'une fonction.
|
> Les fonctions sont **initialisées** par le mot clé **`function`**. C'est lui qui va dire que l'on commence la déclaration d'une fonction.
|
||||||
|
|
||||||
@ -34,8 +34,8 @@ Ci-dessus la syntaxe pour **déclarer** une fonction en <img src="../../../asset
|
|||||||
|
|
||||||
> Entre parenthèses, un ou plusieurs **paramètres** seront utilisés, un paramètres est, en quelques sortes, une variable qui sera donnée lors de l'usage de la fonction. À noter que les paramètres peuvent êtres limité à un certain nombre ou peuvent êtres illimités. Il se peut également qu'aucun paramètre soit utilisé.
|
> Entre parenthèses, un ou plusieurs **paramètres** seront utilisés, un paramètres est, en quelques sortes, une variable qui sera donnée lors de l'usage de la fonction. À noter que les paramètres peuvent êtres limité à un certain nombre ou peuvent êtres illimités. Il se peut également qu'aucun paramètre soit utilisé.
|
||||||
|
|
||||||
```js
|
```php
|
||||||
// Fonction sans paramètres
|
// Fonction sans paramètre
|
||||||
function noParameters() {
|
function noParameters() {
|
||||||
echo "Cette fonction n'utilise aucun paramètres";
|
echo "Cette fonction n'utilise aucun paramètres";
|
||||||
}
|
}
|
||||||
@ -62,7 +62,7 @@ $nomFonction = (paramètres) => code...;
|
|||||||
*/
|
*/
|
||||||
|
|
||||||
$isEven = ($number) => is_integer($number/2)?true:false;
|
$isEven = ($number) => is_integer($number/2)?true:false;
|
||||||
// Ici nous avons cumuler une fonction fléchée avec une opération ternaire pour optimiser le code
|
// Ici nous avons cumulé une fonction fléchée avec une opération ternaire pour optimiser le code
|
||||||
```
|
```
|
||||||
|
|
||||||
Les **fonctions fléchées** en <img src="../../../assets/img/php.png" width="30px"> **php** sont utilisées pour simplifier la syntaxe de déclaration de fonctions.
|
Les **fonctions fléchées** en <img src="../../../assets/img/php.png" width="30px"> php sont utilisées pour simplifier la syntaxe de déclaration de fonctions.
|
||||||
@ -2,11 +2,12 @@
|
|||||||
|
|
||||||
### Definition
|
### Definition
|
||||||
|
|
||||||
Une **expressions régulière** ou **expressions rationnelles** est une chaîne de caractères qui décrit les différentes syntaxe accepté dans une autre chaîne de caractères. Elles sont aussi appelé **regex**, qui est un mot valise provenant de l'anglais et formé de _regular expression_.
|
Une **expressions régulière** ou **expressions rationnelles** est une chaîne de caractères qui décrit les différentes syntaxes acceptées dans une autre chaîne de caractères. Elles sont aussi appelé **regex**, qui est un mot valise provenant de l'anglais et formé de _regular expression_.
|
||||||
|
|
||||||
> La syntaxe des **Regex** est particulière et peut parfois en effrayer certains, mais cette frayeure n'est pas fondé. Une fois pencher sur la question elles sont très utiles et ne sont pas aussi compliqué qu'il n'y paraît
|
> La syntaxe des **Regex** est particulière et peut parfois en effrayer certains, mais cette frayeure n'est pas fondée. Une fois penché sur la question elles sont très utiles et ne sont pas aussi compliqué qu'il n'y paraît
|
||||||
|
|
||||||
> _Ce cours est en grande partie du site suivant : https://www.lucaswillems.com/fr/articles/25/tutoriel-pour-maitriser-les-expressions-regulieres_
|
> _Ce cours est tiré du site suivant : https://www.lucaswillems.com/fr/articles/25/tutoriel-pour-maitriser-les-expressions-regulieres_
|
||||||
|
C'est pourquoi nous vous invitons à vous y rendre pour comprendre en totalité les expressions régulières
|
||||||
|
|
||||||
La syntaxe est la suivante
|
La syntaxe est la suivante
|
||||||
<a href="https://www.lucaswillems.com/fr/articles/25/tutoriel-pour-maitriser-les-expressions-regulieres">
|
<a href="https://www.lucaswillems.com/fr/articles/25/tutoriel-pour-maitriser-les-expressions-regulieres">
|
||||||
@ -45,7 +46,7 @@ m[abcdefghijklmnopqrstuvwxyz]ts
|
|||||||
> Ici, l'expression accepte toutes les lettres de l'[alphabet latin](https://fr.wikipedia.org/wiki/Alphabet_latin)
|
> Ici, l'expression accepte toutes les lettres de l'[alphabet latin](https://fr.wikipedia.org/wiki/Alphabet_latin)
|
||||||
|
|
||||||
<br>
|
<br>
|
||||||
Vous confenez bien qu'il n'est pas pratique d'utiliser cette syntaxe. C'est pourquoi des équivalents existe pour les différentes possibilités.
|
Vous convenez bien qu'il n'est pas pratique d'utiliser cette syntaxe. C'est pourquoi des équivalents existent pour les différentes possibilités.
|
||||||
|
|
||||||
Intervalle | Equivalent | Traduction
|
Intervalle | Equivalent | Traduction
|
||||||
---------|------------|-----------
|
---------|------------|-----------
|
||||||
|
|||||||
@ -1,3 +1,3 @@
|
|||||||
<center><h1>Chapitre 6.3 - Erreurs d'exécution</h1></center>
|
<center><h1>Chapitre 6.3 - Erreurs d'exécution</h1></center>
|
||||||
|
|
||||||
Pour finir, on retrouve les erreurs dites **d'exécution**. Elles apparaîssent durant l'exécution de votre programme et avec des circonstances particulières. On les appel aussi des **exception** car elle renvoie vers un événement exceptionnel. Par exemple, un programme essaie de lire un fichier qui n'existe pas.
|
Pour finir, on retrouve les erreurs dites **d'exécution**. Elles apparaîssent durant l'exécution de votre programme et avec des circonstances particulières. On les appel aussi des **exceptions** car elles renvoient vers un événement exceptionnel. Par exemple, un programme essaie de lire un fichier qui n'existe pas.
|
||||||
@ -11,14 +11,12 @@
|
|||||||
|
|
||||||
### Définition
|
### Définition
|
||||||
|
|
||||||
Une erreur informatique est un événement non-prévu lors du développement qui apparît lors de l'exécution ou la compilation d'un code qui engendre un arrêt du programme ou qui ne réagit pas de la façon souhaitée.
|
Une erreur informatique est un événement non-prévu lors du développement qui apparît lors de l'exécution ou la compilation d'un code qui engendre un arrêt du programme ou ce-dernier ne réagit pas de la façon souhaitée.
|
||||||
#### Principes
|
#### Principes
|
||||||
Savoir lire une erreur est un pilier du [débogage informatique](https://fr.wiktionary.org/wiki/d%C3%A9bogage). Cela vous permettra de supprimer toutes les erreurs de votre programme, afin de pouvoir l'utiliser sans soucis. Mais pour cela il faut comprendre la structure d'une erreur et où les trouver.
|
Savoir lire une erreur est un pilier du [débogage informatique](https://fr.wiktionary.org/wiki/d%C3%A9bogage). Cela vous permettra de supprimer toutes les erreurs de votre programme, afin de pouvoir l'utiliser sans soucis. Mais pour cela il faut comprendre la structure d'une erreur et où les trouver.
|
||||||
Les erreurs que vous rencontrerez durant votre debogage peuvent apparaîtres à plusieurs endroits, en PHP par exemple vous les trouverez sur la page qui sera générée avec le code. En Javascript, cela se passe dans la console de votre IDE et/ou la console de votre navigateur, par exemple.
|
Les erreurs que vous rencontrerez durant votre debogage peuvent apparaîtres à plusieurs endroits, en PHP par exemple vous les trouverez sur la page qui sera générée avec le code. En Javascript, cela se passe dans la console de votre IDE et/ou la console de votre navigateur, par exemple.
|
||||||
<br>
|
<br>
|
||||||
|
|
||||||
> Des exemples sont à votre disposition dans certains langages, si vous pensez pouvoir ajouter des exemples pour un langage qui n'en possède pas, vous pouvez proposer vos exemples via les [pulls requests](https://github.com/Skycel9/basics-course-of-programming/pulls).
|
|
||||||
|
|
||||||
<details open="open"><summary><b>Exemples</b></summary>
|
<details open="open"><summary><b>Exemples</b></summary>
|
||||||
<ul>
|
<ul>
|
||||||
<li><a href="./Practice/Examples/Example_Js.md">Javascript</a></li>
|
<li><a href="./Practice/Examples/Example_Js.md">Javascript</a></li>
|
||||||
|
|||||||
@ -1,3 +1,3 @@
|
|||||||
<center><h1>Chapitre 6.2 - Erreurs sémantiques</h1></center>
|
<center><h1>Chapitre 6.2 - Erreurs sémantiques</h1></center>
|
||||||
|
|
||||||
Le second type d'erreur existant est l'erreur de **logique** aussi nommée erreur de **sémantique**. Ce type ne créer pas d'arrêt du programme, et pour cause, ces erreurs sont des erreurs qui arrive lorsque vous attendez un certain résultat, mais que le résultat que renvoie votre code n'est pas le bon. Pour corriger ces erreurs, il suffit repenser et relire le code écrit afin de comprendre ce qui ne va pas. Elle peuvent parfois être longue à deboguer mais reste tout de même abordable.
|
Le second type d'erreur existant est l'erreur de **logique** aussi nommée erreur **sémantique**. Ce type ne crée pas d'arrêt du programme, et pour cause, ces erreurs sont des erreurs qui arrive lorsque vous attendez un certain résultat, mais que le résultat que renvoie votre code n'est pas le bon. Pour corriger ces erreurs, il suffit repenser et relire le code écrit afin de comprendre ce qui ne va pas. Elle peuvent parfois être longue à deboguer mais reste tout de même abordable.
|
||||||
@ -1,4 +1,3 @@
|
|||||||
<center><h1>Chapitre 6.1 - Erreurs de syntaxe</h1></center>
|
<center><h1>Chapitre 6.1 - Erreurs de syntaxe</h1></center>
|
||||||
|
|
||||||
Pour commencer, le type le plus récurrent est l'erreur de **syntaxe**. Cette erreur apparaît lorsque la [syntaxe](https://www.larousse.fr/dictionnaires/francais/syntaxe/76217 "Syntaxe - Sens 4") du langage n'est pas respecté. Contrairement au langue que nous utilisons quotidiennement tel que le français ou l'anglais, dans lesquelles nous pouvons faires des erreurs de syntaxe qui n'altère pas le sens. En informatique, une erreur de syntaxe engendre un arrêt du programme, aussi appelé [plantage](https://fr.wikipedia.org/wiki/Plantage). À défaut d'être les plus communes, elle sont les plus simple à corriger.
|
Pour commencer, le type le plus récurrent est l'erreur de **syntaxe**. Cette erreur apparaît lorsque la [syntaxe](https://www.larousse.fr/dictionnaires/francais/syntaxe/76217 "Syntaxe - Sens 4") du langage n'est pas respecté. Contrairement aux langues que nous utilisons quotidiennement tel que le français ou l'anglais, dans lesquelles nous pouvons faires des erreurs de syntaxe qui n'altère pas le sens. En informatique, une erreur de syntaxe engendre un arrêt du programme, aussi appelé [plantage](https://fr.wikipedia.org/wiki/Plantage). À défaut d'être les plus communes, elle sont les plus simple à corriger.
|
||||||
|
|
||||||
@ -77,4 +77,4 @@ Ce cours présentera plusieurs chapitres sur diverses notions, vous trouverez ci
|
|||||||
----
|
----
|
||||||
### Soutien
|
### Soutien
|
||||||
|
|
||||||
Si vous aimez le projet, vous pouvez le soutenir de plusieurs manière. En le fork sur votre profil github, en y participant et proposant des exemples pour un langage n'en possédant pas encore via les [pull requests](https://github.com/Skycel9/basics-course-of-programming/pulls), ou en mettant une étoile ⭐ !
|
Si vous aimez le projet, vous pouvez le soutenir de plusieurs manières. En le fork sur votre profil github, en y participant et proposant des exemples pour un langage n'en possédant pas encore via les [pull requests](https://github.com/Skycel9/basics-course-of-programming/pulls), ou en mettant une étoile ⭐ !
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user