# 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`

Another method provides inspection:

- `inspect`

Finally, there is this query method:

- `nil?`

### Public Instance Methods

false & object → false click to toggle source
nil & object → false

Returns `false`:

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

Argument `object` is evaluated:

    false & raise # Raises RuntimeError.

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

true === other → true or false click to toggle source
false === other → true or false
nil === other → true or false

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.

    #define case_equal rb_equal

nil =~ object → nil click to toggle source

Returns `nil`.

This method makes it useful to write:

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

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

false ^ object → true or false click to toggle source
nil ^ object → true or false

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

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

    #define false_xor true_and

inspect → 'nil' click to toggle source

Returns string `'nil'`:

    nil.inspect # => "nil"

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

nil? → true click to toggle source

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

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

rationalize(eps = nil) → (0/1) click to toggle source

Returns zero as a Rational:

    nil.rationalize # => (0/1)

Argument `eps` is ignored.

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

to_a → [] click to toggle source

Returns an empty `Array`.

    nil.to_a # => []

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

to_c → (0+0i) click to toggle source

Returns zero as a Complex:

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

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

to_d → bigdecimal click to toggle source

Returns nil represented as a `BigDecimal`.

    require 'bigdecimal'
    require 'bigdecimal/util'

    nil.to_d   # => 0.0

    # File ext/bigdecimal/lib/bigdecimal/util.rb, line 182
    def to_d
      BigDecimal(0)
    end

to_f → 0.0 click to toggle source

Always returns zero.

    nil.to_f   #=> 0.0

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

to_h → {} click to toggle source

Returns an empty `Hash`.

    nil.to_h   #=> {}

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

to_i → 0 click to toggle source

Always returns zero.

    nil.to_i   #=> 0

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

to_r → (0/1) click to toggle source

Returns zero as a Rational:

    nil.to_r # => (0/1)

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

to_s → '' click to toggle source

Returns an empty String:

    nil.to_s # => ""

    VALUE
    rb_nil_to_s(VALUE obj)
    {
        return rb_cNilClass_to_s;
    }

false | object → true or false click to toggle source
nil | object → true or false

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

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

    #define false_or true_and