blocks|key|812321|text|我创建了几个更快的变种，你可以see+on+jsPerf。我最喜欢的一条是：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|812322|function+chunkSubstr(str,+size)+{
++const+numChunks+=+Math.ceil(str.length+/+size)
++const+chunks+=+new+Array(numChunks)

++for+(let+i+=+0,+o+=+0;+i+<+numChunks;+%2B%2Bi,+o+%2B=+size)+{
++++chunks[i]+=+str.substr(o,+size)
++}

++return+chunks
}|code-block|syntax|javascript|812323|entityMap|0|LINK|mutability|MUTABLE|url|http://jsperf.com/chunk-string/4^0|F|D|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I created several faster variants which you can <a href="http://jsperf.com/chunk-string/4" rel="noreferrer">see on jsPerf</a>. My favorite one is this:

<pre><code>function chunkSubstr(str, size) {
 const numChunks = Math.ceil(str.length / size)
 const chunks = new Array(numChunks)

 for (let i = 0, o = 0; i &lt; numChunks; ++i, o += size) {
 chunks[i] = str.substr(o, size)
 }

 return chunks
}
</code></pre>

blocks|key|596731|text|这是一个快速而直接的解决方案-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|596732|​|596733|function+chunkString+(str,+len)+{
++const+size+=+Math.ceil(str.length/len)
++const+r+=+Array(size)
++let+offset+=+0
++
++for+(let+i+=+0;+i+<+size;+i%2B%2B)+{
++++r[i]+=+str.substr(offset,+len)
++++offset+%2B=+len
++}
++
++return+r
}

console.log(chunkString("helloworld",+3))
//+=>+[+"hel",+"low",+"orl",+"d"+]

//+10,000+char+string
const+bigString+=+"helloworld".repeat(1000)
console.time("perf")
const+result+=+chunkString(bigString,+3)
console.timeEnd("perf")
console.log(result)
//+=>+perf:+0.385+ms
//+=>+[+"hel",+"low",+"orl",+"dhe",+"llo",+"wor",+...+]|code-block|syntax|javascript|596734|596735|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

This is a fast and straightforward solution -

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function chunkString (str, len) {
 const size = Math.ceil(str.length/len)
 const r = Array(size)
 let offset = 0
 
 for (let i = 0; i &lt; size; i++) {
 r[i] = str.substr(offset, len)
 offset += len
 }
 
 return r
}

console.log(chunkString("helloworld", 3))
// =&gt; [ "hel", "low", "orl", "d" ]

// 10,000 char string
const bigString = "helloworld".repeat(1000)
console.time("perf")
const result = chunkString(bigString, 3)
console.timeEnd("perf")
console.log(result)
// =&gt; perf: 0.385 ms
// =&gt; [ "hel", "low", "orl", "dhe", "llo", "wor", ... ]</code></pre>
</div>
</div>

blocks|key|596973|text|惊喜吧！您可以使用split进行拆分。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|596974|var+parts+=+"1234567890+".split(/(.{2})/).filter(O=>O)|code-block|syntax|javascript|596975|[+'12',+'34',+'56',+'78',+'90',+'+'+]格式的结果|style|CODE|596976|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split^0|9|5|0|0|0|0|11|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Surprise! You can use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split" rel="noreferrer">split</a> to split.

<pre><code>var parts = "1234567890 ".split(/(.{2})/).filter(O=&gt;O)
</code></pre>

Results in <code>[ '12', '34', '56', '78', '90', ' ' ]</code>

blocks|key|596638|text|var+str+=+"123456789";
var+chunks+=+[];
var+chunkSize+=+2;

while+(str)+{
++++if+(str.length+<+chunkSize)+{
++++++++chunks.push(str);
++++++++break;
++++}
++++else+{
++++++++chunks.push(str.substr(0,+chunkSize));
++++++++str+=+str.substr(chunkSize);
++++}
}

alert(chunks);+//+chunks+==+12,34,56,78,9|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|596639|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var str = "123456789";
var chunks = [];
var chunkSize = 2;

while (str) {
 if (str.length &lt; chunkSize) {
 chunks.push(str);
 break;
 }
 else {
 chunks.push(str.substr(0, chunkSize));
 str = str.substr(chunkSize);
 }
}

alert(chunks); // chunks == 12,34,56,78,9
</code></pre>

blocks|key|812258|text|我已经编写了一个扩展函数，因此块长度也可以是一个数字数组，如1,3|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812259|String.prototype.chunkString+=+function(len)+{
++++var+_ret;
++++if+(this.length+<+1)+{
++++++++return+[];
++++}
++++if+(typeof+len+===+'number'+&&+len+>+0)+{
++++++++var+_size+=+Math.ceil(this.length+/+len),+_offset+=+0;
++++++++_ret+=+new+Array(_size);
++++++++for+(var+_i+=+0;+_i+<+_size;+_i%2B%2B)+{
++++++++++++_ret[_i]+=+this.substring(_offset,+_offset+=+_offset+%2B+len);
++++++++}
++++}
++++else+if+(typeof+len+===+'object'+&&+len.length)+{
++++++++var+n+=+0,+l+=+this.length,+chunk,+that+=+this;
++++++++_ret+=+[];
++++++++do+{
++++++++++++len.forEach(function(o)+{
++++++++++++++++chunk+=+that.substring(n,+n+%2B+o);
++++++++++++++++if+(chunk+!==+'')+{
++++++++++++++++++++_ret.push(chunk);
++++++++++++++++++++n+%2B=+chunk.length;
++++++++++++++++}
++++++++++++});
++++++++++++if+(n+===+0)+{
++++++++++++++++return+undefined;+//+prevent+an+endless+loop+when+len+=+[0]
++++++++++++}
++++++++}+while+(n+<+l);
++++}
++++return+_ret;
};|code-block|syntax|javascript|812260|代码|812261|"1234567890123".chunkString([1,3])|812262|将返回：|812263|[+'1',+'234',+'5',+'678',+'9',+'012',+'3'+]|812264|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I have written an extended function, so the chunk length can also be an array of numbers, like [1,3]

<pre><code>String.prototype.chunkString = function(len) {
 var _ret;
 if (this.length &lt; 1) {
 return [];
 }
 if (typeof len === 'number' &amp;&amp; len &gt; 0) {
 var _size = Math.ceil(this.length / len), _offset = 0;
 _ret = new Array(_size);
 for (var _i = 0; _i &lt; _size; _i++) {
 _ret[_i] = this.substring(_offset, _offset = _offset + len);
 }
 }
 else if (typeof len === 'object' &amp;&amp; len.length) {
 var n = 0, l = this.length, chunk, that = this;
 _ret = [];
 do {
 len.forEach(function(o) {
 chunk = that.substring(n, n + o);
 if (chunk !== '') {
 _ret.push(chunk);
 n += chunk.length;
 }
 });
 if (n === 0) {
 return undefined; // prevent an endless loop when len = [0]
 }
 } while (n &lt; l);
 }
 return _ret;
};
</code></pre>

The code

<pre><code>"1234567890123".chunkString([1,3])
</code></pre>

will return:

<pre><code>[ '1', '234', '5', '678', '9', '012', '3' ]
</code></pre>

blocks|key|597152|text|你绝对可以做一些像这样的事情|type|unstyled|depth|inlineStyleRanges|entityRanges|data|597153|let+pieces+=+"1234567890+".split(/(.{2})/).filter(x+=>+x.length+==+2);|code-block|syntax|javascript|597154|要获得以下信息：|597155|[+'12',+'34',+'56',+'78',+'90'+]|597156|如果您想要动态输入/调整块大小，以使块的大小为n，您可以这样做：|597157|n+=+2;
let+pieces+=+"1234567890+".split(new+RegExp("(.{"%2Bn.toString()%2B"})")).filter(x+=>+x.length+==+n);|597158|要在原始字符串中查找所有可能的大小为n的块，请尝试执行以下操作：|597159|let+subs+=+new+Set();
let+n+=+2;
let+str+=+"1234567890+";
let+regex+=+new+RegExp("(.{"%2Bn.toString()%2B"})");+++++//set+up+regex+expression+dynamically+encoded+with+n

for+(let+i+=+0;+i+<+n;+i%2B%2B){+++++++++++++++//starting+from+all+possible+offsets+from+position+0+in+the+string
++++let+pieces+=+str.split(regex).filter(x+=>+x.length+==+n);++++//divide+the+string+into+chunks+of+size+n...
++++for+(let+p+of+pieces)+++++++++++++++++//...and+add+the+chunks+to+the+set
++++++++subs.add(p);
++++str+=+str.substr(1);++++//shift+the+string+reading+frame
}|597160|你最终应该会得到：|597161|[+'12',+'23',+'34',+'45',+'56',+'67',+'78',+'89',+'90',+'0+'+]|597162|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

You can definitely do something like

<pre><code>let pieces = "1234567890 ".split(/(.{2})/).filter(x =&gt; x.length == 2);
</code></pre>

to get this:

<pre><code>[ '12', '34', '56', '78', '90' ]
</code></pre>

If you want to dynamically input/adjust the chunk size so that the chunks are of size n, you can do this:

<pre><code>n = 2;
let pieces = "1234567890 ".split(new RegExp("(.{"+n.toString()+"})")).filter(x =&gt; x.length == n);
</code></pre>

To find all possible size n chunks in the original string, try this:

<pre><code>let subs = new Set();
let n = 2;
let str = "1234567890 ";
let regex = new RegExp("(.{"+n.toString()+"})"); //set up regex expression dynamically encoded with n

for (let i = 0; i &lt; n; i++){ //starting from all possible offsets from position 0 in the string
 let pieces = str.split(regex).filter(x =&gt; x.length == n); //divide the string into chunks of size n...
 for (let p of pieces) //...and add the chunks to the set
 subs.add(p);
 str = str.substr(1); //shift the string reading frame
}
</code></pre>

You should end up with:

<pre><code>[ '12', '23', '34', '45', '56', '67', '78', '89', '90', '0 ' ]
</code></pre>

blocks|key|812058|text|var+l+=+str.length,+lc+=+0,+chunks+=+[],+c+=+0,+chunkSize+=+2;
for+(;+lc+<+l;+c%2B%2B)+{
++chunks[c]+=+str.slice(lc,+lc+%2B=+chunkSize);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|812059|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var l = str.length, lc = 0, chunks = [], c = 0, chunkSize = 2;
for (; lc &lt; l; c++) {
 chunks[c] = str.slice(lc, lc += chunkSize);
}
</code></pre>

blocks|key|812092|text|我会使用正则表达式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812093|var+chunkStr+=+function(str,+chunkLength)+{
++++return+str.match(new+RegExp('[\\s\\S]{1,'+%2B+%2BchunkLength+%2B+'}',+'g'));
}|code-block|syntax|javascript|812094|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I would use a regex...

<pre><code>var chunkStr = function(str, chunkLength) {
 return str.match(new RegExp('[\\s\\S]{1,' + +chunkLength + '}', 'g'));
}
</code></pre>

blocks|key|812445|text|const+getChunksFromString+=+(str,+chunkSize)+=>+{
++++var+regexChunk+=+new+RegExp(`.{1,${chunkSize}}`,+'g')+++//+'.'+represents+any+character
++++return+str.match(regexChunk)
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|812446|根据需要调用它|unstyled|812447|console.log(getChunksFromString("Hello+world",+3))+++//+["Hel",+"lo+",+"wor",+"ld"]|812448|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>const getChunksFromString = (str, chunkSize) =&gt; {
 var regexChunk = new RegExp(`.{1,${chunkSize}}`, 'g') // '.' represents any character
 return str.match(regexChunk)
}
</code></pre>

Call it as needed 

<pre><code>console.log(getChunksFromString("Hello world", 3)) // ["Hel", "lo ", "wor", "ld"]
</code></pre>

blocks|key|812559|text|您可以使用不带任何正则表达式的reduce()：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|812560|(str,+n)+=>+{
++return+str.split('').reduce(
++++(acc,+rec,+index)+=>+{
++++++return+((index+%25+n)+%7C%7C+!(index))+?+acc.concat(rec)+:+acc.concat(',',+rec)
++++},
++++''
++).split(',')
}|code-block|syntax|javascript|812561|entityMap^0|F|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You can use <code>reduce()</code> without any regex:

<pre><code>(str, n) =&gt; {
 return str.split('').reduce(
 (acc, rec, index) =&gt; {
 return ((index % n) || !(index)) ? acc.concat(rec) : acc.concat(',', rec)
 },
 ''
 ).split(',')
}
</code></pre>

blocks|key|812173|text|以原型函数的形式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812174|String.prototype.lsplit+=+function(){
++++return+this.match(new+RegExp('.{1,'%2B+((arguments.length==1)?(isFinite(String(arguments[0]).trim())?arguments[0]:false):1)+%2B'}',+'g'));
}|code-block|syntax|javascript|812175|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In the form of a prototype function:

<pre><code>String.prototype.lsplit = function(){
 return this.match(new RegExp('.{1,'+ ((arguments.length==1)?(isFinite(String(arguments[0]).trim())?arguments[0]:false):1) +'}', 'g'));
}
</code></pre>

blocks|key|596930|text|使用slice()方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|596931|function+returnChunksArray(str,+chunkSize)+{
++var+arr+=+[];
++while(str+!==+'')+{
++++arr.push(str.slice(0,+chunkSize));
++++str+=+str.slice(chunkSize);
++}
++return+arr;
}|code-block|syntax|javascript|596932|使用substring()方法也可以做到这一点。|596933|function+returnChunksArray(str,+chunkSize)+{
++var+arr+=+[];
++while(str+!==+'')+{
++++arr.push(str.substring(0,+chunkSize));
++++str+=+str.substring(chunkSize);
++}
++return+arr;
}|596934|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Using slice() method:

<pre><code>function returnChunksArray(str, chunkSize) {
 var arr = [];
 while(str !== '') {
 arr.push(str.slice(0, chunkSize));
 str = str.slice(chunkSize);
 }
 return arr;
}
</code></pre>

The same can be done using substring() method.

<pre><code>function returnChunksArray(str, chunkSize) {
 var arr = [];
 while(str !== '') {
 arr.push(str.substring(0, chunkSize));
 str = str.substring(chunkSize);
 }
 return arr;
}
</code></pre>

blocks|key|812528|text|我对上面的解决方案的问题是，无论字符串在句子中的位置如何，它都会将字符串标记为正式大小的块。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|812529|我认为以下是一种更好的方法；尽管它需要一些性能调整：|812530|+static+chunkString(str,+length,+size,delimiter='\n'+)+{
++++++++const+result+=+[];
++++++++for+(let+i+=+0;+i+<+str.length;+i%2B%2B)+{
++++++++++++const+lastIndex+=+_.lastIndexOf(str,+delimiter,size+%2B+i);
++++++++++++result.push(str.substr(i,+lastIndex+-+i));
++++++++++++i+=+lastIndex;
++++++++}
++++++++return+result;
++++}|code-block|syntax|javascript|812531|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

My issue with the above solution is that it beark the string into formal size chunks regardless of the position in the sentences.

I think the following a better approach; although it needs some performance tweaking:

<pre><code> static chunkString(str, length, size,delimiter='\n' ) {
 const result = [];
 for (let i = 0; i &lt; str.length; i++) {
 const lastIndex = _.lastIndexOf(str, delimiter,size + i);
 result.push(str.substr(i, lastIndex - i));
 i = lastIndex;
 }
 return result;
 }
</code></pre>

blocks|key|597215|text|使用这个npm库"chkchars“，但记住要确保给定字符串的长度与"number”参数完全分开。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|597216|const+phrase+=+"1110010111010011100101110100010000011100101110100111001011101001011101001110010111010001000001110010111010011100101110100"
const+number+=+7

chkchars.splitToChunks(phrase,+number)

//+result+=>+['1110010',+'1110100','1110010',+'1110100','0100000',+'1110010','1110100',+'1110010','1110100',+'1011101','0011100',+'1011101','0001000','0011100','1011101',+'0011100','1011101']

//+perf+=>+0.287ms|code-block|syntax|javascript|597217|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use this npm library &quot;chkchars&quot;
but remember to make sure the length of the string given is perfectly divided by the &quot;number&quot; parameter.
<pre><code>const phrase = &quot;1110010111010011100101110100010000011100101110100111001011101001011101001110010111010001000001110010111010011100101110100&quot;
const number = 7

chkchars.splitToChunks(phrase, number)

// result =&gt; ['1110010', '1110100','1110010', '1110100','0100000', '1110010','1110100', '1110010','1110100', '1011101','0011100', '1011101','0001000','0011100','1011101', '0011100','1011101']

// perf =&gt; 0.287ms
</code></pre>

blocks|key|596916|text|++++window.format+=+function(b,+a)+{
++++++++if+(!b+%7C%7C+isNaN(%2Ba))+return+a;
++++++++var+a+=+b.charAt(0)+==+"-"+?+-a+:+%2Ba,
++++++++++++j+=+a+<+0+?+a+=+-a+:+0,
++++++++++++e+=+b.match(/[%5E\d\-\%2B#]/g),
++++++++++++h+=+e+&&+e[e.length+-+1]+%7C%7C+".",
++++++++++++e+=+e+&&+e[1]+&&+e[0]+%7C%7C+",",
++++++++++++b+=+b.split(h),
++++++++++++a+=+a.toFixed(b[1]+&&+b[1].length),
++++++++++++a+=+%2Ba+%2B+"",
++++++++++++d+=+b[1]+&&+b[1].lastIndexOf("0"),
++++++++++++c+=+a.split(".");
++++++++if+(!c[1]+%7C%7C+c[1]+&&+c[1].length+<=+d)+a+=+(%2Ba).toFixed(d+%2B+1);
++++++++d+=+b[0].split(e);
++++++++b[0]+=+d.join("");
++++++++var+f+=+b[0]+&&+b[0].indexOf("0");
++++++++if+(f+>+-1)
++++++++++++for+(;+c[0].length+<+b[0].length+-+f;)+c[0]+=+"0"+%2B+c[0];
++++++++else+%2Bc[0]+==+0+&&+(c[0]+=+"");
++++++++a+=+a.split(".");
++++++++a[0]+=+c[0];
++++++++if+(c+=+d[1]+&&+d[d.length+-
++++++++++++++++1].length)+{
++++++++++++for+(var+d+=+a[0],+f+=+"",+k+=+d.length+%25+c,+g+=+0,+i+=+d.length;+g+<+i;+g%2B%2B)+f+%2B=+d.charAt(g),+!((g+-+k+%2B+1)+%25+c)+&&+g+<+i+-+c+&&+(f+%2B=+e);
++++++++++++a[0]+=+f
++++++++}
++++++++a[1]+=+b[1]+&&+a[1]+?+h+%2B+a[1]+:+"";
++++++++return+(j+?+"-"+:+"")+%2B+a[0]+%2B+a[1]
++++};

var+str="1234567890";
var+formatstr=format(+"##,###.",+str);
alert(formatstr);


This+will+split+the+string+in+reverse+order+with+comma+separated+after+3+char's.+If+you+want+you+can+change+the+position.|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|596917|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> window.format = function(b, a) {
 if (!b || isNaN(+a)) return a;
 var a = b.charAt(0) == "-" ? -a : +a,
 j = a &lt; 0 ? a = -a : 0,
 e = b.match(/[^\d\-\+#]/g),
 h = e &amp;&amp; e[e.length - 1] || ".",
 e = e &amp;&amp; e[1] &amp;&amp; e[0] || ",",
 b = b.split(h),
 a = a.toFixed(b[1] &amp;&amp; b[1].length),
 a = +a + "",
 d = b[1] &amp;&amp; b[1].lastIndexOf("0"),
 c = a.split(".");
 if (!c[1] || c[1] &amp;&amp; c[1].length &lt;= d) a = (+a).toFixed(d + 1);
 d = b[0].split(e);
 b[0] = d.join("");
 var f = b[0] &amp;&amp; b[0].indexOf("0");
 if (f &gt; -1)
 for (; c[0].length &lt; b[0].length - f;) c[0] = "0" + c[0];
 else +c[0] == 0 &amp;&amp; (c[0] = "");
 a = a.split(".");
 a[0] = c[0];
 if (c = d[1] &amp;&amp; d[d.length -
 1].length) {
 for (var d = a[0], f = "", k = d.length % c, g = 0, i = d.length; g &lt; i; g++) f += d.charAt(g), !((g - k + 1) % c) &amp;&amp; g &lt; i - c &amp;&amp; (f += e);
 a[0] = f
 }
 a[1] = b[1] &amp;&amp; a[1] ? h + a[1] : "";
 return (j ? "-" : "") + a[0] + a[1]
 };

var str="1234567890";
var formatstr=format( "##,###.", str);
alert(formatstr);


This will split the string in reverse order with comma separated after 3 char's. If you want you can change the position.
</code></pre>

blocks|key|596962|text|下面这小段代码怎么样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|596963|function+splitME(str,+size)+{
++++let+subStr+=+new+RegExp('.{1,'+%2B+size+%2B+'}',+'g');
++++return+str.match(subStr);
};|code-block|syntax|javascript|596964|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

What about this small piece of code:

<pre><code>function splitME(str, size) {
 let subStr = new RegExp('.{1,' + size + '}', 'g');
 return str.match(subStr);
};
</code></pre>

blocks|key|812371|text|function+chunkString(str,+length+=+10)+{
++++let+result+=+[],
++++++++offset+=+0;
++++if+(str.length+<=+length)+return+result.push(str)+&&+result;
++++while+(offset+<+str.length)+{
++++++++result.push(str.substr(offset,+length));
++++++++offset+%2B=+length;
++++}
++++return+result;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|812372|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function chunkString(str, length = 10) {
 let result = [],
 offset = 0;
 if (str.length &lt;= length) return result.push(str) &amp;&amp; result;
 while (offset &lt; str.length) {
 result.push(str.substr(offset, length));
 offset += length;
 }
 return result;
}
</code></pre>

I would like to split a very large string (let's say, 10,000 characters) into N-size chunks.

What would be the best way in terms of performance to do this?

For instance:
<code>"1234567890"</code> split by 2 would become <code>["12", "34", "56", "78", "90"]</code>.

Would something like this be possible using <a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/match"><code>String.prototype.match</code></a> and if so, would that be the best way to do it in terms of performance?

Split large string in n-size chunks in JavaScript

我想将一个非常大的字符串(比方说，10,000个字符)分成N个大小的块。在性能方面，什么是实现这一目标的最佳方法？例如:除以2的"1234567890"将变成["12", "34", "56", "78", "90"]。使用可以做到这一点吗?如果可以，从性能上来说，这是不是最好的方法？

问在JavaScript中将大字符串拆分成n大小的块
EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在JavaScript中将大字符串拆分成n大小的块EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在JavaScript中将大字符串拆分成n大小的块
EN