Async, Await

• 비동기 처리를 할 때 사용한다.
• 동시성을 구현하는데 유용하다.

// 예시
func bringWebImageUrl(url: String) async -> URL

func processWebImage() async -> Image {
    let result = await bringWebImageUrl("imageUrl")
    return result
}

let image = processWebImage()

• 실행 흐름

  1. processWebImage() 실행
  2. bringWebImageUrl(”imageUrl”) 로 데이터를 받아오는 요청
     • 작업을 백그라운드에서 실행

  Suspension Point : 함수가 실행되는 도중 스레드를 포기한 시점

  1. 받아온 데이터 result에 저장
  2. result 를 return

• 함수명 뒤에 붙어있는 async 는 비동기적으로 일을 처리하는 함수라는 뜻이다.
  • async 함수 타입이라고 한다. (async → URL 타입)
    
• 하지만 async 함수 내부가 모두 비동기적으로 처리되는 것은 아니다.
  • 그래서 명령 앞에 await 키워드를 붙여서 ‘이곳이 비동기적으로 작업이 수행되는 곳이다’라고 명시한다.
    • await가 붙은 명령이 처리되는 동안 다른 작업들이 실행될 수 있도록 스레드를 포기한다.
      • 비동기(백그라운드) 작업이 완료되면 _Suspension Point_부터 함수를 재시동한다.
      • 이 작업을 동기적으로 처리하면 데이터를 받아오는 동안 다른 작업이 불가능하다.
        
• async 함수 내부에는 sync 함수가 포함될 수 있지만 반대는 불가능하다.
  • sync 함수 내부에 async 함수가 포함되면 async함수를 실행하긴 했으니 작업이 끝나기 전에 sync함수가 작업을 끝내버릴 수도 있기 때문이다.
  • 하지만 반대는 비동기 작업이 필요한 명령 앞에만 await 키워드를 붙이면 된다.

ViewModifier

• View 또는 View의 modifier에 적용하여 다른 형태의 View를 반환하는 modifier이다.
• 모든 View에서 재사용 할 수 있는 modifier를 구현할 수 있다.
• 자주 사용될 것 같은 디자인 컴포넌트들을 설계할 때 유용하다.

// 예시
struct customTextModifier: ViewModifier {
    func body(content: Content) -> some View {
        content
            .font(.title2)
            .bold()
            .foregroundColor(.blue)
    }
}

extension View { // extension으로 modifier 메소드 정의
    func titleBoldBlue() -> some View {
        modifier(customTextModifier())
    }
}

// 사용 예시
struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
                .titleBoldBlue() // extension으로 정의했기 때문에 다른 modifier들처럼 간편하게 사용 가능
        }
        .padding()
    }
}

@ViewBuilder

• 클로저 매개변수에서 복수의 View들을 생성할 때 사용하는 특성(Attribute)이다.

• Button View에서의 예시

    Button.init(action: @escaping () -> Void, @ViewBuilder label: () -> Label) // label에는 View가 들어가야 하기 때문에
  
    // 버튼 생성 구조
    Button {
            // action
    }, label: {
            // View들이 들어감
            Text("")
            Image("")
    }

• VStack, List, ScrollView 등의 컨테이너 View들은 모두 @ViewBuilder 특성을 통해 복수의 View들을 선언한다.

• View 프로토콜의 body 프로퍼티 선언에도 @ViewBuilder 특성이 붙어있다.

  • 때문에 View를 상속 받는 사용자 정의 View의 body에는 @ViewBuilder를 붙이지 않아도 된다.

Identifiable

• 고유 개체를 구분하기 위해 사용하는 프로토콜이다.

• var id 프로퍼티 하나만 가지는 프로토콜이다.

• 값이 다르더라도 id가 같으면 동일한 개체로 취급한다.

• 타입이 Identifiable을 채택했다면 id 프로퍼티 구현은 필수

// 예시
struct Plant: Identifiable {
    var id = UUID()
    var name: String
}

• 스위프트의 오류(Error)는 Error라는 프로토콜을 준수하는 타입의 값을 통해 표현한다
• 오류의 표현은 주로 열거형을 사용한다

enum CoffeeMachineError: Error {
    case emptyCoffeeCapsule
    case notEnoughWater
}

• 오류를 던져줄 때는 throw 구문을 사용한다

    throw CoffeeMachineError.emptyCoffeeBeans

• 오류가 던져지는 것에 대비하여 던져진 오류를 처리하기 위한 코드 작성도 필요하다

  1. 함수에서 발생한 오류 알리기

     • try 키워드로 던져진 오류를 받는 것이 가능하다

       // 호출했을 때, 동작 도중 오류가 발생하면 자신을 호출한 코드에 오류를 던져서 오류를 알림
       func canThrowError() throws -> String

     • throws는 함수나 메서드의 자체 타입에도 영향을 미친다

       • 즉, throws 함수나 메서드는 같은 이름의 throws가 명시되지 않는 함수나 메서드와 구분된다

         enum CoffeeMachineError: Error {
         case emptyCoffeeCapsule
         case emptyWater
         }
         

class CoffeeMachine { private var coffeeCapsule: Int = 10 private var waterLiters: Double = 2.0

var notEnoughCoffeeCapsule: Bool {
    return coffeeCapsule < 1
}

var notEnoughWater: Bool {
    return waterLiters < 0.2
}

func makeCoffee() throws -> String {
    guard notEnoughCoffeeCapsule == false else {
        throw CoffeeMachineError.emptyCoffeeCapsule
    }

    guard notEnoughWater == false else {
        throw CoffeeMachineError.emptyWater
    }

    coffeeCapsule -= 1
    waterLiters -= 0.2

    return "커피"
}

}

```

• 코드 동작 중 발생한 오류는 자신을 호출한 코드로 던져서 알릴 수 있지만, 오류를 받은 코드가 적절히 오류를 처리해주지 않는다면 이후의 코드는 작동하지 않는다

• 프로퍼티 래퍼는 클래스(class)와 구조체(struct)의 구현부에 getter, setter, 연산 프로퍼티 코드의 중복을 줄이는 방법을 제공한다. (Swift 5.1부터 생김)

• 여러 클래스나 구조체에 생성한 연산 프로퍼티들이 유사한 패턴을 갖는 경우가 발생해서 불편할 때가 있다.

  • 이 때, 프로퍼티 래퍼를 사용하면 연산 프로퍼티 기능을 개별 클래스, 구조체와 분리할 수 있고, 앱 코드에서 재사용할 수 있다.

예제

• 다음과 같이 도시 이름을 저장하는 String 프로퍼티를 가진 구조체가 있다고 하자.

  struct Address {
    private var cityName: String
  
    var city: String {
        get { cityName }
        set { cityName = newValue.uppercased()}
    }
  }

• 사용자가 도시 이름을 어떻게 입력했는지와는 상관 없이 대문자로 저장되어야 한다면 다음과 같이 연산 프로퍼티를 구조체에 추가할 수 있다.

• 도시 이름 프로퍼티에 할당되면 연산 프로퍼티의 setter가 private cityName 변수에 값을 저장하기 전에 대문자로 변환하게 된다.

  var address = Address()
  address.city = "Seoul"
  print(address.city) // LONDON

• 연산 프로퍼티를 사용하는 대신에 이 로직을 프로퍼티 래퍼로 구현할 수 있다.

  @propertyWrapper // 이 지시자를 이용하여 선언
  struct FixCase {
    private(set) var value: String = ""
  
    var wrappedValue: String {
        get { value }
        set { value = newValue.uppercased() }
    }
    init(wrappedValue initialValue: String) {
        self.wrappedValue = initialValue
    }
  }

• 모든 프로퍼티 래퍼는 값을 변경하거나 유효성을 검사하는 getter, setter 코드가 포함된 wrappedValue 프로퍼티를 가져야 한다.

  • 초깃값이 전달되는 초기화 메서는 선택 사항으로 포함될 수도 있다.
  • 위 코드의 초깃값(init) 에서는 문자열을 대문자로 변환하고 private 변수에 저장하는 프로퍼티에 할당한다.

• 이제 래퍼에 대한 정의가 끝났으니 이와 동일한 동작이 필요한 다른 프로퍼티 변수에 적용하여 재사용할 수 있다.

struct Contact {
    @FixCase var name: String // FixCase동작이 필요한 프로퍼티 앞에 @FixCase를 붙인다.
    @FixCase var city: String
    @FixCase var country: String
}

var contact = Contact(name: "GilDong", city: "Seoul", country: "Korea")

print("\(contact.name), \(contact.city), \(contact.country)")
// GILDONG, SEOUL, KOREA

• 이처럼 미리 정의된 프로퍼티 래퍼는 나중에 설명할 SwiftUI 작업을 할 때 광범위하게 사용된다.

타입 캐스팅

• 인스턴스의 타입을 확인 하는 용도 또는 인스턴스를 부모 혹은 자식 클래스의 타입으로 사용할 수 있는지, 프로토콜로 취급할 수 있는지 등을 확인하는 용도로 사용한다. (is, as 사용)

• 타입 확인

  • is 사용

• 업 캐스팅

  • as 사용
  • 부모 클래스의 인스턴스로 사용할 수 있도록 컴파일러에게 타입정보를 전환한다.
  • Any, AnyObject로도 변환 가능하다. (암시적으로 처리되므로 꼭 필요한 경우가 아니라면 생략해도 무방)

• 다운 캐스팅

  • as? 또는 as! 사용

  • 자식 클래스의 인스턴스로 사용할 수 있도록 컴파일러에게 타입정보를 전환한다.

  • 조건부 다운 캐스팅

    • as? 사용
    • 캐스팅에 실패하면, 즉 캐스팅하려는 타입에 부합하지 않는 인스턴스라면 nil을 반환하기 때문에 결과의 타입은 옵셔널 타입이다.

  • 강제 다운 캐스팅

    • as! 사용
    • 캐스팅에 실패하면 런타임 오류 발생, 캐스팅에 성공하면 옵셔널이 아닌 일반 타입 반환한다.

• 프로토콜과 타입 캐스팅

  • 프로토콜을 채택하고 있는지 확인한다.
  • 포로토콜로서 타입 캐스팅을 통해 프로토콜에서 정의된 프로퍼티와 메서드 사용 가능하다.

저장 프로퍼티 (Stored Property)

• 일반적인 프로퍼티

지연 저장 프로퍼티 (Lazy Stored Property)

• 프로퍼티가 처음 사용되는 시점에 초기화가 이루어진다. (프로퍼티를 처음 사용해 주어야 초기화)

    struct GamingMouse {
        var companyName: String = "로지텍"
        var productName: String = " G502X"
        lazy var productInfo: String = self.companyName + self.productName
    }

• 특징

  • 의존적인 값을 할당할 수 있다. (자신의 프로퍼티의 값을 또 다른 프로퍼티에서 사용)

    struct GamingMouse {
      var companyName: String = "로지텍"
      var productName: String = " G502X"
      lazy var productInfo: String = self.companyName + self.productName
    }
    
      var gamingMouse = GamingMouse()
      gamingMouse.productname = " G PRO Superlight"
    
      print(gamingMouse.productInfo) // 로지텍 G PRO Superlight 

  • 변수로만 선언할 수 있다. (lazy let은 사용 불가)

    • 인스턴스 초기화가 완료 될 때까지 값이 없을 수도 있기 때문

연산 프로퍼티 (Computed Property)

• 관계에서 얻어지는 값

    struct PersonA {
        var koreanAge: Int
        var americanAge: Int {
            get {
                return koreanAge - 1
            }
            set(newValue) {
                koreanAge = newValue + 1
            }
        }
    }
  
    var minseokAge = PersonA(koreanAge: 30)
    minseokAge.americanAge = 26
  
    print(minseokAge) // PersonA(koreanAge: 27)

  • get : 값을 얻어올 때 호출
  • set : 값이 설정되었을 때 호출
  • 읽기 전용으로도 구현 가능 (get만 정의) (한 쪽으로만 의존적인 관계)
    

• 프로퍼티 감시자 (Property Observer)

  • 프로퍼티를 감시하고 있다가 프로퍼티의 값이 변경됨에 따라 적절한 작업이 가능하다.

  • 변경되는 값이 현재 값과 같더라도 호출한다. (초기화 시점에는 호출 X)

    struct PersonB {
      var name: String {
          willSet(newValue // 생략 가능) {
              // some code
          }
          didSet(oldValue // 생략 가능) {
              // some code
          }
      }
    }

  • willSet : 값이 변경되기 직전 호출

  • didSet: 값이 변경된 직후 호출
    

• 타입 프로퍼티 (Type Property)

  • 타입 자체의 프로퍼티 ( 인스턴스를 만들지 않아도 사용 가능)

  • static을 붙여 사용

    struct SomeStucture {
      static var someProperty: Int = 10
    }
    
    let number = SomeStucture.someProperty

접근 제어(Access Control)

• 외부로 굳이 보여주지 않아도 될 것들은 감추는 것이 좋다.

• 은닉화 (Hiding)

  • 주요 사항이 겉으로 드러나지 않도록 감추는 것

• 캡슐화 (Encapsulation)

  • 중요사항을 감춘 상태에서 외부에서 그것을 사용할 수 있는 방법을 제공하고 외부와 소통하는 것
• 운전자가 직접 자동차 하부의 전진 기어를 엔진으로 연결하도록 하는 것이 아니라, 차에게 전진 명령을 주면 자동차의 인스턴스가 전진 기어를 엔진으로 연결하게 만드는 것이 캡슐화이다.
• 그 과정에서 전진 기어는 운전자에게 직접 보이지 않도록 내부로 감추는 것이 은닉화이다.
• 타입을 설계할 때 순서
  • 일반화 → 추상화 → 은닉화 → 캡슐화

접근 수준(Access Level)

• 접근제어는 접근 수준 키워드를 통해 구현할 수 있다.

• 각 타입(클래스, 구조체, 열거형 등)에 특정 접근수준을 지정할 수 있다.

• 타입 내부의 프로퍼티, 메서드, 이니셜라이저, 서브스크립트 각각에도 접근수준을 지정할 수 있다.

• public - 공개 접근 수준 (모듈 외부까지)

  • 어디서든 쓰일 수 있다.

  • 자신이 구현된 소스파일, 그 소스파일이 속해 있는 모듈, 그 모듈을 가져다 쓰는 모듈 등 모든 곳

  • 주로 프레임워크에서 외부와 연결될 인터페이스를 구현하는데 많이 쓰인다.

  • 스위프트의 기본 요소는 모두 공개 접근 수준으로 구현한다.

    // 스위프트 표준 라이브러리에 정의되어 있는 Bool 타입의 일부
    /// A value type whose instances are either 'true' or 'false'.
    public struct Bool {
         /// Default-initialize Boolean value to 'false'.
         public init()
    }

• open - 개방 접근 수준 (모듈 외부까지)

  • public 접근 수준 이상으로 높은 접근 수준

  • 클래스와 클래스의 멤버에서만 사용 가능하다.

  • public 접근 수준과 비슷하지만 다음과 같은 차이점이 있다.

    • 개방 접근 수준을 제외한 다른 모든 접근수준의 클래스는 그 클래스가 정의된 모듈 안에서만 상속할 수 있다.

    • 개방 접근 수준의 클래스는 그 클래스가 정의된 모듈 밖의 다른 모듈에서도 상속할 수 있다.

    • 개방 접근 수준을 제외한 다른 모든 접근수준의 클래스 멤버는 해당 멤버가 정의된 모듈 안에서만 재정의할 수 있다.

    • 개방 접근 수준의 클래스 멤버는 해당 멤버가 정의된 모듈 밖의 다른 모듈에서도 재정의(override)할 수 있다.

    • 클래스를 개방 접근 수준으로 명시하는 것은 그 클래스를 다른 모듈에서도 부모클래스로 사용 하겠다는 목적으로 클래스를 설계하고 코드를 작성했음을 의미한다.

      // Foundation 프레임워크에 정의되어 있는 개방 접근 수준의 NSString 클래스
      open class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
           open var length: Int { get }
           open func character(at index: Int) -> unichar
           public init()
           public init?(coder aDecoder: NSCoder)
      }

  • 라이브러리 혹은 프레임워크를 설계할 때 라이브러리나 프레임워크를 사용하는 프로그래머가 이 타입을 사용할 수 있도록 하려면 open 혹은 public 공개수준으로 타입을 정의하면 된다.

    • 라이브러리 사용자(프로그래머)가 상속받아 사용하면 좋겠다거나 상속 후 재정의하여 사용하면 좋겠다는 생각을 한다면 open 개방 접근 수준으로, 그렇지 않고 클래스를 상속받거나 재정의 할 수 없도록 막고싶다면 public 공개 접근 수준으로 정의한다.
    • open 및 public 접근수준이 아닌 다른 클래스 및 타입은 모듈 외부에서 접근할 수 없으므로 라이브러리 혹은 프레임워크를 사용하는 프로그래머가 사용할 수 없다.

• internal - 내부 접근 수준 (모듈 내부)

  • 기본적으로 모든 요소에 암묵적으로 지정하는 기본 접근수준
  • 소스파일이 속해 있는 모듈 어디에서든 쓰일 수 있다.
  • 다만 그 모듈을 가져다 쓰는 외부 모듈에서는 접근할 수 없다.
  • 보통 외부에서 사용할 클래스나 구조체가 아니며, 모듈 내부에서 광역적으로 사용할 경우 지정한다.

• fileprivate - 파일 외부 비공개 접근 수준 (파일 내부)

  • 요소가 구현된 소스파일 내부에서만 사용 가능하다.
  • 해당 소스파일 외부에서 값이 변경되거나 함수를 호출하면 부작용이 생길 수 있는 경우 사용하면 좋다.

• private - 비공개 접근 수준 (기능 정의 내부)

  • 가장 한정적인 범위
  • 기능을 정의하고 구현한 범위 내에서만 사용 가능하다.
  • 심지어 같은 소스파일 안에 구현한 다른 타입이나 기능에서도 사용이 불가능하다.

1. 클로저(Closure) 기초

• 클로저는 코드의 블록 이며 일급시민(first-citizen)이다.
  

• 함수의 전달인자, 변수, 상수 등으로 저장, 전달이 가능하다.

• 함수 내부에서 원하는 코드블럭 실행이 가능하다.

  // 클로저의 사용
  // sum이라는 상수에 클로저를 할당
  let sum: (Int, Int) -> Int = { (a: Int, b: Int) in
    return a + b
  }
  let sumResult: Int = sum(1, 2)
  print(sumResult) // 3

2. 다양한 클로저 표현

• 함수의 마지막 매개변수에 전달되는 클로저는 후행클로저(trailing closure)로 함수 소괄호 밖에 구현이 가능하다.
  

• 컴파일러가 클로저의 타입을 유추할 수 있는 경우 매개변수, 반환 타입 생략이 가능하다.

• 반환 값이 있는 경우, 암시적으로 클로저의 맨 마지막 줄은 return 키워드를 생략해도 반환 값으로 취급한다.

• 전달인자의 이름이 굳이 필요없고, 컴파일러가 타입을 유추할 수 있는 경우 축약된 전달인자 이름($0, $1, $2…) 사용 가능하다.

3. 고차함수(Higher-order function)

• 고차함수는 다른 함수를 매개변수의 전달인자로 받거나 함수실행의 결과를 함수로 반환하는 함수이다.
  

• 유용한 고차함수는 스위프트 표준 라이브러리에서 제공한다. (map, filter, reduce 등)

• map

  • 컨테이너 내부의 기존 데이터를 변형(transform)하여 새로운 컨테이너를 생성한다.
    

  • flatMap

    • 컨테이너의 각 요소를 사용하여 지정된 조건을 호출할 때, 순차적인 결과의 배열 반환한다.
    • = 중첩된 배열을 제거하고 평평한 배열(flattened array) 반환한다.

  • compactMap

    • 컨테이너의 각 요소를 조건을 지정하여 호출할 때, nil이 아닌 배열 반환한다.

• filter

  • 컨테이너 내부의 값을 걸러서 새로운 컨테이너로 추출한다.

• reduce

  • 컨테이너 내부의 콘텐츠를 하나로 통합한다.
  • result : 초깃값으로부터 출발하여 마지막 요소까지 순회하는 내내의 결괏값
  • currentItem : 현재 순회하고 있는 요소의 값

오늘은 제목처럼 SwiftUI를 사용한 Log in 화면 구현 과정을 풀어내 보겠다 🧐

먼저, 요구사항은 다음과 같다.

• 아이디에는 Email 형식만 입력
  • 형식이 맞지 않으면 Alert 창 띄우기
• 아이디랑 비밀번호 칸이 두 개가 다 입력되어 있고, 토글 버튼이 true여야 회원가입 버튼이 활성화
• 비밀번호 텍스트 필드 값은 암호 표시
• 아이디와 비밀번호가 설정한 것과 일치하면 다른 뷰로 넘어가기
  • 일치하지 않으면 Alert 창 띄우기
• 화면의 빈 부분을 터치하면 키보드 숨기기
• 아이디 텍스트 필드에서 키보드의 Enter(Return) 버튼을 누르면 비밀번호 텍스트 필드로 넘어가기

이제 기본 뼈대 구현 방법은 제외하고, 각 요구사항 별로 내가 구현한 방법들을 설명해 보겠다 💡

아이디에는 Email 형식만 입력

형식이 맞지 않으면 Alert 창 띄우기

여기에서는 정규 표현식을 사용하는 메서드를 만들어서 다음의 코드와 같은 형식을 만족하지 않으면 Sign in 버튼을 눌렀을 때 Alert 창을 띄우도록 했다.

// 정규 표현식을 사용해 Email 형식 유무 체크

private func checkEmailForm(input: String) -> Bool {
    let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,6}"
    return NSPredicate(format: "SELF MATCHES %@", emailRegex).evaluate(with: input)
}

// Email 형식을 준수하지 않았을 때 띄우는 Alert

.alert(isPresented: $isValid) {
    Alert(title: Text("경고"), message: Text("이메일 형식이 올바르지 않습니다."), dismissButton: .default(Text("확인")))
}

아이디랑 비밀번호 칸이 두 개가 다 입력되어 있고, 토글 버튼이 true여야 회원가입 버튼이 활성화

이 요구사항은 간단한 조건식을 사용해서 구현해 보았다.

// 모든 TextField가 채워지고 토글버튼을 On 해야 버튼이 활성화 되는 조건식

.disabled(email.isEmpty || password.isEmpty || !toggling)

비밀번호 텍스트 필드 값은 암호 표시

이 요구사항은 간단하게 TextField 대신 SecureField를 사용해서 해결했다.

// 비밀번호 텍스트 필드 암호 표시

SecureField("Password", text: $password)

아이디와 비밀번호가 설정한 것과 일치하면 다른 뷰로 넘어가기

일치하지 않으면 Alert 창 띄우기

여기에서는 checkLogin이라는 메서드를 만들어서 이메일과 패스워드 둘 중 하나라도 설정한 값들과 맞지 않으면 미리 만들어 놓은 Bool 타입의 @State notCorrectLogin 변수가 true가 되도록 했다.

// 이메일, 패스워드의 일치 여부 확인

private func checkLogin(isEmail: String, isPassword: String) {
    if isEmail != correctEmail || isPassword != correctPassword {
        notCorrectLogin = true
    }
}

계정 정보가 일치할 때 다른 뷰로 넘어가는 기능은 NavigationLink와 Bool 타입의 @State isActive 변수 를 사용해서 구현했다.

@State private var isActive: Bool = false

NavigationLink(destination: DetailView(), isActive: $isActive) {
    EmptyView()
}

그리고 계정 정보가 일치하지 않았을 때 Sign in 버튼을 누르면 Alert 창을 띄우도록 했다.

// 계정 정보가 일치하지 않을 때 띄우는 Alert

.alert(isPresented: $notCorrectLogin) {
    Alert(title: Text("주의\n"), message: Text("이메일, 또는 비밀번호가 일치하지 않습니다."), dismissButton: .default(Text("확인")))
}

화면의 빈 부분을 터치하면 키보드 숨기기

이 요구사항은 그 동안 해본 적 없는 생소한 부분이라서 구현하는 데 좀 더 시간이 걸렸다. 먼저, extension을 사용해서 View에 다음과 같은 메서드를 추가했다.

// UIKit에서도 활용하는 resignFirstResponder 메서드 추가

extension View {
    func endTextEditing() {          
    UIApplication.shared.sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)    
    }
}

그리고 빈 곳을 탭 했을 때 키보드를 내리고 싶은 뷰 하단에 다음과 같이 onTapGesture 이벤트 메서드를 추가하면 요구사항이 구현된다.

.onTapGesture{
    self.endTextEditing()
}

아이디 텍스트 필드에서 키보드의 Enter(Return) 버튼을 누르면 비밀번호 텍스트 필드로 넘어가기

이 요구사항에서는 @FocusState 변수를 옵셔널로 선언해서 각 TextField마다 submitLabel을 설정해두고 onSubmit을 통해 submit이 되면 자동으로 다음 TextField로 넘어가도록 하였다.

@FocusState private var focusedField: Field?

var body: some View {
    NavigationStack {
        VStack {
        TextField("Email", text: $email)
            .focused($focusedField, equals: .email)
            .textContentType(.givenName)

        SecureField("Password", text: $password)
            .focused($focusedField, equals: .password)
            .textContentType(.familyName)
        }
        .onSubmit {
            switch focusedField {
            case .email:
                focusedField = .password
            default:
                print("Done")
            }
        }
    }
}

전체 코드

import SwiftUI

extension View {
    func endTextEditing() {
        UIApplication.shared.sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)
    }
}

struct ContentView: View {
    enum Field {
        case email
        case password
    }

    @State private var email: String = ""
    @State private var password: String = ""
    @State private var toggling = false
    @State private var isValid: Bool = false
    @State private var notCorrectLogin: Bool = false
    @State private var isShowingDetailView = false
    @State private var isActive: Bool = false
    @FocusState private var focusedField: Field?

    private var correctEmail: String = "a_jb97@naver.com"
    private var correctPassword: String = "mindol97"

    var body: some View {
        NavigationStack {
            VStack(alignment: .leading) {
                Text("Introduce your credentials")
                    .foregroundColor(.gray)

                TextField("Email", text: $email)
                    .textFieldStyle(.roundedBorder)
                    .keyboardType(.emailAddress)
                    .textInputAutocapitalization(.never)
                    .focused($focusedField, equals: .email)
                    .textContentType(.givenName)

                SecureField("Password", text: $password)
                    .textFieldStyle(.roundedBorder)
                    .textInputAutocapitalization(.never)
                    .focused($focusedField, equals: .password)
                    .textContentType(.familyName)

                Toggle(isOn: $toggling) {
                    Text("Agree to terms and conditions")
                        .font(.subheadline)
                }
            }
            .onSubmit {
                switch focusedField {
                case .email:
                    focusedField = .password
                default:
                    print("Done")
                }
            }
            .padding()

            Button {
                isValid = !checkEmailForm(input: email)
                checkLogin(isEmail: email, isPassword: password)

                if notCorrectLogin == false {
                    print("로그인 성공")
                    isActive = true
                }
            } label: {
                Text("Sign in")
                    .frame(width: 300, height: 30)
            }
            .alert(isPresented: $isValid) {
                Alert(title: Text("경고"), message: Text("이메일 형식이 올바르지 않습니다."), dismissButton: .default(Text("확인")))
            }
            .alert(isPresented: $notCorrectLogin) {
                Alert(title: Text("주의\n"), message: Text("이메일, 또는 비밀번호가 일치하지 않습니다."), dismissButton: .default(Text("확인")))
            }
            .disabled(email.isEmpty || password.isEmpty || !toggling)
            .buttonStyle(.borderedProminent)
            .padding()

            NavigationLink(destination: DetailView(), isActive: $isActive) {
                EmptyView()
            }

            Spacer()

            .navigationTitle("Log in")
        }
        .onTapGesture{
            self.endTextEditing()
        }
    }

    private func checkEmailForm(input: String) -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,6}"
        return NSPredicate(format: "SELF MATCHES %@", emailRegex).evaluate(with: input)
    }

    private func checkLogin(isEmail: String, isPassword: String) {
        if isEmail != correctEmail || isPassword != correctPassword {
            notCorrectLogin = true
        }
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}