자신을 반복하지 않고 삼항 연산자 (일명 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 : 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할당 한 다음 쉼표 연산자의 오른쪽, 다음 삼항 연산자 - 모든 법적 자바 스크립트.

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하기 때문에 0A는 falsy 값.

실제로는 다른 변수를 사용하십시오.

귀하의 예는 다음과 같이 일반화됩니다.

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에서 Nullary-coalescing 제안이 있습니다 !

사용하다 ||

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

다음과 같다

const result = a || 'fallback value';

캐스팅 경우 a에 Boolean반환 false, result할당됩니다 'fallback value'의 다른 값을 a.

가장자리 케이스주의 a === 0에 캐스트, false및 result(잘못) 소요됩니다 'fallback value'. 자신의 책임하에 이와 같은 트릭을 사용하십시오.

추신. Swift와 같은 언어에는 유사한 목적으로 사용되는 nil-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가 falsey다음과 같을 때 RHS를 반환하는 데 사용 :

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. 빠른

지금까지 페이지의 모든 답변이 정확 해 보이지만 내 버전의 선명도가 가장 뛰어나고 간결함보다 더 중요하다고 생각합니다. 재사용 할 수있는 도우미 함수를 계산하지 않으면 가장 간결합니다. 헬퍼 함수를 ​​사용하라는 다소 유사한 제안은 불행히도 람다를 사용합니다. 람다를 사용하지 않고 값만 사용하는 한 가지 목적을 가진 더 간단한 함수가 나에게 훨씬 낫습니다.

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나중에 0 이되는 간단한 솔루션입니다 .

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

기본적으로 비트 NOT을 적용한 후 0을 반환하는 원래 값 또는 기본값을 반환하는 이중 비트 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);

질문의 예제 코드를 고려할 때 3인덱스 0에 설정되어 있는지 여부가 어떻게 결정되는지 명확 하지 않습니다 someArray. 이 경우에서 -1반환 된 값 .indexOf()은 일치 할 수있는 일치하지 않는 것으로 추정되는 항목을 제외 할 목적으로 유용합니다.

3가 배열에 포함되지 않은 경우 -1반환됩니다. 우리는 추가 할 수 1의 결과 .indexOf()로 평가하는 false결과 존재에 대한 -1다음, || OR연산자와 0. 때 value참조, 빼기 1배열 또는 요소의 인덱스를 얻을 -1.

어떤 리드는 단순히 사용하여 백업 .indexOf()및 검사 -1가 AT 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 ((value = someArray.indexOf(3)) < 0) value = 0;

이 특별한 경우에는 논리 ||연산자 와 함께 단락을 사용할 수 있습니다 . 으로 0falsy 간주됩니다, 당신은 추가 할 수 있습니다 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);