SWIFTデフォルト構文#2

//Int 타입의 빈 Array 생성
var integers: Array<Int> = Array<Int>()

//Array<Int> == [Int]
var integers: Array<Int> = [Int]()

var integers: [Int] = [Int]()

//[]는 새로운 빈 Array
var integers: [Int] = []

var integers: Array<Int>  = Array<Int>()

var integers: Array<Int> = [Int]()
var integers: Array<Int> = []
var integers: [Int] = []
var integers = [Int]()

let immutableArray = [1, 2, 3]

//append나 remove같은 메소드 사용 불가

.append(1)
.contains(100)
.remove(at: 0)
.removeLast()
.removeAll()
.count

//없는 인덱스에 접근하려고 하면 프로그램 강제 종료
//integers[0], integers[99] = 99 

//Key - String타입, Value - Any타입인 빈 Dictionary 생성
var anyDictionary: Dictionary<String, Any> = [String: Any]()

//[:]는 빈 딕셔너리를 나타낸다
var emptyDictionary: [String: Any] = [:]

anyDictionary["somekKey"] = "value" //딕셔너리에 "someKey": "value" 추가
anyDictionary["anotherKey" = 100    //딕셔너리에 "anotherKey": 100 추가

var anyDictionary: Dictionary<String, Any> = Dictionary<String, Any>()

var anyDictionary: Dictionary<String, Any> = [:]
var anyDictionary: [String: Any] = [String: Any]()
var anyDictionary: [String: Any] = [:]
var anyDictionary = [String: Any]()

let initalizedDictionary: [String: String] = ["name": "sujilee", 
"height": "169.2"] 

.removeValue(forkey: "anotherKey")

//Error!
let someValue: String = initializedDictionary["name"]

//이건 왜 안될까? someValue에 "sujilee"가 담겨야하는 것 아닌가?
//"name" 키에 해당하는 값이 없을 수도 있으므로 String 타입의 값이 나올거라 보장 못함
//nil이 나오면 어쩔건데? 컴파일 오류 발생

var integers: Set<Int> = Set<Int>()

integers.insert()
integers.contains()
integers.remove()
integers.removeFirst()

integers.count

import Foundation

var anyDictionary: Dictionary<String, Any> = [String: Any]()

let setA: Set<Int> = [1, 2, 3, 4, 5]
let setB: Set<Int> = [3, 4, 5, 6, 7]

//union() 메소드로 합집합 구하기
let union: Set<Int> = setA.union(setB)

//sorted() 메소드로 집합 정렬시켜 오름차순 String 배열로 만들기
let sortedUnion: [Int] = union.sorted()

//intersection() 메소드로 교집합 구하기
let intersection: Set<Int> = setA.intersection(setB)

//subtracting() 메소드로 차집합 구하기 (setA - setB)
let subtracting: Set<Int> = setA.subtracting(setB)

import Foundation

// for item in items {
//      code
// }

var integers = [1, 2, 3]
let people = ["sujilee": 1206, "kchoi": 1127, "pol": 1101]

for integer in integers {
    print(integer);
}

//Dictionary의 item은 key와 value로 구성된 튜플 타입
for (name, age) in people {
    print("\(name): \(age)")
}

import Foundation

//while condition {
//  code
//}

var integers = [1, 2, 3]
let people = ["sujilee": 1206, "kchoi": 1127, "pol": 1101]

//한개 남기고 뒤에서부터 반복 삭제
while integers.count > 1 {
    integers.removeLast()
}
print (integers)

import Foundation

//repeat {
//  code
//} while condition

var integers = [1, 2, 3]
let people = ["sujilee": 1206, "kchoi": 1127, "pol": 1101]

//일단 한 번 맨 뒤 요소를 제거하고, 전부 사라질때까지 반복하라.
repeat {
    integers.removeLast()
} while integers.count > 0

print(integers)

import Foundation

//기본값을 갖는 매개변수는 매개변수 목록 중 뒤쪽에 위치하는 것이 좋음

//매개변수 me를 기본값으로 갖는 함수
func greeting (friend: String, me: String = "sujilee") {
    print("Hello \(friend) it's me, \(me)!")
}

//함수 호출 시 매개변수 생략 가능
greeting(friend: "kchoi")
//물론 원하는 인자도 넘길 수 있다
greeting(friend: "kchoi", me: "suji")

import Foundation

//매개변수 이름 앞에 전달인자 레이블을 표시한다
//함수 구현 시, 함수 내부에서는 매개변수 이름을 사용
func greeting(to friend: String, from me: String) {
    print("Hello \(friend) it's me, \(me)!")
}

//함수 호출 시, 함수 외부에서는 전달인자 레이블 사용
greeting(to: "sean", from: "suji")

import Foundation

func sayHelloToFriends(me: String, friends: String...) -> String {
    return "Hello \(friends) it's \(me)!"
}

print(sayHelloToFriends(me: "suji", friends: "kcho", "sean", "joockim"))
//OUTPUT : Hello ["kcho", "sean", "joockim"] it's suji!

import Foundation

func greeting(to friend: String, from me: String) {
    print("Hello \(friend) it's me, \(me)!")
}

//변수 someFunction에, (Sting, Sting)을 매개변수로 가지고 Void를 반환하는 함수 할당
//조건에 일치하는 greeting 함수를 할당할 수 있다.
var someFunction: (String, String) -> Void = greeting(to:from:)

//매개변수의 타입이 같아야함
someFunction = greeting(to:from:)
someFunction("sujilee", "jseo")
//OUTPUT : Hello suji it's me, jseo!

//함수의 매개변수로, (String, String)을 매개변수로 가지고 Void를 반환하는 함수를 받음
func runAnother(function: (String, String) -> Void) {
    function("suji", "lea")
}

//runAnother 함수의 매개변수로 조건에 부합하는 greeting함수 넘김.
//greeting함수의 인자는 이미 runAnother 함수 내부에서 지정해놓음
runAnother(function: greeting(to:from:))
//OUTPUT : Hello suji it's me, lea!
runAnother(function: someFunction)
//OUTPUT : Hello suji it's me, lea!

true && false == false
true && true == true
true || false == true
true || true == true

//옵션 선택지 전달 예시

import Foundation

let apple: Int = 1
let orange: Int = 2
let banana: Int = 4

func printFavoriteFruits(_ selectedFruits: Int) {
    print("사과를 좋아함 : \((selectedFruits & apple) != 0)")
    print("오렌지를 좋아함 : \((selectedFruits & orange) != 0)")
    print("바나나를 좋아함 : \((selectedFruits & banana) != 0)")
}

printFavoriteFruits(apple | orange)
//apple | orange == 0001 | 0010 == 0011

let 진동모드  = 1 // 0001
let 비행기모드 = 2 // 0010
let 와이파이 = 4 // 0100

let 현재모드 = 진동모드 | 비행기모드 // 0011

import Foundation

//Dish라는 타입으로 dish 매개변수의 타입을 제한
enum Dish {
    case rice, noodle, soup
}

//Dish에서 정의한 선택지 외에는 dish 매개변수의 인자로 전달할 수 없음
func choose(dish: Dish) {
    print("\(dish)를 골랐군요!")
}

choose(dish: Dish.rice)
//dish에 전달하는 인자는 Dish 타입이 분명하므로 타입 이름 생략, .뒤에 케이스만 적어도 ok
//이런걸 타입추론이라고 하는데, 초보자는 쓰지마라!
choose(dish: .rice)

//아래와 같은 표현 모두 가능

enum Dish {
	case rice
	case noodle
	case soup
}

enum Dish {
	case rice, noodle
	case soup
}

import Foundation

//원시값(rawValue) 사용 : 각 case별로 고유한 값 지정
enum Dish: String {
    case rice = "밥", noodle = "면", soup = "스프"
}

func choose(dish: Dish) {
    print("\(dish.rawValue)를 골랐군요!")
}

choose(dish: Dish.rice)
//OUTPUT : 밥을 골랐군요!

import Foundation

enum Bearings: String {
    case east = "동"
    case west = "서"
    case south = "남"
    case north = "북"
}

func navigateBearings(bearings: Bearings) {
    print("\(bearings.rawValue)쪽으로 가십시오")
}

navigateBearings(bearings: Bearings.east)

let someInteger = 100

if someInteger < 100 {
    print("100 미만")
} else if someInteger > 100 {
    print("100 초과")
} else {
    print("100")
}
	

import Foundation

//switch value {
//case pattern:
//    code
//default:
//    code
//}

let someInteger = 100

switch someInteger {
case 0:
    print("zero")
//1 이상 100 미만
case 1..<100:
    print("1~99")
case 100:
    print("100")
case 101...Int.max:
    print("over 100")
default:
    print("unknown")
}

switch "sujilee" {
case "kchoi", "sean":
		print("kchoi or sean")
case "joockim"
		print("joockim")
default:
	print("unknown")
}

switch "sujilee" {
case "kchoi":
		print("kchoi or sean")
		fallthrough
case "jseo"
		print("kchoi or sean")
case "joockim"
		print("joockim")
default:
	print("unknown")
}

import Foundation

var optionalValue: Int! = 100

switch optionalValue {
case .none:
    print("This Optional variable is nil")
case .some(let value):
    print("Value is \(value)")
}

//기존 변수처럼 사용 가능
optionalValue = optionalValue + 1

//nil 할당 가능
optionalValue = nil

//잘못된 접근으로 인한 런타임 오류 -> nil에 어떻게 + 1을 하냔 말이야
optionalValue = optionalValue + 1

func printName(_ name: String) {
		print(name)
}

var myName: String? = nil

//컴파일 에러 발생
printName(myName) //Error! : 전달되는 값의 타입이 다르기 때문에

import Foundation

func printName(_ name: String) {
    print(name)
}

var myName: String! = nil

if let name: String = myName {
    printName(name)
} else {
    print("myName == nil")
}

// name 상수는 if-let 구문 내에서만 사용 가능

//컴파일 오류 발생 - 상수 사용범위를 벗어남
printName(name) //Error!

import Foundation

var myName: String? = "sujilee"
var yourName: String? = nil

//name과 friend 모두 값이 있어야(nil이 아니어야) print가 실행됨
if let name = myName, let friend = yourName {
    print("\(name) and \(friend)")
}
//yourName이 nil이라 실행되지 않음

yourName = "sean"

if let name = myName, let friend = yourName {
    print("\(name) and \(friend)")
}
//sujilee and sean

import Foundation

func printName(_ name: String) {
    print(name)
}

var myName: String? = "suijlee"

//!를 붙이면 옵셔널타입인 myName의 값을 강제로 추출해낸 값이라는 뜻
printName(myName!) // 옵셔널 타입인 myName 안의 String 타입의 "sujilee"가 담김
//OUTPUT : sujilee

myName = nil

//런타임 오류 발생
print(myName!) //Error! : 강제추출 시 값이 없으므로 오류

//처음부터 강제추출되는 효과를 가짐 -> 위에 인자로 넘긴 myName!와 같은 의미
var yourName: String! = nil

//런타임 오류 발생
printName(yourName) //Error! : 강제추출 시 값이 없으므로 오류

import Foundation

var someDictionary: [String: String] = [:]
//day(of: today)는 예시를 위해 있다고 가정하자
let day: Int = day(of: today)

if day == 1 || day == 30 {
    someDictionary["날씨"] = "맑음"
} else {
    someDictionary["풍향"] = "남동풍"
}

//이 시점에 "날씨" 키에 해당하는 값이 항상 존재한다고 장담할 수 있을까?