튜플 Tuple
여러 개의 값을 하나로 묶어서 표현하는 데이터 타입
- 관련된 값들을 그룹화하여 관리할 때 유용하다.
- 서로 다른 타입의 값들이 튜플에 저장될 수 있으며, 모두 동일한 타입의 값이어야 한다는 제약도 없다.
let myTuple = (10, 432.433, "This is a String")💡 튜플에 저장된 값을 얻는 방법
(1) 인덱스 위치 참조
let myTuple = (10, 432.433, "This is a String")
let myString = myTuple.2
//인덱스 2에 있는 문자열 추출
print(myString)
// 출력 : "This is a String"(2) 튜플에 있는 모든 값 추출하여 할당
let myTuple = (10, 432.433, "This is a String")
let (myInt, myFloat, myString) = MyTuple
//세 개로 분해하여 각각 할당
//myInt = 10
//myFloat = 432.433
//myString = "This is a String"(3) 튜플에 있는 값들을 선택적으로 추출
let myTuple = (10, 432.433, "This is a String")
var (myInt, _, myString) = MyTuple
//원하지 않는 값의 자리에 밑줄 문자 사용하면 해당 값 무시
//myInt = 10
//myString = "This is a String"(4) 튜플을 생성할 때 변수에 할당
let myTuple = (count : 10, length : 432.433, message : "This is a String")
print(myTuple.message)
//출력 : "This is a String"예제1
//(1) 인덱스 위치 참조
let mySchool: (String, String, Int) = ("AppSchool", "iOS", 6)
//mySchool 튜플 생성
print(mySchool.0)
//출력 : "AppSchool"
print(mySchool.1)
//출력 : "iOS"
print(mySchool.2)
//출력 : 6
//-------------------------------------------------------
//(2) 튜플에 있는 모든 값 추출하여 할당
let (schoolName, osName, season) = ("AppSchool", "iOS", 6)
//let (schoolName, osName, season) = mySchool
print(schoolName)
//출력 : "AppSchool"
print(osName)
//출력 : "iOS"
print(season)
//출력 : 6
//-------------------------------------------------------
//(3) 튜플에 있는 값들을 선택적으로 추출
let (mySchoolName, _ , _) = mySchool
//첫번째 값만 추출
print(mySchoolName)
//출력 : "AppSchool'예제2
func calcTwoNumbers(_ number1: Int, _ number2: Int) -> (Int, Int) {
let sum: Int = number1 + number2
let sub: Int = number1 - number2
return (sum, sub)
}
let (resultSum, resultSub) = calcTwoNumbers(10, 4)
// 함수 결과값(sum, sub)을 튜플에 저장
print(resultSum)
// 출력 : 14 (10+4)
print(resultSub)
// 출력 : 6 (10-4)옵셔널 Optional
- 다른 프로그래밍 언어에 없는 새로운 개념
- 변수 또는 상수에 값이 할당되지 않은 상황을 처리하기 위해 안전하고 일관된 접근 방식 제공
- 값이 있을수도 있고 없을 수도 있다.
옵셔널 기본 방법
변수를 선언할 때, 데이터 타입 애너테이션 다음에 '?' 문자를 두어 옵셔널이 되게 한다.
값이 있는지 없는지 모르기 때문에 "?"
var index : Int ?
//index라는 이름의 Int 타입의 변수를 옵셔널로 선언하는 코드
//옵셔널 값 할당 및 확인
var index : Int?
// 옵셔널 Int 타입 변수에 값 할당
// 옵셔널 값 존재 여부 확인
if index != nil {
//index 변수는 값이 할당되어 있다.
} else {
//index 변수는 값이 할당되어 있지 않다.
}만약 옵셔널에 값이 할당되었다면 해당 값이 옵셔널 내에서 래핑되었다(wrapped) 고 말한다.
강제 언래핑 (forced unwrapping)
옵셔널 값을 강제로 추출하는 방법
감싸져있는 것을 벗기는 것
래핑된 값은 옵셔널 이름 뒤에 느낌표(!) 를 두어 추출되게 한다.
옵셔널 값이 nil인 경우 런타임 오류가 발생하므로 주의해야 한다.
var index : Int? = 3
var treeArray = ["Oak", "Pine", "Yew", "Birch"]
if index != nil {
//index에 값이 할당되어있다면
print(treeArray[index!])
} else {
//index에 값이 할당되어있지않다면
print("index does not contain a value")
}
// 출력 : treeArray[index!] = treeArray[3] = "Birch"
//index! : index에 할당되어있는 값 추출
옵셔널에 감싸져있는 index 값을 강제언래핑을 통해 꺼내서 사용한 것을 볼 수 있다.
만약 느낌표를 붙이지 않고 강제 언래핑을 하지 않은 상태에서 실행하면 컴파일러가 에러가 생긴다.
옵셔널 바인딩 (Optional Binding)
옵셔널 값을 안전하게 추출하고 사용하는 방법
강제 언래핑 대신, 옵셔널로 할당된 값은 옵셔널 바인딩을 이용하여 변수나 상수에 할당할 수 있다. (if-let / guard-let)
if let constantname = optionalName {
}
if var variablename = optionalName {
}위의 코드는 두가지 작업을 수행한다.
- 지정된 옵셔널이 값을 가지고 있는지 확인
- 옵셔널 변수가 값을 가지고 있는 경우에 선언된 상수(또는 변수)에 그 값을 할당하고 코드가 실행
옵셔널 바인딩을 이용해 위 강제 언래핑 예제를 수정해보자 !
var index : Int? = 3
var treeArray = ["Oak", "Pine", "Yew", "Birch"]
//index에 값이 할당되어있다면 myvalue 상수에 할당
//언래핑되었다. 즉 값이 있다.
if let myvalue = index {
print(treeArray[myvalue])
}
//index에 값이 할당되어있지않다면
//값이 없다.
else {
print("index does not contain a value")
}
// 출력 : treeArray[myvalue] = treeArray[3] = "Birch"
index 변수에 할당된 값이 언래핑되어 myvalue라는 임시 상수에 할당된다.
myvalue 상수는 if 구문 안에서만 유효한 상수이기 때문에
if 구문이 끝나면 myvalue 상수는 더이상 존재하지 않게 된다.
이는 myvalue와 같은 임시 값의 사용이 불필요하다는 것이다.
Swift 5.7부터 아래와 같은 약식 if-let 구문이 도입되었다.
이 방식을 사용하면 임시 값을 옵셔널에 할당할 필요가 없어진다.
.
.
.
//약식 if-let
//임시 값 할당 x
if let index {
print(treeArray[myvalue])
}
.
.
.
옵셔널 바인딩을 사용하여 여러 선택 사항을 풀고 조건식을 포함할 수도 있다.
1) 한번에 2개의 옵셔널을 언래핑
var pet1: String?
var pet2: String?
pet1 = "cat"
pet2 = "dog"
//2개의 옵셔널
if let pet1, pet2 {
print(pet1)
print(pet2)
} else {
print("insufficient pets")
}2) 조건문 사용
//조건문 포함
//petcount > 1일 때 옵셔널 바인딩
if let pet1, let pet2, petCount > 1 {
print(pet1)
print(pet2)
} else {
print("insufficient pets")
}petCount에 할당된 값이 1보다 크지 않다면 옵셔널 바인딩이 수행되지 않는다.
nil 결합 연산자 (??)
누락된 값을 처리하는 다른 방법은 nil-결합 연산자 (??) 사용하여 기본값을 제공하는 방법
- 옵셔널에서
??의 왼편이 nil 이 아니면(값이 있으면), 값은 언래핑되고 사용 - 왼편이 nil이면(값이 없으면),
??의 오른편의 값이 사용
let name: String? = nil
let greeting = "Hello, " + (name ?? "friend") + "!"
print(greeting)
// Prints "Hello, friend!"
//??의 왼편 name이 nil이기 때문에 ?? 오른편인 friend 값이 사용된다.암묵적 언래핑 (implicitly unwrapped)
강제 언래핑, 옵셔널 바인딩을 하지 않아도 값에 접근 가능한 옵셔널 선언 방법
옵셔널을 사용할 때 물음표(?) 대신 느낌표(!) 사용
var index : Int!
//옵셔널을 암묵적으로 언래핑 함.
index = 3
var treeArray = ["Oak", "Pine", "Yew", "Birch"]
if index != nil {
print(treeArray[index])
}
else {
print("index does not contain a value")
}
/////////////////////////////////////////////////////
let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
let number = convertedNumber!
//암묵적 언래핑
guard let number = convertedNumber else {
fatalError("The number was invalid")
}index 옵셔널 변수는 암묵적으로 언래핑되도록 선언됨
배열의 인덱스로 사용되어 출력시킬 때 값을 언래핑할 필요가 없게 된다.
암시적으로 언래핑된 옵셔널 (Implicitly Unwrapped Optionals)
옵셔널이 값을 처음 설정한 후에는 항상 값을 갖는 것은 분명함
이러한 경우 항상 값이 있다고 가정할 수 있으므로 접근할 때마다 옵셔널의 값을 확인하고 언래핑 할 필요가 없음.->암시적으로 언래핑
옵셔널을 만들기위해 타입뒤에 물음표 String?를 작성하는 대신에 느낌표 String! 로 암시적으로 언래핑 된 옵셔널을 작성
변수가 nil 이 될 가능성이 있다면 암시적으로 언래핑된 옵셔널을 사용하면 안된다.
//1. 기본 옵셔널 타입, !를 통해 언래핑해야한다.
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // Requires explicit unwrapping
//2. 암시적으로 언래핑된 옵셔널
//자동으로 언래핑 된다.
let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // Unwrapped automatically✚ 추가적으로..
swift에서
- 할당된 값이 없거나
- nil 을 할당할 수 있는 것
은 옵셔널 타입 뿐 !!
var myInt = nil //유효하지 않은 코드
var myString: String = nil //유효하지 않은 코드
var myConstant = nil //유효하지 않은 코드
//위 세개의 코드는 모두 컴파일 에러가 난다.
//옵셔널로 선언된 변수가 아니기 때문에