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

Go言語(Golang)における関数とメソッド

### 関数
関数は、独立して実行できるコードのブロックです。引数を受け取り、戻り値を返すことができます。

#### 例：
“`go
package main

import “fmt”

// 関数の定義
func add(a int, b int) int {
return a + b
}

func main() {
result := add(3, 5)
fmt.Println(result) // 出力: 8
}
“`

### メソッド
メソッドは、特定の型に関連付けられた関数のことです。メソッドは、レシーバーと呼ばれる特別な引数を持ち、その型のインスタンスに対して呼び出されます。

#### 例：
“`go
package main

import “fmt”

// 構造体の定義
type Rectangle struct {
width, height int
}

// メソッドの定義
func (r Rectangle) Area() int {
return r.width * r.height
}

func

Go言語(Golang)におけるレシーバがnilを受け取ることを利用した二本木の実装

“`go
package main

import (
“fmt”
)

type IntTree struct {
val int
left, right *IntTree
}

// valをitに挿入する
func (it *IntTree) Insert(val int) *IntTree {
if it == nil {
return &IntTree{val: val}
}
if val < it.val { it.left = it.left.Insert(val) } else if val > it.val {
it.right = it.right.Insert(val)
}
return it
}

// valがitに含まれるかをチェックし論理値を返す
func (it *IntTree) Contains(val int) bool {
switch {
case it == nil:
return false
case val < it.val: return it.left.Contains(

【Go言語】Goの概要・基本構文を押さえる

## はじめに
本記事では、Go言語を触ってみたい、基本的な構文を押さえたいと言った初学者に向けた記事となっております。
今回は、DockerでGoの環境構築を行うのでGo自体の環境構築は不要となっております。
エディタはVScodeを使用して進めていきます。

::: note warn
🙏 `docker`コマンドが使用できる状態にしておいてください。
:::

## Go言語はどのような開発言語なのか？
– Go言語はGoogleによって2009年にリリースされた、比較的新しいプログラミング言語の一つです。
– Goが正式名称ですが、それだけだと別の意味に捉えられてしまうこともあり、「Go言語」や「Golang」の通称で呼ばれています。

### Go言語には以下の特徴が挙げられます。
1\. コードを簡潔に書くことができる
2\. 高速で動作する
3\. 並行処理・並列処理に優れている
4\. 複雑なシステム構築に向いている
5\. 静的型付け言語である
etc….

具体的に一つずつ見ていきましょう。

>**コードを簡潔に書くことができる**

Go言語は、他

Go言語(Golang)におけるポインタレシーバと値レシーバ

“`go
package main //liststart1

import (
“fmt”
“time”
)

type Counter struct { // Counter型を定義
total int // 合計
lastUpdated time.Time // 最終更新時刻
}

func (c *Counter) Increment() { // ポインタレシーバ（cはポインタ）
c.total++
c.lastUpdated = time.Now()
}

func (c Counter) String() string { // 値レシーバ（cにはコピーが渡される）
return fmt.Sprintf(“合計: %d, 更新: %v”, c.total, c.lastUpdated)
}

func main() {
var c Counter
fmt.Println(c.String())
c.Increment() //「(&c).Increment()」と書かなくてもよい
fmt.Println(c.St

Go言語(Golang)におけるMapとSliceの値渡しに関する考察

“`go
func modMap(m map[int]string) { //liststart1
“`
– `modMap`という関数を定義しています。この関数は、整数をキー、文字列を値とするマップを受け取ります。

“`go
m[2] = “こんにちは”
“`
– マップ`m`のキー`2`に対して、値`”こんにちは”`を設定しています。

“`go
m[3] = “さようなら”
“`
– マップ`m`のキー`3`に対して、値`”さようなら”`を設定しています。

“`go
delete(m, 1)
“`
– マップ`m`からキー`1`を削除しています。

“`go
func modSlice(s []int) {
“`
– `modSlice`という関数を定義しています。この関数は、整数のスライスを受け取ります。

“`go
for k, v := range s {
“`
– スライス`s`の各要素に対して、インデックス`k`と値`v`を取得するための`for`ループを開始しています。

“`go
s[k] = v * 2
“`
–

Go言語におけるSlice、Map、make関数について

### Slice
Sliceは、Go言語における可変長の配列のようなデータ構造です。Sliceは、配列の部分を参照することができ、サイズを動的に変更することができます。

– **宣言と初期化**:
“`go
var s []int // nil Slice
s = []int{1, 2, 3} // 初期化
“`

– **長さと容量**:
Sliceには、長さ（要素数）と容量（Sliceが参照する配列の長さ）があり、`len()`と`cap()`関数で取得できます。
“`go
len(s) // Sliceの長さ
cap(s) // Sliceの容量
“`

– **追加**:
`append`関数を使って要素を追加できます。
“`go
s = append(s, 4) // 4を追加
“`

### Map
Mapは、キーと値のペアを保持するデータ構造で、ハッシュテーブルを基にしています。特定のキーに関連付けられた値を効率的に検索できます。

– **宣言と初期化**:
“`go
var m map[st

Go言語(Golang)における関数とクロージャ

#### 1. **関数の定義と利用**

“`go
func makeMult(base int) func(int) int {
return func(factor int) int {
return base * factor
}
}
“`
– **`makeMult`関数**:
– `makeMult`は引数として整数`base`を受け取ります。この関数は、`factor`という整数を引数に持つ無名関数（匿名関数）を返します。
– この無名関数は、`base`と`factor`の積を計算して返します。

#### 2. **クロージャの特性**

クロージャとは、関数とその関数が定義された環境（スコープ）を束ねたものです。このコードでは、`makeMult`が返す無名関数は、`base`という変数を「閉じ込めて」います。

– **クロージャの動作**:
– `makeMult`が呼ばれると、新しい無名関数が生成され、`base`の値がその関数に保存されます。
– この無名関数は、`makeMult`のスコープを超えても

Go言語(Golang)におけるsort.Sliceについて

### `sort.Slice` の基本

`sort.Slice` は、Goの標準ライブラリ `sort` パッケージに含まれる関数で、スライスを特定の条件に基づいてソートするために使います。スライスと比較関数を引数に取り、スライスの要素をその条件に従って並べ替えます。

### コード

“`go
sort.Slice(people, func(i int, j int) bool {
return people[i].LastName < people[j].LastName }) ``` #### 1. `sort.Slice(people, ...)` - **people**: ソート対象のスライスです。この場合、`Person` 構造体のスライスです。 - `sort.Slice` は、`people` スライスの順序を変更します。 #### 2. `func(i int, j int) bool { ... }` - **比較関数**: ソートの基準を定義する無名関数です。 - **引数 `i` と `j`**: スライス内の要素のインデックスを表します

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