类 Integer

Integer 对象表示一个整数值。

您可以使用以下方法显式创建 Integer 对象：

整数字面量。

您可以使用以下方法将某些对象转换为 Integer：

方法 Integer。

尝试向此类的实例添加单例方法会导致引发异常。

内容¶ ↑

首先，看看其他地方。类 Integer

继承自类 Numeric。

这里，类 Integer 提供了以下方法：

查询¶ ↑

allbits?: 返回 self 中的所有位是否都被设置。
anybits?: 返回 self 中的任何位是否都被设置。
nobits?: 返回 self 中的任何位是否都没有被设置。

比较¶ ↑

<: 返回 self 是否小于给定值。
<=: 返回 self 是否小于或等于给定值。
<=>: 返回一个数字，指示 self 是否小于、等于或大于给定值。
== (别名为 ===): 返回 self 是否等于给定值。
```
value.
```
>: 返回 self 是否大于给定值。
>=: 返回 self 是否大于或等于给定值。

转换¶ ↑

::sqrt: 返回给定值的整数平方根。
::try_convert: 返回转换为整数的给定值。
% (别名为 modulo): 返回 self 对给定值的模。
&: 返回 self 和给定值的按位与。
*: 返回 self 和给定值的乘积。
**: 返回 self 的给定值次幂。
+: 返回 self 和给定值的和。
-: 返回 self 和给定值的差。
/: 返回 self 和给定值的商。
<<: 返回 self 左移后的值。
>>: 返回 self 右移后的值。
[]: 返回 self 中的一段位。
^: 返回 self 和给定值的按位异或。
ceil: 返回大于或等于 self 的最小数。
chr: 返回一个包含 self 值所表示的字符的 1 个字符的字符串。
digits: 返回一个表示 self 的基数为 radix 的数字的整数数组。
div: 返回 self 除以给定值的整数结果。
divmod: 返回一个包含 self 除以给定值的商和余数结果的 2 元素数组。
fdiv: 返回 self 除以给定值的 Float 结果。
floor: 返回小于或等于 self 的最大数。
pow: 返回 self 的模幂运算。
pred: 返回 self 的整数前驱。
remainder: 返回将self除以给定值后的余数。
round: 返回self四舍五入到给定精度的最接近的值。
succ (别名为 next): 返回self的整数后继。
to_f: 返回转换为 Float 的self。
to_s (别名为 inspect): 返回一个字符串，其中包含给定基数中self的位值表示。
truncate: 返回截断到给定精度的self。
|: 返回self和给定值的按位或运算结果。

其他¶ ↑

downto: 使用从self到给定值的每个整数值调用给定的块。
times: 使用(0..self-1)中的每个整数，调用给定的块self次。
upto: 使用从self到给定值的每个整数值调用给定的块。

常量

GMP_VERSION: 加载的 GMP 版本。

公共类方法

sqrt(numeric) → integer click to toggle source

返回非负整数n的整数平方根，它是小于或等于numeric平方根的最大非负整数。

Integer.sqrt(0)       # => 0
Integer.sqrt(1)       # => 1
Integer.sqrt(24)      # => 4
Integer.sqrt(25)      # => 5
Integer.sqrt(10**400) # => 10**200

如果numeric不是整数，则将其转换为整数。

Integer.sqrt(Complex(4, 0))  # => 2
Integer.sqrt(Rational(4, 1)) # => 2
Integer.sqrt(4.0)            # => 2
Integer.sqrt(3.14159)        # => 1

此方法等效于Math.sqrt(numeric).floor，但由于浮点数运算的精度有限，后者的结果可能与真实值不同。

Integer.sqrt(10**46)    # => 100000000000000000000000
Math.sqrt(10**46).floor # => 99999999999999991611392

如果numeric为负，则引发异常。

static VALUE
rb_int_s_isqrt(VALUE self, VALUE num)
{
    unsigned long n, sq;
    num = rb_to_int(num);
    if (FIXNUM_P(num)) {
        if (FIXNUM_NEGATIVE_P(num)) {
            domain_error("isqrt");
        }
        n = FIX2ULONG(num);
        sq = rb_ulong_isqrt(n);
        return LONG2FIX(sq);
    }
    else {
        size_t biglen;
        if (RBIGNUM_NEGATIVE_P(num)) {
            domain_error("isqrt");
        }
        biglen = BIGNUM_LEN(num);
        if (biglen == 0) return INT2FIX(0);
#if SIZEOF_BDIGIT <= SIZEOF_LONG
        /* short-circuit */
        if (biglen == 1) {
            n = BIGNUM_DIGITS(num)[0];
            sq = rb_ulong_isqrt(n);
            return ULONG2NUM(sq);
        }
#endif
        return rb_big_isqrt(num);
    }
}

try_convert(object) → object, integer, or nil click to toggle source

如果object是整数对象，则返回object。

Integer.try_convert(1) # => 1

否则，如果object响应:to_int，则调用object.to_int并返回结果。

Integer.try_convert(1.25) # => 1

如果object不响应:to_int，则返回nil。

Integer.try_convert([]) # => nil

除非object.to_int返回整数对象，否则引发异常。

static VALUE
int_s_try_convert(VALUE self, VALUE num)
{
    return rb_check_integer_type(num);
}

公共实例方法

self % other → real_number 点击切换源代码

返回 self 模 other 的结果，以实数形式表示。

对于整数 n 和实数 r，以下表达式等价

n % r
n-r*(n/r).floor
n.divmod(r)[1]

参见 Numeric#divmod.

示例

10 % 2              # => 0
10 % 3              # => 1
10 % 4              # => 2

10 % -2             # => 0
10 % -3             # => -2
10 % -4             # => -2

10 % 3.0            # => 1.0
10 % Rational(3, 1) # => (1/1)

VALUE
rb_int_modulo(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mod(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_modulo(x, y);
    }
    return num_modulo(x, y);
}

别名：modulo

self & other → integer 点击切换源代码

按位与运算；结果中每个位的值为 1，当且仅当 self 和 other 中对应位的值都为 1，否则为 0。

"%04b" % (0b0101 & 0b0110) # => "0100"

如果 other 不是整数，则会抛出异常。

相关方法：Integer#|（按位或运算），Integer#^（按位异或运算）。

VALUE
rb_int_and(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_and(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_and(x, y);
    }
    return Qnil;
}

self * numeric → numeric_result 点击切换源代码

执行乘法运算。

4 * 2              # => 8
4 * -2             # => -8
-4 * 2             # => -8
4 * 2.0            # => 8.0
4 * Rational(1, 3) # => (4/3)
4 * Complex(2, 0)  # => (8+0i)

VALUE
rb_int_mul(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mul(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_mul(x, y);
    }
    return rb_num_coerce_bin(x, y, '*');
}

self ** numeric → numeric_result 点击切换源代码

将 self 提升到 numeric 的幂。

2 ** 3              # => 8
2 ** -3             # => (1/8)
-2 ** 3             # => -8
-2 ** -3            # => (-1/8)
2 ** 3.3            # => 9.849155306759329
2 ** Rational(3, 1) # => (8/1)
2 ** Complex(3, 0)  # => (8+0i)

VALUE
rb_int_pow(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_pow(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_pow(x, y);
    }
    return Qnil;
}

self + numeric → numeric_result 点击切换源代码

执行加法运算。

2 + 2              # => 4
-2 + 2             # => 0
-2 + -2            # => -4
2 + 2.0            # => 4.0
2 + Rational(2, 1) # => (4/1)
2 + Complex(2, 0)  # => (4+0i)

VALUE
rb_int_plus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_plus(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_plus(x, y);
    }
    return rb_num_coerce_bin(x, y, '+');
}

self - numeric → numeric_result 点击切换源代码

执行减法运算。

4 - 2              # => 2
-4 - 2             # => -6
-4 - -2            # => -2
4 - 2.0            # => 2.0
4 - Rational(2, 1) # => (2/1)
4 - Complex(2, 0)  # => (2+0i)

VALUE
rb_int_minus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_minus(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_minus(x, y);
    }
    return rb_num_coerce_bin(x, y, '-');
}

-int → integer 点击切换源代码

返回 self 的负值。

# File numeric.rb, line 80
def -@
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_uminus(self)'
end

self / numeric → numeric_result 点击切换源代码

执行除法运算；对于整数 numeric，结果将截断为整数。

 4 / 3              # => 1
 4 / -3             # => -2
 -4 / 3             # => -2
 -4 / -3            # => 1

For other +numeric+, returns non-integer result:

 4 / 3.0            # => 1.3333333333333333
 4 / Rational(3, 1) # => (4/3)
 4 / Complex(3, 0)  # => ((4/3)+0i)

VALUE
rb_int_div(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_div(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_div(x, y);
    }
    return Qnil;
}

self < other → true or false 点击切换源代码

如果 self 的值小于 other 的值，则返回 true。

  1 < 0              # => false
  1 < 1              # => false
  1 < 2              # => true
  1 < 0.5            # => false
  1 < Rational(1, 2) # => false

Raises an exception if the comparison cannot be made.

static VALUE
int_lt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_lt(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_lt(x, y);
    }
    return Qnil;
}

self << count → integer 点击切换源代码

返回 self 的位向左移 count 位的结果，如果 count 为负数则向右移。

n = 0b11110000
"%08b" % (n << 1)  # => "111100000"
"%08b" % (n << 3)  # => "11110000000"
"%08b" % (n << -1) # => "01111000"
"%08b" % (n << -3) # => "00011110"