变量提升和函数提升

变量提升 和 函数提升

只有使用var声明的变量才会变量提升,let和const声明的变量不存在。
函数提升优先级高于变量提升

1
2
3
4
5
6
7
foo();
function foo(){
console.log('1');
}
var foo=function(){
console.log('2');
}

实际上会变成

1
2
3
4
5
6
7
8
function foo(){
console.log('1');
}
var foo;
foo(); // 1
foo=function(){
console.log('2');
}

我们先来试试看下面这段代码~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function Foo() {
getName = function(){ alert(1); };
return this;
}
Foo.getName = function() { alert(2); };
Foo.prototype.getName = function(){ alert(3); };
var getName = function() { alert(4); };
function getName(){ alert(5); }
Foo.getName(); // ?
getName(); // ?
Foo().getName(); // ?
getName(); // ?
new Foo.getName(); // ?
new Foo().getName(); // ?
new new Foo().getName(); // ?

  • 变量提升

    1
    2
    3
    4
    5
    6
    7
    8
    9
    var a='1';
    function test(){
    console.log(a); // undefine ,存在变量提升
    if(!a){ //满足要求进入if代码块
    var a=0;
    console.log(a); // 0
    }
    }
    test();

    只有使用var声明的变量才会变量提升

    1
    2
    3
    4
    5
    6
    7
    8
    9
    var a='1';
    function test(){
    console.log(a); // 1 ,不存在变量提升,即寻找全局变量,
    if(!a){
    a=0; //不会变量提升
    console.log(a);
    }
    }
    test();
  • 函数提升

    • 函数声明

      1
      2
      3
      4
      5
      6
      foo();
      var a='test';
      function foo(){
      console.log(n);
      var n=2;
      }

      执行的时候,foo()函数生命给你会提升到作用域的最顶部

      1
      2
      3
      4
      5
      6
      7
      function foo(){
      var n;
      console.log(n);
      n=2;
      }
      var a='test'; // 函数提升 高于 变量提升
      foo();
    • 函数表达式,不会函数提升(实际上是变量提升)

      1
      2
      3
      4
      foo();
      var foo=function(){
      console.log('hello');
      }

      实际执行的时候,只有变量提升

      1
      2
      3
      4
      5
      var foo;
      foo(); //出错
      foo=function(){
      console.log('hello');
      }