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

строгой типизации обычно означает, что есть никаких лазеек в системе типов, тогда как слабая типизация значит типа система может быть разрушена (аннулирование каких-либо гарантий). Эти термины часто используются неправильно для обозначения статической и динамической типизации. Чтобы увидеть разницу, подумайте о C: язык проверяется на тип во время компиляции (статическая типизация), но есть много лазеек; вы можете в значительной степени привести значение любого типа к другому типу того же размера-в частности, вы можете свободно использовать типы указателей. Паскаль был языком, который должен был быть строго типизирован, но, как известно, имел непредвиденную лазейку: a вариант записи без тега.

реализации строго типизированных языков часто приобретают лазейки с течением времени, обычно так, что часть системы времени выполнения может быть реализована на языке высокого уровня. Например, Objective Caml имеет функцию с именем Obj.magic который имеет эффект времени выполнения просто возвращая свой аргумент, но во время компиляции он преобразует значение любого типа в один из любого другого типа. Мой любимый пример-Modula-3, дизайнеры которого назвали их type-casting построить LOOPHOLE.

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

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

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

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

например в Python:

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

С другой стороны,сильная/слабая типизация в языке связано с неявными преобразованиями типов (частично взято из ответа @Dario):

например в Python:

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

тогда как в PHP:

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

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

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

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

в строго типизированном языке тип объекта не имеет изменение-int всегда является int и попытка использовать его в качестве строки приведет к ошибке. И Java, и Python строго типизированы.

разница между динамической и статической типизацией заключается в том, когда применяются правила типа. В статически типизированном языке тип каждой переменной и параметра должен быть объявлен в источнике и применен во время компиляции. В динамически типизированном языке типы проверяются только тогда, когда они используются во время выполнения. Таким образом, Java статически типизирована и Python-это динамически типизированный.

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

аналогично наиболее строго типизированные языки по-прежнему будут автоматически преобразовываться между целыми числами и поплавками (и в некоторых языках abitrary precision BigInts).

сегодня исследуя эту тему я наткнулся на эту замечательную статью http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html это прояснило много вещей для меня, и я думал, что это может добавить к некоторым из великих ответов выше.

сильный и слабый набрав:

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

статические и динамические типы

Это почти единственная общая классификация систем типа это имеет реальное значение. На самом деле, это значение является часто недооценивается [...] Динамические и статические системы типа являются две совершенно разные вещи, цели которых происходят частично частично покрывать.

статическая система тип механизм, с помощью которого компилятор проверяет исходный код и присваивает метки (называемые "типы") частям синтаксис, а затем использует их для вывода чего - то о программе поведение. Динамическая система тип механизм, с помощью которого компилятор генерирует код для отслеживания вида данных (по совпадению, также называется его "тип") используется программой. Использование то же самое слово "типа" в каждой из этих двух систем, конечно, не совсем полностью совпадение; тем не менее, лучше всего понимать, как наличие своего рода слабого историческое значение. Большая путаница возникает в результате попыток найти мировоззрение, в котором "тип" действительно означает одно и то же в обоих случаях системный. Это не так.

Явные / Неявные Типы:

когда эти термины используются, они относятся к степени, в которой a компилятор будет рассуждать о статике типы частей программы. Все языки программирования имеют некоторую форму рассуждения о типах. Некоторые есть больше, чем другие. ML и Haskell имеют неявные типы, в которых нет (или очень мало, в зависимости от используемого языка и расширений) тип нужны декларации. Java и Ada имеют очень явные типы, и человек постоянно декларирует типы вещей. Все вышеперечисленное есть (относительно, по сравнению с C и C++, например) сильный статический тип системный.

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

вот два примера:

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

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

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

статически v / S динамически типизированные языки

• статически типизированные языки-это те, в которых проверка типов выполняется во время компиляции, поэтому это также означает, что в статически типизированных lanaguges каждая переменная имеет тип и она не меняется в течение курса. теперь, напротив, динамически типизированные lanaguges-это те, в которых проверка типа выполняется во время выполнения, и нет проверки типа во время компиляции, поэтому это также означает, что в динамически типизированные языки может быть или не быть тип, связанный с переменными, и если тип связан, то это может быть общий тип, такой как "var" в JS, который хорош как для строки, так и для числа.
  • "реализации динамически проверяемых языков обычно связывают каждый объект среды выполнения с тегом типа (т. е. ссылкой на тип), содержащим информацию о его типе. Эта информация о типе среды выполнения (RTTI) также может использоваться для реализации динамической отправки, поздней привязки, вниз бросать, отражение, и подобные особенности."
• даже если язык статически типизирован, все равно он может иметь некоторую динамически типизированную функцию, что в основном означает, что какая-то проверка типа во время выполнения также. Это полезно при литье типов.
  • " ряд полезных и общих функций языка программирования не может быть проверен статически,например, приведение вниз. Таким образом, многие языки будут иметь как статическую, так и динамическую проверку типов; статическая type checker проверяет, что он может, а динамические проверки проверяют остальное."
• "некоторые языки позволяют писать код, который не является типобезопасным. Например, в C программисты могут свободно передавать значение между любыми двумя типами, имеющими одинаковый размер."
• преимущество" статически " набранных lanaguges таково:
  • поскольку проверка типа делается во время компиляции, поэтому переводчик или runtime может работать на полной скорости, не беспокоясь о видах.
  • это приводит к меньшему количеству исключений во время выполнения или ошибок, связанных с типом, потому что большая часть проверки типа выполняется во время компиляции.
• преимущество "динамически" типизированных lanaguges таково:
  • Они могут помочь в чрезвычайно быстром прототипировании, поскольку разработчику не нужно понимать систему типов, поэтому dev может свободно создавать переменные и запускать ее, и это приводит к очень быстрому прототипирование.
• список статически и динамически типизированных lanaguges:
  • статически:
    • Java
    • C (C-статически типизированный язык, но менее" сильно " типизированный по сравнению с Java, потому что он позволяет более неявно конверсии)
    • C++
    • C#
  • динамически:
    • PERL
    • PHP
    • Python
    • JavaScript
    • Рубин
• проверка типа является важной функцией безопасности. предположим, что нет проверки типа, и метод принимает объект типа "BankAccount", который имеет метод, называемый " creditAccount(BankAccountDetails)", теперь во время выполнения, если нет проверки типа, я могу передать объект моего собственного класса, который имеет тот же метод "creditAccount(BankAccountDetails)", и он будет выполнен, учитывая, что мы говорим об объектно-ориентированном языке, потому что ООП поддерживает "полиморфизм", и здесь мы обсуждаем не что иное, как "полиморфизм". Таким образом, в основном объектно-ориентированный язык (что в основном означает, что он поддерживает "полиморфизм"), который не имеет сильной проверки типов, может привести к безопасности проблемы.

сильно v / S слабо набранные lanaguges

• строго типизированные lanaguges-это те, в которых неявные преобразования не допускаются, если есть потеря точности. Например, в Java вы можете привести "int к long", потому что нет потери точности, но вы не можете "неявно" привести "long к int", потому что будет потеря точности. Напротив, в слабо типизированных lanaguges неявные преобразования разрешены, даже если есть потеря точность.
• Я думаю, что динамически типизированный язык также может быть строго типизированным языком, если "во время выполнения" он не допускает неявных преобразований, в которых есть потеря точности.

---

хорошо далее показания

• Type_system
• Strong_and_weak_typing
• Категория:Statically_typed_programming_languages
• Категория:Dynamically_typed_programming_languages

от Прагматика Языка Программирования, 3-я страница 291 edidition, у нас есть

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

несколько примеров: Ада строго типизирована, и по большей части статически типизированный (некоторые ограничения типа должны быть проверены при запуске время.) Реализация Pascal также может выполнять большую часть проверки типов во время компиляции, хотя язык не совсем строго типизирован: нетегированные вариантные записи (которые будут обсуждаться в разделе 7.3.4) являются его только лазейка. C89 значительно более сильно типизирован, чем его диалекты предшественников, но все же значительно менее сильно типизированные, чем Паскаль. Его лазейки включают союзы, подпространства с переменными числами параметров, и совместимость указателей и массивов (быть обсуждалось в разделе 7.7.1). Реализации C редко проверяют что-нибудь во время выполнения.

динамическая (во время выполнения) проверка типа является формой поздней привязки и имеет тенденцию чтобы найти на языках, которые задерживают другие проблемы до времени выполнения, как что ж. Lisp и Smalltalk динамически (хотя и сильно) типизированы. Наиболее языки сценариев динамической типизацией; некоторые (например, Python и Ruby) строго типизированы. Языки с динамической обзор в целом динамически типизированный (или не типизированный вообще): если компилятор не может определите объект, к которому относится имя, обычно он не может определить тип объекта, либо.

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

Я попытался перевести описание Скотта в красивую диаграмму, которую я опубликовал ниже.

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

динамически типизированные языки обычно не требуют, чтобы объявления переменных имели типы, и они выводят типы переменных на основе типа, вычисленного в результате оценки правой части каждого оператора присваивания или фактических параметров вызова функции. Поскольку переменной может быть присвоено несколько назначений в течение ее жизни, ее тип может меняться с течением времени, и именно поэтому она называется "динамически типизированной". Кроме того, среда выполнения среда должна отслеживать текущий тип для каждой переменной, поэтому тип привязан к значению, а не к объявлению переменной. Это можно считать информационной системой типа времени выполнения (RTTI).

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

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

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

эквивалентный код Java приведет к ошибке компиляции, что обычно предпочтительнее:

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