update crypto fileg

doc: add doc for AddDaySafe, AddMonthSafe, AddYearSafe
feat: add AddDaySafe, AddMonthSafe, AddYearSafe
2026-03-01 00:35:28 +08:00 · 2025-02-18 15:49:52 +08:00 · 2025-02-18 15:47:43 +08:00 · 2025-02-18 15:37:56 +08:00 · 2025-02-18 14:10:04 +08:00
7 changed files with 1117 additions and 245 deletions
--- a/cryptor/rsa_private_example.pem
+++ b/cryptor/rsa_private_example.pem
@@ -1,51 +1,51 @@
 -----BEGIN rsa private key-----
-MIIJKQIBAAKCAgEAof7+5KVH6s/ID7onVeuCPVGPIW6TiHHjDlxbYLdA/CyhTvR2
-Pk8JvX9BjBXLI/+jTWsyTUucwszu3MaVhIS/gzoLKjr5meVp+HEcFe98s4XRYhob
-2cdpDo+Jty8Vuodz5T2nYkIZP/oyJNmQCBYDe20nBwmjjFfworEvwNy2fSucs8wr
-lJT2Xqy4oHZqERWvnIJZtBshX9//9Pw3m/GupHeBFBNW2omWCQm4aTEbeepkXloT
-gVQ75FEpyyjNjDi+OG/Om2v5l+XCvOcV39Hc7sBovDFNX6w39zQSIKiMpFkxciKP
-9SPbqZz+Vv0iyUPKxi2gXwbgy0+k2aTQlsPS976+2/4QgLReU3Ujeh8Q6oRwB8HR
-fPlD7aY+dGPMT16o1R3nhs2jwsGId812lw5qgjaYZJCXCBhQcZFs+1IM7c6GmIGX
-YIAcFDWiVsENqqesQO5tCA1UTTGtIa9kMYD/pwFK1ANVvrr2c6Qu/0UuBneawok7
-6vDHTQCWmVcF0QIe5RaTj8YK9TaNAcQDPy9jM0jWxJE1EBuRpDtIymQIcgMpXwgu
-erh9NuXNoGEVPn4mvlVfy+1TVGzws8WsZwY/LH07afdfIeDc1YwLadwq5S+wxuzw
-NuSCM9t2rIzfbRhorlg/lVDWqP8H6d9vF5MJY9kSiO3KgCSJLYfVl+Q+8asCAwEA
-AQKCAgAdzYTlWcb+WxWqVwwPkZFXaJ7VfrtjudgU90bUZ0JsYmWW2gC6+92F4FiV
-xhimWcyYXKVXdRa0+/Dh6yLsy2NUaCRPs6Ph/UPesiiBnJqriG36B2WiTj50sFGc
-wuvTckIPJaWavSBaFdSN1Pzbj/k6Bt3MPKi7FB6wP7rSV4i3RIPCzEgkQLeGuW4K
-D176H6w8Nfr82JTuR46WaqRsay0/EsFLiTdMY02YAhLMP32Xk1i9xwKZo36VRZ1T
-xAD00CemyGMRUu8LU/jcugLbN4fW4M0j+koK1OtC7nB7U6b0QXiIT/V+Gwe5j6l3
-JYD12CQBC7naYbCPlup0JA8//WzdXlnh5Tix8XfSVC7hx+0e4caAKJZNHXYEiXY/
-7N2Eg77+zk1h+K8oD+8/UCQRSvox1867GkeUd+yDQGpIFr42dM5fSupHt8wV7Etm
-Oap8yI2eX+NUr+gZcMlpaNt3bVFfAQNPrMmMqAsJvlGLTMiniLJ5gE5GhRp+A+03
-mCmokS92qa9E2m9GyaSYWlu37VnMgFeoLxgEj3tiVmiHiXbtReM2F2SLybS/kHxx
-XrgeqlU85J6C7P9ggxEoph2OxGz5+DuinQL2V/JPrV2JhTGEcTHqbV2lN3yfCKj7
-uyzmS7wPTmyM5iJCnDj+DRVC6Od3BRYeh7ohte40zBsNZFLZYQKCAQEAwzrjWUoQ
-ORa/kSA+n1d4CpDPcYX93JhKLPCmSDvE1MJqNE0uqfSbHajtt9XNrRMjmZ7Godnm
-pzMS9hpVc3+DOt4uNOn0I0AY6fbZY4Wn/PJkqRe7RcCeLvvkKu6m4qGmapbu84xl
-FwjQhMksglrx96uB8YIvvtsypyxJvdxYuB7TXnQHU8uXqFgmBkwu+/VmUE/xqIe/
-yEh6LQ9Yiqee9U/WGQwLmupVr0kvixlNP1tlT52ISdD4+3vuUlOlVIcdXefknih4
-tOiUkOWx+u4sIyQ++d0cf1CyMAX8vStikepNoiafGbpRT0ON/EpBC8Aimn15WOUk
-rhBFkQA874628QKCAQEA1GvTH6f9Du9svOXeYJmEgTBkpSwvWLv81McpZ6cErvt9
-YOIKYndGvmhABHFi9Cy9E5FITUBU2zFNmd4idgS9FfcZx6TPibpKp46lHHW4Pwa+
-qXjJ1Xerre938Yh0HeTM7AIUUrTfZHMb7Ymr+8rQW3T90jnJuzCji28eoMzhemNw
-wK5qiTfjC7mKS1WOxCfCAwiLCtCGSaW94WfL3/4vFGEKgMwJBj/FI34uJCbYVHmI
-wZKg0Tdf3xCv+oz9spLfYyaz0AobiCGzBw3gaxlQl2FqeQzOUQal+KQf78scXlBz
-eHZxB9gFl3FrR3thuZ7SyAnTj4gCj6JxT3tySEaKWwKCAQEAuhi9NJTT6AdWLjmF
-WBBhvfiRtU4bUhbcxf/TEZHfq0tzP02/SISBBAHOL+me9/cBfWMLRqbWJdUaovsx
-LzqCVjAJ7aiBbsSfuw3x5Ns36XcJGuIjQnc8kd7MfVwmOmwKnRooxoGyrwVY9upp
-Ag09D3AuGo+VgaGipBYkaNXMwB2qMCP8BBVTCEaWYHRoaQZgM/gwjAxydLEZvTAe
-n3TuojorBI8l1NLBQKhLqJVCvD0b0ouAqZSIcfiNkW5ob62oAaaVl2lOvmvhiklZ
-oa885XacjUMG8hly8TIT3CKqABtPS1zzVevzq9HiW3ZQkKnikk8+x80NbNrX5UNL
-0rLAkQKCAQEAyqpBGN/OqbQ225a47xMo/5TrQUeBuLhKhbuqvlD0P/qDaa7f14gT
-P9D42wRPM8WHc6bWA5ZQH3zPm/D6kfz9ZnqF5xtQQwgw9+I5l4idC8zklY4/iuIN
-MvrZReE5X9gOx1FIkIwu4oiMabpDEw0ycz+Qd0VZObYzIvIWl7ZBneJIDh2aWWav
-wVz5G9z6RB3mlbxN5DiFFrkCC49bTU8XHetj+PQx2/t1m+JkJWvGU/pMRtsdgd7C
-InGqZHKmDfzhEpk3T1KFaAE27JEJv0S8xmFUEz/rjBS6vxnfuonffABn2tOuDZzF
-4PJ+Nwn5d/6W/fGaHkPWpbGHSBzwMRLUJwKCAQBiPAfbLKuB9u2HFxV33lQuBlMi
-HK6JhLoN0o0I5ICuC01IlOaAjAbdTAZdNXcuj9JPfS4tuLG3+nRueKJ5A7MHvwDG
-ZBvVq1q8kKnEl04yW4J/2SfjFk+Do2V3WR8vYjphOgd2pXP72IRw5YWW087VCKFY
-x2Cjuluapss8zdPR6lBxrrdvSCoysW154ALchgUeJAv4G9x/KPQBoBUkDXO4R6UJ
-a36nUMBO7XjkFeucU9npdOl9UEz3ZOE9mWLtck60lZofHoS/dPaY7hzAjetbtfDs
-J8sSwmHsb1DdOx5YSpEkg9aPrtShkChYoKOJFLKhpf7WGbVx2U7OBw71BCa5
+MIIJKAIBAAKCAgEA77XqVTCS3dmAd5FnAvrTPcXrVetPzJeksmqqu4EjFv6Fe4NF
+dZQIWtkjgJQ4v27KpZXUL2ExkJhodrfRegHFgq9xiy822umUu6bCyBva1YxFQPev
+KqgPLY7n6wB3PJRnwnSszQCsUDyBC8JnqbeL41qcRiBAjXSh0BFMERSl3F0AViGk
+VCRCmKuc9612Gi6iuw11cFbLUPqLL+YNk+NIgW398nYUUNeacMG12h02n3YJ8HD5
+Q16PhdJ7Z93aAsDgKzl7dT5tyyv3w2p2wOse1GPMfQffZQA+gXmw7+GJImJu3DtW
+KY0cQqzO1Wsa5t+YxMf0A12AYGJa+Y0aPgr8Vl8LY++NdujnazwsgzTJm94uuqHZ
+iv+mtsYIpkLbuMWmBce05G8MtS0O9IabgBLxrbUQvYk9Myv/ff4BgWkO06SAUq7G
+GUn0cI+EglyYYJCgeeBSQid7daQ8M4Idb9veGo2f7KJqHecRf3fzRwlbMMjoo0Nw
+19FAx/tQm1LTg1NxCaheAFI1UzUTCUAZE/X9QwviTuHXTnfjd0wfxeVaJRMyK9ef
+OJuALAit9rtxyfm1fPRztvPwIrpy/wMUQ+7i8xAEPWa+kXFtVLTqEwGnX3QYZf/N
+GJ/9RZmtpcxgpHIJ6OEyqVUYKKeU7R3uW7i3pv3au9lZ5Id1AvAqQWG8TvkCAwEA
+AQKCAgAdC5jiS6lwEju7wTWPKd9Qu9uhJIsdyj4dlEktwR8EWUDJT4WqEo7Umzzv
+Boa9w2nwmHAGcat0ztLRl8JdGzvYcvO6HrVx3x2zgyhU4PMqLv3xOlHSRFzac1ds
+pTjNcVoFOOf7SxqV+k7UovC2otPjb4ZCBQRtX3V/5aim5S6XvfkddqQXwfED2L+D
+T1RhJcd4DNBvFUU7gbA91I1OnxqY/D/qEh6yEP3YrdAgJqwItF/N75J0dE/FslRb
+qIkTDlXbRvLLqQ3asXArEIplI9gvegw8FikebuIkBB/JYTWhofW238W38S48cf35
+5Cl1UiCLr4LEqZ61jxVg6ZUFcYVTodN5/G9CG0/VSNePWaRrNiT2NFRRhOPzKdQd
+RjC4ohWPJuHNa5dcXkjQZAodL70qRwluzcXZUg7KkPGX8zE9BVyZftymHN3EvhY+
+GDFIpBtsKejEEHvUD9AwcSxlh/dawTfiRWi3NpkhA9JGkEDVGINpZsrB33j0aZeP
+eEcFL7BfAgsC7mt+iNAc9kD/2qPEEJgVm+YIPiotg6vvEMgMZM6tCfZCEmSy6R8O
+zN5qBEa0iweQzjd5wzwSpCabB2HMOSNJg2yZYiLubNjSoeqv+KJuVVcDnPCFpSYW
+TczngaAn5S+CZKsm9inDGACiReqe9JZcDw8/I7PV/k3N2pCKkQKCAQEA/G0/LX01
+cnyu081H6wXbiSxzs+nWnETR6ZUduKEv1kU4FKCsHxI1n5XhXUX5/KVt0ttgLMcP
+qPd6XiUmJngPy/s0WWkvHPBj5C95VEsPT4CeVrRKCDdB/LN60n0gkFZanxatkM8i
+unV3vmoOJitS7mG4z9LWkL+PPyTRtlwNSsSHWQqpqjC8klzkvzyyxbVZvrfMPaFW
+MFkLzM2hTHHdBtW6SqTsnTma319T/LXg/fmJd/A8ZNVFU1vafTgdPFVsy9PUb7/L
+eMmzY5PgbK0qFyuHV12Nbh2jaM7ijsBrNa7lD90fRmuXOAXo1YaQLcL9wLnYVqpO
+I+FAwSeNT+CTPQKCAQEA8xqWXeSWncf7Bh3IYuKjyJNeMhoy6idAdKtE5TQoUyXV
+Qtxf2v6ogYoCmJH+mLhwXNmnRpVPQvBlYLvtwV+6cfvjEMnhEXTUa0a3Q3Iz58qk
+wghBheZcMlJETcQISxt3kSILK9/HP7RsiTrDGgDdsRdHWBHx+BsZQBDu6gwieWk
+4ztSe9amrhpQAzMH/5T4FkKmXIaPRlWXsz3PNWr/+CVSa7LjnmAvriCzD0oMzzkK
+F/XlVmPBTPuuGz3j5rgXTlwaeaa0u4napMKQwb7MQe3nA9GMStp9KQuGu+06zF9Z
+p+VEzg1TVfBFDlqiGXtzhiMHHqRtQVdrVKN3zjX2bQKCAQEA660EA3CXaiDHCbDr
+qJ57bgM2s49rc9M9ORyj9zFm/GL8DSZGDWxu7GR/WRpwYFYDx45SqPvhvxvv/94n
+VFtcRFJxedkex6IZYX6BhRXfYZbwPnttc2ZEEa9wyP1SXfCCA26k9kKuZfAusHVM
+aI6iizZp2n87HUH8eDPkKKKhNmFvDM9LwT5nkS9x0qrVLoo3FD1+TzxGwDUjMz/5
+jOnyNuNtXyvETrbtxge23obhXb6Rfo2plWsZos5rm+W8Rgxr25IXEY68ZjXLavkx
+28WBOsjFP+h0l47MdppSJH26mxCDhOAqxxDEyuWZkWJlUpRvXnUlayTud8ljL/PB
+mAZQ8QKCAQBxpiZRssGu9YSm8Vly0R1ccXiB17mhucPqRv8oX9/SL0epwDiXuqGw
+HYLlLKtnXiI5Zg9LchXh51ydgn29/zC8hNM8UASGEqYTmLWoNEWLwTKroLs/i9zR
+22frQmCqAYlDdaprqYe1WHNT4up3nFCyP06AozgrewFxnlQL8K7waIlTKbJ/7nNx
+xR9Ov5anp07rqTD45HcqnG0VAHpUMLeFnH0RmEnNCo5/yw2qwiWG4tWTKgOTBYOi
+p65XUfGvNLTAj1JZONQZMHMkv0jJKpd24u8y283IWKhWfer5BAiO7qyNTyOBaL1i
+2baO5VQOsaXqOYnki14ARAwLP3iM0LFpAoIBABAIK+w9H+Vndiwq6NV68qHoSQxz
+Cc6EFXGPinIZygK0+4g+cU0pjor1+uCBE6rJsohUwaQE5gIGmiSv0rlRSIg7AWps
+CJneq4id2OVSAVWSItkrtxxwd+W96tDmC/8jdjZGoxwezQWvknEX3qn+W8bjd2TC
+zEsVmzHkRFI2ZONa31ReDYl4HDe938wFjg4dZ5x4Up0bibXEePkPDgZ5IgTD5Ltz
+aEBm0NU6GEk2Gv+r3O6GWbk09AV665GSWdtHNA3ymF7hBGCW92wj26t9qY/PZIEM
+Z4/G6/x4YXoHNtI2BOw8OkpX735I+Jp5Ngvnr6PyAhOnpPaq4utYumypQrU=
 -----END rsa private key-----
--- a/cryptor/rsa_public_example.pem
+++ b/cryptor/rsa_public_example.pem
@@ -1,14 +1,14 @@
 -----BEGIN rsa public key-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAof7+5KVH6s/ID7onVeuC
-PVGPIW6TiHHjDlxbYLdA/CyhTvR2Pk8JvX9BjBXLI/+jTWsyTUucwszu3MaVhIS/
-gzoLKjr5meVp+HEcFe98s4XRYhob2cdpDo+Jty8Vuodz5T2nYkIZP/oyJNmQCBYD
-e20nBwmjjFfworEvwNy2fSucs8wrlJT2Xqy4oHZqERWvnIJZtBshX9//9Pw3m/Gu
-pHeBFBNW2omWCQm4aTEbeepkXloTgVQ75FEpyyjNjDi+OG/Om2v5l+XCvOcV39Hc
-7sBovDFNX6w39zQSIKiMpFkxciKP9SPbqZz+Vv0iyUPKxi2gXwbgy0+k2aTQlsPS
-976+2/4QgLReU3Ujeh8Q6oRwB8HRfPlD7aY+dGPMT16o1R3nhs2jwsGId812lw5q
-gjaYZJCXCBhQcZFs+1IM7c6GmIGXYIAcFDWiVsENqqesQO5tCA1UTTGtIa9kMYD/
-pwFK1ANVvrr2c6Qu/0UuBneawok76vDHTQCWmVcF0QIe5RaTj8YK9TaNAcQDPy9j
-M0jWxJE1EBuRpDtIymQIcgMpXwguerh9NuXNoGEVPn4mvlVfy+1TVGzws8WsZwY/
-LH07afdfIeDc1YwLadwq5S+wxuzwNuSCM9t2rIzfbRhorlg/lVDWqP8H6d9vF5MJ
-Y9kSiO3KgCSJLYfVl+Q+8asCAwEAAQ==
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA77XqVTCS3dmAd5FnAvrT
+PcXrVetPzJeksmqqu4EjFv6Fe4NFdZQIWtkjgJQ4v27KpZXUL2ExkJhodrfRegHF
+gq9xiy822umUu6bCyBva1YxFQPevKqgPLY7n6wB3PJRnwnSszQCsUDyBC8JnqbeL
+41qcRiBAjXSh0BFMERSl3F0AViGkVCRCmKuc9612Gi6iuw11cFbLUPqLL+YNk+NI
+gW398nYUUNeacMG12h02n3YJ8HD5Q16PhdJ7Z93aAsDgKzl7dT5tyyv3w2p2wOse
+1GPMfQffZQA+gXmw7+GJImJu3DtWKY0cQqzO1Wsa5t+YxMf0A12AYGJa+Y0aPgr8
+Vl8LY++NdujnazwsgzTJm94uuqHZiv+mtsYIpkLbuMWmBce05G8MtS0O9IabgBLx
+rbUQvYk9Myv/ff4BgWkO06SAUq7GGUn0cI+EglyYYJCgeeBSQid7daQ8M4Idb9ve
+Go2f7KJqHecRf3fzRwlbMMjoo0Nw19FAx/tQm1LTg1NxCaheAFI1UzUTCUAZE/X9
+QwviTuHXTnfjd0wfxeVaJRMyK9efOJuALAit9rtxyfm1fPRztvPwIrpy/wMUQ+7i
+8xAEPWa+kXFtVLTqEwGnX3QYZf/NGJ/9RZmtpcxgpHIJ6OEyqVUYKKeU7R3uW7i3
+pv3au9lZ5Id1AvAqQWG8TvkCAwEAAQ==
 -----END rsa public key-----
--- a/datetime/datetime.go
+++ b/datetime/datetime.go
@@ -64,28 +64,95 @@ func init() {
 	}
 }

-// AddMinute add or sub minute to the time.
+// AddMinute add or sub minutes to the time.
 // Play: https://go.dev/play/p/nT1heB1KUUK
-func AddMinute(t time.Time, minute int64) time.Time {
-	return t.Add(time.Minute * time.Duration(minute))
+func AddMinute(t time.Time, minutes int64) time.Time {
+	return t.Add(time.Minute * time.Duration(minutes))
 }

-// AddHour add or sub hour to the time.
+// AddHour add or sub hours to the time.
 // Play: https://go.dev/play/p/rcMjd7OCsi5
-func AddHour(t time.Time, hour int64) time.Time {
-	return t.Add(time.Hour * time.Duration(hour))
+func AddHour(t time.Time, hours int64) time.Time {
+	return t.Add(time.Hour * time.Duration(hours))
 }

-// AddDay add or sub day to the time.
+// AddDay add or sub days to the time.
 // Play: https://go.dev/play/p/dIGbs_uTdFa
-func AddDay(t time.Time, day int64) time.Time {
-	return t.Add(24 * time.Hour * time.Duration(day))
+func AddDay(t time.Time, days int64) time.Time {
+	return t.Add(24 * time.Hour * time.Duration(days))
+}
+
+// AddWeek add or sub weeks to the time.
+// play: todo
+func AddWeek(t time.Time, weeks int64) time.Time {
+	return t.Add(7 * 24 * time.Hour * time.Duration(weeks))
+}
+
+// AddMonth add or sub months to the time.
+// Play: todo
+func AddMonth(t time.Time, months int64) time.Time {
+	return t.AddDate(0, int(months), 0)
 }

 // AddYear add or sub year to the time.
 // Play: https://go.dev/play/p/MqW2ujnBx10
 func AddYear(t time.Time, year int64) time.Time {
-	return t.Add(365 * 24 * time.Hour * time.Duration(year))
+	return t.AddDate(int(year), 0, 0)
+}
+
+// AddDaySafe add or sub days to the time and ensure that the returned date does not exceed the valid date of the target year and month.
+// Play: todo
+func AddDaySafe(t time.Time, days int) time.Time {
+	t = t.AddDate(0, 0, days)
+	year, month, day := t.Date()
+
+	lastDayOfMonth := time.Date(year, month+1, 0, 0, 0, 0, 0, t.Location()).Day()
+
+	if day > lastDayOfMonth {
+		t = time.Date(year, month, lastDayOfMonth, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
+	}
+
+	return t
+}
+
+// AddMonthSafe add or sub months to the time and ensure that the returned date does not exceed the valid date of the target year and month.
+// Play: todo
+func AddMonthSafe(t time.Time, months int) time.Time {
+	year := t.Year()
+	month := int(t.Month()) + months
+
+	for month > 12 {
+		month -= 12
+		year++
+	}
+	for month < 1 {
+		month += 12
+		year--
+	}
+
+	daysInMonth := time.Date(year, time.Month(month+1), 0, 0, 0, 0, 0, time.UTC).Day()
+
+	day := t.Day()
+	if day > daysInMonth {
+		day = daysInMonth
+	}
+
+	return time.Date(year, time.Month(month), day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
+}
+
+// AddYearSafe add or sub years to the time and ensure that the returned date does not exceed the valid date of the target year and month.
+// Play: todo
+func AddYearSafe(t time.Time, years int) time.Time {
+	year, month, day := t.Date()
+	year += years
+
+	if month == time.February && day == 29 {
+		if !IsLeapYear(year) {
+			day = 28
+		}
+	}
+
+	return time.Date(year, month, day, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
 }

 // GetNowDate return format yyyy-mm-dd of current date.
--- a/datetime/datetime_example_test.go
+++ b/datetime/datetime_example_test.go
@@ -7,71 +7,141 @@ import (
 )

 func ExampleAddDay() {
-	now := time.Now()
+	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-	tomorrow := AddDay(now, 1)
-	diff1 := tomorrow.Sub(now)
+	after1Day := AddDay(date, 1)
+	before1Day := AddDay(date, -1)

-	yesterday := AddDay(now, -1)
-	diff2 := yesterday.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
+	fmt.Println(after1Day.Format("2006-01-02 15:04:05"))
+	fmt.Println(before1Day.Format("2006-01-02 15:04:05"))

 	// Output:
-	// 24h0m0s
-	// -24h0m0s
+	// 2021-01-02 00:00:00
+	// 2020-12-31 00:00:00
+}
+
+func ExampleAddWeek() {
+	date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+	after2Weeks := AddWeek(date, 2)
+	before2Weeks := AddWeek(date, -2)
+
+	fmt.Println(after2Weeks.Format("2006-01-02"))
+	fmt.Println(before2Weeks.Format("2006-01-02"))
+
+	// Output:
+	// 2021-01-15
+	// 2020-12-18
+}
+
+func ExampleAddMonth() {
+	date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+	after2Months := AddMonth(date, 2)
+	before2Months := AddMonth(date, -2)
+
+	fmt.Println(after2Months.Format("2006-01-02"))
+	fmt.Println(before2Months.Format("2006-01-02"))
+
+	// Output:
+	// 2021-03-01
+	// 2020-11-01
 }

 func ExampleAddHour() {
-	now := time.Now()
+	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-	after2Hours := AddHour(now, 2)
-	diff1 := after2Hours.Sub(now)
+	after2Hours := AddHour(date, 2)
+	before2Hours := AddHour(date, -2)

-	before2Hours := AddHour(now, -2)
-	diff2 := before2Hours.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
+	fmt.Println(after2Hours.Format("2006-01-02 15:04:05"))
+	fmt.Println(before2Hours.Format("2006-01-02 15:04:05"))

 	// Output:
-	// 2h0m0s
-	// -2h0m0s
+	// 2021-01-01 02:00:00
+	// 2020-12-31 22:00:00
 }

 func ExampleAddMinute() {
-	now := time.Now()
+	date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-	after2Minutes := AddMinute(now, 2)
-	diff1 := after2Minutes.Sub(now)
+	after2Minutes := AddMinute(date, 2)
+	before2Minutes := AddMinute(date, -2)

-	before2Minutes := AddMinute(now, -2)
-	diff2 := before2Minutes.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
+	fmt.Println(after2Minutes.Format("2006-01-02 15:04:05"))
+	fmt.Println(before2Minutes.Format("2006-01-02 15:04:05"))

 	// Output:
-	// 2m0s
-	// -2m0s
+	// 2021-01-01 00:02:00
+	// 2020-12-31 23:58:00
 }

 func ExampleAddYear() {
-	now := time.Now()
+	date, _ := time.Parse("2006-01-02", "2021-01-01")

-	after1Year := AddYear(now, 1)
-	diff1 := after1Year.Sub(now)
+	after2Years := AddYear(date, 2)
+	before2Years := AddYear(date, -2)

-	before1Year := AddYear(now, -1)
-	diff2 := before1Year.Sub(now)
-
-	fmt.Println(diff1)
-	fmt.Println(diff2)
+	fmt.Println(after2Years.Format("2006-01-02"))
+	fmt.Println(before2Years.Format("2006-01-02"))

 	// Output:
-	// 8760h0m0s
-	// -8760h0m0s
+	// 2023-01-01
+	// 2019-01-01
+}
+
+func ExampleAddDaySafe() {
+	leapYearDate1, _ := time.Parse("2006-01-02", "2024-02-29")
+	result1 := AddDaySafe(leapYearDate1, 1)
+
+	leapYearDate2, _ := time.Parse("2006-01-02", "2024-03-01")
+	result2 := AddDaySafe(leapYearDate2, -1)
+
+	nonLeapYearDate1, _ := time.Parse("2006-01-02", "2025-02-28")
+	result3 := AddDaySafe(nonLeapYearDate1, 1)
+
+	nonLeaYearDate2, _ := time.Parse("2006-01-02", "2025-03-01")
+	result4 := AddDaySafe(nonLeaYearDate2, -1)
+
+	fmt.Println(result1.Format("2006-01-02"))
+	fmt.Println(result2.Format("2006-01-02"))
+	fmt.Println(result3.Format("2006-01-02"))
+	fmt.Println(result4.Format("2006-01-02"))
+
+	// Output:
+	// 2024-03-01
+	// 2024-02-29
+	// 2025-03-01
+	// 2025-02-28
+}
+
+func ExampleAddMonthSafe() {
+	date1, _ := time.Parse("2006-01-02", "2025-01-31")
+	result1 := AddMonthSafe(date1, 1)
+
+	date2, _ := time.Parse("2006-01-02", "2024-02-29")
+	result2 := AddMonthSafe(date2, -1)
+
+	fmt.Println(result1.Format("2006-01-02"))
+	fmt.Println(result2.Format("2006-01-02"))
+
+	// Output:
+	// 2025-02-28
+	// 2024-01-29
+}
+
+func ExampleAddYearSafe() {
+	date, _ := time.Parse("2006-01-02", "2020-02-29")
+
+	result1 := AddYearSafe(date, 1)
+	result2 := AddYearSafe(date, -1)
+
+	fmt.Println(result1.Format("2006-01-02"))
+	fmt.Println(result2.Format("2006-01-02"))
+
+	// Output:
+	// 2021-02-28
+	// 2019-02-28
 }

 func ExampleGetNowDate() {
--- a/datetime/datetime_test.go
+++ b/datetime/datetime_test.go
@@ -9,78 +9,427 @@ import (

 func TestAddYear(t *testing.T) {
 	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestAddDay")

-	now := time.Now()
-	after2Years := AddYear(now, 1)
-	diff1 := after2Years.Sub(now)
-	assert.Equal(float64(8760), diff1.Hours())
+	tests := []struct {
+		inputDate string
+		years     int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     1,
+			expected:  "2022-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     -1,
+			expected:  "2020-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     0,
+			expected:  "2021-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     2,
+			expected:  "2023-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     3,
+			expected:  "2024-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			years:     4,
+			expected:  "2025-01-01 00:00:00",
+		},
+	}

-	before2Years := AddYear(now, -1)
-	diff2 := before2Years.Sub(now)
-	assert.Equal(float64(-8760), diff2.Hours())
-}
-
-func TestBetweenSeconds(t *testing.T) {
-	t.Parallel()
-
-	assert := internal.NewAssert(t, "TestBetweenSeconds")
-
-	today := time.Now()
-	tomorrow := AddDay(today, 1)
-	yesterday := AddDay(today, -1)
-
-	result1 := BetweenSeconds(today, tomorrow)
-	result2 := BetweenSeconds(today, yesterday)
-
-	assert.Equal(int64(86400), result1)
-	assert.Equal(int64(-86400), result2)
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
+		result := AddYear(date, int64(tt.years))
+		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
+	}
 }

 func TestAddDay(t *testing.T) {
 	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestAddDay")

-	now := time.Now()
-	after2Days := AddDay(now, 2)
-	diff1 := after2Days.Sub(now)
-	assert.Equal(float64(48), diff1.Hours())
+	tests := []struct {
+		inputDate string
+		days      int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      1,
+			expected:  "2021-01-02 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      -1,
+			expected:  "2020-12-31 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      0,
+			expected:  "2021-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      2,
+			expected:  "2021-01-03 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      3,
+			expected:  "2021-01-04 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			days:      4,
+			expected:  "2021-01-05 00:00:00",
+		},
+	}

-	before2Days := AddDay(now, -2)
-	diff2 := before2Days.Sub(now)
-	assert.Equal(float64(-48), diff2.Hours())
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
+		result := AddDay(date, int64(tt.days))
+		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
+	}
 }

 func TestAddHour(t *testing.T) {
 	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestAddHour")

-	now := time.Now()
-	after2Hours := AddHour(now, 2)
-	diff1 := after2Hours.Sub(now)
-	assert.Equal(float64(2), diff1.Hours())
+	tests := []struct {
+		inputDate string
+		hours     int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     1,
+			expected:  "2021-01-01 01:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     -1,
+			expected:  "2020-12-31 23:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     0,
+			expected:  "2021-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     24,
+			expected:  "2021-01-02 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     25,
+			expected:  "2021-01-02 01:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     48,
+			expected:  "2021-01-03 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			hours:     49,
+			expected:  "2021-01-03 01:00:00",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
+		result := AddHour(date, int64(tt.hours))
+		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
+	}

-	before2Hours := AddHour(now, -2)
-	diff2 := before2Hours.Sub(now)
-	assert.Equal(float64(-2), diff2.Hours())
 }

 func TestAddMinute(t *testing.T) {
 	t.Parallel()
-
 	assert := internal.NewAssert(t, "TestAddMinute")

-	now := time.Now()
-	after2Minutes := AddMinute(now, 2)
-	diff1 := after2Minutes.Sub(now)
-	assert.Equal(float64(2), diff1.Minutes())
+	tests := []struct {
+		inputDate string
+		minutes   int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   1,
+			expected:  "2021-01-01 00:01:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   -1,
+			expected:  "2020-12-31 23:59:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   0,
+			expected:  "2021-01-01 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   60,
+			expected:  "2021-01-01 01:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   61,
+			expected:  "2021-01-01 01:01:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   1440,
+			expected:  "2021-01-02 00:00:00",
+		},
+		{
+			inputDate: "2021-01-01 00:00:00",
+			minutes:   1441,
+			expected:  "2021-01-02 00:01:00",
+		},
+	}

-	before2Minutes := AddMinute(now, -2)
-	diff2 := before2Minutes.Sub(now)
-	assert.Equal(float64(-2), diff2.Minutes())
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02 15:04:05", tt.inputDate)
+		result := AddMinute(date, int64(tt.minutes))
+		assert.Equal(tt.expected, result.Format("2006-01-02 15:04:05"))
+	}
+}
+
+func TestAddWeek(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddWeek")
+
+	tests := []struct {
+		inputDate string
+		weeks     int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01",
+			weeks:     1,
+			expected:  "2021-01-08",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     -1,
+			expected:  "2020-12-25",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     0,
+			expected:  "2021-01-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     52,
+			expected:  "2021-12-31",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     53,
+			expected:  "2022-01-07",
+		},
+		{
+			inputDate: "2021-01-01",
+			weeks:     104,
+			expected:  "2022-12-30",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddWeek(date, int64(tt.weeks))
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
+}
+
+func TestAddMonth(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddMonth")
+
+	tests := []struct {
+		inputDate string
+		months    int
+		expected  string
+	}{
+		{
+			inputDate: "2021-01-01",
+			months:    1,
+			expected:  "2021-02-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    -1,
+			expected:  "2020-12-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    0,
+			expected:  "2021-01-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    12,
+			expected:  "2022-01-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    13,
+			expected:  "2022-02-01",
+		},
+		{
+			inputDate: "2021-01-01",
+			months:    24,
+			expected:  "2023-01-01",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddMonth(date, int64(tt.months))
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
+
+}
+
+func TestAddDaySafe(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddDaySafe")
+
+	tests := []struct {
+		inputDate string
+		days      int
+		expected  string
+	}{
+		{"2025-01-31", 10, "2025-02-10"},
+		{"2025-01-01", 30, "2025-01-31"},
+		{"2025-01-31", 1, "2025-02-01"},
+		{"2025-02-28", 1, "2025-03-01"},
+		{"2024-02-29", 1, "2024-03-01"},
+		{"2024-02-29", 365, "2025-02-28"},
+
+		{"2025-01-31", -10, "2025-01-21"},
+		{"2025-01-01", -30, "2024-12-02"},
+		{"2025-02-01", -1, "2025-01-31"},
+		{"2025-03-01", -1, "2025-02-28"},
+		{"2024-03-01", -1, "2024-02-29"},
+
+		{"2025-01-31", -31, "2024-12-31"},
+		{"2025-12-31", 1, "2026-01-01"},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddDaySafe(date, tt.days)
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
+}
+
+func TestAddMonthSafe(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddMonthSafe")
+
+	tests := []struct {
+		inputDate string
+		months    int
+		expected  string
+	}{
+		{
+			inputDate: "2025-01-31",
+			months:    1,
+			expected:  "2025-02-28",
+		},
+		{
+			inputDate: "2025-01-31",
+			months:    -1,
+			expected:  "2024-12-31",
+		},
+		{
+			inputDate: "2025-12-31",
+			months:    1,
+			expected:  "2026-01-31",
+		},
+		{
+			inputDate: "2025-01-31",
+			months:    -1,
+			expected:  "2024-12-31",
+		},
+		{
+			inputDate: "2024-02-29",
+			months:    1,
+			expected:  "2024-03-29",
+		},
+		{
+			inputDate: "2024-02-29",
+			months:    -1,
+			expected:  "2024-01-29",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddMonthSafe(date, tt.months)
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
+
+}
+
+func TestAddYearSafe(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestAddYearSafe")
+
+	tests := []struct {
+		inputDate string
+		years     int
+		expected  string
+	}{
+		{
+			inputDate: "2020-02-29",
+			years:     1,
+			expected:  "2021-02-28",
+		},
+		{
+			inputDate: "2020-02-29",
+			years:     2,
+			expected:  "2022-02-28",
+		},
+		{
+			inputDate: "2020-02-29",
+			years:     -1,
+			expected:  "2019-02-28",
+		},
+		{
+			inputDate: "2020-02-29",
+			years:     -2,
+			expected:  "2018-02-28",
+		},
+	}
+
+	for _, tt := range tests {
+		date, _ := time.Parse("2006-01-02", tt.inputDate)
+		result := AddYearSafe(date, tt.years)
+		assert.Equal(tt.expected, result.Format("2006-01-02"))
+	}
 }

 func TestGetNowDate(t *testing.T) {
@@ -578,3 +927,19 @@ func TestMaxMin(t *testing.T) {
 	assert.Equal(oneMinuteAgo, min)
 	assert.Equal(oneMinuteAfter, max)
 }
+
+func TestBetweenSeconds(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestBetweenSeconds")
+
+	today := time.Now()
+	tomorrow := AddDay(today, 1)
+	yesterday := AddDay(today, -1)
+
+	result1 := BetweenSeconds(today, tomorrow)
+	result2 := BetweenSeconds(today, yesterday)
+
+	assert.Equal(int64(86400), result1)
+	assert.Equal(int64(-86400), result2)
+}
--- a/docs/api/packages/datetime.md
+++ b/docs/api/packages/datetime.md
@@ -23,9 +23,14 @@ import (
 ## 目录

 -   [AddDay](#AddDay)
+-   [AddWeek](#AddWeek)
+-   [AddMonth](#AddMonth)
 -   [AddHour](#AddHour)
 -   [AddMinute](#AddMinute)
 -   [AddYear](#AddYear)
+-   [AddDaySafe](#AddDaySafe)
+-   [AddMonthSafe](#AddMonthSafe)
+-   [AddYearSafe](#AddYearSafe)
 -   [BeginOfMinute](#BeginOfMinute)
 -   [BeginOfHour](#BeginOfHour)
 -   [BeginOfDay](#BeginOfDay)
@@ -109,7 +114,7 @@ import (
 <b>函数签名:</b>

 ```go
-func AddDay(t time.Time, day int64) time.Time
+func AddDay(t time.Time, days int64) time.Time
 ```

 <b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dIGbs_uTdFa)</span></b>
@@ -124,20 +129,89 @@ import (
 )

 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-    tomorrow := datetime.AddDay(now, 1)
-    diff1 := tomorrow.Sub(now)
+    after1Day := datetime.AddDay(date, 1)
+    before1Day := datetime.AddDay(date, -1)

-    yesterday := datetime.AddDay(now, -1)
-    diff2 := yesterday.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after1Day.Format("2006-01-02 15:04:05"))
+    fmt.Println(before1Day.Format("2006-01-02 15:04:05"))

    // Output:
-    // 24h0m0s
-    // -24h0m0s
+    // 2021-01-02 00:00:00
+    // 2020-12-31 00:00:00
+}
+```
+
+### <span id="AddWeek">AddWeek</span>
+
+<p>将日期加/减星期数。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddWeek(t time.Time, weeks int64) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+    after2Weeks := datetime.AddWeek(date, 2)
+    before2Weeks := datetime.AddWeek(date, -2)
+
+    fmt.Println(after2Weeks.Format("2006-01-02"))
+    fmt.Println(before2Weeks.Format("2006-01-02"))
+
+    // Output:
+    // 2021-01-15
+    // 2020-12-18
+}
+```
+
+### <span id="AddMonth">AddMonth</span>
+
+<p>将日期加/减月数。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddMonth(t time.Time, months int64) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+    after2Months := datetime.AddMonth(date, 2)
+    before2Months := datetime.AddMonth(date, -2)
+
+    fmt.Println(after2Months.Format("2006-01-02"))
+    fmt.Println(before2Months.Format("2006-01-02"))
+
+    // Output:
+    // 2021-03-01
+    // 2020-11-01
 }
 ```

@@ -148,7 +222,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func AddHour(t time.Time, hour int64) time.Time
+func AddHour(t time.Time, hours int64) time.Time
 ```

 <b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/rcMjd7OCsi5)</span></b>
@@ -163,20 +237,17 @@ import (
 )

 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-    after2Hours := datetime.AddHour(now, 2)
-    diff1 := after2Hours.Sub(now)
+    after2Hours := datetime.AddHour(date, 2)
+    before2Hours := datetime.AddHour(date, -2)

-    before2Hours := datetime.AddHour(now, -2)
-    diff2 := before2Hours.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Hours.Format("2006-01-02 15:04:05"))
+    fmt.Println(before2Hours.Format("2006-01-02 15:04:05"))

    // Output:
-    // 2h0m0s
-    // -2h0m0s
+    // 2021-01-01 02:00:00
+    // 2020-12-31 22:00:00
 }
 ```

@@ -187,7 +258,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func AddMinute(t time.Time, minute int64) time.Time
+func AddMinute(t time.Time, minutes int64) time.Time
 ```

 <b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nT1heB1KUUK)</span></b>
@@ -202,20 +273,17 @@ import (
 )

 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-    after2Minutes := datetime.AddMinute(now, 2)
-    diff1 := after2Minutes.Sub(now)
+    after2Minutes := datetime.AddMinute(date, 2)
+    before2Minutes := datetime.AddMinute(date, -2)

-    before2Minutes := datetime.AddMinute(now, -2)
-    diff2 := before2Minutes.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Minutes.Format("2006-01-02 15:04:05"))
+    fmt.Println(before2Minutes.Format("2006-01-02 15:04:05"))

    // Output:
-    // 2m0s
-    // -2m0s
+    // 2021-01-01 00:02:00
+    // 2020-12-31 23:58:00
 }
 ```

@@ -226,7 +294,7 @@ func main() {
 <b>函数签名:</b>

 ```go
-func AddYear(t time.Time, year int64) time.Time
+func AddYear(t time.Time, years int64) time.Time
 ```

 <b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MqW2ujnBx10)</span></b>
@@ -241,20 +309,137 @@ import (
 )

 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02", "2021-01-01")

-    after1Year := datetime.AddYear(now, 1)
-    diff1 := after1Year.Sub(now)
+    after2Years := AddYear(date, 2)
+    before2Years := AddYear(date, -2)

-    before1Year := datetime.AddYear(now, -1)
-    diff2 := before1Year.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Years.Format("2006-01-02"))
+    fmt.Println(before2Years.Format("2006-01-02"))

    // Output:
-    // 8760h0m0s
-    // -8760h0m0s
+    // 2023-01-01
+    // 2019-01-01
+}
+```
+
+### <span id="AddDaySafe">AddDaySafe</span>
+
+<p>增加/减少指定的天数，并确保日期是有效日期。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddDaySafe(t time.Time, days int) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    leapYearDate1, _ := time.Parse("2006-01-02", "2024-02-29")
+    result1 := datetime.AddDaySafe(leapYearDate1, 1)
+
+    leapYearDate2, _ := time.Parse("2006-01-02", "2024-03-01")
+    result2 := datetime.AddDaySafe(leapYearDate2, -1)
+
+    nonLeapYearDate1, _ := time.Parse("2006-01-02", "2025-02-28")
+    result3 := datetime.AddDaySafe(nonLeapYearDate1, 1)
+
+    nonLeaYearDate2, _ := time.Parse("2006-01-02", "2025-03-01")
+    result4 := datetime.AddDaySafe(nonLeaYearDate2, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+    fmt.Println(result3.Format("2006-01-02"))
+    fmt.Println(result4.Format("2006-01-02"))
+
+    // Output:
+    // 2024-03-01
+    // 2024-02-29
+    // 2025-03-01
+    // 2025-02-28
+}
+```
+
+### <span id="AddMonthSafe">AddMonthSafe</span>
+
+<p>增加/减少指定的月份，并确保日期是有效日期。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddMonthSafe(t time.Time, months int) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date1, _ := time.Parse("2006-01-02", "2025-01-31")
+    result1 := datetime.AddMonthSafe(date1, 1)
+
+    date2, _ := time.Parse("2006-01-02", "2024-02-29")
+    result2 := datetime.AddMonthSafe(date2, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+
+    // Output:
+    // 2025-02-28
+    // 2024-01-29
+}
+```
+
+### <span id="AddYearSafe">AddYearSafe</span>
+
+<p>增加/减少指定的年份，并确保日期是有效日期。</p>
+
+<b>函数签名:</b>
+
+```go
+func AddYearSafe(t time.Time, years int) time.Time
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2020-02-29")
+
+    result1 := datetime.AddYearSafe(date, 1)
+    result2 := datetime.AddYearSafe(date, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+
+    // Output:
+    // 2021-02-28
+    // 2019-02-28
 }
 ```

--- a/docs/en/api/packages/datetime.md
+++ b/docs/en/api/packages/datetime.md
@@ -24,9 +24,14 @@ import (
 ## Index

 -   [AddDay](#AddDay)
+-   [AddWeek](#AddWeek)
+-   [AddMonth](#AddMonth)
 -   [AddHour](#AddHour)
 -   [AddMinute](#AddMinute)
 -   [AddYear](#AddYear)
+-   [AddDaySafe](#AddDaySafe)
+-   [AddMonthSafe](#AddMonthSafe)
+-   [AddYearSafe](#AddYearSafe)
 -   [BeginOfMinute](#BeginOfMinute)
 -   [BeginOfHour](#BeginOfHour)
 -   [BeginOfDay](#BeginOfDay)
@@ -111,7 +116,7 @@ import (
 <b>Signature:</b>

 ```go
-func AddDay(t time.Time, day int64) time.Time
+func AddDay(t time.Time, days int64) time.Time
 ```

 <b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dIGbs_uTdFa)</span></b>
@@ -126,20 +131,89 @@ import (
 )

 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-    tomorrow := datetime.AddDay(now, 1)
-    diff1 := tomorrow.Sub(now)
+    after1Day := datetime.AddDay(date, 1)
+    before1Day := datetime.AddDay(date, -1)

-    yesterday := datetime.AddDay(now, -1)
-    diff2 := yesterday.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after1Day.Format("2006-01-02 15:04:05"))
+    fmt.Println(before1Day.Format("2006-01-02 15:04:05"))

    // Output:
-    // 24h0m0s
-    // -24h0m0s
+    // 2021-01-02 00:00:00
+    // 2020-12-31 00:00:00
+}
+```
+
+### <span id="AddWeek">AddWeek</span>
+
+<p>Add or sub weeks to time.</p>
+
+<b>Signature:</b>
+
+```go
+func AddWeek(t time.Time, weeks int64) time.Time
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+    after2Weeks := datetime.AddWeek(date, 2)
+    before2Weeks := datetime.AddWeek(date, -2)
+
+    fmt.Println(after2Weeks.Format("2006-01-02"))
+    fmt.Println(before2Weeks.Format("2006-01-02"))
+
+    // Output:
+    // 2021-01-15
+    // 2020-12-18
+}
+```
+
+### <span id="AddMonth">AddMonth</span>
+
+<p>Add or sub months to time.</p>
+
+<b>Signature:</b>
+
+```go
+func AddMonth(t time.Time, months int64) time.Time
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2021-01-01")
+
+    after2Months := datetime.AddMonth(date, 2)
+    before2Months := datetime.AddMonth(date, -2)
+
+    fmt.Println(after2Months.Format("2006-01-02"))
+    fmt.Println(before2Months.Format("2006-01-02"))
+
+    // Output:
+    // 2021-03-01
+    // 2020-11-01
 }
 ```

@@ -165,20 +239,17 @@ import (
 )

 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-    after2Hours := datetime.AddHour(now, 2)
-    diff1 := after2Hours.Sub(now)
+    after2Hours := datetime.AddHour(date, 2)
+    before2Hours := datetime.AddHour(date, -2)

-    before2Hours := datetime.AddHour(now, -2)
-    diff2 := before2Hours.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Hours.Format("2006-01-02 15:04:05"))
+    fmt.Println(before2Hours.Format("2006-01-02 15:04:05"))

    // Output:
-    // 2h0m0s
-    // -2h0m0s
+    // 2021-01-01 02:00:00
+    // 2020-12-31 22:00:00
 }
 ```

@@ -204,20 +275,17 @@ import (
 )

 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02 15:04:05", "2021-01-01 00:00:00")

-    after2Minutes := datetime.AddMinute(now, 2)
-    diff1 := after2Minutes.Sub(now)
+    after2Minutes := datetime.AddMinute(date, 2)
+    before2Minutes := datetime.AddMinute(date, -2)

-    before2Minutes := datetime.AddMinute(now, -2)
-    diff2 := before2Minutes.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Minutes.Format("2006-01-02 15:04:05"))
+    fmt.Println(before2Minutes.Format("2006-01-02 15:04:05"))

    // Output:
-    // 2m0s
-    // -2m0s
+    // 2021-01-01 00:02:00
+    // 2020-12-31 23:58:00
 }
 ```

@@ -243,20 +311,137 @@ import (
 )

 func main() {
-    now := time.Now()
+    date, _ := time.Parse("2006-01-02", "2021-01-01")

-    after1Year := datetime.AddYear(now, 1)
-    diff1 := after1Year.Sub(now)
+    after2Years := AddYear(date, 2)
+    before2Years := AddYear(date, -2)

-    before1Year := datetime.AddYear(now, -1)
-    diff2 := before1Year.Sub(now)
-
-    fmt.Println(diff1)
-    fmt.Println(diff2)
+    fmt.Println(after2Years.Format("2006-01-02"))
+    fmt.Println(before2Years.Format("2006-01-02"))

    // Output:
-    // 8760h0m0s
-    // -8760h0m0s
+    // 2023-01-01
+    // 2019-01-01
+}
+```
+
+### <span id="AddDaySafe">AddDaySafe</span>
+
+<p>Add or sub days to the time and ensure that the returned date does not exceed the valid date of the target year and month.</p>
+
+<b>Signature:</b>
+
+```go
+func AddDaySafe(t time.Time, days int) time.Time
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    leapYearDate1, _ := time.Parse("2006-01-02", "2024-02-29")
+    result1 := datetime.AddDaySafe(leapYearDate1, 1)
+
+    leapYearDate2, _ := time.Parse("2006-01-02", "2024-03-01")
+    result2 := datetime.AddDaySafe(leapYearDate2, -1)
+
+    nonLeapYearDate1, _ := time.Parse("2006-01-02", "2025-02-28")
+    result3 := datetime.AddDaySafe(nonLeapYearDate1, 1)
+
+    nonLeaYearDate2, _ := time.Parse("2006-01-02", "2025-03-01")
+    result4 := datetime.AddDaySafe(nonLeaYearDate2, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+    fmt.Println(result3.Format("2006-01-02"))
+    fmt.Println(result4.Format("2006-01-02"))
+
+    // Output:
+    // 2024-03-01
+    // 2024-02-29
+    // 2025-03-01
+    // 2025-02-28
+}
+```
+
+### <span id="AddMonthSafe">AddMonthSafe</span>
+
+<p>Add or sub months to the time and ensure that the returned date does not exceed the valid date of the target year and month.</p>
+
+<b>Signature:</b>
+
+```go
+func AddMonthSafe(t time.Time, months int) time.Time
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date1, _ := time.Parse("2006-01-02", "2025-01-31")
+    result1 := datetime.AddMonthSafe(date1, 1)
+
+    date2, _ := time.Parse("2006-01-02", "2024-02-29")
+    result2 := datetime.AddMonthSafe(date2, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+
+    // Output:
+    // 2025-02-28
+    // 2024-01-29
+}
+```
+
+### <span id="AddYearSafe">AddYearSafe</span>
+
+<p>Add or sub years to the time and ensure that the returned date does not exceed the valid date of the target year and month.</p>
+
+<b>Signature:</b>
+
+```go
+func AddYearSafe(t time.Time, years int) time.Time
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    date, _ := time.Parse("2006-01-02", "2020-02-29")
+
+    result1 := datetime.AddYearSafe(date, 1)
+    result2 := datetime.AddYearSafe(date, -1)
+
+    fmt.Println(result1.Format("2006-01-02"))
+    fmt.Println(result2.Format("2006-01-02"))
+
+    // Output:
+    // 2021-02-28
+    // 2019-02-28
 }
 ```

@@ -1342,7 +1527,7 @@ import (
 func main() {
    result1 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss")

-	result2 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss", "EST")
+    result2 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss", "EST")

    fmt.Println(result1)
    fmt.Println(result2)
Author	SHA1	Message	Date
dudaodong	a7b28ee864	update crypto fileg	2025-02-18 15:49:52 +08:00
dudaodong	f2823014f2	doc: add doc for AddDaySafe, AddMonthSafe, AddYearSafe	2025-02-18 15:47:43 +08:00
dudaodong	4181c42805	feat: add AddDaySafe, AddMonthSafe, AddYearSafe	2025-02-18 15:37:56 +08:00
dudaodong	a09f5623d6	feat: add AddWeek, AddMonth and update example of some add time functions	2025-02-18 14:10:04 +08:00