函数提升,执行上下文

原文地址:

函数的调用方式

  • 普通的函数调用方式直接调用(this丢失问题): window(非严格) |
    undefined(严格)
  • new构造函数调用方式, 构造函数内部新创建的对象
  • 作为一个对象的方法调用, 指向当前的对象
  • call | apply(函数上下文), 指向第一参数

1.函数的声明定义

两种方式:

函数声明语句

function foo1(args){
var x = 'hello';
}

函数表达式

var foo2 = function(args){ var x = 'hello'  };

两种的区别:
第一种,函数的定义会在执行上下文开始执行代码之前被提升,通俗的讲,就是在函数声明语句之前就可以调用函数了。
第二种,在执行上下文开始执行代码之前,只有变量foo2会被提升,变量的初始化还在原来代码的位置,所以在函数表达式之前,foo2的值为undefined。
函数声明和定义可以嵌套到其他函数里

JavaScript
中的执行上下文和调用栈

ES6
变量作用域与提升:变量的生命周期详解

严格模式

  1. 定义: 在此模式下, 会做更加严格的语法检查
    • 以前在非严格模式下可以使用的一些语句,
      在严格模式下直接报错或者抛出异常
  2. 开启严格模式: "use strict";
    • 书写注意
      • 分号可省略
      • 单引号/双引号都可以
      • 区分大小写, 都是小写
      • 必须是10个字符, 需要把字符串写在script标签顶部
  3. 兼容:
    如果浏览器支持严格模式就会开启严格模式,如果不支持,'use strict'作为一段字符串忽略处理
  4. 严格模式作用域
    • script的顶部, 对整个script标签内有效
    • 写在函数的顶部, 只对当前这个函数有效

2.函数调用

函数声明的调用foo1() //这种是作为函数调用
作为方法属性调用 obj.foo() //这种是作为方法调用
构造函数调用 new Foo() //用于新建对象

三种的区别:

以函数调用形式调用的函数其this的值为全局对象(非严格)或者undefined(严格模式),不管这个函数声明在其他函数里还是在其他地方

以方法形式调用的函数其this的值为调用它的对象

function foo1(){
console.log(this);
foo2();
function foo2(){
console.log(this)
} 
}
var obj ={name : "obj", foo : foo1};
obj.foo();   //结果输出为{name: "obj", foo: ƒ}  和window
//直接在浏览器的控制台粘贴这段代码看结果

将foo2的函数声明变为函数表达式再试试

function foo1(){
console.log(this);
var foo2 = function (){
console.log(this)
} 
foo2();            //这里输出的this为什么为window??????
}
var obj ={name : "obj", foo : foo1};
obj.foo();
//对于foo2为什么输出的是window我也很疑惑,函数表达式调用其实是看作方法调用的,
//所以foo2里的this应该是调用它的作用域的变量对象,很疑惑

构造函数调用
构造函数调用创建一个新的空对象,这个对象继承自构造函数的prototype属性,构造函数可以初始化这个新的对象,并将这个对象作为其的调用上下文(this),可以用this引用新创建的对象。如
new o.m();中,m调用的上下文不是o。//一般不这么用
构造函数一般没有返回值,不过如果显式地返回一
个对象,则这个调用表达式的值就是这个对象 // 一般不这么用

变量提升

  • 变量的定义在代码预解析时,在作用域顶部定义
  • 无 var 没有变量提升

console.log(a);  // undefined,如果没有定义会直接报错
var a = 'aaa';
console.log(a);  // aaa

// 下面代码全等于上面代码
var a;  // 变量提升,函数作用域范围内
console.log(a);  // undefined
a = 'aaa';
console.log(a);  // aaa

console.log(a);  // 直接报错
a = 'aaa';

严格模式注意点

  1. 必须使用Var关键字声明变量
  2. 使用delete关键字删除全局变量会直接报错
  3. 对象中不能存在同名的属性
    • 编译器错误
  4. 函数的形参必须唯一(不能出现同名的参数)
    • 编译器错误
  5. 禁止使用with语句
  6. 不能使用eval和arguments作为标识符
  7. 修正函数内部this的指向
    • 在严格模式下, this始终指向指定的值(未指定的话, 就指向undefined)
    • obj.showName.call(null); //指向null
  8. 禁止使用8进制
  9. 在if语句中不能申明函数
  10. 不能使用callee/caller, 一个指向函数自身/返回调用函数的函数
    • 在全局作用域中, caller返回null
  11. 在严格模式下, arguments的使用区别
    • 在非严格模式下, arguments和形参共享同一份数据
    • 在严格模式下, arguments和形参是独立的

3.函数的作用域(链)

函数的作用域链在函数声明定义的时候就已确定了(这里很难讲清楚,应该说是在声明定义时确定了一条作用域链,这个作用域链不包括函数本身的作用域,只有在函数被调用时,函数本身的作用域才加入到其作用域链顶部)。

不管函数在哪里被调用,它的作用域链在定义时就被确定了,作用域链只和函数被定义的地方有关。

对于作为对象方法的函数的作用域:
var obj = {name : 'obj' ,
           foo : function(args){ console.log(name)} ,
           callfoo : function(){ obj.foo();} 
};
var name = 'scope';
function outterFoo(){ console.log(name)};
obj.foo();
outterFoo();
obj.callfoo();
//输出的结果都为scope

作为对象方法的函数的作用域链(未被调用前)和与对象在同一层的函数的作用域链是一样的。

函数提升

  • 函数的定义在代码预解析时,在作用域顶部定义
  • 函数赋值在作用域顶部

console.log(f1);  // f1() { console.info('函数'); }
var f1 = function() { console.info('变量'); }
console.log(f1);  // ƒ () { console.info('变量'); }
function f1() { console.info('函数'); }
console.log(f1);  // ƒ () { console.info('变量'); }

// 下面代码全等于上面代码
var f1;  // 定义提升
function f1() { console.info('函数'); }  // 函数顶部赋值
console.log(f1);  // f1() { console.info('函数'); }
f1 = function() { console.info('变量'); }
console.log(f1);  // ƒ () { console.info('变量'); }
console.log(f1);  // ƒ () { console.info('变量'); }

作用域: 一个变量的作用范围

  1. 块级作用域: 在JS中没有块级作用域
  2. JS中的作用域
    • script标签组成的全局作用域
    • JS中函数是唯一可以创建作用域的对象
  3. 词法作用域: 一个变量声明完后作用域就已经确定了
    • JS属于词法作用域
  4. 动态作用域: 变量的作用域由程序执行环境决定
  5. 词法作用域中变量的访问原则
    • 首先在当前作用域中查找, 如果没有就去上一级作用域中查找,
      直到访问到全局作用域
    • 内层作用域可以访问外层作用域

4.函数的执行上下文

在打开页面时,全局执行上下文就被压入执行上下文栈中,当调用函数时会将向执行上下文中压入函数的执行上下文,在函数中如果调用其它函数则继续压入新的执行上下文,函数执行完之后,其执行上下文被弹出栈。

之后会写文章从内存的角度来分析函数的执行上下文。持续关注

函数上下文关系

  • 函数的上下文关系在定义时确定

var scope = "global scope";
function checkscope() {
  var scope = "local scope";
  function f() { return scope; }
  return f;
}
checkscope()();  // local scope

变量和函数的提升

  • JS代码的执行过程
    1. 预解析:
      在预解析阶段,系统会对var声明的变量和function声明的代码块进行一个声明提升,提升到当前作用域的顶端
    2. 执行代码
  • 注意点
    • 变量与变量同名, 后面会覆盖前面的
    • 函数与函数同名, 后面会覆盖前面的(函数没有重载)
    • 变量和函数同名, 可以理解为只提升函数声明,
      不提升变量(和函数同名的)

5.函数里变量的查找

函数里变量的查找是在作用域链上依次查找的,会一层一层向外查找。变量的查找不同于this的属性的查找

this和作用域是两个完全不同的概念 this是javascript的关键字而不是变量。

this 上下文关系

  • this 的上下文关系在执行时确定

变量的提升是分作用域的

  • 变量的提升: 提升到当前作用域的顶端

  • 函数表达式的提升:
    只会提升var声明的变量,并不会把整一个函数表达式进行提升

          var fun1 = function () {
              console.log('f1');
          }
          var a = 20;
          console.log(a);     //20
          fun1();     //f1
    
          //模拟变量提升
          var fun1;
          var a;
          fun1 = function () {
              console.log('f1');
          }
          a = 20;
          console.log(a);     //20
          fun1();     //f1
    

6.函数的this

this也可以叫做调用上下文(和执行上下文有区别) // 个人见解

在不指定的情况下,this指向的是调用该方法的对象。
this上属性的查找是在对象的原型链上查找的
在构造函数中,this指向的是通过new关键字新建的实例对象

可以指定this属性的指向
利用call apply bind 三个函数
function foo(arg1,arg2,arg3){};

foo.call{obj,arg1,arg2...}  //call指定this为obj,后面的参数作为foo的参数传进去
foo.apply{obj,[arg1,arg2]}  //也是制定this为obj,但是传给foo的参数是以数组的形式
var newfoo = foo.bind(obj,arg1,arg2)  // 为foo绑定this,和两个参数    bind返回的是一个新函数

调用新的函数,会调用foo,而且foo的this都是指向obj,而且传入newfoo的参数都作为参数赋值给arg3及后面的参数,因为arg1,arg2已经被绑定了。

//模拟bind , bind的一些特性还是模拟不来,功能可以模拟
Function.prototype.bind = Function.prototype.bind || function(obj...){
var self = this;
var boundArgs = arguments;
return function(){
var args=[],i;
for(i=1;i<boundArgs.length;i++) args.push(boundArgs[i]);
for(i=0;i<arguments.length;i++) args.push(arguments[i]);
return self.apply(obj,args);
}
};

正常函数调用,this 指向 window

// 在 function 里
function test() {
    var type = this === window;
    return type;
}
test();  // true

7.自定义函数属性

函数也是一种特殊的对象,可以为其自定义属性。
function foo(){console.log(foo.counter++)};
foo.counter = 0;
这种做法有个问题,函数的counter属性可以被随性修改,可以利用闭包将属性私有化。

通过给构造函数添加方法和属性就模拟实现了类方法和类字段

方法调用,this 指向调用对象

// 在对象里
var obj = {
    test: function() {
        var type = this === obj;
        return type;
    }
};
obj.test();  // true

// 在 prototype 对象的方法中
function obj() {
}
obj.prototype.test = function() {
    return this;
}
var o = new obj();
o.test() === o;  // true

8.闭包

一句话理解闭包,局部作用域的变量被外部引用时,其内存空间不会被销毁
(本人愚见,欢迎各路大神指正)

var unique = (function(){
                  var counter = 0; 
                  return function(){ return counter++}}());   //闭包的典型例子
//函数每次调用时在内存中创建的空间是不一样的。
function getUniqueFoo(){
var counter = 0; 
return function(){ return counter++}   //这里返回的函数里存在外层函数的局部变量counter
}
var unique2 = getUniqueFoo();   //unique2指向返回的函数
var unique3 = geUniqueFoo();    //unique2和unique3是互不干扰的,因为内存空间不是同一块

//又一个闭包例子
function getApp(){
var appName = "xxx";
var version = "1.xxx";
var setName = function(name){
appName = name;
}
return {
get app(){ return appName},  //存取器属性
version : version, 
setName : setName,
}
}
var App =getApp();

可以在外部函数将this转存为一个变量,以便在闭包中访问,外部函数的arguments
也一样
arguments是函数的类数组对象
arguments.callee 指向的是arguments所在的函数本身

之后会写文章从内存的角度来分析函数的闭包。持续关注

构造器函数调用,this 指向 new 生成的对象

// 调用 new 构造对象时
function obj() {
    this.test = function() {
        return this;
    }
}
var o = new obj();
o.test() === o;  // true

apply / call 调用

function test() {
    return this;
}
var o = {};

// apply
test.apply(o) === o;  // true

// call
test.call(o) === o;  // true

dom 的事件属性中

// 点击后输出 true
<input id="a" type="text" onclick="console.info(this === document.getElementById('a'))" />

// 点击后输出 true
<input id="a" type="text" />
<script type="text/javascript">
    document.getElementById('a').addEventListener("click", function(){
        console.info(this === document.getElementById('a'));
    });
</script>

// 点击后输出 true
<input id="a" type="text" />
<script type="text/javascript">
    document.getElementById('a').onclick = function(){
        console.info(this === document.getElementById('a'));
    });
</script>

相关文章