const findOperations = function(oldArr, newArr) {
    const makeMap = arr=>arr.reduce((prev, v, i)=>{
        prev.set(v, (prev.get(v) || 0) + 1);
        return prev;
    }, new Map());
    const oldMap = makeMap(oldArr);
    const newMap = makeMap(newArr);

    const inserts = new Map();
    const removes = new Map();
    const swap = new Map();

    const findInsert = function() {
        for(let [v, count] of newMap) {
            if(!oldMap.get(v)) {
                inserts.set(v, count)
            }else if(oldMap.get(v)<count) {
                inserts.set(v, count - oldMap.get(v));
            }
        }
    }

    const findRemove = function() {
        for(let [v, count] of oldMap) {
            if(!newMap.get(v)) {
                removes.set(v, count)
            }else if(oldMap.get(v)>newMap.get(v)) {
                removes.set(v, count - newMap.get(v));
            }
        }
    }

    findInsert();
    findRemove();

    const operations = [];
    const removeOld = function(v, count) {
        for(let i = 0; i<count; i++) {
            const index = oldArr.indexOf(v);//这里无需再判断-1了
            operations.push(["remove", index]);
            oldArr = oldArr.slice(0, index).concat(oldArr.slice(index+1));
        }
    };

    const insertOld = function(v, count) {
        for(let i = 0; i<count; i++) {
            operations.push(["insert", oldArr.length, v]);
            oldArr.push(v);
        }
    };

    for(let [v, count] of removes) {
        removeOld(v, count);
    }

    for(let [v, count] of inserts) {
        insertOld(v, count);
    }

    let i = 0;
    while(i<newArr.length) {
        if(oldArr[i]==newArr[i]) {
            i++;
            continue;
        }
        const swapIndex = oldArr.indexOf(newArr[i], i+1);
        const tmp = oldArr[i];
        oldArr[i] = oldArr[swapIndex];
        oldArr[swapIndex] = tmp;
        swap.set(i, swapIndex);
        i++;
    }
    
    for(let [v, swapIndex] of swap) {
        operations.push(["swap", v, swapIndex]);
    }

    return operations;
};


//test code:
const oldArr = [1, 2, 3];
const newArr = [4, 3];
console.log(findOperations(oldArr, newArr));

//output
[ 
  [ 'remove', 0 ],//移除第0个元素
  [ 'remove', 0 ],
  [ 'insert', 1, 4 ],//在索引1的位置插入4
  [ 'swap', 0, 1 ] //交换索引0和索引1的元素
]

const evts = ["touchstart", "touchmove", "touchend", "click"]
evts.forEach(evt => document.body.addEventListener(evt, () => console.log(evt)))

class A {
    constructor() {
        this.name = "a"
    }

    say() {
        console.log(this.name)
    }

    sayFn() {
        return ()=>{
            console.log(this.name);
        }
    }
}

const a = new A();
a.say()//输出a

const fn1 = a.say;
fn1();//报错，TypeError: Cannot read property 'name' of undefined

const fn2 = a.say.bind(a);
fn2();//输出a

const fn3 = a.say.bind({name:'b'});
fn3();//输出b

a.say.call({name:'b'});//输出b

const fn4 = (a.sayFn()).bind({name:'b'})
fn4()//输出a

const fn5 = (a.sayFn.bind({name:'b'}))()
fn5()//输出b

window.addEventListener('scroll', function() {console.log('scroll')})
document.addEventListener('scroll', function() {console.log('scroll')})
document.body.addEventListener('scroll', function() {console.log('scroll')})
//滑动页面，上面都没输出scroll

// node_modules/hexo-lazy-image/lib/simple-lazyload.js
window.addEventListener('scroll', function () {
    throttle(processImages, window);
}, true);//useCapture，捕获scroll事件

//@webSrc/utils/promiseFinallyShim.js
import { shim } from 'promise.prototype.finally'
const promiseFinallyShim = shim()
if (!Promise.prototype.finanlly) {
  Promise.prototype.finally = promiseFinallyShim
}

//index.js
import promiseFinallyShim from '@webSrc/utils/promiseFinallyShim'
//引入后能正常使用
(new Promise()).finally

const myFetch = function(url, options, timeout) {
    return new Promise(function(resolve, reject) {
        fetch(url, options).then(resolve).catch(reject)
        setTimeout(function() {
            reject(new Error("timeout"))
        }, timeout)
    });
}

const timeoutFetch = function(url, args, timeout) {
    return Promise.race([fetch(url, args), new Promise((resolve, reject) => {//这里主要巧妙运用Promise.race
        setTimeout(function() {
            reject(new Error('timeout'));
        }, timeout);
    })])
}

//使用：
timeoutFetch('https://www.google.com', {}, 1000)

//通过高阶函数，保持了fetch的参数列表不变，对业务代码的侵入性更低
const timeoutFetch = function(timeout) {
    return function(...args) {
        return Promise.race([
            fetch.apply(this, args), 
            new Promise((resolve, reject) => {
                    setTimeout(function() {
                        reject(new Error('timeout'));
                    }, timeout)
                 })
        ])
    }
};

//使用：
const tf = timeoutFetch(1000)
tf('https://www.google.com', {})

const container = document.createElement("div")
container.innerHTML = '<script type="text/javascript">alert("aaa")</script>'
document.body.appendChild(container)
//不弹出任何东西

const script = document.createElement("script")
script.innerHTML = "alert('aaa')"
document.body.appendChild(script)

const container = document.createElement("div")
container.appendChild(script)
script.innerHTML = "alert('bbb')"
document.body.appendChild(container)
//只弹出aaa