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

¿Por qué se nullconsidera un objecten JavaScript?

Está comprobando

if ( object == null )
      Do something

lo mismo que

if ( !object )
      Do something

?

Y también:

¿Cuál es la diferencia entre nully undefined?

(name is undefined)

Tu: ¿Qué es name? ^(*)
JavaScript name :? ¿Qué es un name? No sé de qué estás hablando. Nunca has mencionado ninguno nameantes. ¿Ves algún otro lenguaje de script en el lado (cliente)?

name = null;

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

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

Una cosa para recordar es que null, conceptualmente, no es igual falseo similar "", incluso si se equiparan después de la conversión de tipos, es decir

name = false;

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

name = '';

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

^{*: nameen 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 muy atrás y fue instituido mucho antes de la identificación. Es útil porque los identificadores deben ser únicos, pero los nombres no tienen que serlo.}

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 == nullEs diferente verificar if ( !object ).

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

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

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

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

nullNo es un objeto , es un valor primitivo . Por ejemplo, no puede agregarle propiedades. A veces las personas suponen erróneamente que es un objeto, porque typeof nullregresa "object". Pero eso es realmente un error (que incluso podría corregirse en ECMAScript 6).

La diferencia entre nully undefinedes la siguiente:

• undefined: utilizado por JavaScript y significa "sin valor". Las variables no inicializadas, los parámetros faltantes 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
  

  Sin embargo, acceder a variables desconocidas produce una excepción:

  > unknownVariable
  ReferenceError: unknownVariable is not defined
  

• null: utilizado por los programadores para indicar "sin valor", por ejemplo, como parámetro de 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 cheque x == nulles un caso límite, porque funciona para ambos nully undefined:

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

Una forma común de verificar si una variable tiene un valor es convertirla a booleana y ver si es true. ¡Esa conversión es realizada por la ifdeclaración 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: se evalúan todos los siguientes valores false, por lo que debe tener cuidado (por ejemplo, las comprobaciones anteriores no pueden distinguir entre undefinedy 0).

• undefined, null
• Booleanos: false
• Números: +0, -0,NaN
• Instrumentos de cuerda: ""

Puede probar la conversión a booleana utilizando Booleancomo una función (normalmente es un constructor, para ser utilizado con new):

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

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

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

Puede declarar una variable, establecerla como nula, y el comportamiento es idéntico, excepto que verá "nulo" impreso versus "indefinido". Incluso puede comparar una variable que no está definida como 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 sí

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

Marque aquí: Javascript tiene

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 solucionar ahora. Debería haber sido tipo nulo, no tipo objeto, o no tenerlo en absoluto. Necesita una verificación adicional (a veces olvidada) al detectar objetos reales y es fuente de errores.

Segunda parte de la pregunta:

Está comprobando


if (object == null)
Do something

lo mismo que

if (!object)
Do something

Las dos verificaciones son siempre falsas, excepto por:

• El objeto es indefinido o nulo: ambos verdaderos.

• object es primitivo, y 0, ""o false: primero verifica falso, segundo verdadero.

Si el objeto no es una primitiva, sino un objeto real, al igual que new Number(0), new String("")o new Boolean(false), a continuación, ambos cheques son falsos.

Entonces, si 'objeto' se interpreta como un Objeto real, ambas verificaciones son siempre iguales. 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 ===en su 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 undefined es de tipo undefined.

En JavaScript, null==undefinedes 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===undefinedno es cierto ya que el tipo debe ser el mismo en ===.

En realidad, nulo e indefinido son idénticos, ya que ambos representan la no existencia. Entonces haga 0, y ""para el caso también, y tal vez los contenedores vacíos []y {}. Muchos tipos de lo mismo, nada son una receta para los errores. Un tipo o ninguno es mejor. Intentaría usar la menor cantidad posible.

'falso', 'verdadero' y '!' son otra bolsa de gusanos que podrían simplificarse, por ejemplo, if(!x)y if(x)solo son suficientes, no necesita verdadero y falso.

Un declarado var xes de tipo indefinido si no se proporciona ningún valor, pero debería ser el mismo que si x nunca se declarara. Otra fuente de error es un contenedor vacío de nada. Por lo tanto, 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 de nada, pero todo es lo mismo en diferentes prendas complicadas. La realidad es

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

Y tal vez todos deberían lanzar excepciones.

var x = null;

x se define como nulo

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

if (!x)

nulo se evalúa como falso

Una forma de dar sentido a nulo e indefinido es entender dónde ocurre cada uno.

Espere un valor de retorno nulo en las siguientes situaciones:

• Métodos que consultan el DOM

  console.log(window.document.getElementById("nonExistentElement"));
  //Prints: null

• Respuestas JSON recibidas de una solicitud de Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Nueva funcionalidad que está en un estado de flujo. Lo siguiente devuelve nulo:

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

Todos los demás casos de inexistencia se denotan por indefinido (como lo señaló @Axel). Cada una de las siguientes impresiones "indefinidas":

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

Por supuesto, si decide escribir var unitialised = null; o devuelva nulo de un método usted mismo, entonces tiene nulo en otras situaciones. Pero eso debería ser bastante obvio.

Un tercer caso es cuando desea acceder a una variable pero ni siquiera sabe si se ha declarado. Para ese caso, use typeof para evitar un error de referencia:

if(typeof unknown !== "undefined"){
    //use unknown
}

En resumen, compruebe si hay valores nulos cuando manipula el DOM, trata con Ajax o usa ciertas características de ECMAScript 5. Para todos los demás casos, es seguro verificar si no está definido con igualdad estricta:

if(value === undefined){
  // stuff
}

Comparación de muchos cheques nulos diferentes en JavaScript:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

nulo e indefinido son falsos para la igualdad de valores (nulo == indefinido): ambos colapsan a falso booleano. 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í mismo. Es el valor predeterminado para variables no inicializadas y funciones que terminan sin una declaración de retorno.

null es una instancia de Object. nulo se usa para 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.

Algunas precisiones:

nulo e indefinido son dos valores diferentes. Uno representa la ausencia de un valor para un nombre y el otro representa la ausencia de un nombre.

Lo que sucede en un ifva de la siguiente manera para if( o ):

Se evalúa la expresión entre paréntesis o, y luego las ifpatadas al coaccionar el valor de la expresión entre paréntesis, en nuestro caso o.

Los valores de falsa (que se convertirán en falsos) en JavaScript son: '', nulo, indefinido, 0 y falso .

Para agregar a la respuesta de ¿Cuál es la diferencia entre undefinedynull , de JavaScript Definitive Guide 6th Edition, p.41 en esta página :

Puede considerar undefinedrepresentar nulluna ausencia de valor a nivel de sistema, inesperada o similar a un error y representar la ausencia de valor a nivel de programa, normal o esperada. Si necesita asignar uno de estos valores a una variable o propiedad o pasar uno de estos valores a una función, nulles casi siempre la opción correcta.

nullEs un objeto. Su tipo es nulo. undefinedno es un objeto; Su tipo es indefinido.

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

Te estas poniendo

indefinido

nulo

Los primeros console.log(...)intentos para obtener myPropertya partir de myObjcuando aún no está definido - por lo que vuelve "indefinido". Después de asignarle nulo, el segundo console.log(...)devuelve obviamente "nulo" porque myPropertyexiste, pero tiene el valor nullasignado.

Para poder consultar esta diferencia, JavaScript tiene nully undefined: Mientras nulles, al igual que en otros idiomas, un objeto, undefinedno puede ser un objeto porque no hay una instancia (ni siquiera una nullinstancia) disponible.

Por ejemplo window.someWeirdProperty, no está definido, entonces

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

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

Checkif Por otra parte if (!o), no es la misma que la comprobación if (o == null)de oestar false.

La otra cosa divertida de nulo, en comparación con indefinido, es que se puede incrementar.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

Esto es útil para establecer valores numéricos predeterminados para contadores. ¿Cuántas veces ha establecido una variable a -1 en su declaración?

En Javascript null no es un objecttipo, es un primitavetipo.

¿Cuál es la diferencia? Indefinido se refiere a un puntero que no se ha establecido. Nulo se refiere al puntero nulo, por ejemplo, algo ha configurado manualmente una variable para que sea de tiponull

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

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

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

Zakas, Nicholas C. (2014-02-07). Los principios de JavaScript orientado a objetos (ubicaciones de Kindle 226-227). No Starch Press. Versión Kindle.

Eso dijo:

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 mejor manera de pensar en 'nulo' es recordar cómo se usa un concepto similar en las bases de datos, donde indica que un campo contiene "ningún valor".

• Sí, se conoce el valor del artículo; que se 'define'. Se ha inicializado.
• El valor del artículo 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, configúralo en 'nulo'. "Por lo tanto, sugiero que, cuando necesite deshacerse del valor de una variable, no" elimine "... configúrelo en 'nulo'. El valor anterior quedará huérfano y pronto se recolectará basura; el nuevo valor es "no hay valor (ahora)". En ambos casos, el estado de la variable es seguro: "obviamente, de manera deliberada, se puso de esa manera".

1. Indefinido significa que se ha declarado una variable 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. Indefinido es un tipo en sí mismo, mientras que Nulo es un objeto.

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