前端(JavaScript)------函数与对象

一、函数

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

 函数概述

       函数的声明

  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)  // []