04_GoLang语言入门_基础语法_02数据类型和运算符

2021-10-19

字数统计: 3.1k字 | 阅读时长≈ 13分

本节课内容：

GO变量和常量
GO数据类型
GO运算符

1、GO变量和常量：

** 变量：**本质是一小块内存。用于存储某个数值，在程序运行过程中可以被改变。值可以更改。

** 常量：**本质是一小块内存。用于存储某个数值，在程序运行过程中不改变。值一般不更改。

变量的定义：即声明，开辟内存空间。
变量的访问：进行赋值或取值。

01、变量

形式：

1 2	var name type name = value

例子：

1
2

var a int        //go语言中定义了变量,  导入了包,  必须使用，不使用会报错！！！(可以定义，但必须使用)
var a int=10     //指针可以获取到变量开辟的内存地址。（内存空间存值）

编程语言：

静态语言
- 又称强类型语言
- 定义变量，要指明数据类型，只能存储对应类型的数据。
- Java，go，c，c#…
动态语言
- 又称弱类型语言
- 定义变量，赋值决定变量的类型。修改的值改变对应的类型。
- JavaScript, Python…

GO类型推断

GO语言中，可以是进行类型推断，可以根据数值推断该变量的类型。

var c=30

%d: 格式化一个整数 (%d、%b、%o、%x:十进制、二进制、八进制、十六进制)
%f: 格式化浮点类型，小数
%s: 格式化一个字符串
%t: 格式化一个bool类型
%T: 格式化(数值)的类型
%v: 原样输出
%c: –打印对应的字符
%p： –打印对应的字符

GO简短声明

1 2	var c=30 c:=30 //(注意：简短声明只能做局部变量，不能全局使用)

1	var x,y,z=1,2,3

var(
  x=1
  y=2
  z=3
  )

1 2	x,y,z:=1,2,3 x,y,d:=1,2,4 //必须有新值加入定义

GO舍弃字符 _

用于舍弃数值

1 2	m,n,_=1,2,3 //_当变量的意思为：只写不可读。（往往用于接受一个函数的返回值，必须接收，但可以不用） fmt.Println(m,n)

02、常量

一般情况下，常量都大写，私有的话加个小些字母“c”。
一组常量中，如果某个常量没有初始值，那么默认和上一行一致。
使用一组常量作为枚举类型
iota作为特殊的常量，go底层自动维护的计数器。
- 当用const定义常量组的时候，初始值为0，每当在常量组中定义一个常量，那么计数器就累加1。
- 下一个const出现的时候，清零。

package main
import (
	"fmt"
)

func main() { //程序的入口
	const (
		A = iota
		B
		C
		D="HAHA"
		E
		F=100
		G
		H=iota
		I
	)
	const(
		J=iota
	)
	fmt.Println(A,B,C,D,E,F,G,H,I)
	fmt.Println(J)
}

结果：

0 1 2 HAHA HAHA 100 100 7 8

编码

** ASCII：美国标准信息交换码**

** 中国： GBK**

** 台湾：大五码**

** 日本： **

** 韩国：**

Unicode编码：统一全世界

** Utf-8: 网络上传输数据用！ **
go采用Utf-8编码

回顾C#数据类型：

值类型：值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。
- Int、 float、 char
引用类型：引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。
- 内置的 引用类型有：object、dynamic 和 stringb. （号和 @引号）C# string 字符串的前面可以加 @（称作”逐字字符串”）将转义字符（\）当作普通字符对待。
指针类型
- 指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。

型描述范围默认值bool布尔值True 或 FalseFalsebyte8 位无符号整数0 到 2550char16 位 Unicode 字符U +0000 到 U +ffff’\0’decimal128 位精确的十进制值，28-29 有效位数(-7.9 x 1028 到 7.9 x 1028) / 100 到 280.0Mdouble64 位双精度浮点型(+/-)5.0 x 10-324 到 (+/-)1.7 x 103080.0Dfloat32 位单精度浮点型-3.4 x 1038 到 + 3.4 x 10380.0Fint32 位有符号整数类型-2,147,483,648 到 2,147,483,6470long64 位有符号整数类型-9,223,372,036,854,775,808 到 9,223,372,036,854,775,8070Lsbyte8 位有符号整数类型-128 到 1270short16 位有符号整数类型-32,768 到 32,7670uint32 位无符号整数类型0 到 4,294,967,2950ulong64 位无符号整数类型0 到 18,446,744,073,709,551,6150ushort16 位无符号整数类型0 到 65,5350

2、GO数据类型：

****

基本数据类型
- 布尔类型
  - True
  - False
- 数值类型
  - 整数 int
  - 浮点 float
  - 复数 complex
- 字符串
  - 多个byte的集合。
  - 理解为一个字符序列
  - 使用双引号 “ “
  - 也可以使用``tab键，并不是单引号
复合数据类型
- 数组、切片、map、结构体、指针、接口、函数… ..

整数值：

01、有符号的：正数和负数

**int8： sbyte **8位，8个01码表示的整数，最高位是符号位（0表示正数，1表示负数，剩余的7位表示数值 **[-128,127] ** ）
Int16: short 16位 [-32768, 32767]
**Int32: int rune 32位 ** [-2,147,483,648, 2,147,483,647] rune等同于c#中的char，但rune是int32整型
- int和int64是不同的数据类型
- int32与rune是同种的数据类型
**Init64: long 64位. ** [-9,223,372,036,854,775,808 , 9,223,372,036,854,775,807]
类似于c#中的byte、short、int、long*

**
**

** 02、无符号的：正数**

** Uint8: byte** ** [0,255]. 255**
** Uint16: **ushort [0,65525] 6w5
** Uint32: **uint 21亿
**** ****** Uint64: ** ulong

** 例如：255，适合用 uint8类型或byte类型存。**

** int和uint：**

根据操作系统32/64位系统决定。

** Int32与rune是一种类型，unit8与byte是一种类型。**

var a int32=32
	var b int64=32
	var c int
	var d rune 
	var e uint8=255
	var f byte 
	c=a//不能赋值
	c=b//不能赋值
	d=a
	f=e
	fmt.Println(a,b,c,d,e,f)

‘A’与A

‘A’ int32类型

Astring类型

package main
import (
	"fmt"
	"unsafe"
)

func main() {
   var str1='a'
   var str2='中'
   var str3=`a`
   fmt.Println(unsafe.Sizeof(str1))
   fmt.Println(unsafe.Sizeof(str2))
   fmt.Println(unsafe.Sizeof(str3))
   
   fmt.Printf("%T",str1) //int32
   fmt.Printf("%T",str3) //string 
}

GO类型转换

兼容类型之间可以相互转换
Type()

3、GO运算符：

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符

算数运算符

运算符描述实例+相加A + B 输出结果 30-相减A - B 输出结果 -10*相乘A * B 输出结果 200/相除B / A 输出结果 2%求余B % A 输出结果 0++自增A++ 输出结果 11–自减A– 输出结果 9

关系运算符

运算符描述实例==检查两个值是否相等，如果相等返回 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

逻辑运算符

运算符描述实例&&逻辑 AND 运算符。如果两边的操作数都是 True，则条件 True，否则为 False。(A && B) 为 False||逻辑 OR 运算符。如果两边的操作数有一个 True，则条件 True，否则为 False。(A || B) 为 True!逻辑 NOT 运算符。如果条件为 True，则逻辑 NOT 条件 False，否则为 True。!(A && B) 为 True

位运算符

pqp & qp | qp ^ q00000010111111010011

运算符描述实例&按位与运算符”&”是双目运算符。其功能是参与运算的两数各对应的二进位相与。(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

赋值运算符

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

其他运算符

运算符描述实例&返回变量存储地址&a; 将给出变量的实际地址。*指针变量。*a; 是一个指针变量

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

   /*  & 和 * 运算符实例 */
   ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);
}

第 1 行 - a 变量类型为 = int 第 2 行 - b 变量类型为 = int32 第 3 行 - c 变量类型为 = float32 a 的值为 4 *ptr 为 4

运算符优先级

优先级运算符5* / % << >> & & ^4+ - | ^3== != < <= > >=2&&1||

几元，运算符操作几个操作数。

1
2
3

a+b, 二元
a&&b,二元
!a,  一元

运算符优先级规则：

一元的优先级高于二元。
与的优先级高于或的优先级。

& 的用法总结：

逻辑运算符：true&& false
位运算符： 3&5 //二进制位的值都是1才是1，其他为0
取地址符：获取变量的内存地址

键盘输入

阻塞式，类似与c#中的 Console.ReadLine();

Scanln()
Scanf()
reader:=bufio.NewReader(os.Stdin)
reader.ReadLine()//拿到切片，可变数组
reader.ReadString(‘\n’)//拿到字符串

package main

import (
	"bufio"
	io "fmt"
	"os"
) //I/O 输入输出,包的自定义名称

/*
	读取键盘：
		阻塞式，类似与c#中的 Console.ReadLine();
		Scanln()
		Scanf()
		reader:=bufio.NewReader(os.Stdin)
		reader.ReadLine()//拿到切片，可变数组
		reader.ReadString('\n')//拿到字符串

 */
func main() {
	//io.Println()
	//var a int
	//var b float64
	//var c string
	//io.Println("请输入一个整数，一个浮点数，一个字符串：")
	//io.Scanln( //阻塞式，类似与c#中的 Console.ReadLine();
	//	&a,
	//	&b,
	//	&c,
	//)
	//io.Scanf("%d:%f:%c",&a,&b,&c)
	//io.Printf("a的值为：%d\n",a)
	//io.Printf("b的值为：%f\n",b)
	//io.Printf("c的值为：%s\n",c)

	//var m string
	//io.Println("请输入一个字符串：")
	//io.Scanln(&m)//hello world
	//io.Println(m)//hello

	//go中函数和方法不同
	io.Println("请输入一个字符串：")
	reader:=bufio.NewReader(os.Stdin)
	//方式一：
	//data, _, _ := reader.ReadLine()//拿到的结果是数组，切片（变长数组）
	//io.Printf("data的数据类型为：%T\n内容编码是：%v\n",data,data)
	//io.Println(string(data))
	//方式二：
	readString,_ := reader.ReadString('\n')
	io.Println(readString)
}

本文作者： 梁俊可
本文链接： http://ljk3d.com/2021/10/19/goLangNote/goLangBasic/04_GoLang语言入门_基础语法_02数据类型和运算符/
版权声明： 梁俊可工作室