45 conseils de développement JavaScript

JavaScript est le langage de programmation le plus populaire au monde et peut être utilisé pour le développement Web, le développement d'applications mobiles (PhoneGap, Appcelerator), le développement côté serveur (Node.js et Wakanda), etc. JavaScript est également le premier langage permettant à de nombreux novices d'entrer dans le monde de la programmation. Il peut être utilisé pour afficher une simple boîte de dialogue dans le navigateur ou pour contrôler le robot via nodebot ou nodruino. Les développeurs capables d'écrire du code JavaScript avec une structure claire et des performances élevées sont désormais les personnes les plus recherchées sur le marché du recrutement.

Dans cet article, je partagerai quelques astuces, secrets et bonnes pratiques JavaScript, à l'exception de quelques-uns, qu'il s'agisse du moteur JavaScript du navigateur ou de l'interpréteur JavaScript côté serveur, tous applicables.

L'exemple de code présenté dans cet article a réussi le test sur la dernière version de Google Chrome 30 (V8 3.20.17.15).

1. Assurez-vous d'utiliser le mot-clé var lors de l'attribution d'une valeur à une variable pour la première fois

Si une variable est affectée directement sans déclaration, elle sera utilisée comme une nouvelle. variable globale par défaut. Essayez d'éviter d'utiliser des variables globales.

2. Utilisez === au lieu de ==

== et l'opérateur != convertira automatiquement le type de données si nécessaire. Mais === et !== ne le font pas, ils comparent les valeurs et les types de données en même temps, ce qui les rend également plus rapides que == et !=.

[10] === 10    // is false
[10]  == 10    // is true
'10' == 10     // is true
'10' === 10    // is false
 []   == 0     // is true
 [] ===  0     // is false
 '' == false   // is true but true == "a" is false
 '' === false  // is false

3. Les résultats logiques des chaînes sous-finisées, nulles, 0, fausses, NaN et vides sont faux

4 Utilisez un point-virgule à la fin de la ligne

Pratique Il est préférable d'utiliser un point-virgule. Ce n'est pas grave si vous oubliez de l'écrire. Dans la plupart des cas, l'interpréteur JavaScript l'ajoutera automatiquement. Pour plus d'informations sur les raisons pour lesquelles les points-virgules sont utilisés, veuillez consulter l'article La vérité sur les points-virgules en JavaScript.

5. Utilisez le constructeur d'objet

function Person(firstName, lastName){
    this.firstName =  firstName;
    this.lastName = lastName;
}
var Saad = new Person("Saad", "Mousliki");

6. Utilisez typeof, instanceof et le constructeur avec précaution

• typeof : opérateur unaire JavaScript, utilisez pour renvoyer. le type original de la variable sous la forme d'une chaîne, notez que typeof null renverra également un objet, et la plupart des types d'objet (tableau Tableau, heure Date, etc.) renverront également un objet

• constructeur : attribut de prototype interne, qui peut être remplacé via le code

• instanceof : opérateur JavaScript, qui sera recherché dans le constructeur dans la chaîne de prototypes. S'il est trouvé, il retournera vrai. , sinon il retournera false

var arr = ["a", "b", "c"];
typeof arr;   // 返回 "object" 
arr instanceof Array // true
arr.constructor();  //[]

7. Utiliser des fonctions auto-invoquées

La fonction est automatiquement exécutée directement après la création, généralement appelée anonyme auto-invoquée. fonction (fonction anonyme auto-invoquée) ou expression de fonction directement invoquée immédiatement. Le format est le suivant :

(function(){
    // 置于此处的代码将自动执行
})();  
(function(a,b){
    var result = a+b;
    return result;
})(10,20)

8. Obtenez aléatoirement des membres du tableau

var items = [12, 548 , 'a' , 2 , 5478 , 'foo' , 8852, , 'Doe' , 2145 , 119];
var  randomItem = items[Math.floor(Math.random() * items.length)];

9. Obtenez des nombres aléatoires dans la plage spécifiée

Cette fonction est. utilisé pour générer des tests Les fausses données sont particulièrement courantes, comme les salaires dans une fourchette spécifiée.

var x = Math.floor(Math.random() * (max - min + 1)) + min;

10. Générez un tableau numérique de 0 à la valeur spécifiée

var numbersArray = [] , max = 100;
for( var i=1; numbersArray.push(i++) < max;);  // numbers = [1,2,3 ... 100]

11. Générez une chaîne alphanumérique aléatoire

function generateRandomAlphaNum(len) {
    var rdmString = "";
    for( ; rdmString.length < len; rdmString  += Math.random().toString(36).substr(2));
    return  rdmString.substr(0, len);
}

12. ordre du tableau de nombres aléatoires

var numbers = [5, 458 , 120 , -215 , 228 , 400 , 122205, -85411];
numbers = numbers.sort(function(){ return Math.random() - 0.5});
/* numbers 数组将类似于 [120, 5, 228, -215, 400, 458, -85411, 122205]  */

La fonction de tri de tableau intégrée de JavaScript est utilisée ici. Une meilleure façon est d'utiliser un code spécialisé pour l'implémenter (comme l'algorithme de Fisher-Yates). pouvez voir cette discussion sur StackOverFlow .

13. Suppression de l'espace de chaîne

Java, C#, PHP et d'autres langages ont implémenté des fonctions spéciales de suppression d'espace de chaîne, mais elles ne sont pas disponibles en JavaScript. faites cette fonction d'objet String et une fonction trim :

String.prototype.trim = function(){return this.replace(/^\s+|\s+$/g, "");};

Le nouveau moteur JavaScript a déjà une implémentation native de trim().

14. Ajouter entre les tableaux

var array1 = [12 , "foo" , {name "Joe"} , -2458];
var array2 = ["Doe" , 555 , 100];
Array.prototype.push.apply(array1, array2);
/* array1 值为  [12 , "foo" , {name "Joe"} , -2458 , "Doe" , 555 , 100] */

15. Convertir les objets en tableaux

var argArray = Array.prototype.slice.call(arguments);

16. Vérifiez s'il s'agit d'un nombre

function isNumber(n){
    return !isNaN(parseFloat(n)) && isFinite(n);
}

17 Vérifiez s'il s'agit d'un tableau

function isArray(obj){
    return Object.prototype.toString.call(obj) === '[object Array]' ;
}

Mais si la méthode toString() est remplacée, elle ne le sera pas. travail. . Vous pouvez également utiliser la méthode suivante :

Array.isArray(obj); // its a new Array method

Si vous n'utilisez pas de frame dans le navigateur, vous pouvez également utiliser instanceof, mais si le contexte est trop complexe, des erreurs peuvent survenir.

var myFrame = document.createElement('iframe');
document.body.appendChild(myFrame);
var myArray = window.frames[window.frames.length-1].Array;
var arr = new myArray(a,b,10); // [a,b,10]  
// myArray 的构造器已经丢失，instanceof 的结果将不正常
// 构造器是不能跨 frame 共享的
arr instanceof Array; // false

18. Obtenez les valeurs maximales et minimales dans le tableau

var  numbers = [5, 458 , 120 , -215 , 228 , 400 , 122205, -85411]; 
var maxInNumbers = Math.max.apply(Math, numbers); 
var minInNumbers = Math.min.apply(Math, numbers);

19. Effacez le tableau

var myArray = [12 , 222 , 1000 ];  
myArray.length = 0; // myArray will be equal to [].

20. directement à partir du tableau Ou supprimer l'élément

Si delete est utilisé directement sur l'élément du tableau, il n'est pas supprimé, mais l'élément est défini sur non défini. La suppression des éléments du tableau doit utiliser splice.

À ne pas faire :

var items = [12, 548 ,'a' , 2 , 5478 , 'foo' , 8852, , 'Doe' ,2154 , 119 ]; 
items.length; // return 11 
delete items[3]; // return true 
items.length; // return 11 
/* items 结果为 [12, 548, "a", undefined × 1, 5478, "foo", 8852, undefined ×
 1, "Doe", 2154, 119] */

Au lieu de cela :

var items = [12, 548 ,'a' , 2 , 5478 , 'foo' , 8852, , 'Doe' ,2154 , 119 ]; 
items.length; // return 11 
items.splice(3,1) ; 
items.length; // return 10 
/* items 结果为 [12, 548, "a", 5478, "foo", 8852, undefined × 1, "Doe", 2154, 119]

Vous pouvez utiliser delete lors de la suppression des propriétés d'un objet.

21. Utilisez l'attribut length pour tronquer le tableau

Dans l'exemple précédent, l'attribut length est utilisé pour effacer le tableau. Vous pouvez également l'utiliser pour tronquer le tableau :

var myArray = [12 , 222 , 1000 , 124 , 98 , 10 ];  
myArray.length = 4; // myArray will be equal to [12 , 222 , 1000 , 124].

En même temps, si l'attribut length est agrandi, la valeur de longueur du tableau augmentera et undefined sera utilisé comme nouvel élément à remplir. la longueur est une propriété accessible en écriture.

myArray.length = 10; // the new array length is 10 
myArray[myArray.length - 1] ; // undefined

22. Utiliser le ET logique ou dans des conditions

var foo = 10;  
foo == 10 && doSomething(); // is the same thing as if (foo == 10) doSomething(); 
foo == 5 || doSomething(); // is the same thing as if (foo != 5) doSomething();

Le OU logique peut également être utilisé pour définir des valeurs par défaut, telles que les valeurs par défaut des paramètres de fonction.

function doSomething(arg1){ 
    arg1 = arg1 || 10; // arg1 will have 10 as a default value if it’s not already set
}

23. Faites boucler la méthode de la fonction map() sur les données

var squares = [1,2,3,4].map(function (val) {  
    return val * val;  
}); 
// squares will be equal to [1, 4, 9, 16]

24. Conservez le nombre de décimales spécifié

var num =2.443242342;
num = num.toFixed(4);  // num will be equal to 2.4432

Remarque. que toFixec() Ce qui est renvoyé est une chaîne, pas un nombre.

25. Problèmes avec les calculs en virgule flottante

0.1 + 0.2 === 0.3 // is false 
9007199254740992 + 1 // is equal to 9007199254740992
9007199254740992 + 2 // is equal to 9007199254740994

Pourquoi ? Parce que 0,1 0,2 est égal à 0,30000000000000004. Les nombres JavaScript sont construits conformément à la norme IEEE 754 et sont représentés en interne par des décimales à virgule flottante de 64 bits. Pour plus de détails, veuillez vous référer à la façon dont les nombres en JavaScript sont codés

en utilisant toFixed(). et toPrecision() Résolvez ce problème.

26、通过for-in循环检查对象的属性

下面这样的用法，可以防止迭代的时候进入到对象的原型属性中。

for (var name in object) {  
    if (object.hasOwnProperty(name)) { 
        // do something with name
    }  
}

27、逗号操作符

var a = 0; 
var b = ( a++, 99 ); 
console.log(a);  // a will be equal to 1 
console.log(b);  // b is equal to 99

28、临时存储用于计算和查询的变量

在jQuery选择器中，可以临时存储整个DOM元素。

var navright = document.querySelector('#right'); 
var navleft = document.querySelector('#left'); 
var navup = document.querySelector('#up'); 
var navdown = document.querySelector('#down');

29、提前检查传入isFinite()的参数

isFinite(0/0) ; // false
isFinite("foo"); // false
isFinite("10"); // true
isFinite(10);   // true
isFinite(undefined);  // false
isFinite();   // false
isFinite(null);  // true，这点当特别注意

30、避免在数组中使用负数做索引

var numbersArray = [1,2,3,4,5];
 var from = numbersArray.indexOf("foo") ; // from is equal to -1
 numbersArray.splice(from,2); // will return [5]

注意传给splice的索引参数不要是负数，当是负数时，会从数组结尾处删除元素。

31、用JSON来序列化与反序列化

var person = {name :'Saad', age : 26, department : {ID : 15, name : "R&D"} };
var stringFromPerson = JSON.stringify(person);
/* stringFromPerson 结果为 "{"name":"Saad","age":26,"department":{"ID":15,"name":"R&D"}}"   */
var personFromString = JSON.parse(stringFromPerson);
/* personFromString 的值与 person 对象相同  */

32、不要使用eval()或者函数构造器

eval()和函数构造器（Functionconsturctor）的开销较大，每次调用，JavaScript引擎都要将源代码转换为可执行的代码。

var func1 = new Function(functionCode);
var func2 = eval(functionCode);

32、不要使用eval()或者函数构造器

eval()和函数构造器（Functionconsturctor）的开销较大，每次调用，JavaScript引擎都要将源代码转换为可执行的代码。

var func1 = new Function(functionCode);
var func2 = eval(functionCode);

33、避免使用with()

使用with()可以把变量加入到全局作用域中，因此，如果有其它的同名变量，一来容易混淆，二来值也会被覆盖。

34、不要对数组使用for-in

避免：

var sum = 0;  
for (var i in arrayNumbers) {  
    sum += arrayNumbers[i];  
}

而是：

var sum = 0;  
for (var i = 0, len = arrayNumbers.length; i < len; i++) {  
    sum += arrayNumbers[i];  
}

另外一个好处是，i和len两个变量是在for循环的第一个声明中，二者只会初始化一次，这要比下面这种写法快：

for (var i = 0; i < arrayNumbers.length; i++)

35、传给setInterval()和setTimeout()时使用函数而不是字符串

如果传给setTimeout()和setInterval()一个字符串，他们将会用类似于eval方式进行转换，这肯定会要慢些，因此不要使用：

setInterval('doSomethingPeriodically()', 1000);  
setTimeout('doSomethingAfterFiveSeconds()', 5000);

而是用：

setInterval(doSomethingPeriodically, 1000);  
setTimeout(doSomethingAfterFiveSeconds, 5000);

36、使用switch/case代替一大叠的if/else

当判断有超过两个分支的时候使用switch/case要更快一些，而且也更优雅，更利于代码的组织，当然，如果有超过10个分支，就不要使用switch/case了。

37、在switch/case中使用数字区间

其实，switch/case中的case条件，还可以这样写：

function getCategory(age) {  
    var category = "";  
    switch (true) {  
        case isNaN(age):  
            category = "not an age";  
            break;  
        case (age >= 50):  
            category = "Old";  
            break;  
        case (age <= 20):  
            category = "Baby";  
            break;  
        default:  
            category = "Young";  
            break;  
    };  
    return category;  
}  
getCategory(5);  // 将返回 "Baby"

38、使用对象作为对象的原型

下面这样，便可以给定对象作为参数，来创建以此为原型的新对象：

function clone(object) {  
    function OneShotConstructor(){}; 
    OneShotConstructor.prototype = object;  
    return new OneShotConstructor(); 
} 
clone(Array).prototype ;  // []

39、HTML字段转换函数

function escapeHTML(text) {  
    var replacements= {"<": "<", ">": ">","&": "&", "\"": """};                      
    return text.replace(/[<>&"]/g, function(character) {  
        return replacements[character];  
    }); 
}

40、不要在循环内部使用try-catch-finally

try-catch-finally中catch部分在执行时会将异常赋给一个变量，这个变量会被构建成一个运行时作用域内的新的变量。

切忌：

var object = ['foo', 'bar'], i;  
for (i = 0, len = object.length; i <len; i++) {  
    try {  
        // do something that throws an exception 
    }  
    catch (e) {   
        // handle exception  
    } 
}

而应该：

var object = ['foo', 'bar'], i;  
try { 
    for (i = 0, len = object.length; i <len; i++) {  
        // do something that throws an exception 
    } 
} 
catch (e) {   
    // handle exception  
}

41、使用XMLHttpRequests时注意设置超时

XMLHttpRequests在执行时，当长时间没有响应（如出现网络问题等）时，应该中止掉连接，可以通过setTimeout()来完成这个工作：

var xhr = new XMLHttpRequest (); 
xhr.onreadystatechange = function () {  
    if (this.readyState == 4) {  
        clearTimeout(timeout);  
        // do something with response data 
    }  
}  
var timeout = setTimeout( function () {  
    xhr.abort(); // call error callback  
}, 60*1000 /* timeout after a minute */ ); 
xhr.open('GET', url, true);  
xhr.send();

同时需要注意的是，不要同时发起多个XMLHttpRequests请求。

42、处理WebSocket的超时

通常情况下，WebSocket连接创建后，如果30秒内没有任何活动，服务器端会对连接进行超时处理，防火墙也可以对单位周期没有活动的连接进行超时处理。

为了防止这种情况的发生，可以每隔一定时间，往服务器发送一条空的消息。可以通过下面这两个函数来实现这个需求，一个用于使连接保持活动状态，另一个专门用于结束这个状态。

var timerID = 0; 
function keepAlive() { 
    var timeout = 15000;  
    if (webSocket.readyState == webSocket.OPEN) {  
        webSocket.send('');  
    }  
    timerId = setTimeout(keepAlive, timeout);  
}  
function cancelKeepAlive() {  
    if (timerId) {  
        cancelTimeout(timerId);  
    }  
}

keepAlive()函数可以放在WebSocket连接的onOpen()方法的最后面，cancelKeepAlive()放在onClose()方法的最末尾。

43、时间注意原始操作符比函数调用快，使用VanillaJS

比如，一般不要这样：

var min = Math.min(a,b); 
A.push(v);

可以这样来代替：

var min = a < b ? a : b; 
A[A.length] = v;

44、开发时注意代码结构，上线前检查并压缩JavaScript代码

别忘了在写代码时使用一个代码美化工具。使用JSLint(一个语法检查工具)并且在上线前压缩代码（比如使用JSMin）。注：现在代码压缩一般推荐 UglifyJS (http://www.php.cn/)

45、JavaScript博大精深，这里有些不错的学习资源

• Code Academy资源：http://www.php.cn/

• Marjin Haverbekex编写的Eloquent JavaScript：http://www.php.cn/

• John Resig编写的Advanced JavaScript：http://www.php.cn/

 以上就是JavaScript 开发的45个技巧的内容，更多相关内容请关注PHP中文网（www.php.cn）！