В чем разница между статически типизированными и динамически типизированными языками?

948

Я часто слышу, что новые языки программирования динамически типизированы, но что это на самом деле означает, когда мы говорим, что язык динамически типизирован или статически типизирован?

Рейчел
источник
25
Хороший вопрос, но ваш принятый ответ не является правильным.
Джон Харроп
42
Можете ли вы ссылаться на то, что является правильным тогда?
Сагируддин Мондал
@EricLeschinski Я думаю, что модульные тесты помогают справиться с этой проблемой, и языки с динамической типизацией, такие как JavaScript, можно кодировать с уверенностью в том, что они сохранятся, что делает их пригодными для разработки корпоративного программного обеспечения, не правда ли?
пиксель 67
8
В лучшем случае эти модульные тесты со временем ухудшаются и отключаются коллегами, пытающимися повысить безопасность работы, в худшем - они никогда не пишутся в первую очередь. Это все равно, что предложить профессиональному механику использовать клейкую ленту на автомобилях своего клиента. Да, младший, использование клейкой ленты на этой передаче - хорошая идея ... для вас.
Эрик Лещинский
2
Я знаю, что этому вопросу 10 лет, но из того, что я прочитал в комментариях, вы, вероятно, должны перейти к ответу «Кристофер Токар».
1.0

Ответы:

854

Статически типизированные языки

Язык статически типизирован, если тип переменной известен во время компиляции. Для некоторых языков это означает, что вы как программист должны указать тип каждой переменной (например, Java, C, C ++); другие языки предлагают некоторую форму вывода типов , способность системы типов определять тип переменной (например, OCaml, Haskell, Scala, Kotlin)

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

Примеры: C, C ++, Java, Rust, Go, Scala

Динамически типизированные языки

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

Примеры: Perl, Ruby, Python, PHP, JavaScript

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

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

Без мужчин
источник
6
@NomeN Можете ли вы назвать любой динамически типизированный язык, который реализует вывод типа HM?
Пит Киркхем
88
«Язык динамически типизируется, если тип переменной интерпретируется во время выполнения»: Нет. Язык динамически типизируется, если тип связан со значениями времени выполнения, а не с именованными переменными / полями / и т. Д.
Пол Биггар
15
Неправильная статическая типизация означает, что «ссылочное значение явно (не то же самое, что во время компиляции) ограничено относительно типа значения, которое оно может обозначать, и что языковая реализация, будь то компилятор или интерпретатор как усиливает, так и максимально использует эти ограничения ». цитируется с: c2.com/cgi/wiki?StaticTyping, который, насколько я понимаю, является правильным.
Матиас Вольф
6
Наиболее очевидная вещь в системах типов Java, C, C ++, Pascal и многих других широко используемых «промышленных» языков заключается не в том, что они статически типизированы, а в том, что они явно типизированы. Другими словами, они требуют много объявления типа. (В мире менее явно типизированных языков, где эти объявления являются необязательными, их часто называют «аннотациями типов».) Это не имеет ничего общего со статическими типами. продолжение ..
Випреш
7
Первые статически типизированные языки были явно типизированы по необходимости. Тем не менее, алгоритмы вывода типов - методы просмотра исходного кода без каких-либо объявлений типов и определения того, какие типы его переменных существуют, существуют уже много лет. Язык ML, который его использует. Хаскелу, который улучшил его, сейчас около 15 лет. Даже C # в настоящее время принимает эту идею, которая вызовет много удивлений и, несомненно, приведет к утверждению о том, что она «слабо напечатана». продолжение ...
Vipresh
399

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

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

Примеры статически типизированных языков: - Java, C, C ++

Примеры динамически типизированных языков: - Perl, Ruby, Python, PHP, JavaScript

Кристофер Токарь
источник
19
Я думаю, что это лучший ответ. В частности, принятый ответ в значительной степени фактически неверен.
Джон Харроп
1
@JonHarrop В чем конкретно?
1252748
21
@thomas: «Это означает, что вы, как программист, можете писать немного быстрее, потому что вам не нужно каждый раз указывать тип». Вам не нужно указывать тип каждый раз при статической типизации, если у вас есть вывод типа. Смотрите SML, OCaml, F #, Haskell ...
Джон Харроп
1
В статически типизированных прог-языках проверка типов выполняется до выполнения, но не совсем во время компиляции.
Луис Фелипе
307

Вот пример, показывающий, как Python (динамически типизированный) и Go (статически типизированный) обрабатывают ошибку типа:

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

Python выполняет проверку типов во время выполнения, и поэтому:

silly(2)

Работает отлично и выдает ожидаемый результат Hi. Ошибка возникает только в случае попадания в проблемную строку:

silly(-1)

Производит

TypeError: unsupported operand type(s) for +: 'int' and 'str'

потому что соответствующая строка была фактически выполнена.

Go с другой стороны выполняет проверку типов во время компиляции:

package main

import ("fmt"
)

func silly(a int) {
    if (a > 0) {
        fmt.Println("Hi")
    } else {
        fmt.Println("3" + 5)
    }
}

func main() {
    silly(2)
}

Выше не скомпилируется, со следующей ошибкой:

invalid operation: "3" + 5 (mismatched types string and int)
Akavall
источник
5
Спасибо за аккуратный пример. Итак, я делаю вывод, что все языки сценариев типизированы динамически, так как они не компилируются?
15:00
8
да. все скриптовые языки динамически типизированы, потому что они не являются компилятором для статической проверки типов в любом случае. Этот момент был проиллюстрирован в этой статье sitepoint.com/typing-versus-dynamic-typing .
Шаши
9
Scala может использоваться как язык сценариев, и он статически типизирован! #discussion @Shashi
Сагируддин Мондал
3
@Shashi Компиляция не означает статически типизированный. runhaskellНапример, Haskell можно интерпретировать как
BalinKingOfMoria восстанавливает СМ
2
Также язык сценариев НЕ означает интерпретируемый язык. TypeScript является статически типизированным, скомпилированным / переданным, но скриптовым языком.
Металим
161

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

Например в Java:

String str = "Hello";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

Где, с другой стороны: в динамически типизированном языке типы переменных являются динамическими , то есть после того, как вы установите переменную в тип, вы МОЖЕТЕ изменить ее. Это связано с тем, что типизация связана со значением, которое она принимает, а не с самой переменной.

Например в Python:

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

Таким образом, лучше всего рассматривать переменные в динамически типизированных языках как просто общие указатели на типизированные значения.

Подводя итог, тип описывает (или должен был описать) переменные в языке, а не сам язык. Он мог бы быть лучше использован в качестве языка со статически типизированными переменными по сравнению с языком с динамически типизированными переменными IMHO.

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

Динамически типизированные языки обычно интерпретируются, поэтому проверка типов (если есть) происходит во время выполнения, когда они используются. Это, конечно, приводит к некоторому снижению производительности и является одной из причин, по которой динамические языки (например, python, ruby, php) не так хорошо масштабируются, как типизированные (java, c # и т. Д.). С другой стороны, статически типизированные языки имеют большую начальную стоимость: обычно вы пишете больше кода, а код сложнее. Но это окупается позже.

Хорошо, что обе стороны заимствуют черты у другой стороны. Типизированные языки включают в себя больше динамических функций, например, универсальные и динамические библиотеки в c #, а динамические языки включают в себя больше проверки типов, например, аннотации типов в python или вариант HACK PHP, которые обычно не являются ядром языка и могут использоваться на требование.

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

Мехмет
источник
8
Это имеет большой смысл. Я думаю, что это объясняет, по крайней мере, причины этих имен гораздо лучше, чем другие ответы здесь.
JamEngulfer
Согласно этой ссылке Python является как статически типизированным, так и динамически типизированным языком: wiki.python.org/moin/… Кто-нибудь знает почему?
модуль
1
Лукас, Напротив, документ продолжает повторять, что Python строго и динамически типизирован. Где ты это видел? Можете ли вы цитировать?
Мехмет
2
Я думаю, что этот ответ лучше всего передает концепцию самым простым способом. Многие другие ответы пытаются абстрактно описать концепцию, но не дают некоторых деталей. Я бы предпочел увидеть этот ответ в верхней части списка.
Ястребиный глаз
5
Большинство других ответов создали больше вопросов в моей голове. Этот очистил их всех. Этот ответ действительно должен быть наверху ИМХО
Хами Торунь,
39

http://en.wikipedia.org/wiki/Type_system

Статическая печать

Говорят, что язык программирования использует статическую типизацию, когда проверка типов выполняется во время компиляции, а не во время выполнения. В статической типизации типы связаны с переменными, а не со значениями. Статически типизированные языки включают в себя Ada, C, C ++, C #, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (в отношении различения скаляров, массивов, хэшей и подпрограмм) и Scala. Статическая типизация является ограниченной формой верификации программы (см. Безопасность типов): соответственно, она позволяет обнаруживать многие ошибки типов на ранних этапах цикла разработки. Средство проверки статического типа оценивает только информацию о типе, которая может быть определена во время компиляции, но может проверить, что проверенные условия выполняются для всех возможных исполнений программы, что устраняет необходимость повторять проверки типов при каждом запуске программы. Выполнение программы также можно сделать более эффективным (т. Е. Быстрее или с меньшим объемом памяти), исключив проверки типов во время выполнения и включив другие оптимизации.

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

if <complex test> then 42 else <type error>

будет отклонен как неправильно напечатанный, потому что статический анализ не может определить, что ветвь else не будет взята. [1] Консервативное поведение статических контроллеров типов выгодно, если нередко оценивается как ложное: статический контролер типов может обнаруживать ошибки типов в редко используемых путях кода. Без статической проверки типов даже тесты покрытия кода со 100% покрытием кода могут не обнаружить такие ошибки типа. Тесты покрытия кода могут не обнаружить такие ошибки типа, поскольку необходимо учитывать комбинацию всех мест, где создаются значения, и всех мест, где используется определенное значение.

Наиболее широко используемые статически типизированные языки не являются формально безопасными. Они имеют «лазейки» в спецификации языка программирования, позволяющие программистам писать код, который обходит проверку, выполняемую статической проверкой типов, и таким образом решает более широкий круг проблем. Например, Java и большинство языков в стиле C имеют типизацию типов, а Haskell имеет такие функции, как unsafePerformIO: такие операции могут быть небезопасными во время выполнения, поскольку они могут вызывать нежелательное поведение из-за неправильного ввода значений во время выполнения программы.

Динамическая печать

Язык программирования называется динамически типизированным или просто «динамическим», когда большая часть его проверки типов выполняется во время выполнения, а не во время компиляции. В динамической типизации типы связаны со значениями, а не переменными. Динамически типизированные языки включают Groovy, JavaScript, Lisp, Lua, Objective-C, Perl (относительно пользовательских типов, но не встроенных типов), PHP, Prolog, Python, Ruby, Smalltalk и Tcl. По сравнению со статической типизацией динамическая типизация может быть более гибкой (например, позволяя программам генерировать типы и функциональные возможности на основе данных времени выполнения), хотя за счет меньшего количества априорных гарантий. Это связано с тем, что динамически типизированный язык принимает и пытается выполнить некоторые программы, которые могут быть признаны недействительными с помощью средства проверки статического типа.

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

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

Разработка на динамически типизированных языках часто поддерживается практиками программирования, такими как модульное тестирование. Тестирование является ключевой практикой в ​​профессиональной разработке программного обеспечения и особенно важно для языков с динамической типизацией. На практике тестирование, выполненное для обеспечения правильной работы программы, может обнаружить гораздо более широкий диапазон ошибок, чем статическая проверка типов, но, наоборот, не может выполнить поиск всесторонне ошибок, которые могут обнаружить как тестирование, так и статическая проверка типов. Тестирование может быть включено в цикл сборки программного обеспечения, и в этом случае его можно рассматривать как проверку «времени компиляции», при которой пользователю программы не нужно будет запускать такие тесты вручную.

Ссылки

  1. Пирс, Бенджамин (2002). Типы и языки программирования. MIT Press. ISBN 0-262-16209-1.
Иаков
источник
75
Основная идея СО заключается в создании совокупности знаний, а не в предоставлении ссылок на другие места. Вы должны попытаться хотя бы сделать выдержку из вики, которая отвечает на вопрос.
Номер
5
Это просто показалось излишним, поскольку это ссылка на Википедию, а не какой-то временный сайт, но я запомню это в следующий раз.
Джейкоб
2
почему-то я до сих пор не могу вспомнить пример на динамически типизированном языке, где тип неясен во время компиляции, но должен быть определен во время выполнения. Не могли бы вы предоставить мне немного?
Novellizator
3
@Novellizator Старый комментарий, но представьте себе сценарий, в котором некоторые данные извлекаются с удаленного сервера, а затем эти данные используются для выбора свойства объекта. Пример: myObject[remoteDataName]. Тогда нет никакого способа узнать, какое свойство он выберет, или даже если это вообще допустимое свойство.
Майк Клак
14

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

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

Тем не менее, мы были для усиления нетипизированной лямбды - исчисления с примитивными числами и арифметическими операциями, то мы могли бы выполнить бессмысленные операции, например , добавив два члена лямбды вместе: (λx.x) + (λy.y). Можно утверждать, что единственная разумная вещь, которую нужно сделать - это сообщить об ошибке, когда это происходит, но чтобы это можно было сделать, каждое значение должно быть помечено индикатором, который указывает, является ли термин лямбда-термином или числом. Затем оператор сложения проверит, что оба аргумента действительно помечены как числа, и, если это не так, сигнализирует об ошибке. Обратите внимание, что эти теги не являются типами, потому что типы - это свойства программ, а не значений, создаваемых этими программами.

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

Такие языки, как JavaScript, Python и Ruby, являются однотипными. Опять же, typeofоператор в JavaScript и typeфункция в Python имеют вводящие в заблуждение имена; они возвращают теги, связанные с операндами, а не их типы. Точно так же dynamic_castв C ++ и instanceofв Java не делайте проверки типов.

rightfold
источник
7

Скомпилировано и интерпретировано

«Когда исходный код переведен»

  • Исходный код : оригинальный код (обычно вводимый человеком в компьютер)
  • Перевод : Преобразование исходного кода во что-то, что компьютер может прочитать (например, машинный код)
  • Время выполнения : период, когда программа выполняет команды (после компиляции, если скомпилирована)
  • Скомпилированный язык : код переведен до выполнения
  • Язык интерпретации : код, переведенный на лету, во время исполнения

Typing

«Когда типы проверяются»

5 + '3'является примером ошибки типа в строго типизированных языках, таких как Go и Python, потому что они не допускают «приведение типов» -> возможность значения менять тип в определенных контекстах, таких как объединение двух типов. Языки со слабой типизацией , такие как JavaScript, не будут вызывать ошибку типа (приводит к '53').

  • Статический : типы проверены перед выполнением
  • Динамический : типы проверяются на лету, во время выполнения

Определения «Static & Compiled» и «Dynamic & Interpreted» очень похожи ... но помните, что это «когда проверяются типы» и «когда переводится исходный код».

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


Пример Python

Динамический, Интерпретированный

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

silly(2)

Поскольку Python интерпретируется и динамически типизируется, он только переводит и проверяет код, на котором он выполняется. elseБлок никогда не выполняется, поэтому 5 + '3'никогда даже не смотрел на!

Что, если он был статически напечатан?

Ошибка типа будет выдана еще до запуска кода. Он по-прежнему выполняет проверку типов перед выполнением, даже если он интерпретируется.

Что если он был скомпилирован?

elseБлок будет переведен / посмотрел на перед во время выполнения, а потому , что это динамически типизированных он не выдаст ошибку! Динамически типизированные языки не проверяют типы до выполнения, и эта строка никогда не выполняется.


Go Example

Статический, скомпилированный

package main

import ("fmt"
)

func silly(a int) {
  if (a > 0) {
      fmt.Println("Hi")
  } else {
      fmt.Println("3" + 5)
  }
}

func main() {
  silly(2)
}

Типы проверяются перед запуском (статические), и ошибка типа немедленно обнаруживается! Типы будут по-прежнему проверяться перед выполнением, если это будет интерпретировано, с тем же результатом. Если бы он был динамическим, он не выдавал бы никаких ошибок, даже если код был бы просмотрен во время компиляции.


Представление

Скомпилированный язык будет иметь лучшую производительность во время выполнения, если он статически типизирован (по сравнению с динамическим); знание типов позволяет оптимизировать машинный код.

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

Точно так же скомпилированные языки быстрее во время выполнения, поскольку код уже был переведен, вместо того, чтобы нуждаться в «интерпретации» / переводе на лету.

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


Больше различий

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

num = 2
num = '3' // ERROR

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

JBallin
источник
« Поскольку Python интерпретируется и динамически типизируется, он только транслирует и проверяет код, который выполняет », - на самом деле это не так. Python (по крайней мере, эталонная реализация) компилирует весь ваш код во время импорта (вы также можете компилировать модули до / без их импорта). Компилятор вводит различные оптимизации (по крайней мере, насколько позволяет динамическая природа Python).
Эли Корвиго
6

Статически типизированные языки : каждая переменная и выражение уже известны во время компиляции.

(во int a;время выполнения может принимать только целочисленные значения)

Примеры: C, C ++, Java

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

( var a;может принимать любые значения во время выполнения)

Примеры: Ruby, Python.

Раман Гупта
источник
5

Статически типизированные языки проверяют тип во время компиляции, и тип НЕ может измениться. (Не будьте милыми с комментариями приведения типов, создается новая переменная / ссылка).

Динамически типизированные языки проверяют тип во время выполнения и тип переменной МОЖЕТ быть изменен во время выполнения.

RESTfulGeoffrey
источник
4

Простые и понятные определения, но соответствующие потребности: языки со статической типизацией связывают тип с переменной для всей своей области (Seg: SCALA) Языки с динамической типизацией связывают тип с фактическим значением, на которое ссылается переменная.

user3627021
источник
3
  • В статически типизированном языке переменная связана с типом, который известен во время компиляции, и этот тип остается неизменным на протяжении всего выполнения программы. Эквивалентно, переменной может быть присвоено только значение, которое является экземпляром известного / указанного типа.
  • В динамически типизированном языке переменная не имеет типа, и ее значение во время выполнения может быть любым из любой формы и формы.
Chudong
источник
2

Языки со статической типизацией, такие как C ++, Java, и языки с динамической типизацией, такие как Python, отличаются только с точки зрения исполнения типа переменной. Статически типизированные языки имеют статический тип данных для переменной, здесь тип данных проверяется во время компиляции, поэтому отладка намного проще ... тогда как динамически типизированные языки не делают того же, проверяется тип данных, который выполняет программу и, следовательно, отладка немного сложна.

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

Акаш Шарма
источник
2

Статически Типизированный

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

Примеры = с ++

Динамически Типизированный

Типы проверяются во время выполнения.

Примеры = Питон

Аттик Деньюмонт
источник
2
Это действительно не добавляет ничего, что еще не охвачено другими ответами, не так ли?
Роберт
1
Да, но большинство ответов были не очень ясными, поэтому я хотел получить ответ, который легко понять.
Аттикус Деньюмонт
1

Языки со статической типизацией (компилятор разрешает вызовы методов и компилирует ссылки):

  • обычно лучшая производительность
  • более быстрая обратная связь при ошибках компиляции
  • лучшая поддержка IDE
  • не подходит для работы с неопределенными форматами данных
  • труднее начать разработку, когда модель не определена, когда
  • более длительное время компиляции
  • во многих случаях требуется написать больше кода

Динамически типизированные языки (решения, принимаемые в запущенной программе):

  • низкая производительность
  • более быстрое развитие
  • некоторые ошибки могут быть обнаружены только позже во время выполнения
  • подходит для неопределенных форматов данных (метапрограммирование)
MagGGG
источник
0

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

Паван Канаджар
источник
-15

Статическая типизация: языки, такие как Java и Scala, имеют статическую типизацию.

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

например int x; х = 10;

System.out.println (х);

Динамическая типизация: Perl - язык динамической типизации.

Переменные не нужно инициализировать перед использованием в коде.

у = 10; используйте эту переменную в более поздней части кода

Prakhyat
источник
2
Ну, этот ответ не совсем правильный. В обоих языках переменные должны быть инициализированы перед использованием. Однако в динамически типизированных языках вы можете не указывать тип, в котором он используется.
даршан
Похоже, вы неправильно используете термин «переменные», вместо этого вы должны были сказать «типы».
Эмир
Я бы сказал, что Perl статически типизирован: у него есть 3 типа: scalar ( $), array ( @) и hash ( %). Тип переменной в Perl известен во время компиляции и остается неизменным до конца жизни переменных.
CoffeeTableEspresso