Swift 1. 스위프트 여행

print("Hello, world!")

var myVariable = 42 // 변수
myVariable = 50
let myConstant = 42 // 상수

let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70 // 타입 명시

let label = "The width is "
let width = 94
let widthLabel = label + String(width)

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I habe \(apples + oranges) pieces of fruit."

var shoppingList = ["catfish", "water", "tulips"]
shoppingList[1] = "bottle of water"
 
var occupations = [
	"Malcolm": "Captain",
	"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

shoppingList.append("blue paint")
print(shoppingList)

let emptyArray: [String] = []
let emptyDictionary: [String: Float] = [:]

shoppingList = []
occupations = [:]

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
	if score > 50 {
		teamScore += 3
	} else {
		teamScore += 1
	}
}

var optionalString: String? = "Hello"
print(optionalString == nil)
 
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName { // nil 이 아니면
	greeting = "Hello, \(name)"
}

let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"

let vegetable = "red pepper"
switch vegetable {
    case "celery":
        print("Add some raisins and make ants on a log.")
    case "cucumber", "watercress":
        print("That would make a good tea sandwich.")
    case let x where x.hasSuffix("pepper"):
        print("Is it a spicy \(x)?")
    default:
        print("Everything tastes good in soup.")
}

let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (_, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)

var n = 2
while n < 100 { // 괄호 씌워도 됩니다.
    n *= 2
}
print(n)
 
var m = 2
repeat {
    m *= 2
} while m < 100
print(m)

var total = 0
for i in 0..<4 { // 또는 ... 을 사용하면 양쪽 다 포함됩니다.
    total += i
}
print(total)

func greet(person: String, dev: String) -> String {
	return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")
// 만약 argument parameter 인 person: 을 붙이지 않으면 에러가 발생합니다.

func greet(_ person: String, on day: String) -> String {
	return "Hello \(person), today is \(day)."
}
greet("Im", on: "수요일")

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
	var min = scores[0]
	var max = scores[0]
	var sum = 0
 
	for (score) in scores {
		if (score > max) {
			max = score
		} else if (score < min) {
			min = score
		}
		sum += score
	}
 
	return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9]) // argument label 꼭 넣어주고
print(statistics.sum) // 이름으로 가능하고
print(statistics.1) // 순서로도 가능하다! 0, 1, 2

func returnFifteen() -> Int {
	var y = 10
	func add() {
		y+= 5 // 포함하는 함수의 변수에 접근중
	}
	add()
	return y
}
returnFifteen()

func makeIncrementer() -> ((Int) -> Int) { // 함수 반환 한다고 명시, 괄호 안씌워도 되나 눈에 잘 띄려고 씌움
	func addOne(number: Int) -> Int {
		return 1 + number
	}
	return addOne // 함수 반환
}
let increment = makeIncrementer() // 함수를 참조중
increment(7)

func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
	for (item) in list {
		if (condition(item)) {
				return true
		}
	}
	return false
}
func lessThanTen(number: Int) -> Bool {
	return number < 10
}
var numbers = [29, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen) // 함수를 인자(argument) 로 사용중

numbers.map({ (number: Int) -> Int in  // arguments 와 return type
	let result = 3 * number // body
	return result // body
})

let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)

let sortedNumebrs = numbers.sorted {$0 > $1}
// 1. 이 경우 클로저의 (파라미터랑 반환 타입)을 아예 생략해버리고
// 2. closure 에 전달된 인자 조차 이름이 아닌 순서 번호로 참조해버리고
// 3. 클로저의 반환도 single statement 그 자체가 되어버리고
// 4. sorted 함수는 인자가 하나만 있기에 (하나만 있다는 것은 마지막인 것과도 같다)
//    괄호로 sorted 함수를 호출하는 방법에서
//    () 를 생략해버리고 closure 만 적어버리는 획기전이 방법을 사용하고 있다.

class Shape {
	var numberOfSides = 0
	func simpleDescription() -> String {
		return "A shape with \(numberOfSides) sides."
	}
}

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

class NamedShape {
	var numberOfSides: Int = 0
	var name: String
 
	init(name: String) {
		self.name = name // self 키워드
	}
 
	func simpleDescription() -> String {
		return "A shape with \(numberOfSides) sides."
	}
}

class Square: NamedShape {
	var sideLength: Double
 
	init(sideLength: Double, name: String) {
		self.sideLength = sideLength
		super.init(name: name)
		numberOfSides = 4
	}
 
	deinit() {
		// 여기는 object 가 메모리에서 deallocated 되기 직전에 실행됩니다.
	}
 
	func area() -> Double {
		return sideLength * sideLength
	}
 
	override func simpleDescription() -> String {
		return "A square with sides of length \(sideLength)."
	}
}
let test: Square? = Square(sideLength: 5.2, name: "my test square")
test?.area()
test?.simpleDescription()
test = nil

class EquilateralTriangle: NamedShape {
	var sideLength: Double = 0.0
 
	init(sideLength: Double, name: String) {
		self.sideLength = sideLength
		super.init(name: name) // argument label 꼭 적어주고
		numberOfSides = 3
	}
 
	var perimeter: Double {
		get {
			return 3.0 * sideLength
		}
		set {
			self.sideLength = newValue / 3.0
		}
	}
 
	override func simpleDescription() -> String {
		return "An equilateral triangle with sides of length \(sideLength)."
	}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)

class TriangleAndSquare {
	var triangle: EquilateralTriangle {
		willSet {
			square.sideLength = newValue.sideLength
		}
	}
	var square: Square {
		willSet {
			triangle.sideLEngth = newValue.sideLength
		}
	}
	init(size: Double, name: String) {
		square = Square(sideLength: size, name: name)
		triangle = EquilateralTriangle(sideLength: size, name: name)
	}
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.square.sideLength) // 사각형 50 으로 바꾸면? 삼각형 길이도 50으로~

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
if let sideLength = optionalSquare?.sideLength {
    print(sideLength)
}

enum Rank: Int {
    case ace = 1
    case two, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king
 
    func simpleDescription() -> String {
        switch self {
            case .ace:
                return "ace"
            case .jack:
                return "jack"
            case .queen:
                return "queen"
            case .king:
                return "king"
            default:
                return String(self.rawValue)
        }
    }
}
let ace = Rank.ace
let aceRawValue = ace.rawValue

if let convertedRank = Rank(rawValue: 3) {
	let threeDescription = convertedRank.simpleDescription()
}

enum Suit { // 타입이 없는 경우
    case spades, hearts, diamonds, clubs
 
    func simpleDescription() -> String {
        switch self {
            case .spades: // 두번째 방법
                return "spades"
            case .hearts:
                return "hearts"
            case .diamonds:
                return "diamonds"
            case .clubs:
                return "clubs"
        }
    }
}
let hearts = Suit.hearts // 첫번째 방법
let heartsDescription = hearts.simpleDescription()

enum ServerResponse {
	case result(String, String)
	case failure(String)
}
 
let success = ServerResponse.result("6:00 am". "8:09 pm")
let failure = ServerReponse.failure("Out of cheese.")
 
switch sueccess {
	case let .result(sunrise, sunset):
		print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
	case let .failure(message):
		print("Failure... \(message)")
}

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

protocol ExampleProtocol {
	var simpleDescription: String { get }
	mutating func adjust() // 돌연변이 함수
}

class SimpleClass: ExampleProtocol {
     var simpleDescription: String = "A very simple class."
     var anotherProperty: Int = 69105
     func adjust() {
          simpleDescription += "  Now 100% adjusted."
     }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
 
struct SimpleStructure: ExampleProtocol {
     var simpleDescription: String = "A simple structure"
     mutating func adjust() {
          simpleDescription += " (adjusted)"
     }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

extension Int: ExampleProtocol { // Int 타입에 extension 으로 프로토콜을 추가
	var simpleDescription: String {
		return "The number \(self)"
	}
	mutating func adjust() {
		self += 42
	}
}
print(7.simpleDescription)

let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty)  // Uncomment to see the error

enum PrinterError: Error {
	case outOfPaper
	case noToner
	case onFire
}

func send(job: Int, toPrinter printerName: String) throws -> String {
	if printerName == "Never Has Toner" {
		throw PrinterError.noToner
	}
	return "Job sent"
}

do {
	let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
	print(printerReponse)
} catch {
	print(error) // 자동으로 주어진 이름
}

do {
	let printerReponse = try send(job: 1440, toPrinter: "Gutenberg")
	print(printerReponse)
} catch PrinterError.onFire {
	print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
	print("Printer error: \(printerError).")
} catch {
	print(error)
}

let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")

var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]
 
func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true // 설정코드
    defer { // clean up 코드
        fridgeIsOpen = false
    }
 
    let result = fridgeContent.contains(food)
    return result
}
fridgeContains("banana")
print(fridgeIsOpen)

func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
	var result: [Item] = []
	for _ in 0..<numberOfTimes { // 1...numberOfTimes 랑 동일
		result.append(item)
	}
	return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

// 스위프트의 optional 타입을 구현해본다
enum OptionalValue<Wrapped> {
	case none
	case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Element: Equatable, T.Element == U.Element
{
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true // 하나라도 같은 걸 확인 한 순간, 반환
            }
        }
    }
   return false
}
anyCommonElements([1, 2, 3], [3])