una - substring c#

¿Cómo obtengo los últimos cuatro caracteres de una cadena en C#?

Question

Supongamos que tengo una cadena:

string mystring = "34234234d124";

Quiero obtener los últimos cuatro caracteres de esta cadena que es "d124" . Puedo usar SubString , pero necesita un par de líneas de código.

¿Es posible obtener este resultado en una expresión con C #?

Answer 1

Aquí hay otra alternativa que no debería funcionar tan mal (debido a la ejecución diferida ):

new string(mystring.Reverse().Take(4).Reverse().ToArray());

Aunque un método de extensión para el propósito mystring.Last(4) es claramente la solución más limpia, aunque un poco más de trabajo.

Answer 2

Definición:

public static string GetLast(string source, int last)
{
     return last >= source.Length ? source : source.Substring(source.Length - last);
}

Uso:

GetLast("string of", 2);

Resultado:

de

Answer 3

En comparación con algunas respuestas anteriores, la principal diferencia es que este fragmento de código tiene en cuenta cuando la cadena de entrada es:

1. Nulo
2. Más largo o igual que la longitud solicitada
3. Más corto que el largo solicitado.

Aquí está:

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

    public static string MyLast(this string str, int length)
    {
        if (str == null)
            return null;
        else if (str.Length >= length)
            return str.Substring(str.Length - length, length);
        else
            return str;
    }
}

Answer 4

Es solo esto:

int count = 4;
string sub = mystring.Substring(mystring.Length - count, count);

Answer 5

Esto no fallará para cualquier cadena de longitud.

string mystring = "34234234d124";
string last4 = Regex.Match(mystring, "(?!.{5}).*").Value;
// last4 = "d124"
last4 = Regex.Match("d12", "(?!.{5}).*").Value;
// last4 = "d12"

Es probable que esto sea una exageración para la tarea en cuestión, pero si es necesario que haya una validación adicional, posiblemente se pueda agregar a la expresión regular.

Edit: creo que esta expresión regular sería más eficiente:

@".{4}/Z"

Answer 6

Ok, entonces veo que esta es una publicación antigua, pero ¿por qué estamos reescribiendo el código que ya se proporciona en el marco?

Le sugiero que agregue una referencia al marco de trabajo DLL "Microsoft.VisualBasic"

using Microsoft.VisualBasic;
//...

string value = Strings.Right("34234234d124", 4);

Answer 7

Puede utilizar un método de extensión :

public static class StringExtension
{
    public static string GetLast(this string source, int tail_length)
    {
       if(tail_length >= source.Length)
          return source;
       return source.Substring(source.Length - tail_length);
    }
}

Y luego llamar:

string mystring = "34234234d124";
string res = mystring.GetLast(4);

Answer 8

Reuní algunos códigos modificados de varias fuentes que obtendrán los resultados que deseas, y además haré mucho más. He permitido valores int negativos, valores int que superan la longitud de la cadena y que el índice final sea menor que el índice inicial. En ese último caso, el método devuelve una subcadena de orden inverso. Hay muchos comentarios, pero hágame saber si algo no está claro o es una locura. Estaba jugando con esto para ver para qué podía usarlo.

    /// <summary>
    /// Returns characters slices from string between two indexes.
    /// 
    /// If start or end are negative, their indexes will be calculated counting 
    /// back from the end of the source string. 
    /// If the end param is less than the start param, the Slice will return a 
    /// substring in reverse order.
    /// 
    /// <param name="source">String the extension method will operate upon.</param>
    /// <param name="startIndex">Starting index, may be negative.</param>
    /// <param name="endIndex">Ending index, may be negative).</param>
    /// </summary>
    public static string Slice(this string source, int startIndex, int endIndex = int.MaxValue)
    {
        // If startIndex or endIndex exceeds the length of the string they will be set 
        // to zero if negative, or source.Length if positive.
        if (source.ExceedsLength(startIndex)) startIndex = startIndex < 0 ? 0 : source.Length;
        if (source.ExceedsLength(endIndex)) endIndex = endIndex < 0 ? 0 : source.Length;

        // Negative values count back from the end of the source string.
        if (startIndex < 0) startIndex = source.Length + startIndex;
        if (endIndex < 0) endIndex = source.Length + endIndex;         

        // Calculate length of characters to slice from string.
        int length = Math.Abs(endIndex - startIndex);
        // If the endIndex is less than the startIndex, return a reversed substring.
        if (endIndex < startIndex) return source.Substring(endIndex, length).Reverse();

        return source.Substring(startIndex, length);
    }

    /// <summary>
    /// Reverses character order in a string.
    /// </summary>
    /// <param name="source"></param>
    /// <returns>string</returns>
    public static string Reverse(this string source)
    {
        char[] charArray = source.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }

    /// <summary>
    /// Verifies that the index is within the range of the string source.
    /// </summary>
    /// <param name="source"></param>
    /// <param name="index"></param>
    /// <returns>bool</returns>
    public static bool ExceedsLength(this string source, int index)
    {
        return Math.Abs(index) > source.Length ? true : false;
    }

Entonces, si tiene una cadena como "Este es un método de extensión", aquí hay algunos ejemplos y resultados que puede esperar.

var s = "This is an extension method";
// If you want to slice off end characters, just supply a negative startIndex value
// but no endIndex value (or an endIndex value >= to the source string length).
Console.WriteLine(s.Slice(-5));
// Returns "ethod".
Console.WriteLine(s.Slice(-5, 10));
// Results in a startIndex of 22 (counting 5 back from the end).
// Since that is greater than the endIndex of 10, the result is reversed.
// Returns "m noisnetxe"
Console.WriteLine(s.Slice(2, 15));
// Returns "is is an exte"

Esperemos que esta versión sea de ayuda para alguien. Funciona como si no usara ningún número negativo, y proporciona valores predeterminados para los parámetros fuera de rango.

Answer 9

Simplemente puede utilizar el método de Substring de C #. Por ej.

string str = "1110000";
string lastFourDigits = str.Substring((str.Length - 4), 4);

Devolverá el resultado 0000.

Answer 10

Todo lo que tienes que hacer es..

String result = mystring.Substring(mystring.Length - 4);

Answer 11

Una solución simple sería:

string mystring = "34234234d124";
string last4 = mystring.Substring(mystring.Length - 4, 4);

Answer 12

Usar Substring es bastante corto y legible:

 var result = mystring.Substring(mystring.Length - Math.Min(4, mystring.Length));
 // result == "d124"

Answer 13

Utilice un Last<T> genérico Last<T> . Eso funcionará con CUALQUIER IEnumerable , incluida la cadena.

public static IEnumerable<T> Last<T>(this IEnumerable<T> enumerable, int nLastElements)
{
    int count = Math.Min(enumerable.Count(), nLastElements);
    for (int i = enumerable.Count() - count; i < enumerable.Count(); i++)
    {
        yield return enumerable.ElementAt(i);
    }
}

Y una específica para cuerda:

public static string Right(this string str, int nLastElements)
{
    return new string(str.Last(nLastElements).ToArray());
}

Answer 14

asumiendo que quería las cadenas entre una cadena que se encuentra a 10 caracteres del último carácter y necesita solo 3 caracteres.

Digamos que StreamSelected = "rtsp://72.142.0.230:80/SMIL-CHAN-273/4CIF-273.stream"

En lo anterior, necesito extraer el "273" que usaré en la consulta de la base de datos

        //find the length of the string            
        int streamLen=StreamSelected.Length;

        //now remove all characters except the last 10 characters
        string streamLessTen = StreamSelected.Remove(0,(streamLen - 10));   

        //extract the 3 characters using substring starting from index 0
        //show Result is a TextBox (txtStreamSubs) with 
        txtStreamSubs.Text = streamLessTen.Substring(0, 3);

Answer 15

mystring = mystring.Length > 4 ? mystring.Substring(mystring.Length - 4, 4) : mystring;

Answer 16

mystring.Substring(Math.Max(0, mystring.Length - 4)); //how many lines is this?

Si está seguro de que la longitud de su cuerda es de al menos 4, entonces es aún más corta:

mystring.Substring(mystring.Length - 4);

Answer 17

string mystring = "34234234d124";
mystring = mystring.Substring(mystring.Length-4)

Answer 18

string var = "12345678";

if (var.Length >= 4)
{
    var = var.substring(var.Length - 4, 4)
}

// result = "5678"