Javascript 闰年函数；这个解决方案是如何工作的？

问题是：

给定一年，报告是否为闰年

这里有一件棘手的事情，那就是公历的闰年发生了：

on every year that is evenly divisible by 4
  except every year that is evenly divisible by 100
    unless the year is also evenly divisible by 400

我的解决方案是：

export const isLeap = (year) => {
    const yearModFour = (year % 4) === 0 
    const yearModHundred = (year % 100) === 0
    const yearModFourHundred = (year % 400) === 0 
    const isLeapYear = yearModFour === yearModHundred === yearModFourHundred
    return isLeapYear
}

我之所以得出这个结论，是因为我忽略了以下逻辑：

on every year that is evenly divisible by 4
  and also evenly divisible by 100
    and also evenly divisible by 400

我的问题是，为什么这会起作用

---

我不知道为什么我没有使用&&operans，但同样的，它也不会这样工作。让我们看看谓词

yearModFour===yearmodhunduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduanduandua

对于第1年，谓词的计算结果为：

(False === False) === False
             True === False
                 False

(True === False) === False
           False === False
                 True

(True === True) === True
           True === True
                True

对于第4年，谓词的计算结果为：

(False === False) === False
             True === False
                 False

(True === False) === False
           False === False
                 True

(True === True) === True
           True === True
                True

对于第100年，谓词求值为：

(True === True) === False
           True === False
               False

对于400年，谓词的计算结果为：

(False === False) === False
             True === False
                 False

(True === False) === False
           False === False
                 True

(True === True) === True
           True === True
                True

这就是所有的可能性，这里没有其他的了。这是因为任何可以被400整除的数字都可以被100、4和1整除；任何可以被100整除的数也可以被4和1整除；等等

所以你的结论并不完全正确，因为它暗示了所有模运算之间的逻辑“和”
 我会给出一个技术性的回答

设A=可被4整除，B=可被100整除，C=可被400整除。闰年的定义为：

(A and (not B)) or C

但你写道：

(A === B) === C

我们需要询问这些公式对于所有可能一致的A、B和C值是否在逻辑上等价。我们不必尝试A、B和C的所有组合，因为这些公式通常在逻辑上不等价：

A  B  C   (A & !B)  (A & !B | C)    A==B   (A==B)==C
------------------------------------------------------
T  T  T     F            T          T        T
T  T  F     F            F          T        F 
T  F  T     T            T          F        F   x
T  F  F     T            T          F        T
F  T  T     F            T          F        F   x    
F  T  F     F            F          F        T   x
F  F  T     F            T          T        T 
F  F  F     F            F          T        F

但是，并非所有可能的A、B和C值都是一致的，因为它们相互依赖。只要C为真（可被400整除），其他的也必须为真。每当B为真时，A也必须为真。因此，我们必须考虑的唯一情况是：

A  B  C   (A & !B)  (A & !B | C)    A==B   (A==B)==C
------------------------------------------------------
T  T  T     F            T          T        T
T  T  F     F            F          T        F 
T  F  F     T            T          F        T
F  F  F     F            F          T        F

这是仅有的四种可能的情况（TTT、TTF、TFF和FFF）。在这四种情况中，（A&！B | C）的真值都与（A==B==C）的真值相同，因此代码工作正常

一般来说，这些公式彼此不等价，但在这种情况下，你没问题。
这更像是
yearModFour&（！yearmodhundu | yearmodfourhundu）
我想OP是在说他的代码是有效的-确实有效-但他不明白为什么
yearModFour&！（yearmodhund&！yearmodfourhund）
或
新日期（年，1，29）。getMonth（）==1
那么如果规则在2400年发生变化，你的代码将继续存在：p
因此你的结论并不完全正确，因为它暗示了所有模运算之间的逻辑“和”。
但是如果它发生了变化，你的
4
示例将是
false
，除非我误解了你的句子。你可能想补充一下为什么这4个都是可能的。天真地说，3个布尔变量将有8个组合。@Bergi Okey dokey。我认为这是显而易见的…%400=真，那么%100和%4只能是真的，%100真，那么%4只能是真的，所以很明显为什么没有8种可能性：p@MatteoTassinari根据对JavaScript（ECMAScript）表达式的求值，使用4的示例是正确的。引用是对OP中自我回答的回应，与我的例子无关。