fmt.Printf("第%d問の答えは%sです\n", i, answer)  // 標準出力（通常は画面）に出力

$ cd example/ch22b/00fmt-verb  # 例題ディレクトリの00fmt-verbに移動
$ go run main.go

$ cd example/ch22b/00fmt-verb
$ go build
$ ./fmt-verb

package main    // メインプログラムは必ずこうする

import "fmt"    // 読み込むパッケージ（ライブラリ）の宣言

func main() {   // 関数の定義。必ずmainが必要。「{」の前で改行してはダメ！
    i := 3      // 変数iに3が代入される。型は自動判定される。この場合はint（整数）
    answer := "Go言語"  // "Go言語"は文字列なので、answerの型はstring（文字列）
    fmt.Printf("第%d問の答えは「%s」です。\n", i, answer)     // ←1:
    // %dがiに、%sがanswerに対応

    s1 := "文字列"
    fmt.Printf("%s\n", s1)                                  // ←2:
    s2 := `バッククオートを使った、改行や
    タブが入った
        文字列`
    fmt.Printf("%s\n", s2)  // そのまま表示                   // ←3〜5:
    fmt.Printf("%q\n", s2)  // 「エスケープ」される            // ←6:

    i = 254  // 上でiの型はintになっているので、254は代入できる
    fmt.Printf("d: %d  b: %b  o: %o  x: %x  X: %X\n", i, i, i, i, i)  // ←7:

    f := 3.14159265358      // 小数（型はfloat64）
    fmt.Printf("f: %f  F: %F\ne: %e  E: %E\n", f, f, f, f)  // ←8〜9:
    fmt.Printf("v: %v  %v  %v\n", s1, i, f)                 // ←10:
    fmt.Printf("T: %T  %T  %T\n", s1, i, f)                 // ←11:
    fmt.Printf("「%%%%」で「%%」をひとつ出力\n")               // ←12:

    fmt.Printf("%%fでs1を指定: %f\n", s1)     // ←13:（間違いあり！）
}

package main  // メインプログラムは必ずこうする

import (  // 読み込むパッケージ（ライブラリ）の宣言
    "fmt"   // 入出力関連のパッケージ 。Scanln と Printlnを使う
    "strconv"  // 文字列から、整数などへの変換。Atoiを使う
) // 複数のパッケージを呼び込む場合は、(...)で指定すると「import」は1個で済む

func main() {
    answer := 4  // :=を使うと型は自動判別してくれる。この場合answerの型はint
    fmt.Print("数当てゲームです。1以上10以下の整数を（半角で）入力してください: ")
    // パッケージfmtの関数Printを使う。パッケージ外に公開する関数は必ず大文字で始まる
    var inp string  // 「var 変数 型」の順。変数には型の「ゼロ値」が入る
        //（この場合は空文字列""になる。整数ならゼロ値は0（「2.1.1 ゼロ値」）
    fmt.Scanln(&inp) // 文字列として読み込み。&はポインタを表す
    // inpの値を書き換えてもらうためにポインタを渡す（「6章 ポインタ」）
    // Scanlnは読み込んだ単語数（スペースあるいは改行区切り）とエラーを戻すが
    // 今回はどちらも無視するので、結果を変数に代入していない
    // 下で整数に変換できなければエラーになるのでこれで大丈夫
    num, err := strconv.Atoi(inp) // 整数に変換（Ascii TO Integer）
    if err != nil || num < 1 || 10 < num  { // 条件を(...)でくくらない
        fmt.Println("1以上10以下の整数ではないので、ハズレです。")
    } else if num == answer { // else を「}」と同じ行に*必ず*書くことに注意
        fmt.Println("ビンゴ！")
    } else {  // else を「}」と同じ行に*必ず*書くことに注意
        fmt.Println("残念でした。ハズレです。")
    }
}

package main  // メインプログラムは必ずこうする

import (  // 読み込むライブラリの宣言
    "fmt"   // 出力関連
    "strconv"  // 文字列から整数などへの変換
    "math/rand"   // 乱数。強力なものが必要ならcrypto/randを使う
    // "time"  // Go 1.20から不要になった（乱数のseed（種）を生成するためのものだった）
)

// main
func main() {
    answer := getTheNumber();    // 関数呼び出し。答えの数字をもらう

    for count:=1; ; count++ {  //「条件」を指定しないと無限ループになる
        printPrompt(count) // 説明のメッセージを表示

        if num, err := readUserAnswer();
        err != nil || num < 1 || 10 < num  {
            // 条件の前で変数を宣言し、値の代入もできる。「err != nil」以降がifの条件
            fmt.Println("1以上10以下の整数ではないので、ハズレです。")
            // fmt.Printlnは改行する
        } else if num != answer {
            fmt.Println("残念でした。ハズレです。")
        } else {
            printSuccessMessage(count) // 当たったときのメッセージを表示
            break  // forループを抜ける
        }
    }
}

// getTheNumber 当てる数字を得る
func getTheNumber() int { // 関数宣言。引数はなし、戻り値はint（整数）
    // rand.Seed(time.Now().UnixNano()) // Go 1.20から不要になった（乱数のseedの設定用）
    num := rand.Intn(10)+1  // 0以上10未満の整数をもらって、+1する
    // fmt.Println("答えは: ", num)  // デバッグ用
    return num
}

// printPrompt プロンプト文字列（説明）を表示
func printPrompt(count int) { // 引数は整数。戻り値はなし
    if count == 1 { // 1回目のみ表示
        fmt.Print("数当てゲームです。")  // fmt.Printは改行しない
    }
    fmt.Printf("1以上10以下の整数を（半角で）入力してください（%v回目）: ", count)
    // fmt.Printfではフォーマットが指定できる。%vを指定すると「良きに計らって」くれる
}

// readUserAnswer ユーザーからの答えを読み込む
func readUserAnswer() (int, error) {  // 戻り値が2つある
    var inp string
    fmt.Scanln(&inp) // 文字列として1行読み込み。詳細は前の例のScanlnのところ参照
    return strconv.Atoi(inp) // 整数に変換。errorも戻る
}

// printSuccessMessage 当たったときのメッセージを表示
func printSuccessMessage(count int) {
    if count == 1 {
        fmt.Printf("ビンゴ！ おめでとうございます。一発で当たりましたね。素晴らしい！\n")
    } else {
        adverb := "" // 副詞（修飾語「ヤット」をつけるかどうか）
        if  7 < count  {
            adverb = "ヤット"
        }
        fmt.Printf("おめでとうございます。%v回目で%s当たりましたね。\n", count, adverb)
    }
}

関数main（switch文を使ったもの）

func main() {
    answer := getTheNumber();
loop:  // 下のbreakでループを抜けるための「ラベル」
    for count := 1; ; count++ {  // 無限ループ
        printPrompt(count) // 入力を促すメッセージを表示

        switch num, err := readUserAnswer(); { // 答えを読み込む
        case err != nil || num < 1 || 10 < num:
            fmt.Println("1以上10以下の整数ではないので、ハズレです。")
            // fmt.Printlnは改行する。breakがなくても、このcaseはここで終了
        case num != answer:
            fmt.Println("残念でした。ハズレです。")
            // breakがなくても、このcaseはここで終了
        default:
            printSuccessMessage(count) // 当たったときのメッセージを表示
            break loop  // forループを抜ける。loopは「ラベル」。
                        // breakだけだとdefaultを抜けるだけになってしまう
        }
    }
}

関数printSuccessMessage（switch文を使ったもの）

func printSuccessMessage(count int) {
    adverb := ""
    switch {
    case count == 1:
        fmt.Printf("ビンゴ！ おめでとうございます。一発で当たりましたね。素晴らしい！\n")
    case 7 < count:
        adverb = "ヤット"
        fallthrough  // この下のcaseも実行。「落っこちる」
    default:
        fmt.Printf("おめでとうございます。%v回目で%s当たりましたね。\n", count, adverb)
    }
}

関数main（日本語の識別子を使ったもの）

func main() {
    正解 := 当てる数字を決定();
loop:
    for カウンタ := 1; ; カウンタ++ {  // 無限ループ
        プロンプトを表示(カウンタ) // 入力を促すメッセージを表示

        switch 解答, err := ユーザーからの答えを取得(カウンタ); { // 答えを読み込む
        case err != nil || 解答 < 1 || 10 < 解答:
            fmt.Println("1以上10以下の整数ではないので、ハズレです。")
            // breakがなくても、このcaseはここで終了
        case 解答 != 正解:
            fmt.Println("残念でした。ハズレです。")
            // breakがなくても、このcaseはここで終了
        default:
            成功時のメッセージを表示(カウンタ) // 当たったときのメッセージを表示
            break loop // forループを抜ける。breakだけだとdefaultを抜けるだけになる
        }
    }
}

関数printSuccessMessageの日本語の識別子を使ったバージョン

func 成功時のメッセージを表示(カウンタ int) {
    修飾語 := ""
    switch {
    case カウンタ == 1:
        fmt.Printf("ビンゴ！ おめでとうございます。一発で当たりましたね。素晴らしい！\n")
    case 7 < カウンタ:
        修飾語 = "ヤット"
        fallthrough  // この下のcaseも実行。「落っこちる」
    default:
        fmt.Printf("おめでとうございます。%v回目で%s当たりましたね。\n", カウンタ, 修飾語)
    }
}

$ bc -l
3400*2             3400×2を計算
6800               答えは 6800
(3330+95-120)*1.1  (3330+95-120)×1.1
3635.5             上の答え
12^3               12の3乗（12×12×12）
1728               上の答え

$ cd ch22b/05a-calc-bc
$ rm -f calc go.mod go.sum   # ソースコード以外のものを（あれば）消す
$ go mod init example/calc   # go.modファイルができる
$ go mod tidy                # 必要なモジュールをダウンロードし、go.sumファイルができる
$ go build                   # ビルド。実行形式ファイルcalcが作られる
$ ./calc "３、３３３*１．１"   # 引数に計算式を全角で指定
次の計算をします: 3333*1.1     文字列を変えたので、一応確認
3666.3                       答え
１２＾５                      12の5乗（12×12×12×12×12）
次の計算をします: 12^5
248832
３４５，１２３÷１２
次の計算をします: 345123/12
28760.25000000000000000000
...                          いろいろ計算してみてください
                             改行のみで終了

package main

import (
    "fmt"
    "os" // コマンドライン引数の処理
    "strings"  // 文字列置換
    "regexp"  // 正規表現
    "bufio" // 読み込み
    "golang.org/x/text/width" // 全角 -> 半角変換
)

func main() {
    var exp string  // EXPression: 式
    if n := len(os.Args); 2 <= n { // 引数があったら
        for i := 1; i < n; i++ {
            exp += os.Args[i] // 引数を後ろに追加していく
        }
        calculateAndPrintValue(exp) // 必要な変換を行って計算する
    }

    scanner := bufio.NewScanner(os.Stdin) // 標準入力を受け付ける「スキャナ」
    for scanner.Scan() { // １行分の入力を取得。できる限り繰り返す
        exp = scanner.Text()  // 入力のテキスト（string）を取得
        if exp == "" {
            return  // 空行入力で終了
        }
        calculateAndPrintValue(exp) // 必要な変換を行って計算する
    }
}

// calculateAndPrintValue  文字の置換を行って計算し出力する
func calculateAndPrintValue(exp string) error {
    expOrigin := exp
    exp = replaceChars(exp) // ÷->/  全角->半角変換などを行う
    if (exp != expOrigin) {
        fmt.Println("次の計算をします:", exp) // 変えた時は確認のため表示
    }
    result, err := calculate(exp) // 計算実行。エラーが起こればerrがnilでなくなる
    if err != nil || len(result)==0 { // エラーが起こったか、結果が空の時
        fmt.Println("計算できません")
    } else {
        fmt.Printf("%s\n", result)
    }
    return err
}

// replaceChars  置換する
func replaceChars(exp string) string {
    exp = width.Fold.String(exp) // 全角 -> 半角
    re := regexp.MustCompile(`[xX]`) // 正規表現を「コンパイル」
    exp = re.ReplaceAllString(exp, "*") // 「x」「X」 -> 「*」

    re = regexp.MustCompile(`[,、，]`) // 3桁ごとの区切り
    exp = re.ReplaceAllString(exp, "") // 「,」「、」「，」 削除

    re = regexp.MustCompile(`[。．]`)
    exp = re.ReplaceAllString(exp, ".") //全角の 「．」「。」 -> 半角の「.」

    exp = strings.ReplaceAll(exp, "÷", "/") //  「÷」 -> 「/」
    return exp
}

package main

import (
    "fmt"
    "os/exec" // OSコマンドの実行
    "strings"
)
// calculate  bcコマンドを呼び出して計算する
func calculate(exp string) (string, error) {
    command := fmt.Sprintf("echo \"%s\" | bc -l", exp)
    // コマンドの文字列を作る。Sprintfの%sの部分がexpの値で置き換わる
    result, err := exec.Command("sh", "-c", command).Output()
    // resultはバイト列（型byteのスライス -- []byte）
    // スライスは「可変長の配列」。Goの配列はサイズ固定だがスライスは変更可
    // err はエラーがあるかどうかを示す。errが nilならば正常終了
    // err の処理は呼び出し側（calculateAndPrintValue）が行う
    if err != nil {
        return "", err
    }
    r := string(result)
    r = strings.TrimRight(r, "\n") // 最後に改行がついて戻るので削除する
    return r, err // 2つの値を戻す
}

// 「//」で始まる行はコメント。英語と日本語はタブで区切る
fungible        代替可能な, 代替性のある, 代替物
fungibility     代替可能性
// fungibility  代替できること
pronunciation   発音

package main

import (
    "fmt"
    "os" // ファイルの読み込みなど
    "strings" // 文字列置換
    "log"  // ログを書くのに便利。
)

// 定数の宣言（詳細は「2.3 定数」）。型は右辺のデフォルト（この場合string）になる
const path1 = "testdata/dict.txt"

func main(){
    allData, err := os.ReadFile(path1) // 全データを一度に読み込み
    // allDataは[]uint8（8ビット符号なし整数のスライス）
    // io/ioutilにもReadFileがある。現在も動作するが、今は単に上のos.ReadFileが呼ばれる
    if err != nil {
        log.Fatal(err) // エラーをログに書いて異常終了
    }
    s := string(allData)     // string(allData)で型をstringに変換してから呼び出し
    s = strings.ReplaceAll(s, "//", "##") // 「//」を「##」にすべて置換
    s = strings.ReplaceAll(s, "\t", "|")  // 「タブ」を「|」にすべて置換
    fmt.Printf("%s", s) // 文字列置換した結果を出力
}

$ go run main.go
## 「##」で始まる行はコメント。英語と日本語はタブで区切る
fungible|代替可能な, 代替性のある, 代替物
fungibility|代替可能性
## fungibility|代替できること
pronunciation|発音

2025/05/22 14:44:19 open testdata/xxx.txt: no such file or directory
exit status 1

allData = bytes.ReplaceAll(allData, []byte( "//"), []byte("##"))
// 第2、第3引数はバイト列に変換してから呼び出し
allData = bytes.ReplaceAll(allData, []byte( "\t"), []byte("|"))
fmt.Printf("%s", allData) // 置換した結果を出力。%sを指定すれば文字列になる

r := strings.NewReplacer("//", "##", "\t", "|") // 一度に複数のペアを指定できる
result := r.Replace(string(allData)) // replacerを使って文字列を置換
fmt.Printf("%s", result)

$ cd ch22b/07fileb-linebyline
$ cat testdata/dict2.txt
## #で始まる行はコメント
fungible|代替可能な, 代替性のある、 代替物
fungibility|代替可能性
# fungibility|代替できること
pronunciation|発音，発音記号

$ go run main.go
fungible|代替可能な
fungible|代替性のある
fungible|代替物
fungibility|代替可能性
pronunciation|発音
pronunciation|発音記号

package main

import (
    "fmt"
    "os"
    "bufio"
    "strings"
    "regexp"
)

var re1 = regexp.MustCompile(`[,，、] *`) // 正規表現をコンパイルしておく

func main(){
    data, _ := os.Open("testdata/dict2.txt")
    defer data.Close()

    scanner := bufio.NewScanner(data)
    for scanner.Scan() {
        s := scanner.Text()
        if s == "" || s[0:1] == "#" { // s[0:1] で先頭の1文字
            continue  // この行はスキップ（コメントあるいは空白行）
        }
        columns := strings.Split(s, "|") // "|"で分割
        if len(columns)!=2 { // カラム数が2個でないとき
            continue // この行はスキップ。形式がおかしい
        }
        eng := columns[0] // 英語部分
        jpn := columns[1] // 日本語訳
        translations := re1.Split(jpn, -1) // 正規表現を使って分割
        // -1ですべての部分文字列を分割。[]string（文字列のスライス）が戻る
        for _, translation := range translations {
            // range からはインデックス（添字）と文字列が戻るが、インデックスは無視する
            // 「_」に代入すると無視できる
            // 変数に代入するとその変数を使わないとエラーになってしまうので
            fmt.Printf("%s|%s\n", eng, translation);
        }
    }
}

// 無名関数を定義して、その無名関数の外の関数で定義されたchをそのまま使う
func main() {
    ch := make(chan string) // 文字列をやり取りするチャネルchを作る

    go func () { // 無名関数を定義。goが頭につくとゴルーチンとして実行
        s1 := "メッセージ1"
        fmt.Println("chへ書き込み:", s1) // chへ書き込み: メッセージ1
        ch <- s1  // 外側の関数のチャネル変数chをそのまま使う

        s1 = "メッセージ2"
        fmt.Println("chへ書き込み:", s1) // chへ書き込み: メッセージ2
        ch <- s1

        s1 = "メッセージ3"
        fmt.Println("chへ書き込み:", s1) // chへ書き込み: メッセージ3
        ch <- s1
    }()  // () を書いて無名関数を実行する。()を書かないとコンパイル時のエラー

    s := <-ch
    fmt.Println("sをchから読み込み:", s) // sをchから読み込み: メッセージ1

    <-ch // スキップ。2つ目を飛ばすことになる

    s = <-ch
    fmt.Println("sをchから読み込み:", s) // sをchから読み込み: メッセージ3
}

$ go run main.go
chへ書き込み: メッセージ1
chへ書き込み: メッセージ2
sをchから読み込み: メッセージ1
chへ書き込み: メッセージ3
sをchから読み込み: メッセージ3

// 参考。無名関数ではなく、関数を定義してゴルーチンとして起動
package main

import "fmt"

func main() {
        ch := make(chan string)
        go sub(ch) // subをchを引数としてゴルーチンとして起動する

        s := <-ch
        fmt.Println("sをchから読み込み:", s) // sをchから読み込み: メッセージ1
        <-ch // スキップ。2つ目を飛ばすことになる
        s = <-ch
        fmt.Println("sをchから読み込み:", s) // sをchから読み込み: メッセージ3
}

func sub(c3 chan<-string) { // チャネルに書き込みのみを行う指定
        s1 := "メッセージ1"
        fmt.Println("c3へ書き込み:", s1) // c3へ書き込み: メッセージ1
        c3 <- s1
        s1 = "メッセージ2"
        fmt.Println("c3へ書き込み:", s1) // c3へ書き込み: メッセージ2
        c3 <- s1
        s1 = "メッセージ3"
        fmt.Println("c3へ書き込み:", s1) // c3へ書き込み: メッセージ3
        c3 <- s1
}

package main

import(
    "fmt"
    "sync"
    "net/http"
    "time"
)

func main() {
    var wg sync.WaitGroup // WaitGroupを使って終了してもよい時を判断
    websites := []string{  // チェックするサイトのURL。文字列のスライス
        "https://www.oreilly.co.jp/",
        "https://musha.com/",
        "https://marlin-arms.com/",
        "https://dictjuggler.net/",
        "http://localhost/",
    }

    client := &http.Client{ // 「13.4 net/http」参照
        Timeout: 200 * time.Millisecond, // タイムアウトの設定  ミリ秒単位 「11.2.1 時間」参照
    }
    fmt.Printf("%T\n", client)

    for i, website := range websites { // 各サイトについて
        go checkWebsite(website, i, &wg, client) // ゴルーチンを生成
        wg.Add(1) // WaitGroupのカウンタを1増やす（処理が終了したら1減る）
    }

    wg.Wait() // WaitGroupのカウンタが0になるのを待つ
    // 0になれば全部確認が終わっているので、終了する
}

// checkWebsite 指定されたページを確認
func checkWebsite(url string, i int, wg *sync.WaitGroup, client *http.Client) {
    defer wg.Done() // 抜ける時にWaitGroupのカウンタを1減らす
    // 忘れないように冒頭にdeferを使って書いておく
    if res, err := client.Get(url); err != nil { // res: response
        fmt.Printf("%d %s  **ダウン** \n", i, url)
    } else {
        fmt.Printf("%d %s  code: %v\n", i, url, res.Status)
    }
}

$ cd ch22b/09waitgroup
$ go run main.go
4 http://localhost/  **ダウン**
2 https://marlin-arms.com/  code: 200 OK
1 https://musha.com/  code: 200 OK
3 https://dictjuggler.net/  code: 200 OK
0 https://www.oreilly.co.jp/  code: 200 OK

package main

import(
    "fmt"
    "net/http"
    "time"
)

const TimeLimit time.Duration = 1000 * time.Millisecond
// タイムリミットを設定
// const TimeLimit time.Duration = 80 * time.Millisecond

type ServerStatus int // サーバの状況を示す型ServerStatusを定義

const ( // ServerStatusが取りうる具体的な値（定数）の定義
    不明   ServerStatus = iota  // 「不明」に 整数の0が割り当てられる
    アップ    // 「アップ」に1
    問題発生  // 「問題発生」に2
)
// ↑変数に使える文字なら日本語も使える

type site struct {
    url string // URL文字列
    status ServerStatus  // 現状。「不明」「アップ」「問題発生」のいずれか
}


func main() {
    websites := []site {  // URLと現状。構造体のスライス
        {"https://www.oreilly.co.jp/", 不明},
        {"https://musha.com/", 不明},
        {"https://marlin-arms.com/", 不明},
        {"https://dictjuggler.net/", 不明},
        {"http://localhost/", 不明},
    }

    ch := make(chan site) // siteをやり取りするチャネルchを作る
    defer close(ch) // 最後にチャネルを閉じる
    client := &http.Client{ // 「11.4.1 クライアント」参照
        Timeout: time.Duration(TimeLimit), // タイムリミットの設定
    }
    for _, site := range websites { // 各サイトについて
        go checkWebsite(site, ch, client) // ゴルーチンを生成
    }

    for i:=0; i<len(websites); i++ { // サイトの数だけループ
        siteResponded := <-ch // どのサイトから返事が来るか、順番はわからない
        fmt.Printf("%s: %v\n", siteResponded.url, siteResponded.status)
        // チャネル経由で返事が来たサイトのURLと状況を書く
    }
}

// checkWebsite siteに指定されたページをチェックする
func checkWebsite(s site, ch chan<-site, client *http.Client) {
    if _, err := client.Get(s.url); err != nil { // urlから
        s.status = 問題発生
    } else {
        s.status = アップ
    }
    ch <- s
}

// ServerStatus 専用の関数（インタフェース）String。これを定義しておくことで、
// fmt.Printfに%vを指定した時に、数字ではなくここで指定した文字列で表示される
// 実行結果参照
func (ss ServerStatus) String() string {
    switch ss {
    case 不明:
        return "不明"
    case アップ:
        return "OK"
    case 問題発生:
        return "★問題発生★"
    default: // これがあれば、将来状態を追加しても何かが表示される
        return fmt.Sprintf("%d", int(ss))
    }
}

$ cd ch22b/10a-server-check-goroutine
$ go run main.go
http://localhost/: ★問題発生★
https://marlin-arms.com/: OK
https://musha.com/: OK
https://dictjuggler.net/: OK
https://www.oreilly.co.jp/: OK