Donde puedo encontrar documentación sobre el formato de una fecha en JavaScript?[cerrado]

StackOverflow https://stackoverflow.com/questions/1056728

Pregunta

Me di cuenta de que JavaScript new Date() la función es muy inteligente en la aceptación de las 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")

Yo no podía encontrar la documentación en cualquier lugar que muestra toda la cadena válida formatos mientras llamadas new Date() la función.

Esto es para convertir una cadena a una fecha.Si nos fijamos en el lado opuesto, es decir, convertir una fecha objeto a una cadena, que hasta ahora estaba bajo la impresión de que JavaScript no tiene un built-in API para dar formato a una fecha objeto en una cadena.

Nota del Editor: El siguiente enfoque es el autor de la pregunta del intento que trabajó en un navegador en particular, pero no no el trabajo en general; ver las respuestas en esta página para ver algunos de soluciones reales.

Hoy, he jugado con el toString() método en el objeto date y, sorprendentemente, sirve al propósito de que el formato de fecha a 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í he podido encontrar ninguna documentación en todas las formas en que podemos formato de la fecha objeto en una cadena.

Dónde está la documentación que las listas de los especificadores de formato soportado por el Date() objeto?

¿Fue útil?

Solución

Me encanta 10 maneras de formatee la hora y la fecha usando JavaScript y Trabajando con Fechas .

Básicamente, tienes tres métodos y tienes que combinar las cadenas 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);

Otros consejos

Moment.js

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

(*) peso ligero significa 9.3KB minified + gzipped en la configuración más pequeña posible (febrero de 2014)

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

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

Sin embargo, el selector de fecha solo formatea fechas y no puede formatear horas.

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

Dónde está la documentación que las listas de los especificadores de formato soportado por el Date() objeto?

Me topé con esto hoy y estaba bastante sorprendido de que nadie se tomó el tiempo para responder a esta simple pregunta.Es cierto, hay muchas bibliotecas que hay para ayudar con la fecha de la manipulación.Algunos son mejores que otros.Pero esa no era la pregunta.

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

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

También tenga en cuenta que el Fecha De Propiedades De Objetos sección proporciona un enlace a prototype, que ilustra algunas maneras que usted puede extender la Fecha de objetos con métodos personalizados.Ha habido un poco de debate en el código JavaScript de la comunidad a través de los años acerca de si esto es o no es la mejor práctica, y no estoy abogando a favor o en contra, simplemente señalar su existencia.

Personalizar el formato de la función:

Fijo formatos, una función simple de hacer el trabajo.Siguiente ejemplo generar internacional el formato 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:Es, sin embargo, no suele ser una buena idea para ampliar el Javascript bibliotecas estándar (por ejemplo,mediante la adición de esta función para el prototipo de la Fecha).

Más avanzada la función podría generar configurable de salida basado en un parámetro de formato.Hay un par de buenos ejemplos en esta misma página.

Si para escribir un formato de la función es demasiado largo, hay un montón de bibliotecas de todo lo que hace.Algunas otras respuestas ya enumerarlos.Pero la cada vez mayor dependencia también tiene su contra-parte.

Estándar ECMAScript las funciones de formato:

Desde las versiones más recientes de ECMAscript, el Date la clase tiene algún formato específico de funciones:

toDateString:Depende de la implementación, mostrar sólo 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 a la norma ISO 8601 la fecha y la hora.

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 la configuración regional de formato.

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 la configuración regional de formato.

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 vez en la configuración regional de formato.

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:Genérico toString 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 de salida personalizado de esas funciones de formato:

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

La Respuesta Corta

No es "universal" de la documentación que javascript abastece a;cada navegador que tiene javascript es realmente una aplicación.Sin embargo, no existe un estándar que la mayoría de los navegadores modernos tienden a seguir, y ese es el archivo emcascript estándar;el estándar ECMAScript cadenas iba a llevar, como mínimo, una versión modificada de la aplicación de la definición de ISO 8601.

Además de esto, hay un segundo estándar establecidas por la IETF que los navegadores tienden a seguir así, que es la definición de las marcas de tiempo realizado en la RFC 2822.Documentación real se puede encontrar en la lista de referencias en la parte inferior.

A partir de esto se puede esperar de la funcionalidad básica, sino de lo que "debería" ser no es en sí lo que "es".Voy a ir un poco en profundidad con este procedimiento, aunque, tal y como aparece sólo tres personas en realidad respondió a la pregunta (Scott, goofballLogic, y peller a saber), lo que, para mí, sugiere que la mayoría de las personas no son conscientes de lo que realmente sucede cuando se crea un objeto Date.

El Tiempo De Respuesta

Dónde está la documentación que las listas de los especificadores de formato soportado por la Fecha de() del objeto?


Para responder a la pregunta, o normalmente incluso buscar la respuesta a esta pregunta, usted necesita saber que javascript no es un lenguaje novedoso;en realidad es una aplicación de ECMAScript, y sigue el ECMAScript normas (pero tenga en cuenta, javascript, de hecho, pre-fechado en dichas normas.Archivo emcascript normas se construyen fuera de la pronta aplicación de LiveScript/JavaScript).El actual estándar ECMAScript 5.1 (2011);en el momento en que la pregunta se pidió originalmente (junio '09), el estándar fue de 3 (4 fue abandonado), pero 5 fue puesto en libertad poco después, a finales de 2009.Este debe describir un problema;¿qué estándar de javascript aplicación puede seguir, no pueden reflejar lo que realmente está en su lugar, porque a) es una implementación de una norma determinada, b) no todas las implementaciones de un estándar se puritano, y c) funcionalidad no está publicado en la sincronización con un nuevo estándar en la medida d) de la implementación es un trabajo constante en el progreso

Esencialmente, cuando se trabaja con javascript, usted está tratando con un derivado (javascript específico para el navegador) de una aplicación (javascript en sí).Google V8, por ejemplo, implementa ECMAScript 5.0, pero Internet Explorer JScript no intento de ajustarse a cualquier estándar ECMAScript, sin embargo, Internet Explorer 9 no se ajustan a ECMAScript 5.0.

Cuando un argumento se pasa a new Date(), que arroja este prototipo de función:

new Date(value)

Cuando dos o más argumentos son pasados a new Date(), que arroja este prototipo de función:

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


Ambas funciones deben buscar familiar, pero esto no inmediatamente responder a su pregunta y lo cuantifica como un método aceptable "formato de fecha" requiere una explicación adicional.Cuando se pasa una cadena a new Date(), se va a llamar el prototipo (se nota que estoy usando la palabra prototipo libremente;las versiones pueden ser funciones individuales, o puede ser parte de una instrucción condicional en una sola función) para nueva Fecha(valor) con su cadena como argumento para el "valor" de los parámetros.Esta función comprueba en primer lugar 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

A partir de esto, podemos deducir que para obtener el formato de cadena permitido para la nueva Fecha(valor), tenemos que buscar en el método de la Fecha.parse(string).La documentación de este método se puede encontrar aquí:

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

Y además, podemos inferir que las fechas se espera que sea en una modificación a la norma ISO 8601 Formato Extendido, como se especifica aquí:

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

Sin embargo, se puede reconocer a partir de la experiencia que javascript del objeto Date acepta otros formatos (forzada por la existencia de esta pregunta en el primer lugar), y esto está bien porque ECMAScript permite la implementación formatos específicos.Sin embargo, que todavía no responde a la pregunta de ¿qué documentación está disponible en los formatos disponibles, ni cuáles son los formatos de hecho se permite.Vamos a buscar en Google de javascript de la aplicación, V8;por favor nota: no estoy sugiriendo que este es el "mejor" motor de javascript (¿cómo se puede definir "mejor" o incluso "bueno") y uno no puede asumir que los formatos permitidos en V8 representan todos los formatos disponibles en la actualidad, pero creo que es justo asumir que siga moderno expectativas.

Google V8, date.js, DateConstructor

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

Mirando el DateConstructor función, podemos deducir que tenemos que encontrar la DateParse función;sin embargo, tenga en cuenta que el "año" no es el real año y es sólo una referencia para el "año" de los parámetros.

Google V8, date.js, DateParse

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

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

Google V8, 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 interesa en esta función es para DateParser::Parse();ignorar la lógica que rodean esas llamadas a la función, estos son sólo los cheques para conformar el tipo de codificación (ASCII y CU16).DateParser::Parse se define aquí:

Google V8, 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 lo que formatos acepta.Esencialmente, busca el archivo emcascript 5.0 estándar ISO 8601 y si no es compatible con los estándares, a continuación, se tratará de construir la fecha basada en el legado de los formatos.Algunos puntos clave a partir de los comentarios:

  1. Palabras antes de que el primer número que son desconocidos para el analizador se omiten.
  2. Entre paréntesis texto se omiten.
  3. Números sin signo, seguido de ":" se interpretan como un "componente de tiempo".
  4. Números sin signo, seguido de "." se interpreta como un "componente de tiempo", y que debe ser seguido por milésimas de segundo.
  5. Números con signo, seguido por la hora o hora minuto (por ejemplo,+5:15 o +0515) se interpreta como la zona horaria.
  6. Cuando se declara la hora y los minutos, usted puede utilizar cualquiera de los "hh:mm" o "hhmm".
  7. Palabras que indican una zona de tiempo se interpreta como una zona de tiempo.
  8. Todos los demás números se interpretan como "fecha de componentes".
  9. Todas las palabras que comienzan con los tres primeros dígitos de un mes se interpreta como el mes.
  10. Puede definir minutos y horas y horas en cualquiera de los dos formatos:"hh:mm" o "hhmm".
  11. Símbolos como "+", "-" y sin igual ")" no están permitidos después de un número ha sido procesado.
  12. Los elementos que coinciden con múltiples formatos (por ejemplo,1970-01-01) se procesan como un estándar compatible con archivo emcascript 5.0 ISO 8601 cadena.

Así que esto debería ser suficiente para dar una idea básica de qué esperar cuando se trata de pasar una cadena en un objeto Date.Usted puede ampliar sobre esto mirando la siguiente especificación que Mozilla señala en el Mozilla Developer Network (conforme a la IETF RFC 2822 marcas de tiempo):

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

La Microsoft Developer Network además menciona una norma adicional para la Fecha objeto de:ECMA-402, ECMAScript Internacionalización de la Especificación del API, la cual es complementaria a la de ECMAScript 5.1 estándar (y el futuro).Que se puede encontrar aquí:

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

En cualquier caso, esto debería ayudar a poner de relieve que no existe una "documentación" que universalmente representa todas las implementaciones de javascript, pero todavía hay bastante documentación disponible para hacer razonable el sentido de lo que las cadenas son aceptables para un objeto Date.Bastante cargado pregunta cuando se piensa en ello, ¿sí?:P

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

Asegúrese de pagar Datejs cuando maneje fechas en JavaScript. Es bastante impresionante y está bien documentado, como puede ver en el caso de toString function .

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

Puede simplemente expandir el objeto Date con un nuevo método format como lo señala meizz , a 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"));

La funcionalidad que cita no es 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 análisis y salida 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 un amplio soporte de localización. También puede consultar los métodos en dojo.date.locale .

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

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/

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"

DateJS tiene todas las funciones, pero recomendaría esta LIBRE MUCHO más simple (formato de fecha JavaScript) que prefiero simplemente porque son solo 120 líneas más o menos.

Después de revisar 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"));

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

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

NOTA :

  • Utiliza Object.keys () que no está definido en los 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];
    });
};

USE 

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

Solo para continuar la respuesta sólida 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;
}

No pude encontrar ninguna documentación definitiva sobre formatos de fecha válidos, así que escribí mi propia prueba para ver qué es compatible con 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 cero inicial o el nombre del mes en formato corto o largo, y el número de fecha puede estar con o sin un cero a la izquierda.

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

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

  • 08/2013/09
  • 08/2013/9
  • 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 fecha puede estar con o sin Un cero a la izquierda.

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

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

[Año completo] - [Número de mes] - [Número de fecha] - El número de mes y fecha debe incluir ceros a la izquierda (este es el formato que Tipo de fecha MySQL utiliza)

  • 2013-08-09

Uso de nombres de mes:
Curiosamente, al usar los nombres de los meses 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');

El formato y especialmente las fechas de análisis en JavaScript pueden ser un poco 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 javascript 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, trata de seguir siendo compatible con versiones anteriores e incluso admite cadenas localizadas.

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

Código de ejemplo: 

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

Salida:

  

" 13: 45: 20 "

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

  

Sugar le da mucho amor a la clase Date comenzando con Date.create   método que puede comprender fechas en casi cualquier formato en 15 principales   idiomas, incluidos formatos relativos como " Hace 1 hora " ;. Las fechas pueden   También se emitirá en cualquier formato o idioma utilizando un fácil de entender   sintaxis, con accesos directos a formatos de fecha de uso común. Fecha compleja   la comparación también es posible con métodos como is, que entienden cualquier   formatear y aplicar construido con precisión.

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"

Todos los navegadores

La manera más confiable para dar formato a una fecha con el formato de fuente que se está usando, es la aplicación de los siguientes pasos :

  1. Uso new Date() para crear un Date objeto
  2. Uso .getDate(), .getMonth() y .getFullYear() para obtener, respectivamente, el día, el mes y el año
  3. Pegue las piezas 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

(Ver también este Violín).

Los navegadores modernos sólo

También puede utilizar el built-in .toLocaleDateString método para hacer el formateo para usted.Sólo se necesita pasar a lo largo de la correcta configuración regional y de las opciones para que coincida con el formato correcto, que por desgracia sólo 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

(Ver también este Violín).

(*) De acuerdo a la MDN, "Navegadores modernos" significa Chrome 24+, Firefox 29+, IE11, Edge12+, Opera 15+ y Safari construir todas las noches

Solo otra opción, que escribí:

Biblioteca DP_DateExtensions

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

Admite el formato de fecha / hora, matemática de fecha (partes de fecha de suma / resta), 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 son capaces), pero si solo necesita agregar rápidamente la manipulación de fechas a un proyecto, déle una oportunidad.

La forma correcta de formatear una fecha para devolver " 2012-12-29 " está con el script de Formato de fecha 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');

Si desea mostrar solo el tiempo con dos dígitos, esto puede ayudarlo: 

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

usa estas funciones 

toTimeString() and toLocaleDateString()

consulte el siguiente enlace para obtener más detalles https://developer.mozilla.org/en-US / docs / Web / JavaScript / Reference / Global_Objects / Date

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

Ejemplo: 

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

La respuesta es " en ninguna parte " dado que el formato de fecha es una funcionalidad patentada. No creo que las funciones de toString estén destinadas a ajustarse a un formato específico. p.ej. 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:

  

" El contenido de la cadena depende de la implementación "

Las funciones como los ejemplos a continuación podrían usarse para lograr 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");
}

Si no necesita todas las funciones que ofrece una biblioteca como Moment.js , puede usar mi puerto de strftime . Es ligero (1,35 KB frente a 57,9 KB minimizado 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://stackoverflow.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;
  });
}

Ejemplo de uso: 

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

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

Usar una biblioteca que usa las mismas cadenas de formato que 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á, por supuesto, en línea en php.net

Simplemente incluye el archivo date.js en tu HTML usando tu método preferido y luego llámalo así: 

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

Puede usar d1.getTime () en lugar de valueOf () si lo desea, hacen lo mismo.

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

Muchos marcos (que quizás ya estés usando) tienen un formato de fecha que quizás no conozcas. jQueryUI ya se mencionó, pero otros marcos como Kendo UI (Globalización) , 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")
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top