Collection

많은 변수들을 어떻게 관리하는 게 좋을까?
→ '통'에 담아 관리

Array

1. 같은 타입끼리
2. 순서 존재(index)

언제 쓸까?
1. 순서가 있는 아이템
2. 아이템의 순서를 알면 유용한 경우

방법1

let evenNumbers:[Int] = [2,4,6,8]

방법2

let evenNumber2:Array<int> = [2,4,6,8]

append

evenNumbers.append(10) // 변경되므로 let이 아닌 var 사용해야
evenNumbers+=[12,14,16]
evenNumbers.append(contentsOf: [18,20])

insert와 remove

let firstThree = evenNumbers[0...2]
evenNumbers.contains(3) // 3있니?
evenNumbers.insert(0, at:0)

evenNumbers.removeAll()
evenNumbers=[]
evenNumbers.remove(at:0)

수정

evenNumbers[0]=-2
evenNumbers[0...2]=[-2, 0, 2]
evenNumbers.swapAt(0, 1) // 순서 바꾸기

for loop에서

for num in evenNumbers
{
	print(num)
}

index 알아보기 위한 for loop

for (index, num) in evenNumbers.enumurated(){
	print("index: \(index), value:\(num)")
}

기타

let isEmpty = evenNumbers.isEmpty

evenNumbers.count

print(evenNumbers.first) // optional 값
print(evenNumbers.last)
if let firstElement = evenNumbers.first {
	print(firstElement)
}

evenNumbers.min()
evenNumbers.max()

evenNumbers[0] //first item
evenNumbers[1] //second item


let arr = evenNumbers.dropFirst(3) // 앞 3개 제외한 값
let arr2 = evenNumbers.dropLast() // 뒤 1개 제외한 값

let firstThree = evenNumbers.prefix(3) // 앞 3개 가져오기
let lastThree = evenNumbers.suffix(3) // 뒤 3개 가져오기

Dictionary

순서 없고, key→value 의 짝. key는 unique 해야.
값을 의미 단위로 찾을 때 사용.

Array vs. Dictionary
순서 기반으로 찾음 vs. key를 기반으로 찾음

var scoreDic:[String:Int] = ["Jason":80, "Jay":95, "Jake":90]
var scoreDic:Dictionary<String, Int> = ["Jason":80]

scoreDic["Jason"] // => 80
scoreDic["Jenny"] // => nil -> dictionary에서 값 빼올 때 옵셔널 바인딩 쓰기

if let score = scoreDic["Jason"] {
	print(score)
} else { // 없으면
	//
}

메소드

scoreDic.isEmpty
scoreDic.count

업데이트

scoreDic["Jason"]=99

사용자 추가 & 제거

scoreDic["Jack"] = 30
scoreDic["Jack"] = nil

For loop로 아이템 확인

for (name, score) in scoreDic {
	print("\(name), \(score)")
}

key만 떼어보기

for key in scoreDic.keys{
	print(key) // cf. 고정된 순서 아님.
}

Set

중복이 없는 Unique한 item

var someArray:Array<Int> = [1,2,3,1] 
var someSet:Set<Int> = [1,2,3]

공통

someset.isEmpty
someset.count
someset.contains(4)
someset.contains(1)
someset.insert(5)
someset.remove(1)

Closure

이름 없는 메소드.
함수처럼 기능을 수행하는 코드블록의 특별한 타입.
함수는 Closure의 한가지 타입.

1. Global 함수
2. Nested 함수
3. Closure Expression

Function vs Closure

차이점)
이름 O vs 이름 X
func 키워드 필요 vs 필요 X
공통점)
인자 받을 수 있다.
값 리턴 가능
변수로 할당 가능
First Class Type (변수에 할당할 수 있다. 인자로 받을 수 있다. 리턴할 수 있다.)

Syntax

{(param) -> returnType in // in 앞에는 param, return / 뒤에는 state절
	statements
}

Example 1. 초심플 Closure

let chosimple = {

}
chosimple()

Example 2. 코드블럭을 구현한 Closure

let simple = {
	print("Hello")
}
simple()

Example 3. Input 파라미터를 받는 Closure

let simple:(String) -> () = { name in
	print("\(name)")
}
simple("corona")

Example 4. 값을 리턴하는 Closure

let simple:(String)->String = { name in
	let message = "ios개발 \(name)님 환영!")
    return message
}
let result = simple("lee")
print(result)

Example 5. Closure를 파라미터로 받는 함수 구현

func someSimpleFunction(choSimpleClosure:()->Void){
	print("함수에서 호출 되었다.")
    choSimpleClosure() // 파라미터 실행됨.
}
someSimpleFunction(choSimpleClosure:{
	print("hello") 
}) 

Example 6. Trailing Closure

마지막 인자가 클로저이면 생략 가능

func someSimpleFunction(message:String, choSimpleClosure:()->Void){
	print(message)
    choSimpleClosure()
}
someSimpleFunction(message:"안녕", choSimpleClosure:{
	print("호호")
})

를

someSimpleFunction(message:"안녕"){
	print("호호")
}

로 생략이 가능하다.

활용

2개의 수를 곱하는 closure

var multiplyClosure:(Int, Int) -> (Int) = {(a:Int, b:Int) 
	-> Int in return a*b
}

var multiplyClosure:(Int, Int) -> Int = {
	$0*$1
}

var multiplyClosure:(Int, Int) -> Int = {a, b in
	return a*b
}

let result = multiplyClosure(3, 5)

Function이 Closure를 갖는 경우

Function이 두 수를 받아 연산된 값을 리턴

//case1
func operateTwoNum(a:Int, b:Int, operation: (Int, Int)->Int) ->Int {
	let result = operation(a, b)
    return result
}
operateTwoNum(a:4, b:2, operation:mulplyClosure)

//case2
var addClosure:(Int, Int)->Int = { a, b in
	return a+b
}
operateTwoNum(a:4, b:2, operation:addClosure)

//case3
operateTwoNum(a:4, b:2){a, b in
	return a/b
}

Capturing Value

input, output 없는 함수

let voidClosure:()->() = {
	print("Hi")
}
voidClosure()

var count=0
let incrementer = {
	count+=1
}
incrementer()
incrementer()
print(count) // count => 2