Go 语言数据类型

Wen743
119 阅读4分钟

Golang数据类型

1.golang 标识符,关键字,命名规则:

标识符定义:

	var name string
	var age int
	var email string

常用关键字:

image-20230804164858107.png

命名规则:

  • 包名称 小写

  • Go 语言对大小写进行了规范:

    任何需要对外暴露的名字必须以大写字母开头(public), 不需要对外暴露的则以小写字母开头(private).

  • 结构体命名:

    采用驼峰命名法,首字母根据访问控制大写或者小写.

  • 变量命名:

    遵循驼峰命名发,首字母根据访问控制原则大写或者小写.

  • 常量命名:

    常量均需使用全部大写字母组成,并使用下划线分词

  • 单元测试:

    单元测试文件命名规范为 example_test.go

    测试用例的函数名称必须以 Test 开头,例: TestExample

2.golang变量

变量初始化语法:

var 变量 类型 = 表达式

例子:

//正常:
var(
		name string = "wen"
		age int = 23
		b bool = false
	)
fmt.Printf("name: %v\n", name)
fmt.Printf("age: %v\n", age)
fmt.Printf("b: %v\n", b)

//类型推断:
var name = "wen"
var age = 22
var b = true 

fmt.Printf("name: %v\n", name)
fmt.Printf("age: %v\n", age)
fmt.Printf("b: %v\n", b)

//批量初始化
var name,age,b = "wen",23,false
fmt.Printf("name: %v\n", name)
fmt.Printf("age: %v\n", age)
fmt.Printf("b: %v\n", b)

//短变量声明(注意短变量 只能放在函数内部, 不能放在函数外部使用)
name := "wen"
age := 20
b := true
fmt.Printf("name: %v\n", name)
fmt.Printf("age: %v\n", age)
fmt.Printf("b: %v\n", b)

//匿名变量:
func getNameAndAge()(string,int) {
	return "tom",20
}

func main() {

	name,age := getNameAndAge()
	fmt.Printf("name: %v\n", name)
	fmt.Printf("age: %v\n", age)
}

3.常量:

定义常量使用 ==const==关键字,格式如下:

const constantName [type] = value

==const==:定义常量关键字

==constantName==:常量名称

==type==:常量类型

==value==:常量的值

const PI float32 = 3.14
const PI2 = 3.1415
fmt.Printf("PI: %v\n", PI)

const(
    a=100
    b=200
)
fmt.Printf("a: %v\n", a)
fmt.Printf("b: %v\n", b)

const w,h = 200,300
fmt.Printf("w: %v\n", w)
fmt.Printf("h: %v\n", h)

iota

​ iota 比较特殊,可以被认为是一个可被编译器修改的常量,他的默认开始值是0,每调用一次加1. 遇到==const== 关键字时被充置为0.

//iota
	const(
		a1 = iota//0
		a2 = iota//1
		a3 = iota//2
	)
	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)
	fmt.Printf("a3: %v\n", a3)

​ 其中可以通过 ==_==跳过某些值:

	const(
		a1 = iota//0
		_ 		 //1
		a2 = iota//2
	)
	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)

​ ==iota== 声明中间插队:

const(
			a1 = iota//0
			a2 = 100
			a3 = iota
	)
	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)
	fmt.Printf("a3: %v\n", a3)

4.go 数据类型

func e(){

}
func main() {
	var name string = "wen"
	age := 20
	b := true
	fmt.Printf("%T\n", name)
	fmt.Printf("%T\n", age)
	fmt.Printf("%T\n", b)

	a := 100
	p := &a
	fmt.Printf("%T\n", p)

	c := [2]int{1,2}
	fmt.Printf("%T\n", c)

	d := []int {1,2,3}
	fmt.Printf("%T\n", d)

	fmt.Printf("%T\n", e)
}

image-20230804203337441.png

派生类型包括:

  • 指针类型 *int
  • 数组类型 [...]int
  • 切片类型 []int
  • ...

5.go 数字类型

go 语言支持整型和浮点型, 并且原生支持 复数.

go中没有 float 类型(只有 float32 和 float64),没有double类型

像 int,uint这些大小不固定的,他们的大小与操作系统架构有关.

uintptr: int 的指针类型,长度被设定为足够存放一个指针即可.

整数:

  • int8(-128 -> 127)
  • int16(-32768 -> 32767)
  • int32
  • int64

无符号整数:

  • uint8(0->255)
  • uint16(0->65535)
  • uint32
  • uint64(最大)

整型的零值为 0,浮点型零值为 0.0

6.golang 字符串

字符串定义:

var s string = "hello wen"
var s1 = "hello wen"
s3 := "hello wen"

fmt.Printf("s: %v\n", s)
fmt.Printf("s1: %v\n", s1)
fmt.Printf("s3: %v\n", s3)

s4 := `
	line1
	line2
	line3
	`
fmt.Printf("s4: %v\n", s4)

image-20230805152350341.png

字符串连接:

// '+' 连接	
	s1 := "tom"
	s2 := "20"
	msg := s1+s2
	fmt.Printf("msg: %v\n", msg)

// fmt 函数连接:
	s1 := "tom"
	s2 := "20"
	msg := fmt.Sprintf("%s,%s",s1,s2)
	fmt.Printf("msg: %v\n", msg)

//string join方法连接
	s1 := "tom"
	s2 := "20"
	s := strings.Join([]string{s1, s2}, ",")
	fmt.Printf("s: %v\n", s)

//buffer.WriteString() 连接
//这种方式效率比较高,它是直接写到缓冲区里面去的,可以当成可变字符使用,对内存的增长也有优化
	var buffer bytes.Buffer
	buffer.WriteString("tom")
	buffer.WriteString(",")
	buffer.WriteString("20")
	fmt.Printf("buffer.String(): %v\n", buffer.String())

字符串的切片操作:

​ 类似于字符串截取,注意这里截取的区间是前闭后开的:

//字符串的切片操作
	s := "hello wen"
	a := 2
	b := 5

	fmt.Printf("s[a]: %c\n", s[a])
	fmt.Printf("s[a:b]: %v\n", s[a:b])//区间:[a,b)
	fmt.Printf("s[a:]: %v\n", s[a:]) //从 a 到结束
	fmt.Printf("s[:b]: %v\n", s[:b]) //从开始到 b

image-20230808152331508.png

字符串函数:


	s := "hello wen"
	fmt.Printf("len(s): %v\n", len(s))
	//输出的是一个数组 ,参数:(分割的字符串s,分割条件" ")
	fmt.Printf("strings.Split(s, \" \"): %v\n", strings.Split(s, " "))
	//是否包含 字符串 ,参数:(字符串s,查找的对象)
	fmt.Printf("strings.Contains(\"hello\"): %v\n", strings.Contains(s,"hello"))
	//转换小写
	fmt.Printf("strings.ToLower(s): %v\n", strings.ToLower(s))
	//转换大写
	fmt.Printf("strings.ToUpper(s): %v\n", strings.ToUpper(s))

	//以...开头
	fmt.Printf("strings.HasPrefix(s, \"hello\"): %v\n", strings.HasPrefix(s, "hello"))
	//以...结尾
	fmt.Printf("strings.HasSuffix(s, \"wen\"): %v\n", strings.HasSuffix(s, "wen"))

	//查找当前字符串中元素的所在位置索引(最前面的)
	fmt.Printf("strings.Index(s, \"l\"): %v\n", strings.Index(s, "l"))
	//查找当前字符串中元素的所在位置索引(取最后的)
	fmt.Printf("strings.LastIndex(s, \"l\"): %v\n", strings.LastIndex(s, "l"))

image-20230808154235421.png

avatar
文章
阅读
粉丝