C'è un modo semplice in .NET per ottenere “st”, “nd”, “rd” e “th” terminazioni per i numeri?[duplica]
-
09-06-2019 - |
Domanda
A questa domanda ha già una risposta qui:
- C'è un modo semplice per creare ordinali in C#? 18 risposte
Mi chiedo se c'è un metodo o una stringa di formato mi manca nel .NET per convertire i seguenti:
1 to 1st
2 to 2nd
3 to 3rd
4 to 4th
11 to 11th
101 to 101st
111 to 111th
Questo link ha un cattivo esempio del principio di base coinvolti nella scrittura di una propria funzione, ma io sono più curioso di sapere se c'è un insita capacità mi manca.
Soluzione
Scott Hanselman la risposta è accettato perché non risponde direttamente alla domanda.
Una soluzione, tuttavia, vedere questo grande risposta.
Soluzione
No, non c'è intrinseca capacità .NET Libreria di classi Base.
Altri suggerimenti
E ' una funzione che è molto più semplice di quanto si pensi.Anche se ci potrebbe essere un .Funzione di rete già in esistenza per questo, la seguente funzione (scritto in PHP), non il lavoro.Non dovrebbe essere troppo difficile da porta di sopra.
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:Qui è la funzione PHP in 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);
}
Semplice, pulito, veloce
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";
}
O meglio ancora, come un metodo di estensione
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";
}
}
Ora si può solo chiamare
int a = 1;
a.DisplayWithSuffix();
o anche più diretto
1.DisplayWithSuffix();
Questo è già stato trattato ma non sono sicuro di come link.Qui è il codice snippit:
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:Questo è un metodo di estensione.Se il vostro .NET versione è inferiore a 3,5 basta togliere la parola chiave this
[EDIT]:Grazie per la segnalazione era corretta, che è quello che si ottiene per il copia / incolla il codice :)
Ecco un database di Microsoft SQL Server versione della Funzione:
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
So che questa non è una risposta all'OP la domanda, ma perché l'ho trovato utile per sollevare la funzione SQL Server da questo thread, qui è un Delphi (Pascal) equivalente:
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;
Non ..., -1, 0 ha senso?
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";
}
Un altro sapore:
/// <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;
Penso che il numero ordinale di suffisso è difficile da ottenere...in sostanza, è necessario scrivere una funzione che utilizza un interruttore per verificare i numeri e aggiungere il suffisso.
Non c'è alcun motivo per una lingua di fornire questo internamente, soprattutto quando si tratta di specifici delle impostazioni internazionali.
Si può fare un po ' meglio di quel link quando si tratta di quantità di codice da scrivere, ma è necessario il codice di una funzione per questo...