vacio - undefined javascript

¿Cómo compruebo valores nulos en JavaScript?

Question

¿Cómo puedo verificar valores nulos en JavaScript? Escribí el código de abajo pero no funcionó.

if (pass == null || cpass == null || email == null || cemail == null || user == null) {
alert("fill all columns");
return false;
}

¿Y cómo puedo encontrar errores en mis programas de JavaScript?

Answer 1

En JavaScript, ninguna cadena es igual a null .

Tal vez esperó que pass == null sea ​​verdadero cuando pass es una cadena vacía porque es consciente de que el operador de igualdad suelta == realiza ciertos tipos de coacción de tipo.

Por ejemplo, esta expresión es verdadera:

'''' == 0

En contraste, el operador de igualdad estricta === dice que esto es falso:

'''' === 0

Dado que '''' y 0 son aproximadamente iguales, usted podría razonablemente conjeturar que '''' y null son aproximadamente iguales. Sin embargo, no lo son.

Esta expresión es falsa:

'''' == null

El resultado de comparar cualquier cadena con un null es falso. Por lo tanto, pass == null y todas las demás pruebas son siempre falsas, y el usuario nunca recibe la alerta.

Para arreglar su código, compare cada valor con la cadena vacía:

pass === ''''

Si está seguro de que pass es una cadena, pass == '''' también funcionará porque solo una cadena vacía es aproximadamente igual a la cadena vacía. Por otro lado, algunos expertos dicen que es una buena práctica usar siempre una igualdad estricta en JavaScript, a menos que usted quiera hacer específicamente el tipo de coerción que realiza el operador de igualdad de igualdad.

Si desea saber qué pares de valores son aproximadamente iguales, consulte la tabla "Comparaciones de igualdad" en el artículo de Mozilla sobre este tema .

Answer 2

En primer lugar, tiene una declaración de retorno sin un cuerpo de función. Lo más probable es que se produzca un error.

Una forma más limpia de hacer su cheque sería simplemente usar el! operador:

if (!pass || !cpass || !email || !cemail || !user) {
alert("fill all columns");
}

Answer 3

En realidad, creo que es posible que deba usar if (value !== null || value !== undefined) porque si usa if (value) también puede filtrar 0 o valores falsos.

Considere estas dos funciones:

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

En mi situación, solo necesitaba comprobar si el valor es nulo e indefinido y no quería filtrar '''' valores 0 false o '''' . así que utilicé la segunda prueba, pero es posible que también deba filtrarlas, lo que puede hacer que use la primera prueba.

Answer 4

Este es un comentario sobre la solución de WebWanderer con respecto a la verificación de NaN (todavía no tengo suficiente representante para dejar un comentario formal). La solución se lee como

if(!parseInt(variable) && variable != 0 && typeof variable === "number")

pero esto fallará para los números racionales que se redondearían a 0 , como la variable = 0.1 . Una mejor prueba sería:

if(isNaN(variable) && typeof variable === "number")

Answer 5

Esto no funcionará en el caso de valores booleanos provenientes de DB para ej:

 value = false
if(!value) {
// it will change all false values to not available
return "not available"
}

Answer 6

Javascript es muy flexible en lo que respecta a la comprobación de valores "nulos". Supongo que en realidad estás buscando cadenas vacías, en cuyo caso funcionará este código más simple:

if(!pass || !cpass || !email || !cemail || !user){

Lo que buscará cadenas vacías ( "" ), null , undefined , false y los números 0 y NaN

Tenga en cuenta que si está verificando específicamente los números, es un error común omitir 0 con este método, y se prefiere num !== 0 (o num !== -1 o ~num (código hacky que también se compara con -1 )) para funciones que devuelven -1 , por ejemplo, indexOf )

Answer 7

Mejora con respecto a la respuesta aceptada comprobando explícitamente si es null pero con una sintaxis simplificada:

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

Answer 8

Para verificar nulo ESPECÍFICAMENTE usted usaría esto:

if(variable === null && typeof variable === "object")

... o más simplemente:

if(variable === null)

Esta prueba SÓLO pasará para null y no pasará para "" , undefined , false , 0 o NaN .

El resto de esto es en respuesta al comentario de inorganik, Sí, puede verificar cada uno individualmente.

Debe implementar el uso de absolutely equals: === y typeof para estar absolutamente seguro con sus cheques.

He creado un JSFiddle aquí para mostrar el funcionamiento de todas las pruebas individuales.

Aquí está toda la salida de las pruebas:

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

Como puede ver, es un poco más difícil probar contra NaN ;

Answer 9

Por favor, ver cuidadosamente antes de votar.

AFAIK en JAVASCRIPT cuando se declara una variable pero no tiene un valor asignado, su tipo undefined está undefined . por lo que podemos verificar la variable incluso si se trataría de un object con alguna instancia en lugar de valor .

cree un método auxiliar para comprobar la nulidad que devuelve true y utilícelo en su API.

Función auxiliar para comprobar si la variable está vacía:

function isEmpty(item){
if(item){
return false;
}else{
return true;
}
}

llamada de API excepcional 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;
}
}

algunos casos de prueba:

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

Answer 10

Prueba esto:

if (!variable && typeof variable === "object") {
// variable is null
}

Answer 11

para verificar si está indefinido y nulo en javascript solo necesita escribir lo siguiente:

if (!var) {
console.log("var IS null or undefined");
} else {
console.log("var is NOT null or undefined");
}

Answer 12

puedes usar intentar atrapar finalmente

 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 {}

También puedes throw tus propios errores. Ver this

Answer 13

simplemente reemplaza el == con === en todos los lugares.

== es una comparación de igualdad suelta o abstracta

=== es una comparación de igualdad estricta

Consulte el artículo de MDN sobre comparaciones de igualdad y la igualdad para obtener más detalles.

Answer 14

Operador de igualdad estricta: -

Podemos marcar nulo por ===

if ( value === null ){
}

Sólo usando if

if( value ) {
}

se evaluará como verdadero si el valor no es :

• nulo
• indefinido
• Yaya
• cuerda vacía ("")
• falso
• 0