这可能是 Go 语言基础入门最全教程（10万字第五期）
前面四篇主题，分享了 Go 语言的发展历史，现状，Go 语言与 C 语言对比，如何学习 Go 语言，Go 语言 IDE 安装方法，Go 语言基础知识，Go语言注释、Go语言编码风格、关键字、标识符、数据类型、变量、数据类型转换等知识点。
第五期，继续和大家分享 Go 语言基础知识点、Go 语言常量。
数值类型和字符串类型之间转换
Go语言中不能通过 数据类型(变量)的格式将数值类型转换为字符串, 也不能通过 数据类型(变量)的格式将字符串转换为数值类型 package main
import "fmt"
func main() {
var num1 int32 = 65
// 可以将整型强制转换, 但是会按照ASCII码表来转换
// 但是不推荐这样使用
var str1 string = string(num1)
fmt.Println(str1)
var num2 float32 = 3.14
// 不能将其它基本类型强制转换为字符串类型
var str2 string = string(num2)
fmt.Println(str2)
var str3 string = "97"
// 不能强制转换, cannot convert str2 (type string) to type int
var num3 int = int(str3)
fmt.Println(num3)
}
数值类型转字符串类型strconv..FormatXxx() package main
import "fmt"
func main() {
var num1 int32 = 10
//***个参数: 需要被转换的整型,必须是int64类型
// 第二个参数: 转换为几进制, 必须在2到36之间
// 将32位十进制整型变量10转换为字符串,并继续保留10进制格式
str1 := strconv.FormatInt(int64(num1), 10)
fmt.Println(str1) // 10
// 将32位十进制整型变量10转换为字符串,并转换为2进制格式
str2 := strconv.FormatInt(int64(num1), 2)
fmt.Println(str2) // 1010
var num5 float64 = 3.1234567890123456789
//***个参数: 需要转换的实型, 必须是float64类型
// 第二个参数: 转换为什么格式,f小数格式, e指数格式
// 第三个参数: 转换之后保留多少位小数, 传入-1按照指定类型有效位保留
// 第四个参数: 被转换数据的实际位数,float32就传32, float64就传64
// 将float64位实型,按照小数格式并保留默认有效位转换为字符串
str3 := strconv.FormatFloat(num5, f, -1, 64)
fmt.Println(str3) // 3.1234567
str4 := strconv.FormatFloat(num5, f, -1, 64)
fmt.Println(str4) // 3.1234567890123457
// 将float64位实型,按照小数格式并保留2位有效位转换为字符串
str5 := strconv.FormatFloat(num5, f, 2, 64)
fmt.Println(str5) // 3.12
// 将float64位实型,按照指数格式并保留2位有效位转换为字符串
str6 := strconv.FormatFloat(num5, e, 2, 64)
fmt.Println(str6) // 3.12
var num6 bool = true
str7 := strconv.FormatBool(num6)
fmt.Println(str7) // true
}
字符串类型转数值类型strconv.ParseXxx() package main
import "fmt"
func main() {
var str1 string = "125"
//***个参数: 需要转换的数据
// 第二个参数: 转换为几进制
// 第三个参数: 转换为多少位整型
// 注意点: ParseInt函数会返回两个值, 一个是转换后的结果, 一个是错误
// 如果被转换的数据转换之后没有超出指定的范围或者不能被转换时,
// 那么错误为nil, 否则错误不为nil
// 将字符串"125"转换为10进制的int8
num1, err := strconv.ParseInt(str1, 10, 8)
if err != nil {
fmt.Println(err)
}
fmt.Println(num1)
var str2 string = "150"
// 将字符串"150"转换为10进制的int8
// 由于int8的取值范围是-128~127, 所以转换之后超出了指定的范围, error不为nil
num2, err := strconv.ParseInt(str2, 10, 8)
if err != nil {
fmt.Println(err)
}
fmt.Println(num2)
var str3 string = "3.1234567890123456789"
//***个参数: 需要转换的数据
// 第二个参数: 转换为多少位小数, 32 or 64
// ParseFloat同样有两个返回值, 如果能够正常转换则错误为nil, 否则不为nil
num3, err := strconv.ParseFloat(str3, 32)
if err != nil {
// 例如: 把字符串"3.14abc"转换为小数就会报错, 因为"3.14abc"不是一个小数
fmt.Println(err)
}
fmt.Println(num3)
var str4 string = "true"
//***个参数: 需要转换的数据
// ParseBool同样有两个返回值, 如果能够正常转换则错误为nil, 否则不为nil
num4, _ := strconv.ParseBool(str4)
fmt.Println(num4)
}
字符串类型转换为数值类型时,如果不能转换除了返回error以外,还会返回对应类型的默认值 package main
import "fmt"
func main() {
var str1 string = "abc"
num1, _ := strconv.ParseInt(str1, 10, 32)
fmt.Println(num1) // 0
num2, _ := strconv.ParseFloat(str1, 32)
fmt.Println(num2) // 0
num3, _ := strconv.ParseBool(str1)
fmt.Println(num3) // false
}
看完上面的代码有没有种想打人的感觉? 如果有那么请继续往下看字符串类型和整型快速转换 package main
import "fmt"
func main() {
var num1 int32 = 110
// 快速将整型转换为字符串类型
// 注意:Itoa方法只能接受int类型
var str1 string = strconv.Itoa(int(num1))
fmt.Println(str1)
var str2 string = "666"
// 快速将字符串类型转换为整型
// 注意: Atoi方法返回两个值, 一个值是int,一个值是error
// 如果字符串能被转换为int,那么error为nil, 否则不为nil
num2, err := strconv.Atoi(str2)
if err != nil{
fmt.Println(err)
}
fmt.Println(num2)
}
数值类型转字符串类型其它方式package main
import "fmt"
func main() {
var num1 int32 = 110
// Sprintf函数和Printf函数很像, 只不过不是输出而将格式化的字符串返回给我们
var str1 string = fmt.Sprintf("%d", num1)
fmt.Println(str1)
var num2 float32 = 3.14
var str2 string = fmt.Sprintf("%f", num2)
fmt.Println(str2)
var num3 bool = true
var str3 string = fmt.Sprintf("%t", num3)
fmt.Println(str3)
}
Go语言常量
和C语言一样Go语言中的常量也分为整型常量、实型常量、字符常量、字符串常量、自定义常量自定义常量
C语言自定义常量: const 数据类型 常量名称 = 值; #include <stdio.h>
int main(int argc, const char * argv[])
{
const float PI = 998;
PI = 110; // 报错
printf("PI = %d\n", PI );
return 0;
}
Go语言自定义常量: const 常量名称 数据类型 = 值or const 常量名称 = 值package main
import "fmt"
func main() {
//const PI float32 = 3.14
//PI = 110 // 报错
//fmt.Println("PI = ", PI )
const PI = 3.14
PI = 110 // 报错
fmt.Println("PI = ", PI )
}
除此之外Go语言还支持一次性定义多个常量package main
import "fmt"
func main() {
// 多重赋值方式
const num1, num2 int = 100, 200
fmt.Println("num1 = ", num1)
fmt.Println("num2 = ", num2)
// 常量组方式
const (
num3 = 100
num4 = 200
)
fmt.Println("num3 = ", num3)
fmt.Println("num4 = ", num4)
// 常量组+多重赋值
const (
num5, num6 = 100, 200
num7 = 300
)
fmt.Println("num5 = ", num5)
fmt.Println("num6 = ", num6)
fmt.Println("num7 = ", num7)
}
Go语言自定义常量注意点
定义的局部变量或者导入的包没有被使用, 那么编译器会报错,无法编译运行但是定义的常量没有被使用,编译器不会报错, 可以编译运行package main
import "fmt"
func main() {
// 可以编译运行
const PI float32 = 3.14
}
在常量组中, 如果上一行常量有初始值,但是下一行没有初始值, 那么下一行的值就是上一行的值package main
import "fmt"
func main() {
const (
num1 = 998
num2 // 和上一行的值一样
num3 = 666
num4 // 和上一行的值一样
num5 // 和上一行的值一样
)
fmt.Println("num1 = ", num1) // 998
fmt.Println("num2 = ", num2) // 998
fmt.Println("num3 = ", num3) // 666
fmt.Println("num4 = ", num4) // 666
fmt.Println("num5 = ", num5) // 666
const (
num1, num2 = 100, 200
num3, num4 // 和上一行的值一样, 注意变量个数必须也和上一行一样
)
fmt.Println("num1 = ", num1)
fmt.Println("num2 = ", num2)
fmt.Println("num3 = ", num3)
fmt.Println("num4 = ", num4)
}
枚举常量
C语言中枚举类型的本质就是整型常量 Go语言中没有C语言中明确意义上的enum定义, 但是可以借助iota标识符来实现枚举类型C语言枚举格式: enum 枚举名 {
枚举元素1,
枚举元素2,
… …
};
C语言枚举中,如果没有指定初始值,那么从0开始递增
#include <stdio.h>
int main(int argc, const char * argv[])
{
enum Gender{
male,
female,
yao,
};
// enum Gender g = male;
// printf("%d\n", g); // 0
// enum Gender g = female;
// printf("%d\n", g); // 1
enum Gender g = yao;
printf("%d\n", g); // 2
return 0;
}
C语言枚举中, 如果指定了初始值,那么从指定的数开始递增#include <stdio.h>
int main(int argc, const char * argv[])
{
enum Gender{
male = 5,
female,
yao,
};
// enum Gender g = male;
// printf("%d\n", g); // 5
// enum Gender g = female;
// printf("%d\n", g); // 6
enum Gender g = yao;
printf("%d\n", g); // 7
return 0;
}
Go语言实现枚举格式const(
枚举元素1 = iota
枚举元素2 = iota
... ...
)
利用iota标识符标识符实现从0开始递增的枚举
package main
import "fmt"
func main() {
const (
male = iota
female = iota
yao = iota
)
fmt.Println("male = ", male) // 0
fmt.Println("male = ", female) // 1
fmt.Println("male = ", yao) // 2
}
iota注意点:
在同一个常量组中,iota从0开始递增, 每一行递增1在同一个常量组中,只要上一行出现了iota,那么后续行就会自动递增 package main
import "fmt"
func main() {
const (
male = iota // 这里出现了iota
female // 这里会自动递增
yao
)
fmt.Println("male = ", male) // 0
fmt.Println("male = ", female) // 1
fmt.Println("male = ", yao) // 2
}
在同一个常量组中,如果iota被中断, 那么必须显示恢复package main
import "fmt"
func main() {
const (
male = iota
female = 666 // 这里被中断, 如果没有显示恢复, 那么下面没有赋值的常量都和上一行一样
yao
)
fmt.Println("male = ", male) // 0
fmt.Println("male = ", female) // 666
fmt.Println("male = ", yao) // 666
}
package main
import "fmt"
func main() {
const (
male = iota
female = 666 // 这里被中断
yao = iota // 这里显示恢复, 会从当前常量组第一次出现iota的地方开始,每一行递增1, 当前是第3行,所以值就是2
)
fmt.Println("male = ", male) // 0
fmt.Println("male = ", female) // 666
fmt.Println("male = ", yao) // 2
}
iota也支持常量组+多重赋值, 在同一行的iota值相同 package main
import "fmt"
func main() {
const (
a, b = iota, iota
c, d = iota, iota
)
fmt.Println("a = ", a) // 0
fmt.Println("b = ", b) // 0
fmt.Println("c = ", c) // 1
fmt.Println("d = ", d) // 1
}
iota自增默认数据类型为int类型, 也可以显示指定类型 package main
import "fmt"
func main() {
const (
male float32 = iota // 显示指定类型,后续自增都会按照指定类型自增
female
yao
)
fmt.Printf("%f\n", male) // 0.0
fmt.Printf("%f\n", female) // 1.0
fmt.Printf("%f\n", yao) // 2.0
fmt.Println("male = ", reflect.TypeOf(female)) // float32
}
Go语言fmt包实现了类似C语言printf和scanf的格式化I/O, 格式化动作源自C语言但更简单 ##输出函数func Printf(format string, a ...interface{}) (n int, err error)
和C语言用法几乎一模一样, 只不过新增了一些格式化符号package main
import "fmt"
func main() {
name := "微信搜索：代码情缘"
age := 33
fmt.Printf("name = %s, age = %d\n", name, age) // name = lnj, age = 33
}
值得注意的是,输出十进制只能通过%d,不能像C语言一样通过%i除了和C语言一样,可以通过%o、%x输出八进制和十六进制外,还可以直接通过%b输出二进制package main
import "fmt"
func main() {
num := 15
fmt.Printf("十进制 = %d\n", num)
fmt.Printf("八进制 = %o\n", num)
fmt.Printf("十六进制 = %x\n", num)
fmt.Printf("二进制 = %b\n", num)
}
除此之外,Go语言还增加了%T控制符, 用于输出值的类型package main
import "fmt"
func main() {
type Person struct {
name string
age int
}
num1 := 10
num2 := 3.14
per := Person{"lnj", 33}
fmt.Printf("num1 = %T\n", num1) // int
fmt.Printf("num2 = %T\n", num2) // float64
fmt.Printf("per = %T\n", per) // main.Person
}
除此之外,Go语言还增加了%v控制符,用于打印所有类型数据
Go语言中输出某一个值,很少使用%d%f等, 一般都使用%v即可输出复合类型时会自动生成对应格式后再输出package main
import "fmt"
func main() {
type Person struct {
name string
age int
}
num1 := 10
num2 := 3.14
per := Person{"lnj", 33}
// 此时相当于把%v当做%d
fmt.Printf("num1 = %v\n", num1) // 10
// 此时相当于把%v当做%f
fmt.Printf("num2 = %v\n", num2) // 3.14
}
Go语言Printf函数其它特性,如宽度、标志、精度、长度、转移符号等,和C语言一样.func Println(a ...interface{}) (n int, err error)
采用默认格式将其参数格式化并写入标准输出,
输出之后会在结尾处添加换行传入多个参数时, 会自动在相邻参数之间添加空格传入符合类型数据时, 会自动生成对应格式后再输出package main
import "fmt"
func main() {
num1 := 10
num2 := 3.14
fmt.Println(num1, num2) // 10 3.14
fmt.Println("num1 =", num1, "num2 =", num2) // num1 = 10 num2 = 3.14
type Person struct {
name string
age int
}
per := Person{"lnj", 33}
fmt.Println(per) // {lnj 33}
}
func Print(a ...interface{}) (n int, err error)
和Println几乎一样
输出之后不会在结尾处添加换行传入多个参数时, 只有两个相邻的参数都不是字符串,才会在相邻参数之间添加空格传入符合类型数据时, 会自动生成对应格式后再输出package main
import "fmt"
func main() {
num1 := 10
num2 := 3.14
fmt.Print(num1, num2) // 10 3.14
fmt.Print("num1 =", num1, "num2 =", num2) // num1 =10 num2 =3.14
type Person struct {
name string
age int
}
per := Person{"lnj", 33}
fmt.Print(per) // {lnj 33}
}
以下三个函数和Printf/Println/Print函数一样, 只不过上面三个函数是输出到标准输出, 而下面三个函数可以通过w指定输出到什么地方func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)func Fprintln(w io.Writer, a ...interface{}) (n int, err error)func Fprint(w io.Writer, a ...interface{}) (n int, err error)package main
import (
"fmt"
"net/http"
"os"
)
func main() {
// os.Stdout 写入到标准输出
name := "lnj"
age := 33
//***个参数: 指定输出到什么地方
// 第二个参数: 指定格式控制字符串
// 第三个参数: 指定要输出的数据
fmt.Fprintf(os.Stdout, "name = %s, age = %d\n", name, age)
// http.ResponseWriter 写入到网络响应
http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
fmt.Fprintf(writer, "name = %s, age = %d\n", name, age)
})
http.ListenAndServe(":8888", nil)
}
以下三个函数和Printf/Println/Print函数一样, 只不过上面三个函数是输出到标准输出, 而下面三个函数不会输出,而是将字符串返回给我们
func Sprintf(format string, a ...interface{}) stringfunc Sprint(a ...interface{}) stringfunc Sprintln(a ...interface{}) stringpackage main
import (
"fmt"
"net/http"
"os"
)
func main() {
name := "lnj"
age := 33
// 按照指定的格式生成字符串
str := fmt.Sprintf("name = %s, age = %d\n", name, age)
// 输出生成的字符串
fmt.Println(str)
}
由于字数限制，本文就分享到这里。
如果觉得有价值，点赞支持
@李南江由于部分好友可能等不及更新，建议先看电子书。
免责声明：本站所有内容及图片均采集来源于网络，并无商业使用，如若侵权请联系删除。
资讯 观察行业视觉，用专业的角度，讲出你们的心声。
2024-07-05
搭建一个app平台要多少钱？费用都在哪些地方
搭建一个app平台要多少钱 搭建一个app平台的费用取决于多个因素，包括应用的复杂性、功能需求、设计要求、···
Load More 2024-05-22
建设官网能给公司带来什么？建设公司官网应该考虑什么
建设官网能给公司带来什么 在当今数字化时代，建设一个优质的公司官网对于企业来说至关重要。它不仅是公司···
Load More 2024-05-22
公司官网的建设有什么建议？公司官网建设的步骤是什么
公司官网的建设有什么建议 随着互联网的迅速发展，公司官网已经成为品牌宣传和业务拓展的重要工具。一个令···
Load More 2024-05-22
公司官网建设注意什么事项？建设官网对公司有什么好处
公司官网建设注意什么事项 在建设公司官网时，有几个关键事项要注意，以确保网站能够吸引用户并提供良好的···
Load More 2024-05-08
建设公司官网需要什么条件？建设公司官网需要考虑哪些
建设公司官网需要什么条件 在现代社会，公司官网已成为企业展示形象和吸引客户的重要工具。要建设一个成功···
Load More 