List of String [text.Baldanders.info]

バイト列の同値性（『プログラミング言語 Go』読書会より）

2020-10-03T10:27:34+00:00

以前 Discord で某エベントに参加したことがあったけど，やっぱオンラインイベントはしんどい。それでもメインで喋る人が決まってるから，今回は楽なほうだったかな。 Discord にしろ Zoom にしろ，オンラインでフリートーク・イベントはかなり難しいと思うのだが，みんなどうしてるんだろう。

閑話休題 (それはさておき) 。

今回，のっけから面白い話を聞いた。『プログラミング言語 Go』4.2章「スライス」に書かれている

配列と異なりスライスは比較可能ではありませんので，二つのスライスが同じ要素で構成されているかを検査するために == は使えません。標準ライブラリは二つのバイトスライス（[]byte）を比較するために高度に最適化された bytes.Equal 関数を提供しています。しかし…

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

という部分（強調は私がやりました）。実際にコードを見てみると

// Equal reports whether a and b
// are the same length and contain the same bytes.
// A nil argument is equivalent to an empty slice.
func Equal(a, b []byte) bool {
	// Neither cmd/compile nor gccgo allocates for these string conversions.
	return string(a) == string(b)
}

てなことになっている。で，「これのどこが『高度に最適化』なん？」という話があったらしい。

バージョンを遡ってみると 1.12.7 までは

// Equal returns a boolean reporting whether a and b
// are the same length and contain the same bytes.
// A nil argument is equivalent to an empty slice.
func Equal(a, b []byte) bool {
	return bytealg.Equal(a, b)
}

となっていた。ちなみに internal/bytealg は内部パッケージで，中身はほぼ（アーキテクチャ毎に）アセンブラで記述されている。実は Go 1.13 では string 周りが大幅に強化されていて，その辺の影響が出ているのかもしれない。

それなら，どの程度のパフォーマンスか気になるよね。というわけで，こんなコードを用意してみた¹。

package eq

import (
	"bytes"
	"fmt"
	"testing"
)

var (
	hello1  = "I could tell you my pass phrase, but then I would have to kill you."
	hello2  = "I could tell you my pass phrase, but then I would have to kill you."
	helloA1 = [67]byte{0x49, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x74, 0x65, 0x6c, 0x6c, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6d, 0x79, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x6b, 0x69, 0x6c, 0x6c, 0x20, 0x79, 0x6f, 0x75, 0x2e}
	helloA2 = [67]byte{0x49, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x74, 0x65, 0x6c, 0x6c, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6d, 0x79, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x6b, 0x69, 0x6c, 0x6c, 0x20, 0x79, 0x6f, 0x75, 0x2e}
	helloS1 = []byte{0x49, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x74, 0x65, 0x6c, 0x6c, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6d, 0x79, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x6b, 0x69, 0x6c, 0x6c, 0x20, 0x79, 0x6f, 0x75, 0x2e}
	helloS2 = []byte{0x49, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x74, 0x65, 0x6c, 0x6c, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6d, 0x79, 0x20, 0x70, 0x61, 0x73, 0x73, 0x20, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x6b, 0x69, 0x6c, 0x6c, 0x20, 0x79, 0x6f, 0x75, 0x2e}
)

func BenchmarkByteEqual1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if hello1 != hello2 {
			fmt.Printf("false")
		}
	}
}

func BenchmarkByteEqual2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if !bytes.Equal([]byte(hello1), []byte(hello2)) {
			fmt.Printf("false")
		}
	}
}

func BenchmarkByteEqual3(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if helloA1 != helloA2 {
			fmt.Printf("false")
		}
	}
}

func BenchmarkByteEqual4(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if string(helloA1[:]) != string(helloA2[:]) {
			fmt.Printf("false")
		}
	}
}

func BenchmarkByteEqual5(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if !bytes.Equal(helloA1[:], helloA2[:]) {
			fmt.Printf("false")
		}
	}
}

func BenchmarkByteEqual6(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if string(helloS1) != string(helloS2) {
			fmt.Printf("false")
		}
	}
}

func BenchmarkByteEqual7(b *testing.B) {
	for i := 0; i < b.N; i++ {
		if !bytes.Equal(helloS1, helloS2) {
			fmt.Printf("false")
		}
	}
}

hello1, hello2 は string 型，helloA1, helloA2 は byte 配列，helloS1, helloS2 は []byte 型で中身はみんな同じ。これらを使って同値性（equallity）をチェックするのだが，内訳はこんな感じ。

関数名	比較手順
`BenchmarkByteEqual1`	`string == string`
`BenchmarkByteEqual2`	`bytes.Equal([]byte(string), []byte(string))`
`BenchmarkByteEqual3`	`<byte array> == <byte array>`
`BenchmarkByteEqual4`	`string(<array>[:]) == string(<array>[:])`
`BenchmarkByteEqual5`	`bytes.Equal(<array>[:], <array>[:])`
`BenchmarkByteEqual6`	`string([]byte) == string([]byte)`
`BenchmarkByteEqual7`	`bytes.Equal([]byte, []byte)`

では，実際に動かしてみようか。

$ go test -bench ByteEqual -benchmem
goos: linux
goarch: amd64
pkg: sample
BenchmarkByteEqual1-4   	301173402	         4.04 ns/op	       0 B/op	       0 allocs/op
BenchmarkByteEqual2-4   	 8552673	       122 ns/op	     160 B/op	       2 allocs/op
BenchmarkByteEqual3-4   	182939372	         6.27 ns/op	       0 B/op	       0 allocs/op
BenchmarkByteEqual4-4   	191359716	         6.29 ns/op	       0 B/op	       0 allocs/op
BenchmarkByteEqual5-4   	191511163	         6.27 ns/op	       0 B/op	       0 allocs/op
BenchmarkByteEqual6-4   	168382664	         7.16 ns/op	       0 B/op	       0 allocs/op
BenchmarkByteEqual7-4   	167058468	         7.06 ns/op	       0 B/op	       0 allocs/op
PASS
ok  	sample	12.140s

分かりやすく表にしておく。ちなみに私の環境では 1ns 未満は誤差の範囲なのであしからず。

比較手順	処理時間 (ns/op)	Alloc 回数
`string == string`	4.04	0
`bytes.Equal([]byte(string), []byte(string))`	122.00	2
`<byte array> == <byte array>`	6.27	0
`string(<array>[:]) == string(array>[:])`	6.29	0
`bytes.Equal(array>[:], <array>[:])`	6.27	0
`string([]byte) == string([]byte)`	7.16	0
`bytes.Equal([]byte, []byte)`	7.06	0

string → []byte へのキャスト時にアロケーションが発生している点に注意。

つか string 同士の比較処理が速いな！配列と slice で若干差が出るのは仕方ないが，元が同じ型なら殆ど差がないようだ。まぁ，これなら確かに

func Equal(a, b []byte) bool { return string(a) == string(b) }

でもいっか，って気になるよな。

ブックマーク

参考図書

プログラミング言語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)

ちなみに “I could tell you my pass phrase, but then I would have to kill you.” という物騒なフレーズは Simson Garfinkel 氏の『PGP』に載っていたパスフレーズの事例である（笑） ↩︎

Rust の文字列操作（2）

2020-03-11T11:24:35+00:00

前回の続き。 Rust の文字列操作についてオベンキョ中です。

他の型の値を文字列に変換する

ある型が ToString トレイトを実装していれば to_string() メソッドを使って文字列に変換できる。整数や浮動小数点数などの基本型は ToString トレイトを実装している。以下のようにリテラル表現に対して直接 to_string() メソッドを起動することもできる。

fn main() {
    println!("{}", (123).to_string()); //Output: 123
    println!("{}", (1.23).to_string()); //Output: 1.23
    println!("{}", (true).to_string()); //Output: true
    println!("{}", ('あ').to_string()); //Output: あ
}

同じ基本型でもタプルや配列は ToString トレイトを実装していないため to_string() メソッドは使えない。

fn main() {
    println!("{}", ([1, 2, 3]).to_string()); //Error: no method named `to_string` found for type `[{integer}; 3]` in the current scope
}

変換する文字列を整形する

今までさんざん出てきたので今更だが， format! 等のマクロを使えば他の型の値を変換する際の文字列を整形できる。

マクロ名	機能
`format!`	文字列を整形して `String` として出力する
`print!`, `println!`	文字列を整形して標準出力に出力する
`write!`, `writeln!`	文字列を整形して指定したストリームに出力する
`panic!`	文字列を整形して panic 出力に付加する

たとえば，こんな感じ。

fn main() {
    println!("{{{} = {num:#04x} = {num:#010b}}}", num = 15); //Output: {15 = 0x0f = 0b00001111}
}

プレースホルダ {which:how} の中身の how の部分が C/C++ や Go の printf 文の書式（%d など）に相当する。意味もだいたい同じ。

書式	意味
なし	既定のテキスト
`b`	2進数
`o`	8進数
`x`	16進数（小文字）
`X`	16進数（大文字）
`e`	浮動小数点数科学技術記法（小文字）
`E`	浮動小数点数科学技術記法（大文字）
`?`	デバッグ出力
`p`	ポインタ値

実はこれらの書式には対応するトレイトがあって，独自に作成した型でもトレイトを実装することで書式に対応できる。

書式	トレイト
なし	`std::fmt::Display`
`b`	`std::fmt::Binary`
`o`	`std::fmt::Octal`
`x`	`std::fmt::LowerHex`
`X`	`std::fmt::UpperHex`
`e`	`std::fmt::LowerExp`
`E`	`std::fmt::UpperExp`
`?`	`std::fmt::Debug`
`p`	`std::fmt::Pointer`

たとえば，以下の構造体 Person に対して

struct Person {
    age: u32,
    name: String,
}

std::fmt::Display トレイトを実装してみる。こんな感じ。

use std::fmt;

struct Person {
    age: u32,
    name: String,
}

impl fmt::Display for Person {
    fn fmt(&self, dest: &mut fmt::Formatter) -> fmt::Result {
        write!(dest, "{} ({})", self.name, self.age)
    }
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "alice".to_string(),
    };
    println!("p1 = {}", p1); //Output: p1 = alice (24)
    println!("p1 = {}", p1.to_string()); //Output: p1 = alice (24)
}

std::fmt::Display トレイトを実装すると ToString トレイトもセットで実装される。便利！

std::fmt::Debug トレイトの実装はもっと簡単で， derive 構文を使って

#[derive(Debug)]
struct Person {
    age: u32,
    name: String,
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "alice".to_string(),
    };
    println!("p1 = {:?}", p1); //Output: p1 = Person { age: 24, name: "alice" }
}

とすればよい。

ちなみに全ての組み込み型と標準ライブラリで定義される型は std::fmt::Debug トレイトを実装済みなので，さきほど to_string() メソッドが使えないと書いたタプルや配列でも

fn main() {
    println!("{:?}", (123, 1.13)); //Output: (123, 1.13)
    println!("{:?}", [1, 2, 3]); //Output: [1, 2, 3]
}

のようにできる。

文字列から他の型の値を取得する

std::str::FromStr トレイトを実装している型であれば文字列からその型の値を取得できる。

pub trait FromStr: Sized {
    type Err;
    fn from_str(s: &str) -> Result<Self, Self::Err>;
}

整数や浮動小数点数などの基本型は std::str::FromStr トレイトを実装している。返り値は Result 型なので何らかのエラーハンドリングが必要だが，以下のコードでは端折っている¹。

use std::str::FromStr;

fn main() {
    println!("{:?}", i64::from_str("123")); //Output: Ok(123)
    println!("{:?}", f64::from_str("1.23")); //Output: Ok(1.23)
    println!("{:?}", bool::from_str("true")); //Output: Ok(true)
}

ちなみに大文字の "TRUE" はダメらしい（笑）

use std::str::FromStr;

fn main() {
    println!("{:?}", bool::from_str("TRUE")); //Output: Err(ParseBoolError { _priv: () })
}

小文字に変換すればいいかな。

use std::str::FromStr;

fn main() {
    println!("{:?}", bool::from_str(&"TRUE".to_lowercase())); //Output: Ok(true)
}

文字列に対して parse() メソッドを使う方法もある。 parse() メソッド内部で from_str() を呼び出しているらしい。

fn main() {
    println!("{:?}", "123".parse::<i64>()); //Output: Ok(123)
    println!("{:?}", "TRUE".to_lowercase().parse::<bool>()); //Output: Ok(true)
}

記述としてはどっちもどっちだな。

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

Eブック版あり。公式ドキュメントよりも系統的に書かれているので痒いところに手が届く感じ。ただし量が多いので，一度斜め読みしたらあとは傍らに置いて必要に応じてつまみ食いしていくのがいいだろう。

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

エラー・ハンドリングについては「エラー・ハンドリングのキホン」を参考にどうぞ。 ↩︎

Rust の文字列操作（1）

2020-03-08T14:08:47+00:00

さて，所有権について何とな〜く分かったところで，目先を変えて文字・文字列・文字列操作について調べていこう。

Rust の「文字列」は Unicode/UTF-8 限定

文字列操作で何が面倒かって複数の文字セットと文字エンコーディングが混在している点である。そこで今どきのプログラミング言語は「文字列」としての操作対象を Unicode/UTF-8 に限定していることが多い。 Rust もそうした言語のひとつである。

こんにちは，世界！

まずは，以下のコードを書いてみる。

fn main() {
    println!("こんにちは，世界！");
}

ここで "こんにちは，世界！" はリテラル文字列で，実行すると

$ cargo run
こんにちは，世界！

と表示される。 println! マクロ引数のリテラル文字列も出力される文字列も UTF-8 エンコーディングである。

ここでリテラル文字列の "こんにちは，世界！" を強引に Shift-JIS に書き換えて実行するとどうなるか。

$ pushd src/
$ cp main.rs main.rs.utf8.txt
$ gonkf conv -s utf8 -d sjis main.rs.utf8.txt > main.rs
$ popd
$ cargo run
error: couldn't read src/main.rs: stream did not contain valid UTF-8

というわけでコンパイルに失敗しました（笑）

Rust における文字と文字列

Rust では Unicode/UTF-8 文字および文字列を扱うために以下の3つの型が存在する。

型名	内部表現	内容
`char`	`u32`	文字（Unicode 符号点）
`String`	`Vec<u8>`	可変長文字列（UTF-8）
`str`	`[u8]`	文字列への参照（UTF-8）

char および str は組み込み型， String は標準ライブラリで定義される型である。

str 型は文字列に対するスライスで，それ自体は所有権を持たず（値を持たないため）範囲指定付きビューとして機能する。通常は &str と参照の形で使う。

String と str の関係はこんな感じ。

fn main() {
    let s: String = "Hello World".to_string();
    let hw: &str = s.as_str();
    let w: &str = &s[6..11];
    println!("{}", s); //Output: Hello World
    println!("{}", hw); //Output: Hello World
    println!("{}", w); //Output: World
}

図にするとこんな感じだろうか。

"Hello World" などのリテラル文字列は型としては &'static str と表現できる。ちなみに 'static はライフタイム注釈の特殊な表現で，生存期間がプログラム全域に及ぶという恐ろしいものである（笑）

リテラル文字列の後ろの to_string() メソッドは文字列のコピーを返す。リテラル文字列そのものがセットされているわけではない。

文字列から文字を抽出する

Rust の文字列の中身は UTF-8 バイト列なので，文字列から文字（厳密には Unicode 符号点¹）を抽出するのは単純ではない。そもそも

fn main() {
    let s = "日本語";
    println!("{}", s[0]); //Error: the type `str` cannot be indexed by `{integer}`
}

とかやってもコンパイル・エラーになるだけである。

文字列から文字を抽出するには，例えばこんな感じに書ける。

fn main() {
    let s1 = "日本語";
    println!("{:?}", s1.chars().nth(0)); //Output: Some('日')
    let s2 = s1.to_string();
    println!("{:?}", s2.chars().nth(1)); //Output: Some('本')
}

まず chars() メソッドで文字列を文字単位のイテレータ Chars に変換し，更に nth() メソッドで任意の位置の文字を抽出している。 nth() メソッドは Option 型の値を返すので本来は何らかのエラー・ハンドリングが必要だが，今回は横着している²。ゴメンペコン。

あるいはもっと簡単に collect() メソッドを使って Chars から配列 Vec<char> に変換して

fn main() {
    let nihongo = "日本語";
    let chs = nihongo.chars().collect::<Vec<char>>();
    println!("{}", chs[0]); //Output: 日
}

てな感じにも記述できる。

「文字」列から「文字列」を生成する

1文字ではなく，先頭の2文字を抽出して文字列を生成してみる。まずは素朴にこんな感じだろうか。

fn main() {
    let nihongo = "日本語";
    let mut nippon = String::new();
    for (i, c) in nihongo.chars().enumerate() {
        nippon.push(c);
        if i > 0 {
            break;
        }
    }
    println!("{}", nippon); //Output: 日本
}

うーん，微妙。たとえば take() メソッドを使えば先頭から指定した数だけ要素を有効にできる。

fn main() {
    let nihongo = "日本語";
    let mut nippon = String::new();
    for c in nihongo.chars().take(2) {
        nippon.push(c);
    }
    println!("{}", nippon); //Output: 日本
}

いや，そもそも for 文で回すってのがダサいというか… ふむむー，そっか。 fold() メソッドを使えばいいのか。

fn main() {
    let nihongo = "日本語";
    let nippon = nihongo.chars().take(2).fold(String::new(), |mut s, c| {
        s.push(c);
        s
    });
    println!("{}", nippon); //Output: 日本
}

でも「先頭の2文字を抽出する」だけなのに，コードが大袈裟すぎないか？と思ってたら，ゴメン。 collect() メソッドを使えば一発で String に変換できたわ。

fn main() {
    let nihongo = "日本語";
    let nippon = nihongo.chars().take(2).collect::<String>();
    println!("{}", nippon); //Output: 日本
}

なんだ，簡単ぢゃん orz

ブックマーク

Stringとstr入門 - Qiita
文字列操作 with Rust - Qiita
Rustで文字列の先頭文字や部分文字列を取得する - Qiita
spiegel-im-spiegel/charset_document: 「文字コードとその実装」 upLaTeX ドキュメント : 大昔に書いたドキュメントで内容が古いため，取り扱いには注意
spiegel-im-spiegel/text: Encoding/Decoding Text Package by Golang : gonkf コマンドはここで公開しています

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

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

Unicode ではひとつの符号点がひとつの文字を表すとは限らない点に注意。これに関して以前に「Go 言語と Unicode 正規化」という記事を書いたので参考にどうぞ。 ↩︎
エラー・ハンドリングについては「エラー・ハンドリングのキホン」を参考にどうぞ。 ↩︎

strings.EqualFold 関数を使え

2019-12-15T09:01:19+00:00

GolangCI が吐くレビュー結果を基にチマチマとコードを直していたのだが，その中で

SA6005: should use strings.EqualFold(a, b) instead of strings.ToLower(a) == strings.ToLower(b)

if strings.ToLower(left) == strings.ToLower(right) {

という指摘があった。いや，もの知らずでゴメンペコン。

strings.EqualFold() 関数ってなんじゃら？と思ってソースコードを見たら

// EqualFold reports whether s and t, interpreted as UTF-8 strings,
// are equal under Unicode case-folding.
func EqualFold(s, t string) bool {
    ...
}

と書かれている。

ふむふむ。では試してみよう。こんな感じのコードを書いて

package main

import (
	"fmt"
	"strings"
)

func main() {
	lefts := []string{"go", "ｇｏ"}
	rights := []string{"Go", "GO", "go", "Ｇｏ", "ＧＯ", "ｇｏ"}

	for _, left := range lefts {
		for _, right := range rights {
			fmt.Printf("%s == %s : %v\n", left, right, strings.EqualFold(left, right))
		}
	}
}

実行してみると

$ go run sample1.go 
go == Go : true
go == GO : true
go == go : true
go == Ｇｏ : false
go == ＧＯ : false
go == ｇｏ : false
ｇｏ == Go : false
ｇｏ == GO : false
ｇｏ == go : false
ｇｏ == Ｇｏ : true
ｇｏ == ＧＯ : true
ｇｏ == ｇｏ : true

ってな感じになった。全角と半角は区別してくれるらしい。 Unicode の文字種をきちんと判別しているということだ。

ちなみに strings.ToLower() 関数を使って

package main

import (
	"fmt"
	"strings"
)

func main() {
	lefts := []string{"go", "ｇｏ"}
	rights := []string{"Go", "GO", "go", "Ｇｏ", "ＧＯ", "ｇｏ"}

	for _, left := range lefts {
		for _, right := range rights {
			fmt.Printf("%s == %s : %v\n", left, right, (left == strings.ToLower(right)))
		}
	}
}

とやっても同じ結果になる。

strings.EqualFold() 関数と strings.ToLower() 関数でどっちが速いかなんてのは考えるまでもないのだが，いちおう試しておこう。こんな感じのコードでいいかな。

package equalfold

import (
	"strings"
	"testing"
)

var (
	lefts   = []string{"go", "ｇｏ"}
	rights  = []string{"Go", "GO", "go", "Ｇｏ", "ＧＯ", "ｇｏ"}
	rights2 = []string{"go", "go", "go", "ｇｏ", "ｇｏ", "ｇｏ"}
)

func BenchmarkEqualCase(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, left := range lefts {
			for _, right := range rights2 {
				if left == right {
					_ = left
				} else {
					_ = right
				}
			}
		}
	}
}

func BenchmarkEqualLower(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, left := range lefts {
			for _, right := range rights {
				if left == strings.ToLower(right) {
					_ = left
				} else {
					_ = right
				}
			}
		}
	}
}

func BenchmarkEqualFold(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for _, left := range lefts {
			for _, right := range rights {
				if strings.EqualFold(left, right) {
					_ = left
				} else {
					_ = right
				}
			}
		}
	}
}

BenchmarkEqualCase は他の2つのコードとの比較用に書いてみた。実行結果はこんな感じ。

$ go test -bench Equal -benchmem
goos: linux
goarch: amd64
pkg: sample
BenchmarkEqualCase-4    	32061360	        36.2 ns/op	       0 B/op	       0 allocs/op
BenchmarkEqualLower-4   	 1367802	       869 ns/op	      64 B/op	       8 allocs/op
BenchmarkEqualFold-4    	 3149362	       378 ns/op	       0 B/op	       0 allocs/op
PASS
ok  	sample	4.748s

表にまとめておこう。

関数名	実行時間	Alloc サイズ	Alloc 回数
`BenchmarkEqualCase`	36.2 ns	0 bytes	0
`BenchmarkEqualLower`	869 ns	64 bytes	8
`BenchmarkEqualFold`	378 ns	0 bytes	0

BenchmarkEqualCase と BenchmarkEqualFold の比較では BenchmarkEqualFold のほうが10倍の時間がかかっているが，それよりも BenchmarkEqualLower の処理のほうが圧倒的に遅いことが分かる。まぁメモリ・アロケーションが絡むとねぇ。

というわけで，大文字小文字を無視した文字列比較では素直に strings.EqualFold() 関数を使いましょう，という話でした。

【付録】 “NUL” 文字の比較

まるきし余談ではあるが

Big Sky :: Go で大文字小文字無視の文字列比較ベンチマーク

この記事にある isDevNull3 関数について

func isDevNull3(name string) bool {
    return strings.ToLower(name) == "nul"
}

strings.EqualFold() 関数を使うよう書き換えてみる。

func isDevNull3(name string) bool {
	return strings.EqualFold(name, "nul")
}

これでベンチマークテストを実行すると

goos: linux
goarch: amd64
pkg: sample/lowercase
BenchmarkS1-4   	41640913	        27.2 ns/op	       0 B/op	       0 allocs/op
BenchmarkS2-4   	35464141	        30.7 ns/op	       0 B/op	       0 allocs/op
BenchmarkS3-4   	12628962	        94.4 ns/op	       0 B/op	       0 allocs/op
PASS
ok  	sample/lowercase	3.578s

メモリ・アロケーションが発生しなくなり，かなり速くなる。まぁ，それでもいっちゃん遅いのだが（笑）

参考図書

プログラミング言語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)

【改訂版】文字列連結はどれが速い？

2019-10-13T08:15:36+00:00

今回も小ネタでお送りしております。

2015年に「文字列連結はどれが速い？」という記事を書いた。あれから文字連結に関してどう変わったのか。特に Go 1.10 で strings.Builder が追加されているので，その辺も含めて再検証してみる。

今回検証するコードは以下の通り。

package join

import (
    "bytes"
    "strings"
)

var sz8k = 8 * 1024

func JoinStringPlus(ss []string) {
    var str string
    for _, s := range ss {
        str += s + "\n"
    }
}

func JoinStringJoin(ss []string) {
    strings.Join(ss, "\n")
}

func JoinStringByteAppend(ss []string) {
    b := []byte{}
    for _, s := range ss {
        b = append(b, s...)
        b = append(b, "\n"...)
    }
}

func JoinStringByteAppend8K(ss []string) {
    b := make([]byte, 0, sz8k)
    for _, s := range ss {
        b = append(b, s...)
        b = append(b, "\n"...)
    }
}

func JoinStringBuilder(ss []string) {
    b := &strings.Builder{}
    for _, s := range ss {
        b.WriteString(s)
        b.WriteString("\n")
    }
}

func JoinStringBuilder8K(ss []string) {
    b := &strings.Builder{}
    b.Grow(sz8k)
    for _, s := range ss {
        b.WriteString(s)
        b.WriteString("\n")
    }
}

func JoinStringBuffer(ss []string) {
    b := &bytes.Buffer{}
    for _, s := range ss {
        b.WriteString(s)
        b.WriteString("\n")
    }
}

func JoinStringBuffer8K(ss []string) {
    b := bytes.NewBuffer(make([]byte, 0, sz8k))
    for _, s := range ss {
        b.WriteString(s)
        b.WriteString("\n")
    }
}

各関数の内容は以下の通り。

関数名	内容
`JoinStringPlus`	`+` 演算子で連結する
`JoinStringJoin`	`strings.Join` 関数で連結する
`JoinStringByteAppend`	`[]byte` 配列に追記する
`JoinStringByteAppend8K`	`[]byte` 配列に追記する（8KB アロケーション）
`JoinStringBuilder`	`strings.Builder` に追記する
`JoinStringBuilder8K`	`strings.Builder` に追記する（8KB アロケーション）
`JoinStringBuffer`	`bytes.Buffer` に追記する
`JoinStringBuffer8K`	`bytes.Buffer` に追記する（8KB アロケーション）

使うメソッドによって出力する型が異なるが（string or []byte），今回は無視することにした¹。

ベンチマーク用のコードは以下の通り。

package join

import (
    "bufio"
    "os"
    "testing"
)

func ReadAll(path string) []string {
    file, err := os.Open(path) //maybe file path
    if err != nil {
        return nil
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    list := []string{}
    for scanner.Scan() {
        list = append(list, scanner.Text())
    }
    if err := scanner.Err(); err != nil {
        return nil
    }
    return list
}

var content = ReadAll("CollisionsForHashFunctions.txt")

func BenchmarkJoinStringPlus(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringPlus(content)
    }
}

func BenchmarkJoinStringJoin(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringJoin(content)
    }
}

func BenchmarkJoinStringByteAppend(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringByteAppend(content)
    }
}

func BenchmarkJoinStringByteAppend8K(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringByteAppend8K(content)
    }
}

func BenchmarkJoinStringBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringBuilder(content)
    }
}

func BenchmarkJoinStringBuilder8K(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringBuilder8K(content)
    }
}

func BenchmarkJoinStringBuffer(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringBuffer(content)
    }
}

func BenchmarkJoinStringBuffer8K(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringBuffer8K(content)
    }
}

入力テキストは前回と同じ CollisionsForHashFunctions.txt を使用した。 8KB ほどのサイズがある。つまりコピー先バッファに 8KB の容量があれば追加のアロケーションは発生しないことになる。

では，さっそく実行してみる。

$ go test -bench JoinString -benchmem
goos: linux
goarch: amd64
pkg: join
BenchmarkJoinStringPlus-4                  19484         65256 ns/op      272160 B/op          69 allocs/op
BenchmarkJoinStringJoin-4                 371649          3087 ns/op        8192 B/op           1 allocs/op
BenchmarkJoinStringByteAppend-4           151417          8339 ns/op       35376 B/op          12 allocs/op
BenchmarkJoinStringByteAppend8K-4         502942          2544 ns/op        8192 B/op           1 allocs/op
BenchmarkJoinStringBuilder-4              130408          8434 ns/op       35376 B/op          12 allocs/op
BenchmarkJoinStringBuilder8K-4            418900          2781 ns/op        8192 B/op           1 allocs/op
BenchmarkJoinStringBuffer-4               133052          9545 ns/op       32240 B/op           8 allocs/op
BenchmarkJoinStringBuffer8K-4             351681          3526 ns/op        8192 B/op           1 allocs/op
PASS
ok      join    12.695s

結果を表にまとめておこう。

関数名	実行時間	Alloc サイズ	Alloc 回数
`JoinStringPlus`	65,256 ns	2,702,160 bytes	69
`JoinStringJoin`	3,087 ns	8,192 bytes	1
`JoinStringByteAppend`	8,339 ns	35,376 bytes	12
`JoinStringByteAppend8K`	2,544 ns	8192 bytes	1
`JoinStringBuilder`	8,434 ns	35,376 bytes	12
`JoinStringBuilder8K`	2,781 ns	8,192 bytes	1
`JoinStringBuffer`	9,545 ns	32,240 bytes	8
`JoinStringBuffer8K`	3,526 ns	8192 bytes	1

まず strings.Join() 関数を使った連結がめっさ速くなってアロケーション回数も1回のみになっていることにビックリした。ソースコードを見てみたら，やっぱり strings.Join() 関数内部で strings.Builder を使っていた。

// Join concatenates the elements of a to create a single string. The separator string
// sep is placed between elements in the resulting string.
func Join(a []string, sep string) string {
    switch len(a) {
    case 0:
        return ""
    case 1:
        return a[0]
    }
    n := len(sep) * (len(a) - 1)
    for i := 0; i < len(a); i++ {
        n += len(a[i])
    }

    var b Builder
    b.Grow(n)
    b.WriteString(a[0])
    for _, s := range a[1:] {
        b.WriteString(sep)
        b.WriteString(s)
    }
    return b.String()
}

ちなみに strings.Builder への追記処理は以下のようになっている。

// WriteString appends the contents of s to b's buffer.
// It returns the length of s and a nil error.
func (b *Builder) WriteString(s string) (int, error) {
    b.copyCheck()
    b.buf = append(b.buf, s...)
    return len(s), nil
}

つまり []byte 配列への append() と strings.Builder への追記と strings.Join() は実質的に同じ処理で，それぞれの前処理分だけ差が出ているということになる。

今回の検証では

やっぱり + 演算子による連結はダメダメ²
よほどの最適化が要求されない限り []byte 配列への append() は strings.Builder へ代替可能³
strings.Join() 関数のパフォーマンスは十分なので気軽に使ってよい
文字列連結に限るなら，もはや bytes.Buffer は有利とは言えない

といったところだろうか。

参考図書

プログラミング言語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)

string 型は不変オブジェクトなので，通常は []byte 型との相互変換の際にメモリ・アロケーションとデータ・コピーが発生する。ちなみに strings.Builder の String() メソッドでは unsafe パッケージを使って無理やりキャスティングしている。 ↩︎
リテラル文字列同士の連結はコンパイラが処理するので + 演算子で無問題。 ↩︎
内部で append() 関数を使っていることから分かる通り strings.Builder のインスタンスはコピーして使えないので注意が必要である（インスタンスのポインタを渡せばOK）。当然ながら goroutine-safe ではないので複数の goroutine 間で共有できない。 ↩︎

文字列連結はどれが速い？

2015-09-21T14:08:07+00:00

（初出： Golang の文字列連結はどちらが速い？ - Qiita）

前回につづき string の話題。 Go 言語で文字列の連結を行う際にどうやるのが一番速いか，という話。

【2019-10-13 追記】 改訂版を公開しました。

文字列連結を行う4つの方法

Go 言語で文字列の連結を行う際には概ね以下の4つの方法がある。

“+” 演算子で連結する
strings.Join で連結する
bytes.Buffer に追記する
[]byte に append する

string は「不変（immutable）」なので，最初の2つが高コストになるだろうことはすぐに想像がつく。

では残りの2つはどうなのかというと

Goの文字列結合のパフォーマンス - Qiita

によると最後のが一番速いらしい。ほんじゃまぁ，確かめてみるか。

サンプルコードを用意

以下のコード join.go を使って評価してみる。

package main

import (
    "bufio"
    "bytes"
    "io"
)

//Read content (text data) from buffer
func ContentText(inStream io.Reader) ([]string, error) {
    scanner := bufio.NewScanner(inStream)
    list := make([]string, 0)
    for scanner.Scan() {
        list = append(list, scanner.Text())
    }
    if err := scanner.Err(); err != nil {
        return nil, err
    }
    return list, nil
}

//Write content (text data) to buffer
func WriteBuffer1(lines []string) []byte {
    //write to byte buffer
    content := make([]byte, 0)
    recode := "\r\n"
    for _, line := range lines {
        content = append(content, line...)
        content = append(content, recode...)
    }
    return content
}

//Write content (text data) to buffer
func WriteBuffer1Cap128(lines []string) []byte {
    //write to byte buffer
    content := make([]byte, 0, 128) //128 bytes capacity
    recode := "\r\n"
    for _, line := range lines {
        content = append(content, line...)
        content = append(content, recode...)
    }
    return content
}

//Write content (text data) to buffer
func WriteBuffer1Cap1K(lines []string) []byte {
    //write to byte buffer
    content := make([]byte, 0, 1024) //1K bytes capacity
    recode := "\r\n"
    for _, line := range lines {
        content = append(content, line...)
        content = append(content, recode...)
    }
    return content
}

//Write content (text data) to buffer (buffered I/O)
func WriteBuffer2(lines []string) []byte {
    //write to byte buffer
    content := bytes.NewBuffer(make([]byte, 0))
    recode := "\r\n"
    for _, line := range lines {
        content.WriteString(line)
        content.WriteString(recode)
    }
    return content.Bytes()
}

//Write content (text data) to buffer (buffered I/O)
func WriteBuffer2Cap128(lines []string) []byte {
    //write to byte buffer
    content := bytes.NewBuffer(make([]byte, 0, 128)) //128 bytes capacity
    recode := "\r\n"
    for _, line := range lines {
        content.WriteString(line)
        content.WriteString(recode)
    }
    return content.Bytes()
}

//Write content (text data) to buffer (buffered I/O)
func WriteBuffer2Cap1K(lines []string) []byte {
    //write to byte buffer
    content := bytes.NewBuffer(make([]byte, 0, 1024)) //1K bytes capacity
    recode := "\r\n"
    for _, line := range lines {
        content.WriteString(line)
        content.WriteString(recode)
    }
    return content.Bytes()
}

テストコード join_test.go はこんな感じ。

package main

import (
    "os"
    "testing"
)

func readFile() []string {
    file, err := os.Open("CollisionsForHashFunctions.txt") //maybe file path
    if err != nil {
        panic(err)
    }
    defer file.Close()
    list, err := ContentText(file)
    if err != nil {
        panic(err)
    }
    return list
}

func BenchmarkWriteBuffer1(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer1(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer1Cap128(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer1Cap128(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer1Cap1K(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer1Cap1K(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer2(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer2(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer2Cap128(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer2Cap128(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer2Cap1K(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer2Cap1K(list)
        _ = string(content)
    }
}

Go 言語のテストについては以前紹介したが，同じ要領で Benchmark から始まる名前の関数を作るとベンチマーク用のコードとして認識される。引数には b *testing.B を指定する。

ベンチマークの内訳は以下のとおり。

ベンチマーク名	処理内容
`BenchmarkWriteBuffer1`	`[]byte` に `append` する
`BenchmarkWriteBuffer1Cap128`	`[]byte` に `append` する（ capacity 128B）
`BenchmarkWriteBuffer1Cap1K`	`[]byte` に `append` する（ capacity 1KB）
`BenchmarkWriteBuffer2`	`bytes.Buffer` に追記する
`BenchmarkWriteBuffer2Cap128`	`bytes.Buffer` に追記する（ capacity 128B）
`BenchmarkWriteBuffer2Cap1K`	`bytes.Buffer` に追記する（ capacity 1KB）

入力テキストだが，小さいファイルではテストにならない気がしたので，大昔に書いたテキスト CollisionsForHashFunctions.txt を使うことにした。サイズは70行，7KB ほど。

テスト結果

結果は以下のとおり。

C:>go test -bench WriteBuffer -benchmem
testing: warning: no tests to run
PASS
BenchmarkWriteBuffer1-8           100000         17831 ns/op       37056 B/op     12 allocs/op
BenchmarkWriteBuffer1Cap128-8     100000         20321 ns/op       36992 B/op     11 allocs/op
BenchmarkWriteBuffer1Cap1K-8      100000         19301 ns/op       36096 B/op      8 allocs/op
BenchmarkWriteBuffer2-8           100000         17300 ns/op       33760 B/op     10 allocs/op
BenchmarkWriteBuffer2Cap128-8     100000         19451 ns/op       34992 B/op      9 allocs/op
BenchmarkWriteBuffer2Cap1K-8      100000         15490 ns/op       25712 B/op      6 allocs/op
ok      join    12.659s

ありゃりゃ。 bytes.Buffer を使ったほうが速いみたい（capacity を大きくとれば）。

それなら，入力テキストを切り詰めて10行，0.3KB にしてやってみる。

C:>go test -bench WriteBuffer -benchmem
testing: warning: no tests to run
PASS
BenchmarkWriteBuffer1-8          2000000           859 ns/op        1312 B/op      5 allocs/op
BenchmarkWriteBuffer1Cap128-8    2000000           707 ns/op        1248 B/op      4 allocs/op
BenchmarkWriteBuffer1Cap1K-8     2000000           796 ns/op        1376 B/op      2 allocs/op
BenchmarkWriteBuffer2-8          1000000          1686 ns/op        1600 B/op      6 allocs/op
BenchmarkWriteBuffer2Cap128-8    1000000          1411 ns/op        1680 B/op      5 allocs/op
BenchmarkWriteBuffer2Cap1K-8     2000000           980 ns/op        1488 B/op      3 allocs/op
ok      join    13.589s

今度は []byte の方が速くなった。

まぁでも予想通りかな。データのサイズが大きくなればバッファ操作のほうが有利になるのは分かりやすいっちゃあ分かりやすい。

注目すべきは BenchmarkWriteBuffer1Cap128 と BenchmarkWriteBuffer1Cap1K で， capacity を 1KB 取ったほうが若干遅くなっている。この辺のチューニングをどうするか，というところなのだろう（実はこれ，環境によって微妙に順位が変わるんだよなぁ）。

ブックマーク

参考図書

プログラミング言語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)

String と Rune

2015-09-19T14:45:56+00:00

（初出：はじめての Go 言語 (on Windows) その4 - Qiita）

文字列を示す string は不変（immutable）なオブジェクトだが，中身は byte 配列である。したがって以下のように

package main

import "fmt"

func main() {
    nihongo := "日本語"
    size := len(nihongo)

    fmt.Printf("nihongo = %d bytes :", size)
    for i := 0; i < size; i++ {
        fmt.Printf(" %02x", nihongo[i])
    }
    fmt.Println()
}

string をダンプすると以下の結果になる¹。

nihongo = 9 bytes : e6 97 a5 e6 9c ac e8 aa 9e

このように（string なんて名前なのに）文字単位で情報を保持しているわけではないため，最初の2文字を取り出すつもりでうっかり

package main

import "fmt"

func main() {
    nihongo := "日本語"

    fmt.Printf("nihongo = %s\n", nihongo)
    fmt.Printf("nippon = %s\n", nihongo[:2])
}

なんてなコードを書くと以下の結果になる。

nihongo = 日本語
nippon = ��

文字列を文字単位で扱うには rune 型を使う²。いや，ルーンってどんだけ厨二… ゲフンゲフン。

ええつと，たとえばこんな感じ。

package main

import "fmt"

func main() {
    nihongo := "日本語"
    nihongoRune := []rune(nihongo)
    size := len(nihongoRune)

    fmt.Printf("nihongo = %d characters : ", size)
    for i := 0; i < size; i++ {
        fmt.Printf("%#U ", nihongoRune[i])
    }
    fmt.Printf("\n")
}

実行結果はこんな感じになる。

nihongo = 3 characters : U+65E5 '日' U+672C '本' U+8A9E '語'

または， string に対して for range 構文を使ってループを回すと rune 単位で取得できる。

package main

import "fmt"

func main() {
    nihongo := "日本語"

    for pos, runeValue := range nihongo {
        fmt.Printf("%#U starts at byte position %d\n", runeValue, pos)
    }
}

このコードの実行結果はこんな感じ。

U+65E5 '日' starts at byte position 0
U+672C '本' starts at byte position 3
U+8A9E '語' starts at byte position 6

rune 型の実体は int32 で，内部表現は Unicode の符号点（code point）になっている。 string と rune 配列は相互変換できるので，文字列を切り取る場合は

package main

import "fmt"

func main() {
    nihongo := "日本語"

    fmt.Printf("nihongo = %s\n", nihongo)
    fmt.Printf("nippon = %s\n", string([]rune(nihongo)[:2]))
}

のように string → []rune → string と変換していけば安全に処理できる。上のコードの実行結果はこんな感じ。

nihongo = 日本語
nippon = 日本

もう少し細かい処理が必要なら unicode/utf8 パッケージを使う手もある³。

ブックマーク

Go 言語に関するブックマーク集はこちら。

参考図書

プログラミング言語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 言語で取り扱う文字列の文字エンコーディングは UTF-8 が既定である。ソースコードがそもそも UTF-8 を要求しているし（つまりリテラルの文字列はかならず UTF-8 になる）， string と rune の相互変換も文字列が UTF-8 であることを前提にしている。しかし，実際には string の実体はただの byte 配列であり，中身が UTF-8 文字列であることを保証しているわけではない。通常は，未知の文字列についてはいったん byte 配列に格納しておいて，何らかの方法で UTF-8 に変換してから string にキャストするのが安全である（または各文字エンコーディング用の独自 type を作るか）。なお，文字エンコーディングの変換については別の記事で改めて紹介する。 ↩︎
厳密には文字単位ではなく Unicode の符号点単位と言ったほうがいいかもしれない。 Unicode では結合文字（濁点記号や異体字セレクタなど）にもコードポイントが割り当てられているので，特に日本語で文字を意識した文字列操作を行う場合は注意が必要である。ぶっちゃけ面倒くさい。 ↩︎
ちなみに strings パッケージは内部で unicode/utf8 パッケージを使っているようだ。 ↩︎