精华内容
参与话题
问答
  • go语言核心编程

    2019-07-24 13:55:42
    Go语言核心编程
  • Go语言核心编程.pdf.zip

    2019-06-28 10:54:08
    Go语言核心编程》是一本系统介绍Go 语言编程的书籍。首先介绍Go 语言的基础知识,使读者对Go 语言有一个整体的认知。接着围绕Go 语言的三大语言特性:类型系统、接口和并发展开论述,《Go语言核心编程》不单单介绍...
  • 《尚硅谷韩顺平Go语言核心编程》采用真实案例,源码级深度讲授,全面具体可落地,从理论到实践,一步一步将Go核心编程技术、编程思想、底层实现融会贯通。通过学习本教程,可掌握Go语言编程思想和底层机制,具备真正...
  • Go语言核心编程视频

    2018-08-28 15:47:09
    尚硅谷 Go语言核心编程课程 全套高清视频 希望能帮到大家
  • 接着围绕Go 语言的三大语言特性:类型系统、接口和并发展开论述,《Go语言核心编程》不单单介绍每个语言特性怎么使用,在章节的最后还对重要语言特性的底层实现原理做了介绍。接着介绍反射这个高级语言特征。
  • 本书重点介绍Go语言的实践和并发编程范式,力求让读者不但清楚并发的基本语法和原理,还学会怎么去使用。本书对Go语言规范中的命名类型、非命名类型,底层类型,动态类型等概念进行阐述,让*发者对Go的类型系统有...
  • 尚硅谷 2018 Go语言核心编程课程
  • 尚硅谷的Go语言核心编程课程,讲的挺细致的,可以看看,多学点技术;如果链接过期了,请留言或者私信。
  • 韩顺平讲解Go编程文档,主要是针对GO编程基础以及小案例进行讲解,最重要的是讲解了常见的算法
  • Go语言核心编程_李文塔.pdf
  • Go语言核心编程(二)

    2020-09-24 16:02:56
    指针 基本介绍: 基本数据类型,变量存的就是值,也叫值类型 获取变量的地址,用&,比如:var num int,获取num的地址:&num 指针类型,变量存的是一个地址,这个地址指向的空间存的才是值 ...
    指针

    基本介绍:

    • 基本数据类型,变量存的就是值,也叫值类型
    • 获取变量的地址,用&,比如:var num int,获取num的地址:&num
    • 指针类型,变量存的是一个地址,这个地址指向的空间存的才是值
      比如:var ptr *int=&num
    • 获取指针类型所指向的值,使用:*,比如 var *ptr int,使用 *ptr获取ptr指向的值

    指针细节说明:

    • 值类型,都有对应的指针类型,形式为 *数据类型,比如int的对应的指针就是 *int,float32对应的指针类型就是 *float,依次类推
    • 值类型包括:基本数据类型 int 系列,float系列,bool,string、数组和结构体struct
    值类型和引用类型

    常见的值类型和引用类型:
    1)值类型:基本数据类型int系列,float系列,bool,string、数组和结构体struct
    2)引用类型:指针、slice切片、map、管道chan、interface等都是引用类型

    值类型和引用类型使用特点:
    1)值类型:变量直接存储值,内存通常在栈中分配
    2)引用类型:变量存储的是一个地址,这个地址对应的空间才真正存储数据(值),内存通常在堆上分配,当没有任何变量引用这个地址时,该地址对应的数据空间就成为一个垃圾,由GC来回收

    标识符的命名规范

    标识符概念:
    1)Golang对各种变量、方法等命名时使用的字符序列称为标识符
    2)凡是自己可以起名字的地方都叫标识符

    标识符的命名规则:

    • 由26个英文字母大小写,0-9,_组成
    • 数字不可以开头
    • Golang中严格区分大小写
    • 标识符不能包含空格
    • 下划线“_”本身在Go中是一个特殊的标识符,称为空标识符。可以代表任何其它的标识符,但是它对应的值会被忽略(比如,忽略某个返回值)。所以仅能被作为占位符使用,不能作为标识符使用
    • 不能以系统保留关键字作为标识符,比如break,if等等…

    保留关键字介绍:

    break default func interface select
    case defer go map struct
    chan else goto package switch
    const fallthrough if range type
    continue for import return var

    注:在Go中,如果变量名、函数名、常量名首字母大写,则可以被其他的包访问;如果首字母小写,则只能在本包中使用(可以理解为,首字母大写是公开的,首字母小写是私有的),在golang中没有public,private等关键字。

    预定义标识符:
    除了保留关键字外,Go还提供了36个预定的标识符,其包括基础数据类型和系统内嵌函数

    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
    运算符

    运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等

    • 算术运算符
    • 赋值运算符
    • 比较运算符
    • 逻辑运算符
    • 位运算符
    • 其它运算符

    注:Golang的++和–只能写在变量的后面不能写在变量的前面,即:只有a++,a–没有++a,–a;而且++和–只能独立使用。

    逻辑运算符:
    注意事项和细节说明:
    1)&&也叫短路与:如果第一个条件为false,则第二个条件不会判断,最终结果为false
    2)| | 也叫短路或:如果第一个条件为true,则第二个条件不会判断,最终结果为true

    位运算符
    运算符 描述
    & 按位与运算符“&”是双目运算符,其功能是参与运算的两数各对应的二进位相与。运算规则是:同时为1,结果为1,否则为0
    | 按位或运算符,其功能是参与运算的两数各对应的二进位相或。运算规则是:有一个为1,结果为1,否则为0
    ^ 按位异或运算符,其功能是参与运算的两数各对应的二进位相异或,运算规则是:当二进位不同时,结果为1,否则为0
    << 左移运算符,其功能是把"<<"左边的运算数的各二进位全部左移若干位,高位丢弃,低位补0,左移n位就是乘以2的n次方
    >> 右移运算符,其功能是把">>"左边的运算数的各二进位全部右移若干位,右移n位就是除以2的n次方

    注意:Go语言不支持传统的三元运算符,要用if-else分支来实现。

    键盘输入语句

    在编程中,需要接收用户输入的数据,就可以使用键盘输入语句来获取。
    步骤:
    1)导入fmt包;
    2)调用fmt包的fmt.Scanln()或者fmt.Scanf()
    Scanln()是程序会停止在这里,等待用户输入,并回车;
    Scanf()是可以按指定的格式输入。

    var name string
    var age byte
    var salary float32
    var ispass bool
    fmt.Println("请输入姓名:")
    fmt.Scanln(&name)
    ...
    fmt.Scanf("%s %d %f %t",&name,&age,&salary,&ispass)
    
    原码、反码、补码

    对于有符号的而言:

    • 二进制的最高位是符号位:0表示正数,1表示负数;
    • 正数的原码、反码和补码都一样;
    • 负数的反码=它的原码符号位不变,其他位取反;
    • 负数的补码=它的反码+1;
    • 0的反码,补码都是0;
    • 在计算机运算的时候,都是以补码的方式运算的。
    跳转控制语句goto
    1. Go语言的goto语句可以无条件地转移到程序中指定的行;
    2. goto语句通常与条件语句配合使用,可用来实现条件转移,跳出循环体等功能;
    3. 在Go程序设计中一般不主张使用goto语句,以免造成程序流程的混乱,使理解和调试程序都产生困难。
    fun main(){
    	fmt.Println("ok1")
    	fmt.Println("ok2")
    	goto label
    	fmt.Println("ok3")
    	fmt.Println("ok4")
    	label:
    	fmt.Println("ok5")
    }
    

    函数注意事项:

    • 在Go中,函数也是一种数据类型,可以赋值给一个变量,则该变量就是一个函数类型的变量了,通过该变量可以对函数调用;
    • 函数既然是一种数据类型,因此在Go中,函数可以作为形参,并且调用!
    • 为了简化数据类型定义,Go支持自定义数据类型;
    • 支持对函数返回值命名
    • Go支持可变参数
    func cal(n1 int,n2 int)(sum int,sub int){
    		sum = n1 + n2
    		sub = n1 - n2
    		return
    }
    
    func sum(args...int)sum int{
    }
    func sum(n1 int,args...int)sum int{
    }
    
    init函数

    每一个源文件都可以包含一个init函数,该函数会在main函数执行前,被Go运行框架调用,也就是说init会在main函数前被调用。
    1)如果一个文件同时包含全局变量定义,init函数和main函数,则执行的流程是变量定义——>init函数——>main函数
    2)init函数最主要的作用是,就是完成一些初始化工作。

    匿名函数

    Go支持匿名函数,如果我们某个函数只是希望使用一次,可以考虑使用匿名函数,匿名函数也可以实现多次调用。

    • 匿名函数使用方式1
      在定义匿名函数时就是使用
    func main(){
    	res := func(n1 int,n2 int) int{
    		return n1 + n2
    }(10,20)
    
    • 匿名函数使用方式2
      将匿名函数赋给一个变量(函数变量),再通过该变量来调用匿名函数
    func main(){
    	res := func(n1 int,n2 int) int{
    		return n1 + n2
    }
    a := res(10,20)
    

    全局匿名函数:
    如果将匿名函数赋给一个全局变量,那么这个匿名函数,就成为一个全局匿名函数,可以在程序中有效。

    闭包

    基本介绍:闭包就是一个函数和与其相关的引用环境组合的一个整体(实体)
    闭包最佳实践:
    请编写一个程序,具体要求如下:
    1)编写一个函数makeSuffix(suffix string)可以接收一个文件后缀名(比如.jpg)并返回一个闭包;
    2)调用闭包,可以传入一个文件名,如果该文件名没有指定的后缀(比如.jpg),则返回文件名.jpg,如果已经有.jpg后缀,则返回原文件名;
    3)要求使用闭包的方式完成;
    4)strings.HasSuffix.
    在这里插入图片描述
    代码说明:
    1)返回的函数和makeSuffix(suffix string)的suffix变量和返回的函数组合成一个闭包,因为返回的函数引用到suffix这个变量;
    2)闭包的好处:如果使用传统的方法,也可以轻松实现这个功能,但是传统方法需要每次都传入后缀名,比如.jpg,而闭包因为可以保留上次引用的某个值,所以传入一次就可以反复使用。
    在这里插入图片描述

    函数中-defer

    为什么需要defer?
    在函数中,程序员经常需要创建资源(比如:数据库连接、文件句柄、锁等)为了在函数执行完毕后,及时的释放资源,Go的设计者提供defer(延时机制)
    在这里插入图片描述
    程序输出的结果顺序是:
    1)res=30
    2)ok2 n2=20
    3)ok1 n1=10
    当执行到defer时,暂时不执行,会将defer后面的语句压入到独立的栈(defer栈),当函数执行完毕后,再从defer栈,按照先入后出的方式出栈,执行。

    defer细节说明:
    1)当go执行到一个defer时,不会立即执行defer后的语句,而是将defer后的语句压入到一个栈中,然后继续执行函数下一语句;
    2)当函数执行完毕后,在从defer栈中,依次从栈顶中取出语句执行;
    3)在defer将语句放入到栈时,也会将相关的值拷贝同时入栈。
    注:defer之后相关变量仍然可以继续使用。(defer file.close() defer connect.close())

    函数参数的传递方式

    两种传递方式:
    1)值传递
    2)引用传递
    其实,不管是值传递还是引用传递,传递给函数的都是变量的副本,不同的是,值传递的是值的拷贝,引用传递的是地址的拷贝。一般来说,地址拷贝效率高,因为数据量小,而值拷贝决定拷贝的数据大小,数据越大,效率越低。

    值类型:基本数据类型int系列、float系列、bool,string、数组和结构体struct
    引用类型:指针、slice切片、map、管道chan、interface等都是引用类型

    变量作用域

    说明:
    1)函数内部声明/定义的变量叫局部变量,作用域仅限于函数内部;
    2)函数外部声明/定义的变量叫全局变量,作用域在整个包都有效,如果其首字母为大写,则作用域在整个程序有效;
    3)如果变量是在一个代码块,比如for /if 中,那么这个变量的作用域就在该代码块。

    字符串中常用的函数

    说明:字符串在我们程序开发中,使用的是非常多的“:
    1)统计字符串的长度,按字节len(str)
    2)字符串遍历,同时处理有中文的问题r:=[]rune(str)
    3)字符串转整数:n,err:=strconv.Atoi(“12”)
    4)整数转字符串:str=strconv.Itoa(12345)
    5)字符串转[]byte:var bytes=[]byte{“hello go”}
    6)[]byte转字符串:str=string([]byte{97,98,99})
    7)10进制转2,8,16进制:str=strconv.FormatInt(123,2)
    8)查找子串是否在指定的字符串中:strings.Contains(“seafood”,“foo”)
    9)统计一个字符串有几个指定的子串:strings.Count(“ceheese”,“e”)
    10)不区分大小写的字符串比较(==是区分字母大小写的):fmt.Println(strings.EqualFold(“abc”,“Abc”))
    11)返回子串在字符串第一次出现的index值,如果没有返回-1:strings.Index(“NIL_abc”,“abc”)
    12)返回子串在字符串最后一次出现的index,如没有返回-1:strings.LastIndex[“go golang”,“go”]
    13)将指定的子串替换成另外一个子串:strings.Replace(“go go hello”,“go”,“go语言”,n)n可以指定你希望替换几个,如果n=1表示全部替换
    14)按照指定的某个字符,为分割标识,将一个字符串拆分成字符串数组
    15)将字符串的字母进行大小写的转换:strings.ToLower(“Go”)
    16)将字符串左右两边的空格去掉:strings.TrimSpace(" to huhj jioj “)
    17)将字符串左右两边指定的字符去掉:strings.Trim(” ! hello!","!")
    18)将字符串左边指定的字符去掉:strings.TrimLeft("! hello !","!")
    19)将字符串右边指定的字符q去掉:strings.TrimRight("! hello !","!")
    20)判断字符串是否以指定的字符串开头:strings.HasPrefix(“ftp://192.168.10.1”,“ftp”)
    21)判断字符串是否以指定的字符串结束:strings.HasSuffix(“NIL_abc.jpg”,“abc”)

    … …
    查看官方文档:https://studygolang.com/pkgdoc

    Go错误处理机制

    基本说明:
    1)Go语言追求简洁优雅,所以,Go语言不支持传统的try…catch…finally这种处理;
    2)Go中引入的处理方式为:defer,panic,recover
    3)这几个异常的使用场景可以简单描述:Go中可以抛出一个panic的异常,然后在defer中通过recover捕获这个异常,然后正常处理
    在这里插入图片描述

    数组和切片

    四种初始化数组的方式:

    1. var num [3]int = [3]int{1,2,3}
    2. var num = [3]int{1,2,3}
    3. var num = […]int{1,2,3}
    4. var num = […]int{1:99,0:100,2:9}

    数组的遍历:
    1.常规遍历
    2.for-range遍历
    for index,value := range array{
    }

    切片——golang中一种特有的数据类型

    为什么需要切片?
    比如我们需要一个数组用于保存学生的成绩,但是学生的个数是不确定的,就可以使用切片来解决。
    基本介绍:
    1)切片——slice
    2)切片是数组的一个引用,因此切片是引用类型,在进行传递时,遵守引用传递的机制
    3)切片的使用和数组类似,遍历切片、访问切片的元素和求切片长度len(slice)都一样
    4)切片的长度是可以变化的,因此切片是一个可以动态变化的数组
    5)切片定义的基本语法:
    var 变量名 []类型
    比如:var a []int

    type slice struct{
    ptr *[2]int
    len int
    cap int
    }
    切片的使用:
    1.定义一个切片,然后让切片去引用一个已经创建好的数组;
    2.通过make来创建切片。
    基本语法:
    var 切片名[] type = make([],len,[cap])
    参数说明:type就是数据类型 len:大小 cap:指定切片容量(即最大可以存放多少个元素),可选
    3)定义一个切片,直接就指定具体数组,使用原理类似make的方式:var num []int=[]int{1,2,3}

    方式1和方式2的区别:
    方式1是直接引用数组,这个数组是事先存在的,程序员是可见的;
    方式2是通过make来创建切片,make也会创建一个数组,是由切片在底层进行维护,程序员是看不见的。
    在这里插入图片描述
    注:切片定义完后,还不能使用,因为本身是一个空的,需要让其引用到一个数组,或者make一个空间供切片来使用。

    string和slice

    1)string底层是一个byte数组,因此string也可以进行切片处理
    2)string和切片在内存的形式
    3)string是不可变的 ,也就是说不能通过str[0]='z’方式来修改字符串
    4)如果需要修改字符串,可以先将string——>[]byte修改重写转成string

    排序的介绍

    排序的分类:
    1)内部排序:
    指将需要处理的所有数据都加载到内部存储器中进行排序:
    包括交换式排序法、选择式排序法、插入式排序法
    2)外部排序法:
    数据量过大,无法全部加载到内存中,需要借助外部存储进行:
    包括合并排序法和直接合并排序法

    交换式排序法

    交换式排序属于内部排序法,是运用数据值比较后,依判断规则对数据位置进行交换,以达到排序的目的。
    交换式排序法又可分为两种:
    1)冒泡排序法
    2)快速排序法

    查找

    在golang中,我们常用的查找有两种:
    1)顺序查找;
    2)二分查找(该数组是有序的);

    二维数组的使用

    使用方式:先声明/定义再赋值
    1)语法:var 数组名[大小][大小]类型
    2)比如:var arr [2][3]int,再赋值
    3)二维数组在内存的存在形式(重点)

    使用方式2:直接初始化
    1)声明:var 数组名[大小][大小]类型=[大小][大小]类型{{初值…},{初值…}}
    2)赋值(有默认值,比如int 类型的就是0)
    3)说明:二维数组在声明/定义时也对应有四种写法[和一维数组类似]

    二维数组的遍历:
    1)双层for循环完成遍历
    2)for-range方式完成遍历

    map

    map介绍:
    map是key-value数据结构,又称为字段或者关联数组,类似其它编程语言的集合,在编程中是经常用到。
    基本语法:
    var map变量名 map[keytype]valuetype
    key可以是什么类型?
    golang中的map的key可以是很多种类型,比如bool,数字,string,指针,channel,还可以是只包含前面几个类型的接口、结构体、数组
    通常为int,string

    注意:slice,map还有function不可以,因为这几个没法用 == 来判断

    map声明的简单举例:
    var a map[string]string
    var a map[string]int
    var a map[int]string
    var a map[string]map[string]string
    注意:声明是不会分配内存的,初始化需要make,分配内存后才能赋值和使用。

    func main(){
    	var a map[string]string
    	a = make(map[string]string,10)
    	a["no1"] = "宋江"
    	fmt.Println(a)
    }
    

    或者在声明的时候直接赋值:

    func main(){
    	var a map[string]string = map[string]string(
    	"NO1":"宋江",
    	)
    	a["No2"] = "武松"
    }
    

    map遍历:
    说明:map的遍历使用for-range的结构遍历
    map切片:
    切片的数据类型如果是map,则我们称为slice of map,map切片,这样使用则map个数就可以动态变化了。

    func main(){
    	var monsters []map[string]string
    	monsters = make([]map[string]string,2)
    	if monsters[0] == nil{
    		monsters[0] = make(map[string]string,2)
    		monsters[0]["name"] = "monster1"
    		monsters[0]["age"] = "500"
    	}
    }
    

    下面用到切片的append函数,可以动态的增加monster

    newMonster := map[string]string(
    	"name":"monster2",
    	"age":1000,
    	)
    newMonster = append(monsters,newMonster)
    

    map排序:
    1)golang中没有一个专门的方法针对map的key进行排序
    2)golang中的map默认是无序的,注意也不是按照添加的顺序存放的,你每次遍历,得到的输出可能不一样
    3)golang中map的排序,是先将key进行排序,然后根据key值遍历输出即可

    如果按照map的key的顺序进行排序输出:
    1.先将map的key放到切片中
    2.对切片排序
    3.遍历切片,然后按照key来输出map

    var keys []int
    for k,_ :range map1{
    	keys = append(keys,k)
    }
    #排序
    sort.Intskeys(keys)
    for _,k :range keys{
    	fmt.Println(k,map1[k])
    }
    
    

    map使用细节:
    1)map是引用类型,遵守引用类型传递的机制,在一个函数接收map,修改后,会直接修改原来的map
    2)map的容量达到后,再想map增加元素,会自动扩容,并不会发生panic,也就是说map能动态的增长键值对(key-value)
    3)map的value也经常使用struct类型,更适合管理复杂的数据,比如value为Student结构体
    在这里插入图片描述

    展开全文
  • Go语言核心编程(一)

    2020-09-19 16:09:28
    Golang核心编程: 区块链(去中心化,让人人都可以参与数据库的记录)研发工程师 Go服务器端(美团)/游戏软件工程师 Golang分布式/云计算软件工程师(京东) Go语言,我们可以简单的写成Golanguage,简写为Golang...

    Golang学习方向

    Golang核心编程:

    • 区块链(去中心化,让人人都可以参与数据库的记录)研发工程师
    • Go服务器端(美团)/游戏软件工程师
    • Golang分布式/云计算软件工程师(京东)

    Go语言,我们可以简单的写成Golanguage,简写为Golang。

    Golang的应用领域

    • 区块链应用开发
    • 后端服务器应用
    • 云计算/云服务后台应用

    Go语言概述

    程序:为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合。
    2009年11月10日,Google将Go语言以开放源代码的方式向全球发布;
    2015年8月19日,Go1.5版发布,本次更新中移除了“最后残余的C代码”。
    Go语言的特点:
    Go语言保证了既能达到静态编译语言的安全和性能,又达到了动态语言开发维护的高效率,Go语言既有C静态语言程序的运行速度,又能达到Python动态语言的快速开发。

    1. 从C语言中继承了很多理念,包括表达式语法,控制结构,基础数据类型,调用参数传值,指针等,也保留了和C语言一样的编译运行方式及弱化的指针;
    2. 引入包的概念,用于组织程序结构,Go语言的一个文件都要归属于一个包,而不能单独存在;
    3. 垃圾回收机制,内存自动回收,不需开发人员管理;
    4. 天然并发:
      1) 从语言层面支持并发,实现简单;
      2) goroutine,轻量级线程,可实现大并发处理,高效利用多核;
      3) 基于CPS并发模型实现。
    5. 吸收了管道通信机制,形成Go语言特有的管道channel
      通过管道channel,可以实现不同的goroute之间的相互通信
    6. 函数返回多个值
    7. 新的创新:比如切片、延时执行defer等

    Go环境配置

    下载SDK和去官网下载Go的安装程序,直接傻瓜安装即可。
    之后进入到解压后的SDK的压缩包,SDK解压后会看到一个go文件夹,进入到该文件夹下的bin目录,并进入控制台命令(windows),若输入go version可看到go版本的输出信息,即证明go安装成功,但注意为了以后的使用方便,还需进一步地配置Go的环境变量,这里只针对windows进行配置说明:

    GOROOT E:\Go\
    GOPATH D:\goproject
    path E:\Go\bin %GOROOT%\bin

    根据自己Go和SDK的安装目录按上面进行配置即可,之后重新打开windows的控制台窗口,这次无需进入go的bin目录,输入go version也能看到安装的go的版本了。大功告成!

    windows下开发步骤:

    1. 安装windows版本 VScode
    2. 将Go代码编写到扩展名为hello.go的文件中
      [说明:源码在工作目录src/go_code下,如d:/goproject/src/go_code]
    3. 通过go build命令对该go文件进行编译,生成.exe文件
    4. 在dos命令行下执行.exe文件就可以看到运行效果
    5. 注意:通过go run命令可以直接运行hello.go程序[类似执行一个脚本文件的格式]

    注意:如果对go程序文件进行编译运行时出现以下错误的话:

    import cycle not allowed 
    package main
    imports fmt
    imports errors
    import int
    

    首先代码可能是没问题的,这时唯一的解决办法就是…重装go了…

    Golang执行流程分析:
    如果是对源码编译后,再执行,Go的执行流程如下图:
    在这里插入图片描述
    如果我们是对源码直接执行go run 源码,Go的执行流程如下图:

    在这里插入图片描述

    Golang执行流程分析:

    说明:两种执行流程的方式区别

    1. 如果我们先编译生成了可执行文件,那么我们可以将该可执行文件拷贝到没有go开发环境的机器上,仍然可以运行;
    2. 如果我们是直接go run go源代码,那么如果要在另外一个机器上这么运行,也需要go开发环境,否则无法执行;

    什么是编译?
    1) 有了go源文件,通过编译器将其编译成机器可以识别的二进制文件;
    2)在该源文件目录下,通过go build对hello.go文件进行编译。可以指定生成的可执行文件名,在windows下必须是.exe后缀;

    go build -o myhello.exe hello.go
    

    3)如果程序没有错误,没有任何提示,会在当前目录下出现一个可执行文件;
    4)如果程序有错误,编译时,会在错误的那行报错。

    Go程序开发注意事项(重点)

    1)Go源文件以"go"为扩展名
    2)Go应用程序的执行入口是main()方法
    3)Go语言严格区分大小写
    4)Go方法由一条条语句构成,每个语句后不需要分号(Go语言会在每行后自动加分号),这也体现出Golang的简洁性
    5)Go编译器是一行一行进行编译的,因此我们一行就写一条语句,不能把多条语句写在同一个,否则报错
    6)go语言定义的变量或者import的包如果没有使用到,代码不能编译通过;
    7)大括号都是成对出现的,缺一不可。

    Golang常用的转义字符
    1. \t:一个制表位,实现对齐的功能
      2)\n:换行符
      3)\:一个
      4)":一个"
    2. \r:一个回车 fmt.Println(“hello world!\rzahngsan”)

    Golang官方网站:https://golang.org
    Golang API官方文档:https://golang.org/pkg
    Golang 中文网 在线标准库文档:https://studygolang.com/pkgdoc

    Go——变量

    变量相当于内存中的一个数据存储空间的表示,你可以把变量看作是一个房间的门牌号,通过门牌号我们可以找到房间,同样的道理,通过变量名可以访问到变量(值)。
    变量使用的基本步骤:
    1)声明变量
    2)赋值
    3)使用
    在这里插入图片描述

    变量中的使用事项:

    • 变量表示内存中的一个存储区域;
    • 该区域有自己的名称(变量名)和类型(数据类型);
    • Golang变量使用的三种方式:
      1)指定变量类型,声明后若不赋值,使用默认值
      2)根据值自行判定变量类型
      3)省略var,注意:=左侧的变量不应该是已经声明过的,否则会导致编译错误
    • 多变量声明:在编程中,有时我们需要一次性声明多个变量,Golang也提供这样的语法
    var num1,num2,num3 int
    
    num1,name,num2 := 10,"zhangsan",22
    
    • 该区域的数据值可以在同一类型范围内不断变化
    • 变量在同一个作用域内不能重名
    • 变量=变量名+值+数据类型
    • Golang的变量如果没有赋初值,编译器会使用默认值,比如int默认值0,string默认值为空串

    变量的数据类型:
    每一种数据都定义了明确的数据类型,在内存中分配了不同大小的内存空间。
    在这里插入图片描述
    整型的类型:

    类型 有无符号 占用存储空间 表数范围 备注
    int8 1字节 -128~127
    int16 2字节 -2^15~ 2^15-1
    int32 4字节 -2^31 ~ 2^31-1
    int64 8字节 -2^43 ~ 2^43-1
    类型 有无符号 占用存储空间 表数范围 备注
    uint8 1字节 0~255
    uint16 2字节 0~2^16-1
    uint32 4字节 0~2^32-1
    uint64 8字节 0~2^64-1
    类型 有无符号 占用存储空间 表数范围 备注
    int 32位系统4个字节、64位系统8个字节 -2^31 ~ 2^31-1、-2 ^63 ~ 2^63-1
    uint 32位系统4个字节、64位系统8个字节 0~2^32-1 、0~ 2^64-1
    rune 与int32一样 - 2^31 ~2^31-1 等价int32,表示一个Unicode码
    byte 与uint8等价 0~255 当要存储字符时选用byte

    整型的使用细节:
    1)Golang各整数类型分:有符号和无符号,int uint的大小和系统有关;
    2)Golang的整型默认声明为int型
    3)如何在程序查看某个变量的字节大小和数据类型;

    unsafe.Sizeof(n1)
    

    4)Golang程序中整型变量在使用时,遵守保小不保大的原则,即:在保证程序正确运行下,尽量使用占用空间小的数据类型;
    5)bit:计算机中的最小存储单位,byte:计算机中基本存储单元。

    浮点型的分类:

    类型 占用存储空间 表数范围
    单精度float32 4字节 -3.403E38~3.403E38
    双精度float64 8字节 -1.798E308~1.798E308

    其中,浮点数=符号位+指数位+尾数位,浮点数都是有符号的。

    浮点型使用细节:

    • Golang浮点类型有固定的范围和字段长度,不受具体OS的影响

    • Golang的浮点型默认声明float64类型

    • 浮点型常量有两种表示形式:
      十进制数形式、科学计数法形式

    • 通常情况下,应该使用float64,因为它比float32更精确

    字符类型:
    字符串就是一串固定长度的字符连接起来的字符序列,Go的字符串是由单个字节连接起来的,也就是说对于传统的字符串是由字符组成的,而Go的字符串不同,它是由字节组成的

    func main(){
    	var c1 byte = 'a'
    	var c2 byte = '0'
    	var c3 int = '北'
    	fmt.Println("c1=",c1,"c2=",c2)
    	fmt.Println("c1=%c c2=%c",c1,c2)
    	fmt.Println("c3=%c",c3)
    

    如果我们保存的字符在ASCII表,比如[0-1,a-z,A-Z],直接可以保存到byte;
    如果我们保存的字符对应码值大于255,这时可以考虑使用uint保存;
    如果我们需要按照字符的方式输出,这时需要格式化输出,fmt.Printf(“c1=%c”,c1)

    字符串注意事项和使用细节:

    • Go语言的字符串的字节使用UTF-8编码标识Unicode文本,这样Golang统一使用UTF-8编码

    • 字符串一旦赋值了,字符串就不能修改了,在Go中字符串是不可变的

    • 字符串的两种表示形式:
      (1)双引号,会识别转义字符
      (2)反引号,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击、输出源代码等效果

    • 字符串拼接方式

    • 当一行字符串太长时,需要使用到多行字符串

    布尔类型:

    • 布尔类型也叫bool类型,bool类型数据只允许取值true和false
    • bool类型占1个字节
    • boolean类型适于逻辑运算,一般用于程序流程控制

    基本数据类型的转换:
    Golang和java/c不同,Go在不同类型的变量之间赋值时需要显式转换,也就是说Golang中数据类型不能自动转换

    func main(){
    	var i int32 = 100
    	var n1 float32 = float32(i)
    

    注:被转换的是变量存储的数据(即值),变量本身的数据类型并没有变化!而且,在转换中,比如将int64转成int8,编译不会报错,只是转换的结果是按溢出处理的,和我们希望的结果不一样

    基本数据类型和string的转换:
    方式一:fmt.Sprintf("%参数",表达式)
    方式二:使用strconv包的函数(string类型转基本数据类型也可用)
    具体细节使用内容可以查看手册:
    https://studygolang.com/pkgdoc

    展开全文
  • 文章目录3.1 变量快速入门案例3.2 变量使用注意事项3.3 程序中+号的使用3.4 数据类型的基本介绍3.4.1 整数类型3.4.2 小数类型/浮点型3.4.3 字符类型3.4.4 布尔类型3.4.5 string类型3.5 基本数据类型的默认值3.6 基本...

    3.1 变量快速入门案例

    package main
    import "fmt"
    
    func main() {
        //定义变量/声明变量
        var i int
        //给i赋值
        i = 10
        //使用变量
        fmt.Println("i=", i)
    }
    

    3.2 变量使用注意事项

    • 变量表示内存中的一个存储区域

    • 该区域有自己的名称(变量名)和类型(数据类型)
      在这里插入图片描述

    • Golang变量使用的三种方式

      • 第一种:指定变量类型,声明后若不赋值,使用默认值
      • 第二种:根据值自行判定变量类型(类型推导
      • 第三种:省略var,注意::=左侧的变量不应该是已经申明过的,否则会导致编译错误
    package main
    import "fmt"
    
    func main() {
       //golang变量使用的方式1:指定变量类型,声明后若不赋值,使用默认值(0)
       var i int
       fmt.Println("i =", i) //输出:i = 0
       //golang变量使用的方式2:根据值自行判定变量类型(类型推导)
       var num = 10.11
       fmt.Println("num =", num)
       //golang变量使用的方式3:省略var,注意:":="左侧的变量不应该是已经申明过的,否则会导致编译错误
       //var name string name = "tom"
       // := 不可以省略,否则错误
       name := "tom"
       fmt.Println("name =", name)
    }
    
    • 多变量声明
      在编程中,有时我们需要一次性声明多个变量,Golang也提供这样的语法。
    package main
    
    import "fmt"
    
    //定义全局变量
    var n8 = 100
    var n9 = 200
    var name3 = "jack"
    //上面的声明方式,也可以改成一次性声明
    var (
       n10 = 300
       n11 = 400
       name4 = "mary"
    )
    
    func main() {
       //golang一次性声明多个变量
       //方式1
       var n1, n2, n3 int
       fmt.Println("n1 =", n1, "n2 =", n2, "n3 =", n3) //n1 = 0 n2 = 0 n3 = 0
       //方式2
       var n4, name1, n5 = 100, "tom", 888 // = 前后一对一赋值
       fmt.Println("n4 =", n4, "name1 =", name1, "n5 =", n5) //n4 = 100 name1 = tom n5 = 888
       //方式3
       n6, name2, n7 := 100, "tom", 888
       fmt.Println("n6 =", n6, "name2 =", name2, "n7 =", n7) //n6 = 100 name2 = tom n7 = 88
    
       //输出全局变量
       fmt.Println("n8 =", n8, "name3 =", name3, "n9 =", n9) //n8 = 100 name3 = jack n9 = 200
       fmt.Println("n10 =", n10, "name4 =", name4, "n11 =", n11) //n10 = 300 name4 = mary n11 = 400
    }
    
    • 该区域的数据值可以在同一类型范围内不断变化
    • 变量在同一个作用域(在一个函数或者代码块)内不能重名
    • 变量=变量名+值+数据类型
    • Golang的变量如果没有赋初值,编译器会使用默认值,比如int默认值0,string默认值为空串,小数默认为0

    3.3 程序中+号的使用

    • 当左右两边都是数值型时,则做加法运算
    • 当左右两边都是字符串,则做字符串拼接

    3.4 数据类型的基本介绍

    在这里插入图片描述
    说明:官方中将string也作为基本数据类型,韩老师讲课中是将其分开的。

    3.4.1 整数类型

    • 整数的类型
    类型 有无符号 占用存储空间 表示范围
    int8 1字节 -128~127
    int6 2字节 215-2^{15} ~ 21512^{15}-1
    int32 4字节 231-2^{31} ~ 23112^{31}-1
    int64 8字节 263-2^{63} ~ 26312^{63}-1
    • int的无符号类型
    类型 有无符号 占用存储空间 表示范围
    unit8 1字节 0~255
    unit16 2字节 0~ 21612^{16}-1
    unit32 4字节 0~ 23212^{32}-1
    unit64 8字节 0~ 26412^{64}-1
    • int的其他类型—整型的类型
    类型 有无符号 占用存储空间 表示范围 备注
    int 32位系统4个字节 231-2^{31} ~ 23112^{31}-1
    64位系统8个字节 263-2^{63} ~ 26312^{63}-1
    unit 32位系统4个字节 0 ~ 23212^{32}-1
    64位系统8个字节 0 ~ 26412^{64}-1
    rune 与int32一样 231-2^{31} ~ 23112^{31}-1 等价int32,表示一个Unicode码
    byte 与unit8等价 0~255 当存储字符时,选用byte
    • 整型的使用细节
      • Golang各整数类型分:有符号和无符号,int unit的大小和系统有关
      • Golang的整型默认声明为int型
      • 如何在程序查看某个变量的字节大小和数据类型
    package main
    
    import (
       "fmt"
       "unsafe"
    )
    
    func main() {
       var n int64 = 10
       fmt.Printf("n 的类型 %T n占有的字节数是 %d ", n, unsafe.Sizeof(n)) //n 的类型 int64 n占有的字节数是 8
    }
    
    • Golang程序中整型变量在使用时,遵守保小不保大的原则,即:在保证程序正确运行下,尽量使用占用空间小的数据类型

    3.4.2 小数类型/浮点型

    • 小数类型
    类型 占用存储空间 表数范围
    单精度float32 4字节 -3.403E38~3.403E38
    双精度float64 8字节 -1.798E308~1.798E308
    • 浮点型使用细节
      • 浮点型的存储分为三部分:浮点数=符号位+指数位+尾数位。存储过程中,尾数部分可能丢失,造成精度损失(如果需要保存一个精度高的数,应该选用float64
      • Golang浮点类型有固定的范围和字段长度,不受具体OS的影响
      • Golang的浮点数默认声明为float64类型
      • 浮点型chang’l常量有两种表示形式
        • 十进制数:如:5.12 .512(必须有小数点)
        • 科学计数法:如:5.1234e2=5.1234×1025.1234e2=5.1234 \times 10^25.12e12=5.12/1025.12e12=5.12 / 10^2
      • 通常情况下,应该使用float64,因为它比float32更精确。

    3.4.3 字符类型

    Golang中没有专门的字符类型,如果要存储单个字符(字母),一般使用byte来保存。Golang中的字符串是由字节组成的(传统的字符串是由字符组成的,而Golang中的字符是由字节保存,故Golang字符串是由字节组成的)。

    package main
    import "fmt"
    
    func main() {
       //演示golang中字符类型使用
       var c1 byte = 'a'
       var c2 byte = '0' //字符的0
       //当我们直接输出byte值,就是输出了对应字符的码值
       fmt.Println("c1 =", c1) //c1 = 97
       fmt.Println("c2 =", c2) //c2 = 48
       //如果我们希望输出对应字符,需要使用格式化输出
       fmt.Printf("c1 = %c, c2 = %c", c1, c2) //c1 = a, c2 = 0
    
       var c3 byte = '北'
       fmt.Printf("c3 = %c", c3) //overflow溢出
       var c4 int = '北'
       fmt.Printf("c4 = %c, c4对应码值 = %d", c4, c4) //c4 = 北, c4对应码值= 21271
    }
    
    • 上述代码说明:
      • 如果我们保存的字符在ASCII表可以直接保存到byte(即一个字节即可表示)
      • 如果我们保存的字符对应码值大于255(如汉字),我们可以考虑使用int类型保存
      • 如果我们需要按照字符的方式输出,那么我们可以格式化输出:fmt.Printf("%c",c)
    • 字符类型使用细节
      • 字符常量是用单引号’括起来的单个字符。如:var c byte = 'a'
      • Go中允许使用转义字符’'来将其后的字符转变为特殊字符型常量。如:var c char = '\n'
      • Go语言的字符使用UTF-8编码:英文字母1个字节,汉字3个字节
      • 在Go中,字符的本质是一个整数,直接输出的是该字符对应的UTF-8编码的码值(所以需要格式化输出)。
      • 可以直接给某个变量赋一个数字,然后按格式化输出%c会输出该数字对应的unicode字符。
      • 字符类型是可以进行运算的,相当于一个整数,因为它都对应有unicode码。如,var n1 = 10 + 'a',n1即107。
    • 字符类型本质
      • 字符型存储到计算机中,需要将字符对应的码值(整数)找出来
        存储:字符–>对应码值–>二进制–>存储
        读取:二进制–>码值–>字符–>读取
      • 字符和码值的对应关系是通过字符编码表决定的
      • Go语言的编码统一成了utf-8

    3.4.4 布尔类型

    布尔类型占1个字节,适用于逻辑运算。

    3.4.5 string类型

    Go的字符串是由单个字节连接起来的,Go语言的字符串的字节使用utf-8编码表示unicode文本。

    • string使用注意事项和细节
      • Go语言的字符串的字节使用utf-8编码表示unicode文本,中文乱码不会产生。
      • Go中字符串是不可变的:一旦赋值了,字符串就不能被修改。
      • 字符串的两种表示形式:
        • 双引号"",会识别转义字符
        • 反引号``,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击、输出源代码等效果
      • 字符串拼接方式var str = "hello" + "world" str+= " haha!"
      • 当一个拼接操作太长时,可以分行写,但是需要将+保留在上一行

    3.5 基本数据类型的默认值

    在Go中,默认值又叫零值。

    数据类型 默认值
    整型 0
    浮点型 0
    字符串 “”
    布尔类型 false

    3.6 基本数据类型的相互转换

    Go和Java/c不同,在不同类型的变量之间赋值时需要显式转换,不能自动转换。
    基本语法:T(v),T是目标数据类型,v是需要转换的变量。如:float32(i)。

    • 注意事项
      • Go中,数据类型的转换可以是:表示范围小–>表示范围大,也可以是:表示范围大–>表示范围小。
      • 被转换的是变量存储的数据(即值),变量本身的数据类型并没有变化。
      • 在转换时,比如将int64转为int8,编译时不会报错,只是转换结果按照溢出处理,和我们希望的结果不一样,所以转换时需要考虑范围

    3.7 基本数据类型和string的转换

    再次强调,官方将string作为基本数据类型,但是韩老师讲课中是分开的。

    • 基本类型转string类型
      • fmt.Sprintf("%参数",表达式)
      • 使用strconv包的函数
        func FormatBool(b bool) string
        func FormatFloat(f float64, fmt btye, prec, bitSize int) string
        func FormatInt(i int64, base int) string
        func FormatUnit(i unit64, base int) string
    package main
    
    import (
       "fmt"
       "strconv"
    )
    
    func main() {
       var num1 int = 99
       var num2 float64 = 23.456
       var b bool = true
       var myChar byte = 'h'
       var str string
    
       //方法一:使用fmt.Sprintf方法
       str = fmt.Sprintf("%d", num1)
       fmt.Printf("str type %T str = %v\n", str, str) //str type string str = 99
       str = fmt.Sprintf("%f", num2)
       fmt.Printf("str type %T str = %v\n", str, str) //str type string str = 23.456000
       str = fmt.Sprintf("%t", b)
       fmt.Printf("str type %T str = %v\n", str, str) //str type string str = true
       str = fmt.Sprintf("%c", myChar)
       fmt.Printf("str type %T str = %v\n", str, str) //str type string str = h
    
       //方法二:使用strconv包的函数
       var num3 int = 99
       var num4 float64  = 23.456
       var b2 bool = true
    
       str = strconv.FormatInt(int64(num3), 10)
       fmt.Printf("str type %T str = %v\n", str, str) //str type string str = 99
       str = strconv.FormatFloat(num4, 'f', 10, 64) //'f'格式,10小数保留位数,64表示float64
       fmt.Printf("str type %T str = %v\n", str, str) //str type string str = 23.4560000000
       str = strconv.FormatBool(b2)
       fmt.Printf("str type %T str = %v\n", str, str) //str type string str = true
    
       //strconv包中海油一个函数Itoa
       var num5 int = 4567
       str = strconv.Itoa(num5)
       fmt.Printf("str type %T str = %v\n", str, str) //str type string str = 4567
    }
    
    • string类型转基本类型
      • 使用strconv包的函数
        func ParseBool(str string)(value bool, err error)
        func ParseFloat(str string, bitSize int)(f float64, err error)
        func ParseInt(str string, base int, bitSize int)(i int64, err error)
        func ParseUnit(str string, b int, bitSize int)(n unit64, err error)
      • 注意事项
        string转成基本数据类型时,要确保string类型能够转成有效的数据,否则Go会将其直接转为零值。如将"hello"转成一个整数那么得到的是0,同理float=>0,bool=>false。
    package main
    import (
       "fmt"
       "strconv"
    )
    
    func main() {
       var str string = "true"
       var b bool
       b, _ = strconv.ParseBool(str)
       //strconv.ParseBool(str)会返回两个值(value bool, err arror),第二个error我们不关心,直接使用_
       fmt.Printf("b type %T, b = %v\n", b, b) //b type bool, b = true
    
       var str2 string = "12345"
       var n1 int64
       var n2 int
       n1, _ = strconv.ParseInt(str2, 10, 64)
       n2 = int(n1)
       fmt.Printf("n1 type %T, n1 = %v\n", n1, n1) //n1 type int64, n1 = 12345
       fmt.Printf("n2 type %T, n2 = %v\n", n2, n2) //n2 type int, n2 = 12345
    
       var str3 string = "123.456"
       var f1 float64
       f1, _ = strconv.ParseFloat(str3, 64)
       fmt.Printf("f1 type %T, f1 = %v\n", f1, f1) //f1 type float64, f1 = 123.456
    }
    

    3.8 指针

    • 基本介绍
      • 基本数据类型,变量存的就是值,也叫值类型
      • 获取变量的地址,用&。如:var num int,获取num的地址:&num
      • 指针类型,指针变量存的是一个地址,这个地址指向空间存的才是值。如:var ptr *int = &num
      • 获取指针类型所指向的值,使用:*。如:var ptr *int,用*ptr获取ptr指向的值
    package main
    import "fmt"
    
    func main() {
       var num int = 10
       fmt.Println(&num) //0xc0000b4008
       var ptr *int = &num //ptr是一个指针变量,ptr的类型是指向int的指针*int,ptr本身的值是&i
       fmt.Println(*ptr) //10
       //通过指针来修改值,但是不会修改指针地址
       *ptr = 100
       fmt.Println(*ptr) //100
       fmt.Println(ptr) //0xc0000b4008
    }
    
    • 指针的使用细节
      • 值类型,都有对应的指针类型,形式为*数据类型,如*int, *float32
      • 值类型包括:基本数据类型:int系列、float系列、bool、string、数组和结构体struct

    3.9 值类型和引用类型

    • 值类型和引用类型的说明
      • 值类型:基本数据类型:int系列、float系列、bool、string、数组和结构体struct。
      • 引用类型:指针、slice切片、map、管道chan、interface等都是引用类型。
    • 值类型和引用类型的使用特点
      • 值类型:变量直接存储值,内存通常在栈中分配。
      • 引用类型:变量存储的是一个地址,这个地址对应的空间才真正存储数据,内存通常在堆上分配,当没有任何变量应用这个地址时,该地址对应的数据空间就成为一个垃圾,由GC来回收。

    3.10 标识符的命名规范

    • 标识符概念
      Golangg对各种变量、方法、函数等命名时使用的字符序列称为标识符。
    • 命名规则
      • 由26个英文字母大小写,0-9,_组成。
      • 数字不可以开头。
      • Golang中严格区分大小写。
      • 标识符不能包含空格。
      • 下划线“_”本身在Go中是一个特殊的标识符,称为空标识符,可以代表任何其他的标识符,但是它对应的值会忽略(如:忽略某个返回值)。所以仅能被作为占位符使用,不能作为标识符使用
      • 不能以系统保留关键字作为标识符(共25个)。
    • 标识符命名注意事项
      • 包名:保持package的名字和目录保持一致,尽量采取有意义的包名,剪短有意义,不要和标准库冲突。
      • 变量名、函数名、常量名:采用驼峰命名法。
      • 如果变量名、函数名、常量名首字母大写,则可以被其他的包访问;如果首字母小写,则只能在本包中使用。(可以简单地理解为,首字母大写是公开的,首字母小写是私有的),在Go中没有public、private关键字。
    • 系统保留关键字
      在这里插入图片描述
    • 系统的预定义标识符在这里插入图片描述
    展开全文
  • 文章目录4.1 运算符的基本介绍4.1.1 算术运算符4.1.2 关系运算符(比较运算符)4.1.3 逻辑运算符4.1.4 赋值运算法4.1.5 位运算符4.1.6 其他运算符4.1.7 运算符的优先级4.2 键盘输入语句 4.1 运算符的基本介绍 ...

    4.1 运算符的基本介绍

    运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等,有算术运算符、赋值运算符、比较运算符/关系运算符、逻辑运算符、位运算符、其他运算符。

    4.1.1 算术运算符

    运算符 运算 范例 结果
    + 正号 +3 3
    - 负号 -4 -4
    + 5 + 5 10
    - 6 - 4 2
    * 3 * 4 12
    / 5 / 5 1
    % 取模(取余) 7 % 5 2
    ++ 自增 a=2 a++ a=3
    自减 a=2 a– a=1
    + 字符串相加 “he” + “llo” “hello”
    • 注意事项
      • 对于除号"/",它的整数除和小数除是有区别的:整数之间做除法时,只保留整数部分而舍弃小数部分。如:x:=19/5结果是3。
      • 当对一个数取模时,可以等价a%b=a-a/b*b
      • Go自增自减只能当做一个独立语言使用,不能写成a = i++if i++ >0这种
      • Go的++和–只能写在变量的后面,不能写在变量的前面
      • Go的设计者去掉c/java的自增自减容易混淆的写法

    4.1.2 关系运算符(比较运算符)

    运算符 运算 范例 结果
    == 相等于 4==3 false
    != 不等于 4!=3 true
    < 小于 4<3 false
    > 大于 4>3 true
    <= 小于等于 4<=3 false
    >= 大于等于 4>=3 true
    • 注意事项
      • 关系运算符的结果都是bool型,也就是要么true,要么false
      • 关系运算符组成的表达式,称为关系表达式

    4.1.3 逻辑运算符

    运算符 描述
    && 逻辑与运算符
    || 逻辑或运算符
    ! 逻辑非运算法
    • 注意事项
      • &&也叫短路与:如果第一个条件为false,则第二个条件不会判断,最终结果为false
      • ||也叫短路或:如果第一个条件为true,则第二个条件不会判断,最终结果为true

    4.1.4 赋值运算法

    运算符 描述
    = 将表达式的值赋给一个左值
    += 相加后再赋值
    -= 相减后再赋值
    *= 相乘后再赋值
    /= 相除后再赋值
    %= 求余后再赋值
    <<= 左移后赋值
    >>= 右移后赋值
    &= 按位与后赋值
    ^= 按位异或后赋值
    |= 按位或后赋值
    • 注意事项
      • 运算顺序从右往左
      • 赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值

    4.1.5 位运算符

    运算符 描述
    & 按位与运算符是双目运算符,其功能是参与运算的两数各自对应的二进制相与。
    | 按位或运算符是双目运算符,其功能是参与运算的两数各自对应的二进制相或。
    ^ 按位异或运算符是双目运算符,其功能是参与运算的两数各自对应的二进制相异或。
    << 左移运算符是双目运算符,其功能把<<左边的运算数的各二进制全部左移若干位,高位丢弃,低位补0。左移n为就是乘以2的n次方。
    >> 右移运算符是双目运算符,其功能把>>左边的运算数的各二进制全部右移若干位,低位溢出,符号位不变,并用符号位补溢出的高位。右移n为就是除以2的n次方。

    4.1.6 其他运算符

    运算符 描述 实例
    & 返回变量存储地址 &a:将给出变量的实际地址
    * 指针变量 *a:是一个指针变量
    • 说明:Go语言明确不支持三元运算符

    4.1.7 运算符的优先级

    在这里插入图片描述

    4.2 键盘输入语句

    • 步骤
      • 导入fmt包
      • 调用fmt包的fmt.Scanln()或fmt.Scanf()函数
        • func Scanln(a …interface{}) (n int, err error):类似Scan,但会在换行时才停止扫描,最后一个条目后必须有换行或者到达结束位置。
        • func Scanf(format string, a …interface{}) ( n int, err error):Scanf从标准输入扫描文本,根据format参数指定的格式将成功读取的空白分割的值保存进成功传递给本函数的参数。返回成功扫描的条目个数和遇到的任何错误。
    package main
    
    import "fmt"
    
    func main() {
       //方式1:fmt.Scanln
       var name string
       var age int
       var sal float32
       var isPass bool
       fmt.Println("请输入姓名:")
       fmt.Scanln(&name)
       fmt.Println("请输入年龄:")
       fmt.Scanln(&age)
       fmt.Println("请输入薪水:")
       fmt.Scanln(&sal)
       fmt.Println("请输入是否通过考试:")
       fmt.Scanln(&isPass)
       fmt.Printf("名字是 %v \n年龄是 %v \n薪水是 %v \n是否通过考试 %v \n", name, age, sal, isPass)
    
       //方式2:fmt.Scanf,可以按指定的格式输入
       fmt.Println("请输入你的名字、年龄、薪水、是否通过考试,使用空格隔开")
       fmt.Scanf("%s %d %f %t", &name, &age, &sal, &isPass)
       fmt.Printf("名字是 %v \n年龄是 %v \n薪水是 %v \n是否通过考试 %v \n", name, age, sal, isPass)
    }
    
    展开全文
  • Go语言核心编程---09Map

    2020-05-18 11:41:49
    文章目录9.1 map的基本介绍9.2 map的声明9.3 map的使用9.4 map的增删改查操作9.5 map遍历9.6 map切片9.7 map排序9.8 map使用细节 9.1 map的基本介绍 map是key-value数据结构,又称为字段或者关联数组。...
  • Go语言核心编程》一书正式上市

    千次阅读 2018-10-09 15:05:01
    市面上几乎所有的图书我都会购来阅读,但是总是感觉缺少一本讲述Go语言的三大核心:类型系统、接口、并发的图书,这么多年过去了,一直没有人写,最后我决定动手写一本这个主题的图书,书名叫《Go语言核心编程》。...
  • 下载地址:百度网盘
  • 学习的视频参考b站上尚硅谷韩顺平老师的Go语言核心编程。 1.1 Golang的学习方向 Go语言,可以简单地写成Golang。 Golang学习方向: 区块链研发工程师 Go服务器端/游戏软件工程师 Golang分布式/云计算软件...
  • 文章目录2.1 Go语言的特点2.2 Go语言开发工具(Mac版本)2.3 Golang执行流程分析2.4 Go程序开发注意事项2.5 Go语言的转义字符2.6 Golang中的注释形式2.7 规范的代码风格2.8 Golang标准库API文档 2.1 Go语言的特点 Go...
  • 文章目录5.1 程序流程控制5.1.1 顺序控制5.1.2 分支控制5.1.3 循环控制5.2 跳转控制语句 5.1 程序流程控制 ...说明:Go语言中,{}的位置只能有一种情况({不能另起一行),且不能省略,否则会出错。因为
  • 文章目录8.1 排序8.1.1 排序的介绍8.1.2 冒泡排序8.2 查找8.2.1 二分查找8.3 二维数组8.3.1 使用方式8.3.2 二维数组的遍历 8.1 排序 8.1.1 排序的介绍 排序的分类: 内部排序:将需要处理的所有数据都加载到内部...

空空如也

1 2 3 4 5 ... 20
收藏数 543
精华内容 217
关键字:

go语言核心编程