[프로그래밍 기초] 정적 타이핑, 동적 타이핑, 강타입, 약타입 정리

변수 타입

프로그래밍 언어를 공부하다 보면 정적 타이핑, 동적 타이핑, 강타입, 약타입이라는 표현을 자주 보게 된다.

 

처음 보면 비슷해 보이지만, 이들은 서로 다른 기준으로 언어의 타입 시스템을 설명하는 말이다.

 

크게 두 가지 질문으로 나누어 이해하면 된다.

타입을 언제 검사하는가?
타입 검사를 얼마나 엄격하게 하는가?

첫 번째 질문은 정적 타이핑과 동적 타이핑의 차이다.
두 번째 질문은 강타입과 약타입의 차이다.

타입이란?

타입은 값의 종류를 의미한다.

 

예를 들어 다음 값들은 서로 다른 타입을 가진다.

10          # 정수
3.14        # 실수
"hello"     # 문자열
True        # 불리언

 

타입이 중요한 이유는 값의 종류에 따라 가능한 연산이 달라지기 때문이다.

 

숫자끼리는 더할 수 있다.

10 + 20

 

문자열끼리도 연결할 수 있다.

"hello" + "world"

 

하지만 숫자와 문자열을 아무렇게나 더하면 문제가 생길 수 있다.

10 + "20"

 

이런 연산을 허용할지, 오류로 볼지, 자동으로 변환할지는 언어마다 다르다.

정적 타이핑

정적 타이핑(static typing)은 프로그램을 실행하기 전에 타입을 검사하는 방식이다.

 

보통 컴파일 단계에서 타입 오류를 확인한다.

C, C++, Java, Go, Rust 같은 언어가 대표적이다.

 

정적 타이핑 언어에서는 변수의 타입을 미리 정해두는 경우가 많다.

 

예를 들어 Java에서는 다음처럼 변수 타입을 명시한다.

int age = 20;
String name = "kim";

 

age는 정수 타입이고, name은 문자열 타입이다.

 

한 번 정수 타입으로 선언한 변수에 문자열을 넣으려고 하면 오류가 발생한다.

int age = 20;
age = "twenty"; // 오류

 

이 오류는 실행 중에 발견되는 것이 아니라, 실행 전에 컴파일 단계에서 발견된다.

정적 타이핑의 장점

정적 타이핑의 장점은 실행 전에 타입 오류를 미리 잡을 수 있다는 점이다.

프로그램을 실행하기 전에 잘못된 타입 사용을 발견할 수 있으므로 안정성이 높다.

실행 전에 타입 오류 발견
코드 안정성 증가
IDE 자동완성, 리팩토링에 유리
큰 규모의 프로젝트에 적합

 

예를 들어 함수가 정수를 받아야 하는데 문자열을 넘겼다면, 실행 전에 오류를 알 수 있다.

public int add(int a, int b) {
    return a + b;
}

add(10, "20"); // 컴파일 오류

 

큰 프로젝트에서는 이런 점이 중요하다.

여러 사람이 함께 개발할수록 변수와 함수의 타입이 명확해야 실수를 줄일 수 있다.

정적 타이핑의 단점

정적 타이핑은 타입을 미리 지정해야 하므로 코드가 길어질 수 있다.

작은 실험 코드를 빠르게 작성할 때는 다소 번거롭게 느껴질 수 있다.

타입 선언이 필요할 수 있음
코드가 다소 길어질 수 있음
초기 작성 속도가 느릴 수 있음

 

다만 최근 정적 타이핑 언어들은 타입 추론을 지원하는 경우가 많다.

 

예를 들어 Java의 var, Kotlin, Swift, TypeScript 등은 타입을 직접 적지 않아도 컴파일러가 타입을 추론할 수 있다.

동적 타이핑

동적 타이핑(dynamic typing)은 프로그램 실행 중에 타입을 검사하는 방식이다.

 

Python, JavaScript, Ruby, PHP 같은 언어가 대표적이다.

 

동적 타이핑 언어에서는 변수에 타입을 미리 고정하지 않는 경우가 많다.

 

Python 예시를 보자.

x = 10
x = "hello"

 

처음에 x에는 정수 10이 들어갔다.

 

그다음에는 문자열 "hello"가 들어갔다.

 

Python에서는 이것이 가능하다.

 

변수 x 자체가 정수 타입으로 고정된 것이 아니라, 실행 중에 어떤 값이 들어가느냐에 따라 타입이 달라진다.

동적 타이핑의 장점

동적 타이핑은 코드를 빠르고 간단하게 작성하기 좋다.

타입을 매번 명시하지 않아도 되므로 문법이 비교적 간결하다.

코드 작성이 빠름
문법이 간결함
실험과 프로토타이핑에 유리

 

예를 들어 Python에서는 다음처럼 바로 변수를 만들고 사용할 수 있다.

name = "kim"
age = 20
print(name, age)

 

데이터 분석, 스크립트 작성, 빠른 테스트 코드 작성에 편리하다.

동적 타이핑의 단점

동적 타이핑은 타입 오류가 실행 중에 발견될 수 있다.

코드를 실행하기 전까지는 문제가 드러나지 않을 수 있다.

def add(a, b):
    return a + b

print(add(10, 20))
print(add(10, "20"))

 

첫 번째 호출은 정상이다.

30

 

두 번째 호출은 오류가 발생한다.

TypeError

 

정적 타이핑 언어라면 실행 전에 이런 오류를 잡을 수 있지만, 동적 타이핑 언어에서는 해당 코드가 실행되는 순간에 오류가 발생한다.

 

프로젝트 규모가 커질수록 이런 오류를 관리하기 어려워질 수 있다.

 

그래서 Python에서도 타입 힌트를 사용하는 경우가 많다.

def add(a: int, b: int) -> int:
    return a + b

 

Python의 타입 힌트는 기본적으로 실행을 강제로 막지는 않지만, IDE나 타입 검사 도구가 오류를 찾는 데 도움을 줄 수 있다.

정적 타이핑과 동적 타이핑 비교

정적 타이핑과 동적 타이핑은 타입을 언제 검사하느냐의 차이다.

구분	정적 타이핑	동적 타이핑
타입 검사 시점	실행 전	실행 중
타입 선언	필요한 경우가 많음	보통 명시하지 않음
오류 발견	컴파일 단계에서 발견 가능	실행 중 발견 가능
장점	안정성, 유지보수성	간결함, 빠른 개발
단점	코드가 길어질 수 있음	런타임 오류 가능성
대표 언어	C, Java, Go, Rust	Python, JavaScript, Ruby

짧게 정리하면 다음과 같다.

정적 타이핑
실행 전에 타입을 검사한다.

동적 타이핑
실행 중에 타입을 검사한다.

 

강타입

강타입(strong typing)은 서로 다른 타입을 엄격하게 구분하는 방식이다.

타입이 맞지 않는 연산을 쉽게 허용하지 않는다.

 

예를 들어 Python은 동적 타이핑 언어이지만 강타입 성격을 가진다.

10 + "20"

 

Python에서는 이 코드가 오류를 발생시킨다.

TypeError

 

정수와 문자열을 마음대로 더하지 못하게 막는다.

문자열로 더하고 싶다면 직접 변환해야 한다.

str(10) + "20"

 

결과는 다음과 같다.

1020

 

숫자로 더하고 싶다면 문자열을 정수로 변환해야 한다.

10 + int("20")

 

결과는 다음과 같다.

30

 

강타입 언어에서는 개발자가 타입 변환을 명확하게 해주어야 한다.

강타입의 장점

강타입의 장점은 예상하지 못한 타입 변환을 줄일 수 있다는 점이다.

타입이 맞지 않으면 오류를 내기 때문에 코드의 의도가 더 명확해진다.

타입 오류를 명확히 드러냄
예상하지 못한 자동 변환을 줄임
코드 안정성 증가

 

예를 들어 숫자 계산을 하려는 코드에서 문자열이 들어왔다면, 자동으로 이상하게 처리되는 것보다 오류가 나는 편이 더 안전할 수 있다.

 

오류가 발생하면 개발자가 문제를 확인하고 올바른 변환을 직접 작성할 수 있다.

약타입

약타입(weak typing)은 서로 다른 타입 사이의 연산에서 언어가 자동으로 타입을 변환하는 경우가 많은 방식이다.

 

JavaScript가 대표적인 예로 자주 언급된다.

10 + "20"

 

JavaScript에서는 이 코드가 오류가 아니라 문자열 연결로 처리된다.

1020

 

숫자 10이 문자열 "10"처럼 취급되어 "20"과 연결된다.

또 다른 예를 보자.

"5" - 2

 

이 경우 JavaScript는 문자열 "5"를 숫자처럼 변환해서 계산한다.

3

 

+에서는 문자열 연결이 되었는데, -에서는 숫자 계산이 되었다.

이런 자동 변환은 편리할 때도 있지만, 예상하지 못한 결과를 만들 수 있다.

약타입의 장점과 단점

약타입은 타입 변환을 자동으로 해주기 때문에 간단한 코드에서는 편리할 수 있다.

하지만 큰 코드에서는 예상하기 어려운 동작을 만들 수 있다.

장점
자동 타입 변환으로 코드가 간단해질 수 있음

단점
예상하지 못한 결과가 나올 수 있음
버그를 찾기 어려울 수 있음

 

예를 들어 다음 JavaScript 코드는 처음 보면 헷갈릴 수 있다.

0 == false

 

결과는 true이다.

자동 타입 변환이 일어나기 때문이다.

반면 엄격 비교 연산자인 ===를 사용하면 타입까지 비교한다.

0 === false

 

결과는 false이다.

이런 이유로 JavaScript에서는 가능하면 ==보다 ===를 사용하는 것이 권장된다.

강타입과 약타입 비교

강타입과 약타입은 타입 검사를 얼마나 엄격하게 하느냐의 차이다.

구분	강타입	약타입
타입 변환	명시적 변환 요구	자동 변환이 자주 발생
타입 오류	비교적 엄격하게 오류 처리	오류 대신 변환 후 처리 가능
장점	안정적이고 예측 가능	간단하게 작성 가능
단점	직접 변환해야 해서 번거로울 수 있음	예상하지 못한 결과 가능
예시 언어	Python, Java, Rust	JavaScript, PHP 등

짧게 정리하면 다음과 같다.

강타입
타입이 다르면 쉽게 섞지 않는다.

약타입
타입이 달라도 자동으로 바꿔서 처리하는 경우가 많다.

 

정적/동적 타이핑과 강타입/약타입은 다른 기준이다

중요한 점은 정적 타이핑과 강타입이 같은 말이 아니라는 것이다.

동적 타이핑과 약타입도 같은 말이 아니다.

 

두 기준은 서로 다르다.

정적/동적 타이핑
타입을 언제 검사하는가?

강타입/약타입
타입을 얼마나 엄격하게 다루는가?

 

예를 들어 Python은 동적 타이핑 언어이다.

변수 타입을 실행 중에 결정한다.

 

하지만 Python은 강타입 성격을 가진다.

정수와 문자열을 마음대로 더하지 않는다.

10 + "20"  # 오류

 

Java는 정적 타이핑 언어이다.

변수 타입을 컴파일 단계에서 검사한다.

또한 강타입 언어로 분류된다.

int x = 10;
x = "hello"; // 오류

 

JavaScript는 동적 타이핑 언어이다.

실행 중에 타입이 결정된다.

또한 약타입 성격이 강하다.

10 + "20" // "1020"

 

예시로 정리하기

몇 가지 언어를 기준으로 보면 다음과 같다.

언어	정적/동적 타이핑	강타입/약타입
C	정적 타이핑	약타입 성격 있음
Java	정적 타이핑	강타입
Rust	정적 타이핑	강타입
Python	동적 타이핑	강타입
JavaScript	동적 타이핑	약타입
TypeScript	정적 타이핑 성격 추가	JavaScript보다 엄격

이 표는 언어의 타입 시스템을 단순화한 것이다.

 

실제로는 언어마다 타입 변환 규칙이 다르기 때문에 강타입과 약타입의 경계가 항상 명확하게 나뉘지는 않는다.

 

그래도 학습 단계에서는 다음처럼 이해하면 충분하다.

정적 타이핑
실행 전에 타입 검사

동적 타이핑
실행 중 타입 검사

강타입
타입을 엄격하게 구분

약타입
타입을 자동으로 변환하는 경우가 많음

 

정리

타입은 값의 종류를 의미한다.

정수, 실수, 문자열, 불리언 같은 값들은 서로 다른 타입을 가진다.

 

정적 타이핑과 동적 타이핑은 타입을 언제 검사하느냐의 차이다.

 

정적 타이핑은 실행 전에 타입을 검사한다.
C, Java, Go, Rust 같은 언어가 대표적이다.

 

동적 타이핑은 실행 중에 타입을 검사한다.
Python, JavaScript, Ruby 같은 언어가 대표적이다.

 

강타입과 약타입은 타입을 얼마나 엄격하게 다루느냐의 차이다.

 

강타입은 서로 다른 타입을 쉽게 섞지 않는다.
타입이 맞지 않으면 오류를 내고, 필요한 경우 개발자가 직접 타입 변환을 해야 한다.

 

약타입은 서로 다른 타입을 자동으로 변환해 처리하는 경우가 많다.
편리할 수 있지만 예상하지 못한 결과가 나올 수 있다.

 

정적 타이핑과 강타입은 같은 개념이 아니다.
동적 타이핑과 약타입도 같은 개념이 아니다.

 

Python은 동적 타이핑이지만 강타입 성격을 가진다.
JavaScript는 동적 타이핑이면서 약타입 성격이 강하다.
Java는 정적 타이핑이면서 강타입 언어로 볼 수 있다.

 

간단히 외우면 다음과 같다.

정적/동적 타이핑
타입을 언제 검사하는가?

강타입/약타입
타입을 얼마나 엄격하게 다루는가?