仅在分隔符的前 n 次出现处拆分字符串

Question

我想仅在分隔符的前 n 次出现处拆分字符串。我知道，我可以使用循环将它们加在一起，但没有更直接的方法吗？

var string = 'Split this, but not this';    
var result = new Array('Split', 'this,', 'but not this');

Answer 1

根据MDN：

string.split(separator, limit);

更新：

var string = 'Split this, but not this',
    arr = string.split(' '),
    result = arr.slice(0,2);

result.push(arr.slice(2).join(' ')); // ["Split", "this,", "but not this"]

更新第 2 版（缩短一个 slice）：

var string = 'Split this, but not this',
    arr = string.split(' '),
    result = arr.splice(0,2);

result.push(arr.join(' ')); // result is ["Split", "this,", "but not this"]

Answer 2

使用 Array.slice：

function splitWithTail(str,delim,count){
  var parts = str.split(delim);
  var tail = parts.slice(count).join(delim);
  var result = parts.slice(0,count);
  result.push(tail);
  return result;
}

结果：

splitWithTail(string," ",2)
// => ["Split", "this,", "but not this"]

Answer 3

split 和 join 与 ES6 特性的组合非常简洁：

let [str1, str2, ...str3] = string.split(' ');
str3 = str3.join(' ');

Answer 4

JavaScript“.split()”函数已经接受了第二个参数，给出了要执行的最大拆分次数。但是，它不会保留原始字符串的尾端；你必须把它粘回去。

另一种方法是使用正则表达式迭代地去除字符串的前导部分，当达到限制时停止。

var str = "hello out there cruel world";
var parts = [];
while (parts.length < 3) { // "3" is just an example
  str = str.replace(/^(\w+)\s*(.*)$/, function(_, word, remainder) {
    parts.push(word);
    return remainder;
  });
}
parts.push(str);

edit——我突然想到另一种简单的方法是只使用普通的“.split()”，去掉前几个部分，然后只使用“.slice() " 和 ".join()" 其余部分。

Answer 5

为此，您可以使用 Split(delimiter) 并选择一个分隔符。

var testSplit = "Split this, but not this";
var testParts= testSplit.Split(",");

var firstPart = testParts[1];

// firstPart = "Split this"

我的语法不是 100% 我已经有一段时间没有使用过 javascript。但我知道这就是它的完成方式......

编辑**对不起，我的错误。现在我相信我知道您的要求，并且我认为最简单的方法是使用 substr。非常简单，不需要循环。刚刚做了一个例子，效果很好

// so first, we want to get everything from 0 - the first occurence of the comma.
// next, we want to get everything after the first occurence of the comma.  (if you only define one parameter, substr will take everything after that parameter.

var testString = "Split this, but this part, and this part are one string";
var part1 = testString.substr(0,testString.indexOf(',')); 
var part2 = testString.substr(testString.indexOf(','));

//part1 = "Split this"
//part2= "but this part, and this part are one string"

Answer 6

var result = [string.split(' ',1).toString(), string.split(' ').slice(1).join(' ')];

结果：

["Split", "this, but not this"]

Answer 7

虽然你可以给split 一个限制，但你不会得到你说你想要的。不幸的是，您将不得不自己动手，例如：

var string = 'Split this, but not this';
var result = string.split(' ');

if (result.length > 3) {
    result[2] = result.slice(2).join(' ');
    result.length = 3;
}

但即便如此，你最终还是会修改后面部分的空格数。所以我可能只是用老式的 write-your-own-loop 方式来做：

function splitWithLimit(str, delim, limit) {
  var index,
      lastIndex = 0,
      rv = [];

  while (--limit && (index = str.indexOf(delim, lastIndex)) >= 0) {
    rv.push(str.substring(lastIndex, index));
    lastIndex = index + delim.length;
  }
  if (lastIndex < str.length) {
    rv.push(str.substring(lastIndex));
  }
  return rv;
}

Live copy

Answer 8

您好，我有同样的问题，只想拆分几次，找不到任何东西，所以我只是扩展了 DOM - 只是一个快速而肮脏的解决方案，但它有效:)

String.prototype.split = function(seperator,limit) {
    var value = "";
    var hops  = [];

    // Validate limit
    limit = typeof(limit)==='number'?limit:0;

    // Join back given value
    for ( var i = 0; i < this.length; i++ ) { value += this[i]; }

    // Walkthrough given hops
    for ( var i = 0; i < limit; i++ ) {
        var pos = value.indexOf(seperator);
        if ( pos != -1 ) {
            hops.push(value.slice(0,pos));
            value = value.slice(pos + seperator.length,value.length)

        // Done here break dat
        } else {
            break;
        }
    }
    // Add non processed rest and return
    hops.push(value)
    return hops;
}

你的情况是这样的

>>> "Split this, but not this".split(' ',2)
["Split", "this,", "but not this"]

Answer 9

健全的limit 实现的改进版本，具有适当的正则表达式支持：

function splitWithTail(value, separator, limit) {
    var pattern, startIndex, m, parts = [];

    if(!limit) {
        return value.split(separator);
    }

    if(separator instanceof RegExp) {
        pattern = new RegExp(separator.source, 'g' + (separator.ignoreCase ? 'i' : '') + (separator.multiline ? 'm' : ''));
    } else {
        pattern = new RegExp(separator.replace(/([.*+?^${}()|\[\]\/\\])/g, '\\$1'), 'g');
    }

    do {
        startIndex = pattern.lastIndex;
        if(m = pattern.exec(value)) {
            parts.push(value.substr(startIndex, m.index - startIndex));
        }
    } while(m && parts.length < limit - 1);
    parts.push(value.substr(pattern.lastIndex));

    return parts;
}

使用示例：

splitWithTail("foo, bar, baz", /,\s+/, 2); // -> ["foo", "bar, baz"]

专为 Chrome、Firefox、Safari、IE8+ 构建并经过测试。

Answer 10

又一个有限制的实现；

// takes string input only
function split(input, separator, limit) {
    input = input.split(separator);
    if (limit) {
        input = input.slice(0, limit - 1).concat(input.slice(limit - 1).join(separator));
    }
    return input;
}

Answer 11

ES2015

const splitAndAppend = (str, delim, count) => {
    const arr = str.split(delim);
    return [...arr.splice(0, count), arr.join(delim)];
}

复杂度O(n).

Answer 12

var s='Split this, but not this', a=s.split(','), b=a[0].split(' ');
b.push(a[1]);
alert(b);

alerts ['Split', 'this', 'but not this']

Answer 13

我刚刚写的另一个实现：

export function split(subject, separator, limit=undefined, pad=undefined) {
    if(!limit) {
        return subject.split(separator);
    }
    if(limit < 0) {
        throw new Error(`limit must be non-negative`);
    }
    let result = [];
    let fromIndex = 0;
    for(let i=1; i<limit; ++i) {
        let sepIdx = subject.indexOf(separator, fromIndex);
        if(sepIdx < 0) {
            break;
        }
        let substr = subject.slice(fromIndex, sepIdx);
        result.push(substr);
        fromIndex = sepIdx + separator.length;
    }
    result.push(subject.slice(fromIndex));
    while(result.length < limit) {
        result.push(pad);
    }
    return result;
}

不使用正则表达式，也不过度拆分和重新加入。

此版本完全保证limit 元素（如果没有足够的分隔符，将使用undefineds 填充）；这使得做这种 ES6 的东西是安全的：

let [a,b,c] = split('a$b','$',3,null);
// a = 'a', b = 'b', c = null

Answer 14

我喜欢使用shift。

function splitFirstN(str,n,delim){
    var parts = str.split(delim);
    var r = [];
    for(var i = 0; i < n; i++){
        r.push(parts.shift());
    }
    r.push(parts.join(delim));
    return r;
}

var str = 'Split this, but not this';    
var result = splitFirstN(str,2,' ');

Answer 15

没有什么是一个简单的正则表达式做不到的：

const string = 'Split this, but not this';
console.log(string.match(/^(\S+)\s*(\S+)?\s*([\s\S]+)?$/).slice(1));

Answer 16

在我的例子中，我试图解析 git grep stdout。所以我有一个 {filename}:{linenumber}:{context}。我不喜欢分裂然后加入。我们应该能够一次解析字符串。您可以简单地遍历每个字母并在前两个冒号上拆分。开箱即用的更快方法是使用 match 方法和正则表达式。

因此，

txt.match(/(.+):(\d+):(.*)/)

效果很好

Answer 17

我的通用版本支持 RegExp 和非 RegExp 分隔符。高度优化。提供的测试。 为什么：因为其他 RegExp 版本充满了错误，这不是一个微不足道的功能。

用法：

"a b  c   d".split_with_tail(/ +/,3) = ['a','b','c   d']
"a b  c   d".split_with_tail(' ',3) = ['a','b',' c   d']

代码

String.prototype.split_with_tail = function(delimiter,limit)
{
    if( typeof(limit) !== 'number' || limit < 1 ) return this.split(delimiter,limit);

    var parts = this.split(delimiter,limit+1);
    if( parts.length <= limit ) return parts;
    parts.splice(-2,2);

    limit = Math.floor(limit) - 1; // used later as index, speed optimization; limit can be float ..
    if( delimiter instanceof RegExp ) {
        // adds 'g' flag to any regexp:
        delimiter += '';
        var len = delimiter.lastIndexOf('/');
        delimiter = new RegExp(delimiter.slice(1, len), delimiter.slice(len + 1)+'g');

        len = 0;
        while(limit--) len += parts[limit].length + (delimiter.exec(this))[0].length;
    }
    else {
        var len = limit * (''+delimiter).length;
        while(limit--) len += parts[limit].length;
    }

    parts.push(this.substring(len)); // adds tail, finally
    return parts;
}

测试

function test(str,delimiter,limit,result) {
    if( JSON.stringify(result) !== JSON.stringify(str.split_with_tail(delimiter,limit)) ) {
        console.log(arguments);
        console.log(str.split_with_tail(delimiter,limit));
        throw "lol";
    }
}
test('',/ +/,undefined,['']);
test('',/ +/,3,['']);
test('a',/ +/,0.1,[]);
test('a',/ +/,1,['a']);
test('a a',/ +/,1,['a a']);
test('a a',/ +/,2.1,['a','a']);
test('a a a',/ +/,2.9,['a','a a']);
test('aaaaa aa a',/ +/,1,['aaaaa aa a']);
test('aaaaa aa a',/ +/,2,['aaaaa', 'aa a']);
test('a a',/ +/,2,['a','a']);
test('a',/ +/,3,['a']);
test('a a',/ +/,3,['a','a']);
test('a a  a',/ +/,3,['a','a','a']);
test('a a  a  a',/ +/,3,['a','a','a  a']);
test('a a  a  a',/ +/,4,['a','a','a','a']);
test('a aa  aaa  ',/ +/,4,['a','aa','aaa','']);
test('a a  a  a',/ +/,2,['a','a  a  a']);
test('a a  a  a',/ +/,1,['a a  a  a']);
test('a a  a  a',/ +/,0,[]);
test('a a  a  a',/ +/,undefined,['a','a','a','a']);
test('a a  a  a',/ +/,-1,['a','a','a','a']);

test('a',' ',3,['a']);
test('aaaaa aa a',' ',2,['aaaaa', 'aa a']);
test('aaaaa  aa  a','  ',2,['aaaaa','aa  a']);
test('a a a',' ',3,['a','a','a']);
test('a a a a',' ',3,['a','a','a a']);
test('a a  a a',' ',3,['a','a',' a a']);
test('a a  a a',' ',2,['a','a  a a']);
test('a a  a a',' ',1,['a a  a a']);
test('a a  a a',' ',0,[]);
test('a a  a a',' ',undefined,['a','a','','a','a']);
test('a a  a a',' ',-1,['a','a','','a','a']);
test('1232425',2,3,['1','3','425']);
console.log("good!");

Answer 18

就我而言，这解决了我的问题：

const splitted = path.split('/')
const core = splittedPath.slice(0, 2)
const rest = splittedPath.slice(2).join('/')
const result = [...core, rest]

Answer 19

对于仅拆分第一个匹配项的特定情况，下面的代码也很有用。在我的测试中，它的性能比most voted answer 好很多（Chrome 大约 40%，Firefox 大约 200%）。

https://jsbench.me/nckrqnwcry/1

function split(term = '', sep = ',') {
    const split = term.split(sep, 1);
    return [split[0], term.substr(split[0].length + sep.length)];
}