Go 语言基础语法|青训营

Elegent__77
61 阅读10分钟

Go 语言基础语法

Hello World

package main
import(
    "fmt"  //引入一个包，表示输入输出字符串、格式化字符串
)
func main(){
    fmt.Println("hello world")
}

变量

package main
import(
    "fmt" 
    "math"
)
func main(){
var a="initial"  //var 变量声明或者：=变量声明
var b,c int =1,2
var d=true
var e float64=0.0
f=float32(e)
g:=a+"foo"  //字符串可用“+“号直接拼接，可直接比较字符串
fmt.Println(a,b,c,d,e,f)
fmt.Println(g)
//常数定义
const h=50000  //const 常量定义
const i=3e20/h
fmt.Print(s,h,i,math,sin(h),math.sin(i))

if else 语句

package main
import "fmt"
func main (){
    if 7%2==0 {    //与C++不同的是if后无括号
        fmt.Println("7 is even")
        }else{
        fmt.Println("7 is odd")
        }
        
    if num :=9;num<10{
        fmt.Println(num,"is nwgative")
        }else if num<10{
        fmt.Println(num,"has 1 digit")
        }else{
        fmt.Println(num,"has multiple digits")
        }
}

循环

在Go语言中循环语句只有For循环，并且for循环语句可以跟if else 联合使用

package main
import "fmt"
func main(){
i:=1
for{
    fmt.Println("loop")
    break;
    }
for j:=7;j<9;j++{
    fmt.Println(j)
    }
for n:=0;n<5;n++{
    if n%2==0{
        continue
        }
        fmt.Println(n)
    }
for i<=3{
    fmt.Println(i)
    i=i+1
    }

switch语句

package main
import(
    "fmt"
    "time"
    )
func main(){
    a:=2
    switch a{
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")   //执行到此便会跳出此Switch语句
    case 3,4:
        fmt.Println("three or four")
    default:
        fmt.Println("other")
        }
        
        t:=time.now()
        switch{
            case t.time()<12:
                fmt.Println("It's before noon")
            default:
                fmt.Println("It's after noon")
                }
  }

数组

package main
import "fmt"
func main(){
var a[5] int
a[4]=100
fmt.Println(a[4],len(a))

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

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

切片

package main

import "fmt"

func main( ) {

s := make([]string，3)
s[0] ="a"
s[1]="b"
s[2]="c"
fmt.printin("get:",，s[2])// c
fmt.PrintIn( "len:",len(s)) // 3

s = append(s，"d")
s = append(s，"e"，"f")
fmt.Println(s) // [a b c d e f]

c := make([]string， len(s ))
copy(c，s)
fmt.Println(c) // [a b c d e f]

fmt.Pr&ntln(s[2:5]) // [c d e]
fmt .Println(s[:5])// [a bcde]
fmt .PrintIn(s[2:])//[cdef]

good := []string("g",O""d")
fmt .Println(good) // g o o d)
}

Go语言基础语法

切片

切片是一个可变长度的数组

package main
import "fmt"
func main(){

s:=make([]string,3)  //用make 创建一个数组
s[0]="a"
s[1]="b"
s[2]="c"
fmt.println("get:",s[2])   //c
fmt.println("len:",len(s))  //3

s=append(s,"d")   //用append追加赋值，注意要赋值给原数组
s=append(s,"e","f")
fmt.println(s)  //[a,b,c,d,e,f]

c:=make([]string,len(s))
copy(c,s)  //复制
fmt.println(c)    //[ a b c d e f ]

fmt.println(s[2:5])  //[c d e ]  表示取出第二个到第五个位置的数，不包括第五个位置
fmt.println(s[:5])   //[a b c d e]   表示去除从第0个到第五个位置的数，不包第都五个
fmt.println(s[2:])    //[c d e f ]   表示从第二个位置开始取数，直至取出剩下的所有

good := []string{"g","o","o","d"}
fmt.println(good)  //[g o o d ]
}

Map

哈希或者字典

package main

import "fmt"

func main(){
 m :=make(map[string]int)  //用make创建一个空map，这里需要两个类型，第一个类型是key的类型，此处为string，第二个类型为value的类型，此处为int类型
 m["one"]=1
 m["two"]=2
 fmt.println(m)   //map[one:1 two:2]
 fmt.println(len(m))  //2
 fmt.println(m["one"])  //1
 fmt.println(m["unknow"])  //0
 
 r,ok :=m["unknow"]   /* 此语句表示在 Map（映射）中查找键为"unknow"的元素。
 如果该元素存在，则将其对应的值赋给变量r，并将布尔值true赋给变量ok；
 如果该元素不存在，则将变量r的零值赋给r，并将布尔值false赋给变量ok。*/
 fmt.println(r,ok)  //0 false
 
 delete(m,"one")
 
 m2:=map[string]int{"one":1,"tow":2}
 var m3=map[string]int{"one":1,"two":2}
 fmt.println(m2,m3)   //输出不是按输入循序输出，二十按照随机的一个循序输出
 }

Range

用于遍历操作

package main
import main(){
nums :=[]int{2,3,4}
sum :=0
for i;num:=range nums{
    sum +=num
    if num ==2{
    fmt.println("index:",i,"num:",num)  //index: 0 num: 2
    }
 }
 fmt.println(sum)  //9
 
 m:=map[string]string{"a":"B","b":"B"}
 for k,v :=range m{
 fmt.println(k,v)  //b B:a A
}
for k:=range m{
fmt.println("key",k)  // key a; key b
    }
}

函数

package main
import "fmt"

func add(a int,b int)int{   //第三个int是返回值类型
    return a+b
}

func add2(a,b int）int{
    return a+b
}
func exists(m map[string]string,k string)(v string,ok bool){  //这里的返回值类型有两个
    v,ok =m[k]
    return v,ok
}
func main(){
    res :=add(1,2)
    fmt.println(res)  //3
    
    v,ok ：=exists(map[string]string{"a":"A"},"a")
    fmt.println(v,ok)   //A True
}

指针

package main
import "fmt"
func add2(n int){
    n +=2
}

func add2ptr(n *int){
    *n+=2
}

func main(){
    n:=5
    add2(n)
    fmt.println(n)   //2
    addsptr(&n)
    fmt.println(n)  //7
}

结构体

package main

import "fmt"

type user struck{
    name string
    password string
}

func main(){
    a:=user{name:"wang",password:"1024"}
    b:=user{"wang","1024"}
    c:=user{name:"wang"}
    c.password="1024"
    var d user
    d.name="wang"
    d,password="1024"
    fmt.println(a,b,c,d)   //{wang 1024}{wang 1024}{wang 1024}{wang 1024}
    fmt.println(checkPassword(a,"haha"))  //false
    fmt.println(checkPassword(&a,"haha"))  //false
    }
   
   func checkPassword(u user,password string)bool{
       return u.password==password
   }
   
   func checkPassword2(u *user,password string)bool{
       return u.password==password
   } 
   /*
checkPassword函数接受两个参数，一个是user类型的u，一个是字符串类型的password。
它的作用是比较u的password属性和传入的password参数是否相等，如果相等则返回true，否则返回false。
checkPassword2函数接受两个参数，一个是指向user类型的指针u，一个是字符串类型的password。
它的作用与checkPassword函数相同，比较u指针所指向的user对象的password属性和传入的password参数是否相等，
如果相等则返回true，否则返回false。
*/

结构体方法

在Go语言中，结构体方法是与特定结构体相关联的函数。结构体方法可以在结构体类型上定义，以便对该类型的实例执行特定的操作。结构体方法可以访问和修改结构体的字段，也可以调用其他方法。

结构体方法的语法如下：

func (s StructType) methodName() {
    // 方法的实现代码
}

其中，StructType是结构体类型的名称，methodName是方法的名称。在方法定义中，使用括号将结构体类型放在方法名称之前，表示该方法与该结构体类型相关联。

使用结构体方法的好处是，可以将操作和数据封装在一起，提高代码的可读性和维护性。结构体方法可以通过.运算符来调用，类似于其他语言中的对象方法。

package main

import "fmt"

type user struct{
    name string
    pssword string
}

func(u user)checkPassword(password string)bool{
    return u.password==password
}

func(u *user)resetPssword(password string){
    u.password=password
}

func main(){
    a :=user{name:"wang",password:"1024"}
    a.resetPassword("2048")
    fmt.println(a.checkPassword("2048"))  // true
}

错误处理

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.PrintIn(err) // not found
    return
} else {
    fmt .Println(u.name )
 }
}

/*这段代码的作用是查找用户列表中是否存在特定用户，并打印出该用户的名称。
如果找不到用户，则打印出错误信息*/

在Go语言中，nil表示一个空值或空指针。它可以用于表示变量没有被赋予任何值，或者表示指针没有指向任何有效的内存地址。

在上面的代码中，nil被用作返回值中的一个特殊值。在findUser函数中，如果找不到指定的用户，就会返回nil作为指向user类型的指针。在main函数中，我们可以通过检查返回的指针是否为nil来判断是否找到了用户。如果返回的指针为nil，则说明没有找到用户；否则，我们可以通过该指针访问到用户的字段值。

字符串操作

package main

import{
    "fmt"
    "strings"
}

func main(){
    a :="hello"
    fmt.println(strings.Containa(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,"llo"))   //2
    fmt.println(strings.Join([]string{"he","llo"},"-"))  //he-llo
    fmt.println(strings.Repeat(a,2))  //hellohello
    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

}

以下是strings包中一些常用函数的用法：

  1. Contains(s, substr string) bool：判断字符串s是否包含子字符串substr，返回一个布尔值。

fmt.Println(strings.Contains("hello", "ll")) // true

  1. Count(s, substr string) int：计算字符串s中子字符串substr的出现次数，返回一个整数。

fmt.Println(strings.Count("hello", "l")) // 2

  1. HasPrefix(s, prefix string) bool：判断字符串s是否以子字符串prefix开头，返回一个布尔值。

fmt.Println(strings.HasPrefix("hello", "he")) // true

  1. HasSuffix(s, suffix string) bool：判断字符串s是否以子字符串suffix结尾，返回一个布尔值。

fmt.Println(strings.HasSuffix("hello", "llo")) // true

  1. Index(s, substr string) int：查找子字符串substr在字符串s中的索引位置，返回一个整数。如果找不到，则返回-1。

fmt.Println(strings.Index("hello", "llo")) // 2

  1. Join(a []string, sep string) string：将字符串切片a中的元素用分隔符sep连接起来，返回一个新的字符串。

fmt.Println(strings.Join([]string{"hello", "world"}, "-")) // hello-world

  1. Repeat(s string, count int) string：将字符串s重复count次，返回一个新的字符串。

fmt.Println(strings.Repeat("hello", 3)) // hellohellohello

  1. Replace(s, old, new string, count int) string：将字符串s中的子字符串old替换为new，替换次数由count指定，返回一个新的字符串。

fmt.Println(strings.Replace("hello", "e", "E", -1)) // hEllo

  1. Split(s, sep string) []string：将字符串s按照分隔符sep进行分割，返回一个字符串切片。

fmt.Println(strings.Split("a-b-c", "-")) // [a b c]

  1. ToLower(s string) string：将字符串s转换为小写形式，返回一个新的字符串。

fmt.Println(strings.ToLower("HELLO")) // hello

  1. ToUpper(s string) string：将字符串s转换为大写形式，返回一个新的字符串。

fmt.Println(strings.ToUpper("hello")) // HELLO

  1. Len(s string) int：计算字符串s的长度，返回一个整数。

fmt.Println(len("hello")) // 5

这些函数提供了对字符串的常见操作，可以方便地进行字符串的查找、替换、分割、大小写转换等操作。

字符串格式化

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
    fmt.Printin(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}
    fmt.Printf("p=%+v\n"， p)// p=(x:1 y:2)
    fmt.Printf("p=%#v\n"，p) // p=main.point{x:1，y:2}
    
    f := 3.141592653
    fmt .Printin(f)  // 3.141592653
    fmt.Printf("%.2f\n"，f) // 3.14
}

在Go语言中，字符串格式化可以通过fmt.Sprintf函数来实现。fmt.Sprintf函数根据指定的格式将其他类型的值转换为字符串。

下面是一些常用的字符串格式化的示例：

  1. 格式化整数：

num := 42
str := fmt.Sprintf("%d", num)
fmt.Println(str) // 输出：42

  1. 格式化浮点数：

pi := 3.14159
str := fmt.Sprintf("%.2f", pi)
fmt.Println(str) // 输出：3.14

  1. 格式化布尔值：

flag := true
str := fmt.Sprintf("%t", flag)
fmt.Println(str) // 输出：true

  1. 格式化字符串：

name := "Alice"
str := fmt.Sprintf("Hello, %s!", name)
fmt.Println(str) // 输出：Hello, Alice!

  1. 格式化多个值：

age := 25
height := 1.75
str := fmt.Sprintf("I am %d years old and %.2f meters tall.", age, height)
fmt.Println(str) // 输出：I am 25 years old and 1.75 meters tall.

  1. 占位符

在格式化字符串时，可以使用占位符%来指定要格式化的值的类型。常用的占位符有：

  • %d：整数
  • %f：浮点数
  • %t：布尔值
  • %s：字符串

还可以使用一些修饰符来控制输出的格式，例如精度、宽度、填充字符等。

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...J
     fmt.PrintIn(string(buf)) // {"Name": "wang","age":18, "Hobby":["Golang","TypeScript"}
   
    buf, err = json.MarshalIndent(a,"","\t")
    if err != nil {
        pantc(err)
    }
    fmt.PrintIn(string(buf ))
    
    var b userInfo
    err = json.Unmarshal(buf,&b)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%#v\n", b) // man.userInfo{Name: "wang"，Age:18, Hobby:[]string"Golang"，"Type5cript"}}
}

package main

import (
    "encoding/json"
    "fmt"
)

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

func main() {
    a := userInfo{
        Name:  "wang",
        Age:   18,
        Hobby: []string{"Golang", "TypeScript"},
    }

    buf, err := json.Marshal(a) // Added missing ":" and corrected variable name "err"
    if err != nil {
        panic(err)
    }

    fmt.Println(buf)             // Print raw JSON bytes
    fmt.Println(string(buf))     // Print JSON string

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

    var b userInfo
    err = json.Unmarshal(buf, &b)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%#v\n", b)       // Print the unmarshaled struct
}
avatar
文章
阅读
粉丝