今日手写

2021-11-18

的几种高级方法

js原生方法的实现

今天来实现实现.. (～￣▽￣)～

一口气写完了哈哈哈

1 2	// 测试数组 var ages = [1, 3, 56, 20, 32, 10, 1, 2, 20, 1, 20]

数组:

//map函数
        Array.prototype.wy_map = function (callback) {
            let newarr = []
            for (let i = 0; i < this.length; i++) {
                // let res = callback(this[i], i, this)
                // newarr.push(res)
                newarr.push(callback(this[i], i, this))
            }
            return newarr
        }
        let res = ages.wy_map((item, index, arr) => {
            return {
                count: item
            }
        })
        console.log(res);

filter

Array.prototype.wy_filter = function (callback) {
            let res = []
            for (let i = 0; i < this.length; i++) {
                callback(this[i], i, this) && res.push(this[i])
            }
            return res
        }

        let res = ages.wy_filter((item, index, arr) => {
            return item > 30
        })
        console.log(res);

every

//every函数
        Array.prototype.wy_every = function (callback) {
            let flag = true
            for (let i = 0; i < this.length; i++) {
                flag = callback(this[i], i, this)
                if (!flag) break
            }

            return flag
        }

        let res = ages.wy_every((item, index, arr) => {
            return item > -10
        })

        console.log(res);

some

Array.prototype.wy_some = function (callback) {
            let flag = false
            for(let i = 0; i < this.length; i++) {
                flag = callback(this[i], i, this)
                if(flag) return true
            }
            return false
        }
        let res = ages.wy_some((item, index, arr) => {
            return item > 10
        })
        console.log(res);

reduce

Array.prototype.wy_reduce = function (callback, initvalue) {
            let pre, start = 0;
            if (!initvalue) {
                pre = this[0]
                start = 1
            } else {
                pre = initvalue
            }
            for (let i = start; i < this.length; i++) {
                pre = callback(pre, this[i], i, this)
            }
            return pre
        }

        let res = ages.wy_reduce((pre, current, index, arr) => {
            return pre + current
        }, 0)
        console.log(res);

findIndex

Array.prototype.wy_findIndex = function (callback) {
           for (let i = 0; i < this.length; i++) {
               if (callback(this[i], i, this)) {
                   return i
               }
           }
           return -1
       }

       let index = ages.wy_findIndex((item, index, arr) => {
           return item === 1
       })
       console.log(index);

find

Array.prototype.wy_find = function (callback) {
           for (let i = 0; i < this.length; i++) {
               if (callback(this[i], i, this)) {
                   return this[i]
               }
           }
       }

       let res = ages.wy_find((item, index, arr) => {
           return item === 989898
       })
       console.log(res);

fill

arr = new Array(8)
       Array.prototype.wy_fill = function (value, start = 0, end) {
           end = end || this.length
           for (let i = start; i < end; i++) {
               this[i] = value
           }
           return this
       }
       let res = arr.wy_fill(10,7,9)
       console.log(res);

includes

Array.prototype.wy_includes = function (value, start = 0) {
           if (start < 0) start = this.length + start
           const isNaN = Number.isNaN(value)
           for (let i = start; i < this.length; i++) {
               if (this[i] === value || Number.isNaN(this[i]) === isNaN) {
                   return true
               }
           } return false
       }
       console.log(ages.wy_includes(20));

jion

Array.prototype.wy_join = function (s = ',') {
            let str = ''
            for (let i = 0; i < this.length; i++) {
                str = i === 0 ? `${str}${this[i]}` : `${str}${s}${this[i]}`
            }
            return str
        }
        console.log(ages.wy_join());

flat

Array.prototype.wy_flat = function () {
           let arr = this
           while (arr.some(item => Array.isArray(item))) {
               arr = [].concat(...arr)
           }
           return arr
       }

       console.log(ages.wy_flat())

对象:

遍历

//遍历对象  for in方法  缺陷 会把原型上的属性都遍历出来
       for(const key in obj) {
           console.log(obj[key]);
       }

entries

Object.prototype.wy_entries = function (obj) {
            const res = []
            for (let key in obj) {
                // 这里为什么使用Object.hasOwnProperty呢 因为 for in会遍历对象原型上的属性, 用obj.hasOwnproperty来判断是否是原型属性
                obj.hasOwnProperty(key) && res.push([key, obj[key]])
            }
            return res
        };
        console.log(Object.wy_entries(obj));

fromEntries

Object.prototype.wy_formEntries = function (arr) {
            const obj = {}
            arr.forEach((item, index) => {
                const [key, value] = item
                obj[key] = value
            })
            return obj
        }
        console.log(Object.wy_formEntries([['name', 'wuyupei'], ['age', 20]]));

keys

Object.prototype.wy_keys = function(obj) {
            const keys = []
            for(let key in obj) {
                obj.hasOwnProperty(key) && keys.push(key)
            }
            return keys
        }
        console.log(Object.wy_keys(obj));

values

Object.prototype.wy_values = function (obj) {
           let values = []
           for(let key in obj) {
               obj.hasOwnProperty(key) && values.push(obj[key])
           }
           return values
       }
       console.log(Object.wy_values(obj));

instanceOf

//instanceOf方法  原理  instanceOf是根据原型链来判断的 看child的原型链上是否有father
       //例如 var obj = new Object()   obj.__proto__ === Object.prototype
       function wy_instanceOf(child, father) {
           const fp = father.prototype
           let cp = child.__proto__
           while(cp) {
               if(fp === cp) {
                   return true
               }
               cp = cp.__proto__
           }
           return false
       }
       console.log(wy_instanceOf(obj, Object));

Object.prototype.wy_is = function (x, y) {
           if (x === y) {
               // 防止 -0 和 +0
               return x !== 0 || 1 / x === 1 / y
           }

           // 防止NaN
           return x !== x && y !== y
       }
       let person = { name: "wuyupei" }
       let student = person
       console.log(Object.wy_is(NaN, NaN));

assign

Object.prototype.wy_assign = function (target, ...args) {
           if (target === null || target === undefined) {
               throw new TypeError('Cannot convert undefined or null to object')
           }
           target = Object(target)
           for(let nextobj of args) {
               for(let key in nextobj) {
                   nextobj.hasOwnProperty(key) && (target[key] = nextobj[key])
               }
           }

           return target
       }

       const obj1 = { name: "wuyupei", age: 20 }
       const obj2 = { name: "zhangsan", friend: ['a', 'b'] }
       console.log(Object.wy_assign(obj1, obj2));

funtion:(之前已经实现过)

call
bind
apply