Go语言基础

最新推荐文章于 2024-06-14 05:44:12 发布
最新推荐文章于 2024-06-14 05:44:12 发布
阅读量81 收藏
点赞数
分类专栏： go 文章标签： golang go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxyxxwindows/article/details/126998717
版权

Go语言基础

1.1 变量的定义

package main

import "fmt"

var (
	aa = 2
	ss = "kkk"
	bb = true
)

func variableZeroValue() {
	var a int
	var s string
	fmt.Println("%d %q\n", a, s)
}

func variableInitialValue() {
	var a, b int = 3, 4
	var s string = "abc"
	fmt.Println(a, b, s)
}

func variableTypeDeduction() {
	var a, b, c, s = 3, 4, true, "def"
	fmt.Println(a, b, c, s)
}

func variableShorter() {
	a, b, c, s := 3, 4, true, "def"
	b = 5
	fmt.Println(a, b, c, s)
}
func main() {
	fmt.Println("hello world")
	variableZeroValue()
	variableInitialValue()
	variableTypeDeduction()
	variableShorter()
	fmt.Println(aa, ss, bb)

}

1.1.1 使用var关键字

var a,b,c bool
var s1,s2 string = "hello", "world"

可放在函数内，或直接放在包内

可以使用var（）集中定义变量

1.1.2让编译器自动决定类型

var a,b,i,s1,s2 = true, false,3,“hello”, “world”

1.1.3使用：=定义变量

a,b,i,s1,s2 := true, false,3,“hello”, “world”

只能在函数内使用

1.2 内建变量类型

v6lLge.jpg

complex定义复数

v61Euj.jpg

v61mEq.jpg

v6G02T.jpg

1.3 常量的定义

v6GTqH.jpg

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cf3uue6n-1663848210436)(https://s1.ax1x.com/2022/08/22/v6GzQS.png)]

v6JpLQ.png

1.4 条件语句

v6Jion.png

package main

import (
	"fmt"
	"io/ioutil"
)

func main() {
	const filename = "abc.txt"
	if contents, err := ioutil.ReadFile(filename); err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("%s\n", contents)
	}
}

v6JDYt.png

switch会自动break，除非使用fallthrough

switch后面可以没有表达式

package main

import (
	"fmt"
	"io/ioutil"
)

func grade(score int) string {
	g := ""
	switch {
	case score < 0 || score > 100:
		panic(fmt.Sprintf("wrong score: %d", score))

	case score < 60:
		g = "F"
	case score < 80:
		g = "C"
	case score < 90:
		g = "B"
	case score <= 100:
		g = "A"
	}
	return g
}

func main() {
	const filename = "abc.txt"
	if contents, err := ioutil.ReadFile(filename); err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("%s\n", contents)
	}
	fmt.Println(
		grade(0),
		grade(59),
		grade(60),
		grade(70),
		grade(82),
		grade(99),
		grade(100),
		//grade(101),
	)
}

1.5 循环

v6YBB4.png

vcMqtf.png

vcQPA0.png

vcQFhT.png

vcQmu9.png

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func convertToBin(n int) string {
	result := ""
	for ; n > 0; n /= 2 {
		lsb := n % 2
		result = strconv.Itoa(lsb) + result
	}
	return result

}

func printFile(filename string) {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	scanner := bufio.NewScanner(file)

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
}

//死循环
func forever() {
	for {
		fmt.Println("abc")
	}

}

func main() {
	fmt.Println(
		convertToBin(5),  // 101
		convertToBin(13), // 1101
		convertToBin(72387885),
		convertToBin(0),
	)

	printFile("abc.txt")

}

1.6 函数func

func eval(a, b int , op string) int {
    
}

vc1KfK.png

vc3OVs.png

vc8AaR.png

package main

import "fmt"

func eval(a, b int, op string) int {
	switch op {
	case "+":
		return a + b
	case "-":
		return a - b
	case "*":
		return a * b
	case "/":
		return a / b
	default:
		panic("unsupported operation: " + op)
	}
}

func div(a, b int) (q, r int) {
	q = a / b
	r = a % b
	return
}
func main() {
	fmt.Println(eval(3, 4, "*"))
	q, r := div(13, 3)
	fmt.Println(q, r)
}

1.7 指针

var a int = 2
var pa *int = &a
*pa = 3
fmt.Println(a)

指针不能运算

1.7.1 值传递 引用传递

vcGAOg.png

vcGQpV.png

值传递做拷贝动作

vcGGm4.png

引用传递做指向动作

vcGJ0J.png

go语言中对象的传递

vcGxjU.png

go语言只有值传递这一种方式

vcJl4I.png

func swap(a, b int) (int, int) {
	return b, a
}
func main() {
	fmt.Println(eval(3, 4, "*"))
	q, r := div(13, 3)
	fmt.Println(q, r)
	a, b := 3, 4
	a, b = swap(a, b)
	fmt.Println(a, b)
}

1.8 数组，切片和容器

//数组
	var arr1 [5]int
	arr2 := [3]int{1, 3, 5}
	arr3 := [...]int{2, 4, 6, 8, 10}
	var grid [4][5]int

	fmt.Println(arr1, arr2, arr3)
	fmt.Println(grid)

数量写在类型的前面

vcochd.png

vcofjP.png

vco5B8.png

package main

import "fmt"

func main() {
	//数组
	var arr1 [5]int
	arr2 := [3]int{1, 3, 5}
	arr3 := [...]int{2, 4, 6, 8, 10}
	var grid [4][5]int

	fmt.Println(arr1, arr2, arr3)
	fmt.Println(grid)

	for i := 0; i < len(arr3); i++ {
		fmt.Println(arr3[i])
	}

	for _, v := range arr3 {
		fmt.Println(v)
	}

}

为什么要用range

① 意义明确，美观

② c++，没有类似的能力

③ java/python : 只能for each value，不能同时获取i， v

vc7mMq.png

package main

import "fmt"

func printArray(arr *[5]int) {
	arr[0] = 100
	for i, v := range arr {
		fmt.Println(i, v)
	}

}

func main() {
	//数组
	var arr1 [5]int
	arr2 := [3]int{1, 3, 5}
	arr3 := [...]int{2, 4, 6, 8, 10}
	var grid [4][5]int

	fmt.Println(arr1, arr2, arr3)
	fmt.Println(grid)

	for i := 0; i < len(arr3); i++ {
		fmt.Println(arr3[i])
	}

	for _, v := range arr3 {
		fmt.Println(v)
	}

	fmt.Println("printArray(arr1)")
	printArray(&arr1)

	fmt.Println("printArray(arr3)")
	printArray(&arr3)
	//printArray(arr2) 报错是因为[3]int 和 [5]int在go语言中是不同的数据类型

	fmt.Println("arr1 and arr3")
	fmt.Println(arr1, arr3)

}

1.9 切片

vcH4nx.png

vcbqaT.png

package main

import "fmt"

func updateSlice(s []int) {
	s[0] = 100
}

func main() {
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
	fmt.Println("arr[2:6] = ", arr[2:6])
	fmt.Println("arr[:6] = ", arr[:6])
	s1 := arr[2:]
	fmt.Println("arr[2:] =", s1)
	s2 := arr[:]
	fmt.Println("arr[:] =", s2)

	fmt.Println("After updateSlice(s1)")
	updateSlice(s1)
	fmt.Println(s1)
	fmt.Println(arr)

}

vcL9pQ.png

vcvqd1.png

vcvvRO.png

vcxpsH.png

vcxYSU.png

vcx5kt.png

	s3 := append(s2, 10)
	s4 := append(s3, 11)
	fmt.Println("s3, s4 = ", s3, s4)
	fmt.Println("arr = ", arr)

切片的操作

1.10 Map

vjbFu4.png

package main

import "fmt"

func main() {
	m := map[string]string{ // map是一个hashmap
		"name":    "ccmouse",
		"course":  "golang",
		"site":    "imooc",
		"quality": "notbad",
	}

	m2 := make(map[string]int) // m2 == empty map

	var m3 map[string]int //m3 == nil
	fmt.Println(m, m2, m3)

	fmt.Println("Traversing map")
	for k, v := range m {
		fmt.Println(k, v)
	}

	fmt.Println("Getting values")
	courseName := m["course"]
	fmt.Println(courseName)
}

vjbR2T.png

vjbhMF.png

vjqSZd.png

1.11 map例题 寻找最长不含有重复字符的子串

vjqkz8.png

vjq1zT.png

package main

import "fmt"

func lengthofNonRepeatingSubStr(s string) int {
	lastOccurred := make(map[byte]int)
	start := 0
	maxLength := 0

	for i, ch := range []byte(s) {

		if lastI, ok := lastOccurred[ch]; ok && lastI >= start {
			start = lastI + 1
		}
		if i-start+1 > maxLength {
			maxLength = i - start + 1
		}
		lastOccurred[ch] = i
	}
	return maxLength
}
func main() {
	fmt.Println(
		lengthofNonRepeatingSubStr("abcabcbb"))
	fmt.Println(
		lengthofNonRepeatingSubStr("bbbbbb"))
	fmt.Println(
		lengthofNonRepeatingSubStr("pwwkew"))
	fmt.Println(
		lengthofNonRepeatingSubStr(""))
	fmt.Println(
		lengthofNonRepeatingSubStr("b"))
	fmt.Println(
		lengthofNonRepeatingSubStr("abcdefg"))
}

vjqyOe.png

vjLODe.png

vjLvEd.png

1.12 面向对象和结构体

package main

import "fmt"

type treeNode struct {
	value       int
	left, right *treeNode
}

func main() {
	var root treeNode

	root = treeNode{value: 3}
	root.left = &treeNode{}
	root.right = &treeNode{5, nil, nil}
	root.right.left = new(treeNode)

	nodes := []treeNode{
		{value: 3},
		{},
		{6, nil, &root},
	}
	fmt.Println(nodes)
}
// 输出结果
//[{3 <nil> <nil>} {0 <nil> <nil>} {6 <nil> 0xc000004078}]

结构创建在堆上还是在栈上？

不需要知道

package main

import "fmt"

type treeNode struct {
	value       int
	left, right *treeNode
}

func (node treeNode) print() {
	fmt.Print(node.value, " ")
}
func (node *treeNode) setValue(value int) {
	node.value = value
}
func createNode(value int) *treeNode {
	return &treeNode{value: value}
}

func main() {
	var root treeNode

	root = treeNode{value: 3}
	root.left = &treeNode{}
	root.right = &treeNode{5, nil, nil}
	root.right.left = new(treeNode)
	root.left.right = createNode(2)

	root.right.left.setValue(4)
	root.right.left.print()
	fmt.Println()

	root.print()
	root.setValue(100)

	pRoot := &root
	pRoot.print()
	pRoot.setValue(200)
	pRoot.print()
}
//输出值为：
//4
//3 100 200 


package main

import "fmt"

type treeNode struct {
	value       int
	left, right *treeNode
}

func (node treeNode) print() {
	fmt.Print(node.value, " ")
}
func (node *treeNode) setValue(value int) {
	if node == nil {
		fmt.Println("setting value to nil node. Ignored.")
		return
	}
	node.value = value
}

func (node *treeNode) traverse() {
	if node == nil {
		return
	}
	node.left.traverse()
	node.print()
	node.right.traverse()
}

func createNode(value int) *treeNode {
	return &treeNode{value: value}
}

func main() {
	var root treeNode

	root = treeNode{value: 3}
	root.left = &treeNode{}
	root.right = &treeNode{5, nil, nil}
	root.right.left = new(treeNode)
	root.left.right = createNode(2)

	root.right.left.setValue(4)
	root.traverse()
}
//输出 0 2 3 4 5

1.13 封装

1.14 扩展已有类型

package main

import (
	"awesomeProject/src/demo/golearning/tree"
	"fmt"
)

type myTreeNode struct {
	node *tree.Node
}

func (myNode *myTreeNode) postOrder() {
	if myNode == nil || myNode.node == nil {
		return
	}

	left := myTreeNode{myNode.node.Left}
	right := myTreeNode{myNode.node.Right}
	left.postOrder()
	right.postOrder()
	myNode.node.Print()
}

func main() {
	var root tree.Node

	root = tree.Node{Value: 3}
	root.Left = &tree.Node{}
	root.Right = &tree.Node{5, nil, nil}
	root.Right.Left = new(tree.Node)
	root.Left.Right = tree.CreateNode(2)
	root.Right.Left.SetValue(4)
	root.Traverse()
	fmt.Println()
	myRoot := myTreeNode{&root}
	myRoot.postOrder()
	fmt.Println()
}
//输出2 0 4 5 3

1.15使用内嵌类来扩展已有类型

1.16 go语言的依赖管理

1.17 go mod

1.18 最后目录的整理

把含有main函数的go文件分到几个不同的目录里面

zxyxxwindows
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go语言基础
01-17
go语言基础,
Go语言基础学习教程
12-31
本文实例讲述了Go语言基础知识。分享给大家供大家参考，具体如下： GO文件目录结构 该图是go-windows的目录结构 如图，go的程序应该是在gopath文件夹下的，分为bin, pkg, 和src三个子文件夹 src文件夹：每个次级...
Linux中too many arguments for format问题
F_Yong的博客
07-11 2万+
在Linux下用C语言实现Bash功能。在这个项目的创建子进程时，输出报错信息是这样写的。不过在我调试的时候警告了。意思是格式参数太多，身为一个强迫症患者，，我找了些资料。所有人都说printf("%m",errno)等价于printf("%s",strerror(errno));但我最后换了。在编译的时候正常了我用man找了下strerror的信息：返回的是一个char*类型，%s输出当然没毛病...
Go语言基础（七）函数
pangsky的博客
12-02 162
函数定义 Go 语言函数定义格式如下： func function_name( [parameter list] ) [return_types] { 函数体 } 函数定义解析： func：函数由 func 开始声明 function_name：函数名称，函数名和参数列表一起构成了函数签名。 parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值...
[GO语言基础] 一.为什么我要学习Golang以及GO语言入门普及
热门推荐
杨秀璋的专栏
12-14 11万+
作为网络安全初学者，会遇到采用Go语言开发的恶意样本。因此从今天开始从零讲解Golang编程语言，一方面是督促自己不断前行且学习新知识；另一方面是分享与读者，希望大家一起进步。这系列文章入门部分将参考“尚硅谷”韩顺平老师的视频和书籍《GO高级编程》，详见参考文献，并结合作者多年的编程经验进行学习和丰富，且看且珍惜吧！后续会结合网络安全进行GO语言实战深入，驾驭~ 这些年我学过各种编程语言，从最早的C语言到C++，再到C#、PHP、JAVA，再到IOS开发、Python，到最新的GO语言，学得是真的杂。有时
Go语言基础整理集合
qq_48937065的博客
02-21 456
go语言是一门静态强类型语言wp:listwp:list可以理解为解释型和编译型 （python，动态解释型语言 一边编译一边执行）（golang，java，静态编译型语言 必须先将文件编译成可执行文件后才能运行）/wp:listwp:list强制类型定义的语言，即一旦某一个变量被定义类型，如果不经强制转换，那么它永远就是该数据类型。强类型语言包括：Java、Python、C++等语言。
【Go入门】Go语言基础知识
weixin_44211968的博客
11-08 5652
Go语言中那些有趣的语法
Go语言基础入门
Naisu的各种笔记
09-19 3135
Go是由谷歌支持的开源编程语言，属于编译型语言，对并发编程有较好的支持。这篇文章将介绍Go语言基础入门相关内容。
Go语言基础语法入门及其示例
weixin_40188817的博客
06-25 1030
一、go简介 1．Go语言（或Golang）起源于2007年，并在2009年正式对外发布。Go是非常年轻的一门语言，它的主要目标是“兼具Python等动态语言的开发速度和C/C++等编译型语言的性能与安全性”。 2．Go语言是一种静态强类型、编译型、并发型、并具有垃圾回收功能的编程语言。 3.Go语言没有类和继承的概念，所以它和Java或C++看起来并不相同。但是它通过接口（interface）的概念来实现多态性。Go语言有一个清晰易懂的轻量级类型系统，在类型之间也没...
【Go之道】探索Go语言之旅：基础与进阶指南
颜淡慕潇
10-19 3万+
Go语言是一门强大而简单的编程语言，适用于各种应用领域。无论你是初学者还是有经验的开发人员，Go都值得学习。希望这篇入门介绍可以帮助你开始学习Go，并探索其丰富的功能和库。祝你编程愉快！
GO语言基础入门
发现问题，面对问题，分析问题，解决问题，总结问题
04-05 4058
文章目录（1）基础语法（2）指针和引用（3）数组 （1）基础语法 【1】Go 程序的一般结构: basic_structure.go // 当前程序的包名 package main // 导入其他包 import . "fmt" // 常量定义 const PI = 3.14 // 全局变量的声明和赋值 var name = "gopher" // 一般类型声明 type newType int // 结构的声明 type gopher struct{} // 接口的声明 type golang inter
Go语言基础之指针
weixin_41894193的博客
01-04 245
一、Go语言中的指针不能进行偏移和运算，因此Go语言中的指针操作非常简单，我们只需要记住两个符号：&（取地址）和*（根据地址取值 二、要搞明白Go语言中的指针需要先知道3个概念：指针地址、指针类型和指针取值。 a := 10 ptr := &a b := *ptr ...
go语言基础.pptx
07-13
go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言基础.pptx go语言...
Go语言基础教程
04-26
里面的内容是我在学习GO语言时候的一个总结，里面提到的相关知识点都是一些基本知识，希望对一些刚想要加入学习GO语言队伍的新老朋友们提供一点点帮助！
Golang | Leetcode Golang题解之第149题直线上最多的点数
最新发布
weixin_66442839的博客
06-14 362
Golang | Leetcode Golang题解之第149题直线上最多的点数
golang函数
zhanglong_longlong的专栏
06-12 335
对特定的功能进行提取，形成一个代码片段，这个代码片段就是我们所说的函数。【3】函数和函数是并列的关系，所以我们定义的函数不能写到main函数中。遵循标识符命名规范:见名知意 addNum,驼峰命名addNum。首字母大写该函数可以被本包文件和其它包文件使用(类似public)形参列表：个数：可以是一个参数，可以是n个参数，可以是0个参数。func 函数名（形参列表)（返回值类型列表）{【2】函数的作用：提高代码的复用性。形式参数列表：作用：接收外来的数据。实际参数：实际传入的数据。
11.2 Go 常用包介绍
专注于全栈开发领域
06-13 665
Go 语言的包非常强大，它们提供了构建高效、可靠应用程序所需的一切。通过深入理解并掌握这些包的使用技巧，开发者可以更加得心应手地解决各种编程问题。希望本文能够帮助开发者更深入地了解 Go 语言的常用包，并在实际开发中运用这些技巧。
go interface
zhanglong_longlong的专栏
06-12 180
【代码】go interface。
golang生成根证书，服务端证书，用于 tls
wanmei002的博客
06-11 339
用golang生成根证书，服务端证书，用于tls
go 语言基础实战 pdf
12-04
总的来说，这本《Go语言基础实战》PDF电子书是学习Go语言入门的好资源。它既适合自学，也适合作为教材在学校或培训机构使用。如果你想系统学习和掌握Go语言编程，不妨找一本这样的书来阅读，相信会对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值