首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >golang基础(一)

golang基础(一)

作者头像
阿dai学长
发布于 2020-03-31 03:07:23
发布于 2020-03-31 03:07:23
52600
代码可运行
举报
文章被收录于专栏:阿dai_linux阿dai_linux
运行总次数:0
代码可运行

Go编程结构

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 当前程序的包名
package main

// 导入其他的包
// import "fmt"

// 导入其他的包,并设置别名
import std "fmt"

// 定义常量
const PI  = 3.14

// 全局变量的声明与赋值
var name  = "gopher"

// 一般类型声明:为类型设置别名
type newType int

// 结构的声明
type gopher string{}

// 接口的声明
type golang interface {}

// 由 main 函数作为程序入口点启动
func main() {
   std.Println("Hello world!")
}

Tips:

  • go程序中导入的包如果在程序中未使用,程序会报错,即不能 import 不使用的包;
  • go中可以使用 . 作为包的别名,不过,尽量不要使用,避免降低代码可读性;
  • go中的 privatepublic 是通过大小写来实现的,以大写字母开头的变量、函数等是public型,以小写字母开头的是private型

数据类型与变量

类型和变量都能批量声明,变量组只能用于全局变量声明,不能在函数体重使用。

数据类型

  • 布尔型:bool
  • 整型:int/uint
  • 8位整型:int8/uint8
  • 字节型:byte(unit8别名)
  • 16位整型:int16/uint16
  • 32位整型:int32/uint32
  • 64位整型:int64/uint64
  • 浮点型:float32/float64
  • 复数:complex64/complex128
  • 其他值类型:
    • array、struct、string
  • 引用类型:
    • slice、map、chan
  • 接口类型:interface
  • 函数类型:func

变量

单个变量的声明与赋值

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 变量的声明
var a int

// 变量的赋值
a = 123

// 声明的同时赋值
var a int = 123

多个变量的声明与赋值

  • 全局变量的声明不可以省略 var ,但可以用并行方式
  • 全局变量的声明可以使用 var() 的方式进行简写
  • 局部变量不可以使用 var() 的方式简写,只能使用并行方式
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 多个变量的声明
var a, b, c int

// 多个变量的复制
a, b, c, = 111, 222,333

// 多个变量声明的同时赋值
var d, e, f int = 444, 555, 666

// 省略变量类型,由系统推断
var i, j, k = 777, 888, 999

// 多个变量声明与赋值的最简写法
m, n, o := 1, 2, 3

var (
	// 使用常规方式
	aaa = "hello"
	// 使用并行方式
	sss, bbb = 1, 2
)

// 函数体内只能使用并行方式声明多个变量
func main() {
	var x, y, z int = 444, 555, 666
  // var aa, _, bb, cc = 11, 22, 33, 44  // _ 为空白符号,即忽略对应位置的值
}

类型转换

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 只能在相互兼容的类型之间转换
func main() {
   var a float32 = 1.1
   b := int(a)
   fmt.Println(a)
   fmt.Println(b)
}

练习:计算机存储单位的枚举

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
const (
   B float64 = 1 << (iota * 10)
   KB
   MB
   GB
   TB
   PB
)

func main() {
   fmt.Println(B)
   fmt.Println(KB)
   fmt.Println(MB)
   fmt.Println(GB)
   fmt.Println(TB)
   fmt.Println(PB)
}

补充内容

go保留了指针,但不支持指针运算以及 -> 运算符,而直接采用 . 选择符来操作指针目标对象的成员。

  • 操作符 & 取变量地址,使用 * 通过指针间接访问目标对象
  • 默认值为 nil,而非 NULL

go语言中(递增、递减),++-- 是作为语句而并不是作为表达式(即,只能作为单独的语句存在)。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 指针
func main() {
	a := 1
	var p *int = &a  // 指针 p 指向变量 a 的地址
	fmt.Println(p)  // 打印指针
	fmt.Println(*p)  // 打印指针对应的目标对象
}

// ++ 和 --
func main() {
	// a := a++  // 不允许这样
	a := 1
	a++
	var p *int = &a
	fmt.Println(p)
	fmt.Println(*p)
}

go控制语句

判断语句 if

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
func main() {
   a := 10
   if a, b := 1, 3; a > 0 {
      fmt.Println(a)
      fmt.Println(b)
   }
   fmt.Println(a)
}

循环语句 for

go语言中只有 for 循环。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 普通 for 循环
func main() {
   a := 1
   for {
      a++
      if a > 3 {
         break
      }
      fmt.Println(a)

   }
   fmt.Println("Over!")
}

// for 循环本身带条件
func main() {
	a := 1
	for a <= 3 {
		a++
		fmt.Println(a)
	}
	fmt.Println("Over!")
}

// 经典用法:计数器(i)
func main() {
	a := 1
	for i := 0; i <= 3; i++ {
		a++
		fmt.Println(a)
	}
	fmt.Println("Over!")
}

选择语句 switch

默认满足某个 case 后自动 break,如果想继续执行后面的 case,需要使用 fallthrough 语句。

类似 python 中的 if...elif...else...

switch 中有变量 swithc a {},则case中默认使用该变量创建表达式( case 0: );如果switch中没有变量 switch {},则需要在case中使用变量创建表达式(case a==0:)。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 普通用法
func main() {
   a := 1
   switch a {
   case 0:
      fmt.Println("a=0")
   case 1:
      fmt.Println("a=1")
   default:
      fmt.Println("None")
   }
}

// fallthrough
func main() {
	a := 1
	switch {
	case a <= 0:
		fmt.Println("a=0")
	case a >= 1:
		fmt.Println("a=1")
		fallthrough
	default:
		fmt.Println("None")
	}
}

// 带一个初始化语句
func main() {
	switch a := 1; {
	case a >= 10:
		fmt.Println("a=0")
	case a >= 1:
		fmt.Println("a=1")
		fallthrough
	default:
		fmt.Println("None")
	}
}

跳转语句 goto,break,continue 和 标签

跳转语句都可以配合标签使用。标签区分大小写。

goto用于调整执行位置;break和continue配合标签可以跳出多层循环。

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 跳出 LABEL1 循环
func main() {
LABEL1:
   for {
      for i := 0; i < 10; i++ {
         if i > 3 {
            break LABEL1
         }
         fmt.Println(i)
      }
   }
   fmt.Println("Over")
}

// continue 本身可以是一个无限循环;但是 continue 对应的标签必须有限循环,不然会造成死循环;
func main() {
LABEL1:
	for i := 0; i < 10; i++ { // 有限循环,即 LABEL1 对应有限循环
		fmt.Println(i)
		for {  // 无限循环
			continue LABEL1 // 有限循环标签
			fmt.Println("???")
		}
	}
	fmt.Println("Over")
}

练习:for + switch + if

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
func main() {
   a := 1
   for {
      switch {
      case a <= 5:
         fmt.Println("a=", a)
      case a > 5 && a <= 10:
         fmt.Println("a=", a)
         fallthrough
      default:
         fmt.Println("None")
      }
      a++
      if a > 10 {
         fmt.Println("Over...", "a=", a)
         break
      }
   }
}

Tips: goto 结合标签使用的时候,标签放在 goto 语句的后面,避免造成死循环。

数组:array

  • 定义数组格式:var <varName> [n]<type>n>=0
  • 数组之间可以用 ==!= 比较,但是不可以使用 <>
  • 可以使用new来创建数组,此方法返回一个指向数组的指针,但是可以通过指针对数组进行操作
  • 如果不值得数组的长度,可以使用 [...] 来让系统自动计算数组长度(注意:该方法只能用于顶级数组)
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 普通
func main() {
	var a [2]int
  fmt.Println(a)
	a[0] = 5
	a[1] = 6
	fmt.Println(a)
}

// 最简方式
func main() {
	a := [2]int{7, 8}
	fmt.Println(a)
}

// 为数组的某一位赋值
func main() {
	a := [2]int{7, 8}
	fmt.Println(a)
	b := [10]int{5: 5}
	fmt.Println(b)
}

// 数组间的比较
func main() {
	a := [2]int{1, 2}
	b := [2]int{1, 2}
	fmt.Println("a=", a)
	fmt.Println("b=", b)
	fmt.Println(a == b)
	fmt.Println(a != b)
}

// 使用new方法创建数组
func main() {
	a := [10]int{}
	a[1] = 2
	fmt.Println(a)

	p := new([10]int)
	p[1] = 2  // 通过指针对数组中单个元素进行操作
	fmt.Println(p)
}

指向数组的指针 和 指针数组

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
func main() {
   a := [10]int{9, 1}
   var p *[10]int = &a // 指向数组的指针
   fmt.Println(p)

   x, y := 1, 2
   b := [...]*int{&x, &y} // 指针数组
   fmt.Println(b)
}

在go语言中数组是值类型。

多维数组:数组中嵌套数组

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
func main() {
   a := [2][3]int{ // 含义是:数组a包含2个元素,每个元素为长度为3的int型数组
      {1, 1, 1},
      {2, 2, 2}}

   fmt.Println(a)
}

go语言实现冒泡排序

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
func main() {
   a := [...]int{5, 3, 6, 7, 9}
   fmt.Println(a)

   num := len(a)
   for i := 0; i < num; i++ {
      for j := i + 1; j < num; j++ {
         if a[i] < a[j] {
            temp := a[i]
            a[i] = a[j]
            a[j] = temp
         }
      }
   }
   fmt.Println(a)
}

切片:slice

  • 切片本身不是数组,它指向的是一个数组
  • 一般使用 make() 创建
  • 用于切片的两个函数:
    • len():获取切片长度
    • cap():获取切片容量
  • 如果多个切片(slice)指向相同底层数组,其中一个值的改变会影响全部
  • 创建切片的格式:make([]Type, len, cap)
    • len:表示切片当前实际长度
    • cap:容量,表示当前切片超出len后的最大容量,用于预分配资源(提升效率)
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// 
func main() {
	var s1 []int // 声明slice,结果为一个空的slice
	fmt.Println(s1)

	a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
  s2 := a[0:5] // 从已有数组中取值
	fmt.Println(s2)
	s3 := a[5:]
	fmt.Println(s3)
}

// make中的 len 和 cap
func main() {
	s1 := make([]int, 5, 10)
	fmt.Println(s1)
	fmt.Println(len(s1), cap(s1))
}

reslice:从一个slice中获取新的slice

  • reslice时索引以被slice的切片为准
  • 索引不可超过被slice的切片的容量cap()值
  • 索引越界不会导致底层数组重新分配,而是引发错误

slice与底层数组的对应关系:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
func main() {
   a := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'}
   fmt.Println("================= aa ===================")
   fmt.Println("a=", string(a))
   fmt.Println("len(a)=", len(a), "cap(a)=", cap(a))
   fmt.Println("================= sa ===================")
   sa := a[2:5]
   fmt.Println("sa=", string(sa))
   fmt.Println("len(sa)=", len(sa), "cap(sa)=", cap(sa))
   fmt.Println("================= sb ===================")
   sb := sa[3:5]
   fmt.Println("sb=", string(sb))
   fmt.Println("len(sb)=", len(sb), "cap(sb)=", cap(sb))
}

append

  • 可以在slice尾部追加元素
  • 可以将一个slice追加到另一个slice的尾部
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
func main() {
	s1 := make([]int, 3, 6)
	fmt.Printf("%p %v\n", s1, s1)
	s1 = append(s1, 1, 2, 3)  // 未超出原始slice容量时,内存地址不变
	fmt.Printf("%p %v\n", s1, s1)
	s1 = append(s1, 1, 2, 3)  // 超出原始slice容量时,会重新分配内存地址
	fmt.Printf("%p %v\n", s1, s1)
}


func main() {
	a := []int{1, 2, 3, 4, 5}
	s1 := a[2:5]
	s2 := a[1:3]
	fmt.Println(s1, s2) // 此时 s1,s2 共用 a[2]
	s1[0] = 9           // 多个切片(slice)指向相同底层数组,其中一个值的改变会影响全部
	fmt.Println(s1, s2)
	fmt.Println(a)
	s2 = append(s2, 1, 2, 3, 4, 5, 6, 7)
	s1[0] = 10
	fmt.Println(s1, s2) // 超出原始切片(s1)容量的部分不受影响,因为超出原始切片容量后,已分配新的内存地址
	fmt.Println(a)
}

copy

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
// copy时,以短的slice中元素长度为准进行copy
func main() {
   s1 := []int{1, 2, 3, 4, 5, 6}
   s2 := []int{7, 8, 9}
   fmt.Println(s1, s2)
   copy(s1, s2)
   fmt.Println("new:: ", s1, s2)

   s3 := []int{1, 2, 3, 4, 5, 6}
   s4 := []int{7, 8, 9}
   fmt.Println(s3, s4)
   copy(s4, s3)
   fmt.Println("new:: ", s3, s4)
}

// 拷贝到目标切片的指定位置
func main() {
	s1 := []int{1, 2, 3, 4, 5, 6}
	s2 := []int{7, 8, 9}
	fmt.Println(s1, s2)
	copy(s1[2:5], s2) 
	fmt.Println("new:: ", s1, s2)
}
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
编辑精选文章
换一批
golang 学习笔记
go语言完整的定义的变量的方法为 var 变量名 类型=值,var name string ="fuwei",可以简写为name:="fuwei"(这种只能在函数内使用,无法再包内使用),
付威
2021/05/06
1.1K0
golang学习笔记之一 - 基础知识与概念
go中字符称为rune,等价于C中的char,可直接与整数转换。rune实际是整型,必需先将其转换为string才能打印出来,否则打印出来的是一个ascii整数
躺平程序员老修
2023/09/05
2720
GO语言基础
golang可执行程序, package main,并且有且只有一个main入口函数
用户9645905
2023/10/27
2860
GO语言基础
A Bite of GoLang(上)
A bite of GoLang(浅尝GoLang),本文只是Go语言的冰山一角,本文包含作者学习Go语言期间积累的一些小的经验,同时为了方便让读者了解到Go语言中的一些概念,文中包含了许多快速简洁的例子,读者后期可以去自行拓展。当然写这篇文章的灵感来源于GitHub上的 a bite of Python
盛国存
2018/05/14
1.2K4
A Bite of GoLang(上)
Go 从入门到精通(三)字符串,时间,流程控制,函数
coders
2018/01/04
7000
Golang 新手可能会踩的 50 个坑【转】
译文:https://github.com/wuYin/blog/blob/master/50-shades-of-golang-traps-gotchas-mistakes.md
landv
2018/11/23
2.1K0
Golang 学习笔记-2:控制流
val 始终为集合中对应索引的值拷贝,因此它一般只具有只读性质,对它所做的任何修改都不会影响到集合中原有的值(译者注:如果 val 为指针,则会产生指针的拷贝,依旧可以修改集合中的原值一个字符串是 Unicode 编码的字符(或称之为 rune)集合,因此您也可以用它迭代字符串
goodspeed
2020/12/22
4130
​Golang切片(Slice)
举个例子,现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7},切片s1 := a[:5],相应示意图如下。
PayneWu
2020/12/18
8810
​Golang切片(Slice)
Golang之旅7-切片slice
切片的本质就是对底层数组的封装,它包含了三个信息:底层数组的指针、切片的长度(len)和切片的容量(cap)。
皮大大
2021/03/02
2350
go 学习笔记之数组还是切片都没什么不一样
上篇文章中详细介绍了 Go 的基础语言,指出了 Go 和其他主流的编程语言的差异性,比较侧重于语法细节,相信只要稍加记忆就能轻松从已有的编程语言切换到 Go 语言的编程习惯中,尽管这种切换可能并不是特别顺畅,但多加练习尤其是多多试错,总是可以慢慢感受 Go 语言之美!
雪之梦技术驿站
2019/08/18
4360
​go语言的31个坑
在其他大多数语言中,{的位置你自行决定。Go比较特别,遵守分号注入规则(automatic semicolon injection):编译器会在每行代码尾部特定分隔符后加;来分隔多条语句,比如会在 )后加分号:
阿兵云原生
2023/02/16
8240
Golang切片与实现原理
array是切片用来存储数据的底层数组的指针,len为切片中元素的数量,cap为切片的容量即数组的长度
Orlion
2024/09/02
1120
Golang切片与实现原理
GO基础知识分享
空白标识符 _ 也被用于抛弃值,如值 5 在 _, b = 5, 7 中被抛弃。
阿兵云原生
2023/02/16
4070
Go语言基础速刷手册
这个“不务正业”的阿巩,今天冒着现学现卖的风险来和大家分享Go了,作为既具备C的理念又有Python 姿态的语言,怎么能不来试上一试呢!
才浅Coding攻略
2022/12/12
9350
3.Go编程快速入门学习
比如:var a [5]int, 数组的长度必须是常量,并且长度是数组类型的一部分。一旦定义,长度不能变。注意: [5]int和[10]int是不同的类型。
全栈工程师修炼指南
2022/09/29
4240
3.Go编程快速入门学习
100天精通Golang(基础入门篇)——第11天:深入解析Go语言中的切片(Slice)及常用函数应用
本文是《100天精通Golang(基础入门篇)——第11天:切片(Slice)》,将详细介绍切片的概念、语法、修改、以及len()、cap()、append()和copy()函数的使用。读者将通过学习本文深入了解Golang中切片的使用方法和常用函数的功能。
猫头虎
2024/04/08
2170
100天精通Golang(基础入门篇)——第11天:深入解析Go语言中的切片(Slice)及常用函数应用
Golang数据类型之切片
Go中的切片slice依赖于数组,它的底层就是数组,所以数组具有的优点,slice都有。 且slice支持可以通过append向slice中追加元素,长度不够时会动态扩展,通过再次slice切片,可以得到得到更小的slice结构,可以迭代、遍历等
仙人技术
2021/08/31
4270
Golang数据类型之切片
Golang的slice
今天来说个简单的,也不简单的东西,那就是切片。slice对于golang来说那真的是一个非常常用的东西了,很多地方都会用到它,今天就来说说,slice底层是如何实现的,又有哪些坑是需要提前注意的。
LinkinStar
2022/09/01
4400
【Go】深入剖析slice和array
array 和 slice 看似相似,却有着极大的不同,但他们之间还有着千次万缕的联系 slice 是引用类型、是 array 的引用,相当于动态数组, 这些都是 slice 的特性,但是 slice 底层如何表现,内存中是如何分配的,特别是在程序中大量使用 slice 的情况下,怎样可以高效使用 slice? 今天借助 Go 的 unsafe 包来探索 array 和 slice 的各种奥妙。
thinkeridea
2019/11/04
5070
【Go】深入剖析slice和array
Go语言——复合类型
二维数组表示一个数组变量中每个元素又是一个一维数组变量,跟java一样 声明二维数组:
传说之下的花儿
2023/04/16
4470
相关推荐
golang 学习笔记
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档