从零开始学GO ---- 变量、常量、基本数据类型

太过爱你忘了你带给我的痛 2022-12-19 13:15 84阅读 0赞

### 从零开始学GO ---- 变量、常量、基本数据类型 ###

#### 第一个GO程序：hello world ####

代码如下：

package main // 声明 main 包，表明当前是一个可执行程序
    
    import "fmt" // 导入内置 fmt 包
    
    func main() {
         // main函数，是程序执行的入口
    	fmt.Printf("Hello World!") // 在终端打印 Hello World!
    }

然后执行： `go build hello.go` 进行编译，之后便可以看到有一个exe文件，可以直接运行。

一些细节：

*  声明main包，表示当前是一个可执行程序
 *  通过import导入其他包，fmt是标准输入输出包，包含有Print函数
 *  main函数表示程序入口，并且main函数所在的包名必须是main
 *  函数以func开头

#### 变量和常量 ####

##### 变量 #####

**显示变量声明**：`var vatName dateType [= value]`

其中，`var`是关键字，用于变量声明，varName是变量名字，dateType表示数据类型，value是初始值，初始值可以是字面量，也可以是其他变量名或者表达式，不显示初始化的话将默认为零值。

tips：GO的变量声明后将立即分配空间

var number int = 1
    var name string = "jessy"
    
    //也可以利用类型推导将变量的类型省略
    var name, age = "Q1mi", 20

**短类型变量声明**： `varName := value`

**只能在函数内部短类型声明**，可以使用更简略的 `:=` 方式声明并初始化变量 ，GO编译器将自动类型推断

//...
    func main() {
        
    	n := 10
    	m := 200 // 此处声明局部变量m
    	//...
    }

**匿名变量**：在使用多重赋值时，如果想要忽略某个值，可以使用`匿名变量（anonymous variable）`。 匿名变量用一个下划线`_`表示

func function() (int, string) {
        
    	return 10, "string"
    }
    func main() {
        
    	x, _ := function()
    	_, y := function()
    	fmt.Println("x=", x)
    	fmt.Println("y=", y)
    }

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。`_`多用于占位，表示忽略值

##### 常量 #####

常量使用一个名称绑定一个内存地址，该内存地址存储的数据类型和内容声明后不可以再变。

//变量前加const就表示常量声明
    const pi = 3.1415
    const e = 2.7182
    
    //可以声明多个变量
    const (
        pi = 3.1415
        e = 2.7182
    )
    //const同时声明多个常量时，如果省略了值则表示和上面一行的值相同
    const (
        n1 = 100
        n2
        n3
    )       //则n2 n3都是100

预声明标识符iota用在常量声明中，初始值为0，一组多个变量同时声明时其值逐行增加，专门用来初始化常量

const (
    	c0=iota  //c0==0
    	c1=iota  //c1==1
    	c2=iota  //c2==2
    )
    //  <===>  等价于
    const(
    	c0=iota   //c0==0
        c1        //c1==1
        c2        //c2==2
    )
    //iota是逐行增加的
    const(
    	a=1<<iota  // iota==0,so a==1
        b=1<<iota  // iota==1,so b==2
        c=3        //c==3  and iota==3
        d=1<<iota  //iota==3,so d==8
    )

#### 基本数据类型 ####

##### 布尔型 #####

Go语言中以`bool`类型进行声明布尔型数据，布尔型数据只有`true`和`false`，并且在Go语言中，布尔型数据和整型数据不可以相互转换，如果声明的布尔型不进行初始化，则默认为`false`

var a bool=true
    var b bool=(x>y)&&(x>0)

##### 整型 #####

Go语言内置了12种整数类型， 分别是：int8、int16、int32、int64 对应的有符号整型，和uint8、uint16、uint32、uint64对应的无符号整型，以及byte，int，uint，uintptr。

byte是unit8的别名，int和uint表示整数类型，受特定 CPU 平台的字长影响。

##### 浮点型 #####

Go语言支持两种浮点型数：`float32`和`float64`

使用浮点数要注意，浮点数字会被自动推断为`float64`类型，并且使用浮点数不应该使用==或 != 来进行比较，而应该采用一个精度的大小比较去判断，高精度要求应该采用math标准库。

var b :=10.00  //会被推断为float64
    var a float32=1.2

打印浮点数时，可以使用`fmt`包配合`%f`进行格式化输出

fmt.Printf("%f\n", math.Pi)  //3.141593
    fmt.Printf("%.2f\n", math.Pi) //3.14

##### 复数类型 #####

Go语言内置的复数类型有两种：`complex64`和`complex128`,复数在计算机中用两个浮点数表示，一个表示实部一个表示虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

var value1 complex64=3.2+14i
    var value2 =2+10i

Go的复数类型有三个内置函数：complex real imag，分别用于构建复数、返回实部、返回虚部

var v=complex(2.1,3)  //构造复数
    a:=real(v)   //a=2.1
    b:=imag(v)   //b=3

##### 字符串 #####

Go语言将字符串作为一种原生的基本数据类型，可以直接使用字符串字面量来进行初始化。

*  字符串是常量，可以通过索引访问，但是不能修改某个字节的值
    
        var a ="hello world!"
        b:=a[0]
        a[1]='a'  //错误，不可以修改某字节的值
 *  字符串尾部不包含NULL字符，与C++不同
 *  采用切片操作时要慎用，因为每转换一次都需要复制内容(尤其数据量大的时候)
    
        a:="hello world!"
        b:=[]byte(a)
 *  字符串的底层实现是一个二元数据结构，一个是指针指向字节数组的起点，另一个是长度
    
        type stringStruct struct{
              
        	str unsafe.Pointer //指向底层字节数组的指针
            len int            //字节数组长度
        }
 *  基于字符串创建的切片和原字符串指向相同的底层字符数组，一样不能修改，对字符串的切片操作返回的字串仍是string，而非slice
 *  string类型常用的一些方法：
    
    <table> 
     <thead> 
      <tr> 
       <th align="center">方法</th> 
       <th align="center">介绍</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">len(str)</td> 
       <td align="center">求长度</td> 
      </tr> 
      <tr> 
       <td align="center">+</td> 
       <td align="center">拼接字符串</td> 
      </tr> 
      <tr> 
       <td align="center">strings.Split</td> 
       <td align="center">分割</td> 
      </tr> 
      <tr> 
       <td align="center">strings.contains</td> 
       <td align="center">判断是否包含</td> 
      </tr> 
     </tbody> 
    </table>
 *  修改字符串：要修改字符串，需要先将其转换成`[]rune`或`[]byte`，完成后再转换为`string`。无论哪种转换，都会重新分配内存，并复制字节数组。
    
        func changeString() {
              
        	s1 := "big"
        	// 强制类型转换
        	byteS1 := []byte(s1)
        	byteS1[0] = 'p'
        	fmt.Println(string(byteS1))  //pig
        }
 *  字符串的切片：
    
        str := "hello,world"
        fmt.Println(str[6:])  
        //打印结果：world

##### byte和rune类型 #####

Go语言的字符类型有两种：

1.  `uint8`类型，或者叫 byte 型，代表了`ASCII码`的一个字符。
2.  `rune`类型，代表一个 `UTF-8字符`。

当需要处理中文、日文或者其他复合字符时，则需要用到`rune`类型。`rune`类型实际是一个`int32`。

遍历一个字符串：

s := "hello,world!"
    	for _, r := range s {
         //rune
    		fmt.Printf("%c", r)
    	}
    	fmt.Println()