二 ：go语言基础语法

基本数据类型

数据类型用来声明变量和函数

布尔类型

布尔类型默认类型是flase

package main

func main() {

	var isFlag bool
	println(isFlag)

}

数字型

整形

整形int和浮点型

uint8无符号8位，（0到255）

uint16无符号16位 （0-65535）

uint32无符号32位   （0到4294967295）

uint64无符号64位整型(0到18446744073709551615)

1	int8有符号8位整型(-128到127)
2	int16有符号16位整型(-32768到32767)
3	int32有符号32位整型(-2147483648到2147483647)
4	int64有符号64位整型(-9223372036854775808到 9223372036854775807)

package main

import "fmt"

func main() {

	var age int = 18
	var money float64 = 200.999999
	fmt.Printf("%d，%T\n\n", age, age)
	fmt.Printf("%f,%T", money, money)

}

浮点型

1. 浮点数=符号位+指数为+尾数位

2.位数数位丢失可能造成损失精度

备注：

byte类似于uint8

rune类似于int32

uintprt无符号整形，用于存放一个指针

字符和字符串

字符就是一个长长的字符连接起来的字符列

package main

import "fmt"

/*
1、定义、打印输出字符串和值
2、定义、打印输出字符和值
3、字符串拼接
4、转义字符 \
5、间隔符 \t tab
*/
func main() {
	//1、定义、打印字符串类型和值
	var str string
	str = "hello,xuexiangban"
	fmt.Println(str)

	//2、定义、打印输出字符和值
	v1 := 'A'
	v2 := 'B'
	v3 := '中'
	fmt.Printf("%T\t%T\t%T\n", v1, v2, v3) //便于查看\t间隔距离

	//3、字符串拼接  +
	fmt.Println("nihao" + "你好")

	//4、转义字符 \
	fmt.Println("nihao\"xuexiaban\"")

	//5、间隔符 \t 相当于tab键盘  \n相当于回车键
	fmt.Println("hello\t\"学相伴\t")
}

数据类型转换

在一定情况下，一个类型的值可以被转换成另一种类型的值

go语言不存在隐形转换，都是显性转换，因此所有的转换都需要显示的声明

整形不能转换为bool类型

package main

import "fmt"

func main() {
	a := 5
	b := 5.0
	c := int(b)
	d := float64(a)
	fmt.Printf("%T\n", a)
	fmt.Printf("%T\n", b)
	fmt.Printf("%T\n", c)
	fmt.Printf("%T\n", d)
}

运算符

算术运算符

假设 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--
	println(a * b)
	a++
	println(a * b)

}

关系运算符

运算符	描述	实例
==	检查两个值是否相等，如果相等返回True，不等返回False	a==b false
!=	检查两个值是否不等，如果是返回True否则返回false	a!=b true
>	检查两个值是否大于右边，如果是返回True否则返回false	a > b false
<	检查两个值是否大于左边，如果是返回True否则返回false	a <b true
>=	检查两个值是否大于等于右边，如果是返回True否则返回false	a >=b flase
<=	检查两个值是否小于等于左边，如果是返回True否则返回false	a >=b ture

package main

import "fmt"

/*
1、定义两个整形变量
2、通过关系运算符 ==、！=、>、<、>=、<= 比较 并打印输出
*/
func main() {
	//1、定义两个整形变量
	var a int = 10
	var b = 20
	//2、通过关系运算符 ==、！=、>、<、>=、<= 比较 并打印输出
	fmt.Println(a == b) //false
	fmt.Println(a != b) //true
	fmt.Println(a > b)  //false
	fmt.Println(a < b)  //true
	fmt.Println(a >= b) //false
	fmt.Println(a <= b) //true

}

逻辑运算符

所有Go语言的逻辑运算符。假定A值为true，B值为false

&&	我和你都为真才为真，反之为假	A&&B为flase
||	我和你有一个为真就可以为真，反之为假	A||B为True
!	如果条件为True，则逻辑NOT条件False，否则为True	!（A&&B）为Ture

逻辑与&&

package main

import "fmt"

/*
1、定义两个布尔型的变量 一个为true 一个为false
2、通过if语句判断 并打印输出
*/
func main() {
	//1、定义两个布尔型的变量 一个为true 一个为false
	var a bool = true
	var b bool = false

	//2、通过if语句判断 并打印输出
	if a && b { //当ab同时为真
		fmt.Println(a) //那么我们输出为真 因为a=true
	} else {
		fmt.Println(b) //否则输出为假  因为b=false
	}
}

//输出结果：false

逻辑或||

package main

func main() {
	
	var a bool = true
	var b bool = false
	if a || b {
		println(a)
	}

}

逻辑或！

逻辑非可以理解为取反

package main

import "fmt"
/*
1、定义两个布尔型的变量 一个为true 一个为false
2、通过if语句判断 并打印输出
*/
func main() {
    //1、定义两个布尔型变量 一个为true 一个为false
   var a bool = true
   var b bool = false
    
	//2、通过if语句判断 并打印输出
   if !b {//非b  那么！b=ture
      fmt.Println(a)//那么我们输出为 a，因为a=true
   }
}

位运算符（二进制）

运算符	描述	实例
&	都是1结果为1，否则是0	(A&B)结果为12,二进制为0000 1100
|	都是0结果为0，否则是1	(A |B)结果为61，二进制0011 1101
^	不同则为1，相同为0	A^B)结果为49,二进制为0011 0001
&^	位清空，a &^b，对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0.	(A&^B)结果为48,二进制为0011 0000
<<	左移n位就是乘以2的n次方。由"<<"右边的数指定移动的位数，高位丢弃，低位补0	A<<2结果为240，二进制为1111 0000
>>	右移n位就是除以2的n次方。"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。	A>>2结果为15，二进制为0000 1111

package main

import (
	"fmt"
)

func main() {
	//uint可以使用十进制，二进制，十六进制
	var c uint = 0
	var a uint = 60
	var b uint = 13

	c = a & b
	fmt.Printf("十进制为:%d\n二进制为:%b", c, c)
	c = a | b
	fmt.Printf("%d，二进制为：%b", c, c)
	c = a ^ b
	fmt.Printf("%d，二进制为：%b", c, c)

	//逻辑运算符&& 我和你true  ||我或你

	c = a << 2
	fmt.Printf("%d,二进制为：%b\n", c, c)
	c = a << 2
	fmt.Printf("%d,555二进制为：%b", c, c)
}

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	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 = 21
	var b int
	b = a

	b += a
	fmt.Printf("打印的值：%d", b)
	b -= a
	fmt.Printf("您的值为：%d", b)

}

其他运算符

package main

import (
	"fmt"
)

func main() {
	var a int
	var b float64
	fmt.Printf("请输入两个整数：")
	fmt.Scan(&a, &b) //利用键盘来录入这两个变量 scanln ,传参不要忘记取地址符&
	fmt.Printf("a的值为:%d\nb的值为%f", a, b)

}