MakeTimestamp logo
MakeTimestamp

타임스탬프 자료

타임스탬프 형식 치트시트: 빠른 참조 가이드

개요

이 포괄적인 치트시트는 프로그래밍 및 데이터 교환에 사용되는 모든 일반적인 타임스탬프 형식에 대한 빠른 참조를 제공합니다. 모든 예시에서는 2024년 1월 1일, 12:00:00 UTC를 참조 시간으로 사용합니다.

빠른 참조 테이블

형식예길이사용 사례
유닉스 초170411040010자리레거시 시스템, API
유닉스 밀리초170411040000013자리JavaScript, Java, 최신 API
유닉스 마이크로초170411040000000016자리고정밀 로깅
유닉스 나노초170411040000000000019자리성능 모니터링
ISO 8601(UTC)2024-01-01T12:00:00Z변수국제표준
ISO 8601(시간대)2024-01-01T12:00:00+00:00변수시간대 인식 데이터
RFC 33392024-01-01T12:00:00.000Z변수인터넷 타임스탬프
RFC 28222024년 1월 1일 월요일 12:00:00 +0000변수이메일 헤더
SQL 날짜시간2024-01-01 12:00:0019자데이터베이스 스토리지

유닉스 타임스탬프 형식

초(10자리)

형식: 1970년 1월 1일, 00:00:00 UTC 이후의 초를 나타내는 정수

1704110400

사용 시기:

  • 레거시 시스템 및 API
  • 저장 효율성(int32로 4바이트)
  • 2038년 문제 고려사항

코드 예:

// JavaScript
const timestamp = Math.floor(Date.now() / 1000);
// 1704110400

const date = new Date(timestamp * 1000);
// 2024-01-01T12:00:00.000Z

# Python
import time
timestamp = int(time.time())
# 1704110400

from datetime import datetime
date = datetime.fromtimestamp(timestamp)
# 2024-01-01 12:00:00

// PHP
$timestamp = time();
// 1704110400

$date = date('Y-m-d H:i:s', $timestamp);
// 2024-01-01 12:00:00

// Go
import "time"

timestamp := time.Now().Unix()
// 1704110400

date := time.Unix(timestamp, 0)
// 2024-01-01 12:00:00 +0000 UTC

밀리초(13자리)

형식: Unix 시대 이후의 밀리초를 나타내는 정수

1704110400000

사용 시기:

  • JavaScript 애플리케이션(Date.now()의 기본값)
  • 최신 웹 API
  • 밀리초 단위의 정밀도가 필요함

코드 예:

// JavaScript
const timestamp = Date.now();
// 1704110400000

const date = new Date(timestamp);
// 2024-01-01T12:00:00.000Z

# Python
import time
timestamp = int(time.time() * 1000)
# 1704110400000

from datetime import datetime
date = datetime.fromtimestamp(timestamp / 1000)

// Java
long timestamp = System.currentTimeMillis();
// 1704110400000

Date date = new Date(timestamp);
// Mon Jan 01 12:00:00 UTC 2024

// C#
long timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
// 1704110400000

DateTimeOffset date = DateTimeOffset.FromUnixTimeMilliseconds(timestamp);

마이크로초(16자리)

형식: Unix 시대 이후의 마이크로초를 나타내는 정수

1704110400000000

사용 시기:

  • 고정밀 로깅 및 모니터링
  • 성능 벤치마킹
  • 과학적 응용

코드 예:

# Python
import time
timestamp = int(time.time() * 1_000_000)
# 1704110400000000

date = datetime.fromtimestamp(timestamp / 1_000_000)

// Go
timestamp := time.Now().UnixMicro()
// 1704110400000000

date := time.UnixMicro(timestamp)

// Rust
use std::time::{SystemTime, UNIX_EPOCH};

let timestamp = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .unwrap()
    .as_micros();
// 1704110400000000

나노초(19자리)

형식: Unix 시대 이후 나노초를 나타내는 정수

1704110400000000000

사용 시기:

  • 초정밀 타이밍 요구 사항
  • 성능 프로파일링
  • 거래 시스템

코드 예:

// Go
timestamp := time.Now().UnixNano()
// 1704110400000000000

date := time.Unix(0, timestamp)

// Rust
let timestamp = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .unwrap()
    .as_nanos();
// 1704110400000000000

ISO 8601 형식

기본 형식(UTC)

형식: `YYYY-MM-DDTHH:MM:SSZ

2024-01-01T12:00:00Z
```
**사용 시기:**
- 국제 데이터 교환
- RESTful API
- JSON 데이터 저장

**코드 예:**
```javascript
// JavaScript
const isoString = new Date().toISOString();
// 2024-01-01T12:00:00.000Z
```

```python
# Python
from datetime import datetime, timezone
iso_string = datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')
# 2024-01-01T12:00:00Z
```

```php
// PHP
$iso_string = gmdate('Y-m-d\TH:i:s\Z');
// 2024-01-01T12:00:00Z
```
### 확장 형식(밀리초 단위)

**형식**: `YYYY-MM-DDTHH:MM:SS.sssZ

2024-01-01T12:00:00.000Z


```javascript
// JavaScript (default)
new Date().toISOString();
// 2024-01-01T12:00:00.000Z

# Python
datetime.now(timezone.utc).isoformat(timespec='milliseconds').replace('+00:00', 'Z')
# 2024-01-01T12:00:00.000Z

시간대 오프셋 포함

형식: `YYYY-MM-DDTHH:MM:SS±HH:MM

2024-01-01T12:00:00+00:00
2024-01-01T17:30:00+05:30  # IST
2024-01-01T07:00:00-05:00  # EST
```
**코드 예:**
```javascript
// JavaScript
const date = new Date();
const offset = -date.getTimezoneOffset();
const sign = offset >= 0 ? '+' : '-';
const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, '0');
const minutes = String(Math.abs(offset) % 60).padStart(2, '0');
const iso = date.toISOString().replace('Z', `${sign}${hours}:${minutes}`);
// 2024-01-01T12:00:00.000+00:00
```

```python
# Python
datetime.now(timezone.utc).isoformat()
# 2024-01-01T12:00:00+00:00

# With specific timezone
from datetime import timezone, timedelta
ist = timezone(timedelta(hours=5, minutes=30))
datetime.now(ist).isoformat()
# 2024-01-01T17:30:00+05:30
```
### 날짜만

**형식**: `YYYY-MM-DD

2024-01-01


```javascript
// JavaScript
new Date().toISOString().split('T')[0];
// 2024-01-01

# Python
datetime.now().date().isoformat()
# 2024-01-01

시간만

형식: HH:MM:SS 또는 `HH:MM:SS.sss

12:00:00
12:00:00.000
```

```javascript
// JavaScript
new Date().toISOString().split('T')[1];
// 12:00:00.000Z
```

```python
# Python
datetime.now().time().isoformat()
# 12:00:00.000000
```
---

## RFC 3339 형식

**형식**: `YYYY-MM-DDTHH:MM:SS.sss±HH:MM` 또는 `...Z

2024-01-01T12:00:00.000Z 2024-01-01T12:00:00.000+00:00

**ISO 8601과의 차이점:**
- 항상 밀리초를 포함합니다.
- 항상 시간대를 포함합니다.
- 더욱 엄격해진 사양

**코드 예:**
```javascript
// JavaScript
new Date().toISOString(); // Already RFC 3339 compliant
// 2024-01-01T12:00:00.000Z

# Python
from datetime import datetime, timezone
datetime.now(timezone.utc).isoformat()
# 2024-01-01T12:00:00.000000+00:00

// Go
time.Now().UTC().Format(time.RFC3339Nano)
// 2024-01-01T12:00:00.000000000Z

RFC 2822 형식

형식: `일, DD 월 YYYY HH:MM:SS ±HHMM

Mon, 01 Jan 2024 12:00:00 +0000
Mon, 01 Jan 2024 12:00:00 GMT
```
**사용 시기:**
- 이메일 헤더(날짜 필드)
- HTTP 헤더
- RSS 피드

**코드 예:**
```javascript
// JavaScript
new Date().toUTCString();
// Mon, 01 Jan 2024 12:00:00 GMT
```

```python
# Python
from email.utils import formatdate
formatdate(timeval=None, localtime=False, usegmt=True)
# Mon, 01 Jan 2024 12:00:00 GMT
```

```php
// PHP
date('r');
// Mon, 01 Jan 2024 12:00:00 +0000
```
---

## SQL 타임스탬프 형식

### MySQL/MariaDB 날짜시간

**형식**: `YYYY-MM-DD HH:MM:SS

2024-01-01 12:00:00


```sql
-- MySQL
SELECT NOW();
-- 2024-01-01 12:00:00

SELECT DATE_FORMAT(NOW(), '%Y-%m-%d %H:%i:%s');
-- 2024-01-01 12:00:00

PostgreSQL 타임스탬프

형식: `YYYY-MM-DD HH:MM:SS.ssssss±TZ

2024-01-01 12:00:00.000000+00
2024-01-01 12:00:00+00
```

```sql
-- PostgreSQL
SELECT NOW();
-- 2024-01-01 12:00:00.000000+00

SELECT CURRENT_TIMESTAMP;
-- 2024-01-01 12:00:00.000000+00
```
### SQLite DATETIME

**형식**: `YYYY-MM-DD HH:MM:SS`(텍스트로 저장됨)
```
2024-01-01 12:00:00
```

```sql
-- SQLite
SELECT datetime('now');
-- 2024-01-01 12:00:00

SELECT strftime('%Y-%m-%d %H:%M:%S', 'now');
-- 2024-01-01 12:00:00
```
### 마이크로소프트 SQL 서버

**형식**: `YYYY-MM-DD HH:MM:SS.sss

2024-01-01 12:00:00.000


```sql
-- SQL Server
SELECT GETUTCDATE();
-- 2024-01-01 12:00:00.000

SELECT FORMAT(GETUTCDATE(), 'yyyy-MM-dd HH:mm:ss.fff');
-- 2024-01-01 12:00:00.000

언어별 형식

자바스크립트

// Various formats
const date = new Date();

// ISO 8601
date.toISOString();                    // 2024-01-01T12:00:00.000Z

// Locale string
date.toLocaleString();                  // 1/1/2024, 12:00:00 PM

// UTC string
date.toUTCString();                     // Mon, 01 Jan 2024 12:00:00 GMT

// Date only
date.toLocaleDateString();              // 1/1/2024

// Time only
date.toLocaleTimeString();              // 12:00:00 PM

// Custom format
date.toLocaleString('en-US', {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit',
  hour: '2-digit',
  minute: '2-digit',
  second: '2-digit',
  hour12: false
});
// 01/01/2024, 12:00:00

Python strftime 코드

from datetime import datetime

dt = datetime(2024, 1, 1, 12, 0, 0)

# Common formats
dt.strftime('%Y-%m-%d')                 # 2024-01-01
dt.strftime('%Y-%m-%d %H:%M:%S')       # 2024-01-01 12:00:00
dt.strftime('%Y-%m-%dT%H:%M:%SZ')      # 2024-01-01T12:00:00Z
dt.strftime('%d/%m/%Y')                 # 01/01/2024
dt.strftime('%m/%d/%Y')                 # 01/01/2024
dt.strftime('%B %d, %Y')                # January 01, 2024
dt.strftime('%A, %B %d, %Y')           # Monday, January 01, 2024
dt.strftime('%I:%M %p')                 # 12:00 PM

PHP 날짜() 형식

<?php
$timestamp = 1704110400;

// Common formats
date('Y-m-d', $timestamp);              // 2024-01-01
date('Y-m-d H:i:s', $timestamp);       // 2024-01-01 12:00:00
date('c', $timestamp);                  // 2024-01-01T12:00:00+00:00 (ISO 8601)
date('r', $timestamp);                  // Mon, 01 Jan 2024 12:00:00 +0000 (RFC 2822)
date('U', $timestamp);                  // 1704110400 (Unix timestamp)
date('d/m/Y', $timestamp);              // 01/01/2024
date('m/d/Y', $timestamp);              // 01/01/2024
date('F j, Y', $timestamp);             // January 1, 2024
date('l, F j, Y', $timestamp);         // Monday, January 1, 2024
date('g:i A', $timestamp);              // 12:00 PM

이동 시간 형식

package main

import (
    "time"
)

func main() {
    t := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)

    // Standard formats
    t.Format(time.RFC3339)              // 2024-01-01T12:00:00Z
    t.Format(time.RFC3339Nano)          // 2024-01-01T12:00:00.000000000Z
    t.Format(time.RFC822)               // 01 Jan 24 12:00 UTC
    t.Format(time.RFC1123)              // Mon, 01 Jan 2024 12:00:00 UTC

    // Custom formats (using reference time: Jan 2 15:04:05 2006 MST)
    t.Format("2006-01-02")              // 2024-01-01
    t.Format("2006-01-02 15:04:05")    // 2024-01-01 12:00:00
    t.Format("01/02/2006")              // 01/01/2024
    t.Format("January 2, 2006")         // January 1, 2024
    t.Format("3:04 PM")                 // 12:00 PM
}

자바 SimpleDateFormat

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;

Date date = new Date(1704110400000L);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
sdf.setTimeZone(TimeZone.getTimeZone("UTC"));

// Common patterns
"yyyy-MM-dd"                            // 2024-01-01
"yyyy-MM-dd HH:mm:ss"                  // 2024-01-01 12:00:00
"yyyy-MM-dd'T'HH:mm:ss'Z'"            // 2024-01-01T12:00:00Z
"dd/MM/yyyy"                            // 01/01/2024
"MM/dd/yyyy"                            // 01/01/2024
"MMMM d, yyyy"                          // January 1, 2024
"EEEE, MMMM d, yyyy"                   // Monday, January 1, 2024
"h:mm a"                                // 12:00 PM

형식 변환 빠른 참조

유닉스 → ISO 8601

// JavaScript
new Date(1704110400000).toISOString();
// 2024-01-01T12:00:00.000Z

# Python
from datetime import datetime, timezone
datetime.fromtimestamp(1704110400, timezone.utc).isoformat()
# 2024-01-01T12:00:00+00:00

ISO 8601 → 유닉스

// JavaScript
new Date('2024-01-01T12:00:00Z').getTime();
// 1704110400000

# Python
from datetime import datetime
datetime.fromisoformat('2024-01-01T12:00:00+00:00').timestamp()
# 1704110400.0

RFC 2822 → ISO 8601

// JavaScript
new Date('Mon, 01 Jan 2024 12:00:00 GMT').toISOString();
// 2024-01-01T12:00:00.000Z

# Python
from email.utils import parsedate_to_datetime
parsedate_to_datetime('Mon, 01 Jan 2024 12:00:00 GMT').isoformat()
# 2024-01-01T12:00:00+00:00

모범 사례

저장소 권장 사항

  1. 데이터베이스: 시간대를 지원하는 기본 TIMESTAMP 유형 사용
  2. API: 이식성을 위해 시간대와 함께 ISO 8601을 사용합니다.
  3. 내부 처리: 계산에 Unix 밀리초를 사용합니다.
  4. 로깅: 밀리초 및 시간대와 함께 ISO 8601을 사용합니다.

시간대 처리

  • 항상 시간대 포함 - 모호한 타임스탬프 방지
  • UTC로 저장 - 표시를 위해 현지 시간으로만 변환
  • UTC에는 Z 사용 - +00:00보다 명확함
  • 시간대 오프셋 유효성 검사 - -12:00에서 +14:00 사이인지 확인하세요.

정밀 선택

정밀사용 사례예
초사용자 이벤트, 스케줄링1704110400
밀리초웹 앱, 일반 로깅1704110400000
마이크로초성능 모니터링1704110400000000
나노초고주파 거래1704110400000000000

일반적인 함정

❌ 피해야 할 사항:

  • 시간대 정보 없이 타임스탬프 저장
  • 저장 시 현지 시간 사용(항상 UTC 사용)
  • 다양한 정밀도 수준 혼합
  • 하드코딩 시간대 오프셋
  • 32비트 정수 사용 (2038년 문제)

✅ 해야 할 일:

  • 항상 시간대 지정자를 포함합니다(Z 또는 ±HH:MM).
  • UTC로 저장하고 표시 전용으로 현지 시간으로 변환
  • 시스템 전반에 걸쳐 일관된 정밀도를 사용하십시오.
  • 시간대 인식 날짜/시간 객체 사용
  • Unix 타임스탬프에 64비트 정수 사용

관련 도구

관련 가이드