go语言基础–变量补充[字符、复合数据类型、强制类型转换、指针、常量、类型别名] – 21运维
通知: .-...

go语言基础–变量补充[字符、复合数据类型、强制类型转换、指针、常量、类型别名]

GO 21运维 195浏览

一,其他非基本数据类型补充以及部分复合数据类型【简单记录,后边单独进行笔记】

1,字符

字符串中的每一个元素叫做字符。严格来讲,并不是一种新的数据类型,只是整数的特殊用例。用单引号”来声明。
package main
import "fmt"
func main(){
var a ='A' b := 'B'
fmt.Println(a,b) fmt.Printf("%T,%v\n",a,b)
}
输出结果:
65 66
int32,66

2,切片(类似c语言的数组)
切片是拥有相同类型元素的可变长度的一个序列集合。
声明方式:
var name []T
name 变量名,T为数据类型
根据索引可以取值某一个元素,索引从0开始,不能超过切片的最大容量。

a:="hello"
fmt.Println(a[2:])

const size=3
var b [size]int
b[0]=100
b[1]=200
b[2]=300
fmt.Println(b[2]) //打印一个元素
fmt.Println(b) //打印整个切片
还有其他复合数据类型,后边单独记录。

二,强制数据类型转换
go语言使用类型前加括号的方式进行类型转换。 比如:

Type(表达式)
var f float32=3.14
fmt.Println(int(f))


c:=math.Pi
fmt.Println(int(c))
注意:强行进行数据类型转换,会导致数据精度的丢失,需要慎用。

三,指针
三个概念:指针地址、指针类型、指针数据
1,概念
go语言中使用“&“操作符放到变量前,进行“取地址操作“,
ptr:=&v //v的类型为type
说明:
v:变量
&v:指针地址
ptr:变量
ptr类型:*type,叫做type的指针类型,
*代表指针。
变量、指针和地址的关系:每个变量都有地址,指针的值就是变量地址。

2,指针取值
可以从指针变量前边加上“*“操作符,取出变量的具体值。
&:取地址(变量在内存当中的位置)
*:取出具体值。

   house:="sichuan chengdu city"
   ptr:=&house
   value:=*ptr
   fmt.Println(value)
}

(1)指针的值,可以通过*指针进行交换
(2)new()函数可以创建指针变量.如下test即为一个string类型的指针变量。

test:=new(string)
*test="sichuan chengdu "
fmt.Println(*test)
注意:指针不可以指向常量。

四,字符串应用
1,统计字符串长度
函数len()

home:="sichuansheng chengdu city"
fmt.Println(len(home))
home2:="四川省成都市"
fmt.Println(len(home2))
fmt.Println(utf8.RuneCountInString(home2))

结论:
ascii字符串长度使用len()函数来计算
unicode字符串长度用utf8.RuneCountInString()函数来计算

2,遍历字符串–获取每一个字符串元素

job := "my offer is 运维工程师"
for i:=0;i<len(job) ;i++ {
fmt.Printf("ascii: %c %d\n",job[i],job[i])

}
for _,s:=range job {
fmt.Printf("unicode: %c %d\n",s,s)
}

总结:
ascii字符串遍历直接使用下标
unicode字符串遍历使用for range。借助匿名变量。

3,修改字符串

angel:= "heros never die"
angleBytes:=[]byte(angel)
for j:=5;j<=10 ;j++  {
   angleBytes[j]=' '
}
fmt.Println(string(angleBytes))

总结:
(1)go语言的字符串是不可变的。
(2)修改字符串时,可以将字符串转换为[]byte 进行修改。
(3)[]byte和string可以通过强制类型转换互转。
4,连接字符串
+或者stringbuilder()
5,格式化字符串(和c一样)
格式化函数,写法:
fmt.sprintf(格式化样式,参数列表)
格式化样式:字符串形式,格式化动词以%开头;
参数列表:多个参数以逗号分割,个数必须与格式化样式重的个数一一对应,否则编译报错。

var progess =10
var target=20
//两个参数格式化
title:=fmt.Sprintf("今天已经学完%d页go语言知识,目标是今天学完%d页面",progess,target)
fmt.Println(title)

pi:=3.1415926
set:=true
cicle:=fmt.Sprintf("%v %v %v","圆周率是,",pi,set)
fmt.Println(cicle)

今天已经学完10页go语言知识,目标是今天学完20页面
圆周率是, 3.1415926 true

字符串格式化常用动词以及功能:
%v:按照原来值输出
%d:按照十进制进行输出
%c:输出一个字符

%f:输出浮点型数据,f前边加小数点和数字可以精确输出浮点型小数点后边的位数
%%:输出%
%p:输出指针变量地址,即指针的值
%T:输出变量数据类型

五,常量
常量,恒定不变的值。比如圆周率
声明方式,和普通变量声明类似,只是var改成了const。

ps:
(1)常量在声明的时候就要赋值,否则会报错;
(2)常量在后边程序当中也不能再单独赋值,否则会报错。
(3)常量只支持基本数据类型,即整型、浮点型、字符串、布尔类型、复数
(4)常量支持批量声明。通过const()就可以了。批量声明中,如果后边的常量没有赋值,则会取值上一个常量的值。


const PI=3.1415
fmt.Println(PI)

const size=3
var b [size]int
b[0]=100
b[1]=200
b[2]=300
fmt.Println(b[2])

3.1415
300

案例:常量批量声明

package main

import "fmt"

func main(){
   const a,b,c,d,e=10,2.222,"21yunwei",true,2+8i
   fmt.Printf("a:%v %T\n b:%v %T\n c:%v %T\n d:%v %T\n e:%v %T\n",a,a,b,b,c,c,d,d,e,e)
}

a:10 int
 b:2.222 float64
 c:21yunwei string
 d:true bool
 e:(2+8i) complex128

常量支持批量声明

	const (
		x=100
		y="Go语言"
		z=true
	)
	fmt.Println(x,y,z)

100 Go语言 true

案例:批量声明当中,如果后边的常量没有赋值,则会取值上一个常量的值

package main

import "fmt"
func main(){
	const(
		a=1
		b
		c=2
		d
	)
	fmt.Println(a,b,c,d)
}

输出结果:
1 1 2 2

案例:iota常量自增,默认值从0开始。

package main

import "fmt"
func main(){
	const(
		a=iota*10
		b
		c
		d=1
		e
	)
	fmt.Println(a,b,c,d,e)
}
输出:0 10 20 1 1

六,枚举
一组常量值。

七,类型别名type alias
类型别名写法: type TypeAlias=Type
说明:typealias只是在代码中出现而已,编译完成以后,不会有这个别名类型存在。

  //定义NewInt为int类型
   type NewInt int
   //定义IntAlias为int的类型别名
   type IntAlias=int
   var x NewInt
   var y IntAlias
   //分别输出x,y的变量的数据类型
   fmt.Printf("x is %T\n",x)
   fmt.Printf("y is %T\n",y)
   
x is main.NewInt
y is int

转载请注明:21运维 » go语言基础–变量补充[字符、复合数据类型、强制类型转换、指针、常量、类型别名]