Moment.jsは数百万のプロジェクトで成功裏に使用されており、ウェブ上での日付と時刻の扱い向上に貢献できたことを嬉しく思っています。2020年9月現在、Momentは毎週1200万回以上のダウンロード数を誇っています！しかし、Momentは以前のJavaScriptエコシステムのために構築されました。現代のウェブは大きく様変わりしました。Momentは長年にわたって多少進化しましたが、2011年に作成されたときと本質的に同じ設計です。多くのプロジェクトがMomentに依存していることを考えると、新機能よりも安定性を優先することにしました。

例として、Momentオブジェクトは変更可能であることを考えてみましょう。これは、Momentに関するよくある不満の1つです。私たちはそれを使用方法ガイドで説明していますが、それでも多くの新規ユーザーにとって意外なことです。Momentを変更不可能にすることは、それを使用するすべてのプロジェクトにとって破壊的な変更になります。変更不可能な「Moment v3」を作成することは大変な作業であり、Momentを全く別のライブラリにしてしまいます。これは他のライブラリですでに達成されているため、変更可能なAPIを維持することがより重要だと考えています。

現代のアプリケーションでMomentを使用することに対するもう1つの一般的な反論は、そのサイズです。Momentは最新の「ツリーシェイキング」アルゴリズムと連携せず、ウェブアプリケーションバンドルのサイズが増える傾向があります。国際化またはタイムゾーンサポートが必要な場合、Momentは非常に大きくなる可能性があります。最新のウェブブラウザ（およびNode.js）は、Intlオブジェクトを介して国際化とタイムゾーンサポートを提供しており、ECMA-402として規定されています。Luxon（およびその他）のようなライブラリはこれを利用して、独自のデータファイルの配信を削減または排除します。

最近、Chrome Dev ToolsはサイズだけでMomentの置き換えを推奨し始めました。私たちは一般的にこの動きを支持しています。

以下の記事も参照してください。

• Moment.jsはもう必要ないかもしれない
• Moment.jsは(もしかしたら)必要ない
• Moment.jsを使用すべきでない理由…
• 日付の国際化のためのmoment.jsの4つの代替手段

Momentチームはこれらの問題について詳細に議論してきました。多くの既存のプロジェクトはMomentを使い続ける可能性がありますが、新しいプロジェクトではMomentの使用を控えることをお勧めします。代わりに、今日の最新のアプリケーションで使用するための優れた選択肢である代替手段をお勧めします。また、フィードバックと貢献者を募っているJavaScript言語へのTemporalの追加も推進したいと思います。

現在、Momentはメンテナンスモードのレガシープロジェクトとみなしています。死んでいるわけではありませんが、確かに終了しています。

実際には、これは次のことを意味します。

• 新機能や機能を追加しません。
• MomentのAPIを変更不可能にすることはありません。
• ツリーシェイキングやバンドルサイズの課題に対処しません。
• 一切の大きな変更(バージョン3はありません)を行いません。
• 特に長年知られている問題の場合、バグや動作上の癖を修正しない場合があります。

Momentの国際化ロケールファイルに関して具体的に言うと

• 特に、現在の形式に関してうまく主張されている場合、ロケール文字列またはローカライズされた日付形式の修正を受け入れない場合があります。
• あなたの主張を支持する重要な、逸話的な証拠ではない証拠を提示して、ロケール変更について新たな説得力のある議論を行う必要があります。
• 変更を求めている文字列または形式がCLDRに反映されている場合は、最初にそこで変更を提出して承認を受ける必要があります。

しかし、Momentが数百万の既存プロジェクトで確立されていることを理解しているので

• 発生する重大なセキュリティ上の問題には対応します。
• IANAタイムゾーンデータベースのリリースに続いて、Moment-Timezoneのデータ更新をリリースします。

Momentを使い続ける理由

ほとんどの場合、新しいプロジェクトではMomentを選択すべきではありません。ただし、Momentを使い続けたいと思う可能性のある理由がいくつかあります。

ブラウザのサポート

MomentはInternet Explorer 8以降で良好に動作します。これに対し、LuxonはIE 10以降でのみ動作し、そのためにはポリフィルが必要です。Luxonのドキュメントで詳細を確認できます。

他のライブラリも、特にモバイルデバイスでのSafariで問題が発生しています。古いブラウザをサポートするという強い要件がある場合、しばらくはMomentを使い続けることを検討しても良いでしょう。

ただし、Day.jsはIE8以降との互換性を報告していますので、それでも代替手段を検討することをお勧めします。

他のライブラリによる依存関係

特に日付ピッカーやグラフ作成ライブラリなど、いくつかの他のライブラリはMomentを依存関係として使用しています。そのようなコンポーネントを使用していて代替手段が見つからない場合は、既にプロジェクトにMomentを含んでいます。したがって、別の時刻と日付のライブラリを含めるよりも、プロジェクト全体でMomentを使い続ける方が理にかなっている可能性があります。

使い慣れ

Momentの長期ユーザーであれば、そのAPIと制限を既に十分に理解している可能性があります。その場合、前述の問題が懸念事項でない場合は、確かに使い続けることができます。

Momentの代わりに使用することを検討できる優れた選択肢がいくつかあります。

選択する際には、次の点に注意してください。

• 一部のライブラリは、モジュール、プラグイン、または付属ライブラリに分割されています。
• 一部のライブラリは、ロケール、タイムゾーン、またはその両方にECMAScript Intl APIを使用します。
• 一部のライブラリは、MomentとMoment-Timezoneのように、独自のロケールとタイムゾーンファイルを提供しています。

推奨する代替手段を以下に示します。

Luxon

Luxonは、Momentの進化版と考えることができます。Momentの長期貢献者であるIsaac Cambronによって作成されました。LuxonのドキュメントのなぜLuxonが存在するのか？とMomentユーザー向けのページをお読みください。

• ロケール：Intl提供
• タイムゾーン：Intl提供

Day.js

Day.jsは、同様のAPIを使用して、Moment.jsのミニマリストな代替となるように設計されています。ドロップイン交換ではありませんが、MomentのAPIの使用に慣れている場合、迅速に作業を進めたい場合は、Day.jsの使用を検討してください。

• ロケール：個別にインポートできるカスタムデータファイル
• タイムゾーン：プラグインを介してIntl提供

date-fns

Date-fnsは、JavaScript Dateオブジェクトを操作するための関数シリーズを提供します。詳細については、date-fnsのホームページで「なぜdate-fnsなのか？」までスクロールしてください。

• ロケール：個別にインポートできるカスタムデータファイル
• タイムゾーン：別の付属ライブラリを介してIntl提供

js-Joda

js-Jodaは、JavaのThree-Ten BackportのJavaScriptポートであり、Java SE 8 java.timeパッケージのJSR-310実装の基礎となっています。java.time、Joda-Time、またはNoda Timeに精通している場合は、js-Jodaを同等のものと感じるでしょう。

• ロケール：アドオンモジュールを介したカスタムデータファイル
• タイムゾーン：アドオンモジュールを介したカスタムデータファイル

ライブラリなし

JavaScriptには常にDateオブジェクトがあり、ECMAScript（ECMA-262）仕様こちらで定義されています。

Dateオブジェクトを使用する際には、次の点に注意してください。

• Dateオブジェクトは内部的にミリ秒精度のUnixタイムスタンプを表します。システムのローカルタイムゾーンとの間で変換を行う関数を提供しますが、内部的には常にUTCです。Momentオブジェクトとは異なり、別のタイムゾーンを使用するように設定することはできません。「モード」という概念はありません。

• Date.parse あるいは new Date(<string>) を使用することは、過去において問題が多く、実装に一貫性がありませんでした。現在の仕様では、ISO 8601文字列のバリエーションの解析を定義しており、日付のみの形式（例："2020-09-14"）は、ISO 8601でローカル時間として扱われる代わりにUTCとして解析されます。それでも、すべての最新のJavaScript実装がこの仕様を正しく実装しているわけではありません（例：Safari）。他のタイプの文字列も機能する可能性がありますが、それらの解析は実装固有であり、特に古いブラウザでは大きく異なる可能性があります。実装と文字列に含まれるコンポーネントによっては、結果に驚くかもしれません。これらの理由から、MDNの説明 に同意し、`Date`オブジェクトで文字列を解析することは強く推奨しません。

最新のJavaScript環境では、ECMA-402仕様も実装されます。これは、Intlオブジェクトを提供し、`Date`オブジェクトの`toLocaleString`、`toLocaleDateString`、`toLocaleTimeString`関数の動作オプションを定義します。

Intlオブジェクトを使用する際には、以下の点に注意してください。

• すべての環境で完全な仕様が実装されるとは限りません。特に、Node.js環境では、ICUによって提供される国際化サポートが必要です。詳細は、Node.jsのドキュメントを参照してください。
• ECMAScript Intl互換性表（kangaxによる） は、どの機能がサポートされ、どの機能がサポートされないかを判断するのに役立ちます。
• 最新の環境のほとんどは、Intl.DateTimeFormatコンストラクタ（およびDate.toLocaleString、Date.toLocaleDateString、Date.toLocaleTimeString）のtimeZoneオプションを介してIANAタイムゾーンサポートを提供します。このオプションを使用すると、Dateオブジェクトの内部UTCベースのタイムスタンプを取得し、名前付きタイムゾーンに変換された文字列を取得できます。ただし、Dateオブジェクトを別のタイムゾーンに変換するには使用できません。

DateオブジェクトとIntlオブジェクトがニーズを満たし、その制限を完全に理解している場合は、それらを直接使用することを検討できます。

Temporal - JavaScript言語における、より優れた日付と時刻の処理！

近い将来、JavaScriptで日付と時刻のライブラリを強く必要とすることはなくなることを願っています。代わりに、JavaScript言語自体の機能を使用できるようになります。DateとIntlで現在利用できる機能もありますが、経験とデータから、改善の余地が大きいことがわかっています。

JavaScript言語でより優れた日付と時刻のAPIを作成するための取り組みは、ECMA TC39 Temporal提案を通じて行われています。現在、TC39プロセスのStage 3にあります。

Temporalは、トップレベルの名前空間（Mathなど）として機能する新しいグローバルオブジェクトになります。Temporal.Instant、Temporal.ZonedDateTime、Temporal.PlainDateTime、Temporal.PlainDate、Temporal.PlainTime、Temporal.TimeZoneなど、多くの個別のオブジェクトタイプを公開します。Temporalクックブックでは、これらのオブジェクトをさまざまなシナリオで使用する方法の例を示した多くの「レシピ」を紹介しています。

本番環境では使用できないポリフィルを使用して、Temporalを今日から試すことができます。ぜひお試しください。ただし、（まだ）本番環境では使用しないでください！

フィードバックをお寄せいただき、この取り組みに貢献いただければ幸いです。特に、Momentや他の日付と時刻のライブラリを使用した経験をお持ちの方はご協力をお願いします！

Momentは、ブラウザとNode.jsの両方で動作するように設計されています。

すべてのコードはこれらの両方の環境で動作し、すべての単体テストはこれらの両方の環境で実行されます。

現在、CIシステムでは、Windows XP上のChrome、Windows 7上のIE 8、9、10、Windows 10上のIE 11、Linux上の最新のFirefox、OSX 10.8および10.11上の最新のSafariが使用されています。

以下のサンプルコードを試したい場合は、ブラウザのコンソールを開いて入力してください。

npm install moment

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

またはES6構文

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

注：2.4.0では、グローバルにエクスポートされたmomentオブジェクトは非推奨になりました。次のメジャーリリースで削除されます。

Moment Timezoneも追加したい場合は、例を示したNode.js用のMoment Timezoneドキュメントを参照してください。

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

Moment.jsは、cdnjs.comとjsDelivrで利用できます。

bower

bower install --save moment

注目すべきファイルは、moment.js、locale/*.js、min/moment-with-locales.jsです。

Require.jsでmomentを使用する予定がある場合は、これを読むことを強くお勧めします。また、最高のエクスペリエンスを得るために、2.14.0以上にアップグレードしてください。

まず、bowerやnode_modulesなど、localesディレクトリをベースフォルダに配置するmoment.jsを配置するツールを通じてmomentを取得した可能性があります。その後、adapt-pkg-mainなどのツールを使用するか、手動でpackages configを使用して実行する必要があります。

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

上記のセットアップでは、momentでコアを、moment/locale/deでdeロケールを必要とすることができます。

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

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

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

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

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

より複雑なユースケースについては、@jrburkeによる優れた説明をお読みください。

Momentは引き続きmomentグローバルを作成します。これは、プラグインやその他のサードパーティコードに役立ちます。そのグローバルを抑制する場合は、モジュール構成でnoGlobalオプションを使用します。

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

noGlobalを指定しない場合、グローバルにエクスポートされたmomentは非推奨警告を出力します。次のメジャーリリース以降は、その動作が必要な場合は自分でエクスポートする必要があります。

バージョン2.5.xの場合、Momentに依存するがAMD互換ではない他のプラグインを使用している場合は、r.js構成にwrapShim: trueを追加する必要がある場合があります。

注：moment.jsプラグインをrequirejs環境でロードできるようにするために、momentは名前付きモジュールとして作成されます。このため、momentは"moment"として正確にロードする必要があり、パスを使用してディレクトリを決定します。"vendor\moment"のようなパスでmomentを要求すると、undefinedが返されます。

注：バージョン2.9.0から、momentは匿名モジュールとしてエクスポートされるため、コアのみ（ロケール/プラグインなし）を使用している場合は、標準以外の場所に配置した場合、構成は必要ありません。

NuGet / Moment.js

Install-Package Moment.js

meteor / atmosphere / momentjs:moment

meteor add momentjs:moment

npm install moment

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

注：moment.localeのロードを防ぐバグがあります。

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

以下の回避策を使用してください。

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

すべてのロケールを含めるには

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

npm install moment

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

注：デフォルトでは、WebpackはすべてのMoment.jsロケールをバンドルします（Moment.js 2.18.1では、160KBの縮小サイズになります）。不要なロケールを削除し、使用されているロケールのみをバンドルするには、moment-locales-webpack-pluginを追加します。

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

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

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

WebpackでMoment.jsを最適化する他のリソースもあります。例えばこれ。

バージョン2.13.0から、MomentはTypeScript定義ファイルを含んでいます。

NPM経由でインストール

npm install moment

TypeScriptファイルにインポートして使用

const moment = require('moment');

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

注：momentのインポートで問題が発生した場合

TypeScript 2.xの場合は、tsconfig.jsonファイルのcompilerOptionsに"moduleResolution": "node"を追加してみてください。

TypeScript 1.xの場合は、tsconfig.jsonファイルのcompilerOptionsに"allowSyntheticDefaultImports": trueを追加し、次の構文を使用してみてください。

import moment from 'moment';

ロケールのインポート

moment.localeを使用するには、最初にターゲットとする言語をインポートする必要があります。

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

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

momentをロードするには、baseURL構成でSystem.configによって指定されたパスに配置します。次に、ページにインポートします。

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

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

momentをグローバルとしてロードする必要がある場合は、メタ構成を使用してこれを行うことができます。

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

または、特定の依存関係のみにグローバルとしてMomentを提供するには、次のようにします。

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

Java/Rhinoで使用する場合は、この手順を参照してください。

Demandwareで使用する場合は、この手順を参照してください。

問題が発生した場合は、まずガイドを確認してください。

そこで必要なものが見つからない場合は、momentjsタグを付けてStack Overflowで質問してみてください。

注：Stack Overflowで見られる問題の半分以上は、このブログ投稿で回答できます。

GitHubのissueトラッカーを使用して、関連するissueを見つけるか、新しいissueを開くこともできます。

さらに、Momentには、内部チームが頻繁に利用できるGitterがあります。

一般的なトラブルシューティングのヘルプについては、Stack Overflowが推奨されるフォーラムです。MomentのメンテナーはStack Overflowで非常にアクティブであり、他の多くの知識のあるユーザーも同様にアクティブです。最も迅速な回答が得られます。

ネイティブのDate.prototypeを変更する代わりに、Moment.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()は、渡された入力ゾーンを保持します。曖昧な入力はUTCとみなされます。
• moment-timezoneプラグインを使用するmoment.tz(...)は、特定のタイムゾーンの入力を解析できます。

タイムゾーンとタイムゾーンオフセットは異なるものであることに注意してください。-08:00のオフセットは、必ずしも米国太平洋時間帯にいることを意味するわけではありません。

詳細については、解析ガイドを参照してください。.

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

現在の日付と時刻を取得するには、パラメータなしでmoment()を呼び出すだけです。

var now = moment();

これは基本的にmoment(new Date())を呼び出すことと同じです。

注：バージョン2.14.0から、moment([])とmoment({})も現在時刻を返します。2.14.0以前は今日の始まりをデフォルトとしていましたが、これは恣意的だったので変更されました。

注記: 関数パラメータは、渡されない場合、undefined をデフォルト値として使用します。Moment は moment(undefined) を moment() として扱います。

注記: Moment オブジェクトは評価時に作成されるため、moment().diff(moment()) は常に 0 を返すとは限りません。詳細は このGitHubのissue を参照してください。

moment(String);

文字列からMomentオブジェクトを作成する場合、まず、その文字列が既知のISO 8601形式と一致するかどうかを確認します。一致しない場合は、RFC 2822日時形式と一致するかどうかを確認し、既知の形式が見つからない場合は、new Date(string) のフォールバックを使用します。

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

警告: 文字列の解析におけるブラウザのサポートは一貫性がないため、あるブラウザで動作するものが、他のブラウザでは動作しない場合があります。サポートされるべき形式に関する仕様がないためです。

ISO 8601文字列以外のものを一貫して解析するには、文字列 + 形式を使用する必要があります。

サポートされているISO 8601文字列

ISO 8601文字列には、日付部分が必須です。

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

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

時間部分を含めることもでき、日付部分とはスペースまたは大文字のTで区切られます。

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

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

日付部分のいずれにも時間部分を含めることができます。

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

時間部分を含める場合、UTCからのオフセットを+-HH:mm、+-HHmm、+-HH、またはZとして含めることもできます。

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

注記: 週と序数の形式のサポートは、バージョン2.3.0で追加されました。

文字列が上記のいずれの形式にも一致せず、Date.parseで解析できない場合、moment#isValidはfalseを返します。

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

RFC 2822日時形式

RFC 2822日時を解析する前に、コメントや改行文字を削除して文字列をクレンジングします。これらの追加文字は形式上有効ですが、有効なMomentオブジェクトインスタンスの作成には何も追加しません。

クレンジング後、文字列は、すべて英語を使用して、以下のスペースで区切られたセクションで検証されます。

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

1. 曜日の頭3文字、オプションでカンマが続きます。(オプション)
2. 月の1桁または2桁の日付、3文字の月名、2桁または4桁の年
3. コロン(:)で区切られた2桁の時間と分、オプションでコロンと2桁の秒が続きます。
4. 以下のいずれかの形式のタイムゾーンまたはオフセット
5. UT : +0000
6. GMT : +0000
7. EST | CST | MST | PST | EDT | CDT | MDT | PDT : 米国時間帯*
8. A - I | K - Z : 軍事時間帯*
9. 時間オフセット +/-9999

[*] 詳細は、仕様の4.3節を参照してください。

パーサーは、曜日（含まれる場合）が日付と一致していることを確認します。

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

入力文字列の形式がわかっている場合は、それを使用してMomentオブジェクトを解析できます。

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

パーサーはデフォルトで英数字以外の文字を無視するため、次の2つは同じ結果を返します。

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

日付と時刻の両方を解析する場合、予期しない結果が発生することがあります。以下の例は、期待通りに解析されない可能性があります。

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

厳密モードを使用すると、解析エラーを特定し、Momentオブジェクトを無効として設定できます。

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

解析トークンは、moment#formatで使用されるフォーマットトークンに似ています。

年、月、日のトークン

トークンは大文字と小文字が区別されます。

バージョン2.10.5から、YYYYは厳密でないモードで2桁の年をサポートし、2000年近くの年に変換します(YYと同じ)。

Yは2.11.1で追加されました。符号付きまたは符号なしの任意の数を一致させます。4桁でない年、または西暦以前の年に役立ちます。任意の年に使用できます。

週年、週、曜日のトークン

これらについては、小文字のトークンはロケール対応の週の開始日を使用し、大文字のトークンはISO週日付の開始日を使用します。

トークンは大文字と小文字が区別されます。

ロケール対応の形式

LT LTS L LL LLL LLLLを使用して、ロケール対応の日付と時刻の形式も使用できます。LTSは2.8.4で追加されたものを除き、バージョン2.2.1で追加されました。

トークンは大文字と小文字が区別されます。

時、分、秒、ミリ秒、オフセットのトークン

トークンは大文字と小文字が区別されます。

バージョン2.10.5から: 小数秒トークンの長さが4～9の場合、任意の桁数の数字を解析できますが、上位3桁（ミリ秒）のみが考慮されます。多くの小数桁で時間が表示され、入力を消費する場合に使用します。

S文字の数（指定されている場合）は、厳密モードでの解析の場合のみ関連します。標準モードでは、S、SS、SSS、SSSSはすべて同等であり、秒の小数部分として解釈されます。たとえば、.12は常に120ミリ秒であり、SSを渡しても12ミリ秒として解釈されることはありません。

Z ZZはバージョン1.2.0で追加されました。

S SS SSSはバージョン1.6.0で追加されました。

Xはバージョン2.0.0で追加されました。

SSSSS ... SSSSSSSSSはバージョン2.10.5で追加されました。

k kkはバージョン2.13.0で追加されました。

タイムゾーンオフセットを指定しない限り、文字列の解析によって現在のタイムゾーンで日付が作成されます。

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

時代年関連トークン

トークンは大文字と小文字が区別されます。

時代サポートは2.25.0で追加されました。トークン/APIはまだ変更される可能性があります。

注記と注意点

解析された入力から得られるMomentオブジェクトが存在しない場合、moment#isValidはfalseを返します。

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

バージョン2.0.0から、ロケールキーをmoment()とmoment.utc()の第3パラメータとして渡すことができます。

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

Momentのパーサーは非常に寛容であるため、望ましくない/予期しない動作につながる可能性があります。

たとえば、次の動作が観察できます。

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

2.13.0より前は、パーサーは次の動作を示していました。これは修正されています。

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

バージョン2.3.0から、最後の引数にブール値を指定して、Momentに厳密な解析を使用させることができます。厳密な解析では、形式と入力が完全に一致する必要があります（区切り記号も含む）。

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

ロケールと厳密さの両方を同時に使用できます。

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

厳密な解析は多くの場合、最適な解析方法です。厳密な解析と寛容な解析の選択の詳細については、解析ガイドを参照してください。

2桁の年の解析

デフォルトでは、68より大きい2桁の年は1900年代、68以下の年は2000年代とみなされます。これは、moment.parseTwoDigitYearメソッドを置き換えることで変更できます。このメソッドの引数は1つだけで、ユーザーが入力した2桁の年を含む文字列であり、整数の年を返す必要があります。

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

連結された時と分の解析

バージョン2.11.0から、hmm、Hmm、hmmss、Hmmssの解析がサポートされています。

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

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

入力文字列の正確な形式は不明だが、複数の形式のいずれかであることがわかっている場合は、形式の配列を使用できます。

これは文字列 + 形式と同じですが、入力を複数の形式に一致させようとします。

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

バージョン2.3.0から、Momentは単純なヒューリスティックを使用して、使用する形式を決定します。順序は次のとおりです。

• 有効な日付をもたらす形式を、無効な形式よりも優先します。
• 文字列のより多くの部分を解析し、形式のより多くの部分を使用する形式を優先します。つまり、より厳密な解析を優先します。
• 配列の先頭の形式を、後の方の形式よりも優先します。

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

ロケール引数と厳密さ引数も指定できます。これらは、単一形式の場合と同じように機能します。

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

注記: 複数のフォーマットを解析する処理は、単一のフォーマットを解析する処理に比べてかなり遅くなります。可能な限り、単一のフォーマットを解析する方が高速です。

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

ISO-8601 は、時間と期間の表示のための標準です。Moment は既に ISO-8601 文字列の解析をサポートしていますが、Moment を構築する際のフォーマット/フォーマットリストで明示的に指定できます。

ISO-8601 解析を指定するには、moment.ISO_8601 定数を使用します。

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

バージョン2.20.0から、以下の HTML5 フォーマットがmomentオブジェクトのHTML5_FMTプロパティ(moment.HTML5_FMT.*)で定数として利用可能です。

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

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

いくつかの単位をオブジェクトで指定して Moment を作成できます。

省略された単位は、0 または現在の日付、月、年にデフォルト設定されます。

dayキーとdateキーはどちらも月の日のことを意味します。

dateは2.8.4で追加されました。

文字列値（最終行に示されているもの）は、バージョン2.11.0からサポートされています。

moment(Array)およびnew Date(year, month, date)と同様に、月は0から始まるインデックスです。

moment(Number);

new Date(Number)と同様に、Unix エポック（1970年1月1日午前12時UTC）からのミリ秒数を表す整数値を渡して Moment を作成できます。

var day = moment(1318781876406);

注記: ECMAScript ではこれを「時間値」と呼びます。

moment.unix(Number)

Unix タイムスタンプ（Unix エポックからの秒数）から Moment を作成するには、moment.unix(Number)を使用します。

var day = moment.unix(1318781876);

これはmoment(timestamp * 1000)として実装されているため、入力タイムスタンプの小数秒も含まれます。

var day = moment.unix(1318781876.721);

注記: Unix タイムスタンプは UTC ベースですが、この関数はローカルモードで Moment オブジェクトを作成します。UTC が必要な場合は、その後で.utc()を呼び出してください。

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

moment(Date);

既存のネイティブ JavaScript Dateオブジェクトを使用してMomentを作成できます。

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

これはDateオブジェクトを複製します。Dateへのそれ以降の変更はMomentに影響せず、その逆も同様です。

moment(Number[]);

new Date()に渡されたパラメーターを反映する数値の配列を使用して Moment を作成できます。

[年、月、日、時、分、秒、ミリ秒]

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

年以降の値はオプションであり、最小値にデフォルト設定されます。

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

配列を使用して構築すると、現在のタイムゾーンで日付が作成されます。UTC で配列から日付を作成するには、moment.utc(Number[])を使用します。

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

注記: これはネイティブのDateパラメーターを反映しているため、月、時、分、秒、ミリ秒はすべて0から始まるインデックスです。年と月の日は1から始まるインデックスです。

これは、特に月に関して、しばしば不満の原因となりますので、注意してください！

配列によって表される日付が存在しない場合、moment#isValidはfalseを返します。

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

moment(String);

Microsoft Web API はデフォルトで JSON 日付を適切な ISO-8601 フォーマットで返しますが、古い ASP.NET テクノロジーでは、JSON の日付が/Date(1198908717056)/または/Date(1198908717056-0700)/として返される場合があります。

このフォーマットに一致する文字列が渡された場合、正しく解析されます。

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

moment(Moment);

すべての Moment は変更可能です。Moment のクローンを作成する場合は、暗黙的または明示的に行うことができます。

Moment でmoment()を呼び出すと、クローンが作成されます。

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

さらに、moment#cloneを呼び出して Moment を複製することもできます。

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

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

デフォルトでは、Moment はローカル時間で解析および表示します。

UTC で Moment を解析または表示する場合は、moment()の代わりにmoment.utc()を使用できます。

これが、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#get*メソッドとDate#set*メソッドの代わりにDate#getUTC*メソッドとDate#setUTC*メソッドを使用します。

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()で作成された Moment はすべて UTC モードになり、moment()で作成された Moment は UTC モードになりません。

UTC からローカル時間に変更するには、moment#utcまたはmoment#localを使用できます。

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

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

moment(string)やmoment.utc(string)のような Moment の文字列解析関数は、提供されている場合にオフセット情報を取得しますが、結果の Moment オブジェクトをローカル時間または UTC 時間に変換します。対照的に、moment.parseZone()は文字列を解析しますが、結果の Moment オブジェクトは、文字列に指定されたオフセットを持つ固定オフセットのタイムゾーンのままです。

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

ロケールと厳密性の引数も渡すことができます。

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

moment.parseZoneは、文字列を解析し、moment#utcOffsetを使用してゾーンを解析することと同等です。

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

moment().isValid();

Moment は、Dateコンストラクターよりも厳格な初期化ルールを適用します。

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

moment#isValidを使用して、Moment が日付を無効と見なすかどうかを確認できます。#isValidで使用されるメトリックは、オブジェクトを返すmoment#parsingFlagsを使用して確認できます。

次の解析フラグは、無効な日付になります。

• overflow: 13番目の月、月の32日目（または閏年以外での2月の29日目）、年の367日目など、日付フィールドのオーバーフロー。overflowには、#invalidAt（下記参照）に一致する無効な単位のインデックスが含まれています。-1はオーバーフローがないことを意味します。
• invalidMonth: moment('Marbruary', 'MMMM');など、無効な月の名前が含まれています。無効な月の文字列自体、またはnullが含まれています。
• empty: moment('this is nonsense');など、解析可能なものが何も含まれていない入力文字列。ブール値。
• nullInput: moment(null);などのnull入力。ブール値。
• invalidFormat: moment('2013-05-25', [])など、空のフォーマットリスト。ブール値。
• userInvalidated: moment.invalid()など、明示的に無効として作成された日付。ブール値。

上記に加えて、2.13.0から、子午線とparsedDatePartsフラグが連携して日付の有効性を決定します。

• meridiem: 解析された子午線（午前/午後）がある場合、その子午線を示します。文字列。
• parsedDateParts: 解析された日付の部分を降順で返す配列 - つまり、parsedDateParts[0] === year。部分が存在せず、子午線に値がある場合、日付は無効です。配列。

さらに、Moment が厳格モードで解析された場合、これらのフラグは Moment が有効であるためには空である必要があります。

• unusedTokens: 入力文字列に見つからないフォーマット部分文字列の配列
• unusedInput: フォーマット文字列に一致しない入力部分文字列の配列

注記: Moment の有効性の概念は、2.2と2.3の間でより厳格で一貫性のあるものになりました。注記: 有効性は Moment の作成時に決定されます。変更された Moment（つまり、moment().hour(NaN)）は有効なままです。

さらに、moment#invalidAtを使用して、どの日付単位がオーバーフローしたかを判断できます。

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

戻り値の意味は以下のとおりです。

1. 年
2. 月
3. 日
4. 時
5. 分
6. 秒
7. ミリ秒

注記: 複数の誤った単位がある場合、最初の単位が返されます（たとえば、日の有効性は月に依存する場合があります）。

無効な Moment

Moment が無効な場合、浮動小数点演算の NaN のように動作します。

次のすべてが無効な Moment を生成します。

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

次のものは、ローカライズされたバージョンの 'InvalidDate' を生成します。

• invalid.format(anyFmt)は、現在のロケールで 'Invalid Date' になります。
• invalid.from(another)
• another.from(invalid)
• invalid.fromNow(suffix)
• invalid.to(another)
• another.to(invalid)
• invalid.toNow(suffix)
• invalid.toISOString()（2.18.0以前）
• invalid.toString()

次のものはfalseを返します。

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

そして、これらは何らかの構造でnullまたはNaNを返します。

• invalid.get(unit)はnullを返し、他の名前付きgetterも同様です。
• invalid.toArray() === [NaN, NaN, NaN, NaN, NaN, NaN]
• invalid.toObject()のすべての値はNaNに設定されています。
• invalid.toDate()は無効なDateオブジェクトを返します。
• invalid.toJSON()はnullを返します。
• invalid.unix()はnullを返します。
• invalid.valueOf()はnullを返します。
• invalid.toISOString()はnullを返します（2.18.0から）

moment().creationData();

Moment オブジェクトが作成された後、すべての入力はcreationData()メソッドでアクセスできます。

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

moment("15", "hh")

一部の単位のみを指定して Moment オブジェクトを作成でき、残りの単位は現在の日付、月、年、または時、分、秒、ミリ秒の0にデフォルト設定されます。

何も渡されない場合、現在時刻にデフォルト設定されます。

moment();  // current date and time

時、分、秒、ミリ秒のみが渡された場合、今日にデフォルト設定されます。

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

日とそれ以下の単位のみが渡された場合、今月と今年にデフォルト設定されます。

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

年が指定されていない場合、今年にデフォルト設定されます。

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

Moment.js はオーバーロードされた getter と setter を使用します。jQuery での使用例からこのパターンに精通しているかもしれません。

これらのメソッドをパラメーターなしで呼び出すと getter として機能し、パラメーター付きで呼び出すと setter として機能します。

これらは、ネイティブのDateオブジェクトの対応する関数にマップされます。

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

UTC モードの場合、UTC と同等のものにマップされます。

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

便宜上、バージョン2.0.0から、単数形と複数形のメソッド名が両方存在します。

注記: これらのメソッドはすべて、setter として使用されると元の Moment を変更します。

注記: 2.19.0から、setter にNaNを渡しても無効になります。2.19.0以前は、間違った方法で Moment を無効にしていました。

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

ミリ秒を取得または設定します。

0〜999の数値を受け入れます。範囲を超えると、秒にバブルアップします。

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

秒を取得または設定します。

0から59の数値を受け入れます。範囲を超えた場合は、分に繰り上がります。

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

分を取得または設定します。

0から59の数値を受け入れます。範囲を超えた場合は、時間に繰り上がります。

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

時を取得または設定します。

0から23の数値を受け入れます。範囲を超えた場合は、日に繰り上がります。

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

月の曜日を取得または設定します。

1から31の数値を受け入れます。範囲を超えた場合は、月に繰り上がります。

注記: Moment#date は月の曜日を表し、Moment#day は曜日の日付を表します。

注記: 日付を作成するために複数の操作をチェーンする場合は、年、月、日の順に開始する必要があります。 そうしないと、予期しない結果になる可能性があります。例えば、day=31 で現在の月が30日しかない場合（ネイティブ JavaScript の `Date` 操作にも同じことが当てはまります）、返される日付は現在の月の30日になります（詳細については 月 を参照してください）。

悪い例: moment().date(day).month(month).year(year)

良い例: moment().year(year).month(month).date(day)

2.16.0 では、moment().dates() の使用が非推奨となりました。代わりに moment().date() を使用してください。

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

曜日を取得または設定します。

このメソッドを使用して、日曜日を0、土曜日を6として曜日の日付を設定できます。

指定された値が0から6の場合、結果の日付は現在の週（日曜日から土曜日）内になります。

範囲を超えた場合は、他の週に繰り上がります。

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

注記: Moment#date は月の曜日を表し、Moment#day は曜日の日付を表します。

2.1.0 以降、曜日の名前もサポートされています。これは、モーメントの現在のロケールで解析されます。

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

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

ロケールに従って曜日を取得または設定します。

ロケールで月曜日が週の最初の日として割り当てられている場合、moment().weekday(0) は月曜日になります。日曜日が週の最初の日である場合、moment().weekday(0) は日曜日になります。

moment#day と同様に、範囲を超えた場合は、他の週に繰り上がります。

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

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

月曜日を1、日曜日を7としてISO曜日を取得または設定します。

moment#day と同様に、範囲を超えた場合は、他の週に繰り上がります。

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

曜日の名前もサポートされています。これは、モーメントの現在のロケールで解析されます。

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

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

年の日を取得または設定します。

1から366の数値を受け入れます。範囲を超えた場合は、年に繰り上がります。

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

年の週を取得または設定します。

異なるロケールでは年の週の番号付けが異なるため、Moment.js はローカライズされた年の週を取得/設定するためのmoment#weekを追加しました。

年の週は、週の最初の日（日曜日、月曜日など）と、年の最初の週がどれであるかによって異なります。

例えば、米国では、日曜日は週の最初の日です。1月1日を含む週は、年の最初の週です。

フランスでは、月曜日は週の最初の日であり、1月4日を含む週は年の最初の週です。

moment#week の出力は、そのモーメントのロケールによって異なります。

年の週を設定する際、曜日は保持されます。

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

ISO年の週を取得または設定します。

年の週を設定する際、曜日は保持されます。

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

月を取得または設定します。

0から11の数値を受け入れます。範囲を超えた場合は、年に繰り上がります。

注記: 月は0から始まるインデックスであるため、1月は月0です。

2.1.0 以降、月の名前もサポートされています。これは、モーメントの現在のロケールで解析されます。

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

2.1.0 より前のバージョンでは、モーメントが月を変更し、新しい月に現在の月の曜日を維持するのに十分な日数がない場合、次の月にオーバーフローしていました。

2.1.0 以降、これはターゲット月の末日にクランプされるように変更されました。

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

2.16.0 では、moment().months() の使用が非推奨となりました。代わりに moment().month() を使用してください。

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

四半期（1～4）を取得します。

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

四半期（1～4）を設定します。

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

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

年を取得または設定します。

-270,000から270,000の数値を受け入れます。

2.6.0 では、moment().years() の使用が非推奨となりました。代わりに moment().year() を使用してください。

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

ロケールに従って週年を取得または設定します。

最初の週の最初の日が必ずしも年の最初の日になるわけではないため、週年と月年が異なる場合があります。

例えば、米国では、1月1日を含む週は常に最初の週です。米国では、週は日曜日から始まります。1月1日が月曜日だった場合、12月31日は1月1日と同じ週、したがって1月1日と同じ週年に属します。12月30日は12月31日とは異なる週年になります。

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

ISO週年を取得または設定します。

moment().weeksInYear();

現在のモーメントの年の、ロケールに従った週数を取得します。

moment().isoWeeksInYear();

ISO週に従って、現在のモーメントの年の週数を取得します。

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

文字列ゲッター。一般的に

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

単位は大文字と小文字を区別せず、複数形と短縮形をサポートします：year（years、y）、month（months、M）、date（dates、D）、hour（hours、h）、minute（minutes、m）、second（seconds、s）、millisecond（milliseconds、ms）。

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

単位を最初の引数として、値を2番目の引数として受け入れる汎用セッター

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

単位は大文字と小文字を区別せず、複数形と短縮形をサポートします：year（years、y）、month（months、M）、date（dates、D）、hour（hours、h）、minute（minutes、m）、second（seconds、s）、millisecond（milliseconds、ms）。

オブジェクトのパースは2.9.0で追加されました。

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

指定されたモーメントインスタンスの最大値（最も遠い未来）を返します。

例えば

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

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

引数がない場合、この関数は現在時刻のモーメントインスタンスを返します。

2.10.5 以降、無効なモーメントが引数の1つである場合、結果は無効なモーメントになります。

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

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

指定されたモーメントインスタンスの最小値（最も遠い過去）を返します。

例えば

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

引数がない場合、この関数は現在時刻のモーメントインスタンスを返します。

2.10.5 以降、無効なモーメントが引数の1つである場合、結果は無効なモーメントになります。

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 はfluent interface パターン（メソッドチェーンとも呼ばれます）を使用します。これにより、次のような複雑な操作を行うことができます。

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

注記: モーメントは変更可能であることに注意してください。操作メソッドのいずれかを呼び出すと、元のモーメントが変更されます。

コピーを作成して操作する場合は、モーメントを操作する前にmoment#cloneを使用する必要があります。クローンに関する詳細情報。

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

時間を追加することで元のモーメントを変更します。

これは、既存のモーメントに時間追加するための非常に堅牢な関数です。時間を追加するには、追加する時間の種類のキーと、追加する量を渡します。

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

簡潔さを重視する人のために、いくつかの省略記号キーもあります。

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

同時に複数の異なるキーを追加する場合は、オブジェクトリテラルとして渡すことができます。

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

量の上限はないため、パラメーターをオーバーロードできます。

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

月と年の特別な考慮事項

元の日の月の日が最終月の日の数より大きい場合、月の日は最終月の最後の日になります。

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

夏時間と交差する時間を追加する際には、考慮すべき特別な点もあります。年、月、週、または日を追加する場合、元の時間は常に追加された時間と一致します。

月を追加すると、指定された数の月が日付に追加されます。

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

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

時、分、秒、またはミリ秒を追加する場合は、時間単位の精度が必要であると想定され、異なる時間になります。

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

または、期間を使用してモーメントに追加することもできます。

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

2.8.0 より前のバージョンでは、moment#add(String, Number) 構文もサポートされていました。これはmoment#add(Number, String) に変更されました。

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

2.12.0 以降、日と月に小数値が渡された場合、最も近い整数に丸められます。週、四半期、年は日または月に変換され、最も近い整数に丸められます。

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

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

時間を減算することで元のモーメントを変更します。

これはmoment#addとまったく同じですが、時間を追加する代わりに時間を減算します。

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

2.8.0 より前のバージョンでは、moment#subtract(String, Number) 構文もサポートされていました。これはmoment#subtract(Number, String) に変更されました。

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

2.12.0 以降、日と月に小数値が渡された場合、最も近い整数に丸められます。週、四半期、年は日または月に変換され、最も近い整数に丸められます。

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

操作moment.add(-.5, 'days')とmoment.subtract(.5, 'days')を同等にするために、-.5、-1.5、-2.5などは切り捨てられます。

moment().startOf(String);

時間単位の開始時刻に設定することで元のモーメントを変更します。

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

これらのショートカットは、基本的に次のものと同じです。

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

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

2.0.0 以降、moment#startOf('day') はmoment#sodに置き換えられました。

注記: moment#startOf('week') は 2.0.0 バージョンで追加されました。

2.1.0 以降、moment#startOf('week') はロケール対応の週の最初の日を使用します。

注記: moment#startOf('isoWeek') は 2.2.0 バージョンで追加されました。

注記: moment#startOf('date') は 2.13.0 で日のエイリアスとして追加されました。

moment().endOf(String);

元のモーメントを、指定された時間単位の終端時刻に設定します。

これはmoment#startOfと同様ですが、時間単位の先頭ではなく、終端時刻に設定する点が異なります。

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

バージョン2.0.0より、moment#endOf('day')がmoment#eodに置き換わりました。

注意: moment#endOf('week')はバージョン2.0.0で追加されました。

バージョン2.1.0より、moment#endOf('week')はロケールに応じた週の開始曜日を使用します。

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

注意: この関数は2.7.0で非推奨となりました。moment.min を代わりに使用してください。

モーメントを別のモーメント値の最大値に制限します。そのため、a.max(b)はa = moment.min(a, b)と同じです（maxがminに変換されることに注意してください）。

サーバー時刻とクライアント時刻が完全に同期していない場合があります。これにより、「数秒後」ではなく「数秒前」のようなヒューマンライクな文字列が表示されることになります。moment#max()を使用することで、これを防ぐことができます。

これはmoment#minの対応関数です。

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

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

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

注意: この関数は2.7.0で非推奨となりました。moment.max を代わりに使用してください。

モーメントを別のモーメント値の最小値に制限します。そのため、a.min(b)はa = moment.max(a, b)と同じです（minがmaxに変換されることに注意してください）。

これはmoment#maxの対応関数です。

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

これはmoment#maxと組み合わせて、モーメントを範囲内に制限するために使用できます。

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

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

元のモーメントの表示にローカル時間を使用するように、元のモーメントにフラグを設定します。

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

ローカル時間は、固定オフセットモードからの変換にも使用できます。

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

trueを渡すと、現在の時刻を変更せずにタイムゾーンを変更します。

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

UTCモードの詳細についてはmoment.utc()を参照してください。

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

元のモーメントの表示にUTCを使用するように、元のモーメントにフラグを設定します。

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

UTCは、固定オフセットモードからの変換にも使用できます。

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

trueを渡すと、現在の時刻を変更せずにタイムゾーンを変更します。

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

UTCモードの詳細についてはmoment.utc()を参照してください。

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

UTCオフセットを分単位で取得または設定します。

注意: moment.fn.zoneとは異なり、この関数はUTCからの実際のオフセットを返し、逆オフセット（Date.prototype.getTimezoneOffsetによって返されるもの）は返しません。

現在のオブジェクトのutcOffsetを取得します。

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

分数を指定してUTCオフセットを設定します。オフセットは、utcOffset()が呼び出されたモーメントオブジェクトに設定されます。グローバルにオフセットを設定する場合は、moment-timezoneの使用を検討してください。オフセットを設定すると、固定され、自動的には変更されません（つまり、DSTルールはありません）。実際のタイムゾーン（特定の場所の時間、例：America/Los_Angeles）が必要な場合は、moment-timezoneを検討してください。

moment().utcOffset(120);

入力が16未満で-16より大きい場合、入力は時間として解釈されます。

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

文字列からUTCオフセットを設定することも可能です。

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

moment#utcOffsetは文字列内で+00 -00 +00:00 +0000 -00:00 -0000 Zの最後のマッチを検索するため、オフセットを含むISO8601形式の文字列を渡すこともでき、モーメントはそのUTCオフセットに変更されます。

文字列に'Z'が含まれていない場合は、+または-文字を含める必要があります。

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

utcOffset関数は、既存の1日の時間を維持するかどうかを示すブール値を受け取るオプションの第2パラメータを持っています。

• false（デフォルト）を渡すと、世界協定時における同じ瞬間が維持されますが、ローカル時刻は変更されます。

• trueを渡すと、ローカル時刻は維持されますが、世界協定時における異なる時点が選択されます。

この機能の1つの用途は、数値入力値のみを使用して特定のタイムゾーンオフセットを持つモーメントを作成する場合です。

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

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

注意: この関数は2.9.0で非推奨となりました。moment.fn.utcOffset を代わりに使用してください。

タイムゾーンオフセットを分単位で取得します。

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

バージョン2.1.0より、GMTからの分単位のオフセットを指定してオフセットを設定できます。

moment().zone(120);

入力が16未満で-16より大きい場合、入力は時間として解釈されます。

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

文字列からゾーンを設定することも可能です。

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

moment#zoneは文字列内で+00:00 +0000 -00:00 -0000の最初のマッチを検索するため、ISO8601形式の文字列を渡すこともでき、モーメントはそのゾーンに変更されます。

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

解析と操作が完了したら、モーメントを表示する必要があります。

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

これは最も堅牢な表示オプションです。トークンの文字列を受け取り、対応する値に置き換えます。

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

Xは2.0.0で追加されました。

e E gg gggg GG GGGGは2.1.0で追加されました。

xは2.8.4で追加されました。

SSSSからSSSSSSSSSは2.10.5で追加されました。3桁の有効数字が表示され、残りはゼロで埋められます。

kとkkは2.13.0で追加されました。

ローカライズされたフォーマット

優先されるフォーマットはロケールによって異なるため、ロケールに基づいてモーメントをフォーマットするために使用できるいくつかのトークンがあります。

同じフォーマットには大文字と小文字のバリエーションがあります。小文字のバージョンは、対応する大文字のバージョンの短縮版を意図しています。

l ll lll llllは2.0.0で利用可能です。LTSは2.8.4で追加されました。

文字のエスケープ

フォーマット文字列内の文字をエスケープするには、文字を角括弧で囲みます。

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

LDMLとの類似点と相違点

注意: これらの日付形式はLDML日付形式と非常に似ていますが、月の曜日、年の通日、曜日の曜日に関するいくつかの小さな違いがあります。

さまざまなロケールにおけるいくつかの異なる日付フォーマットトークンの内訳については、この日付フォーマットトークンのチャートを参照してください。

その他のトークン

LDMLのような解析トークンではなく、strftimeを使用する方が快適な場合は、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]形式になります。これは、+00:00ではなく、オフセットとしてZを返します。

特定の状況では、（Atlantic/Reykjavikなどの）ローカルタイムゾーンがゼロオフセットを持つ場合があり、UTCと見なされます。このような場合、moment.defaultFormatとmoment.defaultFormatUtcを同じフォーマットを使用するように設定すると便利です。

moment.defaultFormatの値を変更しても、フォーマットにしか影響せず、解析には影響しません。例えば

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

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

時刻の一般的な表示方法は、moment#fromNowによって処理されます。これは、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

基本文字列は現在のロケールによってカスタマイズされます。時間は最寄りの秒数に丸められます。

時間の長さごとにどの文字列が表示されるかの内訳は、以下の表に示されています。

注記: バージョン2.10.3以降、ターゲットのmomentオブジェクトが無効な場合、結果はローカライズされた無効な日付文字列になります。

注記: ssキーは2.18.0で追加されました。これはオプションの閾値です。ユーザーが手動でss閾値を設定しない限り、表示されることはありません。ss閾値が設定されるまでは、s閾値から1を引いた値がデフォルトになります（そのため、ユーザーには表示されません）。

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

現在時刻以外の時刻との関連でモーメントを表示したい場合があります。その場合、moment#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と同様に、2番目の引数にtrueを渡すと、サフィックスなしの値が返されます。これは、人間が読み取れる時間の長さを必要とする場合に役立ちます。

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

バージョン2.10.3以降、いずれかの端点が無効な場合、結果はローカライズされた無効な日付文字列になります。

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

時刻の表示の一般的な方法は、moment#toNowによって処理されます。これは、timeagoまたは相対時間と呼ばれることもあります。

これはmoment.fromNowに似ていますが、逆のインターバルを与えます: a.fromNow() = - a.toNow()。

これはmoment.toに似ていますが、現在時刻用に特別な処理がされています。インターバルの2つの端点を制御したい場合は、moment.toを使用してください。

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

trueを渡すと、プレフィックスなしの値を取得できます。

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

基本文字列は現在のロケールによってカスタマイズされます。

時間の長さごとにどの文字列が表示されるかの内訳は、以下の表に示されています。

バージョン2.10.3以降、ターゲットのmomentオブジェクトが無効な場合、結果はローカライズされた無効な日付文字列になります。

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

現在時刻以外の時刻との関連でモーメントを表示したい場合があります。その場合、moment#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と同様に、2番目の引数にtrueを渡すと、サフィックスなしの値が返されます。これは、人間が読み取れる時間の長さを必要とする場合に役立ちます。

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

バージョン2.10.3以降、いずれかの端点が無効な場合、結果はローカライズされた無効な日付文字列になります。

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

カレンダー時間は、指定されたreferenceDay（デフォルトで今日の開始時間）を基準にした相対時間を表示しますが、moment#fromNowとは少し異なる方法で行われます。

moment#calendarは、日付がreferenceDayの日付（デフォルトで今日）にどの程度近いかによって、異なる文字列で日付をフォーマットします。

これらの文字列はローカライズされており、カスタマイズできます。

2.10.5から、momentは呼び出しごとにカレンダー出力形式を指定するのをサポートしています。

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

sameElseは、モーメントがreferenceDayから1週間以上離れている場合のフォーマットとして使用されます。

注記: バージョン2.14.0から、カレンダーのformats引数は、momentコンテキスト内で実行され、現在は1つの引数を持つコールバックになります。

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

注記: バージョン2.25.0から、formats引数のみを渡すことができ、文字列と関数のオブジェクトにすることができます。

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

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

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

ミリ秒単位の差を取得するには、moment#fromと同様にmoment#diffを使用します。

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

別の測定単位の差を取得するには、その測定単位を2番目の引数として渡します。

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

2つのモーメント間の差の期間を取得するには、diffを引数としてmoment#durationに渡すことができます。詳細については、moment#durationのドキュメントを参照してください。

サポートされている測定単位は、years、months、weeks、days、hours、minutes、secondsです。開発の容易さのために、単数形は2.0.0からサポートされています。ミリ秒以外の測定単位は、バージョン1.1.1で使用できます。

デフォルトでは、moment#diffは結果を小数点以下0桁に切り捨て、整数を返します。浮動小数点数が必要な場合は、3番目の引数にtrueを渡します。2.0.0より前は、moment#diffは切り捨てられた数値ではなく、最も近い整数に丸められた数値を返していました。

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

モーメントがmoment.fn.diffに渡しているモーメントより前の場合、戻り値は負になります。

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

これを簡単に考えると、.diff(をマイナス演算子で置き換えることができます。

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

月と年の差

moment#diffは、月と年の差に対して特別な処理をしています。同じ日付を持つ2ヶ月が常に整数だけ離れるように最適化されています。

そのため、1月15日から2月15日までは正確に1ヶ月になります。

2月28日から3月28日までは正確に1ヶ月になります。

2011年2月28日から2012年2月28日までは正確に1年になります。

月と年の差に関する詳細な説明はこちらを参照してください。

月と年の差に対するこの変更は2.0.0で行われました。バージョン2.9.0から、diffは四半期単位もサポートしています。

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

moment#valueOfは、Date#valueOfと同様に、Unixエポックからのミリ秒数を単純に出力します。

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

MomentからUnixタイムスタンプ（エポックからの秒数）を取得するには、moment#unixを使用します。

注記: ECMAScript ではこれを「時間値」と呼びます。

moment().unix();

moment#unixは、Unixタイムスタンプ（Unixエポックからの秒数）を出力します。

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

この値は最も近い秒に切り捨てられ、ミリ秒のコンポーネントは含まれません。

moment().daysInMonth();

現在の月の日の数を取得します。

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

moment().toDate();

Moment.jsがラップするネイティブDateオブジェクトのコピーを取得するには、moment#toDateを使用します。

これは、モーメントが使用するDateのコピーを返します。そのため、そのDateに対する変更は、モーメントの変更には影響しません。モーメントのDateを変更する場合は、moment#manipulateまたはmoment#setを参照してください。

moment#nativeはmoment#toDateに置き換えられ、1.6.0から非推奨になりました。

moment().toArray();

これは、new Date()からのパラメーターを反映する配列を返します。

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

moment().toJSON();

オブジェクトをJSONにシリアライズする場合、Momentオブジェクトがあれば、UTCに調整されたISO8601文字列として表されます。

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

代わりに、モーメントのutcOffset()を反映するISO8601文字列が必要な場合は、次のようにtoJSON関数を変更できます。

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

これにより、動作が次のように変更されます。

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

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

文字列をISO8601標準にフォーマットします。

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

.toISOString()は、対象のモーメントがローカルモードであっても、UTCでタイムスタンプを返します。これは、ES2015仕様で概説されているように、ネイティブJavaScript Date .toISOString()の仕様との整合性を確保するためです。バージョン2.20.0から、UTC変換を防ぐために.toISOString(true)を呼び出すことができます。

バージョン2.8.4から、パフォーマンス上の理由から、利用可能な場合はネイティブのDate.prototype.toISOStringが使用されます。

moment().toObject();

これは、年、月、日、時、分、秒、ミリ秒を含むオブジェクトを返します。

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

moment().toString();

JS Dateの.toString()と同様の形式で英語の文字列を返します。

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

moment().inspect();

同じモーメントを生成するために評価できる、マシン可読の文字列を返します。名前のために、ノードのインタラクティブシェルでもオブジェクトを表示するために使用されます。

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

注記: この関数は主にデバッグ用であり、すべてのケースが正確に処理されるわけではありません。

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

モーメントが別のモーメントより前かどうかを確認します。最初の引数は、まだそうではない場合はモーメントとして解析されます。

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

ミリ秒以外の単位に粒度を制限する場合は、単位を2番目のパラメーターとして渡します。

2番目のパラメーターは精度を決定し、単一の値をチェックするだけではないため、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を返します。

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

モーメントが別のモーメントと同じかどうかを確認します。最初の引数は、まだそうではない場合はモーメントとして解析されます。

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

ミリ秒以外の単位で粒度を制限したい場合は、2番目のパラメーターとして渡します。

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

2番目のパラメーターを含めると、それ以上または等しいすべての単位に一致します。month を渡すと month と year がチェックされ、day を渡すと day、month、year がチェックされます。

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

moment#isAfter と moment#isBefore と同様に、moment#startOf でサポートされている時間単位はすべて moment#isSame でもサポートされています。

year month week isoWeek day hour minute second

2つのモーメントが異なるタイムゾーンを持つ場合、最初のモーメントのタイムゾーンが比較に使用されます。

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

注意: moment().isSame() は動作が未定義であり、使用しないでください！コードの実行速度が速いと、初期に作成されたモーメントは、チェックを実行するために isSame で作成されたモーメントと同じになるため、結果は true になります。しかし、コードの実行速度が遅い場合、isSame で作成されたモーメントは、moment() で作成されたモーメントよりも測定可能なほど後になる可能性があり、その呼び出しは false を返します。

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

あるモーメントが別のモーメントの後かどうかをチェックします。最初の引数は、まだモーメントでない場合はモーメントとして解析されます。

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

ミリ秒以外の単位に粒度を制限する場合は、単位を2番目のパラメーターとして渡します。

2番目のパラメーターは精度を決定し、単一の値をチェックするだけではないため、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

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

ミリ秒以外の単位に粒度を制限する場合は、単位を2番目のパラメーターとして渡します。

2番目のパラメーターは精度を決定し、単一の値をチェックするだけではないため、dayを使用すると、年、月、日を調べます。

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

moment#isAfter と moment#isSame と同様に、moment#startOf でサポートされている時間単位はすべて moment#isSameOrBefore でもサポートされています。

year month week isoWeek day hour minute second

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

あるモーメントが別のモーメントの後またはそれと同等かどうかをチェックします。最初の引数は、まだモーメントでない場合はモーメントとして解析されます。

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

ミリ秒以外の単位に粒度を制限する場合は、単位を2番目のパラメーターとして渡します。

2番目のパラメーターは精度を決定し、単一の値をチェックするだけではないため、dayを使用すると、年、月、日を調べます。

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

moment#isSame と moment#isBefore と同様に、moment#startOf でサポートされている時間単位はすべて moment#isSameOrAfter でもサポートされています。

year month week isoWeek day hour minute second

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

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

あるモーメントが他の2つのモーメントの間にあるかどうかをチェックします。必要に応じて、単位のスケール（分、時間、日など）も考慮します。一致は排他的です。最初の2つの引数は、まだモーメントでない場合はモーメントとして解析されます。

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

2つの引数の順序は重要です。「小さい」日付を最初の引数に指定する必要があります。

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

ミリ秒以外の単位で粒度を制限したい場合は、単位を3番目のパラメーターとして渡します。

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

moment#isSame、moment#isBefore、moment#isAfter と同様に、moment#startOf でサポートされている時間単位はすべて moment#isBetween でもサポートされています。年、月、週、isoWeek、日、時間、分、秒。

バージョン2.13.0では、包含関係が導入されました。[ は値の包含を示し、( は除外を示します。包含パラメーターを使用する場合は、両方のインジケーターを渡す必要があります。

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

from パラメーターと to パラメーターが同じ場合でも、包含パラメーターが異なる場合は、false が優先されます。

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

包含パラメーターを指定しない場合、Moment は () をデフォルトで使用します。

moment().isDST();

moment#isDST は、現在のモーメントがサマータイムであるかどうかをチェックします。

注意: この関数はハックです。moment は、特定の時間が実際のサマータイムであるかどうかを知る方法がありません。ゾーンの時間変更の中には、サマータイムに関連するものもあれば、そうでないものもあり、完全なタイムゾーン情報がないと知ることはできません。

Moment は現在、冬時間と夏時間をチェックしており、オフセットが夏時間のオフセットと一致する場合（そして夏時間のオフセットが冬時間と異なる場合）、サマータイムを報告します。これはほとんどの場合に機能しますが、上記のように「正確」ではなく、すべての場合に機能するわけではありません。だから、文句を言いに来ないでください。

Event moment-timezone（執筆時点では0.5.37）はDST情報（つまり、特定の瞬間に時計が公式にDSTにあるかどうか）をサポートしていないため、状況を改善するには、moment-timezoneでいくつかの新しいもの（およびtzdataのバンドル）が発生する必要があります。

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

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

注意: バージョン2.14.0から、この関数は非推奨です。モーメントオブジェクトを変更した後、正しい答えを与えません。詳細については、moment/3160を参照してください。

もう1つの重要な検証は、日付がDSTによって移動されたかどうかを知ることです。たとえば、米国のほとんどの地域では

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

これは、サマータイムによって時間が2:00から3:00にシフトされるため、2:30は実際の時刻ではありません。結果の時間はブラウザ依存であり、時間を前または後ろに調整します。この条件をテストするには、moment#isDSTShiftedを使用します。

注意: 2.3.0より前では、この条件にあるMomentオブジェクトは、moment#isValidに対して常にfalseを返していました。現在はtrueを返すようになりました。

moment().isLeapYear();

moment#isLeapYear は、その年が閏年であればtrueを返し、そうでなければfalseを返します。

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

moment.isMoment(obj);

変数がモーメントオブジェクトかどうかを確認するには、moment.isMoment()を使用します。

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

バージョン2.11.0からは、instanceof演算子を使用してモーメントオブジェクトをテストすることもできます。

moment() instanceof moment // true

moment.isDate(obj);

変数がネイティブのjs Dateオブジェクトかどうかを確認するには、moment.isDate()を使用します。

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

Moment.jsは、強力な国際化サポートを備えています。

複数のロケールをロードし、それらの間を簡単に切り替えることができます。

グローバルロケールを割り当てることに加えて、特定のモーメントにロケールを割り当てることもできます。

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

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

デフォルトでは、Moment.jsには英語（米国）のロケール文字列が含まれています。他のロケールが必要な場合は、後で使用するようにMoment.jsにロードできます。

ロケールをロードするには、キーと文字列の値をmoment.localeに渡します。

ロケールバンドルの各部分の詳細については、カスタマイズセクションを参照してください。

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

week.dowとweek.doyの詳細については、カスタマイズセクションを参照してください。

ロケールをロードすると、アクティブなロケールになります。アクティブなロケールを変更するには、ロード済みのロケールのキーを使用してmoment.localeを呼び出すだけです。

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

2.21.0以降、ロケールが利用できない場合、Momentはconsole.warnを出力します。

2.8.0以降、グローバルロケールの変更は既存のインスタンスには影響しません。

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

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

moment.localeは、使用されているロケールを返します。これは、Momentが指定したロケールがわからない場合、ロケールを変更しないため便利です。

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

ロケールのリストを指定することもでき、Momentはローカライゼーションがある最初のロケールを使用します。

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

Momentは、最も具体的なものから最も具体的なものまで、ロケール指定子の部分文字列を試して、認識しているロケールが見つかるまで検索します。これは、ユーザーの環境から取得したロケール文字列（例：window.navigator.language）をMomentに提供する場合に便利です。

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

最後に、Momentはロケールの配列とその部分文字列をインテリジェントに検索します。

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

ロジックは以下のとおりです。次のロケールが選択され、そのまま試行されます。それが失敗した場合、コードは通常、最後の部分（通常は国指定）を切り取ってから再度試行します。ただし、次の配列要素に試行されるものと同じかそれ以上の接頭辞がある場合、反復処理は継続されます。たとえば、配列に次のシーケンスがある場合

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

最初に「AA-BB」が試行され、次にナイーブなソリューションでは「AA」が試行されますが、これは代わりに「AA-CC」が実際には「AA」よりも具体的なものであることを確認してから「AA-CC」を試行し、「XX-YY」に「AA」が接頭辞としてない場合にのみ（失敗した場合）、最後に「AA」を試行します。したがって、最終的に、次のロケールがこの順序で試行されます（すべて失敗するため、次のロケールが試行されます）。

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

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

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

異なるロケールにフォーマットする必要があるモーメントを渡す場合、グローバルロケール構成は問題になる可能性があります。

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

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

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

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

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

パラメーターなしでmoment#localeを呼び出すと、そのモーメントに使用されるロケール構成が返されます。

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

モーメントのロケールデータにアクセスする必要がある場合、これが推奨される方法です。

2.3.0以降、ロケール識別子の配列を指定することもできます。グローバルロケール構成と同じように機能します。

moment.locale(String);

NodeJSでのロケールのロードは非常に簡単です。そのキーにちなんで名付けられたロケールファイルがmoment/locale/にある場合、最初にインポートしてからmoment.localeを呼び出してロードします。

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

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

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

個々のロケールをロードする手順を省略するには（つまり、すべてをロードするだけ）、moment/min/moment-with-localesモジュールを代わりにインポートします。

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

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

ロケールをサポートしたい場合は、必要なロケールと単体テストファイルを使用してdevelopブランチにプルリクエストを作成してください。

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

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

ブラウザでのロケールのロードには、ロケールファイルを含めるだけで済みます。エンコーディングの問題を防ぐために、文字セットを指定してください。

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

すべてのロケールをまとめた縮小版があります。

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

HTTPリクエストを最小限に抑えるために、Gruntタスクを使用して、ロケールのカスタムリストを含むMomentをコンパイルします。

grunt transpile:fr,it

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

JSPMをプラグインマネージャーとして使用している場合は、ライブラリにロケールを追加する必要があります。

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

注意: ロケールファイルはUMDスタイルで定義されているため、すべての環境でシームレスに機能するはずです。

Moment.jsにロケールを追加するには、ロケールファイルとテストファイルの両方を含むプルリクエストを送信します。例はmoment/src/locale/fr.jsとmoment/src/test/locale/fr.jsにあります。

Node.jsでテストを実行するには、npm installを実行してからgruntを実行します。

すべてのテストに合格したら、プルリクエストを送信してください。ご協力ありがとうございます！

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

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

頻繁にロケールを変更する場合は、現在使用されているロケールを知りたい場合があります。これは、パラメーターなしでmoment.localeを呼び出すだけで簡単にできます。

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

バージョン2.12.0からは、ロード済みで利用可能なすべてのロケールをリストアップすることが可能です。

moment.locales()

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

たとえば、ドロップダウンメニューにデータを入力する場合など、ロケールの月または曜日のリストを取得することが役立つ場合があります。

moment.months();

現在のロケールの月のリストを返します。

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

同様に、moment.monthsShortは略語の月名を返し、moment.weekdays、moment.weekdaysShort、moment.weekdaysMinは曜日のリストを返します。

これらの関数のそれぞれに整数を渡して、特定の月または曜日を取得できます。

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

2.13.0以降、曜日の関数(weekday functions)の最初の引数にブール値を渡せるようになりました。`true`の場合、曜日はロケール固有の順序で返されます。例えば、アラビア語ロケールでは、土曜日は週の最初の日であるため、

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

注記: ロケール固有の引数が無い場合、曜日のインデックスは、ローカルの週の最初の日に関わらず、日曜日が常に0となります。

一部のロケールでは、月の名前のフォーマット時に特別な考慮事項が考慮されます。例えば、オランダ語では、月の略称は、ダッシュで区切られた月の間でのみ、末尾のピリオドなしでフォーマットされます。monthsメソッドは、月が適切なコンテキストでリスト表示されるように、フォーマットを渡すことをサポートしています。

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

最後に、フォーマットオプションと整数オプションの両方を組み合わせることができます。

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

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

moment.localeData(key)関数を使用して、現在ロードされているロケールのプロパティにアクセスできます。これは、現在のロケール、または指定されたキーを持つロケールを返します。

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

返されたオブジェクトには、以下のメソッドがあります。

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

firstDayOfYearの詳細については、カスタマイズセクションを参照してください。

moment.locale('x-pseudo')

バージョン2.13.0以降、momentはオプションで疑似ロケールを含んでいます。このロケールは、日付に非常に明らかに変更されたデータを設定します。疑似ロケールは、テスト時に役立ちます。これは、どのデータがローカライズされているか、されていないかを明確にするためです。疑似ロケールを含めて、momentのロケールをx-pseudoに設定するだけで、Momentからのテキストは非常に簡単に識別できます。

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

Moment.jsは非常に簡単にカスタマイズできます。一般的には、カスタマイズ設定を含むロケール設定を作成する必要があります。

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

2番目の引数に`null`を渡すことで、事前に定義されたロケールを削除できます。削除されたロケールは、以降使用できなくなります。

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

2.12.0以降、親ロケールを継承するロケールを作成できるようになりました。

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

ロケールに指定されていないプロパティは、親ロケールから継承されます。

2.16.0以降、まだ定義またはロードされていない親を持つロケールを定義できます。

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

2.21.0以降、新しく定義されたロケールでmomentを作成しようとすると、momentはその親が存在する場合は遅延ロードを試みます。そうでない場合は、親をグローバルロケールにデフォルト設定します。

2.12.0以降、ロケールのプロパティを更新することもできます。

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

指定されたプロパティは更新されますが、他のプロパティはそのまま残ります。この関数は、既に存在するmomentには影響しません。updateLocaleを呼び出すと、現在のグローバルロケールも更新されたロケールに変更されることに注意してください。このGitHubのissueで詳細情報を確認してください。

更新を元に戻すには、

moment.updateLocale('en', null);

2.12.0では、既存のロケールを変更するためにmoment.locale()を使用することが非推奨となりました。代わりにmoment.updateLocale()を使用してください。

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

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

Locale#monthsは、月の名前の配列である必要があります。

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

月の名前を計算するための追加処理が必要な場合（たとえば、異なるフォーマットで異なる文法がある場合）、Locale#monthsは、以下のシグネチャを持つ関数にすることができます。常に月の名前を返す必要があります。

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

バージョン2.11.0から、月は、standaloneとformat形式（主格と属格）を指定するオブジェクトにもできます。format形式を使用するかどうかを確認するためにフォーマットに対して実行される正規表現は/D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/です。バージョン2.14.0からは、isFormatキーで異なる正規表現を指定できます。

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

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

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

Locale#monthsShortは、月の略称の配列である必要があります。

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

Locale#monthsと同様に、Locale#monthsShortもコールバック関数にすることができます。

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

注記: バージョン2.11.0から、Locale#monthsと同様に、Locale#monthsShortはstandaloneとformatケースを持つオブジェクトにすることができます。

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

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

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

Locale#weekdaysは、曜日の名前の配列である必要があります。

moment.updateLocale('en', {
    weekdays : [
        "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
    ]
});

Locale#weekdaysもコールバック関数にすることができます。

moment.updateLocale('en', {
    weekdays : function (momentToFormat, format) {
        return weekdays[momentToFormat.day()];
    }
});

注記: バージョン2.11.0から、format/standaloneケースも渡すことができます。isFormatは完全なフォーマット文字列に対して使用され、どの形式を使用するかを決定します。

moment.updateLocale('en', {
    weekdays : {
        standalone: 'Воскресенье_Понедельник_Вторник_Среда_Четверг_Пятница_Суббота'.split('_'),
        format: 'Воскресенье_Понедельник_Вторник_Среду_Четверг_Пятницу_Субботу'.split('_'),
        isFormat: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/
    }
});

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

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

Locale#weekdaysShortは、曜日の略称の配列である必要があります。

moment.updateLocale('en', {
    weekdaysShort : ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
});

Locale#weekdaysShortもコールバック関数にすることができます。

moment.updateLocale('en', {
    weekdaysShort : function (momentToFormat, format) {
        return weekdaysShort[momentToFormat.day()];
    }
});

// From 2.12.0 onward
moment.updateLocale('en', {
    weekdaysMin : String[]
});
moment.updateLocale('en', {
    weekdaysMin : Function
});

// From 2.8.1 to 2.11.2
moment.locale('en', {
    weekdaysMin : String[]
});
moment.locale('en', {
    weekdaysMin : Function
});

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

Locale#weekdaysMinは、2文字の曜日の略称の配列である必要があります。これらはカレンダーピッカーなどで使用されるため、できるだけ短くする必要があります。

moment.updateLocale('en', {
    weekdaysMin : ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]
});

Locale#weekdaysMinもコールバック関数にすることができます。

moment.updateLocale('en', {
    weekdaysMin : function (momentToFormat, format) {
        return weekdaysMin[momentToFormat.day()];
    }
});

// From 2.12.0 onward
moment.updateLocale('en', {
    weekdaysMin : String[]
});
moment.updateLocale('en', {
    weekdaysMin : Function
});

// From 2.8.1 to 2.11.2
moment.locale('en', {
    longDateFormat : Object
});

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

Locale#longDateFormatは、各長い日付フォーマットL LL LLL LLLL LT LTSのキーと値のペアを含むオブジェクトである必要があります。LTは時間フォーマットで、moment#calendarにも使用されます。

moment.updateLocale('en', {
    longDateFormat : {
        LT: "h:mm A",
        LTS: "h:mm:ss A",
        L: "MM/DD/YYYY",
        l: "M/D/YYYY",
        LL: "MMMM Do YYYY",
        ll: "MMM D YYYY",
        LLL: "MMMM Do YYYY LT",
        lll: "MMM D YYYY LT",
        LLLL: "dddd, MMMM Do YYYY LT",
        llll: "ddd, MMM D YYYY LT"
    }
});

小文字のlトークンを削除すると、長いトークンを短いトークンのバリアントに置き換えることで自動的に作成されます。

moment.updateLocale('en', {
    longDateFormat : {
        LT: "h:mm A",
        LTS: "h:mm:ss A",
        L: "MM/DD/YYYY",
        LL: "MMMM Do YYYY",
        LLL: "MMMM Do YYYY LT",
        LLLL: "dddd, MMMM Do YYYY LT"
    }
});

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

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

Locale#relativeTimeは、moment#fromの置換文字列のオブジェクトである必要があります。

moment.updateLocale('en', {
    relativeTime : {
        future: "in %s",
        past:   "%s ago",
        s  : 'a few seconds',
        ss : '%d seconds',
        m:  "a minute",
        mm: "%d minutes",
        h:  "an hour",
        hh: "%d hours",
        d:  "a day",
        dd: "%d days",
        w:  "a week",
        ww: "%d weeks",
        M:  "a month",
        MM: "%d months",
        y:  "a year",
        yy: "%d years"
    }
});

Locale#relativeTime.futureは未来の日付の接頭辞/接尾辞を指し、Locale#relativeTime.pastは過去の日付の接頭辞/接尾辞を指します。その他すべての場合、単一文字は単数形を、二重文字は複数形を指します。

ロケールでトークンに追加の処理が必要な場合、以下のシグネチャを持つ関数としてトークンを設定できます。関数は文字列を返す必要があります。

function (number, withoutSuffix, key, isFuture) {
    return string;
}

key引数は、Locale#relativeTimeオブジェクトの置換キーを指します（例：s m mm hなど）。

number引数は、そのキーの単位の数です。mの場合、数は分単位の数です。

withoutSuffix引数は、トークンが接尾辞なしで表示される場合は`true`、接尾辞付きで表示される場合は`false`になります。（逆のロジックになっている理由は、デフォルトの動作が接尾辞付きで表示されるためです）。

isFuture引数は、未来の接尾辞/接頭辞を使用する場合は`true`、過去の接頭辞/接尾辞を使用する場合は`false`になります。

注記：wとwwの処理は2.25.0で追加されました。

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

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

ロケールで「am/pm」を使用する場合、これらの値はデフォルト値であるため、Locale#meridiemは省略できます。

ロケールでam/pmに異なる計算が必要な場合、Locale#meridiemは、時間、分、大文字/小文字に基づいて正しい文字列を返すコールバック関数である必要があります。

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

// From 2.12.0 onward
moment.updateLocale('en', {
    meridiemParse : RegExp
    isPM : Function
});

// From 2.8.1 to 2.11.2
moment.locale('en', {
    meridiemParse : RegExp
    isPM : Function
});

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

Locale#isPMは、入力文字列が正午以降の場合、`true`を返す必要があります。これは、a Aトークンのパースに使用されます。

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

入力としてパースされる文字列を設定するには、meridiemParseプロパティを設定します。

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

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

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

Locale#calendarには、次のフォーマット文字列が必要です。

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

Locale#calendarの各キーは、現在のmomentのスコープを持つコールバック関数、および最初の引数として現在を表すmomentを持つこともできます。フォーマット文字列を返す必要があります。

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

moment.calendarFormat = Function

これにより、カレンダーで使用されるトークンを変更できます。

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

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

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

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

Locale#ordinalは、指定された数値の序数を返す関数である必要があります。

moment.updateLocale('en', {
    ordinal : function (number, token) {
        var b = number % 10;
        var output = (~~ (number % 100 / 10) === 1) ? 'th' :
            (b === 1) ? 'st' :
            (b === 2) ? 'nd' :
            (b === 3) ? 'rd' : 'th';
        return number + output;
    }
});

2.0.0以降、序数関数は数値と序数の両方返す必要があります。以前は、序数のみが返されていました。

2.1.0以降、トークンパラメータが追加されました。これは、序数化されるトークンの文字列です（例：Mまたはd）。

序数の詳細については、Wikipediaを参照してください。

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

duration.humanizeには、単位が分、時間などに分類されるしきい値があります。たとえば、デフォルトでは、45秒以上は分と見なされ、22時間以上は1日と見なされます。これらのカットオフを変更するには、moment.relativeTimeThreshold(unit, limit)を使用します。ここで、unitはss、s、m、h、d、w、Mのいずれかです。

  // Retrieve existing thresholds
  moment.relativeTimeThreshold('ss'); // 44
  moment.relativeTimeThreshold('s');  // 45
  moment.relativeTimeThreshold('m');  // 45
  moment.relativeTimeThreshold('h');  // 22
  moment.relativeTimeThreshold('d');  // 26
  moment.relativeTimeThreshold('w');  // null (disabled)
  moment.relativeTimeThreshold('M');  // 11

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

注記: 週単位は2.25.0で追加されました。デフォルトでは使用されません（nullに設定されています）が、null以外の値に設定でき、（オプションで）dを小さく設定して、日数から週数への移行を早めることもできます。

注記: しきい値の取得は2.8.1で追加されました。

注記: ssしきい値の取得と設定は2.18.0で追加されました。

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

duration.humanizeは、ロケールで指定されたrelativeTimeフォーマット文字列に供給する前に、可能性のある倍精度値を丸めます。丸めを制御するには、moment.relativeTimeRoundingを使用できます。

var roundingDefault = moment.relativeTimeRounding();

// Round relative time evaluation down
moment.relativeTimeRounding(Math.floor);

moment.relativeTimeThreshold('s', 60);
moment.relativeTimeThreshold('m', 60);
moment.relativeTimeThreshold('h', 24);
moment.relativeTimeThreshold('d', 7);
moment.relativeTimeThreshold('w', 4);
moment.relativeTimeThreshold('M', 12);

var a = moment();
a.subtract({hours: 23, minutes: 59, seconds: 59});
a.toNow();  // == 'in 23 hours'  'Round down towards the nearest hour'

// back to default
moment.relativeTimeRounding(roundingDefault);

丸めをまったく行わないように選択することもできます。

var retainValue = function (value) {
    return value;
};
moment.relativeTimeRounding(retainValue);

var a = moment();
a.subtract({hours: 39});
a.toNow(); // == 'in 1.625 days', 'Round down towards the nearest year'

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

Momentが表示する時間を変更したい場合は、Unixエポック（1970年1月1日）からのミリ秒数を返すメソッドを指定できます。

デフォルトは

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

これはmoment()を呼び出す際に使用され、トークンがformat()から省略された場合に使用される現在の日付です。一般的に、現在時刻を必要とするメソッドは、内部的にこれを使用します。

// From 2.12.0 onward
moment.updateLocale('en', {
    week : {
        dow : Int,
        doy : Int
     }
});
// From 2.8.1 to 2.11.2
moment.locale('en', {
    week : {
        dow : Int,
        doy : Int
    }
});

// Deprecated in 2.8.1
moment.lang('en', {
    week : {
        dow : Int,
        doy : Int
    }
});

Locale#week.dowは、週の最初の日を表す整数である必要があります。0は日曜日、1は月曜日、...、6は土曜日です。

Locale#week.doyは整数である必要があります。doyは、年の最初の週を決定するためにdowと共に使用されます。doyは7 + dow - janXとして計算されます。ここで、janXは、年の最初の週に属する必要がある1月の最初の日です。

// ISO-8601, Europe
moment.updateLocale("en", { week: {
  dow: 1, // First day of week is Monday
  doy: 4  // First week of year must contain 4 January (7 + 1 - 4)
}});

// US, Canada
moment.updateLocale("en", { week: {
  dow: 0, // First day of week is Sunday
  doy: 6  // First week of year must contain 1 January (7 + 0 - 1)
}});

// Many Arab countries
moment.updateLocale("en", { week: {
  dow: 6, // First day of week is Saturday
  doy: 12 // First week of year must contain 1 January (7 + 6 - 1)
}});

// Also common
moment.updateLocale("en", { week: {
  dow: 1, // First day of week is Monday
  doy: 7  // First week of year must contain 1 January (7 + 1 - 1)
}});

moment.updateLocale('en', {
    eras: [{
        since:  '0001-01-01',
        until:  +Infinity,
        offset: 1,
        name:   'Anno Domini',
        narrow: 'AD',
        abbr:   'AD'
    }, {
        until:   -Infinity,
        since:  '0000-12-31',
        offset: 1,
        name:   'Before Christ',
        narrow: 'BC',
        abbr:   'BC'
    }],
});

特定のロケールについて、元号を指定します。元号とは、名称と年番号を持つ時間間隔です。絶対年数（2020年など）は、2020 AD のように 2020 AD 年目として指定することもできます。同様に、絶対年数 -0500 は、紀元前 501 年目として BC 紀元からの 501 年目として記述できます。

eras: [{
    since:  '0001-01-01', // the start of the era
    until:  +Infinity,    // the end of the era, can be +/-Infinity
    offset: 1,            // added to year to (mostly) avoid 0 era years
    name:   'Anno Domini',// full name of era
    narrow: 'AD',         // narrow name of era
    abbr:   'AD'          // abbreviated name of era
}]

since と until は元号の方向を制御します。BC の場合と同様に、-Infinity に向かって増加するため、since > until となります。+Infinity に向かって増加する元号の場合、since < until となります。

元号の解析/フォーマットは、yo、y*、N* トークンを使用して行われます。

注記: 元号関連のAPIは変更される可能性があります。

// From 2.12.0 onward
moment.updateLocale('en', {
    invalidDate : String
});

// From 2.8.1 to 2.11.2
moment.locale('en', {
    invalidDate : String
});

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

Locale#invalidDate は文字列である必要があります。

moment.updateLocale("es", {
  invalidDate: "Fecha invalida"
});

Moment.js には期間オブジェクトもあります。モーメントが時間内の単一点として定義されるのに対し、期間は時間の長さとして定義されます。

期間には、定義された開始日と終了日はありません。コンテキストがありません。

期間は、概念的には「2時間」に「今日の午後2時から4時まで」よりも似ています。そのため、コンテキストに依存する単位間の変換には適したソリューションではありません。

たとえば、1年は366日、365日、365.25日、12ヶ月、または52週間と定義できます。コンテキストなしで年を日に変換しようとすると、意味がありません。Durations を使用するよりも、2つのモーメント間の日の数や年数を計算するには moment#diff を使用する方がはるかに優れています。

ここで説明されているように、Moment.js の期間形式は、ISO 8601 名目期間と RFC 5545 期間の仕様とはわずかに異なります。

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

期間を作成するには、ミリ秒単位の時間の長さを指定して moment.duration() を呼び出します。

moment.duration(100); // 100 milliseconds

ミリ秒以外の測定単位でモーメントを作成する場合は、測定単位も渡すことができます。

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

moment#add と moment#subtract の同じ省略記法もここで機能します。

moment#add と同様に、複数の異なる測定単位が必要な場合は、値のオブジェクトを渡すことができます。

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

2.1.0 から、moment は ASP.NET スタイルの時間範囲の解析をサポートしています。次の形式がサポートされています。

形式は、23:59:59 のようにコロンで区切られた時、分、秒の文字列です。日数は、7.23:59:59 のようにドットセパレータを前に付けることができます。部分秒もサポートされています 23:59:59.999。

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

2.3.0 から、moment は ISO 8601 期間の解析もサポートしています。

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

2.11.0 から、日数と残りの部分の間にスペースがある期間フォーマット文字列がサポートされています。

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

2.13.0 から、期間の解析時に正負の混合符号がサポートされています。

moment.duration('PT-6H3M')

2.18.0 から、無効なモーメントと同様に、無効な期間がサポートされています。無効な期間を作成するには、単位の値に NaN を渡すことができます。

今後のリリースでは、無効な期間がより多くのケース（単位の null 値など）をカバーする予定です。

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

moment.duration().clone();

期間のクローンを作成します。期間はモーメントオブジェクトと同様に変更可能であるため、ある時点のスナップショットを取得できます。

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

moment.duration().humanize();
moment.duration().humanize(withSuffix);
moment.duration().humanize(withSuffix, thresholds); // from 2.25.0
moment.duration().humanize(thresholds);             // from 2.25.0

時々、moment#from のすべての利点を活用したい場合がありますが、2つのモーメントを作成する必要はなく、時間の長さだけを表示したい場合があります。

moment.duration().humanize() を使用します。

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

デフォルトでは、戻り値の文字列は期間を「1ヶ月」 (接尾辞なし) で記述しています。方向性のある期間「1ヶ月後」、「1ヶ月前」(接尾辞付き) を希望する場合は、下記のように true を渡します。

moment.duration(1, "minutes").humanize(true); // in a minute

現在以前の接尾辞には、負の数を渡します。

moment.duration(-1, "minutes").humanize(true); // a minute ago

無効な期間は、ローカライズされた「無効な日付」バージョンに人間化されます。

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

人間化出力は、相対時間しきい値で構成できます。humanize の特定の呼び出しのしきい値を指定するには、それらを単一の引数として、またはサフィックス引数の後に渡します。

moment.duration(-1, 'week').humanize(true, {d: 7, w: 4}); // a week ago
moment.duration(-1, 'week').humanize({d: 7, w: 4}); // a week

注記: humanize でのしきい値の渡しが追加されたのは 2.25.0 です。

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

期間内のミリ秒数を取得するには、moment.duration().milliseconds() を使用します。

0～999 の数値を返します。

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

期間の長さをミリ秒単位で取得する場合は、代わりに moment.duration().asMilliseconds() を使用します。

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

moment.duration().seconds();
moment.duration().asSeconds();

期間内の秒数を取得するには、moment.duration().seconds() を使用します。

0～59 の数値を返します。

moment.duration(500).seconds(); // 0
moment.duration(1500).seconds(); // 1
moment.duration(15000).seconds(); // 15

期間の長さを秒単位で取得する場合は、代わりに moment.duration().asSeconds() を使用します。

moment.duration(500).asSeconds(); // 0.5
moment.duration(1500).asSeconds(); // 1.5
moment.duration(15000).asSeconds(); // 15

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

期間の他のゲッターと同様に、moment.duration().minutes() は分 (0～59) を取得します。

moment.duration().asMinutes() は、期間の長さを分単位で取得します。

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

期間の他のゲッターと同様に、moment.duration().hours() は時間 (0～23) を取得します。

moment.duration().asHours() は、期間の長さを時間単位で取得します。

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

期間の他のゲッターと同様に、moment.duration().days() は日数 (0～30) を取得します。

moment.duration().asDays() は、期間の長さを日単位で取得します。

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

期間の他のゲッターと同様に、moment.duration().weeks() は週数 (0～4) を取得します。

moment.duration().asWeeks() は、期間の長さを週単位で取得します。

期間の他のゲッターとは異なり、週は日数のサブセットとして数えられ、日数のカウントから差し引かれません。

注記: 期間の長さ（週単位）は7日と定義されています。

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

期間の他のゲッターと同様に、moment.duration().months() は月数 (0～11) を取得します。

moment.duration().asMonths() は、期間の長さを月単位で取得します。

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

期間の他のゲッターと同様に、moment.duration().years() は年数を取得します。

moment.duration().asYears() は、期間の長さを年単位で取得します。

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

時間を追加することで元の期間を変更します。

期間の作成に使用されるのと同じキーと省略記法を、第2引数として使用できます。

var a = moment.duration(1, 'd');
var b = moment.duration(2, 'd');
a.add(b).days(); // 3

無効な期間を他の期間に追加すると、無効な期間になることに注意してください。

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

時間を減算することで元の期間を変更します。

期間の作成に使用されるのと同じキーと省略記法を、第2引数として使用できます。

var a = moment.duration(3, 'd');
var b = moment.duration(2, 'd');
a.subtract(b).days(); // 1

無効な期間を他の期間に追加すると、無効な期間になることに注意してください。

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

moment#diff と期間を使用して、2つのモーメント間の期間を取得することもできます。これを行うには、次のように moment#diff メソッドを moment#duration に渡すだけです。

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

moment#diff の詳細については、こちらを参照してください。

moment.duration().as(String);

Duration#asX の代替として、Duration#as('x') を使用できます。moment#add の省略記法キーもここで適用されます。

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

無効な期間は、すべての単位に対して NaN を返します。

moment.duration().get(String);

Duration#x() ゲッターの代替として、Duration#get('x') を使用できます。moment#add の省略記法キーもここで適用されます。

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

無効な期間は、すべての単位に対して NaN を返します。

moment.duration().toJSON();

期間オブジェクトを JSON にシリアライズすると、ISO8601 文字列として表されます。

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

無効な期間は、JSON 表現として 無効な日付 を返します。

moment.isDuration(obj);

変数がモーメント期間オブジェクトであるかどうかを確認するには、moment.isDuration() を使用します。

moment.isDuration() // false
moment.isDuration(new Date()) // false
moment.isDuration(moment()) // false
moment.isDuration(moment.duration()) // true
moment.isDuration(moment.duration(2, 'minutes')) // true

moment.duration().toISOString();

ISO 8601 標準で指定された文字列として期間を返します。

moment.duration(1, 'd').toISOString() // "P1D"

形式 PnYnMnDTnHnMnS 説明

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

locale(...) を使用して、期間のロケールを取得または設定できます。ロケールは、humanize() のような期間の文字列メソッドに影響します。国際化全般の詳細については、intl セクションを参照してください。

moment.duration(1, "minutes").locale("en").humanize(); // a minute
moment.duration(1, "minutes").locale("fr").humanize(); // une minute
moment.duration(1, "minutes").locale("es").humanize(); // un minuto

humanize() の接尾辞も国際化されています。

moment.duration(1, "minutes").locale("en").humanize(true); // in a minute
moment.duration(1, "minutes").locale("fr").humanize(true); // dans une minute
moment.duration(1, "minutes").locale("es").humanize(true); // en un minuto

moment.duration(-1, "minutes").locale("en").humanize(true); // a minute ago
moment.duration(-1, "minutes").locale("fr").humanize(true); // il y a une minute
moment.duration(-1, "minutes").locale("es").humanize(true); // hace un minuto

Moment は、ライブラリを拡張したり、カスタムパーサーを作成したりする際に役立つ可能性のあるいくつかのメソッドを公開しています。

moment.normalizeUnits(String);

Moment の多くの関数は、呼び出し元が単位列挙のエイリアスを渡すことを許可しています。たとえば、以下のすべての get は同等です。

var m = moment();
m.get('y');
m.get('year');
m.get('years');

ライブラリを拡張する場合は、Moment の機能にアクセスして、機能を Moment により適切に合わせる必要があります。

moment.normalizeUnits('y');      // 'year'
moment.normalizeUnits('Y');      // 'year'
moment.normalizeUnits('year');   // 'year'
moment.normalizeUnits('years');  // 'year'
moment.normalizeUnits('YeARS');  // 'year'

moment.invalid(Object);

独自の無効な Moment オブジェクトを作成できます。これは、独自のパーサーを作成する際に役立ちます。

var m = moment.invalid();
m.isValid();                      // false
m.format();                       // 'Invalid date'
m.parsingFlags().userInvalidated; // true

invalid は、設定する解析フラグを指定するオブジェクトも受け入れます。ただし、指定されたプロパティの1つでない限り、userInvalidated 解析フラグは設定されません。

var m = moment.invalid({invalidMonth: 'Actober'});
m.parsingFlags().invalidMonth; // 'Actober'

Moment によって認識される解析フラグを指定する必要はありません。Moment はそれでも無効になり、解析フラグは parsingFlags() によって返されます。

他の人々が Moment.js のプラグインを作成しており、役立つ場合があります。

npm install moment-strftime

LDML のような解析トークンではなく strftime を使用して作業する方が快適な場合は、Ben Oakes のプラグイン moment-strftime を使用できます。

リポジトリは github.com/benjaminoakes/moment-strftimeにあります。

.NET で OLE オートメーション日付を使用している場合は、Markit On Demand の moment-msdate を確認してください。このプラグインを使用すると、OA 日付を JavaScript 日付に、またその逆にフォーマットできます。

moment を OA 日付に変換する

moment().toOADate(); // a floating point number

または、OA 日付を moment に変換する

moment.fromOADate(41493); // Wed Aug 07 2013 00:00:00 GMT-0600 (MDT)

詳細情報と詳細なドキュメントは、GitHub の http://markitondemand.github.io/moment-msdate/にあります。

npm install moment-jdateformatparser

java.text.DateFormat を使用したい場合は、このプラグインを使用できます。

例：

moment("2013-12-24 14:30").formatWithJDF("dd.MM.yyyy");  // returns the formatted date "24.12.2013"
moment().toJDFString("DD.MM.YYYY");  // returns the Java format pattern "dd.MM.yyyy"

リポジトリは github.com/MadMG/moment-jdateformatparserにあります。

npm install moment-range

日付範囲を処理する必要がある場合は、Gianni Chiappetta のプラグイン moment-range を使用できます。

ドキュメントはホームページ github.com/rotaready/moment-rangeにあります。

また、以下のリポジトリでウェブでも利用できます。

リポジトリは github.com/rotaready/moment-rangeにあります。

npm install twix

別の範囲プラグインは、Isaac Cambron のライブラリ Twix です。多くの範囲関連の機能があり、範囲を分かりやすくフォーマットすることに優れています。例：

var t = moment("1/25/1982 9:30 AM").twix("1/25/1982 1:30 PM");
t.isCurrent(); // false
t.count('minutes'); // 241
t.format();  // 'Jan 25, 1982, 9:30 AM - 1:30 PM'
t.simpleFormat("h:m"); // '9:30 - 1:30'

すべてのオプションと機能の完全なドキュメントは こちらにあります。

npm では次のように利用できます。

npm install twix

または、こちらから JS ファイルを入手してください。

npm install moment-precise-range-plugin

正確な範囲プラグインは、Rob Dawsonによって書かれ、日付/時間の範囲の正確で人間が読める表現を表示するために使用できます。

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

moment.preciseDiff("2014-01-01 12:00:00", "2014-04-20 12:00:00");
// 3 months 19 days

文字列ではなく生の数値値を取得するには、メソッドの第3引数として値 true を渡します。

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

npm install moment-isocalendar

Python のような isocalendar メソッドを探している場合は、Rocky Meza のプラグインを使用できます。

moment-isocalendar

moment で isocalendar メソッドを呼び出すと、次のような配列が返されます。

[年、年の週、曜日の週、深夜からの分]

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

isocalendar 配列から moment を再構築することもできます。

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

リポジトリは github.com/fusionbox/moment-isocalendarにあります。

npm install moment-jalaali

ジャラリ暦（ジャラリ、ペルシア、ホルシディ、シャムシ）を使用する場合は、Behrang Noruzi Niya氏によるプラグインmoment-jalaaliを使用できます。

インストールすると、momentをラップし、momentはジャラリ暦の年と月をフォーマットおよび解析できるようになります。簡単な例を以下に示します。

var m = moment('1360/5/26', 'jYYYY/jM/jD'); // Parse a Jalaali date.
m.format('jYYYY/jM/jD [is] YYYY/M/D'); // 1360/5/26 is 1981/8/17

リポジトリはgithub.com/behrang/moment-jalaaliにあります。

npm install moment-hijri

ヒジュラ暦を使用する場合は、moment-hijriプラグインを使用できます。moment-hijriは、ウム・アル・クラの計算に基づいたヒジュラ太陰暦用のmomentプラグインです。このプラグインはSuhail Alkowaileet氏によって開発されました。

インストールすると、momentをラップし、ヒジュラ暦の日付を解析できるようになります。簡単な例を以下に示します。

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

リポジトリはgithub.com/xsoh/moment-hijriにあります。

npm install moment-islamic-civil

これはもう一つのヒジュラ暦です（太陰太陽暦に基づいています）。

リポジトリはgithub.com/ACGC/moment-islamic-civilにあります。

npm install moment-recur

繰り返し日付を扱う必要がある場合は、Casey Trimm氏によるプラグインmoment-recurを使用できます。

このプラグインを使用すると、長さベースの間隔（日、週など）と暦ベースの間隔（daysOfMonth、monthsOfYearなど）を作成できます。

設定されたルールに従って日付が繰り返されるかどうかをテストするmatches関数と、一連の次の日付と前の日付を取得するジェネレーター関数が提供されています。

リポジトリ、ドキュメント、その他多くの例はgithub.com/c-trimm/moment-recurにあります。

var interval = moment( "01/01/2014" ).recur().every(2).days(); // Length Interval
interval.matches( "01/03/2014" ); // true
interval.next( 2, "L" ); // ["01/03/2014", "01/05/2014"]
interval.forget( "days" ); // Remove a rule
interval.dayOfMonth( 10 ); // Calendar Interval
interval.matches( "05/10/2014" ); // true
interval.previous( 2, "L" ); // ["12/10/2013", "11/10/2013"]

Twitterと同じようにツイートの時間をフォーマットする場合は、@hijonathan氏によるmoment.twitterプラグインを使用できます。

これは、人間が読みやすいタイムスタンプの短縮版と長縮版の両方を表示する簡単な方法です。

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

はい、スマートな複数形化を行います。

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

それでも短すぎますか？

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

会計年度、暦、または学期の四半期が必要な場合は、@robgallen氏によるmoment-fquarterプラグインを使用できます。

最も単純な方法では、任意のmomentオブジェクトに対してfquarterメソッドを呼び出すだけです。4月を第1四半期とするフォーマットされた文字列を返します。

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

開始四半期として任意の月を指定できます（例：7月）。

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

暦の四半期を使用する場合は、1月から開始します。

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

npm install moment-parseformat

このプラグインは、日付/時刻文字列の形式を抽出します。

var format = moment.parseFormat('Thursday, February 6th, 2014 9:20pm');
// dddd, MMMM Do, YYYY h:mma
moment().format(format); // format

これにより、ユーザーが日付/時刻を設定できるようにするスマートな日付入力を作成し、今後の使用のためにユーザーが優先する形式を抽出できます。minutes.ioでその使用方法の例を確認できます。

このプラグインは@gr2m氏によって作成されました。リンク：デモ | ソース

npm install moment-round

このプラグインは、日付/時刻を指定された間隔に丸めます。

例：

require('moment-round');
var m = new moment(); // 2015-06-18 15:30:19
m.round(5, 'seconds'); // 2015-06-18 15:30:20
m.ceil(3, 'minutes'); // 2015-06-18 15:33:00
m.floor(16, 'hours'); // 2015-06-18 00:00:00
m.ceil(21, 'hours'); // 2015-06-18 21:00:00
m.ceil(20, 'hours'); // 2015-06-19 00:00:00

リポジトリはgithub.com/WebDevTmas/moment-roundにあります。

bower install moment-transform

moment-transformは、パターンを通じて日付を操作するプラグインです。Momentインスタンスの個々の部分（時間、月など）に対して、基本的な操作（設定/追加/減算）を使用できます。

moment().transform('YYYY-MM-+01 00:00:00.000'); // Tonight at midnight
moment().transform('14:30:00.000'); // Today, 2:30 pm
moment().transform('YYYY-MM--30 00:00:00.000'); // 30 days ago

オプションのパラメーターを使用すると、カスタムパターンを指定し、厳密なパターン使用を強制できます（デフォルトでは、渡された文字列に英数字以外の文字は必須ではありません）。

moment().transform('+01MMYYYY', 'DD/MM/YYYY', false); // Tomorrow, same time
moment().transform('+01MMYYYY', 'DD/MM/YYYY', true); // Invalid date

動作中の様子はこちらで確認でき、リポジトリはこちらにあります。

npm install moment-taiwan

台湾暦を使用する場合は、Bradwoo8621氏によるプラグインmoment-taiwanを使用できます。

インストールすると、momentをラップし、momentは台湾暦の年をフォーマットおよび解析できるようになります。簡単な例を以下に示します。

m = moment('104/01/01', 'tYY/MM/DD') // Parse a Taiwan date
m.format('tYY/MM/DD [is] YYYY/M/D') // 104/01/01 is 2015/01/01

m.twYear() // 104

リポジトリはgithub.com/bradwoo8621/moment-taiwanにあります。

npm install moment-duration-format

これは、Moment期間の包括的なフォーマットを可能にするプラグインです。

例：

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

リポジトリはgithub.com/jsmreese/moment-duration-formatにあります。

npm install moment-timer

これは、ネイティブのJavaScriptタイマーよりもはるかに多くの制御を提供するタイマーの使用を可能にするMoment.jsプラグインです。基本的に、JavaScript独自のsetIntervalとsetTimeoutの書き換えです。

例：

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

リポジトリはgithub.com/SeverinDK/moment-timerにあります。

npm install moment-business

これは、西側の就労週（土曜日と日曜日は非就労日である7日間の週）に関するMoment操作を可能にするMoment.jsライブラリです。

例：

import business from 'moment-business';

// true if the moment is Mon-Fri, false otherwise
business.isWeekDay(someMoment);

// Adds five work days to the Moment
business.addWeekDays(someMoment, 5);

リポジトリはgithub.com/jmeas/moment-businessにあります。

@researchgate氏によるmoment-shortformatプラグインを使用すると、時間を短くフォーマットできます。

moment.twitterプラグインをベースにしており、似ていますが、出力は異なります。

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

相対時間テンプレートの使用を無効にすることもできます。

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

日付が将来または過去に遠すぎる場合、そのように表示されます。

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

npm install moment-feiertage --save

これは（moment-feiertage）、日付がドイツの祝日かどうかを判断するためのMoment.jsプラグインです。祝日はWikipedia（ドイツ語版）から取得されます。宗教的な祝日は毎年異なり、ドイツの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にあります。