JSON 中没有内置的日期类型。这看起来像是某个时期的秒数/毫秒数。如果您知道纪元，则可以通过添加适当的时间量来创建日期。

如果你在 JavaScript 中说，

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

你会看到它是正确的日期，你可以在任何框架的 JavaScript 代码中使用它。

您可以使用它从 JSON 获取日期：

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

然后，您可以使用 JavaScript 日期格式脚本（缩小和压缩后为 1.2 KB）根据需要显示它。

你的JSON可能应该返回某种对象（嗯，它的字符串表示形式）。

"{ myDate : Date(1224043200000) }"

使用 jQuery，您可以通过以下方式访问您的数据对象：

$.get(
    "myJSONFile.php",
    function (data) {
        // data.myDate will be a date object.

        // to show in a short date format (eg: dd/mm/yyyy)
        alert (
            data.myDate.getDate() + "/"
            + (data.myDate.getMonth() + 1) + "/"
            + data.myDate.getFullYear()
        ); // alerts: "15/10/2008"
    }
);

检查日期ISO标准;有点像这样：

yyyy.MM.ddThh:mm

它变成了.2008.11.20T22:18

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

在不使用jQuery库的情况下还有其他选择吗？

我最终将“字符添加到 Panos 的正则表达式中，以摆脱 Microsoft 序列化程序在将对象写入内联脚本时生成的字符：

因此，如果 C# 代码隐藏中有一个属性，则类似于

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

在您的 aspx 中，您有

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

你会得到类似的东西

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

请注意双引号。

为了将其转换为 eval 将正确反序列化的形式，我使用了：

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

我使用 Prototype 并使用它，我添加了

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

一个迟到的帖子，但对于那些搜索过这篇文章的人。

想象一下：

    [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 的功能来创建“自动”泛型。这有点懒惰，但我喜欢它并且有效。 请注意：Profile 是我为 Web 应用程序项目创建的自定义类。

不要想太多。就像我们几十年来所做的那样，从1970年1月1日格林威治标准时间/UTC/&c的事实上的标准纪元（以秒数（或毫秒）为单位，从这个纪元开始传递一个数字偏移量。JavaScript 喜欢它，Java 喜欢它，C 喜欢它，互联网喜欢它。

原始示例：

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

当“Field2”作为 Json 从服务返回时，该值为：

/Date(1224043200000-0600)/

请注意，时区偏移量包含在值中。

修改后的正则表达式：

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

它稍微急切一些，抓住了帕伦之间的一切，而不仅仅是第一个数字。生成的时间 sinze 1970 加上时区偏移量都可以输入到 eval 中以获得日期对象。

替换的 JavaScript 行为：

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

对于使用 Newtonsoft Json.NET 的用户，请阅读如何在 IE8、Firefox 3.5 和 Json.NET 中通过原生 JSON 执行此操作。

此外，有关更改 Json.NET 编写的日期格式的文档也很有用：使用 Json.NET 序列化日期

对于那些太懒的人，这里有一些快速步骤。由于 JSON 具有松散的 DateTime 实现，因此您需要使用 .请注意，从 Json.NET 4.5 开始，默认日期格式为 ISO，因此不需要以下代码。IsoDateTimeConverter()

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

JSON 将作为

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

最后，一些 JavaScript 将 ISO 日期转换为 JavaScript 日期：

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

eval()没有必要。这将正常工作：

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

该函数取出部分，函数获取整数并忽略末尾的整数。生成的数字将传递到构造函数中。substr()/Date(parseInt())/Date

我故意省略了基数（第二个参数）;请参阅下面的评论。parseInt

此外，我完全同意 Rory 的评论：ISO-8601 日期比这种旧格式更受欢迎——因此这种格式通常不应用于新开发。

对于 ISO-8601 格式的 JSON 日期，只需将字符串传递到构造函数中：Date

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

Mootools解决方案：

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

需要mootools-more。在 Firefox 3.6.3 和 IE 7.0.5730.13 上使用 mootools-1.2.3.1-more 进行测试

仅供参考，对于在服务器端使用 Python 的任何人来说：datetime.datetime（）.ctime（） 返回一个字符串，该字符串可通过“new Date（）”进行本机解析。也就是说，如果创建新的 datetime.datetime 实例（例如使用 datetime.datetime.now），则可以将字符串包含在 JSON 字符串中，然后可以将该字符串作为第一个参数传递给 Date 构造函数。我还没有发现任何异常，但我也没有对它进行太严格的测试。

我得到的日期是这样的：

"/Date(1276290000000+0300)/"

在某些示例中，日期的格式略有不同：

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

等。

所以我想出了以下正则表达式：

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

最终代码是：

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

希望它有所帮助。

更新： 我从 Microsoft 找到了这个链接：如何使用 JSON 序列化日期？

这似乎是我们都在寻找的那个。

在很棒的线程中发帖：

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

这令人沮丧。我的解决方案是从 ASP 生成的值中解析出“/ 和 /”。NET 的 JavaScriptSerializer，因此，尽管 JSON 可能没有日期文字，但它仍然被浏览器解释为日期，这就是我真正想要的：{"myDate":Date(123456789)}

自定义 DateTime 的 JavaScriptConverter？

我必须强调罗伊·廷克（Roy Tinker）评论的准确性。这不是合法的 JSON。这是服务器上的一个肮脏的黑客，可以在问题成为 JavaScript 问题之前将其删除。它会扼杀 JSON 解析器。我用它来起步，但我不再使用它了。但是，我仍然觉得最好的答案在于更改服务器格式化日期的方式，例如，其他地方提到的 ISO。

不要重复自己 - 使用$.parseJSON()

帖子的答案提供手动日期转换为 JavaScript 日期的功能。我只是扩展了jQuery，所以它能够在你指示它时自动解析日期。它处理 ASP.NET 格式化的日期 （） 以及 ISO 格式的日期 （），这些日期由浏览器中的本机 JSON 函数（以及 json2.js 等库）支持。$.parseJSON()/Date(12348721342)/2010-01-01T12.34.56.789Z

无论如何。如果您不想一遍又一遍地重复日期转换代码，我建议您阅读这篇博文并获取代码，让您的生活更轻松一些。

更新

我们有一个内部 UI 库，它必须同时应对 Microsoft ASP.NET 内置的 JSON 格式，例如最初在这里询问的 ，以及大多数 JSON 的日期格式（包括 JSON）。NET的，比如.此外，我们需要应对 oldIE 无法应对除小数点后 3 位之外的任何事情。/Date(msecs)/2014-06-22T00:00:00.0

我们首先检测我们正在消耗的日期类型，将其解析为普通的 JavaScript 对象，然后将其格式化。Date

1）检测Microsoft日期格式

// 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）解析ISO日期格式。

我们至少有一种方法可以确保我们正在处理标准 ISO 日期或修改为始终具有三个毫秒位置的 ISO 日期（见上文），因此代码因环境而异。

4a） 解析标准ISO日期格式，应对oldIE的问题：

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） 解析具有固定小数点后三位毫秒的 ISO 格式 - 要容易得多：

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 解析中很有用，这样您就可以获得 Date 对象而不是字符串，或者如果您仍然以某种方式停留在 jQuery <1.5 中。

旧答案

如果将 jQuery 1.4 的 Ajax 函数与 ASP.NET MVC 一起使用，则可以使用以下命令将所有 DateTime 属性转换为 Date 对象：

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

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

在 jQuery 1.5 中，可以通过在 Ajax 调用中使用 converters 选项来避免全局重写该方法。parseJSON

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

不幸的是，您必须切换到较旧的 eval 路由才能让 Dates 就地全局解析 - 否则您需要在解析后根据更多具体情况转换它们。

在 jQuery 1.5 中，只要你有 json2.js 来覆盖旧版浏览器，就可以反序列化来自 Ajax 的所有日期，如下所示：

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

我包含的逻辑假设您将服务器中的所有日期都作为 UTC 发送（您应该这样做）;然后，使用者获取一个 JavaScript 对象，该对象具有适当的 ticks 值来反映这一点。也就是说，在日期调用 等将返回与在服务器上相同的值，而调用将返回由其浏览器确定的用户本地时区的值。DategetUTCHours()getHours()

这没有考虑具有时区偏移量的 WCF 格式，尽管添加起来相对容易。

这些答案都有一个共同点：它们都将日期存储为单个值（通常是字符串）。

另一种选择是利用 JSON 的固有结构，并将日期表示为数字列表：

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

当然，您必须确保对话的两端就格式（年、月、日）以及哪些字段是日期达成一致,...但它的优点是完全避免了日期到字符串转换的问题。全是数字，完全没有字符串。此外，使用顺序：年、月、日还可以按日期正确排序。

只是跳出框框思考 - JSON 日期不必存储为字符串。

这样做的另一个好处是，通过利用 CouchDB 处理数组值查询的方式，您可以轻松（且高效地）选择给定年份或月份的所有记录。

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

使用 jQuery UI 日期选择器 - 只有在您已经包含 jQuery UI 时才有意义：

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

输出：

2008年10月15日

只是为了在这里添加另一种方法，如果你不是非常小心，WCF 采用的“滴答方法”很容易出现时区问题，如此处和其他地方所述。因此，我现在使用的是 .NET 和 JavaScript 都正式支持的 ISO 8601 格式，其中包括时区偏移量。以下是详细信息：

在 WCF/.NET 中：

其中 CreationDate 是 System.DateTime;ToString（“o”） 正在使用 .NET 的往返格式说明符，用于生成符合 ISO 8601 的日期字符串

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

在 JavaScript 中

在检索 JSON 后，我使用 Date 构造函数将日期修复为 JavaSript Date 对象，该构造函数接受 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());
    }
)

一旦你有了 JavaScript 日期，你就可以使用所有方便可靠的 Date 方法，如 toDateString、toLocaleString 等。

在页面中添加 jQuery UI 插件：

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

下面是一个非常简单的解析 JSON 日期的解决方案。根据您的要求使用以下功能。您只需要将 JSON 格式 Date fetched 作为参数传递给以下函数：

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

将 JSON 日期转换为 JavaScript 日期很容易：

var s = Response.StartDate;     
s = s.replace('/Date(', '');

s = s.replace(')/', '');

var expDate = new Date(parseInt(s));

点击这里查看演示

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

结果 - “10/15/2008”

您还可以使用 JavaScript 库 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');

我还必须寻找这个问题的解决方案，最终我遇到了moment.js，这是一个不错的库，可以解析这种日期格式等等。

var d = moment(yourdatestring)

它为我省去了一些麻烦，所以我想我会和你分享。:)
您可以在此处找到有关它的更多信息： http://momentjs.com/

如果 .NET 返回...

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

然后在 JavaScript 中...

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

顺便说一句，KendoUI支持转换Microsoft JSON日期。 所以，如果你的项目引用了“KendoUI”，你可以简单地使用

var newDate = kendo.parseDate(jsonDate);

这使用正则表达式，它也有效：

var date = new Date(parseInt(/^\/Date\((.*?)\)\/$/.exec(jsonDate)[1], 10));

您可以尝试使用的另一个正则表达式示例：

var mydate = json.date
var date = new Date(parseInt(mydate.replace(/\/Date\((-?\d+)\)\//, '$1');
mydate = date.getMonth() + 1 + '/' + date.getDate() + '/' + date.getFullYear();

date.getMonth()返回一个整数 0 - 11，因此我们必须将 1 相加才能得到正确的月份数字

这也可能对您有所帮助。

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

我能建议的最简单方法是将正则表达式用作：JS

//Only use [0] if you are sure that the string matches the pattern
//Otherwise, verify if 'match' returns something
"/Date(1512488018202)/".match(/\d+/)[0] 

在下面的代码中。我有

1. 从日期字符串中检索时间戳。

2.并将其解析为Int

3.最后创建了一个使用它。Date

var dateString = "/Date(1224043200000)/";
var seconds = parseInt(dateString.replace(/\/Date\(([0-9]+)[^+]\//i, "$1"));
var date = new Date(seconds);
console.log(date);

我使用这个简单的函数从 Microsoft JSON Date 获取日期

function getDateValue(dateVal) {
    return new Date(parseInt(dateVal.replace(/\D+/g, '')));
};

replace(/\D+/g, '')将删除除数字以外的所有字符

parseInt将字符串转换为数字

用法

$scope.ReturnDate = getDateValue(result.JSONDateVariable)

试试这个...

function formatJSONDate(jsonDate) {
            var date = jsonDate;
            var parsedDate = new Date(parseInt(date.toString().substring(6)));
            var newDate = new Date(parsedDate);
            var getMonth = newDate.getMonth() + 1;
            var getDay = newDate.getDay();
            var getYear = newDate.getFullYear(); 

            var standardDate = (getMonth<10 ? '0' : '') + getMonth + '/' + (getDay<10 ? '0' : '') + getDay + '/' + getYear;
            return standardDate;
        }

getYear（） 返回年份 - 1900，这已经弃用了一段时间，最好使用 getFullYear（）

TLDR：您无法可靠地转换该仅日期值，而是发送字符串...

...或者至少几乎所有这些答案都应该这样开始。

这里正在发生许多转换问题。

这是一个没有时间的日期

每个人似乎都忽略了一个问题中有多少个尾随零 - 几乎可以肯定，它开始是一个没有时间的日期：

/Date(1224043200000)/

当从 javascript 控制台作为新日期执行时（许多答案的基础）

new Date(1224043200000)

您将获得：

最初的询问者可能在 EST 中，并且具有纯日期 （sql） 或带有午夜的 DateTime（不是 DateTimeOffset）。

换句话说，这里的意图是时间部分毫无意义。但是，如果浏览器在与生成服务器相同的时区执行此操作，则无关紧要，并且大多数答案都有效。

按时区位

但是，如果您在具有不同时区（例如 PST）的计算机上执行上述代码：

你会注意到，我们现在在另一个时区落后了一天。这不会通过更改序列化程序（仍将包含 iso 格式的时区）来解决

问题

Date （sql） 和 DateTime （.net） 没有时区，但只要将它们转换为有时区的内容（在本例中通过 json 推断的 javascript），.net 中的默认操作就是假定当前时区。

序列化创建的数字是自 Unix 纪元以来的毫秒数，或者：

(DateTimeOffset.Parse("10/15/2008 00:00:00Z") - DateTimeOffset.Parse("1/1/1970 00:00:00Z")).TotalMilliseconds;

这是 javascript 中的新 Date（） 作为参数的东西。Epoch 来自 UTC，所以现在无论您是否愿意，您都可以在那里获得时区信息。

可能的解决方案：

在仅表示日期的序列化对象上创建一个字符串属性可能更安全 - 带有“10/15/2008”的字符串不太可能使其他人与这种混乱混淆。尽管即使在那里，您也必须在解析方面小心：https://stackoverflow.com/a/31732581

但是，本着对所提问题提供答案的精神，按原样：

function adjustToLocalMidnight(serverMidnight){ 
  var serverOffset=-240; //injected from model? <-- DateTimeOffset.Now.Offset.TotalMinutes
  var localOffset=-(new Date()).getTimezoneOffset(); 
  return new Date(date.getTime() + (serverOffset-localOffset) * 60 * 1000)
}

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

如果您使用的是 Kotlin，那么这将解决您的问题。

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

只需使用 Moment.js。这很容易

var finalDate = moment("/Date(1198908717056)/").format("dddd, MMM Do YYYY, hh:mm:ss a");

//"Saturday, Dec 29th 2007, 12:11:57 pm"


var finalDate2 = moment("/Date(1198908717056)/").format("DD-MMM-YYYY");  //"29-Dec-2007"