_.isEqual()

1 .判斷兩個(gè)值是否相等
2 .深度進(jìn)行判斷

_.isMatch()

1 .深度搜索是否有某個(gè)值

_.isOlainObject(value)

1 .檢查value是否是普通對象裙士，也就是該對象由Object 構(gòu)造函數(shù)創(chuàng)建害淤，或者[[Prototype]]為空
2 .

_.toPlainObject()

1 .轉(zhuǎn)換為普通對象，甚至對象繼承的可枚舉屬性也一并繼承
2 .

assign()

1 .對象合并跌榔，但是原生的方法是只會進(jìn)行淺復(fù)制凳怨，如果源對象的某個(gè)屬性的值是對象瑰艘，那么目標(biāo)拷貝的是這個(gè)對象的引用。
2 .只拷貝源對象自身的屬性猿棉，不拷貝繼承屬性磅叛，也不拷貝不可枚舉的屬性

let b1={
    'name':123
}

let o1={
    'name':b1
}

let o2={
    'age':20
}
cc(o1)
b1.name='asdfasd'
cc(Object.assign(o1,o2))

1 .可以發(fā)現(xiàn)，當(dāng)修改b1的時(shí)候萨赁，后面合并的的數(shù)組還是會發(fā)生變化，那這樣就很麻煩了兆龙。要不就是保證后面的數(shù)組在合并之后被凍結(jié)杖爽，不然永遠(yuǎn)不能保證這個(gè)數(shù)據(jù)是固定的
2 .自己寫一個(gè)合并的函數(shù)，是深度遍歷合并的
3 .在合并之前紫皇，合并的是克隆之后的函數(shù)慰安，這樣原來怎么改都不會影響到現(xiàn)在的數(shù)組了。

let b1={
    'name':123
}

let o1={
    'name':b1
}

let o2={
    'age':20
}
cc(o1)
let xx=Object.assign(o2,_.cloneDeep(o1))
cc(xx)
b1.name='asdfasd'
cc(o1)
cc(xx)

3 .拷貝繼承鏈 _.assignIn:類似于assign,但是會遍歷并繼承來源對象的屬性

function clone(origin){
    let originProto=Object.getPrototypeOf(origin)
    return Object.assign({},originProto, origin);
}

function assign(obj,arr){
    let re=Object.assign({},obj)
    for (let i of arr){
        Object.assign(re,clone(i))
    }
    cc(re)
    return re
}

assign({},[new f11,new foo])

4 ..assignWith():拷貝選項(xiàng)參數(shù)聪铺，在遍歷的時(shí)候先檢查屬性值化焕，如果屬性值不符合給定的約定函數(shù)，那么不進(jìn)行合并
5 ..at(object, [paths])

1 .如果是選object里面的數(shù)據(jù)的話铃剔，數(shù)組的參數(shù)是要要選的數(shù)據(jù)的路徑
var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };

c(_.at(object,['a[0].b.c'],'a[1]'))

let arr=['a','f','c']

c(_.at(arr,2))
2 .如果選的arr里面的數(shù)據(jù)的話撒桨，參數(shù)是數(shù)組內(nèi)的索引

create() :創(chuàng)建一個(gè)繼承對象的對象

1 .這個(gè)直接使用es6語法實(shí)現(xiàn)，非常簡單
2 .這個(gè)不能寫成調(diào)用函數(shù)键兜，應(yīng)該始終使用語法來實(shí)現(xiàn)凤类，因?yàn)閟uper的時(shí)候需要繼承上個(gè)對象的屬性，這個(gè)如果把要繼承的對象按照一個(gè)函數(shù)的參數(shù)傳進(jìn)去的話普气，是無法得到這個(gè)東西的
3 .子類必須在sonstructor中調(diào)用super方法谜疤。子類自己的this對象，必須先通過父類的構(gòu)造函數(shù)完成塑造现诀，得到與父類同樣的實(shí)例屬性和方法夷磕，然后對其進(jìn)行加工，加上子類自己的實(shí)例屬性和方法仔沿，如果不調(diào)用super方法坐桩，子類就得不到this對象
4 .ES5繼承方式：先創(chuàng)建子類的實(shí)例對象this，然后將父類的方法添加到this上面
5 .ES6繼承機(jī)制：先將父類實(shí)例對象的屬性和方法于未，添加到this上面撕攒，然后在根據(jù)子類的構(gòu)造函數(shù)修改this.

1 .所以可以繼承原生構(gòu)造函數(shù)定義子類陡鹃，可以繼承父類的所有行為
2 .es6可以自定義原生的數(shù)據(jù)結(jié)構(gòu)（Array,String）的子類
3 .extends關(guān)鍵字不僅可以繼承類，還可以繼承原生的構(gòu)造函數(shù)

6 .super

1 .super最為函數(shù)調(diào)用抖坪，代表父類的構(gòu)造函數(shù)萍鲸，用在子類繼承的時(shí)候。
class Shape{
    constructor(x,y){
        this.x=x
        this.y=y
    }
    p(){
        return '2'
    }
    p2(){
        return this.x
    }

}
class Circle extends Shape{
    constructor(x,y,color){
        super(x,y)
        // 調(diào)用父類的constructor(x,y),
        // super雖然代表的是父類的構(gòu)造函數(shù)擦俐，但是返回的是子類的實(shí)例脊阴，super內(nèi)部的this指的是當(dāng)前的子類
        this.color=color;

        // console.log(super.x)
        // 指向父類的原型對象，所以定義在父類實(shí)例上的方法或者屬性是無法通過super調(diào)用的--返回undefined

        // console.log(super.p2())
        // 可以通過這樣的拐彎來實(shí)現(xiàn)可以訪問蚯瞧。其實(shí)訪問的是Shape.prototype.p()
        // 也就是說上面的x屬性如果這樣定義的話嘿期，是可以獲取到的
    }
    tostring(){
        console.log(super.p2())
        // 在子類普通方法內(nèi)使用super，內(nèi)部的this指向當(dāng)前的子類實(shí)例
    }
}
const c1=new Circle(10,10,'red')
2 .super作為對象時(shí)埋合，在普通方法中备徐，指向父類的原型對象，在靜態(tài)方法中甚颂，指向父類
3 .由于this指向子類實(shí)例蜜猾，如果不用this,而是使用super對某個(gè)屬性賦值，這時(shí)super就是this,賦值的屬性會變成子類實(shí)例的屬性
4 .

7 .類的prototype屬性與proto屬性(表示繼承振诬，或者說誰給了他這個(gè)屬性)

1 .子類的__proto__屬性蹭睡，表示構(gòu)造函數(shù)的繼承，總是指向父類
2 .子類prototype屬性的__proto__屬性赶么，表示方法的繼承肩豁，總是指向父類的prototype屬性
3 .
class b extends Object{}
// 子類繼承Object類
cc(b.__proto__==Object)
cc(b.prototype.__proto__==Object.prototype)

class bb{}
// 子類什么都繼承，就是個(gè)普通函數(shù)

cc(bb.__proto__==Function.prototype)
// 此時(shí)子類就是一個(gè)普通函數(shù)辫呻，所以直接繼承自Function.prototype
cc(bb.prototype.__proto__==Object.prototype)
// bb調(diào)用之后返回一個(gè)空對象清钥，所以指向構(gòu)造函數(shù)Object的prototype屬性

4 .實(shí)例的proto屬性:唯一作用，可以通過子類實(shí)例來修改父類實(shí)例的行為

class a{
    constructor(x){
        this.x=x
    }
}
class aa extends a{
    constructor(x){
        super(x)
    }
}

const a1=new a('10')
const a2=new aa()
cc(a2.__proto__.__proto__==a1.__proto__)
cc(a2.__proto__)
//aa{}
cc(a2.__proto__.__proto__)
// a{}
a2.__proto__.__proto__.say=function(){
    console.log('sasasa')
}
a2.say()
a1.say()

.defaults(object, [sources]),.defaultsDeep(object, [sources])

1 .分配來源對象的可枚舉屬性到目標(biāo)對象所有解析為 undefined 的屬性上印屁。 來源對象從左到右應(yīng)用循捺。 一旦設(shè)置了相同屬性的值，后續(xù)的將被忽略掉雄人。
2 .Object.assign()方法不能實(shí)現(xiàn)的東西

1 .對于object.assign來說从橘，如果第一個(gè)參數(shù)不是對象的話，則會先轉(zhuǎn)會對象
2 .對于非首參數(shù)出現(xiàn)非對象础钠，如果不能轉(zhuǎn)換為對象恰力，都是會跳過的。
3 .拷貝得屬性是有限制得旗吁，只能拷貝源對象的自身屬性踩萎，不拷貝不可枚舉的屬性enumerable:false
4 .淺拷貝：如果源對象某個(gè)屬性的值是對象，那么目標(biāo)對象拷貝的是這個(gè)對象的引用.lodash 的defaultsDeep實(shí)現(xiàn)了這個(gè)操作很钓，可以合并拷貝新的對象香府。
5 .同名屬性的替換：嵌套的對象董栽，遇到同名屬性，是替換企孩，而不是添加

const target = { a: { b: 'c', d: 'e' } }
const source = { a: { b: 'hello' } }

let o2=_.defaultsDeep({},target,source)
cc(o2)
//{ a: { b: 'c', d: 'e' } }
//注意在嵌套數(shù)組的合并中锭碳，也是按照外面的策略，如果原來有的話勿璃，就不再添加后面的了擒抛。
//解決的是object.assign方法整個(gè)替換a后面的情況

6 .取值函數(shù)的處理：只能進(jìn)行值的復(fù)制，如果要復(fù)制的是一個(gè)取值函數(shù)补疑，那么求值之后進(jìn)行復(fù)制
7 .

findKey()

1 .按照value的屬性來進(jìn)行條件選擇歧沪，返回整個(gè)key-vallue鍵值對

.forIn(object, [iteratee=.identity]):遍歷對象的自身和繼承的可枚舉屬性

1 .也是無法保證遍歷的順序

_.forOwn:遍歷自身的可枚舉屬性

1 .也是無法保證遍歷順序

_.functions:返回一個(gè)function對象自身可枚舉屬性名的數(shù)組

_.functionsIn:返回一個(gè)function對象和繼承的可枚舉屬性名的數(shù)組

_.get(object, path, [defaultValue]):根據(jù)對象路徑獲取值。如果解析value是undefined會以defaultValue取代

_.has(object,path):檢查path是否是對象的直接屬性

1 .返回對象的所有屬性莲组，然后進(jìn)行數(shù)組的檢查
2 .直接使用in 語法

_.invert(obj):反轉(zhuǎn)對象的key和value

1 ..invertBy(obj,fn):傳入兩個(gè)參數(shù)诊胞，反轉(zhuǎn)對象的key和value，并且在反轉(zhuǎn)的時(shí)候?qū)ey進(jìn)行處理
2 ..invertByAll(obj,fn1,fn2):傳入3隔參數(shù)锹杈，反轉(zhuǎn)對象的key和val厢钧，并且在反轉(zhuǎn)的時(shí)候同時(shí)對key，value進(jìn)行處理

let obj={
    'name':'libater',
    'age':20
}
cc(_.invert(obj))
cc(_.invertBy(obj,(k)=>{
    return 'change'+k
}))

一些按照路徑選擇key,value的函數(shù)

1 ._.invoke(object, path, [args])
2 .

_.keys()

1 .創(chuàng)建object自身可枚舉屬性名為一個(gè)數(shù)組（非對象的值會被強(qiáng)制轉(zhuǎn)換為對象）
2 ..keysIn()創(chuàng)建object自身或繼承的可枚舉屬性名為一個(gè)數(shù)組
3 ..mapKeys()這個(gè)方法創(chuàng)建一個(gè)對象嬉橙，對象的值與源對象相同，但 key 是通過 iteratee 產(chǎn)生的寥假。
4 ..mapValues()創(chuàng)建一個(gè)對象市框，對象的key相同，值是通過 iteratee 產(chǎn)生的糕韧。 iteratee 會傳入3個(gè)參數(shù)： (value, key, object)
5 ..values()
6 ._.valuesIn()

_.merge()

1 .遞歸合并來源對象的自身和繼承的可枚舉屬性到目標(biāo)對象枫振，跳過來源解析為undefined的屬性，數(shù)組和普通對象會遞歸合并萤彩，其他對象和值會被直接分配粪滤。來元對象從左到右分配，后續(xù)的來源對象屬性會覆蓋之前分配的屬性
2 ..mergewith(object, sources, customizer):類似于merge雀扶，但是接收一個(gè)參數(shù)決定如何合并杖小，如果customizer返回undefined將會由合并處理方法代替
3 ..

_.omit(object, [props])

1 .返回忽略屬性之外的自身和繼承的可枚舉屬性。就是刪去括號里面的屬性
2 .這個(gè)方法其實(shí)很弱智啊愚墓。自己寫的話很簡單啊
3 ..omitBy(object, [predicate=.identity])進(jìn)過predicate判斷是不是真值的屬性和自身和繼承的可枚舉屬性
4 ._.

_.pick(object, [props])

1 .從一個(gè)對象選出選中屬性的對象
3 .pickBy(object, [predicate=.identity]):類似上面的東西

_.result(object, path, [defaultValue])

1 .除了如果解析得到的值是一個(gè)函數(shù)的話予权，就綁定this到這個(gè)函數(shù)并返回執(zhí)行后的結(jié)果。
2 .

_.set(object, path, value)

1 .設(shè)置值到對象對應(yīng)的屬性路徑上浪册，如果沒有則創(chuàng)建這部分路徑扫腺。 缺少的索引屬性會創(chuàng)建為數(shù)組，而缺少的屬性會創(chuàng)建為對象
2 ._.unset(obj,path):移除對象路徑的屬性

_.toPairs(obj)

1 .創(chuàng)建一個(gè)對象自身可枚舉屬性的鍵值對數(shù)組
2 ._.toPaireIn():創(chuàng)建一個(gè)對象自身和繼承的可枚舉屬性的鍵值對數(shù)組

_.to