lunar.js 基本使用学习笔记

最新推荐文章于 2024-03-30 09:31:06 发布

RealizeInnerSelf丶

最新推荐文章于 2024-03-30 09:31:06 发布

阅读量336

点赞数

文章标签：学习笔记

本文链接：https://blog.csdn.net/qq_37177115/article/details/133008667

版权

lunar.js 基本使用学习笔记

lunar.js 基本使用学习笔记

介绍

lunar 是一无第三方依赖的公历(阳历)、农历(阴历、老黄历)、佛历和道历工具

支持星座、儒略日、干支、生肖、节气、节日、彭祖百忌、每日宜忌、吉神宜趋、凶煞宜忌、吉神(喜神/福神/财神/阳贵神/阴贵神)方位、胎神方位、冲煞、纳音、星宿、八字、五行、十神、建除十二值星、青龙名堂等十二神、黄道日及吉凶等。

tips：支持法定节假日维护

gitee 地址：lunar-javascript

有多种语言版本(java、python、go、php、c#、typescript……)
源码在 lunar-typescript 仓库中有

感觉此项目可以解决一些实际业务开发中可能会遇到的问题，故此记录一些可能会用到的 API 或者理解消化的结论

个人认为普通的日期处理还是用 dayjs 那个库*处理(个人感觉体积、性能、API结构都会好些)
在遇到需要处理农历、星座、节假日等特定场景(或者浓厚国风文化场景下)才会用的到功能时再结合此库进行处理
粗略跳读文档整体后，发现此库功能十分强大，遇到与农历相关的内容可以在此库中找到一定的解决方案，遇到了可以翻翻有没有相关内容

观察 API 文档结构可发现，Lunar 库分为几个类

实例化为对象使用其自身的一些方法进行数据处理转换

基本使用

如无特殊注明，后文代码中的 new Date() 日期均为 2022.11.27 / 2022.11.28(我是这两天整理的这份笔记)

此文章使用 lunar-javascript 版本：v1.2.36

安装：npm install lunar-javascript

// 引入
import { Solar, Lunar, HolidayUtil } from 'lunar-javascript';



console.log(Lunar.fromDate(new Date()).toFullString())
// 二〇二二年冬月初四 壬寅(虎)年 辛亥(猪)月 甲申(猴)日 午(马)时 纳音[金箔金 钗钏金 泉中水 路旁土] 星期日 北方玄武 星宿[虚日鼠](凶) 彭祖百忌[甲不开仓财物耗散 申不安床鬼祟入房] 喜神方位[艮](东北) 阳贵神方位[坤](西南) 阴贵神方位[艮](东北) 福神方位[坎](正北) 财神方位[艮](东北) 冲[(戊寅)虎] 煞[南]
console.log(Solar.fromYmd(2016, 1, 1).toFullString())
// 2016-01-01 00:00:00 闰年 星期五 (元旦节) 摩羯座
console.log(HolidayUtil.getHoliday(2020, 5, 2) + '')
// 2020-05-02 劳动节 2020-05-01

部分文档 API 转载

*末看文档学习时老是访问失败……看着看着下一页就看不了了…… 简直难顶

~~不知道是不是发布在 github pages 上的~~……(所以后文直接将一些文章拷贝了过*)

看仓库 issue 似乎是作者服务器不太给力……

所以我这里就直接把一些可能用到的文档拷过*了

佛历、道历用不太到，没有放过*

阳历相关的方法 API

Solar 阳历

阳历实例化

阳历的实例化有以下几种方式：

Solar.fromYmd(year, month, day)

指定阳历年(数字)、阳历月(数字)、阳历日(数字)生成阳历对象。注意月份为1到12。
Solar.fromYmdHms(year, month, day, hour, minute, second)

指定阳历年(数字)、阳历月(数字)、阳历日(数字)、阳历小时(数字)、阳历分钟(数字)、阳历秒钟(数字)生成阳历对象。注意月份为1到12。
Solar.fromDate(date)

指定日期(Date)生成阳历对象
Solar.fromJulianDay(julianDay)

指定儒略日(小数)生成阳历对象
Solar.fromBaZi(yearGanZhi, monthGanZhi, dayGanZhi, timeGanZhi, sect, baseYear)

通过八字年柱、月柱、日柱、时柱获取匹配的阳历列表。sect为流派，可选1或2，不传则默认为2。baseYear为起始年份，不传则默认为1900，数字过小可能导致计算时间过长。该方法可能返回多条满足条件的记录。

// 年月日
var d = Solar.fromYmd(2016, 1, 1);
console.log(d);
// 2016-01-01

// 年月日时分秒
d = Solar.fromYmdHms(2016, 1, 1, 20, 35, 0);
console.log(d);
// 2016-01-01

// 日期
d = Solar.fromDate(new Date());
console.log(d.toFullString());
// 2022-11-28 16:23:30 星期一 射手座

// 儒略日
d = Solar.fromJulianDay(2458960.5);
console.log(d.toFullString());
// 2020-04-21 00:00:00 闰年 星期二 金牛座

// 八字反推阳历
var l = Solar.fromBaZi('庚子', '辛巳', '庚午', '丙子');
for (var i=0, j=l.length; i < j; i++) {
  d = l[i];
  console.log(d.toFullString());
}
// 2020-07-21 22:00:00 闰年 星期二 巨蟹座
// 1960-08-05 22:00:00 闰年 星期五 狮子座

阳历对象可以使用多种字符串输出方式：

.toString()

阳历对象的默认字符串输出
.toFullString()

阳历对象的全量字符串输出，包含尽量多的信息
.toYmd()

阳历对象的YYYY-MM-DD字符串输出
.toYmdHms()

阳历对象的YYYY-MM-DD HH:mm:ss字符串输出

// 实例化
var d = Solar.fromDate(new Date());

// 默认字符串输出
console.log(d);
// 2022-11-28
console.log(d.toString());
// 2022-11-28

// YYYY-MM-DD
console.log(d.toYmd());
// 2022-11-28

// YYYY-MM-DD HH:mm:ss
console.log(d.toYmdHms());
// 2022-11-28 16:25:21

// 全量字符串输出
console.log(d.toFullString());
// 2022-11-28 16:25:21 星期一 射手座

获取年、月、日

.getYear()

获取阳历年
.getMonth()

获取阳历月
.getDay()

获取阳历日

var d = Solar.fromDate(new Date());

console.log(d.getYear());
// 2022
console.log(d.getMonth());
// 11
console.log(d.getDay());
// 28

儒略日

儒略日(Julian day，JD)是指由公元前4713年1月1日，协调世界时中午12时开始所经过的天数，多为天文学家采用，用以作为天文学的单一历法，把不同历法的年表统一起*。如果计算相隔若干年的两个日期之间间隔的天数，利用儒略日就比较方便。

可以通过该方法获取某个阳历时间的儒略日。

.getJulianDay()

返回儒略日(小数)。

也可通过儒略日*初始化一个阳历。

var d = Solar.fromDate(new Date());

console.log(d.getJulianDay());
// 2459912.186388889

获取星期

阳历对象提供两种星期表示方式：

.getWeek()

获取星期数字，0代表星期日，1代表星期一，6代表星期六
.getWeekInChinese()

获取星期的中文：日一二三四五六

var d = Solar.fromDate(new Date());

console.log(d.getWeek());
// 1
console.log(d.getWeekInChinese());
// 一

判断是否闰年

.isLeapYear()

返回true/false，true代表闰年，false代表非闰年。

var d = Solar.fromDate(new Date());

console.log(d.isLeapYear());
// false

获取节日

var d = Solar.fromYmd(2016, 1, 1);
var l = d.getFestivals(); // 常见的国内国际节日(返回节日的数组，包括元旦节、国庆节等，也包括母亲节、父亲节、感*节、圣诞节等，有可能同一天有多个，也可能没有)
console.log(l);
// ['元旦节']
for (var i=0, j=l.length; i<j; i++){
  console.log(l[i]);
}
// 元旦节


d = Solar.fromYmd(2019, 3, 5);
l = d.getOtherFestivals(); // 其他纪念日(返回其他纪念日的数组，例如世界抗癌日、香港回归纪念日等，有可能同一天有多个，也可能没有)
console.log(l);
// ['***诞辰纪念日', '中国青年志愿者服务日']
for (var i=0, j=l.length; i<j; i++){
  console.log(l[i]);
}
// ***诞辰纪念日
// 中国青年志愿者服务日

星座

var d = Solar.fromDate(new Date());

console.log(d.getXingZuo()); // 返回阳历对应的星座
// 射手

阳历日期推移(可**跳过节假日、六日**)

.next(days, onlyWorkday)

days(数字)为推移的天数，正数为往后推，负数为往前推。
onlyWorkday(布尔值)默认值为 false，为 true 时仅按工作日推移(法定节假日和正常的*六、*日不算，节假日调休的按工作日计算)。
返回推移后那天的阳历对象。

var d = Solar.fromYmd(2022, 09, 27)
console.log(d.next(4).toString())
// 2022-10-01
console.log(d.next(4, true).toString()) /* 第二个参数为 true(onlyWorkday)，跳过了节假日并自动处理补班(应该是按照法定节假日调休补班*的，当然特殊安排程序无法预料，需要自己额外处理)
打印结果跳过了国庆七天假，并把 10.8 这个*末算作了工作日(按照法定节假日调休补班*的)
*/
// 2022-10-08

var d = Solar.fromYmd(2022, 10, 14)
console.log(d.next(1, true).toString()) // 打印结果跳过了*六*日
// 2022-10-17

公历转阴历(农历)

// 实例化
var solar = Solar.fromDate(new Date());
console.log(solar);
// 2022-11-27

// 转阴历
var lunar = solar.getLunar();
console.log(lunar.toString());
// 二〇二二年冬月初四

console.log(lunar.toFullString());
// 二〇二二年冬月初四 壬寅(虎)年 辛亥(猪)月 甲申(猴)日 午(马)时 纳音[金箔金 钗钏金 泉中水 路旁土] 星期日 北方玄武 星宿[虚日鼠](凶) 彭祖百忌[甲不开仓财物耗散 申不安床鬼祟入房] 喜神方位[艮](东北) 阳贵神方位[坤](西南) 阴贵神方位[艮](东北) 福神方位[坎](正北) 财神方位[艮](东北) 冲[(戊寅)虎] 煞[南]

SolarWeek 阳历*

阳历*实例化

SolarWeek.fromYmd(year, month, day, start)

指定阳历年(数字)、阳历月(数字)、阳历日(数字)、星期几作为一*的开始(数字)生成阳历*对象。注意start值为1234560分别代表星期一至星期天。
SolarWeek.fromDate(date, start)

指定日期(Date)、星期几作为一*的开始(数字)生成阳历*对象。注意start值为1234560分别代表星期一至星期天。

注意：一定要记得start参数，因为常见的*计算方式，有把星期一作为一*的起点，也有把星期日作为一*的起点，不同的起点计算*相关信息时会出现很大的出入。

有人会问为什么不设置一个默认值，因为一旦使用默认值，使用者不会引起注意，结果与他期望的不同，他就会觉得这玩意儿一点都不准。我需要使用者明确知道自己使用的是哪种计算方式。

var d = SolarWeek.fromYmd(2016,1,1,1);
console.log(d);
// 2016.1.1
console.log(d.toFullString());
// 2016年1月第1*

阳历对象转化为字符串

.toString()

阳历*对象的默认字符串输出，格式为：YYYY.M.I(I为数字，从1开始计，表示本月第几*)
.toFullString()

阳历*对象的全量字符串输出，包含尽量多的信息

//实例化
var d = SolarWeek.fromDate(new Date(),1);
//默认字符串输出
console.log(d);
// 2022.11.4
console.log(d.toString());
// 2022.11.4

//全量字符串输出
console.log(d.toFullString());
// 2022年11月第4*

获取阳历日期的年月日

感觉没啥用……(在使用 lunar 处理数据并进行*推移的时候可能会有用)

var d = SolarWeek.fromDate(new Date(),1);
console.log(d.getYear()); // 获取阳历年
// 2022
console.log(d.getMonth()); // 获取阳历月
// 11
console.log(d.getDay()); // 获取阳历日
// 27

获取一*的起点

获取阳历*对象的星期几作为一*的开始，1234560分别代表星期一至星期天。

var d = SolarWeek.fromDate(new Date(),1); // 事实上你设置的起点是几，返回结果就是几，用不用，就看你心情了
console.log(d.getStart());
// 1

获取当前日期是在当月第几*，返回序号从1开始

//以星期一作为一*的起点
var d = SolarWeek.fromDate(new Date(),1);
console.log(d.getIndex());
// 4

//以星期日作为一*的起点
d = SolarWeek.fromDate(new Date(),0);
console.log(d.getIndex());
// 5

获取当前日期是在当年第几*，返回序号从1开始

// 以星期一作为一*的起点
var d = SolarWeek.fromDate(new Date(), 1);
console.log(d.getIndexInYear());
// 48

// 以星期日作为一*的起点
d = SolarWeek.fromDate(new Date(), 0);
console.log(d.getIndexInYear());
// 49

获取阳历*对象中每一天的阳历对象，有可能出现某些天跨月的现象

.getDays()

获取阳历*对象中每一天的阳历对象(可能跨月)，返回一个数组。
.getDaysInMonth()

获取阳历*对象中每一天的阳历对象(把跨月的部分丢弃掉)，返回一个数组。

//以星期一作为一*的起点
// new Date() => 2022.11.28
var d = SolarWeek.fromDate(new Date(),1);
var days = d.getDays();
for(var i=0,j=days.length;i<j;i++){
  console.log(days[i].toFullString());
}
// 2022-11-28 00:00:00 星期一 射手座
// 2022-11-29 00:00:00 星期二 射手座
// 2022-11-30 00:00:00 星期三 射手座
// 2022-12-01 00:00:00 星期四 射手座
// 2022-12-02 00:00:00 星期五 射手座
// 2022-12-03 00:00:00 星期六 射手座
// 2022-12-04 00:00:00 星期日 射手座

days = d.getDaysInMonth();
for(var i=0,j=days.length;i<j;i++){
  console.log(days[i].toFullString());
}
// 2022-11-28 00:00:00 星期一 射手座
// 2022-11-29 00:00:00 星期二 射手座
// 2022-11-30 00:00:00 星期三 射手座

//以星期日作为一*的起点
d = SolarWeek.fromDate(new Date(),0);
days = d.getDays();
for(var i=0,j=days.length;i<j;i++){
  console.log(days[i].toFullString());
}
// 2022-11-27 00:00:00 星期日 射手座
// 2022-11-28 00:00:00 星期一 射手座
// 2022-11-29 00:00:00 星期二 射手座
// 2022-11-30 00:00:00 星期三 射手座
// 2022-12-01 00:00:00 星期四 射手座
// 2022-12-02 00:00:00 星期五 射手座
// 2022-12-03 00:00:00 星期六 射手座

获取阳历*对象中的第一天，有可能出现跨月的现象

.getFirstDay()

获取阳历*对象中第一天的阳历对象(可能是上月的)。
.getFirstDayInMonth()

获取阳历*对象中第一天的阳历对象(只算本月的，如果第一天是上月，则往后顺延)。

//以星期一作为一*的起点
// new Date() => 2022.11.27
var d = SolarWeek.fromDate(new Date(),1);
console.log(d.getFirstDay().toFullString());
// 2022-11-21 00:00:00 星期一 天蝎座

//以星期日作为一*的起点
d = SolarWeek.fromDate(new Date(),0);
console.log(d.getFirstDay().toFullString());
// 2022-11-27 00:00:00 星期日 射手座

获取加(减)几后(前)的阳历对象。

按月单独计算时，如果中间某一*有跨月现象，则那一*会当作2*计。

.next(weeks, separateMonth)

返回阳历*对象。weeks(数字)：推移的*数，正数为往后推，负数为往前推。separateMonth(布尔，默认false)：是否按月单独计算，true按月单独计算，false遇跨月也算一*。

var d = SolarWeek.fromDate(new Date(),1);
//往后推两*
console.log(d.next(2));
// 2022.12.2

//往前推1*，即上*
console.log(d.next(-1));
// 2022.11.3

SolarMonth 阳历月

阳历月的实例化有以下几种方式：

SolarMonth.fromYm(year, month)

指定阳历年(数字)、阳历月(数字)生成阳历月对象。
SolarMonth.fromDate(date)

指定日期(Date)生成阳历月对象。

var d = SolarMonth.fromYm(2016,1);
console.log(d);
// 2016-1
console.log(d.toFullString());
// 2016年1月

阳历月对象可以使用两种字符串输出方式：

.toString()

阳历月对象的默认字符串输出，格式为：YYYY-M
.toFullString()

阳历月对象的全量字符串输出，格式为：YYYY年M月

//实例化
var d = SolarMonth.fromDate(new Date());
//默认字符串输出
console.log(d);
// 2022-11
console.log(d.toString());
// 2022-11

//全量字符串输出
console.log(d.toFullString());
// 2022年11月

获取阳历年、月

.getYear()

获取阳历年
.getMonth()

获取阳历月

var d = SolarMonth.fromDate(new Date());

console.log(d.getYear());
// 2022
console.log(d.getMonth());
// 11

获取阳历月对象中每一天的阳历对象

.getDays()

返回一个阳历对象的数组。

// new Date() => 2022.11.27
var d = SolarMonth.fromDate(new Date());

var days = d.getDays();
for(var i=0,j=days.length;i<j;i++){
  console.log(days[i].toFullString());
}
// 2022-11-01 00:00:00 星期二 (万圣节) 天蝎座
// 2022-11-02 00:00:00 星期三 天蝎座
// 2022-11-03 00:00:00 星期四 天蝎座
// 2022-11-04 00:00:00 星期五 天蝎座
// 2022-11-05 00:00:00 星期六 天蝎座
// 2022-11-06 00:00:00 星期日 天蝎座
// 2022-11-07 00:00:00 星期一 天蝎座
// 2022-11-08 00:00:00 星期二 天蝎座
// 2022-11-09 00:00:00 星期三 天蝎座
// 2022-11-10 00:00:00 星期四 天蝎座
// 2022-11-11 00:00:00 星期五 天蝎座
// 2022-11-12 00:00:00 星期六 天蝎座
// 2022-11-13 00:00:00 星期日 天蝎座
// 2022-11-14 00:00:00 星期一 天蝎座
// 2022-11-15 00:00:00 星期二 天蝎座
// 2022-11-16 00:00:00 星期三 天蝎座
// 2022-11-17 00:00:00 星期四 天蝎座
// 2022-11-18 00:00:00 星期五 天蝎座
// 2022-11-19 00:00:00 星期六 天蝎座
// 2022-11-20 00:00:00 星期日 天蝎座
// 2022-11-21 00:00:00 星期一 天蝎座
// 2022-11-22 00:00:00 星期二 天蝎座
// 2022-11-23 00:00:00 星期三 射手座
// 2022-11-24 00:00:00 星期四 (感*节) 射手座
// 2022-11-25 00:00:00 星期五 射手座
// 2022-11-26 00:00:00 星期六 射手座
// 2022-11-27 00:00:00 星期日 射手座
// 2022-11-28 00:00:00 星期一 射手座
// 2022-11-29 00:00:00 星期二 射手座
// 2022-11-30 00:00:00 星期三 射手座

获取阳历月对象中每一*的阳历对象

.getWeeks(start)

返回一个阳历*对象的数组。start：星期几作为一*的开始，1234560分别代表星期一至星期天

var d = SolarMonth.fromDate(new Date());

var weeks = d.getWeeks(1);
for(var i=0,j=weeks.length;i<j;i++){
  console.log(weeks[i].toFullString());
}
// 2022年11月第1*
// 2022年11月第2*
// 2022年11月第3*
// 2022年11月第4*
// 2022年11月第5*

获取加(减)几月后(前)的阳历月对象。

.next(months)

返回阳历月对象。months(数字)：推移的月数，正数为往后推，负数为往前推。

var d = SolarMonth.fromDate(new Date());

//往后推2月
console.log(d.next(2).toFullString());
// 2023年1月

SolarSeason 阳历季度

阳历季度的实例化有以下几种方式：

SolarSeason.fromYm(year, month)

指定阳历年(数字)、阳历月(数字)生成阳历季度对象。
SolarSeason.fromDate(date)

指定日期(Date)生成阳历季度对象。

var d = SolarSeason.fromYm(2016,1);
console.log(d);
// 2016.1
console.log(d.toFullString());
// 2016年1季度

阳历季度对象可以使用两种字符串输出方式：

.toString()

阳历季度对象的默认字符串输出，格式为：YYYY-I，I为季度序号：1、2、3、4
.toFullString()

阳历季度对象的全量字符串输出，格式为：YYYY年I季度，I为季度序号：1、2、3、4

//实例化
var d = SolarSeason.fromDate(new Date());
//默认字符串输出
console.log(d);
// 2022.4
console.log(d.toString());
// 2022.4

//全量字符串输出
console.log(d.toFullString
// 2022年4季度

获取年、月

.getYear()

获取阳历年
.getMonth()

获取阳历月

var d = SolarSeason.fromDate(new Date());

console.log(d.getYear());
// 2022

console.log(d.getMonth());
// 11

获取阳历季度在一年中的序号，123月为1季度，456月为2季度

.getIndex()

返回序号：1、2、3、4

var d = SolarSeason.fromDate(new Date());

console.log(d.getIndex());
// 4

获取阳历季度对象中的每一月

.getMonths()

返回一个阳历月对象的数组。

var d = SolarSeason.fromDate(new Date());

var months = d.getMonths();
for(var i=0,j=months.length;i<j;i++){
  console.log(months[i].toFullString());
}
// 2022年10月
// 2022年11月
// 2022年12月

获取加(减)几月后(前)的阳历季度对象。

.next(seasons)

返回阳历季度对象。seasons(数字)：推移的季度数，正数为往后推，负数为往前推。

var d = SolarSeason.fromDate(new Date());

//往后推2季度
console.log(d.next(2).toFullString());
// 2023年2季度

SolarHalfYear 阳历半年

阳历半年的实例化有以下几种方式：

SolarHalfYear.fromYm(year, month)

指定阳历年(数字)、阳历月(数字)生成阳历半年对象。
SolarHalfYear.fromDate(date)

指定日期(Date)生成阳历半年对象。

var d = SolarHalfYear.fromYm(2016,1);
console.log(d);
// 2016.1
console.log(d.toFullString());
// 2016年上半年

阳历半年对象可以使用两种字符串输出方式：

.toString()

阳历半年对象的默认字符串输出，格式为：YYYY-I，I为半年序号：1、2
.toFullString()

阳历半年对象的全量字符串输出，格式为：YYYY年I半年，I值为：上、下

//实例化
var d = SolarHalfYear.fromDate(new Date());

//默认字符串输出
console.log(d);
// 2022.2
console.log(d.toString());
// 2022.2

//全量字符串输出
console.log(d.toFullString());
// 2022年下半年

获取年、月

.getYear()

获取阳历年
.getMonth()

获取阳历月

var d = SolarHalfYear.fromDate(new Date());

console.log(d.getYear());
// 2022
console.log(d.getMonth());
// 11

获取阳历半年在一年中的序号，123456月为1半年

.getIndex()

返回序号：1、2

var d = SolarHalfYear.fromDate(new Date());

console.log(d.getIndex());
// 2

获取阳历半年对象中的每一月

.getMonths()

返回一个阳历月对象的数组。

var d = SolarHalfYear.fromDate(new Date());

var months = d.getMonths();
for(var i=0,j=months.length;i<j;i++){
  console.log(months[i].toFullString());
}
// 2022年7月
// 2022年8月
// 2022年9月
// 2022年10月
// 2022年11月
// 2022年12月

获取加(减)几月后(前)的阳历半年对象

.next(halfYears)

返回阳历半年对象。halfYears(数字)：推移的半年数，正数为往后推，负数为往前推。

var d = SolarHalfYear.fromDate(new Date());

//往后推2半年
console.log(d.next(2).toFullString());
// 2023年下半年

SolarYear 阳历年

阳历年的实例化有以下几种方式：

SolarYear.fromYear(year)

指定阳历年(数字)生成阳历年对象。
SolarYear.fromDate(date)

指定日期(Date)生成阳历年对象。

var d = SolarYear.fromYear(2016);
console.log(d);
// 2016

console.log(d.toFullString());
// 2016年

阳历年对象可以使用两种字符串输出方式：

.toString()

阳历年对象的默认字符串输出，格式为：YYYY
.toFullString()

阳历年对象的全量字符串输出，格式为：YYYY年

//实例化
var d = SolarYear.fromDate(new Date());

//默认字符串输出
console.log(d);
// 2022
console.log(d.toString());
// 2022

//全量字符串输出
console.log(d.toFullString());
// 2022年

获取年

.getYear()

获取阳历年

var d = SolarYear.fromDate(new Date());

console.log(d.getYear());
// 2022

获取阳历年对象中的每一月

.getMonths()

返回一个阳历月对象的数组。

var d = SolarYear.fromDate(new Date());

var months = d.getMonths();
for(var i=0,j=months.length;i<j;i++){
  console.log(months[i].toFullString());
}
// 2022年1月
// 2022年2月
// 2022年3月
// 2022年4月
// 2022年5月
// 2022年6月
// 2022年7月
// 2022年8月
// 2022年9月
// 2022年10月
// 2022年11月
// 2022年12月

获取加(减)几月后(前)的阳历年对象

.next(years)

返回阳历年对象。years(数字)：推移的年数，正数为往后推，负数为往前推。

var d = SolarYear.fromDate(new Date());

//往后推2年
console.log(d.next(2).toFullString());
// 2024年

SolarUtil 阳历工具

判断某年是否闰年

SolarUtil.isLeapYear(year)

返回布尔值。true：是闰年。false：非闰年。

console.log(SolarUtil.isLeapYear(2016));
// true

获取某年天数

闰年366天，平年365天。

SolarUtil.getDaysOfYear(year)

返回天数year：阳历年(数字)。

console.log(SolarUtil.getDaysOfYear(2016));
// 366

获取阳历某月天数

SolarUtil.getDaysOfMonth(year, month)

返回天数(数字)。year：阳历年(数字)。month：阳历月(数字)。

console.log(SolarUtil.getDaysOfMonth(2016,2));
// 29

获取某月*数

SolarUtil.getDaysOfMonth(year, month, start)

返回*数(数字)。year：阳历年(数字)。month：阳历月(数字)。start：星期几作为一*的开始，1234560分别代表星期一至星期天(数字)。

console.log(SolarUtil.getWeeksOfMonth(2016,2,1));
// 5

获取某天位于当年第几天

从1月1日开始累积的当年天数。例如1月2日，位于当年第2天，2月1日，位于当年第32天。

SolarUtil.getDaysInYear(year, month, day)

返回位于当年第几天year：阳历年(数字)。month：阳历月(数字)。day：阳历日(数字)。

console.log(SolarUtil.getDaysInYear(2016, 3, 1));
// 61

阴历相关的方法 API

干支禄物候数九三伏六曜二十八宿七政四宫四神兽等文档省略了，个人感觉用不太到

Lunar 阴历

阴历的实例化有以下几种方式：

Lunar.fromYmd(lunarYear, lunarMonth, lunarDay)

指定阴历年(数字)、阴历月(数字)、阴历日(数字)生成阴历对象。注意月份为1到12，闰月为负，即闰2月=-2。
Lunar.fromYmdHms(lunarYear, lunarMonth, lunarDay, hour, minute, second)

指定阴历年(数字)、阴历月(数字)、阴历日(数字)、阳历小时(数字)、阳历分钟(数字)、阳历秒钟(数字)生成阴历对象。注意月份为1到12，闰月为负，即闰2月=-2。
Lunar.fromDate(date)

指定阳历日期(Date)生成阴历对象

var d = Lunar.fromYmd(1986, 4, 21);
console.log(d);
// 一九八六年四月廿一
console.log(d.toFullString());
// 一九八六年四月廿一 丙寅(虎)年 癸巳(蛇)月 癸酉(鸡)日 子(鼠)时 纳音[炉中火 长流水 剑锋金 桑柘木] 星期四 北方玄武 星宿[斗木獬](吉) 彭祖百忌[癸不词讼理弱敌强 酉不会客醉坐颠狂] 喜神方位[巽](东南) 阳贵神方位[巽](东南) 阴贵神方位[震](正东) 福神方位[艮](东北) 财神方位[离](正南) 冲[(丁卯)兔] 煞[东]

d = Lunar.fromDate(new Date());
console.log(d);
// 二〇二二年冬月初五
console.log(d.toFullString());
// 二〇二二年冬月初五 壬寅(虎)年 辛亥(猪)月 乙酉(鸡)日 辰(龙)时 纳音[金箔金 钗钏金 泉中水 白蜡金] 星期一 北方玄武 星宿[危月燕](凶) 彭祖百忌[乙不栽植千株不长 酉不会客醉坐颠狂] 喜神方位[乾](西北) 阳贵神方位[坤](西南) 阴贵神方位[坎](正北) 福神方位[坤](西南) 财神方位[艮](东北) 冲[(己卯)兔] 煞[东]

d = Lunar.fromYmdHms(1986, 4, 21, 20, 5, 0);
// 时辰
console.log(d.getTimeZhi()+'时');
// 戌时

阴历对象可以使用两种字符串输出方式：

.toString()

阴历对象的默认字符串输出
.toFullString()

阴历对象的全量字符串输出，包含尽量多的信息

//实例化
var d = Lunar.fromDate(new Date());

//默认字符串输出
console.log(d);
// 二〇二二年冬月初五
console.log(d.toString());
// 二〇二二年冬月初五

//全量字符串输出
console.log(d.toFullString());
// 二〇二二年冬月初五 壬寅(虎)年 辛亥(猪)月 乙酉(鸡)日 辰(龙)时 纳音[金箔金 钗钏金 泉中水 白蜡金] 星期一 北方玄武 星宿[危月燕](凶) 彭祖百忌[乙不栽植千株不长 酉不会客醉坐颠狂] 喜神方位[乾](西北) 阳贵神方位[坤](西南) 阴贵神方位[坎](正北) 福神方位[坤](西南) 财神方位[艮](东北) 冲[(己卯)兔] 煞[东]

获取年、月、日

获取数字表示

.getYear()

获取阴历年的数字
.getMonth()

获取阴历月的数字，值从1到12，但闰月为负数，如闰二月=-2。
.getDay()

获取阴历日的数字

获取中文表示

.getYearInChinese()

获取阴历年的中文
.getMonthInChinese()

获取阴历月的中文
.getDayInChinese()

获取阴历日的中文

var d = Lunar.fromDate(new Date());

console.log(d.getYear());
// 2022
console.log(d.getMonth());
// 11
console.log(d.getDay());
// 5

console.log(d.getYearInChinese());
// 二〇二二
console.log(d.getMonthInChinese());
// 冬
console.log(d.getDayInChinese());
// 初五

获取时辰

时辰为中国传统计时单位。把一昼夜平分为十二段，每段叫做一个时辰，对应12地支，合现在的两小时。

时辰对照表参考阴历工具-时辰

.getTimeGan()

获取时辰天干
.getTimeZhi()

获取时辰地支
.getTimeInGanZhi()

获取时辰干支
.getTimeShengXiao()

获取时辰生肖
.getTime()

获取时辰对象
.getTimes()

获取当天的所有时辰对象，由于有早子时和晚子时，会返回13个对象。

var d = Lunar.fromDate(new Date());

console.log(d.getTimeGan());
// 庚
console.log(d.getTimeZhi());
// 辰
console.log(d.getTimeInGanZhi());
// 庚辰
console.log(d.getTimeShengXiao());
// 龙

// 获取当天时辰列表
var times = d.getTimes();
for (var i = 0, j = times.length; i < j; i++){
  var time = times[i];
  console.log(time.getMinHm() + ' - ' + time.getMaxHm() + ' : ' + time.getGanZhi());
}
// 00:00 - 00:59 : 丙子
// 01:00 - 02:59 : 丁丑
// 03:00 - 04:59 : 戊寅
// 05:00 - 06:59 : 己卯
// 07:00 - 08:59 : 庚辰
// 09:00 - 10:59 : 辛巳
// 11:00 - 12:59 : 壬午
// 13:00 - 14:59 : 癸未
// 15:00 - 16:59 : 甲申
// 17:00 - 18:59 : 乙酉
// 19:00 - 20:59 : 丙戌
// 21:00 - 22:59 : 丁亥
// 23:00 - 23:59 : 戊子

获取星期

阴历对象也可直接获取星期，同样提供两种星期表示方式：

.getWeek()

获取星期数字，0代表星期日，1代表星期一，6代表星期六
.getWeekInChinese()

获取星期的中文：日一二三四五六

中国古代也用“七曜日”*表示星期，详见七政(七曜)。

var d = Lunar.fromDate(new Date());

console.log(d.getWeek());
// 1
console.log(d.getWeekInChinese());
// 一

节日

.getFestivals()

返回常用节日的数组，包括春节、中秋、元宵等，有可能同一天有多个，也可能没有。
.getOtherFestivals()

返回其他传统节日的数组，包括寒衣节、下元节、祭灶日等，有可能同一天有多个，也可能没有。

注意：这里的节日有可能放假，有可能不放假，是否放假需参考法定假日。

var d = Lunar.fromYmd(2016, 2, 2);
var l = d.getFestivals();
for (var i=0, j=l.length; i<j; i++){
  console.log(l[i]);
}
// 龙头节

l = d.getOtherFestivals();
for (var i=0, j=l.length; i<j; i++){
  console.log(l[i]);
}
// 社日节

生肖

十二生肖，又叫属相，是中国与十二地支相配以人出生年份的十二种动物，包括鼠、牛、虎、兔、龙、蛇、马、羊、猴、鸡、狗、猪。

十二生肖是十二地支的形象化代表，即子(鼠)、丑(牛)、寅(虎)、卯(兔)、辰(龙)、巳(蛇)、午(马)、未(羊)、申(猴)、酉(鸡)、戌(狗)、亥(猪)。

由于生肖对应地支，所以年、月、日、时辰都对应生肖。

.getYearShengXiao()

获取年的生肖(以正月初一起)
.getMonthShengXiao()

获取月的生肖(以节交接当天起)
.getDayShengXiao()

获取日的生肖
.getTimeShengXiao()

获取时辰的生肖
.getShengxiao()

[已过时] 获取年的生肖，为兼容老版本而保留，等同于getYearShengXiao

由于年月的干支划分方式有区别，所以生肖也会对应不同。

.getYearShengXiaoByLiChun()

获取年的生肖(以立春当天起)
.getYearShengXiaoExact()

获取年的生肖(以立春交接时刻起)
.getMonthShengXiaoExact()

获取月的生肖(以节交接时刻起)

var d = Lunar.fromDate(new Date());

console.log('年：'+d.getYearShengXiao());
// 年：虎
console.log('月：'+d.getMonthShengXiao());
// 月：猪
console.log('日：'+d.getDayShengXiao());
// 日：鸡
console.log('时：'+d.getTimeShengXiao());
// 时：龙

console.log('年：'+d.getYearShengXiaoByLiChun());
// 年：虎
console.log('年：'+d.getYearShengXiaoExact());
// 年：虎
console.log('月：'+d.getMonthShengXiaoExact());
// 月：猪

节气

二十四节气包括十二节(立春、惊蛰、清明、立夏、芒种、小暑、立秋、白露、寒露、立冬、大雪、小寒)和十二气(雨水、春分、谷雨、小满、夏至、大暑、处暑、秋分、霜降、小雪、冬至、大寒)。

节气的计算使用了寿星天文历的算法。

节气先后顺序为以冬至开始，以大雪结束，通常冬至位于阳历的上一年。

getJie()

获取节令名(字符串)，当匹配到键为DA_XUE的节令时，也返回中文的大雪，未匹配时返回空字符串
getQi()

获取气令名(字符串)，当匹配到键为DONG_ZHI的气令时，也返回中文的冬至，未匹配时返回空字符串
getJieQi()

获取节气名(字符串)，当匹配到键为DA_XUE的节令时，也返回中文的大雪，当匹配到键为DONG_ZHI的气令时，也返回中文的冬至，未匹配时返回空字符串
getJieQiTable()

获取当年的节气表(键值对方式，键为节气名称，值为对应阳历。)
getJieQiList()

获取当年的节气名称(按时间先后排序)，由于js中getJieQiTable无法排序，所以提供该方法，某些语言(如java)中getJieQiTable已经排序，所以不提供该方法。

注意：为了在任何一天都能获取到上一节气、下一节气而不用考虑跨年的问题，在头部追加一个键为DA_XUE的节令*表示上个节气*期末的大雪；在最后追加一个键为DONG_ZHI的气令*表示阳历年末的冬至；同时，在最后追加一个键为XIAO_HAN的节令*表示下一阳历年初的小寒，追加一个键为DA_HAN的气令*表示下一阳历年初的大寒，追加一个键为LI_CHUN的气令*表示下一阳历年初的立春，追加YU_SHUI表示雨水，追加JING_ZHE表示惊蛰。所以最终节气表如下：

DA_XUE, 冬至, 小寒, 大寒, 立春, 雨水, 惊蛰, 春分, 清明, 谷雨, 立夏, 小满, 芒种, 夏至, 小暑, 大暑, 立秋, 处暑, 白露, 秋分, 寒露, 霜降, 立冬, 小雪, 大雪, DONG_ZHI, XIAO_HAN, DA_HAN, LI_CHUN, YU_SHUI, JING_ZHE

其中冬至到大雪为一个节气*期，DA_XUE和冬至位于阳历上一年，小寒到DONG_ZHI位于阳历同一年，XIAO_HAN、DA_HAN、LI_CHUN、YU_SHUI、和JING_ZHE位于阳历下一年。可参考下方示例打印的节气表辅助理解。

为了更好的封装，单独提供了一个新的JieQi对象，包含节气名称和阳历日期，JieQi对象提供如下方法：

getName()

获取名称(字符串)
getSolar()

获取阳历对象
isJie()

是否节令，返回true/false
isQi()

是否气令，返回true/false

同时也为Lunar对象提供了新的方法，更加方便的获取临近的节气：

getPrevJieQi(wholeDay)

获取上一节气(逆推的第一个节气)。参数wholeDay传true/false，true代表按天匹配，false代表按精确时刻匹配。返回JieQi对象
getNextJieQi(wholeDay)

获取下一节气(顺推的第一个节气)。参数wholeDay传true/false，true代表按天匹配，false代表按精确时刻匹配。返回JieQi对象
getCurrentJieQi()

获取当前节气，返回JieQi对象，当天无节气返回null
getPrevJie(wholeDay)

获取上一节令(逆推的第一个节令)。参数wholeDay传true/false，true代表按天匹配，false代表按精确时刻匹配。返回JieQi对象
getNextJie(wholeDay)

获取下一节令(顺推的第一个节令)。参数wholeDay传true/false，true代表按天匹配，false代表按精确时刻匹配。返回JieQi对象
getCurrentJie()

获取当天节令，返回JieQi对象，当天无节令返回null
getPrevQi(wholeDay)

获取上一气令(逆推的第一个气令)。参数wholeDay传true/false，true代表按天匹配，false代表按精确时刻匹配。返回JieQi对象
getNextQi(wholeDay)

获取下一气令(顺推的第一个气令)。参数wholeDay传true/false，true代表按天匹配，false代表按精确时刻匹配。返回JieQi对象
getCurrentQi()

获取当天气令，返回JieQi对象，当天无气令返回null

//农历2020年3月12日是清明节
var d = Lunar.fromYmd(2020,3,12);

console.log('节：'+d.getJie());
// 节：清明
console.log('气：'+d.getQi());
// 气：
console.log('节气：'+d.getJieQi());
// 节气：清明

//获取立春交接的准确时间
console.log('立春：'+d.getJieQiTable()['立春'].toYmdHms());
// 立春：2020-02-04 17:03:12

var l = d.getJieQiList();
console.log(l);
// DA_XUE,冬至,小寒,大寒,立春,雨水,惊蛰,春分,清明,谷雨,立夏,小满,芒种,夏至,小暑,大暑,立秋,处暑,白露,秋分,寒露,霜降,立冬,小雪,大雪,DONG_ZHI,XIAO_HAN,DA_HAN,LI_CHUN,YU_SHUI,JING_ZHE

var jieQi = d.getJieQiTable();

for (var i=0, j=l.length; i<j; i++){
  var name = l[i];
  console.log(name + ' = ' + jieQi[name].toYmdHms());
}
// DA_XUE = 2019-12-07 18:18:21
// 冬至 = 2019-12-22 12:19:18
// 小寒 = 2020-01-06 05:29:59
// 大寒 = 2020-01-20 22:54:33
// 立春 = 2020-02-04 17:03:12
// 雨水 = 2020-02-19 12:56:53
// 惊蛰 = 2020-03-05 10:56:44
// 春分 = 2020-03-20 11:49:29
// 清明 = 2020-04-04 15:38:02
// 谷雨 = 2020-04-19 22:45:21
// 立夏 = 2020-05-05 08:51:16
// 小满 = 2020-05-20 21:49:09
// 芒种 = 2020-06-05 12:58:18
// 夏至 = 2020-06-21 05:43:33
// 小暑 = 2020-07-06 23:14:20
// 大暑 = 2020-07-22 16:36:44
// 立秋 = 2020-08-07 09:06:03
// 处暑 = 2020-08-22 23:44:48
// 白露 = 2020-09-07 12:07:54
// 秋分 = 2020-09-22 21:30:32
// 寒露 = 2020-10-08 03:55:07
// 霜降 = 2020-10-23 06:59:25
// 立冬 = 2020-11-07 07:13:46
// 小雪 = 2020-11-22 04:39:38
// 大雪 = 2020-12-07 00:09:21
// DONG_ZHI = 2020-12-21 18:02:12
// XIAO_HAN = 2021-01-05 11:23:17
// DA_HAN = 2021-01-20 04:39:42
// LI_CHUN = 2021-02-03 22:58:39
// YU_SHUI = 2021-02-18 18:43:49
// JING_ZHE = 2021-03-05 16:53:32

d = Lunar.fromDate(new Date());
var prev = d.getPrevJieQi();
console.log('上一节气 = ' + prev.getName() + ' ' +prev.getSolar().toYmdHms());
// 上一节气 = 小雪 2022-11-22 16:20:18
var next = d.getNextJieQi();
console.log('下一节气 = ' + next.getName() + ' ' +next.getSolar().toYmdHms());
// 下一节气 = 大雪 2022-12-07 11:46:04

阴历日期的推移

.next(days)

days(数字)为推移的天数，正数为往后推，负数为往前推。返回推移后那天的阴历对象。

你也可以使用阳历进行日期推移，然后再转阴历，效果一样，但可能会更耗时。

var d = Lunar.fromDate(new Date());

// 往后推两天，即后天
console.log(d.next(2));
// 二〇二二年冬月初七

// 往前推1天，即昨天
console.log(d.next(-1));
// 二〇二二年冬月初四

阴历转阳历

阴历和阳历之间的相互转换，必须得支持才行。

.getSolar()

返回对应的阳历对象。

// 实例化
var lunar = Lunar.fromYmd(1986, 4, 21);

console.log(lunar);
// 一九八六年四月廿一

// 转阳历
var solar = lunar.getSolar();

console.log(solar.toString());
// 1986-05-29
console.log(solar.toFullString());
// 1986-05-29 00:00:00 星期四 双子座

LunarMonth 阴历月

阴历月

阴历月自v1.2.0版本加入，它的实例化有以下几种方式：

new LunarMonth(lunarYear, lunarMonth, dayCount, firstJulianDay)

指定阴历年(数字)、阴历月(数字)、当月天数(数字)、初一的儒略日(数字)生成阴历月对象。其中阴历月取值1-12，闰月为负数，如闰2月为-2。当月天数为29或30，小月29天，大月30天。
LunarYear.fromYm(lunarYear, lunarMonth)

指定阴历年(数字)、阴历月(数字)自动计算生成阴历月对象。其中阴历月取值1-12，闰月为负数，如闰2月为-2。

var lunarMonth = LunarMonth.fromYm(2012, -4);
console.log(lunarMonth.toString());
// 2012年闰四月(29)天

阴历月转字符串

.toString()

阴历月对象的默认字符串输出，格式为：YYYY年M月(D)天

//实例化
var lunarMonth = LunarMonth.fromYm(3333, 2);

//默认字符串输出
console.log(lunarMonth);
// 3333年二月(30)天
console.log(lunarMonth.toString());
// 3333年二月(30)天

阴历获取本月天数

阴历月自v1.2.0版本加入，阴历一个月只可能是30天或者29天。获取天数可以判断当月是大月(30天)还是小月(29天)。

.getDayCount()

获取当月天数

var lunarMonth = LunarMonth.fromYm(2021, 9);
console.log(lunarMonth.getDayCount());
// 30

阴历是否闰月

.isLeap()

判断当月是否闰月，是返回true，否返回false

var lunarMonth = LunarMonth.fromYm(2020, 4);
console.log(lunarMonth.isLeap());
// false

lunarMonth = LunarMonth.fromYm(2020, -4);
console.log(lunarMonth.isLeap());
// true

阴历获取当月初一

.getFirstJulianDay()

获取当月初一的儒略日，有了儒略日，就可以很方便的计算出阳历和阴历日期。

var lunarMonth = LunarMonth.fromYm(2021, 9);

var firstJulianDay = lunarMonth.getFirstJulianDay();

// 儒略日转阳历
var solar = Solar.fromJulianDay(firstJulianDay);

// 转阴历
var lunar = solar.getLunar();

console.log(firstJulianDay);
// 2459494
console.log(solar.toYmd());
// 2021-10-06
console.log(lunar.toString());
// 二〇二一年九月初一

获取加(减)几月后(前)的阳历月对象。

按月单独计算时，如果中间某一*有跨月现象，则那一*会当作2*计。

.next(months)

返回阴历月对象。months(数字)：推移的月数，正数为往后推，负数为往前推。

// v1.2.27
var d = LunarMonth.fromYm(2022, 1);

// 往后推2月
console.log(d.next(2).toString());
// 2022年三月(30)天

LunarYear 阴历年

阴历年实例化有以下几种方式：

new LunarYear(lunarYear)

指定阴历年(数字)生成阴历年对象。
LunarYear.fromYear(lunarYear)

指定阴历年(数字)生成阴历年对象。

var lunarYear = LunarYear.fromYear(2012);
console.log(lunarYear);
// 2012
console.log(lunarYear.toFullString());
// 2012年

阴历年自字符串输出：

.toString()

阴历年对象的默认字符串输出，格式为：YYYY
.toFullString()

阴历年对象的全量字符串输出，格式为：YYYY年

//实例化
var lunarYear = LunarYear.fromYear(3333);

//默认字符串输出
console.log(lunarYear);
// 3333
console.log(lunarYear.toString());
// 3333

//全量字符串输出
console.log(lunarYear.toFullString());
// 3333年

获取阴历月

.getMonths()

获取阴历年对象中的所有月份(为保障节气的连续性，增加了冗余的月份)。返回一个阴历月对象的数组。
.getMonth(lunarMonth)

指定当年的阴历月份(数字)获取阴历月对象。参数可选1-12，闰月为负数，如闰2月为-2。如果没有匹配的月份，返回null。

var lunarYear = LunarYear.fromYear(2020);

var months = lunarYear.getMonths();
for(var i=0, j=months.length; i<j; i++){
  console.log(months[i].toString());
}
// 2019年冬月(30)天
// 2019年腊月(30)天
// 2020年正月(29)天
// 2020年二月(30)天
// 2020年三月(30)天
// 2020年四月(30)天
// 2020年闰四月(29)天
// 2020年五月(30)天
// 2020年六月(29)天
// 2020年七月(29)天
// 2020年八月(30)天
// 2020年九月(29)天
// 2020年十月(30)天
// 2020年冬月(29)天
// 2020年腊月(30)天

获取闰月

.getLeapMonth()

获取闰月数字，1代表闰1月，0代表无闰月

var lunarYear = LunarYear.fromYear(2020);
console.log(lunarYear.getLeapMonth());
// 4

获取节气表

.getJieQiJulianDays()

获取阴历年对象中的所有节气(儒略日)。返回一个数组。

var lunarYear = LunarYear.fromYear(2020);

var jieQiJulianDays = lunarYear.getJieQiJulianDays();
for(var i=0, j=jieQiJulianDays.length; i<j; i++){
  var julianDay = jieQiJulianDays[i];
  var solar = Solar.fromJulianDay(julianDay);
  var lunar = solar.getLunar();
  console.log(julianDay + ' = ' + solar.toYmdHms() + ' ' + lunar.getJieQi());
}
// 2458825.262738939 = 2019-12-07 18:18:21 大雪
// 2458840.013406825 = 2019-12-22 12:19:18 冬至
// 2458854.729155622 = 2020-01-06 05:29:59 小寒
// 2458869.4545455333 = 2020-01-20 22:54:33 大寒
// 2458884.2105561327 = 2020-02-04 17:03:12 立春
// 2458899.039498242 = 2020-02-19 12:56:53 雨水
// 2458913.9560679863 = 2020-03-05 10:56:44 惊蛰
// 2458928.992700611 = 2020-03-20 11:49:29 春分
// 2458944.1514096884 = 2020-04-04 15:38:02 清明
// 2458959.4481605194 = 2020-04-19 22:45:21 谷雨
// 2458974.868931047 = 2020-05-05 08:51:16 立夏
// 2458990.4091356103 = 2020-05-20 21:49:09 小满
// 2459006.04048856 = 2020-06-05 12:58:18 芒种
// 2459021.7385792835 = 2020-06-21 05:43:33 夏至
// 2459037.468285391 = 2020-07-06 23:14:20 小暑
// 2459053.192179222 = 2020-07-22 16:36:44 大暑
// 2459068.879201647 = 2020-08-07 09:06:03 立秋
// 2459084.48944142 = 2020-08-22 23:44:48 处暑
// 2459100.005487287 = 2020-09-07 12:07:54 白露
// 2459115.396199445 = 2020-09-22 21:30:32 秋分
// 2459130.663276956 = 2020-10-08 03:55:07 寒露
// 2459145.791266503 = 2020-10-23 06:59:25 霜降
// 2459160.80123198 = 2020-11-07 07:13:46 立冬
// 2459175.6941854595 = 2020-11-22 04:39:38 小雪
// 2459190.506498529 = 2020-12-07 00:09:21 大雪
// 2459205.251524649 = 2020-12-21 18:02:12 冬至
// 2459219.9745042496 = 2021-01-05 11:23:17 小寒
// 2459234.6942393854 = 2021-01-20 04:39:42 大寒
// 2459249.457398226 = 2021-02-03 22:58:39 立春
// 2459264.280423728 = 2021-02-18 18:43:49 雨水
// 2459279.2038478567 = 2021-03-05 16:53:32 惊蛰

阴历年的推移

获取加(减)几月后(前)的阴历年对象。

.next(years)

返回阴历年对象。years(数字)：推移的年数，正数为往后推，负数为往前推。

// v1.2.27
var d = LunarYear.fromYear(2022);

// 往后推2年
console.log(d.next(2).toFullString());
// 2024年

LunarUtil 阴历工具

获取阴历某月天数

LunarUtil.getDaysOfMonth(year, month)

返回天数(数字)。year：阴历年(数字)。month：阴历月(数字)，闰月为负数，如闰二月为-2。v1.2.0及以上版本已删除，可换用LunarYear中的方法。

console.log(LunarUtil.getDaysOfMonth(2016,1));
// 30

获取指定阴历年月的下一月是几月

为什么需要这个方法？因为阴历和阳历不同，阴历会有闰月，比如某年闰4月，那么4月之后，会多出一个4月，所以有需要的时候，可以使用这个方法*获取下个月到底是几月。

LunarUtil.nextMonth(year, month)

返回月份(数字)，闰月为负数。year：阴历年(数字)。month：阴历月(数字)，闰月为负数，如闰二月为-2。v1.2.0及以上版本已删除，可换用LunarYear中的方法。

console.log(LunarUtil.nextMonth(2016,1));
// 2

阴历某年闰几月

获取指定阴历年的的闰月。

为什么需要这个方法？因为阴历和阳历不同，阴历会有闰月，比如某年闰4月，那么4月之后，会多出一个4月，所以有需要的时候，可以使用这个方法*获取指定年份闰几月。v1.2.0及以上版本已删除，可换用LunarYear中的方法。

LunarUtil.getLeapMonth(year)

返回月份(数字)，1代表闰1月，0代表无闰月。year：阴历年(数字)。

console.log(LunarUtil.getLeapMonth(2017));
// 6

时辰

时辰为中国传统计时单位。把一昼夜平分为十二段，每段叫做一个时辰，对应12地支，合现在的两小时。

时辰对照表：

子时	丑时	寅时	卯时	辰时	巳时
23:00-00:59	01:00-02:59	03:00-04:59	05:00-06:59	07:00-08:59	09:00-10:59
午时	未时	申时	酉时	戌时	亥时
11:00-12:59	13:00-14:59	15:00-16:59	17:00-18:59	19:00-20:59	21:00-22:59

LunarUtil.convertTime(hm)

返回时辰(地支)，如子。hm：HH:mm时刻。

console.log(LunarUtil.convertTime('23:59')+'时');
// 子时

HolidayUtil 法定节假日相关 API

笔记存在的问题或可以完善的内容
~~数据修正及补充是什么层面的？存到代码文件中的还是内存中的(一次维护还是需要次次调用相关代码更正？)~~
大概率是内存中，即项目重新运行后需要重新设置一遍
(后续可以在 node_modules\lunar-javascript\lunar.js 里搜索 _DATA= 往后追加新的节假日日期实现数据“持久化”，当然 npm 重新装下就没了，显然不行，建议写到初始化代码里做追加)
// src\main.js
import { HolidayUtil } from 'lunar-javascript';

// 比如是 2021年拉的库，自己按规则把 2022年的节假日处理好了，通过此种方式追加(由于节假日是国家在前一年十一二月公布的，需要手动处理，不能单纯靠代码猜)
HolidayUtil.fix('202201010120220101202201020120220101202201030120220101202201291020220201202201301020220201202201311120220201202202011120220201202202021120220201202202031120220201202202041120220201202202051120220201202202061120220201202204022020220405202204032120220405202204042120220405202204052120220405202204243020220501202204303120220501202205013120220501202205023120220501202205033120220501202205043120220501202205073020220501202206034120220603202206044120220603202206054120220603202209105120220910202209115120220910202209125120220910202210016120221001202210026120221001202210036120221001202210046120221001202210056120221001202210066120221001202210076120221001202210086020221001202210096020221001');
亦或是定期更新 lunar-javascript 包的依赖 npm update lunar-javascript
结合业务场景封装使用(只需要获取到节假日列表，返回结果中需要是什么格式的数据……)

法定假日指国家规定的放假和调休安排，*源于国务院办公厅发布的国办发明电文件。

可前往http://www.gov.cn/zhengce/xxgk/index.htm搜索节假日查看。

一般是每年11月底12月初发布*年的节假日安排。

法定假日包括以下信息：

当天日期(day)：YYYY-MM-DD格式的日期字符串
是否调休(work)：布尔值，调休为true，放假为false
假期名称(name)：字符串，例如国庆节，如果国庆和中秋为同一天，则为国庆中秋。目前包括：元旦节、春节、清明节、劳动节、端午节、中秋节、国庆节、国庆中秋和抗战胜利日，以后有新增再追加。
关联的节日(target)：YYYY-MM-DD格式的日期字符串，例如2020-05-02日放劳动节，它关联的节日为2020-05-01，当放假与节日为同一天时，关联节日也是当天。

var d = HolidayUtil.getHoliday(2020,5,2);
console.log('日期：'+d.getDay());
// 日期：2020-05-02
console.log('是否调休：'+d.isWork());
// 是否调休：false
console.log('假期名称：'+d.getName());
// 假期名称：劳动节
console.log('关联节日：'+d.getTarget());
// 关联节日：2020-05-01

数据修正及补充

由于默认法定节假日数据*源于国务院办公厅发布的通知，一般要年底才发布下一年的节假日安排，所以存在更新及时性的问题，可以在默认节假日数据的基础上，自行修改默认数据，或者追加新的数据。

fix(names, data)

修正或追加节假日数据
fix(data)

等同于fix(null, data)

names(字符串数组)用于替换默认的节假日名称列表，当names传null时，保持默认的节假日名称。

data(字符串)为需要修正或追加的节假日数据，当data传null(go语言传空字符串)时，仅修改默认节假日名称。

每18位表示1天依次排列，格式：当天年月日YYYYMMDD(8位)+节假日名称下标(1位)+调休标识(1位)+节假日当天YYYYMMDD(8位)。

其中节假日名称下标从0开始，超过9的，按ASCII码表依次往后排列；
调休标识0为上班，否则放假。
示例：202005023120200501代表2020-05-02为劳动节放假，对应节假日为2020-05-01。

2022年的修正数据参考(*源于国务院办公厅关于2022年部分节假日安排的通知)：

202201010120220101202201020120220101202201030120220101202201291020220201202201301020220201202201311120220201202202011120220201202202021120220201202202031120220201202202041120220201202202051120220201202202061120220201202204022020220405202204032120220405202204042120220405202204052120220405202204243020220501202204303120220501202205013120220501202205023120220501202205033120220501202205043120220501202205073020220501202206034120220603202206044120220603202206054120220603202209105120220910202209115120220910202209125120220910202210016120221001202210026120221001202210036120221001202210046120221001202210056120221001202210066120221001202210076120221001202210086020221001202210096020221001

如果需要删除指定节假日，可将节假日名称下标置为~，例如下例数据将删除2010年1月1日的节日数据：

20100101~000000000000000000000000000

由于数据已删除，后续的内容都无意义，所以可直接全部用0替代，但总位数不能少。

节假日名称下标对应ASCII码表如下：

下标	ASCII(名称)	下标	ASCII	下标	ASCII	下标	ASCII	下标	ASCII	下标	ASCII	下标	ASCII	下标	ASCII
0	0(元旦节)	10	:	20	D	30	N	40	X	50	b	60	l	70	v
1	1(春节)	11	;	21	E	31	O	41	Y	51	c	61	m	71	w
2	2(清明节)	12	<	22	F	32	P	42	Z	52	d	62	n	72	x
3	3(劳动节)	13	=	23	G	33	Q	43	[	53	e	63	o	73	y
4	4(端午节)	14	>	24	H	34	R	44	\	54	f	64	p	74	z
5	5(中秋节)	15	?	25	I	35	S	45	]	55	g	65	q	75	{
6	6(国庆节)	16	@	26	J	36	T	46	^	56	h	66	r	76	\|
7	7(国庆中秋)	17	A	27	K	37	U	47	_	57	i	67	s	77	}
8	8(抗战胜利日)	18	B	28	L	38	V	48	`	58	j	68	t	78	~(删除指定节假日)
9	9	19	C	29	M	39	W	49	a	59	k	69	u

注：红色为默认已使用的节假日。

// 将2020-01-01修改为春节，并追加2099-01-01为元旦节
HolidayUtil.fix('202001011120200101209901010120990101');
console.log(HolidayUtil.getHoliday('2020-01-01'));
console.log(HolidayUtil.getHoliday('2099-01-01'));
// 2020-01-01 春节 2020-01-01
// 2099-01-01 元旦节 2099-01-01

// 将元旦节改为元旦
String[] names = HolidayUtil.NAMES;
names[0] = '元旦';
HolidayUtil.fix(names, null);
console.log(HolidayUtil.getHoliday('2099-01-01'));
// 2099-01-01 元旦 2099-01-01

数据处理解析理解代码

看着一长串就头疼，自己写*看看

let days = "202201010120220101202201020120220101202201030120220101202201291020220201202201301020220201202201311120220201202202011120220201202202021120220201202202031120220201202202041120220201202202051120220201202202061120220201202204022020220405202204032120220405202204042120220405202204052120220405202204243020220501202204303120220501202205013120220501202205023120220501202205033120220501202205043120220501202205073020220501202206034120220603202206044120220603202206054120220603202209105120220910202209115120220910202209125120220910202210016120221001202210026120221001202210036120221001202210046120221001202210056120221001202210066120221001202210076120221001202210086020221001202210096020221001"

function splitStrBytargetWidth(str, width=18) {
  var strArr = [];
  for (let i = 0; i <str.length ; i+=width) {
    strArr.push(str.slice(i,i+width))
  }
  console.log(strArr);
}

splitStrBytargetWidth(days, 18)
/*
[
  "202201010120220101",
  "202201020120220101",
  "202201030120220101",
  "202201291020220201",
  "202201301020220201",
  "202201311120220201",
  "202202011120220201",
  "202202021120220201",
  "202202031120220201",
  "202202041120220201",
  "202202051120220201",
  "202202061120220201",
  "202204022020220405",
  "202204032120220405",
  "202204042120220405",
  "202204052120220405",
  "202204243020220501",
  "202204303120220501",
  "202205013120220501",
  "202205023120220501",
  "202205033120220501",
  "202205043120220501",
  "202205073020220501",
  "202206034120220603",
  "202206044120220603",
  "202206054120220603",
  "202209105120220910",
  "202209115120220910",
  "202209125120220910",
  "202210016120221001",
  "202210026120221001",
  "202210036120221001",
  "202210046120221001",
  "202210056120221001",
  "202210066120221001",
  "202210076120221001",
  "202210086020221001",
  "202210096020221001"
]
*/

指定日期是否放假或调休

通过以下方法获取法定假日信息：

getHoliday(year, month, day)

通过指定年、月、日(数字)的方式获取，如果当天不是节假日或调休，返回空

getHoliday(ymd)

通过指定年月日(字符串)的方式获取，ymd格式为YYYY-MM-DD，如果当天不是节假日或调休，返回空

var d = HolidayUtil.getHoliday(2020,5,2);
console.log('日期：'+d.getDay());
// 日期：2020-05-02
console.log('是否调休：'+d.isWork());
// 是否调休：false
console.log('假期名称：'+d.getName());
// 假期名称：劳动节
console.log('关联节日：'+d.getTarget());
// 关联节日：2020-05-01
 
d = HolidayUtil.getHoliday('2011-10-01');
console.log('日期：'+d.getDay());
// 日期：2011-10-01
console.log('是否调休：'+d.isWork());
// 是否调休：false
console.log('假期名称：'+d.getName());
// 假期名称：国庆节
console.log('关联节日：'+d.getTarget());
// 关联节日：2011-10-01

获取指定月份的假期列表

通过以下方法获取：

getHolidays(year, month)

通过指定年、月(数字)的方式获取
getHolidays(ymd)

通过指定年月日(字符串)的方式获取，ymd格式为YYYY-MM

var holidays = HolidayUtil.getHolidays(2020,5);
console.log(holidays);
// 2020-05-01 劳动节 2020-05-01,2020-05-02 劳动节 2020-05-01,2020-05-03 劳动节 2020-05-01,2020-05-04 劳动节 2020-05-01,2020-05-05 劳动节 2020-05-01,2020-05-09 劳动节调休 2020-05-01

holidays = HolidayUtil.getHolidays('2011-10');
console.log(holidays);
// 2011-10-01 国庆节 2011-10-01,2011-10-02 国庆节 2011-10-01,2011-10-03 国庆节 2011-10-01,2011-10-04 国庆节 2011-10-01,2011-10-05 国庆节 2011-10-01,2011-10-06 国庆节 2011-10-01,2011-10-07 国庆节 2011-10-01,2011-10-08 国庆节调休 2011-10-01,2011-10-09 国庆节调休 2011-10-01

获取指定年份的假期列表

通过以下方法获取：

getHolidays(year)

通过指定年(数字)的方式获取
getHolidays(ymd)

通过指定年月日(字符串)的方式获取，ymd格式为YYYY

var holidays = HolidayUtil.getHolidays(2020);
console.log(holidays);
// 2020-01-01 元旦节 2020-01-01,2020-01-19 春节调休 2020-01-25,2020-01-24 春节 2020-01-25,2020-01-25 春节 2020-01-25,2020-01-26 春节 2020-01-25,2020-01-27 春节 2020-01-25,2020-01-28 春节 2020-01-25,2020-01-29 春节 2020-01-25,2020-01-30 春节 2020-01-25,2020-01-31 春节 2020-01-25,2020-02-01 春节 2020-01-25,2020-02-02 春节 2020-01-25,2020-04-04 清明节 2020-04-04,2020-04-05 清明节 2020-04-04,2020-04-06 清明节 2020-04-04,2020-04-26 劳动节调休 2020-05-01,2020-05-01 劳动节 2020-05-01,2020-05-02 劳动节 2020-05-01,2020-05-03 劳动节 2020-05-01,2020-05-04 劳动节 2020-05-01,2020-05-05 劳动节 2020-05-01,2020-05-09 劳动节调休 2020-05-01,2020-06-25 端午节 2020-06-25,2020-06-26 端午节 2020-06-25,2020-06-27 端午节 2020-06-25,2020-06-28 端午节调休 2020-06-25,2020-09-27 国庆中秋调休 2020-10-01,2020-10-01 国庆中秋 2020-10-01,2020-10-02 国庆节 2020-10-01,2020-10-03 国庆节 2020-10-01,2020-10-04 国庆节 2020-10-01,2020-10-05 国庆节 2020-10-01,2020-10-06 国庆节 2020-10-01,2020-10-07 国庆节 2020-10-01,2020-10-08 国庆节 2020-10-01,2020-10-10 国庆节调休 2020-10-01

holidays = HolidayUtil.getHolidays('2011');
console.log(holidays);
// 2011-01-01 元旦节 2011-01-01,2011-01-02 元旦节 2011-01-01,2011-01-03 元旦节 2011-01-01,2011-01-30 春节调休 2011-02-03,2011-02-02 春节 2011-02-03,2011-02-03 春节 2011-02-03,2011-02-04 春节 2011-02-03,2011-02-05 春节 2011-02-03,2011-02-06 春节 2011-02-03,2011-02-07 春节 2011-02-03,2011-02-08 春节 2011-02-03,2011-02-12 春节调休 2011-02-03,2011-04-02 清明节调休 2011-04-05,2011-04-03 清明节 2011-04-05,2011-04-04 清明节 2011-04-05,2011-04-05 清明节 2011-04-05,2011-04-30 劳动节 2011-05-01,2011-05-01 劳动节 2011-05-01,2011-05-02 劳动节 2011-05-01,2011-06-04 端午节 2011-06-06,2011-06-05 端午节 2011-06-06,2011-06-06 端午节 2011-06-06,2011-09-10 中秋节 2011-09-12,2011-09-11 中秋节 2011-09-12,2011-09-12 中秋节 2011-09-12,2011-10-01 国庆节 2011-10-01,2011-10-02 国庆节 2011-10-01,2011-10-03 国庆节 2011-10-01,2011-10-04 国庆节 2011-10-01,2011-10-05 国庆节 2011-10-01,2011-10-06 国庆节 2011-10-01,2011-10-07 国庆节 2011-10-01,2011-10-08 国庆节调休 2011-10-01,2011-10-09 国庆节调休 2011-10-01,2011-12-31 元旦节调休 2012-01-01

获取节日相关的假期列表

通过以下方法获取：

getHolidaysByTarget(year, month, day)

通过指定年、月、日(数字)的方式获取
getHolidaysByTarget(ymd)

通过指定年月日(字符串)的方式获取，ymd格式为YYYY-MM-DD

var holidays = HolidayUtil.getHolidaysByTarget(2018,5,1);
console.log(holidays);
// 2018-04-28 劳动节调休 2018-05-01,2018-04-29 劳动节 2018-05-01,2018-04-30 劳动节 2018-05-01,2018-05-01 劳动节 2018-05-01

holidays = HolidayUtil.getHolidaysByTarget('2011-01-01');
console.log(holidays);
// 2011-01-01 元旦节 2011-01-01,2011-01-02 元旦节 2011-01-01,2011-01-03 元旦节 2011-01-01

RealizeInnerSelf丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
lunar.js 基本使用学习笔记

目录lunar.js 基本使用学习笔记介绍基本使用部分文档 API 转载阳历相关的方法 APISolar 阳历阳历实例化阳历对象可以使用多种字符串输出方式：获取年、月、日儒略日获取星期判断是否闰年获取节日星座阳历日期推移(可跳过节假日、*六*日)公历转阴历(农历)SolarWeek 阳历*阳历*实例化阳历对象转化为字符串获取阳历日期的年月日获取一*的起点获取当前日期是在当月第几*，返回序号从1...
复制链接

扫一扫