23 · 포매팅

import Foundation

let iterations = 3000

let t0 = Date()
for _ in 0..<iterations {
    let f = DateFormatter()
    f.locale = Locale(identifier: "en_US_POSIX")
    f.dateFormat = "yyyy-MM-dd HH:mm:ss"
    _ = f.string(from: Date())
}
let freshElapsed = Date().timeIntervalSince(t0)

let cached = DateFormatter()
cached.locale = Locale(identifier: "en_US_POSIX")
cached.dateFormat = "yyyy-MM-dd HH:mm:ss"
let t1 = Date()
for _ in 0..<iterations {
    _ = cached.string(from: Date())
}
let cachedElapsed = Date().timeIntervalSince(t1)

print("매번 새로 생성:", freshElapsed, "초")   // 실측: 0.0483초
print("캐시 재사용:", cachedElapsed, "초")     // 실측: 0.0027초
print("비율:", freshElapsed / cachedElapsed, "배")  // 실측: 약 18배

extension DateFormatter {
    // 설정을 끝낸 뒤로는 절대 바꾸지 않는다 — 그래야 여러 스레드가 동시에 읽어도 안전하다
    static let wireDateTime: DateFormatter = {
        let f = DateFormatter()
        f.locale = Locale(identifier: "en_US_POSIX")
        f.timeZone = TimeZone(identifier: "UTC")
        f.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"
        return f
    }()
}

// 어디서든 이 인스턴스 하나를 공유해서 쓴다 — 매번 새로 만들지 않는다
let payloadDate = DateFormatter.wireDateTime.string(from: Date())

// ❌ 여러 스레드가 같은 wireDateTime을 참조하는데, 누군가 이렇게
// 그때그때 설정을 바꿔버리면 동시에 string(from:)을 부르는 다른 스레드가
// 절반만 바뀐 설정으로 포맷팅할 수 있다
func badFormat(_ date: Date) -> String {
    DateFormatter.wireDateTime.dateFormat = "MM/dd"   // 공유 인스턴스를 오염시킴
    return DateFormatter.wireDateTime.string(from: date)
}

// ✅ 용도가 다르면 처음부터 별도 인스턴스로 분리해 각자 불변으로 둔다
extension DateFormatter {
    static let displayMonthDay: DateFormatter = {
        let f = DateFormatter()
        f.setLocalizedDateFormatFromTemplate("MMdd")
        return f
    }()
}

import Foundation

var gcal = Calendar(identifier: .gregorian)
gcal.timeZone = TimeZone(identifier: "UTC")!

func testYearSymbol(formatterCalendar: Calendar?) {
    let df = DateFormatter()
    df.locale = Locale(identifier: "en_US_POSIX")
    df.timeZone = TimeZone(identifier: "UTC")
    if let c = formatterCalendar { df.calendar = c }   // nil이면 로케일 기본 캘린더를 그대로 씀

    for day in 25...31 {
        var c = DateComponents()
        c.year = 2025; c.month = 12; c.day = day; c.hour = 12
        guard let date = gcal.date(from: c) else { continue }
        df.dateFormat = "yyyy-MM-dd"
        let a = df.string(from: date)
        df.dateFormat = "YYYY-MM-dd"
        let b = df.string(from: date)
        print(a, b, a == b ? "" : "<- 다름")
    }
}

testYearSymbol(formatterCalendar: nil)                              // 포맷터 기본 캘린더: 12/28부터 어긋남
testYearSymbol(formatterCalendar: Calendar(identifier: .iso8601))    // 명시적 ISO8601: 12/29부터 어긋남

let df = DateFormatter()
df.locale = Locale(identifier: "en_US_POSIX")
df.timeZone = TimeZone(identifier: "UTC")

// ❌ "연도니까 대문자든 소문자든 상관없겠지" — 연말연시에 연도가 튄다
df.dateFormat = "YYYY-MM-dd"

// ✅ 캘린더 연도가 필요하면 항상 yyyy
df.dateFormat = "yyyy-MM-dd"

let weekFormatter = DateFormatter()
weekFormatter.locale = Locale(identifier: "en_US_POSIX")
weekFormatter.timeZone = TimeZone(identifier: "UTC")
weekFormatter.calendar = Calendar(identifier: .iso8601)   // 로케일 기본 캘린더에 맡기지 않는다
weekFormatter.dateFormat = "YYYY'년 W'ww"                  // "2026년 W01"

import Foundation

var cal = Calendar(identifier: .gregorian)
cal.timeZone = TimeZone(identifier: "UTC")!
var c = DateComponents()
c.year = 2026; c.month = 1; c.day = 15; c.hour = 14; c.minute = 30
let date = cal.date(from: c)!

let df = DateFormatter()
df.dateFormat = "HH:mm:ss"
df.timeZone = TimeZone(identifier: "UTC")

for id in ["en_US", "ko_KR", "en_GB", "en_US_POSIX"] {
    df.locale = Locale(identifier: id)
    print(id, "->", df.string(from: date))     // 넷 다 "14:30:00" — 정상
}

df.locale = nil                                 // Locale.current에 위임
print("locale 미지정 ->", df.string(from: date))
// 이 기기(Locale.current = ko_KR, hourCycle = oneToTwelve)에서 실측: "오후 2:30:00"

extension DateFormatter {
    static let wireDateTime: DateFormatter = {
        let f = DateFormatter()
        f.locale = Locale(identifier: "en_US_POSIX")   // 기기 설정과 무관하게 항상 24시간·고정 구분자
        f.timeZone = TimeZone(identifier: "UTC")
        f.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"
        return f
    }()
}

let displayFormatter = DateFormatter()
displayFormatter.setLocalizedDateFormatFromTemplate("yMMMdjm")  // 연/월/일/시/분 필드만 요청
// 필드 순서·12/24시간 표기는 사용자 로케일 설정을 그대로 따라간다

import Foundation

var cal = Calendar(identifier: .gregorian)
cal.timeZone = TimeZone(identifier: "UTC")!
var c = DateComponents()
c.year = 2026; c.month = 1; c.day = 15; c.hour = 14; c.minute = 30
let date = cal.date(from: c)!

// 값 타입 조합 — locale/timeZone은 생성자에서, 필드는 체이닝으로
var style = Date.FormatStyle(locale: Locale(identifier: "en_US_POSIX"), timeZone: TimeZone(identifier: "UTC")!)
style = style.year().month(.abbreviated).day()
print(date.formatted(style))                        // 실측: "Jan 15, 2026"

// ParseStrategy — 같은 style 값으로 그대로 되돌린다(대칭)
let numeric = Date.FormatStyle(date: .numeric, time: .omitted,
                                locale: Locale(identifier: "en_US_POSIX"),
                                timeZone: TimeZone(identifier: "UTC")!)
let text = date.formatted(numeric)                    // 실측: "1/15/2026"
let parsed = try! Date(text, strategy: numeric)
print(cal.isDate(parsed, inSameDayAs: date))           // 실측: true — 왕복 성공

// ISO 8601도 같은 방식으로 대칭
let iso = date.formatted(.iso8601)                     // 실측: "2026-01-15T14:30:00Z"
let backFromISO = try! Date(iso, strategy: .iso8601)
print(backFromISO == date)                              // 실측: true

// 같은 설계를 공유하는 다른 도메인들
print(Duration.seconds(5025).formatted(.time(pattern: .hourMinuteSecond)))  // 실측: "1:23:45"
print(1234567.891.formatted(.number.precision(.fractionLength(2))))         // 실측: "1,234,567.89"
print(0.4567.formatted(.percent.precision(.fractionLength(1))))             // 실측: "45.7%"
print(12900.formatted(.currency(code: "KRW")))                              // 실측: "₩12,900"

// ❌ 기존: 캐시해도 여전히 참조 타입 + 문자열 설정
extension DateFormatter {
    static let wireDateTime: DateFormatter = {
        let f = DateFormatter()
        f.locale = Locale(identifier: "en_US_POSIX")
        f.timeZone = TimeZone(identifier: "UTC")
        f.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"
        return f
    }()
}

// ✅ FormatStyle: 값 타입이라 캐싱 목적의 static let이 굳이 필요 없다 —
// 매번 새로 만들어도 저렴하고, 만들 때마다 타입이 검사된다
func wireTimestamp(for date: Date) -> String {
    date.formatted(.iso8601)
}

// 예: Formatter 서브클래스 인스턴스 자체를 받는 옛 API와 맞물려야 하는 경우
func legacyAPI(formatter: DateFormatter) { /* ObjC 쪽 시그니처가 Formatter를 요구 */ }

let bridge = DateFormatter()
bridge.setLocalizedDateFormatFromTemplate("yMMMdjm")  // 필드만 요청, 로케일이 순서를 정함
legacyAPI(formatter: bridge)

import Foundation

// 1) Double: 0.1을 열 번 더해도 정확히 1.0이 아니다
var sum = 0.0
for _ in 0..<10 { sum += 0.1 }
print(sum)                                   // 실측: 0.9999999999999999
print(String(format: "%.20f", sum))          // 실측: 0.99999999999999988898
print(sum - 1.0)                              // 실측: -1.1102230246251565e-16

// 2) Decimal(string:)로 만들면 정확히 1
var dsum = Decimal(0)
for _ in 0..<10 { dsum += Decimal(string: "0.1")! }
print(dsum == Decimal(1))                     // 실측: true

// 3) "리터럴" Decimal(0.1)은 이 환경에서 우연히 깨끗하다
let fromLiteral = Decimal(0.1)
let fromString  = Decimal(string: "0.1")!
print(fromLiteral == fromString)              // 실측: true (둘 다 정확히 0.1)

// 4) 진짜 함정 — 이미 Double 연산을 거친 값을 Decimal로 감싸면 오차가 옮는다
let alreadyComputed = 0.1 + 0.2               // Double: 0.30000000000000004
let wrapped = Decimal(alreadyComputed)
let clean = Decimal(string: "0.3")!
print(wrapped == clean)                        // 실측: false
print(wrapped - clean)                          // 실측: 0.0000000000000000512

// ❌ Double로 먼저 받으면 정밀도가 그 순간 사라진다
struct PriceDouble: Decodable { let value: Double }
// {"value": 19.9999999999999999999} 디코딩 → value == 20.0 (실측, 정밀도 손실 확정)
// 이후 Decimal(value)로 감싸도 이미 20으로 뭉개진 뒤라 되돌릴 수 없다

// ✅ 처음부터 Decimal 프로퍼티로 디코딩하면 텍스트 그대로 보존된다
struct Price: Decodable { let value: Decimal }
// 같은 JSON 디코딩 → value == 19.9999999999999999999 (실측, 손실 없음)

struct Money {
    // 정수 최소단위(원/센트)로 들고 있거나, Decimal로 직접 들고 있는 두 방식 다 안전하다.
    // 핵심은 Double을 절대 경유하지 않는 것.
    let amount: Decimal

    var displayString: String {
        amount.formatted(.currency(code: "KRW"))
    }
}

let price = Money(amount: Decimal(string: "12900.50")!)
print(price.displayString)   // 실측 패턴 확인됨 — 통화 기호 12,900.50 형태로 출력