una - strip_tags javascript

¿Puedo configurar las variables como indefinidas o pasarlas como un argumento?

Question

Estoy un poco confundido acerca de los valores null e undefined de JavaScript.

¿Qué hace if (!testvar) realmente hace? ¿Prueba para undefined y null o simplemente undefined ?

Una vez que se define una variable, ¿puedo borrarla de nuevo a undefined (por lo tanto, eliminar la variable)?

¿Puedo pasar undefined como parámetro? P.ej:

function test(var1, var2, var3) {

}

test("value1", undefined, "value2");

Answer 1

Estoy un poco confundido acerca de Javascript no definido y nulo.

No se confunda con null . En general, tiene sentido y se comporta de manera similar a los conceptos de otros lenguajes de script de los objetos fuera de banda ''null'', ''nil'' o ''None''.

undefined , por otro lado, es una peculiaridad extraña de JavaScript. Es un objeto singleton que representa valores fuera de banda, esencialmente un segundo null similar pero diferente. Aparece

1. Cuando llama a una función con menos argumentos que la lista de argumentos en las listas de sentencias de function , los argumentos no superados se configuran como undefined . Puedes probar eso con ej .:

   function dosomething(arg1, arg2) {
       if (arg2===undefined)
       arg2= DEFAULT_VALUE_FOR_ARG2;
       ...
   }

   Con este método no puede distinguir la diferencia entre dosomething(1) y dosomething(1, undefined) ; arg2 tendrá el mismo valor en ambos. Si necesitas ver la diferencia, puedes mirar los arguments.length de arguments.length , pero hacer argumentos opcionales como estos generalmente no es muy legible.

2. Cuando una función no tiene return value; , devuelve undefined . En general, no hay necesidad de utilizar un resultado de retorno de este tipo.

3. Cuando declara una variable teniendo una sentencia var a en un bloque, pero aún no le ha asignado un valor, no está undefined . Una vez más, nunca deberías necesitar confiar en eso.

4. El operador de tipo espeluznante devuelve ''undefined'' cuando su operando es una variable simple que no existe, en lugar de lanzar un error como ocurriría normalmente si tratara de referirse a él. (También puede asignarle una variable simple entre paréntesis, pero no una expresión completa que incluya una variable inexistente). Tampoco sirve de mucho para eso.

5. Este es el controvertido. Cuando accede a una propiedad de un objeto que no existe, no recibe inmediatamente un error como en cualquier otro idioma. En su lugar obtienes un objeto undefined . (Y luego, cuando intentes usar ese objeto undefined más adelante en el script, saldrá mal de una manera extraña que es mucho más difícil de rastrear que si JavaScript hubiera lanzado un error de inmediato).

   Esto se usa a menudo para verificar la existencia de propiedades:

   if (o.prop!==undefined) // or often as truthiness test, if (o.prop)
      ...do something...

   Sin embargo, debido a que puede asignar undefined como cualquier otro valor:

   o.prop= undefined;

   que en realidad no detecta si la propiedad está allí de forma fiable. Es mejor utilizar el operador in , que no estaba en la versión original de Netscape de JavaScript, pero ahora está disponible en todas partes:

   if (''prop'' in o)
       ...

En resumen, undefined es un desorden específico de JavaScript, que confunde a todos. Aparte de los argumentos de función opcionales, donde JS no tiene ningún otro mecanismo más elegante, se debe evitar el undefined . Nunca debió haber sido parte del lenguaje; null hubiera funcionado bien para (2) y (3), y (4) es un error que solo existe porque al principio JavaScript no tenía excepciones.

¿Qué hace if (!testvar) realmente hace? ¿Prueba para undefined y null o simplemente undefined?

Dicha prueba de "veracidad" verifica contra cadenas false , undefined , null , 0 , NaN y vacías. Pero en este caso, sí, es realmente undefined lo que le preocupa. En mi opinión, debería ser más explícito al respecto y decir if (testvar!==undefined) .

una vez que se define una variable, puedo borrarla de nuevo a indefinida (por lo tanto, eliminar la variable).

Ciertamente, puedes asignarle undefined , pero eso no eliminará la variable. Solo el operador delete object.property realmente elimina las cosas.

delete es realmente para propiedades en lugar de variables como tales. Los navegadores te permitirán salir directamente con la delete variable directa, pero no es una buena idea y no funcionará en el modo estricto de ECMAScript Fifth Edition. Si desea liberar una referencia a algo para que pueda ser recolectado en la basura, sería más común decir variable= null .

¿Puedo pasar indefinido como parámetro?

Sí.

Answer 2

JavaScript, cómo configurar una variable como indefinida en la línea de comandos:

Establezca una variable como indefinida en el terminal de línea de comandos js javascript que viene con Java en Ubuntu 12.10.

el@defiant ~ $ js

js> typeof boo
"undefined"

js> boo
typein:2: ReferenceError: boo is not defined

js> boo=5
5

js> typeof boo
"number"

js> delete(boo)
true

js> typeof boo
"undefined"

js> boo
typein:7: ReferenceError: boo is not defined

Si configura una variable como indefinida en un javascript:

Pon esto en myjs.html:

<html>
<body>
    <script type="text/JavaScript">
        document.write("aliens: " + aliens);
        document.write("typeof aliens: " + (typeof aliens));
        var aliens = "scramble the nimitz";
        document.write("found some aliens: " + (typeof aliens));
        document.write("not sayings its aliens but... " + aliens);
        aliens = undefined;
        document.write("aliens deleted");
        document.write("typeof aliens: " + (typeof aliens));
        document.write("you sure they are gone? " + aliens);
    </script>
</body>
</html>

Imprime esto:

aliens: undefined
typeof aliens: undefined
found some aliens: string
not sayings its aliens but... scramble the nimitz
aliens deleted
typeof aliens: undefined
you sure they are gone? undefined

¡ADVERTENCIA! Cuando configura su variable como indefinida, está configurando su variable a otra variable. Si alguna persona astuta se ejecuta undefined = ''rm -rf /''; luego, cada vez que establezca su variable como indefinida, recibirá ese valor.

Quizás se esté preguntando cómo puedo generar los alienígenas de valor indefinido al inicio y seguir ejecutándolos. Es debido a la elevación de javascript: http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html

Answer 3

El for if (something) y if (!something) se usa comúnmente para verificar si algo está definido o no. Por ejemplo:

if (document.getElementById)

El identificador se convierte en un valor booleano, por lo que undefined se interpreta como false . Por supuesto, hay otros valores (como 0 y '''') que también se interpretan como false , pero o bien el identificador no debería tener ese valor de manera razonable o está contento con tratar ese valor como no definido.

Javascript tiene un operador de delete que se puede usar para eliminar un miembro de un objeto. Dependiendo del alcance de una variable (es decir, si es global o no), puede eliminarla para que quede indefinida.

No hay una palabra clave undefined que pueda usar como un literal no definido. Puede omitir los parámetros en una llamada de función para hacerlos indefinidos, pero eso solo puede usarse enviando menos parámetros a la función, no puede omitir un parámetro en el medio.

Answer 4

La diferencia básica es que undefined y null representan conceptos diferentes.

Si solo estuviera disponible el null , no sería capaz de determinar si el null se estableció intencionalmente como el valor o si el valor no se ha establecido aún a menos que haya utilizado la captura de errores engorrosos: por ejemplo,

var a;

a == null; // This is true
a == undefined; // This is true;
a === undefined; // This is true;

Sin embargo, si establece intencionalmente el valor en null , la igualdad estricta con undefined falla, lo que le permite diferenciar entre valores null e undefined :

var b = null;
b == null; // This is true
b == undefined; // This is true;
b === undefined; // This is false;

Echa un vistazo a la referencia aquí en lugar de confiar en que la gente diga basura como "En resumen, indefinido es un desorden específico de JavaScript, que confunde a todos". Solo porque estés confundido, no significa que sea un desastre.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined

Este comportamiento tampoco es específico de JavaScript y completa el concepto generalizado de que un resultado booleano puede ser true , false , desconocido ( null ), sin valor ( undefined ) o algo salió mal ( error ).

http://en.wikipedia.org/wiki/Undefined_value

Answer 5

La mejor manera de verificar los valores nulos es

if ( testVar !== null )
{
    // do action here
}

y para indefinido

if ( testVar !== undefined )
{
    // do action here
}

Puede asignar una variable con undefined.

testVar = undefined;
//typeof(testVar) will be equal to undefined.

Answer 6

No puede (¿no debería?) Definir algo como indefinido, ya que la variable ya no estaría indefinida, simplemente lo definió como algo.

No puedes (¿no deberías?) Pasar undefined a una función. Si desea pasar un valor vacío, use null lugar.

La instrucción if(!testvar) verifica valores booleanos de verdadero / falso, este en particular prueba si testvar evalúa como false . Por definición, null e undefined no deben evaluarse como true o false , sino que JavaScript evalúa null como false , y da un error si intenta evaluar una variable no definida.

Para realizar una prueba adecuada de undefined o null , use estos:

if(typeof(testvar) === "undefined") { ... }

if(testvar === null) { ... }

Answer 7

Para responder a su primera pregunta, el operador no ( ! ) Forzará lo que sea dado en un valor booleano. Entonces null , 0 , false , NaN y "" (cadena vacía) aparecerán todos falsos.

Answer 8

Prueba esto:

// found on UglifyJS
variable = void 0;

Answer 9

Solo por diversión, aquí hay una forma bastante segura de asignar "sin asignar" a una variable. Para que esto tenga una colisión se requiere que alguien haya agregado al prototipo para Objeto con exactamente el mismo nombre que la cadena generada aleatoriamente. Estoy seguro de que el generador de cadenas aleatorias podría mejorarse, pero tomé una de esta pregunta: Generar cadenas / caracteres aleatorios en JavaScript

Esto funciona al crear un nuevo objeto e intentar acceder a una propiedad en él con un nombre generado aleatoriamente, que asumimos que no existirá y por lo tanto tendrá el valor de no definido.

function GenerateRandomString() {
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    for (var i = 0; i < 50; i++)
        text += possible.charAt(Math.floor(Math.random() * possible.length));

    return text;
}

var myVar = {}[GenerateRandomString()];

Answer 10

SÍ, puede hacerlo , porque indefinido se defined como indefinido.

console.log(
   /*global.*/undefined === window[''undefined''] &&
   /*global.*/undefined === (function(){})() &&
   window[''undefined'']  === (function(){})()
) //true

Tu caso:

test("value1", undefined, "value2")

También puedes create tu propia variable indefinida:

Object.defineProperty(this, ''u'', {value : undefined});
console.log(u); //undefined