Skip to content

Commit

Permalink
fr: Format /web/javascript using Prettier (part 10) (#14649)
Browse files Browse the repository at this point in the history
  • Loading branch information
@queengooborg
queengooborg authored Jul 28, 2023
1 parent 670eb49 commit 1a4be8c
Show file tree
Hide file tree
Showing 88 changed files with 1,491 additions and 1,419 deletions.
14 changes: 7 additions & 7 deletions files/fr/web/javascript/reference/operators/comma_operator/index.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@ L'opérateur virgule est à différencier de la virgule utilisée pour séparer
SI on a un tableau à 2 dimensions appelé `monTableau`, qui possède 10 éléments ayant chacun 10 éléments, on peut utiliser le code suivant avec l'opérateur virgule afin d'incrémenter deux variables (`i` et `j`) à la fois. Attention, la virgule utilisée au sein de l'instruction `var` **n'est pas** l'opérateur virgule (car il ne peut exister au sein d'une expression) ; ici c'est un caractère spécial de l'instruction {{jsxref("Instructions/var","var")}}. Le code qui suit affiche les éléments présents sur la diagonale de cette matrice :

```js
for (var i = 0, j = 9; i <= 9; i++, j--){
for (var i = 0, j = 9; i <= 9; i++, j--) {
console.log("monTableau[" + i + "][" + j + "] = " + monTableau[i][j]);
}
```
Expand All @@ -41,27 +41,27 @@ Dans le code suivant, `a` est défini avec la valeur de `b = 3` (qui est 3) et l

```js
var a, b, c;
a = b = 3, c = 4; // Renvoie 4 dans la console
console.log(a); // 3
(a = b = 3), (c = 4); // Renvoie 4 dans la console
console.log(a); // 3
```

Pour isoler la précédence de l'opérateur, on peut utiliser des parenthèses :

```js
var x, y, z;
x = (y = 5, z = 6); // Renvoie 6 dans la console
console.log(x); // 6
x = ((y = 5), (z = 6)); // Renvoie 6 dans la console
console.log(x); // 6
```

### Effectuer un traitement puis renvoyer une valeur

Un autre exemple consiste à effectuer un certain traitement sur la variable puis à renvoyer le résultat. Par définition, seul le dernier élément sera renvoyé mais les instructions précédentes seront bien exécutées. AInsi, on pourrait avoir :

```js
function maFonction () {
function maFonction() {
var x = 0;

return (x += 1, x); // ce qui revient à renvoyer ++x
return (x += 1), x; // ce qui revient à renvoyer ++x
}
```

Expand Down
51 changes: 26 additions & 25 deletions files/fr/web/javascript/reference/operators/conditional_operator/index.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,7 @@ L'**opérateur (ternaire) conditionnel** est le seul opérateur JavaScript qui c
## Syntaxe

```js
condition ? exprSiVrai : exprSiFaux
condition ? exprSiVrai : exprSiFaux;
```

### Paramètres
Expand All @@ -30,7 +30,7 @@ condition ? exprSiVrai : exprSiFaux
SI `condition` vaut `true`, l'opérateur renverra la valeur d'`exprSiVrai;` dans le cas contraire, il renverra la valeur de `exprSiFaux`. Par exemple, on peut afficher un message différent en fonction d'une variable `estMembre` avec cette déclaration :

```js
"Le prix est : " + (estMembre ? "15 €" : "30 €")
"Le prix est : " + (estMembre ? "15 €" : "30 €");
```

On peut également affecter des variables dont la valeur dépendra du test :
Expand All @@ -43,49 +43,50 @@ On peut enchaîner plusieurs évaluations ternaires l'une à la suite de l'autre

```js
var premierControle = false,
secondControle = false,
acces = premierControle ? "Accès refusé" : secondControle ? "Accès refusé" : "Accès autorisé";
secondControle = false,
acces = premierControle
? "Accès refusé"
: secondControle
? "Accès refusé"
: "Accès autorisé";

console.log(acces); // "Accès autorisé"
```

Il est également possible d'utiliser cet opérateur pour effectuer l'une ou l'autre expression selon le cas de figure qui se présente :

```js
var stop = false, age = 16;
var stop = false,
age = 16;

age > 18 ? location.assign("continue.html") : stop = true;
age > 18 ? location.assign("continue.html") : (stop = true);
```

en utilisant l'{{jsxref("Opérateurs/L_opérateur_virgule","opérateur virgule")}}, on peut même y placer plusieurs instructions (attention toutefois à la lisibilité et à se demander si un {{jsxref("Instructions/if...else","if...else")}} n'est pas plus approprié).

```js
var stop = false, age = 23;

age > 18 ? (
console.log("OK, accès autorisé."),
location.assign("continue.html")
) : (
stop = true,
console.log("Accès refusé !")
);
var stop = false,
age = 23;

age > 18
? (console.log("OK, accès autorisé."), location.assign("continue.html"))
: ((stop = true), console.log("Accès refusé !"));
```

De la même façon, on peut effectuer plusieurs opérations, encadrées par des parenthèses, avant d'affecter le résultat de l'opérateur à une variable. Conformément à l'opérateur virgule, ce sera **_la dernière valeur qui sera affectée_**. Ici aussi, attention à la lisibilité du code relativement à un `if...else`.

```js
var age = 16;

var url = age > 18 ? (
console.log("Accès autorisé."),
// console.log renvoie "undefined", mais cela importe peu car
// ce n'est pas le dernier élément de l'expression
"continue.html" // la valeur à affecter si âge > 18
) : (
console.log("Accès refusé !"),
// etc.
"stop.html" // la valeur à affecter si âge <= 18
);
var url =
age > 18
? (console.log("Accès autorisé."),
// console.log renvoie "undefined", mais cela importe peu car
// ce n'est pas le dernier élément de l'expression
"continue.html") // la valeur à affecter si âge > 18
: (console.log("Accès refusé !"),
// etc.
"stop.html"); // la valeur à affecter si âge <= 18

location.assign(url); // "stop.html"
```
Expand Down
56 changes: 28 additions & 28 deletions files/fr/web/javascript/reference/operators/delete/index.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,14 +13,14 @@ L'opérateur **`delete`** permet de retirer une propriété d'un objet.
## Syntaxe

```js
delete expression
delete expression;
```

où _expression_ est évaluée comme une référence à une propriété :

```js
delete objet.propriete
delete objet['propriete']
delete objet.propriete;
delete objet["propriete"];
```

### Paramètres
Expand Down Expand Up @@ -59,12 +59,12 @@ Voici un fragment de code qui illustre certains cas :
```js
var Employe = {
age: 28,
nom: 'abc',
designation: 'developpeur'
}
nom: "abc",
designation: "developpeur",
};

console.log(delete Employe.nom); // renvoie true
console.log(delete Employe.age); // renvoie true
console.log(delete Employe.nom); // renvoie true
console.log(delete Employe.age); // renvoie true

// Lorsqu'on souhaite supprimer une propriété
// inexistante, on obtient true
Expand All @@ -77,19 +77,19 @@ Lorsqu'une propriété est marquée comme non-configurable, `delete` n'aura aucu

```js
var Employe = {};
Object.defineProperty(Employe, 'nom', {configurable: false});
Object.defineProperty(Employe, "nom", { configurable: false });

console.log(delete Employe.nom); // renvoie false
console.log(delete Employe.nom); // renvoie false
```

{{jsxref("Instructions/var","var")}} (ou `let` ou `const`) crée des propriétés non-configurables qui ne peuvent pas être supprimées via `delete` :

```js
var autreNom = 'XYZ';
var autreNom = "XYZ";

// On peut accéder à la description de cette
// propriété globale grâce à :
Object.getOwnPropertyDescriptor(window, 'autreNom')
Object.getOwnPropertyDescriptor(window, "autreNom");

/* Object {value: "XYZ",
writable: true,
Expand All @@ -100,7 +100,7 @@ Object.getOwnPropertyDescriptor(window, 'autreNom')
// On voit que "autreNom", ajouté avec var
// est marquée comme "non-configurable"

delete autreNom; // renvoie false
delete autreNom; // renvoie false
```

En mode strict, cela aurait déclenché une exception.
Expand All @@ -126,7 +126,7 @@ Voyons comment ce code se comporte en mode strict : au lieu de renvoyer false, l
"use strict";

function Employe() {
delete salaire; // SyntaxError
delete salaire; // SyntaxError
var salaire;
}

Expand All @@ -144,25 +144,25 @@ delete DemoFunction; // SyntaxError

```js
// on crée la propriété adminName sur la portée globale
adminName = 'xyz';
adminName = "xyz";

// on crée la propriété empCount sur la portée globale
// On utilise var, elle est donc non-configurable
var empCount = 43;

EmployeeDetails = {
name: 'xyz',
name: "xyz",
age: 5,
designation: 'Developer'
designation: "Developer",
};

// adminName est une propriété de la portée globale
// qui peut être supprimée car configurable.
delete adminName; // renvoie true
delete adminName; // renvoie true

// En revanche empCount n'est pas configurable
// car c'est var qui a été utilisée.
delete empCount; // renvoie false
delete empCount; // renvoie false

// delete peut être utilisé pour retirer des propriétés
// d'objets
Expand All @@ -178,14 +178,14 @@ delete Math.PI; // renvoie false

// EmployeeDetails est une propriété de la portée globale
// définie sans var, elle est donc configurable
delete EmployeeDetails; // renvoie true
delete EmployeeDetails; // renvoie true

function f() {
var z = 44;

// delete n'a pas d'impact sur les noms
// des variables locales
delete z; // returns false
delete z; // returns false
}
```

Expand All @@ -194,7 +194,7 @@ function f() {
Dans l'exemple qui suit, on supprime une propriété directement rattachée à un objet (une propriété « propre ») alors qu'une propriété du même nom existe sur la chaîne de prototypes :

```js
function Toto(){
function Toto() {
this.truc = 10;
}

Expand Down Expand Up @@ -228,17 +228,17 @@ Lorsqu'on supprime un élément d'un tableau, la longueur du tableau n'est pas m
Lorsqu'on utilise `delete` pour retirer un élément du tableau, cet élément n'est plus dans le tableau. Dans l'exemple suivant, on retire `arbres[3]` grâce à `delete`.

```js
var arbres = ["cèdre","pin","chêne","érable","sapin"];
var arbres = ["cèdre", "pin", "chêne", "érable", "sapin"];
delete arbres[3];
if (3 in arbres) {
// Le code ici ne sera pas exécuté
// Le code ici ne sera pas exécuté
}
```

Si on veut conserver l'existence d'un élément du tableau avec une valeur indéfinie, on pourra affecter la valeur `undefined` à cet élément. Ainsi, contrairement à l'exemple précédent, en utilisant `undefined`, `arbres[3]` continue d'être présent :

```js
var arbres = ["cèdre","pin","chêne","érable","sapin"];
var arbres = ["cèdre", "pin", "chêne", "érable", "sapin"];
arbres[3] = undefined;
if (3 in arbres) {
// Le code ici sera bien exécuté
Expand All @@ -248,14 +248,14 @@ if (3 in arbres) {
Si on souhaite plutôt retirer un élément du tableau en changeant le contenu du tableau, on pourra utiliser la méthode {{jsxref("Array.splice()")}}. Dans l'exemple qui suit, la valeur actuelle de `arbres[3]` est retirée du tableau grâce à `splice()` mais l'index suivant se décale et arbres\[4] devient arbres\[3] :

```js
var arbres = ["cèdre","pin","chêne","érable","sapin"];
var arbres = ["cèdre", "pin", "chêne", "érable", "sapin"];
if (3 in arbres) {
// Le code ici sera exécuté
// Le code ici sera exécuté
}
arbres.splice(3, 1);
console.log(arbres); // ["cèdre","pin","chêne","sapin"];
if (3 in arbres) {
// Le code ici sera également exécuté
// Le code ici sera également exécuté
}
```

Expand Down
Loading

0 comments on commit 1a4be8c

Please sign in to comment.