【学习笔记】Golang基础知识_Golang

系列文章目录

笔者最近实习需要用到Golang，特此记录一下Golang的一些知识点。基本语法之类的知识不做详细阐述了，各类教程上讲的也比较清楚。

文章目录系列文章目录一、结构体定义一个结构体隐藏结构Go函数作为结构体字段二、数组基本语法数组的复制切片切片的组件切片的创建遍历一个切片切片排序指针函数返回指针指向结构体的指针数组指针 Go并发Goroutines 参考资料

一、结构体定义一个结构体

type Address struct{
	name, street, city, state string
	Pincode int
}

//使用该结构体
func main() {
	var a Address
	fmt.Println(a)
	//两种赋值方法
	 a1 := Address{"Akshay", "Dehradun", 3623572} 
	 a2 := Address{Name: "Anikaa", city: "Ballia",Pincode: 277001} 
	fmt.Println(a1)
	fmt.Println(a2)
}

隐藏结构

func main(){
	Element := struct{
		name string
		language string
	}{
		name: "小明"
		language: "Golang"
	}
	fmt.Println(Element)
}

Go函数作为结构体字段

//作为Go结构中的字段
package main 
  
import "fmt"
  
// Finalsalary函数类型
type Finalsalary func(int, int) int
  
//创建结构
type Author struct { 
    name      string 
    language  string 
    Marticles int
    Pay       int
    //函数作为字段
    salary Finalsalary 
} 
  
func main() { 
  
    // 初始化字段结构
    result := Author{ 
        name:      "Tommy", 
        language:  "Golang", 
        Marticles: 120, 
        Pay:       500, 
        salary: func(Ma int, pay int) int { 
            return Ma * pay 
        }, 
    } 
  
    fmt.Println("作者姓名: ", result.name) 
    fmt.Println("语言: ", result.language) 
    fmt.Println("五月份发表的文章总数: ", result.Marticles) 
    fmt.Println("每篇报酬: ", result.Pay) 
    fmt.Println("总工资: ", result.salary(result.Marticles, result.Pay)) 
}

二、数组基本语法

var array_name[length]Type
或
var array_name[length]Typle{item1, item2, item3, ...itemN}

代码如下（示例）：

package main
import "fmt"

func main(){
	var myarr [3]string
	myarr[0] = "Tommy"
	myarr[1] = "abc"
	myarr[2] = "efg"
	//var myarr := [3]string{"Tommy", "abc", "efg"}
	
	fmt.Println(myarr[0]) //输出元素
}

数组的复制

//接上面的例子
myarr2 := myarr
fmt.Println("array2:", myarr2)

切片切片的组件指针：指针用于指向可通过切片访问的数组的第一个元素。在这里，指针指向的元素不必是数组的第一个元素长度：长度是数组中存在的元素的总数容量：容量表示可以拓展的最大大小

代码如下（示例）：

func main() {

    //创建一个数组
    arr := [7]string{"这", "是", "Golang", "学习", "笔记", "切片"}
    //显示数组
    fmt.Println("数组:", arr)
    //创建切片
    myslice := arr[1:5]
    //显示切片
    fmt.Println("切片:", myslice)
    //显示切片的长度
    fmt.Printf("切片长度: %d", len(myslice))
    //显示切片的容量
    fmt.Printf("\n切片容量: %d", cap(myslice))
}

输出
数组：[ 这是 Golang 学习笔记切片]
切片：[ 是 Golang 学习笔记 ]
切片长度: 4
切片容量: 5

切片的创建

使用make函数创建切片
语法：

func make([]T, len, cap) []T

func main(){
	//创建大小为7的数组
    //将此数组切成4
    //并返回切片的引用
    //使用make函数
    var my_slice_1 = make([]int, 4, 7)
    fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n",my_slice_1, len(my_slice_1), cap(my_slice_1))

    //创建另一个大小为7的数组
    //并返回切片的引用
    //使用make函数
    var my_slice_2 = make([]int, 7)
    fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n",my_slice_2, len(my_slice_2), cap(my_slice_2))
}

遍历一个切片

myslice := []string{"这","是","Golang","学习","笔记","切片"}

for i:=0; i < len(myslice);i++{
	fmt.Println(myslice[i])
}

切片排序

//创建切片
    slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"} 
    slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89} 
	sort.Strings(slc1)
	sort.Ints(slc2)

指针

package main
import "fmt"
func main() {

    //使用var关键字
    //我们没有定义
    //没有指定变量的类型
    var y = 120
    //使用指针变量
    // var关键字，不指定类型
    var p = &y
    fmt.Println("更改前存储在y中的值 = ", y)
    fmt.Println("y的地址 = ", &y)
    fmt.Println("存储在指针变量p中的值 = ", p)

    //这是取消引用指针
    //在指针之前使用*运算符
    //变量以访问存储的值
    //指向它所指向的变量
    fmt.Println("更改前存储在y(*p)中的值 = ", *p) //120

    //通过赋值改变y的值
    //指针的新值
    *p =200
    fmt.Println("更改后存储在y(*p)中的值 = ", y)  //200
}

更改前存储在y中的值 = 120
y的地址 = 0xc00000a0b8
存储在指针变量p中的值 = 0xc00000a0b8
更改前存储在y(*p)中的值 = 120
更改后存储在y(*p)中的值 = 200

函数返回指针

Golang编程语言中的指针是一个变量，用于存储另一个变量的内存地址。我们可以将指针传递给函数，也可以从Golang中的函数返回指针。
Go编译器非常智能！它不会将堆栈上的内存分配给该函数的局部变量。它将在堆上分配此变量。在下面的程序中，变量lv将在堆上分配内存，因为Go编译器将执行转义分析以从本地范围转义变量。

//Go 函数返回指针
package main
import "fmt"
func main() {
    //调用函数
    n := rpf()
    //显示值
    fmt.Println("n的值: ", *n)
}

//定义具有整数的函数
//指针作为返回类型
func rpf() *int {
    //局部变量
    //函数内部使用简短运算符声明
    lv := 100
    // 返回lv的地址
    return &lv
}

指向结构体的指针

package main
import "fmt"
//定义结构体
type Employee struct {
    name  string
    empid int
}

func main() {
    //创建的实例
    //员工结构类型
    emp := Employee{"ABC", 19078}
    //在这里，它是指向结构体的指针
    pts := &emp  //不需要重新定义指针哈，编译器会自动定义
    //显示值
    fmt.Println(pts)
    //更新name的值
    pts.name = "XYZ"
    fmt.Println(pts)

}

数组指针

arr := [8]int{200, 300, 400, 500, 600, 700, 800, 900]

var x int
var p [5]*int

for x = 0; x < len(p);x++ {
	p[x] = &arr[x]
	fmt.Printf("p[%d] 的值= %d\n",x, *p[x])
}
fmt.Println("arr的容量",cap(arr)) //8
fmt.Println("p的容量",cap(p))	//5

// 使用 len() 函数查找长度
fmt.Println("arr长度: ", len(arr))
fmt.Println("p长度: ", len(p))

Go并发 Goroutines

优点：

开销比线程小Goroutines存储在堆栈中，并且堆栈的大小可以根据程序的要求而增大或缩小。线程中堆栈的大小是固定的。Goroutines可以使用通道进行通信，并且这些通道经过特殊设计，可以防止内存征用。假设一个程序有一个线程，并且该线程有许多与之关联的Goroutine。如果由于资源需求，任何Goroutine阻塞了线程，则所有其余Goroutine将分配给新创建的OS线程。所有这些细节对程序员都是隐藏的。

package main 
  
import ( 
    "fmt"
    "time"
) 
  
func display(str string) { 
    for w := 0; w < 6; w++ { 
        time.Sleep(1 * time.Second) 
        fmt.Println(str) 
    } 
} 
  
func main() { 
  
    // 调用Goroutine 
    go display("Welcome") 
  
    //调用普通函数
    display("nhooo") 
}

我们在程序中添加了Sleep()方法，它使主Goroutine在新Goroutine执行的1秒之间睡眠1秒，在屏幕上显示欢迎，然后在1秒的主Goroutine重新调度并执行其 *** 作后终止。这个过程一直持续到z的值<6，之后主Goroutine终止。在这里，Goroutine和普通函数同时工作。

参考资料

视频：https://www.bilibili.com/video/BV1ME411Y71o?p=1
教程：

https://studygolang.com/subject/2https://www.nhooo.com/golang/golang-tutorial.htmlhttp://c.biancheng.net/view/5394.html

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/langs/995313.html