はじめてのGo言語 サンプル

arraySample.go

var a [5] int // a[0]~a[4]
var b [3] int {1, 2, 3}
var c [...] 

chanSample.go

//並行処理からの通知を受け取る
func sample20() {
	fmt.Println("開始")
	//チャネルの生成
	ch1 := make(chan int)
	ch2 := make(chan string)
	//終了用チャネル
	chend := make(chan struct{})

	//チャネルを送信するゴルーチン
	//ここでは、別関数に切り出さずに中で処理を行っている
	go func(chint chan<- int, chstr chan<- string, end chan<- struct{}) {
		for i := 0; i < 10; i++ {
			time.Sleep(1 * time.Second)
			// 偶数回はint型チャネル、奇数回はstring型チャネルを送信する
			if i%2 == 0 {
				fmt.Println("intチャネルへ送信")
				chint <- i
			} else {
				fmt.Println("文字列チャネルへ送信")
				chstr <- "test" + strconv.Itoa(i)
			}
		}
		close(end) // クローズして通知
	}(ch1, ch2, chend)
	//非同期処理なのでここまで一瞬で終了。下のループに入る
	// 受信用の無限ループ
	for {
		select {
		case val := <-ch1:
			fmt.Println("ch1から受信：", val)
		case str := <-ch2:
			fmt.Println("ch2から受信：", str)
		case <-chend:
			fmt.Println("終了")
			return
		}
	}
}

errorHandleSample.go

func myFunc() (result,error){
  //処理
  if isError {
    //fmt パッケージを使うと 0,fmt.Errorf("ERR: %s",msg) 
    return 0,errors.New("エラーメッセージ")
  }
}

fileReadSample.go

func main() {
  file, err := os.Open(`ファイルパス`)
  defer file.Close() // defer をつけると処理の最後に実行される
  sc := bufio.NewScanner(file) //Scanner構造体を利用
  for i := 1; sc.Scan(); i++ {
    if err := sc.Err(); err != nil {
      // エラー処理
      break
    }
  fmt.Printf("%4d行目: %s¥n", i, sc.Text())
  }
}

forSample.go

for i = 0 ; i < 5 ; i++ {
  // 処理
}

funcSample.go

func test1(name string) (msg string) {
   msg = name + "さん、こんにちは"
   return
}

goroutineSample.go

func main() {
  sample()
  go sample
}
func sample() {
  //処理
}

hashmapSample.go

	a := make(map[string]int)
	a["One"] = 1
	b := map[string]int{
		"One": 1, "Two": 2, "Three": 3,
  }
  v,ok := b["One"] // ok = true,v=1

httpServer.go

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"strings"
)

//サーバが保持するメモのリスト
var memos []string

func main() {
	fmt.Println(os.Getwd())
	//メモの初期化
	memos = make([]string, 0)
	//memosにアクセスが来た場合、showMemo関数を呼び出す
	http.HandleFunc("/memos", showMemo)
	//memos/addにアクセスが来た場合、addMemo関数を呼び出す
	http.HandleFunc("/memos/new", addMemo)
	//リスナを起動する
	http.ListenAndServe(":80", nil)
}

// memoへのアクセス時に応答する
func showMemo(w http.ResponseWriter, r *http.Request) {
	//index.htmlファイルを読み込み
	index, err := ioutil.ReadFile(`./index.html`)
	if err != nil {
		fmt.Print(err)
		return
	}
	//メモのリストから、表示用HTMLを生成
	memo := "<li>" + strings.Join(memos, "</li><li>") + "</li>"
	// HTML中の[[LIST_AREA]]をmemoのHTMLに置換
	ret := strings.Replace(string(index), "[[LIST_AREA]]", memo, 1)
	//ResponseWriterにHTMLを書き込む
	fmt.Fprintln(w, ret)

}

// memo/addへのアクセス時に応答する
func addMemo(w http.ResponseWriter, r *http.Request) {
	//POSTされた"memo"の値を受け取る
	receiveValue := r.FormValue("memo")
	//保持しているメモリストに追加する
	memos = append(memos, receiveValue)
	//memosにリダイレクトさせる
	http.Redirect(w, r, "/memos", 303)
}

hw.go

package main

import (
	"fmt"
)

func main() {
	fmt.Print("Hello World\n")
}

ifSample.go

if a := 1 ; a == 1 {
  // 処理
}

intSample.go

var (
	a, b = 10, 20
	c, d = 10.5, 20.5 //自動的にfloatと認識される
)

intSample_2.go

func sample02() {
	a := 10
	b, c := 10.5, 20.5
	fmt.Printf("%d %f %f", a, b, c)
}

jsonSample.go

type City struct {
  ID int
  Name string
  CountryCode string
  District string
  Population sql.NullInt64
}

recoverPanicSample.go

func recoverPanic() {
  defer func() {
    if err := recover(); err != nil {//復帰させる
      fmt.Println("recover:", err) //panic時の情報取得可能
    }
  }()
  panic("panic発生")
  //これ以下は実行されない
}

restfulServer.go

package main

func main() {
	//httpパッケージでは、エイリアスをパラメータにすると手間がかかる
	//muxパッケージを利用
	router := mux.NewRouter().StrictSlash(true)
	//ルータの設定
	router.HandleFunc("/countries", Countries)
	router.HandleFunc("/cities/{countrycode}", Cities)
	//リスナを起動
	log.Fatal(http.ListenAndServe(":8080", router))
}

//すでにmysqlとのコネクションは出来ている前提
//テーブル作成と定義も完了している前提
//実際には、データアクセスは別ファイルに切り出す
func Cities(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	countryCode := vars["countrycode"]
	//mysql接続
	db, err := sql.Open("mysql", "seplus:seplus@/world")
	if err != nil {
		panic(err.Error())
	}
	//gorpを利用し、Countryとデータのマッピングを楽にする
	dbmap := &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{}}
	defer db.Close()

	//受け取るための変数を宣言
	var list []City
	//戻り値を受け取る必要がないのでアンダースコアにしている
	_, err2 := dbmap.Select(&list, "SELECT * FROM city WHERE CountryCode = ?", countryCode)
	if err2 != nil {
		panic(err2.Error())
	}
	//構造体からjsonデータに変換
	jsonBytes, err := json.Marshal(list)

	fmt.Fprintln(w, string(jsonBytes))

}

sliceSample.go

a := [5]int{1, 2, 3, 4, 5}
b := make([]int, 3) //[0,0,0]
c := []int{1, 2, 3}

stringsSample.go

data := []string{"山田", "24歳", "男性"}
fmt.Println(strings.Join(data, ","))
// "山田,24歳,男性"

VariousORM.md

db.where("countrycode = ?", "?").Find(&countries)

// Laravel などのEloquent
App\Countries::where('countrycode', ?);

// Rails の ActiveRecord
Country.find_by countrycode: ?

waitGroupSample.go

//並行処理の全終了を待つ
func sample21() {
	// WaitGroup構造体を初期化
	wg := new(sync.WaitGroup)
	// 3つのゴルーチン（3タスク）を実行します
	for i := 0; i < 3; i++ {
		wg.Add(1) // WaitGroupの回数分Addする
		go syncProc(wg)
	}
	// wg.Addで追加したすべてゴルーチンが、Doneで終了通知されるまで待機
	fmt.Println(time.Now())
	wg.Wait()
	fmt.Println(time.Now())
}
func syncProc(wg *sync.WaitGroup) {
	//処理A～Cまで、時間のかかる処理
	fmt.Println("処理A")
	time.Sleep(1 * time.Second)
	fmt.Println("処理B")
	time.Sleep(1 * time.Second)
	fmt.Println("処理C")
	// このタスクが終了したことを通知する
	wg.Done()
}