一个程序猿的奋斗史php开发

Go语言学习笔记04.基本数据类型

2019-11-05  本文已影响0人  快乐的提千万

命名规则

  1. 字母、下划线、数字组成,不能以数字开头。
  2. 区分大小写
  3. 不能用关键字
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
  1. 不能使用预留名字

内建常量:

false iota nil

内建类型:

int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error

内建函数:

make len cap new append copy close delete
complex real imag
panic recover

类型分类

类型 名称 长度 零值 说明
bool 布尔类型 1 false 其值不为真即为家,不可以用数字代表true或false
byte 字节型 1 0 uint8别名
rune 字符类型 4 0 专用于存储unicode编码,等价于uint32
int, uint 整型 4或8 0 32位或64位
int8, uint8 整型 1 0 -128 ~ 127, 0 ~ 255
int16, uint16 整型 2 0 -32768 ~ 32767, 0 ~ 65535
int32, uint32 整型 4 0 -21亿 ~ 21 亿, 0 ~ 42 亿
int64, uint64 整型 8 0
float32 浮点型 4 0.0 小数位精确到7位
float64 浮点型 8 0.0 小数位精确到15位
complex64 复数类型 8
complex128 复数类型 16
uintptr 整型 4或8 ⾜以存储指针的uint32或uint64整数
string 字符串 "" utf-8字符串

变量

package main 

import "fmt" 

func main() {
    //变量,程序运行期间,可以改变的量

    // 声明格式   var 变量名 类型
    // 变量声明了,必须要使用
    // 只是声明没有初始化的变量,默认值为0、空或者false(根据类型而定)
    // 同一个{}里,声明的变量名是唯一的(局部变量)
    var a int
    fmt.Println("a = ", a)

    //同时声明多个变量
    //var b, c int

    a = 10 //变量的赋值
    fmt.Println("a = ", a)

    //变量的初始化:声明变量时,同时赋值
    var b int = 10 //初始化,声明变量时,同时赋值(一步到位)
    b = 20         //赋值, 先声明,后赋值
    fmt.Println("b = ", b)

    //自动推导类型,必须初始化,通过初始化的值确定类型
    //:=, 自动推导类型,先声明变量b,再给b赋值为20
    c := 30
    //%T打印变量所属的类型
    fmt.Printf("c type is %T\n", c)

}

匿名变量

格式:下划线+变量名:_a
性质:任何赋予它的值都会被丢弃
用途:回收变量,常用于接收函数的返回值,因为go的函数是可以有多个返回值的,如果只想用其中的一个, 就可以用匿名变量丢弃其他变量。

package main //必须有一个main包

import "fmt"

//go函数可以返回多个值
func test() (a, b, c int) {
    return 1, 2, 3
}

func main() {
    
    var c, d, e int
    c, d, e = test() //return 1, 2, 3
    fmt.Printf("c = %d, d = %d, e = %d\n", c, d, e)  //三个都用

    _, d, e = test() //return 1, 2, 3
    fmt.Printf("d = %d, e = %d\n", d, e) //只用两个

}

常量

123
3.1415  // 浮点类型的常量
3.2+12i // 复数类型的常量
true  // 布尔类型的常量
"foo" // 字符串常量

常量定义

package main //必须有一个main包

import "fmt"

func main() {
    //变量:程序运行期间,可以改变的量, 变量声明需要var
    //常量:程序运行期间,不可以改变的量,常量声明需要const

    const a int = 10
    //a = 20 //err, 常量不允许修改
    fmt.Println("a = ", a)

    const b = 11.2 //没有使用:=
    fmt.Printf("b type is %T\n", b)
    fmt.Println("b = ", b)
}

itoa

package main //必须有一个main包

import "fmt"

func main() {
    //iota常量自动生成器,每个一行,自动累加1
    //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

    //iota遇到const,重置为0
    const d = iota
    fmt.Printf("d = %d\n", d)//d = 0

    //可以只写一个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

    //如果是同一行,值都一样
    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

}

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)//0 1 2 ha ha 100 100 7 8
}

字符和字符串

package main //必须有一个main包

import "fmt"

func main() {

    //字符
    //1、单引号
    //2、字符,往往都只有一个字符,转义字符除外'\n'
    var ch byte
    ch = 'a'
    fmt.Println("ch =", ch) //ch = 97
    ch = 97
    //格式化输出,%c以字符方式打印,%d以整型方式打印
    fmt.Printf("%c, %d\n", ch, ch)//a, 97
    //其实存储的不是字符,是ASCLL码

    //大写转小写,小写转大写, 大小写相差32,小写大
    fmt.Printf("大写:%d, 小写:%d\n", 'A', 'a')//大写:65, 小写:97
    fmt.Printf("大写转小写:%c\n", 'A'+32)
    fmt.Printf("小写转大写:%c\n", 'a'-32)

    //'\'以反斜杠开头的字符是转义字符, '\n'代表换行
    fmt.Printf("hello go%c", '\n')

    //字符串
    //1、双引号
    //2、字符串有1个或多个字符组成
    //3、字符串都是隐藏了一个结束符,'\0'
    var str string //声明变量
    str = "a" // 由'a'和'\0'组成了一个字符串
    fmt.Println("str = ", str)

    str = "hello go"
    //只想操作字符串的某个字符,从0开始操作
    fmt.Printf("str[0] = %c, str[1] = %c\n", str[0], str[1])//str[0] = h, str[1] = e
    
    //自动推导类型
    str2 := "mike"
    fmt.Printf("str2 类型是 %T\n", str2)

    //内建函数,len()可以测字符串的长度,有多少个字符,不包含\n
    fmt.Println("len(str2) = ", len(str2))//len(str2) =  4

}

复数类型

package main 

import "fmt"

func main() {
    var t complex128 //声明
    t = 2.1 + 3.14i  //赋值
    fmt.Println("t = ", t) //t =  (2.1+3.14i)

    //自动推导类型
    t2 := 3.3 + 4.4i
    fmt.Printf("t2 type is %T\n", t2)//t2 type is complex128

    //通过内建函数,取实部和虚部
    fmt.Println("real(t2) = ", real(t2), ", imag(t2) = ", imag(t2))//real(t2) =  3.3 , imag(t2) =  4.4

}

格式化输入输出

格式 含义
%% 一个%字面量
%b 一个二进制整数值(基数为2),或者是一个(高级的)用科学计数法表示的指数为2的浮点数
%c 字符型。可以把输入的数字按照ASCII码相应转换为对应的字符
%d 一个十进制数值(基数为10)
%e 以科学记数法e表示的浮点数或者复数值
%E 以科学记数法E表示的浮点数或者复数值
%f 以标准记数法表示的浮点数或者复数值
%g 以%e或者%f表示的浮点数或者复数,任何一个都以最为紧凑的方式输出
%G 以%E或者%f表示的浮点数或者复数,任何一个都以最为紧凑的方式输出
%o 一个以八进制表示的数字(基数为8)
%p 以十六进制(基数为16)表示的一个值的地址,前缀为0x,字母使用小写的a-f表示
%q 使用Go语法以及必须时使用转义,以双引号括起来的字符串或者字节切片[]byte,或者是以单引号括起来的数字
%s 字符串。输出字符串中的字符直至字符串中的空字符(字符串以'\0‘结尾,这个'\0'即空字符)
%t 以true或者false输出的布尔值
%T 使用Go语法输出的值的类型
%U 一个用Unicode表示法表示的整型码点,默认值为4个数字字符
%v 使用默认格式输出的内置或者自定义类型的值,或者是使用其类型的String()方式输出的自定义值,如果该方法存在的话
%x 以十六进制表示的整型值(基数为十六),数字a-f使用小写表示
%X 以十六进制表示的整型值(基数为十六),数字A-F使用小写表示
package main 

import "fmt"

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

    //阻塞等待用户的输入
    //fmt.Scanf("%d", &a) //别忘了&
    fmt.Scan(&a)

    b := "abc"
    c := 'a'
    d := 3.14
    //%T操作变量所属类型
    fmt.Printf("%T, %T, %T, %T\n", a, b, c, d)//int, string, int32, float64

    //%d 整型格式
    //%s 字符串格式
    //%c 字符个数
    //%f 浮点型个数
    fmt.Printf("a = %d, b = %s, c = %c, d = %f\n", a, b, c, d)//a = 14, b = abc, c = a, d = 3.140000
    //%v自动匹配格式输出
    fmt.Printf("a = %v, b = %v, c = %v, d = %v\n", a, b, c, d)//a = 14, b = abc, c = 97, d = 3.14
}

类型转换

Go语言中不允许隐式转换,所有类型转换必须显式声明,而且转换只能发生在两种相互兼容的类型之间。
不能转换的类型,叫不兼容类型

package main

import "fmt"

func main() {

    var flag bool
    flag = true
    fmt.Printf("flag = %t\n", flag)

    //bool类型不能转换为int
    //fmt.Printf("flag = %d\n", int(flag))

    //0就是假,非0就是真
    //整型也不能转换为bool
    //flag = bool(1)

    var ch byte
    ch = 'a' //字符类型本质上就是整型
    var t int
    t = int(ch) //类型转换,把ch的值取出来后,转成int再给t赋值
    fmt.Println("t = ", t)

}
上一篇下一篇

猜你喜欢

热点阅读