Déclarations dans le JavaScript

Les instructions JavaScript sont un bloc de code qui exécute une action ou une tâche. Par défaut, l'interpréteur JavaScript exécute ces instructions les unes après les autres dans l'ordre dans lequel elles sont écrites.

Essayons de comprendre les différents types d'instructions dans JS ci-dessous

1. Déclarations d'expression

Les expressions qui ont des effets secondaires sont considérées comme des instructions d'expression telles que les instructions d'affectation, l'appel de fonction, les opérateurs d'incrémentation et de décrémentation, ++ et - liés aux instructions d'affectation et les opérateurs de suppression.

let greeting = “Hello “ + name; //assignment statement
counter ++; // increment operator which is changing a variable value
delete o.x; // deleting a property of an object O
cx = Math.cos(x);; // function invocation and assign the value to a variable

Une seule instruction peut contenir plusieurs sous-instructions et est considérée comme une instruction composée ou un bloc d'instructions dans JS. Les lignes suivantes agissent comme une seule déclaration

{ 
 x = Math.PI; 
 cx = Math.cos(x);
 console.log(“cos(π) = “ + cx);
}

3. Déclaration conditionnelle

Les instructions qui font que l'interpréteur JS exécute ou ignore d'autres instructions en fonction de la valeur d'une expression comme les instructions if et switch .

3.1 if Statement
l'instruction de contrôle fondamentale qui permet à JS de prendre des décisions et d'exécuter des instructions de manière conditionnelle.

//syntax
If (expression) 
 Statement1
else 
 Statement 2

//example
if (n === 1) { //curly braces are optional in case of single statement
 console.log("You have 1 new message.");
} else {
 console.log(`You have ${n} new messages.`);
}

3.2 Instruction switch
Lorsque la valeur de la même expression peut être utilisée pour prendre une décision entre plus de 2 choix, dans de tels cas, JS fournit une instruction switch.

//Syntax
switch(expression) {
 case label1: statement1; // if expression value === label1 execute statement1
 case label2: statement2; // if expression value === label2 execute statement2
 … 
 default: default_statement; // optional
}

//Example:
switch(n) {
  case 1:                        
   // Start here if n === 1.(sameness is determined by the === operator)
   // Execute code block #1.
   break;                         // stop here
  case 2:                         
    // Start here if n === 2
    // Execute code block #2.
   break;                         // Stop here
  case 3:                         
    // Start here if n === 3
    // Execute code block #3;
   break;                         // Stop here
  default:                        
    // If no case match the value of n
    // Execute code block #4.
}

4. Déclaration de boucles

Les instructions qui exécutent d'autres instructions de manière répétitive, comme while et for.

4.1 Boucle While
L'interpréteur évalue d'abord l' expression . Si la valeur de l'expression est fausse, l'interpréteur ignore l' instruction qui sert de corps de boucle et passe à l'instruction suivante du programme. Si, au contraire, l' expression est véridique, l'interprète exécute l' énoncé et le répète.

//Syntax
while (expression) { //curly braces are optional in case of single statement
  //statment or statement block
}

//Example
let count = 0;
while(count < 10) {
 console.log(count);
 count++;
}

//Syntax
do { //curly braces are optional in case of a single statement
 //statement / statement block
} 
while (expression);

//Example
let count = 0;
do {
 console.log(count);
 count++;
}
while (count < 10);

//syntax
for(initialize ; test ; increment) { //curly braces are optional in case of single statement
 //statement / statement block
}
//Example:
for(let count = 0; count < 10; count++) {
 console.log(count);
}

//Syntax with example
let data = [1, 2, 3, 4, 5, 6, 7, 8, 9], sum = 0;
for(let element of data) {
 sum += element;
}

// for of with map
let m = new Map([[1, "one"]]);
for(let [key, value] of m) {
 key    // => 1
 value  // => "one"
}

//syntax
for (variable in object) {
 //statement / statement block
}

//Example:
for(let p in o) { // Assign property names of o to variable p
 console.log(o[p]); // Print the value of each property
}

Les instructions qui amènent l'interpréteur à passer à une autre partie du programme, comme break , return et throw .

5.1 Étiqueté
Toute instruction peut être étiquetée en la faisant précéder d'un identificateur et de deux-points :, En étiquetant une instruction, vous lui donnez un nom que vous pouvez utiliser pour vous y référer ailleurs dans votre programme.

//syntax
identifier: statement

//example
mainloop: while(token !== null) {
 // Code omitted…
 continue mainloop; // Jump to the next iteration of the named loop(mainloop)
 // More code omitted…
}

5.2 Continue
Lorsque l'instruction continue est exécutée, l'itération en cours de la boucle englobante est terminée et l'itération suivante commence.

//example
for(let i = 0; i < data.length; i++) {
 if (!data[i]) continue; // jump to the next iteration of the loop
 total += data[i];
}

//syntax
return expression;

//Example
function square(x) { return x*x; } // A function that has a return statement
square(2) // => 4

// A generator function that yields a range of integers
function* range(from, to) {
  for(let i = from; i <= to; i++) {
    yield i;
  }
}

try/catch/finally
L'instruction try/catch/finally est le mécanisme de gestion des exceptions de JavaScript.

//syntax
try {
 //Normally, this code runs from the top of the block to the bottom
 //without problems. But it can sometimes throw an exception,
 //either directly or with a throw statement.
} catch(e) {
 // The statements in this block are executed if, and only if, the try
 // block throws an exception. These statements can use the local variable
 // e to refer to the Error object or other value that was thrown.
} finally {
 // This block contains statements that are always executed, regardless of
 // what happens in the try block. They are executed whether the try
 // block terminates:
}

//example
try {
  // Ask the user to enter a number
  let n = Number(prompt("Please enter a positive integer", ""));
  // Compute the factorial of the number, assuming the input is valid
  let f = factorial(n);
  // Display the result
  alert(n + "! = " + f);
} catch(e) {     // If the user's input was not valid, we end up here
  alert(e);  // Tell the user what the error is
}

Ces prochains articles feront partie d'une série traitant des bases et des sujets avancés sur JavaScript.

• Opérateurs en Javascript
• Objets en Javascript

Si vous avez apprécié cette histoire, veuillez cliquer sur le bouton et la partager, afin que d'autres puissent également la trouver ! Aussi, n'hésitez pas à laisser un commentaire ci-dessous.

Groww Engineering publie des anecdotes techniques, les dernières technologies et de meilleures façons de résoudre les problèmes de programmation courants. Vous pouvez vous inscrire ici pour obtenir les dernières mises à jour.

Nous recrutons. Voir les offres d'emploi ici .