如何在不重复自己的情况下编写三元运算符（又名 if）表达式

Question

例如，像这样的：

var value = someArray.indexOf(3) !== -1 ? someArray.indexOf(3) : 0

有没有更好的写法？同样，我不是在寻求上述确切问题的答案，只是一个示例，说明您何时可能在三元运算符表达式中重复操作数...

Answer 1

对于这种特殊情况，您可以使用逻辑 || 运算符进行短路。由于0 被认为是虚假的，您可以将1 添加到您的索引中，因此，如果index+1 是0，那么您将得到逻辑或的右侧作为结果，否则，您会得到你的index+1。由于您想要的结果被1 抵消，因此您可以从中减去1 以获得您的索引：

const someArray = [1, 2, 3, 4];
const v = ((someArray.indexOf(3)+1) || 1)-1;
console.log(v);

Answer 2

代码应该是可读的，所以简洁并不意味着不惜一切代价保持简洁——因为你应该重新发布到https://codegolf.stackexchange.com/——所以我建议使用第二个名为index的局部变量来最大限度地提高阅读的可理解性（我注意到，运行时成本也最低）：

var index = someArray.indexOf( 3 );
var value = index == -1 ? 0 : index;

但如果你真的想减少这种表达，因为你对你的同事或项目合作者是一个残忍的虐待狂，那么你可以使用以下 4 种方法：

1：var 语句中的临时变量

您可以使用var 语句的功能来定义（和分配）第二个临时变量index（用逗号分隔）：

var index = someArray.indexOf(3), value = index !== -1 ? index: 0;

2：自执行匿名函数

另一种选择是自执行匿名函数：

// Traditional syntax:
var value = function( x ) { return x !== -1 ? x : 0 }( someArray.indexOf(3) );

// ES6 syntax:
var value = ( x => x !== -1 ? x : 0 )( someArray.indexOf(3) );

3：逗号运算符

还有 JavaScript 支持的臭名昭著的“逗号运算符”，它也存在于 C 和 C++ 中。

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator

当您想在需要单个表达式的位置包含多个表达式时，可以使用逗号运算符。

您可以使用它来引入副作用，在这种情况下通过重新分配给value：

var value = ( value = someArray.indexOf(3), value !== -1 ? value : 0 );

这是因为var value首先被解释（因为它是一个语句），然后最左边，最里面的value赋值，然后是逗号的右边运算符，然后是三元运算符 - 所有合法的 JavaScript。

4：在子表达式中重新赋值

评论员@IllusiveBrian 指出，如果将value 的赋值用作带括号的子表达式，则不需要使用逗号运算符（在前面的示例中）：

var value = ( ( value = someArray.indexOf(3) ) !== -1 ? value : 0 );

请注意，在逻辑表达式中使用否定词对人类来说可能更难理解 - 因此可以通过将idx !== -1 ? x : y 更改为idx == -1 ? y : x 来简化上述所有示例以方便阅读：

var value = ( ( value = someArray.indexOf(3) ) == -1 ? 0 : value );

Answer 3

编辑：在这里，Nullary-coalescing 的提案现在在 JavaScript 中！

---

使用||

const result = a ? a : 'fallback value';

等价于

const result = a || 'fallback value';

如果将a 转换为Boolean 返回false，则result 将被分配'fallback value'，否则为a 的值。

---

注意极端情况a === 0，它转换为false 和result 将（错误地）采用'fallback value'。使用此类技巧需要您自担风险。

---

PS。诸如 Swift 之类的语言具有 nil-coalescing 运算符 (??)，其用途类似。例如，在 Swift 中，您可以编写 result = a ?? "fallback value"，它非常接近 JavaScript 的 const result = a || 'fallback value';

Answer 4

三元就像一个 if-else，如果你不需要 else 部分，为什么不只是一个 if 代替..

if ((value = someArray.indexOf(3)) < 0) value = 0;

Answer 5

这是一个简单的解决方案，使用 bitwise NOT 和默认值 -1，稍后会为零。

index = ~(~array.indexOf(3) || -1);

它基本上适用于双位非，它返回原始值或默认值，应用位非后返回零。

让我们来看看真值表：

 indexOf    ~indexOf   boolean    default     value      result         comment
---------  ---------  ---------  ---------  ---------  ---------  ------------------
      -1          0     falsy          -1         -1          0   take default value
       0         -1    truthy                     -1          0
       1         -2    truthy                     -2          1
       2         -3    truthy                     -3          2

Answer 6

使用extract variable refactoring：

var index = someArray.indexOf(3);
var value = index !== -1 ? index : 0

使用const 而不是var 会更好。您还可以进行额外的提取：

const index = someArray.indexOf(3);
const condition = index !== -1;
const value = condition ? index : 0;

在实践中，使用比index、condition 和value 更有意义的名称。

const threesIndex = someArray.indexOf(3);
const threeFound = threesIndex !== -1;
const threesIndexOrZero = threeFound ? threesIndex : 0;

Answer 7

我可以通过两种方式查看您的问题：您要么想减少行长，要么特别想避免在三元组中重复变量。第一个是微不足道的（许多其他用户已经发布了示例）：

var value = someArray.indexOf(3) !== -1 ? someArray.indexOf(3) : 0;

可以（并且应该，给定函数调用）像这样缩短：

var value = someArray.indexOf(3);
value = value !== -1 ? value : 0;

如果您正在寻找一种更通用的解决方案来防止三元中的变量重复，如下所示：

var value = conditionalTest(foo) ? foo : bar;

foo 只出现一次。丢弃形式的解决方案：

var cad = foo;
var value = conditionalTest(foo) ? cad : bar;

技术上正确但没有抓住重点，那么你就不走运了。有些运算符、函数和方法拥有您所寻求的简洁语法，但根据定义，这些构造不是三元运算符。

例子：

javascript，当LHS为falsey时使用||返回RHS：

var value = foo || bar; // equivalent to !foo ? bar : foo

Answer 8

我个人更喜欢两种变体：

1. 如果像@slebetman 建议的那样纯属

2. 分离函数，将无效值替换为默认值，如下例所示：

function maskNegative(v, def) {
  return v >= 0 ? v : def;
}

Array.prototype.indexOfOrDefault = function(v, def) {
  return maskNegative(this.indexOf(v), def);
}

var someArray = [1, 2];
console.log(someArray.indexOfOrDefault(2, 0)); // index is 1
console.log(someArray.indexOfOrDefault(3, 0)); // default 0 returned
console.log(someArray.indexOfOrDefault(3, 123)); // default 123 returned

Answer 9

我认为||运算符可以定制为indexOf：

var value = ((someArray.indexOf(3) + 1) || 1) - 1;

返回值上移 1，从 -1 变为 0，这是错误的，因此被第二个 1 替换。然后它被移回。

但是，请记住，可读性优于避免重复。

Answer 10

使用辅助函数：

function translateValue(value, match, translated) {
   return value === match ? translated : value;
}

现在你的代码可读性很强，没有重复。

var value = translateValue(someArray.indexOf(3), -1, 0);

编码关注点的层次结构是：

1. 正确（包括真正的性能或 SLA 问题）
2. 清除
3. 简洁
4. 快速

到目前为止，页面上的所有答案似乎都是正确的，但我认为我的版本具有最高的清晰度，这比简洁更重要。如果你不计算辅助函数——因为它可以被重用——它也是最简洁的。不幸的是，使用辅助函数的有点类似的建议使用了一个 lambda，对我来说，它只是掩盖了它在做什么。一个更简单的函数，它的目的是不使用 lambda，只使用值，对我来说要好得多。

附：如果你喜欢 ES6 语法：

const translateValue = (value, match, translated) => value === match ? translated : value;
let value = translateValue(someArray.indexOf(3), -1, 0); // or const

Answer 11

我喜欢@slebetman 的回答。它下面的评论表达了对变量处于“中间状态”的担忧。如果这对您来说是一个大问题，那么我建议将其封装在一个函数中：

function get_value(arr) {
   var value = arr.indexOf(3);
   if (value === -1) {
     value = 0;
   }
   return value;
}

然后打电话

var value = get_value( someArray );

如果您在其他地方使用它们，您可以做更多通用功能，但如果是非常具体的情况，请不要过度设计。

但老实说，除非我需要在多个地方重复使用，否则我只会像 @slebetman 那样做。

Answer 12

您可能正在寻找合并运算符。幸运的是，我们可以利用 Array 原型创建一个：

Array.prototype.coalesce = function() {
    for (var i = 0; i < this.length; i++) {
        if (this[i] != false && this[i] != null) return this[i];
    }
}

[null, false, 0, 5, 'test'].coalesce(); // returns 5

这可以通过向函数添加参数来进一步推广到您的情况：

Array.prototype.coalesce = function(valid) {
    if (typeof valid !== 'function') {
        valid = function(a) {
            return a != false && a != null;
        }
    }

    for (var i = 0; i < this.length; i++) {
        if (valid(this[i])) return this[i];
    }
}

[null, false, 0, 5, 'test'].coalesce(); // still returns 5
[null, false, 0, 5, 'test'].coalesce(function(a){return a !== -1}); // returns null
[null, false, 0, 5, 'test'].coalesce(function(a){return a != null}); //returns false

Answer 13

不是真的，只是使用另一个变量。

您的示例可以概括为这样的内容。

var x = predicate(f()) ? f() : default;

您正在测试一个计算值，然后将该值分配给一个变量，如果它通过了某个谓词。避免重新计算计算值的方法很明显：使用变量来存储结果。

var computed = f();
var x = predicate(computed) ? computed : default;

我明白你的意思 - 似乎应该有某种方法可以做到这一点，看起来更干净一些。但我认为这是最好的方式（习惯上）做到这一点。如果您出于某种原因在代码中多次重复这种模式，您可能会编写一个小辅助函数：

var setif = (value, predicate, default) => predicate(value) ? value : default;
var x = setif(someArray.indexOf(3), x => x !== -1, 0)

Answer 14

对于数字

您可以使用Math.max() 函数。

var value = Math.max( someArray.indexOf('y'), 0 );

如果是这种情况，它将保持结果的边界从0 直到第一个结果大于0。如果indexOf 的结果是-1，它将返回大于-1 的0。

对于布尔值和布尔值

对于 JS，AFAIK 没有特别的通用规则，因为如何评估 falsy 值。

但如果大多数时候可以帮助您的是 or 运算符 (||)：

// Instead of
var variable = this_one === true ? this_one : or_this_one;
// you can use
var variable = this_one || or_this_one;

您必须非常小心，因为在您的第一个示例中，indexOf 可以返回0，如果您评估0 || -1，它将返回-1，因为0 是falsy 值。

Answer 15

鉴于问题中的示例代码，尚不清楚如何确定3 是否设置在someArray 的索引0 处。从.indexOf() 返回的-1 在这种情况下很有价值，目的是排除可能是匹配的假定不匹配。

如果数组中不包含3，则返回-1。我们可以将1 添加到.indexOf() 的结果中，以评估为false，结果为-1，然后是|| OR 运算符和0。当引用value 时，减去1 得到数组元素的索引或-1。

这导致简单地使用.indexOf() 并在if 条件下检查-1。或者，将value 定义为undefined 以避免可能混淆与原始参考相关的评估条件的实际结果。

var someArray = [1,2,3];
var value = someArray.indexOf(3) + 1 || 1;
console.log(value -= 1);

var someArray = [1,2,3];
var value = someArray.indexOf(4) + 1 || 1;
// how do we know that `4` is not at index `0`?
console.log(value -= 1);

var someArray = [1,2,3];
var value = someArray.indexOf(4) + 1 || void 0;
// we know for certain that `4` is not found in `someArray`
console.log(value, value = value || 0);

Answer 16

您可以使用重新分配：

• 将变量初始化为一个值
• 使用&& 运算符的序列化进行重新赋值，因为如果第一个条件为假，则不会计算第二个表达式

例如

var value = someArray.indexOf(3);
value == -1 && (value=0);

var someArray = [4,3,2,1];

var value = someArray.indexOf(1);
value == -1 && (value=0);
console.log('Found:',value);

var value = someArray.indexOf(5);
value == -1 && (value=0);
console.log('Not Found:',value);

Answer 17

我个人认为最好的方法仍然是旧的if 声明：

var value = someArray.indexOf(3);
if (value === -1) {
  value = 0;
}