Js 基础

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属性，指向他的原型对象。当试图访问这个对象的属性时，如果在这个对象上面没有找到，他会搜寻该对象的原型，依次层层向上搜索，直到找到一个名字匹配的属性或达到原型链的末尾。

JS(原型和原型链） - 姜皓 - 博客园

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

})

}

排序：JS中的算法与数据结构——排序（Sort） -

冒泡排序（排序最慢）：比较相邻的元素。如果第一个比第二个大，就交换它们两个

选择排序：从数组的开头开始遍历，将第一个元素和其他元素分别进行比较，记录最小的元素，等循环结束之后，将最小的元素放到数组的第一个位置上，然后从数组的第二个位置开始继续执行上述步骤。当进行到数组倒数第二个位置的时候，所有的数据就完成了排序。

快速排序（递归）：该算法首先要从数列中选出一个元素作为基数（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 = 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的对象是不能被垃圾回收。