En mi código, dividí una cadena basada en _y tomé el segundo elemento de la matriz.

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

good_luckMe toma y me proporciona luck. ¡Funciona genial!

Pero, ahora tengo una clase que se parece good_luck_buddy. ¿Cómo consigo mi javascript para ignorar el segundo _y darme luck_buddy?

Encontré esto var field = element.split(new char [] {'_'}, 2);en una respuesta ac # stackoverflow pero no funciona. Lo intenté en jsFiddle ...

Use paréntesis de captura :

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

Se definen como

Si separatorcontiene paréntesis de captura, los resultados coincidentes se devuelven en la matriz.

Entonces, en este caso, queremos dividir en _.+(es decir, el separador dividido es una subcadena que comienza con _) pero también dejar que el resultado contenga alguna parte de nuestro separador (es decir, todo lo que sigue _).

En este ejemplo, nuestro separador (coincidencia _(.+)) es _luck_buddyy el grupo capturado (dentro del separador) es lucky_buddy. Sin el paréntesis de captura, la luck_buddy(coincidencia .+) no se habría incluido en la matriz de resultados, ya que es simple splitque los separadores no se incluyan en el resultado.

¿Para qué necesita expresiones regulares y matrices?

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

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

Evito RegExp a toda costa. Aquí hay otra cosa que puedes hacer:

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

Reemplace la primera instancia con un marcador de posición único y luego divídalo desde allí.

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

["good","luck_buddy"]

Esto es más útil cuando se necesitan ambos lados de la división.

Puede usar la expresión regular como:

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

Esta solución me funcionó

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"

O

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"

Actualmente String.prototype.split, de hecho, le permite limitar el número de divisiones.

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

...

límite opcional

Un entero no negativo que limita el número de divisiones. Si se proporciona, divide la cadena en cada aparición del separador especificado, pero se detiene cuando se han colocado entradas de límite en la matriz. Cualquier texto restante no está incluido en la matriz en absoluto.

La matriz puede contener menos entradas que el límite si se alcanza el final de la cadena antes de alcanzar el límite. Si el límite es 0, no se realiza la división.

consideración

Es posible que no funcione de la manera que espera. Esperaba que simplemente ignorara el resto de los delimitadores, pero en cambio, cuando alcanza el límite, divide la cadena restante nuevamente, omitiendo la parte después de la división de los resultados de retorno.

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

Esperaba:

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

String.splitDesafortunadamente , Javascript no tiene forma de limitar el número real de divisiones. Tiene un segundo argumento que especifica cuántos de los elementos divididos reales se devuelven, lo que no es útil en su caso. La solución sería dividir la cadena, quitar el primer elemento y luego volver a unir los elementos restantes ::

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

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

Necesito las dos partes de la cadena, por lo tanto, regex lookbehind me ayuda con esto.

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

Con la ayuda de la asignación de desestructuración puede ser más legible:

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

¿La solución más rápida?

Ejecuté algunos puntos de referencia , y esta solución ganó enormemente: ¹

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

Comparación de rendimiento con otras soluciones.

El único competidor cercano era la misma línea de código, excepto el uso en substrlugar de slice.

Otras soluciones que probé involucrando splito RegExps tuvieron un gran éxito de rendimiento y fueron aproximadamente 2 órdenes de magnitud más lentas. Usar joinlos resultados de split, por supuesto, agrega una penalización de rendimiento adicional.

¿Por qué son más lentos? Cada vez que se debe crear un nuevo objeto o matriz, JS tiene que solicitar una porción de memoria del sistema operativo. Este proceso es muy lento.

Aquí hay algunas pautas generales, en caso de que esté persiguiendo puntos de referencia:

• Las nuevas asignaciones de memoria dinámica para objetos {}o matrices [](como la que splitcrea) costarán mucho en rendimiento.
• RegExp Las búsquedas son más complicadas y, por lo tanto, más lentas que las búsquedas de cadenas.
• Si ya tiene una matriz, la desestructuración de las matrices es casi tan rápida como indexarlas explícitamente, y se ve increíble.

Eliminar más allá de la primera instancia

Aquí hay una solución que se dividirá e incluirá la enésima instancia. No es tan rápido, pero en la pregunta del OP, gobble(element, '_', 1)todavía es> 2 veces más rápido que una RegExpo splitsolución y puede hacer más:

/*
`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);
}

Con la definición anterior, gobble('path/to/file.txt', '/')daría el nombre del archivo y gobble('prefix_category_item', '_', 1)eliminaría el prefijo como la primera solución en esta respuesta.

1. Las pruebas se ejecutaron en Chrome 70.0.3538.110 en macOSX 10.14.

La solución de Mark F es increíble, pero no es compatible con los navegadores antiguos. La solución de Kennebec es increíble y es compatible con los navegadores antiguos, pero no admite expresiones regulares.

Entonces, si está buscando una solución que divida su cadena solo una vez, que sea compatible con navegadores antiguos y que sea compatible con regex, esta es mi solución:

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

Para principiantes como yo que no estamos acostumbrados a la expresión regular, esta solución alternativa funcionó:

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

El método slice () extrae una parte de una cadena y devuelve una nueva cadena y el método indexOf () devuelve la posición de la primera aparición encontrada de un valor especificado en una cadena.

Use el replace()método de cadena con una expresión regular :

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

Esta expresión regular coincide con 0 o más caracteres antes del primero _, y el _propio. La coincidencia se reemplaza por una cadena vacía.

Esto funcionó para mí en Chrome + FF:

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

Si también necesita la clave, intente esto:

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

Aquí hay un RegExp que hace el truco.

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

Primero obliga al partido a comenzar desde el principio con el '^'. Luego, coincide con cualquier número de caracteres que no son '_', en otras palabras, todos los caracteres anteriores al primer '_'.

Los '?' significa un número mínimo de caracteres que hacen que todo el patrón coincida con el '. *?' porque es seguido por '_', que luego se incluye en la coincidencia como su último carácter.

Por lo tanto, esta división () usa una parte coincidente como su 'divisor' y la elimina de los resultados. Por lo tanto, elimina todo hasta el primer '_' e incluye el resto como el segundo elemento del resultado. El primer elemento es "" que representa la parte anterior a la parte coincidente. Es "" porque el partido comienza desde el principio.

Hay otros RegExps que funcionan tan bien como /_(.*)/ dado por Chandu en una respuesta anterior.

El /^.*?_/ tiene el beneficio de que puede comprender lo que hace sin tener que saber sobre el papel especial que juegan los grupos de captura con replace ().