मैं जावास्क्रिप्ट में "तर्कों" ऑब्जेक्ट को सरणी में कैसे बदल सकता हूं?

Question

argumentsजावास्क्रिप्ट में वस्तु एक अजीब मस्सा-यह सिर्फ ज्यादातर स्थितियों में एक सरणी की तरह काम करता है, लेकिन यह नहीं है वास्तव में एक सरणी वस्तु। यह है के बाद से वास्तव में कोई अन्य विषय , इसे से उपयोगी फ़ंक्शन नहीं है Array.prototypeकी तरह forEach, sort, filter, और map।

लूप के लिए एक सरल के साथ एक तर्क ऑब्जेक्ट से एक नए सरणी का निर्माण करना बहुत आसान है। उदाहरण के लिए, यह फ़ंक्शन अपने तर्कों को क्रमबद्ध करता है:

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

हालाँकि, यह एक अत्यंत दयनीय बात है कि इसे केवल अत्यंत उपयोगी जावास्क्रिप्ट सरणी कार्यों तक पहुँचने के लिए करना है। क्या मानक पुस्तकालय का उपयोग करने का एक अंतर्निहित तरीका है?

Comments

बारीकी से संबंधित: Array.prototype.slice.call () कैसे काम करता है?

— बेर्गी

Answer 1

बाकी मापदंडों का उपयोग करते हुए ईएस 6

यदि आप ES6 का उपयोग करने में सक्षम हैं तो आप उपयोग कर सकते हैं:

बाकी पैरामीटर

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

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

जैसा कि आप लिंक में पढ़ सकते हैं

बाकी पैरामीटर सिंटैक्स हमें एक सरणी के रूप में अनिश्चित संख्या के तर्क का प्रतिनिधित्व करने की अनुमति देता है।

यदि आप ...वाक्य रचना के बारे में उत्सुक हैं , तो इसे स्प्रेड ऑपरेटर कहा जाता है और आप यहां और अधिक पढ़ सकते हैं ।

ES6 Array.from () का उपयोग कर

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 बस ऐरे-जैसे या Iterable ऑब्जेक्ट्स को Array इंस्टेंस में कनवर्ट करें।

---

---

ES5

आप वास्तव में सिर्फ उपयोग कर सकते हैं Arrayकी sliceएक तर्क वस्तु पर समारोह, और यह एक मानक JavaScript श्रृंखला में परिवर्तित कर देंगे। आपको बस इसे ऐरे के प्रोटोटाइप के माध्यम से मैन्युअल रूप से संदर्भित करना होगा:

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

यह काम क्यों करता है? खैर, यहाँ ECMAScript 5 के दस्तावेज़ीकरण का एक अंश है :

नोट : sliceफ़ंक्शन जानबूझकर सामान्य है; यह की आवश्यकता नहीं है कि अपनी इस मूल्य किसी सरणी वस्तु हो। इसलिए इसे एक विधि के रूप में उपयोग के लिए अन्य प्रकार की वस्तुओं में स्थानांतरित किया जा सकता है। क्या sliceफ़ंक्शन किसी होस्ट ऑब्जेक्ट पर सफलतापूर्वक लागू किया जा सकता है कार्यान्वयन-निर्भर है।

इसलिए, sliceऐसी किसी भी चीज़ पर काम करता है जिसके पास lengthसंपत्ति है, जो argumentsआसानी से करता है।

---

यदि आपके Array.prototype.sliceलिए बहुत अधिक मुंहफट है, तो आप इसे सरणी लिपि का उपयोग करके थोड़ा संक्षिप्त कर सकते हैं:

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

हालाँकि, मुझे लगता है कि पूर्व संस्करण अधिक स्पष्ट है, इसलिए मैं इसके बजाय इसे पसंद करूंगा। सरणी शाब्दिक संकेतन का दुरुपयोग करने से हैकी लगता है और अजीब लगता है।

Comments

हाल ही में फ़ायरफ़ॉक्स संस्करणों (2.0?) और ECMAScript 5 में, एक Array.slice विधि है जो इसे थोड़ा सरल बनाती है। आप इसे इस तरह कहेंगे: var arge = Array.slice (तर्क, 0);)

— मैथ्यू क्रूले

किस 0लिए है? चूंकि कोई तर्क नहीं है जिसे आप पास करना चाहते हैं, आप सिर्फ उपयोग क्यों नहीं कर सकते var args = Array.prototype.slice.call(arguments);? [ MDC तर्क पृष्ठ ] ( developer.mozilla.org/en/JavaScript/Reference/… ) बिना किसी विधि के सुझाव देता है 0।

— पीटर अज़ताई

@ बार्नी - सॉर्ट आवश्यक है क्योंकि मूल प्रश्न तर्कों को क्रमबद्ध करना चाहता है। यदि आप इसे किसी सरणी में बदलना चाहते हैं, तो यह आवश्यक नहीं है।

— क्रीज

"आपको तर्कों पर कटाक्ष नहीं करना चाहिए क्योंकि यह जावास्क्रिप्ट इंजन (उदाहरण के लिए V8) में अनुकूलन को रोकता है।" - MDN developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… से

— फ्रेमवर्किनजा

मुझे यकीन नहीं है कि मूल प्रश्न का उत्तर दे रहा हूं। समय गुजरता गया। फ़ायरफ़ॉक्स और क्रोम में प्रयोग किए गए ES6 के साथ, बाकी पैरामीटर एक अच्छा विकल्प बन रहा है - function sortArgs(...argsToSort) { return argsToSort.sort(); }MDN डेवलपर

— Kir Kanos

Answer 2

यह इस ब्लूबर्ड वादे पुस्तकालय विकि पृष्ठ को संदर्भित करने के लायक भी है जो दिखाता है कि argumentsऑब्जेक्ट को सरणी में कैसे प्रबंधित किया जाए जो V8 जावास्क्रिप्ट इंजन के तहत फ़ंक्शन को अनुकूलन योग्य बनाता है :

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);। लेखक यह भी दर्शाता है कि एक बिल्ड कदम कैसे क्रियात्मकता को कम करने में मदद कर सकता है।

Comments

+1 और ब्लूबर्ड ऑप्टिमाइज़ेशन किलर पेज के लिंक के लिए धन्यवाद। पुनश्च: मैंने हाल ही में नोड-थंकाइज़ प्रोजेक्ट में उपयोग किए गए इस अनुकूलन को देखा है ।

— यवेस एम।

Answer 3

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

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

कुछ सरणी विधियां जानबूझकर बनाई गई हैं ताकि लक्ष्य ऑब्जेक्ट को वास्तविक सरणी होने की आवश्यकता न हो। उन्हें केवल लंबाई और सूचकांक (जो शून्य या बड़ा पूर्णांक होना चाहिए) नाम की संपत्ति के लिए लक्ष्य की आवश्यकता होती है ।

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

Answer 4

उपयोग:

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

Array(arg1, arg2, ...) रिटर्न [arg1, arg2, ...]

Array(str1) रिटर्न [str1]

Array(num1)एक सरणी देता है जिसमें 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();
}

Comments

ध्यान दें कि Array.concat में सपाट व्यवहार के कारण, यह सरणी तर्क स्वीकार करेगा। छंटनी (2, [3,0], 1) 0,1,2,3 देता है।

— हफ्थोर

Answer 5

यदि आप jQuery का उपयोग कर रहे हैं, तो मेरी राय में याद रखना आसान है:

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

Comments

यह अनिवार्य रूप से वही है जो मैं शुद्ध JS में देख रहा था, लेकिन jQuery के JS को थोड़ा आसान बनाने के ठोस उदाहरण के लिए +1 है।

— एंड्रयू कोलेसन

"जब तक एक फ्रेमवर्क / लाइब्रेरी के लिए दूसरा टैग भी शामिल नहीं किया जाता है, शुद्ध जावास्क्रिप्ट उत्तर अपेक्षित होता है।"

— मिचेल पेरोलाकोव्स्की

Answer 6

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 का उपयोग करना चाहिए ।

Answer 7

यहाँ तर्कों को सरणी में परिवर्तित करने के कई तरीकों का बेंचमार्क है।

मेरे लिए, छोटी राशि के तर्कों के लिए सबसे अच्छा समाधान है:

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

Comments

बेंचमार्क के लिए +1। वर्तमान में ग्राफ़ आपके sortArgsफ़ायरफ़ॉक्स में 6 गुना तेज है, लेकिन नवीनतम क्रोम की तुलना में दोगुना धीमा है Array.apply।

— जॉयवेटलिड

चूँकि Array.prototype.slice को हटा दिया गया है क्योंकि यह JS V8 इंजन ऑप्टिमाइज़ेशन को रोकता है इसलिए मैं इसे सबसे अच्छा उपाय मानता हूं जब तक ES6 व्यापक रूप से उपलब्ध नहीं होगा +1

— साशा

इसके अलावा Array.slice () की तरह ऐरे जेनेरिक तरीके भी निकाले गए हैं

— साशा

Answer 8

मैं ECMAScript 6 स्प्रेड ऑपरेटर का उपयोग करने की सलाह देता हूं , जो एक पैरामीटर के लिए अनुगामी मापदंडों को बांध देगा। इस समाधान से आपको argumentsऑब्जेक्ट को छूने की जरूरत नहीं है और आपका कोड सरल हो जाएगा। इस समाधान का नकारात्मक पक्ष यह है कि यह अधिकांश ब्राउज़रों पर काम नहीं करता है, इसलिए इसके बजाय आपको जेएस कंपाइलर जैसे बैबेल का उपयोग करना होगा। हुड के तहत बैबल argumentsएक लूप के साथ एक ऐरे में बदल जाता है।

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

यदि आप एक ECMAScript 6 का उपयोग नहीं कर सकते हैं, तो मैं कुछ अन्य उत्तरों जैसे @Jonathan Fingland देखने की सलाह देता हूं

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

Answer 9

Lodash:

var args = _.toArray(arguments);

कार्रवाई में:

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

पैदा करता है:

[2,3]

Comments

क्यों नहीं _.toArray?

— मेनिक्सर

लेकिन _.toArrayअधिक उपयुक्त है।

— मेनिक्सेटर

मैं तर्क देता हूं कि _slice अधिक उपयुक्त है क्योंकि आप अक्सर कुछ प्रमुख तर्क छोड़ना चाहते हैं।

— हफथोर

Answer 10

उपयोग करें Array.from(), जो एक सरणी जैसी वस्तु (जैसे arguments) तर्क के रूप में लेता है और इसे सरणी में परिवर्तित करता है:

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

ध्यान दें कि यह IE 11 जैसे कुछ पुराने ब्राउज़रों में काम नहीं करता है, इसलिए यदि आप इन ब्राउज़रों का समर्थन करना चाहते हैं, तो आपको Babel का उपयोग करना चाहिए ।

Answer 11

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

Answer 12

एक और जवाब।

काले जादू मंत्र का प्रयोग करें:

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

फ़ायरफ़ॉक्स, क्रोम, Node.js, IE11 ठीक हैं।

Comments

यह निश्चित रूप से सबसे अच्छा समाधान है ... यदि आप अपने कोड को पूरी तरह से अपठनीय बनाना चाहते हैं। इसके अलावा, __proto__पदावनत किया जाता है। MDN डॉक्स देखें ।

— मिशैल पेरोलाकोव्स्की

Answer 13

प्रयोग करके देखें Object.setPrototypeOf()

स्पष्टीकरण: सेट prototypeके argumentsलिएArray.prototype

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

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

---

स्पष्टीकरण: प्रत्येक अनुक्रमणिका को argumentsसरणी के अनुक्रमणिका में एक सरणी में रखें।

वैकल्पिक रूप से उपयोग कर सकते हैं Array.prototype.map()

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

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

---

स्पष्टीकरण: प्रत्येक अनुक्रमणिका को 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]]]))

---

या Object.create()

स्पष्टीकरण: वस्तु बनाएं, प्रत्येक सूचकांक पर वस्तुओं के लिए वस्तु के गुण सेट करें 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]]]))

Comments

आप लोगों से पूछ रहे हैं कि क्या आपका उत्तर "लंबे उत्तर" के बारे में प्रश्न के तहत चेतावनी को संतुष्ट करता है। यह मुझे लगता है कि आपके उत्तर के साथ मुख्य मुद्दा यह है कि आप यह नहीं समझाते हैं कि किसी को आपके द्वारा दिखाए गए तरीकों का उपयोग क्यों करना चाहिए। ऐसा कोई तरीका नहीं है कि मैं आपके द्वारा प्रस्तावित किसी भी समाधान का उपयोग करूं क्योंकि वे स्वीकृत उत्तर में समाधानों से भी बदतर हैं। उदाहरण के लिए, आपके डॉक्टर ने Object.setPrototypeOfचेतावनी दी है कि यह एक "बहुत धीमा ऑपरेशन" है। पृथ्वी पर मैं इस का उपयोग क्यों करूंगा Array.prototype.slice.call?

— लुइस

@Louis प्रत्येक दृष्टिकोण के लिए स्पष्टीकरण के साथ अद्यतन उत्तर। ओपी पर प्रश्न "मानक पुस्तकालय का उपयोग करने के लिए एक अंतर्निहित तरीका है?" , "क्यों नहीं किसी को किसी भी तरीके का उपयोग करना चाहिए" जो अंतर्निहित हैं? कोई भी उपयोगकर्ता जो एक उत्तर पोस्ट करता है, वह सटीक रूप से निर्धारित कर सकता है कि पोस्ट किए गए समाधान ओपी के लिए "सही" हैं? ऐसा लगता है कि यह यह निर्धारित करने के लिए ओपी पर निर्भर है? दरअसल, अधिसूचना के इस हिस्से में इस उपयोगकर्ता की दिलचस्पी है: "समझाएं कि आपका उत्तर सही क्यों है" । इस प्रश्न के उत्तर में कोई भी उत्तर दें: "यह उत्तर" सही "है क्योंकि: x, y, z"?

— 2027 में अतिथि271314

मैंने जो समझाया है वह यह है कि एसओ आम तौर पर कैसे काम करता है। ओपी यह जानना चाहता है कि क्यों एक समाधान दूसरे की तुलना में बेहतर है, पूरी तरह से अप्रासंगिक है, क्योंकि एसओ के लिए पोस्ट किए गए प्रश्न मुख्य रूप से ओपी के लिए नहीं हैं , बल्कि उन सैकड़ों और हजार लोगों के लिए हैं जो प्रश्न और उसके उत्तर बाद में पढ़ेंगे। साथ ही, जो लोग ओपी से संतुष्ट हो सकते हैं, उनके अनुसार वोट देने वाले लोगों को जवाब देने की आवश्यकता नहीं है।

— लुई

Answer 14

यहाँ एक साफ और संक्षिप्त समाधान है:

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, आदि

Answer 15

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

का आनंद लें !

Comments

की तरह कुछ करने के लिए संशोधित करने के लिए सुझाव देना चाहेंगे arguments.length == 1?[arguments[0]]:Array.apply(null, arguments);समारोह को रोकने के लिए केवल एक पूर्णांक तर्क के साथ कहा जाता है dummyFn(3)और कारणों परिणाम[,,]

— कोई बात नहीं

@ अच्छा काम, मैं संपादित करता हूं, आपका संस्करण बेहतर है;) लेकिन मुझे समझ नहीं आया dummyFn(3)कि यह क्या है? यह फ़ंक्शन मौजूद नहीं है ...

— मैट्रिक्स

उह ... कोई बात नहीं, बस एक उदाहरण दिखाना चाहता हूं कि कैसे एक फ़ंक्शन केवल एक पूर्णांक तर्क के साथ बुलाया जाता है और एक निश्चित आकार के खाली सरणी का कारण बनता है, मेरी अंग्रेजी के लिए क्षमा करें।

— कोई बात नहीं

Answer 16

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

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

Answer 17

हालांकि बाकी पैरामीटर अच्छे से काम करते हैं, यदि आप 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()

Answer 18

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

मैंने सरल विनाशकारी तकनीक की कोशिश की

Answer 19

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

हालाँकि, आर्ग्यूमेंट ऑब्जेक्ट एक सरणी नहीं है और इसमें लंबाई के अलावा कोई अन्य गुण नहीं है।

आप तर्क ऑब्जेक्ट को उस सरणी में परिवर्तित कर सकते हैं जिस बिंदु पर आप तर्क ऑब्जेक्ट तक पहुंच सकते हैं।

ऐसे कई तरीके हैं जिनसे आप एक फ़ंक्शन बॉडी के अंदर तर्क ऑब्जेक्ट तक पहुंच सकते हैं, और इनमें शामिल हैं:

1. आप Array.prototoype.slice.call विधि को कॉल कर सकते हैं।

Array.prototype.slice.call (तर्क)

function giveMeArgs(arg1,arg2){

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

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

2. आप सरणी शाब्दिक का उपयोग कर सकते हैं

[] .Slice.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));

Answer 20

आप किसी भी तर्कों के साथ इसे करने के लिए एक पुन: प्रयोज्य कार्य बना सकते हैं, सबसे सरल एक ऐसा कुछ है:

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लिए तर्कों के माध्यम से लूप का उपयोग करना या उन्हें एक नए सरणी में असाइन करना ...

Answer 21

यह एक बहुत पुराना प्रश्न है, लेकिन मुझे लगता है कि मेरे पास एक समाधान है जो पिछले समाधानों की तुलना में थोड़ा आसान है और बाहरी पुस्तकालयों पर निर्भर नहीं है:

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

Comments

Array.applyयदि आपके पास केवल एक धनात्मक पूर्णांक तर्क है तो काम नहीं करेगा। यह इसलिए है क्योंकि new Array(3)एक सरणी लंबाई बनाता है 3। अधिक विशिष्ट होने के लिए परिणाम होगा [undefined, undefined, undefined]और नहीं [3]।

— inf3rno