javascript基础学习笔记2

继承发展史

1.传统形式—>原型链
过多的继承了没用的属性

2.借用构造函数
不能继承借用构造函数的原型
每次构造函数都要多走一个函数

3.共享原型
不能随便改变自己的原型

4.圣杯模式

传统形式

Grand.prototype.lastName = 'li';

function Grand(){};

var grand = new Grand();

Father.prototype = grand;

function Father() {
  this.name = 'ga';
}

var father = new Father();

Son.prototype = father;

function Son(){};

var son = new Son();

借用构造函数

function Person (age,sex,name) {
  this.age = age;
  this.sex = sex;
  this.name = name;
}

function Chen (age,sex,name,job) {
  Person.call(this,age,sex,name);
  this.job = job;
}

var chen = new Chen('18','男','陈旭锋','程序员');

共享原型

function Father () {};

function Son () {};

Son.prototype = Father.prototype;

圣杯模式

var inherit = (function () {
  var F = function ();
  return function (Target, Origin) {
    F.prototype = Origin.prototype;
    Target.protype = new F();
    Target.prototype.constructor = Target;
    Target.prototype.uber = Origin.prototype;
  }
}());

arguments

1.arguments.callee
指向函数自身

2.function.caller
指向函数自身

数组

改变原数组的方法
1.push：向数组最后位置添加元素
2.pop：使数组长度减一，并返回最后一个元素，如果数组为空 ，则不改变数组长度，返回undefined。
3.shift：使数组长度减一，并返回第一个元素，如果数组为空 ，则不改变数组长度，返回undefined。
4.unshift： unshift() 方法将把它的参数插入 arrayObject 的头部，并将已经存在的元素顺次地移到较高的下标处，以便留出空间。该方法的第一个参数将成为数组的新元素 0，如果还有第二个参数，它将成为新的元素 1，以此类推。
5.sort：对数组进行排序，可以重写里面的排序方法，如果要升序可以返回正数，降序则相反。
6.reverse：将数组倒序。
7.splice：三个参数，第一个参数是从什么位置开始，第二个参数是切割几位，第三个参数是往里面添加的元素。

不改变原数组的方法
1.concat：将1个数组拼接在另外的一个数组上，返回一个新的数组。
2.join：将数组通过参数连接起来，每个间隔都会有参数，返回一个新的数组。
3.split：通过参数将数组分割开来，返回一个新的数组。
4.toString：将数组以字符串的形式输出。
5.slice：返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。

类数组

arguments是类数组（具有数组和对象两种性质）。
属性要为索引（数字）属性，必须要有length属性，最好加上一个splice和push

//类数组
obj = {
    "1": "a",
    "2": "b",
    "3": "c",
    "length": 3,
    "name": "chen",
    "age": "21",
    "splice": Array.prototype.splice,
    "push": Array.prototype.push
}

试题

var obj = {
    "2": "a",
    "3": "b",
    "length": 2,
    "push": Array.prototype.push
}

obj.push("c");
obj.push("d");

//push上的方法
Array.prototype.push = function (target) {
    obj[obj.length] = target;
    obj["length"]++;
}

//obj结果
obj = {
    "2": "c",
    "3": "d",
    "length": 4,
    "push": Array.prototype.push
}

对象的深拷贝和浅拷贝

1.浅拷贝

function clone(origin, target) {
    var target = target || {};
    for (var prop in origin) {
        target[prop] = origin[prop];
    }
    return target;
}

2.深拷贝

function deepClone(origin, target) {
    var target = target || {},
        toStr = Object.prototype.toString,
        arrStr = "[object Array]";
    for (var prop in origin) {
        if (origin.hasOwnProperty(prop)) {
            if (origin[prop] !== 'null' && typeof (origin[prop]) == 'object') {
                target[prop] = toStr.call(origin[prop]) == arrStr ? [] : {};
                deepClone(origin[prop], target[prop]);
            } else {
                target[prop] = origin[prop];
            }
        }
    }
    return target;
}