七叶笔记 » golang编程 » go语言学习第一周

go语言学习第一周

Go语言个人认为比较适合大厂的高并发,大流量的项目,还有一些需要长链接的比如即时通讯,游戏等项目。

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

Go 使用编译器来编译代码。编译器将源代码编译成二进制(或字节码)格式;在编译代码时,编译器检查错误、优化性能并输出可在不同平台上运行的二进制文件。要创建并运行 Go 程序,程序员必须执行如下步骤。

  1. 使用文本编辑器创建 Go 程序;
  2. 保存文件;
  3. 编译程序;
  4. 运行编译得到的可执行文件。


这不同于 Python、Ruby 和 JavaScript 等语言,它们不包含编译步骤。Go 自带了编译器,因此无须单独安装编译器。

本周主要学些了go语言的基础语法,各种数据类型的定义,开发环境的安装,ide的安装,这里使用的vscode作为开发工具。

1:变量的定义方法

 package main
import("fmt")
func main(){
//第一种
var name string 
name =  "姓名"
//第二种
var gender  = 1
//第三种
var age int = 24
//第四种
nick := "昵称"
    fmt.Println("name:",name)
fmt.Println("gender:",gender)
fmt.Println("age:",age)
fmt.Println("nick:",nick)
}  

运行结果:

 PS E:\go\01> go run 1.go
name: 姓名
gender: 1
age: 24
nick: 昵称  

定义多个变量集合

 var(
id int 
name string
)
var id name = 1,2  

2:go语言的指针

指针个人理解就是把内存地址传递到函数中,在函数中改变的值,也会改变他对应内存地址的值,也叫传址调用。普通非指针模式叫 传值调用,函数中改变的值是不能影响到外界的。

 package main
import("fmt")

func setName(name *string){
    *name = "老汪" 
}

func setAge(age *int)  {
*age = 25
}
func main(){
//初始值
var name string = "老李"
var age int = 20;
setName(&name);
setAge(&age)
//改变后的值
fmt.Println(name)
fmt.Println(age)

}  

运行效果:

 PS E:\go\01> go run point.go
老汪
25  

3:go语言函数和返回值

 package main
import("fmt")

//返回多个匿名参数
func getBook(id int)(string,string,int)  {
fmt.Println("-----------------")
return "go语言入门","介绍go语言基础知识",50
}
//返回多个实名参数
func getUserInfo(id int) (name string,age int) {
fmt.Println("-----------------")
return "姓名",1
}
//返回多个实名参数
func getUser(id int) (name string,age int) {
fmt.Println("-----------------")
name = "小王"
age = 25
return name,age
}


func main(){
   title,des,price := getBook(1)
   fmt.Println("书籍名称:",title,"书籍介绍:",des,"书籍价格:",price)

   name,age :=getUserInfo(1)
   fmt.Println("name:",name,"age:",age)
   name1,age1 :=getUser(1)
   fmt.Println("name1:",name1,"age1:",age1)
}  

运行结果:

 PS E:\go\01> go run fun.go
-----------------
书籍名称: go语言入门 书籍介绍: 介绍go语言基础知识 书籍价格: 50
-----------------
name: 姓名 age: 1
-----------------
name1: 小王 age1: 25  

4:包和自定义包

引入包的关键import

引入单个包

 import "fmt"  

引入多个包

 import(
"fmt"
"strconv"
)   

创建自定义包

创建的自定义的包需要将其放在 GOPATH 的 src 目录下(也可以是 src 目录下的某个子目录),而且两个不同的包不能放在同一目录下,一个包中可以有任意多个文件,文件的名字也没有任何规定(但后缀必须是 .go),这里我们假设包名就是 .go 的文件名(如果一个包有多个 .go 文件,则其中会有一个 .go 文件的文件名和包名相同)。

 package pak //自定义包名

import "fmt"

func Api()  {
//函数名小写私有=private 大写是公有外部可以调用=public
fmt.Println("自定义开放的api接口")
}

func init(){

fmt.Println("我是自定义包")
}

  

5:defer关键字

defer是的栈形式,所以先进后出,先定义的后执行。

函数中同时存在return 和defer关键字,执行顺序是先return 后defer。

代码如下:

 package main

import(
"fmt"
)

func deferFun()  {
fmt.Println("deferFun")
}

func returnFun() string  {
fmt.Println("returnFun")
return "return"
}

func read() string  {
defer deferFun()
 
return returnFun()
}

func main(){

   ret :=read()
   fmt.Println(ret)
   
}  

结果:

 PS E:\go\01> go run defer.go
returnFun
deferFun
return  

6:go语言的数组

go语言的数组初始化的时候要定义数组的容量。

代码如下

 package main

import(
"fmt"
)
var a [5]int
var b = [10]int{12,15,4,15,8}
func main(){


for i := 0; i < len(a); i++ {
fmt.Println("i=",i)
}

for i,v :=  range b{
           fmt.Println("index:",i,"val:",v)
}
}  

7:切片Slice

切片也叫动态数组,上面介绍的数组的时候发现了,定义的数组一开始都定义好了容量,这样在实际开发中不太灵活,所以Slice切片相对数组就实用的多。

 package main

import(
"fmt"
)
func main(){
//定义一个切片,初始大小5
    s1:= make([]int, 5)

//定义一个切片,包含三个元素
var s2 []int =  []int{1,2,3}

//定义一个切片,包含一个字符串
var s3 = []string{"a"}

//s1中动态增加元素
s1 = append(s1,2)

//s1中修改元素
s1[0] = 100
//s2中动态增加元素
s2 = append(s2,1,2)
//s3中动态增加元素
s3 = append(s3,"b","c")
//结果

fmt.Println("s1",s1,"len",len(s1))
fmt.Println("s2",s2)
fmt.Println("s3",s3)
}
  

运行效果:

 PS E:\go\01> go run slice.go
s1 [100 0 0 0 0 2] len 6
s2 [1 2 3 1 2]
s3 [a b c]  

相关文章