程式語言排名

Lambda 表達式

(參數) => 函數體

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector numbers = {1, 2, 3, 4, 5};

    // 使用 lambda 表達式來計算偶數的和
    int sum = 0;
    std::for_each(numbers.begin(), numbers.end(), [&sum](int n) {
        if (n % 2 == 0) sum += n;
    });

    std::cout << "偶數的總和: " << sum << std::endl;
    return 0;
}
        

# 使用 lambda 表達式來計算兩數的和
add = lambda x, y: x + y
print(add(5, 10))  # 輸出: 15
        

using System;
using System.Collections.Generic;
using System.Linq;

class Program {
    static void Main() {
        List numbers = new List { 1, 2, 3, 4, 5 };
        
        // 使用 Lambda 表達式篩選出偶數並計算總和
        int sum = numbers.Where(n => n % 2 == 0).Sum();
        
        Console.WriteLine($"偶數的總和: {sum}");
    }
}
        

Reflection

概念

常見用途

• 序列化/反序列化（JSON/XML ↔ 物件）
• 依賴注入（DI）/控制反轉（IoC）
• ORM（資料表 ↔ 物件欄位對應）
• 外掛/模組動態載入
• 測試框架（自動掃描測試、Mock）
• 驗證與自動產生表單/文件

優缺點

• 優點：高彈性、可減少樣板碼、支援通用框架設計。
• 缺點：效能較低、型別安全性降低、可見性破壞（可取用私有成員）、增加維護複雜度。

語言支援情況

• 完整支援：Python、C#、Java、Kotlin、JavaScript/TypeScript、Ruby、PHP、Go
• 部分支援：Swift（Mirror）、Scala
• 不支援（無 runtime 反射）：C++（至 C++23）、Rust（以 derive 宏或自訂程式碼生成替代）

典型範例

# Python：列舉並讀取物件屬性
class User:
    def __init__(self): self.id = 0; self.name = "Ann"
u = User()
for k, v in vars(u).items():
    print(k, v)  # id 0 / name Ann

// C#：取得欄位/屬性並讀值
using System;
using System.Reflection;

var t = typeof(MyType);
foreach (var p in t.GetProperties(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic))
    Console.WriteLine($"{p.Name}={p.GetValue(obj)}");

// JavaScript：動態列舉與呼叫
const obj = { x: 1, y: 2, add(){ return this.x + this.y; } };
for (const [k,v] of Object.entries(obj)) console.log(k, v);
console.log(obj["add"]()); // 3

// Java：使用反射讀/寫欄位
import java.lang.reflect.*;
class U { private int id = 42; }
U u = new U();
Field f = U.class.getDeclaredField("id");
f.setAccessible(true);
System.out.println(f.getInt(u)); // 42

// Go：reflect 走訪結構
import "reflect"
func Dump(v any) {
    val := reflect.ValueOf(v)
    for i := 0; i < val.NumField(); i++ {
        name := val.Type().Field(i).Name
        fmt.Println(name, val.Field(i).Interface())
    }
}

最佳實務

• 僅在確有彈性需求時使用（框架/工具層），避免濫用於核心熱路徑。
• 對敏感或私有成員的存取要審慎控管，遵循最小權限原則。
• 加入快取（例如快取成員資訊）以降低反射開銷。
• 搭配型別註解/屬性（Attributes/Annotations）明確意圖。

何時避免

• 效能關鍵路徑（可用事先生成程式碼或泛型/模板替代）。
• 需要強型別安全與可預期行為時（改用明確介面/抽象）。

檢查任意結構是否全為0

觀念總結

• 能否「自動」檢查任意結構取決於語言是否支援反射/內省（reflection/introspection）。
• 動態語言（如 Python、JavaScript、Ruby、PHP）最容易；靜態語言需靠 Reflection API（如 C#、Java、Kotlin、Go）。
• C++（至 C++23）與 Rust 無內建 runtime reflection，需手動為自訂型別撰寫檢查邏輯或以巨集/derive輔助。

語言支援度比較

Python 範例

def is_all_zero(obj, eps=1e-6):
    if isinstance(obj, (int, float)):  # 基本數值
        return abs(obj) < eps
    elif isinstance(obj, (list, tuple, set)):  # 序列/集合
        return all(is_all_zero(x, eps) for x in obj)
    elif isinstance(obj, dict):  # 字典
        return all(is_all_zero(v, eps) for v in obj.values())
    elif hasattr(obj, "__dict__"):  # 一般物件
        return all(is_all_zero(v, eps) for v in vars(obj).values())
    else:
        return False

# 測試
class Point: 
    def __init__(self, x=0, y=0): self.x, self.y = x, y
class Line:
    def __init__(self, p1=None, p2=None): 
        self.p1 = p1 or Point()
        self.p2 = p2 or Point()

print(is_all_zero([[0,0],[0,0]]))        # True
print(is_all_zero(Line(Point(0,0),Point(0,0))))  # True
print(is_all_zero(Line(Point(1,0),Point(0,0))))  # False

JavaScript 範例

function isAllZero(obj, eps = 1e-6) {
  const isNumZero = n => Math.abs(n) < eps;
  if (typeof obj === "number") return isNumZero(obj);
  if (Array.isArray(obj)) return obj.every(v => isAllZero(v, eps));
  if (obj && typeof obj === "object")
    return Object.values(obj).every(v => isAllZero(v, eps));
  return false;
}

console.log(isAllZero([[0,0],[0,0]]));     // true
console.log(isAllZero({x:0, y:{z:0}}));    // true
console.log(isAllZero({x:0.000001, y:0})); // 視 eps 而定

C# (.NET) 範例

using System;
using System.Linq;
using System.Reflection;

public static class ZeroCheck {
    public static bool IsAllZero(object obj, double eps = 1e-6) {
        if (obj == null) return true;
        switch (obj) {
            case int i:    return i == 0;
            case long l:   return l == 0;
            case float f:  return Math.Abs(f) < eps;
            case double d: return Math.Abs(d) < eps;
        }

        var t = obj.GetType();
        if (t.IsArray)
            return ((Array)obj).Cast<object>().All(x => IsAllZero(x, eps));

        // 掃描欄位與屬性
        foreach (var f in t.GetFields(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic))
            if (!IsAllZero(f.GetValue(obj), eps)) return false;

        foreach (var p in t.GetProperties(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic))
            if (p.CanRead && !IsAllZero(p.GetValue(obj, null), eps)) return false;

        return true;
    }
}

Go 範例

package main

import (
    "math"
    "reflect"
)

func IsAllZero(v interface{}, eps float64) bool {
    val := reflect.ValueOf(v)
    switch val.Kind() {
    case reflect.Float32, reflect.Float64:
        return math.Abs(val.Float()) < eps
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return val.Int() == 0
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        return val.Uint() == 0
    case reflect.Slice, reflect.Array:
        for i := 0; i < val.Len(); i++ {
            if !IsAllZero(val.Index(i).Interface(), eps) { return false }
        }
        return true
    case reflect.Map:
        for _, k := range val.MapKeys() {
            if !IsAllZero(val.MapIndex(k).Interface(), eps) { return false }
        }
        return true
    case reflect.Struct:
        for i := 0; i < val.NumField(); i++ {
            if !IsAllZero(val.Field(i).Interface(), eps) { return false }
        }
        return true
    case reflect.Pointer, reflect.Interface:
        if val.IsNil() { return true }
        return IsAllZero(val.Elem().Interface(), eps)
    default:
        return false
    }
}

C++ / Rust 的限制與做法

• C++（至 C++23）：無 runtime reflection。做法是為每個自訂型別撰寫 isAllZero，或用 template/巨集輔助展開成員。
• Rust：同樣無 runtime reflection，常以 derive 宏為型別自動生成實作（例如自訂 trait IsAllZero）。

實務建議

• 處理浮點數請加入容許誤差 eps，避免精度問題導致誤判。
• 若結構龐大，考慮在資料模型內提供明確的 isAllZero() 方法，避免昂貴的反射掃描。
• 在靜態語言（C++/Rust）可用單元測試確保每個新結構的檢查邏輯已涵蓋所有成員。

訊息佇列

定義與作用

訊息佇列 (Message Queue，簡稱 MQ) 是一種用於軟體系統之間異步通信的架構模式。它允許獨立的應用程式或服務透過傳送和接收訊息來交換資訊，而無需直接相互調用或依賴於對方的即時狀態。MQ 的核心作用是作為一個**中間層**，暫時儲存訊息，直到目標接收者準備好處理它們。

主要組成要素

• 發送者 (Producer/Publisher)： 產生並將訊息投遞到佇列或主題的應用程式。發送者在投遞訊息後，通常不會等待回覆，即可繼續執行自己的任務。
• 接收者 (Consumer/Subscriber)： 從佇列或主題中獲取訊息並進行處理的應用程式。接收者可以根據需求，隨時啟動或停止，而不會影響發送者的運作。
• 訊息代理 (Message Broker)： MQ 系統的核心伺服器。它負責接收、儲存、路由和傳遞訊息給正確的接收者。常見的 Broker 實作有 RabbitMQ、Kafka、ActiveMQ 等。

常見的訊息模式

訊息佇列的關鍵優勢

• 異步處理 (Asynchronous Processing)： 允許耗時操作在後台非同步執行，提升前端回應速度和用戶體驗。
• 系統解耦 (System Decoupling)： 消除服務間的直接依賴。發送者不需知道接收者的位置和狀態，使系統更具彈性和可維護性。
• 流量削峰 (Load Leveling/Peak Shaving)： 在高併發情境下，MQ 作為緩衝區，將瞬間的大量請求平滑地分散給後端服務處理，防止後端系統因超載而崩潰。
• 可靠性與冗餘 (Reliability and Redundancy)： 訊息通常會被持久化儲存。即使接收者暫時故障，訊息也不會丟失，待系統恢復後仍可繼續處理。

結語

訊息佇列是建構現代分佈式系統、微服務架構和高可用性應用程式的基石。它通過引入時間和空間上的間接性，顯著提高了系統的彈性、可伸縮性和穩健性。

訊息佇列與 HTTP API 比較

通信模式差異

適用情境比較

訊息佇列 (MQ) 的優勢與應用場景

• 流量削峰： 處理突發的大量請求，例如秒殺活動或大型促銷時的訂單提交。MQ 作為緩衝，保護後端服務不被瞬間流量擊垮。
• 異步處理： 執行耗時長或非即時的操作，例如用戶註冊後發送歡迎信件、日誌處理、生成報表等。
• 系統解耦： 微服務架構中，將不同服務的生命週期和錯誤隔離開來，避免服務 A 的故障影響服務 B。
• 事件驅動架構： 當某個事件發生時（如訂單狀態變更），需要通知多個下游系統同時進行處理。

HTTP API 的優勢與應用場景

• 即時互動： 需要立即得到回覆的場景，例如使用者登入、查詢即時庫存、金融交易的即時確認。
• 請求-回應模式： 需要雙向互動並根據伺服器的回覆進行下一步操作的場景。
• 簡單性： 對於簡單的 CRUD（增、查、改、刪）操作，HTTP API 的開發和測試相對直接和快速。
• 客戶端應用： 網頁或手機 App 等前端應用程式，通常需要直接向後端發送同步請求並更新介面。

結論

MQ 和 HTTP API 並非互相取代的技術，而是針對不同問題而設計的。

• 如果需要立即獲得結果、要求同步，並且服務間的互動簡單明確，應選擇 HTTP API。
• 如果需要處理高併發、執行耗時操作、最大化系統解耦和容錯性，則應該使用訊息佇列。

在現代的分佈式系統中，兩種模式經常並存，互相配合以滿足不同的業務需求。

訊息佇列適合的應用實例

1. 異步任務處理

在許多網路應用中，有些操作是耗時的，如果讓使用者同步等待，會造成糟糕的使用者體驗。MQ 允許將這些任務轉為異步執行。

• 用戶註冊與通知： 當新用戶完成註冊時，核心系統只需將「用戶註冊成功」的訊息發送到佇列，立即回覆用戶端。後續的任務，如發送歡迎電子郵件、生成初始個人資料或積分發放，則由後端的消費者從佇列中取出訊息並慢慢執行。
• 長時計算與報表生成： 使用者請求生成一個包含大量數據的複雜報表或進行大規模資料計算。系統將請求推入 MQ，並立即告知使用者「報表正在生成中，完成後將以郵件通知」。後台服務異步完成計算。

2. 流量削峰與緩衝

MQ 在處理瞬時高流量的場景中至關重要，可以保護後端服務免於崩潰。

• 電子商務搶購/秒殺活動： 在高流量促銷活動中，瞬間湧入的數萬筆訂單提交請求會讓資料庫和後端訂單處理服務超載。MQ 將所有訂單請求接收並排隊。後端服務以其能處理的穩定速度從佇列中取出請求並處理，從而平滑了峰值壓力。
• 支付系統： 支付請求先進入 MQ。即使支付網關短暫超載，請求也不會丟失，而是安全地在佇列中等待被處理。

3. 系統解耦與微服務通信

在複雜的分佈式系統和微服務架構中，MQ 用於隔離服務，減少相互依賴。

• 訂單狀態變更通知： 當「訂單服務」成功建立新訂單後，它發出「新訂單建立」的事件訊息到 MQ 的主題。對此事件感興趣的多個服務（如「庫存服務」需要扣減庫存、「物流服務」需要準備發貨、「積分服務」需要計算積分）都會收到此訊息並各自獨立執行相應操作。
• 資料同步： 當主資料庫中的某個重要資料被更新時，可以發送一個變更事件到 MQ，允許其他下游系統（例如搜尋索引服務、數據倉庫）訂閱並非同步更新各自的資料副本，實現最終一致性。

4. 日誌收集與監控

將大量的日誌資料從前端應用程式或伺服器收集到集中的處理系統。

• 日誌彙集： 數百個應用程式伺服器不斷產生日誌資料。這些日誌不會直接寫入分析資料庫，而是先發送到 MQ（例如使用 Apache Kafka）。集中的日誌處理服務（如 Logstash）從 MQ 中消費日誌，進行清洗、轉換和索引，最終存入 Elasticsearch 等儲存。這隔離了日誌發送與處理的過程。

5. 數據串流處理

特別是像 Apache Kafka 這樣的高吞吐量 MQ/串流平台，非常適合處理連續不斷的即時資料流。

• 物聯網 (IoT) 數據： 數百萬個感測器和設備持續產生溫度、位置或狀態數據。MQ 可以高效地接收這些數據流，並將其傳遞給即時監控系統或數據分析管道。

HTTP API 傳輸圖片與影片

傳輸大型二進位資料的挑戰

使用 HTTP API 傳輸圖片 (Images) 和影片 (Videos) 這些大型二進位資料 (Binary Data)，主要的挑戰在於：

• 大小限制： 單個檔案通常很大，可能超過伺服器或網路設定的請求主體 (Request Body) 大小限制。
• 時間限制： 傳輸大檔案耗時較長，容易導致 HTTP 請求超時 (Timeout)。
• 效率與編碼： 傳統的 JSON 或 XML 不適合傳輸二進位資料，需要使用高效的編碼方式。

HTTP API 上傳（發送）圖片/影片的方法

1. 使用 multipart/form-data 格式 (最常用於檔案上傳)

這是瀏覽器或客戶端應用程式上傳檔案最標準和最常用的方法。

• 原理： 將整個 HTTP 請求主體分成多個部分 (Part)，每個部分可以包含不同的欄位資料（如文字、數字）或一個完整的檔案。
• 優點： 通用性強，大多數 Web 框架和伺服器都原生支持處理此格式。可以一次請求上傳多個檔案和相關的元資料 (Metadata)。
• Content-Type 範例： multipart/form-data; boundary=YourBoundaryString

2. 直接使用二進位主體 (Binary Body)

如果只需上傳一個單一檔案，可以直接將檔案的二進位內容作為請求的主體。

• 原理： 請求的主體只包含檔案的原始位元組 (Raw Bytes)。
• 優點： 簡單直接，沒有額外的表單邊界 (Boundary) 開銷，傳輸效率高。
• Content-Type 範例： 圖片：image/jpeg 或 image/png；影片：video/mp4。

3. 使用 Base64 編碼 (不建議用於大檔案)

將二進位資料轉換成 ASCII 字串，嵌入到 JSON 或 XML 等文本格式中傳輸。

• 優點： 易於嵌入到標準的 JSON 請求中，無需更改 Content-Type，處理簡單文字格式的 API 也能支援。
• 缺點： Base64 編碼會使檔案體積增大約 33%，**極不適合**傳輸大型影片或高畫質圖片，會大幅增加傳輸時間和伺服器解碼開銷。

HTTP API 下載（接收）圖片/影片的方法

下載二進位資料相對簡單，伺服器直接將檔案的原始二進位內容作為 HTTP 回應的主體 (Response Body) 返回。

• 伺服器回應： 伺服器必須設定正確的 HTTP Header：
  • Content-Type： 必須指明檔案的 MIME 類型，例如 image/jpeg 或 video/mp4。
  • Content-Disposition： 通常設定為 attachment; filename="example.mp4"，指示瀏覽器將內容作為檔案下載而非直接顯示。

影片傳輸的優化：分塊傳輸與串流

對於特別大的檔案（尤其是影片），推薦使用以下技術來提高可靠性和效率：

• 分塊上傳 (Chunked Upload)： 客戶端將大檔案分割成多個較小的塊 (Chunks)，分別通過 HTTP 請求上傳，最後由伺服器組裝。這可以避免單次請求超時，並方便續傳。
• 位元組範圍請求 (Byte Range Requests)： 下載時，客戶端可以使用 HTTP Header Range 請求檔案的特定片段（例如 Range: bytes=100-200）。這對於影片串流 (Streaming) 非常重要，允許播放器只下載需要播放的部分，並支持快進/快退。

串流關鍵技術

1. 傳輸協議 (Protocols)

串流傳輸的核心在於如何高效、穩定且低延遲地將影音內容從伺服器傳輸到客戶端。

• HTTP Live Streaming (HLS)： 由 Apple 開發，是目前最普及的串流標準之一。它將影音切分成小的 $\texttt{.ts}$（MPEG Transport Stream）或 $\texttt{.fmp4}$（Fragmented MP4）檔案片段，並使用一個 $\texttt{.m3u8}$ 播放列表來管理這些片段。
  • 優點： 相容性極高（幾乎所有裝置和瀏覽器都支援），易於通過標準 HTTP 快取和 CDN 加速。
• MPEG-DASH (Dynamic Adaptive Streaming over HTTP)： 一個國際標準，功能與 HLS 相似，也採用 HTTP 傳輸和片段化技術，使用 $\texttt{.mpd}$ 檔案作為媒體描述。
  • 優點： 具備高度的彈性和功能性，是 Android 裝置和許多非 Apple 平台的常用選擇。
• WebRTC (Web Real-Time Communication)： 專為實現**超低延遲**的即時通訊而設計，例如視訊會議、直播互動和線上遊戲。它通常使用 UDP 進行資料傳輸。
  • 優點： 延遲極低（毫秒級），點對點 (P2P) 或近點對點傳輸。
• RTMP (Real-Time Messaging Protocol)： 傳統的 Adobe Flash 協議。雖然已逐漸被 HLS/DASH 取代，但仍廣泛用於直播**推流端**（從編碼器推送到串流伺服器）。

2. 核心技術與概念

適應性位元速率 (Adaptive Bitrate Streaming, ABR)

這是現代串流服務的基石。伺服器會將同一段影音內容編碼成多個不同品質（位元速率、解析度）的版本。

• 原理： 客戶端（播放器）會根據自己的網路頻寬和 CPU 負載，**動態地**切換到最高能流暢播放的品質版本。
• 效益： 提供最佳使用者體驗，避免緩衝 (Buffering) 和卡頓。

內容傳遞網路 (Content Delivery Network, CDN)

對於面向全球使用者的串流服務來說，CDN 是不可或缺的。

• 原理： 將影音內容（HLS/DASH 片段）分發並快取到全球各地的邊緣節點伺服器。
• 效益： 使用者從地理位置最近的伺服器獲取內容，大幅降低延遲，提高傳輸速度，並分擔原始伺服器的負載。

影音編解碼器 (Codecs)

用於壓縮和解壓縮影音資料，以減少檔案大小。

• 影片： H.264 (AVC)、H.265 (HEVC)、AV1。H.265 和 AV1 提供比 H.264 更高的壓縮效率，能以更小的檔案大小提供相同的畫質。
• 音訊： AAC (Advanced Audio Coding) 是串流中最常用的音訊編解碼器。

3. 內容保護與貨幣化

• 數位版權管理 (Digital Rights Management, DRM)： 用於保護版權內容不被非法複製和散播，確保只有授權使用者才能播放。常見標準包括 Widevine (Google)、PlayReady (Microsoft) 和 FairPlay Streaming (Apple)。
• 伺服器端廣告插入 (Server-Side Ad Insertion, SSAI)： 在串流內容到達客戶端前，就在伺服器端將廣告片段與主要內容拼接起來，有效繞過客戶端的廣告阻擋器 (Ad Blocker)。

Shell

Bash - $?

在 Bash 中，$? 代表上一個執行的命令的退出狀態碼（Exit Status）。這是一個整數值，通常用來判斷上一個命令是否成功執行。

退出狀態碼的意義

• 0：表示命令成功執行。
• 非 0：表示命令執行失敗，不同的非 0 值可以代表不同的錯誤類型。

範例 1：檢查成功執行的命令

#!/bin/bash
ls
echo "上一個命令的退出狀態碼是: $?"
    

在這個範例中，ls 命令會列出目錄內容，執行成功後，$? 的值將是 0。

範例 2：檢查失敗的命令

#!/bin/bash
ls /nonexistent-directory
echo "上一個命令的退出狀態碼是: $?"
    

在這個範例中，ls 嘗試列出不存在的目錄，命令會失敗，$? 的值將是一個非 0 數字。

範例 3：使用退出狀態碼進行條件判斷

#!/bin/bash
cp file1.txt /some/directory/
if [ $? -eq 0 ]; then
    echo "文件複製成功。"
else
    echo "文件複製失敗。"
fi
    

此範例會根據命令的退出狀態來決定要顯示哪一條訊息。

Bash 的 if

基本語法

if [ 條件 ]; then
    指令
fi

使用 AND（且）

要在 if 中同時滿足多個條件，可使用：

1. 使用 -a（過時但可用）

if [ "$a" -gt 0 -a "$b" -gt 0 ]; then
    echo "a 和 b 都大於 0"
fi

2. 使用 [[ ]] &&（推薦）

if [[ "$a" -gt 0 && "$b" -gt 0 ]]; then
    echo "a 和 b 都大於 0"
fi

3. 使用多重 if 配合 &&

if [ "$a" -gt 0 ] && [ "$b" -gt 0 ]; then
    echo "a 和 b 都大於 0"
fi

使用 OR（或）

只要其中一個條件成立即可執行：

1. 使用 -o（過時但可用）

if [ "$a" -eq 0 -o "$b" -eq 0 ]; then
    echo "a 或 b 為 0"
fi

2. 使用 [[ ]] ||（推薦）

if [[ "$a" -eq 0 || "$b" -eq 0 ]]; then
    echo "a 或 b 為 0"
fi

3. 使用多重 if 配合 ||

if [ "$a" -eq 0 ] || [ "$b" -eq 0 ]; then
    echo "a 或 b 為 0"
fi

混合使用 AND 與 OR

可搭配括號來控制優先順序：

if [[ ( "$a" -gt 0 && "$b" -gt 0 ) || "$c" -eq 1 ]]; then
    echo "a 和 b 都大於 0，或 c 等於 1"
fi

常見的 NOT 用法

在 Bash 中，if 指令通常搭配 [ ]（test 指令）或 [[ ]]（擴展測試指令）使用。要表示「非」（NOT），使用感嘆號 !。

if [ ! 條件 ]; then
    # 當條件為假時執行的程式碼
fi

1. 檢查檔案或目錄是否存在

這是最常見的用法，例如：如果檔案「不存在」則建立它。

# 如果不存在名為 config.txt 的檔案
if [ ! -f "config.txt" ]; then
    echo "檔案不存在，正在建立..."
    touch config.txt
fi

# 如果目錄不存在
if [ ! -d "/var/log/myapp" ]; then
    mkdir -p "/var/log/myapp"
fi

2. 字串比較

檢查字串是否「不等於」或「非空」。

STR="hello"

# 檢查變數是否不等於 "world"
if [ "$STR" != "world" ]; then
    echo "字串不匹配"
fi

# 檢查字串是否不為空 (! -z 等同於 -n)
if [ ! -z "$STR" ]; then
    echo "變數內有資料"
fi

3. 數值比較

雖然數值比較有 -ne (not equal)，但也可以配合 ! 使用。

NUM=10

if [ ! "$NUM" -eq 20 ]; then
    echo "數字不等於 20"
fi

條件邏輯對照表

使用雙中括號 [[ ]] 的優點

在較現代的 Bash 腳本中，建議使用 [[ ]]，它在處理 ! 與邏輯組合時更為強大且不易出錯。

# 結合多個條件：如果不是目錄且不可讀取
if [[ ! -d $path && ! -r $path ]]; then
    echo "路徑無效或權限不足"
fi

注意事項

• 使用 [[ ]] 時支援 && 和 ||
• 使用 [ ] 時建議搭配多個條件語句並用 && / ||
• 變數務必加上引號，避免空值造成錯誤

Bash 條件分支

基本語法結構

case 語句用於將一個變數的值與多個模式（patterns）進行比對，功能類似於其他語言中的 switch。其語法結構如下：

case 變數 in
    模式1)
        # 執行指令
        ;;
    模式2)
        # 執行指令
        ;;
    *)
        # 預設執行指令（類似 default）
        ;;
esac

常見使用範例

1. 簡單的選單判斷

這是最常見的用法，根據使用者的輸入執行不同的動作。

read -p "請輸入 (yes/no): " input

case "$input" in
    "yes")
        echo "您選擇了是"
        ;;
    "no")
        echo "您選擇了否"
        ;;
    *)
        echo "輸入錯誤"
        ;;
esac

2. 合併多個模式 (OR)

使用 | 符號可以讓多個模式執行相同的指令區塊。

read -p "請輸入月份縮寫: " month

case "$month" in
    Jan|Feb|Mar)
        echo "第一季"
        ;;
    Apr|May|Jun)
        echo "第二季"
        ;;
    *)
        echo "其他月份"
        ;;
esac

3. 使用萬用字元 (Wildcards)

模式比對支援類似檔案路徑的擴充符號（如 *, ?, [a-z]）。

read -p "請輸入一個字元: " char

case "$char" in
    [a-z])
        echo "這是小寫字母"
        ;;
    [A-Z])
        echo "這是大寫字母"
        ;;
    [0-9])
        echo "這是數字"
        ;;
    *)
        echo "這是特殊符號或多個字元"
        ;;
esac

關鍵符號說明

使用注意事項

• 變數引用： 建議將變數放在雙引號中（如 "$var"），以避免變數為空值時產生語法錯誤。
• 順序敏感： case 會從上到下進行比對，一旦匹配成功並遇到 ;; 就會停止，因此請將具體的模式放在通用的模式（如 *）之前。

大小寫區分

預設行為：區分大小寫。在標準的 Bash 環境中，case 語句是大小寫敏感的。這意味著 "A" 與 "a" 會被視為不同的模式。

read -p "輸入一個字元: " char
case "$char" in
    a) echo "這是小寫 a" ;;
    A) echo "這是大寫 A" ;;
esac

方法一：使用 nocasematch 選項

如果您希望整個 case 語句忽略大小寫，可以使用 shopt 指令開啟 nocasematch 設定。這會影響後續所有的字串比對與 case 判斷。

# 開啟忽略大小寫
shopt -s nocasematch

read -p "輸入 yes 或 YES: " input
case "$input" in
    yes) echo "匹配成功 (忽略大小寫)" ;;
esac

# 關閉忽略大小寫 (恢復預設)
shopt -u nocasematch

方法二：在模式中手動指定範圍

如果您不想更改全域設定，可以在模式中直接定義大小寫範圍，這是最標準且相容性最高的做法。

read -p "輸入一個字母: " char
case "$char" in
    [aA]) 
        echo "您輸入了 a 或 A" 
        ;;
    [b-zB-Z]) 
        echo "您輸入了其他字母" 
        ;;
esac

方法三：結合管道符號 (OR)

對於特定的單字，可以使用 | 來列舉所有可能的拼寫形式。

case "$input" in
    stop|STOP|Stop)
        echo "停止執行"
        ;;
esac

設定方式對比

Bash 運算優先順序

在 (( )) 中使用小括號

在 Bash 的算術擴展 (( )) 內部，您完全可以使用小括號 ( ) 來明確指定運算的優先順序，這與 C 語言或大多數編程語言的邏輯一致。這在處理複雜的邏輯（結合與、或、加減乘除）時非常重要。

# 範例：(A 且 B) 或 C
if (( (MIN > 91 && MIN < 110) || FORCE_MODE == 1 )); then
    echo "條件成立"
fi

優先順序規則

在 (( )) 內，運算優先順序遵循標準數學與邏輯規範：

1. 括號內項目： ( ) 優先權最高。
2. 乘除法： *, /, %。
3. 加減法： +, -。
4. 比較運算： <, >, <=, >=。
5. 邏輯運算： && (AND) 優先於 || (OR)。

複雜條件範例

假設您需要判斷：數值必須在範圍內，且（必須是特定倍數或是處於強制模式）：

if (( MIN > 91 && (MIN % 5 == 0 || FORCE_MODE == 1) )); then
    {
        echo "觸發複雜條件判斷"
        IS_SHUTDOWN=true
    } |& tee -a "$LOGFILE"
fi

比較與建議

Bash exit 用法

exit 命令與狀態碼

在 Bash 腳本中，exit 用於終止腳本執行並向父程序傳回一個狀態碼（Exit Status）。

• exit 0： 代表「成功」或「正常結束」。
• exit 1 (或非 0 數字)： 代表「失敗」或「發生錯誤」。不同的數字通常代表不同類型的錯誤（範圍為 0-255）。

if [ -f "config.txt" ]; then
    echo "檔案存在"
    exit 0
else
    echo "錯誤：找不到設定檔"
    exit 1
fi

取得 exit 狀態碼

執行完一個腳本或指令後，可以使用特殊變數 $? 來取得上一個程序的 exit 狀態碼。

./script.sh
echo "腳本結束狀態：$?"

使用反引號 `` 或 $() 取得輸出值

當您呼叫 .sh 檔案並希望將其「輸出內容」（即 echo 的內容）存入變數時，可以使用反引號 或 $()。這稱為指令替換（Command Substitution）。

範例腳本 (get_name.sh)

#!/bin/bash
# 這是輸出內容，會被捕捉
echo "Ubuntu_User"
# 這是結束狀態，不會被反引號捕捉
exit 0

在另一個腳本或終端機呼叫

# 使用反引號
RESULT=`./get_name.sh`

# 使用 $() (現代化推薦寫法)
RESULT=$(./get_name.sh)

echo "取得的結果是: $RESULT"

重要區別：回傳值 vs 輸出內容

如果您想同時取得兩者，可以參考以下範例：

OUTPUT=$(./script.sh)
STATUS=$?

echo "內容為: $OUTPUT"
echo "狀態碼為: $STATUS"

Bash return 用法

return 的基本定義

在 Bash 中，return 指令專門用於函式 (Function) 或透過 source 執行的腳本。它會停止執行目前的函式或腳本，並將指定的狀態碼傳回給呼叫者，但不會關閉目前的 Shell 程序。

1. 在函式內使用 return

這是最常見的用法。return 傳回的是狀態碼（0-255），而非字串資料。

範例腳本 (func_test.sh)

#!/bin/bash

# 定義函式
check_file() {
    if [ -f "$1" ]; then
        return 0  # 成功
    else
        return 1  # 失敗
    fi
}

# 呼叫函式
check_file "test.txt"
RESULT=$?

if [ $RESULT -eq 0 ]; then
    echo "檔案存在"
else
    echo "檔案不存在"
fi

2. 在 .sh 檔案中使用 return (搭配 source)

如果您希望一個腳本執行完後，變數與環境能留在目前的終端機，通常會使用 source。此時必須用 return 而非 exit。

被呼叫者 (sub_script.sh)

# 模擬邏輯判斷
if [ "$USER" != "root" ]; then
    echo "權限不足，僅供 root 使用"
    # 如果用 exit 會直接關閉終端機，用 return 則只會停止此腳本執行
    return 1
fi

export APP_STATUS="Ready"
return 0

呼叫者 (直接在 CMD 或另一個腳本)

source ./sub_script.sh
echo "腳本傳回狀態: $?"
echo "取得環境變數: $APP_STATUS"

3. 如何透過 return 機制取得「回傳值」

由於 return 只能傳回數字（狀態碼），若要取得字串或大量數據，建議結合 echo 與 指令替換。

被呼叫者 (get_data.sh)

#!/bin/bash
calculate() {
    local val=$(( $1 + $2 ))
    # 輸出結果到 stdout
    echo "$val"
    # 傳回執行狀態碼
    return 0
}

calculate 10 20

呼叫者

# 取得輸出內容
DATA=$(./get_data.sh)
# 取得 return 的狀態碼
STATUS=$?

echo "計算結果為: $DATA"
echo "執行狀態: $STATUS"

用法總結與對照

Bash 檢查變數是否為空

在 Bash 中，可以使用條件判斷來檢查變數是否為空，以下提供幾種常見的方式：

範例 1：使用 -z 檢查變數是否為空

#!/bin/bash

var=""
if [ -z "$var" ]; then
    echo "變數是空的"
else
    echo "變數不是空的"
fi
    

-z 用來檢查變數是否為空，如果變數為空，條件成立。

範例 2：使用 -n 檢查變數是否不為空

#!/bin/bash

var="some value"
if [ -n "$var" ]; then
    echo "變數不是空的"
else
    echo "變數是空的"
fi
    

-n 用來檢查變數是否不為空，如果變數有值，條件成立。

範例 3：使用雙引號比較來檢查變數是否為空

#!/bin/bash

var=""
if [ "$var" == "" ]; then
    echo "變數是空的"
else
    echo "變數不是空的"
fi
    

這種方式直接將變數與空字串進行比較，來檢查變數是否為空。

Bash 的陣列結構

簡介

Bash 支援兩種陣列：

• 索引陣列（Indexed Array）：以數字索引存取
• 關聯陣列（Associative Array）：以自訂字串鍵存取（需 Bash 4.0 以上）

索引陣列

定義方式

fruits=("apple" "banana" "cherry")

讀取元素

echo "${fruits[0]}"     # apple
echo "${fruits[1]}"     # banana

列出全部元素

echo "${fruits[@]}"

取得陣列長度

echo "${#fruits[@]}"

新增元素

fruits+=("date")

遍歷元素

for fruit in "${fruits[@]}"; do
    echo "$fruit"
done

關聯陣列

定義與使用（需 Bash 4+）

declare -A capital
capital["Taiwan"]="Taipei"
capital["Japan"]="Tokyo"

存取與遍歷

echo "${capital["Japan"]}"  # Tokyo

for key in "${!capital[@]}"; do
    echo "$key 的首都是 ${capital[$key]}"
done

注意事項

• 索引陣列索引從 0 開始
• 元素值建議用雙引號包起來，避免空白字元錯誤
• 關聯陣列必須使用 declare -A 宣告

結論

Bash 陣列是儲存多筆資料的重要結構，適合用於參數清單、目錄集、鍵值對等資料處理。

Bash 合併兩個陣列

基本語法

combined=("${array1[@]}" "${array2[@]}")

這會將兩個陣列中的所有元素合併為一個新陣列 combined。

完整範例

array1=("apple" "banana")
array2=("cherry" "date")

combined=("${array1[@]}" "${array2[@]}")

echo "合併後的陣列："
for item in "${combined[@]}"; do
    echo "$item"
done

合併至原陣列

array1+=("${array2[@]}")

這會將 array2 的內容直接加到 array1 後方。

注意事項

• 請務必使用 "${array[@]}" 形式，避免元素被錯誤展開
• 陣列中若有空白或特殊字元，用雙引號包住是必要的

Bash 判斷字串是否以某字開頭

使用字串模式比對（推薦）

str="hello world"

if [[ "$str" == hello* ]]; then
    echo "字串以 hello 開頭"
fi

說明： 使用 [[ ]] 支援 shell 的模式比對，* 代表任意字元。

使用正規表示式

if [[ "$str" =~ ^hello ]]; then
    echo "字串以 hello 開頭"
fi

說明： ^ 表示開頭，[[ ]] 中的 =~ 是正則運算。

使用 case 敘述

case "$str" in
  hello*) echo "字串以 hello 開頭" ;;
  *) echo "不是以 hello 開頭" ;;
esac

說明： case 是處理字串模式的好工具，簡潔且可讀性高。

使用 expr（舊式寫法）

if expr "$str" : '^hello' &> /dev/null; then
    echo "字串以 hello 開頭"
fi

說明： 使用 expr 的正則比對功能，適用於較舊版本的 shell。

注意事項

• 變數最好加上引號以防空字串錯誤
• [[ ]] 比 [ ] 功能更完整，推薦使用
• 使用 =~ 時可使用正則表達式，但記得不要加引號

Bash 判斷檔案或目錄是否存在

判斷是否存在：-e

-e 用來檢查檔案或目錄是否存在（不分類型）。

FILE="/etc/passwd"

if [ -e "$FILE" ]; then
    echo "$FILE 存在"
else
    echo "$FILE 不存在"
fi

判斷目錄是否不存在：! -d

-d 用來檢查是否為目錄，! 是否定運算。

DIR="/tmp/myfolder"

if [ ! -d "$DIR" ]; then
    echo "$DIR 不存在，正在建立..."
    mkdir -p "$DIR"
else
    echo "$DIR 已存在"
fi

其他常用的條件選項

• -e：檔案或目錄是否存在（不管是什麼類型）
• -f：是否為「一般檔案」
• -d：是否為「目錄」
• -L：是否為「符號連結」

範例：結合檢查與建立

PATH_TO_CHECK="/home/user/config"

if [ -e "$PATH_TO_CHECK" ]; then
    echo "$PATH_TO_CHECK 已存在"
else
    echo "$PATH_TO_CHECK 不存在，建立中..."
    mkdir -p "$PATH_TO_CHECK"
fi

建議

• 若只需知道「有無存在」→ 使用 -e
• 若需特別確認是目錄或檔案→ 使用 -d 或 -f
• 變數務必加上雙引號，避免空值或空格錯誤

列出所有子目錄存入陣列

範例：儲存到陣列

target_dir="/path/to/your/dir"
subdirs=()

while IFS= read -r -d $'\0' dir; do
    subdirs+=("$dir")
done < <(find "$target_dir" -mindepth 1 -maxdepth 1 -type d -print0)

說明

• find：列出子目錄（不遞迴）
• -mindepth 1：排除自身目錄
• -maxdepth 1：只列出第一層
• -type d：只列出目錄
• -print0 搭配 read -d $'\0'：處理有空格的路徑

範例輸出

for dir in "${subdirs[@]}"; do
    echo "$dir"
done

替代簡易寫法（若無特殊字元）

subdirs=( "$target_dir"/*/ )

此寫法使用通配符匹配子目錄，但無法排除檔案或處理空格與特殊字元。

取得包含 ~ 的實際路徑

方法一：使用 eval 展開

path="~/myfolder/file.txt"
realpath "$(eval echo "$path")"

方法二：以 $HOME 取代

path="~/myfolder/file.txt"
realpath "$(echo "$path" | sed "s|^~|$HOME|")"

方法三：使用 readlink

path="~/myfolder/file.txt"
readlink -f "$(eval echo "$path")"

建議用法

realpath "$(eval echo "$path")"

grep

基本搜尋

grep "關鍵字" 檔案名

忽略大小寫

grep -i "關鍵字" 檔案名

顯示行號

grep -n "關鍵字" 檔案名

遞迴搜尋

grep -r "關鍵字" 目錄路徑

只顯示符合的文字

grep -o "關鍵字" 檔案名

同時顯示檔名

grep -H "關鍵字" 檔案名

兩組關鍵字同時出現 (AND)

grep "關鍵字1" 檔案名 | grep "關鍵字2"

兩組關鍵字任一出現 (OR)

# 方法一：正規表示式
grep -E "關鍵字1|關鍵字2" 檔案名

# 方法二：多個 -e 參數
grep -e "關鍵字1" -e "關鍵字2" 檔案名

解決 binary file matches 問題

# 方法一：強制將檔案視為文字
grep -a "關鍵字" 檔案名

# 方法二：轉換檔案編碼為 UTF-8 再搜尋
iconv -f 原始編碼 -t UTF-8 檔案名 | grep "關鍵字"

# 範例 (從 BIG5 轉成 UTF-8)
iconv -f BIG5 -t UTF-8 檔案名 | grep "關鍵字"

常用組合

grep -rin "關鍵字" 目錄路徑

-print0 搭配 read -d $'\0'

用途說明

在處理包含空格、特殊符號（如空白、引號、換行）的檔名或路徑時，傳統使用 find 配管線 xargs 或 read 可能產生誤判。

-print0 可讓 find 以 null（\0）字元作為輸出分隔，而 read -d $'\0' 能精準讀取 null 分隔的內容，確保每個檔案/路徑準確分離。

基本範例：收集所有子目錄

subdirs=()
while IFS= read -r -d $'\0' dir; do
    subdirs+=("$dir")
done < <(find . -type d -print0)

說明

• -print0：將每筆結果用 null 字元結尾，不用換行
• -d $'\0'：read 每次讀取一個 null 結尾的項目
• IFS=：避免空格被當成欄位分隔
• -r：避免處理時跳脫字元

範例 1：列出所有 .txt 檔案絕對路徑

txt_files=()
while IFS= read -r -d $'\0' file; do
    txt_files+=("$file")
done < <(find "$(pwd)" -type f -name "*.txt" -print0)

範例 2：將檔案傳送到某命令處理（安全）

find . -type f -print0 | while IFS= read -r -d $'\0' file; do
    echo "處理：$file"
    # your_command "$file"
done

範例 3：僅處理包含空格的目錄

find . -type d -print0 | while IFS= read -r -d $'\0' dir; do
    if [[ "$dir" == *" "* ]]; then
        echo "含空格的目錄：$dir"
    fi
done

為何不用換行？

傳統用法如：

find . -type f | while read file; do ...

但若檔名內含換行，會導致 read 錯誤解析，甚至多行誤判為多個檔案。

結論

• -print0 與 read -d $'\0' 是處理任何檔名最安全的方式
• 避免空格、特殊字元或換行導致的處理錯誤
• 適用於 Bash 陣列收集、迴圈處理、xargs 搭配 -0 等場景

while read 只取得一個目錄的問題

問題說明

以下寫法在某些 Bash 或 Cygwin 環境中，只讀取第一個項目：

while IFS= read -r -d $'\0' dir; do
    subdirs+=("$dir")
done < <(find "$target_dir" -mindepth 1 -maxdepth 1 -type d -print0)

這通常是因為 `<(find ...)` 在某些系統（如 Cygwin）不是「真正的檔案描述符」，造成 `read` 無法持續讀取。

修正方式：使用管線搭配 `read -d ''`（或 `readarray -d`）

方法 1：使用 `find | while` 管線搭配 -print0

subdirs=()
find "$target_dir" -mindepth 1 -maxdepth 1 -type d -print0 | while IFS= read -r -d $'\0' dir; do
    subdirs+=("$dir")
done

**注意**：若希望 `subdirs` 在主程式中可用，這方法不適合（因 `while ... |` 子 shell 無法回傳陣列）

方法 2：改存為陣列再處理

mapfile -d '' -t subdirs < <(find "$target_dir" -mindepth 1 -maxdepth 1 -type d -print0)

mapfile（或 readarray）可正確讀入 null 分隔字串為陣列。
這是最可靠且能保留在主 shell 中的方式。

範例輸出

for dir in "${subdirs[@]}"; do
    echo "找到目錄：$dir"
done

總結

• mapfile -d '' -t 是處理 -print0 最安全且最 Bash 原生的方式
• 避免使用管線會導致陣列作用範圍侷限於子 shell
• 注意某些舊版本 Bash 或非 Linux 環境可能不支援 `<( ... )` 正常工作

從變數內容讀取資料（用 read）

假設變數中有多行文字內容

var="line1
line2
line3"

用 while read 逐行讀取

while IFS= read -r line; do
    echo "讀到：$line"
done <<< "$var"

解說

• IFS= 避免 trim 空白
• -r 避免跳脫字元被解析
• <<< 是 here-string，將變數內容當成輸入給 while

單行讀取

read -r first_line <<< "$var"
echo "第一行為：$first_line"

讀成陣列

readarray -t lines <<< "$var"
for line in "${lines[@]}"; do
    echo "$line"
done

找出字串開頭的目錄並依日期排序

完整指令（依目錄修改時間排序）

find . -mindepth 1 -maxdepth 1 -type d -name "abc*" -printf "%T@ %p\n" | sort -nr | cut -d' ' -f2-

說明

• -mindepth 1 -maxdepth 1：只列出當前目錄下的子目錄
• -name "abc*"：名稱以 abc 開頭
• -printf "%T@ %p\n"：印出修改時間（timestamp）與目錄名稱
• sort -nr：依時間數值由新到舊排序
• cut -d' ' -f2-：去掉時間戳，只顯示路徑

範例輸出

./abc_latest
./abc_old
./abc_2020

若需存入 Bash 陣列

readarray -t abc_dirs << <(
  find . -mindepth 1 -maxdepth 1 -type d -name "abc*" -printf "%T@ %p\n" |
  sort -nr | cut -d' ' -f2-
)

for dir in "${abc_dirs[@]}"; do
  echo "找到：$dir"
done

附註

• -printf 為 GNU find 專屬功能，在 macOS 預設 find 不支援，可用 gfind 替代
• %T@ 代表「最後修改時間（秒）」，若需建立時間，需額外工具

Bash 檢查儲存裝置是否可寫入

方法 1：檢查目錄是否有寫入權限

DIR="/mnt/usb"

if [ -w "$DIR" ]; then
    echo "$DIR 可寫入"
else
    echo "$DIR 不可寫入"
fi

-w 為檢查目錄是否有「寫入權限」。但若目錄本身可寫，但實際裝置唯讀（如 mount 成 readonly），這方法可能失效。

方法 2：實際嘗試寫入測試檔案

DIR="/mnt/usb"
TESTFILE="$DIR/.write_test"

if touch "$TESTFILE" 2>/dev/null; then
    echo "$DIR 可寫入"
    rm "$TESTFILE"
else
    echo "$DIR 不可寫入"
fi

此方法最可靠，能檢測 mount 狀態或實體裝置是否真的可寫。

方法 3：使用 mount 指令檢查是否唯讀掛載

MNT="/mnt/usb"

if mount | grep "$MNT" | grep -q "(ro,"; then
    echo "$MNT 為唯讀掛載"
else
    echo "$MNT 為可寫掛載"
fi

此方法需檢查裝置是否被以唯讀（ro）方式掛載。

建議

• 若需保險，使用「方法 2」實際寫入測試法。
• 可搭配 udev 或 mount 時自動檢查。

Shell 重導向用法說明

1. 標準輸出重導向：`>`

在 Shell 中，使用 `>` 可以將指令的標準輸出（stdout）重導向到一個檔案或設備。若檔案已存在，內容會被覆蓋。

echo "Hello" > output.txt

這行指令將 "Hello" 寫入 output.txt 檔案。

2. 追加輸出重導向：`>>`

使用 `>>` 會將標準輸出附加到指定檔案的末尾，不會覆蓋原有內容。

echo "Hello again" >> output.txt

這行指令會將 "Hello again" 附加到 output.txt 的結尾。

3. 標準錯誤重導向：`2>`

在 Shell 中，`2>` 用於將標準錯誤（stderr）重導向到指定位置。例如：

ls non_existent_file 2> error.log

這行指令會將錯誤訊息寫入 error.log 檔案。

4. 追加錯誤重導向：`2>>`

若不想覆蓋錯誤訊息檔案，可使用 `2>>` 將錯誤訊息附加到檔案末尾。

ls non_existent_file 2>> error.log

這行指令會將錯誤訊息附加到 error.log。

5. 同時重導向標準輸出與錯誤：`&>`

使用 `&>` 可以同時將標準輸出與標準錯誤都重導向到同一個檔案或設備。

command &> all_output.log

這行指令會將 command 的所有輸出（標準輸出與錯誤）寫入 all_output.log。

6. 合併標準錯誤到標準輸出：`2>&1`

`2>&1` 將標準錯誤合併到標準輸出，便於統一管理。例如：

command > output.log 2>&1

這行指令會將標準輸出和錯誤都寫入 output.log。

7. 禁止所有輸出：`>/dev/null 2>&1`

若不想顯示任何輸出，可將所有輸出導向到 /dev/null，如：

command >/dev/null 2>&1

這行指令會將 command 的所有輸出丟棄。

轉輸出 UTF-8 編碼文件

在使用 tee 命令將輸出追加到文件時，可以通過 iconv 將輸出轉換為 UTF-8 編碼，確保文件內容以 UTF-8 保存。以下是具體的指令和範例。

指令格式

以下是將輸出保存為 UTF-8 編碼的 tee 指令格式：

• command：您要執行的命令。
• iconv -t utf-8：將輸出轉換為 UTF-8 編碼，其中 -t 代表「目標編碼」。
• tee -a output.txt：將轉換後的輸出追加到 output.txt 文件。

範例

以下範例演示如何將 ls 命令的輸出以 UTF-8 編碼寫入到 output.txt：

執行該指令後，output.txt 的內容將以 UTF-8 編碼保存，避免出現編碼錯誤。

Windows cmd

開啟方式

• 在開始選單搜尋「cmd」或「命令提示字元」
• 使用 Win + R 輸入 cmd 後按下 Enter
• 在資料夾路徑列輸入 cmd 可直接於該路徑開啟

常用指令

• dir：顯示目前目錄下的檔案與資料夾
• cd：切換目錄，例如 cd C:\Users
• cls：清除螢幕內容
• copy：複製檔案，例如 copy a.txt b.txt
• del：刪除檔案
• mkdir：建立新資料夾
• rmdir：刪除資料夾
• echo：輸出文字，例如 echo Hello
• exit：關閉命令提示字元

進階操作

• 重新導向輸出：dir > file.txt 將結果輸出至檔案
• 管線操作：dir | find "txt" 篩選包含 txt 的結果
• 批次檔：建立 .bat 檔案一次執行多個指令
• 環境變數：使用 set 查看與設定變數

管理員模式

• 搜尋「cmd」，右鍵選擇「以系統管理員身份執行」
• 可使用如 ipconfig /flushdns 或 sfc /scannow 等系統維護指令

cmd /k 後執行第二個指令

在同一個視窗執行多個指令

可以使用 &、&& 或 || 來接續指令：

cmd /k "第一個指令 & 第二個指令"

• &：無論第一個成功或失敗都會執行下一個
• &&：只有第一個成功時才執行下一個
• ||：只有第一個失敗時才執行下一個

呼叫其他批次檔

在第一個指令後加上 call，即可接續執行另一個批次檔：

cmd /k "第一個指令 & call second.bat"

使用 /c 執行後關閉

若不需要保持視窗開啟，可以用 /c：

cmd /c "第一個指令 & 第二個指令"

/c 會執行完所有指令後自動關閉視窗，而 /k 則會保留視窗。

CMD 變數

什麼是 CMD 變數？

在 Windows 命令提示字元（Command Prompt, CMD）中，變數是用來儲存資料或設定值的命名空間。它們可以儲存在環境中（環境變數），也可以在批次檔（Batch File）中定義和使用（區域變數）。

變數類型

• 環境變數 (Environment Variables):

  系統或使用者設定的變數，在整個作業系統會話中都可用。例如：%PATH%、%TEMP%。

  查看環境變數： 使用 set 命令。

  set

  設定/修改環境變數 (僅限目前 CMD 會話)：

  set MY_VAR=Hello

• 批次檔區域變數 (Batch Local Variables):

  在批次檔（.bat 或 .cmd 檔案）內使用 set 命令定義的變數，只在該批次檔的執行過程中有效。

• 迴圈變數 (For Loop Variables):

  在使用 for 迴圈時定義的變數，用於迭代檔案、資料夾或數字序列。通常以單個字母命名，前面加兩個百分比符號，例如：%%A（在批次檔中）或單個百分比符號，例如：%A（在命令列直接執行時）。

• 參數變數 (Parameter Variables):

  當執行批次檔時傳遞給它的參數。例如：%1 是第一個參數，%2 是第二個參數，%0 是批次檔本身的路徑和名稱。

變數的使用方式

讀取變數值

要取得變數的值，通常需要在變數名稱前後加上百分比符號 %。

set NAME=CMD User
echo 我的名字是 %NAME%

輸出：我的名字是 CMD User

在批次檔中設定區域變數

@echo off
set MESSAGE=這是批次檔訊息
echo %MESSAGE%
pause

設定變數，但僅在變數不存在時

您可以使用 IF DEFINED 或 IF NOT DEFINED 語句來檢查變數是否已存在或已定義（非空）。

@echo off

rem 檢查變數 MY_DEFAULT_VALUE 是否已定義 (非空)
IF NOT DEFINED MY_DEFAULT_VALUE (
    set MY_DEFAULT_VALUE=Default_Setting
    echo 變數 MY_DEFAULT_VALUE 未定義，已設定為預設值。
) ELSE (
    echo 變數 MY_DEFAULT_VALUE 已存在，值為: %MY_DEFAULT_VALUE%
)

rem 執行一次，變數會被設定為 Default_Setting
rem 再次執行，會顯示已存在。

set MY_DEFAULT_VALUE=Existing_Setting

rem 再次檢查
IF NOT DEFINED MY_DEFAULT_VALUE (
    set MY_DEFAULT_VALUE=Another_Default
    echo 變數 MY_DEFAULT_VALUE 未定義，已設定為 Another_Default。
) ELSE (
    echo 變數 MY_DEFAULT_VALUE 已存在，值為: %MY_DEFAULT_VALUE%
)

pause

另一個較為簡潔的技巧是利用變數擴充的預設值功能 (但這主要用於迴圈和參數處理，且在標準 set 命令上並不直接適用於「如果未設定就設定」的邏輯。因此，IF NOT DEFINED 是最標準的作法。)

啟用延遲環境變數擴充 (Delayed Expansion)

在迴圈或條件語句中，標準的百分比符號變數擴充會在語句解析時發生一次。為了在迴圈的每次迭代中都能讀取變數的新值，需要啟用延遲擴充，並使用驚嘆號 ! 來引用變數。

@echo off
setlocal enabledelayedexpansion
set COUNTER=0
:LOOP
    if %COUNTER% LSS 5 (
        set /A COUNTER+=1
        echo 目前計數: !COUNTER!
        goto LOOP
    )
endlocal

特殊變數/系統變數

參數變數的進階用法

對於參數變數（如 %1）或迴圈變數（如 %%A），可以使用修飾符來提取路徑的不同部分：

echo 完整路徑: %~1
echo 驅動器: %~d1
echo 路徑: %~p1
echo 檔名: %~n1
echo 副檔名: %~x1

這在處理檔案路徑時非常有用。

CMD 中篩選關鍵字

使用 find 指令

• 在 CMD 中沒有 grep，但可以使用內建的 find 指令達到類似效果。
• 語法：指令 | find "關鍵字"

範例

dir | find "txt"          :: 只顯示包含 "txt" 的檔案列
ipconfig | find "IPv4"    :: 只顯示含有 IPv4 的行
tasklist | find "chrome"  :: 篩出含有 chrome 的執行程序

常用參數

• /I：忽略大小寫，例如 find /I "error"
• /V：顯示未包含關鍵字的行
• /C：只顯示符合的行數

多關鍵字搜尋

• 可串接多個 find 達成 AND 條件：

type log.txt | find "Error" | find "2025"

• 若要達成 OR 條件，可用 findstr：

type log.txt | findstr /I "error warning fail"

進階：使用 findstr

• findstr 是 CMD 版的進階搜尋工具，支援多關鍵字與正規表示式。
• 範例：

dir | findstr /R ".*\.txt$"   :: 使用正規表示式找出 .txt 檔
type log.txt | findstr /I "timeout error fail"

CMD 啟動時自動執行的設定方式

概念說明

• 在 Linux 中，登入新 bash 時會自動執行 ~/.bash_profile 或 ~/.bashrc。
• 在 Windows CMD 中，沒有完全對等的「.bash_profile」，但可以用幾種方式達到類似效果。

方法一：使用 AutoRun 登錄值

• CMD 啟動時會檢查系統登錄表中的 AutoRun 設定，若有內容會自動執行。

HKEY_CURRENT_USER\Software\Microsoft\Command Processor
HKEY_LOCAL_MACHINE\Software\Microsoft\Command Processor

• 建立或修改字串值 AutoRun，內容可設定為要執行的批次檔路徑：

AutoRun = "C:\Users\YourName\cmd_startup.bat"

• 此批次檔會在每次開啟 CMD 時自動執行。

方法二：修改 CMD 快捷方式

• 右鍵 CMD 快捷方式 → 屬性 → 「目標」欄位修改：

%SystemRoot%\System32\cmd.exe /k "C:\Users\YourName\cmd_startup.bat"

• /k 代表啟動後執行該批次檔並保持視窗開啟。

方法三：使用登入啟動批次檔

• 將啟動批次檔放入：

%AppData%\Microsoft\Windows\Start Menu\Programs\Startup

• 這樣在登入 Windows 帳號時會自動執行，但這是系統層級的自動啟動，而非每次 CMD 開啟。

對應說明

自動設定 CMD AutoRun 的批次檔

功能說明

• 此批次檔會檢查登錄路徑 HKEY_CURRENT_USER\Software\Microsoft\Command Processor 是否存在。
• 若該路徑中沒有 AutoRun 值，則自動建立並設定為指定批次檔路徑。

範例批次檔內容

@echo off
setlocal

:: 設定 AutoRun 要執行的批次檔路徑
set "AUTORUN_PATH=C:\Users\%USERNAME%\cmd_startup.bat"
set "REG_PATH=HKCU\Software\Microsoft\Command Processor"

echo 檢查 CMD AutoRun 設定中...

:: 檢查登錄機碼是否存在
reg query "%REG_PATH%" >nul 2>&1
if errorlevel 1 (
    echo [資訊] 找不到 Command Processor 機碼，建立中...
    reg add "%REG_PATH%" /f >nul
)

:: 檢查 AutoRun 是否已設定
reg query "%REG_PATH%" /v AutoRun >nul 2>&1
if errorlevel 1 (
    echo [資訊] 未找到 AutoRun，建立新值...
    reg add "%REG_PATH%" /v AutoRun /d "%AUTORUN_PATH%" /f >nul
    echo [完成] AutoRun 已設定為：%AUTORUN_PATH%
) else (
    echo [OK] AutoRun 已存在，未做變更。
)

endlocal
pause

說明

• reg query：用來檢查登錄鍵或值是否存在。
• errorlevel：可用來判斷查詢結果是否成功 (0 為存在，1 為不存在)。
• reg add：建立登錄鍵或值。
• /f：強制覆蓋不提示。
• 可將 %AUTORUN_PATH% 改成你要在 CMD 啟動時自動執行的批次檔路徑。

判斷批次檔運行終端機

範例批次檔

@echo off

:: 偵測 PowerShell
if defined PSModulePath (
    echo 目前在 PowerShell 執行
    goto :eof
)

:: 偵測 Cygwin
if defined CYGWIN (
    echo 目前在 Cygwin 執行
    goto :eof
)
if defined SHELL (
    echo 目前在 Cygwin 執行 (SHELL=%SHELL%)
    goto :eof
)

:: 預設為 CMD
echo 目前在 CMD 執行

判斷依據

• PowerShell：批次檔在 PowerShell 中執行時，環境變數 PSModulePath 會存在
• Cygwin：通常會有 CYGWIN 變數，或 SHELL=/bin/bash
• CMD：若上述條件都不符合，即為傳統命令提示字元

PowerShell

開啟方式

• 在開始選單搜尋「PowerShell」
• 使用 Win + X 選擇「Windows PowerShell」或「Windows Terminal」
• 在資料夾路徑列輸入 powershell 可直接於該路徑開啟

常用指令

• Get-ChildItem：列出目前目錄檔案與資料夾 (類似 dir)
• Set-Location：切換目錄 (縮寫 cd)
• Clear-Host：清除螢幕內容 (縮寫 cls)
• Copy-Item：複製檔案或資料夾
• Remove-Item：刪除檔案或資料夾
• New-Item：建立新檔案或資料夾
• Write-Output：輸出文字 (縮寫 echo)
• Exit：關閉 PowerShell

進階操作

• 管線處理：Get-Process | Where-Object {$_.CPU -gt 100}
• 重新導向輸出：Get-ChildItem > file.txt
• 使用別名：例如 ls、cp、rm 可直接使用
• 變數使用：$var = "Hello"，輸出 $var
• 函式與腳本：可建立 .ps1 檔案執行多個指令

管理員模式

• 搜尋「PowerShell」，右鍵選擇「以系統管理員身份執行」
• 可執行如 Get-EventLog、Set-ExecutionPolicy 等系統維護指令

列出 PowerShell 中的所有變數

指令方法

• Get-Variable：顯示目前 PowerShell 工作階段中的所有變數
• Get-ChildItem variable:：透過變數驅動器檢視所有變數

範例

# 列出所有變數
Get-Variable

# 只顯示變數名稱
Get-Variable | Select-Object Name

# 顯示特定變數的值
Get-Variable PATH | Format-List *

# 使用變數驅動器方式
Get-ChildItem variable:

說明

• Get-Variable 預設會輸出名稱、值、描述等欄位
• 變數驅動器 variable: 可當作路徑來操作變數，例如 Get-Content variable:PATH
• 若要篩選，可以搭配 Where-Object，例如：
  Get-Variable | Where-Object { $_.Name -like "P*" } 只顯示以 P 開頭的變數

PowerShell 使用 .NET UI

PowerShell 使用 .NET UI是很常見的用法。

PowerShell 本身建構在 .NET 上，因此可以直接呼叫任何公開的 .NET Class，包括：

• Windows Forms (WinForms)
• WPF (Windows Presentation Foundation)
• System.Drawing
• System.IO
• System.Net
• ADO.NET
• 甚至自行編譯的 DLL

WinForms 範例

執行後會出現真正的 Windows 視窗。

Label + TextBox 範例

使用 WPF

WPF 比 WinForms 新，也比較漂亮。

載入外部 DLL

例如自己的 .NET Library：

直接寫 C#

PowerShell 可動態編譯 C#：

PowerShell GUI 開發的優缺點

企業常見用途

• AD 管理工具
• 批次作業控制台
• 檔案同步工具
• 伺服器管理介面
• SQL 查詢工具
• 系統維護工具
• 安裝程式 Launcher

適合的規模

如果只是：

• 幾個按鈕
• 幾個輸入欄位
• 顯示 Log
• 呼叫 PowerShell Script

WinForms 非常適合，而且通常一個 .ps1 就能完成。

若要做大型桌面應用程式（數十個畫面、MVVM、資料繫結、多語系），則通常直接使用 C# + WPF 或 C# + WinUI 會比較容易維護。

顯示 HTML

甚至可以把 PowerShell 當桌面程式啟動器，內嵌瀏覽器：

因此 PowerShell 不只是腳本語言，實際上可以直接利用 .NET 建立完整 Windows GUI 程式。

C與C++語言

高效能

• 與底層硬體的緊密結合，能直接操作記憶體與硬體資源。
• 程式碼執行速度快，適用於需要高效能的應用場景。

靜態型別系統

• 在編譯期間檢查型別錯誤，減少執行時錯誤的發生。
• 支援型別轉換以實現靈活的程式設計。

資源控制

• 提供精細的記憶體管理能力，允許開發者手動配置與釋放記憶體。
• 適合開發需要高效資源利用的嵌入式系統與即時應用。

語法靈活性

• 語法簡潔，提供高度控制的結構化設計能力。
• 支援多重編程範式，包括程序式與物件導向式。

廣泛應用領域

• C：用於系統程式設計、驅動程式、嵌入式開發。
• C++：用於遊戲開發、圖形處理、金融計算與大型軟體開發。

跨平台

• 在多數作業系統和硬體架構上均可使用。
• 提供高效能的同時，能滿足跨平台的需求。

C/C++ 預處理器指令

概述

預處理器指令 (Preprocessor Directives)是在 C 或 C++ 程式碼被編譯器正式處理（編譯）之前，由一個稱為「預處理器 (Preprocessor)」的程式模組所執行的命令。這些指令以井號（#）開頭，並且不以分號（;）結尾。

預處理器的作用是執行文字替換、檔案包含、條件編譯等操作，從而產生最終的「翻譯單元 (Translation Unit)」供編譯器使用。

主要指令類別與範例

1. 檔案包含 (File Inclusion)

用於將其他檔案的內容插入到當前檔案中。

• #include <filename>：用於包含標準程式庫標頭檔。預處理器會在編譯器預設的系統標頭檔路徑中搜尋檔案。
• #include "filename"：用於包含使用者自定義的標頭檔。預處理器會先在當前原始碼檔案的目錄中搜尋，然後才搜尋系統路徑。

#include <iostream>  // 包含標準 I/O 庫
#include "my_utility.h" // 包含自定義標頭檔

2. 巨集定義與替換 (Macro Definition and Substitution)

用於定義符號常數或代碼片段的文字替換巨集。

• #define：定義巨集。
• #undef：取消定義巨集。

#define MAX_SIZE 100 // 定義一個符號常數
#define SUM(a, b) ((a) + (b)) // 定義一個帶參數的巨集

int main() {
    int size = MAX_SIZE; // 預處理後變為 int size = 100;
    int total = SUM(5, 3); // 預處理後變為 int total = ((5) + (3));
    return 0;
}

3. 條件編譯 (Conditional Compilation)

允許根據預處理器巨集的值，來決定程式碼的特定區塊是否應被編譯。

• #ifdef：如果巨集已定義，則編譯後續區塊。
• #ifndef：如果巨集未定義，則編譯後續區塊。 (常用於 Include Guard)
• #if：根據給定的常數整數表達式的值來決定是否編譯。
• #else / #elif：條件編譯的替代或後續判斷。
• #endif：結束條件編譯區塊。

#define DEBUG_MODE 1

#if DEBUG_MODE
    std::cout << "偵錯模式已啟用" << std::endl;
#else
    std::cout << "生產模式運行中" << std::endl;
#endif

#ifndef MY_HEADER_H
#define MY_HEADER_H 
    // ... 標頭檔內容 (Include Guard 範例)
#endif

4. 錯誤與警告 (Error and Warning)

• #error：強制預處理器在遇到此指令時停止編譯，並顯示指定的錯誤訊息。
• #warning：輸出指定的警告訊息，但不停止編譯 (非標準指令，但許多編譯器支援)。

#ifndef VERSION_DEFINED
#error "必須定義版本號巨集 VERSION_DEFINED!"
#endif

5. 其他指令 (Other Directives)

• #pragma：用於向編譯器發送特殊指令，行為高度依賴於編譯器 (例如 #pragma once 和 #pragma warning)。
• #line：用於改變編譯器報告錯誤或警告時，所顯示的當前行號和檔案名稱。

#pragma once

定義與功能

#pragma once 是 C 和 C++ 語言中的一種預處理器指令 (Preprocessor Directive)。它的核心功能是確保包含此指令的標頭檔 (Header File) 在單次編譯過程中只會被編譯器處理一次。

此指令的目的是為了解決標頭檔重複包含的問題，防止因為多個原始碼檔案或多層級的標頭檔包含關係，導致同一段程式碼（例如類別定義、函式原型或常數宣告）被編譯器看到多次，進而引發重複定義 (Redefinition) 的編譯錯誤。

與 Include Guard 的比較

在 C/C++ 標準中，傳統上透過使用 Include Guard (包含衛兵) 來達到防止重複包含的目的。#pragma once 提供了更簡潔的替代方案。

Include Guard (標準方法)

這是標準且可移植的方法，使用條件編譯指令：

#ifndef MY_HEADER_H
#define MY_HEADER_H

// 標頭檔內容

#endif // MY_HEADER_H

它依賴於一個唯一的巨集名稱（例如 MY_HEADER_H）來控制內容是否被包含。

#pragma once (非標準方法)

使用單行指令：

#pragma once

// 標頭檔內容

編譯器會自動追蹤它在當前編譯會話中是否已經處理過這個檔案，如果處理過，則直接跳過該檔案的剩餘內容。

優點與缺點

#pragma once 的優點：

• 簡潔性： 只需一行程式碼，無需發明和維護唯一的巨集名稱。
• 編譯效率： 對於大型專案，由於編譯器可以直接根據檔案路徑判斷是否跳過，理論上可以提供略微的編譯速度提升。

#pragma once 的缺點：

• 非標準： 它不是 C++ 語言標準的一部分。儘管所有主流編譯器（包括 MSVC、GCC、Clang）都支援它，但在極少數或舊的編譯器上可能不被識別。
• 路徑依賴： 它依賴於編譯器能否正確識別檔案路徑的唯一性。在某些複雜的專案結構或符號連結環境中，可能會出現問題（雖然極為罕見）。

結論

在現代的開發環境中，特別是使用 Visual Studio 或主流編譯器時，#pragma once 因其簡潔和便利性，是防止標頭檔重複包含的常見且推薦的做法。

#pragma warning

定義與用途

#pragma warning 是 C 和 C++ 語言中的預處理器指令，專門用於在程式碼的特定區塊內，選擇性地抑制、恢復或修改編譯器警告的嚴重程度。

此指令的主要目的在於提供比專案級別設定更精細的控制。例如，當您需要包含一個會產生大量警告的舊版程式庫，但又不希望因此而全域性地關閉這些警告時，就可以使用此指令。

主要操作語法 (MSVC 格式)

雖然 #pragma warning 的具體實作在不同編譯器間可能略有差異（尤其 MSVC 使用最廣），但其核心動作分為以下幾種：

1. 禁用警告 (Disable)

從該點開始，編譯器將忽略指定的警告代碼。

#pragma warning( disable : 4996 ) // 禁用 C4996 (例如：關於使用不安全函式的警告)
// 包含或撰寫會產生 C4996 的程式碼

2. 恢復警告 (Default)

將指定的警告恢復到專案或命令列設定的預設行為。

#pragma warning( default : 4996 ) // 將 C4996 恢復為預設狀態

3. 儲存與還原狀態 (Push and Pop)

這是最安全且最推薦的模式。它允許在處理特定程式碼區塊時修改警告設定，然後確保原始的警告狀態在區塊結束後立即被還原，避免副作用。

• #pragma warning( push )：儲存當前的警告設定堆疊狀態。
• #pragma warning( pop )：還原到最近一次 push 所儲存的狀態。

#pragma warning( push )             // 1. 儲存目前的警告設定
#pragma warning( disable : 4996 4244 ) // 2. 禁用多個特定警告
// 包含第三方標頭檔或舊版程式碼
#pragma warning( pop )              // 3. 還原到原始設定
// 後續的程式碼將使用還原後的設定

4. 提升警告等級 (Error)

將特定的警告代碼提升為編譯錯誤，若發生該警告，編譯將失敗。

#pragma warning( error : 4005 ) // 將警告 4005 視為錯誤

注意事項

• 編譯器特有性： 警告編號（如 4996）是編譯器特定的。您必須針對您使用的編譯器（如 MSVC）查閱正確的編號。
• GCC/Clang 差異： 雖然 GCC 和 Clang 支援部分 #pragma warning 的功能，但它們通常更傾向於使用 -W... 命令列旗標或特殊的 #pragma GCC diagnostic 結構來控制警告。

C++ 標準命名空間

概述

在 C++ 程式設計中，std:: 是指 Standard Namespace（標準命名空間）。它是一個容器，包含了 C++ 語言核心和其標準程式庫（Standard Library）中的所有標準實體，包括函式、類別、模板、巨集和物件。

使用 std:: 的主要目的是為了避免命名衝突 (Name Collisions)。如果標準函式（例如 cout 或 vector）沒有被放在單獨的命名空間內，當使用者自己定義了同名的實體時，編譯器就會不知道該使用哪一個。

std:: 的主要內容

C++ 標準程式庫的大部分功能都位於 std:: 命名空間內。主要類別和功能包括：

1. 輸入/輸出串流 (I/O Streams)

• std::cout：標準輸出串流物件，用於將資料列印到控制台。
• std::cin：標準輸入串流物件，用於從控制台讀取資料。
• std::endl：輸出換行符並刷新緩衝區。
• std::ifstream / std::ofstream：檔案輸入/輸出串流。

2. 標準容器 (Containers)

用於儲存資料的集合類別：

• std::vector：動態大小的陣列。
• std::list：雙向連結串列。
• std::map：鍵值對的排序集合（紅黑樹實作）。
• std::unordered_map：鍵值對的無序集合（哈希表實作）。
• std::set：唯一鍵值的排序集合。
• std::string：用於處理字串的類別。

3. 演算法 (Algorithms)

一組用於容器和範圍操作的通用函式：

• std::sort：排序範圍內的元素。
• std::find：在範圍內尋找指定的值。
• std::copy：將元素從一個範圍複製到另一個範圍。

4. 其他核心工具 (Utilities)

• std::shared_ptr / std::unique_ptr：智慧型指標，用於自動化記憶體管理。
• std::thread：用於多執行緒程式設計。
• std::function：通用函式包裝器。
• std::pair / std::tuple：用於儲存固定數量不同類型值的模板。

使用 std:: 的方式

要存取 std:: 命名空間中的實體，有兩種主要方法：

1. 完整限定名稱 (Fully Qualified Names)

每次使用時都明確寫出 std:: 前綴。這是最安全且推薦的做法，尤其是在標頭檔中，以避免污染全域命名空間。

int main() {
    std::cout << "Hello World" << std::endl;
    std::vector<int> numbers;
    return 0;
}

2. using 宣告 (using Directives)

使用 using namespace std; 可以將整個 std:: 命名空間的內容引入到當前作用域，之後可以直接使用名稱而不需要 std:: 前綴。

#include <iostream>
using namespace std; // 將 std:: 命名空間引入

int main() {
    cout << "Hello World" << endl; // 不需 std:: 前綴
    vector<int> numbers;
    return 0;
}

儘管 using namespace std; 很方便，但在大型專案或標頭檔中應極力避免使用，因為它會增加命名衝突的風險。

std::string

1. 宣告與初始值

在 C++ 中，std::string 是一個類別 (Class)。當你宣告一個 std::string 變數但沒有給予初始值時，它會呼叫預設建構子 (Default Constructor)。

• 初始值：預設為空字串 (即 "")。
• 長度：長度為 0。
• 記憶體：它不等於 C 語言中的 NULL 指標，而是一個有效的物件。

#include <string>
#include <iostream>

void initialization_example() {
    std::string s; // 宣告但未給值
    
    std::cout << "長度: " << s.length() << std::endl; // 輸出: 0
    std::cout << "內容: '" << s << "'" << std::endl;  // 輸出: ''
}

2. 如何檢查是否為空 (Empty)

檢查字串是否不含任何字元，最推薦的方法是使用 empty() 成員函式，這比檢查 length() == 0 更具語意化且在某些容器中效率更高。

void check_empty(std::string s) {
    if (s.empty()) {
        std::cout << "這是一個空字串。" << std::endl;
    }
}

3. 如何檢查是否為 Null？

這是一個常見的誤區：std::string 物件本身永遠不會是 null。

在 C++ 中，只有「指標」可以是 nullptr。如果你指的是檢查字串是否尚未賦值，通常就是檢查它是否 empty()。如果你處理的是 C 風格的字串指標 (char*)，才需要檢查 null。

4. 清空字串的方法

如果你想將一個已有內容的字串恢復到初始的空狀態，可以使用以下方法：

void clear_example() {
    std::string s = "Hello";
    
    s.clear();      // 方法 1：最常用
    s = "";         // 方法 2：重新賦值
    s = std::string(); // 方法 3：賦予一個預設物件
}

float 轉 std::string

1. 使用 std::to_string (最簡單方法)

這是 C++11 引入最直接的方法，將數值轉換為字串。預設情況下，它會保留 6 位小數點。

#include <string>
#include <iostream>

void simple_convert() {
    float val = 3.14159f;
    std::string s = std::to_string(val);
    
    std::cout << s << std::endl; // 輸出範例: "3.141590"
}

2. 使用 std::stringstream (自訂精確度)

如果你需要控制小數點的位數或特定格式，stringstream 是最彈性的選擇。它結合了 <iomanip> 庫來精確控制輸出。

#include <sstream>
#include <iomanip>

void precision_convert() {
    float val = 3.1415926f;
    std::stringstream ss;
    
    // 設定固定點計數法 (fixed) 並保留 2 位小數
    ss << std::fixed << std::setprecision(2) << val;
    
    std::string s = ss.str();
    std::cout << s << std::endl; // 輸出: "3.14"
}

3. 使用 std::format (C++20 高效法)

在 C++20 中，你可以使用格式化字串來同時處理型別轉換與精度控制，語法最為精煉。

#include <format>

void modern_format() {
    float val = 123.456f;
    
    // {:.2f} 代表 float 型別且保留兩位小數
    std::string s = std::format("{:.2f}", val);
    
    std::cout << s << std::endl; // 輸出: "123.46" (會自動四捨五入)
}

4. 相關處理用法：去除末尾多餘的零

std::to_string 經常會產生如 "3.140000" 這樣多餘的零。你可以結合 find_last_not_of 和 erase 來清理字串。

std::string remove_trailing_zeros(float val) {
    std::string s = std::to_string(val);
    
    // 移除末尾的 '0'，直到遇到非 0 字元
    s.erase(s.find_last_not_of('0') + 1, std::string::npos);
    
    // 如果最後一個字元是小數點，也一併移除
    if (s.back() == '.') {
        s.pop_back();
    }
    return s;
}

轉換方法比較

std::string 分隔符解析

1. 使用 std::string::find 循環解析

這是 C++ 中最標準且不依賴外部庫的方法。透過 find 尋找分隔符的位置，並利用 substr 擷取子字串。

#include <iostream>
#include <vector>
#include <string>

void split_by_three_chars() {
    std::string text = "Apple---Banana---Cherry---Date";
    std::string delimiter = "---";
    std::vector<std::string> tokens;
    
    size_t pos = 0;
    size_t last_pos = 0;

    // 循環尋找分隔符
    while ((pos = text.find(delimiter, last_pos)) != std::string::npos) {
        tokens.push_back(text.substr(last_pos, pos - last_pos));
        last_pos = pos + delimiter.length();
    }
    
    // 放入最後一個片段
    tokens.push_back(text.substr(last_pos));

    // 輸出結果
    for (const auto& t : tokens) std::cout << "[" << t << "]" << std::endl;
}

2. 使用 std::string_view (C++17 效能優化)

如果你的字串非常龐大，使用 std::string_view 可以避免在拆分過程中產生大量的字串副本，從而大幅提升效能。

#include <string_view>
#include <vector>

std::vector<std::string_view> split_sv(std::string_view str, std::string_view del) {
    std::vector<std::string_view> output;
    size_t first = 0;

    while (first < str.size()) {
        const auto second = str.find(del, first);
        if (second == std::string_view::npos) {
            output.emplace_back(str.substr(first));
            break;
        }
        output.emplace_back(str.substr(first, second - first));
        first = second + del.size();
    }
    return output;
}

3. 使用 Regex 正則表達式

如果你希望程式碼看起來更簡潔，或是分隔符可能會有變動，可以使用 std::regex。但注意正則表達式的執行效能通常比手動 find 慢。

#include <regex>

void regex_split() {
    std::string text = "One###Two###Three";
    std::regex ws_re("###"); // 定義 3 字元分隔符
    
    std::copy(std::sregex_token_iterator(text.begin(), text.end(), ws_re, -1),
              std::sregex_token_iterator(),
              std::ostream_iterator<std::string>(std::cout, "\n"));
}

解析方法比較

檢查 std::vector 是否為空

概述

在 C++ 中，要檢查 std::vector 容器是否不包含任何元素（即大小為零），最標準且推薦的方法是使用其成員函式 empty()。這是因為 empty() 函式通常比直接檢查 size() 是否等於零更高效，特別是在某些容器實作中。

檢查方法

1. 使用 empty() 函式 (推薦)

這是檢查 vector 是否為空的首選方法。它返回一個布林值：如果 vector 沒有元素，則返回 true；否則返回 false。

#include <vector>
#include <iostream>
#include <string>

void check_empty(const std::vector<std::string>& vec)
{
    if (vec.empty()) {
        std::cout << "Vector 是空的 (empty() == true)." << std::endl;
    } else {
        std::cout << "Vector 不是空的 (empty() == false). 元素數量: " << vec.size() << std::endl;
    }
}

int main()
{
    std::vector<std::string> empty_vec;
    std::vector<std::string> non_empty_vec = {"apple", "banana"};

    check_empty(empty_vec);
    check_empty(non_empty_vec);

    return 0;
}

2. 檢查 size() 函式

雖然有效，但這不是檢查空狀態的最慣用或潛在最高效的方法。它直接檢查 vector 中的元素數量是否為零。

void check_size(const std::vector<int>& vec)
{
    if (vec.size() == 0) {
        std::cout << "Vector 是空的 (size() == 0)." << std::endl;
    } else {
        std::cout << "Vector 不是空的 (size() != 0)." << std::endl;
    }
}

效率考量

對於 std::vector 而言，empty() 和 size() == 0 在時間複雜度上都是 $O(1)$，因為 vector 會將其大小作為成員變數儲存。然而，對於某些其他 C++ 標準容器（例如 std::list 或 std::forward_list），標準建議始終優先使用 empty()，因為它通常是 C++ 標準容器庫中檢查空狀態的通用且最快的慣用法。

C++ 解析字串到字串向量

概述

在 C++ 中，要將一個包含空格（Space）或 Tab 字元（\t）分隔的字串解析成一個個獨立的單詞或標記，並儲存到 std::vector<std::string> 中，最常用的方法是利用 **std::stringstream**。檔案串流類別 std::stringstream 就像一個記憶體中的串流，它預設使用空白字元（包括空格、Tab 和換行符）作為分隔符來進行讀取操作。

程式碼範例

以下是使用 std::stringstream 完成此任務的 C++ 程式碼範例：

#include <iostream>
#include <sstream>   // 包含 stringstream
#include <string>
#include <vector>

using namespace std;

/**
 * 將輸入字串依據任何空白字元 (空格或 Tab) 分隔，並存入 vector。
 * @param input_str 要解析的字串。
 * @return 包含所有分離出的單詞的 vector。
 */
vector<string> split_string_by_whitespace(const string& input_str)
{
    vector<string> tokens;
    
    // 1. 建立 stringstream 物件，並用輸入字串初始化
    stringstream ss(input_str); 
    
    string token;
    
    // 2. 迴圈讀取
    // 串流提取運算子 (>>) 會自動以空白字元 (空格、Tab 等) 為分隔符讀取下一個 token。
    // 當成功讀取一個 token 時，運算子返回 true，否則 (到達字串結尾) 返回 false。
    while (ss >> token) 
    {
        tokens.push_back(token);
    }
    
    return tokens;
}

int main()
{
    // 輸入字串包含多個空格和 Tab 符號 (\t)
    string test_string = "Hello \tWorld   this is \ta test string";
    
    cout << "原始字串: " << test_string << endl;
    
    vector<string> result = split_string_by_whitespace(test_string);
    
    cout << "--- 分隔結果 ---" << endl;
    
    for (size_t i = 0; i < result.size(); ++i)
    {
        cout << "Token " << i + 1 << ": [" << result[i] << "]" << endl;
    }
    
    return 0;
}

關鍵機制解釋

• std::stringstream ss(input_str)：這個類別將輸入字串視為一個輸入串流 (Input Stream)，功能類似於從檔案讀取時使用的 std::ifstream。
• 串流提取運算子 (>>)：
  • 它是 C++ 輸入串流的核心機制。
  • 它會自動忽略任何前導的空白字元（包括空格、Tab、換行符等）。
  • 它會讀取所有連續的非空白字元，直到遇到下一個空白字元或串流結尾。
  • 這完美地符合了「依任何空白字元分隔」的要求，並自動處理多個連續分隔符的情況。
• while (ss >> token)：這是一個慣用的 C++ 串流讀取迴圈。只要串流成功提取並將數據儲存到 token 變數中，迴圈就會繼續執行。

C++ 多維陣列初始化為 0

使用 std::array 初始化

在 C++ 中，可以使用 std::array 初始化多維陣列為 0：

#include <iostream>
#include <array>
using namespace std;

int main() {
    array<array<int, 4>, 3> arr = {0}; // 初始化所有元素為 0

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

注意事項

• std::array 是 C++ 標準庫中的容器類別，適合用於大小在編譯期固定的情況。
• 初始化時可以直接將元素設為 0，確保所有值都被清空。
• 與傳統陣列相比，std::array 提供更多的功能和安全性。

C++ std 陣列的迴圈方法

概述

在 C++ 中，迴圈 (Looping) 是遍歷容器或陣列中所有元素的基本操作。std::vector（動態大小容器）和 std::array（固定大小容器）都是 C++ 標準程式庫 (STL) 中的容器，可以使用多種標準且安全的方法來遍歷它們的元素。

1. 基於範圍的 for 迴圈 (Range-based for loop)

這是 C++11 引入的最現代、最安全、最簡潔的遍歷方法。它適用於所有標準容器（包括 std::vector 和 std::array）。

適用性：

• std::vector：**首選**
• std::array：**首選**

#include <iostream>
#include <vector>
#include <array>

void range_based_loop_example()
{
    std::vector<int> vec = {10, 20, 30};
    std::array<int, 4> arr = {1, 2, 3, 4};
    
    // 使用 auto& 以引用方式遍歷，效率高且允許修改元素
    std::cout << "--- Vector (可修改) ---" << std::endl;
    for (auto& element : vec) {
        element += 1; // 修改元素
        std::cout << element << " "; 
    }
    std::cout << std::endl;
    
    // 使用 const auto& 以常數引用方式遍歷，安全且不允許修改元素
    std::cout << "--- Array (唯讀) ---" << std::endl;
    for (const auto& element : arr) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
}

2. 索引式 for 迴圈 (Index-based for loop)

這是一種傳統且通用的方法。適用於需要存取元素索引（例如：需要同時操作兩個容器或陣列、或在特定索引處終止）的情況。

適用性：

• std::vector：適用，使用 size() 取得邊界。
• std::array：適用，使用 size() 取得邊界。

#include <iostream>
#include <vector>
#include <array>

void index_loop_example()
{
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
    std::array<double, 3> prices = {10.5, 20.99, 5.0};
    
    // 使用 size_t 或 auto 搭配 size()，確保索引類型正確且邊界安全
    for (size_t i = 0; i < names.size(); ++i) {
        // 使用 operator[] 存取元素
        std::cout << "名字: " << names[i] << ", 價格: " << prices[i] << std::endl;
    }
}

注意：使用 [] 運算子存取元素時，C++ 不執行邊界檢查。如果需要邊界檢查，請使用 at() 函式（它會在越界時拋出 std::out_of_range 異常）。

3. 迭代器迴圈 (Iterator loop)

這是 C++ 中最靈活的遍歷方法，適用於所有標準容器。當需要與 C++ 標準程式庫 (STL) 演算法互動時，迭代器是必須的。

適用性：

• std::vector：**推薦** (當需要 STL 演算法或特定控制時)
• std::array：**推薦** (當需要 STL 演算法時)

#include <iostream>
#include <vector>

void iterator_loop_example()
{
    std::vector<double> values = {100.0, 50.0, 10.0};
    
    // 使用 auto 簡化迭代器類型，並使用 begin() 和 end() 取得範圍
    for (auto it = values.begin(); 
         it != values.end(); 
         ++it) 
    {
        *it /= 10.0; // *it 解引用迭代器，存取元素
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    // 使用 cbegin() 和 cend() 確保迭代器是 const，用於唯讀遍歷
    for (auto cit = values.cbegin(); cit != values.cend(); ++cit)
    {
        // 嘗試 *cit = 5; 會導致編譯錯誤
        std::cout << *cit << " ";
    }
    std::cout << std::endl;
}

總結與推薦

複製多維 std::array 的內容方法

問題情境

std::array<std::array<std::array<float, 2>, 2>, 2> twoLines;
std::array<std::array<std::array<float, 2>, 2>, 2> twoLinesCopy;

解法一：直接指定（= 運算子）

std::array 支援淺層到深層的完整複製，因此可以直接使用 =：

twoLinesCopy = twoLines;

解法二：使用 std::copy

std::copy(twoLines.begin(), twoLines.end(), twoLinesCopy.begin());

解法三：使用 std::memcpy（適合 POD 型別，這裡 float 適用）

std::memcpy(&twoLinesCopy, &twoLines, sizeof(twoLines));

建議

• 最簡單安全的方式：twoLinesCopy = twoLines;
• std::copy 適用於需要 STL 泛型方法。
• memcpy 僅適用於 POD（Plain Old Data），且無建構子/解構子邏輯。

C++ 捕獲指標記憶體存取錯誤

概述

在 C++ 中，當您操作指標或使用索引存取陣列/記憶體時，如果存取了無效或已越界的記憶體位置，就會發生未定義行為 (Undefined Behavior)。這種行為通常表現為程式崩潰 (Crash)，例如分段錯誤 (Segmentation Fault) 或存取違規 (Access Violation) 錯誤。

C++ 的標準 try-catch 機制主要用於捕獲程式碼中明確拋出的 C++ 異常 (Exceptions)，而不能直接捕獲由作業系統發出的硬體或記憶體存取錯誤。

為什麼 try-catch 無法捕獲記憶體存取錯誤？

當 C++ 程式試圖存取無效記憶體時，例如：

1. 越界存取 (Out-of-Bounds Access)： 存取陣列末尾之後的記憶體。
2. 空指標解引用 (Dereferencing a Null Pointer)： 試圖讀取或寫入地址為 nullptr 的記憶體。
3. 使用已釋放的記憶體 (Use After Free)： 存取已透過 delete 或 free 釋放的記憶體。

這些操作會觸發底層作業系統的保護機制（例如 Windows 上的 Access Violation 或 Unix/Linux 上的 SIGSEGV 信號），程式會被作業系統終止。這些錯誤不是 C++ 語言層級的異常對象（如 std::exception），因此標準的 try-catch 無法捕獲它們。

錯誤範例（標準 try-catch 無效）

#include <iostream>
#include <vector>

using namespace std;

void crash_function()
{
    // 陣列越界存取範例
    vector<int> vec = {10, 20}; 
    cout << "嘗試存取越界索引..." << endl;
    
    // 這是一個未定義行為，很可能導致存取違規崩潰
    int value = vec[100]; // 錯誤: 存取無效的索引
    cout << "值: " << value << endl;
}

int main()
{
    try
    {
        crash_function();
        // 程式會在上面的 vec[100] 處崩潰，不會執行到這裡，
        // 且 catch 區塊將不會被執行。
    }
    catch (const exception& e) 
    {
        // 此處無法捕獲作業系統層級的錯誤
        cerr << "捕獲到 C++ 異常: " << e.what() << endl;
    }
    catch (...)
    {
        // 仍然無法捕獲記憶體存取錯誤
        cerr << "捕獲到未知異常" << endl;
    }

    return 0;
}

如何處理這類錯誤？

1. 使用安全的 C++ 機制 (首選)

最好的方法是在程式碼設計階段就防止這類錯誤發生，而不是試圖捕獲它們：

• 容器存取： 對於 std::vector 和 std::string，使用 at() 成員函式代替 [] 運算子。當 at() 越界時，它會拋出 C++ 異常 std::out_of_range，可以被標準 try-catch 捕獲。
• 指標管理： 使用智慧型指標（std::unique_ptr, std::shared_ptr）來自動化記憶體生命週期。永遠不要解引用 nullptr，並在解引用之前檢查指標是否有效。

void safe_function()
{
    vector<int> vec = {10, 20}; 
    try
    {
        int value = vec.at(100); // 拋出 std::out_of_range 異常
        cout << "值: " << value << endl;
    }
    catch (const std::out_of_range& e)
    {
        // 成功捕獲 C++ 異常
        cerr << "安全捕獲: " << e.what() << endl;
    }
}

2. 使用特定於平台的結構化異常處理 (Structured Exception Handling, SEH)

在 Windows 環境下，您可以使用微軟擴展的 **結構化異常處理 (SEH)** 來捕獲作業系統層級的錯誤，包括存取違規 (Access Violation)。這通常使用 __try 和 __except 關鍵字。

注意：SEH 是非標準的，且不建議在可移植的 C++ 程式碼中使用。在 C++/CLI 專案中，可以使用 .NET 的 try/catch 捕獲部分 SEH 異常，但這需要特定的編譯器設定 (例如 /EHa)。

C++ 捕獲陣列索引記憶體存取錯誤

概述

在 C++ 中，當您使用原始陣列（C-style array）或指標進行索引操作時，如果存取了超出陣列範圍或無效的記憶體位置，就會發生未定義行為 (Undefined Behavior)。這種行為通常會導致程式在作業系統層級發生崩潰 (Crash)，例如存取違規 (Access Violation) 或分段錯誤 (Segmentation Fault)。

關鍵點在於：C++ 標準的 try-catch 機制專門用於捕獲程式碼中明確拋出的 C++ 異常 (Exceptions)，而無法捕獲作業系統發出的硬體或記憶體保護錯誤。

為什麼標準 try-catch 無效？

當 C++ 程式試圖存取無效記憶體時（例如，存取靜態陣列 arr[100]，但陣列只有 10 個元素），它違反了作業系統對記憶體的保護規則。作業系統會介入，發出信號或異常來終止該程序，防止其破壞系統或其他程序。這些錯誤不是 C++ 語言層級的 std::exception 對象，因此無法被標準的 try-catch 區塊捕獲。

錯誤示範（標準 try-catch 無法捕獲崩潰）

#include <iostream>
#include <stdexcept> // 包含標準異常

using namespace std;

void crash_function()
{
    // C 風格的原始陣列
    int raw_array[5] = {1, 2, 3, 4, 5}; 
    cout << "嘗試存取越界索引..." << endl;
    
    // 陣列越界存取：這是一個典型的未定義行為
    // 如果存取到程序沒有權限的記憶體，將立即觸發存取違規，導致程式崩潰。
    int value = raw_array[100]; // 錯誤: 存取無效的索引
    cout << "值 (如果能到達): " << value << endl;
}

int main()
{
    try
    {
        crash_function();
        // 程式會在 raw_array[100] 處終止，不會執行到這裡。
    }
    catch (const exception& e) 
    {
        // 此處無法捕獲作業系統層級的記憶體存取錯誤
        cerr << "捕獲到 C++ 異常: " << e.what() << endl;
    }

    return 0;
}

正確的處理和預防方法 (首選)

最好的做法是完全避免越界存取，或者使用 C++ 提供的安全容器和方法，它們會在發生錯誤時拋出可捕獲的 C++ 異常：

1. 使用 std::vector::at()

對於 std::vector 容器，使用 at() 成員函式代替原始的 [] 運算子。當存取越界時，at() 會拋出 **std::out_of_range** 異常，這是標準 C++ 異常，可以被 try-catch 捕獲並安全處理。

#include <vector>
// ... (其他 include)

void safe_vector_access()
{
    std::vector<int> vec = {10, 20}; 
    try
    {
        // 使用 at() 進行邊界檢查
        int value = vec.at(100); 
        std::cout << "值: " << value << std::endl;
    }
    catch (const std::out_of_range& e)
    {
        // 成功捕獲 C++ 異常
        std::cerr << "安全捕獲到越界異常: " << e.what() << std::endl;
    }
}

2. 避免使用原始陣列，改用 std::array

使用 C++11 引入的 std::array 代替 C 風格的陣列。雖然 std::array 的 [] 運算子不進行檢查，但它的 at() 函式同樣會拋出 std::out_of_range 異常。

#include <array>
// ...

void safe_array_access()
{
    std::array<int, 5> arr = {1, 2, 3, 4, 5}; 
    try
    {
        int value = arr.at(5); // 存取越界，拋出異常
    }
    catch (const std::out_of_range& e)
    {
        std::cerr << "std::array 越界捕獲: " << e.what() << std::endl;
    }
}

特定平台結構化異常處理 (進階/非標準)

在 Windows 等特定平台上，可以使用 **結構化異常處理 (Structured Exception Handling, SEH)** 來捕獲由作業系統發出的硬體異常（如存取違規）。這通常涉及使用微軟擴展的 __try 和 __except 關鍵字。此方法是平台非標準的，會犧牲程式碼的可移植性，且一般不推薦作為常規的錯誤處理機制。

C++/CLI List 存取超出範圍

1. 當索引超出範圍時會發生什麼？

在 C++/CLI 的 System::Collections::Generic::List<T> 中，如果你嘗試存取不存在的索引（例如 size 為 1 但存取 index 1），程式不會給予一個預設值（如 0 或 null），而是會立即拋出異常。

• 拋出的異常： System::ArgumentOutOfRangeException
• 結果： 如果沒有進行異常處理，程式將會崩潰 (Crash)。
• 原因： .NET 集合類別具備嚴格的邊界檢查機制，以防止緩衝區溢位或不可預期的記憶體存取。

2. 安全的存取做法

在進行索引存取之前，應始終檢查 Count 屬性，或者使用 try-catch 區塊捕捉潛在錯誤。

// 方法 A：事前檢查（最推薦，效能最好）
if (nums->Count > 1) {
    int value = nums[1];
    // 處理邏輯
} else {
    // 處理索引不足的情況
}

// 方法 B：異常捕捉
try {
    int value = nums[1];
} catch (System::ArgumentOutOfRangeException^ ex) {
    System::Diagnostics::Debug::WriteLine("索引超出範圍！");
}

3. 不同情境下的表現

4. 預防措施總結

• 檢查長度： 永遠在存取 nums[i] 前確認 i < nums->Count。
• 初始化預設值： 如果你希望在找不到時得到一個預設值，可以使用三元運算子：

  int value = (nums->Count > 1) ? nums[1] : 0;

• 使用 Enumerable： 如果使用 LINQ (需引用 System::Linq)，可以使用 ElementAtOrDefault(1)，這在索引不存在時會回傳型別的預設值 (int 為 0)。

C++ std 最大最小值

1. C++ 標準庫函數：std::min 與 std::max

在 C++ 中，最常使用的工具是定義在 <algorithm> 中的 std::min 與 std::max。它們支援基本型別、物件，甚至是初始化列表。

#include <algorithm>
#include <iostream>
#include <vector>

void basic_usage() {
    int a = 10, b = 20;

    // 1. 比較兩個數
    int small = std::min(a, b);
    int large = std::max(a, b);

    // 2. 比較初始化列表 (C++11)
    int lowest = std::min({5, 1, 9, 3}); // 回傳 1

    // 3. std::minmax (C++11) - 同時取得最大與最小值
    auto result = std::minmax({10, 20, 30, 40});
    std::cout << "Min: " << result.first << ", Max: " << result.second;
}

2. 數值極限：FLT_MAX 與 std::numeric_limits

當你需要初始化一個「最小值」變數時，通常會將其設定為該型別能表達的最大正數，以確保第一次比較時一定會被更新。

C 風格極限 (來自 <cfloat> 與 <climits>)

• FLT_MAX: float 的最大值（約 $3.4 \times 10^{38}$）。
• DBL_MAX: double 的最大值。
• INT_MAX: int 的最大值。

C++ 風格極限 (推薦使用 <limits>)

std::numeric_limits 提供了一致且模板化的方式來獲取數值屬性，這在撰寫泛型程式碼時非常有用。

#include <limits>

void limits_example() {
    // 獲取最大值
    float max_f = std::numeric_limits<float>::max();
    int max_i = std::numeric_limits<int>::max();

    // 獲取「最小正數」 (注意：對於浮點數，min() 回傳的是最小正數而非最大負數)
    float min_positive_f = std::numeric_limits<float>::min(); 

    // 獲取「最低值」 (真正的最小負數)
    float lowest_f = std::numeric_limits<float>::lowest();
}

3. 集合中的最大最小值：std::min_element

如果你要處理的是 std::vector 或陣列，則需要使用 std::min_element 或 std::max_element，它們回傳的是迭代器 (Iterator)。

#include <vector>
#include <algorithm>

void collection_example() {
    std::vector<float> scores = {88.5f, 92.0f, 79.5f, 100.0f};

    // 取得最大值的迭代器
    auto it = std::max_element(scores.begin(), scores.end());

    if (it != scores.end()) {
        std::cout << "最高分: " << *it;
    }
}

4. 關鍵差異與陷阱

C++ std 取得圓周率

概述

在 C++ 的標準數學函式庫中，雖然直到 C++20 才正式標準化了 $\pi$ 的常數定義，但在不同的 C++ 版本和編譯器環境下，有幾種常用的方法來獲取圓周率的近似值。

為了確保程式碼的可移植性和準確性，最推薦的做法是使用 C++20 引入的 std::numbers::pi。

1. 使用 C++20 標準常數 (推薦)

從 C++20 開始，標準庫在 <numbers> 標頭檔中提供了精確且類型安全的數學常數。

標頭檔：

• #include <numbers>

使用方式：

#include <iostream>
#include <numbers> // C++20 引入

void use_cpp20_pi()
{
    // std::numbers::pi_v<T> 是模板變數，根據 T 類型提供精確值
    // std::numbers::pi (無 <T>) 等同於 std::numbers::pi_v<double>
    
    double pi_double = std::numbers::pi;
    float pi_float = std::numbers::pi_v<float>;
    long double pi_long_double = std::numbers::pi_v<long double>;

    std::cout.precision(16); // 設置輸出精度
    std::cout << "C++20 (double): " << pi_double << std::endl;
    std::cout << "C++20 (float):  " << pi_float << std::endl;
}

2. 使用傳統 C 語言的巨集 (C++17 及以前)

在 C++20 之前，許多開發者依賴 C 語言的數學函式庫（<cmath> 或 <math.h>）提供的非標準巨集。雖然這些巨集在大多數現代系統上都存在，但它們並非 C++ 標準的一部分，因此不保證在所有環境下都能使用。

標頭檔：

• #include <cmath> (或 <math.h>)

使用方式：

#include <iostream>
#include <cmath> // 傳統 C 數學庫

void use_c_macro_pi()
{
    // M_PI 是最常見的 PI 巨集，通常被定義為 double 類型。
    // 注意：要啟用這個巨集，在某些系統上可能需要定義 _USE_MATH_DEFINES 宏。
    
    #ifdef M_PI
        double pi_value = M_PI;
        std::cout.precision(16);
        std::cout << "C Macro (M_PI): " << pi_value << std::endl;
    #else
        std::cout << "M_PI 巨集未定義。您可能需要定義 _USE_MATH_DEFINES。" << std::endl;
    #endif
}

3. 自行計算或定義

如果無法使用 C++20 或 C 巨集，可以自己定義 $\pi$ 作為一個常數，或使用數學函式計算它（例如 $\arccos(-1)$）。

使用方式：

#include <iostream>
#include <cmath>

void define_or_calculate_pi()
{
    // 透過數學運算定義：
    const double PI_CUSTOM_CALC = std::acos(-1.0);
    
    // 直接定義為常數：
    const double PI_CUSTOM_DEFINE = 3.14159265358979323846; 

    std::cout.precision(16);
    std::cout << "Custom Calculate: " << PI_CUSTOM_CALC << std::endl;
    std::cout << "Custom Define:    " << PI_CUSTOM_DEFINE << std::endl;
}

推薦總結

• **C++20 或更新版本：** 始終使用 std::numbers::pi。
• **C++17 或更早版本：**
  • 如果專案允許，可以自行定義 const double PI = 3.14159...;
  • 或嘗試使用 M_PI 巨集，但需注意其非標準性。

計算 List 的標準差

範例程式

#include <cmath>
#include <iostream>
using namespace System;
using namespace System::Collections::Generic;

int main()
{
    // 建立測試資料
    Dictionary<int, List<float>^>^ data = gcnew Dictionary<int, List<float>^>();
    data->Add(1, gcnew List<float>({ 1.2f, 2.3f, 3.4f }));
    data->Add(2, gcnew List<float>({ 4.5f, 5.5f, 6.5f, 7.5f }));
    data->Add(3, gcnew List<float>()); // 測試空清單

    // 計算每個 key 的標準差
    for each (KeyValuePair<int, List<float>^> entry in data)
    {
        int key = entry.Key;
        List<float>^ values = entry.Value;

        if (values == nullptr || values->Count == 0)
        {
            Console::WriteLine("Key {0}: 無資料", key);
            continue;
        }

        // 計算平均值
        double sum = 0.0;
        for each (float v in values)
        {
            sum += v;
        }
        double mean = sum / values->Count;

        // 計算變異數（母體變異數）
        double variance = 0.0;
        for each (float v in values)
        {
            double diff = v - mean;
            variance += diff * diff;
        }
        variance /= values->Count; // 若要樣本變異數，改為 (values->Count - 1)

        // 標準差
        double stddev = Math::Sqrt(variance);

        Console::WriteLine("Key {0}: 標準差 = {1:F4}", key, stddev);
    }

    return 0;
}

說明

• data：儲存每組浮點數列表的字典，key 為整數。
• mean：所有元素的平均值。
• variance：每個元素與平均值差的平方平均值。
• stddev：標準差為變異數的平方根。
• 若需樣本標準差，請將分母改為 values->Count - 1。

輸出結果範例

Key 1: 標準差 = 0.8981
Key 2: 標準差 = 1.1180
Key 3: 無資料

std::sort

1. 基本用法

std::sort 是 C++ 標準模板庫 (STL) 中最常用的排序演算法。它位於 <algorithm> 標頭檔中，預設會將範圍內的元素以升冪 (Ascending) 進行排序。

#include <algorithm>
#include <vector>
#include <iostream>

void basic_sort() {
    std::vector<int> nums = {5, 2, 9, 1, 5, 6};
    
    // 排序範圍：從開始迭代器到結束迭代器
    std::sort(nums.begin(), nums.end());
    
    // 結果: 1, 2, 5, 5, 6, 9
}

2. 自定義排序準則 (降冪或特定條件)

你可以透過傳入第三個參數（比較函式或 Lambda 表達式）來改變排序邏輯。

// 1. 使用預定義的 std::greater 進行降冪
std::sort(nums.begin(), nums.end(), std::greater<int>());

// 2. 使用 Lambda 表達式自定義邏輯
std::sort(nums.begin(), nums.end(), [](int a, int b) {
    return a > b; // 當回傳 true 時，a 會排在 b 前面
});

3. 結構體或類別排序

對於自定義類型，必須提供比較邏輯，否則編譯器會因為不知道如何比較大小而報錯。

struct Student {
    std::string name;
    int score;
};

void sort_students() {
    std::vector<Student> students = {{"Alice", 90}, {"Bob", 85}, {"Charlie", 95}};
    
    // 依分數從高到低排序
    std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) {
        return a.score > b.score;
    });
}

4. 底層原理：內省排序 (Introsort)

std::sort 並非單一的排序演算法，而是一種混合演算法，旨在結合各演算法的優點並避免最壞情況發生。其運作邏輯如下：

• 快速排序 (Quick Sort)：初始使用快速排序，速度最快。
• 堆積排序 (Heap Sort)：當遞迴深度過深（可能導致快速排序退化至 $O(n^2)$）時，自動切換為堆積排序，保證 $O(n \log n)$。
• 插入排序 (Insertion Sort)：當資料區間縮小到一定程度（通常為 16 個元素以內）時，切換為插入排序，利用其在小數據量下的極低常數項效能。

效能與特性總結

點與直線方程式的相對位置判斷

1. 數學原理：代入點值

給定直線方程式 $ax + by + c = 0$ 以及一個點 $P(x_0, y_0)$，判斷點與線的關係最快的方法是計算 距離係數 $d$：

$$d = a \cdot x_0 + b \cdot y_0 + c$$

根據 $d$ 的正負號，我們可以判斷點在直線的哪一側。但要注意的是，「上方」或「右方」的定義會受到 $a$ 和 $b$ 正負號的影響。

2. 判斷點在線的上方 (y 較小)

在大多數電腦圖形學座標系中，y 軸向下為正（y 越小代表越靠畫面上方）。若要判斷點 $P$ 是否在線的上方，我們比較點的 $y_0$ 與直線上相同 $x_0$ 時的 $y_{line}$。

// 直線方程：ax + by + c = 0  =>  y = (-ax - c) / b
bool isAbove(std::array<float, 3> line, float x0, float y0) {
    float a = line[0];
    float b = line[1];
    float c = line[2];

    // 若 b 為 0，代表垂直線，無法定義上下
    if (std::abs(b) < 1e-6) return false;

    float y_on_line = (-a * x0 - c) / b;
    
    // y 較小代表在上方
    return y0 < y_on_line;
}

3. 判斷點在線的右方 (x 較大)

同理，我們比較點的 $x_0$ 與直線上相同 $y_0$ 時的 $x_{line}$。

// 直線方程：ax + by + c = 0  =>  x = (-by - c) / a
bool isRight(std::array<float, 3> line, float x0, float y0) {
    float a = line[0];
    float b = line[1];
    float c = line[2];

    // 若 a 為 0，代表水平線，無法定義左右
    if (std::abs(a) < 1e-6) return false;

    float x_on_line = (-b * y0 - c) / a;

    // x 較大代表在右方
    return x0 > x_on_line;
}

4. 快速判斷表 (假設標準化後)

如果你能確保 $b < 0$ (透過將整個方程式乘上 -1)，那麼 $ax + by + c > 0$ 直接就代表點在線的上方。以下是通用邏輯：

實作注意事項

• 浮點數精度： 判斷 a 或 b 是否為 0 時，建議使用一個極小值（如 1e-6）進行比較，避免精確度問題。
• 垂直與水平線： 垂直線 ($b=0$) 沒有「上方」的概念；水平線 ($a=0$) 沒有「右方」的概念。在呼叫函式前應先確認直線類型。
• 座標系： 以上邏輯適用於一般數學座標系或 Windows/OpenCV 常見的 y 軸向下座標系（需確認 y 較小是否符合你的「上方」定義）。

直線方向性判斷

1. 判斷邏輯：斜率與係數比較

給定直線方程式 $ax + by + c = 0$，判斷它是偏向「橫線」還是「直線」，最直觀的方法是看它與座標軸的夾角。以 45度 為分界線，等同於比較 $|a|$ 與 $|b|$ 的大小。

• 橫線偏向 (Horizontal-ish)：與 X 軸夾角 < 45度。此時 $x$ 的變化對 $y$ 的影響較小，即 $|a| < |b|$。
• 直線偏向 (Vertical-ish)：與 X 軸夾角 > 45度。此時 $y$ 的變化對 $x$ 的影響較小，即 $|a| > |b|$。

2. 程式碼實作

使用 std::abs 比較 line[0] ($a$) 與 line[1] ($b$) 的絕對值。

#include <iostream>
#include <array>
#include <cmath>

enum class LineOrientation {
    Horizontal, // 橫線 (< 45度)
    Vertical,   // 直線 (> 45度)
    Diagonal    // 剛好 45度
};

LineOrientation checkOrientation(std::array<float, 3> line) {
    float a = std::abs(line[0]);
    float b = std::abs(line[1]);

    if (a < b) {
        return LineOrientation::Horizontal;
    } else if (a > b) {
        return LineOrientation::Vertical;
    } else {
        return LineOrientation::Diagonal;
    }
}

3. 為什麼比較 |a| 和 |b| 就足夠了？

從斜率公式 $m = -\frac{a}{b}$ 來看：

• 當 夾角為 45度 時，斜率 $|m| = 1$，此時 $|a| = |b|$。
• 當 夾角 < 45度 時，斜率 $|m| < 1$，這意味著分子小於分母，即 $|a| < |b|$。這是一條較為平坦的線（橫線）。
• 當 夾角 > 45度 時，斜率 $|m| > 1$，這意味著分子大於分母，即 $|a| > |b|$。這是一條較為陡峭的線（直線）。

4. 判定基準表

實務建議

在進行點對線的位置判斷時，建議先執行此檢查：

• 如果是橫線 ($|a| < |b|$)，使用 y 座標 來判斷上下比較穩定（因為 $b$ 遠離 0，除法較安全）。
• 如果是直線 ($|a| > |b|$)，使用 x 座標 來判斷左右比較穩定（因為 $a$ 遠離 0，除法較安全）。

C++ 模板

1. 什麼是模板 (Template)？

在 C++ 中，模板 (Template) 是一種泛型編程的工具，允許我們在編寫函數或類別時，不指定具體的資料型別，從而使程式碼更具重用性。模板有助於在單一程式碼中處理不同型別的資料，避免重複的函數或類別定義。

2. 函數模板 (Function Template)

函數模板允許我們撰寫可以處理不同型別的函數。函數模板的語法如下：

template <typename T>
T add(T a, T b) {
    return a + b;
}

在此例中，add 函數可以處理任何支持加法操作的型別，如 int、float 或 double。

使用時，可以這樣呼叫：

int result = add(3, 4);  // 使用 int 型別
double result2 = add(3.5, 2.7);  // 使用 double 型別

3. 類別模板 (Class Template)

類別模板允許我們建立可以適用於多種型別的類別。類別模板的語法如下：

template <typename T>
class MyClass {
private:
    T data;
public:
    MyClass(T data) : data(data) {}
    T getData() { return data; }
};

此例中的 MyClass 類別可以使用任何型別的資料作為 data。

使用時可以這樣：

MyClass<int> obj1(5);      // int 型別
MyClass<double> obj2(3.14);  // double 型別

4. 多個模板參數

模板可以接受多個參數，例如：

template <typename T, typename U>
class Pair {
private:
    T first;
    U second;
public:
    Pair(T first, U second) : first(first), second(second) {}
    T getFirst() { return first; }
    U getSecond() { return second; }
};

這樣的模板類別可以存儲兩種不同型別的資料：

Pair<int, double> pair1(1, 3.14);

5. 模板特化 (Template Specialization)

模板特化允許我們對特定型別的模板進行特別定義。例如：

template <>
class MyClass<int> {
public:
    MyClass(int data) { /* 特化行為 */ }
};

這段程式碼特化了 MyClass 對 int 型別的行為，使其與其他型別不同。

6. 非型別模板參數 (Non-Type Template Parameters)

模板還可以接受非型別的參數，例如常數值：

template <typename T, int Size>
class Array {
private:
    T data[Size];
public:
    int getSize() const { return Size; }
};

在這裡，Size 是一個非型別參數，表示陣列的大小。

使用範例：

Array<int, 10> arr;  // 建立大小為 10 的 int 型別陣列

7. 結論

C++ 模板功能強大，使得程式碼可以更具泛用性並減少重複。了解如何利用函數模板、類別模板及模板特化等技術，將大大提升程式設計的彈性與效能。

C++ Class 互相參照

// ClassA.h
#ifndef CLASSA_H
#define CLASSA_H

// 前向宣告 ClassB
class ClassB;

class ClassA {
public:
    ClassA();
    void setB(ClassB* b); // 設定指向 ClassB 的指標
    void showBData();      // 顯示 ClassB 的數據

private:
    ClassB* b; // 指向 ClassB 的指標
};

#endif
        

// ClassB.h
#ifndef CLASSB_H
#define CLASSB_H

// 前向宣告 ClassA
class ClassA;

class ClassB {
public:
    ClassB(int data);
    int getData();         // 取得數據
    void setA(ClassA* a);  // 設定指向 ClassA 的指標
    void showAInfo();      // 顯示 ClassA 的資訊

private:
    int data;
    ClassA* a; // 指向 ClassA 的指標
};

#endif
        

#include "ClassA.h"
#include "ClassB.h"
#include <iostream>

ClassA::ClassA() : b(nullptr) {}

void ClassA::setB(ClassB* b) {
    this->b = b;
}

void ClassA::showBData() {
    if (b != nullptr) {
        std::cout << "ClassB data: " << b->getData() << std::endl;
    }
}
        

#include "ClassB.h"
#include "ClassA.h"
#include <iostream>

ClassB::ClassB(int data) : data(data), a(nullptr) {}

int ClassB::getData() {
    return data;
}

void ClassB::setA(ClassA* a) {
    this->a = a;
}

void ClassB::showAInfo() {
    if (a != nullptr) {
        a->showBData();
    }
}
        

C++ Friend

在 C++ 中，friend 關鍵字可以用於函數或類別，以允許其他函數或類別訪問類別的私有成員（private）和保護成員（protected）。這樣的設計可讓外部函數或類別進行操作，而不違反封裝原則。

Friend 函數是一種被授權訪問另一類別的私有成員和保護成員的外部函數。在類別內部聲明時，以 friend 關鍵字修飾即可。

範例如下：

#include <iostream>
using namespace std;

class Box {
private:
    double width;

public:
    Box(double w) : width(w) {}

    // 聲明 friend 函數
    friend void showWidth(Box &b);
};

// friend 函數定義，能訪問 Box 類別的私有成員
void showWidth(Box &b) {
    cout << "Box 寬度: " << b.width << endl;
}

int main() {
    Box box(10.5);
    showWidth(box);  // 訪問私有成員 width
    return 0;
}
        

在此範例中，showWidth 函數雖然是 Box 類別外的普通函數，但因為被聲明為 friend 函數，仍然能夠訪問 Box 類別的私有成員 width。

Friend 類別允許某一類別訪問另一類別的所有成員。這樣的設置在類別需要緊密協作時非常有用，但使用時應該謹慎，以避免過多暴露內部細節。

範例如下：

#include <iostream>
using namespace std;

class Square;  // 前置聲明

class Rectangle {
private:
    double width, height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    // 聲明 Square 類別為 friend
    friend class Square;
};

class Square {
public:
    double areaOfRectangle(Rectangle &rect) {
        return rect.width * rect.height;
    }
};

int main() {
    Rectangle rect(5.0, 3.0);
    Square square;
    cout << "矩形面積: " << square.areaOfRectangle(rect) << endl;
    return 0;
}
        

在此範例中，Square 類別被宣告為 Rectangle 類別的 friend 類別，因此 Square 類別中的成員函數可以直接訪問 Rectangle 類別的私有成員 width 和 height。

• 數據封裝：允許某些函數或類別進行直接操作，而不破壞類別內部封裝，適合需要高耦合的類別間通信。
• 運算符重載：可以使用 friend 函數來重載運算符，使其能夠訪問類別內部的私有或保護成員。
• 特定訪問需求：在不破壞封裝的前提下，允許外部函數或類別進行有限的訪問，適合庫開發中的特定設計。

在 C++ 中使用 friend 函數和 friend 類別需謹慎，過多使用會破壞類別的封裝性。因此，friend 關鍵字通常只在設計需要密切配合的類別或函數時使用。

C++ 逐行讀取檔案

概述

在 C++ 中，最標準和推薦的逐行讀取文字檔案的方法是使用標準程式庫中的檔案串流類別 std::ifstream 配合 std::getline 函式。

std::ifstream 負責開啟和管理檔案串流，而 std::getline 則負責從串流中讀取一整行文字（直到遇到換行符 \n），並將其儲存到 std::string 物件中。

程式碼範例

以下是一個完整的 C++ 範例，演示如何逐行讀取一個名為 example.txt 的檔案內容。

#include <iostream>
#include <fstream> // 包含檔案串流函式庫
#include <string>  // 包含字串類別

using namespace std; 

void read_file_line_by_line(const string& filename)
{
    // 1. 建立 std::ifstream 物件
    // 嘗試開啟指定的檔案。
    ifstream input_file(filename); 
    
    // 2. 檢查檔案是否成功開啟
    if (!input_file.is_open()) 
    {
        cerr << "錯誤: 無法開啟檔案 " << filename << endl;
        return;
    }
    
    string line;
    int line_number = 1;
    
    // 3. 使用 std::getline 函式進行逐行讀取
    // 循環條件 (getline(stream, string)) 在每次讀取成功時返回 true。
    // 當到達檔案結尾 (EOF) 或發生錯誤時，返回 false，循環結束。
    while (getline(input_file, line)) 
    {
        cout << "第 " << line_number << " 行: " << line << endl;
        line_number++;
    }
    
    // 4. 關閉檔案串流
    // 當 input_file 物件超出其作用域時，析構函式會自動關閉檔案，
    // 但明確呼叫 close() 也是可接受的做法。
    input_file.close(); 
    
    cout << "檔案讀取完成。" << endl;
}

int main()
{
    read_file_line_by_line("example.txt");
    return 0;
}

關鍵概念

• std::ifstream：繼承自 std::istream，專門用於處理檔案輸入串流。在建構時（或使用 open() 函式時）會嘗試開啟檔案。
• input_file.is_open()：這是標準的錯誤檢查。如果檔案不存在或程式沒有讀取權限，這個函式會返回 false。
• std::getline(stream, string)：
  • 它從第一個參數（輸入串流，例如 input_file）中讀取資料。
  • 它將讀到的所有字元（包括空白）儲存到第二個參數（std::string 物件，例如 line）中。
  • 它會讀取並丟棄換行符 \n，因此 line 變數中不包含換行符。
  • 當讀取成功時，它會返回輸入串流物件本身，在條件判斷中會被轉換為 true。
• 自動資源管理： 在 C++ 中，當 std::ifstream 物件 (input_file) 被銷毀時，它會自動呼叫其析構函式來關閉底層的檔案控制代碼，這是一種可靠的資源管理方式（RAII, Resource Acquisition Is Initialization）。

C++ 逐行寫入檔案與欄位對齊

概述

在 C++ 中，要將資料結構（例如從 std::vector<std::string> 中讀取的 tokens）逐行寫入檔案，並確保每個欄位（token）在行中保持固定寬度的對齊，需要使用 **std::ofstream** 配合 **I/O 串流操縱器 (Stream Manipulators)** 來控制輸出格式。

主要的格式控制工具有：

• std::setw(width)：設定下一個輸出欄位的最小寬度。
• std::left / std::right：設定文字在欄位中的對齊方式（靠左或靠右）。

程式碼範例

以下是一個 C++ 範例，示範如何將一個包含多個欄位的二維數據結構（使用 std::vector<std::vector<std::string>> 模擬）寫入檔案，並確保每個 token 欄位的寬度固定為 15 個字元且靠左對齊。

#include <iostream>
#include <fstream> // 包含檔案輸出串流
#include <string>
#include <vector>
#include <iomanip> // 包含 I/O 串流操縱器 (setw, left/right)

using namespace std;

// 模擬一個二維資料結構，每行包含多個欄位 (tokens)
using TableData = vector<vector<string>>;

void write_aligned_data(const string& filename, const TableData& data, int column_width)
{
    // 1. 建立 std::ofstream 物件並開啟檔案
    ofstream output_file(filename); 
    
    // 2. 檢查檔案是否成功開啟
    if (!output_file.is_open()) 
    {
        cerr << "錯誤: 無法開啟檔案 " << filename << " 進行寫入。" << endl;
        return;
    }

    // 設定全域對齊方式：靠左對齊 (L-Justified)
    output_file << left; 
    
    // 3. 逐行寫入資料
    for (const auto& row : data) 
    {
        // 4. 逐 token 寫入並設定寬度
        for (const auto& token : row) 
        {
            // setw(width) 只影響緊隨其後的下一個輸出項
            output_file << setw(column_width) << token;
        }
        
        // 5. 行結束後插入換行符，開始新的一行
        output_file << "\n"; 
    }
    
    // 6. 關閉檔案串流
    output_file.close(); 
    
    cout << "資料已成功寫入檔案: " << filename << endl;
}

int main()
{
    // 範例資料：包含四行，每行三個欄位
    TableData data = {
        {"Name", "Item", "Price"},
        {"Alice", "Book", "19.99"},
        {"BobJohnson", "PenSet", "4.50"},
        {"Charlie", "Notebook", "800.75"}
    };
    
    const int COLUMN_WIDTH = 15; // 定義每個欄位的寬度
    
    write_aligned_data("output_aligned.txt", data, COLUMN_WIDTH);
    
    return 0;
}

關鍵技術解析

• std::ofstream：檔案輸出串流類別。用於將資料寫入檔案。
• #include <iomanip>：此標頭檔必須包含，才能使用 I/O 串流操縱器。
• output_file << left;：
  • 設定對齊模式為左對齊。此設定一旦應用於串流，就會持續有效，直到被 right 或 internal 覆蓋。
• output_file << setw(column_width) << token;：
  • setw(width)：設定接下來要輸出的資料的最小寬度。如果輸出的字串長度小於設定的寬度，則會用空白字元填充。
  • 重要： setw 只對緊隨其後的下一個輸出操作有效，因此必須在每次輸出 token 之前呼叫一次。
• 字元寬度： 請注意，當處理非 ASCII 字元（如中文）時，C++ 標準串流對於多位元組字元集（如 UTF-8）的寬度計算可能不準確。在處理國際化文字時，可能需要更複雜的函式庫來正確計算視覺寬度。上述範例適用於 ASCII 或單一寬度字元。

vcpkg C++ 套件管理器

1. 下載 vcpkg 原始碼

vcpkg 並非透過安裝檔安裝，而是直接從 GitHub 複製原始碼到本地。建議將其放置在磁碟根目錄（如 C:\vcpkg），避免路徑過長或包含空格。請開啟終端機（CMD 或 PowerShell）執行：

git clone https://github.com/microsoft/vcpkg.git
cd vcpkg

2. 進行初始編譯 (Bootstrap)

下載後需要執行腳本來編譯 vcpkg 的執行檔，這會生成 vcpkg.exe：

• Windows: 執行 .\bootstrap-vcpkg.bat
• macOS / Linux: 執行 ./bootstrap-vcpkg.sh

3. 整合至開發環境

這一步能讓開發工具（如 Visual Studio）自動辨識 vcpkg 安裝的套件：

• Visual Studio (MSBuild) 整合:

  執行 .\vcpkg integrate install。完成後，你在 VS 中新建的專案就能直接 #include 套件，無需手動設定路徑。

• CMake 整合:

  在執行 CMake 配置時，加入以下參數來連結 vcpkg 的工具鏈檔案：

  -DCMAKE_TOOLCHAIN_FILE=[vcpkg路徑]/scripts/buildsystems/vcpkg.cmake

常用指令比較表

設定環境變數 (建議)

為了方便在任何路徑使用 vcpkg，建議將 vcpkg 的資料夾路徑加入系統的 PATH 環境變數中。此外，若希望預設安裝 64 位元套件，可以新增環境變數 VCPKG_DEFAULT_TRIPLET 並設定其值為 x64-windows。

注意事項

在 Windows 上使用 vcpkg 前，請確保已安裝 Visual Studio 2015 或更新版本，並勾選「使用 C++ 的桌面開發」工作負載（包含英文語言包），否則編譯套件時可能會出現錯誤。

週邊控制程式開發

定義

週邊控制程式是用來與電腦或主機連接的外部硬體裝置（例如：印表機、掃描器、馬達、PLC、感測器等）進行通訊與操作的應用程式。

常見通訊介面

• USB
• Serial（RS-232 / RS-485）
• Bluetooth
• Wi-Fi / TCP Socket
• I2C / SPI（多用於嵌入式）

常見開發語言與環境

範例一：使用 Python 控制串列埠

import serial

ser = serial.Serial('COM3', 9600, timeout=1)
ser.write(b'ON\n')  # 傳送控制命令
response = ser.readline()
print("裝置回應：", response.decode())
ser.close()

範例二：C# 控制 COM Port 裝置

SerialPort port = new SerialPort("COM4", 9600);
port.Open();
port.WriteLine("MOVE 100");
string response = port.ReadLine();
Console.WriteLine("回應：" + response);
port.Close();

範例三：控制 USB HID 裝置

• 可用 libusb（C）、pyusb（Python）、HidSharp（C#）等函式庫
• 需掌握 USB Protocol 與裝置 Descriptor 結構

範例四：TCP 通訊控制週邊

import socket

s = socket.socket()
s.connect(('192.168.1.100', 5000))
s.sendall(b'START\n')
data = s.recv(1024)
print("回應:", data.decode())
s.close()

應用案例

• PLC 自動化設備控制
• 3D 印表機 / 雷射雕刻機
• 生產線掃碼器、感測器收集
• POS 系統週邊整合（發票機、條碼機）

注意事項

• 需瞭解裝置的通訊協定（Protocol）與命令格式
• 有些裝置需驅動程式或 SDK 才能通訊
• 通訊延遲、同步處理與錯誤偵測要妥善設計

結論

週邊控制程式開發需依據裝置的介面與協定選擇適合的語言與函式庫，結合串列、USB、網路等通訊方式，可廣泛應用於各種自動化與工控領域。

Barcode Reader 程式開發

常見平台支援

• Android / iOS
• Windows 桌面應用程式
• Web 前端（HTML5 + JavaScript）
• 嵌入式裝置（如樹莓派）

常用條碼類型

• 1D 條碼：EAN-13, Code 39, Code 128, UPC
• 2D 條碼：QR Code, Data Matrix, PDF417

常見開發套件與工具

• ZXing（Java、Android、C++、JavaScript）
• ZBar（C / Python / Linux / Android）
• Dynamsoft Barcode Reader SDK（商用，支援多語言）
• ML Kit Barcode Scanning（Android / Firebase）
• jsQR、QuaggaJS（Web 應用）

Android 開發範例（使用 ZXing）

// build.gradle
implementation 'com.journeyapps:zxing-android-embedded:4.3.0'

// Java 呼叫掃描畫面
IntentIntegrator integrator = new IntentIntegrator(this);
integrator.setPrompt("請掃描條碼");
integrator.setBeepEnabled(true);
integrator.setOrientationLocked(false);
integrator.initiateScan();

// onActivityResult 接收結果
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    IntentResult result = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
    if(result != null) {
        if(result.getContents() != null) {
            String barcode = result.getContents();
            Log.d("條碼內容", barcode);
        }
    }
}

Web 開發範例（使用 QuaggaJS）

<script src="https://unpkg.com/[email protected]/dist/quagga.min.js"></script>

<script>
Quagga.init({
    inputStream: {
        name: "Live",
        type: "LiveStream",
        target: document.querySelector('#scanner')
    },
    decoder: {
        readers: ["code_128_reader", "ean_reader", "upc_reader"]
    }
}, function(err) {
    if (!err) {
        Quagga.start();
    }
});

Quagga.onDetected(function(result) {
    console.log("條碼內容: ", result.codeResult.code);
});
</script>

平台與套件比較

結論

開發 Barcode Reader 可根據平台選擇合適的開源套件，ZXing 是最廣泛支援的選擇，Web 可用 QuaggaJS，若需商業級支援則可考慮 Dynamsoft Barcode SDK。

條碼帶控制字元

基本原理

條碼讀取器本質上是模擬鍵盤輸入的裝置。當掃描到條碼時，它會將條碼中的內容「輸出」成字元流，就像是鍵盤輸入一樣。

因此，條碼中是可以包含控制碼（Control Code），但需要條碼讀取器與條碼格式支援才行。

條碼中常見的控制碼類型

• Ctrl+A ~ Ctrl+Z（ASCII 0x01 ~ 0x1A）
• Enter（CR，ASCII 0x0D）
• Tab（ASCII 0x09）
• ESC（ASCII 0x1B）

條件一：條碼格式需支援控制碼

例如以下格式可編碼控制碼：

• Code 128：支援完整 ASCII 128 字元（包含 Ctrl 字元）
• QR Code：支援所有 Unicode / Binary 資料

條件二：條碼編碼工具需支援嵌入控制碼

部分條碼產生器允許嵌入特殊字元，例如：

• \x0D 表示 Enter
• \x03 表示 Ctrl-C
• ^C、[CTRL+C] 等特殊語法依工具而定

條件三：條碼掃描器需支援輸出控制碼

多數專業條碼機（例如 Zebra、Honeywell）在出廠時預設不啟用控制碼輸出，需透過掃描器提供的「設定條碼」啟用：

• Enable control character transmission
• Enable function key emulation
• Interpret Code 128 FNC1 as ASCII

條件四：作業系統與應用程式需正確接收

例如在 Windows 應用程式中：

• 若條碼輸出 Ctrl+O，應用程式需支援 keydown 與 Ctrl 配合的快捷鍵處理。
• 若條碼輸出的是特殊組合鍵（如 Alt-C），大多應用程式需從低階輸入 API 處理。

示例：編碼 Ctrl-C 的條碼內容

用 Code128 編碼 ASCII 3：

輸入：\x03Hello World

條碼掃描後會觸發 Ctrl+C 再輸出 "Hello World"。

結論

• 條碼可以帶控制碼（如 Ctrl、Alt），但需滿足條件：
• 條碼格式（如 Code128）支援
• 產生器正確編碼
• 掃描器正確設定
• 應用程式能正確接收

Android 開發

Android 開發平台

平台簡介

開發工具

應用程式生命週期

優勢

學習資源

結語

Chromebook 使用 Android Studio

安裝步驟

1. 開啟 設定 → 開發人員 → Linux 開發環境（Crostini），分配至少 20GB 磁碟空間與 8GB 記憶體。
2. 更新套件：

   sudo apt update && sudo apt upgrade -y
   sudo apt install -y wget curl unzip zip git ca-certificates

3. 安裝 JDK（建議版本 17）：

   sudo apt install -y openjdk-17-jdk

4. 下載並安裝 Android Studio：

   sudo dpkg -i ~/Downloads/android-studio-*.deb || sudo apt -f install -y
   android-studio

   或解壓縮 .tar.gz：

   tar -xzf ~/Downloads/android-studio-*.tar.gz -C ~
   ~/android-studio/bin/studio.sh

5. 依照安裝精靈完成 SDK 與工具設定。

使用實體裝置測試

1. 在 ChromeOS：設定 → 開發人員 → Linux → USB 裝置，勾選手機共享給 Linux。
2. 手機開啟 開發人員選項 → USB 偵錯，連線後允許 RSA 指紋。
3. Linux 環境確認裝置：

   sudo apt install -y android-sdk-platform-tools
   adb kill-server
   adb start-server
   adb devices

效能與模擬器建議

• 大部分 Chromebook 模擬器效能不足，建議優先使用實體手機。
• 若必須使用模擬器，選擇 x86_64 版本並降低解析度與 RAM 配置。
• 避免同時執行過多應用程式，確保 Crostini 容器有足夠資源。

替代方案

• VS Code + Android SDK：較輕量，適合 Flutter / React Native 開發。
• 雲端開發環境：如 GitHub Codespaces、Gitpod，降低本機負擔。

Chromebook 使用 VS Code + Android SDK

安裝 VS Code

1. 在 ChromeOS 開啟 設定 → 開發人員 → Linux 開發環境（Crostini）。
2. 下載 VS Code Linux 版（.deb 檔），並於 Linux 容器安裝：

   sudo dpkg -i ~/Downloads/code_*.deb || sudo apt -f install -y

3. 啟動 VS Code，安裝常用擴充套件（如 Kotlin、Flutter、Java Extension Pack）。

安裝 Android SDK 與工具

1. 安裝必要套件：

   sudo apt update && sudo apt install -y openjdk-17-jdk unzip git

2. 下載 Android SDK Command Line Tools：

   wget https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
   unzip commandlinetools-linux-*_latest.zip -d ~/android-sdk

3. 設定環境變數（可加入 ~/.bashrc 或 ~/.zshrc）：

   export ANDROID_SDK_ROOT=$HOME/android-sdk
   export PATH=$ANDROID_SDK_ROOT/cmdline-tools/bin:$ANDROID_SDK_ROOT/platform-tools:$PATH

4. 使用 sdkmanager 安裝平台工具與必要套件：

   sdkmanager "platform-tools" "platforms;android-34" "build-tools;34.0.0"

連接實體手機測試

1. 在 ChromeOS：設定 → 開發人員 → Linux → USB 裝置，勾選手機共享。
2. 手機開啟 開發人員選項 → USB 偵錯。
3. Linux 容器確認裝置：

   adb devices

   看到 device 即可部署測試。

在 VS Code 中開發

• 建立 Kotlin / Java 專案，或使用 Flutter / React Native 框架。
• 在 VS Code 中安裝對應擴充套件，支援語法高亮與除錯。
• 以 adb install 或框架 CLI（如 flutter run）將 App 部署至手機。

適合情境

• Chromebook 硬體資源有限，不適合跑 Android Studio。
• 需要輕量級 IDE，並透過實體手機測試。
• 跨平台開發（Flutter、React Native）效率更高。

Android App 範例

建立新專案

在 Android Studio 中建立一個新的專案，選擇 "Empty Activity" 模板，然後設定專案名稱及其他基本資訊。

編寫介面 (activity_main.xml)

在 res/layout/activity_main.xml 檔案中設計簡單的使用者介面，例如包含一個按鈕和一個文字顯示區域：

        <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:orientation="vertical"
            android:gravity="center">
        
            <Button
                android:id="@+id/button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="點我" />
        
            <TextView
                android:id="@+id/textView"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="Hello, World!"
                android:layout_marginTop="20dp" />
        
        </LinearLayout>

編寫程式邏輯 (MainActivity.java)

在 MainActivity.java 中，設定按鈕的點擊事件，使其更改文字顯示區域的內容：

        package com.example.simpleapp;

        import android.os.Bundle;
        import android.view.View;
        import android.widget.Button;
        import android.widget.TextView;
        import androidx.appcompat.app.AppCompatActivity;

        public class MainActivity extends AppCompatActivity {
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);

                Button button = findViewById(R.id.button);
                TextView textView = findViewById(R.id.textView);

                button.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        textView.setText("你點了按鈕！");
                    }
                });
            }
        }
    

執行應用程式

在 Android Studio 中點擊執行按鈕，即可在模擬器或連接的實體裝置上測試應用程式。點擊按鈕後，文字將更改為 "你點了按鈕！"。

Android 取得目前GPS位置

權限設定

在 AndroidManifest.xml 中加入以下權限：

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

檢查與請求權限（Android 6.0 以上）

if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
    != PackageManager.PERMISSION_GRANTED) {
    ActivityCompat.requestPermissions(this,
        new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 1);
}

取得 LocationManager

LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

取得目前位置

LocationListener locationListener = new LocationListener() {
    @Override
    public void onLocationChanged(@NonNull Location location) {
        double latitude = location.getLatitude();
        double longitude = location.getLongitude();
        Log.d("GPS", "Latitude: " + latitude + ", Longitude: " + longitude);
    }
};

if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
    == PackageManager.PERMISSION_GRANTED) {
    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 
        1000, // 毫秒間隔
        1,    // 最小距離(公尺)
        locationListener);
}

使用 FusedLocationProviderClient（推薦）

FusedLocationProviderClient fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);

if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
    == PackageManager.PERMISSION_GRANTED) {
    fusedLocationClient.getLastLocation()
        .addOnSuccessListener(this, location -> {
            if (location != null) {
                double lat = location.getLatitude();
                double lng = location.getLongitude();
                Log.d("GPS", "Lat: " + lat + ", Lng: " + lng);
            }
        });
}

音控 Android App

基本概念

要實作一個類似 Siri 或 Hey Google 的語音助理功能，你需要結合以下元件：

• 語音辨識（Speech Recognition）
• 語音喚醒（Voice Trigger，可選）
• 語音合成（Text To Speech, TTS）
• 背景服務（Foreground Service）

加入必要權限

<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.INTERNET"/>

語音辨識初始化

SpeechRecognizer recognizer = SpeechRecognizer.createSpeechRecognizer(this);
Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());

recognizer.setRecognitionListener(new RecognitionListener() {
    @Override
    public void onResults(Bundle results) {
        ArrayList<String> matches = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
        if (matches != null && !matches.isEmpty()) {
            String command = matches.get(0).toLowerCase();
            if (command.contains("打開相機")) {
                // 執行操作
            }
        }
    }
    // 其他必要的覆寫方法略
});

recognizer.startListening(intent);

語音合成（回應用戶）

TextToSpeech tts = new TextToSpeech(this, status -> {
    if (status == TextToSpeech.SUCCESS) {
        tts.setLanguage(Locale.TAIWAN);
        tts.speak("你好，我在這裡。", TextToSpeech.QUEUE_FLUSH, null, null);
    }
});

常駐背景監聽（選擇性）

如需常駐背景並語音喚醒，需使用：

• 前景服務（Foreground Service）
• 第三方喚醒庫，例如 Snowboy（已停用）、Porcupine（Picovoice）

注意事項

• SpeechRecognizer 無法在背景連續監聽。
• 建議搭配 Hotword Engine 或使用外部語音 SDK。
• 從 Android 10 起需動態請求 RECORD_AUDIO 權限。

常駐背景監聽

目的

常駐背景監聽的目標，是讓 App 即使在未開啟畫面時也能偵測語音喚醒詞（如「Hey 助理」），並啟動對應功能。

挑戰

• Android 不允許 SpeechRecognizer 長時間背景運行。
• 官方語音辨識 只能短時間收音 並需主動喚起。
• 語音喚醒需使用特殊算法或外部 SDK。

解法架構

1. 使用 前景服務（Foreground Service）保持持續運作。
2. 語音喚醒採用 Porcupine 等離線 Hotword Engine。
3. 喚醒成功後，啟動 SpeechRecognizer 辨識完整語音命令。

Step 1: 前景服務建立

public class VoiceService extends Service {
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Notification notification = new NotificationCompat.Builder(this, "voice_channel")
            .setContentTitle("語音助手運作中")
            .setSmallIcon(R.drawable.ic_mic)
            .build();
        startForeground(1, notification);

        // 初始化 Hotword 檢測
        startHotwordDetection();
        return START_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

Step 2: 建立通知頻道（Android 8+）

NotificationChannel channel = new NotificationChannel("voice_channel",
    "Voice Assistant", NotificationManager.IMPORTANCE_LOW);
NotificationManager manager = getSystemService(NotificationManager.class);
manager.createNotificationChannel(channel);

Step 3: 使用 Porcupine 進行語音喚醒

Porcupine 提供 Android SDK，可辨識自訂關鍵詞並在完全離線情況下運作。

PorcupineManager porcupineManager = new PorcupineManager.Builder()
    .setAccessKey("你的金鑰")
    .setKeywordPath("hey_assistant.ppn")
    .setSensitivity(0.7f)
    .build((keywordIndex) -> {
        // 被喚醒時呼叫 SpeechRecognizer 進行語音辨識
        startSpeechRecognition();
    });

porcupineManager.start();

Step 4: 啟動服務

Intent serviceIntent = new Intent(this, VoiceService.class);
ContextCompat.startForegroundService(this, serviceIntent);

注意事項

• 前景服務在 Android 8 之後是必須的，否則系統會終止 App。
• Porcupine 支援離線運作，但需註冊帳戶取得 AccessKey。
• 記得處理使用者授權 RECORD_AUDIO 權限。

Hey Google 語音助理的優化

使用者端最佳化建議

• 確保語音模型訓練完成：在「Google 助理設定」中進行「Voice Match」訓練，讓裝置更準確辨識個人聲音。
• 避免背景雜音：在安靜環境中使用「Hey Google」效果更佳。
• 裝置靠近嘴部：裝置麥克風收音品質會明顯影響喚醒效果。
• 更新 Google App：最新版本通常會改善語音模型與喚醒靈敏度。
• 開啟「Always on」設定：讓語音喚醒可在螢幕關閉時使用（部分裝置與版本限定）。

開發者端最佳化方式

• 使用 Google Assistant SDK：
  可在嵌入式設備或 Android 上整合原生語音助理體驗。適合 IoT 裝置或特殊應用開發。
  Google Assistant SDK 官方網站
• 啟用 App Actions：
  透過 App Actions 整合 Google Assistant 指令，讓使用者說出語音指令即可打開 App 並執行特定功能。
  例如：「Hey Google，打開我的購物清單」會觸發你的 App 行為。
  App Actions 文件
• Deep Link + Shortcut 提供語意連結：
  讓語音助理能正確觸發應用程式中的特定頁面或操作。

語音喚醒觸發條件優化

• 系統等級喚醒只允許原生 Google 助理使用。
• 非系統助理（第三方 App）無法完全取代「Hey Google」。
• 如需自訂喚醒詞，建議使用 Porcupine、Snowboy（已停用）等工具自建語音助手。

注意限制

• 「Hey Google」語音觸發屬系統級權限，不可由第三方 App 截獲。
• Google 未開放「Hey Google」語音觸發的 SDK 授權。
• Android 11+ 更限制麥克風權限與背景存取。

Apple 產品程式開發

開發工具

• Xcode: Apple 官方的開發環境 (IDE)，支援 macOS、iOS、watchOS 及 tvOS 應用程式開發。
• Swift: Apple 推出的現代化程式語言，安全且高效能。
• SwiftUI: 宣告式 UI 框架，簡化 UI 開發。
• UIKit: 傳統的 UI 框架，提供完整的 UI 控件與自定義功能。

開發環境設定

1. 下載並安裝最新版本的 Xcode。

2. 開啟 Xcode 並前往 Preferences > Accounts，登入 Apple ID 以啟用開發者功能。

3. 透過 Xcode 安裝 Command Line Tools 以使用 Swift 命令列工具。

開發平台

• iOS: 開發 iPhone 與 iPad 應用程式。
• macOS: 開發桌面應用程式。
• watchOS: 為 Apple Watch 開發應用程式。
• tvOS: 開發 Apple TV 應用程式。

建立專案

1. 開啟 Xcode，選擇「Create a new Xcode project」。

2. 選擇適合的應用程式模板，例如 App (iOS/macOS)。

3. 設定專案名稱、識別碼 (Bundle Identifier) 及語言 (Swift 或 Objective-C)。

4. 選擇 UI 框架 (SwiftUI 或 UIKit)。

模擬與測試

• 使用 iOS Simulator 在不同裝置上測試應用程式。
• 透過 TestFlight 發布 Beta 測試版本給測試人員。
• 使用 XCTest 進行單元測試與 UI 測試。

應用程式發布

1. 註冊 Apple Developer Program (需年費 USD $99)。

2. 透過 Xcode 設定 App Store Connect 並提交 App。

3. 遵循 Apple 的 App Store Review Guidelines 確保應用程式符合上架規範。

iOS開發

開發工具

iOS 開發主要使用 Xcode，這是 Apple 提供的官方整合開發環境 (IDE)。

• 程式語言：Swift 和 Objective-C
• 支援模擬器進行測試
• 提供 Interface Builder 設計視覺化介面

開發流程

1. 設計應用程式架構與介面
2. 編寫程式碼實現功能
3. 使用模擬器或實機進行測試
4. 進行錯誤排除與性能優化
5. 通過 App Store 提交與發佈

必備知識

學習 iOS 開發需要掌握以下基礎：

• Swift 語法與基礎
• UIKit 或 SwiftUI 的使用
• 基本設計模式，例如 MVC、MVVM
• 處理網路請求與 JSON
• 應用程式生命周期與背景運作

開發資源

以下是一些實用的學習與開發資源：

• Apple 開發者官網
• Swift 官方網站
• Ray Wenderlich 教學網站
• Stack Overflow 技術社群

Xcode

功能特色

Xcode 是 Apple 提供的整合開發環境 (IDE)，用於 macOS、iOS、watchOS 和 tvOS 應用程式的開發。

• 支援 Swift 和 Objective-C 語言
• 內建模擬器可測試多種設備與系統版本
• 提供 Interface Builder 設計視覺化介面
• 整合 Git 版本控制
• 強大的編譯器與除錯工具

主要組件

1. Code Editor： 提供語法高亮、代碼補全與錯誤提示功能
2. Interface Builder： 支援直覺式拖放設計介面
3. Simulator： 用於測試與模擬應用程式在不同裝置上的運行
4. Debugging 工具： 支援斷點、記憶體檢測與性能分析

安裝與更新

可從 Mac App Store 或 Apple 開發者官網下載最新版本的 Xcode。

• 系統需求：macOS 最新版本
• 定期更新以獲取最新功能與錯誤修正

使用技巧

提升開發效率的實用技巧：

• 利用快捷鍵快速切換檔案與視圖
• 配置自定義模版以重複使用代碼
• 啟用靜態分析工具檢查潛在問題
• 學習如何使用 LLDB 命令進行高效除錯

資源

相關學習與參考資源：

• Xcode 官方網站
• Apple 開發者文檔
• Ray Wenderlich 教學網站

Swift

語言特點

Swift 是 Apple 推出的現代化程式語言，用於開發 iOS、macOS、watchOS 和 tvOS 應用程式。

• 快速且高效的性能
• 簡潔易讀的語法
• 支援安全性檢查，例如可選型別避免空指針錯誤
• 支援函式式編程與物件導向編程
• 強大的錯誤處理機制

語法基礎

• 變數與常數： 使用 var 和 let
• 可選型別： 使用 ? 和 ! 處理值的存在與否
• 控制流程： 包括 if、switch、for、while
• 函數： 使用 func 定義，支援參數標籤與多返回值
• 類別與結構： 使用 class 和 struct

核心概念

1. 使用 Protocol 實現介面與協議
2. 利用 Extension 擴展類別功能
3. 泛型支援提升代碼重用性
4. 運用閉包 (Closures) 實現高階函數
5. 支援自定義操作符與元組

應用場景

Swift 不僅適用於 Apple 生態系統，還可以用於伺服器端開發與跨平台工具。

• iOS 和 macOS 應用程式開發
• 伺服器端應用程式使用 Swift on Server
• 學術研究與快速原型開發

資源

相關學習與參考資源：

• Swift 官方網站
• Apple Swift 開發者資源
• Hacking with Swift 教學網站
• Stack Overflow 技術社群

Objective-C

特點

Objective-C 是一種以 C 為基礎的物件導向程式語言，最初由 NeXT 公司開發，後來被 Apple 廣泛用於 macOS 和 iOS 應用程式開發。

• 基於 C 語言，具備高效能與靈活性
• 支援動態運行時 (Runtime)
• 使用 Smalltalk 風格的訊息傳遞

語法結構

Objective-C 的語法結合了 C 和 Smalltalk 的特性，使用 @ 符號來標示語言擴展。

• 類定義： 使用 @interface 和 @implementation
• 訊息傳遞： 使用方括號語法 [object method]
• 屬性： 使用 @property 和 @synthesize

核心概念

1. 物件導向程式設計，包括類別與繼承
2. 協議 (Protocols) 用於定義方法集合
3. 分類 (Categories) 用於擴展類別功能
4. Block 語法用於閉包與回呼

開發工具

Objective-C 的開發主要使用 Apple 的 Xcode。

• 提供編輯、編譯與除錯功能
• 整合 Interface Builder 設計視覺化介面
• 支援 iOS 與 macOS 應用程式開發

資源

以下是一些學習與參考的資源：

• Apple 官方文檔
• objc.io 技術博客
• Stack Overflow 技術社群
• GitHub 儲存與分享代碼

GNews

什麼是GNews？

GNews是一個由Google開發的新聞聚合平台，旨在幫助用戶獲取最新的全球新聞資訊。它整合了來自各種新聞來源的內容，使用人工智慧技術來個性化推薦用戶感興趣的新聞。

GNews的主要功能

• 新聞聚合：GNews會從各大新聞網站、博客和社交媒體收集最新的新聞報導，提供多元化的新聞來源。
• 個性化推薦：根據用戶的閱讀習慣和興趣，GNews會智能推薦相關的新聞內容，使用戶能快速找到感興趣的話題。
• 實時更新：平台會持續更新新聞資訊，使用戶隨時能獲取最新的國內外新聞動態。
• 多語言支持：GNews支持多種語言，方便不同地區的用戶獲取新聞資訊。

如何使用GNews？

用戶可以通過訪問GNews的網站或下載其應用程式來使用此平台。在平台上，用戶可以選擇感興趣的主題、追蹤特定的新聞來源，並根據自己的需求自訂新聞推送。

GNews的優勢

• 便捷性：用戶不需要逐一訪問各新聞網站，GNews將所有相關資訊集中在一個平台上。
• 快速獲取資訊：實時更新的功能讓用戶能夠快速獲得最新的新聞動態，無論是政治、經濟、科技還是娛樂新聞。
• 多元化的新聞來源：GNews整合了來自不同來源的新聞，使用戶能夠獲得更全面的資訊。

結論

GNews是一個強大的新聞聚合工具，透過人工智慧技術，為用戶提供個性化的新聞體驗。隨著新聞資訊的快速變化，GNews幫助用戶快速跟上世界動態，獲取所需的資訊。

自動化流程工具

AI開發程式

Bolt

Bolt 是一個快速、輕量的 AI 開發框架，專注於提供開發者簡單且高效的工具來建構應用程式。特點包括：

• 快速啟動：適合新手開發者快速建立原型。
• 模組化設計：可擴展性強，適用於多種應用場景。
• 輕量：佔用資源少，運行高效。

Cursor

Cursor 是專為 AI 程式開發設計的編輯器工具，提供智能輔助程式碼撰寫與調試功能。特點包括：

• 程式碼生成：利用 AI 智能補全與提示。
• 語法錯誤檢查：減少開發錯誤率。
• 內建版本控制：提升團隊協作效率。

v0

v0 是一個基於視覺化開發的 AI 平台，允許使用者透過拖放介面構建模型與應用。特點包括：

• 無需程式碼：適合無技術背景的開發者。
• 直觀介面：以視覺化方式操作，學習曲線低。
• 即時預覽：快速測試模型效果。

Codeium

Codeium 是一款結合 AI 智能輔助的程式編輯器，專注於提升程式開發效率與準確性。特點包括：

• 智能補全：根據上下文生成高品質程式碼。
• 多語言支援：適用於多種程式語言的開發需求。
• 整合環境：可與多種 IDE 相容，無縫整合。

軟體工程

定義

軟體工程是一門系統性、規劃性地開發、操作與維護軟體的工程學科，目標是建構高品質、可維護、可靠且符合需求的軟體系統。

核心目標

• 提高軟體品質
• 降低開發成本
• 縮短開發時程
• 增強維護與擴充性

軟體開發生命週期（SDLC）

1. 需求分析：蒐集與分析使用者需求，製作需求規格書
2. 系統設計：設計系統架構、模組、資料庫與介面
3. 實作：依據設計撰寫程式碼
4. 測試：進行單元測試、整合測試、系統測試與驗收測試
5. 部署與上線：將系統部署至生產環境
6. 維護與更新：修正錯誤、更新功能、優化效能

常見開發方法論

• 瀑布式（Waterfall）：階段性完成、流程明確、變更成本高
• 敏捷式（Agile）：迭代開發、快速回饋、強調團隊合作
• Scrum：一種敏捷方法，分為短衝（Sprint）、日會、回顧等儀式
• DevOps：整合開發與運維，強調自動化與持續交付

常見工具與技術

• 版本控制：Git、GitHub、GitLab
• 專案管理：Jira、Trello、Asana
• CI/CD：Jenkins、GitHub Actions、GitLab CI
• 測試工具：JUnit、Selenium、Postman

品質屬性

• 可用性（Availability）
• 可維護性（Maintainability）
• 可擴充性（Scalability）
• 安全性（Security）
• 效率（Efficiency）

角色分工

• 系統分析師：負責需求訪談與分析
• 軟體設計師：設計系統架構與模組
• 程式設計師：負責撰寫與測試程式
• 測試工程師：執行測試並回報缺陷
• 專案經理：規劃時程、協調團隊

敏捷開發

核心價值

• 個人與互動勝於流程與工具
• 可工作的軟體勝於詳盡的文檔
• 客戶合作勝於合約談判
• 應對變化勝於遵循計劃

主要原則

1. 以最高優先級滿足客戶需求，通過早期且持續的交付提供價值。
2. 歡迎需求變更，即使在開發後期，也能利用變更為客戶創造競爭優勢。
3. 頻繁交付可工作的軟體，交付周期通常以數周或數月計算。
4. 開發與業務團隊應該每天合作，促進溝通與理解。
5. 以有動機的個人為核心，提供支持並信任他們完成工作。
6. 面對面交流是最有效的溝通方式。
7. 衡量進度的主要指標是可工作的軟體。
8. 提倡可持續的開發節奏，所有參與者應能維持穩定的步調。
9. 追求技術卓越與設計簡潔，提升靈活性與質量。
10. 保持簡單，專注於完成必要的工作。
11. 自組織團隊能產生最佳設計與架構。
12. 定期反思並調整行為以提升效率。

常用框架

• Scrum：強調短衝刺與固定節奏的開發。
• Kanban：專注於持續流動與可視化工作。
• Extreme Programming (XP)：注重技術實踐與高頻率交付。
• Lean：關注減少浪費並提高價值流效率。

適用場景

• 需求變化頻繁的專案。
• 需要快速交付最小可行產品 (MVP) 的情況。
• 開發過程需要密切客戶參與。
• 跨職能團隊協作的專案。

軟體開發需求文件範本

專案名稱

請填入本專案的正式名稱。

版本紀錄

• 版本：1.0
• 撰寫日期：YYYY-MM-DD
• 撰寫人：姓名
• 審核人：姓名

專案背景與目標

說明此專案的緣由、背景問題以及欲解決的核心問題，並定義明確的專案目標。

系統概要

概述系統功能與整體架構，可搭配系統架構圖。

功能需求

• 功能編號：例如：F-001
• 功能名稱：用戶註冊
• 功能描述：使用者可透過電子郵件與密碼進行註冊。
• 前置條件：未註冊帳號的使用者
• 輸入：電子郵件、密碼
• 處理：驗證格式並儲存於資料庫
• 輸出：註冊成功訊息或錯誤提示

非功能性需求

• 系統應具有99.9%的可用性
• 支援每秒至少100個並發請求
• 回應時間小於2秒
• 支援HTTPS加密

使用者角色與權限

• 一般使用者：註冊、登入、使用基本功能
• 管理員：使用者管理、系統設定

畫面與介面需求

可附上主要畫面草圖或線框圖，描述各畫面的元素與互動流程。

資料需求

列出主要資料表結構、欄位、關聯性等。

整合與相依性

列出需整合的外部系統、API或其他軟體元件。

時程與里程碑

• 需求確認：YYYY-MM-DD
• 初版開發完成：YYYY-MM-DD
• 測試完成：YYYY-MM-DD
• 上線時間：YYYY-MM-DD

風險與限制

列出潛在風險、限制條件（如預算、人力、技術等）。

附錄

相關文件連結、參考資料、名詞定義等。

設計模式

定義

設計模式（Design Patterns）是一組經過實踐驗證的軟體設計解決方案，主要應用於物件導向程式設計中，用來解決在特定情境下反覆出現的設計問題。

三大類別

• 建立型：（Creational）專注於如何建立物件
• 結構型：（Structural）關注類別與物件的組合方式
• 行為型：（Behavioral）處理物件之間的互動與職責分配

常見建立型模式

• 單例模式：（Singleton）確保一個類別在系統中只會有一個實例
• 工廠方法：（Factory Method）使用子類別來決定建立哪個物件
• 抽象工廠：（Abstract Factory）提供建立一組相關物件的介面
• 建造者模式：（Builder）將物件的建立過程與表示分離
• 原型模式：（Prototype）透過複製現有實例來建立新物件

常見結構型模式

• 適配器模式：（Adapter）將一種介面轉換為用戶所期望的另一種介面
• 裝飾者模式：（Decorator）在不修改原類別的情況下，動態新增功能
• 外觀模式：（Facade）提供一個統一的介面來存取複雜子系統
• 組合模式：（Composite）將物件組合成樹狀結構以表示整體/部分層次
• 代理模式：（Proxy）提供控制對目標物件存取的機制

常見行為型模式

• 觀察者模式：（Observer）當某物件改變狀態時，自動通知所有依賴者
• 策略模式：（Strategy）定義一系列演算法，並可在執行時替換
• 命令模式：（Command）將操作封裝為物件，以支援復原、排程等操作
• 狀態模式：（State）允許物件在內部狀態改變時改變其行為
• 迭代器模式：（Iterator）提供一種遍歷集合元素的方法

設計模式的優點

• 提升程式結構的可重用性與可維護性
• 使系統更具彈性與可擴充性
• 加強團隊開發中的溝通與共識

使用建議

• 根據實際需求選擇合適模式，避免過度設計
• 搭配 SOLID 原則可發揮更佳效果
• 在重構時導入設計模式可提升可讀性與穩定性

版本控制

定義

版本控制（Version Control）是一種管理檔案變更歷史的系統，廣泛應用於軟體開發中，讓多位開發者能同時協作，並保留每次變更的完整記錄。

主要功能

• 追蹤每次檔案變動的內容與原因
• 還原到任何歷史版本
• 分支管理以支援多版本並行開發
• 整合多位開發者的修改

版本控制系統類型

• 本地版本控制：紀錄儲存在單一電腦上
• 集中式版本控制：（Centralized VCS）如 SVN，所有開發者透過中央伺服器協作
• 分散式版本控制：（Distributed VCS）如 Git，每位開發者有完整版本庫

常見工具

• Git：最廣泛使用的分散式版本控制系統
• GitHub：Git 的雲端託管平台，支援 Pull Request、Issue、CI/CD 等功能
• GitLab：類似 GitHub，並內建 CI/CD 管理功能
• Bitbucket：支援 Git 與 Mercurial，適合與 Jira 整合

Git 基本指令

• git init：初始化版本庫
• git clone [網址]：複製遠端專案
• git add [檔案]：加入變更至暫存區
• git commit -m "訊息"：提交變更
• git push：將變更推送至遠端儲存庫
• git pull：取得並合併遠端變更
• git branch：查看或建立分支
• git merge：合併分支

分支策略

• Main / Master：穩定可部署版本
• Develop：主要開發分支
• Feature Branch：新功能開發用
• Release Branch：準備發佈版本
• Hotfix Branch：緊急修復生產問題

好處

• 提升團隊協作效率
• 降低版本衝突與風險
• 確保開發流程有跡可循
• 支援快速切換與測試不同版本

Git

簡介

Git 是一種分散式版本控制系統，由 Linus Torvalds（Linux 之父）於 2005 年開發，用於追蹤程式碼變更、協同開發與版本管理。它是現今最廣泛使用的版本控制工具，被應用於個人開發、團隊專案與開源社群中。

核心概念

• Repository（儲存庫）：儲存所有版本歷史與檔案的資料夾，可分為本地端與遠端。
• Commit：一次變更記錄，代表一組檔案的修改狀態。
• Branch（分支）：獨立的開發線路，讓多人可同時開發不同功能而不互相干擾。
• Merge（合併）：將不同分支的變更整合到主分支。
• Clone：將遠端儲存庫複製到本地。
• Push / Pull：上傳或下載變更到遠端儲存庫。

安裝 Git

1. 前往 Git 官方網站 下載適合的版本。
2. 安裝後開啟命令提示字元（CMD）或 PowerShell。
3. 輸入 git --version 以確認安裝成功。

初始設定

第一次使用 Git 時，需設定開發者資訊：

git config --global user.name "你的名稱"
git config --global user.email "你的[email protected]"

基本指令

git init              # 初始化本地儲存庫
git clone URL         # 複製遠端儲存庫
git add .             # 將變更加入暫存區
git commit -m "說明"  # 建立一次提交
git status            # 查看當前狀態
git log               # 查看提交紀錄
git branch            # 查看分支列表
git checkout 分支名   # 切換分支
git merge 分支名      # 合併指定分支
git push              # 將變更推送到遠端
git pull              # 從遠端拉取更新

常見工作流程

1. 建立或複製儲存庫（git init 或 git clone）
2. 編輯或新增檔案
3. 將修改加入暫存區（git add）
4. 提交變更（git commit）
5. 與遠端同步（git push / git pull）

與 Visual Studio 整合

• Visual Studio 內建 Git 支援，可直接操作分支、Commit、Push。
• 可連接 GitHub、Azure DevOps、GitLab 等服務。
• 透過「Git Changes」面板可檢視與管理版本變更。

優點

• 分散式架構，每位開發者都有完整版本歷史。
• 速度快、效率高，支援離線作業。
• 強大的分支與合併功能。
• 跨平台支援（Windows、Linux、macOS）。

常見遠端服務

• GitHub — 全球最大的開源社群平台
• Azure DevOps — 微軟企業級整合平台
• GitLab — 自託管與雲端版本控制服務
• Bitbucket — 支援 Git 與 Mercurial 的專案平台

Git 重置同步遠端

核心指令：git reset

如果您想完全捨棄本地所有尚未提交（Uncommitted）以及已經提交但尚未推送（Local Commits）的更改，將分支重設為與遠端完全一致，請按照以下步驟執行。

1. 取得遠端最新狀態

首先，確保您的本地索引已經更新，知道遠端目前最新的進度：

git fetch --all

2. 強制重設至遠端分支

使用 --hard 參數將目前分支指向遠端的對應分支（假設您的分支是 main）：

git reset --hard origin/main

處理未被追蹤的檔案 (Untracked Files)

git reset --hard 只會處理 Git 已經追蹤的檔案。如果您本地有新建立但尚未 git add 的檔案或資料夾，它們會殘留下來。若要一併刪除，請使用 clean 指令：

刪除未追蹤檔案

# 先執行測試，查看會刪除哪些檔案
git clean -n

# 正式刪除檔案 (-f) 與目錄 (-d)
git clean -fd

常見場景對照表

注意事項

• 不可逆性： git reset --hard 是一個危險的操作，執行後所有本地尚未提交的代碼將無法找回。
• 分支名稱： 請確保將 origin/main 替換為您目前實際使用的遠端分支名稱（例如 origin/master 或 origin/dev）。

Git 衝突檔案比較

當 Git 合併分支發生衝突時，檔案會被標記為「Unmerged」狀態。此時 Git 會在檔案中插入衝突標記，我們需要透過比較指令來定位問題並手動修復。

1. 找出衝突的檔案清單

在解決衝突前，先確認哪些檔案處於衝突狀態：

衝突的檔案會列在 Unmerged paths 區段下。

2. 比較衝突內容

當檔案內含有衝突標記時，可以使用以下方式查看差異：

• 查看標準差異：
  git diff
  這會顯示目前工作目錄與暫存區之間的差異。在衝突時，它會顯示 <<<<<<<、======= 與 >>>>>>> 標記。
• 比較特定端的版本：
  比較「目前的 分支 (Ours)」與衝突檔案：
  git diff --ours <file>
  比較「要合併進來的分支 (Theirs)」與衝突檔案：
  git diff --theirs <file>
• 三方比較 (Base, Ours, Theirs)：
  顯示共同祖先與兩端分支的差異：
  git diff -p <file>

3. 解讀衝突標記

Git 會直接修改衝突檔案，格式如下：

<<<<<<< HEAD (或是你的分支名)
這是你目前分支的內容 (Ours)
=======
這是對方分支的內容 (Theirs)
>>>>>>> branch_name

4. 使用圖形化工具比較 (推薦)

對於複雜的衝突，文字介面較難閱讀，建議調用專用的合併工具：

這會啟動如 Meld, P4Merge, 或 VS Code 等工具，以左右並排（Side-by-side）的方式比較三個版本：基準版本 (Base)、本地版本 (Local) 以及遠端版本 (Remote)。

5. 解決後的動作

手動編輯檔案並決定保留哪些程式碼後，必須執行以下步驟來完成合併：

1. 移除檔案中的 <<<<, ====, >>>> 標記。
2. git add <file> (將解決後的檔案加入暫存區)。
3. git commit (完成合併提交)。

Git Ignore

.gitignore 檔案

查看被 Ignore 的檔案

已加入 Git 的檔案改成 Ignore

重新套用 .gitignore

忽略單一檔案

忽略副檔名

忽略目錄

忽略特定路徑

排除 Ignore 規則

查詢某檔案為何被 Ignore

只在本機 Ignore

全域 Ignore

強制加入被 Ignore 的檔案

常用範例

GitHub

GitHub 是一個基於雲端的版本控制和協作平台，主要用於軟體開發。它使用 Git 進行版本控制，讓開發者能夠管理專案的源代碼、跟蹤變更以及與他人協作。

主要功能

• 版本控制： 透過 Git 跟蹤文件的變更，保留歷史記錄，並能夠回溯到先前的版本。
• 協作工具： 開發者可以通過 pull requests、code reviews 等功能進行協同開發。
• 項目管理： 提供 issues、projects 等功能來追踪任務和計劃。
• GitHub Actions： 支持 CI/CD (持續整合和持續交付) 自動化工作流。

使用 GitHub 的好處

• 集中管理代碼，確保代碼的透明性和可追溯性。
• 提供完善的版本控制工具，方便回退或合併不同版本。
• 開發者之間可以通過平台進行代碼審查，提高代碼質量。
• 支持自動化流程，提升開發效率。

適用對象

GitHub 適合各類開發者，無論是單獨開發者、開源社區還是企業團隊。它能夠滿足小型專案到大型軟體專案的版本控制和協作需求。

GitHub 使用 git pull --rebase

git pull --rebase 是從遠端分支拉取最新變更，並將本地的更改重新應用到最新的遠端提交之上，而不是使用傳統的合併。

使用方式

git pull --rebase

工作流程

1. 從遠端分支獲取最新更改。
2. 暫時移除本地的提交。
3. 將遠端提交應用到本地分支。
4. 重新應用本地的提交，保持歷史記錄線性。

為什麼使用 --rebase？

• 保持線性歷史： --rebase 可以讓提交歷史保持簡潔，沒有多餘的合併提交。
• 避免合併提交： 防止使用傳統合併產生過多的合併記錄。

使用範例

假設你在本地提交了一些更改，而遠端也有新的提交，使用 git pull --rebase 會：

• 下載並應用遠端的最新提交。
• 將你的本地提交重新應用到這些最新的遠端提交之後。

解決衝突

如果在重放本地提交時發生衝突，Git 會要求手動解決衝突：

1. 解決衝突並使用 git add 暫存已解決的文件。
2. 使用 git rebase --continue 繼續重放提交。
3. 若想取消操作，使用 git rebase --abort 回到原狀。

總結

git pull --rebase 是保持 Git 提交歷史整潔的重要工具，特別適合多人協作時，能夠避免產生冗餘的合併提交，並保持代碼庫的提交記錄線性。

GitHub 使用者存取權

若要讓其他開發者參與你的專案，你需要透過儲存庫的設定頁面將其加入為協作者（Collaborator）。以下是操作流程：

操作步驟

1. 進入儲存庫：在 GitHub 上打開你想要授權的專案主頁。
2. 開啟設定：點擊上方選單列最右側的 Settings（齒輪圖示）。
3. 管理存取權：在左側側邊欄中，點擊 Access 類別下的 Collaborators。
4. 身份驗證：系統可能會要求你重新輸入 GitHub 密碼或進行二階段驗證以確認身分。
5. 新增成員：點擊 Add people 按鈕。
6. 搜尋使用者：在彈出視窗中輸入對方的 GitHub 帳號名稱、全名 或 電子郵件。
7. 發送邀請：選中正確的使用者後，點擊 Add [名稱] to this repository。

存取權限級別 (Permission Levels)

針對個人帳戶的儲存庫，受邀者通常預設擁有讀寫權限；若為組織（Organization）帳戶，則可進行更細緻的設定：

注意事項

• 接受邀請：新增後，對方不會自動加入，必須查看其 GitHub 綁定的信箱並點擊 Accept Invitation 連結，或在 GitHub 通知中心接受邀請。
• 邀請時效：邀請連結通常在 7 天後失效。
• 私人儲存庫限制：如果你使用的是免費版 GitHub 帳戶，私人儲存庫的協作者人數並無上限，但部分進階功能（如 GitHub Actions 的保護分支）可能受到限制。

刪除 GitHub 儲存庫

透過網頁介面刪除 GitHub 儲存庫 (Repository)

這是最常見且最直覺的刪除方式。請注意，儲存庫一旦刪除，除非有備份，否則無法復原。

1. 在 GitHub 上進入您想要刪除的儲存庫主頁面。
2. 點擊上方分頁標籤最右側的 Settings (設定)。
3. 捲動頁面到最下方，找到標示為紅色的 Danger Zone (危險區域)。
4. 點擊 Delete this repository 按鈕。
5. 系統會彈出確認視窗，要求您輸入該儲存庫的完整名稱（格式通常為 使用者名稱/儲存庫名稱）。
6. 點擊下方按鈕確認刪除。

使用 GitHub CLI 刪除

如果您有安裝 GitHub 的命令列工具 (gh)，可以透過終端機快速刪除：

gh repo delete <使用者名稱>/<儲存庫名稱> --confirm

注意：--confirm 參數會直接跳過確認步驟，請謹慎使用。

刪除本機 (Local) 的儲存庫資料夾

GitHub 上的遠端儲存庫刪除後，您電腦上的本機資料夾依然會存在。若要徹底移除，請手動刪除該資料夾：

Linux / macOS / ChromeOS

rm -rf <資料夾名稱>

Windows (CMD)

rd /s /q <資料夾名稱>

刪除行為對照表

注意事項

• 權限限制： 您必須是該儲存庫的擁有者 (Owner) 或具有管理員權限的組織成員，才能執行刪除操作。
• 公共儲存庫： 刪除公共儲存庫不會刪除其他人的 Fork (分叉版本)，但會中斷與原專案的連結。
• 二階段驗證： 刪除重要儲存庫時，GitHub 可能會再次要求您進行密碼或二階段驗證 (2FA)。

Visual Studio 使用 Git

概述

Visual Studio 內建 Git 整合功能，但仍需在系統中安裝 Git 執行檔，才能進行版本控制操作（如 Commit、Push、Pull、Merge 等）。

步驟一：確認是否已安裝 Git

1. 開啟命令提示字元（CMD）或 PowerShell。
2. 輸入以下指令：

   git --version

3. 若顯示類似 git version 2.x.x，代表已安裝；若顯示「無法辨識 git 指令」，則需安裝 Git。

步驟二：下載並安裝 Git

1. 前往 Git 官方下載頁面。
2. 選擇對應的作業系統版本（Windows、macOS 或 Linux）。
3. 下載後執行安裝程式，建議使用預設設定一路按「下一步」。
4. 安裝完成後重新啟動 Visual Studio。

步驟三：設定 Git 使用者資訊

開啟命令提示字元，設定您的使用者名稱與電子郵件：

git config --global user.name "你的名稱"
git config --global user.email "你的[email protected]"

這些資訊會附加在每次提交（commit）中，用於識別開發者身份。

步驟四：在 Visual Studio 啟用 Git

1. 開啟 Visual Studio。
2. 點選上方選單的 視圖 (View) → Team Explorer。
3. 選擇 連線 (Connect) → Clone a repository 以複製遠端儲存庫。
4. 或在現有專案中點擊 Git → 建立 Git 儲存庫，讓專案成為版本控制的一部分。

步驟五：驗證整合狀態

• 在 Visual Studio 的狀態列可看到目前分支名稱。
• 可使用「Git Changes」視窗進行 Commit、Pull、Push 操作。
• 若 Visual Studio 顯示「未偵測到 Git」，請確認 Git 安裝路徑已加入系統環境變數。

補充：使用 Visual Studio 內建 Git 安裝

若使用 Visual Studio 2022 或更新版本，在安裝過程中可勾選 「Git for Windows」 選項。這樣 Visual Studio 會自動安裝與整合 Git，無需手動設定。

完成後效果

設定完成後，您可以直接在 Visual Studio 中完成以下操作：

• 建立分支、提交 (Commit)、推送 (Push) 與合併 (Merge)
• 檢視版本歷史與比較差異
• 與 GitHub、Azure Repos 或其他遠端儲存庫整合

Azure DevOps

平台簡介

Azure DevOps 是由 Microsoft 提供的一套整合式開發與協作平台，支援從程式碼管理、建置、自動化測試到部署的完整 DevOps 流程。它適用於多種程式語言與框架，可用於個人專案或大型企業團隊開發。

主要服務組成

• Azure Repos：提供 Git 或 TFVC 版本控制，支援 Pull Request、分支管理與原始碼審查。
• Azure Boards：用於工作項目追蹤、看板（Kanban）、Scrum 計畫與進度管理。
• Azure Pipelines：支援 CI/CD（持續整合與持續部署），可自動建置、測試並部署應用至多平台。
• Azure Test Plans：提供手動與自動化測試管理工具，確保軟體品質。
• Azure Artifacts：管理套件與依賴庫，可建立私有 NuGet、npm、Maven 等封裝源。

主要特色

• 跨平台支援，可在 Windows、Linux、macOS 上運行。
• 可與 GitHub、Docker、Kubernetes、Jenkins 等整合。
• 提供 REST API 與 YAML-based Pipeline 配置。
• 支援雲端與內部部署（Azure DevOps Server）。

常見用途

• 建立 Git 儲存庫並管理程式碼版本。
• 建立自動化建置流程（CI）。
• 設定自動部署流程（CD），將應用部署至 Azure、AWS 或內部伺服器。
• 透過 Boards 管理產品待辦清單與開發進度。
• 在 Test Plans 中進行品質驗證與測試報告。

使用方式

1. 前往 Azure DevOps 官方網站。
2. 登入或註冊 Microsoft 帳號。
3. 建立新組織（Organization）與專案（Project）。
4. 設定 Repos、Pipelines、Boards 等模組開始開發與部署流程。

優點

• 集中化開發管理平台，整合從規劃到部署的全流程。
• 權限與角色管理清晰，適合大型團隊。
• 彈性高，支援多雲與多語言開發環境。

適用場景

• 企業級專案的 CI/CD 流程管理。
• 跨部門協作與任務追蹤。
• 開源與私有程式碼儲存庫管理。

Azure DevOps 存取層級

步驟說明

1. 登入 Azure DevOps。
2. 在左下角點選 Organization Settings（組織設定）。
3. 在左側選單中選擇 Users（使用者）。
4. 系統會列出組織中所有使用者及其對應的 Access Level（存取層級）。

常見的 Access Level 類型

• Basic：可使用大部分開發功能，例如 Boards、Repos、Pipelines。
• Stakeholder：僅能檢視與參與基本工作項目（免費）。
• Basic + Test Plans：包含 Basic 權限，並可使用測試管理功能。
• Visual Studio Subscriber：若帳號綁定了 Visual Studio 訂閱，會自動擁有相應層級的權限。

進階操作

• 若您是組織管理員，可點選使用者右側的 三點選單（⋯） 修改其層級。
• 若權限不足，請聯繫組織擁有者或系統管理員以提升存取層級。

提示

若您在使用 Azure DevOps Pipelines、Repos 或 Boards 時遇到權限限制問題，請先確認您的 Access Level 是否為 Basic 或以上等級。

CMake 跨平台建置系統

CMake 的定義

CMake 是一個開源、跨平台的「元建置系統 (Meta-build System)」。它本身並不直接編譯程式碼，而是透過讀取設定檔（CMakeLists.txt），自動生成適合當前作業系統與開發環境的專案檔。例如，在 Windows 上它能生成 Visual Studio 解決方案，而在 Linux 上則生成 Makefile 或 Ninja 設定檔。

安裝 CMake

在不同作業系統上安裝 CMake 的方法如下：

• Windows：前往官方網站 cmake.org 下載 MSI 安裝程式。安裝時務必勾選「Add CMake to the system PATH」，以便在命令提示字元直接使用。
• macOS：推薦使用 Homebrew，在終端機輸入 brew install cmake。也可以下載 .dmg 檔手動安裝。
• Linux：使用套件管理器安裝，例如 Ubuntu 輸入 sudo apt update && sudo apt install cmake。

核心功能

CMake 的設計目標是簡化複雜軟體專案的管理。它支援多層目錄結構、處理函式庫之間的相依性，並能自動搜尋系統中已安裝的程式庫。此外，它也提供測試 (CTest) 與打包 (CPack) 功能，涵蓋了從開發到發佈的完整生命週期。

主流建置流程

x64 與 ARM64 支援

CMake 具備優秀的跨架構支援能力。在 Windows 環境下，開發者可以透過參數指定目標架構，例如使用 -A x64 或 -A ARM64。對於現代的 Apple Silicon，CMake 支援生成 Universal Binaries，讓程式能同時在 Intel 與 Apple M 系列處理器上執行。

為什麼選擇 CMake

傳統的 Makefile 難以維護且不具備跨平台通用性。CMake 讓開發者只需撰寫一套設定檔，就能讓全球開發者在其偏好的 IDE（如 VS Code, CLion, Xcode）中輕鬆開啟並編譯專案。這也是目前大多數主流開源 C++ 專案都採用 CMake 作為標準工具的原因。

程式部署

定義

程式部署（Application Deployment）是將開發完成的應用程式從開發環境移轉至測試或生產環境，讓使用者可以實際使用的過程。它確保系統能在不同環境中穩定、可重現地執行。

部署流程

1. 建置（Build）：將原始程式碼編譯、打包成可執行檔或映像檔。
2. 測試（Test）：驗證功能、效能及相容性。
3. 部署（Deploy）：將應用與設定檔部署至伺服器。
4. 監控（Monitor）：持續監控運行狀況、記錄日誌及效能指標。

常見部署方式

• 手動部署：人工上傳檔案、修改設定，適合小型專案。
• 自動化部署：利用工具自動化流程，減少人為錯誤。
• 容器化部署：使用 Docker 等技術封裝應用，使環境一致。
• 雲端部署：將應用部署至 AWS、Azure、Google Cloud 等雲端平台。

常見部署架構

• 單機部署：應用與資料庫皆於同一伺服器上運行。
• 前後端分離：前端（如 React、Vue）與後端（如 Node.js、Python）獨立部署。
• 微服務架構：將應用拆分成多個小型服務，分別獨立部署與管理。
• 叢集部署：利用多台伺服器分散負載與確保高可用性。

自動化部署工具

• Jenkins：持續整合與自動化部署工具。
• GitHub Actions：整合在 GitHub 中的 CI/CD 平台。
• GitLab CI/CD：GitLab 內建的自動化流程管理。
• Ansible：用於自動化伺服器設定與應用部署。
• Docker Compose / Kubernetes：支援容器化應用的部署與管理。

部署範例

# 使用 GitHub Actions 部署範例
name: Deploy Web App
on:
  push:
    branches: [ "main" ]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: 建立 Docker 映像
        run: docker build -t myapp .
      - name: 部署至伺服器
        run: docker run -d -p 80:80 myapp

部署時的考量

• 環境變數與設定檔分離
• 版本控制與回滾機制
• 自動化測試與驗證
• 監控與日誌收集
• 安全性（如 SSL、憑證、權限設定）

部署策略

• 藍綠部署：使用兩套環境（Blue/Green），新版本上線後再切換流量，確保不中斷服務。
• 滾動更新：逐步替換舊版本容器，保持服務連續性。
• 金絲雀部署：先讓少部分用戶使用新版本，觀察穩定後再全面推廣。

最佳實踐

• 將部署流程自動化，確保一致性
• 使用版本控制記錄部署變更
• 建立持續整合與持續交付（CI/CD）管線
• 隨時可回滾至前一版本
• 監控效能與錯誤日誌，持續優化部署流程

容器化技術

定義

Docker（容器技術）是一個開放原始碼的平台，用於自動化應用程式的部署、擴展與管理。它利用「容器」（Container）將應用與其依賴封裝在一起，確保在不同環境中能一致執行。

核心概念

• 映像檔（Image）：一個可執行的環境快照，包含應用程式及其依賴
• 容器（Container）：由映像檔建立的可執行實例，運行於隔離環境中
• Dockerfile：描述如何建構映像檔的設定檔案
• Docker Hub：官方映像檔託管平台，類似於「GitHub for Docker」

Docker 的優點

• 跨平台一致性：確保「開發環境與生產環境一致」
• 輕量快速：比虛擬機器啟動速度快，資源占用少
• 可移植性高：映像檔可在任何支援 Docker 的平台執行
• 便於版本控制與回滾

基本指令

• docker pull [映像名稱]：下載映像檔
• docker run [映像名稱]：執行容器
• docker ps：查看執行中的容器
• docker stop [容器ID]：停止容器
• docker rm [容器ID]：刪除容器
• docker build -t [名稱] .：依據 Dockerfile 建立映像檔
• docker images：查看映像檔清單

Dockerfile 範例

# 使用 Python 映像檔
FROM python:3.10

# 設定工作目錄
WORKDIR /app

# 複製程式檔案
COPY . /app

# 安裝依賴套件
RUN pip install -r requirements.txt

# 指定容器啟動時執行的指令
CMD ["python", "app.py"]

Docker Compose

Docker Compose 是一個可定義多個容器應用的工具，使用 docker-compose.yml 檔案定義各服務。

version: '3'
services:
  web:
    build: .
    ports:
      - "8000:8000"
  db:
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: example

應用場景

• 建立一致的開發與測試環境
• 快速部署微服務架構
• 持續整合與部署（CI/CD）流程
• 多版本應用程式的隔離運行

相關技術

• Kubernetes：容器編排與自動化管理平台
• Podman：無需 daemon 的容器工具
• Docker Swarm：Docker 原生的容器叢集管理系統

模組相依性分析

模組相依性分析是一種軟體工程技術，用於識別與追蹤應用程式執行時所依賴的外部檔案（如 DLL、庫、框架）。這對於確保軟體在不同環境下能正確執行至關重要。

核心分析維度

• 靜態相依性 (Static Dependencies)：在程式編譯與連結階段就已確定的依賴關係。作業系統在啟動程式時，會先載入所有標記為靜態相依的模組。
• 動態相依性 (Dynamic Dependencies)：程式在執行過程中，根據需要才透過 LoadLibrary 或 GetProcAddress 等 API 載入的模組。
• 延遲載入 (Delay-load Dependencies)：一種特殊的動態載入方式，模組僅在相關函數第一次被呼叫時才會載入，用以優化程式啟動速度。
• 傳遞性相依 (Transitive Dependencies)：當程式依賴 A.dll，而 A.dll 又依賴 B.dll 時，B.dll 即為傳遞性相依項。

分析的主要目的

常見分析工具

• Dependencies (Modern Dependency Walker)：目前 Windows 平台上最主流的開源分析工具，支援 Win10/11 的 API Sets。
• ldd (Linux)：在類 Unix 系統中，用於列出執行檔所需的共享庫相依關係。
• Process Explorer：由 Sysinternals 提供，可即時查看運行中程序已載入的所有 DLL 模組。
• objdump / nm：底層命令列工具，用於查看二進位檔案的導出與導入表。

Dependency Walker

Dependency Walker（通常稱為 Depends.exe）是一款用於分析 Windows 應用程式（如 .exe、.dll、.sys 等）檔案結構的免費工具。它主要用於掃描任何 32 位元或 64 位元 Windows 模組，並建立所有相關相依模組的分層樹狀圖。

核心功能

• 模組相依性分析：列出程式執行所需的所有 DLL 檔案，並顯示其層級關係。
• 導出與導入函數查看：列出模組導出的所有函數，以及其他模組正在呼叫的函數。
• 偵測遺失的檔案：標記出程式執行時找不到的必要組件，這是解決程式無法啟動問題的關鍵。
• 無效模組偵測：檢查是否有損壞的模組或非 Windows 的模組。
• 架構檢查：識別模組是 32 位元 (x86) 還是 64 位元 (x64)，避免混合架構導致的載入錯誤。
• 執行階段分析：透過 Runtime Profile 功能，監控程式運行時動態載入的模組與發生的錯誤。

常見應用場景

使用限制與替代方案

由於 Dependency Walker 已經多年未更新，對於現代 Windows 10/11 的一些特性（如 API Sets 或延遲載入的 DLL）支援度較差，經常會出現錯誤的紅色警告。在這種情況下，建議使用以下開源替代工具：

• Dependencies：由 lucasg 開發，是 Dependency Walker 的現代化重寫版，完全支援 Windows 10/11。
• Dependency Walker 官方版：僅建議用於傳統舊型系統（Windows XP/7）的維護。

Dependencies

Dependencies 是一款開源的現代化相依性分析工具，旨在取代已停止更新多年的 Dependency Walker (Depends.exe)。它針對 Windows 10 與 Windows 11 的系統架構進行了全面優化，能夠準確解析現代軟體環境中的模組關聯。

為什麼選擇 Dependencies

• 支援 API Sets 解析：能正確處理以 api-ms-win-* 開頭的虛擬 DLL，不會產生錯誤的循環相依警告或遺失檔案錯誤。
• 支援現代 Windows 特性：完整支援 WinSxS (Side-by-Side Isolation) 以及延遲載入 (Delay-load) 模組的追蹤。
• 效能大幅提升：相較於舊版工具在處理大型專案時的緩慢速度，Dependencies 採用多執行緒掃描，載入速度極快。
• 介面直觀：保留了經典的樹狀視圖，並強化了搜尋、過濾以及模組路徑定位功能。

功能對照表

常見快捷功能

• 反向相依性查詢：查看特定的 DLL 被哪些模組所引用。
• 匯出函數驗證：快速比對導入表 (Import Table) 與導出表 (Export Table) 之間的函數序號或名稱是否匹配。
• 路徑追蹤：清楚標示系統最終是從哪個資料夾（System32, SysWOW64 或應用程式目錄）載入該模組。

取得與安裝

Dependencies 是一個綠色免安裝軟體，通常可以從 GitHub 的 lucasg/Dependencies 儲存庫下載編譯好的 Release 版本。使用時只需將要分析的 .exe 或 .dll 檔案拖曳進視窗即可開始分析。

執行階段偵測功能差異

這兩款工具的設計哲學不同：Dependency Walker (Depends.exe) 包含一個動態分析器（Profiler），而現代的 Dependencies 則專注於靜態分析與 API Sets 解析。

為什麼 Dependencies 不執行程式？

• 設計定位：Dependencies 主要設計為一個「靜態分析工具」，用於解決因 Windows API Sets 導致的解析錯誤，它並不包含調試器（Debugger）引擎。
• 安全性考量：執行未知的程式碼具有風險，現代分析工具傾向於將動態監控交給專業的調試工具。
• 替代方案：若需要動態監控 DLL 載入過程，開發者通常會搭配使用 Process Monitor (ProcMon)。

如何使用 Dependency Walker 進行動態偵測 (Profiling)

如果你需要透過「執行程式」來排查只有在運行時才會出現的 DLL 錯誤（例如延遲載入失敗或路徑搜索問題），你可以繼續使用 Dependency Walker 的 Profile 功能：

1. 開啟 Dependency Walker 並載入你的 .exe。
2. 按下鍵盤上的 F7 或點擊選單中的 Profile -> Start Profiling。
3. 在彈出的對話框中設定參數（如工作目錄、命令列參數），然後點擊 OK。
4. 查看底部的 Log 視窗：當程式執行並崩潰時，底部的日誌會以紅色文字標示出具體在哪一個 DLL 載入時發生了錯誤。

動態偵測的優缺點對照

進階調試建議

如果你在 Dependency Walker 的 Profiler 中因為太多虛假錯誤而看不出重點，建議改用以下組合：

• 使用 Dependencies (靜態)：先確認基本的實體 DLL (如 VC++ Runtime, Qt, OpenSSL) 是否都已存在。
• 使用 Process Monitor (動態)：執行程式時，過濾 Process Name 與 Path（結尾為 .dll）。查看是否有任何 NAME NOT FOUND 的紀錄，這能精確告訴你程式在哪些路徑下尋找 DLL 卻失敗了。

程式開發 AI 工具

GitHub Copilot

由 GitHub 與 OpenAI 合作開發，是目前全球使用最廣泛的 AI 編碼助理。它能直接嵌入在 Visual Studio Code、JetBrains 等熱門開發環境中，透過分析註釋和上下文，即時建議程式碼行或整個函式。

Cursor

這是一個基於 VS Code 架構開發的獨立 AI 程式碼編輯器。不同於單純的插件，Cursor 將 AI 深度整合進編輯器的底層。它能理解整個專案的結構（Context），並允許開發者直接與整個程式庫進行對話，執行全域性的重構或 Bug 修復。

Claude 3.5 Sonnet

雖然 Claude 是通用型 AI，但其 3.5 Sonnet 模型在程式碼邏輯、架構設計以及 Debug 能力上被公認為目前最頂尖的選擇之一。搭配 Artifacts 功能，開發者可以在對話框中直接預覽生成的網頁前端畫面或互動式組件。

Tabnine

Tabnine 重視隱私與安全性，適合對原始碼保密要求較高的企業。它支援完全的本地化部署（Self-hosting），確保程式碼不會上傳至雲端進行訓練，並提供精準的自動補全功能。

Amazon Q (原 CodeWhisperer)

由 Amazon Web Services (AWS) 提供的開發助理。除了基本的程式碼生成，它特別強化了與 AWS 雲端服務的整合，能協助開發者快速編寫基礎設施即代碼（IaC）或處理安全性掃描與更新。

Replit Agent

內建於 Replit 線上開發環境中的 AI 代理。它的特色在於自動化部署與環境建置，使用者只需描述應用程式的功能，Agent 就能自動建立檔案、安裝依賴套件、撰寫代碼並完成上線運行。

v0.dev

由 Vercel 推出的前端開發專用 AI。使用者透過自然語言描述介面需求，v0 會直接生成基於 React、Tailwind CSS 和 Shadcn UI 的前端組件程式碼，大幅縮短 UI 刻板的時間。

代理型 AI 編程助手

代理型 AI 編程助手（Agentic AI Coding Assistants）。這類工具的特點是能夠直接存取終端機、讀寫檔案、執行測試，並具備自主規劃任務的能力。

1. 終端機與 CLI 類工具

這類工具與 Claude Code 最為接近，直接在你的終端機中運作，適合習慣命令行操作的開發者。

• Aider： 目前最受歡迎的開源 CLI 編程助手。它支援多種 LLM（如 GPT-4o, Claude 3.5 Sonnet），能自動處理 Git Commit，並具備強大的程式碼重構能力。
• Open Interpreter： 讓 AI 在你的本地電腦上執行代碼。它不限於編程，還能操控系統設定、處理數據檔案，是一個更廣義的電腦代理人。
• Mentat： 專注於大代碼庫導航的開源工具，能自動掃描整個專案並根據自然語言指令進行修改。

2. IDE 與 編輯器類工具

這類工具將代理能力整合進編輯器中，提供更直觀的視覺化開發體驗。

• Cursor： 目前公認最強的 AI 代碼編輯器（基於 VS Code）。其「Composer」模式與 Claude Code 非常相似，能跨多個檔案自動撰寫代碼並執行終端指令。
• Windsurf： 由 Codeium 推出的新一代 IDE，強調「Flow」概念，AI 助手能感知你的動作並在背景自主執行任務，具備極高的環境感知能力。
• Cline (原名 Devinsist/Claude Dev)： 一個 VS Code 擴充功能，讓 Claude 擁有讀寫檔案、執行 Bash 指令與操作瀏覽器的權限，是目前 VS Code 上最接近 Claude Code 的開源替代方案。

3. 全自動化 AI 工程師 (完全自主類)

這類工具通常具備更獨立的作業能力，能夠在網頁端或獨立環境中完成從需求分析到部署的過程。

• Devin： 被稱為全球首位「AI 軟體工程師」，能獨立解決 GitHub 上的 Issue，並具備自己的瀏覽器、編輯器和終端機。
• Replit Agent： 整合在 Replit 雲端開發環境中，使用者只需描述想要的功能，它就能從零開始建構並部署完整的 Web 應用程式。

核心功能對照表

如何選擇

• 如果你偏好極簡與速度：選擇 Claude Code 或 Aider。
• 如果你偏好視覺化與專案管理：選擇 Cursor 或 Windsurf。
• 如果你需要完全開源且高度自定義：選擇 Cline 或 Aider。

開源 AI 編碼專案與本地模型

Aider

Aider 是目前在 GitHub 上最受歡迎的開源 AI 配對編程專案。它的運作機制與 Claude Code 非常相似，都是直接在終端機中執行。Aider 完整開源了其核心架構與程式碼，並支援串接本地執行的免費開源模型。

• GitHub 專案： aider-chat/aider
• 本地模型搭配： 支援透過 Ollama 載入 DeepSeek-Coder-V2 或 Qwen2.5-Coder 等免費模型。

Continue

Continue 是一個完全開源的 IDE 插件專案，旨在作為 VS Code Cursor 的開源替代方案。它允許開發者將程式碼自動補全（Autocomplete）與側邊欄對話框（Chat）的功能，完全建立在本地端的免費模型之上。

• GitHub 專案： continuedev/continue
• 本地模型搭配： 內建支援 Ollama 與 LM Studio。通常建議使用 Starcoder2 處理程式碼補全，並使用 Llama 3.1 或 DeepSeek 處理對話。

Open Interpreter

Open Interpreter 是一個開源的自然語言程式碼執行專案。與一般只負責寫代碼的 AI 不同，它是一個可以運行在終端機的 Agent。它可以像 Claude Code 一樣，在取得權限後直接在本地環境執行 Python、JavaScript 或 Shell 腳本，完成建立檔案、分析數據或操作系統等任務。

• GitHub 專案： KillianLucas/open-interpreter
• 本地模型搭配： 支援透過專屬指令 interpreter --local 直接串接本地的免費開源模型執行。

主流程式專用開源模型（可在 GitHub / Hugging Face 下載）

運作模式對比

像 Cursor 或 Claude Code 這類商業軟體，其後端的專利上下文分析演算法與前端介面通常是閉源的。而上述的 GitHub 開源專案，則是公開了整個客戶端到服務端的原始碼，讓開發者可以自由修改底層架構，並完全切斷網路連線，落實 100% 的本地隱私編碼環境。

Claude Code

Claude Code 是由 Anthropic 開發的一款代理型命令行介面（CLI）工具。它直接運行在開發者的終端機中，能夠理解整個程式碼庫、執行終端指令、編輯檔案，並協助處理 Git 工作流，讓開發者透過自然語言就能完成複雜的編程任務。

核心功能

• 自動規劃與執行： 理解用戶需求並制定多步驟執行計劃，直接在終端執行編譯、測試或修復指令。
• 程式碼編輯與重構： 自動分析現有代碼並進行優化、Bug 修復或大規模的功能重構。
• Git 整合： 協助產生 Commit 訊息、處理分支切換以及解決合併衝突。
• 專案理解： 無需手動提供上下文，它會自動掃描檔案、分析架構並回答關於專案邏輯的問題。

安裝方式

Claude Code 需要 Node.js 18+ 環境，可透過以下方式安裝：

1. 使用 npm 安裝：
   npm install -g @anthropic-ai/claude-code
2. 啟動工具：
   在專案目錄下輸入 claude 即可開始互動模式。

操作模式與快捷鍵

常用內建命令

• /help：顯示所有可用指令與說明。
• /clear：清除當前對話歷史，重置上下文空間。
• /stats：顯示近期的 Token 使用量與費用統計。
• /doctor：診斷安裝狀態是否正常。
• /compact：手動壓縮對話內容以節省空間。

硬體與系統需求

• 作業系統： macOS 13+、Windows 10+ 或主流 Linux 發行版。
• 記憶體： 建議 4 GB RAM 以上。
• 帳號權限： 需要 Claude Pro、Max、Teams 或 Enterprise 訂閱方案，或是有效的 API Key 進行計費。

針對頻繁的權限確認彈窗以及需要跨目錄存取的需求，可以透過啟動參數與內建指令進行優化設定。

1. 減少權限確認彈窗

Claude Code 預設會針對危險指令（如刪除檔案、執行系統指令）進行逐一確認。若要進入「自動化模式」以減少干擾，可使用以下參數：

• 信任模式：
  在會話中輸入 /approve-all，這會對當前會話中的後續操作授予暫時的全面信任。

2. 存取目前目錄以外的目錄

Claude Code 為了安全起見，預設會限制在啟動時所在的專案目錄。若要存取外部路徑，有以下三種方法：

• 啟動時指定多個路徑：
  你可以在啟動指令後方列出所有需要被索引的目錄：
  claude . /path/to/another/project
• 使用 @ 符號手動加入：
  在對話過程中，你可以直接輸入 @ 並貼上外部檔案的絕對路徑，將其內容加入上下文：
  請幫我參考 @/etc/nginx/nginx.conf 的設定來修改目前的專案。
• 建立符號連結 (Symbolic Link)：
  在目前專案目錄下建立指向外部目錄的連結，Claude Code 通常會順著連結讀取：
  ln -s /path/to/external_dir ./external_dir

3. 設定永久別名 (Alias)

為了方便以後快速啟動並帶入這些設定，建議在你的 .bashrc 或 .zshrc (Cygwin/Linux) 中加入別名：

針對完全自動化啟動（免確認）以及存取外部目錄的需求，Claude Code 提供了專門的 CLI 參數來達成。這些功能通常被稱為「YOLO 模式」，適合在受信任的環境或沙盒中使用。

1. 全自動執行：跳過所有權限確認

如果您不希望在執行 ls、mkdir 或編輯檔案時一直點擊確認，可以使用以下危險參數：

• 全域跳過模式：
  --dangerously-skip-permissions
  這是最強大的參數。它會直接略過所有的權限提示，讓 Claude 擁有完全自主的執行權限。
• 僅開啟略過選項（不立即啟動）：
  --allow-dangerously-skip-permissions
  這會將「跳過權限」作為一個可選模式，通常搭配 --permission-mode bypassPermissions 使用。

2. 存取外部目錄：新增權限路徑

預設情況下，Claude 只能讀寫啟動時所在的目錄。若要存取其他路徑，請使用 --add-dir：

• 指令格式：
  claude --add-dir <路徑>
• 多目錄範例：
  claude --add-dir ../another-project --add-dir /var/log
  這樣 Claude 就能同時處理目前專案與指定的外部目錄。

3. 組合技：最強自動化啟動指令

如果您想一次到位，直接在多個目錄間進行無阻礙開發，可以組合使用：

啟動參數對照表

注意事項

• 安全性： 開啟 --dangerously-skip-permissions 後，Claude 可能會執行未經你審核的 shell 指令，建議僅在受信任的專案環境中使用。
• Token 消耗： 當你加入大量外部目錄時，會增加掃描檔案的數量，進而可能增加 API Token 的消耗與處理時間。

安全提醒

• 慎用跳過權限： --dangerously-skip-permissions 具有破壞性。如果 Claude 誤判指令（例如誤刪檔案），系統將不會有任何攔截。
• 環境限制： 在某些系統中，若以 root 或 sudo 身份執行此參數，可能會因為安全機制被阻擋，建議在一般使用者權限下執行。

Claude Code 的對話接續

Claude Code 會自動把每一次對話儲存在本機，所以即使關閉終端機，之後仍能接續之前的工作內容，不需要重新說明專案背景。--continue 與 --resume 就是用來載入這些已儲存對話的兩個指令旗標。

--continue 的行為

執行 claude --continue（簡寫 -c）會自動載入目前所在目錄下最近一次的對話紀錄，不會出現任何選單或詢問。如果該目錄下找不到任何先前的對話，畫面會顯示 No conversation found to continue 並結束程式。這個指令適合每天回到同一個專案、想要零摩擦接續工作的情境。

--resume 的行為

執行 claude --resume（簡寫 -r）不帶任何參數時，會開啟一個互動式的對話選擇清單，列出可恢復的歷史對話。每一筆紀錄會顯示對話名稱或摘要、距離上次活動的時間、訊息筆數，以及所屬的 git 分支。也可以在 --resume 後面直接帶入對話的 ID 或名稱，跳過選單直接載入指定的對話。在執行中的對話裡輸入指令 /resume，也會開啟同樣的互動式選單。

兩者的差異

--continue 適合只想接續最近一次工作、不需要挑選的情境；--resume 則適合同時手上有多個進行中對話、需要明確指定要回到哪一個的情境。在自動化腳本或 CI 流程中，建議優先使用帶有明確 ID 的 --resume，因為 --continue 在非互動模式下有時會建立新的對話，而不是真正接續舊的。

對話的命名

啟動新對話時可以加上 -n 或 --name 旗標指定一個容易識別的名稱，例如 claude -n feature-user-auth。已經在進行中的對話也可以用指令 /rename 重新命名。有了名稱之後，就能在選單中快速辨識，或直接用名稱搭配 --resume 載入，例如 claude --resume feature-user-auth。

選擇器的操作方式

選擇器預設只顯示目前工作目錄下的對話。按下快速鍵可以擴大顯示範圍：擴大到同一個儲存庫的所有工作樹，或擴大到本機上的所有專案。選擇器也支援預覽對話內容、就地重新命名，以及直接貼上 pull request 連結來找到產生那個 PR 的對話。

對話的分支

在對話中輸入指令 /branch（先前名稱為 /fork）可以將目前對話複製成一個新的分支並切換進去，原本的對話維持不變，仍保留在選擇器中可供之後恢復。在 CLI 層面，搭配 --fork-session 旗標與 --resume 或 --continue 一起使用，也能達到同樣效果，也就是恢復對話時建立新的對話編號，而不是延續原本那一筆。需要注意的是，分支出去的新對話不會繼承原本對話中已核准的權限設定，需要重新確認。

對話的儲存位置

每一個對話都會以本機檔案形式持續儲存，邊對話邊寫入磁碟，而不是只在結束時才儲存，因此即使程式中斷或當機，紀錄也不會遺失。對話的儲存與恢復是綁定在專案目錄上的，桌面應用程式、網頁版與編輯器擴充功能各自維護自己的對話紀錄，彼此不互通。

搭配 pull request 使用

當對話過程中使用 gh pr create 建立了 pull request，該對話會自動與這個 PR 建立關聯。之後可以透過指令 claude --from-pr 加上 PR 編號或網址，直接回到當初建立該 PR 的對話，也可以把 PR 網址貼到 /resume 選擇器的搜尋欄位中找到它。

Claude Code 切換帳戶

官方方式：/logout 再 /login

Claude Code 目前官方支援的切換方式是登出後重新登入，沒有內建的多帳戶管理指令。

在 Claude Code 對話提示字元內執行：

/logout

登出後重新啟動 Claude Code：

claude

啟動後會開啟瀏覽器，選擇或輸入另一個帳戶的憑證完成登入。若瀏覽器無法自動開啟（WSL2、SSH 環境），按 c 複製登入網址後手動貼入瀏覽器。

API Key 方式（無需 OAuth 登入）

若使用 Anthropic Console 的 API Key，可直接透過環境變數切換，完全不需要瀏覽器登入，且不同 shell session 或專案可用不同 Key：

啟動時帶入：

ANTHROPIC_API_KEY=sk-ant-NEWKEY claude

或先設定環境變數再啟動：

# Bash / Cygwin
export ANTHROPIC_API_KEY=sk-ant-NEWKEY
claude

也可在專案目錄放 .env 檔，Claude Code 啟動時會自動讀取：

ANTHROPIC_API_KEY=sk-ant-NEWKEY

CLAUDE_CONFIG_DIR：多帳戶同時存在（進階）

Claude Code 的憑證與設定存放於 ~/.claude/，透過 CLAUDE_CONFIG_DIR 環境變數可指定不同目錄，讓多個帳戶各自擁有獨立的設定資料夾：

# 在 ~/.bashrc 或 ~/.bash_profile 加入 alias
alias claude-personal='CLAUDE_CONFIG_DIR=$HOME/.claude-personal command claude'
alias claude-work='CLAUDE_CONFIG_DIR=$HOME/.claude-work command claude'

首次使用時各自執行一次登入即可，之後透過 alias 直接切換，無需重新登入：

claude-personal   # 以個人帳戶啟動
claude-work       # 以工作帳戶啟動

各方式比較

登入憑證優先順序

Cursor

Cursor 是一款基於 VS Code 開發的 AI 代碼編輯器。它並非單純的插件，而是將 AI 能力深植於編輯器底層，使其能理解整個專案的上下文，並具備自動撰寫、重構與修復程式碼的能力。由於繼承了 VS Code，使用者可以直接匯入原有的所有設定與擴充功能。

基本安裝

1. 下載軟體： 前往 Cursor 官網，系統會自動偵測您的作業系統（Windows, macOS, Linux）並提供下載。
2. 匯入設定： 安裝後啟動，Cursor 會詢問是否要從 VS Code 匯入延伸模組（Extensions）、快捷鍵與主題。建議選擇匯入以無縫銜接開發習慣。
3. 登入帳號： 註冊並登入 Cursor 帳號。免費版（Hobby）提供有限次數的高階模型（如 GPT-4o 或 Claude 3.5 Sonnet）查詢，之後會切換至較小的模型。

核心功能使用

1. Cmd + K (Inline Edit)

在程式碼編輯器中直接呼叫 AI：

• 選取一段程式碼，按下 Cmd + K (Windows 為 Ctrl + K)。
• 輸入指令（例如：將此函式改為非同步模式、加上錯誤處理）。
• AI 會在原地產生變更，您可以點擊「Accept」或「Reject」。

2. Cmd + L (Chat Pane)

側邊欄聊天對話框：

• 按下 Cmd + L 開啟聊天視窗。
• 您可以詢問關於專案的整體問題（例如：這個專案的登入邏輯在哪裡？）。
• 使用 @Files、@Codebase 或 @Web 來指定 AI 參考的範圍。

3. Cmd + I (Composer 模式)

這是 Cursor 最強大的「代理人」模式：

• 按下 Cmd + I 開啟 Composer。
• 輸入一個複雜功能需求（例如：建立一個完整的會員註冊頁面，包含前端驗證與後端 API）。
• AI 會同時自動建立或修改多個檔案，並自動執行終端機指令。

進階設定技巧

常用快捷鍵對照

• Cmd + K：編輯選取的程式碼或產生新代碼。
• Cmd + L：開啟 AI 聊天側邊欄。
• Cmd + I：啟動全專案生成模式 (Composer)。
• Cmd + Enter：在 Chat 模式下強迫 AI 掃描整個 Codebase。
• @：在輸入框輸入 @ 可標記檔案、資料夾、Git 紀錄或文件。

注意事項

• 隱私模式： 在設定中可以開啟「Privacy Mode」，開啟後您的代碼將不會被用於訓練模型（僅限 Pro 以上用戶或特定設定）。
• 終端機整合： 您可以直接在終端機按下 Cmd + K，讓 AI 幫您寫出複雜的 Shell 指令。

GitHub Copilot

GitHub Copilot 是由 GitHub（Microsoft）開發的 AI 程式碼助理，整合在編輯器中，能即時提供程式碼補全、生成、解釋與對話功能。它背後使用 OpenAI 的模型，適合各種程式語言，是目前最廣泛使用的 AI 編程工具之一。

主要功能

• 程式碼自動補全與生成
• AI 對話（Copilot Chat）：可問問題、解釋程式碼、找 bug
• 支援多種語言：Python、JavaScript、TypeScript、Go、Ruby 等
• 整合在 VS Code、JetBrains、Visual Studio 等編輯器

價格

在 VS Code 安裝步驟

1. 開啟 VS Code
2. 點選左側 Extensions 圖示（或按 Ctrl+Shift+X）
3. 搜尋 GitHub Copilot
4. 點選 Install 安裝（建議同時安裝 GitHub Copilot Chat）
5. 安裝完成後，點選右下角提示，登入 GitHub 帳號授權
6. 登入後即可開始使用，程式碼補全會自動啟用

常用操作

與 Cursor 比較

適合對象

• 已習慣使用 VS Code 的開發者
• 不想更換編輯器，只想加入 AI 輔助
• 預算有限，免費版即可滿足基本需求
• 程式碼補全與對話功能為主要需求者

Aider

安裝

Aider 是一款基於終端機的 AI 配對編程工具，支援直接修改本地原始碼。安裝前請確保系統已具備 Python 3.8 以上版本與 Git。

python -m pip install aider-chat

API 金鑰配置

啟動前需將 AI 服務商提供的金鑰設定為環境變數。Aider 預設支援 Anthropic 與 OpenAI 等多種模型：

• macOS/Linux: export ANTHROPIC_API_KEY=your-key
• Windows: setx ANTHROPIC_API_KEY your-key

設定完成後，在終端機輸入 aider 即可開啟對話介面。

檔案操作

Aider 僅會讀取與修改您指定加入上下文的檔案，以節省 Token 成本並提高準確度：

• /add <file>：將檔案加入對話，讓 AI 可以看見並編輯該內容。
• /drop <file>：從對話中移除檔案，不再讓 AI 追蹤。
• /ls：顯示目前對話中包含的檔案清單。

代碼編輯

您可以直接使用自然語言要求 Aider 執行任務，例如：「幫我把這個 class 拆分成兩個檔案」或「修復現有的 bug」。執行修改後，Aider 會自動進行 Git Commit，並根據修改內容自動撰寫提交訊息。

指令

Aider 使用本地模型

可行性與原理

Aider 支援透過多種方式與本地執行的免費開源模型進行串接。最常見的方法是利用 Ollama、LM Studio 或 LocalAI 等工具建立一個相容於 OpenAI API 規範的本地伺服器，再讓 Aider 指向該伺服器位址即可。

透過 Ollama 實作

這是目前最簡單且主流的本地化方案：

• 下載模型： 在終端機執行 ollama pull deepseek-coder-v2（或選用 Qwen2.5-Coder 等針對程式優化的模型）。
• 啟動 Aider： 使用 --model 參數指定 Ollama 模型路徑。

aider --model ollama/deepseek-coder-v2

核心設定參數

本地模型的限制與挑戰

• 邏輯推理能力： 雖然本地模型（如 Llama 3 或 DeepSeek）在基礎代碼撰寫上表現不錯，但在處理複雜的跨檔案重構時，精準度仍稍遜於 Claude 3.5 Sonnet。
• 上下文窗口： 本地模型受限於 VRAM 大小，上下文窗口（Context Window）通常較小。若專案檔案過多，可能會發生超出記憶體限制而導致回覆中斷的問題。
• 硬體需求： 建議至少具備 12GB 以上 VRAM 的 GPU，才能流暢執行 7B 或 14B 等級的程式碼專用模型。

推薦的本地模型

並非所有模型都適合搭配 Aider。以下是目前社群公認在程式開發任務中表現較佳的本地開源模型：

• DeepSeek-Coder-V2： 目前最強的開源代碼模型之一，邏輯非常嚴密。
• Qwen2.5-Coder： 阿里巴巴開發的模型，對於多語言程式碼的理解與生成相當出色。
• CodeQwen： 針對 Aider 的 Repository Map 功能有較佳的相容性。

Aider 對話歷程與 Project

Aider 有沒有分 Project 或 Chat Room？

Aider 本身沒有內建「project」或「chat room」概念，但它會自動將對話歷程寫入檔案，可以用目錄隔離來達到類似效果。

對話歷程存在哪裡？

Aider 預設會在當前目錄產生兩個檔案：

• .aider.chat.history.md：完整的對話紀錄（Markdown 格式，人可讀）
• .aider.input.history：你輸入過的指令歷史（供上下鍵回翻用）

只要在同一個目錄下啟動 aider，就會自動接續上一次的對話歷程。

如何「恢復」上一次的對話？

直接 cd 回原本的專案目錄，再執行 aider 即可。Aider 會自動載入該目錄的 .aider.chat.history.md，模型看得到之前的上下文。

用目錄隔離不同 Project

每個專案放在不同目錄，各自擁有獨立的 .aider.chat.history.md，就等同於分開的 chat room：

指定自訂歷程檔案路徑

若想把歷程存到特定位置，可用參數覆蓋預設路徑：

不想保留歷程

若不想寫入歷程檔，可加上：

重點整理

Aider 切換 OpenRouter 帳戶

aider 本身沒有「登入帳戶」的概念，OpenRouter 帳戶的識別完全透過 API Key 決定。切換帳戶 = 替換 API Key。以下是各種設定方式。

方式一：啟動時直接帶入（臨時切換，最快）

aider --api-key openrouter=sk-or-v1-NEWKEY --model openrouter/anthropic/claude-sonnet-4-6

此參數等同於在當次執行期間設定環境變數 OPENROUTER_API_KEY，不影響系統設定，關掉終端機後就失效。

方式二：環境變數（本次終端機 session）

Bash / Zsh（Linux、macOS、Cygwin）：

export OPENROUTER_API_KEY=sk-or-v1-NEWKEY
aider --model openrouter/anthropic/claude-sonnet-4-6

Windows CMD：

set OPENROUTER_API_KEY=sk-or-v1-NEWKEY
aider --model openrouter/anthropic/claude-sonnet-4-6

Windows PowerShell：

$env:OPENROUTER_API_KEY="sk-or-v1-NEWKEY"
aider --model openrouter/anthropic/claude-sonnet-4-6

方式三：.env 檔（專案層級，常用）

在專案目錄下建立或編輯 .env 檔：

OPENROUTER_API_KEY=sk-or-v1-NEWKEY

aider 啟動時會自動讀取所在目錄的 .env，不同專案資料夾可放不同 key，達到每個專案對應不同帳戶的效果。

方式四：aider YAML 設定檔（永久預設）

aider 的全域設定檔位於 ~/.aider.conf.yml（Linux/macOS）或 %USERPROFILE%\.aider.conf.yml（Windows）：

openai-api-key: null
# OpenRouter 使用 api-key 區段傳入
api-key:
  - openrouter=sk-or-v1-NEWKEY

各方式優先順序

確認目前使用哪個 key

OpenRouter 的每個 API Key 在後台是獨立命名的，可到 openrouter.ai/settings/keys 確認各 key 的用量，即可判斷 aider 目前在使用哪個帳戶的 key。

Aider 傳圖給 Vision Model

三種傳圖方式

方式一：啟動時帶入圖片

在命令列直接把圖片路徑與程式碼檔案一起傳入：

aider screenshot.png main.py

可同時帶多張圖：

aider ui_mockup.png error_screenshot.png app.py

方式二：對話中用 /add 加入

已在 aider 會話內時，隨時用 /add 加入圖片：

/add /path/to/screenshot.png

方式三：剪貼簿貼圖（最快）

截圖後（例如 Windows 的 Win+Shift+S、或 Snipping Tool），直接在 aider 提示字元輸入：

/paste

aider 會把剪貼簿中的圖片讀入 chat，無需存成檔案。這是截取錯誤訊息、UI 截圖最方便的做法。

支援格式

aider 接受常見圖片格式：png、jpg/jpeg、gif、webp。格式本身由底層模型決定是否支援，建議優先使用 png。

確認 model 具有 vision 能力

並非所有 model 都接受圖片輸入。以下為常見有效組合：

常見用途

傳圖的典型場景：截圖 UI 讓 aider 實作或修改對應元件；提供設計稿讓 aider 生成前端程式碼；截圖難以複製的終端機錯誤訊息讓 aider 診斷。

Aider model 錯誤

錯誤原因分析

此錯誤 NotFoundError (404) 是由 OpenRouter 後端平台所拋出。錯誤訊息明確指出 No endpoints found for deepseek/deepseek-r1:free，這代表 OpenRouter 官方已經下架、重新命名或暫時關閉了該免費節點（deepseek-r1:free），導致 Aider 透過 LiteLLM 發送請求時找不到對應的 API 端點。

修正方案一：切換至 OpenRouter 目前線上的 DeepSeek 模型

OpenRouter 的免費或付費模型識別碼經常變動。您可以嘗試將模型名稱更改為目前正常運作的標準版本或替代付費版本（付費版本通常極為便宜且穩定）：

• 嘗試官方標準版：

  aider --model openrouter/deepseek/deepseek-r1

• 嘗試聊天優化版（若適用）：

  aider --model openrouter/deepseek/deepseek-chat

修正方案二：改用 Ollama 完全本地端執行（免 API 金鑰）

如果您不希望受到第三方 API 平台端點變動的影響，建議直接在自己的電腦上透過 Ollama 下載並執行開源模型，這也是最穩定的免費方案：

• 步驟 1：下載並啟動本地模型

  在您的終端機執行（推薦針對代碼優化的版本）：

  ollama run qwen2.5-coder

• 步驟 2：讓 Aider 連接本地模型

  關閉上述模型後，直接啟動 Aider 並指定本地路徑：

  aider --model ollama/qwen2.5-coder

修正方案三：檢查環境變數與預設模型設定

有時 Aider 會快取舊的模型名稱，或是環境變數中的 AIDER_MODEL 設定錯誤。請確保您的啟動指令中明確加上了 --model 參數，以覆蓋掉任何可能出錯的預設值：

設定檔機制

可以透過設定檔來固定模型，這樣每次啟動 Aider 時就不需要手動輸入冗長的 --model 參數。Aider 預設會讀取名為 .aider.conf.yml 的 YAML 格式設定檔。

設定檔放置路徑

Aider 啟動時會依序尋找並載入以下路徑的設定檔（後者的設定會覆蓋前者）：

• 全域設定： 放置於使用者家目錄，例如 ~/.aider.conf.yml（Windows 為 C:\Users\您的用戶名\.aider.conf.yml）。
• 專案設定： 放置於當前 Git 專案的根目錄下，適合針對特定專案固定特定的模型。

設定檔內容撰寫

請建立或編輯 .aider.conf.yml，並在檔案中加入以下內容：

# 指定主聊天模型
model: openrouter/deepseek/deepseek-r1

# 如果有需要，也可以一併指定 API 金鑰存放的環境變數檔案
env-file: .env

搭配環境變數檔案 (.env)

為了配合 OpenRouter 的本地調用，通常會在專案根目錄下建立一個 .env 檔案來管理金鑰，這樣可以避免將敏感金鑰直接寫在設定檔中：

OPENROUTER_API_KEY=your_openrouter_api_key_here

自定義設定檔路徑啟動

如果您不想使用預設的隱藏檔案名稱，也可以將配置寫在任意名稱的 YAML 檔案中（例如 my_config.yml），並在啟動時透過 --config 參數指定載入：

aider --config my_config.yml

Tabnine

技術特點與定位

Tabnine 是一款專為軟體開發者設計的 AI 程式碼助理。與其他高度依賴雲端運算的工具不同，Tabnine 的核心優勢在於對隱私與安全性的嚴格掌控。它支援完全的本地化執行（On-premise / Local deployment），確保企業或個人的原始碼不會被上傳至外部伺服器，更承諾其訓練資料完全基於開源的授權代碼，避免侵權風險。

主要功能

• AI 代碼補全： 支援超過 80 種程式語言。在開發者輸入時，會根據上下文即時預測並自動補全下一行甚至整個函式的代碼。
• Tabnine Chat： 整合於 IDE 的對話視窗。開發者可以直接使用自然語言要求 AI 生成代碼、解釋複雜的邏輯、撰寫單元測試或搜尋專案中的特定 Bug。
• IDE 生態整合： 完美支援包括 VS Code、JetBrains 系列（IntelliJ, PyCharm 等）、Android Studio 與 Neovim 在內的主流開發環境。

收費方案與免費版本狀態

Tabnine 的收費策略經歷過數次調整，其目前的方案架構如下：

免費方案的限制

雖然 Tabnine 保留了免費的 Starter 方案，但相比於市場上的競爭對手（如 GitHub Copilot、Cursor 或免費的本地模型），其免費版的功能非常受限。免費版不支援對話式 Chat 功能，只能在編輯器中觸發短小的代碼提示。如果您需要完整的全程式碼生成與問答體驗，通常需要升級至 Pro 方案，或透過申請免費試用（通常為 90 天）來體驗完整功能。

OpenRouter

定位

OpenRouter 是一個統一的 LLM API 閘道（gateway），讓開發者透過單一 OpenAI 相容端點存取來自 60 個以上供應商、超過 300 個模型，包含 Anthropic、OpenAI、Google、Meta、Mistral、DeepSeek、xAI 等主流廠商的模型。只需一組 API Key 與一個信用額度帳戶，即可在這些模型之間自由切換，無需分別申請各家帳號與管理多組 Key。目前全球已有 250 萬以上用戶使用，超過 25 萬個應用程式串接其 API。

核心功能

• 單一 API 端點（https://openrouter.ai/api/v1）存取所有模型，完全相容 OpenAI SDK，只需更換 base URL 與 API Key
• 智慧路由：依照成本、延遲、可用性自動選擇最佳 provider，或手動指定
• 自動 fallback：主要 provider 故障時自動切換備援，確保高可用性
• 分散式邊緣基礎架構，OpenRouter 本身僅增加約 15ms 延遲
• 細粒度資料政策：可限制 prompt 只送往信任的特定 provider，預設不記錄 prompt 與 completion
• BYOK（Bring Your Own Key）：使用自有的 provider API Key，同樣享有 OpenRouter 的路由與 fallback 功能
• Prompt Caching、Guardrails、Agent SDK（多輪工具呼叫）等進階功能

模型路由變體

在模型名稱後加上變體後綴可控制路由行為：

免費方案

無需信用卡，註冊後即可使用超過 26 個免費模型，包含 Qwen3 Coder、DeepSeek V4 Flash、Llama 3.3 70B、Google Gemma 4 31B、OpenAI GPT-OSS 120B 等。免費模型限速為每分鐘 20 次請求、每日 200 次請求。帳戶累積 $10 以上信用額度後，免費模型的每日上限會提升。

付費與費用結構

API 使用方式

與現有 OpenAI SDK 程式碼完全相容，只需修改兩個參數：

# Python 範例
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-v1-YOUR_KEY",
)

response = client.chat.completions.create(
    model="anthropic/claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)

常見整合工具

• aider：aider --model openrouter/anthropic/claude-sonnet-4-6
• Continue.dev、Cursor、Open WebUI 等 IDE 外掛
• LangChain、LlamaIndex 等 AI 框架
• n8n 等無程式碼自動化平台

BYOK 設定

在 OpenRouter 帳戶設定中加入自有的 Anthropic、OpenAI 等 provider API Key 後，OpenRouter 會以該 Key 直接呼叫 provider，適合需要使用 provider 優惠時段折扣（如 DeepSeek 離峰 50–75% 折扣）或希望計費直接走自有帳戶的場景。

注意事項

• 各模型的速率限制繼承自底層 provider，OpenRouter 本身不提供額外的速率寬限
• OpenRouter 的定價與 provider 官方一致，但不代表是市場最低價；直接向 provider 簽約可能取得更低的企業折扣
• 免費模型可能隨時下架或調整，不建議在生產環境依賴特定免費模型
• 對延遲極度敏感或有強烈合規需求的場景，應評估是否直接對接 provider

Tavily AI

定位與核心概念

Tavily 是一個專為 AI 代理（AI Agents）與大型語言模型（LLM）打造的即時網路搜尋 API 平台。有別於傳統搜尋引擎以人類使用者為核心，Tavily 從底層設計就針對 AI 系統的需求進行優化：返回結構化、去雜訊、可直接送入 LLM 處理的網頁內容，讓 AI 代理能夠以即時網路資料作為推理依據，大幅降低幻覺（hallucination）風險。

主要功能端點

搜尋深度等級

Search API 提供四種深度模式，可在延遲與相關性之間取捨：

• Ultra-fast 極速模式，適合即時回應場景
• Fast 快速模式，兼顧速度
• Basic 基本模式，平衡速度與相關性
• Advanced 進階模式，最高相關性，費用約為基本的兩倍

技術架構特點

Tavily 的搜尋流程在單次 API 呼叫中完成以下步驟：自動解析查詢意圖 → 並行搜尋多個來源 → 使用自有 AI 模型評分與過濾 → 提取並清理內容 → 以標準 JSON 格式返回結果（含相關性分數與來源 URL）。其架構採用動態快取與代理原生索引（agent-native index），以確保在生產規模下維持低延遲。

安全機制

Tavily 定位自身為 AI 代理與開放網路之間的防火牆，所有請求均通過安全驗證層，自動封鎖提示注入（prompt injection）攻擊、個人識別資訊（PII）洩漏，以及惡意來源內容，確保 AI 應用的資料安全。

整合生態系

Tavily 對模型廠商保持中立，支援 OpenAI、Anthropic、Llama、Mistral 等主流模型。它已深度整合至以下框架與平台：

• LangChain、LlamaIndex、Agno（主流 AI 代理框架）
• n8n（無程式碼自動化工作流程）
• MCP（Model Context Protocol）伺服器，可連接 Claude、ChatGPT 等 AI 助手
• IBM watsonx、AWS、Google Cloud 等雲端市場

定價方案

基本搜尋消耗 1 點；進階搜尋消耗 2 點；Extract 每 5 個成功 URL 消耗 1 點；Map 每 10 頁消耗 1 點。

旗艦開源專案：GPT Researcher

GPT Researcher 是 Tavily 的旗艦開源項目，採用 Apache 2.0 授權，靈感來自史丹佛大學的 STORM 論文，使用多代理架構進行深度網路研究，同時也是 Tavily API 能力的主要展示平台。

近況：被 Nebius 收購

2026 年 2 月，Tavily 被 AI 基礎設施公司 Nebius 收購。此次收購引發部分開發者社群對平台未來路線圖、定價穩定性及資料處理政策的討論，也促使部分團隊開始評估 Exa.ai、Perplexity Sonar API、Brave Search API 等替代方案。

最適合 Coding 的 Model 比較 - 202607

資料說明

以下資料整合自 2026 年 6–7 月的多個公開 benchmark 來源（SWE-bench Verified、SWE-bench Pro、LiveCodeBench、Terminal-Bench 2.0），以目前實際可購買或可取得的 model 為準。benchmark 數字依賴測試用的 agent harness，同一 model 在不同 harness 可差距 17–22 個百分點，所有數字請作為參考方向而非精確排名。

主力 Model 完整比較表

依場景選 Model

Benchmark 解讀注意事項

• SWE-bench Verified（500 個 Python GitHub issue）有訓練資料污染風險，SWE-bench Pro（1,865 個私有 repo 多語言任務）污染風險較低，是 2026 年更可靠的基準。
• 同一 model 換 harness 可差距 17–22 個百分點；廠商自測數字通常比 Scale 標準 harness 高 10–20 個百分點，兩者不可直接對比。
• LiveCodeBench 偏向演算法競賽題，SWE-bench 偏向真實 repo bug 修補，兩者衡量不同面向的 coding 能力。
• 最可靠的評估方式是把候選 model 放在自己的實際 task 上測試，而非只看榜單數字。

軟體開發相關法律

著作權法

軟體程式碼、設計文件、使用手冊等均屬著作權保護範疇。著作權保護自創作完成時自動成立，無需註冊，禁止未經授權的複製、修改、散布或商業利用。

專利法

若軟體涉及技術創新或獨特演算法，可申請專利保護。專利需經審查批准，保障發明人對技術方案的專有權利，但純粹的程式邏輯通常不受專利保護。

商標法

軟體名稱、圖示（Logo）、品牌識別可註冊為商標，用以保護品牌形象與市場區隔，防止他人冒用造成混淆。

營業秘密保護法

未公開的程式設計細節、演算法、資料庫結構等屬營業秘密。公司應透過保密協議、資訊管理制度等方式保護。

資訊安全相關法規

如個資法、資通安全管理法等，要求軟體開發過程中妥善處理使用者個人資料、保障資訊安全，違規可能面臨行政或刑事責任。

契約法與授權條款

軟體開發常涉及承攬契約、合作開發契約、軟體授權條款等，明確雙方權利義務、程式碼所有權、維護責任、保密義務等，避免法律爭議。

網路與電子商務相關法規

軟體上線運營涉及網路服務、電子支付、智慧財產權線上保護等，需遵守電子簽章法、電子交易法等規範。

軟體開發的智慧財產權

著作權

軟體的程式碼屬於著作權保護的範疇，開發者自動擁有著作權，無需額外登記。著作權保護涵蓋原始碼、設計文件、使用手冊等。

專利權

若軟體涉及新穎性與技術創新，可能可申請專利保護。例如獨特的演算法或解決技術問題的方法，但純粹的程式碼邏輯通常不在專利保護範圍。

商標權

軟體名稱、圖示（Logo）可註冊為商標，用於區分不同來源的產品，避免市場混淆。

營業秘密

未公開的程式設計細節、資料庫結構、演算法可透過營業秘密方式保護。需依靠企業內部保密協議與管理措施維護。

授權模式

軟體可透過不同授權模式發行，例如專有軟體、自由軟體、開源授權（如GPL、MIT）。不同授權模式影響使用者的修改與再散布權利。

侵權風險

未經授權使用他人程式碼、圖像或演算法可能構成侵權。開發過程應確保程式碼來源合法，避免法律糾紛。

國際保護

智慧財產權具地域性，但可透過國際條約如伯恩公約、TRIPS協議在多國獲得一定程度的保護。

軟體商城

軟體販售平台

在 2026 年，選擇合適的軟體販售平台取決於您的軟體類型與目標市場。以下是主流平台的分類與特性：

通用數位產品與 SaaS 平台

• Paddle / Lemon Squeezy： 專為軟體開發者設計的財務代管平台（Merchant of Record），能自動處理全球各國複雜的數位消費稅與合規問題。
• Gumroad： 介面極簡，適合個人創作者販售小工具、外掛程式或腳本，入局門檻極低。
• AppSumo： 全球知名的軟體促銷平台，適合新產品上線初期透過終身授權方案（LTD）快速獲取大量用戶。
• Shopify： 透過強大的擴充生態系，亦可轉化為販售軟體序號與數位授權的品牌官網。

遊戲與桌面應用分發平台

• Steam： 全球最大的 PC 遊戲商城，擁有最強大的自然流量，但會抽取 30% 的銷售分成。
• Epic Games Store： 提供較具競爭力的 12% 抽成比例，對於使用虛幻引擎開發的作品有額外優惠。
• itch.io： 獨立開發者的首選，支持自由定價與自選抽成比例，適合實驗性質或中小型項目。

企業級與行動應用商城

• App Store / Google Play： 行動端應用程式的唯一主流管道，提供完整的訂閱與內購機制。
• AWS / Azure Marketplace： 適合 B2B 企業軟體，能讓企業客戶直接透過雲端服務帳單進行採購與部署。

台灣本土電子商務平台

• SHOPLINE / CYBERBIZ： 提供完善的在地化金流（如 Line Pay、街口支付），適合經營台灣本土品牌的軟體官網。
• 蝦皮購物： 流量極大，適合販售低單價的數位工具、序號或教學檔案。

平台選用對照表

email: [email protected]

T:0000

資訊與搜尋 | 回dev首頁
email: Yan Sa [email protected] Line: 阿央
電話: 02-27566655 ,03-5924828

阿央
泱泱科技
捷昱科技泱泱企業