Go基础

最新推荐文章于 2022-03-30 18:54:05 发布
最新推荐文章于 2022-03-30 18:54:05 发布
阅读量368 收藏
点赞数
分类专栏： Go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_41671472/article/details/89792309
版权

安装go语言

配置环境变量

不配置也没有什么大的影响，只是不方便编译罢了

Windows

  • 我的电脑——右键属性——高级系统设置——环境变量——系统变量
  • GOROOT：Go安装路径
  • GOPATH：Go工程路径，如果有多个按分号间隔

在这里插入图片描述

  • Path：在Path中添加： C：\Go\bin;%GOPATH%\bin;。我的Go安装在C盘中。
  • cmd中使用 go env（查看得到Go的配置信息） 或者 go version（查看go的版本号） 检查环境配置成功与否

Mac

  • 双击下载的pkg包，默认安装就行了
  • 编辑用户目录中的 .bash_profile 文件
    • sudo vim .bash_profile
    • 添加一下内容
export GOPATH=/Users/admin/Desktop/Go_project #为你go语言的工程目录
export GOROOT=/Usr/local/go
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOBIN

下载使用 Goland

自行百度咯

HelloWorld

在这里插入图片描述

package main

import "fmt"

func main() {
    fmt.Println("HelloWorld") 
    //没有分号
}

  • package main定义了包名

    • 必须在源文件中非注释的第一行指明这个文件属于的包
    • package main表示可以独立运行的执行程序

  • import “fmt” 告诉Go编译器导入fmt包，fmt包实现格式化IO

  • func main() 程序入口，每个可执行程序必须包含

    • 一般来说第一个执行的就是main函数
    • 如果有init函数，则优先执行init函数

  • 如果打算将多个语句在写统一行，则必须使用 分号’;’，反正不鼓励这种写法

  • 命令行中使用 go run 01_HelloWorld.go 命令，执行文件

  • 命令行中使用 go build 01_HelloWorld.go 命令，编译出 01_HelloWorld 文件，再运行该文件

Goland快捷方式

  1. ALT+Q：看当前方法的声明
  2. CTRL+Backspace：按单词进行删除
  3. SHIFT+ENTER：向下插入新行
  4. CTRL+X：删除当前光标所在行
  5. CTRL+D：复制当前光标所在行
  6. ALT+SHIFT+UP/DOWN：光标所在代码行，整行上移或下移
  7. CTRL+SHIFT+U：选中内容进行大小写转换
  8. CTRL+ALT+L：自动排版

Go规则

  1. Go语言中，使用大小写来决定标志符（常量，变量，类型，接口，结构或函数）是否可以被外部包所调用

    • 以一个大写字母开头，那么使用这种形式的标志服的对象就可以被外部包的代码所使用，类似C++中的public
    • 以一个小写子母开头，则对包外是不可见的，但是他们在整个包的内部是可见的，像C++中的private

  2. 常用关键字

在这里插入图片描述

  1. 程序组成
    • 当前程序的包名 ： package main
    • 导入其他包 ： import “fmt”
    • 常量定义 ： const PI=“3.14” （习惯性全大写）
    • 全局变量的声明和赋值 ： var name=“gopher”
    • 一般类型声明 ： type newType int
    • 结构的声明 ： type gopher struct{}
    • 接口的声明 ： type golang interface {}
  2. 文件的结构组成
    1.
    - 只有package 名称为main 的包可以包含main函数
    - 一个可执行程序有且只有一个mian包
    - 通过import关键字导入其他非main包
    - 可以通过import关键字单个导入，也可以多个导入
    2. 一般由关键字，常量，变量，运算符，类型和函数组成
    3. 分隔符：括号（），中括号[]，大括号{}
    4. 各种标点符号
    5. 使用var关键字来进行全局变量的声明和赋值
    6. 通过type关键字来进行结构体和接口声明
    7. func关键字进行函数声明

变量

  1. 为初始化的标格式

    • var 变量名 变量类型

  2. 为初始化的批量格式

var (
    a int
    b string
    c []float32
    d func() bool
    e struct{
        x int
        y string
    }
)

整形和浮点型变量默认值：0
bool型默认值是 false
字符串默认值为空字符串
函数，指针变量初始值为nil

  1. 初始值变量的标准格式
var (
    a int = 100
)
  1. 初始化变量的编译器自动推断类型格式
var (
    l = 200
)
  1. 短变量声明格式
    • 只能被用在函数体内，不能被用于全局变量的声明与赋值
    • 该变量名必须是没有定义过的变量
    • 首选的局部变量的名字
m := 100
fmt.Printf("HelloWorld %T %d", m, m) //没有分号
  1. 多个变量同时赋值
m, n, g := "a", "b", 10
x, y int
  1. 匿名变量
  • 使用‘_’替换没有使用到的变量，不会占用命名空间，不会分配内存
  • go语言函数返回与python相似，可以返回多个变量，同时 = 也可以给多个变量赋值
x := 10
y := 20
fmt.Println(x, y)
x, y = y, x
fmt.Println(x, y)

可以看到x，y的值交换了

数据类型

  • 基本数据类型：整形，浮点型，布尔型，字符串，字符（byte，rune）
  • 复合数据类型：指针，数组，切片，映射，函数，结构体，通道

整形

  1. int8, int16, int32, int64, int
  2. unit8, uint16, uint32, uint64, uint
  3. byte一般用于存放ascii表中的数据
  4. rune一般用于存放Unicode中的数据

uint8即使byte型，int16对应C语言的short型，int64对应C语言的long型

符号数据范围
uint82的8次方
uint162的16次方
uint322的32次方
uint642的64次方
int8-128～127
int16-32768~32767
int32-2147483648~2147483647
int64-9223372036854775808~9223372036854775807
byte类似uint8
rune类似int32
uint32或者64位，根据机器字长决定
int与uint一样
uintptr无符号整形，正与存放一个指针
func main(){
    a := 100
    var b byte = 100
    var c rune = 200
    var e byte = 'a'
    var f rune = '一'

    fmt.Printf("%T %v\n", b, b);
    fmt.Printf("%T %v\n", c, c);
    fmt.Printf("%T %v\n", e, e);
    fmt.Printf("%T %v\n", f, f);

}

bool型

  • 声明方式：var flag bool
  • 不参与运算，也无法与其他类型进行转换

字符串

  • 字符串可以使用转义符
    • ‘\r’：回车符
    • ‘\n’：换行符
    • ‘\t’：制表符
    • '：单引号
    • ‘’：双引号
    • \：反斜杠
  • 多行定义字符串
    • 双引号书写字符串被成为字符串字面量（string literal）。不能跨行
    • 多行字符串需要使用 ”`“反引号，多用于内嵌源码和内嵌数据
    • 在反引号中的所有代码都不会被编译器识别，而只是作为字符串的一部分

arr := []byte{97, 98, 99, 65}

code := `type a int
        m := 19
        b = "string"
        h = 100

        fmt.Printf("HelloWorld %T %d", m, m) //没有分号
    `
    fmt.Println(code)

字符型

  • 字符串中的每一个元素都是一个 字符，定义字符使用单引号
  1. byte一般用于存放ascii表中的数据
  2. rune一般用于存放Unicode中的数据
var e byte = 'a'
var f rune = '一'

格式化输出

  1. 通用

    • %v ：值的默认格式表示
    • %+v ：类似%v，但输出结构体时会添加字段名
    • %#v ：值的Go语法比噢哈斯
    • %T ：值的类型的Go语法表示

  2. bool型

    • %t ：单词true或false

  3. 整数

    • %b ： 表示二进制
    • %c ： 该值对应的unicode码值
    • %d ： 表示为十进制
    • %8d： 表示该整型长度是8，不足8则在数值前补空格，超过8则以实际为准不做修改
    • %08d：数字长度是8，不足8位的在数字前补0，超过8不做修改
    • %o ： 表示位八进制
    • %q ： 该值对应的单引号扩起来的go语法字符字面值，必须时会采用安全的转义表示
    • %x ： 表示为十六进制，使用a-f
    • %X ： 表示为十六进制，使用A-F
    • %U ： 表示为Unicode格式：U+1234

  4. 浮点数和复数的两个组分

    • %b ： 无小数部分，二进制指数的科学计数法，如 -123456p-78
    • %e ：（=%.6e）有6位小数部分的科学计数法，如-1234.456e+78
    • %E ： 科学计数法，如-1234.456E+78
    • %f ：（=%.6f）有6位小数部分，如123.456123
    • %F ： 等价于%f
    • %g ： 根据实际情况采用 %e 或%f格式
    • %G ： 根据实际情况采用 %E 或%F格式

  5. 字符串和 []byte

    • %s ： 直接输出字符串或者 []byte
    • %q ： 该值对应的双引号扩起来的go语法字符串字面值
    • %x ： 每个字节使用两字符十六进制表示（使用a-f）
    • %X ： 每个字节使用两字符十六进制表示（使用A-F）

fmt中不仅有 print 等方法格式化输出到控制台，更能将格式化输出的值作为返回值返回成字符串类型

var str := fmt.Sprintf("%b", 123)

数据转换

go语言真的很严格，进行运算的变量必须是统一类型的变量

  1. T（表达式）
    • 采用数据类型前置括号的方式进行类型转换。T表示要转化的类型，表达式包括变量，数值，函数返回值等
    • 类型转换时，需要考虑两种类型之间的关系和范围，是否会发生数值截断
    • 布尔类型无法与其他类类型转换
ch := 90
en := 80.9
avg := (ch + int(en))/2
avg2 := (float64(ch) + en)/2.0
fmt.Println(avg)
fmt.Println(avg2)
  1. floag与int之间的转换
    需要注意float转int时精度的损失
ch := 90
res := string(ch)
fmt.Println(res) // 输出 Z 就是 90对应的ASCII

  1. int转string

    • 其实相当于byte或rune转string
    • 该int数值是ASCII码的编号或Unicode字符集的编号。转成string就是将根据字符集，将对应编号的字符查出来
    • 当该数值超出Unicode编号范围，则转成的字符串显示成乱码

  2. 不允许string转int

常量

声明方式

  1. 常量恒定不变，不能修改
  2. 常量中的数据类型只可以是bool型，数值型和字符串
  3. 常量的定义格式：
    • const 标识符 [类型] = 值
    • 可以省略类型说明符[类型]，
  4. 多个相同的类型可以写成 cosnt WIDTH, HEIGHT = 1, 2
  5. 常量定义后未被使用，编译不会报错

常量用于枚举（常量组）

const (
    Unkown = 0
    Female = 1
    Male = 2    
)
  • 常量组中如果不指定类型和初始值，则与上一行非空常量的值相同
const (
    a = 10
    b
    c
)
// a = 10 b = 10 c = 10

iota

  1. iota，特殊常量值，是一个系统定义的可以被编译器修改的常量值。iota只能出现在常量组中。
  2. 在每一个const关键字出现时，被重制为0，然后每出现一个常量，iota所代表的数值会自动增加1。iota可以理解成常量中常量的计数器，不论该常量的值是什么，只要有一个常量，那么iota就+1
  3. iota可以被用作枚举值
const (
    X = "A"
    Y
)

const (
    a = iota
    b = iota
    c = iota
)
// a = 0 b = 1 c = 2

const (
    A = "Test"
    B = iota
    C
)
// a = "Test" b = 1 c = 2

Go语法

条件分支

if…else…


//1
if 布尔表达式{

}

//2
if 布尔表达式 {

} else {

}

//3
if 布尔表达式 {

} else if 布尔表达式 {

} else {

}

num := 89
if num%2 == 1{
    fmt.Println("奇数");
}
  1. 布尔表达式不是必须使用括号扩起来
  2. 必须使用大括号 {}，即使只有一行代码
  3. 左括号必须与 if 或 else 同行
  4. 在if之后，条件语句之前，可以添加变量初始化语句，使用 ；进行分隔

switch

switch var1 {
    case var1:
        ...
    case var2:
        ...
    case var3:
        ...
    default:
        ...
}
  • switch从上至下，找到匹配到的那一项为止，无需额外添加berak
  • var1可以是任何类型，而var1和var2则可以是任何同类型的任意值
  • 可以同时测试多个符合条件的值，使用逗号分割：case var1,var2,var3
  • Go语言中switch后的表达式可以省略，默认是true
  • case后的值不能重复
  • 因为默认匹配到case 就break，所以如果不想break掉则需要添加fallthrough（贯穿），强制执行后面的case分支
  • fallthrough必须放在case分支的最后一行
func init(){
    month := 2
    days := 0
    switch month {
        case 1, 3, 5, 7, 8, 10, 12
            days = 31
            fallthrough //会执行下一个case，然后在下一个case break掉
        case 4, 6, 9, 11:
            days = 30
        case 2:
            days = 28
        default = -1
    }
}

循环

go语言中没有while也没有do…while…

break

continue

goto

阿茶家的庸医
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
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语言)
朱夏彤的博客
09-07 4651
变量 概念 变量是计算机语言中存储数据的抽象概念。变量的功能是存储数据。变量通过变量名访问。 变量的本质是计算机分配的一小块内存，专门用于存放指定数据，在程序运行过程中该数值可以发生改变。 变量的存储往往具有瞬时性，或者说是临时存储，当程序运行结束，存放该数据的内存就会释放，而该变量就会消失。 Go语言的变量名有字母，数字，下划线组成，首个字符不能为数字。 Go语法规定，定义的局部变量若没有被调用则编译错误。 命名：驼峰标识，不建议用下划线连接多个单词。 声明变量 变量声明有多种形式 //未初始化的标准格式
Go语言-常量
sjsjdnehzhs的博客
07-22 197
一、常量声明 常量的声明方式类似于变量，只不过常量在声明的时候需要初始化。 常量是在编译时被创建的，即使定义在函数内部也是如此，并且只能是布尔类型、数字型、字符串型。 常量的值必须在编译时就能够确定，可以涉及计算过程，但用于计算的值必须能在编译期间就能获得。 显示类型定义 const c string ="abc" 隐式类型定义 const b ="abc" 批量声明 const( e=2.7444 pi=2234 ) ## const( a=1 b c=2
golang break和continue基础使用
qq_39657769的博客
02-08 350
break 跳出循环 案例： package main import( "fmt" "math/rand" "time" ) func main(){ var num int = 0 for { //时间戳 返回一个1970:01:01 0:0:0到至今的一个时间戳 rand.Seed(time.Now().UnixNano()) //随机数 n := rand.Intn(100) + 1 fmt.Println("n = ",n) num++ if(n ==
phper 的Goland学习之路--- for循环
phper 进阶之路
04-12 1025
1. for循环本质：     for  [ 初始化语句]  ; [ 条件表达式 ] ; [ 表达式 ] {   //循环语句}2.for循环实现while循环：    for 条件表达式 {   //循环语句 }     等就于   while( 条件表达式)  {   }3.死循环： for {   // 循环语句  }     类似  while （true）{   }for ; ; ; {...
GoLang中break 和 continue(转载)
wxq_768992698的博客
09-26 256
原文地址：http://studygolang.com/articles/1978     利用break 可以提前退出循环，break 终止当前的循环；也可以定义标签，break指定的循环体。 break的用法示例1： package main import (     "fmt" ) func main() {     for i := 0; i < 10;...
go语言基础
01-17
go语言基础,
Go语言基础教程
04-26
里面的内容是我在学习GO语言时候的一个总结，里面提到的相关知识点都是一些基本知识，希望对一些刚想要加入学习GO语言队伍的新老朋友们提供一点点帮助！
Go语言基础学习教程
12-31
本文实例讲述了Go语言基础知识。分享给大家供大家参考，具体如下： GO文件目录结构 该图是go-windows的目录结构 如图，go的程序应该是在gopath文件夹下的，分为bin, pkg, 和src三个子文件夹 src文件夹：每个次级...
go语言基础 常量
超级系博客
04-29 170
2.常量 概念：类似变量，数值不可以更改 语法： const 常量名 数据类型 = 赋值 const 常量名 = 赋值 赋值：常数，常量表达式 常量的数值：布尔，数值，字符串 常量的名字，所有字母都大写。 package main import "fmt" func main() { /* 常量：同变量类似，区别在于程序执行过程中，数值不可以改变 定义语法： const 常量名...
golang 一行代码 把array/slice转成逗号分隔的字符串
weixin_34077371的博客
04-03 5214
array_or_slice := []int{1,2,3} strings.Replace(strings.Trim(fmt.Sprint(array_or_slice), "[]"), " ", ",", -1) 复制代码结果："1,2,3"
go语言入门-常量（const和itoa）
syouya.shiraki's blog
04-29 2446
go语言入门-常量 定义 常量：常量标识恒定不变的值，区别于变量var。var-变量不赋值存在默认值，但是常量声明是必须显示赋值。 常量关键字：const 常量不能使用 “:=” 语法定义。 声明方式 普通声明方式 const E float64 = 1.602 const EE = 1.602 // 类型可以省略 批量声明方式 常用声明使用方式 const ( A = 'A' B = 'B...
Go：iota（常量计数器）
lj19990824的博客
03-30 832
介绍 iota是go语言的常量计数器，只能在常量的表达式中使用，iota关键字在const关键字出现时将会被重置为0。 const每新增一行常量声明，iota计数一次，（可以当做const语句中的索引），使用iota能简化定义，定义枚举时有用 示例： const ( n1 = iota //0 n2 //1 n3 //2 n4 //3 ) 使用下划线_可
Golang 字符串分割,替换和截取
Bel_Ami_n的博客
07-29 2772
package main import ( "fmt" "strings" ) func main() { str := "赵,钱,孙,李,赵" //字符串分割, 使用字符分割 str1 := strings.Split(str, ",") fmt.Println(str1[0]) //赵 fmt.Println(str1[1]) //钱 fmt.Println(str1[2]) //孙 fmt.Println(str1[3])
Go语言编程中字符串切割方法小结
weixin_33849215的博客
05-15 935
1.func Fields(s string) []string，这个函数的作用是按照1：n个空格来分割字符串最后返回的是[]string的切片 复制代码代码如下: import ("fmt""strings") func main() {fmt.Println(strings.Fields("hello widuu golang")) //out [hello widuu g...
golang语法总结（七）：常量计数器
陈鹏万里
02-22 1738
关键字为iota，没遇到一个const关键字就会置为0，然后递增。还有就是如果定义常量组，没有赋值的编译器会自动将其赋值表达式置为和它前面那个变量的表达式一样      const ( A = 55 B = iota C D)func main() { fmt.Println(A) fmt.Println(B) fmt.Println(C) fmt.Println(D)}
Markdown学习笔记
最新发布
04-30
Markdown学习笔记
热塑性弹性体，全球前21强生产商排名及市场份额.docx
04-30
热塑性弹性体，全球前21强生产商排名及市场份额
配合eclipse svn插件subclipse-4.3.4版本的javahl
04-30
配合eclipse svn插件subclipse-4.3.4版本的javahl，将其中的features和plugins目录解压到与subclipse-4.3.4插件同一目录下即可。在eclipse 4.31版本上验证有效。
go 语言基础实战 pdf
12-04
想要学习Go语言基础实战，我推荐你阅读一本名为《Go语言基础实战》的PDF电子书。这本书涵盖了Go语言的基础知识和实践技巧，适合初学者和有一定编程经验的开发者。 《Go语言基础实战》一书从基本语法和数据类型开始介绍，然后深入讲解了函数、结构体、接口等高级概念。书中还包含了大量实际案例和练习，帮助读者理解和掌握Go语言编程的核心概念。 通过阅读这本书，你将学会如何使用Go语言进行文件操作、网络编程、并发编程等方面的实践技巧。此外，书中还介绍了如何使用Go语言进行Web开发和构建RESTful API，帮助读者在实际项目中运用所学知识。 总的来说，这本《Go语言基础实战》PDF电子书是学习Go语言入门的好资源。它既适合自学，也适合作为教材在学校或培训机构使用。如果你想系统学习和掌握Go语言编程，不妨找一本这样的书来阅读，相信会对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值