변수와 타입

스위프트의 타입에 관련된 기본 문법

• 타입 주석(Type Annotation)

변수를 선언하면서, 타입도 명확하게 지정하는 방식입니다. (*타입을 명시)

var num: Int // 1) Int타입 변수를 선언 (타입 선언)
num = 10 // 2) 값을 저장 (초기화)
print(num) // 출력: 10


# 자료형을 명확하게 지정 (타입어노테이션)

var a: Int = 3
var b: Int = 4

# 타입 선언과 초기화
var pi: Double = 3.14

 

• 타입 추론(Type Inference)

스위프트에서는 타입 추론 기능을 제공하며, 명시적으로 타입을 지정하지 않아도 컴파일러가 초기화된 값에 따라 변수 타입을 추론합니다. (*타입을 명시하지 않고 컴파일러가 타입을 추론)

var a = 2
print(type(of: a)) // 출력: Int

var pi = 1.2
print(type(of: pi))  // 출력: Double

# 스위프트에서 실수의 타입을 명시하지 않을 경우 기본 타입은 Double 타입이다.
var float: Float = 1.2
print(type(of: float))  // 출력: Float

# 스위프트에서 문자의 타입을 명시하지 않을 경우 기본 타입은 String 타입이다.
var char1 = "c"
print(type(of: char1)) // String

var char2: Character = "c"
print(type(of: char2)) // Character

var name = "zerobugPark"
print(type(of: name)) // String

var isOn = true
print(type(of: isOn)) // Bool

 

• 타입 안정성(Type Safety)

타입 안정성이란 변수가 선언될 때부터 정해진 타입만 담을 수 있습니다.

#데이터 할당 불가능

var num = 0 // Int 타입의 변수 선언
num = 3.14 // Int 타입에 double 타입 할당 -> 컴파일 오류 (타입이 다르기 때문에 할당 할 수 없다)

------------------------------------------------------------------------------------

#데이터 할당 가능

var pi = 3.14 // Doulbe형 타입의 변수 선언
pi = 3 // 3이라고 Int 타입은 할당한 것처럼 보이지만, 실질적으로는 3.0의 Double형 할당
#타입 추론으로 인하여 컴파일러는 변수 pi가 Double인 것을 알 수 있으며,
 3.0을 3으로 줄여서 썻다고 컴파일러는 생각하기 때문에 컴파일 오류가 발생하지 않는다
print(typeof:(pi)) //출력: Double

------------------------------------------------------------------------------------

#스위프트는 다른 타입끼리 계산할 수 없다

let num1 = 10
let numm2: Double = num1 //타입이 다르기 때문에 계산할 수 없다.

let a = 12
let pi = 3.14

let result = a + pi // 계산 불가능

// 정수형과 실수형은 계산할 수 없다
// 정수/실수형은 문자형과 계산할 수 없다.

 

• 타입(형) 변환(Type Conversion)

기존에 메모리에 저장된 값을 다른 형식으로 바꾼 후, 새로운 값을 생성하여 다른 메모리 공간에 다시 저장합니다.

• 정수 타입 간의 변환

let intNumber: Int = 42
let doubleNumber: Double = 42.7

// Int를 Double로 변환
let convertedDouble = Double(intNumber)
print(convertedDouble)  // 출력: 42.0
print(type(of: convertedDouble)) //출력: Double

// Double을 Int로 변환
let convertedInt = Int(doubleNumber)
print(convertedInt)  // 출력: 42
print(type(of: convertedInt)) //출력: Int

*실수형 타입의 변수를 정수형으로 변환할 때에는 소수점 아랫자리의 값들은 버림 처리가 됩니다.

• 실수 타입 간의 변환

let floatNumber: Float = 3.14
let doubleValue: Double = 3.14

// Float를 Double로 변환
let convertedToDouble = Double(floatNumber)
print(convertedToDouble) // 출력: 3.14xxxx
print(type(of:convertedToDouble))  // 출력: Double


// Double을 Float로 변환
let convertedToFloat = Float(doubleValue)
print(convertedToFloat)  // 출력: 3.14
print(type(of:convertedToFloat)) // 출력: Float

 

• 문자열을 숫자로 변환

let stringNumber = "123"
let convertedIntFromString = Int(stringNumber)
print(convertedIntFromString)  // 출력: Optional(123)
print(type(of: convertedIntFromString)) // 출력: Optional(Int)

let stringDouble = "123.45"
let convertedDoubleFromString = Double(stringDouble)
print(convertedDoubleFromString)  // 출력: Optional(123.45)
print(type(of: convertedDoubleFromString)) // 출력: Optional(Double)

 

• 숫자를 문자열로 변환

let intValue = 123
let stringFromInt = String(intValue)
print(stringFromInt)  // 출력: "123"
print(type(of: stringFromInt)) // 출력: String

let doubleValue = 123.45
let stringFromDouble = String(doubleValue)
print(stringFromDouble)  // 출력: "123.45"
print(type(of: stringFromDouble)) // 출력: String

 

• 옵셔널 타입(Optional Type)

let invalidStringNumber = "abc"
let convertedNumber = Int(invalidStringNumber)
print(convertedNumber)  // 출력: nil

• 스위프트에서는 문자열을 숫자로 변환할 때는 결과가 옵셔널 타입이 됩니다. 이는 변환이 실패할 가능성이 있기 때문입니다.
• 문자열을 숫자열로 변환 시 옵셔널 타입이 발생하는 이뉴는 문자열이 숫자가 아닌 경우("강아지", "고양이" 등)가 있을 수 있기 때문입니다.
• 숫자를 문자열로 변환할 때에는 옵셔널 타입이 발생하지 않는 이유는 어떠한 숫자든 문자열이 될 수 있기 때문입니다.
• nil이란 값이 없음을 나타내는 키워드입니다.