一四四、go入门到进阶：基础-CSDN博客

本文链接：https://blog.csdn.net/zm06201118/article/details/129882040

1. hello world

package main // 声明文件的package名

import "fmt" // import语言的fmt库-- 用于输出

func main() {
	fmt.Println("Hello, World! %s","33")
}

/*

运行代码方式
1.直接运行
go run demo1.go //编译成二进制文件 并运行

2.编译二进制 在运行
go build demo1.go
./demo1

第一行代码定义了包名。
下一行是引入的包
	包一般4种类型   系统自带的库， 内部私有库   外部库  本地库

main 是程序执行的入口，如果有init先执行
*/

2. 变量声明

package main

import "fmt"

func main() {
	// 声明初始化一个变量
	var x int = 100
	var str string = "hello world"
	// 声明初始化多个变量

	var i, j, k int = 1, 2, 3
	// 不指定类型，通过初始化推导
	var b = true // bool 类型

	const LENGTH int = 10 // 常量

	fmt.Println(x, str, i, j, k, b, LENGTH)

	abc()
}

func abc() {
	var v21 int32 // 初始化为0
	var v22 int = 2
	var v23 = 3
	v24 := 3
	v21 = int32(v23) // 强制转换

	g, h := "cc", "hello" // 只能在函数体中提现
	g,h = h,g
	fmt.Println(g,h)
	fmt.Println("v21 is", v21)
	fmt.Println("v22 is", v22)
	fmt.Println("v23 is", v23)
	fmt.Println("v24 is", v24)
	fmt.Println(g, h)
}

3. 数组声明

package main

import "fmt"

func main() {
	var a [5]int
	fmt.Println("array a:", a)

	a[1] = 10
	a[1] = 30
	fmt.Println("assign:", a)

	fmt.Println("len:", len(a), "cap:", cap(a))

	b := [5]int{1, 2, 3, 4, 5}
	fmt.Println("b array init:", b)

	for k, v := range b {
		fmt.Println("key:", k, "value:", v)
	}

	for  v := range b { // _ 下划线用于忽略值不接收不处理
		fmt.Println( "value:", v)
	}

	var c [2][3]int
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			c[i][j] = i + j
		}
	}
	fmt.Println("2d:", c)
}

4. 多返回值

package main

import "fmt"

func main() {
	v, e := multiReturn("one")
	fmt.Println(v, e) // 输出 1 true

	v, e = multiReturn("four")
	fmt.Println(v, e) // 输出 0 false

	// 通常的用法(注意分号后有e)
	if _, e = multiReturn("four"); e {
		// 正常返回
	} else {
		// 出错返回
		fmt.Println("no four.")
	}
}

func multiReturn(key string) (val int, err bool) {
	m := map[string]int{"one": 1, "two": 2, "three": 3}
	val, err = m[key]
	//k := map[int]interface{}

	return
}

5. 结构体

package main

import "fmt"

// Person 定义一个人属性的结构体
type Person struct {
	name  string
	age   int
	email string
}

func main() {
	// 初始化
	person := Person{"Tom", 30, "tom@gmail.com"}
	fmt.Println(person) // 输出 {Tom 30 tom@gmail.com}

	var person2 = Person{name: "jan", age: 24, email: "jan@gmail.com"}
	fmt.Println(person2)

	pPerson := &person

	fmt.Println(pPerson) // 输出 &{Tom 30 tom@gmail.com}

	pPerson.age = 40
	person.name = "Jerry"
	fmt.Println(person) // 输出 {Jerry 40 tom@gmail.com}
}

6. 接口方法

package main

import "fmt"

type rect struct {
	width, height int
}

func (r *rect) area() int { // 求面积
	return r.width * r.height
}

func (r *rect) perimeter() int { // 求周长
	return 2 * (r.width + r.height)
}

// 注意：Go语言中没有public, protected, private的关键字，所以，如果你想让一个方法可以被别的包访问的话，
// 你需要把这个方法的第一个字母大写。这是一种约定。
func main() {
	r := rect{width: 10, height: 15}

	fmt.Println("面积: ", r.area())
	fmt.Println("周长: ", r.perimeter())

	rp := &r
	fmt.Println("面积: ", rp.area())
	fmt.Println("周长: ", rp.perimeter())
}

7. 接口组合

package main

import (
	"fmt"
	"math"
)

// ---------- 接 口 --------//
type shape interface {
	area() float64      // 计算面积
	perimeter() float64 // 计算周长
}

// --------- 长方形 ----------//
type rects struct {
	width, height float64
}

func (r *rects) area() float64 { // 面积
	return r.width * r.height
}

func (r *rects) perimeter() float64 { // 周长
	return 2 * (r.width + r.height)
}

// ----------- 圆  形 ----------//
type circle struct {
	radius float64
}

func (c *circle) area() float64 { // 面积
	return math.Pi * c.radius * c.radius
}

func (c *circle) perimeter() float64 { // 周长
	return 2 * math.Pi * c.radius
}

// ----------- 接口的使用 -----------//
func main() {
	r := rects{width: 2.9, height: 4.8}
	c := circle{radius: 4.3}

	s := []shape{&r, &c} // 通过指针实现

	for _, sh := range s {
		fmt.Println(sh)
		fmt.Println(sh.area())
		fmt.Println(sh.perimeter())
	}
}

8. http服务

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	// http请求处理
	http.HandleFunc("/test", test)

	fmt.Print("http server start.....")
	// 绑定监听地址和端口
	log.Fatal(http.ListenAndServe("127.0.0.1:8080", nil))
}

func test(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "hello world")
}

9. 并行处理

package main

import (
	"fmt"
	"runtime"
	"sync"
)

// 并发
func main() {
	runtime.GOMAXPROCS(1)
	var wg sync.WaitGroup
	wg.Add(2)

	fmt.Println("Start Goroutines")
	go func() {
		// Schedule the call to Done to tell main we are done.
		defer wg.Done()

		// Display the alphabet three times
		for count := 0; count < 3; count++ {
			for char := 'a'; char < 'a'+26; char++ {
				fmt.Printf("%c ", char)

			}
			fmt.Println()
		}
	}()

	// Declare an anonymous function and create a goroutine.
	go func() {
		// Schedule the call to Done to tell main we are done.
		defer wg.Done()

		// Display the alphabet three times
		for count := 0; count < 3; count++ {
			for char := 'A'; char < 'A'+26; char++ {
				fmt.Printf("%c ", char)
			}
			fmt.Println()
		}
	}()

	// Wait for the goroutines to finish.
	fmt.Println("Waiting To Finish")
	wg.Wait()

	fmt.Println("\nTerminating Program")
}

10. 通道

package main

import (
	"fmt"
	"time"
)

func writeDate(intChan chan int) { // 开启一个writeData协程 读取50个整数，放到intChan中
	for j := 0; j < 50; j++ {
		intChan <- j
		fmt.Println(j ," 写入管道中")
	}

	time.Sleep(2 * time.Second)
	close(intChan) // 关闭写入管道
}

func readData(intChan chan int, exitChan chan bool) { // 开启一个readData协程 ,读取intChan中的数据
	for {
		v, ok := <-intChan
		if !ok {
			break
		}
		fmt.Printf("读取管道数据中%v \n", v)
	}

	exitChan <- true
	close(exitChan) // 关闭判断管道
}

func main() {
	intChan := make(chan int, 50)
	exitChan := make(chan bool, 1)

	go writeDate(intChan)
	go readData(intChan, exitChan)

	for {
		_, ok := <-exitChan
		if !ok {
			break
		}
	}
}