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

Question

有没有一种方法可以在javascript中生成字符或数字序列？

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

Answer 1

原始问题已被编辑。因此，更新后的示例回答：

要填写相同的内容：

数组（8）.fill（1）//=> [1, 1, 1, 1, 1, 1, 1, 1]

要填写从5开始的序列号：

数组（8）.fill（）.map（（元素，索引）=>索引+5）//=> [5, 6, 7, 8, 9, 10, 11, 12]

要填充序列字符，请从“G”开始：

数组（8）.fill（）.map（（element，index）=>String.fromCharCode（'G'.charCodeAt（0）+index））//=>[“G”，“H”，“I”，“J”，“K”，“L”，“M”，“N”]

Answer 2

如果没有for循环，以下是一个解决方案：

Array.apply（0，Array（8））.map（function（）{return 1；}）

解释如下。

阵列（8）生成一个包含8个元素的稀疏数组未定义. The应用这个技巧会把它变成一个密集的数组。最后，使用地图，我们替换它未定义（相同的）价值1.

Answer 3

这是迄今为止最简单的一个

常量序列=[…数组（10）.keys（）]console.log（序列）

输出：[0,1,2,3,4,5,6,7,8,9]

Answer 4

一个衬垫：

新数组（10）.fill（1）.map（（_，i）=>i+1）

产量：

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

Answer 5

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

函数makeArray（计数、内容）{var结果=[]；if（内容类型==“函数”）{for（var i=0；i<计数；i++）{result.prush（内容（i））；}}其他{for（var i=0；i<计数；i++）{结果推送（内容）；}}返回结果；}

然后您可以执行以下任一操作：

var myArray=makeArray（8,1）；//或者更复杂的东西，例如：var myArray=makeArray（8，函数（i）{return i*3；}）；

你可以在这里试试请注意，上面的示例根本不依赖于jQuery，所以您可以在没有jQuery的情况下使用它。这样的事情你不会从库中获得任何东西：）

Answer 6

对于（var i=8，a=[]；i--；）a.push（1）；

Answer 7

2016年，Modern Browser功能问世。不需要一直使用jquery。

数组.from（{length:8}，（el，index）=>1/*或index*/）；

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

注意：此解决方案不支持IE，但在developer.mozilla.org/。。。

Answer 8

使用Jquery：

---

$.map（$（数组（8）），函数（val，i）{return i；}）

这将返回：

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

---

$.map（$（数组（8）），function（）{return 1；}）

这将返回：

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

---

Answer 9

范围（开始、结束、步骤）：使用ES6 Iterator

您可以轻松创建范围（）可以用作迭代器的生成器函数。这意味着您不必预先生成整个数组。

函数*范围（开始、结束、步长）{让状态=开始；while（状态<结束）{屈服状态；状态+=步骤；}回报；};

现在，您可能想创建一些从迭代器预生成数组并返回列表的东西。这对于接受数组的函数很有用。为此，我们可以使用数组.from（）

const generate_array=（start，end，step）=>array.from（range（start、end、step））；

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

const array=generate_array（1,10,2）；

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

for（范围常数i（1，Number.MAX_SAFE_INTEGER，7））{控制台.log（i）}

Answer 10

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

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

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

函数make_sequence（值，增量）{如果（！value）值=0；if（！increment）increment=函数（值）｛返回值+1；｝；返回函数（）{让电流=值；value=增量（值）；回流；};}i=制造顺序（）i（）=>0i（）=>1i（）=>2j=make_sequence（1，函数（x）{return x*2；}）j（）=>1j（）=>2j（）=>4j（）=>8

Answer 11

定义8个1的数组的最快方法是定义它-变量A=[1,1,1,1,1，1,1，1]；//你需要很多1才能让一个专用的函数有价值。//也许在《黑客帝国》中，当你想要很多史密斯的时候：Array.repeat=函数（val，len）{对于（var i=len，a=[]；i--；）a[i]=val；返回a；}var A=数组.repeat（'Smith'，100）/*返回值：（字符串）史密斯，史密斯，史密斯，史密斯*/

Answer 12

这是一个很好的选择

var结果=[]；对于（var i=1；i！=4；++i）结果push（i）

查看此处了解更多选项https://ariya.io/2013/07/sequences-using-javascript-array

Answer 13

在ES6简单解决方案中：

seq=（from，len，step=1）=>数组.from（{length:len}，（el，i）=>from+（i*step））；

Answer 14

基于Ariya Hidayat代码的Typescript方法：

/***从零开始生成数字序列。*@param{number}count结果数组中的数字计数。*@return{Array<number>}从零到（count-1）的数字序列。*/公共静态序列（计数：number）：数组<number>{return Array.apply（0，Array（count））.map（（x，i）=>{返回i；});}

Answer 15

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

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

然后可以在任何方向上使用linSeq，例如linSeq（2,4）生成2,3,4，而linSeg（4,2）生成4,3,2。

Answer 16

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

Array.apply（null，Array（3））.map（Function.prototype.call.bind（Number））

Answer 17

var GetAutoNumber=导出。获取自动编号=（L）=>{让LeftPad=（number，targetLength）=>{让输出=数字+“”；while（output.length<targetLength）{输出=“0”+输出；}返回输出；}设GivenLength的最大数字=“”；for（设t=0；t<L；t++）{MaxNumberOfGivenLength=最大GivenLeng数+“9”}让StartTime=+new Date（）；让结果=[]；let ReturnNumber；for（设i=1；i<=MaxNumberOfGivenLength；i++）{结果推送（LeftPad（i，L））}for（设k=0；k！=26；k++）{for（设j=0；j<=999；j++）{结果推送（String.fromCharCode（k+65）+LeftPad（j，（L-1）））；}}console.log（结果长度）返回结果；}获取自动编号（3）

它将生成类似于001-999、A01-A99…Z01-Z99的结果

Answer 18

如果你想产生一个等号序列，这是一个优雅的函数（解决方案类似于其他答案）：

seq=（n，value）=>数组（n）.fill（value）

如果你想产生一系列连续的数字，从0开始，这是一个很好的单线：

seq=n=>n<1？[]：[…序列（n-1），n]

这适用于不同的起始值和增量：

seq2=（n，开始，inc）=>seq（n）.map（i=>start+inc*i）

Answer 19

下面是一个基准，每个选项后的注释显示了以毫秒为单位的1000次运行的中间时间：

让选择权=['数组（n）.fill（）.map（（_，i）=>i）'，//2.71'数组（n）.fill（）.map（函数（_，i）{return i}）'，//2.73'让o=[]；对于（设i=0；i<1e5；i++）o[i]=i'，//3.29'让o=[]；对于（设i=0；i<1e5；i++）o.push（i）'，//3.31'让o=[]；对于（设i=0，n2=n；i<n2；i++）o[i]=i'，//3.38'让o=[]；对于（设i=0；i<n；i++）o[i]=i'，//3.57“Array.apply（null，Array（n））.map（Function.prototype.call.bind（Number））”，//3.64'数组.apply（0，数组（n））.map（（_，i）=>i）'，//3.73'数组.apply（null，数组（n））.map（（_，i）=>i）'，//3.77‘o2=[]；对于（设i=0；i<n；i++）o2[i]=i'，//4.42'[…数组（n）.keys]'，//7.07'数组.from（{length:n}，（_，i）=>i）'，//7.13'来自数组（数组（n），（_，i）=>i）'，//7.23'o3=[]；对于（i3=0；i3<n；i3++）o3[i3]=i3'//24.34]设n=1e5opt.sort（（）=>Math.random（）-.5）for（让opt的opt）{让t1=process.hrtime.bigint（）评估（可选）让t2=进程.hrtime.bigint（）控制台.log（t2-t1+'\t'+选项）}

这个对于当我使用块范围变量而不是全局变量时，循环变得更快了。

我使用中值时间而不是平均时间，因为偶尔一次跑步会比扭曲平均时间的典型跑步花费更长的时间。

我像这样运行基准测试对于{1..1000}中的i；do节点seqbench.js；完成，因为当我只调用脚本一次，但在脚本中运行每个选项1000次时，它受到某种优化的影响，其中对于循环成为最快的选择。

Answer 20

我喜欢这个。

函数*generate（）{设索引=0；while（真）{索引++；从CharCode生成String.from（64+索引）//这将从A返回，对于number只返回索引}}const gen=生成（）；console.log（gen.next（）.value）；//一console.log（gen.next（）.value）；//B类console.log（gen.next（）.value）；//C类

Answer 21

下面是一个使用迭代器类的选项，目前在V8上，该类的速度略快于其他答案：

数组（…新范围（0，n））；

范围等级：

类别范围{第一；最后；构造函数（第一个，最后一个）{this.first=第一个；this.last=最后；}[Symbol.iterator]（）{return this；}next（）{return（this.first<this.last）返回? {value:this.first++，done:false}：{value:未定义，已完成：true}；}}

最突出的竞争者是push（），尽管Range似乎快了一点（接近基准噪声的极限）。

我惊讶地发现速度慢了很多[…x]与相比阵列（…x），并惊讶地发现*发电机函数方法比上面显式的Range生成器类慢得多。

包裹next（）String.fromCharCode中的表达式以适应字符。

Answer 22

Javascript ES6正在运行：）

数组（8）.fill（1）

console.log（数组（8）.fill（1））

Answer 23

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

函数seq（len，value）{//创建数组//使用我们想要的值进行连接//把它分开return（new Array（len+1））.join（value）.split（“”）；}seq（10，“a”）；[“a”，“a”序列号（5，1）；["1", "1", "1", "1", "1"]

Answer 24

用JavaScript生成整数序列肯定会更方便。下面是一个递归函数，它返回一个整数数组。

函数intSequence（开始，结束，n=开始，arr=[]）{返回n===结束？arr.concat（n）：intSequence（开始，结束，开始<结束？n+1：n-1，arr.concat（n））；}$>intSequence（1,1）<-数组[1]$>intSequence（1,3）<-数组（3）[1，2，3]$>intSequence（3，-3）<-数组（7）[3，2，1，0，-1，-2，-3]