Question

我正在尝试查看我的字符串是否以我创建的字符串数组中的字符串开头。这是我的代码：

string x = "Table a";
string y = "a table";
string[] arr = new string["table", "chair", "plate"]
if (arr.Contains(x.ToLower())){
    // this should be true
 }
if (arr.Contains(y.ToLower())){
    // this should be false
 }

我怎样才能使我的if语句成真？我喜欢只是将字符串x的开头与数组的内容匹配，而忽略大小写和后面的字符。我认为I needed regex要做到这一点，但我可能会弄错。我是一个有正则表达式的新手。

Answer 1

您似乎想检查您的字符串是否包含列表中的元素，因此这应该是您要查找的内容：

if (arr.Any(c => x.ToLower().Contains(c)))

或更简单：

if (arr.Any(x.ToLower().Contains))

或根据您的意见，您可以使用：

if (arr.Any(x.ToLower().Split(' ')[0].Contains))

Answer 2

因为你说你想要正则表达式...
您可以将正则表达式设置为var regex = new Regex("(table|plate|fork)");
并检查if(regex.IsMatch(myString)) { ... }

但是对于手头的问题，你不必使用Regex，因为你正在寻找一个确切的子串...你可以使用
（正如@ S.Akbari所说：if (arr.Any(c => x.ToLower().Contains(c))) { ... }

Answer 3

Enumerable.Contains匹配精确值（并且没有用于检查“starts with”的比较中的构建），您需要var myString = "some string" if (arr.Any(arrayItem => myString.Contains(arrayItem)))...来获取将每个数组元素作为参数并执行检查的谓词。所以第一步是你想让“包含”成为另一种方式 - 给定字符串以包含来自数组的元素：

Contains

现在你实际上要求“字符串以给定的单词开头”而不只是包含 - 所以你显然需要StartsWith（这可以方便地指定区分大小写，而不像if (arr.Any(arrayItem => myString.StartsWith( arrayItem, StringComparison.CurrentCultureIgnoreCase))) ... - Case insensitive 'Contains(string)'）：

请注意，此代码将接受“tableAAA bob” - 如果您确实需要打破单词边界正则表达式可能是更好的选择。只要您正确地转义所有值，动态构建正则表达式是微不足道的。

正则表达式应该是

字符串的开头 - if (arr.Any(arrayItem => Regex.Match(myString, String.Format(@"^{0}\b", Regex.Escape(arrayItem)), RegexOptions.IgnoreCase)) ...
您正在搜索的正确转义词 - Escape Special Character in Regex

分词 - \ b

var regex = new Regex("^(table|chair|plate) *.*");
if (regex.IsMatch(x.ToLower())){}

Answer 4

您可以使用 TypeScript 执行以下操作。也可以使用 contains 或 equals 等来代替开头。

  public namesList: Array<string> = ['name1','name2','name3','name4','name5'];

// SomeString = 'name1, Hello there';
      private isNamePresent(SomeString : string):boolean{
        if (this.namesList.find(name => SomeString.startsWith(name)))
          return true;
        return false;
      }

Answer 5

我想我明白你在这里想说的是什么，尽管仍有一些含糊之处。您是否试图查看数组中是否存在字符串中的1个单词（这是一个句子）？

@Amy是正确的，这可能与Regex根本无关。

我认为这段代码将在Java中完成你想要的（可以很容易地转换为C＃）：

爪哇：

x = x.ToLower();
string[] words = x.Split("\\s+");
foreach(string word in words){
    foreach(string element in arr){
        if(element.Equals(word)){
            return true;
        }
    }
} 
return false;

您还可以使用Set来存储数组中的元素，这样可以提高查找效率。

爪哇：

x = x.ToLower();
string[] words = x.Split("\\s+");
HashSet<string> set = new HashSet<string>(arr);
for(string word : words){
    if(set.contains(word)){
        return true;
    }
} 
return false;

编辑：（12月22日，上午11:05）

我在C＃中重写了我的解决方案，感谢@Amy和@JohnyL的提醒。由于作者只想匹配字符串的第一个单词，因此编辑后的代码应该有效：）

C＃：

    static bool contains(){
        x = x.ToLower();
        string[] words = x.Split(" ");
        var set = new HashSet<string>(arr);
        if(set.Contains(words[0])){
            return true;
        }
        return false;
    }

Answer 6

对不起，我的问题太模糊了，但是这里的解决方案得益于一些回答的人的帮助。

window.onload = function()
{
    {
        var canvas = document.getElementById('mon_canvas');
        var context = canvas.getContext('2d');
    }

    var rafraichissement = setInterval(animation, 1000/60);

    var rBalle = parseFloat(prompt('Entrez le rayon des balles'));

    var vitesseX = 1.1;
    var vitesseY = 1.2;

    var vitesseX2 = -1.5;
    var vitesseY2 = -0.9;

    var vitesseX3 = -1.2;
    var vitesseY3 = 1.33;

    var vitesseX4 = 2;
    var vitesseY4 = -0.7;

    var xBalle = rBalle+1;
    var yBalle = rBalle+1;

    var xBalle2 = canvas.width - rBalle -1;
    var yBalle2 = canvas.height - rBalle -1;

    var xBalle3 = canvas.width - rBalle -1;
    var yBalle3 = rBalle +1;

    var xBalle4 = rBalle +1;
    var yBalle4 = canvas.height - rBalle -1;
    //canvas.width pour la largeur du canvas
    //canvas.height pour sa hauteur

    function animation() {
        context.clearRect(0, 0, canvas.width, canvas.height);

        context.beginPath();
            context.arc(xBalle, yBalle, rBalle, 0, Math.PI*2);
            context.fill();
        context.closePath();

        context.beginPath();
            context.arc(xBalle2, yBalle2, rBalle, 0, Math.PI*2);
            context.fill();
        context.closePath();

        context.beginPath();
            context.arc(xBalle3, yBalle3, rBalle, 0, Math.PI*2);
            context.fill();
        context.closePath()

        context.beginPath();
            context.arc(xBalle4, yBalle4, rBalle, 0, Math.PI*2);
            context.fill();
        context.closePath()

        //collision balles / bord du canvas

        if(xBalle >= canvas.width - rBalle || xBalle <= rBalle){vitesseX *= -1;}            //Balle 1 (haut gauche)
        if(yBalle >= canvas.height - rBalle || yBalle <= rBalle){vitesseY *= -1;}

        if(xBalle2 >= canvas.width - rBalle || xBalle2 <= rBalle){vitesseX2 *= -1;}         //Balle 2 (bas droite)
        if(yBalle2 >= canvas.height - rBalle || yBalle2 <= rBalle){vitesseY2 *= -1;}

        if(xBalle3 >= canvas.width - rBalle || xBalle3 <= rBalle){vitesseX3 *= -1;}         //Balle 3 (haut droite)
        if(yBalle3 >= canvas.height - rBalle || yBalle3 <= rBalle){vitesseY3 *= -1;}

        if(xBalle4 >= canvas.width - rBalle || xBalle4 <= rBalle){vitesseX4 *= -1;}         //Balle 4 (bas gauche)
        if(yBalle4 >= canvas.height - rBalle || yBalle4 <= rBalle){vitesseY4 *= -1;}


        //collision balles / balles
        //var distance entre les balles

        var dist12 = Math.sqrt(Math.pow((parseFloat(xBalle) + parseFloat(xBalle2)), 2) + Math.pow(Math.pow((parseFloat(yBalle) + parseFloat(yBalle2)), 2)));
        var dist13 = Math.sqrt(Math.pow((parseFloat(xBalle) + parseFloat(xBalle3)), 2) + Math.pow(Math.pow((parseFloat(yBalle) + parseFloat(yBalle3)), 2)));
        var dist14 = Math.sqrt(Math.pow((parseFloat(xBalle) + parseFloat(xBalle4)), 2) + Math.pow(Math.pow((parseFloat(yBalle) + parseFloat(yBalle4)), 2)));

        var dist23 = Math.sqrt(Math.pow((parseFloat(xBalle2) + parseFloat(xBalle3)), 2) + Math.pow(Math.pow((parseFloat(yBalle2) + parseFloat(yBalle3)), 2)));
        var dist24 = Math.sqrt(Math.pow((parseFloat(xBalle2) + parseFloat(xBalle4)), 2) + Math.pow(Math.pow((parseFloat(yBalle2) + parseFloat(yBalle4)), 2)));

        var dist34 = Math.sqrt(Math.pow((parseFloat(xBalle3) + parseFloat(xBalle4)), 2) + Math.pow(Math.pow((parseFloat(yBalle3) + parseFloat(yBalle4)), 2)));

        //boucles if vérifiant la valeur de la distance, ainsi que les directions des balles

        if(dist12 <= parseFloat(rBalle)*2){  //balles 1 et 2
            if(vitesseX*vitesseX2 < 0)
            {
                vitesseX *= -1; vitesseX2 *= -1;
            }
            else{
                vitesseX *= 1; vitesseX2 *= 1;
            }

            if(vitesseY*vitesseY2 < 0){
                vitesseY *= -1; vitesseY2 *= -1;
            }
            else{
                vitesseY *= 1; vitesseY2 *= 1;
            }
        }

        if(dist13 <= parseFloat(rBalle)*2){  //balles 1 et 3
            if(vitesseX*vitesseX3 < 0)
            {
                vitesseX *= -1; vitesseX3 *= -1;
            }
            else{
                vitesseX *= 1; vitesseX3 *= 1;
            }

            if(vitesseY*vitesseY3 < 0){
                vitesseY *= -1; vitesseY3 *= -1;
            }
            else{
                vitesseY *= 1; vitesseY3 *= 1;
            }
        }

        if(dist14 <= parseFloat(rBalle)*2){  //balles 1 et 4

            if(vitesseX*vitesseX4 < 0)
            {
                vitesseX *= -1; vitesseX4 *= -1;
            }
            else{
                vitesseX *= 1; vitesseX4 *= 1;
            }

            if(vitesseY*vitesseY4 < 0){
                vitesseY *= -1; vitesseY4 *= -1;
            }
            else{
                vitesseY *= 1; vitesseY4 *= 1;
            }
        }

        if(dist23 <= parseFloat(rBalle)*2){  //balles 2 et 3
            if(vitesseX2*vitesseX3 < 0)
            {
                vitesseX2 *= -1; vitesseX3 *= -1;
            }
            else{
                vitesseX2 *= 1; vitesseX2 *= 1;
            }

            if(vitesseY2*vitesseY3 < 0){
                vitesseY2 *= -1; vitesseY3 *= -1;
            }
            else{
                vitesseY2 *= 1; vitesseY3 *= 1;
            }
        }

        if(dist24 <= parseFloat(rBalle)*2){  //balles 2 et 4

            if(vitesseX2*vitesseX4 < 0)
            {
                vitesseX2 *= -1; vitesseX4 *= -1;
            }
            else{
                vitesseX2 *= 1; vitesseX4 *= 1;
            }

            if(vitesseY2*vitesseY4 < 0){
                vitesseY2 *= -1; vitesseY4 *= -1;
            }
            else{
                vitesseY2 *= 1; vitesseY4 *= 1;
            }
        }

        if(dist34 <= parseFloat(rBalle)*2){  //balles 3 et 4
            if(vitesseX3*vitesseX4 < 0)
            {
                vitesseX3 *= -1; vitesseX4 *= -1;
            }
            else{
                vitesseX3 *= 1; vitesseX4 *= 1;
            }

            if(vitesseY3*vitesseY4 < 0){
                vitesseY3 *= -1; vitesseY4 *= -1;
            }
            else{
                vitesseY3 *= 1; vitesseY4 *= 1;
            }
        }

        //Pour déplacer les balles dans le plan

        xBalle += vitesseX;
        yBalle += vitesseY;

        xBalle2 += vitesseX2;
        yBalle2 += vitesseY2;

        xBalle3 += vitesseX3;
        yBalle3 += vitesseY3;

        xBalle4 += vitesseX4;
        yBalle4 += vitesseY4;
    }
}

检查数组是否以给定的一个开头的字符串（忽略大小写）

6 个答案: