==, equal?, eql?, === w Ruby: co sprawdzają i kiedy używać

29 paź 20:47

3 min. czytania

Spis treściKliknij link, aby przejść do wybranego miejsca

Ta treść została automatycznie przetłumaczona z ukraińskiego.

W Ruby istnieje kilka sposobów porównywania. Na pierwszy rzut oka są podobne, ale działają zupełnie inaczej.

== (sprawdzanie równości wartości)

Sprawdza, czy obie obiekty mają tę samą zawartość.
Często jest przesłaniane w klasach (String, Array, Hash), aby porównywać wartości, a nie tożsamość.

a = "hello"
b = "hello"

a == b        # => true
a.equal?(b)   # => false

== pyta: "Czy te obiekty mają tę samą zawartość?"

a = "hello"
b = "hello"
c = a

a.equal?(b)  # => false
a.equal?(c)  # => true

Aby zrozumieć to wszystko, trzeba wiedzieć, czym jest obiekt w Ruby.

1 == 1.0     # => true
1.eql?(1.0)  # => false, ponieważ różne klasy (Integer vs Float)

eql? jest bardziej rygorystyczne niż ==.

Używane głównie w konstrukcji case (omówimy to poniżej).
Dla różnych klas zachowuje się różnie:
- W klasach (String, Integer) - sprawdza, czy obiekt należy do klasy (is_a?).
- W wyrażeniach regularnych - sprawdza, czy ciąg pasuje do wzorca.
- W Range - czy obiekt mieści się w zakresie.

case 5
when 1..10
  "W zakresie"   # => "W zakresie"
end

String === "hello"  # => true
/ell/ === "hello"   # => true

Przyjrzyjmy się nieco bliżej przykładzie z case. Jak działa case … when w Ruby?

Składnia:

case obiekt
when wzorzec1
  kod1
when wzorzec2
  kod2
else
  kod_domyslny
end

Co się dzieje pod maską

Ruby robi mniej więcej tak:

if wzorzec1 === obiekt
  kod1
elsif wzorzec2 === obiekt
  kod2
else
  kod_domyslny
end

To znaczy, że when automatycznie używa === do porównania z wartością case.

Poniżej przykłady dla różnych typów

Zakres (Range)

case 5
when 1..10
  "W zakresie"
else
  "Poza zakresem"
end
# => "W zakresie"

Działa tak, jakby Ruby wykonywał (to pseudokod):

(1..10) === 5  # => true

Jednak ważne jest, aby zauważyć, że zwykłe użycie === na liczbach czy innych typach niekoniecznie działa tak samo:

10 === (1..20)   # => false
10 == (1..20)    # => false
(1..20) == 10    # => false

Tu Range#=== sprawdza, czy liczba mieści się w zakresie.

Klasa

case "hello"
when String
  "To jest ciąg"
when Integer
  "To jest liczba"
end
# => "To jest ciąg"

Ruby wykonuje:

String === "hello"   # => true
Integer === "hello"  # => false

Dla klas === to skrót dla obj.is_a?(Klasa).

c) Wyrażenie regularne

case "hello"
when /ell/
  "Dopasowanie do wzorca"
else
  "Brak dopasowania"
end
# => "Dopasowanie do wzorca"

Pod maską:

/ell/ === "hello"   # => true

Dla Regexp === sprawdza, czy ciąg odpowiada wzorcowi.

Odeszliśmy nieco od tematu === i przeszliśmy do case (bo tam === jest pod maską). Taki prosty operator, ale robi różne rzeczy.

Aby łatwiej zapamiętać:

case x; when y - to nie x == y, ale y === x.
=== działa różnie w zależności od typu y:
- Class -> is_a?
- Range -> include?
- Regexp -> =~ (dopasowanie ciągu)

To pozwala na bardzo elastyczne pisanie warunków.