Go语言（基础语法学习）

最新推荐文章于 2022-08-30 21:49:49 发布
最新推荐文章于 2022-08-30 21:49:49 发布
阅读量213 收藏
点赞数
文章标签： Go语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43537125/article/details/102776442
版权

Go：简单语法介绍

文章目录

学习（1）运算符

Go:运算符学习
添加新的运算符
对于++，- -也有新的要求
返回值
指针的运算规则
/------------------------------------------------------------------------------

学习（2）数组与切片

Go:切片与数组学习

数组的定义方法
切片的定义方法
数组和切片的对比及其使用

一、字符串尾部不包含NULL字符，与c/c++不一样

二、字符串是常量，可以访问字节单元但是不能修改某个字节单元的值；基于字符串创建的切片和原字符串指向相同的底层字符数组，一样不能修改

package main

import "fmt"

func main(){
	s := "Hello World"
	s[2] = 's'		//error
	a := s[:3]
	fmt.Print(s,"\n",a)
	a[2] = 's' 		//error
}

三、字符串和切片的转换

package main

import "fmt"

func main(){
	s := "Hello World"
	//字符串可以转换为字节数组，也可以转换为Unicode的字符数组
	a0 := []rune(s)			//[72 101 108 108 111 32 87 111 114 108 100]
	a1 := []byte(s)			//[72 101 108 108 111 32 87 111 114 108 100]
	fmt.Print(a0,"\n",a1)
}

四、数组初始化

	a := [3]int{1,2,3}		//初始化长度和字面量 [1 2 3]
	a := [...]int{1,2,3}	//根据输入的数据个数确定长度 [1 2 3]
	a := [3]int{1:1, 2:3}	//指定总长度，通过索引值进行初始化，未初始化的元素使用类型默认值 [0 1 3]
	a := [...]int{1:1, 2:3} //不指定总长度，通过索引值初始化，长度由最后一个索引值确定，
							//未指定索引的元素被初始化为类型的零值 [0 1 3]

数组特点：

  1. 数组创建完长度就固定了，不可以再追加元素
  2. 数组是**值类型的 **，数组赋值或作为函数参数都是值拷贝
  3. 数组的长度是数组类型的组成部分
    [10]int 和 [20]int表示不同数组
  4. 可以根据数组创建切片

五、切片初始化
切片的内部

	a := [5]int{1, 2, 3, 4, 5} //[1 2 3 4 5]
	sl := a[1:] 			   //通过数组创建；[2 3 4 5]
	
	s2 := make([]int,5)		   //使用 make创建，len == cap = 5;  [0 0 0 0 0]

	var s3 []int			   //这是无意义的; []

/------------------------------------------------------------------------------

学习（3）map与结构体

Go:map与结构体学习

一、map的定义与创建
（与切片一样，未创建的map是不能使用的）

	//根据字面量创建
	a := map[string]int{"a":1,"b":2}
	fmt.Println(a)		//map[a:1 b:2]
	fmt.Println(a["a"])	//1

	//使用 make 创建
	b := make(map[string]string)	//长度为默认值0
	b2 :=make(map[string]string,10) //长度为 10
	b3 := make(map[int]int)
	b["name"] = "Tom"				//增加元素后长度逐渐增加
	b2["name"] = "John"
	b2["sex"] = "M"
	fmt.Println(b,len(b)) 								//map[name:Tom] ,len = 1
	fmt.Println(b2["name"],b2["sex"],len(b2))			//John M ,len = 2
	fmt.Println(b3,len(b3))								//map[], len = 0

map的增、删、改、查、遍历（无序）

二、结构体的定义与创建
（与切片和map不一样，定义了的结构体即可使用其变量）

//自定义结构体类型，并初始化
package main

import (
	"fmt"
)

func main() {
	type Person struct {
		name string
		age int
		sex string		//增加字段sex
	}
	//不推荐
	a := Person{"Tom",1}	//报错，因为没有初始化sex
	fmt.Println(a)
	//推荐
	a :=&Person{
		name: "Tom",
		age:  0,	
		//未初始化的字段（sex）会被默认值初始化
	}
	fmt.Println(*a)		//{Tom 0 }
}

结构体类型转换规则
匿名属性（结构体类型的匿名属性，及其访问规则）

/------------------------------------------------------------------------------

学习（4）函数

Go:函数学习

一、函数的特点

  1. 函数可以没有输入参数，也可以没有返回值
  2. 多个相邻的相同类型的参数可以使用简写模式
    例如
func fun(a,b int,f float32){}
  1. 支持有名的返回值，最后return可以不带参数名直接返回
func fun(a,b int)(sum int){
	sum = a + b
	return //return sum 的简写形式
	------------------------------
	sum := a + b	//如果是这样，则相当于新声明一个sum变量，将返回变量sum覆盖
	return sum 		//最后要显式调用 return sum
}
  1. 不支持默认值参数
  2. 不支持函数重载
  3. 不支持函数嵌套，严格说是不支持命名函数的嵌套定义，但支持嵌套匿名函数，例如
//正确，使用了匿名函数嵌套
func add(a,b int)(sum int){
	anonymous := func(x,y int)int{
		return x + y
	}
	return anonymous(a, b)
}

//错误
func add(a,b int)(sum int){
	 func(x,y int)int{//写成func add2(x,y int)int 也是错误的
		return x + y
	}
	return anonymous(a, b)
}

二、多值返回
定义多值返回时的返回参数列表要使用“（）”包裹，并支持命名参数返回

func swap(a, b int)(int int){
	return b ,a
}

三、不定参数
特点：

  1. 所有不定参数的类型必须是相同的
  2. 不定参数必须是函数的最后一个参数
  3. 不定参数名在函数体内相当于切片，对切片的操作同样适合对不定参数的操作
  4. 切片可以作为参数传递给不定参数，切片名后要加上“…"
package main

import "fmt"

func Sum(arr...int)(sum int){
	for _,value:=range arr{	//此时arr就相当于切片，可以使用range访问
		sum += value
	}
	return sum
}
func main(){
	fmt.Println(Sum(1,2,3))	//6

	a := [...]int{1,2,3,4}
	slics := a[:]
	fmt.Println(Sum(slics...))		//10
	
	fmt.Println(Sum(a))		//error，数组不可以作为实参传递给不定参数函数中的参数
}
  1. 形参为不定参数的函数 和 形参为切片的函数类型不同
package main

import "fmt"

func suma(arr...int)(sum int){
	for _,v:=range arr{
		sum += v
	}
	return
}
func sumb(arr []int)(sum int){
	for _,v:=range arr{
		sum += v
	}
	return
}

func main(){
	//suma 和 sumb 类型并不一样
	fmt.Printf("%T\n",suma)	//func(...int) int
	fmt.Printf("%T\n",sumb)	//func([]int) int
}

四、函数签名

  1. 函数类型又叫做函数签名，一个函数的类型就是函数定义首行去掉函数名、参数名和{，可以使用fmt.Printf的%T格式化参数打印函数类型，例如上面的代码
  2. 两个函数类型相同的条件是：拥有相同的形参列表和返回值列表（列表元素的次序、个数和类型都相同），形参名可以不同，例如
//两个函数类型相同
func add(a, b int)int{return a+b}
func Sum(x int, y int)(sum int){
	sum = x+y
	return 
}
  1. 可以使用type 定义函数类型，函数类型变量可以作为函数的参数或返回值
package main

import "fmt"

func suma(arr...int)(sum int){
	for _,v:=range arr{
		sum += v
	}
	return
}
type op func(...int)int

func Hanshu(f op)int{
	return f(1,2,3)
}
func main(){
	fmt.Println(Hanshu(suma))	//6
}

五、匿名函数
匿名函数可以看作函数字面量，所有直接使用函数类型变量的地方都可以由匿名函数代替。

  1. 可以直接赋值给函数变量
package main

import (
	"fmt"
)

func main()  {
	var f = func()int{
		return 1
	}
	fmt.Printf("%T\n",f)	//func() int
	fmt.Println(f())	//1
}
  1. 可以当作实参
package main

import "fmt"

type op func(int)

func Prints(f op){
	fmt.Printf("%T",f)
}
func main(){
	Prints(func(i int) {})	//main.op
}
  1. 可以作为返回值
//典型例子斐波那契数列（使用闭包）
func Fib()func()int{
	a:=-1
	b:=1
	return func()int{
		a,b = b,a+b
		return b
	}
}
  1. 可以直接调用
package main

import "fmt"

func main(){
	fmt.Printf("%T",func(int){})	//func(int)
}

六、闭包

对象是附有行为的数据，而闭包是附有数据的行为

概念：闭包是由函数及其相关引用环境组合而成的实体，一般通过在匿名函数中引用外部函数的局部变量或包全局变量构成
闭包 = 函数 + 引用环境
如果函数返回的闭包引用了该函数的局部变量（参数或函数内部变量）：

  1. 多次调用该函数，返回的多个闭包所引用的外部变量是多个副本，原因是每次调用函数都会为局部变量分配内存
  2. 用一个闭包函数多次，如果该闭包修改了其引用的外部变量，则每次调用该闭包对该外部变量都有影响，因为闭包函数共享外部引用
  3. 如果闭包调用的是全局变量，则每次调用该闭包都会对全局变量产生影响，所以闭包引用全局变量并不是一个好的编程方式
//1.调用参数的闭包
package main

import "fmt"

func fa(n int) func() {
	n++
	return func() {		//注意，这里闭包调用的是参数n，而没有调用函数内部变量，
						//所以n++ 并不起作用，且由于闭包内未对n做处理，输出时就按原值输出
		fmt.Println(n)
	}
}
func fb(n int)func(){
	return func(){		//这里闭包调用了参数且对其做了++处理
		n++
		fmt.Println(n)
	}
}
func main(){
	a := fa(1)
	a()			//2
	a()			//2
	fmt.Println()
	b := fb(1)
	b()			//2
	b()			//3
}

//2.调用函数内部变量的闭包
package main

func Sum()func()int{
	a := 0
	f := func()int {
		a++
		return a
	}
	return f
}
func main()  {
	a0 := Sum()
	println(a0())	//1
	println(a0())	//2
}

内函数对外函数的变量的修改，是对变量的引用

引用链接：对闭包理解有帮助

对其理解--------------------------------------------------------------------/
将拥有闭包的函数称为背包；
从背包外拿东西（传入参数），在背包内处理（利用闭包处理参数），
从背包内拿东西（函数内部变量），在背包内处理（利用闭包处理内部变量）

/------------------------------------------------------------------------------

学习（5）
指针的定义和使用规则
指向切片的指针（二级指针）
指针作为返回值的规则
Go:指针学习

学习（6）
面向对象，使用
“方法”进行绑定 +
组合（在c++中的继承）+
代码首字母的大小写
----------->进行封装
继承方式及规则和c++很像只是语法不同，包括继承的函数的重写…
Go：面向对象简单学习

一、指针接受者的方法
该知识点在于绑定方法时，实参接收者和形参接收者的选择
1.

package main

import "fmt"

type S struct {
	x,y int
}
func (s S)Sum()int{		//形参接收者为 S 类型
	return s.x+s.y
}
func main(){
	fmt.Println(S{1,2}.Sum())	//实参接收者也为 S 类型
}

2.

package main

import "fmt"

type S struct {
	x,y int
}
func (s *S)Sum()int{		//形参接收者为 *S 类型
	return s.x+s.y
}
func main(){
	t := &S{1,2}
	fmt.Println(t.Sum())	//实参接收者也为 *S 类型
}

3.

package main

import "fmt"

type S struct {
	x,y int
}
func (s *S)Sum()int{		//形参接收者为 *S 类型
	return s.x+s.y
}
func main(){
	var t = S{1,2}
	fmt.Println(t.Sum())	//实参接收者为 S 类型
							//此时 t 会被隐式转换为 &t
}

4.

package main

import "fmt"

type S struct {
	x,y int
}
func (s S)Sum()int{		//形参接收者为 S 类型
	return s.x+s.y
}
func main(){
	var t = &S{1,2}
	fmt.Println(t.Sum())	//实参接收者为 *S 类型
							//此时 t 会被隐式转换为 *t
}
Go_bye
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go语言基础学习（二）
wmchr1314的博客
12-04 158
指针 与c一样，go也支持指针，指针保存了值的内存地址。 // 定义一个T类型的指针，零值为 nil var p *int // & 操作符 会生成一个指向其操作数的指针 m := 1 p = &i //指针p指向i // * 操作符 表示引用指针指向的内容（间接引用/重定向） fmt.println(*p) *p = 333 // 修改指针指向的值 var p *int v...
Go语言基础语法
Xiaobai_HuAo的博客
12-06 203
Go语言基础语法
实参和形参的区别_Go中方法接收者是指针类型和值类型的根本区别, 看这一篇就足够了
weixin_39769703的博客
11-30 225
要理解使用指针接收者和使用值接收者的根本区别只需要明确一点就够了：它们的方法名是不一样的。方法名我们拿Man和Woman两个简单的结构体举例：type 我们分别使用指针接收者和值接收者给它们添加一个Say()方法:// Say()方法的全名为(*Man).Say() 这里虽然它们都是Say()方法，但实际上方法名是不一样的，如果你使用指针接收者，方法的全名为(*Man).Say(), 如果是值类型...
Go语言-语法基础-全面
weixin_51991615的博客
10-24 5765
一.Go基础 1.1. init函数 go语言中init函数用于包(package)的初始化，该函数是go语言的一个重要特性。 有下面的特征： 1 init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等 ​ 2 每个包可以拥有多个init函数 ​ 3 包的每个源文件也可以拥有多个init函数 ​ 4 同一个包中多个init函数的执行顺序go语言没有明确的定义(说明) ​ 5 不同包的init函数按照包导入的依赖关系决定该初始化...
go学习（一、基础语法）
酱油师兄的博客
06-18 1146
这一篇把go的基础语法学习了一遍，跟其他语言是有点差别，不过也不算大。
【Go语言入门教程】Go语言基本语法
热门推荐
qq_41854911的博客
02-08 1万+
文章目录Go语言变量的声明（使用var关键字）标准格式批量格式简短格式Go语言变量的初始化回顾C语言变量初始化的标准格式编译器推导类型的格式短变量声明并初始化Go语言多个变量同时赋值Go语言匿名变量（没有名字的变量）Go语言变量的作用域局部变量全局变量形式参数Go语言整型（整数类型）哪些情况下使用 int 和 uintGo语言浮点类型（小数类型）Go语言复数Go语言输出正弦函数（Sin）图像设置图片背景色绘制正弦函数轨迹写入图片文件Go语言bool类型（布尔类型）Go语言字符串定义字符串字符串拼接符“+”字
go语言基础语法示例
09-21
Go语言，也称为Golang，是由Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程语言。它的设计目标是提高程序的简洁性、可读性和可维护性，同时也注重性能和效率。Go语言的基础语法简洁而强大，...
Go语言学习笔记.pdf 共174页
04-11
Go语言学习笔记.pdf 共174页 Go语言学习笔记.pdf 共174页是一本关于Go语言的详细学习笔记，涵盖了Go语言的基础知识、函数、数组、Maps、Structs、接口、并发、程序结构、标准库等方面的内容。本笔记共分为三大部分...
Go 语言基础语法
01-03
Go 语言基础语法 上一章节我们已经了解了 Go 语言的基本组成结构，本章节我们将学习 Go 语言的基础语法。 Go 标记 Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个...
go语言基础语法代码整合
03-22
本资源"Go语言基础语法代码整合"是针对初学者或对Go语言无基础的开发者准备的一个学习材料，它通过一系列独立的Go代码文件，详细展示了Go语言的核心语法。 在Go语言中，语法简洁明了，易于理解和学习。以下是一些...
Go语言基础学习教程
09-21
本教程将详细介绍Go语言的基础知识，包括基本语法、语句和数据结构，帮助初学者快速入门。 首先，我们来看Go语言的文件目录结构。Go有一个特殊的布局，它规定了项目中的bin、pkg和src三个子文件夹。src文件夹下存放...
Go语言基础语法（快速学习）
weixin_44801254的博客
07-09 723
Go语言知识分享 文章目录Go语言知识分享前言Go语言定义适用范围一、基础语法1.1 变量、常量、nil与零值、方法、包、可见性、指针1.1.1 变量声明1.1.2 常量声明1.1.3 nil与零值1.1.4 方法、包Go中方法的定义多个返回值变长参数包与可见性1.1.5 指针1.2 条件、循环、分支1.2.1 条件1.2.2 循环1.2.3 分支1.3 数组、切片、字典1.3.1 数组1.3.2 切片长度、容量创建切片动态操作切片切片的常用场景1.3.3 字典字典的声明与初始化字典的使用场景二、面向对象编
Go语言学习——基本语法
buzaibeishang的专栏
08-30 441
Go语言基础
go基本语法
火山锅锅的博客
07-12 1997
关键字 go实例 new与make的区别 变参 面向对象 继承 方法重写 interface 函数作为值，类型 并发 gorutine channel Buffered Channels select 超时管理 处理goroutine的方法 总体笔记 关键字 defer 延迟（defer）语句，可以在函数中添加多个defer语句。 当函数执行到最后时，这些...
Go语言 基础语法学习 (未完待更......
weixin_48433164的博客
12-14 424
文章目录一 Go语言结构1 Go Hello world实例2 执行Go程序二 Go语言基础语法1 Go标记2 行分隔符3 注释4 标识符5 一些关键字6 Go语言的空格7 格式化字符串Go语言数据类型Go语言变量Go语言常量Go语言运算符Go语言条件语句Go语言循环语句Go语言函数Go语言变量作用域Go语言数组Go语言指针Go语言结构体Go语言切片SliceGo语言范围RangeGo语言MapGo语言递归函数Go语言类型转换Go语言接口Go 语言错误处理Go 语言并发Go语言开发工具 一 Go语言结构 1
Go语言实现并行分段求和计算
weixin_33918114的博客
08-03 532
这个实例通过循环实现并行的分段求和计算，再把各个子段和加到总和中。 通过这个实例可以了解如何实现循环并行处理，以及有关的编程技巧。 但是这个程序是有问题的，因为可能发生变量访问冲突问题，导致计算结果不正确。这个程序是不稳定的，有时能够计算出不正确的结果，有时能够计算出正确结果。 程序中的变量sum是共享变量，需要使用同步用的互斥锁来保证计算的正确性。正解程序附...
Go语言-基础语法
somia的博客
02-07 425
Go语言基础语法 包含了hello world，基本类型，变量声明，分支结构，循环结构，最简单的web服务器搭建等基础语法。与其他语言对照，浅显易懂。
html css js网页设计
最新发布
07-12
HTML、CSS和JavaScript是构建网页和网站的基本技术，它们共同工作来创建和设计用户界面。下面是关于这三种技术的详细介绍： ### HTML (HyperText Markup Language) - **定义**：HTML是构建网页内容的标准标记语言。 - **作用**：用于创建网页的结构和内容，如段落、链接、图片、表格等。 - **语法**：使用标签（如 `<p>`, `<div>`, `<a>`, `<img>` 等）来定义网页元素。 ### CSS (Cascading Style Sheets) - **定义**：CSS是一种样式表语言，用于描述HTML文档的呈现方式。 - **作用**：用于设置网页的布局、颜色、字体和其他视觉元素。 - **语法**：通过选择器（如 `p`, `.myclass`, `#myid` 等）应用样式规则。 ### JavaScript - **定义**：JavaScript是一种脚本语言，通常用于网页上实现交互功能。 - **作用**：允许网页与用户进行交互，如响应用户操作、动态更新内容、动画效果等。 - **语法**：Java

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值