JavaScript
Fecha

Sintaxis

• nueva fecha ();
• nueva fecha (valor);
• nueva fecha (dateAsString);
• nueva Fecha (año, mes [, día [, hora [, minuto [, segundo [, milisegundos]]]]);

Parámetros

Obtén la hora y fecha actual

Use new Date() para generar un nuevo objeto Date que contenga la fecha y la hora actuales.

Tenga en cuenta que la Date() llamada sin argumentos es equivalente a la new Date(Date.now()) .

Una vez que tenga un objeto de fecha, puede aplicar cualquiera de los varios métodos disponibles para extraer sus propiedades (por ejemplo, getFullYear() para obtener el año de 4 dígitos).

A continuación se presentan algunos métodos comunes de fecha.

Obtener el año en curso

var year = (new Date()).getFullYear();
console.log(year);
// Sample output: 2016 

Obtén el mes actual

var month = (new Date()).getMonth();
console.log(month);
// Sample output: 0 

Tenga en cuenta que 0 = enero. Esto se debe a que los meses van de 0 a 11 , por lo que a menudo es conveniente agregar +1 al índice.

Obtener el dia actual

var day = (new Date()).getDate();
console.log(day);
// Sample output: 31

Obtener la hora actual

var hours = (new Date()).getHours();
console.log(hours);
// Sample output: 10

Obtén los minutos actuales

var minutes = (new Date()).getMinutes();
console.log(minutes);
// Sample output: 39

Obtén los segundos actuales

var seconds = (new Date()).getSeconds();
console.log(second);
// Sample output: 48

Obtén los milisegundos actuales

Para obtener los milisegundos (que van de 0 a 999) de una instancia de un objeto Date , use su método getMilliseconds .

var milliseconds = (new Date()).getMilliseconds();
console.log(milliseconds);
 // Output: milliseconds right now

Convierte la hora y fecha actuales en una cadena legible por humanos

var now = new Date();
// convert date to a string in UTC timezone format:
console.log(now.toUTCString());
// Output: Wed, 21 Jun 2017 09:13:01 GMT

El método estático Date.now() devuelve el número de milisegundos que han transcurrido desde el 1 de enero de 1970 a las 00:00:00 UTC. Para obtener la cantidad de milisegundos que han transcurrido desde ese momento utilizando una instancia de un objeto Date , use su método getTime .

// get milliseconds using static method now of Date
console.log(Date.now());

// get milliseconds using method getTime of Date instance
console.log((new Date()).getTime());

Crear un nuevo objeto de fecha

Para crear un nuevo objeto Date use el constructor Date() :

• sin argumentos

  Date() crea una instancia de Date contiene la hora actual (hasta milisegundos) y la fecha.

• con un argumento entero

  Date(m) crea una instancia de Date contiene la hora y la fecha correspondientes a la hora de la época (1 de enero de 1970 UTC) más m milisegundos. Ejemplo: new Date(749019369738) da la fecha Sun, 26 Sep 1993 04:56:09 GMT .

• con un argumento de cadena

  Date(dateString) devuelve el objeto Date que resulta después de analizar dateString con Date.parse .

• con dos o más argumentos enteros

  Date(i1, i2, i3, i4, i5, i6) lee los argumentos como año, mes, día, horas, minutos, segundos, milisegundos y crea una instancia del objeto Date correspondiente. Tenga en cuenta que el mes tiene un índice de 0 en JavaScript, por lo que 0 significa enero y 11 significa diciembre. Ejemplo: new Date(2017, 5, 1) da el 1 de junio de 2017 .

Fechas de exploración

Tenga en cuenta que estos ejemplos se generaron en un navegador en la zona horaria central de los EE. UU., Durante el horario de verano, como lo demuestra el código. Cuando la comparación con UTC fue instructiva, se Date.prototype.toISOString() para mostrar la fecha y la hora en UTC (la Z en la cadena con formato indica UTC).

// Creates a Date object with the current date and time from the 
// user's browser
var now = new Date();
now.toString() === 'Mon Apr 11 2016 16:10:41 GMT-0500 (Central Daylight Time)' 
// true
// well, at the time of this writing, anyway

// Creates a Date object at the Unix Epoch (i.e., '1970-01-01T00:00:00.000Z')
var epoch = new Date(0);
epoch.toISOString() === '1970-01-01T00:00:00.000Z' // true

// Creates a Date object with the date and time 2,012 milliseconds 
// after the Unix Epoch (i.e., '1970-01-01T00:00:02.012Z').
var ms = new Date(2012); 
date2012.toISOString() === '1970-01-01T00:00:02.012Z' // true

// Creates a Date object with the first day of February of the year 2012 
// in the local timezone.
var one = new Date(2012, 1);
one.toString() === 'Wed Feb 01 2012 00:00:00 GMT-0600 (Central Standard Time)' 
// true

// Creates a Date object with the first day of the year 2012 in the local 
// timezone.
// (Months are zero-based) 
var zero = new Date(2012, 0);
zero.toString() === 'Sun Jan 01 2012 00:00:00 GMT-0600 (Central Standard Time)' 
// true

// Creates a Date object with the first day of the year 2012, in UTC.
var utc = new Date(Date.UTC(2012, 0));
utc.toString() === 'Sat Dec 31 2011 18:00:00 GMT-0600 (Central Standard Time)'
// true
utc.toISOString() === '2012-01-01T00:00:00.000Z'
// true

// Parses a string into a Date object (ISO 8601 format added in ECMAScript 5.1)
// Implementations should assumed UTC because of ISO 8601 format and Z designation
var iso = new Date('2012-01-01T00:00:00.000Z');
iso.toISOString() === '2012-01-01T00:00:00.000Z' // true

// Parses a string into a Date object (RFC in JavaScript 1.0)
var local = new Date('Sun, 01 Jan 2012 00:00:00 -0600');
local.toString() === 'Sun Jan 01 2012 00:00:00 GMT-0600 (Central Standard Time)'
// true

// Parses a string in no particular format, most of the time. Note that parsing
// logic in these cases is very implementation-dependent, and therefore can vary
// across browsers and versions.
var anything = new Date('11/12/2012'); 
anything.toString() === 'Mon Nov 12 2012 00:00:00 GMT-0600 (Central Standard Time)'
// true, in Chrome 49 64-bit on Windows 10 in the en-US locale. Other versions in 
// other locales may get a different result.

// Rolls values outside of a specified range to the next value.
var rollover = new Date(2012, 12, 32, 25, 62, 62, 1023);
rollover.toString() === 'Sat Feb 02 2013 02:03:03 GMT-0600 (Central Standard Time)'
// true; note that the month rolled over to Feb; first the month rolled over to 
// Jan based on the month 12 (11 being December), then again because of the day 32
// (January having 31 days).

// Special dates for years in the range 0-99
var special1 = new Date(12, 0);
special1.toString() === 'Mon Jan 01 1912 00:00:00 GMT-0600 (Central Standard Time)`
// true

// If you actually wanted to set the year to the year 12 CE, you'd need to use the
// setFullYear() method:
special1.setFullYear(12);
special1.toString() === 'Sun Jan 01   12 00:00:00 GMT-0600 (Central Standard Time)`
// true

Convertir a JSON

var date1 = new Date();
date1.toJSON();

Devoluciones: "2016-04-14T23: 49: 08.596Z"

Creando una fecha desde UTC

De forma predeterminada, un objeto Date se crea como hora local. Esto no siempre es deseable, por ejemplo, cuando se comunica una fecha entre un servidor y un cliente que no residen en la misma zona horaria. En este escenario, uno no quiere preocuparse por las zonas horarias hasta que la fecha deba mostrarse en la hora local, si es que se requiere.

El problema

En este problema, queremos comunicar una fecha específica (día, mes, año) con alguien en una zona horaria diferente. La primera implementación usa ingenuamente los tiempos locales, lo que resulta en resultados incorrectos. La segunda implementación usa fechas UTC para evitar las zonas horarias donde no son necesarias.

Enfoque ingenuo con resultados equivocados

function formatDate(dayOfWeek, day, month, year) {
  var daysOfWeek = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
  var months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
  return daysOfWeek[dayOfWeek] + " " + months[month] + " " + day + " " + year;
}

//Foo lives in a country with timezone GMT + 1
var birthday = new Date(2000,0,1);
console.log("Foo was born on: " + formatDate(birthday.getDay(), birthday.getDate(),
      birthday.getMonth(), birthday.getFullYear()));

sendToBar(birthday.getTime());

Salida de muestra: Foo was born on: Sat Jan 1 2000

//Meanwhile somewhere else...

//Bar lives in a country with timezone GMT - 1
var birthday = new Date(receiveFromFoo());
console.log("Foo was born on: " + formatDate(birthday.getDay(), birthday.getDate(),
      birthday.getMonth(), birthday.getFullYear()));

Salida de muestra: Foo was born on: Fri Dec 31 1999

Y así, Bar siempre creería que Foo nació el último día de 1999.

Enfoque correcto

function formatDate(dayOfWeek, day, month, year) {
  var daysOfWeek = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
  var months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
  return daysOfWeek[dayOfWeek] + " " + months[month] + " " + day + " " + year;
}

//Foo lives in a country with timezone GMT + 1
var birthday = new Date(Date.UTC(2000,0,1));
console.log("Foo was born on: " + formatDate(birthday.getUTCDay(), birthday.getUTCDate(),
      birthday.getUTCMonth(), birthday.getUTCFullYear()));

sendToBar(birthday.getTime());

Salida de muestra: Foo was born on: Sat Jan 1 2000

//Meanwhile somewhere else...

//Bar lives in a country with timezone GMT - 1
var birthday = new Date(receiveFromFoo());
console.log("Foo was born on: " + formatDate(birthday.getUTCDay(), birthday.getUTCDate(), 
      birthday.getUTCMonth(), birthday.getUTCFullYear()));

Salida de muestra: Foo was born on: Sat Jan 1 2000

Creando una fecha desde UTC

Si uno quiere crear un objeto Date basado en UTC o GMT, se puede usar el método Date.UTC(...) . Utiliza los mismos argumentos que el constructor de Date más largo. Este método devolverá un número que representa el tiempo transcurrido desde el 1 de enero de 1970, 00:00:00 UTC.

console.log(Date.UTC(2000,0,31,12));

Salida de muestra: 949320000000

var utcDate = new Date(Date.UTC(2000,0,31,12));
console.log(utcDate);

Salida de muestra: Mon Jan 31 2000 13:00:00 GMT+0100 (West-Europa (standaardtijd))

Como era de esperar, la diferencia entre la hora UTC y la hora local es, de hecho, el desplazamiento de zona horaria convertido en milisegundos.

var utcDate = new Date(Date.UTC(2000,0,31,12));
var localDate = new Date(2000,0,31,12);

console.log(localDate - utcDate === utcDate.getTimezoneOffset() * 60 * 1000);

Salida de muestra: true

Cambiar un objeto de fecha

Todos los modificadores de objetos de Date , como setDate(...) y setFullYear(...) tienen un equivalente toma un argumento en la hora UTC en lugar de en la hora local.

var date = new Date();
date.setUTCFullYear(2000,0,31);
date.setUTCHours(12,0,0,0);
console.log(date);

Salida de muestra: Mon Jan 31 2000 13:00:00 GMT+0100 (West-Europa (standaardtijd))

Los otros modificadores específicos de UTC son .setUTCMonth() , .setUTCDate() (para el día del mes), .setUTCMinutes() , .setUTCSeconds() y .setUTCMilliseconds() .

Evitar la ambigüedad con getTime () y setTime ()

Cuando se requieren los métodos anteriores para diferenciar la ambigüedad en las fechas, generalmente es más fácil comunicar una fecha como el tiempo transcurrido desde el 1 de enero de 1970, a las 00:00:00 UTC. Este número único representa un solo punto en el tiempo y se puede convertir a la hora local siempre que sea necesario.

var date = new Date(Date.UTC(2000,0,31,12));
var timestamp = date.getTime();
//Alternatively
var timestamp2 = Date.UTC(2000,0,31,12);
console.log(timestamp === timestamp2);

Salida de muestra: true

//And when constructing a date from it elsewhere...
var otherDate = new Date(timestamp);

//Represented as an universal date
console.log(otherDate.toUTCString());
//Represented as a local date
console.log(otherDate);

Salida de muestra:

Mon, 31 Jan 2000 12:00:00 GMT
Mon Jan 31 2000 13:00:00 GMT+0100 (West-Europa (standaardtijd))

Convertir a un formato de cadena

Convertir a cadena

var date1 = new Date();
date1.toString();

Devoluciones: "Viernes 15 de abril de 2016 07:48:48 GMT-0400 (Hora de verano del Este)"

Convertir a cadena de tiempo

var date1 = new Date();
date1.toTimeString();

Devuelve: "07:48:48 GMT-0400 (Hora de verano del Este)"

Convertir en cadena de fecha

var date1 = new Date();
date1.toDateString();

Devoluciones: "Apr 14 2016"

Convertir a cadena UTC

var date1 = new Date();
date1.toUTCString();

Devoluciones: "Vie, 15 de abril de 2016 11:48:48 GMT"

Convertir a ISO String

var date1 = new Date();
date1.toISOString();

Devoluciones: "2016-04-14T23: 49: 08.596Z"

Convertir a cadena GMT

var date1 = new Date();
date1.toGMTString();

Devoluciones: "Jue, 14 de abril 2016 23:49:08 GMT"

Esta función se ha marcado como obsoleta, por lo que es posible que algunos navegadores no la admitan en el futuro. Se sugiere utilizar toUTCString () en su lugar.

Convertir a la cadena de fecha de configuración regional

var date1 = new Date();
date1.toLocaleDateString();

Devoluciones: "14/04/2016"

Esta función devuelve una cadena de fecha sensible al entorno local basada en la ubicación del usuario de forma predeterminada.

date1.toLocaleDateString([locales [, options]])

se puede utilizar para proporcionar configuraciones regionales específicas, pero la implementación del navegador es específica. Por ejemplo,

date1.toLocaleDateString(["zh", "en-US"]);

intentaría imprimir la cadena en la configuración regional china utilizando el inglés de Estados Unidos como alternativa. El parámetro de opciones se puede utilizar para proporcionar un formato específico. Por ejemplo:

var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
date1.toLocaleDateString([], options);

resultaría en

"Jueves 14 de abril de 2016".

Vea el MDN para más detalles.

Incrementar un objeto de fecha

Para incrementar los objetos de fecha en Javascript, generalmente podemos hacer esto:

var checkoutDate = new Date();    // Thu Jul 21 2016 10:05:13 GMT-0400 (EDT)

checkoutDate.setDate( checkoutDate.getDate() + 1 );

console.log(checkoutDate); // Fri Jul 22 2016 10:05:13 GMT-0400 (EDT)

Es posible usar setDate para cambiar la fecha a un día en el mes siguiente usando un valor mayor que el número de días en el mes actual -

var checkoutDate = new Date();    // Thu Jul 21 2016 10:05:13 GMT-0400 (EDT)
checkoutDate.setDate( checkoutDate.getDate() + 12 );
console.log(checkoutDate); // Tue Aug 02 2016 10:05:13 GMT-0400 (EDT)

Lo mismo se aplica a otros métodos como getHours (), getMonth (), etc.

Agregando Días de Trabajo

Si desea agregar días laborables (en este caso supongo que de lunes a viernes) puede usar la función setDate aunque necesita un poco de lógica adicional para los fines de semana (obviamente esto no tendrá en cuenta los días festivos nacionales) -

function addWorkDays(startDate, days) {
    // Get the day of the week as a number (0 = Sunday, 1 = Monday, .... 6 = Saturday)
    var dow = startDate.getDay();
    var daysToAdd = days;
    // If the current day is Sunday add one day
    if (dow == 0)
        daysToAdd++;
    // If the start date plus the additional days falls on or after the closest Saturday calculate weekends
    if (dow + daysToAdd >= 6) {
        //Subtract days in current working week from work days
        var remainingWorkDays = daysToAdd - (5 - dow);
        //Add current working week's weekend
        daysToAdd += 2;
        if (remainingWorkDays > 5) {
            //Add two days for each working week by calculating how many weeks are included
            daysToAdd += 2 * Math.floor(remainingWorkDays / 5);
            //Exclude final weekend if remainingWorkDays resolves to an exact number of weeks
            if (remainingWorkDays % 5 == 0)
                daysToAdd -= 2;
        }
    }
    startDate.setDate(startDate.getDate() + daysToAdd);
    return startDate;
}

Obtenga la cantidad de milisegundos transcurridos desde el 1 de enero de 1970 00:00:00 UTC

El método estático Date.now devuelve el número de milisegundos que han transcurrido desde el 1 de enero de 1970 a las 00:00:00 UTC. Para obtener la cantidad de milisegundos que han transcurrido desde ese momento utilizando una instancia de un objeto Date , use su método getTime .

// get milliseconds using static method now of Date
console.log(Date.now());

// get milliseconds using method getTime of Date instance
console.log((new Date()).getTime());

Formato de una fecha de JavaScript

Formato de una fecha de JavaScript en los navegadores modernos

En los navegadores modernos (*), Date.prototype.toLocaleDateString() permite definir el formato de una Date de una manera conveniente.

Requiere el siguiente formato:

dateObj.toLocaleDateString([locales [, options]])

El parámetro locales debe ser una cadena con una etiqueta de idioma BCP 47, o una matriz de dichas cadenas.

El parámetro de options debe ser un objeto con algunas o todas las siguientes propiedades:

• localeMatcher : los valores posibles son "lookup" y "best fit" ; el valor predeterminado es "best fit"
• zona horaria : el único valor que deben reconocer las implementaciones es "UTC" ; el valor predeterminado es la zona horaria predeterminada del tiempo de ejecución
• hora12 : los valores posibles son true y false ; el valor predeterminado es dependiente de la configuración regional
• formatMatcher : los valores posibles son "basic" y "best fit" ; el valor predeterminado es "best fit"
• día de la semana : los valores posibles son "narrow" , "short" y "long"
• era : los valores posibles son "narrow" , "short" y "long"
• año : los valores posibles son "numeric" y "2-digit"
• mes : los valores posibles son "numeric" , "2-digit" , "narrow" , "short" y "long"
• día : los valores posibles son "numeric" y "2-digit"
• hora : los valores posibles son "numeric" y "2-digit"
• minuto : los valores posibles son "numeric" y "2-digit"
• segundo : los valores posibles son "numeric" y "2-digit"
• timeZoneName : los valores posibles son "short" y "long"

Cómo utilizar

var today = new Date().toLocaleDateString('en-GB', {  
    day : 'numeric',
    month : 'short',
    year : 'numeric'
});

Salida si se ejecuta el 24 de enero de 2036:

'24 Jan 2036'

Yendo personalizado

Si Date.prototype.toLocaleDateString() no es lo suficientemente flexible como para satisfacer cualquier necesidad que pueda tener, es posible que desee crear un objeto Date personalizado que tenga este aspecto:

var DateObject = (function() {
    var monthNames = [
      "January", "February", "March",
      "April", "May", "June", "July",
      "August", "September", "October",
      "November", "December"
    ];
    var date = function(str) {
        this.set(str);
    };
    date.prototype = {
        set : function(str) {
            var dateDef = str ? new Date(str) : new Date();
            this.day = dateDef.getDate();
            this.dayPadded = (this.day < 10) ? ("0" + this.day) : "" + this.day;
            this.month = dateDef.getMonth() + 1;
            this.monthPadded = (this.month < 10) ? ("0" + this.month) : "" + this.month;
            this.monthName = monthNames[this.month - 1];
            this.year = dateDef.getFullYear();
        },
        get : function(properties, separator) {
            var separator = separator ? separator : '-'
                ret = [];
            for(var i in properties) {
                ret.push(this[properties[i]]);
            }
            return ret.join(separator);
        }
    };
    return date;
})();

Si incluyó ese código y ejecutó un new DateObject() el 20 de enero de 2019, produciría un objeto con las siguientes propiedades:

day: 20
dayPadded: "20"
month: 1
monthPadded: "01"
monthName: "January"
year: 2019

Para obtener una cadena con formato, podrías hacer algo como esto:

new DateObject().get(['dayPadded', 'monthPadded', 'year']);

Eso produciría el siguiente resultado:

20-01-2016

(*) Según la MDN , "navegadores modernos" significa Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ y Safari todas las noches.