Statico/Dinamico vs Forte/Debole

https://stackoverflow.com/questions/2351190

23-09-2019
|

Domanda

Io la vedo in questi termini sbandierata in giro in tutto il luogo in programmazione e ho una vaga idea di che cosa significano.Una ricerca dimostra che queste cose sono state chiesto di tutto di overflow dello stack in realtà.Per quanto ne sono a conoscenza Static/Dynamic typing in lingue è leggermente differente da Forte/Debole di battitura ma la cosa che differenza mi sfugge.Diverse fonti sembrano utilizzare significati diversi o anche usare i termini in modo intercambiabile.Non riesco a trovare da qualche parte che parla di entrambi e in realtà esprime la differenza.Cosa sarebbe bello se qualcuno potesse si prega di magia questo chiaramente qui per me e per il resto del mondo.

Soluzione

statico / dinamico Typing è di circa quando tipo di informazioni viene acquisita (entrambi in fase di compilazione o in fase di esecuzione)
Forte / Typing Debole è su come strettamente i tipi si distinguono (ad esempio, se la lingua cerca di fare una conversione implicita da stringhe in numeri).

Vedere wiki-pagina per informazioni più dettagliate.

Altri suggerimenti

Hai scoperto un debole nella terminologia che i dilettanti usano per parlare di linguaggi di programmazione. Non utilizzare i termini "forti" e "deboli" digitando , perché non hanno un universalmente concordato significato tecnico. Per contro, tipizzazione statica significa che i programmi sono controllato prima dell'esecuzione , e un programma potrebbe essere respinto prima del suo inizio. tipizzazione dinamica significa che i tipi di valori sono controllati durante esecuzione , ed un'operazione mal digitato potrebbero causare il programma per fermare o comunque segnalare un errore in fase di esecuzione . Un motivo principale per la tipizzazione statica è quello di escludere i programmi che potrebbero avere tali "errori dinamici di tipo".

Forte tipizzazione generalmente significa che ci sono scappatoie nel sistema tipo, che tipizzazione debole significa che il sistema tipo può essere sovvertito (invalidante eventuali garanzie). I termini sono spesso usati in modo non corretto per indicare tipizzazione statica e dinamica. Per vedere la differenza, pensare di C: la lingua è di tipo controllato in fase di compilazione (tipizzazione statica), ma ci sono un sacco di scappatoie; si può tranquillamente inserire un valore di qualsiasi tipo ad un altro tipo della stessa dimensione --- in particolare, è possibile lanciare tipi di puntatore liberamente. Pascal è un linguaggio che è stato destinato ad essere fortemente tipizzato, ma notoriamente aveva una scappatoia imprevista:. Un record variante con nessun tag

Le implementazioni di linguaggi fortemente tipizzati spesso acquistano scappatoie nel corso del tempo, di solito in modo che parte del sistema run-time può essere implementato nel linguaggio di alto livello. Ad esempio, Obiettivo Caml ha una funzione chiamata Obj.magic che ha l'effetto di runtime di restituire semplicemente sua tesi, ma al momento della compilazione converte un valore di qualsiasi tipo ad un qualsiasi altro tipo. Il mio esempio preferito è Modula-3, i cui progettisti chiamato il loro LOOPHOLE tipo-casting costrutto.

Detto questo, non si può contare su due persone che usano le parole "forti" e "deboli" esattamente nello stesso modo. In modo da evitare loro.

In poche parole in questo modo: in un linguaggio a tipizzazione statica il tipo è static , che significa una volta impostato una variabile a un tipo, non è possibile cambiarlo. Questo perché battitura è associata alla variabile anziché il valore si riferisce.

Ad esempio in Java:

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

considerando che in un linguaggio tipizzato dinamicamente il tipo è dinamica , che significa dopo aver impostato una variabile a un tipo, si può cambiare. Questo perché battitura è associata al valore piuttosto variabile.

Ad esempio in Python:

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

D'altra parte, il tipizzazione forte / debole in una lingua è relativo a conversioni di tipo implicito (parzialmente prelevati da @ risposta di Dario):

Ad esempio in Python:

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly.

mentre in PHP:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

tipizzazione statica consente di verificare la correttezza di tipo in fase di compilazione. lingue tipi statici sono generalmente compilati, e le lingue dinamicamente tipizzati sono interpretati. Pertanto, le lingue dinamicamente tipizzati possono controllare battitura in fase di esecuzione.

tipizzazione debole significa che il tipo di un oggetto può cambiare a seconda del contesto. Per esempio in un linguaggio debolmente tipizzato la stringa "123" può essere trattato come il numero 123 se si aggiunge un altro numero ad esso. Esempi di lingue con tipizzazione debole sono bash, awk e PHP.

Un altro tipo di linguaggio debolmente tipizzato è C, in cui i dati a un indirizzo di memoria possono essere trattati come un tipo diverso da fusione.

In un linguaggio fortemente tipizzato il tipo di un oggetto non cambia - un int è sempre un int e cercando di usarlo come una stringa si tradurrà in un errore. Sia Java e Python sono fortemente tipizzati.

La differenza tra tipizzazione dinamica e statica è quando le regole di tipo applicazione. In un linguaggio a tipizzazione statica del tipo di ogni variabile e parametro deve essere dichiarato nel sorgente e viene applicata al momento della compilazione. In un linguaggio tipizzato in modo dinamico i tipi vengono controllati solo quando sono utilizzati in fase di esecuzione. Così Java è staticamente tipizzato e Python viene digitato in modo dinamico.

Tuttavia i confini possono essere un po 'sfocata, a volte. Per esempio, anche se Java è staticamente tipizzato, ogni volta che si usa di riflessione o di un cast (per esempio quando si usano contenitori di oggetti) che si stanno rimandando il controllo di tipo a runtime.

Allo stesso modo la maggior parte fortemente tipizzato lingue saranno ancora convertire automaticamente tra interi e carri (e in alcune lingue abitrary BigInts precisione).

Oggi la ricerca su questo argomento mi sono imbattuto in questo grande articolo http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html Si chiarito un sacco di cose per me e ho pensato che può aggiungere alla alcune delle grandi risposte di cui sopra.

forza e di debolezza Digitando:

Probabilmente il modo più comune sistemi di tipo sono classificati è "forte" o "debole". Questo è un peccato, dal momento che queste parole hanno quasi nessuna significa affatto. È, in misura limitata, possibile confrontare due lingue con sistemi di tipo molto simili, e designa uno come aventi il più forte di questi due sistemi. Oltre a ciò, le parole non significano nulla a tutti.

Tipi statici e dinamici

Questo è quasi l'unica classificazione comune dei sistemi di tipo   che ha un significato reale. È un dato di fatto, è il significato è   spesso sotto-stimato [...] sistemi di tipo dinamici e statici sono   due cose completamente diverse, i cui obiettivi capita di parte   sovrapposizione.

Un sistema di tipo statico è un meccanismo mediante il quale un compilatore esamina   codice sorgente e assegna etichette (chiamati "tipi") per pezzi del   sintassi, e quindi li utilizza per dedurre qualcosa sul programma di   comportamento. Un sistema di tipo dinamico è un meccanismo mediante il quale un compilatore   genera il codice per tenere traccia del tipo di dati (per coincidenza, anche   chiamato il suo "tipo") utilizzato dal programma. L'uso della stessa parola   "Tipo" in ciascuno di questi due sistemi è, naturalmente, non proprio tutto   una coincidenza; tuttavia si comprende meglio come avente una sorta di debole   significato storico. Grande confusione risultati da cercando di trovare un   visione del mondo in cui "tipo" in realtà significa la stessa cosa in entrambi   sistemi. E non è così.

Tipi espliciti / impliciti:

Quando si utilizzano questi termini, si riferiscono alla misura in cui una compilatore ragionare sui tipi statici di parti di un programma. Tutti i linguaggi di programmazione hanno una qualche forma di ragionamento sui tipi. Alcuni hanno più di altri. ML e Haskell hanno tipi impliciti, in quanto non (O molto pochi, a seconda della lingua e le estensioni in uso) di tipo sono necessari dichiarazioni. Java e Ada hanno tipi molto espliciti, e uno è in continua dichiarando i tipi di cose. Tutto quanto sopra hanno (Relativamente, rispetto a C e C ++, per esempio) di tipo statico forte sistemi.

Da Scott Programming Language Pragmatica , edizione 3 ° pagina 291, abbiamo

controllo dei tipi è il processo di assicurare che un programma obbedisce alla   regole tipo di compatibilità del linguaggio. Una violazione delle regole è noto   come un tipo scontro. Una lingua è detto di essere fortemente tipizzato se   vieta, in un modo che l'implementazione del linguaggio può valere, il   applicazione di qualsiasi operazione su qualsiasi oggetto che non è destinato a   sostenere tale operazione. Una lingua è detto di essere staticamente tipizzato se   si è fortemente tipizzato e il tipo di controllo può essere eseguito in fase di compilazione   tempo. Nel senso più stretto del termine, alcune lingue sono staticamente   digitato. In pratica, i TERMIS spesso applicate alle lingue in cui   più tipo di controllo può essere eseguita in fase di compilazione, e il resto può   essere eseguita in fase di esecuzione.

Alcuni esempi: Ada è fortemente tipizzato, e per la maggior parte   tipizzazione statica (alcuni vincoli di tipo devono essere controllati in fase di esecuzione   tempo). Un'implementazione Pascal può anche fare la maggior parte del suo controllo dei tipi   al momento della compilazione, non se la lingua è abbastanza fortemente tipizzato:   record varianti senza tag (che saranno discussi nella sezione 7.3.4) sono la sua   solo scappatoia. C89 è molto più fortemente tipizzato rispetto al suo   dialetti predecessore, ma ancora significativamente meno fortemente tipizzato di   Pascal. Le sue feritoie includono sindacati, un numero variabile subroutineswith   dei parametri e l'interoperabilità dei puntatori e array (ad essere   discusso nella sezione 7.7.1). Le implementazioni di C controllano raramente   nulla in fase di esecuzione.

Dinamico (run-time) tipo controllo è una forma di associazione tardiva, e tende   si trovano in lingue che ritardano altre questioni fino fase di esecuzione come   bene. Lisp e Smalltalk sono dinamicamente (anche se fortemente) tipizzato. Maggior parte   linguaggi di scripting sono anche dinamicamente tipizzati; alcuni (ad esempio, Python e   Ruby) sono fortemente tipizzati. Lingue con visibilità dinamica sono in genere   dinamicamente tipizzati (o non digitato a tutti): se il compilatore non può   identificare l'oggetto a cui fa riferimento un nome, di solito non può determinare   il tipo di oggetto sia.

Quindi, in termini semplici, statici tipizzazione / dinamico si riferisce al momento in cui si verifica la verifica del tipo: tempo di compilazione per la tipizzazione statica, e il tempo di esecuzione per i linguaggi dinamici. Analogamente, forte / tipizzazione debole si riferisce al modo aggressivo una lingua è rinforzare il suo sistema tipo.

Ho cercato di tradurre la descrizione di Scott in un bel diagramma, che ho postato qui sotto.

Credo che gli altri colleghi hanno fatto un buon lavoro esp. spiegare la differenza tra tipizzazione statica e dinamica. Ma per quanto tipizzazione forte e debole è interessato, va detto che esistono diverse comprensioni / viste.

Ecco due esempi:

Alcuni dicono che Haskell è fortemente tipizzato, perché non è permesso di fare qualsiasi conversioni di tipo.
Altro (es vista di Dario) dire un linguaggio che permette di convertire in modo implicito da stringa a numero di proposito è debolmente tipizzato, ma anche gli altri chiamano questo digitazione solo anatra.

Entrambe le affermazioni evidenziano non gli estremi opposti di un sistema tipo, ma completamente diversi aspetti. Così mi unisco vista del signor Ramsey non usare i termini "forti" e "deboli" per distinguere tra sistemi di tipo.

Staticamente v/s dinamicamente tipizzato lingue

Staticamente tipizzato lingue sono quelle in cui il tipo di controllo è effettuata al momento della compilazione, quindi questo significa anche che in staticamente tipizzato lingue ogni variabile ha un tipo e non cambia durante il corso. Ora, al contrario, linguaggi tipizzati in modo dinamico, sono quelli in cui il tipo di controllo è fatto in fase di runtime, e non c'è nessun tipo di controllo in fase di compilazione, quindi questo significa anche che nei linguaggi tipizzati in modo dinamico ci può essere o non essere un tipo associato con variabili, e se un tipo è associato, quindi potrebbe essere un tipo generico come “var” in JS che vale per entrambi una stringa e un numero.
- “Implementazioni in modo dinamico del tipo controllato lingue in generale e associare a ciascun oggetto di runtime con un tipo di tag (cioè, un riferimento a un tipo) contenente informazioni sul tipo.Questo tipo di runtime information (RTTI) può anche essere utilizzato per implementare l'invio dinamico, l'associazione tardiva, giù di casting, di riflessione e di caratteristiche simili.”
Anche se il linguaggio è staticamente tipizzato, avrebbe potuto dinamicamente tipizzato caratteristica, che in pratica significa che un qualche tipo di tipo di controllo a runtime.Questo è utile in fusione di tipi.
- “Una serie di utili e comune linguaggio di programmazione caratteristiche non possono essere controllati in modo statico, come la discesa di colata.Così, molte lingue che dispongono sia di tipo statico e dinamico di controllo;il tipo statico checker verifica che si può, e dinamica controlli di verificare il resto.”
“Alcuni linguaggi permettono la scrittura di codice che non è type-safe.Per esempio, in C, i programmatori possono liberamente il cast di un valore tra i due tipi che hanno la stessa dimensione.”
Il vantaggio di “staticamente” linguaggi tipizzati sono che:
- Poiché la maggior parte del tipo di controllo è fatto in fase di compilazione, in modo interprete o di runtime può funzionare a piena velocità, senza preoccuparsi di tipi.
- Essa conduce a un minor numero di eccezione di runtime o errori relativi al tipo, perché la maggior parte del tipo di controllo è fatto a tempo di compilazione.
Il vantaggio di “dinamicamente” linguaggi tipizzati sono che:
- Essi potrebbero contribuire in modo estremamente prototipazione rapida, in quanto sviluppatore non ha bisogno di capire il tipo di sistema, in modo che dev può liberamente creare variabili ed eseguire, e questo porta a molto di prototipazione rapida.
Elenco di staticamente e dinamicamente tipizzati lingue:
- In modo statico:
  - Java
  - C (C è un linguaggio tipizzato staticamente, ma meno “forte” tipizzato rispetto a Java perché permette di essere più conversioni implicite)
  - C++
  - C#
- Dinamicamente:
  - PERL
  - PHP
  - Python
  - JavaScript
  - Ruby
Tipo di controllo è un'importante caratteristica di sicurezza. Supponiamo, non c'è nessun tipo di controllo, e di un metodo che accetta un oggetto di tipo “conto in banca” che ha un metodo chiamato “creditAccount(BankAccountDetails)”, ora in fase di runtime se non c'è nessun tipo di controllo, quindi posso passare un oggetto della mia classe che ha le stesse metodo “creditAccount(BankAccountDetails)” e dovranno essere eseguite, visto che stiamo parlando di linguaggio orientato agli oggetti, perché OOP supporta il “polimorfismo” e qui che stiamo discutendo è nulla, ma il “polimorfismo”.Quindi, in sostanza un linguaggio object oriented (che in pratica significa che supporta “polimorfismo”) che non hanno forti tipo di controllo può portare a problemi di sicurezza.

Fortemente v/s debolmente tipizzato lingue

Fortemente tipizzato lingue sono quelle in cui le conversioni implicite non sono ammessi se vi è una perdita di precisione.Per esempio, in Java, è possibile lanciare un “int a lungo”, perché non vi è alcuna perdita di precisione, ma non si può “implicitamente” cast “long int”, perché ci può essere la perdita di precisione.In contrasto, nel debolmente tipizzato lingue, le conversioni implicite sono consentiti anche se vi è una perdita di precisione.
Penso che dinamicamente tipizzato lingua può anche essere un linguaggio fortemente tipizzato se “a runtime” non permette conversioni implicite in cui vi è perdita di precisione.

Buone letture ulteriori

lingue staticamente tipizzati in genere richiedono di dichiarare i tipi di variabili, che viene poi controllati in fase di compilazione per ridurre gli errori. La parola "statica" in "tipizzazione statica" si riferisce a "analisi del codice statico", che è il processo di esaminare l'codice prima di eseguirlo. Anche se è possibile che un linguaggio a tipizzazione statica di dedurre il tipo di variabile dal lato destro di un'espressione o di parametri attuali, in pratica più staticamente tipizzati lingue richiedono tipi di variabili essere esplicitamente dichiarati.

lingue dinamicamente tipizzati generalmente non richiedono dichiarazioni di variabili per avere i tipi, e inferire i tipi di variabile in base al tipo calcolato come risultato della valutazione del lato destro di ogni assegnamento oi parametri attuali a una chiamata di funzione. Dal momento che la variabile può essere dato più assegnazioni durante la sua vita, il suo tipo può cambiare nel corso del tempo ed è per questo che si chiama "dinamicamente digitato". Inoltre, l'ambiente runtime deve tenere traccia del tipo corrente per ogni variabile, in modo che il tipo è legato al valore piuttosto che con la dichiarazione variabile. Questo può essere considerato un sistema rtti (RTTI).

Elementi di lingue staticamente e dinamicamente tipizzati possono essere combinati. Ad esempio, C # supporta sia digitato staticamente e dinamicamente variabili, e linguaggi orientati agli oggetti in genere supporta down-getto della gerarchia dei tipi. lingue tipi statici di solito forniscono vari modi per tipo di bypass di controllo, per esempio utilizzando fusione, la riflessione e l'invocazione dinamica.

Forte vs. Debole Digitando si riferisce ad un continuum di quanto il linguaggio cerca di impedire errori dovuti all'utilizzo di una variabile come se fosse un tipo quando in realtà è un altro tipo. Per esempio sia in C e Java sono tipizzati staticamente lingue, tuttavia Java utilizza molto più forte di quanto non faccia il controllo di tipo C. Il seguente codice C è felice di compilare ed eseguire, e metterà un valore casuale in b variabili in fase di esecuzione, molto probabilmente causando un bug:

char *a = "123";
int b = (int)a;

Il codice Java equivalente produrrà un errore di compilazione, che è generalmente preferibile:

String a = "123"
int b = (int)a;

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow