前端(JavaScript)------函数与对象（下）

传递⽅式

函数参数如果是原始类型的值（数值、字符串、布尔值），传递⽅式是传值传递（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)  // []