Go语言-----入门笔记

最新推荐文章于 2022-08-01 14:47:00 发布

陈某狗Cmoigou

最新推荐文章于 2022-08-01 14:47:00 发布

阅读量3.4k

点赞数 2

分类专栏：读书笔记；文章标签：编程语言

本文链接：https://blog.csdn.net/weixin_39071173/article/details/90714572

版权

读书笔记；专栏收录该内容

3 篇文章 0 订阅

订阅专栏

由于最近想自学区块链搭建的知识，所以先入门了Go语言，以下是一些笔记，在适当位置会对我比较熟悉的Java语言做一个比较，加深记忆；

一、Go语言的特点

1. 运行效率高，开发高效，部署简单；

2. 语言层面支持并发，易于利用多核实现并发；

3. 内置runtime（作用：性能监控，GC等）；

4.简单易学，丰富的标准库，强大的网络库；

5.内置强大的工具（gofmt），跨平台编译，内嵌C支持；

二、Go语言的应用

1.服务器编程，如处理日志，数据打包，虚拟机处理，文件系统等

2.分布式系统，数据库代理器，中间件等；

3.网络编程，web应用，Api应用

4.云平台

三、Go语言命令行工具介绍

四、Go语言基础语法

1. 关键字、标识符、注释、基础结构

Go语言关键字
break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrought	if	range	type
continue	for	import	return	var

Go标识符
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	uintprt

// 单行注释

/*
多行注释
*/

2.基础结构详解

//程序第一行一定要package开头，声明所属的包
package main
//导入引用
import "fmt"
//常量定义,类型放在变量名后
const NAME string = "test"
//全局变量的声明与赋值
var a string = "eanam"
//一般类型声明
type TestInt int
//结构声明
type Learn struct{
}
//接口声明
type ILearn interface{
}
//函数定义
func LearnGo() {
}
//main函数
func main() {
}

3. package的用法

（1）package是最基本的分发单位和工程管理中依赖关系的体现；

（2）每个Go语言源代码文件开头都拥有一个package声明，表示源码文件所属的代码包

（3）要生成Go语言可执行程序，必须要有main的package包，并且该包下有main()函数

（4）同一个路径下只能存在一个package，一个package可以拆成多个源文件组成

4. import的用法

（1）import语句可以导入源代码文件所依赖的package包

（2）不得导入源代码文件中没有用到的package，否则Go语言编译器会报编译错误

//格式1：
import "A"
import "B"

//格式2：
import （
    "A"
    "B"
）

5. import的原理

（1）如果一个main导入其他包，包将按顺序导入；

（2）如果导入的包中有依赖其他包（包B），会首先导入B包，然后初始化B包中的常量和变量，最后如果B包中有init，会自动执行init();

（3）所有包导入完成后才会对main中常量和变量进行初始化，然后执行main中的init函数（如果存在），最后才执行main函数；

（4）如果一个包被导入多次则该包只会被导入一次；

6. import 别名、“.”、“_”

（1）将导入的包命名为另一个容易记忆的别名；

（2）“.”的含义是：“.”标识的包导入后，调用该包函数时可以省略前缀包名；

（3）“_”的含义是：导入该包，但不导入整个包，而是执行该包中的init函数，因此无法通过包名来调用包中的其他函数。使用“_”操作往往是为了注册包内的引擎，让外部可以方便地使用。

//演示
import(
    alias "fmt"    //alias.Print()
    . "fmt"        //Print()
    _ "fmt"        
)

7. Go语言的数据类型

（1）数值类型、字符类型和布尔型

数值类型
整型	1	uint8	无符号8位整型（0到255）
	2	uint16	无符号16位整型（0到65535）
	3	uint32	无符号32位整型（0到4294967295）
	4	uint46	无符号64位整型（18446744073709551615）
	5	int8	有符号8位整型（-128到127）
	6	int16	有符号16位整型（-32768到32767）
	7	int32	有符号32位整型（-2147483648到2147483647）
	8	int64	有符号64位整型
浮点型	1	float32	32位浮点型数
	2	float64	64位浮点型数
	3	complex32	32位实数和虚数
	4	complex128	64位实数和虚数
其他数值类型	1	byte	类似uint8
	2	rune	类似int32
	3	uint	32位或64位
	4	int	与uint一样大小
	5	uintptr	无符号整型用于存放一个指针

（2）派生类型

派生类型
指针类型	Pointer
数组类型
结构化类型	struct
Channel类型	chan
函数类型	func
切片类型	slice
接口类型	interface
Map类型	map

（3）类型零值和类型别名

 A. 类型零值不是空值，而是某个变量被声明后的默认值，一般情况下，值类型的默认值为0，布尔型默认值为 
     false，string默认值为空字符 
   
 B. 我们可以对类型设置别名，如下：
        
        type alias int

（4）类型所占存储大小

五、Go语言变量概念

1. 变量与常量

//变量声明：初始化与赋值

/*
单个变量的声明与赋值
1）变量的声明格式：var <变量名称> [变量类型]
2）变量的赋值格式：<变量名称> = <值、表达式、函数等>
3）声明和赋值同时进行：var <变量名称> [变量类型] = <值、表达式、函数等>
4）分组声明格式：
   var(
        i int
        j float32
        name string
   )


同一行声明多个变量和赋值：var a,b,c int = 1,2,3 或者 a,b := 1,2
全局变量的声明必须使用var关键词，局部变量可以省略
特殊变量下划线"_"
*/

/*
变量的类型转换：
1）Go中不存在隐式转换，类型转换必须是显式的；
2）类型转换只能发生在两种兼容类型之间；
3）类型转换格式：<变量名称> [:]= <目标类型>(<需要转换的变量>)
*/

//变量可见性规则
/*
1）大写字母开头的变量的可导出，也就是其他包可以读取的，是公共变量
2）小写字母开头的就是不可导出，是私有变量
*/


//常量：常量声明与iota的使用
/*
1) 常量定义形式：
    显式：const identifier [type]  = value
    隐式：const identifier = value(通常叫无类型常量)
2）常量类型范围
    目前只支持布尔型、数字型（整数型、浮点型和复数）和字符串型；不支持派生类型
3）特殊常量iota的用法
    iota在const关键字出现时将被重置为0
    const组合声明时每增加一行常量声明将使iota计数一次（同一行iota一样）
    iota常见使用法：
        1）跳值使用法

const(
	a = iota
	b = iota
	c int = iota
	_
	//可省略iota
	d
)

        2）插队使用法


const(
	a = iota
	b = iota
	c int = iota
	k = 2.14
	//可省略iota
    d = iota
)


        3）表达式隐式使用法

            如果没有显示赋值，则会继承上一个表达式的右式

        4）单行使用法
*/

六、Go语言运算符

（1）算术运算符（++、--只能放在变量后面）

（2）关系运算符

（3）逻辑运算符

（4）按位运算符

（5）赋值运算符

七、Go语言控制语句

（1）条件语句： if-else语句

package main

import "fmt"

func main() {
	a := 2
	if a > 0{
		if a > 3{
			fmt.Println("a > 3")
		}
		fmt.Println("a > 0")
	}else {
		fmt.Println("a < 0")

	}
}

（2）选择语句：switch语句

package main

import "fmt"

func main() {
	a := 2

	//演示简单匹配
	switch a {
	case 1:
		fmt.Println(" a is 1")

	case 2:
		fmt.Println(" a is 2")

	case 3:
		fmt.Println(" a is 3")

	default:
		fmt.Println(" a is not in range")
	}


	//演示type-switch
	var b interface{}
	b = 3.14
	switch b.(type) {
	case int:
		fmt.Println("b is int")

	case float64:
		fmt.Println("b is float64")

	default:
		fmt.Println("unsuitable type")
	}
}

（3）循环语句：for语句

package main

import (
	"fmt"
)

func main() {
	
	//无限循环
	for {
		fmt.Println("this is unlinited circle")
	}

	//简单用法
	for i := 0; i < 10;i++{
		fmt.Println("--------",i)
		//time.Sleep(1*time.Second)
	}

	//实现佛reach效果
	a := []string{"banana","peach","apple"}
	for key,value := range a{
		fmt.Println(key,"-",value)
	}
	
}

（4）goto、break、continue

package main

import (
	"fmt"
	"time"
)

func main() {
	var j = 0
	i := 0
	/*
		goto跳到指定步骤
		无限循环打印：this is code 1
	 */
	goto Three
	fmt.Println("demo is start")
	One:
		fmt.Println("this is code 1")
		time.Sleep(1*time.Second)
	goto One

	/*break停止当前循环
		打印两次break demo
	 */

	for {
		fmt.Println("break demo")
		i++
		if i == 2 {
			fmt.Println("doing break")
			break
		}

	}


	/*continue结束本次循环，直接进入下一轮循环
		不打印continue demo2，
	 */
	Three:
	for {
		j++
		if j == 2 {
			fmt.Println("doing continue")
			continue
		}
		fmt.Println("continue demo",j)
		time.Sleep(1*time.Second)

	}
}

陈某狗Cmoigou

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
Go语言-----入门笔记

由于最近想自学区块链搭建的知识，所以先入门了Go语言，以下是一些笔记，在适当位置会对我比较熟悉的Java语言做一个比较，加深记忆；一、Go语言的特点 1. 运行效率高，开发高效，部署简单； 2. 语言层面支持并发，易于利用多核实现并发； 3. 内置runtime（作用：性能监控，GC等）； 4.简单易学，丰富...
复制链接

扫一扫