if语句是一种基本的控制结构，用于根据特定条件执行代码块。如果该条件为真（true），则执行代码块。这是一个基本的使用示例：

let number = 10;  
  
if (number > 5) {  
    console.log("这个数字大于5");  
}

以上示例中，有一个变量number，并将其值设为10。然后，使用if语句检查number是否大于5。如果条件为真（即10大于5），则代码块中的console.log语句将被执行，控制台将打印出"这个数字大于5"。

还可以使用else子句来执行一个替代的代码块，如果if条件为假（false）：

let number = 3;  
  
if (number > 5) {  
    console.log("这个数字大于5");  
} else {  
    console.log("这个数字小于或等于5");  
}

在这个例子中，由于number小于5，if条件为假，所以else代码块中的console.log语句被执行。

还有一种else if语句，可以用来检查多个条件：

let number = 10;  
  
if (number > 20) {  
    console.log("这个数字大于20");  
} else if (number > 10) {  
    console.log("这个数字大于10，但小于或等于20");  
} else {  
    console.log("这个数字小于或等于10");  
}

在这个例子中，首先检查number是否大于20。如果不是，接着检查它是否大于10。如果还不是，就认为这个数字小于或等于10，对应的情况下的代码块会被执行。

do-while语句是一种循环控制结构，它允许在循环的至少一次迭代之后执行代码块，并且每次迭代后都会检查条件。下面是do-while语句的基本语法：

do {  
  // 要执行的代码块  
} while (条件);

在这个语法中，首先执行代码块（即循环体），然后检查条件。如果条件为真（true），则继续执行代码块。如果条件为假（false），则停止循环。

下面是一个简单的示例，演示了如何使用do-while语句：

let i = 0;  
  
do {  
  console.log(i);  
  i++;  
} while (i < 5);

在这个示例中，循环体打印变量i的值，并将i的值递增。然后检查i的值是否小于5。如果是，则继续执行循环体。如果不是，则停止循环。因此，这个示例将打印出数字0到4。

while语句是一种循环结构，用于重复执行一段代码，直到给定的条件不再满足。下面是while语句的基本语法：

while (条件) {  
  // 要执行的代码块  
}

在上述语法中，条件是一个表达式，其结果将用于判断循环是否继续。如果条件为真（true），则循环体将被执行；如果条件为假（false），则循环将停止。

以下是一个简单的示例，演示了如何使用while语句：

let count = 0;  
  
while (count < 5) {  
  console.log(count);  
  count++;  
}

在这个示例中，循环体将打印变量count的值，并将count的值递增。然后检查count的值是否小于5。如果是，则继续执行循环体。当count的值达到5时，循环停止，程序结束。因此，这个示例将打印出数字0到4。

for语句是JavaScript中的一种循环结构，用于在一系列迭代中重复执行一段代码。其基本语法如下：

for ([初始化]; [条件]; [最后表达式]) {  
   // 循环体  
}

各个部分的说明：

• 初始化：这是循环开始前执行一次的表达式。通常在此设置循环计数器或定义其他状态。

• 条件：这是一个布尔表达式，在每次循环开始时都会进行评估。如果其结果为true，则执行循环体；如果结果为false，则停止循环。

• 最后表达式：在每次循环的结尾执行的表达式。通常在此更新循环计数器或状态。

• 循环体：当条件为true时执行的代码块。

下面是一个简单的使用for语句的例子，打印从1到10的所有数字：

for (let i = 1; i <= 10; i++) {  
   console.log(i);  
}

在这个例子中，i是计数器，初始值为1。每次循环开始时，都会检查i是否小于等于10。如果是，就会执行循环体（即打印i的值），然后i增加1（i++是i = i + 1的简写）。当i的值超过10时，for循环将停止。

JavaScript中的for-in语句用于遍历对象的属性。基本语法如下：

for (variable in object) {  
   code }

这里variable是临时变量，用于存储当前正在处理的属性的名称，object是要被处理的属性集合（通常是对象）。

例如，有一个名为person的对象，它包含name，age和height属性。可以使用for-in语句遍历这些属性：

var person = {   
   name: 'John',   
   age: 28,   
   height: 178   
};  
  
for (var prop in person) {  
   console.log("Person " + person[prop]);  
}

这段代码将分别打印出"Person John"、"Person 28"和"Person 178"。

注意：for-in语句不仅遍历对象的属性，还遍历其原型链。如果只想遍历对象自身的属性，而不是原型链上的属性，可以使用hasOwnProperty()方法进行检查：

var person = {   
   name: 'John',   
   age: 28,   
   height: 178   
};  
  
for (var prop in person) {  
   if (person.hasOwnProperty(prop)) {  
      console.log("Person " + person[prop]);  
   }  
}

在这个例子中，如果hasOwnProperty()方法返回true，那么才打印属性值。这样就不会打印出原型链上的属性了。

for-of语句是一种遍历可迭代对象（如数组、Map、Set等）中元素的简洁方式。与传统的for循环不同，for-of语句内部处理了迭代器的创建和关闭，因此代码更加简洁。

下面是for-of语句的基本语法：

for (variable of iterable) {  
  // 执行逻辑  
}

在上述代码中：

• variable是临时变量，用于存储当前正在处理的元素。

• iterable是要被遍历的可迭代对象。

• 执行逻辑是要在每次循环中执行的操作。

下面是一个简单的示例，展示如何使用for-of语句遍历数组中的元素：

const array = [1, 2, 3, 4, 5];  
  
for (let value of array) {  
  console.log(value); // 依次打印出 1, 2, 3, 4, 5  
}

除了数组，for-of语句还可以用于遍历其他可迭代对象，例如：

// 遍历 Map 对象  
const map = new Map([['a', 1], ['b', 2], ['c', 3]]);  
  
for (let [key, value] of map) {  
  console.log(key + ': ' + value); // 依次打印出 a: 1, b: 2, c: 3  
}  
  
// 遍历 Set 对象  
const set = new Set([1, 2, 3, 4, 5]);  
  
for (let value of set) {  
  console.log(value); // 依次打印出 1, 2, 3, 4, 5  
}

注意：for-of语句不能用于遍历对象（Object），因为对象不是可迭代的。如果需要遍历对象的属性，可以使用传统的for-in循环。

标签语句用于给语句加标签，这在循环或其他复杂的代码结构中可能特别有用，尤其是当想要识别或跳转到特定的循环迭代或其他语句部分时。语法如下：

label: statement

下面是一个例子：

outerLoop: for(let i = 0; i < 5; i++){  
    for(let j = 0; j < 5; j++){  
        if(j === 2){  
            continue outerLoop;  
        }  
        console.log(i, j);  
    }  
}

在这个例子中，当j等于2时，continue outerLoop将跳过当前循环的剩余部分并开始下一次外层循环的迭代，因此不会打印出所有可能的(i, j)组合，只打印出一部分。

break语句用于在循环或switch语句中跳出当前执行流程。

1. 在循环中使用break：
当在循环中使用break语句时，如果满足某个条件，可以使用break来跳出循环。这样可以避免执行不必要的循环。

例如，以下是一个简单的for循环示例，当i等于3时，使用break跳出循环：

for (let i = 0; i < 10; i++) {  
  if (i === 3) {  
    break; // 当i等于3时跳出循环  
  }  
  console.log(i);  
}

这将输出0到2，当i等于3时，跳出循环。

2. 在switch语句中使用break：
在switch语句中，break用于在执行完一个case后跳出switch语句。如果不使用break，则代码将继续执行下一个case，这通常不是预期的行为。例如：

let fruit = "apple";  
  
switch (fruit) {  
  case "banana":  
    console.log("I am a banana.");  
    break; // 执行完当前case后跳出switch  
  case "apple":  
    console.log("I am an apple.");  
    break; // 执行完当前case后跳出switch  
  case "orange":  
    console.log("I am an orange.");  
    break; // 执行完当前case后跳出switch  
  default:  
    console.log("Unknown fruit.");  
}

这将输出"I am an apple."，因为在执行完"apple"这个case后，使用break跳出了switch语句。如果不使用break，将会继续执行下一个case"orange"，并输出"I am an orange."。

continue语句在JavaScript中用于跳过当前循环中的剩余语句，并立即开始下一次迭代。

continue语句通常用在for或while循环中。当执行到continue语句时，当前循环的剩余语句将被跳过，控制流将立即返回到循环的开始，开始下一次的循环迭代。

下面是一个简单的例子：

for (let i = 0; i < 10; i++) {  
    if (i === 5) {  
        continue; // 当i等于5时跳过剩余语句  
    }  
    console.log(i);  
}

在这个例子中，当i等于5时，continue语句将被执行，因此不会打印出数字5，只有其他数字会被打印出来。

注意：在标签语句（也就是带标签的循环）中，continue语句也可以用于跳出指定的循环。例如：

outerLoop: for(let i = 0; i < 5; i++){  
    for(let j = 0; j < 5; j++){  
        if(j === 2){  
            continue outerLoop; // 当j等于2时跳出outerLoop循环  
        }  
        console.log(i, j);  
    }  
}

在这个例子中，当j等于2时，continue outerLoop将跳出外层循环，因此不会打印出所有可能的(i, j)组合，只有某些组合会被打印出来。

with语句是一种运行时处理JavaScript代码的机制，它可以在当前作用域内临时改变变量的上下文。基本语法如下：

with (expression) {  
  // code block  
}

在这里，expression是一个对象，code block是要在其中执行该对象的代码块。

with语句的主要目的是为了简化代码，减少在多次访问同一对象时重复编写代码的麻烦。例如：

var obj = {x: 10};  
  
with(obj) {  
  console.log(x); // 输出 10  
}

在这个例子中，with(obj)将obj作为当前上下文，因此在with语句块中可以直接使用x，而无需写成obj.x。

然而，使用with语句也有一些缺点。它可能导致代码难以阅读和理解，特别是当使用嵌套的with语句时。此外，with语句可能会引发一些特殊的语言行为，使得一些代码逻辑难以直观地理解。例如，如果在with语句块中有一个变量与外部的一个同名变量冲突，那么该变量将会覆盖外部的变量。

由于这些原因，许多JavaScript的最佳实践建议避免使用with语句，或者至少要非常谨慎地使用它们。在可能的情况下，使用其他结构（如函数或模块）来组织代码可能更为安全和清晰。

switch 语句是一种用于执行不同条件分支的语句。它允许根据表达式的值来执行不同的代码块。基本语法如下：

switch(expression) {  
    case x:  
        // code block  
        break;  
    case y:  
        // code block  
        break;  
    default:  
        // code block  
}

这里的 expression 是需要比较的变量或表达式。case 关键字后面是想要比较的值，然后是大括号内的代码块。如果 expression 的值匹配 case 后的值，那么就会执行这个 case 对应的代码块。

break 关键字是用来跳出 switch 语句的。如果忘记写 break，那么程序会继续执行下一个 case 的代码块，直到遇到 break 或者 switch 语句结束。这就是为什么每个 case 的结束通常都包含一个 break，以防止这种情况发生。

default 关键字对应的代码块在所有 case 不满足条件时执行。这个代码块可以省略，如果没有提供 default，且所有 case 都不满足，那么 switch 语句将不会执行任何操作。

下面是一个具体的例子：

var fruit = "apple";  
  
switch(fruit) {  
    case "banana":  
        console.log("I am a banana.");  
        break;  
    case "apple":  
        console.log("I am an apple.");  
        break;  
    default:  
        console.log("I don't know what fruit I am.");  
}

在这个例子中，因为 fruit 是 "apple"，所以输出的是 "I am an apple."。如果 fruit 是除 "banana" 和 "apple" 之外的其他值，那么将会输出 "I don't know what fruit I am."。