Tengo que comprobar en string.Endswith("") de cualquiera de los siguientes operadores: +,-,*,/Cómo usar string.Endswith para probar múltiples terminaciones?
Si tengo 20 operadores que no quiero utilizar || operador de 19 veces.
Si está utilizando .NET 3.5, entonces es muy fácil con LINQ:
string test = "foo+";
string[] operators = { "+", "-", "*", "/" };
bool result = operators.Any(x => test.EndsWith(x));
LINQ es siempre el martillo correcto para el trabajo :) – cjk
Me parece más claro usar solo una matriz al inicializar cosas como esa: var operators = new [] {"+", "-", "*", "/" }; '. O simplemente: bool result = new [] {"+", "-", "*", "/"}.Any(x => test.EndsWith (x));' – Svish
@Svish: Cambió a la matriz. :) –
no es una expresión regex una opción
Aunque un ejemplo sencillo como eso es probablemente lo suficientemente bueno usando ||, también puede utilizar expresiones regulares para ello:
if (Regex.IsMatch(mystring, @"[-+*/]$")) {
...
}
Personalmente dudo en recomendar alguna vez RegEx. Para el problema presentado, se trata de la solución más lenta posible, además de ser la más compleja. – Stewart
@Stewart: No dudaría en recomendar la expresión regular para cualquier tarea, pero tengo que aceptar que no es el método más simple aquí. Con regex es fácil introducir un error, por ejemplo, en este caso, si el OP inserta más caracteres, debe tener cuidado de ingresarlos al final de la lista. Si se agregan al inicio, el guión se convertiría en un rango que podría ser un error difícil de encontrar si no está acostumbrado a la sintaxis de regex. –
Ya sabes, la mayoría de la gente recurre a las expresiones regulares cada vez que surge un problema de cadena, pero esta es una situación en la que creo que una expresión regular * es * limpia, concisa, fácil de entender y fácil de mantener ....... si usted sabe regexes. – mpen
Si realmente desea, puede usar las leyes de De Morgan para reemplazar x || y en su código. Una versión dice:
!(x || y) == !x && !y
Si usted quiere tener el mismo resultado, sólo tenemos que negar la expresión completa dos veces:
x || y == !!(x || y) == !(!x && !y)
Totalmente correcto y funcionando, pero no me gustaría estar leyendo eso en 6 meses buscando un error. – Stewart
Esto no tiene relevancia para la pregunta. –
Prueba la última carbón de la cadena utilizando el método String.IndexOfAny(Char[], Int32) (suponiendo str es la variable):
str.IndexOfAny(new char[] {'+', '-', '*', '/'}, str.Length - 1)
Expresión completa:
str.Lenght > 0 ? str.IndexOfAny(new char[] {'+', '-', '*', '/'}, str.Length - 1) != -1 : false
Bueno, pero se supone que todos los operadores consisten de un solo personaje. –
Sí, es un problema. Es necesario probar la longitud de la cuerda es> = 1. –
Dada la falta completa de contexto, lo haría esta solución que es peor que utiliza un || operador fácil ser de utilidad:
Boolean check = false;
if (myString.EndsWith("+"))
check = true;
if (!check && myString.EndsWith("-"))
check = true;
if (!check && myString.EndsWith("/"))
check = true;
etc.
string s = "Hello World +";
string endChars = "+-*/";
Uso una función:
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
mediante LINQ:
bool endsWithAny = endChars.Contains(s.Last());
Usando TrimEnd:
bool endsWithAny = s.TrimEnd(endChars.ToCharArray()).Length < s.Length;
// als possible s.TrimEnd(endChars.ToCharArray()) != s;
¿Qué tal: -
string input = .....;
string[] matches = { ...... whatever ...... };
foreach (string match in matches)
{
if (input.EndsWith(match))
return true;
}
Sé que es terriblemente vieja escuela para evitar LINQ en este contexto, pero uno día tendrá que leer este código. Estoy absolutamente seguro de que LINQ tiene sus usos (tal vez los encuentre algún día), pero estoy bastante seguro de que no está destinado a reemplazar las cuatro líneas de código anteriores.
Yessir. Diría regexias, o esta respuesta. – mpen
No te gustan las expresiones regulares, no te gusta LINQ ... no porque tenga ningún problema, sino porque no puedes leerlas. Ese es completamente tu problema. –
Usando String.IndexOf(String):
str.Lenght > 0 ? "+-*/".IndexOf(str[str.Lenght - 1]) != -1 : false
¿Por qué no le gustaría usar el || ¿operador? Esto es para lo que es. Si puede pensar en soluciones que no usan EndsWith, pero aún usan el || Operador – Stewart
Restricciones ridículas = Tarea –
@stewart: Si tengo 20 cadenas para verificar, tengo que usar || operador 19 veces. – neven