• range(of:options:)
• NSRegularExpression
• NSRegularExpression.Options
• Swift Regex
• Regex
• Swift Regex의 특징
• Regex Builder
• 매칭 데이터 추출 (Capture)
• 유니코드 활용
• TryCapture
• Swift Regex 활용하기
• Match
• Swift Standard Library API

Regex의 개념적인 내용들을 알았으니, 이제 Swift에서는 이 Regex를 어떻게 사용하는지 알아봅시다.

🍎 Swift - Regex.01

못 보신 분들은 위 포스트로!

range(of:options:)

어찌 보면 가장 간편하게 사용할 수 있는 방법입니다.

검색해봤을 때 가장 흔하게 나오는 방법이기도 하구요!

str.range(of: regex, options: .regularExpression)

String 타입의 메서드로 구현되어 있어 주어진 String 타입 값 (예시의 경우 str) 에 대한 결과를 받아오는 형태를 가지고 있습니다.

regex 자리에 정규식 표현을 집어넣고, options로 .regularExpression을 주어 정규식을 충족하는 범위(Range) 를 받아옵니다.

값이 아니라 범위에요! (메서드 이름부터가 range잖아요? 😅)

이 때, 정규식을 충족하는 범위가 없다면 nil 값을 던져주기 때문에 결과는 Optional 타입입니다.

이 Range 결과값을 원래의 String과 함께 string[range]의 형태로 사용해 정규식을 충족하는 부분의 실제 값을 얻어낼 수 있죠.

import Foundation

let strings: [String] = ["abcde", "123", "abc123de45f"]
let pattern: String = "[0-9]*"

for string in strings {
  guard let range = string.range(of: pattern, options: .regularExpression) else { continue }
  print("\(string)에서 숫자로 이루어 진 부분은 \(string[range]) 입니다.")
}

import Foundation

let strings: [String] = ["abcde", "123", "abc123de45f"]
let pattern: String = "[0-9]+"

for string in strings {
  guard let range = string.range(of: pattern, options: .regularExpression) else { continue }
  print("\(string)에서 숫자로 이루어 진 부분은 \(string[range]) 입니다.")
}

range(of:options:)는 편하지만 무조건 가장 처음에 매칭되는 범위만을 반환한다는 단점이 있습니다.

어쩔 수 없어요.. 그게 저 메서드의 목적이거든요.

정규식만을 위한 메서드가 아니고 좀 더 범용적인 메서드에 정규식 기능이 뽀너스로 있는 형태라서 그렇습니다.

NSRegularExpression

그래서 여기 정규식만을 위한 방법도 있답니다!

NSRegularExpression(pattern: pattern, options: [])

NSRegularExpression을 사용하는 방법입니다.

import Foundation

let strings: [String] = ["abcde", "123", "abc123cd45e"]
let pattern: String = "[0-9]*"

var results: [[String]] = []
for string in strings {
  do {
    let regex = try NSRegularExpression(pattern: pattern)
    let result = regex.matches(in: string, range: NSRange(location: .zero, length: string.count))
    
    let resultStrings = result.map {
      let range = Range($0.range, in: string)!
      return String(string[range])
    }.filter {
      !$0.isEmpty
    }
    
    results.append(resultStrings)
  } catch {
    print(error.localizedDescription)
  }
}

results.forEach { print($0) }

우선 NSRegularExpression의 생성자는 throwable하기 때문에 try-catch 문을 사용해주셔야 해요. (9번 라인)

matches 메서드를 사용해 string에서 정규식을 충족하는 모든 부분들에 대한 NSTextCheckingResult 클래스를 배열로 받아옵니다. (10번 라인)

이 NSTextCheckingResult의 range 프로퍼티를 이용하면 위의 range(of:options:) 메서드와 동일한 방법으로 매칭 내용을 얻어낼 수 있습니다. (예시처럼 map을 활용하면 편하겠죠?)

NSRegularExpression.Options

한 가지 안 본게 있습니다.

바로 options: 파라미터에 들어갈 값인데요..

init(
    pattern: String,
    options: NSRegularExpression.Options = []
) throws

기본값으로는 빈 배열이 들어가 있습니다.

그런데 여기에 총 7개의 값을 넣어줄 수 있답니다.

솔직히 많이 사용할까? 싶어서 자세히 다루지는 않겠습니다.

"""
abcdefg
abc
defg
"""

여기까지가 기존에 사용하던 방식들이구요..! 진짜는 지금부터입니다.

Swift Regex

사실 이 포스트는 이전 내용들이 아니라 지금부터 나올 내용들을 정리하기 위한 포스트였어요! 😜

위 내용들.. 조금 직관적이지 못하고 Swifty하지도 않죠?

Obj-C 시절부터 쓰던 코드들이라 그렇습니다. (NS가 붙은거에서부터 아셨을 것 같아요 😅)

WWDC22에서는 정규식을 좀 더 Swifty하게 사용할 수 있도록 새로운 API가 등장했습니다.

그래서 이제부터 그 내용을 살펴볼게요!

Regex

우리를 구원할 그 구조체부터 등장합니다.

struct Regex<Output> { ... }

Regex 구조체는 Output 제너릭 타입을 가집니다.

이 Output은 말 그대로 결과를 위해 사용되는 타입이구요.

Regex는 특이하게도 /로 문자들을 감싸 초기화할 수 있습니다.

컴파일러 또한 이 문법을 알고 있기 때문에(!) 컴파일 에러를 통해 문법적 오류를 방지할 수 있습니다.

let digits = /\d+/
// digits: Regex<Substring>

사용자의 입력을 받아 패턴을 설정하는 등의 런타임동안 패턴이 결정되야 한다면

let runtimeString = #"\d+"#
let digits = try Regex(runtimeString)
// digits: Regex<AnyRegexOutput>

이렇게 문자열을 제공하는 형태의 생성자도 사용할 수 있습니다.

try 문에서 유추할 수 있다싶이, 올바르지 않은 문법이 들어온다면 런타임 에러를 발생시키기도 한답니다.

다만 이 경우에는 런타임 전까지는 Output 타입을 추정할 수 없기 때문에 AnyRegexOutput이라는 일종의 Any 타입을 사용하게 됩니다.

바로 다음에 더 살펴보겠지만,

let digits = OneOrMore(.digit)
// digits: Regex<Substring>

이렇게 Regex Builder라는 API를 통해 생성되는 인스턴스 또한 Regex 구조체입니다.

Swift Regex의 특징

이쯤에서 특징이라 쓰고 장점이라고 읽는 애플이 소개하는 Swift Regex의 특징을 알아봅시다.

1. Regex Builder를 통해 코드를 작성하듯이 구조화되고 정돈된 방법으로 사용할 수 있다.
2. 실제 Parser를 정규식의 구성요소로서 가져다 쓸 수 있다.
3. Unicode를 지원해 어떤 언어던지 대응할 수 있다.
4. 예측 가능한 실행 방식을 제공해 어떤 부분이 문제인지 파악하기 쉽다.

Regex Builder

자 그래서 이렇게까지 좋다고 난리부르스인 Regex Builder란 무엇일까요?

Regex Builder란 정규식을 "선언형" 프로그래밍 방식으로 사용할 수 있도록 하는 API입니다.

import RegexBuilder

RegexBuilder를 사용하려면 우선 import를 해줘야한다는 점 잊지 마시구요!

"""
CREDIT    03/02/2022    Payroll from employer         $200.23
CREDIT    03/03/2022    Suspect A                     $2,000,000.00
DEBIT     03/03/2022    Ted's Pet Rock Sanctuary      $2,000,000.00
DEBIT     03/05/2022    Doug's Dugout Dogs            $33.27
"""

이제 진짜로 사용법을 알아봅시다.

이런 데이터가 있다고 해볼게요.

이 데이터를 각 필드에 따라 데이터화 하기 위해서 정규식을 사용해봅시다.

let fieldSeparator = /\s{2,}|\t/
let transactionMatcher = Regex {
  /CREDIT|DEBIT/
  fieldSeparator
  One(.date(.numeric, locale: Locale(identifier: "en_US"), timeZone: .gmt))
  fieldSeparator
  OneOrMore {
    NegativeLookahead { fieldSeparator }
    CharacterClass.any
  }
  fieldSeparator
  One(.localizedCurrency(code: "USD").locale(Locale(identifier: "en_US")))
}

어라.. 뭐가 지나갔나요? 😵

선언형이라 하나씩 살펴보면 쉬우니까 겁 먹지 말고 한 번 들어가봅시다. (저한테 하는 얘기 맞아요. 🙃)

일단 기본적인 구조는 Regex 생성자의 클로저 파라미터를 통해 각 컴포넌트들을 선언형으로 제공하고 있네요.

검사할 String의 왼쪽부터 오른쪽 순서대로 컴포넌트화 시켜서 검사를 한다니.. 아주 직관적이군요...

이제 컴포넌트별로 하나씩 살펴봅시다.

먼저 fieldSeparator는 space 기준 2칸 이상의 whitespace를 매칭하는 일반적인 형태의 정규식으로 정의되어 있네요.

각각의 필드를 구분하기 위해 사용해주고 있는 것 같죠?

CREDIT과 DEBIT도 쉽습니다.

두 가지 경우의 수 밖에 없기 때문에 CREDIT|DEBIT이면 충분하죠.

날짜를 파싱할 때 Regex Builder의 특징이 잘 들어납니다.

"실제 Parser를 정규식의 구성요소로서 가져다 쓸 수 있다."라는 특징이 있었죠?

String 값을 One이라는 Regex 구조체와 .date라는 메서드를 사용해 날짜 형식으로 불러올 수 있다는 뜻 입니다.

.numeric 외에 다른 형식으로 파싱도 가능하고, locale과 timeZone도 설정이 가능한 점은 굳이 설명하지 않아도 알 수 있죠! 😁

제일 복잡해보이는 세 번째 필드입니다.

OneOrMore { CharacterClass.any }

이미 주어진 정답 대신 이렇게 사용하면 결과는 어떻게 나올까요?

답은 "동일하다." 입니다.

어떤 캐릭터던지 하나 혹은 그 이상을 찾아내고, 바로 다음에 fieldSeparator가 다시 오기 때문에 whitespace들 전까지의 값만 정상적으로 매칭됩니다.

그런데 정답에서 훨씬 복잡해보이는

OneOrMore {
  NegativeLookahead { fieldSeparator }
  CharacterClass.any
}

을 사용한 이유는 최적화를 위해서입니다.

Regex Builder는 fieldSeparator를 만나기 전까지는 OneOrMore { CharacterClass.any }에 매칭되는 String의 끝까지를 매칭 범위라고 생각합니다.

그리고 그 이후에 fieldSeparator를 만난 후에 끝까지 생각한 매칭 범위에서 하나씩 범위를 줄여나가며 새로운 조건에 매칭되는 요소를 찾아나가는 것이죠.

전부 잡아놓고 하나씩 줄여가며 검사하는 것 보다는 애초에 처음부터 잘 잡아두는 것이 더 효율적이겠죠?

정답의 예시는 NegativeLookahead를 사용해 다음 값이 fieldSeparator인지를 검사하며 매칭되는 요소라면 중단하는 방식으로 진행한 모습입니다.

NegativeLookahead가 뭔가요?

Lookahead는 Regex의 고급 문법 중 하나로, 4개의 종류를 가지고 있습니다.

예.. 헷갈리죠? 저도요 🙃

위 이미지의 출처인 엘바노프님의 포스트를 참고해주세요.

저도 헷갈릴 때마다 찾아가는 포스트랍니다.

한 가지만 더 확인하고 넘어갈까요? OneOrMore과 같은 Repetition에 관한 이야기입니다.

Swift Regex는 OneOrMore, ZeroOrMore, Optioinally, Repeat과 같은 반복적으로 수행되는 표현식들이 있습니다.

이 기능들은 기본적으로 .eager하게 동작합니다.

OneOrMore(.any, .eager)

이렇게요.

저 자리에 들어갈 수 있는 옵션들을 살펴봅시다. (3개 밖에 없어요!)

• .eager

이름답게 가능한 모든 매칭을 가져갑니다. 그렇기 때문에 뒤에 오는 Optionally와 같은 경우를 무시하는 경우도 생기죠.

• .reluctant

.eager과는 다르게 가능한 최소한의 매칭을 가져갑니다.

이 옵션을 사용하면 위의 Optionally를 무시하는 경우는 없겠죠?

• .possessive

가능한 모든 매핑을 가져가고, 백트래킹조차 하지 않습니다.

이 옵션들은 각각의 Repetition들에 적용해줄 수도 있지만,

Regex {
  OneOrMore(.digit)
  "."
  OneOrMore(.digit)
}
.repetitionBehavior(.reluctant)

이렇게 맨 뒤에 .repetitionBehavior로 Regex의 기본 옵션을 변경해줌으로써 적용해줄 수도 있습니다.

마지막 금액 부분은 Date 부분과 비슷한 방식으로 처리해주시면 됩니다.

마찬가지로 Foundation의 Parser인 .localizedCurrency를 사용하고 있네요.

매칭 데이터 추출 (Capture)

자 그런데 우리는 이 데이터들을 단순히 인식하는 것이 아니라 매칭된 값들을 추출하고 싶습니다.

해당 값들을 사용해야 하잖아요?

일반적인 Regex에도 이런 기능은 있습니다.

Named Capture Group이라는 이름의 기능인데요, (?<identifier>\d+) 대략 이런 형태입니다.

\d+의 조건에 매칭되는 그룹의 값을 identifier라는 이름으로 접근해 사용할 수 있는 기능입니다.

Regex Builder도 물론 이런 기능을 지원합니다.

Capture를 통해서요!

let fieldSeparator = /\s{2,}|\t/
let transactionMatcher = Regex {
  Capture { /CREDIT|DEBIT/ }
  fieldSeparator
  
  Capture { One(.date(.numeric, locale: Locale(identifier: "en_US"), timeZone: .gmt)) }
  fieldSeparator
  
  Capture {
    OneOrMore {
      NegativeLookahead { fieldSeparator }
      CharacterClass.any
    }
  }
  fieldSeparator
  
  Capture { One(.localizedCurrency(code: "USD", locale: Locale(identifier: "en_US"))) }
}
// transactionMatcher: Regex<(Substring, Substring, Date, Substring, Decimal)>

그런데 이때 파싱되는 값들에 Date와 Decimal도 포함되어 있죠?

Foundation Parser를 활용하는 Regex Builder의 강점이라고 할 수 있겠습니다.

guard let match = transaction.wholeMatch(of: transactionMatcher) else {
  fatalError()
}

print(match.output.2, match.output.4)

이렇게 추출해낸 값들은 output.2와 같이 튜플의 형태로 사용할 수 있습니다.

/.../ 형태를 사용할 떄는 괄호 ()를 통해서 Capture를 할 수 있습니다.

let regex = Regex {
  "a"
  /d(e)f/
}

여기서도 하나만 더 알아봅시다! Transforming Capture라는 기능입니다.

Transforming Capture는 Capture한 값을 다른 특정한 데이터 타입으로 변환해서 Capture하고 싶을 때 사용합니다.

Regex {
  Capture {
    OneOrMore(.digit)
  } transform; {
    Int($0)
  }
} // Regex<(Substring, Int?)>

Regex {
  TryCapture {
    ChoiceOf {
      "started"
      "passed"
      "failed"
    }
  } transform: {
    TestStatus(rawValue: String($0))
  }
} // Regex<(Substring, TestStatus)>

유니코드 활용

다시 세션으로 돌아가봅시다.

마음을 다 잡고 다시 집중으로 하려고 하는 찰나.. 애플이 갑자기 급발진을 합니다...!

private let ledger = """
KIND      DATE          INSTITUTION                AMOUNT
----------------------------------------------------------------
CREDIT    03/01/2022    Payroll from employer      $200.23
CREDIT    03/03/2022    Suspect A                  $2,000,000.00
DEBIT     03/03/2022    Ted's Pet Rock Sanctuary   $2,000,000.00
DEBIT     03/05/2022    Doug's Dugout Dogs         $33.27
DEBIT     06/03/2022    Oxford Comma Supply Ltd.   £57.33
"""

여기서 DATE 부분의 값이 월/일/년 인지 일/월/년인지 애매모호하다!

하지만 AMOUNT의 달러 사인과 유로 사인을 통해 유추가 가능하니 이걸 활용해보자!

라고 하더니 갑자기 이런걸 들이댑니다.

let regex = #/
  (?<date>     \d{2} / \d{2} / \d{4})
  (?<middle>   \P{currencySymbol}+)
  (?<currency> \p{currencySymbol})
/#
// Regex<(Substring, date: Substring, middle: Substring, currency: Substring)>

...? 😕

#/ ... /#를 사용하면 whitespace를 무시해서 일반 코드처럼 가독성 있는 코딩을 할 수 있다!

까지는 뭐 알겠어요.

\P{currencySymbol}이 대체 뭔데 하면서 이것저것 찾아보던 중...

예.. Regex에 원래 있는 표현이였습니다. (출처는 애플 공식 문서입니다.)

Unicode에서 정의한 프로퍼티에 속해있는지 검사하는 표현들이라고 하네요.

\p{}가 프로퍼티에 속해있는지이고 \P{}는 프로퍼티에 속해있지 않은지를 검사하는 표현이라고 해요.

지정된 유니코드 프로퍼티들은 여기에서 확인하실 수 있습니다.

근데요.. 또 currencySymbol은 그룹 이름에 없더라고요..?

대신 비스무리한 건 있었습니다.

\\p\{Sc\} or \\p\{Currency_Symbol\} : any currency sign.

애플이 또 나름대로 래핑을 한 건지 뭔지... 알 수가 없군요.

뭔가 알아내면 내용을 추가해놓도록 하겠습니다.

Unicode.GeneralCategory

하하 😲 Swift에 정의되어 있는게 맞더군요!

Unicode 문서를 보시면 미리 분류된 case들이 enum으로 정의되어 있고..

그 중 GeneralCategory에 currencySymbol이 정의되어 있습니다.

사실 WWDC22 영상에서도 "Unicode Property" 를 사용한다고 언급하는데요, 제가 모르던 개념이였기 때문에 띠용했던게 아닐까 싶습니다 😅

역시 오늘도 먹히는 아는만큼 보인다...

다시 돌아가서...

이제 우리는 (?<currency> \p{currencySymbol}) 이걸 통해서 통화의 기호를 받아올 수 있죠?

func pickStrategy(_ currency: Substring) -> Date.ParseStrategy {
  switch currency {
  case "$": return .date(.numeric, locale: Locale(identifier: "en_US"), timeZone: .gmt)
  case "£": return .date(.numeric, locale: Locale(identifier: "en_GB"), timeZone: .gmt)
  default: fatalError("We found another one!")
  }
}

그걸 이런 식으로 활용해 날짜를 파싱하는 방법에 차이를 만들어주려고 하나봅니다.

ledger.replace(regex) { match -> String in
  let date = try! Date(String(match.date), strategy: pickStrategy(match.currency))

  // ISO 8601, it's the only way to be sure
  let newDate = date.formatted(.iso8601.year().month().day())

  return newDate + match.middle + match.currency
}

주어진 문자열에서 regex를 사용해 애매모호했던 날짜 부분을 통화에 따라 다른 파싱 방식을 써서

확실한 형태의 newDate로 변환해서 저장해주는 함수입니다.

위의 형태에서 아래 형태로요!

여기까지 모든 게 완벽해 보이지만, 한 가지 고려할 점이 하나 더 있습니다.

TryCapture

지금까지 저희가 사용한 정규식은 모든 데이터가 제자리에 있을 때만! 동작하거든요.

어떤 필드의 자리에 조건에 맞는 데이터가 없을 때는 매칭이 실패해서 해당 레코드 자체가 인식되지 못하겠죠?

Swift는 정규식에 Optional을 도입한 TryCapture이라는 기능을 제공합니다.

// CREDIT  <proprietary>  <redacted>  200.23  A1B34EFF  ...
let fieldSeparator = /\s{2,}|\t/
let field = OneOrMore {
  NegativeLookahead { fieldSeparator }
  CharacterClass.any
}
let transactionMatcher = Regex {
  Capture { /CREDIT|DEBIT/ }
  fieldSeparator

  TryCapture(field) { timestamp ~= $0 ? $0 : nil }
  fieldSeparator

  TryCapture(field) { details ~= $0 ? $0 : nil }
  fieldSeparator

  // ...
}

내용에 상관없이 필드별로 데이터를 분리하기 위해 NegativeLookahead를 다시 한 번 활용해 field를 정의해주고요..

TryCapture(field)를 사용해 field 범위의 값이 timestamp나 details의 범위에 있다면 해당 값을 "Capture"하고, 범위에서 벗어난 값이라면 nil을 "Capture"합니다.

이제 진짜 끝이겠죠? 👀

하나 더 남았습니다 😂

지금까지 사용하던 fieldSeparator에서 문제가 하나 발생하는데요,

let fieldSeparator = /\s{2,}|\t/

2개 이상의 space 혹은 탭을 매칭시키는 정규식이였죠?

이 중에서 2개 이상의 space가 문제가 된다고 합니다.

이후에 오는 패턴이 실패하면, 매칭되었던 space의 개수를 1개씩 줄여가며 최소 개수인 2개가 될 때까지 계속해서 다시 시도한다고 하네요.

애플이 만든 애니메이션을 참고하면 아마 이해가 되실 거에요!

이 현상은 Regex의 Global Backtracking이라는 특징 때문에 일어납니다.

"때문에"라기엔 이 특징 덕분에 정규표현식이 강력한거긴 합니다. 다만 이 경우에는 부분적으로 Local Backtracking을 사용하는 편이 더 효율적이기 때문에라고 이해해주세요!

let fieldSeparator = Local { /\s{2,}|\t/ }

사용법은 Local로 기존 표현식을 한 번 감싸주면 됩니다. 쉽죠? 😁

Local 빌더를 사용하면 어떤 점이 효율적인걸까요?

Local 빌더에 포함된 정규식이 한 번 매칭되면 그 이후에는 해당 정규식을 다시 검사하지 않습니다.

위 gif에서 볼 수 있었던 백트래킹이 일어나지 않는다는 거죠!

저희가 사용한 예시의 경우에는 필드와 필드가 서로 확실하게 구분되어 있기 때문에 이런 Local Backtracking이 더 효율적일 수 있었던 것입니다.

사실 이 Local 빌더는 Regex의 **"atomic non-capturing group"**이라는 기능을 래핑한 기능입니다.

애플이 생각하기에 보기만 해도 두려운 이름이라 좀 더 친근한 Local이라는 이름을 붙여줬다고 해요.

정리해보면 이 Local이라는 기능은 정규식의 표현을 scope화해서 부분적으로 범위를 설정해줄 수 있는 기능인겁니다.

Swift Regex 활용하기

여기까지 오신 분들 고생하셨습니다. 😁

지금까지의 내용을 뭔가 활용하기에는 각 잡고 써야할 느낌이 강하게 들죠?

애플은 이 강력한 Regex의 기능을 좀 더 곳곳에서 사용할 수 있도록 Swift standard library의 이곳저곳에 침투시켜 뒀습니다.

그 전에 Regex를 사용하는 익숙한 세 가지 방법부터 빠르게 살펴보는걸로 시작해봅시다!

Match

• firstMatch(of:)

정규식에 매칭되는 가장 첫 Substring 을 반환합니다.

• wholeMatch(of:)

전체 String 을 정규식에 매칭시키고 그 결과를 반환합니다.

• prefixMatch(of:)

String의 prefix로 정규식이 매칭되는 경우 그 결과를 반환합니다.

이 셋은 아마 직관적으로 다들 잘 사용하실 수 있을 것 같아요 👍

Swift Standard Library API

꿀이 가득한 구간입니다 🐝

비교적 간단하게 정규식을 사용할 수 있는 경우들이거든요.

• starts(with regex:)

prefixMatch(of:)와 비슷한 기능을 하는데요, 이 경우에는 매칭 데이터 없이 곧바로 Bool 값을 반환해줍니다.

정규식 표현에 맞는 값으로 시작하는지 여부만 검사하고 싶을 때 유용하겠죠?

• replacing(_ regex:, with replacement:)

정규식 표현에 맞는 부분을 replacement에 주어진 문자열로 교체합니다. 되게 유용하게 쓰일 수 있을 것 같은 느낌이 많이 드는 API네요.

• trimmingPrefix(_ regex:)

String의 prefix가 정규식 표현에 매칭된다면 그 값을 제거합니다.

trimmingSuffix는 없다는 점이 조금 아쉽군요..

• split(separator:)

정규식에 매칭되는 부분을 기준으로 String을 split합니다.

iOS 16.0 이상에서만 쓸 수 있다는 점이 아쉬울 정도로 유용한 기능들인 것 같아요..

원래라면은 문자열을 쪼개고 교체하고 붙이고 하는 등의 작업들을 정규식 하나로 처리해줄 수 있는거니까요..!

그리고 애플이 제공한다는 API가 하나 더 있는데요, 바로 패턴 매칭 문법에 사용할 수 있다는 점입니다.

switch "abc" {
case /\w+/:
  print("It's a word!")
default:
  print("It's not a word..")
}

정말 너무 유용해보이죠 ㅎㅎ

근데 왜 저는 안될까요..

하하..

여기를 보면 저만 겪는 문제도 아닌 것 같긴 합니다만.. 적용이 안된 내용을 WWDC 세션에서 소개했을리가 없는 데 말이죠.

이 부분도 추가적으로 알게되는 내용이 있으면 추가해두도록 하겠습니다...

부스트캠프 동료분들이 관련 내용을 찾아주셨습니다!

Swift 커뮤니티 포럼을 보시면 될 것 같습니다.

switch "abcde" {
case /abc/:     // I'd expect this regular expression
case /.*abc.*/: // to work like this one
case /^abc$/:   // rather than this one
default:      
}

/abc/의 기능이 문자열의 부분만 충족해도 case로 처리할 지, 혹은 전체 문자열이 매칭되어야 case로 처리할 지에 대한 토론이 있었던 것 같습니다.

firstMatch와 wholeMatch 중 어떤 매칭 방법을 사용할 지를 고민하셨던 것이죠.

Perl이나 Ruby같은 다른 언어들의 경우들을 참고해가며 토론하신 것 같지만, 아쉽게도 결론이 지어지지 못해 이 기능은 구현되지 못한 것으로 보이네요.

WWDC 세션에 발표까지 됐지만 커뮤니티에 의해 구현이 되지 않은 기능도 있을 수 있다는 깨달음을 얻을 수 있었습니다. 😅

자 어떠셨나요..?

iOS 16부터 사용할 수 있다는 점이 너무 아쉽지만.. 그래도 이제 정규식 좀 쓸 줄은 안다는 입장에서 이런 기능들은 쌍수들고 환영할 내용인 것 같아요 😆

적재적소에 정규식을 사용할 줄 아는 멋진 개발자가 된 것 같아서 (아직 프로젝트에 적용해본 적 없음)

아주 뿌듯하군요! 🥰

References

_슈프림 - [Swift] 코딩테스트 보다가 열 받아서 정리하는 Swift 정규식 - NSRegularExpression (Regex)

ZeddiOS - iOS) NSRegularExpression.Options

WWDC22 - Meet Swift Regex

엘바노프 스튜디오 공식 블로그 겸 낙서장 - 정규표현식 Lookahead, Lookbehind 기능 이해하기

Unicode Regular Expressions

WWDC22 - Swift Regex: Beyond the basics