Quel opérateur est égal (== vs ===) à utiliser dans la comparaison JavaScript?

J'utilise JSLint pour parcourir JavaScript et renvoie de nombreuses phrases à remplacer == (deux signes égaux) par === (trois signes égaux) lorsque vous effectuez quelque chose comme une comparaison idSele_UNVEHtype.value.length == 0 inside opérateur if .

Existe-t-il un avantage en == de performances pour le remplacement de == par === ?

Toute amélioration des performances sera la bienvenue car il existe de nombreux opérateurs de comparaison.

Si la conversion de type ne se produit pas, le gain sera-t-il comparé à == ?

5673
11 дек. fixé par bcasp le 11 décembre 2008-12-11 17:19 '08 à 17:19 2008-12-11 17:19
ответ 51 réponses
  • 1
  • 2

L'opérateur d'identité ( === ) se comporte de manière identique à l'opérateur d'égalité ( == ), sauf que la conversion de type n'est pas effectuée et que les types doivent être identiques pour être considérés comme égaux.

Référence: tutoriel Javascript: opérateurs de comparaison

L'opérateur == comparera pour l'égalité après avoir effectué les conversions de type nécessaires. L'opérateur === n'effectue pas la conversion. Par conséquent, si les deux valeurs ne correspondent pas, === renverra simplement la valeur false . Les deux sont également rapides.

Citer Douglas Crockford excellent javascript: bonnes pièces ,

En JavaScript, il existe deux ensembles d'opérateurs d'égalité: === et !== , et leurs jumeaux diaboliques == et != . Les bons fonctionnent comme prévu. Si deux opérandes du même type ont la même valeur, === crée true et !== produit false . Les jumeaux maléfiques agissent comme il se doit lorsque les opérandes sont du même type, mais s'ils ont des types différents, ils essaient d'appliquer des valeurs. les règles par lesquelles ils font qui sont complexes et insurmontables. Voici quelques cas intéressants:

 '' == '0' // false 0 == '' // true 0 == '0' // true false == 'false' // false false == '0' // true false == undefined // false false == null // false null == undefined // true ' \t\r\n ' == 0 // true 

Le manque de transitivité est alarmant. Mon conseil est de ne jamais utiliser des jumeaux diaboliques. Au lieu de cela, utilisez toujours === et !== . Toutes les comparaisons ci-dessus montrent false avec l'opérateur === .


Mise à jour:

@Casebash a soulevé un bon point dans les commentaires et dans @Phillipe Laybaert concernant les types de référence. Pour les types de référence, == et === agissent de manière cohérente (sauf dans le cas particulier).

 var a = [1,2,3]; var b = [1,2,3]; var c = { x: 1, y: 2 }; var d = { x: 1, y: 2 }; var e = "text"; var f = "te" + "xt"; a == b // false a === b // false c == d // false c === d // false e == f // true e === f // true 

Un cas particulier est la comparaison d'un littéral avec un objet qui évalue le même littéral en raison de sa toString ou valueOf . Par exemple, envisagez de comparer un littéral de chaîne avec un objet de chaîne créé par le constructeur String .

 "abc" == new String("abc") // true "abc" === new String("abc") // false 

Ici, l'opérateur == vérifie les valeurs de deux objets et renvoie la valeur true , mais === voit qu'ils ne sont pas du même type et renvoie la valeur false . Lequel est correct? Cela dépend vraiment de ce que vous essayez de comparer. Mon conseil est de contourner complètement la question et de ne pas utiliser le constructeur String pour créer des objets chaîne.

Référence
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

5840
11 дек. Réponse donnée par Bill the Lizard le 11 décembre 2008-12-11 17:25 08 à 17h25 2008-12-11 17h25

Utilisation de l'opérateur == (égalité)

 true == 1; //true, because 'true' is converted to 1 and then compared "2" == 2; //true, because "2" is converted to 2 and then compared 

Utilisation de l'opérateur === (identité)

border=0
 true === 1; //false "2" === 2; //false 

Cela est dû au fait que l'opérateur d' égalité == a un type de contrainte , ce qui signifie que l'interpréteur tente implicitement de convertir les valeurs avant la comparaison.

D'autre part, l'opérateur Identity === n'effectue pas de type de contrainte et ne convertit donc pas les valeurs lors de la comparaison.

1016
11 дек. La réponse est donnée par Andreas Grech 11 déc. 2008-12-11 17:33 '08 à 17:33 2008-12-11 17:33

Dans les réponses ici, je n'ai rien lu sur ce que signifie l' égalité . Certains diront que === signifie égal et du même type , mais ce n'est pas le cas. En fait, cela signifie que les deux opérandes se réfèrent au même objet ou, dans le cas de types de valeur , ont la même valeur .

Alors prenons le code suivant:

 var a = [1,2,3]; var b = [1,2,3]; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Idem ici:

 var a = { x: 1, y: 2 }; var b = { x: 1, y: 2 }; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Ou même:

 var a = { }; var b = { }; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Ce comportement n'est pas toujours évident. Il y a plus dans l'histoire que d'être égal et du même type.

Règle:

Pour les types de valeur (nombres):
a === b retourne vrai si a et b ont la même valeur et ont le même type

Pour les types de référence:
a === b retourne vrai si a et b font référence au même objet.

Pour les cordes:
a === b renvoie vrai si a et b sont tous les deux des chaînes et contiennent les mêmes caractères.


Cordes: cas particulier ...

Les chaînes ne sont pas des types de valeur, mais en Javascript, elles se comportent comme des types de valeur. Elles sont donc "égales" lorsque les caractères de la chaîne sont identiques et de la même longueur (comme expliqué dans la troisième règle).

Maintenant cela devient intéressant:

 var a = "12" + "3"; var b = "123"; alert(a === b); // returns true, because strings behave like value types 

Mais qu'en est-il de cela?

 var a = new String("123"); var b = "123"; alert(a === b); // returns false !! (but they are equal and of the same type) 

Je pensais que les chaînes se comportaient comme des types de valeur? Cela dépend de qui vous demandez ... Dans ce cas, a et b ne sont pas du même type. a est de type Object et b est de type string . Rappelez-vous simplement que la création d'un objet chaîne à l'aide du constructeur de string crée quelque chose comme le type Object , qui se comporte la plupart du temps comme une chaîne.

564
05 июня '09 в 22:11 2009-06-05 22:11 a répondu à Philippe Leybaert le 05 juin 09 à 09:11 2009-06-05 22:11

Une représentation graphique intéressante de la comparaison d'égalité entre == et === .

Source: http://dorey.github.io/JavaScript-Equality-Table/


var1 === var2

Lorsque vous utilisez === pour tester l’égalité JavaScript, tout est tel quel. Rien n'est converti avant l'évaluation.

2019

553
05 мая '14 в 8:21 2014-05-05 08:21 la réponse est donnée par SNag le 05 mai '14 à 8:21 2014-05-05 08:21

Permettez-moi d'ajouter cette astuce:

En cas de doute, lisez le cahier des charges !

ECMA-262 est une spécification de >nouvelle chaîne ("a")! == "a" .

Laissez-moi vous expliquer comment lire les spécifications pour clarifier ce problème. Je vois que dans ce très vieux sujet, personne n’a eu de réponse pour un effet très étrange. Donc, si vous pouvez lire le cahier des charges, cela vous aidera beaucoup dans votre profession. C'est une compétence acquise. Alors allez-y.

Trouver un fichier PDF pour === me conduit à la page 56 du cahier des charges: 11.9.4. L'opérateur Strict Equals (===) , et après avoir traversé la spécification, je trouve:

11.9.6 Algorithme pour la comparaison d'égalité stricte
La comparaison de x === y, où x et y sont des valeurs, crée vrai ou faux . Une telle comparaison est effectuée comme suit:
1. Si le type (x) est différent du type (y), retournez false .
2. Si le type (x) est Non défini, retournez true .
3. Si Type (x) est Null, renvoyez true .
4. Si le type (x) n'est pas un nombre, passez à l'étape 11.
5. Si x est NaN , retourne false .
6. Si y est NaN , retourne false .
7. Si x est la même valeur numérique que y, retourne vrai .
8. Si x est +0 et y est -0, retourne vrai .
9. Si x est -0 et y est +0, retourne vrai .
10. Retourne faux .
11. Si Type (x) est une chaîne, retourne vrai si x et y sont exactement la même séquence de caractères (la même longueur et les mêmes caractères aux positions correspondantes); sinon, retourne faux .
12. Si Type (x) est booléen, retourne vrai si x et y sont tous les deux vrais ou tous les deux faux ; sinon, retourne faux .
13. Renvoie true si x et y appartiennent au même objet ou se rapportent à des objets connectés l'un à l'autre (voir 13.1.2). Sinon, retourne false .

L'étape 11 est intéressante.Oui, les chaînes sont traitées comme des types de valeur. Mais cela n’explique pas pourquoi la nouvelle chaîne ("a")! == "a" . Avons-nous un navigateur non-ECMA-262?

Pas si vite!

Vérifiez les types d'opérandes. Essayez vous-même en les enveloppant dans typeof () . J'ai trouvé que la nouvelle chaîne ("a") est un objet et l'étape 1 est utilisée: renvoyer false si les types sont différents.

Si vous vous demandez pourquoi la nouvelle chaîne ("a") ne renvoie pas de chaîne, que diriez-vous de certains exercices lisant la spécification? Amusez vous bien!


Aidiakapi a écrit ceci dans un commentaire ci-dessous:

De la spécification

11.2.2 Nouvel opérateur :

Si le type (constructeur) n'est pas un objet, déclenchez une exception TypeError.

En d'autres termes, si la chaîne n'est pas de type Object, elle ne peut pas être utilisée avec l'opérateur new.

new renvoie toujours un objet, même pour les constructeurs de chaînes . Et hélas! La sémantique de la valeur des chaînes (voir l’étape 11) est perdue.

Et cela signifie enfin: le nouveau String ("a")! == "a" .

254
28 нояб. La réponse est donnée le 28 novembre. 2009-11-28 21:18 '09 à 21:18 2009-11-28 21:18

En PHP et JavaScript, il s'agit d'un opérateur d'égalité stricte. Cela signifie qu'il va comparer le type et les valeurs.

95
12 мая '10 в 15:58 2010-05-12 15:58 la réponse est donnée par Shiki le 12 mai '10 à 15:58 2010-05-12 15:58

Je l'ai testé dans Firefox en utilisant Firebug en utilisant le code suivant:

 console.time("testEquality"); var n = 0; while(true) { n++; if(n==100000) break; } console.timeEnd("testEquality"); 

et

 console.time("testTypeEquality"); var n = 0; while(true) { n++; if(n===100000) break; } console.timeEnd("testTypeEquality"); 

Mes résultats (vérifiés cinq fois et moyennés):

 ==: 115.2 ===: 114.4 

Donc, je dirais qu’une légère différence (c’est plus de 100 000 itérations, rappelez-vous) est négligeable. La performance n'est pas la cause === . Le type de sécurité (ainsi, le niveau de sécurité, comment vous allez utiliser javascript) et la qualité du code.

91
25 дек. La réponse est donnée par Simon Scarfe le 25 décembre. 2008-12-25 14:17 08 à 14h17 2008-12-25 14:17

En JavaScript, cela signifie la même valeur et le même type.

Par exemple

 4 == "4" // will return true 

mais

 4 === "4" // will return false 
88
12 мая '10 в 15:58 2010-05-12 15:58 la réponse est donnée par Dimitar le 12 mai '10 à 15:58 2010-05-12 15:58

L'opérateur === est appelé opérateur de comparaison stricte, il est différent de l'opérateur == .

Prendre 2 vars a et b.

Pour "a == b", évaluer la vérité de a et b devrait être une valeur .

Dans le cas de "a === b", a et b doivent avoir la même valeur et le même type pour que la vérité puisse être évaluée.

Prenons l'exemple suivant

 var a = 1; var b = "1"; if (a == b) //evaluates to true as a and b are both 1 { alert("a == b"); } if (a === b) //evaluates to false as a is not the same type as b { alert("a === b"); } 

En conclusion ; L'utilisation de l'opérateur == peut être considérée comme vraie dans les cas où vous ne le souhaitez pas. L'utilisation de l'opérateur === sera donc plus sûre.

Dans le scénario d’utilisation à 90%, peu importe celui que vous utilisez, mais il est utile de connaître la différence en cas de comportement inattendu un jour.

77
11 дек. La réponse est donnée par le docteur Jones le 11 décembre. 2008-12-11 17:58 '08 à 17h58 2008-12-11 17h58

Il vérifie si les mêmes côtés sont égaux en type et en valeur .

Exemple:

 '1' === 1 // will return "false" because 'string' is not a 'number' 

Exemple général:

 0 == '' // will be "true", but it very common to want this check to be "false" 

Un autre exemple courant est:

 null == undefined // returns "true", but in most cases a distinction is necessary 
70
12 мая '10 в 15:58 2010-05-12 15:58 la réponse est donnée par vsync le 12 mai '10 à 15:58 2010-05-12 15:58

Pourquoi == si imprévisible?

Qu'est-ce que vous obtenez lorsque vous comparez la chaîne vide "" avec le nombre 0 0 ?

<code> TrueCode>

Oui, cela est correct conformément à == chaîne vide et le zéro numérique correspond à la même heure.

Et cela ne se termine pas ici, un autre:

  '0' == false//true Код> 

Les choses deviennent très étranges avec les tableaux.

  [1] == true//true [] == false//true [[]] == false//true [0] == false//true Код> 

Puis Weerder avec des cordes

  [1,2,3] == '1,2,3'//true - ДЕЙСТВИТЕЛЬНО?! '\ r\n\t' == 0//true - Давай! Код> 

S'aggrave:

Quand n'est pas égal à?

  let A = ''//пустая строка пусть В = 0//нуль пусть C = '0'//нулевая строка A == B//true - ok... B == C//true - пока что так хорошо... A == C//** FALSE ** - Закручивание сюжета! Код> 

Laissez-moi le répéter:

  (A == B)(B == C)//true (A == C)//** FALSE ** Код> 

Et ceci est juste le truc fou que vous obtenez avec les primitifs.

C'est un nouveau niveau de folie lorsque vous utilisez == avec des objets.

À ce stade, vous vous demandez probablement ...

Pourquoi est-ce que cela se passe?

Bien, car contrairement à "triple égalité" ( === ), qui vérifie simplement si les deux valeurs correspondent.

== faire tout un tas d'autres choses .

Il a un traitement spécial pour les fonctions, un traitement spécial pour les zéros, undefined, des chaînes, que vous appelez.

Ça devient assez bête.

En fait, si vous essayez d'écrire une fonction qui fait ce qu'elle fait == , cela ressemblera à ceci:

  function isEqual (x, y) {//если `==` были функцией   if (typeof y === typeof x) return y === x;   // обрабатываем null и undefined то же самое   var xIsNothing = (y === undefined) || (y === null);   var yIsNothing = (x === undefined) || (x === null);  если (xIsNothing || yIsNothing) возвращается (xIsNothing  yIsNothing);  if (typeof y === "function" || typeof x === "function" ) {   // если любое значение является строкой   // преобразовать функцию в строку и сравнить   if (typeof x === "string" ) {   return x === y.toString();   } else if (typeof y === "string" ) {   return x.toString() === y;   }   return false;   }  if (typeof x === "object" ) x = toPrimitive (x);   if (typeof y === "object" ) y = toPrimitive (y);   if (typeof y === typeof x) return y === x;  // конвертируем x и y в числа, если они еще не используют трюк +   if (typeof x! == "number" ) x = + x;   if (typeof y! == "number" ) y = + y;   // фактически реальный `==` еще более сложный, чем это, особенно в ES6   return x === y; } функция toPrimitive (obj) {   var value = obj.valueOf();   if (obj! == value) возвращаемое значение;   return obj.toString(); } Код> 

Alors qu'est-ce que cela signifie?

Cela signifie que == est complexe.

Comme c'est difficile, il est difficile de comprendre ce qui se passera quand vous l'utiliserez.

Cela signifie que vous pouvez avoir des erreurs.

Alors la morale de l'histoire ...

Rendez votre vie moins compliquée.

Utilisez === au lieu de == .

La fin.

68
09 авг. réponse donnée par Luis Perez le 09 août 2016-08-09 19:50 '16 à 19:50 2016-08-09 19:50

Diagramme de séquence d'exécution Javascript pour l'égalité stricte / Comparaison '==='

2019

05 сент. la réponse est donnée à Samar Panda 05 sep. 2015-09-05 16:53 '15 à 16h53 2015-09-05 16h53

Javascript === vs == .

 0==false // true 0===false // false, because they are of a different type 1=="1" // true, auto type coercion 1==="1" // false, because they are of a different type 
52
03 июля '13 в 7:08 2013-07-03 07:08 la réponse est donnée par user2496033 le 03 juillet '13 à 7:08 2013-07-03 07:08

Cela signifie l' égalité sans contrainte de type, ce qui signifie que JavaScript ne convertit pas automatiquement les autres types de données en types de données chaîne.

 0==false // true,although they are different types 0===false // false,as they are different types 2=='2' //true,different types,one is string and another is integer but javaScript convert 2 to string by using == operator 2==='2' //false because by using === operator ,javaScript do not convert integer to string 2===2 //true because both have same value and same types 
51
12 мая '10 в 15:59 2010-05-12 15:59 la réponse est donnée par Pop Catalin le 12 mai 2010 à 15:59 2010-05-12 15:59

Dans un script typique, il n'y aura pas de différence de performance. Plus important encore, le fait qu'un millier "===" soit égal à 1 kilo-octet est plus lourd qu'un millier "==" :) Les profileurs JavaScript peuvent vous dire s'il y a une différence de performance dans votre cas.

Mais personnellement, je ferais ce que propose JSLint. Cette recommandation n’est pas due à des problèmes de performances, mais à une restriction de type ('\t\r\n' == 0) .

46
16 дек. réponse donnée Constantin 16 déc. 2008-12-16 17:29 '08 à 17h29 2008-12-16 17:29

L'opérateur de comparaison égal == est confus et doit être évité.

Si vous vivez avec HAVE , rappelez-vous les 3 choses suivantes:

  • Il n'est pas transitif: (a == b) et (b == c) n'entraînent pas (a == c)
  • Il exclut mutuellement sa négation: (a == b) et (a! = B) ont toujours des valeurs booléennes opposées avec tous a et b.
  • En cas de doute, mémorisez la table de vérité suivante:

TABLEAU DE L'OPÉRATEUR DROIT DANS JAVASCRIPT

  • Chaque ligne de la table est un ensemble de 3 valeurs "égales", ce qui signifie que 2 valeurs quelconques sont égales à l'aide du signe égal == *

** STRANGE: notez que deux valeurs quelconques dans la première colonne ne sont pas égales dans ce sens. **

 '' == 0 == false // Any two values among these 3 ones are equal with the == operator '0' == 0 == false // Also a set of 3 equal values, note that only 0 and false are repeated '\t' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\r' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\n' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\t\r\n' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- null == undefined // These two "default" values are not-equal to any of the listed values above NaN // NaN is not equal to any thing, even to itself. 
42
16 сент. réponse donnée par CuongHuyTo 16 sept. 2011-09-16 17:25 '11 à 17:25 2011-09-16 17:25

Il n’ya pratiquement aucune différence de performance entre les deux opérations que vous utilisez. Aucune conversion de type n'est à effectuer, car les deux paramètres sont du même type. Les deux opérations auront une comparaison de type suivie d'une comparaison de valeur.

35
11 дек. réponse donnée Sean 11 déc 2008-12-11 17:44 '08 à 17:44 2008-12-11 17:44

Oui Ça compte.

=== opérateur === en javascript vérifie la valeur, ainsi que le type , l'opérateur == simplement la valeur (convertit le type si nécessaire) .

2019

35
14 нояб. Réponse donnée par Aniket Thakur le 14 nov. 2014-11-14 09:02 14 à 09:02 2014-11-14 09:02
Opérateur

=== vérifie l'égalité des valeurs et des types de variables.

Opérateur

== vérifie simplement la valeur des variables pour l’égalité.

32
12 мая '10 в 16:03 2010-05-12 16:03 la réponse est donnée par Niraj Choubey le 12 mai '10 à 16:03 2010-05-12 16:03

Ceci est un test de test strict.

C'est bien, surtout si vous vérifiez entre 0 et false et null.

Par exemple, si vous avez:

 $a = 0; 

Puis:

 $a==0; $a==NULL; $a==false; 

Tout redevient vrai et vous ne le voudrez peut-être pas. Supposons que vous ayez une fonction pouvant renvoyer l'index de tableau 0th ou false en cas d'erreur. Si vous cochez la case avec "==", vous obtiendrez un résultat déroutant.

Donc, avec les mêmes que ci-dessus, mais un test strict:

 $a = 0; $a===0; // returns true $a===NULL; // returns false $a===false; // returns false 
30
12 мая '10 в 16:19 2010-05-12 16:19 La réponse est donnée à Daniel le 12 mai '10 à 16:19 2010-05-12 16:19

JSLint donne parfois des raisons irréalistes pour changer de matériau. === a les mêmes performances que == si les types correspondent déjà.

Cela est plus rapide uniquement si les types ne correspondent pas, auquel cas il ne tente pas de convertir les types, mais renvoie false.

Donc, à mon humble avis, JSLint peut être utilisé pour écrire du nouveau code, mais une sur-optimisation inutile devrait être évitée à tout prix.

Cela signifie qu'il n'y a aucune raison de changer == en === dans un test, par exemple if (a == 'test') , lorsque vous le connaissez, car un fait ne peut être qu'une chaîne.

La modification d'une grande quantité de code de cette manière prend du temps aux développeurs et aux relecteurs et n'apporte rien.

29
05 июня '12 в 10:53 2012-06-05 10:53 réponse donnée cendres le 05 juin 12 à 10:53 2012-06-05 10:53

Juste

== signifie une comparaison d' opérandes avec la type conversion

=== signifie une comparaison d' opérandes sans type conversion

La conversion de type en javaScript signifie que javaScript convertit automatiquement tous les autres types de données en types de données chaîne.

Par exemple:

 123=='123' //will return true, because JS convert integer 123 to string '123' //as we used '==' operator 123==='123' //will return false, because JS do not convert integer 123 to string //'123' as we used '===' operator 
28
20 марта '15 в 8:05 2015-03-20 08:05 la réponse est donnée Amit le 20 mars '15 à 8:05 2015-03-20 08:05

Un exemple simple est

 2 == '2' -> true, values are SAME because of type conversion. 2 === '2' -> false, values are NOT SAME because of no type conversion. 
25
14 мая '15 в 17:45 2015-05-14 17:45 la réponse est donnée par Vikas le 14 mai '15 à 17h45. 2015-05-14 17:45

Les 2 principales réponses pour les deux réponses mentionnées sont == égalité et === identifiant. Malheureusement, cette déclaration est incorrecte.

Si les deux opérandes dans == sont des objets, ils sont comparés pour voir s’ils sont le même objet. Si les deux opérandes pointent sur le même objet, l'opérateur d'égalité renvoie true. Sinon, ils ne sont pas égaux.

 var a = [1, 2, 3]; var b = [1, 2, 3]; console.log(a == b) // false console.log(a === b) // false 

Dans le code ci-dessus, == et === deviennent faux, car a et b ne sont pas les mêmes objets.

Pour dire: si les deux opérandes de == sont des objets, == se comporte de la même manière que ===, ce qui signifie également une identification. La différence essentielle entre ces deux opérateurs est la conversion de type. == a une conversion avant de vérifier l’égalité, mais pas ===.

23
09 сент. réponse donnée à Harry He 09 septembre 2013-09-09 11:31 '13 à 11h31 am 2013-09-09 11:31

En règle générale, j'ai utilisé === au lieu de == (et !== au lieu de != ).

Les raisons sont expliquées dans les réponses ci-dessus, et Douglas Crockford est assez clair à ce sujet ( JavaScript: Bonnes parties ).

Cependant, il existe une exception : == null est un moyen efficace de vérifier si 'null ou non défini':

 if( value == null ){ // value is either null or undefined } 

Например, jQuery 1.9.1 использует этот шаблон 43 раза, а руководство по стилю jQuery :