javascript - reflexion - Cortando una cuerda en la enésima aparición de un personaje

objetivo del cortometraje cuerdas

Question

Lo que quiero hacer es tomar una cadena como this.those.that obtener una subcadena hacia o desde la enésima aparición de un carácter. Por lo tanto, desde el inicio de la cadena hasta la segunda aparición de . Volvería this.those . this.those . Asimismo, a partir de la 2ª aparición de . al final de la cadena devolvería that . Lo siento si mi pregunta es confusa, no es tan fácil de explicar. Además, no sugiera hacer variables adicionales, y el resultado estará en una cadena y no en una matriz.

Answer 1

En caso de que alguien necesite tanto "este" como "esos.que" de una manera tal como lo describe alex en su comment , aquí hay un código modificado:

var str = ''this.those.that'',
    delimiter = ''.'',
    start = 1,
    tokens = str.split(delimiter),
      result = [tokens.slice(0, start), tokens.slice(start)].map(function(item) {
    return item.join(delimiter);
  }); // [ ''this'', ''those.that'' ] 

document.body.innerHTML = result;

Answer 2

Estoy perplejo en cuanto a por qué quieres hacer cosas puramente con funciones de cadena, pero supongo que podrías hacer algo como lo siguiente:

//str       - the string
//c         - the character or string to search for
//n         - which occurrence
//fromStart - if true, go from beginning to the occurrence; else go from the occurrence to the end of the string
var cut = function (str, c, n, fromStart) {
    var strCopy = str.slice(); //make a copy of the string
    var index;
    while (n > 1) {
        index = strCopy.indexOf(c)
        strCopy = strCopy.substring(0, index)
        n--;
    }

    if (fromStart) {
        return str.substring(0, index);
    } else {
        return str.substring(index+1, str.length);
    }
}

Sin embargo, abogaría por algo como el código mucho más simple de alex.

Answer 3

Podría hacerlo sin matrices, pero tomaría más código y sería menos legible.

En general, solo desea utilizar la mayor cantidad de código para realizar el trabajo, y esto también aumenta la legibilidad. Si encuentra que esta tarea se está convirtiendo en un problema de rendimiento (haga una prueba comparativa), entonces puede decidir iniciar la refactorización para el rendimiento.

var str = ''this.those.that'',
    delimiter = ''.'',
    start = 1,
    tokens = str.split(delimiter).slice(start),
    result = tokens.join(delimiter); // those.that

jsFiddle .

Answer 4

Prueba esto :

"qwe.fs.xczv.xcv.xcv.x".replace(/([^/.]*/.){3}/, '''');
"xcv.xcv.x"

"qwe.fs.xczv.xcv.xcv.x".replace(/([^/.]*/.){**nth**}/, ''''); - donde es nth es la cantidad de ocurrencia para eliminar.

Answer 5

Si realmente desea atenerse a los métodos de cadena, entonces:

// Return a substring of s upto but not including
// the nth occurence of c
function getNth(s, c, n) {
  var idx;
  var i = 0;
  var newS = '''';
  do {
    idx = s.indexOf(c);
    newS += s.substring(0, idx);
    s = s.substring(idx+1);
  } while (++i < n && (newS += c))
  return newS;
}