go快速入门 1

最新推荐文章于 2024-06-06 22:32:45 发布
最新推荐文章于 2024-06-06 22:32:45 发布
阅读量648 收藏 1
点赞数
分类专栏： go 文章标签： go golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44102152/article/details/116132140
版权

go快速入门 1

go开发目录

个人
在这里插入图片描述
团队
在这里插入图片描述

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

语言组成

包声明

package main
第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

引入包

import “fmt”
告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。

函数

func main(){
fmt.Println(“hello world! go and golang”);
}
是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

变量

var name string = “go”
go的变量声明会采用var关键词进行声明同时会携带上声明的数据类型

go保留字

常量:    true  false  iota  nil

类型:    int           int8      int16            int32              int64  
         uint        uint8     uint16            uint32            uint64    uintptr
         float32    float64    complex128       complex64
         =bool       byte       rune               string              error

方法:   make       len        cap     new    append    copy    close    delete
       complex     real      imag
       panic      recover

基本数据类型

类型描述
uint32位或64位
uint8无符号 8 位整型 (0 到 255)
uint16无符号 16 位整型 (0 到 65535)
uint32无符号 32 位整型 (0 到 4294967295)
uint64无符号 64 位整型 (0 到 18446744073709551615)
int32位或64位
int8有符号 8 位整型 (-128 到 127)
int16有符号 16 位整型 (-32768 到 32767)
int32有符号 32 位整型 (-2147483648 到 2147483647)
int64有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
byteuint8的别名(type byte = uint8)
runeint32的别名(type rune = int32)，表示一个unicode码
uintptr无符号整型，用于存放一个指针是一种无符号的整数类型，没有指定具体的bit大小但是足以容纳指针。
uintptr类型只有在底层编程是才需要，特别是Go语言和C语言函数库或操作系统接口相交互的地方。
float32IEEE-754 32位浮点型数
float64IEEE-754 64位浮点型数
complex6432 位实数和虚数
complex12864 位实数和虚数

详细说明：https://www.cnblogs.com/itbsl/p/9854681.html
建议先去看看再回来继续。

类型定义

在这里插入图片描述

package main

import "fmt"

type ih interface { // 定义接口

}
type user struct { // 定义结构体属性
	name string // 结构体属性
	age  int
}

func (u user) getAge() int { //getAge方法名  int 返回参数类型 要先定义结构体
	return u.age
}
func main() {
	//创建结构体
	//实例化
	tu := user{
		name: "哈哈a",
		age:  12,
	}
	fmt.Println(tu.name)
	fmt.Println(tu.getAge()) //调用
}

作用域

在这里插入图片描述

go语言声明

有四种主要声明方式：

var（声明变量）, const（声明常量）, type（声明类型）, func（声明函数）。

变量var

语法

// 变量
var 变量名 变量类型
var (
	a int
	b int
)

例子

// 正常定义方式
var a int = 0
fmt.Println("常定义方式 ：", a)
// 根据值得知类型
var c = 0
fmt.Println("根据值得知类型 ：", c)
// := 定义方式
b := 0
fmt.Println(" := 定义方式 ：", b)
// 批量定义
var (
	v_a int = 201
	v_b int
)
v_b = 202
fmt.Printf("批量声明变量 v_a:%a | v_b:%b \n", v_a, v_b)

常量 const
语法

const identifier [type] = value
const (
	n1 = iota //0
	n2 //1
	n3 //2
	n4 //3
)
const c_name1, c_name2 = value1, value2

例子

const GNAME = "sixstar"
const (
	a = 1
	b = 2
)
const (
	a1 = 10
	b1
	c1
)
fmt.Println("GNAME", GNAME)
fmt.Println("a, b: ", a, b)
fmt.Println("a1, b1, c1: ", a1, b1, c1)

iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota是go语言的常量计数器，只能在常量的表达式中使用。 iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用

const (
	a1 = iota
	b1
	c1
)
const (
	a1 = iota
	b1 = iota
	c1 = iota
)
fmt.Println("a1, b1, c1: ", a1, b1, c1)
// 输出都是 ： a1, b1, c1: 0 1 2
const (
	a = iota //0
	b //1
	c //2
	d = "ha" //独立值，iota += 1
	e //"ha" iota += 1
	f = 100 //iota +=1
	g //100 iota +=1
	h = iota //7,恢复计数
	i //8
)
fmt.Println(a, b, c, d, e, f, g, h, i)
// 输出是 ：0 1 2 ha ha 100 100 7 8
const (
	a, d = iota + 1, iota + 10
	b, e
	c, f
)
fmt.Println(a, b, c, d, e, f)
// 输出是 ：1 2 3 10 11 12

函数 func

特点
------无需声明原型。
------支持不定变参。
------支持多返回值。
------支持命名返回参数。
------支持匿名函数和闭包。
------函数也是一种类型，一个函数可以赋值给变量。
------不支持 嵌套 (nested) 一个包不能有两个名字一样的函数。
------不支持 重载 (overload)
------不支持 默认参数 (default parameter)。

语法

func function_name( [parameter list] ) [return_types] { 
	函数体
}

例子

func main() {
	a, b := test(1, 2, "sum")
	fmt.Println("a,b : ", a, b)
	dome()
}
func test(x, y int, s string) (int, string) {
	// 类型相同的相邻参数，参数类型可合并。 多返回值必须用括号。
	n := x + y
	return n, s
}
func dome() {
	fmt.Println("dome")
}

结构体 type

语法

type 类型名 struct { 
	字段名 字段类型
	字段名 字段类型
	…
}

其中：

  1. 类型名：标识自定义结构体的名称，在同一个包内不能重复。
  2. 字段名：表示结构体字段名。结构体中的字段名必须唯一。
  3. 字段类型：表示结构体字段的具体类型。

对于学习过其他语言的同志来说可以理解为是对象属性，只是不存在方法

栗子：

type go_class struct {
	class_name string
	class_stage int
}
func main() {
	fmt.Println(go_class{"go class", 1}) //输出 {go class 1}
	var g go_class
	g.class_name = "shineyork go class"
	g.class_stage = 1
	fmt.Println("课程名: ", g.class_name)
	fmt.Println("课程阶段: ", g.class_stage)
}

go语言中的init与main函数

main 函数

Go语言程序的默认入口函数(主函数)：func main()
函数体用｛｝一对括号包裹。

func main(){
	//函数体
}

main函数只能用于main包中，且只能定义一个。如同PHP框架中的index.php

init 函数

go语言中init函数用于包(package)的初始化，该函数是go语言的一个重要特性。可以理解为如同其他语言中的面向对象

func init() {

}

特征：

  1. init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等
  2. 每个包可以拥有多个init函数
  3. 包的每个源文件也可以拥有多个init函数
  4. 同一个包中多个init函数的执行顺序go语言没有明确的定义(说明)
  5. 不同包的init函数按照包导入的依赖关系决定该初始化函数的执行顺序
  6. init函数不能被其他函数调用，而是在main函数执行之前，自动被调用

栗子:

var name string
func init() {
	name = "shineyork"
}
func main() {
	fmt.Println(name)
}

对同一个go文件的init()调用顺序是从上到下的。

对同一个package中不同文件是按文件名字符串比较“从小到大”顺序调用各文件中的init()函数。

对于不同的package，如果不相互依赖的话，按照main包中"先import的后调用"的顺序调用其包中的init()，如果package存在依赖，则先调用最早被依赖的package中的init()，最后调用main函数。

如果init函数中使用了println()或者print()你会发现在执行过程中这两个不会按照你想象中的顺序执行。这两个函数官方只推荐在测试环境中使用，对于正式环境不要使用。

import 和 package 的使用

golang使用package来管理定义模块,可以使用import关键字来导入使用。

如果导入的是go自带的包，则会去安装目录$GOROOT/src按包路径加载，如fmt包
如果是我们go get安装或自定义的包，则会去$GOPATH/src下加载

package的定义

注意相信对很多phper来说遵循PSR4的Namespace会将与路径紧密相关命名空间也作为类名的一部分,而golang则只将模块目录文件夹名作为包名,前面的路径只是用来导入而和包名无关,还是有一点需要注意的。

package的存放位置是以$GOPATH/src作为根目录，然后灵活的按照目录去组织，且包名需与最后一级目录名一致。
例如我们自定义baz包,包模块的存放位置则为$GOPATH/src/foo/bar/baz, baz 包的源码都存放在此目录下，foo/bar/baz则作为包路径被import载入。

我们需要规范的将baz包中源码的package定义为baz,就定义好一个可import载入的的包了。

自己操作理解：
GOPATH\src 目录下 或 Path\src 目录下新建 文件夹 sms
sms文件下新建ali文件夹 和 email.go、qq.go
D:\phpstudy_pro\go\src\sms\email.go
package sms //sms为文件夹

package sms
import "fmt"
func Email(){
	fmt.Println("sms:email")
}

D:\phpstudy_pro\go\src\sms\qq.go

package sms
import "fmt"
func Qq(){
	fmt.Println("sms:qq")
}

D:\phpstudy_pro\go\src\sms\ali\zhifubao.go

package ali
import "fmt"
func Yun(){
	fmt.Println("sms\\ali:yun")
}

注意作用域

  1. 声明在函数内部，是函数的本地值，类似private
  2. 声明在函数外部，是对当前包可见(包内所有.go文件都可见)的全局值，类似protect
  3. 声明在函数外部且首字母大写是所有包可见的全局值,类似public

import 的定义

package main
import (
	"fmt"
	"sms"
	"sms/ali"
)
func main(){
	sms.Email()   //sms:email
	sms.Qq()      //sms:qq
	ali.Yun()     //sms\ali:yun
}

普通导入就是按照加载机制，将要使用的包导入进来，然后使用 packageName.MethodName 的方式调用包内的方法即可。注意如果要包方法在其他包中可以调用，包方法需要首字母大写，例如：fmt.Println()
fmt.Printf()。

别名方式
如果两个包的包名存在冲突时，我们可以使用别名导入来解决。

package main
import (
	"fmt"
	"sms"
	smsAli "sms/ali"
)
func main(){
	sms.Email()   //sms:email
	sms.Qq()      //sms:qq
	smsAli.Yun()     //smsAli 就是别名
}

下划线

在包中运用
D:\phpstudy_pro\go\src\sms\email.go

package sms
import "fmt"
func init() {
	fmt.Println("init-sms:email")
}
func Email() {
	fmt.Println("sms:email")
}

D:\phpstudy_pro\go\src\sms\ali\zhifubao.go

package ali
import "fmt"
func init() {
	fmt.Println("init-sms-ali:yun")
}
func Yun(){
	fmt.Println("sms\\ali:yun")
}

测试执行

package main
import (
	"fmt"
	"sms"
	_ "sms/ali"
)
func main(){
	sms.Email()   
	sms.Qq()      
	//ali.Yun()     //不注释的话 undefined: ali 报错
}

init-sms:email
init-sms-ali:yun
sms:email
sms:qq

import 下划线（如：import hello/imp）的作用：当导入一个包时，该包下的文件里所有init()函数都会被执行，然而，有些时候我们并不需要把整个包都导入进来，仅仅是是希望它执行init()函数而已。这个时候就可以使
用 import 引用该包。即使用【import _ 包路径】只是引用该包，仅仅是为了调用init()函数，所以无法通过包名来调用包中的其他函数。

下划线在代码中的运用

package main
import "fmt"
func main() {
	a, _ := compare(1)
	fmt.Println(a)
}
func compare(a int) (int, error) {
	return a, nil
}

解释1：

  1. 下划线意思是忽略这个变量.
  2. 比如compare,返回值为int, error
  3. 普通写法是a,err := compare(1)
  4. 如果此时不需要知道返回的错误值
  5. 就可以用a，_ := compare(1)
  6. 如此则忽略了error变量

解释2：

  1. 占位符，意思是那个位置本应赋给某个值，但是咱们不需要这个值。
  2. 所以就把该值赋给下划线，意思是丢掉不要。
  3. 这样编译器可以更好的优化，任何类型的单个值都可以丢给下划线。
  4. 这种情况是占位用的，方法返回两个结果，而你只想要一个结果。
  5. 那另一个就用"_"占位，而如果用变量的话，不使用，编译器是会报错的。

下一篇：go流程控制和集合 02
上一篇：go介绍安装入门

哒哒-blog
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Go语言之Go 快速入门篇（一）：第一个 Go 程序
weixin_59284282的博客
06-09 753
使用 Go 语言之前，首先要安装 Go。Go 为 Linux、Mac、Windows 等不同的平台分别提供了相应的安装包：Download and install - The Go Programming Language，根据自己的操作系统选择对应的安装包点击下载，然后按照引导流程安装即可。以 Mac 为例，除了官方提供的 Go 安装器，还可以通过 Homebrew 在终端窗口进行安装： 安装完成后，通过 查看 Go 语言的版本来验证是否安装成功（编写此教程时的最新版是 1.15.7）：在本地安装完
GO语言快速入门
程序媛也要干巴爹
03-29 925
简介 特性 强类型、编译型、并发型，并具有垃圾回收功能的编程语言。 运行方式 直接运行： go run helloworld.go 编译后再运行： $ go build helloworld.go $ ./helloworld Hello，world 语法 “{”必须和func同一行 首字母大写的是可以由package外部访问的；首字母小写的只能在package内部访问 数据类型 ...
Go 快速入门
WGH100817的博客
11-21 368
入门 Go 语言需要多久？答案是 —— 读完这篇文章的时间！不妨找一个周末的下午，踏上 Go 之旅吧！ 更新记录： 2016.12.12: 完成重制 2016.11.02: 增加重点理解和参考链接 2016.08.11: 完成初稿 任务目标 了解 Go 的设计哲学和与其他面向对象语言在编程思路上的不同 掌握基本的语法...
快速开始一个go程序（极简-快速入门）
最新发布
技术栈：C++、go、python，方向：软开，测开
06-06 1382
关键字defer会安排随后的函数调用在函数返回时才执行。在使用完文件后，需要主动关闭文件。使用关键字defer来安排调用 Close 方法，可以保证这个函数一定会被调用。哪怕函数意外崩溃终止，也能保证关键字defer安排调用的函数会被执行。关键字defer可以缩短打开文件和关闭文件之间间隔的代码行数，有助提高代码可读性，减少错误。
go快速入门
EGXXM的博客
04-10 1097
文章目录Go速速复习通关开发环境搭建语言环境**Windows安装**开发编辑器hello worldGo语言基础Go编程基础25个内置关键字注释包可见性规则简写类型Go基本类型类型零值类型转换变量与常量变量单个多个短变量注意事项：常量批量iota运算符运算符指针++流程控制forif elseswitch case跳转语句数组一维数组二维/多维数组 2022.3.27 Go速速复习通关 开发环境 搭建语言环境 Windows安装 1.4之前需要配置GOPATH,之后啥都不需要配置 下载安装目录：https
GO快速入门一
小松鼠的专栏
07-09 281
GO快速入门一 简介 该部分教程是从0到入门，快速上手Go语言，至于入门之后是到精通还是放弃，请君自夺。 安装 建议还是Linux下开发，或者是在windows上只是使用ide，其余都在Linux下进行。 下载地址：https://golang.google.cn/dl/ Windows 下载.msi文件，要最新的，学新不学旧。 配置环境变量，大概率安装后不需要配置，会自动配置好。 安...
区块链 go语言快速入门
08-13
区块链 go语言 快速入门 Go安装包 IDE工具 代码 区块链之Go语言快速入门 ppt
golang基础教程-go语言快速入门.zip
04-01
《Go语言快速入门：Go语言基础教程》 Go语言，又称Golang，是Google在2009年推出的一种开源编程语言，由罗伯特·格瑞史莫、罗布·派克和肯特·贝克等大神设计。Go语言的设计目标是简单、高效、安全，特别适合构建...
gostudy:golang基础教程-go语言快速入门
05-07
golang基础教程-快速入门go语言 教程内容 golang语言介绍，安装部署，运行第一个程序及基础介绍，工具介绍，go module，基础语法，常用数据结构，函数介绍，指针，结构体，接口，错误处理，协程，通道，通道选择器及...
golang快速入门[2.3]-go语言开发环境配置-linux
01-08
golang快速入门[2.3]-go语言开发环境配置-linux linux安装Go语言开发包 默认读者会使用linux的基本操作 配置go语言的开发环境的第一步是要在go官网下载页面下载开发包 linux需要下载tar.gz压缩文件   这里我们...
Go-快速入门~~~
lijieaace的博客
11-25 241
如果不是要在Linux平台敲go代码就不需要在Linux平台安装Go，我们开发机上写好的go代码只需要跨平台编译（详见文章末尾的跨平台编译）好之后就可以拷贝到Linux服务器上运行了，这也是go程序跨平台易部署的优势。保证静态语言的安全和性能、又可以达到动态语言的开发维护的高效率、Go=C+Python ，是对当前用户生效的，根据自己的情况自行选择一个文件打开，添加如下两行代码，保存退出。.go文件–go build编译–>可执行文件（.exe或者其他）–运行–> 结果。安装即可，默认会将go安装到。
Go快速入门
Gandoph的博客
07-14 1152
一、Go语言概述 Go是一种编译型语言，它结合了解释型语言的游刃有余，动态类型语言的开发效率，以及静态类型的安全性。它也打算成为现代的，支持网络与多核计算的语言。要满足这些目标，需要解决一些语言上的问题：一个富有表达能力但轻量级的类型系统，并发与垃圾回收机制，严格的依赖规范等等。这些无法通过库或工具解决好，因此Go也就应运而生了。Go是一种新的语言，一种并发的、带垃圾回收的、快速编...
go 快速入门
拒绝熬夜啊的博客
03-27 876
go 快速入门
Go语言快速入门
weixin_39540280的博客
11-10 1828
​ 一. 下载GO go安装文件以及源代码 Downloads - The Go Programming Language 下载对应平台的二进制文件以及安装 环境变量 GOROOT： go的安装目录 GOPATH： src 存放源代码 pkg 存放依赖包 bin 存放可执行文件 其他常用变量： GOOS GOARCH GOPROXY
GO基础篇-快速入门
Anthony路人甲的博客
07-05 561
GO基础篇-快速入门
go语言快速入门篇
YunxiaoYuji1的博客
03-29 415
Go语言是一种并发性高、静态类型、强类型的编程语言，它的设计目的是提高程序开发的效率和可维护性。Go语言需要明确声明变量类型，可以使用关键字var来定义变量，也可以使用:=进行简短声明。Go语言的数组和切片是非常重要的数据结构。Go语言的接口是一种能力描述，可以用来描述一个类型的方法集合。Go语言的函数可以返回多个值，而且函数也可以作为参数传递。f := 3.14 // 浮点型。b := true // 布尔型。// 访问数组和切片元素。// 使用接口实现多态。// 遍历数组和切片。// 函数返回多个值。
Go语言语法快速入门(1)
o83290102o5的博客
11-26 1203
题外话go的语法特性相较于一些新语言来说比较少，甚至还比不过一些比较老的语言,例如，它没有隐式的数值转换，没有构造函数和析构函数，没有运算符重载，没有默认参数，也没有继承，没有泛型，没有异常，没有宏，没有函数修饰，更没有线程局部存储。go和python的编程哲学有点像，做一件事只有一件对的方法，所以他的编译检查非常严格，不仅有和python类似的强制格式，除此之外未使用的变量导入后未使用的包都会导致
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值