wake-up-neo.net

Extrahiere nur die meisten n Buchstaben aus einer Zeichenfolge

Wie kann ich einen Teilstring extrahieren, der aus den ganz rechten sechs Buchstaben eines anderen Strings besteht?

Beispiel: Mein String ist "PER 343573". Jetzt möchte ich nur "343573" extrahieren.

Wie kann ich das machen?

94
Shyju
string SubString = MyString.Substring(MyString.Length-6);
137
Vilx-

Schreiben Sie eine Erweiterungsmethode, um die Funktion Right(n); auszudrücken. Die Funktion sollte Null- oder leere Zeichenfolgen behandeln, die eine leere Zeichenfolge zurückgeben. Zeichenfolgen, die kürzer als die maximale Länge sind, geben die ursprüngliche Zeichenfolge zurück, und Zeichenfolgen, die länger als die maximale Länge sind und die maximale Länge der ganz rechten Zeichen 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;
}
64
stevehipwell

Wahrscheinlich 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);
    }
}

Verwendungszweck

string myStr = "ABCDEPER 343573";
string subStr = myStr.Right(6);
37
James
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, gibt Nullen als leere Zeichenfolge zurück, gibt getrimmte Werte oder Basiswerte zurück. Verwenden Sie es wie "testx". Left (4) oder str.Right (12);

25
Jeff Crawford

MSDN

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

EDIT: zu langsam ...

13
RvdK

wenn Sie sich nicht sicher sind, wie lang Ihre Zeichenfolge ist, Sie sich jedoch sicher sind, dass die Wörter zählen (in diesem Fall immer 2 Wörter, z. B. 'xxx yyyyyy'), sollten Sie split lieber verwenden. 

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

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

8

Das ist nicht genau das, wonach Sie fragen, aber bei Betrachtung des Beispiels scheint es, als würden Sie nach dem numerischen Abschnitt der Zeichenfolge suchen.

Wenn dies immer der Fall ist, wäre es ein guter Weg, einen regulären Ausdruck zu verwenden.

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

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

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

Da Sie .NET verwenden, das alle zu MSIL kompiliert, verweisen Sie einfach auf Microsoft.VisualBasic und benutze Microsofts eingebautes Strings.Right Methode:

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

Es muss keine benutzerdefinierte Erweiterungsmethode oder andere Arbeit erstellt werden. Das Ergebnis wird mit einer Referenz und einer einfachen Codezeile erzielt.

Als weitere Informationen hierzu wurde die Verwendung von Visual Basic-Methoden mit C # dokumentiert anderswo . Ich persönlich bin zuerst darauf gestoßen, als ich versucht habe, eine Datei zu analysieren, und habe this SO thread on using the Microsoft.VisualBasic.FileIO.TextFieldParser Klasse für das Parsen von CSV-Dateien äußerst nützlich.

5
Aaron Thomas

Benutze das:

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

Benutze das:

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

3
Brandao

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

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

Null sichere Methoden:

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

String Rechte Erweiterungsmethode

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

String Link-Erweiterungsmethode

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

Eine andere Lösung, die nicht erwähnt werden darf

S.Substring(S.Length < 6 ? 0 : S.Length - 6)
1
FLICKER
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 null-Zeichenfolge. und der erste ist schneller und der zweite ist kompakter.

ich bevorzuge die zweite, wenn ich die str kenne, die eine kurze Zeichenfolge enthält. Wenn es sich um einen langen String handelt, ist der erste eher 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"
1

Nur ein Gedanke:

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

Hier ist die Lösung, die ich verwende ..... Sie prüft, ob die Länge der Eingabezeichenfolge nicht niedriger 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);
        }
    }
1
Yves Schelpe

Ohne auf den Bit-Konverter zurückgreifen und Bit verschieben zu müssen (die Codierung muss sicher sein) Dies ist die schnellste Methode, die ich als Erweiterungsmethode 'Right' 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);
}
0
user86157

Ich verwende die Min, um negative Situationen zu vermeiden und auch mit Null-Strings umzugehen

// <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;
    }
0
RitchieD
using Microsoft.visualBasic;

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

ausgabe ist "Word"

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