sintassi strana di metodi numerici in JavaScript

Question

Date un'occhiata al seguente codice:

Number.prototype.isIn = function () {
    for (var i = 0, j = arguments.length; i < j; ++i) {
        if (parseInt(this, 10) === arguments[i]) {
            return true;
        }
    }
    return false;
};

var x = 2;
console.log(x.isIn(1,2,3,4,5)); // <= 'true'
console.log(2.isIn(1,2,3,4,5)); // <= Error: 'missing ) after argument list'

Perché è che quando si tratta di una variabile, il codice funziona correttamente ma quando si tratta di un numero letterale, non riesce?

---

E anche, stranamente, perché fa la seguente linea di lavoro?

console.log((2).isIn(1,2,3,4,5)); // <= 'true'

Nella riga sopra, ho praticamente allegato il letterale tra parentesi.

Answer 1

E 'un errore di sintassi, perché si rappresenta un numero. Le stringhe possono lavorare in questo modo, ma non i numeri, perché un periodo immediatamente successivo un numero simboleggia un valore decimale. Il carattere dopo la . sta causando l'errore.

Answer 2

La maggior parte delle risposte già dichiarato che un punto dopo un letterale numerico è considerato parte di questo numero come separatore frazione. Ma se si vuole ancora utilizzare il punto come operatore allora la soluzione rapida e facile sarebbe lasciando uno spazio vuoto tra il numero e lo spazio.

2 .isIn(1,2,3,4,5) // <- notice the space between 2 and .

Answer 3

Josh era corretta, ma non c'è bisogno di utilizzare una variabile di utilizzare un metodo di un numero, anche se di solito è più conveniente per farlo.

5.isIn(1,2,3,4,5) returns an error

5.0.isIn(1.2.3.4.5) returns true, as does
(5).isIn(1,2,3,4,5)

Answer 4

Anche se la distinzione è spesso non è evidente a causa della conversione di tipo automatico, JavaScript supporta un certo numero di tipi primitivi così come gli oggetti:

var foo = 10;
var bar = new Number(10);
alert(foo.toString(16)); // foo is automatically wrapped in an object of type Number 
                         // and that object's toString method is invoked
alert(bar.toString(16)); // bar is already an object of type Number, 
                         // so no type conversion is necessary before 
                         // invoking its toString method
var foo2 = "foo";
var bar2 = new String("foo");
alert(typeof foo2);      // "string" - note the lowercase "s", not a String object
alert(typeof bar2);      // "object"

alert(typeof true)       // "boolean"
alert(typeof new Boolean(true)) // "object"

e qualcosa che confonde realtà il problema:

// the next line will alert "truthy"
alert("Boolean object with value 'false'" + (new Boolean(false) ? " is truthy" : " is falsy"));
// the next line will alert "falsy"
alert("boolean primitive with value 'false'" + (false ? " is truthy" : " is falsy"));

Anche se fare affidamento su conversione di tipo automatico rende la vita un po 'più facile, si dovrebbe sempre avere sul retro della propria mente una buona comprensione di quali tipi vostri valori primitivi e oggetti in realtà sono; un numero sorprendentemente elevato di bug JS avvenuto a causa di persone che non riescono a rendersi conto che, per esempio, qualcosa che assomiglia a un numero è in realtà una stringa, o che alcune operazioni hanno svolto ha portato a qualcosa che utilizzate per contenere un numero che ha stato assegnato un nuovo valore che è una stringa o un oggetto.

EDIT: per affrontare più da vicino la questione originale, che ora mi rendo conto che non avevo risposto in modo esplicito: 10.foo() causerà un errore di sintassi come il . è visto come un punto decimale, e foo() non è una sequenza di caratteri valida da analizzare come un numero. (10).foo() funzionerà come le parentesi racchiudono (10) compongono l'intero costrutto prima della . in una singola espressione. Questa espressione viene valutata e restituisce il valore numerico primitivo 10. Poi il . è visto come trattare tale valore di base nel contesto di un oggetto, quindi viene avvolto automaticamente in un oggetto di tipo Number (questa è la conversione automatica in azione). Poi la proprietà foo di tale oggetto, che si trova sulla sua catena di prototipi, si fa riferimento; e la () finale causare che la proprietà di essere trattati come riferimento funzione e invocato 'questo' contesto dell'oggetto Number che era avvolto il valore di base nel punto di incontro con il ..

Answer 5

La mia comprensione va che i numeri sono letterali, e non un oggetto. Tuttavia, quando si definisce una variabile come un numero, allora diventa un nuovo oggetto Number ().

Così facendo quanto segue;

var x = 10;

è lo stesso di andare;

var x = new Number(10);

Per quanto riguarda il secondo esempio; Posso solo supporre che mettere le parentesi attorno al numero ha fatto il compilatore JavaScript per scontato che il valore è un oggetto numero anonimo (). Quale senso rende immagino ...