正如标题所说，我有一个字符串，我想分成长度为n个字符的段。
例如：
var str = 'abcdefghijkl';
在n = 3的一些魔法之后，将成为
var arr = ['abc','def','ghi','jkl'];
有一种优雅的方式来做到这一点？
var str = 'abcdefghijkl';
console.log(str.match(/.{1,3}/g));注意：使用{1,3}而不仅仅是{3}来包含不是3的倍数的字符串长度的余数，例如：
console.log("abcd".match(/.{1,3}/g)); // ["abc", "d"]更多细微之处：
.将不会捕获这些换行符。请改用/[\s\S]{1,3}/。 （谢谢@Mike）。match()将返回null。通过附加|| []来防止这种情况。所以你最终会得到：
var str = 'abcdef \t\r\nghijkl';
var parts = str.match(/[\s\S]{1,3}/g) || [];
console.log(parts);
console.log(''.match(/[\s\S]{1,3}/g) || []);使用.split：
var arr = str.split( /(?<=^(?:.{3})+)(?!$)/ ) // [ 'abc', 'def', 'ghi', 'jkl' ]
和.replace将是：
var replaced = str.replace( /(?<=^(.{3})+)(?!$)/g, ' || ' ) // 'abc || def || ghi || jkl'
qazxsw poi是在结束qazxsw poi之前停止，没有：
/(?!$)/忽略组/$/ ... var arr = str.split( /(?<=^(?:.{3})+)/ ) // [ 'abc', 'def', 'ghi', 'jkl' ] // I don't know why is not [ 'abc', 'def', 'ghi', 'jkl' , '' ], comment?
var replaced = str.replace( /(?<=^(.{3})+)/g, ' || ') // 'abc || def || ghi || jkl || '
不需要/(?:但是在)/中添加组到arr：
.replace如果你不想使用正则表达式......
var chunks = [];
for (var i = 0, charsLength = str.length; i < charsLength; i += 3) {
chunks.push(str.substring(i, i + 3));
}
...否则正则表达式解决方案非常好:)
str.match(/.{3}/g); // => ['abc', 'def', 'ghi', 'jkl']
在此问题的先前答案的基础上;以下函数将分割字符串（str）的n个数字（size）。
function chunk(str, size) {
return str.match(new RegExp('.{1,' + size + '}', 'g'));
}
(function() {
function chunk(str, size) {
return str.match(new RegExp('.{1,' + size + '}', 'g'));
}
var str = 'HELLO WORLD';
println('Simple binary representation:');
println(chunk(textToBin(str), 8).join('\n'));
println('\nNow for something crazy:');
println(chunk(textToHex(str, 4), 8).map(function(h) { return '0x' + h }).join(' '));
// Utiliy functions, you can ignore these.
function textToBin(text) { return textToBase(text, 2, 8); }
function textToHex(t, w) { return pad(textToBase(t,16,2), roundUp(t.length, w)*2, '00'); }
function pad(val, len, chr) { return (repeat(chr, len) + val).slice(-len); }
function print(text) { document.getElementById('out').innerHTML += (text || ''); }
function println(text) { print((text || '') + '\n'); }
function repeat(chr, n) { return new Array(n + 1).join(chr); }
function textToBase(text, radix, n) {
return text.split('').reduce(function(result, chr) {
return result + pad(chr.charCodeAt(0).toString(radix), n, '0');
}, '');
}
function roundUp(numToRound, multiple) {
if (multiple === 0) return numToRound;
var remainder = numToRound % multiple;
return remainder === 0 ? numToRound : numToRound + multiple - remainder;
}
}());#out {
white-space: pre;
font-size: 0.8em;
}<div id="out"></div>function chunk(er){
return er.match(/.{1,75}/g).join('\n');
}
以上功能是我用于Base64分块的功能。它将创建75个字符的换行符。
我的解决方案（ES6语法）：
const source = "8d7f66a9273fc766cd66d1d";
const target = [];
for (
const array = Array.from(source);
array.length;
target.push(array.splice(0,2).join(''), 2));
我们甚至可以创建一个函数：
function splitStringBySegmentLength(source, segmentLength) {
if (!segmentLength || segmentLength < 1) throw Error('Segment length must be defined and greater than/equal to 1');
const target = [];
for (
const array = Array.from(source);
array.length;
target.push(array.splice(0,segmentLength).join('')));
return target;
}
然后，您可以以可重用的方式轻松调用该函数：
const source = "8d7f66a9273fc766cd66d1d";
const target = splitStringBySegmentLength(source, 2);
干杯
const chunkStr = (str, n, acc) => {
if (str.length === 0) {
return acc
} else {
acc.push(str.substring(0, n));
return chunkStr(str.substring(n), n, acc);
}
}
const str = 'abcdefghijkl';
const splittedString = chunkStr(str, 3, []);
没有REGEX的清洁解决方案
不使用正则表达式的一些干净的解
/**
* Create array with maximum chunk length = maxPartSize
* It work safe also for shorter strings than part size
**/
function convertStringToArray(str, maxPartSize){
const chunkArr = [];
let leftStr = str;
do {
chunkArr.push(leftStr.substring(0, maxPartSize));
leftStr = leftStr.substring(maxPartSize, leftStr.length);
} while (leftStr.length > 0);
return chunkArr;
};
用法示例 - https://jsfiddle.net/maciejsikora/b6xppj4q/。
我还尝试将我的解决方案与正确的正则答案进行比较。一些测试可以在jsfiddle - https://jsfiddle.net/maciejsikora/2envahrk/上找到。测试显示两种方法都有类似的性能，也许在第一次看regexp解决方案稍快一点，但判断它自己。
在这里，我们每隔n个字符散布一个字符串和另一个字符串：
export const intersperseString = (n: number, intersperseWith: string, str: string): string => {
let ret = str.slice(0,n), remaining = str;
while (remaining) {
let v = remaining.slice(0, n);
remaining = remaining.slice(v.length);
ret += intersperseWith + v;
}
return ret;
};
如果我们使用上面这样：
console.log(splitString(3,'|', 'aagaegeage'));
我们得到：
| | | | | ed | e
在这里我们也这样做，但推送到一个数组：
export const sperseString = (n: number, str: string): Array<string> => {
let ret = [], remaining = str;
while (remaining) {
let v = remaining.slice(0, n);
remaining = remaining.slice(v.length);
ret.push(v);
}
return ret;
};
然后运行它：
console.log(sperseString(5, 'foobarbaztruck'));
我们得到：
['fooba'，'rbazt'，'jerk']
如果有人知道一种简化上述代码的方法，lmk，但它应该适用于字符串。