Go言語の書き方：初心者向け基本ステップとベストプラクティス

go version

go version go1.20.3 windows/amd64

package main
import "fmt"
// main関数はプログラムのエントリーポイントです
func main() {
    message := "Hello, World!" // メッセージを定義
    fmt.Println(message)       // メッセージを出力
}

Hello, World!

package main
import "fmt"
// main関数はプログラムのエントリーポイントです
func main() {
    var age int = 25 // 変数ageを宣言し、値を代入
    name := "鈴木"    // 型推論を使用して変数nameを宣言
    const Pi = 3.1415 // 定数Piを宣言
    fmt.Println("名前:", name)
    fmt.Println("年齢:", age)
    fmt.Println("Piの値:", Pi)
}

名前: 鈴木
年齢: 25
Piの値: 3.1415

package main
import "fmt"
// main関数はプログラムのエントリーポイントです
func main() {
    var score int = 80
    var percentage float64 = float64(score) / 100.0
    fmt.Println("スコア:", score)
    fmt.Println("割合:", percentage)
}

スコア: 80
割合: 0.8

package main
import "fmt"
// main関数はプログラムのエントリーポイントです
func main() {
    number := 7
    // 条件分岐
    if number%2 == 0 {
        fmt.Println(number, "は偶数です。")
    } else {
        fmt.Println(number, "は奇数です。")
    }
    // ループ
    for i := 1; i <= 5; i++ {
        fmt.Println("カウント:", i)
    }
}

7 は奇数です。
カウント: 1
カウント: 2
カウント: 3
カウント: 4
カウント: 5

package main
import "fmt"
// add関数は2つの整数を受け取り、その合計を返します
func add(a int, b int) int {
    return a + b
}
// main関数はプログラムのエントリーポイントです
func main() {
    result := add(10, 20) // add関数を呼び出し
    fmt.Println("合計:", result)
}

合計: 30

package main
import (
    "fmt"
    "math"
)
// main関数はプログラムのエントリーポイントです
func main() {
    radius := 5.0
    area := math.Pi * math.Pow(radius, 2) // mathパッケージを使用
    fmt.Println("円の面積:", area)
}

円の面積: 78.53981633974483

package main
import "fmt"
// divide関数は2つの整数を受け取り、商と余りを返します
func divide(a int, b int) (int, int) {
    quotient := a / b // 商を計算
    remainder := a % b // 余りを計算
    return quotient, remainder
}
// main関数はプログラムのエントリーポイントです
func main() {
    q, r := divide(10, 3) // divide関数を呼び出し
    fmt.Println("商:", q)
    fmt.Println("余り:", r)
}

商: 3
余り: 1

package main
import "fmt"
// sum関数は任意の数の整数を受け取り、その合計を返します
func sum(numbers ...int) int {
    total := 0 // 合計を初期化
    for _, num := range numbers {
        total += num // 各数値を合計に加算
    }
    return total
}
// main関数はプログラムのエントリーポイントです
func main() {
    result := sum(1, 2, 3, 4, 5) // sum関数を呼び出し
    fmt.Println("合計:", result)
}

合計: 15

package main
import "fmt"
// main関数はプログラムのエントリーポイントです
func main() {
    name := "田中"
    age := 30
    fmt.Printf("%sさんは%d歳です。\n", name, age) // フォーマットされた文字列を出力
}

田中さんは30歳です。

package main
import (
    "fmt"
    "math"
)
// main関数はプログラムのエントリーポイントです
func main() {
    number := -16.0
    absValue := math.Abs(number) // 絶対値を計算
    sqrtValue := math.Sqrt(25)   // 平方根を計算
    fmt.Println("絶対値:", absValue)
    fmt.Println("平方根:", sqrtValue)
}

絶対値: 16
平方根: 5

package mathutil
// Multiply関数は2つの整数を掛け算します
func Multiply(a int, b int) int {
    return a * b
}
// Add関数は2つの整数を加算します
func Add(a int, b int) int {
    return a + b
}

package main
import (
    "fmt"
    "your_module_path/mathutil" // カスタムパッケージをインポート
)
// main関数はプログラムのエントリーポイントです
func main() {
    product := mathutil.Multiply(4, 5) // Multiply関数を呼び出し
    sum := mathutil.Add(10, 20)        // Add関数を呼び出し
    fmt.Println("掛け算の結果:", product)
    fmt.Println("足し算の結果:", sum)
}

掛け算の結果: 20
足し算の結果: 30

go mod init your_module_path

go get github.com/gin-gonic/gin

go get -u

package main
import "fmt"
// greet関数は指定された名前に挨拶をします
func greet(name string) {
    fmt.Printf("こんにちは、%sさん！\n", name)
}
// main関数はプログラムのエントリーポイントです
func main() {
    userName := "佐藤"
    greet(userName) // greet関数を呼び出し
}

こんにちは、佐藤さん！

package main
import (
    "fmt"
    "strconv"
)
// parseNumber関数は文字列を整数に変換します
func parseNumber(s string) (int, error) {
    number, err := strconv.Atoi(s) // 文字列を整数に変換
    if err != nil {
        return 0, err // エラーが発生した場合はエラーを返す
    }
    return number, nil
}
// main関数はプログラムのエントリーポイントです
func main() {
    input := "123a" // 故意に誤った入力を設定
    number, err := parseNumber(input)
    if err != nil {
        fmt.Println("エラー:", err)
        return
    }
    fmt.Println("変換された数字:", number)
}

エラー: strconv.Atoi: parsing "123a": invalid syntax

package main
import "fmt"
// Rectangle構造体は長方形の幅と高さを表します
type Rectangle struct {
    Width  float64 // 幅
    Height float64 // 高さ
}
// Areaメソッドは長方形の面積を計算します
func (r Rectangle) Area() float64 {
    return r.Width * r.Height // 面積を計算
}
// main関数はプログラムのエントリーポイントです
func main() {
    rect := Rectangle{Width: 5.0, Height: 3.0}
    fmt.Println("長方形の面積:", rect.Area())
}

長方形の面積: 15

package main
import (
    "testing"
)
// Add関数は2つの整数を加算します
func Add(a int, b int) int {
    return a + b
}
// TestAdd関数はAdd関数のテストを行います
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("Add(2, 3) = %d; expected %d", result, expected)
    }
}

go test

ok      your_module_path    0.001s

package main
import "fmt"
// Person構造体は個人情報を表します
type Person struct {
    FirstName string // 名
    LastName  string // 姓
}
// NewPerson関数は新しいPersonを作成します
func NewPerson(firstName, lastName string) Person {
    return Person{FirstName: firstName, LastName: lastName}
}
// FullNameメソッドはPersonのフルネームを返します
func (p Person) FullName() string {
    return p.FirstName + " " + p.LastName
}
// main関数はプログラムのエントリーポイントです
func main() {
    person := NewPerson("山田", "太郎")
    fmt.Println("フルネーム:", person.FullName())
}

フルネーム: 山田 太郎

package main
import (
    "fmt"
    "time"
)
// sayHello関数は挨拶を出力します
func sayHello() {
    fmt.Println("こんにちは、goroutine!")
}
func main() {
    go sayHello() // sayHello関数をgoroutineとして実行
    // メインゴルoutineが別の処理を継続
    for i := 0; i < 3; i++ {
        fmt.Println("メインゴルoutine:", i)
        time.Sleep(500 * time.Millisecond) // 0.5秒待機
    }
}

メインゴルoutine: 0
こんにちは、goroutine!
メインゴルoutine: 1
メインゴルoutine: 2

package main
import (
    "fmt"
)
// sendNumbers関数はチャネルに数字を送信します
func sendNumbers(ch chan int) {
    for i := 1; i <= 5; i++ {
        ch <- i // チャネルにデータを送信
    }
    close(ch) // チャネルを閉じる
}
func main() {
    numbers := make(chan int) // 整数型のチャネルを作成
    go sendNumbers(numbers) // sendNumbers関数をgoroutineとして実行
    // チャネルからデータを受信
    for num := range numbers {
        fmt.Println("受信した数字:", num)
    }
}

受信した数字: 1
受信した数字: 2
受信した数字: 3
受信した数字: 4
受信した数字: 5

package main
import (
    "fmt"
)
// sendMessages関数はチャネルにメッセージを送信します
func sendMessages(ch chan string) {
    messages := []string{"こんにちは", "世界", "Go言語"}
    for _, msg := range messages {
        ch <- msg // チャネルにメッセージを送信
        fmt.Println("送信したメッセージ:", msg)
    }
    close(ch) // チャネルを閉じる
}
func main() {
    messageChannel := make(chan string, 2) // バッファサイズ2のチャネルを作成
    go sendMessages(messageChannel) // sendMessages関数をgoroutineとして実行
    // チャネルからデータを受信
    for msg := range messageChannel {
        fmt.Println("受信したメッセージ:", msg)
    }
}

送信したメッセージ: こんにちは
送信したメッセージ: 世界
受信したメッセージ: こんにちは
送信したメッセージ: Go言語
受信したメッセージ: 世界
受信したメッセージ: Go言語

package main
import (
    "fmt"
    "sync"
    "time"
)
// worker関数は指定されたIDで処理を行います
func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 処理が完了したらWaitGroupをデクリメント
    fmt.Printf("ワーカー%dが開始しました。\n", id)
    time.Sleep(time.Second) // 疑似的な処理時間
    fmt.Printf("ワーカー%dが完了しました。\n", id)
}
func main() {
    var wg sync.WaitGroup // WaitGroupを初期化
    for i := 1; i <= 3; i++ {
        wg.Add(1) // WaitGroupにgoroutineを追加
        go worker(i, &wg) // worker関数をgoroutineとして実行
    }
    wg.Wait() // すべてのgoroutineの完了を待機
    fmt.Println("すべてのワーカーが完了しました。")
}

ワーカー1が開始しました。
ワーカー2が開始しました。
ワーカー3が開始しました。
ワーカー1が完了しました。
ワーカー2が完了しました。
ワーカー3が完了しました。
すべてのワーカーが完了しました。

package main
import (
    "fmt"
    "sync"
)
// Counter構造体はカウンターの値とミューテックスを保持します
type Counter struct {
    value int
    mux   sync.Mutex
}
// Increment関数はカウンターをインクリメントします
func (c *Counter) Increment() {
    c.mux.Lock()   // ミューテックスをロック
    c.value++      // カウンターをインクリメント
    c.mux.Unlock() // ミューテックスをアンロック
}
// Value関数は現在のカウンターの値を返します
func (c *Counter) Value() int {
    c.mux.Lock()         // ミューテックスをロック
    defer c.mux.Unlock() // 関数終了時にミューテックスをアンロック
    return c.value
}
func main() {
    var wg sync.WaitGroup
    counter := Counter{}
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment() // カウンターをインクリメント
        }()
    }
    wg.Wait() // すべてのgoroutineの完了を待機
    fmt.Println("最終カウンターの値:", counter.Value())
}

最終カウンターの値: 100

package main
import (
    "fmt"
    "sync"
)
// fetchData関数はデータを取得し、チャネルに送信します
func fetchData(id int, ch chan<- string, wg *sync.WaitGroup) {
    defer wg.Done()
    data := fmt.Sprintf("データ%d", id) // 仮のデータ取得
    ch <- data // チャネルにデータを送信
}
func main() {
    var wg sync.WaitGroup
    dataChannel := make(chan string, 3) // バッファサイズ3のチャネルを作成
    // 3つのデータを並行して取得
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go fetchData(i, dataChannel, &wg)
    }
    // すべてのデータの取得が完了したらチャネルを閉じる
    go func() {
        wg.Wait()
        close(dataChannel)
    }()
    // チャネルからデータを受信し、結果を表示
    for data := range dataChannel {
        fmt.Println("受信した:", data)
    }
    fmt.Println("すべてのデータを受信しました。")
}

受信した: データ1
受信した: データ2
受信した: データ3
すべてのデータを受信しました。