Go基础1

Posted 骑着哈哥去旅行

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Go基础1相关的知识,希望对你有一定的参考价值。

目录

变量

声明变量

有名变量

匿名变量

常量

常量的声明及基本使用

iota

关于iota的面试题及使

基本数据类型

整形

特殊整形

数字字面量语法

浮点数

布尔型

 字符串

字符串转义

定义多行字符串

byte和rune类型

修改字符串

类型转换

fmt.Printf中的占位符

输出类型


Go是静态编译型语言 。Go和C语言类似,要先编译再执行,即编译型语言。Python、JavaScript等是动态解释型语言Go最大的优势:天生支持并发

变量

Go语言中的变量必须先声明再使用,并且在此变量的整个生命周期内,此变量的类型不可以改变。

声明变量

Go语言中推荐使用驼峰式命名规范。

有名变量

单个变量的声明:

var s1 string  // 单个变量声明

多个变量同时的声明:

var (
	name string
	age int
	sex bool
)
package main

import "fmt"

// 单独声明变量(全局变量)
/*
var name string
var age int
var isOk bool
*/

// 批量声明变量类型(全局变量)
var (
	name string // ""
	age  int    // 0
	sex bool   // false
)

func main() 
	name = "hepengli"
	age = 18
	sex = true

	fmt.Print("You are young \\n")        // 打印完成直接结束(\\n表示换行)
	fmt.Printf("You are young:%s\\n", name) // %s表示格式化输出
	fmt.Println(age, sex)               // 打印完成自带换行


You are young 
You are young:hepengli
18 true

其他声明变量的方式:

package main

import "fmt"

func main() 
	var hobby string = "eating" // 声明变量同时赋值
	fmt.Println(hobby)

	var like = "sleeping" // 推导型声明变量(根据值判断该变量是什么类型)
	fmt.Println(like)

	st1 := "hpl" // 简短型声明变量(只能在函数中使用)
	fmt.Println(st1)



eating
sleeping
hpl

匿名变量

_(下划线)表示匿名变量,不会占用命名空间,不会为其分配内存地址

package main

import "fmt"

func foo() (int, string) 
	return 18, "hpl"


func main() 
	x, _ := foo() // _表示匿名变量,不会占用命名1空间,不会为其分配内存地址
	_, y := foo()

	fmt.Println("x =", x)
	fmt.Println("y =", y)

注意事项:

  1. 函数外的每个语句都必须以关键字开始(var、const、func等)

  2. :=不能在函数外面使用

  3. _多表示占位,表示忽略值

  4. 同一个作用域不能声明同名的变量名

注意:

Go语言中声明的局部变量必须要被使用,否则编译就会报错。

 例如错误如下:

package main

func main() 
	var hobby string



.\\变量.go:4:6: hobby declared but not used

常量

常量的声明及基本使用

package main

import "fmt"

// 常量,定义了常量之后就是不能变化的
const num = 3.14

// 批量的声明常量
const (
	num1 = 10
	num2 = 20
)

// 假如批量声明的常量后面没有赋值,则表示等于上一行变量值
const (
	num3 = 30
	num4
	num5
)

func main() 
	fmt.Println(num3, num4, num5)

	num6 := 666
	fmt.Println(num6)


30 30 30
666

iota

iota是Go语言中的常量计数器,只能在常量的表达式中使用。

iota在const关键字出现时将被重置为0,const中每新增一行常量声明将使iota计数一次(iota可以理解为const语句中的索引)。使用iota能简化定义,在定义枚举时很有用。

package main

import "fmt"

const (
	a1 = iota // 表示a1为0
	a2        // 1
	a3        // 2
	a4        // 3
)

func main() 
	fmt.Println(a1, a2, a3, a4)



0 1 2 3

关于iota的面试题及使

  1. package main
    
    import "fmt"
    
    const (
    	a1 = iota // 表示a1为0
    	a2        // 1
    	_         // 2
    	a4        // 3
    )
    
    func main() 
    	fmt.Println(a1, a2, a4)
    
    
  2. package main
    
    import "fmt"
    
    const (
    	a1 = iota // 表示a1为0
    	a2 = 100
    	a3 // 100
    	a4 // 100
    	a5 = iota
    	a6
    )
    
    func main() 
    	fmt.Println(a1, a3, a4, a5, a6)
    
    
  3. package main
    
    import "fmt"
    
    // 多个常量声明在一行
    const (
    	a1, a2 = iota + 1, iota + 2
    	a3, a4 = iota + 1, iota + 2
    )
    
    func main() 
    	fmt.Println(a1, a2, a3, a4)
    
    
  4. package main
    
    import "fmt"
    
    // 定义数量级
    const (
    	_  = iota             // 扔掉
    	KB = 1 << (10 * iota) // 左移(1*2^10)
    	MB = 1 << (10 * iota) // 1*2^20
    	GB = 1 << (10 * iota) // 1*2^30
    	TB = 1 << (10 * iota) // 1*2^40
    	PB = 1 << (10 * iota) // 1*2^50
    )
    
    func main() 
    	fmt.Println(KB, MB, GB, TB, PB)
    
    

基本数据类型

Go语言中有丰富的数据类型,整形、浮点型、布尔型、字符串、数组、切片、结构体、map、通道(channel)等。Go语言的基本数据类型和其他的语言基本大同小异。

整形

类型描述
uint8无符号的8位整型(0~255)
uint16无符号的16位整型(0~65535)
uint32无符号的32位整型(0~4294967295)
uint64无符号的64位整型(0~18446744073709551615)
int8有符号的8位整型(-128~127)
int16有符号的16位整型(-32768~32767)
int32有符号的32位整型(-2147483648~2147483647)
int64有符号的64位整型(-92233720368644775808~92233720368644775807)

特殊整形

类型描述
uint32位操作系统上就是uint32,64位操作系统上就是uint64
int32位操作系统上就是int32,64位操作系统上就是int64
uintptr无符号整型,用于存放一个指针

注意: 在使用intuint类型时,不能假定它是32位或64位的整型,而是考虑intuint可能在不同平台上的差异。

数字字面量语法

Go1.13版本之后引入了数字字面量语法,这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字,例如:v := 0b00101101, 代表二进制的 101101,相当于十进制的 45。 v := 0o377,代表八进制的 377,相当于十进制的 255。 v := 0xff,代表十六进制的ff,也就是十进制的255。

package main

import "fmt"

func main() 
	a1 := 0b111 // 1*2^0 + 1*2^1 + 1*2^2 = 7
	a2 := 0o637 // 7*8^0 + 3*8^1 + 6*8^2 = 415
	a3 := 0xff  // 0b 1111 1111  ==> 255
	fmt.Println(a1)
	fmt.Println(a2)
	fmt.Println(a3)

浮点数

Go语言支持两种浮点型数:float32float64。这两种浮点型数据格式遵循IEEE 754标准: float32 的浮点数的最大范围约为 3.4e38,可以使用常量定义:math.MaxFloat32float64 的浮点数的最大范围约为 1.8e308,可以使用一个常量定义:math.MaxFloat64

package main

import (
	"fmt"
	"reflect"
)

func main() 
	// math.MaxFloat32 // 浮点数32位1最大值
	f1 := 1.23 // Go中默认定义的是float64类型
	fmt.Print(f1, reflect.TypeOf(f1))


1.23 float64

注意:Go中默认定义的是float64类型

布尔型

Go语言中以bool类型进行声明布尔型数据,布尔型数据只有true(真)false(假)两个值。

注意:

  1. 布尔类型变量的默认值为false

  2. Go 语言中不允许将整型强制转换为布尔型.

  3. 布尔型无法参与数值运算,也无法与其他类型进行转换。

package main

import "fmt"

func main() 
	a1 := true
	var a2 bool // 布尔值默认为false

	fmt.Println(a1, a2)


true false

 字符串

注意:Go中的字符串必须用双引号,Go语言中的单引号表示为字符

s := "hpl"  // 字符串

// 单独的字符、汉字、符号等就是一个字符
s1 := 'a'  // 字符
s2 := '和'  // 字符

字符串转义

转义符含义
\\r回车符(返回行首)
\\n换行符(直接跳到下一行的同列位置)
\\t制表符
\\'单引号
\\"双引号
\\\\反斜杠
package main

import "fmt"

func main() 
	str1 := "D:\\\\Learning_notes\\\\note\\\\GO\\\\go基础"
	fmt.Printf("%#v\\n", str1)
	str2 := "'D:\\\\Learning_notes\\\\note\\\\GO\\\\go基础'"
	fmt.Println(str2)

     
"D:\\\\Learning_notes\\\\note\\\\GO\\\\go基础"
'D:\\Learning_notes\\note\\GO\\go基础'

定义多行字符串

package main

import "fmt"

func main() 
	s2 := `
		   静夜思
		   唐 李白
		  床前明月光,
		  疑似地上霜。
		  举头望明月,
		  低头思故乡。`
	fmt.Printf(s2)



		   静夜思
		   唐 李白
		  床前明月光,
		  疑似地上霜。
		  举头望明月,
		  低头思故乡。

注意:反引号中写什么就输出什么,不用担心转义问题。

方法介绍
len(str),len([]rune(str)),utf8.RuneCountInString(str)求长度
+或fmt.Sprintf拼接字符串
strings.Split分割
strings.contains判断是否包含
strings.HasPrefix,strings.HasSuffix前缀/后缀判断
strings.Index(),strings.LastIndex()子串出现的位置
strings.Join(a[]string, sep string)join操作
package main

import (
	"fmt"
	"strings"
)

func main() 
	name := "hepengli"
	hobby := "sleeping"
	fmt.Println(len(name)) // len()输出长度
	fmt.Println("xxx" + "yyy")
	s1 := fmt.Sprintf("%s%s", name, hobby) // 拼接并返回
	fmt.Println(s1)

	web := "www.baidu.com"
	ret := strings.Split(web, ".") // 切割 [www baidu com]
	fmt.Println(ret)

	res := strings.Contains(web, "ww")   // 判断web字符串中是否包含ww,包含返回true,不包含返回false
	res1 := strings.Contains(web, "xxx") // 判断web字符串中是否包含xxx,包含返回true,不包含返回false
	fmt.Println(res, res1)

	res2 := strings.HasPrefix(web, "ww")  // 判断字符串web是否是以ww开始的,是返回true,否则返回false
	res3 := strings.HasSuffix(web, "sss") // 判断字符串web是否是以sss结尾的,是返回true,否则返回false
	fmt.Println(res2, res3)

	sss := "Nice to meet you!"
	res4 := strings.Index(sss, "t") // 默认只获取第一个t所在的索引位置
	fmt.Println(res4)

	res5 := strings.LastIndex(sss, "t") // 返回最后一个t所在的索引位置
	fmt.Println(res5)

	res6 := strings.Join(ret, "+") // 用某种字符进行拼接
	fmt.Println(res6)


8
xxxyyy
hepenglisleeping
[www baidu com]
true false
true false
5
11
www+baidu+com

byte和rune类型

Go 语言的字符有以下两种:

  1. uint8类型,或者叫 byte 型,代表了ASCII码的一个字符。

  2. rune类型,代表一个 UTF-8字符

当需要处理中文、日文或者其他复合字符时,则需要用到rune类型。rune类型实际是一个int32

Go 使用了特殊的 rune 类型来处理 Unicode,让基于 Unicode 的文本处理更为方便,也可以使用 byte 型进行默认字符串处理,性能和扩展性都有照顾。

package main

import "fmt"

func main() 
	str1 := "Nice to meet you, 遇见你我也很高兴!"
	for i := 0; i < len(str1); i++ 
        fmt.Printf("%c", str1[i]) // 中文会乱码(%c输出单个字符)
	

	fmt.Println()

	for _, s := range str1 
		fmt.Printf("%c", s) // 中文不乱码
	


Nice to meet you, éè§ä½ æä¹å¾é«å´ï¼
Nice to meet you, 遇见你我也很高兴!

修改字符串

要修改字符串,需要先将其转换成[]rune[]byte,完成后再转换为string。无论哪种转换,都会重新分配内存,并复制字节数组。

package main

import "fmt"

func main() 
	s1 := "hepengli"
	bytes1 := []byte(s1) // 要先转换为[]byte
	bytes1[0] = 's'
	fmt.Println(string(bytes1))

	s2 := "hello你好"
	runes2 := []rune(s2) // 先转换为[]rune类型
	runes2[5] = '擦'
	fmt.Println(string(runes2))


sepengli
hello擦好

类型转换

Go语言中只有强制类型转换,没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

package main

import (
	"fmt"
	"reflect"
)

func main() 
	a1 := 222
	fmt.Println(reflect.TypeOf(a1))

	a2 := float64(a1)
	fmt.Println(reflect.TypeOf(a2))


int
float64

fmt.Printf中的占位符

package main

import "fmt"

// fmt中的占位符
func main() 
	num := 666
	str1 := "hpl"
	fmt.Printf("%T:输出数据类型\\n", num)
	fmt.Printf("%v:输出任何类型的值\\n", num)
	fmt.Printf("%b:输出二进制数据\\n", num)
	fmt.Printf("%o:输出八进制数据\\n", num)
	fmt.Printf("%d:输出十进制数据\\n", num)
	fmt.Printf("%x:输出十六进制数据\\n", num)
	fmt.Printf("%s:输出字符串\\n", str1)
	fmt.Printf("%#v:输出带描述符", str1)


int:输出数据类型
666:输出任何类型的值
1010011010:输出二进制数据
1232:输出八进制数据
666:输出十进制数据
29a:输出十六进制数据
hpl:输出字符串
"hpl":输出带描述符

输出类型

package main

import (
	"fmt"
	"reflect"
)

const a3 = 666

func main() 
	fmt.Println(reflect.TypeOf(a3))
    fmt.Printf("%T", a3)


int
int

以上是关于Go基础1的主要内容,如果未能解决你的问题,请参考以下文章

Python 语法基础_数据类型补充

在文本每一行的行首和行尾都插入特定的相同字符或文本

test

第三章,网页中常用的标签

李白《静夜思》古诗赏析

汉语言之古诗词 一