Golang on Wayne's blog | 偉恩的部落格 | 技術博客

【K6】壓力測試工具介紹

Tue, 11 Apr 2023 00:00:00 +0000

與老牌工具 JMeter 相比，K6 比較年輕(2017)，架構與設計現代化許多，採用 Go + JavaScript，聽起來就比 Java 年輕有活力。K6 沒有如 JMeter 的華麗友善 GUI，測試細節全靠指令參數與程式碼決定。

K6 核心以 Go 開發，不用擔心程式效能(依文件說明，K6 靠單一主機便可產生每秒 30 萬次請求)；測試程式則採用 ES6 / JavaScript 語言，讓前端/全端工程師備感親切，進階應用需要對 Module、webpack 有點概念，但單純測試一個 .js 就能搞定，不難上手。官方文件整理得頗詳細，建議花點時間約略讀過再上路，許多東西文件都有寫到，不要瞎查資料胡亂嘗試浪費時間。

先釐清一點，雖然口語上我們很習慣說「壓力測試」或「壓測」，實際上這些相關測試可再細分成：煙霧測試、負載測試、壓力測試、尖峰測試、浸泡測試，下文會再詳細說明。

不過，「壓力測試」是比較通俗常用的說法，所以我會繼續統稱壓力測試，有特定目標的測試再特別區分。

介紹

K6 是用 Go 語言編寫的一種高效能的負載測試工具。具有下面幾個特點：

K6 嵌入了 JavaScript runtime，可以使用 JavaScript ES2015、ES6 來編寫指令碼。
強大的 CLI 工具。
使用 Checks 和 Thresholds 可以更加輕鬆的做面向目標的自動化的負載測試。

Checks：類似斷言功能，但不會真的中斷執行，只是會返回 check 的數據百分比。
Thresholds：極限值、門檻、閾值，指測試系統性能所預期的通過 or 失敗的標準。

為什麼要用 K6？

他是用 JavaScript 直接進行負載測試(JavaScript 腳本 ➡️ Go 底層運作)

這對專注於寫 JavaScript 的人是一大福音！

以自身公司而言，大多都是 JavaScript 為基底的測試，所以如果團隊中能夠統一一種語言，不管是在測試、開發上，能降地學習成本及提高協做效率。

如何安裝？

MacOS

記得先安裝 Homebrew

1

brew install k6

Windows

方法一：使用 chocolatey 安裝(需先安裝 Chocolatey package manager)

1

choco install k6

方法二：使用 winget 安裝

1

winget install k6

Linux

Debian/Ubuntu

1
2
3
4


sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install k6

Fedora/CentOS

1
2


sudo dnf install https://dl.k6.io/rpm/repo.rpm
sudo dnf install k6

了解 K6 能做到哪些負載測試

Smoke Testing 煙霧測試 - 驗證系統在最低硬體配備、正常負載下不會出錯
Load Testing 負載測試(Performance Testing 效能測試) - 取得在一般及尖峰負載下的系統效能數字(用戶數、Throughput、吞吐量(RPS))
Stress Testing 壓力測試 - 測試在高度負載或極端條件下系統的穩定性及可靠度，找出系統極限(請勿在 production 測試)
Spike Testing 尖峰測試 - 故意製造瞬間流量驟升取得系統效能數字(請勿在 production 測試)
Soak Testing 浸泡測試 - 測試系統在長期運作下的穩定性及可靠度

大致上的分類為（低中高流量每間公司定義都不一樣）：

低流量	中等流量	高流量
Smoke Testing 煙霧測試	Load Testing 負載測試(Performance Testing 效能測試)	Stress Testing 壓力測試
Soak Testing 浸泡測試	Spike Testing 尖峰測試

小試身手

在 Windows 安裝很容易，我是用 Chocolatey choco install -y k6 兩分鐘搞定。寫幾行程式存成 script.js，再執行 k6 run script.js 便做能完簡單測試，得到平均回應時間(http_req_duration) 及 Throughput (http_reqs)：

script.js

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import http from "k6/http";
import { sleep } from "k6";

export const options = {
 vus: 1, // user count
 duration: '1s'
};

export default function () {
 http.get("https://test.k6.io");
};

執行指令：

1

k6 run script.js

參數設定

K6 提供的參數很多，以下主要介紹幾個較常用的為主：

vus

虛擬用戶的數量，最少必須要 1 個，與 duration 搭配使用。

duration

指定測試運行的總持續時間，與 vus 一起使用。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import http from 'k6/http';
import { sleep } from 'k6';
export const options = {
 vus: 1,
 duration: '1s',
};

export default function () {
 http.get('https://test.k6.io');
 sleep(1);
}

CLI：

1

k6 run --vus 1 --duration 1s script.js

iterations

腳本中的函數被執行的次數。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import http from 'k6/http';
import { sleep } from 'k6';
export const options = {
 vus: 10,
 duration: '5s',
 iterations: 50
};

export default function () {
 http.get('https://test.k6.io');
 sleep(1);
}

CLI：

1

k6 run --vus 10 --duration 5s --iterations 50 script.js

表示「模擬 10 個用戶，此次腳本最多就是執行 50 次，如果 50 次腳本沒執行完，時間卻到了，那此次測試會顯示 default ✗」。

Stages

可以指定在特定時間內增加或減少用戶數量的執行方式，也就是說可以模仿更精準的測試情境。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


import http from 'k6/http';
import { sleep } from 'k6';
export let options = {
 stages: [
 { duration: '30s', target: 10 },
 { duration: '1m30s', target: 30 },
 { duration: '20s', target: 0 },
 ],
};

export default function () {
 http.get('https://test.k6.io');
 sleep(1);
}

CLI：

1

k6 run --stage 30s:10, -s 1m30s:30, -s 20s:0 .\script.js

第一階段就是在 30 秒間逐步把用戶加到 10 個
第二階段就是在一分半內逐步從 10 個用戶追加到 30 個用戶
第三階段是在 20 秒內逐步從 30 個用戶降到 0 個用戶個用戶

rps

用戶每秒可以發送最大的 request 數量。

其實就是為了更好模擬用戶流量，再測試前須確認好測試範疇，多數平台應該都是在某些時間點流量會增大，但這個流量增大並非是無上限的增大，一定會落在某個數值，只要將數值取出來後並換算。

e.g:
查看數據後，發現這個時段會有 100000 個 request 數量
那我們要測試的是 60 秒能要達到 100000
那就是 100000/60 = 1666
1666 出來後，我們都會多估 10~20% 以防萬一，所以總計大約 2000 即是 rps 的數量

若要更準確的符合真實數據，也可以以下這樣計算：

1
2
3
4
5


用戶量 100 vus
執行時間 60s
request 條件是 100000
那就是一位 user rps 就是 100000/100/60 = 16
通常 rps 的範疇會多估 10-20% 以防萬一，所以湊個整數 20 就是較符合的數值

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import http from 'k6/http';
import { sleep } from 'k6';
export const options = {
 vus: 100,
 duration: '60s',
 rps: 20
};

export default function () {
 http.get('https://test.k6.io');
 sleep(1);
}

group

主要就是將按照功能進行組裝在同一個測試腳本。

可以針對測試方法做調整，通常在測試 API 時可能是一個行為，但是是會多個 API 連續調用的情況。

這時候可以使用 group 方法來實現，以下是官網的例子。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import { group } from 'k6';

export default function () {
 group('user flow: returning user', function () {
 group('visit homepage', function () {
 // load homepage resources
 });
 group('login', function () {
 // perform login
 });
 });
}

如上方例子，可以將整個登入流程加入一個群組，測試結果會多一個指標 group_duration，就可方便得知這一個 group 平均執行時間。

另外，官方也寫到：
Discouraged: one group per request
Wrapping each request within a group might add unnecessary boilerplate.

意味著這個 group 功能不建議僅拿來組裝單一 API，它不是一個像單回傳 api module 般的使用。

這樣就失去 group 功能真正的涵義了。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import { group, check } from 'k6';
import http from 'k6/http';

const id = 5;

// reconsider this type of code
group('get post', function () {
 http.get(`http://example.com/posts/${id}`);
});
group('list posts', function () {
 const res = http.get(`http://example.com/posts`);
 check(res, {
 'is status 200': (r) => r.status === 200,
 });
});

scenarios

顧名思義，就是測試的情境的參數。

在做效能測試前，通常都會先擬定好要測試的情境，蒐集真實數據進行評估，再進一步評估預期達到的目標再哪。

所以可以先將一些常用的測試寫好。只要引用一下，設定一下立刻可以達到我們想要測試的結果。

只要針對每個情境實作好了一些 Executors，最後只要呼叫它即可。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import http from 'k6/http';

export let options = {
 discardResponseBodies: true,
 scenarios: {
 contacts: {
 executor: 'constant-arrival-rate',
 rate: 200, // 200 RPS, since timeUnit is the default 1s
 duration: '1m',
 preAllocatedVUs: 50,
 maxVUs: 100,
 },
 },
};

export default function () {
 http.get('https://test.k6.io/contacts.php');
}

使用這個範例，K6 會盡所能在 duration 內去達到 200 RPS。

所以只要使用這個方法，可以很快找到你 API 的極限瓶頸在哪。

group vs scenarios

group：通常一套業務邏輯且會被重複使用。
scenarios：純粹一個情境、一個故事，為了要讓單一邏輯或 group 能夠被相互組合應用，需要多種不同的參數，用戶數量(vus)、持續時間(duration)等等，以便達到該情境的預期結果。

常看的指標

Http 系列

http_req_receiving： API 從 server 回應所花費的時間
http_req_sending： API 發送到 server 所花費的時間
http_req_waiting： API 從 server 等待回應所花費的時間
http_req_duration： API 請求的總時間(http_req_sending + http_req_waiting + http_req_receiving)
http_req_failed： API 失敗的機率(預設 status code 是 200，若有特別判斷可使用 expectedStatuses)
iteration_duration：該腳本執行一次所花費的時間
http_reqs：會計算測試總共發了多少 request

上述的參數，主要可以分析整個測試的過程，同時也可以了解該 API 的詳細資料針對響應速度、等待回應時間等等，好讓相關團隊可以進行優化分析。

http_req_receiving、http_req_sending、http_req_waiting 三者關係圖

Checks

其實就是類似斷言。僅會返回通過(pass)或失敗(fail)

但這邊的斷言是，不論成功或失敗，腳本皆仍會繼續執行。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


export default function () {
 const res = http.get('http://test.k6.io/');
 check(res, {
 'is status 200': (r) => r.status === 200,
 });
}

// or

export default function () {
 const res = http.get('http://test.k6.io/');
 check(res, {
 'is status 200': (r) => r.status === 200,
 'body size is 11,105 bytes': (r) => r.body.length == 11105,
 });
}

但如果要需要特別處理錯誤情境時，可以使用 Thresholds。

Thresholds

強烈建議多參考官方文檔，寫得非常清楚。

主要是可以為測試的結果自訂一個標準限制，中文稱為門檻值。

可以針對各個指標限制於某個條件，相對來說會更彈性，測試會更為準確。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import http from 'k6/http';

export const options = {
 thresholds: {
 http_req_failed: ['rate<0.01'], // http request 失敗的總比例要低於 1% 才能算通過
 http_req_duration: ['p(95)<200'], // 95% 的 requests 數回傳時間都要低於 200ms 以內才算通過
 },
};

export default function () {
 http.get('https://test-api.k6.io/public/crocodiles/1/');
}

其中 http_req_duration 的 p(95) 高於 200ms 了，所以它就會顯示 some thresholds have failed

Threshold 其實與 Check 有點類似，但差別在於：

Check 設定比較單一且執行失敗的話，腳本仍會繼續執行，直到腳本結束，才會返回 Check 的數據值。
Threshold 可以彈性設定條件且執行失敗的話，它還可以自行設置中斷點，讓執行中腳本達到某條件的話，就直接中斷並且返回錯誤資訊。

aborting sample code(可自行設定中斷點 sample code)：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


export const options = {
 vus: 30,
 duration: '2m',
 thresholds: {
 http_req_duration: [{ threshold: 'p(90) < 400', abortOnFail: true }] //90% 的 requests 數回傳時間都要低於 400ms 以內才算通過，只要一旦高於 400ms 就會直接中斷測試
 }
};

export default function () {
 http.get('https://test-api.k6.io/public/crocodiles/1/');
}

其中 http_req_duration 的 p(95) 高於 200ms 了，所以它就會顯示 some thresholds have failed

常見的套件(module)

K6 套件(module) 基本上我覺得很萬用，是足夠支撐所有測試情境的，也主要介紹幾個較常用的 K6 本身支援的 module (JavaScript API)

http

主要是能發送 API，常使用為 get、post、put、delete…等。

GET sample code：

1
2
3
4
5
6
7
8
9


import http from 'k6/http';
export const options = {
 vus: 1,
 duration: '1s',
};

export default function () {
 http.get('https://test.k6.io');
}

POST sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


import http from 'k6/http';

const url = 'https://httpbin.test.k6.io/post';
const logoBin = open('./logo.png', 'b');
export default function () {
 let data = { name: 'Bert' };

 // Using a JSON string as body
 let res = http.post(url, JSON.stringify(data), {
 headers: { 'Content-Type': 'application/json' },
 });
 console.log(res.json().json.name); // Bert

 // Using an object as body, the headers will automatically include
 // 'Content-Type: application/x-www-form-urlencoded'.
 res = http.post(url, data);
 console.log(res.json().form.name); // Bert

 // Using a binary array as body. Make sure to open() the file as binary
 // (with the 'b' argument).
 http.post(url, logoBin, { headers: { 'Content-Type': 'image/png' } });

 // Using an ArrayBuffer as body. Make sure to pass the underlying ArrayBuffer
 // instance to http.post(), and not the TypedArray view.
 data = new Uint8Array([104, 101, 108, 108, 111]);
 http.post(url, data.buffer, { headers: { 'Content-Type': 'image/png' } });
}

html

解析 HTML 各元素，可能會需要取得 HTML 上的一些元素值做一些處理或換算。

sample code：

1
2
3
4
5
6
7
8


import http from 'k6/http';

export default function () {
 const res = http.get('https://k6.io');
 const doc = parseHTML(res.body); // equivalent to res.html()
 const pageTitle = doc.find('head title').text();
 const langAttr = doc.find('html').attr('lang');
}

sleep

主要就是等待時間，有些時候使用 sleep 是為了更好模擬使用者情境。

因為使用者真實操作 web 可能都會遇到有 loading 渲染的時間，所以我們將 sleep 算進來的話就當作是再重現這部分。

sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import http from 'k6/http';
import { sleep } from 'k6';
export const options = {
 vus: 1,
 duration: '1s',
};

export default function () {
 http.get('https://test.k6.io');
 sleep(1);
}

crypto

這一定也不陌生，非常強大的加密 module ，支援多種不同的加密方式如下：

hmac
md4
md5
sha256
sha384
sha512

通常是為了確保用戶資料安全而特別處理的。e.g. 密碼、API header 等。

sample code：

1
2
3
4
5
6
7
8
9


import crypto from 'k6/crypto';

export default function () {
 console.log(crypto.sha256('hello world!', 'hex'));
 const hasher = crypto.createHash('sha256');
 hasher.update('hello ');
 hasher.update('world!');
 console.log(hasher.digest('hex'));
}

respone：

1

INFO[0000] 7509e5bda0c762d2bac7f90d758b5b2263fa01ccbc542ab5e3df163be08e6ca9

encoding

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import { check } from 'k6';
import encoding from 'k6/encoding';

export default function () {
 const str = 'hello world';
 const enc = 'aGVsbG8gd29ybGQ=';
 const buf = new Uint8Array([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]).buffer;
 check(null, {
 'is encoding string correct': () => encoding.b64encode(str) === enc,
 'is encoding ArrayBuffer correct': () => encoding.b64encode(buf) === enc,
 });
}

JSlib

K6 本身支援蠻多受用的套件，但除此之外，他們還有支援一個是 JSlib 顧名思義就是 JS 庫。

我覺得可以把它當作是外掛包因為其中還支援的很多額外的 module 可用。

httpx：是將 k6/http 原本套件加以簡化處理，可以當成是優化版的 http
k6chaijs：適用於 BDD 和 TDD 斷言風格

k6chaijs sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import { describe, expect } from 'https://jslib.k6.io/k6chaijs/4.3.4.1/index.js';
import http from 'k6/http';

export const options = {
 thresholds: {
 checks: [{ threshold: 'rate == 1.00' }], // fail test on any expect() failure
 },
};

export default function testSuite() {
 describe('Basic API test', () => {
 const response = http.get('https://test-api.k6.io/public/crocodiles');
 expect(response.status, 'API status code').to.equal(200);
 });
}

utils： K6 的小工具包

utils sample code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import { sleep } from 'k6';
import http from 'k6/http';

import {
 randomIntBetween,
 randomString,
 randomItem,
 uuidv4,
 findBetween,
} from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';

export default function () {
 const res = http.post(`https://test-api.k6.io/user/register/`, {
 first_name: randomItem(['Joe', 'Jane']), // random name
 last_name: `Jon${randomString(1, 'aeiou')}s`, //random character from given list
 username: `user_${randomString(10)}@example.com`, // random email address,
 password: uuidv4(), // random password in form of uuid
 });

 // find a string between two strings to grab the username:
 const username = findBetween(res.body, '"username":"', '"');
 console.log('username from response: ' + username);

 sleep(randomIntBetween(1, 5)); // sleep between 1 and 5 seconds.
}

aws：主要是可以直接串接 AWS 上的 API 服務。

總結

k6 官方提供的文檔其實都非常好懂，甚至都會附上很多程式碼範本讓你直接使用。

基本上只要會 javascript，你就可能無痛起手了。

另外 k6 這框架大多使用的情境是以下：

適用人員	描述
開發人員、SDET	方便我們透過 K6 提供的 api 以及 CLI 工具來使用開發且開發人員同常對 javascript 也不太陌生，他們也能快速使用 javascript 來開發模擬真實場景的負載測試
DevOps、SRE	這兩個職位都是偏運維方面的，我們能把上面 SDET 開發的 script 拿來進行自動化的壓力測試，確保我們的基礎建設與應用服務都還是保持著高性能的表現。在 K6 開發的 script 內，設定 SLO 來測試服務的運行狀況是否達標
QA	更方便的寫測試案例與腳本，跑起來也很快，還能跟 Postman、Swagger 等整合，對 QA 來說是很方便的

Golang 的超級初心者筆記

Fri, 10 Feb 2023 00:00:00 +0000

參考網站
 參考網站
 參考網站
 參考網站

簡介

Go 語言是由 Google 開發的開放原始碼項目，目的之一為了提高開發人員的程式設計效率。
Go 語言語法靈活、簡潔、清晰、高效。它對併發的特性可以方便地用於多核處理器和網絡開發，同時靈活新穎的類型系統可以方便地撰寫模組化的系統。
Go 可以快速編譯，同時具有記憶體垃圾自動回收功能，並且還支持運行時反射。
Go 是一個高效、靜態類型，但是又具有解釋語言的動態類型特徵的系統級語法。

由來！？

下載中斷是再正常不過的事，但對知名 Google 程式設計師菲茲派翠克（Brad Fitzpatrick）來說，這件事情太難以忍受。

令人不耐的下載速度

其實他並不孤單，多年來很多人都曾抱怨 dl.google.com 系統不夠穩定。

這個系統非常重要，任務範圍幾乎涵蓋所有 Google 下載任務，包括 Chrome 瀏覽器安裝、Android 原始程式碼，以及較小的 JavaScript。但，問題是該檔案伺服器系統的基礎代碼已經超過五年，相當老舊。

菲茲派翠克認為代碼必須不斷更新提升，最初的 C++ 語言缺乏規範的文檔，自動化測試也未達水準，沒有人能搞懂它，只是不斷做一些小幅改變。最後在負責維護的程式人員眼裡，這些代碼根本是一團糟。

不穩定的系統讓伺服器運營團隊相當苦惱，但沒有人有時間重寫代碼。於是菲茲派翠克自告奮勇接手，他在 Google 底下的 25 人工程師團隊 —– 地鼠隊（Gopher Team）中，負責開發一種程式設計語言命名為 Go。這個機會讓他非常興奮。(以上內容節錄自 Wired)

為什麼要學習 Golang？

Golang 易學易用：Golang 基本上是強化版的 C 語言，都以核心語法短小精要著稱。
Golang 是靜態型別語言：很多程式的錯誤在編譯期就會挑出來，相對易於除錯。
Golang 編譯速度很快：帶動整個開發的流程更快速。
Golang 支援垃圾回收：網頁程式較接近應用程式，而非系統程式，垃圾回收在這個情境下不算缺點；此外，使用垃圾回收可簡化程式碼。
Golang 內建共時性的語法：goroutine 比起傳統的執行緒 (thread) 來說輕量得多，在高負載時所需開銷更少。
Golang 是跨平台的：只要程式中不碰到 C 函式庫，在 Windows (或 Mac) 寫好的 Golang 網頁程式，可以不經修改就直接發布在 GNU/Linux 伺服器上。
Golang 的專案不需額外的設定檔：在專案中，只要放 Golang 程式碼和一些 assets 即可運作，所需的工具皆內建在 Golang 主程式中，省去學習專案設罝的功夫。
Golang 沒有死硬的程式架構：用 Golang 寫網頁程式思維上接近微框架 (micro-framework)，只要少數樣板程式碼就可以寫出網頁程式，也不限定可用的第三方函式庫。
Golang 函式庫很多，甚至可以直接使用 GitHub 上面的函式庫。
Golang 多傳回值，你函式的回傳值可以是多個。
真要說的話，真的列舉不完，以上幾點是我特別看中喜愛的點，希望能勾起大家對於 Golang 的興趣！

但 Golang 並非完美無缺，以下是要考量的點：

Golang 並非完整的物件導向 (object-oriented) 語言，頂多是基於物件的 (object-based) 語言。
Golang 的語言特性相對少：這是 Golang 時常被攻擊的點，這只能靠自己調整寫程式的習慣。
在一些情境下，Golang 程式碼相對笨拙冗餘，像是排序 (sorting)。

開發環境設定

Go 本身支援 Cross Compile 當然有準備各個平台的安裝方法囉！每次發佈的版本都會包括知名的三大平台 (Windows, Linux, Mac OS)，立刻就去下載安裝！

檔案下載網址

等等！Unix Like 的使用者先等等，有個更好用的東西可以讓各位使用，我們有 GVM 可以用，GVM 可以有效的管理 Go 的版本，連 GOPATH 都幫你設定好，超方便的！即時是最新的也都能馬上使用他下載安裝，真的是棒的沒話說，就讓我們來使用他吧！記得要先看一下 Requirements 喔，不然會裝不起來。

另外我的部落格有輕鬆搭建 Go 開發環境的教學 - 在 Windows 平台打造完美的 Go 開發環境 (WSL 2)，可以直接參考該篇文章進行搭建！(開發工具使用 Visual Studio Code)

Go 指令

在終端機上執行 go 指令就會看到一系列的指令介紹：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


$ go
Go is a tool for managing Go source code.

Usage:

 go command [arguments]

The commands are:

 bug start a bug report
 build compile packages and dependencies
 clean remove object files and cached files
 doc show documentation for package or symbol
 env print Go environment information
 fix update packages to use new APIs
 fmt gofmt (reformat) package sources
 generate generate Go files by processing source
 get add dependencies to current module and install them
 install compile and install packages and dependencies
 list list packages or modules
 mod module maintenance
 work workspace maintenance
 run compile and run Go program
 test test packages
 tool run specified go tool
 version print Go version
 vet report likely mistakes in packages

Use "go help <command>" for more information about a command.

Additional help topics:

 buildconstraint build constraints
 buildmode build modes
 c calling between Go and C
 cache build and test caching
 environment environment variables
 filetype file types
 go.mod the go.mod file
 gopath GOPATH environment variable
 gopath-get legacy GOPATH go get
 goproxy module proxy protocol
 importpath import path syntax
 modules modules, module versions, and more
 module-get module-aware go get
 module-auth module authentication using go.sum
 packages package lists and patterns
 private configuration for downloading non-public code
 testflag testing flags
 testfunc testing functions
 vcs controlling version control with GOVCS

Use "go help <topic>" for more information about that topic.

如果對於某個指令特別需要幫助可以用 go help [topic] 指令。

這邊特別介紹的有四個指令：go run、go build、go install、go clean。

go run

直接執行 golang code。

1
2
3


go run src/helloWorld/main.go

> Hello World

go build

build，如果沒有錯誤就產生執行檔於當前目錄。

1

go build

build 後產生的檔案即是執行檔。

go install

如果沒有錯誤則產生執行檔於 $GOPATH/bin。

1
2
3
4
5
6


go install

# 查看執行檔
ls $GOPATH/bin

> helloWorld

go clean

執行後會將 build 產生的檔案都刪除。(install的不會刪)

1

go clean

Javascript v.s. Golang

由於我是從前端寫到後端，這邊用吃飯工具 Javascript 與 Golang 做個寫法比較。

Hello World

Javascript：

1

console.log("hello world");

Golang：

1
2
3
4
5
6
7
8


package main
import (
 "fmt"
)

func main() {
 fmt.Println("hello world")
}

Array

Javascript：

1

const names = ["hello", "world"];

Golang：

1

names := []string { "hello", "world" }

印出後面幾個字的子字串

Javascript：

1
2


let game = "hello world";
console.log(game.substr(8, game.length));

Golang：

1
2


game := "hello world"
fmt.Println(game[8: ])

流程控制

Javascript：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


const gender = 'female';

switch (gender) {
 case 'female':
 console.log("you are a girl");
 break;
 case 'male':
 console.log("your are a boy");
 break;
 default:
 console.log("you are a third gender");
}

Golang：

1
2
3
4
5
6
7
8
9


gender := "female"
switch gender {
case "female":
 fmt.Println("you are a girl")
case "male":
 fmt.Println("your are a boy")
default:
 fmt.Println("you are a third gender")
}

看來 Go 省略了 break 這關鍵字。

Loop

Javascript 有 for loop、while loop、do while loop。
Go 只有 for loop 就能模擬上面三個。
Golang：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


for i := 0; i < 10; i++ {
 fmt.Println(i)
}

// key value pairs
kvs := map[string]string {
 "name": "wayne blog",
 "website": "https://blog.wayne-project.com/",
}

for key, value := range kvs {
 fmt.Println(key, value)
}

Object

Javascript：

1
2
3
4
5
6


const Post = {
 ID: 10213107,
 Title: "Golang 的新手教學",
 Author: "Wayne",
 Difficulty: "Beginner"
}

Golang：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


type Post struct {
 ID int
 Title string
 Author string
 Difficulty string
}

p := Post {
 ID: 10213107,
 Title : "Golang 的新手教學",
 Author: "Wayne",
 Difficulty:"Beginner",
}

Go 能透過定義抽象的 struct 與其屬性，再實例化。

也能透過 map[string]interface 來定義：

1
2
3
4
5
6


Post := map[string]interface{} {
 "ID": 10213107,
 "Title" : "Golang 的新手教學",
 "Author": "Wayne",
 "Difficulty":"Beginner",
}

舉幾個例子比較一下，後面會慢慢補充。

變數型態與宣告方式

Go 和你所知道的大多數語言相同，會有各種型態，如果你有學過 C 語言，這邊你可以很輕鬆的看過去，而且你會發現它跟 C 語言有許多相似之處，Go 之所以被稱為「21 世紀 C 語言不是沒有原因」，另外如果沒有學過，也別擔心，它沒有很困難，那就讓我們來認識看看有哪些型態。

整數

整數的型態很多種，以下表格是 Go 語言擁有的整數型態，以及它的範圍。

類型	位元	值的範圍
int8	1	-128 ~ 127
uint8(byte)	1	0 ~ 255
int16	2	-32768 ~ 32767
uint16	2	0 ~ 65535
int32	4	-2147483648 ~ 2147483647
uint32	4	0 ~ 4294967295
int64	8	-9223372036854775808 ~ 9223372036854775807
uint64	8	0 ~ 18446744073709551615
int	視平台而定	視平台而定
uint	視平台而定	視平台而定
uintptr	同指標	32 位元平台： 4 位元 64 位元平台： 8 位元

PS：unit(unsigned integer) 意味沒有符號的整數

範例：

1
2
3
4
5
6
7


package main

import "fmt"

func main() {
 fmt.Println("1 + 1 =", 1 + 1)
}

浮點數

浮點數囊括任何帶有小數點的數值(.00也算在浮點數)。
浮點數包涵兩種型態 float32、float64。
要注意的是，如果初始化的時候沒有加小數點會被推斷為整數，另外初始化的時候沒有指定型態的話，會被自動推斷為 float64。
float64 在 Go 語言相當於 C 語言的 Double，且 float32 與 float64 是無法一起計算的，需要強制轉型。

範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 var floatValue float64
 floatValue = 7.0
 var floatValue2 = 3.0
 fmt.Println("7.0/3.0 =", floatValue/floatValue2)

 var test float64
 var test2 float32
 test = 1.1
 test2 = 2.2
 fmt.Println("test + test2 =", float32(test) + test2)
}

複數

複數包涵兩種型態 complex64、complex128。
我覺得算是 Go 的特色之一，其他語言很少有這種型態，一個完整的複數需要包涵實數、虛數。
如果是初始化讓 Go 自動判斷型態的型態會是 complex128，而不會是 complex64。

範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import "fmt"

func main() {
 var complexValue complex64
 complexValue = 1.2 + 12i
 complexValue2 := 1.2 + 12i
 complexValue3 := complex(3.2, 12)

 fmt.Println("complexValue =", complexValue)
 fmt.Println("complexValue2 =", complexValue2)
 fmt.Println("complexValue3 =", complexValue3)

 fmt.Println("complexValue3 實數 =", real(complexValue3))
 fmt.Println("complexValue3 虛數 =", imag(complexValue3))
}

字串

請注意字串型態無法在初始化後被修改。

範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 fmt.Println("1" + "1")
 fmt.Println(len("Hello World"))
 fmt.Println("Hello World"[1])
 fmt.Println("Hello" + "World")

 a := "Hello World"
 fmt.Printf("%c",a[1])
}

布林

Go 語言中的布林與其他語言一致，關鍵字一樣是 bool，可以賦予值為 true 和 false。

範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main() {
 var a bool
 a = true
 fmt.Println("a =", a)

 b := false
 fmt.Println("b =", b)

 fmt.Println(true && true)
 fmt.Println(true && false)
 fmt.Println(true || true)
 fmt.Println(true || false)
 fmt.Println(!true)
}

如何宣告？

Golang 在變數宣告的一開始是不需要指定型別的。

例如這樣即可：

1

var myName

如果宣告時順便初始化可以這樣寫：

1

var myName = "Wayne"

或是有更簡潔的寫法：

1

myName := "Wayne"

當然也可以一次宣告很多個：

1

myName, myAge, isPassed := "Wayne", 18, true

Q：你可能會問，那我這樣寫會發生什麼事？

1

myName, myAge, isPassed := "Wayne", 18

A：那個 isPassed 將不會被初始化。

如果想要指定變數型態的話，只需要在 var 後面加上指定型態即可：

1
2
3
4
5


var (
 myName string = "Wayne"
 myAge int = 18
 isPassed boolean = true
)

記得每個變數要不同行，中間不需要逗號分隔

最後有個比較特別的：常數(const)，常數為一個固定值，當然之後在程式內是不允許被修改的。

1
2


const pi = 3.14
const hello_str = "Hello World"

迴圈

Go 只有一種迴圈 -「for」。

除了基本的「for」迴圈，沒有了「()」之外（甚至強制不能使用它們），它看起來跟 C 或者 Java 中做的一樣，而「{}」是必須的。

for

1
2
3


for i := 0; i <= 100; i++ {
 // do something
}

巢狀迴圈

1
2
3
4
5


for i := 0; i <= 100; i++ {
 for j := 0; j <= 100; j++ {
 // do something
 }
}

while 用法的 for 迴圈

1
2
3
4


i := 0
for i <= 10 {
 // do something
}

無窮迴圈

1
2
3


for {
 // do something
}

break

break 終止迴圈執行。

1
2
3
4
5
6
7
8


i := 0
for {
 // do something
 if i >= 100 {
 break;
 }
 i++
}

continue

有 break 當然也會有 continue，continue 就是略過本次的迴圈，直接進行下一輪：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


for {
 i++
 if i % 2 == 0 {
 continue
 }
 fmt.Print(i)
 if i > 50 {
 break
 }
}

if 條件判斷

if 語句除了沒有了「()」之外（甚至強制不能使用它們），看起來跟 C 或者 Java 中的一樣，而「{}」是必須的。

if

如果為 true 就執行，如果為 false 的話就不會執行：

1
2
3
4
5
6
7
8
9


if true {
 fmt.Println("This is true")
}
if false {
 fmt.Println("This line will not be executed")
}

// 輸出結果：
// This is true

&&：且
||：或

1
2
3
4
5
6
7
8


sex := "male"
age := 20
if sex == "male" && age >= 18 {
 fmt.Println("成年男性")
}

// 輸出結果：
// 成年男性

相反(`!`)

在 ture 或 false 之前加上!，會使結果顛倒，true 會變成 false，false 變成 true。

1
2
3
4
5
6
7
8
9


if !true {
 fmt.Println("This is !true")
}
if !false {
 fmt.Println("This is !false")
}

// 輸出結果：
// This is !false

if…else

1
2
3
4
5
6
7
8
9


myMoney := 100
if myMoney > 99 {
 fmt.Println("I can buy it")
} else {
 fmt.Println("I can't buy it")
}

// 輸出結果：
// I can buy it

if…else if

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


myMoney := 100
iceCream := 20
if myMoney-iceCream > 50 {
 fmt.Println("buy it!")
} else if myMoney-iceCream < 50 {
 fmt.Println("sorry, I won't buy")
}

// 輸出結果：
// buy it!

if…else if…else

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


myMoney := 100
ferrari := 450
bmw := 250

if myMoney > ferrari {
 fmt.Println("buy Ferrari")
} else if myMoney > bmw {
 fmt.Println("buy BMW")
} else {
 fmt.Println("buy Toyota")
}

// 輸出結果：
// buy Toyota

if 簡短的敘述

跟「for」一樣，「if」語句可以在條件之前執行一個簡單的語句，由這個語句定義的變數的作用範圍僅在「if」範圍之內。

（在最後的 return 語句處使用 v 看看。）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import (
 "fmt"
 "math"
)

func pow(x, n, lim float64) float64 {
 if v := math.Pow(x, n); v < lim {
 return v
 }
 return lim
}

func main() {
 fmt.Println(
 pow(3, 2, 10),
 pow(3, 3, 20),
 )
}

// 輸出結果：
// 9 20

switch 條件判斷

switch 在很多情況下可以取代 if 的功能，而且寫起來會更加簡潔。

範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


myfriend := "Tony"
switch myfriend {
 case "Amy":
 fmt.Println("Hi, Amy")
 case "Tony":
 fmt.Println("Hi bro")
 case "Jackey":
 fmt.Println("GO AWAY!")
}

// 輸出結果：
// Hi bro

要注意的是 case 中只需要:，並不需要 {} 來分隔。

default

如果都不在 case 裡的情況就會執行 default：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


myfriend := "Jason"
switch myfriend {
case "Amy":
 fmt.Println("Hi, Amy")
case "Tony":
 fmt.Println("Hi bro")
case "Jackey":
 fmt.Println("GO AWAY!")
default:
 fmt.Println("Nice to meet you, but who are you?")
}

// 輸出結果：
// Nice to meet you, but who are you?

fallthrough

在 case 中加入 fallthrough，會接著執行下一個 case。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


myfriend := "Amy"
switch myfriend {
case "Amy":
 fmt.Println("Hi, Amy")
 fallthrough
case "Tony":
 fmt.Println("Hi bro")
case "Jackey":
 fmt.Println("GO AWAY!")
default:
 fmt.Println("Nice to meet you, but who are you?")
}

// 輸出結果：
// Hi, Amy
// Hi bro

多重 case

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


myfriend := "Paul"
switch myfriend {
 case "Amy", "Emily":
 fmt.Println("Hi, beautiful gril")
 case "Tony", "Paul":
 fmt.Println("Hi bro")
}

// 輸出結果：
// Hi bro

switch 沒有對象

這個情況就有點像是 if 的功能了：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


myMoney := 100
switch {
 case myMoney > 500:
 fmt.Println("buy Ferrari")
 case myMoney > 250:
 fmt.Println("buy BMW")
 default
 fmt.Println("buy Toyota")
}

// 輸出結果：
// buy Toyota

BONUS(一)：goto

Go 語言跟 C 語言一樣也有「goto」，但是不建議使用，會讓程式的結構變得很糟糕。

1
2
3
4
5
6
7
8
9


func main() {
 i := 0
HERE:
 fmt.Print(i)
 i++
 if i < 10 {
 goto HERE
 }
}

BONUS(二)：defer

就許多現代語言而言，例外處理機制是基本特性之一，然而，例外處理是好是壞，一直以來存在著各種不同的意見，在 Go 語言中，沒有例外處理機制，取而代之的，是運用 defer、panic、recover 來滿足類似的處理需求。

defer

在 Go 語言中，可以使用 defer 指定某個函式延遲執行，那麼延遲到哪個時機？簡單來說，在函式 return 語句之後準備返回呼叫的函式之前，例如：

延遲效果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


func myfunc() {
 fmt.Println("B")
}

func main() {
 defer myfunc()
 fmt.Println("A")
}

// 輸出結果：
// A
// B

可在返回之前修改返回值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


func Triple(n int) (r int) {
 defer func() {
 r += n // 修改返回值
 }()

 return n + n // <=> r = n + n; return
}

func main() {
 fmt.Println(Triple(5))
}

// 輸出結果：
// 15

變數的快照

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


func main() {
 name := "go"
 defer fmt.Println(name) // 變數 name 的值被記住了，所以會輸出go

 name = "python"
 fmt.Println(name) // 輸出：python
}

// 輸出結果：
// python
// go

應用

反序調用

如果有多個函式被 defer，那麼在函式 return 前，會依 defer 的相反順序執行，也就是 LIFO，例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


func deferredFunc1() {
 fmt.Println("deferredFunc1")
}

func deferredFunc2() {
 fmt.Println("deferredFunc2")
}

func main() {
 defer deferredFunc1()
 defer deferredFunc2()
 fmt.Println("Hello, 世界")
}

// 輸出結果：
// Hello, 世界
// deferredFunc2
// deferredFunc1

defer 與 return

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


func f() {
 r := getResource() // 0: 獲取資源
 // ......
 if ... {
 r.release() // 1: 釋放資源
 return
 }
 // ......
 if ... {
 r.release() // 2: 釋放資源
 return
 }
 // ......
 r.release() // 3: 釋放資源
 return
}

使用 defer 後，不論在哪 return 都會執行 defer 後方的函數，如此便不用在每個 return 前寫上 r.release()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


func f() {
 r := getResource() // 0: 獲取資源

 defer r.release() // 1: 釋放資源
 // ......
 if ... {
 // ...
 return
 }
 // ......
 if ... {
 // ...
 return
 }
 // ......
 return
}

以下是清除資源的範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package main

import (
 "fmt"
 "os"
)

func main() {
 f, err := os.Open("/tmp/dat")
 if err != nil {
 fmt.Println(err)
 return;
 }

 defer func() { // 延遲執行，而且函式 return 後一定會執行
 if f != nil {
 f.Close()
 }
 }()

 b1 := make([]byte, 5)
 n1, err := f.Read(b1)
 if err != nil {
 fmt.Printf("%d bytes: %s\n", n1, string(b1))
 // 處理讀取的內容...
 }
}

BONUS(三)：panic()

如果在函式中執行 panic()，那麼函式的流程就會中斷，若 A 函式呼叫了 B 函式，而 B 函式中呼叫了 panic()，那麼 B 函式會從呼叫了 panic 的地方中斷，而 A 函式也會從呼叫了 B 函式的地方中斷，若有更深層的呼叫鏈，panic 的效應也會一路往回傳播。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import (
 "fmt"
 "os"
)

func check(err error) {
 if err != nil {
 panic(err)
 }
}

func main() {
 f, err := os.Open("/tmp/dat")
 check(err)

 defer func() {
 if f != nil {
 f.Close()
 }
 }()

 b1 := make([]byte, 5)
 n1, err := f.Read(b1)
 check(err)

 fmt.Printf("%d bytes: %s\n", n1, string(b1))
}

如果在開啟檔案時，就發生了錯誤，假設這是在一個很深的呼叫層次中發生，若你直接想撰寫程式，將 os.Open 的 error 逐層傳回，那會是一件很麻煩的事，此時直接發出 panic，就可以達到想要的目的。

BONUS(四)：recover

如果發生了 panic，而你必須做一些處理，可以使用 recover，這個函式必須在被 defer 的函式中執行才有效果，若在被 defer 的函式外執行，recover 一定是傳回 nil。

如果有設置 defer 函式，在發生了 panic 的情況下，被 defer 的函式一定會被執行，若當中執行了 recover，那麼 panic 就會被捕捉並作為 recover 的傳回值，那麼 panic 就不會一路往回傳播，除非你又呼叫了 panic。

因此，雖然 Go 語言中沒有例外處理機制，也可使用 defer、panic 與 recover 來進行類似的錯誤處理。例如，將上頭的範例，再修改為：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


package main

import (
 "fmt"
 "os"
)

func check(err error) {
 if err != nil {
 panic(err)
 }
}

func main() {
 f, err := os.Open("/tmp/dat")
 check(err)

 defer func() {
 if err := recover(); err != nil {
 fmt.Println(err) // 這已經是頂層的 UI 介面了，想以自己的方式呈現錯誤
 }

 if f != nil {
 if err := f.Close(); err != nil {
 panic(err) // 示範再拋出 panic
 }
 }
 }()

 b1 := make([]byte, 5)
 n1, err := f.Read(b1)
 check(err)

 fmt.Printf("%d bytes: %s\n", n1, string(b1))
}

陣列

如何宣告陣列呢？很簡單！只要在變數宣告後面多加 [] 就可以了，裡面要填寫宣告的陣列數字。

1

var x [5]int

完整的範例：

1
2
3
4
5
6
7
8
9


package main

import "fmt"

func main() {
 var x [5]int
 x[4] = 100
 fmt.Println(x)
}

這邊來稍微說明一下：

1

x[4] = 100

這一行的意思是說「x 的第五個元素賦予值 100」，之所以是第五個元素是因為，我們一開始用 var x [5]int 宣告了五個元素的陣列，而陣列的起始元素是第 0 個，從頭開始算 0, 1, 2, 3, 4 五個元素，所以 x[4] 表示的是第五個元素，如果要選擇第 0 個元素要寫 x[0]。

接下來稍微看一個進階的例子來討論一下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


func main() {
 var x [4]float64
 x[0] = 23
 x[1] = 45
 x[2] = 33
 x[3] = 21

 var total float64 = 0
 for i := 0; i < 4; i++ {
 total += x[i]
 }
 fmt.Println(total / 4)
}

這邊一樣是宣告五個元素的陣列，x[0] ~ x[4] 的部分是初始化數值的動作，後面 for 迴圈是走訪所有個元素並且加到 total 這個變數中，最後在 Println 的部分再除以 4 計算平均。雖然這個程式沒有問題，但是沒有彈性，如果我今天加入六個元素、七個元素，你就必須要更改三個地方（宣告、for 迴圈、fmt.Println），所以我們稍微將它更改一下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


var x [4]float64
x[0] = 23
x[1] = 45
x[2] = 33
x[3] = 21

var total float64 = 0
for i := 0; i < len(x); i++ {
 total += x[i]
}
fmt.Println(total / len(x))

我們利用內建的函式 len() 來計算陣列的數量，這樣子如果元素有修改，我們就只需要修改一個部分就可以了，剩下的 len() 會自己去計算陣列的數量。但是！！！這個程式執行會有問題，如果你執行程式碼會看到錯誤：

1

invalid operation: total / 4 (mismatched types float64 and int)

這是因為 total 變數和 len() 計算完成後的型態不同，一個是 float64 另一個則是 int，所以發生錯誤，你必須要讓它強制轉型才可以執行。

1

fmt.Println(total / float64(len(x)))

另外 for 迴圈有另外一種內建的寫法可以走訪每個陣列，就是利用 range ，但是他預設會有兩個回傳值，一個是鍵一個是值。

1
2
3
4
5


var total float64 = 0
for i, value := range x {
 total += value
}
fmt.Println(total / float64(len(x)))

這個程式乍看之下沒有問題，但是我們都知道 Go 沒有使用的函式、變數，被 compile 看到連編譯都不給編，會出現「i declared and not used」錯誤，但是這邊我們真的不需要「i」這個鍵怎麼辦？我們可以利用「_」這個佔位符來取代。

1
2
3
4
5


var total float64 = 0
for _, value := range x {
 total += value
}
fmt.Println(total / float64(len(x)))

讓我們來稍微檢視一下最後修改的版本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


func main() {
 var x [4]float64
 x[0] = 23
 x[1] = 45
 x[2] = 33
 x[3] = 21

 var total float64 = 0
 for _, value := range x {
 total += value
 }
 fmt.Println(total / float64(len(x)))
}

看起十分的精簡又方便維護！但是就只有這樣了嗎？我個人覺得初始化的部份還是太長了，就讓我們來簡化它！

1

x := [4]float64{23, 45, 33, 21}

很短對不對！不過它很不方便閱讀，所以你也可以改成：

1
2
3
4
5
6


x := [4]float64{
 23,
 45,
 33,
 21,
}

注意最後一個逗點要留著喔！不然編譯會出錯，你不要覺得這個逗點很奇怪，一切都是有原因的，原因就在於方便維護！

Slice（切片）

在建立陣列的時候要指定元素的大小，但是！我們今天如果不知道要多大怎麼辦？陣列可以不輸入元素大小嗎？答案是可以！不過這個方法會有問題！而且他的型態不是陣列，而是 Slice。

建立 Slice

1

var x []float64

夠簡單了吧！其實就只是指陣列不寫元素大小而已。

Slice 有兩種數值，一個是容量一個是長度。這兩個有什麼不同呢？其實容量就是最大能裝多少，而長度不能超過容量。

那我們要怎麼設定長度跟容量呢？

1

x := make([]float64, 5)

這是標準的建立 slice 的方法，這裡設定一個長度和容量都是 5 的 slice 變數 x，這時候你會問：為什麼我只有指定一個 5 ，它卻幫我把長度跟容量設定為 5 呢？這是因為這裡設定的 5 其實是長度，容量則是系統自動配置，會符合最適當大小，所以也是 5。

如果要自訂容量大小，只要再多一個參數就可以設定囉：

1

x := make([]float64, 5, 10)

我們還可以利用另外一個方法建立 Slice，[low : high] 這個方法來參考別的 Slice 或是陣列來建立 Slice。

1
2


arr := [5]float64{1,2,3,4,5}
x := arr[0:5]

需要特別注意的點是 high 表示的是結束的點，而不是它的元素位置喔！

以上面的例子來說 arr[0:5] 其實是指 [1,2,3,4,5]，如果是 arr[1:4] 則是 [2,3,4]。

另外在某些情況下 low 跟 high 是可以省略的，像是 arr[0:5] 這樣子就可以省略成 arr[:5]；

如果省略成 arr[0:] 則是相當於 arr[0: len(arr)]；

是的，你發現了嗎？你當然可以省略成 [:]，它相當於 arr[0:len(arr)]。

Append 與 Copy

Slice 有兩個一定要學會的函式，一個是 Append 另一個是 Copy，讓我們逐一看一下例子：

1
2
3
4
5


func main() {
 slice1 := []int{1,2,3}
 slice2 := append(slice1, 4, 5)
 fmt.Println(slice1, slice2)
}

這邊使用 append 把 4、5 加入到 Slice1 中，並且賦予 Slice2。如果要更改原本的內容則是要這樣寫：

1

slice1 = append(slice1, 4, 5)

只要重新覆蓋掉 slice1 就可以了，但是要特別注意！不可以加冒號！冒號是宣告的時候用的短語法。

Map

在 Golang 中，有沒有一個類似 JSON 陣列的方法、型態呢？你可以使用 Map！

建立與使用 Map

1

var x map[string]int

跟 Array 還有 Slice 有點相似對吧？我這邊說明一下：

x 是變數名稱
map 這個是建立 Map 的時候用的關鍵詞彙不能省略
括弧中的 string 表示鍵的型態，int 則是值的型態。

我們來嘗試建立看看一個 Map：

1
2
3


var x map[string]int
x["key"] = 10
fmt.Println(x)

什麼！？居然出現 Panic，這個是什麼？

1

panic: runtime error: assignment to entry in nil map

我稍微省略了一些錯誤的 log ，讓我們聚焦在最重要的這一句話上面，他的意思是說不能賦予值到 nil map 上面。原來我們用 var x map[string]int 建立 Map 的時候沒有初始化它，所以它會建立一個 nil map，而 nil map 不能使用鍵，所以導致這樣的錯誤，那初始化怎麼寫呢？

1
2
3


x := make(map[string]int)
x["key"] = 10
fmt.Println(x)

如果你只是要印出鍵的數值：

1

fmt.Println(x["key"])

當然 string 不是唯一的選項，你也可以用 int。

1
2
3


x := make(map[int]int)
x[1] = 10
fmt.Println(x[1])

這樣就可以使用數字當作鍵來用。

另外可以新增，但是要怎麼刪除呢？ Go 有內建函式可以使用：

1

delete(x, 1)

除了新增刪除，如果今天我想要知道 map 有多少元素呢？

我們之前介紹過得 len() 也可以用的喔，如果只是剛建立沒有給值會是 0 ，如果像是前面的 x[1] = 10 這樣賦予值就會變成 1，以此類推。

1

len(x)

如果鍵沒有宣告？

如果我們今天印出的鍵值沒有宣告，例如：

1
2
3
4
5


elements := make(map[string]string)
elements["H"] = "Hydrogen"
elements["He"] = "Helium"

fmt.Println(elements["Al"])

通常我們要印出不存在的，在編譯的時候會報錯，但是這邊你執行後你會發現 Map 不會。

那 Go 有沒有方法可以判斷它是否是空的呢？當然有的！

1
2


name, ok := elements["Al"]
fmt.Println(name, ok)

這樣會印出什麼呢？它會印出 false，因為他是空值，但是你會發現明明 map 就回傳兩個返回值，為什麼印出來只有 false？原因是 name 其實對應到 value，但是值是空值，所以就沒有印了，而 ok 是返回它有沒有值。

我們再來利用這個語法來做點進階的應用：

1
2
3


if name, ok := elements["Al"]; ok {
 fmt.Println(name, ok)
}

這裡的意思是說「Al 是否有值呢？如果有的話請印出」。

如果覺得前面初始化的太長了，你可以試試這種簡短的寫法：

1
2
3
4


elements := map[string]string{
 "H": "Hydrogen",
 "He": "Helium",
}

當然我們都知道 JSON 格式可以是巢狀的，Go 當然一定也可以囉！

但是要怎麼做呢？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


func main() {
 elements := map[string]map[string]string{
 "H": map[string]string{
 "name":"Hydrogen",
 "state":"gas",
 },
 "He": map[string]string{
 "name":"Helium",
 "state":"gas",
 },
 }

 if el, ok := elements["He"]; ok {
 fmt.Println(el["name"], el["state"])
 }
}

Struct

Struct 是一個可以自定義型態的功能。

Struct 就是有點類似 OOP(物件導向) 的概念。比如說我今天想要建立一個型態"人"，那人有姓名和身高，這時候就可以使用 Struct。

1
2
3
4


type person struct {
 name
 height
}

實例化：

1

p := person{"Tony", 169}

{} 內的順序依定義 struct 的順序，或是可以指定項目初始化：

1

p := person{name: "Tony", height: 169}

如果想要存取 struct 裡面的內容，只要在後面加 . 就好了；比如說我想存取 person 的 name：

1

fmt.Println(person.name)

多重定義

比如說我的人比較多了，想要建立群組，裡面有群組名稱及人：

1
2
3
4
5
6
7
8
9


type person struct {
 name string
 height int
}

type group struct {
 name string
 person
}

實例化：

1

g := group{"LINE", person{name: "Emily", height: 158}}

這時候就算是 struct 裡面又包了 struct。

函式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func add(x int, y int) int {
 return x + y
}

func main() {
 fmt.Println(add(42, 13))
}

// 輸出結果：55

函數可以沒有參數或接受多個參數。

在這個例子中，“add” 接受兩個 int 類型的參數(注意類型在變數之後)。

return 代表傳回的數值為何？這裡表示傳回 x + y 也就是 42 + 13 ，所以結果會是 55。

當兩個或多個連續的函數命名參數是同一類型，則除了最後一個類型之外，其他都可以省略：

1

x int, y int

可以縮寫成：

1

x, y int

也就是說上面的程式碼可以改成：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func add(x, y int) int {
 return x + y
}

func main() {
 fmt.Println(add(42, 13))
}

// 輸出結果：55

多數值的返回

函數可以返回任意數量的返回值，這個函數返回了兩個字串：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func swap(x, y string) (string, string) {
 return y, x
}

func main() {
 a, b := swap("hello", "world")
 fmt.Println(a, b)
}

// 輸出結果：world hello

命名返回值

在 Go 中，函數可以返回多個「結果參數」，而不僅僅是一個值。它們可以像變數那樣命名和使用。

如果命名了返回值參數，一個沒有參數的 return 語句，會將當前的值作為返回值返回。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func split(sum int) (x, y int) {
 x = sum * 4 / 9
 y = sum - x
 return
}

func main() {
 fmt.Println(split(17))
}

// 輸出結果：7 10

以這個程式碼為例，sum int 表示宣告整數 sum，將參數 17 放入 sum 中，x, y int 宣告整數 x,y 在下面使用，由於 return 沒有設定返回值，這邊程式就將 x,y 都回傳了，所以結果會出現 7 10。

Goroutine

Go 很酷的特色 Goroutine，他類似於其他語言的 Thread，意思即一支程式同時進行好幾個小程式。

要使用 Goroutine 非常的簡單，只要一個字，一個很熟悉的字，「go」。

讓我們看看下面這個簡單的例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
 "fmt"
)

func f(n int) {
 for i := 0; i < 10; i++ {
 fmt.Println(n, ":", i)
 }
}

func main() {
 go f(0)
}

你執行後你會發現什麼東西都沒有印出！

不是 Go 有問題，因為使用 goroutine 是平行處理的，所以在還沒開始印 n 之前，main 這個主要的函式已經結束了。

我們使用一下內建的 time 函式，讓 main 函式等一下，讓 goroutine 跑完。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
 "fmt"
 "time"
)

func f(n int) {
 for i := 0; i < 10; i++ {
 fmt.Println(n, ":", i)
 }
}

func main() {
 go f(0)
 time.Sleep(time.Second * 1) // 暫停一秒鐘
}

你就可以看到印出 1 ~ 10 了。

WaitGroup

有鑑於剛剛背景 Thread 所執行的項目都還沒開始程式就結束了，WaitGroup 的功能即為等待這個 Group 的項目執行完再繼續進行。

首先，因為 WaitGroup 是包含在 package sync 裏頭的，所以需要引入一下：

1

import "sync"

宣告一個 WaitGroup 變數：

1

var wg sync.WaitGroup

當 WaitGroup 裏頭的空間等於 0 的時候就會繼續進行主程式，下面會介紹一些操作方式。

Add()

增加 WaitGroup 裡可以容納個 Thread。

1

wg.Add(2)

Wait()

等待 WaitGroup 裡的 Thread 執行完畢再繼續進行。

1

wg.Wait()

Done() 或是 Add(-1)

使 WaitGroup 的容量 - 1。

1
2
3


wg.Done()
// or
// wg.Add(-1)

有了這些基本操作後，我們可以改良剛剛的程式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import (
 "fmt"
 "sync"
)

func foo() {
 for i := 1; i <= 10; i++ {
 fmt.Println("Foo: ", i)
 }
 wg.Done()
}

func bar() {
 for i := 1; i <= 10; i++ {
 fmt.Println("Foo: ", i)
 }
 wg.Done()
}

var wg sync.WaitGroup

func main() {
 wg.Add(2)
 go foo()
 go bar()
 wg.Wait()
}

Sleep

讓程式暫停。

這個功能是放在 package time 裡面的，所以又要引入了。

1
2
3


import "time"

time.Sleep(5 * time.Millisecond)

這個範例是暫停五秒鐘。

Race condition

有了 go 這個好用的東西可以分成好幾個 Thread 同時進行，那就有可能會有同時搶奪資源的情況。比方說兩個 Thread 同時都要讀取並修改同一個變數，拿一個情境題來舉例：

如果今天同一個銀行的網路銀行有提款功能，而有人同時在兩台電腦都登入了要提款，兩台電腦都送出了提領 1000 的請求會怎樣呢？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package main

import (
 "fmt"
 "sync"
 "time"
)

func withdraw() {
 balance := money
 time.Sleep(3000 * time.Millisecond)
 balance -= 1000
 money = balance
 fmt.Println("After withdrawing $1000, balace: ", money)
 wg.Done()
}

var wg sync.WaitGroup
var money int = 1500

func main() {
 fmt.Println("We have $1500")
 wg.Add(2)
 go withdraw() // first withdraw
 go withdraw() // second withdraw
 wg.Wait()
}

到最後大家會發現 1500 提領了兩次 1000 還剩 500？為甚麼呢？

因為在第一次提領的時候，系統先讀取餘額為 1500 元，同時第二台電腦也登入了餘額也是顯示為 1500 元，這時候就是因為兩邊同時搶著讀取餘額的原因，所以第一次提領 1000 元時回報給系統"餘額剩 500 元"，第二台領了 1000 元也回報系統"餘額剩 500 元"。

不過 Golang 的編譯器可以檢查是不是有 race condition，只要在平常執行 go run 後面加上參數 -race 即可。

1

go run -race main.go

Mutex、Lock()、Unlock()

那要如何避免這樣的情況發生呢？Mutex 可以解決上面這樣的問題。這個也是在 package sync 裏頭。

1
2
3
4


import "sync"

// 宣告一個 Mutex 變數
var mu sync.Mutex

當使用 mu.Lock() 的時候，之後所用到的變數就會上鎖，只有在使用中的 Thread 可以存取，其他都需要等到釋放後才能存取。

1

mu.Lock()

釋放 lock 變數：

1

mu.Unlock()

所以我可以將剛剛 withdraw() 改良：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func withdraw() {
 mu.Lock()
 balance := money
 time.Sleep(3000 * time.Millisecond)
 balance -= 1000
 money = balance
 mu.Unlock()
 fmt.Println("After withdrawing $1000, balace: ", money)
 wg.Done()
}

因為 Lock() 和 Unlock() 通常都會一起出現，所以有些人會這樣寫：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


func withdraw() {
 {
 mu.Lock()
 balance := money
 time.Sleep(3000 * time.Millisecond)
 balance -= 1000
 money = balance
 mu.Unlock()
 }
 fmt.Println("After withdrawing $1000, balace: ", money)
 wg.Done()
}

全部的程式碼：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import (
 "fmt"
 "sync"
 "time"
)

func withdraw() {
 mu.Lock()
 balance := money
 time.Sleep(3000 * time.Millisecond)
 balance -= 1000
 money = balance
 mu.Unlock()
 fmt.Println("After withdrawing $1000, balace: ", money)
 wg.Done()
}

var wg sync.WaitGroup
var money int = 1500
var mu sync.Mutex

func main() {
 fmt.Println("We have $1500")
 wg.Add(2)
 go withdraw() // first withdraw
 go withdraw() // second withdraw
 wg.Wait()
}

如此一來就解決 race condition 的問題了！

Channel

Channel 也是 Golang 非常特別的特色。

要建立一個 Channel 很簡單，make(chan string) 這樣就可以了。

1

c := make(chan int)

Send

要將東西送到 channel 就把資料指向 channel 變數就好：

1

c <- 5

Receive

就將箭頭往外指。

1

x := <-c

Close()

當 Channel 被 Close 之後，就只能讀取不能寫入了：

1

close(c)

當變數傳遞

channel 其實就是一個變數，在 function 裡是可以傳入傳出的。

1
2
3
4
5
6
7
8
9


// 傳入
func foo(c chan int) {
 // do something
}

// 傳出
func foo() {
 // do something
}

這邊簡單建立了一個 message 的 channel，可以傳輸字串，然後用 go 來 call goroutine 執行函式，然後 msg 負責接收 messages 的傳輸資料，goroutine 執行的函式裡面傳 “ping” 到 messages 這個 channel 裡面，再由 message 傳給 msg 變數印出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {

 messages := make(chan string)

 go func() { messages <- "ping" }()

 msg := <-messages
 fmt.Println(msg)
}

再講個範例可能會比較容易懂：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "fmt"
)

func main() {
 c := make(chan int)

 // 在 goroutine 之下執行這個 function
 go func() {
 for i := 0; i < 10; i++ {
 c <- i
 }
 close(c)
 }()

 for n := range c {
 fmt.Println(n)
 }
}

在這裡 go func() 將 i 傳入 c，下面的 for 會等待 c 有什麼時候有新東西，一有新東西他就會 print 出來！

很簡單直覺對吧！透過這個方法就可以簡單的讓 Goroutine 可以溝通！

Select

Channel 有一個類似 Switch 的流程控制「Select」，它只能應用於 Channel 讓我們一起來看看。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import "time"
import "fmt"

func main() {

 c1 := make(chan string)
 c2 := make(chan string)

 go func() {
 time.Sleep(time.Second * 1)
 c1 <- "one"
 }()
 go func() {
 time.Sleep(time.Second * 2)
 c2 <- "two"
 }()

 for i := 0; i < 2; i++ {
 select {
 case msg1 := <-c1:
 fmt.Println("received", msg1)
 case msg2 := <-c2:
 fmt.Println("received", msg2)
 }
 }
}

這邊用 go 建立兩個 goroutine 分別將 one 和 two 傳給 c1、c2，下面主函式的 for 回會將 1、2 透過 select 流程控制來接收 channel 的訊息再印出。

是不是很簡單，這樣子就可以更有效的控制 channel 了。

錯誤處理

有時候程式的錯誤是在預料之內的，防範也防範不了，但總不能因為一個錯誤就讓整支程式停下來吧？因此就需要 Error Handling。如果有學過其他程式語言可能會覺得用法跟 try…cache 有點不同。

如何使用？

其實滿簡單的，只要知道所使用的 function 有回傳 error 就可以使用，通常在使用手冊上會看到，以 HTTP GET 來說：

1
2
3
4
5


resp, err := http.Get("http://example.com/")
// ...
resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf)
// ...
resp, err := http.PostForm("http://example.com/form", url.Values{})

官方使用手冊就有回傳 err 的參數，意思就是錯誤內容會傳到 err 內。

那就 HTTP GET 來舉例，如果有 Get 到東西的話就會存到 resp，沒有的話就會把錯誤訊息存到 err：

1
2
3
4


resp, err := http.Get("http://ithelp.ithome.com.tw/")
if err != nil {
 fmt.Println(err)
}

錯誤內容 err 是可以直接 Print 出來的！

Fatalln()

Fatalln() 這個 function 就是兩行 code 的組合，這個 function 是包在 “log” 中的。

1
2
3
4
5


import "log"

// Print 出錯誤內容後結束程式
fmt.Println(err)
os.Exit(1)

淺談 package

package 可以將一些常常會用的程式碼獨自建立一個檔案，所以在同一個資料夾內可以有好幾個 package 檔案。某方面來說也是便於管理程式碼。

package 的有效範圍

在同一個 package 中可以把這些檔案看作是在同一個檔案內。

比如說 package person 中第一個檔案 personName.go：

personName.go

1
2
3


package person

var MyName = "Wayne"

package person 中第二個檔案 sayHelloTo.go：

sayHelloTo.go

1
2
3
4
5
6


package person

func SayHelloTo(s string) string {
 str := "Hello " + s + "!"
 return str
}

這兩個檔案都在 package person 中，所以可以把它視為這樣：

1
2
3
4
5
6
7
8


package person

var MyName = "Wayne"

func SayHelloTo(s string) string {
 str := "Hello " + s + "!"
 return str
}

該如何使用 package？

只要在程式一開始 import 就行了，常用的 fmt 就是一個標準 package。

要注意的是路徑是從 $GOPATH/src/ 為起始目錄的相對路徑。

1
2
3
4


import {
 fmt
 "github.com/xxx"
}

大小寫的差異

在 package 中變數或函式的命名開頭字元大小寫是有差異的：

大寫開頭：在 package 之外可見，稱作 exported
小寫開頭：僅限於 package 內使用，稱作 unexported

注意：這概念跟其他語言的 public、private 很像，但是在 GO 的領域通常還是講 exported、unexported。

舉個例子來說：

alien.go

1
2
3
4


package alien

// name start with capital will be exported in another file
var AlienName = "Wayne"

這邊的 AlienName 大寫開頭 - exported

所以在其他檔案中只要 import 就可以使用：

main.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import (
 "fmt"
 "alien"
)

func main() {
 fmt.Println(alien.AlienName)
}

如果是 function 也是一樣：

person.go

1
2
3
4
5
6


package person

func SayHelloTo(s string) string {
 str := "Hello " + s + "!"
 return str
}

main.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import (
 "fmt"
 "person"
)

func main() {
 fmt.Println(person.SayHelloTo("Wayne"))
}

變數的可視範圍

變數的宣告其實也是門學問，很多新手會想說"全部都宣告全域變數就好了啊"，但為了安全性、可讀性以及有效的執行最小權限原則(即為要用到的變數才看的到，用不到的就不需要看到)，這裡就仔細地跟大家講解。

package

同一個 package 可以視為程式碼都在同一個檔案內。

括號內的變數 `{}`

括號內的變數只要是同樣在括號內都能使用，括號外則不行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 x := 1
 foo() // 錯誤，因為 x 屬於 main 中的變數
}

func foo() {
 fmt.Println(x)
}

全域變數

這個比較猛，意思就是在程式中都能讀到他，每個地方的操作都會改變他的值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

var x = 0

func xPlus() {
 x++
}

func main() {
 x++ // x = 1
 xPuls() // x = 2
}

順序

宣告的順序當然也很重要，宣告之後才可用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import "fmt"

func main() {
 x := 5
 fmt.Println(x)
 fmt.Println(y) // 這樣是找不到 y 的
 y := 10
}

變數和函式名稱相同

這樣用是不會出錯，但是不建議，日後 debug 可能造成麻煩。

Pointer

將變數直接指向記憶體位置就叫做 Pointer，要修改內容就直接到該記憶體位置修改。

基本操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 var p *int // 宣告 p 是一個 int 的指標，但此時他要指向哪還不知道
 a := 10 // a 佔用了一個記憶體空間

 p = &a // 將 p 指到 a 的記憶體位置

 fmt.Println(p) // p 所指到的記憶體位置
 fmt.Println(*p) // * 代表顯示該記憶體位置的值
}

function 的運作

有了 Pointer 的概念，就比較好理解 function 是怎麼傳值的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func foo(x int) {
 fmt.Println(&x) // function 內 x 的記憶體位置
}

func main() {
 a := 10
 fmt.Println(&a) // main 裡面 a 的記憶體位置
 foo(a)
}

結果會看到兩個記憶體位置是不一樣的。代表在 function 傳值過去後，function 複製該值到另一個空間來操作，對於原本 main 裡面的值是不會影響的。

function 傳指標

當然，想要在傳指標到 function 內操作也是可以的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func foo(x *int) {
 fmt.Println(x) // function 內 x 的記憶體位置
}

func main() {
 a := 10
 fmt.Println(&a) // main 裡面 a 的記憶體位置
 foo(&a)
}

可以看到傳指標過去後，兩邊操作的是同一個東西。

測試

寫了這麼多小程式，甚至也自己打包了成 Package 了，那 Go 有提供自動化測試的方法嗎？測試程式是否正常？讓我們一起來看看 Go 的測試方法。

首先我們先寫一個簡單的 Package 來看看：

testing.go

1
2
3
4
5
6
7
8
9


package math

func Average(xs []float64) float64 {
 total := float64(0)
 for _, x := range xs {
 total += x
 }
 return total / float64(len(xs))
}

這個很簡單，這裡簡單建立一個叫 math 的 Package，這是一個簡單算平均的 Package，將讀取進來的浮點數陣列一個一個用 for 讀取進來累加，然後在返回總和除總數的結果。

main.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package math

import "testing"

func TestAverage(t *testing.T) {
 var v float64
 v = Average([]float64{1,2})
 if v != 1.5 {
 t.Error("Expected 1.5, got", v)
 }
}

然後我們來寫另外一個檔案，這個是測試的寫法，建議檔名取 math_test.go，因為前面的 Package 取名叫做 math.go。

一開始先宣告測試用的變數 t，然後引用 Average 函數將 1、2 拿進去計算，如果答案不對利用 t 返回錯誤，使用起來相當的直覺。

操作檔案

讓我們先看看下面這個簡單的範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


package main

import (
 "fmt"
 "os"
)

func main() {
 // 首先我們先利用內建的函式庫 os ，利用 open 方法來開起檔案：
 // file 為開啟後的檔案，用來做後續的操作，err 這個是當開啟失敗的時候返回的錯誤訊息
 file, err := os.Open("test.txt")
 if err != nil {
 return
 }
 // 這一行是使用 defer 來確保檔案有被正確的關閉用的
 defer file.Close()

 stat, err := file.Stat()
 if err != nil {
 return
 }

 bs := make([]byte, stat.Size())
 _, err = file.Read(bs) // 一般情況下會是 nil，如果你不需要 error 訊息你可以使用佔位符來取代

 // 這邊則是說如果 err 不是 nil 那就返回，當然你也可以輸入一些你要設定的除錯訊息
 if err != nil {
 return
 }

 str := string(bs)
 fmt.Println(str)
}

時間

時間是一般開發者常常會用到的功能，Go 已經內建得很齊全了，我們一起來看看吧！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


package main

import (
 "fmt"
 "time"
)

func main() {
 p := fmt.Println

 // 獲取目前的時間
 now := time.Now()
 p(now)

 // 獲取自訂時間
 then := time.Date(
 2009, 11, 17, 20, 34, 58, 651387237, time.UTC)
 p(then)

 p(then.Year())
 p(then.Month())
 p(then.Day())
 p(then.Hour())
 p(then.Minute())
 p(then.Second())
 p(then.Nanosecond())
 p(then.Location())

 p(then.Weekday())

 p(then.Before(now))
 p(then.After(now))
 p(then.Equal(now))

 diff := now.Sub(then)
 p(diff)

 p(diff.Hours())
 p(diff.Minutes())
 p(diff.Seconds())
 p(diff.Nanoseconds())

 p(then.Add(diff))
 p(then.Add(-diff))
}

如果要計算時間差呢？只要使用 Sub 方法就可以計算囉！詳細 time 用法可參考網址。

操作字串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


package main

import (
 "fmt"
 "strings"
)

func main() {
 fmt.Println(
 // true
 strings.Contains("test", "es"),

 // 2
 strings.Count("test", "t"),

 // true
 strings.HasPrefix("test", "te"),

 // true
 strings.HasSuffix("test", "st"),

 // 1
 strings.Index("test", "e"),

 // "a-b"
 strings.Join([]string{"a", "b"}, "-"),

 // == "aaaaa"
 strings.Repeat("a", 5),

 // "bbaa"
 strings.Replace("aaaa", "a", "b", 2),

 // []string{"a","b","c","d","e"}
 strings.Split("a-b-c-d-e", "-"),

 // "test"
 strings.ToLower("TEST"),

 // "TEST"
 strings.ToUpper("test"),
 )
}

Contains：藉由 Contains 可以知道字串中是否包涵哪些字串
Count：用來計算一個字串中的某個字元有幾個
HasPrefix、HasSuffix：用來確認字頭字尾始否有包函某些字串
Index：用來計算指定的字元是字串中的第幾個元素
Join：用來合併成字串，而中間可以嵌入指定的字元
Repeat：重複字串
Split：利用特定字元來拆開字串，拆開的字會放進陣列
ToLower：用來把字串都換成小寫，當然他只有英文XD
ToUpper：用來把字串都換成大寫，當然他只有英文XD

Hash 雜湊

雜湊 (Hash) 是現在很常見的應用，可以用來驗證檔案的正確性、加密等。

範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
 "crypto/sha1"
 "fmt"
 "hash/crc32"
)

func main() {
 h := crc32.NewIEEE()
 h.Write([]byte("test"))
 v := h.Sum32()
 fmt.Println(v)

 i := sha1.New()
 h.Write([]byte("test"))
 bs := i.Sum([]byte{})
 fmt.Println(bs)
}

這邊簡單舉了一般的 Hash 跟 Crypto 的函式用法，當然還有很多種類可以自己看。

這邊 crc32 的部份用 NewIEEE 方法來建立 checksum，然後利用 write 這個內建的 interface 來寫入要算的值，這時候 h 已經是我們要的 Hash 值了，後面這邊在利用 sum32 來返回成我們可以閱讀的 uint32 的值。

sha1 的部份基本上很類似，應該不用多說，馬上可以看懂。

詳細請參考：

hash
crypto

List

有上過資料結構的人都知道 List，Go 有實作喔！不過他不是基礎型別，需要特別引入，讓我們一起來看看。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
 "container/list"
 "fmt"
)

func main() {
 var x list.List
 x.PushBack(1)
 x.PushBack(2)
 x.PushBack(3)

 for e := x.Front(); e != nil; e = e.Next() {
 fmt.Println(e.Value.(int))
 }
}

先是建立 List x 然後利用 PushBack 函式從後面填入，最後利用 For 迴圈將一個一個取出。

除了 List 外還有 Heap 喔！有興趣的可以參考看看。

詳細請參考：

List
Heap

GET / POST

在錯誤處理的時候有提到 HTTP GET、POST，這邊再來說明一下。

舉個例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


func httpGet() {
 resp, err := http.Get("https://tw.yahoo.com/")
 if err != nil {
 // handle error
 }

 defer resp.Body.Close()
 body, err := ioutil.ReadAll(resp.Body)
 if err != nil {
 // handle error
 }

 fmt.Println(string(body))
}

你可以看到，這是一個 function，我們利用 http.get 的方法來將 request 送給 Yahoo，Get 方法會返回兩個數值，一個是 response，另一個是 error，後面利用 defer 來確定是否有收到，然後將 response 裡的 Body 也就是網頁內容讀取出來，然後轉成字串印出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


func httpPost() {
 resp, err := http.Post("https://tw.yahoo.com/",
 "application/x-www-form-urlencoded",
 strings.NewReader("name=test"))
 if err != nil {
 fmt.Println(err)
 }

 defer resp.Body.Close()
 body, err := ioutil.ReadAll(resp.Body)
 if err != nil {
 // handle error
 }

 fmt.Println(string(body))
}

POST 其實大部份就跟 GET 相同，但是不一樣的是 POST 通常傳的資料會比較多，所以這邊可以在後面的參數加上你要傳給伺服器的參數，另外需要特別注意的是，必須使用 application/x-www-form-urlencoded 才能正確的傳值喔！

Martini

我們來玩玩 Framework 吧！

官方網站： http://martini.codegangsta.io/
Repo： https://github.com/go-martini/martini

安裝 Martini

只要用 go get 就可以在本地引入 lib 囉！

1

go get github.com/go-martini/martini

然後我們就可以開始使用官方的 simple code：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "github.com/go-martini/martini"

func main() {
 m := martini.Classic()
 m.Get("/", func() string {
 return "Hello world!"
 })
 m.Run()
}

這是一個簡單利用 Martini 來啟動 Server 的範例程式碼，首先引入 Martini，後面宣告 martini 為變數 m，後面在使用 router 來解析網址「/」，再來我們再跟目錄網只要做什麼事情呢？就是返回 “Hello world”！規則都設定完了，那我們就用 Run 來啟動伺服器。

那我們的 Code 都寫完了，那我們就用 go run 來執行它，例如你的 code 檔名取叫 server.go，那你只要使用：

1

go run server.go

就可以執行囉，接下來你就可以開瀏覽器來看看是否有顯示「Hello world!」，網址請打 localhost:3000，3000 為 Martini 的預設 port。

Router、Template

簡單使用 Martini 的 Router 和 Template 做網站開發！

一開始我們會需要另外一個 lib，因為 Martini 的 lib 只有基本伺服器的工具，沒有包函 View Render，所以我們會需要使用 View Render 來操作 Template。

所以我們先使用 go get 來下載：

1

go get github.com/martini-contrib/render

這樣我們就可以引用 lib 了！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


package main

import (
 "github.com/go-martini/martini"
 "github.com/martini-contrib/render"
)

func main() {
 m := martini.Classic()

 m.Get("/hello/:name", func(params martini.Params) string {
 return "Hello " + params["name"]
 })

 m.Use(render.Renderer(render.Options{
 Layout: "layout",
 }))

 type Member struct {
 Id int
 Name string
 Sex string
 }
 member := Member{
 Id: 1, Name: "Negaihoshi", Sex: "Male",
 }

 m.Get("/", func(r render.Render) {
 r.HTML(200, "hello", member)
 })

 m.Run()
}

首先 m.Get 是使用 Get 方法來獲取 response，如同前面的方法，不過稍微不同的是我們這邊稍微做一點進階的操作，我們在 router 的 rule 這邊打上 /hello/:name，這個是什麼意思呢？意思是網址 /hello/ 下網站會看 :name 這個變數來做操作，所以下面就要寫我們要做什麼？而這邊我們返回 "Hello " + params["name"] 而 params 這邊就是用來解析引數的語法。

如果我今天輸入網址 /hello/:Negaihoshi，那我網站就會出現「Hello Negaihoshi」。

下面這邊我們利用 Use 方法來設定 Options，而這邊設定的是我們要使用 layout，並且指定 layout 的位置，而我們這邊寫 “layout”，指的是 templates/layout.tmpl 這個檔案。

往後面看這邊就簡單了，用了前面學過得 stuct 來存放資料，並且使用 Get 方法，當有人瀏覽根目錄的時候，將 member 傳入 hello.tmpl 檔。

1
2
3


<title></title>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css">
{{ yield }}

這邊其實很簡單就是使用 yield 來引入入其他的 tmpl 檔。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


<table class="table table-hover">
 <thead>
 <tr>
 <td>ID</td>
 <td>Name</td>
 <td>Sex</td>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>{{ .Id }}</td>
 <td>{{ .Name }}</td>
 <td>{{ .Sex }}</td>
 </tr>
 </tbody>
</table>

這邊則是印出我們要的數值，而需要用「.」來操作。

資料庫

前面學會了怎麼簡易的使用 martini，這邊我們來使用看看資料庫。

首先我們要安裝 mysql 的驅動程式套件，我們使用 GitHub 上比較知名的的項目來做。

在終端機輸入：

1

go get github.com/go-sql-driver/mysql

這樣就可以使用囉！

當然，我們需要引入它才能使用：

1
2
3
4


import "database/sql"
import \_ "github.com/go-sql-driver/mysql"

db, err := sql.Open("mysql", "user:password@/dbname")

user 和 password 跟 dbname 就要換成你要連接的資料庫的資料囉！

資料都輸入正確就可以連接資料庫了。

記得加入很重要的 error，這樣連接失敗才能正確的回報哦！

1
2
3


if err != nil {
 panic(err.Error())
}

如果有仔細看範例，你可以看到這一句：

1

defer db.Close()

他的意思是說要確保它可以正確的被關閉。

學會連接資料庫了，那要怎麼操作呢？我們來看一個簡單的例子，這邊是官方的範例：

1
2
3
4
5


stmtIns, err := db.Prepare("INSERT INTO squareNum VALUES( ?, ? )") // ? = placeholder
if err != nil {
 panic(err.Error()) // proper error handling instead of panic in your app
}
defer stmtIns.Close() // Close the statement when we leave main() / the program terminates

這邊使用 Prepare 來使用 sql 指令，將值傳給 stmtIns ，操作簡單直覺！

以上，這篇先簡單介紹 Golang，待之後專案使用到時，再來繼續深入研究！

在 Windows 平台打造完美的 Go 開發環境 (WSL 2)

Thu, 09 Feb 2023 00:00:00 +0000

參考網站
 參考網站
 參考網站
 參考網站
 參考網站

自從 Windows 升級到 Windows 10 Version 2004 之後，因為可以採用效能大幅提昇的 WSL 2 執行環境，像是 .NET Core、Golang 與 Docker 都會全部跑在 WSL 2 的 Linux 下。今天這篇文章，我將介紹如何在 Windows 平台打造完美的 Golang 開發環境，不但可以讓你享受 Linux 平台執行時無比的順暢，更能享受 Windows 平台絕佳的 VSCode 開發體驗。

使用 WSL 在 Windows 上安裝 Linux

開發人員可以在 Windows 計算機上同時訪問 Windows 和 Linux 的強大功能。通過適用於 Linux 的 Windows 子系統(WSL)，開發人員可以安裝 Linux 發行版（例如Ubuntu、OpenSUSE、Kali、Debian、Arch Linux 等），並直接在 Windows 上使用 Linux 應用程序、實用程序和 Bash 命令行工具，不用進行任何修改，也無需承擔傳統虛擬機或雙啟動設置的費用。

安裝 WSL 命令

現在，可以使用單個命令安裝運行 WSL 所需的一切內容。在管理員模式下打開 PowerShell 或 Windows 命令提示符，方法是右鍵單擊並選擇"以管理員身份運行"，輸入 wsl --install 命令，然後重啟電腦。

如果你運行的是舊版，或只是不想使用 install 命令並希望獲得分步指引，請參閱舊版 WSL 手動安裝步驟。

WSL 安裝 Ubuntu

WSL 安裝指令：

1

wsl --install -d <DistroName>

在終端機使用以下指令安裝 Linux Ubuntu：

1

wsl --install -d Ubuntu

設置 Linux 用戶名稱與密碼

使用 WSL 安裝 Linux 發行版的過程完成後，系統將要求你為 Linux 發行版創建"用戶名"和"密碼"。

此用戶名和密碼特定於安裝的每個單獨的 Linux 分發版，與 Windows 用戶名無關。
請注意，輸入密碼時，屏幕上不會顯示任何內容。這稱為盲目鍵入。不會看到正在鍵入的內容，這完全正常。
創建用戶名和密碼後，該帳戶將是分發版的默認用戶，並將在啟動時自動登錄。
此帳戶將被視為 Linux 管理員，能夠運行sudo(Super User Do) 管理命令。
在 WSL 上運行的每個 Linux 發行版都有其自己的 Linux 用戶帳戶和密碼。每當添加分發版、重新安裝或重置時，都必須配置一個 Linux 用戶帳戶。

BONUS：設置 root 密碼

在 WSL 的 Ubuntu，輸入以下指令設定 root 密碼：

1

sudo passwd

測試 root 密碼：

1
2
3
4
5
6
7
8


su -

# 輸入剛剛設定的 root 密碼

# 完成登入

# 退出 root
exit

安裝 Go 版本管理器 (Go Version Manager)

Go Version Manager 簡稱 gvm，專門用來管理 Go 的執行環境，可以讓你任意切換 Go 的 Runtime 版本，又不會搞亂你的作業系統，這可說是兩全其美！

以下兩行命令，就可以輕鬆裝好 gvm 工具：

1
2


bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
source ~/.gvm/scripts/gvm

安裝 Go 執行環境的門檻已經變的超低，尤其是安裝在 Linux / macOS 底下更是如此，官方已經移除了對各家 Linux Distro 的安裝套件支援，一份 tarball 解壓縮，環境變數 PATH 設定好就可以立刻開始使用，沒那麼多奇奇怪怪的套件管理器混淆 Linux 初學者的地方。

我認為安裝 gvm 對於打造 Go 開發環境來說，還是有好處的。至少安裝完成後的 Go 執行環境非常乾淨，各種複雜的 GO____ 環境變數，全部交由 gvm 來管理。不想要 Go 或 gvm 的時候，只要以下兩行就可以清除乾淨：

1
2


chmod u+w -R ~/.gvm/
gvm implode

安裝 Go 執行環境

先安裝 gvm 所需的必要套件

因為 gvm 可能會用到建置下個版本的 Go 執行環境，所以建議你安裝一些建置工具。

如果你採用 Ubuntu/Debian 系統，請安裝以下套件：

1

sudo apt-get install binutils bison gcc make build-essential -y

如果有遇到不能執行上述安裝的情況，請用以下命令修復，修復後再重新安裝一次即可！

1
2


sudo sed -i -r -e 's/^(set -e)$/#\1/' /var/lib/dpkg/info/libc6\:amd64.postinst
sudo apt --fix-broken install -y

如果跳出 Colud not find bison、binutils、gcc、make，手動一一安裝吧！

1
2
3
4


sudo apt-get install bison
sudo apt-get install binutils
sudo apt-get install gcc
sudo apt-get install make

如果有遇到安裝 gcc 時報 404 Not Found 的錯誤，請先升級你的 apt 後再進行安裝：

錯誤訊息：

1
2
3
4
5


E: Failed to fetch http://security.ubuntu.com/ubuntu/pool/main/b/binutils/libctf0_2.34-6ubuntu1.1_amd64.deb 404 Not Found [IP: 91.189.88.152 80]
E: Failed to fetch http://security.ubuntu.com/ubuntu/pool/main/b/binutils/binutils-x86-64-linux-gnu_2.34-6ubuntu1.1_amd64.deb 404 Not Found [IP: 91.189.88.152 80]
E: Failed to fetch http://security.ubuntu.com/ubuntu/pool/main/b/binutils/binutils_2.34-6ubuntu1.1_amd64.deb 404 Not Found [IP: 91.189.88.152 80]
E: Failed to fetch http://security.ubuntu.com/ubuntu/pool/main/l/linux/linux-libc-dev_5.4.0-81.91_amd64.deb 404 Not Found [IP: 91.189.88.152 80]
E: Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?

升級 apt 並重新安裝 gcc：

1
2
3


sudo apt update
sudo apt upgrade
sudo apt install gcc -y

如果你採用 RedHat/CentOS 系統，請安裝以下套件：

1
2
3
4
5
6


sudo yum install curl
sudo yum install git
sudo yum install make
sudo yum install bison
sudo yum install gcc
sudo yum install glibc-devel

安裝完成後查詢 gvm 的版本資訊：

1
2


wayne@Wayne-Desktop:~$ gvm version
Go Version Manager v1.0.22 installed at /home/wayne/.gvm

列出目前 gvm 已安裝的所有 Go 版本

1

gvm listall

撰文當下的回應內容如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276


gvm gos (available)

 go1
 go1.0.1
 go1.0.2
 go1.0.3
 go1.1
 go1.1rc2
 go1.1rc3
 go1.1.1
 go1.1.2
 go1.2
 go1.2rc2
 go1.2rc3
 go1.2rc4
 go1.2rc5
 go1.2.1
 go1.2.2
 go1.3
 go1.3beta1
 go1.3beta2
 go1.3rc1
 go1.3rc2
 go1.3.1
 go1.3.2
 go1.3.3
 go1.4
 go1.4beta1
 go1.4rc1
 go1.4rc2
 go1.4.1
 go1.4.2
 go1.4.3
 go1.5
 go1.5beta1
 go1.5beta2
 go1.5beta3
 go1.5rc1
 go1.5.1
 go1.5.2
 go1.5.3
 go1.5.4
 go1.6
 go1.6beta1
 go1.6beta2
 go1.6rc1
 go1.6rc2
 go1.6.1
 go1.6.2
 go1.6.3
 go1.6.4
 go1.7
 go1.7beta1
 go1.7beta2
 go1.7rc1
 go1.7rc2
 go1.7rc3
 go1.7rc4
 go1.7rc5
 go1.7rc6
 go1.7.1
 go1.7.2
 go1.7.3
 go1.7.4
 go1.7.5
 go1.7.6
 go1.8
 go1.8beta1
 go1.8beta2
 go1.8rc1
 go1.8rc2
 go1.8rc3
 go1.8.1
 go1.8.2
 go1.8.3
 go1.8.4
 go1.8.5
 go1.8.5rc4
 go1.8.5rc5
 go1.8.6
 go1.8.7
 go1.9
 go1.9beta1
 go1.9beta2
 go1.9rc1
 go1.9rc2
 go1.9.1
 go1.9.2
 go1.9.3
 go1.9.4
 go1.9.5
 go1.9.6
 go1.9.7
 go1.10
 go1.10beta1
 go1.10beta2
 go1.10rc1
 go1.10rc2
 go1.10.1
 go1.10.2
 go1.10.3
 go1.10.4
 go1.10.5
 go1.10.6
 go1.10.7
 go1.10.8
 go1.11
 go1.11beta1
 go1.11beta2
 go1.11beta3
 go1.11rc1
 go1.11rc2
 go1.11.1
 go1.11.2
 go1.11.3
 go1.11.4
 go1.11.5
 go1.11.6
 go1.11.7
 go1.11.8
 go1.11.9
 go1.11.10
 go1.11.11
 go1.11.12
 go1.11.13
 go1.12
 go1.12beta1
 go1.12beta2
 go1.12rc1
 go1.12.1
 go1.12.2
 go1.12.3
 go1.12.4
 go1.12.5
 go1.12.6
 go1.12.7
 go1.12.8
 go1.12.9
 go1.12.10
 go1.12.11
 go1.12.12
 go1.12.13
 go1.12.14
 go1.12.15
 go1.12.16
 go1.12.17
 go1.13
 go1.13beta1
 go1.13rc1
 go1.13rc2
 go1.13.1
 go1.13.2
 go1.13.3
 go1.13.4
 go1.13.5
 go1.13.6
 go1.13.7
 go1.13.8
 go1.13.9
 go1.13.10
 go1.13.11
 go1.13.12
 go1.13.13
 go1.13.14
 go1.13.15
 go1.14
 go1.14beta1
 go1.14rc1
 go1.14.1
 go1.14.2
 go1.14.3
 go1.14.4
 go1.14.5
 go1.14.6
 go1.14.7
 go1.14.8
 go1.14.9
 go1.14.10
 go1.14.11
 go1.14.12
 go1.14.13
 go1.14.14
 go1.14.15
 go1.15
 go1.15beta1
 go1.15rc1
 go1.15rc2
 go1.15.1
 go1.15.2
 go1.15.3
 go1.15.4
 go1.15.5
 go1.15.6
 go1.15.7
 go1.15.8
 go1.15.9
 go1.15.10
 go1.15.11
 go1.15.12
 go1.15.13
 go1.15.14
 go1.15.15
 go1.16
 go1.16beta1
 go1.16rc1
 go1.16.1
 go1.16.2
 go1.16.3
 go1.16.4
 go1.16.5
 go1.16.6
 go1.16.7
 go1.16.8
 go1.16.9
 go1.16.10
 go1.16.11
 go1.16.12
 go1.16.13
 go1.16.14
 go1.16.15
 go1.17
 go1.17beta1
 go1.17rc1
 go1.17rc2
 go1.17.1
 go1.17.2
 go1.17.3
 go1.17.4
 go1.17.5
 go1.17.6
 go1.17.7
 go1.17.8
 go1.17.9
 go1.17.10
 go1.17.11
 go1.17.12
 go1.17.13
 go1.18
 go1.18beta1
 go1.18beta2
 go1.18rc1
 go1.18.1
 go1.18.2
 go1.18.3
 go1.18.4
 go1.18.5
 go1.18.6
 go1.18.7
 go1.18.8
 go1.18.9
 go1.18.10
 go1.19
 go1.19beta1
 go1.19rc1
 go1.19rc2
 go1.19.1
 go1.19.2
 go1.19.3
 go1.19.4
 go1.19.5
 go1.20
 go1.20rc1
 go1.20rc2
 go1.20rc3
 release.r56
 release.r57
 release.r58
 release.r59
 release.r60
 release.r57.1
 release.r57.2
 release.r58.1
 release.r58.2
 release.r60.1
 release.r60.2
 release.r60.3

安裝 go1.20 版本

1

gvm install go1.20 --binary

列出目前 gvm 已安裝的所有 Go 版本

1

gvm list

設定目前要用的 Go 版本（並設定為預設版本）

1

gvm use go1.20 --default

確認目前執行的 Go 版本

1

go version

BONUS(一)：管理 Gopath 環境

gvm 提供了一个比較簡單的工具 gvm pkgset 可以創建使用 GOPATH 環境：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


gvm pkgset

# * http://github.com/moovweb/gvm
# == Description
# GVM pkgset is used to manage various Go packages
# == Usage
# gvm pkgset Command
# == Command
# create - create a new package set
# delete - delete a package set
# use - select where gb and goinstall target and link
# empty - remove all code and compiled binaries from package set
# list - list installed go packages

BONUS(二)：卸載指定 Go 版本

1

gvm uninstall go1.13

安裝 VSCode 需要的 go modules 與相關工具

若要從 VSCode 自動開啟網頁，就必須安裝 xdg-utils 套件

1

sudo apt install xdg-utils -y

以下是 Go 擴充套件需要的 go modules

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


go get github.com/sqs/goreturns
go get github.com/mdempsky/gocode
go get github.com/uudashr/gopkgs/v2/cmd/gopkgs
go get github.com/ramya-rao-a/go-outline
go get github.com/acroca/go-symbols
go get golang.org/x/tools/cmd/guru
go get golang.org/x/tools/cmd/gorename
go get github.com/cweill/gotests/...
go get github.com/fatih/gomodifytags
go get github.com/josharian/impl
go get github.com/davidrjenni/reftools/cmd/fillstruct
go get github.com/haya14busa/goplay/cmd/goplay
go get github.com/godoctor/godoctor
go get github.com/go-delve/delve/cmd/dlv
go get github.com/stamblerre/gocode
go get github.com/rogpeppe/godef
go get golang.org/x/tools/cmd/goimports
go get golang.org/x/lint/golint
go get golang.org/x/tools/gopls

啟動 Visual Studio Code 開發工具

你現在可以在任何 WSL Distro 裡面直接輸入 code . 就可以開啟 Windows 環境下的 Visual Studio Code 開發工具！

1

code .

預設會自動安裝並載入 Visual Studio Code Remote - WSL 擴充套件。

安裝 Will 保哥出品的 Go Extension Pack 擴充套件

這份擴充套件包含了以下擴充套件：
執行 VSCode 中 Go 擴充套件的 Go: Install/Update Tools 命令一次

F1 > Go: Install/Update Tools
這個命令會自動安裝遺漏的套件，如果已經安裝過，也會自動更新套件！
調整 Visual Studio Code 使用者設定

在 Will 保哥的 Go Extension Pack 擴充套件說明頁面有提到幾個 Recommended Settings (建議設定)，請記得要手動調整 Visual Studio Code 使用者設定之後才會好用，尤其是快速鍵部分！

測試是否安裝成功

確認目前執行的 Go 版本

1

go version

抓取 Go 套件原始碼回來測試用 VSCode 開啟專案

1
2
3
4


git clone https://github.com/appleboy/gorush.git
cd gorush
make
code .

新增 .vscode/tasks.json 設定檔

預設的「建置」與「測試」命令與參數，每個專案都可能有所不同，請記得手動調整過！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


{
 // See https://go.microsoft.com/fwlink/?LinkId=733558
 // for the documentation about the tasks.json format
 "version": "2.0.0",
 "tasks": [
 {
 "label": "build",
 "command": "go",
 "type": "shell",
 "args": [
 "build",
 "-o",
 "dist/${workspaceFolderBasename}"
 ],
 "group": {
 "kind": "build",
 "isDefault": true
 },
 "presentation": {
 "reveal": "silent"
 },
 "problemMatcher": "$msCompile"
 },
 {
 "label": "test",
 "command": "go",
 "type": "shell",
 "args": [
 "test",
 ],
 "group": {
 "kind": "test",
 "isDefault": true
 },
 "presentation": {
 "reveal": "silent"
 },
 "problemMatcher": "$msCompile"
 }
 ]
}

調整 Visual Studio Code 使用者設定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


{
 "go.useLanguageServer": true,

 "editor.snippetSuggestions": "top",
 "terminal.integrated.shellArgs.linux": ["-l"],

 "code-runner.saveAllFilesBeforeRun": true,
 "code-runner.ignoreSelection": true,
 "code-runner.runInTerminal": true
}