小达不刘

arr.reduce(function(previousValue, item, index, arr){},
initialValue)

const arr = [1,2,3,4]
const res = arr.reduce((pre, item, index, arr)=>{
  return pre + item
}, 0)
console.log(res) // 10

var a = 0
function foo (b) {
    console.log(this)
    var test = () => {
        console.log(this)
    }
    return test
}
var obj1 = {
    a: 1,
    foo: foo,
}
var obj2 = {
    a: 2
    foo: () => {
        console.log(this)
    }
}
obj1.foo()() // this此时指向obj1,虽然是window调用，但是默认绑定规则对箭头函数失效，箭头函数this就是父级this的指向。
var bar = foo.call(obj1) // this依然指向window, 显示绑定也无法改变this指向
obj2.foo() // this此时指向window,而不指向obj2，所以隐式调用也无效

// 箭头函数不允许作为构造函数
var foo1 = () => {
    console.log(this)
}
new foo1() // 浏览器报错：Uncaught typeerror

var name = 'window'
var obj1 = {
    name: '1',
    fn1: function(){
        console.log(this.name)
    },
    fn2: () => {console.log(this.name)},
    fn3: function(){
        return function(){
            console.log(this.name)
        }
    },
    fn4: function(){
        return () => {
            console.log(this.name)
        }
    },
}
var obj2 = {
    name: '2'
}

obj1.fn1() // 1
obj1.fn1.call(obj2) // 2

obj1.fn2() // window
obj1.fn2.call(obj2) // window

obj1.fn3()() //错误 1 // 正确 window 返回的函数自调用，所以指向window
obj1.fn3().call(obj2)  // 2
obj1.fn3.call(obj2)() // 错误 2 // 正确 window 返回的函数自调用，所以指向window

obj1.fn4()() // 错误window //正确 1，返回的箭头函数中this指向父级fn4,fn4的this是obj1调用，故this指向obj1, 所以答案是1
obj1.fn4().call(obj2) // 错误window //正确 1,上题返回1，call不能改变箭头函数的this,故还是1
obj1.fn4.call(obj2)() // 2，相当于fn4在obj2中了，fn4 this指向obj2,故返回的箭头函数this也指向obj2。
//想更改箭头函数的this指向，只能更改父级作用域this指向

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() // 2
getName() // 4
Foo().getName() // 1
getName() // 1
// 预编译时，函数提升，执行时getNname表达式会覆盖函数getNname，所以5永远也不会打印出来了。

new Foo.getName() // 2, new的是对象上的属性，该属性是个方法(Foo.getNname = function(){ console.log(2) })，new的时候会执行里面的语句
new Foo().getName()  // 3, 要这么看：(new Foo()).getName()，也就是new Foo()之后的实例对象的getName()，在实例对象上没有找到getName()，再去原型上找
new new Foo().getName()  // 3，这么看：new( (new Foo()).getName() ),  最终new对象实例上的属性，实例上没有该属性，去原型上找，该属性是个方法，new时会执行里面的语句

for(let i = 0; i< 5; i++) {
  console.log(i)
}

// 遍历String
let str = "Hello";
for (let value of str) {
  console.log(value)
}
// H e l l o

// 遍历Map
let iterable = new Map([["a", 1], ["b", 2], ["c", 3]]);
for (let entry of iterable) {
  console.log(entry);
}
// ["a", 1]
// ["b", 2]
// ["c", 3]
for (let [key, value] of iterable) {
  console.log(value);
}
// 1
// 2
// 3

Function.prototype.mycall = function(ctx, ...args) {
  // this此时是调用mycall的实例对象
  if (typeof this !=== 'funciton') {
    throw new Error('type error')
  }
  ctx = ctx || window
  // this这个实例对象赋值给fn属性
  // 优化：放置fn属性会覆盖该实例本身的fn属性
  let fn = Symbol(1)
  ctx[fn] = this
  // 以属性方式执行
  const res = ctx[fn](...args)
  // 执行完删除该属性
  delete ctx[fn]
  return res
}

Function.prototype.myapply = function(ctx, arg = []) {
  // this此时是调用mycall的实例对象
  if (typeof this !=== 'funciton') {
    throw new Error('type error')
  }
  ctx = ctx || window
  // this这个实例对象赋值给fn属性
  // 优化：放置fn属性会覆盖该实例本身的fn属性
  let fn = Symbol(1)
  ctx[fn] = this
  // 以属性方式执行
  const res = ctx[fn](arg)
  // 执行完删除该属性
  delete ctx[fn]
  return res
}

// 时间戳
function throttled1(fn, delay = 500) {
    let oldtime = Date.now()
    return function (...args) {
        let newtime = Date.now()
        if (newtime - oldtime >= delay) {
            fn.apply(null, args)
            oldtime = Date.now()
        }
    }
}

// 定时器
function throttled2(fn, delay = 500) {
    let timer = null
    return function (...args) {
        if (!timer) {
            timer = setTimeout(() => {
                fn.apply(this, args)
                timer = null
            }, delay);
        }
    }
}

// 时间戳与定时器结合更加准确
function throttled3(fn, delay) {
  let timer = null
  let startTime = Date.now()
  return function(){
    let context = this
    let args = arguments
    let curentTime = Date.now()
    let remainTime = delay - (curentTime - startTime)
    clearTimeout(timer)
    if (remainTime <= 0) {
      fn.apply(context, args)
      startTime = Date.now()
    } else (
      timer = setTimeout(fn, remainTime)
    )
  }
}

// 简单版本
function debounce(fn, wait) {
  let timer
  
  return function() {
    let context = this
    let args = arguments
    clearTimeout(timer)
    timer = setTimeout(() => {
      fn.apply(context, args)
    }, wait)
  }
}

// 防抖如果需要立即执行，可加入第三个参数用于判断，实现如下：
function debounce(func, wait, immediate) {

    let timeout;

    return function () {
        let context = this;
        let args = arguments;

        if (timeout) clearTimeout(timeout); // timeout 不为null
        if (immediate) {
            let callNow = !timeout; // 第一次会立即执行，以后只有事件执行后才会再次触发
            timeout = setTimeout(function () {
                timeout = null;
            }, wait)
            if (callNow) {
                func.apply(context, args)
            }
        }
        else {
            timeout = setTimeout(function () {
                func.apply(context, args)
            }, wait);
        }
    }
}