1.数据类型
基本数据类型
string、number、null、undefined、boolean
引用类型：
funaction、obj、array
判断数据类型可以用typeof，如果是引用类型用instanceof
typeof 一般只能返回如下几个结果："number"、"string"、"boolean"、"object"、"function" 和 "undefined"。
instanceof运算符用来测试一个对象在其原型链中是否存在一个构造函数的prototype属性。
instanceof 检测一个对象A是不是另一个对象B的实例的原理是：查看对象B的prototype指向的对象是否在对象A的[[prototype]]链上。如果在，则返回true,如果不在则返回false。不过有一个特殊的情况，当对象B的prototype为null将会报错(类似于空指针异常)。
instanceof 具体实现：
可以在继承关系中用来判断一个实例是否属于它的父类型:
例如：function Foo(){}
Foo.prototype =newAoo();//JavaScript 原型继承 varfoo =new Foo();
console.log(foo instanceofFoo)//true console.log(fooinstanceofAoo)//true
2.类数组和数组
1）拥有length属性，其它属性（索引）为非负整数（对象中的索引会被当做字符串来处理）;
2）不具有数组所具有的方法；
类数组是一个普通对象，而真实的数组是Array类型。
常见的类数组有: 函数的参数 arguments, DOM 对象列表(比如通过 document.querySelectorAll 得到的列表), jQuery 对象 (比如 $(“div”)).
类数组可以转换为数组:
//第一种方法
Array.prototype.slice.call(arrayLike, start);
//第二种方法 扩展运算符
[...arrayLike];
//第三种方法: Array.from()方法
Array.from(arrayLike);
3.原型、原型链
所有的js对象都有一个prototype属性，指向他的原型对象。当试图访问这个对象的属性时，如果在这个对象上面没有找到，他会搜寻该对象的原型，依次层层向上搜索，直到找到一个名字匹配的属性或达到原型链的末尾。
4.原型、构造函数、实例
实例：var obj=new Object();
1.每个构造函数都有一个原型对象。 每个构造函数本身都是一个对象，它有一个属性叫做prototype，它是一个对象。
2.原型对象都包含一个指向构造函数的指针。
3.实例都有一个属性叫做_proto_，它是个指针，指向原型对象。
4.继承 理解js继承的6种方式 - Grace-zyy - 博客园
1.原型链继承
2.借用构造函数继承 .call()和.apply()
3.组合继承（组合原型链继承和借用构造函数继承）（常用）
在子类的构造函数中通过parent.call(this)继承父类的属性，然后改变子类的原型为new parent()来继承父类的函数
4.寄生式继承
5.寄生组合式继承（常用）
将父类的原型赋值给子类，并且将构造函数设置为子类
6.class 继承
使用extends表明继承自哪个父类，并且在子类构造函数中必须调用super
5. 数组
去重：
（1）Array.sort()
首先使用 sort() 将数组进行排序，然后比较相邻元素是否相等，从而排除重复项
function distinct(a, b) {
let arr = a.concat(b)
arr = arr.sort()
let result = [arr[0]]
for(let i=1, len=arr.length; i
arr[i] !== arr[i-1] && result.push(arr[i])
}
return result
}
（2）new Set() Set 的成员具有唯一性
function distinct(a, b) {
returnArray.from(new Set([...a, ...b]))
}
（3）二、Array.filter() + indexOf
这个方法的思路是，将两个数组拼接为一个数组，然后使用 ES6 中的Array.filter() 遍历数组，并结合 indexOf 来排除重复项
function distinct(a, b) {
let arr = a.concat(b);
return arr.filter((item, index)=> {
return arr.indexOf(item) === index
})
}
冒泡排序（排序最慢）：比较相邻的元素。如果第一个比第二个大，就交换它们两个
选择排序：从数组的开头开始遍历，将第一个元素和其他元素分别进行比较，记录最小的元素，等循环结束之后，将最小的元素放到数组的第一个位置上，然后从数组的第二个位置开始继续执行上述步骤。当进行到数组倒数第二个位置的时候，所有的数据就完成了排序。
快速排序（递归）：该算法首先要从数列中选出一个元素作为基数（pivot）。接着所有的数据都将围绕这个基数进行，将小于改基数的元素放在它的左边，大于或等于它的数全部放在它的右边，对左右两个小数列重复上述步骤，直至各区间只有1个数。
//快速排序functionquickSort( arr ){if( arr.length ==0) {return[]; }varleft = [];varright = [];varpivot = arr[0];for(vari =1; i < arr.length; i++) {if(arr[i] < pivot) { left.push( arr[i] ); }else{ right.push( arr[i] ); } }returnquickSort( left ).concat( pivot, quickSort( right ));}
插入排序、 希尔排序、sort排序
最大值、最小值：
* 数组sort()排序
* apply
* for 循环
var data = [1,25,3,4.23]
var maxData = minData= data[0];
for (var i = 0; i < data.length; i++) {
if (data[i]>maxData) {
maxData = data[i]; // 最大值
};
if (data[i]<minData) {
minData = data[i]; // 最小值
}
}
6.闭包
定义：函数A里面有一个函数B，函数B可以调用函数A的变量，函数B就是闭包
优势：
a.函数外部可以读取函数内部的局部变量,实现变量数据共享
b.保存变量不会被销毁，始终存在在内存中
劣势：
a.保存变量，增加内存开销 （ 相当于返回一个函数，延迟处理）
b.在Ie中可能导致内存泄漏，网页性能降低
解决办法：
a.退出函数之前，将不使用的局部变量全部删除 eg: str=undefined;
b.使用settimeout，通过第三个参数传入变量
c.使用块级作用域，让变量成为上下文的属性，避免共享,eg:
for(vari= 0; i< list.length; i ++){
list[i].addEventListener('click',function(){
console.log(i)
})
}
1.利用let块级作用域的特性 for(let i= 0; i< list.length; i ++){ }
2. 匿名自执行函数
(function() {
var days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
today = new Date(),
msg = 'Today is ' + days[today.getDay()] + ', ' + today.getDate(); alert(msg);
} ());
使用场景：
a.循环遍历嵌套定时器
7.内存泄漏
定义：由于疏忽或错误造成程序未能释放已经不再使用的内存。
原因：
a.意外的全局变量,无法回收
b.定时器，未被正确关闭，导致所用的外部变量无法被释放
c.闭包
d.DOM泄漏：
游览器中DOM和js采用的是不一样的引擎，DOM采用的是渲染引擎，而js采用的是v8引擎，所以在用js操作DOM时会比较耗费性能，因为他们需要桥来链接他们。为了减少DOM的操作，我们一般将常用的DOM。我们会采用变量引用的方式会将其缓存在当前环境。如果在进行一些删除、更新操作之后，可能会忘记释放已经缓存的DOM，话不多说直接来个例子
e.console.log
在代码运行之后需要在开发工具能查看对象信息，所以传递给console.log的对象是不能被垃圾回收。
