在lodash / ramda中，这些比较案例是否有替代方法？

Question

This is my implementation with examples.

function comparator(values = [], matchValue, mapFn, reduceFn) {
  if (values.length === 0) {
    return undefined !== matchValue;
  }

  return values
    .map(mapFn)
    .reduce(reduceFn);
}

/**
 * const a = 1, b = 2, c = 3;
 * a === 1 || b === 1 || c === 1 // true
 * isEqualOr([1, 2, 3], 1) // true
 */
export const isEqualOr = (values, matchValue) => comparator(
  values,
  matchValue,
  value => value === matchValue,
  (prev, curr) => prev || curr
);
/**
 * a === 1 && b === 1 && c === 1 // false
 * isEqualAnd([1, 2, 3], 1) // false
 */
export const isEqualAnd = (values, matchValue) => comparator(
  values,
  matchValue,
  value => value === matchValue,
  (prev, curr) => prev && curr
);
/**
 * a !== 1 || b !== 1 || c !== 1 // true
 * isNotEqualOr([1, 2, 3], 1) // true
 */
export const isNotEqualOr = (values, matchValue) => comparator(
  values,
  matchValue,
  value => value !== matchValue,
  (prev, curr) => prev || curr
);
/**
 * a !== 1 && b !== 1 && c !== 1 // false
 * isNotEqualAnd([1, 2, 3], 1) // false
 */
export const isNotEqualAnd = (values, matchValue) => comparator(
  values,
  matchValue,
  value => value !== matchValue,
  (prev, curr) => prev && curr
);

1. Do you need such utils in your everyday work?
2. How do you solve this tasks?
3. What do you think about this implementation?
4. There are utils in lodash/ramda libraries for these cases?

Answer 1

In Ramda, I would do it using all and any , using complement for negation:

const isEqualOr = (values, matchValue) => any(equals(matchValue), values);

isEqualOr([1, 2, 3], 1); //=> true
isEqualOr([1, 2, 3], 5); //=> false

const isEqualAnd = (values, matchValue) => all(equals(matchValue), values);

isEqualAnd([1, 2, 3], 2); //=> false
isEqualAnd([2, 2, 2], 2); //=> true

// const isNotEqualOr = (values, matchValue) => any(complement(equals)(matchValue), values);
// or
const isNotEqualOr = complement(isEqualAnd);

isNotEqualOr([1, 2, 3], 2); //=> true
isNotEqualOr([2, 2, 2], 2); //=> false

// const isNotEqualAnd = (values, matchValue) => all(complement(equals)(matchValue), values);
// or
const isNotEqualAnd = complement(isEqualOr);

isNotEqualAnd([1, 2, 3], 2); //=> false
isNotEqualAnd([1, 2, 3], 5); //=> true

It would be fairly easy to make these point-free, but I don't see any good reason to do so.