compile()

Precompiles a format string into a reusable compiled object for improved performance when the same format pattern is used repeatedly.

Syntax

compile(formatString)

Parameters

Parameter	Type	Required	Description
`formatString`	`string`	Yes	The format pattern to compile

Returns

CompiledObject - A compiled format object that can be reused with format() and parse()

Basic Usage

import { compile, format, parse } from 'date-and-time';

// Compile once
const pattern = compile('YYYY-MM-DD HH:mm:ss');

// Use multiple times - much faster than parsing the format string each time
const date1 = new Date(2025, 7, 23, 14, 30, 45);
const date2 = new Date(2025, 7, 24, 9, 15, 30);

const formatted1 = format(date1, pattern);  // => 2025-08-23 14:30:45
const formatted2 = format(date2, pattern);  // => 2025-08-24 09:15:30

// Also works with parse()
const parsed = parse('2025-08-25 16:20:10', pattern);

Performance Benefits

The compile() function provides significant performance improvements for repeated operations:

Without Compilation (Slower)

import { format } from 'date-and-time';

const dates = Array.from({ length: 1000 }, () => new Date());

// Format string is parsed 1000 times
dates.forEach(date => {
  format(date, 'YYYY-MM-DD HH:mm:ss.SSS [GMT]ZZ');
});

With Compilation (Faster)

import { format, compile } from 'date-and-time';

const dates = Array.from({ length: 1000 }, () => new Date());
const pattern = compile('YYYY-MM-DD HH:mm:ss.SSS [GMT]ZZ');

// Format string is compiled once, reused 1000 times
dates.forEach(date => {
  format(date, pattern);  // Much faster!
});

Real-world Examples

Logging System

import { compile, format } from 'date-and-time';

class Logger {
  private timestampPattern = compile('\\[YYYY-MM-DD HH:mm:ss.SSS\\]');

  log(level: string, message: string) {
    const timestamp = format(new Date(), this.timestampPattern);
    console.log(`${timestamp} ${level.toUpperCase()}: ${message}`);
  }
}

const logger = new Logger();
logger.log('info', 'Application started');
logger.log('error', 'Database connection failed');
// [2025-08-23 14:30:45.123] INFO: Application started
// [2025-08-23 14:30:45.124] ERROR: Database connection failed

Template Engine Integration

import { compile, format } from 'date-and-time';

class EmailTemplateEngine {
  private patterns = {
    timestamp: compile('YYYY-MM-DD HH:mm:ss'),
    friendly: compile('MMMM D, YYYY [at] h:mm A'),
    fileDate: compile('YYYY-MM-DD')
  };

  generateEmail(user: string, data: any): string {
    const now = new Date();

    return `
      Dear ${user},

      This report was generated on ${format(now, this.patterns.friendly)}.

      System timestamp: ${format(now, this.patterns.timestamp)}
      Report date: ${format(data.reportDate, this.patterns.fileDate)}

      Best regards,
      System
    `.trim();
  }
}

const engine = new EmailTemplateEngine();
const email = engine.generateEmail('John', {
  reportDate: new Date(2025, 7, 23)
});

API Response Formatting

import { compile, format } from 'date-and-time';

class ApiService {
  private isoPattern = compile('YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
  private friendlyPattern = compile('MMMM D, YYYY [at] h:mm A');

  formatResponse(data: any[]) {
    return data.map(item => ({
      ...item,
      createdAt: format(item.createdAt, this.isoPattern, { timeZone: 'UTC' }),
      createdAtFriendly: format(item.createdAt, this.friendlyPattern)
    }));
  }
}

Batch File Operations

import { compile, format } from 'date-and-time';
import { writeFileSync } from 'fs';

const filenamePattern = compile('YYYY-MM-DD_HH-mm-ss');

function generateReports(data: any[]) {
  const timestamp = format(new Date(), filenamePattern);

  data.forEach((report, index) => {
    const filename = `report_${index}_${timestamp}.json`;
    writeFileSync(filename, JSON.stringify(report));
  });
}

Advanced Usage

Multiple Compiled Patterns

import { compile, format } from 'date-and-time';
import en from 'date-and-time/locales/en';
import ja from 'date-and-time/locales/ja';

class MultiFormatHandler {
  private patterns = {
    iso: compile('YYYY-MM-DD[T]HH:mm:ss[Z]'),
    friendly: compile('MMMM D, YYYY [at] h:mm A'),
    japanese: compile('YYYY年M月D日(ddd) HH:mm'),
    filename: compile('YYYYMMDD_HHmmss')
  };

  format(date: Date, type: keyof typeof this.patterns) {
    const pattern = this.patterns[type];

    switch (type) {
      case 'iso':
        return format(date, pattern, { timeZone: 'UTC' });
      case 'japanese':
        return format(date, pattern, { locale: ja });
      default:
        return format(date, pattern);
    }
  }
}

const handler = new MultiFormatHandler();
const date = new Date();

console.log(handler.format(date, 'iso'));       // => 2025-08-23T14:30:45Z
console.log(handler.format(date, 'friendly'));  // => August 23, 2025 at 2:30 PM
console.log(handler.format(date, 'japanese'));  // => 2025年8月23日(土) 14:30
console.log(handler.format(date, 'filename'));  // => 20250823_143045

Conditional Compilation

import { compile, format } from 'date-and-time';

class SmartFormatter {
  private cache = new Map<string, any>();

  private getCompiledPattern(formatString: string) {
    if (!this.cache.has(formatString)) {
      this.cache.set(formatString, compile(formatString));
    }
    return this.cache.get(formatString);
  }

  format(date: Date, formatString: string, options?: any) {
    const pattern = this.getCompiledPattern(formatString);
    return format(date, pattern, options);
  }
}

const formatter = new SmartFormatter();

// First call compiles the pattern
formatter.format(new Date(), 'YYYY-MM-DD');

// Subsequent calls reuse the compiled pattern
formatter.format(new Date(), 'YYYY-MM-DD');  // Faster!

Best Practices

1. Compile Once, Use Many Times

// ✅ Good - compile once
const pattern = compile('YYYY-MM-DD HH:mm:ss');
for (const date of dates) {
  format(date, pattern);
}

// ❌ Bad - compiles every time
for (const date of dates) {
  format(date, 'YYYY-MM-DD HH:mm:ss');
}

2. Cache Compiled Patterns

// ✅ Good - cached patterns
class DateFormatter {
  private static patterns = {
    iso: compile('YYYY-MM-DD[T]HH:mm:ss[Z]'),
    short: compile('MM/DD/YYYY'),
    long: compile('MMMM D, YYYY')
  };

  static format(date: Date, type: keyof typeof DateFormatter.patterns) {
    return format(date, DateFormatter.patterns[type]);
  }
}

3. Lazy Compilation

// ✅ Good - lazy compilation for dynamic patterns
class DynamicFormatter {
  private cache = new Map<string, CompiledObject>();

  format(date: Date, pattern: string) {
    if (!this.cache.has(pattern)) {
      this.cache.set(pattern, compile(pattern));
    }
    return format(date, this.cache.get(pattern)!);
  }
}