Moment.js 已在数百万个项目中成功使用，我们很高兴为在网络上改善日期和时间做出贡献。截至 2020 年 9 月，Moment 每周获得超过 1200 万次下载！但是，Moment 是为 JavaScript 生态系统的上一个时代构建的。如今，现代网络看起来大不相同。多年来，Moment 已经有所发展，但它的设计与 2011 年创建时基本相同。鉴于有多少项目依赖于它，我们选择优先考虑稳定性而不是新功能。

例如，考虑 Moment 对象是可变的。这是人们抱怨 Moment 的常见原因。我们在使用指南中对此进行了说明，但对于大多数新用户来说，这仍然令人惊讶。将 Moment 更改为不可变将对使用它的每个项目造成重大更改。创建一个不可变的“Moment v3”将是一项艰巨的任务，并且会使 Moment 成为一个完全不同的库。由于这已经在其他库中完成，我们认为保留可变 API 更加重要。

反对在现代应用程序中使用 Moment 的另一个常见论点是它的体积。Moment 无法很好地与现代“tree shaking”算法配合使用，因此它往往会增加 Web 应用程序包的大小。如果需要国际化或时区支持，Moment 可能会变得非常大。现代 Web 浏览器（和 Node.js）通过Intl对象公开国际化和时区支持，该对象已编纂为ECMA-402。像Luxon（和其他）这样的库利用了这一点，减少或消除了运送您自己的数据文件的需要。

最近，Chrome Dev Tools 开始显示仅针对大小建议替换 Moment。我们普遍支持此举。

您可能还想阅读

• 您可能不再需要 Moment.js
• 您（可能）不需要 Moment.js
• 您不应该使用 Moment.js 的原因...
• 国际化日期的 4 个 Moment.js 替代方案

Moment 团队对这些问题进行了深入讨论。我们认识到许多现有项目可能会继续使用 Moment，但我们希望阻止 Moment 在未来新项目中使用。相反，我们希望推荐替代方案，这些替代方案是当今现代应用程序中使用的绝佳选择。我们还希望推广Temporal作为 JavaScript 语言的补充，该补充正在寻求反馈和贡献者。

我们现在普遍认为 Moment 是处于维护模式的遗留项目。它并没有死亡，但它确实完成了。

在实践中，这意味着

• 我们不会添加新功能或功能。
• 我们不会更改 Moment 的 API 以使其不可变。
• 我们不会解决 tree shaking 或包大小问题。
• 我们不会进行任何重大更改（没有版本 3）。
• 我们可能会选择不修复错误或行为怪癖，尤其是如果它们是长期存在的已知问题。

特别针对 Moment 的国际化语言环境文件

• 我们可能会选择不接受对语言环境字符串或本地化日期格式的更正，尤其是如果它们已被成功争论为其当前形式。
• 您必须提出一个新的、引人注目的语言环境更改论点，并提供大量非轶事证据来支持您的立场。
• 如果您要求更改的字符串或格式反映在CLDR中，那么您必须首先在那里提交更改并获得接受。

然而，由于我们了解 Moment 已在数百万个现有项目中建立

• 我们将解决出现的关键安全问题。
• 我们将在IANA 时区数据库发布后发布 Moment-Timezone 的数据更新。

继续使用 Moment 的理由

在大多数情况下，您不应该为新项目选择 Moment。但是，您可能希望继续使用它的一些可能原因。

浏览器支持

Moment 适用于 Internet Explorer 8 及更高版本。相比之下，Luxon 仅适用于 IE 10 及更高版本，并且需要一个 polyfill 才能做到这一点。您可以在 Luxon 的文档中阅读更多内容。

其他库也曾出现过 Safari 问题，尤其是在移动设备上。如果您有强烈的要求支持较旧的浏览器，那么您可能需要坚持使用 Moment 一段时间。

但是，Day.js 报告与 IE8 及更高版本兼容，因此您仍然可能希望考虑该替代方案。

其他库的依赖项

其他几个库（尤其是日期选择器和绘图库）将 Moment 作为依赖项。如果您正在使用此类组件并且找不到替代方案，那么您已经在项目中包含了 Moment。因此，在整个项目中继续使用 Moment 可能比再包含另一个日期和时间库更有意义。

熟悉度

如果您是 Moment 的长期用户，您可能已经很好地理解了它的 API 和限制。如果是这样，并且上述问题对您来说不是问题，那么您当然可以继续使用它。

有几个不错的选择可以考虑用作 Moment 的替代品。

在选择时，请考虑

• 某些库被拆分为模块、插件或配套库。
• 某些库使用 ECMAScript Intl API 来处理区域设置、时区或两者。
• 某些库仍然提供自己的区域设置和时区文件，就像 Moment 和 Moment-Timezone 所做的那样。

以下是我们推荐的替代方案

Luxon

Luxon 可以被认为是 Moment 的演变。它的作者是 Isaac Cambron，他是 Moment 的长期贡献者。请阅读 Luxon 文档中的为什么 Luxon 存在？和对于 Moment 用户页面。

• 区域设置：提供 Intl
• 时区：提供 Intl

Day.js

Day.js 被设计为 Moment.js 的极简替代品，使用类似的 API。它不是一个直接替代品，但如果您习惯使用 Moment 的 API 并且希望快速行动，请考虑使用 Day.js。

• 区域设置：可单独导入的自定义数据文件
• 时区：通过插件提供 Intl

date-fns

Date-fns 提供了一系列用于操作 JavaScript Date 对象的函数。有关更多详细信息，请滚动到 date-fns 主页上的“为什么是 date-fns？”。

• 区域设置：可单独导入的自定义数据文件
• 时区：通过单独的配套库提供 Intl

js-Joda

js-Joda 是 Java 的 Three-Ten Backport 的 JavaScript 端口，它是 Java SE 8 java.time 包的 JSR-310 实现的基础。如果您熟悉 java.time、Joda-Time 或 Noda Time，您会发现 js-Joda 具有可比性。

• 区域设置：通过附加模块提供自定义数据文件
• 时区：通过附加模块提供自定义数据文件

无库

JavaScript 一直都有一个 Date 对象，ECMAScript (ECMA-262) 规范在此定义。

使用 Date 对象时，请注意以下事项

• Date 对象在内部表示具有毫秒精度的 Unix 时间戳。它提供将系统本地时区转换来回的函数，但它在内部始终是 UTC。与 Moment 对象不同，它不能设置为使用其他时区；它没有“模式”概念。

• 过去使用 Date.parse 或 new Date(<string>) 一直存在问题，并且实现不一致。 当前规范 定义了解析 ISO 8601 字符串的变体，其中仅日期形式（如 "2020-09-14"）解析为 UTC，而不是 ISO 8601 所解析的本地时间。即便如此，并非所有现代实现都正确地实现了此规范（例如 Safari）。其他类型的字符串可能有效，但解析它们是特定于实现的，并且可能存在很大差异 - 尤其是在较旧的浏览器中。根据实现和字符串中提供的组件，您可能会对结果感到惊讶。出于这些原因，我们同意 MDN 的声明，即强烈不建议使用 Date 对象解析字符串。

现代 JavaScript 环境还将实现 ECMA-402 规范，该规范提供了 Intl 对象，并定义了 Date 对象的 toLocaleString、toLocaleDateString 和 toLocaleTimeString 函数的行为选项。

在使用 Intl 对象时，请注意以下事项

• 并非所有环境都将实现完整规范。特别是，Node.js 环境需要 ICU 提供的国际化支持。有关更多详细信息，请参阅 Node.js 文档。
• ECMAScript Intl 兼容性表（kangax 提供） 可用于确定支持哪些功能以及不支持哪些功能。
• 大多数较新的环境通过 Intl.DateTimeFormat 构造函数（以及 Date.toLocaleString、Date.toLocaleDateString 和 Date.toLocaleTimeString）中的 timeZone 选项提供 IANA 时区支持。此选项可用于获取 Date 对象的内部基于 UTC 的时间戳，并获取已转换为命名时区的字符串。但是，不能使用它将 Date 对象转换为不同的时区。

如果 Date 和 Intl 对象满足您的需求，并且您完全了解它们的限制，那么您可以考虑直接使用它们。

Temporal - JavaScript 语言中更好的日期和时间！

我们希望不久的将来，JavaScript 中根本不需要日期和时间库。相反，我们将能够使用 JavaScript 语言本身的功能。尽管今天已经有一些功能与 Date 和 Intl 一起使用，但我们从经验和数据中得知，还有很大的改进空间。

在 JavaScript 语言中创建更好的日期和时间 API 的工作是通过 ECMA TC39 Temporal Proposal 完成的。它目前处于 TC39 流程 的第 3 阶段。

Temporal 将成为一个新的全局对象，充当顶级命名空间（如 Math）。它公开了许多不同类型的对象，包括 Temporal.Instant、Temporal.ZonedDateTime、Temporal.PlainDateTime、Temporal.PlainDate、Temporal.PlainTime、Temporal.TimeZone 和其他几个对象。Temporal Cookbook 展示了许多“食谱”，其中包含了如何在不同场景中使用这些对象的示例。

您今天可以通过 非生产性填充 来试用 Temporal。请尝试一下，但不要在生产中使用（现在还不行）！

请提供反馈，并考虑为这项工作做出贡献——特别是如果您有使用 Moment 或其他日期和时间库的经验！

Moment 被设计为既可以在浏览器中工作，也可以在 Node.js 中工作。

所有代码都应该在这两种环境中工作，并且所有单元测试在这两种环境中都运行。

目前，ci 系统使用以下浏览器：Windows XP 上的 Chrome、Windows 7 上的 IE 8、9 和 10、Windows 10 上的 IE 11、Linux 上的最新 Firefox 以及 OSX 10.8 和 10.11 上的最新 Safari。

如果您想尝试以下示例代码，只需打开浏览器的控制台并输入它们即可。

npm install moment

var moment = require('moment'); // require
moment().format(); 

或使用 ES6 语法

import moment from 'moment';
moment().format();

注意：在 2.4.0 中，全局导出的 moment 对象已弃用。它将在下一个主要版本中删除。

如果您还想包含 Moment Timezone，请参阅 适用于 Node.js 的单独 Moment Timezone 文档，其中包含示例。

<script src="moment.js"></script>
<script>
    moment().format();
</script>

Moment.js 可在 cdnjs.com 和 jsDelivr 上获得。

bower

bower install --save moment

值得注意的文件有 moment.js、locale/*.js 和 min/moment-with-locales.js。

如果您计划将 moment 与 Require.js 一起使用，我们强烈建议您阅读 此内容。此外，请升级到 2.14.0 或更高版本以获得最佳体验。

首先，您可能已经通过 bower 或 node_modules 或任何其他将 moment.js 与 locales 目录放在基础文件夹中的方式获取了 moment。然后，您应该使用 adapt-pkg-main 之类的工具，或手动使用 packages 配置。

requirejs.config({
  packages: [{
    name: 'moment',
    // This location is relative to baseUrl. Choose bower_components
    // or node_modules, depending on how moment was installed.
    location: '[bower_components|node_modules]/moment',
    main: 'moment'
  }]
});

使用上述设置，您可以使用 moment 要求核心，并使用 moment/locale/de 要求 de 语言环境。

// only needing core
define(['moment'], function (moment) {
    console.log(moment().format('LLLL'));  // 'Friday, June 24, 2016 1:42 AM'
});

// core with single locale
define(['moment', 'moment/locale/de'], function (moment) {
    moment.locale('de');
    console.log(moment().format('LLLL')); // 'Freitag, 24. Juni 2016 01:42'
});

// core with all locales
define(['moment/min/moment-with-locales'], function (moment) {
    moment.locale('de');
    console.log(moment().format('LLLL')); // 'Freitag, 24. Juni 2016 01:42'
});

// async load locale
define(['require', 'moment'], function(require, moment) {
  // Inside some module after the locale is detected. This is the
  // case where the locale is not known before module load time.
  require(['moment/locale/de'], function(localeModule) {
    // here the locale is loaded, but not yet in use
    console.log(moment().format('LLLL'));  // 'Friday, June 24, 2016 1:42 AM'

    moment.locale('de');
    // Use moment now that the locale has been properly set.
    console.log(moment().format('LLLL')); // 'Freitag, 24. Juni 2016 01:42'
  })
});

对于更复杂的使用案例，请阅读 @jrburke 的精彩解释。

Moment 仍将创建一个 moment 全局，这对插件和其他第三方代码很有用。如果您希望压缩该全局，请对模块配置使用 noGlobal 选项。

require.config({
    config: {
        moment: {
            noGlobal: true
        }
    }
});

如果您未指定 noGlobal，则全局导出的 moment 将打印弃用警告。从下一个主要版本开始，如果您想要该行为，您必须自己导出它。

对于版本 2.5.x，如果您使用依赖于 Moment 但与 AMD 不兼容的其他插件，则可能需要将 wrapShim: true 添加到您的 r.js 配置中。

注意：为了允许在 requirejs 环境中加载 moment.js 插件，moment 被创建为一个命名模块。因此，moment 必须完全按 "moment" 加载，使用 paths 确定目录。使用 "vendor\moment" 之类的路径要求 moment 将返回 undefined。

注意：从版本 2.9.0 开始，moment 将自身导出为匿名模块，因此如果您只使用核心（没有语言环境/插件），那么如果您将其放在非标准位置，则不需要配置。

NuGet / Moment.js

Install-Package Moment.js

meteor / atmosphere / momentjs:moment

meteor add momentjs:moment

npm install moment

var moment = require('moment');
moment().format();

注意：有一个错误阻止加载 moment.locale。

var moment = require('moment');
moment.locale('cs');
console.log(moment.locale()); // en

使用以下解决方法

var moment = require('moment');
require('moment/locale/cs');
console.log(moment.locale()); // cs

要包含所有语言环境

var moment = require('moment');
require("moment/min/locales.min");
moment.locale('cs');
console.log(moment.locale()); // cs

npm install moment

var moment = require('moment');
moment().format();

注意：默认情况下，webpack 捆绑所有 Moment.js 语言环境（在 Moment.js 2.18.1 中，为 160 KB 缩小版）。要删除不必要的语言环境并仅捆绑使用的语言环境，请添加 moment-locales-webpack-plugin

// webpack.config.js
const MomentLocalesPlugin = require('moment-locales-webpack-plugin');

module.exports = {
    plugins: [
        // To strip all locales except “en”
        new MomentLocalesPlugin(),

        // Or: To strip all locales except “en”, “es-us” and “ru”
        // (“en” is built into Moment and can’t be removed)
        new MomentLocalesPlugin({
            localesToKeep: ['es-us', 'ru'],
        }),
    ],
};

还有其他资源可以优化带 webpack 的 Moment.js，例如这个。

从版本2.13.0开始，Moment 包含一个 Typescript 定义文件。

通过 NPM 安装

npm install moment

在 Typescript 文件中导入并使用

const moment = require('moment');

let now = moment().format('LLLL');

注意：如果您在导入 moment 时遇到问题

对于Typescript 2.x，请尝试在 tsconfig.json 文件的 compilerOptions 中添加 "moduleResolution": "node"

对于Typescript 1.x，请尝试在 tsconfig.json 文件的 compilerOptions 中添加 "allowSyntheticDefaultImports": true，然后使用语法

import moment from 'moment';

语言环境导入

要使用 moment.locale，您首先需要导入您要定位的语言。

import * as moment from 'moment';
import 'moment/locale/pt-br';

console.log(moment.locale()); // en
moment.locale('fr');
console.log(moment.locale()); // fr
moment.locale('pt-br');
console.log(moment.locale()); // pt-br

要加载 moment，请将其放在 baseURL 配置中 System.config 指定的路径中。然后将其导入您的页面。

<script src="system.js"></script>
<script>
  System.config({
    baseURL: '/app'
  });

  System.import('moment.js');
 </script>

如果您需要将 moment 加载为全局，可以使用 meta 配置执行此操作

System.config({
  meta: {
    'moment': { format: 'global' }
  }
});

或者，要仅将 Moment 作为全局提供给特定依赖项，您可以执行此操作

System.config({
  meta: {
    'path/to/global-file.js': {
      globals: {
        moment: 'moment'
      }
    }
  }
});

要在Java/Rhino下使用，请参阅这些说明。

要在Demandware中使用，请参阅这些说明。

如果您遇到任何问题，首先要检查的是指南。

如果您没有在那里找到您要找的内容，请尝试在Stack Overflow上使用momentjs标签提问。

注意：Stack Overflow 上看到的一半以上的问题都可以通过这篇博文来回答。

您还可以使用GitHub 问题跟踪器来查找相关问题或打开新问题。

此外，Moment 有一个Gitter，内部团队经常在那里。

对于一般的故障排除帮助，Stack Overflow是首选论坛。Moment 的维护者在 Stack Overflow 上非常活跃，还有其他几位知识渊博的用户。最快的响应将在那里。

Moment.js 不会修改本机 Date.prototype，而是为 Date 对象创建一个包装器。要获取此包装器对象，只需使用受支持的输入类型之一调用 moment()。

Moment 原型通过 moment.fn 暴露。如果您想添加自己的函数，那就是您放置它们的地方。

为了便于参考，Moment.prototype 上的任何方法都将在文档中引用为 moment#method。因此 Moment.prototype.format == moment.fn.format == moment#format。

请阅读

• moment(...) 是本地模式。假设不明确的输入（没有偏移量）是本地时间。调整明确的输入（有偏移量）为本地时间。
• moment.utc(...) 是 UTC 模式。假设不明确的输入是 UTC。调整明确的输入为 UTC。
• moment.parseZone() 保持传入的输入区域。假设不明确的输入是 UTC。
• moment.tz(...) 与 moment-timezone 插件一起可以在特定时区解析输入。

请记住，时区和时区偏移量是两回事。-08:00 的偏移量并不一定意味着您在美国太平洋时区。

有关更多信息，请参阅解析指南.

moment();
moment(undefined);
// From 2.14.0 onward, also supported
moment([]);
moment({});

要获取当前日期和时间，只需调用不带任何参数的moment()。

var now = moment();

这实际上与调用moment(new Date())相同。

注意：从2.14.0版本开始，moment([])和moment({})也会返回当前时间。在2.14.0之前，它们默认为当天开始时间，但这是任意的，所以已更改。

注意：未传入函数参数时，默认值为undefined。Moment将moment(undefined)视为moment()。

注意：Moment是在评估时创建的，因此moment().diff(moment())可能并不总是返回0。有关更多详细信息，请参阅此GitHub问题。

moment(String);

从字符串创建Moment时，我们首先检查字符串是否匹配已知的ISO 8601格式，然后检查字符串是否匹配RFC 2822日期时间格式，如果未找到已知格式，则回退到new Date(string)。

var day = moment("1995-12-25");

警告：浏览器对解析字符串的支持不一致。由于没有关于应支持哪些格式的规范，因此在某些浏览器中有效的方法在其他浏览器中将无效。

要一致地解析除ISO 8601字符串之外的任何内容，应使用字符串+格式。

支持的ISO 8601字符串

ISO 8601字符串需要日期部分。

2013-02-08  # A calendar date part
2013-02     # A month date part
2013-W06-5  # A week date part
2013-039    # An ordinal date part

20130208    # Basic (short) full date
201303      # Basic (short) year+month
2013        # Basic (short) year only
2013W065    # Basic (short) week, weekday
2013W06     # Basic (short) week only
2013050     # Basic (short) ordinal date (year + day-of-year)

时间部分也可以包含在内，用空格或大写T与日期部分分隔。

2013-02-08T09            # An hour time part separated by a T
2013-02-08 09            # An hour time part separated by a space
2013-02-08 09:30         # An hour and minute time part
2013-02-08 09:30:26      # An hour, minute, and second time part
2013-02-08 09:30:26.123  # An hour, minute, second, and millisecond time part
2013-02-08 24:00:00.000  # hour 24, minute, second, millisecond equal 0 means next day at midnight

20130208T080910,123      # Short date and time up to ms, separated by comma
20130208T080910.123      # Short date and time up to ms
20130208T080910          # Short date and time up to seconds
20130208T0809            # Short date and time up to minutes
20130208T08              # Short date and time, hours only

任何日期部分都可以有时间部分。

2013-02-08 09  # A calendar date part and hour time part
2013-W06-5 09  # A week date part and hour time part
2013-039 09    # An ordinal date part and hour time part

如果包含时间部分，还可以将与UTC的偏移量包括为+-HH:mm、+-HHmm、+-HH或Z。

2013-02-08 09+07:00            # +-HH:mm
2013-02-08 09-0100             # +-HHmm
2013-02-08 09Z                 # Z
2013-02-08 09:30:26.123+07:00  # +-HH:mm
2013-02-08 09:30:26.123+07     # +-HH

注意：对星期和序数格式的支持已添加到2.3.0版本中。

如果字符串与上述任何格式都不匹配，并且无法使用Date.parse进行解析，则moment#isValid将返回false。

moment("not a real date").isValid(); // false

RFC 2822日期时间格式

在解析RFC 2822日期时间之前，会清除字符串以删除任何注释和/或换行符。其他字符在格式中是合法的，但不会为创建有效的Moment实例增加任何内容。

清除后，将在以下空格分隔的部分中验证字符串，所有部分都使用英语

6 Mar 17 21:22 UT
6 Mar 17 21:22:23 UT
6 Mar 2017 21:22:23 GMT
06 Mar 2017 21:22:23 Z
Mon 06 Mar 2017 21:22:23 z
Mon, 06 Mar 2017 21:22:23 +0000

1. 星期中的某天，用三个字母表示，后面可以跟逗号。（可选）
2. 月份中的某天（1或2位数字），后面跟三个字母的月份和2或4位数字的年份
3. 两位数的小时和分钟，用冒号(:)分隔，后面可以跟另一个冒号和2位数的秒数
4. 时区或偏移量，格式如下
5. UT : +0000
6. GMT : +0000
7. EST | CST | MST | PST | EDT | CDT | MDT | PDT : 美国时区*
8. A - I | K - Z : 军用时区*
9. 时间偏移量 +/-9999

[*] 有关详细信息，请参阅规范的第4.3节。

解析器还会确认星期几（如果包含）与日期一致。

moment(String, String);
moment(String, String, String);
moment(String, String, String[]);
moment(String, String, Boolean);
moment(String, String, String, Boolean);

如果你知道输入字符串的格式，则可以使用它来解析Moment。

moment("12-25-1995", "MM-DD-YYYY");

默认情况下，解析器会忽略非字母数字字符，因此以下两者都会返回相同的结果。

moment("12-25-1995", "MM-DD-YYYY");
moment("12/25/1995", "MM-DD-YYYY");

在解析日期和时间时，你可能会得到意外的结果。以下示例可能无法按预期解析

moment('24/12/2019 09:15:00', "DD MM YYYY hh:mm:ss");

你可以使用严格模式，它将识别解析错误并将Moment对象设置为无效

moment('24/12/2019 09:15:00', "DD MM YYYY hh:mm:ss", true);

解析标记类似于moment#format中使用的格式化标记。

年、月和日标记

标记区分大小写。

从 2.10.5 版本开始，YYYY 在非 strict 模式下支持 2 位数年份，并将它们转换为接近 2000 年的年份（与 YY 相同）。

2.11.1 版本中添加了 Y。它将匹配任何带符号或不带符号的数字。它对于不是 4 位数或早于公元前的年份很有用。它可用于任何年份。

周年份、周和星期几标记

对于这些标记，小写标记使用区域设置感知的周起始日，大写标记使用 ISO 周日期 起始日。

标记区分大小写。

区域设置感知格式

还可以使用 LT LTS L LL LLL LLLL 获得区域设置感知的日期和时间格式。它们在 2.2.1 版本中添加，除了 2.8.4 版本中添加的 LTS。

标记区分大小写。

小时、分钟、秒、毫秒和偏移标记

标记区分大小写。

从 2.10.5 版本开始：长度为 4 到 9 的小数秒标记可以解析任意位数，但只会考虑前 3 位（毫秒）。如果你有带许多小数位的时间打印，并且想要使用输入，请使用它。

请注意，仅在严格模式下进行解析时，提供的 S 字符数才相关。在标准模式下，S、SS、SSS、SSSS 等效，并解释为几分之一秒。例如，.12 始终为 120 毫秒，传递 SS 不会导致其解释为 12 毫秒。

Z ZZ 在版本 1.2.0 中添加。

S SS SSS 在版本 1.6.0 中添加。

X 在版本 2.0.0 中添加。

SSSSS ... SSSSSSSSS 在版本 2.10.5 中添加。

k kk 在版本 2.13.0 中添加。

除非您指定时区偏移，否则解析字符串将在当前时区创建日期。

moment("2010-10-20 4:30",       "YYYY-MM-DD HH:mm");   // parsed as 4:30 local time
moment("2010-10-20 4:30 +0000", "YYYY-MM-DD HH:mm Z"); // parsed as 4:30 UTC

纪元年相关标记

标记区分大小写。

纪元支持在 2.25.0 中添加。标记/API 仍在变化。

注释和注意事项

如果解析输入产生的时刻不存在，则 moment#isValid 将返回 false。

moment("2010 13",           "YYYY MM").isValid();     // false (not a real month)
moment("2010 11 31",        "YYYY MM DD").isValid();  // false (not a real day)
moment("2010 2 29",         "YYYY MM DD").isValid();  // false (not a leap year)
moment("2010 notamonth 29", "YYYY MMM DD").isValid(); // false (not a real month name)

从版本 2.0.0 开始，可以将区域设置键作为第三个参数传递给 moment() 和 moment.utc()。

moment('2012 juillet', 'YYYY MMM', 'fr');
moment('2012 July',    'YYYY MMM', 'en');
moment('2012 July',    'YYYY MMM', ['qj', 'en']);

Moment 的解析器非常宽容，这可能会导致不希望/意外的行为。

例如，可以观察到以下行为

moment('2016 is a date', 'YYYY-MM-DD').isValid() //true, 2016 was matched

在 2.13.0 之前，解析器表现出以下行为。此问题已得到纠正。

moment('I am spartacus', 'h:hh A').isValid();     //true - the 'am' matches the 'A' flag.

从版本 2.3.0 开始，您可以为最后一个参数指定一个布尔值，以使 Moment 使用严格解析。严格解析要求格式和输入完全匹配，包括定界符。

moment('It is 2012-05-25', 'YYYY-MM-DD').isValid();       // true
moment('It is 2012-05-25', 'YYYY-MM-DD', true).isValid(); // false
moment('2012-05-25',       'YYYY-MM-DD', true).isValid(); // true
moment('2012.05.25',       'YYYY-MM-DD', true).isValid(); // false

您可以同时使用区域设置和严格性。

moment('2012-10-14', 'YYYY-MM-DD', 'fr', true);

严格解析通常是最佳解析选项。有关选择严格解析与宽松解析的更多信息，请参阅 解析指南。

解析两位数年份

默认情况下，68 以上的两位数年份被假定为 1900 年代，68 或以下的年份被假定为 2000 年代。可以通过替换 moment.parseTwoDigitYear 方法来更改此设置。此方法的唯一参数是一个包含用户输入的两年字符串，并应将年份作为整数返回。

moment.parseTwoDigitYear = function(yearString) {
    return parseInt(yearString) + 2000;
}

解析粘合小时和分钟

从版本 2.11.0 开始，支持解析 hmm、Hmm、hmmss 和 Hmmss

moment("123", "hmm").format("HH:mm") === "01:23"
moment("1234", "hmm").format("HH:mm") === "12:34"

moment(String, String[], String, Boolean);

如果您不知道输入字符串的确切格式，但知道它可能是多种格式之一，则可以使用格式数组。

这与 字符串 + 格式 相同，只是它会尝试将输入与多种格式进行匹配。

moment("12-25-1995", ["MM-DD-YYYY", "YYYY-MM-DD"]);

从版本 2.3.0 开始，Moment 使用一些简单的启发式方法来确定要使用哪种格式。按顺序

• 优先选择解析为 有效 日期而不是无效日期的格式。
• 优先选择解析字符串更多部分并使用更多格式的格式，即优先选择更严格的解析。
• 优先选择数组中较早的格式而不是较晚的格式。

moment("29-06-1995", ["MM-DD-YYYY", "DD-MM", "DD-MM-YYYY"]); // uses the last format
moment("05-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"]);          // uses the first format

您还可以指定区域设置和严格性参数。它们与单个格式情况的工作方式相同。

moment("29-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"], 'fr');       // uses 'fr' locale
moment("29-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"], true);       // uses strict parsing
moment("05-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"], 'fr', true); // uses 'fr' locale and strict parsing

注意：解析多种格式比解析单个格式慢得多。如果您能避免，解析单个格式要快得多。

moment(String, moment.CUSTOM_FORMAT, [String], [Boolean]);
moment(String, moment.HTML5_FMT.DATETIME_LOCAL, [String], [Boolean]); // from 2.20.0
moment(String, [..., moment.ISO_8601, ...], [String], [Boolean]);

ISO-8601 是一种时间和持续时间显示标准。Moment 已经支持解析 iso-8601 字符串，但可以在构建 moment 时在格式/格式列表中明确指定。

要指定 iso-8601 解析，请使用 moment.ISO_8601 常量。

moment("2010-01-01T05:06:07", moment.ISO_8601);
moment("2010-01-01T05:06:07", ["YYYY", moment.ISO_8601]);

从 **2.20.0** 版本开始，以下 HTML5 格式作为常量在 moment 对象的 HTML5_FMT 属性（moment.HTML5_FMT.*）中提供

moment({unit: value, ...});

moment({ hour:15, minute:10 });
moment({ y    :2010, M     :3, d   :5, h    :15, m      :10, s      :3, ms          :123});
moment({ year :2010, month :3, day :5, hour :15, minute :10, second :3, millisecond :123});
moment({ years:2010, months:3, days:5, hours:15, minutes:10, seconds:3, milliseconds:123});
moment({ years:2010, months:3, date:5, hours:15, minutes:10, seconds:3, milliseconds:123});
moment({ years:'2010', months:'3', date:'5', hours:'15', minutes:'10', seconds:'3', milliseconds:'123'});  // from 2.11.0

可以通过在对象中指定一些单位来创建 moment。

省略的单位默认为 0 或当前日期、月份和年份。

day 和 date 键都表示当月的日期。

date 在 **2.8.4** 中添加。

从 **2.11.0** 版本开始支持字符串值（如最后一行所示）。

请注意，与 moment(Array) 和 new Date(year, month, date) 一样，月份从 0 开始。

moment(Number);

类似于 new Date(Number)，可以通过传递一个表示自 Unix 纪元（1970 年 1 月 1 日凌晨 12 点 UTC）以来毫秒数的整数值来创建 moment。

var day = moment(1318781876406);

注意：ECMAScript 将其称为“时间值”

moment.unix(Number)

要从 Unix 时间戳（自 Unix 纪元以来的秒数）创建 moment，请使用 moment.unix(Number)。

var day = moment.unix(1318781876);

这被实现为 moment(timestamp * 1000)，因此输入时间戳中的部分秒数会被包含在内。

var day = moment.unix(1318781876.721);

注意：尽管 Unix 时间戳基于 UTC，但此函数在本地模式下创建 moment 对象。如果您需要 UTC，请随后调用 .utc()，如下所示

var day = moment.unix(1318781876).utc();

moment(Date);

您可以使用预先存在的原生 Javascript Date 对象创建 Moment。

var day = new Date(2011, 9, 16);
var dayWrapper = moment(day);

这将克隆 Date 对象；对 Date 的进一步更改不会影响 Moment，反之亦然。

moment(Number[]);

您可以使用一个数字数组来创建 moment，该数组反映传递给 new Date() 的参数

[年、月、日、时、分、秒、毫秒]

moment([2010, 1, 14, 15, 25, 50, 125]); // February 14th, 3:25:50.125 PM

年份之后的任何值都是可选的，并且将默认为最低可能的值。

moment([2010]);        // January 1st
moment([2010, 6]);     // July 1st
moment([2010, 6, 10]); // July 10th

使用数组构造将在当前时区创建日期。要从数组创建 UTC 中的日期，请使用 moment.utc(Number[])。

moment.utc([2010, 1, 14, 15, 25, 50, 125]);

注意：由于这反映了原生 Date 参数，因此月份、小时、分钟、秒和毫秒均从 0 开始。年份和月份从 1 开始。

这通常是令人沮丧的原因，特别是对于月份，所以请注意！

如果数组表示的日期不存在，moment#isValid 将返回 false。

moment([2010, 12]).isValid();     // false (not a real month)
moment([2010, 10, 31]).isValid(); // false (not a real day)
moment([2010, 1, 29]).isValid();  // false (not a leap year)

moment(String);

Microsoft Web API 默认情况下以正确的 ISO-8601 格式返回 JSON 日期，但较旧的 ASP.NET 技术可能会以 /Date(1198908717056)/ 或 /Date(1198908717056-0700)/ 的形式在 JSON 中返回日期

如果传入与该格式匹配的字符串，它将被正确解析。

moment("/Date(1198908717056-0700)/"); // 2007-12-28T23:11:57.056-07:00

moment(Moment);

所有时刻都是可变的。如果你想要一个时刻的克隆，你可以隐式或显式地这样做。

在时刻上调用 moment() 将克隆它。

var a = moment([2012]);
var b = moment(a);
a.year(2000);
b.year(); // 2012

此外，你可以调用 moment#clone 来克隆一个时刻。

var a = moment([2012]);
var b = a.clone();
a.year(2000);
b.year(); // 2012

moment.utc();
moment.utc(Number);
moment.utc(Number[]);
moment.utc(String);
moment.utc(String, String);
moment.utc(String, String[]);
moment.utc(String, String, String);
moment.utc(String, String, String[]);
moment.utc(String, String, Boolean);
moment.utc(String, String, String, Boolean);
moment.utc(Moment);
moment.utc(Date);

默认情况下，moment 以当地时间解析和显示。

如果你想以 UTC 解析或显示时刻，你可以使用 moment.utc() 代替 moment()。

这将带我们了解 Moment.js 的一个有趣特性。UTC 模式。

在 UTC 模式下，所有显示方法都将以 UTC 时间而不是本地时间显示。

moment().format();     // 2013-02-04T10:35:24-08:00
moment.utc().format(); // 2013-02-04T18:35:24+00:00

此外，在 UTC 模式下，所有 getter 和 setter 在内部都将使用 Date#getUTC* 和 Date#setUTC* 方法，而不是 Date#get* 和 Date#set* 方法。

moment.utc().seconds(30).valueOf() === new Date().setUTCSeconds(30);
moment.utc().seconds()   === new Date().getUTCSeconds();

重要的是要注意，尽管上面的显示方式不同，但它们都是同一时刻。

var a = moment();
var b = moment.utc();
a.format();  // 2013-02-04T10:35:24-08:00
b.format();  // 2013-02-04T18:35:24+00:00
a.valueOf(); // 1360002924000
b.valueOf(); // 1360002924000

使用 moment.utc() 创建的任何时刻都将处于 UTC 模式，而使用 moment() 创建的任何时刻都不会处于 UTC 模式。

要从 UTC 切换到本地时间，可以使用 moment#utc 或 moment#local。

var a = moment.utc([2011, 0, 1, 8]);
a.hours(); // 8 UTC
a.local();
a.hours(); // 0 PST

moment.parseZone()
moment.parseZone(String)
moment.parseZone(String, String)
moment.parseZone(String, [String])
moment.parseZone(String, String, Boolean)
moment.parseZone(String, String, String, Boolean)

Moment 的字符串解析函数（如 moment(string) 和 moment.utc(string)）接受提供的偏移信息，但将生成的 Moment 对象转换为本地或 UTC 时间。相比之下，moment.parseZone() 解析字符串，但将生成的 Moment 对象保留在固定偏移时区中，其中包含字符串中提供的偏移量。

moment.parseZone("2013-01-01T00:00:00-13:00").utcOffset(); // -780 ("-13:00" in total minutes)
moment.parseZone('2013 01 01 05 -13:00', 'YYYY MM DD HH ZZ').utcOffset(); // -780  ("-13:00" in total minutes)
moment.parseZone('2013-01-01-13:00', ['DD MM YYYY ZZ', 'YYYY MM DD ZZ']).utcOffset(); // -780  ("-13:00" in total minutes);

它还允许你传递区域设置和严格性参数。

moment.parseZone("2013 01 01 -13:00", 'YYYY MM DD ZZ', true).utcOffset(); // -780  ("-13:00" in total minutes)
moment.parseZone("2013-01-01-13:00", 'YYYY MM DD ZZ', true).utcOffset(); // NaN (doesn't pass the strictness check)
moment.parseZone("2013 01 01 -13:00", 'YYYY MM DD ZZ', 'fr', true).utcOffset(); // -780 (with locale and strictness argument)
moment.parseZone("2013 01 01 -13:00", ['DD MM YYYY ZZ', 'YYYY MM DD ZZ'], 'fr', true).utcOffset(); // -780 (with locale and strictness argument alongside an array of formats)

moment.parseZone 等于解析字符串并使用 moment#utcOffset 解析区域。

var s = "2013-01-01T00:00:00-13:00";
moment(s).utcOffset(s);

moment().isValid();

Moment 应用比 Date 构造函数更严格的初始化规则。

new Date(2013, 25, 14).toString(); // "Sat Feb 14 2015 00:00:00 GMT-0500 (EST)"
moment([2015, 25, 35]).format();   // 'Invalid date'

你可以使用 moment#isValid 检查 Moment 是否认为日期无效。你可以使用返回对象的 moment#parsingFlags 检查 #isValid 使用的指标。

以下解析标志导致日期无效

• overflow：日期字段溢出，例如第 13 个月、第 32 天（或非闰年的 2 月 29 日）、第 367 天等等。overflow 包含与 #invalidAt 匹配的无效单元索引（见下文）；-1 表示没有溢出。
• invalidMonth：无效的月份名称，例如 moment('Marbruary', 'MMMM');。包含无效的月份字符串本身，或 null。
• empty：不包含任何可解析内容的输入字符串，例如 moment('this is nonsense');。布尔值。
• nullInput：一个 null 输入，例如 moment(null);。布尔值。
• invalidFormat：一个空的格式列表，例如 moment('2013-05-25', [])。布尔值。
• userInvalidated：明确创建为无效的日期，例如 moment.invalid()。布尔值。

除了上述内容外，从 2.13.0 开始，经午线和 parsedDateParts 标志共同确定日期有效性。

• meridiem：指示解析的经午线（AM/PM），如果有的话。字符串。
• parsedDateParts：返回按降序解析的日期部分数组 - 即 parsedDateParts[0] === 年份。如果没有部分，但经午线有值，则日期无效。数组。

此外，如果以严格模式解析时刻，则这些标志必须为空，时刻才有效

• unusedTokens：输入字符串中未找到的格式子字符串的数组
• unusedInput：与格式字符串不匹配的输入子字符串的数组

注意：时刻的有效性概念在2.2和2.3之间变得更加严格和一致。注意：有效性在时刻创建时确定。修改后的时刻（即moment().hour(NaN)）将保持有效。

此外，可以使用moment#invalidAt来确定哪个日期单位溢出。

var m = moment("2011-10-10T10:20:90");
m.isValid(); // false
m.invalidAt(); // 5 for seconds

返回值具有以下含义

1. 年
2. 月
3. 日
4. 小时
5. 分钟
6. 秒
7. 毫秒

注意：如果有多个错误的单位，则返回第一个单位（例如，因为天的有效性可能取决于月份）。

无效时刻

如果时刻无效，则它在浮点运算中表现得像 NaN。

所有以下操作都会产生无效时刻

• invalid.add(unit, value)
• another.add(invalid)
• invalid.clone()
• invalid.diff(another)
• invalid.endOf(unit)
• invalid.max(another)
• another.max(invalid)
• invalid.min(another)
• another.min(invalid)
• invalid.set(unit, value)
• invalid.startOf(unit)
• invalid.subtract(unit, value)

以下操作会生成'InvalidDate'的本地化版本

• invalid.format(anyFmt)在当前语言环境中生成'Invalid Date'
• invalid.from(another)
• another.from(invalid)
• invalid.fromNow(suffix)
• invalid.to(another)
• another.to(invalid)
• invalid.toNow(suffix)
• invalid.toISOString()（在2.18.0之前）
• invalid.toString()

以下操作返回false

• invalid.isAfter(another)
• invalid.isAfter(invalid)
• another.isAfter(invalid)
• invalid.isBefore(another)
• invalid.isBefore(invalid)
• another.isBefore(invalid)
• invalid.isBetween(another, another)
• invalid.isBetween(invalid, invalid)
• invalid.isSame(another)
• invalid.isSame(invalid)
• another.isSame(invalid)
• invalid.isSameOrAfter(another)
• invalid.isSameOrAfter(invalid)
• another.isSameOrAfter(invalid)
• invalid.isSameOrBefore(another)
• invalid.isSameOrBefore(invalid)
• another.isSameOrBefore(invalid)

以下操作返回null或带有某些结构的NaN

• invalid.get(unit)返回 null，与所有其他命名获取器一样
• invalid.toArray() === [NaN, NaN, NaN, NaN, NaN, NaN]
• invalid.toObject()将所有值设置为NaN
• invalid.toDate()返回一个无效的 Date 对象
• invalid.toJSON()返回 null
• invalid.unix()返回 null
• invalid.valueOf()返回 null
• invalid.toISOString()返回 null（自2.18.0起）

moment().creationData();

创建时刻对象后，可以使用creationData()方法访问所有输入。

moment("2013-01-02", "YYYY-MM-DD", true).creationData() === {
    input: "2013-01-02",
    format: "YYYY-MM-DD",
    locale: Locale obj,
    isUTC: false,
    strict: true
}

moment("15", "hh")

你可以创建一个时刻对象，只指定其中的一些单位，其余的将默认为当前日期、月份或年份，或者小时、分钟、秒和毫秒为 0。

当什么都不传递时，默认为现在

moment();  // current date and time

当只传递小时、分钟、秒和毫秒时，默认为今天

moment(5, "HH");  // today, 5:00:00.000
moment({hour: 5});  // today, 5:00:00.000
moment({hour: 5, minute: 10});  // today, 5:10.00.000
moment({hour: 5, minute: 10, seconds: 20});  // today, 5:10.20.000
moment({hour: 5, minute: 10, seconds: 20, milliseconds: 300});  // today, 5:10.20.300

当只传递天和更小的单位时，默认为本月和本年

moment(5, "DD");  // this month, 5th day-of-month
moment("4 05:06:07", "DD hh:mm:ss");  // this month, 4th day-of-month, 05:06:07.000

如果未指定年份，则默认为今年

moment(3, "MM");  // this year, 3rd month (March)
moment("Apr 4 05:06:07", "MMM DD hh:mm:ss");  // this year, 4th April, 05:06:07.000

Moment.js 使用重载的获取器和设置器。你可能熟悉 jQuery 中使用的这种模式。

不带参数调用这些方法充当获取器，带参数调用它们充当设置器。

这些映射到原生 Date 对象上的相应函数。

moment().seconds(30).valueOf() === new Date().setSeconds(30);
moment().seconds()   === new Date().getSeconds();

如果你处于 UTC 模式 下，它们将映射到 UTC 等效项。

moment.utc().seconds(30).valueOf() === new Date().setUTCSeconds(30);
moment.utc().seconds()   === new Date().getUTCSeconds();

为了方便，从版本 2.0.0 开始，既存在单数方法名，也存在复数方法名。

注意：当用作设置器时，所有这些方法都会改变原始时刻。

注意：从 2.19.0 开始，将 NaN 传递给任何设置器都是无操作的。在 2.19.0 之前，它会以错误的方式使时刻无效。

moment().millisecond(Number);
moment().millisecond(); // Number
moment().milliseconds(Number);
moment().milliseconds(); // Number

获取或设置毫秒。

接受 0 到 999 之间的数字。如果超出范围，它将冒泡到秒。

moment().second(Number);
moment().second(); // Number
moment().seconds(Number);
moment().seconds(); // Number

获取或设置秒。

接受 0 到 59 之间的数字。如果超出范围，它将冒泡到分钟。

moment().minute(Number);
moment().minute(); // Number
moment().minutes(Number);
moment().minutes(); // Number

获取或设置分钟。

接受 0 到 59 之间的数字。如果超出范围，它将冒泡到小时。

moment().hour(Number);
moment().hour(); // Number
moment().hours(Number);
moment().hours(); // Number

获取或设置小时。

接受 0 到 23 之间的数字。如果超出范围，它将冒泡到天。

moment().date(Number);
moment().date(); // Number
moment().dates(Number);
moment().dates(); // Number

获取或设置月日。

接受 1 到 31 之间的数字。如果超出范围，它将冒泡到月。

注意：Moment#date 用于月日，而 Moment#day 用于星期几。

注意：如果你链接多个操作来构造一个日期，你应该从年开始，然后是月，然后是日等等。否则你可能会得到意外的结果，比如当 day=31 且当前月只有 30 天时（这同样适用于原生 JavaScript Date 操作），返回的日期将是当前月的 30 日（有关更多详细信息，请参见 月）。

错误：moment().date(day).month(month).year(year)

正确：moment().year(year).month(month).date(day)

2.16.0 已弃用使用 moment().dates()。请改用 moment().date()。

moment().day(Number|String);
moment().day(); // Number
moment().days(Number|String);
moment().days(); // Number

获取或设置星期几。

此方法可用于设置星期几，其中星期日为 0，星期六为 6。

如果给定的值在 0 到 6 之间，则结果日期将在当前（星期日至星期六）周内。

如果超出范围，它将冒泡到其他周。

moment().day(-7); // last Sunday (0 - 7)
moment().day(0); // this Sunday (0)
moment().day(7); // next Sunday (0 + 7)
moment().day(10); // next Wednesday (3 + 7)
moment().day(24); // 3 Wednesdays from now (3 + 7 + 7 + 7)

注意：Moment#date 用于月日，而 Moment#day 用于星期几。

从 2.1.0 开始，还支持星期名称。这在时刻的当前语言环境中进行解析。

moment().day("Sunday");
moment().day("Monday");

moment().weekday(Number);
moment().weekday(); // Number

根据语言环境获取或设置星期几。

如果语言环境将星期一指定为一周的第一天，则 moment().weekday(0) 将是星期一。如果星期日是一周的第一天，则 moment().weekday(0) 将是星期日。

与 moment#day 一样，如果超出范围，它将冒泡到其他周。

// when Monday is the first day of the week
moment().weekday(-7); // last Monday
moment().weekday(7); // next Monday
// when Sunday is the first day of the week
moment().weekday(-7); // last Sunday
moment().weekday(7); // next Sunday

moment().isoWeekday(Number);
moment().isoWeekday(); // Number

获取或设置 ISO 星期几，其中 1 为星期一，7 为星期日。

与 moment#day 一样，如果超出范围，它将冒泡到其他周。

moment().isoWeekday(1); // Monday
moment().isoWeekday(7); // Sunday

还支持星期名称。这在时刻的当前语言环境中进行解析。

moment().isoWeekday("Sunday");
moment().isoWeekday("Monday");

moment().dayOfYear(Number);
moment().dayOfYear(); // Number

获取或设置一年中的第几天。

接受 1 到 366 之间的数字。如果超出范围，它将冒泡到年。

moment().week(Number);
moment().week(); // Number
moment().weeks(Number);
moment().weeks(); // Number

获取或设置一年中的第几周。

由于不同的区域对一年中的周数定义不同，Moment.js 添加了 moment#week 来获取/设置区域化的一年中周数。

一年中的周数根据一周的第一天（星期日、星期一等）和一年中的第一周而有所不同。

例如，在美国，星期日是一周的第一天。1 月 1 日所在的周是一年中的第一周。

在法国，星期一是一周的第一天，1 月 4 日所在的周是一年中的第一周。

moment#week 的输出将取决于该时刻的 区域设置。

在设置一年中的周数时，将保留该周的天数。

moment().isoWeek(Number);
moment().isoWeek(); // Number
moment().isoWeeks(Number);
moment().isoWeeks(); // Number

获取或设置 一年中的 ISO 周数。

在设置一年中的周数时，将保留该周的天数。

moment().month(Number|String);
moment().month(); // Number
moment().months(Number|String);
moment().months(); // Number

获取或设置月份。

接受 0 到 11 之间的数字。如果超出范围，它将冒泡到年份。

注意：月份从 0 开始，因此 1 月是 0 月。

从 2.1.0 开始，还支持月份名称。这是在时刻的当前区域设置中解析的。

moment().month("January");
moment().month("Feb");

在 2.1.0 版本之前，如果时刻更改了月份，并且新月份没有足够的天数来保留当前的日期，它将溢出到下一个月份。

从 2.1.0 版本开始，已更改为将其固定到目标月份的末尾。

// before 2.1.0
moment([2012, 0, 31]).month(1).format("YYYY-MM-DD"); // 2012-03-02
// after 2.1.0
moment([2012, 0, 31]).month(1).format("YYYY-MM-DD"); // 2012-02-29

2.16.0 已弃用使用 moment().months()。请改用 moment().month()。

moment().quarter(); // Number
moment().quarter(Number);
moment().quarters(); // Number
moment().quarters(Number);

获取季度（1 到 4）。

moment('2013-01-01T00:00:00.000').quarter() // 1
moment('2013-04-01T00:00:00.000').subtract(1, 'ms').quarter() // 1
moment('2013-04-01T00:00:00.000').quarter() // 2
moment('2013-07-01T00:00:00.000').subtract(1, 'ms').quarter() // 2
moment('2013-07-01T00:00:00.000').quarter() // 3
moment('2013-10-01T00:00:00.000').subtract(1, 'ms').quarter() // 3
moment('2013-10-01T00:00:00.000').quarter() // 4
moment('2014-01-01T00:00:00.000').subtract(1, 'ms').quarter() // 4

设置季度（1 到 4）。

moment('2013-01-01T00:00:00.000').quarter(2) // '2013-04-01T00:00:00.000'
moment('2013-02-05T05:06:07.000').quarter(2).format() // '2013-05-05T05:06:07-07:00'

moment().year(Number);
moment().year(); // Number
moment().years(Number);
moment().years(); // Number

获取或设置年份。

接受 -270,000 到 270,000 之间的数字。

2.6.0 已弃用使用 moment().years()。请改用 moment().year()。

moment().weekYear(Number);
moment().weekYear(); // Number

根据区域设置获取或设置周年。

由于第一周的第一天并不总是落在每年的第一天，因此有时周年将与月份年不同。

例如，在美国，包含 1 月 1 日的周始终是第一周。在美国，周也从星期日开始。如果 1 月 1 日是星期一，那么 12 月 31 日将属于与 1 月 1 日相同的周，因此与 1 月 1 日相同的周年。12 月 30 日的周年将与 12 月 31 日不同。

moment().isoWeekYear(Number);
moment().isoWeekYear(); // Number

获取或设置 ISO 周年。

moment().weeksInYear();

根据当前时刻年份的区域设置获取周数。

moment().isoWeeksInYear();

根据 ISO 周 获取当前时刻年份中的周数。

moment().get('year');
moment().get('month');  // 0 to 11
moment().get('date');
moment().get('hour');
moment().get('minute');
moment().get('second');
moment().get('millisecond');

字符串获取器。一般来说

moment().get(unit) === moment()[unit]()

单位不区分大小写，并支持复数和简短形式：年（年，y）、月（月，M）、日期（日期，D）、小时（小时，h）、分钟（分钟，m）、秒（秒，s）、毫秒（毫秒，ms）。

moment().set(String, Int);
moment().set(Object(String, Int));

通用设置器，接受单位作为第一个参数，接受值作为第二个参数

moment().set('year', 2013);
moment().set('month', 3);  // April
moment().set('date', 1);
moment().set('hour', 13);
moment().set('minute', 20);
moment().set('second', 30);
moment().set('millisecond', 123);

moment().set({'year': 2013, 'month': 3});

单位不区分大小写，并支持复数和简短形式：年（年，y）、月（月，M）、日期（日期，D）、小时（小时，h）、分钟（分钟，m）、秒（秒，s）、毫秒（毫秒，ms）。

对象解析已在 2.9.0 中添加

moment.max(Moment[,Moment...]);
moment.max(Moment[]);

返回给定时刻实例的最大值（最远的将来）。

例如

var a = moment().subtract(1, 'day');
var b = moment().add(1, 'day');
moment.max(a, b);  // b

var friends = fetchFriends(); /* [{name: 'Dan', birthday: '11.12.1977'}, {name: 'Mary', birthday: '11.12.1986'}, {name: 'Stephan', birthday: '11.01.1993'}]*/
var friendsBirthDays = friends.map(function(friend){
    return moment(friend.birthday, 'DD.MM.YYYY');
});
moment.max(friendsBirthDays);  // '11.01.1993'

如果没有参数，该函数将返回一个带有当前时间的时刻实例。

从 2.10.5 版本开始，如果无效的时刻是参数之一，则结果将是无效的时刻。

moment.max(moment(), moment.invalid()).isValid() === false
moment.max(moment.invalid(), moment()).isValid() === false
moment.max([moment(), moment.invalid()]).isValid() === false
moment.max([moment.invalid(), moment()]).isValid() === false

moment.min(Moment[,Moment...]);
moment.min(Moment[]);

返回给定时刻实例的最小值（最远的过去）。

例如

var a = moment().subtract(1, 'day');
var b = moment().add(1, 'day');
moment.min(a, b);  // a
moment.min([a, b]); // a

如果没有参数，该函数将返回一个带有当前时间的时刻实例。

从 2.10.5 版本开始，如果无效的时刻是参数之一，则结果将是无效的时刻。

moment.min(moment(), moment.invalid()).isValid() === false
moment.min(moment.invalid(), moment()).isValid() === false
moment.min([moment(), moment.invalid()]).isValid() === false
moment.min([moment.invalid(), moment()]).isValid() === false

一旦你有了 Moment，你可能想要以某种方式操作它。有许多方法可以帮助你做到这一点。

Moment.js 使用 流利接口模式，也称为 方法链接。这允许你做以下类似的疯狂的事情。

moment().add(7, 'days').subtract(1, 'months').year(2009).hours(0).minutes(0).seconds(0);

注意：需要注意的是，时刻是可变的。调用任何操作方法都会改变原始时刻。

如果你想创建一个副本并对其进行操作，你应该在操作时刻之前使用 moment#clone。 有关克隆的更多信息。

moment().add(Number, String);
moment().add(Duration);
moment().add(Object);

通过添加时间来改变原始时刻。

这是一个非常强大的函数，用于向现有时刻添加时间。要添加时间，请传递要添加的时间的键以及要添加的数量。

moment().add(7, 'days');

如果你喜欢简洁，还有一些速记键。

moment().add(7, 'd');

如果你想同时添加多个不同的键，你可以将它们作为对象字面量传递。

moment().add(7, 'days').add(1, 'months'); // with chaining
moment().add({days:7,months:1}); // with object literal

数量没有上限，因此你可以重载任何参数。

moment().add(1000000, 'milliseconds'); // a million milliseconds
moment().add(360, 'days'); // 360 days

对月份和年份的特殊考虑

如果原始日期的日期大于最后一个月的天数，则该日期将更改为最后一个月中的最后一天。

moment([2010, 0, 31]);                  // January 31
moment([2010, 0, 31]).add(1, 'months'); // February 28

在添加跨越夏令时的时段时，还需要特别考虑。如果你要添加年份、月份、周或天，则原始小时将始终与添加的小时匹配。

添加一个月将向日期添加指定数量的月份。

moment([2010, 1, 28]);                 // February 28
moment([2010, 1, 28]).add(1, 'month'); // March 28

var m = moment(new Date(2011, 2, 12, 5, 0, 0)); // the day before DST in the US
m.hours(); // 5
m.add(1, 'days').hours(); // 5

如果你要添加小时、分钟、秒或毫秒，则假设你希望精确到小时，并且将导致不同的小时。

var m = moment(new Date(2011, 2, 12, 5, 0, 0)); // the day before DST in the US
m.hours(); // 5
m.add(24, 'hours').hours(); // 6 (but you may have to set the timezone first)

或者，你可以使用 持续时间 添加到时刻。

var duration = moment.duration({'days' : 1});
moment([2012, 0, 31]).add(duration); // February 1

在版本 2.8.0 之前，还支持 moment#add(String, Number) 语法。它已被弃用，取而代之的是 moment#add(Number, String)。

moment().add('seconds', 1); // Deprecated in 2.8.0
moment().add(1, 'seconds');

从 2.12.0 开始，当为天数和月份传递小数值时，它们将四舍五入到最接近的整数。周、季度和年将转换为天或月，然后四舍五入到最接近的整数。

moment().add(1.5, 'months') == moment().add(2, 'months')
moment().add(.7, 'years') == moment().add(8, 'months') //.7*12 = 8.4, rounded to 8

moment().subtract(Number, String);
moment().subtract(Duration);
moment().subtract(Object);

通过减去时间来改变原始时刻。

这与 moment#add 完全相同，只是它不是添加时间，而是减去时间。

moment().subtract(7, 'days');

在版本 2.8.0 之前，还支持 moment#subtract(String, Number) 语法。它已被弃用，取而代之的是 moment#subtract(Number, String)。

moment().subtract('seconds', 1); // Deprecated in 2.8.0
moment().subtract(1, 'seconds');

从 2.12.0 开始，当为天数和月份传递小数值时，它们将四舍五入到最接近的整数。周、季度和年将转换为天或月，然后四舍五入到最接近的整数。

moment().subtract(1.5, 'months') == moment().subtract(2, 'months')
moment().subtract(.7, 'years') == moment().subtract(8, 'months') //.7*12 = 8.4, rounded to 8

请注意，为了使操作 moment.add(-.5, 'days') 和 moment.subtract(.5, 'days') 等效，-.5、-1.5、-2.5 等将向下舍入。

moment().startOf(String);

通过将其设置为时间单位的开始来改变原始时刻。

moment().startOf('year');    // set to January 1st, 12:00 am this year
moment().startOf('month');   // set to the first of this month, 12:00 am
moment().startOf('quarter');  // set to the beginning of the current quarter, 1st day of months, 12:00 am
moment().startOf('week');    // set to the first day of this week, 12:00 am
moment().startOf('isoWeek'); // set to the first day of this week according to ISO 8601, 12:00 am
moment().startOf('day');     // set to 12:00 am today
moment().startOf('date');     // set to 12:00 am today
moment().startOf('hour');    // set to now, but with 0 mins, 0 secs, and 0 ms
moment().startOf('minute');  // set to now, but with 0 seconds and 0 milliseconds
moment().startOf('second');  // same as moment().milliseconds(0);

这些快捷方式本质上与以下内容相同。

moment().startOf('year');
moment().month(0).date(1).hours(0).minutes(0).seconds(0).milliseconds(0);

moment().startOf('hour');
moment().minutes(0).seconds(0).milliseconds(0)

从版本 2.0.0 开始，moment#startOf('day') 替换了 moment#sod。

注意： moment#startOf('week') 已在版本 2.0.0 中添加。

从版本 2.1.0 开始，moment#startOf('week') 使用区域感知的周开始日。

注意： moment#startOf('isoWeek') 已在版本 2.2.0 中添加。

注意： moment#startOf('date') 已在 2.13.0 中添加，作为 day 的别名

moment().endOf(String);

通过将其设置为时间单位的结束来改变原始时刻。

这与 moment#startOf 相同，只是它不是设置到时间单位的开始，而是设置到时间单位的结束。

moment().endOf("year"); // set the moment to 12-31 23:59:59.999 this year

从版本 2.0.0 开始，moment#endOf('day') 替换了 moment#eod。

注意： moment#endOf('week') 在版本 2.0.0 中添加。

从版本 2.1.0 开始，moment#endOf('week') 使用区域感知的一周开始日期。

moment().max(Moment|String|Number|Date|Array);

注意： 此函数已在 2.7.0 中弃用。请考虑使用 moment.min。

将时刻限制为另一个时刻值的较大值。因此，a.max(b) 与 a = moment.min(a, b) 相同（请注意，max 转换为 min）。

有时，服务器时钟与客户端时钟不同步。这最终会显示诸如“几秒钟后”而不是“几秒钟前”之类的拟人化字符串。你可以使用 moment#max() 来防止这种情况。

这是 moment#min 的对应项。

var momentFromServer = moment(input);
var clampedMoment = momentFromServer.max();

你可以将传递给 moment() 的任何内容传递给 moment#max。

moment().max(moment().add(1, 'd'));
moment().max("2013-04-20T20:00:00+0800");
moment().max("Jan 1 2001", "MMM D YYYY");
moment().max(new Date(2012, 1, 8));

moment().min(Moment|String|Number|Date|Array);

注意： 此函数已在 2.7.0 中弃用。请考虑使用 moment.max。

将时刻限制为另一个时刻值的较小值。因此，a.min(b) 与 a = moment.max(a, b) 相同（请注意，min 转换为 max）。

这是 moment#max 的对应项。

moment().min("2013-04-20T20:00:00+0800");

这可以与 moment#max 结合使用，将时刻限制在一定范围内。

var start  = moment().startOf('week');
var end    = moment().endOf('week');
var actual = moment().min(start).max(end);

moment().local();
moment().local(Boolean); // from 2.8.0

在原始时刻上设置一个标记，以使用本地时间显示时刻，而不是原始时刻的时间。

var a = moment.utc([2011, 0, 1, 8]);
a.hours(); // 8 UTC
a.local();
a.hours(); // 0 PST

本地时间也可以用来转换出固定偏移模式

moment.parseZone('2016-05-03T22:15:01+02:00').local().format(); // "2016-05-03T15:15:01-05:00"

传递 true 将更改时区，而不更改当前时间。

moment.parseZone('2016-05-03T22:15:01+02:00').local(true).format(); //"2016-05-03T22:15:01-05:00"

有关 UTC 模式的更多信息，请参阅 moment.utc()。

moment().utc();
moment().utc(Boolean); // from 2.8.0

在原始时刻上设置一个标记，以使用 UTC 显示时刻，而不是原始时刻的时间。

var a = moment([2011, 0, 1, 8]);
a.hours(); // 8 PST
a.utc();
a.hours(); // 16 UTC

UTC 也可以用来转换出固定偏移模式

moment.parseZone('2016-05-03T22:15:01+02:00').utc().format(); //"2016-05-03T20:15:01Z"

传递 true 将更改时区，而不更改当前时间。

moment.parseZone('2016-05-03T22:15:01+02:00').utc(true).format(); //"2016-05-03T22:15:01Z"

有关 UTC 模式的更多信息，请参阅 moment.utc()。

moment().utcOffset();
moment().utcOffset(Number|String);
moment().utcOffset(Number|String, Boolean);

获取或设置以分钟为单位的 UTC 偏移量。

注意： 与 moment.fn.zone 不同，此函数返回从 UTC 的实际偏移量，而不是反向偏移量（由 Date.prototype.getTimezoneOffset 返回）。

获取当前对象的 utcOffset

moment().utcOffset(); // (-240, -120, -60, 0, 60, 120, 240, etc.)

通过提供分钟数来设置 UTC 偏移量。偏移量设置在调用 utcOffset() 的时刻对象上。如果你想全局设置偏移量，请尝试使用 moment-timezone。请注意，一旦你设置了偏移量，它就是固定的，不会自行更改（即没有 DST 规则）。如果你想要一个实际的时区——特定位置的时间，如 America/Los_Angeles，请考虑 moment-timezone。

moment().utcOffset(120);

如果输入小于 16 且大于 -16，它会将你的输入解释为小时数。

// these are equivalent
moment().utcOffset(8);  // set hours offset
moment().utcOffset(480);  // set minutes offset (8 * 60)

也可以通过字符串设置 UTC 偏移量。

// these are equivalent
moment().utcOffset("+08:00");
moment().utcOffset(8);
moment().utcOffset(480);

moment#utcOffset 将在字符串中搜索 +00 -00 +00:00 +0000 -00:00 -0000 Z 的最后一次匹配，因此你甚至可以传递一个带有偏移量的 ISO8601 格式化的字符串，时刻将更改为该 UTC 偏移量。

请注意，如果字符串不包含 'Z'，则它必须包含 + 或 - 字符。

moment().utcOffset("2013-03-07T07:00:00+08:00");

utcOffset 函数有一个可选的第二个参数，它接受一个布尔值，表示是否保留现有时间。

• 传递 false（默认值）将保持世界时中的同一时刻，但本地时间将更改。

• 传递 true 将保持相同的地方时间，但代价是选择世界时中的一个不同点。

此功能的一个用途是，如果你想仅使用数字输入值构建具有特定时区偏移量的时刻

moment([2016, 0, 1, 0, 0, 0]).utcOffset(-5, true) // Equivalent to "2016-01-01T00:00:00-05:00"

moment().zone();
moment().zone(Number|String);

注意：此函数已在 2.9.0 中弃用。请考虑使用 moment.fn.utcOffset。

以分钟为单位获取时区偏移量。

moment().zone(); // (60, 120, 240, etc.)

从 2.1.0 版本开始，可以通过传入与格林尼治标准时间相差的分钟数来设置偏移量。

moment().zone(120);

如果输入小于 16 且大于 -16，它会将你的输入解释为小时数。

// these are equivalent
moment().zone(480);
moment().zone(8);

也可以通过字符串设置时区。

moment().zone("-08:00");

moment#zone 将搜索字符串以查找 +00:00 +0000 -00:00 -0000 的第一个匹配项，因此你甚至可以传递一个 ISO8601 格式化的字符串，并且时刻将更改为该时区。

moment().zone("2013-03-07T07:00:00-08:00");

完成解析和操作后，你需要某种方式来显示时刻。

moment().format();
moment().format(String);

这是最可靠的显示选项。它采用一个标记字符串并用它们相应的值替换它们。

moment().format();                                // "2014-09-08T08:02:17-05:00" (ISO 8601, no fractional seconds)
moment().format("dddd, MMMM Do YYYY, h:mm:ss a"); // "Sunday, February 14th 2010, 3:25:50 pm"
moment().format("ddd, hA");                       // "Sun, 3PM"
moment().format("[Today is] dddd");               // "Today is Sunday"
moment('gibberish').format('YYYY MM DD');         // "Invalid date"

X 已在 2.0.0 中添加。

e E gg gggg GG GGGG 已在 2.1.0 中添加。

x 已在 2.8.4 中添加。

SSSS 至 SSSSSSSSS 已在 2.10.5 中添加。它们显示 3 个有效数字，其余部分用零填充。

k 和 kk 已在 2.13.0 中添加。

本地化格式

由于首选格式因语言环境而异，因此有一些标记可用于根据其语言环境设置格式化 moment。

相同格式有大小写变体。小写版本旨在成为其大写对应版本的长格式。

l ll lll llll 可在 2.0.0 中使用。 LTS 已在 2.8.4 中添加。

转义字符

要转义格式字符串中的字符，你可以用方括号将字符括起来。

moment().format('[today] dddd'); // 'today Sunday'

与 LDML 的相似之处和不同之处

注意：虽然这些日期格式与 LDML 日期格式非常相似，但关于月份、年份和星期有一些细微差别。

有关不同语言环境中一些不同日期格式化标记的细分，请参阅 此日期格式化标记图表。

其他标记

如果你更习惯使用 strftime 而不是类似 LDML 的解析标记，则可以使用 Ben Oakes 的插件。 benjaminoakes/moment-strftime。

默认格式

不带格式调用 moment#format 将默认为 moment.defaultFormat。开箱即用，moment.defaultFormat 是 ISO8601 格式 YYYY-MM-DDTHH:mm:ssZ。

从版本 2.13.0 开始，在 UTC 模式下，默认格式由 moment.defaultFormatUtc 控制，格式为 YYYY-MM-DDTHH:mm:ss[Z]。它返回 Z 作为偏移量，而不是 +00:00。

在某些情况下，本地时区（例如 Atlantic/Reykjavik）可能为零偏移，并且会被视为 UTC。在这种情况下，设置 moment.defaultFormat 和 moment.defaultFormatUtc 以使用相同的格式可能很有用。

更改 moment.defaultFormat 的值只会影响格式化，而不会影响解析。例如

moment.defaultFormat = "DD.MM.YYYY HH:mm";
// parse with .toDate()
moment('20.07.2018 09:19').toDate() // Invalid date
// format the date string with the new defaultFormat then parse
moment('20.07.2018 09:19', moment.defaultFormat).toDate() // Fri Jul 20 2018 09:19:00 GMT+0300

moment().fromNow();
moment().fromNow(Boolean);

moment#fromNow 处理显示时间的常用方式。这有时称为时间前或相对时间。

moment([2007, 0, 29]).fromNow(); // 4 years ago

如果你传递 true，则可以获取没有后缀的值。

moment([2007, 0, 29]).fromNow();     // 4 years ago
moment([2007, 0, 29]).fromNow(true); // 4 years

基本字符串由 当前语言环境自定义。时间四舍五入到最接近的秒。

下表概述了针对每段时间显示哪个字符串的细分。

注意：从版本 2.10.3 开始，如果目标时刻对象无效，则结果为本地化的无效日期字符串。

注意：在 2.18.0 中添加了 ss 键。它是一个可选阈值。除非用户手动设置 ss 阈值，否则它永远不会显示。在设置 ss 阈值之前，它默认为 s 阈值减 1（因此，对用户不可见）。

moment().from(Moment|String|Number|Date|Array);
moment().from(Moment|String|Number|Date|Array, Boolean);

您可能希望显示与当前时间以外的时间相关的时间。在这种情况下，您可以使用 moment#from。

var a = moment([2007, 0, 28]);
var b = moment([2007, 0, 29]);
a.from(b) // "a day ago"

第一个参数是可以传递给 moment() 的任何内容或实际的 Moment。

var a = moment([2007, 0, 28]);
var b = moment([2007, 0, 29]);
a.from(b);                     // "a day ago"
a.from([2007, 0, 29]);         // "a day ago"
a.from(new Date(2007, 0, 29)); // "a day ago"
a.from("2007-01-29");          // "a day ago"

与 moment#fromNow 一样，将 true 作为第二个参数传递会返回没有后缀的值。这在您需要具有人类可读的时间长度时很有用。

var start = moment([2007, 0, 5]);
var end   = moment([2007, 0, 10]);
end.from(start);       // "in 5 days"
end.from(start, true); // "5 days"

从版本 2.10.3 开始，如果任何端点无效，则结果为本地化的无效日期字符串。

moment().toNow();
moment().toNow(Boolean);

显示时间的一种常见方式由 moment#toNow 处理。这有时称为 timeago 或相对时间。

这类似于 moment.fromNow，但给出了相反的间隔：a.fromNow() = - a.toNow()。

这类似于 moment.to，但对于当前时间是特殊情况。如果您想控制间隔的两个端点，请使用 moment.to。

moment([2007, 0, 29]).toNow(); // in 4 years

如果您传递 true，则可以获取没有前缀的值。

moment([2007, 0, 29]).toNow();     // in 4 years
moment([2007, 0, 29]).toNow(true); // 4 years

基本字符串由 当前语言环境自定义。

下表概述了针对每段时间显示哪个字符串的细分。

从版本 2.10.3 开始，如果目标时刻对象无效，则结果为本地化的无效日期字符串。

moment().to(Moment|String|Number|Date|Array);
moment().to(Moment|String|Number|Date|Array, Boolean);

您可能希望显示与当前时间以外的时间相关的时间。在这种情况下，您可以使用 moment#to。

var a = moment([2007, 0, 28]);
var b = moment([2007, 0, 29]);
a.to(b) // "in a day"

第一个参数是可以传递给 moment() 的任何内容或实际的 Moment。

var a = moment([2007, 0, 28]);
var b = moment([2007, 0, 29]);
a.to(b);                     // "in a day"
a.to([2007, 0, 29]);         // "in a day"
a.to(new Date(2007, 0, 29)); // "in a day"
a.to("2007-01-29");          // "in a day"

与 moment#toNow 一样，将 true 作为第二个参数传递会返回没有后缀的值。这在您需要具有人类可读的时间长度时很有用。

var start = moment([2007, 0, 5]);
var end   = moment([2007, 0, 10]);
end.to(start);       // "5 days ago"
end.to(start, true); // "5 days"

从版本 2.10.3 开始，如果任何端点无效，则结果为本地化的无效日期字符串。

moment().calendar();
moment().calendar(referenceDay);
moment().calendar(referenceDay, formats);  // from 2.10.5
moment().calendar(formats);  // from 2.25.0

日历时间显示相对于给定 referenceDay（默认为今天开始）的时间，但与 moment#fromNow 的方式略有不同。

moment#calendar 将根据日期与 referenceDay 的日期（默认情况下为今天）的接近程度，使用不同的字符串格式化日期。

这些字符串已本地化，并且 可以自定义。

从 2.10.5 开始，moment 支持为每个调用指定日历输出格式

moment().calendar(null, {
    sameDay: '[Today]',
    nextDay: '[Tomorrow]',
    nextWeek: 'dddd',
    lastDay: '[Yesterday]',
    lastWeek: '[Last] dddd',
    sameElse: 'DD/MM/YYYY'
});

当时刻距离 referenceDay 超过一周时，sameElse 用作格式

注意：从版本2.14.0开始，日历格式参数可以是一个回调，现在它在时刻上下文中使用单个参数执行

moment().calendar(null, {
  sameDay: function (now) {
    if (this.isBefore(now)) {
      return '[Will Happen Today]';
    } else {
      return '[Happened Today]';
    }
    /* ... */
  }
});

注意：从版本2.25.0开始，你只能传递一个格式参数，它可以是字符串和函数的对象

moment().calendar({
    sameDay: '[Today]',
    nextDay: '[Tomorrow]',
    nextWeek: 'dddd',
    lastDay: '[Yesterday]',
    lastWeek: '[Last] dddd',
    sameElse: 'DD/MM/YYYY'
});

moment().calendar({
  sameDay: function (now) {
    if (this.isBefore(now)) {
      return '[Will Happen Today]';
    } else {
      return '[Happened Today]';
    }
    /* ... */
  }
});

moment().diff(Moment|String|Number|Date|Array);
moment().diff(Moment|String|Number|Date|Array, String);
moment().diff(Moment|String|Number|Date|Array, String, Boolean);

若要以毫秒为单位获取差异，请使用moment#diff，就像使用moment#from一样。

var a = moment([2007, 0, 29]);
var b = moment([2007, 0, 28]);
a.diff(b) // 86400000

若要以其他测量单位获取差异，请将该测量值作为第二个参数传递。

var a = moment([2007, 0, 29]);
var b = moment([2007, 0, 28]);
a.diff(b, 'days') // 1

若要获取两个时刻之间差异的持续时间，你可以将diff作为参数传递给moment#duration。有关更多信息，请参阅moment#duration的文档。

支持的测量单位包括years、months、weeks、days、hours、minutes和seconds。为了便于开发，从2.0.0开始支持单数形式。1.1.1 版中提供了除毫秒以外的其他测量单位。

默认情况下，moment#diff会将结果截断为零位小数，返回一个整数。如果你想要一个浮点数，请将true作为第三个参数传递。在2.0.0之前，moment#diff返回一个四舍五入到最接近整数的数字，而不是一个截断的数字。

var a = moment([2008, 9]);
var b = moment([2007, 0]);
a.diff(b, 'years');       // 1
a.diff(b, 'years', true); // 1.75

如果时刻早于你传递给moment.fn.diff的时刻，则返回值将为负数。

var a = moment();
var b = moment().add(1, 'seconds');
a.diff(b) // -1000
b.diff(a) // 1000

一种简单的思考方式是用减号运算符替换.diff(。

          // a < b
a.diff(b) // a - b < 0
b.diff(a) // b - a > 0

月度和年度差异

moment#diff对月度和年度差异有一些特殊处理。它经过优化，以确保具有相同日期的两个月始终是整数间隔。

因此，1 月 15 日到 2 月 15 日应该正好是 1 个月。

2 月 28 日到 3 月 28 日应该正好是 1 个月。

2011 年 2 月 28 日到 2012 年 2 月 28 日应该正好是 1 年。

在此处查看有关月度和年度差异的更多讨论

对月度和年度差异的这一更改是在2.0.0中进行的。从版本2.9.0开始，diff 还支持季度单位。

moment().valueOf();
+moment();

moment#valueOf仅仅输出自 Unix Epoch 以来经过的毫秒数，就像Date#valueOf一样。

moment(1318874398806).valueOf(); // 1318874398806
+moment(1318874398806); // 1318874398806

若要从Moment获取 Unix 时间戳（自 Epoch 以来经过的秒数），请使用moment#unix。

注意：ECMAScript 将其称为“时间值”

moment().unix();

moment#unix输出 Unix 时间戳（自 Unix Epoch 以来经过的秒数）。

moment(1318874398806).unix(); // 1318874398

此值向下取整到最接近的秒，不包括毫秒部分。

moment().daysInMonth();

获取当前月份中的天数。

moment("2012-02", "YYYY-MM").daysInMonth() // 29
moment("2012-01", "YYYY-MM").daysInMonth() // 31

moment().toDate();

若要获取 Moment.js 封装的原生 Date 对象的副本，请使用moment#toDate。

这将返回时刻使用的Date的副本，因此对该Date的任何更改都不会导致时刻发生更改。如果你想更改时刻Date，请参阅moment#manipulate或moment#set。

moment#native 已被 moment#toDate 取代，并且已在 1.6.0 中弃用。

moment().toArray();

这会返回一个与 new Date() 的参数相对应的数组。

moment().toArray(); // [2013, 1, 4, 14, 40, 16, 154];

moment().toJSON();

在将对象序列化为 JSON 时，如果存在 Moment 对象，它将表示为 ISO8601 字符串，并调整为 UTC。

JSON.stringify({
    postDate : moment()
}); // '{"postDate":"2013-02-04T22:44:30.652Z"}'

如果你希望获得一个反映时刻的 utcOffset() 的 ISO8601 字符串，那么你可以像这样修改 toJSON 函数

moment.fn.toJSON = function() { return this.format(); }

这会将行为更改为以下内容

JSON.stringify({
    postDate : moment()
}); // '{"postDate":"2013-02-04T14:44:30-08:00"}'

moment().toISOString();
moment().toISOString(keepOffset); // from 2.20.0

将字符串格式化为 ISO8601 标准。

moment().toISOString() // 2013-02-04T22:44:30.652Z

请注意，.toISOString() 会返回一个 UTC 中的时间戳，即使所讨论的时刻处于本地模式。这样做是为了与本机 JavaScript Date .toISOString() 的规范保持一致，如 ES2015 规范 中所述。从版本 2.20.0 开始，你可以调用 .toISOString(true) 来防止 UTC 转换。

从版本 2.8.4 开始，出于性能原因，如果可用，将使用本机 Date.prototype.toISOString。

moment().toObject();

这会返回一个包含年、月、日、时、分、秒、毫秒的对象。

moment().toObject()  // {
                     //     years: 2015
                     //     months: 6
                     //     date: 26,
                     //     hours: 1,
                     //     minutes: 53,
                     //     seconds: 14,
                     //     milliseconds: 600
                     // }

moment().toString();

返回一个类似于 JS Date 的 .toString() 的英语字符串。

moment().toString() // "Sat Apr 30 2016 16:59:46 GMT-0500"

moment().inspect();

返回一个可机读的字符串，该字符串可以评估为生成相同的时刻。由于名称，它还用于节点交互式 shell 中以显示对象。

moment().inspect() // 'moment("2016-11-09T22:23:27.861")'
moment.utc().inspect() // 'moment.utc("2016-11-10T06:24:10.638+00:00")'
moment.parseZone('2016-11-10T06:24:12.958+05:00').inspect() // 'moment.parseZone("2016-11-10T06:24:12.958+05:00")'
moment(new Date('nope')).inspect() // 'moment.invalid(/* Invalid Date */)'
moment('blah', 'YYYY').inspect() // 'moment.invalid(/* blah */)'

注意：此函数主要用于调试，并非所有情况都能精确处理。

moment().isBefore(Moment|String|Number|Date|Array);
moment().isBefore(Moment|String|Number|Date|Array, String);

检查一个时刻是否在另一个时刻之前。第一个参数将被解析为一个时刻，如果不是的话。

moment('2010-10-20').isBefore('2010-10-21'); // true

如果你希望将粒度限制为毫秒以外的单位，请将单位作为第二个参数传递。

由于第二个参数决定了精度，而不仅仅是检查单个值，因此使用天将检查年、月和天。

moment('2010-10-20').isBefore('2010-12-31', 'year'); // false
moment('2010-10-20').isBefore('2011-01-01', 'year'); // true

与 moment#isAfter 和 moment#isSame 一样，moment#startOf 支持的任何时间单位都支持 moment#isBefore。

year month week isoWeek day hour minute second

如果没有将任何内容传递给 moment#isBefore，它将默认为当前时间。

注意：moment().isBefore() 的行为未定义，不应使用！如果代码运行得很快，最初创建的时刻将与在 isBefore 中创建的时刻相同以执行检查，因此结果将为 false。但是，如果代码运行得较慢，则有可能在 isBefore 中创建的时刻明显晚于在 moment() 中创建的时刻，因此调用将返回 true。

moment().isSame(Moment|String|Number|Date|Array);
moment().isSame(Moment|String|Number|Date|Array, String);

检查一个时刻是否与另一个时刻相同。第一个参数将被解析为一个时刻，如果不是的话。

moment('2010-10-20').isSame('2010-10-20'); // true

如果你希望将粒度限制为毫秒以外的单位，请将其作为第二个参数传递。

moment('2010-10-20').isSame('2009-12-31', 'year');  // false
moment('2010-10-20').isSame('2010-01-01', 'year');  // true
moment('2010-10-20').isSame('2010-12-31', 'year');  // true
moment('2010-10-20').isSame('2011-01-01', 'year');  // false

在包含第二个参数时，它将匹配所有相等或更大的单位。传递 month 将检查 month 和 year。传递 day 将检查 day、month 和 year。

moment('2010-01-01').isSame('2011-01-01', 'month'); // false, different year
moment('2010-01-01').isSame('2010-02-01', 'day');   // false, different month

与 moment#isAfter 和 moment#isBefore 一样，moment#startOf 支持的任何时间单位都支持 moment#isSame。

year month week isoWeek day hour minute second

如果两个时刻具有不同的时区，则在比较中将使用第一个时刻的时区。

// Note: Australia/Sydney is UTC+11:00 on these dates
moment.tz("2018-11-09T10:00:00", "Australia/Sydney").isSame(moment.tz("2018-11-08T12:00:00", "UTC"), "day"); // false
moment.tz("2018-11-08T12:00:00", "UTC").isSame(moment.tz("2018-11-09T10:00:00", "Australia/Sydney"), "day"); // true

注意：moment().isSame() 具有未定义的行为，不应使用！如果代码运行得很快，则最初创建的时刻将与在 isSame 中创建的时刻相同以执行检查，因此结果将为 true。但是，如果代码运行得较慢，则有可能在 isSame 中创建的时刻明显晚于在 moment() 中创建的时刻，因此调用将返回 false。

moment().isAfter(Moment|String|Number|Date|Array);
moment().isAfter(Moment|String|Number|Date|Array, String);

检查一个时刻是否在另一个时刻之后。如果尚未解析，则第一个参数将被解析为一个时刻。

moment('2010-10-20').isAfter('2010-10-19'); // true

如果你希望将粒度限制为毫秒以外的单位，请将单位作为第二个参数传递。

由于第二个参数决定了精度，而不仅仅是检查单个值，因此使用天将检查年、月和天。

moment('2010-10-20').isAfter('2010-01-01', 'year'); // false
moment('2010-10-20').isAfter('2009-12-31', 'year'); // true

与 moment#isSame 和 moment#isBefore 类似，moment#startOf 支持的任何时间单位都支持 moment#isAfter。

year month week isoWeek day hour minute second

如果没有传递给 moment#isAfter，则它将默认为当前时间。

moment().isAfter(); // false

moment().isSameOrBefore(Moment|String|Number|Date|Array);
moment().isSameOrBefore(Moment|String|Number|Date|Array, String);

检查一个时刻是否在另一个时刻之前或与另一个时刻相同。如果尚未解析，则第一个参数将被解析为一个时刻。

moment('2010-10-20').isSameOrBefore('2010-10-21');  // true
moment('2010-10-20').isSameOrBefore('2010-10-20');  // true
moment('2010-10-20').isSameOrBefore('2010-10-19');  // false

如果你希望将粒度限制为毫秒以外的单位，请将单位作为第二个参数传递。

由于第二个参数决定了精度，而不仅仅是检查单个值，因此使用天将检查年、月和天。

moment('2010-10-20').isSameOrBefore('2009-12-31', 'year'); // false
moment('2010-10-20').isSameOrBefore('2010-12-31', 'year'); // true
moment('2010-10-20').isSameOrBefore('2011-01-01', 'year'); // true

与 moment#isAfter 和 moment#isSame 类似，moment#startOf 支持的任何时间单位都支持 moment#isSameOrBefore。

year month week isoWeek day hour minute second

moment().isSameOrAfter(Moment|String|Number|Date|Array);
moment().isSameOrAfter(Moment|String|Number|Date|Array, String);

检查一个时刻是否在另一个时刻之后或与另一个时刻相同。如果尚未解析，则第一个参数将被解析为一个时刻。

moment('2010-10-20').isSameOrAfter('2010-10-19'); // true
moment('2010-10-20').isSameOrAfter('2010-10-20'); // true
moment('2010-10-20').isSameOrAfter('2010-10-21'); // false

如果你希望将粒度限制为毫秒以外的单位，请将单位作为第二个参数传递。

由于第二个参数决定了精度，而不仅仅是检查单个值，因此使用天将检查年、月和天。

moment('2010-10-20').isSameOrAfter('2011-12-31', 'year'); // false
moment('2010-10-20').isSameOrAfter('2010-01-01', 'year'); // true
moment('2010-10-20').isSameOrAfter('2009-12-31', 'year'); // true

与 moment#isSame 和 moment#isBefore 类似，moment#startOf 支持的任何时间单位都支持 moment#isSameOrAfter。

year month week isoWeek day hour minute second

//From 2.13.0 onward
moment().isBetween(moment-like, moment-like);
moment().isBetween(moment-like, moment-like, String);
moment().isBetween(moment-like, moment-like, String, String);
// where moment-like is Moment|String|Number|Date|Array

//2.9.0 to 2.12.0
moment().isBetween(moment-like, moment-like);
moment().isBetween(moment-like, moment-like, String);
// where moment-like is Moment|String|Number|Date|Array

检查一个时刻是否在另外两个时刻之间，可以选择查看单位刻度（分钟、小时、天等）。匹配是排他的。如果尚未解析，则前两个参数将被解析为时刻。

moment('2010-10-20').isBetween('2010-10-19', '2010-10-25'); // true
moment('2010-10-20').isBetween('2010-10-19', undefined); // true, since moment(undefined) evaluates as moment()

请注意，两个参数的顺序很重要：“较小”的日期应在第一个参数中。

moment('2010-10-20').isBetween('2010-10-19', '2010-10-25'); // true
moment('2010-10-20').isBetween('2010-10-25', '2010-10-19'); // false

如果要将粒度限制为毫秒以外的单位，请将单位作为第三个参数传递。

moment('2010-10-20').isBetween('2010-01-01', '2012-01-01', 'year'); // false
moment('2010-10-20').isBetween('2009-12-31', '2012-01-01', 'year'); // true

与 moment#isSame、moment#isBefore、moment#isAfter 类似，moment#startOf 支持的任何时间单位都支持 moment#isBetween。年、月、周、isoWeek、天、小时、分钟和秒。

2.13.0 版本引入了包含性。[ 表示包含一个值。( 表示排除。如果使用了包含性参数，则必须传递两个指示符。

moment('2016-10-30').isBetween('2016-10-30', '2016-12-30', undefined, '()'); //false
moment('2016-10-30').isBetween('2016-10-30', '2016-12-30', undefined, '[)'); //true
moment('2016-10-30').isBetween('2016-01-01', '2016-10-30', undefined, '()'); //false
moment('2016-10-30').isBetween('2016-01-01', '2016-10-30', undefined, '(]'); //true
moment('2016-10-30').isBetween('2016-10-30', '2016-10-30', undefined, '[]'); //true

请注意，如果 from 和 to 参数相同，但包含性参数不同，则将优先考虑 false。

moment('2016-10-30').isBetween('2016-10-30', '2016-10-30', undefined, '(]'); //false

如果未指定包含性参数，则 Moment 将默认为 ()。

moment().isDST();

moment#isDST 检查当前时刻是否为夏令时。

注意：此函数是 HACK。moment 无法知道给定的时间是否处于实际的 DST 中。时区中的一些时间更改与 DST 相关，而另一些则不相关，并且如果没有完整的时区信息，它就无法知道。

Moment 目前会检查冬令时和夏令时，如果偏移量与夏令时偏移量匹配（并且夏令时偏移量与冬令时偏移量不同），则会报告夏令时。这在大多数情况下都能奏效，但如上所述，这不是“正确的”，并且无法适用于所有情况。因此，不要向我们抱怨。

事件 moment-timezone（在撰写本文时为 0.5.37）不支持夏令时信息（即时钟在给定时刻是否正式处于夏令时），因此为了让事情变得更好，moment-timezone 中必须发生一些新变化（以及 tzdata 捆绑）。

moment([2011, 2, 12]).isDST(); // false, March 12 2011 is not DST
moment([2011, 2, 14]).isDST(); // true, March 14 2011 is DST
// This example is for "en" locale: https://www.timeanddate.com/time/dst/2011.html

moment('2013-03-10 2:30', 'YYYY-MM-DD HH:mm').isDSTShifted()

注意：从版本 2.14.0 起，此函数已弃用。在修改 moment 对象后，它不会给出正确的答案。有关更多信息，请参阅 moment/3160

另一项重要的验证是了解日期是否因夏令时而发生变化。例如，在美国大部分地区

moment('2013-03-10 2:30', 'YYYY-MM-DD HH:mm').format(); //=> '2013-03-10T01:30:00-05:00'

这是因为夏令时将时间从 2:00 调整到 3:00，因此 2:30 不是一个真实的时间。结果时间取决于浏览器，可以向前或向后调整时间。使用 moment#isDSTShifted 来测试此条件。

注意：在 2.3.0 之前，处于此条件下的 Moment 对象始终为 moment#isValid 返回 false；现在它们返回 true。

moment().isLeapYear();

如果该年份是闰年，moment#isLeapYear 返回 true，如果不是，则返回 false。

moment([2000]).isLeapYear() // true
moment([2001]).isLeapYear() // false
moment([2100]).isLeapYear() // false

moment.isMoment(obj);

要检查变量是否是 moment 对象，请使用 moment.isMoment()。

moment.isMoment() // false
moment.isMoment(new Date()) // false
moment.isMoment(moment()) // true

从版本 2.11.0 起，您还可以通过 instanceof 运算符来测试 moment 对象

moment() instanceof moment // true

moment.isDate(obj);

要检查变量是否是原生 js Date 对象，请使用 moment.isDate()。

moment.isDate(); // false
moment.isDate(new Date()); // true
moment.isDate(moment()); // false

Moment.js 对国际化有强大的支持。

您可以加载多个语言环境，并在它们之间轻松切换。

除了分配全局语言环境外，您还可以将语言环境分配给特定的 moment。

// From 2.8.1 onward
moment.locale(String);
moment.locale(String[]);
moment.locale(String, Object);

// Deprecated in 2.8.1
moment.lang(String);
moment.lang(String[]);
moment.lang(String, Object);

默认情况下，Moment.js 附带英语（美国）语言环境字符串。如果您需要其他语言环境，可以将它们加载到 Moment.js 中以供以后使用。

要加载语言环境，请将键和字符串值传递给 moment.locale。

有关语言环境包的每个部分的更多详细信息，请参阅 自定义 部分。

moment.locale('fr', {
    months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
    monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
    monthsParseExact : true,
    weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
    weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
    weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
    weekdaysParseExact : true,
    longDateFormat : {
        LT : 'HH:mm',
        LTS : 'HH:mm:ss',
        L : 'DD/MM/YYYY',
        LL : 'D MMMM YYYY',
        LLL : 'D MMMM YYYY HH:mm',
        LLLL : 'dddd D MMMM YYYY HH:mm'
    },
    calendar : {
        sameDay : '[Aujourd’hui à] LT',
        nextDay : '[Demain à] LT',
        nextWeek : 'dddd [à] LT',
        lastDay : '[Hier à] LT',
        lastWeek : 'dddd [dernier à] LT',
        sameElse : 'L'
    },
    relativeTime : {
        future : 'dans %s',
        past : 'il y a %s',
        s : 'quelques secondes',
        m : 'une minute',
        mm : '%d minutes',
        h : 'une heure',
        hh : '%d heures',
        d : 'un jour',
        dd : '%d jours',
        M : 'un mois',
        MM : '%d mois',
        y : 'un an',
        yy : '%d ans'
    },
    dayOfMonthOrdinalParse : /\d{1,2}(er|e)/,
    ordinal : function (number) {
        return number + (number === 1 ? 'er' : 'e');
    },
    meridiemParse : /PD|MD/,
    isPM : function (input) {
        return input.charAt(0) === 'M';
    },
    // In case the meridiem units are not separated around 12, then implement
    // this function (look at locale/id.js for an example).
    // meridiemHour : function (hour, meridiem) {
    //     return /* 0-23 hour, given meridiem token and hour 1-12 */ ;
    // },
    meridiem : function (hours, minutes, isLower) {
        return hours < 12 ? 'PD' : 'MD';
    },
    week : {
        dow : 1, // Monday is the first day of the week.
        doy : 4  // Used to determine first week of the year.
    }
});

有关 week.dow 和 week.doy 的详细信息，请参阅 自定义 部分。

加载语言环境后，它将成为活动语言环境。要更改活动语言环境，只需使用已加载语言环境的键调用 moment.locale。

moment.locale('fr');
moment(1316116057189).fromNow(); // il y a une heure
moment.locale('en');
moment(1316116057189).fromNow(); // an hour ago

从 2.21.0 起，如果语言环境不可用，Moment 将 console.warn。

从 2.8.0 起，更改全局语言环境不会影响现有实例。

moment.locale('fr');
var m = moment(1316116057189);
m.fromNow(); // il y a une heure

moment.locale('en');
m.fromNow(); // il y a une heure
moment(1316116057189).fromNow(); // an hour ago

moment.locale 返回所使用的语言环境。这很有用，因为如果 Moment 不知道您指定的语言环境，它不会更改语言环境。

moment.locale('fr'); // 'fr'
moment.locale('tq'); // 'fr'

您还可以指定语言环境列表，Moment 将使用它具有本地化功能的第一个语言环境。

moment.locale(['tq', 'fr']); // 'fr'

Moment 还会尝试从最具体到最不具体的语言环境限定符子字符串，直到找到它知道的语言环境。当向 Moment 提供从用户环境中提取的语言环境字符串（例如 window.navigator.language）时，这很有用。

moment.locale('en-nz'); // 'en'

最后，Moment 将通过语言环境数组及其子字符串进行智能搜索。

moment.locale(['en-nz', 'en-au']); // 'en-au', not 'en'

逻辑如下 - 选择下一个语言环境并按原样尝试。如果失败，代码通常会尝试切断最后一位（通常是国家/地区代码）并再次尝试。但是，如果下一个数组元素与要尝试的元素具有相同或更长的前缀，则迭代继续。因此，例如，如果数组具有以下序列

"AA-BB", "AA-CC", "XX-YY"

然后首先尝试“AA-BB”，然后一个简单的解决方案会尝试“AA”，但这个解决方案会检查“AA-CC”实际上比“AA”更具体，所以它接下来会尝试“AA-CC”，并且只有在它失败（如果它失败）后才会尝试“AA”，因为“XX-YY”没有“AA”作为前缀。因此，最终会按以下顺序尝试以下语言环境（假设全部失败，所以会尝试下一个）

"AA-BB", "AA-CC", "AA", "XX-YY", "XX"

// From version 2.8.1 onward
moment().locale(String|String[]|Boolean);

// Deprecated version 2.8.1
moment().lang(String|String[]|Boolean);

当传递可能需要格式化为不同语言环境的时刻时，全局语言环境配置可能会出现问题。

moment.locale('en'); // default the locale to English
var localLocale = moment();

localLocale.locale('fr'); // set this instance to use French
localLocale.format('LLLL'); // dimanche 15 juillet 2012 11:01
moment().format('LLLL'); // Sunday, July 15 2012 11:01 AM

moment.locale('es'); // change the global locale to Spanish
localLocale.format('LLLL'); // dimanche 15 juillet 2012 11:01
moment().format('LLLL'); // Domingo 15 Julio 2012 11:01

localLocale.locale(['tq', 'fr']); // set this instance to the first localization found
localLocale.format('LLLL'); // dimanche 15 juillet 2012 11:01
moment().format('LLLL'); // Sunday, July 15 2012 11:01 AM

localLocale.locale(false); // reset the instance locale
localLocale.format('LLLL'); // Domingo 15 Julio 2012 11:01
moment().format('LLLL'); // Domingo 15 Julio 2012 11:01

如果您不带任何参数调用moment#locale，您会得到将用于该时刻的语言环境配置。

var fr = moment().locale('fr');
fr.localeData().months(moment([2012, 0])) // "janvier"
fr.locale('en');
fr.localeData().months(moment([2012, 0])) // "January"

如果您需要访问某个时刻的语言环境数据，这是首选方式。

从2.3.0开始，您还可以指定一个语言环境标识符数组。它与全局语言环境配置中的工作方式相同。

moment.locale(String);

在 NodeJS 中加载语言环境非常容易。如果moment/locale/中有一个以该键命名的语言环境文件，首先导入它，然后调用moment.locale来加载它。

var moment = require('moment');
//or
// import moment from 'moment';

// import locale file(s)
import 'moment/locale/fr';

moment.locale('fr');
moment(1316116057189).fromNow(); // il y a 6 ans

为了节省加载各个语言环境的步骤（即只加载所有语言环境），请导入moment/min/moment-with-locales模块。

import moment from 'moment/min/moment-with-locales';

moment.locale('de');
moment(1316116057189).fromNow(); // vor 6 Jahren

如果您希望支持您的语言环境，请创建一个包含必需的语言环境和单元测试文件的拉取请求到develop分支。

// From 2.8.1 onward
moment.locale(String, Object);

// Deprecated in 2.8.1
moment.lang(String, Object);

在浏览器中加载语言环境只需要您包含语言环境文件。务必指定字符集以防止编码问题。

<script src="moment.js"></script>
<script src="locale/fr.js" charset="UTF-8"></script>
<script src="locale/pt.js" charset="UTF-8"></script>
<script>
  moment.locale('fr');  // Set the default/global locale
  // ...
</script>

所有语言环境都有精简版本

<script src="moment.js"></script>
<script src="min/locales.js" charset="UTF-8"></script>

为了最大程度减少 HTTP 请求，请使用我们的 Grunt 任务使用自定义语言环境列表编译Moment

grunt transpile:fr,it

<script src="min/moment-with-locales.custom.js" charset="UTF-8"></script>

如果您使用 JSPM 作为插件管理器，您应该在您的 lib 中添加语言环境。

import * as moment from 'moment';
import 'moment/locale/fr';

注意：语言环境文件以UMD样式定义，因此它们应该可以在所有环境中无缝工作。

要将您的语言环境添加到 Moment.js，请提交一个拉取请求，其中包含语言环境文件和测试文件。您可以在moment/src/locale/fr.js和moment/src/test/locale/fr.js中找到示例。

要在 Node.js 中运行测试，请执行npm install，然后执行grunt。

如果所有测试都通过，请提交一个拉取请求，并感谢您的贡献！

// From version 2.8.1 onward
moment.locale();

// Deprecated in version 2.8.1
moment.lang();

如果您经常更改语言环境，您可能想知道当前正在使用什么语言环境。这就像不带任何参数调用moment.locale一样简单。

moment.locale('en'); // set to english
moment.locale(); // returns 'en'
moment.locale('fr'); // set to french
moment.locale(); // returns 'fr'

从版本2.12.0开始，可以列出已加载且可用的所有语言环境

moment.locales()

moment.months()
moment.monthsShort()
moment.weekdays()
moment.weekdaysShort()
moment.weekdaysMin()

有时获取语言环境中的月份或星期几列表很有用，例如在填充下拉菜单时。

moment.months();

返回当前语言环境中的月份列表。

[ 'January',
  'February',
  'March',
  'April',
  'May',
  'June',
  'July',
  'August',
  'September',
  'October',
  'November',
  'December' ]

类似地，moment.monthsShort返回缩写的月份名称，而moment.weekdays、moment.weekdaysShort、moment.weekdaysMin返回星期几列表。

您可以将一个整数传递到这些函数中的每一个中，以获取特定的月份或星期几。

moment.weekdays(3); // 'Wednesday'

从2.13.0开始，可以将布尔值作为星期函数的第一个参数传递。如果为 true，则会以特定于区域设置的顺序返回星期。例如，在阿拉伯语区域设置中，星期六是一周的第一天，因此

moment.locale('ar');
moment.weekdays(true); // lists weekdays Saturday-Friday in Arabic
moment.weekdays(true, 2); //will result in Monday in Arabic

注意：如果没有特定于区域设置的参数，则星期始终以星期日作为索引 0，而不管一周的第一天在当地是什么时候。

在格式化月份名称时，一些区域设置会考虑特殊情况。例如，荷兰语格式化月份缩写时不会带有尾随句点，但仅当它在破折号之间格式化月份时。months 方法支持传递格式，以便在适当的上下文中列出月份。

moment.locale('nl');
moment.monthsShort(); // ['jan.', 'feb.', 'mrt.', ...]
moment.monthsShort('-MMM-'); // [ 'jan', 'feb', 'mrt', ...]

最后，可以同时组合格式选项和整数选项。

moment.monthsShort('-MMM-', 3); // 'apr'

localeData = moment.localeData()
localeData.months(Moment)
localeData.months()
localeData.monthsShort(Moment)
localeData.monthsShort()
localeData.monthsParse(String)
localeData.weekdays(Moment)
localeData.weekdays()
localeData.weekdays(Boolean)      ## Added 2.24.0, sorts weekdays by locale
localeData.weekdaysShort(Moment)
localeData.weekdaysShort()
localeData.weekdaysShort(Boolean) ## Added 2.24.0, sorts weekdays by locale
localeData.weekdaysMin(Moment)
localeData.weekdaysMin()
localeData.weekdaysMin(Boolean)   ## Added 2.24.0, sorts weekdays by locale
localeData.weekdaysParse(String)
localeData.longDateFormat(String)
localeData.isPM(String)
localeData.meridiem(Number, Number, Boolean)
localeData.calendar(String, Moment)
localeData.relativeTime(Number, Boolean, String, Boolean)
localeData.pastFuture(Number, String)
localeData.ordinal(Number)
localeData.preparse(String)
localeData.postformat(String)
localeData.week(Moment)
localeData.invalidDate()
localeData.firstDayOfWeek()
localeData.firstDayOfYear()

可以通过 moment.localeData(key) 函数访问当前加载的区域设置的属性。它返回当前区域设置或具有给定键的区域设置

// get current locale
var currentLocaleData = moment.localeData();
var frLocaleData = moment.localeData('fr');

返回的对象具有以下方法

localeData.months(aMoment);  // full month name of aMoment
localeData.monthsShort(aMoment);  // short month name of aMoment
localeData.monthsParse(longOrShortMonthString);  // returns month id (0 to 11) of input
localeData.weekdays(aMoment);  // full weekday name of aMoment
localeData.weekdaysShort(aMoment);  // short weekday name of aMoment
localeData.weekdaysMin(aMoment);  // min weekday name of aMoment
localeData.weekdaysParse(minShortOrLongWeekdayString);  // returns weekday id (0 to 6) of input
localeData.longDateFormat(dateFormat);  // returns the full format of abbreviated date-time formats LT, L, LL and so on
localeData.isPM(amPmString);  // returns true iff amPmString represents PM
localeData.meridiem(hours, minutes, isLower);  // returns am/pm string for particular time-of-day in upper/lower case
localeData.calendar(key, aMoment);  // returns a format that would be used for calendar representation. Key is one of 'sameDay', 'nextDay', 'lastDay', 'nextWeek', 'prevWeek', 'sameElse'
localeData.relativeTime(number, withoutSuffix, key, isFuture);  // returns relative time string, key is on of 's', 'm', 'mm', 'h', 'hh', 'd', 'dd', 'M', 'MM', 'y', 'yy'. Single letter when number is 1.
localeData.pastFuture(diff, relTime);  // convert relTime string to past or future string depending on diff
localeData.ordinal(number);  // convert number to ordinal string 1 -> 1st
localeData.preparse(str);  // called before parsing on every input string
localeData.postformat(str);  // called after formatting on every string
localeData.week(aMoment);  // returns week-of-year of aMoment
localeData.invalidDate();  // returns a translation of 'Invalid date'
localeData.firstDayOfWeek();  // 0-6 (Sunday to Saturday)
localeData.firstDayOfYear();  // 0-15 Used to determine first week of the year.

可以在自定义部分中找到有关 firstDayOfYear 的详细信息。

moment.locale('x-pseudo')

从2.13.0版本开始，moment 可选择包含一个伪区域设置。此区域设置将使用非常明显更改的数据填充日期。伪区域设置在测试时非常有用，因为它们可以清楚地表明哪些数据已本地化，哪些数据尚未本地化。只需包含伪区域设置，并将 moment 的区域设置设置为 x-pseudo。Moment 中的文本将很容易被发现。

moment.locale('x-pseudo');
moment().format('LLL'); //14 F~ébrú~árý 2010 15:25
moment().fromNow(); //'á ~féw ~sécó~ñds á~gó'
moment().calendar(); //'T~ódá~ý át 02:00'

Moment.js 非常容易自定义。通常，你应该使用自定义设置创建区域设置。

moment.locale('en-my-settings', {
    // customizations.
});

可以通过将 null 作为第二个参数传递来删除先前定义的区域设置。已删除的区域设置将不再可用。

moment.locale('fr'); // 'fr'
moment.locale('en'); // 'en'
moment.locale('fr', null);
moment.locale('fr'); // 'en'

从2.12.0开始，可以创建继承自父区域设置的区域设置。

moment.defineLocale('en-foo', {
  parentLocale: 'en',
  /* */
});

未在区域设置中指定的属性将从父区域设置中继承。

从2.16.0开始，可以定义一个区域设置，其父区域设置本身尚未定义或加载。

moment.defineLocale('fakeLocale', {parentLocale:'xyz'})

从2.21.0开始，当尝试使用新定义的区域设置创建 moment 时，moment 将尝试延迟加载父区域设置（如果存在）。如果失败，它将默认将父区域设置设为全局区域设置。

从2.12.0开始，还可以更新区域设置的属性。

moment.updateLocale('en', {
  /**/
});

将更新任何指定属性，而其他属性将保持不变。此函数不影响已存在的 moment。请注意，调用 updateLocale 还会将当前全局区域设置更改为已更新的区域设置；有关更多信息，请参阅此 GitHub 问题。

要还原更新，请使用

moment.updateLocale('en', null);

2.12.0 已弃用使用 moment.locale() 来更改现有区域设置。请改用 moment.updateLocale()。

// From 2.12.0 onward
moment.updateLocale('en', {
    months : String[]
});
moment.updateLocale('en', {
    months : Function
});
moment.updateLocale('en', {
    months : {
        format : String[],
        standalone : String[]
    }
});
// From 2.11.0
moment.locale('en', {
    months : {
        format : String[],
        standalone : String[]
    }
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    months : String[]
});
moment.locale('en', {
    months : Function
});

// Deprecated in 2.8.1
moment.lang('en', {
    months : String[]
});
moment.lang('en', {
    months : Function
});

Locale#months 应为月份名称的数组。

moment.updateLocale('en', {
    months : [
        "January", "February", "March", "April", "May", "June", "July",
        "August", "September", "October", "November", "December"
    ]
});

如果需要更多处理来计算月份的名称（例如，如果不同格式有不同的语法），则 Locale#months 可以是具有以下签名的函数。它应该总是返回一个月份名称。

moment.updateLocale('en', {
    months : function (momentToFormat, format) {
        // momentToFormat is the moment currently being formatted
        // format is the formatting string
        if (/^MMMM/.test(format)) { // if the format starts with 'MMMM'
            return nominative[momentToFormat.month()];
        } else {
            return subjective[momentToFormat.month()];
        }
    }
});

从2.11.0版本开始，月份还可以是一个对象，指定standalone和format形式（主格和宾格）。在格式上运行的正则表达式以检查是否使用format形式是/D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/。从2.14.0版本开始，可以使用 isFormat 键指定不同的正则表达式。

moment.updateLocale('en', {
    months : {
         format: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split('_'),
         standalone: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split('_'),
         isFormat: /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?|MMMM?(\[[^\[\]]*\]|\s+)+D[oD]?/  // from 2.14.0
    }
});

// From 2.12.0 onward
moment.updateLocale('en', {
    monthsShort : String[]
});
moment.updateLocale('en', {
    monthsShort : Function
});
moment.updateLocale('en', {
    monthsShort : {
        format: String[],
        standalone : String[]
    }
});
// From 2.11.0
moment.locale('en', {
    monthsShort : {
        format: String[],
        standalone : String[]
    }
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    monthsShort : String[]
});
moment.locale('en', {
    monthsShort : Function
});

// Deprecated in 2.8.1
moment.lang('en', {
    monthsShort : String[]
});
moment.lang('en', {
    monthsShort : Function
});

Locale#monthsShort 应为月份缩写的数组。

moment.updateLocale('en', {
    monthsShort : [
        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    ]
});

与 Locale#months 类似，Locale#monthsShort 也可作为回调函数。

moment.updateLocale('en', {
    monthsShort : function (momentToFormat, format) {
        if (/^MMMM/.test(format)) {
            return nominative[momentToFormat.month()];
        } else {
            return subjective[momentToFormat.month()];
        }
    }
});

注意：从版本 2.11.0 开始，与 Locale#months 类似，Locale#monthsShort 可以是一个包含 standalone 和 format 情况的对象。

moment.updateLocale('en', {
    monthsShort : {
        format: 'янв_фев_мар_апр_мая_июня_июля_авг_сен_окт_ноя_дек'.split('_'),
        standalone: 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_')
    }
});

// From version 2.12.0 onward
moment.updateLocale('en', {
    weekdays : String[]
});
moment.updateLocale('en', {
    weekdays : Function
});
moment.updateLocale('en', {
    weekdays : {
        standalone : String[],
        format : String[],
        isFormat : RegExp
    }
});
// From version 2.11.0
moment.locale('en', {
    weekdays : {
        standalone : String[],
        format : String[],
        isFormat : Boolean
    }
});
// From version 2.8.1 to 2.11.2
moment.locale('en', {
    weekdays : String[]
});
moment.locale('en', {
    weekdays : Function
});

// Deprecated version 2.8.1
moment.lang('en', {
    weekdays : String[]
});
moment.lang('en', {
    weekdays : Function
});

Locale#weekdays 应为星期名称数组。

moment.updateLocale('en', {
    weekdays : [
        "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
    ]
});

Locale#weekdays 也可作为回调函数。

moment.updateLocale('en', {
    weekdays : function (momentToFormat, format) {
        return weekdays[momentToFormat.day()];
    }
});

注意：从版本 2.11.0 开始，还可以传递格式/独立情况。isFormat 将针对完整格式字符串使用，以确定使用哪种形式。

moment.updateLocale('en', {
    weekdays : {
        standalone: 'Воскресенье_Понедельник_Вторник_Среда_Четверг_Пятница_Суббота'.split('_'),
        format: 'Воскресенье_Понедельник_Вторник_Среду_Четверг_Пятницу_Субботу'.split('_'),
        isFormat: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/
    }
});

// From 2.12.0 onward
moment.updateLocale('en', {
    weekdaysShort : String[]
});
moment.updateLocale('en', {
    weekdaysShort : Function
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    weekdaysShort : String[]
});
moment.locale('en', {
    weekdaysShort : Function
});

// Deprecated in 2.8.1
moment.lang('en', {
    weekdaysShort : String[]
});
moment.lang('en', {
    weekdaysShort : Function
});

Locale#weekdaysShort 应为星期缩写数组。

moment.updateLocale('en', {
    weekdaysShort : ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
});

Locale#weekdaysShort 也可作为回调函数。

moment.updateLocale('en', {
    weekdaysShort : function (momentToFormat, format) {
        return weekdaysShort[momentToFormat.day()];
    }
});

// From 2.12.0 onward
moment.updateLocale('en', {
    weekdaysMin : String[]
});
moment.updateLocale('en', {
    weekdaysMin : Function
});

// From 2.8.1 to 2.11.2
moment.locale('en', {
    weekdaysMin : String[]
});
moment.locale('en', {
    weekdaysMin : Function
});

// Deprecated in 2.8.1
moment.lang('en', {
    weekdaysMin : String[]
});
moment.lang('en', {
    weekdaysMin : Function
});

Locale#weekdaysMin 应为两位星期缩写数组。这些缩写的目的是用于日历选择器等，因此应尽可能短。

moment.updateLocale('en', {
    weekdaysMin : ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]
});

Locale#weekdaysMin 也可作为回调函数。

moment.updateLocale('en', {
    weekdaysMin : function (momentToFormat, format) {
        return weekdaysMin[momentToFormat.day()];
    }
});

// From 2.12.0 onward
moment.updateLocale('en', {
    weekdaysMin : String[]
});
moment.updateLocale('en', {
    weekdaysMin : Function
});

// From 2.8.1 to 2.11.2
moment.locale('en', {
    longDateFormat : Object
});

// Deprecated in 2.8.1
moment.lang('en', {
    longDateFormat : Object
});

Locale#longDateFormat 应为一个对象，其中包含每个长日期格式 L LL LLL LLLL LT LTS 的键/值对。LT 应为时间格式，也用于 moment#calendar。

moment.updateLocale('en', {
    longDateFormat : {
        LT: "h:mm A",
        LTS: "h:mm:ss A",
        L: "MM/DD/YYYY",
        l: "M/D/YYYY",
        LL: "MMMM Do YYYY",
        ll: "MMM D YYYY",
        LLL: "MMMM Do YYYY LT",
        lll: "MMM D YYYY LT",
        LLLL: "dddd, MMMM Do YYYY LT",
        llll: "ddd, MMM D YYYY LT"
    }
});

你可以消除小写 l 令牌，它们将通过用短令牌变体替换长令牌自动创建。

moment.updateLocale('en', {
    longDateFormat : {
        LT: "h:mm A",
        LTS: "h:mm:ss A",
        L: "MM/DD/YYYY",
        LL: "MMMM Do YYYY",
        LLL: "MMMM Do YYYY LT",
        LLLL: "dddd, MMMM Do YYYY LT"
    }
});

// From 2.12.0 onward
moment.updateLocale('en', {
    relativeTime : Object
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    relativeTime : Object
});

// Deprecated in 2.8.1
moment.lang('en', {
    relativeTime : Object
});

Locale#relativeTime 应为 moment#from 替换字符串的对象。

moment.updateLocale('en', {
    relativeTime : {
        future: "in %s",
        past:   "%s ago",
        s  : 'a few seconds',
        ss : '%d seconds',
        m:  "a minute",
        mm: "%d minutes",
        h:  "an hour",
        hh: "%d hours",
        d:  "a day",
        dd: "%d days",
        w:  "a week",
        ww: "%d weeks",
        M:  "a month",
        MM: "%d months",
        y:  "a year",
        yy: "%d years"
    }
});

Locale#relativeTime.future 指未来日期的前缀/后缀，Locale#relativeTime.past 指过去日期的前缀/后缀。对于所有其他情况，单个字符指单数，双字符指复数。

如果语言环境需要对令牌进行其他处理，它可以将令牌设置为具有以下签名的函数。该函数应返回一个字符串。

function (number, withoutSuffix, key, isFuture) {
    return string;
}

key 参数指 Locale#relativeTime 对象中的替换键。（例如 s m mm h 等）

number 参数指该键的单位数。对于 m，该数字为分钟数等。

如果令牌将显示为无后缀，则 withoutSuffix 参数为 true，如果将显示为有后缀，则为 false。（反向逻辑的原因是因为默认行为是显示为有后缀。）

如果要使用未来后缀/前缀，则 isFuture 参数为 true，如果要使用过去前缀/后缀，则为 false。

注意：对 w 和 ww 的处理已在 2.25.0 中添加。

// From 2.12.0 onward
moment.updateLocale('en', {
    meridiem : Function
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    meridiem : Function
});

// Deprecated in 2.8.1
moment.lang('en', {
    meridiem : Function
});

如果你的语言环境使用“am/pm”，则可以省略 Locale#meridiem，因为这些值是默认值。

如果你的语言环境需要对 am/pm 进行任何不同的计算，则 Locale#meridiem 应为一个回调函数，该函数根据小时、分钟和大写/小写返回正确的字符串。

moment.updateLocale('zh-cn', {
    meridiem : function (hour, minute, isLowercase) {
        if (hour < 9) {
            return "早上";
        } else if (hour < 11 && minute < 30) {
            return "上午";
        } else if (hour < 13 && minute < 30) {
            return "中午";
        } else if (hour < 18) {
            return "下午";
        } else {
            return "晚上";
        }
    }
});

// From 2.12.0 onward
moment.updateLocale('en', {
    meridiemParse : RegExp
    isPM : Function
});

// From 2.8.1 to 2.11.2
moment.locale('en', {
    meridiemParse : RegExp
    isPM : Function
});

// Deprecated in 2.8.1
moment.lang('en', {
    meridiemParse : RegExp
    isPM : Function
});

如果输入字符串超过下午 12 点，Locale#isPM 应返回 true。这用于解析 a A 令牌。

moment.updateLocale('en', {
    isPM : function (input) {
        return ((input + '').toLowerCase()[0] === 'p');
    }
});

若要配置应解析为输入的字符串，请设置 meridiemParse 属性。

moment.updateLocale('en', {
    meridiemParse : /[ap]\.?m?\.?/i
});

// From 2.12.0 onward
moment.updateLocale('en', {
    calendar : Object
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    calendar : Object
});

// Deprecated in 2.8.1
moment.lang('en', {
    calendar : Object
});

Locale#calendar 应具有以下格式化字符串。

moment.locale('en', {
    calendar : {
        lastDay : '[Yesterday at] LT',
        sameDay : '[Today at] LT',
        nextDay : '[Tomorrow at] LT',
        lastWeek : '[last] dddd [at] LT',
        nextWeek : 'dddd [at] LT',
        sameElse : 'L'
    }
});

Locale#calendar 的每个键也可以是回调函数，其作用域为当前时刻，第一个参数是表示现在的时刻。它应返回格式化字符串。

function callback (now) {
    return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
}

moment.calendarFormat = Function

这允许您修改 日历 使用的令牌。

moment.calendarFormat = function (myMoment, now) {
    var diff = myMoment.diff(now, 'days', true);
    var nextMonth = now.clone().add(1, 'month');

    var retVal =  diff < -6 ? 'sameElse' :
        diff < -1 ? 'lastWeek' :
        diff < 0 ? 'lastDay' :
        diff < 1 ? 'sameDay' :
        diff < 2 ? 'nextDay' :
        diff < 7 ? 'nextWeek' :
        // introduce thisMonth and nextMonth
        (myMoment.month() === now.month() && myMoment.year() === now.year()) ? 'thisMonth' :
        (nextMonth.month() === myMoment.month() && nextMonth.year() === myMoment.year()) ? 'nextMonth' : 'sameElse';
    return retVal;
};

// From 2.12.0 onward
moment.updateLocale('en', {
    ordinal : Function
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    ordinal : Function
});

// Deprecated in 2.8.1
moment.lang('en', {
    ordinal : Function
});

Locale#ordinal 应为返回给定数字的序数的函数。

moment.updateLocale('en', {
    ordinal : function (number, token) {
        var b = number % 10;
        var output = (~~ (number % 100 / 10) === 1) ? 'th' :
            (b === 1) ? 'st' :
            (b === 2) ? 'nd' :
            (b === 3) ? 'rd' : 'th';
        return number + output;
    }
});

从 2.0.0 开始，序数函数应返回数字和序数。以前，只返回序数。

从 2.1.0 开始，添加了令牌参数。它是正在序数化的令牌的字符串，例如：M 或 d。

有关序数的更多信息，请参阅 维基百科。

moment.relativeTimeThreshold(unit);  // getter
moment.relativeTimeThreshold(unit, limit);  // setter

duration.humanize 具有阈值，用于定义何时将单位视为一分钟、一小时等。例如，默认情况下，超过 45 秒被视为一分钟，超过 22 小时被视为一天，依此类推。若要更改这些截止值，请使用 moment.relativeTimeThreshold(unit, limit)，其中 unit 是 ss、s、m、h、d、w、M 之一。

  // Retrieve existing thresholds
  moment.relativeTimeThreshold('ss'); // 44
  moment.relativeTimeThreshold('s');  // 45
  moment.relativeTimeThreshold('m');  // 45
  moment.relativeTimeThreshold('h');  // 22
  moment.relativeTimeThreshold('d');  // 26
  moment.relativeTimeThreshold('w');  // null (disabled)
  moment.relativeTimeThreshold('M');  // 11

  // Set new thresholds
  moment.relativeTimeThreshold('s', 40);
  moment.relativeTimeThreshold('ss', 3);
  moment.relativeTimeThreshold('m', 40);
  moment.relativeTimeThreshold('h', 20);
  moment.relativeTimeThreshold('d', 25);
  moment.relativeTimeThreshold('w', 4);  // enables weeks
  moment.relativeTimeThreshold('M', 10);

注意：周单位已在 2.25.0 中添加。默认情况下不使用（设置为 null），但您可以将其设置为非 null 值，并且（可选）将 d 设置得更低，以便它从天过渡到周更早。

注意：在 2.8.1 中添加了检索阈值。

注意：在 2.18.0 中添加了检索和设置 ss 阈值。

moment.relativeTimeRounding();  // getter
moment.relativeTimeRounding(fn);  // setter

duration.humanize 在将可能双精度值提供给区域设置中指定的相对时间格式字符串之前对其进行舍入。若要控制舍入，可以使用 moment.relativeTimeRounding。

var roundingDefault = moment.relativeTimeRounding();

// Round relative time evaluation down
moment.relativeTimeRounding(Math.floor);

moment.relativeTimeThreshold('s', 60);
moment.relativeTimeThreshold('m', 60);
moment.relativeTimeThreshold('h', 24);
moment.relativeTimeThreshold('d', 7);
moment.relativeTimeThreshold('w', 4);
moment.relativeTimeThreshold('M', 12);

var a = moment();
a.subtract({hours: 23, minutes: 59, seconds: 59});
a.toNow();  // == 'in 23 hours'  'Round down towards the nearest hour'

// back to default
moment.relativeTimeRounding(roundingDefault);

您甚至可以选择根本不舍入

var retainValue = function (value) {
    return value;
};
moment.relativeTimeRounding(retainValue);

var a = moment();
a.subtract({hours: 39});
a.toNow(); // == 'in 1.625 days', 'Round down towards the nearest year'

moment.now = function () { return +new Date(); }

如果您想更改 Moment 看到的时间，可以指定一个方法，该方法返回自 Unix 纪元（1970 年 1 月 1 日）以来的毫秒数。

默认值为

moment.now = function () {
    return +new Date();
}

当调用 moment() 时将使用此值，并且在从 format() 中省略令牌时使用的当前日期。通常，任何需要当前时间的方法都在底层使用此方法。

// From 2.12.0 onward
moment.updateLocale('en', {
    week : {
        dow : Int,
        doy : Int
     }
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    week : {
        dow : Int,
        doy : Int
    }
});

// Deprecated in 2.8.1
moment.lang('en', {
    week : {
        dow : Int,
        doy : Int
    }
});

Locale#week.dow 应为一个整数，表示一周的第一天，0 是星期日，1 是星期一，...，6 是星期六。

Locale#week.doy 应为一个整数。doy 与 dow 一起用于确定一年的第一周。doy 计算为 7 + dow - janX，其中 janX 是必须属于一年第一周的一月第一天。

// ISO-8601, Europe
moment.updateLocale("en", { week: {
  dow: 1, // First day of week is Monday
  doy: 4  // First week of year must contain 4 January (7 + 1 - 4)
}});

// US, Canada
moment.updateLocale("en", { week: {
  dow: 0, // First day of week is Sunday
  doy: 6  // First week of year must contain 1 January (7 + 0 - 1)
}});

// Many Arab countries
moment.updateLocale("en", { week: {
  dow: 6, // First day of week is Saturday
  doy: 12 // First week of year must contain 1 January (7 + 6 - 1)
}});

// Also common
moment.updateLocale("en", { week: {
  dow: 1, // First day of week is Monday
  doy: 7  // First week of year must contain 1 January (7 + 1 - 1)
}});

moment.updateLocale('en', {
    eras: [{
        since:  '0001-01-01',
        until:  +Infinity,
        offset: 1,
        name:   'Anno Domini',
        narrow: 'AD',
        abbr:   'AD'
    }, {
        until:   -Infinity,
        since:  '0000-12-31',
        offset: 1,
        name:   'Before Christ',
        narrow: 'BC',
        abbr:   'BC'
    }],
});

为特定区域设置指定纪元。纪元是一个具有名称和年份编号的时间间隔。绝对年份编号（如 2020）也可以指定为 2020 AD：公元纪元的第 2020 年。类似地，绝对年份编号 -0500 可以描述为 501 BC，即公元前纪元的第 501 年。

eras: [{
    since:  '0001-01-01', // the start of the era
    until:  +Infinity,    // the end of the era, can be +/-Infinity
    offset: 1,            // added to year to (mostly) avoid 0 era years
    name:   'Anno Domini',// full name of era
    narrow: 'AD',         // narrow name of era
    abbr:   'AD'          // abbreviated name of era
}]

since 和 until 管理纪元的方向。就像 BC 的情况一样，它朝向 -Infinity 增长，因此 since > until。对于朝向 +Infinity 递增的纪元，since < until。

使用 yo、y* 和 N* 令牌完成纪元的解析/格式化。

注意：与纪元相关的 API 可能会有所更改。

// From 2.12.0 onward
moment.updateLocale('en', {
    invalidDate : String
});

// From 2.8.1 to 2.11.2
moment.locale('en', {
    invalidDate : String
});

// Deprecated in 2.8.1
moment.lang('en', {
    invalidDate : String
});

Locale#invalidDate 应该是一个字符串。

moment.updateLocale("es", {
  invalidDate: "Fecha invalida"
});

Moment.js 也有持续时间对象。其中时刻被定义为时间中的一个点，而持续时间被定义为时间长度。

持续时间没有定义的开始和结束日期。它们是无上下文的。

持续时间在概念上更类似于“2 小时”，而不是“今天下午 2 点到 4 点”。因此，它们不是在依赖于上下文的单位之间进行转换的良好解决方案。

例如，一年可以定义为 366 天、365 天、365.25 天、12 个月或 52 周。在没有上下文的情况下尝试将年转换为天是没有意义的。使用 moment#diff 计算两个时刻之间的天数或年数比使用 Durations 更好。

正如 此处所讨论的，Moment.js 的持续时间格式与 ISO 8601 标称持续时间和 RFC 5545 持续时间的规范略有不同。

moment.duration(Number, String);
moment.duration(Number);
moment.duration(Object);
moment.duration(String);
moment.duration(String, String); // 2.25.0

要创建持续时间，请使用毫秒为单位的时间长度调用 moment.duration()。

moment.duration(100); // 100 milliseconds

如果你想使用毫秒以外的测量单位创建时刻，你也可以传递测量单位。

moment.duration(2, 'seconds');
moment.duration(2, 'minutes');
moment.duration(2, 'hours');
moment.duration(2, 'days');
moment.duration(2, 'weeks');
moment.duration(2, 'months');
moment.duration(2, 'years');
moment.duration('2', 'years'); // from 2.25.0

moment#add 和 moment#subtract 的相同简写也适用于此处。

与 moment#add 非常相似，如果你需要多个不同的测量单位，你可以传递一个值对象。

moment.duration({
    seconds: 2,
    minutes: 2,
    hours: 2,
    days: 2,
    weeks: 2,
    months: '2',
    years: '2'
});

从 2.1.0 开始，moment 支持解析 ASP.NET 样式的时间跨度。支持以下格式。

格式是一个小时、分钟、秒字符串，用冒号分隔，如 23:59:59。天数可以用点分隔符作为前缀，如下所示 7.23:59:59。部分秒也受支持 23:59:59.999。

moment.duration('23:59:59');
moment.duration('23:59:59.999');
moment.duration('7.23:59:59.999');
moment.duration('23:59'); // added in 2.3.0

从 2.3.0 开始，moment 还支持解析 ISO 8601 持续时间。

moment.duration('P1Y2M3DT4H5M6S');
moment.duration('P1M');

从 2.11.0 开始，支持在日期和其余部分之间带有空格的持续时间格式字符串。

moment.duration('7 23:59:59.999');

从 2.13.0 开始，在解析持续时间时支持混合的负号和正号。

moment.duration('PT-6H3M')

从 2.18.0 开始，支持无效持续时间，类似于无效时刻。要创建无效持续时间，你可以为单位的值传递 NaN。

在即将发布的版本中，预计无效持续时间将涵盖更多情况（如单位的空值）。

moment.duration(NaN);
moment.duration(NaN, 'days');
moment.duration.invalid();

moment.duration().clone();

创建持续时间的克隆。持续时间是可变的，就像时刻对象一样，所以这让你可以在某个时间点获取快照。

var d1 = moment.duration();
var d2 = d1.clone();
d1.add(1, 'second');
d1.asMilliseconds() !== d2.asMilliseconds();

moment.duration().humanize();
moment.duration().humanize(withSuffix);
moment.duration().humanize(withSuffix, thresholds); // from 2.25.0
moment.duration().humanize(thresholds);             // from 2.25.0

有时，你想要 moment#from 的所有优点，但你不想创建两个时刻，你只想显示时间长度。

输入 moment.duration().humanize()。

moment.duration(1, "minutes").humanize(); // a minute
moment.duration(2, "minutes").humanize(); // 2 minutes
moment.duration(24, "hours").humanize();  // a day

默认情况下，返回字符串描述持续时间 a month（无后缀）。如果你想要一个定向持续时间 in a month、a month ago（带后缀），请如下所示传入 true。

moment.duration(1, "minutes").humanize(true); // in a minute

对于当前时间之前的后缀，传递一个负数。

moment.duration(-1, "minutes").humanize(true); // a minute ago

无效的持续时间将被本地化为 无效日期。

moment.duration.invalid().humanize(); // Invalid Date

人性化输出可以用相对时间阈值进行配置。要为特定的人性化调用指定阈值，请将它们作为唯一参数或后缀参数传递

moment.duration(-1, 'week').humanize(true, {d: 7, w: 4}); // a week ago
moment.duration(-1, 'week').humanize({d: 7, w: 4}); // a week

注意：在人性化中传递阈值已在 2.25.0 中添加。

moment.duration().milliseconds();
moment.duration().asMilliseconds();

要获取持续时间中的毫秒数，请使用 moment.duration().milliseconds()。

它将返回 0 到 999 之间的一个数字。

moment.duration(500).milliseconds(); // 500
moment.duration(1500).milliseconds(); // 500
moment.duration(15000).milliseconds(); // 0

如果你想要持续时间的长度（以毫秒为单位），请使用 moment.duration().asMilliseconds()。

moment.duration(500).asMilliseconds(); // 500
moment.duration(1500).asMilliseconds(); // 1500
moment.duration(15000).asMilliseconds(); // 15000

moment.duration().seconds();
moment.duration().asSeconds();

要获取持续时间中的秒数，请使用 moment.duration().seconds()。

它将返回 0 到 59 之间的一个数字。

moment.duration(500).seconds(); // 0
moment.duration(1500).seconds(); // 1
moment.duration(15000).seconds(); // 15

如果你想要持续时间的长度（以秒为单位），请使用 moment.duration().asSeconds()。

moment.duration(500).asSeconds(); // 0.5
moment.duration(1500).asSeconds(); // 1.5
moment.duration(15000).asSeconds(); // 15

moment.duration().minutes();
moment.duration().asMinutes();

与持续时间的其他 getter 一样，moment.duration().minutes() 获取分钟（0 - 59）。

moment.duration().asMinutes() 获取持续时间的长度（以分钟为单位）。

moment.duration().hours();
moment.duration().asHours();

与持续时间的其他 getter 一样，moment.duration().hours() 获取小时（0 - 23）。

moment.duration().asHours() 获取持续时间的长度（以小时为单位）。

moment.duration().days();
moment.duration().asDays();

与持续时间的其他 getter 一样，moment.duration().days() 获取天数（0 - 30）。

moment.duration().asDays() 获取持续时间的长度（以天为单位）。

moment.duration().weeks();
moment.duration().asWeeks();

与持续时间的其他 getter 一样，moment.duration().weeks() 获取周数（0 - 4）。

moment.duration().asWeeks() 获取持续时间的长度（以周为单位）。

请注意，与持续时间的其他 getter 不同，周被计为天数的一个子集，并且不会从天数中扣除。

注意：持续时间的长度（以周为单位）定义为 7 天。

moment.duration().months();
moment.duration().asMonths();

与持续时间的其他 getter 一样，moment.duration().months() 获取月数（0 - 11）。

moment.duration().asMonths() 获取持续时间的长度（以月为单位）。

moment.duration().years();
moment.duration().asYears();

与持续时间的其他 getter 一样，moment.duration().years() 获取年数。

moment.duration().asYears() 获取持续时间的长度（以年为单位）。

moment.duration().add(Number, String);
moment.duration().add(Number);
moment.duration().add(Duration);
moment.duration().add(Object);

通过添加时间来改变原始持续时间。

用于创建持续时间的相同键和速记可以在这里用作第二个参数。

var a = moment.duration(1, 'd');
var b = moment.duration(2, 'd');
a.add(b).days(); // 3

请注意，将无效持续时间添加到任何其他持续时间会导致无效持续时间。

moment.duration().subtract(Number, String);
moment.duration().subtract(Number);
moment.duration().subtract(Duration);
moment.duration().subtract(Object);

通过减去时间来改变原始持续时间。

用于创建持续时间的相同键和速记可以在这里用作第二个参数。

var a = moment.duration(3, 'd');
var b = moment.duration(2, 'd');
a.subtract(b).days(); // 1

请注意，将无效持续时间添加到任何其他持续时间会导致无效持续时间。

var duration = moment.duration(x.diff(y))

你还可以将持续时间与 moment#diff 一起使用，以获取两个时刻之间的持续时间。要做到这一点，只需将 moment#diff 方法传递到 moment#duration 中，如下所示

  var x = new moment()
  var y = new moment()
  var duration = moment.duration(x.diff(y))
  // returns duration object with the duration between x and y

有关 moment#diff 的更多信息，请参见此处。

moment.duration().as(String);

作为 Duration#asX 的替代，你可以使用 Duration#as('x')。所有来自 moment#add 的速记键也适用于这里。

duration.as('hours');
duration.as('minutes');
duration.as('seconds');
duration.as('milliseconds');

无效持续时间返回所有单位的 NaN。

moment.duration().get(String);

作为 Duration#x() 获取器的替代方案，您可以使用 Duration#get('x')。所有 来自 moment#add 的简写键 也适用于此处。

duration.get('hours');
duration.get('minutes');
duration.get('seconds');
duration.get('milliseconds');

无效持续时间返回所有单位的 NaN。

moment.duration().toJSON();

将持续时间对象序列化为 JSON 时，它将表示为 ISO8601 字符串。

JSON.stringify({
    postDuration : moment.duration(5, 'm')
}); // '{"postDuration":"PT5M"}'

无效的持续时间返回 Invalid Date 作为 JSON 表示。

moment.isDuration(obj);

要检查变量是否为 moment 持续时间对象，请使用 moment.isDuration()。

moment.isDuration() // false
moment.isDuration(new Date()) // false
moment.isDuration(moment()) // false
moment.isDuration(moment.duration()) // true
moment.isDuration(moment.duration(2, 'minutes')) // true

moment.duration().toISOString();

以 ISO 8601 标准 指定的字符串形式返回持续时间。

moment.duration(1, 'd').toISOString() // "P1D"

格式 PnYnMnDTnHnMnS 说明

moment.duration().locale();
moment.duration().locale(String);

您可以使用 locale(...) 获取或设置持续时间的语言环境。语言环境将影响持续时间的字符串方法，例如 humanize()。有关国际化的更多信息，请参阅 intl 部分。

moment.duration(1, "minutes").locale("en").humanize(); // a minute
moment.duration(1, "minutes").locale("fr").humanize(); // une minute
moment.duration(1, "minutes").locale("es").humanize(); // un minuto

humanize() 中的后缀也已国际化

moment.duration(1, "minutes").locale("en").humanize(true); // in a minute
moment.duration(1, "minutes").locale("fr").humanize(true); // dans une minute
moment.duration(1, "minutes").locale("es").humanize(true); // en un minuto

moment.duration(-1, "minutes").locale("en").humanize(true); // a minute ago
moment.duration(-1, "minutes").locale("fr").humanize(true); // il y a une minute
moment.duration(-1, "minutes").locale("es").humanize(true); // hace un minuto

Moment 公开了某些方法，这些方法可能对扩展库或编写自定义解析器的人员有用。

moment.normalizeUnits(String);

Moment 的许多函数允许调用者传递单位枚举的别名。例如，以下所有 get 都相等。

var m = moment();
m.get('y');
m.get('year');
m.get('years');

如果您要扩展库，您可能希望访问 Moment 的设施，以便更好地将您的功能与 Moment 对齐。

moment.normalizeUnits('y');      // 'year'
moment.normalizeUnits('Y');      // 'year'
moment.normalizeUnits('year');   // 'year'
moment.normalizeUnits('years');  // 'year'
moment.normalizeUnits('YeARS');  // 'year'

moment.invalid(Object);

您可以创建您自己的无效 Moment 对象，这在制作您自己的解析器时很有用。

var m = moment.invalid();
m.isValid();                      // false
m.format();                       // 'Invalid date'
m.parsingFlags().userInvalidated; // true

invalid 还接受一个指定要设置哪些解析标志的对象。这不会设置 userInvalidated 解析标志，除非它是指定的属性之一。

var m = moment.invalid({invalidMonth: 'Actober'});
m.parsingFlags().invalidMonth; // 'Actober'

您不必指定 Moment 识别的解析标志；Moment 仍然无效，并且解析标志将由 parsingFlags() 返回。

其他人为 Moment.js 制作了一些插件，这些插件可能对您有用。

npm install moment-strftime

如果您更习惯使用 strftime 而不是类似 LDML 的解析标记，您可以使用 Ben Oakes 的插件 moment-strftime。

存储库位于 github.com/benjaminoakes/moment-strftime。

如果您在 .NET 中使用 OLE 自动化日期，请查看 Markit On Demand 的 moment-msdate。使用此插件允许您将 OA 日期格式化为 JavaScript 日期，反之亦然。

将 moment 转换为 OA 日期

moment().toOADate(); // a floating point number

或者，将 OA 日期转换为 moment

moment.fromOADate(41493); // Wed Aug 07 2013 00:00:00 GMT-0600 (MDT)

可以在 GitHub 上的 http://markitondemand.github.io/moment-msdate/ 找到更多信息和详细文档。

npm install moment-jdateformatparser

如果您想使用 java.text.DateFormat，可以使用此插件。

例如，

moment("2013-12-24 14:30").formatWithJDF("dd.MM.yyyy");  // returns the formatted date "24.12.2013"
moment().toJDFString("DD.MM.YYYY");  // returns the Java format pattern "dd.MM.yyyy"

存储库位于 github.com/MadMG/moment-jdateformatparser。

npm install moment-range

如果您需要使用日期范围，可以使用 Gianni Chiappetta 的插件 moment-range。

可以在主页 github.com/rotaready/moment-range 上找到文档。

它还可以在下面的存储库中用于网络。

该存储库位于 github.com/rotaready/moment-range。

npm install twix

另一个范围插件是 Isaac Cambron 的库 Twix。它具有许多与范围相关的特性，并且擅长以可读的方式格式化范围。例如：

var t = moment("1/25/1982 9:30 AM").twix("1/25/1982 1:30 PM");
t.isCurrent(); // false
t.count('minutes'); // 241
t.format();  // 'Jan 25, 1982, 9:30 AM - 1:30 PM'
t.simpleFormat("h:m"); // '9:30 - 1:30'

所有选项和特性的完整文档 在此。

它在 npm 上可用，如下所示

npm install twix

或只需从 此处 获取 JS 文件。

npm install moment-precise-range-plugin

由 Rob Dawson 编写的 精确范围 插件可用于显示日期/时间范围的确切、人类可读的表示形式

moment("2014-01-01 12:00:00").preciseDiff("2015-03-04 16:05:06");
 // 1 year 2 months 3 days 4 hours 5 minutes 6 seconds

moment.preciseDiff("2014-01-01 12:00:00", "2014-04-20 12:00:00");
// 3 months 19 days

要获取原始数字值而不是字符串，请将值 true 作为第三个参数传递给该方法

moment.preciseDiff(m1, m2, true); 
// {years : 0, months : 1, days : 2, hours : 3, minutes : 4, seconds : 5, firstDateWasLater : false}

npm install moment-isocalendar

如果您正在寻找类似 Python 的 isocalendar 方法，则可以使用 Rocky Meza 的插件

moment-isocalendar

对 moment 调用 isocalendar 方法将返回一个类似以下内容的数组

[year, week_of_year, day_of_week, minutes_since_midnight]

moment().isocalendar(); // [2012, 8, 5, 870]

您还可以从 isocalendar 数组重建 moment。

moment.fromIsocalendar([2011, 51, 5, 870]).format('LLLL');
// "Friday, December 23 2011 2:30 PM"

该存储库位于 github.com/fusionbox/moment-isocalendar。

npm install moment-jalaali

如果您想使用 Jalali 日历系统（Jalali、Persian、Khorshidi 或 Shamsi），则可以使用 Behrang Noruzi Niya 的插件 moment-jalaali。

安装后，它将包装 moment，并且 moment 将能够格式化和解析 Jalali 年份和月份。这是一个简短的示例

var m = moment('1360/5/26', 'jYYYY/jM/jD'); // Parse a Jalaali date.
m.format('jYYYY/jM/jD [is] YYYY/M/D'); // 1360/5/26 is 1981/8/17

该存储库位于 github.com/behrang/moment-jalaali。

npm install moment-hijri

如果您想使用 Hijri 日历，则可以使用 moment-hijri 插件。moment-hijri 是基于 Umm al-Qura 计算的 Hijri 农历的 moment 插件。此插件由 Suhail Alkowaileet 开发。

安装后，它将包装 moment，您将能够解析 Hijri 日期。这是一个简短的示例

m = moment('1410/8/28', 'iYYYY/iM/iD'); // Parse a Hijri date.
m.format('iYYYY/iM/iD [is] YYYY/M/D'); // 1410/8/28 is 1990/3/25

该存储库位于 github.com/xsoh/moment-hijri。

npm install moment-islamic-civil

这是另一个 Hijri 日历（基于民用计算）。

该存储库位于 github.com/ACGC/moment-islamic-civil。

npm install moment-recur

如果您需要处理重复日期，则可以使用 Casey Trimm 的插件 moment-recur。

此插件将允许您创建基于长度的间隔（天、周等）和基于日历的间隔（daysOfMonth、monthsOfYear 等）。

它提供了一个 matches 函数来测试日期是否根据设置的规则重复，以及生成器函数来获取系列中的下一个和上一个日期。

可以在 github.com/c-trimm/moment-recur 找到存储库、文档和更多示例

var interval = moment( "01/01/2014" ).recur().every(2).days(); // Length Interval
interval.matches( "01/03/2014" ); // true
interval.next( 2, "L" ); // ["01/03/2014", "01/05/2014"]
interval.forget( "days" ); // Remove a rule
interval.dayOfMonth( 10 ); // Calendar Interval
interval.matches( "05/10/2014" ); // true
interval.previous( 2, "L" ); // ["12/10/2013", "11/10/2013"]

如果您尝试以 Twitter 的方式为推文格式化时间，则可以使用 moment.twitter 插件，作者是 @hijonathan。

这是一种显示人类可读时间戳的简短和长版本的简单方法。

moment().subtract(5, 'hours').twitterLong();
// 5 hours

是的，它确实实现了智能复数形式。

moment().subtract(1, 'hour').twitterLong();
// 1 hour

对您来说还不够简短？

moment().subtract(6, 'days').twitterShort();
// 6d

如果您需要 财政、日历或学术季度，则可以使用 moment-fquarter 插件，作者是 @robgallen。

最简单的方法是在任何 moment 对象上调用 fquarter 方法。它返回一个格式化的字符串，其中 4 月为第一季度。

moment("2013-01-01").fquarter();
// Q4 2012/13

您可以将任何月份作为起始季度，例如 7 月

moment("2013-01-01").fquarter(7);
// Q3 2012/13

如果您想要日历季度，请从 1 月开始

moment("2013-01-01").fquarter(1);
// Q1 2013

npm install moment-parseformat

此插件提取日期/时间字符串的格式。

var format = moment.parseFormat('Thursday, February 6th, 2014 9:20pm');
// dddd, MMMM Do, YYYY h:mma
moment().format(format); // format

这允许创建智能日期输入，让您的用户设置日期/时间，并允许您提取用户首选的格式以供将来使用。在 minutes.io 找到它的示例用法。

此插件由 @gr2m 编写。链接：演示 | 源代码

npm install moment-round

此插件将日期/时间舍入到给定的间隔。

例如，

require('moment-round');
var m = new moment(); // 2015-06-18 15:30:19
m.round(5, 'seconds'); // 2015-06-18 15:30:20
m.ceil(3, 'minutes'); // 2015-06-18 15:33:00
m.floor(16, 'hours'); // 2015-06-18 00:00:00
m.ceil(21, 'hours'); // 2015-06-18 21:00:00
m.ceil(20, 'hours'); // 2015-06-19 00:00:00

存储库位于 github.com/WebDevTmas/moment-round。

bower install moment-transform

moment-transform 是一个通过模式操作日期的插件。您可以在 Moment 实例的各个部分（小时、月份等）上使用基本操作（设置/添加/减去）。

moment().transform('YYYY-MM-+01 00:00:00.000'); // Tonight at midnight
moment().transform('14:30:00.000'); // Today, 2:30 pm
moment().transform('YYYY-MM--30 00:00:00.000'); // 30 days ago

可选参数允许您指定自定义模式并强制严格模式使用（默认情况下，传递的字符串中非字母字符不是必需的）。

moment().transform('+01MMYYYY', 'DD/MM/YYYY', false); // Tomorrow, same time
moment().transform('+01MMYYYY', 'DD/MM/YYYY', true); // Invalid date

您可以在 此处 实时查看它，而存储库 位于此处。

npm install moment-taiwan

如果您想使用台湾日历系统，可以使用 Bradwoo8621 的插件 moment-taiwan。

安装后，它将包装 moment，并且 moment 将能够格式化和解析台湾年份。这是一个简短的示例

m = moment('104/01/01', 'tYY/MM/DD') // Parse a Taiwan date
m.format('tYY/MM/DD [is] YYYY/M/D') // 104/01/01 is 2015/01/01

m.twYear() // 104

存储库位于 github.com/bradwoo8621/moment-taiwan。

npm install moment-duration-format

这是一个允许对 Moment 持续时间进行全面格式化的插件。

例如，

moment.duration(123, "minutes").format("h:mm");
// "2:03"

存储库位于 github.com/jsmreese/moment-duration-format。

npm install moment-timer

这是一个 Moment.js 插件，允许使用计时器，它比本机 JavaScript 计时器提供了更多的控制。它基本上是 JavaScripts 自己 setInterval 和 setTimeout 的重写。

例如，

var timer = moment.duration(5, "seconds").timer({loop: true}, function() {
  // Callback
});

存储库位于 github.com/SeverinDK/moment-timer。

npm install moment-business

这是一个 Moment.js 库，允许对西方工作周进行 Moment 操作：7 天工作周，其中周六和周日为非工作日。

例如，

import business from 'moment-business';

// true if the moment is Mon-Fri, false otherwise
business.isWeekDay(someMoment);

// Adds five work days to the Moment
business.addWeekDays(someMoment, 5);

存储库位于 github.com/jmeas/moment-business。

如果您想以简短的方式格式化时间，可以使用 moment-shortformat 插件，作者为 @researchgate。

它基于 moment.twitter 插件，与之类似，但有不同的输出。

moment().subtract(5, 'hours').short();
// 5h ago
moment().add(5, 'hours').short();
// in 5h

您还可以禁用 相对时间模板 的使用

moment().subtract(1, 'hour').short(false);
// 1h

如果日期太远在未来或过去，它将显示如下

moment().subtract(500, 'days').short();
// 5 Mar, 1970

npm install moment-feiertage --save

这是 (moment-feiertage) 一个 Moment.js 插件，用于确定日期是否是德国假期。假期取自维基百科 (de)。确定日期是否是假期有点复杂，因为宗教节日每年都在变化，并且在 16 个德国州之间有所不同。

由 DaniSchenk 制作。

var someDateInSomeStates = moment('2018-11-01').isHoliday(['BW', 'SH', 'TH']);
/* returns {
  allStates: false,
  holidayName: 'Allerheiligen',
  holidayStates: [ 'BW' ],
  testedStates: [ 'BW', 'SH', 'TH' ]
}*/

存储库位于 github.com/DaniSchenk/moment-feiertage。