js

创建函数，3种：
1 声明：只有声明方式创建的函数才能被声明提前
function fun(arg1, arg2, ...){ statement; return value;}
2 函数直接量：无法被声明提前
var fun = function(arg1, arg2, ...){ statement; return value;};
揭示：函数其实是一个对象，函数名仅仅是一个引用函数对象的普通变量。
3 用new：
var fun = new Function("arg1", "arg2", ..., "statement; return value;");

重载（overload）：相同函数名，不同参数列表的多个函数，在调用时，根据传入参数的不同，自动选择匹配的函数执行
目的目的：减少API的数量，减轻调用者的负担

when：如果多个函数只是流程不同，其实都是一类事，就可以将多个函数命名为同名函数，不同参数
how：js语法不支持重载！js中后定义的同名函数会覆盖先定义的。
arguments：函数中自动接收所有传入函数的参数值的类数组对象。
类数组对象：长得像数组的对象
类数组对象和数组的相同点：都用[i]方式访问每个元素；length属性记录元素的个数；for循环遍历每个元素。

对象的创建，3种：
1 对象直接量：
var obj = {
属性名: 属性值;
...,
方法名: function(){},
...
};
注意：每个属性名和方法名不用加引号，但是底层都是用字符串存储。

this：引用当前正在调用函数的对象！

　　和定义在哪个对象中无关！只和调用时   .  前的对象有关！

　　固定场景：a.在对象自己的方法中，访问自己的属性

　　　　　　　b.在构造函数中，指代正在创建的新对象

　　　　　　　c.在原型对象的共有方法中，指代将来调用共有方法的子对象

　　注意：不是任何对象直接调用的函数中this默认指window对象。
when：对象自己的方法中，想访问对象自己的属性必须用 this.属性名
2 使用new：
var obj = new Object();//创建一个Object类型的空对象
obj.属性名 = 属性值;//等效于 obj["属性名"] = 属性值;
...
obj.方法名 = function(){... this.属性名 ...};
when：如果在创建对象时，暂时不知道包含哪些属性，就先创建一个对象，再添加属性

注意：js中的对象，可以随时添加新属性，只要给不存在的属性赋值，就自动添加

本质：js中一切对象都是hash数组：

　　a.都可以随时添加新的属性和方法

　　b.访问对象中一个不存在的属性，返回undefined

　　c.属性名和方法名其实相当于hash数组中的key

　　d.都可用for in遍历每个属性
3 反复创建多个相同类型和结构的对象;
a.定义构造函数，描述一类对象的统一结构
构造函数：描述一类对象的统一结构德函数
when：只要反复创建相同结构的多个对象前，都需要先定义构造函数，再创建对象。
how：
function 类型名/构造函数名（属性参数列表）{
this.属性名 = 属性参数值;
...
this.方法名 = function(){
... this.属性名...
}
}
b.使用new调用构造函数创建对象并添加属性
var obj = new 构造函数名（属性值列表）;
构造函数中的this，指new正在创建的对象

面向对象：
原型和原型链：
原型：保存所有子对象的公共成员的父级对象

每个构造函数，都有一个prototype属性，引用自己的原型对象
每个子对象，都有一个 __proto__ 属性，继承自构造函数的原型对象

继承：父对象的成员，自对象无需创建，可直接使用！

对象创建：
a.创建空对象
b.设置新对象的 __proto__ 属性继承构造函数的原型对象
c.调用构造函数，添加成员
d.返回地址
when：同一类型的子对象共享的属性和方法，都要放在构造函数的原型对象中。
优点：代码重用，节约内存！

删除属性：
a.自有属性： delete 对象.属性名;
b.共有属性：只能通过构造函数的原型对象删除 delete 构造函数.prototype.属性名

判断自有属性与共有属性：
a.判断自有属性：判断指定属性是否直接保存在当前对象本地
var isSelf = obj.hasOwnProperty("属性名");
true：是自有属性
false：无法确定是否为共有
b.判断共有属性：同时满足两条件：
不是自有： obj.hasOwnProperty("属性名") == false;
但是在原型中有： obj.属性名 !== undefined

<script type="text/javascript">
    
//String类型支持trim()，去掉前后的空格
//如果当前浏览器不支持trim
if(String.prototype.trim === undefined){
    console.log("当前浏览器不支持trim()，自定义trim()");
    String.prototype.trim = function(){
        return this.replace(/^s+|s+$/g, "");
    };
}

var str = "    hello js,  I like  ";
console.log(":" + str + ":");
str = str.trim();
console.log(":" + str + ":");

</script>

总结：不使用 obj. 方式访问对象，都去作用域链找，只要使用 obj. 访问成员，都去原型链找。

原型相关API：

1. 获取原型对象，2种：

　　a. 构造函数.prototype

　　b. 子对象.__proto__  ：内部属性，可能被禁用

　　　　尽量使用Object.getPrototypeOf(子对象);

2. 判断对象间是否有继承关系：

　　var hasInherit = 父对象.isPrototypeOf(子对象); 

3. instanceof：判断一个对象是否是指定构造函数的实例

　　function Student(){};

　　var jack = new Student();

　　jack instanceof Student -> true

多态：同一事物，在不同情况下表现出不同样子

　　重写：override：如果子对象觉得父对象的成员不好用，可在本地定义同名成员，覆盖父对象的。

在原型对象中

　　如何添加共有属性：只能通过原型对象

　　　　构造函数.prototype.属性名 = 值;

　　原型链：由各级对象的 __proto__ 逐级继承形成的链式关系

　　规则：在访问对象属性时，只要自己有，就不去父级找，如果自己没有，才去父级找，如果到Object.prototype都没找到，就返回undefined。

　　和作用域链的比较：

　　　　作用域链：控制变量的使用顺序：所有不带.的变量，默认都去作用域找

　　　　原型链：控制对象的属性的使用顺序：所有用.访问的对象属性，都去原型链找

　　

每个对象内部有一个属性： class 记录了创建对象时使用的类型名
访问对象内部的class： 只能调用原生的toString()
Object.prototype.toString();//"[object Object]"
                                                对象 class

强行调用原生toString()：

原生toString.call(替代this的对象)

　　call做两件事：a.执行函数；b.替换this

　　Object.prototype.toString();     this->Object.prototype

　　Object.prototype.toString.call(obj);　　this->obj->在执行时，相当于obj.toString()

<script type="text/javascript">
    
//判断一个对象是否是数组
var obj1 = {};//Object
var obj2 = [];//Array
var obj3 = function(){};//Function
var obj4 = {}; obj4.__proto__ = [];

//typeof无法区分数组和对象
console.log(typeof obj1);//object
console.log(typeof obj2);//object
console.log(typeof obj3);//function
console.log(typeof obj4);//object
console.log("==================");

//1. isPrototypeOf 不但检查直接父对象，而且检查整个原型链
console.log(Array.prototype.isPrototypeOf(obj1));//false
console.log(Array.prototype.isPrototypeOf(obj2));//true
console.log(Array.prototype.isPrototypeOf(obj3));//false
console.log(Array.prototype.isPrototypeOf(obj4));//true
console.log("==================");

//2. constructor 也可检查整个原型链
console.log(obj1.constructor == Array);//false
console.log(obj2.constructor == Array);//true
console.log(obj3.constructor == Array);//false
console.log(obj4.constructor == Array);//true
console.log("==================");

//3. instanceof 也可检查整个原型链
console.log(obj1 instanceof Array);//false
console.log(obj2 instanceof Array);//true
console.log(obj3 instanceof Array);//false
console.log(obj4 instanceof Array);//true
console.log("==================");

//4. 每个对象内部有一个属性： class 记录了创建对象时使用的类型名
console.log(Object.prototype.toString.call(obj1) == "[object Array]");//false
console.log(Object.prototype.toString.call(obj2) == "[object Array]");//true
console.log(Object.prototype.toString.call(obj3) == "[object Array]");//false
console.log(Object.prototype.toString.call(obj4) == "[object Array]");//false
console.log("==================");

//5. ES5： isArray
if(Array.isArray === undefined){
    console.log("Array.prototype.isArray not exsit.");
    Array.isArray = function(obj){
        return (Object.prototype.toString.call(obj) == "[object Array]");
    };
}
console.log(Array.isArray(obj1));//false
console.log(Array.isArray(obj2));//true
console.log(Array.isArray(obj3));//false
console.log(Array.isArray(obj4));//false

</script>

 

自定义继承：

　　a.仅修改一个对象的父对象：

　　　　子对象.__proto__ = 父对象;

　　　　Object.setPrototypeOf(子对象, 父对象);

　　b.直接修改构造函数的原型对象，可同时修改之后创建的所有子对象的父对象：

　　　　时机：必须在创建第一个对象之前完成，才能保证对象间的一致性。

　　c.两种类型间的继承：即扩展结构（extends），又继承原型（inherit）

　　　　抽象：将多个子类型的相同属性和方法，集中提取到一个公共的父类型中定义。

　　　　how：3步：

　　　　　　c1. 将多个子类型的相同属性和方法，抽象到一个公共的父类型中集中定义

　　　　　　c2. 借用构造函数：在子类型构造函数中调用父类型构造函数

　　　　　　　　问题：如果直接调用父类型构造函数：this->window

　　　　　　　　解决：强行调用，更换this：父类型构造函数.call(this, 参数1, 参数2, ...);

　　　　　　　　问题：call要求每个参数都要重复写一遍

　　　　　　　　解决：使用apply传入arguments，apply可打散arguments，再单独传入：父类型构造函数.apply(this, arguments)；

　　　　　　　　总结：只有两个API可打散数组参数：　

　　　　　　　　　　arr1.concat(arr2); -> arr1.concat(arr2[0], arr2[1], ...);

　　　　　　　　　　fun.apply(obj, arr); -> obj.fun(arr[0], arr[1], ...);

　　　　　　c3. 让子类型的原型继承父类型的原型：Object.setPrototypeOf(子类型的原型, 父类型的原型);

call和apply：

　　相同：都是强行调用一个函数，并替换this

　　差别：传入参数的方式：

　　　　call：要求每个参数必须单独传入

　　　　apply：要求所有参数以一个数组的方式整体传入

<script type="text/javascript">
    
function Flyer(fname, speed){
    this.fname = fname;
    this.speed = speed;
}
Flyer.prototype.fly = function(){
    console.log(this.fname + " is flying, on speed " + this.speed);
};

function Enemy(fname, speed, score){
    Flyer.call(this, fname, speed);
    this.score = score;
}
Enemy.prototype.getScore = function(){
    console.log(this.fname + " score is " + this.score);
};
Object.setPrototypeOf(Enemy.prototype, Flyer.prototype);

function Bee(fname, speed, award){
    Flyer.apply(this, arguments);
    this.award = award;
}
Bee.prototype.getAward = function(){
    console.log(this.fname + " award is " + this.award);
};
Object.setPrototypeOf(Bee.prototype, Flyer.prototype);

var e = new Enemy("enemy001", 50, 20);
e.fly();
e.getScore();

var b = new Bee("bee001", 5, 2);
b.fly();
b.getAward();

</script>

*****ES5

对象的属性：

对象：属性的集合

2大类：

　　a. 命名属性：自定义的可用，直接访问的属性

　　　　a1. 数据属性：直接保存一个数据的属性

　　　　a2. 访问器属性：专门保护另外一个数据属性的特殊属性，不直接保存数据

　　b.内部属性：对象内部自动包含的，无法用.访问到的属性，比如：class

***数据属性：

　　ES5中规定，每个数据属性都包含4大特性：

　　　　value：时机存储属性值的特性

　　　　writable：控制当前属性是否可修改 bool

　　　　enumerable：控制当前属性能否被 for in 遍历到 bool

　　　　configurable：控制当前属性能否被删除，或能否修改其他特性

　　如何访问属性的特性：

　　　　查看属性的特性： var attrs = Object.getOwnPropertyDescriptor(obj, "属性名");

　　　　设置属性的特性： Object.defineProperty(obj, "属性名", {value: 值, writable: true/false, enumerable: true/false, configurable: true/false});

　　　　注意：一般修改特性时，都要将configurable设置为false：不准修改其他特性；不可逆。

　　添加一个新属性，并设置四大属性：

　　　　Object.defineProperty(obj, "属性名", {value: 值, writable: true/false, enumerable: true/false, configurable: true/false});

　　　　注意：使用defineProperty添加的新属性，四大特性默认值为false!

　　　　　　对象直接量中的属性：四大特性默认值为true

　　同时定义或添加多个属性，并设置四大特性：

　　　　Object.defineProperty(obj, {

　　　　　　"属性名": {value: 值, writable: true/false, enumerable: true/false, configurable: true/false},

　　　　　　...

　　　　　　});

<script type="text/javascript">
    
var emp = {id:1001, name: "jack", salary: 10000};
console.log(Object.getOwnPropertyDescriptor(emp, "id"));//Object {value: 1001, writable: true, enumerable: true, configurable: true}
Object.defineProperty(emp, "id", {writable: false});//修改emp的id属性为只读
emp.id = 1002;
Object.defineProperty(emp, "salary", {enumerable: false});//修改emp的salary属性为不可遍历
for(var key in emp){
    console.log(key + ":" + emp[key]);//id:1001   name:jack
}

</script>

静态方法：不需要实例化对象，就直接调用的方法。

方法定义在原型对象中，还是定义在构造函数上：

　　如果只希望当前类型的子对象才能用，就放在原型对象中；

　　如果不希望实例化任何对象，就可以直接调用，就放在构造函数上。