fedono / fe-questions Goto Github PK

const createNew = function (x, y) {
    let result = Array.isArray(y) ? [] : {};

    const create = function (x, y, obj) {
        // 如果所有子的对象都相等的话，就直接把 x 的值放到 obj 中去
        // 而不是 obj[key] = y[key];

        // 如果引用类型里面比对的都对，就不将 obj 返回了，直接返回 x，这样才能比对成功，所以增加了一个 allEqual 的变量
        let allEqual = true;
        for (let key in y) {
            // 相等的时候，是不看两个是基础类型还是引用类型的，只是在不相等的时候，才进行比较
            // 目的比对的，就是引用类型里面所有基础的数据类型是一致的，那么就先赋给 obj，如果后续有数据不对，就将 obj 进行返回
            if (x[key] === y[key]) {
                obj[key] = y[key];
            }
            else if (typeof y[key] === 'object' && y[key] !== null) {
                // 所有的重点，都是在这个分支的
                if (typeof x[key] === 'object' && x[key] !== null) {
                    // 这里 x[key] / y[key] 都是对象，所以需要看下是否都是 Array
                    if (Array.isArray(x[key]) && Array.isArray(y[key])) {
                        let newObj = Array.isArray(y[key]) ? [] : {};
                        let temp = create(x[key], y[key], newObj);
                        if (temp === x[key]) {
                            obj[key] = x[key];
                        }
                        else {
                            obj[key] = temp;
                            allEqual = false;
                        }
                    }
                    // 两个中如果有一个是数组，那么两个数据就不相等，就直接赋值给 obj 好了
                    else if (Array.isArray(y[key]) || Array.isArray(x[key])) {
                        // 既然类型不同，就直接放到给 obj 好了，不用比较了
                        obj[key] = y[key];
                        allEqual = false;
                    }
                    // 这两个都是 Object，再进行递归的比较一次
                    else {
                        let newObj = Array.isArray(y[key]) ? [] : {};
                        let temp = create(x[key], y[key], newObj);
                        if (temp === x[key]) {
                            obj[key] = x[key];
                        }
                        else {
                            obj[key] = temp;
                            allEqual = false;
                        }
                    }
                }
                else {
                    obj[key] = y[key];
                    allEqual = false;
                }
            }
            else {
                obj[key] = y[key];
                allEqual = false;
            }
        }

        // 如果全部都相等的话，就直接将 x 给 obj，也就是引用对象，也是直接给 obj 的，这样才是直接给引用地址的
        if (allEqual) {
            return x;
        }
        return obj;
    }

    create(x, y, result);
    return result;
}


// 测试
const x = {
    a: 1,
    b: 2,
    c: {
        name: 'jack',
        age: 213,
        j: {
            address: 'heibei'
        }
    },
    d: {
        name: 'json',
        age: 32
    }
}

const y = {
    a: 1,
    b: 2,
    c: {
        name: 'jack',
        age: 13,
        j: {
            address: 'heibei'
        }
    },
    d: {
        name: 'json',
        age: 31
    }
}

let res = createNew(x, y);
console.log(res)
console.log(res.c == x.c);  
console.log(res.c.j == x.c.j);  
console.log(res.d == y.d);

var a = function () {
    this.b = 3;
}

var c = new a();
a.prototype.b = 9;
var b = 7;
a();

console.log(b);  
console.log(c.b);

function instance_of(obj, cons) { 
 // 错误判断 构造函数必须是一个function 其他的均报错
  if (typeof cons !== 'function') throw new Error('instance error')
  if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) return false
  // 获取到原型对象
  let proto = cons.prototype
  // 如果obj的原型对象不是null
  while (obj.__proto__) {
    if (obj.__proto__ === proto) return true
    obj = obj.__proto__
  }
  return false
}

// 测试
console.log(instance_of(() => {}, Function)) // true

var str = 'hello world'
str instanceof String // false

var str1 = new String('hello world')
str1 instanceof String // true

class PrimitiveString {
  static [Symbol.hasInstance](x) {
    return typeof x === 'string'
  }
}
console.log('hello world' instanceof PrimitiveString) // true

/**
 * @param {object} obj
 * @param {object} target
 * @return {boolean}
 */
 function myInstanceOf(obj, target) {
  // If the object does not exist or we've reached the base Object constructor, return false
  if(!obj || typeof obj !== 'object') return false

  ​// Check if the target is a valid object
  ​if(!target.prototype) throw Error

  ​// If the object's prototype matches our target's prototype, return true
  ​// Otherwise, recurse down the prototypal chain
  ​if(Object.getPrototypeOf(obj) === target.prototype) {
    ​return true
  ​} else {
    ​return myInstanceOf(Object.getPrototypeOf(obj), target)
  ​}
}

/**
 * @param {Function} func
 * @param {(args: any[], newArgs: any[]) => boolean} [isEqual]
 * @returns {any}
 */

const defaultIsEqual = (args1, args2) => {
  return JSON.stringify(args1) === JSON.stringify(args2)
}

function memoizeOne(func, isEqual = defaultIsEqual) {
  let cache = {
  }

  return function(...args) {
    if (this === cache.self && isEqual(args, cache.args)) {
      return cache.value
    }

    cache.args = args
    cache.self = this
    cache.value = func.apply(this, args)

    return cache.value
  }
}

const debounce = (fn, delay) => {
  let timer = null;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => {
      fn.apply(this, args);
    }, delay)
  }
}

// 定时器实现
const throttle = (fn, delay = 500) => {
    let flag = true;
    return (...args) => {
        if (!flag) return;
        flag = false;
        setTimeout(() => {
            fn.apply(this, args);
            flag = true;
        }, delay);
    };
}

// 时间戳实现
const throttle = (fn, delay = 500) => {
    let preTime = Date.now();
    return (...args) => {
        const nowTime = Date.now();
        if (nowTime - preTime >= delay) {
            preTime = Date.now();
            fn.apply(this, args);
        }
    }
}
      

/*
* 1. class 的使用，new 对象
* 2. this 指向
* 3. apply, call 的运用
* 4. Object.defineProperty 的应用
* 5. 代码的设计能力
* 6. hook 的理解
* */

/*
* 总体的逻辑
* 1. 重写原生的 XMLHttpRequest 方法
* 2. 获取到原生的方法和属性进行劫持
* 3. 在原生的方法中增加 beforeHooks 和 afterHooks
* 4. 使用 Object.defineProperty 重写属性
* */
class XhrHook {
    constructor(beforeHooks = {}, afterHooks = {}) {
        this.XHR = window.XMLHttpRequest;
        this.beforeHooks = beforeHooks;
        this.afterHooks = afterHooks;
        this.init();
    }

    init() {
        let _this = this;
        // 这里使用 function 而不是使用箭头函数，是因为每次使用 XMLHttpRequest 都是使用 new
        // 使用箭头函数会改变 this 指向
        window.XMLHttpRequest = function() {
            this._xhr = new _this.XHR();
            _this.overwrite(this);
        }
    }

    overwrite(proxyXHR) {
        for (let key in proxyXHR._xhr) {
            if (typeof proxyXHR._xhr[key] === 'function') {
                this.overwriteMethod(key, proxyXHR);
                continue;
            }

            this.overwriteAttributes(key, proxyXHR);
        }
    }

    overwriteMethod(key, proxyXHR) {
        let beforeHooks = this.beforeHooks;
        let afterHooks = this.afterHooks;

        proxyXHR[key] = (...args) => {
            // beforeHooks 拦截如果返回 false，那么就不会执行原有的函数了
            if (beforeHooks[key]) {
                const res = beforeHooks[key].call(proxyXHR, args);
                if (res === false) {
                    return;
                }
            }

            const res = proxyXHR._xhr[key].apply(proxyXHR._xhr, args);
            // afterHooks 中需要把原生的函数执行的结果传进来
            afterHooks[key] && afterHooks[key].call(proxyXHR._xhr, res);

            return res;
        }
    }

    overwriteAttributes(key, proxyXHR) {
        Object.defineProperty(proxyXHR, key, this.setPropertyDescriptor(key, proxyXHR));
    }

    setPropertyDescriptor(key, proxyXHR) {
        let obj = Object.create(null);
        let _this = this;

        obj.set = function(val) {
            // 不是 onreadystatechange/onload 这种属性，而是函数
            if (!key.startsWith('on')) {
                proxyXHR['__' + key] = val;
                return;
            }

            if (_this.beforeHooks[key]) {
                this._xhr[key] = function (...args) {
                    _this.beforeHooks[key].call(proxyXHR);
                    val.apply(proxyXHR, args);
                }
                return;
            }

            this._xhr[key] = val;
        }

        obj.get = function() {
            return proxyXHR['__' + key] || this._xhr[key];
        }

        return obj;
    }
}

let data = {
    name: 'king'
}

observe(data);
data.name = 'dmp';
console.log(data.name, '--- get')

function observe(data) {
    if (!data || typeof data !== 'object') {
        return;
    }

    Object.keys(data).forEach(function(key) {
        defineReactive(data, key, data[key]);
    });
}

function defineReactive(data, key, val) {
    observe(val);
    Object.defineProperty(data, key, {
        enumerable: true,
        configurable: true,
        get: function () {
            console.log('获取值');
            // 注意这里不是 data[key]，因为如果是data[key]就会造成死循环了，会一直触发 get 函数
            // 所以在 observe 函数中调用 defineReactive 时会事先取出来
            return val;
        },
        set: function (newVal) {
            console.log('监听到值的变化', val, newVal);
            // 这里有一点不明白的是，val 是一个值，为什么可以设置 val = newVal，但是这里不是 return newVal
            val = newVal;
        }
    })
}

add(1)(2)(3)；  // 6
add(1)(2, 3);   // 6
add(1, 2)(3);   // 6
add(1, 2, 3);   // 6

const curry = fn => {
    const len = fn.length;
    return function curried(...args) {
        if (args.length === len) {
            return fn.apply(null, args);
        }
        return (..._args) => {
            return curried.apply(null, [...args, ..._args]);
        };
    };
};

const sum = (x, y, z) => x + y + z;
const add = curry(sum);

// 6
add(1, 2, 3);

// 6
add(1,2)(3);

// 6
add(1)(2,3);

// 6
add(1)(2)(3);

let items = [
    {
        name: 'item1'
    },
    {
        name: 'item2'
    }
];

const s = {};
s.items = items;

function ParseDom(str) {
    const mid = document.createElement('div');
    mid.innerHTML = str;
    const {children} = mid;
    let res = '';

    [...children].forEach(child => {
        const attrs = [...child.attributes];
        const targetAttr = attrs.find(x => x.name === 'ali-for');
        const nodeName = child.nodeName.toLocaleLowerCase();

        // 所以非 ali-for="item in items" 的属性累加
        const attrsStr = attrs.reduce((r, c) => {
            if (child.name !== 'ali-for') {
                r += ` ${c.name}="${c.value}"`
            }
            return r;
        }, '');

        if (!targetAttr) {
            res += `<${nodeName}${attrsStr}>${child.innerHTML}</${nodeName}>`;
        }

        const vfor = targetAttr.nodeValue; // 拿到 ali-for="item in items" 中的 "item in items"
        const o = vfor.split(' in ')[1]; // 拿到 ali-for="item in items" 中的 items
        const k = child.innerText.match(/\{\{(.*)\}\}/)[1].split('.')[1]; // 拿到{{item.name}} 中的 item.name
        s[o].forEach(x => {
            res += `<${nodeName}${attrsStr}>${x[k]}</${nodeName}>`; // 把 {{item.name}} 替换成 item.name 的值
        });
    })
    return res;
}


const str = '<div ali-for="item in items">{{item.name}}</div>';
let result = ParseDom(str);
console.log(result);

const input = [[[[1],2],3],4],5]

const res = flat(input)  // [[[[1],2],3],4,5]
const res = flat(input, 2) // [[[1],2],3,4,5]

function flat(array, num = 1) {
    let arr = array.concat()
    while (num) {
        // arr = arr.reduce 是最重要的地方，将之前的结果给下一次的循环
        arr = arr.reduce((prev, cur) => {
            if (Array.isArray(cur)) {
                prev.push(... cur)
            } else {
                prev.push(cur)
            }

            return prev;
        }, [])

        Num--;
    }

    return arr
}

const res = flat(input, 2)
console.log(JSON.stringify(res));

let money = 1003450.89;
// $1 匹配到 (\d)，也就是上面金额中的 1 和 3
// 也就是匹配到了小数点前面的多个三个数字然后加上英文逗号，
// 正向预查，即?=n（匹配任何其后紧接指定字符串 n 的字符串）
let result = money.toFixed(2).replace(/(\d)(?=(\d{3})+\.)/g, '$1,')

// 第二种方法
let str = "100000000000",
    // \B是表示匹配非单词边界的元字符，与其互为补集的元字符是\b，表示匹配单词边界。
    //   
    reg = /(?=(\B\d{3})+$)/g;
let res = str.replace(reg, ",");

var str = "10000000000",
    reg = /(?=(\d{3})+$)/g;
console.log(str.match(reg)); // 这里会得到 三个""，这里没有明白为什么会是三个""，是因为`?=`不会匹配到结果中

money.replace(/(\d)(?=(\d{3})+)/g, '$1,') 

foo(); // 1
var foo;
function foo() { 
    console.log( 1 );
}
foo = function() { 
    console.log( 2 );
};

foo();   // 这里会出现什么 
var a = true;
if (a) {
    function foo() { console.log("a"); } }
else {
    function foo() { console.log("b"); }
}

foo(); // 不是 ReferenceError, 而是 TypeError!
var foo = function bar() { // ...
};

foo(); // TypeError
bar(); // ReferenceError
var foo = function bar() { // ...
};

var foo;
foo(); // TypeError
bar(); // ReferenceError
foo = function() {
    var bar = ...self... // ...
}

function foo() { 
    console.log( a ); // 2
}
function bar() { 
    var a = 3;
    foo(); 
}
var a = 2; 
bar();

function foo() {
    console.log( a ); // 3(不是 2 !)
}
function bar() { 
    var a = 3;
    foo(); 
}
var a = 2; 
bar();

/**
 * @param {string} str
 * @return {string}
 */
function compress(str) {
  const res = [];
  let count = 0;
  
  for (let i = 0; i < str.length; i++) {
    count++;
    if (str[i] !== str[i+1]) {
      res.push(str[i]);
      if (count > 1) res.push(count); 
      count = 0;
    }
  }
  return res.join('');
}

let bb = {
    i: 10,
    toString: function() {
        console.log('toString');
        return 20;
    },
    valueOf: function() {
        console.log('valueOf');
        return 30;
    }
}

let cc = {
    i: 10
};

console.log(bb);
console.log(+bb);
console.log(''+bb);

console.log(cc);
console.log(+cc);
console.log(''+cc);

console.log(cc); // { i: 10 }
console.log(+cc); //  NaN
console.log(''+cc); //  [object Object]

console.log(bb); 
// 输出
{ i: 10,
  toString: [Function: toString],
  valueOf: [Function: valueOf] }

console.log(+bb); // 30 valueOf
console.log(''+bb); // 30 valueOf

let bb = {
    i: 10,
    toString: function() {
        console.log('toString');
        return 20;
    }
}
console.log(+bb);  
console.log(''+bb);  

console.log(+bb);  // 20 toString
console.log(''+bb);   // 20 toString

/* --- 1 --- */
let a = {};
let b = '123';
let c = 123;

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

console.log(a[b]);
console.log(Object.keys(a))

/* --- 2 --- */
let a = {};
let b = Symbol('123');
let c = Symbol('123');

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

console.log(a[b]);
console.log(Object.keys(a))

/* --- 3 --- */
let a = {};
let b = {key: '123'};
let c = {key: '456'};

a[b] = 'b';
a[c] = 'c';
console.log(a[b]);

Array.prototype.myReduce = function (callback, initialValue) {
    const argsLength = arguments.length
  
    if (argsLength === 1 && this.length === 0) {
      throw new Error()
    }
    
    let index = argsLength === 1 ? 1 : 0
    let resultValue = argsLength === 1 ? this[0] : initialValue
  
    for (let i = index; i < this.length; i += 1) {
      resultValue = callback(resultValue, this[i], i, this)
    }
  
    return resultValue
  }

function promiseAll(promises) {
    return new Promise(function(resolve, reject) {
        if (!Array.isArray(promises)) {
            throw new TypeError('argument must be a array');
        }

        let resolvedCounter = 0;
        let promiseNum = promises.length;
        let resolvedResult = [];

        for (let i = 0; i < promiseNum; i++) {
            Promise.resolve(promises[i]).then(value => {
                resolvedCounter++;
                resolvedResult[i] = value;
                if (resolvedCounter === promiseNum) {
                    return resolve(resolvedResult);
                }
            }, error => {
                return reject(error);
            })
        }
    })
}

let p1 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve(1)
    }, 1000)
});

let p2 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve(2)
    }, 1000)
});

let p3 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve(3)
    }, 1000)
});

promiseAll([p3, p1, p2]).then(res => {
    console.log(res)
})

const add = function (a, b) {
    // 从a/b的 length - 1开始，也就是从最后一位开始
    let i = a.length - 1; 
    let j = b.length - 1;

    let carry = 0;
    let ret = '';
    while (i >= 0 || j >= 0) {
        let x = 0;
        let y = 0;
        let sum;

        if (i >= 0) {
            x = a[i] - '0';  // 使用 - '0' 来让当前的数转换为整数
            i --;
        }

        if (j >= 0) {
            y = b[j] - '0';
            j --;
        }

        sum = x + y + carry;

        //  每次相加如果大于10，只取个位数，然后下一次的计算的结果加上1 就可以了
        if (sum >= 10) {
            carry = 1;
            sum -= 10;
        } else {
            carry = 0;
        }
        // 0 + ''
        ret = sum + ret;
    }

    // 为什么不在 while 里，因为在while里，carry 每次都是在下一次计算，那么在 while 计算后，还需要看看是否需要进位
    if (carry) {
        ret = carry + ret;
    }

    return ret;
}

// add('999', '1');
// add('1', '999');
// add('123', '321');
// console.log(add('999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999', '1'));

// 延迟一秒输出1,然后2延迟3秒输出3,然后4
const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const log = console.log

createFlow([
    () => delay(1000).then(()=>log(1)),
    () => log(2),
    () => delay(3000).then(()=>log(3)),
    () => log(4),
])

function createFlow(fns) {
    fns.reduce(
        (previous, fn) => previous.then(() => fn()),
        Promise.resolve()
    );
}

const curry = fn => {
    const len = fn.length;
    return function curried(...args) {
        if (args.length === len) {
            return fn.apply(null, args);
        }
        return (..._args) => {
            return curried.apply(null, [...args, ..._args]);
        };
    };
};

const sum = (x, y, z) => x + y + z;
const add = curry(sum);

// 6
add(1, 2, 3);

// 6
add(1,2)(3);

// 6
add(1)(2,3);

// 6
add(1)(2)(3);

const indexOf = function(str, searchStr, fromIndex = 0) {
    let regex = new RegExp(`${searchStr}`, 'ig');
    regex.lastIndex = fromIndex;
    // 没有匹配到的时候，会返回 null
    let result = regex.exec(str);
    return result ? result.index : -1;
}

const indexOf = function(input, search, fromIndex = 0) {
    if (!Array.isArray(input)) {
        input = input.split('');
    }

    for (let i = fromIndex, len = input.length; i < len; i++) {
        if (input[i] === search) {
            return i;
        }
    }

    return -1;
}

/**
 * @param {any} proto
 * @return {object}
 */
function myObjectCreate(proto) {
  function Constructor() {}
  Constructor.prototype = proto.prototype || proto

  return new Constructor();
}

function generateRGB() {
    return '#' + Array.from({length: 6}).map(() => {
        // 要知道Number 的 toString 的方法，才会转换进制，如果是 String(14).toString(16)，输出的还是14，
        return Math.ceil(Math.random() * 16).toString(16);
        // 再补充一个知识点，parseInt(xx, 16) 是十六进制转换成十进制，不是转换成十六进制
        // MDN文档说明：返回值是以第一个参数作为指定基数 radix 的转换后的十进制整数
    }).join('');
}

let result = generateRGB();
console.log(result);

function sendRequest(urls: sring[],max:number,callback:()=>void){
    //TODO
}

var a = 10;
function a() {}
function foo() {
  console.log(a);
  a = 5;
  console.log(window.a);
}
foo()

var a = 10;
function a() { };

function foo() {
  console.log(a)
  a = 5
  console.log(window.a);
  var a = 20;
  console.log(a)
}

foo();

var a = 10;
function a() {}
function foo() {
  console.log(a);
  a = 5;
  console.log(window.a);
}

foo() 

var a = 10;
function a() { };

function foo() {
  console.log(a)
  a = 5
  console.log(window.a);
  var a = 20;
  console.log(a)
}

foo();

function sum(...args) {
    args = [...args];
    let cache = 0;
    if (args.length === 0) {
        throw new Error('参数不能为空');
    }
    else {
        for (let i = 0; i < args.length; i++) {
            cache += args[i];
        }
    }

    let add = function(...args1) {
        args1 = [...args1];
        if (args1.length === 0) {
            throw new Error('参数不能为空');
        }

        for (let i = 0; i < args1.length; i++) {
            cache += args1[i];
        }

        return add;
    }
    add.valueOf = function() {
        console.log(cache)
    }

    return add;
}

var a = {n:1};
var b = a;
a.x = a = {n:2};
console.log(a.x); 
console.log(b.x); 

a.x =  // 这里的 a 还是 {n:1}
          a =  // 这里的 a 还是 {n:1}
                  {n:2} // 到这里后，a 就变成了 {n:2}，也就是这时候 旧 的 a 已经被这个新的 a 替换掉了

console.log(b.x) ;// {n: 2}

console.log(a.x); // undefined

var a = {n: 1};
var b = a;
Object.freeze(a);

try {
    a.x = a = {n: 2}
} catch (e) {

}

console.log(a.n); // 2 证明 a = {n: 2} 的赋值是成功的
console.log(a.x); // undefined 证明 a.x = {n: 2} 的赋值是在旧的 a 而不是在新的 a 上
console.log(b.n); // 1 证明 a = {n: 2} 的赋值是在旧的 a 上
console.log(b.x); // 如果没有Object.freeze(a) 这里就是 {n:2}，如果有就是 undefined，证明 a.x = {n: 2} 的赋值是在旧的 a 而不是在新的 a 上

Array.prototype.myMap = function (callback, thisObj) {
  const result = [];
  this.forEach((...args) => {
    const index = args[1];
    result[index] = callback.apply(thisObj, args);
  });
  return result;
};

const arr = [1, 2, 3];
const res = arr.myMap((curr, id, array) => {
  console.log(curr, id, array);
  return curr + 1;
});

console.log(res);

// Based on ECMAScript spec https://262.ecma-international.org/6.0/#sec-array.prototype.map

Array.prototype.myMap = function(callback, ...args) {
  let thisObject = Object(this)

  if(!thisObject) {
    throw new TypeError("this is null")
  }

  if(typeof callback !== "function"){
    throw new TypeError(callback + " is not a function")
  }

  let length = thisObject.length, mapped = new Array(length)
  let thisParameter = args.length ? args[0] : undefined

  for(let i = 0; i < length; i++){
    // Handle sparse array
    if(i in thisObject){
      // support this binding
      mapped[i] = callback.call(thisParameter, thisObject[i], i, thisObject)
    }
  }
  return mapped
}

function Foo() {
  getName = function () { console.log (1); };
  return this;
}
Foo.getName = function () { console.log (2);};
Foo.prototype.getName = function () { console.log (3);};
var getName = function () { console.log (4);};
function getName() { console.log (5);}

//请写出以下输出结果：
Foo.getName();
getName();
Foo().getName(); 
getName();
new Foo.getName();
new Foo().getName();
new new Foo().getName();

function test(a, b) {
    console.log(b)
    return {
        test: function(c){
            return test(c, a);
        }
    };
}

var retA = test(0);  
retA.test(2); 
retA.test(4); 
retA.test(8);
// 上面几个都好说，下面几个好好想想
var retB = test(0).test(2).test(4).test(8); 
var retC = test('good').test('bad');
retC.test('good'); 
retC.test('bad');
retC.test('good');

render('你好，我们公司是{{ company }}，我们属于{{group.name}}业务线，我们在招聘各种方向的人才，包括{{group.jobs[0]}}、{{group["jobs"][1] }}等。', {group: {name: '高德', jobs: ['前端', '后端']}, company: '阿里巴巴'});

LazyMan("Hank")
// 输出:
Hi! This is Hank!

LazyMan("Hank").sleep(10).eat("dinner")
// 输出
Hi! This is Hank!
//等待10秒..
Wake up after 10
Eat dinner

LazyMan("Hank").eat(“dinner”).eat("supper")
//输出
Hi This is Hank!
Eat dinner
Eat supper

LazyMan("Hank").sleepFirst(5).eat("supper")
//输出
//等待5秒
Wake up after 5
Hi This is Hank!
Eat supper

function _LazyMan(name) {
    this.fns = [];
    let self = this;
    const fn = () => {
        setTimeout(() => {
            console.log('Hi! This is ' + name);
            self.next();
        });
    }

    this.fns.push(fn);
    // 如果这里直接使用 self.next()，就无法将 sleepFirst 放到第一位来执行了
    setTimeout(() => {
        self.next();
    }, 0)
}

// 使用 next 来执行下一次的函数
_LazyMan.prototype.next = function() {
    let fn = this.fns.shift();
    fn && fn();
}

_LazyMan.prototype.sleep = function(time) {
    let self = this;
    const fn = () => {
        setTimeout(() => {
            console.log('Wake up after ' + time);
            self.next();
        }, time * 1000);
    }
    this.fns.push(fn);
    return this;
}

_LazyMan.prototype.eat = function(food) {
    let self = this;
    const fn = () => {
        setTimeout(() => {
            console.log('Eat ' + food);
            self.next();
        }, 0);
    }
    this.fns.push(fn);
    return this;
}

// 看到 sleepFirst 就知道要建立队列的概念
_LazyMan.prototype.sleepFirst = function(time) {
    let self = this;
    const fn = () => {
        setTimeout(() => {
            console.log('Wake up after  ' + time);
            self.next();
        }, time * 1000);
    }
    this.fns.unshift(fn);
    return this;
}

function LazyMan(name) {
    return new _LazyMan(name);
}

LazyMan('jack').sleep(2).eat('orange').sleepFirst(3)

function foo() {
    console.log(this.a);
}

var a = 2;
var o = {a: 3, foo: foo};
var p = {a: 4};

o.foo();
(p.foo = o.foo)(); // 2

const func = (arg1, arg2) => {
  return arg1 + arg2
}

const memoed = memo(func)

memoed(1, 2) 
// 3, func is called

memoed(1, 2) 
// 3 is returned right away without calling func

memoed(1, 3)
// 4, new arguments, so func is called

let a = [];
let b = "0";
console.log(a == 0);  
console.log(a == !a); 
console.log(b == 0); 
console.log(a == b); 

console.log(a == 0);   // true
console.log(a == !a);  // true
console.log(b == 0);   // true
console.log(a == b);   // false

extract(`
<div>
    <a>link1< / a><a href="https://bfe.dev">link1< / a>
    <div<abbr>bfe</abbr>div>
    <div>
<abbr>bfe</abbr><a href="https://bfe.dev" class="link2"> <abbr>bfe</abbr>   <span class="l">l</span><span  class="i">i</span>   nk2   </a>
    </div>
</div>
`)

// [
//    '<a>link1< / a>',
//    '<a href="https://bfe.dev">link1< / a>',
//    '<a href="https://bfe.dev" class="link2"> <abbr>bfe</abbr>   <span class="l">l</span><span  //class="i">i</span>   nk2   </a>'
 //]

/**
 * @param {string} str
 * @return {string[]}
 */
function extract(str) {
  // your code here
  

  let a = new DOMParser();
  let c = a.parseFromString(str, "text/html");
  let d = document.createTreeWalker(c, NodeFilter.SHOW_ELEMENT)
  let curr = d.currentNode;
  let res = [];
  while(curr){
    if(curr.nodeName === "A") res.push(curr.outerHTML);
    curr = d.nextNode()
  }
  return res;
}

function extract(str) {
  return str.match(/<a(\s[^>]*)?>.*?<\s*\/\s*a>/g) || [];
}

{ 
  "a": { 
    "b": { 
      "c": { 
        "d": 1 
      } 
    } 
  }, 
  "aa": 2, 
  "c": [ 
    1, 
    2 
  ] 
}
 //输出 { 'a.b.c.d': 1, aa: 2, 'c[0]': 1, 'c[1]': 2 }

let str = '';
let o = {};
function objFlatten (obj) {
     // 只要遍历一次 obj 就行
    Object.keys(obj).map(item => {
        if (Object.prototype.toString.call(obj[item]) === '[object Object]') {
            str += item + '.';
            // 如果当前值是对象，继续往内层遍历
            objFlatten(obj[item]);
        } else if (Object.prototype.toString.call(obj[item]) === '[object Array]') {
            obj[item].forEach((ele, index) => o[item+`[${index}]`] = ele);
        } else {
            str += item;
            o[str] = obj[item];
            str = '';
        }
    })
}

function flattenObj(obj) {
  let str = '';
  let res = {};

  function getType(data) {
    return Object.prototype.toString.call(data).replace(/\[object\s+(\w+)\]/, '$1');
  }

  const flatten = (obj) => {
    Object.keys(obj).map(item => {
      if (getType(obj[item]) === 'Object') {
        str += item + '.';
        // 如果当前值是对象，继续往内层遍历
        flatten(obj[item]);
      } else if (getType(obj[item]) === 'Array') {
		// 这里还可以考虑一下多维数组，加深一下难度
        obj[item].forEach((ele, index) => res[item+`[${index}]`] = ele);
      } else {
        str += item;
        res[str] = obj[item];
        str = '';
      }
    })
  };

  flatten(obj)

  return res;
}