JavaScript에서 "arguments" 개체를 배열로 변환하려면 어떻게 해야 합니까?

JavaScript에서 "arguments" 개체를 배열로 변환하려면 어떻게 해야 합니까?

이 게시물을 개선하시겠습니까?인용문 및 답변이 올바른 이유를 포함하여 이 질문에 대한 자세한 답변을 제공하십시오.충분한 세부 정보가 없는 답변은 편집 또는 삭제할 수 있습니다.

argumentsJavaScript의 오브젝트는 이상한 사마귀입니다.대부분의 경우 어레이와 동일하게 동작하지만 실제로는 어레이 오브젝트가 아닙니다.완전히 다른 것이기 때문에, 다음과 같은 유용한 기능이 없습니다.forEach,sort,filter , , , , 입니다.map.

단순 for 루프를 사용하여 Arguments 개체에서 새 배열을 구축하는 것은 매우 쉽습니다.예를 들어, 이 함수는 인수를 정렬합니다.

function sortArgs() {
    var args = [];
    for (var i = 0; i < arguments.length; i++)
        args[i] = arguments[i];
    return args.sort();
}

그러나 이는 매우 유용한 JavaScript 배열 함수에 단순히 액세스하기 위해 수행해야 하는 다소 안타까운 일입니다.스탠다드 라이브러리를 사용하여 빌트인 할 수 있는 방법이 있나요?

ES6 정지 파라미터 사용

ES6를 사용할 수 있는 경우 다음을 사용할 수 있습니다.

나머지 파라미터

function sortArgs(...args) {
  return args.sort(function (a, b) { return a - b; });
}

document.body.innerHTML = sortArgs(12, 4, 6, 8).toString();

링크에서 볼 수 있듯이

rest 파라미터 구문을 사용하면 무한의 인수를 배열로 나타낼 수 있습니다.

...이 구문은 스프레드 오퍼레이터라고 불리며 자세한 내용은 여기를 참조하십시오.

Array.from()을 사용한ES6

Array.from 사용:

function sortArgs() {
  return Array.from(arguments).sort(function (a, b) { return a - b; });
}

document.body.innerHTML = sortArgs(12, 4, 6, 8).toString();

Array.from어레이와 같은 오브젝트 또는 반복 가능한 오브젝트를 어레이 인스턴스로 변환하기만 하면 됩니다.

---

---

ES5

해도 돼요.Array님의 함수는 Arguments 오브젝트에서 표준 JavaScript 배열로 변환됩니다.어레이의 프로토타입을 사용하여 수동으로 참조하면 됩니다.

function sortArgs() {
    var args = Array.prototype.slice.call(arguments);
    return args.sort();
}

이게 왜 작동하죠?ECMAScript 5 매뉴얼에서 발췌한 내용을 다음에 나타냅니다.

주의:slice함수는 의도적으로 일반적이며 이 값이 Array 개체일 필요는 없습니다.따라서 다른 종류의 오브젝트로 전송하여 메서드로 사용할 수 있습니다.그 유무slice구현에 따라 호스트 개체에 함수를 성공적으로 적용할 수 있습니다.

therefore그 、slice를 가진 모든 것에 대해 동작합니다.length즉 '''의arguments편리하게도 그렇습니다.

---

ifArray.prototype.slice너무 리터럴을 할 수 있습니다.어레이 리터럴을 사용하면 약간 생략할 수 있습니다.

var args = [].slice.call(arguments);

다만, 이전 버전이 더 노골적이라고 느끼는 경향이 있기 때문에, 그 대신 그것을 선호합니다.배열 문자 표기법을 남용하는 것은 진부하고 이상해 보인다.

또한 이 Bluebird 약속 라이브러리 Wiki 페이지를 참조할 필요가 있습니다.argumentsV8 JavaScript 엔진에서 함수를 최적화할 수 있도록 객체를 배열로 만듭니다.

function doesntLeakArguments() {
    var args = new Array(arguments.length);
    for(var i = 0; i < args.length; ++i) {
        args[i] = arguments[i];
    }
    return args;
}

이 방법은 다음과 같은 경우에 사용됩니다.var args = [].slice.call(arguments);저자는 또한 빌드 단계가 장황함을 줄이는 데 어떻게 도움이 되는지 보여줍니다.

function sortArgs(){ return [].slice.call(arguments).sort() }

// Returns the arguments object itself
function sortArgs(){ return [].sort.call(arguments) }

일부 배열 방식은 대상 개체가 실제 배열일 필요가 없도록 의도적으로 만들어집니다.여기에는 길이와 인덱스라는 속성(0 이상의 정수여야 함)만 있으면 됩니다.

[].sort.call({0:1, 1:0, length:2}) // => ({0:0, 1:1, length:2})

용도:

function sortArguments() {
  return arguments.length === 1 ? [arguments[0]] :
                 Array.apply(null, arguments).sort();
}

Array(arg1, arg2, ...)[arg1, arg2, ...]

Array(str1)[str1]

Array(num1) 、 returns returns that that that that that that that that that 가 있는 합니다.num1

인수 수를 확인해야 합니다!

Array.slice버전(표준):

function sortArguments() {
  return Array.prototype.slice.call(arguments).sort();
}

Array.push버전(슬라이스, 슬라이스보다 빠름):

function sortArguments() {
  var args = [];
  Array.prototype.push.apply(args, arguments);
  return args.sort();
}

버전 이동(느리지만 작은 크기가 더 빠름):

function sortArguments() {
  var args = [];
  for (var i = 0; i < arguments.length; ++i)
    args[i] = arguments[i];
  return args.sort();
}

Array.concat전최최최최최 （ 。

function sortArguments() {
  return Array.prototype.concat.apply([], arguments).sort();
}

jQuery를 사용하는 경우 다음 사항을 기억하기가 훨씬 쉽습니다.

function sortArgs(){
  return $.makeArray(arguments).sort();
}

에서는 ECMAScript 6처럼 못생긴 Array.prototype.slice(). 대신 확산 ...구문을 사용할 수 있습니다().

(function() {
  console.log([...arguments]);
}(1, 2, 3))

이상하게 보일지 모르지만, 꽤 간단합니다. 뽑기만 하면 돼요.arguments요소를 배열로 되돌립니다.그래도 모르는 경우는, 다음의 예를 참조해 주세요.

console.log([1, ...[2, 3], 4]);
console.log([...[1, 2, 3]]);
console.log([...[...[...[1]]]]);

IE 11과 같은 일부 오래된 브라우저에서는 작동하지 않으므로 이러한 브라우저를 지원하려면 Babel을 사용해야 합니다.

다음은 인수를 배열로 변환하는 몇 가지 방법의 벤치마크입니다.

저에 대해서 말하자면, 소량의 논쟁에 대한 최선의 해결책은 다음과 같습니다.

function sortArgs (){
  var q = [];
  for (var k = 0, l = arguments.length; k < l; k++){
    q[k] = arguments[k];
  }
  return q.sort();
}

기타의 경우:

function sortArgs (){ return Array.apply(null, arguments).sort(); }

ECMAScript 6 확산 연산자를 사용하는 것이 좋습니다. ECMAScript 6 확산 연산자는 후행 매개 변수를 배열에 바인딩합니다.이 솔루션을 사용하면arguments오브젝트 및 코드가 심플해집니다.이 솔루션의 단점은 대부분의 브라우저에서는 동작하지 않기 때문에 대신 Babel과 같은 JS 컴파일러를 사용해야 한다는 것입니다. 아래 이 변신하다arguments을 위해

function sortArgs(...args) {
  return args.sort();
}

ECMAScript 6을 사용할 수 없는 경우 @Jonathan Fingland와 같은 다른 답변을 볼 것을 권장합니다.

function sortArgs() {
    var args = Array.prototype.slice.call(arguments);
    return args.sort();
}

Lodash:

var args = _.toArray(arguments);

동작 중:

(function(){ console.log(_.toArray(arguments).splice(1)); })(1, 2, 3)

생산:

[2,3]

를 사용하여 어레이와 같은 개체를 사용합니다(예:arguments

(function() {
  console.log(Array.from(arguments));
}(1, 2, 3));

IE 11과 같은 일부 오래된 브라우저에서는 작동하지 않으므로 이러한 브라우저를 지원하려면 Babel을 사용해야 합니다.

다음은 명확하고 간결한 솔루션입니다.

function argsToArray() {
  return Object.values(arguments);
}

// example usage
console.log(
  argsToArray(1, 2, 3, 4, 5)
  .map(arg => arg*11)
);

Object.values( ) 오브젝트 값이 배열로 반환됩니다.arguments이기 때문에 변환됩니다.기본적으로 변환됩니다.arguments예: 배열의 도우미 기능을 사용할 수 있습니다.map,forEach,filter 등등.

function sortArg(){
var args = Array.from(arguments); return args.sort();
}

 function sortArg(){
    var args = Array.from(arguments); 
    return args.sort();
    }
 
 console.log(sortArg('a', 'b', 1, 2, '34', 88, 20, '19', 39, 'd', 'z', 'ak', 'bu', 90));

다른 답변입니다.

블랙 매직 주문 사용:

function sortArguments() {
  arguments.__proto__ = Array.prototype;
  return arguments.slice().sort();
}

Firefox, Chrome, Node.js, IE11은 정상입니다.

사용해보십시오.

설정: 설정prototypearguments로로 합니다.Array.prototype

function toArray() {
  return Object.setPrototypeOf(arguments, Array.prototype)
} 

console.log(toArray("abc", 123, {def:456}, [0,[7,[14]]]))

---

설 : 의 of of of of of of of of of of of of of of의 각 를 취한다.arguments에 배치합니다.

다른 방법으로 사용할 수 있다

function toArray() {
  return [].map.call(arguments, (_,k,a) => a[k])
} 

console.log(toArray("abc", 123, {def:456}, [0,[7,[14]]]))

---

설 : 의 of of of of of of of of of of of of of of의 각 를 취한다.arguments에 배치합니다.

for..of 루프

function toArray() {
 let arr = []; for (let prop of arguments) arr.push(prop); return arr
} 

console.log(toArray("abc", 123, {def:456}, [0,[7,[14]]]))

---

또는

오브젝트를 오브젝트의 을 각 인덱스의 항목에 설정합니다.arguments; 트 ;prototype에 대해 창조된 목적의Array.prototype

function toArray() {
  var obj = {};
  for (var prop in arguments) {
    obj[prop] = {
      value: arguments[prop],
      writable: true,
      enumerable: true,
      configurable: true
    }
  } 
  return Object.create(Array.prototype, obj);
}

console.log(toArray("abc", 123, {def: 456}, [0, [7, [14]]]))

Benshmarck 3 메서드:

function test()
{
  console.log(arguments.length + ' Argument(s)');

  var i = 0;
  var loop = 1000000;
  var t = Date.now();
  while(i < loop)
  {
      Array.prototype.slice.call(arguments, 0); 
      i++;
  }
  console.log(Date.now() - t);


  i = 0,
  t = Date.now();
  while(i < loop)
  {
      Array.apply(null, arguments);
      i++;
  }
  console.log(Date.now() - t);

  i = 0,
  t = Date.now();
  while(i < loop)
  {
      arguments.length == 1 ? [arguments[0]] : Array.apply(null, arguments);
      i++;
  }
  console.log(Date.now() - t);
}

test();
test(42);
test(42, 44);
test(42, 44, 88, 64, 10, 64, 700, 15615156, 4654, 9);
test(42, 'truc', 44, '47', 454, 88, 64, '@ehuehe', 10, 64, 700, 15615156, 4654, 9,97,4,94,56,8,456,156,1,456,867,5,152489,74,5,48479,89,897,894,894,8989,489,489,4,489,488989,498498);

결과?

0 Argument(s)
256
329
332
1 Argument(s)
307
418
4
2 Argument(s)
375
364
367
10 Argument(s)
962
601
604
40 Argument(s)
3095
1264
1260

맛있게 드세요!

function sortArgs(...args) {
  return args.sort(function (a, b) { return a - b; });
}

document.body.innerHTML = sortArgs(1, 2, 3, 4).toString();

는 정상적으로할 arguments로든 ""를 하십시오."

function sortArgs() {
  return [...arguments].sort()
}

[...arguments]의 할 수 있다Array.from(arguments)이 또한 완벽하게 작동합니다.

ES7의 대체 방법은 어레이 이해입니다.

[for (i of arguments) i].sort()

이것은 정렬하기 전에 인수를 처리하거나 필터링하는 경우에 가장 간단합니다.

[for (i of arguments) if (i % 2) Math.log(i)].sort()

 function x(){
   var rest = [...arguments]; console.log(rest);return     
   rest.constructor;
 };
 x(1,2,3)

나는 간단한 파괴 기술을 시도했다.

Arguments 개체는 함수 본문 내에서만 사용할 수 있습니다.Arguments 개체를 배열처럼 인덱싱할 수 있지만 배열은 아닙니다.길이 이외의 어레이 속성은 없습니다.

// function arguments length 5
function properties(a,b,c,d,e){
var function_name= arguments.callee.name
var arguments_length= arguments.length;
var properties_length=  properties.length; 
var function_from= properties.caller.name;
console.log('I am the function name: '+ function_name);
console.log('I am the function length, I am function spacific: '+ properties_length); 
console.log('I am the arguments length, I am context/excution spacific: '+ arguments_length);
console.log('I am being called From: '+  function_from );
}

// arguments 3
function parent(){
properties(1,2,3);
}

//arguments length 3 because execution spacific
parent();

이 예에서 볼 수 있듯이 어레이와 같이 인덱스를 작성할 수 있습니다.

function add(){

var sum=0;

for(var i=0; i< arguments.length;i++){

sum = sum + arguments[i];

}

return sum;

}

console.log(add(1,2,3));

그러나 Arguments 개체는 배열이 아니며 길이 이외의 속성은 없습니다.

Arguments 개체를 Arguments 개체에 액세스할 수 있는 배열로 변환할 수 있습니다.

함수 본문 내의 Arguments 오브젝트에는 다음과 같은 여러 가지 방법으로 액세스할 수 있습니다.

1. Array.prototoype에 문의할 수 있습니다.slice.call 메서드

Array.protype.slice.call(표준)

function giveMeArgs(arg1,arg2){

var args = Array.prototype.slice.call(arguments);
return args
}

console.log( giveMeArgs(1,2));

2. 어레이 리터럴을 사용할 수 있습니다.

[.syslog.call(호출)]을 클릭합니다.

function giveMeArgs(arg1,arg2){

var args = [].slice.call(arguments);

return args;

}

console.log( giveMeArgs(1,2) );

3. 휴식...을 사용할 수 있습니다.

function giveMeArgs(...args){

return args;

}

console.log(giveMeArgs(1,2))

4. 스프레드 [...]를 사용할 수 있습니다.

function giveMeArgs(){

var args = [...arguments];
return args;

}

console.log(giveMeArgs(1,2));

5. Array.from()을 사용할 수 있습니다.

function giveMeArgs(){

var args = Array.from(arguments);

return args;

}

console.log(giveMeArgs(1,2));

재사용 가능한 함수를 생성하여 임의의 인수를 사용할 수 있습니다.가장 간단한 인수는 다음과 같습니다.

function sortArgs() {
  return [...arguments].sort();
}

sortArgs('ali', 'reza', 1, 2, 'a'); //[1, 2, "a", "ali", "reza"];

ES6 이상에서는 확산 구문을 사용할 수 있습니다.

그러나 ES5 이하와 호환되는 제품을 사용하고 싶다면Array.prototype.slice.call을 사용하다

function sortArgs() {
  return Array.prototype.slice.call(arguments).sort();
}

sortArgs('ali', 'reza', 1, 2, 'a'); //[1, 2, "a", "ali", "reza"];

에도 몇 . , 사용법은 다음과 같습니다.Array.from또는 인수를 루프하여 새 배열에 할당합니다.

이것은 매우 오래된 질문입니다만, 이전의 솔루션보다 타이핑하기 쉽고, 외부 라이브러리에 의존하지 않는 솔루션이 있다고 생각합니다.

function sortArguments() {
  return Array.apply(null, arguments).sort();
}

언급URL : https://stackoverflow.com/questions/960866/how-can-i-convert-the-arguments-object-to-an-array-in-javascript