Como escrever uma expressão de operador ternário (também conhecido como if) sem se repetir

Por exemplo, algo assim:

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

Existe uma maneira melhor de escrever isso? Novamente, não estou procurando uma resposta para a pergunta exata acima, apenas um exemplo de quando você pode ter operandos repetidos em expressões de operador ternário ...

Pessoalmente, acho que a melhor maneira de fazer isso ainda é a boa e velha ifdeclaração:

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

O código deve ser legível, portanto, ser sucinto não deve significar ser conciso custe o que custar - para isso, você deve reenviar para https://codegolf.stackexchange.com/ - então, em vez disso, eu recomendaria usar uma segunda variável local chamada indexpara maximizar a compreensão de leitura ( com custo mínimo de tempo de execução também, eu observo):

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

Mas se você realmente deseja reduzir essa expressão, porque você é um sádico cruel com seus colegas de trabalho ou colaboradores do projeto, então aqui estão 4 abordagens que você pode usar:

1: Variável temporária em uma vardeclaração

Você pode usar a varcapacidade da instrução para definir (e atribuir) uma segunda variável temporária indexquando separada por vírgulas:

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

2: Função anônima autoexecutável

Outra opção é uma função anônima autoexecutável:

// 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: operador vírgula

Há também o infame "operador de vírgula" que o JavaScript suporta, que também está presente em C e C ++.

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

Você pode usar o operador vírgula quando quiser incluir várias expressões em um local que requer uma única expressão.

Você pode usá-lo para introduzir efeitos colaterais, neste caso, reatribuindo a value:

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

Isso funciona porque var valueé interpretado primeiro (como se fosse uma instrução) e, em seguida , a valueatribuição mais à esquerda, mais interna , e então à direita do operador vírgula e, em seguida, o operador ternário - todo JavaScript válido.

4: Reatribuir em uma subexpressão

O comentador @IllusiveBrian apontou que o uso do operador vírgula (no exemplo anterior) é desnecessário se a atribuição a valuefor usada como uma subexpressão entre parênteses:

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

Observe que o uso de negativos em expressões lógicas pode ser mais difícil para humanos seguirem - portanto, todos os exemplos acima podem ser simplificados para leitura mudando idx !== -1 ? x : ypara idx == -1 ? y : x:

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

Para números

Você pode usar a Math.max()função.

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

Isso manterá os limites do resultado 0até o primeiro resultado maiores do que 0se for esse o caso. E se o resultado de indexOffor, -1ele retornará 0, pois é maior que -1.

Para valores booleanos e booleanos

Para JS, não há regra geral AFAIK, especialmente porque os valores falsos são avaliados.

Mas se algo pode ajudá-lo na maioria das vezes é o operador ou ( ||):

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

Você tem que ter muito cuidado com isso, pois no seu primeiro exemplo, indexOfpode retornar 0e se avaliar 0 || -1retornará -1porque 0é um valor falso .

Não realmente, apenas use outra variável.

Seu exemplo se generaliza para algo assim.

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

Você está testando um valor calculado e, em seguida, atribuindo esse valor a uma variável se ela passar algum predicado. A maneira de evitar o recálculo do valor calculado é óbvia: use uma variável para armazenar o resultado.

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

Entendi o que você quis dizer - parece que deve haver alguma maneira de fazer isso que pareça um pouco mais limpa. Mas acho que essa é a melhor maneira (linguística) de fazer isso. Se você estiver repetindo muito esse padrão em seu código por algum motivo, poderá escrever uma pequena função auxiliar:

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

EDIT: Aqui está, a proposta de coalescência nular agora em JavaScript!

Usar ||

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

é equivalente a

const result = a || 'fallback value';

Se lançar apara Booleanretorna false, resultserá atribuído 'fallback value', caso contrário, o valor de a.

Esteja ciente do caso extremo a === 0, que lança para falsee resultirá (incorretamente) levar 'fallback value'. Use truques como este por sua própria conta e risco.

PS. Linguagens como Swift têm operador de coalescência nil ( ??), que serve a um propósito semelhante. Por exemplo, em Swift você escreveria o result = a ?? "fallback value"que é muito próximo do JavaScriptconst result = a || 'fallback value';

Use uma refatoração de variável de extração :

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

É ainda melhor com em constvez de var. Você também pode fazer uma extração adicional:

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

Na prática, usar nomes mais significativos do que index, conditione value.

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

Você provavelmente está procurando um operador de coalescência. Felizmente, podemos aproveitar o Arrayprotótipo para criar um:

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

Isso poderia ser generalizado para o seu caso, adicionando um parâmetro à função:

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

Eu pessoalmente prefiro duas variantes:

1. Puro se, como @slebetman sugeriu

2. Função separada, que substitui o valor inválido pelo padrão, como neste exemplo:

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

Eu gosto da resposta de @ slebetman. O comentário abaixo expressa preocupação sobre a variável estar em um "estado intermediário". se isso é uma grande preocupação para você, sugiro encapsulá-lo em uma função:

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

Então é só ligar

var value = get_value( someArray );

Você poderia fazer funções mais genéricas se tiver usos para elas em outros lugares, mas não faça engenharia excessiva se for um caso muito específico.

Mas para ser honesto, eu faria apenas como @slebetman, a menos que precisasse reutilizar em vários lugares.

Há duas maneiras de ver sua pergunta: ou você deseja reduzir o comprimento da linha ou deseja evitar especificamente a repetição de uma variável em um ternário. O primeiro é trivial (e muitos outros usuários postaram exemplos):

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

pode ser (e deve ser, dadas as chamadas de função) encurtado assim:

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

Se você está procurando uma solução mais genérica que evite a repetição de uma variável em um ternário, assim:

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

onde fooaparece apenas uma vez. Descartando soluções do formulário:

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

como tecnicamente correto, mas perdendo o ponto, você está sem sorte. Existem operadores, funções e métodos que possuem a sintaxe concisa que você procura, mas tais construções, por definição, não são operadores ternários .

Exemplos:

javascript, usando ||para retornar o RHS quando o LHS é falsey:

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

Use uma função auxiliar:

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

Agora seu código é muito legível e não há repetição.

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

A hierarquia de interesses de codificação é:

1. Correto (incluindo o verdadeiro desempenho ou questões de SLA)
2. Claro
3. Conciso
4. Rápido

Todas as respostas da página até agora parecem corretas, mas acho que minha versão tem a maior clareza, o que é mais importante do que a concisão. Se você não contar a função auxiliar, pois ela pode ser reutilizada, ela também é a mais concisa. A sugestão um tanto semelhante de usar uma função auxiliar infelizmente usa um lambda que, para mim, apenas obscurece o que está fazendo. Uma função mais simples com um propósito que não leva lambda, apenas valores, é muito melhor para mim.

PS Se você gosta da sintaxe ES6:

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

Acho que o ||operador pode ser adaptado para indexOf:

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

O valor retornado é deslocado para cima em 1, tornando 0 de -1, que é falsey e, portanto, é substituído pelo segundo 1. Em seguida, ele é deslocado de volta.

No entanto, lembre-se de que a legibilidade é superior a evitar a repetição.

Esta é uma solução simples com NOT bit a bit e um valor padrão de-1 que resulta posteriormente em zero.

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

Funciona basicamente com um NOT bit a bit duplo, que retorna o valor original ou um valor padrão, que após aplicar o NOT bit a bit retorna zero.

Vamos dar uma olhada na tabela da verdade:

 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

Você pode usar a reatribuição:

• inicializar a variável com um valor
• usar a serialização do &&operador para reatribuição, pois se a primeira condição for falsa, a segunda expressão não será avaliada

Ex.

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

Dado o código de exemplo em Question, não está claro como seria determinado se 3é ou não definido no índice 0de someArray. -1retornado de .indexOf()seria valioso neste caso, com o propósito de excluir uma não correspondência presumida que poderia ser uma correspondência.

Se 3não estiver incluído na matriz, -1será retornado. Podemos adicionar 1ao resultado de .indexOf()avaliar como falsesendo o resultado -1, onde seguido pelo || ORoperador e 0. Quando valueé referenciado, subtraia 1para obter o índice do elemento da matriz ou -1.

O que leva de volta a simplesmente usar .indexOf()e verificar -1uma ifcondição. Ou, definindo valuecomo undefinedpara evitar possível confusão quanto ao resultado real da condição avaliada relativa a referência original.

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

Um ternário é como um if-else, se você não precisa da parte else, por que não apenas um único if.

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

Para este caso específico, você pode usar o curto-circuito com o ||operador lógico . Como 0é considerado falso, você pode adicionar 1ao seu índice, portanto, se index+1for 0, você obterá o lado direito da lógica - ou como resultado, caso contrário, obterá o seu index+1. Como o resultado desejado é compensado por 1, você pode subtrair 1dele para obter seu índice:

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