Moment.js 文档

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。

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

Node.js

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

注意:2.4.0不推荐使用全局导出的时刻对象。它将在下一个主要版本中删除。

Bower

bower

bower install --save moment

值得注意的文件是moment.js, locale/*.jsmin/moment-with-locales.js.

Require.js

如果您计划使用Require.js,我们强烈建议您阅读 此内容。也升级到2.14.0或更高版本以获得最佳体验。

首先,您可能需要通过bower或node_modules或其他将moment.js与locales目录放在基本文件夹中的其他内容。然后你应该使用像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'
  }]
});

通过上面的设置,您可以使用带有momentdelocale 的核心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则全局导出的时刻将打印弃用警告。从下一个主要版本开始,如果你想要这种行为,你必须自己导出它。

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

注意:要允许在requirejs环境中加载moment.js插件,请将时刻创建为命名模块。正因为如此,时刻必须被加载完全一样的"moment",用paths 确定的目录。需要一个像路径一样的时刻"vendor\moment" 将会回来undefined.

注意: 从版本2.9.0 开始,将自身导出为匿名模块,因此如果您只使用核心(没有区域设置/插件),那么如果将其放在非标准位置,则不需要配置。

Browserify

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

Webpack

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,例如这个.

Typescript 2.13.0+

从版本2.13.0开始,Moment包含一个打字稿定义文件。

通过NPM安装

npm install moment

在您的Typescript文件中导入和使用

import * as moment from 'moment';

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

注意: 如果您在导入时刻时遇到问题

对于打字稿2.X尝试添加"moduleResolution": "node"compilerOptions 你的tsconfig.json文件,然后使用以下任何语法

import * as moment from 'moment';
import moment = require('moment');

对于打字稿1.x中尝试添加"allowSyntheticDefaultImports": truecompilerOptions 你的 tsconfig.json文件,然后使用语法

import moment from 'moment';

Locale Import

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

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

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

System.js

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

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

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

如果您需要将时间加载为全局,则可以使用元配置执行此操作:

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

或者,要将Moment仅作为特定依赖项的全局提供,您可以执行以下操作:

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

故障排除

如果您遇到任何麻烦,首先要检查的是指南.

如果找不到您要查找的内容,请尝试使用标记在Stack Overflow上提问momentjs

注意:此博客文章可以回答Stack Overflow上看到的一半以上的问题。

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

此外,Moment有一个Gitter,内部团队经常可以使用。

对于常规故障排除帮助,Stack Overflow是首选论坛。Moment的维护者在Stack Overflow上非常活跃,其他一些知识渊博的用户也是如此。最快的反应将在那里。

Date.prototypeMoment.js 不是修改本机,而是为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()保持输入区域的传入。如果输入不明确,则与本地模式相同。
  • moment.tz(...)使用moment-timezone插件可以解析特定时区的输入。

请记住,时区和时区偏移是两个不同的事情。偏移-08:00并不一定意味着您处于美国太平洋时区。

See the Parsing Guide for additional information.

Now 1.0.0+

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(undefined) 作为moment().

var x = undefined;
moment(x).isSame(moment(), 'second'); // true

String 1.0.0+

moment(String);

从字符串创建时刻时,我们首先检查字符串是否与已知的ISO 8601 格式匹配,然后检查字符串是否与RFC 2822 日期时间格式匹配,然后在new Date(string)未找到已知格式的情况下退回到后退。

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

警告:浏览器对解析字符串的支持不一致。因为没有关于应该支持哪种格式的规范,所以在某些浏览器中有效的功能在其他浏览器中不起作用。

为了解析除ISO 8601字符串以外的任何内容的一致结果,您应该使用String + Format.

支持ISO 8601字符串

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

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

20130208    # Basic (short) full date
2013W065    # Basic (short) week, weekday
2013W06     # Basic (short) week only
2013050     # Basic (short) ordinal date

还可以包括时间部分,通过空格或大写字母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, +-HHZ.

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日期时间之前,将清除字符串以删除任何注释和/或换行符。附加字符在格式上是合法的,但不会添加任何内容来创建有效的时刻实例。

清理后,字符串将在以下以空格分隔的部分中进行验证,所有部分均使用英语:

6 Mar 17 21:22 UT
6 Mar 17 21:22:23 UT
6 Mar 2017 21:22:23 GMT
06 Mar 2017 21:22:23 Z
Mon 06 Mar 2017 21:22:23 z
Mon, 06 Mar 2017 21:22:23 +0000
  1. 星期几用三个字母,后跟一个可选的逗号。(可选的)
  2. 每月的日期(1或2位数),然后是三个月的月份和2或4位数的年份
  3. 两位数小时和分钟用冒号(:)分隔,后跟可选的另一个冒号和2位数秒
  4. 时区或偏移量采用以下格式之一:
  5. UT : +0000
  6. GMT : +0000
  7. EST | CST | MST | PST | EDT | CDT | MDT | PDT:美国时区*
  8. A - 我| K - Z:军事时区*
  9. 时间偏移+/- 9999

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

解析器还确认星期几(包括时)与日期一致。

String + Format 1.0.0+

moment(String, String);
moment(String, String, String);
moment(String, String, Boolean);
moment(String, String, String, Boolean);

如果您知道输入字符串的格式,则可以使用它来解析片刻。

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

解析器忽略非字母数字字符,因此以下两个都将返回相同的内容。

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

解析令牌类似于使用的格式化令牌moment#format.

年,月和日代币

令牌区分大小写。

输入描述
YYYY20144或2位数年份
YY142位数年份
Y-25有任意数字的数字和符号的年份
Q1..4一年四分之一。将季度设置为季度的第一个月。
M MM1..12月份编号
MMM MMMMJan..December设置的语言环境中的月份名称moment.locale()
D DD1..31一个月的一天
Do1st..31st有序的月份日
DDD DDDD1..365一年中的一天
X1410715640.579Unix时间戳
x1410715640579Unix ms时间戳

YYYY从版本2.10.5支持2位数年份,并将它们转换为2000年附近的一年(相同YY).

Y在2.11.1中添加。它将匹配任何已签名或未签名的号码。它可用于不是4位数或在共同时代之前的年份。它可以用于任何一年。

周年,周和工作日代币

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

令牌区分大小写。

输入描述
gggg2014Locale 4位数周
gg14Locale 2位数周
w ww1..53一年中的地点
e0..6L区域日期
ddd ddddMon...Sunday设置的语言环境中的日期名称moment.locale()
GGGG2014ISO 4位数周
GG14ISO 2位数周
W WW1..53ISO周一年
E1..7ISO星期几

区域设置感知格式

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

令牌区分大小写。

输入描述
L04/09/1986日期(以本地格式)
LLSeptember 4 1986月份名称,月份,年份
LLLSeptember 4 1986 8:30 PM月份名称,月份,年份,时间
LLLLThursday, September 4 1986 8:30 PM星期几,月份名称,日期,年份,时间
LT08:30 PM时间(没有秒数)
LTS08:30:00 PM时间(秒)

小时,分钟,秒,毫秒和偏移令牌

令牌区分大小写。

输入描述
H HH0..23小时(24小时制)
h hh1..12小时(使用12小时的时间a A。)
k kk1..24小时(24小时从1到24)
a Aam pm张贴或赌注meridiem(注意一个字符a p也被视为有效)
m mm0..59分钟
s ss0..59
S SS SSS0..999 分数秒
Z ZZ+12:00从UTC偏移量+-HH:mm, +-HHmm, 或 Z

从版本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");   // parsed as 4:30 local time
moment("2010-10-20 4:30 +0000", "YYYY-MM-DD HH:mm Z"); // parsed as 4:30 UTC

如果由解析的输入产生的时刻不存在,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的解析器非常宽容,这可能会导致意外/意外行为。

例如,可以观察到以下行为:

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

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

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

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

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

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

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

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

解析两位数年份

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

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

解析胶合小时和分钟

从版本2.11.0解析hmm, Hmm, hmmssHmmss 支持:

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

String + Formats 1.0.0+

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

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

这与 String + Format相同,只是尝试将输入与多种格式匹配。

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

从版本2.3.0开始,Moment使用一些简单的启发式方法来确定要使用的格式。为了:

  • 首选格式会导致有效日期超过无效日期。
  • 更喜欢解析更多字符串而不是更少字符串的格式,并使用更多格式而不是更少,即更喜欢更严格的解析。
  • 首选阵列中较早的格式。
moment("29-06-1995", ["MM-DD-YYYY", "DD-MM", "DD-MM-YYYY"]); // uses the last format
moment("05-06-1995", ["MM-DD-YYYY", "DD-MM-YYYY"]);          // uses the first format

您还可以指定locale和strictness参数。它们的工作方式与单一格式的情况相同。

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

注意: 解析多种格式比解析单一格式要慢得多。如果可以避免它,解析单个格式要快得多。

Special Formats 2.7.0+

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

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

指定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.DATETIME_LOCALYYYY-MM-DDTHH:mm2017-12-14T16:34<input type="datetime-local" />
moment.HTML5_FMT.DATETIME_LOCAL_SECONDSYYYY-MM-DDTHH:mm:ss2017-12-14T16:34:10<input type="datetime-local" step="1" />
moment.HTML5_FMT.DATETIME_LOCAL_MSYYYY-MM-DDTHH:mm:ss.SSS2017-12-14T16:34:10.234<input type="datetime-local" step="0.001" />
moment.HTML5_FMT.DATEYYYY-MM-DD2017-12-14<input type="date" />
moment.HTML5_FMT.TIMEHH:mm16:34<input type="time" />
moment.HTML5_FMT.TIME_SECONDSHH:mm:ss16:34:10<input type="time" step="1" />
moment.HTML5_FMT.TIME_MSHH:mm:ss.SSS16:34:10.234<input type="time" step="0.001" />
moment.HTML5_FMT.WEEKYYYY-[W]WW2017-W50<input type="week" />
moment.HTML5_FMT.MONTHYYYY-MM2017-12<input type="month" />

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'});  // from 2.11.0

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

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

day 并且 date 键都表示每月的日期。

date 在2.8.4中添加。

版本2.11.0支持字符串值(如最后一行所示) 。

请注意,moment(Array)new Date(year, month, date),月份是0索引。

Unix时间戳(秒) 1.6.0+

moment.unix(Number)

要从Unix时间戳(自Unix Epoch以来的秒数)创建时刻,请使用moment.unix(Number).

var day = moment.unix(1318781876);

这实现为moment(timestamp * 1000),因此包括输入时间戳中的部分秒。

var day = moment.unix(1318781876.721);

注意:尽管Unix时间戳是基于UTC的,但此函数在本地模式下创建一个时刻对象。如果您需要UTC,请随后致电.utc(),如:

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

Date 1.0.0+

moment(Date);

您可以Moment使用预先存在的本机JavascriptDate对象创建一个。

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

这克隆了Date对象; 进一步改变Date不会影响Moment,反之亦然。

Array 1.0.0+

moment(Number[]);

您可以使用一组数字创建一个时刻,这些数字镜像传递给新new Date()的参数

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

ASP.NET JSON Date 1.3.0+

moment(String);

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

如果传入与此格式匹配的字符串,则将正确解析该字符串。

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

Moment 克隆 1.2.0+

moment(Moment);

所有的时刻都是可变的。如果您想要克隆片刻,可以隐式或显式地执行此操作。

召唤 moment()片刻会克隆它.

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

此外,您可以打电话moment#clone 克隆片刻。

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

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

默认情况下,时刻会以本地时间进行分析和显示。

如果要以UTC格式解析或显示片刻,可以使用moment.utc() 而不是 moment().

这为我们带来了Moment.js的一个有趣特征。UTC模式。

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

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

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

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

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

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

创建的任何时刻moment.utc() 都将处于UTC模式,并且创建的任何时刻moment() 都不会。

要从UTC切换到本地时间,您可以使用moment#utcmoment#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" 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);

它还允许您传递locale和strictness参数。

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

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

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

Validation 1.7.0+

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。您可以检查#isValidusing使用的指标moment#parsingFlags,它返回一个对象。

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

  • 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:表示解析了什么meridiem(AM / PM),如果有的话。串。
  • parsedDateParts:返回按降序解析的日期部分数组 - 即parsedDateParts [0] === year。如果没有零件,但是meridiem有价值,则日期无效。阵列。

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

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

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

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

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

返回值具有以下含义:

  1. years
  2. months
  3. days
  4. hours
  5. minutes
  6. seconds
  7. milliseconds

注意: 如果有多个错误的单位,则返回第一个单位(例如,因为有效期可能取决于月份)。

无效的时刻

如果片刻无效,则其在浮点运算中的行为类似于NaN。

以下所有内容都会产生无效时刻:

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

以下产生本地化版本'InvalidDate':

  • invalid.format(anyFmt) 导致 'Invalid Date'当前区域设置
  • invalid.from(another)
  • another.from(invalid)
  • invalid.fromNow(suffix)
  • invalid.to(another)
  • another.to(invalid)
  • invalid.toNow(suffix)
  • invalid.toISOString() (2.18.0之前)
  • invalid.toString()

以下返回false:

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

并且这些返回nullNaN具有某种结构:

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

创建数据 2.11.0+

moment().creationData();

创建片刻对象后,可以使用以下creationData() 方法访问所有输入 :

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

默认值 2.2.1+

moment("15", "hh")

您可以创建仅指定某些单位的时刻对象,其余的将默认为当前日期,月份或年份,或0表示小时,分钟,秒和毫秒。

默认为现在,什么都没有通过:

moment();  // current date and time

默认为今天,只传递小时,分钟,秒和毫秒:

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

违约到这个月和一年,只有几天和更小的单位通过:

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

违约到今年,如果未指定年份:

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

Moment.js使用重载的getter和setter。您可能熟悉这种模式在jQuery中的使用。

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

这些映射到本机Date对象上的相应函数。

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

如果您处于UTC mode,它们将映射到UTC等效项。

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

为方便起见,从版本2.0.0开始,存在单数和复数方法名称。

注意:当用作setter时,所有这些方法都会改变原始时刻。

注意: 从2.19.0传递 NaN 到任何setter都是no-op。在2.19.0之前, 它以错误的方式使时刻失效。

millisecond 1.3.0+

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

获取或设置毫秒。

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

Second 1.0.0+

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

获取或设置秒数。

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

Minute 1.0.0+

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

获取或设置分钟。

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

Hour 1.0.0+

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

获取或设置小时。

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

Date of Month 1.0.0+

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.0moment().dates()。请改用moment().date()

Day of Week 1.3.0+

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

Day of Week (Locale Aware) 2.1.0+

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

ISO Day of Week 2.1.0+

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

Day of Year 2.0.0+

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

获取或设置一年中的某一天。

接受从1到366的数字。如果超出范围,它将会冒泡到多年。

Week of Year 2.0.0+

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

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

由于不同的区域设置定义了不同年份的周数,因此添加Moment.js moment#week以获取/设置一年中的本地化周。

一年中的一周取决于哪一天是一周的第一天(星期日,星期一等),以及哪一周是一年中的第一周。

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

在法国,星期一是一周的第一天,而1月4日的星期是一年的第一周。

输出moment#week将取决于当时的语言环境。

设置一年中的星期时,将保留星期几。

Month 1.0.0+

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

获取或设置月份。

接受从0到11的数字。如果超出范围,它将冒泡到年。

注意: 月份为零索引,因此1月份为0月份。

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

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

在版本2.1.0之前,如果一个时刻改变了几个月并且新月没有足够的时间来保持当月的当天,它将会溢出到下个月。

从版本2.1.0开始,此更改被限制为目标月末。

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

不推荐使用2.16.0moment().months()。请moment().month()改用。

Quarter 2.6.0+

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'

Year 1.0.0+

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

获取或设置年份。

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

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

Week Year 2.1.0+

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

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

因为第一周的第一天并不总是落在一年的第一天,所以有时候周年与月份不同。

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

Weeks In Year 2.6.0+

moment().weeksInYear();

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

Get 2.2.1+

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

字符串getter。一般来说

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

Units are case insensitive, and support plural and short forms: year (years, y), month (months, M), date (dates, D), hour (hours, h), minute (minutes, m), second (seconds, s), millisecond (milliseconds, ms).

Set 2.2.1+

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

通用setter,接受单位作为第一个参数,值作为第二个:

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

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

单位不区分大小写,支持复数形式和短形式:年(年,y),月(月,M),日期(日期,D),小时(小时,h),分钟(分钟,m),秒(秒) ,s),毫秒(毫秒,ms)。

在2.9.0中添加了对象解析

Maximum 2.7.0+

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

返回给定时刻实例的最大(最遥远的未来)。

例如:

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

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

如果没有参数,该函数将返回具有当前时间的时刻实例。

从版本2.10.5开始,如果无效时刻是其中一个参数,则结果是无效时刻。

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

Minimum 2.7.0+

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

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

例如:

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

如果没有参数,该函数将返回具有当前时间的时刻实例。

从版本2.10.5开始,如果无效时刻是其中一个参数,则结果是无效时刻。

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

一旦你有了Moment,你可能想以某种方式操纵它。有很多方法可以帮助解决这个问题。

Moment.js使用流畅的界面模式也称为方法链接。这允许你做如下的疯狂事情。

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

注意: 应该注意的是,时刻是可变的。调用任何操作方法都会改变原始时刻。

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

Add 1.0.0+

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

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

这是一个非常强大的功能,可以为现有时刻增加时间。要添加时间,请传递要添加的时间键以及要添加的金额。

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

如果你涉及整个简洁的事情,也有一些速记键。

moment().add(7, 'd');
速记
years y
quarters Q
months M
weeks w
days d
hours h
minutes m
seconds s
milliseconds ms

如果要同时添加多个不同的键,可以将它们作为对象文字传递。

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

金额没有上限,因此您可以重载任何参数。

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

几个月和几年的特殊考虑

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

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

添加跨越夏令时的时间时,还需要特别注意。如果您要添加年,月,周或天,则原始小时将始终与添加的小时相匹配。

添加一个月会将指定的月份数添加到该日期。

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

如果要添加小时,分钟,秒或毫秒,则假设您需要精确到小时,并且将导致不同的小时。

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

或者,您可以使用持续时间来添加时刻。

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

在2.8.0版之前,moment#add(String, Number) 还支持语法。它已被弃用moment#add(Number, String).

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

从2.12.0开始,当十进制值传递了几天和几个月时,它们会四舍五入到最接近的整数。周,季度和年份转换为天或月,然后四舍五入到最接近的整数。

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

Subtract 1.0.0+

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

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

这与完全相同moment#add,只是增加时间而不是增加时间。

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

在2.8.0版之前,moment#subtract(String, Number)还支持语法。它已被弃用 moment#subtract(Number, String).

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

从2.12.0开始,当十进制值传递了几天和几个月时,它们会四舍五入到最接近的整数。周,季度和年份转换为天或月,然后四舍五入到最接近的整数。

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

注意,为了使操作moment.add(-.5, 'days')moment.subtract(.5, 'days') 等效,舍入-.5​​,-1.5,-2.5等。

Start of Time 1.7.0+

moment().startOf(String);

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

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

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

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

从版本2.0.0开始,moment#startOf('day') 替换 moment#sod.

注意: moment#startOf('week') 在2.0.0版中添加了。

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

注意: moment#startOf('isoWeek') 在2.2.0版中添加了。

注意: moment#startOf('date')在2.13.0中添加为日期的别名

End of Time 1.7.0+

moment().endOf(String);

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

这与oment#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') 使用区域设置感知周开始日。

Maximum From 2.1.0, Deprecated 2.7.0

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#max传递给您传递给的内容moment().

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

Minimum From 2.1.0, Deprecated 2.7.0

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

Local 1.5.0+

moment().local();

在原始时刻设置一个标志,以使用当地时间显示片刻而不是原始片刻的时间。

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"

有关UTC模式的更多信息,请参见moment.utc()

UTC 1.5.0+

moment().utc();

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

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

UTC也可用于转换出固定的偏移模式:

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

有关UTC模式的更多信息,请参见moment.utc()

UTC offset 2.9.0++

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

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

注意:moment.fn.zone此函数不同,返回UTC的实际偏移量,而不是反向偏移量(返回的值Date.prototype.getTimezoneOffset).

获取utcOffset 当前对象的:

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

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

moment().utcOffset(120);

如果输入小于16和大于-16,则会将输入解释为小时。

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

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

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

moment#utcOffset将搜索字符串中的第一个匹配项+00:00 +0000 -00:00 -0000 Z,因此您甚至可以传递ISO8601格式的字符串,并且该时刻将更改为该UTC偏移量。

请注意,字符串(如果不是'Z')需要以+- 字符开头。

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

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

  • 传递 false(默认)将在世界时间保持相同的瞬间,但当地时间将会改变。

  • 传递 true将保持相同的当地时间,但代价是选择世界时的不同点。

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

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

Time zone Offset From 1.2.0, deprecated 2.9.0+

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().zone("2013-03-07T07:00:00-08:00");
完成解析和操作后,您需要一些方法来显示时刻。

Format 1.0.0+

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('gibberish').format('YYYY MM DD');         // "Invalid date"
Token Output
Month M 1 2 ... 11 12
Mo 1st 2nd ... 11th 12th
MM 01 02 ... 11 12
MMM Jan Feb ... Nov Dec
MMMM January February ... November December
Quarter Q 1 2 3 4
Qo 1st 2nd 3rd 4th
Day of Month D 1 2 ... 30 31
Do 1st 2nd ... 30th 31st
DD 01 02 ... 30 31
Day of Year DDD 1 2 ... 364 365
DDDo 1st 2nd ... 364th 365th
DDDD 001 002 ... 364 365
Day of Week d 0 1 ... 5 6
do 0th 1st ... 5th 6th
dd Su Mo ... Fr Sa
ddd Sun Mon ... Fri Sat
dddd Sunday Monday ... Friday Saturday
Day of Week (Locale) e 0 1 ... 5 6
Day of Week (ISO) E 1 2 ... 6 7
Week of Year w 1 2 ... 52 53
wo 1st 2nd ... 52nd 53rd
ww 01 02 ... 52 53
Week of Year (ISO) W 1 2 ... 52 53
Wo 1st 2nd ... 52nd 53rd
WW 01 02 ... 52 53
Year YY 70 71 ... 29 30
YYYY 1970 1971 ... 2029 2030
Y 1970 1971 ... 9999 +10000 +10001
注意: 这符合ISO 9601 标准,适用于过去9999年的日期
Week Year gg 70 71 ... 29 30
gggg 1970 1971 ... 2029 2030
Week Year (ISO) GG 70 71 ... 29 30
GGGG 1970 1971 ... 2029 2030
AM/PM A AM PM
a am pm
Hour H 0 1 ... 22 23
HH 00 01 ... 22 23
h 1 2 ... 11 12
hh 01 02 ... 11 12
k 1 2 ... 23 24
kk 01 02 ... 23 24
Minute m 0 1 ... 58 59
mm 00 01 ... 58 59
Second s 0 1 ... 58 59
ss 00 01 ... 58 59
Fractional Second S 0 1 ... 8 9
SS 00 01 ... 98 99
SSS 000 001 ... 998 999
SSSS ... SSSSSSSSS 000[0..] 001[0..] ... 998[0..] 999[0..]
Time Zone z or zz EST CST ... MST PST
注意:从1.6.0开始,z / zz格式标记已从普通时刻对象中弃用。 在这里阅读更多相关信息。 但是,如果您使用带有时刻 - 时区插件的特定时区,它们*会起作用。
Z -07:00 -06:00 ... +06:00 +07:00
ZZ -0700 -0600 ... +0600 +0700
Unix Timestamp X 1360013296
Unix Millisecond Timestamp x 1360013296123

X在2.0.0中添加。

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

x 在2.8.4中添加。

SSSSSSSSSSSSS是在加入2.10.5。它们显示3位有效数字,其余数字用零填充。

kkk在2.13.0中添加。

本地化格式

由于首选格式根据区域设置而不同,因此可以使用一些标记根据其区域设置格式化片刻。

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

时间 LT 8:30 PM
时间与秒 LTS 8:30:25 PM
月份数字,月份,年份 L 09/04/1986
l 9/4/1986
月份名称,月份,年份 LL September 4, 1986
ll Sep 4, 1986
月份名称,月份,年份,时间 LLL September 4, 1986 8:30 PM
lll Sep 4, 1986 8:30 PM
月份名称,月份日期,星期几,年份,时间 LLLL Thursday, September 4, 1986 8:30 PM
llll Thu, Sep 4, 1986 8:30 PM

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作为偏移量返回,而不是+00:00.

在某些情况下,本地时区(例如Atlantic/Reykjavik)可能具有零偏移,并且将被视为UTC。在这种情况下,设置moment.defaultFormatmoment.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

Time from now 1.0.0+

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

显示时间的常用方法由处理moment#fromNow。这有时被称为timeago或相对时间。

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

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

下表列出了每个时间长度显示的字符串细目。

范围 输出
0到44秒 s 几秒钟前
unset ss 44秒前
45到89秒 m 一分钟前
90秒到44分钟 mm 2分钟前... 44分钟前
45至89分钟 h 一小时前
90分钟到21个小时 hh 2小时前... 21小时前
22至35小时 d 一天前
36小时到25天 dd 2天前... 25天前
26至45天 M 一个月前
45至319天 MM 2个月前... 10个月前
320至547天(1。5年) y 一年前
548天+ yy 2年前...... 20年前

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

注意:ss 中加入关键2.18.0。这是一个可选的阈值。除非用户手动设置ss阈值,否则它将永远不会显示。在设置ss阈值之前,它默认为s 阈值减1(因此,对用户不可见)。

Time from X 1.0.0+

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

您可能希望显示与现在不同的时间相关的时刻。在这种情况下,您可以使用moment#from.

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

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

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

比如 moment#fromNow,传递true第二个参数返回没有后缀的值。只要您需要具有人类可读的时间长度,这就非常有用。

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

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

Time to now 2.10.3+

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

显示时间的常用方法由处理moment#toNow。这有时被称为timeago或相对时间。

这类似于moment.fromNow,但给出相反的间隔:a.fromNow() = - a.toNow().

这类似于moment.to,但是在当前时间是特殊的。使用moment.to,如果你想控制的期间的两个端点。

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

如果通过true,则可以获得不带前缀的值。

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

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

下表列出了每个时间长度显示的字符串细目。

范围 输出
0到44秒 s 很快
45到89秒 m 在一分钟内
90秒到44分钟 mm 在2分钟......在44分钟
45至89分钟 h 一个小时内
90分钟到21个小时 hh 在2个小时......在21个小时内
22至35小时 d 一天内
36小时到25天 dd 在2天......在25天内
26至45天 M 在一个月
45至319天 MM 在2个月......在10个月内
320至547天(1。5年) y 在一年以内
548天+ yy 在2年......在20年

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

Time to X 2.10.3+

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

您可能希望显示与现在不同的时间相关的时刻。在这种情况下,您可以使用moment#to.

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

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

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

比如 moment#toNow,传递true第二个参数返回没有后缀的值。只要您需要具有人类可读的时间长度,这就非常有用。

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

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

Calendar Time 1.3.0+

moment().calendar();
moment().calendar(referenceTime);
moment().calendar(referenceTime, formats);  // from 2.10.5

日历时间显示相对于给定的时间referenceTime(默认为现在),但与时间略有不同moment#fromNow.

moment#calendar将根据日期的接近referenceTime日期(默认为今天)格式化具有不同字符串的日期。

上个星期 上周一凌晨2:30
前一天 Yesterday at 2:30 AM
同一天 Today at 2:30 AM
第二天 Tomorrow at 2:30 AM
下个星期 Sunday at 2:30 AM
其他一切 7/10/2011

这些字符串是本地化的,可以自定义。.

从2.10.5开始,支持为每次调用指定日历输出格式:

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

sameElse 当距离时间超过一周时,用作格式referenceTime

注意: 从版本2.14.0开始,calendar参数到calendar可以是一个回调,它在瞬间上下文中使用单个参数执行:

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

Difference 1.0.0+

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

要获得以毫秒为单位的差异,请moment#diff像使用一样使用moment#from.

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

为了获得另一个测量单位的差异,将该测量值作为第二个参数传递。

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

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

支持的测量years, months, weeks, days, hours, minutes, 和 seconds。为了便于开发,从2.0.0开始支持单数形式。版本1.1.1中提供了毫秒以外的度量单位。

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

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

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

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

想到这一点的简单方法是用.diff(减号运算符替换。

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

月和年的差异

moment#diff有一些特殊的处理月和年差异。它经过优化,可确保相同日期的两个月始终是一个整数。

所以1月15日到2月15日应该是1个月。

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

2011年2月28日至2012年2月28日应该是1年。

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

月份和年份差异的变化是在2.0.0中进行的。截至版本2.9.0差异也支持季度单位。

Unix Timestamp (seconds) 1.6.0+

moment().unix();

moment#unix 输出Unix时间戳(自Unix Epoch以来的秒数)。

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

此值将浮动到最接近的秒,并且不包括毫秒组件。

Days in Month 1.5.0+

moment().daysInMonth();

获取当月的天数。

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

As Javascript Date 1.0.0+

moment().toDate();

要获取Moment.js包装的本机Date对象的副本,请使用moment#toDate.

这将返回 Date当前使用的副本,因此对其的任何更改Date都不会导致时刻发生变化。如果您想要改变时刻Date请参阅moment#manipulate or moment#set.

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

As Array 1.7.0+

moment().toArray();

这将返回一个镜像参数的数组new Date().

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

As JSON 2.0.0+

moment().toJSON();

将对象序列化为JSON时,如果有Moment对象,则将其表示为ISO8601字符串,并调整为UTC。

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

如果您想要反映瞬间的ISO8601字符串utcOffset(),那么您可以toJSON 像这样修改函数:

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

这会改变行为,如下所示:

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

As ISO 8601 String 2.1.0+

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

格式化符合ISO8601标准的字符串。

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

请注意.toISOString() ,即使相关时刻处于本地模式,也会返回UTC时间戳。这样做是为了提供与本机JavaScript日期规范的一致性.toISOString(),如 ES2015规范中所述。从版本2.20.0开始,您可以调用.toISOString(true)以防止UTC转换。

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

As Object 2.10.5+

moment().toObject();

这将返回一个包含年,月,日,小时,分钟,秒,毫秒的对象。

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

As String 2.1.0+

moment().toString();

返回与JS Date类似格式的英文字符串.toString().

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

Inspect 2.16.0+

moment().inspect();

返回机器可读字符串,可以对其进行求值以产生相同的时刻。由于其名称,它还在节点交互式shell中用于显示对象。

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

注意: 此功能主要用于调试,并非所有情况都经过精确处理。

Is Before 2.0.0+

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

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

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#startOf支持moment#isBefore.

year month week isoWeek day hour minute second

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

注意: moment().isBefore()有未定义的行为,不应该使用!如果代码运行得很快,那么初始创建的时刻将与在isBefore中创建的时刻相同,以便执行检查,因此结果将是false。但是如果代码运行得比较慢,那么在isBefore中创建的那一刻可能会在创建的那个之后可测量moment(),所以调用会返回true.

Is Same 2.0.0+

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

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

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

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

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

当包含第二个参数时,它将匹配所有等于或大于的单位。传入month将检查monthyear.。传递day 将检查day, month, 和 year.

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

喜欢 moment#isAfter 和支持的moment#isBefore任何时间单位都受moment#startOf 支持 moment#isSame.

year month week isoWeek day hour minute second

如果两个时刻具有不同的时区,则第一时刻的时区将用于比较。

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

注意: moment().isSame() 有未定义的行为,不应该使用!如果代码运行得很快,则初始创建的时刻将与isSame中创建的时刻相同,以便执行检查,因此结果将是true。但是如果代码运行得慢,那么在isSame中创建的那一刻可能会在创建的那个之后可测量moment(),所以调用会返回false.

Is After 2.0.0+

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

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

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#startOf支持moment#isAfter.

year month week isoWeek day hour minute second

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

moment().isAfter(); // false

Is Same or Before 2.11.0+

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

检查一个时刻是否在另一个时刻之前或相同。第一个参数将被解析为片刻,如果不是这样的话。

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

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

由于第二个参数决定了精度,而不仅仅是要检查的单个值,因此使用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#isAftermoment#isSame任何所支持的时间单位moment#startOf 的支持 moment#isSameOrBefore:

year month week isoWeek day hour minute second

Is Same or After 2.11.0+

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

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

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

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

由于第二个参数决定了精度,而不仅仅是要检查的单个值,因此使用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#isSamemoment#isBefore任何所支持的时间单位moment#startOf 的支持moment#isSameOrAfter:

year month week isoWeek day hour minute second

Is Between 2.9.0+

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

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

检查是否在两个其他时刻之间,可选择查看单位比例(分钟,小时,天等)。比赛是独家的。前两个参数将被解析为片刻,如果不是这样的话。

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

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

moment('2010-10-20').isBetween('2010-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引入了包容性。A [表示包含值。A ( 表示排除。如果使用包含性参数,则必须传递两个指标。

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

请注意,如果fromto参数相同,但包含性参数不同,则false将主持。

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

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

Is Daylight Saving Time 1.2.0+

moment().isDST();

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

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

Is DST Shifted From 2.3.0, Deprecated 2.14.0

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

注意: 从版本2.14.0开始,不推荐使用此函数。修改时刻对象后,它没有给出正确的答案。有关更多信息,请参阅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,瞬间在这种情况下始终返回的对象falsemoment#isValid; 他们现在回来了true.

Is Leap Year 1.0.0+

moment().isLeapYear();

moment#isLeapYear 返回 true该年是闰年,返回false 则不是.

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

Is a Moment 1.5.0+

moment.isMoment(obj);

要检查变量是否是时刻对象,请使用moment.isMoment().

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

从版本2.11.0开始,您还可以按instanceof运算符测试时刻对象:

moment() instanceof moment // true

Is a Date 2.9.0+

moment.isDate(obj);

要检查变量是否是本机js Date对象,请使用moment.isDate().

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

Moment.js对il8n有强有力的支持。

您可以加载多个区域设置并在它们之间轻松切换。

除了分配全局区域设置外,您还可以将区域设置分配给特定时刻。

Changing locale globally 1.0.0+

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

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

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

要加载区域设置,请将密钥和字符串值传递给moment.locale.

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

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

有关详细信息week.dowweek.doy 可以在自定义 部分找到.

加载区域设置后,它将成为活动区域设置。要更改活动区域设置,只需moment.locale使用加载的区域设置的键进行调用。

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

从2.21.0开始, console.warn 如果区域设置不可用,则将使用Moment 。

从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'

Changing locales locally 1.7.0+

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

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

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

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

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

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

localLocale.locale(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开始,您还可以指定区域设置标识符数组。它的工作方式与全局语言环境配置相同。

Loading locales in NodeJS 1.0.0+

moment.locale(String);

在NodeJS中加载语言环境非常简单。如果moment-root/locale/在该键之后命名了一个语言环境文件,则第一次调用moment.locale将加载它。

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

如果希望支持语言环境,请develop 使用所需的语言环境和单元测试文件为分支创建拉取请求。

Loading locales in the browser 1.0.0+

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

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

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

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

所有语言环境都有缩小版本:

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

要最小化HTTP请求,请使用我们的Grunt任务使用自定义的语言环境列表编译Moment

grunt transpile:fr,it
<script src="min/moment-with-locales.custom.js" charset="UTF-8"></script>

如果您使用JSPM作为插件管理器,则应在lib中添加区域设置。

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

注意:区域设置文件以UMD样式定义,因此它们应在所有环境中无缝工作。

将您的语言环境添加到Moment.js

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

要运行在Node.js的测试,这样做npm install的话 grunt.

如果所有测试都通过,请提交拉取请求,并感谢您的贡献!

Checking the current Moment.js locale 1.6.0+

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

Listing the months and weekdays of the current Moment.js locale 2.3.0+

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开始,您可以传递bool作为工作日函数的第一个参数。如果为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', ...]

最后,您可以将format选项和整数选项结合使用。

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

Accessing locale specific functionality 2.8.0+

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请参阅自定义部分。

Pseudo Locale 2.13.0+

moment.locale('x-pseudo')

从版本2.13.0开始,可选择包括伪语言环境。此区域设置将使用非常明显更改的数据填充日期。伪测试在测试时非常有用,因为它们可以明显地显示数据的本地化和未定位的数据。只需包含伪语言环境,并将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开始尝试使用新定义的语言环境创建时刻时,如果父项存在,则会尝试延迟加载父项。如果失败则会将父项默认为全局语言环境。

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

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

指定的任何属性都将更新,而其他属性将保持不变。此功能不会影响已存在的时刻。

要还原更新,请使用:

moment.updateLocale('en', null);

不推荐使用2.12.0moment.locale()来更改现有的语言环境。请moment.updateLocale()改用。

Month Names 1.0.0+

// 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版开始,月份也可以是一个对象,指定standaloneformat形式(主格和指控)。在格式上运行的正则表达式,用于检查是否使用该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
    }
});

Month Abbreviations 1.0.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可以与对象standaloneformat情况。

moment.updateLocale('en', {
    monthsShort : {
        format: 'янв_фев_мар_апр_мая_июня_июля_авг_сен_окт_ноя_дек'.split('_'),
        standalone: 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_')
    }
});

Weekday Names 1.0.0+

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

Weekday Abbreviations 1.0.0+

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

Minimal Weekday Abbreviations 1.7.0+

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

Long Date Formats 1.1.0+

// 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"
    }
});

Relative Time 1.0.0+

// 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",
        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如果令牌将没有后缀显示,假,如果将带有后缀显示参数将是真实的。(反转逻辑的原因是因为默认行为是使用后缀显示。)

isFuture如果要使用future后缀/前缀,则该参数为true,如果要使用过去的前缀/后缀,则为false。

AM/PM 1.6.0+

// From 2.12.0 onward
moment.updateLocale('en', {
    meridiem : Function
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    meridiem : Function
});

// Deprecated in 2.8.1
moment.lang('en', {
    meridiem : Function
});

如果您的语言环境使用'am / pm',Locale#meridiem则可以省略,因为这些值是默认值。

如果您的语言环境需要am / pm的任何不同计算,则Locale#meridiem应该是一个回调函数,它根据小时,分钟和大写/小写返回正确的字符串。

moment.updateLocale('zh-cn', {
    meridiem : function (hour, minute, isLowercase) {
        if (hour < 9) {
            return "早上";
        } else if (hour < 11 && minute < 30) {
            return "上午";
        } else if (hour < 13 && minute < 30) {
            return "中午";
        } else if (hour < 18) {
            return "下午";
        } else {
            return "晚上";
        }
    }
});

AM/PM Parsing 2.1.0+

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

Locale#isPM 如果输入字符串超过中午12,则返回true。这用于解析a A 令牌。

moment.updateLocale('en', {
    isPM : function (input) {
        return ((input + '').toLowerCase()[0] === 'p');
    }
});

要配置应将哪些字符串解析为输入,请设置该meridiemParse 属性。

moment.updateLocale('en', {
    meridiemParse : /[ap]\.?m?\.?/i
});

Calendar 1.3.0+

// From 2.12.0 onward
moment.updateLocale('en', {
    calendar : Object
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    calendar : Object
});

// Deprecated in 2.8.1
moment.lang('en', {
    calendar : Object
});

Locale#calendar应具有以下格式字符串。

moment.locale('en', {
    calendar : {
        lastDay : '[Yesterday at] LT',
        sameDay : '[Today at] LT',
        nextDay : '[Tomorrow at] LT',
        lastWeek : '[last] dddd [at] LT',
        nextWeek : 'dddd [at] LT',
        sameElse : 'L'
    }
});

每个 Locale#calendar键也可以是一个回调函数,当前时刻和第一个参数的范围是现在描述的时刻。它应该返回一个格式化字符串。

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

Calendar Format 2.14.0+

moment.calendarFormat = Function

这允许您修改日历使用的标记。

moment.calendarFormat = function (myMoment, now) {
    var diff = myMoment.diff(now, 'days', true);
    var nextMonth = now.clone().add(1, 'month');

    var retVal =  diff < -6 ? 'sameElse' :
        diff < -1 ? 'lastWeek' :
        diff < 0 ? 'lastDay' :
        diff < 1 ? 'sameDay' :
        diff < 2 ? 'nextDay' :
        diff < 7 ? 'nextWeek' :
        // introduce thisMonth and nextMonth
        (myMoment.month() === now.month() && myMoment.year() === now.year()) ? 'thisMonth' :
        (nextMonth.month() === myMoment.month() && nextMonth.year() === myMoment.year()) ? 'nextMonth' : 'sameElse';
    return retVal;
};

Ordinal 1.0.0+

// 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开始,添加了令牌参数。它是正在进行ordinalized的令牌字符串,例如:Md.

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

Relative Time Thresholds 2.7.0+

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

duration.humanize具有阈值,定义何时将单位视为分钟,一小时等。例如,默认情况下,超过45秒被视为一分钟,超过22小时被视为一天,依此类推。改变这些截断值使用moment.relativeTimeThreshold(unit, limit),其中单元是下列之一 ss, s, m, h, d, M.

单元 含义 用法
ss 几秒钟 最少秒数被视为秒。必须在设置`s`单位或不设置`s`单位后设置。
s 最少考虑一分钟的秒数。
m 最少考虑一小时的分钟数。
h 小时 l每天最少考虑的小时数。
d 一个月考虑的最少天数。
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('M');  // 11

  // Set new thresholds
  moment.relativeTimeThreshold('ss', 3);
  moment.relativeTimeThreshold('s', 40);
  moment.relativeTimeThreshold('m', 40);
  moment.relativeTimeThreshold('h', 20);
  moment.relativeTimeThreshold('d', 25);
  moment.relativeTimeThreshold('M', 10);

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

注意: 检索和设置ss阈值已在2.18.0中添加。

Relative Time Rounding 2.14.0+

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

duration.humanize在将其提供给locale中指定的relativeTime格式字符串之前舍入可能的double值。要控制舍入,您可以使用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', 31);
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'

Changing Time Source 2.11.0+

moment.now = function () { return +new Date(); }

如果要更改Moment看到的时间,可以指定一个方法,该方法返回自Unix纪元(1970年1月1日)以来的毫秒数。

默认为:

moment.now = function () {
    return +new Date();
}

这将在调用时使用moment(),并且当省略令牌时使用的当前日期format()。通常,任何需要当前时间的方法都会使用它。

First Day of Week and First Week of Year 1.0.0+

// 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.js也有持续时间对象。如果将时刻定义为单个时间点,则将持续时间定义为时间长度。

持续时间没有定义的开始和结束日期。他们没有上司。

持续时间在概念上更类似于'2小时'而不是'今天下午2点到4点'。因此,它们不是在依赖于上下文的单元之间进行转换的良好解决方案。

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

duration 1.6.0+

moment.duration(Number, String);
moment.duration(Number);
moment.duration(Object);
moment.duration(String);

要创建持续时间,请moment.duration()使用以毫秒为单位的时间长度进行调用。

moment.duration(100); // 100 milliseconds

如果要创建一个测量单位而非毫秒的力矩,您也可以通过测量单位。

moment.duration(2, 'seconds');
moment.duration(2, 'minutes');
moment.duration(2, 'hours');
moment.duration(2, 'days');
moment.duration(2, 'weeks');
moment.duration(2, 'months');
moment.duration(2, 'years');

同样的速记moment#addmoment#subtract工作也适用于此。

Key Shorthand
years y
months M
weeks w
days d
hours h
minutes m
seconds s
milliseconds ms

很像moment#add,如果您需要多个不同的测量单位,则可以传递值对象。

moment.duration({
    seconds: 2,
    minutes: 2,
    hours: 2,
    days: 2,
    weeks: 2,
    months: 2,
    years: 2
});

从2.1.0开始,moment支持解析ASP.NET样式时间跨度。支持以下格式。

格式是以冒号分隔的小时,分​​钟,秒字符串23:59:59。天数可以使用点分隔符作为前缀7.23:59:59。也支持部分秒23:59:59.999.

moment.duration('23:59:59');
moment.duration('23:59:59.999');
moment.duration('7.23:59:59.999');
moment.duration('23:59'); // added in 2.3.0

从2.3.0开始,moment还支持解析ISO 8601 持续时间。

moment.duration('P1Y2M3DT4H5M6S');
moment.duration('P1M');

从2.11.0开始,支持持续时间格式字符串,其中包含天和休息之间的空格。

moment.duration('7 23:59:59.999');

从2.13.0开始,在解析持续时间时支持混合的负号和正号。

moment.duration('PT-6H3M')

从2.18.0开始,支持无效的持续时间,与无效时刻类似。要创建无效的持续时间,您可以传递NaN单位的值。

在即将发布的版本中,期望无效的持续时间可以涵盖更多情况(例如单位的空值)。

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

Clone 2.19.0+

moment.duration().clone();

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

var d1 = moment.duration();
var d2 = d1.clone();
d1.add(1, 'second');
d1.asMilliseconds() !== d2.asMilliseconds();

Humanize 1.6.0+

moment.duration().humanize();

有时,你想要所有的善良,moment#from但你不想创造两个时刻,你只想显示一段时间。

输入moment.duration().humanize().

moment.duration(1, "minutes").humanize(); // a minute
moment.duration(2, "minutes").humanize(); // 2 minutes
moment.duration(24, "hours").humanize();  // a day

默认情况下,返回字符串是无后缀的。如果你想要一个后缀,传入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

Milliseconds 1.6.0+

moment.duration().milliseconds();
moment.duration().asMilliseconds();

要获得持续时间内的毫秒数,请使用moment.duration().milliseconds().

它将返回0到999之间的数字。

moment.duration(500).milliseconds(); // 500
moment.duration(1500).milliseconds(); // 500
moment.duration(15000).milliseconds(); // 0

如果您想要持续时间的长度(以毫秒为单位),请moment.duration().asMilliseconds() 改用。

moment.duration(500).asMilliseconds(); // 500
moment.duration(1500).asMilliseconds(); // 1500
moment.duration(15000).asMilliseconds(); // 15000

Seconds 1.6.0+

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

Minutes 1.6.0+

moment.duration().minutes();
moment.duration().asMinutes();

与持续时间的其他吸气剂一样,moment.duration().minutes()得分(0 - 59)。

moment.duration().asMinutes()得到持续时间的长度,以分钟为单位。

Hours 1.6.0+

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

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

moment.duration().asHours()得到持续时间的长度,以小时为单位。

Days 1.6.0+

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

与持续时间的其他吸气剂一样,moment.duration().days()得到天数(0 - 30)。

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

Weeks 1.6.0+

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

与持续时间的其他吸气剂一样,moment.duration().weeks()获得周数(0 - 4)。

moment.duration().asWeeks()得到持续时间的长度,以周为单位。

请注意,与持续时间的其他吸气剂不同,周数被计为天数的子集,并且不会从天数计算。

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

Months 1.6.0+

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

与持续时间的其他吸气剂一样,moment.duration().months()获得月份(0 - 11)。

moment.duration().asMonths()得到持续时间的长度,以月为单位。

Years 1.6.0+

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

与持续时间的其他吸气剂一样,moment.duration().years()获得年份。

moment.duration().asYears() 获得持续时间的长度。

Add Time 2.1.0+

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

请注意,向任何其他持续时间添加无效持续时间会导致无效持续时间。

Subtract Time 2.1.0+

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

请注意,向任何其他持续时间添加无效持续时间会导致无效持续时间。

Using Duration with Diff 2.1.0+

var duration = moment.duration(x.diff(y))

您还可以使用持续时间moment#diff来获取两个时刻之间的持续时间。为此,只需将moment#diff方法传递moment#duration如下:

  var x = new moment()
  var y = new moment()
  var duration = moment.duration(x.diff(y))
  // returns duration object with the duration between x and y

有关详细信息,请参见这里moment#diff.

As Unit of Time 2.1.0+

moment.duration().as(String);

作为替代Duration#asX,您可以使用Duration#as('x')。所有速记键也 moment#add适用于此处。

duration.as('hours');
duration.as('minutes');
duration.as('seconds');
duration.as('milliseconds');

NaN 所有单位的持续时间均无效。

Get Unit of Time 2.1.0+

moment.duration().get(String);

作为Duration#x()吸气剂的替代品,您可以使用Duration#get('x')。所有速记键也 moment#add适用于此处。.

duration.get('hours');
duration.get('minutes');
duration.get('seconds');
duration.get('milliseconds');

NaN所有单位的持续时间均无效。

As JSON 2.9.0+

moment.duration().toJSON();

将持续时间对象序列化为JSON时,它将表示为ISO8601字符串。

JSON.stringify({
    postDuration : moment.duration(5, 'm')
}); // '{"postDuration":"PT5M"}'

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

Is a Duration 1.6.0+

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

Locale 2.17.1+

moment.duration().locale();
moment.duration().locale(String);

您可以使用获取或设置持续时间的区域设置locale(...)。语言环境将影响持续时间的字符串方法,例如humanize()。有关国际化的更多信息,请参阅国际部分。

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

片刻公开了一些方法,这些方法可能对扩展库或编写自定义解析器的人有用。

Normalize Units 2.3.0+

moment.normalizeUnits(String);

Moment的许多函数允许调用者传入单元枚举的别名。例如,get下面的所有s都是等价的。

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'

Invalid 2.3.0+

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制作了可能对你有用的插件。/p>

MSDate

如果您在.NET中使用OLE自动化日期,请查看Markit On Demandmoment-msdate。使用此插件可以将OA日期格式化为JavaScript日期,反之亦然。

将a转换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/.

Java DateFormat Parser

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.

Twix

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

Precise Range

npm install moment-precise-range-plugin

Precise Range编写的Rob Dawson插件可用于显示日期/时间范围的精确,人类可读的表示:

moment("2014-01-01 12:00:00").preciseDiff("2015-03-04 16:05:06");
 // 1 year 2 months 3 days 4 hours 5 minutes 6 seconds
moment.preciseDiff("2014-01-01 12:00:00", "2014-04-20 12:00:00");
// 3 months 19 days

要获取原始数值而不是字符串,请将值true作为第三个参数传递给方法:

moment.preciseDiff(m1, m2, true); 
// {years : 0, months : 1, days : 2, hours : 3, minutes : 4, seconds : 5, firstDateWasLater : false}

ISO Calendar

npm install moment-isocalendar

如果您正在寻找类似Python的isocalendar方法,可以使用Rocky Meza的插件

moment-isocalendar

稍后调用isocalendar方法将返回如下所示的数组:

[year, week_of_year, day_of_week, minutes_since_midnight]

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

您还可以从isocalendar数组重建一个时刻。

moment.fromIsocalendar([2011, 51, 5, 870]).format('LLLL');
// "Friday, December 23 2011 2:30 PM"

存储库位于 github.com/fusionbox/moment-isocalendar.

Jalaali Calendar

npm install moment-jalaali

如果您想使用Jalaali日历系统(Jalali,Persian,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.

Hijri Calendar

npm install moment-hijri

如果你想使用Hijri日历,那么你可以使用moment-hijri插件。moment-hijri是基于Umm al-Qura 计算的Hijri农历的一个时刻插件。这个插件由Suhail Alkowaileet开发。

当你安装它时,它将换行moment,你将能够解析Hijri日期。这是一个简短的例子:

m = moment('1410/8/28', 'iYYYY/iM/iD'); // Parse a Hijri date.
m.format('iYYYY/iM/iD [is] YYYY/M/D'); // 1410/8/28 is 1990/3/25

存储库位于github.com/xsoh/moment-hijri.

Recur

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

如果你想格式化时间像Twitter的方式做微博,你可以使用moment.twitter通过插件 @hijonathan.

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

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

是的,它确实是智能多元化。

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

不够短吗?

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

Fiscal Quarters

如果你有需要的Fiscal,日历或学术宿舍,你可以使用 moment-fquarter 通过插件 @robgallen.

最简单的是,只需在任何时刻对象上调用fquarter方法。它返回一个格式化的字符串,其中April是第一季度。

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

您可以在任何月份作为起始季度,例如7月

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

如果你想要日历宿舍,请从1月份开始

moment("2013-01-01").fquarter(1);
// Q1 2013

Parse Date Format

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. Links: Demo | Source

Round

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.

Transform

bower install moment-transform

moment-transform是一个通过模式操纵日期的插件。您可以对Moment实例的各个部分(小时,月,...)使用基本操作-set / add / subtract。

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

当存储库在这里 时,你可以看到它存在.

Taiwan Calendar

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.

Timer

edit
npm install moment-timer

这是一个Moment.js插件,允许使用定时器,它提供比本机JavaScript定时器更多的控制。它基本上是JavaScripts自己的setInterval和setTimeout的重写。

例如,

var timer = moment.duration(5, "seconds").timer({loop: true}, function() {
  // Callback
});

存储库位于github.com/SeverinDK/moment-timer.

Business

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.

Short Date Formatter

edit

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

它基于和类似于moment.twitter插件但具有不同的输出。

moment().subtract(5, 'hours').short();
// 5h ago
moment().add(5, 'hours').short();
// in 5h

您还可以禁用相对时间模板的使用

moment().subtract(1, 'hour').short(false);
// 1h

如果日期在将来或过去太远,它将显示如此

moment().subtract(500, 'days').short();
// 5 Mar, 1970

German Holiday (Feiertag)

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.