Jak przekonwertować ciąg na datę w JavaScript?

var st = "date in some format"
var dt = new date();

var dt_st= //st in date format same as dt

Najlepszym formatem ciągów do analizowania ciągów jest format daty ISO wraz z konstruktorem obiektów JavaScript Date.

Przykłady formatu ISO: YYYY-MM-DDlub YYYY-MM-DDTHH:MM:SS.

Ale poczekaj! Samo użycie „formatu ISO” samo w sobie nie działa niezawodnie. Ciągi są czasami analizowane jako UTC, a czasem jako czas lokalny (na podstawie dostawcy przeglądarki i wersji). Najlepszą praktyką powinno być zawsze przechowywanie dat jako UTC i wykonywanie obliczeń jako UTC.

Aby parsować datę jako UTC, dołącz Z - np new Date('2011-04-11T10:20:30Z'). :

Aby wyświetlić datę w UTC, użyj .toUTCString(),
aby wyświetlić datę w czasie lokalnym użytkownika, użyj .toString().

Więcej informacji na temat MDN | Data i ta odpowiedź .

W przypadku starej zgodności z programem Internet Explorer (wersje IE mniejsze niż 9 nie obsługują formatu ISO w Konstruktorze daty), należy podzielić reprezentację ciągu datetime na jego części, a następnie można użyć konstruktora, używając części datetime, np new Date('2011', '04' - 1, '11', '11', '51', '00'). : Pamiętaj, że liczba miesięcy musi być o 1 mniejsza.

Metoda alternatywna - użyj odpowiedniej biblioteki:

Możesz także skorzystać z biblioteki Moment.js, która umożliwia analizowanie daty w określonej strefie czasowej.

Niestety dowiedziałem się o tym

var mydate = new Date('2014-04-03');
console.log(mydate.toDateString());

zwraca „Środa 02 kwietnia 2014”. Wiem, że to brzmi szalenie, ale zdarza się, że niektórzy użytkownicy.

Roztwór kuloodporne jest następujący:

var parts ='2014-04-03'.split('-');
// Please pay attention to the month (parts[1]); JavaScript counts months from 0:
// January - 0, February - 1, etc.
var mydate = new Date(parts[0], parts[1] - 1, parts[2]); 
console.log(mydate.toDateString());

var st = "26.04.2013";
var pattern = /(\d{2})\.(\d{2})\.(\d{4})/;
var dt = new Date(st.replace(pattern,'$3-$2-$1'));

Wyjście będzie:

dt => Date {Fri Apr 26 2013}

function stringToDate(_date,_format,_delimiter)
{
            var formatLowerCase=_format.toLowerCase();
            var formatItems=formatLowerCase.split(_delimiter);
            var dateItems=_date.split(_delimiter);
            var monthIndex=formatItems.indexOf("mm");
            var dayIndex=formatItems.indexOf("dd");
            var yearIndex=formatItems.indexOf("yyyy");
            var month=parseInt(dateItems[monthIndex]);
            month-=1;
            var formatedDate = new Date(dateItems[yearIndex],month,dateItems[dayIndex]);
            return formatedDate;
}

stringToDate("17/9/2014","dd/MM/yyyy","/");
stringToDate("9/17/2014","mm/dd/yyyy","/")
stringToDate("9-17-2014","mm-dd-yyyy","-")

moment.js ( http://momentjs.com/ ) to kompletny i dobry pakiet dla dat użycia i obsługuje ciągi ISO 8601 .

Możesz dodać datę i format ciągu.

moment("12-25-1995", "MM-DD-YYYY");

I możesz sprawdzić, czy data jest ważna.

moment("not a real date").isValid(); //Returns false

Niektóre przykłady wyświetlania

let dt = moment("02-01-2019", "MM-DD-YYYY");
console.log(dt.fromNow()+' |'+dt.format('LL')) 
// output: "3 months ago | February 1, 2019"

Zobacz dokumentację http://momentjs.com/docs/#/parsing/string-format/

Zalecenie: Polecam używać pakietu dla dat, który zawiera wiele formatów, ponieważ zarządzanie strefą czasową i formatowaniem czasu jest naprawdę dużym problemem, ponieważ js rozwiązuje wiele formatów. Można łatwo parsować datę od prostego ciągu do tej pory, ale myślę, że ciężko jest poprzeć wszystkie formaty i odmiany dat.

Przekaż jako argument do Date ():

var st = "date in some format"
var dt = new Date(st);

Można uzyskać dostęp datę, miesiąc, rok, stosując na przykład: dt.getMonth().

Jeśli możesz skorzystać ze wspaniałej biblioteki momentów (np. W projekcie Node.js), możesz łatwo przeanalizować datę, używając np.

var momentDate = moment("2014-09-15 09:00:00");

i może uzyskać dostęp do obiektu daty JS za pośrednictwem

momentDate ().toDate();

new Date(2000, 10, 1) da ci „Śro 01 listopada 2000 00:00:00 GMT + 0100 (CET)”

Zobacz, że 0 za miesiąc daje ci styczeń

Dla tych, którzy szukają małego i inteligentnego rozwiązania:

String.prototype.toDate = function(format)
{
  var normalized      = this.replace(/[^a-zA-Z0-9]/g, '-');
  var normalizedFormat= format.toLowerCase().replace(/[^a-zA-Z0-9]/g, '-');
  var formatItems     = normalizedFormat.split('-');
  var dateItems       = normalized.split('-');

  var monthIndex  = formatItems.indexOf("mm");
  var dayIndex    = formatItems.indexOf("dd");
  var yearIndex   = formatItems.indexOf("yyyy");
  var hourIndex     = formatItems.indexOf("hh");
  var minutesIndex  = formatItems.indexOf("ii");
  var secondsIndex  = formatItems.indexOf("ss");

  var today = new Date();

  var year  = yearIndex>-1  ? dateItems[yearIndex]    : today.getFullYear();
  var month = monthIndex>-1 ? dateItems[monthIndex]-1 : today.getMonth()-1;
  var day   = dayIndex>-1   ? dateItems[dayIndex]     : today.getDate();

  var hour    = hourIndex>-1      ? dateItems[hourIndex]    : today.getHours();
  var minute  = minutesIndex>-1   ? dateItems[minutesIndex] : today.getMinutes();
  var second  = secondsIndex>-1   ? dateItems[secondsIndex] : today.getSeconds();

  return new Date(year,month,day,hour,minute,second);
};

Przykład:

"22/03/2016 14:03:01".toDate("dd/mm/yyyy hh:ii:ss");
"2016-03-29 18:30:00".toDate("yyyy-mm-dd hh:ii:ss");

Właśnie new Date(st);

Zakładając, że jest to właściwy format .

Jeśli chcesz przekonwertować z formatu „dd / MM / rrrr”. Oto przykład:

var pattern = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/;
var arrayDate = stringDate.match(pattern);
var dt = new Date(arrayDate[3], arrayDate[2] - 1, arrayDate[1]);

To rozwiązanie działa w wersjach IE mniejszych niż 9.

Znaczniki czasu należy rzutować na liczbę

var ts = '1471793029764';
ts = Number(ts); // cast it to a Number
var date = new Date(ts); // works

var invalidDate = new Date('1471793029764'); // does not work. Invalid Date

Date.parseprawie dostaje to, czego chcesz. Dusi się na części am/ pm, ale przy pewnym hakowaniu możesz go uruchomić:

var str = 'Sun Apr 25, 2010 3:30pm',
    timestamp;

timestamp = Date.parse(str.replace(/[ap]m$/i, ''));

if(str.match(/pm$/i) >= 0) {
    timestamp += 12 * 60 * 60 * 1000;
}

Konwertuj na format pt-BR:

    var dateString = "13/10/2014";
    var dataSplit = dateString.split('/');
    var dateConverted;

    if (dataSplit[2].split(" ").length > 1) {

        var hora = dataSplit[2].split(" ")[1].split(':');
        dataSplit[2] = dataSplit[2].split(" ")[0];
        dateConverted = new Date(dataSplit[2], dataSplit[1]-1, dataSplit[0], hora[0], hora[1]);

    } else {
        dateConverted = new Date(dataSplit[2], dataSplit[1] - 1, dataSplit[0]);
    }

Mam nadzieję, że komuś pomogę !!!

Stworzyłem do tego skrzypce, możesz użyć funkcji toDate () na dowolnym ciągu daty i podać format daty. Spowoduje to zwrócenie obiektu Date. https://jsfiddle.net/Sushil231088/q56yd0rp/

"17/9/2014".toDate("dd/MM/yyyy", "/")

Do konwersji ciągów do tej pory w js używam http://momentjs.com/

moment().format('MMMM Do YYYY, h:mm:ss a'); // August 16th 2015, 4:17:24 pm
moment().format('dddd');                    // Sunday
moment().format("MMM Do YY");               // Aug 16th 15
moment().format('YYYY [escaped] YYYY');     // 2015 escaped 2015
moment("20111031", "YYYYMMDD").fromNow(); // 4 years ago
moment("20120620", "YYYYMMDD").fromNow(); // 3 years ago
moment().startOf('day').fromNow();        // 16 hours ago
moment().endOf('day').fromNow();          // in 8 hours

Zrobiłem tę funkcję, aby przekonwertować dowolny obiekt Date na obiekt Date UTC.

function dateToUTC(date) {
    return new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds());
}


dateToUTC(new Date());

Jeszcze inny sposób na zrobienie tego:

String.prototype.toDate = function(format) {
    format = format || "dmy";
    var separator = this.match(/[^0-9]/)[0];
    var components = this.split(separator);
    var day, month, year;
    for (var key in format) {
        var fmt_value = format[key];
        var value = components[key];
        switch (fmt_value) {
            case "d":
                day = parseInt(value);
                break;
            case "m":
                month = parseInt(value)-1;
                break;
            case "y":
                year = parseInt(value);
        }
    }
    return new Date(year, month, day);
};
a = "3/2/2017";
console.log(a.toDate("dmy"));
// Date 2017-02-03T00:00:00.000Z

Możesz spróbować:

function formatDate(userDOB) {
  const dob = new Date(userDOB);

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

  const day = dob.getDate();
  const monthIndex = dob.getMonth();
  const year = dob.getFullYear();

  // return day + ' ' + monthNames[monthIndex] + ' ' + year;
  return `${day} ${monthNames[monthIndex]} ${year}`;
}

console.log(formatDate('1982-08-10'));

var date = new Date(year, month, day);

lub

var date = new Date('01/01/1970');

Ciąg daty w formacie „01-01-1970” nie będzie działał w FireFox, więc lepiej użyć „/” zamiast „-” w ciągu formatu daty.

Jeśli musisz sprawdzić zawartość ciągu przed konwersją do formatu daty:

// Convert 'M/D/YY' to Date()
mdyToDate = function(mdy) {
  var d = mdy.split(/[\/\-\.]/, 3);

  if (d.length != 3) return null;

  // Check if date is valid
  var mon = parseInt(d[0]), 
      day = parseInt(d[1]),
      year= parseInt(d[2]);
  if (d[2].length == 2) year += 2000;
  if (day <= 31 && mon <= 12 && year >= 2015)
    return new Date(year, mon - 1, day);

  return null; 
}

Utworzyłem funkcję parseDateTime, aby przekonwertować ciąg na obiekt daty i działa on we wszystkich przeglądarkach (w tym w przeglądarce IE), sprawdź, czy ktoś jest wymagany, odwołanie https://github.com/Umesh-Markande/Parse-String-to-Date we wszystkich przeglądarkach

    function parseDateTime(datetime) {
            var monthNames = [
                "January", "February", "March",
                "April", "May", "June", "July",
                "August", "September", "October",
                "November", "December"
              ];
            if(datetime.split(' ').length == 3){
                var date = datetime.split(' ')[0];
                var time = datetime.split(' ')[1].replace('.00','');
                var timearray = time.split(':');
                var hours = parseInt(time.split(':')[0]);
                var format = datetime.split(' ')[2];
                var bits = date.split(/\D/);
                date = new Date(bits[0], --bits[1], bits[2]); /* if you change format of datetime which is passed to this function, you need to change bits e.x ( bits[0], bits[1], bits[2 ]) position as per date, months and year it represent bits array.*/
                var day = date.getDate();
                var monthIndex = date.getMonth();
                var year = date.getFullYear();
                if ((format === 'PM' || format === 'pm') && hours !== 12) {
                    hours += 12;
                    try{  time = hours+':'+timearray[1]+':'+timearray[2] }catch(e){ time = hours+':'+timearray[1] }
                } 
                var formateddatetime = new Date(monthNames[monthIndex] + ' ' + day + '  ' + year + ' ' + time);
                return formateddatetime;
            }else if(datetime.split(' ').length == 2){
                var date = datetime.split(' ')[0];
                var time = datetime.split(' ')[1];
                var bits = date.split(/\D/);
                var datetimevalue = new Date(bits[0], --bits[1], bits[2]); /* if you change format of datetime which is passed to this function, you need to change bits e.x ( bits[0], bits[1], bits[2 ]) position as per date, months and year it represent bits array.*/
                var day = datetimevalue.getDate();
                var monthIndex = datetimevalue.getMonth();
                var year = datetimevalue.getFullYear();
                var formateddatetime = new Date(monthNames[monthIndex] + ' ' + day + '  ' + year + ' ' + time);
                return formateddatetime;
            }else if(datetime != ''){
                var bits = datetime.split(/\D/);
                var date = new Date(bits[0], --bits[1], bits[2]); /* if you change format of datetime which is passed to this function, you need to change bits e.x ( bits[0], bits[1], bits[2 ]) position as per date, months and year it represent bits array.*/
                return date;
            }
            return datetime;
        }

    var date1 = '2018-05-14 05:04:22 AM';   // yyyy-mm-dd hh:mm:ss A
    var date2 = '2018/05/14 05:04:22 AM';   // yyyy/mm/dd hh:mm:ss A
    var date3 = '2018/05/04';   // yyyy/mm/dd
    var date4 = '2018-05-04';   // yyyy-mm-dd
    var date5 = '2018-05-14 15:04:22';   // yyyy-mm-dd HH:mm:ss
    var date6 = '2018/05/14 14:04:22';   // yyyy/mm/dd HH:mm:ss

    console.log(parseDateTime(date1))
    console.log(parseDateTime(date2))
    console.log(parseDateTime(date3))
    console.log(parseDateTime(date4))
    console.log(parseDateTime(date5))
    console.log(parseDateTime(date6))

**Output---**
Mon May 14 2018 05:04:22 GMT+0530 (India Standard Time)
Mon May 14 2018 05:04:22 GMT+0530 (India Standard Time)
Fri May 04 2018 00:00:00 GMT+0530 (India Standard Time)
Fri May 04 2018 00:00:00 GMT+0530 (India Standard Time)
Mon May 14 2018 15:04:22 GMT+0530 (India Standard Time)
Mon May 14 2018 14:04:22 GMT+0530 (India Standard Time)

Ta odpowiedź opiera się na odpowiedzi Kassem, ale obsługuje również dwucyfrowe lata. Przesłałem poprawkę do odpowiedzi Kassem, ale jeśli nie została zaakceptowana, przesyłam ją również jako osobną odpowiedź.

function stringToDate(_date,_format,_delimiter) {
        var formatLowerCase=_format.toLowerCase();
        var formatItems=formatLowerCase.split(_delimiter);
        var dateItems=_date.split(_delimiter);
        var monthIndex=formatItems.indexOf("mm");
        var dayIndex=formatItems.indexOf("dd");
        var yearIndex=formatItems.indexOf("yyyy");
        var year = parseInt(dateItems[yearIndex]); 
        // adjust for 2 digit year
        if (year < 100) { year += 2000; }
        var month=parseInt(dateItems[monthIndex]);
        month-=1;
        var formatedDate = new Date(year,month,dateItems[dayIndex]);
        return formatedDate;
}

stringToDate("17/9/14","dd/MM/yyyy","/");
stringToDate("17/9/2014","dd/MM/yyyy","/");
stringToDate("9/17/2014","mm/dd/yyyy","/")
stringToDate("9-17-2014","mm-dd-yyyy","-")

Możesz użyć wyrażenia regularnego, aby przeanalizować ciąg znaków do szczegółów czasu, a następnie utworzyć datę lub dowolny format zwracany, taki jak:

//example : let dateString = "2018-08-17 01:02:03.4"

function strToDate(dateString){
    let reggie = /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}).(\d{1})/
  , [,year, month, day, hours, minutes, seconds, miliseconds] = reggie.exec(dateString)
  , dateObject = new Date(year, month-1, day, hours, minutes, seconds, miliseconds);
  return dateObject;
}
alert(strToDate(dateString));

Wydajność

Dzisiaj (2020.05.08) Wykonuję testy dla wybranych rozwiązań - dla dwóch przypadków: data wejściowa to ciąg ISO8601 (Ad, Bd, Cd, Dd, Ed), a data wejściowa to znacznik czasu (At, Ct, Dt). Rozwiązania Bd, Cd, Ct nie zwracają obiektu js Date jako wyników, ale dodaję je, ponieważ mogą być przydatne, ale nie porównuję ich z prawidłowymi rozwiązaniami. Te wyniki mogą być przydatne do masowej analizy dat.

Wnioski

• Rozwiązanie new Date (reklama) jest 50-100 razy szybsze niż moment.js (Dd) we wszystkich przeglądarkach pod kątem daty i znacznika czasu ISO
• Rozwiązanie new Date(reklama) jest ~ 10 razy szybsze niżparseDate (Ed)
• Rozwiązanie Date.parse(Bd) jest najszybsze, jeśli musimy pobrać znacznik czasu od daty ISO we wszystkich przeglądarkach

Detale

Przeprowadzam test na MacOs High Sierra 10.13.6 na Chrome 81.0, Safari 13.1, Firefox 75.0. Rozwiązanie parseDate(Ed) używa new Date(0)i ręcznie ustawia składniki daty UTC.

let ds = '2020-05-14T00:00Z'; // Valid ISO8601 UTC date
let ts = +'1589328000000';    // timestamp

let Ad = new Date(ds);
let Bd = Date.parse(ds);
let Cd = moment(ds);
let Dd = moment(ds).toDate();
let Ed = parseDate(ds);

let At = new Date(ts);
let Ct = moment(ts);
let Dt = moment(ts).toDate();

log = (n,d) => console.log(`${n}: ${+d} ${d}`);

console.log('from date string:', ds)
log('Ad', Ad);
log('Bd', Bd);
log('Cd', Cd);
log('Dd', Dd);
log('Ed', Ed);
console.log('from timestamp:', ts)
log('At', At);
log('Ct', Ct);
log('Dt', Dt);



function parseDate(dateStr) {
  let [year,month,day] = dateStr.split(' ')[0].split('-');
  let d=new Date(0);
  d.setUTCFullYear(year);
  d.setUTCMonth(month-1);
  d.setUTCDate(day)
  return d;
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.19.1/moment-with-locales.min.js"></script>

This snippet only presents used soultions  

Wyniki dla chrome

Datasceny w formacie ISO 8601, tak doskonałe jak standard, nadal nie są szeroko obsługiwane.

Jest to świetny zasób, aby dowiedzieć się, jakiego formatu danych należy użyć:

http://dygraphs.com/date-formats.html

Tak, oznacza to, że twoje przesyłanie danych może być tak proste, jak w przeciwieństwie do

"2014/10/13 23:57:52" zamiast "2014-10-13 23:57:52"

                //little bit of code for Converting dates 

                var dat1 = document.getElementById('inputDate').value;
                var date1 = new Date(dat1)//converts string to date object
                alert(date1);
                var dat2 = document.getElementById('inputFinishDate').value;
                var date2 = new Date(dat2)
                alert(date2);

użyj tego kodu: (mój problem został rozwiązany za pomocą tego kodu)

function dateDiff(date1, date2){
var diff = {}                           // Initialisation du retour
var tmp = date2 - date1;

tmp = Math.floor(tmp/1000);             // Nombre de secondes entre les 2 dates
diff.sec = tmp % 60;                    // Extraction du nombre de secondes

tmp = Math.floor((tmp-diff.sec)/60);    // Nombre de minutes (partie entière)
diff.min = tmp % 60;                    // Extraction du nombre de minutes

tmp = Math.floor((tmp-diff.min)/60);    // Nombre d'heures (entières)
diff.hour = tmp % 24;                   // Extraction du nombre d'heures

tmp = Math.floor((tmp-diff.hour)/24);   // Nombre de jours restants
diff.day = tmp;

return diff;

}

Napisałem funkcję wielokrotnego użytku, której używam, gdy otrzymuję ciągi dat z serwera.
możesz podać żądany separator (/ - itp.), który oddziela dzień miesiąc i rok, aby użyć tej split()metody.
możesz to zobaczyć i przetestować na tym działającym przykładzie .

<!DOCTYPE html>
<html>
  <head>
    <style>
    </style>
  </head>
  <body>
    <div>
      <span>day:
      </span> 
      <span id='day'>
      </span>
    </div>
    <div>
      <span>month:
      </span> 
      <span id='month'>
      </span>
    </div>
    <div>
      <span>year:
      </span> 
      <span id='year'>
      </span>
    </div>
    <br/>
    <input type="button" id="" value="convert" onClick="convert('/','28/10/1980')"/>
    <span>28/10/1980
    </span>
    <script>
      function convert(delimiter,dateString)
      {
        var splitted = dateString.split('/');
        // create a new date from the splitted string 
        var myDate = new Date(splitted[2],splitted[1],splitted[0]);
        // now you can access the Date and use its methods 
        document.getElementById('day').innerHTML = myDate.getDate();
        document.getElementById('month').innerHTML = myDate.getMonth();
        document.getElementById('year').innerHTML = myDate.getFullYear();
      }
    </script>
  </body>
</html>

Jeszcze innym sposobem jest zbudowanie wyrażenia regularnego z nazwanymi grupami przechwytywania na ciągu formatu, a następnie użycie tego wyrażenia do wyodrębnienia dnia, miesiąca i roku z ciągu daty:

function parseDate(dateStr, format) {
  const regex = format.toLocaleLowerCase()
    .replace(/\bd+\b/, '(?<day>\\d+)')
    .replace(/\bm+\b/, '(?<month>\\d+)')
    .replace(/\by+\b/, '(?<year>\\d+)')
  
  const parts = new RegExp(regex).exec(dateStr) || {};
  const { year, month, day } = parts.groups || {};
  return parts.length === 4 ? new Date(year, month-1, day) : undefined;
}

const printDate = x => console.log(x ? x.toLocaleDateString() : x);

printDate(parseDate('05/11/1896', 'dd/mm/YYYY'));
printDate(parseDate('07-12-2000', 'dd-mm-yy'));
printDate(parseDate('07:12:2000', 'dd:mm:yy'));
printDate(parseDate('2017/6/3', 'yy/MM/dd'));
printDate(parseDate('2017-6-15', 'y-m-d'));
printDate(parseDate('2015 6 25', 'y m d'));
printDate(parseDate('2015625', 'y m d')); // bad format