Comment formater une date JavaScript

Utiliser toLocaleDateString();

la méthode toLocaleDateString() renvoie une chaîne avec une représentation sensible à la langue de la partie date de la date. Les arguments locales et options permettent aux applications de spécifier la langue dont les conventions de formatage doivent être utilisées et permettent de personnaliser le comportement de la fonction.

les valeurs que vous pouvez passer en options pour différentes touches:

1. jour:
   
   La représentation de la journée.
   
   Les valeurs possibles sont" numérique","à deux chiffres".
2. de la semaine:
   
   La représentation du jour de la semaine.
   
   Les valeurs possibles sont" étroite"," courte","longue".
3. année:
   
   La représentation de l'année.
   
   Les valeurs possibles sont" numérique","à deux chiffres".
4. mois:
   
   La représentation du mois.
   
   Les valeurs possibles sont" numérique"," à deux chiffres"," étroite"," courte","longue".
5. heure:
   
   La représentation de l'heure.
   
   Les valeurs possibles sont" numérique","à deux chiffres".
6. minute: La représentation de la minute.
   
   Les valeurs possibles sont" numérique","à deux chiffres".
7. la deuxième:
   
   La représentation de la seconde.
   
   Les valeurs possibles sont" numériques", à deux chiffres".

toutes ces touches sont facultatives. Vous pouvez modifier le nombre de valeurs des options en fonction de vos besoins, et cela reflétera également la présence de chaque date heure terme.

Note: Si vous souhaitez configurer seulement les options de contenu, mais utilisez toujours la locale actuelle, en passant null pour le premier paramètre va causer une erreur. Utilisez undefined à la place.

pour différentes langues:

1. "fr-fr": Pour l'anglais
2. "hi": Pour Hindi 1519230920"
3. "ja-JP": Japonais

vous pouvez utiliser plus d'options linguistiques.

par exemple

var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
var today  = new Date();

console.log(today.toLocaleDateString("en-US")); // 9/17/2016
console.log(today.toLocaleDateString("en-US", options)); // Saturday, September 17, 2016
console.log(today.toLocaleDateString("hi-IN", options)); // शनिवार, 17 सितंबर 2016

vous pouvez également utiliser la méthode toLocaleString() dans le même but. La seule différence est que cette fonction fournit le temps où vous ne passez aucune option.

// Example
9/17/2016, 1:21:34 PM

, les Références:

• toLocaleString()

• toLocaleDateString()

utilisez la date .format bibliothèque :

var dateFormat = require('dateformat');
var now = new Date();
dateFormat(now, "dddd, mmmm dS, yyyy, h:MM:ss TT");

retourne:

Saturday, June 9th, 2007, 5:46:21 PM 

dateformat sur npm

http://jsfiddle.net/phZr7/1 /

si vous devez formater rapidement votre date en utilisant JavaScript, utilisez getDate , getMonth + 1 , getFullYear , getHours et getMinutes :

var d = new Date();

var datestring = d.getDate()  + "-" + (d.getMonth()+1) + "-" + d.getFullYear() + " " +
d.getHours() + ":" + d.getMinutes();

// 16-5-2015 9:50

ou, si vous avez besoin d'être capitonné avec des zéros:

var datestring = ("0" + d.getDate()).slice(-2) + "-" + ("0"+(d.getMonth()+1)).slice(-2) + "-" +
    d.getFullYear() + " " + ("0" + d.getHours()).slice(-2) + ":" + ("0" + d.getMinutes()).slice(-2);

// 16-05-2015 09:50

Eh bien, ce que je voulais était de convertir la date d'aujourd'hui en une MySQL chaîne de date amicale comme 2012-06-23, et d'utiliser cette chaîne comme un paramètre dans une de mes requêtes. La solution simple que j'ai trouvée est la suivante:

var today = new Date().toISOString().slice(0, 10);

gardez à l'esprit que la solution ci-dessus ne pas prendre en compte votre décalage de fuseau horaire.

vous pourriez envisager d'utiliser cette fonction à la place:

function toJSONLocal (date) {
    var local = new Date(date);
    local.setMinutes(date.getMinutes() - date.getTimezoneOffset());
    return local.toJSON().slice(0, 10);
}

cela vous donnera la date correcte dans le cas où vous exécutez ce code autour du début/fin de la journée.

• exemple: http://jsfiddle.net/simo/sapuhzmm /
• Date.toISOString
• Date.toJSON
• de la Chaîne.tranche

si vous êtes déjà en utilisant jQuery UI dans votre projet vous pouvez le faire de cette façon:

var formatted = $.datepicker.formatDate("M d, yy", new Date("2014-07-08T09:02:21.377"));

// formatted will be 'Jul 8, 2014'

certaines options de format datepicker pour jouer avec sont disponibles ici .

fonction de formatage personnalisé:

pour les formats fixes, une fonction simple fait le travail. L'exemple suivant génère le format international AAAA-MM - JJ:

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

console.log(dateToYMD(new Date(2017,10,5))); // Nov 5

le format OP peut être généré comme:

function dateToYMD(date) {
    var strArray=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
    var d = date.getDate();
    var m = strArray[date.getMonth()];
    var y = date.getFullYear();
    return '' + (d <= 9 ? '0' + d : d) + '-' + m + '-' + y;
}
console.log(dateToYMD(new Date(2017,10,5))); // Nov 5

Note: il n'est toutefois généralement pas judicieux d'étendre les bibliothèques standards JavaScript (par exemple en ajoutant cette fonction au prototype de Date).

une fonction plus avancée pourrait générer une sortie configurable basée sur un paramètre de format.

si écrire une fonction de mise en forme est trop long, il ya beaucoup de bibliothèques autour de qui le fait. D'autres réponses les énumèrent déjà. Mais l'augmentation des dépendances a également contre-partie.

Standard ECMAScript fonctions de mise en forme:

depuis plus récente versions D'ECMAScript, la classe Date a quelques fonctions de formatage spécifiques:

toDateString : implémentation dependent, show only the date.

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 : indiquer la date et l'heure 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 pour 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 : implémentation dependent, a date in locale format.

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

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

toLocaleString : implémentation dependent, a date&time in locale format.

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 : mise en œuvre dépendant, un temps au format 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 générique pour Date.

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

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

Note: il est possible de générer une sortie personnalisée à partir de ceux formatage >

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

exemples extraits:

console.log("1) "+  new Date().toDateString());
console.log("2) "+  new Date().toISOString());
console.log("3) "+  new Date().toJSON());
console.log("4) "+  new Date().toLocaleDateString());
console.log("5) "+  new Date().toLocaleString());
console.log("6) "+  new Date().toLocaleTimeString());
console.log("7) "+  new Date().toString());
console.log("8) "+  new Date().toISOString().slice(0,10));

je pense que vous pouvez juste utiliser le non standard méthode de la Date toLocaleFormat(formatString)

formatString: une chaîne de format dans le même format prévu par le strftime() fonction en C.

var today = new Date();
today.toLocaleFormat('%d-%b-%Y'); // 30-Dec-2011

, les Références:

• tolocaleformat
• strftime

JavaScript simple est le meilleur choix pour les petits onetimers.

d'autre part, si vous avez besoin de plus de date stuff, MomentJS est une excellente solution.

par exemple:

moment().format('YYYY-MM-DD HH:m:s');     // now() -> 2015-03-24 14:32:20
moment("20111031", "YYYYMMDD").fromNow(); // 3 years ago
moment("20120620", "YYYYMMDD").fromNow(); // 3 years ago
moment().startOf('day').fromNow();        // 11 hours ago
moment().endOf('day').fromNow();          // in 13 hours

dans les navigateurs modernes (*) , vous pouvez simplement faire ceci:

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

sortie si exécutée aujourd'hui (24 janvier 2016):

'24-Jan-2016'

(*) selon MDN , "navigateurs modernes" signifie Chrome 24+, Firefox 29+, Internet Explorer 11, Edge 12+, Opera 15+ & Safari nightly build .

Vous devriez jeter un oeil à date.js . Il ajoute beaucoup d'aides pour travailler avec des dates, par exemple, dans votre cas:

var date = Date.parse('2010-08-10');
console.log(date.toString('dd-MMM-yyyy'));

pour commencer: http://www.datejs.com/2007/11/27/getting-started-with-datejs /

je peux obtenir votre format demandé dans une ligne en utilisant pas de bibliothèques et pas de méthodes de Date, juste regex:

var d = (new Date()).toString().replace(/\S+\s(\S+)\s(\d+)\s(\d+)\s.*/,'--');
// date will be formatted as "14-Oct-2015" (pass any date object in place of 'new Date()')

mise à jour: comme @RobG l'a souligné, la sortie de Date.prototype.toString () dépend de la mise en œuvre. Donc, utilisez avec prudence et modifiez si nécessaire pour vos implémentations si vous utilisez cette solution. Dans mes tests, cela fonctionne de manière fiable en Amérique du Nord où les principaux navigateurs (Chrome, Safari, Firefox et IE) renvoient tous le même format de chaîne de caractères.

@Sébastien -- alternative tout le support du navigateur

new Date(parseInt(496407600)*1000).toLocaleDateString('de-DE', {
year: 'numeric',
month: '2-digit',
day: '2-digit'
}).replace(/\./g, '/');

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

utilisant un modèle de chaîne de caractères ECMAScript Edition 6 (ES6/ES2015):

let d = new Date();
let formatted = `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;

si vous devez changer les délimiteurs:

const delimiter = '/';
let formatted = [d.getFullYear(), d.getMonth() + 1, d.getDate()].join(delimiter);

voici un code que je viens d'écrire pour gérer le formatage de la date pour un projet sur lequel je travaille. Il imite la fonctionnalité de formatage de date PHP pour répondre à mes besoins. N'hésitez pas à l'utiliser, il s'agit simplement de prolonger l'objet Date() déjà existant. Ce n'est peut-être pas la solution la plus élégante, mais elle répond à mes besoins.

var d = new Date(); 
d_string = d.format("m/d/Y h:i:s");

/**************************************
 * Date class extension
 * 
 */
    // Provide month names
    Date.prototype.getMonthName = function(){
        var month_names = [
                            'January',
                            'February',
                            'March',
                            'April',
                            'May',
                            'June',
                            'July',
                            'August',
                            'September',
                            'October',
                            'November',
                            'December'
                        ];

        return month_names[this.getMonth()];
    }

    // Provide month abbreviation
    Date.prototype.getMonthAbbr = function(){
        var month_abbrs = [
                            'Jan',
                            'Feb',
                            'Mar',
                            'Apr',
                            'May',
                            'Jun',
                            'Jul',
                            'Aug',
                            'Sep',
                            'Oct',
                            'Nov',
                            'Dec'
                        ];

        return month_abbrs[this.getMonth()];
    }

    // Provide full day of week name
    Date.prototype.getDayFull = function(){
        var days_full = [
                            'Sunday',
                            'Monday',
                            'Tuesday',
                            'Wednesday',
                            'Thursday',
                            'Friday',
                            'Saturday'
                        ];
        return days_full[this.getDay()];
    };

    // Provide full day of week name
    Date.prototype.getDayAbbr = function(){
        var days_abbr = [
                            'Sun',
                            'Mon',
                            'Tue',
                            'Wed',
                            'Thur',
                            'Fri',
                            'Sat'
                        ];
        return days_abbr[this.getDay()];
    };

    // Provide the day of year 1-365
    Date.prototype.getDayOfYear = function() {
        var onejan = new Date(this.getFullYear(),0,1);
        return Math.ceil((this - onejan) / 86400000);
    };

    // Provide the day suffix (st,nd,rd,th)
    Date.prototype.getDaySuffix = function() {
        var d = this.getDate();
        var sfx = ["th","st","nd","rd"];
        var val = d%100;

        return (sfx[(val-20)%10] || sfx[val] || sfx[0]);
    };

    // Provide Week of Year
    Date.prototype.getWeekOfYear = function() {
        var onejan = new Date(this.getFullYear(),0,1);
        return Math.ceil((((this - onejan) / 86400000) + onejan.getDay()+1)/7);
    } 

    // Provide if it is a leap year or not
    Date.prototype.isLeapYear = function(){
        var yr = this.getFullYear();

        if ((parseInt(yr)%4) == 0){
            if (parseInt(yr)%100 == 0){
                if (parseInt(yr)%400 != 0){
                    return false;
                }
                if (parseInt(yr)%400 == 0){
                    return true;
                }
            }
            if (parseInt(yr)%100 != 0){
                return true;
            }
        }
        if ((parseInt(yr)%4) != 0){
            return false;
        } 
    };

    // Provide Number of Days in a given month
    Date.prototype.getMonthDayCount = function() {
        var month_day_counts = [
                                    31,
                                    this.isLeapYear() ? 29 : 28,
                                    31,
                                    30,
                                    31,
                                    30,
                                    31,
                                    31,
                                    30,
                                    31,
                                    30,
                                    31
                                ];

        return month_day_counts[this.getMonth()];
    } 

    // format provided date into this.format format
    Date.prototype.format = function(dateFormat){
        // break apart format string into array of characters
        dateFormat = dateFormat.split("");

        var date = this.getDate(),
            month = this.getMonth(),
            hours = this.getHours(),
            minutes = this.getMinutes(),
            seconds = this.getSeconds();
        // get all date properties ( based on PHP date object functionality )
        var date_props = {
            d: date < 10 ? '0'+date : date,
            D: this.getDayAbbr(),
            j: this.getDate(),
            l: this.getDayFull(),
            S: this.getDaySuffix(),
            w: this.getDay(),
            z: this.getDayOfYear(),
            W: this.getWeekOfYear(),
            F: this.getMonthName(),
            m: month < 10 ? '0'+(month+1) : month+1,
            M: this.getMonthAbbr(),
            n: month+1,
            t: this.getMonthDayCount(),
            L: this.isLeapYear() ? '1' : '0',
            Y: this.getFullYear(),
            y: this.getFullYear()+''.substring(2,4),
            a: hours > 12 ? 'pm' : 'am',
            A: hours > 12 ? 'PM' : 'AM',
            g: hours % 12 > 0 ? hours % 12 : 12,
            G: hours > 0 ? hours : "12",
            h: hours % 12 > 0 ? hours % 12 : 12,
            H: hours,
            i: minutes < 10 ? '0' + minutes : minutes,
            s: seconds < 10 ? '0' + seconds : seconds           
        };

        // loop through format array of characters and add matching data else add the format character (:,/, etc.)
        var date_string = "";
        for(var i=0;i<dateFormat.length;i++){
            var f = dateFormat[i];
            if(f.match(/[a-zA-Z]/g)){
                date_string += date_props[f] ? date_props[f] : '';
            } else {
                date_string += f;
            }
        }

        return date_string;
    };
/*
 *
 * END - Date class extension
 * 
 ************************************/

si vous utilisez jQuery UI dans votre code, il y a une fonction intégrée appelée formatDate() . Je l'utilise de cette façon pour formater la date d'aujourd'hui:

var testdate = Date();
testdate = $.datepicker.formatDate( "d-M-yy",new Date(testdate));
alert(testdate);

vous pouvez voir beaucoup d'autres exemples de date de formatage dans la documentation de L'UI jQuery .

nous avons beaucoup de solutions pour cela, mais je pense que le meilleur d'entre eux est Moment.js. Donc je suggère personnellement D'utiliser le Moment.js pour la date et l'heure des opérations.

console.log(moment().format('DD-MMM-YYYY'));

<script src="//cdnjs.cloudflare.com/ajax/libs/moment.js/2.14.1/moment.min.js"></script>

solution JavaScript sans utiliser de bibliothèques externes:

var now = new Date()
months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
var formattedDate = now.getDate()+"-"+months[now.getMonth()]+"-"+now.getFullYear()
alert(formattedDate)

Voici comment j'ai implémenté mes plugins npm

var monthNames = [
  "January", "February", "March",
  "April", "May", "June", "July",
  "August", "September", "October",
  "November", "December"
];

var Days = [
  "Sunday", "Monday", "Tuesday", "Wednesday",
  "Thursday", "Friday", "Saturday"
];

var formatDate = function(dt,format){
  format = format.replace('ss', pad(dt.getSeconds(),2));
  format = format.replace('s', dt.getSeconds());
  format = format.replace('dd', pad(dt.getDate(),2));
  format = format.replace('d', dt.getDate());
  format = format.replace('mm', pad(dt.getMinutes(),2));
  format = format.replace('m', dt.getMinutes());
  format = format.replace('MMMM', monthNames[dt.getMonth()]);
  format = format.replace('MMM', monthNames[dt.getMonth()].substring(0,3));
  format = format.replace('MM', pad(dt.getMonth()+1,2));
  format = format.replace(/M(?![ao])/, dt.getMonth()+1);
  format = format.replace('DD', Days[dt.getDay()]);
  format = format.replace(/D(?!e)/, Days[dt.getDay()].substring(0,3));
  format = format.replace('yyyy', dt.getFullYear());
  format = format.replace('YYYY', dt.getFullYear());
  format = format.replace('yy', (dt.getFullYear()+"").substring(2));
  format = format.replace('YY', (dt.getFullYear()+"").substring(2));
  format = format.replace('HH', pad(dt.getHours(),2));
  format = format.replace('H', dt.getHours());
  return format;
}

pad = function(n, width, z) {
  z = z || '0';
  n = n + '';
  return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
}

new Date().toLocaleDateString()

// "3/21/2018"

plus de documentation à developer.mozilla.org

une manière utile et flexible de formater les DateTimes en JavaScript est Intl.DateTimeFormat :

var date = new Date();
var options = { year: 'numeric', month: 'short', day: '2-digit'};
var _resultDate = new Intl.DateTimeFormat('en-GB', options).format(date);
// The _resultDate is: "12 Oct 2017"
// Replace all spaces with - and then log it.
console.log(_resultDate.replace(/ /g,'-'));

Résultat: "12-Oct-2017"

les formats date et heure peuvent être personnalisés en utilisant l'argument options.

l'objet Intl.DateTimeFormat est un constructeur d'objets qui permet le formatage de date et d'heure sensible au langage.

syntaxe

new Intl.DateTimeFormat([locales[, options]])
Intl.DateTimeFormat.call(this[, locales[, options]])

paramètres

locales

facultatif. Une chaîne avec une balise de langage BCP 47, ou un tableau de telles chaînes. Pour la forme générale et l'interprétation de l'argument des locales, voir la page Intl. Les clés D'extension Unicode suivantes sont autorisées:

nu
Numbering system. Possible values include: "arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt".
ca
Calendar. Possible values include: "buddhist", "chinese", "coptic", "ethioaa", "ethiopic", "gregory", "hebrew", "indian", "islamic", "islamicc", "iso8601", "japanese", "persian", "roc".

Options

facultatif. Un objet avec une partie ou la totalité du propriétés suivantes:

localeMatcher

La locale correspondant à l'algorithme à utiliser. Les valeurs possibles sont "lookup" et "best fit" ; la valeur par défaut est "best fit" . Pour plus d'informations sur cette option, Voir la page Intl.

timeZone

Le fuseau horaire à utiliser. La seule valeur que les implémentations doivent reconnaître est "UTC" ; la valeur par défaut est exécution du fuseau horaire par défaut. Les implémentations peuvent également reconnaître les noms de fuseaux horaires de la base de données de fuseaux horaires IANA, tels que "Asia/Shanghai" , "Asia/Kolkata" , "America/New_York" .

12heures

S'il faut utiliser une période de 12 heures (par opposition à une période de 24 heures). Les valeurs possibles sont true et false ; la valeur par défaut dépend de la localisation.

formatMatcher

le format algorithme de correspondance à utiliser. Les valeurs possibles sont "basic" et "best fit" ; la valeur par défaut est "best fit" . Pour en savoir plus sur l'utilisation de ce bien, consultez les paragraphes suivants.

les propriétés suivantes décrivent les composantes date-heure à utiliser dans la sortie formatée et leurs représentations désirées. Les implémentations sont nécessaires pour supporter au moins les sous-ensembles suivants:

weekday, year, month, day, hour, minute, second
weekday, year, month, day
year, month, day
year, month
month, day
hour, minute, second
hour, minute

implémentations may soutien à d'autres sous-ensembles, et les demandes seront négociés contre tous disponibles sous-représentation des combinaisons pour trouver la meilleure correspondance. Deux algorithmes sont disponibles pour cette négociation et sélectionnés par la propriété formatMatcher: un algorithme "basic" entièrement spécifié et un algorithme "best fit" dépendant de l'implémentation.

la semaine

la représentation du jour de la semaine. Les valeurs possibles sont "narrow" , "short" , "long" .

ère

La représentation de l'époque. Les valeurs possibles sont "narrow" , "short" , "long" .

année

La représentation de l'année. Les valeurs possibles sont "numeric" , "2-digit" .

mois

le la représentation du mois. Les valeurs possibles sont "numeric" , "2-digit" , "narrow" , "short" , "long" .

jour

la représentation du jour. Les valeurs possibles sont "numeric" , "2-digit" .

heure

La représentation de l'heure. Les valeurs possibles sont "numeric" , "2-digit" .

minute

la représentation de La minute. Les valeurs possibles sont "numeric" , "2-digit" .

deuxième

la représentation du second. Les valeurs possibles sont "numeric" , "2-digit" .

timeZoneName

la représentation du nom du fuseau horaire. Valeurs possibles sont "short" , "long" . La valeur par défaut pour chaque propriété de la composante date-heure n'est pas définie, mais si toutes les propriétés de la composante ne sont pas définies, alors l'année, le mois et le jour sont supposés être "numeric" .

Consultez En Ligne

Plus De Détails

var today = new Date();
var formattedToday = today.toLocaleDateString() + ' ' + today.toLocaleTimeString();

OK , nous avons quelque chose appelé Intl qui est très utile pour formater une date en JavaScript:

votre date comme ci-dessous:

var date = '10/8/2010';

et vous changer de Date en utilisant la nouvelle Date () comme ci-dessous:

date = new Date(date);

et maintenant vous pouvez le formater de n'importe quelle façon vous aimez en utilisant une liste de locales comme ci-dessous:

date = new Intl.DateTimeFormat('en-AU').format(date); // Australian date format: "8/10/2010" 

date = new Intl.DateTimeFormat('en-US').format(date); // USA date format: "10/8/2010" 

date = new Intl.DateTimeFormat('ar-EG').format(date);  // Arabic date format: "٨‏/١٠‏/٢٠١٠"

si vous voulez exactement le format que vous avez mentionné ci-dessus, vous pouvez faire:

date = new Date(Date.UTC(2010, 7, 10, 0, 0, 0));
var options = {year: "numeric", month: "short", day: "numeric"};
date = new Intl.DateTimeFormat("en-AU", options).format(date).replace(/\s/g, '-');

et le résultat sera:

"10-Aug-2010"

pour plus de détails sur API D'internationalisation D'ECMAScript (Intl) , visitez ici .

de Sucre.js a d'excellentes extensions à L'objet Date, y compris une Date .format méthode.

exemples tirés de la documentation:

Date.create().format('{Weekday} {Month} {dd}, {yyyy}');

Date.create().format('{12hr}:{mm}{tt}')

Bonjour vérifiez si cela aide avec votre problème.

var d = new Date();

var options = {   
    day: 'numeric',
    month: 'long', 
    year: 'numeric'
};

console.log(d.toLocaleDateString('en-ZA', options));

pour toute personne à la recherche d'une solution ES6 très simple à copier-coller.

const dateToString = d => `${d.getFullYear()}-${('00' + (d.getMonth() + 1)).slice(-2)}-${('00' + d.getDate()).slice(-2)}` 

// how to use:
const myDate = new Date(Date.parse('04 Dec 1995 00:12:00 GMT'))
console.log(dateToString(myDate)) // 1995-12-04

essayez ceci:

function init(){
    var d = new Date();
    var day = d.getDate();
    var x = d.toDateString().substr(4, 3);
    var year = d.getFullYear();
    document.querySelector("#mydate").innerHTML = day + '-' + x + '-' + year;
}
window.onload = init;

<div id="mydate"></div>

voici un script qui fait exactement ce que vous voulez""

https://github.com/UziTech/js-date-format

var d = new Date("2010-8-10");
document.write(d.format("DD-MMM-YYYY"));

si vous désirez une fonction courte et lisible par l'homme, celle-ci est facilement réglable pour vous convenir.

le paramètre timeStamp est en millisecondes à partir de 1970 - il est retourné par new Date().getTime() et de nombreux autres appareils...

OK, j'ai changé d'avis. J'ai inclus une fonction supplémentaire pour zéro de remplissage. Malédictions!

 function zeroPad(aNumber) {
     return ("0"+aNumber).slice(-2);
 }
 function humanTime(timeStamp) {
    var M = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
    var D = new Date(timeStamp); // 23 Aug 2016 16:45:59 <-- Desired format.
    return D.getDate() + " " + M[D.getMonth()] + " " + D.getFullYear() + " " + D.getHours() + ":" + zeroPad(d.getMinutes()) + ":" + zeroPad(D.getSeconds());
 }

il y a une nouvelle bibliothèque, smarti.to.js , pour le formatage localisé des numéros JavaScript, des dates et des dates JSON (Microsoft ou ISO8601).

exemple:

new Date('2015-1-1').to('dd.MM.yy')         // Outputs 01.01.2015
"2015-01-01T10:11:12.123Z".to('dd.MM.yy')   // Outputs 01.01.2015

il y a aussi des motifs courts personnalisés définis dans le fichier de localisation (smarti.to.{culture}.js). Exemple (smarti.to.et-EE.js):

new Date('2015-1-1').to('d')                // Outputs 1.01.2015

et une capacité de multiformatage:

smarti.format('{0:n2} + {1:n2} = {2:n2}', 1, 2, 3)   // Output: 1,00 + 2,00 = 3,00