---
# System prepended metadata

title: Ruby 方法
tags: [Ruby]

---


## .parse

- URI.parse
`URI.parse` 將字符串形式的 URL 轉換為一個 `URI::Generic` 對象，你可以通過這個對象訪問 URL 的不同部分。
```ruby
require 'uri'

url = "http://www.example.com/path?query=string"
uri = URI.parse(url)

puts "Scheme: #{uri.scheme}" # "http"
puts "Host: #{uri.host}"     # "www.example.com"
puts "Path: #{uri.path}"     # "/path"
puts "Query: #{uri.query}"   # "query=string"

puts uri.host # 輸出: www.example.com
```
- JSON 解析
```ruby
require 'json'

json_str = '{"name": "Alice", "age": 30}'
data = JSON.parse(json_str)
puts data["name"]  # 輸出: Alice
```
- 解析時間和日期
```ruby
require 'time'

time_str = "2021-01-01 12:30:45"
time = Time.parse(time_str)
puts time  # 輸出: 2021-01-01 12:30:45 +0000

require 'date'

date_str = "2021-01-01"
date = Date.parse(date_str)
puts date  # 輸出: 2021-01-01
```

## 時間

1. Time.now
修改格式 strftime
```
def num_generator
	"{Time.now.strftime('%Y/%m/%d')}"
end

p num_generator  => 2023/08/03 
```

```r
3.2.2 :003 > 
  User.update(confirmed_at: DateTime.parse('2023-08-21 10:04:39.777883'))
  User Load (0.4ms)  SELECT "users".* FROM "users"
  TRANSACTION (0.2ms)  BEGIN
  User Update (0.4ms)  UPDATE "users" SET "updated_at" = $1, "confirmed_at" = $2 WHERE "users"."id" = $3  [["updated_at", "2023-08-21 12:28:39.898310"], ["confirmed_at", "2023-08-21 10:04:39.777883"], ["id", 1]]
  TRANSACTION (1.4ms)  COMMIT
 => [#<User email: "ccc@ccc.ccc", id: 1, name: "123", created_at: "2023-08-21 20:08:32.043862000 +0800", updated_at: "2023-08-21 20:28:39.898310000 +0800", fb_uid: nil, fb_token: nil, google_uid: nil, google_token: nil>]
3.2.2 :004 >
```
## to_
1. `to_s`：將對象轉換為　字串 (String)。
``` rb
42.to_s
#=> "42"
```
2. `to_i`：將對象轉換為　整數 (Integer)。
```rb
 "42".to_i 
#=> 42
```
3. `to_f`：將對象轉換為　浮點數 (Float)。
```rb
 "3.14" .to_f 
#=> 3.14
#如果直接 to_i 會取整數 
"3.14".to_i
#=> 3
```
4. `to_a`：將對象轉換為　陣列 (Array)。
```rb
set = Set.new([1, 2, 3]) 
array_data = set.to_a 
puts array_data.inspect 
#=> [1, 2, 3]
```
5. to_sym : 將對象轉換為　符號(symbol)
# 陣列
## reject 
清除陣列中的空元素
remove `blank elements` from an array 
```ruby
#語法
reject { |c| c.empty? }
```
## compact 
```rb
a = [nil, 0, nil, 1, nil, 2, nil]
a.compact # => [0, 1, 2]
```

## each_slice
This method needs that you

require 'enumerator'

for this method to be available.
```ruby
(1..10).each_slice(3) { |a| p a }
# outputs below
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10]
```
## drop
```rb
a = [0, 1, 2, 3, 4, 5]
a.drop(0) # => [0, 1, 2, 3, 4, 5]
a.drop(1) # => [1, 2, 3, 4, 5]
a.drop(2) # => [2, 3, 4, 5]
```

## delete
刪除指陣列中指定元素, 但不會回傳新的陣列
```ruby
A = [1,2,3,3,3,3]
A.delete(3)
p A # => [1,2]
```
## fill
替換陣列內的元素
```rb
a = ['a', 'b', 'c', 'd']
a # => ["a", "b", "c", "d"]
a.fill(:X) # => [:X, :X, :X, :X]
# 第二個參數代表 從陣列中的第幾個數開始
a.fill(:X, 2) # => ["a", "b", :X, :X]
# 如果起始值為負,從末尾開始計數
a.fill(:X, -2) # => ["a", "b", :X, :X]
# 如果 start 太小（小於且遠離零），則替換所有元素
a.fill(:X, -6) # => [:X, :X, :X, :X]
a.fill(:X, -50) # => [:X, :X, :X, :X]

```
# 字串

## upcase capitalize
- 使用 `.capitalize` 時，字符串的第一個字符會變成大寫，其餘字符變成小寫。
- 使用 `.upcase` 時，字符串中的所有字母都會變成大寫。
```ruby
"hello".capitalize    # => "Hello"
"HELLO".capitalize    # => "Hello"
"Hello".capitalize    # => "Hello"

"hello".upcase       # => "HELLO"
"HELLO".upcase       # => "HELLO"
"Hello".upcase       # => "HELLO"
```
##  end_with?
使用`end_with?`方法來檢查一個字符串是否以另一個字符串結尾。
只用於 "字串"
```rb
puts "hello".end_with?("lo")  # 輸出 true
puts "hello".end_with?("he")  # 輸出 false
```
## chars
把字串拆成一個陣列
```rb
> '13456'.chars
 => ["1", "3", "4", "5", "6"]
> '五倍鵝卵石'.chars
 => ["五", "倍", "鵝", "卵", "石"]
```
## replace

- `replace` 是一個方法，用於將字符串的內容完全替換為另一個字符串的內容。
- 它直接作用於原字符串對象，改變其值。
```ruby
str = "hello" str.replace("world") # 現在 str 的內容變為 "world"
```
## tr

- `tr` 是一個方法，用於根據指定的規則替換字符串中的字符。
- `tr` 適用於需要將一組字符映射到另一組字符的情況，如 ROT13 加密解密。
```ruby
"hello".tr('el', 'ip') # => "hippo"

# ROT13 解密
def rot13(message)
  message.tr("A-Za-z", "N-ZA-Mn-za-m")
end
```
## gsub
- `gsub` 是一個更強大的字符串替換方法，允許使用正則表達式來匹配需要被替換的文本。
- 它可以將所有匹配到的文本替換為指定的字符串或通過代碼塊處理後的結果。
- `gsub` 適用於複雜的文本替換和模式匹配任務。
```rb
"hello".gsub(/[aeiou]/, '*')                  #=> "h*ll*"
"hello".gsub(/([aeiou])/, '<\1>')             #=> "h<e>ll<o>"
"hello".gsub(/./) {|s| s.ord.to_s + ' '}      #=> "104 101 108 108 111 "
"hello".gsub(/(?<foo>[aeiou])/, '{\k<foo>}')  #=> "h{e}ll{o}"
'hello'.gsub(/[eo]/, 'e' => 3, 'o' => '*')    #=> "h3ll*"
```
在正則表達式中，符號 `^` 有兩種主要的用法，具體取決於它的位置和上下文：

1. **作為字符集的第一個字符：** 當 `^` 出現在一個字符集（方括號內）的開始位置時，它表示一個否定或反向字符集。這意味著該字符集將匹配任何不在方括號內的字符。例如，正則表達式 `[^a-z]` 匹配任何不是小寫字母的字符。
    
2. **作為字符串的開始標誌：** 當 `^` 出現在正則表達式的最開始位置（不在方括號內），它表示匹配字符串的開頭。例如，正則表達式 `^Hello` 將匹配所有以 "Hello" 開頭的字符串。
## ord 
把 ==字母== 轉成 ==Unicode 編碼==
## chr
把 =="Unicode 編碼"== 轉成 =="字母"==
```rb
 > 'a'.ord
 => 97
> 97.chr
 => "a"
```
