【原创】go语言学习（二）数据类型、变量量、常量量

目录

1.标识符、关键字
2. 变量量和常量量
3. 数据类型
4. Go程序基本结构

标识符、关键字

1.标识符是⽤用来表示Go中的变量量名或者函数名，以字⺟母或_开头。后⾯面跟着字⺟母 、_或数字
2. 关键字
A. 88ab B. _ab28 C. ab_28
关键字是Go语⾔言预先定义好的，有特殊含义的标识符

break default func interface select
case defer go map struct
chan else goto package switch
const fallthough if range type
continue for import return var

变量

1. 语法：

var identifier type

例1

var a int 
var b string 
var c bool 
var d int = 8 
var e string = “hello

例2

//变量
package main

import "fmt"

func main() {
	/*
		//方式1
		//整数 默认:0
		var a int
		// 布尔 默认:0flase
		var b bool
		// str 默认:""
		var c string
		// 浮点 默认:0.000000
		var d float32
		// 格式化输出
	*/

	//方式二
	var (
		a int
		b bool
		c string
		d float32
	)

	fmt.Printf("a=%d b=%t c=%s d=%f
", a, b, c, d)

	a = 10
	b = true
	c = "hello"
	d = 10.8
}

　　

常量

1. 常量使⽤用const 修饰，代表永远是只读的，不不能修改。
2. 语法：const identifier [type] = value，其中type可以省略略。
举例：

const b string = “hello world”
const b = “hello world”
const Pi = 3.1414926 const a = 9/3

3. ⽐比较优雅的写法：

const(
 
    a = 1 
    b = 2 
    c = 3 
)

　　

4. 更更加专业的写法：

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

　　以上实例运行结果为：

const(
 
    a = 1 << iota 
    b 
    c 
)

　　再看个有趣的的 iota 实例：

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

　　以上实例运行结果为：

i= 1
j= 6
k= 12
l= 24

　　

iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

简单表述:

　　i=1：左移 0 位,不变仍为 1;

• j=3：左移 1 位,变为二进制 110, 即 6;
• k=3：左移 2 位,变为二进制 1100, 即 12;
• l=3：左移 3 位,变为二进制 11000,即 24。

数据类型

1. 布尔类型
a. var b bool 和 var b bool = true 和 var b = false
b. 操作符 == 和 !=
c. 取反操作符： !b
d. && 和 || 操作符
e. 格式化输出占位符: %t

2. 整数和浮点数类型
a. int8、int16、int32、int64
b. uint8、uint16、uint32、uint64
c. int 和 uint，和操作系统平台相关
d. float32 和 float64浮点类型
e. 所有整数 初始化为0，所有浮点数初始化为0.0，布尔类型初始化为false

3. 整数和浮点数类型
a. Go是强类型语⾔言，不不同类型相加以及赋值是不不允许的
b. 那怎么样才能实现，不不同类型相加呢？
c. 输出占位符：整数%d，%x⼗十六进制，%f浮点数

字符串

1. 字符串串的两种表示⽅方式

a. 双引号， “”，可以包含控制字符

b. 反引号， ``，所有字符都是原样输出

package main 

import “fmt” 

func main() { 
    var str = “hello world

”
 
    var str2 = `hello 
 
 
` 
    fmt.Println(“str=“, str) 
    fmt.Println(“str2=“, str2) 
}

　　

2. 字符串串常⽤用操作

a. ⻓长度：len(str)

b. 拼接：+，fmt.Sprintf

c. 分割：strings.Split

d. 包含： strings.Contains

e. 前缀或后缀判断：strings.HasPrefix, strings.HasSuffix

f. ⼦子串串出现的位置: strings.Index(), strings.LastIndex()

g. join操作： strings.Join(a[]string, sep string)

数据类型和操作符

1、操作符
a. 逻辑操作符， == 、 != 、<、<=、>=
b. 算数操作符， +、-、*、/、%

go程序的基本结构

1. 任何⼀一个代码⽂文件⾪隶属于⼀一个包

package main 
import “fmt” 
func main() { 
    fmt.Println(“hello, world”) 
}

　　

2. import 关键字，引⽤用其他包：

import(“fmt”)

import(“os”)

通常习惯写成：

import (

　　“fmt”

　　“os”

)

3. 开发可执⾏行行程序，package main， 并且有且只有⼀一个main⼊入⼝口函数
4. 包中函数调⽤用：

a. 同⼀一个包中函数，直接⽤用函数名调⽤用
b. 不不同包中函数，通过包名+点+ 函数名进⾏行行调⽤用

5. 包访问控制规则：

a. ⼤大写意味着这个函数/变量量是可导出的

b. ⼩小写意味着这个函数/变量量是私有的， 包外部不不能访问