Whiz Tools

Kigeuzi cha Unix Timestamp

Unix времевият печат е броят на секундите от 1 януари 1970 г. (UTC)

Tarehe na Wakati Vilivyogeuzwa

Unix Timestamp Converter

Introduction

Unix timestamp (pia inajulikana kama POSIX time au Epoch time) ni mfumo wa kuelezea wakati fulani. Ni idadi ya sekunde ambazo zimepita tangu Januari 1, 1970 (katika usiku UTC/GMT), bila kuhesabu sekunde za kuruka. Unix timestamps zinatumika sana katika mifumo ya kompyuta na lugha za programu kwani zinatoa uwakilishi wa kompakt, usio na lugha wa wakati maalum.

Converter hii inakuwezesha kubadilisha Unix timestamp kuwa tarehe na wakati unaoweza kusomeka na binadamu. Inasaidia muundo wa wakati wa saa 12 (AM/PM) na saa 24 ili kukidhi mapendeleo tofauti ya kikanda na binafsi.

How Unix Timestamps Work

Unix timestamps huchukuliwa kama idadi ya sekunde tangu Unix Epoch (Januari 1, 1970, 00:00:00 UTC). Hii inawafanya kuwa na manufaa hasa katika kuhesabu tofauti za wakati na kuhifadhi tarehe kwa mfumo wa kompakt.

Mchakato wa kubadilisha Unix timestamp kuwa tarehe ya kalenda unajumuisha hatua kadhaa:

  1. Anza na Unix Epoch (Januari 1, 1970, 00:00:00 UTC)
  2. Ongeza idadi ya sekunde katika timestamp
  3. Hesabu miaka ya kuruka, urefu wa miezi tofauti, na changamoto nyingine za kalenda
  4. Fanya marekebisho ya eneo la wakati ikiwa inahitajika

Kwa mfano, Unix timestamp 1609459200 inawakilisha Ijumaa, Januari 1, 2021, 00:00:00 UTC.

Fomula ya kubadilisha inaweza kuonyeshwa kama:

Tarehe=Unix Epoch+Timestamp (katika sekunde)\text{Tarehe} = \text{Unix Epoch} + \text{Timestamp (katika sekunde)}

Lugha nyingi za programu na mifumo ya uendeshaji hutoa kazi za ndani za kushughulikia kubadilisha hii, zikiondoa hesabu ngumu za kalenda.

Time Format Options

Converter hii inatoa chaguzi mbili za muundo wa wakati:

  1. Muundo wa saa 24 (wakati mwingine huitwa "saa ya kijeshi"): Saa zinaanzia 0 hadi 23, na hakuna alama ya AM/PM. Kwa mfano, 3:00 PM inawakilishwa kama 15:00.

  2. Muundo wa saa 12: Saa zinaanzia 1 hadi 12, na AM (ante meridiem) kwa nyakati kutoka usiku hadi adhuhuri, na PM (post meridiem) kwa nyakati kutoka adhuhuri hadi usiku. Kwa mfano, 15:00 katika muundo wa saa 24 inawakilishwa kama 3:00 PM.

Chaguo kati ya muundo hizi ni suala la kawaida za kikanda na mapendeleo binafsi:

  • Muundo wa saa 24 unatumika sana katika sehemu nyingi za Ulaya, Amerika ya Kusini, na Asia, pamoja na katika muktadha wa kisayansi, kijeshi, na matibabu duniani kote.
  • Muundo wa saa 12 unatumika sana nchini Marekani, Kanada, Australia, na baadhi ya nchi nyingine za Kiingereza kwa matumizi ya kila siku.

Edge Cases and Limitations

Unapofanya kazi na Unix timestamps, ni muhimu kuwa na ufahamu wa hali kadhaa za pembezoni na mipaka:

  1. Timestamps hasi: Hizi zinawakilisha tarehe kabla ya Unix Epoch (Januari 1, 1970). Ingawa ni halali kimaandishi, baadhi ya mifumo huenda zisishughulike timestamps hasi kwa usahihi.

  2. Tatizo la Mwaka 2038: Unix timestamps mara nyingi huhifadhiwa kama nambari za 32-bit zisizokuwa na saini, ambazo zitakumbwa na overflow mnamo Januari 19, 2038. Baada ya wakati huu, mifumo ya 32-bit itashindwa kuwakilisha nyakati kwa usahihi isipokuwa ibadilishwe kutumia aina kubwa ya nambari.

  3. Timestamps kubwa sana: Tarehe za mbali sana za siku zijazo huenda zisizoweza kuwakilishwa katika baadhi ya mifumo, au zinaweza kushughulikiwa kwa kutofautiana.

  4. Sekunde za kuruka: Wakati wa Unix hauzingatii sekunde za kuruka, ambazo huongezwa mara kwa mara kwa UTC ili kuboresha mzunguko usio sawa wa Dunia. Hii inamaanisha wakati wa Unix haujapatikana kwa usahihi na wakati wa angani.

  5. Marekebisho ya eneo la wakati: Unix timestamps zinawakilisha nyakati katika UTC. Kubadilisha kuwa wakati wa ndani kunahitaji taarifa za eneo la wakati za ziada.

  6. Muda wa Kuokoa Mwanga: Wakati wa kubadilisha timestamps kuwa wakati wa ndani, changamoto za mabadiliko ya Muda wa Kuokoa Mwanga zinapaswa kuzingatiwa.

Use Cases

Unix timestamps zinatumika katika programu nyingi katika kompyuta na usimamizi wa data:

  1. Rekodi za Hifadhidata: Timestamps hutumiwa kawaida kurekodi wakati wa kuunda au kubadilisha entries.

  2. Maendeleo ya Mtandao: Vichwa vya HTTP, vidakuzi, na mifumo ya kuhifadhi mara nyingi hutumia Unix timestamps.

  3. Faili za Kumbukumbu: Kumbukumbu za mifumo kawaida huandika matukio kwa timestamps za Unix kwa mpangilio sahihi wa wakati.

  4. Mifumo ya Udhibiti wa Toleo: Git na mifumo mingine ya VCS hutumia timestamps kurekodi wakati wa kutekelezwa.

  5. Majibu ya API: API nyingi za wavuti hujumuisha timestamps katika majibu yao kuonyesha wakati data ilitengenezwa au wakati rasilimali zilipobadilishwa mara ya mwisho.

  6. Mifumo ya Faili: Nyakati za kuunda na kubadilisha faili mara nyingi huhifadhiwa kama Unix timestamps.

  7. Usimamizi wa Kikao: Programu za wavuti hutumia timestamps kuamua wakati vikao vya mtumiaji vinapaswa kuisha.

  8. Uchambuzi wa Data: Timestamps zinatoa njia iliyoandikwa ya kufanya kazi na data ya muda katika programu za uchambuzi.

Alternatives

Ingawa Unix timestamps zinatumika sana, kuna mifumo mbadala ya uwakilishi wa wakati ambayo inaweza kuwa bora katika baadhi ya muktadha:

  1. ISO 8601: Muundo wa mfuatano wa kawaida (mfano, "2021-01-01T00:00:00Z") ambao unaweza kusomeka na binadamu huku ukihifadhi uwezo wa kupanga. Mara nyingi hupendekezwa kwa kubadilishana data na programu zinazokutana na watumiaji.

  2. RFC 3339: Profaili ya ISO 8601 inayotumika katika itifaki za mtandao, ikiwa na mahitaji makali ya muundo.

  3. Muundo unaoweza kusomeka na binadamu: Mifumo ya tarehe iliyotafsiriwa (mfano, "Januari 1, 2021") ni bora kwa mwingiliano wa moja kwa moja na watumiaji lakini sio sahihi kwa hesabu.

  4. Microsoft FILETIME: Thamani ya 64-bit inayowakilisha idadi ya vipindi vya nanosekunde 100 tangu Januari 1, 1601, inayotumiwa katika mifumo ya Windows.

  5. Nambari ya Siku ya Julian: Inayotumiwa katika sayansi na programu zingine za kisayansi, ikihesabu siku tangu Januari 1, 4713 BCE.

Chaguo la muundo wa wakati linaweza kutegemea mambo kama:

  • Usahihi unaohitajika
  • Mahitaji ya kusomeka na binadamu
  • Mipaka ya uhifadhi
  • Ufanisi na mifumo iliyopo
  • Mzunguko wa tarehe zinazohitajika kuwakilishwa

History

Wazo la wakati wa Unix lilitokea na maendeleo ya mfumo wa uendeshaji wa Unix katika Bell Labs katika miaka ya 1960 na mapema 1970. Uamuzi wa kutumia Januari 1, 1970, kama epoch ulikuwa wa kidogo wa bahati lakini wa vitendo kwa wakati huo—ilikuwa ya karibuni vya kutosha kupunguza mahitaji ya uhifadhi kwa tarehe za kupendeza lakini mbali vya kutosha katika zamani ili kuwa na manufaa kwa data ya kihistoria.

Utekelezaji wa awali ulitumia nambari ya 32-bit isiyo na saini kuhifadhi idadi ya sekunde, ambayo ilikuwa ya kutosha kwa muda wa kutarajiwa wa mifumo ya Unix wakati huo. Hata hivyo, uamuzi huu ulisababisha Tatizo la Mwaka 2038 (wakati mwingine huitwa "Y2K38" au "Unix Millennium Bug"), kwani nambari za 32-bit zisizo na saini zinaweza kuwakilisha tarehe hadi Januari 19, 2038 (03:14:07 UTC).

Kadri Unix na mifumo inayofanana na Unix ilivyozidi kuwa maarufu, timestamp ya Unix ikawa kiwango kisichokuwa rasmi kwa uwakilishi wa wakati katika kompyuta. Ilipitishwa na lugha nyingi za programu, hifadhidata, na programu, ikipanuka mbali zaidi ya mazingira yake ya awali ya Unix.

Mifumo ya kisasa inatumia nambari za 64-bit kwa timestamps, ambayo inapanua mzunguko wa kuwakilisha hadi takriban miaka bilioni 292 katika pande zote mbili kutoka kwa epoch, ikitatua kwa ufanisi Tatizo la Mwaka 2038. Hata hivyo, mifumo na programu za zamani zinaweza bado kuwa hatarini.

Urahisi na manufaa ya timestamp ya Unix yamehakikisha umuhimu wake wa kuendelea licha ya maendeleo ya mifumo ya uwakilishi wa wakati yenye ufanisi zaidi. Inabaki kuwa dhana muhimu katika kompyuta, ikitegemea sehemu kubwa ya miundombinu yetu ya kidijitali.

Code Examples

Hapa kuna mifano ya jinsi ya kubadilisha Unix timestamps kuwa tarehe zinazoweza kusomeka kwa lugha mbalimbali za programu:

// JavaScript timestamp conversion
function convertUnixTimestamp(timestamp, use12Hour = false) {
  // Create a new Date object (JavaScript uses milliseconds)
  const date = new Date(timestamp * 1000);
  
  // Format options
  const options = {
    year: 'numeric',
    month: 'long',
    day: 'numeric',
    weekday: 'long',
    hour: use12Hour ? 'numeric' : '2-digit',
    minute: '2-digit',
    second: '2-digit',
    hour12: use12Hour
  };
  
  // Convert to string using locale formatting
  return date.toLocaleString(undefined, options);
}

// Example usage
const timestamp = 1609459200; // January 1, 2021 00:00:00 UTC
console.log(convertUnixTimestamp(timestamp, false)); // 24-hour format
console.log(convertUnixTimestamp(timestamp, true));  // 12-hour format

# Python timestamp conversion
import datetime

def convert_unix_timestamp(timestamp, use_12hour=False):
    # Convert Unix timestamp to datetime object
    date = datetime.datetime.fromtimestamp(timestamp)
    
    # Format the date string
    if use_12hour:
        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-hour format with AM/PM
    else:
        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-hour format
    
    return date.strftime(format_string)

# Example usage
timestamp = 1609459200  # January 1, 2021 00:00:00 UTC
print(convert_unix_timestamp(timestamp, False))  # 24-hour format
print(convert_unix_timestamp(timestamp, True))   # 12-hour format

<?php
// PHP timestamp conversion
function convertUnixTimestamp($timestamp, $use12Hour = false) {
    // Format string
    $formatString = $use12Hour 
        ? 'l, F j, Y g:i:s A'  // 12-hour format with AM/PM
        : 'l, F j, Y H:i:s';   // 24-hour format
    
    // Convert and format the date
    return date($formatString, $timestamp);
}

// Example usage
$timestamp = 1609459200; // January 1, 2021 00:00:00 UTC
echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-hour format
echo convertUnixTimestamp($timestamp, true) . "\n";  // 12-hour format
?>

// Java timestamp conversion
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

public class UnixTimestampConverter {
    public static String convertUnixTimestamp(long timestamp, boolean use12Hour) {
        // Convert Unix timestamp to Instant, then to LocalDateTime
        Instant instant = Instant.ofEpochSecond(timestamp);
        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        
        // Create formatter based on desired format
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
        );
        
        // Format the date
        return dateTime.format(formatter);
    }
    
    public static void main(String[] args) {
        long timestamp = 1609459200; // January 1, 2021 00:00:00 UTC
        System.out.println(convertUnixTimestamp(timestamp, false)); // 24-hour format
        System.out.println(convertUnixTimestamp(timestamp, true));  // 12-hour format
    }
}

// C# timestamp conversion
using System;

class UnixTimestampConverter
{
    public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
    {
        // Convert Unix timestamp to DateTime
        // Unix timestamp is seconds since 1970-01-01
        DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
        
        // Format string based on 12-hour or 24-hour preference
        string formatString = use12Hour 
            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-hour format with AM/PM
            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-hour format
        
        // Return formatted date string
        return dateTime.ToString(formatString);
    }
    
    static void Main()
    {
        long timestamp = 1609459200; // January 1, 2021 00:00:00 UTC
        Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-hour format
        Console.WriteLine(ConvertUnixTimestamp(timestamp, true));  // 12-hour format
    }
}

# Ruby timestamp conversion
require 'time'

def convert_unix_timestamp(timestamp, use_12hour = false)
  # Convert Unix timestamp to Time object
  time = Time.at(timestamp)
  
  # Format based on 12-hour or 24-hour preference
  if use_12hour
    time.strftime("%A, %B %d, %Y %I:%M:%S %p")  # 12-hour format with AM/PM
  else
    time.strftime("%A, %B %d, %Y %H:%M:%S")     # 24-hour format
  end
end

# Example usage
timestamp = 1609459200  # January 1, 2021 00:00:00 UTC
puts convert_unix_timestamp(timestamp, false)  # 24-hour format
puts convert_unix_timestamp(timestamp, true)   # 12-hour format

// Go timestamp conversion
package main

import (
    "fmt"
    "time"
)

func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
    // Convert Unix timestamp to Time
    t := time.Unix(timestamp, 0)
    
    // Format string based on 12-hour or 24-hour preference
    formatString := "Monday, January 2, 2006 "
    if use12Hour {
        formatString += "3:04:05 PM"  // 12-hour format with AM/PM
    } else {
        formatString += "15:04:05"    // 24-hour format
    }
    
    // Return formatted time
    return t.Format(formatString)
}

func main() {
    timestamp := int64(1609459200) // January 1, 2021 00:00:00 UTC
    fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-hour format
    fmt.Println(convertUnixTimestamp(timestamp, true))  // 12-hour format
}

// Swift timestamp conversion
import Foundation

func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
    // Create Date from Unix timestamp
    let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
    
    // Create DateFormatter
    let formatter = DateFormatter()
    formatter.dateStyle = .full
    
    // Set time style based on 12-hour or 24-hour preference
    if use12Hour {
        formatter.timeStyle = .medium
        formatter.amSymbol = "AM"
        formatter.pmSymbol = "PM"
    } else {
        formatter.timeStyle = .medium
        formatter.dateFormat = formatter.dateFormat?.replacingOccurrences(of: "h:mm:ss a", with: "HH:mm:ss")
    }
    
    // Return formatted date
    return formatter.string(from: date)
}

// Example usage
let timestamp = 1609459200 // January 1, 2021 00:00:00 UTC
print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-hour format
print(convertUnixTimestamp(timestamp, use12Hour: true))  // 12-hour format

# R timestamp conversion
convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
  # Convert Unix timestamp to POSIXct datetime
  date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
  
  # Format based on 12-hour or 24-hour preference
  if (use_12hour) {
    format_string <- "%A, %B %d, %Y %I:%M:%S %p"  # 12-hour format with AM/PM
  } else {
    format_string <- "%A, %B %d, %Y %H:%M:%S"     # 24-hour format
  }
  
  # Return formatted date string
  format(date_time, format_string)
}

# Example usage
timestamp <- 1609459200  # January 1, 2021 00:00:00 UTC
cat(convert_unix_timestamp(timestamp, FALSE), "\n")  # 24-hour format
cat(convert_unix_timestamp(timestamp, TRUE), "\n")   # 12-hour format

% MATLAB timestamp conversion
function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
    % Convert Unix timestamp to MATLAB datetime
    % Excel dates are days since 1900-01-01, with 1 = 1900-01-01
    % Unix timestamps are seconds since 1970-01-01
    
    % First convert to Excel date format
    % 25569 is the number of days between 1900-01-01 and 1970-01-01
    excelDate = (timestamp / 86400) + 25569;
    
    % Format based on 12-hour or 24-hour preference
    if use12Hour
        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy h:mm:ss AM/PM');
    else
        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy hh:mm:ss');
    end
end

% Example usage
timestamp = 1609459200;  % January 1, 2021 00:00:00 UTC
disp(convertUnixTimestamp(timestamp, false))  % 24-hour format
disp(convertUnixTimestamp(timestamp, true))   % 12-hour format

' Excel VBA timestamp conversion
Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
    ' Convert Unix timestamp to Excel date/time
    ' Excel dates are days since 1900-01-01, with 1 = 1900-01-01
    ' Unix timestamps are seconds since 1970-01-01
    
    ' First convert to Excel date format
    ' 25569 is the number of days between 1900-01-01 and 1970-01-01
    Dim excelDate As Double
    excelDate = (timestamp / 86400) + 25569
    
    ' Format the date based on 12-hour or 24-hour preference
    If use12Hour Then
        ConvertUnixTimestamp = Format(excelDate, "dddd, mmmm d, yyyy h:mm:ss AM/PM")
    Else
        ConvertUnixTimestamp = Format(excelDate, "dddd, mmmm d, yyyy hh:mm:ss")
    End If
End Function

' Usage in a worksheet:
' =ConvertUnixTimestamp(1609459200, TRUE)  ' 12-hour format
' =ConvertUnixTimestamp(1609459200, FALSE) ' 24-hour format

Handling Edge Cases

Unapofanya kazi na Unix timestamps, ni muhimu kushughulikia hali za pembezoni kwa usahihi. Hapa kuna mifano ya kushughulikia baadhi ya hali za kawaida za pembezoni:

// JavaScript edge case handling
function safeConvertTimestamp(timestamp, use12Hour = false) {
  // Check if timestamp is valid
  if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
    return "Timestamp isiyo sahihi";
  }
  
  // Check for negative timestamps (dates before 1970)
  if (timestamp < 0) {
    // Baadhi ya vivinjari huenda visishughulike timestamps hasi kwa usahihi
    // Tumia mbinu yenye nguvu zaidi kwa tarehe kabla ya 1970
    const date = new Date(timestamp * 1000);
    if (isNaN(date.getTime())) {
      return "Tarehe isiyo sahihi (kabla ya 1970)";
    }
  }
  
  // Check for Y2K38 problem (for 32-bit systems)
  const maxInt32 = 2147483647; // Thamani ya juu kwa nambari ya 32-bit isiyo na saini
  if (timestamp > maxInt32) {
    // Fikiria kutumia BigInt kwa timestamps kubwa sana katika JavaScript ya kisasa
    console.warn("Timestamp inazidi mipaka ya nambari ya 32-bit (tatizo la Y2K38)");
  }
  
  // Proceed with normal conversion
  try {
    const date = new Date(timestamp * 1000);
    const options = {
      year: 'numeric',
      month: 'long',
      day: 'numeric',
      weekday: 'long',
      hour: use12Hour ? 'numeric' : '2-digit',
      minute: '2-digit',
      second: '2-digit',
      hour12: use12Hour
    };
    return date.toLocaleString(undefined, options);
  } catch (error) {
    return "Kosa katika kubadilisha timestamp: " + error.message;
  }
}

References

  1. "Unix Time." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time

  2. "Tatizo la Mwaka 2038." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem

  3. Olson, Arthur David. "Changamoto za Wakati wa Kalenda." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

  4. "ISO 8601." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/ISO_8601

  5. "RFC 3339: Tarehe na Wakati kwenye Mtandao: Timestamps." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339

  6. Kernighan, Brian W., na Dennis M. Ritchie. "Lugha ya Programu ya C." Prentice Hall, 1988.

Zana Zinazohusiana

Kibadilisha Kiwango cha Wakati: Miaka, Siku, Saa, Dakika, Sekunde
Mwandiko wa JSON & Mrembo: Chapisha JSON kwa Ufunguo
Service Uptime Calculator for IT Operations and SLA Compliance
Kihesabu Siku ya Mwaka - Hesabu Siku Zilizobaki Katika Mwaka
Kihesabu Tokeni: Hesabu Idadi ya Tokeni kwa Maktaba ya Tiktoken
Feedback