X'inhi l-utent ta' "everything is an object" fil-Ruby?

Question

Accepted Answer

Fil-Ruby, **everything is an object** — inklużi numri, strings, `nil`, `true`/`false`, u anke l-klassijiet nfushom. Kull valur għandu metodi li tista' tassew fuqhom, u m'hemm l-ebda primitive types (differenti minn Java/C# li għandhom value-type primitives). Din il-konsistenza hija parti ċentrali tal-disinn tar-Ruby.

## Anke numri u nil għandhom metodi

```ruby
42.even?             # true — Integer is an object with methods
42.times { ... }     # call a method on a number
(-5).abs             # 5
3.14.round           # 3

nil.to_s             # "" — even nil is an object (NilClass)
nil.nil?             # true
true.class           # TrueClass — booleans are objects too
"hello".length       # strings are objects
```

Differenti minn lingwi bi primitive types, fil-Ruby `42` huwa object sħiħ (instanza ta' `Integer`) — tassew metodi direttament fuqhom (`42.even?`, `42.times`). Anke `nil`, `true`, u `false` huma objekti b'klassijiet u metodi tiegħhom stess.

## Klassijiet huma objekti wkoll

```ruby
String.class         # Class — a class is itself an object (an instance of Class)
42.class             # Integer
42.class.class       # Class
Integer.ancestors    # [Integer, Numeric, Comparable, Object, ...] — the class hierarchy
```

Anke **klassijiet huma objekti** (instanzi ta' `Class`) — li huwa dak li jippermetti r-Ruby's powerful metaprogramming (tista' timmanipula klassijiet fil-ħin tal-eżekuzzjoni).

## Kollox jeredi minn BasicObject/Object

```ruby
42.is_a?(Object)     # true — everything ultimately descends from Object
# the hierarchy: BasicObject → Object → ... → your value
# so EVERY object shares common methods (class, methods, respond_to?, etc.)
```

## Konsegwenza: imġiba uniformi u konsistenti

```ruby
# because everything is an object, the same patterns work everywhere
[1, 2, 3].map(&:to_s)          # call to_s on each
any_value.respond_to?(:upcase) # ask any object if it has a method
```

## Għaliex hija importanti

L-għarfien li "everything is an object" huwa fundamentali għall-fehim tad-disinn u l-konsistenza tar-Ruby, u huwa wieħed mill-karatteristiki definenti tal-lingwa.

Differenti minn lingwi b'primitive types (Java/C# fejn numri u booleans huma value-type primitives, mhux objekti), Ruby ttratta **kollox** — numri, strings, `nil`, booleans, u anke l-klassijiet nfushom — bħala objekti b'metodi li tista' tassew.

Din il-purità tal-konsistenza object-oriented għandha implikazzjonijiet prattiċi: tista' tassew metodi direttament fuqija kwalunkwe valur (`42.even?`, `nil.to_s`, `42.times`), l-istess pattern object-oriented jaħdmu b'mod uniformi fuq il-valuri kollha (l-ebda trattament speċjali għal "primitives"), u kull object jaqsam metodi komuni mwarritin minn `Object`.
/Tkun kritika, il-fatt li **klassijiet huma nfushom objekti** (instanzi ta' `Class`) huwa dak li jippermetti l-metaprogramming **powerful** tar-Ruby — tista' tinspettja u timmanipula klassijiet fil-ħin tal-eżekuzzjoni, li hija fil-qalba ta' ħafna minn-Ruby's flessibilità u frameworks bħal Rails.

L-għarfien ta' dan il-prinċipju jispjega għaliex il-kodiċi tar-Ruby jista' jassew metodi fuq qalsiex, għaliex il-lingwa tiħoss tant konsistenti u uniformi, u kif il-metaprogramming possibbli.

Hi hija fundazzjoni kunċettwali ċentrali li tiddiferenzi Ruby minn lingwi b'primitive/object dualities, u l-għarfien tagħha huwa essenzjali għall-għarfien tal-Ruby's elegant consistency, l-istil tal-method-calling-on-everything, u r-runtime metaprogramming capabilities — magħmula importanti, għarfien fundamentali għax-xogħol mal-lingwa u punt frekwenti li jaqbad in-natura distintiva ta' Ruby object-oriented.