是否有在 JavaScript 中创建填充数组的快捷方式？

Question

我有这个javascript：

function padded_array(k, value){
    var a = [];
    a[k] = value;
    return a;
}

padded_array(3, "hello"); //=> [undefined, undefined, undefined, 'hello']

是否可以缩短函数体中的代码？

Answer 1

如果要排除'hello'，可以使用

new Array(count);

创建填充数组。

编辑：也许像这样？

new Array(5).concat("hello")

Answer 2

不在标准 ES5 或之前的版本中。当然，您可以在 jQuery 中执行类似 $.extend([], {"3": "hello"}) 的操作；你甚至可以做

Object.create(Array.prototype, {"3": {value: "hello"} });

在裸 ES5 中，但它是 hack，我不认为这是一个解决方案（如果你同意，你可以采用它）。

Answer 3

对于所有来到这里的谷歌员工 - 你可能正在寻找这个：

var pad_array = function(arr,len,fill) {
  return arr.concat(Array(len).fill(fill)).slice(0,len);
}

Answer 4

如果您的 JS 不支持 Array.prototype.fill()（例如 Google Apps 脚本）并且您不能使用第一个答案中的代码，您可以使用它：

function array_pad(array, length, filler)
{
    if(array.length < length)// [10.02.20] Fixed error that Dimitry K noticed
      while(true)
        if(array.push(filler) >= length)
          break;
    return array;
}

Answer 5

使用扩展运算符的另一种解决方案：

padArray = (length, value) => [...Array(length).fill(), value];

而且用法和你说的一样：

padded_array(3, "hello"); //=> [undefined, undefined, undefined, 'hello']

Answer 6

我知道这是一个旧的（呃）问题，但如果有人在这里绊倒（就像我最初做的那样），我想加我 2 美分。

无论如何，这是我对Array.from的看法

const padded_array = (k, value) => Array.from({ length: k }).concat(value)

console.log(padded_array(3, "hello"));

你也可以这样做：

const padded = (arr, pad, val) => {
  arr[pad] = val
  return arr
}

console.log(padded([],3,'hello'))

Answer 7

对于开头的填充：

function padArrayStart(arr, len, padding){
   return Array(len - arr.length).fill(padding).concat(arr);
}

演示：

function padArrayStart(arr, len, padding){
   return Array(len - arr.length).fill(padding).concat(arr);
}
console.log(...padArrayStart([1,2,3], 5, 0));//0 0 1 2 3
console.log(...padArrayStart([4,5,6], 3, 0));//4 5 6

用于末尾的填充：

function padArrayEnd(arr, len, padding){
   return arr.concat(Array(len - arr.length).fill(padding));
}

演示：

function padArrayEnd(arr, len, padding){
   return arr.concat(Array(len - arr.length).fill(padding));
}
console.log(...padArrayEnd(['a','b','c'], 10, 'z'));//a b c z z z z z z z
console.log(...padArrayEnd([0, 'a', 'd'], 6, -1));//0 a d -1 -1 -1

Answer 8

// push is faster than concat
// mutate array in place + return array

const pad_right = (a, l, f) =>
  !Array.from({length: l - a.length})
  .map(_ => a.push(f)) || a;

const a = [1, 2];

pad_right(a, 4, 'x');
// -> [ 1, 2, 'x', 'x' ]

a;
// -> [ 1, 2, 'x', 'x' ]

Answer 9

从 2020 年和 2021 年开始：直截了当的选择

假设这是你的数组

const yourArray = [1,2]

如果你只想循环 4 次（也许是为了 react jsx）

Array.from({length:4}) //[undefined,undefined,undefined,undefined]
Array(4).fill()//[undefined,undefined,undefined,undefined]

如果您想循环 yourArray 4 次，但要从已有的值开始

// unmutation option
Array.from({...yourArray, length:4}) //[1,2,undefined,undefined]

// unmutation option, but need some calcualtion
[...yourArray , ...Array(2)  ] //[1,2,undefined,undefined]
[...Array(2), ...yourArray   ] //[undefined,undefined,1,2]

// loop on your array several times 
Array(3).fill(yourArray).flat() // [1, 2, 1, 2, 1, 2]

// mutation the original array.
yourArray.length = 4;
Array.from(yourArray) //[1,2,undefined,undefined]

如果你真的想要一个充满值的数组。前任。带有递增数字。
重新映射它

// unmutation option

Array.from({...yourArray,length:4}, (v,i) => v ?? i+1 ) 
// [1,'2',3, 4]

// Or, mutation the original array. and fill with "x"
array.yourArray.length = 4;

Array.from(yourArray, (v) => v ?? 'x') 
// [1,'2','x','x']