Multi-language Code Vault: Integrating `timestamp-converter`

While `timestamp-converter` itself is a tool, its underlying logic for parsing and formatting timestamps is implemented in various programming languages. This vault provides snippets showing how to achieve similar functionality in popular languages, demonstrating the core concepts of format specification.

Python

Python's `datetime` module is a powerful tool for timestamp manipulation.

from datetime import datetime

            # Input timestamp string and its format
            input_timestamp_str = "26/10/2023 14:30:00"
            input_format = "%d/%m/%Y %H:%M:%S"

            # Parse the input string into a datetime object
            try:
                dt_object = datetime.strptime(input_timestamp_str, input_format)
                print(f"Parsed datetime object: {dt_object}")

                # Output formats
                # ISO 8601 format
                output_format_iso = "%Y-%m-%dT%H:%M:%SZ" # Assuming UTC for simplicity here, adjust if timezone is known
                iso_timestamp = dt_object.strftime(output_format_iso)
                print(f"ISO 8601 format: {iso_timestamp}")

                # Human-readable format
                output_format_human = "%A, %B %d, %Y at %I:%M %p"
                human_timestamp = dt_object.strftime(output_format_human)
                print(f"Human-readable format: {human_timestamp}")

                # Unix epoch seconds
                epoch_seconds = int(dt_object.timestamp())
                print(f"Unix epoch seconds: {epoch_seconds}")

            except ValueError as e:
                print(f"Error parsing timestamp: {e}")

JavaScript (Node.js/Browser)

JavaScript's `Date` object and libraries like `moment.js` or `date-fns` are commonly used.

// Using native JavaScript Date (requires a bit more manual parsing for complex formats)
            // For robust parsing, libraries like 'date-fns' or 'moment.js' are recommended.

            // Example with a common format that Date can parse directly
            const inputTimestampStr = "2023-10-26T14:30:00Z"; // ISO 8601
            const dateObject = new Date(inputTimestampStr);
            console.log(`Parsed Date object: ${dateObject}`);

            // Formatting to ISO 8601 (already is, but for demonstration)
            const isoOutput = dateObject.toISOString();
            console.log(`ISO 8601 format: ${isoOutput}`);

            // Formatting to a custom string (requires manual construction or libraries)
            // Example using a simple custom format: "October 26, 2023 - 02:30 PM"
            const monthNames = ["January", "February", "March", "April", "May", "June",
                                "July", "August", "September", "October", "November", "December"];
            const dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];

            const day = dateObject.getDate();
            const monthIndex = dateObject.getMonth();
            const year = dateObject.getFullYear();
            const hours = dateObject.getHours();
            const minutes = dateObject.getMinutes();
            const ampm = hours >= 12 ? 'PM' : 'AM';
            const formattedHours = hours % 12 || 12; // Convert to 12-hour format
            const formattedMinutes = minutes < 10 ? '0' + minutes : minutes;

            const customFormatted = `${monthNames[monthIndex]} ${day}, ${year} - ${formattedHours}:${formattedMinutes} ${ampm}`;
            console.log(`Custom format: ${customFormatted}`);

            // Unix epoch seconds
            const epochSeconds = Math.floor(dateObject.getTime() / 1000);
            console.log(`Unix epoch seconds: ${epochSeconds}`);

            // --- Example with date-fns for more complex parsing/formatting ---
            // npm install date-fns
            import { parse, format, utcToZonedTime } from 'date-fns';

            const inputStrCustom = "26/10/2023 14:30:00";
            const inputFormatCustom = 'dd/MM/yyyy HH:mm:ss';
            const parsedDateCustom = parse(inputStrCustom, inputFormatCustom, new Date());

            console.log(`date-fns parsed: ${parsedDateCustom}`);

            // Format to ISO 8601 with Z (UTC)
            const formattedIsoZ = format(parsedDateCustom, "yyyy-MM-dd'T'HH:mm:ss'Z'");
            console.log(`date-fns ISO 8601 (UTC): ${formattedIsoZ}`);

            // Format to RFC 3339 with offset (example for UTC-5)
            const utcMinus5Time = utcToZonedTime(parsedDateCustom, '-05:00');
            const formattedRfc3339 = format(utcMinus5Time, "yyyy-MM-dd'T'HH:mm:ssXXX");
            console.log(`date-fns RFC 3339 (UTC-5): ${formattedRfc3339}`);
            

Java

Java's `java.time` package (introduced in Java 8) is the modern and recommended way to handle dates and times.

import java.time.LocalDateTime;
            import java.time.ZonedDateTime;
            import java.time.OffsetDateTime;
            import java.time.ZoneId;
            import java.time.format.DateTimeFormatter;
            import java.time.temporal.ChronoUnit;

            public class TimestampConverterExample {
                public static void main(String[] args) {
                    // Input timestamp string and its format
                    String inputTimestampStr = "26/10/2023 14:30:00";
                    DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");

                    try {
                        // Parse the input string into a LocalDateTime object
                        LocalDateTime localDateTime = LocalDateTime.parse(inputTimestampStr, inputFormatter);
                        System.out.println("Parsed LocalDateTime: " + localDateTime);

                        // Output formats

                        // ISO 8601 format (assuming UTC for simplicity, needs ZoneId to be explicit)
                        // To represent as UTC, we need to associate a timezone
                        ZonedDateTime utcDateTime = localDateTime.atZone(ZoneId.of("UTC"));
                        DateTimeFormatter isoFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'");
                        String isoTimestamp = utcDateTime.format(isoFormatter);
                        System.out.println("ISO 8601 format (UTC): " + isoTimestamp);

                        // Human-readable format
                        DateTimeFormatter humanFormatter = DateTimeFormatter.ofPattern("EEEE, MMMM dd, yyyy 'at' hh:mm a");
                        String humanTimestamp = localDateTime.format(humanFormatter);
                        System.out.println("Human-readable format: " + humanTimestamp);

                        // Unix epoch seconds
                        long epochSeconds = utcDateTime.toEpochSecond();
                        System.out.println("Unix epoch seconds: " + epochSeconds);

                        // RFC 3339 with offset (example for UTC-5)
                        ZoneId offsetZone = ZoneId.of("UTC-5"); // Or a specific timezone like "America/New_York"
                        ZonedDateTime offsetDateTime = localDateTime.atZone(offsetZone);
                        DateTimeFormatter rfc3339Formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssXXX");
                        String rfc3339Timestamp = offsetDateTime.format(rfc3339Formatter);
                        System.out.println("RFC 3339 format (UTC-5): " + rfc3339Timestamp);

                    } catch (Exception e) {
                        System.err.println("Error parsing timestamp: " + e.getMessage());
                    }
                }
            }

SQL (Example for PostgreSQL)

SQL databases have built-in functions for timestamp manipulation.

-- Example using PostgreSQL
            -- Input timestamp string and its format (using TO_TIMESTAMP)
            SELECT TO_TIMESTAMP('26/10/2023 14:30:00', 'DD/MM/YYYY HH24:MI:SS') AS parsed_timestamp;

            -- Output formats
            -- ISO 8601 format (TIMESTAMP WITH TIME ZONE)
            SELECT TO_CHAR(TO_TIMESTAMP('26/10/2023 14:30:00', 'DD/MM/YYYY HH24:MI:SS') AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS"Z"') AS iso_8601_utc;

            -- Human-readable format
            SELECT TO_CHAR(TO_TIMESTAMP('26/10/2023 14:30:00', 'DD/MM/YYYY HH24:MI:SS'), 'FMDay, Month DD, YYYY "at" HH:MI AM') AS human_readable;

            -- Unix epoch seconds
            SELECT EXTRACT(EPOCH FROM TO_TIMESTAMP('26/10/2023 14:30:00', 'DD/MM/YYYY HH24:MI:SS')) AS epoch_seconds;

            -- RFC 3339 with offset (example for UTC-5)
            SELECT TO_CHAR(TO_TIMESTAMP('26/10/2023 14:30:00', 'DD/MM/YYYY HH24:MI:SS') AT TIME ZONE 'UTC-5', 'YYYY-MM-DD"T"HH24:MI:SSXXX') AS rfc3339_utc_minus_5;

            -- Convert an existing timestamp column to ISO 8601
            -- Assuming you have a table 'events' with a column 'event_time' of type TIMESTAMP
            -- SELECT TO_CHAR(event_time AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS"Z"') AS event_time_iso_utc
            -- FROM events;

These examples illustrate the fundamental principle: you specify an input format to parse a string into a temporal object, and then you specify an output format to render that object as a string in your desired structure. The `timestamp-converter` tool abstracts these operations into a convenient command-line interface.