후행 0 제거

후행 0 제거

컬렉션에서 반환된 일부 필드가 있습니다.

2.4200
2.0044
2.0000

나는 다음과 같은 결과를 원합니다.

2.42
2.0044
2

로 시도했습니다.String.Format그러나 그것은 돌아옵니다.2.0000그리고 그것을 설정합니다.N0다른 값도 반올림합니다.

같은 문제에 부딪혔지만 라이브러리에서 처리한 문자열 출력을 제어할 수 없는 경우입니다.Decimal type 구현의 세부 사항을 살펴본 후(http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx), 참조) 깔끔한 트릭(여기서는 확장 방법)을 생각해냈습니다.

public static decimal Normalize(this decimal value)
{
    return value/1.000000000000000000000000000000000m;
}

소수점의 지수 부분은 필요한 부분으로 줄어듭니다.출력 소수점에서 ToString()을 호출하면 뒤에 0이 없는 숫자가 기록됩니다.

1.200m.Normalize().ToString();

입력이 문자열이면 이렇게 간단하지 않습니까?다음 중 하나를 사용할 수 있습니다.

string.Format("{0:G29}", decimal.Parse("2.0044"))

decimal.Parse("2.0044").ToString("G29")

2.0m.ToString("G29")

이것은 모든 입력에 적용됩니다.

업데이트 표준 숫자 형식을 확인하십시오. 문서에 명확하게 명시된 대로 정밀도 지정자를 29로 설정해야 했습니다.

그러나 숫자가 십진수이고 정밀도 지정자가 생략된 경우 고정점 표기법이 항상 사용되고 후행 0이 보존됩니다.

업데이트 Konrad는 코멘트에서 다음과 같이 지적했습니다.

0.000001과 같은 값을 주의하십시오.G29 형식은 가능한 한 짧은 방법으로 표시하므로 지수 표기법으로 전환됩니다. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))결과적으로 "1E-08"을 제공합니다.

사용자 지정 숫자 형식 문자열을 사용하는 것이 더 안전하다고 생각합니다.

decimal d = 0.00000000000010000000000m;
string custom = d.ToString("0.#########################");
// gives: 0,0000000000001
string general = d.ToString("G29");
// gives: 1E-13

나는 "G29" 과학적 표기법을 피하기 위해 이 코드를 사용합니다.

public static string DecimalToString(this decimal dec)
{
    string strdec = dec.ToString(CultureInfo.InvariantCulture);
    return strdec.Contains(".") ? strdec.TrimEnd('0').TrimEnd('.') : strdec;
}

편집: 시스템 CultureInfo를 사용합니다.번호 형식.숫자 소수 구분 기호:

public static string DecimalToString(this decimal dec)
{
    string sep = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
    string strdec = dec.ToString(CultureInfo.CurrentCulture);
    return strdec.Contains(sep) ? strdec.TrimEnd('0').TrimEnd(sep.ToCharArray()) : strdec;
}

해시 사용(#) 기호는 필요한 경우에만 뒤에 0을 표시합니다.아래 테스트를 참조하십시오.

decimal num1 = 13.1534545765;
decimal num2 = 49.100145;
decimal num3 = 30.000235;

num1.ToString("0.##");       //13.15%
num2.ToString("0.##");       //49.1%
num3.ToString("0.##");       //30%

http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/ 에서 우아한 솔루션을 찾았습니다.

기본적으로

decimal v=2.4200M;

v.ToString("#.######"); // Will return 2.42. The number of # is how many decimal digits you support.

매우 낮은 수준의 접근 방식이지만 빠른 정수 계산(느린 문자열 구문 분석 및 배양에 민감한 방법은 없음)만을 사용하는 것이 가장 성능이 좋은 방법이라고 생각합니다.

public static decimal Normalize(this decimal d)
{
    int[] bits = decimal.GetBits(d);

    int sign = bits[3] & (1 << 31);
    int exp = (bits[3] >> 16) & 0x1f;

    uint a = (uint)bits[2]; // Top bits
    uint b = (uint)bits[1]; // Middle bits
    uint c = (uint)bits[0]; // Bottom bits

    while (exp > 0 && ((a % 5) * 6 + (b % 5) * 6 + c) % 10 == 0)
    {
        uint r;
        a = DivideBy10((uint)0, a, out r);
        b = DivideBy10(r, b, out r);
        c = DivideBy10(r, c, out r);
        exp--;
    }

    bits[0] = (int)c;
    bits[1] = (int)b;
    bits[2] = (int)a;
    bits[3] = (exp << 16) | sign;
    return new decimal(bits);
}

private static uint DivideBy10(uint highBits, uint lowBits, out uint remainder)
{
    ulong total = highBits;
    total <<= 32;
    total = total | (ulong)lowBits;

    remainder = (uint)(total % 10L);
    return (uint)(total / 10L);
}

이것은 간단합니다.

decimal decNumber = Convert.ToDecimal(value);
        return decNumber.ToString("0.####");

테스트 완료.

건배 :)

숫자가 무엇을 나타내고 값을 관리하는 방법에 따라 다릅니다. 통화입니까? 반올림 또는 잘라내기가 필요합니까? 표시용으로만 이 반올림이 필요합니까?

표시를 위해 숫자 형식을 지정하는 것을 고려합니다.문자열로(""")

http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx 및

http://msdn.microsoft.com/en-us/library/0c899ak8.aspx

반올림만 하는 경우에는 수학을 사용합니다.MidPointRounding 오버로드가 필요한 라운드 오버로드

http://msdn.microsoft.com/en-us/library/ms131274.aspx)

데이터베이스에서 값을 얻는 경우 변환 대신 주조를 고려하십시오. 이중 값 = (십진수) myRecord["columnName"];

이렇게 하면 됩니다.

decimal source = 2.4200m;
string output = ((double)source).ToString();

이 또는초값인 string:

string source = "2.4200";
string output = double.Parse(source).ToString();

이 댓글에 주목하세요.

DecimalToString(https://stackoverflow.com/a/34486763/3852139) :

private static decimal Trim(this decimal value)
{
    var s = value.ToString(CultureInfo.InvariantCulture);
    return s.Contains(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator)
        ? Decimal.Parse(s.TrimEnd('0'), CultureInfo.InvariantCulture)
        : value;
}

private static decimal? Trim(this decimal? value)
{
    return value.HasValue ? (decimal?) value.Value.Trim() : null;
}

private static void Main(string[] args)
{
    Console.WriteLine("=>{0}", 1.0000m.Trim());
    Console.WriteLine("=>{0}", 1.000000023000m.Trim());
    Console.WriteLine("=>{0}", ((decimal?) 1.000000023000m).Trim());
    Console.WriteLine("=>{0}", ((decimal?) null).Trim());
}

출력:

=>1
=>1.000000023
=>1.000000023
=>

이거 어때:

public static string TrimEnd(this decimal d)
    {
        string str = d.ToString();
        if (str.IndexOf(".") > 0)
        {
            str = System.Text.RegularExpressions.Regex.Replace(str.Trim(), "0+?$", " ");
            str = System.Text.RegularExpressions.Regex.Replace(str.Trim(), "[.]$", " ");
        }
        return str;
    }

다음과 같이 설정할 수 있습니다.

decimal decNumber = 23.45600000m;
Console.WriteLine(decNumber.ToString("0.##"));

문자열 유형을 사용하지 않는 데 다음 코드를 사용할 수 있습니다.

int decimalResult = 789.500
while (decimalResult>0 && decimalResult % 10 == 0)
{
    decimalResult = decimalResult / 10;
}
return decimalResult;

789.5를 반환합니다.

십진수를 유지하려면 다음 예제를 사용하십시오.

number = Math.Floor(number * 100000000) / 100000000;

여기 제가 작성한 확장 메서드가 있습니다. 마지막 문자인 경우 점이나 쉼표도 제거합니다(0이 제거된 후).

public static string RemoveZeroTail(this decimal num)
{
    var result = num.ToString().TrimEnd(new char[] { '0' });
    if (result[result.Length - 1].ToString() == "." || result[result.Length - 1].ToString() == ",")
    {
        return result.Substring(0, result.Length - 1);
    }
    else
    {
        return result;
    }
}

오는 하려면 " " " " " " " " " " " " " "dateTicks,사용하다

return new String(dateTicks.Take(dateTicks.LastIndexOf(dateTicks.Last(v => v != '0')) + 1).ToArray());

추가 답변:

XAML을 사용하는 WPF 애플리케이션에서 사용할 수 있습니다.

{Binding yourDecimal, StringFormat='#,0.00#######################'}

위의 답변은 일부 상황에서 0을 유지하므로 계속 반환할 수 있습니다.2.00를 들어 .

{Binding yourDecimal, StringFormat='#,0.#########################'}

모든 후행 0을 제거하려면 그에 따라 조정합니다.

다음 코드는 후행 0을 제거할 수 있습니다.힘든 방법인 건 알지만 효과가 있어요.

private static string RemoveTrailingZeros(string input) 
{
    for (int i = input.Length - 1; i > 0; i-- )
    {
        if (!input.Contains(".")) break;
        if (input[i].Equals('0'))
        {
            input= input.Remove(i);
        }
        else break;
    }
    return input;
}

string.Format("{0:G29}", decimal.Parse("2.00"))

string.Format("{0:G29}", decimal.Parse(Your_Variable))

이 코드를 사용해 보십시오.

string value = "100";
value = value.Contains(".") ? value.TrimStart('0').TrimEnd('0').TrimEnd('.') : value.TrimStart('0');

매우 간단한 대답은 TrimEnd()를 사용하는 것입니다.여기 결과가 있습니다.

double value = 1.00;
string output = value.ToString().TrimEnd('0');

출력이 1이면 값이 1.01이면 출력이 1.01이 됩니다.

이렇게 해보세요.

string s = "2.4200";

s = s.TrimStart("0").TrimEnd("0", ".");

그리고 나서 그것을 부유로 변환합니다.

언급URL : https://stackoverflow.com/questions/4525854/remove-trailing-zeros