Swift 기초(타입, 조건문, 반복문, ...)

 

 

(깔끔한 내용설명이라기 보다는 기억을 되살리는 메모 느낌..)

 

 

변수와 상수를 정의하고 콘솔에 출력하기

var name	//변수 선언
var age: Int	//변수 타입 지정

//변수에 값 넣기
age = 15	
var school: String = "Apple Middle School"
var a, b, c = 10, 11, 12 	//여러 값 지정 가능

//콘솔 출력
print()

// \(변수이름)
print("I’m \(age) years old") //string interpolation

 

조건문

var age = 20

if age < 25 {
	print("young")
}
else {
	print("also young")
} 

var isYoung = true //bool 타입

// 조건이 true --> "Bright"
// 조건이 false --> "Shiny"
var future = age > 25 ? "Bright" : "Shiny"	

 

수(Int, Uint, Float ..)

Int : 64비트 정수로, 음수는 최상위비트를 이용해서 마이너스를 표현한다.

UInt: 64비트 부호 없는 정수이다. (양수만 나타냄) 

이외에도 Int/UInt8, 32 등등 비트 별로 타입이 존재한다.

* Int의 Max 값 - Min 값 = UInt의 Max값

(Int는 64비트 숫자를 양수, 음수가 공유하기 때문에 양수만 다루는 UInt가 나타낼 수 있는 최댓값이 커지게 되는 것.)   

print(11%3)	//2
print(-11%3)	//-2

//오버플로 연산자 &+, &-, &*
let y: Int 8 = 120
let z = y + 10

//Int8이 나타낼 수 있는 범위: -128 ~ 127
let z = y& + 10 //-126

 

오버플로 연산자를 이용하면 타입의 값 범위를 넘겼을 때 에러 없이 처리할 수 있다.

예를 들어, 위와 같이 범위가 -128에서 127인 Int8 타입의 변수에 120이 들어있을 때,

10을 더하면 최댓값인 127을 넘게 된다. 이 때 127을 넘은 값들은 마이너스로 넘어가 -126이라는 결과가 나오게 된다.

부동소수점 수 (Floating)은 정확한 값이 아닌 근사값을 표현한다고 할 수 있다.

비트 크기가 클수록, (64비트 Double이 32비트 Float보다) 더 정확한 수를 표현할 수 있다.

 

Switch(스위치)

Switch 구문에서는 조건에 맞는 case를 실행하고, 실행이 끝나면 구문이 종료된다.

//The closed range operator (a...b) -> a에서 b까지
//The half-open range operator (a..<b) -> a에서 b보다 작은 수 까지
var number = 10
var string = ""

switch number {
case 1...5:
	string = "one to five"
case 6, 7:
	string = "six or seven"
    	fallthrough		//아래의 case를 조건 상관 없이 진행
default:				
	string += "or else"
}

 

 

하지만 fallthrough 코드를 위와 같이 삽입하면 밑의 case를 조건과 상관없이 실행한다.

 

위의 default 부분은 나머지 경우를 처리하는 부분이다. 이 부분을,

case let unkownCode:      //임시 변수
	string += "or else"

 

이렇게 unknownCode라는 임시 변수를 사용해서 똑같이 나타낼 수도 있다.

 

또 상세한 조건이 필요하다면 where을 이용해 필터를 만들 수 있다.

case let bornYear where (bornYear >= 1980 && bornYear < 1995) || bornYear > 1979:
	generation = "Millennials"

 

if-case로 switch 대체하기

let bornYear = 2000

if case 1980...2005 = bornYear, bornYear > 1995 {
	print("Gen Z")
}

 

튜플(Tuple)

튜플은 관련 있는 값을 묶은 하나의 집합이라고 할 수 있다.

var year = 2020
var month = 1
let callendar = (year, month)
error.0		//2020
error.1		//1

let callendar2 = (y: year, m: month)	//이름 있는 튜플

switch challendar {
case (20, 1):
	//code
case(19, _):	// _ : 와일드카드(어떤 값이든 가능)
	//code
case (_, 2)
	//code
default:
	//code
}

 

for, while 반복문

for _ in 1...5 {
	//다섯 번 동안 코드 실행
}

for i in 1...50 where i % 3 == 0 {
	print(i)	//3의 배수 출력
} 

where a > 0 {
	//위 조건 검사 후 코드 실행
    //code
    continue	//반복문의 맨 위로 이동(조건 검사 부분)
    //code
}

repeat {
	//코드 먼저 실행 하고 밑의 조건 검사
} where a > 0

var target = 0
var printout: String = “”

//3의 배수면 Fizz, 5의 배수면 Buzz, 3과 5의 배수면 FizzBuzz, 그 외는 그대로 출력하는 프로그램
for i in 0...50 {
	if i % 3 == 0 {
    	printout += “Fizz”
    }
	if i % 5 == 0 {
    	printout += “Buzz”
    }
	else {
    	printout = String(i)
    }
	print(printout)
    	printout = “”
}     

 

문자열(String)

//유니코드는 \u{코드} 형식으로 나타낸다
let something = “\u{1F60E}”		//“😎”


for scalar in 변수이름(스트링).unicodeScalars {
	print(“\scalar.value”)	//각 글자의 유니코드 번호 출력
} 

var greeting = "hello you"

let start = greeting.startIndex		//타입 인스턴스 만들어짐
let end = greeting.index(start, offsetBy: 4)	//start 인덱스에서 네칸 뒤로 이동
let fifthCharacter = greeting[end]	//'o'
let range = start … end
let firstFive = playground[range]	//"hello"

스위프트에서는 C언어에서 처럼 그냥 string에서 greeting[4] 이렇게 접근하지 못한다. (substring 불가)  

 

옵셔널(Optional)

옵셔널은 어떤 인스턴스에 값이 있을 수도, 없을 수도 있다는 것을 나타낸다.

var errorCodeString: String?
errorCodeString = "404"
let theError = errorCodeString // 강제 언래핑으로 옵셔널 값에 접근한다 

 

* String? 의 값과 String의 값은 같지 않다. String? 옵셔널 값은 언래핑 해야 String에 저장이 가능하다.

 

옵셔널 바인딩(Optional Binding)

if let theError = errorCodeString {  //옵셔널 안에 값이 있다면 아래 코드 실행
	if let errorCodeInteger = Int(theError) {	//인트 값이 없다면 옵셔널을 리턴한다
		print(“\(theError): \(errorCodeInteger)”)
	}
} 

if let theError = errorCodeString, let errorCodeInteger = Int(theError), errorCodeInteger == 404 {
	print("\(errorCodeInteger)")	//위 코드를 하나의 if문으로 표현(+ 조건추가)
} 

//!: 암묵적 언래핑
//값이 있을 거라는 확신이 있을 때..?
var errorString: String! = nil
let yetAnotherErrorString = errorString
//yetAnotherErrorString: nil 값이 들어있는 String? 인스턴스 

 

옵셔널 체이닝

let employee: String? = "Tim"
var upCaseEmployee = employee?.uppercased()	//값이 있으면 대문자로 -> "TIM"
//employee가 nil이면 그대로 nil

upCaseEmployee?.append(" Cook")	//"TIM Cook"
//아무 값이 없으면 아무 일도 일어나지 않는다

let a: String? = nil
let b = a ?? "Nothing"
//Optional ?? Non-optioinal
//옵셔널 a에 값이 들어있지 않으면 Non-optional인 "Nothing"을 리턴
//값이 있다면 옵셔널 a의 값 리턴