Go语言特点及基本数据类型使用详解

目录

• 一、Golang 简介
  • 1.Go 语言的特点
  • 2.Golang 的变量作用域
  • 3.Golang 执行流程的两种方式
• 二、Golang 的基本操作
  • 1.在 Linux 上安装 Golang 语言开发包
  • 2.Golang 变量的基本使用
  • 3.Golang 中整数的类型
  • 4.Golang 基本数据类型的默认值
  • 5.基本数据类型转换为 String 类型

一、Golang 简介

Golang（又称为 Go）是 Google 公司开发出的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。

1.Go 语言的特点

Go 语言保证了既能够达到 静态编译语言的安全和性能，又达到了 动态开发语言维护的高效率，使用一个表达式来形容 Go 语言：Go = C + Python，说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发。

1）从 C 语言中继承了很多理念，包括表达式语法，控制结构，基础数据类型，调用参数传值，指针 等等，也保留了和 C 语言一样的编译执行方式及弱化的指针。

func testPtr(num *int) {
    *num = 20
}

2）引入 包的概念，用于组织程序结构，Go 语言的 一个文件都要归于一个包，而不能单独存在。

package main
import "fmt"
func main() {
    fmt.Println("Hello World")
}

3）垃圾回收机制，内存自动回收，不需要开发人员管理。

4）天然并发：从语言层面上支持并发，实现简单；goroutine 轻量级线程，可实现大并发处理，高效利用多核；基于 CPS 并发模型实现。

5）吸收了 管道通信机制，形成 Go 语言特有的管道 Channel，通过管道 Channel，我们可以实现不同 goroute 间的互相通信。

6）函数可以返回多个值：

func getSumAndSub(sum int,sub int) (int,int) {
    Sum := sum + sub
    Sub := sum - sub
    return Sum,Sub
}

7）新的创新，比如：Slice 切片，Defer 延时执行等。

2.Golang 的变量作用域

局部变量： 在函数内部定义的变量，作用域仅限于函数内部（首字母是大写的也不行）

全局变量： 在函数外部定义的变量，作用域在整个包都有效。

但是当变量在代码块中定义时，比如 if for 中，那么这个变量的作用域就在该代码块中有效。

还有一个就是：赋值语句是不能定义在函数体外的，如：这种 name := "zhangsan"，我们换成 var name string = "zhangsan" 即可。

3.Golang 执行流程的两种方式

先编译，在执行： go build -o Hello.exe test.go（编译完后可以到处运行，但是编译后文件会较大）

直接运行： go run test.go（直接运行，速度相对来说要比先编译的较慢，需要依赖 Go 环境）

PS：Go 语言 定义的变量 或者 import 包，如果没有使用放到，代码是不能编译通过的。

二、Golang 的基本操作

1.在 Linux 上安装 Golang 语言开发包

1）安装 Golang 软件包

[root@localhost ~]# wget https://golang.google.cn/dl/go1.17.3.linux-amd64.tar.gz
[root@localhost ~]# tar xf go1.17.3.linux-amd64.tar.gz -C /usr/local/
[root@localhost ~]# ln -s /usr/local/go/bin/* /usr/bin/
[root@localhost ~]# go version
go version go1.17.3 linux/amd64

2）配置 Golang 的开发环境

[root@localhost ~]# mkdir -p ~/Go-Test/src						# Golang 的源代码目录
[root@localhost ~]# mkdir -p ~/Go-Test/pkg						# Golang 编译后生成的库文件
[root@localhost ~]# mkdir -p ~/Go-Test/bin						# Golang 编译后生成的可执行文件

[root@localhost ~]# cat <<END >> ~/.bashrc
export GOROOT=/usr/local/go
export GOPATH=~/Go-Test
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
END
[root@localhost ~]# source ~/.bashrc
[root@localhost ~]# go env							# 查看 Go 的环境变量是否修改文件中目录

3）编写 Go 代码进行验证

[root@localhost ~]# cat <<END > Hello.go
package main
import "fmt"
func main() {
    fmt.Println("Hello World")
}
END
[root@localhost ~]# go run Hello.go
Hello World

2.Golang 变量的基本使用

package main
import "fmt"
func main() {
    var Count int						// 定义一个变量 (声明变量)
    Count = 188 						// 给定义的变量进行赋值
    fmt.Println("Count:",Count)
}

Golang 变量的三种使用方式：

1）指定变量类型（声明后若不赋值，则使用默认值）

func main() {
    var Count int						// int 类型的默认值为 0
    fmt.Println(Count)
}

2）根据自行判定变量类型（类型推导： 简单来说就是让 Go 编译器进行自主判断）

func main() {
    var Count = 18.88
    fmt.Printf("Count 的值=%v,Count 的类型=%T",Count,Count)
}

3）直接使用 := 进行赋值（:= 表示声明并赋值）

func main() {
    name := "zhangsan"
    fmt.Println(name)
}

在区域中的 数据值 可以在 同一类型范围内不断变化：

func main() {
    // 当定义多个相同名称的变量时. Go 便会获取最后一个变量的变量值
    // 需要注意的是只能是同类型的 (比如说 int 类型就不能替换成 string)
    var sum = 188
    // PS: 在同一区域中的变量名不能重复声明. 也就是说在同一区域中的同一个变量名只能声明一次
    sum = 288
    fmt.Println(sum)
}

Golang 中 + 的使用：

func main() {
    var Sum = 188
    var Sub = 18
    Result := Sum + Sub
    fmt.Println(Result)					// 当变量为整数时. 做的便是加法运算
    1 := "Hello"
    2 := "World"
    3 := 1 + 2
    fmt.Println(3)						// 当变量为字符串时. 做的便是拼接操作
}

3.Golang 中整数的类型

类型	有无符号	占用存储空间	备注
int	有	32 位系统 4 个字节，64 位系统 8 个字节
uint	无	32 位系统 4 个字节，64 位系统 8 个字节
rune	有	与 int32 等价	主要用于处理 Unicode 码
byte	无	与 uint8 等价	主要用于存储字符

• 有符号合无符号最大的区别就是，有符号支持负数，而无符号则是只支持正数。
• bit 和 byte 的区别：bit 是计算机中最小的存储单位，而 byte 则是计算机中的基本存储单元（1 btye = 8 bit）

Go 语言的字符使用的是 UTF-8 的字符编码，查询编码地址为：查询编码地址

在 Go 中，字符的本质是一个整数，直接输出时，会打印出字符对应的 UTF-8 编码的码值。

func main() {
    var str string = "张三"
    fmt.Println("str 对应的 Unicode 码为:",[]byte(str))			// 需要使用 []byte 来进行转换
}

4.Golang 基本数据类型的默认值

数据类型	默认值
整形	0
浮点型	0
字符串	" "
布尔类型	false

常见的值类型和引用类型：

值类型： 基本数据类型（int float bool string），数组和结构体（struct）

引用类型： 指针、slice 切片、map、channel 管道、interface 接口等等都是引用类型。

值类型和引用类型的使用特点：

值类型： 变量直接存储值，内存通常在栈中分配。

引用类型： 变量存储的是一个地址，这个地址对应的空间才是真正存储的数据（值），内存通常在堆上分配。

当没有任何变量引用这个地址时，这个地址对应的数据空间就成为了一个 垃圾，由 GC 来进行回收。

5.基本数据类型转换为 String 类型

第一种方式：

package main
import "fmt"
func main() {
    var A int = 88
    var B float64 = 188.88
    var C bool = true
    var D byte = 'Z'						// byte 只能定义单个字符
    var str string							// 定义一个空的字符串
    // Sprintf 用于格式化输出字符串
    str = fmt.Sprintf("%d",A)
    fmt.Printf("str type is %T str=%q\n",str,str)
    str = fmt.Sprintf("%f",B)
    fmt.Printf("str type is %T str=%q\n",str,str)
    str = fmt.Sprintf("%t",C)
    fmt.Printf("str type is %T str=%q\n",str,str)
    str = fmt.Sprintf("%c",D)
    fmt.Printf("str type is %T str=%q\n",str,str)
}

第二种方式：

package main
import (
    "fmt"
    // strconv 包用于实现基本数据类型和其字符串表示的相互转换
    "strconv"
)
func main() {
    var A int = 88
    var B float64 = 188.88
    var C bool = true
    var str string
    str = strconv.FormatInt(int64(A),10)
    fmt.Printf("str type is %T str=%q\n",str,str)
    str = strconv.FormatFloat(B,'f',2,64)			// 'f' 表示格式. 2 表示小数位保留两位. 64 表示这个小数点是 float64
    fmt.Printf("str type is %T str=%q\n",str,str)
    str = strconv.FormatBool(C)
    fmt.Printf("str type is %T str=%q\n",str,str)
}

以上就是Go语言特点及基本数据类型使用详解的详细内容，更多关于Go语言特点及基本数据类型的资料请关注三水点靠木其它相关文章！