变量

package main

import "fmt"
func main(){
  //变量的三种定义方式
  var a string ="big mouse"
  var a1 = 10
  a2:=2.1111
  fmt.Println(a,a1,a2)
}

if-else

package main

import "fmt"
func main(){
 var a=10
  if a>10{
    fmt.Println("大于十！！！")
  }else{
    fmt.Println("小于十！！！")
  }
}

循环

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d\n", i)
    }
}

switch

package main

import "fmt"

func main() {
    var a int 
    fmt.Println("请输入一个数字！！！")
    fmt.Scanln(a)
    switch a{
      case 1:
      fmt.Println("1")
       case 2:
      fmt.Println("2")
      case 3:
      fmt.Println("3")
    }
}

数组

package main

import "fmt"

func main() {
    // 一维数组的创建方式两种
    var a [10]int
    a[0] = 0
    a[1] = 1
    a[2] = 2
    fmt.Println(a)

    // var a1 [10]int={1,2,3,4,5,6,7,8,9,10}
    // 错误：在初始化数组时，不能使用 var 而且 [10]int 放到后面
    //只需 a1 := [10]int{1,2,3,4,5,6,7,8,9,10}
    a1 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println(a1)

    // 错误：在初始化切片时，不能使用 var，只需 a2 := []int{1,2,3}
    a2 := []int{1, 2, 3}
    fmt.Println(a2)

    // 定义二维数组
    // 错误：在二维数组的初始化中，元素之间应该使用逗号 , 而不是分号 ;
    a3 := [2][3]int{{1, 2, 2}, {1, 2, 2}}
    fmt.Println(a3)

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

切片

package main

import "fmt"

func main() {
    //创建切片
    slice :=make([]int,3)
    slice[0]=1
    slice[1]=2
    slice[2]=3
    //错误
    // slice.append(slice,1)
    // slice.append(slice,5,6)
    //append使用方法 
    slice=append(slice,1)
    slice=append(slice,1,2)
    fmt.Println(slice)
    s:=make([]int,len(slice))
    copy(s,slice)
    fmt.Println(s)
    //第二种定义方式
    s1:=[]int{1,2,3}
    s1=append(s1,1)
    fmt.Println(s1)
}

map

package main

import "fmt"

func main() {
   //创建map 3种方法
    a:=make(map[string]int)
    a["1"]=1
    a["2"]=2
    a["3"]=3
    fmt.Println(a)
    a1:=map[string]int{"1":1,"2":2}
    fmt.Println(a1)
    var a2 =map[string]int{"1":1,"2":2}
    fmt.Println(a2)
    //删除
    delete(a2,"1")
    fmt.Println(a2) 
  
}

-range

package main

import "fmt"

func main() {
   //range 既可以便利数组也可以便利map
    a:=[5]int{1,2,3,4,5}
    for k,v:=range(a){
      fmt.Println(k,v)
    }
    a1:=map[string]int{"1":1,"2":2}
    for k:=range(a1){
      fmt.Println(k)
    }
}

函数

package main

import "fmt"
func Handle(a int,b int)int{
  var c=a+b
  return c
}
func main() {
   fmt.Println(Handle(1,2))
}

指针

package main

import "fmt"
func Handle(a int)int{
  a+=1
  return a
}
func Handle1(a *int)int{
  *a+=1
  return *a
}
func main() {
    var a=1
    fmt.Println(Handle(a))
    fmt.Println(a)
    fmt.Println(Handle1(&a))
    fmt.Println(a)
}

结构体

package main

import "fmt"
type User struct{
  Username string
  Passord string
}
func main() {
    a:=User{Username:"1",Passord:"2"}
    a1:=User{"1","2"}
    a2:=User{Username:"1"}
    a2.Passord="2"
    var d User
    d.Passord="1"
    d.Username="2"
    fmt.Println(a)
    fmt.Println(a1)
    fmt.Println(a2)
    fmt.Println(d)
  
}

结构体方法

package main

import "fmt"
type User struct{
  Username string
  Passord string
}
func(a User)Handle(a1 string){
  a.Username=a1
}
func(a *User)Handle1(a1 string){
  a.Username=a1
}
func main() {
  a2:=User{Username:"1",Passord:"2"}
  a2.Handle("wang")
  fmt.Println(a2.Username)
  a2.Handle1("wang")
  fmt.Println(a2.Username)
    
  
}

错误处理

package main

import (
	"errors"
	"fmt"
)

type user struct {
	name     string
	password string
}
//结构体切片
func findUser(users []user, name string) (v *user, err error) {
	for _, u := range users {
		if u.name == name {
			return &u, nil
		}
	}
  //自定义错误类型，直接报出错误。
	return nil, errors.New("not found")
}

func main() {
  //给结构体切片赋值
	u, err := findUser([]user{{"wang", "1024"}}, "wang")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(u.name) // wang

	if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
		fmt.Println(err) // not found
		return
	} else {
		fmt.Println(u.name)
	}
}

字符串操作


package main

import (
	"fmt"
	"strings"
)

func main() {
	a := "hello"
  //字符串是否包含一个子串
	fmt.Println(strings.Contains(a, "ll"))   // true
  //字符串中包含多少个字符
	fmt.Println(strings.Count(a, "l"))                    // 2
  //是否已这个字串为前缀
	fmt.Println(strings.HasPrefix(a, "he"))               // true
  //是否以这个为后缀
	fmt.Println(strings.HasSuffix(a, "llo"))              // true
  //判断子串的位置，下标索引
	fmt.Println(strings.Index(a, "ll"))                   // 2
  //把两个字符串形成一个新的字符串
	fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
  //重复输出n的字符串
	fmt.Println(strings.Repeat(a, 2))                     // hellohello
  //从后往前找“e”成“E”从后后往前找
	fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
  //字符串分割函数
	fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
  //全部转化成小写 全部转化成大写
	fmt.Println(strings.ToLower(a))                       // hello
  //全部转化成大写
	fmt.Println(strings.ToUpper(a))                       // HELLO
	fmt.Println(len(a))                                   // 5
	b := "你好"
	fmt.Println(len(b)) // 6
}

字符串格式化

package main

import "fmt"

type point struct {
	x, y int
}

func main() {
	s := "hello"
	n := 123
	p := point{1, 2}
	fmt.Println(s, n) // hello 123
  //p := point{1, 2} 是一个Go语言中的结构体（struct）的初始化语法。
  //在这个例子中，point 是一个结构体类型，它包含两个字段（field）：x 和 y。
  //通过使用结构体 初始化语法，我们可以创建一个新的结构体变量，并为其字段赋予初始值。
	fmt.Println(p)    // {1 2}
	fmt.Printf("s=%v\n", s)  // s=hello
	fmt.Printf("n=%v\n", n)  // n=123
	fmt.Printf("p=%v\n", p)  // p={1 2}
  //%+v 是格式化字符串中的占位符，用于打印结构体的详细信息。在这个例子中，它会打印出结构
  //体变量 p 的字段名和对应的值。
	fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
  //%#v 是另一个格式化字符串中的占位符，用于打印结构体的详细信息，并包含类型信息。在这个例   
  //子中，它会打印出结构体变量 p 的类型和字段名及对应的值。
	fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}

	f := 3.141592653
	fmt.Println(f)          // 3.141592653
	fmt.Printf("%.2f\n", f) // 3.14
}

JSON处理

package main

import (
	"encoding/json"
	"fmt"
)

type userInfo struct {
	Name  string
	Age   int `json:"age"`
	Hobby []string
}

func main() {
	a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
	buf, err := json.Marshal(a)
	if err != nil {
		panic(err)
	}
	fmt.Println(buf)         // [123 34 78 97...]
	fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}

	buf, err = json.MarshalIndent(a, "", "\t")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(buf))

	var b userInfo
	err = json.Unmarshal(buf, &b)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}

时间处理

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
  //创建时间对象
	t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
	t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
	fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC
	fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
  //把现在时间转化成 2006-01-02 15:04:05格式-2022-03-27 01:25:36
	fmt.Println(t.Format("2006-01-02 15:04:05"))                    // 2022-03-27 01:25:36
  //计算t2和t的时间差。
	diff := t2.Sub(t)
	fmt.Println(diff)                           // 1h5m0s
	fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
  //把字符串形式转化成时间形式"2006-01-02 15:04:05"是固定的 后面的时间会转化
	t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
	if err != nil {
		panic(err)
	}
	fmt.Println(t3 == t)    // true
  //转化成当前时间的时间戳
	fmt.Println(now.Unix()) // 1648738080
}

数字解析

package main

import (
	"fmt"
	"strconv"
)

func main() {
	f, _ := strconv.ParseFloat("1.234", 64)
	fmt.Println(f) // 1.234

	n, _ := strconv.ParseInt("111", 10, 64)
	fmt.Println(n) // 111

	n, _ = strconv.ParseInt("0x1000", 0, 64)
	fmt.Println(n) // 4096

	n2, _ := strconv.Atoi("123")
	fmt.Println(n2) // 123

	n2, err := strconv.Atoi("AAA")
	fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}

进程信息

package main

import (
	"fmt"
	"os"
	"os/exec"
)

func main() {
	// go run example/20-env/main.go a b c d
	fmt.Println(os.Args)           // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
	fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
	fmt.Println(os.Setenv("AA", "BB"))

	buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
	if err != nil {
		panic(err)
	}
	fmt.Println(string(buf)) // 127.0.0.1       localhost
}

golang基础语法｜ 青训营

变量

if-else

循环

switch

数组

切片

map

-range

函数

指针

结构体

结构体方法

错误处理

字符串操作

字符串格式化

JSON处理

时间处理

数字解析

进程信息

golang基础语法｜青训营