1.结构
package main // 声明 main 包，表明当前是一个可执行程序
import "fmt" // 导入内置 fmt
func main(){ // main函数，是程序执行的入口
fmt.Println("Hello World!") // 在终端打印 Hello World!
}
go run main.go
2.变量常量数据类型
package main
import "fmt"
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
func main(){
/**
变量 声明必须使用
var name type / var name1,name2 type
默认0 false ''
以下为nil
*/
// var a0 *int
// var a1 []int
// var a2 map[string] int
// var a3 chan int
// var a4 func(string) int
// var a5 error // error 是接口
var s float64
fmt.Printf("%v",s)
// 2.声明语句 := 只能用于函数体
intv := 1
fmt.Printf("%v", intv)
// 3.全局变量
fmt.Println(a,b)
// 4.值类型 （基本类型）布尔 数字 字符串
// 5.引用类型 (a) 指针类型（Pointer） 数组类型
// 结构化类型(struct)Channel 类型函数类型 切片类型 接口类型（interface）Map 类型
/*
常量
1.定义 const name [type] = (type可以省略)
2.用于枚举
3.iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
*/
// 2.
const (
Unknown = 0
Female = 1
Male = 2
)
println(Unknown,Female)
// 3.
const (
ia = iota //0
ib //1
ic //2
id = "ha" //独立值，iota += 1
ie //"ha" iota += 1
fi = 100 //iota +=1
ig //100 iota +=1
ih = iota //7,恢复计数
ii //8
)
println(ia,ib,ic,ii)
}
package main
func main(){
var a int = 10
var b float64 = float64(a)
//字符串->整型
var str string = "10"
var num int
num, err = strconv.Atoi(str) //strconv.Atoi 函数返回两个值，第一个是转换后的整型值，第二个是可能发生的错误
//整型->字符串
num1 := 123
str1 := strconv.Itoa(num1)
//字符串->浮点型
str := "3.14"
num, err := strconv.ParseFloat(str, 64)
//浮点型->字符串
num := 3.14
str := strconv.FormatFloat(num, 'f', 2, 64)
//类型断言 接口类型->指定类型
var i interface{} = "Hello, World"
str, ok := i.(string)
//类型转化 一个接口->另一个
}
3.语句
package main
func main(){
//条件
a := 10
if a == 100 {
if a < 10{
} else {
}
} else {
}
/**
循环
1.for
for init; condition; post {}
for condition{}
for {}
for key,value := range mapName{}
for _, value := range oldMap
*/
// for i := 0; i <= 10; i++{
// }
// sum := 1;
// for ; sum <= 10; {
// sum = sum + sum;
// }
// for sum<=10{
// sum = sum + sum;
// }
str := []string{"lwx","lwx1"}
for i,v :=range str {
println(i , v)
}
}
4.函数
package main
func main(){
/**
func name( [param]) [return type ]{}
*/
a := max(1,2)
println(a)
b,c :=min(1,2)
println(b,c)
}
func max(n1, n2 int) int {
return n1
}
func min(n1, n2 int) (int,int) {
return n1,n2
}
5.数组
package main
func main(){
/**
数组
1.声明 var arrayName [size]type{}
arrName := [size]type{}
二维
1.声明 var name [][]type{ {},{}}
数组参数
*/
arr := [5]int{1,2,4,5,6}
println(arr[0]);
test(arr)
}
func test(arr []int) {
}
6.指针
package main
func main(){
/**
指针
1.声明 &a 内存地址
var name *type = &name
*/
a := 10;
println(&a)
var ip *int;
ip = &a;
println(*ip)//值
println(ip)//地址
}
7.结构体
package main
import "fmt"
type structName struct {
name string
age int
}
func main(){
fmt.Println(structName{"123",2});
fmt.Println(structName{name:"123", age:2});
var s1 structName
s1.title = "title"
}
8.切片
package main
import "fmt"
func main(){
/**
切片
1.对数组抽象 动态数组 不需要说明长度
2.定义 var name []type = make([]type,len)
name := make([]type, len, capacity) capacity可选参数切片最长可以达到多少
*/
// arr := []int {1,2,3,4}
s := []int {1,2,3}
// s1 := arr[:]
// s2 := arr[1:3]
// s3 := arr[:3]
// s4 := arr[1:]
// 3.空切片
if s == nil {
}
fmt.Printf("len=%d cap=%d slice=%v\n",len(s),cap(s),s)
// 4.切片截取
/* 创建切片 */
numbers := []int{0,1,2,3,4,5,6,7,8}
printSlice(numbers)
/* 打印原始切片 */
fmt.Println("numbers ==", numbers)
/* 打印子切片从索引1(包含) 到索引4(不包含)*/
fmt.Println("numbers[1:4] ==", numbers[1:4])
/* 默认下限为 0*/
fmt.Println("numbers[:3] ==", numbers[:3])
/* 默认上限为 len(s)*/
fmt.Println("numbers[4:] ==", numbers[4:])
numbers1 := make([]int,0,5)
printSlice(numbers1)
/* 打印子切片从索引 0(包含) 到索引 2(不包含) */
number2 := numbers[:2]
printSlice(number2)
/* 打印子切片从索引 2(包含) 到索引 5(不包含) */
number3 := numbers[2:5]
printSlice(number3)
// 5.函数
s = append(s,1,2)
/* 创建切片 ss是之前切片的两倍容量*/
ss := make([]int, len(s), (cap(s))*2)
/* 拷贝 ns 的内容到 ss */
copy(s,ss)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
9.接口
package main
import "fmt"
type Phone interface {
call()
}
type NokiaPhone struct {
}
func (nokiaPhone NokiaPhone) call() {
fmt.Println("I am Nokia, I can call you!")
}
type IPhone struct {
}
func (iPhone IPhone) call() {
fmt.Println("I am iPhone, I can call you!")
}
func main(){
/**
接口
1.它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。
*/
var phone Phone
phone = new(NokiaPhone)
phone.call()
phone = new(IPhone)
phone.call()
}
10.map
func main(){
/**
1.Map 定义 name := make(map[keyType]valueType,cap)
*/
m := make(map[string]int)
m1 := map[string]int {
"k1":1,
"k2":2
}
// 2.元素
v1 := m1["k1"]
m["k1"]=5
delete(m,"k1")
for k,v := range m {
}
len : len(m)
}
11.错误处理
type error interface {
Error() string
}
func main(){
f := -1
if f < 0 {
return 0, errors.New("math: square root of negative number")
}
}
12.并发
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main(){
//Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可
go say("world")
say("hello")
}
