지정된 문자의 첫 번째 인스턴스에서만 문자열 분할

지정된 문자의 첫 번째 인스턴스에서만 문자열 분할

합니다._배열의 두 번째 항목을 잡습니다.

var element = $(this).attr('class');
var field = element.split('_')[1];

이 걸린다good_luck에게 '나에게'를 한다.luck가 좋다 효과가 좋다!

은 ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★good_luck_buddyjavascript를 요?_ 나에게 ★★★★★★★★★★★★★★★★★★★★★.luck_buddy

는 이것을 했다.var field = element.split(new char [] {'_'}, 2);c# stackoverflow는 동작하지 않습니다.jsFiddle에서 요.

캡처 괄호 사용:

'good_luck_buddy'.split(/_(.*)/s)
['good', 'luck_buddy', ''] // ignore the third element

다음과 같이 정의됩니다.

ifseparator에는 캡처 괄호가 포함되어 있으며 일치하는 결과가 배열로 반환됩니다.

이 ._.*됨(즉, split separator)_그러나 결과에는 구분자의 일부(즉, 그 이후의 모든 것)도 포함됩니다._를 참조해 주세요.

에서는 separator하는 것)_(.*)는 )개요_luck_buddy된 그룹내은 '세퍼레이터입니다.lucky_buddy,luck_buddy (비밀(이행).*는이므로 결과 .split구분자가 결과에 포함되지 않는다는 것을 의미합니다.

regex 플래그를 사용하여.\n문자도 마찬가지입니다.그렇지 않으면 첫 번째 줄바꿈으로만 분할됩니다.

정규 표현과 어레이가 필요한 이유는 무엇입니까?

myString = myString.substring(myString.indexOf('_')+1)

var myString= "hello_there_how_are_you"
myString = myString.substring(myString.indexOf('_')+1)
console.log(myString)

나는 무슨 일이 있어도 RegExp를 피한다.다음 작업을 수행할 수 있습니다.

"good_luck_buddy".split('_').slice(1).join('_')

할당을 파기함으로써 보다 읽기 쉽게 할 수 있습니다.

let [first, ...rest] = "good_luck_buddy".split('_')
rest = rest.join('_')

문자열의 첫 번째 키와 나머지 부분을 모두 얻는 간단한 ES6 방법은 다음과 같습니다.

 const [key, ...rest] = "good_luck_buddy".split('_')
 const value = rest.join('_')
 console.log(key, value) // good, luck_buddy

오늘날에는 분할 횟수를 제한할 수 있습니다.

str.split([separator[, limit]])

...

제한 임의

A음이 아닌 정수 스플릿의 수를 제한하다.제공된 경우, 지정된 분리기의 각 발생에 있었지만, 멈추제한 항목이 배열에 놓여 있는 문자열을 분할한다.남아 있는 자리라면 어떤 텍스트 배열의 전혀 포함되지 않습니다.

전에 한계에 도달한 경우 문자열의 끝에 배열 한계보다 적은 항목 포함할 수 있다.만약 제한은 0, 침목을 수행한다.

절차 정지

그것은 기대한 길을 가지 않을 수 있습니다.게 구분 기호의 나머지를 무시하지만, 그때 그것은 한계치에 도달하면 대신에, 다시 반환 결과를 통해 이별 뒤에 그 부분을 생략하는 것은 남아 있는 문자열을 서로 갈라놓기를 바라고 있었다.

let str = 'A_B_C_D_E'
const limit_2 = str.split('_', 2)
limit_2
(2) ["A", "B"]
const limit_3 = str.split('_', 3)
limit_3
(3) ["A", "B", "C"]

나는 다음을 바라고 있었다.

let str = 'A_B_C_D_E'
const limit_2 = str.split('_', 2)
limit_2
(2) ["A", "B_C_D_E"]
const limit_3 = str.split('_', 3)
limit_3
(3) ["A", "B", "C_D_E"]

이 솔루션은 나에게 효과가 있었다

var str = "good_luck_buddy";
var index = str.indexOf('_');
var arr = [str.slice(0, index), str.slice(index + 1)];

//arr[0] = "good"
//arr[1] = "luck_buddy"

또는

var str = "good_luck_buddy";
var index = str.indexOf('_');
var [first, second] = [str.slice(0, index), str.slice(index + 1)];

//first = "good"
//second = "luck_buddy"

첫 번째 인스턴스를 고유한 자리 표시자로 바꾼 다음 여기에서 분할합니다.

"good_luck_buddy".replace(/\_/,'&').split('&')

["good","luck_buddy"]

이것은 분할의 양쪽이 필요한 경우에 더욱 편리합니다.

다음과 같은 정규 표현을 사용할 수 있습니다.

var arr = element.split(/_(.*)/)

분할의 한계를 지정하는 두 번째 매개 변수를 사용할 수 있습니다. 즉, var field = element.select_', 1)[1];

현의 두 부분이 필요하니까, regex 뒷모습 좀 봐주세요.

const full_name = 'Maria do Bairro';
const [first_name, last_name] = full_name.split(/(?<=^[^ ]+) /);
console.log(first_name);
console.log(last_name);

비정규 솔루션

몇 가지 벤치마크를 실시했는데, 이 솔루션이 ¹큰 성공을 거두었습니다.

str.slice(str.indexOf(delim) + delim.length)

// as function
function gobbleStart(str, delim) {
    return str.slice(str.indexOf(delim) + delim.length);
}

// as polyfill
String.prototype.gobbleStart = function(delim) {
    return this.slice(this.indexOf(delim) + delim.length);
};

다른 솔루션과의 퍼포먼스 비교

하게 아슬아슬한 단, 사용법은 동일했다.substrslice.

내가 시도했던 다른 솔루션들split ★★★★★★★★★★★★★★★★★」RegExps는 퍼포먼스가 크게 저하되어 약 2배 정도 느려졌습니다.사용.join의 split물론 퍼포먼스 패널티가 추가됩니다.

왜 이렇게 느려?새로운 오브젝트 또는 어레이를 작성해야 할 때마다 JS는 OS에 메모리 청크를 요청해야 합니다.이 과정은 매우 느립니다.

벤치마크를 추구할 경우에 대비하여 다음과 같은 일반적인 가이드라인을 제시하겠습니다.

• 의 {} 어레이 " " "[]처럼)splitcreates.
• RegExp검색은 문자열 검색보다 더 복잡하기 때문에 속도가 느립니다.
• 어레이가 이미 있는 경우 어레이를 명시적으로 인덱싱하는 것만큼 빠르게 파괴할 수 있어 보기에도 좋습니다.

첫 번째 인스턴스 이후 제거

다음은 n번째 인스턴스까지를 포함하는 솔루션입니다.그렇게 빠르진 않지만 작전부의 질문에 따르면gobble(element, '_', 1) 2배 .RegExp ★★★★★★★★★★★★★★★★★」split 및 더많은 작업을 할 수 .

/*
`gobble`, given a positive, non-zero `limit`, deletes
characters from the beginning of `haystack` until `needle` has
been encountered and deleted `limit` times or no more instances
of `needle` exist; then it returns what remains. If `limit` is
zero or negative, delete from the beginning only until `-(limit)`
occurrences or less of `needle` remain.
*/
function gobble(haystack, needle, limit = 0) {
  let remain = limit;
  if (limit <= 0) { // set remain to count of delim - num to leave
    let i = 0;
    while (i < haystack.length) {
      const found = haystack.indexOf(needle, i);
      if (found === -1) {
        break;
      }
      remain++;
      i = found + needle.length;
    }
  }

  let i = 0;
  while (remain > 0) {
    const found = haystack.indexOf(needle, i);
    if (found === -1) {
      break;
    }
    remain--;
    i = found + needle.length;
  }
  return haystack.slice(i);
}

" " " 입니다.gobble('path/to/file.txt', '/') 이름을 알려주고, 파일명을 알려준다.gobble('prefix_category_item', '_', 1)이 답변의 첫 번째 솔루션과 같이 프레픽스를 삭제합니다.

---

1. 테스트는 MacOSX 10.14의 Chrome 70.0.3538.110에서 실행되었습니다.

string 메서드를 regex와 함께 사용합니다.

var result = "good_luck_buddy".replace(/.*?_/, "");
console.log(result);

은 첫 번째 앞에 합니다._및 , 。_그 자체입니다.그 후 일치는 빈 문자열로 대체됩니다.

의 JavascriptString.split안타깝게도 실제 분할 횟수를 제한할 방법이 없습니다.반환되는 실제 분할 항목 수를 지정하는 두 번째 인수가 있습니다. 이 인수는 사용자의 경우 유용하지 않습니다.해결책은 문자열을 분할하고 첫 번째 항목을 꺼낸 다음 나머지 항목에 다시 가입하는 것입니다.

var element = $(this).attr('class');
var parts = element.split('_');

parts.shift(); // removes the first item from the array
var field = parts.join('_');

여기 RegExp가 있습니다.

'good_luck_buddy' . split(/^.*?_/)[1] 

우선, 「^」로 매치를 개시하도록 강제합니다.그런 다음 '_'가 아닌 임의의 수의 문자와 일치합니다.즉, 첫 번째 '_' 앞에 있는 모든 문자와 일치합니다.

'?'는 패턴 전체를 일치시키는 최소 문자 수를 의미하며, 그 뒤에 '_'가 이어지기 때문에 '.*?'가 매치됩니다.

따라서 이 split()는 일치하는 부분을 'splitter'로 사용하여 결과에서 삭제합니다.따라서 첫 번째 '_'를 포함한 모든 항목을 제거하고 나머지는 결과의 두 번째 요소로 제공합니다.첫 번째 요소는 일치하는 부품 앞의 부품을 나타내는 "입니다.처음부터 시합이 시작됐기 때문에" 입니다.

이전 답변에서 Chandu가 제공한 /_(.*)/와 같이 작동하는 다른 RegExp가 있습니다.

/^.*?_/는, 치환에 의해서 행해지는 특별한 역할에 대해 알 필요 없이, 무엇을 하는지 이해할 수 있는 장점이 있습니다.

Mark F의 솔루션은 훌륭하지만 오래된 브라우저에서는 지원되지 않습니다.Kennebec의 솔루션은 훌륭하고 오래된 브라우저에서 지원되지만 regex는 지원하지 않습니다.

오래된 브라우저에서 지원되며 regex를 지원하는 스트링을 한 번만 분할하는 솔루션을 찾고 있다면 다음과 같은 솔루션이 있습니다.

String.prototype.splitOnce = function(regex)
{
    var match = this.match(regex);
    if(match)
    {
        var match_i = this.indexOf(match[0]);
        
        return [this.substring(0, match_i),
        this.substring(match_i + match[0].length)];
    }
    else
    { return [this, ""]; }
}

var str = "something/////another thing///again";

alert(str.splitOnce(/\/+/)[1]);

저와 같이 정규 표현에 익숙하지 않은 초보자에게는 이 회피책이 효과가 있었습니다.

   var field = "Good_Luck_Buddy";
   var newString = field.slice( field.indexOf("_")+1 );

slice() 메서드는 문자열의 일부를 추출하여 새 문자열을 반환하고 indexOf() 메서드는 문자열에서 지정된 값이 처음 발견된 위치를 반환합니다.

보다 현대적인 방법을 찾고 있는 경우:

let raw = "good_luck_buddy"

raw.split("_")
    .filter((part, index) => index !== 0)
    .join("_")

이건 꽤 빠를 거야

function splitOnFirst (str, sep) {
  const index = str.indexOf(sep);
  return index < 0 ? [str] : [str.slice(0, index), str.slice(index + sep.length)];
}

console.log(splitOnFirst('good_luck', '_')[1])
console.log(splitOnFirst('good_luck_buddy', '_')[1])

이것은 Chrome + FF에서 작동했습니다.

"foo=bar=beer".split(/^[^=]+=/)[1] // "bar=beer"
"foo==".split(/^[^=]+=/)[1] // "="
"foo=".split(/^[^=]+=/)[1] // ""
"foo".split(/^[^=]+=/)[1] // undefined

키도 필요한 경우는, 다음의 조작을 실시해 주세요.

"foo=bar=beer".split(/^([^=]+)=/) // Array [ "", "foo", "bar=beer" ]
"foo==".split(/^([^=]+)=/) // [ "", "foo", "=" ]
"foo=".split(/^([^=]+)=/) // [ "", "foo", "" ]
"foo".split(/^([^=]+)=/) // [ "foo" ]

//[0] = ignored (holds the string when there's no =, empty otherwise)
//[1] = hold the key (if any)
//[2] = hold the value (if any)

첫 번째 키와 나머지 부품을 얻기 위한 간단한 es6 원스테이트먼트 솔루션

let raw = 'good_luck_buddy'

raw.split('_')
   .reduce((p, c, i) => i === 0 ? [c] : [p[0], [...p.slice(1), c].join('_')], [])

언급URL : https://stackoverflow.com/questions/4607745/split-string-only-on-first-instance-of-specified-character