目录

一、函数

  函数概述

函数的重复声明

第⼀等公⺠

函数名的提升

 函数的属性和⽅法

length 属性

 toString()

函数作⽤域

函数内部的变量提升

函数本身的作⽤域

函数参数

参数的省略

传递⽅式

同名参数

arguments 对象

与数组的关系

函数其他知识

eval 命令

闭包

如何从外部读取局部变量

闭包的概念

使⽤闭包的注意点

函数的应⽤

二、对象

查看所有属性

delete 命令


一、函数

函数是⼀段可以反复调⽤的代码块。函数还能接受输⼊的参数,不同的参数会返回不同的值。

  函数概述

        函数的声明
   JavaScript 有三种声明函数的⽅法。
     1. function 命令 function命令声明的代码区块,就是⼀个函数。function命令后⾯是函数名,函数名后⾯是⼀对圆括号,⾥⾯是传⼊函数的参数。函数体放在⼤括号⾥⾯。

function print(s) {
console.log(s);
}

2. 函数表达式 除了⽤function命令声明函数,还可以采⽤变量赋值的写法

var print = function(s) {
console.log(s);
};

3. Function 构造函数 第三种声明函数的⽅式是Function构造函数。

var add = new Function(
'x',
'y',
'return x + y'
);

// 等同于

function add(x, y) {
return x + y;
}

总的来说,这种声明函数的⽅式⾮常不直观,⼏乎⽆⼈使⽤。

函数的重复声明

如果同⼀个函数被多次声明,后⾯的声明就会覆盖前⾯的声明。

function f() {

console.log(1);

}

f() // 2

function f() {

console.log(2);

}
f() // 2

第⼀等公⺠

JavaScript 语⾔将函数看作⼀种值,与其它值(数值、字符串、布尔值等等)地位相同。凡是可以使⽤值的地⽅,就能使⽤函数。⽐如,可以把函数赋值给变量对象的属性,也可以当作参数传⼊其他函数,或者作为函数的结果返回。函数只是⼀个可以执⾏的值,此外并⽆特殊之处。
由于函数与其他数据类型地位平等,所以在 JavaScript 语⾔中⼜称函数为第⼀等公⺠。

function add(x, y) {
return x + y;
}

// 将函数赋值给⼀个变量

var operator = add;

// 将函数作为参数和返回值

function a(op){

return op;

}

a(add)(1, 1)

// 2

函数名的提升

JavaScript 引擎函数名视同变量名,所以采⽤function命令声明函数时,整个函数会像变量声明⼀样,被提升到代码头部。所以,下⾯的代码不会报错。

f();
function f() {}

但是,如果采⽤赋值语句定义函数,JavaScript 就会报错。

f();

var f = function (){};

// TypeError: undefined is not a function

不能在条件语句中声明函数
根据 ES5 的规范,不得在⾮函数的代码块中声明函数,最常⻅的情况就是if语句

if (foo) {

   function x() {}

}

 函数的属性和⽅法

         name 属性
        函数的name属性返回函数的名字。

function f1() 
{

}

f1.name // "f1"

如果是通过变量赋值定义的函数,那么name属性返回变量名。

var f2 = function () {};

f2.name         // "f2"

name属性的⼀个⽤处,就是获取参数函数的名字。

var myFunc = function () {};

function test(f) {

     console.log(f.name);

}

test(myFunc)    // myFunc

length 属性

函数的length属性返回函数预期传⼊的参数个数,即函数定义之中的参数个数。

function f(a, b) {}

f.length      // 2

 toString()

函数的toString⽅法返回⼀个字符串,内容是函数的源码。

function f() {
     a();
     b();
     c();
}

  f.toString()

// function f() {
// a();
// b();
// c();
// }

函数作⽤域

定义
作⽤域(scope)指的是变量存在的范围。在 ES5 的规范中

 JavaScript 只有两种作⽤域:⼀种是全局作⽤域,变量在整个程序中⼀直存在,所有地⽅都可以读取;

另⼀种是函数作⽤域,变量只在函数内部存在。
ES6 ⼜新增了块级作⽤域
函数外部声明的变量就是全局变量(global variable),它可以在函数内部读取。

var v = 1;

function f() {

    console.log(v);

}

f()  // 1

在函数内部定义的变量,外部⽆法读取,称为“局部变量”(local variable)。

function f(){

     var v = 1;

}
v // ReferenceError: v is not defined

函数内部定义的变量,会在该作⽤域内覆盖同名全局变量。

var v = 1;

 function f(){

     var v = 2;

     console.log(v);

}

f() // 2

v // 1

注意,对于var命令来说,局部变量只能在函数内部声明,在其他区块中声明,⼀律都是全局变量。

if (true) {

    var x = 5;

}
console.log(x); // 5

函数内部的变量提升

与全局作⽤域⼀样,函数作⽤域内部也会产⽣“变量提升”现象。var命令声明的变量,不管在什么位置,变量声明都会被提升到函数体的头部。

function foo(x) {

if (x > 100) {

var tmp = x - 100;

     }
}

函数本身的作⽤域

函数本身也是⼀个值,也有⾃⼰的作⽤域。它的作⽤域与变量⼀样,就是其声明时所在的作⽤域,与其运⾏时所在的作⽤域⽆关。

var a = 1;

var x = function () {

    console.log(a);

};
function f() {

   var a = 2;
   x();
 }

f()   // 1

函数参数

函数运⾏的时候,有时需要提供外部数据,不同的外部数据会得到不同的结果,这种外部数据就叫参数。

function square(x) {

return x * x;

}

square(2) // 4

square(3) // 9

参数的省略

函数参数不是必需的,Javascript 允许省略参数。

function f(a, b) {

return a;

}
 
 f(1, 2, 3) // 1

 f(1) // 1

 f() // undefined

 f.length // 2

传递⽅式

函数参数如果是原始类型的值(数值、字符串、布尔值),传递⽅式是传值传递(passes by value)。这意味着,在函数体内修改参数值,不会影响到函数外部。

var p = 2;

function f(p) {

    p = 3;

}

f(p);

p    // 2

同名参数

如果有同名的参数,则取最后出现的那个值

function f(a, a) {

      console.log(a);

}

f(1, 2) // 2

arguments 对象

由于 JavaScript 允许函数有不定数⽬的参数,所以需要⼀种机制,可以在函数体内部读取所有参数。这就是 arguments 对象的由来。

var f = function (one) {

   console.log(arguments[0]);
   console.log(arguments[1]);
   console.log(arguments[2]);
}

f(1, 2, 3)

与数组的关系

     需要注意的是,虽然arguments很像数组,但它是⼀个对象。数组专有的⽅法(⽐如slice和forEach),不能在arguments对象上直接使⽤。
       如果要让arguments对象使⽤数组⽅法,真正的解决⽅法是将arguments转为真正的数组。下⾯是两种常⽤的
转换⽅法:slice⽅法和逐⼀填⼊新数组。

var args = Array.prototype.slice.call(arguments);

// 或者
var args = [];

for (var i = 0; i < arguments.length; i++) {

       args.push(arguments[i]);

}

函数其他知识

⽴即调⽤的函数表达式

在 Javascript 中,圆括号()是⼀种运算符,跟在函数名之后,表示调⽤该函数。⽐如,print()就表示调⽤print函数。那如何让函数⾃⼰执⾏呢?

(function(){ /* code */ }());

// 或者

(function(){ /* code */ })();

eval 命令

eval命令的作⽤是,将字符串当作语句执⾏

eval('var a = 1;');
a // 1

闭包

闭包(closure)是 Javascript 语⾔的⼀个难点,也是它的特⾊,很多⾼级应⽤都要依靠闭包实现。理解闭包,⾸先必须理解变量作⽤域。前⾯提到,JavaScript 有两种作⽤域:全局作⽤域和函数作⽤域。函数内部可以直接读取全局变量

var n=999;

function f1(){

    alert(n);

}

f1();    // 999

另⼀⽅⾯,在函数外部⾃然⽆法读取函数内的局部变量。

function f1(){

   var n=999;

}
alert(n);   // error

这⾥有⼀个地⽅需要注意,函数内部声明变量的时候⼀定要使⽤var命令。如果不⽤的话,你实际上声明了⼀个全局变量!

function f1(){

      n=999;

}

f1();

alert(n); // 999

如何从外部读取局部变量

出于种种原因,我们有时候需要得到函数内的局部变量。但是,前⾯已经说过了,正常情况下,这是办不到的,只有通过变通⽅法才能实现。
那就是在函数的内部,再定义⼀个函数。

function f1(){

   var n=999;

   function f2(){

       alert(n); // 999

    }
}

在上⾯的代码中,函数f2就被包括在函数f1内部,这时f1内部的所有局部变量,对f2都是可⻅的。但是反过来就不⾏,f2内部的局部变量,对f1就是不可⻅的。

这就是Javascript语⾔特有的"链式作⽤域"结构(chainscope),⼦对象会⼀级⼀级地向上寻找所有⽗对象的变量。所以,⽗对象的所有变量,对⼦对象都是可⻅的,反之则不成⽴

function f1(){

var n=999;

function f2(){

    alert(n);

   }

  return f2;
}

var result=f1();

result(); // 999

闭包的概念

上⼀节代码中的f2函数,就是闭包。
各种专业⽂献上的"闭包"(closure)定义⾮常抽象,很难看懂。我的理解是,闭包就是能够读取其他函数内部变量的函数。

由于在Javascript语⾔中,只有函数内部的⼦函数才能读取局部变量,因此可以把闭包简单理解成 "定义在⼀个函数内部的函数"
所以,在本质上,闭包就是将函数内部和函数外部连接起来的⼀座桥梁

闭包的⽤途

   闭包可以⽤在许多地⽅。它的最⼤⽤处有两个,⼀个是前⾯提到的可以读取函数内部的变量,另⼀个就是让这些变量的值始终保持在内存中。

function f1(){

   var n=999;

   nAdd=function(){n+=1}

function f2(){

      alert(n);

    }

   return f2;
}

  var result=f1();

  result(); // 999

  nAdd();

  result(); // 1000

在这段代码中,result实际上就是闭包f2函数。它⼀共运⾏了两次,第⼀次的值是999,第⼆次的值是1000。
这证明了,函数f1中的局部变量n⼀直保存在内存中,并没有在f1调⽤后被⾃动清除。
为什么会这样呢?原因就在于f1是f2的⽗函数,⽽f2被赋给了⼀个全局变量,这导致f2始终在内存中,⽽f2的存在依赖于f1,因此f1也始终在内存中,不会在调⽤结束后,被垃圾回收机制(garbage collection)回收。
这段代码中另⼀个值得注意的地⽅,就是"nAdd=function(){n+=1}"这⼀⾏⾸先在nAdd前⾯没有使⽤var关键字,因此nAdd是⼀个全局变量,⽽不是局部变量。其次,nAdd的值是⼀个匿名函数(anonymous function),⽽这个匿名函数本身也是⼀个闭包,所以nAdd相当于是⼀个setter,可以在函数外部对函数内部的局部变量进⾏操作

使⽤闭包的注意点

1. 由于闭包会使得函数中的变量都被保存在内存中内存消耗很⼤,所以不能滥⽤闭包,否则会造成⽹⻚的性能问题,在IE中可能导致内存泄露。解决⽅法是,在退出函数之前,将不使⽤的局部变量全部删除。

2. 闭包会在⽗函数外部,改变⽗函数内部变量的值。所以,如果你把⽗函数当作对象(object)使⽤,把闭包当作它的公⽤⽅法(Public Method),把内部变量当作它的私有属性(private value),这时⼀定要⼩⼼,不要随便改变⽗函数内部变量的值。

var name = "The Window";

var object = {

    name : "My Object",

 getNameFunc : function(){

     return function(){

      return this.name;

      };
    }
 };
alert(object.getNameFunc()());
var name = "The Window";

var object = {

      name : "My Object",

getNameFunc : function(){

    var that = this;

    return function(){

         return that.name;

        };

    }

};

alert(object.getNameFunc()());

函数的应⽤

  实现阶乘:5 4 3 2 1 的结果

function f(a){

 if(a<=1){

      return 1

   }else{

    return a*f(a-1)

  }
}

二、对象

对象(object)是 JavaScript 语⾔的核⼼概念,也是最重要的数据类型。
什么是对象?简单说,对象就是⼀组“键值对”(key-value)的集合,是⼀种⽆序的复合数据集合。

var obj = {

    foo: 'Hello',

    bar: 'World'
};

上⾯代码中,⼤括号就定义了⼀个对象,它被赋值给变量obj,所以变量obj就指向⼀个对象。

该对象内部包含两个键值对(⼜称为两个“成员”),第⼀个键值对是foo: 'Hello',其中foo是“键名”(成员的名称),字符串Hello是“键值”(成员的值)

键名键值之间⽤冒号分隔。第⼆个键值对是bar: 'World',bar是键名,World是键值。

两个键值对之间⽤逗号分隔对象的所有键名都是字符串(ES6 ⼜引⼊了 Symbol 值也可以作为键名),所以加不加引号都可以。上⾯的代码也可以写成下⾯这样。

var obj = {

   'foo': 'Hello',

   'bar': 'World'

};

如果键名不符合标识名的条件(⽐如第⼀个字符为数字,或者含有空格或运算符),且也不是数字,则必须加上引号,否则会报错。

// 报错
var obj = {

     1p: 'Hello World'

};

// 不报错

var obj = {

    '1p': 'Hello World',

    'h w': 'Hello World',

    'p+q': 'Hello World'
};

对象的每⼀个键名⼜称为“属性”(property),它的“键值”可以是任何数据类型。如果⼀个属性的值为函数,通常把这个属性称为“⽅法”,它可以像函数那样调⽤。

var obj = {

p: function (x) {

      return 2 * x;
   }
};

obj.p(1)   // 2

如果属性的值还是⼀个对象,就形成了链式引⽤。

查看所有属性

查看⼀个对象本身的所有属性,可以使⽤Object.keys⽅法。

var obj = {

   key1: 1,

   key2: 2
};

  Object.keys(obj);

// ['key1', 'key2']

delete 命令

   delete命令⽤于删除对象的属性,删除成功后返回true。

var obj = { p: 1 };

Object.keys(obj)    // ["p"]

delete obj.p        // true

obj.p              // undefined

Object.keys(obj)  // []