Question

我想检查字符串是否以列表中的任何字符开头。我目前在C＃中的实现如下：

char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
private bool startWithColumn(string toCheck)
{
   for(int i=0; i<columnChars.Length; i++)   
     if (toCheck.StartsWith(columnChars[i]+""))
     {
       return true;
     }

   return false;
}

我想知道任何解决方案是否更好？

Answer 1

转动检查并查看第一个字符是否在允许的设置中。

 char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
 private bool startWithColumn(string toCheck)
 {
     return toCheck != null
                && toCheck.Length > 0
                && columnChars.Any( c => c == toCheck[0] );
 }

Answer 2

您可以轻松地从字符串中获取第一个字符：

char c = toCheck[0];

然后检查它是否在数组中：

return columnChars.Contains(c);

Answer 3

我需要类似的东西，但对于字符串：

我想知道我的字符串subject是否以这些字符串中的任何一个开头：

var qualent3s = new string[] { "D", "M", "H", "JUK"};

这样做的LINQ很简单：

qualent3s.Any(x => subject.StartsWith(x))

Answer 4

return columnChars.Any(x => x == toCheck[0]);

Answer 5

如果你的角色“列表”肯定是char[]，我会假设你最好用：

return toCheck.IndexOfAny(columnChars) == 0;

免责声明：我没有对此进行基准测试。但那种方法只是坐在那里。

Answer 6

return Regex.IsMatch(toCheck, "^[A-E]");

可替换地：

return toCheck.Length > 0 && columnChars.Contains(toCheck[0]);

Answer 7

我相信这会更快：

char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
private bool startWithColumn(string toCheck)
{
   for(int i=0; i<columnChars.Length; i++)   
     if (toCheck.Length > 0 && toCheck[0] == columnChars[i]))
     {
       return true;
     }

   return false;
}

Answer 8

private bool startWithColumn(string toCheck)
{
  return (columnChars.IndexOf(toCheck[0]) >=0);
}

Answer 9

显而易见的方法是对数组进行线性搜索以获得字符串的第一个字符：

private bool startWithColumn(string toCheck)
{
     return !string.IsNullOrEmpty(toCheck) 
           && Array.IndexOf(columnChars, toCheck[0]) != -1; 
}

如果您正在寻找性能，考虑使用HashSet<char>或类似的而不是数组，这应该为您提供恒定时间查找。如果阵列更大，这可能是值得的;你必须以这种或那种方式衡量。

Answer 10

以下是我提出的建议：

    readonly char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' };
    private bool startWithColumn(string toCheck)
    {
        return columnChars.Contains(toCheck.Substring(0, 1).ToCharArray()[0]);
    }

修改

没有看到转换次数减少的可能性：

readonly char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' }; private bool startWithColumn(string toCheck) { return columnChars.Contains(toCheck[0]); }

Answer 11

您可以使用Contains和ElementAt：

来完成

char[] columnChars = new char[] { 'A', 'B', 'C', 'D', 'E' }; 
String testString = "This is test String";
var exists = columnChars.Contains(testString.ElementAt(0));

Answer 12

我喜欢我的linq所以：

        string str = "A quick brown fox";
        char[] chars = { 'A', 'B', 'C', 'D', 'E', 'F' };

        var query = from c in str.Substring(0, 1)
                    join c1 in chars on c equals c1
                    select c;

这将为您提供列表中与字符串的第一个字符匹配的所有字符。稍微修改一下，你甚至可以得到你正在搜索的字符列表中的字符索引，在这种情况下索引为0。

这是代码：

        string str = "A quick brown fox";
        char[] chars = { 'Z', 'X', 'A', 'B', 'C', 'D', 'E', 'F' };

        var query = from c in str.Substring(0, 1)
                    join c1 in chars on c equals c1
                    select new { Character = c, Index = chars.ToList().IndexOf(c) };

        var found = query.ToArray();

Answer 13

在这种情况下，我使用这样的扩展方法：

public static bool StartsWithAny(this string Text, IEnumerable<string> Needles) {
            return Needles.Any(x => Text.StartsWith(x));
        }

Answer 14

使用字符串扩展名非常有用：

public static class StringExtensions
{
    public static bool StartsWithAny(this string stack, params string[] needles) {
        return needles.Any(stack.StartsWith);
    }
}

我的全班同学是这样的：

public static class StringExtensions
{
    public static bool StartsWithAny(this string stack, params string[] needles) {
        return needles.Any(stack.StartsWith);
    }

    public static bool ContainsAny(this string stack, params string[] needles) {
        return needles.Any(stack.Contains);
    }

    public static bool IsOneOf<T>(this T value, params T[] items) {
        for (int i = 0; i < items.Length; ++i) {
            if (items[i].Equals(value))
                return true;
        }
        return false;
    }
}

检查字符串是否以列表中的任何字符开头

14 个答案: