Schneiden Sie das letzte Zeichen aus einer Zeichenfolge

Ich habe eine Zeichenfolge zu sagen

"Hello! world!" 

Ich möchte ein Trimmen oder Entfernen vornehmen, um das herauszunehmen! aus der Welt, aber nicht aus Hallo.

"Hello! world!".TrimEnd('!');

Weiterlesen

BEARBEITEN:

Was mir bei dieser Art von Fragen aufgefallen ist, schlägt ziemlich jeder vor, das letzte Zeichen einer bestimmten Zeichenfolge zu entfernen. Dies entspricht jedoch nicht der Definition der Trimmmethode.

Trimmen - Entfernt alle Vorkommen von Leerzeichen am Anfang und Ende dieser Instanz.

MSDN-Trim

Unter dieser Definition ist das Entfernen nur des letzten Zeichens aus der Zeichenfolge eine schlechte Lösung.

Wenn wir also "Letztes Zeichen von Zeichenfolge abschneiden" möchten, sollten wir so etwas tun

Beispiel als Erweiterungsmethode:

public static class MyExtensions
{
  public static string TrimLastCharacter(this String str)
  {
     if(String.IsNullOrEmpty(str)){
        return str;
     } else {
        return str.TrimEnd(str[str.Length - 1]);
     }
  }
}

Beachten Sie, wenn Sie alle Zeichen mit demselben Wert entfernen möchten, dh (!!!!), entfernt die obige Methode alle Existenzen von '!' vom Ende der Zeichenfolge, aber wenn Sie nur das letzte Zeichen entfernen möchten, sollten Sie Folgendes verwenden:

else { return str.Remove(str.Length - 1); }

String withoutLast = yourString.Substring(0,(yourString.Length - 1));

if (yourString.Length > 1)
    withoutLast = yourString.Substring(0, yourString.Length - 1);

oder

if (yourString.Length > 1)
    withoutLast = yourString.TrimEnd().Substring(0, yourString.Length - 1);

... für den Fall, dass Sie ein Nicht-Leerzeichen am Ende entfernen möchten.

        string s1 = "Hello! world!";
        string s2 = s1.Trim('!');

Versuche dies:

return( (str).Remove(str.Length-1) );

string helloOriginal = "Hello! World!";
string newString = helloOriginal.Substring(0,helloOriginal.LastIndexOf('!'));

Das andere Beispiel für das Trimmen des letzten Zeichens aus einer Zeichenfolge:

string outputText = inputText.Remove(inputText.Length - 1, 1);

Sie können es in eine Erweiterungsmethode einfügen und verhindern, dass es eine Nullzeichenfolge usw. enthält.

string s1 = "Hello! world!"
string s2 = s1.Substring(0, s1.Length - 1);
Console.WriteLine(s1);
Console.WriteLine(s2);

Sie können dies auch verwenden:

public static class Extensions
 {

        public static string RemovePrefix(this string o, string prefix)
        {
            if (prefix == null) return o;
            return !o.StartsWith(prefix) ? o : o.Remove(0, prefix.Length);
        }

        public static string RemoveSuffix(this string o, string suffix)
        {
            if(suffix == null) return o;
            return !o.EndsWith(suffix) ? o : o.Remove(o.Length - suffix.Length, suffix.Length);
        }

    }

Leicht modifizierte Version von @Damian Leszczyński - Vash, die sicherstellt, dass nur ein bestimmter Charakter entfernt wird.

public static class StringExtensions
{
    public static string TrimLastCharacter(this string str, char character)
    {
        if (string.IsNullOrEmpty(str) || str[str.Length - 1] != character)
        {
            return str;
        }
        return str.Substring(0, str.Length - 1);
    }
}

Ich habe den Weg eingeschlagen, eine Erweiterung mit TrimEnd zu schreiben, nur weil ich sie bereits inline verwendet habe und damit zufrieden war ... dh:

static class Extensions
{
        public static string RemoveLastChars(this String text, string suffix)
        {            
            char[] trailingChars = suffix.ToCharArray();

            if (suffix == null) return text;
            return text.TrimEnd(trailingChars);
        }

}

Stellen Sie sicher, dass Sie den Namespace mithilfe der statischen Klasse in Ihre Klassen aufnehmen. P und Verwendung sind:

string _ManagedLocationsOLAP = string.Empty;
_ManagedLocationsOLAP = _validManagedLocationIDs.RemoveLastChars(",");          

Sehr einfach und unkompliziert:

str = str.Remove (str.Length - 1);

Ein Beispiel für eine Erweiterungsklasse zur Vereinfachung: -

internal static class String
{
    public static string TrimEndsCharacter(this string target, char character) => target?.TrimLeadingCharacter(character).TrimTrailingCharacter(character);
    public static string TrimLeadingCharacter(this string target, char character) => Match(target?.Substring(0, 1), character) ? target.Remove(0,1) : target;
    public static string TrimTrailingCharacter(this string target, char character) => Match(target?.Substring(target.Length - 1, 1), character) ? target.Substring(0, target.Length - 1) : target;

    private static bool Match(string value, char character) => !string.IsNullOrEmpty(value) && value[0] == character;
}

Verwendung

"!Something!".TrimLeadingCharacter('X'); // Result '!Something!' (No Change)
"!Something!".TrimTrailingCharacter('S'); // Result '!Something!' (No Change)
"!Something!".TrimEndsCharacter('g'); // Result '!Something!' (No Change)

"!Something!".TrimLeadingCharacter('!'); // Result 'Something!' (1st Character removed)
"!Something!".TrimTrailingCharacter('!'); // Result '!Something' (Last Character removed)
"!Something!".TrimEndsCharacter('!'); // Result 'Something'  (End Characters removed)

"!!Something!!".TrimLeadingCharacter('!'); // Result '!Something!!' (Only 1st instance removed)
"!!Something!!".TrimTrailingCharacter('!'); // Result '!!Something!' (Only Last instance removed)
"!!Something!!".TrimEndsCharacter('!'); // Result '!Something!'  (Only End instances removed)

Wenn Sie das '!' Zeichen aus einem bestimmten Ausdruck (in Ihrem Fall "Welt"), dann können Sie diesen regulären Ausdruck verwenden

string input = "Hello! world!";

string output = Regex.Replace(input, "(world)!", "$1", RegexOptions.Multiline | RegexOptions.Singleline);

// result: "Hello! world"

Das Sonderzeichen $ 1 enthält alle übereinstimmenden "Welt" -Ausdrücke und wird verwendet, um die ursprüngliche "Welt" zu ersetzen. Ausdruck