GO 语言语法（1）

最新推荐文章于 2024-04-26 20:43:31 发布
最新推荐文章于 2024-04-26 20:43:31 发布
阅读量220 收藏
点赞数
文章标签： golang 算法
原文链接：https://coolshell.cn/articles/8460.html#%E5%86%85%E5%AD%98%E5%88%86%E9%85%8D
版权

文章目录

Hello World

//文件名：hello.go
package main //声明本文件的package名
import "fmt" //import语言的fmt库——用于输出
func main() {
    fmt.Println("hello world")
}

运行

解释执行&编译执行

#解释执行（实际是编译成a.out再执行）
$go run hello.go
hello world
#编译执行
$go build hello.go
$ls
hello hello.go
$./hello
hello world

fmt

注意：Println不支持，Printf才支持%式的输出：

package main
import "fmt"
import "math"
func main() {
    fmt.Println("hello world")
    fmt.Printf("%t\n", 1==2)
    fmt.Printf("二进制：%b\n", 255)
    fmt.Printf("八进制：%o\n", 255)
    fmt.Printf("十六进制：%X\n", 255)
    fmt.Printf("十进制：%d\n", 255)
    fmt.Printf("浮点数：%f\n", math.Pi)
    fmt.Printf("字符串：%s\n", "hello world")
}

变量和常量

变量

//声明初始化一个变量
var  x int = 100
var str string = "hello world"</pre>
//声明初始化多个变量
var  i, j, k int = 1, 2, 3
//不用指明类型，通过初始化值来推导
var b = true //bool型

x := 100 //等价于 var x int = 100;

常量

const s string = "hello world"
const pi float32 = 3.1415926

数组

func main() {
    var a [5]int
    fmt.Println("array a:", a)
    a[1] = 10
    a[3] = 30
    fmt.Println("assign:", a)
    fmt.Println("len:", len(a))
    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("init:", b)
    var c [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            c[i][j] = i + j
        }
    }
    fmt.Println("2d: ", c)
}

运行结果：

array a: [0 0 0 0 0]
assign: [0 10 0 30 0]
len: 5
init: [1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

数组的切片操作

a := [5]int{1, 2, 3, 4, 5}
b := a[2:4] // a[2] 和 a[3]，但不包括a[4]
fmt.Println(b)
b = a[:4] // 从 a[0]到a[4]，但不包括a[4]
fmt.Println(b)
b = a[2:] // 从 a[2]到a[4]，且包括a[2]
fmt.Println(b)

循环

Go语言中没有while

if语句

//if 语句
if x % 2 == 0 {
    //...
}
//if - else
if x % 2 == 0 {
    //偶数...
} else {
    //奇数...
}
//多分支
if num < 0 {
    //负数
} else if num == 0 {
    //零
} else {
    //正数
}

switch

switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    case 4,5,6:
        fmt.Println("four, five, six")
    default:
        fmt.Println("invalid value!")
}

for循环

//经典的for语句 init; condition; post
for i := 0; i<10; i++{
     fmt.Println(i)
}
//精简的for语句 condition
i := 1
for i<10 {
    fmt.Println(i)
    i++
}
//死循环的for语句 相当于for(;;)
i :=1
for {
    if i>10 {
        break
    }
    i++
}

map

func main(){
    m := make(map[string]int) //使用make创建一个空的map
    m["one"] = 1
    m["two"] = 2
    m["three"] = 3
    fmt.Println(m) //输出 map[three:3 two:2 one:1] (顺序在运行时可能不一样)
    fmt.Println(len(m)) //输出 3
    v := m["two"] //从map里取值
    fmt.Println(v) // 输出 2
    delete(m, "two")
    fmt.Println(m) //输出 map[three:3 one:1]
    m1 := map[string]int{"one": 1, "two": 2, "three": 3}
    fmt.Println(m1) //输出 map[two:2 three:3 one:1] (顺序在运行时可能不一样)
    for key, val := range m1{
        fmt.Printf("%s => %d \n", key, val)
        /*输出：(顺序在运行时可能不一样)
            three => 3
            one => 1
            two => 2*/
    }
}

指针

var i int = 1
var pInt *int = &i
//输出：i=1     pInt=0xf8400371b0       *pInt=1
fmt.Printf("i=%d\tpInt=%p\t*pInt=%d\n", i, pInt, *pInt)

*pInt = 2
//输出：i=2     pInt=0xf8400371b0       *pInt=2
fmt.Printf("i=%d\tpInt=%p\t*pInt=%d\n", i, pInt, *pInt)

i = 3
//输出：i=3     pInt=0xf8400371b0       *pInt=3
fmt.Printf("i=%d\tpInt=%p\t*pInt=%d\n", i, pInt, *pInt)

内存分配

new 是一个分配内存的内建函数，但不同于其他语言中同名的new所作的工作，它只是将内存清零，而不是初始化内存。new(T)为一个类型为T的新项目分配了值为零的存储空间并返回其地址，也就是一个类型为*T的值。用Go的术语来说，就是它返回了一个指向新分配的类型为T的零值的指针。

make(T, args)函数的目的与new(T)不同。它仅用于创建切片、map和chan（消息管道），并返回类型T（不是*T）的一个被初始化了的（不是零）实例。这种差别的出现是由于这三种类型实质上是对在使用前必须进行初始化的数据结构的引用。例如，切片是一个具有三项内容的描述符，包括指向数据（在一个数组内部）的指针、长度以及容量，在这三项内容被初始化之前，切片值为nil。对于切片、映射和信道，make初始化了其内部的数据结构并准备了将要使用的值。如：

下面的代码分配了一个整型数组，长度为10，容量为100，并返回前10个数组的切片

make([]int, 10, 100)

以下示例说明了new和make的不同。

var p *[]int = new([]int)   // 为切片结构分配内存；*p == nil；很少使用
var v  []int = make([]int, 10) // 切片v现在是对一个新的有10个整数的数组的引用

// 不必要地使问题复杂化：
var p *[]int = new([]int)
fmt.Println(p) //输出：&[]
*p = make([]int, 10, 10)
fmt.Println(p) //输出：&[0 0 0 0 0 0 0 0 0 0]
fmt.Println((*p)[2]) //输出： 0

// 习惯用法:
v := make([]int, 10)
fmt.Println(v) //输出：[0 0 0 0 0 0 0 0 0 0]

函数

通用

package main
import "fmt"
func max(a int, b int) int { //注意参数和返回值是怎么声明的
    if a > b {
        return a
    }
    return b
}
func main(){
    fmt.Println(max(4, 5))
}

函数返回多个值

package main
import "fmt"
func main(){
    v, e := multi_ret("one")
    fmt.Println(v,e) //输出 1 true
    v, e = multi_ret("four")
    fmt.Println(v,e) //输出 0 false
    //通常的用法(注意分号后有e)
    if v, e = multi_ret("four"); e {
        // 正常返回
    }else{
        // 出错返回
    }
}
func multi_ret(key string) (int, bool){
    m := map[string]int{"one": 1, "two": 2, "three": 3}
    var err bool
    var val int
    val, err = m[key]
    return val, err
}

函数不定参数

func sum(nums ...int) {
    fmt.Print(nums, " ")  //输出如 [1, 2, 3] 之类的数组
    total := 0
    for _, num := range nums { //要的是值而不是下标
        total += num
    }
    fmt.Println(total)
}
func main() {
    sum(1, 2)
    sum(1, 2, 3)
    //传数组
    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

函数闭包

func nextNum() func() int {
    i,j := 1,1
    return func() int {
        var tmp = i+j
        i, j = j, tmp
        return tmp
    }
}
//main函数中是对nextNum的调用，其主要是打出下一个斐波拉契数
func main(){
    nextNumFunc := nextNum()
    for i:=0; i<10; i++ {
        fmt.Println(nextNumFunc())
    }
}

函数的递归

func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}
func main() {
    fmt.Println(fact(7))
}

结构体

type Person struct {
    name string
    age  int
    email string
}
func main() {
    //初始化
    person := Person{"Tom", 30, "tom@gmail.com"}
    person = Person{name:"Tom", age: 30, email:"tom@gmail.com"}
    fmt.Println(person) //输出 {Tom 30 tom@gmail.com}
    pPerson := &person
    fmt.Println(pPerson) //输出 &{Tom 30 tom@gmail.com}
    pPerson.age = 40
    person.name = "Jerry"
    fmt.Println(person) //输出 {Jerry 40 tom@gmail.com}
}

结构体方法

type rect struct {
    width, height int
}

func (r *rect) area() int { //求面积
    return r.width * r.height
}

func (r *rect) perimeter() int{ //求周长
    return 2*(r.width + r.height)
}

func main() {
    r := rect{width: 10, height: 15}

    fmt.Println("面积: ", r.area())
    fmt.Println("周长: ", r.perimeter())

    rp := &r
    fmt.Println("面积: ", rp.area())
    fmt.Println("周长: ", rp.perimeter())
}

接口和多态

//---------- 接 口 --------//
type shape interface {
    area() float64 //计算面积
    perimeter() float64 //计算周长
}

//--------- 长方形 ----------//
type rect struct {
    width, height float64
}

func (r *rect) area() float64 { //面积
    return r.width * r.height
}

func (r *rect) perimeter() float64 { //周长
    return 2*(r.width + r.height)
}

//----------- 圆  形 ----------//
type circle struct {
    radius float64
}

func (c *circle) area() float64 { //面积
    return math.Pi * c.radius * c.radius
}

func (c *circle) perimeter() float64 { //周长
    return 2 * math.Pi * c.radius
}

// ----------- 接口的使用 -----------//
func interface_test() {
    r := rect {width:2.9, height:4.8}
    c := circle {radius:4.3}

    s := []shape{&r, &c} //通过指针实现

    for _, sh := range s {
        fmt.Println(sh)
        fmt.Println(sh.area())
        fmt.Println(sh.perimeter())
    }
}

错误处理 – Error接口

go的内建接口

type error interface {
    Error() string
}

示例

package main
import "fmt"
import "errors"
//自定义的出错结构
type myError struct {
    arg  int
    errMsg string
}
//实现Error接口
func (e *myError) Error() string {
    return fmt.Sprintf("%d - %s", e.arg, e.errMsg)
}
//两种出错
func error_test(arg int) (int, error) {
    if arg < 0  {
         return -1, errors.New("Bad Arguments - negtive!")
     }else if arg >256 {
        return -1, &myError{arg, "Bad Arguments - too large!"}
    }
    return arg*arg, nil
}
//相关的测试
func main() {
    for _, i := range []int{-1, 4, 1000} {
        if r, e := error_test(i); e != nil {
            fmt.Println("failed:", e)
        } else {
            fmt.Println("success:", r)
        }
    }
}

输出

failed: Bad Arguments - negtive!
success: 16
failed: 1000 - Bad Arguments - too large!

错误处理 – Defer

Go的defer语句预设一个函数调用（延期的函数），该调用在函数执行defer返回时立刻运行。该方法显得不同常规，但却是处理上述情况很有效，无论函数怎样返回，都必须进行资源释放。

func CopyFile(dstName, srcName string) (written int64, err error) {
	src, err := os.Open(srcName)
	if err != nil {
		return
	}
	defer src.Close()
	dst, err := os.Create(dstName)
	if err != nil {
		return
	}
	defer dst.Close()

	return io.Copy(dst, src)
}

我们再来看一个defer函数的示例：

func main() {
	for i := 0; i < 5; i++ {
		defer fmt.Printf("%d ", i)
	}
}

运行结果：

4 3 2 1 0

错误处理 – Panic/Recover

对于不可恢复的错误，Go提供了一个内建的panic函数，它将创建一个运行时错误并使程序停止（相当暴力）。该函数接收一个任意类型（往往是字符串）作为程序死亡时要打印的东西。当编译器在函数的结尾处检查到一个panic时，就会停止进行常规的return语句检查。
当panic被调用时，它将立即停止当前函数的执行并开始逐级解开函数堆栈，同时运行所有被defer的函数。如果这种解开达到堆栈的顶端，程序就死亡了。但是，也可以使用内建的recover函数来重新获得Go程的控制权并恢复正常的执行。 对recover的调用会通知解开堆栈并返回传递到panic的参量。由于仅在解开期间运行的代码处在被defer的函数之内，recover仅在被延期的函数内部才是有用的。
你可以简单地理解为recover就是用来捕捉Painc的，防止程序一下子就挂掉了。

func g(i int) {
    if i>1 {
        fmt.Println("Panic!")
        panic(fmt.Sprintf("%v", i))
    }

}

func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in f", r)
        }
    }()

    for i := 0; i < 4; i++ {
        fmt.Println("Calling g with ", i)
        g(i)
        fmt.Println("Returned normally from g.")
     }
}

func main() {
    f()
    fmt.Println("Returned normally from f.")
}

运行结果如下

Calling g with  0
Returned normally from g.
Calling g with  1
Returned normally from g.
Calling g with  2
Panic!
Recovered in f 2
Returned normally from f.

文章参考： 酷 壳 – CoolShell

Yietion
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go语言学习笔记—golang基础语法
qq_39280718的博客
06-17 1782
golang基础语法
go语言基本语法介绍
Sun_ltyy的博客
12-03 721
Package go程序是由一些列包组成的 程序的运行启动点在main包中的main方法 包通过imort关键字进行导入 为了方便起见，包定义的名称和导出路径的最后一个路径元素名称一致，换句话说包路径的最后一个文件目录下，包含一些列该包名的go文件 例如import"math/rand"，可以看到rand目录下的go文件的package包名都是rand import ...
Go语言template模板语法
JUIU9527的博客
08-10 1006
在嵌套模板中存在预定义函数(官方已经定义好的)和自定义函数(自己定义的),自定义函数使得模板更加灵活.自定义函数通过调用Funcs()方法实现Funcs()方法定义:FuncMapd定义步骤:1.先到后端代码中定义一个函数: (匿名函数为例)2.调用Funcs()方法注意: 调用Funcs()方法,需要在解析模板前调用,也就是在Parse()方法前bytes,err := ioutil.ReadFile("文件名/文件路径")
go语言基本语法
pin-csdn的博客
06-22 2336
1、使用go语言变量 2、定义常量 3、方法定义 4、测试数组 5、测试切片 6、测试map 7、测试通道 8、new 使用 9、range使用 10、并发 11、接口 12、错误处理 13、【defer、panic、recover】
Go语言基础语法入门
qq_41854911的博客
11-09 2249
一、下载及安装 推荐看一下这个博客：Goland激活码/注册码_Goland下载和安装 二、入门教程 Go 语言结构 在我们开始学习 Go 编程语言的基础构建模块前，让我们先来了解 Go 语言最简单程序的结构。 Go Hello World 实例 Go 语言的基础组成有以下几个部分： 包声明 引入包 函数 变量 语句 & 表达式 注释 接下来让我们来看下简单的代码，该代码输出了"Hello World!": 实例 package main import "fmt" func main()
go语言基础语法示例
09-21
主要介绍了go语言基础语法示例，介绍了go语言较为全面的基础知识，具有一定参考价值，需要的可以了解下。
go语言中文教程及手册.pdf
05-06
《go语言中文教程及手册》包含了语言结构、基础语法、数据类型、语言变量、语言常量以及运算符等内容的介绍，可以让你快速进阶为go语言编程高手。简洁，一句废话没有，对于初学者可以让大家快速掌握GO语言！
云计算之go语言——基础语法(下)
01-08
17 Go 语言范围(Range) 1, 概念 Go 语言中 range 关键字用于 for 循环中迭代数组(array)/切片(slice)/通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对...
Go语言学习教程之声明语法（译）
09-21
Golang 就是类C的语法，下面这篇文章主要给大家介绍了关于Go语言学习教程之声明语法的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧。
Go 语言基础语法
01-03
Go 语言基础语法 上一章节我们已经了解了 Go 语言的基本组成结构，本章节我们将学习 Go 语言的基础语法。 Go 标记 Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个...
Golang基础3-函数、nil相关
m0_61973596的博客
04-23 982
1.利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。函数返回值可以无名、有名，这个是方便理解的不全代码，有名res的话本质局部变量，因此defer后会可能会影响res的返回值。使用panic抛出错误，defer捕获错误，一般panic中抛出异常，defer中捕获异常，之后正常处理。因此传入指针等等，defer函数，有无名返回值均会影响main函数中接收到的最终return的值，请注意。
go自编自导自写一片协成池
qq_43022682的博客
04-26 99
go语言自撸协成池
Golang | Leetcode Golang题解之第46题全排列
weixin_66442839的博客
04-23 480
Golang | Leetcode Golang题解之第46题全排列
go中标签创建与引用
进化的深山猿
04-26 177
这个命令会移除不再需要的依赖，并且添加缺少的依赖，确保这两个文件反映了所有其他文件中导入的依赖。目录时，你应该将其内容纳入版本控制系统，这样其他开发者在获取项目代码时，也会得到相同版本的依赖。是 Go 项目维护的一个好习惯，它有助于保持项目依赖的清晰和管理。目录，该目录包含了项目所依赖的包的副本。文件，然后将你的项目所依赖的所有包的特定版本复制到。，你需要在你的项目目录中运行这个命令。命令会使用该目录中的依赖来构建项目，除非使用。目录，并将依赖项的源代码复制到这个目录中。0 util修改的代码提交。
Golang基础7-并发编程
m0_61973596的博客
04-25 854
Golang基础-并发编程
Golang爬虫代理接入的技术与实践
Z_suger7的博客
04-26 379
在介绍Golang爬虫代理接入之前，我们先来简要了解一下Golang爬虫的基本步骤。制定爬虫目标：明确需要爬取的网站或数据来源。制定一个爬虫接口：设计爬虫的请求接口，包括URL、请求头等信息。发出HTTP请求，获取数据：使用Golang标准库中的net/http包发送HTTP请求，获取目标网站的数据。屏蔽无效请求：处理HTTP请求返回的状态码，过滤掉无效的请求，提高爬取效率。解析数据内容：使用HTML解析库（例如goquery）解析网页内容，提取需要的数据。
20个 Golang 常见面试问题
sre救赎之路
04-26 124
Golang 提供了 encoding/json 包，使用 json.Marshal 和 json.Unmarshal 函数将 Go 类型编码为 JSON，并将 JSON 解码为 Go 类型。Golang 鼓励显式地将错误作为返回值返回，并提供了如 errors.New 和 fmt.Errorf 这样的函数来创建和格式化错误。Golang 提供了同步原语，如互斥锁（mutexes）和通道（channels），用于在并发场景中安全地访问和修改共享资源。Golang 中的反射允许在运行时检查类型、值和结构体。
Golang操作Redis
最新发布
weixin_57023347的博客
04-26 428
Redis是完全开源免费的，遵循BSD协议，是一个高性能的key-value数据库。
Golang context 原理分析
元宝不吃香菜
04-20 918
valueCtx 不适合视为存储介质，存放大量的 kv 数据，它的定位类似于请求头，只适合存放少量作用域较大的全局 meta 数据： 一个 valueCtx 实例只能存一个 kv 对，因此 n 个 kv 对会嵌套 n 个 valueCtx，造成空间浪费；在下面这个案例中，子协程的任务需要 2s 才能执行完，但是父协程 1s 后任务超时，开始执行取消任务的流程，通知子协程一并取消任务的执行。本质没有区别，都是 emptyCtx，更多的是语义上的区别，background 通常作为所有 ctx 链的最顶层。
go语言语法
05-26
以下是Go语言的一些基本语法： 1. 变量声明和赋值 Go语言中的变量声明和赋值使用关键字var和:=符号。例如： ``` var a int a = 10 b := "hello, world!" ``` 2. 控制流语句 Go语言中的控制流语句包括if、for、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值