Go関連のことを調べてみた

Go言語(Golang)のGroutineとChannelの基本

### ゴルーチン (Goroutine)

ゴルーチンは、軽量なスレッドのようなもので、Go言語では `go` キーワードを使用して定義します。ゴルーチンを使用することで、関数を非同期に実行することができます。以下のように基本的に使用します。

“`go
package main

import (
“fmt”
“time”
)

func sayHello() {
fmt.Println(“Hello, World!”)
}

func main() {
go sayHello() // ゴルーチンとして関数を非同期に実行
time.Sleep(1 * time.Second) // 他のゴルーチンが実行される時間を確保するためにスリープ
}
“`

上記の例では、`sayHello`関数がゴルーチンとして実行されるため、`main`関数は直ちに次の行に進みます。`time.Sleep`は、ゴルーチンが実行される時間を確保するために使われていますが、他の方法（チャネルを使った待機など）で同期をとることもできます。

### チャネル (C

ISUCONで学ぶGo private-isu環境構築編 alp,pprof,pt-query-digestの導入方法

# IsuconでGoの勉強をしてみる
今回初めてisuconに出ることになり、色々調べてみるとほとんどのチームがGoを使うことがわかった。初心者としては情報が多い方が良さそうなので使ったことはないがGoで挑戦することを決意。
どうやってGoを学ぼうか迷っていたが、Goの書き方やら環境構築やらを行うのがめんどうなので、いっそのことisuconの過去問を眺めながらGoについて学ぶことにした。
# 筆者のスペック
– 大学生
– バックエンドを中心に一年位インターン
– **Go未経験**
– Isucon未経験

# 環境構築
今回導入するツールは
– alp(nginxログ監視ツール)
– pt-query-digest
– pprof

まずは環境構築や、問題を解くためのツールの導入などをおこなう。
以下の記事を参考にしてmultipassで環境構築を行なった。
今回解くのはisuconの練習問題であるprivate-isu

https://github.com/catatsuy/private-isu/blob/master/manual.md

今回はgoで練習したいのでマニュ

Go言語の文字列を対象にしたイテレーションについての考察

“`go:main.go
package main

import “fmt”

func main() {
samples := []string{“hello”, “apple_π!”, “これは漢字文字列”} //liststart
for _, sample := range samples {
for i, r := range sample {
fmt.Println(i, r, string(r))
}
fmt.Println()
}
}
“`
**1. コードの解説**

1. スライスの定義:
“`go
samples := []string{“hello”, “apple_π!”, “これは漢字文字列”}
“`
– `[]string`は文字列のスライスを表します。
– `:=`は短縮変数宣言で、型推論を使用して変数を宣言と同時に初期化します。

2. 外部ループ:
“`go
for _, sample := range samples {
“`
– `range`キー

Go言語(Golang)のmapをrangeでループした際の出力についての考察

**１. ランダムされる例**

“`go:main.go
package main

import “fmt”

func main() {
m := map[string]int{ //liststart
“a”: 1,
“c”: 3,
“b”: 2,
}

for i := 0; i < 3; i++ { fmt.Println("ループ", i) for k, v := range m { fmt.Println(k, v) } } //listend } ``` 出力結果 ``` ループ 0 a 1 c 3 b 2 ループ 1 a 1 c 3 b 2 ループ 2 a 1 c 3 b 2 ``` **２. 昇順に出力される例** ```go:main.go package main import "fmt" func main() { m := map[string]int{ "a": 1, "c": 3, "b": 2, } for i := 0; i < 5; i++ { fmt.Println("

golandにて、goのsdkをダウンロードする方法

# 概要

golandにて、goのsdkを手軽にダウンロードする方法を記した。

ローカルのgoのversionをサクッと上げたいなぁと思って調べたら、思いの外情報がまとまっておらず、golandではとりあえず一瞬でできたのでメモとして残す。

# 結論

https://pleiades.io/help/go/configuring-goroot-and-gopath.html#download-go-sdk
これ。

“`
1. 設定を開き Go | GOROOT に移動します。

2. SDK の追加ボタン（the Add SDK icon）をクリックして、ダウンロードを選択します。

3. バージョンリストから SDK のバージョンを選択します。

4. ロケーションフィールドで、SDK のパスを指定します。ファイルブラウザーを使用するには、参照アイコン the Browse icon をクリックします。

5. 「OK」をクリックして「Go SDK のダウンロード」ダイアログを閉じます。

GOROOT ページで適用または OK をクリックすると、GoLand は GoS

Goのinternalディレクトリに関して理解する

## はじめに
Goのinternalパッケージについて学ぶ記事です。
下記記事を実際に動かすとどうなるんだろうと思い、試してみました！

https://qiita.com/tenntenn/items/d8db61720a5ce7fbdeb6

## ソースコード
参考記事と同様のディレクトリ構成

“`shell:ディレクトリ構成
~/go/internal_jikken$ tree
.
├── b
│ └── d
│ ├── d.go
│ └── internal
│ └── e
│ └── e.go — d.goからのみアクセス可能
├── c
│ └── c.go　– internal配下のe.goはアクセス不可能
└── go.mod

6 directories, 4 files
“`

### internalディレクトリ内のファイル
“`go:b/d/internal/e/e.go
package e

import “fmt”

func InternalFunc() {

Go言語(Golang)におけるスライスの 関数lenと関数cap

Go言語におけるスライスの `len` と `cap` の違いについて説明します。

### `len` と `cap` の違い

– **`len`**: スライスの現在の要素数を返します。これは、スライスに格納されている実際のデータの数を示します。
– **`cap`**: スライスが持つことのできる最大の要素数を返します。これは、スライスが内部的に保持している配列の容量を示します。

### スライスの動作

スライスは、配列のラッパーとして機能し、動的にサイズを変更できます。スライスの容量は、要素を追加する際に増加することがあります。具体的には、スライスの容量は以下のように変化します。

“`go
package main

import “fmt”

func main() {
var x []int
fmt.Println(x, len(x), cap(x)) // [] 0 0
x = append(x, 10)
fmt.Println(x, len(x), cap(x)) // [10] 1 1
x = append(x, 20)
fmt.Printl

質問サイトを作成してみた

## はじめに
初めましての人もそうでない人もこんにちは！

最近友人とお風呂に入る時は先にシャワーを浴びて湯船に浸かるか掛け湯だけして湯船に浸かるかで討論をしてきました！
皆さんはどちらが先ですか？私は掛け湯だけして湯船に入る派ですね！

さてそんな関係ないことは置いといて今回はGoとTypeScriptで質問サイトを作成していきたいと思います！

## 使用技術
**フロントエンド**
– React
– TypeScript

**バックエンド**
– Go
– Supabase

## DB構造

### `questions` テーブル

| カラム名 | データ型 | 説明 |
|———|———-|——————-|
| id | uuid | 主キー（UUID） |
| title | text | 質問のタイトル |
| contents| text | 質問の内容 |

### `comments` テーブル

| カラム名 |

【Go】3. 変数宣言

## 変数宣言

基本的には以下の形で変数の宣言が可能

“`Go
var a int = 1 //– ①

b := “Hello” //– ②
“`

## Goにおける前提

Goではprivateとpublicのような接頭語がなく、大文字から始まるものをpublic、小文字で始まるものをprivateとしている。

この規則は変数だけでなく、関数、構造体のフィールドなどにも適用される。

“`Go
var a int = 1 // private
var A int = 100 // public
“`

privateの変数は他のパッケージから参照ができないので注意すること。

利用していない変数が存在するとエラーになる。

“`Go
var Hoge string = “HOGE”
var Fuga string = “FUGA” // Fugaを宣言して利用していないのでエラーになる
fmt.Println(Hoge)
“`

Goのメモリを無駄に消費しないという思想からきているらしい。(不要なimport文があるとエラーになるのも同じ理由っぽいで

【Go】2. import

## import

“`Go
package main

import (
“encoding/json”
“net/http”

“github.com/gorilla/mux”
)

“`

import文はコード内で利用する依存関係を記述する。基本的にエディタであれば保管が効くので意識する必要はない。

goの成型が走ると、１番上のブロックにgo内部に存在する依存関係を、２番目のブロックにサードパーティー的な依存関係を記述してくれる。不要なimportが存在するとエラーになる。ここはJavaなんかと違うので注意。

## 1. 単一行でのインポート
複数のパッケージをインポートする際、通常は括弧 () を使ってまとめるが、1行でインポートすることもできる。

“`Go
import “fmt”
import “os”
“`

## 2. エイリアスを使ったインポート
import文では、パッケージにエイリアスを付けることができる。これにより、パッケージ名を短くしたり、名前の衝突を避けたりすることが可能。

“`Go
import (
f “fmt” //

【Go】1. Hello world

## 1. Hello world

とりあえず書いてみる。

“`Go
package main

import “fmt”

func main() {
fmt.Println(“Hello world”)
}

“`

#### 実行

“`
go run main.go
> Hello world
“`

Go言語(Golang)におけるgoroutineとheartbeat

“`go
package main

import (
“context”
“fmt”
“io”
“log”
“os”
“strings”
“time”
)

func main() {
file, err := os.Create(“log.txt”)
if err != nil {
log.Fatalln(err)
}
defer file.Close()
errorLogger := log.New(io.MultiWriter(file, os.Stderr), “ERROR: “, log.LstdFlags)
ctx, cancel := context.WithTimeout(context.Background(), 5100*time.Millisecond)
defer cancel()
const wdtTimeout = 800 * time.Millisecond
const beatInterval = 500 * time.Millisecond
heartbeat, v := task(ctx, beatInter

Go言語(Golang)のgoroutineの事例

“`go
package main

import (
“context”
“fmt”
“sync”
“time”
)

const bufSize = 5

func main() {
ch1 := make(chan int, bufSize)
ch2 := make(chan int, bufSize)
var wg sync.WaitGroup
ctx, cancel := context.WithTimeout(context.Background(), 180*time.Millisecond)
defer cancel()
wg.Add(3)
go countProducer(&wg, ch1, bufSize, 50)
go countProducer(&wg, ch2, bufSize, 500)
go countConsumer(ctx, &wg, ch1, ch2)
wg.Wait()
fmt.Println(“finish”)
}
func countProducer(wg *sync.WaitGroup, ch chan<- i

Go言語(Golang)における、goroutineとchannelの使い方の基本的な例

“`go
package main

import (
“fmt”
“sync”
)

func main() {
ch1 := make(chan int)
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println(<-ch1) }() ch1 <- 10 close(ch1) v, ok := <-ch1 fmt.Printf("%v %v\n", v, ok) wg.Wait() ch2 := make(chan int, 2) ch2 <- 1 ch2 <- 2 close(ch2) v, ok = <-ch2 fmt.Printf("%v %v\n", v, ok) v, ok = <-ch2 fmt.Printf("%v %v\n", v, ok) v, ok = <-ch2 fmt.Printf("%v %v\n", v, ok) } ``` このコードは、goroutineを使って非同期にデータを受信し、channelを

Go言語のクロージャーとシャドーイングの影響

Golangにおけるクロージャーは、関数が他の関数のスコープ内で定義され、その外部の変数にアクセスできる機能を指します。これにより、関数内で外部の変数を保持したり、状態を持たせたりすることが可能になります。

### クロージャーの基本
クロージャーは、以下のように定義されます。

“`go
package main

import “fmt”

func main() {
x := 10
increment := func() int {
x++
return x
}

fmt.Println(increment()) // 11
fmt.Println(increment()) // 12
}
“`

この例では、`increment`関数が`x`という外部変数にアクセスし、値をインクリメントしています。`increment`はクロージャーであり、`x`を「閉じ込めて」いるため、呼び出すたびに`x`の値が保持され、更新されます。

### シャドーイングの影響
シャドーイングは、同じ名前の変数が異なるスコー

関数型パラダイムへの招待 ~ dear Gophers. ~

# Introduction
関数という概念はGolangでも馴染みがあるし、**普通のプログラミング**と何が違うの？と感じる人は少なくないと思います。

でも、実はGolangのような所謂「手続型プログラミング」と「関数型プログラミング」は全く異なるパラダイムです。

関数型プログラミングを理解すると、プログラミングを別の角度から見ることができるようになり、視野がグッと広がります。

今日は、Gopherの皆さんに、関数型プログラミングの世界について紹介します。

※この記事では計算理論や圏論などの領域には触れません。また、わかりやすさを優先し、厳密ではない言葉の使い方をしている箇所がありますが、ご容赦ください。

—

# メンタリズムの違い
Golangは所謂、手続き型言語に該当します。
手続き型言語の元祖であるC言語は、アセンブリに変わるシステムプログラミングのための高水準言語として生まれました。
つまるところ、手続き型言語においてプログラムとは「コンピュータを制御するためのもの」というメンタリズムなわけです。

一方で、関数型パラダイムは代数学や計算理論の分野から生まれ

GoでOCR試してみた

ひょんなことからOCRについて気になったので簡易的なものを実装してみた。
オープンソースのtesseractというOCRエンジンがあり、今回はgo向けのラッパーgosseractを利用させてもらいました。
[otiai10/gosseract](https://github.com/otiai10/gosseract “gosseract”)

# 構成
* go
* echo
* react
* typescript
* docker
* tesseract
* gosseract

# Go
“`go:main.go
package main

import (
“fmt”
“io”
“net/http”
“os”
“strings”

“github.com/labstack/echo”
“github.com/labstack/echo/middleware”
“github.com/otiai10/gosseract/v2”
)

func main() {
e := echo.New()
e.Use(middleware.CORSWithConfig(

Goのメソッド・インターフェース

Goの学習を行った記録としてこの記事に残す。
この記事では Goのメソッドとインターフェースについてまとめていく。

## メソッド
Goでもユーザー定義の方に付随する関数を定義できる。
これを型メソッドあるいはメソッドと呼ぶ。
“`Go:メソッド
package main

import “fmt”

// 型Personを定義 //liststart1
type Person struct {
LastName string // 姓
FirstName string // 名
Age int // 年齢
} //listend1

// 型Personに付随するメソッドStringを定義（PersonにメソッドStringを付加） //liststart2
func (p Person) String() string { // 「(p Person)」がレシーバの指定
return fmt.Sprintf(“%s %s：年齢%d歳”, p.LastName, p.FirstName, p.Age)
} //listend2
“`
キーワードfuncとメソッ

Goのポインタ

Goの学習を行った記録としてこの記事に残す。
この記事では Goのポインタについてまとめていく。

## ポインタとは
ポインタとは、ある値が保存されているメモリ内の位置を表す変数。
変数の型が異なれば保存に使うメモリの量は異なるが、ポインタはどのような型を参照していてもサイズが同じ。メモリ内のデータが保存されている位置を（アドレス）を示す値だから。

ポインタのゼロ値はnil

nilはスライス、マップ、関数のゼロ値でもあるが、これらの型は全てポインタで実装されているから。
「＆」はアドレス演算子で、変数の前につけるとその変数のアドレスを返す。返された値はポインタ型の値となる。
「＊」は間接参照のための演算子。ポインタ型の変数の前につけると、そのポインタが参照するアドレスに保存されている値を返す。デリファレンスという。
nilのポインタを参照しようとするとパニックになるので必要ならnilかどうかチェックする必要がある。

ポインタ型の変数をvarで宣言するには、次のようにそのポインタが指す領域に保存される値の型の前に「＊」をつける。
“`Go:ポインタとは
x := 10
var

Goの関数

Goの学習を行った記録としてこの記事に残す。
この記事では Goでの関数についてまとめていく。

## 関数の宣言と呼び出し
関数の宣言は、キーワードfunc、関数名、引数、戻り値（返り値）の型の四つの部分から構成されている。
Goは静的型付け言語なので、引数の型の指定は必須。
関数が値を返すものであれば、returnがなくてはならない。
同じ型の引数を受け取るときは、型の指定をまとめることが出来る。
“`Go:関数宣言
func test(num1, num2 int) int {
return num1 + num2
}
“`

– **複数の戻り値**
関数が複数の戻り値を返す場合、戻り値の型を（int, int, error）のように示す。
関数内でreturnを使って複数の戻り値を返す時には、全てをカンマで区切って返す。
問題なく処理を完了したときは、エラー値としてnilを返す。errorは戻り値の最後に（あるいは唯一の戻り値として）返す習慣になっている。

– **名前付き戻り値**
Goでは関数から複数の値を返せるだけでなく、戻り値に名前を指定できる。
戻り値