01.JS的注释和规范

注释：

1. 单行注释：使用双斜线（//）来注释一行代码。例如：// 这是一个单行注释。
2. 多行注释：使用斜线加星号（/*  /)来注释多行代码。例如：/  这是一个多行注释 */。
3. 文档注释：用于描述函数、类或模块的用途、参数、返回值等详细信息。通常以斜线加星号（/** */)开始，后面跟着描述。例如：

/**

• 计算两个数字的和
• @param {number} a 第一个数字
• @param {number} b 第二个数字
• @returns {number} 两个数字的和
  */
  function add(a, b) {
  return a + b;
  }

规范：

1. 缩进：使用四个空格进行缩进，而不是制表符。
2. 命名规范：使用驼峰命名法（camelCase）来命名变量、函数和对象属性。例如：myVariable、myFunction、myObject。
3. 变量声明：使用关键字（var、let、const）声明变量，并在使用之前进行初始化。
4. 换行：每行代码不宜过长，一般建议不超过80个字符。超过时，可以使用换行符进行换行，或者使用括号将代码包裹起来。
5. 语句结束：每个语句结束后，使用分号（;）进行标记。尽管在一些情况下分号可以省略，但为了代码的清晰性和可读性，建议始终使用分号。
6. 代码块：使用大括号（{}）将代码块包裹起来，即使代码块只有一行。这样可以提高代码的可读性，并且有助于避免潜在的错误。

总结：

注释和规范是编写高质量、易于理解和维护的JavaScript代码的重要组成部分。良好的注释和规范可以提高代码的可读性，使其他开发人员更容易理解和使用你的代码。

02.JS的变量

1. 变量声明：

使用关键字（var、let、const）声明变量。例如：var x; 或 let y; 或 const z;

区别

2.变量赋值：

使用等号（=）给变量赋值。例如：x = 5; 或 y = "hello"; 或 const z = true;

3.变量命名规则：

变量名必须以字母、下划线（_）或美元符号（$）开头。

变量名可以包含字母、数字、下划线或美元符号。

变量名区分大小写，例如：myVariable 和 myvariable 是不同的变量。

变量名应具有描述性，以便于理解和维护代码。

4. 变量作用域：

全局作用域：在函数外部声明的变量具有全局作用域，可以在整个代码中访问。

函数作用域：在函数内部声明的变量具有函数作用域，只能在函数内部访问。

块级作用域：使用关键字 let 或 const 在块（例如，if 语句、循环语句）内部声明的变量具有块级作用域，只能在该块内部访问。

5.变量类型：

基本数据类型：包括数字（number）、字符串（string）、布尔值（boolean）、null 和 undefined。

引用数据类型：包括对象（object）、数组（array）、函数（function）等。

6. 变量提升：

在JavaScript中，声明的变量会被提升到作用域的顶部。这意味着可以在变量声明之前使用变量，但它的值将是 undefined。

总结

变量是JavaScript中非常重要的概念，用于存储和操作数据。了解变量的声明、赋值、命名规则、作用域和类型等知识，可以帮助我们编写高质量、易于理解和维护的JavaScript代码。

03.数据类型

1. 基本数据类型：

数字（number）：用于表示数值，包括整数和浮点数。

字符串（string）：用于表示文本，使用单引号（'）或双引号（"）括起来。

布尔值（boolean）：表示真（true）或假（false）的值。

null：表示一个空值。

undefined：表示一个未定义的值。

2. 引用数据类型：

对象（object）：用于存储多个值的集合，以键值对的形式表示。

数组（array）：用于存储多个值的有序集合，通过索引访问元素。

函数（function）：用于封装可执行的代码块。

3. 数据类型转换：

隐式类型转换：

JavaScript会自动进行一些类型转换，例如将数字和字符串相加时，会将数字转换为字符串。

显式类型转换：

可以使用一些内置函数或操作符来显式地进行类型转换。

转换为字符串：

使用 String() 函数或 toString() 方法。

转换为数字：

使用 Number() 函数或 parseInt()、parseFloat() 方法。

转换为布尔值：

使用 Boolean() 函数。

转换为对象：

使用 Object() 函数或直接使用对象字面量（{}）。

转换为数组：

使用 Array.from() 函数或直接使用数组字面量（[]）。

转换为函数：

使用 Function() 构造函数或将函数作为变量传递。

4.检测数据类型

typeof操作符：typeof操作符可以返回一个值的数据类型。例如：

• typeof 5; // 返回 "number"
• typeof "hello"; // 返回 "string"
• typeof true; // 返回 "boolean"
• typeof undefined; // 返回 "undefined"
• typeof null; // 返回 "object"，这是一个历史遗留问题

04.运算符

1.数学运算符

• 加法：+
• 减法：-
• 乘法：*
• 除法：/
• 取余：%

2.赋值运算符

• 简单赋值：=
• 加法赋值：+=
• 减法赋值：-=
• 乘法赋值：*=
• 除法赋值：/=
• 取余赋值：%=
• 左移赋值：<<=
• 右移赋值：>>=
• 无符号右移赋值：>>>=
• 按位与赋值：&=
• 按位或赋值：|=
• 按位异或赋值：^=

3.比较运算符

• 等于：==
• 不等于：!=
• 全等于：===
• 不全等于：!==
• 大于：>
• 小于：<
• 大于等于：>=
• 小于等于：<=

4.逻辑运算符

1. 逻辑与（&&）：

   用法：用于判断多个条件是否同时满足。只有当所有条件都为真（truthy）时，结果才为真。

   真值表：true && true 为 true，其他情况都为 false。

-   示例：

    -   true && true; // 返回 true
    -   true && false; // 返回 false
    -   false && true; // 返回 false
    -   false && false; // 返回 false

2. 逻辑或（||）：

-   用法：用于判断多个条件是否有一个满足。只要有一个条件为真（truthy），结果就为真。

-   真值表：false || false 为 false，其他情况都为 true。

-   示例：

    -   true || true; // 返回 true
    -   true || false; // 返回 true
    -   false || true; // 返回 true
    -   false || false; // 返回 false

3. 逻辑非（!）：

-   用法：用于取反一个条件的值。如果条件为真（truthy），则返回 false；如果条件为假（falsy），则返回 true。

-   示例：

    -   !true; // 返回 false
    -   !false; // 返回 true
    -   !0; // 返回 true
    -   !1; // 返回 false

5.自增自减运算符

1. 自增运算符（++）：

用法：将变量的值增加1。

前置自增：++variable，先将变量的值增加1，然后返回增加后的值。

后置自增：variable++，先返回变量的值，然后将变量的值增加1。

示例：

let x = 5;  
            console.log(++x); // 输出 6  
            console.log(x); // 输出 6
            let y = 10;  
            console.log(y++); // 输出 10  
            console.log(y); // 输出 11

2. 自减运算符（--）：

用法：将变量的值减少1。

前置自减：--variable，先将变量的值减

示例

let x = 5;

console.log(--x); // 输出: 4，先减1再输出
console.log(x); // 输出: 4

let y = 10;

console.log(y--); // 输出: 10，先输出再减1
console.log(y); // 输出: 9

6.三元运算符

条件表达式、问号（?）和两个冒号（:）。三元运算符的语法如下：

条件表达式 ? 表达式1 : 表达式2

其中，条件表达式是一个返回布尔值的表达式。如果条件表达式为真（true），则返回表达式1的值；如果条件表达式为假（false），则返回表达式2的值。

以下是使用三元运算符的示例：

let age = 18;
let isAdult = age >= 18 ? "成年人" : "未成年人";

console.log(isAdult); // 输出: "成年人"

在上面的示例中，如果年龄（age）大于等于18，则将isAdult赋值为"成年人"；否则将isAdult赋值为"未成年人"。

05.条件分支语句

if

if (条件) {
  // 如果条件为真，执行这里的代码块
} else {
  // 如果条件为假，执行这里的代码块
}

其中，条件是一个返回布尔值的表达式。如果条件为真（true），则执行if代码块中的代码；如果条件为假（false），则执行else代码块中的代码。

以下是使用if语句的示例：

let age = 18;

if (age >= 18) {
  console.log("成年人");
} else {
  console.log("未成年人");
}

在上面的示例中，如果年龄（age）大于等于18，则输出"成年人"；否则输出"未成年人"。

除了基本的if语句，还可以使用嵌套if语句和多个else if语句来处理更复杂的条件。

if语句的注意事项：

• 条件表达式必须返回布尔值，如果返回其他类型的值，会进行隐式转换为布尔值。
• if语句中的代码块可以是单条语句或多条语句的块。
• else和else if语句是可选的，可以根据需要选择是否使用。
• 可以嵌套使用if语句，但要注意代码的可读性和复杂度。
• if语句后面的代码块只有在条件为真时才会执行，否则会跳过。
• 可以使用逻辑运算符（如&&、||）组合多个条件。

swich

switch语句的基本语法如下：

switch (表达式) {
  case 值1:
    // 当表达式的值等于值1时执行的代码块
    break;
  case 值2:
    // 当表达式的值等于值2时执行的代码块
    break;
  ...
  default:
    // 如果表达式的值不等于任何一个case的值时执行的代码块
    break;
}

switch语句中的表达式会被求值，然后根据表达式的值与每个case的值进行比较。如果找到了匹配的case，就会执行对应的代码块，然后使用break语句跳出switch语句。如果没有找到匹配的case，就会执行default代码块（如果有），然后跳出switch语句。

以下是使用switch语句的示例：

let day = 3;
let dayName;

switch (day) {
  case 1:
    dayName = "星期一";
    break;
  case 2:
    dayName = "星期二";
    break;
  case 3:
    dayName = "星期三";
    break;
  case 4:
    dayName = "星期四";
    break;
  case 5:
    dayName = "星期五";
    break;
  default:
    dayName = "周末";
    break;
}

console.log(dayName); // 输出: "星期三"

在上面的示例中，根据变量day的值，选择性地执行不同的代码块，并将对应的dayName赋值。

switch语句的注意事项：

• 表达式可以是任何类型的值，包括数字、字符串、布尔值等。
• case后面的值可以是常量、变量或表达式。
• 如果没有在case中使用break语句，会继续执行下一个case的代码块，直到遇到break或switch语句结束。
• default代码块是可选的，用于处理没有匹配到任何case的情况。
• switch语句可以嵌套在其他语句中，但要注意代码的可读性和复杂度。

06.循环分支语句

while

while循环的基本语法如下：

while (条件) {
  // 循环体代码
}

其中，条件是一个返回布尔值的表达式。只要条件为真（true），就会重复执行循环体中的代码。当条件为假（false）时，循环停止，继续执行循环后面的代码。

以下是使用while循环的示例：

let count = 0;

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

在上面的示例中，循环会从0开始，每次打印出count的值，并将count的值加1，直到count的值不再小于5为止。

while循环的注意事项：

• 循环体中的代码会反复执行，直到条件为假。
• 在循环体中需要确保有一种方式可以使条件为假，否则会导致无限

do while

do while循环的基本语法如下：

do
{
  // 循环体代码
} 
while (条件);

其中，条件是一个返回布尔值的表达式。循环体中的代码至少会执行一次，然后在每次执行完循环体后会检查条件是否为真，如果条件为真，则继续执行循环体中的代码，否则循环停止，继续执行循环后面的代码。

以下是使用do while循环的示例：

let count = 0;

do 
{
  console.log(count);
  count++;
}
while (count < 5);

在上面的示例中，循环会从0开始，先执行一次循环体中的代码，然后检查条件是否为真。只要条件为真，就会继续执行循环体中的代码，直到条件为假。

do while循环的注意事项：

• 循环体中的代码至少会执行一次。
• 在循环体中需要确保有一种方式可以使条件为假，否则可能导致无限循环。
• do while循环适用于需要至少执行一次循环体的场景，即使条件一开始就不满足。
• do while循环的条件判断发生在循环体执行完毕之后，这与while循环的条件判断位置不同。

for

for循环的基本语法如下：

for (初始化表达式; 条件表达式; 更新表达式) {
  // 循环体代码
}

其中，初始化表达式在循环开始前执行，用于初始化循环变量。条件表达式在每次循环开始前进行判断，如果条件为真，则执行循环体中的代码。更新表达式在每次循环结束后执行，用于更新循环变量的值。

以下是使用for循环的示例：

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

在上面的示例中，循环从0开始，每次循环时打印出i的值，并将i的值加1，直到i的值不再小于5为止。

for循环的注意事项：

• 初始化表达式只会在循环开始前执行一次。
• 条件表达式在每次循环开始前进行判断，只有条件为真才会执行循环体中的代码。
• 更新表达式在每次循环结束后执行，用于更新循环变量的值。
• 循环体中的代码会根据条件的判断重复执行，直到条件为假。
• 循环变量的作用域仅限于for循环内部。
• 可以根据需要嵌套多层for循环，用于处理多维的数据结构。
• for循环的三个表达式都是可选的，可以根据需要省略其中的任意一个或多个。

循环控制语句

break

1. 在循环中使用break：

   • 在for循环中，当满足某个条件时，可以使用break语句立即终止循环的执行。
   • 在while循环或do...while循环中，同样可以使用break语句来终止循环的执行。

2. 在switch语句中使用break：

   • 在switch语句中，每个case分支通常会以break语句结束，以防止执行其他的case分支。
   • 如果没有在case分支中使用break语句，会导致所有匹配的case分支都会被执行，直到遇到break语句或switch语句结束。

3. break语句的注意事项：

   • break语句只能用于循环语句或switch语句中，不能单独使用。
   • break语句只能终止当前所在的最内层循环或switch语句，不会影响外层的循环或switch语句。
   • 在嵌套循环中，break语句会跳出最近的一层循环，如果想要跳出外层循环，可以使用标签（label）配合break语句实现。

示例

1. 在for循环中使用break：

for (let i = 1; i <= 10; i++) {
  if (i === 5) {
    break; // 当i等于5时，终止循环的执行
  }
  console.log(i);
}
// 输出结果：1 2 3 4

2. 在while循环中使用break：

let i = 0;
while (i < 10) {
  if (i === 5) {
    break; // 当i等于5时，终止循环的执行
  }
  console.log(i);
  i++;
}
// 输出结果：0 1 2 3 4

3. 在switch语句中使用break：

let day = 3;
switch (day) {
  case 1:
    console.log("Monday");
    break;
  case 2:
    console.log("Tuesday");
    break;
  case 3:
    console.log("Wednesday");
    break; // 当day等于3时，终止switch语句的执行
  case 4:
    console.log("Thursday");
    break;
  case 5:
    console.log("Friday");
    break;
  default:
    console.log("Unknown day");
}
// 输出结果：Wednesday

4. 在嵌套循环中使用break和标签：

outerLoop: for (let i = 1; i <= 3; i++) {
  for (let j = 1; j <= 3; j++) {
    console.log(`i = ${i}, j = ${j}`);
    if (i === 2 && j === 2) {
      break outerLoop; // 当i等于2且j等于2时，跳出外层循环
    }
  }
}
// 输出结果：i = 1, j = 1  i = 1, j = 2  i = 1, j = 3  i = 2, j = 1  i = 2, j = 2

这些示例展示了在不同情况下如何使用break语句来终止循环的执行或避免执行其他的case分支。

continue

1. 在循环中使用continue：

   • 在for循环、while循环或do...while循环中，当满足某个条件时，可以使用continue语句跳过当前循环中剩余的代码，并继续下一次循环的执行。

2. continue语句的注意事项：

   • continue语句只能用于循环语句中，不能单独使用。
   • continue语句只会跳过当前循环中剩余的代码，并继续下一次循环的执行，不会终止循环。
   • 在嵌套循环中，continue语句只会跳过当前循环的剩余代码，不会影响外层的循环。

总结起来，continue语句在JavaScript中用于跳过当前循环中的剩余代码，并继续下一次循环的执行。它可以在循环中使用，以便在满足某个条件时跳过当前循环的执行。

示例

1. 在for循环中使用continue：

for (let i = 1; i <= 5; i++) {
  if (i === 3) {
    continue; // 当i等于3时，跳过当前循环的剩余代码，继续下一次循环的执行
  }
  console.log(i);
}
// 输出结果：1 2 4 5

2. 在while循环中使用continue：

let i = 1;
while (i <= 5) {
  if (i === 3) {
    continue; // 当i等于3时，跳过当前循环的剩余代码，继续下一次循环的执行
  }
  console.log(i);
  i++;
}
// 输出结果：1 2 4 5

3. 在嵌套循环中使用continue：

for (let i = 1; i <= 3; i++) {
  for (let j = 1; j <= 3; j++) {
    if (j === 2) {
      continue; // 当j等于2时，跳过当前循环的剩余代码，继续下一次循环的执行
    }
    console.log(`i = ${i}, j = ${j}`);
  }
}
// 输出结果：i = 1, j = 1  i = 1, j = 3  i = 2, j = 1  i = 2, j = 3  i = 3, j = 1  i = 3, j = 3

这些示例展示了在不同情况下如何使用continue语句来跳过当前循环中的剩余代码，并继续下一次循环的执行。

07. 求质数案例

var num = 20; // 要判断的数

var isPrime = true;

if (num === 1) {
  isPrime = false;
} else {
  for (var i = 2; i < num; i++) {
    if (num % i === 0) {
      isPrime = false;
      break;
    }
  }
}

if (isPrime) {
  console.log(num + " 是一个质数");
} else {
  console.log(num + " 不是一个质数");
}

在该示例中，我们首先将要判断的数赋值给变量 num，然后定义一个 isPrime 变量来表示该数是否为质数。

然后我们使用一个 if-else 语句来判断 num 是否等于 1，如果是，那么它不是一个质数；否则，我们使用一个 for 循环来遍历从 2 开始到 num 前一个数的所有数字。在循环中，我们使用取余操作符 % 来判断 num 是否可以被当前数字整除，如果可以，那么它不是一个质数，将 isPrime 设置为 false 并跳出循环。

最后，我们使用一个 if-else 语句来根据 isPrime 的值输出结果，如果为 true，则表示 num 是一个质数，否则不是。

08.九九乘法表案例

var table = '';

for (var i = 1; i <= 9; i++) {
  for (var j = 1; j <= i; j++) {
    table += j + ' * ' + i + ' = ' + (i * j) + '  ';
  }
  table += '\n';
}

console.log(table);

这段代码使用两个嵌套的for循环来生成九九乘法表的每一行。外层循环控制行数，内层循环控制每一行的列数。通过字符串拼接，将每一行的乘法表达式添加到变量table中。最后，通过console.log(table)打印出整个九九乘法表。

运行这段代码，将会输出如下的九九乘法表：

1 * 1 = 1  
1 * 2 = 2  2 * 2 = 4  
1 * 3 = 3  2 * 3 = 6  3 * 3 = 9  
1 * 4 = 4  2 * 4 = 8  3 * 4 = 12  4 * 4 = 16  
1 * 5 = 5  2 * 5 = 10  3 * 5 = 15  4 * 5 = 20  5 * 5 = 25  
1 * 6 = 6  2 * 6 = 12  3 * 6 = 18  4 * 6 = 24  5 * 6 = 30  6 * 6 = 36  
1 * 7 = 7  2 * 7 = 14  3 * 7 = 21  4 * 7 = 28  5 * 7 = 35  6 * 7 = 42  7 * 7 = 49  
1 * 8 = 8  2 * 8 = 16  3 * 8 = 24  4 * 8 = 32  5 * 8 = 40  6 * 8 = 48  7 * 8 = 56  8 * 8 = 64  
1 * 9 = 9  2 * 9 = 18  3 * 9 = 27  4 * 9 = 36  5 * 9 = 45  6 * 9 = 54  7 * 9 = 63  8 * 9 = 72 

总结

来源