go -和gt; 初级语法一

行分隔符

如果你打算将多个语句写在同一行，它们则必须使用 ; 人为区分，但在实际开发中我们并不鼓励这种做法。

fmt.Println("Hello, World!")  
fmt.Println("菜鸟教程：runoob.com")
或者:
fmt.Println("Hello, World!")  ; fmt.Println("菜鸟教程：runoob.com") ; 

注释

同java：单行// 多行//***/

标识符

同java：字母大小写与下划线 开头

关键字

if 选择结构
import 导入包
return 返回
continue 跳过本次循环
package 包
break 用于跳出循环
func 函数定义
switch  条件执行相应的语句块
default 用于选择结构的默认选项（switch、select）
else 选择结构
var 定义变量
-----------------------------------------------------------------------------------------------
el:
func var_kw(){
  // 定义基本类型
  var age int = 25
  var blog string = "WEIXIN_URL"
  fmt.Println(age, blog)
 
  // 定义指针
  var ptr *int = &age
  fmt.Println(*ptr)
}
-----------------------------------------------------------------------------------------------
type 用于定义一个类型，类型是一种数据的抽象表示，用于描述数据的属性和行为。在Go语言中，可以使用type关键字定义基本类型、结构体类型、函数类型等。
el:
func type_kw() {  
    //定义结构体类型  
    type Person struct {  
        Name string  
        Age int  
        Blog string  
    }  

    //定义基本类型  
    type MyInt int  
    var age MyInt = 25  
    fmt.Println(age)  
}
-----------------------------------------------------------------------------------------------
struct 用于定义一个结构体，结构体是一种自定义的数据类型，可以包含多个字段，每个字段可以是不同的数据类型。在Go语言中，结构体是一种非常重要的数据类型，可以用于组织和管理数据。
el：
func struct_kw() {  
    type Person struct {  
        Name string  
        Age int  
        Blog string  
    }  

    p := Person{"Steverocket", 25, "WEIXIN_URL"}  
    fmt.Println("My name is", p.Name, ". age is", p.Age, ". this is my blog", p.Blog)  
}
结果：
My name is Steverocket . age is 25 . this is my blog WEIXIN_URL
-----------------------------------------------------------------------------------------------
select 用于实现多路复用，可以同时等待多个通道的数据。在select语句中，可以使用case语句监听多个通道，当其中任意一个通道有数据可读时，就执行相应的语句块。
el:
func select_kw() {  
    c1 := make(chan string)  
    c2 := make(chan int)  
    go func() {  
        c1 <- "WEIXIN_URL"  
    }()  

    go func() {  
        c2 <- 25  
    }()  

    select {  
        case c := <-c1:  
            fmt.Println("!________________")  
            fmt.Println(c)  
        case c := <-c2:  
            fmt.Println("!################")  
            fmt.Println(c)  
        default :
            fmt.Println("@@@@@@@")    
    }  
}
结果：
!________________
WEIXIN_URL
或者
!################
25
或者
@@@@@@@

-----------------------------------------------------------------------------------------------
range 用于遍历一个字符串、数组、切片、映射等数据结构，可以获取每个元素的值和索引。在遍历映射时，range关键字返回的是键值对。
el:
func go_kw1() {  
    a := []int{1, 2, 3}  
    for i, v := range a {  
        fmt.Println(i, v)  
    }  

    maps := map[string]string{"csdn": "CSDN_URL", "weixin": "WEIXIN_URL", "git": "GIT_URL"}  
    for k, v := range maps {  
        fmt.Println(k, v)  
    }  
}
//排序输出
func go_kw2() {  
    // 初始化 Map  
    scores := map[string]int{  
        "Tom": 90,  
        "Jerry": 80,  
        "Bob": 85,  
        "Mike": 92,  
    }  

    // 将 Map 中的键复制到一个新的切片中  
    keys := make([]string, 0, len(scores))  
    for key := range scores {  
        keys = append(keys, key)  
    }  

    // 对切片进行排序 < 表示升序 >表示降序  
    //参数一：切片 参数二：比较函数  
    sort.Slice(keys, func(i, j int) bool {  
    // 内部借助快速排序算法  
    return scores[keys[i]] < scores[keys[j]]  
    })  

    // 打印排序后的结果  
    for _, key := range keys {  
        /*  
        Jerry: 80  
        Bob: 85  
        Tom: 90  
        Mike: 92  
        */  
        fmt.Printf("%s: %d\n", key, scores[key])  
    }  
}
-----------------------------------------------------------------------------------------------
map map类型 **** 遍历是无序的
el:
//定义的同时初始化  
func go_kw1() {  
    maps := map[string]string{"csdn": "CSDN_URL", "weixin": "WEIXIN_URL", "git": "GIT_URL"}  
    for k, v := range maps {  
        fmt.Println(k, v)  
    }  
    maps1 := make(map[string]string)  
    //先定义后初始化  
    maps1["csdn"] = "CSDN_URL"  
    maps1["weixin"] = "WEIXIN_URL"  
    maps1["git"] = "GIT_URL"  
    
    fmt.Println(len(maps1))  
    fmt.Println(maps1["weixin"])  
    fmt.Println(maps1["csdn"])  
}
-----------------------------------------------------------------------------------------------
interface 用于定义一个接口，接口是一组方法的集合，用于描述对象的行为。在Go语言中，接口是一种非常重要的概念，它可以实现多态性，使得程序具有更好的可扩展性和灵活性。
url: https://blog.csdn.net/yuqiang870/article/details/124746693
type Person interface {
    // 声明方法
    method1(参数列表)返回值列表
    method2(参数列表)返回值列表
}
实现类：
func (t 自定义类型）method1(参数列表）返回值列表 { 
    //方法实现
}
func (t 自定义类型）method2(参数列表）返回值列表 { 
    //方法实现 
}
el:
// Person 定义接口 
type Person interface { 
    GetName() string 
}
// Student 定义类型 
type Student struct { 
    Name string
} 

func (s Student) GetName() string{ 
    return s.Name 
}
-----------------------------------------------------------------------------------------------
case 选择结构标签
el:
func case_kw(){
  var URL = "WEIXIN_URL"
  switch URL {
  case "CSDN_URL":
    fmt.Println("CSDN_URL")
  default:
    fmt.Println("is not url patterns")
  }
}
-----------------------------------------------------------------------------------------------
defer 用于在函数返回之前执行一些操作，例如关闭文件、释放资源等。defer语句按照后进先出的顺序执行。defer可以用于延迟函数的执行，它会将函数放入一个栈中，在函数结束时按照先进后出的顺序执行。
defer语句可以用于释放资源、记录日志、处理错误等操作。
语法：
defer function(parameters)
其中，function表示要延迟执行的函数，parameters表示函数的参数。
el:[经过优化的`for-range`循环的汇编代码和普通`for`的结构相同。也就是说，使用`for-range`的控制结构最终也会被Go语言编译器换成普通的`for`循环。]
func defer_kw(){
    defer fmt.Println("nice")
    for _,k := range "gun"{
        fmt.Printf("%c", k)
    }
    fmt.Println("\nrun over...")
}

结果:
gun        
run over...
nice    
-----------------------------------------------------------------------------------------------
go 并发执行
el:
func go_kw1() {  
    n := runtime.GOMAXPROCS(2) //指定以2核运算  
    fmt.Println("n = ", n)  
    /** 
    go关键字用于启动一个新的并发线程，以便在后台执行一个函数。使用go关键字可以实现并发编程。  
    */  
    go func() {  
        fmt.Println("WEIXIN_URL1")  
    }()  
}  
  
func go_kw2() {  
    for i := 0; i < 10; i   {  
    fmt.Println("{W#########################################}")  

    go func() {  
        fmt.Println("WEIXIN_URL2")  
        }()  
    }  
    //让出时间片，先让别的协议执行，它执行完，再回来执行此协程  
    runtime.Gosched()  
}

-----------------------------------------------------------------------------------------------
chan 用于定义一个通道，通道是一种用于在多个goroutine之间传递数据的机制。通道可以是无缓冲的或有缓冲的，可以阻塞或非阻塞。
el:
func chan_kw(age int){
    ch:=make(chan int)
    go func(){
        ch <- age
    }()
    fmt.Println(<-ch)
}

结果：
chan_kw(26)  // 26
-----------------------------------------------------------------------------------------------
goto 用于无条件跳转到指定的标签处执行代码，可以用于跳出多层循环或实现异常处理等功能。但是，由于goto语句会破坏程序的结构，使得代码难以理解和维护，因此应该尽量避免使用。
el:
func goto_kw(){  
  times := 0  
  Here:  
    fmt.Println("this is ", times , WEIXIN_URL)  
    times  = 1  
    if times < 3 {  
      goto Here  
    }  
    fmt.Println(CSDN_URL)  
}
-----------------------------------------------------------------------------------------------
const 常量，常量可以是数值、布尔值、字符串等。
el:
const PI = 3.1415926  
const (  
    CSDN_URL01 = "https://blog.csdn.net/zhouruifu2015/"  
    WEIXIN_URL01 = "https://mp.weixin.qq.com/s/0yqGBPbOI6QxHqK17WxU8Q"  
    GIT_URL01 = "https://gitee.com/SteveRocket/practice_python.git"  
)
-----------------------------------------------------------------------------------------------
fallthrough 如果case带有fallthrough，程序会继续执行下一条case,不会再判断下一条case的值它只能用于switch语句中的case语句，且必须是case语句中的最后一条语句。
el:
func fallthrough_kw() {  
    URL := "CSDN_URL"  
    switch URL {  
        case "CSDN_URL":  
            fmt.Println("CSDN_URL")  
            fallthrough  
        case "WEIXIN_URL":  
            fmt.Println("WEIXIN_URL")  
        case "GIT_URL":  
            fmt.Println("GIT_URL")  
        default:  
            fmt.Println("is not url patterns")  
    }  
}
结果：
CSDN_URL
WEIXIN_URL
-----------------------------------------------------------------------------------------------
for 循环
el:
func for_kw() {  
    // 遍历字符串  
    for _, v := range "nice" {  
        fmt.Printf("%c", v)  
    }  
    fmt.Println()  
    // 或
    for i := 0; i < 4; i   {  
        fmt.Print(i)  
    }  
    fmt.Println()  

    //数组  
    arr := [5]int{11, 22, 33, 44, 55}  
    for i := 0; i < len(arr); i   {  
        fmt.Printf("%d\t", arr[i])  
    }  
    fmt.Println()  

    //切片  
    slice := []int{1, 2, 3, 4, 5}  
    for i := 0; i < len(slice); i   {  
        fmt.Printf("%d\t", slice[i])  
    }  
    fmt.Println()  

    //映射  
    maps := map[string]string{"csdn": "csdnUrl", "weixin": "weixinUrl", "git": "weixinUrl"}  
    for k, v := range maps {  
        fmt.Println(k, v)  
    }  
}

字符串替换

Sprintf 根据格式化参数生成格式化的字符串并返回该字符串。
Printf  根据格式化参数生成格式化的字符串并写入标准输出。
// %d 表示整型数字，%s 表示字符串  
var stockcode=123  
var enddate="2020-12-31"  
var url="Code=%d&endDate=%s"  
var target_url=fmt.Sprintf(url,stockcode,enddate)  

fmt.Println(target_url)   // Code=123&endDate=2020-12-31
fmt.Printf(url,stockcode,enddate)    // Code=123&endDate=2020-12-31

Go 语言的空格

在 Go 语言中，空格通常用于分隔标识符、关键字、运算符和表达式，以提高代码的可读性。

Go 语言中变量的声明必须使用空格隔开，如：

var x int
const Pi float64 = 3.14159265358979323846

本节友情提醒：

idea 中使用go语言 定义的变量必须使用否者报错如下:

# command-line-arguments

.\test.go:14:2: n declared and not used

这篇好文章是转载于：学新通技术网