javascript - معلم - مميزات الجافا سكريبت




كيف يمكنني إنشاء صفيف ثنائي الأبعاد في JavaScript؟ (20)

لقد كنت أقرأ على الإنترنت وبعض الأماكن تقول أنه غير ممكن ، والبعض يقول أنه هو ثم أعطي مثالاً وآخرون يدحضون المثال ، إلخ.

  1. كيف أعلن صفيف الأبعاد في JavaScript؟ (على افتراض أنه من الممكن)

  2. كيف يمكنني الوصول إلى أعضائها؟ ( myArray[0][1] أو myArray[0,1] ؟)


كيفية إنشاء صفيف فارغ ثنائي الأبعاد (سطر واحد)

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

بينما يقوم بإرجاع الصفيف ثنائية الأبعاد المطلوبة على ما يبدو ( [ [ <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]);


استخدام الفهم صفيف

في JavaScript 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"]
         ]
*/

يمكنك إنشاء أي صفيف nxm تريده وتعبئته بقيمة افتراضية عن طريق الاتصال

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],
         ]
*/

مزيد من الأمثلة والوثائق يمكن العثور عليها here .

يرجى ملاحظة أن هذه ليست ميزة قياسية حتى الآن .


أسهل طريقة:

var myArray = [[]];

اضطررت إلى إنشاء وظيفة مصفوفة مرنة لإضافة "سجلات" إليها كما أحتاجها ولتمكني من تحديثها والقيام بأي الحسابات اللازمة قبل إرسالها إلى قاعدة بيانات لمزيد من المعالجة. هنا هو رمز ، آمل أن يساعد :).

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"
}

لا تتردد في تحسين و / أو نشير إلى أي أخطاء :)


بطانة واحدة لإنشاء مجموعة am * n 2 مملوءة بصفر.

new Array(m).fill(new Array(n).fill(0));

تحتوي Javascript على صفائف أحادية البعد فقط ، ولكن يمكنك إنشاء صفائف من المصفوفات ، كما أشار آخرون.

يمكن استخدام الوظيفة التالية لإنشاء صفيف ثنائي الأبعاد من الأبعاد الثابتة:

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;
// ...

عدد قليل من الناس يظهرون استخدام الدفع:
لتقديم شيء جديد ، سأوضح لك كيفية تهيئة المصفوفة ببعض القيمة ، مثال: 0 أو سلسلة فارغة "".
تذكير أنه إذا كان لديك صفيف عناصر 10 ، فسيكون الفهرس الأخير في javascript 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

على غرار إجابة Activa ، إليك وظيفة لإنشاء مصفوفة n-dimensional:

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

لا تدعم جافاسكريبت صفيفين ثنائي الأبعاد ، بدلاً من ذلك نقوم بتخزين مصفوفة داخل صفيف آخر ونقوم بإحضار البيانات من الصفيف بناءً على موضع هذا الصفيف الذي تريد الوصول إليه. تذكر أن تعداد الصفيف يبدأ من الصفر .

مثال الكود:

/* 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

لست متأكدا إذا كان أي شخص قد أجبت على هذا ولكنني وجدت أن هذا يعمل لي بشكل جيد -

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

على سبيل المثال:

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

لصفيف 2 الأبعاد ، على سبيل المثال.


لقد قمت بتعديل إجابة ماثيو كروملي لإنشاء وظيفة مصفوفة متعددة الأبعاد. لقد قمت بإضافة أبعاد الصفيف ليتم تمريره كمتغير صفيف وستكون هناك متغير آخر - value ، والذي سيتم استخدامه لتعيين قيم عناصر الصفائف الأخيرة في الصفيف متعدد الأبعاد.

/*
*   Function to create an n-dimensional array
*
*   @param array dimensions
*   @param any type value
*
*   @return array array
 */
function createArray(dimensions, value) {
    // Create new array
    var array = new Array(dimensions[0] || 0);
    var i = dimensions[0];

    // If dimensions array's length is bigger than 1
    // we start creating arrays in the array elements with recursions
    // to achieve multidimensional array
    if (dimensions.length > 1) {
        // Remove the first value from the array
        var args = Array.prototype.slice.call(dimensions, 1);
        // For each index in the created array create a new array with recursion
        while(i--) {
            array[dimensions[0]-1 - i] = createArray(args, value);
        }
    // If there is only one element left in the dimensions array
    // assign value to each of the new array's elements if value is set as param
    } else {
        if (typeof value !== 'undefined') {
            while(i--) {
                array[dimensions[0]-1 - i] = value;
            }
        }
    }

    return array;
}

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

createArray([2], 'empty');    // ['empty', 'empty']

createArray([3, 2], 0);       // [[0, 0],
                              //  [0, 0],
                              //  [0, 0]]

لقد وجدت أن هذا الرمز يعمل لي:

var map = [
    []
];

mapWidth = 50;
mapHeight = 50;
fillEmptyMap(map, mapWidth, mapHeight);

...

function fillEmptyMap(array, width, height) {
    for (var x = 0; x < width; x++) {
        array[x] = [];
        for (var y = 0; y < height; y++) {

            array[x][y] = [0];
        }
    }
}

مقاربتي مشابهة جدا لإجابة بنينش ولكن مع نهج أكثر عمومية.

يمكنك تعريف الصفيف المزدوج كما يلي:

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

هذا ما حققته:

var appVar = [[]];
appVar[0][4] = "bineesh";
appVar[0][5] = "kumar";
console.log(appVar[0][4] + appVar[0][5]);
console.log(appVar);

هذا توضيح لي bineeshkumar


وجدت أدناه هي أبسط طريقة:

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

alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);

يبدو أن الجواب الصحيح

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

لا يمكن ملء الصفوف مباشرة ، نظرًا لأن التعبئة تستخدم مُنشئ نسخة ضحلة ، لذلك ستشترك جميع الصفوف في نفس الذاكرة ...


يمكنك أيضًا إنشاء وظيفة لإنشاء مصفوفة ثنائية الأبعاد كما يلي:

var myTable = [];

function createArray(myLength) {
    myTable = new Array(myLength);
    var cols, rows;
    for (cols = 0; cols < myLength; cols++) {
        myTable[cols] = new Array(myLength);
    }
}

يمكنك الاتصال به عن طريق استخدام ما يلي ، والذي سيعطيك مصفوفة ثنائية الأبعاد 10x10.

createArray(10);

يمكنك أيضًا إنشاء مصفوفة ثلاثية الأبعاد باستخدام هذه الطريقة.


يمكنك ببساطة جعل كل عنصر داخل مجموعة صفيف.

var x = new Array(10);
for (var i = 0; i < 10; i++) {
  x[i] = new Array(20);
}
x[5][12] = 3.0;

يومين بطانة:

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

سيقوم بإنشاء صفيف من طول 10 ، مملوءة بالصفائف. (يقوم Push بإضافة عنصر إلى صفيف وإرجاع الطول الجديد)


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

ينشئ مصفوفة 5 × 5 وملئها null





multidimensional-array