배열의 모든 값이 동일한지 확인합니다.

source

배열의 모든 값이 동일한지 확인합니다.

gigabyte 2023. 1. 12. 22:07

배열의 모든 값이 동일한지 확인합니다.

모든 값이 동일한 어레이를 찾아야 합니다.가장 빠른 방법이 뭔가요?값을 비교하고 루핑해야 할까요?

['a', 'a', 'a', 'a'] // true
['a', 'a', 'b', 'a'] // false

const allEqual = arr => arr.every( v => v === arr[0] )
allEqual( [1,1,1,1] )  // true

또는 원라이너:

[1,1,1,1].every( (val, i, arr) => val === arr[0] )   // true

Array.protype. every (MDN에서):every()메서드는 어레이 내의 모든 요소가 제공된 함수에 의해 구현된 테스트를 통과하는지 여부를 테스트합니다.

편집: 붉은 닌자가 되어라:

!!array.reduce(function(a, b){ return (a === b) ? a : NaN; });

결과:

var array = ["a", "a", "a"] => result: "true"
var array = ["a", "b", "a"] => result: "false"
var array = ["false", ""] => result: "false"
var array = ["false", false] => result: "false"
var array = ["false", "false"] => result: "true"
var array = [NaN, NaN] => result: "false"

경고:

var array = [] => result: TypeError thrown

이는 initialValue가 전달되지 않기 때문입니다.그래서 확인하실 수 있습니다.array.length 번째

이거 되는구나.프로토타입을 사용하여 배열에 메서드를 만듭니다.

if (Array.prototype.allValuesSame === undefined) {
  Array.prototype.allValuesSame = function() {
    for (let i = 1; i < this.length; i++) {
      if (this[i] !== this[0]) {
        return false;
      }
    }
    return true;
  }
}

이것을 다음과 같이 부릅니다.

let a = ['a', 'a', 'a'];
let b = a.allValuesSame(); // true
a = ['a', 'b', 'a'];
b = a.allValuesSame();     // false

어레이를 세트로 만들 수 있습니다.세트의 크기가 1이면 배열의 모든 요소가 동일합니다.

function allEqual(arr) {
  return new Set(arr).size == 1;
}

allEqual(['a', 'a', 'a', 'a']); // true
allEqual(['a', 'a', 'b', 'a']); // false

JavaScript 1.6에서는 다음을 사용할 수 있습니다.

function AllTheSame(array) {
    var first = array[0];
    return array.every(function(element) {
        return element === first;
    });
}

등 할 수 있습니다 모든 가 「모든 요소」인 이 하지 않습니다.NaNNaN !== NaN)) 、 )) 、 )) 、、 )) 、 )) 、)) ）。그??

퍼포먼스 비교를 위해 벤치마크를 실시했습니다.

function allAreEqual(array){
    if(!array.length) return true;
    // I also made sure it works with [false, false] array
    return array.reduce(function(a, b){return (a === b)?a:(!b);}) === array[0];
}
function same(a) {
    if (!a.length) return true;
    return !a.filter(function (e) {
        return e !== a[0];
    }).length;
}

function allTheSame(array) {
    var first = array[0];
    return array.every(function(element) {
        return element === first;
    });
}

function useSome(array){
    return !array.some(function(value, index, array){
        return value !== array[0];
    });
}

결과:

allAreEqual x 47,565 ops/sec ±0.16% (100 runs sampled)
same x 42,529 ops/sec ±1.74% (92 runs sampled)
allTheSame x 66,437 ops/sec ±0.45% (102 runs sampled)
useSome x 70,102 ops/sec ±0.27% (100 runs sampled)

따라서 builtin array.some()을 사용하는 것이 샘플화된 방법 중 가장 빠른 방법입니다.

이미 underscore.js 를 사용하고 있는 경우는, 다음의 옵션을 사용해 주세요._.uniq:

function allEqual(arr) {
    return _.uniq(arr).length === 1;
}

_.uniq는 어레이의 중복이 없는 버전을 반환합니다.1로 하다

한 바와 빈 될 수 .true그 해 보세요.

function allEqual(arr) {
    return arr.length === 0 || _.uniq(arr).length === 1;
}

언더스코어/로더시를 사용한 최단 응답

function elementsEqual(arr) {
    return !_.without(arr, arr[0]).length
}

사양:

elementsEqual(null) // throws error
elementsEqual([]) // true
elementsEqual({}) // true
elementsEqual([1]) // true
elementsEqual([1,2]) // false
elementsEqual(NaN) // true

편집:

더 짧게는 톰의 대답에서 영감을 얻습니다.

function elementsEqual2(arr) {
    return _.uniq(arr).length <= 1;
}

사양:

elementsEqual2(null) // true (beware, it's different than above)
elementsEqual2([]) // true
elementsEqual2({}) // true
elementsEqual2([1]) // true
elementsEqual2([1,2]) // false
elementsEqual2(NaN) // true

version: 사용 2022: 사용Set()

     let a = ['a', 'a', 'b', 'a'];
     let b = ['a', 'a', 'a', 'a'];
     const check = (list) => {
        const setItem = new Set(list);
        return setItem.size <= 1;
     }

     const checkShort = (list) => (new Set(list)).size <= 1        
     
      check(a); // false;
      check(b); // true;
      checkShort(a); // false
      checkShort(b); // true

새 솔루션 업데이트: 인덱스 확인

 let a = ['a', 'a', 'b', 'a'];
 let b = ['a', 'a', 'a', 'a'];
 let check = (list) => list.every(item => list.indexOf(item) === 0);
 check(a); // false;
 check(b); // true;

: Use ES6로 갱신:list.every가장 빠른 방법입니다.

 let a = ['a', 'a', 'b', 'a'];
 let check = (list) => list.every(item => item === list[0]);

이전 버전:

      var listTrue = ['a', 'a', 'a', 'a'];
      var listFalse = ['a', 'a', 'a', 'ab'];

      function areWeTheSame(list) { 
         var sample = list[0];
         return (list.every((item) => item === sample));
      }

네, 다음과 같이 필터를 사용하여 확인할 수도 있습니다.모든 값이 처음 값과 동일한지 확인하는 것은 매우 간단합니다.

//ES6
function sameValues(arr) {
  return arr.filter((v,i,a)=>v===a[0]).length === arr.length;
}

어레이상의 모든 방법을 사용하여 실행할 수도 있습니다.

//ES6
function sameValues(arr) {
  return arr.every((v,i,a)=>v===a[0]);
}

어레이를 다음과 같이 체크할 수 있습니다.

sameValues(['a', 'a', 'a', 'a']); // true
sameValues(['a', 'a', 'b', 'a']); // false

또는 자주 재사용하는 경우 JavaScript의 네이티브 어레이 기능에 추가할 수 있습니다.

//ES6
Array.prototype.sameValues = Array.prototype.sameValues || function(){
 this.every((v,i,a)=>v===a[0]);
}

어레이를 다음과 같이 체크할 수 있습니다.

['a', 'a', 'a', 'a'].sameValues(); // true
['a', 'a', 'b', 'a'].sameValues(); // false

every() 함수는 배열의 모든 요소가 있는지 확인합니다.

    const checkArr = a => a.every( val => val === a[0] )
    checkArr(['a','a','a'])  // true

하시면 됩니다.Array.every다음 중 하나:

var equals = array.every(function(value, index, array){
    return value === array[0];
});

루프의 대체 접근법은 다음과 같습니다.sort

var temp = array.slice(0).sort();
var equals = temp[0] === temp[temp.length - 1];

또는 항목이 질문과 같다면 다음과 같은 더러운 것이 있을 수 있습니다.

var equals = array.join('').split(array[0]).join('').length === 0;

효과도 있습니다.

Array.protype.every, Object.is 및 ES6 화살표 기능을 사용하여 원하는 작업을 수행할 수 있습니다.

const all = arr => arr.every(x => Object.is(arr[0], x));

가장 간단한 방법은 루프를 생성하여 각 값을 다음 값과 비교하는 것이라고 생각합니다.체인(chain)이 끊어지는 한 false가 반환됩니다.첫 번째 요소가 두 번째, 두 번째 요소가 세 번째와 같은 경우 배열의 모든 요소가 서로 동일하다는 결론을 내릴 수 있습니다.

어레이 데이터()를 지정하면 다음을 사용할 수 있습니다.

for(x=0;x<data.length - 1;x++){
    if (data[x] != data[x+1]){
        isEqual = false;            
    }
}
alert("All elements are equal is " + isEqual);

이제 세트를 사용하여 이를 쉽게 수행할 수 있습니다.

let a= ['a', 'a', 'a', 'a']; // true
let b =['a', 'a', 'b', 'a'];// false

console.log(new Set(a).size === 1);
console.log(new Set(b).size === 1);

arr.length && arr.reduce(function(a, b){return (a === b)?a:false;}) === arr[0];

어레이를 세트로 변환하여 크기를 확인할 수 있습니다.

어레이, 즉, 「」의 경우.number,string:

const isArrayWithEqualEntries = array => new Set(array).size === 1

할가 있는 되어 있는 예를 들어 '동일성을 테스트하다'라고 합니다.id:

const mapper = ({id}) => id
const isArrayWithEqualEntries = array => new Set(array.map(mapper)).size === 1

다음을 사용할 수 있습니다.

function same(a) {
    if (!a.length) return true;
    return !a.filter(function (e) {
        return e !== a[0];
    }).length;
}

이 함수는 먼저 배열이 비어 있는지 확인합니다.값이 같다면..그렇지 않으면 배열을 필터링하고 첫 번째 요소와 다른 모든 요소를 가져옵니다.이러한 값이 없는 경우 => 배열에는 동일한 요소만 포함됩니다.그렇지 않은 경우에는 포함되지 않습니다.

심플.함수를 만들고 매개 변수를 전달합니다.이 함수에서는 첫 번째 인덱스를 새 변수로 복사합니다.그런 다음 for 루프를 생성하여 어레이를 루프합니다.루프 내부에 새로운 생성 변수가 루프 내의 모든 요소와 동일한지 여부를 체크하는 조건과 함께 while 루프를 만듭니다.for 루프가 완료된 후 동일한 반환 true가 반환되지 않으면 while 루프 내부에 false가 반환됩니다.

function isUniform(arra){
    var k=arra[0];
    for (var i = 0; i < arra.length; i++) {
        while(k!==arra[i]){
            return false;
        }
    }
    return true;
}

받아들여진 답변은 훌륭했지만 나는 조금 더 추가하고 싶었다.내가 쓰는 것은 효과가 없었다.===오브젝트 어레이의 어레이를 비교하고 있었지만, 앱 전체에서 Fast-Deep-Equal 패키지를 사용하고 있었습니다.이것으로, 제 코드는 다음과 같습니다.

let areAllEqual = arrs.every((val, i, arr) => equal(val, arr[0]) );

데이터는 다음과 같습니다.

[  
  [
    {
      "ID": 28,
      "AuthorID": 121,
      "VisitTypeID": 2
    },
    {
      "ID": 115,
      "AuthorID": 121,
      "VisitTypeID": 1
    },
    {
      "ID": 121,
      "AuthorID": 121,
      "VisitTypeID": 1
    }
  ],
  [
    {
      "ID": 121,
      "AuthorID": 121,
      "VisitTypeID": 1
    }
  ],
  [
    {
      "ID": 5,
      "AuthorID": 121,
      "VisitTypeID": 1
    },
    {
      "ID": 121,
      "AuthorID": 121,
      "VisitTypeID": 1
    }
  ]
]

for 루프를 사용할 수 있습니다.

function isEqual(arr) {
  var first = arr[0];
  for (let i = 1; i < arr.length; i++) {
    if (first !== arr[i]) {
      return false;
    }
  }
  return true;
}

줄_.isEqual(object, other)이 기능은 어레이에서는 정상적으로 동작하고 있는 것 같습니다.어레이의 항목 순서는 동일성을 확인할 때 중요합니다.http://underscorejs.org/ #isEqual을 참조해 주세요.

var listTrue = ['a', 'a', 'a', 'a'];
var listFalse = ['a', 'a', 'a', 'ab'];

function areWeTheSame(list) { 
    var sample = list[0];
    return !(list.some(function(item) {
        return !(item == sample);
    }));
}

function isUniform(array) {   
  for (var i=1; i< array.length; i++) {
    if (array[i] !== array[0]) { return false; }
  }

  for (var i=1; i< array.length; i++) {
    if (array[i] === array[0]) { return true; }
  }
}

첫 번째 루프의 경우 불균형이 검출될 때마다 "false"가 반환됩니다.
첫 번째 루프가 실행되고 false가 반환되면 false가 됩니다.
false가 반환되지 않으면 true가 존재함을 의미하기 때문에 두 번째 루프를 실행합니다.물론 두 번째 루프부터 "true"가 됩니다(첫 번째 루프가 false가 아닌 것을 발견했기 때문입니다).

어레이에 가입하여 문자열을 만듭니다.
지정된 배열의 첫 번째 문자를 반복하여 문자열 생성
양쪽 현에 매치하다

	function checkArray(array){
		return array.join("") == array[0].repeat(array.length);	
	}

	console.log('array: [a,a,a,a]: ' + checkArray(['a', 'a', 'a', 'a']));
	console.log('array: [a,a,b,a]: ' + checkArray(['a', 'a', 'b', 'a']));

그리고 넌 끝났어!

ES6 화살표 함수 구문을 사용할 때의 또 다른 흥미로운 방법은 다음과 같습니다.

x = ['a', 'a', 'a', 'a']
!x.filter(e=>e!==x[0])[0]  // true

x = ['a', 'a', 'b', 'a']
!x.filter(e=>e!==x[0])[0] // false

x = []
!x.filter(e=>e!==x[0])[0]  // true

변수를 어레이(x)에 재사용하지 않을 경우:

!['a', 'a', 'a', 'a'].filter((e,i,a)=>e!==a[0])[0]    // true

array.every(...)를 사용한 IMO의 이전 포스터는 가장 깨끗한 솔루션입니다.

이것은 동작할 가능성이 있습니다.코멘트 아웃 코드도 사용할 수 있습니다.이 코드는 지정된 시나리오와 잘 어울립니다.

function isUniform(){
	var arrayToMatch = [1,1,1,1,1];
	var temp = arrayToMatch[0];
	console.log(temp);
  /* return arrayToMatch.every(function(check){
    return check == temp;
   });*/
var bool;
   arrayToMatch.forEach(function(check){
    bool=(check == temp);
   })
  console.log(bool);
}
isUniform();

첫 번째 엔트리를 채운 어레이와 비교하기만 하면 간단한 한 줄 솔루션입니다.

if(arr.join('') === Array(arr.length).fill(arr[0]).join(''))

**// Logical Solution:- Declare global array and one variable(To check the condition) whether all element of an array contains same value or not.**

    var arr =[];
    var isMatching = false;

    for(var i=0;i<arr.length;i++){
            if(String(arr[i]).toLowerCase()== "Your string to check"){
                isMatching=true;
                // Array has same value in all index of an array
            }
            else{
                isMatching=false;
                // Array Doesn't has same value in all index of an array
                break;
            }
        }
    // **Check isMatching variable is true or false**

        if(isMatching){ // True
            //If Array has same value in all index, then this block will get executed
        }
        else{ //False
            //If Array doesn't has same value in all index, then this block will get executed
        }

어레이에서 고유한 값의 수를 셀 수 있습니다. 이 값이 1이면 모든 항목이 동일합니다.

예:

array = np.array([1, 2, 2, 3, 3])
set(array) # this gives the different values present in the array (1,2,3)
len(set(array)) # this returns 3, 3 different values in the array

언급URL : https://stackoverflow.com/questions/14832603/check-if-all-values-of-array-are-equal

'source' 카테고리의 다른 글

요소를 기준으로 마우스 위치 찾기 (0)	2023.01.22
mysql 데이터베이스의 사이즈는 어떻게 취득합니까? (0)	2023.01.22
Java split() 메서드는 마지막에 빈 문자열을 삭제합니까? (0)	2023.01.12
사전에 새 키를 추가하려면 어떻게 해야 합니까? (0)	2023.01.12
오브젝트 URL에서 파일 또는 BLOB를 가져오려면 어떻게 해야 합니까? (0)	2023.01.12

현재글배열의 모든 값이 동일한지 확인합니다.

각종 프로그래밍 정보를 다루는 블로그입니다.

Ajax, vuex, vuejs2, C, mariaDB, Java, MySQL, PHP, oracle, WordPress, Excel, JSON, reactjs, spring-boot, SWiFT, WPF, JavaScript, sql-server, AngularJS, Python,

Today :
Yesterday :

gigabyte

배열의 모든 값이 동일한지 확인합니다.

배열의 모든 값이 동일한지 확인합니다.

'source' 카테고리의 다른 글

'source'의 다른글

티스토리툴바

« 2025/01 »
일	월	화	수	목	금	토
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

배열의 모든 값이 동일한지 확인합니다.

배열의 모든 값이 동일한지 확인합니다.

'source' 카테고리의 다른 글

'source'의 다른글

관련글

티스토리툴바