Découpe une chaîne de caractères à la nième occurrence d'un caractère

Ce que je veux faire est de prendre une chaîne telle que this.those.that et obtenir une sous-chaîne ou de la n-ième occurrence d'un caractère. Ainsi, depuis le début de la chaîne à la 2ème apparition de . serait de retour this.those. De même, à partir de la 2ème apparition de . à la fin de la chaîne de retour that. Désolé si ma question est brumeux, il n'est pas facile à expliquer. Aussi, s'il vous plaît ne suggèrent pas de prise de variables supplémentaires, et le résultat sera une chaîne de caractères et non un tableau.

  • Toute objection à la fente dans un tableau, puis de rejoindre les tranches de tableaux de nouveau ensemble? Il utilise des fonctions qui opèrent sur des chaînes ou de produire des chaînes de caractères.
  • Il semble que vous connaissez déjà la réponse; le fractionnement de la chaîne sur votre séparateur et puis réformer une nouvelle chaîne avec les parties semble la meilleure option. Pourquoi vous limitez pas à pas à l'aide d'un tableau?
  • Une chaîne de caractères est un tableau.
  • Je n'étais pas assez précis. Je ne veux pas en faire une collection supplémentaire en plus de la chaîne. À l'aide de la matrice de fonctions sur la chaîne qui fonctionne pour ce que je suis en train de réaliser. Je vais corriger la question.
  • Pourquoi ma réponse erronée?
  • Je crois qu'on peut avoir interprété le cas des OP question différemment.
  • Je vois. J'ai pris l'exemple que l'instance spécifique de n qu'il était intéressé par. Vous avez pris comme, pour tout n de produire un résultat et sélectionné une valeur différente pour n. Semble raisonnable. Je retire mon objection et de supprimer mon commentaire.

InformationsquelleAutor Anonymous | 2011-03-31
  1. 75

    Vous pourriez le faire sans tableaux, mais il faudrait plus de code et d'être moins lisible.

    En général, vous ne voulez utiliser que la quantité de code pour faire le travail, et cela augmente la lisibilité. Si vous trouvez que cela est en train de devenir un problème de performances (benchmark c'), puis vous pouvez décider de commencer à refactoring pour la performance.

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

    jsFiddle.

    • Je pensais que le résultat était censé être à la fois "ce.ceux qui" et "que"?
    • Peut-être que j'ai mal interprété la question, mais il a été acceptée 🙂
    • wow, cette réponse est incroyable, merci alex!
    • Je souhaite qu'il y avait un moyen de favori juste cette réponse!
    • Merci! Vraiment une bonne solution!! 🙂
    • Pour obtenir "ce.ceux qui" et "que", de changer de tranche(démarrer) pour la tranche de 0,start)
    • Pour obtenir les deux parties, "ce" et "ceux qui.que", on doit prendre deux tranches, voir ci-dessous
    • Encore plus court en utilisant l'option paramètre de limite à split: résultat = str.split(délimiteur de début+1).join(délimiteur)
    • Nice, je n'ai jamais réalisé split() pourrait prendre un deuxième argument. Je peux changer la réponse en fonction de.
    • Il ressemble à la limite de l'argument vous permet d'arrêter le fractionnement après les matchs, mais dans ce cas ça ne marcherait pas parce que nous voulons quelque chose comme limite négative, c'est à dire stop quand la division de la droite vers la gauche.

    InformationsquelleAutor alex
  2. 4

    Essayez ceci :

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

    "qwe.fs.xczv.xcv.xcv.x".replace(/([^\.]*\.){**nth**}/, ''); - où est le n-ième est le montant de l'événement à supprimer.

    • C'est mieux que la accepté de répondre. Parfois, le séparateur peut être une expression régulière (par exemple, \s+). Dans de tels cas, la accepté de répondre ne fonctionne pas. Mais celui-ci.
    • Étrange raisonnement. Si parfois, le séparateur peut être une regex vous auriez une conception en tant que telle. Si c'était à split, sur une chaîne, vous ne devriez pas toujours favorable à l'expression rationnelle parce que vous pourriez en avoir besoin. YAGNI.
    • Ce seul environ 4 fois plus vite.
    InformationsquelleAutor user2165842
  3. 3

    Je suis perplexe quant à pourquoi vous voulez faire les choses uniquement avec les fonctions de chaîne, mais je suppose que vous pourriez faire quelque chose comme ce qui suit:

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

    Cependant, j'aimerais vous recommande fortement pour quelque chose comme alex est beaucoup plus simple de code.

    • +1 pour l'effort 🙂
    InformationsquelleAutor NT3RP
  4. 3

    Juste au cas où quelqu'un a besoin à la fois de "ce" et "ceux qui.que" dans un sens comme alex l'a mentionné dans sa commentaire, voici le code modifié:

    JS:

    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;

    InformationsquelleAutor hooke
  5. 1

    Si vous voulez vraiment en tenir à la chaîne de méthodes, puis:

    //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;
}
    InformationsquelleAutor RobG