что такое строгая типизация
Строгая типизация
Строгая типизация — один из вариантов политики работы с типами данных, которая используется в языках программирования.
Содержание
Обязательные условия
Строгая типизация подразумевает выполнение следующих обязательных условий:
При точном следовании требованиям строгой типизации даже одинаковые по составу значений и допустимым операциям типы данных являются несовместимыми. Если в программе необходимо присвоить значение одного типа данных переменной другого типа, это можно сделать, но только путём явного применения специальной операции преобразования типа, которая в таких случаях обычно является частью языка программирования (хотя может формально и не являться ею, а предоставляться стандартными библиотеками).
Типизация в языках программирования
В информатике и программировании понятие Сильнотипизированный язык означает ситуацию, когда язык программирования накладывает одно или несколько ограничений на употребление операций над разными типами данных. Антоним — слаботипизированный язык. Однако этим терминам придавалось такое множество значений за историю вычислительной техники, что часто трудно понять вне контекста, что автор хотел выразить ими.
Некоторые языки, формально имеющие понятие типа данных, в действительности можно считать нетипизированными. К таким языкам относится классический Си, в котором, хотя объявление типов и требуется, в действительности все типы данных являются совместимыми по присваиванию (современные компиляторы Си ограничивают эту свободу и выдают, по меньшей мере, предупреждения при опасных преобразованиях типов).
В теории программирования строгая типизация является непременным элементом обеспечения надёжности разрабатываемых программных средств. При правильном применении (подразумевающем, что в программе объявляются и используются отдельные типы данных для логически несовместимых значений) она защищает программиста от простых, но труднообнаруживаемых ошибок, связанных с совместным использованием логически несовместимых значений, возникающих иногда просто из-за элементарной опечатки.
Подобные ошибки выявляются ещё на этапе компиляции программы, тогда как при возможности неявного приведения практически любых типов друг к другу (как, например, в классическом языке Си) эти ошибки выявляются только при тестировании, причём не все и не сразу.
Что такое типизация в программировании
Объясняем, что это такое, какая бывает типизация и на что она влияет.
Если вы читали что-то о языках программирования, то наверняка не раз наткнулись на упоминание типизации. Что это такое и что об этом нужно знать, когда выбираешь язык программирования?
Типизация — это то, как язык распознаёт типы переменных. Типизация определяет, нужно ли вам писать тип, или язык «поймёт» его сам, и насколько свободно можно с типами работать: например, можно ли их менять.
В бэкграунде — программирование, французский язык, академическое рисование, капоэйра. Сейчас учит финский. Любит путешествия и Балтийское море.
А что такое типы?
В переменную можно записывать информацию, а тип переменной описывает, какая именно информация записана в переменной и что с ней можно делать.
Типы бывают разные и немного различаются в разных языках.
Зачем нужно знать о типизации?
От типизации зависит, как вам работается с языком, как он себя ведёт. Если вы знаете, какие выгоды или проблемы приносят разные виды типизации, вам легче будет выбрать язык.
Какая бывает типизация?
Слабая и сильная
Если у языка сильная типизация (её ещё называют строгой), это значит, что он требует, чтобы разработчики строго следовали правилам работы с типами: если вы обозначили что-то как целое число, будьте добры с ним работать как с целым числом.
Языки со слабой типизацией «добрее»: если вы решите прибавить число к тексту, они не будут ругаться, а попробуют сделать то, что вы просите. Правда, результат может быть не совсем таким, как вы планировали.
В JavaScript, языке со слабой типизацией, можно сложить строку с числом, например вот так:
И получить строку «21».
А в Java так сделать нельзя: появится ошибка.
Статическая и динамическая
Статическая типизация значит, что типы определяются на этапе компиляции. То есть ошибки в типах будут видны ещё до того, как программа запустится.
В языках с динамической типизацией типы определяются во время выполнения программы.
Так, в динамически типизированном языке у одной и той же переменной могут быть разные типы в разных частях программы, а в статически типизированном, если вы задали переменной тип string, у неё будет только тип string.
Например, в Python (динамическая типизация) можно сделать вот так:
И язык не будет возражать. В Java (статическая типизация) так сделать нельзя.
Явная и неявная
Ещё типизацию делят на явную и неявную. Когда типизация неявная, тип определяется сам в момент, когда вы записываете в переменную информацию.
Например, если в Python написать так:
Он прочитает, что вы записали в переменную b целое число, и определит b как integer (int).
Явная типизация значит, что тип переменной написан. Например, в С переменная записывается вот так:
Само по себе разделение типизации на явную и неявную не столь важно: в статически типизированных языках она почти всегда явная, а в динамически — неявная.
Как типизация влияет на работу с языком?
Важно учитывать, что типизация — далеко не единственный фактор, который влияет на скорость. Нельзя сказать, что все языки со статической типизацией быстрее языков с динамической.
В каких языках какая типизация
Напоследок — типизации некоторых популярных языков:
Если вы пока новичок в программировании, то приглашаем вас на наш курс «Python-разработчик». Потому что Python — один из лучших языков для начинающих, в том числе благодаря своей типизации. Он научит дисциплине в работе с переменными, но при этом не уморит долгой писаниной. В курсе расскажут подробнее о разных типах переменных и динамической типизации, научат работе с классами и объектами и познакомят с разными библиотеками.
Ликбез по типизации в языках программирования
В данной статье содержится весь необходимый багаж информации, который нужно знать о типизации, для того чтобы динамическая типизация не показалась вам сущим злом.
В развернутой вариации этой статьи расположено детальное отображение всех форм типизации, дополненное образцами кода, а также ссылками на известные всеми языки программирования и наглядными картинками
Советую изначально ознакомиться с сокращенным вариантом статьи, а после при желании приступить к развёрнутой версии.
Сокращенная вариация
Обычно языки программирования по типизации делят на две крупные стороны: типизированные и нетипизированные (бестиповые). К первой стороне можно отнести C, Python, Scala, PHP и Lua, а ко второй язык ассемблера, Forth и Brainfuck.
Поскольку «бестиповая типизация» в сущности – чрезмерно проста, то в дальнейшем она не разделяется на другие типы. Вместо этого типизированные языки представляют собой ещё несколько видов:
Примеры:
Статическая: C, Java, C#;
Динамическая: Python, JavaScript, Ruby.
Примеры:
Сильная: Java, Python, Haskell, Lisp;
Слабая: C, JavaScript, Visual Basic, PHP.
Явная типизация – языки данной типизации разнятся тем, что тип новых переменных / функций / их доводов необходимо задавать явно.
Неявная типизация – языки этой типизации переносят эту задачу на компилятор / интерпретатор.
Примеры:
Неявная: PHP, Lua, JavaScript
По крайней мере, не может быть языков со статической и динамической типизаций одновременно. Однако опережая события, сообщу, что в этом моменте я вру, на самом деле они есть, но об этом чуть позже.
Развернутая вариация
В том случае если информации в сокращенной вариации Вам оказалось мало, то это хорошо. Так как для этого я и написал развёрнутую версию. Суть в том, что в сокращенную вариацию нереально было вместить весь полезный и занимательный материал, развернутая, скорее всего, получится чересчур длинная, не каждый сможет её осилить не напрягаясь.
Бестиповая типизация
В бестиповых языках программирования – все сущности являются обычными очередностями бит, разной длины.
Такая типизация свойственна низкоуровневым (язык ассемблера, Forth) и эзотерическим (Brainfuck, HQ9, Piet) языкам. Но и у неё наравне с недочётами, присутствует перечень достоинств.
Достоинства
Недостатки
Сильная бестиповая типизация?
Да, такое наблюдается. К примеру, в языке ассемблера (для архитектуры х86/х86-64, других не знаю) не следует ассемблировать программу, в случае если вы попробуете загрузить в регистр cx (16 бит) данные из регистра rax (64 бита).
mov cx, eax ; ошибка времени ассемблирования.
То есть выходит, что в ассемблере все-таки есть типизация? Я думаю, что количество подобных проверок неудовлетворительно. Но Ваше мнение зависит, исключительно, только от Вас.
Статическая и динамическая типизации
Важно, что статическую (static) типизацию отличает от динамической (dynamic) именно то, что все проверки видов происходят на этапе сбора данных, а не на этапе осуществления.
Некоторые люди считают, что статическая типизация излишне ограничена (на самом деле так и есть, но от этого давно избавились при помощи неких методик). Некие же думают, что динамически типизированные языки — это рискованные действия, но какие особенности их отличают? Неужели оба вида имеют шансы на существование? Если нет, то почему много как статически, так и динамически типизированных языков?
Давайте разберемся.
Преимущества статической типизации
Проверки типов осуществляются исключительно один раз — на этапе сбора данных. А это означает, что нам не требуется постоянно определять, не пытаемся ли мы поделить число на строку (и либо выдать ошибку, либо осуществить преобразование).
Скорость проведения. Из предыдущего пункта ясно, что статически типизированные языки чаще всего быстрее динамически типизированных.
При неких дополнительных условиях, предоставляется возможность выявлять потенциальные ошибки уже на этапе компиляции.
Ускорение разработки при поддержке IDE (отсеивание вариантов, заведомо не подходящих по типу).
Преимущества динамической типизации
Обобщенное программирование
Главный аргумент за динамическую типизацию – комфортность изложения обобщенных алгоритмов. Предлагаю представить задачу – нам потребуется функция поиска по некоторым спискам – по массиву целых чисел, по массиву вещественных и массиву символов.
Каким же образом мы решим такую задачу? С помощью 3-ех различных языков: один с динамической типизацией и два других со статической.
Алгоритм поиска будет один из элементарных – перебор. Функция получает искомый элемент, сам массив (или список) и впоследствии будет возвращать индекс элемента, или, если элемент не найден – (-1).
Динамическое решение (Python):
Как вы можете видеть, все элементарно и никаких проблем с тем, что список может содержать как числа, списки, либо другие массивы нет. Отлично. А значит, следуем дальше и решим эту же задачу теперь на Си!
Статическое решение (Си):
Допустим, любая функция индивидуально сходна версии из Python, но отчего же их три? Неужто статическое программирование проиграло?
Нельзя дать однозначный ответ. Исходя из того, что есть множество технологий программирования, одну из них мы сейчас обсудим. Называется она обобщенное программирование, а язык C++ ее неплохо сохраняет. Рассмотрим новую вариацию:
Статическое решение (обобщенное программирование, C++):
Хорошо! Такое решение выглядит не намного сложнее, чем вариант на Python, а писать пришлось гораздо больше. Дополнительно мы получаем реализацию для всех массивов, а не только для 3-ех, которые необходимы для решения задачи!
Данный вариант именно тот, который нужен, помимо того, что мы получаем плюсы статической типизации, дополнительно у нас есть плюсы динамической.
Радует, что такое можно реализовать, но всегда есть возможность сделать ещё лучше. Во-первых, обобщенное программирование можно сделать гораздо удобнее и привлекательней как в языке Haskell. Во-вторых, кроме обобщенного программирования можно использовать полиморфизм (результат будет хуже), перегрузку функций (аналогично) или макросы.
Статика в динамике
Кроме того следует отметить, что большинство статических языков предоставляют возможность применение динамической типизации, к примеру:
C# поддерживает псевдо-тип dynamic.
Haskell — динамическая типизация обеспечивается модулем Data.Dynamic.
Delphi — посредством специального типа Variant.
Кроме того, некие динамически типизированные языки дают возможность использовать преимущества статической типизации:
Common Lisp — декларации типов.
Perl — с версии 5.6, довольно ограниченно.
Итак, идем дальше?
Сильная и слабая типизации
Языки с сильной типизацией не дают сочетать сущности разных типов в выражениях и осуществлять какие-либо автоматические преобразования. Их называют «языки со строгой типизацией», с английского «strong typing».
Слабо типизированные языки, напротив максимально содействуют для того, чтобы программист сочетал различные виды в одном выражении, более того компилятор сам приведет все к единому виду. Их называют «языки с нестрогой типизацией», с английского «weak typing».
Зачастую слабую типизацию могут путать с динамической, что абсолютно неправильно. Динамически типизированный язык может быть и слабо и сильно типизирован.
Впрочем мало, кто обращает внимание на строгость типизации. Неоднократно утверждают о том, что если язык статически типизирован, то Вы можете уловить большое количество потенциальных ошибок при компиляции. Они определённо Вам врут!
Исходя из этого, язык должен иметь сильную типизацию. А если компилятор вместо сообщения об ошибке будет просто прибавлять строку к числу, или что еще хуже, вычтет из одного массива другой, какой нам толк с того, что все «проверки» типов будут на этапе компиляции? Слабая статическая типизация еще хуже, чем сильная динамическая! (Ну, это мое мнение).
Исходя из этого, можно сделать вывод, что у слабой типизации вообще нет плюсов? вероятно так и выглядит, но вопреки тому, что я ярый сторонник сильной типизации, не могу не согласиться, что у слабой тоже есть свои преимущества.
Хотите узнать какие? Тогда продолжим.
Достоинства сильной типизации
Преимущества слабой типизации
Теперь, мы разобрались, что и у слабой типизации тоже есть преимущества! А есть ли методы переместить плюсы слабой типизации в сильную?
Оказывается, есть и даже два.
Неявное приведение типов, в конкретных ситуациях и без потерь данных.
Ух… Довольно длинный пункт. Предлагаю, дальше сокращать его до «ограниченное неявное преобразование». Так что же значит определённая ситуация и потери данных?
Определённая ситуация – это трансформация или операция, в которой сущность сразу понятна. К примеру, сложение двух чисел – определённая ситуация. А изменение числа в массив — нет (может, создастся массив из одного элемента, а возможно число трансформируется в строку, а после в массив символов).
Потеря данных это еще элементарней. Если мы изменим вещественное число 3.5 в целое, мы можем потерять часть данных (по сути, такая операция абсолютно неопределённая – как будет производиться округление? В большую сторону? В меньшую? Отбрасывать дробную часть?).
Трансформация в неопределённых ситуациях и трансформация с потерей данных – это крайне плохо. Ничего хуже этого в программировании нет.
Если вы мне не можете поверить в это то, изучите язык PL/I или просто поищите его спецификацию. В нем есть правила преобразования между ВСЕМИ типами данных!
Предлагаю вспомнить про ограниченное неявное изменение. Есть ли такие языки? Да, к примеру, в Pascal. Вы сможете изменить целое число в вещественное, но не противоположно. Кроме этого подобные механизмы есть в C#, Groovy и Common Lisp.
Я говорил, что есть еще метод получить пару плюсов слабой типизации в сильном языке. Он называется полиморфизм конструкторов.
Я покажу его на примере прекрасного языка Haskell.
Полиморфные конструкторы образовались в итоге наблюдения, что чаще всего безопасные неявные изменения требуются в момент использования числовых литералов.
К примеру, в выражении pi + 1, не хочется писать pi + 1.0 или pi + float(1). Хочется написать просто pi + 1!
И это разработано в Haskell, по причине того, что у литерала 1 нет точного вида. Это ни единое, ни материальное, ни всестороннее. Это же просто число!
Безусловно, такой приём поможет только в момент использования смешанных выражений с числовыми литералами, а это лишь начало.
Исходя из этого, можно сделать вывод о том, что наилучшим исходом будет соблюдение баланса, находясь на грани, между сильной и слабой типизацией. Но на данный момент совершенный баланс не соблюдает ни один язык, поэтому я склоняюсь к сильно типизированным языкам (таким как Haskell, Java, C#, Python), а не к слабо типизированным (таким как C, JavaScript, Lua, PHP).
Ладно, пойдем дальше?
Явная и неявная типизации
Язык с явной типизацией планирует, что программист будет отмечать типы всех переменных и функций, которые заявляет. С английского он означает «explicit typing».
Язык с неявной типизацией действует, наоборот, предлагая Вам не задумываться о типах и перевести подобную функцию на компилятор или интерпретатор. С английского он означает «implicit typing».
Изначально, кажется, что неявная типизация равна динамической, а явная – статической, но в дальнейшем мы поймём, что это неверно.
Хотелось бы знать есть ли плюсы у того и другого вида, а есть ли их комбинации и языки с поддержкой тех и других методов?
Преимущества явной типизации
Существование у той или иной функции сигнатуры (к примеру, int add(int, int)) даёт возможность без проблем выяснить, что осуществляет функция.
Программист в момент делает записи о том, какой тип значения содержится в определённой переменной, для того чтобы не запоминать это.
Преимущества неявной типизации
Уменьшение записи – def add (x, y) определённо короче, чем int add( int x, int y).
Стойкость к переменам. К примеру, если в функции временная переменная была одинакового типа, что и входной аргумент, то в явно типизированном языке при преобразовании типа входного аргумента требуется поменять еще и тип временной переменной.
Отчётливо видно, что оба подхода обладают как плюсами, так и минусами, а теперь предлагаю найти способы комбинирования этих двух подходов!
Явная типизация по выбору
Существуют языки, с неявной типизацией по умолчанию, а также с функцией указания типа значений, когда будет необходимо. Настоящий тип выражения транслятор выведет автоматически. Haskell является таким языком. Для того чтобы было более понятно приведу такой пример:
Как мы можем заметить, это крайне коротко и красиво выглядит. Вся функция занимает всего 18 символов на одной строчке, в том числе и пробелы!
Но автоматический вывод типов достаточно сложная вещь, и даже в таком крутом языке как Haskell, он периодически не справляется. (для наглядности можно показать ограничение мономорфизма)
Есть ли языки с явной типизацией по умолчанию и неявной по необходимости? Конечно.
Неявная типизация по-выбору
В новом нормативе языка C++, названном C++11 (ранее назывался C++0x), было введено ключевое слово auto, с помощью которого есть возможность принудить компилятор вывести тип, исходя из контекста:
Нормально. Однако запись сжалась минимально. Предлагаю рассмотреть пример с итераторами (если не понимаете, не беда, главное обратите внимание, как сократилась запись, благодаря автоматическому выводу):
Ого, вот это сокращение! Хорошо, но есть ли возможность создать что-то подобное в Haskell, где тип возвращаемого значения будет зависеть от типов аргументов?
И в очередной раз я отвечу, да. При помощи ключевого слова decltype в объединении с auto:
Может возникнуть ощущение, что эта форма записи не достаточно хороша, но в комбинации с обобщенным программированием (templates / generics) неявная типизация или автоматический вывод типов творят невообразимое.
Некоторые языки программирования по данной классификации
Я предоставлю вам некоторый перечень популярных языков и распишу их классификацию по каждой группе «типизации».
Примечания к таблице:
C# – сохраняет динамическую типизацию, с помощью особого псевдо-типа dynamic с версии 4.0. А также оказывает содействие неявной типизации посредством dynamic и var.
С++ – после стандарта C++11 обрёл опору неявной типизации посредством ключевых слов auto и decltype. Сохраняет динамическую типизацию, в момент использования библиотеки Boost (boost::any, boost::variant). Содержит в себе черты как сильной, так и слабой типизации.
Common Lisp – стандарт предполагает декларации типов, благодаря которым некие реализации используются также для статической проверки типов.
D – также осуществляет поддержание неявной типизации.
Delphi – осуществляет поддержку динамической типизации, с помощью особого типа Variant.
Есть вероятность, что я где-то мог ошибиться, в особенности с CL, PHP и Obj-C, если по какому-либо языку у Вас есть другое мнение – пишите в комментариях.
Заключение
Совсем скоро будет светать и мне кажется, что про типизацию я больше ничего не скажу. Ой, как? Эта же тема бездонная? Много чего недосказано? Предлагаю всю полезную информацию по этой теме высказать в комментариях.
Ликбез по типизации в языках программирования
Эта статья содержит необходимый минимум тех вещей, которые просто необходимо знать о типизации, чтобы не называть динамическую типизацию злом, Lisp — бестиповым языком, а C — языком со строгой типизацией.
В полной версии находится подробное описание всех видов типизации, приправленное примерами кода, ссылками на популярные языки программирования и показательными картинками.
Рекомендую прочитать сначала краткую версию статьи, а затем при наличии желания и полную.
Краткая версия
Языки программирования по типизации принято делить на два больших лагеря — типизированные и нетипизированные (бестиповые). К первому например относятся C, Python, Scala, PHP и Lua, а ко второму — язык ассемблера, Forth и Brainfuck.
Так как «бестиповая типизация» по своей сути — проста как пробка, дальше она ни на какие другие виды не делится. А вот типизированные языки разделяются еще на несколько пересекающихся категорий:
Примеры:
Статическая: C, Java, C#;
Динамическая: Python, JavaScript, Ruby.
Примеры:
Сильная: Java, Python, Haskell, Lisp;
Слабая: C, JavaScript, Visual Basic, PHP.
Примеры:
Явная: C++, D, C#
Неявная: PHP, Lua, JavaScript
Также нужно заметить, что все эти категории пересекаются, например язык C имеет статическую слабую явную типизацию, а язык Python — динамическую сильную неявную.
Тем-не менее не бывает языков со статической и динамической типизаций одновременно. Хотя забегая вперед скажу, что тут я вру — они действительно существуют, но об этом позже.
Подробная версия
Если краткой версии Вам показалось недостаточно, хорошо. Не зря же я писал подробную? Главное, что в краткой версии просто невозможно было уместить всю полезную и интересную информацию, а подробная будет возможно слишком длинной, чтобы каждый смог ее прочесть, не напрягаясь.
Бестиповая типизация
В бестиповых языках программирования — все сущности считаются просто последовательностями бит, различной длины.
Бестиповая типизация обычно присуща низкоуровневым (язык ассемблера, Forth) и эзотерическим (Brainfuck, HQ9, Piet) языкам. Однако и у нее, наряду с недостатками, есть некоторые преимущества.
Преимущества
Недостатки
Сильная безтиповая типизация?
Да, такое существует. Например в языке ассемблера (для архитектуры х86/х86-64, других не знаю) нельзя ассемблировать программу, если вы попытаетесь загрузить в регистр cx (16 бит) данные из регистра rax (64 бита).
mov cx, eax ; ошибка времени ассемблирования
Так получается, что в ассемлере все-таки есть типизация? Я считаю, что этих проверок недостаточно. А Ваше мнение, конечно, зависит только от Вас.
Статическая и динамическая типизации
Главное, что отличает статическую (static) типизацию от динамической (dynamic) то, что все проверки типов выполняются на этапе компиляции, а не этапе выполнения.
Некоторым людям может показаться, что статическая типизация слишком ограничена (на самом деле так и есть, но от этого давно избавились с помощью некоторых методик). Некоторым же, что динамически типизированные языки — это игра с огнем, но какие же черты их выделяют? Неужели оба вида имеют шансы на существование? Если нет, то почему много как статически, так и динамически типизированных языков?
Преимущества статической типизации
Преимущества динамической типизации
Обобщенное программирование
Хорошо, самый важный аргумент за динамическую типизацию — удобство описания обобщенных алгоритмов. Давайте представим себе проблему — нам нужна функция поиска по нескольким массивам (или спискам) — по массиву целых чисел, по массиву вещественных и массиву символов.
Как же мы будем ее решать? Решим ее на 3-ех разных языках: одном с динамической типизацией и двух со статической.
Алгоритм поиска я возьму один из простейших — перебор. Функция будет получать искомый элемент, сам массив (или список) и возвращать индекс элемента, или, если элемент не найден — (-1).
Динамическое решение (Python):
Как видите, все просто и никаких проблем с тем, что список может содержать хоть числа, хоть списки, хоть другие массивы нет. Очень хорошо. Давайте пойдем дальше — решим эту-же задачу на Си!
Статическое решение (Си):
Ну, каждая функция в отдельности похожа на версию из Python, но почему их три? Неужели статическое программирование проиграло?
И да, и нет. Есть несколько методик программирования, одну из которых мы сейчас рассмотрим. Она называется обобщенное программирование и язык C++ ее неплохо поддерживает. Давайте посмотрим на новую версию:
Статическое решение (обобщенное программирование, C++):
Хорошо! Это выглядит не сильно сложнее чем версия на Python и при этом не пришлось много писать. Вдобавок мы получили реализацию для всех массивов, а не только для 3-ех, необходимых для решения задачи!
Эта версия похоже именно то, что нужно — мы получаем одновременно плюсы статической типизации и некоторые плюсы динамической.
Здорово, что это вообще возможно, но может быть еще лучше. Во-первых обобщенное программирование может быть удобнее и красивее (например в языке Haskell). Во-вторых помимо обобщенного программирования также можно применить полиморфизм (результат будет хуже), перегрузку функций (аналогично) или макросы.
Статика в динамике
Также нужно упомянуть, что многие статические языки позволяют использовать динамическую типизацию, например:
Сильная и слабая типизации
Языки с сильной типизацией не позволяют смешивать сущности разных типов в выражениях и не выполняют никаких автоматических преобразований. Также их называют «языки с строгой типизацией». Английский термин для этого — strong typing.
Слабо типизированные языки, наоборот всячески способствуют, чтобы программист смешивал разные типы в одном выражении, причем компилятор сам приведет все к единому типу. Также их называют «языки с нестрогой типизацией». Английский термин для этого — weak typing.
Слабую типизацию часто путают с динамической, что совершенно неверно. Динамически типизированный язык может быть и слабо и сильно типизирован.
Однако мало, кто придает значение строгости типизации. Часто заявляют, что если язык статически типизирован, то Вы сможете отловить множество потенциальных ошибок при компиляции. Они Вам врут!
Язык при этом должен иметь еще и сильную типизацию. И правда, если компилятор вместо сообщения об ошибке будет просто прибавлять строку к числу, или что еще хуже, вычтет из одного массива другой, какой нам толк, что все «проверки» типов будут на этапе компиляции? Правильно — слабая статическая типизация еще хуже, чем сильная динамическая! (Ну, это мое мнение)
Так что-же у слабой типизации вообще нет плюсов? Возможно так выглядит, однако несмотря на то, что я ярый сторонник сильной типизации, должен согласиться, что у слабой тоже есть преимущества.
Хотите узнать какие?
Преимущества сильной типизации
Преимущества слабой типизации
Оказывается есть и даже два.
Неявное приведение типов, в однозначных ситуациях и без потерь данных
Ух… Довольно длинный пункт. Давайте я буду дальше сокращать его до «ограниченное неявное преобразование» Так что же значит однозначная ситуация и потери данных?
Однозначная ситуация, это преобразование или операция в которой сущность сразу понятна. Вот например сложение двух чисел — однозначная ситуация. А преобразование числа в массив — нет (возможно создастся массив из одного элемента, возможно массив, с такой длинной, заполненный элементами по-умолчанию, а возможно число преобразуется в строку, а затем в массив символов).
Потеря данных это еще проще. Если мы преобразуем вещественное число 3.5 в целое — мы потеряем часть данных (на самом деле эта операция еще и неоднозначная — как будет производиться округление? В большую сторону? В меньшую? Отбрасывание дробной части?).
Преобразования в неоднозначных ситуациях и преобразования с потерей данных — это очень, очень плохо. Ничего хуже этого в программировании нет.
Если вы мне не верите, изучите язык PL/I или даже просто поищите его спецификацию. В нем есть правила преобразования между ВСЕМИ типами данных! Это просто ад!
Ладно, давайте вспомним про ограниченное неявное преобразование. Есть ли такие языки? Да, например в Pascal Вы можете преобразовать целое число в вещественное, но не наоборот. Также похожие механизмы есть в C#, Groovy и Common Lisp.
Ладно, я говорил, что есть еще способ получить пару плюсов слабой типизации в сильном языке. И да, он есть и называется полиморфизм конструкторов.
Я поясню его на примере замечательного языка Haskell.
Полиморфные конструкторы появились в результате наблюдения, что чаще всего безопасные неявные преобразования нужны при использовании числовых литералов.
И это сделано в Haskell, благодаря тому, что у литерала 1 нет конкретного типа. Это ни целое, ни вещественное, ни комплексное. Это же просто число!
Конечно спасает этот прием только при использовании смешанных выражений с числовыми литералами, а это лишь верхушка айсберга.
Таким образом можно сказать, что лучшим выходом будет балансирование на грани, между сильной и слабой типизацией. Но пока идеальный баланс не держит ни один язык, поэтому я больше склоняюсь к сильно типизированным языкам (таким как Haskell, Java, C#, Python), а не к слабо типизированным (таким как C, JavaScript, Lua, PHP).
Ладно, пойдем дальше?
Явная и неявная типизации
Язык с явной типизацией предполагает, что программист должен указывать типы всех переменных и функций, которые объявляет. Английский термин для этого — explicit typing.
Язык с неявной типизацией, напротив, предлагает Вам забыть о типах и переложить задачу вывода типов на компилятор или интерпретатор. Английски термин для этого — implicit typing.
По-началу можно решить, что неявная типизация равносильна динамической, а явная — статической, но дальше мы увидим, что это не так.
Есть ли плюсы у каждого вида, и опять же, есть ли их комбинации и есть ли языки с поддержкой обоих методов?
Преимущества явной типизации
Преимущества неявной типизации
Явная типизация по-выбору
Есть языки, с неявной типизацией по-умолчанию и возможностью указать тип значений при необходимости. Настоящий тип выражения транслятор выведет автоматически. Один из таких языков — Haskell, давайте я приведу простой пример, для наглядности:
* Спасибо int_index за нахождение ошибки.
Хм. Как мы видим, это очень красиво и коротко. Запись функции занимает всего 18 символов на одной строчке, включая пробелы!
Однако автоматический вывод типов довольно сложная вещь, и даже в таком крутом языке как Haskell, он иногда не справляется. (как пример можно привести ограничение мономорфизма)
Есть ли языки с явной типизацией по-умолчанию и неявной по-необходимости? Кон
ечно.
Неявная типизация по-выбору
В новом стандарте языка C++, названном C++11 (ранее назывался C++0x), было введено ключевое слово auto, благодаря которому можно заставить компилятор вывести тип, исходя из контекста:
Неплохо. Но запись сократилась не сильно. Давайте посмотрим пример с итераторами (если не понимаете, не бойтесь, главное заметьте, что запись благодаря автоматическому выводу очень сильно сокращается):
Ух ты! Вот это сокращение. Ладно, но можно ли сделать что-нибудь в духе Haskell, где тип возвращаемого значения будет зависеть от типов аргументов?
И опять ответ да, благодаря ключевому слову decltype в комбинации с auto:
Может показаться, что эта форма записи не сильно хороша, но в комбинации с обобщенным программированием (templates / generics) неявная типизация или автоматический вывод типов творят чудеса.
Некоторые языки программирования по данной классификации
Я приведу небольшой список из популярных языков и напишу как они подразделяются по каждой категории “типизаций”.
Возможно я где-то ошибся, особенно с CL, PHP и Obj-C, если по какому-то языку у Вас другое мнение — напишите в комментариях.
Заключение
Окей. Уже скоро будет светло и я чувствую, что про типизацию больше нечего сказать. Ой как? Тема бездонная? Очень много осталось недосказано? Прошу в комментарии, поделитесь полезной информацией.