golang_base-开发语言

环境搭建安装 https://golang.org/dl/ https://golang.google.cn/dl/设置环境变量export GOROOT=$PATH:/path/to/go/export PATH=SPATH:$GOROOT/bin/export GOPATH=/home/user/project/go$ go version查询版本运...

环境搭建

安装
https://golang.org/dl/
https://golang.google.cn/dl/

设置环境变量

export GOROOT=$PATH:/path/to/go/

export PATH=SPATH:$GOROOT/bin/

export GOPATH=/home/user/project/go

$ go version
查询版本

运行

$ go run main.go

打包

$ go build main.go

//定义包名
package main
import 'fmt'

func main() {
    var a string='aaa'
    var b int =13
    //Printf  Println  Print
    fmt.Print(a,b)		//aaa13
}

案例

// 建立http服务器
import (
    "net/http"
)

func main() {
    http.Handle("/", http.FileServer(http.Dir(".")))
    http.ListenAndServe(":8080", nil)
}

编译并执行文件 $ go build ./helloworld.go

package main
import (
    "fmt"     // 导入格式化 模块
    "math/rand"    // 导入随机数 模块
    "time"    // 导入时间 模块
)

// 数据生产者
func producer(header string,channel chan <- string)  {
    // 生产数据的函数,传入一个标记类型为字符串及一个只能写入的通道
    // 无限循环,不停的生产数据
    for {
        // 将随机数和字符串格式化为字符串发送通道
        channel <- fmt.Sprintf("%s:%v",header,rand.Int31())
        // 等待一秒
        time.Sleep(time.Second)
    }
}
// 数据消费者
func consumer(channel <- chan string)  {
    // 不停的获取数据
    for {
        // 从通道中取出数据,此处会阻塞直到信道中返回数据
        message := <- channel
        // 打印数据
        fmt.Println(message)
    }
}

func main()  {
    // 创建一个字符串类型的通道
    channel := make(chan string)
    //创建producer函数的并发goroutine(协成)
    go producer("cat",channel)
    go producer("dog",channel)
    // 数据消费函数
    consumer(channel)
}

定义变量

var关键字声明变量后必须使用推断:=

格式 var username string

? var username string ='aaa'

定义常量

// const关键字	定义为 iota 初始化 为0
const (
	n1 = iota
    n2 :=13
)

输出语句

fmt.Print("","")		// 不换行
fmt.Println("","")		// 单独作为一行
fmt.Printf("")			// 格式化输出,
// %v 用后面的变量来替换输出; %T 输出类型
// %c 原样输出;	%d十进制表示; %b二进制表示
// %o八进制

golang数据类型

简单数据类型：整型int 浮点型floor 字符串string 布尔类型boolean

简单/基本数据类型和数组都是值类型！！！！都是值存储—深拷贝

*引用类型 map 和切片slice(和数组相似,有长度和容量) 引用数据类型不能直接声明，要用make()方法或者定义赋值var slice = []int{1,2,3}

slice类型

// 创建一个整型切片			切片的长度 和 容量  len() 和 cap()
// 容量  从第一个元素，到底层数组元素最后一位的个数
// 其长度为 3 个元素，容量为 5 个元素
slice := make([]int, 3, 5)
b := slice[:]	// 获取所有值
c ：= slice[1:3]  // 获取第一位到第四位	切片的切片
// 扩容    对象 = append(对象,值) 元素往后加一，长度和容量都增加, x2
// 深拷贝	copy(对象切片, 新定义的空切片)
// 删除元素  对象 = append()
// a = append(a[:2], a[3:]...)   获取前两项元素 和 第四项往后的元素,去掉第三个

map类型

类似JavaScript中的json对象类型

// 创建map类型
var userInfo = make(map[string]string)
/* var userInfo = map[string]string{
 * "username" : "aaa",
 * "userage"  : "20",
 * }
*/

userInfo["username"] = "aaa"
userInfo["userage"] = "20"

// curd操作  增删改查
// 增加 就是新定义一个，修改也是直接重赋值
// 查找
value,ok := userInfo["username"]     // "aaa",true
// 删除
delete(userInfo，"username")

// map类型的切片
userInfo := make([]map[string]string,3,3)
// 打印   map[age:20 name:aa]

整型

有符号整型按长度分为: int8 int16 int32 int64

无符号整型: unit8 unit16 uint32 uint64

int8 -2^7~27-1 (127) uint8 0~2^8-1 1字节

int16 -2^15~215-1 uint16 0~2^16-1 2字节

int32 -2^31~231-1 uint8 0~2^32-1 4字节

int64 -2^63~263-1 uint8 0~2^64-1 8字节

类型不同不能相加,需要进行转换 int64(a1) + a2

数字字面语法 %d 表示10进制输出 %b表示二进制 %o八进制

unsafe.Sizeof(变量) 表示64位 int64

浮点型

float32 和 float64,两种浮点型数据格式遵循IEEE754标准

float32的最大范围 3.4e38 math.MaxFloat32 表示

float64的最大范围 1.8e308 math.MaxFloat64 表示

%f 输出float %.2f 输出数据保留两位小数

科学计数法表示

浮点数精度丢失问题,在定长条件下,二进制小数和十进制小数转换时损耗

解决办法是使用第三方包,import引入 ‘https://github.com/shopspring/decimal’

布尔类型

1 0;是无法转换的,不能转换成其他类型！！！！

var flag bool = true

字符串类型

转义字符 \r 回车 \n 换行符 \t 制表符 \’ 单引号

字符串操作

len(Str)	// 获取该字符串的长度
fmt.Sprintf("%v %v",Str1,Str2)	// 字符串拼接
strings.Split(Str,"")	// 返回 字符串分割而成的数组
strings.Join(Arr,"")	// 返回 数组用 连接而成的字符串
strings.HasPrefix(Str1,Str2)	// 返回布尔,Str1开头是否包含Str2
strings.HasSutfix(Str1,Str2)
strings.Index(Str1,Str2)	// 返回数值,Str2在Str1第几位

字符类型byte & rune

byte类型,即unit8类型,转换为ASCII码, 单个字母

rune类型,代表了utf-8标准的字样,如一个汉字或者假名

打印出来会被编译,所以要用格式化输出,%c来原样输出
a := "xorld"
byteA := []byte(a)      // 字符型切片
byteA[0] = 'w'
fmt.Printf("%c",byteA)	// [w o r l d]

// **************
b := "地界"
runeB := []rune(b)     // 字符型切片
runeB[0] = '世'
fmt.Printf("%c",runeB)	// [世 界]

// 字符  转字符串
fmt.Println(string(runeB))

数组类型

定义一个有长度的数组 var a [3]int var b [3]string

// 初始化数组,定义和赋值	
var a = [3]int{1,2,3}	
var b = [...]int{1,2,3}         // 数组长度是动态的了
var c = [...]int{0:1,1:9,5:9}	// len(c)  6

var d [3]int     // 定义了数组的长度

// 二维数组		多维数组的表示
var arr = [3][2]string{
 {"aaa","bbb"},
 {"ccc","ddd"},
 {"eee","fff"}
}

// 遍历数组
var sum int = 0
for i := 0; i < len(a);  i++ {
    sum += a[i]
}

数据类型间的转换

整型间的转换;浮点型间的转换从低位往高位转换,减少错误的发生

整型与浮点型之间的转换,用于计算,将整型转换成浮点型

// 将其他类型转string类型
str := fmt.sprintf("%d",i)

// 或者引入 "strconv"包
str1 := strconv.FormatInt(i,10)	// i必须是int64
str2 := strconv.FormatFloat(变量,类型,保留小数点,格式化类型)
// 参数2:	'f'	(-dd.ddd,	   默认)
//		 'b' (-ddddp土ddd,	二进制)
//		 'e' (-d.dde土dd,	十进制)
//		 'g' (指数很大时用e表示)
// 参数3:保留小数点	-1时不做处理
// 参数4:格式化类型	64 或 32
str3 := strconv.FormatBool(true)
str4 := strconv.FormatUint(uint64(a),10)

// string 转换为整型		参数2:进制	参数3:位数
num1 := strocnv.ParseInt(str,10,64)

// string 转换为浮点型	
num2 := strocnv.ParseFloat(str,64)

//bool 可以转字符串，其他不能,其他也不要转布尔

运算符

算术运算符 + - * / % – ++

关系运算符 > == != >= < <=

逻辑运算符 && || ！

赋值运算符 = += -= *=

流程控制

条件语句 if else关键字,条件语句不加括号

循环语句 for 类似js的规则,条件不加括号 // 可以只写条件成立部分-但要防止死循环

range 关键字—迭代器遍历
var str = "abcdef1024"
// 第一个变量 表示index; 第二个变量 字符串中的字符
for k,v := range str {
 fmt.Println("序号是",k,"，数值是",v)
 fmt.Printf("序号是",k,"，数值的码是",v)
}
switch case 条件判断语句

循环中的关键字 continue break goto 跳转到指定地方

引用类型排序算法

封装函数或者引入 "sort"包

// 切片对象   升序排列
sort.Strings(stringObj)
sort.Float64s()
sort.Ints()
// 降序排列  比较狗血！！！
sort.Sort(sort.Reverse(sort.Strings(stringObj)))

结构体

// 类似于  类
// 结构体 是 值类型
// 将一个结构体赋值到另一个变量中，改变值，原来的不变
// 字段 字段类型可以是
type 类型名 struct {
    字段名 字段类型
}

// 结构体 定义 & 创建
type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {

    // 创建一个新的结构体
    fmt.Println(Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407})

    // 也可以使用 key => value 格式
    fmt.Println(Books{title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", book_id: 6495407})

    // 忽略的字段为 0 或 空
   fmt.Println(Books{title: "Go 语言", author: "www.runoob.com"})
    
    // 创建一个实例体
    var Book1 Books
    Books1.title ="R28g6K+t6KiA"
    Book1.author = "www.runoob.com"
   	Book1.subject = "Go 语言教程"
   	Book1.book_id = 6495407
    
    // 第二种实例化的方法
    var p2 =new(Person)
    ...
    // 第三种
    p3 := &person{}
    ...
    // 第四种
    var p4 =person{
        name:"kabuto",
        age:18,
    }
}


// 结构体的匿名字段， 类型不能重复
type Person struct {
    string,
    int,
}

// map类型中有结构体实例

结构体的方法


// 结构体是值类型
type Person struct {
    name 	string
    age		int
}

// 如果定义了引用类型， 还需要用make（）创建
// {...   person: make([]string,3,3)   ...}
func (p Person) printInfo() {
    fmt.Printf("name:%v",p.Name)
}
// 如果是 (p *Person) 则表示对应结构体原型，可以修改原型
func main() {
    var p1 = &Person{
        ...
    }
    p1.printInfo()
}

// 结构体的嵌套	嵌套等于 继承
type Person struct {
    Name	string,
    Age		int,
    Sex		string,
    Adress	Adress,
}
type Adress struct {
    home	    string,
    workplace	string,
}

// 定义   类似于 类class
type Person struct {
    Name	string
}

接口

// 定义
// 接口只是用来规范要定义的内容，
// 要求定义的 结构体必须定义这些方法
type usber interface {
    start()
    stop()
    off()
}

type Person struct { ... }
func (p Person) start() { ... }

func main() {
    p := Person{
        name:"kabuto",
    }
    var p1 usber	// 接口是个类型，再让他等于struct
    p1 = p
}

// 空接口,任何类型都可以接受
type A inerface{}
// 定义一个空接口的变量  可以赋值给任何类型的值， 多用于函数参数 interface{}
// 类型断言
v,ok := a.(string)
if ok {
    fmt.Printf("string类型，值%v",v)
} else {
    fmt.Printf("不是string类型，值%v",v)
}

switch a.(type) {
    case int:
    	fmt.Printf("int类型")
    case string:
    	fmt.Printf("string类型")
    case bool:
    	fmt.Printf("bool类型")
    default:
    	fmt.Printf("传入错误")
}

文件读取

func main() {
    // 只读方式读取文件   打开及关闭文件
    file,err := os.Open("./main.go")
    defer file.Close()	//必须关闭文件流
    if err != nil {
        fmt.Println(err)
        return
    }
    
    // 读取文件的内容
    var strSlice []byte
    var tempSlice = make([]byte,128)
    // 一次读取128个字节内容
    for {
        n,err := file.Read(tempSlice)
        if err != nil {
            fmt.Println("读取失败")
            return
         }
    }
    
    fmt.Println(n)	//n 是代码字节数，tempslice是代码内容
}

传入错误")
}

文件读取

func main() {
    // 只读方式读取文件   打开及关闭文件
    file,err := os.Open("./main.go")
    defer file.Close()	//必须关闭文件流
    if err != nil {
        fmt.Println(err)
        return
    }
    
    // 读取文件的内容
    var strSlice []byte
    var tempSlice = make([]byte,128)
    // 一次读取128个字节内容
    for {
        n,err := file.Read(tempSlice)
        if err != nil {
            fmt.Println("读取失败")
            return
         }
    }
    
    fmt.Println(n)	//n 是代码字节数，tempslice是代码内容
}