Go言語の基本概念と実践的な利用方法を解説

package main
import "fmt"
// main関数はプログラムのエントリーポイントです。
func main() {
    // 簡単な出力例です。コンパイルと実行が非常に速いことが魅力です。
    fmt.Println("こんにちは、Go言語の世界！")
}

こんにちは、Go言語の世界！

package main
import (
    "fmt"
    "time"
)
// printMessageは指定されたメッセージを表示する関数です。
func printMessage(message string, ch chan string) {
    // 小休止後にメッセージをチャンネルに送信します。
    time.Sleep(500 * time.Millisecond)
    ch <- message
}
func main() {
    messageChannel := make(chan string)
    // goroutineを起動してメッセージの送信処理を実行します。
    go printMessage("並行処理の実例です", messageChannel)
    // チャンネルから送信されたメッセージを受信して表示します。
    result := <-messageChannel
    fmt.Println(result)
}

並行処理の実例です

package main
import "fmt"
// Personは人間の基本情報を表す構造体です。
type Person struct {
    Name string // 名前
    Age  int    // 年齢
}
func main() {
    // Person型の変数を初期化します。
    person := Person{
        Name: "太郎",
        Age:  30,
    }
    fmt.Printf("名前: %s, 年齢: %d\n", person.Name, person.Age)
}

名前: 太郎, 年齢: 30

package main
import "fmt"
// Speakerは発言する機能を持つ型のためのインターフェースです。
type Speaker interface {
    Speak() string
}
// Humanは人間を表す構造体です。
type Human struct {
    Name string
}
// Catは猫を表す構造体です。
type Cat struct {
    Name string
}
// Human型のSpeakメソッドの実装です。
func (h Human) Speak() string {
    return h.Name + "が話しています"
}
// Cat型のSpeakメソッドの実装です。
func (c Cat) Speak() string {
    return c.Name + "が鳴いています"
}
func main() {
    // Speakerインターフェースを実装する型のスライスです。
    speakers := []Speaker{
        Human{Name: "太郎"},
        Cat{Name: "ミケ"},
    }
    // 各要素のSpeakメソッドを呼び出して結果を表示します。
    for _, speaker := range speakers {
        fmt.Println(speaker.Speak())
    }
}

太郎が話しています
ミケが鳴いています

package main
import (
    "fmt"
    "time"
)
// fetchDataは疑似的にデータを取得する関数です。
func fetchData(task string, ch chan string) {
    // 疑似的な待機時間を設け、データの取得を模倣します。
    time.Sleep(300 * time.Millisecond)
    ch <- "データ: " + task
}
func main() {
    // 複数のタスクから結果を受け取るためのchannelを作成します。
    resultChannel := make(chan string, 3)
    // 複数のgoroutineを起動して並行にデータを取得します。
    tasks := []string{"タスクA", "タスクB", "タスクC"}
    for _, task := range tasks {
        go fetchData(task, resultChannel)
    }
    // 各goroutineから送信された結果を受け取り、表示します。
    for i := 0; i < len(tasks); i++ {
        result := <-resultChannel
        fmt.Println(result)
    }
}

データ: タスクA
データ: タスクB
データ: タスクC

package main
import (
    "errors"
    "fmt"
)
// divideは2つの整数を割る関数です。
// divisorが0の場合はエラーを返します。
func divide(numerator, divisor int) (int, error) {
    if divisor == 0 {
        return 0, errors.New("ゼロ除算はできません")
    }
    return numerator / divisor, nil
}
func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("エラー:", err)
    } else {
        fmt.Println("結果:", result)
    }
    result, err = divide(10, 0)
    if err != nil {
        fmt.Println("エラー:", err)
    } else {
        fmt.Println("結果:", result)
    }
}

結果: 5
エラー: ゼロ除算はできません

package main
import (
    "fmt"
    "strings"
)
// processDataは文字列処理の負荷を軽減する例です。
// ここではstrings.Builderを使用して効率よく文字列を連結しています。
func processData(items []string) string {
    var builder strings.Builder
    for _, item := range items {
        // 各項目を結合します。無駄なメモリアロケーションを削減します。
        builder.WriteString(item)
        builder.WriteString(" ")
    }
    return builder.String()
}
func main() {
    // 大量のデータを処理する場合、strings.Builderが有効です。
    data := []string{"高速", "かつ", "軽量", "なアプローチ"}
    result := processData(data)
    fmt.Println(result)
}

高速 かつ 軽量 なアプローチ