JavaScript逻辑运算

布尔逻辑和逻辑运算在JavaScript开发中可能不经常出现，但当它们出现时，你会很高兴知道如何使用它们。让我们来探索一些在JavaScript中常见的逻辑运算以及如何以函数式风格实现它们。

逻辑与

逻辑与（&&）运算符如果两个操作数都为true，则返回true，否则返回false。

const and = (a, b) => a && b;

and(true, true); // true
and(true, false); // false
and(false, false); // false

a	b	a && b
true	true	true
true	false	false
false	true	false
false	false	false

逻辑或

逻辑或（||）运算符如果至少有一个操作数为true，则返回true，否则返回false。

const or = (a, b) => a || b;

## 逻辑或

逻辑或（`||`）运算符返回两个操作数中的任意一个为`true`，则返回`true`，否则返回`false`。

```js
const or = (a, b) => a || b;

or(true, true); // true
or(true, false); // true
or(false, false); // false

a	b	a \|\| b
true	true	true
true	false	true
false	true	true
false	false	false

逻辑非

逻辑非（!）运算符如果操作数为false，则返回true，否则返回false。

const not = a => !a;

not(true); // false
not(false); // true

a	!a
true	false
false	true

逻辑异或

逻辑异或（^）运算符如果两个操作数中只有一个为true，则返回true，否则返回false。

[!NOTE]

虽然JavaScript实现了异或（^）运算符，但它只用于位运算。它不是一个逻辑运算符，因此不能用于布尔值。要实现逻辑异或运算符，我们可以使用前面的逻辑运算符的组合。

const nand = (a, b) => !(a && b);

nand(true, true); // false
nand(true, false); // true
nand(false, true); // true
nand(false, false); // true

a	b	!(a && b)
true	true	false
true	false	true
false	true	true
false	false	true

逻辑异或

逻辑异或运算符是逻辑或和逻辑非运算符的组合。如果两个操作数中有且仅有一个为true，则返回true，否则返回false。

const xor = (a, b) => (( a || b ) && !( a && b ));

xor(true, true); // false
xor(true, false); // true
xor(false, true); // true
xor(false, false); // false

a	b	a ^ b
true	true	false
true	false	true
false	true	true
false	false	false

逻辑非或

逻辑非或运算符是逻辑非和逻辑或运算符的组合。如果两个操作数都为false，则返回true，否则返回false。

const nor = (a, b) => !(a||b);

nor(true, true); // false
nor(true, false); // false
nor(false, false); // true

a	b	!(a \|\| b)
true	true	false
true	false	false
false	true	false
false	false	true

逻辑非与

逻辑非与运算符是逻辑非和逻辑与运算符的组合。如果至少有一个操作数为false，则返回true，否则返回false。

const nand = (a, b) => !(a&&b);

nand(true, true); // false
nand(true, false); // true
nand(false, false); // true

a	b	!(a && b)
true	true	false
true	false	true
false	true	true
false	false	true

使用函数实现逻辑运算

我们之前看到的逻辑运算是使用布尔值进行操作的，但是如果我们想要使用函数进行操作怎么办呢？例如，如果我们想要检查两个函数在给定的参数集上是否都返回true，我们就需要修改它们以使其适用于函数。下面是使用函数实现逻辑与、或和非运算符的示例：

// 函数的逻辑与
const both = (f, g) => (...args) => f(...args) && g(...args);
// 函数的逻辑或
const either = (f, g) => (...args) => f(...args) || g(...args);
// 函数的逻辑非
const complement = fn => (...args) => !fn(...args);

实际上，我们可以使用高阶函数来实现任何二元逻辑运算符的函数通用实现。

const logicalOperator =
  operatorFn =>
  (f, g) =>
  (...args) =>
    operatorFn(f(...args), g(...args));

const and = (a, b) => a && b;
const or = (a, b) => a || b;

const both = logicalOperator(and);
const either = logicalOperator(or);

```javascript
const isEven = num => num % 2 === 0;
const isPositive = num => num > 0;
const isPositiveAndEven = both(isEven, isPositive);
const isPositiveOrEven = either(isEven, isPositive);

isPositiveAndEven(4); // true
isPositiveAndEven(-2); // false
isPositiveOrEven(4); // true
isPositiveOrEven(-2); // true

const isEven = num => num % 2 === 0;
const isPositive = num => num > 0;
const isPositiveAndEven = both(isEven, isPositive);
const isPositiveOrEven = either(isEven, isPositive);

isPositiveAndEven(4); // true
isPositiveAndEven(-2); // false
isPositiveOrEven(4); // true
isPositiveOrEven(-2); // true