什么是Go语言

go语言是一门静态强类型语言

  • 什么是动态和静态:

    • 可以理解为解释型和编译型 （python，动态解释型语言 一边编译一边执行）（golang，java，静态编译型语言 必须先将文件编译成可执行文件后才能运行）

  • 什么是强类型语言：

    • 强制类型定义的语言，即一旦某一个变量被定义类型，如果不经强制转换，那么它永远就是该数据类型。

    • 强类型语言包括：Java、Python、C++等语言。其中Python是动态语言，是强类型定义语言，是类型安全的语言，Java是静态语言，是强类型定义语言，也是类型安全的语言。

  • 什么是弱类型语言：

    • 弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化自动。

    • 弱类型语言包括：VB，PHP，JavaScript等语言。其中VBScript是动态语言，是一种类型不安全的原因。

  • Go 语言特色

    • 简洁、快速、安全

    • 并行、有趣、开源

    • 内存管理、数组安全、编译迅速

  • Go 语言用途

    • Go 语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。对于高性能分布式系统领域而言，Go 语言无疑比大多数其它语言有着更高的开发效率。它提供了海量并行的支持，这对于游戏服务端的开发而言是再好不过了。

GO语言开发注意事项

  1. Go是以包作为管理单位 每个Go源文件必须声明它所属的包。

  2. Go应用程序的执行入口是main()方法。

  3. main函数只能声明在main包中，不能声明在其他包中,并且一个main包中也必须有且仅有一个main函数。

  4. Go语言严格区分大小写。

  5. 函数的左大括号必须和函数在同一行。

  6. Go语言通过import导包，用什么包导什么包(导入了不用会编译出错)。

  7. Go是以包作为管理单位 每个Golang源文件必须声明它所属的包。

Hello Golang

编写go语言的第一个文件

1
2
3
4
5
6
7
8
9
package main   

import (f "fmt")

func main(){

	f.Println("你好 golang")

}

Go语言数据类型

整形数据类型(int)

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 (
	f "fmt"
	"math"
)

// 有符号整形
func main(){
	// 整形顾名思义就是存储数据类型是正数。
	// golang中分为衣服好和无符号，简单理解就是存储范围上的差异，
	// 有符号整形分为 int 86 32 64  以及默认的int
	// 除非我们需要使用特定大小的整数，否则通常都使用int来表示整数
	var num8 int8 = 127
	var num16 int16 = 32767
	var  num32  int32 = math.MaxInt32
	var num64 int64 = math.MaxInt64
	var num int = math.MaxInt

	// golang 支持累加操作  a:=1  a++
	// python 就不支持累加操作 必须这样写  a+=1

	f.Printf("num8是 %d\n",num8)
	f.Printf("num16是 %d\n",num16)
	f.Printf("num32是 %d\n",num32)
	f.Printf("num64是 %d\n",num64)
	f.Printf("num是 %d\n",num)

}

字符串数据类型(string)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	f "fmt"
)

// 字符串
func main(){
	// 字符串几乎是我们最常见的数据类型之一，使用起来也很方便，直接使用双引号进行引用即可
	// 有些字符串没有线程的文字代号，只能使用转义字符来标书，比如这里哥/t

	mystring := "hello\tgolang.18"
	f.Printf(mystring)

}

浮点数据类型(float)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import (
	f "fmt"
	"math"
)

// 浮点
func main(){
	// 浮点数据类型表示存储的数据是实数，比如说3.1415926，主要分为32和64位
	// 区别在于长度。和整数一样，除非需要使用特定大小的浮点，否则通常都使用float来表示浮点 

	var num1 float32 = math.MaxFloat32
	var num2 float64 = math.MaxFloat64

	f.Printf("num1的类型是%T,num1是%g\n",num1,num1)
	f.Printf("num2的类型是%T,num2是%g\n",num2,num2)

	// num1的类型是float32,num1是3.4028235e+38
	// num2的类型是float64,num2是1.7976931348623157e+308

}

字符数据类型(byte)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
	f "fmt"

)

// 字符
func main(){
	// 字符是组成字符串的最小元素，golang中使用byte定义字符串，
	// byte表示utf-8字符串单个字节的值

	// byte 使用单引号 '' 代表字节码
	// 双引号 "" 代表字符串

	var x byte = 65
	var y uint8 = 65

	f.Printf("x = %c\n",x) // x = A
	f.Printf("y = %c\n",y) // y=A
	// x = A
	// y = A

}

布尔数据类型(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
package main

import (
	f "fmt"
)

// 布尔 bool
func showBool(){
	// bool通常情况下表示真或者假通常出现在条件语句中，在Python中布尔数据类型可以参与数值运算，也可以和其他数据类型进行转换
	//  但是在golang中镇值用true表示，并且不与1相等，同样假值用false表示，并且不与0相等，使用上相对严格，没有Python那么挥洒自如
	a := true
	b := false
	f.Println("a=",a)
	f.Println("b=",b)
	f.Println("true && false = ",a && b)
	f.Println("true || false = ",a || b)

}


func main(){
	showBool()
	
}

Go语言容器数据类型

哈希数据类型(hash)

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
package main

import f "fmt"


func main(){
	// 容器数据类型
	//  字典也叫集合 (map)
	// "key:value  key只能是可哈希的值(不可以扩容缩容的值)"


	s_dict := map[string]int{
		"小明":10,
		"小红":20,
	}

	f.Println(s_dict["小红"])//通过key取值
	// 如果要获取的key不存在的话 会返回你当前定义的value的数据类型的0值
	// 而python的话获取不存在的key会报错，或者使用python字典.get('小红',None)设定默认值


	d_dict := map[int]int{}  //允许空值

	// 赋值操作 循环 或者根据key来赋值
	for i := 0; i < 5; i++ {
		d_dict[i]=i
	}

	// 遍历操作  如果你用不到key或者value可以使用_占位符代替,_只做占位符做用并不是声明。
	for key,value := range  d_dict{


		f.Println(key,value)
	} 

	f.Println(d_dict)

}

Go语言的变量(var)和常量(content)

什么是变量和常量

  • 变量

    • 变量是具体数据被内存存储之后内存地址的名称，说白了就是内存中的门牌号。

  • 常量

    • 表示不变的值，在程序运行时，不会被代码逻辑修改，比如数字上的圆周率，自然常数e等

变量

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
// 变量是具体数据被内存存储之后内存地址的名称，说白了就是内存中的门牌号。
package main

import (
	f "fmt"
	"unsafe"
)

func main() {
	// 在Golang里我们使用var关键字声明变量
	// 如果是有初始值的变量我们可以省略变量声明中的类型
	// var name int
	// var name =1
	
	// 海象操作符来声明变量，这还重方式可以不使用var关键字。事实上呢，
	// 它更像是一个连贯操作，我们可以既声明又赋值，那么我们这个操作可以算得上是一种赋值表达式
	// 但是需要注意已经声明过的变量就不是再次使用海象操作符来声明了
	// 海象操作符只能用在函数的内部

	// 可以使用&符号查看内存地址
	// 也可以使用unsafe.Sizeof获取内存大小 
	var name 
	name = 666
	f.Println(&name)
	f.Println(unsafe.Sizeof(name))

	// golang 也支持交换赋值操作
	b,a := "bbbbb","aaaaa"

	b,a = a,b

	f.Println(a,b)

}

常量

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 (
	f "fmt"
)

func main(){

	// 常量constant 表示不变的值，在程序运行时，不会被代码逻辑修改，比如数字上的圆周率，自然常数e等
	const num int = 1

	// const也可以定义枚举类型
	// 常量声明可以使用 iota 常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。
	// 在一个 const 声明语句中，在第一个声明的常量所在的行，iota 将会被置为 0，然后在每一个有常量声明的行加一。

	const (
		// 可以在const()中添加一个关键字iota, 每行的iota都会累加1, 第一行的iota默认是0
		a = iota      // iota = 0
		b             // iota = 1
		c             // iota = 2
	)

	f.Println(num)

}

Go语言的作用域(scope)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import (f "fmt")


// 在函数或者块之外定义的变量我们称之为全局变量，这些变量在程序的整个生命周期中国，都可以使用
var myvarable3 int = 6


func main(){
	// 变量的作用域可以理解为可访问变量的程序的某个范围，比如说啊，在类里，方法里
	// 循环里面定义的变量，那么在函数或代码库尔中声明的变量，我们称之为虎局部变量，
	// 这些变量不能在函数或块之外的的地方访问，所以这些变量我们可以称之为块变量。

	var myvarable1,myvarable2 int =  69,145

	f.Println(myvarable1,myvarable2,myvarable3)

}

Go语言的运算操作符

数学运算符(+ - * / %(取余))

1
2
3
4
5
6
7
8
a := 1
	b := 2
	c := false
	f.Println(a+b)
	f.Println(a-b)
	f.Println(a*b)
	f.Println(a/b)
	f.Println(a%b)

比较运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
if (a==b){
	f.Println("等于")
}

if (a!=b){
	f.Println("不等于")
}

if (a>b){
	f.Println("大于")
}

if (a<b){
	f.Println("小于")
}

if (a>=b){
	f.Println("大于等于")
}

if (a<b){
	f.Println("小于等于")
}

逻辑运算符

1
2
3
4
5
6
7
8
9
10
11
if a==1 && b==2{
	f.Println("逻辑与")
}

if a==1 || b==1{
	f.Println("逻辑或")
}

if !c{
	f.Println("逻辑非")
}

位运算

1
2
3
4
5
f.Println(a & b) //位于  可以判断一个结点是否有一个权限
f.Println(a | b) //位或   可以给一个结点权限
f.Println(a ^ b) //位异或  可以删除一个结点的权限
f.Println(a << 1) //左位移  可以将某一条数据整体向左移动
f.Println(a >>1) //右位移   可以将某一条数据整体向右移动

捕获用户终端输入

1
2
3
4
var  x int
f.Println("请输入一个整数")
f.Scanln(&x) //读取键盘的输入，通过操作地址，赋值给x
f.Println(x)

再此奉上Golang基础集合的github地址供大家参考
https://github.com/renaissancezyc/golang-Basics