Convertidor de Timestamp Unix

Introducció

Un timestamp Unix (també conegut com a temps POSIX o temps Epoch) és un sistema per descriure un moment en el temps. És el nombre de segons que han passat des del 1 de gener de 1970 (mitjanit UTC/GMT), sense comptar els segons intercalars. Els timestamps Unix s'utilitzen àmpliament en sistemes informàtics i llenguatges de programació, ja que proporcionen una representació compacta i independent del llenguatge d'un moment específic en el temps.

Aquest convertidor de timestamp a data detecta i processa automàticament timestamps de diverses longituds, incloent precisió de microsegons (16 dígits), precisió de milisegons (13 dígits) i timestamps Unix estàndard (10 dígits). L'eina identifica el format del timestamp en funció de la longitud de l'entrada, el converteix a un format de data i hora llegible per a humans i mostra el resultat sense requerir que els usuaris especifiquin el tipus de timestamp. Admet tant formats de temps de 12 hores (AM/PM) com de 24 hores per acomodar diferents preferències regionals i personals.

Com funcionen els timestamps Unix

Els timestamps Unix es calculen com el nombre de segons des de l'Epoch Unix (1 de gener de 1970, 00:00:00 UTC). Això els fa particularment útils per calcular diferències de temps i per emmagatzemar dates en un format compacte.

La conversió matemàtica d'un timestamp Unix a una data del calendari implica diversos passos:

1. Començar amb l'Epoch Unix (1 de gener de 1970, 00:00:00 UTC)
2. Afegir el nombre de segons del timestamp
3. Tenir en compte els anys de traspàs, les variacions en la longitud dels mesos i altres complexitats del calendari
4. Aplicar ajustaments de zona horària si és necessari

Per exemple, el timestamp Unix 1609459200 representa divendres, 1 de gener de 2021, 00:00:00 UTC.

La fórmula de conversió es pot expressar com:

$\text{Data} = \text{Epoch Unix} + \text{Timestamp (en segons)}$

La majoria dels llenguatges de programació i sistemes operatius proporcionen funcions integrades per gestionar aquesta conversió, abstraient les complexes càlculs del calendari.

Formats de Timestamp i detecció automàtica

El nostre convertidor admet tres formats de timestamp comuns, que es detecten automàticament en funció del nombre de dígits:

1. Timestamp Unix estàndard (10 dígits): Representa segons des de l'Epoch Unix. Exemple: 1609459200 (1 de gener de 2021, 00:00:00 UTC)

2. Precisión de milisegons (13 dígits): Representa milisegons des de l'Epoch Unix. Exemple: 1609459200000 (1 de gener de 2021, 00:00:00 UTC)

3. Precisión de microsegons (16 dígits): Representa microsegons des de l'Epoch Unix. Exemple: 1609459200000000 (1 de gener de 2021, 00:00:00 UTC)

La detecció automàtica funciona analitzant la longitud de l'entrada:

• Si l'entrada conté 10 dígits, es tracta com un timestamp Unix estàndard (segons)
• Si l'entrada conté 13 dígits, es tracta com un timestamp de milisegons
• Si l'entrada conté 16 dígits, es tracta com un timestamp de microsegons

Aquesta detecció automàtica elimina la necessitat que els usuaris especifiquin el tipus de timestamp, fent que l'eina sigui més amigable i eficient.

Opcions de Format de Temps

Aquest convertidor ofereix dues opcions de format de temps:

1. Format de 24 hores (de vegades anomenat "hora militar"): Les hores van de 0 a 23, i no hi ha designació AM/PM. Per exemple, les 3:00 PM es representen com a 15:00.

2. Format de 12 hores: Les hores van de 1 a 12, amb AM (ante meridiem) per a moments de mitjanit a migdia, i PM (post meridiem) per a moments de migdia a mitjanit. Per exemple, les 15:00 en format de 24 hores es representen com a 3:00 PM.

L'elecció entre aquests formats és en gran mesura una qüestió de convenció regional i preferència personal:

• El format de 24 hores s'utilitza comunament a la majoria d'Europa, Amèrica Llatina i Àsia, així com en contextos científics, militars i mèdics a tot el món.
• El format de 12 hores és prevalent als Estats Units, Canadà, Austràlia i alguns altres països de parla anglesa per a l'ús quotidià.

Casos Límit i Limitacions

En treballar amb timestamps Unix de diverses precisions, és important estar al corrent de diversos casos límit i limitacions:

1. Timestamps negatius: Aquests representen dates abans de l'Epoch Unix (1 de gener de 1970). Si bé són matemàticament vàlids, alguns sistemes poden no gestionar correctament els timestamps negatius. Això s'aplica a tots tres formats de timestamp.

2. El problema del 2038: Els timestamps Unix estàndard (10 dígits) sovint es guarden com a enters signats de 32 bits, que s'inundaran el 19 de gener de 2038. Després d'aquest punt, els sistemes de 32 bits no podran representar els temps correctament a menys que es modifiquin per utilitzar un tipus d'enters més gran.

3. Consideracions de precisió:

   • Timestamps estàndard (10 dígits) tenen precisió de nivell de segon, que és suficient per a la majoria d'aplicacions quotidianes.
   • Timestamps de milisegons (13 dígits) proporcionen 1000 vegades més precisió, útil per a aplicacions que requereixen un temporitzador més precís.
   • Timestamps de microsegons (16 dígits) ofereixen una granularitat encara més fina (1/1.000.000 de segon), que és necessària per a computació d'alta rendiment, aplicacions científiques i certes transaccions financeres.

4. Timestamps extremadament grans: Dates molt llunyanes en el futur poden no ser representables en alguns sistemes, o poden ser gestionades de manera inconsistent. Això és especialment rellevant per als timestamps de milisegons i microsegons, que utilitzen valors numèrics més grans.

5. Segons intercalars: El temps Unix no té en compte els segons intercalars, que s'afegeixen ocasionalment a UTC per compensar la rotació irregular de la Terra. Això significa que el temps Unix no està sincronitzat precisament amb el temps astronòmic.

6. Consideracions de zona horària: Els timestamps Unix representen moments en UTC. Convertir a l'hora local requereix informació addicional sobre la zona horària.

7. Estalvi de llum diürna: En convertir timestamps a l'hora local, s'han de tenir en compte les complexitats de les transicions d'estalvi de llum diürna.

8. Confusió en el format de timestamp: Sense una detecció adequada, un timestamp de milisegons de 13 dígits podria ser interpretat erròniament com una data molt llunyana si es tracta com un timestamp basat en segons. El nostre convertidor evita això detectant automàticament el format en funció de la longitud del dígit.

Casos d'Ús

Els timestamps Unix de diverses precisions s'utilitzen en nombroses aplicacions a través de la informàtica i la gestió de dades:

1. Registres de bases de dades: Els timestamps s'utilitzen comunament per enregistrar quan es van crear o modificar les entrades.

   • Els timestamps estàndard (10 dígits) són sovint suficients per a aplicacions generals de bases de dades.
   • Els timestamps de milisegons (13 dígits) s'utilitzen quan es requereix un ordre més precís dels esdeveniments.

2. Desenvolupament web: Les capçaleres HTTP, les galetes i els mecanismes de caché sovint utilitzen timestamps Unix.

   • La funció Date.now() de JavaScript retorna timestamps de milisegons (13 dígits).

3. Fitxers de registre: Els registres del sistema solen enregistrar esdeveniments amb timestamps Unix per a un ordre cronològic precís.

   • Els sistemes de registre d'alta freqüència poden utilitzar precisió de milisegons o microsegons.

4. Sistemes de control de versions: Git i altres VCS utilitzen timestamps per enregistrar quan es van fer els commits.

5. Respostes d'API: Moltes API web inclouen timestamps en les seves respostes per indicar quan es va generar la dada o quan es van modificar els recursos.

   • Les API REST sovint utilitzen timestamps de precisió de milisegons.

6. Sistemes de fitxers: Els temps de creació i modificació de fitxers sovint es guarden com a timestamps Unix.

7. Gestió de sessions: Les aplicacions web utilitzen timestamps per determinar quan les sessions d'usuari haurien d'expirar.

8. Anàlisi de dades: Els timestamps proporcionen una manera estandarditzada de treballar amb dades temporals en aplicacions d'analítica.

9. Comerç d'alta freqüència: Els sistemes financers sovint requereixen precisió de microsegons (16 dígits) per seqüenciar les transaccions amb precisió.

10. Mesures científiques: L'equip de recerca pot enregistrar observacions amb precisió de microsegons per a una anàlisi temporal precisa.

Alternatives

Si bé els timestamps Unix són àmpliament utilitzats, hi ha formats alternatius de representació del temps que poden ser més apropiats en certs contextos:

1. ISO 8601: Un format de cadena estàndard (per exemple, "2021-01-01T00:00:00Z") que és llegible per a humans mentre manté la capacitat de classificació. Sovint es prefereix per a la intercanvi de dades i aplicacions orientades a l'usuari.

2. RFC 3339: Un perfil d'ISO 8601 utilitzat en protocols d'internet, amb requisits de format més estrictes.

3. Formats llegibles per a humans: Cadenes de data localitzades (per exemple, "1 de gener de 2021") són més apropiades per a la interacció directa amb l'usuari, però són menys adequades per al càlcul.

4. Microsoft FILETIME: Un valor de 64 bits que representa el nombre d'intervals de 100 nanosegons des del 1 de gener de 1601, utilitzat en sistemes Windows.

5. Número de dia julià: Utilitzat en astronomia i algunes aplicacions científiques, comptant els dies des del 1 de gener de 4713 aC.

L'elecció del format de temps depèn de factors com ara:

• La precisió requerida
• Les necessitats de llegibilitat humana
• Les restriccions d'emmagatzematge
• La compatibilitat amb sistemes existents
• El rang de dates que cal representar

Història

El concepte de temps Unix va originar-se amb el desenvolupament del sistema operatiu Unix a Bell Labs a finals dels anys 60 i principis dels anys 70. La decisió d'utilitzar el 1 de gener de 1970 com a època era una mica arbitrària però pràctica per a l'època: era recent suficient per minimitzar els requisits d'emmagatzematge per a dates d'interès, però prou llunyana en el passat per ser útil per a dades històriques.

La implementació original utilitzava un enter signat de 32 bits per emmagatzemar el nombre de segons, que era adequat per a la vida útil esperada dels sistemes Unix en aquell moment. No obstant això, aquesta decisió va portar al problema de l'any 2038 (de vegades anomenat "Y2K38" o "el bug del mil·lenni Unix"), ja que els enters signats de 32 bits només poden representar dates fins al 19 de gener de 2038 (03:14:07 UTC).

A mesura que les necessitats informàtiques evolucionaven, es va fer necessari un timestamp de precisió més alta:

• Precisión de milisegons (13 dígits) es va fer comú amb l'augment de la computació interactiva i la necessitat de mesurar la capacitat de resposta de la interfície d'usuari.

• Precisión de microsegons (16 dígits) va sorgir amb aplicacions de computació d'alta rendiment i sistemes que requerien un temporitzador extremadament precís.

A mesura que Unix i els sistemes operatius similars a Unix van guanyar popularitat, el timestamp Unix es va convertir en un estàndard de facto per representar el temps en la informàtica. Va ser adoptat per nombrosos llenguatges de programació, bases de dades i aplicacions, estenent-se molt més enllà del seu entorn original de Unix.

Els sistemes moderns utilitzen cada vegada més enters de 64 bits per a timestamps, que allarguen el rang representable a aproximadament 292 mil milions d'anys en ambdues direccions des de l'època, resolent efectivament el problema de l'any 2038. No obstant això, els sistemes i aplicacions llegats poden seguir sent vulnerables.

La simplicitat i utilitat del timestamp Unix han assegurat la seva continuïtat malgrat el desenvolupament de formats de representació del temps més sofisticats. Segueix sent un concepte fonamental en la informàtica, fonamentant gran part de la nostra infraestructura digital.

Exemple de Codi

Aquí hi ha exemples de com convertir timestamps Unix de diverses precisions a dates llegibles per a humans en diversos llenguatges de programació:

1// Conversió de timestamp en JavaScript amb detecció automàtica de format
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Convertir cadena a número si cal
4  const numericTimestamp = Number(timestamp);
5  
6  // Detectar format de timestamp en funció de la longitud del dígit
7  let date;
8  if (timestamp.length === 16) {
9    // Precisió de microsegons (dividir per 1.000.000 per obtenir segons)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Detectat: Timestamp de precisió de microsegons");
12  } else if (timestamp.length === 13) {
13    // Precisió de milisegons
14    date = new Date(numericTimestamp);
15    console.log("Detectat: Timestamp de precisió de milisegons");
16  } else if (timestamp.length === 10) {
17    // Timestamp Unix estàndard (segons)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Detectat: Timestamp Unix estàndard (segons)");
20  } else {
21    throw new Error("Format de timestamp no vàlid. S'esperaven 10, 13 o 16 dígits.");
22  }
23  
24  // Opcions de format
25  const options = {
26    year: 'numeric',
27    month: 'long',
28    day: 'numeric',
29    weekday: 'long',
30    hour: use12Hour ? 'numeric' : '2-digit',
31    minute: '2-digit',
32    second: '2-digit',
33    hour12: use12Hour
34  };
35  
36  // Convertir a cadena utilitzant el format local
37  return date.toLocaleString(undefined, options);
38}
39
40// Exemple d'ús
41try {
42  // Timestamp Unix estàndard (10 dígits)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Precisió de milisegons (13 dígits)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Precisió de microsegons (16 dígits)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Conversió de timestamp en Python amb detecció automàtica de format
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Convertir a enter
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Detectar format de timestamp en funció de la longitud del dígit
10    if len(timestamp) == 16:
11        # Precisió de microsegons (dividir per 1.000.000 per obtenir segons)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Detectat: Timestamp de precisió de microsegons")
14    elif len(timestamp) == 13:
15        # Precisió de milisegons (dividir per 1.000 per obtenir segons)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Detectat: Timestamp de precisió de milisegons")
18    elif len(timestamp) == 10:
19        # Timestamp Unix estàndard (segons)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Detectat: Timestamp Unix estàndard (segons)")
22    else:
23        raise ValueError("Format de timestamp no vàlid. S'esperaven 10, 13 o 16 dígits.")
24    
25    # Format de la cadena de data
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # Format de 12 hores amb AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # Format de 24 hores
30    
31    return date.strftime(format_string)
32
33# Exemple d'ús
34try:
35    # Timestamp Unix estàndard (10 dígits)
36    print(convert_timestamp("1609459200", False))
37    
38    # Precisió de milisegons (13 dígits)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Precisió de microsegons (16 dígits)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// Conversió de timestamp en PHP amb detecció automàtica de format
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Assegurar que el timestamp és una cadena per a la comprovació de longitud
5    $timestamp = trim((string)$timestamp);
6    
7    // Detectar format de timestamp en funció de la longitud del dígit
8    if (strlen($timestamp) === 16) {
9        // Precisió de microsegons (dividir per 1.000.000 per obtenir segons)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Detectat: Timestamp de precisió de microsegons\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Precisió de milisegons
14        $seconds = $numericTimestamp / 1000;
15        echo "Detectat: Timestamp de precisió de milisegons\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Timestamp Unix estàndard (segons)
18        $seconds = $numericTimestamp;
19        echo "Detectat: Timestamp Unix estàndard (segons)\n";
20    } else {
21        throw new Exception("Format de timestamp no vàlid. S'esperaven 10, 13 o 16 dígits.");
22    }
23    
24    // Format de cadena
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // Format de 12 hores amb AM/PM
27        : 'l, F j, Y H:i:s';   // Format de 24 hores
28    
29    // Convertir i formatar la data
30    return date($formatString, $seconds);
31}
32
33// Exemple d'ús
34try {
35    // Timestamp Unix estàndard (10 dígits)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Precisió de milisegons (13 dígits)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Precisió de microsegons (16 dígits)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Conversió de timestamp en Java amb detecció automàtica de format
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class TimestampConverter {
8    public static String convertTimestamp(String timestamp, boolean use12Hour) {
9        // Retallar l'entrada
10        timestamp = timestamp.trim();
11        
12        // Detectar format de timestamp en funció de la longitud del dígit
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Precisió de microsegons (dividir per 1.000.000 per obtenir segons)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Convertir a nanosegons
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Detectat: Timestamp de precisió de microsegons");
20        } else if (timestamp.length() == 13) {
21            // Precisió de milisegons
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Detectat: Timestamp de precisió de milisegons");
26        } else if (timestamp.length() == 10) {
27            // Timestamp Unix estàndard (segons)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Detectat: Timestamp Unix estàndard (segons)");
32        } else {
33            throw new IllegalArgumentException("Format de timestamp no vàlid. S'esperaven 10, 13 o 16 dígits.");
34        }
35        
36        // Crear formatador en funció del format desitjat
37        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
38            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
39        );
40        
41        // Format de la data
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Timestamp Unix estàndard (10 dígits)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Precisió de milisegons (13 dígits)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Precisió de microsegons (16 dígits)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// Conversió de timestamp en C# amb detecció automàtica de format
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Retallar l'entrada
9        timestamp = timestamp.Trim();
10        
11        // Detectar format de timestamp en funció de la longitud del dígit
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Precisió de microsegons (dividir per 1.000.000 per obtenir segons)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Format de timestamp no vàlid");
18                
19            // Convertir microsegons a DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Detectat: Timestamp de precisió de microsegons");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Precisió de milisegons
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Format de timestamp no vàlid");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Detectat: Timestamp de precisió de milisegons");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Timestamp Unix estàndard (segons)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Format de timestamp no vàlid");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Detectat: Timestamp Unix estàndard (segons)");
40        }
41        else
42        {
43            throw new ArgumentException("Format de timestamp no vàlid. S'esperaven 10, 13 o 16 dígits.");
44        }
45        
46        // Format de cadena en funció de la preferència de 12 hores o 24 hores
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // Format de 12 hores amb AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // Format de 24 hores
50        
51        // Retornar la cadena de data formatada
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Timestamp Unix estàndard (10 dígits)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Precisió de milisegons (13 dígits)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Precisió de microsegons (16 dígits)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Maneig de Casos Límit

En treballar amb timestamps Unix de diferents precisions, és important gestionar correctament els casos límit. Aquí hi ha un exemple que demostra un maneig exhaustiu de casos límit:

1// Maneig exhaustiu de casos límit en JavaScript per a múltiples formats de timestamp
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Validació d'entrada
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Error: Timestamp buit o indefinit";
6  }
7  
8  // Assegurar que el timestamp és una cadena per a la comprovació de longitud
9  const timestampStr = String(timestamp).trim();
10  
11  // Comprovar si el timestamp conté només dígits
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Error: El timestamp ha de contenir només dígits";
14  }
15  
16  // Detectar format en funció de la longitud
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Precisió de microsegons
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Convertir a milisegons
23      console.log("Processant timestamp de microsegons (16 dígits)");
24      
25      // Comprovar data no vàlida
26      if (isNaN(date.getTime())) {
27        return "Error: Timestamp de microsegons no vàlid";
28      }
29    } else if (timestampStr.length === 13) {
30      // Precisió de milisegons
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Processant timestamp de milisegons (13 dígits)");
34      
35      // Comprovar data no vàlida
36      if (isNaN(date.getTime())) {
37        return "Error: Timestamp de milisegons no vàlid";
38      }
39    } else if (timestampStr.length === 10) {
40      // Timestamp Unix estàndard (segons)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Processant timestamp estàndard (10 dígits)");
44      
45      // Comprovar data no vàlida
46      if (isNaN(date.getTime())) {
47        return "Error: Timestamp estàndard no vàlid";
48      }
49      
50      // Comprovar problema del Y2K38 (per a sistemes de 32 bits)
51      const maxInt32 = 2147483647; // Valor màxim per a enter signat de 32 bits
52      if (seconds > maxInt32) {
53        console.warn("Advertència: El timestamp supera el límit de 32 bits (problema del Y2K38)");
54      }
55    } else {
56      return "Error: Longitud de timestamp no vàlida. S'esperaven 10, 13 o 16 dígits.";
57    }
58    
59    // Format de la data
60    const options = {
61      year: 'numeric',
62      month: 'long',
63      day: 'numeric',
64      weekday: 'long',
65      hour: use12Hour ? 'numeric' : '2-digit',
66      minute: '2-digit',
67      second: '2-digit',
68      hour12: use12Hour
69    };
70    
71    return date.toLocaleString(undefined, options);
72  } catch (error) {
73    return "Error convertint timestamp: " + error.message;
74  }
75}
76
77// Prova amb diversos casos límit
78console.log(safeConvertTimestamp("1609459200"));      // Estàndard (10 dígits)
79console.log(safeConvertTimestamp("1609459200000"));   // Milisegons (13 dígits)
80console.log(safeConvertTimestamp("1609459200000000")); // Microsegons (16 dígits)
81console.log(safeConvertTimestamp("abc123"));          // No numèric
82console.log(safeConvertTimestamp("12345"));           // Longitud no vàlida
83console.log(safeConvertTimestamp("9999999999999999")); // Timestamp de microsegons molt gran
84console.log(safeConvertTimestamp(""));                // Cadena buida
85

Preguntes Freqüents

Què és un timestamp Unix?

Un timestamp Unix és el nombre de segons que han passat des del 1 de gener de 1970 (mitjanit UTC/GMT), sense comptar els segons intercalars. Proporciona una representació compacta i independent del llenguatge d'un moment específic en el temps.

Com funciona la detecció automàtica del format de timestamp?

El convertidor detecta automàticament el format de timestamp en funció del nombre de dígits:

• 10 dígits: Timestamp Unix estàndard (segons des de l'època)
• 13 dígits: Timestamp de precisió de milisegons
• 16 dígits: Timestamp de precisió de microsegons

Per què necessitaria precisió de milisegons o microsegons?

La precisió de milisegons (13 dígits) és útil per a aplicacions que requereixen un temporitzador més precís, com el seguiment del rendiment, el seguiment de la interacció de l'usuari i certes aplicacions financeres. La precisió de microsegons (16 dígits) és necessària per a la computació d'alta rendiment, aplicacions científiques i sistemes de comerç d'alta freqüència on el temporitzador extremadament precís és crític.

Puc convertir dates abans de 1970 utilitzant timestamps Unix?

Sí, les dates abans del 1 de gener de 1970 es representen mitjançant timestamps negatius. No obstant això, alguns sistemes poden no gestionar correctament els timestamps negatius, així que és important provar aquesta funcionalitat si necessiteu treballar amb dates històriques.

Què és el problema del 2038?

El problema del 2038 es produeix perquè molts sistemes emmagatzemen timestamps Unix com a enters signats de 32 bits, que només poden representar dates fins al 19 de gener de 2038 (03:14:07 UTC). Després d'aquest punt, l'enter s'inundarà, cosa que pot causar fallades del sistema. Els sistemes moderns utilitzen cada vegada més enters de 64 bits per evitar aquest problema.

Com manejo les conversions de zona horària amb timestamps Unix?

Els timestamps Unix són sempre en UTC (Temps Universal Coordinat). Per convertir a una zona horària específica, cal aplicar l'offset apropiat després de convertir el timestamp a una data. La majoria dels llenguatges de programació proporcionen funcions integrades per gestionar les conversions de zona horària.

Quina és la diferència entre el temps Unix i ISO 8601?

El temps Unix és una representació numèrica (segons des de l'època), mentre que ISO 8601 és un format de cadena (per exemple, "2021-01-01T00:00:00Z"). El temps Unix és més compacte i més fàcil d'utilitzar per a càlculs, mentre que ISO 8601 és més llegible per a humans i autodescriptiu.

Quina precisió tenen els timestamps Unix?

Els timestamps Unix estàndard tenen precisió de nivell de segon. Per a aplicacions que requereixen una major precisió, els timestamps de milisegons (13 dígits) proporcionen precisió de 1/1000 de segon, i els timestamps de microsegons (16 dígits) ofereixen precisió de 1/1.000.000 de segon.

Els timestamps Unix tenen en compte els segons intercalars?

No, el temps Unix es defineix com el nombre de segons des de l'època, excloent els segons intercalars. Això significa que durant un segon intercalat, el timestamp Unix no s'incrementa. Això pot causar problemes en aplicacions que requereixen un temps astronòmic precís.

Puc utilitzar timestamps Unix per programar esdeveniments futurs?

Sí, els timestamps són àmpliament utilitzats per programar. No obstant això, per a dates molt llunyanes en el futur, tingueu en compte les possibles limitacions, com el problema del 2038 per a sistemes de 32 bits i el maneig dels canvis de zona horària i les transicions d'estalvi de llum diürna.

Referències

1. "Temps Unix." Wikipedia, Fundació Wikimedia, https://ca.wikipedia.org/wiki/Temps_Unix

2. "Problema de l'any 2038." Wikipedia, Fundació Wikimedia, https://ca.wikipedia.org/wiki/Problema_de_l'any_2038

3. Olson, Arthur David. "Les complexitats del temps calendàric." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601." Wikipedia, Fundació Wikimedia, https://ca.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: Data i hora a Internet: Timestamps." Grup d'Enginyeria d'Internet (IETF), https://tools.ietf.org/html/rfc3339

6. Kernighan, Brian W., i Dennis M. Ritchie. "El llenguatge de programació C." Prentice Hall, 1988.

7. "Temporització de precisió en la computació d'alta rendiment." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Representació del temps en sistemes financers." Journal of Financial Technology, https://www.fintech-journal.com/time-representation

Proveu el nostre convertidor de timestamps ara per convertir fàcilment timestamps Unix de qualsevol precisió a dates llegibles per a humans. Ja sigui que estigueu treballant amb timestamps Unix estàndard, de milisegons o de microsegons, la nostra eina detecta automàticament el format i proporciona conversions precises.