값 리스트에 대해 변수 동일성 확인

값 리스트에 대해 변수 동일성 확인

예를 들어, " 를있습다니고확하인수변다있니▁i"입니다.foo여러 값과 동일성을 유지합니다.를 들면 를들면예,

if( foo == 1 || foo == 3 || foo == 12 ) {
    // ...
}

요점은 그것이 그런 사소한 작업에 비해 상당히 많은 코드라는 것입니다.저는 다음을 생각해냈습니다.

if( foo in {1: 1, 3: 1, 12: 1} ) {
    // ...
}

하지만 이것 또한 나에게 완전히 매력적이지는 않습니다. 왜냐하면 나는 물건 안의 항목들에 중복된 값을 주어야 하기 때문입니다.

여러 값에 대해 동등성 검사를 수행하는 괜찮은 방법을 아는 사람이 있습니까?

ECMA 2016에서는 포함 방법을 사용할 수 있습니다.제가 본 것 중 가장 깨끗한 방법입니다. (모든 주요 브라우저에서 지원)

if([1,3,12].includes(foo)) {
    // ...
}

배열을 사용할 수 있으며 다음을(를) 사용할 수 있습니다.

if ([1,3,12].indexOf(foo) > -1)

제공된 답변을 사용하여 다음과 같은 결과를 얻었습니다.

Object.prototype.in = function() {
    for(var i=0; i<arguments.length; i++)
       if(arguments[i] == this) return true;
    return false;
}

다음과 같이 부를 수 있습니다.

if(foo.in(1, 3, 12)) {
    // ...
}

---

편집: 최근에 우연히 이 '꼼수'를 발견했는데, 이는 값이 문자열이고 특수 문자를 포함하지 않을 때 유용합니다.특수문자는 탈출로 인해 못생겨지고 그로 인해 오류가 발생하기 쉽기 때문입니다.

/foo|bar|something/.test(str);

좀 더 정확하게 말하면, 이것은 정확한 문자열을 확인할 것이지만, 단순한 동등성 검정의 경우에는 더 복잡합니다.

/^(foo|bar|something)$/.test(str);

이제 이 시나리오를 해결할 수 있는 더 나은 솔루션이 있을 수 있지만, 제가 선호하는 다른 방법이 있습니다.

const arr = [1,3,12]
if( arr.includes(foo)) { // it will return true if you `foo` is one of array values else false
  // code here    
}

나는 당신이 인덱스도 확인해야 하는 체크 오브 체크보다 위의 솔루션을 선호했습니다.

문서 포함

if ( arr.indexOf( foo ) !== -1 ) { }

이것은 쉽게 확장할 수 있고 읽을 수 있습니다.

switch (foo) {
    case 1:
    case 3:
    case 12:
        // ...
        break

    case 4:
    case 5:
    case 6:
        // something else
        break
}

하지만 반드시 더 쉬운 것은 아닙니다 :)

다니있습다▁write를 쓸 수 있습니다.if(foo in L(10,20,30))을 L되려고

var L = function()
{
    var obj = {};
    for(var i=0; i<arguments.length; i++)
        obj[arguments[i]] = null;

    return obj;
};

var a = [1,2,3];

if ( a.indexOf( 1 ) !== -1 ) { }

indexOf는 코어 ECMA스크립트에 없습니다.IE 및 Array.prototype.indexOf를 지원하지 않는 다른 브라우저에 대한 스니펫이 필요합니다.

if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(searchElement /*, fromIndex */)
  {
    "use strict";

    if (this === void 0 || this === null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (len === 0)
      return -1;

    var n = 0;
    if (arguments.length > 0)
    {
      n = Number(arguments[1]);
      if (n !== n)
        n = 0;
      else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0))
        n = (n > 0 || -1) * Math.floor(Math.abs(n));
    }

    if (n >= len)
      return -1;

    var k = n >= 0
          ? n
          : Math.max(len - Math.abs(n), 0);

    for (; k < len; k++)
    {
      if (k in t && t[k] === searchElement)
        return k;
    }
    return -1;
  };
}

또한 결과를 확인하는 값이 모두 고유하므로 Set.prototype.has()도 사용할 수 있습니다.

var valid = [1, 3, 12];
var goodFoo = 3;
var badFoo = 55;

// Test
console.log( new Set(valid).has(goodFoo) );
console.log( new Set(valid).has(badFoo) );

자주 비교하는 더 많은 값 리스트의 경우 선형 시간으로 실행되는 것보다 를 먼저 구성하고 일정한 시간 검사에 사용하는 것이 가장 적합할 수 있습니다.

const values = new Set([1, 2, 12]);
if(values.has(foo)){
   // do something
}

수락된 답변이 마음에 들었지만 어레이도 사용할 수 있도록 하는 것이 좋겠다고 생각하여 다음으로 확장했습니다.

Object.prototype.isin = function() {
    for(var i = arguments.length; i--;) {
        var a = arguments[i];
        if(a.constructor === Array) {
            for(var j = a.length; j--;)
                if(a[j] == this) return true;
        }
        else if(a == this) return true;
    }
    return false;
}

var lucky = 7,
    more = [7, 11, 42];
lucky.isin(2, 3, 5, 8, more) //true

변경하여 유형 강제를 제거할 수 있습니다.=====.

밑줄에 액세스할 수 있는 경우 다음을 사용할 수 있습니다.

if (_.contains([1, 3, 12], foo)) {
  // ...
}

contains에는 ). 는 Lodash를 사용해야 .includes

if (_.includes([1, 3, 12], foo)) {
  handleYellowFruit();
}

이를 위해 단순히 배열 함수와 값 배열을 사용했습니다.

myArr = ["A", "B", "C", "C-"];

var test = $.inArray("C", myArr)  
// returns index of 2 returns -1 if not in array

if(test >= 0) // true

다음은 작은 도우미 화살표 기능입니다.

const letters = ['A', 'B', 'C', 'D'];

function checkInList(arr, val) {
  return arr.some(arrVal => val === arrVal);
}

checkInList(letters, 'E');   // false
checkInList(letters, 'A');   // true

자세한 내용은 여기...

그것은 정말로 사용 사례로 귀결됩니다.예를 들어, 변수가 특정 값인지 여부에만 관심이 있는 경우,Array.some()기본적으로 수행하기 때문에 최선의 베팅이 될 것입니다.forEach임의의 반복 가능한 유형에서 조건이 충족되는 첫 번째 값에 true를 반환합니다.이를 통해 옵션이 조건을 충족하는지 확인하는 가장 빠른 방법 중 하나가 되며, 이는 옵션이 사용되는 방법의 예입니다.

const anyOfThese = [1, 2, 14];
const doesHave0 = 0;
const doesHave1 = 1;
const doesHave14 = 14;

// checks all
const found0 = anyOfThese.some(singleValue => singleValue === doesHave0));
console.log("found0", found0);
// -> false

// check anyOfThese[0] = (1) returns without checking the rest
const found1 = anyOfThese.some(singleValue => singleValue === doesHave1));
console.log("found1", found1);
// -> true

// checks anyOfThese[0...14] until it finds singleValue === 14
const found14 = anyOfThese.some(singleValue => singleValue === doesHave14));
console.log("found14", found14);
// -> true

그러나 전체 결과를 추적하려는 일부 집합에 값을 저장하는 경우, 예를 들어 해당 집합에 항목이 아직 없는 경우에만 항목을 추가합니다.실제 사용Set세트는 각 고유한 값에 대해 하나의 항목만 가질 수 있고 이렇게 세트에 추가할 수 있으므로 더 좋습니다.

const mSet = new Set();
mSet.add(2);
mSet.add(5);
mSet.add(2);
console.debug("mSet", mSet); // -> mSet Set {2, 5}

그리고 만약 당신이 그 값이 추가되었는지 아닌지를 알아야 할 필요가 있다면, 당신은 단순히 세트의 크기를 다음과 같은 추가와 함께 비교할 수 있습니다.

const mSet = new Set();
mSet.add(2);
const addedFive = mSet.size < mSet.add(5).size;
console.debug("addedFive", addedFive);  // -> true
const addedTwo = mSet.size < mSet.add(2).size;
console.debug("addedTwo", addedTwo);  // -> false
console.debug("mSet", mSet); // -> Set {2, 5}

그리고 그것은<논리적인 확인이 될 수 있습니다, 그래서 당신은 말할 수 있습니다.

const mSet = new Set([2]);
mSet.size === mSet.add(2); // -> returns true; didn't add 2
mSet.size !== mSet.add(2); // -> returns false; didn't add 2
mSet.size === mSet.add(5); // -> returns false; added 5
mSet.size !== mSet.add(6); // -> returns true; added 6

또는 어떤 기능도 사용할 수 있으므로 다음과 같이 말할 수 있습니다.

const mSet = new Set([2]);
mSet.size === mSet.remove(2); // -> returns false; removed 2
mSet.size === mSet.remove(2); // -> returns true; didn't remove anything

그<그리고.>연산자는 당신이 확인하는 것을 더 쉽게 명확히 할 수 있게 하지만,===그리고.!==정확한 변경이 중요하지 않을 수도 있지만 변경된 사항이 있거나 변경되지 않은 경우 더 광범위한 가능성을 제공합니다.

논리를 작성할 때는 이러한 검사가 값을 변형시켜 Set이 실제로 검사된 값을 추가하거나 제거하도록 한다는 것을 기억하십시오.

ES6 구문을 사용하여 다음 작업을 수행할 수 있습니다.

Object.prototype.in = function (...args) {
  return args.includes(this.valueOf());
}

부수적으로 깊은 평등을 확인하기도 합니다.valueOf() 메서드는 개체이므로 필요합니다.

후세 사람들을 위해 당신은 정규 표현을 대안으로 사용하고 싶을 것입니다.브라우저 지원도 상당히 좋습니다(https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match#Browser_compatibility) 참조).

사용해 보세요.

if (foo.toString().match(/^(1|3|12)$/)) {
    document.write('Regex me IN<br>');
} else {
    document.write('Regex me OUT<br>');
}

언급URL : https://stackoverflow.com/questions/4728144/check-variable-equality-against-a-list-of-values