JavaScript中索引数组的多维索引

JavaScript中是否有方法选择多维数组的元素。其中深度/等级/维度是可变的，关键点由一系列索引给出。这样我就不能单独处理每个可能的维度深度。具体地说，我想摆脱像这样的开关箱：

/**
 * set tensor value by index
 * @type {array} indices [ index1, index2, index3 ] -> length == rank.
 * @type {string} value.
 */
tensor.prototype.setValueByIndex = function( indices, value ) {
    var rank = indices.length;

    switch(rank) {
        case 0:
            this.values[0] = value;
        break;
        case 1:
            this.values[indices[0]] = value;
        break;
        case 2:
            this.values[indices[0]][indices[1]] = value;
        break;
        case 3:
            this.values[indices[0]][indices[1]][indices[2]] = value;
        break;
    }
}

其中，此.values是一个多维数组

这样我就得到了更像这样的东西：

/**
 * set tensor value by index
 * @type {array} indices, [ index1, index2, index3 ] -> length == rank
 * @type {string} value
 */
tensor.prototype.setValueByIndex = function( indices, value ) {
    var rank = indices.length;

    this.values[ indices ] = value;
}

tensor.prototype.setValueByIndex = function( indexes, value ) {
    var ref = this.values;  
    if (!indexes.length) indexes = [0];  
    for (var i = 0; i<indexes.length;i++) {
       if (typeof ref[i] === 'undefined') ref[i] = [];
       if (ref[i] instanceof Array) {  
           ref = ref[i];
       } else {
           throw Error('There is already value stored') 
       }
    } 
    ref = value;
}

提前谢谢你

像这样

tensor.prototype.setValueByIndex = function( indices, value ) {
  var t = this, i;
  for (i = 0; i < indices.length - 1; i++) t = t[indices[i]];
  t[indices[i]] = value;
}

tensor.prototype.setValueByIndex=函数（索引，值）{
var t=这个，i；
对于（i=0；i

像这样吗

tensor.prototype.setValueByIndex = function( indices, value ) {
  var t = this, i;
  for (i = 0; i < indices.length - 1; i++) t = t[indices[i]];
  t[indices[i]] = value;
}

tensor.prototype.setValueByIndex=函数（索引，值）{
var t=这个，i；
对于（i=0；i

类似这样的内容：

/**
 * set tensor value by index
 * @type {array} indices, [ index1, index2, index3 ] -> length == rank
 * @type {string} value
 */
tensor.prototype.setValueByIndex = function( indices, value ) {
    var rank = indices.length;

    this.values[ indices ] = value;
}

tensor.prototype.setValueByIndex = function( indexes, value ) {
    var ref = this.values;  
    if (!indexes.length) indexes = [0];  
    for (var i = 0; i<indexes.length;i++) {
       if (typeof ref[i] === 'undefined') ref[i] = [];
       if (ref[i] instanceof Array) {  
           ref = ref[i];
       } else {
           throw Error('There is already value stored') 
       }
    } 
    ref = value;
}

tensor.prototype.setValueByIndex=函数（索引，值）{
var ref=此值；
如果（！index.length）索引=[0]；
对于（var i=0；i类似这样的情况：

/**
 * set tensor value by index
 * @type {array} indices, [ index1, index2, index3 ] -> length == rank
 * @type {string} value
 */
tensor.prototype.setValueByIndex = function( indices, value ) {
    var rank = indices.length;

    this.values[ indices ] = value;
}

tensor.prototype.setValueByIndex = function( indexes, value ) {
    var ref = this.values;  
    if (!indexes.length) indexes = [0];  
    for (var i = 0; i<indexes.length;i++) {
       if (typeof ref[i] === 'undefined') ref[i] = [];
       if (ref[i] instanceof Array) {  
           ref = ref[i];
       } else {
           throw Error('There is already value stored') 
       }
    } 
    ref = value;
}

tensor.prototype.setValueByIndex=函数（索引，值）{
var ref=此值；
如果（！index.length）索引=[0]；
对于（var i=0；i
tensor.prototype.setValueByIndex=函数（索引，值）{
var数组=this.values；
对于（变量i=0；i

这将使用
数组
指向我们当前所在的嵌套数组，并通过
索引
从当前
数组
中查找下一个
数组
值。一旦我们到达
索引
列表中的最后一个索引，我们就找到了要存放值的数组。最终索引是t他在最后一个数组中插入值。tensor.prototype.setValueByIndex=函数（索引，值）{
var数组=this.values；
对于（变量i=0；i

这将使用
数组
指向我们当前所在的嵌套数组，并通过
索引
从当前
数组
中查找下一个
数组
值。一旦我们到达
索引
列表中的最后一个索引，我们就找到了要存放值的数组。最终索引是t他在最后一个数组中插入值。你为什么要这样做？我想说的是写

tensor.values[1][5][8][2] = value;

要比

tensor.setValues([1, 5, 8, 2], value);

如果您真的需要这样做，可以在阵列上进行简单的循环：

tensor.prototype.setValueByIndex = function(indices, value) {
    var arr = this.values;
    for (var i=0; i<indices.length-1 && arr; i++)
        arr = arr[indices[i]];
    if (arr)
        arr[indices[i]] = value;
    else
        throw new Error("Tensor.setValueByIndex: Some index pointed to a nonexisting array");
};

tensor.prototype.setValueByIndex=函数（索引，值）{
var arr=此值；
对于（var i=0；i你为什么要这样做？我想说的是写作

tensor.values[1][5][8][2] = value;

要比

tensor.setValues([1, 5, 8, 2], value);

如果您真的需要这样做，可以在阵列上进行简单的循环：

tensor.prototype.setValueByIndex = function(indices, value) {
    var arr = this.values;
    for (var i=0; i<indices.length-1 && arr; i++)
        arr = arr[indices[i]];
    if (arr)
        arr[indices[i]] = value;
    else
        throw new Error("Tensor.setValueByIndex: Some index pointed to a nonexisting array");
};

tensor.prototype.setValueByIndex=函数（索引，值）{
var arr=此值；
对于（var i=0；iNo，他想要一个集合而不是getNo，他想要一个集合而不是getYes，这看起来很简单，但我想用一个变量“索引数”来创建一个抽象张量，使秩等于“索引数”。这样，所有操作都可以以抽象的方式定义，而不是为不同的列组和维度分别定义所有操作。解决方案的步骤非常简单：P，谢谢！是的，它看起来很简单，但是。我想使用一个变量“索引数”创建一个抽象张量，使秩等于“索引数”。这样，所有操作都可以以抽象的方式定义，而不是为不同的秩和维度分别定义所有操作。这非常简单：P，谢谢！可能重复的可能重复的