isValid()

Validates whether a date string conforms to the specified format pattern and represents a valid date.

Syntax

isValid(dateString, formatString[, options])

Parameters

Parameter	Type	Required	Description
`dateString`	`string`	Yes	The date string to validate
`formatString`	`string \| CompiledObject`	Yes	The format pattern or compiled object
`options`	`ParserOptions`	No	Parser options for validation (see `parse()` for details)

Returns

boolean - true if the date string is valid and matches the format, false otherwise

Basic Examples

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

// Valid dates
isValid('2025-08-23', 'YYYY-MM-DD');    // => true
isValid('08/23/2025', 'MM/DD/YYYY');    // => true
isValid('14:30:45', 'HH:mm:ss');        // => true
isValid('2:30 PM', 'h:mm A');           // => true

// Invalid dates
isValid('2025-02-30', 'YYYY-MM-DD');    // => false (Feb 30th doesn't exist)
isValid('2025-13-01', 'YYYY-MM-DD');    // => false (month 13 doesn't exist)
isValid('25:30:00', 'HH:mm:ss');        // => false (hour 25 doesn't exist)
isValid('invalid-date', 'YYYY-MM-DD');  // => false (doesn't match format)

// Format mismatch
isValid('2025-08-23', 'MM/DD/YYYY');    // => false (wrong format)
isValid('08/23/2025', 'YYYY-MM-DD');    // => false (wrong format)

Validation with Options

Locale Validation

import { isValid } from 'date-and-time';
import es from 'date-and-time/locales/es';

// Spanish month names
isValid('23 de agosto de 2025', 'D [de] MMMM [de] YYYY', { locale: es });  // => true
isValid('23 de invalid de 2025', 'D [de] MMMM [de] YYYY', { locale: es }); // => false

Case-Insensitive Validation

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

// Case-sensitive (default)
isValid('AUGUST 23, 2025', 'MMMM D, YYYY');   // => false
isValid('august 23, 2025', 'MMMM D, YYYY');   // => false

// Case-insensitive
isValid('AUGUST 23, 2025', 'MMMM D, YYYY', { ignoreCase: true });   // => true
isValid('august 23, 2025', 'MMMM D, YYYY', { ignoreCase: true });   // => true
isValid('August 23, 2025', 'MMMM D, YYYY');                         // => true (correct case)

defaultDate Validation

Use defaultDate to provide context for validation of partial date strings. The most practical use case is leap year-aware validation of month-day strings.

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

// Leap day validation — result depends on the year
isValid('02-29', 'MM-DD', { defaultDate: { Y: 2024 } }); // => true  (2024 is a leap year)
isValid('02-29', 'MM-DD', { defaultDate: { Y: 2023 } }); // => false (2023 is not a leap year)
isValid('02-29', 'MM-DD');                               // => false (default year 1970 is not a leap year)

// Day range validation — depends on both year and month
isValid('29', 'D', { defaultDate: { Y: 2024, M: 2 } }); // => true  (Feb 2024 has 29 days)
isValid('31', 'D', { defaultDate: { Y: 2024, M: 4 } }); // => false (April has 30 days)

Note: Values provided in defaultDate are also subject to range validation. For example, an out-of-range H value in defaultDate will cause isValid() to return false.

Advanced Validation Patterns

Multiple Format Validation

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

function isValidDate(dateString: string): boolean {
  const formats = [
    'YYYY-MM-DD',
    'MM/DD/YYYY',
    'DD.MM.YYYY',
    'MMMM D, YYYY',
    'MMM D, YYYY'
  ];

  return formats.some(format => isValid(dateString, format));
}

// Usage
console.log(isValidDate('2025-08-23'));      // => true
console.log(isValidDate('08/23/2025'));      // => true
console.log(isValidDate('23.08.2025'));      // => true
console.log(isValidDate('August 23, 2025')); // => true
console.log(isValidDate('invalid-date'));    // => false

Business Rule Validation

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

function isBusinessDay(dateString: string, format: string): boolean {
  // First check if it's a valid date
  if (!isValid(dateString, format)) {
    return false;
  }

  // Parse and check if it's a weekday
  const date = parse(dateString, format);
  const dayOfWeek = date.getDay();

  // 0 = Sunday, 6 = Saturday
  return dayOfWeek >= 1 && dayOfWeek <= 5;
}

// Usage
console.log(isBusinessDay('2025-08-23', 'YYYY-MM-DD'));  // => false (Saturday)
console.log(isBusinessDay('2025-08-25', 'YYYY-MM-DD'));  // => true (Monday)

Range Validation

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

function isValidInRange(
  dateString: string,
  format: string,
  minDate: Date,
  maxDate: Date
): boolean {
  if (!isValid(dateString, format)) {
    return false;
  }

  const date = parse(dateString, format);
  return date >= minDate && date <= maxDate;
}

// Usage
const min = new Date(2025, 0, 1);  // Jan 1, 2025
const max = new Date(2025, 11, 31); // Dec 31, 2025

console.log(isValidInRange('2025-08-23', 'YYYY-MM-DD', min, max));  // => true
console.log(isValidInRange('2024-08-23', 'YYYY-MM-DD', min, max));  // => false

Performance with Compiled Patterns

For repeated validation, use compile() for better performance:

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

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

// Validate multiple times (faster)
const dateStrings = [
  '2025-08-23 14:30:45',
  '2025-08-24 09:15:30',
  '2025-02-30 12:00:00',  // Invalid
  '2025-08-25 16:45:20'
];

const validDates = dateStrings.filter(dateString =>
  isValid(dateString, pattern)
);

console.log('Valid dates:', validDates);
// => ['2025-08-23 14:30:45', '2025-08-24 09:15:30', '2025-08-25 16:45:20']

Common Use Cases

Form Input Validation

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

class DateInputValidator {
  static validateBirthDate(dateString: string): boolean {
    if (!isValid(dateString, 'YYYY-MM-DD')) {
      return false;
    }

    const date = parse(dateString, 'YYYY-MM-DD');
    const now = new Date();

    // Must be in the past and reasonable range
    return date < now && date > new Date(1900, 0, 1);
  }

  static validateAppointment(dateString: string): boolean {
    if (!isValid(dateString, 'YYYY-MM-DD HH:mm')) {
      return false;
    }

    const date = parse(dateString, 'YYYY-MM-DD HH:mm');
    const now = new Date();

    // Must be in the future
    return date > now;
  }
}

API Input Validation

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

function validateApiDateRange(startDate: string, endDate: string) {
  const format = 'YYYY-MM-DD';

  // Check both dates are valid
  if (!isValid(startDate, format) || !isValid(endDate, format)) {
    throw new Error('Invalid date format. Expected YYYY-MM-DD');
  }

  const start = parse(startDate, format);
  const end = parse(endDate, format);

  // Check logical order
  if (start >= end) {
    throw new Error('Start date must be before end date');
  }

  return { start, end };
}