性能javascript,性能车是什么意思

如何优化javascript性能优化

前言

成都创新互联专注于内黄企业网站建设,成都响应式网站建设,电子商务商城网站建设。内黄网站建设公司,为内黄等地区提供建站服务。全流程定制设计，专业设计，全程项目跟踪，成都创新互联专业和态度为您提供的服务

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

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

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

避免全局查找

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

function search() {

//当我要使用当前页面地址和主机域名

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;

如何编写高性能的 javascript

一．Javascript代码执行效率

1. DOM

1.1 使用 DocumentFragment 优化多次 append

说明：添加多个 dom 元素时，先将元素 append 到 DocumentFragment 中，最后统一将 DocumentFragment 添加到页面。

该做法可以减少页面渲染 dom 元素的次数。经 IE 和 Fx 下测试，在 append1000 个元素时，效率能提高 10%-30% ， Fx 下提升较为明显。

服用前：

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);

1.2 通过模板元素 clone ，替代 createElement

说明：通过一个模板 dom 对象 cloneNode ，效率比直接创建 element 高。性能提高不明显，约为 10% 左右。在低于 100 个元素 create 和 append 操作时，没有优势。

服用前：

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);

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

说明：根据数据构建列表样式的时候，使用设置列表容器 innerHTML 的方式，比构建 dom 元素并 append 到页面中的方式，效率有数量级上的提高。

服用前：

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('

' + i + '

');

}

document.body.innerHTML = html.join('');

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

说明：约能获得 30%-50% 的性能提高。逆向遍历时使用 lastChild 和 previousSibling 。

服用前：

var nodes = element.childNodes;

for (var i = 0, l = nodes.length; i l; i++) {

var node = nodes[i];

……

}

服用后：

var node = element.firstChild;

while (node) {

……

nodenode = node.nextSibling;

}

2. 字符串

2.1 使用 Array 做为 StringBuffer ，代替字符串拼接的操作

说明： IE 在对字符串拼接的时候，会创建临时的 String 对象；经测试，在 IE 下，当拼接的字符串越来越大时，运行效率会急剧下降。 Fx 和 Opera 都 对字符串拼接操作进行了优化；经测试，在 Fx 下，使用 Array 的 join 方式执行时间约为直接字符串拼接的 1.4 倍。

服用前：

var now = new Date();

var str = '';

for (var i = 0; i 10000; i++) {

str += '123456789123456789';

}

alert(new Date() - now);

服用后：

var now = new Date();

var strBuffer = [];

for (var i = 0; i 10000; i++) {

strBuffer.push('123456789123456789');

}

var str = strBuffer.join('');

alert(new Date() - now);

3. 循环语句

3.1 将循环控制量保存到局部变量

说明：对数组和列表对象的遍历时，提前将 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++) {

……

}

3.2 顺序无关的遍历时，用 while 替代 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];

}

4. 条件分支

4.1 将条件分支，按可能性顺序从高到低排列

说明：可以减少解释器对条件的探测次数。

4.2 在同一条件子的多（ 2 ）条件分支时，使用 switch 优于 if

说明： switch 分支选择的效率高于 if ，在 IE 下尤为明显。 4 分支的测试， IE 下 switch 的执行时间约为 if 的一半。

4.3 使用三目运算符替代条件分支

服用前：

if (a b) {

num = a;

} else {

num = b;

}

服用后：

num = a b ? a : b;

5. 定时器

5.1 需要不断执行的时候，优先考虑使用 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);

5.2 使用 function 而不是 string

说明：如果把字符串作为 setTimeout 和 setInterval 的参数，浏览器会先用这个字符串构建一个 function 。

服用前：

var num = 0;

setTimeout('num++', 10);

服用后：

var num = 0;

function addNum () {

num++;

}

setTimeout(addNum, 10);

6. 其他

6.1 尽量不使用动态语法元素

说明： eval 、 Function 、 execScript 等语句会再次使用 javascript 解析引擎进行解析，需要消耗大量的执行时间。

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

说明：避免多次取值的调用开销。

服用前：

var h1 = element1.clientHeight + num1;

var h2 = element1.clientHeight + num2;

服用后：

var eleHeight = element1.clientHeight;

var h1 = eleHeight + num1;

var h2 = eleHeight + num2;

6.3 使用直接量

说明：

var a = new Array(param,param,...) - var a = []

var foo = new Object() - var foo = {}

var reg = new RegExp() - var reg = /.../

6.4 避免使用 with

说明： with 虽然可以缩短代码量，但是会在运行时构造一个新的 scope 。

OperaDev 上还有这样的解释，使用 with 语句会使得解释器无法在语法解析阶段对代码进行优化。对此说法，无法验证。

服用前：

with (a.b.c.d) {

property1 = 1;

property2 = 2;

}

服用后：

var obj = a.b.c.d;

obj.property1 = 1;

obj.property2 = 2;

6.5 巧用 || 和 布尔运算符

重要程度： ★★★

服用前：

function eventHandler (e) {

if(!e) e = window.event;

}

服用后：

function eventHandler (e) {

ee = e || window.event;

}

服用前：

if (myobj) {

doSomething(myobj);

}

服用后：

myobj doSomething(myobj);

6.6 类型转换

说明：

1). 数字转换成字符串，应用 "" + 1 ，性能上： ("" +) String() .toString() new String() ；

2). 浮点数转换成整型，不使用 parseInt() ， parseInt() 是用于将字符串转换成数字，而不是浮点数和整型之间的转换，建议使用 Math.floor() 或者 Math.round()

3). 对于自定义的对象，推荐显式调用 toString() 。内部操作在尝试所有可能性之后，会尝试对象的 toString() 方法尝试能否转化为 String 。

二．内存管理

2.1 循环引用

说明：如果循环引用中包含 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 的引用，从而打断循环引用。

2.2 通过 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);

}

}

2.3 释放 dom 元素占用的内存

说明：

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

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

2.4 释放 javascript 对象

说明：在 rich 应用中，随着实例化对象数量的增加，内存消耗会越来越大。所以应当及时释放对对象的引用，让 GC 能够回收这些内存控件。

对象： obj = null

对象属性： delete obj.myproperty

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

2.5 避免 string 的隐式装箱

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

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

如何编写高性能的javascript

一．Javascript代码执行效率

1. DOM

1.1 使用 DocumentFragment 优化多次 append

说明：添加多个 dom 元素时，先将元素 append 到 DocumentFragment 中，最后统一将 DocumentFragment 添加到页面。

该做法可以减少页面渲染 dom 元素的次数。经 IE 和 Fx 下测试，在 append1000 个元素时，效率能提高 10%-30% ， Fx 下提升较为明显。

服用前：

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);

1.2 通过模板元素 clone ，替代 createElement

说明：通过一个模板 dom 对象 cloneNode ，效率比直接创建 element 高。性能提高不明显，约为 10% 左右。在低于 100 个元素 create 和 append 操作时，没有优势。

服用前：

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);

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

说明：根据数据构建列表样式的时候，使用设置列表容器 innerHTML 的方式，比构建 dom 元素并 append 到页面中的方式，效率有数量级上的提高。

服用前：

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('

' + i + '

');

}

document.body.innerHTML = html.join('');

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

说明：约能获得 30%-50% 的性能提高。逆向遍历时使用 lastChild 和 previousSibling 。

服用前：

var nodes = element.childNodes;

for (var i = 0, l = nodes.length; i l; i++) {

var node = nodes[i];

……

}

服用后：

var node = element.firstChild;

while (node) {

……

nodenode = node.nextSibling;

}

2. 字符串

2.1 使用 Array 做为 StringBuffer ，代替字符串拼接的操作

说明： IE 在对字符串拼接的时候，会创建临时的 String 对象；经测试，在 IE 下，当拼接的字符串越来越大时，运行效率会急剧下降。 Fx 和 Opera 都 对字符串拼接操作进行了优化；经测试，在 Fx 下，使用 Array 的 join 方式执行时间约为直接字符串拼接的 1.4 倍。

服用前：

var now = new Date();

var str = '';

for (var i = 0; i 10000; i++) {

str += '123456789123456789';

}

alert(new Date() - now);

服用后：

var now = new Date();

var strBuffer = [];

for (var i = 0; i 10000; i++) {

strBuffer.push('123456789123456789');

}

var str = strBuffer.join('');

alert(new Date() - now);

3. 循环语句

3.1 将循环控制量保存到局部变量

说明：对数组和列表对象的遍历时，提前将 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++) {

……

}

3.2 顺序无关的遍历时，用 while 替代 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];

}

4. 条件分支

4.1 将条件分支，按可能性顺序从高到低排列

说明：可以减少解释器对条件的探测次数。

4.2 在同一条件子的多（ 2 ）条件分支时，使用 switch 优于 if

说明： switch 分支选择的效率高于 if ，在 IE 下尤为明显。 4 分支的测试， IE 下 switch 的执行时间约为 if 的一半。

4.3 使用三目运算符替代条件分支

服用前：

if (a b) {

num = a;

} else {

num = b;

}

服用后：

num = a b ? a : b;

5. 定时器

5.1 需要不断执行的时候，优先考虑使用 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);

5.2 使用 function 而不是 string

说明：如果把字符串作为 setTimeout 和 setInterval 的参数，浏览器会先用这个字符串构建一个 function 。

服用前：

var num = 0;

setTimeout('num++', 10);

服用后：

var num = 0;

function addNum () {

num++;

}

setTimeout(addNum, 10);

6. 其他

6.1 尽量不使用动态语法元素

说明： eval 、 Function 、 execScript 等语句会再次使用 javascript 解析引擎进行解析，需要消耗大量的执行时间。

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

说明：避免多次取值的调用开销。

服用前：

var h1 = element1.clientHeight + num1;

var h2 = element1.clientHeight + num2;

服用后：

var eleHeight = element1.clientHeight;

var h1 = eleHeight + num1;

var h2 = eleHeight + num2;

6.3 使用直接量

说明：

var a = new Array(param,param,...) - var a = []

var foo = new Object() - var foo = {}

var reg = new RegExp() - var reg = /.../

6.4 避免使用 with

说明： with 虽然可以缩短代码量，但是会在运行时构造一个新的 scope 。

OperaDev 上还有这样的解释，使用 with 语句会使得解释器无法在语法解析阶段对代码进行优化。对此说法，无法验证。

服用前：

with (a.b.c.d) {

property1 = 1;

property2 = 2;

}

服用后：

var obj = a.b.c.d;

obj.property1 = 1;

obj.property2 = 2;

6.5 巧用 || 和 布尔运算符

重要程度： ★★★

服用前：

function eventHandler (e) {

if(!e) e = window.event;

}

服用后：

function eventHandler (e) {

ee = e || window.event;

}

服用前：

if (myobj) {

doSomething(myobj);

}

服用后：

myobj doSomething(myobj);

6.6 类型转换

说明：

1). 数字转换成字符串，应用 "" + 1 ，性能上： ("" +) String() .toString() new String() ；

2). 浮点数转换成整型，不使用 parseInt() ， parseInt() 是用于将字符串转换成数字，而不是浮点数和整型之间的转换，建议使用 Math.floor() 或者 Math.round()

3). 对于自定义的对象，推荐显式调用 toString() 。内部操作在尝试所有可能性之后，会尝试对象的 toString() 方法尝试能否转化为 String 。

二．内存管理

2.1 循环引用

说明：如果循环引用中包含 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 的引用，从而打断循环引用。

2.2 通过 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);

}

}

2.3 释放 dom 元素占用的内存

说明：

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

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

2.4 释放 javascript 对象

说明：在 rich 应用中，随着实例化对象数量的增加，内存消耗会越来越大。所以应当及时释放对对象的引用，让 GC 能够回收这些内存控件。

对象： obj = null

对象属性： delete obj.myproperty

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

2.5 避免 string 的隐式装箱

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

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

如何改进javascript代码的性能

而现在Ajax则是最为流行的一种方式。javascript是一种解释型语言，所以能无法达到和C/Java之类的水平，限制了它能在客户端所做的事情，为了能改进他的性能，我想基于我以前给JavaScript做过的很多测试来谈谈自己的经验，希望能帮助大家改进自己的JavaScript脚本性能。

语言层次方面循环循环是很常用的一个控制结构，大部分东西要依靠它来完成，在JavaScript中，我们可以使用for(;;),while(),for(in)三种循环，事实上，这三种循环中for(in)的效率极差，因为他需要查询散列键，只要可以就应该尽量少用。for(;;)和while循环的性能应该说基本(平时使用时)等价。

如果是循环变量递增或递减，不要单独对循环变量赋值，应该在它最后一次读取的时候使用嵌套的++或—操作符。

如果要与数组的长度作比较，应该事先把数组的length属性放入一个局部变量中，减少查询次数。

局部变量和全局变量

局部变量的速度要比全局变量的访问速度更快，因为全局变量其实是全局对象的成员，而局部变量是放在函数的栈当中的。

不使用Eval使用eval相当于在运行时再次调用解释引擎对内容进行运行，需要消耗大量时间。这时候使用JavaScript所支持的闭包可以实现函数模版(关于闭包的内容请参考函数式编程的有关内容)减少对象查找

因为JavaScript的解释性，所以a.b.c.d.e，需要进行至少4次查询操作，先检查a再检查a中的b，再检查b中的c，如此往下。所以如果这样的表达式重复出现，只要可能，应该尽量少出现这样的表达式，可以利用局部变量，把它放入一个临时的地方进行查询。

这一点可以和循环结合起来，因为我们常常要根据字符串、数组的长度进行循环，而通常这个长度是不变的，比如每次查询a.length，就要额外进行一个操作，而预先把var len=a.length，则就少了一次查询。

字符串连接如果是追加字符串，最好使用s+=anotherStr操作，而不是要使用s=s+anotherStr。

如果要连接多个字符串，应该少使用+=，如

s+=a;s+=b;s+=c;

应该写成

s+=a + b + c;

以下是引用片段：

varbuf=newArray();for(vari=0;i100;i++){buf.push(i.toString());}varall=buf.join("");类型转换类型转换是大家常犯的错误，因为JavaScript是动态类型语言，你不能指定变量的类型。

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

以下是引用片段：

(""+)String().toString()newString()

这条其实和下面的“直接量”有点类似，尽量使用编译时就能使用的内部操作要比运行时使用的用户操作要快。

String()属于内部函数，所以速度很快，而.toString()要查询原型中的函数，所以速度逊色一些，new String()用于返回一个精确的副本。

2. 浮点数转换成整型，这个更容易出错，很多人喜欢使用parseInt()，其实parseInt()是用于将字符串转换成数字，而不是浮点数和整型之间的转换，我们应该使用Math.floor()或者Math.round()。

另外，和第二节的对象查找中的问题不一样，Math是内部对象，所以Math.floor()其实并没有多少查询方法和调用的时间，速度是最快的。

javascript是什么意思

JavaScript是一种基于对象和事件驱动并具有安全性能的脚本语言。

Javascript脚本语言同其他语言一样，有它自身的基本数据类型，表达式和算术运算符及程序的基本程序框架。Javascript提供了四种基本的数据类型和两种特殊数据类型用来处理数据和文字。而变量提供存放信息的地方，表达式则可以完成较复杂的信息处理。

JavaScript与Java的不同点

Java代码必须编译才能执行，而JavaScript不需编译，只需浏览器解释执行。

Java和JavaScript虽然都可以在服务器与客户端执行，但Java多运行于服务器，而JavaScript多运行于客户端。

JavaScript使用的是松散型的数据类型，而Java则使用的是严谨的数据类型。