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

例如，考虑 Moment 对象是可变的。 这是有关 Moment 的常见投诉来源。 我们 在我们的使用指南中 解决了这个问题，但它仍然让大多数新用户感到惊讶。 将 Moment 更改为不可变对于使用它的每个项目来说都是一个重大变化。 创建一个不可变的 "Moment v3" 将是一项艰巨的任务，并且会使 Moment 成为一个完全不同的库。 由于这已经在其他库中完成，我们认为保留可变 API 更为重要。

在现代应用程序中反对使用 Moment 的另一个常见论点是它的大小。 Moment 不适用于现代 "摇树优化" 算法，因此它往往会增加 Web 应用程序包的大小。 如果需要国际化或时区支持，Moment 会变得很大。 现代网络浏览器（和 Node.js）通过编码为 ECMA-402 的 Intl 对象公开国际化和时区支持。 像 Luxon（和其他）这样的库利用了这一点，减少或消除了传送您自己的数据文件的需要。

最近，Chrome Dev Tools 仅针对尺寸 开始显示更换 Moment 的建议。 我们普遍支持这一举措。

您可能还想阅读：

• 你可能不再需要 Moment.js
• 你不需要（可能不需要）Moment.js
• 为什么你不应该使用 Moment.js...
• 4 种替代 moment.js 的国际化日期

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

我们现在普遍认为 Moment 是处于维护模式的旧项目。 它没有死，但它确实结束了。

实际上，这意味着：

• 我们不会添加新的特性或功能。
• 我们不会将 Moment 的 API 更改为不可变的。
• 我们不会解决摇树优化或者包体积的问题。
• 我们不会进行任何重大更改（没有版本 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 的进化。 它由 艾萨克·坎布伦 撰写，他是 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 具有一些功能，但我们从经验和数据中知道还有很大的改进空间。

通过 ECMA TC39 Temporal 提案 正在努力用 JavaScript 语言制作更好的日期和时间 API。 它目前处于 TC39 流程 的第 3 阶段。

Temporal 将是一个新的全局对象，充当顶层命名空间（如 Math）。 它公开了许多不同类型的对象，包括 Temporal.Instant、Temporal.ZonedDateTime、Temporal.PlainDateTime、Temporal.PlainDate、Temporal.PlainTime、Temporal.TimeZone 和其他几个。 Temporal 手册 显示了许多 "方法"，其中包含如何在不同场景中使用这些对象的示例。

您今天可以通过 非生产环境 polyfill 试用 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 结合使用，我们强烈建议您阅读 this。 同时升级到 2.14.0 或更高版本以获得最佳体验。

首先，您可能已经通过 bower 或 node_modules 或任何其他将 moment.js 与 locales 目录放在基本文件夹中的工具获得了 moment。 那么您应该使用像 adapt-pkg-main 这样的工具，或者手动使用 packages config。

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 和 de 区域设置以及 moment/locale/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，尝试添加 "moduleResolution": "node" 在 compilerOptions 在你的 tsconfig.json 文件

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

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 加载为全局，你可以使用元配置来做到这一点：

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

或者，要将 Moment 作为全局提供给特定依赖项，您可以这样做：

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

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

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

如果您有任何问题，首先要检查的地方是 guides。

如果您在那里找不到您要找的东西，请尝试在带有 momentjs 标签的 Stack Overflow 上提问。

注意： 在 Stack Overflow 上看到的一半以上的问题都可以由 this blog post 回答。

您还可以使用 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-timezone插件的moment.tz(...)可以解析特定时区的输入。

请记住，时区和时区偏移量是两个不同的东西。 偏移量 -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 时，我们首先检查字符串是否与已知的 国际标准化组织 8601 格式匹配，然后检查字符串是否与 RFC 2822 日期时间 格式匹配，如果未找到已知格式，则返回 new Date(string) 格式。

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

警告：浏览器支持解析字符串 is inconsistent。 因为没有关于应支持哪些格式的规范，所以在某些浏览器中有效的内容在其他浏览器中无效。

为了在解析 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. 以冒号 (:) 分隔的两位数小时和分钟，后跟可选的另一个冒号和两位数的秒
4. 以下格式之一的时区或偏移量：
5. UT： +0000
6. GMT ： +0000
7. EST | CST | MST | 太平洋标准时间 | EDT | CDT | MDT | 太平洋夏令时 ： 美国时区*
8. 一个 - 我 | K-Z： 军事时区*
9. 时间偏移 +/-9999

[*] 有关详细信息，请参阅规范的 section 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 相同）。

Y 是在 2.11.1 中添加的。 它将匹配任何有符号或无符号的数字。 对于不是 4 位数字或纪元之前的年份很有用。 它可以用于任何一年。

周年、周和工作日标记

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

令牌区分大小写。

语言环境感知格式

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

令牌区分大小写。

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

令牌区分大小写。

从版本 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不存在，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);

严格解析通常是最好的解析选项。 有关选择严格解析与宽容解析的更多信息，请参阅 parsing guide.

解析两位数年份

默认情况下，假定 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 使用一些简单的启发式方法来确定要使用的格式。 为了：

• 比无效日期更喜欢产生 valid 日期的格式。
• 更喜欢解析更多字符串的格式而不是更少，使用更多格式而不是更少的格式，即更喜欢更严格的解析。
• 优先使用数组中较早的格式而不是较晚的格式。

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

您可以通过指定对象中的某些单位来创建力矩。

省略的单位默认为 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 日 12AM UTC）以来的毫秒数的整数值来创建moment。

var day = moment(1318781876406);

Note: ECMAScript calls this a "Time Value"

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

[year, month, day, hour, minute, second, millisecond]

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 参数，所以月份、小时、分钟、秒和毫秒都是零索引。 年份和月份中的日期为 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都是可变的。 如果你想要一个 moment 的克隆，你可以隐式或显式地这样做。

稍后调用 moment() 将克隆它。

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

此外，您可以调用 moment#clone 来克隆 moment。

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

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

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() 创建的任何moment都将采用 UTC 模式，而使用 moment() 创建的任何moment都不会。

要从 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解析zone。

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');. 包含无效的月份字符串本身，否则为空。
• empty: 不包含任何可解析内容的输入字符串，例如 moment('this is nonsense');。 布尔值。
• nullInput: null 输入，如 moment(null);。 布尔值。
• invalidFormat: 一个空的格式列表，例如 moment('2013-05-25', [])。 布尔值。
• userInvalidated: 明确创建为无效的日期，例如 moment.invalid()。 布尔值。

除上述内容外，自 2.13.0 起，meridiem 和 parsedDateParts 标志共同确定日期有效性。

• meridiem: 指示解析了什么子午线 (AM/PM)，如果有的话。 字符串。
• parsedDateParts: 返回按降序解析的日期部分数组 - 即 parsedDateParts[0] === year。 如果不存在任何部分，但 meridiem 具有值，则日期无效。 数组。

此外，如果在严格模式下解析 Moment，则这些标志必须为空才能使 Moment 有效：

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

注意： Moment 的有效性概念在 2.2 和 2.3 之间变得更加严格和一致。 注意： 有效性在moment创建时确定。 修改后的moment（即 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. 毫秒

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

无效moment

如果某个moment无效，则它在浮点运算中的行为类似于 NaN。

以下所有内容都会产生无效moment：

• 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，与所有其他命名的 getter 一样
• invalid.toArray() === [NaN, NaN, NaN, NaN, NaN, NaN]
• invalid.toObject() 的所有值都设置为 NaN
• invalid.toDate() 返回无效的日期对象
• invalid.toJSON() 返回空值
• invalid.unix() 返回空值
• invalid.valueOf() 返回空值
• invalid.toISOString() 返回 null（截至 2.18.0）

moment().creationData();

创建 moment 对象后，可以使用 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")

您可以创建一个仅指定部分单位的 moment 对象，其余单位将默认为当前日、月或年，或 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 使用重载的 getter 和 setter。 您可能熟悉这种模式在 jQuery 中的使用。

调用这些不带参数的方法充当 getter，带参数调用它们充当 setter。

这些映射到原生 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 起，单数和复数方法名称均存在。

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

注意： 从 2.19.0 开始，将 NaN 传递给任何 setter 都是空操作。 之前 2.19.0 它以错误的方式使moment无效。

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 号（有关更多详细信息，请参见 month）。

坏的： 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 的输出将取决于 locale。

设置一年中的第几周时，保留星期几。

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 个月。

从 2.1.0 开始，还支持月份名称。 这是在当前的语言环境中解析的。

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

在2.1.0版本之前，如果某个moment改变了月份，新的月份没有足够的天数来保留当月的当前日期，就会溢出到下个月。

从版本 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所在年份的区域设置获取周数。

moment().isoWeeksInYear();

根据 周数，获取当前moment所在年份的周数。

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

单位不区分大小写，并支持复数和缩写形式： 年（years，y），月（months，M），日期（dates，D），小时（hours，h），分钟（minutes，m），秒（seconds，s），毫秒（milliseconds，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});

单位不区分大小写，并支持复数和缩写形式： 年（years，y），月（months，M），日期（dates，D），小时（hours，h），分钟（minutes，m），秒（seconds，s），毫秒（milliseconds，ms）。

在 2.9.0 中添加了对象解析

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

返回给定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'

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

从 2.10.5 版本开始，如果 invalid moment 是参数之一，则结果为 invalid moment。

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

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

例如：

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

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

从 2.10.5 版本开始，如果 invalid moment 是参数之一，则结果为 invalid moment。

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 使用 流畅的界面模式，也称为 method chaining。 这允许你做如下疯狂的事情。

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

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

如果要创建副本并对其进行操作，则应在操作moment之前使用 moment#clone。 有关克隆的更多信息。

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

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

这是一个非常强大的功能，可以为现有moment添加时间。 要添加时间，请传递要添加的时间和要添加的数量的密钥。

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)

或者，您可以使用 durations 添加到朋友圈。

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。

这和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') and moment.subtract(.5, 'days') 等效，-.5、-1.5、-2.5 等向下舍入。

moment().startOf(String);

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

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设置为时间单位的末尾来改变原始moment。

这点和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

在原始moment设置标志以使用本地时间显示moment而不是原始moment的时间。

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

Local 也可用于转换出固定偏移模式：

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

在原始moment设置标志以使用 UTC 显示moment而不是原始moment的时间。

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对象上。 如果您想全局设置偏移量，请尝试使用 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 格式的字符串，moment将更改为该 UTC 偏移量。

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

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

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

• 传递 false（默认值）将在世界时保持相同moment，但本地时间会改变。

• 通过 true 将保持相同的本地时间，但代价是选择不同的世界时间点。

此功能的一种用途是，如果您想仅使用数字输入值来构建具有特定时区偏移量的moment：

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 开始，可以通过传入与 GMT 的分钟数偏移来设置偏移量。

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将更改为该区域。

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

解析和操作完成后，您需要某种方式来显示moment。

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 中添加的。

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

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 日期格式非常相似，但在月中日、年中日和星期中存在一些细微差别。

有关跨不同语言环境的几个不同日期格式标记的细分，请参阅 这个日期格式标记图表。

格式化速度

要将 Moment.js 格式化速度与其他库进行比较，请查看 与其他库的比较。

其他代币

如果您更喜欢使用 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 as the offset, instead of +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 开始，如果目标 moment 对象无效，则结果是本地化的无效日期字符串。

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

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

您可能想要显示与现在以外的时间相关的moment。 在这种情况下，您可以使用 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 处理。 这有时称为时间前或相对时间。

这类似于 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对象无效，则结果是本地化的无效日期字符串。

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

您可能想要显示与现在以外的时间相关的moment。 在这种情况下，您可以使用 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'
});

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

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

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#from 一样使用 moment#diff。

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

要获得两个moment之间差异的持续时间，您可以将 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早于你传递给 moment.fn.diff 的moment，则返回值为负数。

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 时间戳（自纪元以来的秒数），请使用 moment#unix。

Note: ECMAScript calls this a "Time Value"

moment().unix();

moment#unix 输出一个 Unix 时间戳（自 Unix 纪元以来的秒数）。

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。

这将返回 moment 使用的 Date 的副本，因此对该 Date 的任何更改都不会导致 moment 发生变化。 如果要更改力矩 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"}'

相反，如果您想要一个反映moment 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 时间戳，即使相关moment处于本地模式也是如此。 这样做是为了与原生 JavaScript Date ``.toISOString()的规范保持一致，如 [ES2015规范](https://www.ecma-international.org/ecma-262/6.0/#sec-date.prototype.toisostring) 中所述。 从 **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();

返回一个机器可读的字符串，可以对其进行评估以产生相同的moment。 由于名称的原因，它还用于节点交互式 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是否在另一个moment之前。 第一个参数将被解析为 moment，如果不是这样的话。

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

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

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

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#isBefore 支持 moment#startOf 支持的任何时间单位。

year month week isoWeek day hour minute second

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

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

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

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

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#isSame 支持 moment#startOf 支持的任何时间单位。

year month week isoWeek day hour minute second

如果两个moment的时区不同，则使用第一个moment的时区进行比较。

// 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() 具有未定义的行为，不应使用！ 如果代码运行得很快，最初创建的moment将与在 isSame 中创建的moment相同以执行检查，因此结果将是 true。 但是，如果代码运行速度较慢，则 isSame 中创建的moment可能明显晚于 moment() 中创建的moment，因此调用将返回 false。

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

检查一个moment是否在另一个moment之后。 第一个参数将被解析为 moment，如果不是这样的话。

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

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

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

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#isAfter 支持 moment#startOf 支持的任何时间单位。

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是否在另一个moment之前或与另一个moment相同。 第一个参数将被解析为 moment，如果不是这样的话。

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

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

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

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#isSameOrBefore 支持 moment#startOf 支持的任何时间单位：

year month week isoWeek day hour minute second

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

检查一个moment是否在另一个moment之后或与另一个moment相同。 第一个参数将被解析为 moment，如果不是这样的话。

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

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

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

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#isSameOrAfter 支持 moment#startOf 支持的任何时间单位：

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是否在其他两个moment之间，可选择查看单位 刻度（分钟、小时、天等）。 比赛是排他性的。 前两个参数将被解析为矩，如果不是这样的话。

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

请注意，两个参数的顺序很重要： "smaller" 日期应该在第一个参数中。

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 and to 参数相同， 但包容性参数不同，false 将主持。

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

如果不指定 inclusivity 参数，Moment 将默认为 ()。

moment().isDST();

moment#isDST 检查当前moment是否处于夏令时。

注意： 这个函数是一个 HACK。 moment 无法知道给定时间是否在实际 DST 中。 区域中的某些时间更改与 DST 相关，有些则不相关，如果没有完整的时区信息，它就无法知道。

Moment 当前检查冬季和夏季时间，如果偏移量与夏季偏移量匹配（夏季休假与冬季休假不同），则它会报告夏令时。 这适用于绝大多数情况，但如上所述，不是 "correct" 并且不适用于所有情况。 所以不要来找我们抱怨。

事件moment时区（在编写 0.5.37 时）不支持 DST 信息（即时钟是否在给定moment正式在 DST 中），所以为了让事情变得更好一些新东西（和 tzdata 捆绑）有 发生在moment时区。

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

另一个重要的验证是了解日期是否已被 DST 移动。 例如，在美国大部分地区：

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

有关语言环境包每个部分的更多详细信息，请参见 customization 部分。

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 的详细信息，请参阅 customization 部分。

加载语言环境后，它就会成为活动语言环境。 要更改活动区域设置，只需使用已加载区域设置的键调用 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时，全局语言环境配置可能会出现问题。

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 作为插件管理器，你应该在你的库中添加语言环境。

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 的详细信息，请参阅 customization 部分。

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 参数将为真；如果要使用过去的前缀/后缀，则为假。

注意： 在 2.25.0 中添加了对 w 和 ww 的处理。

// 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 应返回真。 这用于解析 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 键也可以是回调函数 当前moment的范围和第一个参数是描述现在的moment。 它 应该返回一个格式化字符串。

function callback (now) {
    return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
}

moment.calendarFormat = Function

这使您可以修改 calendar 使用的标记。

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 开始，添加了 token 参数。 它是正在被排序的令牌字符串，例如： M 或 d。

有关序号的更多信息，请参阅 维基百科。

moment.relativeTimeThreshold(unit);  // getter
moment.relativeTimeThreshold(unit, limit);  // setter

duration.humanize 具有定义单位何时被视为一分钟、一小时等的阈值。 例如，默认情况下超过 45 秒被视为一分钟，超过 22 小时被视为一天等等。 要更改这些截止值，请使用 moment.relativeTimeThreshold(unit, limit)，其中单位是 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），但您可以将其设置为非空值，并且（可选）将 d 设置得更低，以便它从几天前过渡到几周前。

注意：在2.8.1 中添加了检索阈值。

注意：检索和设置 ss 阈值是在 2.18.0 中添加的。

moment.relativeTimeRounding();  // getter
moment.relativeTimeRounding(fn);  // setter

duration.humanize 在将其提供给语言环境中指定的 relativeTime 格式字符串之前舍入可能为双精度的值。 要控制舍入，您可以使用 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 年，即公元前 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。 对于那个时代 increment toward +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 也有持续时间对象。 当 moment 定义为单个时间点，持续时间定义为时间长度。

持续时间没有定义的开始和结束日期。 它们是无上下文的。

持续时间在概念上更类似于 '2 hours' 而不是 'between 2 and 4 pm today'。 因此，它们不是在依赖上下文的单位之间进行转换的好解决方案。

例如，一年可以定义为 366 天、365 天、365.25 天、12 个月或 52 周。 没有上下文，试图将年转换为天是没有意义的。 与使用 Durations 相比，使用 moment#diff 计算两个moment之间的天数或年数要好得多。

作为 discussed here，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，你也可以传递度量单位。

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 还支持解析 国际标准化组织 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 开始，支持无效持续时间，类似于 invalid moment。 要创建无效持续时间，您可以将 NaN 传递给值 一个单位。

在即将发布的版本中，预计无效持续时间会涵盖更多情况（例如 单位的空值）。

moment.duration(NaN);
moment.duration(NaN, 'days');
moment.duration.invalid();

moment.duration().clone();

创建持续时间的克隆。 持续时间是可变的，就像 moment 对象一样，所以这可以让您在某个时间点获得快照。

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，你只想显示一个时间长度。

输入 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

无效的持续时间被人性化为 Invalid Date 的本地化版本。

moment.duration.invalid().humanize(); // Invalid Date

可以使用相对时间阈值配置人性化输出。 要为特定的人性化调用指定阈值，请将它们作为唯一参数或在后缀 arg 之后传递：

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 中添加了 humanize 中的通过阈值。

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

与持续时间的其他获取器一样，moment.duration().minutes() 获取分钟数 (0 - 59)。

moment.duration().asMinutes() 获取持续时间的长度（以分钟为单位）。

moment.duration().hours();
moment.duration().asHours();

与持续时间的其他获取器一样，moment.duration().hours() 获取小时数 (0 - 23)。

moment.duration().asHours() 获取持续时间的长度（以小时为单位）。

moment.duration().days();
moment.duration().asDays();

与持续时间的其他获取器一样，moment.duration().days() 获得天数 (0 - 30)。

moment.duration().asDays() 获取以天为单位的持续时间长度。

moment.duration().weeks();
moment.duration().asWeeks();

与持续时间的其他获取器一样，moment.duration().weeks() 获得周数 (0 - 4)。

moment.duration().asWeeks() 获取持续时间的长度（以周为单位）。

请注意，与持续时间的其他获取器不同，周被算作天数的子集，并且不会从天数中扣除。

注意：以周为单位的持续时间长度定义为 7 天。

moment.duration().months();
moment.duration().asMonths();

与持续时间的其他获取器一样，moment.duration().months() 获取月份 (0 - 11)。

moment.duration().asMonths() 获取持续时间的长度（以月为单位）。

moment.duration().years();
moment.duration().asYears();

与持续时间的其他获取器一样，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之间的持续时间。 为此，只需将 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"}'

无效的持续时间以 json 表示形式返回 Invalid Date。

moment.isDuration(obj);

要检查变量是否为持续时间对象，请使用 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

由 罗布·道森 编写的 精确范围 插件可用于显示准确的、人类可读的日期/时间范围表示：

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 的等历法，您可以使用 Rocky Meza 的插件

moment-isocalendar

立即调用 isocalendar 方法将返回如下数组：

[year, week_of_year, day_of_week, minutes_since_midnight]

moment().isocalendar(); // [2012, 8, 5, 870]

您还可以从等历表重建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

如果您想使用 Jalaali 日历系统（Jalali、波斯语、Khorshidi 或 Shamsi），您可以使用 Behrang Noruzi Niya 的插件 moment-jalaali。

安装后，它将封装 moment 并且瞬间将能够格式化和解析 Jalaali 年份和月份。 这是一个简短的例子：

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是基于乌姆古拉计算的回历农历moment插件。 本插件由苏海尔酒精开发。

当你安装它时，它会封装 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

这是另一个回历（基于民间计算）。

存储库位于 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 那样为推文设置时间格式，您可以使用 @hijonathan 的 moment.twitter 插件。

这是显示人类可读时间戳的短版本和长版本的简单方法。

moment().subtract(5, 'hours').twitterLong();
// 5 hours

是的，它进行智能多元化。

moment().subtract(1, 'hour').twitterLong();
// 1 hour

对你来说还不够短？

moment().subtract(6, 'days').twitterShort();
// 6d

如果您需要 财、日历或学术宿舍，您可以使用 @robgallen 的 moment-fquarter 插件。

最简单的是，只需在任何moment对象上调用 fquarter 方法。 它返回一个格式化的字符串，四月是第一季度。

moment("2013-01-01").fquarter();
// Q4 2012/13

您可以将任何月份作为起始季度，例如 七月

moment("2013-01-01").fquarter(7);
// Q3 2012/13

如果你想要日历季度，从一月开始

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 是一个通过模式操作日期的插件。 您可以使用基本操作 –set/add/subtract– 在 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

您可以在 there 上看到它，而存储库是 在这里。

npm install moment-taiwan

如果你想使用台湾日历系统，你可以使用 Bradwoo8621 的插件 moment-taiwan。

安装后，将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 Durations 的插件。

例如，

moment.duration(123, "minutes").format("h:mm");
// "2:03"

存储库位于 github.com/jsmreese/moment-duration-format。

npm install moment-timer

这是一个允许使用计时器的 Moment.js 插件，它提供比原生 JavaScript 计时器更多的控制。 它基本上是对 JavaScript 自己的 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。

如果想短时间格式化，可以使用@researchgate的moment-shortformat插件。

它基于并类似于 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。