Zeichenfolge ersetzen mit einer Liste <string>

Question

ich eine Liste von Worten habe ich wie diese ignorieren will:

public List<String> ignoreList = new List<String>() 
     { 
      "North", 
      "South", 
      "East", 
      "West" 
     }; 

Für eine gegebene Zeichenfolge, sagen "14th Avenue North" Ich will den „Nord“ Teil entfernen zu können, also im Grunde eine Funktion, die "14th Avenue " zurückgeben würde, wenn sie aufgerufen wird.

Ich habe das Gefühl, dass ich etwas mit LINQ, Regex und Replace machen kann, aber ich kann es einfach nicht herausfinden.

Das größere Bild ist, ich versuche, einen Adressenabgleich-Algorithmus zu schreiben. Ich möchte Wörter wie "Street", "North", "Boulevard" usw. herausfiltern, bevor ich den Levenshtein-Algorithmus zur Bewertung der Ähnlichkeit verwende.

Answer 1

Wie wäre es damit:

string.Join(" ", text.Split().Where(w => !ignoreList.Contains(w))); 

oder für .Net 3:

string.Join(" ", text.Split().Where(w => !ignoreList.Contains(w)).ToArray()); 

Beachten Sie, dass diese Methode die Zeichenfolge in einzelne Wörter zerlegt, so dass nur das ganze Wörter entfernt. Auf diese Weise funktioniert es richtig mit Adressen wie Northampton Way #123, die string.Replace nicht verarbeiten kann.

Answer 2

So etwas sollte funktionieren:

string FilterAllValuesFromIgnoreList(string someStringToFilter) 
{ 
    return ignoreList.Aggregate(someStringToFilter, (str, filter)=>str.Replace(filter, "")); 
} 

Answer 3

public static string Trim(string text) 
{ 
    var rv = text; 
    foreach (var ignore in ignoreList) 
     rv = rv.Replace(ignore, ""); 
    return rv; 
} 

Aktualisiert Gabe

---

public static string Trim(string text) 
{ 
    var rv = ""; 
    var words = text.Split(" "); 
    foreach (var word in words) 
    { 
     var present = false; 
     foreach (var ignore in ignoreList) 
     if (word == ignore) 
      present = true; 
     if (!present) 
     rv += word; 
    } 
    return rv; 
} 

Answer 4

Was für Schleife mit einem einfachen falsch?

Answer 5

Wenn Sie eine Liste haben, denke ich, dass Sie alle Elemente berühren müssen. Sie können eine massive RegEx mit all Ihren ignorierenden Keywords erstellen und durch ersetzen.

Hier ist ein Anfang:

(^|\s+)(North|South|East|West){1,2}(ern)?(\s+|$) 

Wenn Sie ein einzelnes RegEx haben für Worte ignorieren, können Sie für jede Phrase eine einzige ersetzen möchten Sie dem Algorithmus übergeben wollen.

Answer 6

Regex r = new Regex(string.Join("|", ignoreList.Select(s => Regex.Escape(s)).ToArray())); 
string s = "14th Avenue North"; 
s = r.Replace(s, string.Empty); 

Answer 7

Warum halten nicht juts es einfach?

public static string Trim(string text) 
{ 
    var rv = text.trim(); 
    foreach (var ignore in ignoreList) { 
     if(tv.EndsWith(ignore) { 
     rv = rv.Replace(ignore, string.Empty); 
    } 
    } 
    return rv; 
} 

Answer 8

Wenn es sich um eine kurze Zeichenfolge wie in Ihrem Beispiel handelt, können Sie nur die Zeichenfolgen durchlaufen und einzeln ersetzen. Wenn Sie Lust bekommen möchten, können Sie die LINQ Aggregate Methode verwenden, um es zu tun:

address = ignoreList.Aggregate(address, (a, s) => a.Replace(s, String.Empty)); 

Wenn es eine große Zeichenfolge ist, die langsam sein würde. Stattdessen können Sie alle Zeichenfolgen in einem einzigen Durchlauf durch die Zeichenfolge ersetzen, die viel schneller ist. Ich habe dafür eine Methode in this answer gemacht.

Answer 9

Wenn Sie wissen, dass die Liste des Wortes nur Zeichen enthält, die in einem regulären Ausdruck zu entkommen nicht brauchen, dann können Sie dies tun:

string s = "14th Avenue North"; 
Regex regex = new Regex(string.Format(@"\b({0})\b", 
         string.Join("|", ignoreList.ToArray()))); 
s = regex.Replace(s, ""); 

Ergebnis:

 
14th Avenue 

Wenn es etwas Besonderes ist Zeichen müssen Sie zwei Dinge zu beheben:

• Verwenden Sie Regex.Escape auf jedes Element der Ignorierliste.
• Die Wortgrenze \b wird keine Leerzeichen durch ein Symbol, oder umgekehrt, gefolgt entsprechen. Möglicherweise müssen Sie stattdessen Whitespace (oder andere trennende Zeichen wie Interpunktion) mithilfe von Lookaround Assertions suchen.

Hier ist, wie diese beiden Probleme zu beheben:

Regex regex = new Regex(string.Format(@"(?<= |^)({0})(?= |$)", 
    string.Join("|", ignoreList.Select(x => Regex.Escape(x)).ToArray()))); 

Answer 10

Sie können dies mit und Ausdruck tun, wenn Sie mögen, aber es ist einfacher, es zu drehen als ein Aggregat mit. Ich würde so etwas tun:

string s = "14th Avenue North" 
ignoreList.ForEach(i => s = s.Replace(i, "")); 
//result is "14th Avenue " 

Answer 11

LINQ macht dies einfach und lesbar. Dies erfordert jedoch normalisierte Daten, insbesondere dahingehend, dass zwischen Groß- und Kleinschreibung unterschieden wird.

List<string> ignoreList = new List<string>() 
{ 
    "North", 
    "South", 
    "East", 
    "West" 
};  

string s = "123 West 5th St" 
     .Split(' ') // Separate the words to an array 
     .ToList() // Convert array to TList<> 
     .Except(ignoreList) // Remove ignored keywords 
     .Aggregate((s1, s2) => s1 + " " + s2); // Reconstruct the string