【学习笔记】Golang基础知识

【学习笔记】Golang基础知识,第1张

系列文章目录

笔者最近实习需要用到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

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-05-21
下一篇 2022-05-21

发表评论

登录后才能评论

评论列表(0条)

保存