以原型函数的形式:

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

我已经写了一个扩展函数，所以块长度也可以是一个数字数组，比如[1,3]

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++) {
            _ret[_i] = this.substring(_offset, _offset = _offset + 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 + o);
                if (chunk !== '') {
                    _ret.push(chunk);
                    n += chunk.length;
                }
            });
            if (n === 0) {
                return undefined; // prevent an endless loop when len = [0]
            }
        } while (n < l);
    }
    return _ret;
};

的代码

"1234567890123".chunkString([1,3])

将返回:

[ '1', '234', '5', '678', '9', '012', '3' ]

你绝对可以做一些

let pieces = "1234567890 ".split(/(.{2})/).filter(x => x.length == 2);

要得到这个:

[ '12', '34', '56', '78', '90' ]

如果你想动态输入/调整数据块的大小，使数据块的大小为n，你可以这样做:

n = 2;
let pieces = "1234567890 ".split(new RegExp("(.{"+n.toString()+"})")).filter(x => x.length == n);

要在原始字符串中找到所有大小为n的块，尝试这样做:

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 < n; i++){               //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
}

你应该得到:

[ '12', '23', '34', '45', '56', '67', '78', '89', '90', '0 ' ]

我创建了几个更快的变体，您可以在jsPerf上看到。我最喜欢的是这个:

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

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

  return chunks
}

这是一个解决方案，我想出了一个模板字符串后，一个小实验:

用法:

chunkString(5)`testing123`

函数chunkString(nSize) return (strToChunk) => { Let result = []; let chars = String(strToChunk).split("); 对于(设I = 0;i < (String(strToChunk)。length / nSize);我+ +){ result = result.concat(char .slice(i*nSize，(i+1)*nSize).join(")); ｝ 返回结果 ｝ ｝ document . write (chunkString(5)“testing123”); //返回:testi,ng123 document . write (chunkString(3)“testing123”); //返回:tes,tin,g12,3

它将大字符串拆分为给定单词的小字符串。

function chunkSubstr(str, words) {
  var parts = str.split(" ") , values = [] , i = 0 , tmpVar = "";
  $.each(parts, function(index, value) {
      if(tmpVar.length < words){
          tmpVar += " " + value;
      }else{
          values[i] = tmpVar.replace(/\s+/g, " ");
          i++;
          tmpVar = value;
      }
  });
  if(values.length < 1 &&  parts.length > 0){
      values[0] = tmpVar;
  }
  return values;
}