文章目录
一、变量和常量的使用
1、变量的使用
1.1、含义
变量时为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法
变量的本质就是一小块内存，用于存储数据，在程序运行过程中数值可以改变
1.2、声明变量
格式化输出
| %s | 输出字符串 |
|---|---|
| %d | 输出整型 |
| %T | 输出数据类型 |
| %p | 输出变量地址，&+变量名 |
| %v | 值的默认格式表示 |
| %% | 百分号 |
| %b | 表示为二进制 |
| %c | 该值对应的unicode码值 |
| %d | 表示十进制 |
| %o | 表示为八进制,小写字母o |
| %x | 表示为十六进制，使用a-f |
| %X | 表示为十六进制，使用A-F |
| %U | 表示为Unicode格式：U+1234，等价于"U+%04X" |
| %t | 单词true或false |
var 名称类型是声明单个变量的语法
以字母或下划线开头，由一个或多个字母、数字、下划线组成
/*第一种，指定变量类型，声明后若不赋值，使用默认值
格式：
var name type
var name type = 值
name=value*/
//例子：
var name string
name="小白"
fmt.printf("名字为%s",name)
package main
import "fmt"
func main() {
var name string
name="小白"
fmt.Printf("名字为%s",name)
}
//第二种，根据值自行判定变量数据类型
/*如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。如果变量具有初始值，则可以省略变量申明
*/
var name="value"
//格式化%T输出该变量的数据类型
fmt.Printf("类型是%T",name)
/*第三种、简短定义，省略var，注意 := 左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量)，否则会导致编译出错
格式：
变量名 := 100
*/
sum := 100
fmt.Printf("类型是%d",sum)
/*
多变量同时声明
*/
var a,b, c int
a=1
b=2
c=3
var d,e int = 1,2
var f,g = 1,"GO"
fmt.Println(a,b,c,d,e,f,g)
/*
集合类型(多变量)
*/
var(
name = "name"
num = 100
)
var(
name1 string = "name"
num1 int =1
)
fmt.Println(name,name1,num,num1)
/*匿名变量使用下划线_,如果我们接收到多个变量，有一些变量使用不到，可以使用下划线_表示变量名称，这种变量叫做匿名变量。*/
package main
import "fmt"
func getNameAndAge() (string, int) {
return "小白", 30
}
func main() {
name, _ := getNameAndAge()
fmt.Printf("name: %v\n", name)
}
输出：
name: 小白
1.3、注意事项
- 变量必须先定义才能使用
- go语言是静态语言，要求变量的类型和赋值的类型必须一致
- 变量名不能冲突(同一个作用域内不能冲突)
- 简短定义方式，左边的变量名至少有一个是最新的
- 简短定义方式，不能定义全局变量
- 变量的零值。也称为默认值，字符串默认值为空串，整型默认为0，float64(默认为0)，切片(默认[])，bool（默认为false）
- 变量定义了就要使用，否则无法编译通过
2、常量的使用——constant
2.1、常量声明
常量是一个简单值的标识符，在程序运行时，不会修改的值。
常量声明定义之后没有使用程序也是可以编译通过，变量如果声明定义之后没有使用程序会编译出错
语法:const 常量名 [类型] = 值
显式类型定义 const b string = “ABC”
隐式类型定义 const b = "abc"
//定义一组常量
const a,b=1,"abc"
const a,b int =1,2
//一组常量中，如果某个常量没有初始值，默认和上一行常量是一样的
const(
a int=1
b
)
fmt.Println(a,b)
输出结果为：1 1
//枚举类型：使用常量组作为枚举类型，一组相关数值的数据
const(
SPRING=0
SUMMER=1
AUTUMN=2
WINTER=3
)
2.2、常量的注意事项
- 常量中的数据类型只可以是布尔类型、数字型（整数型、浮点型和复数）和字符串型
- 不曾使用的常量，在编译的时候是不会报错的
- 显示指定类型的时候，必须确保常量左右值类型一致，需要时可显示类型转换。这与变量就不一样，变量时可以不用类型值
3、特殊的常量iota
iota，特殊的常量，可以认为是一个可以被编译器修改的常量，iota可以被看作枚举值
/*第一个iota等于0,每当iota在新的一行被使用时候，它的值就会自动加一，所以a=0,b=1,c=2,两种写法*/
const(
a=iota
b=iota
c=iota
)
const(
a=iota //0
b //1
c//2
)
package main
import "fmt"
func main() {
const(
a=iota//iota=0
b//iota=1
c//iota=2
d="hah"//iota=3
e//"hah" iota=4
f=iota //iota=5
g//iota=6
)
fmt.Println(a,b,c,d,e,f,g)
}
输出结果：0 1 2 hah hah 5 6
二、数据类型
1、基本数据类型
数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
1.1、布尔型bool
布尔型的值只可以是常量 true 或者 false。var b bool = true
1.2、数值型
整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
1、整型
| 类型 | 数据范围 |
|---|---|
| uint8 | 无符号 8 位整型 (0 到 255) |
| uint16 | 无符号 16 位整型 (0 到 65535) |
| uint32 | 无符号 32 位整型 (0 到 4294967295) |
| uint64 | 无符号 64 位整型 (0 到 18446744073709551615) |
| int8 | 有符号 8 位整型 (-128 到 127) |
| int16 | 有符号 16 位整型 (-32768 到 32767) |
| int32 | 有符号 32 位整型 (-2147483648 到 2147483647) |
| int64 | 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) |
2、浮点型
| 类型 | 描述 |
|---|---|
| float32 | IEEE-754 32位浮点型数 |
| float64 | IEEE-754 64位浮点型数 |
| complex64 | 32 位实数和虚数 |
| complex128 | 64 位实数和虚数 |
3、其他数字类型
| 类型 | 描述 |
|---|---|
| byte | 类似 uint8 |
| rune | 类似 int32 |
| uintptr | 无符号整型，用于存放一个指针 |
1.3、字符串型
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本
var str string
str="helloworld"
//区别'A' "A"
a :='A'
b :="A"
fmt.Printf("'A':%T,%d,\n\"A\":%T,%s",a,a,b,b)
输出结果：
'A':int32,65,
"A":string,A
//转义字符
\+字符：例如\n换行
1.4、基本数据类型强制转换
//语法格式：Type(Value)
//常数：在有需要的时候，会自动转换
//变量：需要手动转型T(V)
//注意点：兼容的类型才可以转换
var a int8 =-8
var b uint8 = uint8(a)
fmt.Printf("a:%d b:%d",a,b)
输出结果：
a:-8 b:248
三、运算符
1、算术运算符
+ - * / %(求余) ++ --
var a int8 =-8
var b int8 = 11
var c int8 =a+b
fmt.Println(c)
2、关系运算符
== != > < >= <=
a :=10
b :=11
c := a>b
fmt.Println(c)
3、逻辑运算符
&& || !(与或非)
a :=0
b :=1
c := (a>b)&&(a>b)
fmt.Println(c)
4、位运算符
A&^B：对于B上的每个数值，如果是0，则取A对应位的数值，如果为1，则结果位取0
5、赋值运算符
^=等等
6、运算符优先级
可以使用括号来提升优先级
