当前位置： 文江博客话题详情

内置 .Net 算法将值舍入到最接近的 10 区间

发布于 2024-07-08 18:23:27 字数 245 浏览 7 评论 0原文

在 C# 中，如何将任意值舍入为 10 区间？ 例如，如果我有 11，我希望它返回 10，如果我有 136，那么我希望它返回 140。

我可以轻松地手动完成

return ((int)(number / 10)) * 10;

但我正在寻找一个内置算法来完成这项工作，例如数学.Round(). 我不想手工完成的原因是我不想在我的项目中编写相同或相似的代码，即使是像上面这样简单的事情。

原文

How to, in C# round any value to 10 interval? For example, if I have 11, I want it to return 10, if I have 136, then I want it to return 140.

I can easily do it by hand

return ((int)(number / 10)) * 10;

But I am looking for an builtin algorithm to do this job, something like Math.Round(). The reason why I won't want to do by hand is that I don't want to write same or similar piece of code all over my projects, even for something as simple as the above.

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论， 你可以免费 注册 一个本站的账号。

评论（8）

风筝有风，海豚有海 2024-07-15 18:23:27

类库中没有内置函数可以执行此操作。 最接近的是 System.Math.Round()仅适用于将 Decimal 和 Double 类型的数字舍入到最接近的整数值。 但是，如果您使用的是 .NET 3.5，则可以将语句包装在扩展方法中，这将使您能够更干净地使用该函数。

public static class ExtensionMethods
{
    public static int RoundOff (this int i)
    {
        return ((int)Math.Round(i / 10.0)) * 10;
    }
}

int roundedNumber = 236.RoundOff(); // returns 240
int roundedNumber2 = 11.RoundOff(); // returns 10

如果您正在针对旧版本的 .NET 框架进行编程，只需从 RoundOff 函数中删除“this”，然后像这样调用该函数：

int roundedNumber = ExtensionMethods.RoundOff(236); // returns 240
int roundedNumber2 = ExtensionMethods.RoundOff(11); // returns 10

There is no built-in function in the class library that will do this. The closest is System.Math.Round() which is only for rounding numbers of types Decimal and Double to the nearest integer value. However, you can wrap your statement up in a extension method, if you are working with .NET 3.5, which will allow you to use the function much more cleanly.

public static class ExtensionMethods
{
    public static int RoundOff (this int i)
    {
        return ((int)Math.Round(i / 10.0)) * 10;
    }
}

int roundedNumber = 236.RoundOff(); // returns 240
int roundedNumber2 = 11.RoundOff(); // returns 10

If you are programming against an older version of the .NET framework, just remove the "this" from the RoundOff function, and call the function like so:

int roundedNumber = ExtensionMethods.RoundOff(236); // returns 240
int roundedNumber2 = ExtensionMethods.RoundOff(11); // returns 10
回复 原文
橙幽之幻 2024-07-15 18:23:27

使用 Math.Ceiling 始终向上舍入。

int number = 236;
number = (int)(Math.Ceiling(number / 10.0d) * 10);

Modulus(%) 得到余数，所以你得到：

// number = 236 + 10 - 6

将其放入上面编辑的扩展方法中

public static int roundupbyten(this int i){
    // return i + (10 - i % 10); <-- logic error. Oops!
    return (int)(Math.Ceiling(i / 10.0d)*10); // fixed
}

// call like so:
int number = 236.roundupbyten();

： 我应该本能地使用 Math.Ceiling

我 在计算 UPC 校验位时在博客上讨论了这一点。

Use Math.Ceiling to always round up.

int number = 236;
number = (int)(Math.Ceiling(number / 10.0d) * 10);

Modulus(%) gets the remainder, so you get:

// number = 236 + 10 - 6

Put that into an extension method

public static int roundupbyten(this int i){
    // return i + (10 - i % 10); <-- logic error. Oops!
    return (int)(Math.Ceiling(i / 10.0d)*10); // fixed
}

// call like so:
int number = 236.roundupbyten();

above edited: I should've gone with my first instinct to use Math.Ceiling

I blogged about this when calculating UPC check digits.

回复 原文
夜空下最亮的亮点 2024-07-15 18:23:27

这可能有点太晚了，但我想有一天这可能会有很好的帮助...

我已经尝试过：

public int RoundOff(int number, int interval){
    int remainder = number % interval;
    number += (remainder < interval / 2) ? -remainder : (interval - remainder);
    return number;
}

使用：

int number = 11;
int roundednumber = RoundOff(number, 10);

这样，您可以选择是否将间隔的一半向上舍入或向下舍入。 =)

This might be a little too late but I guess this might be of good help someday...

I have tried this:

public int RoundOff(int number, int interval){
    int remainder = number % interval;
    number += (remainder < interval / 2) ? -remainder : (interval - remainder);
    return number;
}

To use:

int number = 11;
int roundednumber = RoundOff(number, 10);

This way, you have the option whether if the half of the interval will be rounded up or rounded down. =)

回复 原文
追风人 2024-07-15 18:23:27

将浮点数舍入为整数类似于 (int)(x+0.5)，而不是简单地转换 x - 如果您想要 10 的倍数，您可以轻松调整。

如果您只想进行整数数学运算并将其四舍五入为 10，请尝试 (x+10/2)/10*10。

编辑：我注意到这个回复不符合原作者的要求，也是一种我不喜欢做的有偏见的四舍五入形式。 然而，另一个接受的回复已经指出了 Math.round()，这是一个更好的解决方案。

Rounding a float to an integer is similar to (int)(x+0.5), as opposed to simply casting x - if you want a multiple of 10, you can easily adapt that.

If you just want to do integer math and are rounding it to ten, try (x+10/2)/10*10.

Edit: I noticed that this response doesn't meet the original's author's request, and is also a biased form of rounding that I prefer not to do. However, another accepted response already stated Math.round(), a much better solution.

回复 原文
人生戏 2024-07-15 18:23:27

老问题，但这里有一种方法可以完成所要求的任务，而且我将其扩展为能够将任何数字四舍五入到您想要的符号数。

    private double Rounding(double d, int digits)
    {
        int neg = 1;
        if (d < 0)
        {
            d = d * (-1);
            neg = -1;
        }

        int n = 0;
        if (d > 1)
        {
            while (d > 1)
            {
                d = d / 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d * Math.Pow(10, n - digits);
        }
        else
        {
            while (d < 0.1)
            {
                d = d * 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d / Math.Pow(10, n + digits);
        }

        return d*neg;
    }


   private void testing()
   {
       double a = Rounding(1230435.34553,3);
       double b = Rounding(0.004567023523,4);
       double c = Rounding(-89032.5325,2);
       double d = Rounding(-0.123409,4);
       double e = Rounding(0.503522,1);
       Console.Write(a.ToString() + "\n" + b.ToString() + "\n" + 
           c.ToString() + "\n" + d.ToString() + "\n" + e.ToString() + "\n");
   }

Old question but here is a way to do what has been asked plus I extended it to be able to round any number to the number of sig figs you want.

    private double Rounding(double d, int digits)
    {
        int neg = 1;
        if (d < 0)
        {
            d = d * (-1);
            neg = -1;
        }

        int n = 0;
        if (d > 1)
        {
            while (d > 1)
            {
                d = d / 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d * Math.Pow(10, n - digits);
        }
        else
        {
            while (d < 0.1)
            {
                d = d * 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d / Math.Pow(10, n + digits);
        }

        return d*neg;
    }


   private void testing()
   {
       double a = Rounding(1230435.34553,3);
       double b = Rounding(0.004567023523,4);
       double c = Rounding(-89032.5325,2);
       double d = Rounding(-0.123409,4);
       double e = Rounding(0.503522,1);
       Console.Write(a.ToString() + "\n" + b.ToString() + "\n" + 
           c.ToString() + "\n" + d.ToString() + "\n" + e.ToString() + "\n");
   }
回复 原文
暗恋未遂 2024-07-15 18:23:27

我不喜欢引入 Math 库，也不使用浮点，所以我的建议是只进行整数算术，如下所示，我四舍五入到下一个 1K。 如果您不想重复，请将其包装在方法或 lambda 片段或其他内容中。

int MyRoundedUp1024Int = ((lSomeInteger + 1023) / 1024) * 1024;

我还没有对这种方式与其他方式进行性能测试，但我敢打赌这是最快的方式来做到这一点，保存可能是这种方式的移位和旋转位版本。

I prefer to not bring in the Math library nor go to floating point so my suggestion is just do integer arithmetic like below where I round up to the next 1K. Wrap it in a method or lambda snippet or something if you don't want to repeat.

int MyRoundedUp1024Int = ((lSomeInteger + 1023) / 1024) * 1024;

I have not run performance tests on this vs. other the ways but I'd bet it is the fastest way to do this save maybe a shifting and rotating of bits version of this.

回复 原文
南风几经秋 2024-07-15 18:23:27

以下是我如何舍入到任意因子的最接近倍数，而不从整数类型转换为浮点值。 这适用于从 int.MinValue + 1 到 int.MaxValue 的任何 int

我使用了 从零方程舍入一半，Round(x) = sgn(x)*Floor(Abs(x) + 0.5)，事实Floor(z) = z - (z%1) 和我想要的输出方程 F(value, factor) = Round(value/factor)*factor 来推导不需要精确小数除法的方程。

public static int RoundToNearestMultipleOfFactor(this int value, int factor)
{
    if (factor == 0)
    {
        throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
    }

    var halfAbsFactor = Math.Abs(factor) >> 1;
    return value + Math.Sign(value) * (halfAbsFactor - (Math.Abs(value) % factor + halfAbsFactor % factor) % factor);
}

下面是整个扩展方法类，其中包含 int 和 long 的方法以及仅朝零或远离零舍入的方法。

/// <summary>
/// Extension methods for rounding integral numeric types
/// </summary>
public static class IntegralRoundingExtensions
{
    /// <summary>
    /// Rounds to the nearest multiple of a <paramref name="factor"/> using <see cref="MidpointRounding.AwayFromZero"/> for midpoints.
    /// <para>
    /// Performs the operation Round(value / factor) * factor without converting to a floating type.
    /// </para>
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <remarks>
    /// Uses math derived from the <see href="https://en.wikipedia.org/wiki/Rounding#Round_half_away_from_zero">Round half away from zero equation</see>: y = sgn(x)*Floor(Abs(x) + 0.5) and floor equation: Floor(z) = z - (z % 1)
    /// </remarks>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    /// <seealso cref="MidpointRounding"/>
    public static long RoundToNearestMultipleOfFactor(this long value, long factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var halfAbsFactor = Math.Abs(factor) >> 1;
        // return value + Math.Sign(value) * (halfAbsFactor - ((Math.Abs(value) + halfAbsFactor) % factor));
        //fix overflow
        return value + Math.Sign(value) * (halfAbsFactor - (Math.Abs(value) % factor + halfAbsFactor % factor) % factor);
    }

    /// <summary>
    /// Round to the nearest multiple of <paramref name="factor"/> with magnitude less than or equal to <paramref name="value"/>.
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    public static long RoundToMultipleOfFactorTowardZero(this long value, long factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var remainder = value % factor; // negative iff value is negative

        if (remainder == 0)
        {
            return value;
        }

        return value - remainder;
    }

    /// <summary>
    /// Round to the nearest multiple of <paramref name="factor"/> with magnitude greater than or equal to <paramref name="value"/>.
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    public static long RoundToMultipleOfFactorAwayFromZero(this long value, long factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var remainder = value % factor; // negative iff value is negative

        if (remainder == 0)
        {
            return value;
        }

        return value - remainder + Math.Sign(value) * Math.Abs(factor);
    }

    /// <summary>
    /// Rounds to the nearest multiple of a <paramref name="factor"/> using <see cref="MidpointRounding.AwayFromZero"/> for midpoints.
    /// <para>
    /// Performs the operation Round(value / factor) * factor without converting to a floating type.
    /// </para>
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <remarks>
    /// Uses math derived from the <see href="https://en.wikipedia.org/wiki/Rounding#Round_half_away_from_zero">Round half away from zero equation</see>: y = sgn(x)*Floor(Abs(x) + 0.5) and floor equation: Floor(z) = z - (z % 1)
    /// </remarks>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    /// <seealso cref="MidpointRounding"/>
    public static int RoundToNearestMultipleOfFactor(this int value, int factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var halfAbsFactor = Math.Abs(factor) >> 1;
        // return value + Math.Sign(value) * (halfAbsFactor - ((Math.Abs(value) + halfAbsFactor) % factor));
        //fix overflow
        return value + Math.Sign(value) * (halfAbsFactor - (Math.Abs(value) % factor + halfAbsFactor % factor) % factor);
    }

    /// <summary>
    /// Round to the nearest multiple of <paramref name="factor"/> with magnitude less than or equal to <paramref name="value"/>.
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    public static int RoundToMultipleOfFactorTowardZero(this int value, int factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var remainder = value % factor; // negative iff value is negative

        if (remainder == 0)
        {
            return value;
        }

        return value - remainder;
    }

    /// <summary>
    /// Round to the nearest multiple of <paramref name="factor"/> with magnitude greater than or equal to <paramref name="value"/>.
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    public static int RoundToMultipleOfFactorAwayFromZero(this int value, int factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var remainder = value % factor; // negative iff value is negative

        if (remainder == 0)
        {
            return value;
        }

        return value - remainder + Math.Sign(value) * Math.Abs(factor);
    }
}

Here's how I round to the nearest multiple of any arbitrary factor without converting from integral types to floating-point values. This works for any int from int.MinValue + 1 to int.MaxValue

I used the Round half away from zero equation, Round(x) = sgn(x)*Floor(Abs(x) + 0.5), the fact that Floor(z) = z - (z%1), and my desired output equation F(value, factor) = Round(value/factor)*factor to derive the an equation that doesn't require precise decimal division.

public static int RoundToNearestMultipleOfFactor(this int value, int factor)
{
    if (factor == 0)
    {
        throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
    }

    var halfAbsFactor = Math.Abs(factor) >> 1;
    return value + Math.Sign(value) * (halfAbsFactor - (Math.Abs(value) % factor + halfAbsFactor % factor) % factor);
}

Here's the entire extension method class with methods for both int and long as well as methods to round only toward or away from zero.

/// <summary>
/// Extension methods for rounding integral numeric types
/// </summary>
public static class IntegralRoundingExtensions
{
    /// <summary>
    /// Rounds to the nearest multiple of a <paramref name="factor"/> using <see cref="MidpointRounding.AwayFromZero"/> for midpoints.
    /// <para>
    /// Performs the operation Round(value / factor) * factor without converting to a floating type.
    /// </para>
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <remarks>
    /// Uses math derived from the <see href="https://en.wikipedia.org/wiki/Rounding#Round_half_away_from_zero">Round half away from zero equation</see>: y = sgn(x)*Floor(Abs(x) + 0.5) and floor equation: Floor(z) = z - (z % 1)
    /// </remarks>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    /// <seealso cref="MidpointRounding"/>
    public static long RoundToNearestMultipleOfFactor(this long value, long factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var halfAbsFactor = Math.Abs(factor) >> 1;
        // return value + Math.Sign(value) * (halfAbsFactor - ((Math.Abs(value) + halfAbsFactor) % factor));
        //fix overflow
        return value + Math.Sign(value) * (halfAbsFactor - (Math.Abs(value) % factor + halfAbsFactor % factor) % factor);
    }

    /// <summary>
    /// Round to the nearest multiple of <paramref name="factor"/> with magnitude less than or equal to <paramref name="value"/>.
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    public static long RoundToMultipleOfFactorTowardZero(this long value, long factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var remainder = value % factor; // negative iff value is negative

        if (remainder == 0)
        {
            return value;
        }

        return value - remainder;
    }

    /// <summary>
    /// Round to the nearest multiple of <paramref name="factor"/> with magnitude greater than or equal to <paramref name="value"/>.
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    public static long RoundToMultipleOfFactorAwayFromZero(this long value, long factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var remainder = value % factor; // negative iff value is negative

        if (remainder == 0)
        {
            return value;
        }

        return value - remainder + Math.Sign(value) * Math.Abs(factor);
    }

    /// <summary>
    /// Rounds to the nearest multiple of a <paramref name="factor"/> using <see cref="MidpointRounding.AwayFromZero"/> for midpoints.
    /// <para>
    /// Performs the operation Round(value / factor) * factor without converting to a floating type.
    /// </para>
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <remarks>
    /// Uses math derived from the <see href="https://en.wikipedia.org/wiki/Rounding#Round_half_away_from_zero">Round half away from zero equation</see>: y = sgn(x)*Floor(Abs(x) + 0.5) and floor equation: Floor(z) = z - (z % 1)
    /// </remarks>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    /// <seealso cref="MidpointRounding"/>
    public static int RoundToNearestMultipleOfFactor(this int value, int factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var halfAbsFactor = Math.Abs(factor) >> 1;
        // return value + Math.Sign(value) * (halfAbsFactor - ((Math.Abs(value) + halfAbsFactor) % factor));
        //fix overflow
        return value + Math.Sign(value) * (halfAbsFactor - (Math.Abs(value) % factor + halfAbsFactor % factor) % factor);
    }

    /// <summary>
    /// Round to the nearest multiple of <paramref name="factor"/> with magnitude less than or equal to <paramref name="value"/>.
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    public static int RoundToMultipleOfFactorTowardZero(this int value, int factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var remainder = value % factor; // negative iff value is negative

        if (remainder == 0)
        {
            return value;
        }

        return value - remainder;
    }

    /// <summary>
    /// Round to the nearest multiple of <paramref name="factor"/> with magnitude greater than or equal to <paramref name="value"/>.
    /// </summary>
    /// <param name="value">The value to round.</param>
    /// <param name="factor">The factor to round to a multiple of. Must not be zero. Sign does not matter.</param>
    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="factor"/> is zero</exception>
    public static int RoundToMultipleOfFactorAwayFromZero(this int value, int factor)
    {
        if (factor == 0)
        {
            throw new ArgumentOutOfRangeException(nameof(factor), factor, "Cannot be zero");
        }

        var remainder = value % factor; // negative iff value is negative

        if (remainder == 0)
        {
            return value;
        }

        return value - remainder + Math.Sign(value) * Math.Abs(factor);
    }
}
回复 原文
梅倚清风 2024-07-15 18:23:27

据我所知，没有一个原生的内置 C# 库可以将整数四舍五入到最接近的十位。

如果您使用的是 c# 8 或更高版本，您可以创建小型开关表达式实用程序方法，这些方法可以做很多很酷的有用的事情。 如果您使用的是旧版本，则可以使用 if/else 和 switch case 块：

public static int RoundIntToTens(int anInt)
   => (anInt, (anInt < 0 ? 0 - anInt : anInt) % 10) switch
   {
       // If int needs to be "round down" and is negative or positive
       (>= 0, < 5) or (< 0, < 5) => anInt - anInt % 10,
       // If int needs to be "round up" and is NOT negative (but might be 0)
       (>= 0, >= 5) => anInt + (10 - anInt % 10),
       // If int needs to be "round up" and is negative
       (< 0, >= 5) => anInt - (10 + anInt % 10)
    };

您必须在使用它的任何地方导入它，但这会任何库都是如此，除非有办法将类添加到全局名称空间。

As far as I know there isn't a native built-in c# library that rounds integers to the nearest tens place.

If you're using c# 8 or later you can create small switch expression utility methods that can do a lot of cool helpful things. If you're using an older version, if/else and switch case blocks can be used instead:

public static int RoundIntToTens(int anInt)
   => (anInt, (anInt < 0 ? 0 - anInt : anInt) % 10) switch
   {
       // If int needs to be "round down" and is negative or positive
       (>= 0, < 5) or (< 0, < 5) => anInt - anInt % 10,
       // If int needs to be "round up" and is NOT negative (but might be 0)
       (>= 0, >= 5) => anInt + (10 - anInt % 10),
       // If int needs to be "round up" and is negative
       (< 0, >= 5) => anInt - (10 + anInt % 10)
    };

You would have to import it where ever you use it but that'd be the case with any library unless there's a way to add classes to a global name space.

回复 原文
~没有更多了~

关于作者

要走干脆点

暂无简介

文章
评论
26 人气
发私信

相关话题

更多

热门标签

操作系统 程序设计 IT运维 Linux系统管理 JavaScript 服务器应用 solaris C/C++ PHP Shell BSD Vue.js aix Oracle Python HTML 系统管理 HTML5 CSS 前端
更多

推荐作者

西西弗的石头怪

文章 0 评论 0

5397313

文章 0 评论 0

烟沫凡尘

文章 0 评论 0

一个破名字

文章 0 评论 0

萌︼了一个春

文章 0 评论 0

当爱已成负担

文章 0 评论 0

更多

友情链接

文江博客
    我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站，即表示您同意使用 Cookies 和您的相关数据。
    原文