【Golang】一起来学笔记（一）

Go语言简绍

他是编译性语言。
配置：

在path那里还需要增加这个路径配置


bin:存放编译后生成的可执行文件
pkg:用来存放编译后生成的归档文件
src:用来存放源码文件
golang.org-author-项目名

运行：在main.go 当前文件，go run main.go
编译：go build -o name ,然后执行helloworld.exe

1、 helloworld

建立一个文件夹叫helloworld，里面写入main.go

package main

import “fmt"
func main(){
	fmt.Println("Hello world!")
}

2、 变量

（1）全局定义变量

var alex="dsb"

（2）局部变量定义

func main(){
	//声明的变量必须在下方使用
	var name string
	var age int
	fmt.Println(name)
	fmt.Println(age)
}

（3）批量声明变量

func main(){
	//声明的变量必须在下方使用
	var(
	a string
	b int
	c bool
	)
	fmt.Println(a, b, c)
}

结果
" "0 false

（4）声明变量并初始化

var x string="老男孩“
fmt.Printf("%s哈哈哈",x)

（5）类型推导

var y=200
var x=true
fmt.Println(y,z)

（6）短变量声明，只能在函数内部使用

func main(){
	a:="123"
	fmt.Println(a)
}

（7）匿名变量

func foo()(string,int){
	return "alex",90000
}
func main(){
	aa,_:=foo()
	fmt.Println(aa)
}

3、 常量

（1）直接定义

const pi=3.14
func main(){
	fmt.Println(pi)
}

（2）批量定义

const (
	a=100
	b=1000
	c
	d
)
func main(){
	fmt.Println(a,b,c,d)
}

注意，这里c,d如果没有赋值，则会继承上一个有赋值的值，所以c,d=1000

（3）枚举常量

枚举常量就是一个会自增的关键字，每新增一行常量声明，iota计数一次
第一种：

const (
	aa=iota // 0
	bb
	cc
	dd
)

func main(){
	fmt.Println(aa,bb,cc,dd)
}

结果是：0,1,2,3
第二种：

const (
	n1=iota
	n2
	_
	n4
)

func main(){
	fmt.Println(n1,n2,n4)
}

结果是
0,1,3

第三种

const (
	n5=iota
	n6=100
	n7=iota
	n8
)

func main(){
	fmt.Println(n5,n6,n7,n8)
}

结果是：0,100,2,3

第四种：

const (
	_=iota
	KB=1<<(10*iota) //位运算，左移10位--》2^10
	MB=1<<(10*iota)
	GB=1<<(10*iota)
	TB=1<<(10*iota)
	PB=1<<(10*iota)
)

第五种

const (
	a,b=iota+1,iota+2
	c,d
	e,f
)
func main(){
	fmt.Println(a,b,c,d,e,f)
}

结果是1,2,2,3,3,4

4、 数据类型

不允许整型强制转换为布尔值，但不能与其他类型进行转换；
字符串以原生数据类型出现，使用UTF-8编码，""表示; 单引号表示一个字符char

（1）八进制

func main(){
	var a int =077
	fmt.Printf("%o",a)
}

（2）十六进制

func main(){
	var b int =0x77
	fmt.Printf("%x",b)
}

（3）变量内存地址

func main(){
	var b int =0x77
	fmt.Printf("%p",b)
}

（4）浮点数常量

计数float64最多存储大数

import (
	"math"
	"fmt"
)
func main(){
	fmt.Println(math.MaxFloat64)
}

（5）字符串转义

func main(){
	fmt.Println("c:\\go")
	var s1="abcd"
	var s2=`
	这是\
	多行\
`
	fmt.Println(s1)
	fmt.Println(s2)
}

多行文本会直接原样输出

（6）byte和rune类型

func main(){
	s1:='G' //byte类型,表示英文
	s2:="中国" //rune类型，
	
	for k,v := range s2{
	fmt.Printf("%d %c\n",k,v) //中文会占3个字符，所以会占3个索引位
	//只有这种方式才能表示中文原样输出
}
}

byte类型是以ASCII编码表示
rune类型是以UTF-8 编码表示

（7）布尔值

func main(){
	var a bool // 默认为false
	var b =true
}

5、 字符串操作

(1)拼接

func main(){
	s1:="alexdsb"
	fmt.Println(len(s1))
	s2:="Python"
	fmt.Println(s1+s2）
	//或者
	s3:=fmt.Sprintf("%s---%s",s1,s2)
}

(2)分割

import "strings"
func main(){
	s1:="alexdsb"
	ret:=strings.Split(s1,"x")
}

结果：[ale dsb]

(3)判断是否存在某字符串

import "strings"
func main(){
	s1:="alexdsb"
	ret2:=strings.Contains(s1,"sb")
}

(4)前缀后缀判断

import "strings"
func main(){
	s1:="alexdsb"
	ret3:=strings.HasPrefix(s1,"alex") //前缀
	ret4:=strings.HasSuffix(s1,"sb") //后缀
}

(5)求子串位置

import "strings"
func main(){
	s2:="applepen"
	fmt.Println(strings.Index(s2,"p"))
	//从0开始找，返回首次出现p的索引位置
	fmt.Println(strings.LastIndex(s2,"p")) 
	//从0开始找，返回最后一次出现p的索引位置
}

(6)join操作

import "strings"
func main(){
	a1:=[]string{"a","b","c"}
	fmt.Println(strings.Join(a1,"---")
}

这个的结果是
a—b---c

(7)练习：字符串逆输出

方法1

import "strings"
func main(){
	s1:="hello"
	byteArray:=[]byte(s1) //转成数组
	s2:=""
	for i:=len(byteArray)-1; i>=0;i--{
		s2+=string(byteArray[i])
		}
	fmt.Println(s2)
}

方法2

import "strings"
func main(){
	length:=len(byteArray)
	for i:=0;i<length/2;i++{
		//互换变量
		byteArray[i],byteArray[length-1-i]=byteArray[length-1-i],byteArray[i]
		}
		fmt.Println(string(byteArray))//从Ascii转为string
}

6、 流程控制

（1）if

方法1：这一种，age是全局变量，任何位置都可访问

import "fmt"
func main(){
	age:=19
	if age>18{
		fmt.Println("abc")
	} else if age<18{
		fmt.Println("cbc")
}else{
	fmt.Println("成了")
}
}

方法2：这一种是局部if变量，其作用域只在if范围

import "strings"
func main(){
	if age:=28;age>18{
	fmt.Println("abc")
}

（2）for

import "strings"
func main(){
	age:=18
	for age>0{
		fmt.Println(age)
		age--
	}
	fmt.Println(age)
}

（3）switch

第一种

import "strings"
import "fmt"

func switchdemo(){
	finger:=3
	case 1:
		fmt.Println("1")
	case 2:
		fmt.Println("2")
	case 3:
		fmt.Println("3")
	default:
		fmt.Println("0")
}
func main(){
	switchdemo()
}

第二种

import "strings"
import "fmt"

func switchdemo(){
	switch n:=7;n{
	case 1,3,5,7,9:
		fmt.Println("奇数")
	case 2,4,6,8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
}
}
func main(){
	switchdemo()
}

第三种

import "strings"
import "fmt"

func switchdemo(){
	age:=30
	switch{
	case age<25:
		fmt.Println("abc")
	case age>25 && age<35:
		fmt.Println("cbc")
	case age>60:
		fmt.Println("aaa")
	default:
		fmt.Println("ddd")
	}
}
func main(){
	switchdemo()
}

第四种

import "strings"
import "fmt"

func switchdemo(){
	s:="a"
	switch{
	case s=="a":
		fmt.Println("a")
		fallthrough //无条件执行下面的case语句
	case s=="b":
		fmt.Println("b")
	case s=="c":
		fmt.Println("c")
	default:
		fmt.Println("....")	
}
}
func main(){
	switchdemo()
}

结果是：
a
b

7、 练习

（1）乘法表

package main

import "fmt"

//打印9*9乘法表
func main() {
	//法1
	for i := 1; i <= 9; i++ {
		for j := 1; j <= 9; j++ {
			if j <= i {
				fmt.Printf("%dx%d=%d\t", j, i, i*j)
				if i == j {
					fmt.Println()
				}
			}

		}
	}
	fmt.Println()
	//法2
	for i := 1; i < 10; i++ {
		for j := 1; j <= i; j++ {
			//此处写的表格里的一行
			fmt.Printf("%d x %d = %d\t", j, i, i*j)
		}
		fmt.Println() // 每行结束换行
	}

}

（2）打印素数

package main

import "fmt"

//打印200~1000之间的素数（除了本身没有其他被除数）
func main() {
	for i := 200; i < 1000; i++ {
		//判断是否为素数
		flag := true
		for j := 2; j < i; j++ {
			if i%j == 0 {
				flag = false
				break //不是质数
			}
		}
		if flag {
			fmt.Println(i)
		}
	}
}

仅此笔记，记录一周的学习，强化记忆