මම මගේ පළමු ඉරිතැලීම අජැක්ස් හි jQuery සමඟ රැගෙන යන්නෙමි . මම මගේ දත්ත මගේ පිටුවට ඇතුළත් කරමි, නමුත් දිනය දත්ත වර්ග සඳහා ආපසු ලබා දෙන JSON දත්ත සමඟ මට යම් ගැටළුවක් ඇත. මූලික වශයෙන්, මම මේ ආකාරයට පෙනෙන නූලක් ආපසු ලබා ගනිමි:

/Date(1224043200000)/

මුළුමනින්ම අළුත් කෙනෙකුගේ සිට JSON දක්වා - මම මෙය කෙටි දින ආකෘතියකට සංයුති කරන්නේ කෙසේද? මෙය jQuery කේතයේ කොතැනක හෝ හැසිරවිය යුතුද? කිසිදු සාර්ථකත්වයක් නොමැතිව මම jQuery.UI.datepickerප්ලගිනය භාවිතා කර අත්හදා බැලුවෙමි $.datepicker.formatDate().

FYI: මෙන්න මම ඉදිරිපත් කළ විසඳුම මෙහි පිළිතුරු සංයෝජනයක් භාවිතා කරමින්:

function getMismatch(id) {
  $.getJSON("Main.aspx?Callback=GetMismatch",
    { MismatchId: id },

    function (result) {
      $("#AuthMerchId").text(result.AuthorizationMerchantId);
      $("#SttlMerchId").text(result.SettlementMerchantId);
      $("#CreateDate").text(formatJSONDate(Date(result.AppendDts)));
      $("#ExpireDate").text(formatJSONDate(Date(result.ExpiresDts)));
      $("#LastUpdate").text(formatJSONDate(Date(result.LastUpdateDts)));
      $("#LastUpdatedBy").text(result.LastUpdateNt);
      $("#ProcessIn").text(result.ProcessIn);
    }
  );

  return false;
}

function formatJSONDate(jsonDate) {
  var newDate = dateFormat(jsonDate, "mm/dd/yyyy");
  return newDate;
}

මෙම විසඳුම මගේ වස්තුව ඇමතුම් ලබා ගැනීමේ ක්‍රමයෙන් ලබා ගත් අතර දිනය ආකෘති පුස්තකාලය භාවිතයෙන් පිටුවේ දිනයන් නිසි ලෙස ප්‍රදර්ශනය කළේය.

eval()අවශ්‍ය නොවේ. මෙය හොඳින් ක්‍රියාත්මක වනු ඇත:

var date = new Date(parseInt(jsonDate.substr(6)));

මෙම substr()උත්සවය සිදු ගනී /Date(කොටසක්, සහ parseInt()කාර්යය වන පූර්ණ සංඛ්යාව ලැබෙන හා නොතකා )/අවසානයේ. එහි ප්‍රති number ලයක් ලෙස අංකය Dateඉදිකිරීම්කරු වෙත ලබා දේ.

මම හිතාමතාම රේඩික්ස් අතහැර දමා ඇත (2 වන තර්කය සිට parseInt); බලන්න පහත මගේ අදහස් .

එසේම, රෝරිගේ ප්‍රකාශය සමඟ මම සම්පුර්ණයෙන්ම එකඟ වෙමි : මෙම පැරණි ආකෘතියට වඩා ISO-8601 දිනයන් වඩාත් කැමති වේ - එබැවින් මෙම ආකෘතිය සාමාන්‍යයෙන් නව සංවර්ධනය සඳහා භාවිතා නොකළ යුතුය. ISO-8601 ආකෘතිය භාවිතා කරමින් දිනයන් අනුක්‍රමික කරන විශිෂ්ට විකල්පයක් සඳහා විශිෂ්ට Json.NET පුස්තකාලය බලන්න .

ISO-8601 ආකෘතිගත කළ JSON දිනයන් සඳහා, නූල Dateඉදිකිරීම්කරු වෙත යොමු කරන්න :

var date = new Date(jsonDate); //no ugly parsing needed; full timezone support

JSON වෙතින් දිනයක් ලබා ගැනීමට ඔබට මෙය භාවිතා කළ හැකිය:

var date = eval(jsonDate.replace(/\/Date\((\d+)\)\//gi, "new Date($1)"));

ඔබට අවශ්‍ය පරිදි එය ප්‍රදර්ශනය කිරීම සඳහා ඔබට ජාවාස්ක්‍රිප්ට් ඩේට් ෆෝමැට් ස්ක්‍රිප්ට් එකක් (අවම කර gzip කළ විට 1.2 KB) භාවිතා කළ හැකිය.

නිව්ටන්සොෆ්ට් Json.NET භාවිතා කරන්නන් සඳහා , IE8, ෆයර්ෆොක්ස් 3.5 සහ Json.NET හි ස්වදේශීය JSON හරහා එය කරන්නේ කෙසේද යන්න කියවන්න .

Json.NET විසින් ලියන ලද දිනයන්හි ආකෘතිය වෙනස් කිරීම පිළිබඳ ලියකියවිලි ද ප්‍රයෝජනවත් වේ: Json.NET සමඟ දින අනුක්‍රමික කිරීම

කම්මැලි අයට, මෙන්න ඉක්මන් පියවර. JSON හි ලිහිල් ඩේටයිම් ක්‍රියාත්මක කිරීමක් ඇති බැවින්, ඔබ එය භාවිතා කළ IsoDateTimeConverter()යුතුය. Json.NET 4.5 සිට පෙරනිමි දිනය ආකෘතිය ISO බැවින් පහත කේතය අවශ්‍ය නොවන බව සලකන්න.

string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());

JSON ලෙස පැමිණෙනු ඇත

"fieldName": "2009-04-12T20:44:55"

අවසාන වශයෙන්, අයිඑස්ඕ දිනය ජාවාස්ක්‍රිප්ට් දිනයක් බවට පරිවර්තනය කිරීම සඳහා සමහර ජාවාස්ක්‍රිප්ට්:

function isoDateReviver(value) {
  if (typeof value === 'string') {
    var a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)(?:([\+-])(\d{2})\:(\d{2}))?Z?$/.exec(value);
      if (a) {
        var utcMilliseconds = Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6]);
        return new Date(utcMilliseconds);
      }
  }
  return value;
}

මම මේ වගේ පාවිච්චි කළා

$("<span />").text(isoDateReviver(item.fieldName).toLocaleString()).appendTo("#" + divName);

මුල් උදාහරණය:

/Date(1224043200000)/  

ගොඩනඟන ලද JSON අනුක්‍රමිකකරණය භාවිතා කරමින් WCF REST හරහා දින යැවීමේදී WCF භාවිතා කරන ආකෘතිකරණය පිළිබිඹු නොවේ. (අවම වශයෙන් .NET 3.5, SP1 මත)

මෙහි පිළිතුර මට ප්‍රයෝජනවත් බව මට පෙනී ගියේය, නමුත් රීජෙක්ස් වෙත සුළු සංස්කරණයක් අවශ්‍ය වේ, මන්දයත්, කාල කලාපයේ GMT ඕෆ්සෙට් WCF JSON හි ආපසු ලබා දුන් අංකයට (1970 සිට) එකතු කරන බව පෙනේ.

WCF සේවාවක මා සතුව ඇත්තේ:

[OperationContract]
[WebInvoke(
    RequestFormat = WebMessageFormat.Json,
    ResponseFormat = WebMessageFormat.Json,
    BodyStyle = WebMessageBodyStyle.WrappedRequest
    )]
ApptVisitLinkInfo GetCurrentLinkInfo( int appointmentsId );

ApptVisitLinkInfo සරලව අර්ථ දක්වා ඇත:

public class ApptVisitLinkInfo {
    string Field1 { get; set; }
    DateTime Field2 { get; set; }
    ...
}

සේවයෙන් "ෆීල්ඩ් 2" ජේසන් ලෙස ආපසු ලබා දුන් විට වටිනාකම:

/Date(1224043200000-0600)/

වටිනාකමේ කොටසක් ලෙස ඇතුළත් කර ඇති කාල කලාප ඕෆ්සෙට් සැලකිල්ලට ගන්න.

වෙනස් කළ රීජෙක්ස්:

/\/Date\((.*?)\)\//gi

එය මදක් වැඩි උනන්දුවක් දක්වන අතර පළමු අංකය පමණක් නොව පරෙන්ස් අතර ඇති සියල්ල අල්ලා ගනී. එහි ප්‍රති ing ලයක් ලෙස 1970 සින්ස්, සහ කාල කලාප ඕෆ්සෙට් සියල්ල දින වස්තුවක් ලබා ගැනීම සඳහා එවාල් වෙත පෝෂණය කළ හැකිය.

ප්‍රතිස්ථාපනය සඳහා වන ජාවාස්ක්‍රිප්ට් රේඛාව:

replace(/\/Date\((.*?)\)\//gi, "new Date($1)");

ඔබම පුනරාවර්තනය නොකරන්න - දිනය පරිවර්තනය භාවිතා කරමින් ස්වයංක්‍රීය කරන්න $.parseJSON()

ඔබගේ ලිපියට පිළිතුරු ජාවාස්ක්‍රිප්ට් දිනයන් සඳහා අතින් දිනය පරිවර්තනය කරයි. මම jQuery $.parseJSON()ටිකක් විස්තාරණය කර ඇත , එබැවින් ඔබ එය උපදෙස් දෙන විට ස්වයංක්‍රීයව දිනයන් විග්‍රහ කළ හැකිය. එය ASP.NET ආකෘතිගත කරන ලද දිනයන් ( /Date(12348721342)/) මෙන්ම ISO ආකෘතිගත කළ දිනයන් ( 2010-01-01T12.34.56.789Z) ක්‍රියාවට නංවයි, ඒවා බ්‍රව්සර්වල (සහ json2.js වැනි පුස්තකාල) ස්වදේශීය JSON ක්‍රියාකාරකම් මගින් සහාය වේ.

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

ඔබ ජාවාස්ක්‍රිප්ට් වලින් කියනවා නම්,

var thedate = new Date(1224043200000);
alert(thedate);

එය නිවැරදි දිනය බව ඔබට පෙනෙනු ඇති අතර ඔබට ඕනෑම රාමුවක් සමඟ ජාවාස්ක්‍රිප්ට් කේතයේ ඕනෑම තැනක එය භාවිතා කළ හැකිය.

නිරූපණය පරීක්ෂා කිරීම සඳහා මෙහි ක්ලික් කරන්න

JavaScript / jQuery

var = MyDate_String_Value = "/Date(1224043200000)/"
var value = new Date
            (
                 parseInt(MyDate_String_Value.replace(/(^.*\()|([+-].*$)/g, ''))
            );
var dat = value.getMonth() +
                         1 +
                       "/" +
           value.getDate() +
                       "/" +
       value.getFullYear();

ප්‍රති ult ලය - "10/15/2008"

යාවත්කාලීන කරන ලදි

අපි දෙන්නම මයික්රොසොෆ්ට් සමාගමේ ASP.NET බිල්ට් JSON ආකෘතිය, වැනි සමඟ කටයුතු කිරීමට ඇති බව අභ්යන්තර UI පුස්තකාලය ඇති /Date(msecs)/, මුලින් ගැන මෙහි ඉල්ලා, සහ JSON.NET ගේ, වැනි ඇතුළු බොහෝ JSON ගේ දිනය දක්වන 2014-06-22T00:00:00.0. මීට අමතරව දශමස්ථාන 3 ක් හැර වෙනත් කිසිවක් සමඟ කටයුතු කිරීමට පැරණි අයිඊයට ඇති නොහැකියාව සමඟ අප කටයුතු කළ යුතුය .

අපි කුමන ආකාරයේ දිනයක් පරිභෝජනය කරනවාදැයි අපි මුලින්ම හඳුනාගෙන, එය සාමාන්‍ය ජාවාස්ක්‍රිප්ට් Dateවස්තුවකට විග්‍රහ කර , පසුව එය සංයුති කරන්නෙමු.

1) මයික්‍රොසොෆ්ට් දිනය ආකෘතිය හඳුනා ගන්න

// Handling of Microsoft AJAX Dates, formatted like '/Date(01238329348239)/'
function looksLikeMSDate(s) {
    return /^\/Date\(/.test(s);
}

2) ISO දිනය ආකෘතිය හඳුනා ගන්න

var isoDateRegex = /^(\d\d\d\d)-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(\.\d\d?\d?)?([\+-]\d\d:\d\d|Z)?$/;

function looksLikeIsoDate(s) {
    return isoDateRegex.test(s);
}

3) MS දිනය ආකෘතිය විග්‍රහ කරන්න:

function parseMSDate(s) {
    // Jump forward past the /Date(, parseInt handles the rest
    return new Date(parseInt(s.substr(6)));
}

4) අයිඑස්ඕ දිනය ආකෘතිය විග්‍රහ කරන්න.

සෑම විටම මිලි තත්පර තුනක් ඇති වන පරිදි වෙනස් කරන ලද සම්මත අයිඑස්ඕ දිනයන් හෝ අයිඑස්ඕ දිනයන් සමඟ අප කටයුතු කරන බවට සහතික වීමට අපට අවම වශයෙන් ක්‍රමයක් තිබේ ( ඉහත බලන්න ), එබැවින් කේතය පරිසරය අනුව වෙනස් වේ.

4a) සම්මත ISO දිනය ආකෘතිය විග්‍රහ කරන්න, පැරණි ගැටළු සමඟ සාර්ථකව කටයුතු කරන්න:

function parseIsoDate(s) {
    var m = isoDateRegex.exec(s);

    // Is this UTC, offset, or undefined? Treat undefined as UTC.
    if (m.length == 7 ||                // Just the y-m-dTh:m:s, no ms, no tz offset - assume UTC
        (m.length > 7 && (
            !m[7] ||                    // Array came back length 9 with undefined for 7 and 8
            m[7].charAt(0) != '.' ||    // ms portion, no tz offset, or no ms portion, Z
            !m[8] ||                    // ms portion, no tz offset
            m[8] == 'Z'))) {            // ms portion and Z
        // JavaScript's weirdo date handling expects just the months to be 0-based, as in 0-11, not 1-12 - the rest are as you expect in dates.
        var d = new Date(Date.UTC(m[1], m[2]-1, m[3], m[4], m[5], m[6]));
    } else {
        // local
        var d = new Date(m[1], m[2]-1, m[3], m[4], m[5], m[6]);
    }

    return d;
}

4b) ස්ථාවර මිලි තත්පර තුනක දශම ස්ථාන සහිත අයිඑස්ඕ ආකෘතිය විග්‍රහ කරන්න - වඩා පහසු:

function parseIsoDate(s) {
    return new Date(s);
}

5) එය සංයුති කරන්න:

function hasTime(d) {
    return !!(d.getUTCHours() || d.getUTCMinutes() || d.getUTCSeconds());
}

function zeroFill(n) {
    if ((n + '').length == 1)
        return '0' + n;

    return n;
}

function formatDate(d) {
    if (hasTime(d)) {
        var s = (d.getMonth() + 1) + '/' + d.getDate() + '/' + d.getFullYear();
        s += ' ' + d.getHours() + ':' + zeroFill(d.getMinutes()) + ':' + zeroFill(d.getSeconds());
    } else {
        var s = (d.getMonth() + 1) + '/' + d.getDate() + '/' + d.getFullYear();
    }

    return s;
}

6) ඒ සියල්ල එකට බැඳ තබන්න:

function parseDate(s) {
    var d;
    if (looksLikeMSDate(s))
        d = parseMSDate(s);
    else if (looksLikeIsoDate(s))
        d = parseIsoDate(s);
    else
        return null;

    return formatDate(d);
}

මෙම දිනය හැඩතල ගැන්වීම jQuery හි JSON විග්‍රහයට සම්බන්ධ කිරීම සඳහා පහත පැරණි පිළිතුර ප්‍රයෝජනවත් වේ, එවිට ඔබට නූල් වෙනුවට දිනය වස්තු ලැබෙනු ඇත, නැතහොත් ඔබ තවමත් jQuery <1.5 හි කෙසේ හෝ සිරවී සිටී නම්.

පැරණි පිළිතුර

ඔබ ASP.NET MVC සමඟ jQuery 1.4 හි Ajax ශ්‍රිතය භාවිතා කරන්නේ නම්, ඔබට සියලු ඩේටයිම් ගුණාංග දිනය වස්තු බවට පරිවර්තනය කළ හැකිය:

// Once
jQuery.parseJSON = function(d) {return eval('(' + d + ')');};

$.ajax({
    ...
    dataFilter: function(d) {
        return d.replace(/"\\\/(Date\(-?\d+\))\\\/"/g, 'new $1');
    },
    ...
});

JQuery 1.5 හි ඔබට parseJSONඅජැක්ස් ඇමතුමේ ඇති පරිවර්තක විකල්පය භාවිතා කිරීමෙන් ගෝලීය වශයෙන් මෙම ක්‍රමය ඉක්මවා යාම වළක්වා ගත හැකිය .

http://api.jquery.com/jQuery.ajax/

අවාසනාවට, දින වකවානු ගෝලීයව විග්‍රහ කිරීම සඳහා ඔබට පැරණි එවාල් මාර්ගයට මාරුවිය යුතුය - එසේ නොමැතිනම් ඒවා පසු විග්‍රහයෙන් වඩාත් සිද්ධි ආකාරයෙන් පරිවර්තනය කළ යුතුය.

JSON හි ඉදිකරන ලද දින වර්ගයක් නොමැත . මෙය යම් යුගයක තත්පර / මිලි තත්පර ගණන මෙන් පෙනේ. ඔබ යුගය දන්නේ නම් නියම වේලාව එකතු කිරීමෙන් දිනය නිර්මාණය කළ හැකිය.

මටද මෙම ගැටලුවට විසඳුමක් සෙවීමට සිදු වූ අතර අවසානයේදී මට moment.js හමුවිය. එය මෙම දිනය ආකෘතිය සහ තවත් බොහෝ දේ විග්‍රහ කළ හැකි හොඳ පුස්තකාලයකි.

var d = moment(yourdatestring)

එය මට යම් හිසරදයක් ඉතිරි කර ඇති නිසා මම එය ඔබ සමඟ බෙදා ගනු ඇතැයි සිතුවෙමි. :)
ඔබට ඒ පිළිබඳ තවත් තොරතුරු මෙතැනින් සොයාගත හැකිය: http://momentjs.com/

මයික්‍රොසොෆ්ට් අනුක්‍රමිකකරණය මඟින් ජනනය කරන ලද ඒවා ඉවත් කිරීම සඳහා පැනෝස් හි නිත්‍ය ප්‍රකාශනයට අක්ෂර එකතු කිරීම මම අවසන් කළෙමි.

එබැවින් ඔබේ C # කේතයේ පිටුපස දේපලක් තිබේ නම් එය සමාන ය

protected string JsonObject { get { return jsSerialiser.Serialize(_myObject); }}

ඔබේ ඇස්පෙක්ස් තුළ ඔබ සතුව ඇත

<script type="text/javascript">
    var myObject = '<%= JsonObject %>';
</script>

ඔබට එවැනි දෙයක් ලැබෙනු ඇත

var myObject = '{"StartDate":"\/Date(1255131630400)\/"}';

ද්විත්ව උපුටා දැක්වීම් සැලකිල්ලට ගන්න.

එවාල් නිවැරදිව ආශා කරන ආකාරයකට මෙය ලබා ගැනීම සඳහා, මම භාවිතා කළේ:

myObject = myObject.replace(/"\/Date\((\d+)\)\/"/g, 'new Date($1)');

මම මූලාකෘති භාවිතා කරන අතර මා එකතු කළ එය භාවිතා කිරීමට

String.prototype.evalJSONWithDates = function() {
    var jsonWithDates = this.replace(/"\/Date\((\d+)\)\/"/g, 'new Date($1)');
    return jsonWithDates.evalJSON(true);
}

JQuery 1.5 හි, පැරණි බ්‍රව්සර් සඳහා ආවරණය කිරීමට ඔබට json2.js ඇති තාක් කල් , ඔබට අජැක්ස් වෙතින් එන සියලුම දිනයන් පහත පරිදි අභිමතකරණය කළ හැකිය:

(function () {
    var DATE_START = "/Date(";
    var DATE_START_LENGTH = DATE_START.length;

    function isDateString(x) {
        return typeof x === "string" && x.startsWith(DATE_START);
    }

    function deserializeDateString(dateString) {
        var dateOffsetByLocalTime = new Date(parseInt(dateString.substr(DATE_START_LENGTH)));
        var utcDate = new Date(dateOffsetByLocalTime.getTime() - dateOffsetByLocalTime.getTimezoneOffset() * 60 * 1000);
        return utcDate;
    }

    function convertJSONDates(key, value) {
      if (isDateString(value)) {
        return deserializeDateString(value);
      }
      return value;
    }

    window.jQuery.ajaxSetup({
      converters: {
        "text json": function(data) {
          return window.JSON.parse(data, convertJSONDates);
        }
      }
    });
}());

මම සියලු තර්කනයන් සේවාදායකයෙන් යූටීසී ලෙස යවන බව උපකල්පනය කරන තර්කනය ඇතුළත් කළෙමි (ඔබ කළ යුත්තේ එයයි); එවිට පාරිභෝගිකයාට ජාවාස්ක්‍රිප්ට් Dateවස්තුවක් ලැබෙනු ඇත . එනම්, getUTCHours()දිනය ඇමතීම යනාදිය සේවාදායකයේ ඇති අගයට සමාන අගයක් ලබා දෙන අතර ඇමතුම් getHours()මඟින් පරිශීලකයාගේ දේශීය කාල කලාපයේ අගය ඔවුන්ගේ බ්‍රව්සරය විසින් තීරණය කරනු ලැබේ.

මෙය කාල කලාප ඕෆ්සෙට් සමඟ WCF ආකෘතිය සැලකිල්ලට නොගනී , එය එකතු කිරීම සාපේක්ෂව පහසුය.

JQuery UI datepicker භාවිතා කිරීම - සැබවින්ම අර්ථවත් වන්නේ ඔබ දැනටමත් jQuery UI ඇතුළත් කර ඇත්නම් පමණි:

$.datepicker.formatDate('MM d, yy', new Date(parseInt('/Date(1224043200000)/'.substr(6)))); 

ප්‍රතිදානය:

2008 ඔක්තෝබර් 15

මෙය ඕනෑවට වඩා සිතන්න එපා. අප දශක ගණනාවක් තිස්සේ කර ඇති පරිදි, 1970 ජනවාරි 1 මධ්‍යම රාත්‍රියේ GMT / UTC / & c තථ්‍ය සම්මත යුගයේ සිට සංඛ්‍යාත්මක ඕෆ්සෙට් එකක් මෙම යුගයේ සිට තත්පර ගණනකින් (හෝ මිලි තත්පර) පසු කරන්න. ජාවාස්ක්‍රිප්ට් එයට කැමතියි, ජාවා එයට කැමතියි, සී එයට කැමතියි, සහ අන්තර්ජාලය එයට කැමතියි.

මෙම සෑම පිළිතුරකටම එක දෙයක් පොදු ය: ඒවා සියල්ලම තනි අගයක් ලෙස (සාමාන්‍යයෙන් නූලක්) ගබඩා කරයි.

තවත් විකල්පයක් නම් JSON හි ආවේනික ව්‍යුහයෙන් වාසි ලබා ගැනීම සහ අංක ලැයිස්තුවක් ලෙස දිනයක් නිරූපණය කිරීම:

{ "name":"Nick",
  "birthdate":[1968,6,9] }

ඇත්ත වශයෙන්ම, සංවාදයේ කෙළවර දෙකම ආකෘතියට (වර්ෂය, මාසය, දිනය) එකඟ වන බවට වග බලා ගත යුතු අතර, කුමන ක්ෂේත්‍රයන් දිනයන් ලෙස අදහස් කරන්නේද, ... නමුත් දිනය පිළිබඳ ගැටළුව සම්පූර්ණයෙන්ම වළක්වා ගැනීමේ වාසිය එයට ඇත. -ත-පරිවර්තනයට. ඒ සියල්ලම සංඛ්‍යා - නූල් නැත. එසේම, ඇණවුම භාවිතා කිරීම: වර්ෂය, මාසය, දිනය ද දිනය අනුව නිසි ලෙස වර්ග කිරීමට ඉඩ ලබා දේ.

මෙහි ඇති කොටුවෙන් පිටත සිතීම - JSON දිනයක් නූලක් ලෙස ගබඩා කළ යුතු නොවේ.

මේ ආකාරයට එය කළ හැකි තවත් ප්‍රසාද දීමනාවක් නම්, අරච් අගයන් පිළිබඳ විමසීම් CouchDB හසුරුවන ආකාරය උත්තේජනය කිරීමෙන් ඔබට යම් වසරක් හෝ මාසයක් සඳහා සියලු වාර්තා පහසුවෙන් (හා කාර්යක්ෂමව) තෝරා ගත හැකිය .

නියමයි ත්‍රෙඩ් එකේ පළ කිරීම:

var d = new Date(parseInt('/Date(1224043200000)/'.slice(6, -2)));
alert('' + (1 + d.getMonth()) + '/' + d.getDate() + '/' + d.getFullYear().toString().slice(-2));

මෙහි තවත් ප්‍රවේශයක් එක් කිරීම සඳහා, WCF විසින් ගනු ලබන “කිනිතුල්ලන්ගේ ප්‍රවේශය” ඔබ මෙහි සහ වෙනත් ස්ථානවල විස්තර කර ඇති ආකාරයට අතිශයින්ම පරෙස්සම් නොවන්නේ නම් කාල කලාප සමඟ ගැටලු ඇති වේ. ඒ නිසා මම දැන් භාවිතා කරන්නේ අයිඑස්ඕ 8601 ආකෘතියයි .නෙට් සහ ජාවාස්ක්‍රිප්ට් යන දෙකම නිසි පරිදි සහාය වන කාල කලාප ඕෆ්සෙට් ඇතුළත් වේ. විස්තර පහත දැක්වේ:

WCF / .NET හි:

CreationDate යනු System.DateTime; ToString ("o") භාවිතා කරන්නේ .NET හි වට-චාරිකා ආකෘති පිරිවිතරයක් වන අතර එය ISO 8601 අනුකූල දින තීරුවක් ජනනය කරයි

new MyInfo {
    CreationDate = r.CreationDate.ToString("o"),
};

JavaScript හි

JSON ලබා ගැනීමෙන් පසු මම ජාවාස්ක්‍රිප්ට් දිනය වස්තූන් බවට පත් කර ISO 8601 දින නූලක් පිළිගන්නා දිනය ඉදිකිරීම්කරු භාවිතා කරමි ...

$.getJSON(
    "MyRestService.svc/myinfo",
    function (data) {
        $.each(data.myinfos, function (r) {
            this.CreatedOn = new Date(this.CreationDate);
        });
        // Now each myinfo object in the myinfos collection has a CreatedOn field that is a real JavaScript date (with timezone intact).
       alert(data.myinfos[0].CreationDate.toLocaleString());
    }
)

ඔබට ජාවාස්ක්‍රිප්ට් දිනයක් ලැබුණු පසු ඔබට ඩේට්ස්ට්‍රිං , ටු ලොකේල්ස්ට්‍රිං වැනි පහසු සහ විශ්වාසදායක දින ක්‍රම භාවිතා කළ හැකිය .

var newDate = dateFormat(jsonDate, "mm/dd/yyyy"); 

JQuery පුස්තකාලය භාවිතා නොකර වෙනත් විකල්පයක් තිබේද?

මෙය ඔබට උදව් විය හැකිය.

 function ToJavaScriptDate(value) { //To Parse Date from the Returned Parsed Date
        var pattern = /Date\(([^)]+)\)/;
        var results = pattern.exec(value);
        var dt = new Date(parseFloat(results[1]));
        return (dt.getMonth() + 1) + "/" + dt.getDate() + "/" + dt.getFullYear();
    }

පහත දැක්වෙන්නේ JSON දිනයන් විග්‍රහ කිරීම සඳහා ඉතා සරල විසඳුමකි. ඔබගේ අවශ්‍යතාවය අනුව පහත කාර්යයන් භාවිතා කරන්න. පහත දැක්වෙන කාර්යයන් සඳහා පරාමිතියක් ලෙස ලබාගත් දිනය ඔබ JSON ආකෘතිය පසු කළ යුතුය:

function JSONDate(dateStr) {
    var m, day;
    jsonDate = dateStr;
    var d = new Date(parseInt(jsonDate.substr(6)));
    m = d.getMonth() + 1;
    if (m < 10)
        m = '0' + m
    if (d.getDate() < 10)
        day = '0' + d.getDate()
    else
        day = d.getDate();
    return (m + '/' + day + '/' + d.getFullYear())
}

function JSONDateWithTime(dateStr) {
    jsonDate = dateStr;
    var d = new Date(parseInt(jsonDate.substr(6)));
    var m, day;
    m = d.getMonth() + 1;
    if (m < 10)
        m = '0' + m
    if (d.getDate() < 10)
        day = '0' + d.getDate()
    else
        day = d.getDate();
    var formattedDate = m + "/" + day + "/" + d.getFullYear();
    var hours = (d.getHours() < 10) ? "0" + d.getHours() : d.getHours();
    var minutes = (d.getMinutes() < 10) ? "0" + d.getMinutes() : d.getMinutes();
    var formattedTime = hours + ":" + minutes + ":" + d.getSeconds();
    formattedDate = formattedDate + " " + formattedTime;
    return formattedDate;
}

ඔබට ජාවාස්ක්‍රිප්ට් පුස්තකාලය moment.js භාවිතා කළ හැකිය, ඔබ විවිධ දේශීයකරණය කළ ආකෘතීන් සමඟ ගනුදෙනු කිරීමට සහ දින අගයන් සමඟ වෙනත් මෙහෙයුම් සිදු කිරීමට සැලසුම් කරන විට එය ප්‍රයෝජනවත් වේ:

function getMismatch(id) {
    $.getJSON("Main.aspx?Callback=GetMismatch",
    { MismatchId: id },

    function (result) {
        $("#AuthMerchId").text(result.AuthorizationMerchantId);
        $("#SttlMerchId").text(result.SettlementMerchantId);
        $("#CreateDate").text(moment(result.AppendDts).format("L"));
        $("#ExpireDate").text(moment(result.ExpiresDts).format("L"));
        $("#LastUpdate").text(moment(result.LastUpdateDts).format("L"));
        $("#LastUpdatedBy").text(result.LastUpdateNt);
        $("#ProcessIn").text(result.ProcessIn);
    }
    );
    return false;
}

ප්‍රාදේශීයකරණය සැකසීම ඔබේ ව්‍යාපෘතියට වින්‍යාස ගොනු එකතු කිරීම (ඔබ ඒවා momentjs.com වෙතින් ලබා ගනී) සහ භාෂාව වින්‍යාස කිරීම තරම් පහසු ය:

moment.lang('de');

මට මේ වගේ දිනය ලැබෙනවා:

"/Date(1276290000000+0300)/"

සමහර උදාහරණ වල දිනය තරමක් වෙනස් ආකෘති වලින් යුක්ත වේ:

"/Date(12762900000000300)/"
"Date(1276290000000-0300)"

ආදිය.

එබැවින් මම පහත දැක්වෙන RegExp සමඟ පැමිණියෙමි:

/\/+Date\(([\d+]+)\)\/+/

අවසාන කේතය:

var myDate = new Date(parseInt(jsonWcfDate.replace(/\/+Date\(([\d+-]+)\)\/+/, '$1')));

එය උපකාරී වේ යැයි සිතමි.

යාවත්කාලීන කිරීම: මයික්‍රොසොෆ්ට් වෙතින් මෙම සබැඳිය මට හමු විය: JSON සමඟ දින අනුක්‍රමික කරන්නේ කෙසේද?

මෙය අප සියල්ලන්ම සොයන එක මෙන් පෙනේ.

දිනය ISO ප්‍රමිතිය පරීක්ෂා කරන්න; මේ වගේ:

yyyy.MM.ddThh:mm

එය බවට පත්වේ 2008.11.20T22:18.

මෙය කලකිරීමට කරුණකි. මගේ විසඳුම වූයේ ASP.NET හි JavaScriptSerializer විසින් ජනනය කරන ලද අගයෙන් "/ සහ /" විග්‍රහ කිරීමයි, එවිට JSON හට වචනානුසාරයෙන් දිනයක් නොතිබුණද, එය තවමත් බ්‍රව්සරය දිනයක් ලෙස අර්ථකථනය කරනු ලැබේ. අවශ්‍යයි:{"myDate":Date(123456789)}

DateTime සඳහා අභිරුචි JavaScriptConverter?

රෝයි ටින්කර්ගේ ප්‍රකාශයේ නිරවද්‍යතාවය මා අවධාරණය කළ යුතුය. මෙය නීත්‍යානුකූල JSON නොවේ. ජාවාස්ක්‍රිප්ට් සඳහා ගැටලුවක් බවට පත්වීමට පෙර එය ඉවත් කිරීම සේවාදායකයේ අපිරිසිදු, අපිරිසිදු හැක් කිරීමකි. එය JSON විග්‍රහකයකු යටපත් කරනු ඇත. මම එය බිමෙන් බැසීමට භාවිතා කළ නමුත් මම මෙය තවදුරටත් භාවිතා නොකරමි. කෙසේ වෙතත්, හොඳම පිළිතුර වන්නේ සේවාදායකයා දිනය සංයුති කරන ආකාරය වෙනස් කිරීම බව මට තවමත් දැනේ, උදාහරණයක් ලෙස, වෙනත් තැනක සඳහන් කර ඇති පරිදි ISO.

ප්‍රමාද වූ පෝස්ට් එකක්, නමුත් මෙම ලිපිය සෙවූ අයට.

මෙය සිතා බලන්න:

    [Authorize(Roles = "Administrator")]
    [Authorize(Roles = "Director")]
    [Authorize(Roles = "Human Resources")]
    [HttpGet]
    public ActionResult GetUserData(string UserIdGuidKey)
    {
        if (UserIdGuidKey!= null)
        {
            var guidUserId = new Guid(UserIdGuidKey);
            var memuser = Membership.GetUser(guidUserId);
            var profileuser = Profile.GetUserProfile(memuser.UserName);
            var list = new {
                              UserName = memuser.UserName,
                              Email = memuser.Email ,
                              IsApproved = memuser.IsApproved.ToString() ,
                              IsLockedOut = memuser.IsLockedOut.ToString() ,
                              LastLockoutDate = memuser.LastLockoutDate.ToString() ,
                              CreationDate = memuser.CreationDate.ToString() ,
                              LastLoginDate = memuser.LastLoginDate.ToString() ,
                              LastActivityDate = memuser.LastActivityDate.ToString() ,
                              LastPasswordChangedDate = memuser.LastPasswordChangedDate.ToString() ,
                              IsOnline = memuser.IsOnline.ToString() ,
                              FirstName = profileuser.FirstName ,
                              LastName = profileuser.LastName ,
                              NickName = profileuser.NickName ,
                              BirthDate = profileuser.BirthDate.ToString() ,
            };
            return Json(list, JsonRequestBehavior.AllowGet);
        }
        return Redirect("Index");
    }

ඔබට පෙනෙන පරිදි, මම "ස්වයංක්‍රීය" ජනක විද්‍යාව නිර්මාණය කිරීම සඳහා C # 3.0 හි විශේෂාංගය භාවිතා කරමි. එය ටිකක් කම්මැලි, නමුත් මම එයට කැමතියි එය ක්‍රියාත්මක වේ. සටහනක්: පැතිකඩ යනු මගේ වෙබ් යෙදුම් ව්‍යාපෘතිය සඳහා මා විසින් නිර්මාණය කරන ලද අභිරුචි පන්තියකි.

FYI, සේවාදායක පැත්තේ පයිතන් භාවිතා කරන ඕනෑම කෙනෙකුට: datetime.datetime (). Ctime () "නව දිනය ()" මගින් දේශීයව විග්‍රහ කළ හැකි නූලක් ලබා දෙයි. I.e. මම තවම කිසිදු ව්‍යතිරේකයක් සොයාගෙන නැත, නමුත් මම එය දැඩි ලෙස පරීක්ෂා කර නැත.

මූටූල්ස් විසඳුම:

new Date(Date(result.AppendDts)).format('%x')

මූටූල් අවශ්‍යයි - තවත්. ෆයර්ෆොක්ස් 3.6.3 සහ අයිඊ 7.0.5730.13 මත මූටූල්ස්-1.2.3.1-වැඩි භාවිතා කර පරීක්ෂා කර ඇත

var obj = eval('(' + "{Date: \/Date(1278903921551)\/}".replace(/\/Date\((\d+)\)\//gi, "new Date($1)") + ')');
var dateValue = obj["Date"];

මෙම එක් කරන්න jQuery UI ඔබේ පිටුවේ ප්ලගිනය:

function DateFormate(dateConvert) {
    return $.datepicker.formatDate("dd/MM/yyyy", eval('new ' + dateConvert.slice(1, -1)));
};

.නෙට් නැවත පැමිණේ නම් ...

return DateTime.Now.ToString("u"); //"2013-09-17 15:18:53Z"

ඉන්පසු ජාවාස්ක්‍රිප්ට් හි ...

var x = new Date("2013-09-17 15:18:53Z");