我一直在网上阅读,一些地方说这是不可能的,一些地方说这是可能的,然后给出一个例子,另一些地方反驳这个例子,等等。
如何在JavaScript中声明一个2维数组?(假设这是可能的) 我如何访问它的成员?(myArray[0][1] or myArray[0,1]?)
我一直在网上阅读,一些地方说这是不可能的,一些地方说这是可能的,然后给出一个例子,另一些地方反驳这个例子,等等。
如何在JavaScript中声明一个2维数组?(假设这是可能的) 我如何访问它的成员?(myArray[0][1] or myArray[0,1]?)
当前回答
很少有人会使用“推”: 为了带来一些新的东西,我将向您展示如何用一些值初始化矩阵,例如: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
其他回答
我发现下面是最简单的方法:
Var array1 = [[]]; Array1 [0][100] = 5; alert (array1 [0] [100]); 警报(array1.length); alert (array1 [0] . length);
我不喜欢使用.fill()的ES6解决方案。有些可能可以工作,但为了避免引用复制问题而添加的额外箍使它们不直观。
我建议的ES6方法是对外部数组和内部数组充分利用展开运算符。在我看来,这更容易解释。
[...Array(3)].map(() => [...Array(4)])
如果你需要设置一个初始值,那么你可以在内部数组创建时使用.map()链接:
[...Array(3)].map(() => [...Array(4)].map(() => 0))
最后,一个类型安全的TypeScript util函数:
export const createMultiDimensionalArray = <T>(
n: number,
m: number,
initialVal?: T,
): T[][] => {
const matrix = [...Array(n)].map(() => [...Array(m)]);
return initialVal === undefined
? matrix
: matrix.map(r => r.map(() => initialVal));
};
使用它的例子:
const a = createMultiDimensionalArray(1, 2);
a[1][2] = 3; // Works
const b = createMultiDimensionalArray(2, 3, false);
b[1][2] = true; // Works
b[1][2] = 3; // Error: Type '3' is not assignable to type 'boolean'.
最简单的方法:
var myArray = [[]];
这是我的多维数组的实现。
在这种方法中,我创建了一个一维数组
我已经添加了一个原型函数多数组对象,它可以用来创建任何维度的数组。
我还为数组对象添加了一个原型函数索引,用于从多维索引中获取线性数组的索引。
创建Array
//Equivalent to arr[I][J][K]..[] in C
var arr = new Array().multi(I,J,K,..);
在任意索引处访问数组值
//Equivalent in C arr[i][j][k];
var vaue = arr[arr.index(i,j,k)];
片段
/* 存储数组为一维 使用Array.index(i,j,k,…) * / Array.prototype.multi = function(){ 这一点。Multi_size =参数; 这一点。Multi_len = 1 对于(参数的关键字)这个。Multi_len *= parameters [key]; (var i=0;i<this.multi_len;i++) this.push(0); 返回; } Array.prototype.index = function(){ Var _size = this.multi_len; Var temp = 1; Var指数= 0; 对于(参数中的关键字){ 临时* = this.multi_size(例子); 索引+ =(参数(例子)* (_size / temp)) } 返回索引; } //现在你可以使用多维数组 //一个3x3 2D矩阵 var ar2d = new Array().multi(3,3);//一个2D数组 Arr2d [Arr2d .index(1,1,1)] = 5; console.log (arr2d [arr2d.index (1 1 1)]); //一个3x3x3 3D矩阵 var arr3d = new Array().multi(3,3,3);//一个3D数组 Arr3d [Arr3d .index(1,1,1)] = 5; console.log (arr3d [arr3d.index (1 1 1)]); //一个4x3x3 4D矩阵 var arr4d = new Array().multi(4,3,3,3);//一个4D数组 Arr4d [Arr4d .index(4,0,0,1)] = 5; console.log (arr4d [arr4d.index (4 0 0,1)]);
这将构造任何维度的数组。
function makeArrayChildren(parent, firstDimension, ...dimensions) {
for (let i = 0; i < parent.length; i++) {
parent[i] = new Array(firstDimension);
if (dimensions.length != 0) {
makeArrayChildren(parent[i], ...dimensions);
}
}
}
function makeArray(firstDimension, ...dimensions) {
if (firstDimension == undefined) {
throw Exception("Too few dimensions");
}
let topArray = new Array(firstDimension);
if (dimensions.length != 0) makeArrayChildren(topArray, ...dimensions);
return topArray;
}
这里还有另外两个我想做的函数,我可以用它作为一个完整性检查:一个用于在多维数组中所有最低级别项上执行的每个函数,一个填充方法。
Array.prototype.dimensionalFill = function (value) {
for (let i = 0; i < this.length; i++) {
const elem = this[i];
if (elem instanceof Array) {
elem.dimensionalFill(value);
} else {
this[i] = value;
}
}
};
/*Unlike forEach, this also loops over undefined values. */
Array.prototype.dimensionalForEach = function (callableFunc, thisArg) {
if (thisArg != undefined) {
return this.dimensionalForEach(callableFunc.bind(thisArg));
}
for (let i = 0; i < this.length; i++) {
const elem = this[i];
if (elem instanceof Array) {
elem.dimensionalForEach(callableFunc);
} else {
callableFunc(elem, i, this);
}
}
};
这里有一个漂亮的小检查,它使用了所有的特性。所以至少,它不可能完全错误。
let arr = makeArray(10, 10, 5, 4);
arr.dimensionalFill(2);
let sum = 0;
arr.dimensionalForEach((elem) => {
sum += elem;
});
console.log(`sum: ${sum} === ${10 * 10 * 5 * 4 * 2}`);
值得一提的是,在这一点上,创建一个全新的结构将是一个更好的实践,但这很有趣。