从字符串中获取倒数第二个字符位置

string str = "part1.abc.part2.abc.part3.abc";
int ix1 = str.LastIndexOf('.');
int ix2 = ix1 > 0 ? str.LastIndexOf('.', ix1 - 1) : -1;

总是有人喜欢正则表达式(和jQuery)，所以我将给出一个正则表达式解决方案(对于jQuery解决方案，您将不得不等待:-)):

var match = Regex.Match(str, @"'.[^'.]*'.", RegexOptions.RightToLeft);
int ix = match.Success ? match.Index : -1;

(注意，我是一个恨的Regexes，我把它给你，这样你就可以有足够的绳子吊死自己，如果你这样选择)。

请注意，我正在使用RegexOptions.RightToLeft选项，以便Regex从最后一个字符开始。

您可以使用String.LastIndexOf('.')方法来获取最后一个句号/句号的位置，然后在对LastIndexOf('.')的第二次调用中使用该位置来获取倒数第二，例如:

string aString = "part1.abc.part2.abc.part3.abc";
int lastPos = aString.LastIndexOf('.');
int lastPosButOne = aString.LastIndexOf('.', lastPos - 1);

但是我建议使用String.Split('.')，它会给你一个字符串部分的数组，然后你可以采取最后一个，例如

string aString = "part1.abc.part2.abc.part3.abc";
string[] parts = aString.Split('.');
string lastPartButOne = parts[parts.Length - 1];

这是另一个解决方案:

         string aString = "part1.abc.part2.abc.part3.abc";
        // Getting string until last dot
        var untilLastDot = aString.Substring(0, aString.LastIndexOf("."));
        // Now we have string until last dot and last dot here will be last but one 
        // and getting text from last but one dot to end
        string lastWordButOne = aString.Substring(untilLastDot.LastIndexOf(".") + 1);
        // Result: part3.abc

希望有帮助，谢谢!

据我所知，没有现成的解决方案。一种方法是使用string的LastIndexOf查找最后一个"。"，然后再次搜索最后一个点，这一次使用允许您指定startindex和count的重载，使用第一个调用的索引作为count的参数。

您可以使用String.Split()方法，该方法返回拆分项的数组。然后，您可以将前两个连接起来，留下最后一个。

尝试string类LastIndexOf方法

那么"part1.abc.part2.abc.part3.abc".Split('.')呢?在这种情况下，您将得到一个包含所有子字符串的数组

LastIndexOf应该做你想做的。做两遍。

基于@bitbonk的答案。我使用了下面的代码，这是VFP的RAT()函数的副本。

    public static int RightIndexAt(this string expressionToSearch, char charToSearch, int occurence)
    {
        //Validate parameter
        if (occurence < 1)
            return -1;
        int index = -1;
        int numfound = 0;
        for (int count = expressionToSearch.Length - 1; count >= 0; count--)
        {
            if (expressionToSearch[count].Equals(charToSearch))
            {
                index = count;
                numfound++;
            }
            if (numfound.Equals(occurence))
                break;
        }
        return numfound < occurence ? -1 : index;
    }

这将是具有最佳性能的解决方案(它可能不会比这更快和内存轻量级，除非您想走不安全的路线):

public static int LastIndexOf(this string str, char charToSearch, int repeatCound)
{
    int index = -1;
    for(int i = str.Length - 1; i >= 0, numfound < repeatCound)
    {
        if(str[i] == charToSearch)
        {
            index = i; 
            numfound++;
        }
    }
    return index;
}

这是我的(测试)版本

/// <summary>
///     Returns the index of the <paramref name="n" />th last occurrence of <paramref name="character" /> in <paramref name="targetString" />.
///     If <paramref name="character" /> does not occur in <paramref name="targetString" />, returns -1
/// </summary>
public static int NthLastIndexOf(this string targetString, char character, int n)
{
    switch (n)
    {
        case < 1: {
            return -1;
        }
        case 1: {
            return targetString.LastIndexOf(character);
        }
        default: {
            var source = targetString[..targetString.LastIndexOf(character)];
            var resultIndex = -1;
            for (var i = 2; i <= n; i++)
            {
                var nThIndexOf = source.LastIndexOf(character);
                if (nThIndexOf == -1)
                {
                    break;
                }
                resultIndex = nThIndexOf;
                source = targetString[..nThIndexOf];
            }
            return resultIndex;
        }
    }
}