JS基础知识（一）

1.必须传参的函数
function test(x = x) {return x}
如果不传参，括号里面的x就是没定义，会报没定义的错

2.对象的valueOf函数
当你这么玩的时候：
1 + { valueOf() {return 1} }  此时右边这个对象会调用valueOf方法进行数字转换
所以答案是2

3.forEach 
如果数组的某个元素为空他会跳过那次循环 比如
var i = 0
[1,2, ,4].forEach((item, index) => {i++}) // 3

4.Symbol
var a = Symbol('s')
var b = Symbol('s')
a == b  // false
JavaScript标准中规定对象的key只能是 String 或 Symbol 类型，String 类型的key可以重复而 Symbol 类型的key是唯一的。
var c = Symbol.for('s')
c == a // false
var d = Symbol.for('s')
c == d // true

5.let的暂时性死区
一旦你使用了let，那不好意思，在我未声明该变量前，不许使用该变量
{
	console.log(tem)  // 报错
	let tem = 1
}
这很正常，let不允许提升嘛 
var tem = 2
{
	console.log(tem)  // 报错
	let tem = 1
}
按理来说，里面的tem不会提升，它会去找外面的，但是let 很霸道，它不给出去找。
这就是暂时性死区：因为let的霸道而出现的

6. 0/0 1/0
在JavaScript 中,任何非零数除以零会返回infinite，0/0会返回出 NaN ,不会报错，也不会终止程序执行。

7.在jsx里面,要把class换成className才能正确编译,表示样式.

8.this指向
function test() {
  this.flag = false;
  this.change = () => {
    this.flag = true;
    console.log(button.flag);
  };
}
const button = new test();
button.change()    // true

9. -0 和 +0
它们相等

10.0.1 + 0.2 > 0.3 

11.Object.is()
Object.is() 方法判断两个值是否为同一个值。
如果满足以下条件则两个值相等:
都是 undefined
都是 null
都是 true 或 false
都是相同长度的字符串且相同字符按相同顺序排列
都是相同对象（意味着每个对象有同一个引用）
都是数字且
都是 +0
都是 -0
都是 NaN
或都是非零而且非 NaN 且为同一个值 

12.代码回收规则如下：
1.全局变量不会被回收。
2.局部变量会被回收，也就是函数一旦运行完以后，函数内部的东西都会被销毁。
3.只要被另外一个作用域所引用就不会被回收

13.new 的this绑定优先级高于 bind

14.es6 编译 es5
class Person {
     constructor (name) {
          this.name = name;
     }
     greet () {
          console.log(`Hi, my name is ${this.name}`);
     }
     greetDelay (time) {
          setTimeout(() => {
               console.log(`Hi, my name is ${this.name}`);
          }, time);
     }
}

 var Person = (function () {
     function Person (name) {
          this._name = name;
     }
     Person.prototype.greet = function () {
          console.log(“Hi, my name is “ + this._name);
     }
     Person.prototype.greetDelay = function (time) {
          var _this = this;
          setTimeout(function () {
               console.log(“Hi, my name is “ + _this.name);
          }, time);
     }
})();

15. 
['1', '2', '3'].map(parseInt)
map的回调函数接收三个参数
1.值
2.索引
而parseInt接收两个参数
1.值
2.进制
parseInt('1', 0) // 1  进制为0时 且值不以'0' 或 '0x'开头 进制按10处理
parseInt('2', 1) // NaN
parseInt('3', 2) // NaN

16.防抖
短时间某事件执行多次只有最后一次有效
function debounce(fn, delay) {
	let timer
	return function() {
		if(timer) {
			clearTimeout(timer)
		}
		timer = setTimeout(fn, delay)
	}
}
var fn1 = debounce(fn, 2000)
document.getElementById().click = fn1

17.节流
短时间某事件触发多次，只有第一次有效 给定时间内无法再次生效
function throttle(fn, delay) {
	let timer = null
	let flag = false
	return function() {
		if(!flag) {
			timer = setTimeout(() => {fn.apply(this, ...arguments); flag = false;}, delay)
			flag = true
		}
	}
}

18.weakSet 和 set
set 允许存储任何类型的唯一值，包括原始值和对象
weakSet 只允许存储对象，且对象的存储是弱引用，可以被垃圾回收机制回收。用来保存dom节点很合适，不容易造成内存泄漏

19.深度优先遍历
从某个点开始，找它的邻接点，再找这个邻接点的邻接点，直到找完所有点。
// 递归写法  如果改为迭代写法一般需要借用栈
先明确下节点的构成
{node: {val, children:[]}}
即是一个节点拥有值和子节点这两个属性
function deepTraversal(node, visitedNode) {
	if(!node.children) return
	visitedNode.push(node)
	// 找邻接点
	var children = node.children
	// 递归
	for(let i = 0; i < children.length; i++) {
		deepTraversal(children[i], visitedNode)
	}
}
//测试例子
var n = {
	val: 1,
	children: [
		{val: 2, children: [
			{val: 3, children: []}
		]},
		{val: 4, children: [
			{val: 5, children: [
				{val: 6, children: [
					{val: 7, children: []}
				]}
			]}
		]}
	]
}
var res = []
deepTraversal(n, res)
console.log(res)

迭代法


20.广度优先遍历
从某个点开始，寻找它的**所有**邻接点。再从这些邻接点中选一个找它的所有邻接点，直到找完为止
记录一个i 第一个节点被保存，它的子节点也跟着被保存
i循环递增 重复这个操作
function wideTraversal(node) {
	var visitedNode = []
	var i = 0
	var children
	while(node.children != null) {
		visitedNode.push(node)
		node = visitedNode[i++]
		children = node.children
		for(let j = 0; j < children.length; j++) {
			visitedNode.push(children[j])
		}
		node = visitedNode[i]
	}
}