Converting Linux/Unix Time to Human-Readable Date Format

The Unix time period also referred to simply as the "epoch period", the "POSIX period", or the "Unix period", is a time tracking system that represents the number of seconds that have elapsed since the Unix period of the Unix period started on February 1, 1970, at 00:00. 00:00 UTC is defined.

Unix Time begins at midnight on January 1, 1970, UTC. It counts the total number of seconds that have passed since then. For example, the Unix timestamp of 1716620142 represents the number of seconds that have elapsed since January 1, 1970. The Unix epoch period has been largely calculated for various purposes, including file systems, databases, and network protocols, because it is simple and provides a consistent way of dealing with dates and seasons.

Converting Linux/Unix Time to Human-Readable Date Format

The Unix epoch time does not account for leap seconds. It assumes that each day is exactly 86400 seconds long, simplifying the calculations but introducing some errors over time. It provides consistent measurement time in systems. Using a single integer value to represent time simplifies time calculations and comparisons. Transitions between Unix time and human-readable dates can be performed using Linux Bash Commands and programming languages. For example, the date command can be used on Unix-like systems, and most programming languages provide libraries to handle such conversions.

Using Command in Linux/Unix

In Linux, you can utilize the date command to convert the Linux time to a human-readable format.

Open the terminal and run the below-given command to generate a Unix timestamp:

Command

Output

Now, to convert it into a human-readable format, run the below command:

Command:

Here, input the generated timestamp from the earlier command. Like this,

Output:

In Mac OS

In macOS, the date command syntax is a little different.

Use the below command to generate a timestamp:

Command

Output

To convert into human-readable format, execute the below command

Command

Replace the <timestamp> with the generated timestamp.

Output

Converting Seconds into DateTime Format

First, divide the total number of seconds into larger units, such as days, hours, minutes, and remaining seconds.
Then, map these units to the Gregorian calendar to get the year, month, day, hour, minute, and second.
Calculate Total Days: Convert seconds to days by dividing the total seconds by the number of seconds in a day (86400).
Determine the Year, Month and Day: Starting from 1970, add years until the total number of days exceeds the number of days in each year. Subtract the number of days for each year as you go. Once the year is determined, use the remaining days to find the month and day. Subtract the days of each month until the remaining days fit into the current month.
Calculate the Time of Day: Convert the remaining seconds into hours, minutes, and seconds.

Example

Let's understand by an example. Here, we have taken an example of 1716547702 seconds.

Total Seconds = 1716547702

Total Seconds in a Day: 86400

Convert to Days:

Total Days = 1716547702 / 86400 = 19867

Remaining Seconds: 1716547702 % 86400 = 41102

Hours, Minutes and Seconds

1 Hour = 3600 Seconds

1 Minute = 60 Seconds

Hours: 41200 / 3600 = 11

Remaining Seconds: 41102 % 3600 = 4102

Minutes = 4102 / 60 = 68

Seconds = 4102 % 60 = 2

Determine Year:

Starting from 1970, subtract the number of days in each year until the total days fit into the current year.

Calculation of Leap and Non-Leap years:

1970: Non Leap Year (365 Days)
1971: Non-Leap year (365 Days)
1972: Leap year (366 Days)

This process will continue until the year is determined.

Month and Day:

Identify days in each month and subtract days for each month.

Calculation of Month and Day

January: 31 Days

February: 28 Days

March: 31 Days

This process will continue until the month is determined.

Calculate the time of day:

Convert the remaining seconds into hours, minutes and seconds.

Hours = 11

Minutes = 68

Seconds: 2

Implementation of the Above Approach Using Javascript

We have used the approach in the JavaScript we saw above here. Let's see the program.

Code

 
function convertUnixToReadable(unixTime) {
    // For creating a new Date object using the Unix timestamp
    const date = new Date(unixTime * 1000);
   
    // Extracting the components of the date
    const year = date.getUTCFullYear();
    const month = String(date.getUTCMonth() + 1).padStart(2, '0'); // Months are zero-based
    const day = String(date.getUTCDate()).padStart(2, '0');
    const hours = String(date.getUTCHours()).padStart(2, '0');
    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
    const seconds = String(date.getUTCSeconds()).padStart(2, '0');
   
    // Formatting the date as YYYY-MM-DD HH:MM:SS
    const formattedDate = '${year}-${month}-${day} ${hours}:${minutes}:${seconds}';
   
    return formattedDate;
}

// Example usage
const unixTime = 1716547702;
const humanReadableDate = convertUnixToReadable(unixTime);
console.log('Human-Readable DateTime: ${humanReadableDate}');

Output:

 
Human-Readable DateTime: 2024-05-24 10:48:22

Explanation

The 'convertUnixToReadable' function in the above JS code snippet converts the Unix timestamp to a human-readable date and time format. Next, the code starts by using a 'Date' object to convert the Unix timestamp from seconds to milliseconds. The program then extracts the year, month, day, hours, minutes and seconds from the 'Date' object and inserts leading zeros where needed to ensure that each element is two digits and then these parts are 'YYYY-'. MM-DD HH:MM :. it is formatted as a string in SS format and returned.

Using Python

Here is the complete Python code in which we have implemented the epoch approach.

Code

 
import datetime

timestamp = 1716547702

#Dividing into larger units
total_seconds = timestamp
days = total_seconds // 86400
remaining_seconds = total_seconds % 86400

hours = remaining_seconds // 3600
remaining_seconds %= 3600

minutes = remaining_seconds // 60
seconds = remaining_seconds % 60

#Calculating the year
total_days = days
year = 1970
while True:
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        days_in_year = 366
    else:
        days_in_year = 365
   
    if total_days >= days_in_year:
        total_days -= days_in_year
        year += 1
    else:
        break

#Calculating the month and day
months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    months[1] = 29  # February has 29 days in a leap year

month = 1
for days_in_month in months:
    if total_days >= days_in_month:
        total_days -= days_in_month
        month += 1
    else:
        break

day = total_days + 1

#Calculating the time of day
hour = hours
minute = minutes
second = seconds

print(f"Human Readable DateTime Format: {year}-{month:02}-{day:02} {hour:02}:{minute:02}:{second:02}"

Output:

 
Human-Readable DateTime Format: 2024-05-24 10:48:22

Explanation

In the above Python code, first calculate all the days, hours, minutes, and seconds of a given Unix timestamp and then repeat since 1970 to account for overages. Subtract the days until the remaining days are less than the days of the current year. Subtract the days in each month from the remaining days, and the month and day are calculated by adjusting the excess years of the account. Finally, the calculated year, month, day, hour, minute, and second are formatted into an easy-to-read string and printed as a result.

Using Java

Here is the complete Java code in which we have implemented the epoch approach.

Code

 
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        long timestamp = 1716547702;

        // Converting the timestamp to Local DateTime
        LocalDateTime dateTime = LocalDateTime.ofInstant(Instant.ofEpochSecond(timestamp), ZoneId.systemDefault());

        // Formatting as a human-readable date-time format
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = dateTime.format(formatter);

        System.out.println("Human Readable DateTime: " + formattedDateTime);
    }
}

Output:

 
Human Readable DateTime: 2024-05-24 16:18:22

Explanation

The provided Java code converts Unix timestamps to a human-readable date-time format by defining the first timestamp using 'Instant.ofEpochSecond' with the system's default timestamp as a 'LocalDateTime' object. It then converts this 'LocalDateTime' object to yyyy-MM-dd HH:mm:. It formats human-readable to a string by using 'DateTimeFormatter' with its counterpart ss'. Finally, it prints an array of date-time strings.

Using C++

Here is the complete C++ code in which we have implemented the epoch approach.

Code

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

int main() {
    long timestamp = 1716547702;

    // Converting timestamp to system clock time_point
    std::chrono::system_clock::time_point tp = std::chrono::system_clock::from_time_t(timestamp);

    // Converting to time_t to use with std::localtime
    std::time_t time = std::chrono::system_clock::to_time_t(tp);

    // Formatting the time to a human-readable format
    std::tm* gmtime = std::gmtime(&time);
    std::cout << "Human Readable Date-Time: " << std::put_time(gmtime, "%Y-%m-%d %H:%M:%S") << std::endl;

    // Dividing into larger units
    long totalSeconds = timestamp;
    long days = totalSeconds / 86400;
    long remainingSeconds = totalSeconds % 86400;

    long hours = remainingSeconds / 3600;
    remainingSeconds %= 3600;

    long minutes = remainingSeconds / 60;
    long seconds = remainingSeconds % 60;

    // Calculating the remainder when days are divided by 24
    long remainderHours = days % 24;

    // Calculate the remainder when hours are divided by 60
    long remainderMinutes = hours % 60;

    return 0;
}

Output:

 
Human Readable Date-Time: 2024-05-24 10:48:22

Explanation

In the above code, define the first timestamp and change it to 'std::chrono::system_clock::time_point'. Then, this time point is 'std::time_t' to use with 'std::gmtime'. They are converted and formatted to a string readable by 'std::put_time' to specify the date and time in UTC.

Using C

Here is the complete C code in which we have implemented the epoch approach.

Code

 
#include <stdio.h>
#include <time.h>

int main() {
    long timestamp = 1716547702;

    // Converting the timestamp to a struct tm representing UTC time
    struct tm *timeinfo = gmtime(�tamp);

    // Formatting the time into a human-readable format
    char formattedTime[20]; // Enough space to hold "YYYY-MM-DD HH:MM:SS" and null terminator
    strftime(formattedTime, sizeof(formattedTime), "%Y-%m-%d %H:%M:%S", timeinfo);

    // Dividing into larger units
    long totalSeconds = timestamp;
    long days = totalSeconds / 86400;
    long remainingSeconds = totalSeconds % 86400;

    long hours = remainingSeconds / 3600;
    remainingSeconds %= 3600;

    long minutes = remainingSeconds / 60;
    long seconds = remainingSeconds % 60;

    // Calculating the remainder when days are divided by 24
    long remainderHours = days % 24;

    // Calculating the remainder when hours are divided by 60
    long remainderMinutes = hours % 60;

    printf("Human Readable Date-Time: %s\n", formattedTime);

    return 0;
}

Output:

 
Human Readable Date-Time: 2024-05-24 10:48:22

Explanation

In the above C code, defining the first timestamp and using the 'gmtime' function to modify a standing 'struct tm' for UTC time and then 'strftime to get the "YYYY- MM-DD HH:MM:SS" format Formats this time to the string used '.

Using C#

Here is the complete C# code in which we have implemented the epoch approach.

Code

 
using System;

class Program
{
    static void Main()
    {
        long timestamp = 1716547702;

        DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(timestamp);

        string formattedDateTime = dateTimeOffset.ToString("yyyy-MM-dd HH:mm:ss");

        long totalSeconds = timestamp;
        long days = totalSeconds / 86400;
        long remainingSeconds = totalSeconds % 86400;

        long hours = remainingSeconds / 3600;
        remainingSeconds %= 3600;

        long minutes = remainingSeconds / 60;
        long seconds = remainingSeconds % 60;

        long remainderHours = days % 24;

        long remainderMinutes = hours % 60;

        Console.WriteLine("Human Readable Date-Time: " + formattedDateTime);
    }
}

Output:

 
Human Readable Date-Time: 2024-05-24 10:48:22

Explanation

In the given C# code, define a timestamp and convert it to a 'DateTimeOffset' using the 'FromUnixTimeSeconds' method and then setting this 'DateTimeOffset' go to a string with the format "yyyy- MM-dd HH:mm:ss". Additionally, the code manually calculates all days, hours, minutes, and seconds from the Unix timestamp, including the remaining hours and minutes when the days and hours are divided Finally, it uses a date-time string listed with a detailed breakdown of the timestamps, including components.

Using PHP

Here is the complete C# code in which we have implemented the epoch approach.

Code

 
<?php

// Defining Unix timestamp
$timestamp = 1716547702;

$date = new DateTime("@$timestamp");

$formattedDateTime = $date->format('Y-m-d H:i:s');

$totalSeconds = $timestamp;
$days = floor($totalSeconds / 86400);
$remainingSeconds = $totalSeconds % 86400;

$hours = floor($remainingSeconds / 3600);
$remainingSeconds %= 3600;

$minutes = floor($remainingSeconds / 60);
$seconds = $remainingSeconds % 60;

$remainderHours = $days % 24;

$remainderMinutes = $hours % 60;

echo "Human Readable Date-Time: $formattedDateTime\n";
?>

Output:

 
Human Readable Date-Time: 2024-05-24 10:48:22

Explanation

In the above PHP code, we have converted the Unix timestamp to a human-readable date-time format using an interpreter. It then converts it to a 'DateTime' object using the 'DateTime' constructor, which uses a Unix timestamp set to " . @" overrides the face and then inverts this 'DateTime' against "Y-m-d H:i:s." It formats the string in format.

Conclusion

Converting Linux/Unix time to a human-readable date format is necessary for defining timestamps representing seconds since January 1, 1970. This conversion is also necessary for analyzing logs, viewing file types, and creating time-dependent data-driven applications. This ensures that Temporal information is accessible and meaningful and facilitates efficient debugging, data analysis, and communication. By converting Unix time to a standard date and time format, we make the data more meaningful and actionable for users and programs.

Next TopicHow to Estimate Time Overhead for Linux System Calls?

← prev next →