精华内容
下载资源
问答
  • var和let

    2020-10-16 10:30:35
    let是ES6新增的,用来声明局部变量,作用于块级,有暂时性死区的约束;var是函数作用域 var变量提升 var a = 111 f() console.log(a) 111 function f() { console.log(a) 111 } var a = 111 //全局变量 f() //...

    let是ES6新增的,用来声明局部变量,作用于块级,有暂时性死区的约束;var是函数作用域

    • var变量提升
    var a = 111
    f()
    console.log(a)  111
    
    function f() {
        console.log(a)  111
    }
    
    var a = 111   //全局变量
    f()   //函数定义在调用的后面,但是函数声明会提升至作用域的顶部
    console.log(a)  111
    
    function f() {
        console.log(a) //当前变量a是下面变量a声明提升后,默认值为undefined
        var a = 110
        console.log(a)  110
    }
    

    ES6之前,js只有函数和全局作用域

    • let和for循环
      参考博客
    • let没有变量提升和暂时性死区
      暂时性死区:使用let声明之前,该变量不可用
    • let变量不能重复声明
    展开全文
  • var let

    2019-09-28 17:04:24
    1.变量提升,var定义的变量可以在定义前使用然后报undefined的错误,let定义的变量不可以在定义前使用,会报ReferenceError错误 console.log(abs) // abs is not defined var abs = 1 console.log(cca) // Cannot ...

    1.变量提升,var定义的变量可以在定义前使用然后报undefined的错误,let定义的变量不可以在定义前使用,会报ReferenceError错误

    console.log(abs)  // abs is not defined
    var abs = 1
    
    console.log(cca) // Cannot access 'cca' before initialization
    let cca = 2 
    

    2.暂时性区域性
    let 一旦声明就会形成一个自己的变量作用区域只有在这个区域外调用他都会报错,var 则没有

    var a = a  //不报错
    let b=b    //Cannot access 'b' before initialization   也是不能变量提升
    

    3.不能重复定义,let重复定义变量会报错,var则不会

    var d = 3
    let d1 = 4
    var d =4
    let d1 = 5     // Identifier 'd1' has already been declared
    

    本文参考了 阮一峰老师es6 let const

    展开全文
  • var和let和const

    2021-05-10 15:46:38
    var和let和const var和let的使用: 在ES5中,if 和for的都没有作用域,想要有作用域必须要借助function的作用域(ES5中只有function有作用域 <!DOCTYPE html> <html lang="en"> <head> <meta...

    var和let和const

    var和let的使用:

    在ES5中,if 和for的都没有作用域,想要有作用域必须要借助function的作用域(ES5中只有function有作用域

    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    
    <body>
        <button>1</button>
        <button>2</button>
        <button>3</button>
        <button>4</button>
        <button>5</button>
    </body>
    <script src="let和const.js"></script>
    
    </html>
    
    {
        var func;
        if (true) {
            var name = 'why';
            func = function () {
                console.log(name);
            }
            // func()
        }
        name = 'what'
        //在中间可以修改name的值
        //ES5的缺陷
        func()
        // if 的块级作用域必须要借助function
    }
    
    

    在下面代码的第 10 行中的var i = 1,在所有地方的i都会赋值为 1,无论在括号内还是括号外都是 1

    {
        // for块级作用域必须要借用function
        var btns = document.getElementsByTagName('button')
        // for(var i = 0; i <btns.length;i++){
        //     btns[i].addEventListener('click',function(){
        //         console.log('第'+i +'个按钮被点击');
        //     })
        // }
      
        for (var i = 0; i < btns.length; i++) {
            (function (num) {
                btns[i].addEventListener('click', function () {
                    console.log('第' + num + '个按钮被点击');
                })
            })(i)
            //而闭包可以实现,因为函数自己有自己的作用域,不会受外面的影响,只找属于自己的i
    
        }
    } 
    
    {
        console.log('-------ES6定义的let有块级作用域');
        let btns = document.getElementsByTagName('button');
        for (let i = 0; i < btns.length; i++) {
            btns[i].addEventListener('click', function () {
                console.log('第' + i + '个按钮被点击');
            })
        }
    
    }
    

    var和let的使用的范例

    var a = [];
    for (var i = 0; i < 10; i++) {
        a[i] = function () {
            console.log(i);
        };
    }
    a[6]()
    

    输出10

    若将var改成let
    var a = [];
    for (let i = 0; i < 10; i++) {
        a[i] = function () {
            console.log(i);
        };
    }
    a[6]()
    

    输出6

    for (let f = 0; f < 3; f++) {
        let f = 'abc';
        console.log(f);
    }
    

    var 命令会发生“变量提升”现象, 即变量可以在声明之前使用,值为 undefined 。声明了未初始化

    function fn() {
        var a = 1;
        var a = 2;
    }
    

    ​ 两个let或是一个let一个var会报错

    {
        var fn = [];
        for (let i = 0; i < 5; i++) {
            fn[i] = function (x) {
                return x * i;
            };
        }
        console.log(fn[2](10));
    }
    

    输出20,若改为var ,则输出50

    const的用法

    一旦给const修饰的标识符被赋值后,不能修改

    const name = 'why'
     name = 'abc'
    

    在使用const 定义标识符,必须进行赋值

      const name,//直接写会报错
    

    常量的含义是指向的对象不能修改,但是可以改变对象内部的属性

    const obj = {
            name: 'whr',
            age: 18,
            height: 1.55
            }
        obj.name = 'ww';
        obj.age = 22;
        console.log(obj);
    

    对象字面量的增强写法

    ES5的写法

    const name = 'wwww';
        const age = 22;
        const height = 1.5
        //ES5的写法
        const obj = {
            name: name,
            age: age,
            height: height,
            run: function () {
                console.log('running1');
            },
            eat: function () {
                console.log('eating1');
            }
    
        }
        console.log(obj);
    

    ES6的语法糖

        //ES6的写法
        const obj = {
            name,
            age,
            height,
            run() {
    
            },
            eat() {
    
            }
        }
        console.log(obj);
    
    展开全文
  • var和let和const Var (Var) Using var declares either a locally(within function) scoped variable or a globally scoped variable. 使用var声明局部(函数内)范围的变量或全局范围的变量。 范围 (Scope) When ...

    var和let和const

    Var (Var)

    Using var declares either a locally(within function) scoped variable or a globally scoped variable.

    使用var声明局部(函数内)范围的变量或全局范围的变量。

    范围 (Scope)

    When var is used outside a function, it declares a globally scoped variable.

    当在函数外使用var时,它将声明一个全局范围的变量。

    var a = 2; // globally scoped variablefunction foo() {
    console.log(a);
    }foo(); // prints out 2console.log(window.a); // prints out 2

    This is similar to adding a property to window object directly, while there is a difference: you can’t delete the variable declared using var.

    这类似于直接向窗口对象添加属性,但有一个区别:您不能删除使用var声明的变量。

    var a = 2; // globally scoped variablewindow.b = 3; // new property of window object, also globally scopeddelete a; // returns falsedelete b; // returns true

    When var is used inside a function definition, it creates a local variable which is only available within the function:

    当在函数定义中使用var时,它将创建仅在函数中可用的局部变量:

    function bar() {
    var a = 2; // only available inside this function
    console.log(a);
    }bar(); // prints out 2console.log(a); // Uncaught ReferenceError: a is not definedconsole.log(window.a); // prints out undefined

    If you happen to forget to add var in a function when declare a variable, it becomes a globally scoped variable.

    如果您在声明变量时忘了在函数中添加var,它将成为全局范围的变量。

    function foo() {
    a = 2; // note there is no var in front of the variable name
    console.log(a);
    }foo(); // prints out 2console.log(a); // prints out 2console.log(window.a); // prints out 2

    It may not be what you intended to do, for example:

    它可能不是您打算要做的,例如:

    var a = 2;function foo() {
    a = 3; // the value of the global variable a is overwritten here
    console.log(a);
    }console.log(a); // prints out 2foo(); // prints out 3console.log(a); // prints out 3, the old value got overwritten

    吊装 (Hoisting)

    The variables declared with var are hoisted, which means you can use the variables even before it reaches the line in the code it declares the variable.

    用var声明的变量被吊起,这意味着您甚至可以在变量到达声明变量的代码中的行之前使用这些变量。

    console.log(a); // prints out undefined. This doesn't mean the variable a is not defined. It means the value of a is undefineda = 2;console.log(a); // prints out 2 as we just assigned a value to itvar a;

    Note that if you try out above example in Chrome console, copy and paste above code snippet in one shot, i.e. don’t copy and execute each line one at a time; otherwise you’ll get a “Uncaught ReferenceError: a is not defined” error.

    请注意,如果您在Chrome控制台中尝试上述示例,请一次性复制并粘贴以上代码段,即不要一次复制并执行每一行; 否则,您将收到“ Uncaught ReferenceError:未定义”错误。

    (Let)

    Using let declares a block scoped variable.

    使用let声明块范围的变量。

    范围 (Scope)

    The variable declared with let is only available within the code block it is defined.

    用let声明的变量仅在定义的代码块中可用。

    { // note the curly bracket here
    let a = 2;
    console.log(a); // prints out 2
    }console.log(a); // Uncaught ReferenceError: a is not defined

    Unlike var, the variables declared with let is not added to window object as a property even if it is globally accessible.

    与var不同,使用let声明的变量即使可全局访问,也不会作为属性添加到window对象。

    let a = 2;function foo() {
    console.log(a);
    }foo(); // prints out 2console.log(a); // prints out 2console.log(window.a); // prints out undefined

    Unlike var, you can not re-declare a let variable in the same scope.

    与var不同,您不能在同一范围内重新声明let变量。

    let a = 2; // declare for the first time, no problemlet a = 2; // Uncaught SyntaxError: redeclaration of let a

    A fun fact is that both Chrome (84.0.4147.105) console and Microsoft Edge (83.0.478.61) allow this redeclaration, while FireFox (78.0.2) and Safari (13.1.1) don’t.

    一个有趣的事实是Chrome(84.0.4147.105)控制台和Microsoft Edge(83.0.478.61)都允许重新声明,而FireFox(78.0.2)和Safari(13.1.1)不允许。

    吊装 (Hoisting)

    The variables declared with let are not hoisted to the top, hence let variable is still not yet initialized with undefined if user use it before declaration. That’s why there is a temporal death zone, i.e., browsers will report an error if one use the let variable before declaration.

    用let声明的变量未提升到顶部,因此,如果用户在声明之前使用let,则let变量仍未使用undefined初始化。 这就是为什么存在临时死亡区的原因,即,如果一个浏览器在声明之前使用let变量,则浏览器将报告错误。

    function foo() {
    console.log(a);
    let a;
    }foo(); // Uncaught ReferenceError: Cannot access 'a' before initializationfunction bar() {
    let b;
    console.log(b);
    }bar(); // prints undefined

    康斯特 (Const)

    Using const declares and initializes a block scoped constant. If the constant is a primitive type (string, number, bigint, boolean, undefined, and symbol) or null, the value could not be altered after initialization.

    使用const声明并初始化块作用域常量。 如果常量是原始类型(字符串,数字,bigint,布尔值,未定义和符号)或为null,则初始化后不能更改该值。

    {
    const a = 2;
    a = 3; // Uncaught TypeError: Assignment to constant variable.
    }

    While if it points to an object, the properties can be modified/added/deleted. The only thing that cannot be modified is the memory address of the object to which the constant is pointing.

    如果它指向一个对象,则可以修改/添加/删除属性。 唯一不能修改的是常量指向的对象的内存地址。

    {
    const a = {};
    a.foo = "hello";
    a.bar = "world";
    console.log(a.foo); // prints out hello
    console.log(a.bar); // prints out world
    }

    范围 (Scope)

    Like let, const constants are block scoped.

    像let一样,const常量是块范围的。

    {
    const a = 2;
    console.log(a); // prints out 2
    }console.log(a); // Uncaught ReferenceError: a is not defined

    In addition, browsers don’t allow redeclaration of constant in the same block scope, even in Chrome and Microsoft Edge.

    此外,即使在Chrome和Microsoft Edge中,浏览器也不允许在同一块范围内重新声明常量。

    吊装 (Hoisting)

    Like let, const constants are not available before declaration, i.e. browser will report an error if one use it before declaration.

    像let一样,const常量在声明之前不可用,即如果在声明之前使用const常量,浏览器将报告错误。

    翻译自: https://medium.com/@wenhe.qi/understanding-var-let-and-const-with-examples-81dd3ae78c2a

    var和let和const

    展开全文
  • 在JavaScript中有三种声明变量的方式:var、let、const。但是有朋友不清楚这三种声明变量的区别,下面脚本之家小编给大家详细介绍下js中const、var和let的区别,感兴趣的朋友一起看看吧
  • var和let的区别

    2020-08-08 10:07:37
    var和let声明变量最大的区别是 var是与函数作用域绑定的(function scoped) let是与块级作用域绑定的(block scoped) 此外,var还有变量提升(var declaration hoisting)的问题,但let没有这个,因此不存在...
  • var和let,var和const的区别

    千次阅读 2017-07-05 10:59:23
    var和let,var和const的区别;let和const是ES6的语法:ES6虽然现在大多数浏览器还不兼容,还需要转换成ES5,但是以后ES6会是一个趋势。
  • var和let,const区别总结

    千次阅读 2020-07-04 19:43:20
    var和let,const区别 文章目录var和let,const区别一.var1.var属于ES5规范2.预解析3.声明提升4 作用域5.挂载对象二.let1.let属于ES6规范2.let只在块级作用域有效3.let声明变量不会提升4.不能通过let声明和形参相同的...
  • var和let和constby Shirshendu Bhowmick 通过Shirshendu Bhowmick With the old JavaScript, we had only one way to declare a variable, and that was with var, like var x = 10. It will create a variable ...
  • var和let关键字的比较

    2020-03-14 16:18:41
    var和let关键字的比较 说明 let是es6新增的关键字 有效区域 let 是在代码块内有效,var 是在全局范围内有效: { let a = 0; var b = 1; } a // 此时报错ReferenceError: a is not defined b // 此时输出1 重复...
  • JavaScripts中的的var和let关键字 1、 JavaScripts变量的声明 JS变量的声明有三种方式,分别为var、let和const,其中let和const是Es6发布的内容,这里主要讲var和let的差别。 2、JavaScripts中var和let的区别 1.作用...
  • var变量声明会引入了一个新的标识符 declaration,在 JavaScript 中,新创建的变量的默认值都是 undefined。 作用域 JavaScript 的世界共有两种作用域:全局作用域方法作用域。...var let ...
  • javascript中var和let的主要区别 ...
  • js中var和let的区别

    2020-07-27 21:48:26
    var和let的区别 ES6 新增了let命令,用来声明变量。它的用法类似于var,但是所声明的变量,只在let命令所在的代码块内有效。 function func(){ let a = 100; var b = 10; } a // ReferenceError: a is not ...
  • 1.var和let比较 初始化 var和let未初始化的变量默认值都为undefined。 var a1; let a2; console.log(a1+"-"+a2) //undefined--undefined 作用域 var声明的变量作用域的范围为方法作用域,即整个花括号中。 ...
  • var和let/const的区别块级作用域不存在变量提升暂时性死区不可重复声明let、const声明的全局变量不会挂在顶层对象下面const命令两个注意点:const 声明之后必须马上赋值,否则会报错const 简单类型一旦声明就不能再...
  • JS中var和let的区别

    2020-09-10 14:57:24
    var和let的区别: 区别: 1.使用var声明的变量,其作用域为该语句所在的函数内,且存在变量提升现象; 2.使用let声明的变量,其作用域为该语句所在的代码块内,不存在变量提升; 3.let不允许在相同作用域内,重复...
  • var和let/const的区别

    2019-01-05 15:51:00
    var和let/const的区别 let和const是 ES6 新增的命令,用于声明变量,这两个命令跟 ES5 的var有许多不同,并且let和const也有一些细微的不同,再认真阅读了阮一峰老师的文档后,发现还是有一些不...
  • js var和let的区别

    2019-01-14 16:00:43
    1.相同点:var和let都用于声明变量。 2.不同点:同一个变量名,可以用var重复声明,(浏览器)不会报错; 但是用let重复声明同一个变量名会报错。 参考:https://www.runoob.com/js/js-let-const.html ...
  • var和let、const的区别

    2021-03-01 14:50:25
    var和let、const的区别 变量提升 代码执行前,会把所有带var/function关键字的定义进行提前或声明 var会提前声明 function的是声明加定义 全局声明 全局上下文中,var声明的变量会给全局变量window加上一个属性,...
  • var和let以及const的区别 一、var是ES6之前的变量声明方式,使用var声明的变量,其作用域为该语句所在的函数内,并且存在变量提升现象。 由于变量提升的关系,我们可以看到在if语句里面,我们在 a赋值前将其输出并...
  • 在JavaScript中var和let都可以定义变量,但是var定义比较常见,var和let变量有什么区别呢? 内容 var用来定义全局变量,let用来定义局部变量。 1、var { var i = 0; } alert(i); 可以正常运行,var定义全局变量,...
  • var和let都用于声明变量,let是ES6中新增的定义方式 var a=1; let b=2; 两个语法相同,区别如下 二、区别 1. 作用域 块作用域:块作用域由 { } 包括,if语句和for语句里面的{ }也属于块作用域 var定义的变量有 函数...
  • js变量var和let的区别

    2019-11-05 16:20:01
    js变量var和let的区别 在 ES2015 之前,JavaScript 只有两种类型的作用域:全局作用域和函数作用域。 ES2015 引入了两个重要的 JavaScript 新关键词:let 和 const,这两个关键字在 JavaScript 中提供了块作用域...
  • for中用var和let触发定时器的区别 一、题目 以下两个题目分别会console.log出什么东西? // 题目一 for(var i = 0;i < 5;i++){ setTimeout(function(){ console.log(i); }) } // 题目二 for(let i = 0;i < 5...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,413
精华内容 3,765
关键字:

var和let