go语言基础基本语法与使用 – 21运维
通知: .-...

go语言基础基本语法与使用

GO 21运维 75浏览

一,变量
gou 语言的每一个变量都拥有自己的类型,必须经过声明才能使用。
程序组成除了语言自身的标识符意外,一般都会使用大量的自定义标识符,自定义标识符需要通过声明语句来实现。其中go语言声明用到的几个关键字:
var 声明变量
const声明常量
type声明新类型
func声明函数
package 声明包
interface声明接口
声明之后通过各种调用和流程语句,完成程序使命。
1,声明变量
(1)标准格式
var 变量名 变量类型
其中变量类型,可以是go内置的基本数据类型、复合数据类型,甚至函数,接口,方法和自定义类型等。
(2)批量格式
var (
变量1 变量类型
变量2 变量类型
.
.

2,初始化变量
(1)标准格式
var 变量名 变量类型 = 表达式(值)
(2)编译器推导类型格式(即省略变量类型,由编译器根据右值 推导变量类型)
var 变量名 =表达式
(3)短变量声明并初始化(这种比较常用)
变量名:= 表达式
这里变量与表达式采用“:=“来进行赋值
说明:短变量声明以及初始化的变量名,比如是一个没有定义过的变量,否则会编译报错。

package main

import "fmt"
func main(){
   name:="21yunwei"
   fmt.Println(name)
}
package main

import "fmt"
func main(){
	var a [3]int=[3]int{1,2,3}
	fmt.Println(a)
}

ps:
整型和浮点型的默认值为0
字符串变量的默认值为空字符串
布尔类型变量的值默认为false
接口、函数、切片、指针、切片、map、chan等变量的默认值为nil;
数组或者结构体则是构成他们元素对应类型的默认值。

3,多个变量同时赋值
多重赋值时,变量的左值和右值按从左到右的顺序进行赋值。

4,匿名变量
匿名变量使用“_“来表示,实际就是占有一个逻辑位置,实际不占命名空间也不会分配内存。

package main

import "fmt"
func GetData()(int,int){
   return 100,200
}
func main(){
   a,_:=GetData()
   _,b:=GetData()
   fmt.Println(a)
   fmt.Println(b)
}

5,自增和自减,适用于数值类型,不能放到表达式。

package main

import "fmt"
func main(){
   var a int=10
   a++
   fmt.Println(a)
}

二,基本数据类型
go语言支持的类型比较多,整型、浮点型、字符串、布尔类型、切片、map、结构体等等。
1,整型int
分两类:
按照长度:int8 int16 int32 int64;
无符号整型:unit8,unit16,unit32,unit64

说明:取值范围可以通过math的min max来获取获取。
了解:
int8 取值范围:-128—+127
int16:-32767–+32768
int32:-2147483648–2147483647

2,浮点型 float
支持float32和float64,区别就是精度不一样,平时建议直接使用float64,float32精度经常出错。
ps:打印float类型,可以借助fmt包printf的%f来获取,同时也可以指定小数点后边位数(这点和c语言一样)

3,布尔类型bool
bool类型只有两个值:true和false,且默认值为false。
ps:
(1)bool变量无法参与数值运算,也无法进行强制类型转换。
(2)bool变量一般用来做if判断或者是条件判断。

4,字符串类型string
字符串类型在go语言中以原生数据出现,采用双引号““进行赋值。
var name string= “hello“
Name:=”world”
说明:
(1)转义字符:\r \n \t \’ \” \\
(2)go语言字符串内部基于utf-8来实现。
(3)原始字符串。采用反引号“`“来定义。两个反引号中间的值会原样赋值到变量中,而且转移字符也会无效
【原因:反单引号的内容不会被编译器识别】。一般用于内嵌数据或者内嵌源码。

5,复数
平时用的比较少,主要用于数学计算学科。
两种类型:complex64\complex128
ps:上述1-5五种变量类型,是go语言当中的基本数据类型。

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

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语言基础基本语法与使用