Differenza tra lingue fortemente e debolmente tipizzate?

Question

Ho letto diverse pagine, inclusa la pagina wiki http://en.wikipedia.org/wiki/Strong_and_weak_typing che trattava lingue con caratteri forti e debolmente tipizzati. Per la maggior parte, penso di capire la differenza. Tuttavia, vorrei una risposta diretta al punto di differenziare i due.

Dalla mia comprensione, in lingue debolmente tipizzate, i tipi di dati non devono essere chiamati esplicitamente. Questo sarebbe un linguaggio come Matlab in cui è possibile aggiungere 4 e 2.3 senza dover digitare. Le lingue fortemente tipizzate richiedono al programmatore di dichiarare un tipo di dati per ogni variabile e/o valore. Per esempio in C, avresti bisogno di fare qualcosa come 4 + (int) 2.3 o (float) 4 + 2.3 (non ricordo se questo è un casting di tipo C valido).

Qualsiasi informazione che espande o corregge la mia comprensione di questi concetti sarebbe molto apprezzata.

Answer 1

Controlla il blog di Eric Lippert. C'è una voce su proprio quello che stai cercando here.

Dall'aspetto del suo blog, questi termini sono soggettivi, quindi "parla in modo più preciso delle funzionalità del sistema di tipi".

Answer 2

Come hai detto ... ... in lingue debolmente tipizzate, i tipi di dati non devono essere chiamati esplicitamente.

Le lingue fortemente tipizzate richiedono al programmatore di dichiarare un tipo di dati per ogni variabile e/o valore.

Questo è corretto ...

V'è anche una sorta di paradigma nei cosiddetti "fortemente" tipizzati linguaggi come C#, in cui i tipi possono essere dichiarati, se necessario, o voluto dal programmatore ... per esempio C# ha il tipo "var", ma ha anche tipi forti (Int32, String, Boolean, ecc.) Che preferiscono molti programmatori che usano questa lingua.

In questo modo un linguaggio può essere sia "fortemente" che "debolmente" digitato.

Spero che questo aiuta ulteriormente la comprensione di questo concetto ...

Answer 3

La differenza non è di dichiarare i tipi di variabili. È un po 'più sottile di quello (e pace Eric Lippert, penso che il termine sia ragionevolmente ben definito). La distinzione è che in un linguaggio fortemente tipizzato, ogni espressione ha un tipo che può essere determinato al momento della compilazione e solo le operazioni appropriate a quel tipo sono consentite.

In un linguaggio non tipizzato ("debolmente tipizzato" per criticare, "digitato dinamicamente" per i fan), non è così. Il linguaggio consente a qualsiasi operazione di essere eseguita su qualsiasi tipo, con la riserva piuttosto sostanziale che l'operazione potrebbe non riuscire. Cioè, mentre la lingua può consentire l'operazione, il runtime non può.

Si noti che è possibile avere una lingua fortemente tipizzata senza richiedere dichiarazioni di tipo ovunque. In effetti, non esiste un linguaggio fortemente tipizzato. Considerate questo po 'di Java:

String s = "hellO"; 
int l = s.getBytes().length; 

Come fa il compilatore decide che .length è legale lì? È legale perché viene utilizzato su un byte[]. Ma non c'è nessuna dichiarazione di nulla come byte[] qui.Piuttosto, il compilatore sa che s è un String e che quando si chiama getBytes() su un String, si ottiene un byte[]. Da questi fatti risulta che il tipo di s.getBytes() è un byte[], e quindi è legale chiedere il suo length.

Alcune lingue i cui sistemi di tipi sono più sofisticati di Java consentono al compilatore di dedurre più di questo. Per esempio, in Scala, si può dire:

val s = "hello" 
val l = s.getBytes().length 

E il compilatore dedurre i tipi di s e l, così come delle espressioni intermedie.

Lingue che hanno una forte tipizzazione ma limiti artificiali sul tipo di inferenza che richiedono dichiarazioni di tipo ridondante (come Java) sono descritte come aventi manifesta digitando, perché i tipi devono essere resi manifesti, che è un modo elegante per dire portato esplicitamente all'esistenza, che è un modo elegante di dire scritto.

Answer 4

Un linguaggio fortemente tipizzato controlla il tipo di una variabile prima di eseguire un'operazione su di esso, mentre un linguaggio tipizzato debole no.

esempio: JAVA (linguaggio fortemente tipizzato):

int i = 10; 
boolean b = true; 
System.out.println(i + b); //compile error. Can't add int with boolean 

C (linguaggio debolmente tipizzato):

int i = 10; 
bool b = true; 
printf("%d" i + b); //Prints 11