मैं जावास्क्रिप्ट में दो आयामी सरणी कैसे बना सकता हूं?

1137

मैं ऑनलाइन पढ़ रहा हूं और कुछ जगह कहते हैं कि यह संभव नहीं है, कुछ कहते हैं कि यह एक उदाहरण है और अन्य उदाहरण का खंडन करते हैं, आदि।

  1. मैं जावास्क्रिप्ट में 2 आयामी सरणी कैसे घोषित करूं? (यह संभव है)

  2. मैं इसके सदस्यों तक कैसे पहुँच पाऊँगा? ( myArray[0][1]या myArray[0,1]?)

javascript  arrays  multidimensional-array 
— डिएगो
स्रोत
21
कुछ हद तक पांडित्य की परिभाषा, यह जावास्क्रिप्ट में एक 2d सरणी बनाने के लिए तकनीकी रूप से असंभव है। लेकिन आप एक सारणी बना सकते हैं, जो समान है।
— IJ कैनेडी
10
FYI करें ... जब आप उपयोग करके अधिक सरणियों के साथ एक सरणी भरते हैं var arr2D = new Array(5).fill(new Array(3));, तो Array (5) का प्रत्येक तत्व समान Array (3) को इंगित करेगा। इसलिए उप-सरणियों को गतिशील रूप से आबाद करने के लिए लूप के लिए उपयोग करना सबसे अच्छा है।
— जोश स्ट्रिब्लिंग
51
a = Array(5).fill(0).map(x => Array(10).fill(0))
— वू
2
दूसरे शब्दों में, भरे जाने वाले एरे के प्रत्येक इंडेक्स के लिए fillकॉल नहीं करता है new Array(3), क्योंकि यह लैम्ब्डा एक्सप्रेशन या कुछ भी नहीं है, जैसे कि ऊपर लॉन्गफेई वू की टिप्पणी, जो शुरुआत में 0 के साथ सरणी को भरता है, फिर लैम्बडा के साथ मैप फ़ंक्शन का उपयोग करता है। प्रत्येक तत्व को नए सरणी के साथ भरें। भरण फ़ंक्शन केवल उसी सरणी को भरता है जिसे आप इसे बताते हैं। क्या इसका कोई मतलब है? mapफ़ंक्शन के बारे में अधिक जानकारी के लिए , देखें: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
— जोश स्ट्रिपिंग
2
@kalehmann जो ठीक है: meta.stackoverflow.com/a/252017/2311074 If the new question is a better question or has better answers, then vote to close the old one as a duplicate of the new one.
— एडम

जवाबों:

1231 

var items = [
  [1, 2],
  [3, 4],
  [5, 6]
];
console.log(items[0][0]); // 1
console.log(items[0][1]); // 2
console.log(items[1][0]); // 3
console.log(items[1][1]); // 4
console.log(items);
स्निपेट का विस्तार करें

— Ballsacian1
स्रोत
32
इस तरह एक बड़े बहुआयामी सरणी को शुरू करना मुश्किल होगा। हालांकि, इस फ़ंक्शन का उपयोग रिक्त बहुआयामी बनाने के लिए किया जा सकता है, जिसमें मापदंडों के रूप में निर्दिष्ट आयाम हैं।
— एंडरसन ग्रीन
2
@AndersonGreen यह एक अच्छी बात है कि आपने मल्टी-डी सरणी समाधान में रुचि रखने वालों के लिए एक लिंक का उल्लेख किया है, लेकिन प्रश्न और बॉल्ससिएन 1 का उत्तर "2 डी" सरणी के बारे में है, न कि "मल्टी-डी" सरणी
— बुराईरिको
आपको पूरी बात से गुजरना चाहिए ... उदाहरण के लिए चेतावनी (आइटम [0] [1]); // 2 आदि
— Dois
1
@SashikaXP, यह 0. के अलावा अन्य पहले सूचकांकों के लिए काम नहीं करता है
— माइकल फ्रांज
1
सवाल यह है कि दो आयामी सरणी कैसे घोषित की जाए। यही वह चीज है जिसकी मुझे तलाश थी और यह और निम्नलिखित उत्तर मिले जो घोषणा और प्रारंभिक के बीच के अंतर को समझने में विफल रहे। ज्ञात लंबाई या असंबद्ध के साथ घोषणा भी है, जिसमें से किसी पर भी चर्चा नहीं की गई है।
— क्रिस
444

आप बस प्रत्येक आइटम को एक सरणी के भीतर बनाते हैं।

var x = new Array(10);

for (var i = 0; i < x.length; i++) {
  x[i] = new Array(3);
}

console.log(x);
स्निपेट का विस्तार करें

— Sufian
स्रोत
6
क्या वे अपनी चाबी और मूल्यों के लिए तार जैसी चीजों का उपयोग कर सकते हैं? myArray ['Book'] ['item1']?
— डिएगो
42
@Diego, हाँ, लेकिन ऐसा नहीं है जो सरणियों के लिए अभिप्रेत है। किसी वस्तु का उपयोग करने के लिए बेहतर है जब आपकी चाबियाँ तार हों।
— मैथ्यू क्रूले
10
मुझे यह उदाहरण स्वीकार किए गए उत्तर से बेहतर लगता है क्योंकि यह गतिशील रूप से आकार सरणियों के लिए लागू किया जा सकता है, जैसे new Array(size)कि sizeएक चर कहां है।
— वारीडिज्म
1
काम नहीं करता - असाइनमेंट पर त्रुटि। यदि यह बेकार है तो इस उत्तर को 280 लाइक कैसे मिले?
— 18
1
यह काम कर रहा है, धन्यवाद। आप उदाहरण देख सकते हैं गार्गो jsfiddle.net/matasoy/oetw73sj
— Matasoy
198

एक्टिवा के जवाब के समान, यहां एक एन-आयामी सरणी बनाने का एक कार्य है:

function createArray(length) {
    var arr = new Array(length || 0),
        i = length;

    if (arguments.length > 1) {
        var args = Array.prototype.slice.call(arguments, 1);
        while(i--) arr[length-1 - i] = createArray.apply(this, args);
    }

    return arr;
}

createArray();     // [] or new Array()

createArray(2);    // new Array(2)

createArray(3, 2); // [new Array(2),
                   //  new Array(2),
                   //  new Array(2)]
— मैथ्यू Crumley
स्रोत
2
क्या यह 4 आयामी सरणी बना सकता है?
— trusktr
4
@trusktr: हाँ, आप जितने चाहें उतने आयाम बना सकते हैं (अपनी स्मृति बाधाओं के भीतर)। बस चार आयामों की लंबाई में गुजरती हैं। उदाहरण के लिए, var array = createArray(2, 3, 4, 5);।
— मैथ्यू क्रुमले
4
सबसे बढ़िया उत्तर ! हालांकि, मैं इसे 0 या 1 मापदंडों (बेकार) के साथ उपयोग करने की सिफारिश नहीं करूंगा
— अपोलो
2
@BritishDeveloper हाँ। यह एक 5D सरणी है जिसकी प्रत्येक लंबाई 5:[[[[[null,null],[null,null]],[[null,null],[null,null]]],[[[null,null],[null,null]],[[null,null],[null,null]]]],[[[[null,null],[null,null]],[[null,null],[null,null]]],[[[null,null],[null,null]],[[null,null],[null,null]]]]]
— हैकम
2
@haykam अपना समय बर्बाद करने के लिए क्षमा करें - मैं व्यंग्य कर रहा था: /
— BritishDeveloper
84

जावास्क्रिप्ट में केवल 1-आयामी सरणियाँ हैं, लेकिन आप सरणियों के सरणियों का निर्माण कर सकते हैं, जैसा कि अन्य ने बताया है।

निम्नलिखित फ़ंक्शन का उपयोग निश्चित आयामों के 2-डी सरणी के निर्माण के लिए किया जा सकता है:

function Create2DArray(rows) {
  var arr = [];

  for (var i=0;i<rows;i++) {
     arr[i] = [];
  }

  return arr;
}

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

तब आप बस कॉल कर सकते हैं:

var arr = Create2DArray(100);

arr[50][2] = 5;
arr[70][5] = 7454;
// ...
— फिलिप लेबेर्ट
स्रोत
मैं एक 2-मंद सरणी बनाना चाहता हूं जो कार्ड के डेक का प्रतिनिधित्व करेगा। जो एक 2-मंद सरणी होगी जो कार्ड मूल्य और उसके बाद सूट में रखती है। ऐसा करने का सबसे आसान तरीका क्या होगा।
— डग हैफ
1
फ़ंक्शन Create2DArray (पंक्तियाँ) {var arrest = []; के लिए (var i = 0; मैं <पंक्तियों; i ++) {arr [i] = []; } रिटर्न अरेस्ट; } फ़ंक्शन प्रिंट (डेक) {के लिए (टी = 1; टी <= 4; टी ++) {के लिए (i = 1 = <= 13; i ++) {document.writeln (डेक [टी] [i]); }}} fucntion fillDeck (d) {के लिए (t = 1; t <= 4; t ++) {myCardDeck [t] [1] = t; for (i = 1; i <= 13; i ++) {myCardDeck [t] [i] = i; }}} function loadCardDeck () {var myCardDeck = Create2DArray (13); fillDeck (myCardDeck); प्रिंट (myCardDeck); }
— डग हफ
2
@ डौग: आप वास्तव में 2 विशेषताओं वाली वस्तुओं का एक आयामी आयाम चाहते हैं। var डेक = []; डेक [0] = {चेहरा: 1, सूट: 'एच'};
— TeasingDart
@DougHauf कि एक छोटा 2D सरणी है ?? : P: D
— माही
78

सबसे आसान तरीका:

var myArray = [[]];
— फ्रेड
स्रोत
29
जो एक 2-आयाम सरणी है
— मॉरीज़ियो इन डिमार्कमार्क
15
हाँ, इससे सावधान। MyArray को असाइन करना [0] [जो भी] ठीक है, लेकिन myArray [1] [जो कुछ भी] सेट और सेट करें और यह शिकायत करता है कि myArray [1] अपरिभाषित है।
— फिलिप
22
@Philip आपको myArray[1]=[];असाइन करने से पहले सेट करना होगाmyArray[1][0]=5;
— 182764125216
4
ज्ञात हो, यह @AndersonGreen ने लिखा है कि "एक खाली 1x1 सरणी नहीं बनाएं"। यह एक "1x0" सरणी बनाता है (यानी 0 कॉलम के साथ एक सरणी वाली 1 पंक्ति)। myArray.length == 1और myArray[0].length == 0। जो तब गलत परिणाम देता है यदि आप तब "वास्तव में खाली" "0x0" सरणी की प्रतिलिपि बनाते हैं।
— जॉनब्रवे
3
@ 182764125216 मेरे लिए दिन का ज्ञान था । धन्यवाद :)
— th3pirat3
76

खाली दो आयामी सरणी (एक-पंक्ति) कैसे बनाएं

Array.from(Array(2), () => new Array(4))

2 और 4 क्रमशः पहले और दूसरे आयाम हैं।

हम उपयोग कर रहे हैं Array.from, जो प्रत्येक तत्व के लिए एक सरणी-जैसे परम और एक वैकल्पिक मानचित्रण ले सकता है।

Array.from (arrayLike [, mapFn [, thisArg]])

var arr = Array.from(Array(2), () => new Array(4));
arr[0][0] = 'foo';
console.info(arr);
स्निपेट का विस्तार करें

एक ही ट्रिक का उपयोग जावास्क्रिप्ट सरणी बनाने के लिए किया जा सकता है जिसमें 1 ... N है

वैकल्पिक रूप से (लेकिन अधिक अक्षम 12% n = 10,000)

Array(2).fill(null).map(() => Array(4))

प्रदर्शन में कमी इस तथ्य के साथ आती है कि हमें पहले आयाम मानों को चलाने के लिए आरंभीकृत करना होगा .map। याद रखें कि Arrayआप पदों को तब तक आवंटित नहीं करेंगे जब तक आप इसे .fillमूल्य या प्रत्यक्ष असाइनमेंट के लिए आदेश नहीं देते हैं ।

var arr = Array(2).fill(null).map(() => Array(4));
arr[0][0] = 'foo';
console.info(arr);
स्निपेट का विस्तार करें

ऊपर का पालन करें

यहां एक विधि है जो सही प्रतीत होती है, लेकिन इसमें समस्याएं हैं ।

 Array(2).fill(Array(4)); // BAD! Rows are copied by reference

हालांकि यह स्पष्ट रूप से वांछित दो आयामी सरणी ( [ [ <4 empty items> ], [ <4 empty items> ] ]) लौटाता है , वहाँ एक पकड़ है: पहले आयाम सरणियों को संदर्भ द्वारा कॉपी किया गया है। इसका मतलब है arr[0][0] = 'foo'कि वास्तव में एक के बजाय दो पंक्तियों को बदल देगा।

var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo';
console.info(arr);
console.info(arr[0][0], arr[1][0]);
स्निपेट का विस्तार करें

— zurfyx
स्रोत
मेरा यह सुझाव है:Array.from({length:5}, () => [])
— vsync
यहां विषय लेकिन यह उत्तर (इसके भीतर पहला और दूसरा) रसीला, तेज और आधुनिक का सबसे अच्छा संतुलन की तरह लगता है।
— ब्रैडी डॉवलिंग
@zurfyx किसी भी विचार, या किसी को भी पता है, क्यों webstorm इस बारे में शिकायत कर रहा है? ऐसा लगता है कि अरेंजमेंट अपरिभाषित के रूप में मूल्यों को छोड़ता रहता है और फिर मैं बनाए गए सरणी के साथ काम नहीं कर सकता, हालांकि स्निपेट
— स्टैकओवरफ्लो
46

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

तो, यह परस्पर विरोधी दृष्टिकोण का कारण है।

— जेम्स कॉनिग्लिआरो
स्रोत
41
नहीं यह नहीं। कुछ भाषाओं में, आपके पास बहुआयामी सरणियाँ हो सकती हैं जैसे string[3,5] = "foo";। यह कुछ परिदृश्यों के लिए एक बेहतर दृष्टिकोण है, क्योंकि वाई अक्ष वास्तव में एक्स अक्ष का बच्चा नहीं है।
— राफेल शाम
3
एक बार जब यह अंतर्निहित मशीन कोड के लिए हो जाता है, तो आयाम के सभी दसियों> 1 सरणियों के एरे होते हैं, जिस भी भाषा के बारे में हम बात कर रहे हैं। कैश ऑप्टिमाइज़ेशन के कारणों को ध्यान में रखते हुए यह सार्थक है। संख्यात्मक कंप्यूटिंग के लिए गंभीरता से पूरा करने वाली कोई भी सभ्य भाषा आपको स्मृति में अपनी बहुआयामी संरचना को संरेखित करने की अनुमति देगी जैसे कि आपके सबसे अधिक उपयोग किए जाने वाले आयाम को संचित रूप से संग्रहीत किया जाता है। पायथन के नम्पी, फोरट्रान, और सी, दिमाग में आते हैं। वास्तव में ऐसे मामले हैं जब इस कारण से कई संरचनाओं में आयामीता कम करना सार्थक है।
— थॉमस ब्राउन ने
कंप्यूटर में आयामों की कोई धारणा नहीं है। केवल 1 आयाम है, मेमोरी एड्रेस। प्रोग्रामर के लाभ के लिए बाकी सब कुछ उल्लेखनीय सजावट है।
— TeasingDart
3
@ThomasBrowne बिल्कुल नहीं। "सरणियों के सरणियों" को आंतरिक सरणियों के आकार के लिए कुछ भंडारण की आवश्यकता होती है (वे भिन्न हो सकते हैं) और एक अन्य सूचक डेरेफेरिंग को उस स्थान को खोजने के लिए जहां एक आंतरिक सरणी संग्रहीत है। किसी भी "सभ्य" भाषा में बहु-विषयक सरणियाँ दांतेदार सरणियों से भिन्न होती हैं, क्योंकि वे प्रति से भिन्न डेटा संरचनाएँ होती हैं। (और भ्रामक हिस्सा यह है कि C सरणियाँ
— बहुपद
33

कुछ लोग धक्का का उपयोग दिखाते हैं:
कुछ नया लाने के लिए, मैं आपको दिखाऊंगा कि कुछ मूल्य के साथ मैट्रिक्स को कैसे शुरू किया जाए, उदाहरण: 0 या एक खाली स्ट्रिंग ""।
यह याद दिलाते हुए कि यदि आपके पास 10 तत्वों की सरणी है, तो जावास्क्रिप्ट में अंतिम सूचकांक 9 होगा!

function matrix( rows, cols, defaultValue){

  var arr = [];

  // Creates all lines:
  for(var i=0; i < rows; i++){

      // Creates an empty line
      arr.push([]);

      // Adds cols to the empty line:
      arr[i].push( new Array(cols));

      for(var j=0; j < cols; j++){
        // Initializes:
        arr[i][j] = defaultValue;
      }
  }

return arr;
}

उपयोग के उदाहरण: 

x = matrix( 2 , 3,''); // 2 lines, 3 cols filled with empty string
y = matrix( 10, 5, 0);// 10 lines, 5 cols filled with 0
— सर्जियो अब्रेउ
स्रोत
मैं forआपकी प्रक्रिया से अंतिम (जो डिफ़ॉल्ट मान सेट करता हूं) निकालता हूं और लिखता हूं m=matrix(3,4); m[1][2]=2; console.log(JSON.stringify(m));- और हम बहुत स्ट्रैज मैट्रिक्स (बहुत ज्यादा नेस्टेड) ​​प्राप्त करते हैं - आप इसे अंतिम फॉर- डिफॉल्ट वेल्यू स्टेप में रिपेयर करते हैं, लेकिन मुझे लगता है कि आप इससे पहले कम नेस्ट्रा का उपयोग करने के लिए प्रक्रिया को फिर से लिख सकते हैं। डिफ़ॉल्ट मान सेट करना।
— कामिल Kiełczewski
27

दो लाइनर:

var a = []; 
while(a.push([]) < 10);

यह सरणियों से भरा, लंबाई 10 की एक सरणी उत्पन्न करेगा। (पुश एक तत्व को एक सरणी में जोड़ता है और नई लंबाई देता है)

— domenukk
स्रोत
13
वन-लाइनर for (var a=[]; a.push([])<10;);:?
— बरगी
@ बर्गी एक वैरिएबल अभी भी अगली पंक्ति में परिभाषित किया जाएगा ..?
— स्टिंकटैट
1
@StinkyCat: हाँ, यह कैसे varकाम करता है। यह हमेशा फ़ंक्शन-स्कोप किया जाता है।
— बेर्गी
मुझे पता है, इसलिए इस मामले में आपका एक-लाइनर बेकार है: आप "अपने सदस्यों तक पहुंच नहीं सकते हैं" (जांच प्रश्न)
— StinkyCat
1
domenukk और @ बर्गी, तुम दोनों सही हो। मैंने इसे आज़माया और मैं इसके लिए एक के बाद एक एक्सेस कर सकता हूं। मैं क्षमाप्रार्थी हूं! और धन्यवाद, यह मेरे लिए एक सबक हो सकता है;)
— स्टिंकटैट
24

पुण्य उत्तर लगता है

var nrows = ~~(Math.random() * 10);
var ncols = ~~(Math.random() * 10);
console.log(`rows:${nrows}`);
console.log(`cols:${ncols}`);
var matrix = new Array(nrows).fill(0).map(row => new Array(ncols).fill(0));
console.log(matrix);
स्निपेट का विस्तार करें

ध्यान दें कि हम नहीं कर सकते सीधे के बाद से भरने का उपयोग करता है उथले प्रतिलिपि निर्माता पंक्तियों के साथ भरने, इसलिए सभी पंक्तियों का हिस्सा होगा एक ही स्मृति ... यहाँ उदाहरण जो दर्शाता है कि कैसे प्रत्येक पंक्ति साझा किया जाएगा (अन्य उत्तर से लिया गया):

// DON'T do this: each row in arr, is shared
var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo'; // also modifies arr[1][0]
console.info(arr);
— फ्रांसेस्को डोंडी
स्रोत
यह सबसे ऊपर होना चाहिए। मैंने कुछ इसी तरह का प्रयोग किया है Array.apply(null, Array(nrows))लेकिन यह बहुत अधिक सुरुचिपूर्ण है।
— डिमिग्युएल
इस संबंध में मेरी आखिरी टिप्पणी ... इंटरनेट एक्सप्लोरर और ओपेरा के लिए समर्थन नहीं है fill। यह अधिकांश ब्राउज़रों पर काम नहीं करेगा।
— डाइमिगेल
@ मिगल फिल को इस उदाहरण में एक निरंतर मानचित्र के साथ अनुकरण किया जा सकता है: Array(nrows).map(() => 0)या,Array(nrows).map(function(){ return 0; });
— कॉनर ओ'ब्रायन
20

सबसे आसान तरीका:

var arr  = [];

var arr1 = ['00','01'];
var arr2 = ['10','11'];
var arr3 = ['20','21'];

arr.push(arr1);
arr.push(arr2);
arr.push(arr3);

alert(arr[0][1]); // '01'
alert(arr[1][1]); // '11'
alert(arr[2][0]); // '20'
— Chicharito
स्रोत
18

यह वही है जो मैंने हासिल किया:

var appVar = [[]];
appVar[0][4] = "bineesh";
appVar[0][5] = "kumar";
console.log(appVar[0][4] + appVar[0][5]);
console.log(appVar);
स्निपेट का विस्तार करें

इसने मुझे बिनेशकुमार बना दिया

— Bineesh
स्रोत
2
ध्यान दें कि आप केवल पेरेंट सरणी के 0 इंडेक्स तक कैसे पहुंच सकते हैं। यह कुछ उपयोगी नहीं है, जो आपको सेट करने की अनुमति देता है, उदाहरण के लिए, appVar [5] [९] = १०; ... आपको इसके साथ 'अपरिभाषित' की संपत्ति "9" सेट करने में असमर्थ मिलेगा।
— किशीनब्रेनचंच
लेकिन appVar[1][4] = "bineesh";गलत है, इसे कैसे हल किया जाए?
— गैंक
16

दो आयामी सरणियों को उसी तरह बनाया जाता है जैसे एकल आयामी सरणियाँ होती हैं। और आप उन्हें पसंद करते हैं array[0][1]।

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

alert (arr[2][1]); //alerts "4"
— टीजे एल
स्रोत
14

मुझे यकीन नहीं है कि किसी ने भी इसका जवाब दिया है, लेकिन मैंने पाया कि यह मेरे लिए बहुत अच्छा है - 

var array = [[,],[,]]

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

var a = [[1,2],[3,4]]

उदाहरण के लिए, 2 आयामी सरणी के लिए।

— उचेन्ना
स्रोत
मैं इसे गतिशील रूप से कैसे कर सकता हूं? मुझे विभिन्न आकारों के साथ आंतरिक सरणियाँ चाहिए।
— अलाप
3
आपको अतिरिक्त अल्पविराम की आवश्यकता नहीं var array = [[],[]]है।
— काया टोस्ट
13

JavaScript में 2D सरणी बनाने के लिए हम पहले एक Array बना सकते हैं और फिर Arrays जोड़ सकते हैं क्योंकि यह एलिमेंट्स है। यह विधि दी गई संख्या पंक्तियों और स्तंभों के साथ एक 2D सरणी लौटाएगी। 

function Create2DArray(rows,columns) {
   var x = new Array(rows);
   for (var i = 0; i < rows; i++) {
       x[i] = new Array(columns);
   }
   return x;
}

Array बनाने के लिए नीचे इस विधि का उपयोग करें।

var array = Create2DArray(10,20);
— प्रधान
स्रोत
2
आप अपने ansdwer में कुछ व्याख्यात्मक जानकारी जोड़ेंगे, यह दिखाएगा कि यह कैसे काम करता है, और यह समस्या का हल क्यों करता है। यह उन लोगों की मदद करेगा जो भविष्य में इस पृष्ठ को
— हमारा आदमी केले में
आपको एक ऐसे ऐरे की आवश्यकता कब होगी जो जावास्क्रिप्ट में कुछ निश्चित संख्या में कोलम के साथ पहले से ही बना हुआ है? आप एक [] सरणी के n- वें तत्व को भी एक्सेस कर सकते हैं।
— domenukk
मैंने देखा कि फ़ंक्शन कैपिटल सी के साथ शुरू होता है, जो (कुछ सम्मेलनों द्वारा) यह सुझाव देता है कि यह एक फंक्शन कंस्ट्रक्टर होगा और आप इसे नए कीवर्ड के साथ उपयोग करेंगे। एक बहुत ही मामूली और कुछ हद तक माना जाता है, लेकिन मैं अभी भी अन-कैपिटलाइज्ड शब्द का सुझाव दूंगा।
— हचि
12

गैर-विरल "2 डी" सरणी (x, y) बनाने के लिए सभी सूचकांकों के साथ पता लगाने योग्य और मान शून्य करने के लिए सेट करें:

let 2Darray = new Array(x).fill(null).map(item =>(new Array(y).fill(null)))

बोनस "3 डी" ऐरे (x, y, z)

let 3Darray = new Array(x).fill(null).map(item=>(new Array(y).fill(null)).map(item=>Array(z).fill(null)))

इस सवाल के जवाब में टिप्पणियों और विभिन्न बिंदुओं पर इस पर बदलाव और सुधार का उल्लेख किया गया है, लेकिन वास्तविक जवाब के रूप में नहीं इसलिए मैं इसे यहां जोड़ रहा हूं।

यह ध्यान दिया जाना चाहिए कि (अधिकांश अन्य उत्तरों के समान) इसमें O (x * y) समय की जटिलता है, इसलिए यह संभवतया बहुत अच्छे सरणियों के लिए उपयुक्त नहीं है।

— जस्टिन ओहम्स
स्रोत
1
सावधान रहें क्योंकि fillसमान मूल्य निर्धारित करें। अगर null`ऑब्जेक्ट में परिवर्तन होता है, तो यह हर कॉलम में एक ही ऑब्जेक्ट होगा
— स्टैनिस्लाव मेयोरोव
@StanislavMayorov यदि आप प्रत्येक सेल का मान निर्धारित करना चाहते हैं, तो बस उसी ट्रिक का उपयोग करें:let 2Darray = new Array(x).fill(null).map(item =>(new Array(y).fill(null).map(cell =>(yourValueHere))))
— haykam
10

ऐरे कॉम्प्रिहेंशन का उपयोग करें

जावास्क्रिप्ट 1.7 और उच्चतर में आप दो आयामी सरणियों बनाने के लिए सरणी समझ का उपयोग कर सकते हैं । आप सरणी भरने के दौरान प्रविष्टियों को फ़िल्टर और / या हेरफेर भी कर सकते हैं और लूप का उपयोग नहीं करना है।

var rows = [1, 2, 3];
var cols = ["a", "b", "c", "d"];

var grid = [ for (r of rows) [ for (c of cols) r+c ] ];

/* 
         grid = [
            ["1a","1b","1c","1d"],
            ["2a","2b","2c","2d"],
            ["3a","3b","3c","3d"]
         ]
*/

आप अपनी n x mइच्छानुसार कोई भी सरणी बना सकते हैं और उसे कॉल करके डिफ़ॉल्ट मान से भर सकते हैं

var default = 0;  // your 2d array will be filled with this value
var n_dim = 2;
var m_dim = 7; 

var arr = [ for (n of Array(n_dim)) [ for (m of Array(m_dim) default ]] 
/* 
         arr = [
            [0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0],
         ]
*/

अधिक उदाहरण और दस्तावेज यहां देखे जा सकते हैं ।

कृपया ध्यान दें कि यह एक मानक विशेषता नहीं है ।

— टिम हैलिबर्टन
स्रोत
एक त्वरित गूगल की जाँच यहाँ ... हाँ ... forबयान अभी भी एक पाश है ...
— Pimp Trizkit
1
यह किसी भी ब्राउज़र द्वारा समर्थित नहीं है - यहाँ ?
— कामिल Kiełczewski
10

एक लाइनर प्रेमियों के लिए Array.from ()

// creates 8x8 array filed with "0"    
const arr2d = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => "0"))

एक और एक (dmitry_romanov द्वारा टिप्पणी से) ऐरे का उपयोग करें ()। भरें ()

// creates 8x8 array filed with "0"    
const arr2d = Array(8).fill(0).map(() => Array(8).fill("0"))

ES6 + प्रसार ऑपरेटर ("InspiredJW जवाब :) द्वारा प्रेरित" ) का उपयोग करना

// same as above just a little shorter
const arr2d = [...Array(8)].map(() => Array(8).fill("0"))
— मेरे-
स्रोत
2
हम 0पहले fill()समारोह में निकाल सकते हैं :const arr2d = Array(8).fill().map(() => Array(8).fill("0"));
— ली
8

मेरा दृष्टिकोण @Bineesh उत्तर के समान है, लेकिन अधिक सामान्य दृष्टिकोण के साथ।

आप निम्न प्रकार से डबल एरे की घोषणा कर सकते हैं:

var myDoubleArray = [[]];

और निम्नलिखित तरीके से सामग्री को संग्रहीत करना और उस तक पहुंच बनाना:

var testArray1 = [9,8]
var testArray2 = [3,5,7,9,10]
var testArray3 = {"test":123}
var index = 0;

myDoubleArray[index++] = testArray1;
myDoubleArray[index++] = testArray2;
myDoubleArray[index++] = testArray3;

console.log(myDoubleArray[0],myDoubleArray[1][3], myDoubleArray[2]['test'],)

यह अपेक्षित आउटपुट प्रिंट करेगा

[ 9, 8 ] 9 123
— सिकंदर
स्रोत
7

मैंने पाया कि सबसे सरल तरीका है:

var array1 = [[]];   
array1[0][100] = 5; 

alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);
— GMsoF
स्रोत
array1[1][100] = 666;फेंकताUncaught TypeError: Cannot set property '100' of undefined
— कामिल कियॉलेजवेस्की
@ KamilKiełczewski आप सही हैं, ऐसा लगता है कि यह केवल पहले सरणी के लिए आरंभ करता है array1[1][100] = 666;, दूसरे के लिए, इससे पहले कि आपको ऐसा करने की आवश्यकता हो array1[1] = [];।
— GMsoF
7

प्रदर्शन

आज 2020.02.05 मैं चुने हुए समाधानों के लिए Chrome v79.0, Safari v13.0.4 और Firefox v72.0 पर MacOs HighSierra 10.13.6 पर परीक्षण करता हूं।

गैर-आरंभिक 2 डी सरणी के लिए निष्कर्ष

  • गूढ़ समाधान {}/arr[[i,j]](N) बड़ी और छोटी सरणियों के लिए सबसे तेज़ है और ऐसा लगता है कि यह बड़े विरल सरणियों के लिए अच्छा विकल्प है
  • for-[]/while(ए, जी) पर आधारित समाधान तेज हैं और वे छोटे सरणियों के लिए अच्छे विकल्प हैं।
  • समाधान for-[](B, C) तेज़ हैं और वे बड़े सरणियों के लिए अच्छे विकल्प हैं
  • Array..map/from/fill(I, J, K, L, M) पर आधारित समाधान छोटे सरणियों के लिए काफी धीमा है, और बड़ी सरणियों के लिए काफी तेज है
  • आश्चर्य की बात है for-Array(n)(बी, सी) सफारी for-[](ए) की तुलना में बहुत धीमी है
  • for-[]बड़े ब्राउज़रों के लिए आश्चर्यजनक रूप से (ए) सभी ब्राउज़रों पर धीमा है
  • समाधान K सभी ब्राउज़रों के लिए छोटे सरणियों के लिए धीमा है
  • समाधान A, E, G सभी ब्राउज़रों के लिए बड़े सरणियों के लिए धीमा है
  • समाधान एम सभी ब्राउज़रों पर सभी सरणियों के लिए सबसे धीमा है

यहां छवि विवरण दर्ज करें

प्रारंभिक 2d सरणी के लिए निष्कर्ष

  • for/whileसभी ब्राउज़रों पर छोटे सरणियों के लिए (ए, बी, सी, डी, ई, जी) पर आधारित समाधान सबसे तेज़ / काफी तेज़ हैं
  • forसभी ब्राउज़रों पर बड़े सरणियों के लिए (ए, बी, सी, ई) पर आधारित समाधान सबसे तेज़ / काफी तेज़ हैं
  • Array..map/from/fillसभी ब्राउज़रों पर छोटे सरणियों के लिए (I, J, K, L, M) पर आधारित समाधान मध्यम तेज़ या धीमे हैं
  • समाधान एफ, जी, एच, आई, जे, के, एल बड़े सरणियों के लिए क्रोम या सफारी पर मध्यम या तेज हैं, लेकिन फ़ायरफ़ॉक्स पर सबसे धीमा।
  • गूढ़ समाधान {}/arr[[i,j]](एन) सभी ब्राउज़रों पर छोटे और बड़े सरणियों के लिए सबसे धीमा है

यहां छवि विवरण दर्ज करें

विवरण

उन समाधानों के लिए परीक्षण करें जो आउटपुट सरणी (प्रारंभिक) नहीं भरते हैं

हम समाधान की गति का परीक्षण करते हैं

  • छोटे सरणियों (12 तत्वों) - आप अपने मशीन पर परीक्षण प्रदर्शन कर सकते हैं यहाँ
  • बड़ा सरणियों (1 मिलियन तत्वों) सरणियों - आप अपने मशीन पर परीक्षण प्रदर्शन कर सकते हैं यहाँ

कोड स्निपेट दिखाएं

उन समाधानों के लिए परीक्षण करें जो आउटपुट सरणी को भरते हैं (आरंभ करते हैं)

हम समाधान की गति का परीक्षण करते हैं

  • छोटे सरणियों (12 तत्वों) - आप अपने मशीन पर परीक्षण प्रदर्शन कर सकते हैं यहाँ
  • बड़ा सरणियों (1 मिलियन तत्वों) सरणियों - आप अपने मशीन पर परीक्षण प्रदर्शन कर सकते हैं यहाँ

कोड स्निपेट दिखाएं

यहां छवि विवरण दर्ज करें

— कामिल कियॉलेजवस्की
स्रोत
6

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

कोड उदाहरण:

/* Two dimensional array that's 5 x 5 

       C0 C1 C2 C3 C4 
    R0[1][1][1][1][1] 
    R1[1][1][1][1][1] 
    R2[1][1][1][1][1] 
    R3[1][1][1][1][1] 
    R4[1][1][1][1][1] 
*/

var row0 = [1,1,1,1,1],
    row1 = [1,1,1,1,1],
    row2 = [1,1,1,1,1],
    row3 = [1,1,1,1,1],
    row4 = [1,1,1,1,1];

var table = [row0,row1,row2,row3,row4];
console.log(table[0][0]); // Get the first item in the array
— पोरौटी
स्रोत
6 

var playList = [
  ['I Did It My Way', 'Frank Sinatra'],
  ['Respect', 'Aretha Franklin'],
  ['Imagine', 'John Lennon'],
  ['Born to Run', 'Bruce Springsteen'],
  ['Louie Louie', 'The Kingsmen'],
  ['Maybellene', 'Chuck Berry']
];

function print(message) {
  document.write(message);
}

function printSongs( songs ) {
  var listHTML;
  listHTML = '<ol>';
  for ( var i = 0; i < songs.length; i += 1) {
    listHTML += '<li>' + songs[i][0] + ' by ' + songs[i][1] + '</li>';
  }
  listHTML += '</ol>';
  print(listHTML);
}

printSongs(playList);
स्निपेट का विस्तार करें

— antelove
स्रोत
6

ES6 +, ES2015 + इसे और भी सरल तरीके से कर सकते हैं

3 x 2 ऐरे बनाना सच से भरा है

[...Array(3)].map(item => Array(2).fill(true))
— jwchang
स्रोत
मुझे कबूल करने की जरूरत है। मैंने आपके उत्तर को "अपनाया" और मेरा , वन-लाइनर्स संग्रह में जोड़ा ।
— my-
5

मुझे इसकी आवश्यकता के अनुसार "रिकॉर्ड" जोड़ने के लिए एक लचीला सरणी फ़ंक्शन करना था और उन्हें आगे की प्रक्रिया के लिए डेटाबेस में भेजने से पहले मुझे उन्हें अपडेट करने में सक्षम होने के लिए और जो भी गणनाएं करने की आवश्यकता थी, उन्हें करने में सक्षम होना चाहिए। यहाँ कोड है, आशा है कि यह मदद करता है :)।

function Add2List(clmn1, clmn2, clmn3) {
    aColumns.push(clmn1,clmn2,clmn3); // Creates array with "record"
    aLine.splice(aPos, 0,aColumns);  // Inserts new "record" at position aPos in main array
    aColumns = [];    // Resets temporary array
    aPos++ // Increments position not to overlap previous "records"
}

किसी भी कीड़े को अनुकूलित करने और / या इंगित करने के लिए स्वतंत्र महसूस करें :)

— सीजे मेंडेस
स्रोत
कैसे बस के बारे में aLine.push([clmn1, clmn2, clmn3]);?
— पिंप ट्राइज़किट
5

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

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(e => Array(y));
}

आप इस फ़ंक्शन को ES5 फ़ंक्शन में भी आसानी से बदल सकते हैं।

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(function(e) {
        return Array(y);
    });
}

यह क्यों काम करता है: new Array(n)निर्माणकर्ता एक प्रोटोटाइप के साथ एक ऑब्जेक्ट बनाता है Array.prototypeऔर फिर ऑब्जेक्ट को असाइन करता है length, जिसके परिणामस्वरूप एक अनपेक्षित सारणी होती है। वास्तविक सदस्यों की कमी के कारण हम इस Array.prototype.mapपर कार्य नहीं कर सकते हैं ।

हालाँकि, जब आप कंस्ट्रक्टर को एक से अधिक तर्क प्रदान करते हैं, जैसे कि जब आप करते हैं Array(1, 2, 3, 4), तो कंस्ट्रक्टर argumentsऑब्जेक्ट को तुरंत Arrayसही करने और पॉप्युलेट करने के लिए ऑब्जेक्ट का उपयोग करेगा ।

इस कारण से, हम उपयोग कर सकते हैं Array.apply(null, Array(x)), क्योंकि applyफ़ंक्शन कंस्ट्रक्टर में तर्कों को फैलाएगा। स्पष्टीकरण के लिए, करना करने Array.apply(null, Array(3))के बराबर है Array(null, null, null)।

अब जब हमने एक वास्तविक आबादी वाला सरणी बनाया है, तो हमें केवल कॉल करना होगा mapऔर दूसरी परत ( y) बनानी होगी ।

— dimiguel
स्रोत
5

एक के नीचे, एक 5x5 मैट्रिक्स बनाता है और उन्हें भरता है null

var md = [];
for(var i=0; i<5; i++) {
    md.push(new Array(5).fill(null));
}

console.log(md);
स्निपेट का विस्तार करें

— zeah
स्रोत
3
यह उत्तर गलत है। यह अपने स्लॉट्स में एक ही एरे को भरने के साथ एक अरै बना देगा। md[1][0] = 3 और बाकी सभी तत्व भी अपडेट किए गए हैं
— Qiang
5

एक सरणी के पंक्ति और स्तंभ आकार जिन्हें केवल रन टाइम में जाना जाता है, तब डायनामिक 2 डी सरणी बनाने के लिए निम्न विधि का उपयोग किया जा सकता है ।

var num = '123456';
var row = 3; // Known at run time
var col = 2; // Known at run time
var i = 0;

var array2D = [[]];
for(var r = 0; r < row; ++r)
{
    array2D[r] = [];
    for(var c = 0; c < col; ++c)
    {
        array2D[r][c] = num[i++];
    }
}
console.log(array2D); 
// [[ '1', '2' ], 
//  [ '3', '4' ], 
//  [ '5', '6' ]]

console.log(array2D[2][1]); // 6
— SridharKritha
स्रोत
4

एक और समाधान है, जो आपको 2d सरणी के आकार को पूर्व-परिभाषित करने के लिए मजबूर नहीं करता है, और यह बहुत संक्षिप्त है।

var table = {}
table[[1,2]] = 3 // Notice the double [[ and ]]
console.log(table[[1,2]]) // -> 3
स्निपेट का विस्तार करें

यह काम करता है क्योंकि, [1,2]एक स्ट्रिंग में तब्दील हो जाता है, जिसका उपयोग ऑब्जेक्ट के लिए स्ट्रिंग कुंजी के रूप में किया जाता है table।

— ओली
स्रोत
यह उत्तर अकेले मुझे कबाड़ के साथ गड़बड़ नहीं करना चाहता है जो जावास्क्रिप्ट में "बहुआयामी" सरणियाँ हैं, यहां तक ​​कि मेरे पास एक बहुत ही सुंदर समाधान है। यह भी दिखाता है कि हर कोई वास्तव में बहुआयामी सरणियों को नहीं बना रहा है। जैसे कि जावास्क्रिप्ट में एक "सरणी"; यह उत्तर पूरी तरह से एक छद्म-अनंत आकार, मनमाना आकार और सामग्री के अनंत आयाम सरणी को "अनुकरण" करेगा। अन्य पुनरावृत्ति और लूप आधारित उत्तरों से उनके द्वारा बनाई जा सकने वाली सरणी संरचना के आकार की बहुत कम ऊपरी सीमा होती है। इन बड़े संरचनाओं के लिए गति एक प्रमुख मुद्दा होगा।
— पिंप ट्राइज़किट
प्री-फिलिंग को अनुकरण करने के बजाय इस लाइन का उपयोग करें:var table = new Proxy({}, {get:(t,n)=>n in t ? t[n] : 42});
— पिंप ट्राइज़किट
वस्तु द्वारा Array2D :) का अनुकरण करने का अच्छा, रचनात्मक तरीका :)
— कामिल कीलवेकस्की
4

4x6 सरणी बनाने के लिए, बस यह करें

const x = [...Array(6)].map(elem => new Array(4))
— अतिथि
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.