¿Dividir cadena una vez en javascript?

¿Cómo puedo dividir una cadena solo una vez, es decir, hacer un 1|Ceci n'est pas une pipe: | Ouianálisis de ["1", "Ceci n'est pas une pipe: | Oui"]:?

El límite en split no parece ayudar ...

Este no es un enfoque agradable, pero funciona con una eficiencia decente:

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

Aquí hay una demostración rápida

Desearía usar String.indexOf('|')para obtener el índice de la primera aparición de '|'.

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

Puedes usar:

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

La expresión regular divide la cadena en dos grupos coincidentes (entre paréntesis), el texto que precede al primero | y el texto siguiente. Luego, obtenemos shiftel resultado para deshacernos de toda la cadena match ( splits[0]).

un trazador de líneas y en mi opinión, más simple:

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

Esto devuelve "soy super | genial | yea!"

La sintaxis de ES6 permite un enfoque diferente:

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

Lo que también maneja la eventualidad de que la cadena no tenga un |retorno nulo en lugar de una cadena vacía, que es más explícita.

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!

Agregué esta respuesta principalmente para poder hacer un juego de palabras con el símbolo de la tubería, pero también para mostrar la sintaxis de es6: es sorprendente cuántas personas todavía no lo usan ...

Prueba esto:

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

Si la cadena no contiene el delimitador, la solución de @ NickCraver aún devolverá una matriz de dos elementos, siendo el segundo una cadena vacía. Prefiero que el comportamiento coincida con el de la división. Es decir, si la cadena de entrada no contiene el delimitador, devuelve solo una matriz con un solo elemento.

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

Tan malvado como la mayoría de las respuestas hasta ahora:

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

Un enfoque alternativo y corto, además de los de bienes en otros lugares, es utilizar replace()el límite a su favor.

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

Como señala @sreservoir en los comentarios, la frase única debe ser verdaderamente única: no puede estar en la fuente sobre la que está ejecutando esta división, o la cadena se dividirá en más partes de las que desea. Un carácter no imprimible, como él dice, puede funcionar si está ejecutando esto contra la entrada del usuario (es decir, escrito en un navegador).

Este es un poco más largo, pero funciona como creo que el límite debería:

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 devuelve resultados divertidos, pero en nombre de la eficiencia, dejé el cheque. Puede agregar esto como la primera línea de la función si lo necesita:

if(limit < 1) return [];

si quieres utilizar una "canalización", ¿ reducees tu amigo?

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

Método más eficaz:

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

use la funcionalidad de expresión regular de JavaScript y tome la primera expresión capturada.

el RE probablemente se vería así /^([^|]*)\|/.

en realidad, solo necesita /[^|]*/si ha validado que la cadena está formateada de tal manera, debido a la codicia de las expresiones regulares de JavaScript.