const imgLazyLoad = (function () {
  let count = 0
  return function () {
    let deleteIndexList = []
    imgList.forEach((img, index) => {
      let rect = img.getBoundingClientRect()
      if (rect.top < window.innerHeight) {
        console.log(`加载第${index}张图片`)
        img.src = img.dataset.src
        deleteIndexList.push(index)
        count++
      }
      // 说明图片已经全部加载完成了，移除监听事件
      if (count === length) {
        document.removeEventListener('scroll', imgLazyLoad)
      }
    })
    // 剔除已经完成加载的图片的地址
    imgList = imgList.filter(
      (img, index) => !deleteIndexList.includes(index)
    )
  }
})()
// 监听鼠标滚动事件
document.addEventListener('scroll', imgLazyLoad)

function throttle(func, wait) {
  let prev = 0,
    context,
    args
  return function () {
    let now = +new Date()
    context = this
    args = arguments
    if (now - prev > wait) {
      func.apply(context, args)
      prev = now
    }
  }
}
// 监听鼠标滚动事件
document.addEventListener('scroll', throttle(imgLazyLoad, 500))

function imgLazyLoad() {
  const io = new IntersectionObserver((inters) => {
    inters.forEach((item, index) => {
      // 进入可视区域
      if (item.isIntersecting) {
        item.target.src = item.target.dataset.src
        //停止监听该元素
        io.unobserve(item.target)
      }
    })
  })
  // 监听每一个元素
  imgList.forEach((el) => io.observe(el))
}

const p = document.querySelector('p')
p.addEventListener("mousedown", (event) => {
  // event.cancelBubble = true
  event.stopPropagation()
  console.log("我是p元素上被绑定的第一个监听函数: mousedown");
}, false);

p.addEventListener("mousedown", (event) => {
  console.log("我是p元素上被绑定的第二个监听函数: mousedown");
}, false);
document.querySelector(".A").addEventListener("mousedown", (event) => {
  event.cancelBubble = true
  console.log("我是div & class A元素");
}, false);
document.querySelector(".B").addEventListener("mousedown", (event) => {
  console.log("我是div & class B元素");
}, false);

const p = document.querySelector('p')
p.addEventListener("mousedown", (event) => {
  // event.cancelBubble = true
  event.stopPropagation()
  console.log("我是p元素上被绑定的第一个监听函数: mousedown");
}, false);

p.addEventListener("mousedown", (event) => {
  console.log("我是p元素上被绑定的第二个监听函数: mousedown");
}, false);
document.querySelector(".A").addEventListener("mousedown", (event) => {
    // event.cancelBubble = true
    event.stopPropagation()
  console.log("我是div & class A元素");
}, true);
document.querySelector(".B").addEventListener("mousedown", (event) => {
  console.log("我是div & class B元素");
}, true);

const p = document.querySelector('p')
p.addEventListener("mousedown", (event) => {
  console.log("我是p元素上被绑定的第一个监听函数: mousedown");
}, false);

p.addEventListener("mousedown", (event) => {
  event.stopImmediatePropagation()
  console.log("我是p元素上被绑定的第二个监听函数: mousedown");
}, false);

p.addEventListener("mousedown",(event) => {
  console.log("我是p元素上被绑定的第三个监听函数: mousedown");
  // 该监听函数排在上个函数后面，该函数不会被执行
}, false);

p.addEventListener('click', (event) => {
  // 嘿嘿嘿，虽然监听的是同一元素，但却是不同事件！
  console.log('我是p元素上被绑定的第四个监听函数: click')
}, false)

document.querySelector(".A").addEventListener("mousedown", (event) => {
  console.log("我是div & class A元素");
}, false);

document.querySelector(".B").addEventListener("mousedown", (event) => {
  console.log("我是div & class B元素");
}, false);

function Parent () {
    this.names = ['kevin', 'daisy'];
}

function Child () {

}

Child.prototype = new Parent();

var child1 = new Child();

child1.names.push('yayu');

console.log(child1.names); // ["kevin", "daisy", "yayu"]

var child2 = new Child();

console.log(child2.names); // ["kevin", "daisy", "yayu"]

function Parent () {
    this.names = ['kevin', 'daisy'];
}

function Child () {
    Parent.call(this);
}

var child1 = new Child();

child1.names.push('yayu');

console.log(child1.names); // ["kevin", "daisy", "yayu"]

var child2 = new Child();

console.log(child2.names); // ["kevin", "daisy"]

function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}

Parent.prototype.getName = function () {
    console.log(this.name)
}

function Child (name, age) {

    Parent.call(this, name);
    
    this.age = age;

}

Child.prototype = new Parent();
Child.prototype.constructor = Child;

var child1 = new Child('kevin', '18');

child1.colors.push('black');

console.log(child1.name); // kevin
console.log(child1.age); // 18
console.log(child1.colors); // ["red", "blue", "green", "black"]

var child2 = new Child('daisy', '20');

console.log(child2.name); // daisy
console.log(child2.age); // 20
console.log(child2.colors); // ["red", "blue", "green"]

function createObj(o) {
    function F(){}
    F.prototype = o;
    return new F();
}

function createObj (o) {
    var clone = Object.create(o);
    clone.sayName = function () {
        console.log('hi');
    }
    return clone;
}

Child.prototype = new Parent()

let child1 = new Child('kevin', '18');

function Child (name, age) {
    Parent.call(this, name); 
    this.age = age;
}

Child.prototype = Object.create(Parent.prototype);
// Child.prototype = Parent.prototype
// 直接这样的话会存在隐患，如果修改Child.prototype的话会影响Parent.prototype
Child.prototype.constructor = Child;

function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}

Parent.prototype.getName = function () {
    console.log(this.name)
}

function Child (name, age) {
    Parent.call(this, name); 
    this.age = age;
}

Child.prototype = Object.create(Parent.prototype);
// Child.prototype = Parent.prototype
// 直接这样的话会存在隐患，如果修改Child.prototype的话会影响Parent.prototype
Child.prototype.constructor = Child;



// 可以封装一下
// function prototype(child, parent) {
//   var prototype = Object.create(parent.prototype);
//   prototype.constructor = child;
//   child.prototype = prototype;
// }

// // 当我们使用的时候：
// prototype(Child, Parent);

parsers: # array
  - url: xxxxxxxxx
    yaml:
      prepend-rules:
        - DOMAIN-SUFFIX,hdbits.org,🎯 国内网络
        - DOMAIN-SUFFIX,xthor.tk,🎯 国内网络
        - DOMAIN-SUFFIX,filelist.io,🎯 国内网络

parseInt(021)  //17
parseInt('021') //21
parseInt('021', 8) //17

['10','10','10','10','10'].map((num, index) => {
    return parseInt(num, index)
});
// [10, NaN, 2, 3, 4]
// 对于第一个数： 基数为0，将num当成十进制解析
// 对于第二个数， 基数为1， 返回NaN
// 对于第三个数， 基数为2， 将num当成二进制解析
// ..... 同上

parseInt(021)  //17
// (021).toString() -->  '17' --> 17
parseInt('021') //21
//未指定radix, 默认radix=10
parseInt('021', 8) //17
//指定 radix=8


// 返回15
parseInt("0xF", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10);   // parseInt(015, 8); 返回 13
parseInt(15.99, 10);
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);

//返回NaN
parseInt("Hello", 8); // 根本就不是数值
parseInt("546", 2);   // 除了“0、1”外，其它数字都不是有效二进制数字

//返回-15
parseInt("-F", 16);
parseInt("-0XF", 16);
parseInt(-15.1, 10);
parseInt(" -17", 8);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

filterInt = function (value) {
  if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value))
    return Number(value);
  return NaN;
}

console.log(filterInt('421'));               // 421
console.log(filterInt('-421'));              // -421
console.log(filterInt('+421'));              // 421
console.log(filterInt('Infinity'));          // Infinity
console.log(filterInt('421e+0'));            // NaN
console.log(filterInt('421hop'));            // NaN
console.log(filterInt('hop1.61803398875'));  // NaN
console.log(filterInt('1.61803398875'));     // NaN

var inorderTraversal = function(root) {
    let res = []
    let cur = root
    let mosRight = null
    while(cur !== null) {
        //有左子树，找前驱节点，判断是第一次访问还是第二次访问
        if(cur.left !== null) {
            mosRight = cur.left
            while(mosRight.right !== null && mosRight.right !== cur) {
                mosRight = mosRight.right
            } 
            //是第一次访问，访问左子树//是第一次访问，访问左子树
            if(mosRight.right === null) {
                mosRight.right = cur
                cur = cur.left
            } else {  
                //第二次访问了，那么应当消除链接
                //该节点访问完了，接下来应该访问其右子树
                mosRight.right = null
                res.push(cur.val)
                cur = cur.right
            }
        } else { //没有左子树，直接访问该节点，再访问右子树
            res.push(cur.val)
            cur = cur.right
        }
    }
    return res
}

var recoverTree = function(root) {
    let x = null, y = null, pred = null, predecessor = null
    while(root !== null) {
        if(root.left !== null) {
            // 首先让predecessor指针指向root.left,然后一直向右走到尽头
            predecessor = root.left
            while(predecessor.right !== null && predecessor.right !== root) {
                predecessor = predecessor.right
            }
            // 走到root节点左子树的最右边节点后，将其右指针指向root,然后将root指针指向其左节点，开始新一轮遍历
            if(predecessor.right === null) {
                predecessor.right = root
                root = root.left
            } 
            // predecessor指针不为空，说明左子树已经访问完了，需要断开连接，也就是对子树进行恢复，不然就成为了一个图
            else {
                if(pred !== null && root.val < pred.val) {
                    y = root
                    if(x === null) {
                        x = pred
                    }
                }
                pred = root
                predecessor.right = null
                // 左边找完了，找右边
                root = root.right
            }
        }
        else {
            // 如果没有左孩子，则访问右孩子
            if(pred !== null && root.val < pred.val) {
                y = root
                if(x === null) {
                    x = pred
                }
            }
            pred = root
            root = root.right
        }
    }
    [x.val, y.val] = [y.val, x.val]
}

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
//  从任意节点出发 => 选择记录max全局最大值
/* dfs记录以当前节点为根节点的最大路径和，递归左右子节点，
更新全局最大值的同时返回以当前节点为根节点的最大路径和 */
var maxPathSum = function(root) {
    let max = -Infinity
    const dfs = (root) => {
        if(!root) return 0
        let left = dfs(root.left) //以左节点为根节点的二叉树最大路径和
        let right = dfs(root.right) // 以右节点为根节点的二叉树最大路径和
        // 递归的过程中可能已经出现了原二叉树的最大路径和，需要更新最大路径和max
        // 为什么要加入0进行比较？因为最大路径和有可能为负数
        //为负数的话就返回Math.max就返回0，代表不选择该节点
        max = Math.max(max, Math.max(left, 0) + Math.max(right, 0)+root.val) 
        /*此外，dfs的功能就是计算以当前节点为根节点的最大路径和，因此将 当前节点的值（即root.val）
        与 以当前节点的子节点为根节点的子树的最大路径和（即 Math.max(left, right， 0)）的和
        作为以当前节点为根节点的最大路径和
        为什么加入0进行比较的原因同上，因为最大路径和有可能为负数 */
        return Math.max(left, right, 0) + root.val
    }
    dfs(root)
    return max
};

const getNext = function(s) {
  let next = []
  let j = -1
  next[0] = j
  for(let i = 1; i < s.length; i++) {
    while(j >= 0 && s[j+1] !== s[i]){ // s[j + 1] 与 s[i] 不相等
      j = next[j] // 回退
        // next[j]就是记录着j（包括j）之前的子串的最长相同前后缀的长度。
    }
    if(s[j+1] === s[i]) j++  //找到了相同的前后缀，同时向后移动i、j
    next[i] = j  // 将j(前缀的长度)赋给next[i],next[i]记录最长相同前后缀的长度
  }
  return next //f
}

let strStr = function(haystack, needle) {
  if(needle.length === 0) return 0
  const getNext = function(s) {
    let next = []
    let j = -1
    next[0] = j
    for(let i = 1; i < s.length; i++) {
      while(j >= 0 && s[j+1] !== s[i]){
        j = next[j]
      }
      if(s[j+1] === s[i]) j++
      next[i] = j 
    }
    return next
  }
  
  let next = getNext(next, needle)
  let j = -1
  for(let i = 0; i < haystack.length; i++) {
    while(j >= 0 && haystack[i] !== needle[j+1]){
      j = next[j]
    }
    if(haystack[i] === needle[j+1]) j++
    if(j === needle.length - 1) {
      return i - needle.length + 1
    }
  }
  return -1
}

function repeatedSubstringPattern(s: string): boolean {
    const getNext = (s) => {
        let j = -1
        let next = [j]
        for(let i = 1; i < s.length; i++) {
            while(j >= 0 && s[j+1] !== s[i]) {
                j = next[j]
            }
            if(s[j+1] === s[i]){
                j++
            }
            next[i] = j
        }
        return next
    }
    if(s.length === 0) return false
    let next = getNext(s)
    if(next[s.length - 1] !== -1 && s.length % (s.length - (next[s.length - 1] + 1)) === 0) {
        return true
    }
    return false
};