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

StackOverflow https://stackoverflow.com/questions/2690544

Вопрос

Кроме того, это подразумевает другой?

Это было полезно?

Решение

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

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

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

Статические против динамики

Противоположность статически набранного «динамически набирается», что означает, что

  1. Значения, используемые во время выполнения, классифицируются на типы.
  2. Существуют ограничения о том, как могут быть использованы такие значения.
  3. Когда эти ограничения нарушены, нарушение сообщается как (динамическая) ошибка типа.

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

Сильные против слабые

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

Что на самом деле происходит здесь?

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

  • Любители часто связывают их «статическими» и «динамичными».

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

  • Профессионалы не могут согласиться точно, что означает условия.

  • В целом вы вряд ли сообщите или просветите свою аудиторию.

Грустная правда в том, что когда дело доходит до систем типа, «Сильные» и «слабые» не имеют универсально согласованного по техническому значению. Если вы хотите обсудить относительную силу типа систем, лучше обсуждать, какие гарантии есть и не предусмотрены. Например, хороший вопрос, заданный это: «- это каждое значение данного типа (или класса), гарантированного, позвонив в соответствии с одним из конструкторов этого типа?» В C ответ нет. В CLU, F #, и Haskell это да. Для C ++ я не уверен - я хотел бы знать.

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

Один из них подразумевает другой?

На педантическом уровне нет, потому что слово «сильный» на самом деле ничего не значит. Но на практике люди почти всегда делают одну из двух вещей:

  • Они (неправильно) используют «сильные» и «слабые», чтобы означать «статические» и «динамичные», в этом случае они (неправильно) используют «сильно набранные» и «статически набранные» взаимозаменяемо.

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

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

Другие советы

Это часто неправильно понято, так что позвольте мне очистить его.

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

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

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

Так что в Java например:

String s = "abcd";

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

В 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 принуждено к логическому false И, таким образом, условие на самом деле верно. Решение должно использовать === вместо == чтобы избежать неявного преобразования.

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

Сравните это, чтобы Ruby:

val = "abc" + 123

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

val = "abc" + 123.to_s

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

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

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

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

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

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

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

  • сильно набрали против слабо напечатаны
  • Статически набран против динамически набран

Сильно набрал Средство, а не будет автоматически преобразуется из одного типа на другой. Слабо напечатано напротив: Perl может использовать строку, как "123" в числовом контексте, автоматически преобразуя его в INT 123. Отказ Настоятельно напечатанный язык, такой как Python, не сделает этого.

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

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

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

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

String s = "abc" + 123;

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

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

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

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

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

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

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

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

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

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

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

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

Ответ уже приведен выше. Попытка дифференцироваться между сильной VS-неделей и статической VS динамической концепцией.

Что сильно напечатано против слабо напечатано?

Сильно набирается: не будет автоматически преобразован из одного типа на другой

В GO или Python, как сильно напечатанные языки «2» + 8 будут поднять ошибку типа, потому что они не позволяют «принуждение к типу».

Слабо (свободно) набран: будет автоматически преобразован в один тип на другой:Слабо напечатанные языки, такие как JavaScript или Perl, не будут бросать ошибку, и в этом случае JavaScript будут результаты «28», а Perl приведет к 10.

Пример Perl:

my $a = "2" + 8;
print $a,"\n";

Сохраните его на main.pl и запустить perl main.pl И вы получите выход 10.

Что такое статический VS Dyamic тип?

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

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

Что это значит?

В GO I он проверяет набравшееся до времени выполнения (статическая проверка). Это означает, что это не только переводит не только код, и код проверки, который он выполняется, но он сканирует через все ошибки кода и в типе будут брошены до проведения кода. Например,

package main

import "fmt"

func foo(a int) {
    if (a > 0) {
        fmt.Println("I am feeling lucky (maybe).")
    } else {
        fmt.Println("2" + 8)
    }
}

func main() {
    foo(2)
}

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

go run main.go
# command-line-arguments
./main.go:9:25: cannot convert "2" (type untyped string) to type int
./main.go:9:25: invalid operation: "2" + 8 (mismatched types string and int)

Но этот случай недействителен для Python. Например, следующий блок кода будет выполнен для первого вызова FOO (2) и не удастся для второго вызова FOO (0). Это потому, что Python динамически набирается, он только переводится и код проверки типа его выполнения. Самый остальный блок никогда не выполняет для FOO (2), поэтому «2» + 8 никогда не смотрит на звонок, а для FOO (0) это попытается выполнить этот блок и не удалось.

def foo(a):
    if a > 0:
        print 'I am feeling lucky.'
    else:
        print "2" + 8
foo(2)
foo(0)

Вы увидите следующий вывод

python main.py
I am feeling lucky.
Traceback (most recent call last):
  File "pyth.py", line 7, in <module>
    foo(0)
  File "pyth.py", line 5, in foo
    print "2" + 8
TypeError: cannot concatenate 'str' and 'int' objects
Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top