Goで変数と定数を使用する方法
変数は、習得するための重要なプログラミング概念です。 これらは、プログラムで使用している値を表す記号です。
このチュートリアルでは、作成するGoプログラム内でそれらを使用するためのいくつかの変数の基本とベストプラクティスについて説明します。
変数を理解する
技術用語では、変数は、シンボリック名または識別子に関連付けられた値に保管場所を割り当てています。 変数名を使用して、コンピュータープログラム内に保存されている値を参照します。
変数は、値に結び付ける名前が付いたラベルと考えることができます。
整数があるとしましょう、 1032049348
、そして長い数字を何度も何度も再入力するのではなく、変数に格納したいと思います。 これを実現するために、変数のように覚えやすい名前を使用できます i
. 値を変数に格納するには、次の構文を使用します。
i := 1032049348
この変数は、値に関連付けられているラベルのように考えることができます。
ラベルには変数名があります i
その上に書かれ、整数値に関連付けられています 1032049348
.
表現 i := 1032049348
は、いくつかの部分で構成される宣言および割り当てステートメントです。
- 変数名(
i
) - 短い変数宣言の割り当て(
:=
) - 変数名に関連付けられている値(
1032049348
) - Goによって推測されるデータ型(
int
)
次のセクションで、タイプを明示的に設定する方法については後で説明します。
一緒に、これらの部分は変数を設定するステートメントを構成します i
整数の値に等しい 1032049348
.
変数を値に設定するとすぐに、初期化するか、その変数を作成します。 これが完了すると、値の代わりに変数を使用できるようになります。
設定したら i
の値に等しい 1032049348
、使用できます i
整数の代わりに、それを印刷してみましょう:
package main
import "fmt"
func main() {
i := 1032049348
fmt.Println(i)
}
Output1032049348
また、変数を使用してすばやく簡単に計算を行うこともできます。 と i := 1032049348
、整数値を引くことができます 813
次の構文で:
fmt.Println(i - 813)
Output1032048535
この例では、Goが計算を行い、変数から813を減算します。 i
合計を返す 1032048535
.
数学と言えば、変数は数学の方程式の結果と等しく設定できます。 2つの数値を合計して、合計値を変数に格納することもできます。 x
:
x := 76 + 145
この例が代数に似ていることに気づいたかもしれません。 数式や数式内の数値や数量を表すために文字やその他の記号を使用するのと同じように、変数はデータ型の値を表す記号名です。 Go構文を正しくするには、変数が方程式の左側にあることを確認する必要があります。
先に進んで印刷しましょう x
:
package main
import "fmt"
func main() {
x := 76 + 145
fmt.Println(x)
}
Output221
値を返しました 221
変数が x
の合計に等しく設定されました 76
と 145
.
変数は、整数だけでなく、任意のデータ型を表すことができます。
s := "Hello, World!"
f := 45.06
b := 5 > 9 // A Boolean value will return either true or false
array := [4]string{"item_1", "item_2", "item_3", "item_4"}
slice := []string{"one", "two", "three"}
m := map[string]string{"letter": "g", "number": "seven", "symbol": "&"}
これらの変数のいずれかを出力すると、Goはその変数と同等のものを返します。 文字列の代入ステートメントを操作してみましょう slice
データ・タイプ:
package main
import "fmt"
func main() {
slice := []string{"one", "two", "three"}
fmt.Println(slice)
}
Output[one two three]
のスライス値を割り当てました []string{"one", "two", "three"}
変数に slice
、次に使用した fmt.Println
を呼び出すことによってその値を出力する関数 slice
.
変数は、指定された値を受け入れるコンピューター内のメモリの小さな領域を切り分けて、その領域に関連付けることで機能します。
変数の宣言
Goでは、変数を宣言する方法がいくつかあり、場合によっては、まったく同じ変数と値を宣言する方法が複数あります。
と呼ばれる変数を宣言できます i
データ型の int
初期化なし。 これは、値を入れるスペースを宣言しますが、初期値は与えないことを意味します。
var i int
これにより、次のように宣言された変数が作成されます i
データ型の int
.
等しい(を使用して値を初期化できます=
)演算子、次の例のように:
var i int = 1
Goでは、これらの形式の宣言は両方ともlong変数宣言と呼ばれます。
短い変数宣言を使用することもできます。
i := 1
この場合、次の変数があります i
、およびのデータ型 int
. データ型を指定しない場合、Goはデータ型を推測します。
変数を宣言する3つの方法で、Goコミュニティは次のイディオムを採用しています。
-
長い形式のみを使用し、
var i int
、変数を初期化していないとき。 -
短い形式を使用し、
i := 1
、宣言および初期化する場合。 -
Goでデータ型を推測したくないが、短い変数宣言を使用したい場合は、次の構文を使用して、値を目的の型でラップできます。
i := int64(1)
Goでは、値を初期化するときに長い変数宣言フォームを使用することは慣用的とは見なされません。
var i int = 1
他の人があなたのプログラムをシームレスに読めるように、Goコミュニティが通常どのように変数を宣言するかに従うのは良い習慣です。
ゼロ値
すべての組み込み型の値はゼロです。 割り当てられた変数は、値が割り当てられていない場合でも使用できます。 次のタイプのゼロ値を確認できます。
package main
import "fmt"
func main() {
var a int
var b string
var c float64
var d bool
fmt.Printf("var a %T = %+v\n", a, a)
fmt.Printf("var b %T = %q\n", b, b)
fmt.Printf("var c %T = %+v\n", c, c)
fmt.Printf("var d %T = %+v\n\n", d, d)
}
Outputvar a int = 0
var b string = ""
var c float64 = 0
var d bool = false
使用しました %T
動詞 fmt.Printf
声明。 これは、関数に印刷するように指示します data type
変数の場合。
Goでは、すべての値に zero
価値、私たちは持つことはできません undefined
他のいくつかの言語のような値。 たとえば、一部の言語のbooleanは次のようになります。 undefined
, true
、 また false
、 three
変数に状態を示します。 囲碁では、 two
ブール値の状態。
変数の命名:ルールとスタイル
変数の命名は非常に柔軟ですが、覚えておくべきいくつかのルールがあります。
- 変数名は1語のみにする必要があります(スペースを入れない場合など)。
- 変数名は、文字、数字、およびアンダースコアのみで構成する必要があります(
_
). - 変数名を数字で始めることはできません。
これらのルールに従って、有効な変数名と無効な変数名の両方を見てみましょう。
有効 | 無効 | なぜ無効なのか |
---|---|---|
userName |
user-name |
ハイフンは許可されていません |
name4 |
4name |
数字で始めることはできません |
user |
$user |
記号は使用できません |
userName |
user name |
複数の単語にすることはできません |
さらに、変数に名前を付けるときは、大文字と小文字が区別されることに注意してください。 これらの名前 userName
, USERNAME
, UserName
、 と uSERnAME
すべて完全に異なる変数です。 プログラム内で同様の変数名を使用しないようにして、現在および将来の共同作業者と共同作業者の両方が変数をまっすぐに保つことができるようにすることをお勧めします。
変数では大文字と小文字が区別されますが、Goでは変数の最初の文字の大文字と小文字が特別な意味を持ちます。 変数が大文字で始まる場合、その変数は、宣言されたパッケージの外部からアクセスできます(または exported
). 変数が小文字で始まる場合、それは宣言されているパッケージ内でのみ使用できます。
var Email string
var password string
Email
大文字で始まり、他のパッケージからアクセスできます。 password
小文字で始まり、宣言されているパッケージ内でのみアクセスできます。
Goでは、非常に簡潔な(または短い)変数名を使用するのが一般的です。 使用するかどうかの選択を考えると userName
と user
変数の場合、選択するのは慣用的です user
.
スコープは、変数名の簡潔さにも影響します。 ルールは、変数が存在するスコープが小さいほど、変数名は小さくなります。
names := []string{"Mary", "John", "Bob", "Anna"}
for i, n := range names {
fmt.Printf("index: %d = %q\n", i, n)
}
変数を使用します names
より広い範囲では、プログラムでの意味を覚えやすくするために、より意味のある名前を付けるのが一般的です。 ただし、 i
と n
変数はコードの次の行ですぐに使用し、その後は使用しないでください…このため、変数が使用されている場所やその意味についてコードを読んでいる人を混乱させることはありません。
次に、可変スタイルに関するいくつかの注意事項について説明します。 スタイルは使用することです MixedCaps
また mixedCaps
複数の単語の名前にアンダースコアを付けるのではなく。
従来のスタイル | 型破りなスタイル | なぜ型破りなのか |
---|---|---|
userName |
user_name |
アンダースコアは従来のものではありません |
i |
index |
好む i 以上 index 短いので |
serveHTTP |
serveHttp |
頭字語は大文字にする必要があります |
スタイルに関して最も重要なことは、一貫性を保つこと、そしてあなたが取り組むチームがスタイルに同意することです。
変数の再割り当て
「変数」という言葉が意味するように、Go変数は簡単に変更できます。 これは、再割り当てによって、以前に割り当てられた変数に別の値を接続できることを意味します。 プログラムの過程全体で、ユーザーが生成した値をすでに初期化された変数に受け入れる必要がある場合があるため、再割り当てできると便利です。 また、割り当てを以前に定義したものに変更する必要がある場合もあります。
変数を簡単に再割り当てできることを知っていると、他の誰かが書いた大規模なプログラムで作業するときに役立ちます。また、どの変数がすでに定義されているかが明確ではありません。
の値を割り当てましょう 76
と呼ばれる変数に i
タイプの int
、次に新しい値を割り当てます 42
:
package main
import "fmt"
func main() {
i := 76
fmt.Println(i)
i = 42
fmt.Println(i)
}
Output76
42
この例は、最初に変数を割り当てることができることを示しています i
整数の値を使用して、変数を再割り当てします i
今回はの値を割り当てます 42
.
注: およびを宣言して変数を初期化すると、次を使用できます。 :=
ただし、すでに宣言されている変数の値を単純に変更する場合は、equal演算子(=
).
Goは typed
言語では、あるタイプを別のタイプに割り当てることはできません。 たとえば、値を割り当てることはできません "Sammy"
タイプの変数に int
:
i := 72
i = "Sammy"
異なるタイプを相互に割り当てようとすると、コンパイル時エラーが発生します。
Outputcannot use "Sammy" (type string) as type int in assignment
Goでは、変数名を複数回使用することはできません。
var s string
var s string
Outputs redeclared in this block
同じ変数名に対して短い変数宣言を複数回使用しようとすると、コンパイルエラーも発生します。 これは誤って発生する可能性があるため、エラーメッセージの意味を理解しておくと役立ちます。
i := 5
i := 10
Outputno new variables on left side of :=
変数宣言と同様に、変数の名前を考慮すると、将来再訪するときに、自分や他の人にとってプログラムの読みやすさが向上します。
複数の割り当て
Goを使用すると、同じ行内の複数の変数に複数の値を割り当てることもできます。 これらの各値は、異なるデータ型にすることができます。
j, k, l := "shark", 2.05, 15
fmt.Println(j)
fmt.Println(k)
fmt.Println(l)
Outputshark
2.05
15
この例では、変数 j
文字列に割り当てられました "shark"
、変数 k
フロートに割り当てられました 2.05
、および変数 l
整数に割り当てられました 15
.
1行の複数の値に複数の変数を割り当てるこのアプローチにより、コードの行数を抑えることができます。 ただし、コードの行数を減らしても読みやすさを損なわないことが重要です。
グローバル変数とローカル変数
プログラム内で変数を使用する場合は、変数スコープを念頭に置くことが重要です。 変数のスコープは、特定のプログラムのコード内からアクセスできる特定の場所を指します。 つまり、特定のプログラムのすべての部分からすべての変数にアクセスできるわけではありません。一部の変数はグローバルになり、一部はローカルになります。
グローバル変数は関数の外に存在します。 ローカル変数は関数内に存在します。
実際のグローバル変数とローカル変数を見てみましょう。
package main
import "fmt"
var g = "global"
func printLocal() {
l := "local"
fmt.Println(l)
}
func main() {
printLocal()
fmt.Println(g)
}
Outputlocal
global
ここでは使用します var g = "global"
関数の外部にグローバル変数を作成します。 次に、関数を定義します printLocal()
. 関数の内部では、と呼ばれるローカル変数 l
割り当てられてから印刷されます。 プログラムは電話で終了します printLocal()
次に、グローバル変数を出力します g
.
なぜなら g
はグローバル変数であり、で参照できます printLocal()
. それを行うために前のプログラムを変更してみましょう:
package main
import "fmt"
var g = "global"
func printLocal() {
l := "local"
fmt.Println(l)
fmt.Println(g)
}
func main() {
printLocal()
fmt.Println(g)
}
Outputlocal
global
global
まず、グローバル変数を宣言します g
, var g = "global"
. の中に main
関数、関数を呼び出します printLocal
、ローカル変数を宣言します l
そしてそれを印刷し、 fmt.Println(l)
. それで、 printLocal
グローバル変数を出力します g
, fmt.Println(g)
. それでも g
内で定義されていません printLocal
、グローバルスコープで宣言されているため、引き続きアクセスできます。 最後に、 main
関数が出力されます g
同じように。
次に、関数の外部でローカル変数を呼び出してみましょう。
package main
import "fmt"
var g = "global"
func printLocal() {
l := "local"
fmt.Println(l)
}
func main() {
fmt.Println(l)
}
Outputundefined: l
割り当てられている関数の外部でローカル変数を使用することはできません。 あなたがそうしようとすると、あなたは受け取るでしょう undefined
コンパイル時にエラーが発生します。
グローバル変数とローカル変数に同じ変数名を使用する別の例を見てみましょう。
package main
import "fmt"
var num1 = 5
func printNumbers() {
num1 := 10
num2 := 7
fmt.Println(num1)
fmt.Println(num2)
}
func main() {
printNumbers()
fmt.Println(num1)
}
Output10
7
5
このプログラムでは、 num1
2回可変。 まず、宣言しました num1
グローバルスコープで、 var num1 = 5
、そして再びローカルスコープ内 printNumbers
関数、 num1 := 10
. 印刷するとき num1
から main
プログラム、私たちはの価値を見ます 5
印刷した。 それの訳は main
グローバル変数宣言のみが表示されます。 ただし、印刷する場合 num1
から printNumbers
関数、それはローカル宣言を見て、の値を出力します 10
. それでも printNumbers
と呼ばれる新しい変数を作成します num1
それに値を割り当てました 10
、のグローバルインスタンスには影響しません num1
の値で 5
.
変数を操作するときは、プログラムのどの部分が各変数にアクセスする必要があるかについても考慮する必要があります。 それに応じてグローバル変数またはローカル変数を採用します。 Goプログラム全体で、ローカル変数が一般的であることがわかります。
定数
定数は変数に似ていますが、宣言された後は変更できない点が異なります。 定数は、プログラムで複数回使用される値を定義するのに役立ちますが、変更することはできません。
たとえば、ショッピングカートシステムの税率を宣言する場合は、定数を使用して、プログラムのさまざまな領域で税を計算できます。 将来のある時点で、税率が変更された場合、プログラムの1つの場所でその値を変更するだけで済みます。 変数を使用した場合、プログラムのどこかで誤って値を変更し、計算が不適切になる可能性があります。
定数を宣言するには、次の構文を使用できます。
const shark = "Sammy"
fmt.Println(shark)
OutputSammy
宣言された後に定数を変更しようとすると、コンパイル時エラーが発生します。
Outputcannot assign to shark
定数は untyped
. これは、整数型のデータなどの数値を操作するときに役立ちます。 定数が untyped
、明示的に変換されます。 typed
定数はそうではありません。 定数を使用する方法を見てみましょう。
package main
import "fmt"
const (
year = 365
leapYear = int32(366)
)
func main() {
hours := 24
minutes := int32(60)
fmt.Println(hours * year)
fmt.Println(minutes * year)
fmt.Println(minutes * leapYear)
}
Output8760
21900
21960
型で定数を宣言すると、その正確な型になります。 ここで定数を宣言すると leapYear
、データ型として定義します int32
. したがって、それは typed
定数、つまり、でのみ動作できることを意味します int32
データ型。 The year
型なしで宣言する定数なので、 untyped
. このため、任意の整数データ型で使用できます。
いつ hours
定義された、それはタイプであると推測 int
明示的にタイプを指定しなかったため、 hours := 24
. 宣言したとき minutes
、明示的に宣言しました int32
, minutes := int32(60)
.
次に、各計算とそれが機能する理由を見ていきましょう。
hours * year
この場合、 hours
は int
、 と years
untypedです。 プログラムがコンパイルされると、明示的に変換されます years
に int
、これにより、乗算演算を成功させることができます。
minutes * year
この場合、 minutes
は int32
、 と year
untypedです。 プログラムがコンパイルされると、明示的に変換されます years
に int32
、これにより、乗算演算を成功させることができます。
minutes * leapYear
この場合、 minutes
は int32
、 と leapYear
は型付き定数です int32
. 両方の変数がすでに同じタイプであるため、今回はコンパイラーが行うことは何もありません。
2つのタイプを乗算しようとすると typed
互換性がない場合、プログラムはコンパイルされません。
fmt.Println(hours * leapYear)
Outputinvalid operation: hours * leapYear (mismatched types int and int32)
この場合、 hours
として推測された int
、 と leapYear
として明示的に宣言された int32
. Goは型付き言語であるため、 int
と int32
数学演算とは互換性がありません。 それらを乗算するには、を使用して1つをint32またはintに変換する必要があります。
結論
このチュートリアルでは、Go内の変数の一般的なユースケースのいくつかを確認しました。 変数はプログラミングの重要な構成要素であり、プログラムで使用するデータ型の値を表すシンボルとして機能します。