<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Hugh&#39;s Programming life on Medium]]></title>
        <description><![CDATA[Stories by Hugh&#39;s Programming life on Medium]]></description>
        <link>https://medium.com/@hugh-program-learning-diary-js?source=rss-cd53d8c994f6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*mkXBx7jTXjpaitHOKgYiFA.jpeg</url>
            <title>Stories by Hugh&amp;#39;s Programming life on Medium</title>
            <link>https://medium.com/@hugh-program-learning-diary-js?source=rss-cd53d8c994f6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 15:24:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hugh-program-learning-diary-js/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[多年來的財務痛悟：你的時間，比你想得值錢太多了]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/%E5%A4%9A%E5%B9%B4%E4%BE%86%E7%9A%84%E8%B2%A1%E5%8B%99%E7%97%9B%E6%82%9F-%E4%BD%A0%E7%9A%84%E6%99%82%E9%96%93-%E6%AF%94%E4%BD%A0%E6%83%B3%E5%BE%97%E5%80%BC%E9%8C%A2%E5%A4%AA%E5%A4%9A%E4%BA%86-3b778f11ab62?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b778f11ab62</guid>
            <category><![CDATA[financial-independence]]></category>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[personal-finance]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[time-management]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 10:12:14 GMT</pubDate>
            <atom:updated>2026-07-28T10:12:14.601Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>財務微思維：為什麼我們該把心思放在「創造收入」而不是「極致省錢」？</blockquote><p>最近在重新檢視與整理個人的財務狀況時，我獲得了一個很深刻的體悟：<strong>一個人能主動創造的「收入」，才是財務增長真正的核心引擎。</strong></p><p>早年，我也曾迷信許多投資大師的觀念，認為只要靠投資就能翻身。為此，我花了大量時間研究投資。但後來我發現，當本業薪水不夠高時，投資的效果其實非常受限。</p><p>舉個簡單的例子：假設一個人月收入是三萬元，即使他極度節儉，拿出 20% 來投資，每個月也只有六千元。但如果另一個人月收入是十萬元，他只需拿出 10%，每個月就有一萬元的投資本金，在財務操作上自然「游刃有餘」。更重要的是，當一個人的本業收入（償付能力）較強時，面對市場波動或投資虧損，他的承受能力與底氣也會大得多。</p><h3><strong>生活水準的殘酷真相：為什麼收入必須是開銷的 5 到 10 倍？</strong></h3><p>近期我閱讀到一份關於生活水準的資料，裡面提到一個觀點：一個人或組織的收入，必須是其生活水準的 5 到 10 倍。</p><p>起初我覺得這個數字高得驚人。如果一個月基本開銷是一萬元，那收入不就要達到五萬甚至十萬？但仔細思考背後的邏輯，這其實是無比真實的。因為生活不僅僅是「基本開銷」，我們還必須扣除經常性費用、稅賦、以及各種突發的額外支出（如醫療費用、罰單、急用採買等）。如果是創業，為了負擔營運成本，這個倍數甚至需要放得更大。追求良好的生活水準，必須要有對應的收入規模來支撐底部的風險。</p><h3><strong>省錢的盲點：過度關注節流，反而限制了格局</strong></h3><p>認知到這點後，我回顧了自己過去的文章與思維。以前我總認為，有了收入之後，下一個重點就是「省錢」，省下的錢才能讓我更有能力去投資。這幾年下來，我發現自己常常為了省下 5% 的費用，花費好幾個小時去研究信用卡回饋或優惠政策；而一旦政策更改，一切又得重來。</p><p>我逐漸意識到，當一個人把所有的專注力都放在「節省」上時，他的格局會越變越小。第一，省下的錢終究有極限；第二，那些耗費在比價上的時間全都浪費了，因為這些時間無法在未來產生更多價值。</p><h3><strong>將心思轉向「創造」，放大時間的價值</strong></h3><p>相反地，當一個人把心思放在「創造收入」上時，他會擁有更多的可能性。</p><p>例如，一個上班族可以把英文學好，跳槽到英語系環境工作，同樣的技能，薪水可能直接倍增。以我身為軟體工程師為例，我也可以利用業餘時間開發一個網路應用服務。這個服務初期可能每個月只帶來五千或一萬元的收入，但我寫完之後，這個應用就能持續在網路上運作、帶來收益，我不需要一直重新花時間去寫它。這就是把心思放在「可以創造更多價值」的地方。</p><p>以前我總是不懂，為什麼老闆或前輩們捨得花將近 1.5 倍的價格訂外送？現在我完全明白了。因為他們深知自己的時間很值錢，這些時間應該拿去做更高價值、更有創造力的事情，而不是為了省那 50 到 100 元的外送費，親自花一小時走路去買飯。</p><h3><strong>結論：擴大你的遊戲規模</strong></h3><p>我現在堅信，我們應該專注於提升自身的價值與本業收入，不該把過多的心思耗費在枝微末節的節流上。那些事物只會讓人困惑，搞錯財務的真正重點。</p><p>基於這個理念，我最近也做出了決定：我準備前往新加坡等海外地區工作，尋求更高層次的挑戰與收入。我希望能大幅度提高自己的能力與財務基礎，這樣未來才有餘力去創業，去玩更大、更有趣的遊戲。</p><p>將這些近期的財務體悟寫下來，希望能為正在閱讀這篇文章的你帶來一些不同的觀點與啟發。我們共勉之！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b778f11ab62" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[完美不是目標，能運作的系統才是真正的力量]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/%E5%AE%8C%E7%BE%8E%E4%B8%8D%E6%98%AF%E7%9B%AE%E6%A8%99-%E8%83%BD%E9%81%8B%E4%BD%9C%E7%9A%84%E7%B3%BB%E7%B5%B1%E6%89%8D%E6%98%AF%E7%9C%9F%E6%AD%A3%E7%9A%84%E5%8A%9B%E9%87%8F-f19728738ed5?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/f19728738ed5</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[entrepreneurship]]></category>
            <category><![CDATA[personal-growth]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 00:54:58 GMT</pubDate>
            <atom:updated>2026-07-20T00:54:58.055Z</atom:updated>
            <content:encoded><![CDATA[<p>最近重讀山達基的護衛技術規章，其中提到 <strong>workable system</strong> 的重要性，也提到一套系統不需要追求完美，只要能夠實際運行，就應該持續應用。這讓我開始重新思考自己過去在軟體開發上的許多習慣。</p><p>身為一名前端工程師，我過去一直希望自己的程式碼能夠寫得完美、架構清楚且優雅，因此常常花很多時間反覆調整設計與實作，希望做到自己心目中的最佳狀態。然而，在經歷了幾間公司的專案，也開始思考創業、建立自己的產品之後，我逐漸發現，商業環境其實變化得非常快。許多曾經投入大量心力打造的程式，最後可能因為需求改變、產品方向調整，甚至技術棧更換，而必須重寫。回頭來看，當初追求的那些「完美」，未必真正創造了最大的價值。</p><p>再加上現在 AI 的快速發展，程式碼已經不再需要一行一行親自撰寫，而是能夠快速產生大量程式內容。真正重要的能力，逐漸從「寫出最漂亮的程式碼」，轉變為「建立一套能快速解決問題、持續創造價值的系統」。</p><p>因此，我開始理解，自己真正需要追求的，不是一開始就打造出完美的作品，而是先建立一套可以運行的系統，讓使用者盡快開始使用，並透過實際回饋持續改善。真正的完美，不是在開始之前就完成，而是在不斷運作與修正的過程中逐漸形成。</p><p>這個體悟也讓我放下了許多過去對於完美的執著。我開始相信，與其花大量時間追求一個理想中的作品，不如先完成一個真正能解決問題的成果。只要它是可行的、能夠持續運作並創造價值，它就是一套值得持續應用的 workable system。之後，再透過不斷改善，讓它變得越來越好。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f19728738ed5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI 時代，我重新找回了自己想成為的人]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/ai-%E6%99%82%E4%BB%A3-%E6%88%91%E9%87%8D%E6%96%B0%E6%89%BE%E5%9B%9E%E4%BA%86%E8%87%AA%E5%B7%B1%E6%83%B3%E6%88%90%E7%82%BA%E7%9A%84%E4%BA%BA-0655c55dbbbb?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/0655c55dbbbb</guid>
            <category><![CDATA[entrepreneurship]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Wed, 15 Jul 2026 05:12:50 GMT</pubDate>
            <atom:updated>2026-07-15T05:12:50.841Z</atom:updated>
            <content:encoded><![CDATA[<p>最近準備回歸職場，但我開始重新思考一個問題：</p><p><strong>我真正想要的是什麼？</strong></p><p>過去幾年，因為對自我成長的追求，我暫時離開職場，開始了一段不同於傳統職涯的旅程。</p><p>這段時間，我學到了很多，也跌倒了不少。</p><p>我接觸新的知識、嘗試不同方向，也開始思考：如果人生不只是追求一份穩定工作，那我真正想創造的是什麼？</p><p>前陣子，隨著 AI 快速發展，我開始重新看待工程師這個職業。</p><p>一開始，我其實也感受到壓力。</p><p>如果工程師只是重複把需求轉換成程式碼，那麼 AI 的確可能改變這個角色。</p><p>但是後來我發現，我真正擔心的並不是 AI 取代工程師。</p><p>我害怕的是，自己一直停留在重複性的工作模式，而沒有把能力用在更大的創造上。</p><p>因為我一直有一個夢想：</p><p><strong>成為一個創造產品、建立事業的人。</strong></p><p>過去，我以為這條路需要經歷：</p><p>工程師 → 資深工程師 → 技術主管 → 創辦人</p><p>可能需要十年，甚至更久。</p><p>但是 AI 的出現，讓這條路開始改變。</p><p>現在，一個人可以利用 AI 協助自己快速完成原本需要大量時間的工作。</p><p>從想法驗證、原型製作，到產品開發，都比過去容易許多。</p><p>這不代表創業變簡單了。</p><p>市場需求、商業模式、使用者理解，依然需要人自己探索。</p><p>但 AI 降低了一個重要門檻：</p><p><strong>把想法變成實際成果的成本。</strong></p><p>我早在 2023 年就開始使用 ChatGPT 協助程式開發。</p><p>一開始，它只是我的開發工具。</p><p>但隨著 AI 能力提升，我發現它不只是幫助我寫程式，也能協助我整理想法、分析問題，甚至從不同角度檢視自己的選擇。</p><p>最近，我透過長期與 AI 的對話，重新整理了自己的方向。</p><p>我發現，我一直渴望的不是單純成為一名工程師。</p><p>我真正想成為的是一個能創造價值的人。</p><p>我希望利用技術與工具，用更少的時間創造更大的成果，讓自己能投入更有意義的事情。</p><p>這也讓我重新思考一件事情：</p><p>很多人擔心 AI 會控制人的人生。</p><p>但我認為，工具本身沒有方向。</p><p>真正重要的是使用工具的人是否仍然保持自己的判斷能力。</p><p>AI 可以提供建議，但最後的決定仍然需要自己思考、驗證與負責。</p><p>對我而言，AI 不是取代我的東西。</p><p>它更像是一個放大器。</p><p>它放大我的學習能力，也放大我的創造能力。</p><p>接下來，我會繼續探索 AI、軟體開發與創業的結合，希望透過技術創造更多價值，也讓自己成為一個能對世界產生更多貢獻的人。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0655c55dbbbb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Zod 的魔法：為什麼它能「定義一次，享受兩次」？]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/zod-%E7%9A%84%E9%AD%94%E6%B3%95-%E7%82%BA%E4%BB%80%E9%BA%BC%E5%AE%83%E8%83%BD-%E5%AE%9A%E7%BE%A9%E4%B8%80%E6%AC%A1-%E4%BA%AB%E5%8F%97%E5%85%A9%E6%AC%A1-fcf628c390f5?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/fcf628c390f5</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[zod]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Mon, 03 Nov 2025 11:32:05 GMT</pubDate>
            <atom:updated>2025-11-15T15:39:29.951Z</atom:updated>
            <content:encoded><![CDATA[<h3>前言</h3><p>最近回歸職場後，我注意到一個叫做 zod 的工具。</p><p>它非常神奇。它不只能用來<strong>驗證</strong>資料，它的規則竟然還能<strong>反過來變成 TypeScript 的型別</strong>，解決了很多過去處理型別時的麻煩。</p><p>我使用了一陣子後，就對它背後的原理非常好奇：「它究竟是怎麼辦到的？」</p><p>在深入探究後，我終於有了初步的理解，所以決定寫下這篇文章，分享我是如何搞懂這一切的。</p><p>在 TypeScript 的世界裡，我們一直在追求「類型安全」。但在 API 開發中，我們長期以來都活在一種「分裂」的狀態：</p><ol><li><strong>編譯期 (Compile Time)：</strong> 我們手動編寫 interface 或 type，讓 VS Code 知道我們的資料長什麼樣子。</li><li><strong>執行期 (Runtime)：</strong> 我們用 Joi 或其他驗證庫，再寫<em>一套</em>驗證規則，去檢查從前端或 .env 傳來的「不被信任的」資料。</li></ol><p>這意味著我們必須維護<strong>兩套幾乎一樣的邏輯</strong>。只要一邊改了，另一邊忘了改，Bug 就會出現。</p><p>Zod，一個「TypeScript-first」的驗證庫，徹底解決了這個問題。它最神奇的地方，就是：<strong>「一套規則，兩種享受」</strong>。</p><h3>Zod 的雙重職責</h3><p>當你寫下這段 Zod Schema：</p><pre>import { z } from &#39;zod&#39;;<br><br>// 1. Zod Schema (唯一的「事實來源」)<br>const UserSchema = z.object({<br>  username: z.string().min(3),<br>  email: z.string().email(),<br>});</pre><p>UserSchema 這個常數，其實同時扮演著兩種角色：</p><h4>角色一：執行期的「保全」 (Validator)</h4><p>這是在程式<strong>執行時</strong>的角色。UserSchema 是一個真實存在的 JavaScript 物件，它有一個 .parse() 方法。你可以用它來「驗證」真實的資料。</p><pre>// 執行期：用 .parse() 驗證<br>try {<br>  const user = UserSchema.parse({ username: &#39;al&#39; }); // 👈 這會拋出錯誤<br>} catch (err) {<br>  console.error(err); // ZodError: &quot;username&quot; must be at least 3 chars<br>}</pre><h4>角色二：編譯期的「藍圖」 (Type Definition)</h4><p>這是在程式<strong>編譯時</strong>（也就是在 VS Code 裡）的角色。Zod 巧妙地利用了 TypeScript 的類型系統，讓 UserSchema 這個變數本身<strong>「攜帶」</strong>了它所代表的 TypeScript 類型資訊。</p><p>而我們需要一個「鑰匙」來解鎖這個資訊。</p><h3>解鎖魔法：z.infer 是如何運作的？</h3><p>z.infer 就是那把「鑰匙」。它是一個<strong>只存在於 TypeScript 類型世界</strong>的工具。</p><pre>// 編譯期：用 z.infer 抓取類型<br>type User = z.infer&lt;typeof UserSchema&gt;;<br><br>// User 類型被自動推導為：<br>// {<br>//   username: string;<br>//   email: string;<br>// }</pre><p>這個「自動推導」的背後，有兩個關鍵的 TypeScript 技術：</p><h4>1. _output：Zod 藏好的「類型標籤」</h4><p>Zod 的作者非常聰明。他們在 Zod 函式庫的原始碼中，為<strong>每一個</strong>驗證器（z.string, z.number...）的<strong>類型定義</strong>，都加上了一個隱藏的屬性，叫做 _output。</p><ul><li>z.string() 的類型定義中，藏著 _output: string。</li><li>z.number() 的類型定義中, 藏著 _output: number。</li></ul><p>而 z.object() 這個組合器，會自動<strong>「組合」</strong>你傳入的所有 _output 標籤，產生一個新的 _output 標籤。</p><p>所以，當你定義 UserSchema 時，TypeScript 會自動幫你組合出，UserSchema 這個變數的類型上，攜帶了一個標籤：</p><pre>_output: { username: string, email: string }</pre><h4>2. extends 和 infer：拆禮物的工具</h4><p>z.infer&lt;T&gt; 的內部原理，就是如同的「拆禮物」工具：</p><pre>// Zod 函式庫中的（簡化）定義：<br>type z.infer&lt;T&gt; = <br>  T extends { _output: infer O } // 👈 提問 + 填空<br>  ? O                            // 👈 回傳答案<br>  : never;</pre><p>這段程式碼的白話文就是：</p><ul><li>T extends … (提問)：</li><li>「嘿 TypeScript，傳進來的 T (也就是 UserSchema 的類型)，它是不是一個『帶有 _output 標籤』的禮物盒？」</li><li>{ _output: infer O } (填空)：</li><li>「如果是！那請你幫我『<strong>推斷 (infer)』出 _output 標籤裡面</strong>的類型是什麼，並把這個類型放進 O 這個空格裡。」</li><li>? O : never (回傳)：</li><li>「提問成功，O 現在等於 { username: string, email: string }。好，我就把 O 回傳出去。」</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pAX13s3p-juTFvS9Thh55A.png" /></figure><h3>結論</h3><p>Zod 的魔法並非憑空而來，它建立在對 TypeScript 類型系統的深刻理解之上。</p><p>它透過在「Schema 物件」上<strong>同時附加</strong>「執行期驗證邏輯」和「編譯期類型標籤 (_output)」 ，並提供 z.infer 這個「類型讀取器」，完美地實現了<strong>「單一事實來源 (Single Source of Truth)」</strong>。</p><p>你只需要維護 Zod Schema，就能同時確保你的「執行期驗證」和「編譯期類型」100% 同步。這就是 Zod 如此強大且優雅的真正原因。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fcf628c390f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[從前端視角理解 SOLID：I — 介面隔離原則，別再硬塞用不到的 Props 了！]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-i-%E4%BB%8B%E9%9D%A2%E9%9A%94%E9%9B%A2%E5%8E%9F%E5%89%87-%E5%88%A5%E5%86%8D%E7%A1%AC%E5%A1%9E%E7%94%A8%E4%B8%8D%E5%88%B0%E7%9A%84-props-%E4%BA%86-7f4deb6199e0?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f4deb6199e0</guid>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[component-design]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Fri, 01 Aug 2025 02:58:07 GMT</pubDate>
            <atom:updated>2025-08-01T02:58:07.514Z</atom:updated>
            <content:encoded><![CDATA[<h3>從前端視角理解 SOLID：I — 介面隔離原則，別再硬塞用不到的 Props 了！</h3><blockquote><em>本文為 </em><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b"><strong><em>從前端視角理解 SOLID</em></strong></a><em> 系列的第五篇。</em></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b"><strong>第一篇：導論，為何好懂的 React 程式碼都有它的影子？</strong></a></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-s-%E5%96%AE%E4%B8%80%E8%81%B7%E8%B2%AC%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84%E5%87%BD%E5%BC%8F%E7%AE%A1%E5%A4%AA%E5%A4%9A%E4%BA%86%E5%97%8E-05a71a450216"><strong>第二篇：S — 單一職責原則</strong></a></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-o-%E9%96%8B%E6%94%BE%E5%B0%81%E9%96%89%E5%8E%9F%E5%89%87-%E4%B8%8D%E5%8B%95%E8%88%8A%E7%A2%BC%E6%96%B0%E5%A2%9E%E5%8A%9F%E8%83%BD%E7%9A%84%E9%AD%94%E6%B3%95-c5e14f9400f0"><strong>第三篇：O — 開放封閉原則</strong></a></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-l-%E9%87%8C%E6%B0%8F%E6%9B%BF%E6%8F%9B%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84-%E5%BB%B6%E4%BC%B8%E6%AC%BE-%E5%88%A5%E8%83%8C%E5%8F%9B%E4%BA%86-%E5%9F%BA%E6%9C%AC%E6%AC%BE-b983acaa3bc7"><strong>第四篇：L — 里氏替換原則</strong></a></blockquote><blockquote><strong>第五篇：I — 介面隔離原則 (本文)</strong></blockquote><blockquote><strong>第六篇：D — 依賴反轉原則 <em>(敬請期待)</em></strong></blockquote><p>到目前為止，我們已經探討了如何拆分職責 (SRP)、如何擴展功能 (OCP)、以及如何確保擴展的可靠性 (LSP)。今天，我們要來解決一個在元件化開發中非常常見的問題：<strong>一個元件到底該知道多少事？</strong> 這就是 <strong>I — 介面隔離原則 (Interface Segregation Principle, ISP)</strong> 要探討的核心。</p><h3>釐清詞彙：到底什麼是「介面隔離」？</h3><p>介面隔離原則的官方定義是：</p><blockquote><strong><em>客戶端不應該被迫依賴於它們不使用的介面 (Clients should not be forced to depend upon interfaces that they do not use)。</em></strong></blockquote><p>這句話在 TypeScript 的世界裡，簡直是為我們量身打造的。讓我們把它翻譯成 React 開發者的日常語言：</p><p><strong>一個元件不應該被迫接收它根本用不到的 Props。</strong></p><p>ISP 的精神在於「精準」與「最小化」。與其設計一個包山包海、什麼都有的「肥胖」Props 型別，不如將它拆分成數個更小、更專一的型別，讓每個元件只索取它完成任務所<strong>必要的最少資訊</strong>。</p><h3>具象化理解：分時段的餐廳菜單 vs. 超厚電話簿菜單</h3><p>想像一下你去一家高級餐廳。</p><ul><li><strong>場景一（遵循 ISP）</strong>：你中午抵達，服務生遞給你一本精緻的「午間套餐」菜單。上面只有午餐時段供應的餐點，清晰明瞭，你很快就做出了決定。</li><li><strong>場景二（違反 ISP）</strong>：你中午抵達，服務生卻遞給你一本像電話簿一樣厚的「本店全品項」菜單。裡面包含了早餐、午餐、下午茶、晚餐、宵夜和酒水單。你只想點個午餐，卻得費力地翻過數十頁你根本點不到的品項，體驗極差。</li></ul><p>這個「超厚電話簿菜單」，就是一個違反 ISP 的「肥胖介面」。它強迫客戶（你）去依賴一堆你根本用不到的資訊。我們的目標，就是成為那位貼心的服務生，只提供客戶真正需要的菜單。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ca3lkjeaVYE4dV3lqqTg2w.png" /></figure><h3>前端實戰：告別「上帝 Props」</h3><p>在 TypeScript + React 的專案中，最容易違反 ISP 的地方，就是定義一個巨大、全能的 IUser 介面，然後在所有需要使用者資訊的元件中都傳遞整個 user 物件。</p><h4><strong>反面教材：</strong></h4><p><strong>一個臃腫的 </strong><strong>IUser 介面</strong></p><pre>// types/user.types.ts (一個肥胖介面)<br>interface IUser {<br>  id: string;<br>  name: string;<br>  avatarUrl: string;<br>  email: string;<br>  lastLogin: Date;<br>  permissions: string[];<br>  isActive: boolean;<br>  // ... 可能還有 20 個其他欄位<br>}<br><br>// 一個只需要顯示頭像和名稱的元件<br>const UserAvatar = ({ user }: { user: IUser }) =&gt; {<br>  return (<br>    &lt;div&gt;<br>      &lt;img src={user.avatarUrl} alt={user.name} /&gt;<br>      &lt;span&gt;{user.name}&lt;/span&gt;<br>    &lt;/div&gt;<br>  );<br>};<br>// 另一個只需要根據權限顯示內容的元件<br>const AdminPanel = ({ user }: { user: IUser }) =&gt; {<br>  if (user.permissions.includes(&#39;admin&#39;)) {<br>    return &lt;div&gt;Admin Controls&lt;/div&gt;;<br>  }<br>  return null;<br>};</pre><p><strong>問題在哪裡？</strong></p><ol><li><strong>不必要的耦合</strong>：UserAvatar 元件明明只需要 name 和 avatarUrl，卻被迫知道了 email, permissions 等一大堆不相關的資訊。未來如果 permissions 的型別改變了，即使 UserAvatar 根本沒用到它，也可能會引發型別錯誤，增加了不必要的維護成本。</li><li><strong>可讀性差</strong>：當其他開發者看到 UserAvatar 接收了整個 IUser 物件，他無法立刻明白這個元件到底依賴了哪些具體資料，必須深入閱讀程式碼才能釐清。</li><li><strong>難以複用與測試</strong>：在為 UserAvatar 寫測試時，你必須模擬一個完整的 IUser 物件，而不是只提供它需要的兩個屬性即可。</li></ol><h4><strong>遵循 ISP 的重構：</strong></h4><p><strong>拆分成精簡的 Props 型別</strong></p><p>現在，我們用 ISP 的精神來重構它，為每個元件建立專屬的「小菜單」。</p><pre>// types/user.types.ts (拆分後的介面)<br>// 介面一：只包含頭像所需資訊<br>export interface IAvatarInfo {<br>  name: string;<br>  avatarUrl: string;<br>}<br><br>// 介面二：只包含權限所需資訊<br>export interface IPermissionInfo {<br>  permissions: string[];<br>}<br><br>// 完整的 User 型別可以由這些小介面組合而成<br>export interface IUser extends IAvatarInfo, IPermissionInfo {<br>  id: string;<br>  email: string;<br>  // ...<br>}<br><br>// --- 元件實作 ---<br>// UserAvatar 現在只依賴它需要的最小資訊集<br>const UserAvatar = ({ user }: { user: IAvatarInfo }) =&gt; {<br>  return (<br>    &lt;div&gt;<br>      &lt;img src={user.avatarUrl} alt={user.name} /&gt;<br>      &lt;span&gt;{user.name}&lt;/span&gt;<br>    &lt;/div&gt;<br>  );<br>};<br><br>// AdminPanel 也一樣<br>const AdminPanel = ({ user }: { user: IPermissionInfo }) =&gt; {<br>  if (user.permissions.includes(&#39;admin&#39;)) {<br>    return &lt;div&gt;Admin Controls&lt;/div&gt;;<br>  }<br>  return null;<br>};</pre><p>重構之後，好處非常明顯：</p><ol><li><strong>低耦合</strong>：UserAvatar 的世界裡，只有 name 和 avatarUrl。IUser 其他屬性的任何變更，都與它無關。</li><li><strong>高可讀性</strong>：Props 的型別定義，就像一份清晰的「元件使用說明書」，一眼就能看出元件的資料依賴。</li><li><strong>易於測試</strong>：測試 UserAvatar 時，只需要傳入 { name: &#39;Test&#39;, avatarUrl: &#39;...&#39; } 即可，非常簡單。</li></ol><h3>背景資料</h3><p>介面隔離原則 (ISP) 同樣由羅伯特·C·馬丁 (Uncle Bob) 提出。據說，這個原則的靈感，來自於他在為全錄 (Xerox) 公司提供諮詢時，遇到的一個巨大的印表機系統。系統中所有的客戶端都依賴一個龐大的 Job 類別，導致任何微小的修改都會引發連鎖反應，最終他透過將這個肥胖的介面拆分成數個更小的介面，成功地解耦了系統。</p><h3>結論</h3><p>介面隔離原則在 TypeScript 的世界中，是我們對抗「不必要複雜性」的利器。它提醒我們，在定義元件的 Props 時，應該像一位精準的外科醫生，而不是一個粗暴的屠夫。</p><blockquote><strong>只索取你需要的，不要多拿一分一毫。</strong></blockquote><p>養成這個習慣，能讓你的元件變得更加獨立、專一且易於理解。當你的專案是由一個個這樣「輕量級」的元件組成時，整個系統的耦合度將會大幅降低，可維護性和開發者體驗也將得到質的飛躍。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f4deb6199e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[從前端視角理解 SOLID：L — 里氏替換原則，你的「延伸款」別背叛了「基本款」]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-l-%E9%87%8C%E6%B0%8F%E6%9B%BF%E6%8F%9B%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84-%E5%BB%B6%E4%BC%B8%E6%AC%BE-%E5%88%A5%E8%83%8C%E5%8F%9B%E4%BA%86-%E5%9F%BA%E6%9C%AC%E6%AC%BE-b983acaa3bc7?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/b983acaa3bc7</guid>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Wed, 30 Jul 2025 09:54:11 GMT</pubDate>
            <atom:updated>2025-08-01T03:17:54.768Z</atom:updated>
            <content:encoded><![CDATA[<h3>從前端視角理解 SOLID：L — 里氏替換原則，你的「延伸款」別背叛了「基本款」</h3><blockquote><em>本文為 </em><a href="https://hugh-program-learning-diary-js.medium.com/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b"><strong><em>從前端視角理解 SOLID</em></strong></a><em> 系列的第四篇。</em></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b"><strong>第一篇：導論，為何好懂的 React 程式碼都有它的影子？</strong></a></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-s-%E5%96%AE%E4%B8%80%E8%81%B7%E8%B2%AC%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84%E5%87%BD%E5%BC%8F%E7%AE%A1%E5%A4%AA%E5%A4%9A%E4%BA%86%E5%97%8E-05a71a450216"><strong>第二篇：S — 單一職責原則</strong></a></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-o-%E9%96%8B%E6%94%BE%E5%B0%81%E9%96%89%E5%8E%9F%E5%89%87-%E4%B8%8D%E5%8B%95%E8%88%8A%E7%A2%BC%E6%96%B0%E5%A2%9E%E5%8A%9F%E8%83%BD%E7%9A%84%E9%AD%94%E6%B3%95-c5e14f9400f0"><strong>第三篇：O — 開放封閉原則</strong></a></blockquote><blockquote><strong>第四篇：L — 里氏替換原則 (本文)</strong></blockquote><blockquote><strong>第五篇：I — 介面隔離原則 <em>(敬請期待)</em></strong></blockquote><p>在前面的文章中，我們學會了用 SRP 來「拆解」職責，用 OCP 來「擴展」功能。現在，我們的程式碼已經有了一定的彈性。</p><p>但一個新問題浮現了：當我們基於一個「基本款」元件，去擴展出一個「延伸款」時，要如何確保這個延伸款不會失控，甚至破壞掉原有的系統？這就是我們今天要深入探討的，SOLID 中最具哲學思辨的原則：<strong>L — 里氏替換原則 (Liskov Substitution Principle, LSP)。</strong></p><h3>釐清詞彙：到底什麼是「里氏替換」？</h3><p>里氏替換原則的官方定義聽起來非常學術：</p><blockquote><strong><em>如果 S 是 T 的子類型，那麼所有 T 類型的物件，都可以在不改變程式任何所需屬性的情況下，被 S 類型的物件替換 (If S is a subtype of T, then objects of type T may be replaced with objects of type S without altering any of the desirable properties of that program)。</em></strong></blockquote><p>別怕，讓我們把它翻譯成前端工程師都懂的白話文：</p><p><strong>一個「延伸款」元件，必須能夠完美地替換掉它的「基本款」元件，而不會讓使用它的地方產生任何錯誤或非預期的「驚喜」。</strong></p><p>LSP 的核心，其實是在談一個「<strong>承諾</strong>」或「<strong>契約</strong>」。當一個基本款元件向外做出某種行為承諾時（例如：傳入 onClick 就一定會被點擊觸發），所有基於它擴展出來的延伸款，都必須<strong>無條件地遵守</strong>這個承諾。</p><h3>具象化理解：通用遙控器 vs. 特異功能電視</h3><p>想像一下，你買了一支「通用電視遙控器」。這支遙控器（程式）是基於一個「電視機」（基本款）的通用規格設計的，上面有電源、音量＋、音量－等標準按鈕。</p><ul><li>你家裡有一台 <strong>Sony 電視</strong>（延伸款 A）。你用通用遙控器對著它，按音量＋，音量就變大；按音量－，音量就變小。一切正常，這台 Sony 電視<strong>遵循了 LSP</strong>。</li><li>後來你又買了一台<strong>新潮設計師款電視</strong>（延伸款 B）。你用同一支遙控器對著它，按音量＋，電視卻變成了靜音；按音量－，電視卻關機了。這台電視的行為完全違背了你對「電視機」的預期，它給了你一個巨大的「驚喜」。這台電視就<strong>違反了 LSP</strong>。</li></ul><p>在這種情況下，你不能說「是遙控器壞了」，問題出在這台電視沒有遵守作為一台「電視」應有的基本行為契約。它雖然看起來像電視，卻不能被安全地「替換」一台標準電視。</p><h4>前端實戰：元件的「行為承諾」</h4><p>在現代 React 開發中，我們很少使用 class 繼承，但 LSP 的精神，完美地體現在<strong>元件的 API 契約（Props）</strong>上。當我們建立一個基礎元件，並基於它去擴充時，就必須遵守 LSP。</p><p>讓我們來看一個 &lt;BaseButton&gt; 的例子。</p><p><strong>基本款元件：</strong><strong>&lt;BaseButton&gt; 的承諾</strong></p><pre>// components/BaseButton.tsx<br>import React from &#39;react&#39;;<br><br>interface BaseButtonProps extends React.ButtonHTMLAttributes&lt;HTMLButtonElement&gt; {<br>  children: React.ReactNode;<br>}<br>// 它的承諾很簡單：<br>// 1. 渲染一個標準的 &lt;button&gt;<br>// 2. 顯示傳入的 children<br>// 3. 接受所有標準按鈕屬性，包括一個 onClick 處理函式<br>const BaseButton = ({ children, ...props }: BaseButtonProps) =&gt; {<br>  return (<br>    &lt;button style={{ padding: &#39;10px 15px&#39;, border: &#39;1px solid gray&#39;, cursor: &#39;pointer&#39; }} {...props}&gt;<br>      {children}<br>    &lt;/button&gt;<br>  );<br>};<br>export default BaseButton;</pre><p><strong>遵循 LSP 的延伸：</strong><strong>&lt;PrimaryButton&gt;</strong></p><pre>// components/PrimaryButton.tsx<br>import React from &#39;react&#39;;<br>import BaseButton from &#39;./BaseButton&#39;;<br><br>// PrimaryButton 只是改變了外觀，完全遵守了 BaseButton 的所有行為承諾。<br>// 它可以安全地替換任何使用 BaseButton 的地方。<br>const PrimaryButton = (props: React.ComponentProps&lt;typeof BaseButton&gt;) =&gt; {<br>  return (<br>    &lt;BaseButton <br>      style={{ backgroundColor: &#39;blue&#39;, color: &#39;white&#39;, border: &#39;none&#39; }} <br>      {...props} <br>    /&gt;<br>  );<br>};</pre><p><strong>違反 LSP 的延伸：</strong><strong>&lt;ConfirmButton&gt;</strong></p><p>現在，讓我們來看一個<strong>背叛了承諾</strong>的延伸款。</p><pre>// components/ConfirmButton.tsx (違反 LSP 的版本)<br>import React from &#39;react&#39;;<br>import BaseButton from &#39;./BaseButton&#39;;<br><br>const ConfirmButton = (props: React.ComponentProps&lt;typeof BaseButton&gt;) =&gt; {<br>  const originalOnClick = props.onClick;<br>  // 驚喜來了：它改變了 onClick 的核心行為！<br>  const handleConfirmClick: React.MouseEventHandler&lt;HTMLButtonElement&gt; = (event) =&gt; {<br>    if (window.confirm(&#39;您確定要執行此操作嗎？&#39;)) {<br>      // 只有在使用者點擊「確定」時，才會執行原本的 onClick<br>      originalOnClick?.(event);<br>    }<br>    // 如果使用者點擊「取消」，原本的 onClick 將永遠不會被觸發<br>  };<br>  return &lt;BaseButton {...props} onClick={handleConfirmClick} /&gt;;<br>};</pre><p><strong>為什麼 </strong><strong>&lt;ConfirmButton&gt; 違反了 LSP？</strong></p><p>想像一個開發者，在一個表單中使用 &lt;BaseButton&gt; 來提交資料：</p><p>&lt;BaseButton onClick={submitForm}&gt;提交&lt;/BaseButton&gt;</p><p>他預期點擊按鈕，submitForm 就會被執行。一切正常。</p><p>後來，為了美觀，他決定換成 &lt;ConfirmButton&gt;：</p><p>&lt;ConfirmButton onClick={submitForm}&gt;提交&lt;/ConfirmButton&gt;</p><p>他認為這只是一個樣式上的替換，但現在，他的 submitForm 函式<strong>不一定會被執行了</strong>！&lt;ConfirmButton&gt; 單方面地改變了 onClick 的行為契約，給使用者帶來了非預期的「驚喜」，這就可能導致 bug。它不能安全地替換 &lt;BaseButton&gt;。</p><h4>那要如何正確地實作「確認」功能？</h4><p>這個問題的答案，正好體現了 SRP (單一職責) 與 LSP 的相輔相成。關鍵在於<strong>將「確認邏輯」與「點擊行為」分離</strong>。按鈕的職責就是被點擊；而「確認」是屬於更高層次的業務邏輯。</p><p>最直接且完全遵循 LSP 的方式，就是讓 BaseButton 保持單純，確認邏輯由使用它的地方來提供。</p><pre>// 在你的表單元件中<br>const handleSubmit = () =&gt; {<br>  // ... 提交表單的邏輯 ...<br>};<br><br>const handleSubmitWithConfirm = () =&gt; {<br>  if (window.confirm(&#39;您確定要提交嗎？&#39;)) {<br>    handleSubmit();<br>  }<br>};<br>return &lt;BaseButton onClick={handleSubmitWithConfirm}&gt;提交&lt;/BaseButton&gt;;</pre><p>在這裡，&lt;BaseButton&gt; 的 onClick 承諾被完美遵守了。它不在乎傳入的函式是什麼，只負責在被點擊時忠實地執行它。我們透過<strong>組合</strong>的方式，在外部為它增加了新功能，這完美地遵守了里氏替換原則。</p><h3>背景資料</h3><p>里氏替換原則 (LSP) 由電腦科學家<strong>芭芭拉·利斯科夫 (Barbara Liskov)</strong> 在 1987 年提出。她在電腦科學領域有著卓越貢獻，是<strong>美國第一位獲得電腦科學博士學位的女性</strong>，並因其在程式語言和系統設計方面的成就，於 2008 年獲頒<strong>圖靈獎</strong>（電腦科學界的最高榮譽）。</p><p>這個原則最初是為了給物件導向語言中的「繼承」提供一個嚴謹的行為準則，確保子類別不會破壞父類別的行為，從而建立可靠的軟體系統。</p><h3>結論</h3><p>在前端的世界裡，LSP 提醒我們，當我們在建立元件庫或設計系統時，<strong>可預測性</strong>和<strong>信賴感</strong>至關重要。</p><p>每一次的元件擴充，都是一次「承諾的延伸」。我們必須確保延伸款元件會<strong>尊重</strong>並<strong>遵守</strong>基本款所定下的契約。一個遵循 LSP 的元件庫，能讓團隊中的所有開發者都能充滿信心地使用這些元件，因為他們知道，這些元件的行為會跟他們預期的一樣，不會有任何意外的「驚喜」。這正是打造一個穩健、可信賴前端系統的基礎。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b983acaa3bc7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[從前端視角理解 SOLID：O — 開放封閉原則，不動舊碼新增功能的魔法]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-o-%E9%96%8B%E6%94%BE%E5%B0%81%E9%96%89%E5%8E%9F%E5%89%87-%E4%B8%8D%E5%8B%95%E8%88%8A%E7%A2%BC%E6%96%B0%E5%A2%9E%E5%8A%9F%E8%83%BD%E7%9A%84%E9%AD%94%E6%B3%95-c5e14f9400f0?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5e14f9400f0</guid>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Tue, 29 Jul 2025 03:45:05 GMT</pubDate>
            <atom:updated>2025-08-01T02:42:05.501Z</atom:updated>
            <content:encoded><![CDATA[<h3>從前端視角理解 SOLID：O — 開放封閉原則，不動舊碼新增功能的魔法</h3><blockquote><em>本文為 </em><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b"><strong><em>從前端視角理解 SOLID</em></strong></a><em> 系列的第三篇。</em></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b"><strong>第一篇：導論，為何好懂的 React 程式碼都有它的影子？</strong></a></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-s-%E5%96%AE%E4%B8%80%E8%81%B7%E8%B2%AC%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84%E5%87%BD%E5%BC%8F%E7%AE%A1%E5%A4%AA%E5%A4%9A%E4%BA%86%E5%97%8E-05a71a450216"><strong>第二篇：S — 單一職責原則</strong></a></blockquote><blockquote><strong>第三篇：O — 開放封閉原則 (本文)</strong></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-l-%E9%87%8C%E6%B0%8F%E6%9B%BF%E6%8F%9B%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84-%E5%BB%B6%E4%BC%B8%E6%AC%BE-%E5%88%A5%E8%83%8C%E5%8F%9B%E4%BA%86-%E5%9F%BA%E6%9C%AC%E6%AC%BE-b983acaa3bc7"><strong>第四篇：L — 里氏替換原則</strong></a></blockquote><p>在上一篇文章中，我們學會了如何運用「單一職責原則 (SRP)」，將程式碼拆解成一個個職責清晰的「專業工具」。現在，我們的工具箱看起來乾淨又整潔。</p><p>但新的挑戰來了：如果客戶提出新需求，要我們為工具箱增加一把「新工具」，我們該怎麼辦？是把整個工具箱拆開，修改內部的結構嗎？這正是我們今天要探討的主題：<strong>O — 開放封閉原則 (Open/Closed Principle, OCP)。</strong></p><h3>釐清詞彙：什麼是「開放」？什麼是「封閉」？</h3><p>開放封閉原則的官方定義是：</p><blockquote><strong><em>軟體實體（類別、模組、函式）應該對於擴展開放，但對於修改封閉 (Software entities should be open for extension, but closed for modification)。</em></strong></blockquote><p>這句話是 SOLID 原則中最著名、也可能最常被誤解的一句。讓我們把它翻譯成前端開發者更熟悉的語言：</p><ul><li><strong>對擴展開放 (Open for extension)</strong>：意味著當業務需求變化時，我們可以輕易地為系統<strong>增加新功能</strong>或新行為。</li><li><strong>對修改封閉 (Closed for modification)</strong>：意味著我們在增加新功能時，應該盡量<strong>避免去修改</strong>那些已經寫好、且穩定運作的舊程式碼。</li></ul><p>簡單來說，OCP 的核心精神就是：<strong>用增加新程式碼的方式，來取代修改舊程式碼。</strong> 這樣做的最大好處是，能顯著降低在現有功能中引入新錯誤 (bug) 的風險，讓我們的系統更穩定。</p><h3>具象化理解：你的 VSCode vs. 遠古時代的記事本</h3><p>身為工程師，我們每天都在使用的 VSCode 就是 OCP 的最佳範例。</p><ul><li><strong>對擴展開放</strong>：你需要新的主題配色？去市集安裝一個主題就好。你需要新的程式碼檢查工具？安裝一個 ESLint 擴充套件。你需要遠端開發？安裝一個 Remote SSH。你可以透過無數的「擴充套件」來為 VSCode 增加新功能。</li><li><strong>對修改封閉</strong>：在安裝這些擴充套件時，你需不需要去修改 VSCode 的原始碼？完全不用。VSCode 的核心程式是穩定且封閉的，它透過一個定義良好的擴充機制，讓全世界的開發者都能安全地為它添加新功能。</li></ul><p>這與遠古時代的記事本（Notepad）形成了鮮明對比。如果你想讓記事本支援語法高亮，你唯一的選擇就是去修改它的原始碼，這充滿了風險。</p><p>我們的目標，就是讓自己寫的元件和模組，更像 VSCode，而不是記事本。</p><h3>前端實戰：告別 if/else 地獄</h3><p>在前端開發中，最常違反 OCP 的場景，莫過於無盡的 if/else 或 switch 判斷。讓我們來看一個顯示不同狀態標籤的 StatusBadge 元件。</p><h4><strong>反面教材：一個對修改「開放」的元件</strong></h4><p>假設我們一開始有三種狀態：success, error, pending。</p><pre>// StatusBadge.tsx (違反 OCP 的版本)<br>import React from &#39;react&#39;;<br><br>type Status = &#39;success&#39; | &#39;error&#39; | &#39;pending&#39;;<br>interface BadgeProps {<br>  status: Status;<br>}<br>const StatusBadge = ({ status }: BadgeProps) =&gt; {<br>  let backgroundColor = &#39;&#39;;<br>  let textColor = &#39;&#39;;<br>  let text = &#39;&#39;;<br>  // 每增加一種新狀態，就必須回來修改這裡的程式碼<br>  switch (status) {<br>    case &#39;success&#39;:<br>      backgroundColor = &#39;#D4EDDA&#39;;<br>      textColor = &#39;#155724&#39;;<br>      text = &#39;成功&#39;;<br>      break;<br>    case &#39;error&#39;:<br>      backgroundColor = &#39;#F8D7DA&#39;;<br>      textColor = &#39;#721C24&#39;;<br>      text = &#39;失敗&#39;;<br>      break;<br>    case &#39;pending&#39;:<br>      backgroundColor = &#39;#FFF3CD&#39;;<br>      textColor = &#39;#856404&#39;;<br>      text = &#39;處理中&#39;;<br>      break;<br>    default:<br>      backgroundColor = &#39;#E2E3E5&#39;;<br>      textColor = &#39;#383D41&#39;;<br>      text = &#39;未知&#39;;<br>  }<br>  return (<br>    &lt;span style={{ backgroundColor, color: textColor, padding: &#39;4px 8px&#39;, borderRadius: &#39;4px&#39; }}&gt;<br>      {text}<br>    &lt;/span&gt;<br>  );<br>};<br>export default StatusBadge;</pre><p>這個元件現在運作得很好。但下週，產品經理說：「我們需要增加一個『警告 (warning)』的狀態」。你該怎麼辦？唯一的辦法就是<strong>打開這個檔案，修改 </strong><strong>switch 區塊</strong>，增加一個 case &#39;warning&#39;。</p><p>這就違反了 OCP，因為你「修改」了現有的程式碼。這樣做不僅麻煩，而且每次修改都有可能不小心改錯，影響到舊有的狀態顯示。</p><h4><strong>遵循 OCP 的重構：使用「策略模式」</strong></h4><p>現在，我們用 OCP 的精神來重構它。我們將「策略」（也就是每個狀態對應的樣式和文字）從元件中抽離出來，讓元件本身變得穩定。</p><pre>// StatusBadge.tsx (遵循 OCP 的版本)<br><br>import React from &#39;react&#39;;<br>// 1. 將策略定義抽離出來<br>const BADGE_CONFIG = {<br>  success: {<br>    backgroundColor: &#39;#D4EDDA&#39;,<br>    textColor: &#39;#155724&#39;,<br>    text: &#39;成功&#39;,<br>  },<br>  error: {<br>    backgroundColor: &#39;#F8D7DA&#39;,<br>    textColor: &#39;#721C24&#39;,<br>    text: &#39;失敗&#39;,<br>  },<br>  pending: {<br>    backgroundColor: &#39;#FFF3CD&#39;,<br>    textColor: &#39;#856404&#39;,<br>    text: &#39;處理中&#39;,<br>  },<br>  // ✨ 新增狀態時，只需要在這裡增加新策略 ✨<br>  warning: {<br>    backgroundColor: &#39;#FFEEBA&#39;,<br>    textColor: &#39;#856404&#39;,<br>    text: &#39;警告&#39;,<br>  },<br>  default: {<br>    backgroundColor: &#39;#E2E3E5&#39;,<br>    textColor: &#39;#383D41&#39;,<br>    text: &#39;未知&#39;,<br>  },<br>};<br>// 讓 TypeScript 自動推斷出所有可能的 status<br>type Status = keyof typeof BADGE_CONFIG;<br>interface BadgeProps {<br>  status: Status;<br>}<br>// 2. 元件本身變得極其穩定且封閉<br>const StatusBadge = ({ status }: BadgeProps) =&gt; {<br>  const config = BADGE_CONFIG[status] || BADGE_CONFIG.default;<br>  return (<br>    &lt;span style={{ backgroundColor: config.backgroundColor, color: config.textColor, padding: &#39;4px 8px&#39;, borderRadius: &#39;4px&#39; }}&gt;<br>      {config.text}<br>    &lt;/span&gt;<br>  );<br>};<br>export default StatusBadge;</pre><p>重構之後，StatusBadge 元件本身變得<strong>對修改封閉</strong>了。未來無論要增加多少種新狀態，我們都<strong>不需要再碰這個元件的程式碼</strong>。我們只需要在 BADGE_CONFIG 這個設定檔中<strong>增加新的程式碼</strong>（對擴展開放），就能完成需求的變更。</p><p>這就是 OCP 的魔法：它讓我們的核心元件變得像磐石一樣穩定，同時又保有極高的擴充彈性。</p><h3>背景資料</h3><p>開放封閉原則 (OCP) 最早由電腦科學家伯特蘭·梅耶 (Bertrand Meyer) 在 1988 年提出。它被認為是物件導向設計中最核心的原則之一，其目標是建立一個能夠在需求變更時，依然保持穩定與可靠的系統。</p><h3>結論</h3><p>如果說 SRP 教我們如何「正確地拆解」，那麼 OCP 就是教我們如何「優雅地組合與擴展」。</p><p>在開發中，我們無法預測所有未來的需求，但我們可以透過遵循 OCP，建立一個能夠從容應對變化的架構。當下次產品經理帶著新需求來時，你不再需要提心吊膽地修改舊程式碼，而是可以自信地說：「沒問題，我只要增加一個新模組就好。」這份自信，正是源自於開放封閉原則帶給我們的穩定性與彈性。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5e14f9400f0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[從前端視角理解 SOLID：S — 單一職責原則，你的函式管太多了嗎？]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-s-%E5%96%AE%E4%B8%80%E8%81%B7%E8%B2%AC%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84%E5%87%BD%E5%BC%8F%E7%AE%A1%E5%A4%AA%E5%A4%9A%E4%BA%86%E5%97%8E-05a71a450216?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/05a71a450216</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[clean-code]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Fri, 25 Jul 2025 03:31:40 GMT</pubDate>
            <atom:updated>2025-08-01T02:42:08.143Z</atom:updated>
            <content:encoded><![CDATA[<h3>從前端視角理解 SOLID：S — 單一職責原則，你的函式管太多了嗎？</h3><blockquote><em>本文為 </em><a href="https://hugh-program-learning-diary-js.medium.com/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b"><strong><em>從前端視角理解 SOLID</em></strong></a><em> 系列的第二篇。</em></blockquote><blockquote><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b"><strong>第一篇：導論，為何好懂的 React 程式碼都有它的影子？</strong></a></blockquote><blockquote><strong>第二篇：S — 單一職責原則 (本文)</strong></blockquote><p>在上一篇導論中，我們聊到了 SOLID 原則如何作為一面「透鏡」，幫助我們理解並打造更穩健的前端架構。今天，我們就從這趟旅程的第一站開始，深入探討五大原則中最基礎、也最核心的一個：<strong>S — 單一職責原則 (Single Responsibility Principle, SRP)。</strong></p><h4>釐清詞彙：到底什麼是「單一職責」？</h4><p>單一職責原則 (Single Responsibility Principle, SRP) 的官方定義是：</p><blockquote><strong><em>一個模組或一個類別，只應該有一個會需要變更它的理由 (A class should have only one reason to change)。</em></strong></blockquote><p>這句話聽起來有點抽象。用更白話的前端語言來「翻譯」，它的意思是：</p><p><strong>一個元件或一個函式，就只專心做好一件事情。</strong></p><p>如果一個函式同時負責「從 API 獲取資料」、「處理複雜的資料格式轉換」、最後還「根據不同狀態回傳不同的 JSX」，那它就違反了單一職責原則。因為「API 規格變更」、「資料結構變更」或「UI 樣式變更」這三個<strong>完全不同的理由</strong>，都可能導致你需要回頭修改這個函式。</p><p>當多種職責耦合在一起，程式碼的複雜度就會呈指數級增長，最終變得難以維護與測試。</p><h4>具象化理解：瑞士刀 vs. 專業工具組</h4><p>為了更好地理解這個概念，我們可以想像一個情境：</p><p>你是一位專業的鐘錶維修師傅。在你面前有兩種工具可以選：</p><ol><li><strong>一把萬能瑞士刀</strong>：上面有螺絲起子、有小刀、有鑷子、有放大鏡。</li><li><strong>一組專業維修工具</strong>：一支精密的螺絲起子、一把鋒利的小刀、一支防靜電的鑷子、一個高倍率的放大鏡。</li></ol><p>你會選擇哪一個？答案顯而易見。</p><ul><li><strong>瑞士刀</strong>就像一個<strong>違反 SRP（單一職責）</strong> 的巨大元件。它什麼都能做一點，但什麼都做不好。當你想升級其中一個功能（例如換一個更高倍率的放大鏡），你必須換掉整把刀，而且使用起來也笨手笨腳。</li><li><strong>專業工具組</strong>則完美體現了 <strong>SRP（單一職責）的精神</strong>。每個工具都有它獨一無二、不可取代的職責。它們各自獨立，你可以單獨升級或替換任何一個工具，而完全不影響其他工具。它們組合在一起時，能發揮出最強大的專業能力。</li></ul><p>我們的目標，就是將我們的程式碼，從一把笨重的瑞士刀，打造成一組精良、高效的專業工具。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PTtBUdmdUzmSpBW2IXrS9A.png" /></figure><h4>前端實戰：告別肥胖元件 (Fat Component)</h4><p>在 React 開發中，最常見的 SRP 違規現場，就是一個「肥胖元件」。讓我們來看一個典型的例子：一個顯示使用者個人資料的元件。</p><p><strong>反面教材：一個什麼都做的 </strong><strong>UserProfile 元件</strong></p><pre>// UserProfile.tsx (違反 SRP 的版本)<br>import React, { useState, useEffect } from &#39;react&#39;;<br><br>interface User {<br>  id: number;<br>  name: string;<br>  email: string;<br>}<br>const UserProfile = ({ userId }: { userId: number }) =&gt; {<br>  const [user, setUser] = useState&lt;User | null&gt;(null);<br>  const [loading, setLoading] = useState(true);<br>  const [error, setError] = useState&lt;string | null&gt;(null);<br>  // 職責一：獲取遠端資料 (Data Fetching)<br>  useEffect(() =&gt; {<br>    const fetchUser = async () =&gt; {<br>      try {<br>        setLoading(true);<br>        const response = await fetch(`https://api.example.com/users/${userId}`);<br>        if (!response.ok) {<br>          throw new Error(&#39;Failed to fetch user&#39;);<br>        }<br>        const data = await response.json();<br>        setUser(data);<br>      } catch (err) {<br>        setError(err instanceof Error ? err.message : &#39;An unknown error occurred&#39;);<br>      } finally {<br>        setLoading(false);<br>      }<br>    };<br>    fetchUser();<br>  }, [userId]);<br>  // 職責二：處理載入與錯誤狀態 (State Logic)<br>  if (loading) {<br>    return &lt;div&gt;Loading...&lt;/div&gt;;<br>  }<br>  if (error) {<br>    return &lt;div&gt;Error: {error}&lt;/div&gt;;<br>  }<br>  // 職責三：渲染 UI (Rendering)<br>  return (<br>    &lt;div&gt;<br>      &lt;h1&gt;{user?.name}&lt;/h1&gt;<br>      &lt;p&gt;Email: {user?.email}&lt;/p&gt;<br>    &lt;/div&gt;<br>  );<br>};<br>export default UserProfile;</pre><p>這個 UserProfile 元件顯然管得太多了。它集<strong>資料獲取</strong>、<strong>狀態管理</strong>和<strong>畫面渲染</strong>三大職責於一身。這使得它難以測試（你必須模擬 fetch）、難以複用（你想在別的地方用這套 fetch 邏輯怎麼辦？複製貼上？）。</p><p><strong>遵循 SRP 的重構：拆分成 Custom Hook 與純 UI 元件</strong></p><p>現在，我們用 SRP 來重構它，把它拆分成兩樣「專業工具」：</p><p><strong>工具一：專門負責「資料獲取與狀態管理」的 Custom Hook</strong></p><pre>// hooks/useUser.ts (專職的 Custom Hook)<br>import { useState, useEffect } from &#39;react&#39;;<br><br>interface User {<br>  id: number;<br>  name: string;<br>  email: string;<br>}<br>// 這個 Hook 只負責一件事：根據 userId 獲取使用者資料並管理相關狀態<br>export const useUser = (userId: number) =&gt; {<br>  const [user, setUser] = useState&lt;User | null&gt;(null);<br>  const [loading, setLoading] = useState(true);<br>  const [error, setError] = useState&lt;string | null&gt;(null);<br>  useEffect(() =&gt; {<br>    const fetchUser = async () =&gt; {<br>      try {<br>        setLoading(true);<br>        const response = await fetch(`https://api.example.com/users/${userId}`);<br>        if (!response.ok) {<br>          throw new Error(&#39;Failed to fetch user&#39;);<br>        }<br>        const data = await response.json();<br>        setUser(data);<br>      } catch (err) {<br>        setError(err instanceof Error ? err.message : &#39;An unknown error occurred&#39;);<br>      } finally {<br>        setLoading(false);<br>      }<br>    };<br>    fetchUser();<br>  }, [userId]);<br>  return { user, loading, error };<br>};</pre><p><strong>工具二：專門負責「渲染 UI」的純元件 (Presentational Component)</strong></p><pre>// components/UserProfile.tsx (遵循 SRP 的版本)<br>import React from &#39;react&#39;;<br>import { useUser } from &#39;../hooks/useUser&#39;;<br><br>// 這個元件也只負責一件事：根據傳入的 props 渲染畫面<br>const UserProfile = ({ userId }: { userId: number }) =&gt; {<br>  const { user, loading, error } = useUser(userId);<br>  if (loading) {<br>    return &lt;div&gt;Loading...&lt;/div&gt;;<br>  }<br>  if (error) {<br>    return &lt;div&gt;Error: {error}&lt;/div&gt;;<br>  }<br>  return (<br>    &lt;div&gt;<br>      &lt;h1&gt;{user?.name}&lt;/h1&gt;<br>      &lt;p&gt;Email: {user?.email}&lt;/p&gt;<br>    &lt;/div&gt;<br>  );<br>};<br>export default UserProfile;</pre><p>重構之後，好處顯而易見：</p><ol><li><strong>高可讀性</strong>：每個部分都只做一件事，程式碼意圖清晰。</li><li><strong>高可複用性</strong>：useUser 這個 Hook 可以在任何需要獲取使用者資料的地方被重複使用。</li><li><strong>高可測試性</strong>：我們可以獨立地為 useUser 這個 Hook 撰寫單元測試，而完全不用關心 UI 長什麼樣子。</li></ol><p>這就是單一職責原則在現代前端開發中的威力。</p><h4>背景資料</h4><p>單一職責原則 (SRP) 的概念，由羅伯特·C·馬丁 (Robert C. Martin) 在他的著作中系統性地提出。其核心思想源自於一個觀察：一個軟體模組的變更，通常都源自於某個特定「角色」或「利益關係人」的需求。SRP 強調，一個模組應該只為一個「角色」服務，這樣才能在需求變更時，將影響範圍降到最低。</p><h4>結論</h4><p>單一職責原則是 SOLID 中最容易理解，也最容易被忽略的原則。它提醒我們，在動手寫程式碼之前，先花點時間思考「<strong>這段程式碼的核心職責是什麼？</strong>」。</p><p>養成將不同職責分離的習慣，是告別「義大利麵程式碼」、邁向「高內聚、低耦合」的第一步，也是最關鍵的一步。當你的每個元件、每個函式都像一個個精密的專業工具時，你所構建出來的系統，自然會優雅、穩健且充滿彈性。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=05a71a450216" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[從前端視角理解 SOLID：一切的開端]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-%E4%B8%80%E5%88%87%E7%9A%84%E9%96%8B%E7%AB%AF-b10abdc2490b?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/b10abdc2490b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Mon, 21 Jul 2025 06:10:47 GMT</pubDate>
            <atom:updated>2025-07-30T10:16:02.755Z</atom:updated>
            <content:encoded><![CDATA[<p>最近一次的面試，我被問到一個既熟悉又陌生的問題：「你了解 SOLID 原則嗎？在你的專案中是如何應用的？」</p><p>這個問題，讓我想起了幾年前的一段經歷。當時我正帶領一個全新的 React 專案，一位寫 Java 的 App 同事，總是在專案會議上把 SOLID 掛在嘴邊。在當時，我正全心專注於產品的快速交付與團隊的開發流程，雖然聽進去了，卻沒有機會去深究這個名詞背後的完整體系，但「SOLID」這個詞就此在我腦中留下一個索引。</p><p>直到這次面試，為了能清晰地回答問題，我開始系統性地回顧自己的開發習慣：我如何拆分複雜的元件、如何設計可複用的 Hooks、如何定義清晰的 Props 介面。面試結束後，我投入時間將這些實踐經驗與 SOLID 的理論定義進行對照，這才迎來了我的「啊哈時刻」（Aha moment）。</p><p>更讓我驚訝的是，我發現 <strong>SOLID 原則的精神，不僅能很好的應用於函數式程式設計 (Functional Programming) 的概念上，甚至 React 自身的設計，尤其是在 Hooks 問世之後，其背後的核心思想都與 SOLID 不謀而合</strong>。例如，將邏輯抽離至 Custom Hook，本身就是「單一職責」與「依賴反轉」的絕佳體現。</p><p>原來，這些原則的靈魂早已超越了 class 的語法，並深深地影響著現代前端的架構。也因此，我決定將這段學習歷程整理成文章，分享給所有可能跟我一樣，在實踐中摸索，卻需要一條理論線索來將所有知識串連起來的前端夥伴。</p><h3>我們都曾踏入的「技術債」泥潭</h3><p>在討論解方之前，讓我們先回到一個真實的場景。</p><p>你是否也曾參與過一個快速迭代的前端專案？專案初期，我們意氣風發，元件乾淨、邏輯清晰。但隨著時間推移，需求不斷變更、功能持續堆疊，情況開始失控：</p><ul><li><strong>一個失控的元件：</strong> 一個 UserProfile.tsx 元件，從一開始的 50 行，膨脹到 500 行。它既要負責打 API、又要處理表單狀態、還要應對三種不同的使用者權限，最後再渲染出複雜的畫面。這個元件成了團隊裡沒人敢碰的「不定時炸彈」。</li><li><strong>恐懼變更的文化：</strong> 「牽一髮而動全身」成了日常。你想重構一小段邏輯，卻發現它與十幾個地方都有耦合。你盯著那段程式碼，心想：「算了，先複製貼上，能動就好…」技術債就這樣悄悄地累積。</li><li><strong>寸步難行的測試：</strong> 你想為某個核心功能寫單元測試，卻發現光是模擬（mock）它所依賴的十幾個 props 和服務，就比寫測試本身還累，最後只好無奈放棄。</li></ul><p>這就是「高耦合、低內聚」的典型症狀，也是專案從靈活敏捷，走向開發地獄的警訊。</p><h3>SOLID：前端開發的「架構心法」</h3><p>面對上述的困境，SOLID 原則為我們提供了一面「透鏡」，讓我們能看懂為何 React Hooks 如此強大，也讓我們能更有意識地去打造穩健的系統。</p><p>它並非一套生硬的規則，而是一系列經過驗證的思考框架，一套幫助我們打造出優雅程式碼的設計心法：</p><ul><li><strong>單一職責原則 (S)</strong> 讓我們理解，為何將邏輯抽離至 Custom Hook 是一種優雅的實踐。</li><li><strong>開放/封閉原則 (O)</strong> 讓我們在添加一個新的「主題配色」或「會員等級」時，可以透過擴充，而非修改核心的判斷邏輯。</li><li><strong>里氏替換原則 (L)</strong> 確保我們擴充的元件（例如 &lt;PrimaryButton&gt;）不會違背基礎元件（&lt;BaseButton&gt;）的行為承諾，讓系統行為可預測。</li><li><strong>介面隔離原則 (I)</strong> 提醒我們不要設計一個有 20 個 props 的「上帝元件」，而是讓每個元件只向外索取它真正需要的東西。</li><li><strong>依賴反轉原則 (D)</strong> 引導我們依賴抽象（例如一個 IAuthService 介面），而不是具體實作（例如 FirebaseService），讓元件變得可獨立測試、可輕易抽換。</li></ul><p>遵循這些原則，能讓我們更有意識地寫出符合 React 精神、且經得起時間考驗的程式碼。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KtLW7UaYPRhROZ-zLuSkug.png" /></figure><h3>結論：</h3><p>深入理解 SOLID 原則的過程，讓我對許多早已熟悉的程式設計概念，如柯里化（Currying）、高階函式（Higher-Order Functions）有了全新的體悟。我意識到，無論是 SOLID 還是函數式程式設計，它們的誕生，都是為了解決一個共通的目標：<strong>如何讓我們的程式碼擁有更高的可控性與更好的可讀性</strong>。</p><p>學海無涯，我認為理解這些更底層的設計哲學，能讓我們在規劃程式結構時，擁有更清晰的藍圖與更堅實的信心。這份信心，也將讓我們在與 AI 協作的時代，能更好地引領 AI 寫出真正優雅且強固的程式碼。</p><blockquote><strong>在您的開發經驗中，是否也曾遇過類似的「技術債」場景？或是您對於 SOLID 原則在前端的應用，有什麼不同的看法呢？</strong></blockquote><blockquote><strong>歡迎在下方留言區分享您的經驗與觀點，讓我們一同交流成長！</strong></blockquote><h3>系列文預告：</h3><p>在接下來的系列文中，我們將一次專注一個原則。我會先用最白話的方式，解釋它的<strong>「核心概念」；接著用「生活化比喻」來加深記憶；最後，我們會看如何在「TypeScript 與 React」</strong>的專案中，將它具體地實踐出來。至於每個原則的歷史與字源，我會將它放在文末的補充，給有興趣深入的讀者參考。</p><ul><li><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-s-%E5%96%AE%E4%B8%80%E8%81%B7%E8%B2%AC%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84%E5%87%BD%E5%BC%8F%E7%AE%A1%E5%A4%AA%E5%A4%9A%E4%BA%86%E5%97%8E-05a71a450216"><strong>從前端視角理解 SOLID：S — 單一職責原則，你的函式管太多了嗎？</strong></a></li><li><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-o-%E9%96%8B%E6%94%BE%E5%B0%81%E9%96%89%E5%8E%9F%E5%89%87-%E4%B8%8D%E5%8B%95%E8%88%8A%E7%A2%BC%E6%96%B0%E5%A2%9E%E5%8A%9F%E8%83%BD%E7%9A%84%E9%AD%94%E6%B3%95-c5e14f9400f0"><strong>從前端視角理解 SOLID：O — 開放封閉原則，不動舊碼新增功能的魔法</strong></a></li><li><a href="https://medium.com/@hugh-program-learning-diary-js/%E5%BE%9E%E5%89%8D%E7%AB%AF%E8%A6%96%E8%A7%92%E7%90%86%E8%A7%A3-solid-l-%E9%87%8C%E6%B0%8F%E6%9B%BF%E6%8F%9B%E5%8E%9F%E5%89%87-%E4%BD%A0%E7%9A%84-%E5%BB%B6%E4%BC%B8%E6%AC%BE-%E5%88%A5%E8%83%8C%E5%8F%9B%E4%BA%86-%E5%9F%BA%E6%9C%AC%E6%AC%BE-b983acaa3bc7"><strong>從前端視角理解 SOLID：L — 里氏替換原則，你的「延伸款」別背叛了「基本款」</strong></a></li><li><strong>從前端視角理解 SOLID：I — 介面隔離原則，別再硬塞用不到的 Props 了！ <em>(敬請期待)</em></strong></li><li><strong>從前端視角理解 SOLID：D — 依賴反轉原則與系列總結 <em>(敬請期待)</em></strong></li></ul><p>如果您準備好，想讓自己寫的程式碼不只「能動」，更能達到「優雅且強固」的境界，那麼，敬請期待本系列文章。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b10abdc2490b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[碰 Twilio 之前先停下來，看完這篇再行動：一個前輩的串接實錄]]></title>
            <link>https://hugh-program-learning-diary-js.medium.com/%E7%A2%B0-twilio-%E4%B9%8B%E5%89%8D%E5%85%88%E5%81%9C%E4%B8%8B%E4%BE%86-%E7%9C%8B%E5%AE%8C%E9%80%99%E7%AF%87%E5%86%8D%E8%A1%8C%E5%8B%95-%E4%B8%80%E5%80%8B%E5%89%8D%E8%BC%A9%E7%9A%84%E4%B8%B2%E6%8E%A5%E5%AF%A6%E9%8C%84-1b9b1df327e0?source=rss-cd53d8c994f6------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b9b1df327e0</guid>
            <category><![CDATA[webrtc]]></category>
            <category><![CDATA[twilio]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Hugh's Programming life]]></dc:creator>
            <pubDate>Tue, 15 Jul 2025 02:48:19 GMT</pubDate>
            <atom:updated>2025-07-17T12:38:46.469Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dI8xfb5_clvkQYsHgfQyAg.png" /></figure><p>你是不是也曾在整合第三方服務時，看官方文件看到快睡著？</p><p><strong>曾經，我也為此花了快兩個月的時間，在無數個坑裡打滾。</strong> 回頭看那段經歷，我發現官方文件解釋了每個 API <em>能做什麼</em>，卻很少聊到在真實專案裡 <em>該怎麼組合</em>，更別提那些會讓你抓狂的各種狀況了。</p><p>這篇文章，就是我從記憶裡挖出來的一些心得和開發模式，希望能幫你少走一些我走過的冤枉路。</p><p>在這篇只會介紹串接 Twilio 最核心的部分！但基本上核心串接完成之後，其他部分難度就大降了。</p><p>以下用 Nextjs 撰寫<strong>虛擬碼 (Pseudocode)。</strong></p><h3>核心觀念：先搞懂規則，再上牌桌</h3><p>動手前，有四個角色你一定要先認識，不然肯定會一團亂：</p><ol><li><strong>Room（房間）：</strong> 就是一個<strong>虛擬聊天室</strong>，大家都在這裡碰面，由 Twilio 的伺服器管著。</li><li><strong>Participant（參與者）：</strong> 任何進來的人，包括<strong>你自己</strong> (LocalParticipant) 和<strong>其他人</strong> (RemoteParticipant)。</li><li><strong>Track（軌道）：</strong> 真正傳送畫面的<strong>數據流</strong>。你的攝影機畫面是一個 VideoTrack，麥克風聲音是 AudioTrack。</li><li><strong>Access Token：</strong> 一張<strong>有時效、有權限的臨時房卡</strong>。前端不能拿萬能鑰匙（API Keys），只能憑這張房卡進門。</li></ol><h3>後端：蓋一個安全的「授權櫃檯」</h3><p>第一步，也是最重要的，就是蓋一個安全的後端來發放「房卡」。用 Next.js 的 API Routes 來做這件事超方便。</p><p><strong>注意：以下為虛擬碼 (Pseudocode)，旨在說明概念，並非可直接執行的程式碼。</strong></p><pre>// 檔案位置： /api/generate-twilio-token<br>// 收到前端來的請求<br>function handler(請求) {<br>  // === 安全第一 ===<br>  // 這裡一定要先檢查，發請求的人是不是合法的登入使用者<br>  // ... 你自己的使用者身份驗證邏輯 ...<br>  // 從請求中拿出使用者名稱跟想進入的房間名<br>  const userName = 請求.body.userName;<br>  const roomName = 請求.body.roomName;<br>  // === 呼叫 Twilio ===<br>  // 1. 拿出存在伺服器環境變數裡、絕不外洩的 Twilio 金鑰<br>  const twilioKeys = {<br>    accountSid: process.env.TWILIO_ACCOUNT_SID,<br>    apiKey: process.env.TWILIO_API_KEY_SID,<br>    apiSecret: process.env.TWILIO_API_KEY_SECRET,<br>  };<br>  // 2. 用這些金鑰，向 Twilio SDK 要求一張新的 Access Token<br>  const accessToken = createNewTwilioToken(twilioKeys, userName);<br>  <br>  // 3. 告訴 Twilio，這張 Token 只能用在指定的房間<br>  grantVideoAccess(accessToken, roomName);<br>  // === 回傳結果 ===<br>  // 把產生好的 JWT 格式 Token 回傳給前端<br>  return response.json({ token: accessToken.toJwt() });<br>}</pre><h3>前端：優雅地處理各種突發狀況</h3><p>前端最麻煩的就是<strong>處理非同步事件</strong>。人隨時會進來、離開、斷線，我們得準備好。</p><h4>1. 概念：用一個專屬 Hook 集中管理房間邏輯</h4><p>我習慣把所有跟 Twilio 房間有關的髒活累活，都丟到一個自訂的 Hook (useTwilioRoom) 裡，讓 UI 元件保持清爽。</p><p><strong>注意：以下為虛擬碼 (Pseudocode)。</strong></p><pre>// 檔案位置： /hooks/useTwilioRoom.js<br>function useTwilioRoom(token) {<br>  // 我們需要管理的狀態：房間物件、所有參與者的列表<br>  const [room, setRoom] = useState(null);<br>  const [participants, setParticipants] = useState([]);<br>  // 當拿到前端傳來的 token 後，執行連線<br>  useEffect(() =&gt; {<br>    if (!token) return;<br>    // 概念：呼叫 Twilio SDK 的 connect 方法，傳入 token<br>    const twilioRoom = connectToTwilio(token);<br>    setRoom(twilioRoom);<br>    setParticipants(twilioRoom.currentParticipants);<br>    // === 這裡就是事件監聽的藝術 ===<br>    // 監聽事件：當有「新的人」進來時<br>    twilioRoom.on(&#39;participantConnected&#39;, (newParticipant) =&gt; {<br>      // 概念：把新的參與者加到我們的 participants 狀態列表中<br>      addParticipantToList(newParticipant);<br>    });<br>    // 監聽事件：當有「某個人」離開時<br>    twilioRoom.on(&#39;participantDisconnected&#39;, (leavingParticipant) =&gt; {<br>      // 概念：從 participants 狀態列表中移除這個人<br>      removeParticipantFromList(leavingParticipant);<br>    });<br>    <br>    // 最重要的清理工作：當這個 Hook 被銷毀時 (例如使用者跳頁)<br>    return () =&gt; {<br>      // 概念：主動告訴 Twilio 我要離開房間了，釋放資源<br>      disconnectFromRoom(room);<br>    };<br>  }, [token]);<br>  <br>  // 把整理好的狀態回傳給 UI 元件使用<br>  return { room, participants };<br>}</pre><h4>2. 概念：讓每個參與者，都成為一個獨立元件</h4><p>千萬別直接在 useEffect 裡操作 DOM，那在 React 裡是災難的開始。更好的方法是，讓每個參與者的畫面都由一個專屬的元件負責。</p><p><strong>注意：以下為虛擬碼 (Pseudocode)。</strong></p><pre>// 檔案位置： /components/ParticipantView.js<br>function ParticipantView({ participant }) {<br>  // 建立一個 ref，用來指向未來要放影像畫面的那個 div<br>  const videoRef = useRef(null);<br>  useEffect(() =&gt; {<br>    // === 處理影音軌道 ===<br>    <br>    // 概念：取得這個參與者發布的所有影音軌道<br>    const allTracks = participant.tracks;<br>    // 遍歷所有軌道<br>    for (const track of allTracks) {<br>      // 如果這個軌道是可見的 (subscribed)<br>      if (track.isSubscribed) {<br>        // 概念：把這個 track 的影像畫面，掛到 videoRef 這個 DOM 元素上<br>        attachTrackToDOM(track, videoRef.current);<br>      }<br>    }<br>    // === 同樣要監聽未來的新增與移除事件 ===<br>    // participant.on(&#39;trackSubscribed&#39;, ...);<br>    // participant.on(&#39;trackUnsubscribed&#39;, ...);<br>    // === 清理工作 ===<br>    return () =&gt; {<br>      // 概念：當這個元件消失時，要把掛上去的畫面全部移除乾淨<br>      detachAllTracksFromDOM(participant.tracks);<br>    };<br>  }, [participant]);<br>  <br>  // 回傳一個容器，用來顯示這個參與者的畫面和名字<br>  return (<br>    &lt;div className=&quot;participant-container&quot;&gt;<br>      &lt;div ref={videoRef} className=&quot;video-wrapper&quot; /&gt;<br>      &lt;p&gt;{participant.identity}&lt;/p&gt;<br>    &lt;/div&gt;<br>  );<br>}</pre><h3>結語</h3><p>這段打造 Twilio 視訊功能的旅程，說實話，真的不容易。我一開始也跟大家一樣，把官方文件翻了個底朝天，但總覺得少了點什麼；接著跑去研究官方的範例專案，結果光是啟動就遇到一堆問題。</p><p>過程中，我找到一位印度開發者的版本，寫得清楚多了，給了我不少啟發，但離我想要的完整功能，始終差了那麼一步。</p><p>最終，我只能用最簡單也最有效的方法：<strong>直接去看 Twilio SDK 的 TypeScript 原始碼</strong>。我就這樣一行一行地追蹤、一個一個地摸索，像在拼湊一塊巨大的拼圖。直到某個瞬間，所有零散的觀念突然串連起來，我才終於打造出一個能穩定運作的視訊功能。</p><p>這趟旅程雖然艱辛，但也讓我真正體會到，<strong>追根究柢、直面源頭，才是解決複雜問題的最終王道</strong>。它證明了只要不放棄，再難的技術也能被我們一步步征服。</p><blockquote><em>如果你想看看我更早期的奮鬥紀錄，可以參考這篇文章：<br></em><a href="https://hugh-program-learning-diary-js.medium.com/%E4%BA%BA%E7%94%9F%E9%87%8D%E6%A7%8B-day29-%E5%86%8D%E6%88%B0%E6%96%B0%E7%94%A2%E5%93%81-%E4%B8%B2%E6%8E%A5%E8%A6%96%E8%A8%8A%E5%8A%9F%E8%83%BD-twilio-0b668701e571"><em>人生重構-Day29-再戰新產品-串接視訊功能-Twilio</em></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b9b1df327e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>