五倍直播間

Blogs - Sidebar


時間永遠是固定的24小時這麼多，如何掌握在有限的時間內取捨事情的優先順序？

PM 手中可能會有多個專案在進行，最有可能遇到的狀況，例如：

你一早進到公司，正打開電腦要回 A 專案客戶的訊息，結果不到兩秒鐘， B 客戶問你能不能開個簡短的視訊會議討論他剛剛新開的 issue，接著 C 客戶突然又在群組上問你昨天會議的事情，然後同事走過來問你午餐要吃什麼(咦)。

是的，彷彿受到詛咒一般，點開什麼東西，事情就會一卡車的跟著飛來XD

>做事之前，先排列好優先順序，勇者打怪也是要照步驟來的。

## 優先順序
### 以有限的時間為前提，做出取捨

手中有太多事時，如同前面所提到，在有限的時間內優先處理重要且緊急的事情，可以從下面的象限圖，將你手中的事情先大致分為四塊：

(請看我<del>簡單明瞭的</del>象限圖表)

- 緊急且重要的事情
- 緊急但不重要的事情
- 不緊急但重要的事情
- 不緊急也不重要的事情

用上述的四象限去安排優先順序，比起遇到什麼事就先解決什麼事，倒不如從優先緊急的事情下手，對於自己的時間安排會更好掌握。

以專案管理上會遇到的狀況來說，若時程緊縮無法調整的時候，也可以依照此象限表去跟客戶協商哪些功能或是畫面是最緊急重要的，進而做出取捨。

但我有看過另一種說法，通常我們做不重要又不緊急的事情<del>總是最愉快的，有時候甚至最快完成，例如：追劇打遊戲。</del>

## 排程

>我為什麼需要為自己的時間排程？
>—— 排程表可以一眼看出整個時間的分配計劃

確定好需要安排的事項後，將它們記在任何你擅長使用的排程工具上，遇到計畫調整時，可以較為輕鬆直覺地去安排。

排程這個動作也可以運用在專案管理上，你可以使用排程表去和專案成員 or 客戶討論議題，最起碼你手上有個可以直接調整的時程表，方便雙方討論，減少溝通成本。

排時程表除了『提醒自己有這些待辦事情』外，也有『應對突發狀況而需要調整』時，可以一眼看出整個計畫的走向，從而去迅速的協調安排的功能。

>有時候會有這種疑問：專案就算排程了，也只是預估的時間，跟實際上所花費的時間還是會有所差距，那為什麼要排程?

就像出去旅行，也會大致安排幾個今天要吃的食物 / 要去的景點，比起毫無排程，有安排過後的行程可以掌握到大概有哪些事情需要去完成，調好整體專案的速度與步驟，隨時可以應付變動，搭配最前面提到的象限表，做出取捨或是應對方法。

## 適度留白

>那些平時被你疏忽的小事，也會佔據你的時間。

不是當下緊急的事情，常常容易被忽略去估算花費的時間，覺得總會有時間去完成。舉例來說：每天大概會花費30~60分鐘整理各專案的進度，又會花 15-30 分鐘去準備隔日會議的內容。

又例如，預估時程時，開發前的評估+研究，跟開發完成後的測試時間，看起來只是普通的兩件事，但其實這後面有許多隱藏成本，例如評估研究時，跟客戶雙向溝通的時間成本、還有測試時出現 bug 時，解決也需要時間，小事疊加起來，耗掉的時間也是非常可觀的。

所以在行程前後通常會再抓一些餘裕，是用來應對有意料外的狀況發生時，還有緩衝的時間可以消耗。

## 搭配專注的爆發力，不可小覷

在每件執行的事情上，最好將一切外在的干擾排除，保持一定的高專注力，全數貫注於手頭的事情上，將進度衝刺到最大值。

公司工程師們曾經跟我討論過一個話題，打 code 有時候打到一定的程度時需要高度專注與心力投入，被打擾的話，要再度切回原本的思緒與高專注力是有困難的，就像你算數學算到一半，有人叫你寫作文，寫完再繼續切回去算數學一樣，心情很難恢復啊——！

## 結語

上述所提的幾個小主題，可以幫助你在時間上作出較合理的時程安排，避免讓自己陷入什麼事都想做，卻什麼事都沒做完的狀況。

延伸到專案上的話，除了排優先度的先後順序外，難免會有功能必須做出取捨，如同前面提到，可以幫你節省大量的溝通與時間成本，希望對於有興趣研究時間管理與時程安排的你，可以增添一些幫助 :)

post-勇者，成為時間的支配者吧！

勇者，成為時間的支配者吧！


PM 除了常被討論到的溝通、專案管理技能，在團隊中是否具備補位能力，也是能否讓團隊成員妥善發揮的重要指標，尤其在小團隊協作中，善於補位的 PM 能給的 buff 效果也會更為顯著。

那什麼是補位？補位又該做什麼呢？

簡單來說，在專案過程中能讓開發流暢進行，但沒有專人負責、沒被注意到、可能讓夥伴被打斷的事項，或是需要反覆確認的細節等，都會需要有人能適時補上空缺。當然，這也不僅是 PM 的責任，就像出團打副本，如果每個人都能靈活支援彼此，應該都能滿載而歸才對 XD

而在小團隊中， PM 最常見的補位就是 QA。

團隊協作中難免會出現溝通過但認知不同的狀況，或是開發中沒有注意到的盲點，若能在 QA 這道防線中被察覺，就可以在功能上線或交付前找到問題，早發現早治療。

接著，就來說說 QA 必學的 Git 指令吧！

## 複製專案到本機

QA 時常需要在本機端進行測試，這時我們會利用 `git clone` 這個指令取回線上的 Repository，在[這篇文章](https://gitbook.tw/chapters/github/clone-repository.html)裡有包含圖形介面及指令的解說，在此就不多贅述，接下來的介紹也將以終端機上的操作指令為主。

（專案複製到本機端後，記得詳讀當中的 README 文件把專案環境先架設起來喔！）

## 切換分支

多人協作的專案常會採用多分支進行開發，主要是為了不影響已上線的功能，也避免大家在開發過程中你等我、我等你這樣浪費時間，說好先各自平行發展，等確認沒問題後再一一合併回來。

使用慣例上，一個分支通常代表就一個功能或一個 Bug 的修正，在測試時就針對每個分支處理的內容驗證，可以限縮問題的範圍，減少多個功能混合開發導致問題很難追溯的情況。

換句話說，你今天預計測哪個功能，就切到那個功能的分支去測試。

    $ git checkout feature_1
    Switched to branch 'feature_1'

使用 `git checkout` 會將遠端的分支建立一份在本機端，也可以用來在本機端切換分支，同時還是檔案救星！如果使用 Git 的過程中發現做錯事了，莫急莫慌，這指令可以用來[拯救被誤刪的檔案或目錄](https://gitbook.tw/chapters/using-git/recover-deleted-files.html)。

## 更新分支內容

如果一個分支在測試的同時也還在進行開發，那麼能隨時拉到開發人員最新推出的分支內容就很重要了，要嚴防自己的分支內容跟不上時代啊！XD

    ＄ git pull

這主要在處理當遠方的分支內容更新時，要讓本機能同步成最新的狀態，這樣就能確保自己不會測到過時的內容，也避免開發人員已經修正過的問題沒有被注意到而造成誤解。

雖然看似單純，但 **git pull** [背後的故事](https://gitbook.tw/chapters/github/pull-from-github.html)可不只這樣而已！搭配不同參數還有不同奧妙，就留給有心人自己挖掘了。（笑）

## 新增/查看目前分支

有時候，一些簡單的設定檔修改，也是 PM 可以協助的範圍，這時可能就需要加入新的分支，用來測試加入或更新的設定檔是否正確。例如：我們試著新增一個叫作 feature_2 的分支。

    $ git branch feature_2

發現好像什麼事都沒有發生 o_oa
那要怎麼確認這個分支到底有沒有被加出來呢？
其實上述指令去掉後面的 branch name，就可以用來查看分支列表。

    $ git branch
      feature_2
    * feature_1
      master

看起來這個分支有被加出來了，但怎麼確認我目前在哪個分支上呢？
上面的例子裡，分支名稱前的星號稱為 **Head** ，標示的就是目前所在的分支，要在新分支上調整設定檔的話，記得先利用上面説的 `git checkout` 指令切換過去唷！

    $ git checkout feature_2
    Switched to branch 'feature_2'

## 將檔案交給 Git 做版本控制

PM 除了在協助 QA 時會頻繁地切換分支外，偶爾也會協助更新設定檔這些簡易的修改，如果說前面的指令主要在切換版本，這裡要提的就是將協助修改或新增的檔案上傳到 Git 加入控管所需的相關指令。

當我們在目錄裡新增了一個 Git 之前完全不認識的檔案 `hello.html` 後，可以利用 `git status` 這個指令來查看目錄當前的版控狀態。

    $ git status
    On branch master

    Initial commit

    Untracked files:
      (use "git add <file>..." to include in what will be committed)

	          hello.html

此時 Git 表示：這誰啊？我不認識。雖然發現了這傢伙的存在，但因為沒聽說過這位想幹嘛，所以`hello.html` 就先列為 untracted file 囉。

但 `hello.html` 也是後續需要被納入版本控制的檔案，當務之急還是趕快透過 `git add` 讓 Git 知道這位之後也是快樂夥伴吧。

    $ git add hello.html

此時，終端機畫面看起來平靜無波、不起漣漪，但我們可以利用 `git status` 確認一下。

    $ git status
    On branch master

    Initial commit

    Changes to be committed:
      (use "git rm --cached <file>..." to unstage)

	          new file:   hello.html

看起來 `hello.html` 這個檔案有被順利認識並註記為新朋友了，但這其實還不算是真的加入為版控成員。`git add` 這個指令就像跟 Git 說：這位先登記錄取，之後再跟其它人一起報到的意思差不多。

等到其它需要新增、修改的檔案也透過 `git add` 登記好了之後，再利用 `git commit` 一起正式報到給 Git 儲存控管。

    ＄ git commit -m "Add some files for ..."

在 `git commit` 後加上參數 `-m` 可以直接輸入本次修改處理了什麼事情，讓其他協作者或將來的自己可以快速看懂這次的修改發生了什麼事。

完成 `git commit` 之後，總算是將這次的修改正式交給 Git 控管了！

如果想研究如何搭配圖像介面使用，或是想進一步了解更多細節，建議可以服用[這篇](https://gitbook.tw/chapters/using-git/add-to-git.html)，個人覺得對了解這些指令有奇效 XD

## 總結

這篇稍微介紹了 PM 平常會用到的一些 Git 入門指令，熟悉這些指令後就可以在不同分支中跳來跳去，一下我進來了，一下我又出去了，耶！

這些指令用起來都不難，也沒什麼毀天滅地的破壞性，建議同是 PM 的你可以試著以此為起點接觸 Git，發現它的妙用後就能做更多的應用。Git 絕對是 PM 值得一點的技能樹！

如果有興趣進一步認識 Git 的話，就走這道[任意門](https://gitbook.tw/)前往探索吧！門的彼端有詳盡、有趣、又容易理解的介紹喔！

---

>  👩‍🏫  __課務小幫手：__
>  
> ✨ 想掌握 Git 觀念和原理嗎？
>
> 我們有開設 🔮 [坐上 Git 時光機 - 版本控制](https://5xruby.tw/courses/git) 課程唷 ❤️️
>


post-PM 也能乘著 Git 時空旅行

PM 也能乘著 Git 時空旅行


「咦？為什麼系統的訂單金額一直都是顯示成 0 元？」「從什麼時候開始有這問題的？」

主管看到訂單系統的顯示結果不正常，想問到底是怎麼一回事。但這個專案的開發團隊有二十多人，大家每天都有許多的 Commit，也許某位同事無意間改了計算稅務的功能，結果不小心跟著改到訂單顯示金額了。

如果很明確的知道問題是出在哪一個檔案的話，我在「[為你自己學 Git](https://gitbook.tw)」一書的「[【狀況題】等等，這行程式誰寫的？](https://gitbook.tw/chapters/using-git/git-blame.html)」章節曾經介紹過 `git blame` 指令可以找出指定檔案的第幾行是誰在什麼時候寫的，一下子就可以把犯人抓出來。

但是，有時候一個問題的造成，背後可能是多個程式執行之後的結果，或像是開發 iOS App 需要進行編譯才能看到顯示結果為什麼不正確，所以可能不是單純光用 `git blame` 就能輕鬆找出問題來。更何況，這個問題可能早在幾週前就發生了，只是當時沒人發現，直到現在才曝光。在這麼多的 Commit 裡，要怎麼知道從哪個 Commit 開始是有這個問題的？特別是如果大家在 Commit 訊息都沒有特別註明自己改了什麼內容的話，面對這幾百甚至是幾千個 Commit，難道只能 Checkout 到每一個 Commit，然後檢查訂單的顯示結果是不是正確嗎？

## 使用「二分法」

不知道大家有沒有玩過「猜數字」遊戲：

「請你從 1 到 100 之間猜一個數字，如果沒猜中，我會跟你說你猜的數字比答案大還是比答案小，然後繼續猜，直到猜到為止」

「50！」

「比 50 大」

「75！」

「比 75 小」

「65！」

「恭喜你，答對了」

通常一開始我們會使用「二分法」從中間的 50 開始猜，為什麼？因為這樣一次就能刪掉一半的數字，沒猜中的話，就再對剩下的另一半再切一半繼續猜，這樣應該沒幾次就能猜到答案了。

在 Git 裡有個叫做 `bisect` 的指令，也是用類似的「猜數字」的方式，可以很快把有問題的點找出來。

<i class="icon-download" aria-hidden="true"></i>檔案下載：<https://ubin.io/git-bisect>

在這個範例裡，目前總共有 23 次 Commit：

    $ git log --oneline
    6e593bc (HEAD -> master) update CSS
    e67e3cf add footer
    da11948 update CSS
    84ee212 add links
    8b59e89 add Tiger page
    711bc24 update title of Fish page
    1ee10be update page
    6a8fb89 update title
    6e3fab8 update title
    b031a2c update page
    73860fa update page
    f53c5ea add Fish page
    afa4537 add cover image
    2d15868 remove js code
    8f744f8 add Dog page
    b51f5e8 add Cat page
    da3d4b9 update CSS
    7a51f8e add Sign in form
    7e64d30 update script
    1086842 link style and script file in index
    f6b72af add stylesheet and script file
    3de629a add HTML content
    f9f14ff init commit

不知道什麼時候開始，在 `index.html` 頁面上的 Sign In 按鈕沒辦法按了（被 disabled 了）。看看上面這些 Commit 訊息，寫得實在很糟糕...根本看不出來 update 了什麼內容。

所以，除了一個一個去看到底每個 Commit 改了什麼之外，我們可以試著使用 Git 裡的 `bisect` 指令來抓問題：

    $ git bisect start 起始點 結束點

因為我確定在 `f6b72af` 的時候功能還是正常的，所以可以這樣做：

    $ git bisect start HEAD f6b72af

意思是針對目前的所在地（也就是 `HEAD`）到 `f6b72af` 這段範圍開始來做二分法。按下 Enter 鍵執行之後：

    $ git bisect start HEAD f6b72af
    Bisecting: 9 revisions left to test after this (roughly 3 steps)
    [73860fa1ba395a7db7dd34c966644f667b0b87e3] update page

這時 Git 會直接跳到差不多一半的地方，也就是 `73860fa` 這個 Commit。這時候發現功能還是正常的，Sign In 按鈕是可以按的，所以就可以跟 Git 說目前的結果是好的：

    $ git bisect good
    Bisecting: 4 revisions left to test after this (roughly 2 steps)
    [711bc2458ac4c9c87b41110a4f23224ff1536a13] update title of Fish page

這時 Git 會自動跳到差不多中間的位置，也就是 `711bc24` 這個 Commit。重新整理頁面，發現這時候功能是壞掉的...所以繼續跟 Git 說現在是壞掉的：

    $ git bisect bad
    Bisecting: 2 revisions left to test after this (roughly 1 step)
    [6e3fab83aeb14d9640337357027c167194f0c628] update title

現在看起來是正常的，所以：

    $ git bisect good
    Bisecting: 0 revisions left to test after this (roughly 1 step)
    [1ee10be0c8b8565a8d2e66e1707d90c3ef3fa07a] update page

如果結果是正常的，就是 `git bisect good`，如果結果是不正確的，就是 `git bisect bad`，在不斷的 good 跟 bad 的交錯幾次之後，最後找到答案了：

    $ git bisect bad
    6a8fb890400553b95e27996ec948fefb836cb2d6 is the first bad commit
    commit 6a8fb890400553b95e27996ec948fefb836cb2d6
    Author: Eddie Kao <eddie@digik.com.tw>
    Date:   Wed Aug 7 16:18:23 2019 +0800

        update title

    :100644 100644 bd266562ec6d1ec64e5c29f32c7190582db95958 39f7c9edc892bd2b2e916e233ad1bc3989f7a3d4 M	index.html

抓到了！看看在第一行出現的訊息，Git 告訴你「6a8fb89...cb2d6 is the first bad commit」，就是從這個地方開始壞掉的，原來是某位同事在修改頁面的時候暫時把那個按鈕關掉，結果忘記改回來...

如果 `bisect` 做一半不想做了，或是做完了，可以使用 `reset` 參數：

    $ git bisect reset
    Previous HEAD position was 6a8fb89 update title
    Switched to branch 'master'

然後就回到原本的 `master` 分支了。

雖然在這個範例只有少少 23 個 Commit，可能感受不出來效果，感覺自己一個一個 Commit 查也是可以查得到，但如果是 230 個或是 2,300 個就不一樣了。生命應該浪費在寶貴的事物上，而不是浪費在這種地方呀 :)

> 本文轉載自「為你自己學 Git」電子書之追加章節

---

>  👩‍🏫  __課務小幫手：__
>  
> ✨ 想掌握 Git 觀念和原理嗎？
>
> 我們有開設 🔮 [坐上 Git 時光機 - 版本控制](https://5xruby.tw/courses/git) 課程唷 ❤️️
>


post-咦？這個問題是從什麼時候就有的？

咦？這個問題是從什麼時候就有的？

大家好，今天要來跟大家說一個如果是非本科系的工程師不確定上課有沒有學過，如果是本科系的應該是上課有學過，菜鳥工程師可能會不小心踩到的坑，在開始說明之前先給大家看一段程式碼。

這是一段很簡單的 Ruby 程式碼，表示調整廣播電台頻道的類別，支援預設電台的功能，也就是說使用者在按下某個按鈕，就可以跳到喜歡的頻道(話說現在年輕人還知道電台嗎？＠＠)。

```ruby
class Tuner
  def initialize(presets)
    @presets = presets

    clean
  end

  private

  def clean
    @presets.delete_if { |preset| preset[-1].to_i.even? }
  end
end

p presets = %w(90.1 106.2 88.5) # -> ["90.1", "106.2", "88.5"]
p turner = Tuner.new(presets) # -> <Tuner:0x00007fe7b08ff170 @presets=["90.1", "88.5"]>
p presets # -> ["90.1", "88.5"]
```

大家發現了嗎？ presets 已經被我們改變了，在討論為什麼之前我們先來看看有什麼方式可以傳遞引數！

## 傳遞引數的方式

1. Pass-by-reference：丟到方法裡的引數實際上只是變數的參考(reference)，修改引數就會修改到原始的變數。

2. Pass-by-value：丟到方法裡的引數是變數的值(value)，修改引數不會修改到原始的變數。

## Ruby 的引數是如何傳遞？

參考[官網的FAQ](https://www.ruby-lang.org/en/documentation/faq/4/)：

在 Ruby 中所有的變數和常數都會指向一個參考物件，除了直接使用會噴 NameError 例外錯誤的未初始化區域變數(沒有參考)，當我們指派一個變數或初始化一個常數，表示我們設定了變數或常數指向的參考物件。

意思是指派這件事情，實際上並不會產生一個複製的新物件，例如前面範例程式碼中 `presets = %w(90.1 106.2 88.5)` 表示說 `presets` 是會指向 `%w(90.1 106.2 88.5)` 參考物件的變數。

但 `Fixnum`, `true`, `nil`, 和 `false` 是例外，他們是 `immediate values`，變數會保持本身的物件而不是另外指向一個參考物件，這些例外被指派的引數會產生這個類型的複製物件。

當方法被調用時，引數被指派為參數：

```ruby
def addOne(n)
  n += 1
end

  a = 1
p addOne(a) # -> 2
p a         # -> 1
```

當傳遞的是物件的參考時，一個方法是有可能改變傳進來的可變物件(mutable object)：

```ruby
def downer(string)
  string.downcase!
end

p a = "HELLO" # -> "HELLO"
p downer(a)   # -> "hello"
p a           # -> "hello"
```

### 小結：
- Ruby 傳遞引數的方法並沒有相當於其他語言的 pass-by-reference。
- Ruby 是 pass-by-value，但是 values 是 references，Pass by reference value 可能是相對準確的說法。

---

回頭看看上面的 code，把 `object_id` 印出來觀察，presets 改變的原因是因為傳進方法的是可變物件的參考(相同 `object_id`)，當我們直接改變物件就直接改到了原來的物件。

```ruby
class Tuner
  def initialize(presets)
    @presets = presets

    clean
  end

  private

  def clean
    @presets.delete_if { |preset| preset[-1].to_i.even? }
    p @presets.object_id # -> 70140344834080
  end
end

p presets = %w(90.1 106.2 88.5) # -> ["90.1", "106.2", "88.5"]
p presets.object_id # -> 70140344834080
p turner = Tuner.new(presets) # -> <Tuner:0x00007fe7b08ff170 @presets=["90.1", "88.5"]>
p presets # -> ["90.1", "88.5"]
```

## 解決方法

上面的範例，看起來可以改成這樣：

```ruby
class Tuner
  def initialize(presets)
    @presets = clean(presets)
  end

  private

  def clean(presets)
    presets.reject { |preset| preset[-1].to_i.even? }
  end
end

p presets = %w(90.1 106.2 88.5) # -> ["90.1", "106.2", "88.5"]
p turner = Tuner.new(presets) # -> <Tuner:0x00007f9adfaa2b80 @presets=["90.1", "88.5"]>
p presets # -> ["90.1", "106.2", "88.5"]
```

因為 reject 會以傳回一個新的陣列代替更改接收端(presets)，故原本的物件並不會被我們修改到，但這並不一定是個好方法，如果我們不需要在初始化的階段就更改 presets，或是其他實體的方法才需要更改 presets，還是有可能會遇到麻煩。

**所以其實我們真正想要的是，可以用複製物件來代替指向原本物件的參考。**

## Ruby 複製物件的方法

Ruby 有兩種複製物件的方法：`dup` 和 `clone`，雖然兩者都會根據接收端建立新物件，但 `clone` 會保存原始物件的 2 項額外功能，`dup` 則不會。

### `clone` 不同於 `dup` 的 2 項額外功能：

1.`clone` 會顧及接收端的凍結狀態(frozen status)，如果原始物件已經凍結，那副本也會是凍結的。

```ruby
    object = Object.new
    object.freeze
    p object.frozen? # -> true
    dup_object = object.dup
    p dup_object.frozen? # -> false
    clone_object = object.clone
    p clone_object.frozen? # -> true
```

2.如果接收端有單例方法，`clone` 會複製單例類別(singleton class)。

```ruby
    object = Object.new
    def object.wow; :wow end
    p object.singleton_methods # -> [:wow]
    p object.wow # -> :wow
    clone_object = object.clone
    dup_object = object.dup
    p clone_object.wow # -> :wow
    p dup_object.wow # -> undefined method `wow' for #<Object:0x00007f7effa8af40> (NoMethodError)
```

所以當我們想修改物件的時候，大部分會選則用 `dup` 而不是 `clone`，因為凍結的物件無法修改或解凍，所以 `clone` 可能會回傳無法修改的物件。

## 修改程式碼

所以我們現在將程式碼改成這樣：

```ruby
class Tuner
  def initialize(presets)
    @presets = presets.dup

    clean
  end

  private

  def clean
    @presets.delete_if { |preset| preset[-1].to_i.even? }
  end
end

p presets = %w(90.1 106.2 88.5) # -> ["90.1", "106.2", "88.5"]
p turner = Tuner.new(presets) # -> <Tuner:0x00007fe7b08ff170 @presets=["90.1", "88.5"]>
p presets # -> ["90.1", "106.2", "88.5"]
```

恭喜！這樣就解決了我們一開始更改到原始物件的問題了！

## 注意

雖然我們已經解決問題了，但要留意 `dup` 和 `clone` 只會產生淺層複製(shallow copy)的物件，意思是對於 `Array` 這類的集合物件，雖然複製了容器，但並未複製容器內的元素，我們可以在不影響原始物件的情況下加入或移除元素，但是如果我們試圖要修改 `Array` 裡的元素，就會修改到原始元素，例如：

```ruby
array = ["Polar"]
p dup_array = array.dup << "Bear" # -> ["Polar","Bear"]
p dup_array.each { |element| element.sub!("lar", "oh") } # -> ["Pooh", "Bear"]
p array # -> ["Pooh"]
```

可以看到我們還是修改到原始物件的元素了，編寫自己的類別的時候我們可以複寫 `initialize_copy` 這個方法來控制複製過逞的深度，如果需要使用既有類別深層副本的物件，就必須自行處理。

另外有一個方法是可以使用 [Marshal](https://ruby-doc.org/docs/ruby-doc-bundle/ProgrammingRuby/book/ref_m_marshal.html) 類別來序列化，然後再對集合及其元素進行序列化還原：

```ruby
array = ["Polar"]
p dup_array = Marshal.load(Marshal.dump(array)) << "Bear" # -> ["Polar","Bear"]
p dup_array.each { |element| element.sub!("lar", "oh") } # -> ["Pooh", "Bear"]
p array # -> ["Polar"]
```

使用 `Marshal` 會有相當的限制，除了時間，他要對物件序列化並還原序列化，還必須考慮記憶體的需求數量。複製的物件將會佔用它自己的記憶體空間，如此一來使得 `Marshal::dump` 建立序列化位元組資料流，因此假如載入大型物件會使得程式大幅增加記憶體需求。

另一個問題是 `Marshal` 並非可以對所有的物件作序列化，例如 IO 類別的實體、單例物件(singleton objects)等，會引發 TypeError 的例外。

## 總結

- 大部分的情況我們使用 `dup` 就可以解決想要複製物件的問題了，但如果我們可以了解這些限制能讓我們將來在需要做深層副本的時候遠離麻煩。
- Ruby 表現得像為不可變物件傳遞值(pass-by-value)，為可變物件傳遞參考(pass-by-reference)。
- `dup` 和 `clone` 只會建立淺層副本。
- 大多數物件來說，`Marshal` 能在需要時用來建立深層副本。

### 參考： 
[Effective Ruby](https://www.effectiveruby.com)

---

>  👩‍🏫  __課務小幫手：__
>  
> ✨ 想掌握 Ruby on Rails 觀念和原理嗎？
>
> 我們有開設 🏓 [Ruby on Rails 實戰課程](https://5xruby.tw/courses/ruby-on-rails) 課程唷 ❤️️
>

post-新手不小心會踩到的坑：我真的複製出物件了嗎？

新手不小心會踩到的坑：我真的複製出物件了嗎？


## 什麼是 DSL? DSL 的存在意義是什麼？

DSL 為 Domain Specific Language 的縮寫，中文譯為「特定領域語言」。而 DSL 的開發通常是為了迎合某些特殊的需求，例如針對系統、平台、程式工具、軟體問題、商業邏輯等等領域，當人們發現現有的程式語言並沒有辦法好好地嵌合使用需求，DSL 就有其存在的價值。目前為人所知的 DSL 包括 CSS 以及 SQL，而這種易於人類閱讀的 DSL 也能夠讓程式設計師乃至於一般使用者都能享受 DSL 帶來的好處，甚至不懂程式設計的使用者都能夠針對自己的需求調整參數。

而 Ruby 本身由於程式設計面本身帶有易於閱讀的特質，因此非常多的 Gem 都是開發為 DSL 的形式，例如 [AASM](https://github.com/aasm/aasm)、[whenever](https://github.com/javan/whenever)、以及最為廣為人知，最多人使用的測試框架 [RSpec](https://github.com/rspec/rspec) 等等。

這篇文章透過設計一個簡單的 RSpec 框架，來告訴大家一個 DSL 是如何開發而成的。

## 測試範例

我們會用下面的程式來舉例。

```ruby
class CatFactory
  def produce
    "meow"
  end
end

describe CatFactory
  describe "#produce" do 
    it "produce a cat and meowing" do
      expect(CatFactory.new.produce).to eq("meow")
    end

    it "does not produce a dog" do
      expect(CatFactory.new.produce).not_to eq("woof")
    end
  end
end
```

這是一個相當簡單的範例，我們有個貓咪工廠，每當我們產出一隻貓就會喵一聲。下面的 Test Case 則有兩個，在 DSL 的形式之下，我們可以很明顯地讀懂這個測試想表達的意思：我們希望測試這個 #produce 函式可以產生出一隻貓，並且「喵」一聲，而不是產生出一隻狗。

## 實作 RSpec

接著我們會慢慢地實作出小型的測試框架，先從 describe 開始吧！

```ruby
class Describe
  def initialize(context, &block)
    @context = context
    instance_eval(&block)
  end

  # 為了讓我們可以使用 describe 來做成巢狀結構
  def describe(context, &block)
    Describe.new(context, &block)
  end
end
```

由於我們希望 DSL 的形式是 `describe CatFactory` 而不是`Describe.new(CatFactory)`，我們可以在 Describe 這個 class 外面新增一個 helper method:

```ruby
# helper method

def describe(context, &block)
  Describe.new(context, &block)
end
```

如此以來我們就可以利用 `describe` 來創造一個清楚明瞭的巢狀結構了。

接著我們希望把每個測試的 Case 都化為一個物件稱為 Example，因此我們要在創建一個新的 class。

```ruby
class Example
  def initialize(context, &block)
    @context = context
    instance_eval(&block)
  end

  def expect(result)
  end

  def to(expectation)
  end

  def not_to(expectation)
  end

  def eq(expectation)
  end
end
```

讓我們來一個一個實作這些函式吧。

\#expect 這個函式單純只是保存測試的結果，因此是最為容易的一個。

```ruby
  def expect(result)
    @result = result

    # 為了讓 #expect 之後可以繼續串 Example 裡頭的其他函數，所以我們這裡希望回傳 self。

    self
  end
```

\#eq 這個函式很單純只是做出像 `==` 一樣的運算，不過我們必須將它傳進 \#to，並且和真正的結果對比。這裡我們會用 Proc 來處理。

```ruby
  def to(expectation)
    @test_result = expectation.call(@result)
  end

  def eq(expectation)
    Proc.new { |result| result.eql?(expectation) }
  end
```

別忘了，我們還有一個 \#not\_to，不過 \#not\_to 其實就是 \#to 的相反，因此就很容易了。

```ruby
  def not_to(expectation)
    @test_result = !(expectation.call(@result))
  end
```

## 顯示測試的結果

我們已經實作了大致的邏輯，現在我們希望可以在終端機中顯示我們的測試結果。這裡我們希望顯示出 describe 的巢狀結構，並且也列出所有 \#it 表示的測試內容描述。為了表現出測試的結果是否成功與失敗，我們要運用 `colorize` 這個 Gem。

為了達到上述的功能，我們希望給 `Example` 一個 `test_result` 的 Reader，讓 `Describe` 可以得知測試的結果。

```ruby
  class Example
    attr_reader :context, :test_result

    # other code below
    # ...
  end
```

接著我們讓 `Describe` 可以用陣列儲存我們的 context 和 example：

```ruby
  class Describe
    attr_reader :context, :examples, :describes
     def initialize(context, &block)
      @context = context
      @describes = []
      @examples = []
      instance_eval &block
    end

    def describe(context, &block)
      describes << Describe.new(context, &block)
    end

    def it(context, &block)
      @examples << Example.new(context, &block)
    end
  end
```

最後，我們在 `Describe` 裡面實作一個 `test` 函式 來啟動整個測試：

```ruby
    def test
      puts context
      describes.each do |describe_node|
        puts "  " + describe_node.context
        describe_node.examples.each do |example_node|
          color = example_node.test_result ? :green : :red
          puts "    " + example_node.context.colorize(color)
        end
      end
    end
```

在這個函式裡面我們可以看見，我們先印出最上位的 context，之後我們再印出每個巢狀結構下面的 `describe` 裡面的 context，最後則是印出 Example 的結果。而 color 的部分則是我們的 test_result 是 true 的情況下印出綠色，而 false 的情況下則印出紅色。

接著讓我賦予 test case 一個變數，然後啟動測試。

```ruby
rspec = describe CatFactory
  describe "#produce" do 
    it "produce a cat and meowing" do
      expect(CatFactory.new.produce).to eq("meow")
    end

    it "does not produce a dog" do
      expect(CatFactory.new.produce).not_to eq("woof")
    end
  end
end

rspec.test
```

當你執行這個 Ruby 檔案時，你應該會看到一個巢狀結構的顯示，代表你順利創造出了這個小型的 DSL 測試框架了！

```ruby
CatFactory
  #produce
    produce cat and meowing
    does not produce dog
```

## 總結

由於 Ruby 的種種特性（適合 Metaprogramming，簡潔的寫法，易讀的語句），讓 DSL 的實現變得更加容易，也使得很多的 Gem 成為非常洗鍊的 DSL 工具。未來在製作自己的工具的時候，不仿利用這些特性，也可以讓你的工具更加易於應用及推廣。

---

>  👩‍🏫  __課務小幫手：__
>  
> ✨ 想掌握 Ruby on Rails 觀念和原理嗎？
>
> 我們有開設 🏓 [Ruby on Rails 實戰課程](https://5xruby.tw/courses/ruby-on-rails) 課程唷 ❤️️
>


post-以 Rspec 為例，創造一個自己的 DSL 工具吧！

以 Rspec 為例，創造一個自己的 DSL 工具吧！


在 [COSCUP 2019 講完用 WebRTC 建立半分散式網路](https://coscup.org/2019/programs/58fcc6a0-1e5c-4a17-af0a-3e3dfba381c4)，想說來把[投影片](https://md.pastleo.me/p/webrtc-network-coscup2019-talk#/)整理成一篇文章來紀錄一下這段時間拿 WebRTC 嘗試形成網路的一些實驗結果

## WebRTC 是什麼？

簡單來說 WebRTC 可以讓瀏覽器直接跟瀏覽器連線，但是連線的建立很麻煩，開發者要自己想辦法讓兩個瀏覽器交換 handshake 資訊 (offer, answer, ice)

## Multiplayer game using WebRTC

跟朋友開始一個遊戲(?)專案 -- Bazaar，就如同下面這個影片這樣，可以有多個玩家在畫面上走來走去跳來跳去，移動等資訊就是透過 WebRTC 傳輸的

![](https://static.pastleo.me/assets/bazaar-coscup-demo.gif)

* 程式碼： [https://github.com/pastleo/bazaar](https://github.com/pastleo/bazaar)
* 想試玩？在這： [https://bazaar-pre.pastleo.me/](https://bazaar-pre.pastleo.me/)

### Bazaar client 之間的連線方法

其實很無腦，首先用 websocket 跟伺服器 (wss) 連線，接著與所有玩家連線

![](https://i.imgur.com/3auxTBw.gif)

1. firefox 與 wss 連線
2. firefox 與 wss 連線完成
3. chromium 與 wss 連線
4. chromium 與 wss 連線完成
5. chromium 透過 wss 與 firefox 建立 WebRTC 連線
6. chromium 與 firefox 的 WebRTC 連線建立完成
7. safari 與 wss 連線
8. safari 與 wss 連線完成
9. safari 透過 wss 與 firefox 以及 chromium 建立 WebRTC 連線
10. safari 與 firefox 以及 chromium 的 WebRTC 連線建立完成

這邊很快就會發現一件事，就是每個玩家的連線數是總玩家數 - 1，也就是說假設有 20 個人在場上，瀏覽器要建立 19 個連線...雖然沒有明定 WebRTC 的連線數限制...但是我自己後來做測試時大概 30 ~ 40 個連線時 chromium 會跟我說太多連線不允許建立更多連線

## 一個發想：如果 server 可以是一個 NPC...

不知道當時在想什麼，這個念頭讓我開始把 server 當成 client 看待，為了讓 browser 對待 server 就跟其他 browser 一樣，嘗試製作 WebRTC 跟 WebSocket 共用的界面

### WebRTC 與 WebSocket 共用的 interface

![](https://static.pastleo.me/assets/190815150840.svg)

對於 wsConn 以及 rtcConn 來說，提供的功能就是送訊息以及接收訊息，很容易做成共用的界面

雖然兩者建立連線的方式有很大的不同，但是 WebRTC 連線建立其實就是需要一個節點幫忙傳送 handshaking 資料，於是試著蓋一層 peerConns，上面提供 API `connect(peer, viaPeer)`

![](https://static.pastleo.me/assets/190815153930.svg)

* `peer` 如果是 WebSocket URL，則不需要 `viaPeer`，直接連線就好，而且就算給 `viaPeer` 也不會怎麼樣
* `peer` 如果是一個瀏覽器 (每個瀏覽器初始化時會自動產生一個 id)，必須給上 `viaPeer` 指定一個節點幫忙傳送 handshaking 資料建立連線

> 不過 bazaar 遊戲到目前為止 `viaPeer` 永遠會是 wss

## 透過 browser 進行 WebRTC 連線建立會是什麼樣子？

WebRTC 連線一定會需要一個節點幫忙做連線，因此

* 第一個連線一定是 WebSocket

後來可以透過瀏覽器幫忙連線，因此

* 加入網路之後可以關閉 WebSocket 連線

舉個例子來跑一次看看：

![](https://i.imgur.com/jTHtCHY.gif)

1. 假設一開始 chromium 已經跟 firefox 建立 WebRTC 連線，chromium 已經跟 wss 建立 WebSocket 連線，而且 firefox 沒有跟 wss 連線
2. safari 與 wss 連線
3. safari 與 wss 連線完成
4. safari 透過 wss 與 chromium 建立 WebRTC 連線
5. safari 與 chromium 的 WebRTC 連線建立完成
6. safari 透過 chromium 與 firefox 建立 WebRTC 連線
7. safari 與 firefox 的 WebRTC 連線建立完成

雖然第一個連線一定是 WebSocket，不過還是可以某種程度的降低對 WebSocket server 的依賴性，於是就開始嘗試把整個連線的東西抽出來做...

## 半分散式網路

這個抽出來的東西暫時叫他 unnamed-network(?)，總結前面的實驗以及遇到的問題，抽出來之後做了這些事：

* 在這之前 WebSocket server 都是 Elixir 做的，這邊改用 nodejs 實做
  * WebSocket server 是個 client, 網路中同時可以有複數個
* 群組功能
  * 一個 client 可以同時加入多個 group
  * 群組廣播

### unnamed-network 架構

![](https://static.pastleo.me/assets/190815183330.svg)

* wsConn 與 rtcConn 部份幾乎與上面一樣負責收發訊息
* connProvider 部份負責處理 browser 與 wss 接受連線時行為上的不同
* connManager 與上面差不多，提供 `connect(peer, viaPeer)` 給上層使用
* client 部份負責網路的維持並提供群組功能

### connManager 連線建立策略

因為 wss 也只是一個 client 了，wss 也很有可能會想要主動與他人連線，列舉一下整理成四種情況：

| 左下連右上 | wss    | browser        |
|----------|--------|----------------|
| wss      | ws 直連 | 邀請連 ws `(!)` |
| browser  | ws 直連 | WebRTC `(!)`   |

這邊比較有趣的就是『當 wss 想要連到 browser』的狀況，這邊想到的方法是透過 viaPeer 邀請 browser 來連 wss；需要 viaPeer 的部份標上 `(!)`，所以結論來說不是只有 WebRTC 會需要 viaPeer

### 網路的維持以及群組功能

這就是還很不完善的部份了，這邊就稍微講一下目前運作的行為

* 初始化時
  * 每個 client 有一個 known list 紀錄已知的 wss
  * 所有 client 都會加入 `"/"` 群組
* 加入群組時
  * 對 `"/"` 請求 `route-group`
    * max hops: 10
  * 加入群組時發現找不到人就是建立新群組

沒關係這邊有簡易的案例：

![](https://i.imgur.com/gpqosXj.gif)

1. 假設一開始有一個 `group1` 有三個人，其中 chrome 與 wss 連線
2. safari 因為 known list 知道 wss 的存在，加入 `"/"` 群組時會去找 wss 連線
3. safari 與 wss 連線建立
4. safari 對著 `"/"` 群組的節點詢問 `route-group` `group1` 怎麼走，因此對著 wss 發問
5. wss 對著 `"/"` 群組的節點詢問 `route-group` `group1` 怎麼走，因為詢問來自 safari，因此對著 chrome 發問
6. chrome 自己在 `group1`，回覆自己的 id
7. wss 收到回覆，回覆 safari 得到的 id 加上自己的 id
8. safari 透過 wss 與 chrome 連線進入 `group1`，因此透過 wss 與 chrome 進行 WebRTC 連線並請求加入 `group1`
9. safari 與 chrome 的 WebRTC 連線建立完成並且加入 `group1`

不過這個網路顯然大家會來來去去的，safari 只跟 group1 保持一個連線感覺很危險，所以加上 neighbor 數量維護的機制，每個節點自己會盡可能維持一個群組內的連線數（也就是鄰居 neighbor 數）在 3 - 6 個之間：

* 低水位: 3 -- 低於這個數量會嘗試尋找更多 neighbor
* 高水位: 6 -- 高於這個數量會去減少 neighbor 數量
* 滿水位: 10 -- 不接受更多連線
  * wss 的滿水位設定在 100 避免加入不了網路

所以舉例來說：

![](https://i.imgur.com/nvyvc9q.gif)

1. 假設延續剛剛建立的狀態，且 wss 已經與另外 5 個節點連線
2. wss 有 7 個連線了，需要隨機挑選一個節點斷線，這邊假設選擇 safari 斷線，同時 safari 發覺自己的 neighbor 過少，詢問 `group1` 是否還有其他人
3. chrome 回覆其他 neighbor 的 id (firefox1, firefox2)
4. safari 透過 chrome 與 firefox1, firefox2 建立 WebRTC 連線
5. safari 與 firefox1, firefox2 的 WebRTC 連線建立完成

花了這麼多力氣建立了網路...總得來送些訊息吧？群組廣播的時候發起廣播的節點需要附上隨機的 `msgId` 然後送給 neighbors，收到廣播訊息的節點先看一下 `msgId` 是否有看過，如果看過就不要理他，反之則觸發事件告訴更上面的 application 層並且繼續傳遞自己的其他 neighbors，一樣舉個例子：

![](https://i.imgur.com/ZRESfTl.gif)

1. 假設 group1 已經有 6 個節點，連接的拓撲上有環
2. safari 發出廣播，假設 `msgId` 為 `123`，傳送給 chrome, firefox 與另一個 safari
3. chrome 與 firefox 之間如果又收到同樣的 `msgId` `123`，則會避免繼續再把訊息散布下去

不過如果有 neighbor 離開, 斷線又或是一堆人離開的時候，還沒有想到一個好方法避免孤島產生，目前的方式就是重新找 wss 加入群組，其實是很沒效率而且很容易出問題的方法...所以這個網路或許建立連線的時候還行，但如果要在人來來去去的情況下持續運作是肯定有問題的

### 要讓這個 network 能用的話需要...

* 能跨多個 node 進行連線以增加多 hop 連線效率
  * 上面提到透過 viaPeer，意思是只能透過一個節點來幫忙連線，如果要跨多個點連線則是要依序跟路上所有人建立連線
* wss 能夠提供 stun/turn 服務，有自己嘗試架設了 stun server 用在下面的 demo 看起來還行
  * [https://aur.archlinux.org/packages/coturn-git/](https://aur.archlinux.org/packages/coturn-git/)
  * [https://github.com/coturn/coturn](https://github.com/coturn/coturn)
  * [https://aur.archlinux.org/packages/stund](https://aur.archlinux.org/packages/stund)
* 分散式，並且同時可以避免孤島產生的機制
  * 感覺上 [Distributed hash table](https://zh.wikipedia.org/wiki/%E5%88%86%E6%95%A3%E5%BC%8F%E9%9B%9C%E6%B9%8A%E8%A1%A8) 可能是解法之一
* 解決安全性問題
* 釋出為一個連線框架

### 拿來做個 Youtube sync 聊天室

畢竟都花這麼多力氣了，就來做點東西刷點存在感，這是一個群組聊天室，加上 Youtube 同步播放(或是同步顯示 imgur 圖片)的功能，跑起來大概像是這樣：

<iframe width="560" height="315" src="https://www.youtube.com/embed/kogpQkkBlGY" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

#### DEMO 站連結：
[https://static.pastleo.me/unnamed-network-chat-ysync/](https://static.pastleo.me/unnamed-network-chat-ysync/)

> 可以的話請用 chrome / chromium 最新電腦版，同時網路順暢的情況下試玩，這個東西就如同上面講的還有問題，所以有 bug 也算是在預期內

個人是期望這個 network 可以做到這些事情：

* 使得瀏覽器不用安裝任何 plugins / add-ons 就可以使用分散式應用程式
* 降低架設 wss 的技術門檻，人人都可以成為網路進入點
* 讓不同應用程式可以共用這個 network 來建構多人遊戲、共筆系統等

### unnamed-network 專案：
[https://github.com/pastleo/unnamed-network](https://github.com/pastleo/unnamed-network)

如果看完有興趣歡迎來按個星星讓我知道這個東西可以繼續做，或是透過我的個人網站 [https://pastleo.me/](https://pastleo.me/) 上的聯絡方式找到我，感謝各位的閱讀！

本技術文章同時也發布在個人站上：[https://md.pastleo.me/webrtc-unnamed-network-chatroom](https://md.pastleo.me/webrtc-unnamed-network-chatroom)


Post - 用 WebRTC 半分散網路弄一個聊天室 - cover

用 WebRTC 半分散網路弄一個聊天室

[React Hooks](https://reactjs.org/docs/hooks-intro.html) 在 React 16.8 推出之後 <del>(雖然已經有 lag 瞬間就已經來到 React 16.9.0 惹)</del>，讓工程師們又多出幾行 code 的時間可以滿足客戶的<del>磨練</del>需求啦！
這次就利用 React Hoock 來串接一個聊天室應用，看看 React Hooks 如何幫助簡化並加速整個開發過程。除了 React 自身提供的 `useState` 和 `useEffect` hook 之外，還會用到幾個開源的 React hooks 來幫忙提昇開發效率。

- 預計實做功能
	- 群組聊天室
	- 傳送與接收訊息
	- 訊息履歷
	- 使用者上線離線通知

## 準備工作

- [Open-chat server](https://github.com/akash-joshi/socket-server) 是一個使用 socket.io 和 Node.JS 技術的開源應用，這篇文章先把他想像成一個 server 端的黑盒子，主要負責處理這次 server 端的程式部份。
- 所有的 CSS 樣式會全放在一個 [ CSS ](https://github.com/fokayx/react-hooks-socket-client/blob/master/src/App.css) 檔案裡面。
- [React](https://reactjs.org/)
	- Node >= 8.10
	- npm >=5.6

```bash
npx create-react-app socket-client
#npx is not a typo — it’s a package comes with npm 5.2+
cd socket-client
npm start
```

然後在瀏覽器打開 `http://localhost:3000` 可以看到預設的歡迎首頁。接著先來認識一下幾個 APP 裡面會用到的 `hooks`。

## [useState](https://reactjs.org/docs/hooks-state.html)

`useState` 是 React 內建的 hook，用在讓 React functional component 也能擁有原本 class component 才能有的 `state`，原本想要存在 state 裡面的 data 可以輕鬆存在 `useState` 裡面，不用寫 class component 裡的 `this.state` 叭啦叭啦，而且當 state 更新的時候 `useState` 會自動重新渲染 component，兩者都能少寫好幾行的程式碼。

```javascript
import React, { useState } from 'react';
```

這次 APP 要用 `useState` 在 component 中存放使用者輸入的名稱、聊天室名稱，還有使用者名稱的 input 狀態，`nameInput` 這個主要是要確認使用者是否有填名稱，因為在這個 APP 裡面將使用者名稱 (name) 和使用者 id 綁在一起，所以一定要有填才能繼續下去，所以會宣告一個 `handleSubmit` 方法來確認使用者有沒有 name 填好填滿，如果有填 name 等於有了 id，再對 sever 發射訊號，進行建立一個使用者開啟或進入聊天室的動作，聊天室 (room) 的部份如果沒有特別填會進入一個預設的聊天室 (default)。檢查到 name 沒填的話，則會提示警告訊息：Name can't be empty <del>連名字都沒有是要怎麼聊天</del>。

```javascript
// App.js

import React, { useState } from 'react';
import './index.css';

export default () => {
  const [id, setId] = useState("");
  const [name, setNameInput] = useState("");
  const [room, setRoom] = useState("");

  const handleSubmit = e => {
    e.preventDefault();
    if (!nameInput) {
      return alert("Name can't be empty");
    }
    setId(name);
    socket.emit("join", name, room);
  };

  return id !== '' ? (
    <div>Hello</div>
  ) : (
    <div style={{ textAlign: "center", margin: "30vh auto", width: "70%" }}>
      <form onSubmit={event => handleSubmit(event)}>
        <input
          id="name"
          onChange={e => setNameInput(e.target.value.trim())}
          required
          placeholder="What is your name .."
        />
        <br />
        <input
          id="room"
          onChange={e => setRoom(e.target.value.trim())}
          placeholder="What is your room .."
        />
        <br />
        <button type="submit">Submit</button>
      </form>
    </div>
  );
};
```

上面的程式碼就是用 `useState` 來存放使用者名稱和聊天室名稱，然後有使用者名稱可以透過 socket 發射事件，server 接收後就會建立帳號 (id) 和聊天室，如果沒有 id 的話視同登出，會重新生成登入的表單畫面。

## [useSocket](https://github.com/iamgyz/use-socket.io-client)

Socket.IO 是在 server 和 client 端提供即時、雙向而且是事件導向的 library， APP 會用 Socket.IO 提供的 `useStocket` 來處理和 Open-chat server 的 websocket 連線和處理收發即時訊息。因為 `useSocket` 不是 React 提供的 hook，所以要安裝 `use-socket.io-client`，才能呼叫 `useSocket`，再用 `socket` 進行一個對 server 連線的動作：

```javascript
$ npm add use-socket.io-client

// APP.js
import useSocket from  'use-socket.io-client';
const  [socket]  =  useSocket('<https://open-chat-naostsaecf.now.sh>');
// useSocket(URL) -> URL：socket server 位址

socket.connect();
console.log(socket); //打開瀏覽器的 consle 確認一下 socket 的狀態是否有正確的連線。
```

在 Socket.io client library 提供的 `socket`  可以被用在任何的 component 裡面，然後透過 `socket` 串聯 server 端的事件，也因此只要是對這個 server 有連線的 client 端都可以對 server 發射事件，那在 APP 裡面的 clent 端如果有對該事件做監聽的話就可以做相對應的處理，例如聊天室更新訊息裡面包含自己和其他人的，來自遠方的他人訊息變動，用 Socket hooks 接收就可以在 APP 這邊各自做好對應的處理。

在這次的應用中會使用幾個 socket 提供的 API，想瞭解更多可以詳閱[官方說明書](https://socket.io/docs) XD

##  [useImmer](https://github.com/immerjs/use-immer)

`useImmer` 是 [Immer](https://github.com/mweststrate/immer) 提供的 hook，所以也要先安裝 `use-immer`，`useImmer` 結合 `useState` 和  Immer 來產生 immutable state，`useImmer` 會根據原始的 state 複製一份 draft state，這樣在進行 state data 操作的時候，可以完整保留原先的 state，相對安全地進行不同的程式邏輯處理，最後再對 state 進行更新。然後 `useImmer` 基本用法和 `useState` 有 87% 像，這裡要用來處理訊息紀錄和在線使用者的部份。看一下 `useImmer` 的基本用法：

```javascript
$ npm add use-immer

const [data, setData] = useImmer(default_value)

setData(draftState => {
  draftState.operation();
});
// ...or
setData(draftState => newState);
// draftState 是現有 state 的複製，進行處理之後可以更新 state
```

關於這個 `setData` 其中會傳入一個 draftState 參數，就是複製於原始的 state ，這麼做可以在 function 內安全地進行操作後再更新 state。APP 會用在訊息和在線人線的更新：

```javascript
const [messages, setMessages] = useImmer([]);
const [online, setOnline] = useImmer([]);
```

## [useEffect](https://reactjs.org/docs/hooks-effect.html)
`useEffect` 是 React 提供的一個 hook，如果對 React 的 class lifecycle methods 有點了解的話，可以當做和 `componentDidMount`、`componentDidUpdate`、`componentWillUnmount` 這三個的功用有點類似。

`useEffect` 在 component 初始渲染的時候會作用個，然後在 React update DOM  的時候再進行動作，在 `useEffect` 裡面可以處理 component 的更新。這邊將 socket 相關的程式邏輯放到 `userEffect`，例如監聽 server 端發出的 socket 事件，然後根據事件，更新在 `useEffect` 裡面處理一些先前定義的 message hook `setMessages` 更新 message，利用 `useEffect` 可以避免 component 重新渲染的時候產生不必要的重複動作，有助於整個 APP 的效能提昇。

```javascript
import React,  { useState, useEffect }  from  'react';
const [socket] = useSocket('<https://open-chat-naostsaecf.now.sh>');
socket.connect();

const [messages, setMessages] = useImmer([]);
useEffect(()=>{
  socket.on('update', message => setMessages(draft => {
    draft.push(['', message]);
  }));

  socket.on('message que',(nick, message) => {
    setMessages(draft => {
      draft.push([nick, message])
    })
  });
}, 0);
```

講到這裡，先來加入一個顯示訊息和一個顯示在線人數的 component：

```javascript
const Messages = props => props.data.map(m => m[0] !== '' ? (<li key={m[0]}><strong>{m[0]}</strong> : <div className="innermsg">{m[1]}</div></li>)
: (<li key={m[1]} className="update">{m[1]}</li>));

const Online = props => props.data.map(m => <li id={m[0]}>{m[1]}</li>);
```

現在再回頭看一下先前定義的 `handleSubmit`，裡面有一個 socket emit 事件 `join`，這個是用來讓 server 端接收到 socket 的發射事件，然後不論是在 server 端還是 client 端透過 `socket.on` 的設定接收，並做出對這個事件的相對處理，在這次的 APP 裡面會用在確認有使用者名稱 (id)，再比對聊天室名稱，如果聊天室名稱相同就會連到同一個聊天室，再進行一個列出該聊天室歷史訊息的動作，如果 server 端沒有比對到聊天室名稱但有填聊天室名稱的話就新開一個聊天室，萬一聊天室名稱未填寫，就讓使用者進入預設的聊天室。<del>bug：少做了一個同樣使用者名稱的阻擋和警告w</del>

```javascript
const handleSubmit {
// ...
  socket.emit('join', name, room);
};

return id ? (
  <section style={{ display: "flex", flexDirection: "row" }}>
      <ul id="messages">
        <Messages data={messages} />
      </ul>
      <ul id="online">
        {" "}
        &#x1f310; : <Online data={online} />{" "}
      </ul>
      <div id="sendform">
        <form onSubmit={e => handleSend(e)} style={{ display: "flex" }}>
          <input id="m" onChange={e => setInput(e.target.value.trim())} />
          <button style={{ width: "75px" }} type="submit">
            Send
          </button>
        </form>
      </div>
    </section>
) : (
// ...
```

## APP 戰神合體

看過上面的幾個 hook 的介紹之後，整個 APP 還要加上幾個小東西：

- 用 `useImmer` 再做一個在線使用者相關的 listener
- 訊息傳送的 submit handler

噹啷下面就是這次 React Hooks 聊天室的完整體現：

```javascript
// App.js

import React, { useState, useEffect } from 'react';
import useSocket from 'use-socket.io-client';
import { useImmer } from 'use-immer';

import './index.css';

let uniqueID = 1;
const Messages = props => props.data.map(m => m[0] !== '' ? (<li key={uniqueID++}><strong>{m[0]}</strong> : <div className="innermsg">{m[1]}</div></li>) : (<li className="update" key={uniqueID++}>{m[1]}</li>) );

const Online = props => props.data.map(m => <li id={m[0]} key={uniqueID++}>{m[1]}</li>);

export default () => {
  const [id, setId] = useState('');
  const [name, setNameInput] = useState('');
  const [room, setRoom] = useState('');
  const [input, setInput] = useState('');

  const [socket] = useSocket('https://open-chat-naostsaecf.now.sh');
  socket.connect();

  const [messages, setMessages] = useImmer([]);
  const [online, setOnline] = useImmer([]);

  useEffect(() => {
    socket.on('message que', (nick, message) => {
      setMessages(draft => {
        draft.push([nick, message])
      })
    });

    socket.on('update', message => setMessages(draft => {
      draft.push(['', message]);
    }));

    socket.on('people-list', people => {
      let newState = [];
      for (let person in people) {
        newState.push([people[person].id, people[person].nick]);
      }
      setOnline(draft=>{draft.push(...newState)});
    });

    socket.on('add-person', (nick, id) => {
      setOnline(draft => {
        draft.push([id, nick])
      })
    });

    socket.on('remove-person', id => {
      setOnline(draft => draft.filter(m => m[0] !== id))
    });

    socket.on('chat message', (nick, message) => {
      setMessages(draft => {draft.push([nick, message])})
    });
  }, 0);

  const handleSubmit = e => {
    e.preventDefault();
    if (!name) {
      return alert("Name can't be empty");
    }
    setId(name);
    socket.emit("join", name, room);
  };

  const handleSend = e => {
    e.preventDefault();
    if(input !== ''){
      socket.emit('chat message', input, room);
      setInput('');
    }
  };

  return id ? (
    <section>
      <div id="chat">
        <ul id="messages"><Messages data={messages} /></ul>
        <div id="sendform">
          <form onSubmit={e => handleSend(e)}>
              <input id="msg" value={input} onChange={e => setInput(e.target.value.trim())} /><button type="submit">Send</button>
          </form>
        </div>
      </div>
      <ul id="online"> &#x1f310; : <Online data={online} /> </ul>
    </section>
  ) : (
    <div id="login">
      <form onSubmit={event => handleSubmit(event)}>
        <input id="name" onChange={e => setNameInput(e.target.value.trim())} required placeholder="What is your name .." /><br />
        <input id="room" onChange={e => setRoom(e.target.value.trim())} placeholder="What is your room .." /><br />
        <button type="submit">Submit</button>
      </form>
    </div>
  );
};
```

以上就是對 React Hooks 的小小初體驗，跟以前那堆 `this.state` 說掰掰！~~不用花時間寫廢扣，又可以多點廢話惹~~，如果想要再多了解 React Hooks 可以看這篇進階的文章：[Build a powerful chat application using React Hooks](https://blog.flexiple.com/build-a-powerful-chat-application-using-react-hooks/)，打造更完整的聊天室 APP。在 GitHub 有完整的 [APP 專案程式碼](https://github.com/fokayx/react-hooks-socket-client)。

Ref：

-  [Build a Chat App Using React Hooks in 100 Lines of Code](https://css-tricks.com/build-a-chat-app-using-react-hooks-in-100-lines-of-code/)

---

>  👩‍🏫  __課務小幫手：__
>  
> ✨ 想掌握 React 觀念和原理嗎？
>
> 我們有開設 💠 [React 全攻略入門班](https://5xruby.tw/courses/react) 課程唷 ❤️️
>


post-React hooks：不用一百行快速勾出 Chat APP

React hooks：不用一百行快速勾出 Chat APP


還記得一開始自學程式語言時，大家一定或多或少都聽過一個名詞 `物件導向`。然後身為程式新手和非程式相關科系畢業的你也許會開始 Google 它到底是什麼意思，然後你會在 [維基百科](https://zh.wikipedia.org/wiki/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E7%A8%8B%E5%BA%8F%E8%AE%BE%E8%AE%A1) 上查到諸如此類的解釋：

> 物件導向程式設計（英語：Object-oriented programming，縮寫：OOP）是種具有物件概念的程式編程典範，同時也是一種程式開發的抽象方針。它可能包含資料、屬性、程式碼與方法。物件則指的是類別的實體。它將物件作為程式的基本單元，將程式和資料封裝其中，以提高軟體的重用性、靈活性和擴充性，物件裡的程式可以存取及經常修改物件相關連的資料。在物件導向程式編程裡，電腦程式會被設計成彼此相關的物件。

當下看完名詞解釋，如果你和筆者一樣只是個普通人的話應該根據名詞解釋還是無法了解一個抽象的概念，然後可能因為你強盛的好奇心，會繼續在網路上搜尋更多的文章來理解這樣抽象的概念，但有可能你會發現閱讀更多文章後仍然似懂非懂，不要擔心這是屬於正常的現象。

## 找到方向

上述所描寫的正是筆者個人學習上的經歷，看了些許文章後，仍然覺得少了點什麼才能對整體抽象的理論有更進一步的理解。直到閱讀了 `Practical Object-Oriented Design: An Agile Primer Using Ruby` 才發現作者 [Sandi Metz](https://www.sandimetz.com/) 很懂得如何引導新手走入物件導向的大門。例如談論到物件導向時一定會提到的幾個重要原則：`SOLID`（`單一功能`、`開閉原則`、`李氏替換`、`介面隔離`、`依賴反轉`）當你看過這些原則後對於實際開發上該怎麼應用上，根據筆者個人的學習經驗似乎只會產生更多的疑問。但作者似乎知道與其講那些理論，不如透過探討實際的程式碼由淺入深的方式一步一步告訴你如果同樣的程式碼，採用物件導向的方式撰寫程式碼會有什麼優缺點？如果不使用物件導向的方式去寫可能會造成後續維護程式碼上困難？筆者看完那本書後終於對物件導向有了更深一層的概念，它也提供了思考程式碼「為什麼要這樣寫會更好？」的方向，而不僅僅是停在「把程式碼寫出來會動就好⋯⋯」的層面上。

接下來將分享書中部分的概念，去探討如何運用技巧去撰寫出容易維護的程式碼。

## 管理相依性 Manage Dependencies

在物件導向的程式世界中，物件會有所謂 `相依性` 的問題，什麼是相依性呢？我們舉現實生活中的車子來理解這個抽象概念。車子是一種交通工具對吧？在 `Ruby` 中車子將可能會是車子這個類別中的一個實體物件，它的行為是進行移動。那車子為什麼可以移動的呢？車子是需要靠輪子來移動的，我們也可以說車子依賴輪子來進行移動，沒有輪子的車子可能哪也去不了，所以車子對輪子產生了很高的相依性。

在物件導向的世界中，我們對程式類別和物件相互依賴的程度高低稱為 [耦合性](https://zh.wikipedia.org/wiki/%E8%80%A6%E5%90%88%E6%80%A7_(%E8%A8%88%E7%AE%97%E6%A9%9F%E7%A7%91%E5%AD%B8))。耦合性愈高的程式理論上來講會愈難維護，這點可以想像我們先前舉例的車子。假設有一款特殊類別的車子，輪子的構造和一般輪子的構造不一樣，是所謂一體成型的構造。也就是說它的輪子不容易替換，那這輛特殊的車子對於這種特別設計的輪子就會有較高的依賴性。就算真的壞了也沒辦法像其他一般車子一樣快速找到同規格的零件進行替換，當我們這樣設計一台車子的時候就像在設計程式中的類別與方法。我們有沒有遵循物件導向的思維去設計程式，在未來專案的開發與維護時就會產生成本上顯著的差異。

接下來我們將透過程式碼的範例介紹 `Ruby` 程式語言特性所衍生出來降低程式碼之間的耦合度與管理相依性的技巧。

## 移除參數順序的相依性 Remove Argument-Order Dependencies

在 `Ruby` 中，當我們要定義一個方法時通常會像接下來的例子一樣定義它：

```ruby
class Car
  def initialize(color, type, wheels)
    @color = color
    @type = type
    @wheels = wheels
  end

  def info
    puts "這輛車子是#{@color}色的，類型為#{@type}，輪子有#{@wheels}個。"
  end
end

sport_car = Car.new('黃', '跑車', 4)
sport_car.info # => 這輛車子是黃色的，類型為跑車，輪子有4個。
```

在這段範例中，我們定義了 `Car` 這個類別(Class)，然後我們在類別中透過定義初始化方法(Initialize)規定了方法需要傳入三個參數(Parameter)，並且在 `Car.new` 實例化類別時需要`依序`將參數傳入。最後再定義了一個方法 `info` 去顯示這輛車子的資訊(`color`, `type`, `wheels`)。

當我們定義好 `Car` 這個類別並且有一天我們的同事需要使用這個車子類別去做一些事情的時候，你可能會需要寫一份文件就像 [Ruby Doc](https://ruby-doc.org/core-2.6.3/) 一樣解釋這個車子類別在實例化時需要依照順序傳入哪些參數。在這個簡單的例子中你可能會覺得，才三個參數會是有多難記？但是你有一天可能會面臨需要建立一個方法擁有七個參數以上要傳呢？你能確保每一個參數的順序你都記得嗎？萬一傳錯順序了程式可能會產生不可預期的錯誤。這時候我們就可以運用 `Ruby` 的一個特性來解決問題，它就是[雜湊](https://ruby-doc.org/core-2.6.3/Hash.html)(Hash)！

在 `Ruby` 的世界中，雜湊是沒有順序性的，它關注的只有一對成雙 `Key` 和 `Value` 的組合，只要對 `Hash` 提供正確的 `Key` 就能取出那把 `Key` 所對應的值。所以在知名的網頁框架 [Ruby On Rails](https://rails.ruby.tw/getting_started.html) 的方法中可以大量發現使用 `Hash` 的存在。現在就讓我們利用 `Hash` 來把剛剛的範例改寫如下：

```ruby
class Car
  def initialize(info)
    @color = info[:color]
    @type = info[:type]
    @wheels = info[:wheels] || 4
  end

  def info
    puts "這輛車子是#{@color}色的，類型為#{@type}，輪子有#{@wheels}個。"
  end
end

sport_car = Car.new(type: '跑車', color: '橘', wheels: 4)
sport_car.info      # => 這輛車子是橘色的，類型為跑車，輪子有4個。

compact_car = Car.new(color: '黑', type: '房車')
compact_car.info    # => 這輛車子是黑色的，類型為房車，輪子有4個。
```

還記得我們在前一個例子中，實例化方法需要依照順序傳入的三個參數嗎？利用 `Hash` 改寫後，現在我們的 `initialize` 的參數部分只規定了一個 `info`，實際上這個 `info` 代表是一個 `Hash`。我們現在從 `info` 取出三個 `Key` 分別是 `:color`, `:type`, `:wheels` 所對應得值，並將它們存入實體變數 `@color`, `@type`, `@wheels` 當中給 `info` 方法顯示資訊用。

這樣一來當我們將參數改為傳入一個 `Hash` 後，我們已經移除提供參數時會產生參數傳入對順序相依的問題，這樣就可以降低因為順序錯誤導致程式出錯的機率。再者因為當我們對 `Hash` 提供 `Key` 要取出對應的值為 `nil` 時，我們可以再利用一個小技巧讓值為 `nil` 時自動帶入預設的數值。也就是這個範例中的這段程式碼：

```ruby
@wheels = info[:wheels] || 4
```

當我們對 `info` 取出輪子數量為 `nil` 時（也就是使用者沒有傳入 `wheels: 輪子數量`)，這時因為 `info[:wheels] || 4` 前者為 `nil` 時會回傳後者的特性，我們實作了當使用者沒有提供該參數時自動帶入 `4` 的預設值。所以範例中的 `compact_car` 在實例化過程中如下：

```ruby
compact_car = Car.new(color: '黑', type: '房車')
compact_car.info    # => 這輛車子是黑色的，類型為房車，輪子有4個。
```

我並沒有傳入 `wheels` 的值，但在執行 `compact_car.info` 時仍然能自動帶入輪子數量的預設值並印出 `這輛車子是黑色的，類型為房車，輪子有4個。`

## 孤立相依性 Isolate Dependencies

當我們在開發專案時，你終究會遇到需在自身類別中使用其它類別所實例化的物件來做一些事情。但每當你在自身類別中引用其它類別時，實際上也是在對其它類別產生了相依性，並且提高了這個類別對其他程式碼的耦合度，這樣的情況並不是我們所樂見的。當我們必須對其它類別產生相依性且無可避免的時候呢？我們該怎麼處理類似的情況呢？這時候我們可以選擇孤立其它類別在自身類別中。接下來我們將使用實例來探討該如何處理類似的情況。

繼續我們先前的車子範例，如果我們要繼續打造這台車子，但是輪子需要乘載更多的資訊量呢？是時候考慮將輪子獨立出來自成一類來處理相關的資訊了。我們先將程式範例改寫為如下：

```ruby
class Car
  attr_reader :name, :color, :wheels, :type

  def initialize(info = {})
    @name = info[:name] || '未命名'
    @color  = info[:color]  || '藍'
    @type   = info[:type]   || '房車'
    @wheels = info[:wheels] || Wheels.new
  end

  def info
    puts "#{name}，這輛車子是#{@color}色的，類型為#{@type}，輪子有#{@wheels.quantity}個。"
  end
end

class Wheels
  attr_reader :color, :quantity, :type

  def initialize(info = {})
    @color = info[:color] || '黑'
    @quantity = info[:quantity] || 4
    @type = info[:type] || '道路'
  end

  def info
    puts "這台車的輪胎規格為#{@type}胎，顏色為#{@color}色，共有#{@quantity}個輪胎。"
  end
end

compact_car = Car.new(name: '發財車', type: '貨車')
compact_car.info          # => 發財車，這輛車子是藍色的，類型為貨車，輪子有4個。
compact_car.wheels.info   # => 這台車的輪胎規格為道路胎，顏色為黑色，共有4個輪胎。

super_car = Car.new(name: '佛拉利', color: '紅', type: '跑車',
wheels: Wheels.new(color: '銀', type: '賽道'))
super_car.info            # => 佛拉利，這輛車子是紅色的，類型為跑車，輪子有4個。
super_car.wheels.info     # => 這台車的輪胎規格為賽道胎，顏色為銀色，共有4個輪胎。
```

當我們決定把 `Wheels` 獨立拆出來成為一個類別時，我們的 `Car` 類別很自然的會期待在初始化物件時接收一個 `Wheels` 類別的實體並存入一個實體變數當中，以待需要時取得 `Wheels` 的實體並使用它。我們所講述的正是這行程式碼：

```ruby
@wheels = info[:wheels] || Wheels.new
```
還記得先前所講的嗎？當我們在自身類別中引用外部類別時，我們就對它產生了依賴性與提高了耦合度。我們現在對 `Wheels` 這個類別產生了依賴。現在來說你可能會想一切都在我的掌控之中因為 `Wheels` 這個類別是我所寫的，我很清楚它會如何運作。但是稍等一下⋯⋯假設今天的專案是多人協作的呢？`Wheels`這個類別是同事所寫的呢？你能確保在接下來的專案開時間下，`Wheels` 對這個類別呼叫 `Wheels.new` 所需要傳入的參數以及他所提供的 [API](https://zh.wikipedia.org/wiki/%E5%BA%94%E7%94%A8%E7%A8%8B%E5%BA%8F%E6%8E%A5%E5%8F%A3) `info` 不會有所變動嗎？它仍然是可靠的嗎？（謎之聲：那個誰誰誰？你幹嘛沒事去改動傳入的參數啦！？這樣害我程式整組壞光光惹 Q_Q，說好的可靠性呢？）

是的，我們的車子確實需要輪子來進行移動，這點無法分割的一部分我承認，但是總會有更好的方式來管理這種情況。那就是`孤立相依性`！既然我們沒辦法把它切割乾淨，那反其道而行，要依賴就要把關係處理好（更好維護的方式）所以因為前人的智慧，我們可以將這段程式碼修改為下列範例：

```ruby
class Car
  attr_reader :name, :color, :wheels, :type

  def initialize(info = {})
    @name = info[:name] || '未命名'
    @color  = info[:color]  || '藍'
    @type   = info[:type]   || '房車'
    external_wheels(wheels)
  end

  def external_wheels(external_wheels)
    @wheels = external_wheels || Wheels.new
  end

  def info
    puts "#{name}，這輛車子是#{@color}色的，類型為#{@type}，輪子有#{@wheels.quantity}個。"
  end
end

class Wheels
  attr_reader :color, :quantity, :type

  def initialize(info = {})
    @color = info[:color] || '黑'
    @quantity = info[:quantity] || 4
    @type = info[:type] || '道路'
  end

  def info
    puts "這台車的輪胎規格為#{@type}胎，顏色為#{@color}色，共有#{@quantity}個輪胎。"
  end
end

compact_car = Car.new(name: '發財車', type: '貨車')
compact_car.info            # => 發財車，這輛車子是藍色的，類型為貨車，輪子有4個。
compact_car.wheels.info     # => 這台車的輪胎規格為道路胎，顏色為黑色，共有4個輪胎。

super_car = Car.new(name: '佛拉利', color: '紅', type: '跑車',
                    wheels: Wheels.new(color: '銀', type: '賽道'))
super_car.info              # => 佛拉利，這輛車子是紅色的，類型為跑車，輪子有4個。
super_car.wheels.info       # => 這台車的輪胎規格為賽道胎，顏色為銀色，共有4個輪胎。
```

有發現差異了嗎？我們把在 `Car` 類別中的 `initialize` 方法中，我們把先前的：

```ruby
@wheels = info[:wheels] || Wheels.new
```

改寫為：

```ruby
external_wheels(wheels)
```

然後在 `Car` 類別中新增一個方法：

```ruby
def external_wheels(external_wheels)
  @wheels = external_wheels || Wheels.new
end
```

為什麼要這樣寫呢？因為如剛剛我說，我們目的是要把引用外部類別 `Wheels` 抽離出來成一個獨立的方法。這樣對我們來說有什麼好處嗎？根據古人的智慧把外部類別隔離成一個方法有以下好處：

1. 當我們引用外部類別，獨立出來可以很明確的知道它是來自外部，是較為不可靠的。
2. 當這個外部類別發生變動導致程式錯誤時，你可以很快找到是在某個隔離出來的方法之中，而不是從一堆程式碼中大海撈針。

## 小結 || 小傑（奇犽？)

在有限的篇幅當中，我們嘗試去探討一個大方向的主題，物件導向在 `Ruby` 的世界中可能會是以怎樣的形式實作。這是一個可以用數千字到上萬字可能都還講不完的主題。但是筆者為什麼要選這樣的主題來分享呢？因為身為非本科生亂入變成每天和 `Ruby` & `Rails` 打交道謀生的工作者，有一天因為工作上的需求去閱讀人生第一本原文書並把它看完了。從閱讀的過程中發現物件導向的觀念在同事幾年前所寫的龐大專案中無所不在。為什麼有經驗的 Coder 會用這種方式去寫程式呢？為什麼在 Code Review 的過程中會引導我嘗試去用物件導向的方式產出程式碼呢？這一切的一切都是從閱讀先前所推薦的物件導向書中慢慢理解。如果你和筆者一樣剛進入程式的世界還沒有很久，也許是時候擠出一點點的時間去閱讀一本關於物件導向的書籍。你也許會發現程式設計的美好世界（充滿 Bug 的世界？）最後請容許我引用一句講者在 [RubyConf Taiwan 2019](https://2019.rubyconf.tw/) 閉幕演講的話做為結尾。

> Energy Saving => Environent Friendly

多利用物件導向，少複製貼上程式碼是可以節約能源拯救地球的！

> Let's have this in mind and Build a Better World.

讓我們謹記心，打造更棒的世界！

[演講投影片](https://speakerdeck.com/c9s/virtual-machines)

本文同步發表於 [硬底居米 Indie Jimmy](https://blog.raiden.me/)

---

>  👩‍🏫  __課務小幫手：__
>  
> ✨ 想掌握 Ruby on Rails 觀念和原理嗎？
>
> 我們有開設 🏓 [Ruby on Rails 實戰課程](https://5xruby.tw/courses/ruby-on-rails) 課程唷 ❤️️
>


五倍紅寶石・專業程式教育機構

ASTRO Camp

線上課程

實體課程

技術文章

五倍消息

技術文章

勇者，成為時間的支配者吧！

PM 也能乘著 Git 時空旅行

咦？這個問題是從什麼時候就有的？

新手不小心會踩到的坑：我真的複製出物件了嗎？

以 Rspec 為例，創造一個自己的 DSL 工具吧！

用 WebRTC 半分散網路弄一個聊天室

React hooks：不用一百行快速勾出 Chat APP

想找到脫離新手村的方向？讓 Ruby 中的物件導向基礎為你引路！

訂閱文章

電話 | (02) 2331-5247

信箱 | [email protected]

地址 | 10046 台北市中正區衡陽路 7 號 5 樓

專業課程

ASTRO Camp

線上課程

實體課程

關於我們

關於五倍紅寶石

聯絡我們

媒體報導

加入我們

部落格

技術文章

五倍消息

幫助與政策

常見問題

隱私權政策

服務條款