Ruby (ngôn ngữ lập trình)

**Ruby** là một ngôn ngữ lập trình hướng đối tượng, có khả năng phản ứng. Theo tác giả, Ruby chịu ảnh hưởng bởi Perl, Smalltalk, Eiffel, Ada và Lisp.

Ruby cung cấp nhiều mẫu hình lập trình, bao gồm lập trình hàm, hướng đối tượng, mệnh lệnh, phản xạ. Nó sử dụng hệ thống kiểu biến động và tự động quản lý bộ nhớ tự động.

## Lịch sử
Ruby được tạo ra từ 24 tháng 2 năm 1993, bởi lập trình viên người Nhật Bản tên là **Matsumoto Yukihiro** (松本 行弘), biệt danh **Matz**. Phiên bản chính thức 0.95 (Đây là phiên bản công khai đầu tiên của Ruby được công bố tại Nhật Bản) vào ngày 21 tháng 12 năm 1995. Ở phiên bản Ruby 0.95, nó đã có nhiều tính năng quen thuộc trong các phiên bản sau của Ruby, bao gồm thiết kế hướng đối tượng, các lớp với kế thừa, mixin, vòng lặp, xử lý ngoại lệ và thu gom rác.

### Ruby 3.4.0
Ruby 3.4.0 được phát hành vào ngày 25 tháng 12 năm 2024. Phiên bản 3.4.0 cũng cung cấp các nâng cấp về mặt hiệu năng cho các phiên bản Ruby 3.3.x. Phiên bản 3.4.0 này tập trung vào việc bổ sung các tham số chiếu trong tham số khối. Ngoài ra phiên bản cũng lựa chọn Prism là trình phân tích cú pháp măc định và hỗ trợ thêm Happy Eyeballs phiên bản 2 vào thư viện socket, cải thiện YJIT, thêm Modular GC, ...

##### Tham số <code>it</code> được giới thiệu
Thay đổi lớn nhất trong phiên bản 3.4.0 của Ruby là việc xuất hiện tham số `it` trong block. Tham số này chính là tham chiếu mặc định cho tham số của một block, tương tự như `_1`, giúp code trong các block đơn giản trở nên dễ đọc hơn. Ví dụ:
```ruby
["a", "b"].map { it.upcase } # -> ["A", "B"]
```


##### Prism là trình phân tích cú pháp mặc định
Chuyển trình phân tích cú pháp mặc định từ parse.y sang Prism.

Việc thay đổi trình phân tích cú pháp mặc định sang Prism là một thay đổi nội bộ trong ngôn ngữ Ruby nên người dùng sẽ thấy ít có sự thay đổi. Để sử dụng trình phân tích cú pháp thông thường, sử dụng đối số dòng lệnh `--parser=parse.y`.

##### Hỗ trợ Happy Eyeballs Version 2
Thư viện `socket` được cải tiến để giảm độ trễ kết nối mạng bằng cách thử đồng thời cả địa chỉ IPv6 và IPv4, sau đó chọn kết nối thành công đầu tiên.

#### Các cải tiến về mặt hiệu năng

##### YJIT (Just-In-Time Compiler)
YJIT tiếp tục được cải thiện, mang lại hiệu năng tốt hơn trên hầu hết các benchmark cho cả nền tàng x86-64 và arm64. Việc sử dụng bộ nhớ cũng được giảm thiểu và có thêm các tùy chọn dòng lệnh mới để quản lý.

##### Modular GC (Modular Garbage Collector)
Ruby 3.4.0 giớ thiệu một hệ thống garbage collector (GC) dạng mô-đun, cho phép tải các trình thu gom rác khác nhau một cách linh hoạt. Đáng chú ý là sự xuất hiên của một trình Garbage Collector thử nghiệm dựa trên MMTk (viết bằng Rust) hứa hẹn một hiệu năng cao.

##### JSON
Tốc độ của `JSON.parse` được cải thiện, **nhanh hơn khoảng 1.5 lần** so với phiên bản tiền nhiệm.

#### Các thay đổi quan trọng khác
Việc thay đổi các chuỗi (string) trong các file không có comment `frozen_string_literal` giờ đây sẽ đưa ra cảnh báo không dùng nữa (deprecation warning).

Việc phân tán từ khóa `nil` khi gọi phương thức hiện được hỗ trợ. `**nil` được xử lý tương tự như `**{}`, không truyền từ khóa và không gọi bất kỳ phương thức chuyển đổi nào.

### Bảng các phiên bản Ruby

### Cái tên Ruby
Nguồn gốc của cái tên "Ruby" là từ một phiên chat online giữa Matsumoto và Ishitsuka Keiji vào ngày 24 tháng 2 năm 1993, trước khi bất kỳ đoạn mã nào được viết cho ngôn ngữ này. Ban đầu, "Coral" và "Ruby" là hai cái tên được đề xuất. Matsumoto chọn tên sau trong email gửi đến Ishitsuka. Sau này Matz cũng bất ngờ khi phát hiện ra Pearl là viên đá quý tượng trưng cho những người sinh tháng 6, còn Ruby thì tượng trưng cho những người sinh tháng 7. Anh cho rằng cái tên Ruby như thế là phù hợp vì Ruby kế thừa và phát triển nhiều đặc tính từ Perl.

## Quan điểm
Quan điểm chính trong việc thiết kế của Matz là nhằm giảm thiểu các công việc nhàm chán mà họ, các nhà lập trình, buộc phải làm; tiếp đến là nguyên tắc thiết kế giao diện người dùng (user interface) hiệu quả. Ông nhấn mạnh rằng việc thiết kế hệ thống cần phải tập trung vào con người, hơn là vào máy tính:

:*Often people, especially computer engineers, focus on the machines. They think, "By doing this, the machine will run faster. By doing this, the machine will run more effectively. By doing this, the machine will something something something." They are focusing on machines. But in fact we need to focus on humans, on how humans care about doing programming or operating the application of the machines. We are the masters. They are the slaves.*

Ngôn ngữ Ruby được thiết kế nhằm theo nguyên tắc ít gây ngạc nhiên nhất (principle of least surprise-POLS), nghĩa là ngôn ngữ hoạt động theo một cách trực quan hay ít nhất đó cũng là nhận xét mà các nhà lập trình đưa ra. Nguyên tắc này không xuất phát từ Matz và, nói chung, Ruby gần với suy nghĩ **ít ngạc nhiên nhất** của 'Matz' hơn.

## Ngữ nghĩa
Ruby là một ngôn ngữ hướng đối tượng: mỗi giá trị đều là một đối tượng (object), bao gồm các kiểu dữ liệu mà đối với các ngôn ngữ khác, chúng là kiểu cơ bản (primitive) như integer. Mỗi hàm (function) là một phương thức (method). Tên biến (variables) chính là tham chiếu (references) đến các đối tượng, bản thân nó không phải là đối tượng. Ruby hỗ trợ kế thừa (inheritance) với dynamic dispatch, mixin và singleton method (thuộc về, và để định nghĩa cho, một instance đơn hơn là định nghĩa dành cho lớp). Mặc dù Ruby không hỗ trợ đa kế thừa, các lớp vẫn có thể được đưa vào các module dưới dạng các **mixins**. Cú pháp dạng thủ tục (procedural syntax) vẫn còn được hỗ trợ, có vẻ như là ngoài tầm vực của mọi đối tượng, nhưng thực sự là thuộc một *thể hiện* của class Object tên là 'main'. Vì class này là cha của mọi class khác, nó trở trên ẩn đối với mọi lớp và đối tượng.

Ruby được xem là một ngôn ngữ lập trình đa mẫu hình (*multi-paradigm programming language*): nó cho phép bạn lập trình dạng thủ tục (tạo ra các hàm/biến nằm ngoài phạm vi của các lớp và biến chúng thành một phần của đối tượng gốc, 'self' Object), với khả năng hướng đối tượng (mọi thứ đều là đối tượng) hay hàm (nó có các hàm không có tên (anonymous functions), closures, và continuations; mọi câu lệnh đều có giá trị trả về, và các hàm đều trả về kết quả ước lượng cuối cùng). Nó hỗ trợ mạnh cho tự định kiểu (type introspection), reflection và meta-programming.

Theo Ruby FAQ, "Nếu bạn thích Perl, bạn sẽ thích Ruby và sẽ thấy thoải mái với cú pháp của nó. Nếu bạn thích Smalltalk, bạn sẽ thích Ruby và sẽ thấy thoải mái với ngữ nghĩa của nó (semantics). Nếu bạn thích Python, bạn có thể hoặc không thể dừng lại bởi sự khác biệt lớn trong triết lý hiện thực giữa Python và Ruby/Perl."

## Các bản thông dịch
### Trình thông dịch Ruby của Matz (MRI)
Bản trình thông dịch gốc của Ruby thường được gọi là "Trình thông dịch Ruby của Matz" (viết tắt là MRI). Bản thông dịch này được viết bằng ngôn ngữ C và sử dụng bản máy ảo Ruby riêng của nó.

Bắt đầu từ Ruby 1.9 và từ các phiên bản Ruby 2.x trở lên, trình thông dịch chính thức của Ruby là YARV, viết tắt cho "Yet Another Ruby VM" (dịch thô: "lại thêm một máy ảo Ruby").

### Các bản thông dịch khác

Tính đến năm 2018, nhiều bản thông dịch khác của Ruby đã xuất hiện, với mỗi bản được thiết kế theo một định hướng riêng. Một số ví dụ như JRuby và Rubinius cung cấp chức năng biên dịch lập tức (just-in-time compilation), và mruby cho phép biên dịch trực tiếp (ahead-of-time compilation).

## Tính năng
* Hướng đối tượng
* Xử lý ngoại lệ
* Iterator và closures (dựa vào cách truyền một khối lệnh)
* Native, biểu thức chính quy như Perl ở mức độ ngôn ngữ
* Chồng toán tử (operator overloading)
* Thu hồi rác tự động
* Tính khả chuyển cao (portable)
* Có thể chạy đa luồng (multi-threading) trên mọi platforms
* Khả năng nạp động các DLL/thư viện chia sẻ trên hầu hết mọi platforms.
* Tự kiểm tra (introspection), reflection và meta-programming
* Rất nhiều thư viện chuẩn
* Hỗ trợ dependency injection
* Continuation và generator (xem ví dụ tại RubyGarden: continuations  và generators )
* Dùng khối lệnh (code block)

Ruby hiện tại vẫn chưa hỗ trợ Unicode, dù chỉ mới hỗ trợ tạm thời cho UTF-8.

## Những vấn đề mới
Mặc dù việc thiết kế Ruby tuân theo nguyên tắc ít gây ngạc nhiên nhất, nhưng một số tính năng khác với các ngôn ngữ khác như C hay Perl:

* Các tên bắt đầu bằng ký tự hoa được xem là hằng, vì thế biến cục bộ nên bắt đầu bằng ký tự thường.
* Việc đánh giá Boolean đối với các dữ liệu không phải bool rất chặt chẽ: 0, `""` và `[]` được xem là *true*: Trong C, biểu thức `0 ? 1: 0` được xem là 0. Trong Ruby, tuy nhiên, nó lại trả về 1, vì số 0 được xem là "một cái gì đó"; chỉ có `nil` và `false` mới được xem là bằng *false*. Một hệ luận đối với quy luật này là theo qui ước, các phương thức của Ruby—ví dụ, biểu thức chính quy tìm kiếm — sẽ trả về các số, chuỗi, danh sách etc. nếu thành công, nhưng lại trả về `nil` nếu thất bại (ví dụ, không tìm thấy).
* Để biểu diễn một số thực dấu chấm động, ta phải theo quy tắc dùng ký số zero (`99.0`) hay chuyển đổi tường minh (`99.to_f`). Việc dùng dấu chấm là không đủ (`99.`) vì các số vẫn có thể nhận cú pháp có phương thức.
* Thiếu một kiểu dữ liệu ký tự ("char"). Điều này có thể gây ngạc nhiên khi duyệt qua chuỗi: `"abc"[0]` cho ra 97 (một số nguyên, biểu diễn mã ASCII của ký tự đầu tiên trong chuỗi); để lấy được `"a"` dùng `"abc"[0,1]` (chuỗi con có chiều dài 1) hay `"abc"[0].chr`.

Một danh sách các lỗi thường gặp ("gotchas") có thể tra trong cuốn sách của Hal Fulton *The Ruby Way*, trang 48–64. Tuy nhiên, vì danh sách trong cuốn sách là dựa trên phiên bản cũ của Ruby (version 1.6), một số mục đã được sửa đổi sau khi cuốn sách ấn hành. Ví dụ, `retry` bây giờ làm việc được với `while`, `until` và `for`, cũng như với iterators.

## Ví dụ
Lưu ý: Các ví dụ sử dụng chuỗi ký tự Unicode để chạy được cần đặt một biến môi trường là $KCODE="u". Hay là chạy #ruby với tùy chọn là -K u vẫn được. Xem thêm những hạn chế của phiên bản Ruby hiện tại với Unicode tại ruby và unicode 


```ruby
# Mọi thứ, kể cả tầm thường nhất, là một đối tượng. Vì thế những ví dụ dưới đều chạy được:
-199.abs                                       # => 199, abs: giá trị tuyệt đối
"ruby is cool".length                          # => 12
"Rick".index("c")                              # => 2
"Nice Day Isn't It?".split(//).uniq.sort.join  # => " '?DINaceinsty"
```


### Input

```ruby
print 'Làm ơn gõ tên >'
name = gets.chomp
puts "Chào #{name}."
```


### Hội thoại

```ruby
puts 'Cho tôi con số của bạn'
number = gets.chomp
puts number.to_i
output_number = number.to_i + 1
puts output_number.to_s + ' là một con số lớn hơn.'
```


### Mảng

Khởi tạo và sử dụng một mảng:


```ruby
a = [1, 'chào', 3.14, 1, 2, [4, 5]]

a[2]                      # => 3.14
a.reverse                 # => [[4, 5], 2, 1, 3.14, 'chào', 1]
a.flatten.uniq            # => [1, 'chào', 3.14, 2, 4, 5]
```


Khởi tạo và xây dựng một mảng kết hợp (Ruby gọi là hash):


```ruby
hash = Hash.new                              # Tương đương với hash = {}
hash = {:water => 'wet',:fire => 'hot'}      # Đoạn mã đầu trở nên dư thừa khi
                                             # đưa cho hash một đối tượng hash riêng biệt mới
puts hash[:fire]                             # Xuất ra "hot"

hash.each_pair do |key, value|               # Hoặc: hash.each do |key, value|
    puts "#{key} is #{value}"
end
# Trả về {:water => 'wet',:fire => 'hot'} và xuất ra:
# water is wet
# fire is hot

hash.delete:water                            # Hủy cặp giá trị:water => 'wet' và trả về "wet"
hash.delete_if {|key, value| value == 'hot'} # Hủy cặp giá trị:fire => 'hot' và trả về {}
```


### Cấu trúc rẽ nhánh
Mệnh đề If:
```ruby
# Tạo ra một số ngẫu nhiên và in ra số đó là chẵn hay lẻ.
if rand(100) % 2 == 0
  puts "Là số chẵn"
else
  puts "Là số lẻ"
end
```


### Block và iterator

2 cách để tạo một đoạn block:
```ruby
{ puts 'Xin chào, thế giới!' } # lưu ý dấu ngoặc
# hoặc:
do
  puts 'Xin chào, thế giới!'
end
```


Một block có thể được truyền đến một hàm (method) như một tham số tùy chọn. Nhiều hàm được cài sẵn có tham số như vậy:
```ruby
File.open('file.txt', 'w') do |file| # 'w' biểu thị "chế độ ghi chép"
  file.puts 'Viết gì đó'
end                                  # Tập tin sẽ tự động đóng ở đây

File.readlines('file.txt').each do |line|
  puts line
end
# => 'Viết gì đó'
```
Thông số đi qua block để trở thành closure (ví dụ):


```ruby
# Trong một biến thể hiện đối tượng (biểu thị bằng '@'), hãy lưu block này.
def remember(&p)
    @block = p
end

# Dùng hàm trên, cho block đó một cái tên.
remember {|ten| puts "Xin chào, #{ten}!"}

# Dùng closure (lưu ý rằng điều này không có áp dụng tự do cho các biến khác):!
@block.call("Tèo")  # Xuất ra "Xin chào, Tèo!"
```


Tạo ra một hàm ẩn danh:
```ruby
proc {|arg| puts arg}
Proc.new {|arg| puts arg}
lambda {|arg| puts arg}
->(arg) {puts arg}         # được giới thiệu ở Ruby 1.9
```


Trả về closure từ một hàm:
```ruby
def create_set_and_get(initial_value=0) # Lưu ý initial_value là 0
  closure_value = initial_value
  [ Proc.new {|x| closure_value = x}, Proc.new { closure_value } ]
end

setter, getter = create_set_and_get  # Trả về hai giá trị
setter.call(21)
getter.call      # => 21

# Biến tham số cũng có thể được sử dụng như là một liên kết cho closure,
# Vậy nên hàm trên có thể được viết lại như sau:

def create_set_and_get(closure_value=0)
  [ proc {|x| closure_value = x }, proc { closure_value } ]
end
```
Trong một hàm, có thể thay đổi block vào lúc gọi hàm:


```ruby
def bfs(e)
    q = []
    e.mark
    yield e
    q.push e
    while not q.empty?
      u = q.shift
      u.edge_iterator do |v|
      if not v.marked?
        v.mark
        yield v
        q.push v
      end  
    end
  end
  bfs(e) {|v| puts v}
```


Duyệt lần lượt trên enumation và mảng bằng cách dùng block:


```ruby
a = [1, 'chào', 3.14]
a.each {|item| puts item}          # Xuất ra toàn bộ phần tử
(3..6).each {|num| puts num}       # Xuất ra các số từ 3 đến 6
```


Block cũng có thể dùng với các hàm dựng sẵn:


```ruby
File.open('taptin.txt', 'w+b') do |taptin|
  taptin.puts 'Viết linh tinh gì đó.'
end                # File được tự động đóng lại tại đây
```


Hay:


```ruby
IO.readlines('taptin.txt') do |dòng|
  # Xử lý từng dòng ở đây.
end
```


Sử dụng enumeration và block để xuất ra lũy thừa 2 của các số từ 1 đến 10:


```ruby
(1..10).collect {|x| x*x}    => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
```


### Lớp
Đoạn mã sau định nghĩa một lớp tên là `''Person''`. Bên cạnh phương thức khởi tạo `''initialize''`, là phương thức được gọi đến khi cần tạo đối tượng mới, lớp này còn có 2 phương thức khác: một là ghi đè lên toán tử so sánh  (vì thế `Array#sort` có thể sắp xếp theo tuổi) và hai là là ghi đè lên phương thức `to_s` (vì thế `Kernel#puts` có thể định dạng đầu ra của nó). Ở đây, `attr_accessor` là một ví dụ của meta-programming trong Ruby: nó định nghĩa các phương thức dạng *getter* và *setter* của biến thực thể, trong khi `attr_reader` các phương thức dạng 'getter'. Và, câu lệnh cuối cùng trong một phương thức là giá trị trả về của nó, điều này cho phép bỏ qua lệnh `return`.


```ruby
class Person
  attr_reader:name,:age
  def initialize(name, age)
    @name, @age = name, age
  end
  def <=>(person)           # Định nghĩa toán tử so sánh
    @age <=> person.age
  end
  def to_s
    "#{@name} (#{@age})"
  end
end

group = [
  Person.new("Bob", 33),
  Person.new("Chris", 16),
  Person.new("Ash", 23)
]

puts group.sort.reverse
```


Đoạn mã trên in ra ba tên theo tuổi giảm dần:


```ruby
Bob (33)
Ash (23)
Chris (16)
```


### Ngoại lệ
Một trường hợp ngoại lệ được đưa ra với lệnh `raise`:
```ruby
raise
```
Có thể thêm một thông báo tùy chọn:
```ruby
raise "Đây là một thông báo"
```
Ngoại lệ cũng có thể xác định bởi các lập trình viên:
```ruby
raise ArgumentError, "Tranh luận bất hợp pháp!"
```
Ngoài ra, một thực thể của lớp Ngoại lệ có thể tạo ra được với biến `raise` như sau
```ruby
raise ArgumentError.new("Tham số không phù hợp!")
```


## Cú pháp
Cú pháp trong Ruby tương tự như Perl and Python. Lớp và phương thức được định nghĩa thông qua các từ khóa, ngoài ra khối (block) còn có thể được định nghĩa bằng cặp dấu ngoặc nhọn `{}`. Khác với Perl, biến số (variable) không nhất thiết phải bắt đầu bằng dấu `$`, và nếu sử dụng sẽ thay đổi phạm vi của biến số. Các kí tự xuống dòng (line breaks) cũng như dấu chấm phẩy `;` phân chia các mệnh đề (*statement*) với nhau.

Một trong những điểm khác biệt lớn nhất so với Perl và Python là Ruby ẩn hoàn toàn các biến của thực thể (*instance*) và chỉ có thể truy cập và chỉnh sửa chúng thông qua các phương thức (như `attr_writer`, `attr_reader`).

## Các ứng dụng
RubyGems là trình quản lý gói chính của Ruby. Một gói mã Ruby được gọi là "gem" và có thể được tải về qua giao diện dòng lệnh. Đa số các gói là thư viện, tuy nhiên cũng có một số ứng dụng tồn tại dưới dạng gói. Tính đến năm 2026, trang RubyGems.org đang lưu trữ hơn 180,000 gói.

**Ruby Application Archive** đã từng đóng vai trò là một kho lưu trữ các loại ứng dụng, tài liệu và các thư viện viết cho Ruby. Vào năm 2013, trang này ngưng hoạt động, và các chức năng của nó được chuyển giao cho RubyGems.

## Tham khảo

## Xem thêm
* Duck typing
* RubyGems (tiện ích quản lý các gói viết bằng Ruby)
* Ruby on Rails (một framework dành cho phát triển ứng dụng Web viết bằng Ruby)

## Liên kết ngoài

* Ruby language home page
* Giáo trình Tự học Ruby bằng tiếng Việt 
* Ruby Garden
* ''Programming Ruby'' —Full text of first edition of the book by David Thomas & Andrew Hunt, ISBN 0-201-71089-7
* Why's Poignant Guide to Ruby
* Learning to Program very basic tutorial for non-programmers
* About the name 'Ruby' 
* Ruby FAQ 
* Quick Reference
* Ruby Application Archive  (RAA)
* JRuby
* The Ruby Documentation project
* Ruby Forum 
* RubyForge 
* RedHanded —Daily Ruby news and more
* Ruby Newcomers Advice 
* Getting started with Ruby 
* RubyGems—the Ruby standard for publishing and managing third party libraries
* VnRuby —Hội nghiên cứu ứng dụng ngôn ngữ Ruby của Việt Nam
* Full Ruby on Rails Tutorial