Comment faire pour utiliser des chaînes de caractères.Endswith pour tester de multiples fins?

J'ai besoin de vérifier dans string.Endswith("") de l'un des opérateurs suivants: +,-,*,/

Si j'ai 20 opérateurs, je ne veux pas utiliser || opérateur de 19 fois.

Pourquoi ne voulez-vous pas utiliser l'opérateur||? C'est ce qu'il est pour. Si vous pouvez penser à des solutions qui n'utilisent pas EndsWith, mais ils continuent à utiliser l'opérateur ||
Ridicule Restrictions = Devoirs
Si j'ai 20 chaînes de vérifier,je dois utiliser l'opérateur || 19 fois.
Je souhaite que les gens demandent des devoirs questions de les marquer comme tel. C'est une étrange question. Le droit de réponse pour autant que je suis concerné est "Écrire || pour l'amour de dieu."
si vous avez 20 chaînes de vérifier que vous devriez dire. Votre question implique un petit fixe les règles de grammaire. Si vous avez un plus grand grammaire des modifications de la réponse. Même RegExes ne va pas aider avec 20 chaînes à vérifier. Astuce - essayez une table et d'une boucle for

OriginalL'auteur neven | 2010-05-09

  1. 31

    Si vous êtes en utilisant .NET 3.5, alors il est assez facile avec LINQ:

    string test = "foo+";
string[] operators = { "+", "-", "*", "/" };
bool result = operators.Any(x => test.EndsWith(x));
    LINQ est toujours le bon marteau pour le travail 🙂
    Je trouve ça plus clair d'utiliser un tableau lors de l'initialisation des choses comme ça: var opérateurs = new [] {"+", "-", "*", "/"};. Or just: bool result = new [] {"+", "-", "*", "/"}.Any(x => test.EndsWith(x));
    Changé à la matrice. 🙂
    Ne serait-ce pas très lente? Il va certainement générer beaucoup de code.
    C'est un non-sens. La seule lambda expressions LINQ utilise sont ceux que vous tapez ... dans ce cas x => test.EndsWith(x) de toute façon, en général, un prématuré de la question de l'efficacité est incompétent.

    OriginalL'auteur Mark Byers

  2. 8

    Bien que d'un exemple simple comme ça, c'est probablement assez bon à l'aide de ||, vous pouvez également utiliser des Regex pour elle:

    if (Regex.IsMatch(mystring, @"[-+*/]$")) {
  ...
}
    Personnellement, je hésitez pas à jamais vous recommandons de RegEx. Pour le problème tel que présenté c'est à peu près la plus lente possible de la solution, ainsi que d'être la plus complexe.
    Je n'irais pas aussi loin que hésiter à recommander regex pour n'importe quelle tâche, mais je suis d'accord que ce n'est pas la méthode la plus simple ici. Avec la regex, il est facile d'introduire une erreur, par exemple, dans ce cas, si l'OP insère plus de caractères qu'ils doivent faire attention à les saisir à la fin de la liste. Si elles sont ajoutées au début le trait d'union qui allait devenir une série qui pourrait être un dur à trouver d'erreur si vous n'êtes pas habitué à la syntaxe regex.
    Vous le savez, la plupart des gens sauter sur les regexes chaque fois qu'une chaîne de problème se pose, mais c'est une situation où je pense qu'une regex en fait est propre, concis, facile à comprendre et facile à entretenir.......si vous connaissez regexes.
    "Si vous savez regexes" dit tout. Mon problème avec les Regexes est double. Je n'ai jamais appris correctement. Je peux les utiliser si je le dois, mais je n'ai pas passer la plupart de mon temps munging des chaînes si je n'ai jamais appris. Cela signifie que lorsque je suis révision ou de la lecture ou de débogage de code, j'ai arrêter et de lire une ligne contenant une Regex à plusieurs reprises. Les lignes qui doivent être lus plusieurs fois sont une excellente façon de cacher les erreurs. Aussi, si le prochain opérateur à être analysé est "||", cette solution juste obtenu enourmously complexe. Et la compilation et l'analyse de la regex n'est pas gratuit, bien sûr.
    "Je n'ai jamais appris correctement." -- C'est votre problème; il n'a aucune incidence sur cette solution. "si le prochain opérateur à être analysé est ||, cette solution juste obtenu enourmously complexe" -- non, elle n'a pas, et regex est encore plus simple que d'autres solutions. "de la compilation et de l'analyse de la regex n'est pas gratuit bien sûr" -- c'est une constante de l'expression rationnelle, de sorte qu'il peut être analysé et compilé exactement une fois par exécution. Si que a été votre plainte, la réponse pourrait être modifié pour utiliser un initialiseur statique.

    OriginalL'auteur Max Shawabkeh

  3. 4
    string s = "Hello World +";
string endChars = "+-*/";

    À l'aide d'une fonction:

    private bool EndsWithAny(string s, params char[] chars)
{
    foreach (char c in chars)
    {
        if (s.EndsWith(c.ToString()))
            return true;
    }
    return false;
}

bool endsWithAny = EndsWithAny(s, endChars.ToCharArray()); //use an array
bool endsWithAny = EndsWithAny(s, '*', '/', '+', '-');     //or this syntax

    À l'aide de LINQ:

    bool endsWithAny = endChars.Contains(s.Last());

    À L'Aide De TrimEnd:

    bool endsWithAny = s.TrimEnd(endChars.ToCharArray()).Length < s.Length;
//als possible s.TrimEnd(endChars.ToCharArray()) != s;

    OriginalL'auteur Kobi

  4. 3

    Comment sur:-

    string input = .....;
string[] matches = { ...... whatever ...... };

foreach (string match in matches)
{
    if (input.EndsWith(match))
        return true;
}

    Je sais que c'est affreusement vieille école, afin d'éviter LINQ dans ce contexte, mais un jour vous aurez besoin de lire ce code. Je suis absolument sûr que LINQ a ses utilisations (je vais peut-être trouver un jour) mais je suis assez sûr qu'il n'est pas destiné à remplacer les quatre lignes de code ci-dessus.

    Yessir. Je dirais regexes, ou de cette réponse.
    Vous n'aimez pas les regexes, vous n'aimez pas LINQ ... non pas à cause de problème avec eux, mais parce que vous ne pouvez pas les lire. C'est tout à fait votre problème.

    OriginalL'auteur Stewart

  5. 2

    Si vous le voulez vraiment, vous pouvez utiliser les lois De De Morgan, pour remplacer x || y dans votre code. Une version dit:

    !(x || y) == !x && !y

    Si vous voulez avoir le même résultat, nous avons juste besoin de réduire à néant l'expression deux fois:

    x || y == !!(x || y) == !(!x && !y)
    Tout à fait correcte et de travail, mais je n'aimerais pas être à la lecture qu'en 6 mois de temps à la recherche pour un bug.
    Cela n'a aucune pertinence pour la question.

    OriginalL'auteur porges

  6. 2

    Tester le dernier caractère de la chaîne à l'aide de String.IndexOfAny(Char[], Int32) méthode (en supposant que str est votre variable):

    str.IndexOfAny(new char[] {'+', '-', '*', '/'}, str.Length - 1)

    Expression complète:

    str.Lenght > 0 ? str.IndexOfAny(new char[] {'+', '-', '*', '/'}, str.Length - 1) != -1 : false
    Sympa, mais il suppose que tous les opérateur constitué d'un seul caractère.
    Ouais, c'est un problème. Il est nécessaire de tester la longueur de la chaîne est >= 1.

    OriginalL'auteur Serge S.

  7. 0

    Est un regex expression n'est pas une option

    OriginalL'auteur Mark Pearl

  8. 0

    Compte tenu de l'absence totale de contexte, serait-ce la solution qui est pire que l'aide d'un simple || exploitant d'utilisation:

    Boolean check = false;
if (myString.EndsWith("+"))
     check = true;

if (!check && myString.EndsWith("-"))
     check = true;

if (!check && myString.EndsWith("/"))
     check = true;

etc.

    OriginalL'auteur cjk

  9. 0

    Utilisant String.IndexOf(String):

    str.Lenght > 0 ? "+-*/".IndexOf(str[str.Lenght - 1]) != -1 : false

    OriginalL'auteur Serge S.