操纵阵列的Javascript

Question

我有一个数组是这样的..

var array = [2,a,b,3] 

我想做出安排，以便它可以显示控制台阵列这样

//console.log 
[1,a,b,1] 
[1,a,b,2] 
[1,a,b,3] 
[2,a,b,1] 
[2,a,b,2] 
[2,a,b,3] 

更新

如果我想循环阵列中的每个数字，以及如果该阵列不是静态但动态的呢？

var array = [2,'a','b',3] 
var array = [2,'a',4,'c','b',3] 
var array = [2,'a'] 

，我希望把该控制台结果阵列

，如果任何机构想知道为什么我这样做这因为我已经nasted阵列我保存所有Object.prototypename内部数组，所以我可以把它叫做leater，

这axample

var data = [{a:0,b:[{c:0},{c:0}]},{a:0,b:[{c:0},{c:0}]}] 

我有功能，因此它会返回

[2,a,b,2,c] 

那么我就可以CAL l在

data [2][a][b][2][c] 

我的函数可以返回任何acording到选定的数据，所以我想使这一点，但卡在这里

Answer 1

function clone(arr, i, values) { 
 
    var newArr = arr.slice(); 
 
    values.forEach(v => newArr[v.index] = Math.floor(i/v.breaker) % v.max + 1); 
 
    return newArr; 
 
} 
 

 
function result(arr) { 
 
    var n = 1, 
 
     values = arr.reduceRight((acc, e, i) => { 
 
      if(typeof e === "number") { 
 
       acc.push({ 
 
        index: i, 
 
        max: e, 
 
        breaker: n 
 
       }); 
 
       n *= e; 
 
      } 
 
      return acc; 
 
     }, []); 
 
    
 
    var res = []; 
 
    for(var i = 0; i < n; i++) { 
 
     res.push(clone(arr, i, values)); 
 
    } 
 
    return res; 
 
} 
 

 
console.log(result([2,'a','b',3,4]));

---

用一个例子解释：

让arr是[2, a, 3]。

然后values将是：

[ 
    { 
     index: 0, 
     max: 2, 
     breaker: 3 
    }, 
    { 
     index: 2, 
     max: 3, 
     breaker: 1 
    } 
] 

而且n，排列数为：2 * 3 === 6。

的breaker属性的用途：

当clone功能克隆阵列，它会根据当前排列i的索引更新克隆的编号。

breaker，可以更频繁地增加早期（首次遇到）号码。要增加一个数字，我们需要等待N次（permodiaions），其中N是此数字左侧数字的排列数。在上例中：我们更新2的地方每3排列（每次3的地方已完成一个周期）。

如果数组是：[2, 3, 7]则：

• 要增加7的数量，我们将不必等待。它将会不间断地循环，直到完成所有排列。因此，breaker === 1。
• 要增加3的数字，我们必须等待7完成一个循环。 7's将采取7排列完成一个，因此breaker === 7。
• 要增加2的号码，我们必须等待3的完成一个周期，也必须等待7的完成一个。所以我们必须等待3次7，因此breaker === 3 * 7 === 21。

一个数字的breaker只是它左边的数字完成一个循环所需的排列数。

解读clone功能：

的clone函数采用：

• arr：根据当前的排列的索引被克隆和修饰的阵列。
• i：当前排列的索引。
• valuesvaluesvalues：包含有关数组arr（数字的索引，可以使用的最大值，其breaker值）中所有数字的信息的数组对象的数组。

该函数首先为该数组创建一个克隆（var newArr = arr.slice();）。然后循环通过values阵列中的所有数据对象，计算所述数量的值：首先，我们通过断路器将当前排列的索引

theValueOfTheNumber = (indexOfCurrentPermutation/breaker) % maximumValuePossible + 1; 

以确保该值不会被递增，直到其左侧的数字完成一个周期（如果应用Math.floor，则需要增加3排列，然后0/3，1/3,2/3将全部等于0）。然后我们通过使用Modulo运算符%和+1来限制该值，使其不超过允许的最大值（初始值），因此值将在[1 -> maximumValuePossible]范围内。

result功能的说明：

此功能是简单的，它只是收集所需的信息，例如全部置换的数量n和values阵列。

它使用reduceRight循环阵列之上由右至左，从而遇到号码时，我们只是分配积累n作为其breaker值（其将是排列在其左侧数）。

之后，我们收集信息，我们只是创建一个循环，确定排列的确切数目，调用clone并将其返回的值推送到结果数组中。

Answer 2

如果阵列固定：

for(i = 1; i <= 2; i++) { 
    for(j = 1; j <= 3; j++) { 
    console.log("[" + i + ",a,b," + j +"]"); 
    } 
} 

Answer 3

您将需要遍历通过阵列：

var array = [2, 'a', 'b', 3]; 
 
for(i = 1; i <= array[0]; i++) { 
 
    for(j = 1; j <= array[3]; j++) { 
 
    console.log("[" + i + array[1] + array[2] + j +"]"); 
 
    } 
 
}

Answer 4

编辑：我的大脑即将完成今晚，但当我茫然地盯着你的问题，试图找出你想要做什么，为什么你要这样做，我开始想到一个潜在的方法，比我现在的答案要好。

如果字母值是静态的，您真正关心的是根据数字构建矩阵。如果你有[2,3]，你需要一个二乘三的矩阵，中间有静态字母。如果你有一个[3,3]，你需要一个2行9行的矩阵。 [2,3,2]将是3行12行。

所以，如果这是一个正确的假设[2,"a","b",3,"c",2]最终会看起来像：

[1,1,1] 
[1,1,2] 
[1,2,1] 
[1,2,2] 
[1,3,1] 
[1,3,2] 
[2,1,1] 
[2,1,2] 
[2,2,1] 
[2,2,2] 
[2,3,1] 
[2,3,2] 

然后添加静态内容回复于：

[1,"a","b",1,"c",1] 
[1,"a","b",1,"c",2] 
[1,"a","b",2,"c",1] 
[1,"a","b",2,"c",2] 
[1,"a","b",3,"c",1] 
[1,"a","b",3,"c",2] 
[2,"a","b",1,"c",1] 
[2,"a","b",1,"c",2] 
[2,"a","b",2,"c",1] 
[2,"a","b",2,"c",2] 
[2,"a","b",3,"c",1] 
[2,"a","b",3,"c",2] 

那是远程你在找什么？除了他们需要在最终输出中显示的字母之外，这些字母是不相关的吗？

这里就是我离开过今晚：

const data = [2, "a", "b", 3]; 

// Find the numbers 
const numericData = data.filter(item => typeof item === 'number'); 
console.log(numericData); // [2,3] 

// Build the matrix 
const matrix = Array(2).fill() 
         .map(()=>Array(3).fill(0)); 
console.table(matrix); 

// Populate the matrix 

// Add static content back in 

原来的答复：

我们有了一个更好的办法，但这里有一个方法。

const data = [2, "a", "b", 3]; 
 

 
let output = []; 
 

 
for (let x = 1; x <= data[0]; x++) { 
 
    for (let y = 1; y <= data[3]; y++) { 
 
    output.push([x, "a", "b", y]); 
 
    } 
 
} 
 

 
console.log(output);

产量：

[ 
[1,"a","b",1], 
[1,"a","b",2], 
[1,"a","b",3], 
[2,"a","b",1], 
[2,"a","b",2], 
[2,"a","b",3] 
] 

Answer 5

如何：

var len = array.length; 

for(i = 1; i <= array[0]; i++) { 
    for(j = 1; j <= array[len-1]; j++) { 
     console.log([i].concat(array.slice(1, len-1), [j])) 
    } 
} 

[ 1, 'a', 'b', 1 ] 
[ 1, 'a', 'b', 2 ] 
[ 1, 'a', 'b', 3 ] 
[ 2, 'a', 'b', 1 ] 
[ 2, 'a', 'b', 2 ] 
[ 2, 'a', 'b', 3 ]