Разница между сильно и слабо типизированными языками?

Я прочитал несколько страниц, в том числе страницу wiki http://en.wikipedia.org/wiki/Strong_and_weak_typing, в которой описаны сильно и слабо типизированные языки. По большей части, я думаю, я понимаю разницу. Тем не менее, я хотел бы прямо ответить на вопрос, дифференцируя их.

По моему мнению, на слабо типизированных языках типы данных не обязательно должны быть явно вызваны. Это был бы такой язык, как Matlab, где вы можете добавить 4 и 2.3 без приведения типов. Сильно типизированные языки требуют от программиста объявления типа данных для каждой переменной и/или значения. Например, в C вам нужно будет сделать что-то вроде 4 + (int) 2.3 или (float) 4 + 2.3 (не помню, если это допустимо C-литье).

Приветствуется всякая информация, расширяющая или корректирующая мое понимание этих понятий.

Ответ 1

Проверьте блог Эрика Липперта. Здесь есть запись о том, что вы ищете здесь.

Из взглядов его блога эти термины субъективны, поэтому "более точно говорите о функциях системы типов".

Ответ 2

Разница заключается не в объявлении типов переменных. Это немного более тонко, чем это (и темп Эрик Липперт, я думаю, что этот термин достаточно четко определен). Различие заключается в том, что на строго типизированном языке каждое выражение имеет тип, который можно определить во время компиляции, а разрешены только те операции, которые соответствуют этому типу.. p >

В нетипизированном ( "слабо типизированном" критике, "динамически типизированном" для фанатов) языке, это не так. Язык позволяет выполнять любую операцию на любом типе с достаточно существенным условием, что операция может завершиться неудачей. То есть, хотя язык может разрешить операцию, время выполнения может не быть.

Обратите внимание, что он может иметь строго типизированный язык, не требуя объявления типа везде. Действительно, ни один строго типизированный язык не делает. Рассмотрим этот бит Java:

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

Как компилятор решил, что .length является законным там? Это законно, потому что оно используется на byte[]. Но здесь нет никакого объявления как byte[]. Скорее, компилятор знает, что s является String, а когда вы вызываете getBytes() на String, вы получаете byte[]. Из этих фактов следует, что тип s.getBytes() является byte[], и поэтому законно запрашивать его length.

Некоторые языки, системы типов которых более сложны, чем Java, позволяют компилятору вывести больше, чем это. Например, в Scala вы можете сказать:

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

И компилятор выведет типы s и l, а также промежуточные выражения.

Языки, которые имеют сильную типизацию, но искусственные ограничения на вывод типа, которые требуют объявления избыточного типа (например, Java), описываются как имеющие типичную типизацию, поскольку типы должны быть явлены, что является причудливым способом выражения, который является причудливым способом сказать записано.

Ответ 3

Как вы сказали... ... в слабо типизированных языках типы данных не обязательно должны быть явно вызваны.

Сильно типизированные языки требуют, чтобы программист объявлял тип данных для каждой переменной и/или значения.

Это правильно...

Существует также парадигма в так называемых "сильно" типизированных языках, таких как С#, в которых типы могут быть объявлены при необходимости или нужны программисту... например. С# имеет тип "var", но также имеет сильные типы (Int32, String, Boolean и т.д.), Которые предпочитают многие программисты, которые используют этот язык.

Таким образом, язык может быть как "сильно", так и "слабо".

Надеюсь, это поможет вам в дальнейшем понять эту концепцию...

Ответ 4

Сильно типизированный язык проверяет тип переменной перед выполнением операции над ней, тогда как язык с плохой типизацией не работает.

Например: JAVA (строго типизированный язык):

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

C (слабо типизированный язык):

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