new Date()ආකෘති කිහිපයකින් දිනයන් පිළිගැනීමේදී ජාවාස්ක්‍රිප්ට් හි ක්‍රියාකාරිත්වය ඉතා දක්ෂ බව මම දුටුවෙමි .

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

ඇමතුම් new Date()ශ්‍රිතය අතරතුර වලංගු නූල් ආකෘති පෙන්වන කිසිදු තැනක මට ලේඛන සොයාගත නොහැකි විය .

මෙය නූලක් දිනයකට පරිවර්තනය කිරීම සඳහා ය. අපි ප්‍රතිවිරුද්ධ පැත්ත දෙස බැලුවහොත්, එනම්, දින වස්තුවක් නූලක් බවට පරිවර්තනය කිරීම, මේ දක්වා මා සිතුවේ ජාවාස්ක්‍රිප්ට් හි දින වස්තුවක් නූලකට සංයුති කිරීම සඳහා බිල්ට් ඒපීඅයි නොමැති බවයි.

සංස්කාරක සටහන: පහත දැක්වෙන ප්‍රවේශය වන්නේ කිසියම් බ්‍රව්සරයක වැඩ කළ නමුත් පොදුවේ ක්‍රියාත්මක නොවන ඉල්ලුම්කරුගේ උත්සාහයයි ; සත්‍ය විසඳුම් කිහිපයක් බැලීමට මෙම පිටුවේ පිළිතුරු බලන්න.

අද, මම toString()දිනය වස්තුව පිළිබඳ ක්‍රමවේදය සමඟ ක්‍රීඩා කළ අතර පුදුමයට කරුණක් නම් එය නූල් වලට දිනය සංයුති කිරීමේ අරමුණයි.

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

මෙහි දී මට දිනය වස්තුව නූලකට සංයුති කළ හැකි සියලු ආකාරයන් පිළිබඳ කිසිදු ලේඛනයක් සොයාගත නොහැකි විය.

Date()වස්තුව විසින් සහාය දක්වන ආකෘති පිරිවිතරයන් ලැයිස්තුගත කරන ප්‍රලේඛනය කොහිද ?

මම ආදරෙයි JavaScript භාවිතා කල දිනය හා වේලාව සංයුති කිරීමට ක්රම 10 සහ දින සමඟ වැඩ .

මූලික වශයෙන්, ඔබට ක්‍රම තුනක් ඇති අතර ඔබටම නූල් ඒකාබද්ධ කළ යුතුය:

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

උදාහරණයක්:

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

Moment.js

එය (සැහැල්ලු) * විග්‍රහ කිරීම, හැසිරවීම සහ දින හැඩතල ගැන්වීම සඳහා ජාවාස්ක්‍රිප්ට් දින පුස්තකාලයකි.

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"

(*) සැහැල්ලු අර්ථය 9.3KB මිනිෆයිඩ් + හැකි කුඩාම සැකසුම තුළ gzpped (feb 2014)

ඔබ දැනටමත් ඔබේ ව්‍යාපෘතියේ jQuery UI භාවිතා කරන්නේ නම් , ඔබේ දින වස්තුව සංයුති කිරීම සඳහා ඔබට ගොඩනංවන ලද ඩේට්පිකර් ක්‍රමය භාවිතා කළ හැකිය:

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

කෙසේ වෙතත්, ඩේට්පිකර් දින හැඩතල පමණක් වන අතර වේලාවන් සංයුති කළ නොහැක.

උදාහරණ වන jQuery UI datepicker formatDate දෙස බලන්න .

Date()වස්තුව විසින් සහාය දක්වන ආකෘති පිරිවිතරයන් ලැයිස්තුගත කරන ප්‍රලේඛනය කොහිද ?

මම අද මේ ගැන පැකිලී ගිය අතර මෙම සරල ප්‍රශ්නයට පිළිතුරු දීමට කිසිවෙකු කාලය ගත නොකිරීම ගැන මම පුදුමයට පත් වීමි. දිනය හැසිරවීමට උපකාර කිරීම සඳහා බොහෝ පුස්තකාල එහි ඇති බව ඇත්තකි. සමහර ඒවා අනෙක් අයට වඩා හොඳයි. නමුත් එය ඇසූ ප්‍රශ්නය නොවේ.

AFAIK, පවිත්ර, JavaScript ආකෘතිය නිශ්චයකක් සඳහා පහසුකම් සපයන්නේ නැත , ඔබ ඔවුන් භාවිතා කිරීමට කැමති ඇඟවුම් කර තිබේ මාර්ගය . නමුත් එය එවැනි හැඩතලයෙන් දින සහ / හෝ වරක් සහයෝගය ක්රම කරන්නේ .toLocaleDateString(), .toLocaleTimeString()සහ .toUTCString().

මෙම Dateවස්තුව යොමු මම භාවිතා නිතර නිතර මේ පිළිබඳ w3schools.com වෙබ් අඩවිය (නමුත් ඉක්මන් ගූගල් සෙවුම් ඔබගේ අවශ්යතා වඩා හොඳ හමුවීමට හැකි බව බොහෝ හෙළි කරනු ඇත).

දිනය වස්තු ගුණාංග අංශය සබැඳියක් සපයන බව සලකන්න prototype, එය ඔබට අභිරුචි ක්‍රම සමඟ දිනය වස්තුව දිගු කළ හැකි ක්‍රම කිහිපයක් විදහා දක්වයි. මෙය හොඳම භාවිතයක් ද නැද්ද යන්න පිළිබඳව වසර ගණනාවක් තිස්සේ ජාවාස්ක්‍රිප්ට් ප්‍රජාව තුළ යම් විවාදයක් පැවතුන අතර , මම එහි පැවැත්ම පෙන්වා දෙමින් මම එයට පක්ෂව හෝ විපක්ෂව නොසිටිමි.

අභිරුචි හැඩතල ගැන්වීමේ කාර්යය:

ස්ථාවර ආකෘති සඳහා, සරල කාර්යයක් මඟින් කාර්යය සිදු කරයි. පහත උදාහරණයෙන් අන්තර්ජාතික ආකෘතිය YYYY-MM-DD ජනනය කරයි:

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

සටහන: කෙසේ වෙතත්, සාමාන්‍යයෙන් ජාවාස්ක්‍රිප්ට් සම්මත පුස්තකාල දීර් extend කිරීම හොඳ අදහසක් නොවේ (උදා: මෙම ශ්‍රිතය දිනයෙහි මූලාකෘතියට එකතු කිරීමෙන්).

වඩාත් දියුණු ශ්‍රිතයකට ආකෘති පරාමිතියක් මත පදනම්ව වින්‍යාසගත කළ හැකි ප්‍රතිදානයක් ජනනය කළ හැකිය. මෙම පිටුවේම හොඳ උදාහරණ කිහිපයක් තිබේ.

ආකෘතිකරණ ශ්‍රිතයක් ලිවීමට දිගු නම්, එය වටා පුස්තකාල ඕනෑ තරම් තිබේ. තවත් සමහර පිළිතුරු දැනටමත් ඒවා ගණන් බලා ඇත. නමුත් පරායත්තතාවයන් වැඩි කිරීම එයට ප්‍රති-කොටසක් ද ඇත.

සම්මත ECMAScript හැඩතල ගැන්වීමේ කාර්යයන්:

ECMAscript හි වඩාත් නවතම අනුවාදයන් බැවින්, Dateපන්තියට නිශ්චිත හැඩතල ගැන්වීමේ කාර්යයන් ඇත:

toDateString : ක්‍රියාත්මක කිරීම මත රඳා පවතී, දිනය පමණක් පෙන්වන්න.

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 : 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 : JSON සඳහා Stringifier.

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 : ක්‍රියාත්මක කිරීම මත රඳා පවතින, ස්ථානීය ආකෘතියෙන් දිනයකි.

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

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

toLocaleString : ක්‍රියාත්මක කිරීම මත රඳා පවතින දිනය සහ වේලාව ස්ථාන ආකෘතියෙන්.

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 : ක්‍රියාත්මක කිරීම මත රඳා පවතින, ස්ථානීය ආකෘතියෙන් කාලය.

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.

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

සටහන: එම හැඩතල ගැන්වීමේ කාර්යයන්ගෙන් අභිරුචි ප්‍රතිදානය ජනනය කළ හැකිය:

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

කෙටි පිළිතුර

ජාවාස්ක්‍රිප්ට් සපුරාලන “විශ්වීය” ලියකියවිලි නොමැත; ජාවාස්ක්‍රිප්ට් ඇති සෑම බ්‍රව්සරයක්ම සැබවින්ම ක්‍රියාත්මක කිරීමකි. කෙසේ වෙතත්, බොහෝ නවීන බ්‍රව්සර් අනුගමනය කිරීමට නැඹුරු වන ප්‍රමිතියක් ඇත, එය EMCAScript ප්‍රමිතියයි; ECMAScript සම්මත නූල් අවම වශයෙන් ISO 8601 අර්ථ දැක්වීම නවීකරණය කිරීම අවශ්‍ය වේ.

මීට අමතරව, IETF විසින් ඉදිරිපත් කරන ලද දෙවන ප්‍රමිතිය ද ඇත බ්රවුසරයෙන් RFC සිදු 2822. සත ප්රලේඛනය පතුලේ ඇති යොමු ලැයිස්තුව සොයා ගත හැකි timestamps සඳහා අර්ථ දැක්වීම වන, මෙන්ම අනුගමනය කිරීමට නැඹුරු බව.

මෙයින් ඔබට මූලික ක්‍රියාකාරිත්වය අපේක්ෂා කළ හැකි නමුත් “විය යුතු” දේ සහජයෙන්ම “යනු කුමක්ද” යන්න නොවේ. ක්‍රියාපටිපාටිය අනුව මම මේ ගැන මඳක් ගැඹුරට යන්නෙමි. පෙනෙන ආකාරයට ඇත්ත වශයෙන්ම තිදෙනෙකු පමණක් ප්‍රශ්නයට පිළිතුරු දී ඇත (ස්කොට්, ගොෆ්බෝල් ලොජික් සහ පෙලර්), මට අනුව, ඔබ යෝජනා කරන විට ඇත්ත වශයෙන්ම සිදුවන්නේ කුමක්ද යන්න බොහෝ දෙනා නොදන්නා බව මට පෙනේ දින වස්තුවක් සාදන්න.

දිගු පිළිතුර

දිනය () වස්තුව මඟින් සහය දක්වන ආකෘති පිරිවිතරයන් ලැයිස්තුගත කරන ප්‍රලේඛනය කොහිද?

ප්‍රශ්නයට පිළිතුරු දීමට හෝ සාමාන්‍යයෙන් මෙම ප්‍රශ්නයට පිළිතුර සෙවීමට පවා ඔබ දැනගත යුත්තේ ජාවාස්ක්‍රිප්ට් නව භාෂාවක් නොවන බවයි; එය ඇත්ත වශයෙන්ම ECMAScript ක්‍රියාත්මක කිරීමක් වන අතර ECMAScript ප්‍රමිතීන් අනුගමනය කරයි (නමුත් සටහන, ජාවාස්ක්‍රිප්ට් ඇත්ත වශයෙන්ම එම ප්‍රමිතීන්ට පෙර දින නියම කර ඇත; EMCAScript ප්‍රමිතීන් ගොඩනඟා ඇත්තේ LiveScript / JavaScript හි මුල් ක්‍රියාත්මක කිරීමෙනි). වර්තමාන ECMAScript ප්‍රමිතිය 5.1 (2011); ප්‍රශ්නය මුලින් ඇසූ අවස්ථාවේ (ජූනි 09), ප්‍රමිතිය 3 (4 අතහැර දමා ඇත), නමුත් 5 ක් 2009 අවසානයේ තනතුරෙන් ටික කලකට පසුව මුදා හරින ලදි. මෙය එක් ගැටළුවක් ගෙනහැර දැක්විය යුතුය; ජාවාස්ක්‍රිප්ට් ක්‍රියාවට නැංවීම අනුගමනය කළ හැකි ප්‍රමිතිය, ඇත්ත වශයෙන්ම පවතින දේ පිළිබිඹු නොවිය හැකිය, මන්ද අ) එය ලබා දී ඇති ප්‍රමිතියක් ක්‍රියාත්මක කිරීම, ආ) ප්‍රමිතියක් ක්‍රියාත්මක කිරීම පියුරිටන් නොවේ,

අත්‍යවශ්‍යයෙන්ම, ජාවාස්ක්‍රිප්ට් සමඟ ගනුදෙනු කරන විට, ඔබ ක්‍රියාත්මක කරන්නේ ක්‍රියාවට නැංවීමේ ව්‍යුත්පන්නයක් (බ්‍රව්සරයට විශේෂිත වූ ජාවාස්ක්‍රිප්ට්) ය. ගූගල් හි V8, ECMAScript 5.0 ක්‍රියාත්මක කරයි, නමුත් ඉන්ටර්නෙට් එක්ස්ප්ලෝරර්ගේ JScript කිසිදු ECMAScript ප්‍රමිතියකට අනුකූල වීමට උත්සාහ නොකරයි, නමුත් Internet Explorer 9 ECMAScript 5.0 ට අනුකූල වේ.

එක් තර්කයක් නව දිනය () වෙත යොමු කළ විට, එය මෙම ශ්‍රිත මූලාකෘතිය දක්වයි:

new Date(value)

නව දිනය () වෙත තර්ක දෙකක් හෝ වැඩි ගණනක් සම්මත කළ විට, එය මෙම ශ්‍රිත මූලාකෘතිය දක්වයි:

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

මෙම කාර්යයන් දෙකම හුරුපුරුදු විය යුතුය, නමුත් මෙය ඔබගේ ප්‍රශ්නයට ක්ෂණිකව පිළිතුරු නොදෙන අතර පිළිගත හැකි “දින ආකෘතියක්” ලෙස ප්‍රමාණාත්මක වන්නේ කුමක් ද යන්න තවදුරටත් පැහැදිලි කිරීම අවශ්‍ය වේ. ඔබ නව දිනයකට () නූලක් යවන විට, එය මූලාකෘතිය ලෙස හඳුන්වනු ඇත (මම මූලාකෘති යන වචනය ලිහිල් ලෙස භාවිතා කරන බව සලකන්න ; අනුවාදයන් තනි කාර්යයන් විය හැකිය, නැතහොත් එය එක් ශ්‍රිතයක කොන්දේසි සහිත ප්‍රකාශයක කොටසක් විය හැකිය) “අගය” පරාමිතිය සඳහා වන තර්කය ලෙස ඔබේ නූල් සමඟ නව දිනය (අගය) . මෙම ශ්‍රිතය මුලින්ම එය අංකයක් හෝ නූලක් දැයි පරීක්ෂා කරයි. මෙම කාර්යය සඳහා වන ලියකියවිලි මෙතැනින් සොයාගත හැකිය:

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

මෙයින්, නව දිනය (අගය) සඳහා නූල් හැඩතල ගැන්වීම සඳහා අපට එය අනුමාන කළ හැකිය, අපි Date.parse (string) ක්‍රමය දෙස බැලිය යුතුය. මෙම ක්‍රමය සඳහා වන ලියකියවිලි මෙතැනින් සොයාගත හැකිය:

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

මෙහි දක්වා ඇති පරිදි නවීකරණය කරන ලද ISO 8601 දීර් tend කරන ලද ආකෘතියක දිනයන් අපේක්ෂා කරන බව අපට තවදුරටත් අනුමාන කළ හැකිය:

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

කෙසේ වෙතත්, ජාවාස්ක්‍රිප්ට්ගේ දිනය වස්තුව වෙනත් ආකෘතීන් පිළිගන්නා බව අපට අත්දැකීමෙන් හඳුනාගත හැකිය (මෙම ප්‍රශ්නයේ පැවැත්මෙන් මුලින් බලාත්මක වේ), සහ ECMAScript මඟින් විශේෂිත ආකෘතීන් ක්‍රියාත්මක කිරීමට ඉඩ ලබා දෙන බැවින් මෙය හරි ය. කෙසේ වෙතත්, පවතින ආකෘතීන්හි ඇති ලියකියවිලි මොනවාද, ඇත්ත වශයෙන්ම කුමන ආකෘතීන් සඳහා අවසර දී තිබේද යන ප්‍රශ්නයට එය තවමත් පිළිතුරු සපයන්නේ නැත. අපි ගූගල් හි ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීම දෙස බලමු, V8; කරුණාකර සටහන් කරන්න මෙය “හොඳම” ජාවාස්ක්‍රිප්ට් එන්ජිම (යමෙකුට “හොඳම” හෝ “හොඳ” යන්න නිර්වචනය කරන්නේ කෙසේද) සහ V8 හි අවසර දී ඇති ආකෘතීන් අද පවතින සියලුම ආකෘතීන් නියෝජනය කරයි යැයි කෙනෙකුට සිතිය නොහැකිය, නමුත් එය සාධාරණ යැයි මම සිතමි ඔවුන් නවීන අපේක්ෂාවන් අනුගමනය කරයි යැයි උපකල්පනය කිරීම.

ගූගල් හි V8, date.js, DateConstructor

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

DateConstructor ශ්‍රිතය දෙස බලන විට, අපට DateParse ශ්‍රිතය සොයා ගැනීමට අවශ්‍ය යැයි අනුමාන කළ හැකිය; කෙසේ වෙතත්, “වර්ෂය” යනු සත්‍ය වර්ෂය නොවන අතර එය “වර්ෂය” පරාමිතියට යොමු කිරීමක් පමණක් බව සලකන්න.

ගූගල් හි V8, date.js, DateParse

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

මෙය% DateParseString ලෙස හැඳින්වේ, එය ඇත්ත වශයෙන්ම C ++ ශ්‍රිතයක් සඳහා ධාවන කාල ශ්‍රිත යොමුවකි. එය පහත කේතය වෙත යොමු වේ:

ගූගල් හි V8, runtime.cc,% DateParseString

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

මෙම ශ්‍රිතයේ අප සැලකිලිමත් වන ශ්‍රිත ඇමතුම ඩේට්පාර්සර් :: විග්‍රහය (); එම ශ්‍රිත ඇමතුම් අවට ඇති තර්කනය නොසලකා හරින්න, මේවා කේතීකරණ වර්ගයට (ASCII සහ UC16) අනුකූල වන චෙක්පත් පමණි. DateParser :: විග්‍රහය මෙහි අර්ථ දක්වා ඇත:

ගූගල් හි V8, dateparser-inl.h, DateParser :: විග්‍රහ කරන්න

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

මෙය පිළිගන්නේ කුමන ආකෘතීන් ද යන්න නිර්වචනය කරන ශ්‍රිතයයි. අත්යවශ්යයෙන්ම, එය EMCAScript 5.0 ISO 8601 ප්රමිතිය සඳහා පරික්ෂා කරන අතර එය ප්රමිතීන්ට අනුකූල නොවේ නම්, එය පැරණි ආකෘතීන් මත පදනම්ව දිනය ගොඩනැගීමට උත්සාහ කරනු ඇත. අදහස් මත පදනම් වූ ප්‍රධාන කරුණු කිහිපයක්:

1. විග්‍රහ කරන්නා නොදන්නා පළමු අංකයට පෙර වචන නොසලකා හරිනු ලැබේ.
2. වරහන් කළ පෙළ නොසලකා හරිනු ලැබේ.
3. “:” ට පසුව අත්සන් නොකළ අංක “කාල සංරචකයක්” ලෙස අර්ථ දැක්වේ.
4. අත්සන් නොකළ අංක ඉන්පසු “.” “කාල සංරචකයක්” ලෙස අර්ථකථනය කර ඇති අතර එය අනුගමනය කළ යුත්තේ මිලි තත්පර.
5. පැය හෝ පැයේ මිනිත්තුවෙන් පසුව අත්සන් කළ අංක (උදා: +5: 15 හෝ +0515) කාල කලාපය ලෙස අර්ථ දැක්වේ.
6. පැය සහ මිනිත්තුව ප්‍රකාශ කරන විට, ඔබට “hh: mm” හෝ “hhmm” භාවිතා කළ හැකිය.
7. කාල කලාපයක් දැක්වෙන වචන කාල කලාපයක් ලෙස අර්ථ දැක්වේ.
8. අනෙක් සියලුම සංඛ්‍යා “දිනය සංරචක” ලෙස අර්ථ දැක්වේ.
9. මසක පළමු ඉලක්කම් තුනෙන් ආරම්භ වන සියලුම වචන මාසය ලෙස අර්ථ දැක්වේ.
10. “Hh: mm” හෝ “hhmm” යන ආකෘති දෙකෙන් ඔබට මිනිත්තු සහ පැය එකට අර්ථ දැක්විය හැකිය.
11. අංකයක් සැකසූ පසු “+”, “-“ සහ අසමසම “)” වැනි සංකේත වලට අවසර නැත.
12. බහුවිධ හැඩතලවලට ගැලපෙන අයිතම (උදා: 1970-01-01) සම්මත අනුකූල EMCAScript 5.0 ISO 8601 නූලක් ලෙස සකසනු ලැබේ.

එබැවින් දිනය වස්තුවකට නූලක් යැවීමේදී අපේක්ෂා කළ යුතු දේ පිළිබඳ මූලික අදහසක් ලබා දීමට මෙය ප්‍රමාණවත් විය යුතුය. මොසිල්ලා සංවර්ධක ජාලයට (IETF RFC 2822 කාලරාමුවලට අනුකූලව) මොසිල්ලා පෙන්වා දෙන පහත පිරිවිතර දෙස බැලීමෙන් ඔබට මෙය තවදුරටත් පුළුල් කළ හැකිය:

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

මයික්‍රොසොෆ්ට් සංවර්ධක ජාලය දින වස්තුව සඳහා අතිරේක ප්‍රමිතියක් ගැන සඳහන් කරයි: ECMA-402, ECMAScript ජාත්‍යන්තරකරණ API පිරිවිතර, එය ECMAScript 5.1 ප්‍රමිතියට (සහ අනාගත ඒවාට) අනුපූරක වේ. එය මෙහි සොයාගත හැකිය:

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

කෙසේ වෙතත්, මෙය ජාවාස්ක්‍රිප්ට් හි සියලු ක්‍රියාත්මක කිරීම් විශ්වීයව නිරූපණය කරන “ලියකියවිලි” නොමැති බව ඉස්මතු කිරීමට උපකාරී වේ, නමුත් දිනය වස්තුවක් සඳහා පිළිගත හැකි නූල් මොනවාද යන්න පිළිබඳව සාධාරණ අවබෝධයක් ලබා ගැනීම සඳහා ප්‍රමාණවත් ලියකියවිලි තවමත් තිබේ. ඔබ ඒ ගැන සිතන විට පටවා ඇති ප්‍රශ්නය, ඔව්? : පී

යොමුව

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

සම්පත්

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

ජාවාස්ක්‍රිප්ට් හි දිනයන් සමඟ කටයුතු කිරීමේදී ඔබ ඩේටෙජ් පරීක්ෂා කර බැලීමට වග බලා ගන්න . ToString ශ්‍රිතය සම්බන්ධයෙන් ඔබට පෙනෙන පරිදි එය ඉතා ආකර්ෂණීය හා හොඳින් ලේඛනගත කර ඇත.

සංස්කරණය කරන්න : ටයිලර් ෆෝසයිත් පෙන්වා දෙන්නේ එම දිනය යල් පැන ගිය එකක් බවයි. මම එය මගේ වර්තමාන ව්‍යාපෘතියේ භාවිතා කරන අතර ඒ සමඟ කිසිදු කරදරයක් නොවීය, කෙසේ වෙතත් ඔබ මේ පිළිබඳව දැනුවත් විය යුතු අතර විකල්ප සලකා බැලිය යුතුය.

Meizz විසින් සටහන් කර ඇති පරිදි Dateඔබට නව formatක්‍රමයක් සමඟ වස්තුව පුළුල් කළ හැකිය , කර්තෘ විසින් ලබා දුන් කේතය පහත දැක්වේ. මෙන්න 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"));

ඔබ උපුටා දක්වන ක්‍රියාකාරීත්වය සම්මත ජාවාස්ක්‍රිප්ට් නොවේ, බ්‍රව්සර් හරහා අතේ ගෙන යා නොහැකි අතර එබැවින් හොඳ පුහුණුවක් නොමැත. මෙම සම්මතයන් 3 පිරිවිතර කොළ පේළියේ සහ ප්රතිදානය හැඩතල ජාවාස්ක්රිප්ට් ක්රියාත්මක කිරීම දක්වා ක්රියාත්මක වෙති. ECMAScript 5 ISO8601 සහයයේ උප කුලකයක් එක් කරයි. ඔබ සඳහන් කරන toString () ශ්‍රිතය එක් බ්‍රව්සරයක (මොසිල්ලා?) නව්‍යකරණයක් යැයි මම විශ්වාස කරමි.

පුස්තකාල කිහිපයක් මෙය පරාමිතිකරණය කිරීම සඳහා චර්යාවන් සපයයි, සමහර ඒවාට පුළුල් දේශීයකරණ සහාය ඇත. ඔබට dojo.date.locale හි ඇති ක්‍රමවේදයන් ද පරීක්ෂා කළ හැකිය .

මම මෙය ඉතා සරල හැඩතල ගැන්වීමක් කළෙමි, එය කැපීම / n / පේස්ට් කළ හැකිය (නීටර් අනුවාදය සමඟ යාවත්කාලීන කරන ලදි):

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/

රාමු රහිත, සීමිත නමුත් සැහැල්ලු ය

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 නිසැකවම අංග සම්පූර්ණයි, නමුත් මම නිර්දේශ කරන්නේ මෙම වඩාත් සරල ලිබ් (ජාවාස්ක්‍රිප්ට් දිනය ආකෘතිය) මම කැමති එය පේළි 120 ක් හෝ ඊට වැඩි නිසා.

වෙනත් පිළිතුරු වලින් සපයා ඇති විකල්ප කිහිපයක් සොයා බැලීමෙන් පසු, අනෙක් අයටද ප්‍රයෝජනවත් විය හැකි මගේම සීමිත නමුත් සරල විසඳුමක් ලිවීමට මම තීරණය කළෙමි.

/**
* 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;
}

උදාහරණ භාවිතය:

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

මෙන්න මම ගොඩක් භාවිතා කරන ශ්‍රිතයක්. ප්රති result ලය yyyy-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);
}

දිනය වස්තුව වෙනස් කිරීම ඔබට ප්‍රයෝජනවත් විය හැකිය, එය ඕනෑම පුස්තකාලයකට වඩා කුඩා වන අතර විවිධ හැඩතල සඳහා පහසුවෙන් විස්තාරණය කළ හැකිය:

සටහන:

• එය පැරණි බ්‍රව්සර්වල නිර්වචනය කර නැති Object.keys () භාවිතා කරයි, එවිට ඔබට ලබා දී ඇති සබැඳියෙන් පොලිෆිල් ක්‍රියාත්මක කිරීමට අවශ්‍ය වනු ඇත.

කේතය

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

භාවිත

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

ගොංෂිටාඕගේ ස්ථිර පිළිතුර දිගටම කරගෙන යාමට - මෙය 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;
}

වලංගු දින ආකෘති පිළිබඳ නිශ්චිත ලියකියවිලි සොයා ගැනීමට මට නොහැකි විය, එබැවින් විවිධ බ්‍රව්සර්වල සහය දක්වන්නේ කුමක් දැයි බැලීමට මම මගේම පරීක්‍ෂණයක් ලිවීය.

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

මගේ ප්‍රති results ල අනුව මම පරීක්ෂා කළ සියලුම බ්‍රව්සර් වල පහත ආකෘති වලංගු වේ (උදාහරණ "2013 අගෝස්තු 9 දිනය භාවිතා කරයි"):

[පූර්ණ අවුරුදු] / [මාසික] / [දිනය අංකය] - මාසික ප්රමුඛ ශුන්ය හෝ මාසික නම කෙටි හෝ දීර්ඝ ආකෘතියෙන් ඇතිව හෝ නැතිව එක්කෝ අංකය, සහ දිනය අංකය ප්රමුඛ ශුන්ය ඇතිව හෝ නැතිව විය හැක විය හැක.

• 2013/08/09
• 2013/08/9
• 2013/8/09
• 2013/8/9
• 2013 / අගෝස්තු / 09
• 2013 / අගෝස්තු / 9
• 2013 / අගෝස්තු / 09
• 2013 / අගෝස්තු / 9

[මාසික] / [පූර්ණ අවුරුදු] / [දිනය අංකය] - මාසික ප්රමුඛ ශුන්ය හෝ මාසික නම කෙටි හෝ දීර්ඝ ආකෘතියෙන් ඇතිව හෝ නැතිව එක්කෝ අංකය, සහ දිනය අංකය ප්රමුඛ ශුන්ය ඇතිව හෝ නැතිව විය හැක විය හැක.

• 08/2013/09
• 08/2013/9
• 8/2013/09
• 8/2013/9
• අගෝස්තු / 2013/09
• අගෝස්තු / 2013/9
• අගෝස්තු / 2013/09
• අගෝස්තු / 2013/9

[පූර්ණ වර්ෂය], [මාසය නම] සහ [දිනය අංකය] යන ඕනෑම සංයෝජනයක් අවකාශයන්ගෙන් වෙන් කර ඇත - මාසික නම කෙටි හෝ දිගු ආකෘතියකින් විය හැකි අතර දිනය අංකය ප්‍රමුඛ ශුන්‍යයක් සමඟ හෝ නැතිව විය හැකිය.

• 2013 අගෝස්තු 09
• අගෝස්තු 2013 09
• 2013 අගෝස්තු 09
• 2013 අගෝස්තු 09
• අගෝස්තු 9 2013
• 2013 9 අගෝස්තු
• etc ...

"නවීන බ්‍රව්සර්" වලද වලංගු වේ (හෝ වෙනත් වචන වලින් කිවහොත් IE9 සහ ඊට පහළින් ඇති සියලුම බ්‍රව්සර්)

[සම්පූර්ණ වර්ෂය] - [මාස අංකය] - [දිනය අංකය] - මාසය සහ දිනය අංකයට ප්‍රමුඛ ශුන්‍යයන් ඇතුළත් විය යුතුය (මෙය MySQL දිනය වර්ගය භාවිතා කරන ආකෘතියයි )

• 2013-08-09

මාස නාම භාවිතා කිරීම:
සිත්ගන්නා කරුණ නම් , මාස නාම භාවිතා කරන විට මා සොයාගත්තේ මාස නාමයේ මුල් අක්ෂර 3 පමණක් මෙතෙක් භාවිතා කර ඇති බැවින් පහත සඳහන් සියල්ලම පරිපූර්ණ ලෙස වලංගු වේ:

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

ජාවාස්ක්‍රිප්ට් හි ආකෘතිකරණය සහ විශේෂයෙන් විග්‍රහ කරන දිනයන් ටිකක් හිසරදයක් විය හැකිය. සියලුම බ්‍රව්සර් දිනයන් එකම ආකාරයකින් හසුරුවන්නේ නැත. එබැවින් මූලික ක්‍රම දැන ගැනීම ප්‍රයෝජනවත් වන අතර, උපකාරක පුස්තකාලයක් භාවිතා කිරීම වඩාත් ප්‍රායෝගිකයි.

මෙම XDate ජාවාස්ක්රිප්ට් පුස්තකාලය විසින් ආදම් ෂෝ 2011 මැද භාගයේ සිට පැවත සහ ක්රියාකාරී සංවර්ධනය යටතේ තවමත් ඇත. එහි අපූරු ලියකියවිලි ඇත, විශිෂ්ට API, හැඩතල ගැන්වීම, පසුපසට අනුකූල වීමට උත්සාහ කරන අතර දේශීයකරණය කළ නූල් සඳහා පවා සහාය වේ.

ස්ථානීය නූල් වෙනස් කිරීමට සබැඳිය: https://gist.github.com/1221376

උදාහරණ කේතය:

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

ප්‍රතිදානය:

"13:45:20"

JavaScript හි දිනයන් සමඟ වැඩ කිරීම සඳහා පුස්තකාලය sugar.js සතුව විශාල ක්‍රියාකාරිත්වයක් ඇත. එය ඉතා හොඳින් ලේඛනගත කර ඇත.

"පැය 1 කට පෙර" වැනි සාපේක්ෂ ආකෘතීන් ඇතුළුව ප්‍රධාන භාෂා 15 කින් ඕනෑම ආකෘතියකින් දිනයන් තේරුම් ගත හැකි ඩේට් ක්‍රියේට් ක්‍රමයෙන් ආරම්භ වන සීනි දිනය පන්තියට බොහෝ ආදරය ලබා දෙයි. පොදුවේ භාවිතා වන දින ආකෘති වලට කෙටිමං සමඟ පහසුවෙන් තේරුම් ගත හැකි වාක්‍ය ඛණ්ඩයක් භාවිතා කරමින් දිනයන් ඕනෑම ආකෘතියකින් හෝ භාෂාවකින් ප්‍රතිදානය කළ හැකිය. ඕනෑම දිනයක් තේරුම් ගෙන නිරවද්‍යතාවයෙන් ගොඩනගා ඇති වැනි සංකීර්ණ ක්‍රම සමඟ සැසඳිය හැකිය.

උදාහරණ කිහිපයක්:

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"

සියලුම බ්‍රව්සර්

ඔබ භාවිතා කරන ප්‍රභව ආකෘතිය සමඟ දිනයක් සංයුති කිරීමට වඩාත්ම විශ්වාසදායක ක්‍රමය නම්, පහත පියවර අනුගමනය කිරීම:

1. වස්තුවක් new Date()නිර්මාණය කිරීමට භාවිතා කරන්නDate
2. භාවිතය .getDate(), .getMonth()සහ .getFullYear()දිනය පිළිවෙළින් ලබා, මාසය සහ වසර සඳහා
3. ඔබේ ඉලක්ක ආකෘතියට අනුව කෑලි එකට අලවන්න

උදාහරණයක් :

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

( මෙම ෆෙඩෙල් ද බලන්න ).

නවීන බ්‍රව්සර් පමණි

ඔබ .toLocaleDateStringවෙනුවෙන් හැඩතල ගැන්වීම සඳහා ඔබට බිල්ට් ක්‍රමය භාවිතා කළ හැකිය . අවාසනාවට නවීන බ්‍රව්සර් (*) මඟින් පමණක් සහාය වන නිවැරදි ආකෘතියට ගැලපෙන පරිදි ඔබට නිසි ස්ථානය සහ විකල්පයන් පසුකර යාමට අවශ්‍යය :

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

( මෙම ෆෙඩෙල් ද බලන්න ).

(*) එම්ඩීඑන් අනුව , “නූතන බ්‍රව්සර්” යන්නෙන් ක්‍රෝම් 24+, ෆයර්ෆොක්ස් 29+, අයිඊ 11, එඩ්ජ් 12 +, ඔපෙරා 15+ සහ සෆාරි රාත්‍රී ගොඩනැගීම

මා ලියූ තවත් විකල්පයක්:

DP_DateExtensions පුස්තකාලය

එය උදව් කරයිදැයි විශ්වාස නැත, නමුත් ව්‍යාපෘති කිහිපයකම එය ප්‍රයෝජනවත් බව මට පෙනී ගියේය - එය ඔබට අවශ්‍ය දේ කරනු ඇති බව පෙනේ.

දිනය / වේලාව හැඩතල ගැන්වීම, දිනය ගණිතය (දිනය කොටස් එකතු කිරීම / අඩු කිරීම), දිනය සංසන්දනය කිරීම, දිනය විග්‍රහ කිරීම යනාදිය සඳහා සහාය වේ. එය ලිබරල් විවෘත මූලාශ්‍රයකි.

ඔබ දැනටමත් රාමුවක් භාවිතා කරන්නේ නම් එය සලකා බැලීමට කිසිදු හේතුවක් නැත (ඒවා සියල්ලම දක්ෂයි), නමුත් ඔබට ව්‍යාපෘතියකට දින හැසිරවීම ඉක්මනින් එකතු කිරීමට අවශ්‍ය නම් එයට අවස්ථාවක් ලබා දෙන්න.

ඔබට ඉලක්කම් දෙකකින් පමණක් කාලය පෙන්වීමට අවශ්‍ය නම් , මෙය ඔබට උපකාරී වනු ඇත:

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

මෙම කාර්යයන් භාවිතා කරන්න

toTimeString() and toLocaleDateString()

වැඩි විස්තර සඳහා පහත සබැඳිය බලන්න https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

JsSimpleDateFormat යනු දිනය වස්තුව සංයුති කර ආකෘතිගත කළ නූල් දිනය වස්තුවට විග්‍රහ කළ හැකි පුස්තකාලයකි. එය ජාවා ආකෘතිය භාවිතා කරයි (සිම්පල් ඩේට් ෆෝමැට් පන්තිය). මාස සහ දිනවල නම දේශීයකරණය කළ හැකිය.

උදාහරණයක්:

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

දිනය හැඩතල ගැන්වීම හිමිකාර ක්‍රියාකාරිත්වය බැවින් පිළිතුර “කොතැනකවත් නැත”. ToString කාර්යයන් විශේෂිත ආකෘතියකට අනුකූල වීමට අදහස් කරන බව මම නොසිතමි. මෙම සම්මතයන් 5.1 පිරිවිතර (දී උදා http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, 173 පිටුව), එම toString කාර්යය පහත සඳහන් පරිදි ලේඛනගත :

"සංගීතයේ අන්තර්ගතය ක්‍රියාත්මක කිරීම මත රඳා පවතී"

ආකෘතිකරණය තරමක් පහසුවෙන් ඉටු කර ගැනීම සඳහා පහත සාම්පල වැනි කාර්යයන් භාවිතා කළ හැකිය.

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

ඔබ වැනි පුස්තකය සියලු අංග අවශ්ය නොවේ නම් Moment.js සපයයි, ඔබ මගේ වරාය භාවිතා කළ හැකි අවසාන පිවිසුම . එය සැහැල්ලු ය (1.35 KB එදිරිව 57.9 KB Moment.js 2.15.0 හා සසඳන විට අවම කර ඇත) සහ එහි බොහෝ ක්‍රියාකාරීත්වය සපයයි 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;
  });
}

නියැදි භාවිතය:

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"

නවතම කේතය මෙහි ඇත: https://github.com/thdoan/strftime

"2012-12-29" ආපසු යැවීමට දිනයක් සංයුති කිරීමට නිවැරදි ක්‍රමය ජාවාස්ක්‍රිප්ට් දිනය ආකෘතියෙන් ස්ක්‍රිප්ට් එක සමඟ ය :

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

මෙම කේතය ක්‍රියා නොකරයි:

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

පුද්ගලිකව, මම PHP සහ jQuery / javascript යන දෙකම සමාන මිනුම් වලින් භාවිතා කරන නිසා, මම php.js http://phpjs.org/functions/date/ වෙතින් දින ශ්‍රිතය භාවිතා කරමි.

මා දැනටමත් දන්නා දෙයක් ලෙස එකම ආකෘතියේ නූල් භාවිතා කරන පුස්තකාලයක් භාවිතා කිරීම මට පහසු වන අතර, දිනය ශ්‍රිතය සඳහා සියලු ආකෘති නූල් හැකියාවන් අඩංගු අත්පොත ඇත්ත වශයෙන්ම php.net හි මාර්ගගත වේ

ඔබ කැමති ක්‍රමවේදය භාවිතා කර ඔබගේ HTML හි date.js ගොනුව ඇතුළත් කර එය මේ ආකාරයට අමතන්න:

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

ඔබට අවශ්‍ය නම් valueOf () වෙනුවට d1.getTime () භාවිතා කළ හැකිය, ඔවුන් එකම දේ කරයි.

ජාවාස්ක්‍රිප්ට් කාලරාමුව 1000 කින් බෙදීම යනු ජාවාස්ක්‍රිප්ට් කාලරාමුව මිලි තත්පර වලින් වන නමුත් PHP කාලරාමුව තත්පර කිහිපයකින් පවතින බැවිනි.

බොහෝ රාමු (ඔබ දැනටමත් භාවිතා කරමින් සිටින) ඔබ නොදැන සිටිය හැකි දින හැඩතල ගැන්වීම් ඇත. jQueryUI දැනටමත් සඳහන් කර ඇති නමුත් කෙන්ඩෝ යූඅයි (ගෝලීයකරණය) , යාහූ යූ (යූටිල්) සහ ඇන්ගුලර් ජේඑස් වැනි වෙනත් රාමු ද ඒවා සතුව ඇත.

// 11/6/2000
kendo.toString(new Date(value), "d")

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