tipo - ¿Qué razón hay para usar null en lugar de indefinido en JavaScript?

que es undefined javascript

Question

He estado escribiendo JavaScript durante bastante tiempo, y nunca tuve una razón para usar null . Parece que lo undefined siempre es preferible y cumple el mismo objetivo programáticamente. ¿Cuáles son algunas razones prácticas para usar null lugar de undefined ?

Answer 1

Al final del día, debido a que tanto el null como el undefined coercen con el mismo valor ( Boolean(undefined) === false && Boolean(null) === false ), puede usarlo técnicamente para realizar el trabajo. Sin embargo, hay una forma correcta, IMO.

1. Deje el uso de undefined en el compilador de JavaScript.

   undefined se usa para describir variables que no apuntan a una referencia. Es algo que el compilador JS cuidará de ti. En tiempo de compilación, el motor JS establecerá el valor de todas las variables undefined en undefined . A medida que el motor avance por el código y los valores estén disponibles, el motor asignará los valores respectivos a las variables respectivas. Para aquellas variables para las que no se encontraron valores, las variables continuarían manteniendo una referencia a la primitiva undefined .

2. Use null solo si quiere indicar explícitamente el valor de una variable como "sin valor".

   Como dice @ com2gz: null se usa para definir algo programáticamente vacío. undefined pretende decir que la referencia no existe. Un valor null tiene una referencia definida a "nada". Si está llamando a una propiedad no existente de un objeto, entonces será undefined . Si quisiera que esa propiedad esté intencionalmente vacía, entonces debe ser null para que sepa que es a propósito.

TLDR; No use la primitiva undefined . Es un valor que el compilador JS configurará automáticamente cuando declare variables sin asignación o si intenta acceder a propiedades de objetos para los cuales no hay referencia. Por otro lado, use null si y solo si desea intencionalmente que una variable tenga "ningún valor".

Nunca configuré explícitamente algo indefinido (y no me he encontrado con esto en las muchas bases de código con las que he interactuado). Además, rara vez uso null . Las únicas veces que utilizo null es cuando quiero denotar el valor de un argumento para una función que no tiene ningún valor, es decir ,:

function printArguments(a,b) {
  console.log(a,b);
}

printArguments(null, " hello") // logs: null hello

Answer 2

Aquí hay una razón: var undefined = 1 es javascript legal, pero var null = 1 es un error de sintaxis. La diferencia es que null es una palabra clave de idioma, mientras que undefined es, por alguna razón, no.

Si su código se basa en comparaciones undefined como si fuera una palabra clave ( if (foo == undefined) - un error muy fácil de hacer) que solo funciona porque nadie ha definido una variable con ese nombre. Todo ese código es vulnerable a que alguien, accidental o maliciosamente, defina una variable global con ese nombre. Por supuesto, todos sabemos que definir accidentalmente una variable global es totalmente imposible en javascript ...

Answer 3

Estoy trabajando en esta pregunta exacta en este momento, y estoy mirando la siguiente filosofía:

1. Cualquier función que está destinada a devolver un resultado debe devolver nulo si no puede encontrar un resultado
2. Cualquier función que NO está destinada a devolver un resultado devuelve implícitamente indefinido.

Para mí, esta pregunta es importante porque cualquier persona que llame a una función que devuelva un resultado no debería tener dudas sobre si debe probar si es indefinido o nulo.

Esta respuesta no intenta abordar:

1. Valores de propiedad de null vs undefined
2. Las variables dentro de sus funciones son nulas frente a indefinidas

En mi opinión, las variables son su propio negocio y no una parte de su API, y las propiedades en cualquier sistema OO están definidas y, por lo tanto, deberían definirse con un valor diferente de lo que serían si no se definieran (nulo por definido, indefinido es lo que obtener cuando se accede a algo que no está en su objeto).

Answer 4

Los nodos DOM y los elementos no están indefinidos, pero pueden ser nulos.

• El nextSibling del último hijo de un elemento es nulo.

• El hermano anterior del primer hijo es nulo.

• Una referencia document.getElementById es nula si el elemento no existe en el documento.

Pero en ninguno de estos casos es el valor indefinido ; simplemente no hay ningún nodo allí.

Answer 5

No estoy completamente de acuerdo con que el uso nulo o indefinido sea innecesario. indefinido es lo que mantiene vivo todo el proceso de encadenamiento del prototipo. Así que el compilador solo con null no puede verificar si esta propiedad es igual a null, o no está definida en el prototipo del endpoint. En otros lenguajes de tipado dinámico (fe Python) arroja una excepción si desea acceder a una propiedad no definida, pero para los lenguajes basados ​​en prototipos, el compilador también debe verificar los prototipos principales y aquí están los lugares donde más se necesita.

El significado total del uso de null es simplemente vincular la variable o la propiedad con el objeto que es singleton y tiene un significado de vacío, y también el uso nulo tiene fines de rendimiento. Este 2 código tiene un tiempo de ejecución de diferencia.

var p1 = function(){this.value = 1};
var big_array = new Array(100000000).fill(1).map((x, index)=>{
    p = new p1();
    if(index > 50000000){
       p.x = "some_string";
    }

    return p;
});
big_array.reduce((sum, p)=> sum + p.value, 0)

var p2 = function(){this.value = 1, p.x = null};
var big_array = new Array(100000000).fill(1).map((x, index)=>{
    p = new p2();
    if(index > 50000000){
       p.x = "some_string";
    }

    return p; 
});
big_array.reduce((sum, p)=> sum + p.value, 0)

Answer 6

Nulo e indefinido son esencialmente dos valores diferentes que significan lo mismo. La única diferencia está en las convenciones de cómo los usa en su sistema. Como algunos han mencionado, algunas personas usan nulo para significar "ningún objeto" donde a veces puede obtener un objeto mientras no está definido significa que no se esperaba ningún objeto (o que hubo un error). Mi problema con eso es completamente arbitrario y totalmente innecesario.

Dicho esto, hay una gran diferencia: las variables que no se inicializan (incluidos los parámetros de funciones donde no se aprobó ningún argumento, entre otras cosas) siempre están indefinidas.

Por eso, en mi código, nunca uso null a menos que algo que no controlé devuelva nulo (por ejemplo, ajuste de expresiones regulares). La belleza de esto es que simula las cosas mucho. Nunca tengo que verificar si x === undefined || x === nulo. Y si tienes el hábito de usar == o simplemente cosas como si (x) .... Para. !x evaluará a verdadero para una cadena vacía, 0, nulo, NaN - es decir, cosas que probablemente no desee. Si desea escribir javascript que no sea horrible, siempre use triple equals === y nunca use null (use undefined en su lugar). Te hará la vida mucho más fácil.

Answer 7

Puede adoptar la convención sugerida aquí, pero realmente no hay una buena razón para hacerlo. No se usa de manera consistente para ser significativo.

Para que la convención sea útil, primero debe saber que la función llamada sigue la convención. Luego debe probar explícitamente el valor devuelto y decidir qué hacer. Si no está definido , puede suponer que se produjo algún tipo de error que la función llamada conocía . Pero si ocurrió un error, y la función lo sabía, y es útil enviarlo a un entorno más amplio, ¿por qué no utilizar un objeto de error? es decir, arrojar un error?

Entonces, al final del día, la convención es prácticamente inútil en cualquier cosa que no sean programas muy pequeños en entornos simples.

Answer 8

Realmente no tengo una respuesta, pero de acuerdo con Nicholas C. Zakas , página 30 de su libro " JavaScript profesional para desarrolladores web " :

Al definir una variable destinada a contener más tarde un objeto, es aconsejable inicializar la variable como null en lugar de cualquier otra cosa. De esta forma, puede verificar explícitamente el valor null para determinar si la variable se ha rellenado con una referencia de objeto en un momento posterior

Answer 9

Todos tenemos su propia forma de codificación y su propia semántica interna, pero a lo largo de los años he encontrado que este es el consejo más intuitivo que les doy a las personas que hacen esta pregunta: cuando dudes, haz lo que hace JavaScript .

Supongamos que está trabajando con propiedades de objeto, como opciones para un complemento de jQuery ... pregúntese qué valor le da a JavaScript una propiedad que aún no se ha definido; la respuesta es undefined . Entonces, en este contexto, inicializaría este tipo de cosas con ''indefinido'' para ser coherente con JavaScript (para las variables, puede hacer var myVar; lugar de var myVar = undefined; ).

Ahora digamos que está haciendo manipulación de DOM ... ¿qué valor asigna JavaScript a los elementos inexistentes? La respuesta es null . Este es el valor con el que iniciaría si está creando una variable de marcador de posición que posteriormente tendrá una referencia a un elemento, fragmento de documento o similar que se relaciona con el DOM.

Si está trabajando con JSON, se debe realizar un caso especial: para valores de propiedad no definidos, debe establecerlos en "" o null porque un valor de undefined no se considera formato JSON adecuado.

Dicho esto, como ha expresado un afiche anterior, si descubres que estás inicializando cosas con null o undefined más de una vez en una luna azul, entonces tal vez deberías reconsiderar cómo vas a codificar tu aplicación.

Answer 10

Una propiedad útil en null que undefined no califica:

> null + 3
3
> undefined + 3
NaN

Uso null cuando quiero ''apagar'' un valor numérico, o para inicializar algunos. Mi último uso fue manipular la transformación css:

const transforms = { perspective : null, rotateX : null };
// if already set, increase, if not, set to x
runTimeFunction((x) => { trasforms.perspective += x; });
// still useful, as setting perspective to 0 is different than turning it off
runTimeFunction2((x) => { transforms.perspective = null; });

// toCss will check for ''null'' values and not set then at all
runTimeFunction3(() => { el.style.transform = toCss(transforms); });

No estoy seguro si debería usar esta propiedad pensamiento ...

Answer 11

indefinido es donde no existe ninguna noción de la cosa; no tiene ningún tipo y nunca se ha hecho referencia a él en ese ámbito; null es donde se sabe que existe la cosa, pero no tiene ningún valor.