Як написати вираз потрійного оператора (він же, якщо), не повторюючи себе

Наприклад, щось подібне:

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;

Але якщо ви дійсно хочете скоротити цей вираз, оскільки ви жорстокий садист зі своїми колегами чи співробітниками проектів, то ось чотири підходи, які ви можете використати:

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

Для чисел

Ви можете використовувати Math.max()функцію.

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

Він буде зберігати межі результату 0до моменту, коли перший результат буде більшим, ніж 0якщо це так. І якщо результат з indexOfцього, -1він поверне 0, як більше -1.

Для булевих та булевих значень y

Для JS немає загального правила AFAIK спеціально, тому що, як оцінюються помилкові значення.

Але якщо щось може допомогти вам більшість часу - це або оператор ( ||):

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

EDIT: Ось пропозиція про Nullary-злиття зараз у 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 operator ( ??), який виконує аналогічне призначення. Наприклад, у Swift ви б написали, result = a ?? "fallback value"що досить близьке до JavaScriptconst 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, використовуючи ||для повернення RHS, коли LHS є 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. Правильно (включаючи справжню ефективність чи проблеми угод за умовами угоди)
2. Ясно
3. Стислі
4. Швидкий

Усі відповіді на сторінці поки що здаються правильними, але я вважаю, що моя версія має найбільшу чіткість, що важливіше, ніж стислість. Якщо ви не підраховуєте функцію помічника - як це можна повторно використовувати - це також найбільш стисло. Дещо схожа пропозиція використовувати хелперну функцію, на жаль, використовує лямбда, яка, як на мене, просто затьмарює те, що вона робить. Простіша функція з однією метою, яка не приймає лямбда, а лише значення, для мене набагато краща.

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, роблячи 0 з -1, що є фальсею, і тому його замінюють другим 1. Потім воно зміщується назад.

Однак майте на увазі, що читабельність є кращою, ніж уникнення повторення.

Це просте рішення з розрядним 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

Ви можете використовувати повторне призначення:

• ініціалізувати змінну до одного значення
• використовувати серіалізацію &&оператора для перепризначення, тому що якщо перша умова помилкова, другий вираз не буде оцінено

Вих.

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

З огляду на приклад коду на запитання, чи не ясно , як це буде визначено , що 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 ((value = someArray.indexOf(3)) < 0) value = 0;

У цьому конкретному випадку ви можете використовувати коротке замикання з логічним ||оператором. Як 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);