前言
仅记录学习笔记，如有错误欢迎指正。
开发环境
idea plugins 下载
下载go sdk
直接new go项目就ok了
基本语法
go
package main
import (
"fmt"
"unsafe"
)
/**
当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，
那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），
这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的
，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
*/
var x,y,z int
const (
one = "abc"
two = 999
)
func main(){
//输出
fmt.Println("hello GO!!!!" + "say hi")
//常量的定义
const PI float64 = 3.1415926
if PI != 3{
fmt.Println("not equals")
}
var stockCode=123
// %d 表示整型数字，%s 表示字符串
var endDate="2020-12-31"
var url="Code=%d&endDate=%s"
var target_url=fmt.Sprintf(url,stockCode,endDate)
fmt.Println(target_url)
//p := testRes()
//声明式定义 让编译器自己去管理类型 无需定义类型
num1 := 1
num2 := 9
println(num1+num2)
x=2
y=2
println(x*y)
res := testRes(x,y)
println(res)
testIota()
getSize()
}
//先写接受 再写返回的类型
func testRes( x1 ,x2 int) int{
//var x1 ,x2 int = 1,2
fmt.Println(x1+x2)
res := x1+x2
return res
}
//iota 后面的变量会自动跟随第一个变量的赋值 ++
const (
i int = 2<<iota
j
k
)
func testIota(){
println(i,j,k)
}
func getSize(){
s := "hello"
println(unsafe.Sizeof(s))
}类型转换、指针、递归
go
package main
import (
"fmt"
"strconv"
)
func main() {
var nums [5]int
var nums1 = [3]int{1,2,3}
//var p *[]int 指针和引用
p := &nums1
fmt.Println(nums1,nums,*p)
num2 := nums1[1:3]
fmt.Println(num2,len(num2),cap(num2))
//切片为引用传递 数组为值传递
num3 := []int{1,2,3}
changeData(nums1)
changeData1(num3)
fmt.Println("after change")
fmt.Println(nums1,num3)
//类似java的foreach
s :="abcdef"
for _,str := range s{
fmt.Printf("%c", str)
}
fmt.Println(fibonacci(6))
//str 转数字
var stri string = "12"
var number int
number,_=strconv.Atoi(stri)
strconv.Itoa(number)
fmt.Println(number)
}
//递归 斐波那契
func fibonacci(n int) int{
if n < 2 {
return n
}
return fibonacci(n-1) + fibonacci(n-2)
}
func changeData(arr [3]int ) {
arr[0] = 999
}
func changeData1(arr []int ) {
arr[0] = 999
}接口 并发 通道
go
package main
import (
"fmt"
"time"
)
//interface
type Animal interface {
run()
}
type Tiger struct {
leg string
}
func (tiger Tiger) run(){
fmt.Println("i am tiger,i have " + tiger.leg+ " legs,run fast")
}
type Human struct {
leg string
}
func (human Human) run(){
fmt.Println("i am human,i have " + human.leg+ " legs,run slow")
}
func say(s string){
for i:=0;i<5;i++{
time.Sleep(100*time.Millisecond)
fmt.Println(s)
}
}
//c channel
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // 把 sum 发送到通道 c
}
func main() {
//"继承"和"多态"
var tiger Animal = Tiger{"5"}
var human Animal = Human{leg: "2"}
tiger.run()
human.run()
//并发处理
//Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。
//goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。
//goroutine 语法格式：
go say("1111")
say("222")
s := []int{7, 2, 8, -9, 4, 0}
//通道（channel）是用来传递数据的一个数据结构。
//通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。
//操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。
//通道缓冲区
//通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：
c := make(chan int)
go sum(s[:len(s)/2], c)
go sum(s[len(s)/2:], c)
x, y := <-c, <-c // 从通道 c 中接收
fmt.Println(x, y, x+y)
}