@ VictorSchröder Не думаю, что это вызвало бы много путаницы, но я все же отредактировал.

м коде я разбил строку на основе_ и возьмите второй элемент в массиве.

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

принимаетgood_luck и предоставляет мнеluck, Работает отлично!

Но теперь у меня есть класс, который выглядит какgood_luck_buddy, Как я могу получить мой JavaScript, чтобы игнорировать второй_ и дай мнеluck_buddy?

я нашел этоvar field = element.split(new char [] {'_'}, 2); в ответе c # stackoverflow, но он не работает. Я попробовал это в jsFiddle ...

Ответы на вопрос(13)

как я, который не привык к регулярным выражениям, это обходное решение сработало:

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

Метод slice () извлекает часть строки и возвращает новую строку, а метод indexOf () возвращает позицию первого найденного вхождения указанного значения в строке.

 Victor Schröder07 февр. 2019 г., 01:06
Это не обходной путь, а правильный способ сделать это;)
Решение Вопроса

использованиезахват скобок:

"good_luck_buddy".split(/_(.+)/)[1]
"luck_buddy"

Они определены как

Еслиseparator содержит круглые скобки, соответствующие результаты возвращаются в массив.

Так что в этом случае мы хотим разделить на_.+ (то есть разделитель-разделитель является подстрокой, начинающейся с_) но и пусть результат содержит некоторую часть нашего разделителя (т.е.все после_).

В этом примере наш разделитель (соответствующий_(.+)) является_luck_buddy и захваченная группа (внутри разделителя)lucky_buddy, Без скобокluck_buddy (соответствие.+) не был бы включен в массив результатов, как в случае с простымsplit что разделители не включены в результат.

 Alan Moore05 янв. 2011 г., 21:04
Просто чтобы быть ясно, причина этого решения в том, что все после первого_ сопоставляется внутри группы захвата и по этой причине добавляется в список токенов.
 Ofeargall05 янв. 2011 г., 19:43
Очень элегантный. Работает как шарм. Спасибо.
 Mark F05 янв. 2011 г., 19:32
Вам даже не нужно (?), Просто используйте /_(.+)/, чтобы захватить еще 1 символов после первого _
 katy lavallee08 мая 2014 г., 19:42
Кто-нибудь знает, почему я получаю дополнительный пустой строковый элемент с этим: в:"Aspect Ratio: 16:9".split(/:(.+)/) вне:["Aspect Ratio", " 16:9", ""]
 ifightcrime18 июн. 2012 г., 23:14
Я не мог заставить это работать в IE8

replace() метод срегулярное выражение:

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

Это регулярное выражение соответствует 0 или более символов перед первым_и_ сам. Затем совпадение заменяется пустой строкой.

 James T08 февр. 2019 г., 22:52
@ VictorSchröder, как вы ожидаете увидеть вывод фрагмента безdocument.body.innerHTML?
 Victor Schröder10 февр. 2019 г., 14:58
document.body зависит от наличия DOM и не будет работать в чистой среде JavaScript.console.log для этого достаточно или просто оставьте результат в переменной для проверки.
 Victor Schröder07 февр. 2019 г., 01:05
document.body.innerHTML часть здесь совершенно бесполезна.
 James T11 февр. 2019 г., 04:06
@ VictorSchröder Не думаю, что это вызвало бы много путаницы, но я все же отредактировал.

var arr = element.split(/_(.*)/)
Вы можете использовать второй параметр, который определяет предел разделения. то есть: var field = element.split ('_', 1) [1];
 Alan Moore05 янв. 2011 г., 20:59
Был(:?.*) должна быть группа без захвата? Если так, то должно быть(?:.*), но если вы исправите это, вы обнаружите, что это больше не работает.(:?.*) соответствует необязательному: с последующим нулем или более любого символа. Это решение в конечном итоге работает по той же причине, что и @ MarkF: все после первого_ добавлен в список токенов, потому что он был найден в группе захвата. (Так жеg Модификатор не имеет эффекта при использовании в регулярном выражении split.)
 Alex Vidal05 янв. 2011 г., 19:29
Это только указывает, сколько из разделенных элементов возвращается, а не сколько раз оно разделяется.'good_luck_buddy'.split('_', 1); возвращается только['good']
 Chandu05 янв. 2011 г., 19:35
Спасибо сделал предположение об этом. Обновлен пост, чтобы использовать регулярное выражение.
 Ofeargall05 янв. 2011 г., 19:42
этот код работает, как и у Марка, но он был первым. Спасибо!
 Igor Alekseev09 авг. 2012 г., 13:32
Это не работает в ie8, и я переключаюсь обратно на indexOf и подстроку

но оно не поддерживается старыми браузерами. Решение Kennebec великолепно и поддерживается старыми браузерами, но не поддерживает регулярные выражения.

Итак, если вы ищете решение, которое разбивает вашу строку только один раз, которое поддерживается старыми браузерами и поддерживает регулярные выражения, вот мое решение:

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

Вот один RegExp, который делает трюк.

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

Сначала это заставляет матч начинаться с начала с '^'. Затем он соответствует любому количеству символов, которые не являются «_», другими словами, все символы перед первым «_».

'?' означает, что минимальное количество символов, которые соответствуют целому шаблону, совпадает с '. *?' потому что за ним следует '_', который затем включается в совпадение в качестве последнего символа.

Поэтому этот метод split () использует такую ​​подходящую часть, как «разделитель», и удаляет ее из результатов. Таким образом, он удаляет все, вплоть до первого «_», и дает вам остальное как 2-й элемент результата. Первый элемент - это «», представляющий часть перед соответствующей частью. Это "", потому что матч начинается с начала.

Есть и другие RegExps, которые работают так же, как /_(.*)/, данные Чанду в предыдущем ответе.

Преимущество /^.*?_/ заключается в том, что вы можете понять, что он делает, не зная об особой роли групп захвата, выполняемых с replace ().

а затем разделите его.

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

["good","luck_buddy"]

Это более полезно, когда необходимы обе стороны разделения.

 Joe17 янв. 2019 г., 11:12
@sebjwallace Что бы вы ни выбрали, это означает, что у вас не может быть этого символа в строке. Например. Я думаю, что "fish & chips_are_great" дает [fish, chips, are_great].
 GuitarViking21 июл. 2017 г., 19:33
Этот ответ работал для меня, когда все вышеперечисленные ответы не.
 sebjwallace18 янв. 2019 г., 15:09
@Joe Вы можете использовать что угодно вместо '&' - это был просто пример. Вы можете заменить первое вхождение _ на ¬, если хотите. Таким образом, «fish & chips_are_great» заменит первое вхождение _ на ¬, чтобы дать «fish & chips¬are_great», а затем разделит на ¬, чтобы получить [«fish & chips», «are_great»]
 sebjwallace26 июл. 2017 г., 20:12
@YanFoto вы имеете в виду, используя '&'? Это может быть что угодно.
 Yan Foto22 июл. 2016 г., 11:46
Это накладывает ненужные ограничения на строку.

Для чего вам нужны регулярные выражения и массивы?

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

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

 stuckedoverflow02 февр. 2019 г., 19:19
Это гений!
 kennebec21 апр. 2016 г., 01:34
строка! == строка JavaScript чувствителен к регистру.
 Sun15 нояб. 2016 г., 21:29
Ответ выводит вторую часть строки. Что, если вам тоже нужна первая часть? С участиемvar str = "good_luck_buddy", res = str.split(/_(.+)/);Вы получаете все части:console.log(res[0]); console.log(res[1]);
 muratgozel28 окт. 2016 г., 01:42
Я думаю, что это лучший ответ. также возможно получить строку после второго_ написав:myString.substring( myString.indexOf('_', myString().indexOf('_') + 1) + 1 )
 Steffan01 нояб. 2017 г., 13:51
@PeterLeger let split =[ string.substring(0, string.indexOf(options.divider)), string.substring(string.indexOf(options.divider) + 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)

так что, regex lookbehind поможет мне в этом.

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

которую вы можете сделать:

"good_luck_buddy".split('_').slice(1).join('_')
 yonas27 февр. 2014 г., 20:00
@bfontaine - да, я согласен. Для действительно длинных строк мне придется просто смириться с этим и использовать RegExp.
 yonas05 окт. 2017 г., 17:01
Ха! Я написал этот комментарий 4+ лет назад. Я определенно нахожусь на борту с RegExp сейчас! :)
 Christiaan Westerbeek20 авг. 2014 г., 10:28
Тот, кто боится RegExp, никогда не может сказать, насколько велик RegExp. Вам нужно найти дверь самостоятельно. Как только вы там, вы никогда не будете оглядываться назад. Спросите меня снова через несколько лет, и вы скажете мне, как это здорово.
 Julian F. Weinert11 окт. 2015 г., 10:39
@yonas Да, возьми красную таблетку! Это сделает вашу жизнь быстрее, даже для коротких строк:jsperf.com/split-by-first-colon
 frnhr08 мар. 2015 г., 19:40
@yonas Возьми красную таблетку!
Самое быстрое решение?

Я пробежалтестыи это решение победило чрезвычайно:1

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);
};
Сравнение производительности с другими решениями

Единственным близким соперником была та же строка кода, за исключением использованияsubstr вместоsplit.

Другие решения, которые я пытался задействоватьsplit или жеRegExpS получил большой успех производительности и около 2порядки величины помедленнее. С помощьюjoin по итогамsplitРазумеется, добавляет дополнительный штраф за производительность.

Почему они медленнее? Каждый раз, когда необходимо создать новый объект или массив, JS должен запросить кусок памяти у ОС. Этот процесс очень медленный.

Вот некоторые общие рекомендации, если вы гоняетесь за эталонными тестами:

Новые динамические выделения памяти для объектов{} или массивы[] (как тот, которыйsplit создает) будет стоить много в исполнении.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) удалил бы префикс как первое решение в этом ответе.

Тесты были выполнены в Chrome 70.0.3538.110 на macOSX 10.14.
 Victor Schröder07 февр. 2019 г., 01:02
Да ладно ... Сейчас 2019 год. Есть ли люди, которые до сих пор используют микробенчмаркинг?
 TamusJRoyce11 февр. 2019 г., 15:06
Я согласен. Хотя микробенчмаркинг немного интересен, вы должны полагаться на компилятор или транслятор для оптимизации. Кто знает. Мб кто-то читает это, строит компилятор или использует ejs / embedded и не может использовать регулярные выражения. Тем не менее, это выглядит лучше для моего конкретного случая, чем регулярное выражение. (Я бы убрал "самое быстрое решение")

в JavaScriptString.split к сожалению, нет способа ограничить фактическое количество расколов. У него есть второй аргумент, который указывает, сколько фактических разделенных элементов возвращается, что в вашем случае бесполезно. Решением было бы разделить строку, сдвинуть первый элемент, а затем воссоединить оставшиеся элементы:

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

parts.shift(); // removes the first item from the array
var field = parts.join('_');
 Dan Hanly02 февр. 2012 г., 12:14
Я вижу, что функция split не помогает, но использование регулярных выражений, похоже, позволяет добиться этого. Следует указать, что вы имеете в виду саму функцию Split, изначально.
 Sukima14 дек. 2017 г., 20:20
Интересно, что это решение сводит проблему к более читаемому / управляемому решению. В моем случае преобразования полного имени в первое и последнее (да, наши требования заставили эту логику) это решение работало лучше и было более читабельным, чем другие. Спасибо

Ваш ответ на вопрос