# class NilClass

The class of the singleton object `nil`.

Several of its methods act as operators:

- `&`

- `|`

- `===`

- `=~`

- `^`

Others act as converters, carrying the concept of nullity to other classes:

- `rationalize`

- `to_a`

- `to_c`

- `to_h`

- `to_r`

- `to_s`

While `nil` doesn’t have an explicitly defined to_hash method, it can be used in `**` unpacking, not adding any keyword arguments.

Another method provides inspection:

- `inspect`

Finally, there is this query method:

- `nil?`

### Public Instance Methods

false & object → false
nil & object → false
Source

    static VALUE
    false_and(VALUE obj, VALUE obj2)
    {
        return Qfalse;
    }

Returns `false`:

    false & true       # => false
    false & Object.new # => false

Argument `object` is evaluated:

    false & raise # Raises RuntimeError.

true === other → true or false
false === other → true or false
nil === other → true or false
Source

    #define case_equal rb_equal

Returns `true` or `false`.

Like `Object#==`, if `object` is an instance of `Object` (and not an instance of one of its many subclasses).

This method is commonly overridden by those subclasses, to provide meaningful semantics in `case` statements.

nil =~ object → nil
Source

    static VALUE
    nil_match(VALUE obj1, VALUE obj2)
    {
        return Qnil;
    }

Returns `nil`.

This method makes it useful to write:

    while gets =~ /re/
      # ...
    end

false ^ object → true or false
nil ^ object → true or false
Source

    #define false_xor true_and

Returns `false` if `object` is `nil` or `false`, `true` otherwise:

    nil ^ nil        # => false
    nil ^ false      # => false
    nil ^ Object.new # => true

false | object → true or false
nil | object → true or false
Source

    #define false_or true_and

Returns `false` if `object` is `nil` or `false`, `true` otherwise:

    nil | nil        # => false
    nil | false      # => false
    nil | Object.new # => true

inspect → 'nil'
Source

    static VALUE
    nil_inspect(VALUE obj)
    {
        return rb_usascii_str_new2("nil");
    }

Returns string `'nil'`:

    nil.inspect # => "nil"

nil? → true
Source

    static VALUE
    rb_true(VALUE obj)
    {
        return Qtrue;
    }

Returns `true`. For all other objects, method `nil?` returns `false`.

rationalize(eps = nil) → (0/1)
Source

    static VALUE
    nilclass_rationalize(int argc, VALUE *argv, VALUE self)
    {
        rb_check_arity(argc, 0, 1);
        return nilclass_to_r(self);
    }

Returns zero as a Rational:

    nil.rationalize # => (0/1)

Argument `eps` is ignored.

to_a → []
Source

    static VALUE
    nil_to_a(VALUE obj)
    {
        return rb_ary_new2(0);
    }

Returns an empty `Array`.

    nil.to_a # => []

to_c → (0+0i)
Source

    static VALUE
    nilclass_to_c(VALUE self)
    {
        return rb_complex_new1(INT2FIX(0));
    }

Returns zero as a Complex:

    nil.to_c # => (0+0i)

to_f → 0.0
Source

    # File nilclass.rb, line 22
    def to_f
      return 0.0
    end

Always returns zero.

    nil.to_f   #=> 0.0

to_h → {}
Source

    static VALUE
    nil_to_h(VALUE obj)
    {
        return rb_hash_new();
    }

Returns an empty `Hash`.

    nil.to_h   #=> {}

to_i → 0
Source

    # File nilclass.rb, line 10
    def to_i
      return 0
    end

Always returns zero.

    nil.to_i   #=> 0

to_r → (0/1)
Source

    static VALUE
    nilclass_to_r(VALUE self)
    {
        return rb_rational_new1(INT2FIX(0));
    }

Returns zero as a Rational:

    nil.to_r # => (0/1)

to_s → ''
Source

    VALUE
    rb_nil_to_s(VALUE obj)
    {
        return rb_cNilClass_to_s;
    }

Returns an empty String:

    nil.to_s # => ""