如何从C＃中的字符串中获取最后四个字符？

Question

假设我有一个字符串：

string mystring = "34234234d124";

我想获取此字符串的最后四个字符"d124"。我可以使用SubString，但它需要几行代码。

是否可以使用C＃在一个表达式中获得此结果？

Answer 1

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

如果你是正面的，你的弦的长度至少为4，那么它甚至更短：

mystring.Substring(mystring.Length - 4);

Answer 2

您可以使用extension method：

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

然后致电：

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

Answer 3

好的，所以我看到这是一篇旧帖子，但为什么我们要重写已在框架中提供的代码？

我建议您添加对框架DLL“Microsoft.VisualBasic”

的引用

using Microsoft.VisualBasic;
//...

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

Answer 4

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

Answer 5

使用Substring实际上非常简短易读：

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

Answer 6

你所要做的就是......

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

Answer 7

更新2020 ：C＃8.0最终使此操作变得简单：

> "C# 8.0 finally makes this easy"[^4..]
"easy"

您也可以用相同的方式对数组进行切片，请参见Indices and ranges。

Answer 8

您可以简单地使用C＃的Substring方法。对于前。

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

它将返回结果0000。

Answer 9

这是另一个不应该执行得太糟糕的选择（因为deferred execution）：

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

虽然用于mystring.Last(4)目的的扩展方法显然是最干净的解决方案，尽管需要更多的工作。

Answer 10

一个简单的解决方案是：

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

Answer 11

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

Answer 12

与之前的一些答案相比，主要区别在于，当输入字符串为：

时，这段代码会被考虑在内

1. 空
2. 长于或匹配所要求的长度
3. 比要求的长度短。

这是：

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 13

就是这样：

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

Answer 14

任何长度的字符串都不会失败。

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

这对于手头的任务可能有点过头了，但是如果需要进行额外的验证，可以将其添加到正则表达式中。

编辑：我认为这个正则表达式会更有效：

@".{4}\Z"

Answer 15

定义：

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

用法：

GetLast("string of", 2);

结果：

的<强>

Answer 16

使用通用Last<T>。这适用于任何IEnumerable，包括字符串。

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

一个特定的字符串：

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

Answer 17

我想扩展提及在 C# 8 或更高版本中使用新范围的现有答案：使代码可用于所有可能的字符串。如果你想复制代码，我建议使用示例 5 或 6。

string mystring ="C# 8.0 finally makes slicing possible";

1：切片结束部分 - 通过指定从开头省略多少个字符 - 这是 VS 2019 建议的内容：

string example1 = mystring[Math.Max(0, mystring.Length - 4)..] ;

2：切片取尾部分-通过指定从末端取多少个字符：

string example2 = mystring[^Math.Min(mystring.Length, 4)..] ;

3：切片取最后部分 - 用 ?: 运算符替换 Max/Min：

string example3 = (mystring.length > 4)? mystring[^4..] : mystring); 

就我个人而言，我更喜欢第二个和第三个变体。

MS doc reference for Indices and ranges:

Null？但是我们还没有完成关于普遍性的工作。到目前为止，每个示例都会为空字符串抛出异常。要考虑空值（如果您不在 C# 8 或更高版本中使用不可为空的字符串），并且不使用“if”（经典示例“with if”已在另一个答案中给出），我们需要：

4：切片考虑空-通过指定要省略多少字符：

string example4 = mystring?[Math.Max(0, mystring.Length - 4)..] ?? string.Empty;

5：切片考虑空-通过指定要取多少个字符：

string example5 = mystring?[^Math.Min(mystring.Length, 4)..] ?? string.Empty;

6：使用 ?: 运算符（以及另外两个“?”运算符 ;-) 对 考虑 null 进行切片：
（你不能把它放在一个整体的字符串插值中，例如对于 WriteLine。）

string example6 = (mystring?.Length > 4) ? filePath[^4..] : mystring ?? string.Empty;

7：等效于 variant 与旧的 Substring() 对于 C# 6 或 7.x：
（你不能把它放在一个整体的字符串插值中，例如对于 WriteLine。）

string example7 = (mystring?.Length > 4) ? mystring.Substring(mystring.Length- 4) : mystring ?? string.Empty;

优雅降级？ 我喜欢 C# 的新特性。像上一个例子那样将它们放在一行上可能看起来有点过分。我们的结局有点过分，不是吗？ 但这是一个很好的学习示例，我可以在经过测试的库方法中使用它一次。 更好的是，我们可以在现代 C# 中摆脱 null，如果我们想避免所有这些特定于 null 的处理。

这样的库/扩展方法作为快捷方式真的很有用。尽管 C# 取得了进步，但您必须自己编写一些东西才能获得比为每个小的字符串操作需要重复上面的代码更容易使用的东西。

我是从 BASIC 开始的人之一，40 年前就已经有了 Right$(,)。有趣的是，仍然可以将 VB 中的 Strings.Right(,) 与 C# 一起使用，如另一个答案所示。

C# 选择了精确而不是优雅降级（与旧的 BASIC 相反）。 因此，请在这些答案中复制您喜欢的任何适当变体，并为自己定义一个优雅的快捷功能，我的是一个名为 RightChars(int) 的扩展函数。

Answer 18

string var = "12345678";

var = var[^4..];

// var = "5678"

Answer 19

我将从各种来源修改过的代码汇集在一起​​，这些代码将获得您想要的结果，并且还可以做更多的事情。我允许负int值，int值超过字符串的长度，并且end index小于起始索引。在最后一种情况下，该方法返回一个反序子字符串。有很多评论，但如果有什么不清楚或只是疯了，请告诉我。我正在玩这个，看看我可以用它做什么。

    /// <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;
    }

因此，如果你有一个像＆＃34这样的字符串;这是一个扩展方法＆＃34;，这里有一些例子和结果。

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"

希望这个版本对某人有帮助。如果您不使用任何负数，它就会像平常一样运行，并为超出范围的参数提供默认值。

Answer 20

string var = "12345678";

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

// result = "5678"

Answer 21

假设您希望字符串介于一个字符串之间，该字符串与最后一个字符相距10个字符，而您只需要3个字符。

让我们说StreamSelected = "rtsp://72.142.0.230:80/SMIL-CHAN-273/4CIF-273.stream"

在上面，我需要提取我将在数据库查询中使用的"273"

        //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 22

使用 range operator 对我来说是最简单的方法。不需要很多代码。

在你的情况下，你可以像这样得到你想要的：

// the ^ operator indicates the element position from the end of a sequence
string str = "34234234d124"[^4..] 

Answer 23

建议使用TakeLast方法，例如：new String（text.TakeLast（4）.ToArray（））