nemo._.log

날씨 앱 만들기

Fri, 03 Jan 2025 02:19:50 GMT

날씨 앱 만들기

URLSession 을 이용해서 서버에서 날씨 데이터를 가져와 띄우는 간단한 날씨 앱을 개발해봅니다.

아래 데이터들을 화면에 노출합니다.

현재 기온
최소 기온
최고 기온
날씨 이미지
UITableView 를 사용한 5일 간 예보

간단한 날씨 앱을 개발하기 위한 공부들을 해봅시다.

Open Weather API

Open Weather API

Open 소스 API 란 모두가 사용할 수 있게 공공적으로 열어놓은 API 를 말합니다.
Open 소스 API 중 날씨 데이터를 제공하는 Open Weather API 를 사용합니다. 링크텍스트

(1) 회원 가입

Open Weather API 를 사용 하기 위해, 먼저 회원가입을 해야합니다.

API 사용 목적을 설문 상 물어볼텐데 적당히 값을 입력하고 회원가입 완료.

회원가입이 완료되면 My API Keys 에서 API Key 를 확인 가능.
API Key 란 API 명세에 넣어야하는 고유한 값.

(2) API 파악

Guide 로 가서 API 가이드 읽어보기

현재 날씨 API
- https://openweathermap.org/current
Current Weather Data 항목을 보면, 현재 날씨를 가져오는 API 명세가 가이드 되어있음.

https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={API key}&units=metric

? 뒤의 key-value 는 쿼리 파라미터.
5일간 날씨 예보 API
- https://openweathermap.org/forecast5
- 5일간 3시간 간격으로 날씨 예보 데이터 API.

URLSession 으로 날씨 앱 만들기

💻 URLSession 을 사용해서 날씨 데이터를 불러와 띄워봅시다.

https://openweathermap.org/current

API 명세를 파악하고, JSON 데이터를 가져오기 위한 Codable 구조체를 선언합니다.
URLSession 의 URL 에 사용할 API 의 URL 주소를 입력합니다.
URLSession.dataTask 를 통해 네트워크 통신을 수행하고, 성공적으로 데이터를 받아왔다면 데이터를 뷰(UILabel, UITableView)에 적용합니다.

- CurrentWeatherResult.swift

import Foundation

struct CurrentWeatherResult: Codable {
    let weather: [Weather]
    let main: WeatherMain
}

struct Weather: Codable {
    let id: Int
    let main: String
    let description: String
    let icon: String
}

struct WeatherMain: Codable {
    let temp: Double
    let temp_min: Double
    let temp_max: Double
    let humidity: Int
}

- ViewController.swift

import UIKit
import SnapKit

class ViewController: UIViewController {

    // 테이블 뷰에 넣을 데이터 소스.
    private var dataSource = [ForecastWeather]()

    // URL 쿼리에 넣을 아이템들
    // 서울역 위경도
    private let urlQueryItems: [URLQueryItem] = [
        URLQueryItem(name: "lat", value: "37.5"),
        URLQueryItem(name: "lon", value: "126.9"),
        URLQueryItem(name: "appid", value: "3d1be1b2d3419223212333eb2388ba4a"),
        URLQueryItem(name: "units", value: "metric")
    ]

    private let titleLabel: UILabel = {
        let label = UILabel()
        label.text = "서울특별시"
        label.textColor = .white
        label.font = .boldSystemFont(ofSize: 30)
        return label
    }()
    private let tempLabel: UILabel = {
        let label = UILabel()
        label.textColor = .white
        label.font = .boldSystemFont(ofSize: 50)
        return label
    }()
    private let tempMinLabel: UILabel = {
        let label = UILabel()
        label.textColor = .white
        label.font = .boldSystemFont(ofSize: 20)
        return label
    }()
    private let tempMaxLabel: UILabel = {
        let label = UILabel()
        label.textColor = .white
        label.font = .boldSystemFont(ofSize: 20)
        return label
    }()
    private let tempStackView: UIStackView = {
        let stackView = UIStackView()
        stackView.axis = .horizontal
        stackView.spacing = 20
        stackView.distribution = .fillEqually
        return stackView
    }()
    private let imageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFit
        imageView.backgroundColor = .black
        return imageView
    }()
    private lazy var tableView: UITableView = {
        let tableView = UITableView()
        tableView.backgroundColor = .black
        // delegate: "대리자. 대신 수행해주는 사람." tableView 의 여러가지 속성 세팅을 이 ViewController 에서 대신 세팅해주겠다.
        tableView.delegate = self
        // dataSource: 테이블 뷰에 넣을 데이터를 이 ViewController 에서 세팅해주겠다.
        tableView.dataSource = self
        // 테이블 뷰에 테이블 뷰 셀 등록.
        tableView.register(TableViewCell.self, forCellReuseIdentifier: TableViewCell.id)
        return tableView
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        fetchCurrentWeatherData()
        fetchForecastData()
        configureUI()
    }

    // 서버 데이터를 불러오는 메서드
    private func fetchData(url: URL, completion: @escaping (T?) -> Void) {
        let session = URLSession(configuration: .default)
        session.dataTask(with: URLRequest(url: url)) { data, response, error in
            guard let data = data, error == nil else {
                print("데이터 로드 실패")
                completion(nil)
                return
            }
            // http status code 성공 범위.
            let successRange = 200..<300
            if let response = response as? HTTPURLResponse, successRange.contains(response.statusCode) {
                guard let decodedData = try? JSONDecoder().decode(T.self, from: data) else {
                    print("JSON 디코딩 실패")
                    completion(nil)
                    return
                }
                completion(decodedData)
            } else {
                print("응답 오류")
                completion(nil)
            }
        }.resume()
    }

    // 서버에서 현재 날씨 데이터를 불러오는 메서드
    private func fetchCurrentWeatherData() {
        var urlComponents = URLComponents(string: "https://api.openweathermap.org/data/2.5/weather")
        urlComponents?.queryItems = self.urlQueryItems

        guard let url = urlComponents?.url else {
            print("잘못된 URL")
            return
        }

        fetchData(url: url) { [weak self] (result: CurrentWeatherResult?) in
            guard let self, let result else { return }
            // UI 작업은 메인 쓰레드에서 작업
            DispatchQueue.main.async {
                self.tempLabel.text = "\(Int(result.main.temp))°C"
                self.tempMinLabel.text = "최소: \(Int(result.main.temp_min))°C"
                self.tempMaxLabel.text = "최고: \(Int(result.main.temp_max))°C"
            }
            guard let imageUrl = URL(string: "https://openweathermap.org/img/wn/\(result.weather[0].icon)@2x.png") else { return }

            // image 를 로드하는 작업은 백그라운드 쓰레드 작업
            if let data = try? Data(contentsOf: imageUrl) {
                if let image = UIImage(data: data) {
                    // 이미지뷰에 이미지를 그리는 작업은 UI 작업이기 때문에 다시 메인 쓰레드에서 작업.
                    DispatchQueue.main.async {
                        self.imageView.image = image
                    }
                }
            }
        }
    }

    // 서버에서 5일 간 날씨 예보 데이터를 불러오는 메서드
    private func fetchForecastData() {
        var urlComponents = URLComponents(string: "https://api.openweathermap.org/data/2.5/forecast")
        urlComponents?.queryItems = self.urlQueryItems

        guard let url = urlComponents?.url else {
            print("잘못된 URL")
            return
        }

        fetchData(url: url) { [weak self] (result: ForecastWeatherResult?) in
            guard let self, let result else { return }

            // result 콘솔에 찍어보기
            for forecastWeather in result.list {
                print("\(forecastWeather.main)\n\(forecastWeather.dtTxt)\n\n")
            }

            // UI 작업은 메인 쓰레드에서
            DispatchQueue.main.async {
                self.dataSource = result.list
                self.tableView.reloadData()
            }
        }
    }

    private func configureUI() {
        view.backgroundColor = .black
        [
            titleLabel,
            tempLabel,
            tempStackView,
            imageView,
            tableView
        ].forEach { view.addSubview($0) }

        [
            tempMinLabel,
            tempMaxLabel
        ].forEach { tempStackView.addArrangedSubview($0) }

        titleLabel.snp.makeConstraints {
            $0.centerX.equalToSuperview()
            $0.top.equalToSuperview().offset(120)
        }

        tempLabel.snp.makeConstraints {
            $0.centerX.equalToSuperview()
            $0.top.equalTo(titleLabel.snp.bottom).offset(10)
        }

        tempStackView.snp.makeConstraints {
            $0.centerX.equalToSuperview()
            $0.top.equalTo(tempLabel.snp.bottom).offset(10)
        }

        imageView.snp.makeConstraints {
            $0.centerX.equalToSuperview()
            $0.width.height.equalTo(160)
            $0.top.equalTo(tempStackView.snp.bottom).offset(20)
        }

        tableView.snp.makeConstraints {
            $0.top.equalTo(imageView.snp.bottom).offset(30)
            $0.leading.trailing.equalToSuperview().inset(20)
            $0.bottom.equalToSuperview().inset(50)
        }
    }
}

extension ViewController: UITableViewDelegate {
    // 테이블 뷰 셀의 높이 크기 지정.
    func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
        40
    }
}

extension ViewController: UITableViewDataSource {
    // 테이블 뷰의 indexPath 마다 테이블 셀 지정.
    // indexPath = 테이블 뷰의 행과 섹션을 지정. 여기서 섹션은 사용하지 않고 행만 사용함.
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        guard let cell = tableView.dequeueReusableCell(withIdentifier: TableViewCell.id) as? TableViewCell else { return UITableViewCell() }
        cell.configureCell(forecastWeather: dataSource[indexPath.row])
        return cell
    }
    // 테이블 뷰 섹션에 행이 몇 개 들어가는가. 여기서 섹션은 없으니 그냥 총 행 개수를 입력하면 된다.
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        dataSource.count
    }
}

- ForecastWeatherResult.swift

import Foundation

struct ForecastWeatherResult: Codable {
    let list: [ForecastWeather]
}

struct ForecastWeather: Codable {
    let main: WeatherMain
    let dtTxt: String

    enum CodingKeys: String, CodingKey {
        case main
        case dtTxt = "dt_txt"
    }
}

- TableCell.swift

import UIKit

final class TableViewCell: UITableViewCell {

    static let id = "TableViewCell"

    private let dtTxtlabel: UILabel = {
        let label = UILabel()
        label.backgroundColor = .black
        label.textColor = .white
        return label
    }()

    private let templabel: UILabel = {
        let label = UILabel()
        label.backgroundColor = .black
        label.textColor = .white
        return label
    }()

    // TableView 의 style 과 id 로 초기화할때 사용하는 코드.
    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)
        configureUI()
    }

    private func configureUI() {
        contentView.backgroundColor = .black
        [
            dtTxtlabel,
            templabel
        ].forEach { contentView.addSubview($0) }
        dtTxtlabel.snp.makeConstraints {
            $0.leading.equalToSuperview().inset(20)
            $0.centerY.equalToSuperview()
        }
        templabel.snp.makeConstraints {
            $0.trailing.equalToSuperview().inset(20)
            $0.centerY.equalToSuperview()
        }
    }

    public func configureCell(forecastWeather: ForecastWeather) {
        dtTxtlabel.text = forecastWeather.dtTxt
        templabel.text = "\(forecastWeather.main.temp)°C"
    }

    // 인터페이스 빌더를 통해 셀을 초기화 할 때 사용하는 코드. 여기서는 fatalError 를 통해 명시적으로 인터페이스 빌더로 초기화 하지 않음을 나타냄.
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

Alamofire 로 날씨 앱 만들기

Alamofire 는 Swift 의 HTTP 네트워킹 라이브러리.
내부적으로 URLSession 을 사용.
URLSession 을 한단계 감싸서 네트워크 코드 사용성에 편의를 제공.
AF.request(url) 메서드를 통해서 네트워크 통신 수행.
AF.request(url).responseDecodable(of: xxx) 를 통해서 네트워크 통신과 동시에 response 를 디코딩 가능.
Result 타입으로 response 반환

- 위 URLSession 으로 작성했었던 fetchData() 메서드는, Alamofire 로 작성하면 아래와 같습니다.

import Alamofire

// 서버 데이터를 불러오는 메서드
private func fetchDataByAlamofire(url: URL, completion: @escaping (Result) -> Void) {
    AF.request(url).responseDecodable(of: T.self) { response in
        completion(response.result)
    }
}

URLSession 과 비교했을 때
- successRange 를 정의해주지 않아도, Alamofire 가 success 와 failure 여부를 판단.
- responseDecodable 메서드를 통해서 JSONDecoder().decode() 과정 생략.
- 코드 간소화.

- Alamofire 를 사용한 Current Weather 와 ForecastWeather fetch 메서드.

// 서버에서 현재 날씨 데이터를 불러오는 메서드
private func fetchCurrentWeatherData() {
    var urlComponents = URLComponents(string: "https://api.openweathermap.org/data/2.5/weather")
    urlComponents?.queryItems = self.urlQueryItems

    guard let url = urlComponents?.url else {
        print("잘못된 URL")
        return
    }

    fetchDataByAlamofire(url: url) { [weak self] (result: Result) in
        switch result {
        case .success(let result):
            DispatchQueue.main.async {
                self?.tempLabel.text = "\(Int(result.main.temp))°C"
                self?.tempMinLabel.text = "최소: \(Int(result.main.temp_min))°C"
                self?.tempMaxLabel.text = "최고: \(Int(result.main.temp_max))°C"
            }

            guard let imageUrl = URL(string: "https://openweathermap.org/img/wn/\(result.weather[0].icon)@2x.png") else {
                return
            }

            // Alamofire 를 사용한 이미지 로드
            AF.request(imageUrl).responseData { response in
                if let data = response.data, let image = UIImage(data: data) {
                    DispatchQueue.main.async {
                        self?.imageView.image = image
                    }
                }
            }
        case .failure(let error):
            print("데이터 로드 실패: \(error)")
        }
    }
}

// 서버에서 5일 간 날씨 예보 데이터를 불러오는 메서드
private func fetchForecastData() {
    var urlComponents = URLComponents(string: "https://api.openweathermap.org/data/2.5/forecast")
    urlComponents?.queryItems = self.urlQueryItems

    guard let url = urlComponents?.url else {
        print("잘못된 URL")
        return
    }

    fetchDataByAlamofire(url: url) { [weak self] (result: Result) in
        guard let self else { return }
        switch result {
        case .success(let result):
            DispatchQueue.main.async {
                self.dataSource = result.list
                self.tableView.reloadData()
            }
        case .failure(let error):
            print("데이터 로드 실패: \(error)")
        }
    }
}

네트워크 통신 이해

Fri, 27 Dec 2024 05:14:28 GMT

네트워크 기본 개념

💻 네트워크란 둘 이상의 컴퓨터가 연결되고 소통하는 것을 말합니다.

아이폰도 하나의 컴퓨터, 서버도 하나의 컴퓨터로 생각할 수 있기 때문에, 서버와 아이폰과의 통신도 네트워크 통신입니다.
인터넷이란 전 세계 컴퓨터를 연결하는 거대한 네트워크를 말합니다.
인터넷 연결을 위해서는 와이파이 연결이 되있거나 데이터가 켜져있어야 합니다.
Swift 로 서버와 통신하는 코드를 작성할 수 있습니다.
네트워크 통신 코드를 공부하기 전에, 알아야할 기본 개념들을 먼저 공부해봅시다.

JSON 이란

💻 JSON (JavaScript Object Notation) 은 데이터를 표현하는 형식 중 하나입니다.

이름은 Adam, 전화번호는 010-1111-2222 라는 전화번호 정보를 알고 있습니다. 이 정보를 다른 누군가에게 전달할 때 어떤 포맷으로 전달하는게 좋을까요?
그냥 쉽게 문자열로 “이름Adam,전화번호010-1111-2222” 로 보낸다면..?
아니면.. “이름:Adam,전화번호:010-1111-2222” 이렇게? 🤔
일반적으로 데이터를 표현하는 형식이 있다면, 그걸 따르는 게 좋을 것 같습니다.
이렇게 네트워크에서 데이터를 주고받으려면, 아무렇게나 주고 받는 것이 아니라 정해진 형식을 지켜서 데이터를 교환하는 것이 좋습니다.
이 중 서버와 클라이언트가 가장 많이 사용하는 데이터 형식이 JSON 형식입니다.
JSON 은 key-value 형태를 가집니다.
예를 들어, 앞선 강의의 전화번호 구조체를 JSON 으로 표현하면 다음과 같습니다.

[
    {
        "name": "Adam",
        "phoneNumber": "010-1111-2222"
    },
    {
        "name": "Eve",
        "phoneNumber": "010-3333-4444"
    },
    {
        "name": "Abel",
        "phoneNumber": "010-5555-6666"
    }
]

이 JSON 데이터는 리스트[ ] 안에 3개의 전화번호부 데이터를 표현합니다.
JSON 은 특정한 프로그래밍 언어 안에 속하지 않으며, 대부분의 프로그래밍 언어에서는 JSON 포맷의 데이터를 다룰 수 있는 기능을 제공합니다. Swift 역시 마찬가지입니다.

API 란

💻 API (Application Programming Interface) 란?

API 를 이해하기 위해서는 먼저 API 의 I(Interface) 가 뭔지 먼저 이해해야 합니다.
개발 용어에서 인터페이스(Interface)는 항상 창구를 의미합니다.

너는 나의 내부가 어떻게 생겨먹었는지는 정확히 알 필요가 없어. 그저 내가 뚫어준 창구를 통해 나와 소통하면 돼.

? 예를 들어, TV 를 컨트롤 하기 위한 리모콘을 생각해봅시다.

리모콘의 전원 버튼, 채널 버튼, 음량 버튼 은 TV 를 컨트롤 하기 위한 창구 = API입니다.
- 여러분들이 실제로 음량 버튼 내부 회로 및 하드웨어가 어떻게 동작하는지 알 필요가 있을까요?
- 그저 음량 버튼을 눌렀을 때 → TV 음량이 조절된다. 의 결과가 잘 도출되는지가 중요합니다.
  - 음량 버튼을 눌렀다 = API 에게 내가 원하는 요청을 했다 = API Request
  - 음량이 조절 되었다 = API 로 부터 요청의 결과를 받았다 = API Response
조금 더 실제 개발 상황을 예로 들어볼까요?

서버의 데이터베이스에 모든 유저의 정보를 담고 있습니다. 전화번호까지요.
클라이언트 (= iOS 네이티브 앱) 에서 “아담” 이라는 유저의 정보를 알고 싶습니다.
서버는 API 로 UserInfo 라는 API 를 뚫어 놓았고, 이 API 를 사용하면 유저의 정보를 알 수 있습니다. API 명세는 다음과 같습니다.
API Request 는 이렇게 보내주세요.
```
{
      name: "Adam"
}
```

API Response 는 이렇게 보내주겠습니다.

{
      "name": "Adam",
      "phoneNumber": "010-1111-2222",
      "Mbti": "ENTJ"
}

iOS 개발자인 여러분은 이제 이 API 명세를 보고, Request JSON 과 Response JSON 형식을 지켜서 서버와 소통하는 코드를 작성하면 됩니다.
서버가 이 데이터를 돌려주기 위해서 내부적으로 어떤 로직을 수행했고, 서버 데이터베이스 내부가 어떻게 생겨먹었고를 알 필요가 없습니다.
그저 서버가 뚫어놓은 API 라는 창구 를 통해서 서버와 소통을 하고, 원하는 결과를 얻으면 iOS 개발자의 책임은 끝입니다.

👨🏻‍🍳 다시, 이번엔 레스토랑에 비유해보겠습니다.

클라이언트 앱 = 레스토랑의 손님
API = 레스토랑의 메뉴판, 웨이터
서버 = 레스토랑의 요리사
손님이라는 클라이언트는 메뉴판, 웨이터 라는 창구를 통해서 요리사라는 서버의 음식을 받습니다.
- 손님이 메뉴판을 보고 웨이터를 부른다 → API 명세를 파악한다
- “봉골레 파스타 주세요” → API Request
- 요리사가 파스타를 손님에게 바친다 → API Response

마지막으로 API 가 뭔지 정리해보면,

API 는 직역 그대로 Application Programming 에 필요한 Interface 입니다.
즉, 어떤 프로그램을 개발할 때 원하는 기능들을 제공해주는 창구, 설명서, 도구 입니다.

Swift Codable

🧑🏻‍💻 Swift 의 인코딩과 디코딩

인코딩: 데이터를 특정 형식으로 변환하는 것.
디코딩: 인코딩 된 데이터를 다시 원본으로 변환하는 것.
Swift 의 Codable 프로토콜을 채택한다는 것은 인코딩과 디코딩이 될 수 있음을 의미.
- Codable 안을 열어보면 Decodable & Encodable 로 구현되어있음.
서버와 통신하기 위해서, JSON 형식으로 인코딩을 많이 한다.
```
struct PhoneBook: Codable {

  let name: String
  let phoneNumber: String
}
```
Codable 을 채택함으로써 인코딩 디코딩이 가능한 객체가 됨.

🧑🏻‍💻 JSON 형식의 데이터에서 Swift 로 데이터를 디코딩해서 추출하는 과정

import Foundation

struct PhoneBook: Codable {

    let name: String
    let phoneNumber: String
}

// string 으로 json 모양의 데이터를 생성.
let jsonString = """
[
    {
        "name": "Adam",
        "phoneNumber": "010-1111-2222"
    },
    {
        "name": "Eve",
        "phoneNumber": "010-3333-4444"
    },
    {
        "name": "Abel",
        "phoneNumber": "010-5555-6666"
    }
]
"""

// jsonString 으로 jsonData 를 생성.
let jsonData = jsonString.data(using: .utf8)!

// Swift 가 제공하는 JSON 디코더.
let jsonDecoder = JSONDecoder()

// JSON -> Codable 디코딩 진행.
do {
    let phoneBooks = try jsonDecoder.decode([PhoneBook].self, from: jsonData)
    for phoneBook in phoneBooks {
        print("name: \(phoneBook.name), phoneNumber: \(phoneBook.phoneNumber)")
    }
} catch {
    print("JSON 디코딩 실패")
}

URL 구조

URL 의 구조에 대해 자세히 공부해봅니다.

URL (Uniform Resource Locators): 웹에서 특정 위치를 나타내는 주소.
Protocol: http, https → 인터넷 통신 규약을 의미.
Domain: 자원이 위치한 서버(컴퓨터)의 이름. 예를 들어 google, naver . url 의 정체성을 나타낸다.
Port: 구체적으로 어떤 서버를 이용할지 번호로 결정. HTTP 의 경우 80. HTTPS 는 443.
Path: 서버에서 제공하는 자원의 경로를 나타냄.
Query: 자원에 대한 추가적인 매개변수를 전달하는 데 사용됨. 주로 key=value 형식으로 표현되며, 여러 개의 매개변수는 &로 구분.
Fragment: 자원 내에서 특정 부분을 가리킬 때 사용.

ex) https://ko.wikipedia.org/wiki/대한민국#문화

REST API

REST API (Representational State Transfer) 란 무엇인지 공부합니다.

전세계에서 대표적으로 널리 쓰이는 API 형식 중 하나.
상태 (State) 를 표현해서 정보를 주고 받는 API 이다.
HTTP URL 을 통해서 자원을 명시한다.
HTTP Method (GET, POST, PUT, DELETE 등) 를 통해 해당 자원을 어떻게 할 것인지 CRUD 를 결정한다.
- GET: 자원을 조회합니다.
- POST: 자원을 생성합니다.
- PUT: 자원을 업데이트합니다.
- DELETE: 자원을 삭제합니다.
REST API 도 결국 API 이기 때문에, 데이터를 주고 받는 형식, 창구라고 생각 할 수 있음.

🧐 예를들어, https://spartacodingclub.com 서버와 REST API 통신을 한다고 가정해봅시다.

스파르타 코딩클럽의 유저 정보 데이터들은 https://spartacodingclub.com/users 에 저장되어있다고 가정합니다. (실제로 그렇지 않습니다.)

유저 데이터를 조회하고 싶으면 GET 메소드와 해당 URL 을 사용해서 네트워크 통신을 하면 됩니다.

요청 방식: GET https://spartacodingclub.com/users

[
    {
        "id": 1,
        "name": "Adam",
        "email": "adam.doe@example.com"
    },
    {
        "id": 2,
        "name": "Eve",
        "email": "eve.smith@example.com"
    }
]

위처럼 URL 을 가지고 네트워크 통신을 할 수 있게 하는 Swift 의 클래스가 바로 URLSession 입니다.

URLSession

URLSession 은 Swift 에서 서버와 통신하기 위해 제공되는 클래스.

URLSession 을 다루기 위해서는 크게 아래 2가지 개념을 알아야 합니다.
1. URLSessionConfiguration
2. URLSessionTask

URLSessionConfiguration

Configuration 이란 환경 설정을 의미.

URLSession 으로 네트워크 통신을 하되, 여러가지 커스텀한 설정들을 할 때 URLSessionConfiguration 을 이용.

예를들어 네트워크 통신의 타임아웃 시간 설정, 네트워크 통신 캐시 정책 설정 등을 세팅할 수 있음.

URLSession 객체를 생성하려면 URLSessionConfiguration 을 넣어줘야 함.

다음과 같이 default configuration 을 활용해 URLSession 생성 가능.

let defaultUrlSession = URLSession(configuration .default)

URLSessionTask

URLSessionTask 으로 네트워크 통신을 할 때 어떤 태스크를 수행할 것 인지 결정 가능.
- URLSessionDataTask: GET 요청. 서버로부터 데이터를 가져오거나 서버에 데이터를 전송할 때 사용.
- URLSessionDownloadTask 파일 다운로드를 처리할 때 사용. 백그라운드 다운로드 지원.
- URLSessionUploadTask: 파일 업로드를 처리할 때 사용. 백그라운드 업로드 지원.

URLSession 을 통해, 서버의 데이터를 GET 해오는 예제 코드를 작성해봅시다.

https://reqres.in/api/users/1
위 URL 은 테스트를 위한 데이터를 내려주는 사이트입니다.
GET 메소드를 사용해서 REST API 통신을 수행해봅시다.

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        fetchData()
    }

    // 서버 데이터를 불러오는 메서드 선언
    private func fetchData() {

        let defaultUrlSession = URLSession(configuration: .default)

        guard let url: URL = URL(string: "https://reqres.in/api/users/1") else {
            print("URL is not correct")
            return
        }

        // URLRequest 설정
        var request: URLRequest = URLRequest(url: url)

        // GET 메소드 사용
        request.httpMethod = "GET"

        // json 데이터 형식임을 나타냄
        request.addValue("application/json", forHTTPHeaderField: "Content-Type")

        // URLSession 생성 (기본 default 세션)
        let session: URLSession = URLSession(configuration: .default)

        // dataTask
        session.dataTask(with: request) { (data, response, error) in
                // http 통신 response 에는 status code 가 함께오는데, 200번대가 성공을 의미.
            let successRange: Range = (200..<300)

            // 통신 성공
            guard let data, error == nil else { return }

            if let response: HTTPURLResponse = response as? HTTPURLResponse{
                print("status code: \(response.statusCode)")

                // 요청 성공 (StatusCode가 200번대)
                if successRange.contains(response.statusCode){

                    // decode
                    guard let userInfo: ResponseData = try? JSONDecoder().decode(ResponseData.self, from: data) else { return }
                    print(userInfo)

                } else { // 요청 실패 (Status code가 200대 아님)
                    print("요청 실패")
                }
            }

        }.resume()
    }
}

// 데이터 구조체 정의
struct UserData: Codable {
    let id: Int
    let email: String
    let firstName: String
    let lastName: String
    let avatar: URL

    // JSON 키와 구조체 프로퍼티 간의 매핑을 위해 CodingKeys 열거형 정의
    enum CodingKeys: String, CodingKey {
        case id
        case email
        case firstName = "first_name"
        case lastName = "last_name"
        case avatar
    }
}

// Support 구조체 정의
struct SupportData: Codable {
    let url: URL
    let text: String
}

// 최상위 구조체 정의
struct ResponseData: Codable {
    let data: UserData
    let support: SupportData
}

→ 서버에서 받아온 값이 잘 print 되는 것 확인.

CoreData와 UserDefaults

Fri, 20 Dec 2024 07:06:09 GMT

CRUD 개념

CRUD (Create, Read, Update Delete) 란?

-> 일반적인 개발론에서 CRUD 라는 용어는 자주 사용합니다. 뜻은 다음과 같습니다.

Create = 데이터 생성
Read = 데이터 읽기
Update = 데이터 업데이트 (쓰기)
Delete = 데이터 삭제

전화번호 앱에서 일어나는 CRUD 에 대해 생각해봅시다.

C = 새로운 전화번호를 등록한다.
R = 저장된 전화번호 데이터를 조회한다.
U = 저장된 전화번호를 수정한다.
D = 전화번호를 삭제한다.

데이터 CRUD 는 네이티브 (앱) 내부에서도 일어날 수 있고, 서버에서도 일어날 수 있습니다.

CoreData

CoreData 란?

CoreData 는 앱에서 기기의 디스크에 데이터를 읽고 쓸 수 있게 돕는 프레임워크.
Swift 로 기기 내 디스크에 데이터를 저장할 수 있는 대표적인 방법으로는 CoreData 와 UserDefaults 가 있다.

(1) CoreData 프로젝트 생성

프로젝트를 생성할 때 Storage → CoreData 를 선택.

(2) Entity 생성

아래 Add Entity 버튼을 클릭해서 Entity 만들기. Entity 는 저장될 데이터들의 집합.
우리는 PhoneBook 이라는 Entity 를 만들어보겠습니다.
Entity 이름은 PhoneBook
Attribute 로는 name , phoneNumber 를 추가합니다.
전화번호부 라는 데이터 집합 안에 이름 과 전화번호 라는 속성이 부여된 것.
오른쪽 인스펙터 영역 중 Codegen 개념
- Code Generator 의 줄임말. Entity 를 어떤 형식의 코드로 생성할 것인지 선택하는 속성.
- Manual/None = Entity 의 서브 클래스를 자동으로 생성하지 않고 개발자가 클래스 작성.
- Class Definition = Entity 의 서브 클래스를 자동으로 생성.
- Category/Extension = Entity 클래스와 함께 extension 을 위한 파일까지 생성.
- 여기서는 Manual/None 으로 생성해보겠습니다.

(3) Code Generate

Editor → Create NSManagedObject Subclass 를 클릭해서 코드를 생성.

그럼 위와 같이 2개의 파일이 생성됨.

PhoneBook+CoreDataClass.swift 간단 설명.
```
import Foundation
import CoreData
```

@objc(PhoneBook) public class PhoneBook: NSManagedObject {

}


- NSManagedObject는 Core Data 프레임워크에서 관리되는 객체를 나타내는 기본 클래스. 이 클래스는 Core Data 엔티티와의 상호작용을 관리하며, 속성 값의 저장 및 검색을 처리.

- PhoneBook+CoreDataProperties.swift 간단 설명.
```swift
import Foundation
import CoreData


extension PhoneBook {

    @nonobjc public class func fetchRequest() -> NSFetchRequest {
        return NSFetchRequest(entityName: "PhoneBook")
    }

    @NSManaged public var name: String?
    @NSManaged public var phoneNumber: String?

}

extension PhoneBook : Identifiable {

}

@nonobjc = Objective-C 에서는 동작하지 않고 Swift 에서만 동작하는 메서드임을 명시.
fetchRequest() = PhoneBook 에 대한 여러가지 데이터 검색을 도움.
@NSManaged = CoreData 에 의해 관리되는 객체를 의미.
Identifiable = PhoneBook 타입이 고유하게 식별될 수 있음을 의미.

(4) NSPersistentContainer 생성

NSPersistentContainer 는 CoreData에서 데이터를 저장하고 관리하는 데 필요한 핵심 객체.

→ 직역해보면 영구적인 저장 장소.
먼저 NSPersistentContainer 를 생성해줘야하는데, 프로젝트 생성할 때 CoreData 를 사용한다고 체크 해줬으므로, AppDelegate.swift 에 기본적으로 NSPersistentContainer 를 세팅하는 코드가 존재.

AppDelegate.swift 아래쪽에보면 saveContext() 라는 메서드도 자동으로 생성되어있는데, 직역하면 문맥을 저장한다는 뜻.
데이터의 업데이트(추가, 업데이트, 삭제 등)가 일어났으면 saveContext() 를 호출해서 그 문맥을 저장해야 함.

(4) CoreData 를 활용한 CRUD.

NSPersistentConatiner 를 만들었으므로, ViewController 에서 이를 활용해서 데이터 접근.
CoreData 를 통해 CRUD 의 C, R 을 하는 과정.
```
import UIKit
import CoreData
```

class ViewController: UIViewController {

var container: NSPersistentContainer!

override func viewDidLoad() {
    super.viewDidLoad()

    let appDelegate = UIApplication.shared.delegate as! AppDelegate
    self.container = appDelegate.persistentContainer

    createData(name: "Adam", phoneNumber: "010-1111-2222")
    readAllData()
}

// AdamCoreData 에 데이터 Create.
func createData(name: String, phoneNumber: String) {
    guard let entity = NSEntityDescription.entity(forEntityName: "PhoneBook", in: self.container.viewContext) else { return }
    let newPhoneBook = NSManagedObject(entity: entity, insertInto: self.container.viewContext)
    newPhoneBook.setValue(name, forKey: "name")
    newPhoneBook.setValue(phoneNumber, forKey: "phoneNumber")

    do {
        try self.container.viewContext.save()
        print("문맥 저장 성공")
    } catch {
        print("문맥 저장 실패")
    }
}

// AdamCoreData 에서 데이터 Read.
func readAllData() {
    do {
        let phoneBooks = try self.container.viewContext.fetch(PhoneBook.fetchRequest())

        for phoneBook in phoneBooks as [NSManagedObject] {
            if let name = phoneBook.value(forKey: "name") as? String,
               let phoneNumber = phoneBook.value(forKey: "phoneNumber") as? String {
                print("name: \(name), phoneNumber: \(phoneNumber)")
            }
        }

    } catch {
        print("데이터 읽기 실패")
    }
}

}

![](https://velog.velcdn.com/images/nemo_/post/628f1c1a-f0e4-48e7-b804-9668fe0b7926/image.png)

→ 디스크에 저장했으므로, 데이터를 저장한 코드를 삭제한 뒤 앱을 다시켜도 데이터가 남아있음을 확인 가능.

💻 **여기서 잠깐 리팩토링을 해봅시다.**
코드를 좀 더 나은 방향으로 개선하는 것을 리팩토링이라고 합니다.
- PhoneBook 클래스를 이렇게 수정해봅시다.

```swift
@objc(PhoneBook)
public class PhoneBook: NSManagedObject {
    public static let className = "PhoneBook"
    public enum Key {
        static let name = "name"
        static let phoneNumber = "phoneNumber"
    }
}

→ static 프로퍼티는 그 타입에 대고 호출을 할 수 있는 프로퍼티입니다.

→ PhoneBook.className → PhoneBook 이라는 클래스 타입에 대고 점을찍고 호출.

그럼 이렇게 했을때 장점..? 🤔
1. 자동완성 기능을 사용할 수 있게 된다.
2. 직접 손으로 “phoneNumber” 라고 타자를 치지 않기 때문에 실수할 일이 적어진다 → 휴먼 에러를 줄인다.
3. 값을 수정해야할일이 생겼을때 전체 다 일일이 안고쳐도되고 이곳 한군데만 고치면 된다.
4. 성격이 같은 프로퍼티끼리 모아서 관리할 수 있다.

- 리팩토링 후 C, R 과정

import UIKit
import CoreData

class ViewController: UIViewController {

    var container: NSPersistentContainer!

    override func viewDidLoad() {
        super.viewDidLoad()

        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        self.container = appDelegate.persistentContainer
        createData(name: "Adam", phoneNumber: "010-1111-2222")
        readAllData()
    }

    func createData(name: String, phoneNumber: String) {
        guard let entity = NSEntityDescription.entity(forEntityName: PhoneBook.className, in: self.container.viewContext) else { return }
        let newPhoneBook = NSManagedObject(entity: entity, insertInto: self.container.viewContext)
        newPhoneBook.setValue(name, forKey: PhoneBook.Key.name)
        newPhoneBook.setValue(phoneNumber, forKey: PhoneBook.Key.phoneNumber)

        do {
            try self.container.viewContext.save()
            print("문맥 저장 성공")
        } catch {
            print("문맥 저장 실패")
        }
    }

    func readAllData() {
        do {
            let phoneBooks = try self.container.viewContext.fetch(PhoneBook.fetchRequest())

            for phoneBook in phoneBooks as [NSManagedObject] {
                if let name = phoneBook.value(forKey: PhoneBook.Key.name) as? String,
                   let phoneNumber = phoneBook.value(forKey: PhoneBook.Key.phoneNumber) {
                    print("name: \(name), phoneNumber: \(phoneNumber)")
                }
            }
        } catch {
            print("데이터 읽기 실패")
        }
    }
}

- CoreData 를 통해 CRUD 의 U 를 하는 과정.

func updateData(currentName: String, updateName: String) {

    // 수정할 데이터를 찾기 위한 fetch request 생성
    let fetchRequest = PhoneBook.fetchRequest()
    fetchRequest.predicate = NSPredicate(format: "name == %@", currentName) // 예시: 이름이 "Adam"인 데이터 수정

    do {
        // fetch request 실행
        let result = try self.container.viewContext.fetch(fetchRequest)

        // 결과 처리
        for data in result as [NSManagedObject] {
            // 데이터 수정
            data.setValue(updateName, forKey: PhoneBook.Key.name) // 이름을 "Adam"에서 "Abel"로 수정

            // 변경 사항 저장
            try self.container.viewContext.save()
            print("데이터 수정 완료")
        }

    } catch {
        print("데이터 수정 실패")
    }
}

- CoreData 를 통해 CRUD 의 D 를 하는 과정.

func deleteData(name: String) {
    // 삭제할 데이터를 찾기 위한 fetch request 생성
    let fetchRequest = PhoneBook.fetchRequest()
    fetchRequest.predicate = NSPredicate(format: "name == %@", name)

    do {
        // fetch request 실행
        let result = try self.container.viewContext.fetch(fetchRequest)

        // 결과 처리
        for data in result as [NSManagedObject] {
            // 삭제
            // CRUD 의 D.
            self.container.viewContext.delete(data)
            print("삭제된 데이터: \(data)")
        }

        // 변경 사항 저장
        try self.container.viewContext.save()
        print("데이터 삭제 완료")

    } catch {
        print("데이터 삭제 실패: \(error)")
    }
}

UserDefaults

UserDefaults 또한 디스크에 데이터를 저장할 수 있게 돕는 도구.
CoreData 보다 사용성이 간단.
key 와 value 를 이용해서 값을 저장.
대량의 데이터를 담는데에는 CoreData 가, 비교적 단순한 데이터를 담는 데에는 UserDefaults 가 적절.

UserDefaults 의 CRUD

UserDefaults.standard.set() 메서드를 통해서 Create, Update
UserDefaults.standard.string(forKey: "") 메서드를 통해서 Read (각 타입에 맞는 메서드사용)
- bool 타입 Read: UserDefaults.standard.bool(forKey: "")
- Int 타입 Read: UserDefaults.standard.integer(forKey: "")
UserDefaults.standard.removeObject(forKey: "") 메서드를 통해서 Delete

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // Create
        UserDefaults.standard.set("010-1111-2222", forKey: "phoneNumber")

        // Read
        let phoneNumber = UserDefaults.standard.string(forKey: "phoneNumber")
        print("저장된 전화번호: \(phoneNumber)")

        // Update
        // 같은 키에다가 set 을 하면 됨.
        UserDefaults.standard.set("010-6666-7777", forKey: "phoneNumber")
        let newPhoneNumber = UserDefaults.standard.string(forKey: "phoneNumber")
        print("바뀐 전화번호: \(newPhoneNumber)")

        // Delete
        UserDefaults.standard.removeObject(forKey: "phoneNumber")
        print("전화번호가 남아있는가: \(UserDefaults.standard.string(forKey: "phoneNumber"))")
    }
}

Int, String 과 같은 원시타입이 아닌 Struct 나 Class 타입을 저장하기 위해서는 json 인코딩 과정이 필요.

UserDefaults 를 활용해서 간단한 포스트잇 앱 만들기

포스트잇 앱 만들기

UserDefaults 는 디스크에 데이터를 저장하기 때문에, 포스트잇에 적은 텍스트를 UserDefaults 에 저장 해둔다면, 앱을 종료해도 데이터가 소멸되지 않습니다.
메모를 작성하고, 앱을 종료했다가 다시 실행해도 메모가 남는 포스트잇 앱을 만들어봅니다.

import UIKit
import SnapKit

class ViewController: UIViewController {

    private let label: UILabel = {
        let label = UILabel()
        label.text = "포스트잇"
        label.font = .boldSystemFont(ofSize: 30)
        label.textColor = .black
        return label
    }()

    private let textView: UITextView = {
        let textView = UITextView()
        textView.text = UserDefaults.standard.string(forKey: "memo")
        textView.layer.cornerRadius = 10
        textView.backgroundColor = UIColor(red: 75/255, green: 253/255, blue: 30/355, alpha: 1.0)
        textView.textColor = .black
        textView.font = .boldSystemFont(ofSize: 30)
        return textView
    }()

    private lazy var button: UIButton = {
        let button = UIButton()
        button.setTitle("적용", for: .normal)
        button.backgroundColor = .red
        button.setTitleColor(.white, for: .normal)
        button.titleLabel?.font = .boldSystemFont(ofSize: 20)
        button.layer.cornerRadius = 10
        button.addTarget(self, action: #selector(buttonTapped), for: .touchDown)
        return button
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        [
            label,
            textView,
            button
        ].forEach { view.addSubview($0) }

        view.backgroundColor = .white

        label.snp.makeConstraints {
            $0.top.equalToSuperview().offset(100)
            $0.centerX.equalToSuperview()
        }

        textView.snp.makeConstraints {
            $0.top.equalTo(label.snp.bottom).offset(100)
            $0.centerX.equalToSuperview()
            $0.height.width.equalTo(200)
        }

        button.snp.makeConstraints {
            $0.top.equalTo(textView.snp.bottom).offset(50)
            $0.width.equalTo(60)
            $0.height.equalTo(40)
            $0.centerX.equalToSuperview()
        }
    }

    @objc
    private func buttonTapped() {
        UserDefaults.standard.set(textView.text, forKey: "memo")
        print("저장 완료")
    }
}

메모리 관리 이해

Fri, 13 Dec 2024 12:07:14 GMT

메모리와 디스크 기본 개념

메모리와 디스크는 모두 컴퓨터나 스마트폰에서 데이터의 저장 및 처리를 담당하지만 목적과 특성이 다르다.

▪️ 메모리

일반적으로 RAM 을 말하는 경우가 많다.
맥북에서도 몇 GB 짜리 RAM 을 사용하는지 볼 수 있다.
RAM 은 휘발성 메모리이다. 즉, 데이터를 영구적으로 저장하지 않는다. 일시적인 저장에 사용한다.

→ 앱 실행중에 메모리에 저장된 데이터들은 앱을 종료하면 함께 삭제된다. (휘발된다)

→ 앱도 결국 데이터 덩어리이기 때문에, 실행을 시키면 메모리에 올라간다.

→ 그렇기 때문에 메모리에 저장된 데이터는 앱이 메모리에서 내려올 때 같이 내려오게 되는 것.

→ RAM 의 용량이 클 수록, 동시에 실행시킬 수 있는 앱의 총량이 높아진다고 생각할 수 있다.
디스크보다 속도가 빠르다. (CPU 가 디스크보다 메모리에 더 빨리 접근할 수 있다.)
디스크에 비해 용량이 작다. (보통 8GB, 16GB, 32GB)
EEPROM 과 같은 비휘발성 메모리도 있다. 아이폰은 이곳에 장치의 일련번호 및 하드웨어 정보를 저장한다.

▪️ 디스크

영구적인 데이터를 저장하는 곳. 비휘발성 장치.

→ 앱 실행중에 디스크에 저장된 데이터들은 앱을 종료해도 디스크에 남는다.
파일, 문서, 프로그램 등 상대적으로 용량이 큰 정보들을 담을 수 있다.
메모리에 비해 속도가 느리다.
UserDefaults, CoreData 를 활용해서 디스크에 데이터를 저장할 수 있다.

💻 다음 주어진 상황들에서, 메모리를 활용하는게 좋을지 디스크를 활용하는게 좋을지 생각해봅시다. (추후 수정 예정)

1. 전화번호부 앱에서 친구의 이름, 전화번호 정보 데이터. 2. 카운터 앱 개발할 때 사용했던 number 변수. 3. 스테이지가 있는 게임 앱에서 유저가 몇 스테이지까지 클리어했는지 정보. 4. 유튜브나 인스타그램 같은 SNS 앱에서 추천 창에 뜬 이미지와 동영상 정보들.

💻 비유와 함께 개발할 때 메모리 관리가 왜 중요한지 이해해봅시다.

일류 요리사가 있습니다.
조리대에 수많은 식재료들이 있고, 열심히 요리를 하고 있습니다.
조리대의 크기가 클수록 한꺼번에 올려놓을 수 있는 식재료의 양이 많아지겠죠.
조리대의 크기는 메모리 (RAM) 의 크기에 비유해서 생각할 수 있습니다. RAM 의 크기가 클 수록 한꺼번에 올려놓고 처리할 수 있는 데이터의 양이 많아지는 것과 같습니다. 요리사는 CPU 입니다.
매우 넓은 조리대가 있고, 요리사는 열심히 요리를 하느라 정신이 없어서, 더 이상 사용하지 않는 식재료를 정리하면서 동시에 요리하기가 힘듭니다.
하지만 더 이상 필요하지 않은 식재료가 조리대의 자리를 차지하면 정작 필요한 재료들을 새로 올려놓을 때 좋지 않겠죠.
하지만 더 이상 필요하지 않은 식재료가 조리대의 자리를 차지하면 정작 필요한 재료들을 새로 올려놓을 때 좋지 않겠죠.
이때 센스있는 조교가 나타납니다. 이 조교는 조리대를 슥 훑어보고 “지금부터 양배추와 토마토는 더 이상 사용하지 않는군.” 하고 알아서 조리대에서 양배추와 토마토를 정리해줍니다.
그렇게 함으로써 요리사는 조리대를 더 효율적으로 사용할 수 있게 됩니다.
이 조교는 Garbage Collector (가비지 컬렉터) 입니다.

💻 Garbage Collector

Garbage Collector 는 직역하면 쓰레기 청소부. 메모리에서 필요없는 것들을 정리해주는 역할을 합니다. 사용하지 않는 데이터들이 메모리에 올라와 공간을 차지하고 있는 것은 매우 비효율적입니다. 따라서 좋은 개발자는 메모리 관리를 신경써서 잘 할 줄 알아야 합니다.

사용하지 않는 메모리가 쌓이고 쌓여서 메모리에 부담이 되는 상황을 메모리 누수 (Memory Leak) 이라고 합니다.

Java 에서는 개발자가 직접 명시적으로 메모리 관리를 하지 않더라도 기본적으로 메모리 관리를 돕는 GC 라는 시스템이 있습니다.

GC 가 동작하는 방식을 간단하게만 소개하면, 런타임에 메모리 영역을 슥 훑어보며 사용중인 것들을 표시 (Mark) 하고, 표 되지 않은 모든 것들을 정리해버리는 Mark-and-Sweep 방식을 사용합니다.

🤔 왜 갑자기 Java 의 메모리 관리 시스템을 공부하나요?

일반적인 메모리 관리 개념의 근간이 되는 시스템이며, 개발자라면 필수 교양으로 알아야 하는 내용이기 때문에 간단하게 공부해보았습니다.

Reference Counting

메모리를 할당 받은 객체를 인스턴스라고 합니다.

예를들어 아래 코드에서 myClass 는 인스턴스가 된 것이죠.

class MyClass {}

// 메모리를 할당받음. 인스턴스.
let myClass = MyClass()

인스턴스는 하나 이상의 참조자(소유자=owner) 가 있어야 메모리에 유지가 됩니다. 소유자가 없다면 즉시 메모리에서 제거가 됩니다. 이때 인스턴스를 참조하고 있는 소유자의 개수를 reference count 라고 합니다.

reference count > 0 이면 메모리에 살아있고, reference count = 0 이면 메모리에서 삭제됩니다.

그렇기 때문에, 더 이상 사용하지 않을 인스턴스의 reference coutn 가 0보다 크지 않도록 주의를 해야합니다.

class MyClass {
    init() {
        print("MyClass 생성")
    }
    deinit {
        print("MyClass 소멸")
    }
}

// RC = 1
var myClass: MyClass? = MyClass()

// RC = 2
var myClass2 = myClass

// RC = 2-1 = 1
myClass = nil

오늘의 스스로 숙제! 클래스의 deinit 소멸자 메서드는 메모리에서 해제될때 호출됩니다. 위 코드에서 deinit 의 프린트가 찍힐까? Reference Count 의 개념을 생각하며 결과에 대한 이유를 생각해보자

ARC 와 MRC

ARC = Automatic Reference Counting
MRC = Manual Reference Counting
ARC
- ARC 는 Swift 의 메모리 관리 시스템. Java 에 GC 가 있다면 Swift 에는 ARC 가 있음.
- Reference Count 를 자동으로 계산. (Automatic)
  - 객체가 생성될 때 RC 가 1 로 설정
  - 객체가 다른 변수나 속성에 할당되어 참조될때마다 RC 가 1 씩 증가
  - 객체에 대한 참조가 해제될때마다 RC 가 감소
  - RC 0 이 되면 더 이상 사용되지 않는 것으로 간주되어 메모리에서 해제.
MRC
- MRC 는 Objective-C 에서 사용하는 메모리 관리 시스템.
- Reference Count 를 개발자가 코드로 직접 계산. (Manual)
  - 객체가 생성될때 개발자가 명시적으로 메모리 할당
  - 객체를 다른 변수나 속성에 할당되어 참조될때마다 개발자가 명시적으로 RC 증가
  - 객체에 대한 참조가 해제될때마다 개발자가 명시적으로 RC 감소
  - RC 가 0 이되면 개발자가 명시적으로 메모리에서 해제.
🙋🏻‍♂️ 그렇다면 ARC 는 자동으로 RC 카운트를 해서 메모리 관리를 해주는 좋은 시스템이니, 개발자는 메모리 관리에 대해 신경쓰지 않아도 되나요?

→ 그렇지 않습니다. ARC 로 잡아내지 못하는 메모리 누수 상황이 발생할 수 있기 때문에, 개발자는 메모리 관리 방법을 반드시 알아야 합니다.

약참조와 강참조

약참조
- Reference Count 를 증가시키지 않으면서 참조하는 것.
- weak 키워드를 붙여서 약참조를 할 수 있다.
- 강참조
  - Reference Count 를 증가시키면서 참조하는 것.
  - 일반적인 참조 방식을 말한다.

클로저의 캡처링 개념

Swift 의 클로저 안에서 값을 사용하는 방법 중에는 캡처링 이 있습니다.

class Adam {
    let mbti = "ENTJ"
    init() {
        print("클래스 생성")
    }
    deinit {
        print("클래스 소멸")
    }
}

// adam rc = 1
var adam: Adam? = Adam()

// 클로저 내부에서 adam 캡처. rc 1 증가. adam rc = 2
let printMbti: () -> () = { [adam] in
    guard let adam else { return }
    print("adam's mbti = \(adam.mbti)")
}

printMbti()

// adam rc = 2-1 = 1
adam = nil

printMbti 라는 클로저를 선언했고, 클로저 내부에서 클로저 외부의 adam 이라는 객체를 가져다 쓰고 싶으면 값을 캡처 해야합니다. 이때 [ ] 로 감싸면 값을 캡처링해서 클로저 내부에서 사용할 수 있게 됩니다.

🌟 클로저 내부에서 클래스의 값을 캡처하면, Reference Count 가 증가합니다.

위 예시를 따라해보면 adam 의 deinit 소멸자가 호출되지 않습니다. 클로저에서 값을 캡처해 rc 가 증가했기 때문입니다.

위 코드를 개선해서, 메모리 누수가 발생하지 않는 상황을 만들려면 다음과 같이 코드를 작성해야 합니다.

class Adam {
    let mbti = "ENTJ"
    init() {
        print("클래스 생성")
    }
    deinit {
        print("클래스 소멸")
    }
}

// adam rc = 1
var adam: Adam? = Adam()

// 클로저 내부에서 adam 캡처.
// weak 참조 했으므로 rc 가 증가하지 않음. adam rc = 1
let printMbti: () -> () = { [weak adam] in
    guard let adam else { return }
    print("adam's mbti = \(adam.mbti)")
}

printMbti()

// adam rc = 1-1 = 0
adam = nil

위 코드를 따라서 실행해보면, 메모리가 해제되고 deinit ”클래스 소멸” 이 호출되는 것을 확인할 수 있습니다.

순환 참조 (Circular Reference)

A 가 B 를 참조하고 (A→B), B 가 A 를 참조해서 (B→A), 서로가 서로를 참조하는 상황을 순환 참조라고합니다. 일반적으로 순환 참조는 메모리 누수를 발생시키는 대표적인 사례입니다. 아래 예시를 보고 순환 참조 개념을 이해해봅시다.

class Person {
    var pet: Dog?
    init() {
        print("Person 클래스 생성")
    }
    deinit {
        print("Person 클래스 소멸")
    }
}

class Dog {
    var owner: Person?
    init() {
        print("Dog 클래스 생성")
    }
    deinit {
        print("Dog 클래스 소멸")
    }
}

// person rc = 1
var person: Person? = Person()
// dog rc = 1
var dog: Dog? = Dog()

// dog rc = 2
person?.pet = dog
// person rc = 2
dog?.owner = person

// person rc = 1
person = nil
// dog rc = 1
dog = nil

→ 따라서, 개발자는 개발할 때 순환참조가 발생하는 상황이 아닌지 점검할 줄 알아야 합니다.

ViewController 생명주기

Mon, 02 Dec 2024 11:01:45 GMT

UIViewController 개념

UIKit 앱의 뷰 계층을 관리하는 개체입니다.

한 개의 페이지는 반드시 한 개의 UIViewController 를 가짐.
UIViewController 내부에 UIView, UIButton, UIScrollView 등 UIKit 의 UI 클래스들을 배치하며 화면을 구성한다. 링크텍스트

ViewController 생명주기

iOS 의 대표적인 생명주기 2가지
1. 앱 생명주기 (App Lifecycle) → [1-3. Xcode 빌드] 강의에서 공부했음.
2. ViewController 생명주기 (ViewController Lifecycle)

ViewController Lifecycle

ViewController Lifecycle 메서드 호출 확인

▪️ ViewController 에서 버튼을 클릭하면 AdamViewController 로 이동하도록 구현합니다.

ViewController 의 라이프사이클 메서드에 print() 문으로 로그를 남기고, 직접 어떤 타이밍에 어떤 라이프사이클이 호출되는지 확인합니다.

1) viewDidLoad ~viewDidAppear

2) viewWillDisappear ~ viewDidDisappear

3) viewWillAppear ~ viewDidAppear

SceneDelegate.swift

//
//  SceneDelegate.swift
//

import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = scene as? UIWindowScene else { return }
        let window = UIWindow(windowScene: windowScene)
        window.rootViewController = UINavigationController(rootViewController: ViewController())
        window.makeKeyAndVisible()
        self.window = window
    }
    // ...
}

ViewController.swift

~~NSLayoutConstraint 로 구현~~

//
//  ViewController.swift
//

import UIKit

class ViewController: UIViewController {

    let button = UIButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
        print("viewDidLoad")
    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        print("viewWillAppear")
    }

    override func viewIsAppearing(_ animated: Bool) {
        super.viewIsAppearing(animated)
        print("viewIsAppearing")
    }

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        print("viewDidAppear")
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        print("viewWillDisappear")
    }

    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        print("viewDidDisappear")
    }

    private func configureUI() {
        view.addSubview(button)
        view.backgroundColor = .white

        button.setTitle("페이지 이동", for: .normal)
        button.addTarget(self, action: #selector(buttonTapped), for: .touchDown)
        button.backgroundColor = .red
        button.setTitleColor(.white, for: .normal)
        button.titleLabel?.font = .boldSystemFont(ofSize: 30)
        button.translatesAutoresizingMaskIntoConstraints = false

        NSLayoutConstraint.activate([
            button.widthAnchor.constraint(equalToConstant: 200),
            button.heightAnchor.constraint(equalToConstant: 120),
            button.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            button.centerYAnchor.constraint(equalTo: view.centerYAnchor)
        ])
    }

    @objc
    private func buttonTapped() {
        self.navigationController?.pushViewController(AdamViewController(), animated: true)
    }
}

AdamViewController.swift

//
//  AdamViewController.swift
//
//

import UIKit

class AdamViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .orange
        print("AdamViewController viewDidLoad")
    }
}

ViewController 를 볼때마다 색상을 랜덤하게 변경하기

override func viewWillAppear(_ animated: Bool) {
    print("viewWillAppear")

    self.view.backgroundColor = UIColor(
        red: .random(in: 0...1),
        green: .random(in: 0...1),
        blue: .random(in: 0...1),
        alpha: 1.0
    )

    self.button.backgroundColor = UIColor(
        red: .random(in: 0...1),
        green: .random(in: 0...1),
        blue: .random(in: 0...1),
        alpha: 1.0
    )
}

카운터 앱 개발

Fri, 22 Nov 2024 06:07:15 GMT

앱 요구사항

카운터 앱 개발하기

~~앱의 요구사항~~

숫자를 띄울 라벨

속성	요구사항
숫자라벨	Int 형.0 부터 시작
textColor	white
font	boldSystem 폰트. size = 45
textAlignment	center
width	80
constraint	superView와 center가 갖게 설정.

감소, 증가 버튼

속성	요구사항
backgroundColor	감소 버튼은 red, 증가 버튼은 blue.
textColor	white
width	80
height	30
cornerRadius	8
constraint	centerY 는 모두 숫자 라벨과 같게 설정. 감소 버튼은 라벨로부터 왼쪽으로 32 떨어지게 설정. 증가 버튼은 라벨로부터 오른쪽으로 32 떨어지게 설정.

증가 버튼을 누르면 숫자가 +1 , 감소 버튼을 누르면 숫자가 -1 되어 보이도록 구현.

스토리보드로 카운터 앱 개발

import UIKit

class ViewController: UIViewController {

    private var number: Int = 0
    @IBOutlet weak var label: UILabel!
    @IBOutlet weak var minusButton: UIButton!
    @IBOutlet weak var plusButton: UIButton!
    @IBAction func minusButtonTapped(_ sender: Any) {
        self.number -= 1
        label.text = "\(self.number)"
    }
    @IBAction func plusButtonTapped(_ sender: Any) {
        self.number += 1
        label.text = "\(self.number)"
    }
    override func viewDidLoad() {
        super.viewDidLoad()
    }
}

코드베이스로 카운터 앱 개발

~~SnapKit 활용~~

import UIKit
import SnapKit

class ViewController: UIViewController {

    private var number: Int = 0
    let label = UILabel()
    let minusButton = UIButton()
    let plusButton = UIButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        view.backgroundColor = .black
        label.text = "\(number)"
        label.textColor = .white
        label.font = .boldSystemFont(ofSize: 45)
        label.textAlignment = .center
        minusButton.setTitle("감소", for: .normal)
        minusButton.backgroundColor = .red
        minusButton.setTitleColor(.white, for: .normal)
        minusButton.layer.cornerRadius = 8
        minusButton.addTarget(self, action: #selector(minusButtonTapped), for: .touchDown)
        plusButton.setTitle("증가", for: .normal)
        plusButton.backgroundColor = .blue
        plusButton.setTitleColor(.white, for: .normal)
        plusButton.layer.cornerRadius = 8
        plusButton.addTarget(self, action: #selector(plusButtonTapped), for: .touchDown)

        [label, minusButton, plusButton]
            .forEach { view.addSubview($0) }

        label.snp.makeConstraints {
            $0.width.equalTo(80)
            $0.center.equalToSuperview()
        }

        minusButton.snp.makeConstraints {
            $0.centerY.equalTo(label.snp.centerY)
            $0.width.equalTo(60)
            $0.height.equalTo(30)
            $0.trailing.equalTo(label.snp.leading).offset(-32)
        }

        plusButton.snp.makeConstraints {
            $0.centerY.equalTo(label.snp.centerY)
            $0.width.equalTo(60)
            $0.height.equalTo(30)
            $0.leading.equalTo(label.snp.trailing).offset(32)
        }
    }

    @objc
    private func minusButtonTapped() {
        self.number -= 1
        label.text = "\(number)"
    }

    @objc
    private func plusButtonTapped() {
        self.number += 1
        label.text = "\(number)"
    }
}

응용 - 초기화 버튼 만들기

import UIKit
import SnapKit

class ViewController: UIViewController {

    private var number: Int = 0
    let label = UILabel()
    let minusButton = UIButton()
    let plusButton = UIButton()
    let resetButton = UIButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        view.backgroundColor = .black
        label.text = "\(number)"
        label.textColor = .white
        label.font = .boldSystemFont(ofSize: 45)
        label.textAlignment = .center
        minusButton.setTitle("감소", for: .normal)
        minusButton.backgroundColor = .red
        minusButton.setTitleColor(.white, for: .normal)
        minusButton.layer.cornerRadius = 8
        minusButton.addTarget(self, action: #selector(minusButtonTapped), for: .touchDown)
        plusButton.setTitle("증가", for: .normal)
        plusButton.backgroundColor = .blue
        plusButton.setTitleColor(.white, for: .normal)
        plusButton.layer.cornerRadius = 8
        plusButton.addTarget(self, action: #selector(plusButtonTapped), for: .touchDown)
        resetButton.setTitle("초기화", for: .normal)
        resetButton.backgroundColor = .gray
        resetButton.setTitleColor(.white, for: .normal)
        resetButton.layer.cornerRadius = 8
        resetButton.addTarget(self, action: #selector(resetButtonTapped), for: .touchDown)

        [label, minusButton, plusButton, resetButton]
            .forEach { view.addSubview($0) }

        label.snp.makeConstraints {
            $0.width.equalTo(80)
            $0.center.equalToSuperview()
        }

        minusButton.snp.makeConstraints {
            $0.centerY.equalTo(label.snp.centerY)
            $0.width.equalTo(60)
            $0.height.equalTo(30)
            $0.trailing.equalTo(label.snp.leading).offset(-32)
        }

        plusButton.snp.makeConstraints {
            $0.centerY.equalTo(label.snp.centerY)
            $0.width.equalTo(60)
            $0.height.equalTo(30)
            $0.leading.equalTo(label.snp.trailing).offset(32)
        }

        resetButton.snp.makeConstraints {
            $0.centerX.equalToSuperview()
            $0.width.equalTo(80)
            $0.height.equalTo(30)
            $0.top.equalTo(label.snp.bottom).offset(100)
        }
    }

    @objc
    private func minusButtonTapped() {
        self.number -= 1
        label.text = "\(number)"
    }

    @objc
    private func plusButtonTapped() {
        self.number += 1
        label.text = "\(number)"
    }

    @objc
    private func resetButtonTapped() {
        self.number = 0
        label.text = "\(number)"
    }
}

코드 베이스 UI

Thu, 21 Nov 2024 14:26:00 GMT

스토리보드 vs 코드베이스

코드베이스란 스토리보드 같은 인터페이스 빌더를 사용하지 않고, 코드 작성으로만 UI 구성을 하는 것.
스토리보드에서 하던 뷰의 size, constraint 및 모든 속성들을 코드로 작성한다.
팀끼리 협업할 때, github에 코드를 올리고 서로 코드 리뷰를 하게 되는데, 스토리보드로 작성한 UI 를 github에 올린 것보다, swift로 작성한 UI 코드를 github에 올린 것이 가독성이 더 좋음.
다만 스토리보드처럼 눈에 보이는 상태로 UI를 구성하는 것이 아니기 때문에, 코드 베이스로 UI를 작성하면 반드시 실행시켜서 확인해야 한다는 단점이 존재
좌: 스토리보드 UI를 github에 올린 모습.
우: 코드베이스 UI를 github에 올린 모습.

→ Swift로 UI가 작성되었기 때문에 코드 파악하기가 용이.

스토리보드 삭제

-> 스토리보드를 일절 사용하지 않고, 코드만으로 UI를 구성하기 위해 프로젝트에서 스토리보드를 완전히 삭제합니다.

Main이라는 이름의 스토리보드 삭제. Move to Trash로 삭제할 것.
into.plist라는 파일에서 ctrl+F로 검색 → main 검색해서 Storyboard Name 항목 삭제.
프로젝트 파일에서 TARGETS 선택 후 → Build Settings로 이동 → ctrl+F로 main 검색 → UIKit Main Storyboard File Base Name 항목 삭제.
앱에게 맨 처음 시작할 뷰를 알려줘야 하므로 SceneDelegate.swift 파일에 다음과 같은 코드 작성.

코드 및 설명.

// SceneDelegate.swift

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
        // 윈도우. 앱에 반드시 한 개는 필요한 가장 근본이 되는 뷰. 이 위에 뷰가 쌓이기 시작.
    var window: UIWindow?

        // 앱을 시작할때 세팅해줄 코드를 작성하는 곳.
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // UIWindow 객체 생성.
        guard let windowScene = (scene as? UIWindowScene) else { return }
        let window = UIWindow(windowScene: windowScene)

        // window 에게 루트 뷰 지정. 
        window.rootViewController = ViewController()

         // 이 메서드를 반드시 작성해줘야 윈도우가 활성화 됨.
        window.makeKeyAndVisible()
        self.window = window
    }

실행해 봤을때 컴파일 에러 없이 잘 실행된다면 스토리보드 삭제 및 코드 베이스 UI 작성 준비 완료.

NSLayoutConstraint

NSLayoutConstraint로 Constraint 작성 가능.
Constraint는 뷰와 뷰 사이의 제약조건을 의미. 오토 레이아웃에서 중요한 개념.
leadingAnchor trailingAnchor topAnchor bottomAnchor widthAnchor heightAnchor
centerXAnchor : 뷰에 가로선 그었을 때 그 중간을 의미.
centerYAnchor : 뷰에 세로선 그었을 때 그 중간을 의미.
NSLayoutConstraint.activate([제약조건들]) : 제약조건들을 넣고 코드 작성하면 제약조건 활성화.

UILabel

▪️ NSLayoutConstraint를 이용해서 UILabel 그려보기.

let label = UILabel() 코드로 라벨을 선언.
configureUI()라는 메서드를 정의하고, 그 안에 UI를 세팅하는 코드들을 담습니다.
view는 ViewController가 기본적으로 갖고 있는 기본 view를 의미.
view에 label을 추가해야 합니다. view.addSubview(label)
코드로 여러 가지 속성들을 부여. text, textColor 등.
label.translatesAutoresizingMaskIntoConstraints = false 이 코드는 오토 레이아웃을 활성화시키기 위해 작성 필요.
NSLayoutConstraint.activate 안에 제약조건들을 작성.
```
import UIKit
```

class ViewController: UIViewController {

let label = UILabel()

override func viewDidLoad() {
    super.viewDidLoad()
    configureUI()
}

private func configureUI() {
    view.backgroundColor = .white
    label.text = "안녕하세요"
    label.textColor = .black
    label.translatesAutoresizingMaskIntoConstraints = false

    view.addSubview(label)
    NSLayoutConstraint.activate([
        label.widthAnchor.constraint(equalToConstant: 80),
        label.heightAnchor.constraint(equalToConstant: 40),
        label.centerXAnchor.constraint(equalTo: view.centerXAnchor),
        label.centerYAnchor.constraint(equalTo: view.centerYAnchor)
    ])
}

}

>### UIButton

![](https://velog.velcdn.com/images/nemo_/post/fba20805-c7aa-40f4-84fb-f4187ef8db93/image.png)

▪️ **NSLayoutConstraint를 이용해서 UIButton 그려보기.**

- `let button = UIButton()` 코드로 버튼을 선언.
- `setTitle`, `setTitleColor`, `backgroundColor` 등 속성을 코드로 부여.
- 버튼뿐 아니라 모든 뷰들의 테두리를 둥글게 하고 싶다면 `layer.cornerRadius` 속성 사용.
```swift
import UIKit

class ViewController: UIViewController {

    let button = UIButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        view.backgroundColor = .white
        // 버튼 타이틀 지정.
        button.setTitle("Click", for: .normal)
        // 버튼 타이틀 컬러 지정.
        button.setTitleColor(.white, for: .normal)
        // 버튼 색상 지정.
        button.backgroundColor = .red
        button.translatesAutoresizingMaskIntoConstraints = false
            // 버튼 테두리 둥글게 지정.
        button.layer.cornerRadius = 10

        view.addSubview(button)
        NSLayoutConstraint.activate([
            button.widthAnchor.constraint(equalToConstant: 120),
            button.heightAnchor.constraint(equalToConstant: 60),
            button.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            button.centerYAnchor.constraint(equalTo: view.centerYAnchor)
        ])
    }
 }

UIImageView

▪️ NSLayoutConstraint를 이용해서 UIImageView 그려보기.

let imageView = UIImageView() 코드로 이미지 뷰를 선언.
image, backgroundColor, contentMode 등 속성을 코드로 부여.
전에 배웠듯, 미리 이미지 파일을 프로젝트에 추가해야 함.
```
import UIKit
```

class ViewController: UIViewController {

let imageView = UIImageView()

override func viewDidLoad() {
    super.viewDidLoad()
    configureUI()
}

private func configureUI() {
    view.backgroundColor = .white
    imageView.image = UIImage(named: "cat")
    imageView.backgroundColor = .black
    imageView.contentMode = .scaleAspectFit
    imageView.translatesAutoresizingMaskIntoConstraints = false

    view.addSubview(imageView)
    NSLayoutConstraint.activate([
        imageView.widthAnchor.constraint(equalToConstant: 300),
        imageView.heightAnchor.constraint(equalToConstant: 300),
        imageView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
        imageView.centerYAnchor.constraint(equalTo: view.centerYAnchor)
    ])
}

}

>### SnapKit

![](https://velog.velcdn.com/images/nemo_/post/84f818c1-5d3a-4a31-aefd-97c2d8df49ae/image.png)
SnapKit 이란?

SnapKit 이란 코드베이스로 UI를 작성할 때, 조금 더 간결한 문법을 사용하도록 도와주는 서드파티 라이브러리. NSLayoutConstraint 을 사용할 때보다 편하게 코드를 작성할 수 있게 도와준다.
🧑🏻‍💻 현업에서 가장 많이 사용하는 필수 라이브러리 중 하나.

>### Swift Package Manager (SPM)

![](https://velog.velcdn.com/images/nemo_/post/df72365d-9bad-4d41-8073-306cb64eba86/image.png)
- `Swift Package Manager` 란, 프로젝트에 서드파티 라이브러리를 가져와서 사용할 수 있도록 도와주는 도구.
- `Cocoapods`, `Carthage` 등 다른 도구도 있지만, `SPM` 이 애플에서 지원하는 퍼스트 파티 도구.
- `SPM` 을 통해서 `SnapKit` 을 프로젝트에 추가해 봅시다.

**<프로젝트에 SPM으로 서드파티 라이브러리 추가하는 방법>**

1. 프로젝트 파일에서 TARGETS 선택 → General → Frameworks, Libraries 영역에서 십자(+) 버튼 클릭
![](https://velog.velcdn.com/images/nemo_/post/f3d40322-df5b-4ef9-938b-17b4d63d0fb6/image.png)

2. Add Other… 클릭 후 Add Package Dependency 클릭.
![](https://velog.velcdn.com/images/nemo_/post/1da6fd83-aeca-40f9-ab27-635bc5032831/image.png)

3. 구글에 사용할 라이브러리 검색 → github 들어가서 Code → HTTPS 복사.
![](https://velog.velcdn.com/images/nemo_/post/ad02468e-5281-43bd-9760-7f3cebf39ced/image.png)

4. 검색창에 사용할 라이브러리의 주소 붙여 넣기 → Add Package.
![](https://velog.velcdn.com/images/nemo_/post/df9f9952-4427-4cb5-8e47-c718b381484c/image.png)

5. 1. 네비게이터 영역에 Package Dependencies에 SnapKit 생긴 것 확인. 코드에 `import SnapKit` 이 가능해진 것 확인.
![](https://velog.velcdn.com/images/nemo_/post/ce94868b-b275-438e-8b64-b2e28a6b8ffd/image.png)

[링크텍스트](https://github.com/SnapKit/SnapKit)

>### UILabel

![](https://velog.velcdn.com/images/nemo_/post/7ea21ec1-27d7-4fde-a364-ac283b98bd80/image.png)

▪️ **SnapKit을 이용해서 UILabel 그려보기.**

- `let label = UILabel()` 코드로 라벨을 선언.
- 라벨의 속성을 부여하는 코드는 NSConstraintLayout 때와 동일.
- `label.translatesAutoresizingMaskIntoConstraints = false` 이 코드가 `SnapKit`에서는 필요하지 않음.
- `NSLayoutConstraint.activate`로 작성하던 제약조건들을 `SnapKit` 문법으로 작성.
- **`inset`**: 슈퍼뷰의 경계로부터 내부 여백을 설정합니다.
- **`offset`**: 특정 뷰나 위치로부터 외부 여백을 설정합니다.

```swift
import UIKit
import SnapKit

class ViewController: UIViewController {

    let label = UILabel()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        view.backgroundColor = .white
        label.text = "안녕하세요"
        label.textColor = .black

        view.addSubview(label)
        label.snp.makeConstraints {
            $0.width.equalTo(80)
            $0.height.equalTo(40)
            $0.centerX.equalToSuperview()
            $0.centerY.equalToSuperview()
        }
    }
}

아래처럼 작성할 수도 있지만, Swift 문법에서 클로저의 인자는 $0으로 축약할 수 있기 때문에 축약.

// (1) 축약하지 않은 코드.
label.snp.makeConstraints { make in
    make.width.equalTo(80)
    make.height.equalTo(40)
    make.centerX.equalToSuperview()
    make.centerY.equalToSuperview()
}

// (2) 축약할 수 있으니 이렇게 축약합시다.
label.snp.makeConstraints {
    $0.width.equalTo(80)
    $0.height.equalTo(40)
    $0.centerX.equalToSuperview()
    $0.centerY.equalToSuperview()
}

같은 내용의 NSLayoutConstraint 와 비교했을 때 SnapKit 코드가 가독성이 더 좋음. 구성해야 할 레이아웃 종류들이 많아질수록 체감이 커짐. translatesAutoresizingMaskIntoConstraints를 신경 쓰지 않아도 됨.

// (1) NSLayoutConstraint 로 작성한 코드.
NSLayoutConstraint.activate([
    label.widthAnchor.constraint(equalToConstant: 80),
    label.heightAnchor.constraint(equalToConstant: 40),
    label.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    label.centerYAnchor.constraint(equalTo: view.centerYAnchor)
])

// (2) SnapKit 으로 작성한 코드.
label.snp.makeConstraints {
    $0.width.equalTo(80)
    $0.height.equalTo(40)
    $0.centerX.equalToSuperview()
    $0.centerY.equalToSuperview()
}

UIButton

import UIKit
import SnapKit

class ViewController: UIViewController {

    let button = UIButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        view.backgroundColor = .white
        // 버튼 타이틀 지정.
        button.setTitle("Click", for: .normal)
        // 버튼 타이틀 컬러 지정.
        button.setTitleColor(.white, for: .normal)
        // 버튼 색상 지정.
        button.backgroundColor = .red
        // 버튼 테두리 둥글게 지정.
        button.layer.cornerRadius = 10

        view.addSubview(button)
        button.snp.makeConstraints {
            $0.width.equalTo(120)
            $0.height.equalTo(60)
            $0.centerX.equalToSuperview()
            $0.centerY.equalToSuperview()
        }
    }
}

💡 IBAction 에서 했었던, 버튼 클릭 이벤트 추가하는 방법.

button.addTarget(**self**, action: **#selector**(buttonClicked), for: .touchDown) addTarget 메서드 사용.
#selector() 내부에 버튼 클릭 시 어떤 로직을 수행할 건지 담긴 메서드 작성.
for: 버튼의 어떤 이벤트에 로직을 수행할 것인지.
touchDown : 사용자가 버튼을 터치하는 순간 발생.
touchUpInside: 사용자가 버튼을 터치한 후 손가락을 떼는 순간 발생.

import UIKit
import SnapKit

class ViewController: UIViewController {

    let button = UIButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        view.backgroundColor = .white
        // 버튼 타이틀 지정.
        button.setTitle("Click", for: .normal)
        // 버튼 타이틀 컬러 지정.
        button.setTitleColor(.white, for: .normal)
        // 버튼 색상 지정.
        button.backgroundColor = .red
        // 버튼 테두리 둥글게 지정.
        button.layer.cornerRadius = 10
        // 버튼 클릭 이벤트 추가.
        button.addTarget(self, action: #selector(buttonClicked), for: .touchDown)

        view.addSubview(button)
        button.snp.makeConstraints {
            $0.width.equalTo(120)
            $0.height.equalTo(60)
            $0.centerX.equalToSuperview()
            $0.centerY.equalToSuperview()
        }
    }

    // #selector() 안에 넣기 위해서는 @objc 키워드 붙여야 함.
    @objc 
    private func buttonClicked() {
        print("버튼이 클릭되었음.")
    }
}

UIImageView

import UIKit
import SnapKit

class ViewController: UIViewController {

    let imageView = UIImageView()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        view.backgroundColor = .white
        imageView.image = UIImage(named: "cat")
        imageView.backgroundColor = .black
        imageView.contentMode = .scaleAspectFit

        view.addSubview(imageView)

        imageView.snp.makeConstraints {
            $0.width.equalTo(300)
            $0.height.equalTo(300)
            $0.centerX.equalToSuperview()
            $0.centerY.equalToSuperview()
        }
    }
}

SnapKit을 이용해서 UIImageView와 UILabel을 제약조건과 함께 배치해 봅시다.
```
import UIKit
import SnapKit
```

class ViewController: UIViewController {

let imageView = UIImageView()
let label = UILabel()

override func viewDidLoad() {
    super.viewDidLoad()
    configureUI()
}

private func configureUI() {
    view.backgroundColor = .white
    imageView.image = UIImage(named: "cat")
    imageView.backgroundColor = .black
    imageView.contentMode = .scaleAspectFit
    label.text = "고양이"
    label.textColor = .black
    label.font = UIFont.boldSystemFont(ofSize: 30)

    [imageView, label]
        .forEach { view.addSubview($0) }

    imageView.snp.makeConstraints {
        $0.width.equalTo(300)
        $0.height.equalTo(300)
        $0.centerX.equalToSuperview()
        $0.centerY.equalToSuperview()
    }

    label.snp.makeConstraints {
        $0.centerX.equalToSuperview()
        $0.top.equalTo(imageView.snp.bottom).offset(16)
    }
}

}


- SnapKit을 이용해서 다음과 같은 UI를 구성해 봅시다.
![](https://velog.velcdn.com/images/nemo_/post/b981e3f8-ee26-479a-b4f9-99aa55a2f041/image.png)
```swift
import UIKit
import SnapKit

class ViewController: UIViewController {

    let imageView = UIImageView()
    let imageView2 = UIImageView()
    let label = UILabel()
    let label2 = UILabel()

    override func viewDidLoad() {
        super.viewDidLoad()
        configureUI()
    }

    private func configureUI() {
        view.backgroundColor = .white
        imageView.image = UIImage(named: "cat")
        imageView.backgroundColor = .black
        imageView.contentMode = .scaleAspectFit
        label.text = "고양이"
        label.textColor = .black
        label.font = UIFont.boldSystemFont(ofSize: 30)
        imageView2.image = UIImage(named: "dog")
        imageView2.backgroundColor = .black
        imageView2.contentMode = .scaleAspectFit
        label2.text = "강아지"
        label2.textColor = .black
        label2.font = UIFont.boldSystemFont(ofSize: 30)

        [imageView, label, imageView2, label2]
            .forEach { view.addSubview($0) }

        imageView.snp.makeConstraints {
            $0.width.equalTo(160)
            $0.height.equalTo(160)
            $0.leading.equalToSuperview().inset(16)
            $0.centerY.equalToSuperview()
        }

        label.snp.makeConstraints {
            $0.centerX.equalTo(imageView.snp.centerX)
            $0.top.equalTo(imageView.snp.bottom).offset(16)
        }

        imageView2.snp.makeConstraints {
            $0.width.equalTo(160)
            $0.height.equalTo(160)
            $0.trailing.equalToSuperview().inset(16)
            $0.centerY.equalToSuperview()
        }

        label2.snp.makeConstraints {
            $0.centerX.equalTo(imageView2.snp.centerX)
            $0.top.equalTo(imageView2.snp.bottom).offset(16)
        }
    }
}

UI 디버깅 팁

코드 실행 중에 (런타임에) 화살표 표시한 버튼을 누르면 뷰의 계층구조를 파악하며 디버깅할 수 있음.

스토리보드 UI

Wed, 20 Nov 2024 12:24:06 GMT

IBOutlet & IBAction

IBOutlet

IBOutlet 은 Interface Builder 와 연결된 객체.
UI 객체를 스토리보드에서 ctrl 을 누른 채로 Drag & Drop 하면 IBOutlet 생성 가능.
혹은 마우스 우클릭으로 Drag & Drop 해도 됨.
`@IBOutlet weak var imageView: UIImageView!`
weak는 약한 참조를 의미 → 숙련 과정에서 자세히 공부.
스토리보드와 UI 객체의 연결고리 역할.
IB는 Interface Builder의 줄임말.

IBAction

IBAction 개념

IBAction 은 Interface Builder와 연결된 Action.
IBOutlet 생성할 때처럼 UI 객체를 스토리보드에서 ctrl 을 누른 채로 Drag & Drop .

→ Connection 항목에서 Action 선택.

→ 마찬가지로 마우스 우클릭으로 Drag & Drop 해도 됨.
스토리보드와 UI 액션 (이벤트)의 연결고리 역할.
IB는 마찬가지로 Interface Builder의 줄임말.

💡 ex1) IBAction으로 버튼이 클릭 되었다는 print 문을 찍어보자. 버튼이 클릭될 때마다 IBAction에 작성된 로직 실행됨. ~~예제 코드~~

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var imageView: UIImageView!
    @IBOutlet weak var button: UIButton!
    @IBAction func buttonAction(_ sender: Any) {
        print("버튼이 클릭 되었음.")
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
    }
}

💡 ex2) 변수를 이용해서, 버튼이 몇 번 클릭 되었는지 세도록 해보자. ~~예제 코드~~

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var imageView: UIImageView!
    @IBOutlet weak var button: UIButton!
    @IBAction func buttonAction(_ sender: Any) {
        self.number += 1
        print("버튼이 \(number)회 클릭 되었음.")
    }
    private var number: Int = 0

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
    }
}

💡 ex3) 버튼을 클릭하면, 강아지 사진으로 바뀌도록 구현해보자.

⚠️ 먼저 Image asset 디렉토리에 dog.jpeg를 넣어야 한다. ~~예제 코드~~

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var imageView: UIImageView!
    @IBOutlet weak var button: UIButton!
    @IBAction func buttonAction(_ sender: Any) {
        self.imageView.image = UIImage(named: "dog")
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
    }
}

UIKit

Tue, 19 Nov 2024 11:31:15 GMT

UIKit 기초 개념

UI 와 UX 의 차이

UI (User Interface)

Interface는 상호작용 할 수 있는 창구, 상호작용할 수 있는 매개체를 의미한다. ex) TV 와 상호작용하려면 리모콘 버튼들(인터페이스) 필요. ex) 전자레인지의 작동 버튼들 (인터페이스).
UI는 앱에서 유저와 상호작용하는 구성 요소(창구)들. ex) 타이틀, 배터리 잔량, 텍스트 입력 창,이미지 뷰, 스위치 버튼, 아이콘, 버튼, 스크롤 뷰 등.
앱을 구성하는 모든 시각적 요소들은 UI 가 될 수 있다.

UX (User Experience)

User Experience는 유저 경험을 의미한다.
앱을 개발하는데, 버튼1과 버튼2를 유저가 순서대로 눌러야 하는 상황이 연출된다고 가정.
좌/우 예시 중 어떤 게 유저 경험에 좋고 나쁠까?
좌측 예시가 유저의 손가락을 덜 움직이게 하기 때문에 유저 경험에 더 좋다.
이럴 때 UX 가 더 좋다고 표현한다. 그리고 앱을 서비스하는 회사에서 이 사소한 차이가 매출의 차이를 낼 수 있게 된다.

UIKit 개념

✅ UIKit

iOS 앱에서 필요한 UI 요소들을 제공하는 프레임워크
애플이 제공하는 프레임워크
UIKit 은 앞서 말한 예시의 UI 구성요소를 이미 다 제공하고 있다.

버튼 = UIButton , 제목 표시 = UILabel , 텍스트 입력창 = UITextView,

스크롤 뷰 = UIScrollView , 이미지 뷰 = UIImageView , 등등..

💡- 프레임워크(Framework)란?

UIKit이 UI 프레임워크라고 자연스럽게 설명하고 지나갔지만, 프레임워크란 무엇일까. Framework라는 말 그대로 직역을 해보면 Frame = 틀, work = 작업. 즉 작업을 하는 틀(뼈대)을 의미합니다.

“이런 이런 맥락 안에서 개발을 해라”라는 틀을 제공해 주고, 그걸 사용하는 개발자는 그 틀 안에서 개발을 하게 됩니다.

다시 한번 UIKit 을 이해해 보면, iOS 개발자가 Swift로 UI를 개발할 수 있는 틀을 제공하는 도구로 이해할 수 있습니다.

UIKit vs SwiftUI

▪️ UIKit vs SwiftUI

SwiftUI는 UIKit 과 같은 UI 개발 프레임워크.
iOS 13 이상 버전부터는 SwiftUI로 개발 가능.
즉, UIKit 이후에 SwiftUI 가 등장.
SwiftUI는 선언적 프로그래밍을 하게 되고, UIKit 은 명령적 프로그래밍을 하게 된다.
- 선언적 프로그래밍: UI의 상태에 대해 선언하고, 상태가 변경되면 자동으로 UI를 업데이트.
- 명령적 프로그래밍: UI의 상태를 명령으로 정의하고, 변화에 따른 업데이트를 직접 처리.
SwiftUI는 아래 사진과 같은 Preview를 보면서 개발 가능.

🤔 왜 UIKit 을 SwiftUI 보다 먼저 공부하나요 ?

앞서 말한 것처럼, SwiftUI는 iOS 13 버전부터 지원되기 때문에, 비교적 최신에 나온 프레임워크.
SwiftUI보다 UIKit이 개발자에게 사용된 기간이 길다. 역사가 탄탄한 프레임워크.
시중 자료 중 UIKit으로 작성된 코드가 SwiftUI로 작성된 코드보다 훨씬 많다. 공부 자료가 많다.
현재 서비스 중인 앱들은 iOS 13 보다 낮은 버전을 지원하는 앱이 굉장히 많다. → SwiftUI로 개발을 한 앱은 사용할 수 있는 유저 풀이 UIKit으로 개발한 앱보다 줄어들게 된다. 이는 서비스를 운영하는 회사 입장에선 주의 깊게 고려할 요소.
아직은 취업시장에서 원하는 기술 스택이 UIKit의 비율이 더 높다.
SwiftUI도 물론 굉장히 좋은 기술입니다 :)

Cocoa Framework

Cocoa Framework iOS 공부를 하다 보면 Cocoa라는 단어를 많이 보게 됨. Cocoa Framework는 애플에서 iOS, macOS 등의 애플 운영체제용 어플리케이션을 제작할 때 사용하는 프레임워크를 말한다. Cocoa Framework 중 iOS를 위한 프레임 워크를 Cocoa Touch라고 한다. UIKit, Foundation 이 Cocoa Touch 안에 포함된다.

import Foundation vs import UIKit

NewFile로 새로운 파일을 생성할 때, Swift File / Cocoa Touch Class를 선택해서 생성할 수 있음.
Swift File로 생성하면 import Foundation이 되어있는 상태로 생성.
Cocoa Touch Class로 생성하면 import UIKit이 되어있는 상태로 생성.
앞선 개념에서 배웠듯, UIKit 은 UI 를 위한 프레임워크.
하지만 Swift로 반드시 UI 관련 코드만 작성하게 되는 것은 아니다. UI와 무관한 코드를 작성할 수 있다. ex) 단순 연산, 비즈니스 로직, 네트워크 관련 로직 등..
그런 경우 import UIKit을 하는게 아니라 import Foundation을 한다.
Foundation 은 Swift 를 위한 기초 프레임워크이지만 UI 관련 프레임워크가 생략된 것.
파일의 맨 처음에 import Foundation이 되어있냐, import UIKit이 되어있냐에 따라 그 파일에 작성된 코드의 의도와 범위를 유추해볼 수 있게 됨.

Safe Area

아이폰에는 Safe Area라는 보이지 않는 영역이 존재.
Safe Area는 앱의 컨텐츠가 안정적으로 보이기 위한 영역
아이폰 기기마다 모습이 조금씩 다르기 때문에 Safe Area 가 필요.
예를 들어 노치가 있는 기기도 있고, 없는 기기도 있는데 이런 기기 특성과 무관하게 안정적으로 앱의 컨텐츠를 노출시켜주기 위한 가이드 영역.

AutoLayout & Constraint

💡 AutoLayout

AutoLayout 이란 기기 사이즈에 맞춰 자동으로 사이즈를 맞춰주는 것.
AutoLayout 을 사용하지 않을 경우, iPhone 15에서 노출된 사진의 위치와 iPad에서 노출된 사진의 위치가 의도와 맞지 않게 다르게 된다.
마지막 사진은 AutoLayout 을 적용시킨 사진.

💡 Constraint

Constraint는 뷰와 뷰 사이의 제약조건을 의미한다.
- left / right / top / bottom
  
  각각 좌 / 우 / 위 / 아래 제약 조건을 의미.
- leading / trailing
  
  직역하면 앞 / 뒤 제약 조건인데, 지역화된 조건이기 때문에
  
  왼쪽에서 오른쪽으로 읽는 게 자연스러운 지역 조건의 기기에서는
  
  leading = left, trailing = right로 대응되고, 반대의 경우엔
  
  leading = right, trailing = left로 대응된다.

위 고양이 사진에서 기기의 leading / trailing / top / bottom Constraint를 지정해두었기 때문에 기기가 달라지더라도 원하는 레이아웃으로 조정된다.

Margin, Padding

Margin은 Border 바깥쪽을 차지. 주변 요소와 거리를 두기 위한 영역.
Padding은 Content와 Border 사이의 여백을 나타내는 영역. Content 영역이 배경색이나 배경 이미지를 가질 때, 이 Padding 영역까지도 영향을 미침.

스토리보드에서 cmd + shift + L을 누르면 UIKit의 구성요소들을 사용할 수 있습니다. 혹은 툴 바 영역의 십자 버튼(+) 을 눌러도 같은 동작을 할 수 있습니다.

Label 을 사용하고 싶다 → Label 을 드래그해서 스토리보드로 옮김 → 스토리보드에 Label 생성

UITableView

테이블 형태의 뷰
각 테이블 항목은 UITableViewCell이라고 한다.

UICollectionView

UITableView 보다 복잡한 구성을 할 수 있는 뷰.
각 컬렉션 뷰의 항목은 UICollectionViewCell이라고 한다.

UIAlertController

알럿을 띄우는 뷰.
앱을 맨 처음 설치하고 위치 정보, 사진 접근 등 권한을 물을 때도 알럿을 사용한다.

UITextView

텍스트를 입력하는 뷰.
검색 창이나, 아이디 입력 창에 많이 사용한다.

UIPageViewController

페이지를 넘기듯 넘길 수 있는 뷰.
인스타그램에서도 페이지를 넘기는듯한 페이지 뷰를 사용하고 있다.

Xcode 빌드

Mon, 18 Nov 2024 12:13:43 GMT

빌드하기 전 기초 개념

컴파일 & 빌드

💡 - 컴파일(Compile)

- 컴파일이란 어떤 언어의 코드 전체를 다른 언어로 바꿔주는 과정이다.

즉, Swift에서 컴파일이란, 사람이 이해하기 쉬운 High Level 언어인 Swift로 작성한 코드를 컴퓨터가 이해하기 쉬운 바이너리 파일로 변환하는 과정.

💡 - 빌드 (Build)

소스 코드 파일을 실행 가능한 소프트웨어 산출물로 변환하는 과정이다. 컴파일만 해서는 실행 가능한 결과가 나오지 않는다. 프로젝트에 포함한 리소스(이미지, 컬러 등 Swift 코드가 아닌 것들)까지 모두 말아서 실행 가능한 결과를 만든다.

앱 생명주기 (App Lifecycle)

▪️ Unattached (= Not Running)

앱을 실행 중이지 않은 상태.

▪️ Foreground Inactive

앱을 실행했지만 사용자로부터 이벤트를 받을 수 없는 상태.

앱을 완전히 활성화하기 이전 단계.

▪️ Foregound Active

앱을 실행했고 사용자로부터 이벤트를 받을 수 있는 상태.

가장 일반적인 앱을 사용하고 있는 상태.

▪️ Background

앱을 실행한 뒤 백그라운드로 넘어간 상태.

홈버튼을 눌러 밖으로 나갔을 때의 상태.

그래도 메모리에 올라가있는 상태이다.

ex) 멜론 앱이 홈 화면에서도 음악을 계속 재생하는 상태

▪️ Suspend

백그라운드 상태에서 앱이 특별한 작업을 필요로 하지 않을 경우 접어드는 상태

OS 가 판단하여 Background → Suspend 상태로 변환시킨다.

ex) 게임 앱을 동시에 30개 켜면 (기기 메모리에 부담스러운 상황을 연출하면), 비교적 초반에 실행한 앱들은 백그라운드에서 Suspend 상태로 넘어가, 돌아갔을 때 앱이 재실행되는 경우가 있다.

AppDelegate & SceneDelegate

AppDelegate

프로젝트를 생성하면 자동으로 생성되는 클래스.
앱의 생명주기와 관련된 다양한 메서드들을 제공하는 클래스.

ex 1) didFinishLaunchingWithOptions (위 캡처화면에서 보이는 메서드)

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Override point for customization after application launch.
    return true
}

이 메서드는 앱이 실행할 준비를 마친 초기 상황에 실행된다.

따라서 앱을 실행한 극 초반에 세팅해야 할 코드들을 이곳에 작성하면 된다.

ex 2) didBecomeActive

이 메서드는 앱의 상태가 inActive에서 Active로 변하기 직전에 실행된다.

따라서 앱이 Active한 상태가 되기 전에 작성하고 싶은 코드들을 작성한다.

예를 들어 앱이 백그라운드에 갔다가 돌아올 때마다 화면에 보이는 정보들을 업데이트하고 싶다. 이런 경우에 이 메서드를 활용할 수 있다.

SceneDelegate

프로젝트를 생성하면 자동으로 생성되는 클래스.
Scene 을 다루는 클래스. iOS13부터 등장.
멀티 윈도우 환경에서 다중 Scene의 개념이 생겨났다.
아이패드에서 가로 모드, 화면 분할을 하면 각 분할된 화면이 Scene 을 의미.
그전에는 AppDelegate가 SceneDelgate의 역할까지 모두 수행했다.

퍼스트파티 & 서드파티

▪️ 퍼스트 파티 (제1자)

iOS 개발은 애플이 주관하기 때문에, 애플이 제공하는 툴들을 퍼스트 파티라고 한다.

ex) UIKit, URLSession 등

▪️ 서드 파티 (제3자)

애플이 오피셜 하게 만든 것이 아닌, 제3자가 제공하는 툴들을 서드 파티라고 한다.

ex) SnapKit (UI를 편하게 짜도록 돕는 라이브러리)

Alamofire (URLSession 을 편하게 사용하도록 돕는 라이브러리)

KingFisher (이미지 로드를 편하게 하도록 돕는 라이브러리)

Swinject (DI 및 ServiceLocating 을 편하게 하도록 돕는 라이브러리)

CocoaPods, SPM(Swift Package Manager), Carthage 등을 이용해서 서드파티 라이브러리를 프로젝트에 받아올 수 있다.

디버깅, llldb 개념

디버깅

디버깅이란?

디버깅(Debugging)이란 소프트웨어에서 발생하는 오류(bug)를 찾아내고 수정하는 과정. 프로그램이 예상대로 작동하지 않을 때 그 이유를 찾아내고, 그 문제를 해결하는 작업.

print() 문으로 디버깅하기

// ViewController.swift 

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        let randomNumber = getRandomNumber()
        print("randomNumber = \(randomNumber)")
    }

    // 0 부터 100 중 랜덤한 수를 리턴하는 함수
    func getRandomNumber() -> Int {
        return Int.random(in: 0...100)
    }
}

OSLog 로그 찍기

import UIKit
import OSLog

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        os_log(.default, "(default) randomNumber = \(self.getRandomNumber())")
        os_log(.debug, "(debug) randomNumber = \(self.getRandomNumber())")
        os_log(.info, "(info) randomNumber = \(self.getRandomNumber())")
        os_log(.error, "(error) randomNumber = \(self.getRandomNumber())")
        os_log(.fault, "(fault) randomNumber = \(self.getRandomNumber())")
    }

    // 0 부터 100 중 랜덤한 수를 리턴하는 함수
    func getRandomNumber() -> Int {
        return Int.random(in: 0...100)
    }
}

브레이크포인트 찍기

16 번 라인 숫자를 클릭해서 파란색 브레이크 포인트 생성.
브레이크 포인트를 삭제하려면 드래그해서 밖에다가 버리면 됨.
아래 디버그 영역에 randomNumber = (Int) 75 출력된 것 확인.
아래 디버그 영역에서 재생 버튼 누르면 브레이크가 풀리며 다시 원래 흐름대로 이어서 실행됨.

lldb

💡- lldb 란?

Low Level Debuger의 줄임말. 디버그 영역 중 오른쪽 영역에 lldb를 사용해서 디버깅을 할 수 있다. 브레이크 포인트와 함께 사용하면 효과가 좋다.

po 명령어: print object의 줄임말로, 객체에 대한 값을 출력한다. 가장 많이 사용하게 될 명령어.

위 캡처 사진처럼 맥락 안에서 어느 정도 자동완성도 지원을 해준다.

po randomNumber > 100처럼 계산식을 입력해서 그에 대한 결과값도 받을 수 있다.
cmd + K를 눌러서 디버그 창을 깨끗하게 비울 수 있다.

expression 명령어: 변수를 선언할 수 있게 해준다.

expression let $x = 100 : x = 100 선언.

expression randomNumber : lldb 영역 내에서 randomNumber를 $R0 이라는 변수로 선언. 새롭게 선언할 때마다 $R1, $R2 로 자동 선언.

po $R0 + $x : 두 값을 더한 값 출력

Xcode 시작

Fri, 15 Nov 2024 06:55:12 GMT

Xcode 이해

Xcode는 애플 소프트웨어 개발을 위한 IDE.
iOS, macOS, watchOS, tvOS 등 개발 가능.
Swift, Objective-C로 개발 가능.

Xcode release notes.
release note 란 새로운 버전이 출시(release) 되었을 때 이 버전에 대한 정보를 정리한 노트.
Xcode 버전 별로 지원하는 iOS, macOS 버전이 다르므로 주의.
맥북 왼쪽 위 사과 버튼 → 이 mac에 관하여를 보면 나의 macOS 버전을 볼 수 있음. 링크텍스트

Xcodes = 다양한 Xcode 버전을 담는 프로그램.
여러 개의 프로젝트를 동시에 진행 중이고, 각각의 프로젝트에서 모두 다른 Xcode 버전이 필요한 상황이라면? 링크텍스트

Xcode 15.1 다운로드

STEP 1

먼저, 지원하는 버전 확인.
Xcode 15.1 Release Notes의 Overview를 읽어보면, macOS 버전이 Ventura 13.5 이후 버전이어야 함이 명시되어 있음.
먼저 본인 맥북의 macOS를 Ventura 13.5 이상 or Sonoma로 맞추어야 합니다.

STEP 2

다운로드 링크로 이동.
검색창에 Xcode 15.1 검색
View Details → Xcode 15.1 (.xip) 클릭해서 다운로드
Xcode 15.1 (.xip 파일) 다운로드.

STEP3

파일 압축 해제 하면 다운로드 완료.
Xcode 실행 모습
Version 15.1 확인

Xcode 둘러보기

프로젝트 생성

Create New Project -> App → ProductName 입력 → Next → 프로젝트 위치 설정 → 생성 완료

항목	설명	비고
Product Name	생성할 프로젝트 이름	ex) MyTestApp, MyTestProject
Team	애플 개발자 인증서 선택	없을 경우 None 선택. 인증서가 있어야 실제 기기로 테스트하거나 앱스토어에 배포 가능
Organization Identifier	조직 or 도메인 이름 입력	한 회사에서 여러 개의 앱을 낼 수 있음.한 개발자가 여러 개의 앱을 낼 수 있음 - com.adam.app1 - com.adam.app2
Bundle Identifier	앱 고유 아이디	- com.adam.MyTestApp
Interface	User Interface 선택	여기서는 Storyboard 선택
Storage	Core Data 사용 여부	이 강의에서는 None 선택
Include Tests	테스트 코드 작성 여부	테스트 코드란, 내 코드를 테스트(검증)하기 위한 코드

Apple Developer Certificates - 애플 개발자 인증서란? 🤔

내가 애플의 인증을 받고 앱스토어에 앱을 낼 수 있는 개발자라는 증명서

Apple Developer Program에 등록하면 받을 수 있음. 매년 99달러 (약 13만 원)

실기기로 테스트하려면 인증서 필요

앱스토어에 앱을 배포하려면 인증서 필요

Organization Identifier & Bundle Identifier 개념

Organization Identifier
- com.coupang
- com.kakao
Bundle Identifier
- com.coupang.Coupang
- com.coupang.coupang-eats
- com.coupang.play

iOS개요

Thu, 14 Nov 2024 11:24:21 GMT

~~내일만 버티면 금요일이다.이걸 보는 모두 화이팅..~~

iOS 개발에 대한 기본적인 이해

애플은 기기에 따른 다양한 운영체제들을 지원 중.
(아이폰 - iOS), (맥북 - macOS), (애플워치 - watchOS)
(애플 TV - tvOS), (비전 pro - visionOS)
모두 Objective-C, Swift로 개발 가능.
iOS 개발을 하기 위해서는 반드시 macOS 기반으로 개발.
iOS 개발자가 된다는 건, 개발뿐만 아니라 애플이 제공하는 기기와 운영체제들에 대한 깊은 이해를 가지게 된다는 것.
앱을 출시하기 위해서는 앱스토어 심사과정 필요.
HIG (애플의 앱 디자인 가이드) 등 애플의 철학 이해 필요.
나아가서는 iOS 와 macOS 버전에 따른 변화 파악. 링크텍스트 링크텍스트 ~~들어가지마세요. 책임안져요.~~
네이티브 앱

각 OS 환경에 최적화된 네이티브 언어로 개발된 앱.

-Swift로 개발한 iOS 앱. -Kotlin으로 개발한 Android 앱.

ex) 카카오, 쿠팡, 당근 마켓, 티맵, 쏘카, 스노우 등
하이브리드 앱

Android, iOS 플랫폼 모두 돌아가도록 개발한 앱.

-React Native, JavaScript로 개발. -Flutter - Dart로 개발.

ex) 페이스북, 인스타그램 등
웹 앱

웹 기술을 사용해 웹 사이트를 모바일 앱 형태로 개발.

ex) 네이버, 크롬 등

🙋🏻‍♂️ Android, iOS 둘 다 가능한 하이브리드 앱개발이 네이티브 앱개발보다 무조건 좋은 거 아닌가요?

→ 🙅🏻‍♂️ 각각의 장단점이 존재합니다.

하이브리드 앱은 Android, iOS 앱에서 모두 돌아가도록 한 번에 개발을 할 수 있지만, 이를 다른 말로 옮겨보면, 두 운영체제를 동시에 관통하는 일반적인 코드를 작성하게 되기 때문에, 반대로 각각의 고유한 특성을 활용하는 데에는 한계가 있다는 것을 의미.

ex1) 카메라 기능을 사용하는 SNOW 같은 앱을 개발한다면?

안드로이드 폰의 카메라와 아이폰의 카메라는 근본적으로 다를 수밖에 없기 때문에, 하이브리드 앱으로는 각 카메라 하드웨어의 깊은 곳까지 파고드는 기능을 사용하는 데에는 한계 존재.

ex2) 기기의 GPS 기능을 자주 활용하는 Tmap 같은 네비게이션 앱을 개발한다면?

하이브리드 앱보다 네이티브 앱이 플랫폼 친화적이기 때문에 GPS 활용 수행 능력이 좋음.

서버 개발, 안드로이드 개발과의 비교

네모의 앱 로그인 기능을 구현한다고 했을 때.
- 서버: 데이터베이스에 유저 정보를 저장. 유저가 아이디와 비밀번호를 입력해서 로그인 요청을 했을 때 정합성 파악.
- iOS: 로그인 페이지의 텍스트 뷰, 버튼 구현. 유저가 입력한 아이디와 비밀번호를 가지고 서버에 로그인 요청. 유저 로그인 정보 기기에 저장.
- Android: 같은 내용을 Kotlin으로 구현.

서버 개발자는 앱스토어의 심사 개념이라든지, 애플의 디자인 철학이 어떻게 된다든지 이런 건 자세하게 몰라도 됨.

안드로이드 개발자도 마찬가지. 각 개발자는 각자의 영역에 대해서 집중.

iOS 개발자로 회사에 들어간다라는건 이런 부분들을 맡아서 전문성 있게 잘 해내준다는 걸 의미.

효율적인 공부 방법

개발 입문 단계에서는 검색으로 해결 못하는 것이 없음. ~~반박시 죄송합니다.~~
Google 과 StackOverflow를 활용.
검색 키워드에 “iOS”보단 “Swift”를 붙이는 게 좋음.
뭔가 동작을 잘 안 할 때 “issue” or “not work” 검색.
키워드 끝에 “doc”을 붙이면 관련 애플 공식 문서 노출. 링크텍스트

앱에서 버튼을 구현할 일이 생겼다. 근데 나는 아무것도 할 줄 모른다.

CASE 1 UIButton 관련 문서를 정독하고, 관련 서적 찾아 UIButton의 모든 속성들에 대해 공부한 뒤 코드를 작성. (BackgroundColor, Title Color, Button State, 테두리 만드는 법, shadow 등 등 너무 많음.)
CASE 2 구글에 “Swift 버튼 구현” 검색하고 따라 해본 뒤 직접 해보면서 이해.

→ CASE 2가 더 효율적. 직접 코드를 작성하시고 부딪혀보시면서 몸으로 느끼면서 공부하는 것이 효율적.

CS 공부. 중요한가요?

CS 공부, 중요하긴 중요하다.
하지만 지금 당장 몰라도 충분히 iOS 개발을 할 수 있다.
구글에 “개발자 CS 면접 준비”라고 검색하면 좋은 자료들 多.
iOS 개발자는 운영체제, 자료구조 > 네트워크 > 그 외 순으로 중요.
전공서 사서 공부하기 X.

다 알면 좋지만, 현재로써는 다 알기보다는 중요도에 맞춰서 하는걸 추천. 데이터 베이스가 서버를 공부할 경우 추천하지만, iOS는 비교적 중요도가 낮아서 오히려 운영체제(메모리를 관리하는 방법), 자료구조(데이터 다루는 기본적 구조)를 공부하면 좋다.

Swift 문법종합 - 메모리

Wed, 13 Nov 2024 12:11:38 GMT

12. 메모리로 보는 자료구조

CPU는 컴퓨터의 중앙처리장치로, 프로그램의 연산을 실행하고 처리하는 하드웨어이며, 메모리에 저장된 데이터를 직접 처리하는 역할을 합니다.
앞에서 예시로 들었던 var, let, 함수 등은 메모리에 할당되어 있어요.
메모리란?
메모리는 프로그램이 실행될 때 데이터를 저장하는 임시 공간입니다.
채팅앱을 사용한다고 가정해보죠!
- 친구 목록이나 주고받은 채팅들이 화면에 보여진다는 것은 핸드폰 어딘가에 정보들이 저장되어 있다는 것을 의미합니다.
- 이 저장되어 있는 영역을 메모리(RAM)이라고 합니다.
- 아이폰에서 앱을 누르면 iOS는 앱을 위해 메모리에 영역을 설정해줍니다.
  - 실행한 앱은 여기 영역만 쓰세요~ 라고 영역을 정해주는 거죠!
  - 나중에 우리가 작성한 코드도 메모리에 저장됩니다!
  - 우리가 사용하는 변수나 상수의 값들도 메모리에 저장돼요!
  - 메모리에는 영역이 나뉘어져 있다.

Swift 문법종합 - trailing closure

Tue, 12 Nov 2024 12:45:27 GMT

10-2. trailing closure (트레일링 클로저)

클로저에는 경량화 방법이 많이 존재하는데 그 중 하나인 트레일링 클로저에 대해서 알아볼게요!
함수를 호출할 때 마지막 파라미터가 클로저일 때 괄호를 닫은 뒤 작성할 수 있습니다.
장점
클로저를 함수 호출 외부에 작성해서 클로저의 구현부가 길어지면 가독성이 읽기 편합니다.

func trailingTest(key: String, closure: () -> Void) {
    print(key)
    closure()
}

trailingTest(key: "Key name", closure: { // 원래는 이렇게 만들어야 하지만 아래처럼 가능
    print("Hello")
})

trailingTest(key: "Hello") { 
    print("World")
}

Swift 문법종합 - 클로저

Mon, 11 Nov 2024 11:47:18 GMT

10-1. 클로저

[코드스니펫] 클로저 구현 코드

let closure: (Int, String) -> Void = { intValue, stringValue in 
                                // in 키워드를 사용하여 앞에는 파라미터 이름을 뒤에는 구현부를 작성합니다.
    print(intValue)
    print(stringValue)
}
// ⬆️ 오랜만에 한국말로 읽어보기! 
// closure 상수의 타입은 클로저로 Int, String 타입의 파라미터가 있고 Return은 없습니다.
// 할당값은 클로저의 구현입니다.

// 파라미터의 이름을 생략하면 구현부에서 $0로 사용할 수 있습니다.
// 파라미터의 이름을 생략했기 때문에 in 키워드도 생략합니다. 
let closure2: (Int) -> Void = { 
    print($0)
}

let closure3: () -> Void = {
    print("Hello")
}

// 파라미터의 이름을 value라고 사용하고 Int값을 리턴합니다.
let closure4: (Int) -> Int = { value in
    return value * 2
}

let closure5: (String, Int) -> Int = {
    return $0.count + $1
}

let optionalClosure: ((Int) -> Int)? = { value in
    return value * 2
}

// 파라미터가 없을 때는 in을 사용하면 안됩니다. 
let emptyParameterClosure: () -> Void = {
    print("World")
}

익명 함수 라고 불리는 클로저는 함수와 유사하게 특정 작업을 수행하는 코드블록 입니다.
함수의 4가지 요소(이름, 파라미터, 반환타입, 구현부)에서 이름 을 제외한 파라미터, 반환타입, 구현부 로 구성되어 있습니다.
데이터타입으로 클로저를 사용할 수 있습니다.
- 변수에 할당하여 재사용할 수 있습니다.
- 함수의 파라미터로 전달할 수 있습니다.
클로저가 함수 안에 포함된 것이 아니라 클로저 안에 함수가 포함되어 있습니다.

코드의 재사용성을 높이고, 비동기 처리, 컬렉션 연산 등의 장점이 있습니다.

// 타입으로 사용할 때 표현방법
(파라미터 데이터 타입) -> 리턴 타입

파라미터의 타입은 없을 때 비워두고, 리턴 타입이 없는경우 Void 라고 명시합니다.
파라미터가 없을때도 () 괄호는 있어야 합니다!
데이터 타입으로 사용할 수 있기 때문에 Optional 타입으로 사용할 수 있습니다. 이 때 전체를 () 로 감싼 후 ? 를 입력해야 합니다.

let closure: (Int, String) -> Void // 파라미터는 튜플(Int, String) 타입이고
                                                                     // 반환타입은 없습니다.
                                                                     // 만약 -> Void가 생략되었다면 튜플과 같죠!?

let closure2: (Int) -> Void        // 파라미터는 1개로 Int이며 반환타입은 없습니다.

let closure3: () -> Void           // 파라미터는 없고 반환타입은 없습니다.
                                                                     // 파라미터는 ()로 감싸고 있어서 Void를 생략할 수 있어요.

let closure4: (Int) -> Int         // 파라미터는 1개이고 Int 타입이며, 반환값은 Int 입니다. 
let closure5: (String, Int) -> Int // 파라미터는 튜플(String, Int) 타입이고
                                                                     // 반환타입은 Int 입니다.

let optionalClosure: ((Int) -> Int)? // 옵셔널 타입입니다.
                                                                         // 만약 ()가 없었다면 리턴값이 Int? 라고 판단됩니다!

클로저 구현하는 방법

클로저는 익명함수 이므로, 구현할 때 in 키워드를 사용하여 파라미터와 구현부를 구분해야 합니다.

// 기본적인 구현 방법
// 중괄호로 시작하고 파라미터와 구현부 부분을** in ** 키워드를 사용하여 나눕니다.
{ 파라미터 이름 in  
    // 구현부
    // 리턴
}

in 키워드를 사용하여 앞에는 파라미터 이름을 뒤에는 구현부를 분리하여 작성합니다.
파라미터 이름은 생략 가능하며 0번째 파라미터 $0 으로 사용할 수 있습니다. ($0, $1, $2 …) 파라미터 이름을 생략할 때는 in 키워드까지 생략해야 합니다.
파라미터가 없다면 in 을 생략해야 합니다.
파라미터 이름은 사용하실 이름을 자유롭게 작성하면 됩니다.

[코드스니펫] 클로저 구현 코드

let closure: (Int, String) -> Void = { intValue, stringValue in 
                                // in 키워드를 사용하여 앞에는 파라미터 이름을, 뒤에는 구현부를 작성합니다.
    print(intValue)
    print(stringValue)
}
// ⬆️ 오랜만에 한국말로 읽어보기! 
// closure 상수의 타입은 클로저로 Int, String 타입의 파라미터가 있고 Return은 없습니다.
// 할당값은 클로저의 구현입니다.

// 파라미터의 이름을 생략하면 구현부에서 $0로 사용할 수 있습니다.
// 파라미터의 이름을 생략했기 때문에 in 키워드도 생략합니다. 
let closure2: (Int) -> Void = { 
    print($0)
}

let closure3: () -> Void = {
    print("Hello")
}

// 파라미터의 이름을 value라고 사용하고 Int값을 리턴합니다.
let closure4: (Int) -> Int = { value in
    return value * 2
}

let closure5: (String, Int) -> Int = {
    return $0.count + $1
}

let optionalClosure: ((Int) -> Int)? = { value in
    return value * 2
}

// 파라미터가 없을 때는 in을 사용하면 안됩니다. 
let emptyParameterClosure: () -> Void = {
    print("World")
}

클로저를 사용(호출)하는 방법

클로저를 변수나 상수에 저장했다면 함수처럼 이름뒤에 괄호를 사용하면 됩니다.
옵셔널 변수에 저장한 클로저는 변수이름?() 형식으로 사용하면 됩니다.
구현하고 즉시 호출한 결과값을 저장하고 싶다면 {} 뒤에 괄호() 를 사용하면 됩니다.

// 변수에 저장한 클로저 호출
let closure: (Int, String) -> Void = { intValue, stringValue in
    print(intValue)
    print(stringValue)
}

closure(10, "20")

/* 출력 값
10
20
*/

// 옵셔널 변수에 저장한 클로저 호출

let optionalClosure: ((Int) -> Int)? = { 
    return $0 * 2
}

print(optionalClosure?(10)) // 옵셔널 상수 optionalClosure의 클로저를 호출합니다.
                                                      // 상수의 타입이 optional이기 때문에 결과값이 Optional로 나옵니다.

/* 출력 값
Optional(20)
*/

// 옵셔널 변수에 저장한 클로저 호출

let optionalClosure: ((Int) -> Int)? = { 
    return $0 * 2
}

print(optionalClosure?(10)) // 옵셔널 상수 optionalClosure의 클로저를 호출합니다.
                                                      // 상수의 타입이 optional이기 때문에 결과값이 Optional로 나옵니다.

/* 출력 값
Optional(20)
*/

// 구현하고 바로 호출

// 클로저를 구현하고 바로 실행하여 결과값을 helloClosure 상수에 할당합니다.
let helloClosure = {
    return "안녕하세요! 구현하자마자 바로 실행해보겠습니다!"
}()

print(helloClosure) // 안녕하세요! 구현하자마자 바로 실행해보겠습니다!

Swift 심화 - 숫자 야구

Fri, 08 Nov 2024 01:09:36 GMT

배경

Level2의 "오류가 날 수 있는 예외처리 상황에 대해 고민해보기 + 구현하기"라는 문항을 보고, 예외처리와 오류를 어떻게 효과적으로 다룰 수 있을지 고민하며 야구 게임을 구현했습니다. 게임 내에서 발생할 수 있는 다양한 예외 상황을 처리하기 위해 여러 방안을 고려했으며, 이를 코드로 구현해보았습니다.

발단

게임에서 사용자가 입력하는 값이나 예상치 못한 상황에서 오류가 발생할 수 있습니다. 예를 들면:

사용자가 잘못된 범위의 숫자를 입력할 경우 : 특정 연산에서 예기치 않게 잘못된 상태가 발생할 경우 (예: 점수 계산, 게임 종료 조건 등)
게임이 여러 번 반복되면서 상태가 꼬이는 경우 : 이런 예외 상황들을 미리 처리하지 않으면 게임의 흐름이 중단되거나 예상치 못한 오류가 발생할 수 있습니다.

전개

게임을 구현하면서 몇 가지 문제에 직면했습니다:

사용자의 잘못된 입력 처리: 사용자가 숫자가 아닌 값을 입력하거나, 범위를 벗어난 값을 입력할 경우 이를 처리해야 했습니다. 게임 종료 조건 처리: 게임이 끝난 후 계속해서 입력을 받는 오류가 발생할 수 있었습니다. 불필요한 상태 변경: 게임이 진행되는 도중, 사용자가 잘못된 입력을 했을 때 상태가 변경되지 않도록 해야 했습니다. 이를 해결하기 위해서는 예외를 처리하는 조건문을 추가하고, 사용자가 입력하는 값에 대해 더 철저히 검증해야 했습니다. 또한, 게임의 상태를 관리하는 방법을 개선하여 불필요한 상태 변경을 방지해야 했습니다.

위기

게임 진행 중에 예외 처리 코드가 너무 많아져 코드의 가독성이 떨어졌다. 게임 종료 조건을 정확하게 처리하지 못해, 게임이 끝난 후에도 계속 입력을 받는 문제가 발생 Int 타입의 입력값에 대한 예외 처리가 미흡하여 프로그램이 크래시가 날 위험이 있다.

절정

게임의 흐름을 관리하기 위해 게임 상태를 명확히 구분하였고, 예외 처리를 간결하게 처리할 수 있는 방법을 도입했습니다. try-catch 구문을 활용하여 예외를 처리하고, 사용자가 잘못된 입력을 했을 때 즉시 오류 메시지를 출력하고 게임을 종료하거나 입력을 다시 받도록 했습니다.

또한, 게임 종료 후에는 더 이상 입력을 받지 않도록 상태를 관리했습니다. 이를 통해 코드의 가독성을 크게 개선하고, 예외 상황에서 게임이 끊김 없이 정상적으로 동작하도록 만들었습니다.

결말

아래와 같이 게임을 구현할 수 있었고, 예외처리와 입력 검증을 철저히 하여 게임이 더 안정적이고 예측 가능하게 되었습니다. 예외가 발생할 경우, 적절한 오류 메시지를 출력하고 게임이 정상적으로 종료되도록 처리했습니다.

Swift 문법종합 - 함수

Thu, 07 Nov 2024 12:57:57 GMT

8. 함수

/코드스니펫/ 함수의 기본 사용방법

// 함수의 기본 사용방법

// 함수의 정의(선언)
func 함수이름(파라미터 이름: 파라미터 타입) -> 반환타입 {
  // 구현부 
    return 반환 타입의 값
}

// 파라미터가 여러개인 경우
func 함수이름(파라미터1 이름: 파라미터1 타입, 파라미터2 이름: 파라미터2 타입) -> 반환타입 {
  // 구현부 
    return 반환 타입의 값
}

// 파라미터가 없는 경우 
func 함수이름() -> 반환 타입 {
  // 구현부 
    return 반환 타입의 값
}

// 반환값이 없는 경우 
func 함수이름(파라미터 이름: 파라미터 타입) {
    // 구현부
    // 반환타입이 없기때문에 return이 없어도 됩니다.
    // 반환타입이 없는데 중간에 함수를 탈출하고 싶을 때 return을 사용할 수 있습니다.
}

// 파라미터가 없고, 반환값도 없는 경우
func 함수이름() {
    // 구현부
}

함수는 재사용이 가능한 코드의 집합으로, 특정 작업을 수행하는 코드 블록입니다.

함수는 INPUT 을 받아서 작업을 수행하고, OUTPUT을 반환합니다.
동일한 입력에는 동일한 출력이 반환됩니다!

함수는 function이라고 불리며, 코드를 구조적이고 효율적으로 작성하는데 도움을 줍니다.
동일한 작업을 반복해서 작성할 필요 없게 도와줍니다.
함수는 선언과 사용으로 나눌 수 있습니다.
- 함수의 선언 : 함수를 정의하는 과정입니다.
  - func 키워드를 사용하여 시작합니다.
  - 함수 선언의 4가지 요소
    1. 함수의 이름
    2. 파라미터(이름, 타입)
      - 파라미터는 함수에서 사용될 INPUT의 이름과 데이터타입
    3. 반환 타입
      - 함수에서 결과값으로 반환할 데이터 타입
    4. 구현부
      - 실제 작업을 수행하는 코드 블록
- 함수의 사용 : 정의한 함수를 호출하여 실제로 실행하는 과정입니다.
  - 함수의 이름뒤에 () 를 사용하여 함수를 실행합니다.
  - () 안에는 파라미터를 넣을 수 있습니다.
  - 함수를 사용하여 나온 결과값을 변수나 상수에 할당할 수 있습니다.

[코드스니펫] 함수의 기본 사용방법

// 함수의 기본 사용방법

// 함수의 정의(선언)
func 함수이름(파라미터 이름: 파라미터 타입) -> 반환타입 {
  // 구현부 
    return 반환 타입의 값
}

// 파라미터가 여러개인 경우
func 함수이름(파라미터1 이름: 파라미터1 타입, 파라미터2 이름: 파라미터2 타입) -> 반환타입 {
  // 구현부 
    return 반환 타입의 값
}

// 파라미터가 없는 경우 
func 함수이름() -> 반환 타입 {
  // 구현부 
    return 반환 타입의 값
}

// 반환값이 없는 경우 
func 함수이름(파라미터 이름: 파라미터 타입) {
    // 구현부
    // 반환타입이 없기때문에 return이 없어도 됩니다.
    // 반환타입이 없는데 중간에 함수를 탈출하고 싶을 때 return을 사용할 수 있습니다.
}

// 파라미터가 없고, 반환값도 없는 경우
func 함수이름() {
    // 구현부
}

[코드스니펫] 함수의 기본 실습

// 실제로 사용해 봅시다!

// 함수의 선언
func sayHello(name: String) -> String { // sayHello 이름의 함수를 정의합니다. 파라미터는 name이며 타입은 String이고, 함수의 반환값의 데이터타입은 String입니다.
    return "\(name)님 안녕하세요!" // 파라미터 name을 사용하여 문자열을 만들어 반환합니다.
}
// 함수의 사용
sayHello(name: "Swift 기초반") // 결과값은 문자열로 "Swift 기초반님 안녕하세요!" 입니다.



// 함수의 선언
func printHello() {
    print("안녕하세요!")
}
// 함수의 사용
printHello()


func add(a: Int, b: Int) -> Int {
    return a + b
}

let result = add(a: 3, b: 5) // add 함수를 사용하여 받은 결과값을 result 상수에 할당합니다. 
print(result) // 8

함수 파라미터 이름의 분리

함수의 구현부에서 사용하는 이름과 함수 호출할 때 사용하는 이름을 다르게 설정할 수 있습니다. 기본적으로 함수의 선언부에서 정한 파라미터의 이름은 함수의 구현부와 호출부에서 동일하게 사용됩니다.

 func sayHello(name: String) {
        print("\(name)님 안녕하세요.")
}

sayHello(name: "수강생") 

// sayHello 함수를 정의하는 곳에서 파라미터의 이름이 name이면 
// sayHello 함수를 호출하는 곳에서도 파라미터의 이름은 name을 사용합니다.

Swift에서는 구현부에서 사용하는 파라미터의 이름과 호출부에서 사용하는 파라미터의 이름을 다르게 할 수 있습니다.

첫번째 이름: 함수를 호출할 때 사용하는 이름
두번째 이름: 함수 구현부에서 사용하는 이름

// 스페이스로 띄우고 파라미터 이름을 2개 입력하면 호출, 구현부 에서 사용하는 이름을 정할 수 있습니다.
func sayHello(to name: String) { 
    print("\(name)님 안녕하세요.")
}

// 함수를 정의한 곳에서 파라미터의 이름이 2개 있을 때 첫번째 값이 호출할때 사용하는 이름입니다.
sayHello(to: "수강생") 


// _ 를 사용하여 파라미터의 이름을 생략할 수 있습니다.
// _는 보통 생략하는데 사용됩니다.
// 위에와 동일하게 정의하는 곳에서 파라미터 이름이 2개로 들어가 있습니다.(_, name)
func sayBye(_ name: String) {
    print("\(name)님 안녕히가세요.")
}

sayBye("수강생")

Swift Convention Guide No.5 → 함수의 코드 스타일

함수의 이름은 소문자로 시작해서 Camel Case로 맞춰주세요.
파라미터의 이름은 소문자로 시작해서 Camel Case로 맞춰주세요.
-> 연산자 앞뒤로 공백을 넣습니다.

// ✅ 함수의 이름은 messageToBirthday로 message to birthday 의 Camel Case
// ✅ 파라미터의 이름은 isTodayBirthDay로 소문자 Camel Case
func messageToBirthday(isTodayBirthDay: Bool) -> String {
    // 구현부
}

// ❌ 함수의 이름이 소문자로 시작하지만 Camel Case가 아니여서 읽기 힘들어요.
// ❌ 파라미터의 이름이 소문자로 시작하지만 Camel Case가 아니여서 읽기 힘들어요.
func messagetobirthday(istodaybirthday: Bool) -> String {
    // 구현부
}

Swift 문법종합 - 조건문

Wed, 06 Nov 2024 11:10:36 GMT

6. 조건문

*- if문 실습 *var age = 15

if age >= 20 {
    print("20살이 넘은 성인입니다")
} else if age >= 17 {
    print("20살 미만이고 17살 이상인 고등학생입니다.")
} else if age >= 14 {
    print("17살 미만이고 14살 이상인 중학생입니다.")
} else {
    print("어린이 입니다!")
}

// 위의 코드를 한줄씩 번역해 볼게요!
let age = 15  // age 상수에 15를 할당합니다.

if age >= 20 { // 만약 age가 20 이상이면 아래 코드블록을 실행합니다.
    print("20살이 넘은 성인입니다")
} else if age >= 17 { // 만약 age가 20 미만이고 17이상이면 아래 코드블록을 실행합니다.
    print("20살 미만이고 17살 이상인 고등학생입니다.")
} else if age >= 14 { // 만약 age가 17 미만이고 14이상이면 아래 블록을 실행합니다.
    print("17살 미만이고 14살 이상인 중학생입니다.")
} else { // 위의 조건들이 모두 false이면 else 의 code block을 실행합니다.
    print("어린이 입니다!")
}


if 10 > 20 { // 만약 10 이 20보다 크다면 아래 코드블록을 실행합니다.
    print("10은 20보다 큽니다!!!")
} else { // 만약 10이 20보다 크지 않다면 아래 코드블록을 실행합니다.
    print("10은 20보다 작습니다!!!")
}

- 조건문 실습 1

let score = 80

switch score {
    case 90...100:
        print("A 등급 입니다!")
    case 80..<90:
        print("B 등급 입니다.")
    case 70..<80:
        print("C 등급 입니다.")
    default:
        print("D 등급 입니다.")
}

// 번역

let score = 80 // score 이름의 상수에 80을 할당합니다.

switch score { // score를 switch 코드블록에 넣습니다. 
    case 90...100: // score가 90이상 100점 이하일 때 아래 코드를 실행합니다.
        print("A 등급 입니다!")
    case 80..<90: // score가 80이상 90미만일 때 아래 코드를 실행합니다.
        print("B 등급 입니다.")
    case 70..<80: // score가 70이상 80미만일 때 아래 코드를 실행합니다.
        print("C 등급 입니다.")
    default: // score가 위에 조건문에서 true가 하나도 없었다면 아래 코드를 실행합니다.
        print("D 등급 입니다.")
}

- 조건문 실습 2

**var score = 50

switch score {
    case 90...:
        break
    default:
        print("공부를 더 하세요!")        
}

// 출력 
// "공부를 더 하세요!"

switch score {
case 50...:
    print("50점 이상이시군요")
    fallthrough
case 50:
    print("딱 50점이시네요?")
default:
    print("공부를 더 하세요!")
}

// 출력 
// "50점 이상이시군요"
// "딱 50점이시네요?" 


// 번역
var score = 50 // score 라는 변수에 값 50을 할당합니다.

switch score { // score를 switch 코드블록에 넣습니다.
    case 90...: // score가 90보다 크다면 아래 코드를 실행합니다.
        break     // 아무런 행동을 하지 않고 코드블록에서 탈출합니다.
    default:   // score가 위의 조건에 맞지 않는다면 아래 코드를 실행합니다.
        print("공부를 더 하세요!")         
}

// 출력 
// "공부를 더 하세요!"

switch score { // score를 switch 코드블록에 넣습니다.
case 50...: // score가 50 이상이면 아래 코드를 실행합니다.
    print("50점 이상이시군요")
    fallthrough // 아래의 case도 확인합니다.
case 50: // score가 50이면 아래 코드를 실행합니다.
    print("딱 50점이시네요?")
default: // score가 위의 조건에 맞는게 없다면 아래 코드를 실행합니다.
    print("공부를 더 하세요!")
}

프로그램의 흐름을 제어하는 문법으로, 특정 조건이 true 인지 false인지에 따라 코드블록을 실행하거나 건너뛸 수 있습니다.

**- if

조건이 true 이면 코드 블록을 실행하고, false 이면 else 의 코드블록이 실행됩니다.
if 와 else 중간에 조건을 추가하려면 else if 로 조건을 추가할 수 있습니다.

- if문 실습

if 10 > 20 { // 만약 10 이 20보다 크다면 아래 코드블록을 실행합니다.
    print("10은 20보다 큽니다!!!")
} else { // 만약 10이 20보다 크지 않다면 아래 코드블록을 실행합니다.
    print("10은 20보다 작습니다!!!")
}


var age = 15 

if age >= 20 {
    print("20살이 넘은 성인입니다")
} else if age >= 17 {
    print("20살 미만이고 17살 이상인 고등학생입니다.")
} else if age >= 14 {
    print("17살 미만이고 14살 이상인 중학생입니다.")
} else {
    print("어린이 입니다!")
}

/*
// 위의 코드를 한줄씩 번역해 볼게요!
var age = 15  // age 상수에 15를 할당합니다.

if age >= 20 { // 만약 age가 20 이상이면 아래 코드블록을 실행합니다.
    print("20살이 넘은 성인입니다")
} else if age >= 17 { // 만약 age가 20 미만이고 17 이상이면 아래 코드블록을 실행합니다.
    print("20살 미만이고 17살 이상인 고등학생입니다.")
} else if age >= 14 { // 만약 age가 17 미만이고 14 이상이면 아래 블록을 실행합니다.
    print("17살 미만이고 14살 이상인 중학생입니다.")
} else { // 위의 조건들이 모두 false이면 else의 code block을 실행합니다.
    print("어린이 입니다!")
}
*/

- Guard

guard 는 조건이 false일 때 코드를 더이상 실행시키지 않고 코드블록을 빠져나가는 조건문입니다.
조건이 true일 경우 코드를 계속 진행하고, false일 경우 else 코드 블록에서 탈출해야합니다.
else 블록은 필수입니다.

guard 조건 else { 
    // 조건이 false 일 때 실행되는 코드블록  
    // return, break, continue, throw등 코드블록을 종료하는 구문이 필요
    return 
}

// 만약 위에서 조건이 false라면 아래 코드는 실행되지 않습니다.
// ealry exit (빠른 탈출)이라고도 불립니다.

// 조건이 true이면 아래의 코드를 게속 진행합니다.

// 반복문에서 사용하는 guard

for i in 0...10 {
    print(i)
    guard i < 5 else { break }  
}

/* 출력 값
0
1
2
3
4
5
*/

// 한국말로 풀어보기
for i in 0...10 { // 0부터 10까지 반복합니다. 현재값은 i에 넣습니다.
    print(i) 
    guard i < 5 else { break }   // i가 5보다 작다면 true이기 때문에 계속 진행합니다.
                                                             // i가 5보다 크다면 false이기 때문에 else 코드블록을 실행합니다.
                                                             // else 코드블록에서는 for 반복문을 탈출하는 break 
}

if vs guard

if 조건문은 true 일 때 코드블록을 실행하고, false 일 때 다른처리를 할 수 있습니다.
guard 조건문은 false일 때 즉시 탈출하는 방식입니다.
if 조건문은 코드블록을 명시적으로 작성해야 하지만 guard 는 true 일 때 코드블록이 없고 계속 진행합니다.

- guard 는 아래의 더이상 코드를 진행하지 못하게 하는 경비원 같은 존재

- if는 코드블록에 들어갈 수 있는 티켓 놀이공원에 입장하려면 티켓이 필요해요. 그리고 놀이공원 안에서만 사용할 수 있다고 생각하면 된다.

Switch

하나의 값을 여러 경우와 비교하는 조건문입니다.
모든 경우의 조건을 처리해야 합니다.
case, default 를 사용해서 조건들에 맞는 코드를 실행할 수 있습니다.
case 에서 조건을 확인하여 조건이 맞다면 코드를 실행하고 switch 코드블록에서 빠져나갑니다.
case 에서 맞는 조건이 없다면 default 에서 구현한 코드가 실행됩니다.
case, default 조건 뒤에는 : 을 사용하여 동작을 구현해야 합니다.
case 에서 실행하고 싶은 코드가 없다면 break 키워드를 사용해야 합니다.
- 아무런 코드가 없으면 빌드오류가 발생합니다.
case 에서 조건이 없다면 default 코드를 실행합니다.
case 에서 조건이 맞아서 실행된 후 아래의 조건도 확인하고 싶다면 fallthrough 키워드를 사용해야 합니다.

- 조건문 실습 1

let score = 80

switch score {
    case 90...100:
        print("A 등급 입니다!")
    case 80..<90:
        print("B 등급 입니다.")
    case 70..<80:
        print("C 등급 입니다.")
    default:
        print("D 등급 입니다.")
}

// 번역
let score = 80 // score 이름의 상수에 80을 할당합니다.

switch score { // score를 switch 코드블록에 넣습니다. 
    case 90...100: // score가 90이상 100점 이하일 때 아래 코드를 실행합니다.
        print("A 등급 입니다!")
    case 80..<90: // score가 80이상 90미만일 때 아래 코드를 실행합니다.
        print("B 등급 입니다.")
    case 70..<80: // score가 70이상 80미만일 때 아래 코드를 실행합니다.
        print("C 등급 입니다.")
    default: // score가 위에 조건문에서 true가 하나도 없었다면 아래 코드를 실행합니다.
        print("D 등급 입니다.")
}

- 조건문 실습 2

var score = 50

switch score {
    case 90...:
        break
    default:
        print("공부를 더 하세요!")        
}

// 출력 
// "공부를 더 하세요!"

switch score {
case 50...:
    print("50점 이상이시군요")
    fallthrough
case 50:
    print("딱 50점이시네요?")
default:
    print("공부를 더 하세요!")
}

// 출력 
// "50점 이상이시군요"
// "딱 50점이시네요?" 


// 번역
var score = 50 // score 라는 변수에 값 50을 할당합니다.

switch score { // score를 switch 코드블록에 넣습니다.
    case 90...: // score가 90보다 크다면 아래 코드를 실행합니다.
        break     // 아무런 행동을 하지 않고 코드블록에서 탈출합니다.
    default:   // score가 위의 조건에 맞지 않는다면 아래 코드를 실행합니다.
        print("공부를 더 하세요!")         
}

// 출력 
// "공부를 더 하세요!"

switch score { // score를 switch 코드블록에 넣습니다.
case 50...: // score가 50 이상이면 아래 코드를 실행합니다.
    print("50점 이상이시군요")
    fallthrough // 아래의 case도 확인합니다.
case 50: // score가 50이면 아래 코드를 실행합니다.
    print("딱 50점이시네요?")
default: // score가 위의 조건에 맞는게 없다면 아래 코드를 실행합니다.
    print("공부를 더 하세요!")
}

Swift 문법종합 - 반복문

Tue, 05 Nov 2024 11:32:37 GMT

7. 반복문

반복문은 배열이나 Dictionary 같은 Collection Type이나 범위를 반복적으로 접근할 때 사용합니다.

배열은 동일한 데이터 타입의 값을 순서대로 저장하는 Collection Type중 하나입니다.
대괄호를 사용하여 배열을 만들 수 있습니다.

let array = [1, 2, 3, 4, 5] 
// [ ] 안에 데이터들을 넣으면 1,2,3,4,5가 들어가 있는 배열이 만들어집니다.

["봄", "여름", "가을", "겨울"] // 봄, 여름, 가을, 겨울이 저장되어 있는 배열이에요!

for 반복문

for in 을 사용하면 배열(Collection Type)과 범위의 숫자를 반복할 수 있습니다.

// 컬렉션 타입에 대한 for in 반복문

let names = ["Anna", "Alex", "Brian", "Jack"] 

for name in names {
    print(name)
}

// 출력 값 
// Anna
// Alex
// Brian
// Jack

// 해석 

let names = ["Anna", "Alex", "Brian", "Jack"] // names 상수에 배열로 순서대로 "Anna", "Alex", "Brian", "Jack"을 넣습니다.

for name in names { // names 배열 안에 있는 값들을 반복하여 아래 코드블록을 실행합니다. name에 배열의 데이터를 넣습니다.
    print(name)
}

// 숫자의 범위를 사용한 for in 반복문

for index in 0...5 {
    print(index)
}

// 출력 값
// 0
// 1
// 2
// 3
// 4
// 5 

// 한국어 번역
for index in 0...5 { 
  // 0이상 5까지 숫자를 index에 할당하며 반복합니다.
    print(index)
}

while 반복문

while 반복문은 조건이 true 인 동안 코드블록을 반복 실행합니다.
조건이 false가 되면 반복을 종료합니다.

// while 뒤에 조건을 입력하여 사용합니다. 조건이 true이면 코드블록을 실행하고 false이면 코드블록이 실행되지 않고 다음으로 넘어갑니다. 
while 조건 {
        // 반복 실행할 코드
}

[코드스니펫] while 반복문 실습

var happyNewYearCount = 10

while happyNewYearCount > 0 {
    print(happyNewYearCount)
    happyNewYearCount -= 1
}

print("새해 복 많이 받으세요 :)")

/*
출력 값
10
9
8
7
6
5
4
3
2
1
새해 복 많이 받으세요 :)
*/

// 한국말로 풀어보기.

var happyNewYearCount = 10 
// happyNewYearCount라는 이름의 변수에 10을 할당합니다. 

while happyNewYearCount > 0 { 
        // happyNewYearCount가 0보다 크다면 코드블록을 반복하여 실행합니다.
    print(happyNewYearCount) 
    happyNewYearCount -= 1 // happyNewYearCount에 1을 뺀 값을 할당합니다.
}

print("새해 복 많이 받으세요 :)")

while true {
    print("결과가 항상 true여서 영원히 while 코드블록이 실행됩니다 🥲")
}

반복문에서 흐름제어를 도와주는 break continue(크고 진하게)

break

반복문이나 switch에서 즉시 종료하고, 코드블록을 빠져나올 때 사용됩니다.
반복문에서 더이상 반복이 필요 없을 때 사용합니다.
switch에서 특정 case에서 아무런 작업을 하지 않거나, 중간에 작업을 종료하고 싶을 때 사용합니다.

// for 반복문에서 더이상 반복이 필요없는 경우

for age in 15...99 {
    print(age)

    if age >= 20 {
        break
    }
}

/*
출력값 : 
15
16
17
18
19
20
*/

// 한국말로 풀어보기
for age in 15...99 { 
    // 15이상 99까지 반복하여 코드블록을 실행합니다. 현재 숫자는 age에 넣습니다.
    print(age)

    if age >= 20 { // age가 20이상이면 코드블록을 실행합니다.
        break        // 반복문을 종료합니다.
    }
}

// while 반복문에서 더이상 반복이 필요없는 경우

var age = 15
while age < 100 {
    print(age)

    if age >= 20 {
        break
    }

    age += 1
}

/*
출력값 : 
15
16
17
18
19
20
*/

// 한국말로 풀어보기
var age = 15 // age라는 이름의 변수에 값 15를 할당합니다.
while age < 100 { // age가 100 미만일 때 반복적으로 코드블록을 호출합니다.
    print(age)

    if age >= 20 { // 만약 age가 20보다 크거나 같을 때 아래 코드블록을 실행합니다.
        break // 반복문을 종료합니다.
    }

    age += 1 // age에 1을 더한 값을 할당합니다.
}

[코드스니펫] break문 실습

// 1. 조건문 switch에서 특정 case에서 아무런 행동을 하고싶지 않을 때

var age = 15

switch age {
    case 15: 
        break
    default: 
        print("15가 아니에요")
}

// case에서 아무런 행동을 하지 않을 때 코드가 없으면 빌드오류가 발생하기 때문에 break문을 사용합니다.

// 2. 조건문 switch에서 코드 중에 탈출하고 싶을 때

let score = 50
switch score {
case 50...:
    print("50점 이상이시군요")
    fallthrough
case 50:
    print("딱 50점이시네요?")
    break
    print("저는 80점인데요~")
default:
    print("공부를 더 하세요!")
}

/*
출력 값:
50점 이상이시군요
딱 50점이시네요?
*/

// 한국말로 풀어보기.
let score = 50 // score 라는 이름의 상수에 값 50을 할당합니다.

switch score { // score 상수를 switch 조건문 코드블록으로 넣습니다.
case 50...: // 50이상일 때 아래의 코드가 호출됩니다.
    print("50점 이상이시군요") 
    fallthrough // 아래의 case도 확인합니다.
case 50: // score가 50일 때 아래의 코드를 호출합니다.
    print("딱 50점이시네요?")   
    break // switch 코드블록
    print("저는 80점인데요~") // 위에서 break를 사용하여 switch에서 탈출하여 실행되지 않는 코드입니다.
default:
    print("공부를 더 하세요!")
}

continue

반복문 안에서 현재 반복을 건너뛰고 다음 반복으로 넘어갈 때 사용합니다.

// for in 에서 continue를 사용하여 반복문을 건너뛰는 방법

for number in 1...5 {
    if number % 2 == 0 {
        continue 
    }

    print(number)
}

/*
출력 값
1
3
5
*/

// 한국말로 풀어보기

for number in 1...5 { // 1이상 5이하까지 반복합니다. 현재 숫자는 number에 넣습니다.
    if number % 2 == 0 { // number 에서 2를 나눴을 때 나머지가 0이면 아래의 코드블록을 실행합니다.
        continue // 다음 반복문으로 바로 이동합니다. 아래의 코드는 실행하지 않습니다.
    }

    print(number)
}

// while에서 continue를 사용하여 반복문을 건너뛰는 방법

var number = 0 

while number < 5 {
    number += 1

    if number % 2 == 1 {
        continue
    }

    print(number)    
}

/*
출력 값 
2
4
*/

// 한국말로 풀어보기

var number = 0 // 변수 number에 0 값을 할당합니다.

while number < 5 { // number가 5 미만일 때 반복합니다.
    number += 1 // number에 1을 더한값을 할당합니다.

    if number % 2 == 1 { // number에 2를 나눈 나머지 값이 1일 때 코드블록을 실행합니다.
        continue
    }

    print(number)    
}

Swift 문법종합 - 연산자

Mon, 04 Nov 2024 12:20:15 GMT

5.연산자

대입연산자, 산술연산자, 비교연산자, 논리연산자, 범위연산자

대입연산자

= 연산자는 값을 변수나 상수에 대입할 때 사용합니다.

= 연산자 기준으로 뒤에 값을 앞에 대입(할당) 합니다.
변수의 데이터 타입이 같다면 다른 값으로 재할당할 수 있습니다.

let age = 20 // 해석 : age 라는 상수에 20을 대입(할당)합니다.
// 이렇게 하면 age에는 실제 값이 20이 들어가있습니다.

var name = "내배캠" // 해석 : name이라는 변수에 "내배캠" 이라는 값을 대입(할당)합니다.
var address = "서울" 

name = address // adress에 있는 값 서울을 name 변수에 할당합니다.
print(name) // name변수의 저장 값 "서울"이 출력됩니다.

산술 연산자

더하기

+ : 두 값을 더합니다.
+= : 기존 값에 더한 후 할당합니다.

var result = 10 + 20 // result 변수에 10 + 20의 값 30을 할당합니다.
print(result) // 출력 : 30

result += 3 // result에 3을 더한 후 값을 할당합니다.
print(result) // 출력 : 33

let value = 5
result += value // result에 value 값 더한 후 할당합니다.
print(result) // 38

*** 나누기

- / : 두 값을 나눕니다.

var result = 30 / 7 // result 변수에 30 나누기 7의 값인 4를 할당합니다.

print(result) // 출력 : 4

* 곱하기

- *** : 두 값을 곱합니다. - *=** : 기존 값에서 곱한 뒤 할당합니다.

var result = 10 * 3 // result 변수에 10 * 3의 값 30을 할당합니다.
print(result) // 출력 : 30

result *= 2 // result 값에 2를 곱한 값을 할당합니다.
print(result) // 출력 : 60

* 나머지 - % : 두 값을 나눈 후의 나머지를 반환합니다.

var result = 10 % 3 // result 변수에 10/3의 나머지값 1을 할당합니다.

print(result) // 출력 : 1

비교 연산자

**두 값을 비교하여 참(true) 나 거짓(false)를 반환합니다. 예)

let hello = "안녕하세요"
let hi = "안녕"

hello == hi // false "안녕하세요"와 "안녕"은 같지 않아요!
123 == 123 // true 123 과 123은 같은 값이에요.

hello != hi // true "안녕하세요"와 "안녕"은 같지 않아요.
123 != 123 // false 

123 > 123 // false
100 > 120 // false

123 >= 123 // true

123 < 123 // false
123 <= 123 // true
100 < 50 // true

== : 값이 같은지 확인
- a == b : a와 b가 같은지 확인
- 1 == 1 : 숫자 1과 숫자 1이 같은지 확인 → true
!= : 두 값이 다른지 확인
- a != b : a와 b가 같지 않은지 확인
- 1 != 1 : 숫자 1과 숫자 1이 같지 않은지 확인 → false
(>) : 왼쪽의 값이 오른쪽 값보다 더 큰지 확인
- a > b : a가 b보다 큰지 확인
- 1 > 2 : 1이 2보다 큰지 확인 → false
< : 왼쪽의 값이 오른쪽 값보다 더 작은지 확인
- a < b : a가 b보다 작은지 확인
- 1 < 2 : 1이 2보다 작은지 확인 → true
(>=) : 왼쪽의 값이 크거나 같은지 확인
- a >= b : a가 b보다 크거나 같은지 확인
- 1 >= 1 : 1이 1보다 크거나 같은지 확인 → true
<= : 왼쪽의 값이 작거나 같은지 확인
- a <= b : a가 b보다 작거나 같은지 확인
- 1 <= 1 : 1이 1보다 작거나 같은지 확인 → true

논리 연산자 (Bool 값을 조작하거나 결합할 때 사용합니다) * NOT 연산자 * ! 키워드를 사용합니다. * !true 처럼 느낌표가 앞에 옵니다. * Bool 값을 반대로 반환하는 연산자 * true → false * false → true

var allowedEntry = false

print(allowedEntry) // false가 출력됩니다.

print(!allowedEntry) // false의 반대값인 true가 출력됩니다

allowedEntry = !allowedEntry // allowedEntry 변수에 allowedEntry의 값 false 의 반대인 true를 대입합니다.

print(allowedEntry) // true가 출력됩니다.

* **AND 연산자 * \ 두개의 값을 비교하여 두개의 값이 모두 true 일 때 true를 반환하는 연산자 * 한개가 true이고 한개가 false일 때는 false를 반환합니다. * && 키워드를 사용합니다.

true && true // true

true && false // false

false && false // false

let isHavingPan = false let isHavingPineApple = true let pineAppleApplePan = isHavingPan && isHavingPineApple

print(pineAppleApplePan) // false isHavingPineApple이 false이기 때문에 전체값이 false가 됩니다.

** OR 연산자 ** \ 두개의 값을 비교하여 한개만 true일 때 true를 반환하는 연산자 * 한개가 true 이고 한개가 false일 때 true를 반환합니다. * || 키워드를 사용합니다.

true || true // true

true || false // true

false || false // false

let isGreenPan = false

let isYelloPan = true

let isHavingPan = isGreenPan || isYelloPan

print(isHavingPan) // true // isGreenPan, isYellowPan 둘 중 하나가 true여서 true가 할당됩니다.

범위 연산자 (숫자나 값의 범위를 나타낼 때 사용하는 연산자입니다)

닫힌 범위 연산자(Closed Range Operator)
- a...b 와 같이 ... 를 사용합니다.
- 시작값과 마지막값을 모두 포함하는 범위를 정의할 때 사용합니다.
- a...b a이상 b이하의 범위를 나타냅니다.

(0...3) // 0,1,2,3 의 범위로 0이상 3이하의 범위를 포함합니다.

(10...12) // 10, 11, 12 의 범위로 10이상 12이하의 범위를 포함합니다.

** 반-열림 범위 연산자(Half-Open Range Operator) ** \ a..

(0..<3) // 0,1,2 의 범위

(10..<15) // 10, 11, 12, 13, 14 의 범위를 포함합니다.

** 단-방향 범위(One-Sided Ranges) ** \ a... ...b 와 같이 한쪽에만 값을 넣어서 사용합니다. * 오로지 한쪽으로만 범위를 갖고 있습니다.

(10...) // 10, 11, 12, 13 ...

*삼항 연산자 *

조건 ? 참일 때 반환값 : 거짓일 때 반환값 형태를 가진 연산자입니다.

let age = 20 let isAdult = age > 20 ? "성인 입니다" : "미성년자 입니다"

// 위에 코드를 번역해보면 // age 상수에 20 값을 할당합니다. // isAdult 상수에 age가 20이면 "성인입니다"를 할당하고 아니면 "미성년자 입니다"를 할당합니다.

*Swift Convention Guide No.4 → 연산자 코드 컨밴션 *

대입 연산자 , 산술 연산자, 비교 연산자 양옆으로 공백을 주세요.

논리연산자 NOT을 제외한 AND, OR 연산자에는 양옆으로 공백을 주세요.

범위 연산자는 공백을 안주셔도 됩니다.

Code Block(코드블록)

Code Block이란 중괄호 { } 감싸진 코드의 묶음을 의미합니다.

여러 명령어를 하나로 묶어서 특정 조건이나 반복문 등에서 실행하는 단위로 사용됩니다.

주로 조건문, 반복문, 클래스, 클로저 등에서 사용하게 됩니다