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

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では関数から複数の値を返せるだけでなく、戻り値に名前を指定できる。
戻り値

Goの制御構造

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

## if
他の言語のifとほとんど変わらない。
Go言語のifでは条件を(…)で囲まない。
“`Go:if文package main //liststart

import (
“fmt”
“math/rand”
“time”
)

func main() {
rand.Seed(time.Now().UnixNano()) // シードの指定
n := rand.Intn(10) // 0以上10未満の整数を戻す
if n == 0 {
fmt.Println(“少し小さすぎます:”, n)
} else if n > 5 {
fmt.Println(“大きすぎます:”, n)
} else {
fmt.Println(“いい感じの数字です:”, n)
}
} //listend
“`

必要なときだけ変数を宣言して利用できる。
一群のif/elseが終わるとnは未定義なる。

“`Go:if文（変数宣言）
func main() {
rand.

Goの型の種類

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

## 基本型
Goの基本型は他の言語同様以下のものが挙げられる。
– 論理型
– 整数型
– 文字列型
– 浮動小数点数型

それぞれの型について詳しく見ていく。

#### 論理型
真偽値の値を持つ変数。tureまたはfalse。boolのゼロ値はfalse

#### 整数型
整数型のゼロ値は0
intとint32やint64では、代入・比較・演算は型変換をしない限りコンパイルエラーとなる。
整数リテラルはデフォルトでint型となる

演算について、整数の割り算の結果は整数となる。浮動小数点の結果がほしければ浮動小数点型に変換が必要。

#### 文字列型
文字列のゼロ値は””空文字列
runeリテラルのデフォルト型はrune
文字列リテラルの基本型はstring

文字列を参照しているときはint32ではなくruneを使用する

#### 浮動小数点数型
既存フォーマットとの互換性を気にしなくて良いのであれば、float64だけ使えば良い。
そもそも浮動小数点数を使うかの検討が必要で、

Go言語(Golang)の、変数のスコープとメモリアドレス

“`go
ok, result := true, “A”

fmt.Printf(“memory address of result: %p\n”, &result)
if ok {
result := “B”
fmt.Printf(“memory address of result: %p\n”, &result)
println(result)
} else {
result := “C”
println(result)
}

println(result)
“`

このGo言語のコードは、変数のスコープとメモリアドレスの取得に関する例です。

“`go
ok, result := true, “A”
fmt.Printf(“memory address of result: %p\n”, &result)
“`

1. **変数の初期化**:
– `ok` と `result` という2つの変数を同時に初期化しています。`ok` は `true`、`result` は `”A”` という文字列です。
– `:=` 演算子を使って

Go言語(Golang)のポインタとメモリアドレス

### 1. 変数の宣言とメモリアドレスの表示

“`go
var ui1 uint16
fmt.Printf(“memory address of ui1: %p\n”, &ui1)

var ui2 uint16
fmt.Printf(“memory address of ui2: %p\n”, &ui2)
“`

– `ui1`と`ui2`は、`uint16`型の変数です。
– `&ui1`のように「&」を使うことで、変数のメモリアドレスを取得できます。`%p`フォーマット指定子を使って、ポインタとして出力します。

### 2. ポインタの宣言と初期化

“`go
var p1 *uint16
fmt.Printf(“value of p1: %v\n”, p1)

p1 = &ui1
fmt.Printf(“value of p1: %v\n”, p1)
“`

– `p1`は`uint16`型のポインタです。初期状態では`nil`（何も指していない状態）です。
– `p1 = &ui1`によって、`ui1`のメモリアドレスを`p1`に代入します。これにより、`p1`

サイバーエージェントの夏インターンに参加してきた

# はじめに

　今回は今夏に参加した2社目のインターンについての振り返り記事を書きます。

　この度、株式会社サイバーエージェントの[**次世代トップエンジニア創出インターンシップ ACE**](https://www.cyberagent.co.jp/careers/students/event/detail/id=30024)に参加してきました。

　このインターンシップでは、プロダクトを0から開発する時にこれまであまり考えてこなかった設計周りの話や、Goを使った初めての実務経験？の中で、たくさんの（自分にとって）新しい技術に触れるともに、エンジニアとしての未熟さを痛感することになりました….。

　今回の記事では、インターン期間中に経験した内容を中心に、どこに苦戦したのか、何を学んだのか、今後の展望などについてまとめたいと思います。

## **なぜこの記事を書いたか**

– 自分自身、去年のインターン参加者の方の記事を読んで大いに参考にさせていただいたので、私も後に続く方々の情報源になるような記事を書きたかったから
– 改めてインターンを振り返るためのメモ的な位置付けにした