Moment.js 会为 Date 对象创建封装器，而不是修改本地的 Date.prototype。 若要获取此封装器对象，则只需使用一种受支持的输入类型调用 moment() 即可。

Moment 原型通过 moment.fn 公开。 如果要添加自己的函数，则可以在其中放置它们。

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

请阅读：

• moment(...) 是本地模式。不明确的输入（无偏移量）会被假定为本地时间。明确的输入（带偏移量）会被调整为本地时间。
• moment.utc(...) 是 utc 模式。不明确的输入会被假定为 UTC。明确的输入会被调整为 UTC。
• moment.parseZone() 会保持输入的区域被传入。如果输入不明确，则与本地模式相同。
• moment.tz(...) 使用 moment-timezone 插件可以以特定的时区来解析输入。

记住，时区和时区偏移是两件事。 -08:00 的偏移量不一定意味着你处于美国太平洋时区。

moment() 1.0.0+

moment();
moment(undefined);
// 从 2.14.0 开始，也受支持。
moment([]);
moment({});

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

var now = moment();

这基本上与调用 moment(new Date()) 相同。

从 2.14.0 版本开始，moment([]) 和 moment({}) 也返回当前时间。 在 2.14.0 之前，它们默认为今天开始，但这是随意的，因此已更改。

函数参数在未传入时默认为 undefined。 Moment 会将 moment(undefined) 视作 moment()。

moment(String) 1.0.0+

moment(String);

当从字符串创建 moment 时，需要首先检查字符串是否与已知的 ISO 8601 格式匹配，如果未找到已知的格式，则在降维到 new Date(string) 之前检查字符串是否与 RFC 2822 日期时间格式匹配。

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

注意，浏览器对于解析字符串的支持是不一致的。 因为没有关于应该支持哪种格式的规范，所以在某些浏览器中有效的格式在其他浏览器中可能无效。

为了在解析 ISO 8601 以外的字符串时获得一致的结果，应使用字符串 + 格式。

支持的 ISO 8601 字符串

ISO 8601 字符串需要日期片段。

2013-02-08  # 日历日期片段。
2013-W06-5  # 星期日期片段。
2013-039    # 序数日期片段。

20130208    # 基本的完整日期（短）。
2013W065    # 基本的星期、工作日（短）。
2013W06     # 仅基本的星期（短）。
2013050     # 基本的序数日期（短）。

还可以包括时间片段，与日期片段之间使用空格或大写字母 T 分隔。

2013-02-08T09            # 使用 T 分隔的小时时间片段。
2013-02-08 09            # 使用空格分隔的小时时间片段。
2013-02-08 09:30         # 小时、分钟的时间片段。
2013-02-08 09:30:26      # 小时、分钟、秒钟的时间片段。
2013-02-08 09:30:26.123  # 小时、分钟、秒钟和毫秒的时间片段。
2013-02-08 24:00:00.000  # 小时 24、分钟、秒钟、毫秒等于 0 表示第二天午夜。

20130208T080910,123      # 短的日期和时间，精确到毫秒，以逗号分隔。
20130208T080910.123      # 短的日期和时间，精确到毫秒。
20130208T080910          # 短的日期和时间，精确到秒钟。
20130208T0809            # 短的日期和时间，精确到分钟。
20130208T08              # 短的日期和时间，仅有小时。

任何的日期片段都可以有时间片段。

2013-02-08 09  # 日历日期片段和小时时间片段。
2013-W06-5 09  # 星期日期片段和小时时间片段。
2013-039 09    # 序数日期片段和小时时间片段。

如果包含时间片段，则还可以将 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 实例没有任何作用。

清理之后，该字符串会在以下使用空格分隔的部分中进行验证，全部使用英语：

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

解析器还会确认星期（当包含时）与日期一致。

moment(String) 带格式 1.0.0+

moment(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＃format 中使用的格式化令牌。

年份、月份、日期的令牌

令牌区分大小写。

从版本 2.10.5 开始，YYYY 支持 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 版本。

k kk 新增于 2.18.0 版本。

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

moment("2010-10-20 4:30",       "YYYY-MM-DD HH:mm");   // 解析为当地时间 4:30。
moment("2010-10-20 4:30 +0000", "YYYY-MM-DD HH:mm Z"); // 解析为 UTC 时间 4:30。

如果 moment 解析的输入结果不存在，则 moment＃isValid 将会返回 false。

moment("2010 13",           "YYYY MM").isValid();     // false（不是真实的月份）
moment("2010 11 31",        "YYYY MM DD").isValid();  // false（不是真实的日期）
moment("2010 2 29",         "YYYY MM DD").isValid();  // false（不是闰年）
moment("2010 notamonth 29", "YYYY MMM DD").isValid(); // false（不是真实的月份名称）

从 2.0.0 版本开始，可以将语言环境键作为第三个参数传给 moment() 和 moment.utc()。

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

Moment 的解析器非常宽松，这可能会导致不期望或意外的行为。

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

moment('2016 is a date', 'YYYY-MM-DD').isValid() //true, 2016 被匹配。

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

moment('I am spartacus', 'h:hh A').isValid();     //true - 'am' 和 'A' 标志匹配。

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

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

可以同时使用语言环境和严格性。

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

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

解析两位数字的年份

默认情况下，68 之前的两位数字的年份会被假定是 1900 年代，而 68 或之后的年份则会被假定是 2000 年代。 可以通过替换 moment.parseTwoDigitYear 方法来更改。 该方法的唯一参数是包含用户输入的两位年份的字符串，并且应以整数形式返回年份。

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

解析胶合的小时和分钟

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

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

moment(String) 多个格式 1.0.0+

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

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

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

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

从 2.3.0 版本开始，Moment 使用一些简单的试探法来确定要使用的格式。 这是为了：

• 优先使用能生成有效日期（而不是无效日期）的格式。
• 优先使用能解析更多（而不是更少）字符串的格式，且优先使用解析更多（而不是更少）的格式，即优先更严格的解析。
• 优先使用在数组中前面（而不是后面）的格式。

moment("29-06-1995", ["MM-DD-YYYY", "DD-MM", "DD-MM-YYYY"]); // 使用最后一种格式。
moment("05-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"]);          // 使用第一种格式

还可以指定语言环境和严格性参数。 它们的工作方式与单一格式的情况相同。

moment("29-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"], 'fr');       // 使用 'fr' 语言环境。
moment("29-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"], true);       // 使用严格的解析。
moment("05-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"], 'fr', true); // 使用 'fr' 语言环境和严格的解析。

注意：解析多种格式比解析单一格式要慢得多。 如果可以避免，则解析单一格式要快得多。

moment(String) 特殊格式 2.7.0+

moment(String, moment.CUSTOM_FORMAT, [String], [Boolean]);
moment(String, moment.HTML_FMT.DATETIME_LOCAL, [String], [Boolean]); // 从 2.20.0 开始。
moment(String, [..., moment.ISO_8601, ...], [String], [Boolean]);

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

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

从 2.20.0 版本开始，可以使用以下 HTML5 格式：

moment(Object) 2.2.1+

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'});  // 从 2.11.0 开始。

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

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

day 和 date 键均表示月份的某天。

date 新增于 2.8.4。

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

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

moment(Number) 1.0.0+

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

var day = moment(1318781876406);

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

unix() 1.6.0+

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) 1.0.0+

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

这会克隆 Date 对象，Date 的后续更改不会影响 Moment，反之亦然。

moment(Number[]) 1.0.0+

moment(Number[]);

可以使用数值的数组（映射传给 new Date() 的参数）来创建 moment。

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

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

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

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（不是真实的月份）
moment([2010, 10, 31]).isValid(); // false（不是真实的日期）
moment([2010, 1, 29]).isValid();  // false（不是闰年）

moment(JSONDate) 1.3.0+

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) 1.2.0+

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

utc() 1.5.0+

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, Boolean);
moment.utc(String, String, String, Boolean);
moment.utc(Moment);
moment.utc(Date);

默认情况下，moment 会解析并以本地时间显示。

如果要解析或以 UTC 显示 moment，则可以使用 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

parseZone() 2.3.0+

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")
moment.parseZone('2013 01 01 05 -13:00', 'YYYY MM DD HH ZZ').utcOffset(); // -780  (总分钟数 "-13:00")
moment.parseZone('2013-01-01-13:00', ['DD MM YYYY ZZ', 'YYYY MM DD ZZ']).utcOffset(); // -780  (总分钟数 "-13:00");

它还允许传入语言环境和严格性参数。

moment.parseZone("2013 01 01 -13:00", 'YYYY MM DD ZZ', true).utcOffset(); // -780  (总分钟数 "-13:00")
moment.parseZone("2013-01-01-13:00", 'YYYY MM DD ZZ', true).utcOffset(); // NaN (未通过严格性检查)
moment.parseZone("2013 01 01 -13:00", 'YYYY MM DD ZZ', 'fr', true).utcOffset(); // -780 (带有语言环境和严格性参数)
moment.parseZone("2013 01 01 -13:00", ['DD MM YYYY ZZ', 'YYYY MM DD ZZ'], 'fr', true).utcOffset(); // -780 (带有语言环境和严格性参数以及格式的数组)

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

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

isValid() 1.7.0+

moment().isValid();

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

可以使用 moment#isValid 检查 Moment 是否被视为无效的日期。 可以使用 moment#parsingFlags 查看 #isValid 使用的指标，该指标返回一个对象。

无效的日期会返回以下的解析标志：

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

除上述内容外，从 2.13.0 开始，meridiem 和 parsedDateParts 标志也可以一起判断日期的有效性。

• meridiem: 表明解析的子午线（AM/PM），如果有的话。字符串。
• parsedDateParts: 返回按降序解析的日期片段的数组，即 parsedDateParts[0] === 年份。 如果没有片段，但子午线有值，则日期无效。数组。

此外，如果在严格模式中解析 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 表示秒钟

返回值具有以下含义：

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() 返回无效的 Date 对象。
• invalid.toJSON() 返回 null。
• invalid.unix() 返回 null。
• invalid.valueOf() 返回 null。
• invalid.toISOString() 返回 null（从 2.18.0 开始）。

creationData() 2.11.0+

moment().creationData();

创建 moment 对象之后，可以使用 creationData() 方法访问所有的输入：

moment("2013-01-02", "YYYY-MM-DD", true).creationData() === {
    input: "2013-01-02",
    format: "YYYY-MM-DD",
    locale: 语言环境对象,
    isUTC: false,
    strict: true
}

默认值 2.2.1+

moment("15", "hh")

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

当没传入任何值时，默认为现在时间：

moment();  // 当前的日期和时间。

当仅传入小时、分钟、秒钟和毫秒时，默认为今天：

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

当仅传入日期和更小的单位时，默认为本月和今年：

moment(5, "DD");  // 本月的第 5 天
moment("4 05:06:07", "DD hh:mm:ss");  // 本月的第 4 天 05:06:07.000

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

moment(3, "MM");  // 今年第三个月（三月）
moment("Apr 4 05:06:07", "MMM DD hh:mm:ss");  // 今年四月的第 4 天 05:06:07.000