2016/09/30
丸善出版の『プログラミング言語Go』の読書履歴です。
出てきた内容の気になったポイントのまとめや練習問題の解答（自分なりの）を記載していきます。
（ここに記載されている内容で問題が生じても責任は負えませんのであしからず…。）
練習問題は結構長くなるものが増えてきたので、本文記載のコードの修正の場合は修正部分だけ抜粋しています。
すべてのコードが見たい場合はGitHubにあるので、そちらを見てみてください。
プログラミング言語Go GitHub
さて、第3章は基本データ型についてです。
3.1 整数
3.2 浮動小数
3.3 複素数
3.4 ブーリアン
3.5 文字列
3.6 定数
Go言語の整数型には符号付きと符号なしがあります。
符号付き整数型は int8型、int16型、int32型、int64型があり、符号なし整数型には uint8型、uint16型、uint32型、uint64型があります。
また、ビット数が32ビットか64ビットになる int型と uint型もあります。
これらのビット数はハードウェア依存です。
他に rune型というのがあって、int32のシノニムで、慣習的にUncodeのコードポイントとして使われます。
byte型というのもあって、これはuint8のシノニムで、生データを扱うときに使われるようです。
それから、uintptr型というのもあって、これはポインタを格納するときに使うようです。
通常はint、uintを使えば良いようです。
ただ、intとint32と言ったデータ型は暗黙的に変換してくれないので、int32(x) といったように明示的に変換する必要があります。
算術、論理、比較演算子は次のようなものがあり、CやJavaなどと同じですね。
*, /, %, +, -, <<, >>, &, &^, |, ^, ==, !=, <, <=, >, >=, &&, ||
Goでは float32 と float64 があって、それぞれ精度が6桁と約15桁になります。
小数点より前の桁を省略（.707）、もしくは後の桁を省略（1.）することができます。
非常に小さな値や大きな値は e または E を使った科学的記数法で書くこともできます。
不正な値があったらポリゴンをスキップする、という問題なので、単純にIsNaN（） で値を調べるif文を追加しています。
（文中にあるソースコードの修正なので、修正部分の関数だけ抜粋します）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
func main() { fmt.Printf("<svg xmlns='http://www.w3.org/2000/svg' " + "style='stroke: grey; fill; white; stroke-width: 0.7'" + "width='%d' height='%d'>", width, height) for i := 0; i < cells; i++ { for j := 0; j < cells; j++ { ax, ay := corner(i+1, j) bx, by := corner(i, j) cx, cy := corner(i, j+1) dx, dy := corner(i+1, j+1) if !(math.IsNaN(ax) && math.IsNaN(ay) && math.IsNaN(by) && math.IsNaN(by) && math.IsNaN(cy) && math.IsNaN(cy) && math.IsNaN(dy) && math.IsNaN(dy)) { fmt.Printf("<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\n", ax, ay, bx, by, cx, cy, dx, dy) } } } fmt.Println("</svg>") } |
mathパッケージの別の関数を使って違う図形を作りなさい、という課題なのですが、数学が苦手ゆえ解答が出ず。。。
悩みすぎて先に進めなさそうなので、時々考えることにしてちょっとパスします（汗）
高さに基づいて色を変えよ、ということなのですが、こちらもイマイチ解答が浮かばずでして。。。
色はstyleを設定することで変更可能です。
|
1 |
fmt.Printf("<polygon style='stroke: #ff0000;' points='%g,%g %g,%g %g,%g %g,%g'/>\n", ax, ay, bx, by, cx, cy, dx, dy) |
SVGデータをクライアントに書き出すWebサーバを作成する、という問題なので、1章で作ったWebサーバを参考にしてこんな感じにすればブラウザで図形を見れるようになります。
HTTPリクエストでパラメータを受け取って高さなどを指定できるように、ともなるのですが、この辺は練習1.12でもやっているのでそちらを参考にしてください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
func main() { handler := func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "image/svg+xml") polygon(w) } http.HandleFunc("/", handler) log.Fatal(http.ListenAndServe("localhost:8000", nil)) } func polygon(out io.Writer) { fmt.Fprintf(out, "<svg xmlns='http://www.w3.org/2000/svg' "+ "style='stroke: grey; fill: white; stroke-width: 0.7;' "+ "width='%d' height='%d'>\n", width, height) for i := 0; i < cells; i++ { for j := 0; j < cells; j++ { ax, ay := corner(i+1, j) bx, by := corner(i, j) cx, cy := corner(i, j+1) dx, dy := corner(i+1, j+1) if !(math.IsNaN(ax) && math.IsNaN(ay) && math.IsNaN(bx) && math.IsNaN(by) && math.IsNaN(cx) && math.IsNaN(cy) && math.IsNaN(dx) && math.IsNaN(dy)) { fmt.Fprintf(out, "<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\n", ax, ay, bx, by, cx, cy, dx, dy) } } } fmt.Fprintf(out, "</svg>") } |
複素数ってなによ、と思うのは私だけ？（汗）
数学における複素数（ふくそすう、英: complex number）は、実数の対 a, b と 1 と線型独立な（実数ではない）要素 i の線型結合 a + bi の形に表される数（二元数: 実数体上の二次拡大環の元）で、基底元 i はその平方が −1 になるという特別な性質を持ち虚数単位と呼ばれる。
全然わかんない…(＠_＠;)
ま、ま、ま、とりあえず読み進めます。はい。
複素数の生成にはcomplex関数が使えて、次のように書きます。
|
1 |
var x complex128 = complex(1, 2) |
もっと単純に書くこともできて、次のようになります。
|
1 |
x := 1 + 2i |
real関数、imag関数で実部と虚部を取り出すことができます。
|
1 2 |
fmt.Println(real(x)) // "1" fmt.Println(imag(x)) // "2" |
えぇと、、、数学が苦手な私にはだいぶ難しく、ちょっと解けていません。。。
ここで時間使いすぎても先に進めないので、この説の練習問題は飛ばしてしまいました。すみませんm(_ _)m
この問題は画像データをクライアントに書き出すWebサーバを作る、というものなので、問題1.12を参考にすれば出来ると思います。
パラメータを取得するところは作りこんでいませんが、クライアントに書き出すところまで作ったものがGitHubにアップロードしてあるので参考にしてみてください。
GitHub – 練習問題3.9
ブーリアンは bool 型を使います。取り得る値は true と false の2つだけです。
&&演算子と || 演算子と組み合わせる事ができて、次のように書くことも可能です。
|
1 2 |
s := "hoge" println( s != "" && s[0] == 'w' ) |
こうすると出力結果は false になります。
s が空文字の場合は s[0] でエラーになってしまうので、あらかじめ s != "" で空文字かどうかのチェックをしてから、1文字目のチェックをしているわけですね。
空文字の場合は最初の条件の時点でfalseになるので、エラーにならず処理はきちんと終わります。
それから、int と boolは暗黙の変換はないので、ifを使って変換することになります。
こんな感じに変換関数を用意しておくといいかもね、というお話でした。
|
1 2 3 4 5 6 7 8 9 10 |
// bool -> int func btoi(b bool) int { if b { return 1 } return 0 } // int -> bool func itob(i int) bool { return 1 != 0 } |
テキスト文字列はUTF-8エンコードされたのUnicodeです。
文字数は組み込み関数の len() を使って取得でき、 s[0] とすると0番目の文字を取り出すこともできます。
部分文字列も取り出せて、 s[0:5] と言ったように書けばOKです。この場合、0から5未満の文字列を取り出すことになります。
|
1 2 3 |
s := "hello world" fmt.Println(len(s)) // 11 fmt.Println(s[0], s[6]) // 104 119 （文字コードが返ってきます） |
+ 演算子を使って文字列を結合して新しい文字列を生成することができます。
|
1 2 3 4 5 |
s := "left foot" t := s s += ", right foot" fmt.Println(s) // left foot, right foot fmt.Println(t) // left foot |
あくまでも新しい文字列が生成されるので、s を代入しておいた t は元のままの文字列になります。
文字列は不変なので、文字列のデータを直接変換することはできません。
例えば以下のようにするとコンパイルエラーになります。
|
1 |
s[0] = 'f' |
文字列リテラルは ""(ダブルクォート)で囲んで書きます。
|
1 |
"Hello World" |
\(バックスラッシュ)で始まるエスケープシーケンスも使えます。
|
1 2 3 4 5 6 7 8 9 10 |
\a アラート \b バックスペース \f フォームフィード \n 改行 \r キャリッジリターン \t タブ \v 垂直タブ \' シングルクォート \" ダブルクォート \\ バックスラッシュ |
生文字列リテラル(raw string literal)はダブルクオートの代わりにバッククォート ` で囲みます。
生文字列リテラルはエスケープシーケンスが使えません。
ま文字列はプログラムソース内で複数行に広げることができたり、バックスラッシュを含むことが多い正規表現を書くときに便利です。
昔はASCIIだったけど、いろいろな言語に対応するためにUnicodeができたよ、といった話です。
Go言語でも文字列はUnicodeで扱われます。
文字コードはGo言語ではルーン(rune)と呼ばれる規格番号を割り当てています。
UTF-8はUnicodeコードポイントのバイトしての可変長エンコーディングです。
最近はUTF-8が使われることが非常に多いですね。
Go言語ではutf-8パッケージが用意されていて、いろいろな機能があるようです。
ルーンとUTF-8の変換と言った関数も用意されています。
文字列を操作するには、bytes、strings、strconv、unicode の標準パッケージを使うことができます。
strings パッケージは文字列の検索、置換、比較、トリミング、分割、連結などの関数を提供しています。
bytes パッケージは文字列をバイトスライスとして操作することができて、stringsと同じような機能も持っています。
strconv パッケージは整数値、ブール値、浮動小数点値から文字列へ変換やその逆変換などの機能を提供します。
unicode パッケージはルーンを分類するための関数などを提供します。
この節ではこれらのパッケージを使わないで文字列をバイトスライスとして扱う方法や、stringsやbytesを使った方法などを紹介しています。
この節では練習問題があるので、文中に出てくる commma プログラムから修正した部分だけ抜粋しています。
文字列連結の代わりに bytes.Buffer を使って行う、というものです。ちょっと冗長な気もしますがとりあえず…。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
func comma(s string) string { n := len(s) var b bytes.Buffer for n > 0 { l := n % 3 if l == 0 { l = 3 } b.WriteString(s[:l]) if n > 3 { b.WriteString(",") } s = s[l:] n = len(s) } return b.String() } |
comma を機能拡張して、符号記号を持つ浮動小数点を扱えるようにする、という問題です。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
func comma(s string) string { var b bytes.Buffer if strings.HasPrefix(s, "+") || strings.HasPrefix(s, "-") { b.WriteByte(s[0]) s = s[1:] } f := "" num := strings.Index(s, ".") if num > 0 { f = s[num:] s = s[:num] } n := len(s) for n > 0 { l := n % 3 if l == 0 { l = 3 } b.WriteString(s[:l]) if n > 3 { b.WriteString(",") } s = s[l:] n = len(s) } b.WriteString(f) return b.String() } |
この問題はちょっと飛ばしてしまいました。すみません…m(_ _)m
文字列と数値の変換はよくやるのですが、Go言語の場合は strconv パッケージか fmt.Sprintf を使うと簡単にできます。
|
1 2 3 |
x := 123 y := fmt.Sprintf("%d", x) fmt.Println(y, strconv.Itoa(x)) |
定数は実行時ではなくコンパイル時に評価が行われることが保障されている式です。
定数にはブーリアン、文字列、数値の基本型を使うことが可能です。
定数を定義するには const を使います。
|
1 |
const pi = 3.14 |
定数もひとつの宣言内に書くことができます。
|
1 2 3 4 |
const ( e = 2.71 pi = 3.14 ) |
const宣言で定数生成器 iota を使うことができます。
次のように書くと、Sundayはint型なので 0 が設定されます。
そのあとのMonday以降の定数には値を指定していませんが、1ずつインクリメントされた値が設定されます。
|
1 2 3 4 5 6 7 8 9 10 |
type Weekday int const ( Sunday Weekday = iota Monday Tuesday Wednesday Thursday Friday Saturday ) |
多言語によくある Enumのような型にすることができます。
iotaはビット演算はできますが、塁上演算子がないので、1000の累乗を生成するにはどうしたらいいか、という問題です。
単純に1000を掛けて行くようにしただけですが、これでいいのかしら…
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package main import "fmt" const ( KB = 1000 MB = KB * KB GB = MB * KB TB = GB * KB PB = TB * KB EB = PB * KB ZB = EB * KB YB = ZB * KB ) func main() { fmt.Println(KB, MB, GB, TB, PB, EB) //, ZB, YB) } |
const宣言では型に結びついていない定数を定義することができて、その場合は基本型の値より遥かに高い数値精度を表現することができます。
前節で Zib や YiB は定数にそのまま代入しようとしたり、ｆｍｔ．Ｐｒｉｎｔｌｎで表示しようとするとオーバーフローを起こしてエラーになっていましたが、次のように式に使うことが可能です。
|
1 |
fmt.Println(YiB / ZiB) |
また変数や定数に代入するときには明示的な変換を必要しません。
ただし、変数に代入したあとに精度の違う変数に使いたい場合は型変換が必要となります。
|
1 2 |
const Pi64 float64 = math.Pi var x float32 = float32(Pi64) |
さて、、、ようやく基本データ型の章が終わりました。
この投稿も結構なボリュームになりましたが、書籍もかなりボリュームがあります。
もちろん基本中の基本な章なのでしっかり抑えておくことが大事だと思います。
2016/08/31
丸善出版の『プログラミング言語Go』の読書履歴です。
出てきた内容の気になったポイントのまとめや練習問題の解答（自分なりの）を記載していきます。
（ここに記載されている内容で問題が生じても責任は負えませんのであしからず…。）
この章では主に変数やパッケージ、スコープについての説明になります。
練習問題があまりないので、各節の気になったポイントを書いていこうと思います。
2.1 名前
2.2 宣言
2.3 変数
2.4 代入
2.5 型宣言
2.6 パッケージとファイル
2.7 スコープ
Go言語では大文字小文字は区別されるので、heapSort と Heapsort は異なる名前になります。
(大抵の言語はそうですけど。)
最初の文字が大文字が小文字かでパッケージ外から見えるかどうかが変わって、大文字だとパッケージ外からアクセス可能になります。
他の言語だと関数名の先頭は小文字っていうのが多いので fmt.Println() とか大文字で始まるのが気持ち悪いなぁと思っていたのですが、なるほどこういうことなのですね。
なので他言語でよく見られる public や private と言ったキーワードがないようです。
関数内で宣言されたローカルなので関数内でしか使えませんが、関数外で宣言された変数はそのパッケージ内からは使うことができます。
宣言において重要なものが4種類あって、それは var、const、type、funcで、それぞれ変数、定数、型、関数ですね。
変数はvarを使って定義して、初期値を設定します。基本構文は以下になります。
|
1 |
var name type = expression |
具体的に書くこんな感じ。
|
1 |
var s string = "hello!" |
type か expression の部分を省略することができます。
type が省略されたときは、初期値によって型が決まります。(型推論ですね)
expression が省略された場合はその方に対するゼロ値になります。
数値なら0、真偽値ならfalse、文字列なら””、インタフェースと参照型はnilと言った具合です。
単一宣言で複数の変数を宣言することができて、初期値を宣言時に設定する場合はデータ型が異なっていてもOKです。
|
1 2 |
var i, j, k int var b, f, s = true, 2.3, "hoge" |
ローカル変数を宣言して初期化するときに省略変数宣言を使うことができます。
|
1 |
name := expression |
チュートリアルで sep := " " とか出てきてなんだろうと思っていたのですが、ようやく納得ですｗ
宣言時に初期値を設定しない場合や明示的な型の宣言が必要な場合は var を使います。
諸略変数宣言ですが、複数の変数でもOKで、同じように := を使います。
|
1 |
i, j := 0, 1 |
便利だからと言って多用し過ぎると可読性が落ちてしまうので、ローカル内でそれほど使われないというような変数のみにしたほうがよさそうですね。
おぉ。ポインタ。C/C++以外ではポインタって用語を使う言語が少ないので、ちょっと身構えてしまいますね。
(もともとC/C++プログラマなんですけど、私ｗ)
C/C++のポインタとほぼ同じような考え方です。
ポインタを指す場合は & を使って、ポインタの中身を取り出すときは * を使います。
|
1 2 3 |
x := 1 p := &x *p = 2 |
このようなソースの場合は p は x のポインタ(変数のアドレス)が格納されているので、*p とするとポインタの中身を書き換えるので、x も書き換わります。
うん、C/C++と同じですね。
変数を作成する別の方法として ｎｅｗ 関数があります。
変数名を付ける必要がないときなどに便利そうです。
すごく単純な例ですけど、こういう使い方ができるようです。
|
1 2 3 |
func newInt() *int { return new(int) } |
変数は到達不可能になるまで存在し続け、その後はそのメモリ領域は再利用されるかもしれない、というお話ですね。
ただ、ガベージコレクションが基本的にやってくれるので、そこまで神経質に考える必要はないけれど少し頭に入れておくのはいいとは思います。
代入するには = を使えばOKです。これまでにも出てきていますが。
+=、*=などや++、--も使えます。
タプル代入では複数の変数に一度に代入ができます。
以下のような2つの変数の値を交換するという使い方もできます。
|
1 |
x, y = y, x |
今までにも出てきたような関数から複数の値を受け取るようなものもタプル代入ですね。
|
1 |
f, err = os.Open("hoge.txt") |
Go言語は使われない変数を定義することができないので、複数値を返す関数の1つの値しか使わない、という場合には ブランク識別子 _ (アンダースコア) を指定することで安全に破棄してくれるようになります。
例えば、io.Copy() はコピーしたバイト数とエラー値を返しますが、バイト数がいらない場合はブランクにしてあげればOKです。
|
1 |
_, err = ｉｏ.Copy(dst, src) |
暗黙的に発生する代入があり、例えば、関数は引数をパラメータ変数に暗黙的に代入するというようなお話ですね。
あとはスライスの初期値の設定なんかもそういうことらしいです。
型によっても変わってくるので、あとの章で説明があるようです。
もともと用意されている型はいろいろありますが、type宣言をすると既存の方と同じ基底型を持つ新しい型を作ることができます。
構文はこのようになります
|
1 |
type name underlying-type |
たとえば、長さの単位毎に型を作って見るとすると以下のようになります。
|
1 2 |
type Meter float64 type Feet float64 |
どちらもflota64を基底型としていますが、まったく別の型として使うことができます。
typeも名前の先頭を大文字で書くとパッケージ外からも使うことができるようになります。
今までもなんとなく書いてきたpackageについてです。
他の言語と同じように名前空間として機能があって、同じ関数名がバッティングしないようにするために使います。
構文は次のようになります。
|
1 |
package name |
同じパッケージに属しているファイルであれば、パッケージ名を使うことなく関数や変数を使うことができます。
さて、この章では初めても練習問題です。
書籍の本文に記載されている摂氏、華氏の変換モジュールに絶対温度との変換も追加しなさい、というようなものですね。
とりあえずこんな感じでいいかな、と…
exportedな関数にドックコメントをつけていないとwarningが出てしまいますが、とりあえず面倒なので入れていません(汗)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
<div class="filename">tempconv.go</div> package tempconv import "fmt" type Celsius float64 type Fahrenheit float64 type Kelvin float64 const ( AbsoluteZeroC Celsius = -273.15 FreezingC Celsius = 0 BoilingC Celsius = 100 ) func (c Celsius) String() string { return fmt.Sprintf("%g°C", c) } func (f Fahrenheit) String() string { return fmt.Sprintf("%g°F", f) } func (k Kelvin) String() string { return fmt.Sprintf("%g°K", k) } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<div class="filename">conv.go</div> package commonconv func CToF(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) } func FToC(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) } func CToK(c Celsius) Kelvin { return Kelvin(c + 273.15) } func FToK(f Fahrenheit) Kelvin { return Kelvin(5/9*(f-32) + 273.15) } func KToC(k Kelvin) Celsius { return Celsius(k - 273.15) } func KToF(k Kelvin) Fahrenheit { return Fahrenheit(5/9*(k-32) + 273.15) } func FtToM(ft Feet) Meter { return Meter(ft / 3.2808) } func MToFt(m Meter) Feet { return Feet(m * 3.2808) } func KgToP(kg Kilogram) Pound { return Pound(kg * 0.454) } func PToKg(p Pound) Kilogram { return Kilogram(p / 0.454) } |
パッケージを作ったら、使う場合はインポートをしてあげなければいけません。
今までも fmtやstringsなどなどいろいろとインポートしていたのも同様ですね。
パッケージ名とフォルダ名は一致させておいたほうがいいようです。
なぜならば、インポートで指定するのはフォルダ名なんですよね。
というわけで、私はGOPATHで指定したパスのsrcフォルダのなかに、lessons というフォルダを作っていその中に書籍のソースや練習問題を入れています。
なので、前節のソースコードは ＄GOPATH/lessons/ch2/tempconv というフォルダに入れてあります。
このｔｅｍｐｃｏｎｖをインポートする場合は下記のように指定してあげればOKです。
＄GOPATH/src 以下のパスを指定しないと、標準パッケージを見に行こうとするので、独自パッケージの場合はパスの指定が必要なようです。
|
1 |
import "lessons/ch2/tempconv" |
こうすると、標準パッケージと同じように tempconv.FToC というように書けるわけです。
さてさて、練習問題ですね。
main.goでコマンドライン引数がない場合は、オプションと値を入力してもらうようにしています。
それから、コマンドライン引数の場合は flag を使ってオプションと値を取るようにしました。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
<div class="filename">main.go</div> package main import ( "bufio" "flag" "fmt" "lessons/ex2/2_2/commonconv" "os" "strconv" ) func main() { if len(os.Args) <= 1 { input := bufio.NewScanner(os.Stdin) fmt.Println("種類を入力してください(温度=t, 長さ=h, 重さ=w)") option := "" value := 0.0 for input.Scan() { option = input.Text() break } fmt.Println("数値を入力してください") for input.Scan() { value, _ = strconv.ParseFloat(input.Text(), 64) break } printConv(option, value) } else { t := flag.Float64("t", -0.0, "temperature") h := flag.Float64("h", -0.0, "height") w := flag.Float64("w", -0.0, "weight") flag.Parse() if *t != -0.0 { printConv("t", *t) } if *h != -0.0 { printConv("h", *h) } if *w != -0.0 { printConv("w", *w) } } } func printConv(option string, value float64) { switch option { case "t": f := commonconv.Fahrenheit(value) c := commonconv.Celsius(value) fmt.Printf("%s = %s, %s = %s\n", f, commonconv.FToC(f), c, commonconv.CToF(c)) case "w": p := commonconv.Pound(value) kg := commonconv.Kilogram(value) fmt.Printf("%s = %s, %s = %s\n", p, commonconv.PToKg(p), kg, commonconv.KgToP(kg)) case "h": ft := commonconv.Feet(value) m := commonconv.Meter(value) fmt.Printf("%s = %s, %s = %s\n", ft, commonconv.FtToM(ft), m, commonconv.MToFt(m)) } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
<div class="filename">commonconv/common_conv.go</div> package commonconv import "fmt" type Celsius float64 type Fahrenheit float64 type Kelvin float64 type Feet float64 type Meter float64 type Kilogram float64 type Pound float64 const ( AbsoluteZeroC Celsius = -273.15 FreezingC Celsius = 0 BoilingC Celsius = 100 ) func (c Celsius) String() string { return fmt.Sprintf("%g°C", c) } func (f Fahrenheit) String() string { return fmt.Sprintf("%g°F", f) } func (k Kelvin) String() string { return fmt.Sprintf("%g°K", k) } func (ft Feet) String() string { return fmt.Sprintf("%gft", ft) } func (m Meter) String() string { return fmt.Sprintf("%gm", m) } func (kg Kilogram) String() string { return fmt.Sprintf("%gkg", kg) } func (p Pound) String() string { return fmt.Sprintf("%glbs", p) } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<div class="filename">commonconv/conv.go</div> package commonconv func CToF(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) } func FToC(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) } func CToK(c Celsius) Kelvin { return Kelvin(c + 273.15) } func FToK(f Fahrenheit) Kelvin { return Kelvin(5/9*(f-32) + 273.15) } func KToC(k Kelvin) Celsius { return Celsius(k - 273.15) } func KToF(k Kelvin) Fahrenheit { return Fahrenheit(5/9*(k-32) + 273.15) } func FtToM(ft Feet) Meter { return Meter(ft / 3.2808) } func MToFt(m Meter) Feet { return Feet(m * 3.2808) } func KgToP(kg Kilogram) Pound { return Pound(kg * 0.454) } func PToKg(p Pound) Kilogram { return Kilogram(p / 0.454) } |
パッケージの初期化処理は func init() {...} という特殊な関数を使うことができます。
変数の初期化程度なら、パッケージレベルで行えばいいのですが、処理が複雑になってくるとそれも難しいので、そういうときに init() を使うといいようです。
他の言語のクラスのコンストラクタのようなものですね。最初に必ず実行されます。
単一式ではなくループってことなので、こんなかんじ？
性能比較はやっていません…。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package popcount var pc [256]byte func init() { for i := range pc { pc[i] = pc[i/2] + byte(i&1) } } func PopCount(x uint64) int { count := 0 for i := 0; i < 8; i++ { count += int(pc[byte(x>>(uint(i)*8))]) } return count } |
ビットシフトしながらということなので、こんな感じでしょうか…。
PopCount（）のみ書き出しています。他の部分は練習問題2.3と同じです。
|
1 2 3 4 5 6 7 |
func PopCount(x uint64) int { count := 0 for i := 0; i < 64; i++ { count += int(x>>uint(i)) & 1 } return count } |
式x&(x-1) は最下位ビットをクリアする、という事実を使ってビット数を求める、ということで自身が無いですが、こんな感じで…
とりあえずは動いてます。
|
1 2 3 4 5 6 7 8 9 10 |
func PopCount(x uint64) int { count := 0 for x > 0 { if x != x&(x-1) { count++ x = x & (x - 1) } } return count } |
宣言された変数などを参照できる範囲についての説明です。
ブロックは関数やループを囲んでいる {} で囲われた一連の文のことになります。
ブロック内で宣言された変数などはブロック外からは見えません。
具体的な例を出しながら説明されているので、実際に動かしながら見てみるとわかりやすいと思います。
ここでは練習問題はなし！わーいｗ
2章から結構ボリュームあるなぁ、読み応えあるなぁ、という印象です。
3章は基本データ型について。ここも結構ボリューミィな感じなので、がんばります。
2016/08/10
なんとなく自宅学習しようと思って、丸善出版の『プログラミング言語Go』を買ってみました。
(正確には旦那様に買ってもらった、ですが)
せっかくなので、感想とか練習問題の解答とかを書いて行こうと思います。
最後まで続くといいですねぇ。。。
Goのインストールや開発環境の構築は終わっているものとして話を進めます。
ちなみに私は Atom エディタとターミナルで学習してます。
1.1 ハロー、ワールド
1.2 コマンドライン引数
1.3 重複した行を見つける
1.4 GIFアニメーション
1.5 URLから取得
1.6 URLからの並列な取得
1.7 ウェブサーバ
1.8 残りの項目
ご存知、ハローワールド。
＊書籍がカタカナで書いているので、それに習ってます。
以前旦那様がハローワークを見て、「あぁ、ハローワールドがあるんだねぇ」とつぶやいたくらい
エンジニア的にはお馴染みのワードですね。
細かいことはあとから説明があると思うので、とにかく本に書いてあるコードを写経します。
|
1 2 3 4 5 6 |
package main import "fmt" func main() { fmt.Println("Hello, 世界") } |
「Hello, 世界」って斬新だなぁ、とか思ったりもしますが、日本語版の書籍だからですかね。
そんなこんなで実行してみましょう。
このソースの動作確認をするには以下のコマンドを実行します。
|
1 |
$ go run helloworld.go |
Go言語はコンパイル言語なので、指定されたソースファイルをコンパイルして、ライブラリとリンクして、実行ファイルを生成して、それを実行する、というのを run は一度にやってくれるようです。
もちろんコンパイルとリンクをして実行ファイルを作る方法もあって、以下のコマンドを実行します。
|
1 |
$ go build helloworld.go |
そうすると同じディレクトリに「helloworld」というファイルが作られるので、これを実行するには
|
1 |
$ go ./helloworld |
としてあげます。
run の場合も、build した実行ファイルから実行した場合も
|
1 |
Hello, 世界 |
と表示されるはずです。
Go言語は Unicode を扱うので、日本語も化けることなくきちんと表示されますねー。
この章は練習問題はないので次へ！
この章ではコマンドライン引数の取り方のチュートリアルになっています。
コマンドライン引数は os.Args 取得できます。
os.Args は文字列のスライスです。
スライスはここでは動的に大きさを決めることができる配列だと思っておけばいいでしょう。
スライスの要素にアクセスするには、os.Args[0] と言ったようにJavaなどの他の言語と同じように添字を指定しればOKです。
0番目の要素にはコマンド自身の名前が入ってきて、それ以降の要素がコマンドライン引数になります。
まあ、、、スライスの説明はあとの章で詳しく出てくるようなので、ここではコマンドライン引数の取り方を覚えておけばいいと思います。
書籍に載っているソースコードはここで記載してもしょうがないと思うので、省略します。
というわけで練習問題の解答を…（間違ってても苦情は受け付けません…ｗ）
コマンド名も表示されるようにするという問題なので、単純に for のカウンタを 0 からにしてみました。単純すぎ…？
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package main import ( "fmt" "os" ) func main() { var s, sep string for i := 0; i < len(os.Args); i++ { s += sep + os.Args[i] sep = " " } fmt.Println(s) } |
個々の引数のインデックスと値を1行毎に表示する、ということなので、単純に fmt.Println() で index と arg を表示するように修正しました。
不要になったソースも削除しています。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package main import ( "fmt" "os" ) func main() { for index, arg := range os.Args[1:] { fmt.Println(index, arg) } } |
ベンチマークテストをしろってことなのですが、必要となる知識はこのあとの説明になるのようなので、今回は飛ばします…
知識を得たら再度チャレンジするということにします(汗)
チュートリアルだからなのか、変数の定義の仕方とか、メソッドの使い方とか、そのへんはあまり言及されていないので、ちょっとわからなくなることがありますが、とりあえずいまのところは、そんなものなんだろう、程度にとどめて先に進めることにします。
この節では、if文、for文、map、標準入力からの読み込みやファイル入出力などの使い方について説明されています。
C言語でお馴染みのfprintfに似た、Fprintfなんかも出てきて、書式指定子なども出てきます。
Go言語ではヴァーブ(verb)って呼ぶようですね。
詳しい説明は書籍を読んでもらうこととして、練習問題をやってみたいと思います。
ファイル読み込みで、重複した行のそれぞれが含まれていた全てのファイルの名前を表示するようにする。
私はファイル名の保存用にもう一つ map を追加して、行をキーとして、さらに map ファイル名を追加していく、という流れにしました。
最後にスラッシュ区切りでファイル名を並べた文字列を作成して、重複行と一緒に表示しています。
多重の map にしたので初期化の仕方で手間取ったりもしましたが、一応こんな感じでいいのかな、と…ｗ
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
package main import ( "bufio" "fmt" "os" ) func main() { filenames := make(map[string]map[string]int) counts := make(map[string]int) files := os.Args[1:] if len(files) == 0 { countLines(os.Stdin, counts, filenames) } else { for _, arg := range files { f, err := os.Open(arg) if err != nil { fmt.Fprintf(os.Stderr, "dup2: %v\n", err) continue } countLines(f, counts, filenames) f.Close() } } for line, n := range counts { if n > 1 { names, sep := "", "" for name := range filenames[line] { names += sep + name sep = "/" } fmt.Printf("%d\t%s\t%s\n", n, line, names) } } } func countLines(f *os.File, counts map[string]int, filenames map[string]map[string]int) { input := bufio.NewScanner(f) for input.Scan() { str := input.Text() counts[str]++ if filenames != nil { if filenames[str] == nil { filenames[str] = make(map[string]int) } filenames[str][f.Name()]++ } } } |
この節ではGo言語の標準画像パッケージの基本的な使い方のチュートリアルになっています。
リサージュ図形というGIFアニメーションを作成するのですが、動いた時はちょっと感動しますｗ
ここでは、const宣言や構造体型なども出てきますが、詳しくはあとの章で出てくるので、ここではさらっとこんなものもあるという程度にど止めておくのがいいかと思います。
では、練習問題の解答を…
リサージュプログラムの背景を黒として、線を緑になるように修正する、というものです。
書籍にRGBでのカラーの作成方法は載っています。緑なので、#00FF00 で作っています。
paletteの０番目が背景色、１番目が線色なので、その順番に黒、緑と指定しています。
修正点はそこだけだったと思います。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
package main import ( "image" "image/color" "image/gif" "io" "math" "math/rand" "os" "time" ) var palette = []color.Color{color.Black, color.RGBA{0x00, 0xff, 0x00, 0xff}} const ( whiteIndex = 0 blackIndex = 1 ) func main() { rand.Seed(time.Now().UTC().UnixNano()) lissajous(os.Stdout) } func lissajous(out io.Writer) { const ( cycles = 5 res = 0.001 size = 100 nframes = 64 delay = 8 ) freq := rand.Float64() * 3.0 anim := gif.GIF{LoopCount: nframes} phase := 0.0 for i := 0; i < nframes; i++ { rect := image.Rect(0, 0, 2*size+1, 2*size+1) img := image.NewPaletted(rect, palette) for t := 0.0; t < cycles*2*math.Pi; t += res { x := math.Sin(t) y := math.Sin(t*freq + phase) img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blackIndex) } phase += 1.0 anim.Delay = append(anim.Delay, delay) anim.Image = append(anim.Image, img) } gif.EncodeAll(out, &anim) } |
リサージュプログラムを修正して、paletteに色をもっと追加して、複数の色で画像を生成しなさい、というものです。
paletteには赤、青、緑を追加しています。
SetColorIndex の代３引数を変更して、ということだったので、paletteの１〜３の色を使って順に色が変わるようにしてみました。
これでいいのかな…。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
package main import ( "image" "image/color" "image/gif" "io" "math" "math/rand" "os" "time" ) var palette = []color.Color{color.White, color.RGBA{0xff, 0x00, 0x00, 0xff}, color.RGBA{0x00, 0xff, 0x00, 0xff}, color.RGBA{0x00, 0x00, 0xff, 0xff}} const ( whiteIndex = 0 blackIndex = 1 ) func main() { rand.Seed(time.Now().UTC().UnixNano()) lissajous(os.Stdout) } func lissajous(out io.Writer) { const ( cycles = 5 res = 0.001 size = 100 nframes = 64 delay = 8 ) freq := rand.Float64() * 3.0 anim := gif.GIF{LoopCount: nframes} phase := 0.0 for i := 0; i < nframes; i++ { rect := image.Rect(0, 0, 2*size+1, 2*size+1) img := image.NewPaletted(rect, palette) for t := 0.0; t < cycles*2*math.Pi; t += res { x := math.Sin(t) y := math.Sin(t*freq + phase) img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), uint8(i)) } phase += 1.0 anim.Delay = append(anim.Delay, delay) anim.Image = append(anim.Image, img) } gif.EncodeAll(out, &anim) } |
この節ではHTTPを使って情報を取得する簡単なチュートリアルになっています。
引数で渡されたURLからHTMLを取得する、といったものです。
http.Get(url)で取得できちゃうので、すごく簡単ですね。
というわけで、練習問題を…。
ioutil.ReadAll の代わりに io.Copy を使いなさい、というものです。
io.Copy の使い方とかいろいろ調べたりして時間がかかりましたが、問題をきちんと読んでからやれば簡単でした…。
基本的には ioutil.ReadAll を io.Copy に置き換えただけなのですが、io.Copy の出力先を os.Stdout にしてあげればOKです。
エラーは取らないといけないので、戻り値は _, err にする必要があります。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
package main import ( "fmt" "io" "net/http" "os" ) func main() { for _, url := range os.Args[1:] { resp, err := http.Get(url) if err != nil { fmt.Fprintf(os.Stderr, "fetch: %v¥n", err) os.Exit(1) } _, err = io.Copy(os.Stdout, resp.Body) resp.Body.Close() if err != nil { fmt.Fprintf(os.Stderr, "fetch: reading %s: %v\n", url, err) os.Exit(1) } fmt.Printf("%v", os.Stdin) } } |
コマンドライン引数で渡される url に http://がなければ追加する、というものです。
strings.HasPrefix が使えるというヒントが載っているので、そちらを使ってみます。
引数を取得したところで、http:// があるかないか判定をして、なければ追加するようにしています。
ハードコードしてますが、許してください…ｗ
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package main import ( "fmt" "io" "net/http" "os" "strings" ) func main() { for _, url := range os.Args[1:] { if !strings.HasPrefix(url, "http://") { url = "http://" + url } resp, err := http.Get(url) if err != nil { fmt.Fprintf(os.Stderr, "fetch: %v¥n", err) os.Exit(1) } _, err = io.Copy(os.Stdout, resp.Body) resp.Body.Close() if err != nil { fmt.Fprintf(os.Stderr, "fetch: reading %s: %v\n", url, err) os.Exit(1) } fmt.Printf("%v", os.Stdin) } } |
さて、最後の練習問題。この節は問題が多くて辛いですｗ
resp.Status に設定されている HTTP ステータスコードも表示するように、というものです。
何か問題の意味を履き違えているかもしませんが、とりあえず表示する処理を最後に追加しています。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package main import ( "fmt" "io" "net/http" "os" "strings" ) func main() { for _, url := range os.Args[1:] { if !strings.HasPrefix(url, "http://") { url = "http://" + url } resp, err := http.Get(url) if err != nil { fmt.Fprintf(os.Stderr, "fetch: %v/n", err) os.Exit(1) } _, err = io.Copy(os.Stdout, resp.Body) resp.Body.Close() if err != nil { fmt.Fprintf(os.Stderr, "fetch: reading %s: %v\n status: %s\n", url, err, resp.Status) os.Exit(1) } fmt.Printf("%v\n%s\n", os.Stdin, resp.Status) } } |
ここでは並列プログラミングについてのチュートリアルになります。
Go言語の並列処理を行うゴルーチンとチャネルについて簡単に触れられていますが、詳しくはあとの章で説明されるようなので、ここではこんなふうに使えるんだ、くらいにとどめておくのがいいと思います。
fetchall プログラムの出力をファイルに保存するように修正しなさい、というものです。
特にヒントも書いていないので、file.Write を使ってみましたが、もっと簡単に書ける方法はないのかしら…。
これで一応、同じ内容が log.txt というファイルに保存されるようになります。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
package main import ( "fmt" "io" "io/ioutil" "net/http" "os" "time" ) func main() { start := time.Now() ch := make(chan string) for _, url := range os.Args[1:] { go fetch(url, ch) } for range os.Args[1:] { fileWrite(([]byte)(<-ch)) } content := fmt.Sprintf("%.2fs elapsed", time.Since(start).Seconds()) fileWrite(([]byte)(content)) } func fetch(url string, ch chan<- string) { start := time.Now() resp, err := http.Get(url) if err != nil { ch <- fmt.Sprint(err) return } nbytes, err := io.Copy(ioutil.Discard, resp.Body) resp.Body.Close() if err != nil { ch <- fmt.Sprintf("while reading %s: %v", url, err) return } secs := time.Since(start).Seconds() ch <- fmt.Sprintf("%.2fs %7d %s", secs, nbytes, url) } func fileWrite(content []byte) { file, err := os.OpenFile("log.txt", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644) if err != nil { fmt.Printf("file open: %v", err) return } defer file.Close() file.Write(([]byte)(content)) file.Write(([]byte)("\n")) } |
簡単なウェブサーバの作り方のチュートリアルです。
なんか、すごく少ないコード量で動いてしまうので驚きました。
バックグランドでプログラムを起動させる方法が載っているので、以下のコマンドのように & を付けて起動します。
|
1 |
$ go run server1/main.go & |
この後にサーバーを終了しないといけないの、その手順を。(旦那様には常識だって言われたけど…)
まず、起動時に以下のような数字が表示されます。これはプロセス番号になっています。
|
1 |
[1] 13710 |
色々動かしたあとですでに起動時のログが見つからない、という場合は以下のコマンドを打ってください。
|
1 |
ps |
そうすると、現在起動されているプロセスの一覧が表示されます。
|
1 2 3 4 |
PID TTY TIME CMD 419 ttys000 0:00.64 -bash 10333 ttys001 0:00.08 /bin/bash --login 13710 ttys001 0:00.19 go run server1/main.go |
もっとたくさんあるかもしれませんが、一覧の中から自分が起動したアプリがあるはずなので、先頭に記載されている PID の部分がプロセス番号になります。
で、そのプロセス番号を使って、kill します。
|
1 |
kill 13710 |
これだけだとまだlocalhost:8000にアクセスできてしまうので、次のコマンドを打って、8000ポートを使っているプロセスを探します。
|
1 |
lsof -i:8000 |
8000ポートを使っているプロセスの一覧が表示されます。
|
1 2 |
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME main 13713 user_name 5u IPv4 0xa354a7c2d7be9639 0t0 TCP localhost:irdmi (LISTEN) |
ここで main と書いてあるのが、今起動しているプログラムで、PID はプロセス番号になります。
なので、このプロセス番号を使って再度 kill します。
|
1 |
kill 13713 |
これでようやく全部のプロセスが終了するので、改めてプログラムを起動することができます。
が、、、面倒なので、バックグランドで起動させずに通常起動させて、Ctrl + C で終了させたほうがラクだと思います。
書籍では1.6 URLからの取得で作成した fetch プログラムと合わせて使うためにバックグランドで起動しているようですが、もうひとつターミナルを起動すればいいだけなので、通常起動のほうがなにかと便利かと思います。たぶん…。
文中でリエージュ図形と組み合わせるプログラムを書くのですが、それの修正になります。
リエージュ図形のソース部分は 1.4 GIFアニメーション で作ったものを流用しています。
パラメータを取得して、それを使ってリエージュ図形を変える、という感じです。
cyclesをパラメータで取得して、lissajous()に渡すように変更しました。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
package main import ( "image" "image/color" "image/gif" "io" "log" "math" "math/rand" "net/http" "strconv" ) func main() { handler := func(w http.ResponseWriter, r *http.Request) { if err := r.ParseForm(); err != nil { log.Print(err) } cycles := 5 for k, v := range r.Form { if k == "cycles" { cycles, _ = strconv.Atoi(v[0]) } } lissajous(w, cycles) } http.HandleFunc("/", handler) log.Fatal(http.ListenAndServe("localhost:8000", nil)) } var palette = []color.Color{color.White, color.Black} const ( whiteIndex = 0 blackIndex = 1 ) func lissajous(out io.Writer, cycles int) { const ( // cycles = 5 res = 0.001 size = 100 nframes = 64 delay = 8 ) freq := rand.Float64() * 3.0 anim := gif.GIF{LoopCount: nframes} phase := 0.0 for i := 0; i < nframes; i++ { rect := image.Rect(0, 0, 2*size+1, 2*size+1) img := image.NewPaletted(rect, palette) for t := 0.0; t < float64(cycles)*2*math.Pi; t += res { x := math.Sin(t) y := math.Sin(t*freq + phase) img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blackIndex) } phase++ anim.Delay = append(anim.Delay, delay) anim.Image = append(anim.Image, img) } gif.EncodeAll(out, &anim) } |
この節はswitch、名前付き型、ポインタ、メソッドとインタフェース、パッケージ、コメントについての簡単な説明になっています。
基本的には読み物で、ソースコードも記載されていますが、実際に書いて動かく必要はないかな、という感じです。
どれもこのあとの章で詳しく説明があると思うので、さらっと流してしまうのがいいでしょう。
この章は練習問題はないので、ここまで！
ようやくチュートリアルが終わりました…。地味に難しかったです、練習問題(汗)
さて、次は第2章 プログラム構造です。変数やパッケージ、スコープなどの説明が出てくるようです。
練習問題もちょくちょくあるようなので、がんばります…ｗ
当たり前ですが細かい説明は書籍を読んでくださいね。