go初级

程序:
为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合.

API:
是Golang提供的基本编程接口,go语言提供了大量的标准库,因此google公司也为这届标准库提供的响应的API文档,用于高速开发者如何使用这些标准库,以及标准库包含的方法.

绝对路径:从当前盘的最上面开始定位,比如D:test100
相对路径:从当前位置开始定位,去找对应的目录.比如:

转义字符"":

/转义字符的使用"\"
    //"\t"  tab键 
    fmt.Println("小红\t小刚")
    //"\n"  换行
    fmt.Println("小红\n小刚")
    //"\\"  转成普通字符
    fmt.Println("\\Users\\bryme\\Desktop\\amd\\src")
    //"\r"  回车键:,从当前行的最前面开始输出,覆盖掉以前的内容
    fmt.Println("我是你爸爸\r不是")

整体缩进调整(格式化)

Bryme-2:aa bryme$ gofmt 临时.go 
package main

import "fmt"

func main() {
        //转义字符的使用"\"
        //"\t"  tab键
        fmt.Println("小红\t小刚")
        //"\n"  换行
        fmt.Println("小红\n小刚")
        //"\\"  转成普通字符
        fmt.Println("\\Users\\bryme\\Desktop\\amd\\src")
        //"\r"  回车键:,从当前行的最前面开始输出,覆盖掉以前的内容
        fmt.Println("我是你爸爸\r不是")
        fmt.Println("姓名\t年龄\t籍贯\t住址\njohn\t12\t河北\t北京\t")
}
Bryme-2:aa bryme$ gofmt -w 临时.go   //将格式化的内容重新写入到文件

变量:
变量如果没有赋初值,编译器会使用默认值,int为0,string为空字符串,

var a int               //声明一个整形变量(默认值为0)
var b int  = 10         //定义一个变量
c := 10                 //自动推到类型
a,b,c,d := 1,2,3,4       //多重赋值
a,b = b,a                //数据交换(go语言独有)
fmt.Printf("%3d",a)      //保留三位整数,超过三位,全部输出
fmt.Printf("%.4f",a)       //保留小数点后四位,会对第四位四舍五入
float32                 //默认保留小数后7位有效数字
float64                 //默认保留小数后15位有效数字
var str string = "我是你大哥"    //go语言中一个汉字算作3个字符(在linux中一样)
num := len(str)
const a  = 10       //类型可以省略不写

//一次性声明多个变量的方式1
    var n1,n2,n3 int
    fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)

    //一次性声明多个变量的方式2
    var n1,n2,n3 = 100,"tom",888
    fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)

"+"号:
当两边都是数值型时,则作加法运算
当两边都是字符串时,则做字符串拼接

func main() {
    var str1 = "hello"
    var str2 = "world"
    var res = str1 + str2
    fmt.Println("res=",res)
}

枚举:

const(              //枚举
   a = 10           //定义时可以赋值(初始值为0)
   b,c =iota,iota   //在同一行值相同,换一行值加一
   d                //值+1
   e                //值+1
)
```tian
表达式:

b = a-- //不能将自增自减运用在表达式中(go语言独有)
整形的类型:
int 有符号整形,32位系统占4个字节,64位系统占8个字节
uint 无符号整形,32位系统占四个字节,64位系统占8个字节
rune 与int32一样,用于中文字符串
浮点数:
1)浮点数都是有符号的
2)位数部分可能丢失,造成精度损失,flo64的精度比float32的要准确如果我们要保存一个精度高的数,则应该选用float64
3)浮点型的精度不收操作系统的影响,float默认是float64类型
字符型:
在go中,字符的本质是一个整数,直接输出时,是该字符对应的UTF-8编码的码值
可以直接给某个变量赋一个数字,然后按格式化输出%c,会输出该数字对应的unicode字符

    var c4 int = 22269
    fmt.Printf("c4=%c\n",c4)

字符类型是可以进行运算的,相当于一个整数,运输时是按照码值运行的

var n1 = 10 +'a'
    fmt.Println("n1=",n1)

字符类型是可以进行运算的,相当于一个整数,因为它都对应有Unicode码

var n1 = 10 +'a'
    fmt.Println("n1=",n1)

bool类型:
不可以用0或非0的整数代替false和true,这点和c语言不通

var b = false
    fmt.Println("b=",b)
    //bool类型占用储存空间是1个字节.bool类型只能取true或者false
    fmt.Println("b 的占用空间 =",unsafe.Sizeof(b))

字符串类型:

//字符串一点赋值了,字符串就不能修改了:在go字符串是不吭呢改变的
    //字符串的两种表示形式:
    //1.双引号,会识别转义字符
    //2.反引号,会以字符串的原生形式输出,包括换行和特殊字符,可以实现防止共计.输出源代码等效果
    str2 := "abc\nabc"
    str3 := `abcd\nabc`
    fmt.Println(str2,str3)

//字符串的拼接

//当一个拼接的操作很长时,怎么办,可以分行写,但是注意,西药将+保留在上一行.
    str4 := "操作很"+"操作很"+ 
    "操作很"+"操作很"+ 
    "操作很"+"操作很" + 
    "操作很"+"操作很"
    fmt.Println(str4)

基础类型的默认值:

var a int //0
    var b float32
    var c float64
    var isMarried bool
    var name string
    //v表示安装变量的值来输出
    fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v",a,b,c,isMarried,name)

类型转换:
1)go中,数据类型的转换可以从表示范围小-->表示范围大,也可以范围大-->范围小
2)被转换的是变量储存的数据,(即值),变量本身的数据类型并没有变化
3)在转换中,比如将int64转成int8(-128--127),编译时不会报错,只是转换的结果是按溢出处理,和我们希望的结果不一样
4)只用同一类型数据类型的数字,才可以进行运算

int(b)     //数据类型转换

百分号格式:

通用：

%v  值的默认格式表示
%+v 类似%v，但输出结构体时会添加字段名
%#v 值的Go语法表示
%T  值的类型的Go语法表示
%%  百分号
布尔值：

%t  单词true或false
整数：

%b  表示为二进制
%c  该值对应的unicode码值
%d  表示为十进制
%o  表示为八进制
%q  该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
%x  表示为十六进制，使用a-f
%X  表示为十六进制，使用A-F
%U  表示为Unicode格式：U+1234，等价于"U+%04X"
浮点数与复数的两个组分：

%b  无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat
%e  科学计数法，如-1234.456e+78
%E  科学计数法，如-1234.456E+78
%f  有小数部分但无指数部分，如123.456
%F  等价于%f
%g  根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
%G  根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）
字符串和[]byte：

%s  直接输出字符串或者[]byte
%q  该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%x  每个字节用两字符十六进制数表示（使用a-f）
%X  每个字节用两字符十六进制数表示（使用A-F）    
指针：

%p  表示为十六进制，并加上前导的0x    

把基础类型转换为string类型:
1)fmt.Sprintf方法:

var num1 int = 99
    var num2 float64 = 23.456
    var b bool 
     var mychar byte = 'h'
    var str string //空的str
    //使用第一种凡是来转换 fmt.Sprintf方法把其他数据转换成string
    str = fmt.Sprintf("%d",num1)
    fmt.Printf("str type %T str=%v\n",str,str)

    str = fmt.Sprintf("%f",num2)
    fmt.Printf("str type %T str=%v\n",str,str)

    str = fmt.Sprintf("%t",b)
    fmt.Printf("str type %T str=%v\n",str,str)

    str = fmt.Sprintf("%c",mychar)
    fmt.Printf("str type %T str=%v\n",str,str)

2)strconv.Format方法:

//第二种方式 strconv 函数
    var num3 = 99
    var num4 float64 = 23.455
    var b2 bool = true

    str = strconv.FormatInt(int64(num3),10)
    fmt.Printf("str type %T str=%q\n",str,str)

    //strconv.FormatFloat(num4,'f',10,64)
    //'f':代表格式,'10':代表小数位保留10位,'64':代表这个小数是float64
    str = strconv.FormatFloat(num4,'f',10,64)
    fmt.Printf("str type %T str=%q\n",str,str)

    str = strconv.FormatBool(b2)
    fmt.Printf("str type %T str=%q\n",str,str)

3)strconv.Itoa方法:

//第三种方式strconv.Itoa
    var num5 int = 23556
    str = strconv.Itoa(num5)
    fmt.Printf("str type %T str=%q\n",str,str)

字符串类型转成基本类型:
将string类型转成基本数据类型时,要确保string类型能够转成有效的数据,比如我们可以吧"123"转成一个整数,但是不能把"hello"转成一个整数,如果这样做,golang将直接将其转成0

strconv.Parse方法

var str string = "true"
    var b bool
    //说明;
    //strconv.ParseBool(str)函数会返回两个值(value bool ,err error)
    b,_ = strconv.ParseBool(str)
    fmt.Printf("b type %T b=%v\n",b,b)

    var str2 string = "12345"
    var n1 int64
    var n2 int
    n1,_ = strconv.ParseInt(str2,10,64)
    n2 = int(n1)
    fmt.Printf("b type %T n1=%v\n",n1,n1)
    fmt.Printf("b type %T n2=%v\n",n2,n2)

    var str3 = "123.435"
    var f1 float64
    f1,_ = strconv.ParseFloat(str3,64)
    fmt.Printf("b type %T f1=%v\n",f1,f1)

指针类型:
1)值类型,都有对应的指针类型,形式为数据类型,比如int的对应的指针就是int,float32对应的指针类型就是 *float32,依次类推.

//指针类型:
    var i int = 10
    //取出i的地址
    fmt.Println("i的地址=",&i)
    //ptr为指针类型的变量,可以储存内存地址,其指向的值为i的值
    var ptr *int = &i
    fmt.Printf("ptr=%v\n",ptr)
    fmt.Printf("ptr 的地址=%v\n",ptr)
    fmt.Printf("ptr 指向的值=%v\n",*ptr)

标识符的案列:

hello    //ok
hello2    //ok
1hello    //error,不能以数字开头
h-b    //error,不能使用
x  h    //error,不能含有空格
h_4    //ok
_ab    //ok
int    //ok,最好不要这样使用,容易造成误会
float32    //ok,最好不要这样使用,容易造成误会
_      //error
Abc    //ok

运算符:
1)对于除号"/",它的整数除和小数除是有区别的,整数之间做除法时,只保留整数部分而舍弃小数部分.列如:x:19/5,结果是3
2)当对一个数取模时,可以等价a%b=a-a/b*b,这样我们可以看到取模的一个本质运算.
3)Golang的自增自减只能当做一个独立语言是用来时,不能这样使用.b:=a++ 或者b:=a--
4)Golang的++和--只能写在变量的后面,不能写在变量的前面,没有++a和--a

//取模"%"的使用:
    fmt.Println("10%3=",10%3)   //=1
    fmt.Println("-10%3=",-10%3) //=-1
    fmt.Println("10%-3=",10%-3) //=1
    fmt.Println("-10%-3=",-10%-3)   //-1

逻辑运算符:
&&: 并且,两边的操作都是true,则为true,否则为False
||: 或者,如果两边的操作有一个是true,则为true,否则为false
!: 不,否,如果条件为true,则逻辑为false,如果条件为false,则逻辑为true
复合赋值的操作:

a := 2
    //复合赋值的操作
    a +=17//相当于a = a + 17
    fmt.Println("a=",a)

赋值运算符的特点:
1)运算顺序是从右往左
2)赋值运算符的左边只能是变量,而右边可以是变量,表达式,常量.
3)复合赋值运算符等于a = a + 3
运算符的优先级一览表:

image.png

在golang中没有三元运算的效果,如果想要实现的话,可以用if语句俩实现:

var n int
    var i int = 10
    var j int = 20
    //传统的三元运算
    //n = i > j ? i :j
    if i > j{
        n = i
    }else{
        n = j
    }
    fmt.Println("n=",n)

获取控制台输入的数据:

var name string
    var age byte
    var sal float32
    var isPass bool
    fmt.Println("请输入姓名")
    //当程序执行到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)

golang中的进制>>>>>>>>>>>>>>>>>>>>>>>>>>
1)二进制:0和1,满2进1
在golang中,不能直接使用二进制来表示一个整数,它沿用了c的特点
2)十进制:0-9,满10进1
3)八进制:0-7,满8进1,以数字0开头表示.
4)十六进制:0-9及A-F,满16进1,以0x或0X开头表示,A-F不区分大小写.

var i int = 5
    //转为二进制输出
    fmt.Printf("%b \n",i)

    //八进制:0-7,满8进1,以数字0开头
    var j int = 011
    fmt.Println("j=",j)

    //十六进制,满16进1,以0x或0X开头表示
    var k int = 0x11
    fmt.Println("k=",k)

进制之间的转换>>>>>>>>>>>>>>>>>>>>>>
二进制转十进制:

image.png

switch语句:

switch a {      //switch中不能使用浮点型数据(浮点型数据是一个约等于数据)
default:        //如果输入的值没有满足条件进入默认选项
}

this指针:

//在go语言中有一句话"go语言中没有隐藏的this指针"

//我们要操作的这个对象它是显示传递的,没有像是其他语言一样被隐藏起来

//操作对象的时候不一定为要叫做this

//操作对象的时候不一定要非使用指针

for循环:

for{
    fmt.Println("hello")
    continue            //结束本次执行,继续下次循环
    break               //跳出循环(如果在多重循环中使用,则跳出当前循环)
    }

函数:

   test2(a[0:]...)         //如果函数为不定参数,传递方式为a[0;]