Answers:
这基本上就是您需要做的-至少,这是最简单的解决方案。您要“浪费”的只是n个方法调用的成本-如果您考虑一下,您实际上将不会两次检查任何一种情况。(IndexOf将在找到匹配项后立即返回,并且您将继续从其中断的地方开始。)
StringUtils.ordinalIndexOf()
。具有所有Linq和其他出色功能的C#,只是对此没有内置支持。是的,如果要处理解析器和令牌生成器,则必须提供支持。
string
:) 上将其添加为扩展方法:
您确实可以使用正则表达式/((s).*?){n}/
来搜索substring的第n次出现s
。
在C#中,它可能看起来像这样:
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;
}
}
注意:我已经添加Regex.Escape
到原始解决方案中,以允许搜索对正则表达式引擎具有特殊含义的字符。
value
吗?在我来说,我一直在寻找一个点msdn.microsoft.com/en-us/library/...
这基本上就是您需要做的-至少,这是最简单的解决方案。您要“浪费”的只是n个方法调用的成本-如果您考虑一下,您实际上将不会两次检查任何一种情况。(IndexOf将在找到匹配项后立即返回,并且您将继续从其中断的地方开始。)
这是作为扩展方法的(上述想法的)递归实现,模仿了框架方法的格式:
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);
}
另外,这是一些(MBUnit)单元测试,可能会对您有所帮助(证明它是正确的):
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));
}
}
}
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;
}
或在C#中使用扩展方法
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;
}
index
初始设置为-1 进行更正。
"BOB".IndexOf("B")
返回0,那么此函数应该用于IndexOfOccurence("BOB", "B", 1)
IndexOfOccurence
s
null
ArgumentNullException
match
null
经过一些基准测试,这似乎是最简单,最有效的解决方案
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;
}
Tod的答案可以稍微简化。
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));
}
}
输出量
1
3
5
-1