"Mọi thứ đều là object" nghĩa là gì trong Ruby?

Question

Accepted Answer

Trong Ruby, **mọi thứ đều là object** — bao gồm số, chuỗi, `nil`, `true`/`false`, và thậm chí cả class. Mọi giá trị đều có method bạn có thể gọi trên nó, và không có kiểu nguyên thủy (primitive) nào (khác với Java/C# với các primitive kiểu giá trị). Tính nhất quán này là phần cốt lõi trong thiết kế của Ruby.

## Ngay cả số và nil cũng có method

```ruby
42.even?             # true — Integer là object có method
42.times { ... }     # gọi method trên một con số
(-5).abs             # 5
3.14.round           # 3

nil.to_s             # "" — ngay cả nil cũng là object (NilClass)
nil.nil?             # true
true.class           # TrueClass — boolean cũng là object
"hello".length       # chuỗi cũng là object
```

Khác với các ngôn ngữ có kiểu primitive, trong Ruby `42` là một object đầy đủ (một instance của `Integer`) — bạn gọi method trực tiếp trên nó (`42.even?`, `42.times`). Ngay cả `nil`, `true`, và `false` cũng là object với class và method riêng.

## Class cũng là object

```ruby
String.class         # Class — một class tự thân là object (một instance của Class)
42.class             # Integer
42.class.class       # Class
Integer.ancestors    # [Integer, Numeric, Comparable, Object, ...] — phân cấp class
```

Ngay cả **class cũng là object** (instance của `Class`) — đây chính là điều cho phép metaprogramming mạnh mẽ của Ruby (bạn có thể thao tác với class tại thời điểm chạy).

## Mọi thứ kế thừa từ BasicObject/Object

```ruby
42.is_a?(Object)     # true — mọi thứ cuối cùng đều hậu duệ của Object
# phân cấp: BasicObject → Object → ... → giá trị của bạn
# nên MỌI object chia sẻ các method chung (class, methods, respond_to?, v.v.)
```

## Một hệ quả: hành vi đồng nhất, nhất quán

```ruby
# vì mọi thứ đều là object, cùng một pattern hoạt động ở mọi nơi
[1, 2, 3].map(&:to_s)          # gọi to_s trên mỗi phần tử
any_value.respond_to?(:upcase) # hỏi bất kỳ object nào xem có method đó không
```

## Tại sao điều này quan trọng

Hiểu rằng "mọi thứ đều là object" là điều nền tảng để nắm bắt thiết kế và tính nhất quán của Ruby, và đó là một trong những đặc điểm định danh của ngôn ngữ.

Khác với các ngôn ngữ có kiểu primitive (Java/C# nơi số và boolean là primitive kiểu giá trị, không phải object), Ruby đối xử với **mọi thứ** — số, chuỗi, `nil`, boolean, và thậm chí cả class — như object có method bạn có thể gọi.

Tính nhất quán hướng đối tượng thuần túy này có những hệ quả thực tế: bạn có thể gọi method trực tiếp trên bất kỳ giá trị nào (`42.even?`, `nil.to_s`, `42.times`), cùng các pattern hướng đối tượng hoạt động đồng nhất trên mọi giá trị (không có xử lý đặc biệt cho "primitive"), và mọi object chia sẻ các method chung kế thừa từ `Object`.

Quan trọng nhất, việc **class tự thân là object** (instance của `Class`) chính là điều cho phép **metaprogramming** mạnh mẽ của Ruby — bạn có thể kiểm tra và thao tác class tại thời điểm chạy, vốn là nền tảng cho phần lớn sự linh hoạt của Ruby và các framework như Rails.

Hiểu nguyên tắc này giải thích vì sao code Ruby có thể gọi method trên bất cứ thứ gì, vì sao ngôn ngữ cảm thấy nhất quán và đồng nhất đến vậy, và metaprogramming khả thi như thế nào.

Đây là nền tảng khái niệm cốt lõi phân biệt Ruby với các ngôn ngữ có sự phân đôi primitive/object, và nắm bắt nó là thiết yếu để hiểu tính nhất quán thanh lịch của Ruby, phong cách gọi-method-trên-mọi-thứ của nó, và các năng lực metaprogramming — khiến nó trở thành kiến thức nền tảng, quan trọng để làm việc với ngôn ngữ và là điểm thường được nhắc tới thể hiện bản chất hướng đối tượng đặc trưng của Ruby.