JavaScript
Arrays

वाक्य - विन्यास

• सरणी = [ मूल्य , मूल्य , ... ]
• सरणी = नया एरियर ( मान , मान , ... )
• सरणी = Array.of ( मान , मूल्य , ... )
• सरणी = एरे.फ्रॉम ( सरणी )

टिप्पणियों

console.log(new Array(53)); // This array has 53 'undefined' elements!

console.log([53]); // Much better!

मानक सरणी आरंभीकरण

सरणियाँ बनाने के कई तरीके हैं। सबसे आम हैं सरणी लीटर या अर्रे कंस्ट्रक्टर का उपयोग करना:

var arr = [1, 2, 3, 4];
var arr2 = new Array(1, 2, 3, 4);

यदि Array कंस्ट्रक्टर का उपयोग बिना किसी तर्क के किया जाता है, तो एक खाली सरणी बनाई जाती है।

var arr3 = new Array();

का परिणाम:

[]

ध्यान दें कि यदि यह बिल्कुल एक तर्क के साथ प्रयोग किया जाता है और यह तर्क एक number , तो सभी undefined मानों के साथ उस लंबाई का एक सरणी बनाया जाएगा:

var arr4 = new Array(4);

का परिणाम:

[undefined, undefined, undefined, undefined]

यदि एकल तर्क गैर-संख्यात्मक है, तो यह लागू नहीं होता है:

var arr5 = new Array("foo");

का परिणाम:

["foo"]

Array.of(21, "Hello", "World");

[21, "Hello", "World"]

var newArray = Array.from({ length: 5 }, (_, index) => Math.pow(index, 4));

[0, 1, 16, 81, 256]

ऐरे फैल / आराम

फैला हुआ संचालक

let arr = [1, 2, 3, ...[4, 5, 6]];  // [1, 2, 3, 4, 5, 6]

// in ES < 6, the operations above are equivalent to
arr = [1, 2, 3];
arr.push(4, 5, 6);

let arr = [1, 2, 3, ...[..."456"].map(x=>parseInt(x))]; // [1, 2, 3, 4, 5, 6]

let arr = [..."123456"].map(x=>parseInt(x)); // [1, 2, 3, 4, 5, 6]

let arr = [..."123456"]; // ["1", "2", "3", "4", "5", "6"]

function myFunction(a, b, c) { }
let args = [0, 1, 2];

myFunction(...args);

// in ES < 6, this would be equivalent to:
myFunction.apply(null, args);

[a, b, ...rest] = [1, 2, 3, 4, 5, 6]; // rest is assigned [3, 4, 5, 6]

function myFunction(a, b, ...rest) { console.log(rest); }

myFunction(0, 1, 2, 3, 4, 5, 6); // rest is [2, 3, 4, 5, 6]

मानचित्रण मूल्यों

मौजूदा सरणी के मूल्यों के आधार पर एक नया सरणी उत्पन्न करना अक्सर आवश्यक होता है।

उदाहरण के लिए, स्ट्रिंग की एक सरणी से स्ट्रिंग लंबाई की एक सरणी उत्पन्न करने के लिए:

['one', 'two', 'three', 'four'].map(function(value, index, arr) {
  return value.length;
});
// → [3, 3, 5, 4]

['one', 'two', 'three', 'four'].map(value => value.length);
// → [3, 3, 5, 4]

इस उदाहरण में, map() फ़ंक्शन के लिए एक अनाम फ़ंक्शन प्रदान किया जाता है, और मैप फ़ंक्शन इसे इस क्रम में निम्नलिखित मापदंडों को प्रदान करते हुए सरणी के प्रत्येक तत्व के लिए कॉल करेगा:

• तत्व ही
• तत्व का सूचकांक (0, 1 ...)
• संपूर्ण सरणी

साथ ही, map() का मान सेट करने के लिए एक वैकल्पिक दूसरा पैरामीटर प्रदान करता है this मानचित्रण समारोह में। निष्पादन वातावरण पर निर्भर करता है, का डिफ़ॉल्ट मान this पराक्रम से बदलते हैं:

एक ब्राउज़र में, का डिफ़ॉल्ट मान this हमेशा होता है window :

['one', 'two'].map(function(value, index, arr) {
  console.log(this); // window (the default value in browsers)
  return value.length;
});

आप इसे इस तरह किसी भी कस्टम ऑब्जेक्ट में बदल सकते हैं:

['one', 'two'].map(function(value, index, arr) {
  console.log(this); // Object { documentation: "randomObject" }
  return value.length;
}, {
  documentation: 'randomObject'
});

फ़िल्टरिंग मान

filter() विधि सभी सरणी तत्वों से भरा एक सरणी बनाता है जो एक फ़ंक्शन के रूप में प्रदान की गई परीक्षा पास करता है।

[1, 2, 3, 4, 5].filter(function(value, index, arr) {
  return value > 2;
});

[1, 2, 3, 4, 5].filter(value => value > 2);

नए सरणी में परिणाम:

[3, 4, 5]

मिथ्या मूल्यों को फ़िल्टर करें

var filtered = [ 0, undefined, {}, null, '', true, 5].filter(Boolean);

चूंकि बूलियन एक देशी जावास्क्रिप्ट फ़ंक्शन / कंस्ट्रक्टर है जो [एक वैकल्पिक पैरामीटर] लेता है और फ़िल्टर विधि भी एक फ़ंक्शन लेती है और इसे वर्तमान सरणी आइटम को पैरामीटर के रूप में पारित करती है, आप इसे निम्न की तरह पढ़ सकते हैं:

1. Boolean(0) गलत देता है
2. Boolean(undefined) गलत देता है
3. Boolean({}) सही है जिसका अर्थ है कि इसे दिए गए सरणी में धकेलें
4. Boolean(null) गलत देता है
5. Boolean('') गलत है
6. Boolean(true) रिटर्न देता है, जिसका अर्थ है कि उसे लौटाए गए सरणी में धकेल दें
7. Boolean(5) सही है जिसका अर्थ है कि इसे दिए गए सरणी में धकेलें

इसलिए समग्र प्रक्रिया का परिणाम होगा

[ {}, true, 5 ]

एक और सरल उदाहरण

यह उदाहरण फ़ंक्शन को पास करने की उसी अवधारणा का उपयोग करता है जो एक तर्क लेता है

function startsWithLetterA(str) {
    if(str && str[0].toLowerCase() == 'a') {
        return true
    }
    return false;
}

var str              = 'Since Boolean is a native javascript function/constructor that takes [one optional paramater] and the filter method also takes a function and passes it the current array item as a parameter, you could read it like the following';
var strArray         = str.split(" ");
var wordsStartsWithA = strArray.filter(startsWithLetterA);
//["a", "and", "also", "a", "and", "array", "as"]

यात्रा

एक पारंपरिक for -loop

लूप के for एक पारंपरिक तीन घटक होते हैं:

1. इनिशियलाइज़ेशन: लुक ब्लॉक से पहले निष्पादित पहली बार निष्पादित किया गया है
2. स्थिति: लूप ब्लॉक निष्पादित होने से पहले हर बार एक स्थिति की जांच करता है, और गलत होने पर लूप को छोड़ देता है
3. बाद में: लूप ब्लॉक निष्पादित होने के बाद हर बार प्रदर्शन किया जाता है

इन तीन घटकों को एक दूसरे से अलग किया जाता है a ; प्रतीक। इन तीन घटकों में से प्रत्येक के लिए सामग्री वैकल्पिक है, जिसका अर्थ है कि निम्नलिखित लूप के for सबसे न्यूनतम है:

for (;;) {
    // Do stuff
}

बेशक, आपको एक if(condition === true) { break; } या if(condition === true) { return; } कहीं अंदर है कि यह चलने के for बंद करने के लिए।

आमतौर पर, हालांकि, इनिशियलाइज़ेशन का उपयोग इंडेक्स घोषित करने के लिए किया जाता है, इस शर्त का उपयोग उस इंडेक्स की न्यूनतम या अधिकतम मूल्य के साथ तुलना करने के लिए किया जाता है, और बाद में इंडेक्स को बढ़ाने के लिए उपयोग किया जाता है:

for (var i = 0, length = 10; i < length; i++) {
    console.log(i);
}

एक सरणी के माध्यम से पाश के for एक पारंपरिक का उपयोग करना

एक सरणी के माध्यम से लूप करने का पारंपरिक तरीका यह है:

for (var i = 0, length = myArray.length; i < length; i++) {
    console.log(myArray[i]);
}

या, यदि आप पीछे की ओर लूप करना पसंद करते हैं, तो आप ऐसा करते हैं:

for (var i = myArray.length - 1; i > -1; i--) {
    console.log(myArray[i]);
}

हालाँकि, कई बदलाव संभव हैं, उदाहरण के लिए यह एक:

for (var key = 0, value = myArray[key], length = myArray.length; key < length; value = myArray[++key]) {
    console.log(value);
}

... या यह एक ...

var i = 0, length = myArray.length;
for (; i < length;) {
    console.log(myArray[i]);
    i++;
}

... या यह एक:

var key = 0, value;
for (; value = myArray[key++];){
    console.log(value);
}

जो भी सबसे अच्छा काम करता है वह काफी हद तक व्यक्तिगत स्वाद और आपके द्वारा लागू किए जाने वाले विशिष्ट उपयोग के मामले में होता है।

ध्यान दें कि इनमें से प्रत्येक विविधता सभी ब्राउज़रों द्वारा समर्थित है, जिसमें बहुत पुराने भी शामिल हैं!

एक while लूप

एक करने के लिए एक वैकल्पिक for पाश एक है while पाश। एक सरणी के माध्यम से लूप करने के लिए, आप ऐसा कर सकते हैं:

var key = 0;
while(value = myArray[key++]){
    console.log(value);
}

छोरों के for पारंपरिक की तरह, while छोरों को ब्राउज़र के सबसे पुराने द्वारा भी समर्थन किया जाता है।

इसके अलावा, ध्यान दें कि हर जबकि पाश एक के रूप में लिखा जा सकता है कि for पाश। उदाहरण के लिए, while पाश hereabove इस के रूप में ठीक उसी तरह से बर्ताव करता है for -loop:

for(var key = 0; value = myArray[key++];){
    console.log(value);
}

for...in

जावास्क्रिप्ट में, आप यह भी कर सकते हैं:

for (i in myArray) {
    console.log(myArray[i]);
}

हालांकि, इसका उपयोग सावधानी से किया जाना चाहिए, क्योंकि यह सभी मामलों में लूप के for पारंपरिक के समान व्यवहार नहीं करता है, और संभावित साइड-इफेक्ट्स हैं जिन पर विचार करने की आवश्यकता है। देखें क्यों "इट्स ... इन" के साथ "एरियन" का उपयोग करना एक बुरा विचार है? अधिक जानकारी के लिए।

for...of

ES 6 में, for-of पाश एक सरणी के मूल्यों पर पुनरावृत्ति की सिफारिश की तरीका है:

let myArray = [1, 2, 3, 4];
for (let value of myArray) {
  let twoValue = value * 2;
  console.log("2 * value is: %d", twoValue);
}

निम्नलिखित उदाहरण लूप के for...of for...in और लूप में for...of बीच अंतर दिखाता है:

let myArray = [3, 5, 7];
myArray.foo = "hello";

for (var i in myArray) {
  console.log(i); // logs 0, 1, 2, "foo"
}

for (var i of myArray) {
  console.log(i); // logs 3, 5, 7
}

Array.prototype.keys()

Array.prototype.keys() विधि का उपयोग इस तरह के सूचकांकों पर पुनरावृति करने के लिए किया जा सकता है:

let myArray = [1, 2, 3, 4];
for (let i of myArray.keys()) {
  let twoValue = myArray[i] * 2;
  console.log("2 * value is: %d", twoValue);
}

Array.prototype.forEach()

.forEach(...) विधि ES 5 और इसके बाद के संस्करण में एक विकल्प है। यह सभी आधुनिक ब्राउज़रों द्वारा समर्थित है, साथ ही साथ इंटरनेट एक्सप्लोरर 9 और बाद में भी।

[1, 2, 3, 4].forEach(function(value, index, arr) {
  var twoValue = value * 2;
  console.log("2 * value is: %d", twoValue);
});

लूप के for पारंपरिक की तुलना में, हम .forEach() में लूप से बाहर नहीं जा सकते। इस मामले में, लूप के for उपयोग करें, या नीचे प्रस्तुत आंशिक पुनरावृत्ति का उपयोग करें।

जावास्क्रिप्ट के सभी संस्करणों में, लूप के for पारंपरिक सी-शैली का उपयोग करके एक सरणी के सूचकांक के माध्यम से पुनरावृति करना संभव है।

var myArray = [1, 2, 3, 4];
for(var i = 0; i < myArray.length; ++i) {
  var twoValue = myArray[i] * 2;
  console.log("2 * value is: %d", twoValue);
}

लूप करते while इसका उपयोग करना भी संभव है:

var myArray = [1, 2, 3, 4],
    i = 0, sum = 0;
while(i++ < myArray.length) {
  sum += i;
}
console.log(sum);

Array.prototype.every

ES5 के बाद से, यदि आप किसी सरणी के एक हिस्से पर पुनरावृति करना चाहते हैं, तो आप Array.prototype.every उपयोग कर सकते हैं, जो कि तब तक पुनरावृत्ति करता है जब तक कि हम false लौटते:

// [].every() stops once it finds a false result
// thus, this iteration will stop on value 7 (since 7 % 2 !== 0)
[2, 4, 7, 9].every(function(value, index, arr) {
  console.log(value);
  return value % 2 === 0; // iterate until an odd number is found
}); 

किसी भी जावास्क्रिप्ट संस्करण में बराबर:

var arr = [2, 4, 7, 9];
for (var i = 0; i < arr.length && (arr[i] % 2 !== 0); i++) { // iterate until an odd number is found
  console.log(arr[i]);
}

Array.prototype.some

Array.prototype.some तब तक Array.prototype.some जब तक हम वापस true :

// [].some stops once it finds a false result
// thus, this iteration will stop on value 7 (since 7 % 2 !== 0)
[2, 4, 7, 9].some(function(value, index, arr) {
  console.log(value);
  return value === 7; // iterate until we find value 7
}); 

किसी भी जावास्क्रिप्ट संस्करण में बराबर:

var arr = [2, 4, 7, 9];
for (var i = 0; i < arr.length && arr[i] !== 7; i++) {
  console.log(arr[i]);
}

पुस्तकालय

अंत में, कई यूटिलिटी लाइब्रेरीज़ की अपनी foreach भिन्नता है। सबसे लोकप्रिय लोगों में से तीन ये हैं:

jQuery.each() , jQuery में :

$.each(myArray, function(key, value) {
    console.log(value);
});

_.each() , अंडरस्कोर _.each() में:

_.each(myArray, function(value, key, myArray) {
    console.log(value);
});

_.forEach() , Lodash.js में :

_.forEach(myArray, function(value, key) {
    console.log(value);
});

SO पर निम्नलिखित प्रश्न भी देखें, जहाँ इस जानकारी को मूल रूप से पोस्ट किया गया था:

• जावास्क्रिप्ट में एक सरणी के माध्यम से लूप

फ़िल्टरिंग ऑब्जेक्ट एरर्स

filter() पद्धति एक परीक्षण फ़ंक्शन को स्वीकार करती है, और मूल सरणी के केवल तत्वों से युक्त एक नया सरणी प्रदान करती है जो प्रदान किए गए परीक्षण को पास करती है।

// Suppose we want to get all odd number in an array:
var numbers = [5, 32, 43, 4];

var odd = numbers.filter(function(n) {
  return n % 2 !== 0;
});

let odd = numbers.filter(n => n % 2 !== 0); // can be shortened to (n => n % 2)

odd में निम्न सरणी होगी: [5, 43] ।

यह वस्तुओं की एक सरणी पर भी काम करता है:

var people = [{
  id: 1,
  name: "John",
  age: 28
}, {
  id: 2,
  name: "Jane",
  age: 31
}, {
  id: 3,
  name: "Peter",
  age: 55
}];

var young = people.filter(function(person) {
  return person.age < 35;
});

let young = people.filter(person => person.age < 35);

young में निम्न सरणी होगी:

[{
  id: 1,
  name: "John",
  age: 28
}, {
  id: 2,
  name: "Jane",
  age: 31
}]

आप इस तरह से एक मूल्य के लिए पूरे सरणी में खोज कर सकते हैं:

var young = people.filter((obj) => {
  var flag = false;
  Object.values(obj).forEach((val) => {
    if(String(val).indexOf("J") > -1) {
      flag = true;
      return;
    }    
  });
  if(flag) return obj;
});

यह रिटर्न:

[{
  id: 1,
  name: "John",
  age: 28
},{
  id: 2,
  name: "Jane",
  age: 31
}]

एक स्ट्रिंग में सरणी तत्वों को जोड़ना

किसी सरणी के सभी तत्वों को स्ट्रिंग में join करने के लिए, आप join विधि का उपयोग कर सकते हैं:

console.log(["Hello", " ", "world"].join("")); // "Hello world"
console.log([1, 800, 555, 1234].join("-")); // "1-800-555-1234"

जैसा कि आप दूसरी पंक्ति में देख सकते हैं, जो आइटम तार नहीं हैं उन्हें पहले परिवर्तित किया जाएगा।

ऐरे की तरह ऐरे-ऑब्जेक्ट को परिवर्तित करना

ऐरे-जैसी वस्तुएं क्या हैं?

जावास्क्रिप्ट में "ऐरे-लाइक ऑब्जेक्ट्स" हैं, जो एक लंबाई संपत्ति के साथ एरे के ऑब्जेक्ट प्रतिनिधित्व हैं। उदाहरण के लिए:

var realArray = ['a', 'b', 'c'];
var arrayLike = {
  0: 'a',
  1: 'b',
  2: 'c',
  length: 3
};

वस्तुओं की तरह सरणी के सामान्य उदाहरण हैं arguments कार्यों में आपत्ति और HTMLCollection या NodeList तरह के तरीकों से लौटे वस्तुओं document.getElementsByTagName या document.querySelectorAll ।

हालाँकि, Arrays और Array जैसी वस्तुओं के बीच एक महत्वपूर्ण अंतर यह है कि Array जैसी वस्तुएँ Object.prototype बजाय Object.prototype से इनहेरिट Array.prototype । इसका मतलब यह है कि ऐरे जैसी वस्तुएं सामान्य ऐरे प्रोटोटाइप विधियों जैसे forEach() , push() , map() , filter() और slice() :

var parent = document.getElementById('myDropdown');
var desiredOption = parent.querySelector('option[value="desired"]');
var domList = parent.children;

domList.indexOf(desiredOption); // Error! indexOf is not defined.
domList.forEach(function() { 
  arguments.map(/* Stuff here */) // Error! map is not defined.
}); // Error! forEach is not defined.

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

ES6 में Arrays जैसी Array जैसी ऑब्जेक्ट में कनवर्ट करें

1. Array.from :

const arrayLike = {
  0: 'Value 0',
  1: 'Value 1',
  length: 2
};
arrayLike.forEach(value => {/* Do something */}); // Errors
const realArray = Array.from(arrayLike);
realArray.forEach(value => {/* Do something */}); // Works

2. for...of

var realArray = [];
for(const element of arrayLike) {
  realArray.append(element);
}

3. प्रसार ऑपरेटर:

[...arrayLike]

4. Object.values :

var realArray = Object.values(arrayLike);

5. Object.keys :

var realArray = Object
   .keys(arrayLike)
   .map((key) => arrayLike[key]);

Convert ES5 में ऐरे की तरह ऐरे को ऑब्जेक्ट में कनवर्ट करें

Array.prototype.slice उपयोग करें जैसे:

var arrayLike = {
  0: 'Value 0',
  1: 'Value 1',
  length: 2
};
var realArray = Array.prototype.slice.call(arrayLike);
realArray = [].slice.call(arrayLike); // Shorter version

realArray.indexOf('Value 1'); // Wow! this works

आप बिना किसी Array.prototype सीधे Array जैसे ऑब्जेक्ट पर Array.prototype तरीकों को कॉल करने के लिए Function.prototype.call का भी उपयोग कर सकते हैं:

var domList = document.querySelectorAll('#myDropdown option');

domList.forEach(function() { 
  // Do stuff
}); // Error! forEach is not defined.

Array.prototype.forEach.call(domList, function() { 
  // Do stuff
}); // Wow! this works

आप सरणी विधियों को उधार लेने और उन्हें अपनी वस्तु पर [].method.bind( arrayLikeObject ) लिए [].method.bind( arrayLikeObject ) का भी उपयोग कर सकते हैं:

var arrayLike = {
  0: 'Value 0',
  1: 'Value 1',
  length: 2
};

arrayLike.forEach(function() {
  // Do stuff
}); // Error! forEach is not defined.

[].forEach.bind(arrayLike)(function(val){
  // Do stuff with val
}); // Wow! this works

रूपांतरण के दौरान आइटम संशोधित करना

ES6 में, Array.from का उपयोग करते समय, हम एक मानचित्र फ़ंक्शन निर्दिष्ट कर सकते हैं जो नए सरणी के लिए मैप किया गया मान लौटाता है।

Array.from(domList, element => element.tagName); // Creates an array of tagName's

देखें विस्तृत विश्लेषण के लिए Arrays ऑब्जेक्ट हैं ।

मूल्यों को कम करना

[1, 2, 3, 4].reduce(function(a, b) {
  return a + b;
});
// → 10

[2].reduce(function(a, b) {
  console.log(a, b); // prints: 1 2
  return a + b;
}, 1);
// → 3

var array = [{
    key: 'one',
    value: 1
}, {
    key: 'two',
    value: 2
}, {
    key: 'three',
    value: 3
}];

array.reduce(function(obj, current) {
  obj[current.key] = current.value;
  return obj;
}, {});

array.reduce((obj, current) => Object.assign(obj, {
  [current.key]: current.value
}), {});

array.reduce((obj, current) => ({...obj, [current.key]: current.value}), {});

Flatten Array के उपरोक्त सभी उदाहरण निम्नलिखित हैं:

{
  one: 1,
  two: 2,
  three: 3
}

function map(list, fn) {
  return list.reduce(function(newList, item) {
    return newList.concat(fn(item));
  }, []);
}

// Usage:
map([1, 2, 3], function(n) { return n * n; });
// → [1, 4, 9]

var arr = [4, 2, 1, -10, 9]

arr.reduce(function(a, b) {
  return a < b ? a : b
}, Infinity);
// → -10

var arr = [1, 2, 1, 5, 9, 5];

arr.reduce((prev, number) => {
  if(prev.indexOf(number) === -1) {
    prev.push(number);
  }
  return prev;
}, []);
// → [1, 2, 5, 9]

मूल्यों की तार्किक संयोजकता

[false, false].some(function(value) {
  return value;
});
// Result: false

[false, true].some(function(value) {
  return value;
});
// Result: true

[true, true].some(function(value) {
  return value;
});
// Result: true

[false, false].every(function(value) {
  return value;
});
// Result: false

[false, true].every(function(value) {
  return value;
});
// Result: false

[true, true].every(function(value) {
  return value;
});
// Result: true

कॉनराटेटिंग एर्रेज़

दो अर्र

var array1 = [1, 2];
var array2 = [3, 4, 5];

var array3 = array1.concat(array2);  // returns a new array

var array3 = [...array1, ...array2]

नए Array में परिणाम:

[1, 2, 3, 4, 5]

एकाधिक ऐरे

var array1 = ["a", "b"],
    array2 = ["c", "d"],
    array3 = ["e", "f"],
    array4 = ["g", "h"];

var arrConc = array1.concat(array2, array3, array4);

var arrConc = [...array1, ...array2, ...array3, ...array4]

नए Array में परिणाम:

["a", "b", "c", "d", "e", "f", "g", "h"]

पहला ऐरे को कॉपी किए बिना

var longArray = [1, 2, 3, 4, 5, 6, 7, 8],
    shortArray = [9, 10];

longArray.push.apply(longArray, shortArray);

longArray.push(...shortArray)

longArray का मान अब है:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

ध्यान दें कि यदि दूसरा सरणी बहुत लंबा है (> 100,000 प्रविष्टियाँ), तो आपको स्टैक ओवरफ़्लो त्रुटि मिल सकती है (क्योंकि यह कैसे apply है)। सुरक्षित होने के लिए, आप इसके स्थान पर पुनरावृति कर सकते हैं:

shortArray.forEach(function (elem) {
    longArray.push(elem);
});

सरणी और गैर-सरणी मान

var array = ["a", "b"];

var arrConc = array.concat("c", "d");

var arrConc = [...array, "c", "d"]

नए Array में परिणाम:

["a", "b", "c", "d"]

आप गैर-सरणियों के साथ सरणियों को भी मिला सकते हैं

var arr1 = ["a","b"];
var arr2 = ["e", "f"];

var arrConc = arr1.concat("c", "d", arr2);

नए Array में परिणाम:

["a", "b", "c", "d", "e", "f"]

Array करने के लिए आइटम जोड़ें / प्रीपेंड करें

Unshift

एक सरणी की शुरुआत में एक या एक से अधिक आइटम जोड़ने के लिए .unshift का उपयोग करें।

उदाहरण के लिए:

var array = [3, 4, 5, 6];
array.unshift(1, 2);

सरणी परिणाम:

[1, 2, 3, 4, 5, 6]

धक्का दें

इसके अलावा .push का उपयोग वर्तमान में मौजूद आइटम के बाद आइटम जोड़ने के लिए किया जाता है।

उदाहरण के लिए:

var array = [1, 2, 3];
array.push(4, 5, 6);

सरणी परिणाम:

[1, 2, 3, 4, 5, 6]

दोनों विधियाँ नई सरणी लंबाई लौटाती हैं।

ऑब्जेक्ट कुंजियाँ और मान सरणी के लिए

var object = {
    key1: 10,
    key2: 3,
    key3: 40,
    key4: 20
};
 
var array = [];
for(var people in object) {
  array.push([people, object[people]]);
}

अब सरणी है

[
  ["key1", 10],
  ["key2", 3],
  ["key3", 40],
  ["key4", 20]
]

बहुआयामी सरणी को क्रमबद्ध करना

निम्नलिखित सरणी को देखते हुए

var array = [
  ["key1", 10],
  ["key2", 3],
  ["key3", 40],
  ["key4", 20]
];

आप इसे क्रमबद्ध करके क्रमबद्ध कर सकते हैं (दूसरा सूचकांक)

array.sort(function(a, b) {
  return a[1] - b[1];
})

array.sort((a,b) => a[1] - b[1]);

यह आउटपुट करेगा

[
  ["key2", 3],
  ["key1", 10],
  ["key4", 20],
  ["key3", 40]
]

ध्यान रखें कि सॉर्ट विधि जगह पर सरणी पर चल रही है । यह एरे को बदल देता है। अधिकांश अन्य सरणी विधियाँ एक नया सरणी लौटाती हैं, जिससे मूल एक बरकरार रहता है। यह नोट करना विशेष रूप से महत्वपूर्ण है यदि आप एक कार्यात्मक प्रोग्रामिंग शैली का उपयोग करते हैं और कार्यों को साइड-इफेक्ट न करने की अपेक्षा करते हैं।

किसी सरणी से आइटम निकालना

खिसक जाना

किसी सरणी के पहले आइटम को निकालने के लिए .shift का उपयोग करें।

उदाहरण के लिए:

var array = [1, 2, 3, 4];
array.shift();

सरणी परिणाम:

[2, 3, 4]

पॉप

आगे .pop का उपयोग किसी सरणी से अंतिम आइटम को निकालने के लिए किया जाता है।

उदाहरण के लिए:

var array = [1, 2, 3];
array.pop();

सरणी परिणाम:

[1, 2]

दोनों तरीके हटाए गए आइटम को वापस करते हैं;

ब्याह

सरणी से तत्वों की एक श्रृंखला निकालने के लिए .splice() का उपयोग करें। .splice() दो पैरामीटर, प्रारंभिक सूचकांक और हटाने के लिए तत्वों की एक वैकल्पिक संख्या को स्वीकार करता है। यदि दूसरा पैरामीटर बाहर छोड़ दिया जाता है। .splice() सरणी के अंत के माध्यम से प्रारंभिक सूचकांक से सभी तत्वों को हटा देगा।

उदाहरण के लिए:

var array = [1, 2, 3, 4];
array.splice(1, 2);

पत्ते युक्त array :

[1, 4]

array.splice() की वापसी हटाए गए तत्वों से युक्त एक नई सरणी है। उपरोक्त उदाहरण के लिए, वापसी होगी:

[2, 3]

इस प्रकार, दूसरे पैरामीटर को छोड़ने से प्रभावी रूप से सरणी को दो सरणियों में विभाजित किया जाता है, मूल के साथ निर्दिष्ट सूचकांक से पहले समाप्त होता है:

var array = [1, 2, 3, 4];
array.splice(2);

... [1, 2] युक्त array छोड़ता है और [3, 4] ।

हटाएं

सरणी की लंबाई को बदले बिना आइटम से delete लिए delete का उपयोग करें:

var array = [1, 2, 3, 4, 5];
console.log(array.length); // 5
delete array[2];
console.log(array); // [1, 2, undefined, 4, 5]
console.log(array.length); // 5

Array.prototype.length

सरणी की length के मान को असाइन करने से length दी गई मान में बदल जाती है। यदि नया मान सरणी लंबाई से कम है, तो आइटम को मूल्य के अंत से हटा दिया जाएगा।

array = [1, 2, 3, 4, 5];
array.length = 2;
console.log(array); // [1, 2]

उलटा सरणियों

.reverse का उपयोग किसी सरणी के अंदर वस्तुओं के क्रम को उलटने के लिए किया जाता है।

.reverse लिए उदाहरण:

[1, 2, 3, 4].reverse();

का परिणाम:

[4, 3, 2, 1]

नोट : कृपया ध्यान दें कि .reverse ( Array.prototype.reverse ) जगह में सरणी को उलट देगा। उलटी प्रतिलिपि वापस करने के बजाय, यह उसी सरणी को वापस करेगा, उलट।

var arr1 = [11, 22, 33];
var arr2 = arr1.reverse();
console.log(arr2); // [33, 22, 11]
console.log(arr1); // [33, 22, 11]

आप किसी सरणी को 'गहराई' से उल्टा भी कर सकते हैं:

function deepReverse(arr) {
  arr.reverse().forEach(elem => {
    if(Array.isArray(elem)) {
      deepReverse(elem);
    }
  });
  return arr;
}

गहरा के लिए उदाहरण:

var arr = [1, 2, 3, [1, 2, 3, ['a', 'b', 'c']]];

deepReverse(arr);

का परिणाम:

arr // -> [[['c','b','a'], 3, 2, 1], 3, 2, 1]

सरणी से मान निकालें

जब आपको किसी सरणी से एक विशिष्ट मान निकालने की आवश्यकता होती है, तो आप दिए गए मान के बिना प्रतिलिपि सरणी बनाने के लिए निम्नलिखित एक-लाइनर का उपयोग कर सकते हैं:

array.filter(function(val) { return val !== to_remove; });

या यदि आप प्रतिलिपि बनाए बिना सरणी को स्वयं बदलना चाहते हैं (उदाहरण के लिए यदि आप एक फ़ंक्शन लिखते हैं जो फ़ंक्शन के रूप में एक सरणी प्राप्त करता है और इसे हेरफेर करता है) तो आप इस स्निपेट का उपयोग कर सकते हैं:

while(index = array.indexOf(3) !== -1) { array.splice(index, 1); }

और अगर आपको केवल पहले मूल्य को हटाने की आवश्यकता है, तो लूप को हटा दें:

var index = array.indexOf(to_remove);
if(index !== -1) { array.splice(index , 1); }

जाँच रहा है कि क्या एक वस्तु एक सरणी है

Array.isArray(obj) true अगर ऑब्जेक्ट एक Array , अन्यथा false ।

Array.isArray([])           // true
Array.isArray([1, 2, 3])    // true
Array.isArray({})           // false
Array.isArray(1)            // false

ज्यादातर मामलों में आप कर सकते हैं instanceof यदि एक वस्तु एक है की जाँच करने के Array ।

[] instanceof Array; // true
{} instanceof Array; // false

Array.isArray एक का उपयोग करने पर एक फायदा है instanceof जाँच में है कि यह अभी भी वापस आ जाएगी true भले ही सरणी के प्रोटोटाइप बदल दिया गया है और वापस आ जाएगी false अगर एक गैर सरणियों प्रोटोटाइप में बदल गया था Array प्रोटोटाइप।

var arr = [];
Object.setPrototypeOf(arr, null);
Array.isArray(arr);   // true
arr instanceof Array; // false

छंटनी कर रहे हैं

.sort() विधि किसी सरणी के तत्वों को .sort() । डिफ़ॉल्ट विधि स्ट्रिंग यूनिकोड कोड बिंदुओं के अनुसार सरणी को सॉर्ट करेगी। किसी सरणी को सांख्यिक रूप से सॉर्ट करने के लिए .sort() विधि के लिए इसके साथ एक compareFunction पास होना चाहिए।

नोट: .sort() विधि अशुद्ध है। .sort() सरणी को इन-प्लेस में सॉर्ट करेगा, अर्थात, मूल एरे की सॉर्ट की गई कॉपी बनाने के बजाय, यह ओरिजिनल एरे को फिर से ऑर्डर करेगा और उसे लौटाएगा।

डिफ़ॉल्ट सॉर्ट करें

सरणी को UNICODE क्रम में रखता है।

['s', 't', 'a', 34, 'K', 'o', 'v', 'E', 'r', '2', '4', 'o', 'W', -1, '-4'].sort();

का परिणाम:

[-1, '-4', '2', 34, '4', 'E', 'K', 'W', 'a', 'l', 'o', 'o', 'r', 's', 't', 'v']

नोट: अपरकेस अक्षर लोअरकेस के ऊपर चले गए हैं। सरणी वर्णमाला क्रम में नहीं है, और संख्या संख्यात्मक क्रम में नहीं हैं।

वर्णमाला क्रमबद्ध

['s', 't', 'a', 'c', 'K', 'o', 'v', 'E', 'r', 'f', 'l', 'W', '2', '1'].sort((a, b) => {
  return a.localeCompare(b);        
});

का परिणाम:

['1', '2', 'a', 'c', 'E', 'f', 'K', 'l', 'o', 'r', 's', 't', 'v', 'W']

नोट: उपरोक्त सॉर्ट एक त्रुटि फेंक देगा यदि कोई सरणी आइटम एक स्ट्रिंग नहीं है। यदि आप जानते हैं कि सरणी में ऐसे आइटम हो सकते हैं जो तार नहीं हैं तो नीचे दिए गए सुरक्षित संस्करण का उपयोग करें।

['s', 't', 'a', 'c', 'K', 1, 'v', 'E', 'r', 'f', 'l', 'o', 'W'].sort((a, b) => {
  return a.toString().localeCompare(b);      
});

स्ट्रिंग छँटाई लंबाई (सबसे लंबे समय तक पहले)

["zebras", "dogs", "elephants", "penguins"].sort(function(a, b) {
  return b.length - a.length;
});

का परिणाम

["elephants", "penguins", "zebras", "dogs"];

लंबाई द्वारा छँटाई स्ट्रिंग (सबसे पहले)

["zebras", "dogs", "elephants", "penguins"].sort(function(a, b) {
  return a.length - b.length;
});

का परिणाम

["dogs", "zebras", "penguins", "elephants"];

संख्यात्मक क्रमबद्ध (आरोही)

[100, 1000, 10, 10000, 1].sort(function(a, b) {
  return a - b;
});

का परिणाम:

[1, 10, 100, 1000, 10000]

न्यूमेरिकल सॉर्ट (अवरोही)

[100, 1000, 10, 10000, 1].sort(function(a, b) {
  return b - a;
});

का परिणाम:

[10000, 1000, 100, 10, 1]

सम तथा विषम संख्याओं द्वारा क्रमबद्ध सारणी

[10, 21, 4, 15, 7, 99, 0, 12].sort(function(a, b) {
    return (a & 1) - (b & 1) || a - b;
});

का परिणाम:

[0, 4, 10, 12, 7, 15, 21, 99]

दिनांक क्रमबद्ध (अवरोही)

var dates = [
  new Date(2007, 11, 10),
  new Date(2014, 2, 21),
  new Date(2009, 6, 11),
  new Date(2016, 7, 23)
];

dates.sort(function(a, b) {
  if (a > b) return -1;
  if (a < b) return 1;
  return 0;
});

// the date objects can also sort by its difference
// the same way that numbers array is sorting
dates.sort(function(a, b) {
  return b-a;
});

का परिणाम:

[
  "Tue Aug 23 2016 00:00:00 GMT-0600 (MDT)",
  "Fri Mar 21 2014 00:00:00 GMT-0600 (MDT)",
  "Sat Jul 11 2009 00:00:00 GMT-0600 (MDT)",
  "Mon Dec 10 2007 00:00:00 GMT-0700 (MST)"
]

एक सरणी क्लोनिंग

कभी-कभी, आपको यह सुनिश्चित करने की आवश्यकता होती है कि आप मूल को संशोधित न करते हुए एक सरणी के साथ काम करें। एक clone विधि के बजाय, सरणियों में एक slice विधि होती है जो आपको किसी सरणी के किसी भी भाग की उथली प्रतिलिपि बनाने की अनुमति देती है। ध्यान रखें कि यह केवल पहले स्तर पर क्लोन करता है। यह आदिम प्रकारों के साथ अच्छी तरह से काम करता है, जैसे संख्या और तार, लेकिन ऑब्जेक्ट नहीं।

उथले-क्लोन करने के लिए एक सरणी (यानी एक नया सरणी उदाहरण है, लेकिन समान तत्वों के साथ), आप निम्न एक-लाइनर का उपयोग कर सकते हैं:

var clone = arrayToClone.slice();

यह अंतर्निहित JavaScript Array.prototype.slice पद्धति को कॉल करता है। यदि आप slice लिए तर्क पारित करते हैं, तो आप अधिक जटिल व्यवहार प्राप्त कर सकते हैं जो किसी सरणी के केवल भाग के उथले क्लोन बनाते हैं, लेकिन हमारे उद्देश्यों के लिए सिर्फ slice() कॉलिंग पूरे सरणी की एक उथली प्रतिलिपि बनाएगी।

किसी सरणी को क्लोन करने के लिए वस्तुओं की तरह सरणी में परिवर्तित करने के लिए उपयोग की जाने वाली सभी विधि:

arrayToClone = [1, 2, 3, 4, 5];
clone1 = Array.from(arrayToClone);
clone2 = Array.of(...arrayToClone);
clone3 = [...arrayToClone] // the shortest way

arrayToClone = [1, 2, 3, 4, 5];
clone1 = Array.prototype.slice.call(arrayToClone);
clone2 = [].slice.call(arrayToClone);

एक ऐरे को खोजना

अनुशंसित तरीका ( ES5 के बाद से) Array.prototyp.find का उपयोग करना है :

let people = [
  { name: "bob" },
  { name: "john" }
];

let bob = people.find(person => person.name === "bob");

// Or, more verbose
let bob = people.find(function(person) {
  return person.name === "bob";
});

जावास्क्रिप्ट के किसी भी संस्करण में, लूप के for एक मानक का उपयोग किया जा सकता है:

for (var i = 0; i < people.length; i++) {
  if (people[i].name === "bob") {
    break; // we found bob
  }
}

FindIndex

FindIndex () विधि सरणी में एक सूचकांक देता है, यदि सरणी में कोई तत्व प्रदान किए गए परीक्षण फ़ंक्शन को संतुष्ट करता है। अन्यथा -1 वापस कर दिया जाता है।

array = [
  { value: 1 },
  { value: 2 },
  { value: 3 },
  { value: 4 },
  { value: 5 }
];
var index = array.findIndex(item => item.value === 3); // 2
var index = array.findIndex(item => item.value === 12); // -1

ब्याह का उपयोग करके तत्वों को निकालना / जोड़ना ()

ऐरे से तत्वों को निकालने के लिए splice() विधि का उपयोग किया जा सकता है। इस उदाहरण में, हम पहले 3 को सरणी से हटाते हैं।

var values = [1, 2, 3, 4, 5, 3];
var i = values.indexOf(3);
if (i >= 0) {
  values.splice(i, 1);
}
// [1, 2, 4, 5, 3]

तत्वों को एक सरणी में जोड़ने के लिए splice() विधि का भी उपयोग किया जा सकता है। इस उदाहरण में, हम सरणी के अंत में संख्या 6, 7 और 8 डालेंगे।

var values = [1, 2, 4, 5, 3];
var i = values.length + 1;
values.splice(i, 0, 6, 7, 8);
//[1, 2, 4, 5, 3, 6, 7, 8]

splice() का पहला तर्क splice() विधि वह सूचकांक है जिस पर तत्वों को निकालना / सम्मिलित करना है। दूसरा तर्क निकालने के लिए तत्वों की संख्या है। तीसरा तर्क और उसके बाद सरणी में सम्मिलित करने के लिए मान हैं।

तुलना करना

सरल सरणी तुलना के लिए आप JSON स्ट्रिंग का उपयोग कर सकते हैं और आउटपुट स्ट्रिंग्स की तुलना कर सकते हैं:

JSON.stringify(array1) === JSON.stringify(array2)

नोट: कि यह केवल तभी काम करेगा जब दोनों ऑब्जेक्ट JSON क्रमिक हों और जिनमें चक्रीय संदर्भ न हों। यह TypeError: Converting circular structure to JSON को फेंक सकता है TypeError: Converting circular structure to JSON

आप सरणियों की तुलना करने के लिए एक पुनरावर्ती फ़ंक्शन का उपयोग कर सकते हैं।

function compareArrays(array1, array2) { 
  var i, isA1, isA2;
  isA1 = Array.isArray(array1);
  isA2 = Array.isArray(array2);
  
  if (isA1 !== isA2) { // is one an array and the other not?
    return false;      // yes then can not be the same
  }
  if (! (isA1 && isA2)) {      // Are both not arrays 
    return array1 === array2;  // return strict equality
  }
  if (array1.length !== array2.length) { // if lengths differ then can not be the same
    return false;
  }
  // iterate arrays and compare them
  for (i = 0; i < array1.length; i += 1) {
    if (!compareArrays(array1[i], array2[i])) { // Do items compare recursively
      return false;
    }           
  }
  return true; // must be equal
}

चेतावनी: इसके बाद के संस्करण समारोह का उपयोग करना खतरनाक है और एक में लपेटा जाना चाहिए try catch अगर आपको संदेह इस बात की संभावना सरणी चक्रीय संदर्भ (जो स्वयं का संदर्भ होता है एक सरणी के लिए एक संदर्भ) है

a = [0] ;
a[1] = a;
b = [0, a]; 
compareArrays(a, b); // throws RangeError: Maximum call stack size exceeded

नोट: फ़ंक्शन नॉन एरे आइटमों की तुलना करने के लिए फ़ंक्शन सख्त समानता ऑपरेटर === का उपयोग करता है {a: 0} === {a: 0} false

एक सरणी को नष्ट करना

const triangle = [3, 4, 5];
const [length, height, hypotenuse] = triangle;

length === 3;     // → true
height === 4;     // → true
hypotneuse === 5; // → true

const [,b,,c] = [1, 2, 3, 4];

console.log(b, c); // → 2, 4

const [b,c, ...xs] = [2, 3, 4, 5];
console.log(b, c, xs); // → 2, 3, [4, 5]

function area([length, height]) {
  return (length * height) / 2;
}

const triangle = [3, 4, 5];

area(triangle); // → 6

डुप्लिकेट तत्वों को निकाल रहा है

ES5.1 के बाद से, आप एक सरणी के माध्यम से लूप के लिए मूल विधि Array.prototype.filter का उपयोग कर सकते हैं और केवल प्रविष्टियों को छोड़ सकते हैं जो किसी दिए गए कॉलबैक फ़ंक्शन को पास करते हैं।

निम्नलिखित उदाहरण में, हमारे कॉलबैक की जाँच करता है कि दिए गए मान सरणी में होते हैं या नहीं। यदि ऐसा होता है, तो यह एक डुप्लिकेट है और परिणामस्वरूप सरणी में कॉपी नहीं किया जाएगा।

var uniqueArray = ['a', 1, 'a', 2, '1', 1].filter(function(value, index, self) { 
  return self.indexOf(value) === index;
}); // returns ['a', 1, 2, '1']

यदि आपका वातावरण ES6 का समर्थन करता है, तो आप सेट ऑब्जेक्ट का उपयोग भी कर सकते हैं। यह ऑब्जेक्ट आपको किसी भी प्रकार के अनूठे मूल्यों को संग्रहीत करने देता है, चाहे आदिम मूल्य या वस्तु संदर्भ:

var uniqueArray = [... new Set(['a', 1, 'a', 2, '1', 1])];

एसओ पर निम्न आर्य भी देखें:

• संबंधित एसओ जवाब
• ईएस 6 के साथ संबंधित जवाब

सभी तत्वों को हटाना

var arr = [1, 2, 3, 4];

विधि 1

एक नया सरणी बनाता है और मौजूदा सरणी संदर्भ को नए के साथ अधिलेखित करता है।

arr = [];

ध्यान रखा जाना चाहिए क्योंकि यह मूल सरणी से किसी भी आइटम को नहीं हटाता है। किसी फ़ंक्शन में पास होने पर सरणी बंद हो सकती है। फ़ंक्शन के जीवन के लिए सरणी स्मृति में रहेगी, हालांकि आपको इसके बारे में पता नहीं हो सकता है। यह मेमोरी लीक का एक सामान्य स्रोत है।

खराब सरणी समाशोधन से उत्पन्न स्मृति रिसाव का उदाहरण:

var count = 0;

function addListener(arr) { // arr is closed over
  var b = document.body.querySelector("#foo" + (count++));
  b.addEventListener("click", function(e) { // this functions reference keeps
    // the closure current while the
    // event is active
    // do something but does not need arr       
  });
}

arr = ["big data"];
var i = 100;
while (i > 0) {
  addListener(arr); // the array is passed to the function
  arr = []; // only removes the reference, the original array remains
  array.push("some large data"); // more memory allocated
  i--;
}
// there are now 100 arrays closed over, each referencing a different array
// no a single item has been deleted

स्मृति रिसाव के जोखिम को रोकने के लिए उपरोक्त उदाहरण के लूप में सरणी को खाली करने के लिए निम्न 2 विधियों में से एक का उपयोग करें।

विधि 2

लंबाई गुण सेट करना नई सरणी लंबाई से पुरानी सरणी लंबाई तक सभी सरणी तत्व को हटा देता है। यह सरणी में सभी आइटम्स को निकालने और उन्हें हटाने का सबसे कुशल तरीका है। मूल सरणी का संदर्भ रखता है

arr.length = 0;

विधि 3

विधि 2 के समान है, लेकिन हटाए गए आइटमों के साथ एक नया सरणी देता है। यदि आपको वस्तुओं की आवश्यकता नहीं है तो यह विधि अक्षम है क्योंकि नया सरणी अभी भी केवल तुरंत बनाए जाने के लिए बनाया गया है।

arr.splice(0); // should not use if you don't want the removed items
// only use this method if you do the following
var keepArr = arr.splice(0); // empties the array and creates a new array containing the
                             // removed items

संबंधित प्रश्न ।

किसी सरणी में पुन: स्वरूपित वस्तुओं के मानचित्र का उपयोग करना

Array.prototype.map() : मूल सरणी में प्रत्येक तत्व पर दिए गए फ़ंक्शन को कॉल करने के परिणामों के साथ एक नया सरणी देता है।

निम्नलिखित कोड उदाहरण व्यक्तियों की एक सरणी लेता है और एक नया सरणी बनाता है जिसमें 'fullName' संपत्ति वाले व्यक्ति होते हैं

var personsArray = [
  {
    id: 1,
    firstName: "Malcom",
    lastName: "Reynolds"
  }, {
    id: 2,
    firstName: "Kaylee",
    lastName: "Frye"
  }, {
    id: 3,
    firstName: "Jayne",
    lastName: "Cobb"
  }
];

// Returns a new array of objects made up of full names.
var reformatPersons = function(persons) {
  return persons.map(function(person) {
    // create a new object to store full name.
    var newObj = {};
    newObj["fullName"] = person.firstName + " " + person.lastName;

    // return our new object.
    return newObj;
  });
};

अब हम reformatPersons(personsArray) कॉल कर सकते हैं और प्रत्येक व्यक्ति के पूर्ण नामों का एक नया सरणी प्राप्त कर सकते हैं।

var fullNameArray = reformatPersons(personsArray);
console.log(fullNameArray);
/// Output
[
  { fullName: "Malcom Reynolds" }, 
  { fullName: "Kaylee Frye" },
  { fullName: "Jayne Cobb" }
]

personsArray और इसकी सामग्री अपरिवर्तित रहती है।

console.log(personsArray);
/// Output
[
  {
    firstName: "Malcom",
    id: 1,
    lastName: "Reynolds"
  }, {
    firstName: "Kaylee",
    id: 2,
    lastName: "Frye"
  }, {
    firstName: "Jayne",
    id: 3,
    lastName: "Cobb"
  }
]

कुंजी मान युग्म के रूप में दो सरणी मिलाएं

जब हमारे पास दो अलग-अलग सरणी होती है और हम उस दो सरणी से महत्वपूर्ण मूल्य युग्म बनाना चाहते हैं, तो हम नीचे दिए गए सरणी प्रकार को कम कर सकते हैं:

var columns = ["Date", "Number", "Size", "Location", "Age"];
var rows = ["2001", "5", "Big", "Sydney", "25"];
var result =  rows.reduce(function(result, field, index) {
  result[columns[index]] = field;
  return result;
}, {})

console.log(result);

आउटपुट:

{
  Date: "2001",
  Number: "5",
  Size: "Big",
  Location: "Sydney",
  Age: "25"
}

एक स्ट्रिंग को एक ऐरे में परिवर्तित करें

.split() विधि सबस्ट्रिंग की एक सरणी में एक स्ट्रिंग को विभाजित करती है। डिफ़ॉल्ट रूप से .split() रिक्त स्थान में स्ट्रिंग को तोड़ देगा ( " " ), जो कॉलिंग के बराबर है .split(" ") ।

स्ट्रिंग को विभाजित करने के लिए उपयोग करने के लिए पैरामीटर .split() वर्ण या नियमित अभिव्यक्ति निर्दिष्ट करता है।

एक सरणी कॉल में एक स्ट्रिंग विभाजित करने के लिए .split कोई रिक्त स्ट्रिंग (के साथ "" )। महत्वपूर्ण नोट: यह केवल तभी काम करता है जब आपके सभी पात्र यूनिकोड की निचली श्रेणी के पात्रों में फिट होते हैं, जो अधिकांश अंग्रेजी और अधिकांश यूरोपीय भाषाओं को कवर करता है। उन भाषाओं के लिए जिन्हें 3 और 4 बाइट यूनिकोड वर्णों की आवश्यकता होती है, slice("") उन्हें अलग करेगा।

var strArray = "StackOverflow".split("");
// strArray = ["S", "t", "a", "c", "k", "O", "v", "e", "r", "f", "l", "o", "w"]

var strArray = [..."sky is blue"];        
// strArray = ["s", "k", "y", " ", "i", "s", " ", "b", "l", "u", "e"]

समानता के लिए सभी सरणी आइटम का परीक्षण करें

.every विधि परीक्षण यदि सभी सरणी तत्व प्रदान किए गए विधेय परीक्षण को पास करते हैं।

समानता के लिए सभी वस्तुओं का परीक्षण करने के लिए, आप निम्नलिखित कोड स्निपेट का उपयोग कर सकते हैं।

[1, 2, 1].every(function(item, i, list) { return item === list[0]; }); // false
[1, 1, 1].every(function(item, i, list) { return item === list[0]; }); // true

[1, 1, 1].every((item, i, list) => item === list[0]); // true

संपत्ति समानता के लिए निम्नलिखित कोड स्निपेट परीक्षण करते हैं

let data = [
  { name: "alice", id: 111 },
  { name: "alice", id: 222 }
];

data.every(function(item, i, list) { return item === list[0]; }); // false
data.every(function(item, i, list) { return item.name === list[0].name; }); // true

data.every((item, i, list) => item.name === list[0].name); // true

एक ऐरे का हिस्सा कॉपी करें

टुकड़ा () विधि एक सरणी के एक हिस्से की एक प्रति लौटाती है।

यह दो पैरामीटर लेता है, arr.slice([begin[, end]]) :

शुरू

शून्य आधारित सूचकांक जो निष्कर्षण की शुरुआत है।

समाप्त

शून्य-आधारित सूचकांक जो निष्कर्षण का अंत है, जो इस सूचकांक को घटाता है लेकिन इसमें शामिल नहीं है।

यदि अंत एक ऋणात्मक संख्या है, तो end = arr.length + end ।

उदाहरण 1

// Let's say we have this Array of Alphabets
var arr = ["a", "b", "c", "d"...];

// I want an Array of the first two Alphabets
var newArr = arr.slice(0, 2); // newArr === ["a", "b"]

उदाहरण 2

// Let's say we have this Array of Numbers
// and I don't know it's end
var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9...];

// I want to slice this Array starting from
// number 5 to its end
var newArr = arr.slice(4); // newArr === [5, 6, 7, 8, 9...]

न्यूनतम या अधिकतम तत्व ढूँढना

यदि आपकी सरणी या सरणी जैसी वस्तु संख्यात्मक है , अर्थात, यदि इसके सभी तत्व संख्याएँ हैं, तो आप पहले तर्क के रूप में null करके Math.min.apply या Math.max.apply उपयोग कर सकते हैं, और दूसरे के रूप में आपका सरणी। ।

var myArray = [1, 2, 3, 4];

Math.min.apply(null, myArray); // 1
Math.max.apply(null, myArray); // 4

var myArray = [1, 2, 3, 4, 99, 20];

var maxValue = Math.max(...myArray); // 99
var minValue = Math.min(...myArray); // 1

निम्न उदाहरण एक का उपयोग करता है for पाश:

var maxValue = myArray[0];
for(var i = 1; i < myArray.length; i++) {
   var currentValue = myArray[i];
   if(currentValue > maxValue) {
      maxValue = currentValue;
   }
}

var myArray = [1, 2, 3, 4];

myArray.reduce(function(a, b) {
  return Math.min(a, b);
}); // 1

myArray.reduce(function(a, b) {
  return Math.max(a, b);
}); // 4

myArray.reduce((a, b) => Math.min(a, b)); // 1
myArray.reduce((a, b) => Math.max(a, b)); // 4

function myMax(array) {
  return array.reduce(function(maxSoFar, element) {
    return Math.max(maxSoFar, element);
  }, -Infinity);
}

myMax([3, 5]);             // 5
myMax([]);                 // -Infinity
Math.max.apply(null, []);  // -Infinity

चपटे Arrays

2 आयामी सरणियाँ

function flattenES6(arr) {
  return [].concat(...arr);
}

var arrL1 = [1, 2, [3, 4]];
console.log(flattenES6(arrL1)); // [1, 2, 3, 4]

function flatten(arr) {
  return [].concat.apply([], arr);
}

var arrL1 = [1, 2, [3, 4]];
console.log(flatten(arrL1)); // [1, 2, 3, 4]

उच्च आयाम Arrays

इस तरह एक गहरी नेस्टेड सरणी को देखते हुए

var deeplyNested = [4,[5,6,[7,8],9]];

यह इस जादू से चपटा हो सकता है

console.log(String(deeplyNested).split(',').map(Number);
#=> [4,5,6,7,8,9]

या

const flatten = deeplyNested.toString().split(',').map(Number)
console.log(flatten);
#=> [4,5,6,7,8,9]

उपरोक्त दोनों विधियाँ केवल तभी काम करती हैं जब सरणी विशेष रूप से संख्याओं से बनी होती है। इस पद्धति द्वारा वस्तुओं के एक बहु-आयामी सरणी को समतल नहीं किया जा सकता है।

किसी आइटम को एक विशिष्ट इंडेक्स पर एक सरणी में डालें

सरल आइटम सम्मिलन Array.prototype.splice विधि के साथ किया जा सकता है:

arr.splice(index, 0, item);

कई तर्कों और जंजीरों के समर्थन के साथ अधिक उन्नत संस्करण:

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
  this.splice.apply(this, [index, 0].concat(
    Array.prototype.slice.call(arguments, 1)));
  return this;
};

["a", "b", "c", "d"].insert(2, "X", "Y", "Z").slice(1, 6);  // ["b", "X", "Y", "Z", "c"]

और सरणी-प्रकार के तर्कों के साथ विलय और जंजीरों का समर्थन:

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
  index = Math.min(index, this.length);
  arguments.length > 1
    && this.splice.apply(this, [index, 0].concat([].pop.call(arguments)))
    && this.insert.apply(this, arguments);
  return this;
};

["a", "b", "c", "d"].insert(2, "V", ["W", "X", "Y"], "Z").join("-");  // "a-b-V-W-X-Y-Z-c-d"

प्रविष्टियाँ () विधि

entries() विधि एक नया ऐरे Iterator ऑब्जेक्ट देता है जिसमें सरणी में प्रत्येक इंडेक्स के लिए कुंजी / मान जोड़े होते हैं।

var letters = ['a','b','c'];

for(const[index,element] of letters.entries()){
  console.log(index,element);
}

परिणाम

0 "a"
1 "b"
2 "c"

नोट : यह विधि इंटरनेट एक्सप्लोरर में समर्थित नहीं है।

CC-SA-2.5 के तहत लाइसेंस प्राप्त मोज़िला योगदानकर्ताओं द्वारा Array.prototype.entries से इस सामग्री के अंश