Existe-t-il un moyen simple d'accéder à & # 8220; st & # 8221 ;, & # 8220; nd & # 8221 ;, & # 8220; rd & # 8221; et & # 8220; th & # 8221; des fins pour les nombres? [dupliquer]

https://stackoverflow.com/questions/69262

09-06-2019
|

Question

Cette question a déjà une réponse ici:

Existe-t-il un moyen simple de créer des ordinaux en C #? 18 réponses

Je me demande s’il manque une méthode ou un format de chaîne dans .NET pour convertir ce qui suit:

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

Ce lien contient un Mauvais exemple du principe de base impliqué dans l'écriture de votre propre fonction, mais je suis plus curieux s'il existe une capacité incorporée qui me manque.

Solution

La réponse de Scott Hanselman est la réponse acceptée car elle répond directement à la question.

Toutefois, pour obtenir une solution, consultez la page Cette excellente réponse .

La solution

Non, il n'y a pas de fonctionnalité intégrée dans la bibliothèque de classes de base .NET.

Autres conseils

C’est une fonction beaucoup plus simple que vous ne le pensez. Bien qu’il existe peut-être déjà une fonction .NET pour cela, la fonction suivante (écrite en PHP) fait le travail. Il ne devrait pas être trop difficile de le transférer.

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

@nickf: Voici la fonction PHP en 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);
}

Simple, propre, rapide

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

Ou mieux encore, en tant que méthode d'extension

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

Vous pouvez maintenant appeler

int a = 1;
a.DisplayWithSuffix();

ou même aussi direct que

1.DisplayWithSuffix();

Cela a déjà été couvert, mais je ne sais pas comment faire le lien. Voici l'extrait de code:

    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: Il s’agit d’une méthode d’extension. Si votre version .NET est inférieure à 3.5, supprimez simplement le mot-clé this

[EDIT]: Merci d'avoir signalé que c'était incorrect, c'est ce que vous obtenez pour copier / coller le code:)

Voici une version de la fonction Microsoft SQL Server:

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

Je sais que ce n'est pas une réponse à la question du PO, mais parce que j'ai trouvé utile de retirer la fonction SQL Server de ce fil, voici un équivalent de 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;

Est-ce que ..., -1er, 0e est logique?

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

Autre saveur:

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

else if (choice=='q')
{
    qtr++;

    switch (qtr)
    {
        case(2): strcpy(qtrs,"nd");break;
        case(3):
        {
           strcpy(qtrs,"rd");
           cout<<"End of First Half!!!";
           cout<<" hteam "<<"["<<hteam<<"] "<<hs;
           cout<<" vteam "<<" ["<<vteam;
           cout<<"] ";
           cout<<vs;dwn=1;yd=10;

           if (beginp=='H') team='V';
           else             team='H';
           break;
       }
       case(4): strcpy(qtrs,"th");break;

Je pense que le suffixe ordinal est difficile à obtenir ... vous devez en principe écrire une fonction qui utilise un commutateur pour tester les nombres et ajouter le suffixe.

Il n'y a aucune raison pour qu'une langue fournisse cela en interne, en particulier lorsqu'il s'agit de paramètres régionaux.

Vous pouvez faire un peu mieux que ce lien en ce qui concerne la quantité de code à écrire, mais vous devez coder une fonction pour cela ...

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow