Object.print = function (o) { console.log(o) };

Object.prototype.print = function () {
  console.log(this);
};

var obj = new Object();
obj.print() // Object

var obj = Object() // obj => {}
// 等同于
obj = Object(undefined)
obj = Object(null)
obj instanceof Object // true

// 包装对象实例

var obj = Object(1) // obj => Number{1}
obj instanceof Object // true     in s tan ce of 判断对象类型
obj instanceof Number // true


var obj = Object('foo') // obj => String{‘foo’}
obj instanceof Object // true
obj instanceof String // true

var obj = Object(true) // obj => Boolean{‘foo’}
obj instanceof Object // true
obj instanceof Boolean // true

var arr = []
var obj = Object(arr) // obj => []
obj === arr // true


var value = {}
var obj = Object(value) // obj => {}
obj === value // true


var fn = function() {}
var obj = Object(fn) // obj => function(){}
obj === fn // true

var obj = new Object() // 等同于 var obj = {}

var obj = {
    p1: 123,
    p2: 456
}

Object.keys(obj) // ['p1','p2']  注意是属性名

var obj = {
    p1: 123,
    p2: 456
}
Object.getOwnPropertyNames(obj) // ['p1','p2']
// getOwnPropertyNames 中文含义：获取自己的属性名

var a = ['hello','world']
Object.keys(a) // ['0',‘1’]  如果对象是数组时返回索引字符串
Object.getOwnPropertyNames(a) // [‘0’,‘1’,'length']

var obj = new Object()
obj.valueof() === obj //true

var obj = Object()
1+obj //"1[object Object]"

var obj = new Object()
obj.valueof = function () {
    return 2
}
1 + obj // 3

var o1 = new Object()
o1.toString() // "[object Object]"

var o2 = {a:2}
o2.toString() // "[object Object]"

var obj = new Object()

obj.toString = function() {
    return 'hello'
}
obj + ' '+ 'world' // "hello world"

[1, 2, 3].toString() // "1,2,3"

'123'.toString() // "123"

(function () {
  return 123;
}).toString()
// "function () {
//   return 123;
// }"

(new Date()).toString()
// "Tue May 10 2016 09:11:31 GMT+0800 (CST)"

Object.prototype.toString.call(2) // "[object Number]"
Object.prototype.toString.call('') // "[object String]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(Math) // "[object Math]"
Object.prototype.toString.call({}) // "[object Object]"
Object.prototype.toString.call([]) // "[object Array]"

var type = function (o){
    var s = Object.prototype.toString.call(o)
    return s.match(/\[object (.*?)\]/)[1].toLowerCase()
}
type({}); // "object"
type([]); // "array"
type(5); // "number"
type(null); // "null"
type(); // "undefined"
type(/abcd/); // "regex"
type(new Date()); // "date"

var type = function (o){
  var s = Object.prototype.toString.call(o);
  return s.match(/\[object (.*?)\]/)[1].toLowerCase();
};

['Null',
 'Undefined',
 'Object',
 'Array',
 'String',
 'Number',
 'Boolean',
 'Function',
 'RegExp'
].forEach(function (t) {
  type['is' + t] = function (o) {
    return type(o) === t.toLowerCase();
  };
});

type.isObject({}) // true
type.isNumber(NaN) // true
type.isRegExp(/abc/) // true

var obj = {};
obj.toString(obj) // "[object Object]"
obj.toLocaleString(obj) // "[object Object]"

var person = {
  toString: function () {
    return 'Henry Norman Bethune';
  },
  toLocaleString: function () {
    return '白求恩';
  }
};

person.toString() // Henry Norman Bethune
person.toLocaleString() // 白求恩

var date = new Date();
date.toString() // "Sun Oct 06 2019 15:50:04 GMT+0800 (中国标准时间)"
date.toLocaleString() // "2019/10/6 下午3:50:04"

{
  value: 123, // 该属性的属性值，默认undefined
  writable: false, // 属性值是否可改变，默认为true
  enumerable: true, // 该属性是否可遍历，默认为true
  configurable: false, //属性描述对象的可配置性,默认为true
  get: undefined, // 该属性的取值函数（getter），默认为undefined
  set: undefined // 该属性的存值函数（setter），默认为undefined
}

var obj = {p:'a'}

Object.getOwnPropertyDescriptor(obj,'p')
// Object { value: "a",  // 属性值'a'
//   writable: true, // 属性值'a' 可改写
//   enumerable: true, // 'p'属性可被遍历
//   configurable: true // 属性描述对象的可配置性
// }


// getOwnPropertyDescriptor 中文含义：获取自己的属性描述符

var obj = { p: 'a' };

Object.getOwnPropertyDescriptor(obj, 'toString')
// undefined

var obj = Object.defineProperties({}, {
  p1: { value: 1, enumerable: true },
  p2: { value: 2, enumerable: false }
});

Object.getOwnPropertyNames(obj)
// ["p1", "p2"]

Object.keys([]) // []
Object.getOwnPropertyNames([]) // [ 'length' ]

Object.keys(Object.prototype) // []
Object.getOwnPropertyNames(Object.prototype)
 /*[
	"constructor",   // 构造函数
    "__defineGetter__",
    "__defineSetter__",
    "hasOwnProperty",  // 检测属性名
    "__lookupGetter__",
    "__lookupSetter__",
    "isPrototypeOf",
    "propertyIsEnumerable",
    "toString",  // 返回类型字符串
    "valueOf",
    "__proto__",  // 原型链
    "toLocaleString"
   ]
*/

Object.defineProperty(object, propertyName, attributesObject)

var obj = Object.defineProperty({}, 'p', {
  value: 123,
  writable: false, // 设置为false，无法被改写
  enumerable: true, // 可遍历
  configurable: false // 属性描述不可再被配置
});

obj.p // 123

obj.p = 246; // 由于writable为false,改写无效
obj.p // 123

var obj = Object.defineProperties({}, {
  p1: { value: 123, enumerable: true },
  p2: { value: 'abc', enumerable: true },
  p3: { get: function () { return this.p1 + this.p2 },
    enumerable:true,
    configurable:true
  }
});

obj.p1 // 123
obj.p2 // "abc"
obj.p3 // "123abc"

var obj = {};

Object.defineProperty(obj, 'p', {
  value: 123,
  get: function() { return 456; }
});
// TypeError: Invalid property.
// A property cannot both have accessors and be writable or have a value

Object.defineProperty(obj, 'p', {
  writable: true,
  get: function() { return 456; }
});
// TypeError: Invalid property descriptor.
// Cannot both specify accessors and a value or writable attribute

var obj = {};
Object.defineProperty(obj, 'foo', {});
Object.getOwnPropertyDescriptor(obj, 'foo')
// {  // 默认值
//   value: undefined,
//   writable: false,
//   enumerable: false,
//   configurable: false
// }

var obj = {};
obj.p = 123;

obj.propertyIsEnumerable('p') // true
obj.propertyIsEnumerable('toString') // false

var obj = {};
obj.p = 123;

Object.getOwnPropertyDescriptor(obj, 'p').value
// 123

Object.defineProperty(obj, 'p', { value: 246 });
obj.p // 246

var obj = {};

Object.defineProperty(obj, 'a', {
  value: 37,
  writable: false
});

obj.a // 37
obj.a = 25; // 可写性为false，值无法被修改
obj.a // 37

var proto = Object.defineProperty({}, 'foo', {
  value: 'a',
  writable: false
});

var obj = Object.create(proto); // obj对象继承proto对象

obj.foo = 'b';
obj.foo // 'a'

var proto = Object.defineProperty({}, 'foo', {
  value: 'a',
  writable: false
});

var obj = Object.create(proto);
Object.defineProperty(obj, 'foo', {
  value: 'b'
});

obj.foo // "b"

var obj = {};
'toString' in obj // true

var obj = {};

Object.defineProperty(obj, 'x', {
  value: 123,
  enumerable: false
});

obj.x // 123

for (var key in obj) {
  console.log(key);
}
// undefined

Object.keys(obj)  // []
JSON.stringify(obj) // "{}"

var obj = Object.defineProperty({}, 'p', {
  value: 1,
  writable: false,
  enumerable: false,
  configurable: false
});

Object.defineProperty(obj, 'p', {value: 2})
// TypeError: Cannot redefine property: p

Object.defineProperty(obj, 'p', {writable: true})
// TypeError: Cannot redefine property: p

Object.defineProperty(obj, 'p', {enumerable: true})
// TypeError: Cannot redefine property: p

Object.defineProperty(obj, 'p', {configurable: true})
// TypeError: Cannot redefine property: p

var obj = Object.defineProperty({}, 'p', {
  writable: true,
  configurable: false
});

Object.defineProperty(obj, 'p', {writable: false})
// 修改成功

var o1 = Object.defineProperty({}, 'p', {
  value: 1,
  writable: true,
  configurable: false
});

Object.defineProperty(o1, 'p', {value: 2})
// 修改成功

var o2 = Object.defineProperty({}, 'p', {
  value: 1,
  writable: false,
  configurable: true
});

Object.defineProperty(o2, 'p', {value: 2})
// 修改成功

var obj = Object.defineProperty({}, 'p', {
  value: 1,
  writable: false,
  configurable: false
});

obj.p = 2;
obj.p // 1

var obj = Object.defineProperties({}, {
  p1: { value: 1, configurable: true },
  p2: { value: 2, configurable: false }
});

delete obj.p1 // true
delete obj.p2 // false

obj.p1 // undefined
obj.p2 // 2

var obj = Object.defineProperty({}, 'p', {
  get: function () { // 获取属性时执行
    return 'getter' // 这里相当于定义了p属性的值，如果设置了get则不能再设置value
  },
  set: function (value) { // 设置属性时执行
    console.log('setter: ' + value);
  }
});

obj.p // "getter"
obj.p = 123 // "setter: 123"

var obj = {
    get p(){ // 相当于为obj对象创建一个p属性，并且赋值为‘getter’
        return 'getter'
    },
    ser p(value){
        console.log('setter'+value)
    }
}

var obj ={
  $n : 5,
  get next() { return this.$n++ },
  set next(n) {
    if (n >= this.$n) this.$n = n;
    else throw new Error('新的值必须大于当前值');
  }
};

obj.next // 5

obj.next = 10;
obj.next // 10

obj.next = 5;
// Uncaught Error: 新的值必须大于当前值

var extend = function (to, from){
    for(var property in from) {
        to[property] = from[property]
    }
    return to
}
extend({}, {a: 1}) // {a:1}

var extend = function (to, from){
    for(var property in from){
    	if(!from.hasOwnProperty()) continue //过滤继承属性 continue 终止本次循环，继续剩余循环
        Object.defineProperty(
            to,
            property,
            Object.getOwnPropertyDescriptor(from,property)
        )
    }
    return to
}
extend({},{get a(){return 1}}) // {get a(){return 1}}

var obj = new Object()
Object.preventExtensions(obj) // prevent Extensions 中文： 防止扩展
Object.defineProperty(obj,'p',{
    value: 'hello'
}) // TypeError:cannot define property:p, object is not extensible

obj.p = 1
obj.p // undefined

var obj = new Object()
Object.isExtensible(obj) // true    is Extensible 中文： 是可扩展的？
Object.preventExtensions(obj)
Object.isExtensible(obj) // false

var obj = {p: 'hello'}
Object.seal(obj) // seal 中文： 密封

delete obj.p // 删除属性无效
obj.p // hello

obj.p = 'hi' // 可修改值
obj.p // hi

obj.x = 'world' // 新增属性无效
obj.x // undefined

var obj = {p: 'a'}

Object.getOwnPropertyDescriptor(obj, 'p')
// Object {
//   value: "a",
//   writable: true,
//   enumerable: true,
//   configurable: true
// }

Object.seal(obj)

Object.getOwnPropertyDescriptor(obj, 'p')
// Object {
//   value: "a",
//   writable: true,
//   enumerable: true,
//   configurable: false
// }

Object.defineProperty(obj,'p',{
    enumerable:
})
// TypeError: Cannot redefine property: p

var obj = {p:'a'}
Object.seal(obj)
Object.isSealed(obj) // true   is Sealed 中文： 是密封的？

var obj = { p: 'a' };

Object.seal(obj);
Object.isExtensible(obj) // false

var obj = {p:'hello'}
Object.freeze(obj)

obj.p = 'world'
obj.p // hello

obj.t = 'hello'
obj.t // nudefined

delete obj.p // false
obj.p // hello

var obj = {
  p: 'hello'
};

Object.freeze(obj);
Object.isFrozen(obj) // true // 是冻结的

var obj = {
  p: 'hello'
};

Object.freeze(obj);

Object.isSealed(obj) // true // 是密封的
Object.isExtensible(obj) // false // 不是可扩展的

var obj = {
  p: 'hello'
};

Object.freeze(obj);

if (!Object.isFrozen(obj)) {
  obj.p = 'world';
}

var obj = new Object();
Object.preventExtensions(obj);

var proto = Object.getPrototypeOf(obj); // 获取原型对象
proto.t = 'hello';
obj.t
// hello

var obj = new Object();
Object.preventExtensions(obj);

var proto = Object.getPrototypeOf(obj);
Object.preventExtensions(proto);

proto.t = 'hello';
obj.t // undefined

var obj = {
  foo: 1,
  bar: ['a', 'b']
};
Object.freeze(obj);

obj.bar.push('c');
obj.bar // ["a", "b", "c"]

var arr = new Array(2); // Array是原生对象，也是构造函数； 2表示生成2个成员
arr.length // 2
arr // [ empty x 2 ]

var arr = new Array(2);
// 等同于
var arr = Array(2);

// 无参数时，返回一个空数组
new Array() // []

// 单个正整数参数，表示返回的新数组的长度
new Array(1) // [ empty ]
new Array(2) // [ empty x 2 ]

// 非正整数的数值作为参数，会报错
new Array(3.2) // RangeError: Invalid array length
new Array(-3) // RangeError: Invalid array length

// 单个非数值（比如字符串、布尔值、对象等）作为参数，
// 则该参数是返回的新数组的成员
new Array('abc') // ['abc']
new Array([1]) // [Array[1]]

// 多参数时，所有参数都是返回的新数组的成员
new Array(1, 2) // [1, 2]
new Array('a', 'b', 'c') // ['a', 'b', 'c']

// bad
var arr = new Array(1, 2);

// good
var arr = [1, 2];

var a = new Array(3);
var b = [undefined, undefined, undefined];

a.length // 3
b.length // 3

a[0] // undefined
b[0] // undefined

0 in a // false  // in运算符用于数组时，前面的参数为数组索引
0 in b // true

var arr = [1,2,3]
typeof arr // object // 使用typeof返回的是object
Array.isArray(arr)// true

var arr = [1,2,3]
arr.valueOf() // [1,2,3]

var arr = [1, 2, 3];
arr.toString() // "1,2,3"

var arr = [1, 2, 3, [4, 5, 6]];
arr.toString() // "1,2,3,4,5,6"

var arr=[]
arr.push(1) // 1
arr.push('a') // 2
arr.push(true,{}) // 4
arr // [1,'a',true,{}]

// 注：push()方法 返回添加后的数组长度，会改变原数组

var arr = ['a','b','c']
arr.pop() // 'c'  删除最后一个元素，并返回该元素
arr // ['a','b']

[].pop() // undefined

var arr = [];
arr.push(1, 2);
arr.push(3);
arr.pop();
arr // [1, 2]

var a = ['a', 'b', 'c'];

a.unshift('x'); // 4
a // ['x', 'a', 'b', 'c']

var arr = [ 'c', 'd' ];
arr.unshift('a', 'b') // 4
arr // [ 'a', 'b', 'c', 'd' ]

var a = ['a','b','c']
a.shift() // 'a' 删除第一个元素，并返回该元素
a // ['b','c']

var list = [1, 2, 3, 4];
var item;

while (item = list.shift()) {
  console.log(item);
}

list // []

var queue = []
queue.push('1')
queue.push('2')
queue.push('3')
queue.shift()
queue // ['2','3']

var a = [1,2,3,4]

a.join('') // '1234'
a.join(' ') // '1 2 3 4'
a.join('|') // '1|2|3|4‘
a.join() // '1,2,3,4'

[undefined, null].join('#')
// '#'

['a',, 'b'].join('-')
// 'a--b'

Array.prototype.join.call('hello', '-')
// "h-e-l-l-o"
// 等价 'hello'.split('').join('-')

var obj = { 0: 'a', 1: 'b', length: 2 }; // 数组的变形对象
Array.prototype.join.call(obj, '-')
// 'a-b'

['hello'].concat(['world'])
// ['hello','world']

['hello'].concat(['world'],['!'])
// ["hello", "world", "!"]

[].concat({a: 1}, {b: 2})
// [{ a: 1 }, { b: 2 }]

[2].concat({a: 1})
// [2, {a: 1}]

[].concat(1,2)
// [1,2]

[1, 2, 3].concat(4, 5, 6)
// [1, 2, 3, 4, 5, 6]

var obj = { a: 1 };
var oldArray = [obj]; // 浅拷贝

var newArray = oldArray.concat();

obj.a = 2; // 改变原对象以后，新数组跟着改变
newArray[0].a // 2

var a = [1,2,3,4]
a.reverse() // [4,3,2,1]
a // [4,3,2,1]

arr.slice(start, end);

var a = ['a','b','c']
a.slice(0) // ['a','b','c'] 从0到最后一个成员
a.slice(1) // ['b','c'] 从1到最后一个成员
a.slice(1,2) // ['b'] 从1到2成员，不包含2成员
a.slice(2,6) // ['c'] 从2到6成员，超出的不计算在内
a.slice() //['a','b','c'] 无参数，默认全部，多用于拷贝数组到新的数组

var a = ['a', 'b', 'c'];
a.slice(-2) // ["b", "c"]
a.slice(-2, -1) // ["b"]

var a = ['a', 'b', 'c'];
a.slice(4) // []
a.slice(2, 1) // []

Array.prototype.slice.call({ 0: 'a', 1: 'b', length: 2 })
// ['a', 'b']

Array.prototype.slice.call(document.querySelectorAll("div"));
Array.prototype.slice.call(arguments);

arr.splice(start, count, addElement1, addElement2, ...);
// 第几个开始，删除几个，加入的新成员...(非必需）

var a = [1,2,3,4,5,6]
a.splice(2,2) // [3,4] 返回被删除成员
a.[1,2,5,6]

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2, 1, 2) // ["e", "f"]
a // ["a", "b", "c", "d", 1, 2]

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(-4, 2) // ["c", "d"] 负数表示倒数

var a = [1, 1, 1];

a.splice(1, 0, 'a') // [] // 不删除成员，并加入新成员到指定位置
a // [1, 'a', 1, 1]

var a = [1, 2, 3, 4];
var a2 = a.splice(2) // [3, 4]
a // [1, 2]
a2 // [3, 4]

['d', 'c', 'b', 'a'].sort()
// ['a', 'b', 'c', 'd']


[4, 3, 2, 1].sort()
// [1, 2, 3, 4]

['abc','ba','ea','ae'].sort()
// ["abc", "ae", "ba", "ea"]

[11, 101].sort()
// [101, 11]

[10111, 1101, 111].sort()
// [10111, 1101, 111]

[10111, 1101, 111].sort(function (a, b) { // 返回值大于0,则a排于b之后，否则反之。
  return a - b; // 升序
})
// [111, 1101, 10111]

[10111, 1101, 111].sort(function (a, b) {
  return b - a; // 降序
})
// [10111，1101, 111]

[
  { name: "张三", age: 30 },
  { name: "李四", age: 24 },
  { name: "王五", age: 28  }
].sort(function (o1, o2) {
  return o1.age - o2.age;
})
// [
//   { name: "李四", age: 24 },
//   { name: "王五", age: 28  },
//   { name: "张三", age: 30 }
// ]


// 自定义排序
[
    {day: '星期日'}, {day:'星期一'}, {day:'星期五'}
].sort(function(o1,o2){
    return computedDay(o1.day.charAt(2)) - computedDay(o2.day.charAt(2))
}) //[{ day: '星期一' }, { day: '星期五' }, { day: '星期日' }]

function computedDay(v){
   return v === '一' ? 1 : v === '二' ? 2 : v === '三' ? 3 : v === '四' ? 4 : v === '五' ? 5 : v === '六' ? 6 : 7
}

// bad
[1, 4, 2, 6, 0, 6, 2, 6].sort((a, b) => a > b) // 返回布尔值，不推荐

// good
[1, 4, 2, 6, 0, 6, 2, 6].sort((a, b) => a - b) // 返回数值，推荐

var numbers = [1, 2, 3];

numbers.map(function (n) {
  return n + 1;
});
// [2, 3, 4]

numbers
// [1, 2, 3]

[1, 2, 3].map(function(elem, index, arr) { // 当前成员、当前索引、数组本身
  return elem * index;
});
// [0, 2, 6]

var arr = ['a', 'b', 'c'];

[1, 2].map(function (e) {
  return this[e]; // this指向arr
}, arr) // 使内部this指向arr
// ['b', 'c']

var f = function (n) { return 'a' };

[1, undefined, 2].map(f) // ["a", "a", "a"]
[1, null, 2].map(f) // ["a", "a", "a"]
[1, , 2].map(f) // ["a", , "a"]

function log(element, index, array) {  // 当前成员、当前索引、数组本身
  console.log('[' + index + '] = ' + element);
}

[2, 5, 9].forEach(log);
// [0] = 2
// [1] = 5
// [2] = 9

var out = [];

[1, 2, 3].forEach(function(elem) {
  this.push(elem * elem); // this指向为out
}, out); // 使内部this指向out

out // [1, 4, 9]

var arr = [1, 2, 3];
for (var i = 0; i < arr.length; i++) {
  if (arr[i] === 2) break;
  console.log(arr[i]);
}
// 1

var log = function (n) {
  console.log(n + 1);
};

[1, undefined, 2].forEach(log)
// 2
// NaN
// 3

[1, null, 2].forEach(log)
// 2
// 1  // null+1 => 1
// 3

[1, , 2].forEach(log)
// 2
// 3

[1,2,3,4,5].filter(function(elem){
    return elem > 3
})
// [4,5]

var arr = [0, 1, 'a', false];

arr.filter(Boolean)
// [1, "a"]

[1, 2, 3, 4, 5].filter(function (elem, index, arr) { // 当前成员，当前位置、整个数组
  return index % 2 === 0;
});
// [1, 3, 5]

var obj = { MAX: 3 };
var myFilter = function (item) {
  if (item > this.MAX) return true; // this指向obj
};

var arr = [2, 8, 3, 4, 1, 3, 2, 9];
arr.filter(myFilter, obj) // [8, 4, 9]  // 使myFilter内部this指向obj

var arr = [1,2,3,4,5]
arr.some(function(elem,index,arr){ // 返回值中有一个为true则此方法返回true
    return elem >= 3
})
// true

var arr = [1, 2, 3, 4, 5];
arr.every(function (elem, index, arr) { // 每个返回值都为true，此方法才返回true，否则返回false
  return elem >= 3;
});
// false

function isEven(x) { return x % 2 === 0 } // 不会执行此函数

[].some(isEven) // false
[].every(isEven) // true

var arr = [1,2,3]
var obj = {MAX:0}
function fn(elem) {
    return elem > this.MAX // this指向obj
}

arr.some(fn,obj) // true
arr.every(fn,obj) // true

[1,2,3,4,5].reduce(function(a,b,c,d){
    // 记住a是默认是第一个成员，然后是上一次运算的返回值。
    console.log(a,b)
    console.log(c)
    return a+b
})
// 1 2
// 3 3
// 6 4
// 10 5
// 最终结果 15