安徽建新建设工程有限公司网站,湖南营销型网站建设 地址磐石网络,网站代码优化多少钱,网站上线多少钱Go语言基础语法 文章目录 Go语言基础语法一、注释1.单行注释2.多行注释 二、变量1.变量的定义2.变量的初始化3.理解变量#xff08;内存地址#xff09;4.变量交换5.匿名变量6.变量的作用域 三、常量1.常量的定义#xff1a; const2.iota#xff08;特殊常量#xff09; 四…Go语言基础语法 文章目录 Go语言基础语法一、注释1.单行注释2.多行注释 二、变量1.变量的定义2.变量的初始化3.理解变量内存地址4.变量交换5.匿名变量6.变量的作用域 三、常量1.常量的定义 const2.iota特殊常量 四、基本数据类型1.布尔类型2.数值型3.字符串型4.数据类型的转换 五、运算符1.算术运算符2.关系运算符3.逻辑运算符4.位运算符5.赋值运算符6.其他运算符 六、键盘的输入和输出 一、注释
我们在写代码的时候会有这种情况时长发生刚写完的代码觉得逻辑很清晰自己怎么这么厉害过一段时间再去看这个代码就会产牛疑问这个代码到底TM谁写的所以为了防止自己看不懂自己的代码或者你想把你写的代码给别人看这个时候我们就需要汗释了 注释你可以理解为写给人看的机器并不会去执行这行语句。 注释主要的功能就是为了增强代码的可读性,不参与程序的一切功能,Go语言的注释主要分成两类。
1.单行注释
package main
// 双斜杠表示单行注释程序不会执行这行语句这是写给自己或他人看的
import fmtfunc main() {fmt.Printf(helloword!)
}2.多行注释
package main
/*杠星 星杠表示多行注释在二者之间的范围内可以换行写多行注释
*/
import fmt/*这是一个main函数这是go语言启动的入口
*/
func main() {// fmt.Printfln:打印一行内容然后执行完成后进行换行fmt.Printfln(hello,word!)
}养成写注释是一个良好的习惯方便自己阅读也方便他人阅读
二、变量
在数学概念中变量表示没有固定值且可改变的数。比如 x1x 2字面上的意思理解变量就是会变化的量。比如我定一个了一个变量叫做名字它在Go语言中是这样表示的这个值既可以是张三也可以是李四也可以是王五也可以是你的名字。那么在这里这个name就是变量可以变化的量。
// 这里的等于是赋值就是把等号右边的值赋值给左边变量的意思
var name string guan在这里除了name之外我们还写了其他的东西比如 var、string 这些都是干嘛的呢接下来就来带大家了解下go 语言中的变量的定义以及go 语言的一些数据类型比如上面的 name 名字它就是一个字符串类型的我们有时候还需要表示数字所以还会存在数字类型等后面进一步了解。
1.变量的定义
Go语言是静态类型语言,就是所有的类型我们都需要明确的去定义。这里先不管其他类型,先了解string,用它来表示字符半。在Go语言中,我们声明一个变量一般足使用 var关键字:
var name type第一个 var 是声明变量的关键字是固定的写法声明一个变量就需要一个var。第二个 name就是变量的名字你可以按照自己的需求给它定 个名字用来后续使用。第二个 type就是用来代表变量的类型。
举个栗子
// 定义一个字符串变量name
var name string
// 定义一个数字类型变量 age
var age int如果之前学过Jva, C或者其他编程语言,第一次看到这样的操作肯人不舒服。Go语言和许多编程语言不同它在声明变量时将变量的类型放在变量的名称之后,这样做的处就是可以避免像C语言那样合糊不清的声明形式,例如: int *a, b; 其中只有 a 是指针而b不是。如过想要这两个变量都是指针变量则需要将分开书写。而在Go中则可以和轻松地将们都声明为用钊类型
var a,b *int变量的命名规则遵循骆驼命名命法, 即首个单词小写,每个新单词的首字母大写,例如: helloWord 和 guanGuan。 . 变量定义的标准格式为 var 变量名 变量类型变量声明以关键字 var 开头后置变量类型行尾无须分号。 我们有时候会批量定义变量如果每次都单独定义比较麻烦Go语言文持批量定义变量使用关键了 var 和括号可以将一组变量定义放在一起。 var (name stringage intaddr string)形式的声明语句往往是用于需要显式指定变量类型地方,或者因为变量稍后会被重新赋值而初始值大关紧要的地方。当一个变量被声明之后如果没有显示的给他赋值系统自动赋予它该类型的零值
整型和浮点型变量的默认值为 0 和 0.0字符串变量的默认值为空字符串。布尔类型变量默认值为 false。切片、函数、指针变量的默认为 null
fmt.Printf(name, age, addr)2.变量的初始化 变量初始化的标准格式 var 变量名 类型 值表达式比如我想定义guan的一些信息我可以这么表示
var name string guan
var age int 18fmt.Printf(name:%s,age:%d, name, age)
这里的 name 和 age 就是变量名name 的类型为 string age 的类型为 int。他们的值分别为 guan 和 18 短变量声明并初始化 name : guanGuan
age :18fmt.Printf(name:%s,age:%d, name, age)这是Go语言的推导声明写法编译器会自动根据右值类型推断出左值的对应类型。它可以自动的推导出一些类型但是使用也是有限制的
定义变量同时显式初始化。不能提供数据类型。只能用在函数内部。不能随便到处定义
因为简洁和灵活的特点简短变量声明被广泛用于大部分的局部变量的声明和初始化。
注意由于使用了而不是赋值的因此推导声明写法的左值变量必须是没有被定义过的变量。若定义过将会发生编译错误。
// 定义变量 name
var name string
// 定义变量 name并赋值为guanGuan
name : guanGuan编译会报错信息如下no new variables on left side of :意思是在“”的左边没有新变量出现意思就是“”的左边变量已经被声明了。
3.理解变量内存地址 var num intnum 1000fmt.Printf(num的值%d,内存地址:%p\n, num, num)num 2000fmt.Printf(num的值%d,内存地址:%p\n, num, num)4.变量交换
package mainimport fmtfunc main() {/*在编程中最简单的算法就是变量的交换但是一般常见的方式就是定义中间变量var a int 100var b int 2oovar t intt aa ba tfmt.Println(a,b)*/var a int 100var b int 200fmt.Printf(交换前的变量a%d,b%d\n, a, b)// 在Go语言中可以直接用这样的方式实现值得交换无需中间变量b, a a, bfmt.Printf(交换后的变量a%d,b%d, a, b)}输出
5.匿名变量
匿名变量的特点是一个下画线””““本身就是一个特殊的标识符被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值任何类型都可以赋值给它但任何赋给这个标识符的值都将被抛弃因此这些值不能在后续的代码中使用也不可以使用这个标识符作为变量对其它变量进行赋值或运算。使用匿名变量时,只需要在变量声明的地方使用下画线替换即可。
例如:
package mainimport fmt
/*
定义一个test函数它会返回两个int类型的值每次调用将会返叵 100 和 200 两个数值、这里我们先不只管 函数的定义后面会讲解。89我们用这个函数来理解这个匿名变量。
*/
func test()(int, int) {return 100, 200
}
func main(){a,_: test()_, b : test()fmt.Println(a, b) //输出的结果100,200// 在第一行代码巾我们只需要获取第一个返叵值所以第二个返回值定义为匿名交量// 在第二行代码巾我们只需要获取第二个返叵值所以第一个返回值定义为匿名变量
}在编译过程中,可能会遇到没有名称的变量、类型或方法。虽然这不是必须的,但有时候这样做可以极大地增强代巧的灵活性,这些变量被统称为匿名变量。匿名变量不占用内存空间不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。
6.变量的作用域
一个变量常量、类型或函数在程序中都有一定的作用范围称之为作用域。
了解变量的作用域对我们学习Go语言来说足比较重要的因为Go语言会在编译时检查每个变量足否使用过一旦出现未使用的变量就会报编译错误。如果不能埋解变量的作用域,就有可能会带来一些不明所以的编译错误。 局部变量 在函数体内声明的变量称之为局部变量,它们的作用域只在函数体内,函数的参数和返回值变量都属于局部变量。
package mainimport fmt// 全局变量
var name string guanGuanfunc main() {//局部变量var age int 18var name string Guanfmt.Println(name, age)}func test() {fmt.Println(name)}全局变量 在函数休外声明的变量称之为全局变量,全局变量只需要在一个源文件中定义,就可以在所有源文件中使用,当然,不包含这个全局变量的源文件需要使用import关键它引入全局变量所在的源文件之后才能使用这个全局变量。
全局变量声明必须以var关键字开头,如果想要在外部包中使用全局变量的首字母必须大写。
//声明全局变量
var c int
func main(){//声明局部变量var a,b int初始化参数a 3b 4c a bfmt.printf(a %d,b %d,c %d\n,a,b,c) //a 3, b 4, c 7
}Go语言程序中全局变量与局部变量名称可以相同但是函数体内的局部变量会被优先考虑。
package main
import fmt
//声明全局变量
var a float32 3.14
func main(){//声明局部变量var a int 3fmt.Printf(a %d\n, a) // a 3
}三、常量
1.常量的定义 const
常量是一个简单值的标识符在程序运行时不会被修改的量。
常量中的数据类型只可以是布尔型、数字型整数型、浮点型和复数和字符申型
const identifier [type] value你可以省略类型说明符[type],因为编译器可以根据变量的值来推断其类型。
显式类型定义 const b string “abc”隐式类型定义 const b “abc”
多个相同类型的声明可以简写为:
const c_name1, c_name2 value1, value2以下实例演示了常量的应用
package mainfunc main() {// 常量不能被修改的量否则会报错const URL string www.baidu.comURL www.guan.com
}输出
package mainimport fmtfunc main() {const URL1 string www.baidu.com // 显式定义const URL2 www.guan.com // 隐式定义const a,b,c 3.14,guanGuan,true //同时定义多个常量fmt.Println(URL1)fmt.Println(URL2)fmt.Println(a,b,c)
}输出
2.iota特殊常量 iota特殊常量可以认为是一个可以被编译器修改的常量。iota是go语言的常量认数器 iota在const关键字出现时将被重置为0(const内部的第一行之前), const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。
iota 可以被用作枚举值
const (
a iota
b iota
c iota
)第一个iota等干0,每当iota在新的一行被使用时它的值都会自动加 1;所以a0, b1,c2可以简写人如下形式:
package mainimport fmtfunc main() {const (// 一组常量中如果某个常量没有初始值默认和上一行一致a iota //iota0b //iota1c //iota2d hello,guan // hello,guan iota3e // hello,guan iota4f 100 // 100 iota5g // 100 iota6h iota //iota7i //iota8)const (j iota // iota0k iota // iota1)fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}
四、基本数据类型
Go语言是一种静态类型的编程语言,在Go编程语言中,数据类型用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据编程的时候需要川大数据的时候才需要申请大内存就可以充分利川内存。编译器在讲行编译的时候就要知道每个值的类型这样编译器就知道要为这个值分配多少内存,并且知道这段分配的内存表示什么.
1.布尔类型
布尔型的值只可以是常量 true 或者 false。举一个简单的栗子
package mainimport fmtfunc main() {// var 变量名 数据类型// bool true falsevar isFlag boolvar b1 bool truevar b2 bool falsefmt.Println(isFlag) //如果不进行初始赋值则默认值为falsefmt.Printf(%T,%t\n, b1, b1)fmt.Printf(%T,%t\n, b2, b2)
}2.数值型
整型int和浮点型loat32、 foat64, Go语言支持整型和浮点型数字,并且支持复数,其中位的运算采用补码。 Go 也有基于架构的类型例如uint 无符号、int 有符号 序号类型和描述1uint8 无符号 8 位整型 (0到255)2uint16 无符号 16 位整型 (0 到 65535)3uint32 无符号 32 位型 (0 到 4294967295)4uint64 无符号64位整型 (0到18446744073709551615)5int8 力符号 8 位整型 (-128 到 127)6int16 有符号 16位整型(-32768 到 32767)7int32 有符号 32 位整型 (-2147483648 到 2147483647)8int64 符号64位整型(-9223372036854775808到9223372036854775807)
package mainimport fmtfunc main() {// 定义一个整型// byte uint8// rune int32// int int64var age int -100var i1 int8var i2 uint8i1 66i2 188fmt.Printf(%T,%d\n,age,age)fmt.Println(i1)fmt.Println(i2)
}浮点型 序号类型和描述1float32 IEEE-754 32位浮点型数2float64 IEEE-754 64位浮点平数3complex64 32 位实数和虚数4complex128 64 位头数和虚数
package mainimport fmtfunc main() {var f1 float32f1 3.14var f2 float64f2 5.12// %f 默认保留小数点后6位.2f%就是保留2位.3f%就是保留3位fmt.Printf(%T,%.3f\n, f1, f1)fmt.Printf(%T,%f\n, f2, f2)
}输出 1、关于浮点数在机器中存放形式的简单说明浮点符号位指数位尾数位
2、尾数位部分可能会丢失造成精度损失。-123.0000901
package mainimport fmtfunc main() {// float64 尽量使用 float64 来定义浮点类型的小数var num1 float32 -123.1234567var num2 float64 -123.1234567fmt.Println(num1, num1, num2, num2)}说明float64的精度要比float32的要准确说明如果我们要保存一个精度高的数则应该选择float64
3、浮点型的存储分为二部分符号位指数位尾数位在存储过程中精度会有丢失、
4、golang的浮点型默认为float64类型
5、通常情况下应该使用float64因为它比float32更精确
以下列出了其他更多的数字类型
序号类型和描述1byte 类似 uint82rune 类似 int323uint 32 或 64 位4int 与 uint 一样大小5uintptr 无符号整型用于存放一个指针
3.字符串型
import fmtfunc main() {var str stringstr helloWorld!fmt.Printf(%T,%s\n, str, str)//单引号 字符 整型-ASCII字符码x1 : Ax2 : Ax3 : 关// 拓展// 编码表 ASCII 字符码// 所有的中国字的编码表GBK// 全世界的编码表Unicode 编码表fmt.Printf(%T,%d\n, x1, x1)fmt.Printf(%T,%s\n, x2, x2)fmt.Printf(%T,%s\n, x3, x3)
}package mainimport fmtfunc main() {var str1, str2, str3 stringstr1 hellostr2 guanstr3 ,// 字符串的连接 用 号fmt.Println(str1 str3 str2)// 转义字符 \fmt.Println(hello\\guan)fmt.Println(hello\guan)fmt.Println(hello\nguan) // \n 换行fmt.Println(hello\tguan) // \t 制表符
}
输出
4.数据类型的转换
在必要以及可行的情况下,一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换因此所有的类型转换都必须显式的声明
valueofTypeA typeA (valueofTypeB)类型 A 的值类型 A(类型 B的值)
func main() {a : 5.0 // float64b : 8 // int//需求将int类型的 b 转化为 float64 类型c : float64(b)d : int(a)// 整型不能转换为bool类型//e : bool(b)//fmt.Printf(%T,%f\n, e, e)fmt.Printf(%T,%f\n, c, c)fmt.Printf(%T,%d\n, d, d)}
输出
类型转换只能在定义正确的情况下转换成功例如从一个取值范围较小的类型转换到一个取值范围较大的类型将int16 转换为 int32).当从取值范围较大的类型转换到取伯范围较小的类型时(将int32转换为int16或将float32转换为int) ,会发生精度丢失(截断)的情况。
五、运算符 1.算术运算符
下表列出了所有Go语言的算术运算符。假定A值为1, B值为2。
运算符描述实例相加AB 输出结果 3-相减A-B 输出结果 -1*相乘A*B 输出结果 2/相除A/B 偷出结果 0%求余A % B 输山结果 1自增A 输出结果2–自减A–输出结果 1
package mainimport fmtfunc main() {var a int 1var b int 2// - * / % --fmt.Println(a b)fmt.Println(a - b)fmt.Println(a * b)fmt.Println(a / b)fmt.Println(a % b)afmt.Println(a)a--fmt.Println(a)}
输出 2.关系运算符
下表列出了所有Go语言的关系运算符。假定A值为1, B值为2.
运算符描述实例检查两个值是否相等如果相等返回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否则返回FalseAB为 True
package mainimport fmtfunc main() {var a int 1var b int 2// 等于 赋值// 关系运算符 返回结果都是 bool值fmt.Println(a b)fmt.Println(a ! b)fmt.Println(a b)fmt.Println(a b)fmt.Println(a b)fmt.Println(a b)}输出结果
3.逻辑运算符
下表列出了所有Go语言的逻辑运算符。假设A值为True, B值为False。
运算符描述实例逻辑 AND 运算符。如果两边的操作数都是 True则条件 True否则为 False(A B) 为 False||逻辑 OR 运算符。如果两边的操作数有一个 True则条件 True否则为 False。(A || B)为True!逻辑 NOT 运算符。如果条件为 True则逻辑 NOT 条件 False否则为 True。!(A B) 为True
package mainimport fmtfunc main() {var a bool truevar b bool false// 逻辑与 要左右两边的表达式同时为真才执行结果才为真否则为假// 关系运算符 返回结果都是 bool值fmt.Println(a b)// 逻辑或 || 只要其中有一个为真则为真全为假则为假fmt.Println(a || b)// !为逻辑非即取反结果相反// a true// b falsefmt.Println(!a) fmt.Println(!b)}输出结果
4.位运算符
Go语言文持的位运算符如下表所示。倭定A为60, B为13:
运算符描述实例按位与运算符是双目运算符。都足1结果为1否则足0A B 结果为 12二进制为0000 1100|按位或运算符|是双月运算符。都是0结果为0,否则是1A|B结果为 61二进制为 0011 1101^按位异或运算符^是双目运算符。不同则为1机同为0(A^B)结果为49二进制为 0011 0001^位清空,a^b对于b上的每个数值如果为0,则取a对应位上的数值,如果为1,则取0(A ^ B) 结果为 48二进制为 0011 0000左移运算符“是双目运算符。左移n位就是乘以2的n次方。其功能把”“左边的运算数的各二进位全部左移若干位,由”右边的数指定移动的位数,高位丢弃,低位补0A2 结果为 240二进制为 1111 0000右移认算符“是双目运算符。右移n位就是除以2的n次方。其功能是把”“左边的运算数的各二进制文全部右移若干位”右边的数指定移动的位数A 2 结果为 15二进制为0000 1111
package mainimport fmtfunc main() {// 二进制 0 1 逢二进一// 位运算二进制上的 0 false 、 1 true// 逻辑运算符 只要有一个为假则为假、 || 只要有一个为真则为真// a 60 0011 1100// b 13 0000 1101// --------------------------// 0000 1100 同时满足// | 0011 1101 一个满足就行// ^ 0011 0001 不同为1相同为0// 2// 2var a uint 60var b uint 13// 位运算var c uint 0c a b //位运算fmt.Printf(%d,二进制%b, c, c) // 0000 1100fmt.Println()c a | b //位运算fmt.Printf(%d,二进制%b, c, c) // 0011 1101fmt.Println()c a ^ b //位运算fmt.Printf(%d,二进制%b, c, c) // 0011 0001fmt.Println()// 60 0011 1100c a 2fmt.Printf(%d,二进制%b, c, c) //fmt.Println()a 60c a 2fmt.Printf(%d,二进制%b, c, c) //
}
输出
5.赋值运算符
下表列出了所有Go语言的赋值认算符。
运算符描述实例简单的赋值运算符,将一个表达式的值赋给一个左值CAB将 AB表达式结果赋值给C相加后赋值BA等于BBA-相减后再赋值B-A 等于 BB-A*相乘后再赋值C*A等于CC*A/相除后由赋值C/A等于C C/A%求余后再赋值C%A 等于 C C % A左移后赋值C2等于CC2右移后赋值C2等于CC2按位与后赋值C2 等于CC2٨按位异或后赋值C^2 等于CC^2| 按位或后赋值C|2等于 C C|2
package mainimport fmtfunc main() {var a int 21var c int// 将等号右边的值赋值给左边c afmt.Printf(第 1 行 运算符实例,c 值为 %d\n, c)c afmt.Printf(第 2 行 运算符实例,c 值为 %d\n, c)c - afmt.Printf(第 3 行 - 运算符实例,c 值为 %d\n, c)c * afmt.Printf(第 4 行 * 运算府实例,c 值为 %d\n, c)c / afmt.Printf(第 5 行 / 运算符实例,c 值为 %d\n, c)c 200c 2fmt.Printf(第 6行 运算符实例,c值为 %d\n, c)c 2fmt.Printf(第 7 行 运算符实例,c 值为 %d\n, c)c 2fmt.Printf(第 8 行 运算符实例,c 值为 %d\n, c)c ^ 2fmt.Printf(第 9 行 ^ 运算符实例,c 值为 %d\n, c)c | 2fmt.Printf(第 10 行 | 运算符实例,c 值为 %d\n, c)
}
输出
6.其他运算符
下表列出了Go语言的其他运算符
运算符描述实例返回变量存储地址a将给出变量的实际地址*指针变量*a是一个指针变量
package mainimport fmtfunc main() {var a int 6var b int32var c float32var 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 的值为 %p\n, ptr)fmt.Printf(ptr 的值为 %d\n, *ptr)}
输出
六、键盘的输入和输出
package mainimport fmtfunc main() {var name stringvar phoneNumber string// 定义了两个变量想用键盘来输入这两个变量//fmt.Println() //打印并换行//fmt.Printf() //格式化输出//fmt.Print() //打印输出fmt.Println(请输入姓名和手机号码)// 变量去地址 变量// 指针、地址来修改和操作变量// Scanln 阻塞等待从键盘输入fmt.Scanln(name, phoneNumber)fmt.Println(name:, name)fmt.Println(phoneNumber:, phoneNumber)// fmt.Scanln() //接收输入并换行// fmt.Scanf() // 接收输入格式化输入// fmt.Scan() // 接收输入}
输出
