充分了解JavaScript中的对象，顺便弄懂你一直不明白的原型和原型链

{
	name: '张三',
	fn: function() { return 1 }
}

let obj1 = {}      //创建了一个空的对象
let obj2 = {	   //创建了有一个属性为name，值为张三的对象
	name: '张三'
}

let arr = new Array()
let data = new Date()

function MyObj() {
	
}
let obj = new MyObj()    //成功调用构造函数 MyObj，创建了一个对象

let obj = Object.create({x:1, y:2})  //{x:1, y:2}是obj的原型

//先写一个构造函数
function MyObj() {
	//这里暂时先不写任何代码
}
console.log(typeof MyObj)   //  function
console.log(typeof MyObj.prototype)  // Object

let arr = []                          //对象直接量创建对象
console.log(arr.__proto__ === Array.prototype)    //  true
console.log(arr.__proto__.__proto__ === Object.prototype)  //true
console.log(arr.__proto__.__proto__.__proto__)  // null

let arr = Object.create({x:1, y:2})
console.log(arr.__proto__)          // {x:1, y:2}
console.log(arr.__proto__.__proto__ === Object.prototype) // true
console.log(arr.__proto__.__proto__.__proto__)    // null

let obj = {
	name: 'Lpyexplore',
	age: 21,
	gender: 0
}

let name = obj.name     //获取obj对象中的name属性  Lpyexplore
let age = obj["age"]    //获取obj对象中的age属性    21
let fn = obj.toString   //获取obj对象中的继承属性toString    [Function: toString]
 
obj["like"] = "python"  //给obj对象设置一个like属性，值为python
obj.weight = 128        //给obj对象设置一个weight属性，值为128
obj.age = 22            //修改obj对象中的age属性，值改为22

console.log(obj.height) //获取obj对象中的height属性
console.log(obj)        //查看一下obj对象的变化
/*

undefined

{
	name: 'Lpyexplore',
	age: 22,
	gender: 0,
	like: 'python',
	weight: 128
}

*/

let obj = {
    x:1,
    y:2,
    z:3
}

delete obj.x         //删除对象obj中的属性x，返回true
delete obj["y"]      //删除对象obj中的属性y，返回true
delete obj.toString  //toString是对象obj的原型中的属性，属于继承属性，无法删除该属性，但仍然返回true

console.log(obj.x)   //查询对象obj中的属性x
console.log(obj)     //查看对象obj

/*
undefined
{z:3}
*/

let obj = {
	x: 1,
	y: undefined
}

"x" in obj        //返回true，表示对象obj中有属性x
"y" in obj        //返回true，表示对象obj中有属性y，只不过值为undefined
"z" in obj        //返回false，表示对象obj中不存在属性z
delete obj.x      //删除对象obj中的x属性
"x" in obj        //返回false，表示对象obj中不存在属性x

let obj = {
	x:1
}

obj.hasOwnProperty("x")     //返回true，表明属性x存在，且为obj的自有属性
obj.hasOwnProperty("z")     //返回false，属性zu不存在于对象obj中
obj.hasOwnProperty("toString")  //返回false，属性toString是obj的继承属性，不是自有属性

let obj = Object.create({x:1}) //新建一个对象obj，继承于对象 {x:1}
obj.y = 2                   //给obj对象设置一个属性y，其值为2

obj.propertyIsEnumerable("y")  //返回true，表示属性y为该对象的自有属性，且具有可枚举性
obj.propertyIsEnumerable("x")  //返回false，因为属性x是继承属性，继承于对象{x:1}
Object.prototype.propertyIsEnumerable("toString")   //返回false，虽然属性toString是对象Object.prototype的自有属性，但它不具有可枚举性

let obj = {
	x:1, 
	y:2,
	z:3
}

for(let i in obj) {    //遍历对象obj的自有属性
	console.log(i)
}

// 输出  1  2  3

let obj = {
    x:1,
    y:2,
    z:3
}

Object.keys(obj)   //    ['x', 'y', 'z']

let obj = {
    x:1,
    y:2,
    z:3
}

Object.getOwnPropertyNames(obj)   //    ['x', 'y', 'z']

let obj = {
	x:1,
	y:2,
	get r() {     //用getter方法定义了属性r，在查询该属性时，调用该函数
		return this.x + 2		
	},
	set r(data) {   //用setter方法定义了属性r，在给属性r赋值时，调用该函数，并将值作为该函数的参数
		this.y * data;
		return this.y
	}
}

let r = obj.r        //查询对象obj中的属性r，返回 3
obj.r = 7            //给对象obj的属性r赋值为7，  返回 14

//先创建一个对象obj
let obj = {
	x:1
}

Object.getOwnPropertyDescriptor(obj, "x")    //查询对象obj中属性x的属性描述符

// 返回 {value: 1, writable: true, enumerable: true, configurable: true}

//先创建一个对象obj
let obj = {
	get r() {
		return this.x + 1
	},
	set r(data) {
		this.x = data
	}
}

Object.getOwnPropertyDescriptor(obj, "r")   //查询对象obj中属性r的属性描述符

// 返回 {get: [Function: get r], set: [Function: set r], enumerable: true, configurable: true}

//创建一个对象
let obj = {
	x:1
}

//先用propertyIsEnumerable()来测试一下对象obj中的属性x是否还具有可枚举性
obj.propertyIsEnumerable("x")   //返回true，说明此时属性x是具有可枚举性的

//修改对象obj中属性x的属性特性
Object.defineProperty(obj, "x", {
	value: 2,                //属性x的值变为2
	writable: true,          //属性x具有可写性
	enumerable: false,       //属性x不具有可枚举性
	configurable: true       //属性x具有可配置性
})

//利用 propertyIsEnumerable()来测试一下对象obj中的属性x是否还具有可枚举性
obj.propertyIsEnumerable("x")      // 返回 false，说明对象obj中属性x已经不具有可枚举性了

//创建对象obj
let obj = {
	x:2
}

//给对象obj创建一个属性，并配置好该属性的特性
Object.defineProperty(obj, "r", {
	get: function() {return this.x + 1},      //给存储器属性r设定一个get函数
	set: function(data) {this.x *= data}, //给存储器属性r设定一个set函数
	enumerable: true,             //存储器属性r具有可枚举性
	configurable: true            //存储器属性r具有可配置性
})

//查询对象obj中的属性r
obj.r                // 返回 3

//给对象obj中的属性r赋值
obj.r = 3  

//查询对象obj中的属性x的值
obj.x        //返回  6        

let obj = {
	x:1
}

Object.defineProperties(obj, {
	x: {
		value: 3,
		writable: true,
		enumerable: true,
		configurable: true
	},
	y: {
		value: 10,
		writable: true,
		enumerable: true,
		configurable: true
	}
})

console.log(obj)

// 返回 {x:3, y:10}

let obj = Object.create({x:1})   //新建一个对象obj继承于 {x:1}

Object.getPrototypeOf(obj)       //返回  {x:1}

let obj1 = {x:1}
let obj2 = Object.create(obj1)

obj1.isPrototypeOf(obj2)         //返回true，因为obj2就是继承于obj1

Object.prototype.isPrototypeOf(obj2)  //返回true，因为Object.prototype在obj2的原型链上

//先将 Object.prototype.toString.call() 封装成一个函数，方便后面的代码简化
function classof(obj) {
	return Object.prototype.toString.call(obj)
}

classof(null)                         //[object Null]
classof(undefined)                    //[object Undefined]
classof(1)                            //[object Number]
classof("")                           //[object String]
classof(true)                         //[object Boolean]
classof({})                           //[object Object]
classof([])                           //[object Array]
classof(/\d+/)                        //[object RegExp]
classof(new Date())                   //[object Date]
classof(window)                       //[object window]
classof(document)                     //[object HTMLDocument]
function a() {}
classof(new a())                      //[object Object]
let b = {}
classof(b)                            //[object Object]
let c = Object.create(b)
classof(c)                            //[object Object]

let obj1 = {x:1}
let obj2 = Object.create(obj1)     //obj2继承于Obj1
obj2.z = 4                         //给obj2添加一个属性z，值为4
console.log(obj2)                  //打印  {z:4}
Object.preventExtensions(obj2)     //将obj2转换成不可扩展的
obj2.y = 2                         //尝试向obj2中添加新属性y
console.log(obj2.y)                  //  打印 undefined ，说明obj2是不可扩展的

obj1.y =  2
console.log(obj2.y)          // 打印 2 ，说明obj2虽然被转换成不可扩展的了，但是还是能从原型继承属性的

delete obj2.z                 //打印  {}，说明使用Object.preventExtensions()将对象转换成不可扩展后，虽然无法添加属性，但是可以删除属性

let obj1 = {x:1}
let obj2 = Object.create(obj1)     //obj2继承于Obj1
obj2.z = 4                         //给obj2添加一个属性z，值为4
console.log(obj2)                  //打印  {z:4}
Object.seal(obj2)                  //将obj2封闭

delete obj2.z                 //打印  {z:4}，说明使用Object.seal()将对象封闭后，既无法添加属性，也无法删除属性

obj2.z = 100                   //修改obj2中的属性z为100
console.log(obj2)              //打印  {z:100} ，说明已封闭的对象，还是可以对其属性进行修改的

let obj1 = {x:1}
let obj2 = Object.create(obj1)     //obj2继承于Obj1
obj2.z = 4                         //给obj2添加一个属性z，值为4
console.log(obj2)                  //打印  {z:4}
Object.freeze(obj2)                  //将obj2冻结

obj2.z = 100                   //修改obj2中的属性z为100
console.log(obj2)              //打印  {z:4} ，说明已冻结的对象，无法修改对象中的属性值