2021-11-30

Go语言基础(2)

go语言基础

指针：

指针变量只能读取不能修改，不能修改指针变量指向的地址
& 根据变量取地址
* 根据内存地址取值

package main

import "fmt"

func main() {
   s := 5
   fmt.Printf("%T",&s) //打印的是int类型的指针 *int
   a := &s
   fmt.Println()
   fmt.Printf("%T",*a)//打印的是int类型的值 int
}

map:

1.map存储的是键值对的数据，也是需要申请内存。

var m1 map[string]int
m1 = make(map[string]int)
m1["jiayue"] = 100
fmt.Println(m1)

m2 := map[string]int{
    "jiayue" : 100,
}

// 声明之后必须初始化，才能使用，以下两种一个意思
package main
var m map[string]int
func main(){
    m = make(map[string]int) //或者m = map[string]int{}
    m["jiayue"] = 100
    fmt.Println(m)
} 
------------------------------------------------------------------------
package main
func main(){
    // 声明并初始化 <= 注意这里是 := 不是 =
    m := make(map[string]int) //或者m := map[string]int{"jiayue":1}
    m["jiayue"] = 1
    fmt.Println(m)
    
} 
-------------------------------------------------------------------------
package main

var m = map[string]int{"jiayue":1} //Go允许声明带初始值的变量，变量可以是数组 切片 map 还有普通变量

func main(){
    fmt.Println(m)
    
}

2.map如果key不存在反馈的是value类型的是值
判断key是否存在
score，ok := m1[“jiayue”]
如果jiayue这个key不存在 ok 是false

3.delete删除map对应的值，如果删除的key不存在，那就什么都不干
delete(map变量，删除的key)

defer语句
defer把它后面的语句延迟到函数即将返回的时在执行
defer 多个的话后进先出原则
defer主要放便释放资源比如关闭open的文件

package main

import "fmt"

func calc(index string, a, b int) int {
   ret := a + b
   fmt.Println(index, a, b, ret)
   return ret
}


func main() {
   a := 1
   b := 2
   defer calc("1", a, calc("10", a, b)) //a和b的值已经代入，不受后面变量的改变而改变，calc里的calc会直
                                       // 接运算，不等待defer
   a = 0
   defer calc("2", a, calc("20", a, b)) //同理上面备注，只是a变成了0
   b = 1

}

//运行结果
// 10 1 2 3
// 20 0 2 2
// 2 0 2 2
// 1 1 3 4

2021-11-30

Go语言基础(1)

Go语言基础（1）

1.Go语言中的函数传递的都是原来值的是一个副本，和原来的值没关系
2.切片（Slice）是一个引用，修改切片的值，原来的值也发生改变。

a := []int{1, 2, 3}
b := a
b[1] =100
fmt.Println(a)

3.Array定义例子:a = [3]int 或者 a = […]int
4.切片定义 :
a := []int 切片要用初始化：a := []int{1, 2, 3}
也可以用make的初始化例： a := make([]int, 3, 3) 初始化的容量是对应类型的0值
切片：指针，长度，容量
切片不能直接比较，只能和nil进行比较，Slice没有分配内存 == nil
切片用append可以自动初始化，不需要初始化
copy是拷贝到值，而不是引用，且拷贝的目标必须有位置,具体例子：

package main

import "fmt"

func main() {
   a := []int{1, 2, 3}
   b := make([]int, 3)
   copy(b, a)
   b[0] = 100
   fmt.Println(b)
   fmt.Println(a)
}

Slice扩容策略（需要了解)
bool类型的初始值是false

2021-11-28

Go语言简介

Go语言（或 Golang）起源于 2007 年，并在 2009 年正式对外发布。Go 是非常年轻的一门语言，它的主要目标是“兼具 Python 等动态语言的开发速度和 C/C++ 等编译型语言的性能与安全性”。

Go语言是编程语言设计的又一次尝试，是对类C语言的重大改进，它不但能让你访问底层操作系统，还提供了强大的网络编程和并发编程支持。Go语言的用途众多，可以进行网络编程、系统编程、并发编程、分布式编程。

Go语言的推出，旨在不损失应用程序性能的情况下降低代码的复杂性，具有“部署简单、并发性好、语言设计良好、执行性能好”等优势，目前国内诸多 IT 公司均已采用Go语言开发项目。

Go语言有时候被描述为“C 类似语言”，或者是“21 世纪的C语言”。Go 从C语言继承了相似的表达式语法、控制流结构、基础数据类型、调用参数传值、指针等很多思想，还有C语言一直所看中的编译后机器码的运行效率以及和现有操作系统的无缝适配。

因为Go语言没有类和继承的概念，所以它和 Java 或 C++ 看起来并不相同。但是它通过接口（interface）的概念来实现多态性。Go语言有一个清晰易懂的轻量级类型系统，在类型之间也没有层级之说。因此可以说Go语言是一门混合型的语言。

此外，很多重要的开源项目都是使用Go语言开发的，其中包括 Docker、Go-Ethereum、Thrraform 和 Kubernetes。