複合型の言語を行きます：
ポインタ：各変数は、2つのデータ、一つのメモリ変数、二つの変数、すなわち、メモリアドレスタグを有します。
私たちは、メモリの通常の変数出力されます。
var a int = 1
fmt.Println(a)＆（％pを占める出力形式）：私たちは、ポインタを操作する必要がある場合は、操作の必要性、すなわち、メモリタグをアドレス指定
fmt.Println(&a)あなたが必要なタイプ* int型アドレス** int型のポインタを保存する場合は、* int型を必要とint型変数のアドレスポインタ型を保存します。
var p *int = &a //指针变量指向谁就把谁的地址赋值给指针变量，p是*int类型指向int类型变量
*p = 10 //为指针所指向的变量赋值ないのp * p個のメモリ操作が、メモリは、pが指すの操作に相当しますことに注意してください。
言語のポインタを保持するために行くが、他の異なる言語になって：
1.ポインタのデフォルト値はNULLが一定ではなく、nilです。
2.演算子「＆」ポインタを介してターゲットオブジェクトにアクセスするには、「*」、値のアドレスを取ります。
「 - >」3.サポートしていないポインタ演算をサポートしていない。対象部材に直接アクセスして、オペレータに「」
それ以外の場合はエラーになり、初期化されていないまたは割り当て（ゼロ）ポインタ：メモリの法的ポイントなしで運転しないでください。
この問題を解決するために、私たちは宇宙の動的割り当てに似た新しい（）関数で、とメモリ操作のためのスペースを生成することができますが、囲碁言語空間のリリースを検討する必要はありません、独自のガベージコレクションを持っている、または削除する方法のライフサイクルを気にしません。
p=new(int) //赋值
q:=new(int) //自动推导関数ポインタと組み合わせて使用します：
パラメータの関数として、共通変数：機能を交換することにより、変数の値
func swap(a,b int){
a,b=b,a
}
func mian(){
a,b:=10,20
swap(a,b)
}この方法により、異なる変数のスコープので、異なる定義が、そこ結果：カスタム関数内部変数の値を交換しているが、価値送信ではなく、メイン関数内の変数の交換値でした。
住所配達：
func swap(p1,p2 *int){
*p1,*p2=*p2,*p1
}
func mian(){
a,b:=10,20
swap(&a,&b)
}この方法により、二つの変数のメモリを交換exは、主な機能は、変数に値する交換を達成すること。
言語の配列を行く操作の簡略化された宣言および初期化の同じ型、同じ型のコレクションです。
配列定義：
var arr [50]int //50代表数组的容量，下标从0-len()-1それに注意してください。
1.配列内の要素の数は一定でなければなりません。
LEN（）0〜2添字アレイ - 1。
手動割り当てや印刷の配列：
forループを使用して割り当てを印刷します：
for i:=0;i<len(arr);i++{
arr[i]=i
fmt.Printf("arr[%d]=%d",i,arr[i])
}また、反復印刷を使用することができます。
for i,data:=range arr{
fmt.Printf("arr[%d]=%d",i,data)
}また、ダイレクトプリントを使用することができます。
fmt.Println(arr)単一のアレイ要素割付：
arr[10]=1 // 10是下标，这时的下标可以使用变量或者常量声明その割り当て：配列を初期化
すべての初期化：
var arr [5]int=[5]int{1,2,3,4,5}初期化の一部：
arr:=[5]int{1,2,3} //推荐使用自动推导类型，没有初始化的元素自动赋值为0指定された要素の初期化：
arr:=[5]int{2:10,5:20}二次元配列：サイクル上で動作するようにどのように多くの層数次元配列で、どのように多くの角括弧。
二次元配列の割り当てと印刷：
割り当てと印刷循環用：
var arr [3][4]int
k:=0
for i:=0;i<3;i++{
for j:=0;j<4;j++{
a[i][j]=k++
fmt.Printf("a[%d][%d]=%d\n",i,j,a[i][j])
}
}ダイレクトプリント：
fmt.Println(arr)導出と自動初期化：ネストされた配列と同様に、各アレイは、新しい横座標です。
arr:=[2][2]int{{1,2},{3,4}}また、初期設定の一部にすることができます。
arr:=[2][2]int{1:{1,2}}比較と割り当ての配列：のみ==または=ブール変数を返すと比較！のみ各要素タイプを比較することができ、同じ配列が同じではありません。一方、アレイの同じタイプは、ARR1 = ARR2として割り当てることができます。
シードを設定する必要があるとし、乱数を生成します。乱数を使用。
package main
import "math/rand"
import "fmt"
func mian(){
rand.Seed(123) //设置种子为123
fmt.Println(rand.Int()) //产生随机数
}しかし、注意してください：プログラムが生成した乱数が同じであるとして、あなたはシードパラメータを実行する場合。
シード時間：ネイティブシードとしての時間。
package main
import "math/rand"
import "time"
func mian(){
rand.Seed(time.Now().UnixNano()) //设置时间种子,以当前系统时间作为种子参数
}私たちは、その後、一定の範囲内で乱数を生成することができます。
rand.Intn(100)+0 //在0-100范围内产生随机数原理バブルソートの2つの隣接するソート要素、N-1行の順序の最大値の比較。
package main
import "fmt"
import "math/rand"
import "time"
func main() {
rand.Seed(time.Now().UnixNano()) //设置时间种子
var a [10]int
n := len(a)
for i := 0; i < n; i++ {
a[i] = rand.Intn(100) //生成100以内随机数
}
fmt.Println(a)
//冒泡排序，相邻两元素比较排序，升序
var b bool = true //增加判断器以优化代码效率
for i := 0; b == true && i < n-1; i++ {
b = false
for j := 0; j < n-1-i; j++ {
if a[j] > a[j+1] {
b = true
a[j], a[j+1] = a[j+1], a[j]
}
}
}
fmt.Println("排序完成\n", a)
}
関数パラメータの配列：関数パラメータの配列が渡された値であり、パラメータセットの各要素は、固体パラメータ群が成形されます。
func modify(arr [5]int){ //形参的数组是由实参数组复制来的
arr[0]=20
fmt.Println(arr)
}
func main(){
arr:=[5]int{1,2,3,4,5}
modify(arr)
}関数パラメータの配列ポインタ：Pの配列に転送アドレス、配列ポインタは、P *は、実メモリ、すなわちパラメータARRを指摘しています。
func modify(p *[5]int){
(*p)[0]=20
fmt.Println(*p)
}
func main(){
arr:=[5]int{1,2,3,4,5}
modify(&arr)
}配列のサイズが固定され、パラメータが渡すときに送信が完了していなければならない、そしてそれは、アレイの欠点を補うために、機能セクションの概念を導入しています。同一のタイムスライスで可変長の動的配列として理解することができます。スライスがアレイから切り出し、長さが指定されていません。
スライスの初期化：
a:=[...]int{1,2,3,0,0} //中括号内可以省略...
スライスと相違点の配列：
1.アレイを[]は、一定の長さに固定され、長さが長さと容積は一定で、変更することができません。
2.セクション[]は空であるか、...、およびセクションの容量が固定長ではないかもしれません。
3.append（S 11）の要素は、端部11秒に添加することができます。
スライスを作成します。
自動導出も初期化します。
s1:=[]int{1,2,3,4,5}フォーマット：作る（スライスタイプ、長さ、ボリューム）機能が初期化させる意味
s2:=make([]int, 5, 10) //切片容量可以不指定，默认容量与长度相同スライス取ら：基本的な形態：S：=：高い：低い最大]を
s:=a[0:3:5]組み込み関数：LEN（S）スライス印刷長、キャップ（S）スライス印刷能力。
低：次のスライスの始点の対象
高：被験者の終わりにスライス（含まれていません）
高低スライスの長さlen =
スライスキャップ= MAX-低容量
アレイの動作と同様：スライス内の個々の動作要素
data:=array[1]アレイ上で撮影したセクション：
array:=[]int{1,2,3,4,5,6,7,8,9}
s1:=array[:] //[0:len(array):len(array)]不指定，默认容量与长度相同
s2:=array[3:6:7] //从array[3]开始到array[5]，长度是3，容量是4
s3:=array[:6] //从0开始取6个元素，长度和容量都是6，此方法最为常用
s4:=array[3:] //从array[3]开始，取到结尾
s5:=array[2:5] //从array[2]开始，取3个元素需要注意的是：切片指向底层数组，在对某个切片元素重新赋值时，无论切片经过多少次重切，切片所指向的最底层数组的相应元素也会跟着被重新赋值，改变。
切片的append追加函数：自动扩容，一旦超过原底层容量，容量通常以两倍的容量重新分配底层数组并复制数据。
append(s,1) //在切片s末尾添加元素1切片的copy函数：对某一切片的前几位用原切片做覆盖。copy(目的切片,原切片)
copy(s1,s2) //将s2替换到s1的前几位切片做函数参数：引用传递，传递方式与数组值传递相同，但不会完整传递，只会传递所需的某个元素。
产生随机数：产生四位随机数。
传统方法：
rand.Intn(10000) //产生随机数通过if判断是否大于等于1000推荐方法：
rand.Intn(9000)+1000 //1000是四位数最小值，9000+1000是四位数最大值（不包含）切片保存数字的每一位数（4位）：可以通过数字的取商‘/’与取余‘%’配合使用，取出数字每一位并追加给切片或给切片元素赋值，如：
s[0]=2514/1000 //求千位
s[1]=(2514%1000)/100 //求百位Go语言中的map：键值对类型key-value 格式：map[key类型]vale类型{}
需要注意的是：
1.map的key-value是对应的，key不能出现重复。
2.map的打印和返回时无序的。
3.切片与函数不能作为key值。
4.几乎任何类型都可以作为value值。
5.map只有长度没有容量。
map的定义：
直接定义：
var m1 map[int]string //key为int，value为string通过make函数定义：
m2:=make(map[int]string)
m3:=make(map[int]string,10) //指定长度:只是预先分配空间，但没有存数据，长度仍是0map的初始化：
m:=map[int]string{1:”mike”,2:”tom”,3:”jack”} //常用，键值一定是唯一的map的赋值：
m[1]=”go” //为已经存在的key值赋值--修改value
m[5]=”stop” //新增key，下标超出分配空间，会自动扩充长度：不存在key值则追加，map底层自动扩容map的遍历：
for key,value:=range m{} //遍历结果是无序的判断key是否存在：
value,info:=m[1] //info返回布尔类型用来判断key：1是否存在删除key键值：
delete(m,1) //删除m中key：1map做函数参数声明及调用：引用传递，地址传递。
func fun(m map[int]string){
}
func main(){
fun(m)
}Go语言的结构体类型：
结构体的定义：与自定义函数同级，定义在主函数之外。
type Student struct{
id int
name string
sex byte
age int
addr string
}声明结构体变量：
var s1 Student = Student{1,"tom",'M',18,"北京"} //顺序初始化，每一个成员都要初始化
s2: = Student{name:"jack",age:20} //部分指定成员初始化，没有初始化成员自动赋值为0结构体指针变量初始化：声明时加“&”，使用/打印时加“*”但*可有可无。打印可以使用可以直接打印。
var p1 *Student=&Student{1,"tom",'M',18,"北京"}
p2:=&Student{name:"jack",age:20}结构体成员的使用：操作程序需要用到 . 运算符。
普通变量：
s1.id=10086
s1.name="zx"
s2.age=18
s2.addr="天津"指针变量：指针有合法指向后才能操作成员。
var s Student //先定义普通结构体变量
var p *Student //再定义指针变量指向s保存其地址
p=&s通过指针操作成员变量时：以下两种语句完全等价，与其他语言不同，都只能运用 . 运算符。
p.id //推荐写法
(*p).idnew函数创建空间：
p:=new(Student)Go语言中结构体的比较：与数组比较相类似，只能用==和!=运算符，返回布尔类型。
结构体赋值：同类型的结构体可以相互赋值。
结构体作为函数参数的使用：
值传递：同名不同作用域的函数声明以及调用。
func fun (s Student){
}
func main(){
fun(s) //值传递，实参不会跟着实参一起改变
}地址传递/引用传递：
func fun(p *Student){
}
func main(){
fun(&s) //引用传递，参数跟着函数内部改变
} 可见性规则：
如果想使用其他包的函数、结构体类型、结构体成员。函数名，类型名，结构体成员变量名的首字母必须大写。如果首字母是小写，则只能在同一个包里面使用。