Anweisungen im JavaScript

Jan 24 2023

JavaScript-Anweisungen sind ein Codeblock, der eine Aktion oder Aufgabe ausführt. Standardmäßig führt der JavaScript-Interpreter diese Anweisungen nacheinander in der Reihenfolge aus, in der sie geschrieben wurden.

Versuchen wir im Folgenden, die verschiedenen Arten von Anweisungen in JS zu verstehen

1. Ausdrucksanweisungen

Ausdrücke, die Nebenwirkungen haben, werden als Ausdrucksanweisungen wie Zuweisungsanweisungen, Funktionsaufrufe, Inkrementierungs- und Dekrementierungsoperatoren, ++ und – im Zusammenhang mit Zuweisungsanweisungen und Löschoperatoren betrachtet.

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

Eine einzelne Anweisung kann mehr als eine Unteranweisung enthalten und wird in JS als zusammengesetzte Anweisung oder Anweisungsblock betrachtet. Die folgenden Zeilen fungieren als eine einzelne Anweisung

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

3. Bedingte Anweisung

Anweisungen, die den JS-Interpreter veranlassen, abhängig vom Wert eines Ausdrucks andere Anweisungen auszuführen oder zu überspringen, z. B. if- und switch- Anweisungen.

3.1 if-Anweisung
ist die grundlegende Kontrollanweisung, die es JS ermöglicht, Entscheidungen zu treffen und Anweisungen bedingt auszuführen.

//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 Switch-Anweisung
Wenn der Wert desselben Ausdrucks verwendet werden kann, um in solchen Fällen eine Entscheidung zwischen mehr als zwei Auswahlmöglichkeiten zu treffen, stellt JS eine Switch-Anweisung bereit.

//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. Loops-Anweisung

Anweisungen, die andere Anweisungen wiederholt ausführen, z. B. while und for.

4.1 While-Schleife
Der Interpreter wertet zunächst den Ausdruck aus . Wenn der Wert des Ausdrucks falsch ist, überspringt der Interpreter die Anweisung , die als Schleifenkörper dient, und fährt mit der nächsten Anweisung im Programm fort. Ist der Ausdruck hingegen wahr, führt der Interpreter die Aussage aus und wiederholt sie.

//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
}

Anweisungen, die den Interpreter veranlassen, zu einem anderen Teil des Programms zu springen, z. B. break , return und throw .

5.1 Beschriftet
Jede Anweisung kann gekennzeichnet werden, indem ihr ein Bezeichner und ein Doppelpunkt vorangestellt werden: Indem Sie eine Anweisung beschriften, geben Sie ihr einen Namen, mit dem Sie an anderer Stelle in Ihrem Programm darauf verweisen können.

//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
Wenn die continue-Anweisung ausgeführt wird, wird die aktuelle Iteration der umschließenden Schleife beendet und die nächste Iteration beginnt.

//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
Die try/catch/finally-Anweisung ist der Ausnahmebehandlungsmechanismus von 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
}

Die nächsten Beiträge sind Teil einer Reihe, in der Grundlagen und fortgeschrittene Themen zu JavaScript besprochen werden.

Wenn Ihnen diese Geschichte gefallen hat, klicken Sie bitte auf die Schaltfläche und teilen Sie sie, damit auch andere sie finden können! Sie können auch gerne unten einen Kommentar hinterlassen.

Groww Engineering veröffentlicht technische Anekdoten, die neuesten Technologien und bessere Möglichkeiten zur Lösung häufiger Programmierprobleme. Sie können sich hier anmelden, um die neuesten Updates zu erhalten.