2. golang数据类型

一、命令行运行go

一个文件夹里的文件只能有一个main函数 、也就是入口函数

命令：go build xxx.go :编译   xxx.exe:运行

Go  run  xxx.go //不生成程序、直接运行

 

 

二、数据类型和命令规则

1、命令规范：字母、下划线、数字

不能以数字开头、名字不能是关键字、区分大小写

2、关键字：

下面列出GO语言的关键字或保留字：

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

除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符，其中包含了基本类型的名称和一些基本的内置函数，见下表：

append	bool	byte	cap	close	complex	complex64	complex128	uint16
copy	false	float32	float64	imag	int	int8	int16	uint32
int32	int64	iota	len	make	new	nil	panic	uint64
print	println	real	recover	string	true	uint	uint8	uintptr

 

3、变量：程序运行期间、可以改变的量。

Var  a  int    声明格式：  var   变量名  类型、

变量声明必须要使用

只是声明没有初始化的变量、默认值为0

同一个大括号里、声明的变量名是唯一的

 

4、变量初始化：声明变量同时赋值 var b int = 10

 

5、自动推导：自动推导类型、必须初始化、通过初始化的值确定类型

c:=20  fmt.Printf(“c type is %T\n”, c) 

:= 、自动推导、先声明变量b、再给b赋值20

 

6、Printf和Println区别

a  := 10

fmt.Println(“a=”,a) //一段一段处理、自动加换行

fmt.Printf(“a=%d\n”,a)//格式化输出、把a的内容放在%d的位置 \n代表换行符

 

7、多重赋值和匿名变量

a,b := 10,20

         a,b = b,a //交换2个变量的值

         fmt.Printf(“a = %d,b = %d\n”, a,b)//多重赋值

         i = 10

         j = 20

         tmp,_ = i,j

         fmt.Println(“tmp=”,tmp) //匿名变量

 

8、常量：程序运行期间、不可以改变的量、关键字const

Const a int = 20 //常量不可以修改

Const b = 10 //没有使用:= 、可以自动推导类型

fmt.Printf(“b type is %T\n”, b)

fmt.Println(“b=”,b)

9、多个变量或常量定义：

package main

import "fmt"

func main() {

    //不同类型变量可常量声明

    //    var a int = 1

    //    var b float64 = 3.33

    var (

        a int     = 2

        b float64 = 9.9

    )



    fmt.Println("a=", a)

    fmt.Println("b=", b)



    //    const i int = 10

    //    const j float64 = 9.83

    const (//可以去掉int float64、会自动推导类型

        i int     = 20

        j float64 = 8.88

    )

    fmt.Println("i=", i)

    fmt.Println("j=", j)

}

 

 

10、枚举_iota

package main
import "fmt"
func main() {
    //1、iota常量自动生成器、每个一行、自动累加1
    //2、iota给量赋值使用
    const (
        a = iota //0
        b = iota //1
        c = iota //2
    )
    fmt.Printf("a=%d, b= %d, c = %d\n", a, b, c)
    //显示：a=0, b= 1, c = 2
    //3、iota遇到const、重置为0
    const d = iota
    fmt.Printf("d = %d\n", d) //显示d = 0

    //4、可以只写一处iota
    const (
        a1 = iota //0
        b1
        c1
    )
    fmt.Printf("a1=%d,b1=%d,c1 = %d\n", a1, b1, c1)
    //显示:a1=0,b1=1,c1 = 2

    //5、如果是同一行、值 都是一样的
    const (
        i          = iota
        j1, j2, j3 = iota, iota, iota
        k          = iota
    )
    fmt.Printf("i=%d,j1=%d,j2=%d,j3=%d,k=%d\n", i, j1, j2, j3, k)
    //显示：i=0,j1=1,j2=1,j3=1,k=2
}

 

三、数据类型：基本数据类型和复合数据类型

1、基础数据类型：

 

2、Bool 布尔类型：

package main

import "fmt"
func main() {
    //1、声明变量、没有初始化、初始值为false
    var a bool
    fmt.Println("a1 = ", a) //显示：a1 =  false

    a = true
    fmt.Println("a =", a) //显示：a = true

    //2、自动推导类型
    var b = false
    fmt.Println("b =", b) //显示 b = false

    c := false
    fmt.Println("c = ", c) //显示 c =  false
}

3、整型：

Var  I  int32//声明变量

I = 123

Fmt.Println(“I = ”,i)

J := 64 //自动推导

Fmt.Println(“j =”,j)

 

4、浮点型：

package main

import "fmt"

func main() {
    //1、声明变量
    var f1 float32
    f1 = 3.1415926
    fmt.Println("f1 = ", f1) //显示：f1 =  3.1415925

    //2、自动推导类型 、float64比float32更准确
    f2 := 3.141592612
    fmt.Printf("f2 type is %T\n", f2) //显示：f2 type is float64
    fmt.Println("f2 =", f2)           //显示：f2 = 3.141592612
}

 

 

5、字符类型：

 

package main



import "fmt"



func main() {

    var str byte

    str = 97

    fmt.Println("str = ", str)      //显示：str =  97

    fmt.Printf("%c,%d\n", str, str) //显示：a,97

    //格式化输出、%c以字符方式打印、%d以整型方式打印



    str = 'a'                        //字符、单引号

    fmt.Printf("%c, %d\n", str, str) //显示：a, 97



    //大小写转换

    fmt.Printf("大写：%d, 小写： %d\n", 'A', 'a')

    fmt.Printf("大写转小写：%c\n", 'A'+32)

    fmt.Printf("小写转大写：%c\n", 'a'-32)

//    大写：65, 小写： 97

//    大写转小写：a

//    小写转大写：A

}

6、字符串类型：
 

package main

import "fmt"

func main() {
    var str string //声明变量
    str = "This is a String"
    fmt.Println("str=", str) //显示：str= This is a String

    //自动推导类型
    str1 := "This is a str"
    fmt.Printf("Str类型是%T\n", str1) //显示：Str类型是string

    //内建函数、len()字符串长度、包括空格
    fmt.Println("len测试长度：", len(str1))//显示：len测试长度： 13
}

7、字符和字符串区别：

这个和java定义是一样的。

字符：是由单个字符给成。单引号

字符串：多个字符、双引号、隐藏了一个结束符：’\0’

 Var str string = “a”  //由’a’和’\0’组成了一个字符串

package main

import "fmt"

func main() {
    var ch byte
    var str string

    ch = 'a'
    str = "a"
    fmt.Println("ch=", ch)//ch= 97
    fmt.Println("str=", str)//str= a

    str = "abcde"//如果想取出字符串的摸个字符、从0开始操作
fmt.Printf("str[0]= %c, str[1]= %c\n", str[0], str[1])
//str[0]= a, str[1]= b
}

8、复数类型：

package main

import "fmt"

func main() {
    var t complex128       //声明
    t = 2.2 + 9.99i        //赋值
    fmt.Println("t = ", t) //显示：t =  (2.2+9.99i)

    //自动推导类型
    t2 := 4.4 + 9.99i
    
    //通过内建函数、取实部和虚部
    fmt.Println("real(t2) = ", real(t2), "imag(t2)", imag(t2))
    //显示：real(t2) =  4.4 imag(t2) 9.99
}

9、格式化：

 

 

10、变量的输入：

package main

import "fmt"

func main() {
    var a int //声明变量
    fmt.Printf("请输入变量a:")

    //阻塞等待用户的输入
    //fmt.Scanf("%d", &a)
    fmt.Scan(&a) //简写
    fmt.Println("a=", a)
}
//    请输入变量a:444

//    a= 444

11、类型转换：

package main

import "fmt"

func main() {

    //注：不兼容类型是不能相互转换的
    var ch byte
    ch = 'a' //字符类型
    var t int
    t = int(ch)          //字符转换、把ch的值取出来、转成int再给t赋值
    fmt.Println("t=", t) //显示：t= 97
}

12、类型别名：

package main

import "fmt"

func main() {

    type bigInt int64
    var a bigInt
    fmt.Printf("a type is %T\n", a) //显示： type is main.bigInt

    type (
        long int64
        char byte
    )
    var b long = 119
    var chr char = 'b'
    fmt.Printf("b=%d, chr = %c\n", b, chr)
    //显示：b=119, chr = b
}

13、运算符：

算术运算符：

 

关系运算符：

 

逻辑运算符：

 

位运算符：

赋值运算符：

 

其他运算符：

 

运算符优先级：

Go语言中：一元运算符拥有最高优先级、二元运算符的运算方向均从左向右

 

 

 

14、流程控制：

格式：if支持一个初始化语句（也可以不写在这）、初始化后面就条件

If  a:=10; a == 10{

}else if a>10{

}else{

}

 

 

Switch  num := 1;num {//支持一个初始化语句

         case 1:

                   fmt.Println()

                   break;//不写默认就包含

                   fallthrough //不跳出switch语句、后面的无条件执行

         case 2:

                   fmt.Println()

                   break;//不写默认就包含

                   fallthrough //不跳出switch语句、后面的无条件执行

         case 3:

                   fmt.Println()

                   break;//不写默认就包含

                   fallthrough //不跳出switch语句、后面的无条件执行

         default:

                   fmt.Println()

}

score :=80

switch {

         case score > 90;

         fmt.Println()

         case score > 80;

         fmt.Println()

         case score > 70;

         fmt.Println()

         default:

         fmt.Println()

}

 

 

for 初始化条件;  判断条件; 条件变化{

 

}

 

 

15、迭代：range

package main

import "fmt"

func main() {
    str := "abcd"
    //通过for打印每个字符
    for i := 0; i < len(str); i++ {
        fmt.Printf("str[%d]=%c\n", i, str[i])
    }
    //    str[0]=a
    //    str[1]=b
    //    str[2]=c
    //    str[3]=d

    //迭代打印每个元素、默认返回2个值、一个是元素的位置、一个是元素本身
    for i, data := range str {
        fmt.Printf("str[%d] = %c\n", i, data)
    }
    //    str[0] = a
    //    str[1] = b
    //    str[2] = c
    //    str[3] = d

    for i := range str {
        fmt.Printf("str[%d] = %c\n", i, str[i])
    }
    //    str[0] = a
    //    str[1] = b
    //    str[2] = c
    //    str[3] = d

    for i, _ := range str {
        fmt.Printf("str[%d] = %c\n", i, str[i])
    }
    //    str[0] = a
    //    str[1] = b
    //    str[2] = c
    //    str[3] = d
}

16、Break和continue

Break用于for、switch、select 而continue仅能用于for循环

Break:跳出循环、如果嵌套多个、跳出最近的那个内循环

Continue:路出本次循环、下一次继续

 

 

17、goto

goto end//goto 无条件跳转到标签end