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|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|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|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|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|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|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|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|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>

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|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|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|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|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|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|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>

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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