quitar - typeof javascript

¿Por qué hay un valor ''nulo'' en JavaScript?

Question

En JavaScript, hay dos valores que básicamente dicen ''Yo no existo'' - undefined y null .

Una propiedad a la que un programador no ha asignado nada no estará undefined , pero para que una propiedad se vuelva null , null debe asignarse explícitamente.

Una vez pensé que había una necesidad de null porque undefined es un valor primitivo y null un objeto. No lo es, incluso si typeof null arrojará ''object'' : en realidad, ambos son valores primitivos, lo que significa que ni undefined ni null pueden devolverse desde una función de constructor, ya que ambos se convertirán en un objeto vacío (hay que arrojar un error proclamar fracaso en constructores).

También ambos evalúan a false en contextos booleanos. La única diferencia real que puedo pensar es que uno evalúa a NaN , el otro a 0 en contextos numéricos.

Entonces, ¿por qué hay ambos undefined y null si esto solo confunde a los programadores que están buscando incorrectamente el null cuando intentan averiguar si una propiedad se ha establecido o no?

Lo que me gustaría saber es si alguien tiene un ejemplo razonable en el que es necesario usar un null que, en su lugar, no podría expresarse utilizando undefined .

Entonces, el consenso general parece ser que " undefined " significa "no existe tal propiedad" mientras que null significa "la propiedad existe, pero no tiene valor".

Podría vivir con eso si las implementaciones de JavaScript realmente imponen este comportamiento, pero undefined es un valor primitivo perfectamente válido, por lo que puede asignarse fácilmente a las propiedades existentes para romper este contrato. Por lo tanto, si desea asegurarse de que existe una propiedad, debe usar el operador in o hasOwnProperty() todos modos. Entonces, una vez más: ¿cuál es el uso práctico para valores separados para undefined y null ?

De hecho, uso undefined cuando quiero desarmar los valores de las propiedades que ya no se usan pero que no quiero delete . ¿Debo usar null lugar?

Answer 1

null es hermoso

como son todos los otros tipos de Live Script.

cita: en JavaScript, hay dos valores que básicamente dicen ''No existo'' - indefinido y nulo.

¿Por qué querrías decir cosas incorrectas?

"nulo" es "Objeto vacío" al igual que "0" es un "Número vacío" . 0, no es nada, pero existe como una cosa Tipo de Número. null, por supuesto, también está vacío, pero "es" y es una cosa bien definida de un Tipo de objeto .

Es común hablar de estas cosas como de "tipos", cuando no lo son. De hecho, son "categorías". Pero eso ya pasó.

Así que nos apegaremos a decir que "nulo" es un tipo de objeto sin clase. Y "nulo" dice "¡Existo mucho [!], Pero no tengo contenido de mi tipo".

Mientras que undefined carece tanto del tipo como de la clase donde undefined también es su definición de tipo. Un tipo indefinido de un tipo se convierte en su tipología distintiva. Existe una especie de [¿nada "y cómo se define" nada "?] Pregunta.

cita: indefinido ni nulo se pueden devolver desde una función constructora, ya que ambos serán convertidores a un objeto vacío

Has logrado decir una vez más algo incorrecto. Por supuesto que no, lo "indefinido" no es un Objeto, es un Símbolo simple que los humanos entendemos; pero en contra de ese nulo está, y te dice eso: su Tipo es correcto, pero el Tipo que estás buscando no está contenido en él, o al menos, no en este momento. Ven a visitarnos más tarde cuando pongamos / assign some object in / to it.

cita: La única diferencia real que puedo pensar es que uno evalúa a NaN, el otro a 0 en contextos numéricos.

Eso hace que el objetivo de su distinción principal sea el mencionado: undefined es un token simple y como está compuesto del mismo material "genético" que sus parientes distantes: strings, la operación [+ undefined] lo convertirá en pato. NaN, similarmente nulo, por supuesto, se transformará en un tipo correcto 0 / Number en su lugar, y en lugar de indefinido que se transformará en una cadena (! Que no está vacía!) Y es exactamente por eso que produce NaN en su lugar. Donde: + undefined >> + "undefined" >> NaN. Dado que el contexto numérico espera un valor explícito.

Mientras que el contexto booleano espera referencia: no encuentra nada que convertir y arroja ''falso''.

Vamos a cortar ahora ...

cite: Así que una vez más: ¿cuál es el uso práctico para valores separados para indefinido y nulo?

Trataré de darte solo dos ejemplos empíricos y espero que sean suficientes

oElement.onclick >> null

// significa que la propiedad existe; su valor esperado es Type: Object , y ¡oElement soporta el evento "onclick"!

oElement.innerText >> ""

// significa que la propiedad existe; su valor esperado es Type: String , lo que significa que oElement admite la propiedad "innerText".

en ambos casos, si recibe "indefinido", significa que la propiedad no existe; no es compatible o tiene una implementación incorrecta (ua proveedor).

Quédate helada y diviértete.

Answer 2

Como programador de Java, veo una gran diferencia entre indefinido y nulo. Codifica JavaScript, no tanto, porque JavaScript no está fuertemente tipado, y las diferencias entre indefinido y nulo se ven borrosas por las conversiones automáticas que se realizan frecuentemente por el tiempo de ejecución. Por cierto, aprovecho frecuentemente esas conversiones; hacen que mi código JS sea más compacto y legible.

Para responder a su pregunta, indefinido significa que nunca se estableció un valor. En términos prácticos, esto generalmente apunta a un error. Si yourObject.property no está definido, eso significa que no ha establecido la propiedad por algún motivo, o estoy buscando algo que no existe en absoluto. Este es un problema real cuando se trabaja en un proyecto con más de un codificador.

null significa que "sin valor" se estableció explícitamente. En términos prácticos, me está diciendo algo acerca de la propiedad, tal vez que no se utiliza en este contexto, o que un valor aún no se ha determinado.

En Java, los intentos de acceder a un campo que no está definido siempre tendrán como resultado una excepción. De hecho, se puede hacer que el compilador lo advierta sobre esto en su código.

Answer 3

Creo que su conclusión de que JavaScript define undefined como "no hay tal propiedad" y null como "la propiedad no tiene valor" es perfectamente correcta. Y en un lenguaje tan dinámico como JavaScript, es una distinción muy importante. El uso de la tipificación de pato significa que debemos ser capaces de diferenciar entre una propiedad que no existe y que no tiene un valor. Es nuestro medio principal de obtener información de tipo. en un lenguaje tipado estáticamente existe una distinción definida entre un campo que es nulo y un campo que no existe. En JavaScript esto no es diferente. Sin embargo, se verifica en tiempo de ejecución y puede modificarse hasta ese momento.

Voy a tener que aceptar que la implementación es extraña, ya que muchas veces la distinción es borrosa. Sin embargo, creo que en JavaScript la distinción es importante. Y poder asignar undefined es esencial.

Recuerdo haber leído una publicación de blog hace un tiempo sobre un juego de rol en línea escrito en JavaScript. Utilizaba ejemplos donde los objetos se creaban como copias de instancias existentes en lugar de prototipos (clases, funciones, lo que sea) y luego se alteraban. Esto realmente me hizo entender lo poderoso que podría ser ese undefined al modificar objetos existentes, pero no recuerdo quién lo escribió.

Answer 4

De lo que se trata es de la naturaleza dinámica de javascripts.

Las cosas pueden estar indefinidas para que puedan agregarse en un momento posterior. Podría decirse que este javascript es tan poderoso y extensible.

Answer 5

Es completamente posible necesitar ambos. Por ejemplo, si consulta WMI, es completamente posible tener una clase devuelve propiedades que tienen un valor nulo. Están definidos, simplemente pasan a ser nulos en ese momento.

Answer 6

La pregunta no es realmente "por qué hay un valor nulo en JS": existe un valor nulo de algún tipo en la mayoría de los lenguajes y generalmente se considera muy útil.

La pregunta es, "¿por qué hay un valor indefinido en JS". Lugares principales donde se usa:

1. cuando declaras ''var x;'' pero no le asignes, x tiene indefinido;
2. cuando su función obtiene menos argumentos de los que declara;
3. cuando accede a una propiedad de objeto inexistente.

''nulo'' ciertamente habría funcionado igual de bien para (1) y (2) *. (3) debería lanzar una excepción de inmediato, y el hecho de que no lo haga, en lugar de devolver este raro ''indefinido'' que fallará más tarde, es una gran fuente de dificultad para la depuración.

*: también podría argumentar que (2) debería arrojar una excepción, pero luego tendría que proporcionar un mecanismo mejor y más explícito para los argumentos por defecto / variable.

Sin embargo, JavaScript originalmente no tenía excepciones, o cualquier forma de preguntarle a un objeto si tenía un miembro con un nombre determinado: la única forma era (y algunas veces lo es) de acceder al miembro y ver lo que obtienes. Dado que ''nulo'' ya tiene un propósito y es posible que desee establecer un miembro, se requiere un valor diferente fuera de banda. Así que tenemos ''indefinido'', es problemático como usted señala, y es otra gran ''característica'' de JavaScript de la que nunca podremos deshacernos.

De hecho, uso indefinido cuando quiero desarmar los valores de las propiedades que ya no se usan pero que no quiero eliminar. ¿Debo usar null en su lugar?

Sí. Mantenga ''indefinido'' como un valor especial para la señalización cuando otros lenguajes arrojen una excepción.

''null'' es generalmente mejor, excepto en algunas interfaces IE DOM donde establecer algo en ''nulo'' puede darle un error. A menudo, en este caso, la configuración de la cadena vacía tiende a funcionar.

Answer 7

Mejor descrito here , pero en resumen:

indefinido es la falta de un tipo y valor, y nulo es la falta de un valor.

Además, si estás haciendo comparaciones ''=='' simples, tienes razón, salen igual. Pero pruebe ===, que compara tanto el tipo como el valor, y notará la diferencia.

Answer 8

No creo que haya ninguna razón para tener ambos null e undefined , porque la única razón que muchas personas han sugerido (" undefined significa que no existe tal variable / propiedad") no es válida, al menos en JavaScript. undefined no puede decirle si la variable / propiedad existe o no.

console.log(foo);               // "ReferenceError: foo is not defined"
                                // foo does not exist
var foo;
console.log(foo);               // "undefined", a different response
console.log(foo === undefined); // "true", but it does exist

var obj = {};
console.log(obj.hasOwnProperty("foo")); // "false", no such property
obj.foo = undefined;
console.log(obj.hasOwnProperty("foo")); // "true", it exists and has the value "undefined"
console.log(obj.foo === undefined);     // "true", but it does exist

obj.bar = "delete me";
obj.bar = undefined;
console.log(obj.hasOwnProperty("bar")); // "true", not actually deleted
delete obj.bar;
console.log(obj.hasOwnProperty("bar")); // "false", deleted

Como puede ver, comprobar foo === undefined no le dice si foo existe, y establecer obj.bar = undefined no borra la bar .

Puede ser la intención original del autor de JavaScript que undefined represente "inexistencia". Sin embargo, la implementación no resultó de esa manera.

Answer 9

Prueba este ejemplo:

<html>
<head>
    <script type="text/javascript">
        function ShowObjProperties(obj) {
            var property, propCollection = "";

            for(property in obj) {
                propCollection += (property + ": " + obj[property] + "/n");
            }

            alert(propCollection);
        }

        var obj = {
            userid: 3,
            name: ''me!'',
            speak: function() { alert(''Hi! My name is '' + this.name + '' and my ID is '' + this.userid + ''.''); }
        }

        //Shows all properties
        ShowObjProperties(obj);

        //The Speak function is no longer in the list!
        delete obj.speak;
        alert(typeof obj.speak);
        ShowObjProperties(obj);

        //The UserID is still listed, it just has no value!
        obj.userid = null;
        ShowObjProperties(obj);
    </script>
</head>
<body>

</body>
</html>

Creo que hay un uso muy real para 2 tipos diferentes aquí.

Answer 10

Semánticamente significan cosas diferentes. El tipo nulo tiene exactamente un valor en su dominio, nulo y una propiedad puede tener asignado este valor específico. Indefinido representa una clara falta de cualquier valor que se haya asignado.

Answer 11

después de leer una discusión increíble sobre undefined vs null, una pequeña búsqueda en google me llevó a Mozilla Documentations https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null se menciona - null es a menudo recuperado en un lugar donde se puede esperar un objeto pero ningún objeto es relevante.

No es similar al patrón de objeto nulo https://en.wikipedia.org/wiki/Null_object_pattern

Así que supongo que tiene sentido tener un tipo de datos nulo.

La documentación también se menciona como typeof null // "object" (no "null" por razones heredadas)

No estoy seguro de cuáles son los motivos de herencia

Answer 12

es una característica importante del lenguaje si envuelve su programa alrededor del paradigma de javascript.

// a key exists as a placeholder for something
if(obj[name] === null) 
// no key exists int eh hashtable that is in this object
if(obj[name] === undefined)

esto es muy útil si se trata de un conjunto de datos que necesita un valor para representar "nada" para indicar alguna acción diferente de usar "nada" para indicar la acción predeterminada.

filter_func_pt = {
  date:function(d){ return Math.round(d.getTime()/1000);},
  user: null,
}

function transform(obj){
    var ret = {};
    for( var prop in obj){
       var f = filter_func_pt[prop];
       if(f)
          ret[prop] = f(obj);
       else if(filter_func_pt[prop] === null)
         continue;
       else
         ret[prop] == obj;
    }
  return ret;
}

var a = {
   date: new Date(),
   user: ''sam''
   votes: [23, 41, 55] 
};

var b = transform(a);

/* b = {
 *    date: 1298582417
 *    votes: [23, 41, 55]
 * }
 */

en el código anterior, la palabra clave nula y el servidor indefinido son muy claros y diferentes. la búsqueda que no se encuentra en el objeto filter_func_pt que devuelve indefinido significa agregar la propiedad al objeto de devolución tal cual, mientras que un valor nulo indica que el valor debe retenerse y no agregarse, y la presencia de cualquier valor verdadero en este case representa una función utilizada para transformar el valor antes de agregarlo al objeto ret .