ho bisogno di check-in string.Endswith("") da uno qualsiasi dei seguenti operatori: +,-,*,/Come usare string.Endswith per verificare i finali multipli?
Se ho 20 operatori che non voglio usare || operatore di 19 volte.
Se si utilizza .NET 3.5, allora è abbastanza facile con LINQ:
string test = "foo+";
string[] operators = { "+", "-", "*", "/" };
bool result = operators.Any(x => test.EndsWith(x));
LINQ è sempre il martello corretto per il lavoro :) – cjk
Trovo più chiaro utilizzare solo un array durante l'inizializzazione di cose del genere: var operator = new [] {"+", "-", "*", "/" }; '. O semplicemente: bool result = new [] {"+", "-", "*", "/"}.Any(x => test.EndsWith (x));' – Svish
@Svish: modificato in array. :) –
È un regex non un'espressione un'opzione
Anche se un semplice esempio del genere è probabilmente sufficiente usando ||, è anche possibile utilizzare Regex per esso:
if (Regex.IsMatch(mystring, @"[-+*/]$")) {
...
}
personalmente esito a raccomandare mai RegEx. Per il problema presentato, si tratta della soluzione più lenta e più complessa. – Stewart
@Stewart: non esiterei a raccomandare espressioni regolari per qualsiasi attività, ma devo ammettere che non è il metodo più semplice qui. Con regex è facile introdurre un errore, per esempio in questo caso se l'OP inserisce più caratteri dovrebbero fare attenzione ad inserirli alla fine dell'elenco. Se vengono aggiunti all'inizio, il trattino diventa un intervallo che potrebbe essere un errore difficile da trovare se non si è abituati a regolare la sintassi. –
Sai, la maggior parte delle persone salta su regex ogni volta che si verifica un problema con le stringhe, ma questa è una situazione in cui penso che un'espressione regolare in realtà * sia * pulita, concisa, facile da capire e facile da mantenere ....... se conosci le regex. – mpen
Se si vuole veramente, è può utilizzare le leggi di De Morgan per sostituire x || y nel codice. Una versione dice:
!(x || y) == !x && !y
Se si vuole avere lo stesso risultato, abbiamo solo bisogno di negare l'intera espressione due volte:
x || y == !!(x || y) == !(!x && !y)
Completamente corretto e funzionante, ma non mi piacerebbe leggerlo tra 6 mesi cercando un bug. – Stewart
Questo non ha rilevanza per la domanda. –
prova l'ultimo carattere della stringa utilizzando il metodo String.IndexOfAny(Char[], Int32) (supponendo str è la variabile):
str.IndexOfAny(new char[] {'+', '-', '*', '/'}, str.Length - 1)
espressione completa:
str.Lenght > 0 ? str.IndexOfAny(new char[] {'+', '-', '*', '/'}, str.Length - 1) != -1 : false
Bello, ma presuppone che tutti gli operatori siano composti da un solo carattere. –
Sì, è un problema. È necessario testare la lunghezza della stringa è> = 1. –
Data la totale assenza di contesto, sarebbe questa soluzione che è peggio che usare un facile || operatore sia di utilizzo:
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 = "+-*/";
Utilizzando una funzione:
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
utilizzando LINQ:
bool endsWithAny = endChars.Contains(s.Last());
Utilizzando TrimEnd:
bool endsWithAny = s.TrimEnd(endChars.ToCharArray()).Length < s.Length;
// als possible s.TrimEnd(endChars.ToCharArray()) != s;
ne dite di: -
string input = .....;
string[] matches = { ...... whatever ...... };
foreach (string match in matches)
{
if (input.EndsWith(match))
return true;
}
So che è terribilmente vecchia scuola per evitare LINQ in questo contesto, ma uno giorno dovrai leggere questo codice. Sono assolutamente sicuro che LINQ ha i suoi usi (forse li troverò un giorno) ma sono abbastanza sicuro che non è destinato a sostituire le quattro righe di codice sopra.
Yessir. Direi regex, o questa risposta. – mpen
Non ti piacciono le espressioni regolari, LINQ non ti piace ... non a causa di alcun problema con loro, ma perché non puoi leggerli. Questo è interamente il tuo problema. –
Utilizzando String.IndexOf(String):
str.Lenght > 0 ? "+-*/".IndexOf(str[str.Lenght - 1]) != -1 : false
Perché sarebbe non si vuole utilizzare il || operatore? Questo è quello che è per. Se riesci a pensare a soluzioni che non usano EndsWith, ma usano ancora il || operatore – Stewart
Restrizioni ridicole = Compiti –
@stewart: Se ho 20 stringhe da controllare, devo usare || operatore 19 volte. – neven