Строковый формат чисел до миллионов, тысяч с округлением
Я пытаюсь отформатировать цену для отображения, и я хочу отобразить число с суффиксом million (M) или thousands (K), но только когда-либо отображать не более 3 значений, округленных вниз.
нашел этот вопрос что очень близко к тому, что я хочу, но не обрабатывает округление (в частности, всегда округление)
кроме того, здесь у вас нет контроля над округлением.
пример ввода / ожидаемый вывод:
1 = 1
10 = 10
100 = 100
1000 = 1K
100000 = 100K
125000 = 125K
125900 = 125K
1000000 = 1M
1250000 = 1.25M
1258000 = 1.25M
10000000 = 10M
10500000 = 10.5M
100000000 = 100M
100100000 = 100M
Я по существу только когда-либо хочу отобразить 3 значения.
Я не вижу как я могу использовать "," настраиваемый описатель и указать округление.
мое первоначальное мышление предполагает, что мне нужно использовать комбинацию вышеизложенного, Math.Пол и еще кое-что .ToString () форматирование магии, но я не совсем уверен, с чего начать.
может кто-нибудь мне помочь?
спасибо заранее.
4 ответов
это должно помочь в сочетании с одним из методов форматирования в других вопросах, с которыми вы связаны.
internal long MaxThreeSignificantDigits(long x)
{
int i = (int)Math.Log10(x);
i = Math.Max(0, i - 2);
i = (int)Math.Pow(10, i);
return x / i * i;
}
EDIT:
хорошо, как насчет этого?
Console.WriteLine(SO30180672.FormatNumber(1));
Console.WriteLine(SO30180672.FormatNumber(12));
Console.WriteLine(SO30180672.FormatNumber(123));
Console.WriteLine(SO30180672.FormatNumber(1234));
Console.WriteLine(SO30180672.FormatNumber(12345));
Console.WriteLine(SO30180672.FormatNumber(123456));
Console.WriteLine(SO30180672.FormatNumber(1234567));
Console.WriteLine(SO30180672.FormatNumber(12345678));
Console.WriteLine(SO30180672.FormatNumber(123456789));
здесь частично скопировано следующее:https://stackoverflow.com/a/23384710/253938
internal class SO30180672
{
internal static string FormatNumber(long num)
{
num = MaxThreeSignificantDigits(num);
if (num >= 100000000)
return (num / 1000000D).ToString("0.#M");
if (num >= 1000000)
return (num / 1000000D).ToString("0.##M");
if (num >= 100000)
return (num / 1000D).ToString("0k");
if (num >= 100000)
return (num / 1000D).ToString("0.#k");
if (num >= 1000)
return (num / 1000D).ToString("0.##k");
return num.ToString("#,0");
}
internal static long MaxThreeSignificantDigits(long x)
{
int i = (int)Math.Log10(x);
i = Math.Max(0, i - 2);
i = (int)Math.Pow(10, i);
return x / i * i;
}
}
EDIT 2-Большое спасибо @Rhexis
internal class SO30180672
{
internal static void RunTest()
{
Console.WriteLine(FormatNumber(1));
Console.WriteLine(FormatNumber(10));
Console.WriteLine(FormatNumber(100));
Console.WriteLine(FormatNumber(1000));
Console.WriteLine(FormatNumber(10000));
Console.WriteLine(FormatNumber(100000));
Console.WriteLine(FormatNumber(125000));
Console.WriteLine(FormatNumber(125900));
Console.WriteLine(FormatNumber(1000000));
Console.WriteLine(FormatNumber(1250000));
Console.WriteLine(FormatNumber(1258000));
Console.WriteLine(FormatNumber(10000000));
Console.WriteLine(FormatNumber(10500000));
Console.WriteLine(FormatNumber(100000000));
Console.WriteLine(FormatNumber(100100000));
}
private static string FormatNumber(long num)
{
// Ensure number has max 3 significant digits (no rounding up can happen)
long i = (long)Math.Pow(10, (int)Math.Max(0, Math.Log10(num) - 2));
num = num / i * i;
if (num >= 1000000000)
return (num / 1000000000D).ToString("0.##") + "B";
if (num >= 1000000)
return (num / 1000000D).ToString("0.##") + "M";
if (num >= 1000)
return (num / 1000D).ToString("0.##") + "K";
return num.ToString("#,0");
}
}
Это мой код с теста выхода
1249 1.24K
12499 12.4K
124999 124K
1249999 1.24M
12499999 12.4M
124999999 124M
1249999999 1.24B
код выведет максимум три цифры.
static string FormatNumber(uint n)
{
if (n < 1000)
return n.ToString();
if (n < 10000)
return String.Format("{0:#,.##}K", n - 5);
if (n < 100000)
return String.Format("{0:#,.#}K", n - 50);
if (n < 1000000)
return String.Format("{0:#,.}K", n - 500);
if (n < 10000000)
return String.Format("{0:#,,.##}M", n - 5000);
if (n < 100000000)
return String.Format("{0:#,,.#}M", n - 50000);
if (n < 1000000000)
return String.Format("{0:#,,.}M", n - 500000);
return String.Format("{0:#,,,.##}B", n - 5000000);
}
поскольку формат существенно изменяется в зависимости от диапазона, вам, скорее всего, понадобится Условное форматирование, подобное приведенному ниже. У меня проверили только образец предоставил, поэтому убедитесь, что это работает для полного диапазона ожидаемых значений.
class Program
{
static void Main(String[] args)
{
Console.WriteLine(RoundAndFormat(1));
Console.WriteLine(RoundAndFormat(10));
Console.WriteLine(RoundAndFormat(100));
Console.WriteLine(RoundAndFormat(1000));
Console.WriteLine(RoundAndFormat(100000));
Console.WriteLine(RoundAndFormat(125000));
Console.WriteLine(RoundAndFormat(125900));
Console.WriteLine(RoundAndFormat(1000000));
Console.WriteLine(RoundAndFormat(1250000));
Console.WriteLine(RoundAndFormat(1258000));
Console.WriteLine(RoundAndFormat(10000000));
Console.WriteLine(RoundAndFormat(10500000));
Console.WriteLine(RoundAndFormat(100000000));
Console.WriteLine(RoundAndFormat(100100000));
Console.ReadLine();
}
public static String RoundAndFormat(Int32 value)
{
var result = String.Empty;
var negative = value < 0;
if (negative) value = value * -1;
if (value < 1000)
{
result = value.ToString();
}
else if (value < 1000000)
{
result = RoundDown(value / 1000.0, 0) + "K";
}
else if (value < 100000000)
{
result = RoundDown(value / 1000000.0, 2) + "M";
}
else if (value < 10000000000)
{
result = RoundDown(value / 1000000.0, 0) + "M";
}
if (negative) return "-" + result;
return result;
}
public static Double RoundDown(Double value, Int32 digits)
{
var pow = Math.Pow(10, digits);
return Math.Truncate(value * pow) / pow;
}
Спасибо за вашу помощь всем, это привело меня на правильный путь, чтобы выяснить это самостоятельно.
public static string FormatPriceValue(this int num)
{
if (num >= 100000000)
{
return ((num >= 10050000 ? num - 500000 : num) / 1000000D).ToString("#M");
}
if (num >= 10000000)
{
return ((num >= 10500000 ? num - 50000 : num) / 1000000D).ToString("0.#M");
}
if (num >= 1000000)
{
return ((num >= 1005000 ? num-5000 : num) / 1000000D).ToString("0.##M");
}
if (num >= 100000)
{
return ((num >= 100500 ? num - 500 : num) / 1000D).ToString("0.k");
}
if (num >= 10000)
{
return ((num >= 10550 ? num - 50 : num) / 1000D).ToString("0.#k");
}
return num >= 1000 ? ((num >= 1005 ? num - 5 : num) / 1000D).ToString("0.##k") : num.ToString("#,0");
}