一、javascript高级基础

1. Object

• JavaScript 的所有其他对象都继承自Object对象，即那些对象都是Object的实例
• Object对象的原生方法分成两类：Object静态方法与Object的原型方法

Object的原型方法
constructor: ƒ Object()
hasOwnProperty: ƒ hasOwnProperty() //表示该实例对象自身是否具有该属性（不包含原型对象中的）
isPrototypeOf: ƒ isPrototypeOf()
propertyIsEnumerable: ƒ propertyIsEnumerable()
toLocaleString: ƒ toLocaleString()
toString: ƒ toString()
valueOf: ƒ valueOf()

constructor:
概念：constructor属性返回对创建此对象的数组函数的引用
语法：prototypeObj.constructor;//rototypeObj是一个原型对象
例子：Father.prototype.constructor===Father;//true
总结：constructor存在的意义就是标注一个对象的构造函数是哪个`

hasOwnProperty:
概念：判断一个属性是否是自身的属性
语法：obj.hasOwnProperty(str); //接受一个字符串作为参数，返回一个布尔值
例子：childOne.hasOwnProperty("age");//返回true

isPrototypeOf:
概念：当判断当前对象是否为另一个对象的原型is Proto(原型) typeOF:即原型检测
语法：prototypeObj.isPrototypeOf(obj);//prototypeObj是一个原型对象，obj是一个实例对象，返回一个布尔值
例子：Father.prototype.isPrototypeOf(childOne);//返回true

propertyIsEnumerable:
概念：判断某个属性是否可枚举(自定义的)
语法：obj.propertyIsEnumerable(str);//str:字符串，obj为实例对象。即obj对象中str属性是否可枚举，返回一个布尔值
例子：childOne.propertyIsEnumerable("age");//返回true
总结：只有该构造函数内部自定义的属性才会返回true.

toLocaleString
概念：返回当前对象对应的<mark>本地字符串形式</mark> 
语法：obj.toLocaleString([locales [, options]]);//locales:语音环境"en"/"zh"..，options:输出样式的配置项。返回指定格式字符串
例子：(new Date()).toLocaleString('zh');//2018-10-5 20:20:18
总结：可以针对不同语音环境输出本地字符串，还可以通过options修整

toString:
概念：将所有的的数据类型都转换为字符串，但是要排除null 和 undefined
语法：obj.toString();//返回转换后的字符串
例子：(123).toString();//"123"，注明:Number对象重构了这个方法。可以obj.toString([radix]) radix表示进制,可以是任何数字
总结：对象字符串操作时会默认调用这个方法,对比 String(value); //字符串的构造函数，全都可以转化成字符串

valueOf:
概念：我们没有重新定义valueOf和toString，其隐式转换会调用默认的toString()方法，将对象作为字符串返回
      如果重新定义了toString/valueOf方法，那么其转换会按照我们的定义来，其中valueOf比toString优先级更高
语法：obj.valueOf();//会调用该方法，返回对象的值，如果没有这个方法，则默认返回该对象
例子：let obj1={};obj1.valueOf=function(){return 20;};则let obj2=obj1+5;//为25
总结：对象数值操作时会默认调用这个方法

Object构造函数属性
arguments: (...)
length: 1
name: "Object"
[[Scopes]]: Scopes[0]
prototype: {constructor: ƒ, defineGetter: ƒ, defineSetter: ƒ, hasOwnProperty: ƒ,}
_ proto _:

arguments :
概念：arguments 是一个类似数组的对象, 对应于传递给函数的参数，是函数执行的生成的属性对象
语法：arguments[i]            //获得某个参数
     arguments[i]=3          //设置某个参数的值，可以用来设置默认值。<mark>从这里可以看出，其保存的不是参数的值，而是参数的引用</mark> 
     arguments.length        //返回实参个数，可以利用这个及结合参数类型实现函数重载 
     arguments.callee        //指向当前执行的函数，可用于递归调用自身函数。arguments.callee.name:当前函数名称 
     arguments.callee.caller //指向当前执行函数的外部函数，arguments.callee.caller.name:执行函数的外部函数名称

其它：arguments不是数组，而是类数组，如下函数可以转化成真正的数组
      Array.prototype.slice.call(arguments) 或 [].slice.call(arguments)
      Array.from(arguments) 
      [...arguments];        //展开运算符` 

类数组：
概念：有些对象，定义了length属性及值
例子：Fun.length;      //获得形参个数 
      arguments.length;//获得实参个数
      Str.length;      //获得字符串的长度(字符个数)
      Arr.length;      //获得数组的长度` 

name：
概念：返回,显式定义名称的变量的变量名

[[Scopes]]：
概念：作用域链，用于变量访问`

prototype：
概念：原型链，用于对象属性的访问

_ _proto_ _：
概念：原型对象

Object构造函数方法
arguments: (...)
assign: ƒ assign()
caller: (...)
create: ƒ create()
defineProperties: ƒ defineProperties()
defineProperty: ƒ defineProperty()
entries: ƒ entries()
freeze: ƒ freeze()
getOwnPropertyDescriptor: ƒ getOwnPropertyDescriptor()
getOwnPropertyDescriptors: ƒ getOwnPropertyDescriptors()
getOwnPropertyNames: ƒ getOwnPropertyNames()
getOwnPropertySymbols: ƒ getOwnPropertySymbols()
getPrototypeOf: ƒ getPrototypeOf()
is: ƒ is()
isExtensible: ƒ isExtensible()
isFrozen: ƒ isFrozen()
isSealed: ƒ isSealed()
keys: ƒ keys()
length: 1
name: "Object"
preventExtensions: ƒ preventExtensions()
prototype: {constructor: ƒ, defineGetter: ƒ, defineSetter: ƒ, hasOwnProperty: ƒ, lookupGetter: ƒ, …}
seal: ƒ seal()
setPrototypeOf: ƒ setPrototypeOf()
values: ƒ values()
proto: ƒ ()
[[Scopes]]: Scopes[0]

assign:
克隆(浅拷贝)增加到源对象中
概念：拷贝源对象自身的并且可枚举的属性到目标对象，浅拷贝(对于引用对象，拷贝的是引用)，并且同名会覆盖 
语法：Object.assign(target, ...sources);//target:目标对象，sources：源对象
例子：Object.assign(childOne,{x:14,y:15});//则为childOne增加了x:14属性，和y:15属性
用途：合并对象(或为对象增加方法、属性（也可以值覆盖，来设置默认值）)，克隆对象（浅）

create:
概念：创建一个具有指定原型且可选择性地包含指定属性的新的原型对象
语法：Object.create(prototypeObj, descriptors);//prototypeObj原型对象，可以为null。descriptors为描述对象，返回一个新的原型对象
例子：Object.create(Father.prototype,{constructor:{value:Child},getAge:{value:function(){return this.age}};

defineProperty :设置/获取属性描述符
概念：defineProperty 将一个属性添加到对象或修改一个现有属性的特性。define:规定，Property：特性
语法：Object.defineProperties(obj, descriptor)，//obj为对其添加或修改属性的对象,descriptor:为单个描述对象
例子：Object.defineProperties(childOne,{x:{value:14}};//为childOne添加了一个属性，及属性描述 
      Object.defineProperties(childOne,{x:{value:14,writable:false}};//为已有属性修改(增加)一个属性描述 

defineProperties:
概念：defineProperties 将一个或多个属性添加到对象或修改现有属性的特性
语法：Object.defineProperties(obj, descriptors);//，descriptors为描述对象
例子：Object.defineProperties(childOne,{x:{value:14},y{value:15};//为childOne添加了两个属性，这里描述符只设置了value

getOwnPropertyDescriptor:
概念：getOwnPropertyDescriptor 获取对象自身指定的属性描述符
语法：Object.getOwnPropertyDescriptor(obj, propertyname);//obj为要操作的对象，propertyname为属性的名称，返回属性描述符对象 
例子：Object.getOwnPropertyDescriptor(childOne,"age");//获取childOne的age属性的属性描述符
示例 返回值为：{ value: 20,  writable: true,  enumerable: true,  configurable: true } 

getOwnPropertyDescriptors :
概念：getOwnPropertyDescriptors 返回给定对象的所有属性描述符
语法：Object.getOwnPropertyDescriptors（obj);//返回属性描述符对象：{属性1描述符对象,属性2描述符对象} 
例子：Object.getOwnPropertyDescriptor(childOne);//获取childOne的所有属性的属性描述符
示例 返回值为：{ name: { value: '张三',writable: true,enumerable: true,configurable: true },
                age: { value: 20,writable: true,enumerable: true,configurable: true }} //篇幅原因，省略x,y部分的描述对象

属性类型描述符：value(值)、get(函数,获取)、set(函数,设置)、writable(布尔,能否修改值)
    enumeranle(布尔,能否枚举，即能否被for-in)、configurable(布尔,属性能否配置(及删除)，为false则其它特性也不能改变)

getOwnPropertyNames:获取属性名称
概念：返回对象自己的属性的名称
语法：Object.getOwnPropertyNames(obj);//返回，数组
例子：Object.getOwnPropertyNames(childOne);//返回 [ 'name', 'age', 'x', 'y' ] 
总结：对比Object.keys();这个方法还可以返还不可枚举属性 `

getOwnPropertySymbols:获取自有符号属性
概念：返回对象的自有符号属性。这里涉及到Symbol;
语法：Object.getOwnPropertySymbols(object);//返回，数组


setPrototypeOf:对象获取/设置原型
概念：setPrototypeOf 设置对象的原型
语法：Object.setPrototypeOf(obj, protoObj);//obj为要操作的对象，protoObj为原型对象
例子：let _x={x:10,y:function(){console.log(this.x)};     Object.setPrototypeOf(childOne,_x}
则：childOne原来指向Father.prototype,现在指向_x。原 <mark>原型对象的属性方法不能再访问到

getPrototypeOf:
概念：getPrototypeOf返回对象的原型
语法：Object.getPrototypeOf(obj);//返回，原型对象
例子：Object.getPrototypeOf(childOne);//返回的是Father的原型对象，即Father.prototype
总结：等价于childOne.__proto__=Father.prototype

entries:
概念：获取对象键值对的方法，返回一个对象自身可枚举属性的键值对数组
语法：Object.entries(obj);//返回，键值对数组
例子：Object.entries(childOne);//[ [ 'name', '张三' ], [ 'age', 20 ], [ 'x', 14 ], [ 'y', 15 ] ]

keys:
概念：返回对象的可枚举属性和方法的名称
语法：Object.keys(object);//返回，数组
例子：Object.keys(childOne);//返回，[ 'name', 'age', 'x', 'y' ]

values:
概念：返回给定对象自己的可枚举属性值的数组，其顺序与for...in循环提供的顺序相同(不同之处在于for-in循环也枚举了原型链中的属性)
语法：Object.values（obj）

is:
概念：确定两个值是否是相同的值
语法：Object.is(value1, value2);//返回，布尔值
例子：Object.is(null, null);    // true
总结：对比==，===相等运算

preventExtensions:扩展特性
概念：阻止向对象添加新属性。
语法：Object.preventExtensions(obj);
      Object.isExtensible(obj);//返回，布尔值

seal:密封特性
概念：阻止修改现有属性的特性，并阻止添加新属性。
语法：Object.seal(obj);
      Objecct.isSealed(obj);//返回，布尔值


freeze:冻结特性
概念：阻止修改现有属性的特性和值，并阻止添加新属性;
语法：Object.freeze(obj);
      Object.isFrozen(object);//返回，布尔值                                                                                                                       作用：a:使对象不可扩展，这样便无法向其添加新属性
      b:为对象的所有属性将 configurable 特性设置为 false,则无法更改属性的特性且无法删除属性
      c:为对象的所有数据属性将 writable 特性设置为 false,则无法更改数据属性值`</pre>

二、补充对象深拷贝

1.自定义方法

function deepcopy(obj){
    var newobj = {};
    for(arr in obj){
        if (typeof obj[arr]==='object' && obj[arr] !== null) {
            newobj[arr] = deepcopy(obj[arr]); //递归，核心代码
        } else {
            newobj[arr] = obj[arr];
        }
    }
    return newobj;
}

2.利用JSON

let obj=JSON.parse(JSON.stringify(源数据))
优点：代码简洁 
缺点：无法处理function，无法处理Reg，无法处理循环引用对象。如果源对象中没有这些，可以采用 

三、遍历

• 遍历自身、原型？
• 遍历可枚举、不可枚举？

---

• for(i in obj){} 特点：遍历（自身+原型）的可枚举属性

例子：for(i in child);//fx fy fz cy cz protoFy protoFz 。前四个是自身可枚举，后两个是原型可枚举属性
总结：可结合obj.hasOwnProperty(str)。即child.hasOwnProperty(i)来判断是不是自身属性

• 遍历自身属性

遍历自身所有属性
语法：Object.getOwnPropertyNames(obj);//遍历自身所有属性，包括不可枚举的 
例子：Object.getOwnPropertyNames(child);//[ 'fx', 'fy', 'fz', 'cx', 'cy', 'cz' ]。其中'cx'设置了不可枚举，也能遍历出来

遍历自身可枚举属性
Object.keys(obj);   //键     [ 'fx', 'fy', 'fz', 'cy', 'cz' ]
Object.values(obj); //值     [ 1, 2, 3, 5, 6 ]
Object.entries(obj);//键值对 [ [ 'fx', 1 ], [ 'fy', 2 ], [ 'fz', 3 ], [ 'cy', 5 ], [ 'cz', 6 ] ]