Come viene controllato il tipo in un interprete / compilatore di un linguaggio dinamico, come JavaScript?

Nei linguaggi dinamici, come JavaScript o Python, il tipo di una variabile viene determinato in fase di esecuzione. Questo è uno dei motivi per cui sono più lenti dei linguaggi digitati come Java.

Come viene eseguito il controllo del tipo? Qual è la ragione essenziale per cui questo processo è lento?

C'è confusione nella domanda.

Si presume che il controllo del tipo sia lento, il che non è necessariamente il caso.

La domanda sembra anche confondere il processo di invio del tipo con il controllo del tipo , e sono due cose diverse. Uno è un processo che viene eseguito in fase di esecuzione, l'altro un processo in fase di compilazione. Ho il sospetto che la domanda si stia davvero ponendo sul tipo di spedizione.

È l'invio di tipi che può introdurre un sovraccarico in fase di esecuzione, poiché il calcolo impiega tempo con istruzioni che decidono, in modo dinamico, quale azione intraprendere, in base ai tipi di valori che vede in fase di esecuzione. ad es. in un linguaggio dinamico, se applico "+" su due cose, potrei significare addizione numerica o concatenazione di stringhe, quindi ho bisogno di passare il tempo a guardare ciò che è a portata di mano per decidere cosa fare. Esistono strategie di valutazione che possono ridurre il costo della spedizione dinamica. (ad es. tracciamento di JIT)

Per quanto riguarda l'esecuzione del controllo del tipo in JavaScript, consultare: http://www.cs.brown.edu/~sk/Publications/Papers/Published/gsk-flow-typing-theory/ . Per una panoramica più generale di come funzionano i correttori di tipo, un manuale di linguaggio di programmazione standard coprirà gli algoritmi. Ad esempio, http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/

In sostanza, nei linguaggi non tipizzati, ogni riferimento a un oggetto che contiene sia il tipo che il valore. Ad esempio, var a = 3punta a un'istanza che contiene il valore 3 e il tipo int, se lo si fa a = "bla", il riferimento viene aggiornato a un'istanza che contiene la stringa "bla" e la stringa del tipo, l'oggetto vecchio viene scartato, ecc ...

Questo è lento perché ogni volta che un'operazione (ad es. a + b) Deve essere eseguita su questo tipo di base, il runtime deve prima fare la dereferenza sugli oggetti, verificare che il loro tipo sia compatibile, eseguire l'operazione, creare un nuovo oggetto.

Al contrario, a + bin C ++ o Java verifica al momento della compilazione che i tipi siano validi e compatibili, quindi aeb vengono memorizzati come valori immediati (non riferimenti) e l'aggiunta è una semplice operazione del processore su questi valori.

Ovviamente, tutto ciò è molto teorico. In pratica, su questo processo si può fare molta ottimizzazione per evitare la maggior parte delle spese generali e le lingue tipizzate dinamicamente possono essere abbastanza veloci.

Ogni valore viene memorizzato insieme al suo tipo, che è necessario ispezionare per primo. Anche le conversioni dicono da una stringa all'altra tramite l'ispezione, al volo.