前端js优化小技能

时间 2020-07-10

原文原文链接

JavaScript 性能优化的小知识总结

前言

一直在学习 javascript，也有看过《犀利开发 Jquery 内核详解与实践》，对这本书的评价只有两个字犀利，多是对 javascript 理解的还不够透彻异或是本身太笨，更多的是本身不擅于思考懒得思考以致于里面说的一些精髓都没有太深刻的理解。javascript

鉴于想让本身有一个提高，进不了一个更加广阔的天地，总得找一个属于本身的居所好好生存，因此平时会有意无心的去积累一些使用 jQuerry 的经常使用知识，特别是对于性能要求这一块，老是会想是否是有更好的方式来实现。css

下面是我总结的一些小技巧，仅供参考。(我先会说一个总标题，而后用一小段话来讲明这个意思再最后用一个 demo 来简单言明)html

避免全局查找

在一个函数中会用到全局对象存储为局部变量来减小全局查找，由于访问局部变量的速度要比访问全局变量的速度更快些java

function search() {node
//当我要使用当前页面地址和主机域名编程
alert(window.location.href + window.location.host);数组
}浏览器
//最好的方式是以下这样先用一个简单变量保存起来缓存
function search() {安全
var location = window.location;
alert(location.href + location.host);
}

定时器

若是针对的是不断运行的代码，不该该使用 setTimeout，而应该是用 setInterval，由于 setTimeout 每一次都会初始化一个定时器，而 setInterval 只会在开始的时候初始化一个定时器

var timeoutTimes = 0;
function timeout() {
timeoutTimes++;
if (timeoutTimes < 10) {
setTimeout(timeout, 10);
}
}
timeout();
//能够替换为：
var intervalTimes = 0;
function interval() {
intervalTimes++;
if (intervalTimes >= 10) {
clearInterval(interv);
}
}
var interv = setInterval(interval, 10);

字符串链接

若是要链接多个字符串，应该少使用 +=，如

s+=a;

s+=b;

s+=c;

应该写成 s+=a + b + c；

而若是是收集字符串，好比屡次对同一个字符串进行 += 操做的话，最好使用一个缓存，使用 JavaScript 数组来收集，最后使用 join 方法链接起来

var buf = [];
for (var i = 0; i < 100; i++) {
buf.push(i.toString());
}
var all = buf.join("");

避免 with 语句

和函数相似，with 语句会建立本身的做用域，所以会增长其中执行的代码的做用域链的长度，因为额外的做用域链的查找，在 with 语句中执行的代码确定会比外面执行的代码要慢，在能不使用 with 语句的时候尽可能不要使用 with 语句。

with (a.b.c.d) {
property1 = 1;
property2 = 2;
}
//能够替换为：
var obj = a.b.c.d;
obj.property1 = 1;
obj.property2 = 2;

数字转换成字符串

般最好用 "" + 1 来将数字转换成字符串，虽然看起来比较丑一点，但事实上这个效率是最高的，性能上来讲：

("" +) > String() > .toString() > new String()

浮点数转换成整型

不少人喜欢使用 parseInt()，其实 parseInt() 是用于将字符串转换成数字，而不是浮点数和整型之间的转换，咱们应该使用 Math.floor() 或者 Math.round()

各类类型转换

var myVar = "3.14159",
str = "" + myVar, // to string
i_int = ~ ~myVar, // to integer
f_float = 1 * myVar, // to float
b_bool = !!myVar, /* to boolean - any string with length
and any number except 0 are true */
array = [myVar]; // to array

若是定义了 toString() 方法来进行类型转换的话，推荐显式调用 toString()，由于内部的操做在尝试全部可能性以后，会尝试对象的 toString() 方法尝试可否转化为 String，因此直接调用这个方法效率会更高

多个类型声明

在 JavaScript 中全部变量均可以使用单个 var 语句来声明，这样就是组合在一块儿的语句，以减小整个脚本的执行时间，就如上面代码同样，上面代码格式也挺规范，让人一看就明了。

插入迭代器

如 var name=values[i]; i++; 前面两条语句能够写成 var name=values[i++]

使用直接量

var aTest = new Array(); //替换为
var aTest = [];
var aTest = new Object; //替换为
var aTest = {};
var reg = new RegExp(); //替换为
var reg = /../;
//若是要建立具备一些特性的通常对象，也可使用字面量，以下：
var oFruit = new O;
oFruit.color = "red";
oFruit.name = "apple";
//前面的代码可用对象字面量来改写成这样：
var oFruit = { color: "red", name: "apple" };

使用 DocumentFragment 优化屡次 append

一旦须要更新 DOM, 请考虑使用文档碎片来构建 DOM 结构，而后再将其添加到现存的文档中。

for (var i = 0; i < 1000; i++) {
var el = document.createElement('p');
el.innerHTML = i;
document.body.appendChild(el);
}
//能够替换为：
var frag = document.createDocumentFragment();
for (var i = 0; i < 1000; i++) {
var el = document.createElement('p');
el.innerHTML = i;
frag.appendChild(el);
}
document.body.appendChild(frag);

使用一次 innerHTML 赋值代替构建 dom 元素

对于大的 DOM 更改，使用 innerHTML 要比使用标准的 DOM 方法建立一样的 DOM 结构快得多。

var frag = document.createDocumentFragment();
for (var i = 0; i < 1000; i++) {
var el = document.createElement('p');
el.innerHTML = i;
frag.appendChild(el);
}
document.body.appendChild(frag);
//能够替换为：
var html = [];
for (var i = 0; i < 1000; i++) {
html.push('<p>' + i + '</p>');
}
document.body.innerHTML = html.join('');

经过模板元素 clone，替代 createElement

不少人喜欢在 JavaScript 中使用 document.write 来给页面生成内容。事实上这样的效率较低，若是须要直接插入 HTML，能够找一个容器元素，好比指定一个 div 或者 span，并设置他们的 innerHTML 来将本身的 HTML 代码插入到页面中。一般咱们可能会使用字符串直接写 HTML 来建立节点，其实这样作，1 没法保证代码的有效性 2 字符串操做效率低，因此应该是用 document.createElement() 方法，而若是文档中存在现成的样板节点，应该是用 cloneNode() 方法，由于使用 createElement() 方法以后，你须要设置屡次元素的属性，使用 cloneNode() 则能够减小属性的设置次数——一样若是须要建立不少元素，应该先准备一个样板节点

var frag = document.createDocumentFragment();
for (var i = 0; i < 1000; i++) {
var el = document.createElement('p');
el.innerHTML = i;
frag.appendChild(el);
}
document.body.appendChild(frag);
//替换为：
var frag = document.createDocumentFragment();
var pEl = document.getElementsByTagName('p')[0];
for (var i = 0; i < 1000; i++) {
var el = pEl.cloneNode(false);
el.innerHTML = i;
frag.appendChild(el);
}
document.body.appendChild(frag);

使用 firstChild 和 nextSibling 代替 childNodes 遍历 dom 元素

var nodes = element.childNodes;
for (var i = 0, l = nodes.length; i < l; i++) {
var node = nodes[i];
//……
}
//能够替换为：
var node = element.firstChild;
while (node) {
//……
node = node.nextSibling;

删除 DOM 节点

删除 dom 节点以前, 必定要删除注册在该节点上的事件, 无论是用 observe 方式仍是用 attachEvent 方式注册的事件, 不然将会产生没法回收的内存。另外，在 removeChild 和 innerHTML=’’两者之间, 尽可能选择后者. 由于在 sIEve(内存泄露监测工具) 中监测的结果是用 removeChild 没法有效地释放 dom 节点

使用事件代理

任何能够冒泡的事件都不只仅能够在事件目标上进行处理，目标的任何祖先节点上也能处理，使用这个知识就能够将事件处理程序附加到更高的地方负责多个目标的事件处理，一样，对于内容动态增长而且子节点都须要相同的事件处理函数的状况，能够把事件注册提到父节点上，这样就不须要为每一个子节点注册事件监听了。另外，现有的 js 库都采用 observe 方式来建立事件监听, 其实现上隔离了 dom 对象和事件处理函数之间的循环引用, 因此应该尽可能采用这种方式来建立事件监听

重复使用的调用结果，事先保存到局部变量

//避免屡次取值的调用开销
var h1 = element1.clientHeight + num1;
var h4 = element1.clientHeight + num2;
//能够替换为：
var eleHeight = element1.clientHeight;
var h1 = eleHeight + num1;
var h4 = eleHeight + num2;

注意 NodeList

最小化访问 NodeList 的次数能够极大的改进脚本的性能

var images = document.getElementsByTagName('img');
for (var i = 0, len = images.length; i < len; i++) {
}

编写 JavaScript 的时候必定要知道什么时候返回 NodeList 对象，这样能够最小化对它们的访问

进行了对 getElementsByTagName() 的调用
获取了元素的 childNodes 属性
获取了元素的 attributes 属性
访问了特殊的集合，如 document.forms、document.images 等等

要了解了当使用 NodeList 对象时，合理使用会极大的提高代码执行速度

优化循环

可使用下面几种方式来优化循环

减值迭代

大多数循环使用一个从 0 开始、增长到某个特定值的迭代器，在不少状况下，从最大值开始，在循环中不断减值的迭代器更加高效

简化终止条件

因为每次循环过程都会计算终止条件，因此必须保证它尽量快，也就是说避免属性查找或者其它的操做，最好是将循环控制量保存到局部变量中，也就是说对数组或列表对象的遍历时，提早将 length 保存到局部变量中，避免在循环的每一步重复取值。

var list = document.getElementsByTagName('p');
for (var i = 0; i < list.length; i++) {
//……
}
//替换为：
var list = document.getElementsByTagName('p');
for (var i = 0, l = list.length; i < l; i++) {
//……
}

简化循环体

循环体是执行最多的，因此要确保其被最大限度的优化

使用后测试循环

在 JavaScript 中，咱们可使用 for(;;),while(),for(in) 三种循环，事实上，这三种循环中 for(in) 的效率极差，由于他须要查询散列键，只要能够，就应该尽可能少用。for(;;) 和 while 循环，while 循环的效率要优于 for(;;)，多是由于 for(;;) 结构的问题，须要常常跳转回去。

var arr = [1, 2, 3, 4, 5, 6, 7];
var sum = 0;
for (var i = 0, l = arr.length; i < l; i++) {
sum += arr[i];
}
//能够考虑替换为：
var arr = [1, 2, 3, 4, 5, 6, 7];
var sum = 0, l = arr.length;
while (l--) {
sum += arr[l];
}

最经常使用的 for 循环和 while 循环都是前测试循环，而如 do-while 这种后测试循环，能够避免最初终止条件的计算，所以运行更快。

展开循环

当循环次数是肯定的，消除循环并使用屡次函数调用每每会更快。

避免双重解释

若是要提升代码性能，尽量避免出现须要按照 JavaScript 解释的字符串，也就是

尽可能少使用 eval 函数

使用 eval 至关于在运行时再次调用解释引擎对内容进行运行，须要消耗大量时间，并且使用 Eval 带来的安全性问题也是不容忽视的。

不要使用 Function 构造器

不要给 setTimeout 或者 setInterval 传递字符串参数

var num = 0;
setTimeout('num++', 10);
//能够替换为：
var num = 0;
function addNum() {
num++;
}
setTimeout(addNum, 10);

缩短否认检测

if (oTest != '#ff0000') {
//do something
}
if (oTest != null) {
//do something
}
if (oTest != false) {
//do something
}
//虽然这些都正确，但用逻辑非操做符来操做也有一样的效果：
if (!oTest) {
//do something
}

条件分支

将条件分支，按可能性顺序从高到低排列：能够减小解释器对条件的探测次数
在同一条件子的多（>2）条件分支时，使用 switch 优于 if：switch 分支选择的效率高于 if，在 IE 下尤其明显。4 分支的测试，IE 下 switch 的执行时间约为 if 的一半。
使用三目运算符替代条件分支

if (a > b) {
num = a;
} else {
num = b;
}
//能够替换为：
num = a > b ? a : b;

使用常量

重复值: 任何在多处用到的值都应该抽取为一个常量
用户界面字符串: 任何用于显示给用户的字符串，都应该抽取出来以方便国际化
URLs: 在 Web 应用中，资源位置很容易变动，因此推荐用一个公共地方存放全部的 URL
任意可能会更改的值: 每当你用到字面量值的时候，你都要问一下本身这个值在将来是否是会变化，若是答案是 “是”，那么这个值就应该被提取出来做为一个常量。

避免与 null 进行比较

因为 JavaScript 是弱类型的，因此它不会作任何的自动类型检查，因此若是看到与 null 进行比较的代码，尝试使用如下技术替换

若是值应为一个引用类型，使用 instanceof 操做符检查其构造函数
若是值应为一个基本类型，做用 typeof 检查其类型
若是是但愿对象包含某个特定的方法名，则使用 typeof 操做符确保指定名字的方法存在于对象上

避免全局量

全局变量应该所有字母大写，各单词之间用_下划线来链接。尽量避免全局变量和函数, 尽可能减小全局变量的使用，由于在一个页面中包含的全部 JavaScript 都在同一个域中运行。因此若是你的代码中声明了全局变量或者全局函数的话，后面的代码中载入的脚本文件中的同名变量和函数会覆盖掉（overwrite）你的。

//糟糕的全局变量和全局函数
var current = null;
function init(){
//...
}
function change() {
//...
}
function verify() {
//...
}
//解决办法有不少，Christian Heilmann建议的方法是：
//若是变量和函数不须要在“外面”引用，那么就可使用一个没有名字的方法将他们全都包起来。
(function(){
var current = null;
function init() {
//...
}
function change() {
//...
}
function verify() {
//...
}
})();
//若是变量和函数须要在“外面”引用，须要把你的变量和函数放在一个“命名空间”中
//咱们这里用一个function作命名空间而不是一个var，由于在前者中声明function更简单，并且能保护隐私数据
myNameSpace = function() {
var current = null;
function init() {
//...
}
function change() {
//...
}
function verify() {
//...
}
//全部须要在命名空间外调用的函数和属性都要写在return里面
return {
init: init,
//甚至你能够为函数和属性命名一个别名
set: change
};
};

尊重对象的全部权

由于 JavaScript 能够在任什么时候候修改任意对象，这样就能够以不可预计的方式覆写默认的行为，因此若是你不负责维护某个对象，它的对象或者它的方法，那么你就不要对它进行修改，具体一点就是说：

不要为实例或原型添加属性
不要为实例或者原型添加方法
不要重定义已经存在的方法
不要重复定义其它团队成员已经实现的方法，永远不要修改不是由你全部的对象，你能够经过如下方式为对象建立新的功能:
建立包含所需功能的新对象，并用它与相关对象进行交互
建立自定义类型，继承须要进行修改的类型，而后能够为自定义类型添加额外功能

循环引用

若是循环引用中包含 DOM 对象或者 ActiveX 对象，那么就会发生内存泄露。内存泄露的后果是在浏览器关闭前，即便是刷新页面，这部份内存不会被浏览器释放。

简单的循环引用：

var el = document.getElementById('MyElement');
var func = function () {
//…
}
el.func = func;
func.element = el;

可是一般不会出现这种状况。一般循环引用发生在为 dom 元素添加闭包做为 expendo 的时候。

function init() {
var el = document.getElementById('MyElement');
el.onclick = function () {
//……
}
}
init();

init 在执行的时候，当前上下文咱们叫作 context。这个时候，context 引用了 el，el 引用了 function，function 引用了 context。这时候造成了一个循环引用。

下面 2 种方法能够解决循环引用：

1.置空 dom 对象

function init() {
var el = document.getElementById('MyElement');
el.onclick = function () {
//……
}
}
init();
//能够替换为：
function init() {
var el = document.getElementById('MyElement');
el.onclick = function () {
//……
}
el = null;
}
init();

将 el 置空，context 中不包含对 dom 对象的引用，从而打断循环应用。

若是咱们须要将 dom 对象返回，能够用以下方法：

function init() {
var el = document.getElementById('MyElement');
el.onclick = function () {
//……
}
return el;
}
init();
//能够替换为：
function init() {
var el = document.getElementById('MyElement');
el.onclick = function () {
//……
}
try {
return el;
} finally {
el = null;
}
}
init();

2. 构造新的 context

function init() {
var el = document.getElementById('MyElement');
el.onclick = function () {
//……
}
}
init();
//能够替换为：
function elClickHandler() {
//……
}
function init() {
var el = document.getElementById('MyElement');
el.onclick = elClickHandler;
}
init();

把 function 抽到新的 context 中，这样，function 的 context 就不包含对 el 的引用，从而打断循环引用。

经过 javascript 建立的 dom 对象，必须 append 到页面中

IE 下，脚本建立的 dom 对象，若是没有 append 到页面中，刷新页面，这部份内存是不会回收的！

function create() {
var gc = document.getElementById('GC');
for (var i = 0; i < 5000; i++) {
var el = document.createElement('div');
el.innerHTML = "test";
//下面这句能够注释掉，看看浏览器在任务管理器中，点击按钮而后刷新后的内存变化
gc.appendChild(el);
}
}

释放 dom 元素占用的内存

将 dom 元素的 innerHTML 设置为空字符串，能够释放其子元素占用的内存。

在 rich 应用中，用户也许会在一个页面上停留很长时间，可使用该方法释放积累得愈来愈多的 dom 元素使用的内存。

释放 javascript 对象

在 rich 应用中，随着实例化对象数量的增长，内存消耗会愈来愈大。因此应当及时释放对对象的引用，让 GC 可以回收这些内存控件。

对象： obj = null

对象属性： delete obj.myproperty

数组 item：使用数组的 splice 方法释放数组中不用的 item

避免 string 的隐式装箱

对 string 的方法调用，好比'xxx'.length，浏览器会进行一个隐式的装箱操做，将字符串先转换成一个 String 对象。推荐对声明有可能使用 String 实例方法的字符串时，采用以下写法：

var myString = new String('Hello World');

松散耦合

一、解耦 HTML/JavaScript

JavaScript 和 HTML 的紧密耦合：直接写在 HTML 中的 JavaScript、使用包含内联代码的 <script> 元素、使用 HTML 属性来分配事件处理程序等

HTML 和 JavaScript 的紧密耦合：JavaScript 中包含 HTML，而后使用 innerHTML 来插入一段 html 文本到页面

其实应该是保持层次的分离，这样能够很容易的肯定错误的来源，因此咱们应确保 HTML 呈现应该尽量与 JavaScript 保持分离

二、解耦 CSS/JavaScript

显示问题的惟一来源应该是 CSS，行为问题的惟一来源应该是 JavaScript，层次之间保持松散耦合才可让你的应用程序更加易于维护，因此像如下的代码 element.style.color="red" 尽可能改成 element.className="edit"，并且不要在 css 中经过表达式嵌入 JavaScript

三、解耦应用程序 / 事件处理程序

将应用逻辑和事件处理程序相分离：一个事件处理程序应该从事件对象中提取，并将这些信息传送给处理应用逻辑的某个方法中。这样作的好处首先可让你更容易更改触发特定过程的事件，其次能够在不附加事件的状况下测试代码，使其更易建立单元测试

性能方面的注意事项

一、尽可能使用原生方法

二、switch 语句相对 if 较快

经过将 case 语句按照最可能到最不可能的顺序进行组织

三、位运算较快

当进行数字运算时，位运算操做要比任何布尔运算或者算数运算快

四、巧用 ||和 && 布尔运算符

function eventHandler(e) {
if (!e) e = window.event;
}
//能够替换为：
function eventHandler(e) {
e = e || window.event;
}

if (myobj) {
doSomething(myobj);
}
//能够替换为：
myobj && doSomething(myobj);

避免错误应注意的地方

一、每条语句末尾须加分号

在 if 语句中，即便条件表达式只有一条语句也要用 {} 把它括起来，以避免后续若是添加了语句以后形成逻辑错误

二、使用 + 号时需谨慎

JavaScript 和其余编程语言不一样的是，在 JavaScript 中，'+'除了表示数字值相加，字符串相链接之外，还能够做一元运算符用，把字符串转换为数字。于是若是使用不当，则可能与自增符'++'混淆而引发计算错误

var valueA = 20;
var valueB = "10";
alert(valueA + valueB); //ouput: 2010
alert(valueA + (+valueB)); //output: 30
alert(valueA + +valueB); //output:30
alert(valueA ++ valueB); //Compile error

三、使用 return 语句须要注意

一条有返回值的 return 语句不要用 () 括号来括住返回值，若是返回表达式，则表达式应与 return 关键字在同一行，以免压缩时，压缩工具自动加分号而形成返回与开发人员不一致的结果

function F1() {
var valueA = 1;
var valueB = 2;
return valueA + valueB;
}
function F2() {
var valueA = 1;
var valueB = 2;
return
valueA + valueB;
}
alert(F1()); //output: 3
alert(F2()); //ouput: undefined

== 和 === 的区别

避免在 if 和 while 语句的条件部分进行赋值，如 if (a = b)，应该写成 if (a == b)，可是在比较是否相等的状况下，最好使用全等运行符，也就是使用 === 和!== 操做符会相对于 == 和!= 会好点。== 和!= 操做符会进行类型强制转换

var valueA = "1";
var valueB = 1;
if (valueA == valueB) {
alert("Equal");
}
else {
alert("Not equal");
}
//output: "Equal"
if (valueA === valueB) {
alert("Equal");
}
else {
alert("Not equal");
}
//output: "Not equal"

不要使用生偏语法

不要使用生偏语法，写让人迷惑的代码，虽然计算机可以正确识别并运行，可是晦涩难懂的代码不方便之后维护

函数返回统一类型

虽然 JavaScript 是弱类型的，对于函数来讲，前面返回整数型数据，后面返回布尔值在编译和运行均可以正常经过，但为了规范和之后维护时容易理解，应保证函数应返回统一的数据类型

老是检查数据类型

要检查你的方法输入的全部数据，一方面是为了安全性，另外一方面也是为了可用性。用户随时随地都会输入错误的数据。这不是由于他们蠢，而是由于他们很忙，而且思考的方式跟你不一样。用 typeof 方法来检测你的 function 接受的输入是否合法

什么时候用单引号，什么时候用双引号

虽然在 JavaScript 当中，双引号和单引号均可以表示字符串, 为了不混乱，咱们建议在 HTML 中使用双引号，在 JavaScript 中使用单引号，但为了兼容各个浏览器，也为了解析时不会出错，定义 JSON 对象时，最好使用双引号

部署

用 JSLint 运行 JavaScript 验证器来确保没有语法错误或者是代码没有潜在的问
部署以前推荐使用压缩工具将 JS 文件压缩
文件编码统一用 UTF-8
JavaScript 程序应该尽可能放在 .js 的文件中，须要调用的时候在 HTML 中以 <script src="filename.js"> 的形式包含进来。JavaScript 代码若不是该 HTML 文件所专用的，则应尽可能避免在 HTML 文件中直接编写 JavaScript 代码。由于这样会大大增长 HTML 文件的大小，无益于代码的压缩和缓存的使用。另外， <script src="filename.js"> 标签应尽可能放在文件的后面, 最好是放在 </body > 标签前。这样会下降因加载 JavaScript 代码而影响页面中其它组件的加载时间。

永远不要忽略代码优化工做，重构是一项从项目开始到结束须要持续的工做，只有不断的优化代码才能让代码的执行效率愈来愈好。