Obtenir l'index de la n-ième occurrence d'une chaîne de caractères?

Sauf si je suis en manque évident de la méthode intégrée, ce qui est le moyen le plus rapide pour obtenir le nth occurrence d'une chaîne dans une chaîne de caractères?

Je me rends compte que je pouvais boucle de la IndexOf par la méthode de mise à jour de son index de début de chaque itération de la boucle. Mais cette façon de faire semble un gaspillage de moi.

Je voudrais utiliser une des expressions régulières pour pas que vous devez voie optimale correspondant à la chaîne de caractères dans la chaîne. Ce dans l'une des belles DSLs nous devrions tous utiliser lorsque cela est possible. Un exemple dans VB.net le code est presque la même en C#.
Je place beaucoup d'argent sur les expressions régulières version nettement plus difficile d'obtenir le droit de "garder la boucle et faire simple Chaîne de caractères.IndexOf". Les expressions régulières ont leur place, mais ne doit pas être utilisé lorsque des alternatives plus simples existent.
Similaire: stackoverflow.com/a/9908392/1305911

InformationsquelleAutor PeteT | 2008-10-09

.net c#indexing indexof string

52

C'est en gros ce que vous devez faire - ou du moins, c'est la solution la plus simple. Tous vous seriez "perdre" est le coût de n appels de méthode - vous n'allez pas être la vérification de tous les cas deux fois, si vous pensez à ce sujet. (IndexOf sera de retour dès qu'il trouve le match, et vous allez continuer à aller de l'endroit où il l'avait laissé.)
- Je suppose que votre droit, il semble comme il devrait être intégré dans la méthode, si, je suis sûr que c'est un voir occurrence.
- Vraiment? Je ne me souviens pas d'avoir jamais eu à le faire dans près de 13 ans de Java et C# développement. Cela ne veut pas dire j'ai jamais vraiment eu à le faire -, mais tout simplement pas assez souvent à retenir.
- En parlant de Java, nous avons StringUtils.ordinalIndexOf(). C# avec tous les Linq et d'autres caractéristiques merveilleuses, n'a tout simplement pas d'un bâti-support pour cela. Et oui, il est très impératif de disposer de son soutien si vous travaillez avec des analyseurs et des générateurs de jetons.
- Vous dites "nous" - voulez-vous dire à Apache Commons? Si oui, vous pouvez écrire votre propre bibliothèque tiers pour .NET tout aussi facilement que vous le pouvez pour Java... donc c'est pas comme si c'est quelque chose de la Java standard de la bibliothèque a que .NET ne fonctionne pas. Et bien sûr, en C#, vous pouvez l'ajouter comme une extension de la méthode sur string 🙂
InformationsquelleAutor Jon Skeet
104

Vous ne pouvais vraiment utiliser l'expression régulière /((s).*?){n}/ à la recherche pour la n-ième occurrence de la sous-chaîne s.

En C# il pourrait ressembler à ceci:
```
public static class StringExtender
{
    public static int NthIndexOf(this string target, string value, int n)
    {
        Match m = Regex.Match(target, "((" + Regex.Escape(value) + ").*?){" + n + "}");

        if (m.Success)
            return m.Groups[2].Captures[n - 1].Index;
        else
            return -1;
    }
}
```
Remarque: j'ai ajouté Regex.Escape à solution originale pour permettre la recherche des caractères qui ont une signification particulière pour moteur d'expressions régulières.
- devriez-vous être de s'échapper de la value? Dans mon cas, je cherchais un point msdn.microsoft.com/en-us/library/...
- Cette Regex ne fonctionne pas si la chaîne de caractères contient des retours à la ligne (. Pourriez-vous résoudre ce problème? Merci.
- Semble de verrouillage s'il n'y a pas un Énième match. J'avais besoin de limiter les valeurs séparées par des virgules à 1000 valeurs, et cette accroché lorsque le csv avait de moins en moins. Donc @Yogesh -- probablement pas un grand accepté de répondre comme il est. 😉 Utilisant une variante de la cette réponse (il y a une chaîne de chaîne de version ici) et changé la boucle pour s'arrêter au nième count à la place.
- En essayant de recherche sur \, valeur transmise est "\\", et le match de la chaîne ressemble à ceci avant de la regex.le match: (().*?){2}. J'obtiens cette erreur: analyse d'"(().*?){2}" - Pas assez ) s'. Quel est le format correct pour chercher des barres obliques inverses sans erreur?
- ne fonctionne pas si la recherche pour le caractère "+"
- J'ai légèrement modifié le code afin de permettre la recherche de caractères spéciaux.
- Désolé, mais une critique mineure: regex solutions ne sont pas optimales, parce que je dois réapprendre regexs pour la énième fois. Le code est essentiellement plus difficile à lire quand regexes sont utilisés.
InformationsquelleAutor Alexander Prokofyev

C'est en gros ce que vous devez faire - ou du moins, c'est la solution la plus simple. Tous vous seriez "perdre" est le coût de n appels de méthode - vous n'allez pas être la vérification de tous les cas deux fois, si vous pensez à ce sujet. (IndexOf sera de retour dès qu'il trouve le match, et vous allez continuer à aller de l'endroit où il l'avait laissé.)

Voici le récursive de mise en œuvre (ci-dessus idée) comme une extension de la méthode, mimicing le format de la méthode du cadre(s):

public static int IndexOfNth(this string input,
                             string value, int startIndex, int nth)
{
    if (nth < 1)
        throw new NotSupportedException("Param 'nth' must be greater than 0!");
    if (nth == 1)
        return input.IndexOf(value, startIndex);
    var idx = input.IndexOf(value, startIndex);
    if (idx == -1)
        return -1;
    return input.IndexOfNth(value, idx + 1, --nth);
}

Aussi, voici quelques (MBUnit) tests unitaires qui pourrait vous aider (pour prouver qu'il est correct):

using System;
using MbUnit.Framework;
namespace IndexOfNthTest
{
[TestFixture]
public class Tests
{
//has 4 instances of the 
private const string Input = "TestTest";
private const string Token = "Test";
/* Test for 0th index */
[Test]
public void TestZero()
{
Assert.Throws<NotSupportedException>(
() => Input.IndexOfNth(Token, 0, 0));
}
/* Test the two standard cases (1st and 2nd) */
[Test]
public void TestFirst()
{
Assert.AreEqual(0, Input.IndexOfNth("Test", 0, 1));
}
[Test]
public void TestSecond()
{
Assert.AreEqual(4, Input.IndexOfNth("Test", 0, 2));
}
/* Test the 'out of bounds' case */
[Test]
public void TestThird()
{
Assert.AreEqual(-1, Input.IndexOfNth("Test", 0, 3));
}
/* Test the offset case (in and out of bounds) */
[Test]
public void TestFirstWithOneOffset()
{
Assert.AreEqual(4, Input.IndexOfNth("Test", 4, 1));
}
[Test]
public void TestFirstWithTwoOffsets()
{
Assert.AreEqual(-1, Input.IndexOfNth("Test", 8, 1));
}
}
}

J'ai mis à jour la mise en forme et des cas de test basé sur Weston super retour (merci Weston).

InformationsquelleAutor Tod Thomson

14
```
private int IndexOfOccurence(string s, string match, int occurence)
{
int i = 1;
int index = 0;
while (i <= occurence && (index = s.IndexOf(match, index + 1)) != -1)
{
if (i == occurence)
return index;
i++;
}
return -1;
}
```
ou en C# avec les méthodes d'extension
```
public static int IndexOfOccurence(this string s, string match, int occurence)
{
int i = 1;
int index = 0;
while (i <= occurence && (index = s.IndexOf(match, index + 1)) != -1)
{
if (i == occurence)
return index;
i++;
}
return -1;
}
```
- Si je ne me trompe pas, cette méthode échoue si la chaîne de match débute à la position 0, ce qui peut être corrigé par la mise en index d'abord à -1.
- Vous pouvez également vérifier la valeur null ou une chaîne vide s et match ou il va le jeter, mais c'est une décision de conception.
- Merci @PeterMajeed - si "BOB".IndexOf("B") retourne 0, donc si cette fonction pour IndexOfOccurence("BOB", "B", 1)
- Le vôtre est probablement l'ultime solution, car il possède à la fois une fonction d'extension et il évite les regexs et la récursivité, les deux de rendre le code moins lisible.
- En effet, l'Analyse de Code sera question "CA1062: Valider les arguments des méthodes publiques" si IndexOfOccurence de ne pas vérifier si s est null. Et Chaîne de caractères.IndexOf (String, Int32) jetez ArgumentNullException si match est null.
InformationsquelleAutor Schotime
1

Peut-être qu'il serait bien aussi de travailler avec les String.Split() Méthode et de vérifier si l'événement est dans le tableau, si vous n'avez pas besoin de l'index, mais la valeur à l'index

InformationsquelleAutor user3227623

Après quelques benchmarking, ce qui semble être la plus simple et la plus efficace solution

public static int IndexOfNthSB(string input,
char value, int startIndex, int nth)
{
if (nth < 1)
throw new NotSupportedException("Param 'nth' must be greater than 0!");
var nResult = 0;
for (int i = startIndex; i < input.Length; i++)
{
if (input[i] == value)
nResult++;
if (nResult == nth)
return i;
}
return -1;
}

InformationsquelleAutor ShadowBeast

0

Système.ValueTuple ftw:

var index = line.Select((x, i) => (x, i)).Where(x => x.Item1 == '"').ElementAt(5).Item2;

l'écriture d'une fonction de qui est les devoirs

InformationsquelleAutor Matthias

Tod's réponse peut être quelque peu simplifié.

using System;
static class MainClass {
private static int IndexOfNth(this string target, string substring,
int seqNr, int startIdx = 0)
{
if (seqNr < 1)
{
throw new IndexOutOfRangeException("Parameter 'nth' must be greater than 0.");
}
var idx = target.IndexOf(substring, startIdx);
if (idx < 0 || seqNr == 1) { return idx; }
return target.IndexOfNth(substring, --seqNr, ++idx); //skip
}
static void Main () {
Console.WriteLine ("abcbcbcd".IndexOfNth("bc", 1));
Console.WriteLine ("abcbcbcd".IndexOfNth("bc", 2));
Console.WriteLine ("abcbcbcd".IndexOfNth("bc", 3));
Console.WriteLine ("abcbcbcd".IndexOfNth("bc", 4));
}
}

Sortie

InformationsquelleAutor seron

-3

Cela pourrait le faire:
```
Console.WriteLine(str.IndexOf((@"\")+2)+1);
```
- Je ne vois pas comment cela pourrait fonctionner. Pourriez-vous inclure une brève explication de ce que cela fait?
InformationsquelleAutor Sameer Shaikh

Vous devez vous connecter pour publier un commentaire.