고(Go) 언어 시간 다루기 완전 정복: time.Parse 함수, 이제는 마스터해볼까요?

고(Go) 언어 시간 다루기 완전 정복: time.Parse 함수, 이제는 마스터해볼까요?

---

고(Go) 언어에서 시간 파싱이 왜 중요할까요?

우리가 프로그램을 만들다 보면, 날짜나 시간 정보를 글자(문자열이라고 부릅니다) 형태로 다뤄야 할 때가 정말 많습니다.

예를 들어, 사용자가 입력한 생일이나, 파일이 만들어진 시간 같은 정보들이 보통 "2024-07-27 10:30:00" 이런 식으로 글자로 되어 있을 텐데요.

컴퓨터는 이런 글자를 곧바로 시간으로 알아듣지 못합니다.

그래서 글자로 된 시간 정보를 컴퓨터가 이해할 수 있는 진짜 시간 정보로 바꿔주는 과정이 필요한데요, 이걸 '시간 파싱(Time Parsing)'이라고 부릅니다.

고(Go) 언어에서는 time이라는 기본 패키지 안에 있는 Parse라는 똑똑한 함수가 이 어려운 일을 멋지게 해낸답니다.

이 time.Parse 함수를 잘 이해하고 활용하면, 고(Go)로 만드는 프로그램에서 시간과 관련된 여러 가지 작업들을 아주 정확하고 효과적으로 처리할 수 있게 되는데요.

자, 그럼 지금부터 time.Parse 함수를 어떻게 사용하는지 차근차근 알아볼까요?.

time.Parse 함수, 어떻게 생겼을까요?

고(Go) 언어의 time.Parse 함수는 우리가 "이런 모양의 시간 글자야!" 하고 알려주면, 그 글자를 분석해서 진짜 시간 정보(time.Time 타입의 값)로 바꿔주는 역할을 합니다.

이 함수를 사용하려면 두 가지 정보를 넘겨줘야 하는데요, 바로 '레이아웃(layout)'과 '값(value)'입니다.

함수의 기본 생김새는 이렇습니다.

func Parse(layout, value string) (Time, error)

여기서 각 부분이 의미하는 바는 다음과 같습니다.

• layout: 우리가 분석하고 싶은 시간 글자가 어떤 형식으로 되어 있는지 알려주는 '설계도' 같은 문자열입니다.
  
  
• value: 실제로 분석할 시간 정보가 담긴 문자열, 즉 '재료'라고 생각하면 쉽습니다.
  
  

함수를 실행하고 나면, 성공적으로 변환된 시간 정보(Time)와 혹시라도 변환 중에 문제가 생겼을 경우 그에 대한 정보(error)를 돌려줍니다.

레이아웃(Layout)은 어떻게 만드는 걸까요? 고(Go)만의 독특한 방식!

고(Go) 언어에서 시간 형식을 알려주는 '레이아웃'을 만드는 방법은 다른 프로그래밍 언어와는 조금 달라서 처음에는 낯설 수 있는데요.

보통 다른 언어에서는 'YYYY-MM-DD'처럼 약속된 기호를 사용하지만, 고(Go)는 아주 특별한 '기준 시간(Reference Time)'을 사용합니다.

이 기준 시간을 우리가 원하는 시간 문자열의 모양대로 바꿔서 표현해주면, 그게 바로 레이아웃이 되는 방식입니다.

마치 "이 샘플처럼 생긴 글자를 시간으로 바꿔줘!" 하고 컴퓨터에게 보여주는 것과 비슷한데요.

고(Go)에서 사용하는 이 마법 같은 기준 시간은 항상 똑같습니다.

바로 Mon Jan 2 15:04:05 MST 2006 입니다.

이 기준 시간의 각 부분이 어떤 시간 요소를 나타내는지 살펴볼까요?.

• 2006: 연도 (Year)
• 01 또는 Jan: 월 (Month)
• 02 또는 2: 일 (Day)
• 15: 시간 (Hour, 24시간제 기준)
• 04: 분 (Minute)
• 05: 초 (Second)
• MST: 시간대 (Time Zone)
• Mon: 요일 (Weekday, 선택 사항)

예를 들어, 만약 우리가 "일/월/년 시:분:초" 형식, 그러니까 "25/07/2019 13:45:00" 같은 시간 문자열을 다루고 싶다고 해봅시다.

이때 레이아웃은 기준 시간을 저 모양에 맞춰서 이렇게 만들어주면 됩니다.

layout := "02/01/2006 15:04:05"

여기서 02는 기준 시간의 '2일'을, 01은 '1월'을, 2006은 '2006년'을, 15는 '오후 3시'를, 04는 '4분'을, 05는 '5초'를 각각 의미한답니다.

이렇게 기준 시간을 활용해서 우리가 원하는 시간 문자열의 본을 뜨는 것이죠.

자, 이제 진짜 시간 문자열을 바꿔볼까요? (예제 코드)

위에서 만든 '설계도'(레이아웃)를 가지고 실제 시간 글자를 진짜 시간 정보로 바꿔보는 예제 코드를 한번 살펴볼까요?.

package main

import (
    "fmt"
    "time"
)

func main() {
    // 시간 문자열의 형식을 정의하는 레이아웃 (설계도)
    // "일/월/년 시:분:초" 형식
    layout := "02/01/2006 15:04:05"
    // 분석할 실제 시간 문자열 (재료)
    timeStr := "25/07/2019 13:45:00"

    // time.Parse 함수를 사용해서 문자열을 시간 정보로 변환
    t, err := time.Parse(layout, timeStr)
    // 만약 변환 중 에러가 발생했다면, 에러 메시지를 출력하고 프로그램을 종료
    if err != nil {
        fmt.Println("시간 파싱 중 에러 발생:", err)
        return
    }

    // 성공적으로 변환된 시간 정보를 출력
    fmt.Println("파싱된 시간:", t)
}

이 코드를 실행하면 다음과 같은 결과가 나올 겁니다.

파싱된 시간: 2019-07-25 13:45:00 +0000 UTC

짠! "25/07/2019 13:45:00"이라는 글자가 2019년 7월 25일 오후 1시 45분 0초라는 컴퓨터가 이해하는 시간 정보로 멋지게 변환되었습니다.

뒤에 붙은 +0000 UTC는 협정 세계시(UTC)를 기준으로 시간이 표시되었다는 의미인데요, 시간대 정보가 특별히 지정되지 않으면 보통 이렇게 UTC 기준으로 나온답니다.

오전/오후(AM/PM)가 있는 시간은 어떻게 다룰까요?

시간 문자열의 형식이 항상 위 예제처럼 간단하지만은 않을 텐데요.

예를 들어 "오후 11시 22분"처럼 오전/오후(AM/PM) 표시가 있는 시간을 다뤄야 할 수도 있습니다.

이럴 때도 걱정할 필요 없이 레이아웃만 살짝 바꿔주면 됩니다.

layout := "03:04 PM"
timeStr := "11:22 PM"
t, err := time.Parse(layout, timeStr)

이 레이아웃에서 03은 시간을 (12시간제 기준), 04는 분을, 그리고 PM은 오후를 나타내는 약속된 기호입니다.

오전을 나타내고 싶다면 AM을 쓰면 되겠죠?.

이런 방식을 응용하면 재미있는 계산도 가능한데요.

예를 들어, 특정 시간이 자정(밤 12시)으로부터 몇 초나 지났는지 알고 싶을 때 유용하게 사용할 수 있습니다.

package main

import (
    "fmt"
    "time"
)

func main() {
    // "오전/오후 시:분" 형식의 레이아웃
    layout := "03:04 PM"

    // 기준 시간인 자정(12:00 AM)을 파싱
    ref, _ := time.Parse(layout, "12:00 AM") // 에러 처리는 간단하게 생략

    // 분석할 시간인 오후 11시 22분(11:22 PM)을 파싱
    t, err := time.Parse(layout, "11:22 PM")
    if err != nil {
        fmt.Println("시간 파싱 중 에러 발생:", err)
        return
    }

    // 두 시간의 차이를 초 단위로 계산해서 출력
    // t.Sub(ref)는 t 시간에서 ref 시간을 뺀 기간(Duration)을 반환
    // .Seconds()는 이 기간을 초 단위로 바꿔줌
    fmt.Println("자정으로부터 지난 시간(초):", t.Sub(ref).Seconds())
}

이 코드를 실행하면 결과는 이렇게 나옵니다.

자정으로부터 지난 시간(초): 84120

오후 11시 22분은 자정으로부터 총 84,120초가 지난 시간이라는 것을 알 수 있네요!

time.Parse 사용 시 주의할 점들! (흔한 실수 피하기)

time.Parse 함수는 매우 편리하지만, 몇 가지 주의할 점을 모르면 예상치 못한 오류를 만나 당황할 수 있습니다.

마치 숨겨진 함정 같은 것들인데요, 미리 알아두면 실수를 줄일 수 있겠죠?.

1. 설계도(레이아웃)와 재료(시간 문자열)의 궁합을 확인하세요!
   가장 흔한 실수는 레이아웃 문자열과 실제 분석하려는 시간 문자열의 형식이 일치하지 않는 경우입니다.
   
   예를 들어 레이아웃은 "년-월-일" 순서인데, 실제 시간 문자열은 "월/일/년" 순서라면 컴퓨터는 당연히 혼란스러워하며 오류를 낼 수밖에 없습니다.
   
   항상 레이아웃과 시간 문자열의 형식이 정확히 일치하는지 꼼꼼하게 확인해야 합니다.
   
   
2. 시간대(Time Zone) 정보도 신경 써주세요!
   만약 분석하려는 시간 문자열에 "KST"나 "+0900"처럼 시간대 정보가 포함되어 있다면, 레이아웃에도 이를 반영해주어야 합니다.
   
   기준 시간을 만들 때 MST 또는 -0700(시간대 오프셋) 같은 형태로 시간대 정보를 포함시켜야 정확한 시간으로 변환될 수 있습니다.
   
   그렇지 않으면 의도와 다른 시간으로 해석될 수 있으니 주의해야 합니다.
   
   
3. 숫자 앞의 '0'을 잊지 마세요! (특히 레이아웃 만들 때)
   레이아웃을 정의할 때 사용하는 기준 시간(Mon Jan 2 15:04:05 MST 2006)의 숫자 표현 방식을 잘 살펴봐야 하는데요.
   
   예를 들어, 기준 시간에서 1월은 Jan 또는 01로, 2일은 2 또는 02로, 오후 3시는 15로, 4분은 04로, 5초는 05로 표현됩니다.
   
   우리가 만들려는 레이아웃이 이 기준 시간의 숫자 표현 방식(예: 한 자릿수 월/일/분/초 앞에 0이 붙는지, 아니면 그냥 한 자리 숫자로 표현되는지)을 정확히 따라야 합니다.
   
   그리고 분석하려는 실제 시간 문자열도 이 레이아웃 형식에 맞춰져 있어야 정확한 파싱이 가능합니다.
   
   예를 들어, 시간 문자열이 "7/5/2024" (월/일/년, 월과 일이 한 자릿수) 형태이고, 이를 파싱하기 위한 레이아웃을 기준 시간의 01/02/2006 (두 자릿수 월/두 자릿수 일/네 자릿수 년) 형태로 만들었다면, 파싱이 제대로 안 될 수 있습니다.
   
   이럴 때는 레이아웃을 기준 시간의 1/2/2006 (한 자릿수 월/한 자릿수 일/네 자릿수 년) 형태로 만들거나, 시간 문자열을 "07/05/2024"처럼 두 자릿수로 맞춰주는 것이 좋습니다.
   
   

마무리하며: time.Parse로 시간 마법사가 되어보세요!

지금까지 고(Go) 언어에서 문자열로 된 시간 정보를 진짜 시간 정보로 변환하는 데 사용되는 time.Parse 함수에 대해 자세히 알아봤습니다.

처음에는 기준 시간을 사용하는 독특한 레이아웃 방식이 조금 어색하게 느껴질 수도 있는데요.

하지만 몇 번 사용해보면 그 편리함과 강력함에 깜짝 놀라게 될 겁니다.

다양한 형식의 날짜와 시간 문자열을 정확하게 분석하고 다룰 수 있게 되면, 프로그램에서 시간 관련 기능을 훨씬 더 효과적으로 구현할 수 있게 된답니다.

오늘 배운 내용을 바탕으로 직접 코드를 작성해보면서 time.Parse 함수와 친해져 보는 건 어떨까요?.

---