it-swarm-vi.tech

Có một cách dễ dàng trong .NET để có các kết thúc "st", "nd", "rd" và "th" cho các số không?

Tôi tự hỏi nếu có một phương thức hoặc chuỗi định dạng tôi bị thiếu trong .NET để chuyển đổi như sau:

   1 to 1st
   2 to 2nd
   3 to 3rd
   4 to 4th
  11 to 11th
 101 to 101st
 111 to 111th

Liên kết này có một ví dụ tồi về nguyên tắc cơ bản liên quan đến việc viết chức năng của riêng bạn, nhưng tôi tò mò hơn nếu có một khả năng sẵn có mà tôi đang thiếu.

Giải pháp

Câu trả lời của Scott Hanselman là câu trả lời được chấp nhận vì nó trả lời trực tiếp câu hỏi.

Tuy nhiên, để biết giải pháp, hãy xem câu trả lời tuyệt vời này .

65
Matt Mitchell

Không, không có khả năng sẵn có trong Thư viện lớp cơ sở .NET.

56
Scott Hanselman

Đó là một chức năng đơn giản hơn bạn nghĩ rất nhiều. Mặc dù có thể có một hàm .NET đã tồn tại cho điều này, nhưng hàm sau (được viết bằng PHP) thực hiện công việc. Không nên quá khó khăn để chuyển nó qua.

function ordinal($num) {
    $ones = $num % 10;
    $tens = floor($num / 10) % 10;
    if ($tens == 1) {
        $suff = "th";
    } else {
        switch ($ones) {
            case 1 : $suff = "st"; break;
            case 2 : $suff = "nd"; break;
            case 3 : $suff = "rd"; break;
            default : $suff = "th";
        }
    }
    return $num . $suff;
}
83
nickf

Đơn giản, sạch sẽ, nhanh chóng

    private static string GetOrdinalSuffix(int num)
    {
        if (num.ToString().EndsWith("11")) return "th";
        if (num.ToString().EndsWith("12")) return "th";
        if (num.ToString().EndsWith("13")) return "th";
        if (num.ToString().EndsWith("1")) return "st";
        if (num.ToString().EndsWith("2")) return "nd";
        if (num.ToString().EndsWith("3")) return "rd";
        return "th";
    }

Hoặc tốt hơn, như một phương pháp mở rộng

public static class IntegerExtensions
{
    public static string DisplayWithSuffix(this int num)
    {
        if (num.ToString().EndsWith("11")) return num.ToString() + "th";
        if (num.ToString().EndsWith("12")) return num.ToString() + "th";
        if (num.ToString().EndsWith("13")) return num.ToString() + "th";
        if (num.ToString().EndsWith("1")) return num.ToString() + "st";
        if (num.ToString().EndsWith("2")) return num.ToString() + "nd";
        if (num.ToString().EndsWith("3")) return num.ToString() + "rd";
        return num.ToString() + "th";
    }
}

Bây giờ bạn chỉ có thể gọi

int a = 1;
a.DisplayWithSuffix(); 

hoặc thậm chí trực tiếp như

1.DisplayWithSuffix();
56
Shahzad Qureshi

@nickf: Đây là hàm PHP trong C #:

public static string Ordinal(int number)
{
    string suffix = String.Empty;

    int ones = number % 10;
    int tens = (int)Math.Floor(number / 10M) % 10;

    if (tens == 1)
    {
        suffix = "th";
    }
    else
    {
        switch (ones)
        {
            case 1:
                suffix = "st";
                break;

            case 2:
                suffix = "nd";
                break;

            case 3:
                suffix = "rd";
                break;

            default:
                suffix = "th";
                break;
        }
    }
    return String.Format("{0}{1}", number, suffix);
}
55
Scott Dorman

Điều này đã được bảo hiểm nhưng tôi không chắc làm thế nào để liên kết với nó. Đây là đoạn mã:

    public static string Ordinal(this int number)
    {
        var ones = number % 10;
        var tens = Math.Floor (number / 10f) % 10;
        if (tens == 1)
        {
            return number + "th";
        }

        switch (ones)
        {
            case 1: return number + "st";
            case 2: return number + "nd";
            case 3: return number + "rd";
            default: return number + "th";
        }
    }

FYI: Đây là một phương pháp mở rộng. Nếu phiên bản .NET của bạn nhỏ hơn 3,5, chỉ cần xóa từ khóa này

[EDIT]: Cảm ơn bạn đã chỉ ra rằng nó không chính xác, đó là những gì bạn nhận được để sao chép/dán mã :)

12
mjallday

Đây là phiên bản Microsoft SQL Server Function:

CREATE FUNCTION [Internal].[GetNumberAsOrdinalString]
(
    @num int
)
RETURNS nvarchar(max)
AS
BEGIN

    DECLARE @Suffix nvarchar(2);
    DECLARE @Ones int;  
    DECLARE @Tens int;

    SET @Ones = @num % 10;
    SET @Tens = FLOOR(@num / 10) % 10;

    IF @Tens = 1
    BEGIN
        SET @Suffix = 'th';
    END
    ELSE
    BEGIN

    SET @Suffix = 
        CASE @Ones
            WHEN 1 THEN 'st'
            WHEN 2 THEN 'nd'
            WHEN 3 THEN 'rd'
            ELSE 'th'
        END
    END

    RETURN CONVERT(nvarchar(max), @num) + @Suffix;
END
8
redcalx

Tôi biết đây không phải là câu trả lời cho câu hỏi của OP, nhưng vì tôi thấy hữu ích khi nâng chức năng SQL Server khỏi luồng này, đây là một tương đương Delphi (Pascal):

function OrdinalNumberSuffix(const ANumber: integer): string;
begin
  Result := IntToStr(ANumber);
  if(((Abs(ANumber) div 10) mod 10) = 1) then // Tens = 1
    Result := Result + 'th'
  else
    case(Abs(ANumber) mod 10) of
      1: Result := Result + 'st';
      2: Result := Result + 'nd';
      3: Result := Result + 'rd';
      else
        Result := Result + 'th';
    end;
end;

Liệu ..., -1, 0 có ý nghĩa?

2
avenmore

Một hương vị khác:

/// <summary>
/// Extension methods for numbers
/// </summary>
public static class NumericExtensions
{
    /// <summary>
    /// Adds the ordinal indicator to an integer
    /// </summary>
    /// <param name="number">The number</param>
    /// <returns>The formatted number</returns>
    public static string ToOrdinalString(this int number)
    {
        // Numbers in the teens always end with "th"

        if((number % 100 > 10 && number % 100 < 20))
            return number + "th";
        else
        {
            // Check remainder

            switch(number % 10)
            {
                case 1:
                    return number + "st";

                case 2:
                    return number + "nd";

                case 3:
                    return number + "rd";

                default:
                    return number + "th";
            }
        }
    }
}
0
Frank Hoffman
public static string OrdinalSuffix(int ordinal)
{
    //Because negatives won't work with modular division as expected:
    var abs = Math.Abs(ordinal); 

    var lastdigit = abs % 10; 

    return 
        //Catch 60% of cases (to infinity) in the first conditional:
        lastdigit > 3 || lastdigit == 0 || (abs % 100) - lastdigit == 10 ? "th" 
            : lastdigit == 1 ? "st" 
            : lastdigit == 2 ? "nd" 
            : "rd";
}
0
Faust