lunar

package module
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 22, 2026 License: MIT Imports: 18 Imported by: 0

README

lunar

Go Version CI License 零依赖

优雅、低资源消耗且高效的 Go 历法库：公历/农历互转 · 干支 · 节气 · 黄历宜忌 · 八字命理 · 佛道历 · 法定节假日。基于寿星天文历实时天文推算（非查表），运行时零第三方依赖。

本库是 lunar-go v1.4.6 镜像 的 v2 现代化重构：天文内核 bit 级保留，外壳全部按现代 Go 重建。与 v1 不兼容（迁移指南见 docs/migration-v1-to-v2.md）。

安装

go get github.com/tekintian/lunar

3 分钟上手

package main

import (
        "fmt"

        "github.com/tekintian/lunar"
)

func main() {
        // 公历 → 农历
        solar := lunar.MustSolar(2020, 1, 25)
        lunarDay := solar.Lunar()
        fmt.Println(lunarDay.String())        // 二〇二〇年正月初一
        fmt.Println(lunarDay.DayInGanZhi())   // 丁卯

        // 农历 → 公历（闰月为负数月份；可失败构造返回 error，零 panic）
        l, err := lunar.NewLunar(2020, -4, 13) // 2020 闰四月十三
        if err != nil { panic(err) }
        fmt.Println(l.Solar().String())       // 2020-06-04

        // 黄历全景（结构化，替代 v1 的字符串拼接）
        a := l.Almanac()
        fmt.Println(a.Yi, a.Ji, a.Chong)

        // 节气
        fmt.Println(l.NextJieQi().Name(), l.NextJieQi().Solar().String())

        // 八字（不可变设计：流派经选项确定，而非 v1 的 SetSect）
        ec := lunar.MustSolarTime(1981, 1, 29, 23, 37, 0).Lunar().EightChar()
        fmt.Println(ec.String())              // 庚申 己丑 丁未 壬子
        yun := ec.Yun(lunar.Female)
        fmt.Println("起运:", yun.StartSolar().String())

        // 法定节假日（O(1) 查询 + 调休判定）
        if h := lunar.HolidayOfDay(2025, 10, 1); h != nil {
                fmt.Println(h.Name, "放假:", !h.Work)
        }
}

更多示例见 example_test.go（godoc 官方格式，覆盖 14 个核心场景）。

为什么是 v2？

维度 v1.4.6 v2
API 风格 Java 化 GetXxx() ~680 个 Go 惯用（Year()/DayYi()），零 Get 前缀
错误处理 11 处 panic 零 panic（(T, error) + errors.Is；fuzz + 934 方法反射冒烟验证）
Solar→Lunar 19.4µs / 233 allocs 0.18µs / 1 alloc（年表缓存，atomic.Pointer copy-on-write）
每日宜忌 15.8µs（函数内正则重编译） 0.12µs（sync.Once 预解码索引表，0 allocs）
八字反推 1.68ms 2.7µs
假日查询 O(15KB 编码串扫描) 69ns O(1)（五层架构）
数据竞争 HolidayUtil.Fix 写竞争 -race 全绿（RWMutex + COW）
container/list 14 文件 0
等价性 — 9,364 字段对拍零差异（461 日期 × 全部领域输出）

假日数据：每年更新，主库零发版

节假日是年度政策数据。v2 采用 tzdata 模式五层架构：

Layer 4  程序化 Patch（HolidayStore.Patch，应用侧最高优先级）
Layer 3  运行时文件（LoadFile / Watch mtime 轮询热更新）
Layer 2  holidaydata 子模块（blank import，CalVer 发版）★ 年度更新主通道
Layer 1  主库内嵌基线（2001-2026，go:embed）★ 兜底

年度更新流程（目标 ≤1 小时，主库零提交）：

go run ./cmd/lunarholiday scaffold 2027   # 库预填历法节日日期（春节=正月初一等）
# 人工审核放假/调休天数 → PR
go run ./cmd/lunarholiday validate --all  # schema + 历法自洽校验（CI 同款门禁）

下游应用年度更新仅需：

import (
    "github.com/tekintian/lunar"
    _ "github.com/tekintian/lunar/holidaydata" // 2027+ 数据自动覆盖基线
)

go get -u github.com/tekintian/lunar/holidaydata  # 仅数据更新，无 API 影响

自洽校验由库自身把关：春节必覆盖正月初一、端午必含五月初五、调休必在周末……机器验证替代人肉 review（校验器在迁移过程中实际抓出了上游 v1 的 2 条历史数据错误，详见 cmd/lunarholiday/main.go 注释）。

并发语义

  • Solar / *Lunar / LunarYear / EightChar 等值对象构造后并发只读安全；
  • 全局年表缓存读侧零锁；
  • HolidayStore 并发读写安全；Watch 轮询 goroutine 走同一写锁。

值年太岁与年三煞（taisui）

六十甲子太岁星君名讳表取北京白云观元辰殿体系（中国道协依清初宫廷 如意馆六十甲子神画像重塑，与《太岁神传略》一致，现代黄历通行口径）。 四源核对（维基百科/百度百科/精明宝宫/《太岁神传略》）后，名讳存在 异读的 18 项（如丙寅/丁卯两君互调、甲戌施广一作誓广、己丑傅佑非潘佑） 以 Note 字段全量保留，不替用户裁决：

d := lunar.NewLunarYear(2025).TaiSuiDeity()  // {乙巳 吴遂 大将军}
l := lunar.MustSolar(2025, 1, 29).Lunar()    // 正月初一，立春(02-03)前
l.TaiSuiDeity()        // 吴遂大将军（初一换年，默认）
l.TaiSuiDeityByLiChun() // 李诚大将军（立春换年，择日通书主流）

d2, ok := lunar.TaiSuiDeityOfGanZhi("甲辰") // 李诚大将军；非法干支 ok=false

// 年三煞（劫煞/灾煞/岁煞三方，《协纪辨方书》口径）
lunar.NewLunarYear(2025).PositionSanShaDesc() // 东(寅卯辰)
l.PositionSanShaDesc()                        // Lunar 便捷代理

Almanac 聚合 JSON 同步补齐黄历 App 标配字段：zhiXing（值日建除）、 dayLu（日禄）、xunKongYear/Month/Day（三柱空亡）、yangGui/yinGui （阳贵阴贵）、dayNineStar（日九星）、sanSha（年三煞）、taiSui （太岁星君）、nianJing（年景歌诀十四法）、times（十二时辰吉凶表）。

月相精确时刻（moonphase）

在农历日粒度月相名（Lunar.YueXiang）之上，提供天文精确到时刻的 四相事件（与朔/节气同一寿星 VSOP87D 链路，北京时间，分钟级精度， 对 timeanddate 北京 2026 年 17 个四相锚点实测差值 ≤2 分钟）：

ev, _ := lunar.MustSolar(2025, 1, 1).NextMoonPhase()      // 之后最近一次四相
ev.Phase    // "上弦"
ev.Solar.ToYmdHms() // "2025-01-07 07:56:41"

lunar.MustSolar(2025, 6, 15).PrevMoonPhaseOf(lunar.MoonPhaseWang)
// 望 2025-06-11 15:46:35（农历五月十六）

lunar.MustSolar(2025, 1, 1).NextMoonPhaseOf(lunar.MoonPhaseShuo) // 指定相位版本

民间择吉（zeji）

黄历域之外，v2.1 提供民间择吉规则层（均可从历法数据确定性推导）：

l := lunar.FromTime(time.Now())

l.FolkTaboos()      // 当日禁忌速查：月破/岁破/四离四绝/杨公十三忌/三娘煞/红沙日/节气交接日
l.SiLiSiJue()       // 四离四绝："四离(冬至前一日)" / "四绝(立春前一日)" / ""
l.IsYuePo()         // 月破：日支冲月建（与十二值日"破"、神煞"大耗"恒等）
l.IsSuiPo()         // 岁破：日支冲年太岁支（立春换年）
l.IsYangGongJi()    // 杨公十三忌（闰月随本月序号，与佛历杨公忌同一约定）
l.IsSanNiangSha()   // 三娘煞：每月初三/初七/十三/十八/廿二/廿七
l.IsHongSha()       // 红沙日：四孟酉、四仲巳、四季丑（默认月建口径）
l.HasJiShen("不将") // 神煞包含查询（选嫁娶"不将日"）
lunar.ZhiSanHe("巳", "酉"), lunar.ZhiLiuHe("巳", "申")  // 地支三合/六合
l.DayNaYinWuXing()  // 纳音五行（"金箔金"→"金"；民间"水日/火日"据此）
lunar.XingJiaYue("卯") // 女命行嫁大利月/小利月：[1 7] [2 8]
lunar.XingJiaMonths("子") // 行嫁十二月六档全表：大利/妨媒/妨翁姑/妨父母/妨夫主/妨女身
流派变体层（兼收并蓄）

民间择吉的同一规则在不同流派、地域、典籍传承中常存在多个通行版本。 本项目不替用户裁决唯一正解，而是全量收录各派口径并逐条标记， 由使用者按自身传承选择：

l := lunar.FromTime(...) // 2025-01-29（正月初一、立春前）

// 单项变体判定（分歧规则逐派独立 API）：
l.IsSuiPoByBoundary(lunar.YearByLiChun) // 岁破·立春换年派：true（甲辰冲戌）
l.IsSuiPoByBoundary(lunar.YearByChuYi)  // 岁破·初一换年派：false（乙巳冲亥）
l.IsYangGongJiByLeapRule(lunar.LeapFollowHost) // 杨公忌·闰月随本月派
l.IsYangGongJiByLeapRule(lunar.LeapNoJi)        // 杨公忌·闰月不忌派
l.IsHongShaByBase(lunar.HongShaByYueJian) // 红沙·月建口径（通书正统）
l.IsHongShaByBase(lunar.HongShaByNongLi)  // 红沙·农历月口径（民俗）

// 带标记聚合输出（分歧日各派独立成条，两派同判标记「通行」）：
for _, it := range l.FolkTaboosTagged() {
        // ZejiItem{ Rule, Detail, Sect, Source, Note }
        // Sect 如「通书·立春换年」「民俗·初一换年」「通书·月建口径」
}
l.FolkTaboosGrouped() // map[流派][]ZejiItem，直接适配分块展示

以 2025 年实测为例：红沙日两口径全年分歧 19 天；岁破双年界在正月初一 与立春之间（01-29～02-02）两派判定相反；闰六月初三两派杨公忌判定相异 ——分歧均为真实存在的传承差异，库内全部收录并标记。

禁忌速查已并入 Almanac JSON（folkTaboos 默认口径 + folkTaboosTagged 全流派标记版）。传统择吉为多维综合（黄黑道 + 建除 + 神煞 + 事项宜忌）， 本层只提供原子判定与流派标记，不代作决断。

二十四山与太阳太阴到山（天星择日）

修造、安葬、修方择日常用的「天星到山」体系，定局表经造福堂日馆、 福山堂等多家通书来源交叉验证一致（二十四山含庚山，壬子癸、丑艮寅、 甲卯乙、辰巽巳、丙午丁、未坤申、庚酉辛、戌乾亥）：

l := lunar.FromTime(time.Now())

// 二十四山基础
lunar.ParseShan("壬山")             // ("壬", true)，兼容「壬」「壬山」两种输入
lunar.ShanOpposite("壬")            // 到向（对冲山）："丙"（壬山丙向）
lunar.ShanSanHe("壬")               // 三合照两山："乙","坤"（相距120°）
lunar.ShanJu("壬")                  // 双山五行三合局："水局（坤壬乙·申子辰）"

// 太阳/太阴到山（节气区间驻留语义：如「立春后雨水前太阳到壬山」）
l.TaiYangShan()                     // 当日节气区间太阳所在山
l.TaiYinShan()                      // 当日节气区间太阴所在山
l.TaiYangDaoShan("壬")              // 太阳判定：到山(又次之)/到向(上吉)/三合照(次吉)
l.TaiYinDaoShan("艮")               // 太阴判定：到山(吉)/到向(凶·有争议)/三合照
l.ShanInfo("壬")                 // 坐山综合信息（太阳+太阴+到向+三合一次取齐）

定局规则：太阳立春起壬山逐节气逆推（冬至到丑、夏至到未、立夏到庚）； 太阴立春起艮山逐节气顺推（冬至到子、夏至到午）。吉级与用法细则按 福山堂系统：太阳到向上吉、三合照次吉、到山又次之（另有「平民用太阳 到山反招不利，唯帝王修造为宜」一说，Note 字段标注由使用者按师承取舍）； 太阳宜白天用事、太阴宜夜晚用事；太阴到向一派认为极凶一派照常取用 （同样以 Note 标注分歧）。本表依星体平均行度（速查定局）， 《协纪辨方书》卷三十四另有精确到时刻的「太阳到方时刻表」，求精确行度 请另查天星历。Almanac JSON 已含 taiYangShan/taiYinShan 字段。

分事择日评估器（zeri）

面向具体用事的一次性多维度评估，典籍层与民俗层结论分层呈现、 逐条标记来源（ZejiItem.Sect：典籍·铺注 / 典籍·黄黑道 / 典籍·建除 / 民俗·禁忌 / 天星·到山 / 民俗·正冲），可直接按 Sect 分块渲染：

l := lunar.FromTime(time.Now())

// 典籍铺注模式（默认）：铺注宜忌 + 黄黑道 + 建除 + 民俗禁忌（全流派标记）
// + 太阳太阴到山（传入 Shan）+ 正冲校验（传入 UserZhi）
r := l.ZeRi(lunar.ZeRiOptions{Event: "动土", Shan: "申", UserZhi: "午"})
r.Verdict   // 宜 / 忌 / 平 / 诸事不宜（仲裁规则见 doc 注释，全部依据在 Reasons）
r.YiHit     // 命中的宜键（如 ["动土","破土"]）
r.Reasons   // 判定依据逐条（[]ZejiItem，分块+标记）

// 现代加权评分参考模式（非典籍方法，仅适合多候选日排序）
sc := l.ZeRiScore(lunar.ZeRiOptions{Event: "动土", Shan: "申", UserZhi: "午"})
sc.Score    // 0~100；sc.Level 上吉/吉/可用/平/慎用；sc.Items 逐项加减分

事件支持口语别名（婚嫁/结婚/搬家/乔迁/动土/开工/开业/开市/装修/ 安葬/出行/提车/订婚……未登记名称自动按铺注键匹配）。仲裁策略： 「诸事不宜」铺注最高优先；月破/岁破/四离四绝（典籍级凶神）与铺注忌 判「忌」；喜庆类事件触三娘煞/红沙、出行起造类触红沙亦升「忌」； 杨公忌/节气交接日仅提示不改变结论；正冲用事人年支时「宜」降「平」。 命理喜用神校验超出历法库边界（八字格局/旺衰/用神另有专门体系）， 请用 EightChar 层由上层应用按师承实现。

干支关系（ganzhi_rel）

与地支三合六合（ZhiSanHe/ZhiLiuHe）配套的干支基础关系判定：

lunar.GanWuHe("甲", "己")    // ("土", true) —— 五合：甲己土、乙庚金、丙辛水、丁壬木、戊癸火
lunar.ZhiLiuHai("子", "未")  // true —— 六害：子未、丑午、寅巳、卯辰、申亥、酉戌
lunar.ZhiSanXing("巳", "寅") // "无恩之刑" —— 三刑：无恩(寅巳申)/恃势(丑戌未)/无礼(子卯)/自刑(辰午酉亥)
梅雨（meiyu，多流派）

入梅/出梅按「节气后第 1 个某干支日」推算（含节气当日），作用域为 所在公历年。典籍分歧的口径全量收录（《岁时广记》：「说不一， 要之芒种逢丙之说近是」）：

l := lunar.FromTime(time.Now())
l.MeiYu()        // 通行口径（《神枢经》/现行历书）：芒种后丙入、小暑后未出
                 // 2025 → In=2025-06-06(丙午) Out=2025-07-13(癸未)
l.IsMeiYuDay()   // 当日是否在梅雨期（入梅日 ≤ 当日 ≤ 出梅日，两端含）
l.MeiYuByBase(lunar.MeiYuJiangNan) // 江南壬日系（《江南志书》/《碎金》吴俗）
l.MeiYuByBase(lunar.MeiYuMinSu)    // 闽俗系（《月日纪古》）
// MeiYu{In, Out *Date, Base, Note} —— Note 说明口径出处与异说存疑处
专业时辰层（zeji_time，通书级择时）

黄黑道之外的择日馆时辰神煞（《协纪辨方书》卷七）：

lt := lunar.NewLunarTimeFromLunar(lunar.MustNewLunarDateTime(2025, 1, 27, 12, 0, 0))
lt.IsWuBuYu()  // 五不遇时：时干克日干（甲日庚午时 true；谋事反复百事不宜）
lt.IsRiLu()    // 日禄归时：时支为日干禄位（甲禄寅、乙禄卯…癸禄子）

l := lunar.MustSolar(2025, 2, 24).Lunar() // 甲子日（雨水后亥将）
l.YueJiang()        // "亥" —— 月将（太阳过宫，中气换将）
l.GuiDengTianMen()  // [{阳贵 3 卯} {阴贵 9 酉}] —— 贵登天门时：月将加时、
                    // 贵人临乾亥，「乃时之最吉者，能解诸凶」
l.GuiDengTianMenByBase(lunar.GuiShenZiPing) // 子平「甲戊庚牛羊」贵神口径变体
lunar.NewLunarTimeFromLunar(lunar.MustNewLunarDateTime(2025, 2, 24, 6, 0, 0)).IsGuiDengTianMen()
                    // 时辰级判定：卯时 true

支持域

  • 公历 公元前 4713 ~ 公元 9999 年（儒略日换算限制）；1582-10-05~14 返回 ErrJulianGap；
  • 节气交接按东八区（UTC+8）。

命令行工具

go run ./cmd/lunarholiday scaffold 2027  # 生成新年份假日模板
go run ./cmd/lunarholiday validate --all # 校验全部数据
go run ./cmd/lunarholiday coverage       # 覆盖报告

文档

感谢

License

MIT

定制开发联系

Documentation

Overview

Package lunar 是一个优雅、低资源消耗且高效的 Go 历法库： 公历/农历互转、干支、节气、黄历宜忌、八字命理、佛道历、法定节假日， 基于寿星天文历实时推算（非查表），无任何运行时第三方依赖。

本包是 lunar-go v1.4.6 的 v2 重构（破坏性重设计），内核（天文算法与 常量表）bit 级保留，外壳（API/并发/性能/工程化）按现代 Go 重建。

快速开始 

solar := lunar.MustSolar(2020, 1, 25)   // 或 NewSolar 返回 (Solar, error)
lunarDay := solar.Lunar()
fmt.Println(lunarDay.String())          // 二〇二〇年正月初一
fmt.Println(lunarDay.DayYi())           // [祭祀 沐浴 ...]

核心类型

  • Solar：公历（值类型，48B 可比较，构造零堆分配）
  • *Lunar：农历（含四柱干支/节气/黄历派生态）
  • LunarYear / LunarMonth / LunarTime：年/月/时辰视图
  • EightChar：八字（不可变设计，WithSect 选项替代 v1 SetSect）
  • HolidayStore：法定节假日（五层架构，O(1) 查询）
  • Almanac：黄历一日全景（结构化，替代字符串解析）

错误模型（零 panic 红线）

可失败构造一律返回 (T, error)，错误哨兵可 errors.Is 分支： 

l, err := lunar.NewLunar(2020, -4, 13) // 闰四月十三
if errors.Is(err, lunar.ErrInvalidDate) { ... }

编译期常量输入可用 Must* 系列便捷构造（仅建议字面量使用）。 全部导出方法对任意输入零 panic（fuzz + 全量导出方法反射冒烟验证）。

并发语义

  • Solar / Lunar / LunarYear / LunarMonth / EightChar 等值对象构造后 并发只读安全；
  • 全局年表缓存读侧零锁（atomic.Pointer copy-on-write）；
  • HolidayStore 并发读写安全（RWMutex），Watch 轮询 goroutine 亦然；
  • 唯一非并发安全点：astro.SetDeltaT 与 HolidayStore.SetMaxEntries 仅允许初始化阶段调用。

性能（对照 v1.4.6，详见 benchmark_test.go） 

Solar→Lunar 转换:   19.4µs → 0.18µs   （年表缓存）
Lunar.ToFullString: 44µs   → 2.6µs    （strings.Builder）
每日宜忌:           15.8µs → 0.12µs   （正则消除，预解码索引）
八字反推:           1.68ms → 2.7µs
假日查询:           O(15KB 串扫描) → 69ns O(1)

假日数据五层架构 

Layer 1  主库内嵌基线（2001-2026，go:embed）——兜底
Layer 2  holidaydata 子模块（blank import，CalVer 发版）——年度更新主通道
Layer 3  运行时文件（LoadFile / Watch mtime 轮询）——运维侧
Layer 4  程序化 Patch（HolidayStore.Patch）——应用侧

年度更新流程：`go run ./cmd/lunarholiday scaffold 2027` 生成模板 （历法节日日期由库预填）→ 人审放假调休 → validate 校验 → PR。 详见 cmd/lunarholiday 与 .github/workflows/holiday-data.yml。

民间择吉（zeji）

黄历域（宜忌/神煞/黄黑道/建除）之外，另设民间择吉规则层： FolkTaboos 禁忌速查（月破/岁破/四离四绝/杨公十三忌/三娘煞/红沙日/ 节气交接日）、HasJiShen 神煞查询（如嫁娶"不将日"）、ZhiSanHe/ZhiLiuHe 地支关系、DayNaYinWuXing 纳音五行、XingJiaYue/XingJiaMonths 女命行嫁月。

流派变体层（zeji_variant.go）：同一规则在不同流派、地域传承中存在 多个通行版本时，全量收录各派口径并逐条标记，不替用户裁决—— IsSuiPoByBoundary 岁破双年界（立春/初一换年）、IsYangGongJiByLeapRule 杨公忌闰月两派（随本月/闰月不忌）、IsHongShaByBase 红沙日双口径 （节气月建/农历月序）、FolkTaboosTagged/FolkTaboosGrouped 带流派 标记的聚合输出（ZejiItem.Rule/Detail/Sect/Source/Note）。 无分歧规则标记为「通行」；分歧规则各派独立判定、分别列出。

二十四山与到山层（zeji_shan.go）：天星择日的二十四山体系 （ParseShan 解析「壬/壬山」双格式、ShanOpposite 到向、ShanSanHe 三合照、ShanJu 双山五行三合局）与太阳/太阴到山定局（TaiYangShan/ TaiYinShan 当日节气区间驻山、TaiYangDaoShan/TaiYinDaoShan 到山/ 到向/三合照判定、ShanInfo 综合信息）。太阳立春起壬山逆推、 太阴立春起艮山顺推（造福堂日馆/福山堂定局表交叉验证）；到山为 节气区间驻留语义；吉级与用法分歧（平民用太阳到山、太阴到向凶） 以 DaoShanResult.Note 逐条标注。

分事择日评估器（zeji_zeri.go）：ZeRi 按用事（口语别名或铺注键） 做多维度评估，判定依据逐条分块标记（典籍·铺注/黄黑道/建除、 民俗·禁忌、天星·到山、民俗·正冲），Verdict 仲裁规则全部透明 （诸事不宜 > 铺注忌/典籍级凶神/事件相关民俗凶 > 铺注宜 > 平）。 ZeRiScore 为现代加权评分参考模式（非典籍方法，仅适合多候选日 排序）。命理喜用神校验超出历法库边界，请用 EightChar 层实现。

干支关系（ganzhi_rel.go）：GanWuHe 天干五合、ZhiLiuHai 地支六害、 ZhiSanXing 地支三刑（无恩/恃势/无礼/自刑），与 ZhiSanHe/ZhiLiuHe 配套的基础关系判定。

梅雨（meiyu.go）：入梅/出梅按「节气后第 1 个某干支日」推算， MeiYu 通行口径（芒种后丙入/小暑后未出）+ MeiYuJiangNan 江南壬日系 + MeiYuMinSu 闽俗系三流派全量收录，IsMeiYuDay 当日判定。

专业时辰层（zeji_time.go）：五不遇时（IsWuBuYu 时干克日干）、 日禄归时（IsRiLu 时支为日干禄位）、月将（YueJiang 中气换将）、 贵登天门时（GuiDengTianMen，协纪定例/子平变体双口径）—— 《协纪辨方书》卷七时辰神煞。

值年太岁与年三煞（taisui.go）：TaiSuiDeity 六十甲子太岁星君名讳 （白云观元辰殿体系，异读 18 项 Note 保留，初一/立春双换年口径）， PositionSanSha 年三煞方位（劫煞/灾煞/岁煞，《协纪辨方书》）。 Almanac 聚合 JSON 含黄历 App 标配字段（值日/日禄/空亡/阴阳贵/ 日九星/三煞/太岁/年景歌诀/十二时辰吉凶表）。

月相精确时刻（moonphase.go）：NextMoonPhase/PrevMoonPhase 四相事件 （朔/上弦/望/下弦）天文精确时刻（北京时间），与朔/节气同一寿星 VSOP87D 链路；日粒度月相名见 Lunar.YueXiang。 Lunar.Times 返回当日十二时辰（v1 getTimes 对位）。

精度与支持域

  • 历法推算基于寿星天文历（VSOP87D 简化黄经 + ΔT 拟合）， 公历支持域约公元前 4713 年 ~ 公元 9999 年；
  • 1582-10-05 ~ 14 为儒略历改革空档，构造返回 ErrJulianGap；
  • 节气交接按东八区（UTC+8）。

Index

Examples

Constants

View Source 
const (
	MoonPhaseShuo      = "朔"  // 新月，月日视黄经差 0°
	MoonPhaseShangXian = "上弦" // 黄经差 90°
	MoonPhaseWang      = "望"  // 满月，黄经差 180°
	MoonPhaseXiaXian   = "下弦" // 黄经差 270°
)

月相四相（月日视黄经差）。日粒度的通俗月相名（新月/渐盈凸月等）见 Lunar.YueXiang， 本层为天文精确时刻（北京时间，东八区），数据链路与朔（初一）/节气同源。

View Source 
const (
	ZeRiYi         = "宜"
	ZeRiJi         = "忌"
	ZeRiPing       = "平"
	ZeRiZhuShiBuYi = "诸事不宜"
)

zeRiVerdicts Verdict 取值常量（字符串便于直接渲染）。

Variables

View Source 
var ErrInvalidDate = errors.New("lunar: invalid date")

ErrInvalidDate 表示公历或农历日期值域错误。 携带上下文的典型形态：fmt.Errorf("month %d: %w", m, ErrInvalidDate)

View Source 
var ErrInvalidGanZhi = errors.New("lunar: invalid gan-zhi (must be one of the 60 jia-zi)")

ErrInvalidGanZhi 表示干支字符串不是有效的六十甲子。

View Source 
var ErrInvalidYear = errors.New("lunar: year out of supported range")

ErrInvalidYear 表示农历年份超出支持范围（约公元前 721 年 ~ 公元 9999 年）。

View Source 
var ErrJulianGap = errors.New("lunar: date falls in the Julian calendar gap (1582-10-05 .. 1582-10-14)")

ErrJulianGap 表示日期落在 1582-10-05 ~ 1582-10-14（儒略历改格里高利历的空档）。

Functions

func GanWuHe 

func GanWuHe(a, b string) (string, bool)

GanWuHe 判断两天干是否天干五合（甲己合土、乙庚合金、丙辛合水、 丁壬合木、戊癸合火）。相合返回（所化五行, true），否则（"", false）。

五合即「一阴一阳之谓道」：相隔五位的天干两两相合（甲己、乙庚、丙辛、 丁壬、戊癸），合而化土/金/水/木/火，出《素问·五运行大论》「丹天之气 经于牛女戊分……黅天之气经于心尾己分」之化运说，命理合婚与择日 「天干合」吉象即据此。参数顺序无关（甲己与己甲同判）；同干不合； 任一参数非法返回（"", false）。

func GuiShenNote 

func GuiShenNote(base GuiShenBase) string

GuiShenNote 返回贵神口径的典籍出处备注（供逐条标记渲染）。 未知口径返回空串。

func HolidayCoverage 

func HolidayCoverage() (from, to int)

HolidayCoverage 返回全局默认存储的覆盖区间。

func MarshalHolidayFile 

func MarshalHolidayFile(year int, source string, entries []Holiday) ([]byte, error)

MarshalHolidayFile 序列化假日数据为 schema v1 JSON（缩进 2 空格，供 scaffold/人审）。

func ParseShan 

func ParseShan(s string) (string, bool)

ParseShan 解析二十四山输入，兼容「壬」「壬山」两种格式。 返回规范山名（如「壬」）；非法输入返回空串与 false。

func RegisterHolidayFiles 

func RegisterHolidayFiles(fsys fs.FS) error

RegisterHolidayFiles 注册一个假日数据文件系统并合并进全局默认存储 （holidaydata 子模块 blank import 时调用；后注册者按日期覆盖）。 返回错误供注册方暂存诊断（holidaydata.Status() 模式），不 panic。

func SetDefaultHolidayStore 

func SetDefaultHolidayStore(s *HolidayStore)

SetDefaultHolidayStore 替换全局默认存储。

func ShanJu 

func ShanJu(shan string) string

ShanJu 返回山所属的双山五行三合局名 （如「壬」→「水局（坤壬乙·申子辰）」）。非法输入返回空串。

func ShanNames 

func ShanNames() []string

ShanNames 返回二十四山名序列（罗盘顺时针序，自子山起）。

func ShanOpposite 

func ShanOpposite(shan string) string

ShanOpposite 返回山的对冲山（到向，相距180°）：壬↔丙、艮↔坤、子↔午。 非法输入返回空串。

Example

二十四山：坐山解析、到向与三合照（双山五行三合局）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	shan, _ := lunar.ParseShan("壬山")
	a, b := lunar.ShanSanHe(shan)

	fmt.Println(shan, lunar.ShanOpposite(shan), a, b, lunar.ShanJu(shan))
}

Output:
壬 丙 乙 坤 水局（坤壬乙·申子辰）

func ShanSanHe 

func ShanSanHe(shan string) (a, b string)

ShanSanHe 返回坐山的三合照两山（相距120°，如壬山→坤、乙）。 三合照与坐山同属一个三合局（双山五行），吉应次之。非法输入返回零值。

func XingJiaYue 

func XingJiaYue(nvZhi string) (daLi, xiaoLi []int, ok bool)

XingJiaYue 按女命年支返回行嫁大利月与小利月（农历月序 1~12， 如 [1 7] 表示正月与七月皆大利）。闰月随本月序号。 地支非法时 ok 为 false。 

大利月：宜嫁娶之月；小利月（次吉）：妨媒人，无媒可成婚。
Example

民间择吉：女命行嫁大小利月（口诀「正七迎鸡兔」——卯酉女正月、七月大利）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	daLi, xiaoLi, _ := lunar.XingJiaYue("卯")

	fmt.Println(daLi, xiaoLi)
}

Output:
[1 7] [2 8]

func ZhiLiuHai 

func ZhiLiuHai(a, b string) bool

ZhiLiuHai 判断两地支是否六害（子未、丑午、寅巳、卯辰、申亥、酉戌， 双向）。六害者「六合被冲则成害」：如子丑合而午冲子，故丑午相害， 出《五行大义》引《神白经》「害者，妨也，不合之义」；命理以六害主 亲人不利、彼此妨害，与六冲、三刑并论。同支或非法输入返回 false。

func ZhiLiuHe 

func ZhiLiuHe(a, b string) bool

ZhiLiuHe 判断两地支是否六合（子丑/寅亥/卯戌/辰酉/巳申/午未）。 非法输入返回 false。

func ZhiSanHe 

func ZhiSanHe(a, b string) bool

ZhiSanHe 判断两地支是否构成三合（同局且不同支：申子辰/寅午戌/巳酉丑/亥卯未）。 相同地支或非法输入返回 false。

func ZhiSanXing 

func ZhiSanXing(a, b string) string

ZhiSanXing 判断两地支是否相刑，返回刑名，不相刑返回空串： 

无恩之刑：寅刑巳、巳刑申、申刑寅（《阴符经》「恩生于害」之义；
          组内任意两支相见即为刑，寅巳、巳申、寅申皆同判）
恃势之刑：丑刑戌、戌刑未、未刑丑（组内任意两支相见即为刑）
无礼之刑：子刑卯、卯刑子（子卯相刑，双向）
自刑：辰辰、午午、酉酉、亥亥（仅同支相遇）

三刑名义出通行命书（《三命通会·论三刑》承《阴符经》《汉书》之说）： 「寅巳申无恩者，以害报恩；丑戌未恃势者，以势相刑；子卯无礼者， 以无礼而刑；辰午酉亥自刑者，自寻烦恼」。本函数按典籍组内两支相见 即为刑的通行实务口径（合婚、择日两支互见即论刑）；同支仅自刑四支 成立，其余同支不相刑；非法输入返回空串。

Types

type Almanac 

type Almanac struct {
	Lunar            *Lunar        `json:"lunar"`
	Solar            Solar         `json:"solar"`
	JieQi            string        `json:"jieQi"`            // 当日节气（无则空）
	Yi               []string      `json:"yi"`               // 宜
	Ji               []string      `json:"ji"`               // 忌
	JiShen           []string      `json:"jiShen"`           // 吉神
	XiongSha         []string      `json:"xiongSha"`         // 凶煞
	Chong            string        `json:"chong"`            // 冲（如 "(壬子)鼠"）
	Sha              string        `json:"sha"`              // 煞方位
	Xiu              string        `json:"xiu"`              // 星宿
	Zheng            string        `json:"zheng"`            // 七政
	Gong             string        `json:"gong"`             // 宫位
	Shou             string        `json:"shou"`             // 神兽
	Animal           string        `json:"animal"`           // 星宿动物
	TianShen         string        `json:"tianShen"`         // 天神
	TaiShen          string        `json:"taiShen"`          // 胎神
	PengZuGan        string        `json:"pengZuGan"`        // 彭祖百忌（干）
	PengZuZhi        string        `json:"pengZuZhi"`        // 彭祖百忌（支）
	PositionXi       string        `json:"positionXi"`       // 喜神方位
	PositionFu       string        `json:"positionFu"`       // 福神方位
	PositionCai      string        `json:"positionCai"`      // 财神方位
	DayNaYin         string        `json:"dayNaYin"`         // 日纳音
	ShuJiu           string        `json:"shuJiu,omitempty"` // 数九（非数九天为空）
	Fu               string        `json:"fu,omitempty"`     // 三伏（非三伏天为空）
	Hou              string        `json:"hou"`              // 候
	WuHou            string        `json:"wuHou"`            // 物候
	LiuYao           string        `json:"liuYao"`           // 六曜
	YueXiang         string        `json:"yueXiang"`         // 月相
	ZhiXing          string        `json:"zhiXing"`          // 值日建除十二神（建/除/…/闭）
	DayLu            string        `json:"dayLu"`            // 日禄（如 "酉命互禄"）
	XunKongYear      string        `json:"xunKongYear"`      // 年柱空亡（如 "寅卯"）
	XunKongMonth     string        `json:"xunKongMonth"`     // 月柱空亡
	XunKongDay       string        `json:"xunKongDay"`       // 日柱空亡
	YangGui          string        `json:"yangGui"`          // 日阳贵神方位（如 "艮"，与喜/福/财方位同为单字口径）
	YinGui           string        `json:"yinGui"`           // 日阴贵神方位
	DayNineStar      string        `json:"dayNineStar"`      // 日九星（简明「数+色+五行」三字口径，如 "五黄土"）
	SanSha           string        `json:"sanSha"`           // 年三煞方位说明（如 "东(寅卯辰)"）
	TaiSui           TaiSuiDeity   `json:"taiSui"`           // 值年太岁星君（所在农历年，正月初一换年）
	NianJing         NianJing      `json:"nianJing"`         // 年景歌诀（所在农历年）
	Times            []AlmanacTime `json:"times"`            // 当日时辰吉凶表（子时～亥时 12 项）
	Festivals        []string      `json:"festivals"`        // 节日
	OtherFestivals   []string      `json:"otherFestivals"`
	FolkTaboos       []string      `json:"folkTaboos,omitempty"`       // 民俗禁忌速查（月破/岁破/四离四绝/杨公忌/三娘煞/红沙日/节气日）
	FolkTaboosTagged []ZejiItem    `json:"folkTaboosTagged,omitempty"` // 全流派逐条标记版（含分歧口径与典籍出处）
	TaiYangShan      string        `json:"taiYangShan,omitempty"`      // 当日节气区间太阳所在山（二十四山，修造坐山适配）
	TaiYinShan       string        `json:"taiYinShan,omitempty"`       // 当日节气区间太阴所在山
	Holiday          *Holiday      `json:"holiday,omitempty"`          // 法定假日（无则省略）
	SalaryRate       int           `json:"salaryRate"`                 // 工资倍率 1/2/3
}

Almanac 为黄历一日全景（计划 T1.0：替代 ToFullString 的猜测式解析， 全量信息一次取齐，API 服务刚需）。 除传统黄历域外，亦聚合黄历 App 标配字段（Task 16-b）：值日建除、日禄、 年月日三柱空亡、阳贵/阴贵方位、日九星、年三煞、值年太岁名讳、年景歌诀 与当日十二时辰吉凶表。

并发语义：值语义快照，构造后只读。

type AlmanacTime 

type AlmanacTime struct {
	Zhi          string `json:"zhi"`          // 时支（"子"…"亥"）
	GanZhi       string `json:"ganZhi"`       // 时柱干支（如 "戊子"）
	TianShen     string `json:"tianShen"`     // 时辰天神（黄黑道神，如 "天刑"）
	TianShenType string `json:"tianShenType"` // 天神类型（"黄道"/"黑道"）
	TianShenLuck string `json:"tianShenLuck"` // 天神吉凶（"吉"/"凶"）
	Chong        string `json:"chong"`        // 时冲（如 "(壬午)马"）
	Sha          string `json:"sha"`          // 时煞方位
}

AlmanacTime 当日时辰吉凶表条目（Lunar.Times 子时～亥时十二项之一）。

type DaYun 

type DaYun struct {
	// contains filtered or unexported fields
}

DaYun 表示一轮大运。

func (*DaYun) EndAge 

func (dy *DaYun) EndAge() int

EndAge 返回结束年龄。

func (*DaYun) EndYear 

func (dy *DaYun) EndYear() int

EndYear 返回结束年。

func (*DaYun) GanZhi 

func (dy *DaYun) GanZhi() string

GanZhi 返回大运干支（首运为空）。

func (*DaYun) Index 

func (dy *DaYun) Index() int

Index 返回序数。

func (*DaYun) LiuNian 

func (dy *DaYun) LiuNian() []LiuNian

LiuNian 返回 10 轮流年。

func (*DaYun) LiuNianBy 

func (dy *DaYun) LiuNianBy(n int) []LiuNian

LiuNianBy 返回 n 轮流年。

func (*DaYun) Lunar 

func (dy *DaYun) Lunar() *Lunar

Lunar 返回所属农历。

func (*DaYun) StartAge 

func (dy *DaYun) StartAge() int

StartAge 返回开始年龄。

func (*DaYun) StartYear 

func (dy *DaYun) StartYear() int

StartYear 返回开始年。

func (*DaYun) XiaoYun 

func (dy *DaYun) XiaoYun() []XiaoYun

XiaoYun 返回 10 轮小运。

func (*DaYun) XiaoYunBy 

func (dy *DaYun) XiaoYunBy(n int) []XiaoYun

XiaoYunBy 返回 n 轮小运。

func (*DaYun) Xun 

func (dy *DaYun) Xun() string

Xun 返回所在旬。

func (*DaYun) XunKong 

func (dy *DaYun) XunKong() string

XunKong 返回旬空（空亡）。

type DaoShanRelation 

type DaoShanRelation string

DaoShanRelation 到山判定关系。 

const (
	// DaoShanNone 当日无到山关系。
	DaoShanNone DaoShanRelation = ""
	// DaoShanArrive 到山：天体驻坐山。
	DaoShanArrive DaoShanRelation = "到山"
	// DaoShanOpposite 到向：天体到坐山之对冲方（朝向方位）。
	DaoShanOpposite DaoShanRelation = "到向"
	// DaoShanSanHe 三合照：天体到坐山之三合方（相距120°）。
	DaoShanSanHe DaoShanRelation = "三合照"
)

type DaoShanResult 

type DaoShanResult struct {
	Shan     string          `json:"shan"`             // 坐山
	Body     string          `json:"body"`             // 天体（太阳/太阴）
	Relation DaoShanRelation `json:"relation"`         // 到山/到向/三合照/空
	Grade    string          `json:"grade,omitempty"`  // 吉级（上吉/次吉/又次之/吉…）
	JieQi    string          `json:"jieQi"`            // 当日所处节气
	Hits     []string        `json:"hits,omitempty"`   // 命中的山（三合照时为具体到山之山）
	Detail   string          `json:"detail,omitempty"` // 判定说明
	Source   string          `json:"source"`           // 典籍/通书出处
	Note     string          `json:"note,omitempty"`   // 流派差异与用法备注
}

DaoShanResult 太阳/太阴到山判定结果。

type Date 

type Date struct {
	Year  int
	Month int
	Day   int
}

Date 表示纯日期（不含时间），用于假日等按日语义的领域。 值类型：可比较、可拷贝、零堆分配。

func MustDate 

func MustDate(year, month, day int) Date

MustDate 构造 Date，非法输入 panic。仅建议字面量常量使用。

func NewDate 

func NewDate(year, month, day int) (Date, error)

NewDate 校验并构造 Date；值域错误返回包装 ErrInvalidDate 的错误， 1582-10-05 ~ 14 返回包装 ErrJulianGap 的错误。

func ParseDate 

func ParseDate(s string) (Date, error)

ParseDate 解析 "2006-01-02" 形态字符串。

func (Date) After 

func (d Date) After(other Date) bool

After 报告 d 是否晚于 other。

func (Date) Before 

func (d Date) Before(other Date) bool

Before 报告 d 是否早于 other（仅比较年月日）。

func (Date) MarshalJSON 

func (d Date) MarshalJSON() ([]byte, error)

MarshalJSON 实现 Date 的 "2006-01-02" 输出。

func (Date) String 

func (d Date) String() string

String 返回 "2006-01-02" 形态。

func (Date) Time 

func (d Date) Time() time.Time

Time 返回东八区（Asia/Shanghai）零点的 time.Time。

func (Date) Week 

func (d Date) Week() int

Week 返回星期几（0=日 …… 6=六）。

type EightChar 

type EightChar struct {
	// contains filtered or unexported fields
}

EightChar 表示八字（年/月/日/时四柱及其派生态）。 构造后只读，并发安全。

Example

八字：不可变设计 + 流派选项。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	lunarDay := lunar.MustSolarTime(1981, 1, 29, 23, 37, 0).Lunar()
	ec := lunarDay.EightChar() // 默认民间流派（晚子时日柱算当天）

	fmt.Println(ec.String())
	// 换流派：重新构造（不可变），而非 v1 的 SetSect 可变状态
	ancient := lunar.NewEightChar(lunarDay, lunar.WithSect(lunar.SectAncient))
	fmt.Println(ancient.Day())
}

Output:
庚申 己丑 丁未 壬子
戊申

func NewEightChar 

func NewEightChar(l *Lunar, opts ...EightCharOption) *EightChar

NewEightChar 构造八字。

func (*EightChar) Day 

func (ec *EightChar) Day() string

Day 返回日柱干支（按流派）。

func (*EightChar) DayDiShi 

func (ec *EightChar) DayDiShi() string

DayDiShi 返回日柱十二长生。

func (*EightChar) DayGan 

func (ec *EightChar) DayGan() string

DayGan 返回日干（按流派）。

func (*EightChar) DayGanIndex 

func (ec *EightChar) DayGanIndex() int

DayGanIndex 返回日干序（按流派）。

func (*EightChar) DayHideGan 

func (ec *EightChar) DayHideGan() []string

DayHideGan 返回日支藏干。

func (*EightChar) DayNaYin 

func (ec *EightChar) DayNaYin() string

DayNaYin 返回日柱纳音。

func (*EightChar) DayShiShenGan 

func (ec *EightChar) DayShiShenGan() string

DayShiShenGan 返回日干十神（日主）。

func (*EightChar) DayShiShenZhi 

func (ec *EightChar) DayShiShenZhi() []string

DayShiShenZhi 返回日支十神（藏干列表）。

func (*EightChar) DayWuXing 

func (ec *EightChar) DayWuXing() string

DayWuXing 返回日柱五行。

func (*EightChar) DayXun 

func (ec *EightChar) DayXun() string

DayXun 返回日柱所在旬（按流派）。

func (*EightChar) DayXunKong 

func (ec *EightChar) DayXunKong() string

DayXunKong 返回日柱空亡（按流派）。

func (*EightChar) DayZhi 

func (ec *EightChar) DayZhi() string

DayZhi 返回日支（按流派）。

func (*EightChar) DayZhiIndex 

func (ec *EightChar) DayZhiIndex() int

DayZhiIndex 返回日支序（按流派）。

func (*EightChar) Lunar 

func (ec *EightChar) Lunar() *Lunar

Lunar 返回所属农历。

func (*EightChar) MingGong 

func (ec *EightChar) MingGong() string

MingGong 返回命宫。

func (*EightChar) MingGongNaYin 

func (ec *EightChar) MingGongNaYin() string

MingGongNaYin 返回命宫纳音。

func (*EightChar) Month 

func (ec *EightChar) Month() string

Month 返回月柱干支。

func (*EightChar) MonthDiShi 

func (ec *EightChar) MonthDiShi() string

MonthDiShi 返回月柱十二长生。

func (*EightChar) MonthGan 

func (ec *EightChar) MonthGan() string

MonthGan 返回月干。

func (*EightChar) MonthHideGan 

func (ec *EightChar) MonthHideGan() []string

MonthHideGan 返回月支藏干。

func (*EightChar) MonthNaYin 

func (ec *EightChar) MonthNaYin() string

MonthNaYin 返回月柱纳音。

func (*EightChar) MonthShiShenGan 

func (ec *EightChar) MonthShiShenGan() string

MonthShiShenGan 返回月干十神。

func (*EightChar) MonthShiShenZhi 

func (ec *EightChar) MonthShiShenZhi() []string

MonthShiShenZhi 返回月支十神（藏干列表）。

func (*EightChar) MonthWuXing 

func (ec *EightChar) MonthWuXing() string

MonthWuXing 返回月柱五行。

func (*EightChar) MonthXun 

func (ec *EightChar) MonthXun() string

MonthXun 返回月柱所在旬。

func (*EightChar) MonthXunKong 

func (ec *EightChar) MonthXunKong() string

MonthXunKong 返回月柱空亡。

func (*EightChar) MonthZhi 

func (ec *EightChar) MonthZhi() string

MonthZhi 返回月支。

func (*EightChar) Sect 

func (ec *EightChar) Sect() Sect

Sect 返回流派。

func (*EightChar) ShenGong 

func (ec *EightChar) ShenGong() string

ShenGong 返回身宫。

func (*EightChar) ShenGongNaYin 

func (ec *EightChar) ShenGongNaYin() string

ShenGongNaYin 返回身宫纳音。

func (*EightChar) String 

func (ec *EightChar) String() string

String 返回 "年柱 月柱 日柱 时柱"。

func (*EightChar) TaiXi 

func (ec *EightChar) TaiXi() string

TaiXi 返回胎息。

func (*EightChar) TaiXiNaYin 

func (ec *EightChar) TaiXiNaYin() string

TaiXiNaYin 返回胎息纳音。

func (*EightChar) TaiYuan 

func (ec *EightChar) TaiYuan() string

TaiYuan 返回胎元。

func (*EightChar) TaiYuanNaYin 

func (ec *EightChar) TaiYuanNaYin() string

TaiYuanNaYin 返回胎元纳音。

func (*EightChar) Time 

func (ec *EightChar) Time() string

Time 返回时柱干支。

func (*EightChar) TimeDiShi 

func (ec *EightChar) TimeDiShi() string

TimeDiShi 返回时柱十二长生。

func (*EightChar) TimeGan 

func (ec *EightChar) TimeGan() string

TimeGan 返回时干。

func (*EightChar) TimeHideGan 

func (ec *EightChar) TimeHideGan() []string

TimeHideGan 返回时支藏干。

func (*EightChar) TimeNaYin 

func (ec *EightChar) TimeNaYin() string

TimeNaYin 返回时柱纳音。

func (*EightChar) TimeShiShenGan 

func (ec *EightChar) TimeShiShenGan() string

TimeShiShenGan 返回时干十神。

func (*EightChar) TimeShiShenZhi 

func (ec *EightChar) TimeShiShenZhi() []string

TimeShiShenZhi 返回时支十神（藏干列表）。

func (*EightChar) TimeWuXing 

func (ec *EightChar) TimeWuXing() string

TimeWuXing 返回时柱五行。

func (*EightChar) TimeXun 

func (ec *EightChar) TimeXun() string

TimeXun 返回时柱所在旬。

func (*EightChar) TimeXunKong 

func (ec *EightChar) TimeXunKong() string

TimeXunKong 返回时柱空亡。

func (*EightChar) TimeZhi 

func (ec *EightChar) TimeZhi() string

TimeZhi 返回时支。

func (*EightChar) Year 

func (ec *EightChar) Year() string

Year 返回年柱干支。

func (*EightChar) YearDiShi 

func (ec *EightChar) YearDiShi() string

YearDiShi 返回年柱十二长生。

func (*EightChar) YearGan 

func (ec *EightChar) YearGan() string

YearGan 返回年干。

func (*EightChar) YearHideGan 

func (ec *EightChar) YearHideGan() []string

YearHideGan 返回年支藏干。

func (*EightChar) YearNaYin 

func (ec *EightChar) YearNaYin() string

YearNaYin 返回年柱纳音。

func (*EightChar) YearShiShenGan 

func (ec *EightChar) YearShiShenGan() string

YearShiShenGan 返回年干十神。

func (*EightChar) YearShiShenZhi 

func (ec *EightChar) YearShiShenZhi() []string

YearShiShenZhi 返回年支十神（藏干列表）。

func (*EightChar) YearWuXing 

func (ec *EightChar) YearWuXing() string

YearWuXing 返回年柱五行。

func (*EightChar) YearXun 

func (ec *EightChar) YearXun() string

YearXun 返回年柱所在旬。

func (*EightChar) YearXunKong 

func (ec *EightChar) YearXunKong() string

YearXunKong 返回年柱空亡。

func (*EightChar) YearZhi 

func (ec *EightChar) YearZhi() string

YearZhi 返回年支。

func (*EightChar) Yun 

func (ec *EightChar) Yun(gender Gender) *Yun

Yun 起大运（默认 SectAncient 按时辰起运口径，与 v1 GetYun 默认一致）。

Example

大运流年。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	lunarDay := lunar.MustSolarTime(1981, 1, 29, 23, 37, 0).Lunar()
	yun := lunarDay.EightChar().Yun(lunar.Female)

	fmt.Println("起运:", yun.StartSolar().String())
	// 大运[0] 为出生小运段（GanZhi 为空），自大运[1] 起干支顺/逆推
	for _, dy := range yun.DaYun()[:3] {
		if gz := dy.GanZhi(); gz != "" {
			fmt.Printf("大运[%d] %d-%d %s\n", dy.Index(), dy.StartYear(), dy.EndYear(), gz)
		} else {
			fmt.Printf("大运[%d] %d-%d\n", dy.Index(), dy.StartYear(), dy.EndYear())
		}
	}
}

Output:
起运: 1989-02-18
大运[0] 1981-1988
大运[1] 1989-1998 戊子
大运[2] 1999-2008 丁亥

func (*EightChar) YunBySect 

func (ec *EightChar) YunBySect(gender Gender, sect Sect) *Yun

YunBySect 按流派起运。

type EightCharOption 

type EightCharOption func(*EightChar)

EightCharOption 为八字构造选项。

func WithSect 

func WithSect(sect Sect) EightCharOption

WithSect 指定流派（默认 SectFolk 民间流派：晚子时日柱算当天）。

type Foto 

type Foto struct {
	// contains filtered or unexported fields
}

Foto 佛历。

func MustNewFoto 

func MustNewFoto(year, month, day, hour, minute, second int) *Foto

MustNewFoto 构造佛历日期时间，非法输入 panic。仅建议字面量常量使用。

func MustNewFotoFromYmd 

func MustNewFotoFromYmd(year, month, day int) *Foto

MustNewFotoFromYmd 构造佛历日期，非法输入 panic。仅建议字面量常量使用。

func NewFoto 

func NewFoto(year, month, day, hour, minute, second int) (*Foto, error)

NewFoto 构造佛历日期时间（year 为佛历年份；月/日/时值域错误返回包装 ErrInvalidDate 的错误）。

func NewFotoFromLunar 

func NewFotoFromLunar(l *Lunar) *Foto

NewFotoFromLunar 由农历构造佛历（lunar 为 nil 时返回 nil）。

func NewFotoFromYmd 

func NewFotoFromYmd(year, month, day int) (*Foto, error)

NewFotoFromYmd 构造佛历日期（零时）。

func (*Foto) Animal 

func (f *Foto) Animal() string

Animal 返回 27 星宿动物。

func (*Foto) Day 

func (f *Foto) Day() int

Day 返回农历日。

func (*Foto) DayInChinese 

func (f *Foto) DayInChinese() string

DayInChinese 返回中文日（初一 ~ 三十）。

func (*Foto) Festivals 

func (f *Foto) Festivals() []FotoFestival

Festivals 返回当日佛历因果犯忌（闰月按同一月查表，v1 语义）。

func (*Foto) Gong 

func (f *Foto) Gong() string

Gong 返回 27 星宿所在宫位。

func (*Foto) IsDayYangGong 

func (f *Foto) IsDayYangGong() bool

IsDayYangGong 返回是否杨公忌。 v1 此方法对 list 元素做值类型断言（实际存的是指针），节日非空即 panic； v2 值切片语义顺带修复该缺陷，语义与 v1 意图一致。

func (*Foto) IsDayZhaiGuanYin 

func (f *Foto) IsDayZhaiGuanYin() bool

IsDayZhaiGuanYin 返回是否观音斋。

func (*Foto) IsDayZhaiShuoWang 

func (f *Foto) IsDayZhaiShuoWang() bool

IsDayZhaiShuoWang 返回是否朔望斋（初一/十五）。

func (*Foto) IsDayZhaiSix 

func (f *Foto) IsDayZhaiSix() bool

IsDayZhaiSix 返回是否六斋日（廿八时按当月大小边界修正，v1 语义）。

func (*Foto) IsDayZhaiTen 

func (f *Foto) IsDayZhaiTen() bool

IsDayZhaiTen 返回是否十斋日。

func (*Foto) IsMonthZhai 

func (f *Foto) IsMonthZhai() bool

IsMonthZhai 返回是否月斋期（正/五/九月）。

func (*Foto) Lunar 

func (f *Foto) Lunar() *Lunar

Lunar 返回对应农历。

func (*Foto) Month 

func (f *Foto) Month() int

Month 返回农历月（负数表示闰月）。

func (*Foto) MonthInChinese 

func (f *Foto) MonthInChinese() string

MonthInChinese 返回中文月份（闰月带「闰」前缀）。

func (*Foto) OtherFestivals 

func (f *Foto) OtherFestivals() []string

OtherFestivals 返回当日其他佛节日（菩萨圣诞等；键含闰月负号，v1 语义原样保留）。

func (*Foto) Shou 

func (f *Foto) Shou() string

Shou 返回宫位对应神兽。

func (*Foto) String 

func (f *Foto) String() string

String 返回如 "二五六五年十月十四"。

func (*Foto) ToFullString 

func (f *Foto) ToFullString() string

ToFullString 返回完整佛历描述（含当日因果犯忌）。

func (*Foto) Xiu 

func (f *Foto) Xiu() string

Xiu 返回当日 27 星宿（佛历专用 27 宿体系，牛宿并入女宿，区别于农历 28 宿）。

func (*Foto) XiuLuck 

func (f *Foto) XiuLuck() string

XiuLuck 返回 27 星宿吉凶。

func (*Foto) XiuSong 

func (f *Foto) XiuSong() string

XiuSong 返回 27 星宿歌诀。

func (*Foto) Year 

func (f *Foto) Year() int

Year 返回佛历年份（v1 边界逻辑原样迁移：公历年与农历年相同代表正月初一 及以后，年份 +1）。

func (*Foto) YearInChinese 

func (f *Foto) YearInChinese() string

YearInChinese 返回中文佛历年份（如 二五六五）。

func (*Foto) Zheng 

func (f *Foto) Zheng() string

Zheng 返回 27 星宿七政。

type FotoFestival 

type FotoFestival struct {
	// contains filtered or unexported fields
}

FotoFestival 佛历因果犯忌（值类型：小对象、构造后只读）。

func NewFotoFestival 

func NewFotoFestival(name, result string, everyMonth bool, remark string) FotoFestival

NewFotoFestival 构造佛历因果犯忌。

func (FotoFestival) IsEveryMonth 

func (f FotoFestival) IsEveryMonth() bool

IsEveryMonth 返回是否每月同。

func (FotoFestival) Name 

func (f FotoFestival) Name() string

Name 返回是日何日，如：雷斋日。

func (FotoFestival) Remark 

func (f FotoFestival) Remark() string

Remark 返回备注，如：宜先一日即戒。

func (FotoFestival) Result 

func (f FotoFestival) Result() string

Result 返回犯之因果，如：犯者夺纪。

func (FotoFestival) String 

func (f FotoFestival) String() string

String 返回名称。

func (FotoFestival) ToFullString 

func (f FotoFestival) ToFullString() string

ToFullString 返回完整描述（名称 + 因果 + 备注）。

type Fu 

type Fu struct {
	// contains filtered or unexported fields
}

Fu 表示三伏。

func (*Fu) Index 

func (f *Fu) Index() int

Index 返回第几天。

func (*Fu) Name 

func (f *Fu) Name() string

Name 返回名称。

func (*Fu) String 

func (f *Fu) String() string

String 返回名称。

func (*Fu) ToFullString 

func (f *Fu) ToFullString() string

ToFullString 返回如 "初伏第3天"。

type Gender 

type Gender int

Gender 表示性别（用于大运顺逆排）。 

const (
	Female Gender = iota // 女
	Male                 // 男
)

func (Gender) String 

func (g Gender) String() string

String 实现 fmt.Stringer。

type GuiShenBase 

type GuiShenBase int

GuiShenBase 日干贵神（天乙贵人昼夜贵）取用口径。 

const (
	// GuiShenXieJi 《协纪辨方书》定例（默认）：阳贵甲起未顺行
	// （甲未、乙申、丙酉、丁亥、戊丑、己子、庚丑、辛寅、壬卯、癸巳），
	// 阴贵甲起丑逆行（甲丑、乙子、丙亥、丁酉、戊未、己申、庚未、
	// 辛午、壬巳、癸卯）。通书贵登天门时定局表皆用此例。
	GuiShenXieJi GuiShenBase = iota
	// GuiShenZiPing 子平命理通行口诀「甲戊庚牛羊，乙己鼠猴乡，
	// 丙丁猪鸡位，壬癸兔蛇藏，六辛逢马虎」以丑为昼贵（阳贵）：
	// 甲戊庚阳丑阴未、乙己阳子阴申、丙丁阳亥阴酉、壬癸阳卯阴巳、
	// 辛阳午阴寅。命理排盘常用；与协纪定例在甲乙丙辛癸五干上
	// 昼夜互异（丁戊己庚壬五干相同）。
	GuiShenZiPing
)

type Holiday 

type Holiday struct {
	Date   Date
	Name   string
	Work   bool
	Target Date
}

Holiday 描述单个假日条目。 Work=false 为放假，Work=true 为调休上班；Target 为归属节日锚点日期 （如「2026-02-28 春节调休上班」的 Target 为春节首日）。

func HolidayOfDay 

func HolidayOfDay(year, month, day int) *Holiday

HolidayOfDay 查询全局默认存储中指定日期的假日（便捷函数，O(1)）。

func HolidaysByYear 

func HolidaysByYear(year int) []Holiday

HolidaysByYear 查询全局默认存储中某年的全部假日。

type HolidayStore 

type HolidayStore struct {
	// contains filtered or unexported fields
}

HolidayStore 为并发安全的假日存储实例。 零值不可用，请通过 NewHolidayStore / FromScratchHolidayStore 构造。

Example

法定节假日：五层架构。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	// Layer 1：主库内嵌基线（2001-2026）自动生效
	h := lunar.HolidayOfDay(2025, 10, 1)
	fmt.Println("2025-10-01:", h.Name, "放假:", !h.Work)

	// Layer 4：程序化补丁（应用侧，最高优先级）
	lunar.DefaultHolidayStore().Patch(lunar.Holiday{
		Date:   lunar.MustDate(2025, 10, 8),
		Name:   "自定义补班",
		Work:   true,
		Target: lunar.MustDate(2025, 10, 1),
	})
	fmt.Println("2025-10-08 上班:", lunar.DefaultHolidayStore().IsWorkDay(2025, 10, 8))

	// 覆盖区间预检（空窗期优雅降级）
	from, to := lunar.HolidayCoverage()
	fmt.Printf("覆盖: %d-%d\n", from, to)
}

Output:
2025-10-01: 国庆中秋 放假: true
2025-10-08 上班: true
覆盖: 2001-2026

func DefaultHolidayStore 

func DefaultHolidayStore() *HolidayStore

DefaultHolidayStore 返回全局默认假日存储（惰性初始化，含 Layer 1 基线）。

func FromScratchHolidayStore 

func FromScratchHolidayStore() *HolidayStore

FromScratchHolidayStore 创建空存储（不含内嵌基线）。

func NewHolidayStore 

func NewHolidayStore() *HolidayStore

NewHolidayStore 创建含 Layer 1 内嵌基线（2001 起）的默认形态存储。 若环境变量 LUNAR_HOLIDAY_FILE 指向有效文件，则额外加载（Layer 3）。

func (*HolidayStore) Coverage 

func (s *HolidayStore) Coverage() (from, to int)

Coverage 返回数据覆盖年份区间 [from, to]；空存储返回 (0, 0)。

func (*HolidayStore) EmbeddedError 

func (s *HolidayStore) EmbeddedError() error

EmbeddedError 返回内嵌假日基线（Layer 1）的加载错误，正常为 nil。 用于部署环境自检：若非 nil，说明内嵌 JSON 数据损坏，库以空假日存储降级运行， 可通过 Coverage 观察到覆盖年份为空。

func (*HolidayStore) Holiday 

func (s *HolidayStore) Holiday(year, month, day int) *Holiday

Holiday 返回指定日期的假日条目；无则返回 nil。 未覆盖年份的优雅降级：返回零值 nil，调用方可经 Coverage 预检（计划 R10）。

func (*HolidayStore) HolidaysByMonth 

func (s *HolidayStore) HolidaysByMonth(year, month int) []Holiday

HolidaysByMonth 返回某年某月全部条目。

func (*HolidayStore) HolidaysByTarget 

func (s *HolidayStore) HolidaysByTarget(year, month, day int) []Holiday

HolidaysByTarget 返回锚点为指定日期的全部条目（该节日与其全部调休安排）。

func (*HolidayStore) HolidaysByYear 

func (s *HolidayStore) HolidaysByYear(year int) []Holiday

HolidaysByYear 返回某年全部条目（按日期升序）。

func (*HolidayStore) IsWorkDay 

func (s *HolidayStore) IsWorkDay(year, month, day int) bool

IsWorkDay 判断某日是否须上班：先查调休/假日覆盖，否则按周六周日判断。

func (*HolidayStore) Len 

func (s *HolidayStore) Len() int

Len 返回条目总数。

func (*HolidayStore) LoadBytes 

func (s *HolidayStore) LoadBytes(b []byte) error

LoadBytes 解析并合并假日 JSON 数据（格式见 holidayJSON）。

func (*HolidayStore) LoadFS 

func (s *HolidayStore) LoadFS(fsys fs.FS) error

LoadFS 解析 fsys 根目录下全部 *.json 并合并（按文件名升序，后者覆盖前者）。

func (*HolidayStore) LoadFile 

func (s *HolidayStore) LoadFile(path string) error

LoadFile 加载运行时假日数据文件（Layer 3）。同日期条目覆盖既有数据。

Example

运行时假日文件热更新（Layer 3）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	store := lunar.FromScratchHolidayStore()
	// store.LoadFile("/etc/myapp/holidays.json")     // 启动加载
	// stop := store.Watch("/etc/myapp/holidays.json") // mtime 轮询热更新
	// defer stop()
	fmt.Println(store.Len())
}

Output:
0

func (*HolidayStore) Patch 

func (s *HolidayStore) Patch(holidays ...Holiday)

Patch 应用程序化补丁（Layer 4，最高优先级）：同日期条目被覆盖。

func (*HolidayStore) Remove 

func (s *HolidayStore) Remove(year, month, day int) bool

Remove 删除指定日期的条目；返回是否存在。

func (*HolidayStore) Watch 

func (s *HolidayStore) Watch(path string) (stop func())

Watch 启动 mtime 轮询热更新（默认 1 分钟间隔，纯标准库）。 返回 stop 函数。刻意不用 fsnotify（零依赖红线，YAGNI）。

type HongShaBase 

type HongShaBase int

HongShaBase 红沙日取月口径。 

const (
	// HongShaByYueJian 按节气月建（通书正统）：孟月（寅申巳亥）酉日、
	// 仲月（子午卯酉）巳日、季月（辰戌丑未）丑日。
	HongShaByYueJian HongShaBase = iota
	// HongShaByNongLi 按农历月序（民俗简便）：正四七十月酉日、
	// 二五八十一月巳日、三六九十二月丑日。闰月随本月序号。
	HongShaByNongLi
)

type JieQi 

type JieQi struct {
	// contains filtered or unexported fields
}

JieQi 表示节气（含交接时刻）。

func NewJieQi 

func NewJieQi(name string, solar Solar) *JieQi

NewJieQi 构造节气对象。

func (*JieQi) IsJie 

func (jq *JieQi) IsJie() bool

IsJie 报告是否节令。

func (*JieQi) IsQi 

func (jq *JieQi) IsQi() bool

IsQi 报告是否气令。

func (*JieQi) Name 

func (jq *JieQi) Name() string

Name 返回节气名。

func (*JieQi) Solar 

func (jq *JieQi) Solar() Solar

Solar 返回交接时刻的公历。

func (*JieQi) String 

func (jq *JieQi) String() string

String 返回节气名。

type LeapRule 

type LeapRule int

LeapRule 杨公十三忌的闰月处理口径。 

const (
	// LeapFollowHost 闰月随本月序号：闰六月初三仍按六月初三论（多数通书）。
	LeapFollowHost LeapRule = iota
	// LeapNoJi 闰月不设忌：闰月内无杨公忌日（另一派通书）。
	LeapNoJi
)

type LiuNian 

type LiuNian struct {
	// contains filtered or unexported fields
}

LiuNian 表示流年。

func (*LiuNian) Age 

func (ln *LiuNian) Age() int

Age 返回年龄。

func (*LiuNian) GanZhi 

func (ln *LiuNian) GanZhi() string

GanZhi 返回流年干支。

func (*LiuNian) Index 

func (ln *LiuNian) Index() int

Index 返回序数。

func (*LiuNian) LiuYue 

func (ln *LiuNian) LiuYue() []LiuYue

LiuYue 返回该年 12 个流月。

func (*LiuNian) Xun 

func (ln *LiuNian) Xun() string

Xun 返回所在旬。

func (*LiuNian) XunKong 

func (ln *LiuNian) XunKong() string

XunKong 返回旬空。

func (*LiuNian) Year 

func (ln *LiuNian) Year() int

Year 返回年。

type LiuYue 

type LiuYue struct {
	// contains filtered or unexported fields
}

LiuYue 表示流月。

func (*LiuYue) GanZhi 

func (ly *LiuYue) GanZhi() string

GanZhi 返回流月干支（五虎遁）。

func (*LiuYue) Index 

func (ly *LiuYue) Index() int

Index 返回序数。

func (*LiuYue) MonthInChinese 

func (ly *LiuYue) MonthInChinese() string

MonthInChinese 返回中文月。

func (*LiuYue) Xun 

func (ly *LiuYue) Xun() string

Xun 返回所在旬。

func (*LiuYue) XunKong 

func (ly *LiuYue) XunKong() string

XunKong 返回旬空。

type Lunar 

type Lunar struct {
	// contains filtered or unexported fields
}

Lunar 为农历日期时间（指针语义：字段重、派生态多）。 构造后只读，并发安全（计划 T3.9 文档化语义）。

func FromSolar 

func FromSolar(s Solar) *Lunar

FromSolar 由公历构造农历（不可失败：任何合法公历日期均有对应农历）。

func FromTime 

func FromTime(t time.Time) *Lunar

FromTime 由 time.Time 构造农历。

Example

由 time.Time 构造。 

package main

import (
	"fmt"
	"time"

	"github.com/tekintian/lunar"
)

func main() {
	t := time.Date(2024, 2, 10, 10, 30, 0, 0, time.UTC)
	lunarDay := lunar.FromTime(t)

	fmt.Println(lunarDay.String(), lunarDay.Solar().String())
}

Output:
二〇二四年正月初一 2024-02-10

func MustNewLunar 

func MustNewLunar(year, month, day int) *Lunar

MustNewLunar 构造农历日期，非法输入 panic。仅建议字面量常量使用。

func MustNewLunarDateTime 

func MustNewLunarDateTime(year, month, day, hour, minute, second int) *Lunar

MustNewLunarDateTime 构造农历日期时间，非法输入 panic。仅建议字面量常量使用。

func MustNewLunarTime deprecated 

func MustNewLunarTime(year, month, day, hour, minute, second int) *Lunar

MustNewLunarTime 为 MustNewLunarDateTime 的早期别名（v2 历史命名）。 注意：本方法返回 *Lunar 而非 *LunarTime；如需时辰对象请用 NewLunarTime / NewLunarTimeFromLunar。

Deprecated: 命名易与 NewLunarTime（返回 *LunarTime）混淆，请改用 MustNewLunarDateTime。

func NewLunar 

func NewLunar(year, month, day int) (*Lunar, error)

NewLunar 构造农历日期（零时）。 month 为负表示闰月；月/日值域错误返回包装 ErrInvalidDate 的错误。

Example

错误模型：可失败构造返回错误（零 panic）。 

package main

import (
	"errors"
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	// 闰四月合法
	if l, err := lunar.NewLunar(2020, -4, 13); err == nil {
		fmt.Println("2020 闰四月十三 =", l.String())
	}
	// 不存在的闰月报错
	_, err := lunar.NewLunar(2033, -12, 1)
	fmt.Println("2033 闰十二月:", errors.Is(err, lunar.ErrInvalidDate))
}

Output:
2020 闰四月十三 = 二〇二〇年闰四月十三
2033 闰十二月: true

func NewLunarDateTime 

func NewLunarDateTime(year, month, day, hour, minute, second int) (*Lunar, error)

NewLunarDateTime 构造农历日期时间。

func (*Lunar) Almanac 

func (l *Lunar) Almanac() Almanac

Almanac 返回当日黄历全景快照。

Example

结构化输出：Almanac 全景与 JSON。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	lunarDay := lunar.MustNewLunar(2019, 3, 27)
	a := lunarDay.Almanac()

	fmt.Println(a.Chong, a.Sha, a.PositionCai)
}

Output:
(壬辰)龙 北 坎
Example (StandardFields)

Almanac 标配字段：值日建除、日禄、三柱空亡、阳贵阴贵、日九星、 年三煞、值年太岁、年景歌诀与十二时辰吉凶表一次取齐。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	a := lunar.MustSolar(2025, 6, 1).Lunar().Almanac()

	fmt.Println(a.ZhiXing, a.DayLu)
	fmt.Println(a.XunKongYear, a.XunKongMonth, a.XunKongDay)
	fmt.Println(a.YangGui, a.YinGui, a.DayNineStar)
	fmt.Println(a.SanSha, a.TaiSui.String())
	fmt.Println(a.NianJing.ZhiShui, a.NianJing.FenBing, a.NianJing.DeJin)
	fmt.Println(len(a.Times), a.Times[2].GanZhi, a.Times[2].TianShen, a.Times[2].TianShenLuck)
}

Output:
成 酉命互禄
寅卯 申酉 辰巳
艮 离 五黄土
东(寅卯辰) 吴遂大将军
七龙治水 九人分饼 四日得金
12 庚寅 金匮 吉

func (*Lunar) Animal 

func (l *Lunar) Animal() string

Animal 返回星宿动物。

func (*Lunar) BaZi 

func (l *Lunar) BaZi() [4]string

BaZi 返回四柱干支数组。

func (*Lunar) BaZiNaYin 

func (l *Lunar) BaZiNaYin() [4]string

BaZiNaYin 返回四柱纳音。

func (*Lunar) BaZiShiShenGan 

func (l *Lunar) BaZiShiShenGan() [4]string

BaZiShiShenGan 返回四柱天干十神。

func (*Lunar) BaZiShiShenZhi 

func (l *Lunar) BaZiShiShenZhi() [4]string

BaZiShiShenZhi 返回四柱地支十神（每柱取首藏干）。

func (*Lunar) BaZiWuXing 

func (l *Lunar) BaZiWuXing() [4]string

BaZiWuXing 返回四柱五行。

func (*Lunar) CurrentJie 

func (l *Lunar) CurrentJie() *JieQi

CurrentJie 返回当日节令对象；无则返回 nil。

func (*Lunar) CurrentJieQi 

func (l *Lunar) CurrentJieQi() *JieQi

CurrentJieQi 返回当日节气对象；无则返回 nil。

func (*Lunar) CurrentQi 

func (l *Lunar) CurrentQi() *JieQi

CurrentQi 返回当天气令对象；无则返回 nil。

func (*Lunar) Day 

func (l *Lunar) Day() int

Day 返回农历日。

func (*Lunar) DayChong 

func (l *Lunar) DayChong() string

DayChong 返回日冲地支。

func (*Lunar) DayChongDesc 

func (l *Lunar) DayChongDesc() string

DayChongDesc 返回日冲描述，如 "(壬子)鼠"。

func (*Lunar) DayChongGan 

func (l *Lunar) DayChongGan() string

DayChongGan 返回日冲天干。

func (*Lunar) DayChongGanTie 

func (l *Lunar) DayChongGanTie() string

DayChongGanTie 返回日冲天干（贴身）。

func (*Lunar) DayChongShengXiao 

func (l *Lunar) DayChongShengXiao() string

DayChongShengXiao 返回日冲生肖。

func (*Lunar) DayGan 

func (l *Lunar) DayGan() string

DayGan 返回日干。

func (*Lunar) DayGanExact 

func (l *Lunar) DayGanExact() string

DayGanExact 返回日干（晚子时日柱算明天）。

func (*Lunar) DayGanExact2 

func (l *Lunar) DayGanExact2() string

DayGanExact2 返回日干（晚子时日柱算当天）。

func (*Lunar) DayGanIndex 

func (l *Lunar) DayGanIndex() int

DayGanIndex 返回日干序。

func (*Lunar) DayGanIndexExact 

func (l *Lunar) DayGanIndexExact() int

DayGanIndexExact 返回日干序（晚子时算明天）。

func (*Lunar) DayGanIndexExact2 

func (l *Lunar) DayGanIndexExact2() int

DayGanIndexExact2 返回日干序（晚子时算当天）。

func (*Lunar) DayInChinese 

func (l *Lunar) DayInChinese() string

DayInChinese 返回中文日（初一 ~ 三十）。

func (*Lunar) DayInGanZhi 

func (l *Lunar) DayInGanZhi() string

DayInGanZhi 返回日柱干支。

func (*Lunar) DayInGanZhiExact 

func (l *Lunar) DayInGanZhiExact() string

DayInGanZhiExact 返回日柱干支（晚子时日柱算明天）。

func (*Lunar) DayInGanZhiExact2 

func (l *Lunar) DayInGanZhiExact2() string

DayInGanZhiExact2 返回日柱干支（晚子时日柱算当天）。

func (*Lunar) DayJi 

func (l *Lunar) DayJi() []string

DayJi 返回当日忌（默认流派一）。

func (*Lunar) DayJiBySect 

func (l *Lunar) DayJiBySect(sect Sect) []string

DayJiBySect 按流派返回当日忌。

func (*Lunar) DayJiShen 

func (l *Lunar) DayJiShen() []string

DayJiShen 返回当日吉神。

func (*Lunar) DayLu 

func (l *Lunar) DayLu() string

DayLu 返回日禄。

func (*Lunar) DayNaYin 

func (l *Lunar) DayNaYin() string

DayNaYin 返回日柱纳音。

func (*Lunar) DayNaYinWuXing 

func (l *Lunar) DayNaYinWuXing() string

DayNaYinWuXing 返回日纳音五行属性（金/木/水/火/土）。 纳音名末字即五行（如「金箔金」→「金」）；民间搬家选「水日」、 避「火日」等即据此判定。纳音缺失返回空串。

func (*Lunar) DayNineStar 

func (l *Lunar) DayNineStar() *NineStar

DayNineStar 返回日九星。

func (*Lunar) DayPositionCai 

func (l *Lunar) DayPositionCai() string

DayPositionCai 返回日财神方位。

func (*Lunar) DayPositionCaiDesc 

func (l *Lunar) DayPositionCaiDesc() string

DayPositionCaiDesc 返回日财神方位说明。

func (*Lunar) DayPositionFu 

func (l *Lunar) DayPositionFu() string

DayPositionFu 返回日福神方位（民间流派）。

func (*Lunar) DayPositionFuBySect 

func (l *Lunar) DayPositionFuBySect(sect Sect) string

DayPositionFuBySect 按流派返回日福神方位。

func (*Lunar) DayPositionFuDesc 

func (l *Lunar) DayPositionFuDesc() string

DayPositionFuDesc 返回日福神方位说明。

func (*Lunar) DayPositionFuDescBySect 

func (l *Lunar) DayPositionFuDescBySect(sect Sect) string

DayPositionFuDescBySect 按流派返回日福神方位说明。

func (*Lunar) DayPositionTai 

func (l *Lunar) DayPositionTai() string

DayPositionTai 返回日胎神方位。

func (*Lunar) DayPositionTaiSui 

func (l *Lunar) DayPositionTaiSui() string

DayPositionTaiSui 返回日太岁方位（民间流派）。

func (*Lunar) DayPositionTaiSuiBySect 

func (l *Lunar) DayPositionTaiSuiBySect(sect Sect) string

DayPositionTaiSuiBySect 按流派返回日太岁方位。

func (*Lunar) DayPositionTaiSuiDesc 

func (l *Lunar) DayPositionTaiSuiDesc() string

DayPositionTaiSuiDesc 返回日太岁方位说明。

func (*Lunar) DayPositionTaiSuiDescBySect 

func (l *Lunar) DayPositionTaiSuiDescBySect(sect Sect) string

DayPositionTaiSuiDescBySect 按流派返回日太岁方位说明。

func (*Lunar) DayPositionXi 

func (l *Lunar) DayPositionXi() string

DayPositionXi 返回日喜神方位。

func (*Lunar) DayPositionXiDesc 

func (l *Lunar) DayPositionXiDesc() string

DayPositionXiDesc 返回日喜神方位说明。

func (*Lunar) DayPositionYangGui 

func (l *Lunar) DayPositionYangGui() string

DayPositionYangGui 返回日阳贵方位。

func (*Lunar) DayPositionYangGuiDesc 

func (l *Lunar) DayPositionYangGuiDesc() string

DayPositionYangGuiDesc 返回日阳贵方位说明。

func (*Lunar) DayPositionYinGui 

func (l *Lunar) DayPositionYinGui() string

DayPositionYinGui 返回日阴贵方位。

func (*Lunar) DayPositionYinGuiDesc 

func (l *Lunar) DayPositionYinGuiDesc() string

DayPositionYinGuiDesc 返回日阴贵方位说明。

func (*Lunar) DaySha 

func (l *Lunar) DaySha() string

DaySha 返回日煞方位。

func (*Lunar) DayShengXiao 

func (l *Lunar) DayShengXiao() string

DayShengXiao 返回日生肖。

func (*Lunar) DayTianShen 

func (l *Lunar) DayTianShen() string

DayTianShen 返回日天神。

func (*Lunar) DayTianShenLuck 

func (l *Lunar) DayTianShenLuck() string

DayTianShenLuck 返回日天神吉凶。

func (*Lunar) DayTianShenType 

func (l *Lunar) DayTianShenType() string

DayTianShenType 返回日天神类型（黄道/黑道）。

func (*Lunar) DayXiongSha 

func (l *Lunar) DayXiongSha() []string

DayXiongSha 返回当日凶煞。

func (*Lunar) DayXun 

func (l *Lunar) DayXun() string

DayXun 返回日旬。

func (*Lunar) DayXunExact 

func (l *Lunar) DayXunExact() string

DayXunExact 返回日旬（晚子时日柱算明天）。

func (*Lunar) DayXunExact2 

func (l *Lunar) DayXunExact2() string

DayXunExact2 返回日旬（晚子时日柱算当天）。

func (*Lunar) DayXunKong 

func (l *Lunar) DayXunKong() string

DayXunKong 返回日空亡。

func (*Lunar) DayXunKongExact 

func (l *Lunar) DayXunKongExact() string

DayXunKongExact 返回日空亡（晚子时日柱算明天）。

func (*Lunar) DayXunKongExact2 

func (l *Lunar) DayXunKongExact2() string

DayXunKongExact2 返回日空亡（晚子时日柱算当天）。

func (*Lunar) DayYi 

func (l *Lunar) DayYi() []string

DayYi 返回当日宜（默认流派一，月柱以节交接当日起算）。

Example

黄历：宜忌 / 神煞 / 节气。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	lunarDay := lunar.MustNewLunar(2019, 3, 27)

	fmt.Println(lunarDay.DayYi())
	fmt.Println(lunarDay.DayJiShen())
	fmt.Println(lunarDay.NextJieQi().Name())
}

Output:
[祭祀 求医 治病 解除 馀事勿取]
[天马 福生 解神]
立夏

func (*Lunar) DayYiBySect 

func (l *Lunar) DayYiBySect(sect Sect) []string

DayYiBySect 按流派返回当日宜。

func (*Lunar) DayZhi 

func (l *Lunar) DayZhi() string

DayZhi 返回日支。

func (*Lunar) DayZhiExact 

func (l *Lunar) DayZhiExact() string

DayZhiExact 返回日支（晚子时日柱算明天）。

func (*Lunar) DayZhiExact2 

func (l *Lunar) DayZhiExact2() string

DayZhiExact2 返回日支（晚子时日柱算当天）。

func (*Lunar) DayZhiIndex 

func (l *Lunar) DayZhiIndex() int

DayZhiIndex 返回日支序。

func (*Lunar) DayZhiIndexExact 

func (l *Lunar) DayZhiIndexExact() int

DayZhiIndexExact 返回日支序（晚子时算明天）。

func (*Lunar) DayZhiIndexExact2 

func (l *Lunar) DayZhiIndexExact2() int

DayZhiIndexExact2 返回日支序（晚子时算当天）。

func (*Lunar) EightChar 

func (l *Lunar) EightChar() *EightChar

EightChar 返回八字号（默认民间流派；结果缓存于 Lunar 实例）。 需要其他流派视图时请使用 NewEightChar(l, WithSect(...))。

func (*Lunar) Festivals 

func (l *Lunar) Festivals() []string

Festivals 返回当日农历节日（含除夕判定）。

func (*Lunar) FolkTaboos 

func (l *Lunar) FolkTaboos() []string

FolkTaboos 返回当日触发的民间择吉禁忌列表（通行通书默认口径速查）： 

月破 / 岁破（立春换年）/ 四离四绝 / 杨公十三忌 / 三娘煞 /
红沙日（月建口径）/ 节气交接日

正常日返回 nil。分歧口径（岁破初一换年、杨公忌闰月不忌、红沙 农历月口径等）请用 FolkTaboosTagged / FolkTaboosGrouped（zeji_variant.go）。 此为禁忌单向速查，吉日判定请另行综合黄黑道（DayTianShen）、建除 （ZhiXing）、宜忌（DayYi/DayJi）与神煞（DayJiShen/DayXiongSha）多维信息。

func (*Lunar) FolkTaboosGrouped 

func (l *Lunar) FolkTaboosGrouped() map[string][]ZejiItem

FolkTaboosGrouped 按流派/口径分块返回禁忌判定（分块展示便捷入口）。 map 键为 ZejiItem.Sect（「通行」「通书·立春换年」「民俗·农历月口径」等）。

func (*Lunar) FolkTaboosTagged 

func (l *Lunar) FolkTaboosTagged() []ZejiItem

FolkTaboosTagged 返回全流派口径下的择吉禁忌判定，逐条标记流派、 典籍出处与版本差异。分歧规则各派独立判定、分别列出；两派同判时 标记「通行」并在 Note 说明。分块展示用 FolkTaboosGrouped。

Example

择吉流派：全流派标记输出。正月初一（立春前）戌日，岁破两派判定相反， 逐条标记流派、典籍出处与异派观点，由使用者按自身传承取舍。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	s, _ := lunar.NewSolar(2025, 1, 29)
	l := s.Lunar()

	for _, it := range l.FolkTaboosTagged() {
		fmt.Printf("[%s] %s：%s（%s）\n", it.Sect, it.Rule, it.Detail, it.Note)
	}
}

Output:
[通书·立春换年] 岁破：日支戌冲太岁（立春界年支辰）（民俗初一换年派（年支巳）此日非岁破）

func (*Lunar) Fu 

func (l *Lunar) Fu() *Fu

Fu 返回三伏；非三伏天返回 nil。

func (*Lunar) Gong 

func (l *Lunar) Gong() string

Gong 返回星宿所在宫位。

func (*Lunar) GuiDengTianMen 

func (l *Lunar) GuiDengTianMen() []TianMenGui

GuiDengTianMen 返回当日的贵登天门时（默认《协纪辨方书》定例贵神， 另见 GuiDengTianMenByBase）。

贵登天门时「乃时之最吉者，能解诸凶」（《协纪辨方书》卷七引通书）： 以月将加于用时时支之上起天盘，日干贵神（天乙贵人）恰临乾亥 （天门）之时辰即为贵登天门时。此时贵人居天门、六吉将得地、 六凶将敛威，故又曰「神藏煞没」，为择时第一义。推法公式： 

时支序 = (月将序 + 亥序 − 贵神支序) mod 12

每日阳贵、阴贵各得一时，返回两条（GuiType "阳贵"/"阴贵"）； 昼用阳贵时、夜用阴贵时（日出日落为界），昼夜取用由调用方按 用事时刻裁定。算例锚点（《协纪辨方书》卷七原文）：雨水后甲日 卯时阳贵登天门、酉时阴贵登天门；大寒后甲日辰时阳贵、戌时阴贵。

Example

专业时辰层：贵登天门时（月将加时、贵人临乾亥，《协纪辨方书》 卷七「择时第一义」，能解诸凶）。2025-02-24 甲子日（雨水后亥将）： 阳贵卯时（昼用）、阴贵酉时（夜用）——协纪卷七原文算例。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	l := lunar.MustSolar(2025, 2, 24).Lunar()

	fmt.Println("月将:", l.YueJiang())
	for _, g := range l.GuiDengTianMen() {
		fmt.Println(g.GuiType, g.Zhi+"时")
	}
}

Output:
月将: 亥
阳贵 卯时
阴贵 酉时

func (*Lunar) GuiDengTianMenByBase 

func (l *Lunar) GuiDengTianMenByBase(base GuiShenBase) []TianMenGui

GuiDengTianMenByBase 按指定贵神口径返回当日的贵登天门时。 推法同 GuiDengTianMen；两口径在甲乙丙辛癸五干上结果互异， 出处备注见 GuiShenNote。月将或贵神数据异常时返回 nil （理论上不发生）。

Example

专业时辰层：贵神口径变体（子平「甲戊庚牛羊」系 vs 协纪定例）。 同日甲干两系阳贵登天门时互异：协纪阳贵未得卯时，子平阳贵丑得酉时。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	l := lunar.MustSolar(2025, 2, 24).Lunar()

	for _, base := range []lunar.GuiShenBase{lunar.GuiShenXieJi, lunar.GuiShenZiPing} {
		g := l.GuiDengTianMenByBase(base)
		fmt.Println(base, g[0].GuiType, g[0].Zhi+"时")
	}
	fmt.Println(lunar.GuiShenNote(lunar.GuiShenZiPing) != "")
}

Output:
0 阳贵 卯时
1 阳贵 酉时
true

func (*Lunar) HasJiShen 

func (l *Lunar) HasJiShen(name string) bool

HasJiShen 返回当日吉神是否含指定名（如 "不将"、"天德"、"月德"）。 选嫁娶「不将日」即 HasJiShen("不将")。

Example

民间择吉：神煞查询（选嫁娶「不将日」）与地支关系。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	s, _ := lunar.NewSolar(2025, 1, 7)
	l := s.Lunar()

	fmt.Println(l.HasJiShen("不将"), l.DayNaYinWuXing())
	fmt.Println(lunar.ZhiSanHe("巳", "酉"), lunar.ZhiLiuHe("巳", "申"))
}

Output:
true 水
true true

func (*Lunar) HasXiongSha 

func (l *Lunar) HasXiongSha(name string) bool

HasXiongSha 返回当日凶煞是否含指定名（如 "月破"、"四离"、"重日"）。

func (*Lunar) Hou 

func (l *Lunar) Hou() string

Hou 返回候（如 "冬至 初候"）。

func (*Lunar) Hour 

func (l *Lunar) Hour() int

Hour 返回时（0-23）。

func (*Lunar) IsHongSha 

func (l *Lunar) IsHongSha() bool

IsHongSha 判定红沙日（默认通书正统的月建口径，另见 IsHongShaByBase）。

func (*Lunar) IsHongShaByBase 

func (l *Lunar) IsHongShaByBase(b HongShaBase) bool

IsHongShaByBase 按指定取月口径判定红沙日。

口诀「四孟金鸡四仲蛇，四季逢丑是红沙」。两口径在节气与农历月 交界附近（如立春前后的农历正月/丑月）判定不同：2025 年两口径 全年分歧 19 天，首例 2025-02-01（丑月丑日）月建口径判红沙、 农历口径（正月）不判。

Example

择吉流派：红沙日两口径（通书按节气月建、民俗按农历月序）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	s, _ := lunar.NewSolar(2025, 2, 1)
	l := s.Lunar()

	fmt.Println(l.IsHongShaByBase(lunar.HongShaByYueJian), l.IsHongShaByBase(lunar.HongShaByNongLi))
}

Output:
true false

func (*Lunar) IsJieQiDay 

func (l *Lunar) IsJieQiDay() bool

IsJieQiDay 返回当日是否节气交接日。 民间认为节气当天气场不稳，重大事项一般避开。

func (*Lunar) IsMeiYuDay 

func (l *Lunar) IsMeiYuDay() bool

IsMeiYuDay 判断当日是否处于梅雨期内（默认通行口径）： 入梅日 ≤ 当日 ≤ 出梅日（两端含，出梅日为梅雨期末日，与通书及 tyme 系口径一致）。入梅前/出梅后返回 false。其他口径见 IsMeiYuDayByBase。

Example

梅雨：当日是否处于梅雨期内（入梅日 ≤ 当日 ≤ 出梅日，两端含）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	for _, d := range []int{5, 6, 13, 14} {
		l := lunar.MustSolar(2025, 7, d).Lunar()
		fmt.Printf("2025-07-%02d %v\n", d, l.IsMeiYuDay())
	}
}

Output:
2025-07-05 true
2025-07-06 true
2025-07-13 true
2025-07-14 false

func (*Lunar) IsMeiYuDayByBase 

func (l *Lunar) IsMeiYuDayByBase(base MeiYuBase) bool

IsMeiYuDayByBase 按指定口径判断当日是否处于梅雨期内 （入梅日 ≤ 当日 ≤ 出梅日，两端含）。锚点缺失（理论不可达） 返回 false。

func (*Lunar) IsSanNiangSha 

func (l *Lunar) IsSanNiangSha() bool

IsSanNiangSha 返回当日是否三娘煞。

func (*Lunar) IsSuiPo 

func (l *Lunar) IsSuiPo() bool

IsSuiPo 返回当日是否岁破日（日支冲年太岁支）。 年支按民间主流的立春换年（与太岁方位 YearPositionTaiSuiBySect 同源）； 岁破日诸事不宜，尤忌动土、搬迁。

func (*Lunar) IsSuiPoByBoundary 

func (l *Lunar) IsSuiPoByBoundary(b YearBoundary) bool

IsSuiPoByBoundary 按指定换年界限判定岁破。

立春与正月初一之间的日期（两界不同年），两派判定可能相反： 如 2025-01-29（正月初一、立春前）戌日，立春派判岁破（甲辰冲戌）、 初一派不判（乙巳冲亥）；次日亥日则恰好相反。

func (*Lunar) IsYangGongJi 

func (l *Lunar) IsYangGongJi() bool

IsYangGongJi 返回当日是否杨公十三忌（唐代杨筠松所订，百事忌）。 闰月随本月序号：闰六月初三仍按六月初三论。

func (*Lunar) IsYangGongJiByLeapRule 

func (l *Lunar) IsYangGongJiByLeapRule(r LeapRule) bool

IsYangGongJiByLeapRule 按指定闰月口径判定杨公十三忌。

如 2025 年闰六月初三（2025-07-27）：随本月派判忌、闰月不忌派不判。 非闰月日期两派恒同判。

func (*Lunar) IsYuePo 

func (l *Lunar) IsYuePo() bool

IsYuePo 返回当日是否月破日（日支冲月建）。 民谚「破不破，先看月建冲不冲」；与十二值日「破」恒等 （见 ZhiXing），亦即神煞「大耗」。

func (*Lunar) Jie 

func (l *Lunar) Jie() string

Jie 返回当日节令名（立春/惊蛰/清明……）；无则空。

func (*Lunar) JieQi 

func (l *Lunar) JieQi() string

JieQi 返回当日节气名；无节气返回空字符串。

func (*Lunar) JieQiNames 

func (l *Lunar) JieQiNames() []string

JieQiNames 返回节气键序列（31 键，与 JieQiTable 值平行）。

func (*Lunar) JieQiTable 

func (l *Lunar) JieQiTable() map[string]Solar

JieQiTable 返回节气表（键含 24 节气名与 7 个跨年键；每次调用构建新 map，可安全修改）。

Example

节气表与最近节气。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	lunarDay := lunar.FromSolar(lunar.MustSolar(2024, 2, 4))

	table := lunarDay.JieQiTable()
	fmt.Println("立春:", table["立春"].String())
	jq := lunarDay.CurrentJieQi()
	fmt.Println("当日节气:", jq.Name())
}

Output:
立春: 2024-02-04
当日节气: 立春

func (*Lunar) LiuYao 

func (l *Lunar) LiuYao() string

LiuYao 返回六曜。

func (*Lunar) MarshalJSON 

func (l *Lunar) MarshalJSON() ([]byte, error)

MarshalJSON 实现 Lunar 的结构化 JSON 输出（API 服务刚需，计划 T1.0）。 输出四柱/生肖/纳音/旬空/节气等核心域；完整全景请用 Almanac()。

Example 
package main

import (
	"encoding/json"
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	lunarDay := lunar.MustNewLunar(2020, -4, 13)
	b, _ := json.Marshal(lunarDay)
	var m map[string]any
	_ = json.Unmarshal(b, &m)
	fmt.Println(m["month"], m["monthInChinese"], m["dayGanZhi"])
}

Output:
-4 闰四 戊寅

func (*Lunar) MeiYu 

func (l *Lunar) MeiYu() MeiYu

MeiYu 返回所在公历年的入梅/出梅日期（默认通行口径：芒种后第 1 个 丙日入梅、小暑后第 1 个未日出梅）。其他口径见 MeiYuByBase。

Example

梅雨：默认通行口径（《神枢经》：芒种后第 1 个丙日入梅、小暑后第 1 个未日出梅）查询 2025 年入梅/出梅。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	l := lunar.MustSolar(2025, 8, 15).Lunar()
	m := l.MeiYu()

	fmt.Println(m.String())
	fmt.Println(lunar.MustSolar(m.In.Year, m.In.Month, m.In.Day).Lunar().DayInGanZhi())
}

Output:
2025-06-06～2025-07-13
丙午

func (*Lunar) MeiYuByBase 

func (l *Lunar) MeiYuByBase(base MeiYuBase) MeiYu

MeiYuByBase 按指定口径返回所在公历年的入梅/出梅日期。

「节气后第 1 个 X 日」含节气当日（芒种当日为丙日则当日入梅）； 作用域为所在公历年（与农历闰月无关）；Note 字段说明口径出处， 异说分歧由使用者按传承取舍。

Example

梅雨：多流派口径（《江南志书》/《碎金》壬日系：芒种后壬入、夏至后庚出）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	l := lunar.MustSolar(2025, 8, 15).Lunar()
	for _, base := range []lunar.MeiYuBase{
		lunar.MeiYuTongXing, lunar.MeiYuJiangNan, lunar.MeiYuMinSu,
	} {
		m := l.MeiYuByBase(base)
		fmt.Println(base, m.String())
	}
}

Output:
0 2025-06-06～2025-07-13
1 2025-06-12～2025-06-30
2 2025-05-11～2025-06-12

func (*Lunar) Minute 

func (l *Lunar) Minute() int

Minute 返回分。

func (*Lunar) Month 

func (l *Lunar) Month() int

Month 返回农历月（负数表示闰月）。

func (*Lunar) MonthGan 

func (l *Lunar) MonthGan() string

MonthGan 返回月干（以节交接当日起算）。

func (*Lunar) MonthGanExact 

func (l *Lunar) MonthGanExact() string

MonthGanExact 返回月干（以节交接时刻起算）。

func (*Lunar) MonthGanIndex 

func (l *Lunar) MonthGanIndex() int

MonthGanIndex 返回月干序。

func (*Lunar) MonthGanIndexExact 

func (l *Lunar) MonthGanIndexExact() int

MonthGanIndexExact 返回月干序（精确）。

func (*Lunar) MonthInChinese 

func (l *Lunar) MonthInChinese() string

MonthInChinese 返回中文月份（闰月带「闰」前缀）。

func (*Lunar) MonthInGanZhi 

func (l *Lunar) MonthInGanZhi() string

MonthInGanZhi 返回月柱干支（以节交接当日起算）。

func (*Lunar) MonthInGanZhiExact 

func (l *Lunar) MonthInGanZhiExact() string

MonthInGanZhiExact 返回月柱干支（以节交接时刻起算）。

func (*Lunar) MonthNaYin 

func (l *Lunar) MonthNaYin() string

MonthNaYin 返回月柱纳音。

func (*Lunar) MonthNineStar 

func (l *Lunar) MonthNineStar() *NineStar

MonthNineStar 返回月九星（民间流派）。

func (*Lunar) MonthNineStarBySect 

func (l *Lunar) MonthNineStarBySect(sect Sect) *NineStar

MonthNineStarBySect 按流派返回月九星。

func (*Lunar) MonthPositionTai 

func (l *Lunar) MonthPositionTai() string

MonthPositionTai 返回月胎神占位。

func (*Lunar) MonthPositionTaiSui 

func (l *Lunar) MonthPositionTaiSui() string

MonthPositionTaiSui 返回月太岁方位（民间流派）。

func (*Lunar) MonthPositionTaiSuiBySect 

func (l *Lunar) MonthPositionTaiSuiBySect(sect Sect) string

MonthPositionTaiSuiBySect 按流派返回月太岁方位。

func (*Lunar) MonthPositionTaiSuiDesc 

func (l *Lunar) MonthPositionTaiSuiDesc() string

MonthPositionTaiSuiDesc 返回月太岁方位说明。

func (*Lunar) MonthPositionTaiSuiDescBySect 

func (l *Lunar) MonthPositionTaiSuiDescBySect(sect Sect) string

MonthPositionTaiSuiDescBySect 按流派返回月太岁方位说明。

func (*Lunar) MonthShengXiao 

func (l *Lunar) MonthShengXiao() string

MonthShengXiao 返回月生肖。

func (*Lunar) MonthXun 

func (l *Lunar) MonthXun() string

MonthXun 返回月旬（以节交接当日起算）。

func (*Lunar) MonthXunExact 

func (l *Lunar) MonthXunExact() string

MonthXunExact 返回月旬（以节交接时刻起算）。

func (*Lunar) MonthXunKong 

func (l *Lunar) MonthXunKong() string

MonthXunKong 返回月空亡（以节交接当日起算）。

func (*Lunar) MonthXunKongExact 

func (l *Lunar) MonthXunKongExact() string

MonthXunKongExact 返回月空亡（以节交接时刻起算）。

func (*Lunar) MonthZhi 

func (l *Lunar) MonthZhi() string

MonthZhi 返回月支。

func (*Lunar) MonthZhiExact 

func (l *Lunar) MonthZhiExact() string

MonthZhiExact 返回月支（精确变体）。

func (*Lunar) MonthZhiIndex 

func (l *Lunar) MonthZhiIndex() int

MonthZhiIndex 返回月支序。

func (*Lunar) MonthZhiIndexExact 

func (l *Lunar) MonthZhiIndexExact() int

MonthZhiIndexExact 返回月支序（精确）。

func (*Lunar) Next 

func (l *Lunar) Next(days int) *Lunar

Next 返回 days 天后的农历（负数为向前推）。

func (*Lunar) NextJie 

func (l *Lunar) NextJie() *JieQi

NextJie 返回下一节令（按时刻）。

func (*Lunar) NextJieByWholeDay 

func (l *Lunar) NextJieByWholeDay(wholeDay bool) *JieQi

NextJieByWholeDay 返回下一节令（wholeDay=true 按整日比较）。

func (*Lunar) NextJieQi 

func (l *Lunar) NextJieQi() *JieQi

NextJieQi 返回下一节气（节令或气令）。

func (*Lunar) NextJieQiByWholeDay 

func (l *Lunar) NextJieQiByWholeDay(wholeDay bool) *JieQi

NextJieQiByWholeDay 返回下一节气（wholeDay=true 按整日比较）。

func (*Lunar) NextMoonPhase 

func (l *Lunar) NextMoonPhase() (MoonPhaseEvent, error)

NextMoonPhase 返回此刻之后最近的一次月相事件（代理到公历时刻）。

Example 
// 农历乙巳年正月初一（公历 2025-01-29）当天的朔时刻
ev, _ := MustNewLunar(2025, 1, 1).NextMoonPhase()
fmt.Println(ev.Phase, ev.Solar.ToYmdHms())

Output:
朔 2025-01-29 20:35:33

func (*Lunar) NextQi 

func (l *Lunar) NextQi() *JieQi

NextQi 返回下一气令。

func (*Lunar) NextQiByWholeDay 

func (l *Lunar) NextQiByWholeDay(wholeDay bool) *JieQi

NextQiByWholeDay 返回下一气令（wholeDay=true 按整日比较）。

func (*Lunar) OtherFestivals 

func (l *Lunar) OtherFestivals() []string

OtherFestivals 返回当日其他农历节日/纪念日（含寒食/春社/秋社）。

func (*Lunar) PengZuGan 

func (l *Lunar) PengZuGan() string

PengZuGan 返回彭祖百忌（天干）。

func (*Lunar) PengZuZhi 

func (l *Lunar) PengZuZhi() string

PengZuZhi 返回彭祖百忌（地支）。

func (*Lunar) PositionSanSha 

func (l *Lunar) PositionSanSha() string

PositionSanSha 返回当日所在农历年的三煞方位（代理到所在农历年）。

func (*Lunar) PositionSanShaDesc 

func (l *Lunar) PositionSanShaDesc() string

PositionSanShaDesc 返回当日所在农历年的三煞方位说明（代理到所在农历年）。

func (*Lunar) PrevJie 

func (l *Lunar) PrevJie() *JieQi

PrevJie 返回上一节令（按时刻）。

func (*Lunar) PrevJieByWholeDay 

func (l *Lunar) PrevJieByWholeDay(wholeDay bool) *JieQi

PrevJieByWholeDay 返回上一节令（wholeDay=true 按整日比较）。

func (*Lunar) PrevJieQi 

func (l *Lunar) PrevJieQi() *JieQi

PrevJieQi 返回上一节气。

func (*Lunar) PrevJieQiByWholeDay 

func (l *Lunar) PrevJieQiByWholeDay(wholeDay bool) *JieQi

PrevJieQiByWholeDay 返回上一节气（wholeDay=true 按整日比较）。

func (*Lunar) PrevMoonPhase 

func (l *Lunar) PrevMoonPhase() (MoonPhaseEvent, error)

PrevMoonPhase 返回此刻之前（含相等）最近的一次月相事件。

func (*Lunar) PrevQi 

func (l *Lunar) PrevQi() *JieQi

PrevQi 返回上一气令。

func (*Lunar) PrevQiByWholeDay 

func (l *Lunar) PrevQiByWholeDay(wholeDay bool) *JieQi

PrevQiByWholeDay 返回上一气令（wholeDay=true 按整日比较）。

func (*Lunar) Qi 

func (l *Lunar) Qi() string

Qi 返回当天气令名（冬至/大寒/雨水……）；无则空。

func (*Lunar) Season 

func (l *Lunar) Season() string

Season 返回农历季节名（孟春……季冬）。

func (*Lunar) Second 

func (l *Lunar) Second() int

Second 返回秒。

func (*Lunar) ShanInfo 

func (l *Lunar) ShanInfo(shan string) *ShanInfo

ShanInfo 返回指定坐山的综合适配信息（太阳/太阴到山到向三合照一次取齐）。 shan 非法时返回 nil。 注：方法与返回类型同名（Go 命名空间合法），对应 v2 无 Get 前缀约定。

func (*Lunar) Shou 

func (l *Lunar) Shou() string

Shou 返回宫位对应神兽。

func (*Lunar) ShuJiu 

func (l *Lunar) ShuJiu() *ShuJiu

ShuJiu 返回数九；非数九天返回 nil。

func (*Lunar) SiLiSiJue 

func (l *Lunar) SiLiSiJue() string

SiLiSiJue 返回当日四离四绝标识；非四离四绝日返回空串。 如冬至前一日返回 "四离(冬至前一日)"，立春前一日返回 "四绝(立春前一日)"。

Example

民间择吉：四离四绝与禁忌速查。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	s, _ := lunar.NewSolar(2025, 12, 20)
	l := s.Lunar()

	fmt.Println(l.SiLiSiJue())
	fmt.Println(l.FolkTaboos())
}

Output:
四离(冬至前一日)
[岁破 四离(冬至前一日)]

func (*Lunar) Solar 

func (l *Lunar) Solar() Solar

Solar 返回对应公历。

func (*Lunar) String 

func (l *Lunar) String() string

String 返回如 "二〇二〇年四月十三"。

func (*Lunar) TaiSuiDeity 

func (l *Lunar) TaiSuiDeity() TaiSuiDeity

TaiSuiDeity 返回当日值年太岁星君（代理到所在农历年，正月初一换年口径）。 立春口径（择日通书主流）见 TaiSuiDeityByLiChun。

Example

值年太岁：按日期取，正月初一换年（默认）与立春换年（择日通书主流）两派。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	// 2025-01-29 正月初一，立春（2025-02-03）前：换年窗口内两派太岁不同
	chunJie := lunar.MustSolar(2025, 1, 29).Lunar()
	liChun := lunar.MustSolar(2025, 2, 3).Lunar()
	fmt.Println(chunJie.TaiSuiDeity().String())
	fmt.Println(chunJie.TaiSuiDeityByLiChun().String())
	fmt.Println(liChun.TaiSuiDeityByLiChun().String())
}

Output:
吴遂大将军
李诚大将军
吴遂大将军

func (*Lunar) TaiSuiDeityByLiChun 

func (l *Lunar) TaiSuiDeityByLiChun() TaiSuiDeity

TaiSuiDeityByLiChun 返回当日值年太岁星君（立春换年口径，择日通书主流）。 正月初一至立春之间的日期，太岁仍属上一农历年：如 2025-01-29（正月初一、 立春 2025-02-03 前）立春口径太岁仍为甲辰李诚，正月初一口径已是乙巳吴遂。

func (*Lunar) TaiYangDaoShan 

func (l *Lunar) TaiYangDaoShan(shan string) *DaoShanResult

TaiYangDaoShan 判定当日太阳与指定坐山的关系（到山/到向/三合照）。

太阳为万宿之主，照临之方大小凶煞可制化，宜修造动土、安葬立坟： 

到向：上吉（光辉直照向方，取欣欣向荣之象）
三合照：次吉（光辉拱照坐山三合方）
到山：又次之（福山堂一派认为平民用之反招不利，唯帝王修造为宜，
      造福堂等日馆则照常取用——见 Note，按师承取舍）

仅白天用事（夜晚太阳无光难显其用）。shan 非法时返回 nil。

Example

天星择日：太阳到山到向三合照（2025-08-23 处暑区间，太阳在巳山）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	s, _ := lunar.NewSolar(2025, 8, 23)
	l := s.Lunar()

	for _, shan := range []string{"巳", "亥", "酉"} {
		if r := l.TaiYangDaoShan(shan); r.Relation != "" {
			fmt.Printf("%s山：%s（%s）%s\n", shan, r.Relation, r.Grade, r.Detail)
		}
	}
}

Output:
巳山：到山（又次之）处暑太阳到巳山
亥山：到向（上吉）处暑太阳到巳山，即亥山之向（亥山巳向）
酉山：三合照（次吉）处暑太阳到巳山，与酉山（金局（巽庚癸·巳酉丑））三合

func (*Lunar) TaiYangShan 

func (l *Lunar) TaiYangShan() string

TaiYangShan 返回当日节气区间太阳所在的山（到山驻留语义）。 非节气数据异常时返回空串。

func (*Lunar) TaiYinDaoShan 

func (l *Lunar) TaiYinDaoShan(shan string) *DaoShanResult

TaiYinDaoShan 判定当日太阴与指定坐山的关系（到山/到向/三合照）。

太阴母仪之象，至柔至顺，能压制众凶煞、遇难呈祥，宜夜晚用事。 到山乘时令得地气为吉；到向一派认为违反时令极凶（福山堂）、 一派照常取用（造福堂），见 Note，按师承取舍。shan 非法时返回 nil。

Example

天星择日：太阴到山（2025-02-10 立春区间，太阴在艮山）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	s, _ := lunar.NewSolar(2025, 2, 10)
	l := s.Lunar()

	r := l.TaiYinDaoShan("艮")
	fmt.Println(r.Relation, r.Grade, r.Detail)
}

Output:
到山 吉 立春太阴到艮山

func (*Lunar) TaiYinShan 

func (l *Lunar) TaiYinShan() string

TaiYinShan 返回当日节气区间太阴所在的山（到山驻留语义）。

func (*Lunar) TimeChong 

func (l *Lunar) TimeChong() string

TimeChong 返回时冲地支。

func (*Lunar) TimeChongDesc 

func (l *Lunar) TimeChongDesc() string

TimeChongDesc 返回时冲描述。

func (*Lunar) TimeChongGan 

func (l *Lunar) TimeChongGan() string

TimeChongGan 返回时冲天干。

func (*Lunar) TimeChongGanTie 

func (l *Lunar) TimeChongGanTie() string

TimeChongGanTie 返回时冲天干（贴身）。

func (*Lunar) TimeChongShengXiao 

func (l *Lunar) TimeChongShengXiao() string

TimeChongShengXiao 返回时冲生肖。

func (*Lunar) TimeGan 

func (l *Lunar) TimeGan() string

TimeGan 返回时干。

func (*Lunar) TimeGanIndex 

func (l *Lunar) TimeGanIndex() int

TimeGanIndex 返回时干序。

func (*Lunar) TimeInGanZhi 

func (l *Lunar) TimeInGanZhi() string

TimeInGanZhi 返回时柱干支。

func (*Lunar) TimeJi 

func (l *Lunar) TimeJi() []string

TimeJi 返回时辰忌。

func (*Lunar) TimeNaYin 

func (l *Lunar) TimeNaYin() string

TimeNaYin 返回时柱纳音。

func (*Lunar) TimeNineStar 

func (l *Lunar) TimeNineStar() *NineStar

TimeNineStar 返回时九星。

func (*Lunar) TimePositionCai 

func (l *Lunar) TimePositionCai() string

TimePositionCai 返回时财神方位。

func (*Lunar) TimePositionCaiDesc 

func (l *Lunar) TimePositionCaiDesc() string

TimePositionCaiDesc 返回时财神方位说明。

func (*Lunar) TimePositionFu 

func (l *Lunar) TimePositionFu() string

TimePositionFu 返回时福神方位。

func (*Lunar) TimePositionFuDesc 

func (l *Lunar) TimePositionFuDesc() string

TimePositionFuDesc 返回时福神方位说明。

func (*Lunar) TimePositionXi 

func (l *Lunar) TimePositionXi() string

TimePositionXi 返回时喜神方位。

func (*Lunar) TimePositionXiDesc 

func (l *Lunar) TimePositionXiDesc() string

TimePositionXiDesc 返回时喜神方位说明。

func (*Lunar) TimePositionYangGui 

func (l *Lunar) TimePositionYangGui() string

TimePositionYangGui 返回时阳贵方位。

func (*Lunar) TimePositionYangGuiDesc 

func (l *Lunar) TimePositionYangGuiDesc() string

TimePositionYangGuiDesc 返回时阳贵方位说明。

func (*Lunar) TimePositionYinGui 

func (l *Lunar) TimePositionYinGui() string

TimePositionYinGui 返回时阴贵方位。

func (*Lunar) TimePositionYinGuiDesc 

func (l *Lunar) TimePositionYinGuiDesc() string

TimePositionYinGuiDesc 返回时阴贵方位说明。

func (*Lunar) TimeSha 

func (l *Lunar) TimeSha() string

TimeSha 返回时煞方位。

func (*Lunar) TimeShengXiao 

func (l *Lunar) TimeShengXiao() string

TimeShengXiao 返回时生肖。

func (*Lunar) TimeTianShen 

func (l *Lunar) TimeTianShen() string

TimeTianShen 返回时辰天神。

func (*Lunar) TimeTianShenLuck 

func (l *Lunar) TimeTianShenLuck() string

TimeTianShenLuck 返回时辰天神吉凶。

func (*Lunar) TimeTianShenType 

func (l *Lunar) TimeTianShenType() string

TimeTianShenType 返回时辰天神类型。

func (*Lunar) TimeXun 

func (l *Lunar) TimeXun() string

TimeXun 返回时旬。

func (*Lunar) TimeXunKong 

func (l *Lunar) TimeXunKong() string

TimeXunKong 返回时空亡。

func (*Lunar) TimeYi 

func (l *Lunar) TimeYi() []string

TimeYi 返回时辰宜。

func (*Lunar) TimeZhi 

func (l *Lunar) TimeZhi() string

TimeZhi 返回时支。

func (*Lunar) TimeZhiIndex 

func (l *Lunar) TimeZhiIndex() int

TimeZhiIndex 返回时支序（0=子）。

func (*Lunar) Times 

func (l *Lunar) Times() []*LunarTime

Times 返回当日 12 个时辰（子时～亥时，时柱天干按当日日干五鼠遁起法）。 对应 v1 getTimes：早子时（00:00–00:59）与常时同用当日日干；若本 Lunar 时刻为 23 时（晚子），全部时辰按次日日干起遁（v1 同口径）。 晚子时（23:00–24:59）单独的时柱请用 NewLunarTimeFromLunar(MustNewLunarDateTime(y, m, d, 23, 0, 0)) 构造。

func (*Lunar) ToFullString 

func (l *Lunar) ToFullString() string

ToFullString 返回完整黄历描述（与 v1 输出逐字一致，golden 基线）。

func (*Lunar) Week 

func (l *Lunar) Week() int

Week 返回星期几（0=日 …… 6=六）。

func (*Lunar) WeekInChinese 

func (l *Lunar) WeekInChinese() string

WeekInChinese 返回星期中文名。

func (*Lunar) WuHou 

func (l *Lunar) WuHou() string

WuHou 返回物候（七十二候名）。

func (*Lunar) Xiu 

func (l *Lunar) Xiu() string

Xiu 返回当日星宿。

func (*Lunar) XiuLuck 

func (l *Lunar) XiuLuck() string

XiuLuck 返回星宿吉凶。

func (*Lunar) XiuSong 

func (l *Lunar) XiuSong() string

XiuSong 返回星宿歌诀。

func (*Lunar) Year 

func (l *Lunar) Year() int

Year 返回农历年。

func (*Lunar) YearGan 

func (l *Lunar) YearGan() string

YearGan 返回年干（以正月初一起算）。

func (*Lunar) YearGanByLiChun 

func (l *Lunar) YearGanByLiChun() string

YearGanByLiChun 返回年干（以立春当日起算）。

func (*Lunar) YearGanExact 

func (l *Lunar) YearGanExact() string

YearGanExact 返回年干（以立春交接时刻起算）。

func (*Lunar) YearGanIndex 

func (l *Lunar) YearGanIndex() int

YearGanIndex 返回年干序（0=甲）。

func (*Lunar) YearGanIndexByLiChun 

func (l *Lunar) YearGanIndexByLiChun() int

YearGanIndexByLiChun 返回年干序（立春当日）。

func (*Lunar) YearGanIndexExact 

func (l *Lunar) YearGanIndexExact() int

YearGanIndexExact 返回年干序（立春交接时刻）。

func (*Lunar) YearInChinese 

func (l *Lunar) YearInChinese() string

YearInChinese 返回中文年份（如 二〇二〇）。 负年份（公元前）保留负号前缀（如 -1 → "-一"）；非数字字符原样保留（零 panic 红线）。

func (*Lunar) YearInGanZhi 

func (l *Lunar) YearInGanZhi() string

YearInGanZhi 返回年柱干支（以正月初一起算）。

func (*Lunar) YearInGanZhiByLiChun 

func (l *Lunar) YearInGanZhiByLiChun() string

YearInGanZhiByLiChun 返回年柱干支（以立春当日起算）。

func (*Lunar) YearInGanZhiExact 

func (l *Lunar) YearInGanZhiExact() string

YearInGanZhiExact 返回年柱干支（以立春交接时刻起算）。

func (*Lunar) YearNaYin 

func (l *Lunar) YearNaYin() string

YearNaYin 返回年柱纳音。

func (*Lunar) YearNineStar 

func (l *Lunar) YearNineStar() *NineStar

YearNineStar 返回年九星（民间流派）。

func (*Lunar) YearNineStarBySect 

func (l *Lunar) YearNineStarBySect(sect Sect) *NineStar

YearNineStarBySect 按流派返回年九星。

func (*Lunar) YearPositionTaiSui 

func (l *Lunar) YearPositionTaiSui() string

YearPositionTaiSui 返回年太岁方位（民间流派）。

func (*Lunar) YearPositionTaiSuiBySect 

func (l *Lunar) YearPositionTaiSuiBySect(sect Sect) string

YearPositionTaiSuiBySect 按流派返回年太岁方位 （SectAncient 正月初一 / SectFolk 立春当日 / SectExact 立春交接时刻）。

func (*Lunar) YearPositionTaiSuiDesc 

func (l *Lunar) YearPositionTaiSuiDesc() string

YearPositionTaiSuiDesc 返回年太岁方位说明。

func (*Lunar) YearPositionTaiSuiDescBySect 

func (l *Lunar) YearPositionTaiSuiDescBySect(sect Sect) string

YearPositionTaiSuiDescBySect 按流派返回年太岁方位说明。

func (*Lunar) YearShengXiao 

func (l *Lunar) YearShengXiao() string

YearShengXiao 返回年生肖（以正月初一起算）。

func (*Lunar) YearShengXiaoByLiChun 

func (l *Lunar) YearShengXiaoByLiChun() string

YearShengXiaoByLiChun 返回年生肖（以立春当日起算）。

func (*Lunar) YearShengXiaoExact 

func (l *Lunar) YearShengXiaoExact() string

YearShengXiaoExact 返回年生肖（以立春交接时刻起算）。

func (*Lunar) YearXun 

func (l *Lunar) YearXun() string

YearXun 返回年旬（以正月初一起算）。

func (*Lunar) YearXunByLiChun 

func (l *Lunar) YearXunByLiChun() string

YearXunByLiChun 返回年旬（以立春当日起算）。

func (*Lunar) YearXunExact 

func (l *Lunar) YearXunExact() string

YearXunExact 返回年旬（以立春交接时刻起算）。

func (*Lunar) YearXunKong 

func (l *Lunar) YearXunKong() string

YearXunKong 返回年空亡（以正月初一起算）。

func (*Lunar) YearXunKongByLiChun 

func (l *Lunar) YearXunKongByLiChun() string

YearXunKongByLiChun 返回年空亡（以立春当日起算）。

func (*Lunar) YearXunKongExact 

func (l *Lunar) YearXunKongExact() string

YearXunKongExact 返回年空亡（以立春交接时刻起算）。

func (*Lunar) YearZhi 

func (l *Lunar) YearZhi() string

YearZhi 返回年支（以正月初一起算）。

func (*Lunar) YearZhiByLiChun 

func (l *Lunar) YearZhiByLiChun() string

YearZhiByLiChun 返回年支（以立春当日起算）。

func (*Lunar) YearZhiExact 

func (l *Lunar) YearZhiExact() string

YearZhiExact 返回年支（以立春交接时刻起算）。

func (*Lunar) YearZhiIndex 

func (l *Lunar) YearZhiIndex() int

YearZhiIndex 返回年支序（0=子）。

func (*Lunar) YearZhiIndexByLiChun 

func (l *Lunar) YearZhiIndexByLiChun() int

YearZhiIndexByLiChun 返回年支序（立春当日）。

func (*Lunar) YearZhiIndexExact 

func (l *Lunar) YearZhiIndexExact() int

YearZhiIndexExact 返回年支序（立春交接时刻）。

func (*Lunar) YueJiang 

func (l *Lunar) YueJiang() string

YueJiang 返回当日所处中气区间的月将（太阳过宫）地支。 月将随中气交接（交节当日起用新月将，与节气区间判定同口径）； 如雨水后春分前为亥将（登明）、夏至后大暑前为未将（小吉）。 节气数据异常时返回空串（理论上不发生）。

func (*Lunar) YueXiang 

func (l *Lunar) YueXiang() string

YueXiang 返回月相。

func (*Lunar) ZeRi 

func (l *Lunar) ZeRi(opt ZeRiOptions) *ZeRiResult

ZeRi 对当日做指定用事的择日评估（典籍铺注模式）。

评估维度（Reasons 逐条标记来源，分块渲染可直接按 Sect 分组）： 

典籍·铺注   DayYi/DayJi 对事件键的命中（依据《协纪辨方书》铺注条例数据）
典籍·黄黑道 DayTianShen 吉凶
典籍·建除   ZhiXing 值神及通行吉凶口诀
民俗·禁忌   FolkTaboosTagged 全流派逐条（含分歧口径）
天星·到山   太阳/太阴到山到向三合照（传入 Shan 时）
民俗·正冲   日支冲用事人年支（传入 UserZhi 时）
Example

分事择日：典籍铺注模式（判定依据逐条分块标记）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	s, _ := lunar.NewSolar(2025, 8, 23)
	l := s.Lunar()

	r := l.ZeRi(lunar.ZeRiOptions{Event: "动土", Shan: "申", UserZhi: "午"})
	fmt.Println("结论：", r.Verdict)
	for _, it := range r.Reasons {
		fmt.Printf("  [%s] %s：%s\n", it.Sect, it.Rule, it.Detail)
	}
}

Output:
结论： 平
  [典籍·铺注] 铺注：宜「动土、破土」
  [典籍·黄黑道] 黄黑道：青龙（吉）
  [典籍·建除] 建除：定日
  [民俗·禁忌（通行）] 杨公十三忌：七月初一
  [民俗·禁忌（通行）] 节气交接日：处暑
  [天星·到山] 太阴到山：处暑太阴到申山
  [民俗·正冲] 正冲：日支子冲用事人年支午

func (*Lunar) ZeRiScore 

func (l *Lunar) ZeRiScore(opt ZeRiOptions) *ZeRiScoreResult

ZeRiScore 对当日做加权评分（现代参考模式，非典籍方法）。

模型：基础分 60，按黄黑道、建除、吉凶神煞（封顶 ±20）、事件铺注 命中、民俗禁忌、天星到山、正冲逐项加减： 

≥85 上吉；≥70 吉；≥55 可用；≥40 平；<40 慎用

注意：加权评分为现代择日软件的启发式参考模型，《协纪辨方书》 的正统方法是分事铺注宜忌（见 ZeRi），两者并行不悖、各有用途—— 评分适合多候选日快速排序，铺注适合单日逐事定性。

Example

分事择日：现代加权评分参考模式（非典籍方法，多候选日排序用）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	s, _ := lunar.NewSolar(2025, 8, 23)
	l := s.Lunar()

	sc := l.ZeRiScore(lunar.ZeRiOptions{Event: "动土", Shan: "申", UserZhi: "午"})
	fmt.Println(sc.Score, sc.Level)
}

Output:
72 吉

func (*Lunar) Zheng 

func (l *Lunar) Zheng() string

Zheng 返回星宿七政。

func (*Lunar) ZhiXing 

func (l *Lunar) ZhiXing() string

ZhiXing 返回十二值日（建除十二神）。

type LunarMonth 

type LunarMonth struct {
	// contains filtered or unexported fields
}

LunarMonth 表示农历月；month 为负表示闰月（如 -2 表示闰二月）。

func NewLunarMonth 

func NewLunarMonth(year, month int) *LunarMonth

NewLunarMonth 返回某年某月（month 为负表示闰月）；不存在返回 nil。

func (LunarMonth) DayCount 

func (m LunarMonth) DayCount() int

DayCount 返回该月天数（29 或 30）。

func (LunarMonth) FirstJulianDay 

func (m LunarMonth) FirstJulianDay() float64

FirstJulianDay 返回该月首日（初一）的儒略日。

func (LunarMonth) Gan 

func (m LunarMonth) Gan() string

Gan 返回月干。

func (LunarMonth) GanIndex 

func (m LunarMonth) GanIndex() int

GanIndex 返回月干序（0=甲）。

func (LunarMonth) GanZhi 

func (m LunarMonth) GanZhi() string

GanZhi 返回月柱干支。

func (LunarMonth) Index 

func (m LunarMonth) Index() int

Index 返回该月以正月为 1 起算的序号。

func (LunarMonth) IsLeap 

func (m LunarMonth) IsLeap() bool

IsLeap 报告是否闰月。

func (LunarMonth) Month 

func (m LunarMonth) Month() int

Month 返回农历月（负数表示闰月）。

func (LunarMonth) Next 

func (m LunarMonth) Next(n int) *LunarMonth

Next 返回相对本月第 n 个月（n 可负；越界返回 nil）。

func (LunarMonth) NineStar 

func (m LunarMonth) NineStar() *NineStar

NineStar 返回月九星。

func (LunarMonth) PositionCai 

func (m LunarMonth) PositionCai() string

PositionCai 返回月财神方位。

func (LunarMonth) PositionCaiDesc 

func (m LunarMonth) PositionCaiDesc() string

PositionCaiDesc 返回月财神方位说明。

func (LunarMonth) PositionFu 

func (m LunarMonth) PositionFu() string

PositionFu 返回月福神方位（民间流派）。

func (LunarMonth) PositionFuBySect 

func (m LunarMonth) PositionFuBySect(sect Sect) string

PositionFuBySect 按流派返回月福神方位。

func (LunarMonth) PositionFuDesc 

func (m LunarMonth) PositionFuDesc() string

PositionFuDesc 返回月福神方位说明。

func (LunarMonth) PositionFuDescBySect 

func (m LunarMonth) PositionFuDescBySect(sect Sect) string

PositionFuDescBySect 按流派返回月福神方位说明。

func (LunarMonth) PositionTaiSui 

func (m LunarMonth) PositionTaiSui() string

PositionTaiSui 返回月太岁方位。

func (LunarMonth) PositionTaiSuiDesc 

func (m LunarMonth) PositionTaiSuiDesc() string

PositionTaiSuiDesc 返回月太岁方位说明。

func (LunarMonth) PositionXi 

func (m LunarMonth) PositionXi() string

PositionXi 返回月喜神方位。

func (LunarMonth) PositionXiDesc 

func (m LunarMonth) PositionXiDesc() string

PositionXiDesc 返回月喜神方位说明。

func (LunarMonth) PositionYangGui 

func (m LunarMonth) PositionYangGui() string

PositionYangGui 返回月阳贵方位。

func (LunarMonth) PositionYangGuiDesc 

func (m LunarMonth) PositionYangGuiDesc() string

PositionYangGuiDesc 返回月阳贵方位说明。

func (LunarMonth) PositionYinGui 

func (m LunarMonth) PositionYinGui() string

PositionYinGui 返回月阴贵方位。

func (LunarMonth) PositionYinGuiDesc 

func (m LunarMonth) PositionYinGuiDesc() string

PositionYinGuiDesc 返回月阴贵方位说明。

func (LunarMonth) String 

func (m LunarMonth) String() string

String 返回如 "2020年四月(29)天"。

func (LunarMonth) Year 

func (m LunarMonth) Year() int

Year 返回农历年。

func (LunarMonth) Zhi 

func (m LunarMonth) Zhi() string

Zhi 返回月支。

func (LunarMonth) ZhiIndex 

func (m LunarMonth) ZhiIndex() int

ZhiIndex 返回月支序（0=子）。

type LunarTime 

type LunarTime struct {
	// contains filtered or unexported fields
}

LunarTime 表示时辰（含其所属农历日的上下文）。

func NewLunarTime 

func NewLunarTime(year, month, day, hour, minute, second int) (*LunarTime, error)

NewLunarTime 构造指定农历年月日时刻的时辰（对应 v1 calendar.NewLunarTime）。

func NewLunarTimeFromLunar 

func NewLunarTimeFromLunar(l *Lunar) *LunarTime

NewLunarTimeFromLunar 由农历时刻构造时辰。

func (*LunarTime) Chong 

func (lt *LunarTime) Chong() string

Chong 返回时冲地支。

func (*LunarTime) ChongDesc 

func (lt *LunarTime) ChongDesc() string

ChongDesc 返回时冲描述。

func (*LunarTime) ChongGan 

func (lt *LunarTime) ChongGan() string

ChongGan 返回时冲天干。

func (*LunarTime) ChongGanTie 

func (lt *LunarTime) ChongGanTie() string

ChongGanTie 返回时冲天干（贴身）。

func (*LunarTime) ChongShengXiao 

func (lt *LunarTime) ChongShengXiao() string

ChongShengXiao 返回时冲生肖。

func (*LunarTime) Gan 

func (lt *LunarTime) Gan() string

Gan 返回时干。

func (*LunarTime) GanIndex 

func (lt *LunarTime) GanIndex() int

GanIndex 返回时干序。

func (*LunarTime) GanZhi 

func (lt *LunarTime) GanZhi() string

GanZhi 返回时柱干支。

func (*LunarTime) IsGuiDengTianMen 

func (lt *LunarTime) IsGuiDengTianMen() bool

IsGuiDengTianMen 判断当前时辰是否当日的贵登天门时（阳贵或阴贵 任一命中即真，默认协纪定例；昼夜细分请用 GuiDengTianMen 按 GuiType 取用）。

Example

专业时辰层：时辰级贵登天门判定。2025-02-24 甲子日卯时 （雨水后亥将，阳贵未加乾亥）为贵登天门时。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	mao := lunar.NewLunarTimeFromLunar(lunar.MustNewLunarDateTime(2025, 1, 27, 6, 0, 0))
	chen := lunar.NewLunarTimeFromLunar(lunar.MustNewLunarDateTime(2025, 1, 27, 8, 0, 0))

	fmt.Println(mao.GanZhi(), mao.IsGuiDengTianMen())
	fmt.Println(chen.GanZhi(), chen.IsGuiDengTianMen())
}

Output:
丁卯 true
戊辰 false

func (*LunarTime) IsRiLu 

func (lt *LunarTime) IsRiLu() bool

IsRiLu 判断当前时辰是否日禄归时（时支为日干禄位）。

禄即十干临官之位：「甲禄在寅、乙禄在卯、丙戊禄在巳、丁己禄在 午、庚禄在申、辛禄在酉、壬禄在亥、癸禄在子」（出《五行大义》 及子平诸书）。《协纪辨方书》卷七：「神煞起例有八禄时，本日之 禄位也，定为吉时」——日禄归时主食禄临身，宜求财、赴任、见贵， 通书与黄黑道、贵登天门并列为时家吉时。

Example

专业时辰层：日禄归时（时支为日干禄位，「八禄时」）。 甲禄在寅——甲子日丙寅时即日禄归时。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	l := lunar.MustNewLunarDateTime(2025, 1, 27, 4, 0, 0) // 甲子日寅时
	lt := lunar.NewLunarTimeFromLunar(l)

	fmt.Println(l.DayInGanZhi(), lt.GanZhi(), lt.IsRiLu())
}

Output:
甲子 丙寅 true

func (*LunarTime) IsWuBuYu 

func (lt *LunarTime) IsWuBuYu() bool

IsWuBuYu 判断当前时辰是否五不遇时（时干克日干）。

《协纪辨方书》卷七神煞起例：「五不遇时，时干尅日干也」，并引 遁甲歌「时尅干兮五不遇，此时名为辱损明，举事遥遥终不定， 朝行暮败损精兵」——时干五行克日干五行（如甲日庚午时，庚金克 甲木），主谋事反复、举事不定，百事不宜。日干按晚子时日柱算 明天（DayGanIndexExact，与 NewLunarTimeFromLunar 时干起遁同源）。 另有「时支克日支亦为五不遇」的遁甲注家异说，协纪考原已辨其 「不若神煞起例之善」，不取。

Example

专业时辰层：五不遇时（时干克日干，《协纪辨方书》卷七 「五不遇时，时干尅日干也」）。甲子日庚午时，庚金克甲木。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	l := lunar.MustNewLunarDateTime(2025, 1, 27, 12, 0, 0)                               // 农历正月廿七 = 2025-02-24 甲子日
	wu := lunar.NewLunarTimeFromLunar(l)                                                 // 午时
	yin := lunar.NewLunarTimeFromLunar(lunar.MustNewLunarDateTime(2025, 1, 27, 4, 0, 0)) // 寅时

	fmt.Println(l.DayInGanZhi(), wu.GanZhi(), wu.IsWuBuYu())
	fmt.Println(l.DayInGanZhi(), yin.GanZhi(), yin.IsWuBuYu())
}

Output:
甲子 庚午 true
甲子 丙寅 false

func (*LunarTime) Ji 

func (lt *LunarTime) Ji() []string

Ji 返回时辰忌。

func (*LunarTime) MaxHm 

func (lt *LunarTime) MaxHm() string

MaxHm 返回当前时辰最晚时分。

func (*LunarTime) MinHm 

func (lt *LunarTime) MinHm() string

MinHm 返回当前时辰最早时分。

func (*LunarTime) NaYin 

func (lt *LunarTime) NaYin() string

NaYin 返回时柱纳音。

func (*LunarTime) NineStar 

func (lt *LunarTime) NineStar() *NineStar

NineStar 返回时九星。

func (*LunarTime) PositionCai 

func (lt *LunarTime) PositionCai() string

PositionCai 返回时财神方位。

func (*LunarTime) PositionCaiDesc 

func (lt *LunarTime) PositionCaiDesc() string

PositionCaiDesc 返回时财神方位说明。

func (*LunarTime) PositionFu 

func (lt *LunarTime) PositionFu() string

PositionFu 返回时福神方位（民间流派）。

func (*LunarTime) PositionFuBySect 

func (lt *LunarTime) PositionFuBySect(sect Sect) string

PositionFuBySect 按流派返回时福神方位。

func (*LunarTime) PositionFuDesc 

func (lt *LunarTime) PositionFuDesc() string

PositionFuDesc 返回时福神方位说明。

func (*LunarTime) PositionFuDescBySect 

func (lt *LunarTime) PositionFuDescBySect(sect Sect) string

PositionFuDescBySect 按流派返回时福神方位说明。

func (*LunarTime) PositionXi 

func (lt *LunarTime) PositionXi() string

PositionXi 返回时喜神方位。

func (*LunarTime) PositionXiDesc 

func (lt *LunarTime) PositionXiDesc() string

PositionXiDesc 返回时喜神方位说明。

func (*LunarTime) PositionYangGui 

func (lt *LunarTime) PositionYangGui() string

PositionYangGui 返回时阳贵方位。

func (*LunarTime) PositionYangGuiDesc 

func (lt *LunarTime) PositionYangGuiDesc() string

PositionYangGuiDesc 返回时阳贵方位说明。

func (*LunarTime) PositionYinGui 

func (lt *LunarTime) PositionYinGui() string

PositionYinGui 返回时阴贵方位。

func (*LunarTime) PositionYinGuiDesc 

func (lt *LunarTime) PositionYinGuiDesc() string

PositionYinGuiDesc 返回时阴贵方位说明。

func (*LunarTime) Sha 

func (lt *LunarTime) Sha() string

Sha 返回时煞方位。

func (*LunarTime) ShengXiao 

func (lt *LunarTime) ShengXiao() string

ShengXiao 返回时生肖。

func (*LunarTime) String 

func (lt *LunarTime) String() string

String 返回时柱干支。

func (*LunarTime) TianShen 

func (lt *LunarTime) TianShen() string

TianShen 返回时辰天神。

func (*LunarTime) TianShenLuck 

func (lt *LunarTime) TianShenLuck() string

TianShenLuck 返回时辰天神吉凶。

func (*LunarTime) TianShenType 

func (lt *LunarTime) TianShenType() string

TianShenType 返回时辰天神类型。

func (*LunarTime) Xun 

func (lt *LunarTime) Xun() string

Xun 返回时辰所在旬。

func (*LunarTime) XunKong 

func (lt *LunarTime) XunKong() string

XunKong 返回值时空亡。

func (*LunarTime) Yi 

func (lt *LunarTime) Yi() []string

Yi 返回时辰宜。

func (*LunarTime) Zhi 

func (lt *LunarTime) Zhi() string

Zhi 返回时支。

func (*LunarTime) ZhiIndex 

func (lt *LunarTime) ZhiIndex() int

ZhiIndex 返回时支序（0=子）。

type LunarYear 

type LunarYear struct {
	// contains filtered or unexported fields
}

LunarYear 表示农历年（含全部月序与节气表；数据来自缓存，只读共享）。

Example

年视图：闰月与年景。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	year := lunar.NewLunarYear(2020)

	fmt.Println("闰月:", year.LeapMonth())
	fmt.Println("天数:", year.DayCount())
	fmt.Println("治水:", year.ZhiShui())
}

Output:
闰月: 4
天数: 384
治水: 二龙治水

func LunarYearOfYear 

func LunarYearOfYear(year int) *LunarYear

LunarYearOfYear 为内部别名（与 NewLunarYear 等价）。

func NewLunarYear 

func NewLunarYear(year int) *LunarYear

NewLunarYear 返回农历年（任意年份均可推算；构建结果全局缓存共享）。

func (*LunarYear) CaoZi 

func (y *LunarYear) CaoZi() string

CaoZi 返回「草子几分」。

func (*LunarYear) DayCount 

func (y *LunarYear) DayCount() int

DayCount 返回本年总天数。

func (*LunarYear) DeJin 

func (y *LunarYear) DeJin() string

DeJin 返回「几日得金」。

func (*LunarYear) FenBing 

func (y *LunarYear) FenBing() string

FenBing 返回「几人分饼」。

func (*LunarYear) Gan 

func (y *LunarYear) Gan() string

Gan 返回年干。

func (*LunarYear) GanIndex 

func (y *LunarYear) GanIndex() int

GanIndex 返回年干序（0=甲）。

func (*LunarYear) GanZhi 

func (y *LunarYear) GanZhi() string

GanZhi 返回年柱干支。

func (*LunarYear) GengTian 

func (y *LunarYear) GengTian() string

GengTian 返回「几牛耕田」。

func (*LunarYear) GongZhu 

func (y *LunarYear) GongZhu() string

GongZhu 返回「几屠共猪」。

func (*LunarYear) HuaShou 

func (y *LunarYear) HuaShou() string

HuaShou 返回「花收几分」。

func (*LunarYear) JiaTian 

func (y *LunarYear) JiaTian() string

JiaTian 返回「甲田几分」。

func (*LunarYear) JieQiJulianDays 

func (y *LunarYear) JieQiJulianDays() []float64

JieQiJulianDays 返回 31 键节气儒略日（与 jieQiInUse 平行）。

func (*LunarYear) KanCan 

func (y *LunarYear) KanCan() string

KanCan 返回「几姑看蚕」。

func (*LunarYear) LeapMonth 

func (y *LunarYear) LeapMonth() int

LeapMonth 返回闰月月份（0 表示本年无闰月）。

func (*LunarYear) Month 

func (y *LunarYear) Month(month int) *LunarMonth

Month 返回本年某月（month 负数表示闰月）；不存在返回 nil。

func (*LunarYear) Months 

func (y *LunarYear) Months() []LunarMonth

Months 返回全部 15 个月（自上年十一月起，跨年界）。

func (*LunarYear) MonthsInYear 

func (y *LunarYear) MonthsInYear() []LunarMonth

MonthsInYear 返回属于本年的月（正月或十一月起序，视年界而定）。

func (*LunarYear) Next 

func (y *LunarYear) Next(n int) *LunarYear

Next 返回 n 年后的农历年。

func (*LunarYear) NineStar 

func (y *LunarYear) NineStar() *NineStar

NineStar 返回年九星。

func (*LunarYear) PositionCai 

func (y *LunarYear) PositionCai() string

PositionCai 返回年财神方位。

func (*LunarYear) PositionCaiDesc 

func (y *LunarYear) PositionCaiDesc() string

PositionCaiDesc 返回年财神方位说明。

func (*LunarYear) PositionFu 

func (y *LunarYear) PositionFu() string

PositionFu 返回年福神方位（民间流派）。

func (*LunarYear) PositionFuBySect 

func (y *LunarYear) PositionFuBySect(sect Sect) string

PositionFuBySect 按流派返回年福神方位。

func (*LunarYear) PositionFuDesc 

func (y *LunarYear) PositionFuDesc() string

PositionFuDesc 返回年福神方位说明。

func (*LunarYear) PositionFuDescBySect 

func (y *LunarYear) PositionFuDescBySect(sect Sect) string

PositionFuDescBySect 按流派返回年福神方位说明。

func (*LunarYear) PositionSanSha 

func (y *LunarYear) PositionSanSha() string

PositionSanSha 返回年三煞方位（如 "南"）。 申子辰年煞南、巳酉丑年煞东、寅午戌年煞北、亥卯未年煞西。

Example

年三煞方位：申子辰煞南、巳酉丑煞东、寅午戌煞北、亥卯未煞西。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	for _, year := range []int{2024, 2025, 2026} {
		y := lunar.NewLunarYear(year)
		fmt.Println(y.GanZhi(), y.PositionSanSha(), y.PositionSanShaDesc())
	}
}

Output:
甲辰 南 南(巳午未)
乙巳 东 东(寅卯辰)
丙午 北 北(亥子丑)

func (*LunarYear) PositionSanShaDesc 

func (y *LunarYear) PositionSanShaDesc() string

PositionSanShaDesc 返回年三煞方位说明（如 "南(巳午未)"）， 三支依次为劫煞、灾煞、岁煞所临之支。

func (*LunarYear) PositionTaiSui 

func (y *LunarYear) PositionTaiSui() string

PositionTaiSui 返回年太岁方位。

func (*LunarYear) PositionTaiSuiDesc 

func (y *LunarYear) PositionTaiSuiDesc() string

PositionTaiSuiDesc 返回年太岁方位说明。

func (*LunarYear) PositionXi 

func (y *LunarYear) PositionXi() string

PositionXi 返回年喜神方位。

func (*LunarYear) PositionXiDesc 

func (y *LunarYear) PositionXiDesc() string

PositionXiDesc 返回年喜神方位说明。

func (*LunarYear) PositionYangGui 

func (y *LunarYear) PositionYangGui() string

PositionYangGui 返回年阳贵方位。

func (*LunarYear) PositionYangGuiDesc 

func (y *LunarYear) PositionYangGuiDesc() string

PositionYangGuiDesc 返回年阳贵方位说明。

func (*LunarYear) PositionYinGui 

func (y *LunarYear) PositionYinGui() string

PositionYinGui 返回年阴贵方位。

func (*LunarYear) PositionYinGuiDesc 

func (y *LunarYear) PositionYinGuiDesc() string

PositionYinGuiDesc 返回年阴贵方位说明。

func (*LunarYear) QiangMi 

func (y *LunarYear) QiangMi() string

QiangMi 返回「几鸡抢米」。

func (*LunarYear) RenBing 

func (y *LunarYear) RenBing() string

RenBing 返回「几人几丙」。

func (*LunarYear) RenChu 

func (y *LunarYear) RenChu() string

RenChu 返回「几人几锄」。

func (*LunarYear) String 

func (y *LunarYear) String() string

String 返回年份字符串。

func (*LunarYear) TaiSuiDeity 

func (y *LunarYear) TaiSuiDeity() TaiSuiDeity

TaiSuiDeity 返回该农历年的值年太岁星君（按年号干支）。

值年太岁以立春为岁首更替是择日通书主流口径：正月初一至立春之间的 日期，其值年太岁（立春口径）仍属上一农历年，见 Lunar.TaiSuiDeityByLiChun； 民俗安太岁则多随正月初一更替，见 Lunar.TaiSuiDeity。本方法按农历年号 干支直取，为整年视图。

Example

值年太岁：由农历年取太岁星君名讳（白云观元辰殿体系）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	y := lunar.NewLunarYear(2025)
	d := y.TaiSuiDeity()
	fmt.Println(d.GanZhi, d.String())
}

Output:
乙巳 吴遂大将军

func (*LunarYear) ToFullString 

func (y *LunarYear) ToFullString() string

ToFullString 返回如 "2020年"。

func (*LunarYear) TouLiang 

func (y *LunarYear) TouLiang() string

TouLiang 返回「几鼠偷粮」。

func (*LunarYear) TuoGu 

func (y *LunarYear) TuoGu() string

TuoGu 返回「几马驮谷」。

func (*LunarYear) Year 

func (y *LunarYear) Year() int

Year 返回年。

func (*LunarYear) Yuan 

func (y *LunarYear) Yuan() string

Yuan 返回「上元/中元/下元」。

func (*LunarYear) Yun 

func (y *LunarYear) Yun() string

Yun 返回「X运」。

func (*LunarYear) Zhi 

func (y *LunarYear) Zhi() string

Zhi 返回年支。

func (*LunarYear) ZhiIndex 

func (y *LunarYear) ZhiIndex() int

ZhiIndex 返回年支序（0=子）。

func (*LunarYear) ZhiShui 

func (y *LunarYear) ZhiShui() string

ZhiShui 返回「几龙治水」。

type MeiYu 

type MeiYu struct {
	In   *Date     `json:"in,omitempty"`   // 入梅日（nil 为防御路径，理论上必能找到）
	Out  *Date     `json:"out,omitempty"`  // 出梅日（同上）
	Base MeiYuBase `json:"base"`           // 所用口径
	Note string    `json:"note,omitempty"` // 口径出处备注
}

MeiYu 某公历年的梅雨区间（入梅日～出梅日，两端含）。

func (MeiYu) String 

func (m MeiYu) String() string

String 返回如 "2025-06-06～2025-07-13"（缺锚点时以 "?" 占位）。

type MeiYuBase 

type MeiYuBase int

MeiYuBase 入梅/出梅取日口径。 

const (
	// MeiYuTongXing 通行口径（默认）：芒种后第 1 个丙日入梅、
	// 小暑后第 1 个未日出梅。《神枢经》，现行历书主流。
	MeiYuTongXing MeiYuBase = iota
	// MeiYuJiangNan 江南壬日系：芒种后第 1 个壬日入梅、夏至后第
	// 1 个庚日出梅。《江南志书》/《碎金》系，吴俗（陆游《入梅并序》）。
	MeiYuJiangNan
	// MeiYuMinSu 闽俗系：立夏后第 1 个庚日入梅、芒种后第 1 个
	// 壬日出梅。《月日纪古》引闽俗；出梅另有「芒种后逢辰日」异文。
	MeiYuMinSu
)

type MoonPhaseEvent 

type MoonPhaseEvent struct {
	Phase string // 朔 / 上弦 / 望 / 下弦
	Solar Solar  // 精确时刻（北京时间，东八区）
}

MoonPhaseEvent 一次月相事件。

type NianJing 

type NianJing struct {
	TouLiang string `json:"touLiang"` // 几鼠偷粮
	CaoZi    string `json:"caoZi"`    // 草子几分
	GengTian string `json:"gengTian"` // 几牛耕田
	HuaShou  string `json:"huaShou"`  // 花收几分
	ZhiShui  string `json:"zhiShui"`  // 几龙治水
	TuoGu    string `json:"tuoGu"`    // 几马驮谷
	QiangMi  string `json:"qiangMi"`  // 几鸡抢米
	KanCan   string `json:"kanCan"`   // 几姑看蚕
	GongZhu  string `json:"gongZhu"`  // 几屠共猪
	JiaTian  string `json:"jiaTian"`  // 甲田几分
	FenBing  string `json:"fenBing"`  // 几人分饼
	DeJin    string `json:"deJin"`    // 几日得金
	RenBing  string `json:"renBing"`  // 几人几丙
	RenChu   string `json:"renChu"`   // 几人几锄
}

NianJing 年景歌诀（灶马头农事年成占诀，聚合 LunarYear 十四法； 归属当日所在农历年，键为小驼峰拼音）。

type NineStar 

type NineStar struct {
	// contains filtered or unexported fields
}

NineStar 表示九星。

func NewNineStar 

func NewNineStar(index int) *NineStar

NewNineStar 构造九星。

func (*NineStar) BaMenInQiMen 

func (ns *NineStar) BaMenInQiMen() string

BaMenInQiMen 返回奇门八门。

func (*NineStar) Color 

func (ns *NineStar) Color() string

Color 返回七色。

func (*NineStar) Index 

func (ns *NineStar) Index() int

Index 返回九星序（0-8）。

func (*NineStar) LuckInQiMen 

func (ns *NineStar) LuckInQiMen() string

LuckInQiMen 返回奇门吉凶。

func (*NineStar) LuckInXuanKong 

func (ns *NineStar) LuckInXuanKong() string

LuckInXuanKong 返回玄空吉凶。

func (*NineStar) NameInBeiDou 

func (ns *NineStar) NameInBeiDou() string

NameInBeiDou 返回北斗九星名。

func (*NineStar) NameInQiMen 

func (ns *NineStar) NameInQiMen() string

NameInQiMen 返回奇门九星名。

func (*NineStar) NameInTaiYi 

func (ns *NineStar) NameInTaiYi() string

NameInTaiYi 返回太乙九神名。

func (*NineStar) NameInXuanKong 

func (ns *NineStar) NameInXuanKong() string

NameInXuanKong 返回玄空九星名。

func (*NineStar) Number 

func (ns *NineStar) Number() string

Number 返回九数（一~九）。

func (*NineStar) Position 

func (ns *NineStar) Position() string

Position 返回后天八卦方位。

func (*NineStar) PositionDesc 

func (ns *NineStar) PositionDesc() string

PositionDesc 返回方位说明。

func (*NineStar) SongInTaiYi 

func (ns *NineStar) SongInTaiYi() string

SongInTaiYi 返回太乙九神歌诀。

func (*NineStar) String 

func (ns *NineStar) String() string

String 返回如 "一白水天枢"。

func (*NineStar) ToFullString 

func (ns *NineStar) ToFullString() string

ToFullString 返回完整九星描述。

func (*NineStar) TypeInTaiYi 

func (ns *NineStar) TypeInTaiYi() string

TypeInTaiYi 返回太乙九神类型。

func (*NineStar) WuXing 

func (ns *NineStar) WuXing() string

WuXing 返回五行。

func (*NineStar) YinYangInQiMen 

func (ns *NineStar) YinYangInQiMen() string

YinYangInQiMen 返回奇门阴阳。

type Sect 

type Sect int

Sect 表示八字流派（晚子时日柱口径）与部分按流派 API 的换年口径。

  • SectAncient 古法（晚子时日柱算当天；换年口径为正月初一）
  • SectFolk 民间（晚子时日柱算明天，默认；换年口径为立春当日）
  • SectExact 精确（按节气交接时刻换年；仅 *BySect 年界类 API 支持）
const (
	SectAncient Sect = iota + 1 // 古法
	SectFolk                    // 民间（默认）
	SectExact                   // 精确（按节气交接时刻换年）
)

func (Sect) String 

func (s Sect) String() string

String 实现 fmt.Stringer。

type ShanInfo 

type ShanInfo struct {
	Shan     string         `json:"shan"`     // 坐山
	Opposite string         `json:"opposite"` // 到向（对冲山）
	SanHe    [2]string      `json:"sanHe"`    // 三合照两山
	Ju       string         `json:"ju"`       // 所属三合局（双山五行）
	TaiYang  *DaoShanResult `json:"taiYang"`  // 太阳判定
	TaiYin   *DaoShanResult `json:"taiYin"`   // 太阴判定
	JieQi    string         `json:"jieQi"`    // 当日所处节气
}

ShanInfo 坐山综合信息（二十四山适配一次取齐）。

type ShuJiu 

type ShuJiu struct {
	// contains filtered or unexported fields
}

ShuJiu 表示数九。

func (*ShuJiu) Index 

func (sj *ShuJiu) Index() int

Index 返回第几天（1-9）。

func (*ShuJiu) Name 

func (sj *ShuJiu) Name() string

Name 返回名称（一九……九九）。

func (*ShuJiu) String 

func (sj *ShuJiu) String() string

String 返回名称。

func (*ShuJiu) ToFullString 

func (sj *ShuJiu) ToFullString() string

ToFullString 返回如 "一九第3天"。

type Solar 

type Solar struct {
	// contains filtered or unexported fields
}

Solar 为公历日期时间（值类型，计划 T1.1：6 个 int 字段 ≈48B—— 栈分配、可比较、可拷贝、构造零堆分配）。

支持年份域：约公元前 4713 年 ~ 公元 9999 年（受儒略日换算限制）； 1582-10-05 ~ 14 为儒略历改革空档，构造返回 ErrJulianGap。

并发语义：值类型天然并发安全（构造后只读）。

func FromJulianDay 

func FromJulianDay(julianDay float64) (Solar, error)

FromJulianDay 由儒略日（UT）构造。 儒略日超出公历支持域（公元前 4713 ~ 公元 9999 年）时返回包装 ErrInvalidYear 的错误（更远的年份天文表精度失效，v2 零 panic 红线要求显式拒绝）。

func MustSolar 

func MustSolar(year, month, day int) Solar

MustSolar 构造公历日期，非法输入 panic。仅建议字面量常量使用。

func MustSolarTime 

func MustSolarTime(year, month, day, hour, minute, second int) Solar

MustSolarTime 构造公历日期时间，非法输入 panic。仅建议字面量常量使用。

func NewSolar 

func NewSolar(year, month, day int) (Solar, error)

NewSolar 构造公历日期（零时）；值域错误返回包装 ErrInvalidDate / ErrJulianGap 的错误。

func NewSolarTime 

func NewSolarTime(year, month, day, hour, minute, second int) (Solar, error)

NewSolarTime 构造公历日期时间。

func SolarFromBaZi 

func SolarFromBaZi(yearGanZhi, monthGanZhi, dayGanZhi, timeGanZhi string) ([]Solar, error)

SolarFromBaZi 由八字四柱反推公历时刻（民间流派，baseYear=1900）。 yearGanZhi/monthGanZhi/dayGanZhi/timeGanZhi 为年/月/日/时柱干支（如 "丙寅"）。 干支非法返回 ErrInvalidGanZhi；无匹配时刻返回空切片。

Example

八字反推：由四柱求公历时刻。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	list, err := lunar.SolarFromBaZi("丙辰", "丁酉", "丙子", "甲午")
	if err != nil {
		panic(err)
	}
	for _, s := range list {
		fmt.Println(s.ToYmdHms())
	}
}

Output:
1916-10-06 12:00:00
1976-09-21 12:00:00

func SolarFromBaZiBySect 

func SolarFromBaZiBySect(yearGanZhi, monthGanZhi, dayGanZhi, timeGanZhi string, sect Sect) ([]Solar, error)

SolarFromBaZiBySect 按流派反推（SectFolk 晚子时日柱算当天，SectAncient 算明天）。

func SolarFromBaZiBySectAndBaseYear 

func SolarFromBaZiBySectAndBaseYear(yearGanZhi, monthGanZhi, dayGanZhi, timeGanZhi string, sect Sect, baseYear int) ([]Solar, error)

SolarFromBaZiBySectAndBaseYear 指定起算年份反推（v1 ListSolarFromBaZiBySectAndBaseYear）。 搜索范围：baseYear-1 起、以年柱 60 年周期逐窗推进至当前年份。

func SolarFromTime 

func SolarFromTime(t time.Time) Solar

SolarFromTime 由 time.Time 构造公历（取其年月日时分秒）。

func (Solar) After 

func (s Solar) After(other Solar) bool

After 报告 s 是否晚于 other。

func (Solar) Before 

func (s Solar) Before(other Solar) bool

Before 报告 s 是否早于 other（精确到秒）。

func (Solar) Day 

func (s Solar) Day() int

Day 返回日。

func (Solar) Festivals 

func (s Solar) Festivals() []string

Festivals 返回当日公历节日（按日期定义 + 按周序定义）。

func (Solar) Format 

func (s Solar) Format(layout string) string

Format 按 Go time 布局输出（如 "2006-01-02"、"2006年01月02日 15:04"）。 年份超出 [1,9999] 时的输出与 Go time 包行为一致。

func (Solar) FormatChinese 

func (s Solar) FormatChinese() string

FormatChinese 返回 "2020年01月01日" 形态。

func (Solar) Hour 

func (s Solar) Hour() int

Hour 返回时（0-23）。

func (Solar) IsLeapYear 

func (s Solar) IsLeapYear() bool

IsLeapYear 判断所在年是否为闰年。

func (Solar) JulianDay 

func (s Solar) JulianDay() float64

JulianDay 返回儒略日（UT）。

func (Solar) Lunar 

func (s Solar) Lunar() *Lunar

Lunar 返回对应农历（依赖年表缓存，热路径 ≤5µs 验收）。

Example

基础转换：公历 ⇄ 农历。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	solar := lunar.MustSolar(2020, 1, 25)
	lunarDay := solar.Lunar()

	fmt.Println(lunarDay.String())
	fmt.Println(lunarDay.YearInGanZhi(), lunarDay.MonthInGanZhi(), lunarDay.DayInGanZhi())
}

Output:
二〇二〇年正月初一
庚子 丁丑 丁卯

func (Solar) MarshalJSON 

func (s Solar) MarshalJSON() ([]byte, error)

MarshalJSON 输出 "2006-01-02 15:04:05" 字符串（API 服务刚需）。

func (Solar) Minute 

func (s Solar) Minute() int

Minute 返回分（0-59）。

func (Solar) Month 

func (s Solar) Month() int

Month 返回月（1-12）。

func (Solar) Next 

func (s Solar) Next(days int, onlyWorkday bool) Solar

Next 返回 days 天后；onlyWorkday 为 true 时跳过休息日 （以 HolidayStore 的调休数据为准，无数据时按周末）。

func (Solar) NextDay 

func (s Solar) NextDay(days int) Solar

NextDay 返回 days 天后（可为负；自动跨越 1582 儒略历洞）。

func (Solar) NextHour 

func (s Solar) NextHour(hours int) Solar

NextHour 返回 hours 小时后（可为负）。

func (Solar) NextMonth 

func (s Solar) NextMonth(months int) Solar

NextMonth 返回 months 月后（日超月末时钳位）。

func (Solar) NextMoonPhase 

func (s Solar) NextMoonPhase() (MoonPhaseEvent, error)

NextMoonPhase 返回 s 时刻之后最近的一次月相事件（四相中最早者）。

Example 
ev, _ := MustSolar(2025, 1, 1).NextMoonPhase()
fmt.Println(ev.Phase, ev.Solar.ToYmdHms())

Output:
上弦 2025-01-07 07:56:41

func (Solar) NextMoonPhaseOf 

func (s Solar) NextMoonPhaseOf(phase string) (MoonPhaseEvent, error)

NextMoonPhaseOf 返回 s 时刻之后最近一次指定月相的精确时刻。 phase 须取 MoonPhaseShuo / MoonPhaseShangXian / MoonPhaseWang / MoonPhaseXiaXian。

func (Solar) NextYear 

func (s Solar) NextYear(years int) Solar

NextYear 返回 years 年后（月日不变，2 月底等日期钳位到月末）。

func (Solar) OtherFestivals 

func (s Solar) OtherFestivals() []string

OtherFestivals 返回当日其他公历节日/纪念日。

func (Solar) PrevMoonPhase 

func (s Solar) PrevMoonPhase() (MoonPhaseEvent, error)

PrevMoonPhase 返回 s 时刻之前（含相等）最近的一次月相事件（四相中最晚者）。

func (Solar) PrevMoonPhaseOf 

func (s Solar) PrevMoonPhaseOf(phase string) (MoonPhaseEvent, error)

PrevMoonPhaseOf 返回 s 时刻之前（含相等）最近一次指定月相的精确时刻。

Example 
// 2025 年芒种后最近一次望（满月）
ev, _ := MustSolar(2025, 6, 15).PrevMoonPhaseOf(MoonPhaseWang)
fmt.Println(ev.Phase, ev.Solar.ToYmdHms(), FromSolar(ev.Solar).DayInChinese())

Output:
望 2025-06-11 15:46:35 十六

func (Solar) SalaryRate 

func (s Solar) SalaryRate() int

SalaryRate 返回工资倍率：3=法定节假日（元旦/劳动节/国庆前三天/春节前三天/端午/中秋/清明）， 2=休息日（周末或调休放假），1=工作日。

func (Solar) Second 

func (s Solar) Second() int

Second 返回秒（0-59）。

func (Solar) String 

func (s Solar) String() string

String 返回 "2006-01-02" 形态（保持 v1 ToYmd 兼容，golden 基线）。

func (Solar) Subtract 

func (s Solar) Subtract(other Solar) int

Subtract 返回 s 与 other 相差的天数（s - other，仅按日期计算）。 注：data.DaysBetween(a, b) 的语义是 b - a（与 v1 GetDaysBetween 一致）， 故此处参数顺序为 (other, s)。

func (Solar) SubtractMinute 

func (s Solar) SubtractMinute(other Solar) int

SubtractMinute 返回 s 与 other 相差的分钟数（s - other）。

func (Solar) ToFullString 

func (s Solar) ToFullString() string

ToFullString 返回完整描述（含闰年/星期/节日/星座，与 v1 输出逐字一致）。

func (Solar) ToYmdHms 

func (s Solar) ToYmdHms() string

ToYmdHms 返回 "2006-01-02 15:04:05" 形态。

func (Solar) Week 

func (s Solar) Week() int

Week 返回星期几（0=日 …… 6=六）。

func (Solar) WeekInChinese 

func (s Solar) WeekInChinese() string

WeekInChinese 返回星期几的中文名（日/一/……/六）。

func (Solar) XingZuo 

func (s Solar) XingZuo() string

XingZuo 返回星座（白羊……双鱼）。

func (Solar) Year 

func (s Solar) Year() int

Year 返回年。

func (Solar) Ymd 

func (s Solar) Ymd() Date

Ymd 返回 Date 视图（丢弃时分秒）。

type SolarHalfYear 

type SolarHalfYear struct {
	// contains filtered or unexported fields
}

SolarHalfYear 表示阳历半年（上/下半年）。值类型。

func NewSolarHalfYear 

func NewSolarHalfYear(year, month int) SolarHalfYear

NewSolarHalfYear 构造阳历半年（v1 NewSolarHalfYearFromYm）。

func (SolarHalfYear) Index 

func (h SolarHalfYear) Index() int

Index 返回本半年在本年的序号（1-2；v1 GetIndex）。

func (SolarHalfYear) Iter 

func (h SolarHalfYear) Iter() iter.Seq[SolarHalfYear]

Iter 返回本半年起（含本半年）逐半年向前的无限序列，配合 break 使用。

func (SolarHalfYear) Month 

func (h SolarHalfYear) Month() int

Month 返回锚定月（1-12）。

func (SolarHalfYear) Months 

func (h SolarHalfYear) Months() []SolarMonth

Months 返回本半年包含的 6 个月（v1 GetMonths）。

func (SolarHalfYear) Next 

func (h SolarHalfYear) Next(halfYears int) SolarHalfYear

Next 返回 halfYears 个半年后（可为负；v1 Next）。

func (SolarHalfYear) Seasons 

func (h SolarHalfYear) Seasons() []SolarSeason

Seasons 返回本半年包含的 2 个季度（v2 新增层级访问器）。

func (SolarHalfYear) String 

func (h SolarHalfYear) String() string

String 返回 "2020.1" 形态（年.半年序号）。

func (SolarHalfYear) ToFullString 

func (h SolarHalfYear) ToFullString() string

ToFullString 返回 "2020年上半年" / "2020年下半年" 形态。

func (SolarHalfYear) Year 

func (h SolarHalfYear) Year() int

Year 返回年。

type SolarMonth 

type SolarMonth struct {
	// contains filtered or unexported fields
}

SolarMonth 表示阳历月。值类型：可比较、可拷贝、零堆分配。

func NewSolarMonth 

func NewSolarMonth(year, month int) SolarMonth

NewSolarMonth 构造阳历月（v1 NewSolarMonthFromYm）。

func (SolarMonth) Days 

func (m SolarMonth) Days() []Solar

Days 返回本月逐日（v1 GetDays；1582 年 10 月为 21 天，跨儒略历洞）。

func (SolarMonth) Iter 

func (m SolarMonth) Iter() iter.Seq[SolarMonth]

Iter 返回自本月起（含本月）逐月向前的无限序列，配合 break 使用。

func (SolarMonth) Month 

func (m SolarMonth) Month() int

Month 返回月（1-12）。

func (SolarMonth) Next 

func (m SolarMonth) Next(months int) SolarMonth

Next 返回 months 月后（可为负；v1 Next）。

func (SolarMonth) String 

func (m SolarMonth) String() string

String 返回 "2020-3" 形态（不补零，与 v1 一致）。

func (SolarMonth) ToFullString 

func (m SolarMonth) ToFullString() string

ToFullString 返回 "2020年3月" 形态。

func (SolarMonth) WeekCount 

func (m SolarMonth) WeekCount(start WeekStart) int

WeekCount 返回本月在 start 周起始约定下占用的周数（恒等于 len(Weeks(start))）。 v2 新增便捷方法；注意与 v1 SolarUtil.GetWeeksOfMonth 的公式 ceil((天数+1日星期-start)/7) 在「1 日星期早于 start」的月份（如 2023-01 周一起）少 1， 本方法与 Weeks 切片严格一致。

func (SolarMonth) Weeks 

func (m SolarMonth) Weeks(start WeekStart) []SolarWeek

Weeks 返回本月占用的周（v1 GetWeeks；自包含当月 1 日的周起， 至首日仍落在本月的周止——含首尾跨月的部分周）。

func (SolarMonth) Year 

func (m SolarMonth) Year() int

Year 返回年。

type SolarSeason 

type SolarSeason struct {
	// contains filtered or unexported fields
}

SolarSeason 表示阳历季度（锚定年内任一月，归属于所在季度）。值类型。

func NewSolarSeason 

func NewSolarSeason(year, month int) SolarSeason

NewSolarSeason 构造阳历季度（v1 NewSolarSeasonFromYm）。

func (SolarSeason) HalfYear 

func (s SolarSeason) HalfYear() SolarHalfYear

HalfYear 返回本季度所在的半年（v2 新增层级访问器）。

func (SolarSeason) Index 

func (s SolarSeason) Index() int

Index 返回本季度在本年的序号（1-4；v1 GetIndex）。

func (SolarSeason) Iter 

func (s SolarSeason) Iter() iter.Seq[SolarSeason]

Iter 返回本季度起（含本季度）逐季度向前的无限序列，配合 break 使用。

func (SolarSeason) Month 

func (s SolarSeason) Month() int

Month 返回锚定月（1-12）。

func (SolarSeason) Months 

func (s SolarSeason) Months() []SolarMonth

Months 返回本季度包含的 3 个月（v1 GetMonths）。

func (SolarSeason) Next 

func (s SolarSeason) Next(seasons int) SolarSeason

Next 返回 seasons 个季度后（可为负；v1 Next）。

func (SolarSeason) String 

func (s SolarSeason) String() string

String 返回 "2020.1" 形态（年.季度序号）。

func (SolarSeason) ToFullString 

func (s SolarSeason) ToFullString() string

ToFullString 返回 "2020年1季度" 形态。

func (SolarSeason) Year 

func (s SolarSeason) Year() int

Year 返回年。

type SolarWeek 

type SolarWeek struct {
	// contains filtered or unexported fields
}

SolarWeek 表示阳历周（锚定某日，按 start 约定的一周）。 值类型：可比较、可拷贝、零堆分配。

func NewSolarWeek 

func NewSolarWeek(year, month, day int, start WeekStart) SolarWeek

NewSolarWeek 构造阳历周；锚定日期不做校验（视图语义，非法输入推算结果未定义但不 panic）。

func (SolarWeek) Day 

func (w SolarWeek) Day() int

Day 返回锚定日。

func (SolarWeek) Days 

func (w SolarWeek) Days() []Solar

Days 返回本周 7 天（自本周第一天起；v1 GetDays，[]Solar 取代 *list.List）。

func (SolarWeek) DaysInMonth 

func (w SolarWeek) DaysInMonth() []Solar

DaysInMonth 返回本周中落在本月的日子（v1 GetDaysInMonth 意图的修复实现，见文件头差异 2）。

func (SolarWeek) FirstDay 

func (w SolarWeek) FirstDay() Solar

FirstDay 返回本周第一天（v1 GetFirstDay）。

func (SolarWeek) FirstDayInMonth 

func (w SolarWeek) FirstDayInMonth() Solar

FirstDayInMonth 返回本周中落在本月的第一个日子（v1 GetFirstDayInMonth）； 合法锚定下本周必含本月日子，故恒有值。

func (SolarWeek) Index 

func (w SolarWeek) Index() int

Index 返回本周在本月的第几周（1 起；v1 GetIndex）。

func (SolarWeek) IndexInYear 

func (w SolarWeek) IndexInYear() int

IndexInYear 返回本周在本年的第几周（1 起；v1 GetIndexInYear）； 锚定日期非法（如 1582-10-05～14 儒略历洞）时返回 0。

func (SolarWeek) Iter 

func (w SolarWeek) Iter() iter.Seq[SolarWeek]

Iter 返回自本周起（含本周）逐周向前的无限序列（自然周链，等价于连续 Next(1, false)）， 配合 break 使用： 

for w := range NewSolarWeek(2024, 1, 1, Monday).Iter() {
    if w.Month() == 3 { break }
}
Example

时间组件 + Go 1.23 迭代器。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	// 遍历 2024 年 3 月的每周（周一起）
	month := lunar.NewSolarMonth(2024, 3)
	for _, week := range month.Weeks(lunar.Monday) {
		fmt.Println(week.ToFullString())
	}
}

Output:
2024年3月第1周
2024年3月第2周
2024年3月第3周
2024年3月第4周
2024年3月第5周

func (SolarWeek) Month 

func (w SolarWeek) Month() int

Month 返回锚定月（1-12）。

func (SolarWeek) Next 

func (w SolarWeek) Next(weeks int, separateMonth bool) SolarWeek

Next 返回 weeks 周后（可为负；v1 Next）。

separateMonth 为 false 时按自然周推进（锚定日 ±7×weeks）； 为 true 时按「月内周序」推进：跨月时前移吸附到目标月第 1 周（锚定该周首日或当月 1 日）， 后退吸附到目标月最后一周（锚定该周末日或当月末日）。 注：v1 因变量遮蔽该模式恒返回自身，v2 恢复其设计语义（见文件头差异 1）。

func (SolarWeek) Start 

func (w SolarWeek) Start() WeekStart

Start 返回周起点约定。

func (SolarWeek) String 

func (w SolarWeek) String() string

String 返回 "2020.5.3" 形态（年.月.当月第几周）。

func (SolarWeek) ToFullString 

func (w SolarWeek) ToFullString() string

ToFullString 返回 "2020年5月第3周" 形态。

func (SolarWeek) Year 

func (w SolarWeek) Year() int

Year 返回锚定年。

type SolarYear 

type SolarYear struct {
	// contains filtered or unexported fields
}

SolarYear 表示阳历年。值类型。

func NewSolarYear 

func NewSolarYear(year int) SolarYear

NewSolarYear 构造阳历年（v1 NewSolarYearFromYear）。

func (SolarYear) HalfYears 

func (y SolarYear) HalfYears() []SolarHalfYear

HalfYears 返回本年 2 个半年（v2 新增层级访问器）。

func (SolarYear) Iter 

func (y SolarYear) Iter() iter.Seq[SolarYear]

Iter 返回本年起（含本年）逐年向前的无限序列，配合 break 使用。

func (SolarYear) Months 

func (y SolarYear) Months() []SolarMonth

Months 返回本年 12 个月（v1 GetMonths）。

func (SolarYear) Next 

func (y SolarYear) Next(years int) SolarYear

Next 返回 years 年后（可为负；v1 Next）。

func (SolarYear) Seasons 

func (y SolarYear) Seasons() []SolarSeason

Seasons 返回本年 4 个季度（v2 新增层级访问器）。

func (SolarYear) String 

func (y SolarYear) String() string

String 返回 "2020" 形态。

func (SolarYear) ToFullString 

func (y SolarYear) ToFullString() string

ToFullString 返回 "2020年" 形态。

func (SolarYear) Year 

func (y SolarYear) Year() int

Year 返回年。

type TaiSuiDeity 

type TaiSuiDeity struct {
	GanZhi string `json:"ganZhi"`         // 年干支（如 "甲辰"）
	Name   string `json:"name"`           // 星君名讳（如 "李诚"）
	Title  string `json:"title"`          // 尊号（"大将军"）
	Note   string `json:"note,omitempty"` // 名讳异读标注（如 "一作王清"；无则空）
}

TaiSuiDeity 值年太岁星君（六十甲子各一位）。

func TaiSuiDeityOfGanZhi 

func TaiSuiDeityOfGanZhi(ganZhi string) (TaiSuiDeity, bool)

TaiSuiDeityOfGanZhi 由年干支（如 "甲辰"）返回值年太岁星君； 干支非法（非六十甲子组合，如 "甲丑"）时 ok=false。

func (TaiSuiDeity) String 

func (t TaiSuiDeity) String() string

String 返回完整名讳，如 "李诚大将军"。

type Tao 

type Tao struct {
	// contains filtered or unexported fields
}

Tao 道历。

func MustNewTao 

func MustNewTao(year, month, day, hour, minute, second int) *Tao

MustNewTao 构造道历日期时间，非法输入 panic。仅建议字面量常量使用。

func MustNewTaoFromYmd 

func MustNewTaoFromYmd(year, month, day int) *Tao

MustNewTaoFromYmd 构造道历日期，非法输入 panic。仅建议字面量常量使用。

func NewTao 

func NewTao(year, month, day, hour, minute, second int) (*Tao, error)

NewTao 构造道历日期时间（year 为道历年份；月/日/时值域错误返回包装 ErrInvalidDate 的错误）。

func NewTaoFromLunar 

func NewTaoFromLunar(l *Lunar) *Tao

NewTaoFromLunar 由农历构造道历（lunar 为 nil 时返回 nil）。

func NewTaoFromYmd 

func NewTaoFromYmd(year, month, day int) (*Tao, error)

NewTaoFromYmd 构造道历日期（零时）。

func (*Tao) Day 

func (t *Tao) Day() int

Day 返回农历日。

func (*Tao) DayInChinese 

func (t *Tao) DayInChinese() string

DayInChinese 返回中文日（初一 ~ 三十）。

func (*Tao) Festivals 

func (t *Tao) Festivals() []TaoFestival

Festivals 返回当日道历节日（含冬至/夏至圣诞、八节日、八会日判定，v1 顺序）。

func (*Tao) IsDayAnWu 

func (t *Tao) IsDayAnWu() bool

IsDayAnWu 返回是否暗戊。

func (*Tao) IsDayBaHui 

func (t *Tao) IsDayBaHui() bool

IsDayBaHui 返回是否八会日。

func (*Tao) IsDayBaJie 

func (t *Tao) IsDayBaJie() bool

IsDayBaJie 返回是否八节日。

func (*Tao) IsDayMingWu 

func (t *Tao) IsDayMingWu() bool

IsDayMingWu 返回是否明戊（日干为戊）。

func (*Tao) IsDaySanHui 

func (t *Tao) IsDaySanHui() bool

IsDaySanHui 返回是否三会日。

func (*Tao) IsDaySanYuan 

func (t *Tao) IsDaySanYuan() bool

IsDaySanYuan 返回是否三元日。

func (*Tao) IsDayWu 

func (t *Tao) IsDayWu() bool

IsDayWu 返回是否戊日（明戊或暗戊）。

func (*Tao) IsDayWuLa 

func (t *Tao) IsDayWuLa() bool

IsDayWuLa 返回是否五腊日。

func (*Tao) Lunar 

func (t *Tao) Lunar() *Lunar

Lunar 返回对应农历。

func (*Tao) Month 

func (t *Tao) Month() int

Month 返回农历月（负数表示闰月）。

func (*Tao) MonthInChinese 

func (t *Tao) MonthInChinese() string

MonthInChinese 返回中文月份（闰月带「闰」前缀）。

func (*Tao) String 

func (t *Tao) String() string

String 返回如 "四七一八年十月十七"。

func (*Tao) ToFullString 

func (t *Tao) ToFullString() string

ToFullString 返回完整道历描述（干支纪年月日 + 时辰，v1 逐字一致）。

func (*Tao) Year 

func (t *Tao) Year() int

Year 返回道历年份。

func (*Tao) YearInChinese 

func (t *Tao) YearInChinese() string

YearInChinese 返回中文道历年份（如 四七一八）。

type TaoFestival 

type TaoFestival struct {
	// contains filtered or unexported fields
}

TaoFestival 道历节日（值类型：小对象、构造后只读）。

func NewTaoFestival 

func NewTaoFestival(name, remark string) TaoFestival

NewTaoFestival 构造道历节日。

func (TaoFestival) Name 

func (f TaoFestival) Name() string

Name 返回名称。

func (TaoFestival) Remark 

func (f TaoFestival) Remark() string

Remark 返回备注。

func (TaoFestival) String 

func (f TaoFestival) String() string

String 返回名称。

func (TaoFestival) ToFullString 

func (f TaoFestival) ToFullString() string

ToFullString 返回完整描述（名称 + [备注]）。

type TianMenGui 

type TianMenGui struct {
	GuiType  string `json:"guiType"`  // 贵神类型："阳贵"（昼贵）/"阴贵"（夜贵）
	ZhiIndex int    `json:"zhiIndex"` // 时支序（0=子 …… 11=亥）
	Zhi      string `json:"zhi"`      // 时支名
}

TianMenGui 贵登天门时条目。

type WeekStart 

type WeekStart int

WeekStart 表示周起点（用于周序计算）。 

const (
	Sunday WeekStart = iota // 周日为一周之始
	Monday                  // 周一为一周之始
)

func (WeekStart) String 

func (w WeekStart) String() string

String 实现 fmt.Stringer。

type XiaoYun 

type XiaoYun struct {
	// contains filtered or unexported fields
}

XiaoYun 表示小运。

func (*XiaoYun) Age 

func (xy *XiaoYun) Age() int

Age 返回年龄。

func (*XiaoYun) GanZhi 

func (xy *XiaoYun) GanZhi() string

GanZhi 返回小运干支。

func (*XiaoYun) Index 

func (xy *XiaoYun) Index() int

Index 返回序数。

func (*XiaoYun) Xun 

func (xy *XiaoYun) Xun() string

Xun 返回所在旬。

func (*XiaoYun) XunKong 

func (xy *XiaoYun) XunKong() string

XunKong 返回旬空。

func (*XiaoYun) Year 

func (xy *XiaoYun) Year() int

Year 返回年。

type XingJiaCategory 

type XingJiaCategory struct {
	Name   string `json:"name"`   // 档名
	Months [2]int `json:"months"` // 农历月序（升序）
	Note   string `json:"note"`   // 宜忌说明
}

XingJiaCategory 行嫁十二月六档归属之一。

func XingJiaMonths 

func XingJiaMonths(nvZhi string) ([]XingJiaCategory, bool)

XingJiaMonths 按女命年支返回行嫁十二月的完整六档归属 （大利月/妨媒人/妨翁姑/妨父母/妨夫主/妨女身，各两个月，合覆十二月）。

六档自大利月起按月序顺推：大利 k 与 k+6、妨媒人 k+1 与 k+7、 妨翁姑 k+2 与 k+8、妨父母 k+3 与 k+9、妨夫主 k+4 与 k+10、 妨女身 k+5 与 k+11。如女命子年：大利六、十二月，妨媒人正、七月， 妨翁姑二、八月，妨父母三、九月，妨夫主四、十月，妨女身五、十一月。 闰月随本月序号。地支非法时 ok 为 false。

Example

择吉流派：女命行嫁十二月六档全表（女命子年）。 

package main

import (
	"fmt"

	"github.com/tekintian/lunar"
)

func main() {
	cats, _ := lunar.XingJiaMonths("子")

	for _, c := range cats {
		fmt.Printf("%s%v月：%s\n", c.Name, c.Months, c.Note)
	}
}

Output:
大利月[6 12]月：宜嫁娶
妨媒人[1 7]月：小利月，次吉；妨媒人，无媒可成婚
妨翁姑[2 8]月：妨公婆，翁姑避之可成婚
妨父母[3 9]月：妨父母，父母避之可成婚
妨夫主[4 10]月：妨丈夫，夫避之可成婚
妨女身[5 11]月：妨女自身，大凶勿用

type YearBoundary 

type YearBoundary int

YearBoundary 换年界限口径（岁破等年依规则的分派依据）。 

const (
	// YearByLiChun 立春换年：子平命理与择日馆主流（太岁随立春更替）。
	YearByLiChun YearBoundary = iota
	// YearByChuYi 正月初一换年：民俗与港台民历常用（生肖太岁随新年更替）。
	YearByChuYi
)

type Yun 

type Yun struct {
	// contains filtered or unexported fields
}

Yun 表示大运起运信息。

func (*Yun) DaYun 

func (yun *Yun) DaYun() []DaYun

DaYun 返回 10 轮大运。

func (*Yun) DaYunBy 

func (yun *Yun) DaYunBy(n int) []DaYun

DaYunBy 返回 n 轮大运。

func (*Yun) Gender 

func (yun *Yun) Gender() Gender

Gender 返回性别。

func (*Yun) IsForward 

func (yun *Yun) IsForward() bool

IsForward 报告是否顺推。

func (*Yun) Lunar 

func (yun *Yun) Lunar() *Lunar

Lunar 返回所属农历。

func (*Yun) StartDay 

func (yun *Yun) StartDay() int

StartDay 返回起运天数。

func (*Yun) StartHour 

func (yun *Yun) StartHour() int

StartHour 返回起运小时数。

func (*Yun) StartMonth 

func (yun *Yun) StartMonth() int

StartMonth 返回起运月数。

func (*Yun) StartSolar 

func (yun *Yun) StartSolar() Solar

StartSolar 返回起运阳历日期。

func (*Yun) StartYear 

func (yun *Yun) StartYear() int

StartYear 返回起运年数。

type ZeRiOptions 

type ZeRiOptions struct {
	Event   string // 用事（口语别名或铺注键，如「嫁娶」「搬家」「开业」；空串仅出概况）
	Shan    string // 坐山（二十四山，可选；传入则做太阳/太阴到山适配）
	UserZhi string // 用事人年支（子丑寅……亥，可选；传入则做正冲校验）
}

ZeRiOptions 择日评估入参。

type ZeRiResult 

type ZeRiResult struct {
	Event        string     `json:"event"`               // 规范用事名
	EventKeys    []string   `json:"eventKeys,omitempty"` // 对应铺注键
	GanZhi       string     `json:"ganZhi"`              // 日干支
	TianShen     string     `json:"tianShen"`            // 黄黑道天神
	TianShenLuck string     `json:"tianShenLuck"`        // 黄道吉/黑道凶
	ZhiXing      string     `json:"zhiXing"`             // 建除十二神
	YiHit        []string   `json:"yiHit,omitempty"`     // 命中的宜键
	JiHit        []string   `json:"jiHit,omitempty"`     // 命中的忌键
	Chong        string     `json:"chong"`               // 日冲生肖
	ChongUser    bool       `json:"chongUser,omitempty"` // 冲用事人年支（正冲）
	Taboos       []ZejiItem `json:"taboos,omitempty"`    // 民俗禁忌（全流派标记版）
	Shan         *ShanInfo  `json:"shan,omitempty"`      // 坐山适配（传入 Shan 时）
	Verdict      string     `json:"verdict"`             // 宜 / 忌 / 平 / 诸事不宜
	Reasons      []ZejiItem `json:"reasons"`             // 判定依据（分块+标记）
}

ZeRiResult 分事择日评估结果（判定依据逐条分块标记）。

type ZeRiScoreResult 

type ZeRiScoreResult struct {
	Score   int        `json:"score"`   // 0~100
	Level   string     `json:"level"`   // 上吉 / 吉 / 可用 / 平 / 慎用
	Items   []ZejiItem `json:"items"`   // 逐项加减分明细（Sect=现代参考·加权项）
	Warning string     `json:"warning"` // 非典籍声明
}

ZeRiScoreResult 现代加权评分结果。

type ZejiItem 

type ZejiItem struct {
	Rule   string `json:"rule"`           // 规则名（如「岁破」「红沙日」）
	Detail string `json:"detail"`         // 细节（如「日支戌冲太岁辰」）
	Sect   string `json:"sect"`           // 流派/口径标记
	Source string `json:"source"`         // 典籍出处
	Note   string `json:"note,omitempty"` // 版本差异备注（异派观点）
}

ZejiItem 带流派标记的择吉判定条目。

Sect 取值约定：「通行」（诸派同判）或「体系·口径」格式 （如「通书·立春换年」「民俗·初一换年」「通书·月建口径」）。

Source Files

View all Source files

Directories

Path Synopsis
cmd
lunarholiday command
Command lunarholiday 为节假日数据维护工具链（计划 T3.5）。
 Command lunarholiday 为节假日数据维护工具链（计划 T3.5）。
internal
astro
Package astro 实现寿星天文历的核心天体位置算法：VSOP87D 简化日月黄经、 章动、光行差、ΔT 拟合，以及朔（新月）与节气（太阳视黄经 15° 整数倍）的 牛顿迭代求解。
 Package astro 实现寿星天文历的核心天体位置算法：VSOP87D 简化日月黄经、 章动、光行差、ΔT 拟合，以及朔（新月）与节气（太阳视黄经 15° 整数倍）的 牛顿迭代求解。
calcache
Package calcache 提供历法年表的并发安全缓存组件（计划 T1.10/T2.2）。
 Package calcache 提供历法年表的并发安全缓存组件（计划 T1.10/T2.2）。
data
农历基础常量表（天干地支、数字、月日名、神煞、方位、冲煞等）。
 农历基础常量表（天干地支、数字、月日名、神煞、方位、冲煞等）。
data/holidays
Package holidays 内嵌主库假日数据基线（Layer 1，计划 §4.1）。
 Package holidays 内嵌主库假日数据基线（Layer 1，计划 §4.1）。
gz
Package gz 提供干支域的高速查询：六十甲子索引、旬/旬空、 每日宜忌、每日神煞（吉神/凶煞）与时辰宜忌。
 Package gz 提供干支域的高速查询：六十甲子索引、旬/旬空、 每日宜忌、每日神煞（吉神/凶煞）与时辰宜忌。

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.