4. Numeric_1

var myScore: UInt = 50

myScore = 50

var myScore1: UInt8 = 200

200이라는 값의 2진수 값을 알고 싶을 경우!!

String(myScore1, radix: 2(2진수여서), uppercase: false(true/ false 아무거나 ok))

String(myScore1, radix: 2, uppercase: false)

uppercase : true // 16진수 표현하고자 할 때 대문자로 표현

uppercase : false // 16진수 표현하고자 할 때 소문자로 표현

Int8.max // 127

Int8.min // -128

UInt8.max // 255

UInt8.min // 0

// bit (binary, 2진수) 0 -> 1 -> 10

// 3bit 000 -> 111

// 4bit 0000 -> 1100

// 8bit 00000000 -> 11111111

5. Numeric_2

var myScore = 1_000_000 // 숫자 중간에 언더바 사용 가능, 시각적으로 보기 편함

var myBit = 00010001 // 이대로 쓰면 10001만 인식

00010001라는 2진수로 인식하게 하려면?

var myBit = 0b00010001 // 앞에 0b를 쓴다! 17이 저장됨

var myBit = 0b0001_0001_1111 // 이때도 사용 가능

그럼 8진수는? -> 0o (0-7까지의 숫자만 사용 가능)

var myBit = 0o10 // 8

그럼 16진수는? -> 0x

var myBit = 0xf // 15

var myBit = 0x10 // 16

// reminder %

var anyNumber = 9

if (anyNumber % 2 == 0) {

// 짝수

} else {

// 홀수

}

var number1 = 0.7

var number2 = 0.2

var sum = number1 + number2 // 0.89999999가 나옴, 0.9X

WHY?

0.7, 0.2도 2진수로 바뀌어서 계산되기 때문에 0.1101001010 + 0.11010001001

2진수 소수 계산 검색하여 알아보기

0.9가 나오려면 어떻게 계산해?

--> Decimal // 일반적으로 우리가 사용하는 0부터 9까지의 숫자 체계대로 계산하여 나타나게 해줌

따라서 Decimal(sum)을 하면 0.9가 나옴

6. Array_1

Swift는 Array, Set, Dictionary 세 가지 Collection Type이 있음

Collection Type이란, 데이터의 묶음, 데이터의 집합 느낌

// Int Array

var numbers1 = [4, 5, 10, 23, 0, 4, 3, 2, 1]

var numbers2: [Int] = [4, 5, 10, 23, 0, 4, 3, 2, 1]

var numbers3: Array<Int> = [4, 5, 10, 23, 0, 4, 3, 2, 1]

// 1 ~ 5

var numbers4 = Array<Int>(1...5)

var numbers5 = [Int](1..5)

// 1, 1, 1, 1, 1

var numbers6 = Array(repeating: 1, count: 5)

// String Array

var strings = ["lee", "kim"]

// Any Array

var anyArray: [Any] = [0, "lee"] // 타입이 여러 개 있을 때 Any타입 사용. but, swift 성격과 맞지는 않음, 안 쓸 수 있으면 안 쓰는 게 좋음

// empty Array - 타입을 꼭 명시해야 함. 네 가지 모두 같은 의미

var emptyArray1: [String] = [] // String 타입의 빈 배열 만들어짐

var emptyArray2: [String] = Array() // 인스턴스화 한 것 -> 그래야 메모리에 올라가 사용 가능

var emptyArray3 = Array<String>()

var empryArray4 = [String]()

7. Array_2

// add

var numbers10 = [4, 5, 10, 23, 0, 4, 3, 2, 1]

var numbers11 = [100, 200, 300]

numbers10.insert(contentsOf: numbers11, at: 1) // 중간에 삽입, [4, 100, 200, 300, 5, 10, 23, 0, 4, 3, 2, 1]

numbers10.append(contentsOf: numbers11) // 끝에 삽입, [4, 100, 200, 300, 5, 10, 23, 0, 4, 3, 2, 1, 100, 200, 300]

numbers10.append(100) // [4, 100, 200, 300, 5, 10, 23, 0, 4, 3, 2, 1, 100, 200, 300, 100]

numbers10.insert(500, at: 0) // [500, 4, 100, 200, 300, 5, 10, 23, 0, 4, 3, 2, 1, 100, 200, 300, 100]

numbers10.insert(1000, at: 5) // [500, 4, 100, 200, 300, 1000, 5, 10, 23, 0, 4, 3, 2, 1, 100, 200, 300, 100]

// remove

var numbers20 = [4, 5, 10, 23, 0, 4, 3, 2, 1]

let removeNumber = numbers20.remove(at: 4) // 삭제 된 값이 리턴되어 removeNumber에 저장

numbers20.removeFirst()

numbers20.removeLast()

numbers20.removeFirst(2) // 앞에 두 개 삭제

numbers20.removeLast(2) // 뒤에 두 개 삭제

// replace

var numbers30 = [4, 5, 10, 23, 0, 4, 3, 2, 1]

// read

numbers30.last // 마지막 인덱스의 값 읽어옴

let lastIndex = numbers30.count - 1

numbers30[lastIndex]

8. Set_1

Set은 순서도 없고, 인덱스도 없음, 중복 허용 안됨

Array는 순서대로 접근 할 때 사용

// Set type

var number1: Set = [1,2,3,4,5] // {4, 3, 1, 5, 2}

var number2: Set<Int> = [1,2,3,4,5] // {2, 5, 4, 3, 1}

var number3 = Set([1,2,3,4,5]) // {1, 4, 2, 3, 5}

// empty Set

var numbers4 = Set<Int>()

var numbers5 : Set<Int> = []

// add

numbers1.insert(100) // (inserted true, memberAfterInsert 100)

numbers1.insert(100) // (inserted false, memberAfterInsert 100)

true와 false 값만 얻고 싶다면?

numbers1.insert(100).inserted // true

numbers1.insert(100).inserted // false, 중복 허용되지 않기 때문에

// 덮어쓰기, update는 무조건 넣는 것,

numbers1.update(with: 100) // 기존에 그 값이 있는지 없는지 값으로 알려줌, 100을 넣으려고 했는데 기존에 100이 있었다는 것을 보여줌

numbers1.update(with: 1000) // 기존 값은 없다라는 것이 nil로 표시됨, nil은 아무것도 없다는 의미, 이 값은 numbers1에 들어감

// remove

numbers1.remove(50) // 50이란 값이 numbers1에 없으므로 nil로 표시

numbers1.remove(100) // 100

numbers1 // {3, 1000, 1, 2, 5, 4}

내부적으로는 Set도 순서를 가지고 있다!!

numbers1.firstIndex(of: 1000) // 1000의 인덱스 값 가져오기

let setIndex = numbers1.firstIndex(of: 1000) // Set<Int>.index // numbers에 1000이 있으므로 1000의 index값이 setIndex에 저장

numbers1.remove(at: setIndex!) // !(느낌표) 꼭 써야함, 이유는 나중에 설명

9. Set_2

let numbers1: Set = [1,2,3,4,5]

let numbers2: Set = [4,5,6,7,8]

// 합집합

numbers1.union(numbers2) // {4,1,3,5,7,8,2}

// 교집합

numbers.intersection(numbers2) // {4,5}

// 대칭차집합 (합집합-교집합)

numbers1.symmetricDifference(numbers2) // {1,3,2,7,8,6}

// 여집합

numbers1.subtracting(numbers2) // {1,3,2} // numbers1에서 numbers2와 겹치는 원소 제외하고 나열

numbers2.subtracting(numbers1) // {7,9,8} // numbers2에서 numbers1과 겹치는 원소 제외하고 나열

// 한 쪽에 모두 포함 여부

let numbers3: Set = [1,2,3,4,5]

let numbers4: Set = [1,5]

numbers3.isSubset(of: numbers4) // numbers3의 원소들이 numbers4에 포함되어 있는가? --> false

numbers4.isSubset(of: numbers3) // numbers4의 원소들이 numbers3에 포함되어 있는가? --> true

numbers3.isSuperset(of: numbers4) // numbers4의 원소들이 numbers3에 포함되어 있는가? --> true

numbers4.isSuperset(of: numbers3) // numbers3의 원소들이 numbers4에 포함되어 있는가? --> false

// 한 쪽에 모두 불포함 여부

let numbers5: Set = [1,2,3,4,5]

let numbers6: Set = [6,7]

numbers5.isDisjoint(with: numbers6) // numbers5와 numbers6는 중복되어 있는 값이 하나도 없는가? --> true

let numbers5: Set = [1,2,3,4,5]

let numbers6: Set = [6,7,5]

numbers5.isDisjoint(with: numbers6) // numbers5와 numbers6는 중복되어 있는 값이 하나도 없는가? --> false

10. Counted Set

// NSCountedSet : 타입의 한 종류, 중복되서 누적되는 카운팅 개수를 셀 때 사용

let colors: NSCountedSet = ["red", "orange", "blue"]

colors.count(for: "red") // 1

colors.add("red") // {"red", "orange", "blue"}

colors.count(for: "red") // 2

colors.add("red") // {"red", "orange", "blue"}

colors.count(for: "red") // 3

11. Dictionary

key - value

Set과 같이 순서가 없음, key 중복 허락x, value는 중복 가능

// 생성

// empty

let names1 = Dictionary<String, String>() // [:]

let names2 = [String : String]() // [:]

let names3: [String : String] = [:] // [:]

var names4 = ["cityA" : "Seoul" , "cityB" : "La"]

names4.count // 2

names1.isEmpty / true

// 직접 입력 추가

names4["cityC"] = "tokyo"

names4["cityD"] = "baijing"

names4.updateValue("Busan", forKey: "cityE")

names3["cityE"] = "incheon"

names3["cityF"] = "SF"

// Dictionary + Dictionary, cityE가 중복되므로 return 값에 따라 한쪽 cityE는 지워짐

let mergingDic = names3.merging(names4) { leftValue, rightValue in return letfValue}

// leftValue, rightValue는 개발자가 임의로 지은 이름. 보통은 current, new으로 씀, leftValue는 names3를, rightValue는 names4를 의미

// return letfValue하면 names3에 있는 cityE : incheon이 남음

// return rightValue하면 names4에 있는 cityE : Busan이 남음

// 삭제

names3 // ["cityE" = "incheon"], ["cityF" = "SF"]

names3["cityF"] = nill

names3.removeValue(forKey: "cityF")

// 두 개 같은 의미

names3 // ["cityE" = "incheon"]

// 업데이트

names3["cityE"] = "hawaii"

12. Tuple

Tuple은 ()안에 들어 있음, 삭제, 추가할 수 없음

var someTuple1 = (100, "kim", false)

someTuple을 타입 추론하면 someTuple: (Int, String, Bool)

==> 첫 번째 값은 Int, 두 번째 값은 String, 세 번째 값은 Bool 타입의 값이 들어가야 함

// 생성

var someTuple2 = (score : 100, userName : "kim", isShowName : false)

var someTuple3: (String, Int) = ("lee", 50)

// 조회

someTuple.0 // 100

someTuple2.score // 100

let (score, name, isShowName) = someTuple1 // let 대신 var도 사용 가능

score // 100

name // "kim"

isShowName // false

// 업데이트

someTuple2.score = 50 // 50

someTuple2 // (score : 50, userName : "kim", isShowName : false)