Go语⾔基础：语⾔格式变量常量数据类型占位符转义符
⽬录
Go语⾔格式
输出HelloWorld
package main
//导⼊包语句
import "fmt" //使⽤fmt系统包的申明，这个系统包包含了各种输出⽅法，对⽐Java
//程序的⼊⼝，对⽐C语⾔，存在⼀个且唯⼀的main函数
func main() {
fmt.Println("Hello World")
}
函数外⾯只能放置标识符的声明，⽐如变量声明、常量声明、函数声明等等
像fmt.println("sss") 直接放在函数外⾯，这种是错误的
此外，go代码串结束的时候不需要分号
使⽤命令⾏编译并执⾏go⽂件
使⽤ go build ⽂件名.go 可以⽣成⼆进制⽂件
使⽤ go run ⽂件名.go 可以直接执⾏⽂件
使⽤⽂件名.exe 执⾏⼆进制⽂件
当然也可以⽤go build直接编译全部的go⽂件
变量
标识符
Go的标识符和其他语⾔⼀样，由数字、字母、下划线组成，只能以下划线和字母开头，尽量采⽤驼峰式命名法，名称不能是关键字和保留字关键字和保留字
//保留字
break        default      func        interface    select
case        defer        go          map          struct
chan        else        goto        package      switch
const        fallthrough  if          range        type
continue    for          import      return      var
//关键字
//常量
true  false  iota  nil
// 数据类型
int  int8  int16  int32  int64
uint  uint8  uint16  uint32  uint64  uintptr
float32  float64  complex128  complex64
bool  byte  rune  string  error
// 内置函数
make  len  cap  new  append  copy  close  delete
complex  real  imag panic  recover
变量声明
格式1：var 变量名称数据类型
//格式1
var name string
var age int
var sex string
格式2：var ( 变量名称数据类型 \n 变量名称数据类型……)
// 格式2
var(
id int
isOk bool
)
格式3：var 变量名称=变量值
//格式3
var name string = "aaa"
var age int = 22
格式4：var 变量1，变量2=值1，值2
//格式4
var name, age = "aaa", 22
格式3 属于创建并初始化变量，系统会⾃动选配最适合变量传⼊值的数据类型
变量初始化的必要性
上⾯的格式3和格式4都是变量初始化的实例
在Go语⾔中，变量⼀旦定义就必须初始化，否则就会报错
短变脸声明
在函数内部，可以进⾏短变量声明，使⽤:=符号
例⼦：
package main
import (
"fmt"
)
// 全局变量m
var m = 100
func main() {
n := 10
m := 200 // 此处声明局部变量m
fmt.Println(m, n)
//⽣成结果： 200 10
}
匿名变量
在使⽤多重赋值时，如果想要忽略某个值，可以使⽤匿名变量（anonymous variable）。匿名变量⽤⼀个下划线_表⽰
如下例⼦
package main
import "fmt"
func foo() (int, string) {
return 10, "aaa"
}
func main() {
x, _ := foo()
_, y := foo()
fmt.Println("x=", x)
fmt.Println("y=", y)
}
//结果：
//x= 10
//y= aaa
匿名变量不占⽤命名空间，不会分配内存，所以匿名变量之间不存在重复声明。
注意事项：
函数外的每个语句都必须以关键字开始（var、const、func等）
:=不能使⽤在函数外。
_多⽤于占位，表⽰忽略值。
常量
常量⽤const定义，⼀旦定义就必须赋值，开辟⼀个空间并写⼊⼀个不可变的数据
常量声明
直接定义并赋值：
const pi = 3.1415
const e = 2.7182
多重定义赋值
const (
pi = 3.1415
e = 2.7182
)
多重定义赋值之省略赋值：如果在多重定义赋值中某⼀个常量没有赋值，则它的值⾃动为向上寻最近的已经被赋值的常量值const (
n1 = 100
n2
n3
)
// 此时n1=n2=n3=100
关键字iota
iota是go语⾔的常量计数器，只能在常量的表达式中使⽤。
iota在const关键字出现时将被重置为0。
const中每新增⼀⾏常量声明将使iota计数⼀次(iota可理解为const语句块中的⾏索引)。
使⽤iota能简化定义，在定义枚举时很有⽤。
看下⾯的例⼦:
package main
import "fmt"
const (
a1 = iota
a2
a3
_ //使⽤_跳过某些值
_
a4
a5 = 100
a6
a7 = iota //iota声明中间插队
a8
// 0 1 2 5 100 100 8 9
)
'此时iota对每⼀⾏出现的常量进⾏了计数，并且遵从上⾯的多重定义赋值之省略赋值的原则'
// 定义数量级
//这⾥的<<；表⽰左移操作，1<<10表⽰将1的⼆进制表⽰向左移10位，也就是由1变成了10000000000，也就是⼗进制的1024。
//同理2<<2表⽰将2的⼆进制表⽰向左移2位，也就是由10变成了1000，也就是⼗进制的8。
const (
_  = iota
KB = 1 << (10 * iota)
MB = 1 << (10 * iota)
GB = 1 << (10 * iota)
TB = 1 << (10 * iota)
PB = 1 << (10 * iota)
// 1024 1048576 1073741824 1099511627776 1125899906842624
)
'可以看到,iota遇到了const关键字就变成了0，重新计数'
// 多个iota定义在⼀⾏
const (
a, b = iota, iota        //0,0
c, d = iota, iota        // 1,1
e, f = iota + 1, iota + 2 //3,4
// 0 0 1 1 3 4
)
'由于此时多个常量定义在⼀⾏,⽽iota只对⼀⾏的常量能够⾃增'
func main() {
fmt.Println(a1, a2, a3, a4, a5, a6, a7, a8)
fmt.Println(KB, MB, GB, TB, PB)
fmt.Println(a, b, c, d, e, f)
}
0 1 2 5 100 100 8 9
1024 1048576 1073741824 1099511627776 1125899906842624
0 0 1 1 3 4
数据类型
Go语⾔中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组、切⽚、结构体、函数、map、通道（channel）等。整形 int族
整型分为以下两个⼤类：按长度分为：int8、int16、int32、int64 对应的⽆符号整型：uint8、uint16、uint32、uint64
后⾯的数字式字节数,8代表8bit
其中，uint8就是我们熟知的byte型，int16对应C语⾔中的short型，int64对应C语⾔中的long型。
类型符号描述
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)
package main
import "fmt"
func main() {
var a uint = 22
fmt.Println(a)
}
特殊整型
类型描述
uint32位操作系统上就是uint32，64位操作系统上就是uint64
int32位操作系统上就是int32，64位操作系统上就是int64
uintptr⽆符号整型，⽤于存放⼀个指针
在使⽤int和 uint类型时，不能假定它是32位或64位的整型，⽽是考虑int和uint可能在不同平台上的差异。所以在跨平台开发的时候需要考虑是否对⽅不是64位.
获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进⾏变化。实际使⽤中，切⽚或 map 的元素数量等都可以⽤int来表⽰。在涉及到⼆进制传输、读写⽂件的结构描述时，为了保持⽂件的结构不会受到不同编译⽬标平台字节长度的影响，不要使⽤int和 uint。
数字字⾯量语法（Number literals syntax）
Go1.13版本之后引⼊了数字字⾯量语法，这样便于开发者以⼆进制、⼋进制或⼗六进制浮点数的格式定义数字，例如：
v := 0b00101101，代表⼆进制的 101101，相当于⼗进制的 45。
v := 0o377，代表⼋进制的 377，相当于⼗进制的 255。
v := 0x1p-2，代表⼗六进制的 1 除以 2²，也就是 0.25。
⽽且还允许我们⽤ _ 来分隔数字，⽐如说： v := 123_456 表⽰ v 的值等于 123456。
我们可以借助fmt函数来将⼀个整数以不同进制形式展⽰。
package main
import "fmt"
//go语⾔中⽆法定义⼆进制数
func main() {
// ⼗进制
var a int = 10
数组格式字符串转数组fmt.Printf("%d \n", a) // 10 %d表⽰整数，%s表⽰的是字符串
fmt.Printf("%b \n", a) // 1010  占位符%b表⽰⼆进制
// ⼋进制以0开头，因为⼋进制是三位⼆进制，就是作为32位系统的时候前⼋位位0
var b int = 077
fmt.Printf("%o \n", b) // 77
// ⼗六进制以0x开头
var c int = 0xff
fmt.Printf("%x \n", c) // ff
fmt.Printf("%X \n", c) // FF
// var d int = 18
/
/ fmt.Println("%x \n", d) //输出%x\n 18
// 查看变量类型
fmt.Printf("%T\n", a)
// var e int8 = 9
// fmt.Println("%T\n",e)
}
类型解释
%d⼗进制整数
%f浮点数
%o⼋进制
%x⼗六进制
%T类型
%s字符串类型
浮点型和复数
Go语⾔⽀持两种浮点型数：float32和float64。
这两种浮点型数据格式遵循IEEE 754标准：
float32 的浮点数的最⼤范围约为 3.4e38，可以使⽤常量定义：math.MaxFloat32。
float64 的浮点数的最⼤范围约为 1.8e308，可以使⽤⼀个常量定义：math.MaxFloat64。
复数使⽤的是:complex64和complex128
打印浮点数时，可以使⽤fmt包配合动词%f
package main
import (
"fmt"
"math"
)
// complex64和complex128
// 复数
var c1 complex64 = 1 + 2i
var c2 complex128 = 2 + 3i
func main() {
fmt.Println(math.MaxFloat64)//打印最⼤浮点数
// 浮点数
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
// 复数
fmt.Println(c1)
fmt.Println(c2)
//1.7976931348623157e+308
//3.141593
//3.14
//(1+2i)
//(2+3i)
}
布尔值
Go语⾔中以bool类型进⾏声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。
注意：
布尔类型变量的默认值为false。
Go 语⾔中不允许将整型强制转换为布尔型.
布尔型⽆法参与数值运算，也⽆法与其他类型进⾏转换。
字符串
Go语⾔中的字符串以原⽣数据类型出现，使⽤字符串就像使⽤其他原⽣数据类型（int、bool、float32、float64 等）⼀样。
Go 语⾔⾥的字符串的内部实现使⽤UTF-8编码。字符串的值为双引号(")中的内容(字符才是单引号)，可以在Go语⾔的源码中直接添加⾮ASCII码字符，例如：
s1 := "hello"
s2 := "你好"
字符串转义符
Go 语⾔的字符串常见转义符包含回车、换⾏、单双引号、制表符等，如下表所⽰。
转义符含义
\r回车符（返回⾏⾸）
\n换⾏符（直接跳到下⼀⾏的同列位置）
\t制表符
\'单引号
\"双引号
\\反斜杠
例如，打印输出:str := "c:\Code\"
fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
多⾏字符串
Go语⾔中要定义⼀个多⾏字符串时，就必须使⽤反引号字符：
s1 := `第⼀⾏
第⼆⾏
第三⾏
`
字符串操作
⽅法介绍
len(str)求长度
+或fmt.Sprintf拼接字符串
strings.Split分割
strings.HasPrefix,strings.HasSuffix前缀/后缀判断
strings.Index(),strings.LastIndex()⼦串出现的位置
strings.Join(a[]string, sep string)join操作
byte和rune类型
组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。字符⽤单引号（’）包裹起来，如：
var a = '中'
var b = 'x'
Go 语⾔的字符有以下两种：
uint8类型，或者叫 byte 型，代表了ASCII码的⼀个字符。
rune类型，代表⼀个 UTF-8字符。
当需要处理中⽂、⽇⽂或者其他复合字符时，则需要⽤到rune类型。rune类型实际是⼀个int32。
Go 使⽤了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的⽂本处理更为⽅便，也可以使⽤ byte 型进⾏默认字符串处理，性能和扩展性都有照顾。
// 遍历字符串

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。