回顾go语言基础中一些特别的概念

本文涉及的产品
服务治理 MSE Sentinel/OpenSergo,Agent数量 不受限
云原生网关 MSE Higress,422元/月
容器镜像服务 ACR,镜像仓库100个 不限时长
简介: 【7月更文挑战第6天】本文介绍Go语言基础涵盖包声明、导入、函数、变量、语句和表达式以及注释。零值可用类型如切片、互斥锁和缓冲,支持预分配容量以优化性能。

基础简介

go语言基础包括如下几个部分

包声明
引入包
函数
变量
语句 & 表达式
注释

go程序始于package mainmain函数是执行入口,fmt.Println用于输出。Go有25个关键字和36个预定义标识符。
go语言特点包括接口的水平和垂直组合,隐式接口,内存零值初始化。挑战涉及包管理、泛型、错误处理等。
推荐遵循idiomatic Go的项目结构,利用go.mod管理依赖。
错误处理通过if err != nil检查,panicrecover用于异常控制。

Toroid托瑞德符号.png

1,基本结构说明

首先定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包。

  package main     

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

  import "fmt"

执行入口,func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的,一般来说都是在启动后第一个执行的函数(如果有 init() 函数则会先执行该函数)。

func main() {
   /* 第一个程序 */
   fmt.Println("Hello, World!")
}

其中, /.../ 是注释,在程序执行时将被忽略。单行注释是最常见的注释形式,在程序执行时一般将被忽略。

实际程序只有一个打印输出到控制台。 fmt.Println(...) 可以将字符串输出到控制台,并在最后自动增加换行字符 \n。

执行。 如果您已经安装go语言程序,那么打开 cmd(windows平台) 或 shell(linux平台),新建并保存以上代码到hello.go 文件

  $ go run hello.go
  Hello, World!

也可以编译后,执行

$ go build hello.go 
$ dir // 或者在linux执行 ls
  hello    hello.go
$ ./hello 
  Hello, World!

2 标识符和关键字。

golang默认有25个关键字

  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

golang 默认有36个预定义标识符

  append    bool    byte    cap    close    complex    complex64    complex128    uint16
  copy    false    float32    float64    imag    int    int8    int16    uint32
  int32    int64    iota    len    make    new    nil    panic    uint64
  print    println    real    recover    string    true    uint    uint8    uintptr

程序一般由关键字、常量、变量、运算符、类型和函数组成。

程序中可能会使用到这些分隔符:括号 (),中括号 [] 和大括号 {}。

程序中可能会使用到这些标点符号:.、,、;、: 和 …

  • 并且没有解析符号表。
  • const 常量是数字,首字母大小决定结构体属性的可见性。
  • 没有子类型继承。
  • 隐式的接口,implements 声明
  • 内存总是初始化零值

3 go1规范和使用挑战中的概念

  • go1 规范:

      interface 水平组合, 满足依赖抽象,里氏替换,接口隔离
    
      type embedding 垂直组合, 通过方法名 匹配和调用函数。
        通过 例程 goroutine + channel 组合实现类似 unix pipe 的功能。
    

    并发有关代码结构。
    并行有关执行的结构。

    解决了性能问题,单靠cpu主频提高以提高性能不总是有效的。
    大型程序中,操作系统调度切换线程代价不小。
    所谓自带电池是指,内建的标准库丰富。

    • 使用go的挑战

      1 包管理
      2 相似的语言特征
      3 泛型支持
      4 客户端GUI支持
      5 错误处理
      6 调试和库支持
      

4 go的标准项目结构

  原生编程思维 --->  idiomatic go   内建工具链,go语言语法
                                   标准库
                                   三方库、工具

  项目结构,go 风格  --->  api 
                          lib
                          src  -->  cmd  ---> cgo, gc,gofmt,yacc ...
                                    pkg  --->  fmt/, go/, io/, math/, syscall/,unsafe/,...
                                    vandor...

  go项目推荐 module-ware风格 ---> go.mod
                                 go.num
                                 lib.go
                                 lib1
                                 lib2

缓存失效和命名的问题

  命名:  --->  var 变量声明聚类,同类型的相同前后缀
           const 常量命名,整合了c的风格  --->  宏定义常量, 枚举常量
                                              const 只读变量,为类型安全的。

无类型常量

      const  SearchStart = 1

有类型常量

      const  SearchEnd int  = 10

枚举类型 iota是 Go的一个预定义标识符,它表示const 声明块,包括单行声明的每个常量所处位置在块中的偏移量(从0开始)。

5 零值可用类型

某些数据类型可以支持零值可用,但是功能受限

* 切片   零值切片可添加元素,但是不能使用下标。

* 互斥锁和池 sync.Mutex  sync.Pool   

  有大并发需求的创建,使用读写锁。 RWMutex

* io 缓冲  bytes.Buffer  避免值复制错误

创建切片的cap参数

 St := make([]int, 0)
 size := 10
 Se := make([]int, 0, size)

使用cap容量规定切片最大有多少元素,可以预知切片最大容量,提高 40%的性能。

函数的可变参数, 如下 Call函数有可变参数类型,在函数最后可以使用,不传或传多个。

 func Call(name, ...String) {...}

6 错误处理

 1 构造错误值对象  fmt.Errorf(...), errors.New(...)
 2 透明错误处理,实现低耦合   if err != nil {...}   
 3 哨兵处理方式    

    if err != nil {
      switch err.Error() {
      case "bufio:negative...":
      ...
      case ....
    }
    }
  • 错误类型检视

         switch err := err.(type) {
         case * unmarshal.TypeError{
         ...
       }
       }
    
  • 错误行为检查

      将错误封装到结构体
    
          type OpError struct {
            ...
            err error
          }
    
          type temp interface {
            Temp() 
          }
    
      func (eop *OpError) Temp() bool {
        if ne, ok := eop.Err.(* os.Syscall.Error); ok {
        t, ok := ne.Err.(temp)
        return ok && t.Temp
      }
      }
    
  • panic 恐慌的使用场景

         1 充当断言
         2 简化错误处理
         3 recover 捕获 panic, 防止协程退出
         由于在go中,多例程时,无论哪个例程退出,整个go程序都将失败。
    
         panic 常常都被用于程序栈跟踪。
    
目录
相关文章
|
20天前
|
Java 编译器 Go
【Golang】(1)Go的运行流程步骤与包的概念
初次上手Go语言!先来了解它的运行流程吧! 在Go中对包的概念又有怎样不同的见解呢?
62 4
|
20天前
|
存储 安全 Java
【Golang】(4)Go里面的指针如何?函数与方法怎么不一样?带你了解Go不同于其他高级语言的语法
结构体可以存储一组不同类型的数据,是一种符合类型。Go抛弃了类与继承,同时也抛弃了构造方法,刻意弱化了面向对象的功能,Go并非是一个传统OOP的语言,但是Go依旧有着OOP的影子,通过结构体和方法也可以模拟出一个类。
73 1
|
2月前
|
Cloud Native 安全 Java
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
258 1
|
2月前
|
Cloud Native Go API
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
302 0
|
2月前
|
Cloud Native Java Go
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
205 0
|
2月前
|
Cloud Native Java 中间件
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
171 0
|
2月前
|
Cloud Native Java Go
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
267 0
|
2月前
|
数据采集 Go API
Go语言实战案例:多协程并发下载网页内容
本文是《Go语言100个实战案例 · 网络与并发篇》第6篇,讲解如何使用 Goroutine 和 Channel 实现多协程并发抓取网页内容,提升网络请求效率。通过实战掌握高并发编程技巧,构建爬虫、内容聚合器等工具,涵盖 WaitGroup、超时控制、错误处理等核心知识点。
|
2月前
|
数据采集 JSON Go
Go语言实战案例:实现HTTP客户端请求并解析响应
本文是 Go 网络与并发实战系列的第 2 篇,详细介绍如何使用 Go 构建 HTTP 客户端,涵盖请求发送、响应解析、错误处理、Header 与 Body 提取等流程,并通过实战代码演示如何并发请求多个 URL,适合希望掌握 Go 网络编程基础的开发者。
|
3月前
|
JSON 前端开发 Go
Go语言实战:创建一个简单的 HTTP 服务器
本篇是《Go语言101实战》系列之一,讲解如何使用Go构建基础HTTP服务器。涵盖Go语言并发优势、HTTP服务搭建、路由处理、日志记录及测试方法,助你掌握高性能Web服务开发核心技能。