Extrahieren Sie nur ganz rechts n Buchstaben aus einer Zeichenfolge

Wie kann ich einen, substringder aus den sechs Buchstaben ganz rechts besteht, aus einem anderen extrahieren string?

Bsp.: Meine Zeichenfolge ist "PER 343573". Jetzt möchte ich nur extrahieren "343573".

Wie kann ich das machen?

string SubString = MyString.Substring(MyString.Length-6);

Schreiben Sie eine Erweiterungsmethode, um die Right(n);Funktion auszudrücken . Die Funktion sollte sich mit null oder leeren Zeichenfolgen befassen, die eine leere Zeichenfolge zurückgeben, Zeichenfolgen, die kürzer als die maximale Länge der ursprünglichen Zeichenfolge sind, und Zeichenfolgen, die länger als die maximale Länge sind und die maximale Länge der Zeichen ganz rechts zurückgeben.

public static string Right(this string sValue, int iMaxLength)
{
  //Check if the value is valid
  if (string.IsNullOrEmpty(sValue))
  {
    //Set valid empty string as string could be null
    sValue = string.Empty;
  }
  else if (sValue.Length > iMaxLength)
  {
    //Make the string no longer than the max length
    sValue = sValue.Substring(sValue.Length - iMaxLength, iMaxLength);
  }

  //Return the string
  return sValue;
}

Wahrscheinlich ist es besser, eine Erweiterungsmethode zu verwenden:

public static class StringExtensions
{
    public static string Right(this string str, int length)
    {
        return str.Substring(str.Length - length, length);
    }
}

Verwendung

string myStr = "PER 343573";
string subStr = myStr.Right(6);

using System;

public static class DataTypeExtensions
{
    #region Methods

    public static string Left(this string str, int length)
    {
        str = (str ?? string.Empty);
        return str.Substring(0, Math.Min(length, str.Length));
    }

    public static string Right(this string str, int length)
    {
        str = (str ?? string.Empty);
        return (str.Length >= length)
            ? str.Substring(str.Length - length, length)
            : str;
    }

    #endregion
}

Sollte kein Fehler auftreten, werden Nullen als leere Zeichenfolge zurückgegeben, zugeschnittene Werte oder Basiswerte zurückgegeben. Verwenden Sie es wie "testx" .Left (4) oder str.Right (12);

MSDN

String mystr = "PER 343573";
String number = mystr.Substring(mystr.Length-6);

EDIT: zu langsam ...

Wenn Sie sich über die Länge Ihrer Zeichenfolge nicht sicher sind, aber über die Anzahl der Wörter (in diesem Fall immer 2 Wörter, z. B. 'xxx yyyyyy'), sollten Sie split verwenden.

string Result = "PER 343573".Split(" ")[1];

Dies gibt immer das zweite Wort Ihrer Zeichenfolge zurück.

Dies ist nicht genau das, wonach Sie fragen, aber wenn Sie sich nur das Beispiel ansehen, scheint es, dass Sie nach dem numerischen Abschnitt der Zeichenfolge suchen.

Wenn dies immer der Fall ist, ist die Verwendung eines regulären Ausdrucks ein guter Weg, dies zu tun.

var regex= new Regex("\n+");
string numberString = regex.Match(page).Value;

Benutze das:

String text = "PER 343573";
String numbers = text;
if (text.Length > 6)
{
    numbers = text.Substring(text.Length - 6);
}

Das Erraten Ihrer Anforderungen, aber der folgende reguläre Ausdruck ergibt nur 6 alphanumerische Zeichen vor dem Ende der Zeichenfolge und ansonsten keine Übereinstimmung.

string result = Regex.Match("PER 343573", @"[a-zA-Z\d]{6}$").Value;

Da Sie .NET verwenden, das alle in MSIL kompiliert wird , verweisen Sie einfach auf Microsoft.VisualBasic und verwenden Sie die integrierte Strings.RightMethode von Microsoft :

using Microsoft.VisualBasic;
...
string input = "PER 343573";
string output = Strings.Right(input, 6);

Sie müssen keine benutzerdefinierte Erweiterungsmethode oder andere Arbeit erstellen. Das Ergebnis wird mit einer Referenz und einer einfachen Codezeile erzielt.

Als weitere Informationen hierzu wurde die Verwendung von Visual Basic-Methoden mit C # an anderer Stelle dokumentiert . Ich persönlich bin zuerst darauf gestoßen, als ich versucht habe, eine Datei zu analysieren, und fand diesen SO-Thread bei der Verwendung der Microsoft.VisualBasic.FileIO.TextFieldParserKlasse äußerst nützlich für das Parsen von CSV-Dateien.

var str = "PER 343573";
var right6 = string.IsNullOrWhiteSpace(str) ? string.Empty 
             : str.Length < 6 ? str 
             : str.Substring(str.Length - 6); // "343573"
// alternative
var alt_right6 = new string(str.Reverse().Take(6).Reverse().ToArray()); // "343573"

Dies unterstützt eine beliebige Anzahl von Zeichen in der str. Der alternative Code unterstützt keine nullZeichenfolge. und der erste ist schneller und der zweite ist kompakter.

Ich bevorzuge die zweite, wenn ich die strenthaltende kurze Zeichenfolge kenne. Wenn es sich um eine lange Saite handelt, ist die erste besser geeignet.

z.B

var str = "";
var right6 = string.IsNullOrWhiteSpace(str) ? string.Empty 
             : str.Length < 6 ? str 
             : str.Substring(str.Length - 6); // ""
// alternative
var alt_right6 = new string(str.Reverse().Take(6).Reverse().ToArray()); // ""

oder

var str = "123";
var right6 = string.IsNullOrWhiteSpace(str) ? string.Empty 
             : str.Length < 6 ? str 
             : str.Substring(str.Length - 6); // "123"
// alternative
var alt_right6 = new string(str.Reverse().Take(6).Reverse().ToArray()); // "123"

Benutze das:

string mystr = "PER 343573"; int number = Convert.ToInt32(mystr.Replace("PER ",""));

Eine andere Lösung, die möglicherweise nicht erwähnt wird

S.Substring(S.Length < 6 ? 0 : S.Length - 6)

Null sichere Methoden:

Zeichenfolgen, die kürzer als die maximale Länge sind und die ursprüngliche Zeichenfolge zurückgeben

String Right Extension-Methode

public static string Right(this string input, int count) =>
    String.Join("", (input + "").ToCharArray().Reverse().Take(count).Reverse());

String Left Extension-Methode

public static string Left(this string input, int count) =>
    String.Join("", (input + "").ToCharArray().Take(count));

Hier ist die Lösung, die ich verwende ... Sie überprüft, ob die Länge der Eingabezeichenfolge nicht geringer als die angeforderte Länge ist. Die oben aufgeführten Lösungen berücksichtigen dies leider nicht - was zu Abstürzen führen kann.

    /// <summary>
    /// Gets the last x-<paramref name="amount"/> of characters from the given string.
    /// If the given string's length is smaller than the requested <see cref="amount"/> the full string is returned.
    /// If the given <paramref name="amount"/> is negative, an empty string will be returned.
    /// </summary>
    /// <param name="string">The string from which to extract the last x-<paramref name="amount"/> of characters.</param>
    /// <param name="amount">The amount of characters to return.</param>
    /// <returns>The last x-<paramref name="amount"/> of characters from the given string.</returns>
    public static string GetLast(this string @string, int amount)
    {
        if (@string == null) {
            return @string;
        }

        if (amount < 0) {
            return String.Empty;
        }

        if (amount >= @string.Length) {
            return @string;
        } else {
            return @string.Substring(@string.Length - amount);
        }
    }

Dies ist die Methode, die ich verwende: Ich mag es, die Dinge einfach zu halten.

private string TakeLast(string input, int num)
{
    if (num > input.Length)
    {
        num = input.Length;
    }
    return input.Substring(input.Length - num);
}

Nur ein Gedanke:

public static string Right(this string @this, int length) {
    return @this.Substring(Math.Max(@this.Length - length, 0));
}

//s - your string
//n - maximum number of right characters to take at the end of string
(new Regex("^.*?(.{1,n})$")).Replace(s,"$1")

Ohne auf den Bitkonverter und die Bitverschiebung zurückzugreifen (muss auf Codierung achten), ist dies die schnellste Methode, die ich als Erweiterungsmethode 'Richtig' verwende.

string myString = "123456789123456789";

if (myString > 6)
{

        char[] cString = myString.ToCharArray();
        Array.Reverse(myString);
        Array.Resize(ref myString, 6);
        Array.Reverse(myString);
        string val = new string(myString);
}

Ich benutze das Min, um die negativen Situationen zu verhindern und auch Nullzeichenfolgen zu behandeln

// <summary>
    /// Returns a string containing a specified number of characters from the right side of a string.
    /// </summary>
    public static string Right(this string value, int length)
    {
        string result = value;
        if (value != null)
            result = value.Substring(0, Math.Min(value.Length, length));
        return result;
    }

using Microsoft.visualBasic;

 public class test{
  public void main(){
   string randomString = "Random Word";
   print (Strings.right(randomString,4));
  }
 }

Ausgabe ist "Word"