module Comparable

Das Comparable Mixin wird von Klassen verwendet, deren Objekte sortiert werden können. Die Klasse muss den <=> Operator definieren, der das Empfängerobjekt mit einem anderen Objekt vergleicht und je nachdem, ob das Empfängerobjekt kleiner als, gleich oder größer als das andere Objekt ist, einen Wert kleiner als 0, 0 oder größer als 0 zurückgibt. Wenn das andere Objekt nicht vergleichbar ist, sollte der <=> Operator nil zurückgeben. Comparable verwendet <=>, um die konventionellen Vergleichsoperatoren (<, <=, ==, >= und >) sowie die Methode between? zu implementieren.

class StringSorter
  include Comparable

  attr :str
  def <=>(other)
    str.size <=> other.str.size
  end

  def initialize(str)
    @str = str
  end

  def inspect
    @str
  end
end

s1 = StringSorter.new("Z")
s2 = StringSorter.new("YY")
s3 = StringSorter.new("XXX")
s4 = StringSorter.new("WWWW")
s5 = StringSorter.new("VVVVV")

s1 < s2                       #=> true
s4.between?(s1, s3)           #=> false
s4.between?(s3, s5)           #=> true
[ s3, s2, s5, s4, s1 ].sort   #=> [Z, YY, XXX, WWWW, VVVVV]

Was gibt es hier

Modul Comparable stellt diese Methoden bereit, die alle die Methode <=> verwenden

<: Gibt zurück, ob self kleiner als das gegebene Objekt ist.
<=: Gibt zurück, ob self kleiner oder gleich dem gegebenen Objekt ist.
==: Gibt zurück, ob self gleich dem gegebenen Objekt ist.
>: Gibt zurück, ob self größer als das gegebene Objekt ist.
>=: Gibt zurück, ob self größer oder gleich dem gegebenen Objekt ist.
between?: Gibt true zurück, wenn self zwischen zwei gegebenen Objekten liegt.
clamp: Für gegebene Objekte min und max oder den Bereich (min..max) gibt
- min zurück, wenn (self <=> min) < 0.
- max zurück, wenn (self <=> max) > 0.
- self andernfalls.

Öffentliche Instanzmethoden

self < other → true or false

Source

static VALUE
cmp_lt(VALUE x, VALUE y)
{
    return RBOOL(cmpint(x, y) < 0);
}

Gibt zurück, ob self "kleiner als" other ist; äquivalent zu (self <=> other) < 0

'foo' < 'foo'  # => false
'foo' < 'food' # => true

self <= other → true or false

Source

static VALUE
cmp_le(VALUE x, VALUE y)
{
    return RBOOL(cmpint(x, y) <= 0);
}

Gibt zurück, ob self "kleiner oder gleich" other ist; äquivalent zu (self <=> other) <= 0

'foo' <= 'foo'  # => true
'foo' <= 'food' # => true
'food' <= 'foo' # => false

obj == other → true oder false

Source

static VALUE
cmp_equal(VALUE x, VALUE y)
{
    VALUE c;
    if (x == y) return Qtrue;

    c = rb_exec_recursive_paired_outer(cmp_eq_recursive, x, y, y);

    if (NIL_P(c)) return Qfalse;
    return RBOOL(rb_cmpint(c, x, y) == 0);
}

Vergleicht zwei Objekte basierend auf der <=> Methode des Empfängerobjekts und gibt true zurück, wenn diese 0 zurückgibt. Gibt auch true zurück, wenn obj und other dasselbe Objekt sind.

obj > other → true oder false

Source

static VALUE
cmp_gt(VALUE x, VALUE y)
{
    return RBOOL(cmpint(x, y) > 0);
}

Vergleicht zwei Objekte basierend auf der <=> Methode des Empfängerobjekts und gibt true zurück, wenn diese einen Wert größer als 0 zurückgibt.

obj >= other → true oder false

Source

static VALUE
cmp_ge(VALUE x, VALUE y)
{
    return RBOOL(cmpint(x, y) >= 0);
}

Vergleicht zwei Objekte basierend auf der <=> Methode des Empfängerobjekts und gibt true zurück, wenn diese einen Wert größer oder gleich 0 zurückgibt.

zwischen?(min, max) → true oder false

Source

static VALUE
cmp_between(VALUE x, VALUE min, VALUE max)
{
    return RBOOL((cmpint(x, min) >= 0 && cmpint(x, max) <= 0));
}

Gibt false zurück, wenn obj <=> min kleiner als Null ist oder wenn obj <=> max größer als Null ist, andernfalls true.

3.between?(1, 5)               #=> true
6.between?(1, 5)               #=> false
'cat'.between?('ant', 'dog')   #=> true
'gnu'.between?('ant', 'dog')   #=> false

clamp(min, max) → obj

clamp(range) → obj

Source

static VALUE
cmp_clamp(int argc, VALUE *argv, VALUE x)
{
    VALUE min, max;
    int c, excl = 0;

    if (rb_scan_args(argc, argv, "11", &min, &max) == 1) {
        VALUE range = min;
        if (!rb_range_values(range, &min, &max, &excl)) {
            rb_raise(rb_eTypeError, "wrong argument type %s (expected Range)",
                     rb_builtin_class_name(range));
        }
        if (!NIL_P(max)) {
            if (excl) rb_raise(rb_eArgError, "cannot clamp with an exclusive range");
        }
    }
    if (!NIL_P(min) && !NIL_P(max) && cmpint(min, max) > 0) {
        rb_raise(rb_eArgError, "min argument must be less than or equal to max argument");
    }

    if (!NIL_P(min)) {
        c = cmpint(x, min);
        if (c == 0) return x;
        if (c < 0) return min;
    }
    if (!NIL_P(max)) {
        c = cmpint(x, max);
        if (c > 0) return max;
    }
    return x;
}

In der Form (min, max) gibt min zurück, wenn obj <=> min kleiner als Null ist, max, wenn obj <=> max größer als Null ist, und andernfalls obj.

12.clamp(0, 100)         #=> 12
523.clamp(0, 100)        #=> 100
-3.123.clamp(0, 100)     #=> 0

'd'.clamp('a', 'f')      #=> 'd'
'z'.clamp('a', 'f')      #=> 'f'

Wenn min nil ist, wird es als kleiner als obj betrachtet, und wenn max nil ist, wird es als größer als obj betrachtet.

-20.clamp(0, nil)           #=> 0
523.clamp(nil, 100)         #=> 100

In der Form (range) gibt range.begin zurück, wenn obj <=> range.begin kleiner als Null ist, range.end, wenn obj <=> range.end größer als Null ist, und andernfalls obj.

12.clamp(0..100)         #=> 12
523.clamp(0..100)        #=> 100
-3.123.clamp(0..100)     #=> 0

'd'.clamp('a'..'f')      #=> 'd'
'z'.clamp('a'..'f')      #=> 'f'

Wenn range.begin nil ist, wird es als kleiner als obj betrachtet, und wenn range.end nil ist, wird es als größer als obj betrachtet.

-20.clamp(0..)           #=> 0
523.clamp(..100)         #=> 100

Wenn range.end ausgeschlossen und nicht nil ist, wird eine Ausnahme ausgelöst.

100.clamp(0...100)       # ArgumentError