javascript - Javascript 运算符 && 替代选项（限制所需）

Question

我怎么能写以下没有&&？

if(a == 1 && b == 2) { ... }

我可以为操作员创建一个函数吗？

Answer 1

创建一个函数来封装您的操作：

function compare(a, b, value1, value2) {
    if(a === value1) {
        if(b === value2) {
            return true;
        }
    }
    return false;
}

你可以像这样使用它：

if(compare(a, b, 1, 2)) {
    // Your action..
}

Answer 2

你可以这样做

if(a==1){
  if(b==2){
    JS function
  }
}

两者的工作方式相同，但是if(a==1 && b==2)是完全相同的好方法。

Answer 3

不知道你为什么要这样做，但你可以嵌套if语句：

if(a == 1){
    if(b == 2){
        ...
    }
}

或者你可以使用按位运算符，如果你真的只需要考虑2和1

if(b >> a === 1){
    ...
}

有很多方法可以做到这一点，但这实际上取决于您的数据。

Answer 4

您可以利用原型继承，并创建一个构造函数，其原型使用方法扩展。

function Comparer(a, b) {
    if (!(this instanceof Comparer))
        return new Comparer(a, b);

    this.assign(a, b);
    this.compare();
}

Comparer.prototype.result = false;
Comparer.prototype.compare = function() {
    this.result = this.a == this.b;
};
Comparer.prototype.assign = function(a, b) {
    this.a = a;
    this.b = b;
};
Comparer.prototype.and = function(a, b) {
    this.assign(a, b);
    if (this.result !== false) 
        this.compare();
    return this;
};
Comparer.prototype.or = function(a, b) {
    this.assign(a, b);
    if (this.result !== true) 
        this.compare();
    return this;
};

并像这样使用它：

var a = 1,
    b = 2;

if (Comparer(a, 1).and(b, 2).result) 
    console.log("pass");
else
    console.log("fail");

---

我们甚至可以扩展它以摆脱if声明。

Comparer.prototype.then = function(fn) {
    if (this.result === true)
        fn();
    return this;
};
Comparer.prototype.otherwise = function(fn) {
    if (this.result === false)
        fn();
    return this;
};

并像这样使用它：

var a = 1,
    b = 2;

Comparer(a, 1)
    .and(b, 2)
    .then(function() { console.log("pass"); })
    .otherwise(function() { console.log("fail"); });

---

或者像这样缩短：

var log = Function.bind.bind(console.log, console);

var a = 1,
    b = 2;

Comparer(a, 1)
    .and(b, 2)
    .then(log("pass"))
    .otherwise(log("fail"));

Answer 5

您的问题有点毫无意义，但您可以使用乘法运算符*而不是&&：

if(a==1 * b==2){
    //do something
}

Answer 6

如果你想将操作符实现&&为一个函数，它会变得很难看，因为你需要将条件作为闭包传递，无论何时你关心短路和副作用。

示例：

if(condition && changeTheWorld()) { ... }

// Cannot be translated into a function call of this nature:
if(land(condition, changeTheWorld()) { ... }

相反，您需要创建一个闭包：

if(land(condition, function() {return changeTheWorld()}) {...}

如您所见，它确实很麻烦且冗长，而没有任何优势。

如果你真的需要这个功能，这里有一个

用短路实现

&&如果您将不得评估的条件（在短路的情况下）作为函数而不是表达式传递，则此函数正确模拟了语义。

换句话说，函数按顺序遍历参数，如果一个是函数，它首先评估它，否则它只取它的值，如果是假的，它通过返回假而中止，否则，它继续下一个参数。

function land(){
    for(var i = 0; i < arguments.length; i++) {
        var operand = arguments[i];
        var value = (typeof operand === 'function') ? operand() : operand;
        if (!value) {
            return false;
        }
    }
    return true;
}

示例：

function evaluateTo(result) {
    return function() {
            console.log("Evaluating " + result);
        return result;
    };
}

if(land(true, evaluateTo(1))) {
    console.log("All truthy");
}
// Outputs:
// Evaluating 1
// All truthy

if(land(evaluateTo(1), evaluateTo(0), evaluateTo(true))) {
    console.log("All truthy");
}
// Outputs:
// Evaluating 1
// Evaluating 0

强制性导弹示例

function changeTheWorld() {
    console.log("Missiles away!");
    // Firing 3 missiles
    return nukeTheGlobe(3);
}

if(false && changeTheWorld() == 3) { ... }
// we survived, missiles not fired

if(naiveLand(maybe, changeTheWorld() == 3) { ... }
// Missiles away! no matter what value `maybe` has

if(land(false, function(){ return changeTheWorld() == 3; })) {...}
// we survived, missiles not fired