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

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を使った初めての実務経験？の中で、たくさんの（自分にとって）新しい技術に触れるともに、エンジニアとしての未熟さを痛感することになりました….。

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

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

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

Go言語のプログラムの中でJavaSciptを実行する方法

# はじめに

TWSNMPシリーズを開発している時、Go言語で開発したプログラムの中でユーザーが入力した何等かのスクリプトを実行して結果をGo言語側に戻した場面がありました。
その時使ったottoというパッケージ

https://github.com/robertkrimen/otto

の紹介です。

# インストール

“`terminal
$ go get github.com/robertkrimen/otto/otto
“`

# サンプルプログラム

ottoのGitHUBのトップページにあるサンプルを、まとめて実行可能にしたものです。

“`go:main.go
package main

import (
“log”

“github.com/robertkrimen/otto”
)

func main() {
// JavaScript仮想マシンの作成
vm := otto.New()
// スクリプトの実行
vm.Run(`
abc = 2 + 2;
console.log(“The value of abc is ” + ab

ORMパッケージdbrとは? gormとの違いは？[Go][ORM]

# dbrとは?

dbrとは、GoのORMパッケージの1つです。

:::note
ORMとは
`Object Relational Mapper`の略称で、リレーショナルデーターベースにおける操作をオブジェクト指向の考え方で操作できるようにする技術のことです。
:::

GoでORMを利用すると、定義した構造体とデータベースを簡単に対応させることができ、その状態でデータベースの抽象的な操作をすることが可能になります。

https://github.com/gocraft/dbr

# 早速dbrを使ってみる。

今回、Dockerでmysqlのコンテナを立ち上げて使ってみようと思います。

使用するmysqlのファイルは以下のようになっています。

“`yml:docker-compose.yml
services:
db:
image: mysql:8.0
container_name: mysql_dbr
restart: always
environment:
MYSQL_ROOT_PASSWORD: root

Go言語でシンプルなWebアプリケーションを作る：ワークアウト記録アプリ


## はじめに

今回は、Go言語（Golang）を使用して、シンプルなワークアウト記録Webアプリケーションを作成してみました。この記事は、私がGo言語の基本を学ぶための備忘録として書いています。データベースにはPostgreSQLを使用し、Dockerを利用して環境を構築します。

## プロジェクト構造

まずは、プロジェクトの構造を見てみましょう：

“`
/my-go-workout-app
├── Dockerfile
├── docker-compose.yml
├── go.mod
├── go.sum
├── init.sql
├── main.go
├── handlers
│ └── records.go
│ └── down

GoのFunctional Options Patternのユースケースを実務から紹介する

## サマリ
– 実務においてFunctional Options Patternを活用できた例を紹介します
– 具体的には、構造体が階層構造になっている場合で、初期化時の子要素の構造体作成の制御に利用したケースを紹介します

## はじめに
Goを実務で使うようになって、学び始めてから1年以上経ちましたが、なかなかアウトプットができていなかったので初めて記事を書いてみました。

今回は、GoのFunctional Options Patternについて、実務で利用できたケースについて紹介できればと思います。

## Functional Options Patternとは？

Functional Options Patternは、Go言語でよく使われるデザインパターンの一つです。
構造体の初期化時に、特定のオプションフィールドを関数として渡すことにより、構造体の設定を行うものです。

このパターンを用いると、構造体の初期化時に多くの引数を渡す必要がある場合でも、可読性を損なわずにオプションを追加・管理することが可能になります。

今回は詳細の解説は行いませんが、以下の記事がシンプル

GoのbigCacheのサンプルコード

## リポジトリ

[https://github.com/allegro/bigcache](https://github.com/allegro/bigcache)

## Example(echo使用)

“`go
// キャッシュの設定
config := bigcache.Config{
// シャードの数（2のべき乗でなければならない）
Shards: 1024,
// エントリが削除されるタイムアウトの時間
LifeWindow: 10 * time.Minute,
// 期限切れのエントリを削除する間隔
CleanWindow: 30 * time.Second,
}

// キャッシュの初期化(アプリケーション実行時のみ行うmain.goやroute.goなど)
cache, err := bigcache.NewBigCache(config)
if err != nil {
e.Logger.Fatal(err)
}

// キャッシュお試しのルート
cacheGroup := publicGroup.Group(“/cache”)
cac

golang-migrateを使ってみた(アプリケーション編)

### ソースコード
“`go
package main

import (
“database/sql”
“fmt”
“log”

_ “github.com/lib/pq”
“github.com/golang-migrate/migrate/v4”
“github.com/golang-migrate/migrate/v4/database/postgres”
_ “github.com/golang-migrate/migrate/v4/source/file”
)
func main(){

// PostgreSQL に接続
db, err := sql.Open(“postgres”, “postgres://postgres:password@localhost:5432/dbname?sslmode=disable&search_path=test_schema”)
if err != nil {
log.Fatalf(“Failed to connect to the database:

Goでファイルを書き込むと書き込み先ファイルが消えているのに読み込める

## 症状
### 準備
以下のようなログラムを作成した．
“`go
package main

import (
“fmt”
“io”
“os”
“path/filepath”
)

func main() {
path := “~/.config/tilde-expan/hoge.txt”
write(path)
read(path)
}

func write(path string) {
dir := filepath.Dir(path) // ディレクトリが存在しない場合は作成する
if _, err := os.Stat(dir); os.IsNotExist(err) {
err = os.MkdirAll(dir, 0755)
}

file, _ := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
defer file.Close()

fmt.Fprintln(file, “test”)
}

func read(path string) {
file, _

gofmtについて

## gofmtについて

goに標準で搭載されているコード整形機能のこと。
`fmt.Println()`ばかり使っていたのでこの機能を知った時はとても便利な機能があるなと思いました。

### 例）hogehoge.goのコード
“`
package main

import “fmt”

const (
idKey = “id”
nameKey = “name”
runeKey = ‘a’
)

func main() {

for i := 0; i < 10; i++ { fmt.Println(i) if i == 5 { break } } t := 10 fmt.Println(t) fmt.Println(1 + 1, 2+2) fmt.Println("1 + 1 =", 1+1) fmt.Println("10 - 1", 10-1) fmt.Println("10 / 2", 10/2) fmt.Println("10 / 3", 10/3) fmt.Println("10.0

[Go] 構造体のKey/Value を出力する

“`go
package main

import (
“fmt”
“reflect”
)

type User struct {
ID string
Foo string
Bar int
pri string
Pub int
}

func main() {
user := User{“id1”, “foo”, 2, “skip me without panic”, 4}
fmt.Println(user.String())
//ID: id1
//Foo: foo
//Bar: 2
//Pub: 4
}

func (u User) String() string {
str := “”
fa := reflect.ValueOf(u)
for i := 0; i < fa.NumField(); i++ { if !fa.Field(i).CanInterface() { // skip private for avoid panic continue } str += fmt.Sprintf("%v: %v\n", fa.