如何在javascript中生成数字/字符序列？

有没有办法在javascript中生成字符或数字序列

---

例如，我想创建包含八个1的数组。我可以使用for循环来实现它，但不知道是否有jQuery库或javascript函数可以为我实现它？

我想您可以创建自己的可重用函数，例如：

function makeArray(count, content) {
   var result = [];
   if(typeof content == "function") {
      for(var i = 0; i < count; i++) {
         result.push(content(i));
      }
   } else {
      for(var i = 0; i < count; i++) {
         result.push(content);
      }
   }
   return result;
}

---

，请注意，上面的示例根本不依赖jQuery，因此您可以使用它而不必使用它。如果没有for循环，您不会从库中获得任何东西：）

，下面是一个解决方案：

Array.apply(0, Array(8)).map(function() { return 1; })

解释如下

Array（8）

生成一个包含8个元素的稀疏数组，所有

元素都未定义。
apply
技巧将把它变成一个密集数组。最后，使用
map
，我们使用Jquery将
未定义的
替换为
1
的（相同）值：


这将返回：

[0, 1, 2, 3, 4, 5, 6, 7]

[1, 1, 1, 1, 1, 1, 1, 1]


这将返回：

[0, 1, 2, 3, 4, 5, 6, 7]

[1, 1, 1, 1, 1, 1, 1, 1]

序列是一个流，它在需要时计算值。使用这些值时，这只需要一点内存，但需要更多的CPU时间

数组是预计算值的列表。这需要一些时间才能使用第一个值。它需要大量内存，因为序列中所有可能的值都必须存储在内存中。你必须定义一个上限

这意味着，在大多数情况下，使用序列值创建数组不是一个好主意。相反，最好将序列实现为实序列，这仅受CPU的字长限制

function make_sequence (value, increment)
{
  if (!value) value = 0;
  if (!increment) increment = function (value) { return value + 1; };

  return function () {
    let current = value;
    value = increment (value);
    return current;
  };
}

i = make_sequence()
i() => 0
i() => 1
i() => 2

j = make_sequence(1, function(x) { return x * 2; })
j() => 1
j() => 2
j() => 4
j() => 8

原来的问题经过编辑。因此，更新后的示例回答：

填写相同内容：

Array(8).fill(1)
//=> [1, 1, 1, 1, 1, 1, 1, 1]

Array(8).fill().map((element, index) => index + 5)
//=> [5, 6, 7, 8, 9, 10, 11, 12]

Array(8).fill().map((element, index) => String.fromCharCode('G'.charCodeAt(0) + index)) 
//=> ["G", "H", "I", "J", "K", "L", "M", "N"]

从5开始填充序列号：

Array(8).fill(1)
//=> [1, 1, 1, 1, 1, 1, 1, 1]

Array(8).fill().map((element, index) => index + 5)
//=> [5, 6, 7, 8, 9, 10, 11, 12]

Array(8).fill().map((element, index) => String.fromCharCode('G'.charCodeAt(0) + index)) 
//=> ["G", "H", "I", "J", "K", "L", "M", "N"]

从“G”开始填充顺序字符：

Array(8).fill(1)
//=> [1, 1, 1, 1, 1, 1, 1, 1]

Array(8).fill().map((element, index) => index + 5)
//=> [5, 6, 7, 8, 9, 10, 11, 12]

Array(8).fill().map((element, index) => String.fromCharCode('G'.charCodeAt(0) + index)) 
//=> ["G", "H", "I", "J", "K", "L", "M", "N"]

为什么不只是简单的连接和拆分

function seq(len, value)
{
    // create an array
    // join it using the value we want
    // split it
    return (new Array(len + 1)).join(value).split("");
}

seq(10, "a");
["a", "a", "a", "a", "a", "a", "a", "a", "a", "a"]

seq(5, 1);
["1", "1", "1", "1", "1"]

2016年的今天，现代浏览器功能已经实现。不需要一直使用jquery

Array.from({length: 8}, (el, index) => 1 /* or index */);

您可以用一个简单的回调函数来替代箭头函数，以覆盖更广泛的受支持浏览器。至少对我来说，这是一步迭代初始化数组的最简单方法

注意：此解决方案不支持IE，但基于Ariya Hidayat代码的Typescript方法中有一个polyfill：

/**
 * Generates sequence of numbers from zero.
 * @ param {number} count Count of numbers in result array.
 * @ return {Array<number>} Sequence of numbers from zero to (count - 1).
 */
public static sequence(count: number): Array<number>
{
    return Array.apply(0, Array(count)).map((x, i) =>
    {
        return i;
    });
}

/**
*从零生成数字序列。
*@param{number}count结果数组中的数字计数。
*@return{Array}从零到（count-1）的数字序列。
*/
公共静态序列（计数：编号）：数组
{
返回数组。应用（0，数组（计数））.map（（x，i）=>
{
返回i；
});
}
范围（开始、结束、步骤）
：使用ES6迭代器
您可以轻松创建
range（）
generator函数，该函数可以用作迭代器。这意味着您不必预先生成整个阵列

function * range ( start, end, step ) {
  let state = start;
  while ( state < end ) {
    yield state;
    state += step;
  }
  return;
};

现在您可以轻松生成静态数组

const array = generate_array(1,10,2);

但是当某些东西需要一个迭代器（或者让您选择使用迭代器）时，您也可以轻松地创建一个迭代器

for ( const i of range(1, Number.MAX_SAFE_INTEGER, 7) ) {
  console.log(i)
}

如果您像我一样经常使用linspace，您可以像这样轻松地修改您的linspace版本：

function linSeq(x0, xN) {
    return linspace(x0, xN, Math.abs(xN-x0)+1);
}

function linspace(x0, xN, n){

    dx = (xN - x0)/(n-1);
    var x = [];
    for(var i =0; i < n; ++i){
        x.push(x0 + i*dx);
    }

    return x;
}

函数linSeq（x0，xN）{
返回linspace（x0，xN，Math.abs（xN-x0）+1）；
}
函数linspace（x0，xN，n）{
dx=（xN-x0）/（n-1）；
var x=[]；
对于（变量i=0；i

然后，您可以在任何方向上使用linSeq，例如，linSeq（2,4）生成2,3,4，而linSeq（4,2）生成4,3,2。
在JavaScript中生成整数序列肯定更方便。下面是一个递归函数，返回一个整数数组

function intSequence(start, end, n = start, arr = []) {
  return n === end ? arr.concat(n)
    : intSequence(start, end, start < end ? n + 1 : n - 1, arr.concat(n));
}

$> intSequence(1, 1)
<- Array [ 1 ]

$> intSequence(1, 3)
<- Array(3) [ 1, 2, 3 ]

$> intSequence(3, -3)
<- Array(7) [ 3, 2, 1, 0, -1, -2, -3 ]

函数intSequence（开始，结束，n=start，arr=[]）{
返回n==end？arr.concat（n）
：intSequence（开始，结束，开始<结束？n+1:n-1，arr.concat（n））；
}
$>intSequence（1,1）
intSequence（1，3）
整数序列（3，-3）
一艘班轮：

new Array(10).fill(1).map( (_, i) => i+1 )

收益率：

[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

另一种方法，对于那些如何节省内存的学究：

Array.apply(null, Array(3)).map(Function.prototype.call.bind(Number))

var GetAutoNumber=exports.GetAutoNumber=（L）=>{
LeftPad=（数字，目标长度）=>{
让输出=数字+“”；
while（output.length
var result = [];
for (var i = 1; i != 4; ++i) result.push(i)

在此处查看更多选项
如果您想生成一个相等的数字序列，这是一个优雅的函数（解决方案类似于其他答案）：

如果您想生成一个从0开始的连续数字序列，这是一个很好的单行线：

seq = n => n<1 ? [] : [...seq(n-1), n]

Javascript ES6正在运行：）


console.log（数组（8.fill）（1））
使用
for
循环有什么错？库有必要做这项工作吗？我不这么认为=）一点也不。这显然是最好在语言级别上解决的问题，而不是在库级别上。我已经相应地修改了这个问题。我认为这是一个非常有效的问题，有些语言是开箱即用的你必须创建3个下拉列表日/月/年，然后3个循环看起来很混乱，但是这似乎也是唯一快速的方法，我认为
result.push（i）；
应该是'result.push（content）59
@不只是开玩笑，OP可能不满意，因为它缺少jQuery，哈哈。在你的评论中，
a.push（$（1））
，它将jQuery对象推入数组，而不是数字：）@Avinash，我知道，只是在胡闹；）这是真的
seq2 = (n, start, inc) => seq(n).map(i => start + inc * i)

Array(8).fill(1)