头条

• node 多进程，进程守护创建
• proxy 都有什么拦截属性
• electron，主进程、渲染进程通信
• compute 和 watcher 区别，实现原理
• 给定一颗树，树节点上的内容都是数字。实现一个函数，判断从 root 到叶子是否存在一条 path 的和等于给定的数字
• 实现 一个 高阶函数 cache ,能够缓存参数一样的结果，已经计算过一样的不要重复计算
• 实现一个 LazyGuy，支持LazyGuy('jack').eat('apple').sleep(10).eat('cake')函数
• 实现一个组件：
  • 点击编辑进入编辑状态，可以取消、保存内容
  • 如果取消信息回复到编辑前

TreeNode {
  num: number;
  children: TreeNode[];
}

• 实现 一个 高阶函数 cache ,能够缓存参数一样的结果，已经计算过一样的不要重复计算

const cache = (fn) => {};

function computed(a, b, c) {
  return a + b + c;
}
let cacheFn = cache(computed);
cacheFn(1, 2, 3);
cacheFn(1, 2, 3); // 第二次不会重复运算

• 实现一个LazyGuy('jack').eat('apple').sleep(10).eat('cake')函数
• 运行结果：

// // 输出如下 // I am jack // I am eating apple // // 等待 10s // I am eating cake

• 实现一个组件：
  • 点击编辑进入编辑状态，可以取消、保存内容。如果取消信息回复到编辑前
• 实现一个合并多个有序数组的函数

// 给定一颗树，树节点上的内容都是数字
// 实现一个函数，判断从root到叶子是否存在一条path的和等于给定的数字



const exsitPath = function (root, num) {

}
// 实现 一个 高阶函数 cache
// 入参只需要考虑 简单类型: string, number

const cache = (fn) => {

}

const cache = (fn) => {
    let map = {};
    return function(...args){
        let key = args.reduce((pre,next)=>{
            let type = typeof next;
            return pre+type+next;
        },'');
        if(map[key]!==undefined) return map[key];
        let result = fn(...args);
        map[key] = result;
        return result;
    }
}


const exsitPath = function (root, num) {
    function countNum (node,count,flag){
        if (!node) return false;
        if(node.num+count===flag&&node.children.length===0) return true;
        for(let i=0;i<node.children.length;i++){
            let iNode = node.children[i];
            let result = countNum(iNode,count,flag);
            if (result) return true;
        }
        return false;
    }
    return countNum(root,0,num);
}

// lazy man
LazyGuy('jack').eat('apple').sleep(10).eat('cake')


// // 输出如下
// I am jack
// I am eating apple
// // 等待10s
// I am eating cake



function LazyGuy(who){
    console.log(`I am ${who}`);
    let callback = [];
    let fn = {
        eat (some){
            callback.push({
                fn: ()=>{
                    console.log(`I eating ${some}`);
                },
                type: 'normal'
            });
            return fn;
        },
        sleep(time) {
            callback.push({
                fn: ()=>{
                    return new Promise((resolve)=>{
                        setTimeout(()=>{
                            resolve();
                        },time*1000)
                    });
                },
                type: 'async'
            });
            return fn;
        }
    };
    setTimeout(async ()=>{
        while(callback.length>0){
            let ct = callback.shift();
            if(ct.type==='normal'){
                ct.fn();
            } else {
                await ct.fn();
            }
        }
    },0)
    return fn;
}

LazyGuy('jack').eat('apple').sleep(10).eat('cake');

// promise finally


Promise.prototype.finally = function(callback){
    return this.then(
        (res)=>{
            return Promise.resolve(callback(res)).then(()=>value);
        },
        (err)=>{
            callback(err);
            return Promise.reject();
        }
    )
}

class EditInfo extends React.components{
    constructor(){
        super();
        this.state = {
            flag: true,
            initVal: '',
            editInfo: '',
        }
    }
    toggleState(){
        this.setState({
            flag: !this.state.flag,
            editInfo: this.state.initVal
        })
    }

    changeVal(event){
        this.setState({
            editInfo: event.target.value
        })
    }

    save(){
        this.setState({
            flag: true,
            initVal: this.state.editInfo,
            editInfo: ''
        })
        //
    }
    cancel(){
        this.setState({
            flag: true,
            editInfo: ''
        })
    }
    componentDidMounted(){
        // ajax请求
        this.setState({
            initVal: '当前值'
        });
    }


    render(){
        return (
            <div>
                {
                    this.state.flag?
                    <div>{this.state.initVal}<span onClick={()=>this.toggleState()}>编辑</span></div>
                    :<div>
                        <input value={this.state.editInfo} onChange={(event)=>this.changeVal(event)}/>
                        <span onClick={()=>this.save()}>保存</span>
                        <span onClick={()=>this.cancel()}>取消</span>
                    </div>
                }
            </div>
        )
    }

}

function mergeKList(...list) {
}

const a = new List(....); // 1 -> 3 -> 5
const b = new List(....); // 2 -> 4 -> 6
const c = new List(....); // 4 -> 7 -> 9


const result = mergeKList(a, b, c);
dump(result);
// 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6 -> 7 -> 9