Split string once in JavaScript?

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)];

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

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]).

one liner and imo, simpler:

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

This returns " am super | cool | yea!"

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

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

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)

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", '|');

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.

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

Just as evil as most of the answers so far:

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

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

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 [];

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 != ''))

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

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.