移動-クイックガイド

Goは、システムプログラミングを念頭に置いて設計された汎用言語です。これは、2007年にRobert Griesemer、Rob Pike、KenThompsonによってGoogleで最初に開発されました。強く静的に型付けされ、ガベージコレクションの組み込みサポートを提供し、並行プログラミングをサポートします。

プログラムは、依存関係を効率的に管理するために、パッケージを使用して構築されます。Goプログラミングの実装では、従来のコンパイルおよびリンクモデルを使用して、実行可能なバイナリを生成します。Goプログラミング言語は2009年11月に発表され、Googleの一部の本番システムで使用されています。

Goプログラミングの機能

Goプログラミングの最も重要な機能を以下に示します-

• 動的言語と同様のパターンを採用する環境のサポート。たとえば、型推論（x：= 0はint型の変数xの有効な宣言です）

• コンパイル時間は速いです。

• 組み込みの並行性サポート：軽量プロセス（goルーチンを介して）、チャネル、selectステートメント。

• Goプログラムは、シンプル、簡潔、そして安全です。

• インターフェイスと型の埋め込みのサポート。

• 外部依存関係のない静的にリンクされたネイティブバイナリの生成。

意図的に除外された機能

言語を単純かつ簡潔に保つために、他の同様の言語で一般的に利用可能な以下の機能はGo −では省略されています。

• 型継承のサポート

• メソッドまたは演算子のオーバーロードのサポート

• パッケージ間の循環依存のサポート

• ポインタ演算のサポート

• アサーションのサポート

• ジェネリックプログラミングのサポート

プログラムに行く

Goプログラムの長さは、3行から数百万行までさまざまであり、拡張子が「.go」の1つ以上のテキストファイルに書き込む必要があります。たとえば、hello.goです。

「vi」、「vim」、またはその他のテキストエディタを使用して、Goプログラムをファイルに書き込むことができます。

ローカル環境のセットアップ

それでもGoプログラミング言語用の環境をセットアップする場合は、コンピューターで次の2つのソフトウェアを使用できる必要があります。

• テキストエディタ
• Goコンパイラ

テキストエディタ

プログラムを入力するには、テキストエディタが必要になります。テキストエディタの例には、Windowsメモ帳、OS Editコマンド、Brief、Epsilon、EMACS、vimまたはviが含まれます。

テキストエディタの名前とバージョンは、オペレーティングシステムによって異なる場合があります。たとえば、メモ帳はWindowsで使用され、vimまたはviはWindowsとLinuxまたはUNIXで使用されます。

テキストエディタで作成したファイルは source files。プログラムのソースコードが含まれています。Goプログラムのソースファイルには、通常、拡張子が付けられています。".go"。

プログラミングを開始する前に、テキストエディタが配置されていて、コンピュータプログラムを作成し、ファイルに保存し、コンパイルして、最後に実行するのに十分な経験があることを確認してください。

Goコンパイラ

ソースファイルに記述されたソースコードは、プログラムの人間が読める形式のソースです。CPUが実際に与えられた指示に従ってプログラムを実行できるように、コンパイルして機械語に変換する必要があります。Goプログラミング言語コンパイラは、ソースコードを最終的な実行可能プログラムにコンパイルします。

Goディストリビューションは、FreeBSD（リリース8以降）、Linux、Mac OS X（Snow Leopard以降）、および32ビット（386）および64ビット（amd64）x86プロセッサアーキテクチャを備えたWindowsオペレーティングシステム用のバイナリインストール可能です。

次のセクションでは、さまざまなOSにGoバイナリ配布をインストールする方法について説明します。

GoArchiveをダウンロード

GoDownloadsから最新バージョンのGoインストール可能アーカイブファイルをダウンロードします。このチュートリアルでは、次のバージョンが使用されています：go1.4.windows-amd64.msi。

C：\> goフォルダーにコピーされます。

OS	アーカイブ名
ウィンドウズ	go1.4.windows-amd64.msi
Linux	go1.4.linux-amd64.tar.gz
マック	go1.4.darwin-amd64-osx10.8.pkg
FreeBSD	go1.4.freebsd-amd64.tar.gz

UNIX / Linux / Mac OS X、およびFreeBSDへのインストール

ダウンロードアーカイブを/ usr / localフォルダーに抽出し、/ usr / local / goにGoツリーを作成します。例-

tar -C / usr / local -xzf go1.4.linux-amd64.tar.gz

/ usr / local / go / binをPATH環境変数に追加します。

OS	出力
Linux	export PATH = $ PATH：/ usr / local / go / bin
マック	export PATH = $ PATH：/ usr / local / go / bin
FreeBSD	export PATH = $ PATH：/ usr / local / go / bin

Windowsへのインストール

MSIファイルを使用し、プロンプトに従ってGoツールをインストールします。デフォルトでは、インストーラーはc：\ GoのGoディストリビューションを使用します。インストーラーは、WindowのPATH環境変数にc：\ Go \ binディレクトリを設定する必要があります。変更を有効にするために、開いているコマンドプロンプトを再起動します。

インストールの確認

test.goという名前のgoファイルを作成します C:\>Go_WorkSpace。

ファイル：test.go

package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}

次に、test.goを実行して結果を確認します-

C:\Go_WorkSpace>go run test.go

出力

Hello, World!

Goプログラミング言語の基本的な構成要素を学習する前に、次の章で参照できるように、まずGoプログラムの最小限の構造について説明します。

HelloWorldの例

Goプログラムは、基本的に次の部分で構成されています。

• パッケージ宣言
• パッケージのインポート
• Functions
• Variables
• ステートメントと式
• Comments

「HelloWorld」という単語を出力する簡単なコードを見てみましょう-

package main

import "fmt"

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

上記のプログラムのさまざまな部分を見てみましょう-

• プログラムパッケージmainの最初の行は、このプログラムが存在するパッケージ名を定義します。Goプログラムはパッケージで実行されるため、これは必須のステートメントです。メインパッケージは、プログラムを実行するための開始点です。各パッケージには、パスと名前が関連付けられています。

• 次の行のimport "fmt"は、パッケージfmtにあるファイルを含めるようにGoコンパイラに指示するプリプロセッサコマンドです。

• 次の行funcmain（）は、プログラムの実行を開始するmain関数です。

• 次の行/ * ... * /はコンパイラによって無視され、プログラムにコメントを追加するためにあります。コメントも、JavaまたはC ++コメントと同様に//を使用して表されます。

• 次の行fmt.Println（...）は、Goで使用できる別の関数であり、「Hello、World！」というメッセージが表示されます。画面に表示されます。ここで、fmtパッケージは、画面にメッセージを表示するために使用されるPrintlnメソッドをエクスポートしました。

• Printlnメソッドの大文字のPに注意してください。Go言語では、大文字で始まる名前がエクスポートされます。エクスポートとは、それぞれのパッケージのインポーターが関数または変数/定数にアクセスできることを意味します。

Goプログラムの実行

ソースコードをファイルに保存し、コンパイルして、最後にプログラムを実行する方法について説明しましょう。以下の手順に従ってください-

• テキストエディタを開き、上記のコードを追加します。

• ファイルをhello.goとして保存します

• コマンドプロンプトを開きます。

• ファイルを保存したディレクトリに移動します。

• go run hello.goと入力し、Enterキーを押してコードを実行します。

• コードにエラーがない場合は、「HelloWorld！」と表示されます。画面に印刷されます。

$ go run hello.go
Hello, World!

Goコンパイラがパスにあり、ソースファイルhello.goを含むディレクトリで実行していることを確認してください。

前の章で、Goプログラムの基本構造について説明しました。これで、Goプログラミング言語の他の基本的な構成要素を簡単に理解できるようになります。

Goのトークン

Goプログラムは、さまざまなトークンで構成されています。トークンは、キーワード、識別子、定数、文字列リテラル、または記号のいずれかです。たとえば、次のGoステートメントは6つのトークンで構成されています-

fmt.Println("Hello, World!")

個々のトークンは-

fmt
.
Println
(
   "Hello, World!"
)

ラインセパレーター

Goプログラムでは、行区切りキーはステートメントターミネータです。つまり、個々のステートメントに「;」のような特別な区切り文字は必要ありません。Cで。Goコンパイラは内部的に「;」を配置します。1つの論理エンティティの終わりを示すステートメントターミネータとして。

たとえば、次のステートメントを見てください-

fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")

コメント

コメントは、Goプログラムのテキストを支援するようなものであり、コンパイラーによって無視されます。以下に示すように、/ *で始まり、文字* /で終わります。

/* my first program in Go */

コメント内にコメントを含めることはできません。また、コメントは文字列または文字リテラル内にはありません。

識別子

Go識別子は、変数、関数、またはその他のユーザー定義アイテムを識別するために使用される名前です。識別子は、文字AからZまたはaからzまたはアンダースコア_で始まり、その後に0個以上の文字、アンダースコア、および数字（0から9）が続きます。

識別子=文字{文字| unicode_digit}。

Goでは、識別子内に@、$、％などの句読文字を使用できません。行くはcase-sensitiveプログラミング言語。したがって、Manpowerとmanpowerは、Goの2つの異なる識別子です。受け入れ可能な識別子の例を次に示します-

mahesh      kumar   abc   move_name   a_123
myname50   _temp    j      a23b9      retVal

キーワード

次のリストは、Goで予約されている単語を示しています。これらの予約語は、定数や変数、またはその他の識別子名として使用することはできません。

ブレーク	デフォルト	func	インターフェース	選択する
場合	延期	行く	地図	構造体
ちゃん	そうしないと	後藤	package	Switch
const	fallthrough	if	range	Type
continue	for	import	return	Var

Whitespace in Go

Whitespace is the term used in Go to describe blanks, tabs, newline characters, and comments. A line containing only whitespace, possibly with a comment, is known as a blank line, and a Go compiler totally ignores it.

Whitespaces separate one part of a statement from another and enables the compiler to identify where one element in a statement, such as int, ends and the next element begins. Therefore, in the following statement −

var age int;

There must be at least one whitespace character (usually a space) between int and age for the compiler to be able to distinguish them. On the other hand, in the following statement −

fruit = apples + oranges;   // get the total fruit

No whitespace characters are necessary between fruit and =, or between = and apples, although you are free to include some if you wish for readability purpose.

In the Go programming language, data types refer to an extensive system used for declaring variables or functions of different types. The type of a variable determines how much space it occupies in storage and how the bit pattern stored is interpreted.

The types in Go can be classified as follows −

Sr.No.	Types and Description
1	Boolean types They are boolean types and consists of the two predefined constants: (a) true (b) false
2	Numeric types They are again arithmetic types and they represents a) integer types or b) floating point values throughout the program.
3	String types A string type represents the set of string values. Its value is a sequence of bytes. Strings are immutable types that is once created, it is not possible to change the contents of a string. The predeclared string type is string.
4	Derived types They include (a) Pointer types, (b) Array types, (c) Structure types, (d) Union types and (e) Function types f) Slice types g) Interface types h) Map types i) Channel Types

Array types and structure types are collectively referred to as aggregate types. The type of a function specifies the set of all functions with the same parameter and result types. We will discuss the basic types in the following section, whereas other types will be covered in the upcoming chapters.

Integer Types

The predefined architecture-independent integer types are −

Sr.No.	Types and Description
1	uint8 Unsigned 8-bit integers (0 to 255)
2	uint16 Unsigned 16-bit integers (0 to 65535)
3	uint32 Unsigned 32-bit integers (0 to 4294967295)
4	uint64 Unsigned 64-bit integers (0 to 18446744073709551615)
5	int8 Signed 8-bit integers (-128 to 127)
6	int16 Signed 16-bit integers (-32768 to 32767)
7	int32 Signed 32-bit integers (-2147483648 to 2147483647)
8	int64 Signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

Floating Types

The predefined architecture-independent float types are −

Sr.No.	Types and Description
1	float32 IEEE-754 32-bit floating-point numbers
2	float64 IEEE-754 64-bit floating-point numbers
3	complex64 Complex numbers with float32 real and imaginary parts
4	complex128 Complex numbers with float64 real and imaginary parts

The value of an n-bit integer is n bits and is represented using two's complement arithmetic operations.

Other Numeric Types

There is also a set of numeric types with implementation-specific sizes −

Sr.No.	Types and Description
1	byte same as uint8
2	rune same as int32
3	uint 32 or 64 bits
4	int same size as uint
5	uintptr an unsigned integer to store the uninterpreted bits of a pointer value

A variable is nothing but a name given to a storage area that the programs can manipulate. Each variable in Go has a specific type, which determines the size and layout of the variable's memory, the range of values that can be stored within that memory, and the set of operations that can be applied to the variable.

The name of a variable can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because Go is case-sensitive. Based on the basic types explained in the previous chapter, there will be the following basic variable types −

Sr.No	Type & Description
1	byte Typically a single octet(one byte). This is an byte type.
2	int The most natural size of integer for the machine.
3	float32 A single-precision floating point value.

Go programming language also allows to define various other types of variables such as Enumeration, Pointer, Array, Structure, and Union, which we will discuss in subsequent chapters. In this chapter, we will focus only basic variable types.

Variable Definition in Go

A variable definition tells the compiler where and how much storage to create for the variable. A variable definition specifies a data type and contains a list of one or more variables of that type as follows −

var variable_list optional_data_type;

Here, optional_data_type is a valid Go data type including byte, int, float32, complex64, boolean or any user-defined object, etc., and variable_list may consist of one or more identifier names separated by commas. Some valid declarations are shown here −

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

The statement “var i, j, k;” declares and defines the variables i, j and k; which instructs the compiler to create variables named i, j, and k of type int.

Variables can be initialized (assigned an initial value) in their declaration. The type of variable is automatically judged by the compiler based on the value passed to it. The initializer consists of an equal sign followed by a constant expression as follows −

variable_name = value;

For example,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

For definition without an initializer: variables with static storage duration are implicitly initialized with nil (all bytes have the value 0); the initial value of all other variables is zero value of their data type.

Static Type Declaration in Go

A static type variable declaration provides assurance to the compiler that there is one variable available with the given type and name so that the compiler can proceed for further compilation without requiring the complete detail of the variable. A variable declaration has its meaning at the time of compilation only, the compiler needs the actual variable declaration at the time of linking of the program.

Example

Try the following example, where the variable has been declared with a type and initialized inside the main function −

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

When the above code is compiled and executed, it produces the following result −

20
x is of type float64

Dynamic Type Declaration / Type Inference in Go

A dynamic type variable declaration requires the compiler to interpret the type of the variable based on the value passed to it. The compiler does not require a variable to have type statically as a necessary requirement.

Example

Try the following example, where the variables have been declared without any type. Notice, in case of type inference, we initialized the variable y with := operator, whereas x is initialized using = operator.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

When the above code is compiled and executed, it produces the following result −

20
42
x is of type float64
y is of type int

Mixed Variable Declaration in Go

Variables of different types can be declared in one go using type inference.

Example

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

When the above code is compiled and executed, it produces the following result −

3
4
foo
a is of type int
b is of type int
c is of type string

The lvalues and the rvalues in Go

There are two kinds of expressions in Go −

• lvalue − Expressions that refer to a memory location is called "lvalue" expression. An lvalue may appear as either the left-hand or right-hand side of an assignment.

• rvalue − The term rvalue refers to a data value that is stored at some address in memory. An rvalue is an expression that cannot have a value assigned to it which means an rvalue may appear on the right- but not left-hand side of an assignment.

Variables are lvalues and so may appear on the left-hand side of an assignment. Numeric literals are rvalues and so may not be assigned and can not appear on the left-hand side.

The following statement is valid −

x = 20.0

The following statement is not valid. It would generate compile-time error −

10 = 20

Constants refer to fixed values that the program may not alter during its execution. These fixed values are also called literals.

Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal. There are also enumeration constants as well.

Constants are treated just like regular variables except that their values cannot be modified after their definition.

Integer Literals

An integer literal can be a decimal, octal, or hexadecimal constant. A prefix specifies the base or radix: 0x or 0X for hexadecimal, 0 for octal, and nothing for decimal.

An integer literal can also have a suffix that is a combination of U and L, for unsigned and long, respectively. The suffix can be uppercase or lowercase and can be in any order.

Here are some examples of integer literals −

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */

Following are other examples of various type of Integer literals −

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

Floating-point Literals

A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or exponential form.

While representing using decimal form, you must include the decimal point, the exponent, or both and while representing using exponential form, you must include the integer part, the fractional part, or both. The signed exponent is introduced by e or E.

Here are some examples of floating-point literals −

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

Escape Sequence

When certain characters are preceded by a backslash, they will have a special meaning in Go. These are known as Escape Sequence codes which are used to represent newline (\n), tab (\t), backspace, etc. Here, you have a list of some of such escape sequence codes −

Escape sequence	Meaning
\\	\ character
\'	' character
\"	" character
\?	? character
\a	Alert or bell
\b	Backspace
\f	Form feed
\n	Newline
\r	Carriage return
\t	Horizontal tab
\v	Vertical tab
\ooo	Octal number of one to three digits
\xhh . . .	Hexadecimal number of one or more digits

The following example shows how to use \t in a program −

package main

import "fmt"

func main() {
   fmt.Printf("Hello\tWorld!")
}

When the above code is compiled and executed, it produces the following result −

Hello World!

String Literals in Go

String literals or constants are enclosed in double quotes "". A string contains characters that are similar to character literals: plain characters, escape sequences, and universal characters.

You can break a long line into multiple lines using string literals and separating them using whitespaces.

Here are some examples of string literals. All the three forms are identical strings.

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

The const Keyword

You can use const prefix to declare constants with a specific type as follows −

const variable type = value;

The following example shows how to use the const keyword −

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int

   area = LENGTH * WIDTH
   fmt.Printf("value of area : %d", area)   
}

When the above code is compiled and executed, it produces the following result −

value of area : 50

Note that it is a good programming practice to define constants in CAPITALS.

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Go language is rich in built-in operators and provides the following types of operators −

• Arithmetic Operators
• Relational Operators
• Logical Operators
• Bitwise Operators
• Assignment Operators
• Miscellaneous Operators

This tutorial explains arithmetic, relational, logical, bitwise, assignment, and other operators one by one.

Arithmetic Operators

Following table shows all the arithmetic operators supported by Go language. Assume variable A holds 10 and variable B holds 20 then −

Show Examples

Operator	Description	Example
+	Adds two operands	A + B gives 30
-	Subtracts second operand from the first	A - B gives -10
*	Multiplies both operands	A * B gives 200
/	Divides the numerator by the denominator.	B / A gives 2
%	Modulus operator; gives the remainder after an integer division.	B % A gives 0
++	Increment operator. It increases the integer value by one.	A++ gives 11
--	Decrement operator. It decreases the integer value by one.	A-- gives 9

Relational Operators

The following table lists all the relational operators supported by Go language. Assume variable A holds 10 and variable B holds 20, then −

Show Examples

Operator	Description	Example
==	It checks if the values of two operands are equal or not; if yes, the condition becomes true.	(A == B) is not true.
!=	It checks if the values of two operands are equal or not; if the values are not equal, then the condition becomes true.	(A != B) is true.
>	It checks if the value of left operand is greater than the value of right operand; if yes, the condition becomes true.	(A > B) is not true.
<	It checks if the value of left operand is less than the value of the right operand; if yes, the condition becomes true.	(A < B) is true.
>=	It checks if the value of the left operand is greater than or equal to the value of the right operand; if yes, the condition becomes true.	(A >= B) is not true.
<=	It checks if the value of left operand is less than or equal to the value of right operand; if yes, the condition becomes true.	(A <= B) is true.

Logical Operators

The following table lists all the logical operators supported by Go language. Assume variable A holds 1 and variable B holds 0, then −

Show Examples

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non-zero, then condition becomes true.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is non-zero, then condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	!(A && B) is true.

The following table shows all the logical operators supported by Go language. Assume variable A holds true and variable B holds false, then −

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are false, then the condition becomes false.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is true, then the condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make it false.	!(A && B) is true.

Bitwise Operators

Bitwise operators work on bits and perform bit-by-bit operation. The truth tables for &, |, and ^ are as follows −

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume A = 60; and B = 13. In binary format, they will be as follows −

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

The Bitwise operators supported by C language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then −

Show Examples

Operator	Description	Example
&	Binary AND Operator copies a bit to the result if it exists in both operands.	(A & B) will give 12, which is 0000 1100
|	Binary OR Operator copies a bit if it exists in either operand.	(A | B) will give 61, which is 0011 1101
^	Binary XOR Operator copies the bit if it is set in one operand but not both.	(A ^ B) will give 49, which is 0011 0001
<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A << 2 will give 240 which is 1111 0000
>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15 which is 0000 1111

Assignment Operators

The following table lists all the assignment operators supported by Go language −

Show Examples

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assign value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand	C *= A is equivalent to C = C * A
/=	Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand	C /= A is equivalent to C = C / A
%=	Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand	C %= A is equivalent to C = C % A
<<=	Left shift AND assignment operator	C <<= 2 is same as C = C << 2
>>=	Right shift AND assignment operator	C >>= 2 is same as C = C >> 2
&=	Bitwise AND assignment operator	C &= 2 is same as C = C & 2
^=	bitwise exclusive OR and assignment operator	C ^= 2 is same as C = C ^ 2
|=	bitwise inclusive OR and assignment operator	C |= 2 is same as C = C | 2

Miscellaneous Operators

There are a few other important operators supported by Go Language including sizeof and ?:.

Show Examples

Operator	Description	Example
&	Returns the address of a variable.	&a; provides actual address of the variable.
*	Pointer to a variable.	*a; provides pointer to a variable.

Operators Precedence in Go

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Show Examples

Category	Operator	Associativity
Postfix	() [] -> . ++ - -	Left to right
Unary	+ - ! ~ ++ - - (type)* & sizeof	Right to left
Multiplicative	* / %	Left to right
Additive	+ -	Left to right
Shift	<< >>	Left to right
Relational	< <= > >=	Left to right
Equality	== !=	Left to right
Bitwise AND	&	Left to right
Bitwise XOR	^	Left to right
Bitwise OR	|	Left to right
Logical AND	&&	Left to right
Logical OR	||	Left to right
Assignment	= += -= *= /= %=>>= <<= &= ^= |=	Right to left
Comma	,	Left to right

Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages −

Go programming language provides the following types of decision making statements. Click the following links to check their detail.

Sr.No	Statement & Description
1	if statement An if statement consists of a boolean expression followed by one or more statements.
2	if...else statement An if statement can be followed by an optional else statement, which executes when the boolean expression is false.
3	nested if statements You can use one if or else if statement inside another if or else if statement(s).
4	switch statement A switch statement allows a variable to be tested for equality against a list of values.
5	select statement A select statement is similar to switch statement with difference that case statements refers to channel communications.

There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages −

Go programming language provides the following types of loop to handle looping requirements.

Sr.No	Loop Type & Description
1	for loop It executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
2	nested loops These are one or multiple loops inside any for loop.

Loop Control Statements

Loop control statements change an execution from its normal sequence. When an execution leaves its scope, all automatic objects that were created in that scope are destroyed.

Go supports the following control statements −

Sr.No	Control Statement & Description
1	break statement It terminates a for loop or switch statement and transfers execution to the statement immediately following the for loop or switch.
2	continue statement It causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
3	goto statement It transfers control to the labeled statement.

The Infinite Loop

A loop becomes an infinite loop if its condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop are required, you can make an endless loop by leaving the conditional expression empty or by passing true to it.

package main

import "fmt"

func main() {
   for true  {
       fmt.Printf("This loop will run forever.\n");
   }
}

When the conditional expression is absent, it is assumed to be true. You may have an initialization and increment expression, but C programmers more commonly use the for(;;) construct to signify an infinite loop.

Note − You can terminate an infinite loop by pressing Ctrl + C keys.

A function is a group of statements that together perform a task. Every Go program has at least one function, which is main(). You can divide your code into separate functions. How you divide your code among different functions is up to you, but logically, the division should be such that each function performs a specific task.

A function declaration tells the compiler about a function name, return type, and parameters. A function definition provides the actual body of the function.

The Go standard library provides numerous built-in functions that your program can call. For example, the function len() takes arguments of various types and returns the length of the type. If a string is passed to it, the function returns the length of the string in bytes. If an array is passed to it, the function returns the length of the array.

Functions are also known as method, sub-routine, or procedure.

Defining a Function

The general form of a function definition in Go programming language is as follows −

func function_name( [parameter list] ) [return_types]
{
   body of the function
}

A function definition in Go programming language consists of a function header and a function body. Here are all the parts of a function −

• Func − It starts the declaration of a function.

• Function Name − It is the actual name of the function. The function name and the parameter list together constitute the function signature.

• Parameters − A parameter is like a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.

• Return Type − A function may return a list of values. The return_types is the list of data types of the values the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the not required.

• Function Body − It contains a collection of statements that define what the function does.

Example

The following source code shows a function called max(). This function takes two parameters num1 and num2 and returns the maximum between the two −

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

Calling a Function

While creating a Go function, you give a definition of what the function has to do. To use a function, you will have to call that function to perform the defined task.

When a program calls a function, the program control is transferred to the called function. A called function performs a defined task and when its return statement is executed or when its function-ending closing brace is reached, it returns the program control back to the main program.

To call a function, you simply need to pass the required parameters along with its function name. If the function returns a value, then you can store the returned value. For example −

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200
   var ret int

   /* calling a function to get max value */
   ret = max(a, b)

   fmt.Printf( "Max value is : %d\n", ret )
}

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

We have kept the max() function along with the main() function and compiled the source code. While running the final executable, it would produce the following result −

Max value is : 200

Returning multiple values from Function

A Go function can return multiple values. For example −

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

When the above code is compiled and executed, it produces the following result −

Kumar Mahesh

Function Arguments

If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.

The formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.

While calling a function, there are two ways that arguments can be passed to a function −

Sr.No	Call Type & Description
1	Call by value This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
2	Call by reference This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.

By default, Go uses call by value to pass arguments. In general, it means the code within a function cannot alter the arguments used to call the function. The above program, while calling the max() function, used the same method.

Function Usage

A function can be used in the following ways:

Sr.No	Function Usage & Description
1	Function as Value Functions can be created on the fly and can be used as values.
2	Function Closures Functions closures are anonymous functions and can be used in dynamic programming.
3	Method Methods are special functions with a receiver.

A scope in any programming is a region of the program where a defined variable can exist and beyond that the variable cannot be accessed. There are three places where variables can be declared in Go programming language −

• Inside a function or a block (local variables)

• Outside of all functions (global variables)

• In the definition of function parameters (formal parameters)

Let us find out what are local and global variables and what are formal parameters.

Local Variables

Variables that are declared inside a function or a block are called local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. The following example uses local variables. Here all the variables a, b, and c are local to the main() function.

package main

import "fmt"

func main() {
   /* local variable declaration */
   var a, b, c int 

   /* actual initialization */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}

When the above code is compiled and executed, it produces the following result −

value of a = 10, b = 20 and c = 30

グローバル変数

グローバル変数は、関数の外部、通常はプログラムの上で定義されます。グローバル変数は、プログラムの存続期間を通じてその値を保持し、プログラム用に定義された任意の関数内でアクセスできます。

グローバル変数には、任意の関数からアクセスできます。つまり、グローバル変数は、宣言後、プログラム全体で使用できます。次の例では、グローバル変数とローカル変数の両方を使用しています-

package main

import "fmt"
 
/* global variable declaration */
var g int
 
func main() {
   /* local variable declaration */
   var a, b int

   /* actual initialization */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

value of a = 10, b = 20 and g = 30

プログラムはローカル変数とグローバル変数に同じ名前を付けることができますが、関数内のローカル変数の値が優先されます。例-

package main

import "fmt"
 
/* global variable declaration */
var g int = 20
 
func main() {
   /* local variable declaration */
   var g int = 10
 
   fmt.Printf ("value of g = %d\n",  g)
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

value of g = 10

仮パラメータ

仮パラメータは、その関数内でローカル変数として扱われ、グローバル変数よりも優先されます。例-

package main

import "fmt"
 
/* global variable declaration */
var a int = 20;
 
func main() {
   /* local variable declaration in main function */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("value of a in main() = %d\n",  a);
   c = sum( a, b);
   fmt.Printf("value of c in main() = %d\n",  c);
}
/* function to add two integers */
func sum(a, b int) int {
   fmt.Printf("value of a in sum() = %d\n",  a);
   fmt.Printf("value of b in sum() = %d\n",  b);

   return a + b;
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

ローカル変数とグローバル変数の初期化

ローカル変数とグローバル変数は、デフォルト値である0に初期化されます。ポインタはnilに初期化されます。

データ・タイプ	初期デフォルト値
int	0
float32	0
ポインター	なし

Goプログラミングで広く使用されている文字列は、読み取り専用のバイトスライスです。Goプログラミング言語では、文字列はslices。Goプラットフォームは、文字列を操作するためのさまざまなライブラリを提供します。

• unicode
• regexp
• strings

文字列の作成

文字列を作成する最も直接的な方法は、次のように書くことです。

var greeting = "Hello world!"

コード内で文字列リテラルを検出すると、コンパイラはその値（この場合は「Helloworld！」）を使用して文字列オブジェクトを作成します。

文字列リテラルは、ルーンと呼ばれる有効なUTF-8シーケンスを保持します。文字列は任意のバイトを保持します。

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("normal string: ")
   fmt.Printf("%s", greeting)
   fmt.Printf("\n")
   fmt.Printf("hex bytes: ")
   
   for i := 0; i < len(greeting); i++ {
       fmt.Printf("%x ", greeting[i])
   }
   fmt.Printf("\n")
   
   const sampleText = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98" 
   /*q flag escapes unprintable characters, with + flag it escapses non-ascii 
   characters as well to make output unambigous  
   */
   fmt.Printf("quoted string: ")
   fmt.Printf("%+q", sampleText)
   fmt.Printf("\n")  
}

これにより、次の結果が生成されます-

normal string: Hello world!
hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 
quoted string: "\xbd\xb2=\xbc \u2318"

Note −文字列リテラルは不変であるため、一度作成すると文字列リテラルを変更できません。

文字列の長さ

len（str）メソッドは、文字列リテラルに含まれるバイト数を返します。

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("String Length is: ")
   fmt.Println(len(greeting))  
}

これにより、次の結果が生成されます-

String Length is : 12

文字列の連結

文字列パッケージにはメソッドが含まれています join 複数の文字列を連結するため-

strings.Join(sample, " ")

結合は、配列の要素を連結して単一の文字列を作成します。2番目のパラメーターは、配列の要素の間に配置されるセパレーターです。

次の例を見てみましょう-

package main

import ("fmt" "math" )"fmt" "strings")

func main() {
   greetings :=  []string{"Hello","world!"}   
   fmt.Println(strings.Join(greetings, " "))
}

これにより、次の結果が生成されます-

Hello world!

Goプログラミング言語はと呼ばれるデータ構造を提供します the array、同じタイプの要素の固定サイズの順次コレクションを格納できます。配列はデータのコレクションを格納するために使用されますが、配列を同じタイプの変数のコレクションと考える方が便利な場合がよくあります。

number0、number1、...、number99などの個々の変数を宣言する代わりに、numbersなどの1つの配列変数を宣言し、numbers [0]、numbers [1]、...、numbers [99]を使用して表現します。個々の変数。配列内の特定の要素は、インデックスによってアクセスされます。

すべてのアレイは、連続したメモリ位置で構成されています。最小アドレスは最初の要素に対応し、最大アドレスは最後の要素に対応します。

配列の宣言

Goで配列を宣言するために、プログラマーは次のように配列に必要な要素のタイプと要素の数を指定します。

var variable_name [SIZE] variable_type

これは一次元配列と呼ばれます。ザ・arraySize ゼロより大きい整数定数である必要があり、 type任意の有効なGoデータ型にすることができます。たとえば、と呼ばれる10要素の配列を宣言するにはbalance タイプfloat32の場合、このステートメントを使用します-

var balance [10] float32

ここに、 balance 最大10個の浮動小数点数を保持できる可変配列です。

配列の初期化

Goで配列を初期化するには、次のように1つずつ、または1つのステートメントを使用します。

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

中括弧{}の間の値の数は、角括弧[]の間の配列に対して宣言する要素の数より大きくすることはできません。

配列のサイズを省略すると、初期化を保持するのに十分な大きさの配列が作成されます。したがって、あなたが書く場合-

var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

前の例で行ったのとまったく同じ配列を作成します。以下は、配列の単一の要素を割り当てる例です。

balance[4] = 50.0

上記のステートメントは、配列の5^番目の要素番号に50.0の値を割り当てます。すべての配列には、ベースインデックスとも呼ばれる最初の要素のインデックスとして0があり、配列の最後のインデックスは、配列の合計サイズから1を引いたものになります。以下は、上記で説明した同じ配列の図解です。

配列要素へのアクセス

要素には、配列名にインデックスを付けることでアクセスします。これは、配列名の後に角括弧内に要素のインデックスを配置することによって行われます。例-

float32 salary = balance[9]

上記のステートメントは、配列から10^番目の要素を取得し、その値を給与変数に割り当てます。以下は、上記の3つの概念すべてを使用する例です。宣言、割り当て、配列へのアクセス-

package main

import "fmt"

func main() {
   var n [10]int /* n is an array of 10 integers */
   var i,j int

   /* initialize elements of array n to 0 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* set element at location i to i + 100 */
   }
   /* output each array element's value */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

アレイの詳細

Goプログラマーには明らかな配列に関連する重要な概念があります-

シニア番号	コンセプトと説明
1	多次元配列 Goは多次元配列をサポートしています。多次元配列の最も単純な形式は、2次元配列です。
2	関数に配列を渡す インデックスなしで配列の名前を指定することにより、配列へのポインタを関数に渡すことができます。

Goのポインタは簡単で楽しく学ぶことができます。一部のGoプログラミングタスクはポインターを使用するとより簡単に実行でき、参照による呼び出しなどの他のタスクはポインターを使用しないと実行できません。したがって、完璧なGoプログラマーになるには、ポインターを学ぶ必要があります。

ご存知のように、すべての変数はメモリ位置であり、すべてのメモリ位置にはアドレスが定義されており、メモリ内のアドレスを示すアンパサンド（＆）演算子を使用してアクセスできます。定義された変数のアドレスを出力する次の例を考えてみましょう-

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Address of a variable: 10328000

これで、メモリアドレスとは何かとそれにアクセスする方法を理解しました。それでは、ポインタとは何かを見てみましょう。

ポインタとは何ですか？

A pointerは、値が別の変数のアドレス、つまりメモリ位置の直接アドレスである変数です。他の変数や定数と同様に、変数アドレスを格納するために使用する前に、ポインターを宣言する必要があります。ポインタ変数宣言の一般的な形式は次のとおりです。

var var_name *var-type

ここに、 typeポインタの基本型です。有効なCデータ型である必要があり、var-nameポインタ変数の名前です。ポインタを宣言するために使用したアスタリスク*は、乗算に使用したものと同じアスタリスクです。ただし、このステートメントでは、変数をポインターとして指定するためにアスタリスクが使用されています。有効なポインタ宣言は次のとおりです-

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

整数、浮動小数点、その他を問わず、すべてのポインタの値の実際のデータ型は同じであり、メモリアドレスを表す長い16進数です。異なるデータ型のポインター間の唯一の違いは、ポインターが指す変数または定数のデータ型です。

ポインタの使い方は？

ポインターを使用して頻繁に実行する重要な操作がいくつかあります。（a）ポインター変数を定義し、（b）変数のアドレスをポインターに割り当て、（c）ポインター変数に格納されているアドレスの値にアクセスします。 。

これらの操作はすべて、オペランドで指定されたアドレスにある変数の値を返す単項演算子*を使用して実行されます。次の例は、これらの操作を実行する方法を示しています-

package main

import "fmt"

func main() {
   var a int = 20   /* actual variable declaration */
   var ip *int      /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/

   fmt.Printf("Address of a variable: %x\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

Goのゼロポインタ

割り当てる正確なアドレスがない場合に備えて、Goコンパイラはポインタ変数にNil値を割り当てます。これは、変数宣言時に行われます。nilが割り当てられたポインタは、nil ポインター。

nilポインターは、いくつかの標準ライブラリで定義されている値がゼロの定数です。次のプログラムを検討してください-

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

The value of ptr is 0

ほとんどのオペレーティングシステムでは、メモリがオペレーティングシステムによって予約されているため、プログラムはアドレス0のメモリにアクセスできません。ただし、メモリアドレス0には特別な意味があります。これは、ポインタがアクセス可能なメモリ位置を指すことを意図していないことを示します。ただし、慣例により、ポインターにnil（ゼロ）値が含まれている場合は、何も指していないと見なされます。

nilポインターをチェックするには、次のようにifステートメントを使用できます。

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

ポインタの詳細

ポインターには多くの簡単な概念があり、Goプログラミングにとって非常に重要です。以下のポインターの概念は、Goプログラマーにとって明確である必要があります-

シニア番号	コンセプトと説明
1	Go-ポインタの配列 多数のポインターを保持する配列を定義できます。
2	Go-ポインタへのポインタ Goを使用すると、ポインタの上にポインタを置くことができます。
3	Goの関数へのポインタの受け渡し 参照またはアドレスの両方で引数を渡すと、渡された引数を、呼び出された関数によって呼び出し元の関数で変更できます。

Go配列を使用すると、同じ種類の複数のデータ項目を保持できる変数を定義できます。 Structure は、Goプログラミングで使用できるもう1つのユーザー定義データ型であり、さまざまな種類のデータ項目を組み合わせることができます。

構造は、レコードを表すために使用されます。図書館の本を追跡したいとします。各本の次の属性を追跡することをお勧めします-

• Title
• Author
• Subject
• ブックID

このようなシナリオでは、構造は非常に役立ちます。

構造の定義

構造を定義するには、次を使用する必要があります type そして structステートメント。structステートメントは、プログラムの複数のメンバーを持つ新しいデータ型を定義します。typeステートメントは、名前を、この場合はstructである型にバインドします。structステートメントの形式は次のとおりです-

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

構造型が定義されると、次の構文を使用してその型の変数を宣言するために使用できます。

variable_name := structure_variable_type {value1, value2...valuen}

構造体メンバーへのアクセス

構造体の任意のメンバーにアクセスするには、 member access operator (.).メンバーアクセス演算子は、構造体変数名とアクセスする構造体メンバーの間のピリオドとしてコード化されます。あなたは使用しますstruct構造タイプの変数を定義するキーワード。次の例は、構造の使用方法を説明しています-

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   /* print Book2 info */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Book 1 title      : Go Programming
Book 1 author     : Mahesh Kumar
Book 1 subject    : Go Programming Tutorial
Book 1 book_id    : 6495407
Book 2 title      : Telecom Billing
Book 2 author     : Zara Ali
Book 2 subject    : Telecom Billing Tutorial
Book 2 book_id    : 6495700

関数の引数としての構造

他の変数やポインタを渡すのと非常によく似た方法で、構造体を関数の引数として渡すことができます。上記の例で行ったのと同じ方法で構造変数にアクセスします-

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(Book1)

   /* print Book2 info */
   printBook(Book2)
}
func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

構造体へのポインタ

次のように他の変数へのポインタを定義するのと同じ方法で、構造体へのポインタを定義できます。

var struct_pointer *Books

これで、構造体変数のアドレスを上記で定義したポインタ変数に格納できます。構造体変数のアドレスを見つけるには、次のように構造体の名前の前に＆演算子を置きます。

struct_pointer = &Book1;

構造体へのポインタを使用して構造体のメンバーにアクセスするには、「。」を使用する必要があります。次のように演算子-

struct_pointer.title;

構造体ポインタを使用して上記の例を書き直してみましょう-

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books   /* Declare Book1 of type Book */
   var Book2 Books   /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(&Book1)

   /* print Book2 info */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

Go Sliceは、GoArrayを抽象化したものです。Go Arrayを使用すると、同じ種類の複数のデータアイテムを保持できる変数を定義できますが、サイズを動的に増やしたり、独自のサブ配列を取得したりするための組み込みメソッドは提供されません。スライスはこの制限を克服します。配列に必要な多くのユーティリティ関数を提供し、Goプログラミングで広く使用されています。

スライスの定義

スライスを定義するには、サイズを指定せずに配列として宣言できます。または、make スライスを作成する関数。

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

len（）およびcap（）関数

スライスは、配列を抽象化したものです。実際には、基礎となる構造として配列を使用します。ザ・len() 関数は、スライスに存在する要素を返します。 cap()関数はスライスの容量（つまり、スライスが収容できる要素の数）を返します。次の例では、スライスの使用法を説明しています。

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

len = 3 cap = 5 slice = [0 0 0]

ゼロスライス

スライスが入力なしで宣言されている場合、デフォルトでは、スライスはnilとして初期化されます。その長さと容量はゼロです。例-

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   if(numbers == nil){
      fmt.Printf("slice is nil")
   }
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

len = 0 cap = 0 slice = []
slice is nil

サブスライス

スライスを使用すると、下限と上限を指定して、を使用してそのサブスライスを取得できます。[lower-bound:upper-bound]。例-

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9  slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]

append（）およびcopy（）関数

を使用してスライスの容量を増やすことができます append()関数。使用するcopy()関数では、ソーススライスの内容が宛先スライスにコピーされます。例-

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]

ザ・ range キーワードはで使用されます forループして、配列、スライス、チャネル、またはマップのアイテムを反復処理します。配列とスライスを使用すると、アイテムのインデックスが整数として返されます。マップでは、次のキーと値のペアのキーを返します。Rangeは、1つまたは2つの値を返します。範囲式の左側で1つの値のみが使用されている場合、それは次の表の最初の値です。

範囲式	1番目の値	2番目の値（オプション）
[n] Eを配列またはスライスする	index i int	a [i] E
文字列の文字列型	index i int	ルーンint
map m map [K] V	キーkK	値m [k] V
チャンネルちゃんE	要素eE	なし

例

次の段落は、範囲の使用方法を示しています-

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8} 
   
   /* print the numbers */
   for i:= range numbers {
      fmt.Println("Slice item",i,"is",numbers[i])
   }
   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"}
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* print map using key-value*/
   for country,capital := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",capital)
   }
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Slice item 0 is 0
Slice item 1 is 1
Slice item 2 is 2
Slice item 3 is 3
Slice item 4 is 4
Slice item 5 is 5
Slice item 6 is 6
Slice item 7 is 7
Slice item 8 is 8
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo

Goは、一意のキーを値にマップするmapという名前の別の重要なデータ型を提供します。キーは、後日値を取得するために使用するオブジェクトです。キーと値を指定すると、その値をMapオブジェクトに格納できます。値が保存されたら、そのキーを使用して値を取得できます。

マップの定義

使用する必要があります make マップを作成する関数。

/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type

/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)

例

次の例は、マップを作成して使用する方法を示しています-

package main

import "fmt"

func main() {
   var countryCapitalMap map[string]string
   /* create a map*/
   countryCapitalMap = make(map[string]string)
   
   /* insert key-value pairs in the map*/
   countryCapitalMap["France"] = "Paris"
   countryCapitalMap["Italy"] = "Rome"
   countryCapitalMap["Japan"] = "Tokyo"
   countryCapitalMap["India"] = "New Delhi"
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* test if entry is present in the map or not*/
   capital, ok := countryCapitalMap["United States"]
   
   /* if ok is true, entry is present otherwise entry is absent*/
   if(ok){
      fmt.Println("Capital of United States is", capital)  
   } else {
      fmt.Println("Capital of United States is not present") 
   }
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Capital of India is New Delhi
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of United States is not present

delete（）関数

delete（）関数は、マップからエントリを削除するために使用されます。マップと、削除する対応するキーが必要です。例-

package main

import "fmt"

func main() {   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}
   
   fmt.Println("Original map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* delete an entry */
   delete(countryCapitalMap,"France");
   fmt.Println("Entry for France is deleted")  
   
   fmt.Println("Updated map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Original Map
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of India is New Delhi
Entry for France is deleted
Updated Map
Capital of India is New Delhi
Capital of Italy is Rome
Capital of Japan is Tokyo

再帰は、自己相似的な方法でアイテムを繰り返すプロセスです。同じ概念がプログラミング言語にも当てはまります。プログラムが同じ関数内の関数を呼び出すことを許可する場合、それは再帰関数呼び出しと呼ばれます。次の例を見てください-

func recursion() {
   recursion() /* function calls itself */
}
func main() {
   recursion()
}

Goプログラミング言語は再帰をサポートしています。つまり、関数がそれ自体を呼び出すことができます。ただし、再帰を使用している間、プログラマーは関数からの終了条件を慎重に定義する必要があります。そうしないと、無限ループになります。

Goでの再帰の例

再帰関数は、数値の階乗の計算、フィボナッチ数列の生成など、多くの数学の問題を解決するのに非常に役立ちます。

例1：Goで再帰を使用して階乗を計算する

次の例では、再帰関数を使用して、指定された数値の階乗を計算します。

package main

import "fmt"

func factorial(i int)int {
   if(i <= 1) {
      return 1
   }
   return i * factorial(i - 1)
}
func main() { 
   var i int = 15
   fmt.Printf("Factorial of %d is %d", i, factorial(i))
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Factorial of 15 is 1307674368000

例2：Goで再帰を使用するフィボナッチ数列

次の例は、再帰関数を使用して、指定された数のフィボナッチ数列を生成する方法を示しています。

package main

import "fmt"

func fibonaci(i int) (ret int) {
   if i == 0 {
      return 0
   }
   if i == 1 {
      return 1
   }
   return fibonaci(i-1) + fibonaci(i-2)
}
func main() {
   var i int
   for i = 0; i < 10; i++ {
      fmt.Printf("%d ", fibonaci(i))
   }
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

0 1 1 2 3 5 8 13 21 34

型キャストは、変数をあるデータ型から別のデータ型に変換する方法です。たとえば、long値を単純な整数に格納する場合は、cast long tointと入力できます。を使用して、あるタイプから別のタイプに値を変換できます。cast operator。その構文は次のとおりです-

type_name(expression)

例

キャスト演算子によって、ある整数変数を別の整数変数で除算することが浮動小数点演算として実行される次の例について考えてみます。

package main

import "fmt"

func main() {
   var sum int = 17
   var count int = 5
   var mean float32
   
   mean = float32(sum)/float32(count)
   fmt.Printf("Value of mean : %f\n",mean)
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Value of mean : 3.400000

Goプログラミングは、と呼ばれる別のデータ型を提供します interfacesこれは、メソッドシグネチャのセットを表します。structデータ型は、これらのインターフェイスを実装して、インターフェイスのメソッドシグネチャのメソッド定義を持ちます。

構文

/* define an interface */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* define a struct */
type struct_name struct {
   /* variables */
}

/* implement interface methods*/
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* method implementation */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* method implementation */
}

例

package main

import (
   "fmt" 
   "math" 
)

/* define an interface */
type Shape interface {
   area() float64
}

/* define a circle */
type Circle struct {
   x,y,radius float64
}

/* define a rectangle */
type Rectangle struct {
   width, height float64
}

/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
   return rect.width * rect.height
}

/* define a method for shape */
func getArea(shape Shape) float64 {
   return shape.area()
}

func main() {
   circle := Circle{x:0,y:0,radius:5}
   rectangle := Rectangle {width:10, height:5}
   
   fmt.Printf("Circle area: %f\n",getArea(circle))
   fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Circle area: 78.539816
Rectangle area: 50.000000

Goプログラミングは、次の宣言の組み込みエラーインターフェイスタイプを備えた非常に単純なエラー処理フレームワークを提供します-

type error interface {
   Error() string
}

関数は通常、最後の戻り値としてエラーを返します。使用するerrors.New 次のように基本的なエラーメッセージを作成します-

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}

戻り値とエラーメッセージを使用します。

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

例

package main

import "errors"
import "fmt"
import "math"

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}
func main() {
   result, err:= Sqrt(-1)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
   
   result, err = Sqrt(9)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
}

上記のコードをコンパイルして実行すると、次の結果が得られます。

Math: negative number passed to Sqrt
3