ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

golang_base

2021-04-11 23:32:15  阅读:119  来源: 互联网

标签:string int fmt golang 类型 base go var


环境搭建

安装
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 -27~27-1 (127) uint8 0~2^8-1 1字节

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

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

int64 -263~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 ="Go 语言"
    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是代码内容
}

标签:string,int,fmt,golang,类型,base,go,var
来源: https://blog.csdn.net/weixin_43543530/article/details/115609403

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有