sirve - que hace la funcion isnan en javascript

¿Por qué no deberías usar Number como constructor?

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Por qué evitar crear objetos en JavaScript? 2 respuestas

Ingresé esta declaración en JSLint:

var number = new Number(3);

Y recibió el siguiente mensaje:

No use Number como constructor.

¿Porqué es eso? La declaración está creando un objeto numérico, no un valor primitivo, por lo que no veo por qué usar new es un problema.

EDITAR: Gracias por todas las respuestas. Me hicieron pensar más, así que publiqué una pregunta de seguimiento here .

Answer 1

en JavaScript, un tipo de objeto no es igual a otro tipo de objeto, incluso cuando tienen exactamente el mismo valor, a menos que ambos sean el mismo objeto EXACTO.

En otras palabras, en el ejemplo siguiente de Matthew, n1 == n2 es falso porque está comparando dos REFERENCIAS con dos objetos SEPARADOS, pero n1 == n1 es verdadero porque está comparando referencias al OBJETO EXACTO.

Entonces, aunque ahora entiendo por qué utilizar Number como constructor puede causar problemas, descubrí que puede usar la propiedad valueOf al comparar objetos Number.

En otras palabras, n1.valueOf == n2.valueOf es verdadero. (Esto se debe a que está comparando los valores de retorno del valor de la FUNCIÓN, no las REFERENCIAS con los objetos mismos).

_{Esta respuesta / resumen se extrajo de la pregunta a la que no pertenece.}

Answer 2

Además de romper === y typeof devolver "object", usar el constructor Number también cambia la forma en que se usa el valor en contextos booleanos. Como "nuevo Número (0)" es un objeto, no un valor literal, se evalúa como "verdadero" porque no es nulo. Así por ejemplo:

var n1 = 0;
var n2 = new Number(0);
n1 == n2 // true
n1 === n2 // false
if (n1) {
// Doesn''t execute
}
if (n2) {
// Does execute, because n2 is an object that is not null
}

Editar: Incluso peor que romper === entre los literales numéricos y los objetos numéricos, == ni siquiera funciona entre dos objetos numéricos (al menos no de forma intuitiva: prueban la identidad, no la igualdad).

var n1 = new Number(3);
var n2 = new Number(3);
alert(n1 == n2); // false
alert(n1 === n2); // false

Answer 3

Es más lento y requiere más memoria. El tiempo de ejecución puede tratar literales inmutables como literales inmutables. Eso significa que cuando encuentra 3 en alguna parte del código, puede optimizar eso en un objeto compartido. Cuando utiliza el constructor Number , se asigna nueva memoria para cada instancia.

Answer 4

Lamentablemente, los documentos de JSLint no entran en más detalles que "no espera ver", por lo que nos queda por adivinar. Mi propia sospecha es que esto es para facilitar la verificación de tipos:

assert(typeof 3 === "number");
assert(typeof new Number(3) === "object");

Si mezcla los dos en su código, sus comprobaciones de tipo se vuelven más complejas:

if (typeof foo === "number" || foo instanceof Number) { … }

Sin embargo, JSLint también tiene problemas con los constructores Object y Array, que no hacen esta distinción, por lo que puede ser simplemente la preferencia de estilo de codificación del autor:

assert(typeof [] === "object");
assert(typeof new Array() === "object");
assert(typeof {} === "object");
assert(typeof new Object() === "object");

Editar: la respuesta de Steven plantea un excelente punto: el operador de igualdad de no encasillado (===). Los objetos numéricos y las primitivas numéricas nunca serán considerados iguales por este operador, incluso si sus valores son los mismos:

assert(3 !== new Number(3));

Answer 5

new Number () no devuelve el mismo objeto como un número literal. Esto significa que el uso de nuevos Número () se rompe ===, que es la mejor manera de verificar la igualdad exacta en Javascript.

>>> 3 == 1 + 2
true
>>> 3 === 1 + 2
true
>>> new Number(3) == 1 + 2
true
>>> new Number(3) === 1 + 2
false

Puede encontrar la justificación para el comportamiento de JSLint en el libro del autor, JavaScript: The Good Parts , en el Apéndice C.

Answer 6

var number = new Number(3);
alert(typeof number); // gives "object"

Hacer que el number variable tenga un tipo de Object probablemente no sea el resultado más deseado. Mientras:

var number = Number(3);
alert(typeof number); // gives "number"