✏️ 강의 필기

👩‍💻 foreach

import UIKit

var myArray : [Int] = [0,1,2,3,4,5,6,7,8,9,10]

//foreach
for i in myArray {
    print("item: \(i)")
}
for i in myArray where i > 5 {
    print("5보다 큰 수 : \(i)")
}
for i in myArray where i%2==0 {
    print("짝수: \(i)")
}
for i in myArray where i%2 != 0 {
    print("홀수: \(i)")
}

👩‍💻 enum

• 타입을 나누는 것

import UIKit

enum School {
    case elementy, middle, high
}

let yourSchool = School.elementy
print("yourSchool : \(yourSchool)")
//print("yourSchool: ",yourSchool)

enum Grade: Int {
    case first = 1
    case second = 2
}

let yourGrade = Grade.second.rawValue //enum이 가지고 있는 값을 가져올 때 (rawValue)
print("yourGrade: \(yourGrade)")
//let yourGrade = Grade.second
//print("yourGrade: \(yourGrade.rawValue)") 

enum SchoolDetail {
    case elementary(name: String) //elementary case를 지정할 때 데이터를 정할 수 있다.
    case middle(name: String)
    case high(name: String )
    
    func getName() -> String { // -> 리턴의 뜻
        switch self {
        case .elementary(let name): //let 두 가지 형태
            return name
        case let .middle(name):
            return name
        case let .high(name):
            return name
        }
    }
}

let yourHighSchoolName = SchoolDetail.high(name: "nang")
print("yourHighSchoolName: \(yourHighSchoolName)") 
//yourHighSchoolName: high(name: "nang")
print("yourHighSchoolName: \(yourHighSchoolName.getName())")
//yourHighSchoolName: nang

👩‍💻 for 반복문

import UIKit

//0...5
//0,1,2,3,4,5
for i in 0...5 {
    print("호호 i: \(i)")
}

//0..<5
//0,1,2,3,4
for i in 0..<5 {
	print("호호 i: \(i)")
}

for i in 0..<5 where i%2==0 {
    print("호호 i: \(i)")
}

var randomInts: [Int] = [] //빈 배열 만들기
//var randomInts : [Int] = [Int]()

for _ in 0..<25 {
    let randomNumber = Int.random(in: 0...100) //랜덤숫자의 범위 지정
    randomInts.append(randomNumber)
}
print("randomInts: \(randomInts)")

👩‍💻 Unwrap 옵셔널 변수

import UIKit

//옵셔널 :값이 있는지 없는지 모르는 상태
//'Int? = nil'은 값이 확실하게 비어있는 상태
var someVariable : Int?

if someVariable == nil {
    someVariable = 90 
}
print("someVariable: \(someVariable)")
//값이 들어가긴 했지만 someVariable은 원래 옵셔널 상태이기 때문에 항상 옵셔널이라고 붙어 값이 출력된다.

//언랩핑 :감싸져 있는 것을 벗기는 것
//1) if let
if let otherVariable = someVariable {
//만약 someVariable에 값이 있으면 otherVariable(Optional 아님)에 넣어서 사용하겠다는 의미
    print("값이 있다(언랩핑 되었다). otherVariable: \(otherVariable)")
} else {
    print("값이 없다.")
}

someVariable = nil

//someVariable이 비어있다면, 기본값 설정
let myValue = someVariable ?? 10
print("myValue: \(myValue)")

var firstValue: Int? = 30
var secondValue: Int? = 150

print("firstValue: \(firstValue)") //firstValue: Optional(30)
print("secondValue: \(secondValue)") //secondValue: Optional(150)

unwrap(firstValue) 
//unwrap() called
//unWrappedParam: 30 
unwrap(secondValue)
 
//2) guard let
func unwrap(_ parameter: Int?){
    print("unwrap() called")
    guard let unWrappedParam = parameter else {return} //값이 없으면 리턴
    print("unWrappedParam: \(unWrappedParam)")
}

👩‍💻 class & struct

struct는 복사한 것 -> clone의 값을 변경해도 original 구조체의 값 변화 x
class는 서로 연결 -> clone의 값을 변경하면 original 클래스의 값도 변화 (clone은 original의 참조)

//struct - 유튜버(데이터)모델
struct YoutuberStruct {
    var name : String
    var subscriberCount : Int
}

var devJeong = YoutuberStruct(name: "정나영", subscriberCount: 1)
var devJeongClone = devJeong
print("devJeongClone.name: \(devJeongClone.name)")

devJeongClone.name = "정다영"
print("devJeongClone.name: \(devJeongClone.name)")
print("devJeong.name: \(devJeong.name)")
 

//class
class YoutuberClass {
    var name : String
    var subscriberCount : Int
    //생성자 - 메모리에 올림
    //매개변수를 가진 생성자 메소드를 만들어야 (매개변수를 가진)객체(object) 생성 가능
    init(name:String, subscriberCount: Int){
        self.name = name
        self.subscriberCount = subscriberCount
    }
}

var devNang = YoutuberClass(name: "정나영", subscriberCount: 1)
var devNangClone = devNang
print("devNangClone.name: \(devNang.name)")

devNangClone.name = "정다영"
print("devNangClone.name: \(devNangClone.name)")
print("devNang.name: \(devNang.name)")

👩‍💻 property observer

var myAge = 0 {
    willSet {
        print("값이 설정될 예정이다. myAge: \(myAge)")
    }
    didSet {
        print("값이 설정되었다. myAge: \(myAge)")
    }
}

myAge = 10
myAge = 20

👩‍💻 함수 매개변수 이름

/*
 일반적으로 매개변수가 있는 함수를 정의할 때 변수의 이름을 정해주는데, 
 이름을 바꾸고 싶을 때에는 myFunction2처럼 앞에 다른 이름을 넣어주면 되고, 
 아예 생략하고 싶을 때에는 myFunction3처럼 _를 쓰고, 함수 호출할 때에는 ""만!
 */

//함수 정의
func myFunction(name: String) -> String{
    return "안녕하세요! \(name) 입니다"
}

//함수 호출
myFunction(name: "정나영")

//함수 정의
func myFunction2(with name: String) -> String{
    return "안녕하세요! \(name) 입니다"
}

//함수 호출
myFunction2(with: "정여미")

func myFunction3(_ name: String) -> String{
    return "안녕하세요! \(name) 입니다"
}

myFunction3("정주니")

👩‍💻 제네릭

제네릭은 어떠한 형태든지 받을 수 있다.

struct myArray<SomeElement> {
    //제네릭을 담은 빈 배열
    var elements : [SomeElement] = [SomeElement]()
    
    //생성자
    init(_ elements : [SomeElement]) {
        self.elements = elements
    }
    
}

struct Friend {
    var name : String
}

struct PpakCoder {
    var name : String
}

var mySomeArray = myArray([1,2,3])
print("mySomeArray: \(mySomeArray)")

var myStringArray = myArray(["가","나","다"])
print("myStringArray: \(myStringArray)")

let friend_1 = Friend(name: "낭")
let friend_2 = Friend(name: "당")
let friend_3 = Friend(name: "쭌")

var myFriendArray = myArray([friend_1,friend_2,friend_3])
print("myFriendArray: \(myFriendArray )")

👩‍💻 클로저 (closure)

• 코드 안에서 전달되어 사용할 수 있는 로직을 가진 코드의 블럭
• 함수는 클로저의 일종 (이름이 있는 클로저)

//String을 반환하는 클로저
let myName : String = {
    return "정나영"
}()
print(myName)

//클로저 정의
let myRealName : (String) -> String = { (name:String) -> String in
    return "코딩 무당벌레 \(name)"
}
myRealName("정나영")

let myRealNameLogic : (String) -> Void = { (name: String) in
    print("개발하는 \(name)")
}
myRealNameLogic("무당벌레")

👩‍💻 매개변수로의 클로저(closure)