ජාවාස්ක්‍රිප්ට් දිනයක් සංයුති කරන්නේ කෙසේද

ජාවාස්ක්‍රිප්ට් හි, දින වස්තුවක් ලෙස මුද්‍රණය කරන්නේ 10-Aug-2010කෙසේද?

අභිරුචි-වෙන් කරන ලද දින ආකෘති සඳහා, ඔබ DateTimeFormatවස්තුවකින් දිනය (හෝ වේලාව) සංරචක ඉවත් කළ යුතුය (එය ECMAScript ජාත්‍යන්තරකරණ API හි කොටසකි ), ඉන්පසු ඔබට අවශ්‍ය පරිසීමකයන් සමඟ අතින් අතින් සාදන්න.

මෙය සිදු කිරීම සඳහා, ඔබට මෙය භාවිතා කළ හැකිය DateTimeFormat#formatToParts:

const date = new Date('2010-08-05')
const dateTimeFormat = new Intl.DateTimeFormat('en', { year: 'numeric', month: 'short', day: '2-digit' }) 
const [{ value: month },,{ value: day },,{ value: year }] = dateTimeFormat .formatToParts(date ) 

console.log(`${day}-${month}-${year }`)
console.log(`${day}👠${month}👢${year}`) // just for fun

ඔබට DateTimeFormatඑකින් එක භාවිතයෙන් කොටස් ඉවත් කර ගත හැකිය DateTimeFormat#format, නමුත් මෙම ක්‍රමය භාවිතා කරන විට, 2020 මාර්තු වන විට, මිනිත්තු සහ තත්පර වල ප්‍රමුඛ ශුන්‍යයන් වෙත පැමිණෙන විට ECMAScript ක්‍රියාත්මක කිරීමේදී දෝෂයක් ඇති බව සලකන්න (මෙම දෝෂය ඉහත ප්‍රවේශය මග හැරේ).

const d = new Date('2010-08-05')
const ye = new Intl.DateTimeFormat('en', { year: 'numeric' }).format(d)
const mo = new Intl.DateTimeFormat('en', { month: 'short' }).format(d)
const da = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(d)

console.log(`${da}-${mo}-${ye}`)

දිනයන් සහ වේලාවන් සමඟ වැඩ කරන විට, සාමාන්‍යයෙන් පුස්තකාලයක් භාවිතා කිරීම වටී (උදා: moment.js , luxon ) ක්ෂේත්‍රයේ සැඟවුණු සංකීර්ණතා බොහොමයක් නිසා.

ඉහත විසඳුම් සඳහා භාවිතා කරන ECMAScript ජාත්‍යන්තරකරණ API, IE10 හි සහය නොදක්වන බව සලකන්න ( 2020 පෙබරවාරි මාසයේ ගෝලීය බ්‍රව්සර් වෙළඳපල කොටස 0.03% ).

දැනට පිළිගත් පිළිතුරට වඩා හැඩතල ගැන්වීම පිළිබඳ ඔබට තරමක් අඩු පාලනයක් අවශ්‍ය නම්, Date#toLocaleDateStringසම්මත ස්ථාන-විශේෂිත විදැහුම් නිර්මාණය කිරීමට භාවිතා කළ හැකිය. මෙම localeසහ optionsතර්ක අයදුම්පත් සිය හැඩතල සම්මුතීන් භාවිතා කළ යුතුය භාෂාව නියම, සහ විදැහුම් සමහර පාරිභෝගිකයාගේ ඉඩ දෙන්න.

විකල්ප ප්‍රධාන උදාහරණ:

1. දිනය: දවස
   නියෝජනය කිරීම.
   විය හැකි අගයන් වන්නේ "සංඛ්‍යාත්මක", "ද්වි-ඉලක්කම්" ය.
2. සතියේ දිනය: සතියේ දිනය
   නියෝජනය කිරීම.
   විය හැකි අගයන් වන්නේ "පටු", "කෙටි", "දිගු" ය.
3. වර්ෂය: වර්ෂය
   නියෝජනය කිරීම.
   විය හැකි අගයන් වන්නේ "සංඛ්‍යාත්මක", "ද්වි-ඉලක්කම්" ය.
4. මාසය: මාසය
   නියෝජනය කිරීම.
   විය හැකි අගයන් වන්නේ "සංඛ්‍යාත්මක", "ද්වි-ඉලක්කම්", "පටු", "කෙටි", "දිගු" ය.
5. පැය: පැයේ
   නිරූපණය.
   විය හැකි අගයන් වන්නේ "සංඛ්‍යාත්මක", "ද්වි-ඉලක්කම්" ය.
6. මිනිත්තුව: මිනිත්තුවේ නිරූපණය.
   විය හැකි අගයන් වන්නේ "සංඛ්‍යාත්මක", "ද්වි-ඉලක්කම්" ය.
7. දෙවනුව: දෙවැන්න
   නියෝජනය කිරීම.
   විය හැකි අගයන් වන්නේ "සංඛ්‍යාත්මක", ද්වි-ඉලක්කම් "ය.

මෙම යතුරු සියල්ලම අත්‍යවශ්‍ය නොවේ. ඔබගේ අවශ්‍යතා මත පදනම්ව ඔබට විකල්ප අගයන් ගණන වෙනස් කළ හැකි අතර, මෙය එක් එක් දින කාල වකවානුවේ පැවැත්ම පිළිබිඹු කරයි.

සටහන: ඔබ අන්තර්ගත විකල්පයන් වින්‍යාස කිරීමට පමණක් කැමති නමුත් වර්තමාන ස්ථානය භාවිතා කරන්නේ නම්, nullපළමු පරාමිතිය සඳහා ගමන් කිරීම දෝෂයක් ඇති කරයි. undefinedඒ වෙනුවට භාවිතා කරන්න .

විවිධ භාෂා සඳහා:

1. "en-US": ඉංග්‍රීසි සඳහා
2. "හයි-ඉන්": හින්දි සඳහා
3. "ja-JP": ජපන් භාෂාව සඳහා

ඔබට තවත් භාෂා විකල්ප භාවිතා කළ හැකිය.

උදාහරණයක් වශයෙන්

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

ඔබට toLocaleString()එකම ක්රමය සඳහා ක්රමය භාවිතා කළ හැකිය . එකම වෙනස නම් මෙම ශ්‍රිතය මඟින් ඔබ කිසිදු විකල්පයක් සමත් නොවන කාලය සපයයි.

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

යොමුව:

• toLocaleString()

• toLocaleDateString()

Date.format පුස්තකාලය භාවිතා කරන්න :

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

ප්‍රතිලාභ:

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

දිනය ආකෘතිය npm

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

ඔබ ඉක්මනින් සරල JavaScript, භාවිතා භාවිතා කර ඔබගේ දිනය සංයුති කිරීමට අවශ්ය නම් getDate, getMonth + 1, getFullYear, getHoursහා getMinutes:

var d = new Date();

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

// 16-5-2015 9:50

නැතහොත්, ඔබට එය ශුන්‍ය සමග පෑඩ් කිරීමට අවශ්‍ය නම්:

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

හොඳයි, මට අවශ්‍ය වූයේ අද දිනය 2012-06-23 වැනි MySQL හිතකාමී දින නූලක් බවට පරිවර්තනය කිරීම සහ එම විමසුම මගේ එක් විමසුමක පරාමිතියක් ලෙස භාවිතා කිරීමයි. මා සොයාගත් සරල විසඳුම මෙයයි:

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

ඉහත විසඳුම ඔබගේ කාල කලාපය ඕෆ්සෙට් සැලකිල්ලට නොගන්නා බව මතක තබා ගන්න .

ඒ වෙනුවට ඔබට මෙම ශ්‍රිතය භාවිතා කිරීම ගැන සලකා බැලිය හැකිය:

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

ඔබ මෙම කේතය දවසේ ආරම්භය / අවසානය දක්වා ක්‍රියාත්මක කරන්නේ නම් මෙය ඔබට නිවැරදි දිනය ලබා දෙනු ඇත.

• උදාහරණය: http://jsfiddle.net/simo/sapuhzmm/
• Date.toISOString
• දිනය. JJSON
• String.slice

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

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

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

OP ආකෘතිය පහත පරිදි ජනනය කළ හැකිය:

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

සටහන: කෙසේ වෙතත්, සාමාන්‍යයෙන් ජාවාස්ක්‍රිප්ට් සම්මත පුස්තකාල දීර් 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 : දිනය සඳහා සාමාන්‍ය toString.

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

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

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

ස්නිපෙට් සඳහා උදාහරණ:

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

ඔබ දැනටමත් ඔබේ ව්‍යාපෘතියේ jQuery UI භාවිතා කරන්නේ නම් ඔබට එය මේ ආකාරයෙන් කළ හැකිය:

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

// formatted will be 'Jul 8, 2014'

සෙල්ලම් කිරීමට සමහර ඩේට්පිකර් දින ආකෘති විකල්ප මෙහි ඇත.

මම හිතන්නේ ඔබට සම්මත නොවන දින ක්‍රමය භාවිතා කළ හැකියtoLocaleFormat(formatString)

formatString:strftime() C හි ශ්‍රිතය අපේක්ෂා කරන එකම ආකෘතියේ ආකෘතියක් .

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

යොමුව:

• tolocaleformat
• strftime

කුඩා ඔනිටිමර් සඳහා හොඳම තේරීම සරල ජාවාස්ක්‍රිප්ට් ය.

අනෙක් අතට, ඔබට තවත් දින දේවල් අවශ්‍ය නම්, MomentJS විශිෂ්ට විසඳුමකි.

උදාහරණයක් වශයෙන්:

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

නවීන බ්‍රව්සර්වල (*) , ඔබට මෙය කළ හැකිය:

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

අද ක්‍රියාත්මක වන්නේ නම් ප්‍රතිදානය (ජනවාරි 24ᵗʰ, 2016):

'24-Jan-2016'

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

ඔබට date.js දෙස බැලිය යුතුය . දිනයන් සමඟ වැඩ කිරීම සඳහා එය බොහෝ පහසු සහායකයින් එක් කරයි, උදාහරණයක් ලෙස, ඔබේ නඩුවේ:

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

ආරම්භ කිරීම: http://www.datejs.com/2007/11/27/getting-started-with-datejs/

@ සෙබස්තියන් - විකල්පයක් ලෙස සියලුම බ්‍රව්සර් සහාය

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

ප්‍රලේඛනය: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString

පුස්තකාල සහ දින ක්‍රම භාවිතයෙන් තොරව ඔබ ඉල්ලූ ආකෘතිය එක පේළියකින් ලබා ගත හැකිය, රීජෙක්ස්:

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

මගේ පරීක්ෂණයේදී, මෙය ප්‍රධාන බ්‍රව්සර්වල (ක්‍රෝම්, සෆාරි, ෆයර්ෆොක්ස් සහ අයිඊ.) විශ්වාසදායක ලෙස ක්‍රියා කරයි. @RobG පෙන්වා දුන් පරිදි, Date.prototype.toString () හි ප්‍රතිදානය ක්‍රියාත්මක කිරීම මත රඳා පවතී, එබැවින් ප්‍රතිදානය සහතික කර ගන්න එය ඔබගේ ජාවාස්ක්‍රිප්ට් එන්ජිම තුළම ක්‍රියාත්මක වේ. නූල් ප්‍රතිදානය පරීක්ෂා කිරීම සඳහා ඔබට යම් කේතයක් එකතු කළ හැකි අතර ඔබ රීජෙක්ස් ප්‍රතිස්ථාපනය කිරීමට පෙර එය ඔබ අපේක්ෂා කරන දේට ගැලපෙන බවට වග බලා ගන්න.

හරි , අපට මේ දිනවල ජාවාස්ක්‍රිප්ට් හි දිනයක් සංයුති කිරීම සඳහා ඉතා ප්‍රයෝජනවත් වන Intl නමින් යමක් තිබේ :

ඔබගේ දිනය පහත පරිදි වේ:

var date = '10/8/2010';

පහත දැක්වෙන පරිදි නව දිනය () භාවිතා කිරීමෙන් ඔබ දිනය වෙත වෙනස් වේ:

date = new Date(date);

දැන් ඔබට පහත දැක්වෙන ස්ථාන ලැයිස්තුවක් භාවිතා කිරීමට කැමති ආකාරයකින් එය සංයුති කළ හැකිය :

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: "٨‏/١٠‏/٢٠١٠"

ඔබ ඉහත සඳහන් කළ ආකෘතිය ඔබට හරියටම අවශ්‍ය නම්, ඔබට කළ හැක්කේ:

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

ප්‍රති result ලය වනු ඇත්තේ:

"10-Aug-2010"

වැඩි විස්තර සඳහා Intl API සහ Intl.DateTimeFormat ප්‍රලේඛනය බලන්න.

ECMAScript සංස්කරණය 6 (ES6 / ES2015) නූල් අච්චුවක් භාවිතා කිරීම:

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

ඔබට පරිසීමක වෙනස් කිරීමට අවශ්‍ය නම්:

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

ඇසුරුම් කළ විසඳුම: ලක්සන්

සියල්ලටම ගැලපෙන පරිදි එක් විසඳුමක් භාවිතා කිරීමට ඔබට අවශ්‍ය නම්, ලක්සන් (Moment.js හි නවීකරණය කරන ලද අනුවාදය) භාවිතා කිරීම මම තරයේ නිර්දේශ කරමි බොහෝ ස්ථාන / භාෂාවන් සහ වෙනත් විශේෂාංග ටොන් ගණනක් ආකෘතිකරණය කරන ) .

ලක්සන් මොමන්ට්.ජේ වෙබ් අඩවියේ සත්කාරකත්වය දරනු ලබන අතර එය මොමන්ට්.ජේ සංවර්ධකයෙකු විසින් වැඩි දියුණු කරන ලදි, මන්ද මොමන්ට්.ජේට සංවර්ධකයාට ආමන්ත්‍රණය කිරීමට අවශ්‍ය නමුත් සීමාවන් නොමැත.

ස්ථාපනය සඳහා:

npm install luxon හෝ yarn add luxon (වෙනත් ස්ථාපන ක්‍රම සඳහා සබැඳිය බලන්න)

උදාහරණයක්:

luxon.DateTime.fromISO('2010-08-10').toFormat('yyyy-LLL-dd');

අස්වැන්න:

10-අගෝස්තු -2010

අතින් විසඳුම

Moment.js, Class DateTimeFormatter (Java) , සහ Class SimpleDateFormat (Java) වැනි සමාන හැඩතල ගැන්වීම් භාවිතා කිරීම. මම පුළුල් විසඳුමක් ක්‍රියාත්මක කළෙමිformatDate(date, patternStr) , කේතය කියවීමට හා වෙනස් කිරීමට පහසු වන . ඔබට දිනය, වේලාව, AM / PM යනාදිය ප්‍රදර්ශනය කළ හැකිය. තවත් උදාහරණ සඳහා කේතය බලන්න.

උදාහරණයක්:

formatDate(new Date(), 'EEEE, MMMM d, yyyy HH:mm:ss:S')

(formatDate පහත කේත ස්නිපටයේ ක්‍රියාත්මක වේ)

අස්වැන්න:

2018 ඔක්තෝබර් 12 වන සිකුරාදා 18: 11: 23: 445

"කේත ස්නිපටය ධාවනය කරන්න" ක්ලික් කිරීමෙන් කේතය උත්සාහ කරන්න.

දිනය සහ කාල රටා

yy= ඉලක්කම් 2; yyyy= සම්පූර්ණ වර්ෂය

M= ඉලක්කම් මාසය; MM= ඉලක්කම් 2 මාසය; MMM= කෙටි මාසය නම; MMMM= සම්පූර්ණ මාසය නම

EEEE= සම්පූර්ණ සතියේ දින නම; EEE= කෙටි සතියේ දින නම

d= ඉලක්කම් දිනය; dd= ඉලක්කම් 2 ක දිනය

h= පැය am / pm; hh= ඉලක්කම් දෙකේ පැය am / pm; H= පැය; HH= ඉලක්කම් දෙකේ පැය

m= මිනිත්තු; mm= ඉලක්කම් දෙකේ මිනිත්තු; aaa= AM / PM

s= තත්පර; ss= ඉලක්කම් 2 තත්පර

S = මිලි තත්පර

var monthNames = [
  "January", "February", "March", "April", "May", "June", "July",
  "August", "September", "October", "November", "December"
];
var dayOfWeekNames = [
  "Sunday", "Monday", "Tuesday",
  "Wednesday", "Thursday", "Friday", "Saturday"
];
function formatDate(date, patternStr){
    if (!patternStr) {
        patternStr = 'M/d/yyyy';
    }
    var day = date.getDate(),
        month = date.getMonth(),
        year = date.getFullYear(),
        hour = date.getHours(),
        minute = date.getMinutes(),
        second = date.getSeconds(),
        miliseconds = date.getMilliseconds(),
        h = hour % 12,
        hh = twoDigitPad(h),
        HH = twoDigitPad(hour),
        mm = twoDigitPad(minute),
        ss = twoDigitPad(second),
        aaa = hour < 12 ? 'AM' : 'PM',
        EEEE = dayOfWeekNames[date.getDay()],
        EEE = EEEE.substr(0, 3),
        dd = twoDigitPad(day),
        M = month + 1,
        MM = twoDigitPad(M),
        MMMM = monthNames[month],
        MMM = MMMM.substr(0, 3),
        yyyy = year + "",
        yy = yyyy.substr(2, 2)
    ;
    // checks to see if month name will be used
    patternStr = patternStr
      .replace('hh', hh).replace('h', h)
      .replace('HH', HH).replace('H', hour)
      .replace('mm', mm).replace('m', minute)
      .replace('ss', ss).replace('s', second)
      .replace('S', miliseconds)
      .replace('dd', dd).replace('d', day)
      
      .replace('EEEE', EEEE).replace('EEE', EEE)
      .replace('yyyy', yyyy)
      .replace('yy', yy)
      .replace('aaa', aaa);
    if (patternStr.indexOf('MMM') > -1) {
        patternStr = patternStr
          .replace('MMMM', MMMM)
          .replace('MMM', MMM);
    }
    else {
        patternStr = patternStr
          .replace('MM', MM)
          .replace('M', M);
    }
    return patternStr;
}
function twoDigitPad(num) {
    return num < 10 ? "0" + num : num;
}
console.log(formatDate(new Date()));
console.log(formatDate(new Date(), 'dd-MMM-yyyy')); //OP's request
console.log(formatDate(new Date(), 'EEEE, MMMM d, yyyy HH:mm:ss.S aaa'));
console.log(formatDate(new Date(), 'EEE, MMM d, yyyy HH:mm'));
console.log(formatDate(new Date(), 'yyyy-MM-dd HH:mm:ss.S'));
console.log(formatDate(new Date(), 'M/dd/yyyy h:mmaaa'));

ලක්සන් ගෙන ඒමට ස්තූතියි @ ජෙරී.

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

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

බාහිර පුස්තකාල භාවිතා නොකර ජාවාස්ක්‍රිප්ට් විසඳුමක්:

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)

new Date().toLocaleDateString()

// "3/21/2018"

දී වඩා ප්රලේඛනය developer.mozilla.org

ඔබ ඔබේ කේතයේ jQuery UI භාවිතා කරන්නේ නම්, ඉන්බිල්ට් ශ්‍රිතයක් formatDate()ඇත. අද දිනය සංයුති කිරීම සඳහා මම එය මේ ආකාරයෙන් භාවිතා කරමි:

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

දිනය සැකසීමේ තවත් බොහෝ උදාහරණ jQuery UI ප්‍රලේඛනයෙන් ඔබට දැක ගත හැකිය .

මේ සඳහා අපට විසඳුම් රාශියක් ඇත, නමුත් මම හිතන්නේ ඒවායින් හොඳම දේ Moment.js ය. එබැවින් දිනය සහ වේලාව මෙහෙයුම් සඳහා Moment.js භාවිතා කිරීමට මම පෞද්ගලිකව යෝජනා කරමි.

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

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

ජාවාස්ක්‍රිප්ට් හි දින වේලාවන් සංයුති කිරීම සඳහා ප්‍රයෝජනවත් සහ නම්‍යශීලී ක්‍රමයක් වන්නේ 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,'-'));

ප්‍රති ult ලය: "12-Oct-2017"

විකල්ප තර්කය භාවිතා කරමින් දිනය සහ වේලාවන් අභිරුචිකරණය කළ හැකිය.

එම Intl.DateTimeFormat වස්තුව භාෂාව සංවේදී දිනය හා වේලාව හැඩතල හැකි බව වස්තූන් සඳහා ඉදිකිරීමටත් වේ.

සින්ටැක්ස්

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

පරාමිතීන්

පෙදෙස්

විකල්ප. BCP 47 භාෂා ටැගය සහිත නූලක් හෝ එවැනි නූල් සමූහයක්. ස්ථාන තර්කයේ පොදු ස්වරූපය සහ අර්ථ නිරූපණය සඳහා, Intl පිටුව බලන්න. පහත දැක්වෙන යුනිකෝඩ් දිගු කිරීමේ යතුරු සඳහා අවසර ඇත:

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

විකල්ප

විකල්ප. පහත ගුණාංග සමහරක් හෝ සියල්ල සහිත වස්තුවක්:

localeMatcher

භාවිතා කිරීමට ස්ථාන ගැලපෙන ඇල්ගොරිතම. විය හැකි අගයන් "lookup"සහ "best fit"; පෙරනිමිය වේ "best fit". මෙම විකල්පය පිළිබඳ වැඩි විස්තර සඳහා, Intl පිටුව බලන්න.

වේලා කලාපය

භාවිතා කළ යුතු කාල කලාපය. ක්‍රියාවට නැංවිය යුතු එකම අගය වන්නේ "UTC"; පෙරනිමිය යනු ධාවන කාලයේ පෙරනිමි කාල කලාපයයි. නිර්මාණයන් ද IANA කාල කලාපය දත්ත අදාල කාල කලාපය නම්, වැනි හඳුනා හැක "Asia/Shanghai", "Asia/Kolkata", "America/New_York".

පැය 12

පැය 12 ක කාලය භාවිතා කළ යුතුද යන්න (පැය 24 ක කාලයට වඩා වෙනස්ව). විය හැකි අගයන් trueසහ false; පෙරනිමිය පෙදෙසි මත රඳා පවතී.

formatMatcher

භාවිතා කිරීමට ගැලපෙන ඇල්ගොරිතම ආකෘතිය. විය හැකි අගයන් "basic"සහ "best fit"; පෙරනිමිය වේ "best fit". මෙම දේපල භාවිතය පිළිබඳ තොරතුරු සඳහා පහත ඡේද බලන්න.

පහත දැක්වෙන ගුණාංග මඟින් ආකෘතිගත නිමැවුම් සඳහා භාවිතා කළ යුතු දින-කාලීන සංරචක සහ ඒවායේ අපේක්ෂිත නිරූපණයන් විස්තර කෙරේ. අවම වශයෙන් පහත දැක්වෙන අනුකොටස් සඳහා සහය දැක්වීම සඳහා ක්‍රියාත්මක කිරීම අවශ්‍ය වේ:

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

ක්‍රියාත්මක කිරීම වෙනත් අනුකොටස් සඳහා සහාය විය හැකි අතර, හොඳම ගැලපීම සොයා ගැනීම සඳහා පවතින සියලුම උප-නිරූපණ සංයෝජනයන්ට එරෙහිව ඉල්ලීම් සාකච්ඡා කරනු ලැබේ. මෙම සාකච්ඡාව සඳහා ඇල්ගොරිතම දෙකක් ලබා ගත හැකි අතර එය මැචර් දේපල ආකෘතියෙන් තෝරාගෙන ඇත: සම්පුර්ණයෙන්ම නිශ්චිතව දක්වා ඇති "basic"ඇල්ගොරිතමයක් සහ ක්‍රියාත්මක කිරීම මත රඳා පවතින “හොඳම සුදුසු” ඇල්ගොරිතම.

සතියේ දිනය

සතියේ දිනය නියෝජනය කිරීම. හැකි අගයන් වේ "narrow", "short", "long".

යුගය

යුගයේ නියෝජනය. හැකි අගයන් වේ "narrow", "short", "long".

වර්ෂය

වසරේ නියෝජනය. විය හැකි අගයන් "numeric", "2-digit".

මාසය

මාසය නියෝජනය කිරීම. හැකි අගයන් වේ "numeric", "2-digit", "narrow", "short", "long".

දවස

දවසේ නියෝජනය. විය හැකි අගයන් "numeric", "2-digit".

පැය

පැයේ නිරූපණය. විය හැකි අගයන් "numeric", "2-digit".

විනාඩිය

මිනිත්තුවේ නිරූපණය. විය හැකි අගයන් "numeric", "2-digit".

දෙවැනි

දෙවැන්න නියෝජනය කිරීම. විය හැකි අගයන් "numeric", "2-digit".

timeZoneName

කාල කලාපයේ නම නිරූපණය කිරීම. විය හැකි අගයන් "short", "long". එක් එක් දිනය-කාලීන සංරචක දේපල සඳහා පෙරනිමි අගය නිර්වචනය කර නැත, නමුත් සියලු සංරචක ගුණාංග නිර්වචනය කර නොමැති නම්, වර්ෂය, මාසය සහ දිනය ලෙස උපකල්පනය කෙරේ "numeric".

මාර්ගගතව පරීක්ෂා කරන්න

වැඩිපුර විස්තර

මෙය ගැටලුවට උදව් විය හැකිය:

var d = new Date();

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

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

මගේ 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;
}

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

ඔබට DayJs දෙස බැලිය යුතුය. එය momentJs හි ප්‍රතිනිර්මාණයකි, නමුත් මොඩියුලර් ගෘහ නිර්මාණ ශිල්පය එතරම් සැහැල්ලු ය.

එකම නවීන API සමඟ Moment.js සඳහා වේගවත් 2kB විකල්පය

Day.js යනු අවම වශයෙන් ජාවාස්ක්‍රිප්ට් පුස්තකාලයක් වන අතර එය බොහෝ විට Moment.js- අනුකූල API සහිත නවීන බ්‍රව්සර් සඳහා දිනයන් සහ වේලාවන් විග්‍රහ කිරීම, වලංගු කිරීම, හැසිරවීම සහ ප්‍රදර්ශනය කරයි. ඔබ Moment.js භාවිතා කරන්නේ නම්, Day.js භාවිතා කරන්නේ කෙසේදැයි ඔබ දැනටමත් දන්නවා.

var date = Date.now();
const formatedDate = dayjs(date).format("YYYY-MM-DD")
console.log(formatedDate);

<script src="https://cdnjs.cloudflare.com/ajax/libs/dayjs/1.8.16/dayjs.min.js" crossorigin="anonymous"></script>

Sugar.js Date.format ක්‍රමයක් ඇතුළුව දිනය වස්තුවට විශිෂ්ට දිගු ඇත .

ප්‍රලේඛනයෙන් උදාහරණ:

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

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

පිටපත් කිරීම, ඇලවීම සහ සම්මත කර ගැනීම සඳහා ඉතා සරල ES6 විසඳුමක් සොයන ඕනෑම කෙනෙකුට:

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

2019 වන විට, ඔබට සමහර කොටස් පමණක් ආපසු ලබා දීමට ලොකේල් ඩේට්ස්ට්‍රිං වෙත යා හැකි බව පෙනේ, එවිට ඔබට අවශ්‍ය පරිදි ඒවාට සම්බන්ධ විය හැකිය:

var date = new Date();

console.log(date.toLocaleDateString("en-US", { day: 'numeric' }) 
            + "-"+ date.toLocaleDateString("en-US", { month: 'short' })
            + "-" + date.toLocaleDateString("en-US", { year: 'numeric' }) );

> 16-Nov-2019

console.log(date.toLocaleDateString("en-US", { month: 'long' }) 
            + " " + date.toLocaleDateString("en-US", { day: 'numeric' }) 
            + ", " + date.toLocaleDateString("en-US", { year: 'numeric' }) );

> November 16, 2019

"10-අගෝස්තු -2010" ලබා ගැනීමට, උත්සාහ කරන්න:

var date = new Date('2010-08-10 00:00:00');
date = date.toLocaleDateString(undefined, {day:'2-digit'}) + '-' + date.toLocaleDateString(undefined, {month:'short'}) + '-' + date.toLocaleDateString(undefined, {year:'numeric'})

බ්‍රව්සර් සහාය සඳහා, ලොකේල් ඩේට්ස්ට්රිං බලන්න .