obtener - sumar dias a una fecha javascript

¿Dónde puedo encontrar documentación sobre cómo formatear una fecha en JavaScript?

Question

Noté que la new Date() JavaScript es muy inteligente al aceptar fechas en varios formatos.

Xmas95 = new Date("25 Dec, 1995 23:15:00")
Xmas95 = new Date("2009 06 12,12:52:39")
Xmas95 = new Date("20 09 2006,12:52:39")

No pude encontrar documentación en ningún lugar que muestre todos los formatos de cadena válidos al llamar a la new Date()

Esto es para convertir una cadena en una fecha. Si observamos el lado opuesto, es decir, la conversión de un objeto de fecha en una cadena, hasta ahora tenía la impresión de que JavaScript no tiene una API integrada para formatear un objeto de fecha en una cadena.

Nota del editor: el siguiente enfoque es el intento del autor de la pregunta que funcionó en un navegador en particular pero no funciona en general; Vea las respuestas en esta página para ver algunas soluciones reales.

Hoy jugué con el método toString() en el objeto de fecha y, sorprendentemente, cumple el propósito de formatear la fecha de las cadenas.

var d1 = new Date();
d1.toString(''yyyy-MM-dd''); //Returns "2009-06-29" in Internet Explorer, but not Firefox or Chrome
d1.toString(''dddd, MMMM ,yyyy'') //Returns "Monday, June 29,2009" in Internet Explorer, but not Firefox or Chrome

También aquí no pude encontrar ninguna documentación sobre todas las formas en que podemos formatear el objeto de fecha en una cadena.

¿Dónde está la documentación que enumera los especificadores de formato admitidos por el objeto Date() ?

Answer 1

¿Dónde está la documentación que enumera los especificadores de formato admitidos por el objeto Date() ?

Me encontré con esto hoy y me sorprendió bastante que nadie se haya tomado el tiempo para responder esta simple pregunta. Es cierto que hay muchas bibliotecas por ahí para ayudar con la manipulación de la fecha. Algunos son mejores que otros. Pero esa no era la pregunta formulada.

AFAIK, el JavaScript puro no admite los especificadores de formato de la forma que ha indicado que le gustaría usar . Pero sí admite métodos para formatear fechas y / o horas, como .toLocaleDateString() , .toLocaleTimeString() y .toUTCString() .

La referencia del objeto Date que uso con mayor frecuencia se encuentra en el w3schools.com/jsref/jsref_obj_date.asp (pero una búsqueda rápida en Google revelará muchos más que pueden satisfacer mejor sus necesidades).

También tenga en cuenta que la sección Propiedades del objeto de fecha proporciona un enlace al prototype , que ilustra algunas formas en que puede extender el objeto de fecha con métodos personalizados. A lo largo de los años, ha habido cierto debate en la comunidad de JavaScript acerca de si esto es o no una buena práctica, y no estoy abogando ni a favor, sino simplemente señalando su existencia.

Answer 2

La respuesta corta

No hay documentación "universal" a la que se adapta JavaScript; Cada navegador que tiene javascript es realmente una implementación. Sin embargo, hay un estándar que la mayoría de los navegadores modernos tienden a seguir, y ese es el estándar EMCAScript; Las cadenas estándar de ECMAScript tendrían, como mínimo, una implementación modificada de la definición ISO 8601.

Además de esto, hay un segundo estándar establecido por el IETF que los navegadores también tienden a seguir, que es la definición de las marcas de tiempo realizadas en el RFC 2822. La documentación real se puede encontrar en la lista de referencias en la parte inferior.

De esto se puede esperar una funcionalidad básica, pero lo que "debería" ser no es inherentemente lo que "es". Sin embargo, voy a profundizar un poco en esto con el procedimiento, ya que parece que solo tres personas respondieron la pregunta (Scott, goofballLogic y peller a saber), lo que, para mí, sugiere que la mayoría de las personas no saben lo que realmente sucede cuando crear un objeto de fecha.

La respuesta larga

¿Dónde está la documentación que enumera los especificadores de formato admitidos por el objeto Date ()?

Para responder a la pregunta, o normalmente buscar la respuesta a esta pregunta, debe saber que JavaScript no es un lenguaje novedoso; en realidad es una implementación de ECMAScript, y sigue los estándares de ECMAScript (pero tenga en cuenta que javascript también es anterior a esos estándares; los estándares de EMCAScript se basan en la implementación temprana de LiveScript / JavaScript). El estándar ECMAScript actual es 5.1 (2011); en el momento en que se formuló originalmente la pregunta (junio de 2009), la norma era 3 (se abandonó 4), pero 5 se publicó poco después de la publicación a fines de 2009. Esto debería plantear un problema; qué estándar puede seguir una implementación de javascript, puede no reflejar lo que realmente está implementado, porque a) es una implementación de un estándar dado, b) no todas las implementaciones de un estándar son puritanas, yc) la funcionalidad no se libera en sincronización con un nuevo estándar como d) una implementación es un trabajo constante en progreso

Esencialmente, cuando se trata de javascript, se trata de un derivado (javascript específico para el navegador) de una implementación (javascript en sí). El V8 de Google, por ejemplo, implementa ECMAScript 5.0, pero el JScript de Internet Explorer no intenta cumplir con ningún estándar de ECMAScript, sin embargo, Internet Explorer 9 se ajusta a ECMAScript 5.0.

Cuando se pasa un solo argumento a la nueva Fecha (), se convierte este prototipo de función:

new Date(value)

Cuando se pasan dos o más argumentos a la nueva Fecha (), se convierte este prototipo de función:

new Date (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] )

Ambas funciones deben parecer familiares, pero esto no responde de inmediato a su pregunta y lo que se cuantifica como un "formato de fecha" aceptable requiere una explicación adicional. Cuando pase una cadena a la nueva Fecha (), llamará al prototipo (tenga en cuenta que estoy usando la palabra prototipo de manera general; las versiones pueden ser funciones individuales o pueden ser parte de una declaración condicional en una sola función) para nueva fecha (valor) con su cadena como argumento para el parámetro "valor". Esta función primero verificará si es un número o una cadena. La documentación para esta función se puede encontrar aquí:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.3.2

De esto, podemos deducir que para obtener el formato de cadena permitido para la nueva Fecha (valor), debemos observar el método Date.parse (cadena). La documentación para este método se puede encontrar aquí:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2

Y también podemos inferir que se espera que las fechas estén en un formato extendido ISO 8601 modificado, como se especifica aquí:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15

Sin embargo, podemos reconocer por experiencia que el objeto Date de javascript acepta otros formatos (forzado por la existencia de esta pregunta en primer lugar), y esto está bien porque ECMAScript permite formatos de implementación específicos. Sin embargo, eso todavía no responde a la pregunta de qué documentación está disponible en los formatos disponibles, ni qué formatos están realmente permitidos. Vamos a ver la implementación de javascript de Google, V8; tenga en cuenta que no estoy sugiriendo que este sea el "mejor" motor javascript (cómo se puede definir "mejor" o incluso "bueno") y no se puede asumir que los formatos permitidos en V8 representan todos los formatos disponibles en la actualidad, pero creo que es justo para asumir que sí siguen las expectativas modernas.

V8 de Google, date.js, DateConstructor

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#141

Al observar la función DateConstructor, podemos deducir que necesitamos encontrar la función DateParse; sin embargo, tenga en cuenta que "año" no es el año real y es solo una referencia al parámetro "año".

V8 de Google, date.js, DateParse

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#270

Esto llama a% DateParseString, que en realidad es una referencia de función en tiempo de ejecución para una función de C ++. Se refiere al siguiente código:

V8 de Google, runtime.cc,% DateParseString

https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559

La llamada a la función que nos ocupa en esta función es para DateParser :: Parse (); ignore la lógica que rodea esas llamadas de función, estas son solo verificaciones para cumplir con el tipo de codificación (ASCII y UC16). DateParser :: Parse se define aquí:

V8 de Google, dateparser-inl.h, DateParser :: Parse

https://code.google.com/p/v8/source/browse/trunk/src/dateparser-inl.h?r=18400#36

Esta es la función que realmente define qué formatos acepta. Esencialmente, verifica el estándar EMCAScript 5.0 ISO 8601 y, si no cumple con los estándares, intentará construir la fecha basándose en formatos heredados. Algunos puntos clave basados ​​en los comentarios:

1. Las palabras antes del primer número que son desconocidas para el analizador se ignoran.
2. El texto entre paréntesis se ignora.
3. Los números sin firmar seguidos de ":" se interpretan como un "componente de tiempo".
4. Los números sin firmar seguidos de "." Se interpretan como un "componente de tiempo", y deben ir seguidos de milisegundos.
5. Los números firmados seguidos de la hora o la hora (p. Ej., +5: 15 o +0515) se interpretan como la zona horaria.
6. Al declarar la hora y los minutos, puede usar "hh: mm" o "hhmm".
7. Las palabras que indican una zona horaria se interpretan como una zona horaria.
8. Todos los demás números se interpretan como "componentes de fecha".
9. Todas las palabras que comienzan con los primeros tres dígitos de un mes se interpretan como el mes.
10. Puede definir minutos y horas juntos en cualquiera de los dos formatos: "hh: mm" o "hhmm".
11. Símbolos como "+", "-" y ")" no coincidentes no se permiten después de que se haya procesado un número.
12. Los elementos que coinciden con varios formatos (por ejemplo, 1970-01-01) se procesan como una cadena EMCAScript 5.0 ISO 8601 compatible con el estándar.

Por lo tanto, esto debería ser suficiente para darle una idea básica de qué esperar cuando se trata de pasar una cadena a un objeto Date. Puede ampliar aún más esto observando la siguiente especificación a la que Mozilla apunta en la Red de Desarrolladores de Mozilla (compatible con las marcas de tiempo IETF RFC 2822):

http://tools.ietf.org/html/rfc2822#page-14

La Red de desarrolladores de Microsoft menciona además un estándar adicional para el objeto Fecha: ECMA-402, la especificación de la API de internacionalización ECMAScript, que es complementaria al estándar ECMAScript 5.1 (y futuros). Eso se puede encontrar aquí:

http://www.ecma-international.org/ecma-402/1.0/

En cualquier caso, esto debería ayudar a resaltar que no existe una "documentación" que represente universalmente todas las implementaciones de javascript, pero todavía hay suficiente documentación disponible para comprender qué cadenas son aceptables para un objeto Date. Bastante la pregunta cargada cuando piensas en ello, ¿sí? :PAG

Referencias

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.3.2

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15

http://tools.ietf.org/html/rfc2822#page-14

http://www.ecma-international.org/ecma-402/1.0/

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#141

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#270

https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559

https://code.google.com/p/v8/source/browse/trunk/src/dateparser-inl.h?r=18400#36

Recursos

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

http://msdn.microsoft.com/en-us/library/ff743760(v=vs.94).aspx

Answer 3

Función de formato personalizado:

Para formatos fijos, una función simple hace el trabajo. El siguiente ejemplo genera el formato internacional YYYY-MM-DD:

function dateToYMD(date) {
var d = date.getDate();
var m = date.getMonth() + 1;
var y = date.getFullYear();
return '''' + y + ''-'' + (m<=9 ? ''0'' + m : m) + ''-'' + (d <= 9 ? ''0'' + d : d);
}

Nota: Sin embargo, generalmente no es una buena idea extender las bibliotecas estándar de Javascript (por ejemplo, agregando esta función al prototipo de Fecha).

Una función más avanzada podría generar una salida configurable basada en un parámetro de formato. Hay un par de buenos ejemplos en esta misma página.

Si escribir una función de formateo es demasiado larga, hay muchas bibliotecas alrededor de las cuales lo hace. Algunas otras respuestas ya las enumeran. Pero el aumento de dependencias también lo tiene contraparte.

Funciones de formato estándar de ECMAScript:

Desde las versiones más recientes de ECMAscript, la clase Date tiene algunas funciones de formato específicas:

toDateString : depende de la implementación, muestra solo la fecha.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.todatestring

new Date().toDateString(); // e.g. "Fri Nov 11 2016"

toISOString : muestra la fecha y la hora ISO 8601.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.toisostring

new Date().toISOString(); // e.g. "2016-11-21T08:00:00.000Z"

toJSON : Stringifier para JSON.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tojson

new Date().toJSON(); // e.g. "2016-11-21T08:00:00.000Z"

toLocaleDateString : dependiente de la implementación, una fecha en formato de entorno local.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocaledatestring

new Date().toLocaleDateString(); // e.g. "21/11/2016"

toLocaleString : dependiente de la implementación, una fecha y hora en formato de entorno local.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocalestring

new Date().toLocaleString(); // e.g. "21/11/2016, 08:00:00 AM"

toLocaleTimeString : dependiente de la implementación, una hora en formato de entorno local.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocaletimestring

new Date().toLocaleTimeString(); // e.g. "08:00:00 AM"

toString : toString genérico para la fecha.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tostring

new Date().toString(); // e.g. "Fri Nov 11 2016 08:00:00 GMT+0100 (W. Europe Standard Time)"

Nota: es posible generar una salida personalizada de esas funciones de formato:

new Date().toISOString().slice(0,10); // By @Image72, return YYYY-MM-DD

Answer 4

Todos los navegadores

La forma más confiable de formatear una fecha con el formato de origen que está utilizando, es aplicar los siguientes pasos:

1. Utilice new Date()para crear un Dateobjeto
2. Utilizar .getDate(), .getMonth()y .getFullYear()para obtener respectivamente el día, mes y año.
3. Pegue las piezas juntas de acuerdo a su formato de destino

Ejemplo:

var date = ''2015-11-09T10:46:15.097Z'';
function format(input) {
var date = new Date(input);
return [
("0" + date.getDate()).slice(-2),
("0" + (date.getMonth()+1)).slice(-2),
date.getFullYear()
].join(''/'');
}
document.body.innerHTML = format(date); // OUTPUT : 09/11/2015

(Véase también este violín ).

Solo navegadores modernos

También puede usar el .toLocaleDateStringmétodo incorporado para hacer el formato por usted. Solo necesita pasar la configuración regional y las opciones adecuadas para que coincidan con el formato correcto, que desafortunadamente solo es compatible con los navegadores modernos (*) :

var date = ''2015-11-09T10:46:15.097Z'';
function format(input) {
return new Date(input).toLocaleDateString(''en-GB'', {
year: ''numeric'',
month: ''2-digit'',
day: ''2-digit''
});
}
document.body.innerHTML = format(date); // OUTPUT : 09/11/2015

(Véase también este violín ).

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

Answer 5

Aquí hay una función que uso mucho. El resultado es aaaa-mm-dd hh: mm: ss.nnn.

function date_and_time() {
var date = new Date();
//zero-pad a single zero if needed
var zp = function (val){
return (val <= 9 ? ''0'' + val : '''' + val);
}
//zero-pad up to two zeroes if needed
var zp2 = function(val){
return val <= 99? (val <=9? ''00'' + val : ''0'' + val) : ('''' + val ) ;
}
var d = date.getDate();
var m = date.getMonth() + 1;
var y = date.getFullYear();
var h = date.getHours();
var min = date.getMinutes();
var s = date.getSeconds();
var ms = date.getMilliseconds();
return '''' + y + ''-'' + zp(m) + ''-'' + zp(d) + '' '' + zp(h) + '':'' + zp(min) + '':'' + zp(s) + ''.'' + zp2(ms);
}

Answer 6

Asegúrese de Datejs cuando se trata de fechas en JavaScript. Es bastante impresionante y está bien documentado, como se puede ver en el caso de la función toString .

EDITAR : Tyler Forsythe señala que las fechas no están actualizadas. Lo uso en mi proyecto actual y no tuve ningún problema con él, sin embargo, debe tener esto en cuenta y considerar alternativas.

Answer 7

Código de ejemplo:

var d = new Date();
var time = d.toISOString().replace(/.*?T(/d+:/d+:/d+).*/, "$1");

Salida:

"13:45:20"

Answer 8

DateJS tiene todas las funciones, pero recomendaría esta versión mucho más sencilla (formato de fecha de JavaScript) que prefiero, simplemente porque son solo 120 líneas aproximadamente.

Answer 9

Después de examinar varias de las opciones proporcionadas en otras respuestas, decidí escribir mi propia solución limitada pero simple que otros también pueden encontrar útil.

/**
* Format date as a string
* @param date - a date object (usually "new Date();")
* @param format - a string format, eg. "DD-MM-YYYY"
*/
function dateFormat(date, format) {
// Calculate date parts and replace instances in format string accordingly
format = format.replace("DD", (date.getDate() < 10 ? ''0'' : '''') + date.getDate()); // Pad with ''0'' if needed
format = format.replace("MM", (date.getMonth() < 9 ? ''0'' : '''') + (date.getMonth() + 1)); // Months are zero-based
format = format.replace("YYYY", date.getFullYear());
return format;
}

Ejemplo de uso:

console.log("The date is: " + dateFormat(new Date(), "DD/MM/YYYY"));

Answer 10

Hice este formateador muy simple, es cut / n / pastable (actualizado con una versión más limpia):

function DateFmt(fstr) {
this.formatString = fstr
var mthNames = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
var dayNames = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
var zeroPad = function(number) {
return ("0"+number).substr(-2,2);
}
var dateMarkers = {
d:[''getDate'',function(v) { return zeroPad(v)}],
m:[''getMonth'',function(v) { return zeroPad(v+1)}],
n:[''getMonth'',function(v) { return mthNames[v]; }],
w:[''getDay'',function(v) { return dayNames[v]; }],
y:[''getFullYear''],
H:[''getHours'',function(v) { return zeroPad(v)}],
M:[''getMinutes'',function(v) { return zeroPad(v)}],
S:[''getSeconds'',function(v) { return zeroPad(v)}],
i:[''toISOString'']
};
this.format = function(date) {
var dateTxt = this.formatString.replace(/%(.)/g, function(m, p) {
var rv = date[(dateMarkers[p])[0]]()
if ( dateMarkers[p][1] != null ) rv = dateMarkers[p][1](rv)
return rv
});
return dateTxt
}
}
fmt = new DateFmt("%w %d:%n:%y - %H:%M:%S %i")
v = fmt.format(new Date())

http://snipplr.com/view/66968.82825/

Answer 11

La funcionalidad que usted cita no es un Javascript estándar, no es probable que sea portátil en todos los navegadores y, por lo tanto, no es una buena práctica. La especificación ECMAScript 3 deja la función de formatos de salida y análisis hasta la implementación de Javascript. ECMAScript 5 agrega un subconjunto de compatibilidad con ISO8601. Creo que la función toString () que mencionas es una innovación en un navegador (¿Mozilla?)

Varias bibliotecas proporcionan rutinas para parametrizar esto, algunas con un amplio soporte de localización. También puede consultar los métodos en dojo.date.locale .

Answer 12

Marco libre, limitado pero ligero.

var d = (new Date()+'''').split('' '');
// ["Tue", "Sep", "03", "2013", "21:54:52", "GMT-0500", "(Central", "Daylight", "Time)"]
[d[3], d[1], d[2], d[4]].join('' '');
// "2013 Sep 03 21:58:03"

Answer 13

Me encantan las 10 formas de formatear la hora y la fecha mediante JavaScript y Trabajar con fechas

Básicamente, tienes tres métodos y tienes que combinar las cadenas para ti:

getDate() // Returns the date
getMonth() // Returns the month
getFullYear() // Returns the year

Ejemplo:

var d = new Date();
var curr_date = d.getDate();
var curr_month = d.getMonth() + 1; //Months are zero based
var curr_year = d.getFullYear();
console.log(curr_date + "-" + curr_month + "-" + curr_year);

Answer 14

Puede encontrar útil esta modificación del objeto de fecha, que es más pequeña que cualquier biblioteca y es fácilmente ampliable para admitir diferentes formatos:

NOTA:

• Utiliza Object.keys() que no está definido en navegadores más antiguos, por lo que es posible que necesite implementar polyfill desde el enlace dado.

CÓDIGO

Date.prototype.format = function(format) {
// set default format if function argument not provided
format = format || ''YYYY-MM-DD hh:mm'';
var zeropad = function(number, length) {
number = number.toString();
length = length || 2;
while(number.length < length)
number = ''0'' + number;
return number;
},
// here you can define your formats
formats = {
YYYY: this.getFullYear(),
MM: zeropad(this.getMonth() + 1),
DD: zeropad(this.getDate()),
hh: zeropad(this.getHours()),
mm: zeropad(this.getMinutes())
},
pattern = ''('' + Object.keys(formats).join('')|('') + '')'';
return format.replace(new RegExp(pattern, ''g''), function(match) {
return formats[match];
});
};

UTILIZAR

var now = new Date;
console.log(now.format());
// outputs: 2015-02-09 11:47
var yesterday = new Date(''2015-02-08'');
console.log(yesterday.format(''hh:mm YYYY/MM/DD''));
// outputs: 00:00 2015/02/08

Answer 15

Si ya está utilizando la interfaz de usuario jQuery en su proyecto, puede usar el método de selección de fechas incorporado para formatear su objeto de fecha:

$.datepicker.formatDate(''yy-mm-dd'', new Date(2007, 1 - 1, 26));

Sin embargo, el selector de fecha solo da formato a las fechas y no puede dar formato a las horas.

Eche un vistazo a jQuery UI datepicker formatDate , los ejemplos.

Answer 16

Simplemente puede expandir el Objeto de Date con un nuevo método de format como lo indica meizz , a continuación se muestra el código dado por el autor. Y aquí hay un jsfiddle .

Date.prototype.format = function(format) //author: meizz
{
var o = {
"M+" : this.getMonth()+1, //month
"d+" : this.getDate(), //day
"h+" : this.getHours(), //hour
"m+" : this.getMinutes(), //minute
"s+" : this.getSeconds(), //second
"q+" : Math.floor((this.getMonth()+3)/3), //quarter
"S" : this.getMilliseconds() //millisecond
}
if(/(y+)/.test(format)) format=format.replace(RegExp.$1,
(this.getFullYear()+"").substr(4 - RegExp.$1.length));
for(var k in o)if(new RegExp("("+ k +")").test(format))
format = format.replace(RegExp.$1,
RegExp.$1.length==1 ? o[k] :
("00"+ o[k]).substr((""+ o[k]).length));
return format;
}
alert(new Date().format("yyyy-MM-dd"));
alert(new Date("january 12 2008 11:12:30").format("yyyy-MM-dd h:mm:ss"));

Answer 17

JsSimpleDateFormat es una biblioteca que puede formatear el objeto de fecha y analizar la cadena formateada de nuevo al objeto de fecha. Utiliza el formato Java (clase SimpleDateFormat). El nombre de meses y días puede ser localizado.

Ejemplo:

var sdf = new JsSimpleDateFormat("EEEE, MMMM dd, yyyy");
var formattedString = sdf.format(new Date());
var dateObject = sdf.parse("Monday, June 29, 2009");

Answer 18

momentjs

Es una biblioteca de fechas JavaScript (liviana) * para analizar, manipular y formatear fechas.

var a = moment([2010, 1, 14, 15, 25, 50, 125]);
a.format("dddd, MMMM Do YYYY, h:mm:ss a"); // "Sunday, February 14th 2010, 3:25:50 pm"
a.format("ddd, hA"); // "Sun, 3PM"

(*) significado liviano 9.3KB minified + gzipped en la configuración más pequeña posible (feb 2014)

Answer 19

No pude encontrar ninguna documentación definitiva sobre formatos de fecha válidos, así que escribí mi propia prueba para ver qué se admite en varios navegadores.

http://blarg.co.uk/blog/javascript-date-formats

Mis resultados concluyeron que los siguientes formatos son válidos en todos los navegadores que probé (los ejemplos usan la fecha "9 de agosto de 2013"):

[Año completo] / [Mes] / [Número de fecha] : el mes puede ser el número con o sin un cero inicial o el nombre del mes en formato corto o largo, y el número de fecha puede ser con o sin un cero inicial.

• 2013/08/09
• 2013/08/9
• 2013/8/09
• 2013/8/9
• 2013 / agosto / 09
• 2013 / agosto / 9
• 2013 / agosto / 09
• 2013 / agosto / 9

[Mes] / [Año completo] / [Número de fecha] : el mes puede ser el número con o sin un cero inicial o el nombre del mes en formato corto o largo, y el número de la fecha puede ser con o sin un cero inicial.

• 20/08/2013
• 20/08/2013
• 8/2013/09
• 8/2013/9
• Agosto / 2013/09
• Agosto / 2013/9
• Ago / 2013/09
• Ago / 2013/9

Cualquier combinación de [Año completo], [Nombre del mes] y [Número de fecha] separados por espacios : el nombre del mes puede estar en formato corto o largo, y el número de la fecha puede estar con o sin un cero inicial.

• 2013 agosto 09
• Agosto 2013 09
• 09 de agosto de 2013
• 2013 ago 09
• 9 de agosto de 2013
• 2013 9 de agosto
• etc ...

También válido en "navegadores modernos" (o en otras palabras, en todos los navegadores excepto IE9 y anteriores)

[Año completo] - [Número de mes] - [Número de fecha] - El mes y el número de fecha deben incluir ceros iniciales (este es el formato que usa el tipo de fecha MySQL )

• 2013-08-09

Uso de nombres de mes: Es
interesante que al usar nombres de mes descubrí que solo se usan los primeros 3 caracteres del nombre del mes, por lo que todos los siguientes son perfectamente válidos:

new Date(''9 August 2013'');
new Date(''9 Aug 2013'');
new Date(''9 Augu 2013'');
new Date(''9 Augustagfsdgsd 2013'');

Answer 20

Solo otra opción, que escribí:

DP_DateExtensions Library

No estoy seguro de si ayudará, pero lo he encontrado útil en varios proyectos; parece que hará lo que necesites.

Admite el formateo de fecha / hora, datos matemáticos de fecha (sumar / restar partes de fecha), comparación de fecha, análisis de fecha, etc. Es de código abierto.

No hay razón para considerarlo si ya está utilizando un marco (todos ellos son capaces), pero si solo necesita agregar rápidamente la manipulación de la fecha a un proyecto, déle una oportunidad.

Answer 21

Solo para continuar con la sólida respuesta de gongzhitaao - esto maneja AM / PM

 Date.prototype.format = function (format) //author: meizz
{
var hours = this.getHours();
var ttime = "AM";
if(format.indexOf("t") > -1 && hours > 12)
{
hours = hours - 12;
ttime = "PM";
}
var o = {
"M+": this.getMonth() + 1, //month
"d+": this.getDate(), //day
"h+": hours, //hour
"m+": this.getMinutes(), //minute
"s+": this.getSeconds(), //second
"q+": Math.floor((this.getMonth() + 3) / 3), //quarter
"S": this.getMilliseconds(), //millisecond,
"t+": ttime
}
if (/(y+)/.test(format)) format = format.replace(RegExp.$1,
(this.getFullYear() + "").substr(4 - RegExp.$1.length));
for (var k in o) if (new RegExp("(" + k + ")").test(format))
format = format.replace(RegExp.$1,
RegExp.$1.length == 1 ? o[k] :
("00" + o[k]).substr(("" + o[k]).length));
return format;
}

Answer 22

usa estas funciones

toTimeString() and toLocaleDateString()

Consulte el siguiente enlace para obtener más detalles developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

Answer 23

Formateo y especialmente el análisis de fechas en JavaScript puede ser un poco de dolor de cabeza. No todos los navegadores manejan las fechas de la misma manera. Entonces, si bien es útil conocer los métodos básicos, es más práctico usar una biblioteca auxiliar.

La biblioteca de javascript de XDate de Adam Shaw ha existido desde mediados de 2011 y todavía está en desarrollo activo. Tiene una documentación fantástica, una gran API, formato, intenta ser compatible con versiones anteriores e incluso admite cadenas localizadas.

Enlace para cambiar las cadenas de configuración regional: https://gist.github.com/1221376

Answer 24

La biblioteca sugar.js tiene una gran funcionalidad para trabajar con fechas en JavaScript. Y está muy bien documented .

Sugar le da mucho cariño a la clase Date, comenzando con el método Date.create que puede entender las fechas en casi cualquier formato en 15 idiomas principales, incluidos los formatos relativos como "hace 1 hora". Las fechas también pueden publicarse en cualquier formato o idioma utilizando una sintaxis fácil de entender, con accesos directos a los formatos de fecha más utilizados. La comparación compleja de fechas también es posible con métodos como es, que comprenden cualquier formato y aplican precisión integrada.

Algunos ejemplos:

Date.create(''July 4, 1776'') -> July 4, 1776
Date.create(-446806800000) -> November 5, 1955
Date.create(1776, 6, 4) -> July 4, 1776
Date.create(''1776年07月04日'', ''ja'') -> July 4, 1776
Date.utc.create(''July 4, 1776'', ''en'') -> July 4, 1776
Date.create().format(''{Weekday} {d} {Month}, {yyyy}'') -> Monday July 4, 2003
Date.create().format(''{hh}:{mm}'') -> 15:57
Date.create().format(''{12hr}:{mm}{tt}'') -> 3:57pm
Date.create().format(Date.ISO8601_DATETIME) -> 2011-07-05 12:24:55.528Z
Date.create().is(''the 7th of June'') -> false
Date.create().addMonths(2); ->"Sunday, June 15, 2014 13:39"

Answer 25

La forma correcta de formatear una fecha para devolver "2012-12-29" es con el script desde el formato de fecha de JavaScript :

var d1 = new Date();
return d1.format("dd-m-yy");

Este código NO funciona:

var d1 = new Date();
d1.toString(''yyyy-MM-dd'');

Answer 26

La respuesta es "en ninguna parte" ya que el formato de fecha es una funcionalidad propietaria. No creo que las funciones de toString estén diseñadas para ajustarse a un formato específico. por ejemplo, en la especificación ECMAScript 5.1 ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, página 173), la función toString se documenta de la siguiente manera :

"Los contenidos de la cadena dependen de la implementación"

Las funciones como las siguientes muestras podrían usarse para realizar el formateo con bastante facilidad.

function pad(toPad, padWith) {
return (String(padWith) + String(toPad)).slice(-1 * padWith.length);
}
function dateAsInputValue(toFormat) {
if(!(toFormat instanceof Date)) return null;
return toFormat.getFullYear() + "-" + pad(toFormat.getMonth() + 1, "00") + "-" + pad(toFormat.getDate(), "00");
}
function timeAsInputValue(toFormat) {
if(!(toFormat instanceof Date)) return null;
return pad(toFormat.getHours(), "00") + ":" + pad(toFormat.getMinutes(), "00") + ":" + pad(toFormat.getSeconds(), "00");
}

Answer 27

Muchos marcos (que es posible que ya esté utilizando) tienen un formato de fecha que quizás no conozca. jQueryUI ya se mencionó, pero otros marcos como Kendo UI (Globalization) , Yahoo UI (Util) y AngularJS también los tienen.

// 11/6/2000
kendo.toString(new Date(value), "d")
// Monday, November 06, 2000
kendo.toString(new Date(2000, 10, 6), "D")

Answer 28

Personalmente, como uso PHP y jQuery / javascript en igual medida, uso la función de fecha de php.js http://phpjs.org/functions/date/

Por supuesto, usar una biblioteca que utiliza las mismas cadenas de formato como algo que ya conozco es más fácil para mí, y el manual que contiene todas las posibilidades de cadenas de formato para la función de fecha está en línea en php.net

Simplemente incluya el archivo date.js en su HTML usando su método preferido y luego llámelo así:

var d1=new Date();
var datestring = date(''Y-m-d'', d1.valueOf()/1000);

Puedes usar d1.getTime () en lugar de valueOf () si quieres, ellos hacen lo mismo.

La división por 1000 de la marca de tiempo de javascript se debe a que una marca de tiempo de javascript está en milisegundos, pero una marca de tiempo de PHP está en segundos.

Answer 29

Si desea mostrar solo la hora con dos dígitos, esto puede ayudarlo a:

var now = new Date();
var cHour = now.getHours();
var cMinuts = now.getMinutes();
var cSeconds = now.getSeconds();
var outStr = (cHour <= 0 ? (''0'' + cHour) : cHour) + '':'' + (cMinuts <= 9 ? (''0'' + cMinuts) : cMinuts) + '':'' + (cSeconds <= 9 ? ''0'' + cSeconds : cSeconds);

Answer 30

Si no necesita todas las características que proporciona una biblioteca como momentjs , puede usar mi puerto de strftime . Es ligero (1.35 KB vs. 57.9 KB minificado en comparación con Moment.js 2.15.0) y proporciona la mayor parte de la funcionalidad de strftime().

/* Port of strftime(). Compatibility notes:
*
* %c - formatted string is slightly different
* %D - not implemented (use "%m/%d/%y" or "%d/%m/%y")
* %e - space is not added
* %E - not implemented
* %h - not implemented (use "%b")
* %k - space is not added
* %n - not implemented (use "/n")
* %O - not implemented
* %r - not implemented (use "%I:%M:%S %p")
* %R - not implemented (use "%H:%M")
* %t - not implemented (use "/t")
* %T - not implemented (use "%H:%M:%S")
* %U - not implemented
* %W - not implemented
* %+ - not implemented
* %% - not implemented (use "%")
*
* strftime() reference:
* http://man7.org/linux/man-pages/man3/strftime.3.html
*
* Day of year (%j) code based on Joe Orost''s answer:
* http://.com/questions/8619879/javascript-calculate-the-day-of-the-year-1-366
*
* Week number (%V) code based on Taco van den Broek''s prototype:
* http://techblog.procurios.nl/k/news/view/33796/14863/calculate-iso-8601-week-and-year-in-javascript.html
*/
function strftime(sFormat, date) {
if (!(date instanceof Date)) date = new Date();
var nDay = date.getDay(),
nDate = date.getDate(),
nMonth = date.getMonth(),
nYear = date.getFullYear(),
nHour = date.getHours(),
aDays = [''Sunday'', ''Monday'', ''Tuesday'', ''Wednesday'', ''Thursday'', ''Friday'', ''Saturday''],
aMonths = [''January'', ''February'', ''March'', ''April'', ''May'', ''June'', ''July'', ''August'', ''September'', ''October'', ''November'', ''December''],
aDayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
isLeapYear = function() {
if (nYear&3!==0) return false;
return nYear%100!==0 || year%400===0;
},
getThursday = function() {
var target = new Date(date);
target.setDate(nDate - ((nDay+6)%7) + 3);
return target;
},
zeroPad = function(nNum, nPad) {
return ('''' + (Math.pow(10, nPad) + nNum)).slice(1);
};
return sFormat.replace(/%[a-z]/gi, function(sMatch) {
return {
''%a'': aDays[nDay].slice(0,3),
''%A'': aDays[nDay],
''%b'': aMonths[nMonth].slice(0,3),
''%B'': aMonths[nMonth],
''%c'': date.toUTCString(),
''%C'': Math.floor(nYear/100),
''%d'': zeroPad(nDate, 2),
''%e'': nDate,
''%F'': date.toISOString().slice(0,10),
''%G'': getThursday().getFullYear(),
''%g'': ('''' + getThursday().getFullYear()).slice(2),
''%H'': zeroPad(nHour, 2),
''%I'': zeroPad((nHour+11)%12 + 1, 2),
''%j'': zeroPad(aDayCount[nMonth] + nDate + ((nMonth>1 && isLeapYear()) ? 1 : 0), 3),
''%k'': '''' + nHour,
''%l'': (nHour+11)%12 + 1,
''%m'': zeroPad(nMonth + 1, 2),
''%M'': zeroPad(date.getMinutes(), 2),
''%p'': (nHour<12) ? ''AM'' : ''PM'',
''%P'': (nHour<12) ? ''am'' : ''pm'',
''%s'': Math.round(date.getTime()/1000),
''%S'': zeroPad(date.getSeconds(), 2),
''%u'': nDay || 7,
''%V'': (function() {
var target = getThursday(),
n1stThu = target.valueOf();
target.setMonth(0, 1);
var nJan1 = target.getDay();
if (nJan1!==4) target.setMonth(0, 1 + ((4-nJan1)+7)%7);
return zeroPad(1 + Math.ceil((n1stThu-target)/604800000), 2);
})(),
''%w'': '''' + nDay,
''%x'': date.toLocaleDateString(),
''%X'': date.toLocaleTimeString(),
''%y'': ('''' + nYear).slice(2),
''%Y'': nYear,
''%z'': date.toTimeString().replace(/.+GMT([+-]/d+).+/, ''$1''),
''%Z'': date.toTimeString().replace(/.+/((.+?)/)$/, ''$1'')
}[sMatch] || sMatch;
});
}

Uso de la muestra:

strftime(''%F''); // Returns "2016-09-15"
strftime(''%A, %B %e, %Y''); // Returns "Thursday, September 15, 2016"
// You can optionally pass it a Date object...
strftime(''%x %X'', new Date(''1/1/2016'')); // Returns "1/1/2016 12:00:00 AM"

El último código está disponible aquí: https://github.com/thdoan/strftime