List of Map [text.Baldanders.info]

Go 1.21.0 がリリースされた

2023-08-09T04:58:32+00:00

予定通り8月に Go 1.21.0 がリリースされた。

お気づきだろうか。今回のバージョン番号は 1.21 ではなく 1.21.0 なのですよ。これからは2月8月の初期リリースでも後ろにちゃんと 1.xx.0 って付けるんだってさ。これで Go の機械的なバージョン管理がしやすくなると思う。

Windows 7, 8, Server 2008, Server 2012 サポート終了のお知らせ

1.21 からは Windows 10 および Windows Server 2016 が最低要件となる。それより前の Windows バージョンに対応するには 1.20 系が必要。それでも2024年2月でサポートが終わるんだよな。

log/slog パッケージ

個人的に最大のトピックはこれ。 log/slog 構造化ログパッケージが追加されたこと。これでサードパーティの logger も log/slog パッケージの下に統合されることを期待したい。

ログなんて「詳細」ですよ。偉い人には分からんのです。

min/max 組み込み関数

多分，他の言語の人には「今までなかったんかい！」ってツッコまれるんだろうなぁ。マジでなかったんスよ。つか，いわゆる Generics が導入されてようやく実現したというか。

slices, maps, cmp パッケージ

slices, maps, cmp 各パッケージの追加も Generics 導入の恩恵だよね。何せ，今までは配列要素の反転（reverse）でさえ自前で

func reverse(s []int) {
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }
}

プログラミング言語Goより

てな感じに書いてたんだぜ。クールだろ（笑）

こうやって Go の標準ライブラリのイケてないところが徐々に解消されていくといいねぇ。 math/rand/v2 のプロポーザルとか見てても，着々と Go 2 に進んでる気がする。

例によって…

Ubuntu の APT で管理している Go コンパイラは古いので，ダウンロードページからバイナリ（go1.21.0.linux-amd64.tar.gz）を取ってきてインストールすることを強く推奨する。以下は完全手動での作業例。

$ cd /usr/local/src
$ sudo curl -L "https://go.dev/dl/go1.21.0.linux-amd64.tar.gz" -O
$ cd ..
$ sudo unlink go # 以前の Go が入っている場合
$ sudo tar xvf src/go1.21.0.linux-amd64.tar.gz
$ sudo mv go go1.21.0
$ sudo ln -s go1.21.0 go
$ go version # /usr/local/go/bin にパスが通っている場合
go version go1.21.0 linux/amd64

Windows は Scoop 経由で OK

複数バージョンの Go コンパイラを扱いたい場合は

$ go install golang.org/dl/go1.21.0@latest
$ go1.21.0 download
$ go1.21.0 version
go version go1.21.0 linux/amd64

てな感じで導入できる。

アップデートは計画的に。

ブックマーク

（随時追加予定）

公式の構造化 Logger (になるかもしれない) slog パッケージ

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

著者のひとりは（あの「バイブル」とも呼ばれる）通称 “K&R” の K のほうである。この本は Go 言語の教科書と言ってもいいだろう。と思ったら絶版状態らしい（2025-01 現在）。復刊を望む！

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

初めてのGo言語 ―他言語プログラマーのためのイディオマティックGo実践ガイド: Jon Bodner (著), 武舎広幸 (翻訳); オライリージャパン 2022-09-26; 単行本（ソフトカバー）; 4814400047 (ASIN), 9784814400041 (EAN), 4814400047 (ISBN); 評価

2021年に出た “Learning Go” の邦訳版。私は版元で PDF 版を購入。 Go 特有の語法（idiom）を切り口として Go の機能やパッケージを解説している。 Go 1.19 対応。

reviewed by Spiegel on 2022-10-11 (powered by PA-APIv5)

実用 Go言語 ―システム開発の現場で知っておきたいアドバイス: 渋川よしき (著), 辻大志郎 (著), 真野隼記 (著); オライリージャパン 2022-04-22; 単行本（ソフトカバー）; 4873119693 (ASIN), 9784873119694 (EAN), 4873119693 (ISBN); 評価

版元のデジタル版を購入。 Go で躓きやすい点を解説していくのが最初の動機らしい。「◯◯するには」を調べる際にこの本を調べるといいかも。

reviewed by Spiegel on 2022-10-26 (powered by PA-APIv5)

Go言語による並行処理: Katherine Cox-Buday (著), 山口能迪 (翻訳); オライリージャパン 2018-10-26; 単行本（ソフトカバー）; 4873118468 (ASIN), 9784873118468 (EAN), 4873118468 (ISBN); 評価

Eブック版もある。感想はこちら。 Go 言語で並行処理を書くならこの本は必読書になるだろう。

reviewed by Spiegel on 2020-01-13 (powered by PA-APIv5)

Go言語による分散サービス ―信頼性、拡張性、保守性の高いシステムの構築: Travis Jeffery (著), 柴田芳樹 (翻訳); オライリージャパン 2022-08-03; 単行本（ソフトカバー）; 4873119979 (ASIN), 9784873119977 (EAN), 4873119979 (ISBN); 評価

版元でデジタル版を購入。読書会の課題図書。ハンズオンぽい構成でコードがたくさん書かれているのがよい。

reviewed by Spiegel on 2022-08-03 (powered by PA-APIv5)

Goならわかるシステムプログラミング第2版: 渋川よしき (著), ごっちん (イラスト); ラムダノート 2022-03-23; 単行本（ソフトカバー）; 4908686122 (ASIN), 9784908686122 (EAN), 4908686122 (ISBN); 評価

第1版はとてもためになる内容だったので第2版も PDF 版で確保しておく。

reviewed by Spiegel on 2022-10-08 (powered by PA-APIv5)

デベロッパーゴースーパーゴラン Tシャツ: Geek Go Super Golang Tees; ウェア&シューズ; B09C2XBC2F (ASIN); 評価

ついカッとなってポチった。反省はしない

reviewed by Spiegel on 2022-04-10 (powered by PA-APIv5)

特殊形式による式評価について

2021-03-04T10:27:13+00:00

元ネタが Zenn の記事だし小ネタだし，どちらで書こうか悩んだが，今まで書いたことがない切り口な気がするので，こっち側で。

いきなりだが，以下のコードを起点に話を始めよう。

package main

import "fmt"

func main() {
    ageMap := map[string]uint{
        "Alice": 18,
        "Teles": 20,
    }
    fmt.Println(ageMap["Alice"])
    // Output
    // 18
}

このコードをみて分かるように，インデックス式 ageMap[x] の評価結果は uint 型になっている（インデックス値が存在しない場合はゼロ値がセットされる）。まぁ，当たり前だよね。

ところが ageMap[x] の評価結果を (uint, bool) の組（tuple）で受けることもできるのだ¹。これによってコードを

package main

import "fmt"

func main() {
    ageMap := map[string]uint{
        "Alice": 18,
        "Teles": 20,
    }
    if age, ok := ageMap["Selene"]; ok {
        fmt.Println(age)
    } else {
        fmt.Println("unknown")
    }
    // Output
    // unknown
}

と書き換えることでき， ageMap[x] の評価に失敗した際の挙動を記述できる。 Go の言語仕様では，これを「特殊形式（special form）」と呼んでいる（日本語が怪しいのはご容赦）。

言語仕様を眺めてみると，この特殊形式が適用可能なのは以下の3つのみのようだ。

#	Expressions	Normal Form	Special Form
1	Index Expression on Map	`foo := bar[x]`	`foo, ok := bar[x]`
2	Type Assertion	`foo := bar.(T)`	`foo, ok := bar.(T)`
3	Receive Expression	`foo := <-ch`	`foo, ok := <-ch`

最初のはインデックス値 x が map にない場合に false になる。 2番目は型 T でのアサーションに失敗した場合に（panic を吐くことなく） false になる。最後のはチャネル ch が閉じている場合に false になる。

他の式評価や関数の返り値ではこのようなことはできない。たとえば slice のインデックス式評価に特殊形式はない。インデックス値が範囲外なら単に panic が投げられるだけだ。

実は，特殊形式が上の3つの式評価でしか適用されないというのが分からなくて「どうして普通の関数の返り値とかではできないんだろう」とひとしきり悩んだことがあったのだった。言語仕様を読めっての（笑）

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

厳密には，特殊形式 (T, bool) の2要素目は型付けなしの真偽値（untyped boolean）に評価される。「型付けなし（untyped）」というのは Go 特有の概念だそうで，具体的な型が決定される前の状態を指す。たとえば，定数 math.Pi は10進数64桁の小数点数で定義されている。型付けなし定数については『プログラミング言語Go』の3.6.2章にも解説がある。 ↩︎

Map は連想配列ではなく連想配列への「参照」である

2019-06-07T14:07:39+00:00

今回は小ネタで。つか，だいぶフワッとした話になるので，その辺は割引いて読んでいただけるとありがたい。

いやね。

Goのスコープに苦しんだ事例集 - Qiita

の「事例その１」で

type hogehoge map[string]string

func (h *hogehoge) Seter(p string) {
    h = &hogehoge{
        "key": p,
    }
}

func main() {
    var f hogehoge
    f.Seter("ddd")

    fmt.Println(f) // <- nil
}

というコードを書いておられて，言わんとすることは分かるけど事例に map を使うのは混乱を助長しないかなぁ，と思ってしまったのだ。そこでこの記事では主に map の振る舞いにピントを合わせて説明していこう。

Map は連想配列ではなく連想配列への「参照」である

のっけからぶっちゃけるが，要するにそういうことである。もう少し厳密に言うと「Map は連想配列への「参照」のように振る舞う」といったところか。

これを端的に表すコードがこれ。

package main

import "fmt"

type KeyValues map[string]string

func main() {
	kv := KeyValues{"foo": "bar"}
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
}

これを実行すると

0x40c128: 0x43e260: map[foo:bar]

などと表示される。

最初の値がインスタンス kv のポインタ値，次の値が kv が参照する連想配列のポインタ値，最後が kv の内容と考えれば分かりやすいだろう。

Go 言語において関数の引数は「値渡し」なので…

型 KeyValues にひとつ関数を追加してみよう。

package main

import "fmt"

type KeyValues map[string]string

func (kv KeyValues) Set(k, v string) {
	kv[k] = v
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
}

func main() {
	kv := KeyValues{}
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
	kv.Set("foo", "bar")
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
}

これを実行すると

0x40c128: 0x43e260: map[]
0x40c138: 0x43e260: map[foo:bar]
0x40c128: 0x43e260: map[foo:bar]

となる。

ポイントは2行目で main() 関数内のインスタンス kv と KeyValues.Set() 関数のメソッド・レシーバの kv は異なるポインタ値になっているので異なるインスタンスだと分かるが，参照している連想配列（へのポインタ）は同一である。

もっと簡単なコードで示そうか。

package main

import "fmt"

type KeyValues map[string]string

func main() {
	kv := KeyValues{"foo": "bar"}
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
	cpy := KeyValues{}
	fmt.Printf("%p: %p: %v\n", &cpy, cpy, cpy)
	cpy = kv
	fmt.Printf("%p: %p: %v\n", &cpy, cpy, cpy)
}

これを実行すると

0x40c128: 0x43e260: map[foo:bar]
0x40c148: 0x43e2a0: map[]
0x40c148: 0x43e260: map[foo:bar]

となる。つまり map は連想配列への参照なので，連想配列そのものは宣言構文（:=）や代入構文（=）では複製できない，ということである¹。

それでもポインタは「参照」ではない

じゃあ，先ほどの KeyValues.Set() 関数のメソッド・レシーバをポインタ型にするとどうなるか，やってみよう。

package main

import "fmt"

type KeyValues map[string]string

func (kv *KeyValues) Set(k, v string) {
	(*kv)[k] = v
	fmt.Printf("%p: %p: %v\n", kv, *kv, *kv)
}

func main() {
	kv := KeyValues{}
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
	kv.Set("foo", "bar")
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
}

これを実行すると

0x40c128: 0x43e260: map[]
0x40c128: 0x43e260: map[foo:bar]
0x40c128: 0x43e260: map[foo:bar]

となる。

main() 内のインスタンス kv はポインタ型ではないが KeyValues.Set() 関数呼び出し時に暗黙的な変換が行われる。このため KeyValues.Set() 関数のメソッド・レシーバの kv は main() 内のインスタンス kv と同一のインスタンスになるわけだ。

では調子に乗ってこんな関数を作ってみよう。

func (kv *KeyValues) Initialize(k, v string) {
	kv = &KeyValues{k: v}
}

KeyValues.Initialize() 関数のメソッド・レシーバは呼び出し元のインスタンスと同一なんだから，これで初期化できるんじゃね？というわけだ。

プログラム全体はこんな感じ。これでようやく最初に紹介したコードにほぼ近い形になっただろう。

package main

import "fmt"

type KeyValues map[string]string

func (kv *KeyValues) Initialize(k, v string) {
	kv = &KeyValues{k: v}
	fmt.Printf("%p: %p: %v\n", kv, *kv, *kv)
}

func main() {
	kv := KeyValues{}
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
	kv.Initialize("foo", "bar")
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
}

まぁ動かしてみよう（笑）

0x40c128: 0x43e260: map[]
0x40c138: 0x43e2a0: map[foo:bar]
0x40c128: 0x43e260: map[]

ちょっと考えれば分かるのだが， KeyValues.Initialize() 関数のメソッド・レシーバに渡されるのはポインタ「値」なので，それを関数内で上書きしたところで呼び出し元の main() 関数には全く影響ないのである。

これが「Go 言語に『参照』は存在しない」ということの意味である。いかに参照っぽく振る舞っていようとも Go 言語でやり取りできるのはあくまでも「値」であり，その「値」が何を指しているかを考えながらコードを書いていく必要がある。

たとえば先ほどの KeyValues.Initialize() 関数を以下のように書き換えればまた挙動が変わる。

package main

import "fmt"

type KeyValues map[string]string

func (kv * KeyValues) Initialize(k, v string) {
	* kv = KeyValues{k: v}
	fmt.Printf("%p: %p: %v\n", kv, * kv, * kv)
}

func main() {
	kv := KeyValues{}
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
	kv.Initialize("foo", "bar")
	fmt.Printf("%p: %p: %v\n", &kv, kv, kv)
}

これを実行すると

0x40c128: 0x43e260: map[]
0x40c128: 0x43e2a0: map[foo:bar]
0x40c128: 0x43e2a0: map[foo:bar]

となる。なにがどう違うのか考えてみよう。ここまでくれば簡単だよね（笑）

ブックマーク

Map の話

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

Go 言語においては宣言や代入は式（expression）ではなく構文（statement）であり := や = は演算子ではなく構文を構成する（var とかと同じ）トークンに過ぎない。ちなみに ++ や -- も演算子ではなく代入構文のトークンである。 ↩︎

CSV/TSV データの読み書き

2018-10-13T20:41:02+00:00

今回は小ネタ。以下の記事を見て，思いつきで書いてみる。

tsvファイルの入出力を簡単にする技

「Python ならこんなに簡単に書けるのに Go 言語で書いたらワケワカメだよ」という，まぁよくある DIS り記事なのだが，関数型言語に慣れている人から見ると Go 言語が標準で提供しているコンテナ操作のアレコレはまだるっこしい感じに見えると思う。

特に配列や連想配列については zip/unzip や map のような標準的で気の利いた高階関数は用意されておらず，頑張って汎用パッケージを作ってみたところで実用的なパフォーマンスが得られずに打ち捨てられてしまうのがオチのようである。

リンク先の例にしても，結局 Go 言語では for 文で回していかざるを得ないのだから連想配列に格納するという発想自体を捨ててしまったほうが得策である。

というわけで，手遊びで書いてみた。

GitHub - spiegel-im-spiegel/csvtable: Demonstration for CSV/TSV Access

CSV/TSV は要するに行・列の2次元配列なんだから，以下のクラスを作って連想配列ではなく普通の配列で管理する。

//CsvTable is CSV/TSV table class
type CsvTable struct {
    header []string
    col    map[string]int
    body   [][]string
}

その上でデータの読み込み時にヘッダの列名とカラム位置の関係を col フィールドに保持ってしまえばいいのである。

//New returns new CsvTable instance
func New(r *csv.Reader) (*CsvTable, error) {
    ct := &CsvTable{}
    err := ct.readAll(r)
    return ct, err
}

func (ct *CsvTable) readAll(r *csv.Reader) error {
    if ct == nil {
        ct = &CsvTable{}
    }
    ct.col = map[string]int{}

    dt, err := r.ReadAll()
    if err != nil {
        return err
    }
    l := len(dt)
    if l > 0 {
        ct.header = dt[0]
        for i, e := range ct.header {
            ct.col[e] = i
        }

        if l > 1 {
            ct.body = dt[1:]
        }
    }
    return nil
}

main 側は以下のようになる。

package main

import (
    "encoding/csv"
    "flag"
    "fmt"
    "io"
    "os"
    "strings"

    "github.com/spiegel-im-spiegel/csvtable"
)

func main() {
    flag.Parse()
    if flag.NArg() > 1 {
        fmt.Fprintln(os.Stderr, os.ErrInvalid)
        return
    }
    var r io.Reader
    if flag.NArg() == 0 {
        r = os.Stdin
    } else {
        f, err := os.Open(flag.Arg(0)) //maybe file path
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
            return
        }
        defer f.Close()
        r = f
    }

    cr := csv.NewReader(r)
    cr.Comma = '\t'
    cr.LazyQuotes = true       // a quote may appear in an unquoted field and a non-doubled quote may appear in a quoted field.
    cr.TrimLeadingSpace = true // leading white space in a field is ignored.

    ct, err := csvtable.New(cr)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //fmt.Println("cols :", ct.Cols())
    //fmt.Println("rows :", ct.Rows())
    w := csv.NewWriter(os.Stdout)
    w.Comma = cr.Comma
    //w.UseCRLF = true
    //header, body := ct.OutputAll()
    header, body := ct.Output(strings.Split("city/temperature", "/"))
    w.Write(header)
    w.WriteAll(body)
}

念の為このパッケージの欠点を挙げておくと， CSV/TSV ファイルの内容の総てを一旦メモリ内に読み込んでいるため，巨大データを扱えないという問題がある。実際問題として CSV/TSV データは数万行から数十万行の規模になることもザラにあるため，このままでは全く実用に耐えられないだろう。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

Map の話

2018-02-07T12:03:54+00:00

今回も覚え書き用の小ネタ。

map による連想配列の定義と基本操作

まず， map を使って以下の連想配列を考える。

type platnets map[string]float64

p := platnets{
    "Mercury": 0.055,
    "Venus":   0.815,
    "Earth":   1.0,
}

この連想配列の各要素を操作する記述は以下のような感じになる。

package main

import (
    "fmt"
)

type platnets map[string]float64

func main() {
    p := platnets{
        "Mercury": 0.055,
        "Venus":   0.815,
        "Earth":   1.0,
    }

    if v, ok := p["Mars"]; ok {
        fmt.Println("Mars =", v)
    } else {
        fmt.Println("Mars is not exist.")
    }

    p["Mars"] = 0.107 //add or set
    if v, ok := p["Mars"]; ok {
        fmt.Println("Mars =", v)
    } else {
        fmt.Println("Mars is not exist.")
    }

    delete(p, "Mars")
    if v, ok := p["Mars"]; ok {
        fmt.Println("Mars =", v)
    } else {
        fmt.Println("Mars is not exist.")
    }
}

このコードの実行結果は以下の通り。

Mars is not exist.
Mars = 0.107
Mars is not exist.

この連想配列の要素を全て取り出す。これは for range 構文を使ってこんな感じに記述する。

package main

import "fmt"

type platnets map[string]float64

func main() {
    p := platnets{
        "Mercury": 0.055,
        "Venus":   0.815,
        "Earth":   1.0,
    }
    for k, v := range p {
        fmt.Println(k, v)
    }
}

結果は以下の通り。

Mercury 0.055
Venus 0.815
Earth 1

ちなみに for range 構文で map を使う場合，取り出しの順番は不定になる¹。例えば，アルファベット順に取り出したければ以下のようにキーをソートした配列を用意する。

package main

import (
    "fmt"
    "sort"
    "strings"
)

type platnets map[string]float64

func main() {
    p := platnets{
        "Mercury": 0.055,
        "Venus":   0.815,
        "Earth":   1.0,
    }

    keys := []string{}
    for k, _ := range p {
        keys = append(keys, k)
    }
    sort.Slice(keys, func(i, j int) bool {
        return strings.Compare(keys[i], keys[j]) < 0
    })
    for _ , k := range keys {
        fmt.Println(k, p[k])
    }
}

結果は以下の通り

Earth 1
Mercury 0.055
Venus 0.815

map は連想配列を参照するオブジェクトである

map は連想配列への参照を属性として持つオブジェクトである。したがって map インスタンスを引数として渡した場合は見かけ上「参照渡し」として機能する。

package main

import "fmt"

type platnets map[string]float64

func (p platnets) print() {
    for k, v := range p {
        fmt.Println(k, v)
    }
}

func add(p platnets, k string, v float64) {
    p[k] = v
}

func main() {
    p := platnets{
        "Mercury": 0.055,
        "Venus":   0.815,
        "Earth":   1.0,
    }
    p.print()
    fmt.Println()

    add(p, "Mars", 0.107)
    p.print()
}

このコードの実行結果は以下の通り。

Mercury 0.055
Venus 0.815
Earth 1

Mercury 0.055
Venus 0.815
Earth 1
Mars 0.107

Nil に注意

当たり前の話ではあるが map では空の連想配列と nil では挙動が異なる。たとえば nil map に要素を追加しようとすると

package main

type platnets map[string]float64

func main() {
    var p platnets
    p["Mars"] = 0.107 //add or set
}

以下のように実行時 panic になる。

panic: assignment to entry in nil map

したがって有効な map インスタンスを宣言する場合は make() 関数で初期化するか nil 以外の初期値を与える必要がある。

package main

type platnets map[string]float64

func main() {
    p := platnets{}
    p["Mars"] = 0.107 //add or set
}

ちなみに nil map に対して len() 関数を使っても実行時 panic にならない²。

package main

import "fmt"

type platnets map[string]float64

func main() {
    var p platnets
    fmt.Println(len(p)) // 0
}

連想配列の複製

map 内の連想配列の複製を行う関数は用意されていない³ ため for range 構文で地道に処理する。

package main

import "fmt"

type platnets map[string]float64

func (p platnets) print() {
    for k, v := range p {
        fmt.Println(k, v)
    }
}

func (p platnets) copy() platnets {
    c := platnets{}
    for k, v := range p {
        c[k] = v
    }
    return c
}

func main() {
    p1 := platnets{
        "Mercury": 0.055,
        "Venus":   0.815,
        "Earth":   1.0,
    }

    p2 := p1.copy()
    p2["Mars"] = 0.107

    p1.print()
    fmt.Println()
    p2.print()
}

このコードの実行結果は以下の通り。

Mercury 0.055
Venus 0.815
Earth 1

Mercury 0.055
Venus 0.815
Earth 1
Mars 0.107

連想配列の比較

map インスタンス同士は == 演算子による比較ができない。以下のコードはコンパイルエラーになる⁴。

package main

import "fmt"

type platnets map[string]float64

func (p platnets) copy() platnets {
    c := platnets{}
    for k, v := range p {
        c[k] = v
    }
    return c
}

func main() {
    p1 := platnets{
        "Mercury": 0.055,
        "Venus":   0.815,
        "Earth":   1.0,
    }

    p2 := p1.copy()
    if p1 == p2 {
        fmt.Println("p1 == p2")
    } else {
        fmt.Println("p1 != p2")
    }
}

prog.go:23:8: invalid operation: p1 == p2 (map can only be compared to nil)

map が参照している連想配列の内容を比較したいのであれば reflect.DeepEqual() 関数が使える。

package main

import (
    "fmt"
    "reflect"
)

type platnets map[string]float64

func (p platnets) copy() platnets {
    c := platnets{}
    for k, v := range p {
        c[k] = v
    }
    return c
}

func main() {
    p1 := platnets{
        "Mercury": 0.055,
        "Venus":   0.815,
        "Earth":   1.0,
    }

    p2 := p1.copy()
    if reflect.DeepEqual(p1, p2) {
        fmt.Println("p1 == p2")
    } else {
        fmt.Println("p1 != p2")
    }
}

このコードの実行結果は以下の通り。

p1 == p2

map が参照している連想配列のインスタンスが同一であるかどうか調べるには reflect.ValueOf() 関数で値（＝連想配列）を取得し，そのポインタ値を == 演算子で比較する。

package main

import (
    "fmt"
    "reflect"
)

type platnets map[string]float64

func (p platnets) copy() platnets {
    c := platnets{}
    for k, v := range p {
        c[k] = v
    }
    return c
}

func main() {
    p1 := platnets{
        "Mercury": 0.055,
        "Venus":   0.815,
        "Earth":   1.0,
    }

    p2 := p1
    if reflect.ValueOf(p1).Pointer() == reflect.ValueOf(p2).Pointer() {
        fmt.Println("p1 == p2")
    } else {
        fmt.Println("p1 != p2")
    }

    p2 = p1.copy()
    if reflect.ValueOf(p1).Pointer() == reflect.ValueOf(p2).Pointer() {
        fmt.Println("p1 == p2")
    } else {
        fmt.Println("p1 != p2")
    }
}

このコードの実行結果は以下の通り。

p1 == p2
p1 != p2

【2023-08-10 追記】 maps 標準パッケージを使う

Go 1.21 から maps 標準パッケージが追加された。これは map の操作を Generics を使って定義したもので，たとえば map の複製や比較を行うメソッドは

// Clone returns a copy of m.  This is a shallow clone:
// the new keys and values are set using ordinary assignment.
func Clone[M ~map[K]V, K comparable, V any](m M) M {
    // Preserve nil in case it matters.
    if m == nil {
        return nil
    }
    return clone(m).(M)
}

// Equal reports whether two maps contain the same key/value pairs.
// Values are compared using ==.
func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
    if len(m1) != len(m2) {
        return false
    }
    for k, v1 := range m1 {
        if v2, ok := m2[k]; !ok || v1 != v2 {
            return false
        }
    }
    return true
}

といった感じに定義されている。これを使えば前節のコードは

package main

import (
	"fmt"
	"maps"
	"reflect"
)

type platnets map[string]float64

func main() {
	p1 := platnets{
		"Mercury": 0.055,
		"Venus":   0.815,
		"Earth":   1.0,
	}

	p2 := maps.Clone(p1)
	if reflect.ValueOf(p1).Pointer() == reflect.ValueOf(p2).Pointer() {
		fmt.Println("p1.Pointer == p2.Pointer")
	} else {
		fmt.Println("p1.Pointer != p2.Pointer")
	}
	if maps.Equal(p1, p2) {
		fmt.Println("p1 == p2")
	} else {
		fmt.Println("p1 != p2")
	}

	p2["mars"] = 0.107
	if maps.Equal(p1, p2) {
		fmt.Println("p1 == p2")
	} else {
		fmt.Println("p1 != p2")
	}
	// Output:
	// p1.Pointer != p2.Pointer
	// p1 == p2
	// p1 != p2
}

てな感じに書き直すことができる。 maps.Clone() 関数によって新たにコピーが生成されているのが確認できるだろう。また maps.Equal() 関数が連想配列の内容（値）を比較している点にも注目してほしい。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

言語仕様上定義されていないという意味ではなく，意図的に乱択されるらしい。 ↩︎
これは nil slice も同様で， len() 関数を使っても実行時 panic にならず 0 が返る。 ↩︎
代入構文では map インスタンスの複製ができるだけで，参照している連想配列は同じものになる。 ↩︎
&p1 == &p2 ならコンパイルエラーにはならないが，やってることは map インスタンスのポインタ値を比較しているだけである。 ↩︎