在我的代码中，我基于分割了一个字符串_并获取了数组中的第二项。

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);在ac＃stackoverflow答案中找到了它，但是它不起作用。我在jsFiddle上尝试过...

使用捕获括号：

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

它们被定义为

如果separator包含捕获括号，则在数组中返回匹配的结果。

因此，在这种情况下，我们希望在处进行分割_.+（即，分割分隔符是以开头的子字符串_），但还要让结果包含分隔符的某些部分（即之后的所有内容_）。

在此示例中，我们的分隔符（match _(.+)）为_luck_buddy，捕获的组（分隔符内）为lucky_buddy。如果没有捕获括号，则luck_buddy（matching .+）不会包含在结果数组中，因为在这种情况下split，分隔符不包含在结果中很简单。

您需要什么正则表达式和数组？

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('_')

用唯一的占位符替换第一个实例，然后从那里拆分。

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

["good","luck_buddy"]

当需要拆分的两侧时，此功能将更为有用。

您可以使用如下正则表达式：

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

如今String.prototype.split确实确实允许您限制拆分次数。

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

...

限制可选

一个非负整数，用于限制拆分数。如果提供，则在每次出现指定的分隔符时拆分字符串，但是在将限制条目放置在数组中时停止。数组中完全不包含任何剩余的文本。

如果在达到限制之前已到达字符串的末尾，则数组中的条目可能少于限制。如果limit为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"

String.split不幸的是，Javascript 无法限制实际的拆分次数。它有第二个参数，它指定要返回多少实际拆分项目，这在您的情况下没有用。解决方案是拆分字符串，将第一个项目移开，然后重新加入其余项目：

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

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

我需要字符串的两个部分，因此，正则表达式在后面帮助我。

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

借助解构分配，可以提高可读性：

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

最快的解决方案？

我运行了一些基准测试，此解决方案获得了巨大的成功：¹

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在于使用代替slice。

我尝试过涉及split或RegExp的其他解决方案对性能造成了很大的影响，但速度却慢了两个数量级。使用join上的结果split，当然，增加了一个额外的性能损失。

他们为什么慢一些？每当必须创建新对象或数组时，JS都必须从OS请求大块内存。这个过程很慢。

如果您正在追逐基准测试，则以下是一些一般准则：

• 为对象{}或数组[]（如split创建的对象）分配新的动态内存会花费很多性能。
• RegExp 搜索比字符串搜索更为复杂，因此速度较慢。
• 如果已经有一个数组，则对数组进行解构的速度与显式索引它们的速度差不多，并且看起来很棒。

超出首次实例

这是一个解决方案，可分割并包括第n个实例。它的速度不尽如人意，但是在OP的问题上，gobble(element, '_', 1)它仍然比a RegExp或split解决方案快2倍以上，并且可以执行更多操作：

/*
`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中运行的。

Mark F的解决方案很棒，但是旧的浏览器不支持。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]);

对于像我这样不习惯使用正则表达式的初学者，此解决方法有效：

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

slice（）方法提取字符串的一部分并返回新的字符串，indexOf（）方法返回在字符串中首次发现指定值的位置。

将字符串replace()方法与正则表达式一起使用：

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

此正则表达式在第一个_和_本身之前匹配0个或多个字符。然后将匹配项替换为空字符串。

这在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)

这是一个完成此操作的RegExp。

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

首先，它强制匹配从'^'开始。然后它匹配任意数量的非'_'字符，换句话说，第一个'_'之前的所有字符。

'？' 表示使整个模式匹配的最小字符数由'。*？'匹配 因为它后面跟有“ _”，然后将其作为最后一个字符包含在匹配项中。

因此，此split（）使用此类匹配部分作为其“分割器”，并将其从结果中删除。因此，它将删除直到并包括第一个“ _”的所有内容，并为您提供其余内容作为结果的第二个元素。第一个元素是“”，表示匹配的零件之前的零件。之所以是“”，是因为比赛是从头开始的。

还有其他RegExps可以像Chandu在先前的答案中给出的/_(.*)/一样工作。

/^.*?__/的好处是您可以了解它的功能，而不必了解捕获组在replace（）中扮演的特殊角色。