1.GO 数据类型
1.布尔类型 bool
var flag bool = true;
2.数字类型 int float32 float64 byte
Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
3.字符类型
没有专门的字符类型，使用byte保存单个字母字符
4.字符串类型
string
5.派生类型
包括：
5.1.指针类型 Pointer
5.2.数组类型
5.3.结构化类型 struct（结构体）
5.4.Channel类型（管道）
5.5.函数类型
5.6.切片类型（slice）
5.7.接口类型 interface
5.8.Map类型
2.GO 变量
变量可以通过变量名访问。
1.Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
2.声明变量
//var identifier type
//一次性声明多个变量
//var identifier1,identifier2 type
实例：
package main
import "fmt"
func main(){
var a string="123"
fmt.Println(a)
var d,c int =1,2
fmt.Println(d,c)
}
//输出结果
//123
//1 2
2.1 指定变量类型
如果没有初始化，变量默认为零值
var a int;
a = 1
实例：
package main
import "fmt"
func main(){
var a int;
fmt.Println(a)
//int类型 零值为0
var b bool;
fmt.Println(b)
//bool类型 零值false
var c string;
fmt.Println(c)
//string类型 零值为""（空字符串）
}
2.2 根据值判定变量类型
package main
func main(){
var d = true
fmt.Println(d)
}
//输出 true
2.3 变量如果已经使用var声明，再使用：=声明变量，会报错
package main
func main(){
var e = 123
e:=222
//报错
}
//e：=222相当于
var e int;
e = 222;
可以将 var f string = “Runoob” 简写为 f := “Runoob”：
3.多变量声明
//类型相同的多变量声明
var v1,v2,v3 string;
v1,v2,v3 = 1,2,3
//类型自动推断
var a1,a2,a3 = 1,2,3;
//简写//这种不带声明格式的只能在函数体中出现
c1,c2,c3 :=1,2,3
//c1,c2,c3 不能是已经声明过的变量，否则会导致编译报错
//以下为因式分解关键字写法，一般用于全局变量
var (
name1 string
name2 bool
)
4.常量
常量是一个简单值的标识符，在程序运行中不会被修改的量
常量中的数据类型只能是布尔类型，数字类型（整型、浮点和复数类型）和字符串类型
格式：
const identifier [type] = value
//可以省略type 编译器会自行推断
//显式
const id string = "123"
//隐式
const user = "小王"
//多个常量声明可以简写
const value1,value2,value3 = 1,2,3
常量还可以用作枚举
const (
//未知 0
Unkown = 0
//男性 1
Female = 1
//女性 2
Male = 2
)
常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：
package main
import "fmt"
const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a)
)
func main(){
fmt.Println(a,b,c)
}
//结果
//"abc" 3 16
5.iota
特殊常量
可以认为是一个可以被编译器修改的常量
iota在const关键字出现时被重置为0（const 内部的第一行之前），const 中每新增一行常量声明将使iota计数一次（iota可以理解为const语句块中的行索引）
iota也可以用作枚举
const (
a = iota
b = iota
c = iota
)
//第一个iota等于0
//每当iota在新的一行被使用时，它的值会自动+1
//可简写如下
const (
a = iota
b
c
)
fmt.Println(0,1,2)
3.Go语言 运算符
go语言运算符包括：
1.算数运算符
2.关系运算符
3.逻辑运算符
4.位运算符
5.赋值运算符
6.其他运算符
1.算符运算符
假定 A 值为 10，B 值为 20。
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 相加 | A + B 输出结果 30 |
| - | 相减 | A - B 输出结果 -10 |
| * | 相乘 | A * B 输出结果 200 |
| / | 相除 | B / A 输出结果 2 |
| % | 求余 | B % A 输出结果 0 |
| ++ | 自增 | A++ 输出结果 11 |
| – | 自减 | A-- 输出结果 9 |
2.关系运算符
假定 A 值为 10，B 值为 20。
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个值是否相等，如果相等返回 True 否则返回 False。 | (A == B) 为 False |
| != | 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 | (A != B) 为 True |
| > | 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 | (A > B) 为 False |
| < | 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 | (A < B) 为 True |
| >= | 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 | (A >= B) 为 False |
| <= | 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 | (A <= B) 为 True |
3.逻辑运算符
假定 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 |
4.位运算符
对整数在内存中的二进制位进行操作。
| 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 |
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。 | (A & B) 结果为 12, 二进制为 0000 1100 |
| | | 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或 | (A | B) 结果为 61, 二进制为 0011 1101 |
| ^ | 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 | (A ^ B) 结果为 49, 二进制为 0011 0001 |
| << | 左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。 其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。 | A << 2 结果为 240 ，二进制为 1111 0000 |
| >> | 右移运算符">>“是双目运算符。右移n位就是除以2的n次方。 其功能是把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。 | A >> 2 结果为 15 ，二进制为 0000 1111 |
实例：
package main
import "fmt"
func main() {
var a uint = 60 /* 60 = 0011 1100 */
var b uint = 13 /* 13 = 0000 1101 */
var c uint = 0
c = a & b /* 12 = 0000 1100 */
fmt.Printf("第一行 - c 的值为 %d\n", c )
c = a | b /* 61 = 0011 1101 */
fmt.Printf("第二行 - c 的值为 %d\n", c )
c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("第三行 - c 的值为 %d\n", c )
c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("第四行 - c 的值为 %d\n", c )
c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf("第五行 - c 的值为 %d\n", c )
}
//第一行 - c 的值为 12
//第二行 - c 的值为 61
//第三行 - c 的值为 49
//第四行 - c 的值为 240
//第五行 - c 的值为 15
5.赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | 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 = C ^ 2 |
| |= | 按位或后赋值 | C |= 2 等于 C = C | 2 |
6.其他运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a; 将给出变量的实际地址。 |
| * | 指针变量。 | *a; 是一个指针变量 |
package main
import "fmt"
var c, d int = 1, 2
func main() {
var a int = 1
var b int32 = 2
var c float32
fmt.Printf("a得类型=%T\n", a)
fmt.Printf("b得类型=%T\n", b)
fmt.Printf("c得类型=%T\n", c)
//获取a得地址
ptr := &a
fmt.Printf("a 的值为 %d\n", a)
fmt.Printf("*ptr 为 %d\n", *ptr)
}
7.运算符优先级
有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：
| 优先级 | 运算符 |
|---|---|
| 5 | * / % << >> & &^ |
| 4 | + - | ^ |
| 3 | == != < <= > >= |
| 2 | && |
| 1 | || |
4.GO 条件语句
1.Go 语言提供了以下几种条件判断语句：
| 语句 | 描述 |
|---|---|
| if | if 语句 由一个布尔表达式后紧跟一个或多个语句组成。 |
| if…else | if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。 |
| if 嵌套语句 | 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。 |
| switch 语句 | switch 语句用于基于不同条件执行不同动作。 |
| select 语句 | select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。 |
2.if语句
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
}
实例：
//使用 if 判断一个数变量的大小：
package main
import "fmt"
func main(){
var a int = 10
if a < 20{
fmt.Printf("a小于20\n")
}
fmt.Printf("a得值：%d\n",a)
}
//a小于20
//a得值：10
3.if …else…
package main
import "fmt"
func main() {
/* 局部变量定义 */
var a int = 100;
/* 判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n" );
} else {
/* 如果条件为 false 则执行以下语句 */
fmt.Printf("a 不小于 20\n" );
}
fmt.Printf("a 的值为 : %d\n", a);
}
//a不小于20
//a的值为：100
4.if嵌套语句
if 布尔表达式 1 {
/* 在布尔表达式 1 为 true 时执行 */
if 布尔表达式 2 {
/* 在布尔表达式 2 为 true 时执行 */
}
}
package main
import "fmt"
func main(){
var a = 100
var b = 200
if a == 100{
if b==200 {
fmt.Printf("a的值为%d，b的值为%d\n",a,b)
}
}
fmt.PrintLn("a的值为100")
fmt.Println("b的值为200")
}
//a的值为100，b的值为200
//a的值为100
//b的值为200
实例:
package main
import "fmt"
func main() {
var a int
var b int
fmt.Printf("请输入密码： \n")
fmt.Scan(&a)
if a == 5211314 {
fmt.Printf("请再次输入密码：")
fmt.Scan(&b)
if b == 5211314 {
fmt.Printf("密码正确，门锁已打开")
} else {
fmt.Printf("非法入侵，已自动报警")
}
} else {
fmt.Printf("非法入侵，已自动报警")
}
}
5.Switch
switch var1 {
case val1:
...
case val2:
...
default:
...
}
//变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
5.1.Type Switch
switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。
switch x.(type){
case type:
statement(s);
case type:
statement(s);
/* 你可以定义任意个数的case */
default: /* 可选 */
statement(s);
}
package main
import "fmt"
func main() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" x 的类型 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Printf("未知型")
}
}
//x 的类型 :<nil>
5.2fallthrough
使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。
package main
import "fmt"
func main() {
switch {
case false:
fmt.Println("1、case 条件语句为 false")
fallthrough
case true:
fmt.Println("2、case 条件语句为 true")
fallthrough
case false:
fmt.Println("3、case 条件语句为 false")
fallthrough
case true:
fmt.Println("4、case 条件语句为 true")
case false:
fmt.Println("5、case 条件语句为 false")
fallthrough
default:
fmt.Println("6、默认 case")
}
}
6.for循环
计算从1加到10
package main
import "fmt"
//计算从1加到10
func main() {
sum := 0
for i := 1; i <= 10; i++ {
sum += i
}
fmt.Printf("sum=%d\n", sum)
}
sum 小于 10 的时候计算 sum 自相加后的值：
package main
import "fmt"
func main (){
sum:=1
for sum<=10{
sum+=sum
}
fmt.Printf("sum为%d\n",sum)
}
For-each range 循环
for i,j:= range xxx{
fmt.println(i,j)
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
