Rencontrons un nouvel objet intégré : Date. Il stocke la date, l'heure et fournit des méthodes de gestion de la date/heure.
Par exemple, nous pouvons l'utiliser pour stocker les temps de création/modification, pour mesurer le temps ou simplement pour imprimer la date actuelle.
Pour créer un nouvel objet Date , appelez new Date() avec l'un des arguments suivants :
new Date()
Sans arguments – créez un objet Date pour la date et l'heure actuelles :
laissez maintenant = new Date(); alerte (maintenant); // affiche la date/heure actuelle
new Date(milliseconds)
Créez un objet Date avec une heure égale au nombre de millisecondes (1/1000 de seconde) écoulées après le 1er janvier 1970 UTC+0.
// 0 signifie 01.01.1970 UTC+0 soit Jan01_1970 = new Date(0); alerte( 01 janvier_1970 ); // ajoutez maintenant 24 heures, obtenez 02.01.1970 UTC+0 soit Jan02_1970 = new Date(24 * 3600 * 1000); alerte( Jan02_1970 );
Un nombre entier représentant le nombre de millisecondes écoulées depuis le début des années 1970 est appelé horodatage .
C'est une représentation numérique légère d'une date. Nous pouvons toujours créer une date à partir d'un horodatage en utilisant new Date(timestamp) et convertir l'objet Date existant en un horodatage en utilisant la méthode date.getTime() (voir ci-dessous).
Les dates antérieures au 01.01.1970 ont des horodatages négatifs, par exemple :
// 31 décembre 1969 soit Dec31_1969 = new Date(-24 * 3600 * 1000); alerte( Dec31_1969 );
new Date(datestring)
S'il n'y a qu'un seul argument et qu'il s'agit d'une chaîne, il est analysé automatiquement. L'algorithme est le même que celui utilisé par Date.parse , nous y reviendrons plus tard.
let date = new Date("2017-01-26");
alerte (date);
// L'heure n'est pas définie, elle est donc supposée être minuit GMT et
// est ajusté en fonction du fuseau horaire dans lequel le code est exécuté
// Le résultat pourrait donc être
// Jeu. 26 janvier 2017 11:00:00 GMT+1100 (heure avancée de l'Est de l'Australie)
// ou
// Mercredi 25 janvier 2017 16:00:00 GMT-0800 (heure normale du Pacifique) new Date(year, month, date, hours, minutes, seconds, ms)
Créez la date avec les composants donnés dans le fuseau horaire local. Seuls les deux premiers arguments sont obligatoires.
L' year doit avoir 4 chiffres. Pour des raisons de compatibilité, 2 chiffres sont également acceptés et considérés comme 19xx , par exemple 98 est le même que 1998 ici, mais toujours utiliser 4 chiffres est fortement encouragé.
Le décompte month commence par 0 (janvier) jusqu'à 11 (décembre).
Le paramètre date est en fait le jour du mois, s'il est absent, alors 1 est supposé.
Si hours/minutes/seconds/ms sont absentes, elles sont supposées égales à 0 .
Par exemple:
nouvelle date (2011, 0, 1, 0, 0, 0, 0); // 1 janvier 2011, 00:00:00 nouvelle date (2011, 0, 1); // pareil, les heures etc sont 0 par défaut
La précision maximale est de 1 ms (1/1000 sec) :
let date = new Date(2011, 0, 1, 2, 3, 4, 567); alerte( date ); // 01.01.2011, 02:03:04.567
Il existe des méthodes pour accéder à l'année, au mois, etc. à partir de l'objet Date :
getFullYear()
Obtenez l'année (4 chiffres)
getMois()
Obtenez le mois, de 0 à 11 .
obtenirDate()
Obtenez le jour du mois, de 1 à 31, le nom de la méthode semble un peu étrange.
getHours(), getMinutes(), getSeconds(), getMilliseconds()
Obtenez les composantes temporelles correspondantes.
Pas getYear() , mais getFullYear()
De nombreux moteurs JavaScript implémentent une méthode non standard getYear() . Cette méthode est obsolète. Il renvoie parfois une année à 2 chiffres. Veuillez ne jamais l'utiliser. Il y a getFullYear() pour l'année.
De plus, nous pouvons obtenir un jour de la semaine :
getDay()
Obtenez le jour de la semaine, de 0 (dimanche) à 6 (samedi). Le premier jour est toujours le dimanche, dans certains pays ce n'est pas le cas, mais cela ne peut pas être modifié.
Toutes les méthodes ci-dessus renvoient les composants relatifs au fuseau horaire local.
Il existe également leurs homologues UTC, qui renvoient le jour, le mois, l'année, etc. pour le fuseau horaire UTC+0 : getUTCFullYear(), getUTCMonth(), getUTCDay(). Insérez simplement le "UTC" juste après "get" .
Si votre fuseau horaire local est décalé par rapport à UTC, le code ci-dessous affiche des heures différentes :
// date du jour let date = new Date(); // l'heure de votre fuseau horaire actuel alert( date.getHours() ); // l'heure dans le fuseau horaire UTC+0 (heure de Londres sans heure d'été) alert( date.getUTCHours() );
Outre les méthodes données, il en existe deux spéciales qui n'ont pas de variante UTC :
getTime()
Renvoie l'horodatage de la date – nombre de millisecondes écoulées depuis le 1er janvier 1970 UTC+0.
getTimezoneOffset()
Renvoie la différence entre UTC et le fuseau horaire local, en minutes :
// si vous êtes dans le fuseau horaire UTC-1, affiche 60 // si vous êtes dans le fuseau horaire UTC+3, affiche -180 alert( new Date().getTimezoneOffset() );
Les méthodes suivantes permettent de définir les composants date/heure :
setFullYear(year, [month], [date])
setMonth(month, [date])
setDate(date)
setHours(hour, [min], [sec], [ms])
setMinutes(min, [sec], [ms])
setSeconds(sec, [ms])
setMilliseconds(ms)
setTime(milliseconds) (définit la date entière en millisecondes depuis le 01.01.1970 UTC)
Chacun d'entre eux, à l'exception de setTime() a une variante UTC, par exemple : setUTCHours() .
Comme nous pouvons le voir, certaines méthodes peuvent définir plusieurs composants à la fois, par exemple setHours . Les composants non mentionnés ne sont pas modifiés.
Par exemple:
laissez aujourd'hui = new Date(); aujourd'hui.setHours(0); alerte (aujourd'hui); // toujours aujourd'hui, mais l'heure est passée à 0 aujourd'hui.setHours(0, 0, 0, 0); alerte (aujourd'hui); // toujours aujourd'hui, maintenant 00:00:00 précises.
La correction automatique est une fonctionnalité très pratique des objets Date . Nous pouvons définir des valeurs hors plage et elles s’ajusteront automatiquement.
Par exemple:
let date = new Date(2013, 0, 32); // 32 janvier 2013 ?!? alerte (date); // ...nous sommes le 1er février 2013 !
Les composants de date hors plage sont distribués automatiquement.
Disons que nous devons augmenter la date du « 28 février 2016 » de 2 jours. Il peut s'agir du « 2 mars » ou du « 1 mars » en cas d'année bissextile. Nous n'avons pas besoin d'y penser. Ajoutez simplement 2 jours. L'objet Date fera le reste :
let date = new Date(2016, 1, 28); date.setDate(date.getDate() + 2); alerte( date ); // 1er mars 2016
Cette fonctionnalité est souvent utilisée pour obtenir la date après une période de temps donnée. Par exemple, obtenons la date « 70 secondes après maintenant » :
let date = new Date(); date.setSeconds(date.getSeconds() + 70); alerte( date ); // affiche la date correcte
Nous pouvons également définir des valeurs nulles, voire négatives. Par exemple:
let date = new Date(2016, 0, 2); // 2 janvier 2016 date.setDate(1); // définit le jour 1 du mois alerte( date ); date.setDate(0); // le jour min vaut 1, donc le dernier jour du mois précédent est supposé alerte( date ); // 31 décembre 2015
Lorsqu'un objet Date est converti en nombre, il devient le même horodatage que date.getTime() :
let date = new Date(); alerte(+date); // le nombre de millisecondes, identique à date.getTime()
L'effet secondaire important : les dates peuvent être soustraites, le résultat est leur différence en ms.
Cela peut être utilisé pour les mesures de temps :
let start = new Date(); // commence à mesurer le temps
// fait le travail
pour (soit i = 0; i < 100000; i++) {
laissez faireQuelquechose = i * i * i;
}
let end = new Date(); // fin du temps de mesure
alert( `La boucle a pris ${end - start} ms` ); Si nous voulons uniquement mesurer le temps, nous n'avons pas besoin de l'objet Date .
Il existe une méthode spéciale Date.now() qui renvoie l'horodatage actuel.
Il est sémantiquement équivalent à new Date().getTime() , mais il ne crée pas d'objet Date intermédiaire. C'est donc plus rapide et ne met pas de pression sur la collecte des déchets.
Il est principalement utilisé pour des raisons de commodité ou lorsque les performances sont importantes, comme dans les jeux en JavaScript ou dans d'autres applications spécialisées.
Donc c'est probablement mieux :
let start = Date.now(); // les millisecondes comptent à partir du 1er janvier 1970
// fait le travail
pour (soit i = 0; i < 100000; i++) {
laissez faireQuelquechose = i * i * i;
}
let end = Date.now(); // fait
alert( `La boucle a pris ${end - start} ms` ); // soustrait des nombres, pas des datesSi nous voulons un benchmark fiable des fonctions gourmandes en CPU, nous devons être prudents.
Par exemple, mesurons deux fonctions qui calculent la différence entre deux dates : laquelle est la plus rapide ?
Ces mesures de performance sont souvent appelées « références ».
// nous avons date1 et date2, quelle fonction renvoie plus rapidement leur différence en ms ?
fonction diffSubtract(date1, date2) {
date de retour2 - date1 ;
}
// ou
fonction diffGetTime (date1, date2) {
return date2.getTime() - date1.getTime();
} Ces deux-là font exactement la même chose, mais l'un d'eux utilise une date.getTime() explicite pour obtenir la date en ms, et l'autre s'appuie sur une transformation date en nombre. Leur résultat est toujours le même.
Alors, lequel est le plus rapide ?
La première idée pourrait être de les exécuter plusieurs fois de suite et de mesurer le décalage horaire. Dans notre cas, les fonctions sont très simples, il faut donc le faire au moins 100 000 fois.
Mesurons :
fonction diffSubtract(date1, date2) {
date de retour2 - date1 ;
}
fonction diffGetTime (date1, date2) {
return date2.getTime() - date1.getTime();
}
banc de fonctions (f) {
laissez date1 = nouvelle Date(0);
let date2 = new Date();
let start = Date.now();
pour (soit i = 0; i < 100000; i++) f(date1, date2);
return Date.now() - début ;
}
alert( 'Heure de diffSubtract : ' + bench(diffSubtract) + 'ms' );
alert( 'Heure de diffGetTime : ' + bench(diffGetTime) + 'ms' ); Ouah! Utiliser getTime() est tellement plus rapide ! C'est parce qu'il n'y a pas de conversion de type, il est beaucoup plus facile pour les moteurs d'optimiser.
D'accord, nous avons quelque chose. Mais ce n’est pas encore une bonne référence.
Imaginez qu'au moment de l'exécution bench(diffSubtract) le processeur faisait quelque chose en parallèle et prenait des ressources. Et au moment de l'exécution bench(diffGetTime) ce travail est terminé.
Un scénario assez réel pour un système d'exploitation multi-processus moderne.
En conséquence, le premier benchmark aura moins de ressources CPU que le second. Cela pourrait conduire à des résultats erronés.
Pour une analyse comparative plus fiable, l’ensemble des analyses comparatives doit être réexécuté plusieurs fois.
Par exemple, comme ceci :
fonction diffSubtract(date1, date2) {
date de retour2 - date1 ;
}
fonction diffGetTime (date1, date2) {
return date2.getTime() - date1.getTime();
}
banc de fonctions (f) {
laissez date1 = nouvelle Date(0);
let date2 = new Date();
let start = Date.now();
pour (soit i = 0; i < 100000; i++) f(date1, date2);
return Date.now() - début ;
}
laissez time1 = 0 ;
soit time2 = 0 ;
// exécute bench(diffSubtract) et bench(diffGetTime) 10 fois chacun en alternance
pour (soit i = 0; i < 10; i++) {
time1 += banc(diffSubtract);
time2 += banc(diffGetTime);
}
alert( 'Durée totale pour diffSubtract : ' + time1 );
alert( 'Durée totale pour diffGetTime : ' + time2 );Les moteurs JavaScript modernes commencent à appliquer des optimisations avancées uniquement au « code chaud » qui s'exécute plusieurs fois (pas besoin d'optimiser les éléments rarement exécutés). Ainsi, dans l’exemple ci-dessus, les premières exécutions ne sont pas bien optimisées. Nous souhaiterons peut-être ajouter un échauffement :
// ajouté pour le "chauffage" avant la boucle principale
banc (diffSubtract);
banc (diffGetTime);
// maintenant benchmark
pour (soit i = 0; i < 10; i++) {
time1 += banc(diffSubtract);
time2 += banc(diffGetTime);
}Soyez prudent lors du microbenchmarking
Les moteurs JavaScript modernes effectuent de nombreuses optimisations. Ils peuvent modifier les résultats des « tests artificiels » par rapport à « l’utilisation normale », en particulier lorsque nous évaluons quelque chose de très petit, comme le fonctionnement d’un opérateur ou une fonction intégrée. Donc, si vous souhaitez sérieusement comprendre les performances, étudiez le fonctionnement du moteur JavaScript. Et puis, vous n’aurez probablement pas du tout besoin de microbenchmarks.
Le superbe pack d'articles sur le V8 peut être trouvé sur https://mrale.ph.
La méthode Date.parse(str) peut lire une date à partir d'une chaîne.
Le format de chaîne doit être : YYYY-MM-DDTHH:mm:ss.sssZ , où :
YYYY-MM-DD – est la date : année-mois-jour.
Le caractère "T" est utilisé comme délimiteur.
HH:mm:ss.sss – est l'heure : heures, minutes, secondes et millisecondes.
La partie facultative 'Z' indique le fuseau horaire au format +-hh:mm . Une seule lettre Z signifierait UTC+0.
Des variantes plus courtes sont également possibles, comme YYYY-MM-DD ou YYYY-MM ou même YYYY .
L'appel à Date.parse(str) analyse la chaîne dans le format donné et renvoie l'horodatage (nombre de millisecondes à partir du 1er janvier 1970 UTC+0). Si le format n'est pas valide, renvoie NaN .
Par exemple:
let ms = Date.parse('2012-01-26T13:51:50.417-07:00');
alerte (ms); // 1327611110417 (horodatage) Nous pouvons créer instantanément un new Date à partir de l'horodatage :
let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );
alerte (date); La date et l'heure en JavaScript sont représentées par l'objet Date. Nous ne pouvons pas créer « uniquement la date » ou « uniquement l'heure » : les objets Date contiennent toujours les deux.
Les mois sont comptés à partir de zéro (oui, janvier est un mois zéro).
Les jours de la semaine dans getDay() sont également comptés à partir de zéro (c'est-à-dire dimanche).
Date se corrige automatiquement lorsque des composants hors plage sont définis. Idéal pour ajouter/soustraire des jours/mois/heures.
Les dates peuvent être soustraites, donnant leur différence en millisecondes. En effet, une Date devient l'horodatage lorsqu'elle est convertie en nombre.
Utilisez Date.now() pour obtenir rapidement l'horodatage actuel.
Notez que contrairement à de nombreux autres systèmes, les horodatages en JavaScript sont exprimés en millisecondes et non en secondes.
Parfois, nous avons besoin de mesures de temps plus précises. JavaScript lui-même ne permet pas de mesurer le temps en microsecondes (1 millionième de seconde), mais la plupart des environnements le proposent. Par exemple, le navigateur a performance.now() qui donne le nombre de millisecondes à partir du début du chargement de la page avec une précision de la microseconde (3 chiffres après le point) :
alert(`Chargement commencé il y a ${performance.now()}ms`);
// Quelque chose comme : "Le chargement a commencé il y a 34731,26000000001 ms"
// 0,26 correspond à des microsecondes (260 microsecondes)
// plus de 3 chiffres après la virgule sont des erreurs de précision, seuls les 3 premiers sont corrects Node.js a un module microtime et d'autres moyens. Techniquement, presque tous les appareils et environnements permettent d'obtenir plus de précision, ce n'est tout simplement pas le cas dans Date .
importance : 5
Créez un objet Date pour la date : 20 février 2012, 3h12. Le fuseau horaire est local.
Montrez-le en utilisant alert .
Le new Date utilise le fuseau horaire local. La seule chose importante à retenir est donc que les mois commencent à zéro.
Février porte donc le numéro 1.
Voici un exemple avec des nombres comme composants de date :
//nouvelle Date(année, mois, date, heure, minute, seconde, milliseconde) soit d1 = nouvelle date (2012, 1, 20, 3, 12) ; alerte( d1 );
Nous pourrions également créer une date à partir d'une chaîne, comme ceci :
//nouvelle date (chaîne de données)
soit d2 = new Date("2012-02-20T03:12");
alerte( d2 );importance : 5
Écrivez une fonction getWeekDay(date) pour afficher le jour de la semaine au format court : 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'.
Par exemple:
let date = new Date(2012, 0, 3); // 3 janvier 2012 alerte( getWeekDay(date) ); // devrait afficher "TU"
Ouvrez un bac à sable avec des tests.
La méthode date.getDay() renvoie le numéro du jour de la semaine, à partir du dimanche.
Créons un tableau de jours de la semaine, afin que nous puissions obtenir le nom du jour par son numéro :
fonction getWeekDay(date) {
soit jours = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'] ;
jours de retour[date.getDay()] ;
}
let date = new Date(2014, 0, 3); // 3 janvier 2014
alerte( getWeekDay(date) ); // ENOuvrez la solution avec des tests dans un bac à sable.
importance : 5
Les pays européens ont des jours de la semaine commençant par le lundi (numéro 1), puis le mardi (numéro 2) et jusqu'au dimanche (numéro 7). Écrivez une fonction getLocalDay(date) qui renvoie le jour de la semaine « européen » pour date .
let date = new Date(2012, 0, 3); // 3 janvier 2012 alerte( getLocalDay(date) ); // mardi, devrait afficher 2
Ouvrez un bac à sable avec des tests.
fonction getLocalDay (date) {
let day = date.getDay();
if (day == 0) { // le jour de la semaine 0 (dimanche) vaut 7 en européen
jour = 7 ;
}
jour de retour;
}Ouvrez la solution avec des tests dans un bac à sable.
importance : 4
Créez une fonction getDateAgo(date, days) pour renvoyer le jour du mois il y a days à partir de la date .
Par exemple, si aujourd'hui nous sommes le 20, alors getDateAgo(new Date(), 1) devrait être le 19 et getDateAgo(new Date(), 2) devrait être le 18.
Devrait fonctionner de manière fiable pendant days=365 ou plus :
let date = new Date(2015, 0, 2); alerte( getDateAgo(date, 1) ); // 1, (1er janvier 2015) alerte( getDateAgo(date, 2) ); // 31, (31 décembre 2014) alerte( getDateAgo(date, 365) ); // 2, (2 janvier 2014)
PS La fonction ne doit pas modifier la date donnée .
Ouvrez un bac à sable avec des tests.
L'idée est simple : soustraire un nombre donné de jours à date :
fonction getDateAgo (date, jours) {
date.setDate(date.getDate() - jours);
date de retour.getDate();
} …Mais la fonction ne doit pas changer date . C'est une chose importante, car le code externe qui nous donne la date ne s'attend pas à ce qu'elle change.
Pour l'implémenter, clonons la date, comme ceci :
fonction getDateAgo (date, jours) {
let dateCopy = new Date(date);
dateCopy.setDate(date.getDate() - jours);
return dateCopy.getDate();
}
let date = new Date(2015, 0, 2);
alerte( getDateAgo(date, 1) ); // 1, (1er janvier 2015)
alerte( getDateAgo(date, 2) ); // 31, (31 décembre 2014)
alerte( getDateAgo(date, 365) ); // 2, (2 janvier 2014)Ouvrez la solution avec des tests dans un bac à sable.
importance : 5
Écrivez une fonction getLastDayOfMonth(year, month) qui renvoie le dernier jour du mois. Parfois c'est le 30, le 31 ou même le 28/29 pour le mois de février.
Paramètres :
year – année à quatre chiffres, par exemple 2012.
month – mois, de 0 à 11.
Par exemple, getLastDayOfMonth(2012, 1) = 29 (année bissextile, février).
Ouvrez un bac à sable avec des tests.
Créons une date en utilisant le mois suivant, mais passons zéro comme jour :
function getLastDayOfMonth (année, mois) {
let date = new Date(année, mois + 1, 0);
date de retour.getDate();
}
alerte( getLastDayOfMonth(2012, 0) ); // 31
alerte( getLastDayOfMonth(2012, 1) ); // 29
alerte( getLastDayOfMonth(2013, 1) ); // 28Normalement, les dates commencent à 1, mais techniquement, nous pouvons transmettre n'importe quel nombre, la date s'ajustera automatiquement. Ainsi quand on passe 0, alors cela signifie « un jour avant le 1er jour du mois », autrement dit : « le dernier jour du mois précédent ».
Ouvrez la solution avec des tests dans un bac à sable.
importance : 5
Écrivez une fonction getSecondsToday() qui renvoie le nombre de secondes depuis le début de la journée.
Par exemple, s'il était maintenant 10:00 am et qu'il n'y avait pas de changement d'heure d'été, alors :
getSecondsToday() == 36000 // (3600 * 10)
La fonction devrait fonctionner n’importe quel jour. Autrement dit, il ne devrait pas avoir une valeur codée en dur de « aujourd’hui ».
Pour obtenir le nombre de secondes, nous pouvons générer une date en utilisant le jour et l'heure actuels 00:00:00, puis la soustraire de « maintenant ».
La différence est le nombre de millisecondes depuis le début de la journée, qu'il faut diviser par 1000 pour obtenir les secondes :
fonction getSecondsToday() {
laissez maintenant = new Date();
// crée un objet en utilisant le jour/mois/année en cours
let aujourd'hui = new Date(now.getFullYear(), now.getMonth(), now.getDate());
soit diff = maintenant - aujourd'hui ; // ms différence
return Math.round(diff / 1000); // fait des secondes
}
alerte( getSecondsToday() );Une solution alternative serait d'obtenir des heures/minutes/secondes et de les convertir en secondes :
fonction getSecondsToday() {
soit d = new Date();
return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
}
alerte( getSecondsToday() );importance : 5
Créez une fonction getSecondsToTomorrow() qui renvoie le nombre de secondes jusqu'à demain.
Par exemple, s'il est maintenant 23:00 , alors :
getSecondsToDemain() == 3600
PS La fonction devrait fonctionner n'importe quel jour, le « aujourd'hui » n'est pas codé en dur.
Pour obtenir le nombre de millisecondes jusqu'à demain, nous pouvons à partir de « demain 00:00:00 » soustraire la date actuelle.
Tout d’abord, nous générons ce « demain », puis nous le faisons :
fonction getSecondsToDemain() {
laissez maintenant = new Date();
// date de demain
laissez demain = new Date(now.getFullYear(), now.getMonth(), now.getDate()+1);
soit diff = demain - maintenant ; // différence en ms
return Math.round(diff / 1000); // conversion en secondes
}Solution alternative :
fonction getSecondsToDemain() {
laissez maintenant = new Date();
let hour = now.getHours();
laissez minutes = maintenant.getMinutes();
laissez secondes = maintenant.getSeconds();
soit totalSecondsToday = (heure * 60 + minutes) * 60 + secondes ;
soit totalSecondsInADay = 86400 ;
retourner totalSecondsInADay - totalSecondsToday ;
}Veuillez noter que de nombreux pays appliquent l'heure d'été (DST), il peut donc y avoir des jours de 23 ou 25 heures. Nous souhaiterions peut-être traiter ces jours séparément.
importance : 4
Écrivez une fonction formatDate(date) qui doit formater date comme suit :
Si depuis date s'est écoulée moins d'une seconde, alors "right now" .
Sinon, si date s'est écoulée depuis moins d'une minute, alors "n sec. ago" .
Sinon, si moins d'une heure, alors "m min. ago" .
Sinon, la date complète au format "DD.MM.YY HH:mm" . C'est-à-dire : "day.month.year hours:minutes" , le tout au format à 2 chiffres, par exemple 31.12.16 10:00 .
Par exemple:
alert( formatDate(nouvelle Date(nouvelle Date - 1)) ); // "tout de suite" alert( formatDate(nouvelle Date(nouvelle Date - 30 * 1000)) ); // "il y a 30 secondes" alert( formatDate(nouvelle Date(nouvelle Date - 5 * 60 * 1000)) ); // "il y a 5 minutes" // la date d'hier comme le 31.12.16 20h00 alert( formatDate(nouvelle Date(nouvelle Date - 86400 * 1000)) );
Ouvrez un bac à sable avec des tests.
Pour obtenir l'heure depuis date jusqu'à maintenant, soustrayons les dates.
fonction formatDate(date) {
laissez diff = new Date() - date ; // la différence en millisecondes
if (diff < 1000) { // moins de 1 seconde
renvoie « maintenant » ;
}
laissez sec = Math.floor(diff / 1000); // convertit les différences en secondes
si (sec < 60) {
retourner sec + 'sec. il y a';
}
let min = Math.floor(diff / 60000); // convertit les différences en minutes
si (min < 60) {
retourner min + 'min. il y a';
}
// formate la date
// ajoute des zéros non significatifs au jour/mois/heures/minutes à un chiffre
soit d = date ;
ré = [
'0' + d.getDate(),
'0' + (d.getMonth() + 1),
'' + d.getFullYear(),
'0' + d.getHours(),
'0' + d.getMinutes()
].map(component => composant.slice(-2)); // prend les 2 derniers chiffres de chaque composant
// joint les composants à la date
return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
}
alert( formatDate(nouvelle Date(nouvelle Date - 1)) ); // "tout de suite"
alert( formatDate(nouvelle Date(nouvelle Date - 30 * 1000)) ); // "il y a 30 secondes"
alert( formatDate(nouvelle Date(nouvelle Date - 5 * 60 * 1000)) ); // "il y a 5 minutes"
// date d'hier comme le 31.12.2016 20h00
alert( formatDate(nouvelle Date(nouvelle Date - 86400 * 1000)) );Solution alternative :
fonction formatDate(date) {
let dayOfMonth = date.getDate();
laissez mois = date.getMonth() + 1;
laissez année = date.getFullYear();
let hour = date.getHours();
laissez minutes = date.getMinutes();
laissez diffMs = new Date() - date ;
soit diffSec = Math.round(diffMs / 1000);
soit diffMin = diffSec / 60 ;
soit diffHour = diffMin / 60 ;
// formatage
année = année.toString().slice(-2);
mois = mois < 10 ? '0' + mois : mois ;
jour du mois = jour du mois < 10 ? '0' + jour du mois : jour du mois ;
heure = heure < 10 ? '0' + heure : heure ;
minutes = minutes < 10 ? '0' + minutes : minutes ;
si (diffSec < 1) {
renvoie « maintenant » ;
} sinon si (diffMin < 1) {
renvoie `${diffSec} sec. il y a
} sinon si (diffHour < 1) {
renvoie `${diffMin} min. il y a
} autre {
renvoie `${dayOfMonth}.${month}.${year} ${hour}:${minutes}`
}
}Ouvrez la solution avec des tests dans un bac à sable.