那几个年份有闰六月？

Posted 2023-03-29

历法上出现闰六月的年份：
1653年、1664年、1683年、1702年、1721年、1740年、1759年、1778年、1797年、1805年、1816年

1835年、1873年、1892年、1911年、1922年、1930年、1941年、1960年、1979年、1987年、2017年

2025年、2036年、2055年、2074年、2093年、2112年、2131年、2150年、2161年、2169年、2180年

2188年、2199年、2207年、2245年、2256年、2275年、2283年、2294年、2302年、2313年、2332年、

2351年、2370年、2389年、2397年、2408年、2427年、2465年、2484年、2503年、2522年、2533年、

2552年、2571年、2579年、2609年、2617年、2628年、2647年、2666年、2685年、2704年、2723年、

2742年、2753年、2761年、2772年、2780年、2791年、2799年、2810年、2837年、2848年、2867年

2875年、2886年、2894年、2905年、2924年、2943年、2962年、2981年、2989年、3000年、3019年

3030年、3057年、3076年、3095年、3106年、3114年、3125年、3144年、3163年、3171年、3182年

3201年、3209年、3220年、3239年、3247年、3258年、3277年、3296年、3315年、3334年、3353年

3372年、3383年、3391年、3402年、3410年、3467年、3478年、3486年、3497年、3516年、3535年......

扩展资料：

在一年期间，地球和太阳的距离时近时远。地球离太阳远时，是公历6月左右，运动慢，所以两个中气的间隔长，最长超过31天。按之前两个节气长度平均30.5天的长度算，月份中没有中气的可能性大，闰月可能性就大，所以闰四月、闰五月、闰六月机会多。

闰六月是农历中的常见闰月，但它出现的频率和间隔不是一成不变的，此后随时间推移，闰六月的出现频率会从最高逐渐下降。

闰六月一般相隔19年出现一次（如1960年和1979年），但有时相隔38年（如1835年和1873年）出现一次，还有闰六月出现的间隔大于19年而小于38年的情况（如1987年和2017年，相隔30年，又如2810年和2837年，相隔27年）。

两次闰六月出现的最短间隔是8年（如2017年和2025年），次之的是间隔11年（如2025年和2036年）出现一次。闰六月的出现频率仅次于闰五月。且部分出现闰六月的年份，也是七夕节、中元节、中秋节时间最晚的年份。

参考技术A

以下年份出现过闰六月：

1653年、1664年、1683年、1702年、1721年、1740年、1759年、1778年、1797年、1805年、1816年，1835年、1873年、1892年、1911年、1922年、1930年、1941年、1960年、1979年、1987年、2017年。

2025年、2036年、2055年、2074年、2093年、2112年、2131年、2150年、2161年、2169年、2180年，2188年、2199年、2207年、2245年、2256年、2275年、2283年、2294年、2302年、2313年、2332年，2351年、2370年、2389年、2397年、2408年、2427年、2465年、2484年、2503年、2522年、2533年。

2552年、2571年、2579年、2609年、2617年、2628年、2647年、2666年、2685年、2704年、2723年、2742年、2753年、2761年、2772年、2780年、2791年、2799年、2810年、2837年、2848年、2867年......

闰月，是为了使历法符合日月运行的规律而制定的。阳历闰月在二月份多加一天，为二十九天；农历闰月多加一个月，一年为十三个月。

阴历是指我国旧时通用的历法，就是农历，实际上是阴阳合历。它是以两个新月之间时间的间隔作为一个月，这就是所说的“朔望月”；以地球围绕太阳公转一周的时间为一年，也就是所说的“回归年”。

扩展资料：

农历年中月以朔望月长度29.5306日为基础，所以大月为30日，小月为29日。为保证每月的头一天（初一）必须是朔日，就使得大小月的安排不固定，而需要通过严格的观测和计算来确定。

因此，农历中连续两个月是大月或是小月的事是常有的，甚至还出现过如1990年三、四月是小月，九、十、十一、十二连续四个月是大月的罕见特例。

参考技术B

以往的年份有闰六月的有：1653年、1664年、1683年、1702年、1721年、1740年、1759年、1778年、1797年、1805年、1816年，1835年、1873年、1892年、1911年、1922年、1930年、1941年、1960年、1979年、1987年、2017年。

闰六月是指农历为保持和公历(阳历)的回归年同步，古人采用设置闰月的方法解决的一个月份。以24节气分为节气和中气，则没有中气的这个月被历法规定为“闰月”，称作“闰某月”。如果闰月在六月后面，就是闰六月。

扩展资料：

闰月，是一种历法置闰方式。在亚洲（尤其在中国），闰月特指汉历（民间亦称农历）每2至3年增加的一个月。

闰月的计算法

农历年中月以朔望月长度29.5306日为基础，所以大月为30日，小月为29日。为保证每月的头一天（初一）必须是朔日，就使得大小月的安排不固定，而需要通过严格的观测和计算来确定。

因此，农历中连续两个月是大月或是小月的事是常有的，甚至还出现过如1990年三、四月是小月，九、十、十一、十二连续四个月是大月的罕见特例。

现行的置闰方法是两个冬至之间，如仅有12个月则不置闰，若有13个月即置闰。置闰的月从“冬至”开始，当出现第一个没有“中气”的月份，这个月就是闰月，其名称是在前个月的前面加一个“闰”字。

参考资料来源：百度百科-闰六月

百度百科-闰月

参考技术C 1982年5月23日 闰四月小 壬戊年
1984年11月23日 闰十月大 甲子年
1987年7月26日 闰六月大 丁卯年
1990年6月23日 闰五月大 庚午年
1993年4月22日 闰三月大 癸酉年
1995年9月25日 闰八月大 乙亥年
1998年6月24日 闰五月小 戊寅年
2001年5月23日 闰四月大 辛巳年
2004年3月21日 闰二月大 甲申年
2006年8月24日 闰七月大 丙戊年
2009年6月23日 闰五月大 己丑年
2012年5月21日 闰四月小 壬辰年
2014年10月24日 闰九月小 甲午年
2017年7月23日 闰六月大 丁酉年
2020年5月23日 闰四月小 庚子年
2023年3月22日 闰二月大 癸卯年
2025年7月25日 闰六月大 己巳年
2028年6月23日 闰五月大 戊申年
2031年4月22日 闰三月大 辛亥年
2033年8月25日 闰七月大 癸丑年
2036年7月23日 闰六月小 丙辰年
2039年6月22日 闰五月大 己未年
2042年3月22日 闰二月大 壬戊年 参考技术D 1949 闰七月 1952 闰五月 1955 闰三月 1957 闰八月 1960 闰六月
1963 闰四月 1966 闰三月 1968 闰七月 1971 闰五月 1974 闰四月
1976 闰八月 1979 闰六月 1982 闰四月 1984 闰十月 1987 闰六月
1990 闰五月 1993 闰三月 1995 闰八月 1998 闰五月 2001 闰四月
2004 闰二月 2006 闰七月 2009 闰五月 2012 闰四月 2014 闰九月
2017 闰六月 2020 闰四月

TypeScript中那几个奇怪的知识点

写在开头

• 我写了一年多TypeScript,总结了以下几个点，希望可以帮到大家
• 如果感觉写得不错，记得来个关注/在看

比较容易遇到的问题

给一个对象添加属性

interface Obj {
  a: string;
}

const obj: Obj = {
  a: "1",
};

obj.b = 2;

• 此时会出现错误提示:类型“Obj”上不存在属性“b”。
• 要想解决这个问题，要使用索引签名

interface Obj {
  a: string;
  [index: string]: string | number;
}

const obj: Obj = {
  a: "1",
};

obj.b = 2;

• 大家很好奇，为什么我这里会加入[index: string]: string | number;,类型是字符串或者数字。因为:

当你声明一个索引签名时，所有明确的成员都必须符合索引签名

函数重载

• 场景：函数有多个参数，而且参数不确定时，函数运行逻辑不一致

// 重载
function padding(all: number);
function padding(topAndBottom: number, leftAndRight: number);
function padding(top: number, right: number, bottom: number, left: number);
// Actual implementation that is a true representation of all the cases the function body needs to handle
function padding(a: number, b?: number, c?: number, d?: number) {
  if (b === undefined && c === undefined && d === undefined) {
    b = c = d = a;
  } else if (c === undefined && d === undefined) {
    c = a;
    d = b;
  }
  return {
    top: a,
    right: b,
    bottom: c,
    left: d
  };
}

这样函数兼容 传 1、2、4个参数。 但是只要传三个，就会报错。

• 函数重载最重要的是，最终声明（从函数内部看到的真正声明）与所有重载兼容（与上面的索引签名一致）

下载的第三方npm库没有ts声明文件

• 例如:

npm i somePackage --save 
import somePackage from \'somePackage\';

• 但是此时提示:找不到模块“somePackage”或其相应的类型声明。
• 此时你可以在项目根目录下新建index.d.ts，编写如下代码:

declare module \'somePackage\';
...

这个问题迎刃而解

泛型

• 这个问题很容易困扰小白，其实泛型简单来说，就是一个类型变量,如下所示:

class Peter {
  niubi<T>(a: T): T[] {
    return [a];
  }
}

此时的T就是一个泛型,它是一个可变的类型。根据你传入niubi这个方法的参数对象来确定的，当我们传入的a是字符串，那么T就为string.返回的就是一个item为字符串的数组

class Peter {
  niubi<T>(a: T): T[] {
    return [a];
  }
}

const obj = new Peter();

let res = obj.niubi("hehe");

res = 1;

res = ["2"];

此时res = 1会报错不能将类型“number”分配给类型“string[]”, 因为此时TS推断出来，res必定为一个数组，且里面的item是一个字符串.

res = ["2"]则不会报错

• 泛型可以说是TS里面的一个难点，但是其实它只是一个可变的类型变量。
• 调整参数后：

let res2 = obj.niubi(2);

res2 = 2;

• 会报错:不能将类型“number”分配给类型“number[]”。

最后要记住的是，既然是类型变量。那么这个变量也可以是一个泛型。

class Peter {
  niubi<T>(a: T): T[] {
    return [a];
  }
}

const obj = new Peter();

function test<T>(b: T): T {
  return b;
}

let res = obj.niubi(test(1));

• 看到这里肯定有人会说，Peter你脱裤子放屁啊。这个还不如用any.那你再看下面这段代码，我们封装api请求的时候。
• 首先定义好返回的接口。（返回的接口一般都是有统一的格式，状态码和result,data等）

// 请求接口数据
export interface ResponseData<T = any> {
  /**
   * 状态码
   * @type { number }
   */
  code: number;

  /**
   * 数据
   * @type { T }
   */
  result: T;

  /**
   * 消息
   * @type { string }
   */
  message: string;
}

• 这里的data数据是动态的格式，我们可以用泛型来定义。
• 这里用了两次泛型,先定义好返回的data数据，再用泛型方式传入，组装好返回的整个返回数据接口(包含code,result,data)。再接着传入到真正的请求函数中

// 在 axios.ts 文件中对 axios 进行了处理，例如添加通用配置、拦截器等
import Ax from \'./axios\';

import { ResponseData } from \'./interface.ts\';

export function getUser<T>() {
  return Ax.get<ResponseData<T>>(\'/somepath\')
    .then(res => res.data)
    .catch(err => console.error(err));
}

• 在真正的请求函数中使用了泛型，即传入任意类型参数<T>，那么便返回一个Promise风格的Promise<T>数据 ：

const get = <T>(config: { url: string; headers?: { [key: string]: string } }): Promise<T> => {
  const fetchConfig = {
    method: \'GET\',
    Accept: \'application/json\',
    \'Content-Type\': \'application/json\',
    ...(config.headers || {})
  };
  return fetch(config.url, fetchConfig).then<T>(response => response.json());
};

总结两次泛型的连续使用:

1.使用data作为泛型，传入

2.组装成{code,result,data}这种类型接口

3.将第二步的组装后类型作为泛型<T>传入get方法中

4.返回一个Promise风格的Promise<T>数据

这样做的意义，提取可变的数据类型data,让TS推断出这个接口返回的数据是怎么样的。减少不必要的重复代码，即每次接口调取都会返回的数据格式类型：code和result

• 相信你通过这段代码和文字，能真正理解TS的泛型如何用，什么地方使用，以及使用的意义了。

颗粒度定义类型后的问题

• 当我们颗粒度比较细定义了接口以后，可能存在接口复用的问题,例如：

interface test1 {
  a: string;
}

interface test2 {
  b: string;
}

• 此时我想要定义一个两个属性都拥有的对象，那么可以使用联合类型。

const obj: test1 & test2 = {
  a: "1",
  b: "2",
};

• 如果我想定义一个只有a/b的对象,可以使用

const obj: test1 | test2 = {
  a: "1",
};

可能有人会说，怎么会写这么简单的东西。

• 这里是为了接下来的类型兼容性打基础，TS里面最重要的就是type类型，类型系统就是它的核心。
• 我们可以用两个不同的变量来互相赋值来检验，他们的类型是否兼容，例如：

interface Test1 {
  a: number;
  b: number;
  c: string;
}

interface Test2 {
  a: number;
  b: number;
}

let test1: Test1 = {
  a: 1,
  b: 2,
  c: "3",
};

let test2: Test2 = {
  a: 1,
  b: 2,
};

test1 = test2;

此时提示类型 "Test2" 中缺少属性 "c"，但类型 "Test1" 中需要该属性。

• 但是当我们用test1赋值给test2的时候:

test2 = test1;

这个时候是可以的

• 这里其实隐藏着一些逻辑，Test1接口比Test2接口多一个c属性，Test2接口可以说是Test1接口的子类。这是多态性

关于如何处理、判断TS的类型兼容性，大家可以看下面这些类型

• 协变（Covariant）：只在同一个方向；
• 逆变（Contravariant）：只在相反的方向；
• 双向协变（Bivariant）：包括同一个方向和不同方向；
• 不变（Invariant）：如果类型不完全相同，则它们是不兼容的。

写在最后