tablas - obtener datos de una tabla html javascript

¿Por qué 4 no es una instancia de Número?

Question

Sólo curioso:

• 4 instancia de Número => falso
• nuevo número (4) instanceof Number => true?

¿Por qué es esto? Lo mismo con cadenas:

• ''some string'' instanceof String devuelve falso
• new String(''some string'') instanceof String => true
• String(''some string'') instanceof String también devuelve falso
• (''some string'').toString instanceof String también devuelve false

Para los tipos objeto, matriz o función, el operador instanceof funciona como se espera. Simplemente no sé cómo entender esto.

[ nuevas ideas ]

Object.prototype.is = function() {
        var test = arguments.length ? [].slice.call(arguments) : null
           ,self = this.constructor;
        return test ? !!(test.filter(function(a){return a === self}).length)
               : (this.constructor.name ||
                  (String(self).match ( /^function/s*([^/s(]+)/im )
                    || [0,''ANONYMOUS_CONSTRUCTOR'']) [1] );
}
// usage
var Newclass = function(){};  // anonymous Constructor function
var Some = function Some(){}; // named Constructor function
(5).is();                     //=> Number
''hello world''.is();           //=> String
(new Newclass()).is();        //=> ANONYMOUS_CONSTRUCTOR
(new Some()).is();            //=> Some
/[a-z]/.is();                 //=> RegExp
''5''.is(Number);               //=> false
''5''.is(String);               //=> true

Answer 1

Como se afirma en la respuesta de Christoph, los literales de cadena y número no son lo mismo que los objetos de cadena y número. Si usa cualquiera de los métodos de Cadena o Número en el literal, diga

''a string literal''.length

El literal se convierte temporalmente en un objeto, el método se invoca y el objeto se descarta.
Los literales tienen algunas ventajas claras sobre los objetos.

//false, two different objects with the same value
alert( new String(''string'') == new String(''string'') ); 

//true, identical literals
alert( ''string'' == ''string'' );

¡Siempre use literales para evitar comportamientos inesperados!
Puede usar Number () y String () para encasillar si necesita:

//true
alert( Number(''5'') === 5 )

//false
alert( ''5'' === 5 )

Answer 2

Este es un matiz de Javascript que descubrí que atrapa un poco. instanceof del operador siempre dará como resultado falso si el LHS no es un tipo de object .

Tenga en cuenta que el new String(''Hello World'') no da como resultado un tipo de string sino que es un object . El new operador siempre da como resultado un objeto. Veo este tipo de cosas:

function fnX(value)
{
     if (typeof value == ''string'')
     {
          //Do stuff
     }
}
fnX(new String(''Hello World''));

La expectativa es que " Do Stuff " sucederá pero no porque el tipo del valor es objeto.

Answer 3

Puede intentar evaluar:

>>> typeof("a")
"string"
>>> typeof(new String("a"))
"object"
>>> typeof(4)
"number"
>>> typeof(new Number(4))
"object"

Answer 4

value instanceof Constructor es lo mismo que Constructor.prototype.isPrototypeOf(value) y ambos comprueban el [[Prototype]] - cadena de value para las ocurrencias de un objeto específico.

Las cadenas y los números son valores primitivos , no objetos y, por lo tanto, no tienen un [[Prototipo]], por lo que solo funcionarán si los envuelve en objetos normales (denominados ''boxeo'' en Java).

Además, como habrás notado, String(value) y new String(value) hacen cosas diferentes: si llamas a las funciones de constructor de los tipos incorporados sin usar el new operador, intentan convertir (''fundir'') el argumento en el tipo específico. Si usa el new operador, crean un objeto contenedor.

new String(value) es más o menos equivalente a Object(String(value)) , que se comporta de la misma manera que el new Object(String(value)) .

Algunos más sobre tipos en JavaScript: ECMA-262 define los siguientes tipos primitivos: Indefinido , Nulo , Booleano , Número y Cadena . Además, está el tipo Object para cosas que tienen propiedades.

Por ejemplo, las funciones son de tipo Object (solo tienen una propiedad especial llamada [[Call]]), y null es un valor primitivo de tipo Null . Esto significa que el resultado del operador typeof realmente no devuelve el tipo de valor ...

Además, los objetos JavaScript tienen otra propiedad llamada [[Class]]. Puede obtenerlo a través de Object.prototype.toString.call(value) (esto devolverá ''[object Classname ]'' ). Las matrices y las funciones son del tipo Object , pero sus clases son Array y Function .

La prueba para la clase de un objeto dada arriba funciona cuando la instanceof falla (por ejemplo, cuando los objetos se pasan entre los límites de ventana / marco y no comparten los mismos prototipos).

Además, es posible que desee verificar esta versión mejorada de typeof :

function typeOf(value) {
    var type = typeof value;

    switch(type) {
        case ''object'':
        return value === null ? ''null'' : Object.prototype.toString.call(value).
            match(/^/[object (.*)/]$/)[1]

        case ''function'':
        return ''Function'';

        default:
        return type;
    }
}

Para las primitivas, devolverá su tipo en minúsculas , para los objetos, devolverá su clase en mayúsculas y minúsculas .

Ejemplos:

• Para las primitivas de tipo Número (p. Ej. 5 ), devolverá ''number'' , para objetos de envoltura de clase Número (por ejemplo, new Number(5) ), devolverá ''Number'' ;

• Para las funciones, devolverá ''Function'' .

Si no desea discernir entre los valores primitivos y los objetos del contenedor (para cualquier cosa, probablemente una mala razón), use typeOf(...).toLowerCase() .

Los errores conocidos son algunas funciones incorporadas en IE, que se consideran ''Object'' y un valor de retorno ''unknown'' cuando se usan con algunos objetos COM +.

Answer 5

En el caso de los números primitivos, el método isNaN también puede ayudarlo.