Random Date Code Examples

<?php
// Generate random date between two dates
function randomDate($startDate, $endDate) {
    $startTimestamp = strtotime($startDate);
    $endTimestamp = strtotime("$endDate 23:59:59"); // include the whole end day
    $randomTimestamp = mt_rand($startTimestamp, $endTimestamp);
    return date("Y-m-d", $randomTimestamp);
}

// Generate random DateTime object
function randomDateTime($startDate, $endDate) {
    $startTimestamp = strtotime($startDate);
    $endTimestamp = strtotime($endDate);
    $randomTimestamp = mt_rand($startTimestamp, $endTimestamp);
    return new DateTime("@$randomTimestamp");
}

// Generate random past date (within last N days)
function randomPastDate($daysAgo = 365) {
    $timestamp = time() - mt_rand(0, $daysAgo * 86400);
    return date("Y-m-d", $timestamp);
}

// Generate random future date (within next N days)
function randomFutureDate($daysAhead = 365) {
    $timestamp = time() + mt_rand(0, $daysAhead * 86400);
    return date("Y-m-d", $timestamp);
}

// Generate random date with specific format
function randomDateFormatted($format = "Y-m-d H:i:s") {
    $start = strtotime("2020-01-01");
    $end = strtotime("2025-12-31");
    $random = mt_rand($start, $end);
    return date($format, $random);
}

// Generate random birthday (18-80 years ago)
function randomBirthday() {
    $minAge = 18;
    $maxAge = 80;
    $minDate = strtotime("-$maxAge years");
    $maxDate = strtotime("-$minAge years");
    $random = mt_rand($minDate, $maxDate);
    return date("Y-m-d", $random);
}

// Generate multiple random dates
function generateRandomDates($count = 10, $startDate = "2020-01-01", $endDate = "2025-12-31") {
    $dates = [];
    for ($i = 0; $i < $count; $i++) {
        $dates[] = randomDate($startDate, $endDate);
    }
    return $dates;
}

// Using Carbon library (install: composer require nesbot/carbon)
// use Carbon\Carbon;
// $randomDate = Carbon::createFromTimestamp(mt_rand(
//     Carbon::parse("2020-01-01")->timestamp,
//     Carbon::parse("2025-12-31")->timestamp
// ));
// $pastDate = Carbon::now()->subDays(mt_rand(1, 365));
// $futureDate = Carbon::now()->addDays(mt_rand(1, 365));

// Usage examples
echo "Random date: " . randomDate("2020-01-01", "2025-12-31") . "\n";
echo "Past date: " . randomPastDate(30) . "\n";
echo "Future date: " . randomFutureDate(90) . "\n";
echo "Random birthday: " . randomBirthday() . "\n";
echo "Formatted: " . randomDateFormatted("d/m/Y") . "\n";
print_r(generateRandomDates(5));

// Generate random date between two dates
function randomDate(startDate, endDate) {
    const start = new Date(startDate).getTime();
    const end = new Date(endDate).getTime() + 86400000 - 1; // include the whole end day
    const randomTimestamp = Math.floor(Math.random() * (end - start + 1)) + start;
    return new Date(randomTimestamp);
}

// Generate random date as ISO string
function randomDateISO(startDate, endDate) {
    return randomDate(startDate, endDate).toISOString().split("T")[0];
}

// Generate random past date (within last N days)
function randomPastDate(daysAgo = 365) {
    const now = new Date();
    const past = new Date(now.getTime() - Math.random() * daysAgo * 86400000);
    return past;
}

// Generate random future date (within next N days)
function randomFutureDate(daysAhead = 365) {
    const now = new Date();
    const future = new Date(now.getTime() + Math.random() * daysAhead * 86400000);
    return future;
}

// Generate random birthday (18-80 years ago)
function randomBirthday() {
    const now = new Date();
    const minAge = 18;
    const maxAge = 80;
    const minDate = new Date(now.getFullYear() - maxAge, now.getMonth(), now.getDate());
    const maxDate = new Date(now.getFullYear() - minAge, now.getMonth(), now.getDate());
    return randomDate(minDate, maxDate);
}

// Format date as YYYY-MM-DD
function formatDate(date) {
    const year = date.getUTCFullYear();
    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
    const day = String(date.getUTCDate()).padStart(2, "0");
    return `${year}-${month}-${day}`;
}

// Generate multiple random dates
function generateRandomDates(count = 10, startDate = "2020-01-01", endDate = "2025-12-31") {
    return Array.from({length: count}, () =>
        formatDate(randomDate(startDate, endDate))
    );
}

// Using moment.js (npm install moment)
// const moment = require("moment");
// const randomMoment = moment(Math.random() * (
//     moment("2025-12-31").valueOf() - moment("2020-01-01").valueOf()
// ) + moment("2020-01-01").valueOf());

// Using date-fns (npm install date-fns)
// const { addDays, subDays } = require("date-fns");
// const pastDate = subDays(new Date(), Math.floor(Math.random() * 365));
// const futureDate = addDays(new Date(), Math.floor(Math.random() * 365));

// Usage examples
console.log("Random date:", formatDate(randomDate("2020-01-01", "2025-12-31")));
console.log("Past date:", formatDate(randomPastDate(30)));
console.log("Future date:", formatDate(randomFutureDate(90)));
console.log("Random birthday:", formatDate(randomBirthday()));
console.log("ISO format:", randomDateISO("2020-01-01", "2025-12-31"));
console.log("Batch:", generateRandomDates(5));

import random
from datetime import datetime, timedelta

# Generate random date between two dates
def random_date(start_date, end_date):
    start = datetime.strptime(start_date, "%Y-%m-%d")
    end = datetime.strptime(end_date, "%Y-%m-%d")
    delta = end - start
    random_days = random.randint(0, delta.days)
    return start + timedelta(days=random_days)

# Generate random past date (within last N days)
def random_past_date(days_ago=365):
    today = datetime.now()
    past = today - timedelta(days=random.randint(0, days_ago))
    return past

# Generate random future date (within next N days)
def random_future_date(days_ahead=365):
    today = datetime.now()
    future = today + timedelta(days=random.randint(0, days_ahead))
    return future

# Generate random birthday (18-80 years ago)
def random_birthday():
    today = datetime.now()
    min_age = 18
    max_age = 80
    years_ago = random.randint(min_age, max_age)
    birth_year = today.year - years_ago
    return random_date(f"{birth_year}-01-01", f"{birth_year}-12-31")

# Generate random datetime with time component
def random_datetime(start_date, end_date):
    date = random_date(start_date, end_date)
    random_hour = random.randint(0, 23)
    random_minute = random.randint(0, 59)
    random_second = random.randint(0, 59)
    return datetime(date.year, date.month, date.day,
                   random_hour, random_minute, random_second)

# Generate multiple random dates
def generate_random_dates(count=10, start_date="2020-01-01", end_date="2025-12-31"):
    return [random_date(start_date, end_date).strftime("%Y-%m-%d")
            for _ in range(count)]

# Using Faker library (install: pip install faker)
# from faker import Faker
# fake = Faker()
# random_date = fake.date_between(start_date="-1y", end_date="today")
# past_date = fake.past_date(start_date="-30d")
# future_date = fake.future_date(end_date="+90d")
# birthday = fake.date_of_birth(minimum_age=18, maximum_age=80)
# datetime_obj = fake.date_time_between(start_date="-1y", end_date="now")

# Usage examples
print("Random date:", random_date("2020-01-01", "2025-12-31").strftime("%Y-%m-%d"))
print("Past date:", random_past_date(30).strftime("%Y-%m-%d"))
print("Future date:", random_future_date(90).strftime("%Y-%m-%d"))
print("Random birthday:", random_birthday().strftime("%Y-%m-%d"))
print("With time:", random_datetime("2024-01-01", "2024-12-31").strftime("%Y-%m-%d %H:%M:%S"))
print("Batch:", generate_random_dates(5))

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

public class RandomDateGenerator {
    private static final Random random = new Random();

    // Generate random date between two dates
    public static LocalDate randomDate(LocalDate startDate, LocalDate endDate) {
        long startEpochDay = startDate.toEpochDay();
        long endEpochDay = endDate.toEpochDay();
        long randomDay = ThreadLocalRandom.current().nextLong(startEpochDay, endEpochDay + 1);
        return LocalDate.ofEpochDay(randomDay);
    }

    // Generate random past date (within last N days)
    public static LocalDate randomPastDate(int daysAgo) {
        LocalDate today = LocalDate.now();
        int randomDays = random.nextInt(daysAgo + 1);
        return today.minusDays(randomDays);
    }

    // Generate random future date (within next N days)
    public static LocalDate randomFutureDate(int daysAhead) {
        LocalDate today = LocalDate.now();
        int randomDays = random.nextInt(daysAhead + 1);
        return today.plusDays(randomDays);
    }

    // Generate random birthday (18-80 years ago)
    public static LocalDate randomBirthday() {
        LocalDate today = LocalDate.now();
        int minAge = 18;
        int maxAge = 80;
        int randomAge = random.nextInt(maxAge - minAge + 1) + minAge;
        LocalDate birthYear = today.minusYears(randomAge);
        LocalDate startOfYear = LocalDate.of(birthYear.getYear(), 1, 1);
        LocalDate endOfYear = LocalDate.of(birthYear.getYear(), 12, 31);
        return randomDate(startOfYear, endOfYear);
    }

    // Generate random LocalDateTime
    public static LocalDateTime randomDateTime(LocalDate startDate, LocalDate endDate) {
        LocalDate date = randomDate(startDate, endDate);
        int hour = random.nextInt(24);
        int minute = random.nextInt(60);
        int second = random.nextInt(60);
        return LocalDateTime.of(date, java.time.LocalTime.of(hour, minute, second));
    }

    // Generate multiple random dates
    public static List<String> generateRandomDates(int count, String startDate, String endDate) {
        LocalDate start = LocalDate.parse(startDate);
        LocalDate end = LocalDate.parse(endDate);
        List<String> dates = new ArrayList<>();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        for (int i = 0; i < count; i++) {
            dates.add(randomDate(start, end).format(formatter));
        }
        return dates;
    }

    // Using JavaFaker library (add dependency: com.github.javafaker:javafaker:1.0.2)
    // import com.github.javafaker.Faker;
    // Faker faker = new Faker();
    // Date randomDate = faker.date().between(startDate, endDate);
    // Date pastDate = faker.date().past(30, TimeUnit.DAYS);
    // Date futureDate = faker.date().future(90, TimeUnit.DAYS);
    // Date birthday = faker.date().birthday(18, 80);

    public static void main(String[] args) {
        LocalDate start = LocalDate.parse("2020-01-01");
        LocalDate end = LocalDate.parse("2025-12-31");

        System.out.println("Random date: " + randomDate(start, end));
        System.out.println("Past date: " + randomPastDate(30));
        System.out.println("Future date: " + randomFutureDate(90));
        System.out.println("Random birthday: " + randomBirthday());
        System.out.println("With time: " + randomDateTime(start, end));
        System.out.println("Batch: " + generateRandomDates(5, "2020-01-01", "2025-12-31"));
    }
}

using System;
using System.Linq;

public class RandomDateGenerator
{
    private static readonly Random random = new Random();

    // Generate random date between two dates
    public static DateTime RandomDate(DateTime startDate, DateTime endDate)
    {
        int range = (endDate - startDate).Days;
        return startDate.AddDays(random.Next(range + 1));
    }

    // Generate random past date (within last N days)
    public static DateTime RandomPastDate(int daysAgo = 365)
    {
        return DateTime.Now.AddDays(-random.Next(daysAgo + 1));
    }

    // Generate random future date (within next N days)
    public static DateTime RandomFutureDate(int daysAhead = 365)
    {
        return DateTime.Now.AddDays(random.Next(daysAhead + 1));
    }

    // Generate random birthday (18-80 years ago)
    public static DateTime RandomBirthday()
    {
        var today = DateTime.Now;
        var minAge = 18;
        var maxAge = 80;
        var randomAge = random.Next(minAge, maxAge + 1);
        var birthYear = today.Year - randomAge;
        var startOfYear = new DateTime(birthYear, 1, 1);
        var endOfYear = new DateTime(birthYear, 12, 31);
        return RandomDate(startOfYear, endOfYear);
    }

    // Generate random DateTime with time component
    public static DateTime RandomDateTime(DateTime startDate, DateTime endDate)
    {
        var date = RandomDate(startDate, endDate);
        var hour = random.Next(24);
        var minute = random.Next(60);
        var second = random.Next(60);
        return new DateTime(date.Year, date.Month, date.Day, hour, minute, second);
    }

    // Generate random DateTimeOffset (timezone-aware)
    public static DateTimeOffset RandomDateTimeOffset(DateTime startDate, DateTime endDate)
    {
        var dateTime = RandomDateTime(startDate, endDate);
        return new DateTimeOffset(dateTime, TimeSpan.Zero);
    }

    // Generate multiple random dates
    public static string[] GenerateRandomDates(int count, string startDate, string endDate)
    {
        var start = DateTime.Parse(startDate);
        var end = DateTime.Parse(endDate);

        return Enumerable.Range(0, count)
            .Select(_ => RandomDate(start, end).ToString("yyyy-MM-dd"))
            .ToArray();
    }

    // Using Bogus library (Install-Package Bogus)
    // using Bogus;
    // var faker = new Faker();
    // DateTime randomDate = faker.Date.Between(startDate, endDate);
    // DateTime pastDate = faker.Date.Past(1); // 1 year ago
    // DateTime futureDate = faker.Date.Future(1); // 1 year ahead
    // DateTime birthday = faker.Date.Past(80, DateTime.Now.AddYears(-18));
    // DateTimeOffset recentDate = faker.Date.RecentOffset(30); // Last 30 days

    public static void Main()
    {
        var start = new DateTime(2020, 1, 1);
        var end = new DateTime(2025, 12, 31);

        Console.WriteLine($"Random date: {RandomDate(start, end):yyyy-MM-dd}");
        Console.WriteLine($"Past date: {RandomPastDate(30):yyyy-MM-dd}");
        Console.WriteLine($"Future date: {RandomFutureDate(90):yyyy-MM-dd}");
        Console.WriteLine($"Random birthday: {RandomBirthday():yyyy-MM-dd}");
        Console.WriteLine($"With time: {RandomDateTime(start, end):yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Batch: {string.Join(", ", GenerateRandomDates(5, "2020-01-01", "2025-12-31"))}");
    }
}

#include <iostream>
#include <random>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <sstream>

class RandomDateGenerator {
private:
    std::mt19937 rng;

public:
    RandomDateGenerator() : rng(std::random_device{}()) {}

    // Convert date string to time_point
    std::chrono::system_clock::time_point parseDate(const std::string& dateStr) {
        std::tm tm = {};
        tm.tm_isdst = -1; // let mktime decide whether DST applies
        std::istringstream ss(dateStr);
        ss >> std::get_time(&tm, "%Y-%m-%d");
        return std::chrono::system_clock::from_time_t(std::mktime(&tm));
    }

    // Generate random date between two dates
    std::chrono::system_clock::time_point randomDate(
        const std::string& startDate,
        const std::string& endDate) {

        auto start = parseDate(startDate);
        auto end = parseDate(endDate) + std::chrono::hours(24) - std::chrono::seconds(1); // whole end day

        auto startTime = std::chrono::system_clock::to_time_t(start);
        auto endTime = std::chrono::system_clock::to_time_t(end);

        std::uniform_int_distribution<std::time_t> dist(startTime, endTime);
        std::time_t randomTime = dist(rng);

        return std::chrono::system_clock::from_time_t(randomTime);
    }

    // Generate random past date (within last N days)
    std::chrono::system_clock::time_point randomPastDate(int daysAgo = 365) {
        auto now = std::chrono::system_clock::now();
        auto maxOffset = std::chrono::hours(24 * daysAgo);

        std::uniform_int_distribution<long long> dist(0, maxOffset.count());
        auto randomOffset = std::chrono::hours(dist(rng));

        return now - randomOffset;
    }

    // Generate random future date (within next N days)
    std::chrono::system_clock::time_point randomFutureDate(int daysAhead = 365) {
        auto now = std::chrono::system_clock::now();
        auto maxOffset = std::chrono::hours(24 * daysAhead);

        std::uniform_int_distribution<long long> dist(0, maxOffset.count());
        auto randomOffset = std::chrono::hours(dist(rng));

        return now + randomOffset;
    }

    // Format time_point as string
    std::string formatDate(const std::chrono::system_clock::time_point& tp) {
        std::time_t time = std::chrono::system_clock::to_time_t(tp);
        std::tm* tm = std::localtime(&time);
        std::ostringstream oss;
        oss << std::put_time(tm, "%Y-%m-%d");
        return oss.str();
    }

    // Format with time component
    std::string formatDateTime(const std::chrono::system_clock::time_point& tp) {
        std::time_t time = std::chrono::system_clock::to_time_t(tp);
        std::tm* tm = std::localtime(&time);
        std::ostringstream oss;
        oss << std::put_time(tm, "%Y-%m-%d %H:%M:%S");
        return oss.str();
    }
};

int main() {
    RandomDateGenerator generator;

    auto randomDate = generator.randomDate("2020-01-01", "2025-12-31");
    auto pastDate = generator.randomPastDate(30);
    auto futureDate = generator.randomFutureDate(90);

    std::cout << "Random date: " << generator.formatDate(randomDate) << std::endl;
    std::cout << "Past date: " << generator.formatDate(pastDate) << std::endl;
    std::cout << "Future date: " << generator.formatDate(futureDate) << std::endl;
    std::cout << "With time: " << generator.formatDateTime(randomDate) << std::endl;

    return 0;
}

require "date"
require "time"

# Generate random date between two dates
def random_date(start_date, end_date)
  start = Date.parse(start_date)
  finish = Date.parse(end_date)
  start + rand(0..(finish - start).to_i)
end

# Generate random past date (within last N days)
def random_past_date(days_ago = 365)
  Date.today - rand(0..days_ago)
end

# Generate random future date (within next N days)
def random_future_date(days_ahead = 365)
  Date.today + rand(0..days_ahead)
end

# Generate random birthday (18-80 years ago)
def random_birthday
  today = Date.today
  min_age = 18
  max_age = 80
  years_ago = rand(min_age..max_age)
  birth_year = today.year - years_ago
  random_date("#{birth_year}-01-01", "#{birth_year}-12-31")
end

# Generate random Time object
def random_time(start_date, end_date)
  start_time = Time.parse(start_date).to_i
  end_time = Time.parse(end_date).to_i
  random_timestamp = rand(start_time..end_time)
  Time.at(random_timestamp)
end

# Generate random DateTime
def random_datetime(start_date, end_date)
  date = random_date(start_date, end_date)
  hour = rand(0..23)
  minute = rand(0..59)
  second = rand(0..59)
  DateTime.new(date.year, date.month, date.day, hour, minute, second)
end

# Generate multiple random dates
def generate_random_dates(count = 10, start_date = "2020-01-01", end_date = "2025-12-31")
  count.times.map { random_date(start_date, end_date).strftime("%Y-%m-%d") }
end

# Using Faker gem (add to Gemfile: gem 'faker')
# require 'faker'
# random_date = Faker::Date.between(from: "2020-01-01", to: "2025-12-31")
# past_date = Faker::Date.backward(days: 30)
# future_date = Faker::Date.forward(days: 90)
# birthday = Faker::Date.birthday(min_age: 18, max_age: 80)
# random_time = Faker::Time.between(from: 1.year.ago, to: Date.today)

# Usage examples
puts "Random date: #{random_date('2020-01-01', '2025-12-31')}"
puts "Past date: #{random_past_date(30)}"
puts "Future date: #{random_future_date(90)}"
puts "Random birthday: #{random_birthday}"
puts "With time: #{random_time('2024-01-01', '2024-12-31').strftime('%Y-%m-%d %H:%M:%S')}"
puts "Batch: #{generate_random_dates(5).join(', ')}"

package main

import (
    "fmt"
    "math/rand"
    "time"
)

// Generate random date between two dates
func randomDate(startDate, endDate string) time.Time {
    layout := "2006-01-02"
    start, _ := time.Parse(layout, startDate)
    end, _ := time.Parse(layout, endDate)

    delta := end.Unix() - start.Unix() + 86399 // through 23:59:59 of the end date
    randomSeconds := rand.Int63n(delta + 1)

    return start.Add(time.Duration(randomSeconds) * time.Second)
}

// Generate random past date (within last N days)
func randomPastDate(daysAgo int) time.Time {
    now := time.Now()
    maxSeconds := int64(daysAgo * 86400)
    randomSeconds := rand.Int63n(maxSeconds + 1)
    return now.Add(-time.Duration(randomSeconds) * time.Second)
}

// Generate random future date (within next N days)
func randomFutureDate(daysAhead int) time.Time {
    now := time.Now()
    maxSeconds := int64(daysAhead * 86400)
    randomSeconds := rand.Int63n(maxSeconds + 1)
    return now.Add(time.Duration(randomSeconds) * time.Second)
}

// Generate random birthday (18-80 years ago)
func randomBirthday() time.Time {
    now := time.Now()
    minAge := 18
    maxAge := 80
    yearsAgo := rand.Intn(maxAge-minAge+1) + minAge
    birthYear := now.Year() - yearsAgo

    startDate := fmt.Sprintf("%d-01-01", birthYear)
    endDate := fmt.Sprintf("%d-12-31", birthYear)

    return randomDate(startDate, endDate)
}

// Generate random time with specific components
func randomDateTime(startDate, endDate string) time.Time {
    date := randomDate(startDate, endDate)
    hour := rand.Intn(24)
    minute := rand.Intn(60)
    second := rand.Intn(60)

    return time.Date(
        date.Year(), date.Month(), date.Day(),
        hour, minute, second, 0, time.UTC,
    )
}

// Generate multiple random dates
func generateRandomDates(count int, startDate, endDate string) []string {
    dates := make([]string, count)
    layout := "2006-01-02"

    for i := 0; i < count; i++ {
        dates[i] = randomDate(startDate, endDate).Format(layout)
    }

    return dates
}

func main() {
    layout := "2006-01-02"
    layoutWithTime := "2006-01-02 15:04:05"

    fmt.Println("Random date:", randomDate("2020-01-01", "2025-12-31").Format(layout))
    fmt.Println("Past date:", randomPastDate(30).Format(layout))
    fmt.Println("Future date:", randomFutureDate(90).Format(layout))
    fmt.Println("Random birthday:", randomBirthday().Format(layout))
    fmt.Println("With time:", randomDateTime("2024-01-01", "2024-12-31").Format(layoutWithTime))
    fmt.Println("Batch:", generateRandomDates(5, "2020-01-01", "2025-12-31"))
}