See More

Chceme tento open-source projekt zpřístupnit lidem po celém světě.

Pomozte přeložit obsah tohoto tutoriálu do svého jazyka!

Mapa tutoriálu
  1. Tutoriál
  2. Jazyk JavaScript
  3. Datové typy
26. ledna 2025

Datum a čas

Seznámíme se s novým vestavěným objektem: Date. Tento objekt v sobě ukládá datum a čas a poskytuje metody pro práci s nimi.

Můžeme jej například použít k uložení času vytvoření nebo modifikace něčeho, k měření času nebo jen k vypsání dnešního data.

Vytvoření

Abychom vytvořili objekt Date, zavoláme new Date() s jedním z následujících argumentů:

new Date()

Bez argumentů – vytvoří se objekt Date pro aktuální datum a čas:

let nyní = new Date();
alert( nyní ); // zobrazí aktuální datum a čas
new Date(milisekundy)

Vytvoří objekt Date s časem, který odpovídá počtu milisekund (1/1000 sekundy), které uplynuly od 1. ledna 1970 UTC+0.

// 0 znamená 01.01.1970 UTC+0
let leden01_1970 = new Date(0);
alert( leden01_1970 );

// nyní přidáme 24 hodin a získáme 02.01.1970 UTC+0
let leden02_1970 = new Date(24 * 3600 * 1000);
alert( leden02_1970 );

Celé číslo, které představuje počet milisekund, které uplynuly od začátku roku 1970, se nazývá časové razítko nebo časová značka (anglicky timestamp).

Je to číselná reprezentace data. Z časového razítka můžeme vždy vytvořit datum pomocí new Date(časovéRazítko) a existující objekt Date můžeme převést na časové razítko pomocí metody datum.getTime() (viz níže).

Data před 1. lednem 1970 mají záporná časová razítka, např.:

// 31. prosinec 1969
let pros31_1969 = new Date(-24 * 3600 * 1000);
alert( pros31_1969 );
new Date(datovýŘetězec)

Jestliže je uveden jediný argument a je to řetězec, bude z něj automaticky vytvořeno datum. Algoritmus je stejný, jaký používá Date.parse. Probereme ho později.

let datum= new Date("2017-01-26");
alert(datum);
// Čas není nastaven, takže se předpokládá půlnoc GMT a
// přizpůsobí se časovému pásmu, ve kterém je kód spuštěn.
// Výsledek tedy může být:
// Thu Jan 26 2017 11:00:00 GMT+1100 (Australian Eastern Daylight Time)
// nebo:
// Wed Jan 25 2017 16:00:00 GMT-0800 (Pacific Standard Time)
// V Česku zřejmě bude:
// Thu Jan 26 2017 01:00:00 GMT+1100 (Středoevropský standardní čas) - pozn. překl.
new Date(rok, měsíc, den, hodiny, minuty, sekundy, ms)

Vytvoří datum ze zadaných složek v místním časovém pásmu. Povinné jsou jen první dva argumenty.

  • Parametr rok by mÄ›l mít 4 číslice. Z důvodu kompatibility se pÅ™ijímají i 2 číslice a považují se za 19xx, napÅ™. 98 je zde totéž jako 1998, ale důraznÄ› se doporučuje používat vždy 4 číslice.
  • Parametr mÄ›síc může být od 0 (leden) do 11 (prosinec).
  • Parametr den znamená den v mÄ›síci. Není-li uveden, pÅ™edpokládá se 1.
  • Nejsou-li uvedeny parametry hodiny/minuty/sekundy/ms, pÅ™edpokládá se, že jsou 0.

Příklad:

new Date(2011, 0, 1, 0, 0, 0, 0); // 1. leden 2011, 00:00:00
new Date(2011, 0, 1); // totéž, hodiny atd. jsou standardně 0

Maximální přesnost je 1 ms (1/1000 s):

let datum = new Date(2011, 0, 1, 2, 3, 4, 567);
alert( datum ); // 1.01.2011, 02:03:04.567

Přístup ke složkám data

Existují metody, kterými můžeme přistupovat k roku, měsíci a dalším složkám objektu Date:

getFullYear()
Vrací rok (4-číslicový).
getMonth()
Vrací měsíc od 0 do 11.
getDate()
Vrací den v měsíci od 1 do 31. Název metody skutečně vypadá trochu podivně.
getHours(), getMinutes(), getSeconds(), getMilliseconds()
Vracejí odpovídající časové složky (getHours() vrací hodiny, getMinutes() minuty, getSeconds() sekundy a getMilliseconds() milisekundy – pozn. překl.).
Ne getYear(), ale getFullYear()

Mnoho JavaScriptových motorů implementuje nestandardní metodu getYear(). Tato metoda je zastaralá. Někdy vrací 2-číslicový letopočet. Prosíme nepoužívejte ji. Ke zjištění roku je určena metoda getFullYear().

Navíc můžeme získat i den v týdnu:

getDay()
Vrací den v týdnu od 0 (neděle) do 6 (sobota). První den je vždy neděle. V některých zemích to tak není, ale nedá se to změnit.

Všechny výše uvedené metody vracejí složky relativní k místnímu časovému pásmu.

Existují také jejich UTC-protějšky, které vracejí den, měsíc atd. pro časové pásmo UTC+0: getUTCFullYear(), getUTCMonth(), getUTCDay(). Stačí vložit "UTC" rovnou za "get".

Jestliže je vaše místní časové pásmo vzhledem k UTC posunuto, pak následující kód zobrazí různé hodiny:

// nynější datum
let datum = new Date();

// hodina ve vašem nynějším časovém pásmu
alert( datum.getHours() );

// hodina v časovém pásmu UTC+0 (londýnský zimní čas)
alert( datum.getUTCHours() );

Kromě uvedených metod existují i dvě speciální, které nemají UTC-variantu:

getTime()

Vrací časové razítko data – počet milisekund, které uplynuly od 1. ledna 1970 UTC+0.

getTimezoneOffset()

Vrací rozdíl mezi UTC a místním časovým pásmem v minutách:

// jestliže jste v časovém pásmu UTC-1, vypíše 60
// jestliže jste v časovém pásmu UTC+3, vypíše -180
// (v Česku vypíše v letním čase -120, v zimním -60 - pozn. překl.)
alert( new Date().getTimezoneOffset() );

Nastavení složek data

Následující metody umožňují nastavit složky data a času:

Každá z nich kromě setTime() má UTC-variantu, např. setUTCHours().

Jak vidíme, některé metody umožňují nastavit více složek najednou, např. setHours. Složky, které nejsou uvedeny, nebudou změněny.

Příklad:

let dnes = new Date();

dnes.setHours(0);
alert(dnes); // stále dnes, ale hodina se změní na 0

dnes.setHours(0, 0, 0, 0);
alert(dnes); // stále dnes, nyní 00:00:00

Automatická oprava

Automatická oprava je velmi šikovná vlastnost objektů Date. Můžeme nastavit hodnoty mimo rozsah a ty se automaticky přizpůsobí.

Příklad:

let datum = new Date(2013, 0, 32); // 32. leden 2013 ?!?
alert(datum); // ...je 1. únor 2013!

Datové složky mimo povolený rozsah se automaticky přepočítají.

Řekněme, že potřebujeme zvýšit datum „28. únor 2016“ o 2 dny. Může to být „2. březen“ nebo v případě přestupného roku „1. březen“. Na to nemusíme myslet. Stačí přičíst 2 dny. O zbytek se postará objekt Date:

let datum = new Date(2016, 1, 28);
datum.setDate(datum.getDate() + 2);

alert( datum ); // 1. březen 2016

Tato vlastnost se často používá k získání data, které nastane po uplynutí zadaného času. Například získejme datum, které bude za „70 sekund od nynějška“:

let datum = new Date();
datum.setSeconds(datum.getSeconds() + 70);

alert( datum ); // zobrazí správné datum

Můžeme nastavit i nulové nebo záporné hodnoty. Například:

let datum = new Date(2016, 0, 2); // 2. leden 2016

datum.setDate(1); // nastavíme 1. den v měsíci
alert( datum );

datum.setDate(0); // minimální den je 1, takže se předpokládá poslední den předchozího měsíce
alert( datum ); // 31. prosinec 2015

Konverze data na číslo, rozdíl dat

Když je objekt Date konvertován na číslo, převede se na časové razítko, stejné, jaké vrací metoda datum.getTime():

let datum = new Date();
alert(+datum); // počet milisekund, totéž jako datum.getTime()

Důležitý vedlejší efekt: data lze od sebe odečítat, výsledkem je jejich rozdíl v milisekundách.

To můžeme využít k měření času:

let začátek = new Date(); // spustíme měření času

// uděláme práci
for (let i = 0; i < 100000; i++) {
  let dělejNěco = i * i * i;
}

let konec = new Date(); // zastavíme měření času

alert( `Cyklus trval ${konec - začátek} ms` );

Date.now()

Jestliže chceme jenom měřit čas, nepotřebujeme objekt Date.

Existuje speciální metoda Date.now(), která vrací aktuální časové razítko.

Je sémanticky ekvivalentní new Date().getTime(), ale nevytváří dočasný objekt Date. Je tedy rychlejší a nezatěžuje sběrač odpadků.

Používá se většinou proto, že je pohodlnější, nebo tehdy, když záleží na výkonu, například v JavaScriptových hrách nebo jiných specializovaných aplikacích.

Tohle je tedy pravděpodobně lepší:

let začátek = Date.now(); // počet milisekund od 1. ledna 1970

// uděláme práci
for (let i = 0; i < 100000; i++) {
  let dělejNěco = i * i * i;
}

let konec = Date.now(); // hotovo

alert( `Cyklus trval ${konec - začátek} ms` ); // odečítáme čísla, ne data

Benchmarky

Jestliže chceme spolehlivý benchmark funkce náročné na CPU, měli bychom být opatrní.

Například změřme dvě funkce, které počítají rozdíl mezi dvěma daty: která z nich je rychlejší?

Taková měření výkonu se často nazývají „benchmarky“.

// máme datum1 a datum2, která funkce vrátí rychleji jejich rozdíl v ms?
function rozdílOdečtením(datum1, datum2) {
  return datum2 - datum1;
}

// nebo
function rozdílPomocíGetTime(datum1, datum2) {
  return datum2.getTime() - datum1.getTime();
}

Tyto dvě funkce dělají přesně totéž, ale jedna z nich používá explicitní datum.getTime(), aby získala datum v milisekundách, zatímco druhá se spoléhá na transformaci data na číslo. Jejich výsledek je vždy stejný.

Která je tedy rychlejší?

Jako první můžeme dostat nápad, že je spustíme mnohokrát za sebou a změříme rozdíl časů. V našem případě jsou tyto funkce velmi jednoduché, takže to musíme udělat alespoň 100 000krát.

Změřme to:

function rozdílOdečtením(datum1, datum2) {
  return datum2 - datum1;
}

function rozdílPomocíGetTime(datum1, datum2) {
  return datum2.getTime() - datum1.getTime();
}

function bench(f) {
  let datum1 = new Date(0);
  let datum2 = new Date();

  let začátek = Date.now();
  for (let i = 0; i < 100000; i++) f(datum1, datum2);
  return Date.now() - začátek;
}

alert( 'Čas funkce rozdílOdečtením: ' + bench(rozdílOdečtením) + ' ms' );
alert( 'Čas funkce rozdílPomocíGetTime: ' + bench(rozdílPomocíGetTime) + ' ms' );

Páni! Použití getTime() je mnohem rychlejší! Je to proto, že tam není žádná typová konverze, a proto je pro motory mnohem snadnější funkci optimalizovat.

Dobrá, něco tedy máme. To však ještě není dobrý benchmark.

Představme si, že v době spuštění bench(rozdílOdečtením) CPU prováděl paralelně něco jiného a to mu ubíralo zdroje. A v době spuštění bench(rozdílPomocíGetTime) tahle práce skončila.

V moderních multiprocesních operačních systémech je to dosti reálný scénář.

Výsledkem je, že první benchmark měl méně zdrojů CPU než druhý. To mohlo vést ke špatným výsledkům.

Pro spolehlivější benchmarkové testování bychom měli celý balíček benchmarků spustit několikrát za sebou.

Například takto:

function rozdílOdečtením(datum1, datum2) {
  return datum2 - datum1;
}

function rozdílPomocíGetTime(datum1, datum2) {
  return datum2.getTime() - datum1.getTime();
}

function bench(f) {
  let datum1 = new Date(0);
  let datum2 = new Date();

  let začátek = Date.now();
  for (let i = 0; i < 100000; i++) f(datum1, datum2);
  return Date.now() - začátek;
}

let čas1 = 0;
let čas2 = 0;

// spustíme bench(rozdílOdečtením) a bench(rozdílPomocíGetTime) střídavě, každou 10krát
for (let i = 0; i < 10; i++) {
  čas1 += bench(rozdílOdečtením);
  čas2 += bench(rozdílPomocíGetTime);
}

alert( 'Celkový čas funkce rozdílOdečtením: ' + čas1 );
alert( 'Celkový čas funkce rozdílPomocíGetTime: ' + čas2 );

Moderní JavaScriptové motory začínají aplikovat pokročilé optimalizace jen na „horký kód“, který se provádí mnohokrát (není třeba optimalizovat to, co se provádí jen vzácně). Ve výše uvedeném příkladu tedy první spuštění nejsou dobře optimalizovaná. Můžeme chtít přidat zahřívací kolo:

// přidáno pro „zahřátí“ před hlavní smyčkou
bench(rozdílOdečtením);
bench(rozdílPomocíGetTime);

// nyní benchmark
for (let i = 0; i < 10; i++) {
  čas1 += bench(rozdílOdečtením);
  čas2 += bench(rozdílPomocíGetTime);
}
Při mikrobenchmarkových testech buďte opatrní

Moderní JavaScriptové motory provádějí množství optimalizací, které mohou vylepšit výsledky „umělých testů“ ve srovnání s „běžným použitím“, zvláště když provádíme benchmark něčeho velmi malého, např. práce operátoru nebo vestavěné funkce. Pokud tedy chcete skutečně porozumět výkonu, pak si prosíme prostudujte, jak funguje JavaScriptový motor. A pak už pravděpodobně nebudete mikrobenchmarky vůbec potřebovat.

Výborný balík článků o V8 naleznete na https://mrale.ph.

Načítání data z řetězce

Metoda Date.parse(řetězec) dokáže načíst datum z řetězce.

Řetězec by měl mít formát RRRR-MM-DDTHH:mm:ss.sssZ, kde:

  • RRRR-MM-DD – je datum: rok-mÄ›síc-den.
  • Znak "T" se používá jako oddÄ›lovač.
  • HH:mm:ss.sss – je čas: hodiny, minuty, sekundy a milisekundy.
  • Nepovinná část 'Z' označuje časové pásmo ve formátu +-hh:mm. Samotné písmeno Z znamená UTC+0.

Jsou možné i kratší varianty, např. RRRR-MM-DD nebo RRRR-MM nebo jen RRRR.

Volání Date.parse(řetězec) rozebere řetězec v uvedeném formátu a vrátí časové razítko (počet milisekund od 1. ledna 1970 UTC+0). Není-li formát správný, vrátí NaN.

Příklad:

let ms = Date.parse('2012-01-26T13:51:50.417-07:00');

alert(ms); // 1327611110417  (časové razítko)

Z tohoto časového razítka můžeme ihned vytvořit objekt pomocí new Date:

let datum = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );

alert(datum);

Shrnutí

  • Datum a čas v JavaScriptu pÅ™edstavuje objekt Date. Nemůžeme vytvoÅ™it „jenom datum“ nebo „jenom čas“: objekty Date obsahují vždy obojí.
  • MÄ›síce se počítají od nuly (ano, leden je nultý mÄ›síc).
  • Dny v týdnu ve funkci getDay() se také počítají od nuly (to je nedÄ›le).
  • Date se automaticky opravuje, když jsou nastaveny složky mimo správný rozsah. To je dobré pro pÅ™ičítání/odečítání dnů/mÄ›síců/hodin.
  • Data lze od sebe odečítat, výsledkem je jejich rozdíl v milisekundách. To je proto, že Date se pÅ™i konverzi na číslo pÅ™evede na časové razítko.
  • ÄŒasové razítko času, který je právÄ› teď, rychle získáme pomocí Date.now().

Všimněte si, že na rozdíl od mnoha jiných systémů se časová razítka v JavaScriptu počítají v milisekundách, ne v sekundách.

Někdy potřebujeme přesnější měření času. Samotný JavaScript neobsahuje způsob, jak měřit čas v mikrosekundách (1 milióntina sekundy), ale většina prostředí jej poskytuje. Například prohlížeče mají metodu performance.now(), která vrací počet milisekund od začátku načítání stránky s přesností na mikrosekundy (3 číslice za desetinnou čárkou):

alert(`Načítání začalo před ${performance.now()}ms`);
// Něco jako: "Načítání začalo před 34731.26000000001ms"
// .26 jsou mikrosekundy (260 mikrosekund)
// více než 3 číslice za desetinnou čárkou jsou chyba přesnosti, jedině první 3 jsou správné

Node.js má modul microtime a jiné způsoby. Technicky téměř každé zařízení a každé prostředí umožňuje získat lepší přesnost, jenom ne pomocí Date.

Úlohy

Vytvoření data

důležitost: 5

Vytvořte objekt Date pro datum: 20. února 2012, 3.12 hodin. Časové pásmo je místní.

Zobrazte jej pomocí alert.

Konstruktor new Date používá místní časové pásmo, takže jediná důležitá věc, kterou si musíme pamatovat, je, že měsíce se počítají od nuly.

Únor má tedy číslo 1.

Zde je příklad s čísly jako složkami data:

//new Date(rok, měsíc, den, hodiny, minuty, sekundy, milisekundy)
let d1 = new Date(2012, 1, 20, 3, 12);
alert( d1 );

Můžeme vytvořit datum i z řetězce, např. takto:

//new Date(řetězecSDatem)
let d2 = new Date("2012-02-20T03:12");
alert( d2 );

Zobrazení dne v týdnu

důležitost: 5

Napište funkci vraťDenVTýdnu(datum), která zobrazí den v týdnu ve zkráceném tvaru: „PO“, „ÚT“, „ST“, „ČT“, „PÁ“, „SO“, „NE“.

Příklad:

let datum = new Date(2012, 0, 3);  // 3. leden 2012
alert( vraťDenVTýdnu(datum) );     // měla by vypsat „ÚT“

Otevřít pískoviště s testy.

Metoda datum.getDay() vrací číslo dne v týdnu počínajíc nedělí.

Vytvoříme pole dnů v týdnu, abychom mohli získat název příslušného dne podle jeho čísla:

function vraťDenVTýdnu(datum) {
  let dny = ['NE', 'PO', 'ÚT', 'ST', 'ČT', 'PÁ', 'SO'];

  return dny[datum.getDay()];
}

let datum = new Date(2014, 0, 3); // 3. leden 2014
alert( vraťDenVTýdnu(datum) ); // PÁ

Otevřít řešení s testy na pískovišti.

Evropský den v týdnu

důležitost: 5

V evropských zemích začíná týden pondělím (číslo 1), pak je úterý (číslo 2) a tak dále, až nakonec je neděle (číslo 7). Napište funkci vraťMístníDenVTýdnu(datum), která vrátí „evropský“ den v týdnu pro datum.

let datum = new Date(2012, 0, 3);     // 3. leden 2012
alert( vraťMístníDenVTýdnu(datum) );  // úterý, měla by zobrazit 2

Otevřít pískoviště s testy.

function vraťMístníDenVTýdnu(datum) {

  let den = datum.getDay();

  if (den == 0) { // 0. den v týdnu (neděle) je v Evropě 7.
    den = 7;
  }

  return den;
}

Otevřít řešení s testy na pískovišti.

Který den v měsíci byl před mnoha dny?

důležitost: 4

Vytvořte funkci vraťDenPřed(datum, dny), která vrátí den v měsíci, který byl dny dnů přede dnem datum.

Například jestliže dnes je 20., pak vraťDenPřed(new Date(), 1) by měla vrátit 19 a vraťDenPřed(new Date(), 2) by měla vrátit 18.

Měla by spolehlivě fungovat i pro dny=365 nebo více:

let datum = new Date(2015, 0, 2);

alert( vraťDenPřed(datum, 1) ); // 1, (1. leden 2015)
alert( vraťDenPřed(datum, 2) ); // 31, (31. prosinec 2014)
alert( vraťDenPřed(datum, 365) ); // 2, (2. leden 2014)

P.S. Funkce by neměla modifikovat zadané datum.

Otevřít pískoviště s testy.

Myšlenka je jednoduchá: odečíst zadaný počet dní od datum:

function vraťDenPřed(datum, dny) {
  datum.setDate(datum.getDate() - dny);
  return datum.getDate();
}

…Funkce by však neměla měnit datum. To je důležité, jelikož vnější kód, který nám datum předává, neočekává, že bude změněno.

Abychom to implementovali, naklonujeme datum, napÅ™. takto:

function vraťDenPřed(datum, dny) {
  let kopieData = new Date(datum);

  kopieData.setDate(datum.getDate() - dny);
  return kopieData.getDate();
}

let datum = new Date(2015, 0, 2);

alert( vraťDenPřed(datum, 1) ); // 1, (1. leden 2015)
alert( vraťDenPřed(datum, 2) ); // 31, (31. prosinec 2014)
alert( vraťDenPřed(datum, 365) ); // 2, (2. leden 2014)

Otevřít řešení s testy na pískovišti.

Poslední den v měsíci?

důležitost: 5

Napište funkci vraťPosledníDenVMěsíci(rok, měsíc), která vrátí číslo posledního dne v měsíci. Někdy je to 30., někdy 31., v únoru dokonce 28. nebo 29.

Parametry:

  • rok – čtyřčíslicový rok, napÅ™. 2012.
  • mÄ›síc – mÄ›síc, od 0 do 11.

Například vraťPosledníDenVMěsíci(2012, 1) = 29 (přestupný rok, únor).

Otevřít pískoviště s testy.

Vytvořme datum z následujícího měsíce, ale jako den předáme nulu:

function vraťPosledníDenVMěsíci(rok, měsíc) {
  let datum = new Date(rok, měsíc + 1, 0);
  return datum.getDate();
}

alert( vraťPosledníDenVMěsíci(2012, 0) ); // 31
alert( vraťPosledníDenVMěsíci(2012, 1) ); // 29
alert( vraťPosledníDenVMěsíci(2013, 1) ); // 28

Normálně dny začínají od 1, ale technicky můžeme předat jakékoli číslo a datum se samo přizpůsobí. Když tedy předáme 0, bude to znamenat „jeden den před 1. dnem v měsíci“, jinými slovy: „poslední den předcházejícího měsíce“.

Otevřít řešení s testy na pískovišti.

Kolik sekund už dnes uplynulo?

důležitost: 5

Napište funkci vraťDnešníSekundy(), která vrátí počet sekund, které uplynuly od začátku dnešního dne.

Například jestliže je právě 22:00 a dnes se neměnil letní čas na zimní nebo naopak, pak:

vraťDnešníSekundy() == 36000 // (3600 * 10)

Funkce by měla fungovat v kterýkoli den. To znamená, že by neměla mít napevno zakódovanou hodnotu „dneška“.

Abychom získali počet sekund, můžeme vygenerovat datum z dnešního dne a času 00:00:00 a pak je odečíst od „nynějška“.

Rozdílem bude počet milisekund od začátku dne, který bychom měli vydělit 1000, abychom získali sekundy:

function vraťDnešníSekundy() {
  let nyní = new Date();

  // vytvoříme objekt z dnešního dne/měsíce/roku
  let dnešek = new Date(nyní.getFullYear(), nyní.getMonth(), nyní.getDate());

  let rozdíl = nyní - dnešek; // rozdíl v milisekundách
  return Math.round(rozdíl / 1000); // vytvoříme sekundy
}

alert( vraťDnešníSekundy() );

Alternativním řešením by bylo získat hodiny, minuty a sekundy a převést je na sekundy:

function vraťDnešníSekundy() {
  let d = new Date();
  return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
}

alert( vraťDnešníSekundy() );

Kolik sekund zbývá do zítřka?

důležitost: 5

Vytvořte funkci vraťSekundyDoZítřka(), která vrátí počet sekund, které zbývají do zítřka.

Například jestliže právě je 23:00, pak:

vraťSekundyDoZítřka() == 3600

P.S. Funkce by měla fungovat v kterémkoli dni, „dnešek“ v ní nemá být napevno zakódován.

Abychom získali počet milisekund zbývajících do zítřka, můžeme odečíst aktuální datum od „zítřka 00:00:00“.

Nejprve tento „zítřek“ vygenerujeme a pak to provedeme:

function vraťSekundyDoZítřka() {
  let nyní = new Date();

  // zítřejší datum
  let zítřek = new Date(nyní.getFullYear(), nyní.getMonth(), nyní.getDate()+1);

  let rozdíl = zítřek - nyní; // rozdíl v ms
  return Math.round(rozdíl / 1000); // převod na sekundy
}

alert(vraťSekundyDoZítřka());

Alternativní řešení:

function vraťSekundyDoZítřka() {
  let nyní = new Date();
  let hodiny = nyní.getHours();
  let minuty = nyní.getMinutes();
  let sekundy = nyní.getSeconds();
  let celkemSekundDnes = (hodiny * 60 + minuty) * 60 + sekundy;
  let celkemSekundZaDen = 86400;

  return celkemSekundZaDen - celkemSekundDnes;
}

alert(vraťSekundyDoZítřka());

Prosíme všimněte si, že mnoho zemí používá letní čas, takže mohou existovat dny, které mají 23 nebo 25 hodin. S takovými dny můžeme chtít zacházet odlišně.

Relativní formátování data

důležitost: 4

Napište funkci formátujDatum(datum), která by měla formátovat datum následovně:

  • Jestliže od okamžiku datum uplynula ménÄ› než 1 sekunda, pak "právÄ› teď".
  • Jinak jestliže od datum uplynula ménÄ› než 1 minuta, pak "pÅ™ed n s".
  • Jinak jestliže uplynula ménÄ› než hodina, pak "pÅ™ed m min.".
  • Jinak úplné datum ve formátu "DD.MM.RR HH:mm", tedy: "den.mÄ›síc.rok hodiny:minuty", vÅ¡e v 2-číslicovém formátu, napÅ™. 31.12.16 10:00.

Příklad:

alert( formátujDatum(new Date(new Date - 1)) ); // "právě teď"

alert( formátujDatum(new Date(new Date - 30 * 1000)) ); // "před 30 s"

alert( formátujDatum(new Date(new Date - 5 * 60 * 1000)) ); // "před 5 min."

// včerejší datum ve formátu 31.12.16 20:00
alert( formátujDatum(new Date(new Date - 86400 * 1000)) );

Otevřít pískoviště s testy.

Abychom získali čas, který uplynul od data datum do nynějška, odečteme data.

function formátujDatum(datum) {
  let rozdíl = new Date() - datum; // rozdíl v milisekundách

  if (rozdíl < 1000) { // méně než 1 sekunda
    return 'právě teď';
  }

  let sec = Math.floor(rozdíl / 1000); // převedeme rozdíl na sekundy

  if (sec < 60) {
    return 'před ' + sec + ' s';
  }

  let min = Math.floor(rozdíl / 60000); // převedeme rozdíl na minuty
  if (min < 60) {
    return 'před ' + min + ' min.';
  }

  // naformátujeme datum
  // před jednociferný den/měsíc/hodiny/minuty přidáme nulu
  let d = datum;
  d = [
    '0' + d.getDate(),
    '0' + (d.getMonth() + 1),
    '' + d.getFullYear(),
    '0' + d.getHours(),
    '0' + d.getMinutes()
  ].map(složka => složka.slice(-2)); // z každé složky vezmeme poslední 2 číslice

  // spojíme složky do data
  return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
}

alert( formátujDatum(new Date(new Date - 1)) ); // "právě teď"

alert( formátujDatum(new Date(new Date - 30 * 1000)) ); // "před 30 s"

alert( formátujDatum(new Date(new Date - 5 * 60 * 1000)) ); // "před 5 min."

// včerejší datum ve formátu 31.12.2016 20:00
alert( formátujDatum(new Date(new Date - 86400 * 1000)) );

Alternativní řešení:

function formátujDatum(datum) {
  let denVMěsíci = datum.getDate();
  let měsíc = datum.getMonth() + 1;
  let rok = datum.getFullYear();
  let hodina = datum.getHours();
  let minuta = datum.getMinutes();
  let rozdílMs = new Date() - datum;
  let rozdílSec = Math.round(rozdílMs / 1000);
  let rozdílMin = rozdílSec / 60;
  let rozdílHod = rozdílMin / 60;

  // formátování
  rok = rok.toString().slice(-2);
  měsíc = měsíc < 10 ? '0' + měsíc : měsíc;
  denVMěsíci = denVMěsíci < 10 ? '0' + denVMěsíci : denVMěsíci;
  hodina = hodina < 10 ? '0' + hodina : hodina;
  minuta = minuta < 10 ? '0' + minuta : minuta;

  if (rozdílSec < 1) {
    return 'právě teď';
  } else if (rozdílMin < 1) {
    return `před ${rozdílSec} s`
  } else if (rozdílHod < 1) {
    return `před ${rozdílMin} min.`
  } else {
    return `${denVMěsíci}.${měsíc}.${rok} ${hodina}:${minuta}`
  }
}

alert( formátujDatum(new Date(new Date - 1)) ); // "právě teď"

alert( formátujDatum(new Date(new Date - 30 * 1000)) ); // "před 30 s"

alert( formátujDatum(new Date(new Date - 5 * 60 * 1000)) ); // "před 5 min."

// včerejší datum, např. 31.12.2016 20:00
alert( formátujDatum(new Date(new Date - 86400 * 1000)) );

Otevřít řešení s testy na pískovišti.

Předchozí lekceDalší lekce
Mapa tutoriálu

Komentáře

přečtěte si před komentováním…
  • Máte-li návrhy na zlepÅ¡ení, vytvoÅ™te prosím issue na GitHubu nebo pull request místo komentáře.
  • Pokud v článku něčemu nerozumíte, napiÅ¡te prosím, čemu pÅ™esnÄ› a na kterém místÄ›.
  • Pro vložení nÄ›kolika slov kódu použijte značku <code>, pro nÄ›kolik řádků je obalte značkou <pre>, pro více než 10 řádků vložte odkaz na pískoviÅ¡tÄ› (plnkr, jsbin, codepen…)

Kapitola

Navigace v lekci

Sdílet
Upravit na GitHubu