type MyStruct struct {
    Value int
}
// 例：(m MyStruct)
func (m MyStruct) GetValue() int {
    return m.Value
}

myVar := MyStruct{Value: 42}
result := myVar.GetValue()

type MyStruct struct {
	Value int
}

func (m MyStruct) GetValue() int {
	return m.Value
}

// 値レシーバなので変更されない
func (m MyStruct) SetValue(newValue int) {
	m.Value = newValue
}

// ポインタレシーバなので変更される
func (m *MyStruct) SetValueP(newValue int) {
	m.Value = newValue
}
func main() {

	myVar := MyStruct{Value: 42}
	println("SET Before:", myVar.GetValue())
	myVar.SetValue(2) // 値は変わらない
	println("SetValue After:", myVar.GetValue())
	myVar.SetValueP(12345) // 値が更新される
	println("SetValueP After:", myVar.GetValue())
}

SET Before: 42
SetValue After: 42
SetValueP After: 12345

パッケージA
├── パッケージB
│   ├── パッケージD
│   └── internal
│       └── パッケージE // AやCからは参照できない
├── パッケージC
└── go.mod

func TestConcurrentStuff(t *testing.T) {
    // テスト関数内での同時実行数を制限
    t.Parallel()

    // テストのロジック
}

package main

import "fmt"

type MyInterface interface {
    MyMethod()
}

type MyStruct struct{}

func (ms MyStruct) MyMethod() {
    fmt.Println("MyMethod Call")
}

func main() {
    var myValue MyInterface
    myValue = MyStruct{}    // MyStruct型をMyInterface型に代入

    // インターフェースを介してメソッドを呼び出す
    myValue.MyMethod()
}

package main

import "fmt"

type MyInterface interface {
	MyMethod()
}

type MyInt int

func (mi MyInt) MyMethod() {
	// メソッドの実装
	fmt.Println("Hello, 世界")
}

func main() {
	var myValue MyInterface // MyInterface型の変数を宣言
	myValue = MyInt(0)      // MyInt型をMyInterface型に代入

	// インターフェースを介してメソッドを呼び出す
	myValue.MyMethod()
}

type Interface1 interface {
    Method1()
}

type Interface2 interface {
    Method2()
}

// Interface1 と Interface2 を埋め込む新しいインタフェース
type CombinedInterface interface {
    Interface1
    Interface2
}

package main

func main() {
        // 1. 
        defer func() {recover()}()

        // 2. 
        ch := make(chan struct{})

        go func() {
                // 4. 
                panic("PANIC")
                close(ch)
        }()

        // 3.
        <-ch
}

package main

import (
	"fmt"
	"io/fs"
)

func main() {
	if err := f(); err == nil {
		fmt.Printf("%T\n", err)
	} else {
		fmt.Println("err is not nil")
	}
}

func f() error {
	var err *fs.PathError
	return err
}

package main
import (
    "fmt"
    "unsafe"
)
type sample struct {
    a int
    b string
}
func main() {
    s := &sample{a: 1, b: "test"}
    
   //構造体 s のフィールド b のアドレスの取得
    p := unsafe.Pointer(uintptr(unsafe.Pointer(s)) + unsafe.Offsetof(s.b))
    
    //文字列ポインタに型キャストし、その値を表示する。
    fmt.Println(*(*string)(p))
}

test

package main

import (
	"fmt"
	"unsafe"
)

type sample struct {
	a int
	b string
}

func main() {
	s := &sample{
		a: 1,
		b: "test",
	}
	//uintptrとしてアドレスを取得
	startAddress := uintptr(unsafe.Pointer(s))
	fmt.Printf("Start Address of s: %d\n", startAddress)
}

Start Address of s: 824633976600

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	// キャンセル用のコンテキストを作成
	ctx, cancel := context.WithCancel(context.Background())

	// ゴールーチン内でコンテキストを使用
	go process(ctx)

	// 3秒後にキャンセル
	time.Sleep(3 * time.Second)

	// ゴールーチンをキャンセル
	cancel()

	// メインゴルーチンが終了する前に待機
	time.Sleep(1 * time.Second)
}

func process(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println("ゴールーチンがキャンセルされました")
			return
		default:
			// 何らかの処理
			fmt.Println("ゴールーチン実行中...")
			time.Sleep(1 * time.Second)
		}
	}
}

// Intに依存したメソッド
func PrintInts(s []int) {
    for _, v := range s { fmt.Print(v) }
}
// Stringに依存したメソッド
func PrintStrings(s []string) {
    for _, v := range s { fmt.Print(v) }
}

// 型に依存しないメソッド
func Print[T any](s []T) {
    for _, v := range s { fmt.Print(v) }
}