Question

我需要拆分一个字符串，让我们说“asdf aA asdfget aa uoiu AA”拆分使用“aa”忽略这个案例。到

"asdf "
"asdfget "
"uoiu "

Answer 1

使用string.Split实现此目的并不容易。（好吧，除了为数组中的每个字符小写/大写字母指定拆分字符串的所有排列 - 不是很优雅我认为你会同意。）

然而，Regex.Split应该很好地完成这项工作。

示例：

var parts = Regex.Split(input, "aa", RegexOptions.IgnoreCase);

Answer 2

在算法中，您可以使用String.IndexOf方法并将OrdinalIgnoreCase作为StringComparison参数传递。

Answer 3

如果您不关心大小写，那么最简单的方法是在使用split之前将字符串强制为大写或小写。

stringbits = datastring.ToLower().Split("aa")

如果您关心字符串的有趣位而不是分隔符的情况，那么我将使用String.Replace强制所有分隔符到特定的大小写（大写或小写，无关紧要），然后调用String。使用匹配大小写分割为分隔符。

strinbits = datastring.Replace("aA", "aa").Replace("AA", "aa").Split("aa")

Answer 4

我的答案不如Noldorin's那么好，但我会留下它让人们可以看到替代方法。这对于简单的拆分不太好，但如果你需要进行更复杂的解析，它会更灵活。

using System.Text.RegularExpressions;

string data = "asdf aA asdfget aa uoiu AA";
string aaRegex = "(.+?)[aA]{2}";

MatchCollection mc = Regex.Matches(data, aaRegex);

foreach(Match m in mc)
{
    Console.WriteLine(m.Value);
}

Answer 5

这不是pretties版本，但也有效：

"asdf aA asdfget aa uoiu AA".Split(new[] { "aa", "AA", "aA", "Aa" }, StringSplitOptions.RemoveEmptyEntries);

Answer 6

    public static List<string> _Split(this string input,string[] splt)
    {
        List<string> _Result=new List<string>();
        foreach(string _splt in splt)
        {
            if (splt.Count() == 1)
            { 
                _Result.AddRange(Regex.Split(input, _splt, RegexOptions.IgnoreCase).ToList());
            }
            else 
            {
                List<string> NewStr = Regex.Split(input, _splt, RegexOptions.IgnoreCase).ToList();
                foreach(string _NewStr in NewStr)
                {
                    List<string> NewSplt = splt.ToList();
                    NewSplt.Remove(_splt);
                    return _Split(_NewStr, NewSplt.ToArray());
                }
            } 
        }
        return _Result;
    }

然后将此功能用作下面的

public frmThematicConversation()
{
    InitializeComponent();
    string str = "a b c d e f g h a b c f a d c b f";
    string[] splt = { "a", "b" };
    List<string> _result = str._Split(splt);
}

Answer 7

Dim arr As String() = Strings.Split("asdf aA asdfget aa uoiu AA", 
                                    "aa" ,, CompareMethod.Text)

CompareMethod.Text忽略大小写。

Answer 8

基于@Noldorin的答案，我做了这种扩展方法。

它接受多个分隔符字符串，并且如果您提供多个分隔符字符串，则模仿string.Split(..)的行为。它具有不变的（“非特定文化”）文化，并且会忽略某些情况。

/// <summary>
/// <see cref="string.Split(char[])"/> has no option to ignore casing.
/// This functions mimics <see cref="string.Split(char[])"/> but also ignores casing.
/// When called with <see cref="StringSplitOptions.RemoveEmptyEntries"/> <see cref="string.IsNullOrWhiteSpace(string)"/> is used to filter 'empty' entries.
/// </summary>
/// <param name="input">String to split</param>
/// <param name="separators">Array of separators</param>
/// <param name="options">Additional options</param>
/// <returns></returns>
public static IEnumerable<string> SplitInvariantIgnoreCase(this string input, string[] separators, StringSplitOptions options)
{
    if (separators == null) throw new ArgumentNullException(nameof(separators));
    if (separators.Length <= 0) throw new ArgumentException("Value cannot be an empty collection.", nameof(separators));
    if (string.IsNullOrWhiteSpace(input)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(input));

    // Build a regex pattern of all the separators this looks like aa|bb|cc
    // The Pipe character '|' means alternative.
    var regexPattern = string.Join("|", separators);

    var regexSplitResult = Regex.Split(input, regexPattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);

    // NOTE To be honest - i don't know the exact behaviour of Regex.Split when it comes to empty entries.
    //      Therefore i doubt that filtering null values even matters - however for consistency i decided to code it in anyways.
    return options.HasFlag(StringSplitOptions.RemoveEmptyEntries) ? 
        regexSplitResult.Where(c => !string.IsNullOrWhiteSpace(c)) 
        : regexSplitResult;
}

Answer 9

我编写的这个使用 .replace() 来查找和修复外壳的扩展方法取得了很好的成功。

你这样称呼它：

var result = source.Split(prefix, StringComparison.InvariantCultureIgnoreCase);

扩展方法定义如下。

public static string[] Split(this string source, string separator, 
    StringComparison comparison = StringComparison.CurrentCulture, 
    StringSplitOptions splitOptions = StringSplitOptions.None)
{
    if (source is null || separator is null)
        return null;

    // Pass-through the default case.
    if (comparison == StringComparison.CurrentCulture)
        return source.Split(new string[] { separator }, splitOptions);
    
    // Use Replace to deal with the non-default comparison options.
    return source
        .Replace(separator, separator, comparison)
        .Split(new string[] { separator }, splitOptions);
}

注意：此方法处理我通常传递单个字符串分隔符的默认情况。

如何在忽略分隔符的情况下拆分字符串？

9 个答案: