loyalvi
js语句
loyalvi Lv7
  2026-03-13 16:44:14   2026-03-16 10:42:02    

JS语句

var 和 let 语句

var 关键字用来定义变量，如果在函数内部定义，则定义的变量只能在函数内部使用， 如果在函数外部定义，则会成为全局变量 。 在函数中使用变量时会优先使用内部变量，只有找不到内部变量时才会使用全局变量。
js中函数的执行方式
js中自运行的匿名函数
在 ES2015 中可以使用 let 来定义块级变量，这样定义的变量在块的外部不可以使用。

let const var的区别

在 JavaScript 中，let、const 和 var 都是用于声明变量的关键字，但它们在作用域、提升行为和重新声明等方面有显著的区别。以下是它们的详细对比：

1. 作用域

  • var
    • 函数作用域：var 声明的变量在声明它的函数内部有效。如果在函数外部声明，则在全局作用域中有效。
    • 示例：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      function testVar() {
          var x = 1;
          if (true) {
              var x = 2; // 重新声明，但仍然在函数作用域内
              console.log(x); // 2
          }
          console.log(x); // 2
      }
      testVar();
  • let 和 const
    • 块级作用域：let 和 const 声明的变量在声明它的块（{}）内部有效。如果在函数外部声明，则在全局作用域中有效，但仍然是块级作用域。
    • 示例：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      function testLetConst() {
          let y = 1;
          const z = 2;
          if (true) {
              let y = 3; // 块级作用域，与外层的 y 不同
              const z = 4; // 块级作用域，与外层的 z 不同
              console.log(y); // 3
              console.log(z); // 4
          }
          console.log(y); // 1
          console.log(z); // 2
      }
      testLetConst();

2. 提升（Hoisting）

  • var
    • 变量提升：var 声明的变量会被提升到函数或全局作用域的顶部，但初始化（赋值）不会被提升。在声明之前访问变量会得到 undefined。
    • 示例：
      1
      2
      3
      console.log(x); // undefined
      var x = 1;
      console.log(x); // 1
  • let 和 const
    • 暂时性死区（Temporal Dead Zone, TDZ）：let 和 const 声明的变量也会被提升，但它们在块的开始到声明点之间处于暂时性死区。在声明之前访问变量会抛出 ReferenceError。
    • 示例：
      1
      2
      3
      4
      5
      6
      console.log(y); // 抛出 ReferenceError
      let y = 1;
      console.log(y); // 1
      console.log(z); // 抛出 ReferenceError
      const z = 2;
      console.log(z); // 2

3. 重新声明

  • var
    • 允许重新声明：var 声明的变量可以在同一个作用域内多次声明，后面的声明会覆盖前面的声明。
    • 示例：
      1
      2
      3
      var a = 1;
      var a = 2;
      console.log(a); // 2
  • let 和 const
    • 不允许重新声明：let 和 const 声明的变量不能在同一个作用域内多次声明。尝试重新声明会抛出 SyntaxError。
    • 示例：
      1
      2
      3
      4
      let b = 1;
      let b = 2; // 抛出 SyntaxError
      const c = 1;
      const c = 2; // 抛出 SyntaxError

4. 常量性

  • var 和 let
    • 可变：var 和 let 声明的变量可以重新赋值。
    • 示例：
      1
      2
      3
      4
      5
      6
      var d = 1;
      d = 2;
      console.log(d); // 2
      let e = 1;
      e = 2;
      console.log(e); // 2
  • const
    • 不可变：const 声明的变量必须初始化，并且不能重新赋值。但需要注意的是，如果 const 声明的是一个对象或数组，对象的属性或数组的元素可以被修改。
    • 示例：
      1
      2
      3
      4
      5
      6
      7
      8
      const f = 1;
      f = 2; // 抛出 TypeError
      const g = { name: "John" };
      g.name = "Jane"; // 允许修改对象的属性
      console.log(g); // { name: "Jane" }
      const h = [1, 2, 3];
      h.push(4); // 允许修改数组的元素
      console.log(h); // [1, 2, 3, 4]

5. 总结

  • var
    • 函数作用域：在函数内部有效。
    • 变量提升：声明会被提升，但初始化不会。
    • 允许重新声明：可以在同一个作用域内多次声明。
    • 可变：可以重新赋值。
  • let
    • 块级作用域：在块（{}）内部有效。
    • 暂时性死区：声明会被提升，但在声明点之前访问会抛出 ReferenceError。
    • 不允许重新声明：不能在同一个作用域内多次声明。
    • 可变：可以重新赋值。
  • const
    • 块级作用域：在块（{}）内部有效。
    • 暂时性死区：声明会被提升，但在声明点之前访问会抛出 ReferenceError。
    • 不允许重新声明：不能在同一个作用域内多次声明。
    • 不可变：必须初始化，不能重新赋值，但对象的属性和数组的元素可以被修改。

6. 最佳实践

  • 使用 let 和 const：在现代 JavaScript 编程中，推荐使用 let 和 const，因为它们提供了更严格的作用域规则和更好的块级作用域支持，有助于避免一些常见的变量声明和作用域问题。
  • 默认使用 const：如果变量的值不需要改变，使用 const 声明。如果需要重新赋值，使用 let 声明。尽量避免使用 var。
    希望这些解释能帮助你更好地理解和使用 let、const 和 var。

delete

在 JavaScript 中，delete 语句用于删除对象的属性。它不会删除变量或函数声明，但可以删除对象上的属性或方法。以下是关于 delete 语句的详细解释：

语法

1
2
3
delete object.property;
delete object[index];
delete property; // 仅在 with 语句中有效

示例

删除对象属性

1
2
3
4
5
6
7
8
let person = {
    firstName: "John",
    lastName: "Doe",
    age: 30
};
console.log(person); // { firstName: 'John', lastName: 'Doe', age: 30 }
delete person.age;
console.log(person); // { firstName: 'John', lastName: 'Doe' }

删除数组元素

1
2
3
4
let fruits = ["Apple", "Banana", "Cherry"];
console.log(fruits); // ['Apple', 'Banana', 'Cherry']
delete fruits[1];
console.log(fruits); // ['Apple', undefined, 'Cherry']

注意事项

  1. 删除属性后的影响
    • 删除对象属性后，该属性将不再存在，访问该属性会返回 undefined。
    • 删除数组元素后，该位置的元素会变成 undefined，数组的长度不会改变。
  2. 无法删除某些属性
    • 一些对象的属性是不可删除的，例如 Math 对象的属性和 Object.prototype 上的属性。
    • 例如：
      1
      2
      3
      4
      delete Math.PI; // 返回 false，Math.PI 仍然存在
      console.log(Math.PI); // 3.141592653589793
      delete Object.prototype.toString; // 返回 false，Object.prototype.toString 仍然存在
      console.log(Object.prototype.toString); // function toString() { [native code] }
  3. 删除变量和函数声明
    • delete 不能删除变量或函数声明，但可以删除通过 var 声明的变量在全局对象上的属性。
    • 例如：
      1
      2
      3
      4
      5
      6
      var x = 1;
      console.log(delete x); // false
      console.log(x); // 1
      // 在全局作用域中
      delete window.x; // true
      console.log(window.x); // undefined
  4. 严格模式下的行为
    • 在严格模式下，delete 不能删除变量或函数声明，尝试删除会抛出 SyntaxError。
    • 例如：
      1
      2
      3
      'use strict';
      var y = 1;
      delete y; // 抛出 SyntaxError

总结

  • delete 语句用于删除对象的属性。
  • 删除属性后，该属性将不再存在，访问该属性会返回 undefined。
  • 一些对象的属性是不可删除的，例如 Math 对象的属性和 Object.prototype 上的属性。
  • delete 不能删除变量或函数声明，但可以删除通过 var 声明的变量在全局对象上的属性。
  • 在严格模式下，delete 不能删除变量或函数声明，尝试删除会抛出 SyntaxError。
    理解 delete 语句的这些特性可以帮助你更有效地管理对象的属性。

if-else 语句

while 语句

do-while 语句

for 语句

for-in 语句

continue 语句

with 语句

JS 是一种面向对象的语言，对象主要是通过其属性来使用，如果需要对同一个对象的多 个属性多次进行操作，就需要多次写对象的名称，例如下面的操作 。

1
2
$("#cur").css("color","yellow"); 
$("#cur").css("backgroundColor","red");

这个例子中重复使用了$("#cur")，这时就可以使用 with 语句 。

1
2
3
4
with ($("#cur")){
	css("color","yellow")
	css("backgroundColor","red")
}

这两种写法的作用是相同的，只是将所要操作的对象 $("#cur") 统一放到 with 语句的小括号中。 with 语句的作用就是指定所操作的对象，但是由于它会影响运行速度且不利于优化，所以不建议使用，并且在 strict model （严格模式） 下已经禁用了 with 语句

switch-case-default 语句

switch 语句用于对指定变量进行分类处理，不同的类型使用不同的 case 语句进行区分
要使用 break 语句跳出，否则会接着执行下一种类型的相应语句。另外，在 switch 语句中经常会用到 default 语句，用于在所有 case 都不符合条件时执行。 default 语句应放在所有 case 语句之后。
switch 和 if-else 语句的区别是， switch 语句只是对单一的变量进行分类处理，而 if-else 可以在不同的判断条件中对不同的变量进行判断。因此， if-else 语句更加灵活， switch 语句更加简单、清晰。

try-catch-finally 语句

try语句用于处理异常，其结构如下 。

1
try{ 正常语句块 } catch (error) { 异常处理语句块 } finally { 最后执行语句}

另外，如果没有必须执行的语句，那么也可以省略 finally 语句块 。

throw 语句

throw 用于主动抛出异常。 JS 中 throw 抛出的异常可以是任何类型的，而且可以使用 try－ catch 语句进行捕获， catch 捕获到的就是 throw 所抛出的。

js语句
posts/fb663874/
作者
loyalvi
发布于
2026-03-13 16:44
许可
  1. JS语句
    1. var 和 let 语句
    2. let const var的区别
      1. 1. 作用域
      2. 2. 提升（Hoisting）
      3. 3. 重新声明
      4. 4. 常量性
      5. 5. 总结
      6. 6. 最佳实践
    3. delete
      1. 语法
      2. 示例
        1. 删除对象属性
        2. 删除数组元素
      3. 注意事项
      4. 总结
    4. if-else 语句
    5. while 语句
    6. do-while 语句
    7. for 语句
    8. for-in 语句
    9. continue 语句
    10. with 语句
    11. switch-case-default 语句
    12. try-catch-finally 语句
    13. throw 语句
© 2020 - 2026    loyalvi
由 Hexo 驱动 & 主题 Keep
访客数 访问量
  1. JS语句
    1. var 和 let 语句
    2. let const var的区别
      1. 1. 作用域
      2. 2. 提升（Hoisting）
      3. 3. 重新声明
      4. 4. 常量性
      5. 5. 总结
      6. 6. 最佳实践
    3. delete
      1. 语法
      2. 示例
        1. 删除对象属性
        2. 删除数组元素
      3. 注意事项
      4. 总结
    4. if-else 语句
    5. while 语句
    6. do-while 语句
    7. for 语句
    8. for-in 语句
    9. continue 语句
    10. with 语句
    11. switch-case-default 语句
    12. try-catch-finally 语句
    13. throw 语句