Per approfondire il motivo per cui JavaScript non viene digitato a mano a mano, guardiamo nella direzione opposta a C #, che è staticamente digitato con una digitazione implicita.
Secondo MSDN , C # ha introdotto una parola chiave var con la versione 3.0 rilasciata nel 2007 È consentito solo su "variabili dichiarate nell'ambito del metodo", quelle che chiamerei variabili locali. La parola chiave var non è di tipo dinamico, perché consente al compilatore di capire che tipo deve essere la dichiarazione , ma poi tratta tutti i riferimenti a quella variabile come il tipo specificato esattamente come se tu l'avevo dichiarato staticamente.
Ecco alcuni esempi di come può e non può essere utilizzato.
class MyClass {
// Standard member variable
public string MyName = "Patrick";
// Illegal declaration - var cannot be used here even though the type may be inferred
// from the literal definition; compiler throws an error
private var LuckyNumber = 7;
// Have to do it like this:
private int LuckyNumber = 7;
private MyClass(int luckyNumber) {
LuckyNumber = luckyNumber;
}
public MyClass MyClassFactory(int newLucky) {
// Legal - myInstance is in the method scope
var myInstance = new MyClass(newLucky);
// Not legal - myInstance is not a dynamic type just because we declared it with var
myInstance = new MyOtherClass();
// We can return myInstance because its type matches the method signature
return myInstance;
}
}
In altre parole, C # non fornisce un modo per dichiarare una variabile che può contenere un tipo arbitrario. Il più vicino che puoi ottenere è con polymorphism , dove i compiti sono limitati alla struttura di ereditarietà.
Si noti che in netto contrasto, JavaScript consentirebbe la linea illegale in MyClassFactory . Quanto segue è perfettamente legale in JS:
var foo = "foo";
foo = 1;
foo = 2.0;
foo = new Date();
foo = [];
foo = {};
foo = function() {};
Ogni riga cambia il tipo di foo . Inoltre, non c'è modo di dichiarare foo come un tipo che non può essere modificato.
Si noti che esistono modi per inserire tipicamente static in JavaScript, ma in realtà sono strati wrapper attorno al codice JS effettivo, che finisce ogni volta con una digitazione dinamica come se fosse stato scritto a mano. Ci sono molti più modi di quelli che avrei immaginato, come risulta: ecco un elenco completo di linguaggi (o più correttamente sintassi o parser) che possono sfornare JavaScript . Di questi, CoffeeScript è il più comune nella mia esperienza.
Infine, un linguaggio deve fornire dichiarazioni sia dinamiche che statiche per poter essere considerato digitato dinamicamente. In altre parole, il seguente deve essere possibile con qualche sintassi:
// Statically typed declaration
Integer myNumber = 3;
// May be legal if the language provides for auto-conversion or dynamic-casting; may
// throw an error. It depends on the language
myNumber = 7.5;
// Static type declaration of an object class
MyParentType instance = new MyParentType();
// legal if MyChildType inherits/extends MyParentType - illegal otherwise
instance = new MyChildType();
// Illegal always - MUST throw an error
instance = new IncompatibleType();
// Dynamic typed declaration
dynamic otherInstance = new MyParentType();
// Legal for variables declared dynamic - MUST NOT throw an error
otherInstance = new IncompatibleType();
Si noti che, come dimostrato, né C # né JS supportano entrambi tipi di dichiarazioni variabili per diversi motivi.