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

例如，如下所示：

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

有没有更好的方法可以写呢？再说一次，我不是要寻找上述确切问题的答案，而只是当您可能在三元运算符表达式中重复操作数时的一个示例...

我个人认为，执行此操作的最佳方法仍然是好的旧if声明：

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

代码应易于阅读，因此简洁明了不意味着要花多少钱，否则您应该重新发布到https://codegolf.stackexchange.com/-因此，我建议使用第二个局部变量，以index最大程度地提高阅读的理解度（我还注意到，运行时成本也极低）：

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

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

1：a中的临时变量 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/zh-CN/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 );

对于数字

您可以使用该Math.max()功能。

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

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

对于布尔值和布尔值-y

对于JS，没有通用规则AFAIK特别是因为评估伪造值的方式。

但是，如果大多数情况下可以帮助您的是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它是伪造的值。

并非如此，仅使用另一个变量。

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

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)

编辑：在这里，现在在JavaScript中进行空字符合并的建议！

用 ||

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

相当于

const result = a || 'fallback value';

如果强制转换a为Booleanreturn false，result则将分配'fallback value'，否则为a。

注意边缘情况下a === 0，其造型为false和result会（错误地）走'fallback value'。使用此类技巧需要您自担风险。

PS。诸如Swift之类的语言具有n -coalescing运算符（??），其作用类似。例如，在Swift中，您将编写result = a ?? "fallback value"与JavaScript非常接近的代码const result = a || 'fallback value';

使用提取变量重构：

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;

您可能正在寻找合并运算符。幸运的是，我们可以利用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

我个人更喜欢两个变体：

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

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

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

然后打电话

var value = get_value( someArray );

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

但老实说，除非我需要在多个地方重复使用，否则我将以@slebetman的身份工作。

我可以通过两种方式查看您的问题：要么减少行长，要么特别想避免在三进制中重复变量。首先是琐碎的（许多其他用户都张贴了示例）：

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为时用于返回RHS falsey：

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

使用辅助功能：

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了。

PS如果您喜欢ES6语法：

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

我认为||运营商可以针对indexOf：

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

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

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

这是一个按位NOT的简单解决方案，其默认值-1后来变为零。

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

它基本上与双按位NOT一起工作，它返回原始值或默认值，在应用按位NOT以后返回默认值零。

让我们看一下事实表：

 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

您可以使用重新分配：

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

例如

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);

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

如果3未包含在数组中，-1将返回。我们可以添加1到的结果.indexOf()来评价作为false对结果是-1，在随后|| OR运营商和0。当value被引用时，减去1以获得阵列或的元素的索引-1。

这导致回简单地使用.indexOf()，并检查-1在if状态。或者，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);

三进制就像if-else，如果您不需要else部分，那么为什么不只是一个if。

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

对于这种特殊情况，您可以使用逻辑||运算符进行短路。由于0被认为falsy，您可以添加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);