函数:[JavaScript 教程]
函数是一段可以反复调用的代码块。可以传递参数,不同的参数会返回不同的值。
函数声明的三种方法:
1. function 命令
function 命令声明的代码块,就是一个函数。 function 命令后面是函数名,函数名后面是一对圆括号(), 里面可以传入参数。函数体放在大括号里面。
function show(name) { // 代码块... console.log( name ); }
2. 函数表达式
除了用 function 命令声明函数, 还可以采用变量赋值的写法。
var show = function(name) { // 代码块... console.log( name ); };
这种写法是将一个匿名函数赋值给变量。因为赋值语句的等号右侧只能放表达式,所有这个匿名函数称函数表达式。
带名的函数表达式,函数名在函数体内有效,在函数体外部无效。
var show = function abc() { // 代码块... // 命名函数表达式 // 每个函数都会有一个name的属性,这里的区别就在于 show.name 是 abc };
注意: 函数作为表达式出现,则会忽略名称。函数表达式需要在语句结尾加上分号,表示语句结束。
3. Function 构造函数
Function 构造函数可以不使用new命令,返回结果完全一样。这种声明方式少人使用。 var show = new Function( "x", "y", "return x + y" ); // 等同于 function show(x, y) { return x + y; } Function 构造函数的最后一个参数会被当作函数体,如果只有一个参数,该参数就是函数体。
函数调用:
有4种调用模式:函数调用模式、方法调用模式、构造器调用模式、间接调用模式;
1. 函数调用模式
function init(){ // 代码块... // 非严格模式下,this指向全局对象window // 'use strict' // 严格模式下, this是undefined } init(); // window.init(); 可以通过 this 来判断当前是否是严格模式 var strict = (function(){ return !this; }());
2. 方法调用模式
当一个函数被保存为对象的一个属性时,我们称它为一个方法。当一个方法被调用时,this被绑定到该对象。
var myObject = { value: 100, init: function() { console.log( this.value ); } } myObject.init(); // 100
3. 构造器调用模式,用new关键字来新建一个函数对象的调用; (this指向被绑定到的构造函数实例上)
var init = function (status) { this.status = status; } init.prototype.getStatus = function () { return this.status; }; var test = new init('构造函数'); console.log( test.getStatus() ); // 构造函数; this指向test
4. 间接调用模式 (this指向指定调用的对象)
call()、apply()是函数的两个方法,可以用来间接地调用函数。
var obj = {}; function show(x, y) { return x + y; } show.call(obj, 1, 2); //3 this => obj show.apply(obj, [1, 2]); //3 this => obj
函数的重复声明:
变量的重复声明是无用的,不会覆盖之前同一作用域声明的变量。
但函数的重复声明会覆盖前面的声明的同名函数或同名变量。
变量的重复声明变量无用
var num = 10; var num; console.log( num ); // 10
覆盖同名变量
var num; function num() { console.log(1); } num(); // 1
覆盖同名函数
function num() { console.log("A"); } num(); // B function num() { console.log("B"); }
JavaScript 引擎将函数名视同变量名,所有采用 function 命令声明函数,都会被提升到代码头部。
// 先调用 show(); // 后声明,由于"变量提升", 所以代码可以正常执行 function show() { .. } 采用赋值语句定义函数,先调用,再声明就会报错。 show(); var show = function() {} // TypeError: show is not a function 等同以下形式 var show; show(); show = function() {}; 注意: 同时采用 function 命令 和 赋值语句 声明同一个函数,最后采用的总是赋值语句定义的。 var show = function() { console.log("A"); }; function show() { console.log("B"); } show(); // A
函数本身的作用域:
函数执行时所在的作用域,是定义时的作用域,而不是调用时所在的作用域。
函数的属性和方法:
A. name 属性
函数的 name 属性返回函数的名字 function show() {} show.name; // show 变量赋值定义的函数,name 属性返回变量名。 var show = function () { // 匿名函数表达式 }; show.name; // show var show = function abc() { // 有名函数表达式 } show.name; // abc
B. length 属性 (函数形参的个数)
function show(a, b){ // a,b 是函数的形参 } show.length; // 2
C. toString() 方法: 返回一个字符串,内容是函数的源码;
function show() { // 注释 hide(); } show.toString(); 结果: "function show() { // 注释 hide(); }"
关于删除:
function 命令声明函数无法删除,和变量声明一样 function show() { console.log("A"); } delete show; // false show(); // A
关于函数返回值:(return 有终止程序的作用)
所有函数都有返回值,没有return语句时,默认返回内容是undefined,return语句不会阻止finally的执行
function show() { try{ return "A"; }catch(error) { return "B"; }finally{ return "C"; } } show(); // C
作为构造函数使用时,在调用之前前面加上了new,如果有return语句,返回值不是一个对象,则会忽略,则返回值是this(new出来的新对象);
function show() { // 约定:如果一个函数要做为构造函数的话,首字母需大写。 this.num = 2; return 1; // 返回的是一个基本类型,构造函数会忽略 } var test = new show(); console.log( test ); // { num: 2 } console.log( test.constructor ); // show(){ this.num = 2; return 1; }
如果返回值是一个对象,则返回该对象。
function show() { this.num = 2; return { num: 1 }; } var test = new show(); console.log( test ); // { num: 1 } console.log( test.constructor ); // Object(){ [native code] }
关于函数的参数:
函数运行的时候,有时需要提供外部数据,不同的外部数据会得到不同的结果,这种外部数据就叫参数。
// 在函数声明时圆括号内的参数,叫形式参数 - 简称形参;
function test(a, b, c){ // 形参 - 在函数内部相当于新定义的变量 // var a, b, c; // 获取形参的长度: test.length; // arguments 是函数的实参列表, 记录的是函数实际传入的参数 // [1,2,3] arguments一个类数组 // 形参个数 和 实参列表arguments一一对应,如有一方修改则都改, // 例外:当实参小于形参时,修改形参变量,对应的arguments为undefined return a; }
// 函数调用的时候掺入的参数,叫做实际参数 - 简称实参;
test(1, 2); // 1; 实参比形参多, 则会忽略多传入的实参 test(); // undefined; 形参比实参多, 内部用到则默认为undefined test( , 1); // 不能省略靠前的参数,如果要省略只有显示传入undefined // 报错 SyntaxError: Unexpected token ,(...) test(undefined, 1); // undefined
同名形参: (在实际开发过程中肯定是不允出现的)
A. 在非严格模式下,函数中可以出现同名形参,且只能访问最后出现的该名称的形参。
function test(a, a, a) { console.log(a); } test(1,2,3); // 3 test(1,2); // undefined
B. 在严格模式下,出现同名形参会抛出语法错误。
function test(a,a,a){ 'use strict'; return a; } test(1,2,3); // SyntaxError: Duplicate parameter name not allowed in this context
以对象为参数:
当一个函数的形参过多时,在调用的时候必须传入和形参对应的数据。
function show(name, sex, age) { // 在传入实参数是必须一一对应,name(名称),sex(性别),age(年龄) console.log('姓名:' + name ',性别:' + sex + ', 年龄:' + age); } 正常顺序 show('jing', '女', '18'); // 姓名:jing,性别:女, 年龄:18 错误顺序 show('jing', '18', '女'); // 姓名:jing,性别:18, 年龄:女 通过key/value对的形式来传入参数,参数的顺序就无关紧要了。 function show(option) { console.log( '姓名:' + option.name + ',性别:' + option.sex + ', 年龄:' + option.age ); } show({age: 18, name:'jing', sex: '女'}); // 姓名:jing,性别:女, 年龄:18
以函数为参数:
函数本身是一个对象,因此可以将函数作为另一个函数的参数,实现函数回调。
function show( fn ) { // 判断当前传入的参数类型是否是函数,如果是函数则立即执行; if(typeof(fn) === 'function'){ fn(); // 执行回调 } } show(function(){ console.log('A'); }); // A
arguments对象:(函数内部的实参数列表)
由于JavaScript允许函数有不定数目的参数,所以需要一种机制,可以在函数体内部读取所有参数。这是就arguments对象的由来。
arguments对象包含了函数运行时的所有参数,arguments[下标]来获取,只有在函数体内才可以使用。
function show() { console.log(arguments[0]); console.log(arguments[1]); } show("A", "B"); // A // B
当形参和实参的格式相同时,arguments对象的值和对应的形参的值保持同步
function show(num1, num2) { console.log( num1, arguments[0] ); // 1 1 arguments[0] = 7; console.log( num1, arguments[0] ); // 7 7 num1 = 10; console.log( num1, arguments[0] ); // 10 10 } show(1); 注意: 虽然形参和实参列表的值相同,但不是相同的命名空间。他们的命名空间是独立的,但值是同步的。
在严格模式下,arguments对象的值和形参的值是 独立的
function show(num1, num2) { 'use strict' console.log( num1, arguments[0] ); // 1 1 arguments[0] = 7; console.log( num1, arguments[0] ); // 1 7 num1 = 10; console.log( num1, arguments[0] ); // 10 7 } show(1);
当形参并没有对应的实参时,arguments对象的值和形参的值并不对应
function show(num1, num2) { console.log( num1, arguments[0] ); // undefined, undefined num1 = 10; arguments[0] = 7; console.log( num1, arguments[0] ); // 10 7 } show();
arguments对象的内部属性callee
该属性是一个指针,指向拥有这个arguments对象的函数。
var show = function() { console.log( arguments.callee === show ); } show(); // true 可以通过 arguments.callee 达到调用函数自身的目的。 注意:这个属性在严格模式下是禁用的。
通过递归(函数调用自身)实现的阶乘函数
function factorial(num) { if( num <= 1 ){ return 1; }else{ return num * factorial(num-1); } } factorial(5); // 120
使用arguments.callee消除函数解耦
function factorial(num) { if( num <= 1 ){ return 1; }else{ return num * arguments.callee(num-1); } } factorial(5); // 120
闭包:
理解闭包,必须理解变量作用域。
JS的两种作用域: 全局作用域和函数作用域。函数内部可以直接读取全局变量。
// 函数内部读取全局变量
var num = 10; function show() { cosnole.log( num ); } show(); // 10
函数外部无法读取函数内部声明的变量。
function show() { var num = 10; } console.log( num ); // ReferenceError: num is not defined
链式作用域,子对象可以向上寻找父对象的变量。
// 函数内部嵌套函数,内部函数可以访问外部的变量
function show(){ var num = 10; function show2() { console.log( num ); // 10 } return show2; }
函数 show 的返回值是函数 show2, 由于 show2 可以读取 show 的内部变量, 所以就可以在外部获得 show 的内部变量了。 show2 函数就是闭包, 能够读取其他函数内部变量的函数。
只有函数内部的子函数才能读取内部变量,简单理解成,定义在一个函数内部的函数。
闭包最大的特点,就是它可以记住诞生的环境,比如 show2 记住了它诞生的环境 show,所以从show2可以得到show的内部变量。 闭包就是将函数内部和函数外部连接起来的一座桥梁。
闭包的最大的两个用处,1. 可以读取函数内部变量。 2. 让这些变量始终保持在内存中。
function count(start) { return function () { return start++; } } var init = count(5); init(); // 5; init(); // 6; init(); // 7 通过闭包,start的状态被保留了, 每一次调用都是在上一次调用的基础上进行计算。
闭包的另一个用处: 是封装对象的私有属性和私有方法。
function Person(name) { var _age; function setAge(n) { _age = n; } function getAge() { return _age; } return { name: name, getAge: getAge, setAge: setAge }; } var p1 = Person('yuxi'); p1.setAge(18); p1.getAge(); // 18 函数 Person 的内部变量 _age, 通过闭包 getAge 和 setAge,变成了返回对象 p1 的私有变量。
注意: 外层函数每次运行,都会生成一个新的闭包,而这个闭包又会保留外层函数的内部变量,所以会消耗很大内存。因此不能滥用闭包,否则会造成网页的性能问题。