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


Noté que JavaScript new Date() la función 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 ninguna parte mostrando todos los formatos de cadena válidos mientras llamaba new Date() función.

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

Nota del editor: El siguiente enfoque es el intento del asker que funcionó en un navegador en particular pero lo hace no trabajo en general; ver las respuestas en esta página para ver algunas soluciones reales.

Hoy, jugué con el toString() método en el objeto de fecha y, sorprendentemente, sirve para dar formato a las cadenas de fecha.

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 Date() ¿objeto?


1293
2018-06-29 05:46


origen


Respuestas:


amo 10 formas de formatear la hora y la fecha usando JavaScript y Trabajando con fechas.

Básicamente, tienes tres métodos y tienes que combinar las cuerdas por ti mismo:

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);


1010
2018-04-12 07:18



Moment.js

Es una biblioteca de fechas de JavaScript (ligera) * 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"

(*) liviano significa 9.3 KB minificado + gzip en la configuración más pequeña posible (feb 2014) 


670
2017-08-11 07:27



Si ya estás usando jQuery UI en su proyecto, puede usar el método datepicker integrado para formatear su objeto de fecha:

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

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

Mira esto jQuery UI datepicker formatDate, los ejemplos.


419
2017-08-03 16:55



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

Me encontré con esto hoy y me sorprendió bastante que nadie se tomara el tiempo para responder a esta simple pregunta. Es cierto que hay muchas bibliotecas para ayudar con la manipulación de fechas. Algunos son mejores que otros. Pero esa no fue la pregunta.

AFAIK, JavaScript puro no es compatible con los especificadores de formato la forma en que ha indicado que desea usarlos. Pero sí admite métodos para formatear fechas y / o tiempos, como .toLocaleDateString(), .toLocaleTimeString()y .toUTCString().

los Date referencia de objeto que uso con mayor frecuencia es en el Sitio web de w3schools.com (pero una búsqueda rápida en Google revelará muchos más que pueden satisfacer mejor sus necesidades).

También tenga en cuenta que el Propiedades del objeto de fecha la sección proporciona un enlace a prototype, que ilustra algunas formas en que puede extender el objeto Date con métodos personalizados. Ha habido un poco de debate en la comunidad de JavaScript a lo largo de los años acerca de si esta es o no la mejor práctica, y no estoy abogando a favor o en contra, simplemente señalando su existencia.


215
2018-05-21 12:48



Función de formateo personalizado:

Para formatos fijos, una función simple hace el trabajo. El siguiente ejemplo genera el formato internacional AAAA-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 resultados configurables en función de 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 las dependencias también lo tiene en contrapartida.

Funciones de formateo de ECMAScript estándar:

Desde versiones más recientes de ECMAscript, el Date la clase tiene algunas funciones de formateo 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: Mostrar fecha y 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: Depende de la implementación, una fecha en formato de configuración regional.

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

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

toLocaleString: Depende de la implementación, una fecha y hora en formato de configuración regional.

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: Depende de la implementación, una hora en formato de configuración regional.

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

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

Encadenar: 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 salida personalizada a partir de esas funciones de formateo:

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

200
2017-07-02 20:07



La respuesta corta

No hay documentación "universal" a la que javascript sirva; 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 ECMAScript tomarí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 tienden a seguir también, que es la definición de marcas de tiempo hecha en el RFC 2822. La documentación real se puede encontrar en la lista de referencias en la parte inferior.

A partir de esto, puede esperar una funcionalidad básica, pero lo que "debe ser" no es inherentemente lo que "es". Sin embargo, voy a profundizar un poco en esto de forma procedimental, ya que parece que solo tres personas respondieron la pregunta (Scott, goofballLogic y peller) que, para mí, sugiere que la mayoría de la gente desconoce 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 soportados por el objeto Date ()?


Para responder la pregunta, o incluso buscar la respuesta a esta pregunta, debe saber que javascript no es un idioma nuevo; 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 EMCAScript se basan en la implementación temprana de LiveScript / JavaScript). El estándar actual de ECMAScript es 5.1 (2011); en el momento en que se planteó originalmente la pregunta (junio de 2009), el estándar era 3 (4 se abandonaron), pero 5 se publicó poco después de la publicación a finales de 2009. Esto debería plantear un problema; qué estándar puede seguir una implementación de javascript, puede no reflejar lo que está realmente en su lugar, porque a) es una implementación de un estándar dado, b) no todas las implementaciones de un estándar son puritanas, y c) la funcionalidad no se libera en sincronización con un nuevo estándar como d) una implementación es un trabajo constante en progreso

Básicamente, cuando se trata de javascript, se trata de una derivada (javascript específico del navegador) de una implementación (javascript en sí). El V8 de Google, por ejemplo, implementa ECMAScript 5.0, pero JScript de Internet Explorer no intenta ajustarse a ningún estándar ECMAScript, sin embargo, Internet Explorer 9 se ajusta a ECMAScript 5.0.

Cuando se pasa un único argumento a la nueva Fecha (), arroja este prototipo de función:

new Date(value)

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

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


Ambas funciones deberían ser familiares, pero esto no responde inmediatamente a su pregunta y lo que se cuantifica como un "formato de fecha" aceptable requiere una explicación más detallada. Cuando pasa una cadena a la nueva Fecha (), llamará al prototipo (tenga en cuenta que estoy usando la palabra prototipo flojamente; las versiones pueden ser funciones individuales, o puede 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 se trata de 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

A partir de esto, podemos deducir que para obtener el formato de cadena permitido para la nueva Fecha (valor), tenemos que mirar 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 podemos inferir además que las fechas se espera que estén en un Formato ampliado 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 (impuesta por la existencia de esta pregunta en primer lugar), y esto está bien porque ECMAScript permite formatos específicos de implementación. Sin embargo, eso aún 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 sugiero que este es el "mejor" motor de 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 hoy, pero creo que es justo asumir que siguen las expectativas modernas.

Google V8, 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 función de llamada que nos interesa en esta función es para DateParser :: Parse (); ignore la lógica que rodea esas llamadas a funciones, estas son solo comprobaciones para ajustarse al 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. Básicamente, comprueba el estándar EMCAScript 5.0 ISO 8601 y, si no cumple con los estándares, intentará construir la fecha según los formatos heredados. Algunos puntos clave basados ​​en los comentarios:

  1. Las palabras anteriores al primer número que son desconocidas para el analizador son ignoradas.
  2. El texto entre paréntesis se ignora.
  3. Los números sin signo seguidos por ":" se interpretan como un "componente de tiempo".
  4. Los números sin signo seguidos de "." Se interpretan como un "componente de tiempo", y deben ir seguidos de milisegundos.
  5. Los números firmados seguidos por la hora u hora por minuto (por ejemplo, +5: 15 o +0515) se interpretan como la zona horaria.
  6. Al declarar la hora y el minuto, puede usar "hh: mm" o "hhmm".
  7. Las palabras que indican un huso horario se interpretan como un huso horario.
  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. Los símbolos como "+", "-" y no coincidentes ")" no están permitidos 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 estándar compatible con EMCAScript 5.0 ISO 8601.

Así que 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 al observar la siguiente especificación a la que apunta Mozilla en Mozilla Developer Network (compatible con las marcas de tiempo de IETF RFC 2822):

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

Microsoft Developer Network también menciona un estándar adicional para el objeto Date: ECMA-402, la especificación de API de internacionalización de ECMAScript, que es complementaria al estándar ECMAScript 5.1 (y a futuros). Eso se puede encontrar aquí:

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

En cualquier caso, esto debería ayudar a destacar que no existe una "documentación" que represente universalmente todas las implementaciones de javascript, pero todavía hay suficiente documentación disponible para tener un sentido razonable de qué cadenas son aceptables para un objeto Date. Muy la pregunta cargada cuando lo piensas, ¿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

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

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


121
2017-11-19 11:31



Asegúrate de pagar Datejs cuando se trata de fechas en JavaScript. Es bastante impresionante y bien documentado como se puede ver en el caso de Función toString.

EDITAR: Tyler Forsythe señala que esa fecha es obsoleta. Lo uso en mi proyecto actual y no tuve ningún problema con él, sin embargo, debe ser consciente de esto y considerar alternativas.


91
2017-09-07 03:23



Puedes simplemente expandir el Date Objeto con un nuevo format método según lo observado por meizzA continuación, se muestra el código proporcionado 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"));

68
2017-08-31 09:59



La funcionalidad que cita no es Javascript estándar, es probable que no sea portátil en todos los navegadores y, por lo tanto, no es una buena práctica. los Especificación ECMAScript 3 deja el análisis y los formatos de salida funcionan hasta la implementación de Javascript. ECMAScript 5 agrega un subconjunto de soporte 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 soporte de localización extensivo. También puedes ver los métodos en dojo.date.locale.


35
2018-01-17 22:19



Hice este formateador muy simple, es cut / n / pastable (actualizado con la 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/


31
2017-09-28 12:05