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

Оба являются полюсами на двух разных осях:

• строго типизированный или слабо типизированный
• статический типизированный или динамически типизированный

строго типизированный означает, что a не будет автоматически преобразован из одного типа в другой . Слабая типизация - это наоборот: Perl может использовать строку типа «123» в числовом контексте, автоматически преобразовывая ее в int 123 . Строго типизированный язык, такой как python, этого не сделает.

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

Строгая типизация, вероятно, означает, что переменные имеют четко определенный тип и строгие правила комбинирования переменных разных типов в выражениях. Например, если A - целое число, а B - число с плавающей запятой, то строгим правилом для A + B может быть то, что A приводится к типу с плавающей запятой, а результат возвращается как float. Если A - целое число, а B - строка, то строгим правилом может быть недопустимость A + B.

Статическая типизация, вероятно, означает, что типы присваиваются во время компиляции (или его эквивалента для нескомпилированных языков) и не могут изменяться во время выполнения программы.

Обратите внимание, что эти классификации не являются взаимоисключающими, на самом деле я бы ожидал, что они будут часто встречаться вместе. Многие строго типизированные языки также имеют статическую типизацию.

И заметьте, что когда я использую слово «вероятно», это потому, что нет общепринятых определений этих терминов. Как вы уже видели из ответов.

Принуждение данных не обязательно означает слабую типизацию, потому что иногда это синтаксический сахар:

Приведенный выше пример со слабой типизацией Java из-за

String s = "abc" + 123;

Не является слабо типизированным примером, потому что это действительно так:

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

Принуждение данных также не является слабо типизированным, если вы создаете новый объект. Java - очень плохой пример слабо типизированного (и любой язык, который имеет хорошее отражение, скорее всего, не будет слабо типизированным). Поскольку среда выполнения языка всегда знает, что это за тип (исключением могут быть собственные типы).

В этом отличие от C. C - один из лучших примеров слабо типизированных. Среда выполнения не знает, являются ли 4 байта целым числом, структурой, указателем или 4 символами.

Время выполнения языка действительно определяет, является ли он слабо типизированным, в противном случае это действительно справедливое мнение.

РЕДАКТИРОВАТЬ: После дальнейших размышлений это не обязательно верно, поскольку среда выполнения не обязательно должна иметь все типы, переопределенные в системе времени выполнения, чтобы быть системой со строгой типизацией. Haskell и ML имеют такой полный статический анализ, что они могут исключить информацию о типе из среды выполнения.

Одно не подразумевает другого. Для языка, который будет статически типизирован, это означает, что типы всех переменных известны или предполагаются во время компиляции.

строго типизированный язык не позволяет использовать один тип как другой. C - это слабо типизированный язык, и он является хорошим примером того, что строго типизированные языки не допускают. В C вы можете передать элемент данных неправильного типа, и он не будет жаловаться. На строго типизированных языках это невозможно.

Это часто неправильно понимают, поэтому позвольте мне прояснить это.

Статическая / динамическая типизация

Статическая типизация - это когда тип привязан к переменной . Типы проверяются во время компиляции.

При динамической типизации тип привязан к значению . Типы проверяются во время выполнения.

Так, например, в Java:

String s = "abcd";

s «навсегда» будет String . В течение своей жизни он может указывать на разные String s (поскольку s является ссылкой в ​​Java). Он может иметь значение null , но никогда не будет ссылаться на Integer или список . Это статическая типизация.

В 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

Это динамическая типизация.

Сильная / Слабая типизация

(Редактировать предупреждение!)

Сильная типизация - это фраза, не имеющая общепринятого значения. Большинство программистов, которые используют этот термин для обозначения чего-то другого, кроме статической типизации, используют его, чтобы подразумевать, что существует дисциплина типов, которая обеспечивается компилятором. Например, в CLU есть строгая система типов, которая не позволяет клиентскому коду создавать значение абстрактного типа, кроме как с помощью конструкторов, предоставляемых этим типом. C имеет довольно сильную систему типов, но ее можно до некоторой степени «подорвать», потому что программа всегда может привести значение одного типа указателя к значению другого типа указателя. Так, например, в C вы можете взять значение, возвращаемое функцией malloc () , и весело преобразовать его в FILE * , и компилятор не попытается остановить вас или даже предупредить вы что делаете что-нибудь хитрое.

(В исходном ответе что-то говорилось о значении, «не меняющем тип во время выполнения». Я знал многих разработчиков языков и разработчиков компиляторов, но не знал ни одного, который бы говорил об изменении типа значений во время выполнения, за исключением, возможно, некоторых очень продвинутых исследование систем типов, где это известно как «проблема сильного обновления».)

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

В оригинале этого ответа слабая типизация объединилась с неявным преобразованием (иногда также называемым «неявным продвижением»). Например, в Java:

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

Этот код является примером неявного продвижения: 123 неявно преобразуется в строку перед объединением с «abc» . Можно утверждать, что компилятор Java переписывает этот код следующим образом:

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

Рассмотрим классическую проблему PHP "начинается с":

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

Ошибка в том, что strpos () возвращает индекс соответствия, будучи 0. 0 преобразуется в логическое ложное , и, таким образом, условие действительно истинно. Решение состоит в том, чтобы использовать === вместо == , чтобы избежать неявного преобразования.

Этот пример показывает, как сочетание неявного преобразования и динамической типизации может сбить программистов с пути.

Сравните это с Ruby:

val = "abc" + 123

, что является ошибкой времени выполнения, потому что в Ruby объект 123 не неявно преобразован только потому, что он передается в + метод.В Ruby программист должен сделать преобразование явным:

val = "abc" + 123.to_s

Сравнение PHP и Ruby - хорошая иллюстрация. Оба являются динамически типизированными языками, но PHP имеет множество неявных преобразований, а Ruby (что, возможно, удивительно, если вы с ним не знакомы) - нет.

Статическая / динамическая и сильная / слабая

Дело в том, что статическая / динамическая ось не зависит от сильной / слабой оси. Люди путают их, вероятно, отчасти потому, что сильная и слабая типизация не только менее четко определены, но и нет реального консенсуса относительно того, что именно подразумевается под сильным и слабым. По этой причине сильный / слабый набор текста - это скорее оттенок серого, чем черный или белый.

Итак, чтобы ответить на ваш вопрос: другой способ взглянуть на это, в основном правильный, - это сказать, что статическая типизация - это безопасность типов во время компиляции, а строгая типизация - это безопасность типов во время выполнения.

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

Но важно понимать, что язык может быть статическим / сильным, статическим / слабым, динамическим / сильным или динамическим / слабым.