validar - variable null javascript




¿Por qué es nulo un objeto y cuál es la diferencia entre nulo e indefinido? (14)

¿Cuál es la diferencia entre nulo e indefinido?

Una propiedad cuando no tiene definición, es indefinida. nulo es un objeto. Su tipo es objeto. nulo es un valor especial que significa "sin valor. indefinido no es un objeto, su tipo no está definido.

Puede declarar una variable, establecerla en nula, y el comportamiento es idéntico, excepto que verá "nulo" impreso frente a "indefinido". Incluso puede comparar una variable que no está definida a nula o viceversa, y la condición será verdadera:

 undefined == null
 null == undefined

Consulte la Diferencia de JavaScript entre nulo e indefinido para obtener más detalles.

y con tu nueva edición si

if (object == null)  does mean the same  if(!object)

cuando se prueba si el objeto es falso, ambos solo cumplen la condición cuando se prueba si es falso , pero no cuando es verdadero

Compruebe aquí: Javascript gotcha

¿Por qué se considera null un object en JavaScript?

Esta comprobando

if ( object == null )
      Do something

lo mismo que

if ( !object )
      Do something

?

Y también:

¿Cuál es la diferencia entre null e undefined ?


  1. No definido significa que una variable se ha declarado, pero no se le ha asignado ningún valor, mientras que Null se puede asignar a una variable que representa "sin valor" (Null es un operador de asignación)

2.Undefined es un tipo en sí mismo mientras que Null es un objeto.

3.Javascript puede inicializar cualquier variable no asignada a undefined pero nunca puede establecer el valor de una variable en nulo. Esto tiene que hacerse programáticamente.



De "Los principios del Javascript orientado a objetos" por Nicholas C. Zakas

Pero ¿por qué un objeto cuando el tipo es nulo? (De hecho, esto ha sido reconocido como un error por TC39, el comité que diseña y mantiene JavaScript. Podría razonar que el nulo es un puntero de objeto vacío, lo que hace que "objeto" tenga un valor de retorno lógico, pero aún así es confuso.)

Zakas, Nicholas C. (2014-02-07). Los Principios de JavaScript Orientado a Objetos (Ubicaciones Kindle 226-227). Sin prensa de almidón. Versión Kindle.

Dicho esto:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Caso indefinido:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

La diferencia se puede resumir en este fragmento:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

Comprobación

object == null es diferente para verificar if ( !object ) .

¡Este último es igual a ! Boolean(object) ! Boolean(object) , porque el unario ! el operador automáticamente convierte el operando correcto en un booleano.

Dado que Boolean(null) es igual a falso entonces !false === true .

Entonces, si su objeto no es nulo , sino falso o 0 o "" , la verificación se aprobará porque:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

La mejor manera de pensar en 'nulo' es recordar cómo se utiliza el concepto similar en las bases de datos, donde indica que un campo no contiene "ningún valor".

  • Sí, el valor del artículo es conocido; es 'definido'. Se ha inicializado.
  • El valor del ítem es: "no hay valor".

Esta es una técnica muy útil para escribir programas que se depuran más fácilmente. Una variable 'indefinida' podría ser el resultado de un error ... (¿cómo lo sabrías?) ... pero si la variable contiene el valor 'nulo', sabes que "alguien, en algún lugar de este programa, lo establece en 'nulo'. "Por lo tanto, sugiero que, cuando necesite deshacerse del valor de una variable, no" elimine "... configúrelo como 'nulo'. El valor anterior quedará huérfano y pronto se recogerá la basura; el nuevo valor es "no hay valor (ahora)". En ambos casos, el estado de la variable es cierto: "obviamente, deliberadamente, fue así".


La siguiente función muestra por qué y es capaz de resolver la diferencia:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

Si llamas

test();

Estás recibiendo

indefinido

nulo

El primer console.log(...) intenta obtener myProperty de myObj cuando aún no está definido, por lo que vuelve "indefinido". Después de asignarle un valor nulo, el segundo console.log(...) devuelve obviamente "nulo" porque myProperty existe, pero tiene el valor null asignado.

Para poder consultar esta diferencia, JavaScript tiene un null e undefined : mientras que un objeto es null , al igual que en otros idiomas, un objeto, undefined no puede ser un objeto porque no hay ninguna instancia disponible (ni siquiera una instancia null ).


Mira esto:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

Por ejemplo window.someWeirdProperty no está definido, por lo que

"window.someWeirdProperty === null" evalúa como falso mientras

"window.someWeirdProperty === undefined" evalúa como verdadero.

Además, checkif if (!o) no es lo mismo que verificar if (o == null) para que o sea false .


Primera parte de la pregunta:

¿Por qué se considera nulo un objeto en JavaScript?

Es un error de diseño de JavaScript que no pueden arreglar ahora. Debería haber sido de tipo nulo, no de tipo objeto o no tenerlo en absoluto. Requiere una comprobación adicional (a veces olvidada) al detectar objetos reales y es fuente de errores.

Segunda parte de la pregunta:

Esta comprobando


if (object == null)
Do something

lo mismo que

if (!object)
Do something

Los dos controles siempre son falsos, excepto por:

  • El objeto es indefinido o nulo: ambos verdaderos.

  • el objeto es primitivo, y 0, "" o falso: primero verifique falso, segundo verdadero.

Si el objeto no es primitivo, sino un Objeto real, como el new Number(0) , la new String("") , o el new Boolean(false) , entonces ambas comprobaciones son falsas.

Entonces, si se interpreta que 'objeto' significa un objeto real, entonces ambas comprobaciones son siempre las mismas. Si se permiten primitivas, las comprobaciones son diferentes para 0, "" y falso.

En casos como object==null , los resultados no obvios podrían ser una fuente de errores. El uso de == no se recomienda nunca, use === lugar.

Tercera parte de la pregunta:

Y también:

¿Cuál es la diferencia entre nulo e indefinido?

En JavaScript, una diferencia es que null es de tipo objeto y no definido es de tipo indefinido.

En JavaScript, null==undefined es verdadero, y se considera igual si se ignora el tipo. Por qué decidieron eso, pero 0 "" y falso no son iguales, no lo sé. Parece ser una opinión arbitraria.

En JavaScript, null===undefined no es verdadero ya que el tipo debe ser el mismo en === .

En realidad, nulo e indefinido son idénticos, ya que ambos representan la no existencia. También lo hacen 0, y "" para el caso también, y quizás los contenedores vacíos [] y {} . Tantos tipos de la misma nada son una receta para los errores. Un tipo o ninguno en absoluto es mejor Intentaría usar lo menos posible.

'falso', 'verdadero' y '!' Hay otra bolsa de gusanos que podría simplificarse, por ejemplo, if(!x) y if(x) son suficientes, no es necesario que sea verdadero o falso.

Una var x declarada es de tipo indefinido si no se da ningún valor, pero debería ser igual que si nunca se hubiera declarado x. Otra fuente de error es un contenedor de nada vacío. Así que es mejor declararlo y definirlo juntos, como var x=1 .

La gente da vueltas y vueltas en círculos tratando de descubrir todos estos tipos diferentes de nada, pero todo es exactamente lo mismo en prendas diferentes y complicadas. La realidad es

undefined===undeclared===null===0===""===[]==={}===nothing

Y tal vez todos deberían lanzar excepciones.


null y undefined son falsos para la igualdad de valores (null == undefined): ambos se colapsan a boolean false. No son el mismo objeto (nulo! == indefinido).

undefined es una propiedad del objeto global ("ventana" en los navegadores), pero es un tipo primitivo y no un objeto en sí. Es el valor predeterminado para las variables y las funciones sin inicializar que finalizan sin una declaración de retorno.

null es una instancia de Object. null se utiliza para los métodos DOM que devuelven objetos de colección para indicar un resultado vacío, lo que proporciona un valor falso sin indicar un error.


null no es un objeto , es un valor primitivo . Por ejemplo, no puede agregarle propiedades. A veces la gente asume erróneamente que es un objeto, porque typeof null devuelve "object" . Pero eso es realmente un error (que incluso podría ser arreglado en ECMAScript 6).

La diferencia entre null e undefined es la siguiente:

  • undefined : utilizado por JavaScript y significa "sin valor". Las variables no inicializadas, los parámetros que faltan y las variables desconocidas tienen ese valor.

    > var noValueYet;
    > console.log(noValueYet);
    undefined
    
    > function foo(x) { console.log(x) }
    > foo()
    undefined
    
    > var obj = {};
    > console.log(obj.unknownProperty)
    undefined
    

    Acceder a variables desconocidas, sin embargo, produce una excepción:

    > unknownVariable
    ReferenceError: unknownVariable is not defined
    
  • null : utilizado por los programadores para indicar "sin valor", por ejemplo, como un parámetro para una función.

Examinando una variable:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

Como regla general, siempre debe usar === y nunca == en JavaScript (== realiza todo tipo de conversiones que pueden producir resultados inesperados). El check x == null es un caso de borde, porque funciona tanto para null como para undefined :

> null == null
true
> undefined == null
true

Una forma común de verificar si una variable tiene un valor es convertirla en booleana y ver si es true . Esa conversión es realizada por la sentencia if y el operador booleano. ("no").

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

Inconveniente de este enfoque: todos los valores siguientes se evalúan como false , por lo que debe tener cuidado (por ejemplo, las comprobaciones anteriores no pueden distinguir entre undefined y 0 ).

  • undefined , null
  • Booleanos: false
  • Números: +0 , -0 , NaN
  • Cuerdas: ""

Puede probar la conversión a booleano utilizando Boolean como una función (normalmente es un constructor, para usar con el new ):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

(name is undefined)

Tu: ¿Qué es el name ? (*)
JavaScript: name ? Cual es un name No sé de qué estás hablando. Nunca antes has mencionado ningún name . ¿Está viendo algún otro lenguaje de scripting en el lado (cliente)?

name = null;

Tu: ¿Qué es el name ?
JavaScript: No lo sé.

En breve; undefined es donde no existe noción de la cosa; no tiene ningún tipo, y nunca se ha mencionado antes en ese ámbito; null es donde se sabe que existe la cosa, pero no se sabe cuál es el valor.

Una cosa para recordar es que null no es, conceptualmente, lo mismo que false o "" o algo así, incluso si se equiparan después de la conversión de tipos, es decir,

name = false;

Tu: ¿Qué es el name ?
JavaScript: booleano falso.

name = '';

Tu: ¿Qué es el name ?
JavaScript: cadena vacía

*: el name en este contexto se entiende como una variable que nunca se ha definido. Podría ser cualquier variable indefinida. Sin embargo, el nombre es una propiedad de casi cualquier elemento de formulario HTML. Va camino, hace mucho tiempo y fue instituido mucho antes de la identificación. Es útil porque los identificadores deben ser únicos pero los nombres no deben ser.


var x = null;

x se define como nulo

y no está definido; // porque no lo definí

if (!x)

nulo se evalúa como falso





typeof