[UMC] 7주차 : DB & DBMS

📝 학습 목표

---

1. 데이터베이스를 이해한다.
2. iOS에서 데이터베이스를 구축하고 관리할 수 있다.
3. UserDefaults를 이해하고 활용할 수 있다.

✍🏻 수업 내용 정리

---

DB를 계좌로 설명

은행의 고객이 ATM을 통해 현금을 인출한다

서비스 이용 과정에서 DBMS에 접근하고 DBMS에서 고객 정보를 수정해서 돈을 빠져나가게 한다.

DBMS는 DB를 관리하는 sw

DBMS는 데이터를 파일 형태로 다루는데

데이터가 돈과 관련되어있기에 보안 상에 큰 문제가 발생할 수도 있어서

단점을 보완한 RDBMS가 탄생했다.

이때 R는 relational 관계형이란 뜻이다

말 그대로 데이터들이 관계를 지니게 됐다.

전에는 각각 파일 형태였는데

이젠 테이블이란 개념을 통해 관리된다.

이 테이블끼리 관계성을 띄고 있다.

저기 오른쪽 테이블의 회색 글씨가 보이는가

테이블로 데이터를 관리하면서 나타난 키란 개념이다.

이 RDBMS 상의 테이블을 관리하고 데이터를 관리하기 위한 언어가

우리가 익히 들어본

SQL이다

SQL(Structured Query Language)

앱을 꺼도 데이터 존재하도록→ UserDefaults 사용

🎯 핵심 키워드

---

• DB

  줄여서

  DB

  특정 다수의 이용자들에게 필요한 정보를 제공한다든지 조직 내에서 필요로 하는 정보를 체계적으로 축적하여 그 조직 내의 이용자에게 필요한 정보를 제공하는 정보 서비스 기관의 심장부에 해당된다.

  일반적으로 응용 프로그램과는 별개의 미들웨어를 통해서 관리된다. 데이터베이스 자체만으로는 거의 아무 것도 못하기 때문에 그걸 관리하는 시스템과 통합돼 제공되며 따라서 정확한 명칭은 데이터베이스 관리 시스템DBMS이 된다. 데이터베이스만 제공되는 건 CSV 같이 아주 단순한 데이터에 국한되는데 이걸 직접 사용하는 경우는 많지 않고 이런 데이터를 RAW데이터로 간주해 다른 DBMS시스템에 적재하고 사용하는 게 일반적이다.

  간단히 비유하자면 데이터베이스 자체는 화물(데이터)을 저장할 수 있는 창고 그 자체의 역할만 수행하고, 화물을 적재하거나 적재된 화물을 처리할 수 있는 능력은 없다. 이 때문에 DBMS라는 관리자들을 고용하여 화물을 적재하거나 이동시키는 등 크레인과 같은 여러가지 업무를 수행하도록 하는 것이다.

  관계형 데이터베이스(RDBMS)가 가장 널리 쓰이고 있다. 그리고 이 관계형 데이터베이스를 이용하기 위한 표준 언어가 만들어져 있는데 그것이 SQL이다. 구조화 질의 언어(Structured Query Language)의 약자. 예전에는 관계형 데이터베이스가 데이터베이스의 대명사처럼 여겨졌으나 요즘에는 다른 형태의 데이터베이스도 많이 나와있다. 가히 데이터베이스 춘추전국시대. 이런 비-관계형 데이터베이스는 NoSQL이라 불린다.

  SQL을 사용하지 않는 데이터베이스라는 다소 장난스런 표현. 물론 정식 명칭은 각자 가지고 있다. 객체형, 문서형, 컬럼형 등등이 해당된다.

  관계형 데이터베이스를 이용하기 위해 만들어진 SQL문은 배워 두면 여러모로 쓸 데가 많다.

  컴퓨터로 하는 일에서 대부분을 차지하는 작업은 바로 정렬과 탐색인데 이 두 작업을 가장 전문적으로 처리하는 건 데이터베이스이다. 컴퓨터로 계산을 하는 경우는 의외로 정렬과 탐색에 비하면 비중이 낮은 편이다.

  https://namu.wiki/w/데이터베이스

• DBMS

  데이터베이스라는 데이터의 집합을 만들고, 저장 및 관리할 수 있는 기능들을 제공하는 응용 프로그램이다. 즉, 데이터의 관리에 특화된 프로그램이라고 생각하면 편하다. 종류에 따라 DataBase Server까지 지원하기도 한다.주로 서버에 사용하는 용도만 DBMS라고 생각하는 오개념이 많다. 그러나 Microsoft Access라는 개인용 컴퓨터에 저장하는 용도의 프로그램도 훌륭한 DBMS이다. 블룸버그 터미널 같은 경우는 자체적으로 DBMS를 내장하고 있다.

• RDBMS

  https://cloud.google.com/learn/what-is-a-relational-database?hl=ko

  # 관계형 데이터베이스 정의

  관계형 데이터베이스(RDB)는 테이블, 행, 열의 정보를 구조화하는 방식입니다. RDB에는 테이블을 조인하여 정보 간 관계 또는 링크를 설정할 수 있는 기능이 있어, 여러 데이터 포인트 간의 관계를 쉽게 이해하고 정보를 얻을 수 있습니다.

  # 관계형 데이터베이스 모델

  ###

  1970년대 IBM의 EF Codd가 개발한 관계형 데이터베이스 모델을 사용하면 모든 테이블을 공통 속성을 사용해 다른 테이블과 연관시킬 수 있습니다. Codd는 계층 구조를 사용하여 데이터를 정리하는 대신 데이터가 포함된 테이블을 재구성하지 않고 테이블에 데이터가 저장, 액세스 및 연결되는 데이터 모델을 사용하는 것으로 전환할 것을 제안했습니다.

  관계형 데이터베이스는 비즈니스에서 데이터를 구성, 관리, 연결하는 데 도움이 되는 스프레드시트 파일 모음이라고 생각하면 됩니다. 관계형 데이터베이스 모델에서 각 ‘스프레드시트’는 열(속성)과 행(레코드 또는 튜플)으로 대표되는 정보를 저장하는 테이블입니다.

  속성(열)은 데이터 유형을 지정하며 각 레코드(또는 행)는 구체적인 데이터 유형의 값을 포함합니다. 관계형 데이터베이스의 모든 테이블에는 행에서 고유하게 식별 가능한 기본 키라는 속성이 있으며, 외래 키(다른 기존 테이블의 기본 키를 참조)를 사용하여 각 행에서 서로 다른 테이블 간의 관계를 만드는 데 사용할 수 있습니다.

  이제 관계형 데이터베이스 모델의 실제 작동 방식을 살펴보겠습니다.

  고객 테이블과 주문 테이블이 있다고 가정해 보겠습니다.

  https://lh3.googleusercontent.com/_j-DAQG6tx5MwOwhdNFkHMou4fWHRuEbzYr3wEaRClkCnC3W2TR8CnMsAvmVX-rgOICpWX-wrBPc=e14-rj-sc0xffffff-h1000-w1000

  ###

  고객 테이블에는 고객에 관한 데이터가 포함됩니다.

  • 고객 ID(기본 키)
  • 고객 이름
  • 청구서 수신 주소
  • 배송지 주소

  고객 테이블에서 고객 ID는 고객이 관계형 데이터베이스에서 고유하게 식별되는 기본 키입니다. 동일한 고객 ID를 가지는 다른 고객은 없습니다.

  주문 테이블에는 주문에 관한 거래 정보가 포함됩니다.

  • 주문 ID(기본 키)
  • 고객 ID(외래 키)
  • 주문 날짜
  • 배송일
  • 주문 상태

  여기에서 특정 주문을 식별하는 기본 키는 주문 ID입니다. 외래 키를 사용하여 고객 테이블의 고객 ID를 연결하여 고객을 주문과 연결할 수 있습니다.

  이제 두 테이블이 공유된 고객 ID를 기반으로 합니다. 즉, 두 테이블을 쿼리하여 공식 보고서를 만들거나 다른 애플리케이션에 데이터를 사용할 수 있습니다. 예를 들어 소매 지점 관리자는 특정 날짜에 구매한 모든 고객에 관한 보고서를 생성하거나 지난 달에 배송일이 지연된 주문을 받은 고객을 파악할 수 있습니다.

  위의 설명은 간단하지만, 관계형 데이터베이스는 데이터 간의 매우 복잡한 관계를 보여주는 데에도 탁월하기 때문에 데이터가 데이터베이스의 사전 정의된 관계형 스키마를 준수하는 한 더 많은 테이블의 데이터를 참조할 수 있습니다.

  데이터가 사전 정의된 관계로 구성되므로 데이터를 선언적으로 쿼리할 수 있습니다. 선언적 쿼리는 시스템이 결과를 어떻게 연산해야 하는지 표현하지 않고 시스템에서 추출할 내용을 정의하는 방법입니다. 이는 다른 시스템과 달리 관계형 시스템의 핵심입니다.

  # 관계형 데이터베이스의 예

  ###

  이제 관계형 데이터베이스의 작동 방식을 이해했으므로 관계형 데이터베이스 모델을 사용하는 여러 관계형 데이터베이스 관리 시스템에 대해 알아볼 수 있습니다. 관계형 데이터베이스 관리 시스템(RDBMS)은 관계형 데이터베이스를 만들고 업데이트하고 관리하는 데 사용하는 프로그램입니다. 잘 알려진 RDBMS의 예로는 MySQL, PostgreSQL, MariaDB, Microsoft SQL Server, Oracle Database가 있습니다.

  Cloud SQL, Cloud Spanner, AlloyDB와 같은 클라우드 기반 관계형 데이터베이스는 데이터베이스 유지보수, 패치, 용량 관리, 프로비저닝, 인프라 지원을 위한 관리형 서비스를 제공하기 때문에 점점 더 많은 인기를 얻고 있습니다.

  시작할 준비가 되셨나요? 10GB 스토리지를 포함한 90일 Cloud Spanner 무료 체험판 인스턴스를 무료로 만드세요.

  # 관계형 데이터베이스의 이점

  관계형 데이터베이스 모델의 주요 이점은 직관적인 데이터 표현 방법을 제공하고 관련 데이터 포인트에 쉽게 액세스할 수 있다는 점입니다. 그래서 관계형 데이터베이스는 인벤토리 추적부터 트랜잭션 데이터 처리 및 애플리케이션 로깅에 이르기까지 대량의 구조화된 데이터를 관리해야 하는 조직에서 가장 많이 사용합니다.

  관계형 데이터베이스를 사용하면 데이터를 관리하고 저장할 때 다음과 같은 여러 가지 장점이 있습니다.

  ### 유연성

  전체 데이터베이스 구조를 변경하거나 기존 애플리케이션에 영향을 주지 않고 필요할 때마다 간편하게 테이블, 관계를 추가 또는 삭제하고 데이터를 변경할 수 있습니다.

  ### ACID 규정 준수

  관계형 데이터베이스는 ACID(원자성, 일관성, 격리, 내구성) 성능을 지원하므로 오류, 실패, 기타 잠재적 오작동에 관계없이 데이터 유효성을 검사할 수 있습니다.

  ### 사용 편의성

  기술자가 아닌 사용자도 데이터베이스와 상호작용하는 방법을 배울 수 있는 SQL을 사용하여 복잡한 쿼리를 쉽게 실행할 수 있습니다.

  ### 공동작업

  여러 사용자가 동시에 데이터를 운영하고 액세스할 수 있습니다. 기본 제공되는 잠금 기능으로 업데이트 도중 데이터에 동시 액세스할 수 없습니다.

  ### 내장된 보안 기능

  역할 기반 보안을 통해 데이터 액세스가 특정 사용자로 제한됩니다.

  ### 데이터베이스 정규화

  관계형 데이터베이스는 데이터 중복성을 줄이고 데이터 무결성을 개선하는 정규화라는 설계 기법을 사용합니다.

  # 관계형 및 비관계형 데이터베이스

  ###

  관계형 및 비관계형 데이터베이스(NoSQL 데이터베이스)의 주요 차이점은 데이터를 저장하고 구성하는 방법입니다. 비관계형 데이터베이스는 규칙 기반의 테이블 형식 방식으로 데이터를 저장하지 않습니다. 대신 데이터를 연결되지 않은 개별 파일로 저장하며, 문서 또는 리치 미디어 파일과 같은 복잡하고 구조화되지 않은 데이터 유형에 사용할 수 있습니다.

  관계형 데이터베이스와 달리 NoSQL 데이터베이스는 유연한 데이터 모델을 따르므로 자주 변경되는 데이터를 저장하거나 다양한 유형의 데이터를 처리하는 애플리케이션에 적합합니다.

• SQL

  https://aws.amazon.com/ko/what-is/sql/

  ## SQL이란 무엇인가요?

  구조적 쿼리 언어(SQL)는 관계형 데이터베이스에 정보를 저장하고 처리하기 위한 프로그래밍 언어입니다. 관계형 데이터베이스는 정보를 표 형식으로 저장하며, 행과 열은 다양한 데이터 속성과 데이터 값 간의 다양한 관계를 나타냅니다. SQL 문을 사용하여 데이터베이스에서 정보를 저장, 업데이트, 제거, 검색 및 검색할 수 있습니다. 데이터베이스 성능을 유지 관리하고 최적화하는 데 SQL을 사용할 수도 있습니다.

• UserDefaults

  Class UserDefaults

  An interface to the user’s defaults database, where you store key-value pairs persistently across launches of your app.

  iOS 2.0+iPadOS 2.0+macOS 10.0+Mac Catalyst 13.0+tvOS 9.0+watchOS 2.0+

  ## Declaration

  class UserDefaults : [NSObject](https://developer.apple.com/documentation/objectivec/nsobject)

  ## Overview

  The UserDefaults class provides a programmatic interface for interacting with the defaults system. The defaults system allows an app to customize its behavior to match a user’s preferences. For example, you can allow users to specify their preferred units of measurement or media playback speed. Apps store these preferences by assigning values to a set of parameters in a user’s defaults database. The parameters are referred to as defaults because they’re commonly used to determine an app’s default state at startup or the way it acts by default.

  At runtime, you use UserDefaults objects to read the defaults that your app uses from a user’s defaults database. UserDefaults caches the information to avoid having to open the user’s defaults database each time you need a default value. When you set a default value, it’s changed synchronously within your process, and asynchronously to persistent storage and other processes.

  Important Don’t try to access the preferences subsystem directly. Modifying preference property list files may result in loss of changes, delay of reflecting changes, and app crashes. To configure preferences, use the defaults command-line utility in macOS instead.

  With the exception of managed devices in educational institutions, a user’s defaults are stored locally on a single device, and persisted for backup and restore. To synchronize preferences and other data across a user’s connected devices, use [NSUbiquitousKeyValueStore](https://developer.apple.com/documentation/foundation/nsubiquitouskeyvaluestore) instead.

  ### Storing Default Objects

  The UserDefaults class provides convenience methods for accessing common types such as floats, doubles, integers, Boolean values, and URLs. These methods are described in Setting Default Values.

  A default object must be a property list—that is, an instance of (or for collections, a combination of instances of) [NSData](https://developer.apple.com/documentation/foundation/nsdata), [NSString](https://developer.apple.com/documentation/foundation/nsstring), [NSNumber](https://developer.apple.com/documentation/foundation/nsnumber), [NSDate](https://developer.apple.com/documentation/foundation/nsdate), [NSArray](https://developer.apple.com/documentation/foundation/nsarray), or [NSDictionary](https://developer.apple.com/documentation/foundation/nsdictionary). If you want to store any other type of object, you should typically archive it to create an instance of NSData.

  Values returned from UserDefaults are immutable, even if you set a mutable object as the value. For example, if you set a mutable string as the value for “MyStringDefault”, the string you later retrieve using the [string(forKey:)](https://developer.apple.com/documentation/foundation/userdefaults/1416700-string) method will be immutable. If you set a mutable string as a default value and later mutate the string, the default value won’t reflect the mutated string value unless you call [set(_:forKey:)](https://developer.apple.com/documentation/foundation/userdefaults/1414067-set) again.

  For more details, see Preferences and Settings Programming Guide.

  ### Persisting File References

  A file URL specifies a location in the file system. If you use the [set(_:forKey:)](https://developer.apple.com/documentation/foundation/userdefaults/1414194-set) method to store the location for a particular file and the user moves that file, your app may not be able to locate that file on next launch. To store a reference to a file by its file system identity, you can instead create NSURL bookmark data using the [bookmarkData(options:includingResourceValuesForKeys:relativeTo:)](https://developer.apple.com/documentation/foundation/nsurl/1417795-bookmarkdata) method and persist it using the [set(_:forKey:)](https://developer.apple.com/documentation/foundation/userdefaults/1414067-set) method. You can then use the [URLByResolvingBookmarkData:options:relativeToURL:bookmarkDataIsStale:error:](https://developer.apple.com/documentation/foundation/nsurl/1572035-urlbyresolvingbookmarkdata) method to resolve the bookmark data stored in user defaults to a file URL.

  ### Responding to Defaults Changes

  You can use key-value observing to be notified of any updates to a particular default value. You can also register as an observer for [didChangeNotification](https://developer.apple.com/documentation/foundation/userdefaults/1408206-didchangenotification) on the [default](https://developer.apple.com/documentation/foundation/notificationcenter/1414169-default) notification center in order to be notified of all updates to a local defaults database.

  For more details, see Key-Value Observing Programming Guide and Notification Programming Topics.

  ### Using Defaults in Managed Environments

  If your app supports managed environments, you can use UserDefaults to determine which preferences are managed by an administrator for the benefit of the user. In a managed environment, such as a computer lab or classroom, an administrator or teacher can configure the systems by establishing a set of default preferences for users. If a preference is managed in this manner (as determined by the methods described in Accessing Managed Environment Keys), your app should prevent users from editing that preference by disabling or hiding controls.

  For more details, see Mobile Device Management Protocol Reference.

  An app running on a device managed by an educational institution can use the iCloud key-value store to share small amounts of data with other instances of itself on the user’s other devices. For example, a textbook app might store the current page number being read by the user so that other instances of the app can open to the same page when launched.

  For more information, see Storing Preferences in iCloud in Preferences and Settings Programming Guide.

  ### Sandbox Considerations

  A sandboxed app cannot access or modify the preferences for any other app, with the following exceptions:

  • App extensions on macOS and iOS
  • Other apps in your application group on macOS

  Adding a third-party app’s domain using the [addSuite(named:)](https://developer.apple.com/documentation/foundation/userdefaults/1410294-addsuite) method doesn’t allow your app to access to that app’s preferences. Attempting to access or modify another app’s preferences doesn’t result in an error; instead, macOS reads and writes files located within your app’s container, rather than the actual preference files for the other application.

  ### Thread Safety

  The UserDefaults class is thread-safe.

  ## Topics

  **Getting the Standard User Defaults Object**

  [class var standard: UserDefaults](https://developer.apple.com/documentation/foundation/userdefaults/1416603-standard)

  Returns the shared defaults object.

  **Creating User Defaults Objects**

  [init()](https://developer.apple.com/documentation/foundation/userdefaults/1414356-init)

  Creates a user defaults object initialized with the defaults for the app and current user.

  [init?(suiteName: String?)](https://developer.apple.com/documentation/foundation/userdefaults/1409957-init)

  Creates a user defaults object initialized with the defaults for the specified database name.

  **Getting Default Values**

  [func object(forKey: String) -> Any?](https://developer.apple.com/documentation/foundation/userdefaults/1410095-object)

  Returns the object associated with the specified key.

  [func url(forKey: String) -> URL?](https://developer.apple.com/documentation/foundation/userdefaults/1408648-url)

  Returns the URL associated with the specified key.

  [func array(forKey: String) -> [Any]?](https://developer.apple.com/documentation/foundation/userdefaults/1414792-array)

  Returns the array associated with the specified key.

  [func dictionary(forKey: String) -> [String : Any]?](https://developer.apple.com/documentation/foundation/userdefaults/1408563-dictionary)

  Returns the dictionary object associated with the specified key.

  [func string(forKey: String) -> String?](https://developer.apple.com/documentation/foundation/userdefaults/1416700-string)

  Returns the string associated with the specified key.

  [func stringArray(forKey: String) -> [String]?](https://developer.apple.com/documentation/foundation/userdefaults/1416414-stringarray)

  Returns the array of strings associated with the specified key.

  [func data(forKey: String) -> Data?](https://developer.apple.com/documentation/foundation/userdefaults/1409590-data)

  Returns the data object associated with the specified key.

  [func bool(forKey: String) -> Bool](https://developer.apple.com/documentation/foundation/userdefaults/1416388-bool)

  Returns the Boolean value associated with the specified key.

  [func integer(forKey: String) -> Int](https://developer.apple.com/documentation/foundation/userdefaults/1407405-integer)

  Returns the integer value associated with the specified key.

  [func float(forKey: String) -> Float](https://developer.apple.com/documentation/foundation/userdefaults/1414027-float)

  Returns the float value associated with the specified key.

  [func double(forKey: String) -> Double](https://developer.apple.com/documentation/foundation/userdefaults/1416581-double)

  Returns the double value associated with the specified key.

  [func dictionaryRepresentation() -> [String : Any]](https://developer.apple.com/documentation/foundation/userdefaults/1415919-dictionaryrepresentation)

  Returns a dictionary that contains a union of all key-value pairs in the domains in the search list.

  **Setting Default Values**

  [func set(Any?, forKey: String)](https://developer.apple.com/documentation/foundation/userdefaults/1414067-set)

  Sets the value of the specified default key.

  [func set(Float, forKey: String)](https://developer.apple.com/documentation/foundation/userdefaults/1413320-set)

  Sets the value of the specified default key to the specified float value.

  [func set(Double, forKey: String)](https://developer.apple.com/documentation/foundation/userdefaults/1408646-set)

  Sets the value of the specified default key to the double value.

  [func set(Int, forKey: String)](https://developer.apple.com/documentation/foundation/userdefaults/1413614-set)

  Sets the value of the specified default key to the specified integer value.

  [func set(Bool, forKey: String)](https://developer.apple.com/documentation/foundation/userdefaults/1408905-set)

  Sets the value of the specified default key to the specified Boolean value.

  [func set(URL?, forKey: String)](https://developer.apple.com/documentation/foundation/userdefaults/1414194-set)

  Sets the value of the specified default key to the specified URL.

  **Removing Defaults**

  [func removeObject(forKey: String)](https://developer.apple.com/documentation/foundation/userdefaults/1411182-removeobject)

  Removes the value of the specified default key.

  **Maintaining Suites**

  [func addSuite(named: String)](https://developer.apple.com/documentation/foundation/userdefaults/1410294-addsuite)

  Inserts the specified domain name into the receiver’s search list.

  [func removeSuite(named: String)](https://developer.apple.com/documentation/foundation/userdefaults/1408047-removesuite)

  Removes the specified domain name from the receiver’s search list.

  **Registering Defaults**

  [func register(defaults: [String : Any])](https://developer.apple.com/documentation/foundation/userdefaults/1417065-register)

  Adds the contents of the specified dictionary to the registration domain.

  **Maintaining Persistent Domains**

  [func persistentDomain(forName: String) -> [String : Any]?](https://developer.apple.com/documentation/foundation/userdefaults/1412197-persistentdomain)

  Returns a dictionary representation of the defaults for the specified domain.

  [func setPersistentDomain([String : Any], forName: String)](https://developer.apple.com/documentation/foundation/userdefaults/1408187-setpersistentdomain)

  Sets a dictionary for the specified persistent domain.

  [func removePersistentDomain(forName: String)](https://developer.apple.com/documentation/foundation/userdefaults/1417339-removepersistentdomain)

  Removes the contents of the specified persistent domain from the user’s defaults.

  ~~[func persistentDomainNames() -> [Any]](https://developer.apple.com/documentation/foundation/userdefaults/1589081-persistentdomainnames)~~

  Returns an array of the current persistent domain names.

  Deprecated

  **Maintaining Volatile Domains**

  [var volatileDomainNames: [String]](https://developer.apple.com/documentation/foundation/userdefaults/1414231-volatiledomainnames)

  The current volatile domain names.

  [func volatileDomain(forName: String) -> [String : Any]](https://developer.apple.com/documentation/foundation/userdefaults/1409592-volatiledomain)

  Returns the dictionary for the specified volatile domain.

  [func setVolatileDomain([String : Any], forName: String)](https://developer.apple.com/documentation/foundation/userdefaults/1413720-setvolatiledomain)

  Sets the dictionary for the specified volatile domain.

  [func removeVolatileDomain(forName: String)](https://developer.apple.com/documentation/foundation/userdefaults/1415955-removevolatiledomain)

  Removes the specified volatile domain from the user’s defaults.

  **Accessing Managed Environment Keys**

  [func objectIsForced(forKey: String) -> Bool](https://developer.apple.com/documentation/foundation/userdefaults/1408635-objectisforced)

  Returns a Boolean value indicating whether the specified key is managed by an administrator.

  [func objectIsForced(forKey: String, inDomain: String) -> Bool](https://developer.apple.com/documentation/foundation/userdefaults/1416306-objectisforced)

  Returns a Boolean value indicating whether the key in the specified domain is managed by an administrator.

  **Domains**

  [class let argumentDomain: String](https://developer.apple.com/documentation/foundation/userdefaults/1410665-argumentdomain)

  The domain consisting of defaults parsed from the application’s arguments. These are one or more pairs of the form -default value included in the command-line invocation of the application.

  [class let globalDomain: String](https://developer.apple.com/documentation/foundation/userdefaults/1407355-globaldomain)

  The domain consisting of defaults meant to be seen by all applications.

  [class let registrationDomain: String](https://developer.apple.com/documentation/foundation/userdefaults/1415953-registrationdomain)

  The domain consisting of a set of temporary defaults whose values can be set by the application to ensure that searches will always be successful.

  **Notifications**

  [class let didChangeNotification: NSNotification.Name](https://developer.apple.com/documentation/foundation/userdefaults/1408206-didchangenotification)

  Posted when user defaults are changed within the current process.

  [class let sizeLimitExceededNotification: NSNotification.Name](https://developer.apple.com/documentation/foundation/userdefaults/1617187-sizelimitexceedednotification)

  Posted when more data is stored in user defaults than is allowed.

  [class let completedInitialCloudSyncNotification: NSNotification.Name](https://developer.apple.com/documentation/foundation/userdefaults/1617169-completedinitialcloudsyncnotific)

  Posted when ubiquitous defaults finish downloading data, either the first time a device is connected to an iCloud account or when a user switches their primary iCloud account.

  [class let didChangeCloudAccountsNotification: NSNotification.Name](https://developer.apple.com/documentation/foundation/userdefaults/1617438-didchangecloudaccountsnotificati)

  Posted when the user changes the primary iCloud account.

  [class let noCloudAccountNotification: NSNotification.Name](https://developer.apple.com/documentation/foundation/userdefaults/1648504-nocloudaccountnotification)

  Posted when a cloud default is set, but no iCloud user is logged in.

  • dictionary

    tructure Dictionary

    A collection whose elements are key-value pairs.

    iOS 8.0+iPadOS 8.0+macOS 10.10+Mac Catalyst 13.0+tvOS 9.0+watchOS 2.0+

    ## Declaration

    @frozen struct Dictionary<Key, Value> where Key : [Hashable](https://developer.apple.com/documentation/swift/hashable)

    ## Overview

    A dictionary is a type of hash table, providing fast access to the entries it contains. Each entry in the table is identified using its key, which is a hashable type such as a string or number. You use that key to retrieve the corresponding value, which can be any object. In other languages, similar data types are known as hashes or associated arrays.

    Create a new dictionary by using a dictionary literal. A dictionary literal is a comma-separated list of key-value pairs, in which a colon separates each key from its associated value, surrounded by square brackets. You can assign a dictionary literal to a variable or constant or pass it to a function that expects a dictionary.

    Here’s how you would create a dictionary of HTTP response codes and their related messages:

    var responseMessages = [200: "OK", 403: "Access forbidden", 404: "File not found", 500: "Internal server error"]

    The responseMessages variable is inferred to have type [Int: String]. The Key type of the dictionary is Int, and the Value type of the dictionary is String.

    To create a dictionary with no key-value pairs, use an empty dictionary literal ([:]).

    var emptyDict: [String: String] = [:]

    Any type that conforms to the Hashable protocol can be used as a dictionary’s Key type, including all of Swift’s basic types. You can use your own custom types as dictionary keys by making them conform to the Hashable protocol.

    # Getting and Setting Dictionary Values

    The most common way to access values in a dictionary is to use a key as a subscript. Subscripting with a key takes the following form:

    print(responseMessages[200])// Prints "Optional("OK")"

    Subscripting a dictionary with a key returns an optional value, because a dictionary might not hold a value for the key that you use in the subscript.

    The next example uses key-based subscripting of the responseMessages dictionary with two keys that exist in the dictionary and one that does not.

    let httpResponseCodes = [200, 403, 301]for code in httpResponseCodes { if let message = responseMessages[code] { print("Response \(code): \(message)") } else { print("Unknown response \(code)") }}// Prints "Response 200: OK"// Prints "Response 403: Access forbidden"// Prints "Unknown response 301"

    You can also update, modify, or remove keys and values from a dictionary using the key-based subscript. To add a new key-value pair, assign a value to a key that isn’t yet a part of the dictionary.

    responseMessages[301] = "Moved permanently"print(responseMessages[301])// Prints "Optional("Moved permanently")"

    Update an existing value by assigning a new value to a key that already exists in the dictionary. If you assign nil to an existing key, the key and its associated value are removed. The following example updates the value for the 404 code to be simply “Not found” and removes the key-value pair for the 500 code entirely.

    responseMessages[404] = "Not found"responseMessages[500] = nilprint(responseMessages)// Prints "[301: "Moved permanently", 200: "OK", 403: "Access forbidden", 404: "Not found"]"

    In a mutable Dictionary instance, you can modify in place a value that you’ve accessed through a keyed subscript. The code sample below declares a dictionary called interestingNumbers with string keys and values that are integer arrays, then sorts each array in-place in descending order.

    var interestingNumbers = ["primes": [2, 3, 5, 7, 11, 13, 17], "triangular": [1, 3, 6, 10, 15, 21, 28], "hexagonal": [1, 6, 15, 28, 45, 66, 91]]for key in interestingNumbers.keys { interestingNumbers[key]?.sort(by: >)} print(interestingNumbers["primes"]!)// Prints "[17, 13, 11, 7, 5, 3, 2]"

    # Iterating Over the Contents of a Dictionary

    Every dictionary is an unordered collection of key-value pairs. You can iterate over a dictionary using a for-in loop, decomposing each key-value pair into the elements of a tuple.

    let imagePaths = ["star": "/glyphs/star.png", "portrait": "/images/content/portrait.jpg", "spacer": "/images/shared/spacer.gif"] for (name, path) in imagePaths { print("The path to '\(name)' is '\(path)'.")}// Prints "The path to 'star' is '/glyphs/star.png'."// Prints "The path to 'portrait' is '/images/content/portrait.jpg'."// Prints "The path to 'spacer' is '/images/shared/spacer.gif'."

    The order of key-value pairs in a dictionary is stable between mutations but is otherwise unpredictable. If you need an ordered collection of key-value pairs and don’t need the fast key lookup that Dictionary provides, see the KeyValuePairs type for an alternative.

    You can search a dictionary’s contents for a particular value using the contains(where:) or firstIndex(where:) methods supplied by default implementation. The following example checks to see if imagePaths contains any paths in the "/glyphs" directory:

    let glyphIndex = imagePaths.firstIndex(where: { $0.value.hasPrefix("/glyphs") })if let index = glyphIndex { print("The '\(imagePaths[index].key)' image is a glyph.")} else { print("No glyphs found!")}// Prints "The 'star' image is a glyph.")

    Note that in this example, imagePaths is subscripted using a dictionary index. Unlike the key-based subscript, the index-based subscript returns the corresponding key-value pair as a non-optional tuple.

    print(imagePaths[glyphIndex!])// Prints "(key: "star", value: "/glyphs/star.png")"

    A dictionary’s indices stay valid across additions to the dictionary as long as the dictionary has enough capacity to store the added values without allocating more buffer. When a dictionary outgrows its buffer, existing indices may be invalidated without any notification.

    When you know how many new values you’re adding to a dictionary, use the init(minimumCapacity:) initializer to allocate the correct amount of buffer.

📢 7주차 수업 후기

---

• 7주차 수업을 듣고 서로 느낀 점을 이야기해주세요!
• 핵심 키워드에 대해 완벽하게 이해했는지? 혹시 이해가 안 되는 부분은 뭐였는지? 서로 이야기해주세요!

UserDefaults는 이전 미션에서도 몇 번 사용한 적이 있어 쉽게 이해했다.

튜플과 딕셔너리 활용 방법이 수없이 많아서 관련 경험이 많을 수록 좋을 것 같다.

⚠️ 스터디간 주의사항

---

1. 과제 피드백 기반 진행입니다 - 한명씩 본인의 과제를 발표하는 시간 그리고 해온 과제에 대한 피드백을 하는 시간 (ex:전 이렇게 생각해서 이런 부분 다르게 해왔는데 저것도 괜찮은 것 같아요!)이 무조건 기반이 되어야 합니다!
2. 부가적으로 워크북에서 제공되는 키워드 혹은 강의에서 들은 디테일적인 부분에서 더 토의해봐도 좋을 것 같습니다.

✅ 실습 체크리스트

---

• dictionary의 정의와 실행 원리를 이해했나요?

• UserDefaults를 사용하여 회원가입과 로그인 로직을 구현했나요?

• 회원가입과 로그인 기능이 정상적으로 동작하는 것을 확인했나요?

• 회원가입과 로그인에 대한 예외처리 코드 및 로직을 이해했나요?

• 미션 참고 영상

  [iOS] #7. DB - Practice

⚡ 트러블 슈팅

---

• ⚡이슈 No.1 (예시, 서식만 복사하시고 지워주세요.)

  이슈

  👉 앱 실행 중에 노래 다음 버튼을 누르니까 앱이 종료되었다.

  문제

  👉 노래클래스의 데이터리스트의 Size를 넘어서 NullPointException이 발생하여 앱이 종료된 것이었다.

  해결

  👉 노래 다음 버튼을 눌렀을 때 데이터리스트의 Size를 검사해 Size보다 넘어가려고 하면 다음으로 넘어가는 메서드를 실행시키지 않고, 첫 노래로 돌아가게끔 해결

  참고 레퍼런스

  • 링크

🤔 이것도 한 번 생각해봐요!

---

• DB 특성에 대해 생각해보세요! (ex 영속성)

• dictionary의 문법과 자료구조에 대해 공부해보세요!

• UserDefaults의 다른 옵션도 공부해보세요!

• JSON에 대해 공부해보세요!

• 서버의 데이터베이스와 ios는 어떻게 소통할지 생각해보세요!

• UserDefaults 보다 더 유용한 자체 DB는 없을지 조사해보세요! (ex. CoreData, Realm, FireBase)7wnck

스탠다드 미션 😎

원래는 6주차 앱으로 적용해보려고 했지만

unable to open dependencies file 이라는 정체모를 에러가 7개나 뜬 관계로

(어떻게든 고쳐보려고 pod 도 업데이트 해보고, 구글링한 target 설정도 바꿔보았는데도 해결 못 함. 결국 xcode를 다시 지웠다가 깔아보니 정상 작동, 아마 xcode 업데이트 상에서 뭔가 문제가 발생한 듯 하다. 그리고 여전히 6주차 파일이 작동을 안한다)

예전에 한 번 만들어 놓은 뽀모도로 앱에 userDefaults를 적용해 보았다.

 import UIKit
import AudioToolbox

enum TimerStatus {
    case start
    case pause
    case end
}

class ViewController: UIViewController {

    
    @IBOutlet weak var timerLabel: UILabel!
    @IBOutlet weak var progessView: UIProgressView!
    @IBOutlet weak var datePicker: UIDatePicker!
    
    @IBOutlet weak var cancelButton: UIButton!
    @IBOutlet weak var toggleButton: UIButton!
    
    @IBOutlet weak var imageView: UIImageView!
    var duration = 60
    var timerStatus: TimerStatus = .end
    var timer: DispatchSourceTimer?
    var currentSeconds = 0
    
    
    var clockRecord: [String] = []
    
    override func viewDidLoad() {
        
        super.viewDidLoad()
        self.configureToggleButton()

  
    }
    

    func setTimerInfoViewVisible(isHidden: Bool){
        self.timerLabel.isHidden = isHidden
        self.progessView.isHidden = isHidden
        
    }
    
    func configureToggleButton(){
        self.toggleButton.setTitle("시작", for: .normal)
        self.toggleButton.setTitle("일시정지", for: .selected)
    }
    
    func startTimer() {
        if self.timer == nil {
            self.timer = DispatchSource.makeTimerSource(flags: [], queue: .main)
            self.timer?.schedule(deadline: .now(), repeating: 1)
            self.timer?.setEventHandler(handler: { [weak self] in
                guard let self = self else { return }
                self.currentSeconds -= 1
                let hour = self.currentSeconds / 3600
                let minute = (self.currentSeconds % 3600) / 60
                let seconds = (self.currentSeconds % 3600) % 60
                self.timerLabel.text = String(format: "%02d:%02d:%02d", hour, minute, seconds)
                self.progessView.progress = Float(self.currentSeconds) / Float(self.duration)
                UIView.animate(withDuration: 0.5, delay: 0, animations: {
                    self.imageView.transform = CGAffineTransform(rotationAngle: .pi)
                    
                })
                UIView.animate(withDuration: 0.5, delay: 0.5, animations: {
                    self.imageView.transform = CGAffineTransform(rotationAngle: .pi * 2)
                    
                })
                if self.currentSeconds <= 0 {
                    
                    self.stopTimer()
                    AudioServicesPlaySystemSound(1005) 
                }
                
            })
            self.timer?.resume()
        }
        
        
    }
    
    func stopTimer(){
        if self.timerStatus == .pause {
            self.timer?.resume()
        }
        self.timerStatus = .end
        self.cancelButton.isEnabled = false
        UIView.animate(withDuration: 0.5, animations: {
            self.timerLabel.alpha = 0
            self.progessView.alpha = 0
            self.datePicker.alpha = 1
            self.imageView.transform = .identity
        })
        self.toggleButton.isSelected = false
        self.timer?.cancel()
        self.timer = nil
        
        
    }
    
    @IBAction func tapCancelButton(_ sender: UIButton) {
        switch self.timerStatus {
        case .start, .pause:
            self.stopTimer()
        default:
            break
            
        }
    }
    
    @IBAction func tapToggleButton(_ sender: UIButton) {
        self.duration = Int(self.datePicker.countDownDuration)
        self.clockRecord.append(String(self.duration))
        UserDefaults.standard.set(self.clockRecord, forKey: "clockRecord")
        switch self.timerStatus {
        case .end:
            self.currentSeconds = self.duration
            self.timerStatus = .start
            UIView.animate(withDuration: 0.5, animations: {
                self.timerLabel.alpha = 1
                self.progessView.alpha = 1
                self.datePicker.alpha = 0
                
            })
            self.toggleButton.isSelected = true
            self.cancelButton.isEnabled = true
            self.startTimer()
            
        case .start:
            self.timerStatus = .pause
            self.toggleButton.isSelected = false
            self.timer?.suspend()
            
        case .pause:
            self.timerStatus = .start
            self.toggleButton.isSelected =  true
            self.timer?.resume()
    
            
            
        }
    }
    
    
}

import UIKit

class recordViewController: UIViewController {
    
    @IBOutlet weak var tableView: UITableView!
    
    var timeRecord: [String] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        guard let clockRecord: [String] = UserDefaults.standard.stringArray(forKey: "clockRecord") else {return}
        timeRecord = clockRecord
        tableView.dataSource = self
    }
    
    
    
}

extension recordViewController: UITableViewDataSource {
    func tableView(_ tableView: UITableView, numberOfRowsInSection: Int) -> Int {
        return timeRecord.count
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "cell", for: indexPath)
        cell.textLabel?.text = timeRecord[indexPath.row]
        return cell
    }
}

토글버튼을 누를 때마다 userDefaults에 저장할 수 있도록 해서, 그동안 설정한 타임 duration을 볼 수 있도록 했다.

실제로 1분을 적용하면 테이블 뷰에 이렇게 기록된다.

3분을 적용하면

이렇게 바뀌고

앱을 껐다가 켜도

완벽하게 유지!