Qual è la differenza tra un linguaggio fortemente tipizzato e un linguaggio a tipizzazione statica?

StackOverflow https://stackoverflow.com/questions/2690544

Domanda

Inoltre, si fa implica l'altra?

È stato utile?

Soluzione

  

Qual è la differenza tra un linguaggio fortemente tipizzato e un linguaggio a tipizzazione statica?

Un linguaggio a tipizzazione statica ha un sistema di tipo che viene verificata al momento della compilazione dall'implementazione (un compilatore o interprete). Il controllo di tipo respinge alcuni programmi, e programmi che superano il controllo solitamente con alcune garanzie; per esempio, le garanzie compilatore non usare intero istruzioni aritmetiche su numeri in virgola mobile.

Non c'è un vero accordo su cosa significa "fortemente tipizzati", anche se la definizione più usato nella letteratura professionale è che in una lingua "fortemente tipizzato", non è possibile per il programmatore per aggirare le restrizioni imposte dalla il sistema di tipi. Questo termine è quasi sempre usato per descrivere lingue staticamente tipizzati.

Statico vs dinamica

Il contrario di tipizzazione statica è "dinamico digitato", il che significa che

  1. I valori utilizzati in fase di esecuzione sono classificati in tipi.
  2. Non ci sono restrizioni su come possono essere utilizzati tali valori.
  3. Quando tali restrizioni sono violate, la violazione viene segnalato come un (dinamico) tipo di errore.

Per esempio, Lua , un linguaggio tipizzato in modo dinamico, ha un tipo stringa, un tipo di numero, e un tipo booleano , tra gli altri. In Lua ogni valore appartiene a esattamente un tipo, ma questo non è un requisito per tutte le lingue dinamicamente tipizzati. In Lua, è consentito per concatenare due stringhe, ma non è ammissibile per concatenare una stringa e un valore booleano.

Forte vs debole

Il contrario di "fortemente tipizzato" è "debolmente tipizzato", che significa che è possibile aggirare il sistema di tipi. C è notoriamente debolmente tipizzato perché qualsiasi tipo di puntatore è convertibile in qualsiasi altro tipo di puntatore semplicemente per fusione. Pascal doveva essere fortemente tipizzato, ma una svista nella progettazione (record varianti senza tag) illustra una lacuna nel sistema tipo, quindi tecnicamente è debolmente tipizzato. Esempi di linguaggi fortemente tipizzati veramente includono CLU, ML standard, e Haskell. Standard ML ha infatti subito diverse revisioni per rimuovere falle nel sistema di tipo che sono stati scoperti dopo che il linguaggio è stato ampiamente utilizzato.

Cosa sta realmente accadendo qui?

Nel complesso, si scopre di non essere così utile per parlare di "forte" e "debole". Se un sistema di tipo ha una scappatoia è meno importante il numero esatto e la natura delle lacune, come è probabile che a venire in pratica, e quali sono le conseguenze di sfruttare una scappatoia. In pratica, è meglio evitare i termini "forti" e "deboli" del tutto , in quanto

  • Amatoriali spesso li assimila con "statico" e "dinamico".

  • Apparentemente "tipizzazione debole" viene usato da persone a parlare del prevalance relativa o assenza di conversioni implicite.

  • i professionisti non riescono ad accordarsi su esattamente che cosa significano i termini.

  • In generale e 'difficile informare o illuminare il vostro pubblico.

La triste verità è che quando si tratta di scrivere sistemi, "forte" e "debole" non hanno un universalmente concordato significato tecnico. Se si vuole discutere la forza relativa di tipo sistemi, è meglio per discutere esattamente quali garanzie sono e non sono forniti. Ad esempio, una buona domanda da porsi è questa: "è ogni valore di un determinato tipo (o classe) garantito per essere stato creato chiamando uno dei costruttori che di tipo?" In C la risposta è no. In CLU, F #, e Haskell è sì. Per C ++ Non sono sicuro mi piacerebbe sapere.

Per contro, statica digitazione significa che i programmi sono controllato prima dell'esecuzione , e un programma può essere respinto prima che inizi. Dinamico digitazione significa che i tipi di valori sono controllati durante esecuzione, e un maloperazione digitato potrebbe causare il programma di arresto 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".

  

Se uno implica l'altro?

A livello pedante, no, perché la parola "forte" in realtà non significa nulla. Ma in pratica, la gente quasi sempre fare una delle due cose:

  • Si (in modo non corretto) uso "forte" e "debole" per significare "statico" e "dinamico", nel qual caso (in modo errato) stanno usando "fortemente tipizzato" e "staticamente tipizzati" in modo intercambiabile.

  • Usano "forte" e "debole" per confrontare le proprietà dei sistemi di tipo statico. E 'molto raro sentire qualcuno parlare di un "forte" o "debole" del sistema di tipo dinamico. Fatta eccezione per via, che in realtà non ha alcun tipo di un sistema di tipo, non riesco a pensare ad un linguaggio tipizzato in modo dinamico in cui il sistema tipo può essere sovvertito. Una sorta di per definizione, tali controlli sono bulit nel motore di esecuzione, e ogni operazione ottiene controllati per la sanità mentale prima di essere giustiziato.

In entrambi i casi, se una persona chiama un linguaggio "fortemente tipizzato", quella persona è molto probabile che sia parlare di un linguaggio a tipizzazione statica.

Altri suggerimenti

Questo è spesso frainteso per cui vorrei chiarirlo.

statico / dinamico Typing

Static tipizzazione è dove il tipo è legato alla variabile . Tipi vengono controllati al momento della compilazione.

Dinamico tipizzazione è dove il tipo è legato al valore . Tipi vengono controllati in fase di esecuzione.

Quindi, in Java, per esempio: 

String s = "abcd";

s sarà "per sempre" essere un String. Durante la sua vita può puntare a diversi Strings (poiché s è un riferimento in Java). Si può avere un valore null ma non sarà mai riferirsi ad un Integer o un List. Ecco tipizzazione statica.

In PHP: 

$s = "abcd";          // $s is a string
$s = 123;             // $s is now an integer
$s = array(1, 2, 3);  // $s is now an array
$s = new DOMDocument; // $s is an instance of the DOMDocument class

Questa è la tipizzazione dinamica.

Forte / Typing Debole

(Modifica alert!)

tipizzazione forte è una frase senza ampiamente concordato significato. La maggior parte dei programmatori che utilizzano questo termine per qualcosa di media diversi dall'uso tipizzazione statica a implicano che c'è un tipo di disciplina che viene applicata dal compilatore. Ad esempio, CLU ha un sistema di tipo forte che non consente codice client per creare un valore di tipo astratto se non utilizzando i costruttori forniti dal tipo. C è un sistema di tipo piuttosto forte, ma può essere "sovvertire" in misura perché un programma può sempre inserire un valore di un tipo di puntatore a un valore di un altro tipo di puntatore. Così, per esempio, in C si può prendere un valore restituito da malloc() e allegramente gettarlo ai FILE*, e il compilatore non cercare di fermare voi, o addirittura si avvisa che si sta facendo qualcosa di rischioso.

(La risposta originale detto qualcosa su un valore "non cambiare tipo in fase di esecuzione". Ho conosciuto molti progettisti di linguaggi e scrittori del compilatore e non ho conosciuto uno che ha parlato di valori di tipo in fase di esecuzione che cambiano, tranne forse alcuni molto avanzata ricerca in sistemi di tipo, in cui questo è noto come il "forte problema di aggiornamento".)

tipizzazione debole implica che il compilatore non impone un discpline di battitura, o forse che l'applicazione può essere facilmente sovvertito.

L'originale di questa risposta conflated tipizzazione debole con conversione implicita (a volte chiamato anche "promozione implicito"). Per esempio, in Java: 

String s = "abc" + 123; // "abc123";

Questo codice è un esempio di promozione implicita: 123 viene implicitamente convertito in una stringa prima di essere concatenato con "abc". Si può sostenere il compilatore Java riscrive il codice come: 

String s = "abc" + new Integer(123).toString();

Si consideri un PHP classico "inizia con" problema: 

if (strpos('abcdef', 'abc') == false) {
  // not found
}

L'errore qui è che strpos() restituisce l'indice della partita, essendo 0. 0 è costretto in false booleano e quindi la condizione è effettivamente vero. La soluzione è quella di utilizzare === anziché == per evitare conversione implicita.

Questo esempio illustra come una combinazione di conversione implicita e tipizzazione dinamica può portare programmatori fuori strada.

Confronto che a Ruby: 

val = "abc" + 123

che è un errore di runtime perché in rubino oggetto 123 è non implicitamente convertito solo perché sembra essere passato a un metodo +. In Ruby il programmatore deve fare la conversione esplicita: 

val = "abc" + 123.to_s

Confronto tra PHP e Ruby è un buon esempio qui. Entrambi sono dinamicamente tipizzati lingue, ma PHP ha un sacco di conversioni implicite e Rubino (forse sorprendentemente, se non si ha familiarità con esso) non fa.

statico / dinamico vs Forte / Debole

Il punto qui è che il / asse dinamico statico è indipendente dal asse forte / debole. La gente li confondono probabilmente in parte a causa forte vs tipizzazione debole non è solo meno chiaramente definiti, non v'è alcun reale consenso su esattamente che cosa si intende con forti e deboli. Per questo motivo forte / tipizzazione debole è molto più di una tonalità of grigio anziché nero o bianco.

Quindi, per rispondere alla tua domanda:. Un altro modo di guardare a questo che di lo più corretto per dire che tipizzazione statica è in fase di compilazione della sicurezza tipo e tipizzazione forte è il runtime di sicurezza di tipo

La ragione di questo è che le variabili in un linguaggio a tipizzazione statica hanno un tipo che deve essere dichiarata e possono essere controllati al momento della compilazione. Un linguaggio fortemente tipizzato ha valori che hanno un tipo in fase di esecuzione, ed è difficile per il programmatore di sovvertire il sistema di tipo senza un controllo dinamico.

Ma è importante capire che una lingua può essere statico / Forte, statico / Debole, dinamico / Forte o Dinamico / debole.

Entrambi sono poli su due assi differenti:

  • vs. fortemente tipizzato debolmente tipizzato
  • vs. staticamente tipizzato dinamicamente tipizzato

fortemente tipizzato i mezzi, un non vengono convertiti automaticamente da un tipo all'altro. digitato debolmente è l'opposto: Perl può utilizzare una stringa come "123" in un contesto numerico, convertendo automaticamente nella int 123. Un linguaggio fortemente tipizzato come Python non farà questo.

staticamente tipizzato mezzi, le figure compilatore il tipo di ogni variabile in fase di compilazione. lingue dinamicamente tipizzati capire solo i tipi di variabili in fase di esecuzione.

fortemente tipizzato significa che ci sono restrizioni tra conversioni tra tipi. Staticamente tipizzato significa che i tipi non sono dinamici - non è possibile cambiare il tipo di una variabile, una volta che è stato creato.

Dati La coercizione non significa necessariamente debolmente tipizzato, perché a volte il suo zucchero syntacical:

L'esempio precedente di Java essere debolmente tipizzato a causa di 

String s = "abc" + 123;

Non è debolmente tipizzato esempio perché la sua davvero fare: 

String s = "abc" + new Integer(123).toString()

la coercizione dei dati, inoltre, non debolmente tipizzato se si sta costruendo un nuovo oggetto. Java è un pessimo esempio di digitato debolmente (e qualsiasi linguaggio che ha una buona riflessione molto probabilmente non essere debolmente tipizzato). Poiché il tempo di esecuzione del linguaggio sa sempre ciò che il tipo è (l'eccezione potrebbe essere tipi nativi).

Questo è diverso da C. C è uno dei migliori esempi di digitato debolmente. Il runtime ha idea se 4 byte è un intero, una struttura, un puntatore o un 4 caratteri.

Il tempo di esecuzione del linguaggio definisce in realtà se la sua debolmente tipizzato altrimenti la sua realtà solo parere.

EDIT: Dopo ulteriori pensato che questo non è necessariamente vero come il runtime non avere tutti i tipi reificati nel sistema di runtime per essere un sistema fortemente tipizzato. Haskell e ML hanno tale analisi statica completa che possano potenziale informazioni sul tipo OMMIT dal runtime.

Un non implica l'altra. Per un linguaggio per essere staticamente tipizzato significa che i tipi di tutte le variabili sono noti o dedotti in fase di compilazione.

Un con forza linguaggio tipizzato non consente l'utilizzo di un tipo come un altro. C è un linguaggio debolmente tipizzato ed è un buon esempio di ciò che lingue fortemente tipizzati non consentono. In C è possibile passare un elemento di dati del tipo sbagliato e non si lamentano. In linguaggi fortemente tipizzati non si può.

tipizzazione forte probabilmente significa che le variabili hanno un tipo ben definito e che non ci sono regole rigide sulla combinazione di variabili di diversi tipi di espressioni. Ad esempio, se A è un intero e B è un galleggiante, la regola rigorosi su A + B potrebbe essere che A è fuso ad un galleggiante e il risultato restituito come un galleggiante. Se A è un intero e B è una stringa, allora la regola rigida potrebbe essere che A + B non è valido.

tipizzazione statica probabilmente significa che i tipi sono assegnati al momento della compilazione (o il suo equivalente per le lingue non-compilato) e non può cambiare durante l'esecuzione del programma.

Si noti che queste classificazioni non si escludono a vicenda, anzi mi aspetto che si sono verificati di frequente insieme. Molte lingue fortemente tipizzato sono staticamente tipizzati.

E nota che quando uso la parola 'probabilmente' è perché non ci sono universalmente definizioni di questi termini accettati. Come avrete già visto dalle risposte finora.

  

La risposta è stata già data in precedenza. Cercando di distinguere tra forte vs settimana e statico vs concetto dinamico.

Qual è fortemente tipizzato VS debolmente tipizzato?

fortemente tipizzato: non saranno convertite automaticamente da un tipo ad un altro

In Vai o Python come le lingue fortemente tipizzati "2" + 8 alzerà un errore di tipo, perché non permettono di "tipo la coercizione".

debolmente (vagamente) scelto: saranno convertite automaticamente in un tipo all'altro: lingue debolmente tipizzato come JavaScript o Perl non genera un errore e in questo caso saranno javascript risultati '28' e perl si tradurrà 10.

Perl Esempio: 

my $a = "2" + 8;
print $a,"\n";

Salva per main.pl e perl main.pl corsa e si otterrà uscita 10.

Qual è statica VS Dyamic tipo?

Nella programmazione, progammer definire tipizzazione statica e la tipizzazione dinamica rispetto al punto in cui vengono controllati i tipi di variabili. Statico digitato lingue sono quelle in cui il controllo di tipo avviene a tempo di compilazione, mentre dinamico digitato lingue sono quelle in cui il controllo di tipo viene effettuato in fase di esecuzione.

  • statico: Tipi controllato prima di run-time
  • dinamico: Tipi controllata al volo, durante l'esecuzione

Che cosa è questo mezzo?

Nel fare da controlli digitati prima fase di esecuzione (controllo statico). Questo si traduce non solo e tipo di controlli codice significa che è in esecuzione, ma esegue la scansione attraverso tutti sarebbero stati gettati il ??codice e errore di tipo prima che il codice è ancora eseguito. Ad esempio, 

package main

import "fmt"

func foo(a int) {
    if (a > 0) {
        fmt.Println("I am feeling lucky (maybe).")
    } else {
        fmt.Println("2" + 8)
    }
}

func main() {
    foo(2)
}

Salva il file in main.go ed eseguirlo, si otterrà la compilazione messaggio non inviato per questo. 

go run main.go
# command-line-arguments
./main.go:9:25: cannot convert "2" (type untyped string) to type int
./main.go:9:25: invalid operation: "2" + 8 (mismatched types string and int)

Ma questo caso non è valido per Python. Ad esempio seguente blocco di codice verrà eseguito per primo foo (2) chiamata e sicuro per la seconda foo (0) chiamata. È perché Python viene digitato in modo dinamico, si traduce solo e tipo di controlli di codice è in esecuzione su. Il blocco else mai eseguito per foo (2), in modo da "2" + 8 è mai nemmeno guardato e per foo (0) chiamano tenterà di eseguire quel blocco e non è riuscito. 

def foo(a):
    if a > 0:
        print 'I am feeling lucky.'
    else:
        print "2" + 8
foo(2)
foo(0)

Si vedrà seguente output 

python main.py
I am feeling lucky.
Traceback (most recent call last):
  File "pyth.py", line 7, in <module>
    foo(0)
  File "pyth.py", line 5, in foo
    print "2" + 8
TypeError: cannot concatenate 'str' and 'int' objects
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top