“හරි” JSON දිනය ආකෘතිය

JSON දිනය ආකෘතිය සඳහා මම විවිධ ප්‍රමිතීන් දැක ඇත්තෙමි:

"\"\\/Date(1335205592410)\\/\""         .NET JavaScriptSerializer
"\"\\/Date(1335205592410-0500)\\/\""    .NET DataContractJsonSerializer
"2012-04-23T18:25:43.511Z"              JavaScript built-in JSON object
"2012-04-21T18:25:43-05:00"             ISO 8601

නිවැරදි එක කුමක්ද? නැත්නම් හොඳම ද? මේ සම්බන්ධයෙන් කිසියම් ප්‍රමිතියක් තිබේද?

දිනයන් නිරූපණය කළ යුතු ආකාරය JSON විසින්ම සඳහන් නොකරයි , නමුත් JavaScript මඟින් එය සිදු කරයි.

ඔබ කළ යුතු විසින් නිකුත් කරන ආකෘතිය භාවිතා Dateගේ toJSONක්රමය:

2012-04-23T18:25:43.511Z

මෙන්න හේතුව:

1. එය මිනිස් කියවිය හැකි නමුත් සංක්ෂිප්ත ය

2. එය නිවැරදිව වර්ග කරයි

3. කාලානුක්‍රමය නැවත ස්ථාපිත කිරීමට උපකාරී වන භාගික තත්පර එයට ඇතුළත් වේ

4. එය ISO 8601 ට අනුකූල වේ

5. අයිඑස්ඕ 8601 දශකයකට වැඩි කාලයක් තිස්සේ ජාත්‍යන්තරව හොඳින් ස්ථාපිත වී ඇත

6. ISO 8601 W3C , RFC3339 සහ XKCD විසින් අනුමත කර ඇත

එසේ පැවසුවහොත් , මෙතෙක් ලියන ලද සෑම දිනකම පුස්තකාලයට "1970 සිට මිලි තත්පර" තේරුම් ගත හැකිය. එබැවින් පහසුවෙන් අතේ ගෙන යා හැකි නම් , හොරා මාස්ටර් හරි.

JSON දිනයන් ගැන කිසිවක් දන්නේ නැත. .NET කරන්නේ සම්මත නොවන හැක් / දිගුවකි.

මම Dateජාවාස්ක්‍රිප්ට් හි වස්තුවකට පහසුවෙන් පරිවර්තනය කළ හැකි ආකෘතියක් භාවිතා කරමි , එනම් එය සම්මත කළ හැකිය new Date(...). පහසුම හා බොහෝ විට අතේ ගෙන යා හැකි ආකෘතිය වන්නේ 1970 සිට මිලි තත්පර අඩංගු කාලරාමුවයි.

නිවැරදි ආකෘතියක් නොමැත ; මෙම JSON පිරිවිතර එය කිරීමට බොහෝ වෙනස් ක්රම ඇත ඇයි වන දින හුවමාරු සඳහා ආකෘතියක් නියම කරන්නේ නැත.

හොඳම ආකෘතිය ISO 8601 ආකෘතියෙන් නිරූපණය වන දිනයකි ( විකිපීඩියාව බලන්න ); එය හොඳින් දන්නා සහ බහුලව භාවිතා වන ආකෘතියක් වන අතර විවිධ භාෂාවන් හරහා හැසිරවිය හැකි අතර එය අන්තර් ක්‍රියාකාරිත්වයට ඉතා සුදුසු වේ. ජනනය කරන ලද json පාලනය කිරීමට ඔබට හැකියාවක් තිබේ නම්, උදාහරණයක් ලෙස, ඔබ වෙනත් පද්ධති සඳහා json ආකෘතියෙන් දත්ත ලබා දෙයි, දිනය හුවමාරු ආකෘතිය ලෙස 8601 තෝරා ගැනීම හොඳ තේරීමකි.

ජනනය කරන ලද json පාලනය කිරීමට ඔබට හැකියාවක් නොමැති නම්, උදාහරණයක් ලෙස, ඔබ දැනට පවතින විවිධ පද්ධති කිහිපයක json පාරිභෝගිකයා වේ, මෙය හැසිරවිය හැකි හොඳම ක්‍රමය වන්නේ අපේක්ෂිත විවිධ ආකෘතීන් හැසිරවීමට දිනය විග්‍රහ කිරීමේ උපයෝගීතා ශ්‍රිතයක් තිබීමයි.

RFC 7493 වෙතින් (I-JSON පණිවිඩ ආකෘතිය) :

I-JSON යනු අන්තර්ජාල JSON හෝ අන්තර් ක්‍රියාකාරී JSON යන්නයි.

ප්‍රොටෝකෝල වල බොහෝ විට කාලරාමු හෝ කාල සීමාවන් අඩංගු වන පරිදි නිර්මාණය කර ඇති දත්ත අයිතම අඩංගු වේ. RFC 3339 හි නිශ්චිතව දක්වා ඇති පරිදි, එවැනි සියලු දත්ත අයිතම ISO 8601 ආකෘතියේ තන්තු අගයන් ලෙස ප්‍රකාශ කළ යුතු බව නිර්දේශ කර ඇත, කුඩා අකුරු වෙනුවට ලොකු අකුරු භාවිතා කළ යුතු අමතර සීමාවන් සහිතව, කාල කලාපය ඇතුළත් නොකිරීමට සහ විකල්ප පසුපස තත්පර ඒවායේ අගය "00" වූ විට පවා ඇතුළත් කළ යුතුය. කාල සීමාවන් අඩංගු සියලුම දත්ත අයිතම RFC 3339 හි උපග්‍රන්ථයේ A හි “කාලසීමාව” නිෂ්පාදනයට අනුකූල වන බව නිර්දේශ කර ඇත.

යොමු කිරීම සඳහා මෙම ආකෘතිය භාවිතා කර ඇති බව මම දැක ඇත්තෙමි:

Date.UTC(2017,2,22)

එය JSONP සමඟ ක්‍රියා කරයි$.getJSON() කාර්යය. මෙම ප්‍රවේශය නිර්දේශ කිරීම සඳහා මා මෙතරම් දුරක් යාවි යැයි විශ්වාස නැත ... හැකියාවක් ලෙස එය පිටතට විසි කිරීම මිනිසුන් එය මේ ආකාරයෙන් කරන නිසා.

FWIW: සන්නිවේදන ප්‍රොටෝකෝලයක යුගයේ සිට තත්පර ගණනක් හෝ යුගයේ සිට මිලි තත්පර භාවිතා නොකරන්න, මන්දයත් මේවා අහඹු ලෙස පිම්ම තත්පර ක්‍රියාත්මක කිරීම නිසා ස්තුතිවන්ත වන බැවිනි (යවන්නා සහ ලබන්නා යන දෙදෙනාම යූටීසී පිම්ම තත්පර නිසි ලෙස ක්‍රියාත්මක කරන්නේ දැයි ඔබට අදහසක් නැත).

සුරතල් වෛරයක්, නමුත් බොහෝ අය විශ්වාස කරන්නේ යූටීසී යනු GMT සඳහා නව නම පමණක් බවයි - වැරදියි! ඔබේ පද්ධතිය අධික තත්පර ගණනක් ක්‍රියාත්මක නොකරන්නේ නම් ඔබ භාවිතා කරන්නේ GMT ය (බොහෝ විට වැරදි වුවත් UTC ලෙස හැඳින්වේ). ඔබ පිම්ම තත්පර සම්පූර්ණයෙන්ම ක්‍රියාත්මක කරන්නේ නම් ඔබ ඇත්ත වශයෙන්ම UTC භාවිතා කරයි. අනාගත පිම්ම තත්පර දැනගත නොහැක; ඒවා අවශ්‍ය පරිදි IERS විසින් ප්‍රකාශයට පත් කරනු ලබන අතර නිරන්තර යාවත්කාලීන කිරීම් අවශ්‍ය වේ. ඔබ පිම්ම තත්පර ක්‍රියාත්මක කිරීමට උත්සාහ කරන නමුත් යල් පැන ගිය යොමු වගුවක් අඩංගු (ඔබ සිතනවාට වඩා පොදු) පද්ධතියක් ක්‍රියාත්මක කරන්නේ නම් ඔබට GMT හෝ UTC නොමැති නම්, ඔබට UTC ලෙස මවා පෙන්වන විස්මයජනක පද්ධතියක් තිබේ.

මෙම දින කවුන්ටර අනුකූල වන්නේ බිඳුණු ආකෘතියකින් (y, m, d, ආදිය) ප්‍රකාශ කළ විට පමණි. ඒවා යුග ආකෘතියකට නොගැලපේ. එය මතකයේ තබා ගන්න.

සැකයක් ඇති විට F12( Ctrl+Shift+Kෆයර්ෆොක්ස් හි) එබීමෙන් නවීන බ්‍රව්සරයක ජාවාස්ක්‍රිප්ට් වෙබ් කොන්සෝලය වෙත ගොස් පහත සඳහන් දේ ලියන්න:

new Date().toISOString()

ප්‍රතිදානය කරයි:

"2019-07-04T13: 33: 03.969Z"

තා-ඩා !!

JSON සතුව දින ආකෘතියක් නොමැත, කිසිවෙකු දිනයන් ගබඩා කරන්නේ කෙසේද යන්න එය ගණන් ගන්නේ නැත. කෙසේ වෙතත්, මෙම ප්‍රශ්නය javascript සමඟ ටැග් කර ඇති බැවින්, JSON හි javascript දිනයන් ගබඩා කරන්නේ කෙසේදැයි දැන ගැනීමට ඔබට අවශ්‍ය යැයි මම සිතමි. ඔබට JSON.stringifyක්‍රමයට දිනයකින් සමත් විය හැකි අතර , එය Date.prototype.toJSONපෙරනිමියෙන් භාවිතා කරනු ඇත, එය අනෙක් අතට භාවිතා කරයි Date.prototype.toISOString( MD.d on Date.toJSON ):

const json = JSON.stringify(new Date());
const parsed = JSON.parse(json); //2015-10-26T07:46:36.611Z
const date = new Date(parsed); // Back to date object

මම JSON නූල් කියවන සෑම විටම ISO නූල් ස්වයංක්‍රීයව ජාවාස්ක්‍රිප්ට් දිනයන් බවට පරිවර්තනය reviverකිරීම සඳහා JSON.parse( JSON.parse හි MDN ) පරාමිතිය භාවිතා කිරීම ප්‍රයෝජනවත් බව මට පෙනී ගියේය .

const isoDatePattern = new RegExp(/\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)/);

const obj = {
 a: 'foo',
 b: new Date(1500000000000) // Fri Jul 14 2017, etc...
}
const json = JSON.stringify(obj);

// Convert back, use reviver function:
const parsed = JSON.parse(json, (key, value) => {
    if (typeof value === 'string' &&  value.match(isoDatePattern)){
        return new Date(value); // isostring, so cast to js date
    }
    return value; // leave any other value as-is
});
console.log(parsed.b); // // Fri Jul 14 2017, etc...

විශ්ව අන්තර්ක්‍රියාකාරිත්වය සඳහා හොඳම ආකෘතිය ISO-8601 නූල නොව EJSON භාවිතා කරන ආකෘතිය බව මම විශ්වාස කරමි.

{ "myDateField": { "$date" : <ms-since-epoch> } }

මෙහි විස්තර කර ඇති පරිදි: https://docs.meteor.com/api/ejson.html

ප්‍රතිලාභ

1. කාර්ය සාධනය අන්තහ්කරණය: ඔබ, ISO-8601 නූල් ලෙස දින ගබඩා නම්, එම ක්ෂේත්රය යටතේ දිනය අගය අපේක්ෂාවෙන් නම්, මේ ශ්රේෂ්ඨ වේ, එහෙත් ඔබ සන්දර්භය තොරව අගය වර්ග තීරණය යුතු ක්රමයක් තිබේ නම්, ඔබ සෑම string මාණකරනය ක්රියාත්මක කරන්නේ දිනය ආකෘතිය.
2. දිනය වලංගු කිරීම අවශ්‍ය නොවේ : දිනය වලංගු කිරීම සහ සත්‍යාපනය කිරීම ගැන ඔබ කරදර විය යුතු නැත. නූලක් ISO-8601 ආකෘතියට ගැලපුණත් එය සත්‍ය දිනයක් නොවිය හැකිය; මෙය කිසි විටෙකත් EJSON දිනයකින් සිදුවිය නොහැක.
3. අවිනිශ්චිත වර්ග ප්‍රකාශනය: සාමාන්‍ය දත්ත පද්ධති යන තාක් දුරට, ඔබට එක් අවස්ථාවකදී අයිඑස්ඕ නූලක් නූලක් ලෙස ගබඩා කිරීමට අවශ්‍ය නම් , සහ සැබෑ පද්ධති දිනයක් තවත් අවස්ථාවක, අයිඑස්ඕ -8601 නූල් ආකෘතිය භාවිතා කරන සාමාන්‍ය පද්ධති මෙයට යාන්ත්‍රිකව ඉඩ නොදේ. (ගැලවීමේ උපක්‍රම හෝ ඒ හා සමාන භයානක විසඳුම් නොමැතිව).

නිගමනය

මානව කියවිය හැකි ආකෘතියක් (අයිඑස්ඕ -8601 නූල්) 80% භාවිතා කිරීමේ අවස්ථාවන් සඳහා උපකාරී වන අතර වඩාත් පහසු බව මම තේරුම් ගතිමි. ඇත්ත වශයෙන්ම ඔවුන්ගේ දිනයන් අයිඑස්ඕ -8601 නූල් ලෙස ගබඩා නොකරන ලෙස කිසිවෙකුට නොකිය යුතුය. තේරුම් ගන්න, නමුත් විශ්වීයව පිළිගත් ප්‍රවාහන ආකෘතියක් සඳහා නිශ්චිත අගයන් නිශ්චිතවම දින වකවානු සහතික කළ යුතුය, අපැහැදිලි සහ මෙතරම් වලංගු භාවයක් සඳහා අවශ්‍ය වන්නේ කෙසේද?

කැමති ක්‍රමය භාවිතා කරන්නේ 2018-04-23T18:25:43.511Z...

පහත පින්තූරයේ දැක්වෙන්නේ මෙය වඩාත් සුදුසු ක්‍රමය වන්නේ මන්ද යන්නයි:

ඔබ දකින පරිදි දිනයට ස්වදේශීය ක්‍රමයක් ඇත toJSON, එය returnමෙම ආකෘතියෙන් සහ පහසුවෙන් Dateනැවත පරිවර්තනය කළ හැකිය ...

ෂෙයාර්පොයින්ට් 2013 හි, JSON හි දත්ත ලබා ගැනීම දිනය දිනය පමණක් ආකෘතියක් බවට පරිවර්තනය කිරීමේ ආකෘතියක් නොමැත, මන්ද එම දිනය ISO ආකෘතියෙන් විය යුතුය

yourDate.substring(0,10)

මෙය ඔබට ප්‍රයෝජනවත් විය හැකිය

"2014-01-01T23: 28: 56.782Z"

දිනය යූටීසී වේලාවක් නිරූපණය කරන සම්මත සහ වර්ග කළ හැකි ආකෘතියකින් නිරූපණය කෙරේ (ඉසෙඩ් මඟින් දැක්වේ). ISO 8601 ද කාල කලාප ඕෆ්සෙට් සඳහා Z හෝ + අගය වෙනුවට ආදේශ කිරීමෙන් කාල කලාප සඳහා සහය දක්වයි:

"2014-02-01T09: 28: 56.321-10: 00"

අයිඑස්ඕ 8601 පිරිවිතරයේ කාල කලාප කේතන ක්‍රමයේ වෙනත් වෙනස්කම් තිබේ, නමුත් -10: 00 ආකෘතිය වර්තමාන JSON විග්‍රහ කරන්නන් සහාය දක්වන එකම TZ ආකෘතියයි. පොදුවේ ගත් කල, දිනය නිපදවූ කාල කලාපය සොයා ගැනීමට ඔබට නිශ්චිත අවශ්‍යතාවයක් නොමැති නම් (සේවාදායක පාර්ශව උත්පාදනය සඳහා පමණක්) UTC පදනම් කරගත් ආකෘතිය (Z) භාවිතා කිරීම වඩාත් සුදුසුය.

සැ.යු: var date = නව දිනය (); console.log (දිනය); // බදාදා ජනවාරි 01, 13:28:56 GMT- 1000 (හවායි සම්මත වේලාව)

var json = JSON.stringify(date);
console.log(json);  // "2014-01-01T23:28:56.782Z"

ජාවාස්ක්‍රිප්ට් සඳහා සම්මත ආකෘතියක් නොතිබුණද එය වඩාත් කැමති ක්‍රමය බව ඔබට පැවසීමට

// JSON encoded date
var json = "\"2014-01-01T23:28:56.782Z\"";

var dateStr = JSON.parse(json);  
console.log(dateStr); // 2014-01-01T23:28:56.782Z

ඔබ කොට්ලින් භාවිතා කරන්නේ නම් මෙය ඔබගේ ගැටළුව විසඳනු ඇත. (MS Json ආකෘතිය)

val dataString = "/Date(1586583441106)/"
val date = Date(Long.parseLong(dataString.substring(6, dataString.length - 2)))

එය විග්‍රහ සේවාදායකය සමඟ මට වැඩකි

{
    "ContractID": "203-17-DC0101-00003-10011",
    "Supplier":"Sample Co., Ltd",
    "Value":12345.80,
    "Curency":"USD",
    "StartDate": {
                "__type": "Date",
                "iso": "2017-08-22T06:11:00.000Z"
            }
}

මේ සඳහා ඇත්තේ එකම නිවැරදි පිළිතුරක් වන අතර බොහෝ පද්ධති එය වැරදියට වටහා ගනී. යුගයේ සිට මිලි තත්පර ගණන, බිට් 64 ක පූර්ණ සංඛ්‍යාවක්. කාල කලාපය UI සැලකිලිමත් වන අතර යෙදුම් ස්ථරයේ හෝ db ස්තරයේ ව්‍යාපාරයක් නොමැත. ඔබේ ඩීබී කාල කලාපයේ යමක් ගැන සැලකිලිමත් වන්නේ ඇයි, එය එය බිට් 64 නිඛිලයක් ලෙස ගබඩා කිරීමට යන බව ඔබ දන්නා විට පරිණාමන ගණනය කිරීම් කරන්න.

බාහිර බිටු ඉවත් කර දිනයන් UI දක්වා අංක ලෙස සලකන්න. විමසීම් සහ තර්කනයන් කිරීමට ඔබට සරල ගණිත ක්‍රියාකරුවන් භාවිතා කළ හැකිය.

පහත කේතය මා වෙනුවෙන් වැඩ කර ඇත. මෙම කේතය DD-MM-YYYY ආකෘතියෙන් දිනය මුද්‍රණය කරනු ඇත .

DateValue=DateValue.substring(6,8)+"-"+DateValue.substring(4,6)+"-"+DateValue.substring(0,4);

වෙනත්, ඔබට ද භාවිතා කළ හැකිය:

DateValue=DateValue.substring(0,4)+"-"+DateValue.substring(4,6)+"-"+DateValue.substring(6,8);

මම හිතන්නේ එය ඇත්ත වශයෙන්ම භාවිතා කිරීමේ අවස්ථාව මත රඳා පවතී. බොහෝ අවස්ථාවන්හීදී නිසි වස්තු ආකෘතියක් භාවිතා කිරීම වඩා ප්‍රයෝජනවත් විය හැකිය (දිනය නූලකට විදැහුම් කිරීම වෙනුවට), වැනි:

{
"person" :
      {
 "name" : {
   "first": "Tom",
   "middle": "M",
  ...
}
 "dob" :  {
         "year": 2012,
         "month": 4,
         "day": 23,
         "hour": 18,
         "minute": 25,
         "second": 43,
         "timeZone": "America/New_York"
    }   
   }
}

මෙය RFC 3339 ට වඩා වාචික බව පිළිගත යුතුය.

• එය මිනිසුන්ට කියවිය හැකි ය
• එය නිසි වස්තු ආකෘතියක් ක්‍රියාත්මක කරයි (OOP හි මෙන්, JSON එයට අවසර දෙන තාක් දුරට)
• එය කාල කලාප සඳහා සහය දක්වයි (ලබා දී ඇති දිනය හා වේලාව අනුව UTC ඕෆ්සෙට් පමණක් නොවේ)
• එයට මිලි තත්පර, නැනෝ තත්පර, ... හෝ හුදෙක් භාගික තත්පර වැනි කුඩා ඒකක සඳහා සහාය විය හැකිය
• එයට වෙනම විග්‍රහ කිරීමේ පියවරක් අවශ්‍ය නොවේ (දිනය-කාල නූල විග්‍රහ කිරීමට), JSON විග්‍රහකය ඔබ වෙනුවෙන් සෑම දෙයක්ම කරනු ඇත
• ඕනෑම දිනයක රාමුවක් හෝ ඕනෑම භාෂාවක ක්‍රියාත්මක කිරීම සමඟ පහසුවෙන් නිර්මාණය කිරීම
• වෙනත් දින දර්ශන පරිමාණයන් (හෙබ්‍රෙව්, චීන, ඉස්ලාමීය ...) සහ යුගයන් (ක්‍රි.ව., ක්‍රි.පූ, ...) සඳහා පහසුවෙන් විස්තාරණය කළ හැකිය.
• එය වසර 10000 ආරක්ෂිතයි ;-) (RFC 3339 නොවේ)
• දවස පුරා දිනයන් සහ පාවෙන වේලාවන් සඳහා සහය දක්වයි (ජාවාස්ක්‍රිප්ට් Date.toJSON()නැත)

නිවැරදි වර්ග කිරීම (RFC 3339 සඳහා funroll විසින් සටහන් කර ඇති පරිදි) JSON වෙත දිනයක් අනුක්‍රමික කිරීමේදී සැබවින්ම අවශ්‍ය වන අංගයක් යැයි මම නොසිතමි. එසේම එය සත්‍ය වන්නේ එකම කාල කලාප ඕෆ්සෙට් ඇති දින වකවානු සඳහා පමණි.