今回は、Go言語の関数について学びます。
<目次>
関数の意義
そもそも関数って何の為にあるの？
プログラム言語には必ず「関数」という概念が存在ます。どのような形であれ、私たちはこの「関数」をプログラムを構成する「パーツ」として作成し、プログラム処理の中の至る所で呼び出します。
その為、関数を作成する意義は、「再利用性」にあると私は考えています。
例えば、関数を”使用していない“次のサンプルコードを見てください。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import "fmt" func main() { var width, height, area float64 // Define 1 width = 4.2 height = 3.0 area = width * height fmt.Printf("%.2f liters needed\n", area/10.0) // Define 2 width = 5.2 height = 3.5 area = width * height fmt.Printf("%.2f liters needed\n", area/10.0) } |
このプログラムは、問題なく動作します。
|
1 2 3 4 |
$ go run main.go 1.26 liters needed 1.82 liters needed |
しかし、コードの重複が目立ちます。
この重複を関数に置き換えて、削除するとスッキリしそうです。
関数の作成
関数を作成するにはどうすればいいのかな？
Go言語で関数を作成するには、funcキーワードを使用します。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// 引数なしパターン func run() { fmt.Println("Dog is running") } // 引数あり、戻り値なしパターン func run(name string) { fmt.Printf("%s is running", name) } // 引数あり、戻り値ありパターン func run(name string) string { fmt.Printf("%s is running", name) return "OK" } |
私が推奨しているPythonの書き方も合わせて載せておきます。
|
1 2 |
def run(): print('Dog is running') |
Go言語はご覧の通り、中括弧({})で関数の処理を包み込みます。この書き方は、javaScriptやPHPと同じであるため、多くの開発者には馴染みがあるでしょう。
関数の命名規則は、変数の命名規則と同じです。
・名前の先頭は、文字で始める(数字不可)
・名前の先頭大文字 -> 外部ファイルからの参照可
・名前の先頭小文字 -> 同一パッケージ内のみ参照可
・キャメルケースを推奨(例: func runTogether(){})
例をあげて見ましょう。
|
1 2 3 4 5 6 7 8 9 |
// ok double addPart Publish // not ok 2times //数値からは ng addpart // 大文字でないと他のパッケージから参照できない(privateで扱いたいときは、ok) ports.publish // 先頭大文字(publish)でないと他パッケージから参照できない |
やってみよう
サンプルコードを重複無しの状態にしてみてください。
改修したサンプルコードを載せておきます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
package main import "fmt" func paintNeeded(width float64, height float64) { area := width * height fmt.Printf("%.2f liters needed\n", area/10.0) } func main() { paintNeeded(4.2, 3.2) paintNeeded(3.5, 9.3) paintNeeded(3.2, 7.1) } |
|
1 2 3 4 5 |
go run main.go 1.34 liters needed 3.26 liters needed 2.27 liters needed |
関数で置き換えるとだいぶスッキリして見えますね。
PrintfとSprintf
先ほどのサンプルプログラムには、「%.2f」という記号のようなものが使用されていました。これは、Go言語のフォーマット整形関数の仕様にしたがって記述したフォーマットタイプです。
フォーマット整形関数には、「Printf」と「Sprintf」の2つの関数が存在します。
それぞれの使い方を見てみましょう。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "fmt" func main() { # Printf fmt.Printf("About one-third: %0.2f\n", 1.0/3.0) # Sprintf(フォーマット後のデータを変数に格納したい場合は、こちらを使う) resultString := fmt.Sprintf("About one-third: %0.2f\n", 1.0/3.0) fmt.Println(resultString) } |
この２つの関数は、実質「同じこと」をしています。
|
1 2 |
About one-third: 0.33 About one-third: 0.33 |
サンプルコードの中で使用されている%fは、引き取る変数のタイプによって以下のように変化します。
| フォーマットタイプ | 出力タイプ |
|---|---|
| %f | 浮動小数点 |
| %d | 整数 |
| %s | 文字列 |
| %t | True/False(boolean) |
| %v | 任意のタイプ |
| %#v | Goプログラムコードに表示される形式の任意の値 |
| %T | 引数のタイプ情報(int, stirng, etc…) |
実際にコードを見た方が、理解が早いかもしれませんね。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package main import "fmt" func main() { fmt.Printf("A float: %f\n", 3.1415) fmt.Printf("An integer: %d\n", 15) fmt.Printf("A string: %s\n", "Hello") fmt.Printf("A boolean: %t\n", false) fmt.Printf("Values: %v %v %v\n", 1.2, "\t", true) fmt.Printf("Values: %#v, %#v, %#v\n", 1.2, "\t", true) fmt.Printf("Types: %T %T %T\n", 1.2, "\t", true) fmt.Printf("Percent sign: %%\n") } |
|
1 2 3 4 5 6 7 8 |
A float: 3.141500 An integer: 15 A string: Hello A boolean: false Values: 1.2 true Values: 1.2, "\t", true Types: float64 string bool Percent sign: % |
%# は、単なる%よりも多くの情報を出力しますね。
|
1 2 3 4 5 6 7 8 |
package main import "fmt" func main() { fmt.Printf("%v %v %v", "", "\t", "\n") fmt.Printf("%#v %#v %#v", "", "\t", "\n") } |
|
1 2 |
// 何も出力されない "" "\t" "\n"$ // 出力される |
このフォーマットタイプは、出力文字数を指定して綺麗に整えることも可能です。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "fmt" func main(){ // %12s -> 12文字で埋める, %2d -> 2文字で埋める fmt.Printf("%12s | %s\n", "Important", "Time is Money") fmt.Println("-----------------------------") fmt.Printf("%12s | %2d\n", "Fast", 40) fmt.Printf("%12s | %2d\n", "Technic", 3) fmt.Printf("%12s | %2d\n", "More Hard", 57) } |
|
1 2 3 4 5 6 |
go run main.go Important | Time is Money ----------------------------- Fast | 40 Technic | 3 More Hard | 57 |
数値の制御も可能です。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "fmt" func main() { // %7.3fの7は、全体の数値の最小幅、.3は、小数点以下の幅 fmt.Printf("%%7.3f: %7.3f\n", 12.3456) fmt.Printf("%%7.2f: %7.2f\n", 12.3456) fmt.Printf("%%7.1f: %7.1f\n", 12.3456) #小数点のみ影響 fmt.Printf("%%.1f: %.1f\n", 12.3456) fmt.Printf("%%.2f: %.2f\n", 12.3456) } |
|
1 2 3 4 5 6 7 |
go run main.go %7.3f: 12.346 %7.2f: 12.35 %7.1f: 12.3 %.1f: 12.3 %.2f: 12.35 |
関数のスコープ
関数にもスコープが存在します。
例えば、下記の例では、paintNeeded関数内に宣言された「area」変数にmain関数からアクセスを試みていますが、コンパイルエラーになります。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "fmt" func paintNeeded(width float64, height float64) { area := width * height fmt.Printf("%.2f liters needed\n", area/10.0) } func main() { paintNeeded(4.2, 3.2) fmt.Println(area) } |
|
1 2 3 4 |
go run main.go # command-line-arguments ./main.go:12:14: undefined: area |
関数外から参照したい場合は、もっと上のレベルで変数を宣言する必要があります。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package main import "fmt" // Topレベルに宣言 var area float64 func paintNeeded(width float64, height float64) { area = width * height fmt.Printf("%.2f liters needed\n", area/10.0) } func main() { paintNeeded(4.2, 3.2) fmt.Println(area) } |
|
1 2 3 4 |
$ go run main.go 1.34 liters needed 13.440000000000001 |
関数の戻り値
関数には、戻り値を定義できます。()(丸括弧)の直後にあるタイプ(float64)が戻り値の型です。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
// float64の戻り値 func double(number float64) float64 { return number * 2 } // stringの戻り値 func double(number float64) string { if grade < 60.0 { return "Oh, That's too bad" } return "You are passing!" } |
関数の「return」キーワードで値を返却します。そして、return実行後、即座に関数から抜けます。
それじゃあ、returnの後に処理を書いても、無駄なんだ?
無駄というか、Go言語のコンパイラは賢いので、コンパイラエラーで教えてくれます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "fmt" func postIndexCapital(num float64) float64 { return num * 2 fmt.Println("Get Capital") # 処理を書きます } func main() { r := postIndexCapital(20.1) fmt.Println(r) } |
|
1 2 3 4 |
$ go run main.go # command-line-arguments ./main.go:8:1: missing return at end of function |
おお〜賢いね。こんなルールもあるんだ。
分からねえことにルールを探す。そのくっそ地道な努力を、化学って呼んでるだけだ(by Dr.STONE 千空)
話それますが、今アニメでやっているDr.STONE、面白くないですか？
千空氏の化学に向ける情熱、少しは見習いたいものです。
やってみよう
float64の戻り値を返すdouble関数を定義してみましょう。
サンプルを載せておきます。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "fmt" func double(num float64) float64 { return num * 2 } func main() { r := double(20.1) fmt.Println(r) fmt.Println(double(r)) } |
|
1 2 3 4 |
go run main.go 40.2 80.4 |
エラーを発生させる方法
知ってた？Go言語には、try-catch(except)構文がないのよ
そうなんです。Go言語には、try-catchと呼ばれる構文が存在しません。
代わりに、functionの戻り値に「error」オブジェクトを設定し、受け取った値が、errorかnilかで判定します。
エラーを発生させる方法の一つをご紹介します。
|
1 2 3 4 5 6 7 8 9 10 11 |
package main import ( "errors" "fmt" ) func main() { err := errors.New("Can't recieve negative number!!!") fmt.Println(err.Error()) } |
|
1 2 3 |
$ go run main.go Can't recieve negative number!!! |
ご覧の通り、エラーは、Errorパッケージ内で定義されています。
ちなみに、Printfみたいにフォーマットされた状態で出力することも可能です。
|
1 2 3 4 5 6 7 8 9 10 11 |
package main import ( "fmt" ) func main() { err := fmt.Errorf("Can't recieve negative %0.2f!!!", -10.45) fmt.Println(err.Error()) fmt.Println(err) } |
|
1 2 3 |
$ go run main.go Can't recieve negative -10.45!!! Can't recieve negative -10.45!!! |
では、エラーを関数に実装してみます。
|
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 |
package main import ( "errors" "fmt" "log" ) func returnErrorObject(num int) (string, error) { var err error var msg string if num < 10 { err = errors.New("Error happens now!!!!\n") msg = "I', sorry." return msg, err } else { msg = "Ok, You are safe!!!\n" } return msg, nil } func main() { msg, err := returnErrorObject(0) if err != nil { log.Fatal(err.Error()) } fmt.Println(msg) msg2, err := returnErrorObject(11) if err != nil { log.Fatal(err) } fmt.Println(msg2) } |
try-catchの方法の代わりに「if err !=nil」でエラーチェックします。
戻り値の型には、()(中括弧)の,(カンマ区切り)で指定していますが、引数と同様に名前をつけることもできます。
|
1 2 3 4 5 6 7 8 9 10 11 |
func returnErrorObject(num int) (message string, numerror error) { var err error var msg string if num < 10 { err = errors.New("Error happens now!!!!\n") msg = "I', sorry." } else { msg = "Ok, You are safe!!!\n" } return msg, err } |
とはいえ、戻り値に名前をつけてもプログラムが読みやすくなるわけでも、何かが便利になるわけでもありません。むしろ、つけないほうが多いです(私はつけてません)。
関数の引数の実態
関数の引数は、オリジナルからコピーされた値が渡されます。
…? どういうこと？
関数に引数が設定されていた場合、関数の呼び出しの際には、パラメータを渡す必要があります。その際に、パラメータはオリジナルから「コピーしたもの」を渡します。
Go言語は、基本的に値渡し(pass-by-value)の言語なのです。
多くの場合は値渡しでも問題ありませんが、バグを引き起こすことがあります。
具体例をお見せしましょう。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
package main import "fmt" func double(amount int) { amount *= 2 fmt.Printf("amount in double function is %d\n", amount) } func main() { amount := 6 double(amount) fmt.Printf("amount in main function is %d\n", amount) } |
このサンプルは、単純な計算プログラムです。main関数からdoubleパラメータに任意の数値を渡すとその数を2倍にします。
main関数で計算後の値を出力できれば、この関数は問題なく動作していることになります。
では、実行してみましょう。
|
1 2 3 4 |
$ go run main.go amount in double function is 12 amount in main function is 6 |
double関数内で出力したamountは意図した通り、「12」になりました。一方で、main関数内の出力したamountに関しては、「6」になっています。
本来であれば「12」が出力されて欲しいところですが、「オリジナルの値がコピーされたパラメータ」が関数に渡されただけなので、計算結果に反映されません。
この手のバグは、実際の現場でも発生しやすい「バグ」の一つです。テストコードの書き方を覚えて、ガンガン潰していくしかないです。
ポインタ
つまり…関数内で処理した値を呼び出し元で使いたいときは、戻り値として受け取るしかないってことよね？
実は、そうでもないのです。「ポインタ」を使えば、この問題は回避できます。
いよいよ「ポインタ」が出てきました。C言語を使っている人には馴染み深いかもしれないですね。
ポインタを説明する前に、まず変数についてもう少し詳しく説明します。
私たちがプログラム内で変数を定義したとき、メモリ上に保存領域を確保します。
この領域には、一つ一つ、「アドレス」がついており、メモリの位置情報がわかる様になっています。
Go言語では「&(アンパサンド)」を使うとこのアドレスを取得できるのです。
この説明だけでは、意味がわからないですよね？具体例を見ていきましょう。
サンプルプログラムを用意します。
|
1 2 3 4 5 6 7 8 9 10 11 |
package main import "fmt" func main() { address := 10 // 普通に出力 fmt.Println(address) // アドレスを出力 fmt.Println(&address) } |
|
1 2 3 4 |
$ go run main.go 10 // 変数の中身 0xc00007a008 // メモリ上のアドレス |
10を格納した変数addressのメモリ上のアドレスは、「0xc00007a008 」と出ました。
この事を頭に入れて、値渡しをしていたサンプルコードのアドレスを見てみましょう。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package main import "fmt" func double(amount int) { amount *= 2 fmt.Println("amount address in double function is :", &amount) fmt.Printf("amount in double function is %d\n", amount) } func main() { amount := 6 double(amount) fmt.Println("amount address in main function is :", &amount) fmt.Printf("amount in main function is %d\n", amount) } |
|
1 2 3 4 |
amount address in double function is : 0xc000088008 amount in double function is 12 amount address in main function is : 0xc000088000 amount in main function is 6 |
amount変数が、それぞれ違うアドレスを指していますね？つまり、「別物の変数」として扱われているという事です。アドレスは、変数の場所を指し示しているとも言えます。
アドレスって、現実で言うと住所みたいなものなんだ。東京都練馬区1丁目の佐藤さん宅、2丁目の鈴木さん宅、みたいな感じね。だから、値渡しした変数の中身は書き変わらないのね。
え、じゃあ、「アドレスを指定すれば」変数の書き換えは可能じゃないか？
その通りです。それを可能にするのが「ポインタ」なのです。
Go言語では、変数のアドレスを指し示す値をポインタと読んでいます。理由は、変数の場所を「指し示している」からです。
Pythonなどのスクリプト言語に馴染みのある方には、ポインタは聞き慣れない用語かもしれません。何故なら、私がそうでしたから！「変数のアドレスを差し示すもの、それはポインタ!」と上の画像と一緒に覚えておいてください。ポインタは、Go言語の中でも特に重要な概念の一つです。
ポインタタイプ
Go言語には、int, string, boolなど複数のタイプが存在します。ポインタのタイプには*(アスタリスク)シンボルがタイプの前に付与されます。
|
1 |
*int |
もしかしたら見慣れない表記かもしれませんが、「pointer to int」と何度か声に出して、読んでみてください。直ぐに慣れます。
サンプルプログラムでも確認して見ましょう。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package main import ( "fmt" "reflect" ) func main() { var myInt int fmt.Println(reflect.TypeOf(&myInt)) var myFloat float64 fmt.Println(reflect.TypeOf(&myFloat)) var myBool bool fmt.Println(reflect.TypeOf(&myBool)) } |
|
1 2 3 |
*int *float64 *bool |
確かに*がついてるね。だから何？って感じだけど
どうでもいいことに見えるかもしれませんが、実はこれは結構大切なのです。
次のサンプルを見てください。
|
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" ) func main() { var myInt int // intポインタを保持する変数 var myIntPointer *int // myIntのアドレスを格納 myIntPointer = &myInt fmt.Println(myIntPointer) // 同じ要領で、FLoat版を作成1 var myFloat float64 var myFloatPointer *float64 myFloatPointer = &myFloat fmt.Println(myFloatPointer) // 省略版 var myBool bool myBoolPointer := &myBool fmt.Println(myBoolPointer) } |
|
1 2 3 4 5 |
$ go run main.go 0xc00008a000 0xc00008a008 0xc00007a002 |
このサンプルでは、変数のアドレスをポインタタイプに格納しています。ポインタタイプでないと「変数のアドレスを格納できない」からです。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package main import ( "fmt" ) func main() { var myInt int // 普通の変数 var myIntPointer int // myIntのアドレスを格納 myIntPointer = &myInt // 普通の変数にアドレスは格納できない fmt.Println(myIntPointer) } |
|
1 2 3 |
$ go run main.go # command-line-arguments ./main.go:12:15: cannot use &myInt (type *int) as type int in assignment |
値の変更(by ポインタ)
なんだか、わかってきたわ。変数のアドレスを指し示しているのがポインタで、ポインタを扱うにはポインタタイプで変数を宣言しなくてはならないと。
待って！呼び出し元でアドレスを関数に渡し、呼び出し先の引数をポインタタイプにすれば、値の書き換えが可能になるんじゃないか？
!
一つ一つの仕組みを理解すると「応用が効く」ようになります。B男君は前回の発言を挽回できるほどのひらめきを見せてくれました。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package main import "fmt" // ポインタタイプで受け取る func double(amount *int) { *amount *= 2 fmt.Printf("amount in double function is %d\n", *amount) } func main() { amount := 6 double(&amount) fmt.Printf("amount in main function is %d\n", amount) } |
|
1 2 3 4 |
$ go run main.go amount in double function is 12 amount in main function is 12 |
計算結果が意図したものに変わりましたね？
素晴らしい。いや、そのアルキなんとかの知恵がじゃない。君のその、一歩一歩問題解決へと楔を打ち続ける、揺らがぬ信念がだよ(by コハク)
本日は、ここまでになります。プログラミング学習は、難しいし眠くなりますよね？Dr.STONEを読んでモチベーションをあげましょう。
参考書籍
次回
次回は、パッケージについて学びましょう^^
にほんブログ村
コメントを残す
コメントを投稿するにはログインしてください。