js函数调用

本节主要讲述 js函数调用

隐式函数参数

arguments

this

函数调用的4种方式

  • 作为一个函数——skulk(),直接被调用
  • 作为一个方法——ninja.skulk(),关联在一个对象上,实现面向对象编程
  • 作为一个构造函数——new Ninja(),实例化一个新的对象
  • 通过函数的apply或者call方法——skulk.apply(ninja)

作为函数直接被调用

1
2
3
4
5
6
7
8
9
10
/* 函数定义作为函数被调用 */
function ninja() {};
ninja();

/* 函数表达式作为函数被调用 */
var samuria = function() {};
samuria();

/* 立即调用的函数表达式 */
(function() {})()

函数上下文

  • 非严格模式:全局上下文(window对象)
  • 严格模式:undefined

严格模式

作为方法被调用

1
2
3
4
5
6
7
8
9
10
function whatsMyContext() {
console.log(this)
}
whatsMyContext();

var ninja = {
getThis: whatsMyContext
}

ninja.getThis();

作为构造函数被调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* 构造函数创建一个对象,并在该对象也就是函数上下文添加一个属性skulk。这个函数再次返回函数的上下文 */
function Ninja(){
this.skula=function(){
return this;
};
}

/* 通过关键字调用的构造函数从而创建两个新对象。 */
var n1=new Ninja();
var n2=new Ninja();


console.log(n1.skula() === n1)
console.log(n2.skula() === n2)

使用new关键字调用函数会触发以下几个动作

  1. 创建一个新的空对象
  2. 该对象作为this参数传递给构造函数,从而成为构造函数的上下文
  3. 新构造函数的对象作为new运算符的返回值

apply和call

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function juggle(){
var result=0;
for(var i=0;i<arguments.length;i++){
result += arguments[i];
}

this.result = result;
}

var n1=new juggle();
var n2=new juggle();

juggle.call(n1,1,2,3,4,5);
juggle.apply(n2,[1,2,3,34])

console.log(n1.result)
console.log(n2.result)

闭包

理解闭包

闭包允许访问并操作函数外部的变量,只要变量或函数存在与声明函数时的作用域内。

一个简单的闭包

1
2
3
4
5
6
7
var outervalue="Blue";

function outFun(){
console.log(outervalue)
}

outFun();

该函数可以访问到外部变量

另一个闭包的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var outerValue="Qian"
var later;

function outerFun(){
var innerValue="inner";

function innerFun(){
console.log(outerValue);
console.log(innerValue);
}

later = innerFun;
}

outerFun()

later();
  • Qian
  • inner