13518219792
给别人看的，机器并不会执行这行语句
创新互联专注于企业网络营销推广、网站重做改版、山海关网站定制设计、自适应品牌网站建设、H5建站、商城网站开发、集团公司官网建设、成都外贸网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为山海关等各大城市提供网站开发制作服务。
// 我是单行注释
/*
我是多行注释
我是多行注释
我是多行注释
我是多行注释
*/
// 这是一个main函数，这个是go语言启动的入口
func main() {
//fmt.Println ：打印一句话，然后执行完毕后，进行换行
fmt.Println("Hello,Word")
}
字面理解为变量就是会变化的量
package main
import "fmt"
func main() {
var name string = "DuPeng"
fmt.Println(name)
}
注意：如果在点击这里执行会出错
出错提示：项目里有多个main方法
正确执行方式：鼠标单击右键执行，一定要在main方法外！ 一定要在main方法外 ！一定要在main方法外，重要事情说三遍
var name type
name
name 为变量，它指向的是地址，而这个地址指向内存空间，而内存空间的数据是可以更换的
var
声明变量的关键字，固定的写法，记住即可
type
代表变量的类型
定义多个变量
package main
import "fmt"
// “=” 赋值符号 将等号右边的值赋值给等号左边
func main() {
var (
//姓名
name string
//年龄
age int
//地址
addr string
)
//string 默认值：空
//int 默认值：0
fmt.Println(name, age, addr)
}
标准格式
var 变量名 类型 =值(表达式)
也可以先定义，再赋值
package main
import "fmt"
func main() {
// “=” 赋值符号
var (
//姓名
name string
//年龄
age int
//地址
addr string
)
name = "dupeng"
age = 22
addr = "成都"
//string 默认值：空
//int 默认值：0
fmt.Println(name, age, addr)
}
短变量声明并初始化
import "fmt"
func main() {
// :=自动推导
name := "dupeng"
age := 18
fmt.Println(name, age)
//打印输出name和age的类型
fmt.Printf("%T,%T", name, age)
}
打印输出声明类型
打印内存地址
import "fmt"
func main() {
var num int
num = 100
fmt.Printf("num：%d,内存地址：%p", num, &num)
}
不要忘记取地址符
值发生变换而内存地址不会发生改变，但每次重启系统就会重新分配一个新的地址空间
package main
import "fmt"
func main() {
/*
在其他语言中 变量的交换为下列代码
a=100
b=200
temp=0
temp=a
a=b
b=temp
*/
// 而在go语言中
var a int = 100
var b int = 200
b, a = a, b
fmt.Println(a, b)
}
特点是"_","_"本身就是一个特殊字符
被称为空白标识符，任何赋值给这个标识符的值都会被抛弃，这样可以加强代码的灵活性
package main
import "fmt"
func test() (int, int) {
return 100, 200
}
func main() {
a, b := test()
fmt.Println(a, b)
}
当我们不想接收第二个值时可以废弃掉
package main
import "fmt"
func test() (int, int) {
return 100, 200
}
func main() {
a,_ := test()
fmt.Println(a)
}
一个变量（常量、类型或函数)在程序中都有一定的作用范围，称之为作用域。
局部变量
在函数体声明的变量，只作用在函数体内
全局变量
在函数体外声明的变量为全局变量
全局变量必须以var关键字开头，如果要在外部包使用全局变量的首字母必须大写
是一个简单值得标识符，在程序运行时，不会被修改的量
数据类型：布尔型，数字型，（整数型、浮点型和复数型）和字符串型
当定义完常量后，常量不允许被修改，否则会出错
示例：
特殊常量，可以认为是一个被编译器修改的常量
iota是go语言的常量计数器 从0开始 依次递增
直至const出现之时将被重置
package main
import "fmt"
func main() {
const (
a = iota //0
b //1
c //2
d = "dd" // dd iota=3
e //4
f = 100 //100 iota=5
g //6
h = iota //haha iota=7
i //8
)
const (
j = iota
k
)
fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}
//输出结果：0 1 2 dd dd 100 100 7 8 0 1
在Go编程语言中，数据类型用于声明函数和变量。
数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
编译器在进行编译的时候，就要知道每个值的类型，这样编译器就知道要为这个值分配多少内存，并且知道这段分配的内存表示什么。
布尔型的值只可以是常量true或者false
布尔类型的值默认为false
package main
import "fmt"
func main() {
// var 变量名 数据类型
var isFlang bool
fmt.Println(isFlang)
}
//输出结果为：false
整形int和浮点型float32、float64、Go语言支持整形和浮点型数字，并且支持负数，其中位 的运算采用补码
| 序号 | 类型和描述 |
|---|---|
| 1 | uint8无符号8位整型(O到255) |
| 2 | uint16无符号16位整型(O到) |
| 3 | uint32无符号32位整型(O到) |
| 4 | uint64无符号64位整型(0到) |
| 5 | int8有符号8位整型(-128到127) |
| 6 | int16有符号16位整型(-到) |
| 7 | int32有符号32位整型(-到) |
| 8 | int64有符号64位整型(-到 ) |
package main
import "fmt"
func main() {
//定义一个整形
//byte uint8
//rune int32
//int int64
var age int = 18
fmt.Printf("%T,%d\n", age, age)
//定义一个浮点型
var money float32 = 300.15
//这里打印浮点数类型为%f
//默认是6位小数打印
fmt.Printf("%T,%f\n", money, money)
}
//输出结果：int,18
//float32,300.
1、关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位
2、尾数数部分可能丢失，造成精度损失。-123.0000901
| 序号 | 类型和描述 |
|---|---|
| 1 | float32 IEEE-754 32位浮点型数 |
| 2 | float64 lEEE-位浮点型数 |
| 3 | complex64 32位实数和虚数 |
| 4 | complex128 64位实数和虚数 |
类型别名
| 序号 | 类型和描述 |
|---|---|
| 1 | byte类似于uint8 |
| 2 | rune类似于int32 |
| 3 | uInt32或64位 |
| 4 | int与uint一样大小 |
| 5 | uintprt无符号整形，用于存放一个指针 |
字符串就是一串固定长度的字符连接起来的字符序列。
Go的字符串是由单个字节连接起来的。
Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
package main
import "fmt"
func main() {
//字符串 双引号
var str string
str = "hello,word"
//输出打印的类型和值
fmt.Printf("%T,%s\n", str, str)
// 字符 单引号
//字符为数值类型，需要%d打印
//所有中国字的编码表：GBK
//全世界的编码表：Unicode编码表
v1 := 'A'
v2 := "B"
v3 := '中'
//编码表 ASCII字符吗
fmt.Printf("%T,%d\n", v1, v1)
fmt.Printf("%T,%s\n", v2, v2)
fmt.Printf("%T,%d\n", v3, v3)
//字符串拼接
fmt.Printf("hello" + "学相伴\n")
//转义字符 \
fmt.Printf("hello\"学相伴\"\n")
//间隔符 \t tab
fmt.Printf("hello\"学相伴\t")
}
在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。
由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明
package main
import "fmt"
func main() {
a := 3 //int
b := 4.0 //float64
//需求：将a转换为float64位
c := float64(a)
//boll 整形是不能转换为bool的
//cannot convert a (variable of type int) to type bool
//e := bool(a)
fmt.Printf("%T\n", a)
fmt.Printf("%T\n", b)
fmt.Printf("%T\n", c)
//fmt.Printf("%T\n", e)
}
/*
输出结果为：
int
float64
float64
*/
类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型(将int16转换为int32)。
当从一个取值范围较大的类型转换到取值范围较小的类型时(将int32转换为int16或将 float32转换为 int)，会发生精度丢失（截断）的情况。
下表列出了所有Go语言的算术运算符。假定A值为10，B值为20。
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 相加 | A+B输出结果30 |
| - | 相减 | A-B输出结果-10 |
| * | 相乘 | A*B输出结果为200 |
| / | 相除 | B/A输出结果为2 |
| % | 求余 | B%A输出结果为0 |
| ++ | 自增 | A++输出结果11 |
| -- | 自减 | A--输出结果为9 |
package main
import "fmt"
func main() {
var a int = 10
var b int = 3
// + - * / % ++ --
fmt.Println(a + b)
fmt.Println(a - b)
fmt.Println(a * b)
fmt.Println(a / b)
a++ //a=a+1
fmt.Println(a)
a-- //a=a-1
fmt.Println(a)
}
/*输出结果为：
13
7
30
3
11
10
*/
下表列出了所有Go语言的关系运算符。假定A值为10，B值为20。
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个值是否相等，如果相等返回True否则返回false | A==B 为false |
| ！= | 检查两个值是否不相等，如果不相等返回True否则返回false | A！=B为true |
| > | 检查左边值是否大于右边值，如果是返回True否则返回false | A>B 为false |
| < | 检查左边值是否小于右边值，如果是返回True否则返回false | A |
| >= | 检查左边值是否大于等于右边值，如果是返回True否则返回false | A>=B 为false |
| <= | 检查左边值是否小于等于右边值，如果是返回True否则返回false | A<=B 为true |
package main
import "fmt"
func main() {
var A int = 10
var B int = 20
//关系运算符，结果都是bool
fmt.Println(A == B)
fmt.Println(A != B)
fmt.Println(A > B)
fmt.Println(A < B)
fmt.Println(A >= B)
fmt.Println(A <= B)
/*
输出结果：
false
true
false
true
false
true
*/
}
下表列出了所有Go语言的逻辑运算符。假定A值为true，B值为false。
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 逻辑AND运算符，如果两边的操作数都是True，则条件True，否则为False。 | A&&B 为false |
| || | 逻辑OR运算符，如果两边的操作数有一个True，则条件True，否则为False。 | A||B为true |
| ！ | 逻辑NOT运算符，如果条件为True，则逻辑NOT条件False，否则为True。 | ！（A&&B ）为true |
逻辑与&&
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
//如果a和b同时为真
if a && b {
//那么我们输出为 true
fmt.Println(a)
} else {
//否则输出为 false
fmt.Println(b)
// 输出的结果为 ：false
}
}
逻辑或||
遇真则真，全假则假
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
//当a或者b其中一个为真那么结果为真，
if a || b {
//那么我们输出为 true
fmt.Println(a)
}
//输出结果： true
}
逻辑非！
非也，也可以理解取反，表示否定的意思
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
//非b 那么！b=ture
if !b {
//那么我们输出为 a，因为a=true
fmt.Println(a)
}
//输出结果： true
}
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符"&"是双目运算符。都是1结果为1，否则是0 | (A&B)结果为12,二进制为0000 1100 |
| | | 按位或运算符"|"是双目运算符。都是0结果为0，否则是1 | (A |B)结果为61，二进制0011 1101 |
| ^ | 按位异或运算符"A"是双目运算符。不同则为1，相同为0 | (A^B)结果为49,二进制为0011 0001 |
| &^ | 位清空，a &^b，对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0. | (A&^B)结果为48,二进制为0011 0000 |
| << | 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补O。 | A<<2结果为240，二进制为1111 0000 |
| >> | 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。 | A>>2结果为15，二进制为0000 1111 |
package main
import "fmt"
func main() {
// 二进制 逢二进一
//位运算：二进制
// 60 0011 1100
// 13 0000 1101
//----------------进行&运算
// 12 0000 1100 我和你 同时满足
//----------------进行|运算
// 61 0011 1101 我或你 一个满足即可
// 49 0011 0001 不同为1 相同为0
var a uint = 60
var b uint = 13
//与运算结果
fmt.Printf("%d,二进制：%b\n", a&b, a&b)
//或运算结果
fmt.Printf("%d,二进制：%b\n", a|b, a|b)
//非运算结果
fmt.Printf("%d,二进制：%b\n", a^b, a^b)
//a向左移动两位
// 60 0011 1100
// 移动之后 1111 0000
fmt.Printf("左移动后后的十进制：%d,左移动后的二进制：%b\n", a<<2, a<<2)
//a向右移动两位
// 60 0011 1100
// 移动之后 0000 1111
fmt.Printf("右移动后后的十进制：%d,右移动后的二进制：%b\n", a>>2, a>>2)
/*
输出结果：
12,二进制：1100
61,二进制：
49,二进制：
左移动后后的十进制：240,左移动后的二进制：
右移动后后的十进制：15,右移动后的二进制：1111
*/
}
下表列出了所有的Go语言的赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | C =A+B将A＋B表达式结果赋值给C |
| += | 相加后再赋值 | C +=A等于C=C+A |
| -= | 相减后再赋值 | C -=A等于C=C-A |
| *= | 相乘后再赋值 | C *=A等于C=C *A |
| /= | 相除后再赋值 | C/=A等于C=C/ A |
| %= | 求余后再赋值 | C%=A等于C=C%A |
| <<= | 左移后赋值 | C<<=2等于C=C<<2 |
| >>= | 右移后赋值 | C>>=2等于C=c>>2 |
| &= | 按位与后赋值 | C&=2等于C=C&2 |
| ^= | 按位异或后赋值 | C=2等于C=C2 |
| != | 按位或后赋值 | C|=2等于C=C|=2 |
package main
import "fmt"
func main() {
var A int = 10
var B int = 20
var C int
// 赋值运算符 =
C = A + B
fmt.Println(C) //结果为30
// 相加后再赋值
C += A //注意这里初始值为：C=30 C= C+A=30+10
fmt.Println(C)
/*
输出结果：
30
40
*/
}
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a;将给出变量的实际地址 |
| * | 指针变量 | *a；是一个指针变量 |
package main
import "fmt"
func main() {
var a int
var b float32
//定义了两个变量，想用键盘来录入这个两个变量
//fmt.Println() 打印并换行
//fmt.Printf() 格式化输出
//fmt.Printf() 打印输出
fmt.Printf("请输入两个数：1.整数 2.浮点数\n")
fmt.Scanln(&a, &b)
fmt.Printf("输出的两个数的结果为：\n")
fmt.Println("a:", a, "b:", b)
// fmt.Scanln（） 接受输入scan
// fmt.Scanf（） 接受输入 格式化输入 作业
// fmt.Scan（） 接受输入 作业
}
命名规范
命名是代码规范中很重要的一部分，统一的命名规则有利于提高的代码的可读性，好的命名仅仅通过命名就可以获取到足够多的信息。
包名：package
保持package的名字和目录名保持一致，尽量采取有意义的包名，简短，有意义，尽量和标准库不要冲突。包名应该为小写单词，不要使用下划线或者混合大小写。
package model
package main
文件名
尽量采取有意义的文件名，简短，有意义，应该为小写单词，使用下划线分隔各个单词(蛇形命名)。
