投稿
  1. Web176教程首页
  2. MomentJS教程

MomentJS教程：自定义

terry • • MomentJS教程 • 阅读 301

Moment.js 非常容易自定义。 通常，应该使用自定义创建语言环境。

moment.locale('en-my-settings', {
    // 自定义
});

可以通过传入 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。

要还原更新，则使用：

moment.updateLocale('en', null);

使用 moment.locale() 更改现有的语言环境已废弃于 2.12.0。 改用 moment.updateLocale()。

months 1.0.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    months : String[]
});
moment.updateLocale('en', {
    months : Function
});
moment.updateLocale('en', {
    months : {
        format : String[],
        standalone : String[]
    }
});
// 从 2.11.0 开始
moment.locale('en', {
    months : {
        format : String[],
        standalone : String[]
    }
});
// 从 2.8.1 至 2.11.2
moment.locale('en', {
    months : String[]
});
moment.locale('en', {
    months : Function
});

// 废弃于 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 是当前正在被格式化的 moment。
        // format 是格式化字符串。
        if (/^MMMM/.test(format)) { // 如果格式以 '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
    }
});

monthsShort 1.0.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    monthsShort : String[]
});
moment.updateLocale('en', {
    monthsShort : Function
});
moment.updateLocale('en', {
    monthsShort : {
        format: String[],
        standalone : String[]
    }
});
// 从 2.11.0 开始
moment.locale('en', {
    monthsShort : {
        format: String[],
        standalone : String[]
    }
});
// 从 2.8.1 至 2.11.2
moment.locale('en', {
    monthsShort : String[]
});
moment.locale('en', {
    monthsShort : Function
});

// 废弃于 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('_')
    }
});

weekdays 1.0.0+

// 从 2.12.0 版本开始
moment.updateLocale('en', {
    weekdays : String[]
});
moment.updateLocale('en', {
    weekdays : Function
});
moment.updateLocale('en', {
    weekdays : {
        standalone : String[],
        format : String[],
        isFormat : RegExp
    }
});
// 从 2.11.0 版本开始
moment.locale('en', {
    weekdays : {
        standalone : String[],
        format : String[],
        isFormat : Boolean
    }
});
// 从 2.8.1 至 2.11.2 版本
moment.locale('en', {
    weekdays : String[]
});
moment.locale('en', {
    weekdays : Function
});

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

weekdaysShort 1.0.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    weekdaysShort : String[]
});
moment.updateLocale('en', {
    weekdaysShort : Function
});
// 从 2.8.1 至 2.11.2
moment.locale('en', {
    weekdaysShort : String[]
});
moment.locale('en', {
    weekdaysShort : Function
});

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

weekdaysMin 1.7.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    weekdaysMin : String[]
});
moment.updateLocale('en', {
    weekdaysMin : Function
});

// 从 2.8.1 至 2.11.2
moment.locale('en', {
    weekdaysMin : String[]
});
moment.locale('en', {
    weekdaysMin : Function
});

// 废弃于 2.8.1
moment.lang('en', {
    weekdaysMin : String[]
});
moment.lang('en', {
    weekdaysMin : Function
});

Locale#weekdaysMin 应是两个字母的工作日缩写的数组。 它们的目的是用于日历选择器之类的，因此它们应尽可能短小。

moment.updateLocale('en', {
    weekdaysMin : ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]
});

Locale#weekdaysMin 也可以是回调函数。

moment.updateLocale('en', {
    weekdaysMin : function (momentToFormat, format) {
        return weekdaysMin[momentToFormat.day()];
    }
});

longDateFormat 1.1.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    longDateFormat : Object
});

// 从 2.8.1 至 2.11.2
moment.locale('en', {
    longDateFormat : Object
});

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

relativeTime 1.0.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    relativeTime : Object
});
// 从 2.8.1 至 2.11.2
moment.locale('en', {
    relativeTime : Object
});

// 废弃于 2.8.1
moment.lang('en', {
    relativeTime : Object
});

Locale#relativeTime 应是用于 moment#from 的替换字符串的对象。

moment.updateLocale('en', {
    relativeTime : {
        future: "in %s",
        past:   "%s ago",
        s  : 'a few seconds',
        ss : '%d seconds',
        m:  "a minute",
        mm: "%d minutes",
        h:  "an hour",
        hh: "%d hours",
        d:  "a day",
        dd: "%d days",
        M:  "a month",
        MM: "%d months",
        y:  "a year",
        yy: "%d years"
    }
});

Locale#relativeTime.future 指向未来日期的前缀/后缀，而 Locale#relativeTime.past 则指向过去日期的前缀/后缀。 对于所有其他字符，单个字符指向单数，而双字符指向复数。

如果语言环境需要对令牌进行其他处理，则可以使用以下签名将令牌设置为函数。 该函数应返回一个字符串。

function (number, withoutSuffix, key, isFuture) {
    return string;
}

key 参数指向 Locale#relativeTime 对象中的替换键。（例如 s m mm h 等）

number 参数指向该键的单位数。 对于 m，该数字是分钟数，以此类推。

如果不带后缀显示令牌，则 withoutSuffix 参数将会为 true，如果带后缀显示令牌，则为 false。（之所以使用逻辑倒置，是因为默认的行为是显示后缀。）

如果要使用未来的后缀/前缀，则 isFuture 参数将会为 true，如果要使用过去的前缀/后缀，则为 false。

meridiem 1.6.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    meridiem : Function
});
// 从 2.8.1 至 2.11.2
moment.locale('en', {
    meridiem : Function
});

// 废弃于 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 "晚上";
        }
    }
});

meridiemParse 2.1.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    meridiemParse : RegExp
    isPM : Function
});

// 从 2.8.1 至 2.11.2
moment.locale('en', {
    meridiemParse : RegExp
    isPM : Function
});

// 废弃于 2.8.1
moment.lang('en', {
    meridiemParse : RegExp
    isPM : Function
});

如果输入的字符是中午12点以后，则 Locale#isPM 应返回 true。 这用于解析 a A 令牌。

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

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

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

calendar 1.3.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    calendar : Object
});
// 从 2.8.1 至 2.11.2
moment.locale('en', {
    calendar : Object
});

// 废弃于 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';
}

calendarFormat 2.14.0+

moment.calendarFormat = Function

这可以修改日历使用的令牌。

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

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

ordinal 1.0.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    ordinal : Function
});
// 从 2.8.1 至 2.11.2
moment.locale('en', {
    ordinal : Function
});

// 废弃于 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。

relativeTimeThreshold() 2.7.0+

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

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

单位含义用法
ss几秒钟被认为是秒钟的最少秒数。必须在设置 `s` 单位之后设置，或者不设置 `s` 单位。
s秒钟被认为是一分钟的最少秒数。
m分钟被认为是一小时的最少分钟数。
h小时被认为是一天的最少小时数。
d天被认为是一个月的最少天数。
M月份被认为是一年的最少月份数。
  // 检索现有的阈值。
  moment.relativeTimeThreshold('ss'); // 44
  moment.relativeTimeThreshold('s');  // 45
  moment.relativeTimeThreshold('m');  // 45
  moment.relativeTimeThreshold('h');  // 22
  moment.relativeTimeThreshold('d');  // 26
  moment.relativeTimeThreshold('M');  // 11

  // 设置新的阈值。
  moment.relativeTimeThreshold('ss', 3);
  moment.relativeTimeThreshold('s', 40);
  moment.relativeTimeThreshold('m', 40);
  moment.relativeTimeThreshold('h', 20);
  moment.relativeTimeThreshold('d', 25);
  moment.relativeTimeThreshold('M', 10);

注意：检索阈值新增于 2.8.1。

注意：检索与设置 ss 阈值新增于 2.18.0。

relativeTimeRounding() 2.14.0+

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

duration.humanize 在将其提供给语言环境中指定的 relativeTime 格式字符串之前，会舍入一个可能为双精度的值。 要控制舍入，则可以使用 moment.relativeTimeRounding。

var roundingDefault = moment.relativeTimeRounding();

// 向下舍入相对时间。
moment.relativeTimeRounding(Math.floor);

moment.relativeTimeThreshold('s', 60);
moment.relativeTimeThreshold('m', 60);
moment.relativeTimeThreshold('h', 24);
moment.relativeTimeThreshold('d', 31);
moment.relativeTimeThreshold('M', 12);

var a = moment();
a.subtract({hours: 23, minutes: 59, seconds: 59});
a.toNow()  // == '23 小时内'  '向下舍入到最近的小时'

// 回退到默认值。
moment.relativeTimeRounding(roundingDefault);

甚至可以选择完全不舍入：

var retainValue = function (value) {
    return value;
};
moment.relativeTimeRounding(retainValue);

var a = moment();
a.subtract({hours: 39});
a.toNow() // == '1.625 天内', '向下舍入到最近的年份'

now 2.11.0+

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

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

默认为：

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

这将会在调用 moment() 时使用，而在 format() 中省略令牌时使用的当前日期。 通常，任何需要当前时间的方法都可以在后台使用。

week 1.0.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    week : {
        dow : Int,
        doy : Int
     }
});
// 从 2.8.1 至 2.11.2
moment.locale('en', {
    week : {
        dow : Int,
        doy : Int
    }
});

// 废弃于 2.8.1
moment.lang('en', {
    week : {
        dow : Int,
        doy : Int
    }
});

Locale#week.dow 应是代表星期中第一天的整数，0是星期日、1是星期一、...、6是星期六。

Locale#week.doy 应是整数。 doy 与 dow 一起用于判断年份中的第一周。 doy 的计算方式为 7 + dow - janX，其中 janX 是一月的第一天（必须属于年份中的第一周）。

// ISO-8601，欧洲
moment.updateLocale("en", { week: {
  dow: 1, // 星期的第一天是星期一
  doy: 4  // 年份的第一周必须包含1月4日 (7 + 1 - 4)
}});

// 美国，加拿大
moment.updateLocale("en", { week: {
  dow: 0, // 星期的第一天是星期日
  doy: 6  // 年份的第一周必须包含1月1日 (7 + 0 - 1)
}});

// 许多阿拉伯国家
moment.updateLocale("en", { week: {
  dow: 6, // 星期的第一天是星期六
  doy: 12 // 年份的第一周必须包含1月1日 (7 + 6 - 1)
}});

// 也很常见
moment.updateLocale("en", { week: {
  dow: 1, // 星期的第一天是星期一
  doy: 7  // 年份的第一周必须包含1月1日 (7 + 1 - 1)
}});

invalidDate 2.3.0+

// 从 2.12.0 开始
moment.updateLocale('en', {
    invalidDate : String
});

// 从 2.8.1 至 2.11.2
moment.locale('en', {
    invalidDate : String
});

// 废弃于 2.8.1
moment.lang('en', {
    invalidDate : String
});

Locale#invalidDate 应是一个字符串。

moment.updateLocale("es", {
  invalidDate: "Fecha invalida"
});

作者：terry，如若转载，请注明出处：https://www.web176.com/momentjs/2364.html

赞 (0)
打赏 支付宝 支付宝 微信 微信
terryterry
0 0
上一篇 2021年4月7日 下午3:26
下一篇 2021年4月7日 下午3:43

相关推荐

发表回复

登录后才能评论