정적 유형 언어와 동적 유형 언어의 차이점은 무엇입니까?

https://stackoverflow.com/questions/1517582

19-09-2019
|

문제

새로운 프로그래밍 언어가 동적으로 유형이 지정된다는 말을 많이 듣습니다. 그러나 언어가 동적으로 유형이 지정된다는 것이 실제로 무엇을 의미합니까?정적으로 입력되었나요?

해결책

정적으로 입력 한 언어

변수 유형이 컴파일 시간에 알려진 경우 언어가 정적으로 입력됩니다. 일부 언어의 경우 이것은 프로그래머로서 귀하가 각 변수가 어떤 유형인지 지정해야 함을 의미합니다 (예 : Java, C, C ++); 다른 언어는 어떤 형태의 형태를 제공합니다 입력 유추, 변수의 유형을 추론하는 유형 시스템의 기능 (예 : Ocaml, Haskell, Scala, Kotlin)

여기서 주요 장점은 모든 종류의 점검을 컴파일러에 의해 수행 할 수 있으므로 매우 초기 단계에서 많은 사소한 버그가 잡히는 것입니다.

예 : C, C ++, Java, Rust, Go, Scala

동적으로 입력 한 언어

유형이 런타임 값과 연관되어 있고 이름이 지정된 변수/필드 등이없는 경우 언어가 동적으로 입력됩니다. 즉, 프로그래머로서 당신은 매번 유형을 지정할 필요가 없기 때문에 더 빨리 쓸 수 있음을 의미합니다 (정적으로 유형의 언어를 사용하지 않는 한 입력 유추).

예 : Perl, Ruby, Python, PHP, JavaScript

어쨌든 정적 유형 확인을 수행 할 컴파일러가 없으므로 대부분의 스크립팅 언어에는이 기능이 있지만 변수 유형을 잘못 해석하여 통역사로 인한 버그를 검색 할 수 있습니다. 운 좋게도 스크립트는 작아서 버그는 숨길 곳이 많지 않습니다.

대부분의 동적으로 입력 한 언어를 사용하면 유형 정보를 제공 할 수 있지만 필요하지 않습니다. 현재 개발중인 한 언어, 악당, 하이브리드 접근법은 기능 내에서 동적 타이핑을 허용하지만 함수 서명에 대한 정적 타이핑을 시행합니다.

다른 팁

정적으로 입력 한 프로그래밍 언어는 유형 확인을 수행합니다 (즉, 유형의 제약 조건을 확인하고 시행하는 프로세스) 컴파일 타임 반대로 실행 시간.

동적으로 입력 한 프로그래밍 언어는 유형 확인을합니다 실행 시간 반대로 컴파일 타임.

다음은 Python (동적으로 입력) 및 GO (정적으로 입력 한) 유형 오류를 처리하는 방법에 대조되는 예입니다.

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

파이썬은 런타임에 확인을 입력하므로 다음과 같습니다.

silly(2)

완벽하게 잘 실행되며 예상 출력을 생성합니다 Hi. 문제가 발생한 선이 누르면 오류가 발생합니다.

silly(-1)

생산합니다

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

관련 라인이 실제로 실행 되었기 때문입니다.

반면에 컴파일 시간에 유형 확인을합니다.

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)

간단히 말하면 다음과 같이하십시오 정적으로 입력 한 언어 변수의 유형은입니다 공전, 의미 변수를 유형으로 설정하면 변경할 수 없습니다. 입력은 참조하는 값보다는 변수와 관련되기 때문입니다.

예를 들어 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

반면에 : a 동적으로 유형화 된 언어 변수의 유형은입니다 동적, 의미 변수를 유형으로 설정 한 후에는 변경할 수 있습니다. 이는 타이핑이 변수 자체가 아닌 가정하는 값과 관련되기 때문입니다.

예를 들어 파이썬에서 :

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의 유형 주석 또는 PHP의 해킹 변형을 포함합니다. 수요.

기술 선택에 관해서는 어느 쪽도 다른 쪽보다 본질적인 우월성을 가지고 있습니다. 더 많은 컨트롤이 시작되거나 유연성으로 더 많은 것을 선호하는 문제 일뿐입니다. 작업에 적합한 도구를 선택하고 스위치를 고려하기 전에 반대쪽으로 사용할 수있는 내용을 확인하십시오.

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>
정적 분석에서 다른 지점을 취하지 않을 것이라고 판단 할 수 없기 때문에 불쾌한 것으로 거부됩니다. [1] 정적 유형 체커의 보수적 인 동작은 오 탐지를 드물게 평가할 때 유리합니다. 정적 유형 검사기는 거의 사용되지 않는 코드 경로에서 유형 오류를 감지 할 수 있습니다. 정적 유형 확인이 없으면 100% 코드 커버리지가있는 코드 커버리지 테스트조차도 이러한 유형 오류를 찾을 수 없습니다. 코드 적용 범위 테스트는 값이 생성되는 모든 장소와 특정 값을 사용하는 모든 장소의 조합을 고려해야하기 때문에 이러한 유형 오류를 감지하지 못할 수 있습니다.

가장 널리 사용되는 정적으로 타이핑 된 언어는 공식적으로 안전하지 않습니다. 프로그래밍 언어 사양에 "허점"이있어 프로그래머는 정적 유형 검사기가 수행 한 검증을 우회하는 코드를 작성하여 더 넓은 범위의 문제를 해결할 수 있습니다. 예를 들어, Java와 대부분의 C 스타일 언어에는 유형의 펀딩이 있으며 Haskell은 UnsaFeperFormio와 같은 기능을 가지고 있습니다. 이러한 작업은 런타임에 안전하지 않을 수 있습니다. 프로그램이 실행될 때 값의 잘못된 입력으로 인해 원치 않는 동작을 일으킬 수 있습니다.

동적 타이핑

프로그래밍 언어는 컴파일 타임과 달리 대부분의 유형 검사가 런타임에 수행 될 때 동적으로 입력되거나 '동적'이라고합니다. 동적 타이핑에서 유형은 변수가 아닌 값과 연관됩니다. 동적으로 입력 한 언어에는 Groovy, JavaScript, LISP, LUA, Objective-C, Perl (사용자 정의 유형과 관련하여 내장 유형이 아닌), PHP, Prolog, Python, Ruby, Smalltalk 및 TCL이 포함됩니다. 정적 타이핑과 비교할 때, 동적 타이핑은보다 유연 할 수 있지만 (예 : 프로그램이 런타임 데이터를 기반으로 유형 및 기능을 생성 할 수있게함으로써) 선험적 보증이 적을 수 있습니다. 동적으로 입력 한 언어는 정적 유형 검사기에 의해 유효하지 않은 일부 프로그램을 받아들이고 실행하려고하기 때문입니다.

동적 유형은 런타임 유형 오류가 발생할 수 있습니다. 이 작업은 프로그래밍 실수가 발생한 곳, 즉 잘못된 유형의 데이터가 가지고 있지 않은 장소로 전달 된 장소 후에도 발생할 수 있습니다. 이것은 버그를 찾기 어렵게 만듭니다.

정적으로 입력 한 사촌과 비교하여 동적으로 입력 한 언어 시스템은 소스 코드에서 "컴파일 타임"점검을 적게 만듭니다 (예를 들어 프로그램이 구문 적으로 정확한지 확인합니다). 런타임 검사는 동적 정보와 편집 중에 존재하는 정보를 사용할 수 있기 때문에 더 정교 할 수 있습니다. 반면에, 런타임 확인은 프로그램의 특정 실행에서 조건이 유지된다고 주장하며,이 점검은 프로그램의 모든 실행에 대해 반복됩니다.

동적으로 입력 한 언어의 개발은 종종 단위 테스트와 같은 프로그래밍 관행에 의해 지원됩니다. 테스트는 전문 소프트웨어 개발의 핵심 관행이며 동적으로 입력 한 언어에서 특히 중요합니다. 실제로, 올바른 프로그램 작동을 위해 수행 된 테스트는 정적 유형 확인보다 훨씬 더 넓은 오류를 감지 할 수 있지만, 반대로 테스트 및 정적 유형 검사가 모두 감지 할 수있는 오류를 종합적으로 검색 할 수는 없습니다. 테스트는 소프트웨어 빌드주기에 통합 될 수 있으며,이 경우 프로그램 사용자가 수동으로 그러한 테스트를 실행할 필요가 없다는 점에서 "컴파일 시간"점검으로 생각할 수 있습니다.

참조

피어스, 벤자민 (2002). 유형 및 프로그래밍 언어. MIT 프레스. ISBN 0-262-16209-1.

용어 "Dynamically Typed"는 불행히도 오해의 소지가 있습니다. 모든 언어는 정적으로 입력되며 유형은 표현의 속성입니다 (일부 생각과 같은 가치가 아님). 그러나 일부 언어에는 하나의 유형 만 있습니다. 이것을 Uni-Typed 언어라고합니다. 그러한 언어의 한 예는 유형의 람다 미적분학입니다.

Untyped Lambda 미적분학에서 모든 용어는 Lambda 용어이며, 용어에서 수행 할 수있는 유일한 작업은 다른 용어로 적용하는 것입니다. 따라서 모든 작업은 항상 무한 재귀 또는 람다 용어를 초래하지만 오류를 나타내지 않습니다.

그러나 우리는 원시적 숫자와 산술 연산을 갖춘 미지의 람다 미적분을 보강해야했고, 두 가지 람다 용어를 함께 추가하는 무의미한 작업을 수행 할 수있었습니다. (λx.x) + (λy.y). 이런 일이 발생할 때 오류를 알리는 유일한 제정신 일은 주장 할 수 있지만,이를 수행 할 수 있으려면 각 값에는 용어가 Lambda 용어인지 숫자인지를 나타내는 표시기로 태그를 붙여야합니다. 그런 다음 추가 연산자는 실제로 두 인수가 숫자로 태그가 지정되어 있는지 확인하고 그렇지 않은 경우 오류를 나타냅니다. 이 태그는이 태그입니다 ~ 아니다 유형은 유형이 해당 프로그램에 의해 생성 된 값이 아닌 프로그램의 속성이기 때문에 유형.

이를 수행하는 Uni-Typed 언어를 동적으로 입력합니다.

JavaScript, Python 및 Ruby와 같은 언어는 모두 uni-typed입니다. 다시, typeof JavaScript의 연산자 type 파이썬의 기능은 오해의 소지가있는 이름을 가지고 있습니다. 그들은 유형이 아니라 피연산자와 관련된 태그를 반환합니다. 비슷하게, dynamic_cast C ++에서 instanceof 자바에서 ~ 아니다 확인을 입력하십시오.

편집 대 해석

"소스 코드가 번역 될 때"

소스 코드: 원본 코드 (일반적으로 사람이 컴퓨터에 타이핑)
번역: 소스 코드를 컴퓨터로 읽을 수있는 것으로 변환 (즉, 기계 코드)
실행 시간: 프로그램이 명령을 실행하는 기간 (컴파일 후, 컴파일 된 경우)
편집 된 언어: 런타임 이전에 코드가 번역되었습니다
해석 된 언어: 실행 중에 즉시 코드가 번역되었습니다

타자

"유형을 확인할 때"

5 + '3' 유형 오류의 예입니다 강력하게 입력했습니다 Go 및 Python과 같은 언어는 "유형 강요"를 허용하지 않기 때문에 -> 두 가지 유형 병합과 같은 특정 컨텍스트에서 값이 유형을 변경하는 능력. 약하게 입력했습니다 JavaScript와 같은 언어는 유형 오류를 던지지 않습니다 (결과는 '53').

공전: 런타임 전에 확인 된 유형
동적: 실행 중에 즉시 확인 된 유형

"정적 및 컴파일"및 "동적 및 해석"의 정의는 상당히 유사하지만 ... 소스 코드가 번역 될 때 "유형이 점검 될 때"를 기억하십시오.

언어가 편집되었는지 또는 해석되었는지 여부에 관계없이 동일한 유형 오류가 발생합니다.! 이 용어를 개념적으로 분리해야합니다.

파이썬 예제

역동적이고 해석됩니다

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

silly(2)

Python은 해석되고 동적으로 입력되기 때문에 실행중인 코드 만 번역하고 유형-점검됩니다. 그만큼 else 블록은 결코 실행되지 않습니다 5 + '3' 결코 보지 못했습니다!

정적으로 입력 한 경우 어떻게해야합니까?

코드가 실행되기 전에 유형 오류가 발생합니다. 해석 되더라도 여전히 런타임 전에 유형 확인을 수행합니다.

컴파일 된 경우 어떻게해야합니까?

그만큼 else 런타임 전에 블록이 번역/보이지만 동적으로 입력되기 때문에 오류가 발생하지 않습니다! 동적으로 입력 한 언어는 실행 될 때까지 유형을 확인하지 않으며 해당 라인이 실행되지 않습니다.

예를 들어보세요

정적, 컴파일

package main

import ("fmt"
)

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

func main() {
  silly(2)
}

실행하기 전에 유형을 점검하고 (static) 유형 오류가 즉시 잡혔습니다! 해석 된 경우 런타임 전에 유형을 확인하고 동일한 결과를 얻습니다. 역동적 인 경우 컴파일 중에 코드가 보이지만 오류가 발생하지 않습니다.

성능

컴파일링 된 언어는 정적으로 입력 한 경우 (동적으로) 런타임에 더 나은 성능을 갖습니다. 유형에 대한 지식은 기계 코드 최적화를 허용합니다.

정적으로 입력 된 언어는 실행 중에 유형을 동적으로 점검 할 필요가 없기 때문에 런타임에 더 나은 성능을 제공합니다 (실행하기 전에 확인).

마찬가지로, 코드가 "해석"/번역 할 필요가없는 대신 코드가 이미 번역되었으므로 컴파일 된 언어는 런타임에 더 빠릅니다.

컴파일 된 언어와 정적으로 입력 한 언어는 각각 번역 및 유형 확인을 위해 실행되기 전에 지연됩니다.

더 많은 차이점

정적 타이핑은 실행 중에 오류를 찾는 대신 일찍 오류를 포착합니다 (특히 긴 프로그램에 유용함). 프로그램의 어느 곳에서나 유형 오류를 허용하지 않으며 종종 변수가 변경 유형에서 변수를 방지하여 의도하지 않은 오류로부터 더 많은 방어를 방지한다는 점에서 더 "엄격한"것입니다.

num = 2
num = '3' // ERROR

다이나믹 타이핑은 더 유연하며 일부는 감사합니다. 일반적으로 변수가 유형을 변경하도록 허용하므로 예기치 않은 오류가 발생할 수 있습니다.

정적으로 입력 한 언어는 컴파일 시간에 유형-점검되며 유형은 변경 될 수 없습니다. (유형의 주석에 귀여워하지 마십시오. 새로운 변수/참조가 생성됩니다).

동적으로 입력 한 언어 유형-점검 시간에 런타임 및 변수 유형을 런타임에 변경할 수 있습니다.

정적으로 입력 한 언어: 각 변수와 표현식은 컴파일 시간에 이미 알려져 있습니다.

(int a; A는 런타임에 정수 유형 값 만 취할 수 있습니다)

예 : C, C ++, Java

동적으로 입력 한 언어: 변수는 런타임에 다른 값을받을 수 있으며 유형은 런타임에 정의됩니다.

(var a; A는 런타임에 모든 종류의 값을 취할 수 있습니다)

예 : 루비, 파이썬.

달콤하고 단순한 정의이지만 필요에 맞는 : 정적으로 입력 된 언어는 전체 범위 (SEG : SCALA) 동적으로 유형 된 언어에 대한 변수에 유형을 바인딩합니다.

정적으로 입력 한 언어에서 변수는 컴파일 시간에 알려진 유형과 관련되며,이 유형은 프로그램 실행 전반에 걸쳐 변경되지 않은 상태로 유지됩니다. 동등하게, 변수에는 알려진/지정된 유형의 인스턴스 인 값 만 할당 할 수 있습니다.
동적으로 입력 한 언어에서 변수는 유형이 없으며 실행 중 그 값은 모든 모양과 형태 일 수 있습니다.

C ++, Java 및 Python과 같은 동적으로 입력 한 언어와 같은 정적으로 입력 한 언어는 변수 유형의 실행 측면에서만 다릅니다. 정적으로 입력했습니다 언어에는 변수의 정적 데이터 유형이 있습니다. 여기에서 데이터 유형이 컴파일 중에 확인되므로 디버깅이 훨씬 간단합니다. 동적으로 입력했습니다 언어는 동일하지 않으며, 데이터 유형이 확인되어 프로그램을 실행하므로 디버깅이 약간 어렵습니다.

또한 그들은 매우 작은 차이를 가지고 있으며 강력하게 입력했습니다 그리고 약하게 입력했습니다 언어. 강력하게 입력 된 언어는 한 유형을 다른 유형으로 사용할 수 없습니다. C 및 C ++ ... 약하게 타이핑 된 언어는 예를 들어 EG.Python을 허용합니다.

동적으로 유형화 된 언어 어떤 가변 유형을 사용해야하는지 생각하는 것에 대한 오버 헤드없이 (필요한) 정적으로 타이핑 된 언어이자형).

정적 유형 언어(컴파일러가 메서드 호출을 확인하고 참조를 컴파일함):

일반적으로 더 나은 성능
더 빠른 컴파일 오류 피드백
더 나은 IDE 지원
정의되지 않은 데이터 형식 작업에는 적합하지 않습니다.
모델이 정의되지 않은 경우 개발을 시작하기가 더 어렵습니다.
컴파일 시간이 길어짐
대부분의 경우 더 많은 코드를 작성해야 합니다.

동적 유형 언어(프로그램 실행 시 결정):

성능 저하
더 빠른 개발
일부 버그는 나중에 런타임에만 감지될 수 있습니다.
정의되지 않은 데이터 형식(메타 프로그래밍)에 적합

정적 타이핑 : Java 및 Scala와 같은 언어는 정적 유형입니다.

변수는 코드에 사용되기 전에 정의되고 초기화되어야합니다.

전. in x; x = 10;

System.out.println (x);

동적 타이핑 :Perl은 역동적 인 유형 언어입니다.

변수는 코드에서 사용하기 전에 초기화 할 필요가 없습니다.

y = 10; 코드의 후반부 에이 변수를 사용하십시오

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow