Erhalten Sie den Index des n. Auftretens eines Strings?

Question

Wenn ich keine offensichtliche integrierte Methode vermisse, was ist der schnellste Weg, um das Auftreten einer Zeichenkette innerhalb einer Zeichenkette zu erreichen?

Ich realisiere, dass ich die IndexOf Methode durch Aktualisieren des Startindex bei jeder Iteration der Schleife loopen könnte. Aber so zu handeln, scheint mir verschwenderisch.

Answer 1

Das ist im Grunde, was Sie tun müssen - oder zumindest ist es die einfachste Lösung. Alles, was Sie "verschwenden" würden, sind die Kosten von n Methodenaufrufen - Sie werden tatsächlich keinen Fall zweimal überprüfen, wenn Sie darüber nachdenken. (IndexOf zurückkehren wird, sobald es die Übereinstimmung findet, und Sie halten gehen, wo er unterbrochen wird.)

Answer 2

Sie wirklich den regulären Ausdruck /((s).*?){n}/ verwenden könnten für n-ten Auftreten des Teils suchen s.

In C# es könnte wie folgt aussehen:

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

Hinweis: Ich habe Regex.Escape zur ursprünglichen Lösung gegeben Zeichen zu ermöglichen suchen, die eine besondere Bedeutung zu Regex-Engine haben.

Answer 3

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

oder in C# mit Erweiterungsmethoden

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

Answer 4

That's basically what you need to do - or at least, it's the easiest solution. All you'd be "wasting" is the cost of n method invocations - you won't actually be checking any case twice, if you think about it. (IndexOf will return as soon as it finds the match, and you'll keep going from where it left off.)

Hier ist die rekursive Implementierung (der oben Idee) als Erweiterungsmethode, um das Format des Rahmenverfahren nachahmt (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); 
} 

Auch hier sind einige (MBUnit) Unit Tests, die migh t Hilfe, die Sie (um es zu beweisen ist richtig):

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

Answer 5

Dies könnte es tun:

Console.WriteLine(str.IndexOf((@"\")+2)+1); 

Answer 6

Vielleicht wäre es auch schön, mit der String.Split() Methode zu arbeiten und überprüfen, ob die angeforderte Auftreten in das Array, wenn Sie nicht den Index benötigen, aber der Wert im Index