Go语言学习基础笔记
2019-06-21 本文已影响0人
TZX_0710
Go
1.声明变量
1.指定变量类型 (variable)
var i int
如果未指定默认值 那么默认值为0
2.自动判断值类型
var i="string";
3.省略var 初始化声明
hello:="spark"
多变量声明
1.指定声明变量的类型 统一类型
var i,k,s,w int
2.声明不同的类型
var (
i int
str string
b bool
)
！！！在同一个作用域当中 不能对变量进行二次初始化 :变量名=v
2.Go语言常量
const关键词 常量声明语法
1.单个常量声明方法 显示声明 const 变量名 变量类型=value
const str string ="100"
2.隐示声明 可省略string 因为会自动推断类型
const str ="100"
const str,str1 int
3.枚举声明
const (
MAN=1
GIRL=0
)
4.特殊常量iota 在const关键词出现时被重置为0 每次出现一次+1可以把iota当作const索引
const(
MAN=iota
MAIN=iota
)
3.运算符
//算术运算符
+ - * / ++ --
//关系运算符 跟Java中的一致
== != > < >= <=
//逻辑运算符
&& || !
4.for循环
//berak关键词 停止当前循环
//goto 跳转到指定的标签
//continue 跳过当前循环
func main() {
//var i="string";
for i:=1; i<=10 ;i++ {
// goto breakHader
if(i==1){
fmt.Println(i)
}else if(i==10){
fmt.Println("执行")
goto breakHader
}else{
if(i==5){
fmt.Println(i)
break;
}
}
}
breakHader:
fmt.Print("Message")
}
5.Go函数
//声明函数
func function_name(param list)(return paramList)
{
//函数体
}
//demo
func GetMaxNum(a ,b int)(int){
//声明一个返回变量
var result int
if(a<b){
result=b;
}else if(b>a){
result=a
}
return result
}
//main函数
//noinspection ALL
func main() {
//var i="string";
var num=GetMaxNum(1,10);
fmt.Print(num)
}
//匿名函数 把一个函数作为方法的返回值
func function_name func()匿名函数返回值//int {
}
func getSequenes() func()int{
var i =0
return func() int{
i++
return i;
}
}
//noinspection ALL
func main() {
sequene := getSequenes()
fmt.Println(sequene())
fmt.Println(sequene())
//var i="string";
//var num=GetMaxNum(1,10);
//fmt.Print(num)
}
6.数组声明
[length]Type
[N]Type{value1, value2, ..., valueN}
[...]Type{value1, value2, ..., valueN} 初始化数组
var 数组名称[] type
//不指定数组长度
var 数组名称=[...]int{1,2,3,4,501}
7.语言指针
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。指针接受的是一个变量的内存地址 如果直接赋值会报错
访问指针中的值 采用 *指针名称
一个指针变量指向了一个值的内存地址。
//输出变量地址
var n [10]int /* n 是一个长度为 10 的数组 */
n[0]=100
fmt.Printf("变量的地址: %x\n", &n[0] )
//声明指针
//声明一个变量
var a=10
//声明指针变量
var i *int
//存储 &a的地址
i=&a
fmt.Printf("a 变量的地址是: %x\n", &a )
/* 指针变量的存储地址 */
fmt.Printf("ip 变量储存的指针地址: %x\n", i )
/* 使用指针访问值 */
fmt.Printf("*ip 变量的值: %d\n", *i )
8.结构体定义
Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
可以理解为是一个对象
定义语法
type sturct_name struct{
filedName type
}
//demo
//noinspection ALL
type Student struct {
title string
name string
age int
Book[] int
}
//声明对象的方法可以采用以下函数
func (stu *Student)GetInfo()(Student)
{
}
//noinspection ALL
func main() {
var studet Student
studet.title="Ubuntu"
studet.name="Mac"
studet.age=18
var boo=[]int{1,2,3,4,50}
studet.Book=boo
fmt.Print(studet)
}
type Student struct {
title string
name string
age int
Book[] int
}
//匿名函数 声明一个对象的专有函数 传入指针类型 表示 可以修改
//
//为Student类型绑定Area的方法，*Rect为指针引用可以修改传入参数的值c (stu *Student) Getage()( *Student){
stu.age=20
return stu
}
//noinspection ALL
func main() {
var stu *Student
var student Student
student.age=19
stu=&student;
//获取得到一个student的地址
i := stu.Getage()
age := i.age
println(age)
}
9.切片
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
切片是一种引用类型
~~ 新获得的切片跟源切片底层对应的数组都是同一个，所以对其中一个切片元素的修改也会影响到另外一个
声明切片语法
make([]type, length, capacity)
make([]type, length)
[]type{}
[]type{value1, value2,..., valueN}
s[n] 切片s中索引位置为n的项
s[n:m] 从切片s的索引位置n到m-1处所获得的切片
s[n:] 从切片s的索引位置到len(s)-1处所获得的切片
s[:m] 从切片s的索引位置0到m-1处所获得的切片
s[:] 从切片s的索引位置0到len(s)-1处获得的切片
var identifier []type
切片初始化
s:=[]int{1,2,3}
/* 创建切片 长度为4 最长长度可以达到4*/
slice := make([]int, 2, 4)
append_slice := []int{1, 2}
fmt.Printf("slice addr:%p len:%d cap:%d slice:%v\n", slice, len(slice), cap(slice), slice)
//追加2个元素 地址未改变
slice = append(slice, append_slice...)
fmt.Printf("slice addr:%p len:%d cap:%d slice:%v\n", slice, len(slice), cap(slice), slice)
//继续追加 地址改变
slice = append(slice, 10, 20)
fmt.Printf("slice addr:%p len:%d cap:%d slice:%v\n", slice, len(slice), cap(slice), slice)
slice = append(slice, 30, 40, 50)
fmt.Printf("slice addr:%p len:%d cap:%d slice:%v\n", slice, len(slice), cap(slice), slice)
slice addr:0xc000052140 len:2 cap:4 slice:[0 0]
slice addr:0xc000052140 len:4 cap:4 slice:[0 0 1 2]
slice addr:0xc00006c140 len:6 cap:8 slice:[0 0 1 2 10 20]
slice addr:0xc00008a000 len:9 cap:16 slice:[0 0 1 2 10 20 30 40 50]
10.创建Map集合
声明map的方式
var hashMap=make(map[keyType]valueType);
var hashMap=make(map[string]string)
hashMap["Lucy"]="张三"
hashMap["Ad"]="Nike"
for k, v := range hashMap {
fmt.Println(k+"\t"+v)
}
//删除函数
delete(hashMap,"Lucy")
for k, v := range hashMap {
fmt.Println(k+"\t"+v)
}
11.类型转换
type_name(exp)
var name=12
var str=string(12)
12.接口定义 实现
demo
//定义一个say的接口
type Say interface {
sayHelloWorld();
}
type sayHello struct {
}
type saySpeak struct {
}
//实现类
func (say sayHello) sayHelloWorld() {
fmt.Println("helloworld")
}
//实现类
func ( saySpeak saySpeak)sayHelloWorld(){
fmt.Println("Nice")
}
func main() {
var say Say
say=new(sayHello)
say.sayHelloWorld();
say=new(saySpeak);
say.sayHelloWorld();
}
13 异常情况
package main
import (
"fmt"
)
// 定义一个 DivideError 结构
type DivideError struct {
dividee int
divider int
}
// 实现 `error` 接口
func (de *DivideError) Error() string {
strFormat := `
Cannot proceed, the divider is zero.
dividee: %d
divider: 0
`
return fmt.Sprintf(strFormat, de.dividee)
}
// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
if varDivider == 0 {
dData := DivideError{
dividee: varDividee,
divider: varDivider,
}
errorMsg = dData.Error()
return
} else {
return varDividee / varDivider, ""
}
}
func main() {
// 正常情况
if result, errorMsg := Divide(100, 10); errorMsg == "" {
fmt.Println("100/10 = ", result)
}
// 当被除数为零的时候会返回错误信息
if _, errorMsg := Divide(100, 0); errorMsg != "" {
fmt.Println("errorMsg is: ", errorMsg)
}
}
