golang基础语法

go基础

文章目录

• • go的关键字
  • go的数据类型
  • • 整形
    • 浮点型
    • 字符和字符串
    • 基本数据类型相互转换
    • 指针
    • map
    • 数组与切片
    • 结构体和面向对象
    • 结构体的定义
    • 类型别名
  • 结构体嵌套和json化
  • 面向对象
  • • 继承
    • 接口和多态

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数据类型的定义

1. var 声明定义一个变量，定义后，值可修改

2. const 声明定义一个常量，定义后不可再修改

3. := 定义一个变量，类型由后面的值决定。常用的定义方式

go的数据类型

go的数据类型主要分为了两类：基本的数据类型和派生数据类型。

基本数据类型 ： 整形、浮点型、字符串

整形

长度说明:位既是一个二进制位，8即2^8=256,如果是有符号则需要一位作为符号位

整形 分为了有符号和无符号。无符号即有符号前加多个u
例如有符号8位 int8、无符号8位 uint8
范围大小 ： 8 、16 、32 、64
其他的范围 ： int类型 大小与系统有关，32位系统则为32，64位系统则为64 
注意 ： rune 为int的别名、byte为uint8的别名
// 例如
var( a int8 = 256
b int16 = 123 
c int32
d int64  )

浮点型

属性	说明
范围	32位、64位

浮点型只有两种类型 float32 和 float64 默认为64


64位更加精准

字符和字符串

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的，也就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。

1. 字符使用单引号定义字符，字符定义后无法修改

var word byte = 'a'

1. 字符串可以用双引号和反引号定义,字符串定义后可修改

双引号会解析特殊字符，如\n或\r等，反引号直接原样处理

var word string = "hello \n world"

var word2 string = `hello \n world`

基本数据类型相互转换

Golang和Java/C不同，Golang在不同类型的变量之间赋值时需要显式转换。也就是Golang中数据类型不能自动转换。

基本语法:

表达式var_type(var_name) 将值v转换为类型var_type

var num int = 42
// 转浮点型
var float float64 = float64(num)
// 转 整形无符号八位
var ui uint8 = uint8(float)
fmt.Println(num, float, ui)

//数据的转换必须显式转换，不能自动转换    
    var n1 int32 = 12
    var n2 int64
    var n3 int8

    n2 = n1 + 20 //int32  --> int64  错误
    n3 = n1 + 20 //int32  --> int8   错误

    n2 = int64(n1) + 20 //正确
    n3 = int8(n1) + 20  //正确

//引入strconv包 
import (
    "fmt"
    "strconv"
)
// 其他类型转字符类型
    var num1 int = 99;
    var num2 float64 = 23.456
    var isTrue bool = true 
    // int 转字符串
    str = strconv.FormatInt(int64(num1), 10)
    // “99”

    // float 转字符串
    str = strconv.FormatFloat(num2, 'f', 10, 64)
    // "23.4560000000"

    // 布尔转字符串
    str = strconv.FormatBool(isTrue)
    // true

// 其他类型转字符类型
    var str string = "true"
    var str1 string = "123456"
    var str2 string = "123.456"
    var isTrue bool
    var num int64
    var num2 float64

    isTrue, _ = strconv.ParseBool(str)
    // true

    num, _ = strconv.ParseInt(str1, 10, 64)
    // 123456

    num2, _ = strconv.ParseFloat(str2, 64)
    //  123.456

派生数据类型：指针、数组、切片、函数、map、结构体、通道、接口

指针

指针保存是变量在内存的地址，与c类似

1. 用 *类型来定义指针变量、对于指针变量，可以用*变量名来获取内存地址指向的值

2. &用来获取变量的地址

var a := 1
var num *int = &a
fmt.Println(*num)

map

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用

var gomap map[int]string
// 添加
gomap[1] = "hello"
gomap[2] = "golang"

// map的遍历
for key,value range gomap{
    fmt.Printf("index : %v, value : %v \n", key, value)
}
// search 
v, ok := gomap["age"] 
if ok {
 fmt.Println(v) 
} else { 
 fmt.Println("无字段")
}

// delete


`delete(
delete(gomap,1)

数组与切片

数组：go数组与c相似。需要定义数组类型，和数组长度。数组长度定义后不能修改。

var intarr [4]int
var strarr = [2]string 
var arr = [...]int{1,2,3,4}
var darr = [...][2]int{{1,3},{2,4}}

切片：Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大

var goslice []int
 s1 := make([]int,0,0,0)

// 添加
`append(,)`
// copy 
`copy(,)`
// cap 检查slice容量
`cap()`

结构体和面向对象

go中没有“类”的概念，也不支持“类”的继承和面向对象的概念。GO语言中通过结构体的内嵌在配合接口比面向对象有更高的扩展性和灵活性。

结构体的定义

结构体中字段大写开头表示公开访问，小写表示私有（仅在定义当前结构体的包中可访问）

type <类型名> struct{
    字段名 字段类型
    字段名 字段类型
    字段名 字段类型
}

通过点号访问结构体属性（这里与c类似）

type go_class struct { class_name string class_stage int }
// 声明
var goc := go_class{"helo",10}
// fmt.Println(goc.class_name)

结构体的实例化。（四种实例化方式）

type gc{
    n string
    a int
}
// 1.普通的实例化
var gc1 gc
// 2.键值对初始化
g2 := gc{
    n:"kerci"
    a:10
}
g21 := &gc{
    n:"kerci"
    a:10
}
// 3. 值列表
g3 := &gc{
    "nike"
    20
}
// 4. new关键字,返回的是结构体指针
g4 := new(gc)
//g4 是一个结构体指针

类型别名

语法格式

type <类型名> 类型描述

例如

type byte = uint8
type zj = uint8
//定义结构体变量
var j zj = 1

结构体匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。即上面的值列表的实例化方法定义的字段

结构体嵌套和json化

type address struct { city string }
//User 用户结构体 
type user struct { 
name string 
sex string 
addr address //匿名结构体
}
user1 := user{
    name: "shineyork", 
    sex: "男",
    addr: address{ 
        city: "长沙",
         }, 
    }

结构体转json【json.Marshal()】

data,err := json.Marshal(user1)
if err == nil{
    // 解析错误
}

json转结构体【json.Unmarshal(<[]byte>,<&var>)】

Unmarshal方法有两个参数,第一个是json字符串，需要转为切片类型为[]byte,
第二个参数用来存解析后的结构体。是一个指针变量
// JSON反序列化：JSON格式的字符串-->结构体 

user2 := &user1{} 
err = json.Unmarshal([]byte(data), user2)

面向对象

Go语言中的方法是一种作用于特定变量的函数。这种函数变量叫做接收者（receiver）。接收者概念类似于this或者self

// 1.定义结构体user
type user struct{
    Name string
}
// 2. 添加方法
func (u user) getName() string {
    fmt.Println(u.Name)
}
// 3. 实例化、调用

user1 = &user{"zhijie"}
user1.getName()

继承

通过结构体的匿名字段来实现继承

type Animal struct{
    Name string
}
func (a Animal) Eat() {
    fmt.Printf("%v is eating", a.Name)
}
// 定义cat类，继承Animal
type Cat struct {
    Animal
}
// 实例化
cat := Cat{Animal:&Animal{Name:"cat"}}
cat.Eat()

接口和多态

Go中的接口(interface)是一种数据结构！准确来说是一种方法参数的类型约束

接口的定义和使用

type ImplAnimal interface{
    Eat()
}
// 动物 所有动物的父类
type Animal struct {
    Name string
}
// 实现接口的方法
func (a Animal) Eat{
    fmt.Printf("%v is eating", a.Name)
}

// 定义一个接口
tye Animal interface{
    Eat()
}
// 定义两种动物类
type Cat struct{
    Name string
}
type Dog struct{
    Name string
}
func (c Cat) Eat() {
    fmt.Println("eat fish")
    fmt.Println()
}
func (d Dog) Eat(){
    fmt.Println("eat bone")
    fmt.Println()
}
// 定义一个多态函数
func A_Eat(a Animal){
    a.Eat()
}
func main(){
    // 实例化使用
    dog := &Dog{}
    cat := &Cat{}
    A_Eat(dog)
    A_Eat(cat)
}

基础篇end