Golang 【第三篇】Go变量与数据类型

Golang 【第三篇】Go变量与数据类型

 

1 转义符

package main

import "fmt" //fmt包中提供格式化，输出，输入的函数.

//这是一个main函数，是程序入口
func main() {
    //演示转义字符的使用 \t
    fmt.Println("tom\tjack")

    // 如果希望一次性注释 ctrl + / 第一次表示注释，第二次表示取消注释
    fmt.Println("hello\nworld")
    fmt.Println("C:\\Users\\Administrator\\Desktop\\Go语言核心编程课程\\资料")
    fmt.Println("tom说\"i love you\"")

    // \r 回车,从当前行的最前面开始输出，覆盖掉以前内容
    fmt.Println("天龙八部雪山飞狐\r张飞厉害")
    
    // \n表示换行符
    fmt.Println("helloworldhelloworldhelloworldhelloworl\n", 
        "dhelloworldhelloworldhelloworldhelloworldhelloworldhellowor\n", 
        "ldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworl\n", 
        "dhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhel\n", 
        "loworldhelloworldhelloworldhelloworldhelloworldhelloworldhellowor\n", 
        "ldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworld")

    //var num = 2 + 4 * 5 
}

package main 

import "fmt" //fmt包中提供格式化，输出，输入的函数.
func main() {
    //要求：要求：请使用一句输出语句，达到输入如下图形的效果
    fmt.Println("姓名\t年龄\t籍贯\t地址\njohn\t20\t河北\t北京")
    
}

 

2  变量

package main
import "fmt"

//演示golang中标识符的使用
func main() {

    //Golang中严格区分大小写
    //golang 中 认为 num 和 Num是不同的变量
    var num int = 10
    var Num int = 20
    fmt.Printf("num=%v Num=%v\n", num, Num)

    //标识符不能包含空格
    //var ab c int = 30

    //_ 是空标志符，用于占用
    // var _ int = 40 //error
    // fmt.Println(_)

    var int int = 90
    fmt.Println(int)
}

package main
import "fmt"

func main() {
    //定义变量/声明变量
    var i int
    //给i 赋值
    i = 10
    //使用变量
    fmt.Println("i=", i)
}

package main
import "fmt"

func main() {
    //golang的变量使用方式1
    //第一种：指定变量类型，声明后若不赋值，使用默认值
    // int 的默认值是0 , 其它数据类型的默认值后面马上介绍
    var i int 
    fmt.Println("i=", i)

    //第二种：根据值自行判定变量类型(类型推导)
    var num  = 10.11
    fmt.Println("num=", num)

    //第三种：省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误
    //下面的方式等价 var name string   name = "tom"
    // := 的 :不能省略，否则错误
    name := "tom"
    fmt.Println("name=", name)

}

package main
import "fmt"

//定义全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的声明方式，也可以改成一次性声明
var (
    n3 = 300
    n4 = 900
    name2 = "mary"
)

func main() {
    
    //该案例演示golang如何一次性声明多个变量
    // var n1, n2, n3 int 
    // fmt.Println("n1=",n1, "n2=", n2, "n3=", n3)

    //一次性声明多个变量的方式2 
    // var n1, name , n3 = 100, "tom", 888
    // fmt.Println("n1=",n1, "name=", name, "n3=", n3)

    //一次性声明多个变量的方式3, 同样可以使用类型推导
    // n1, name , n3 := 100, "tom~", 888
    // fmt.Println("n1=",n1, "name=", name, "n3=", n3)

    //输出全局变量
    //fmt.Println("n1=",n1, "name=", name, "n2=", n2)
    fmt.Println("n3=",n3, "name2=", name2, "n4=", n4)

}

package main
import ( 
    "fmt"
    //为了使用utils.go文件的变量或者函数，我们需要先引入该model包 
    "go_code/chapter03/demo04/model"
)

//变量使用的注意事项
func main() {
    
    //该区域的数据值可以在同一类型范围内不断变化
    var i int = 10
    i = 30
    i = 50
    fmt.Println("i=", i)
    //i = 1.2 //int ,原因是不能改变数据类型

    //变量在同一个作用域(在一个函数或者在代码块)内不能重名
    //var i int = 59
    //i := 99
    //我们使用utils.go 的heroName 包名.标志符
    fmt.Println(model.HeroName)

}

package main
import "fmt"

//演示golang中+的使用
func main() {
    
    var i = 1
    var j = 2
    var r = i + j //做加法运算
    fmt.Println("r=", r)

    var str1 = "hello "
    var str2 = "world"
    var res = str1 + str2 //做拼接操作
    fmt.Println("res=", res)

}

 

3 数据类型

 

 

 

package main
// import "fmt"
// import "unsafe"
import (
    "fmt"
    "unsafe"
)



//演示golang中整数类型使用
func main() {
    
    var i int = 1
    fmt.Println("i=", i)

    //测试一下int8的范围 -128~127,
    //其它的 int16, int32, int64,类推。。。
    var j int8 = 127
    fmt.Println("j=", j)

    //测试一下 uint8的范围(0-255),其它的 uint16, uint32, uint64类推即可
    var k uint16 = 255
    fmt.Println("k=", k)

    //int , uint , rune , byte的使用
    var a int = 8900
    fmt.Println("a=", a)
    var b uint = 1
    var c byte = 255
    fmt.Println("b=", b, "c=", c)

    //整型的使用细节
    var n1 = 100 // ? n1 是什么类型
    //这里我们给介绍一下如何查看某个变量的数据类型
    //fmt.Printf() 可以用于做格式化输出。
    fmt.Printf("n1 的 类型 %T \n", n1)


    //如何在程序查看某个变量的占用字节大小和数据类型 （使用较多）
    var n2 int64 = 10
    //unsafe.Sizeof(n1) 是unsafe包的一个函数，可以返回n1变量占用的字节数
    fmt.Printf("n2 的 类型 %T  n2占用的字节数是 %d ", n2, unsafe.Sizeof(n2))

    

}

package main
import (
    "fmt"
    "unsafe"
)

//演示golang中小数类型使用
func main() {
    
    var price float32 = 89.12
    fmt.Println("price=", price)
    var num1 float32 = -0.00089
    var num2 float64 = -7809656.09
    fmt.Println("num1=", num1, "num2=", num2)

    //尾数部分可能丢失，造成精度损失。 -123.0000901
    var num3 float32 = -123.0000901
    var num4 float64 = -123.0000901
    fmt.Println("num3=", num3, "num4=", num4)

    //Golang 的浮点型默认声明为float64 类型
    var num5 = 1.1
    fmt.Printf("num5的数据类型是 %T \n", num5)


    //十进制数形式：如：5.12       .512   (必须有小数点）
    num6 := 5.12
    num7 := .123 //=> 0.123
    fmt.Println("num6=", num6, "num7=", num7)

    //科学计数法形式
    num8 := 5.1234e2 // ? 5.1234 * 10的2次方
    num9 := 5.1234E2 // ? 5.1234 * 10的2次方 shift+alt+向下的箭头
    num10 := 5.1234E-2 // ? 5.1234 / 10的2次方 0.051234
    
    fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)

    var c1 rune = '北'
    fmt.Println("c1=", c1, unsafe.Sizeof(c1))

}

package main
import (
    "fmt"
)

//演示golang中字符类型使用
func main() {
    
    var c1 byte = 'a'
    var c2 byte = '0' //字符的0

    //当我们直接输出byte值，就是输出了的对应的字符的码值
    // 'a' ==> 
    fmt.Println("c1=", c1)
    fmt.Println("c2=", c2)
    //如果我们希望输出对应字符，需要使用格式化输出
    fmt.Printf("c1=%c c2=%c\n", c1, c2)

    //var c3 byte = '北' //overflow溢出
    var c3 int = '北' //overflow溢出
    fmt.Printf("c3=%c c3对应码值=%d\n", c3, c3)

    //可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode 字符
    var c4 int = 22269 // 22269 -> '国' 120->'x'
    fmt.Printf("c4=%c\n", c4)

    //字符类型是可以进行运算的，相当于一个整数,运输时是按照码值运行
    var n1 = 10 + 'a' //  10 + 97 = 107
    fmt.Println("n1=", n1)

}

package main
import (
    "fmt"
    "unsafe"
)

//演示golang中bool类型使用
func main() {
    var b = false
    fmt.Println("b=", b)
    //注意事项
    //1. bool类型占用存储空间是1个字节
    fmt.Println("b 的占用空间 =", unsafe.Sizeof(b) )
    //2. bool类型只能取true或者false
    
}

package main
import (
    "fmt"
)

//演示golang中string类型使用
func main() {
    //string的基本使用
    var address string = "北京长城 110 hello world!"
    fmt.Println(address)

    //字符串一旦赋值了，字符串就不能修改了：在Go中字符串是不可变的
    //var str = "hello"
    //str[0] = 'a' //这里就不能去修改str的内容，即go中的字符串是不可变的。

    //字符串的两种表示形式(1) 双引号, 会识别转义字符(2) 反引号，
    //以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、
    //输出源代码等效果  【案例演示】
    str2 := "abc\nabc"
    fmt.Println(str2)

    //使用的反引号 ``
    str3 := ` 
    package main
    import (
        "fmt"
        "unsafe"
    )
    
    //演示golang中bool类型使用
    func main() {
        var b = false
        fmt.Println("b=", b)
        //注意事项
        //1. bool类型占用存储空间是1个字节
        fmt.Println("b 的占用空间 =", unsafe.Sizeof(b) )
        //2. bool类型只能取true或者false
        
    }
    `
    fmt.Println(str3)

    //字符串拼接方式
    var str = "hello " + "world"
    str += " haha!"

    fmt.Println(str)
    //当一个拼接的操作很长时，怎么办，可以分行写,但是注意，需要将+保留在上一行.
    str4 := "hello " + "world" + "hello " + "world" + "hello " + 
    "world" + "hello " + "world" + "hello " + "world" + 
    "hello " + "world"
    fmt.Println(str4)


    var a int // 0
    var b float32 // 0
    var c float64 // 0
    var isMarried bool // false 
    var name string // ""
    //这里的%v 表示按照变量的值输出
    fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v",a,b,c,isMarried, name)

}

package main
import (
    "fmt"
)

//演示golang中基本数据类型的转换
func main() {

    var i int32 = 100
    //希望将 i => float
    var n1 float32 = float32(i)
    var n2 int8 = int8(i)
    var n3 int64 = int64(i) //低精度->高精度

    fmt.Printf("i=%v n1=%v n2=%v n3=%v \n", i ,n1, n2, n3)
    
    //被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化
    fmt.Printf("i type is %T\n", i) // int32

    //在转换中，比如将 int64  转成 int8 【-128---127】 ，编译时不会报错，
    //只是转换的结果是按溢出处理，和我们希望的结果不一样
    var num1 int64 = 999999
    var num2 int8 = int8(num1) // 
    fmt.Println("num2=", num2)

}

package main
import (
    "fmt"
    "strconv"
)

//演示golang中string转成基本数据类型
func main() {

    var str string = "true"
    var b bool
    // b, _ = strconv.ParseBool(str)
    // 说明
    // 1. strconv.ParseBool(str) 函数会返回两个值 (value bool, err error)
    // 2. 因为我只想获取到 value bool ,不想获取 err 所以我使用_忽略
    b , _ = strconv.ParseBool(str)
    fmt.Printf("b type %T  b=%v\n", b, b)
    
    var str2 string = "1234590"
    var n1 int64
    var n2 int
    n1, _ = strconv.ParseInt(str2, 10, 64)
    n2 = int(n1)
    fmt.Printf("n1 type %T  n1=%v\n", n1, n1)
    fmt.Printf("n2 type %T n2=%v\n", n2, n2)

    var str3 string = "123.456"
    var f1 float64
    f1, _ = strconv.ParseFloat(str3, 64)
    fmt.Printf("f1 type %T f1=%v\n", f1, f1)


    //注意：
    var str4 string = "hello"
    var n3 int64 = 11
    n3, _ = strconv.ParseInt(str4, 10, 64)
    fmt.Printf("n3 type %T n3=%v\n", n3, n3)

}

package main
import (
    "fmt"
    _ "unsafe"
    "strconv"
)

//演示golang中基本数据练习转成string使用
func main() {

    var num1 int = 99
    var num2 float64 = 23.456
    var b bool = true
    var myChar byte = 'h'
    var str string //空的str

    //使用第一种方式来转换 fmt.Sprintf方法

    str = fmt.Sprintf("%d", num1)
    fmt.Printf("str type %T str=%q\n", str, str)

    str = fmt.Sprintf("%f", num2)
    fmt.Printf("str type %T str=%q\n", str, str)

    str = fmt.Sprintf("%t", b)
    fmt.Printf("str type %T str=%q\n", str, str)

    str = fmt.Sprintf("%c", myChar)
    fmt.Printf("str type %T str=%q\n", str, str)

    //第二种方式 strconv 函数 
    var num3 int = 99
    var num4 float64 = 23.456
    var b2 bool = true

    str = strconv.FormatInt(int64(num3), 10)
    fmt.Printf("str type %T str=%q\n", str, str)
    
    // strconv.FormatFloat(num4, 'f', 10, 64)
    // 说明： 'f' 格式 10：表示小数位保留10位 64 :表示这个小数是float64
    str = strconv.FormatFloat(num4, 'f', 10, 64)
    fmt.Printf("str type %T str=%q\n", str, str)

    str = strconv.FormatBool(b2)
    fmt.Printf("str type %T str=%q\n", str, str)

    //strconv包中有一个函数Itoa
    var num5 int64 = 4567
    str = strconv.Itoa(int(num5))
    fmt.Printf("str type %T str=%q\n", str, str)

}

指针类型

package main
import (
    "fmt"
)

//演示golang中指针类型
func main() {

    //基本数据类型在内存布局
    var i int = 10
    // i 的地址是什么,&i
    fmt.Println("i的地址=", &i)
    
    //下面的 var ptr *int = &i
    //1. ptr 是一个指针变量
    //2. ptr 的类型 *int
    //3. ptr 本身的值&i
    var ptr *int = &i 
    fmt.Printf("ptr=%v\n", ptr)
    fmt.Printf("ptr 的地址=%v", &ptr) 
    fmt.Printf("ptr 指向的值=%v", *ptr)

}

package main
import "fmt"

func main() {

    var num int = 9
    fmt.Printf("num address=%v\n", &num)

    var ptr *int 
    ptr = &num
    *ptr = 10 //这里修改时，会到num的值变化
    fmt.Println("num =" , num)
    var a_b int = 20
    fmt.Println(a_b)

    var int int = 30
    fmt.Println(int)
}

原理：

 

 

 

4 值类型与引用类型

     

 

 

 

 5 系统保留关键字与预定义标识符