Raz podzielić ciąg w javascript?

W jaki sposób można podzielić ciąg tylko raz, tj make 1|Ceci n'est pas une pipe: | Ouiparse do: ["1", "Ceci n'est pas une pipe: | Oui"]?

Limit w splicie nie wydaje się pomagać ...

To nie jest ładne podejście, ale działa z przyzwoitą wydajnością:

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

Oto krótkie demo

Chciałbyś użyć, String.indexOf('|')aby uzyskać indeks pierwszego wystąpienia „|”.

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

Możesz użyć:

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

Wyrażenie regularne dzieli ciąg na dwie pasujące grupy (w nawiasach), tekst poprzedzający pierwszy | a tekst po. Wtedy myshift wynik, aby pozbyć się całego ciągu match ( splits[0]).

jedna wkładka i imo, prostsze:

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

Zwraca to „Jestem super | super | tak!”

Składnia ES6 pozwala na inne podejście:

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

Który również obsługuje ewentualność łańcucha nie zawierającego a |, zwracając wartość null zamiast pustego ciągu, co jest bardziej wyraźne.

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!

Dodałem tę odpowiedź przede wszystkim po to, aby móc zrobić kalambur na symbolu potoku, ale także po to, aby pochwalić się składnią es6 - to niesamowite, ile osób nadal jej nie używa ...

Spróbuj tego:

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

Jeśli ciąg nie zawiera separatora, rozwiązanie @ NickCraver nadal zwróci tablicę dwóch elementów, z których drugi będzie pusty. Wolę zachowanie pasujące do podziału. Oznacza to, że jeśli ciąg wejściowy nie zawiera separatora, zwraca tylko tablicę z pojedynczym elementem.

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

Tak samo złe, jak większość dotychczasowych odpowiedzi:

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

Alternatywnym, krótkim podejściem, oprócz towarów gdzie indziej, jest wykorzystanie replace()limitu na swoją korzyść.

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

Jak @sreservoir wskazuje w komentarzach, unikalna fraza musi być naprawdę wyjątkowa - nie może znajdować się w źródle, w którym przeprowadzasz ten podział, w przeciwnym razie łańcuch zostanie podzielony na więcej części niż chcesz. Znak niedrukowalny, jak mówi, może zrobić, jeśli uruchamiasz to na podstawie danych wejściowych użytkownika (tj. Wpisywanych w przeglądarce).

Ten jest trochę dłuższy, ale wydaje mi się, że limit powinien:

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 Zero zwraca śmieszne wyniki, ale w imię wydajności pominąłem sprawdzanie. Możesz dodać to jako pierwszy wiersz funkcji, jeśli tego potrzebujesz:

if(limit < 1) return [];

jeśli chcesz użyć „rurociągu”, reduceto twój przyjaciel

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

Bardziej skuteczna metoda:

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

użyj funkcji wyrażeń regularnych javascript i weź pierwsze przechwycone wyrażenie.

RE prawdopodobnie by wyglądał /^([^|]*)\|/.

w rzeczywistości potrzebujesz tylko /[^|]*/wtedy, gdy potwierdziłeś, że łańcuch jest sformatowany w taki sposób, ze względu na zachłanność wyrażeń regularnych javascript.