Split string once in javascript?

Question

How can I split a string only once, i.e. make 1|Ceci n'est pas une pipe: | Oui parse to: ["1", "Ceci n'est pas une pipe: | Oui"]?

The limit in split doesn't seem to help...

Answer 1

var str = "1|Ceci n'est pas une pipe: | Oui";
str.split(/(?<!\|.*)\|/s);

With this regex, it will find "|" before which there is no "|", so only the first "|".

Answer 2

You could split the string into an array, then concatenate all but the first element into a string.

const text = 'a=b=c=d'
const [key, ...values] = text.split('=')
const value = values.join('=')
console.log(key, value)

Answer 3

You can also split on a regex that matches everything

const str = "one | two | three | four"
const [first, second] = str.split(/\|(.*)/s) // [ 'one ', ' two | three | four', '' ]

I don't know why there's an empty string, you can just ignore it. Just don't forget to add s (see documentation) to the end of the regular expression, otherwise it will split until the first newline.

Answer 4

This is an old question, but if u need to loop through strings, and have multiple separators, use regexp for your match cases, like this:

let exampleRegexp = />|<|=|\||(?:and|not|etc)/

let strings = ["left | middle | right", "yes and not yes"]

function splitOnce(str, regexp){
    let check = regexp.exec(str)
    let tail = str.slice(check.index + check.toString().length)
    let head = str.substring(0, check.index)
    return [head, tail]
}

for(let str of strings){
    let [head, tail] = splitOnce(str, exampleRegexp)
    console.log(head + ":::" + tail)
}

Answer 5

More effective method:

const str = "1|Ceci n'est pas une pipe: | Oui"

const [head] = str.split('|', 1);

const result = [head, str.substr(head.length + 1)]

console.log(result);

Answer 6

if you wanna use a "pipeline", reduce is your friend

const separator = '|'
jsonNode.split(separator)
   .reduce((previous, current, index) =>
    {
        if (index < 2) previous.push(current)
        else previous[1] += `${separator}${current}`
        return previous
    }, [])
    .map((item: string) => (item.trim()))
    .filter((item: string) => (item != ''))

Answer 7

ES6 syntax allows a different approach:

function splitOnce(s, on) {
   [first, ...rest] = s.split(on)
   return [first, rest.length > 0? rest.join(on) : null]
}

Which also handles the eventuality of the string not having a | by returning null rather than an empty string, which is more explicit.

splitOnce("1|Ceci n'est pas une pipe: | Oui", "|")
>>> ["1", "Ceci n'est pas une pipe: | Oui"]

splitOnce("Celui-ci n'a pas de pipe symbol!", "|")
>>> ["Celui-ci n'a pas de pipe symbol!", null]

Pas de pipe? C'est null!

I added this reply primarily so I could make a pun on the pipe symbol, but also to show off es6 syntax - its amazing how many people still don't use it...

Answer 8

This one's a little longer, but it works like I believe limit should:

function split_limit(inString, separator, limit){
    var ary = inString.split(separator);
    var aryOut = ary.slice(0, limit - 1);
    if(ary[limit - 1]){
        aryOut.push(ary.slice(limit - 1).join(separator));
    }
    return aryOut;
}
console.log(split_limit("1|Ceci n'est pas une pipe: | Oui","|", 1));
console.log(split_limit("1|Ceci n'est pas une pipe: | Oui","|", 2));
console.log(split_limit("1|Ceci n'est pas une pipe: | Oui","|", 3));
console.log(split_limit("1|Ceci n'est pas une pipe: | Oui","|", 7));

https://jsfiddle.net/2gyxuo2j/

limit of Zero returns funny results, but in the name of efficiency, I left out the check for it. You can add this as the first line of the function if you need it:

if(limit < 1) return [];

Answer 9

If the string doesn't contain the delimiter @NickCraver's solution will still return an array of two elements, the second being an empty string. I prefer the behavior to match that of split. That is, if the input string does not contain the delimiter return just an array with a single element.

var splitOnce = function(str, delim) {
    var components = str.split(delim);
    var result = [components.shift()];
    if(components.length) {
        result.push(components.join(delim));
    }
    return result;
};

splitOnce("a b c d", " "); // ["a", "b c d"]
splitOnce("a", " "); // ["a"]

Answer 10

one liner and imo, simpler:

var str = 'I | am super | cool | yea!';
str.split('|').slice(1).join('|');

This returns " am super | cool | yea!"

Answer 11

An alternate, short approach, besides the goods ones elsewhere, is to use replace()'s limit to your advantage.

var str = "1|Ceci n'est pas une pipe: | Oui";
str.replace("|", "aUniquePhraseToSaySplitMe").split("aUniquePhraseToSaySplitMe");

As @sreservoir points out in the comments, the unique phrase must be truly unique--it cannot be in the source you're running this split over, or you'll get the string split into more pieces than you want. An unprintable character, as he says, may do if you're running this against user input (i.e., typed in a browser).

Answer 12

This isn't a pretty approach, but works with decent efficiency:

var string = "1|Ceci n'est pas une pipe: | Oui";
var components = string.split('|');
alert([components.shift(), components.join('|')]​);​​​​​

Here's a quick demo of it

Answer 13

Just as evil as most of the answers so far:

var splits = str.split('|');
splits.splice(1, splits.length - 1, splits.slice(1).join('|'));

Answer 14

You'd want to use String.indexOf('|') to get the index of the first occurrence of '|'.

var i = s.indexOf('|');
var splits = [s.slice(0,i), s.slice(i+1)];

Answer 15

use the javascript regular expression functionality and take the first captured expression.

the RE would probably look like /^([^|]*)\|/.

actually, you only need /[^|]*/ if you validated that the string is formatted in such a way, due to javascript regex greediness.

Answer 16

Try this:

function splitOnce(input, splitBy) {
    var fullSplit = input.split(splitBy);
    var retVal = [];
    retVal.push( fullSplit.shift() );
    retVal.push( fullSplit.join( splitBy ) );
    return retVal;
}

var whatever = splitOnce("1|Ceci n'est pas une pipe: | Oui", '|');

Answer 17

You can use:

var splits = str.match(/([^|]*)\|(.*)/);
splits.shift();

The regex splits the string into two matching groups (parenthesized), the text preceding the first | and the text after. Then, we shift the result to get rid of the whole string match (splits[0]).