Fecha y hora

Autor：Eve Cole Fecha de actualización：2024-12-24 11:00:57

Conozcamos un nuevo objeto incorporado: Fecha. Almacena la fecha, la hora y proporciona métodos para la gestión de fecha/hora.

Por ejemplo, podemos usarlo para almacenar tiempos de creación/modificación, para medir el tiempo o simplemente para imprimir la fecha actual.

Creación

Para crear un nuevo objeto Date , llame new Date() con uno de los siguientes argumentos:

new Date()

Sin argumentos: cree un objeto Date para la fecha y hora actuales:

 let ahora = nueva fecha();
alerta (ahora); // muestra la fecha/hora actual

new Date(milliseconds)
Cree un objeto Date con el tiempo igual al número de milisegundos (1/1000 de segundo) transcurridos después del 1 de enero de 1970 UTC+0.
```
 // 0 significa 01.01.1970 UTC+0
let Jan01_1970 = nueva fecha (0);
alerta (01 de enero de 1970);

// ahora agrega 24 horas, obtienes 02.01.1970 UTC+0
let Jan02_1970 = nueva fecha (24 * 3600 * 1000);
alerta (02 de enero de 1970);
```
Un número entero que representa la cantidad de milisegundos que han pasado desde principios de 1970 se llama marca de tiempo .
Es una representación numérica ligera de una fecha. Siempre podemos crear una fecha a partir de una marca de tiempo usando new Date(timestamp) y convertir el objeto Date existente en una marca de tiempo usando el método date.getTime() (ver más abajo).
Las fechas anteriores al 01.01.1970 tienen marcas de tiempo negativas, por ejemplo:
```
 // 31 de diciembre de 1969
let Dec31_1969 = nueva fecha (-24 * 3600 * 1000);
alerta (31 de diciembre de 1969);
```
new Date(datestring)

Si hay un único argumento y es una cadena, se analiza automáticamente. El algoritmo es el mismo que usa Date.parse , lo cubriremos más adelante.

 let fecha = nueva fecha ("2017-01-26");
alerta(fecha);
// La hora no está establecida, por lo que se supone que es medianoche GMT y
// se ajusta según la zona horaria en la que se ejecuta el código
// Entonces el resultado podría ser
// Jueves 26 de enero de 2017 11:00:00 GMT+1100 (hora de verano del este de Australia)
// o
// miércoles 25 de enero de 2017 16:00:00 GMT-0800 (hora estándar del Pacífico)

new Date(year, month, date, hours, minutes, seconds, ms)
Cree la fecha con los componentes dados en la zona horaria local. Sólo los dos primeros argumentos son obligatorios.
- El year debe tener 4 dígitos. Por compatibilidad, también se aceptan 2 dígitos y se consideran 19xx , por ejemplo, 98 es lo mismo que 1998 aquí, pero se recomienda encarecidamente utilizar siempre 4 dígitos.
- El recuento month comienza con 0 (enero) y llega hasta 11 (diciembre).
- El parámetro date es en realidad el día del mes; si está ausente, se supone 1 .
- Si no hay hours/minutes/seconds/ms , se supone que son iguales a 0 .
Por ejemplo:
```
 nueva fecha (2011, 0, 1, 0, 0, 0, 0); // 1 de enero de 2011, 00:00:00
nueva fecha (2011, 0, 1); // lo mismo, las horas, etc. son 0 por defecto
```
La precisión máxima es 1 ms (1/1000 seg):
```
 let fecha = nueva fecha (2011, 0, 1, 2, 3, 4, 567);
alerta (fecha); // 01.01.2011, 02:03:04.567
```

Componentes de fecha de acceso

Existen métodos para acceder al año, mes, etc. desde el objeto Date :

obtenerAñoCompleto()
Obtener el año (4 dígitos)
obtenerMes()
Obtenga el mes, del 0 al 11 .
obtener fecha()
Obtenga el día del mes, del 1 al 31, el nombre del método parece un poco extraño.
getHoras(), getMinutos(), getSeconds(), getMillisegundos()
Obtenga los componentes de tiempo correspondientes.

No getYear() , sino getFullYear()

Muchos motores de JavaScript implementan un método no estándar getYear() . Este método está en desuso. A veces devuelve el año de 2 dígitos. Por favor nunca lo uses. Existe getFullYear() para el año.

Además, podemos obtener un día de la semana:

obtenerDía()
Obtenga el día de la semana, de 0 (domingo) a 6 (sábado). El primer día siempre es domingo, en algunos países no es así, pero no se puede cambiar.

Todos los métodos anteriores devuelven los componentes relativos a la zona horaria local.

También están sus contrapartes UTC, que devuelven día, mes, año, etc. para la zona horaria UTC+0: getUTCFullYear(), getUTCMonth(), getUTCDay(). Simplemente inserte la "UTC" justo después de "get" .

Si su zona horaria local cambia con respecto a UTC, entonces el siguiente código muestra horas diferentes:

 // fecha actual
let fecha = nueva fecha();

// la hora en tu zona horaria actual
alerta( fecha.getHours() );

// la hora en la zona horaria UTC+0 (hora de Londres sin horario de verano)
alerta( fecha.getUTCHours() );

Además de los métodos indicados, hay dos métodos especiales que no tienen una variante UTC:

obtenerTiempo()
Devuelve la marca de tiempo de la fecha: una cantidad de milisegundos transcurridos desde el 1 de enero de 1970 UTC+0.
getTimezoneOffset()

Devuelve la diferencia entre UTC y la zona horaria local, en minutos:

 // si estás en la zona horaria UTC-1, genera 60
// si estás en la zona horaria UTC+3, genera -180
alerta (nueva fecha().getTimezoneOffset());

Configuración de componentes de fecha

Los siguientes métodos permiten configurar componentes de fecha/hora:

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) (establece la fecha completa en milisegundos desde el 01.01.1970 UTC)

Cada uno de ellos, excepto setTime() tiene una variante UTC, por ejemplo: setUTCHours() .

Como podemos ver, algunos métodos pueden configurar varios componentes a la vez, por ejemplo setHours . Los componentes que no se mencionan no se modifican.

Por ejemplo:

 let hoy = nueva fecha();

hoy.setHours(0);
alerta (hoy); // todavía hoy, pero la hora se cambió a 0

hoy.setHours(0, 0, 0, 0);
alerta (hoy); // todavía hoy, ahora a las 00:00:00 en punto.

Autocorrección

La autocorrección es una característica muy útil de los objetos Date . Podemos establecer valores fuera de rango y se ajustará automáticamente.

Por ejemplo:

 let fecha = nueva fecha (2013, 0, 32); // 32 de enero de 2013 ?!?
alerta(fecha); // ...¡es el 1 de febrero de 2013!

Los componentes con fecha fuera de rango se distribuyen automáticamente.

Digamos que necesitamos aumentar la fecha "28 de febrero de 2016" en 2 días. Puede ser “2 de marzo” o “1 de marzo” en caso de un año bisiesto. No necesitamos pensar en eso. Solo agrega 2 días. El objeto Date hará el resto:

 let fecha = nueva fecha (2016, 1, 28);
fecha.setDate(fecha.getDate() + 2);

alerta (fecha); // 1 de marzo de 2016

Esa característica se utiliza a menudo para obtener la fecha después de un período de tiempo determinado. Por ejemplo, obtengamos la fecha de “70 segundos después de ahora”:

 let fecha = nueva fecha();
fecha.setSeconds(fecha.getSeconds() + 70);

alerta (fecha); //muestra la fecha correcta

También podemos establecer valores cero o incluso negativos. Por ejemplo:

 let fecha = nueva fecha (2016, 0, 2); // 2 de enero de 2016

fecha.setDate(1); // establece el día 1 del mes
alerta (fecha);

fecha.setDate(0); // el día mínimo es 1, por lo que se supone el último día del mes anterior
alerta (fecha); // 31 de diciembre de 2015

Fecha al número, diferencia de fecha

Cuando un objeto Date se convierte en número, se convierte en la misma marca de tiempo que date.getTime() :

 let fecha = nueva fecha();
alerta(+fecha); // el número de milisegundos, igual que date.getTime()

El efecto secundario importante: las fechas se pueden restar, el resultado es su diferencia en ms.

Eso se puede utilizar para mediciones de tiempo:

 dejar empezar = nueva fecha(); //comenzamos a medir el tiempo

// hacer el trabajo
para (sea i = 0; i < 100000; i++) {
  let doSomething = i * i * i;
}

let end = nueva fecha(); // finaliza el tiempo de medición

alert(`El bucle tardó ${end - start} ms`);

Fecha.ahora()

Si solo queremos medir el tiempo, no necesitamos el objeto Date .

Hay un método especial Date.now() que devuelve la marca de tiempo actual.

Es semánticamente equivalente a new Date().getTime() , pero no crea un objeto Date intermedio. Por lo tanto, es más rápido y no ejerce presión sobre la recolección de basura.

Se utiliza principalmente por conveniencia o cuando el rendimiento importa, como en juegos en JavaScript u otras aplicaciones especializadas.

Entonces esto probablemente sea mejor:

 dejar empezar = Fecha.ahora(); // cuenta de milisegundos desde el 1 de enero de 1970

// hacer el trabajo
para (sea i = 0; i < 100000; i++) {
  let doSomething = i * i * i;
}

let end = Fecha.ahora(); // hecho

alert(`El bucle tardó ${end - start} ms`); // resta números, no fechas

Evaluación comparativa

Si queremos un punto de referencia confiable de la función que consume mucha CPU, debemos tener cuidado.

Por ejemplo, midamos dos funciones que calculan la diferencia entre dos fechas: ¿cuál es más rápida?

Estas mediciones de desempeño a menudo se denominan “puntos de referencia”.

 // tenemos fecha1 y fecha2, ¿qué función devuelve más rápido su diferencia en ms?
función diffSubtract(fecha1, fecha2) {
  fecha de regreso2 - fecha1;
}

// o
función diffGetTime(fecha1, fecha2) {
  devolver fecha2.getTime() - fecha1.getTime();
}

Estos dos hacen exactamente lo mismo, pero uno de ellos usa un date.getTime() explícito para obtener la fecha en ms, y el otro se basa en una transformación de fecha a número. Su resultado es siempre el mismo.

Entonces, ¿cuál es más rápido?

La primera idea puede ser ejecutarlos muchas veces seguidas y medir la diferencia horaria. Para nuestro caso, las funciones son muy simples, por lo que tenemos que hacerlo al menos 100000 veces.

Midamos:

 función diffSubtract(fecha1, fecha2) {
  fecha de regreso2 - fecha1;
}

función diffGetTime(fecha1, fecha2) {
  devolver fecha2.getTime() - fecha1.getTime();
}

banco de funciones (f) {
  let fecha1 = nueva fecha(0);
  let fecha2 = nueva fecha();

  dejar empezar = Fecha.ahora();
  for (sea i = 0; i < 100000; i++) f(fecha1, fecha2);
  return Date.now() - inicio;
}

alert( 'Tiempo de diffSubtract: ' + banco(diffSubtract) + 'ms' );
alert( 'Tiempo de diffGetTime: ' + banco(diffGetTime) + 'ms' );

¡Guau! ¡Usar getTime() es mucho más rápido! Esto se debe a que no hay conversión de tipos, por lo que es mucho más fácil de optimizar para los motores.

Bien, tenemos algo. Pero ese aún no es un buen punto de referencia.

Imagine que en el momento de ejecutar bench(diffSubtract) la CPU estaba haciendo algo en paralelo y estaba consumiendo recursos. Y cuando se ejecuta bench(diffGetTime) ese trabajo ha terminado.

Un escenario bastante real para un sistema operativo multiproceso moderno.

Como resultado, el primer punto de referencia tendrá menos recursos de CPU que el segundo. Eso puede conducir a resultados incorrectos.

Para obtener evaluaciones comparativas más confiables, se debe volver a ejecutar todo el paquete de evaluaciones comparativas varias veces.

Por ejemplo, así:

 función diffSubtract(fecha1, fecha2) {
  fecha de regreso2 - fecha1;
}

función diffGetTime(fecha1, fecha2) {
  devolver fecha2.getTime() - fecha1.getTime();
}

banco de funciones (f) {
  let fecha1 = nueva fecha(0);
  let fecha2 = nueva fecha();

  dejar empezar = Fecha.ahora();
  for (sea i = 0; i < 100000; i++) f(fecha1, fecha2);
  return Date.now() - inicio;
}

dejar tiempo1 = 0;
dejar tiempo2 = 0;

// ejecuta bench(diffSubtract) y bench(diffGetTime) cada 10 veces alternando
para (sea i = 0; i < 10; i++) {
  tiempo1 += banco(diffSubtract);
  tiempo2 += banco(diffGetTime);
}

alerta( 'Tiempo total para diffSubtract: ' + tiempo1 );
alert( 'Tiempo total para diffGetTime: ' + time2 );

Los motores JavaScript modernos comienzan a aplicar optimizaciones avanzadas solo al "código activo" que se ejecuta muchas veces (no es necesario optimizar cosas que rara vez se ejecutan). Entonces, en el ejemplo anterior, las primeras ejecuciones no están bien optimizadas. Es posible que queramos agregar una carrera de calentamiento:

 // agregado para "calentar" antes del ciclo principal
banco(diffSubtract);
banco(diffGetTime);

// ahora punto de referencia
para (sea i = 0; i < 10; i++) {
  tiempo1 += banco(diffSubtract);
  tiempo2 += banco(diffGetTime);
}

Tenga cuidado al hacer microbenchmarking

Los motores JavaScript modernos realizan muchas optimizaciones. Pueden modificar los resultados de las "pruebas artificiales" en comparación con el "uso normal", especialmente cuando comparamos algo muy pequeño, como cómo funciona un operador o una función incorporada. Entonces, si realmente desea comprender el rendimiento, estudie cómo funciona el motor JavaScript. Y entonces probablemente no necesitará ningún microbenchmarking.

El gran paquete de artículos sobre V8 se puede encontrar en https://mrale.ph.

Date.parse de una cadena

El método Date.parse(str) puede leer una fecha de una cadena.

El formato de la cadena debe ser: YYYY-MM-DDTHH:mm:ss.sssZ , donde:

YYYY-MM-DD – es la fecha: año-mes-día.
El carácter "T" se utiliza como delimitador.
HH:mm:ss.sss – es el tiempo: horas, minutos, segundos y milisegundos.
La parte 'Z' opcional indica la zona horaria en el formato +-hh:mm . Una sola letra Z significaría UTC+0.

También son posibles variantes más cortas, como YYYY-MM-DD o YYYY-MM o incluso YYYY .

La llamada a Date.parse(str) analiza la cadena en el formato dado y devuelve la marca de tiempo (número de milisegundos desde el 1 de enero de 1970 UTC+0). Si el formato no es válido, devuelve NaN .

Por ejemplo:

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

alerta (ms); // 1327611110417 (marca de tiempo)

Podemos crear instantáneamente un new Date a partir de la marca de tiempo:

 let fecha = nueva fecha (Fecha.parse('2012-01-26T13:51:50.417-07:00'));

alerta(fecha);

Resumen

La fecha y la hora en JavaScript se representan con el objeto Fecha. No podemos crear “única fecha” o “única hora”: los objetos Date siempre llevan ambas.
Los meses se cuentan desde cero (sí, enero es un mes cero).
Los días de la semana en getDay() también se cuentan desde cero (es decir, el domingo).
Date se corrige automáticamente cuando se configuran componentes fuera de rango. Bueno para sumar/restar días/meses/horas.
Las fechas se pueden restar, dando su diferencia en milisegundos. Esto se debe a que una Date se convierte en la marca de tiempo cuando se convierte en un número.
Utilice Date.now() para obtener rápidamente la marca de tiempo actual.

Tenga en cuenta que, a diferencia de muchos otros sistemas, las marcas de tiempo en JavaScript están en milisegundos, no en segundos.

A veces necesitamos mediciones de tiempo más precisas. JavaScript en sí no tiene una forma de medir el tiempo en microsegundos (1 millonésima de segundo), pero la mayoría de los entornos sí lo proporcionan. Por ejemplo, el navegador tiene performance.now() que proporciona el número de milisegundos desde el inicio de la carga de la página con precisión de microsegundos (3 dígitos después del punto):

 alert(`La carga comenzó hace ${rendimiento.now()}ms`);
// Algo como: "La carga comenzó hace 34731.26000000001ms"
// .26 son microsegundos (260 microsegundos)
// más de 3 dígitos después del punto decimal son errores de precisión, sólo los primeros 3 son correctos

Node.js tiene módulo microtime y otras formas. Técnicamente, casi cualquier dispositivo y entorno permite obtener más precisión, pero no está en Date .

Tareas

crear una fecha

importancia: 5

Cree un objeto Date para la fecha: 20 de febrero de 2012, 3:12 a. m. La zona horaria es local.

Muéstralo usando alert .

El new Date utiliza la zona horaria local. Entonces, lo único importante que debes recordar es que los meses comienzan desde cero.

Entonces febrero tiene el número 1.

Aquí hay un ejemplo con números como componentes de fecha:

 //nueva fecha(año, mes, fecha, hora, minuto, segundo, milisegundo)
sea d1 = nueva fecha (2012, 1, 20, 3, 12);
alerta (d1);

También podríamos crear una fecha a partir de una cadena, como esta:

 //nueva fecha(cadena de datos)
let d2 = nueva fecha ("2012-02-20T03:12");
alerta (d2);

Mostrar un día laborable

importancia: 5

Escriba una función getWeekDay(date) para mostrar el día de la semana en formato corto: 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'.

Por ejemplo:

 let fecha = nueva fecha (2012, 0, 3);  // 3 de enero de 2012
alerta( getWeekDay(fecha) );        // debería generar "TU"

Abra una caja de arena con pruebas.

El método date.getDay() devuelve el número del día de la semana, comenzando desde el domingo.

Hagamos una serie de días de la semana, de modo que podamos obtener el nombre correcto del día por su número:

 función obtenerDíaSemana(fecha) {
  let días = ['SU', 'MO', 'TU', 'NOSOTROS', 'TH', 'FR', 'SA'];

  días de retorno[date.getDay()];
}

let fecha = nueva fecha (2014, 0, 3); // 3 de enero de 2014
alerta( getWeekDay(fecha) ); // franco

Abra la solución con pruebas en un sandbox.

día laborable europeo

importancia: 5

Los países europeos tienen días de la semana que comienzan con el lunes (número 1), luego el martes (número 2) y hasta el domingo (número 7). Escriba una función getLocalDay(date) que devuelva el día de la semana "europeo" para date .

 let fecha = nueva fecha (2012, 0, 3);  // 3 de enero de 2012
alerta( getLocalDay(fecha) );       // martes, debería mostrar 2

Abra una caja de arena con pruebas.

 función getLocalDay(fecha) {

  dejar día = fecha.getDay();

  if (día == 0) { // el día laborable 0 (domingo) es 7 en europeo
    día = 7;
  }

  día de regreso;
}

Abra la solución con pruebas en un sandbox.

¿Qué día del mes fue hace muchos días?

importancia: 4

Cree una función getDateAgo(date, days) para devolver el día del mes hace days a partir de la date .

Por ejemplo, si hoy es el día 20, entonces getDateAgo(new Date(), 1) debería ser el 19 y getDateAgo(new Date(), 2) debería ser el 18.

Debería funcionar de manera confiable durante days=365 o más:

 let fecha = nueva fecha (2015, 0, 2);

alerta( getDateAgo(fecha, 1) ); // 1, (1 de enero de 2015)
alerta( getDateAgo(fecha, 2) ); // 31, (31 de diciembre de 2014)
alerta( getDateAgo(fecha, 365) ); // 2, (2 de enero de 2014)

PD: La función no debe modificar la date dada.

Abra una caja de arena con pruebas.

La idea es simple: restar un número determinado de días a date :

 función getDateAgo(fecha, días) {
  fecha.setDate(fecha.getDate() - días);
  fecha de retorno.getDate();
}

…Pero la función no debería cambiar date . Eso es algo importante, porque el código externo que nos da la fecha no espera que cambie.

Para implementarlo clonemos la fecha, así:

 función getDateAgo(fecha, días) {
  let dateCopy = nueva Fecha(fecha);

  dateCopy.setDate(date.getDate() - días);
  fecha de retornoCopy.getDate();
}

let fecha = nueva fecha (2015, 0, 2);

alerta( getDateAgo(fecha, 1) ); // 1, (1 de enero de 2015)
alerta( getDateAgo(fecha, 2) ); // 31, (31 de diciembre de 2014)
alerta( getDateAgo(fecha, 365) ); // 2, (2 de enero de 2014)

Abra la solución con pruebas en un sandbox.

¿Último día del mes?

importancia: 5

Escribe una función getLastDayOfMonth(year, month) que devuelva el último día del mes. A veces es el 30, 31 o incluso el 28/29 de febrero.

Parámetros:

year : año de cuatro dígitos, por ejemplo 2012.
month – mes, de 0 a 11.

Por ejemplo, getLastDayOfMonth(2012, 1) = 29 (año bisiesto, febrero).

Abra una caja de arena con pruebas.

Creemos una fecha usando el próximo mes, pero pasemos cero como día:

 función getLastDayOfMonth(año, mes) {
  let fecha = nueva Fecha(año, mes + 1, 0);
  fecha de retorno.getDate();
}

alerta( getLastDayOfMonth(2012, 0) ); // 31
alerta( getLastDayOfMonth(2012, 1) ); // 29
alerta( getLastDayOfMonth(2013, 1) ); // 28

Normalmente, las fechas empiezan en 1, pero técnicamente podemos pasar cualquier número, la fecha se ajustará automáticamente. Entonces, cuando pasamos 0, significa "un día antes del primer día del mes", en otras palabras: "el último día del mes anterior".

Abra la solución con pruebas en un sandbox.

¿Cuantos segundos han pasado hoy?

importancia: 5

Escribe una función getSecondsToday() que devuelva el número de segundos desde el comienzo de hoy.

Por ejemplo, si ahora fueran 10:00 am y no hubiera horario de verano, entonces:

 getSecondsHoy() == 36000 // (3600 * 10)

La función debería funcionar cualquier día. Es decir, no debería tener un valor codificado de "hoy".

Para obtener la cantidad de segundos, podemos generar una fecha usando el día y la hora actuales 00:00:00, luego restarla de "ahora".

La diferencia es el número de milisegundos desde el inicio del día, que debemos dividir por 1000 para obtener segundos:

 función obtenerSecondsHoy() {
  let ahora = nueva fecha();

  // crea un objeto usando el día/mes/año actual
  let hoy = nueva Fecha(now.getFullYear(), now.getMonth(), now.getDate());

  let diff = ahora - hoy; // ms diferencia
  devolver Math.round(diff/1000); // hacer segundos
}

alerta( getSecondsToday() );

Una solución alternativa sería obtener horas/minutos/segundos y convertirlos a segundos:

 función obtenerSecondsHoy() {
  let d = nueva fecha();
  return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
}

alerta( getSecondsToday() );

¿Cuántos segundos faltan para mañana?

importancia: 5

Cree una función getSecondsToTomorrow() que devuelva el número de segundos hasta mañana.

Por ejemplo, si ahora son 23:00 , entonces:

 obtener segundos para mañana() == 3600

PD: La función debería funcionar cualquier día, el "hoy" no está codificado.

Para obtener el número de milisegundos hasta mañana, podemos restar la fecha actual a “mañana 00:00:00”.

Primero generamos ese “mañana”, y luego lo hacemos:

 función obtenerSecondsToMañana() {
  let ahora = nueva fecha();

  // fecha de mañana
  let mañana = nueva Fecha(now.getFullYear(), now.getMonth(), now.getDate()+1);

  let diff = mañana - ahora; // diferencia en ms
  devolver Math.round(diff/1000); // convertir a segundos
}

Solución alternativa:

 función obtenerSecondsToMañana() {
  let ahora = nueva fecha();
  let hora = ahora.getHours();
  let minutos = now.getMinutes();
  let segundos = now.getSeconds();
  let totalSecondsToday = (hora * 60 + minutos) * 60 + segundos;
  let totalSecondsInADay = 86400;

  devolver totalSecondsInADay - totalSecondsToday;
}

Tenga en cuenta que muchos países tienen horario de verano (DST), por lo que puede haber días con 23 o 25 horas. Es posible que deseemos tratar esos días por separado.

Formatear la fecha relativa

importancia: 4

Escriba una función formatDate(date) que debería formatear date de la siguiente manera:

Si desde date pasó menos de 1 segundo, entonces "right now" .
De lo contrario, si desde date pasó menos de 1 minuto, entonces "n sec. ago" .
De lo contrario, si es menos de una hora, entonces "m min. ago" .
En caso contrario, la fecha completa en el formato "DD.MM.YY HH:mm" . Es decir: "day.month.year hours:minutes" , todo en formato de 2 dígitos, por ejemplo, 31.12.16 10:00 .

Por ejemplo:

 alerta (formatoFecha (nueva fecha (nueva fecha - 1))); // "ahora mismo"

alerta (formatoFecha (nueva fecha (nueva fecha - 30 * 1000))); // "Hace 30 segundos"

alerta (formatoFecha (nueva fecha (nueva fecha - 5 * 60 * 1000))); // "Hace 5 minutos"

// fecha de ayer como 31.12.16 20:00
alerta (formatoFecha (nueva fecha (nueva fecha - 86400 * 1000)));

Abra una caja de arena con pruebas.

Para obtener la hora desde date hasta ahora, restemos las fechas.

 función formatoFecha(fecha) {
  let diff = nueva Fecha() - fecha; // la diferencia en milisegundos

  if (diff < 1000) { // menos de 1 segundo
    devolver 'ahora mismo';
  }

  let sec = Math.floor(diff / 1000); // convierte la diferencia a segundos

  si (seg < 60) {
    devolver seg + ' seg. atrás';
  }

  let min = Math.floor(diff / 60000); // convierte diferencias a minutos
  si (mín < 60) {
    devolver min + 'min. atrás';
  }

  // formatea la fecha
  // agrega ceros a la izquierda al día/mes/horas/minutos de un solo dígito
  sea d = fecha;
  re = [
    '0' + d.getDate(),
    '0' + (d.getMonth() + 1),
    '' + d.getAñoCompleto(),
    '0' + d.getHours(),
    '0' + d.getMinutos()
  ].map(componente => componente.slice(-2)); // toma los últimos 2 dígitos de cada componente

  // unir los componentes a la fecha
  return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
}

alerta (formatoFecha (nueva fecha (nueva fecha - 1))); // "ahora mismo"

alerta (formatoFecha (nueva fecha (nueva fecha - 30 * 1000))); // "Hace 30 segundos"

alerta (formatoFecha (nueva fecha (nueva fecha - 5 * 60 * 1000))); // "Hace 5 minutos"

// fecha de ayer como 31.12.2016 20:00
alerta (formatoFecha (nueva fecha (nueva fecha - 86400 * 1000)));

Solución alternativa:

 función formatoFecha(fecha) {
  let díaDeMes = fecha.getDate();
  let mes = fecha.getMonth() + 1;
  let año = fecha.getFullYear();
  let hora = fecha.getHours();
  let minutos = fecha.getMinutes();
  let diffMs = nueva Fecha() - fecha;
  let diffSec = Math.round(diffMs / 1000);
  let diffMin = diffSec / 60;
  let diffHour = diffMin / 60;

  // formateo
  año = año.toString().slice(-2);
  mes = mes < 10 ? '0' + mes : mes;
  díaDelMes = díaDelMes < 10 ? '0' + díadelmes: díadelmes;
  hora = hora < 10 ? '0' + hora : hora;
  minutos = minutos < 10 ? '0' + minutos: minutos;

  si (segdiff < 1) {
    devolver 'ahora mismo';
  } si no (diffMin < 1) {
    devuelve `${diffSec} seg. hace`
  } más si (diffHour < 1) {
    devolver `${diffMin} mín. hace`
  } demás {
    devolver `${díaDeMes}.${mes}.${año} ${hora}:${minutos}`
  }
}

Abra la solución con pruebas en un sandbox.