Comment vérifier les valeurs nulles en JavaScript?
Comment puis-je vérifier les valeurs NULL en JavaScript? J'ai écrit le code ci-dessous mais cela n'a pas fonctionné.
if (pass == null || cpass == null || email == null || cemail == null || user == null) {
alert("fill all columns");
return false;
}
Et comment puis-je trouver des erreurs dans mes programmes JavaScript?
Javascript est très flexible en ce qui concerne la vérification des valeurs "nulles". Je suppose que vous recherchez réellement des chaînes vides, auquel cas ce code plus simple fonctionnera:
if(!pass || !cpass || !email || !cemail || !user){
Ce qui va vérifier les chaînes vides (""), null, undefined, false et les nombres 0 et NaN
Veuillez noter que si vous recherchez spécifiquement des chiffres, il est fréquent que vous manquiez 0 avec cette méthode, et num !== 0 est préférable (ou num !== -1 ou ~num (hacky code qui vérifie également par rapport à -1)) pour les fonctions renvoyant -1, par exemple indexOf)
Pour vérifier null SPÉCIFIQUEMENT, vous utiliseriez ceci:
if(variable === null && typeof variable === "object")
... ou plus simplement:
if(variable === null)
Ce test SEULEMENT sera valable pour null et ne passera pas pour "", undefined, false, 0 ou NaN.
Le reste de ceci est en réponse au commentaire de inorganik, oui, vous pouvez vérifier chacun individuellement.
Vous devez implémenter l'utilisation de absolutely equals: === et typeof pour être absolument sûr de vos chèques.
J'ai créé un JSFiddle ici pour afficher tous les tests individuels qui fonctionnent
Voici tous les résultats des tests:
Null Test:
if(variable === null && typeof variable === "object")
- variable = ""; (false) typeof variable = string
- variable = null; (true) typeof variable = object
- variable = undefined; (false) typeof variable = undefined
- variable = false; (false) typeof variable = boolean
- variable = 0; (false) typeof variable = number
- variable = NaN; (false) typeof variable = number
Empty String Test:
if(variable === "" && typeof variable === "string")
- variable = ""; (true) typeof variable = string
- variable = null; (false) typeof variable = object
- variable = undefined; (false) typeof variable = undefined
- variable = false; (false) typeof variable = boolean
- variable = 0; (false) typeof variable = number
- variable = NaN; (false) typeof variable = number
Undefined Test:
if(variable === undefined && typeof variable === "undefined")
- variable = ""; (false) typeof variable = string
- variable = null; (false) typeof variable = object
- variable = undefined; (true) typeof variable = undefined
- variable = false; (false) typeof variable = boolean
- variable = 0; (false) typeof variable = number
- variable = NaN; (false) typeof variable = number
False Test:
if(variable === false && typeof variable === "boolean")
- variable = ""; (false) typeof variable = string
- variable = null; (false) typeof variable = object
- variable = undefined; (false) typeof variable = undefined
- variable = false; (true) typeof variable = boolean
- variable = 0; (false) typeof variable = number
- variable = NaN; (false) typeof variable = number
Zero Test:
if(variable === 0 && typeof variable === "number")
- variable = ""; (false) typeof variable = string
- variable = null; (false) typeof variable = object
- variable = undefined; (false) typeof variable = undefined
- variable = false; (false) typeof variable = boolean
- variable = 0; (true) typeof variable = number
- variable = NaN; (false) typeof variable = number
NaN Test:
if(!parseFloat(variable) && variable != 0 && typeof variable === "number")
- variable = ""; (false) typeof variable = string
- variable = null; (false) typeof variable = object
- variable = undefined; (false) typeof variable = undefined
- variable = false; (false) typeof variable = boolean
- variable = 0; (false) typeof variable = number
- variable = NaN; (true) typeof variable = number
Comme vous pouvez le constater, il est un peu plus difficile de tester contre NaN;
il suffit de remplacer le == par === à tous les endroits.
== est une comparaison d'égalité lâche ou abstraite
=== est une comparaison d'égalité stricte
Voir l'article du MDN sur Comparaisons d'égalité et similitude pour plus de détails.
Opérateur d'égalité stricte: -
Nous pouvons vérifier null par ===
if ( value === null ){
}
Juste en utilisant if
if( value ) {
}
sera évalué à vrai si la valeur n'est pas:
- nul
- undefined
- NaN
- chaîne vide ("")
- false
Amélioration de la réponse acceptée en recherchant explicitement null mais avec une syntaxe simplifiée:
if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
// your code here ...
}
// Test
let pass=1, cpass=1, email=1, cemail=1, user=1; // just to test
if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
// your code here ...
console.log ("Yayy! None of them are null");
} else {
console.log ("Oops! At-lease one of them is null");
}Tout d'abord, vous avez une instruction return sans corps de fonction. Les chances sont que cela jettera une erreur.
Une façon plus propre de faire votre chèque serait simplement d’utiliser le! opérateur:
if (!pass || !cpass || !email || !cemail || !user) {
alert("fill all columns");
}
pour vérifier ndefined et null en javascript, il vous suffit d'écrire ce qui suit:
if (!var) {
console.log("var IS null or undefined");
} else {
console.log("var is NOT null or undefined");
}
vous pouvez utiliser essayer attraper enfin
try {
document.getElementById("mydiv").innerHTML = 'Success' //assuming "mydiv" is undefined
} catch (e) {
if (e.name.toString() == "TypeError") //evals to true in this case
//do something
} finally {}
vous pouvez aussi throw vos propres erreurs. Voir this .
Ceci est un commentaire sur la solution de WebWanderer concernant la vérification de NaN (je n'ai pas encore assez de représentants pour laisser un commentaire formel). La solution se lit comme
if(!parseInt(variable) && variable != 0 && typeof variable === "number")
mais cela échouera pour les nombres rationnels arrondis à 0, tel que variable = 0.1. Un meilleur test serait:
if(isNaN(variable) && typeof variable === "number")
En JavaScript, aucune chaîne n'est égale à null.
Peut-être que vous vous attendiez à ce que pass == null soit vrai lorsque pass est une chaîne vide, car vous savez que l'opérateur d'égalité en vrac == exécute certains types de coercition de types.
Par exemple, cette expression est vraie:
'' == 0
En revanche, l'opérateur d'égalité stricte === dit que cela est faux:
'' === 0
Etant donné que '' et 0 sont approximativement égaux, vous pouvez raisonnablement supposer que '' et null sont approximativement égaux. Cependant, ils ne le sont pas.
Cette expression est fausse:
'' == null
Le résultat de la comparaison d'une chaîne à null est faux. Par conséquent, pass == null et tous vos autres tests sont toujours faux et l'utilisateur ne reçoit jamais l'alerte.
Pour corriger votre code, comparez chaque valeur à la chaîne vide:
pass === ''
Si vous êtes certain que pass est une chaîne, pass == '' fonctionnera également, car seule une chaîne vide est approximativement égale à la chaîne vide. Par ailleurs, selon certains experts, il est judicieux de toujours utiliser une égalité stricte en JavaScript, à moins que vous ne souhaitiez spécifiquement appliquer la contrainte de type exécutée par l'opérateur d'égalité en vrac.
Si vous voulez savoir quelles paires de valeurs sont vaguement égales, consultez le tableau "Comparaisons de la ressemblance" dans le article de Mozilla sur ce sujet .
Vous pouvez utiliser le module lodash pour vérifier si la valeur est nulle ou non définie
_.isNil(value)
Example
country= "Abc"
_.isNil(country)
//false
state= null
_.isNil(state)
//true
city= undefined
_.isNil(state)
//true
pin= true
_.isNil(pin)
// false
Lien de référence: https://lodash.com/docs/#isNil
En fait, je pense que vous devrez peut-être utiliser if (value !== null || value !== undefined), car si vous utilisez if (value), vous pouvez également filtrer les valeurs 0 ou fausses.
Considérez ces deux fonctions:
const firstTest = value => {
if (value) {
console.log('passed');
} else {
console.log('failed');
}
}
const secondTest = value => {
if (value !== null && value !== undefined) {
console.log('passed');
} else {
console.log('failed');
}
}
firstTest(0); // result: failed
secondTest(0); // result: passed
firstTest(false); // result: failed
secondTest(false); // result: passed
firstTest(''); // result: failed
secondTest(''); // result: passed
firstTest(null); // result: failed
secondTest(null); // result: failed
firstTest(undefined); // result: failed
secondTest(undefined); // result: failed
Dans ma situation, je devais simplement vérifier si la valeur est null et non définie et je ne voulais pas filtrer les valeurs 0 ou false ou ''. J'ai donc utilisé le deuxième test, mais vous devrez peut-être aussi les filtrer, ce qui pourrait vous amener à utiliser le premier test.
J'ai trouvé un autre moyen de tester si la valeur est null:
if(variable >= 0 && typeof variable === "object")
null agit simultanément en tant que number et object. En comparant null >= 0 ou null <= 0, on obtient true. La comparaison de null === 0 ou null > 0 ou null < 0 donnera la valeur false. Mais comme null est également un objet, nous pouvons le détecter comme nul.
J'ai créé une fonction plus complexe natureof qui fera mieux que typeof et peut dire quels types inclure ou conserver groupés
/* function natureof(variable, [included types])
included types are
null - null will result in "undefined" or if included, will result in "null"
NaN - NaN will result in "undefined" or if included, will result in "NaN"
-infinity - will separate negative -Inifity from "Infinity"
number - will split number into "int" or "double"
array - will separate "array" from "object"
empty - empty "string" will result in "empty" or
empty=undefined - empty "string" will result in "undefined"
*/
function natureof(v, ...types){
/*null*/ if(v === null) return types.includes('null') ? "null" : "undefined";
/*NaN*/ if(typeof v == "number") return (isNaN(v)) ? types.includes('NaN') ? "NaN" : "undefined" :
/*-infinity*/ (v+1 === v) ? (types.includes('-infinity') && v === Number.NEGATIVE_INFINITY) ? "-infinity" : "infinity" :
/*number*/ (types.includes('number')) ? (Number.isInteger(v)) ? "int" : "double" : "number";
/*array*/ if(typeof v == "object") return (types.includes('array') && Array.isArray(v)) ? "array" : "object";
/*empty*/ if(typeof v == "string") return (v == "") ? types.includes('empty') ? "empty" :
/*empty=undefined*/ types.includes('empty=undefined') ? "undefined" : "string" : "string";
else return typeof v
}
// DEMO
let types = [null, "", "string", undefined, NaN, Infinity, -Infinity, false, "false", true, "true", 0, 1, -1, 0.1, "test", {var:1}, [1,2], {0: 1, 1: 2, length: 2}]
for(i in types){
console.log("natureof ", types[i], " = ", natureof(types[i], "null", "NaN", "-infinity", "number", "array", "empty=undefined"))
}Cela ne fonctionnera pas dans le cas de valeurs booléennes provenant de DB, par exemple:
value = false
if(!value) {
// it will change all false values to not available
return "not available"
}
S'il vous plaît voir attentivement avant downvote.
D'après ce que je sais, JAVASCRIPT lorsqu'une variable est déclarée mais n'a pas de valeur assignée, son type est undefined. afin que nous puissions vérifier la variable même s'il s'agirait d'une object contenant quelque instance à la place de valeur.
créez une méthode d'assistance pour vérifier la nullité qui retourne true et utilisez-la dans votre API.
fonction d'assistance pour vérifier si la variable est vide:
function isEmpty(item){
if(item){
return false;
}else{
return true;
}
}
appel API exceptionnel try-catch:
try {
var pass, cpass, email, cemail, user; // only declared but contains nothing.
// parametrs checking
if(isEmpty(pass) || isEmpty(cpass) || isEmpty(email) || isEmpty(cemail) || isEmpty(user)){
console.log("One or More of these parameter contains no vlaue. [pass] and-or [cpass] and-or [email] and-or [cemail] and-or [user]");
}else{
// do stuff
}
} catch (e) {
if (e instanceof ReferenceError) {
console.log(e.message); // debugging purpose
return true;
} else {
console.log(e.message); // debugging purpose
return true;
}
}
quelques cas de test:
var item = ""; // isEmpty? true
var item = " "; // isEmpty? false
var item; // isEmpty? true
var item = 0; // isEmpty? true
var item = 1; // isEmpty? false
var item = "AAAAA"; // isEmpty? false
var item = NaN; // isEmpty? true
var item = null; // isEmpty? true
var item = undefined; // isEmpty? true
console.log("isEmpty? "+isEmpty(item));
J'ai créé cette fonction très simple qui fonctionne à merveille:
function safeOrZero(route) {
try {
Function(`return (${route})`)();
} catch (error) {
return 0;
}
return Function(`return (${route})`)();
}
La route est une chaîne de valeurs qui peut exploser. Je l'utilise pour jQuery/cheerio et les objets et autres.
Exemples 1: un objet simple tel que celui-ci const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.
Mais ce pourrait être un très gros objet que nous n'avons même pas fait. Alors je le passe à travers:
let value1 = testobj.items[2].val; // "hum!"
let value2 = testobj.items[3].val; // Uncaught TypeError: Cannot read property 'val' of undefined
let svalue1 = safeOrZero(`testobj.items[2].val`) // "hum!"
let svalue2 = safeOrZero(`testobj.items[3].val`) // 0
Bien sûr, si vous préférez, vous pouvez utiliser null ou 'No value'... Quel que soit votre choix.
Habituellement, une requête DOM ou un sélecteur jQuery peut générer une erreur s'il n'est pas trouvé. Mais en utilisant quelque chose comme:
const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
[...]
}