前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
工具
TVP
最新优惠活动
文章/答案/技术大牛
发布
首页
学习
活动
专区
工具
TVP最新优惠活动
返回腾讯云官网
社区首页 >专栏 >golang基础（一）

golang基础（一）

作者头像
阿dai学长
发布于 2020-03-31 11:07:23
5030
发布于 2020-03-31 11:07:23
举报
文章被收录于专栏：阿dai_linux

Go编程结构

代码语言：javascript
复制
// 当前程序的包名
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中的 private 和 public 是通过大小写来实现的，以大写字母开头的变量、函数等是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
复制
// 变量的声明
var a int

// 变量的赋值
a = 123

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

多个变量的声明与赋值

  • 全局变量的声明不可以省略 var ，但可以用并行方式
  • 全局变量的声明可以使用 var() 的方式进行简写
  • 局部变量不可以使用 var() 的方式简写，只能使用并行方式
代码语言：javascript
复制
// 多个变量的声明
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
复制
// 只能在相互兼容的类型之间转换
func main() {
   var a float32 = 1.1
   b := int(a)
   fmt.Println(a)
   fmt.Println(b)
}

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

代码语言：javascript
复制
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
复制
// 指针
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
复制
func main() {
   a := 10
   if a, b := 1, 3; a > 0 {
      fmt.Println(a)
      fmt.Println(b)
   }
   fmt.Println(a)
}

循环语句 for

go语言中只有 for 循环。

代码语言：javascript
复制
// 普通 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
复制
// 普通用法
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
复制
// 跳出 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
复制
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
复制
// 普通
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
复制
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
复制
func main() {
   a := [2][3]int{ // 含义是：数组a包含2个元素，每个元素为长度为3的int型数组
      {1, 1, 1},
      {2, 2, 2}}

   fmt.Println(a)
}

go语言实现冒泡排序

代码语言：javascript
复制
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
复制
// 
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
复制
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
复制
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
复制
// 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 删除
go
编程算法

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

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

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

go
编程算法
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
LV.
文章
0
获赞
0
目录
  • 数据类型与变量
    • 数据类型
      • 变量
        • 单个变量的声明与赋值
          • 多个变量的声明与赋值
            • 类型转换
              • 练习：计算机存储单位的枚举
                • 补充内容
                  • go控制语句
                    • 判断语句 if
                      • 循环语句 for
                        • 选择语句 switch
                          • 跳转语句 goto，break，continue 和 标签
                            • 练习：for + switch + if
                              • 数组：array
                                • 指向数组的指针 和 指针数组
                                  • 多维数组：数组中嵌套数组
                                    • go语言实现冒泡排序
                                      • 切片：slice
                                        • reslice：从一个slice中获取新的slice
                                          • append
                                            • copy
                                            领券

                                            腾讯云开发者

                                            扫码关注腾讯云开发者

                                            扫码关注腾讯云开发者

                                            领取腾讯云代金券

                                            热门产品

                                            热门推荐

                                            更多推荐

                                            Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

                                            深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

                                            腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

                                            问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

                                            Copyright © 2013 - 2024 Tencent Cloud.

                                            All Rights Reserved. 腾讯云 版权所有

                                            登录 后参与评论