function object(o) {function F() {}F.prototype = o;return new F();
}// 要继承的父对象
var parent = {name: "Papa"
};// 新对象
var child = object(parent);// 测试
console.log(child.name); // "Papa"
// 父构造函数
function Person() {// an "own" property
    this.name = "Adam";
}
// 给原型添加新属性
Person.prototype.getName = function () {return this.name;
};
// 创建新person
var papa = new Person();
// 继承
var kid = object(papa);
console.log(kid.getName()); // "Adam"
// 父构造函数
function Person() {// an "own" property
    this.name = "Adam";
}
// 给原型添加新属性
Person.prototype.getName = function () {return this.name;
};
// 继承
var kid = object(Person.prototype);
console.log(typeof kid.getName); // "function",因为是在原型里定义的
console.log(typeof kid.name); // "undefined", 因为只继承了原型

/* 使用新版的ECMAScript 5提供的功能 */
var child = Object.create(parent);var child = Object.create(parent, {age: { value: 2} // ECMA5 descriptor
});
console.log(child.hasOwnProperty("age")); // true

// 首先，定义一个新对象man
var man = Object.create(null);// 接着，创建包含属性的配置设置
// 属性设置为可写，可枚举，可配置
var config = {writable: true,enumerable: true,configurable: true
};// 通常使用Object.defineProperty()来添加新属性(ECMAScript5支持）
// 现在，为了方便，我们自定义一个封装函数
var defineProp = function (obj, key, value) {config.value = value;Object.defineProperty(obj, key, config);
}defineProp(man, 'car', 'Delorean');
defineProp(man, 'dob', '1981');
defineProp(man, 'beard', false);

var driver = Object.create( man );
defineProp (driver, 'topSpeed', '100mph');
driver.topSpeed // 100mph

/* 浅拷贝 */
function extend(parent, child) {var i;child = child || {};for (i in parent) {if (parent.hasOwnProperty(i)) {child[i] = parent[i];}}return child;
}var dad = { name: "Adam" };
var kid = extend(dad);
console.log(kid.name); // "Adam"

var dad = {counts: [1, 2, 3],reads: { paper: true }
};
var kid = extend(dad);
kid.counts.push(4);
console.log(dad.counts.toString()); // "1,2,3,4"
console.log(dad.reads === kid.reads); // true

/* 深拷贝 */
function extendDeep(parent, child) {var i,toStr = Object.prototype.toString,astr = "[object Array]";child = child || {};for (i in parent) {if (parent.hasOwnProperty(i)) {if (typeof parent[i] === 'object') {child[i] = (toStr.call(parent[i]) === astr) ? [] : {};extendDeep(parent[i], child[i]);} else {child[i] = parent[i];}}}return child;
}var dad = {counts: [1, 2, 3],reads: { paper: true }
};
var kid = extendDeep(dad);kid.counts.push(4);
console.log(kid.counts.toString()); // "1,2,3,4"
console.log(dad.counts.toString()); // "1,2,3"

console.log(dad.reads === kid.reads); // false
kid.reads.paper = false;

function mix() {var arg, prop, child = {};for (arg = 0; arg < arguments.length; arg += 1) {for (prop in arguments[arg]) {if (arguments[arg].hasOwnProperty(prop)) {child[prop] = arguments[arg][prop];}}}return child;
}var cake = mix({ eggs: 2, large: true },{ butter: 1, salted: true },{ flour: '3 cups' },{ sugar: 'sure!' });console.dir(cake);

// Car
var Car = function (settings) {this.model = settings.model || 'no model provided';this.colour = settings.colour || 'no colour provided';
};// Mixin
var Mixin = function () { };
Mixin.prototype = {driveForward: function () {console.log('drive forward');},driveBackward: function () {console.log('drive backward');}
};// 定义的2个参数分别是被混入的对象（reciving）和从哪里混入的对象（giving)
function augment(receivingObj, givingObj) {// 如果提供了指定的方法名称的话，也就是参数多余3个
    if (arguments[2]) {for (var i = 2, len = arguments.length; i < len; i++) {receivingObj.prototype[arguments[i]] = givingObj.prototype[arguments[i]];}}// 如果不指定第3个参数，或者更多参数，就混入所有的方法
    else {for (var methodName in givingObj.prototype) {// 检查receiving对象内部不包含要混入的名字，如何包含就不混入了
            if (!receivingObj.prototype[methodName]) {receivingObj.prototype[methodName] = givingObj.prototype[methodName];}}}
}// 给Car混入属性，但是值混入'driveForward' 和 'driveBackward'*/
augment(Car, Mixin, 'driveForward', 'driveBackward');// 创建新对象Car
var vehicle = new Car({ model: 'Ford Escort', colour: 'blue' });// 测试是否成功得到混入的方法
vehicle.driveForward();
vehicle.driveBackward();

var one = {name: 'object',say: function (greet) {return greet + ', ' + this.name;}
};// 测试
console.log(one.say('hi')); // "hi, object"

var two = {name: 'another object'
};console.log(one.say.apply(two, ['hello'])); // "hello, another object"

// 将say赋值给一个变量，this将指向到全局变量
var say = one.say;
console.log(say('hoho')); // "hoho, undefined"

// 传入一个回调函数callback
var yetanother = {name: 'Yet another object',method: function (callback) {return callback('Hola');}
};
console.log(yetanother.method(one.say)); // "Holla, undefined"

function bind(o, m) {return function () {return m.apply(o, [].slice.call(arguments));};
}var twosay = bind(two, one.say);
console.log(twosay('yo')); // "yo, another object"
// ECMAScript 5给Function.prototype添加了一个bind()方法，以便很容易使用apply()和call()。

if (typeof Function.prototype.bind === 'undefined') {Function.prototype.bind = function (thisArg) {var fn = this,
slice = Array.prototype.slice,
args = slice.call(arguments, 1);return function () {return fn.apply(thisArg, args.concat(slice.call(arguments)));};};
}var twosay2 = one.say.bind(two);
console.log(twosay2('Bonjour')); // "Bonjour, another object"

var twosay3 = one.say.bind(two, 'Enchanté');
console.log(twosay3()); // "Enchanté, another object"