GO 语言基础语法一 (快速入门 Go 语言)

Posted 2023-03-08 DR5200

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了GO 语言基础语法一 (快速入门 Go 语言)相关的知识，希望对你有一定的参考价值。

Go语言基础语法

一. golang 标识符，关键字，命名规则
二. golang 变量
三. golang 常量
四. golang 数据类型
五. golang 布尔类型
六. golang 数字类型
七. golang 字符串
八. golang格式化输出
九. golang运算符
十. golang流程控制

一. golang 标识符，关键字，命名规则

二. golang 变量

三. golang 常量

四. golang 数据类型

五. golang 布尔类型

六. golang 数字类型

七. golang 字符串

1. go语言字符串字面量

在Go语言中，字符串字面量使用双引号 “” 或者反引号 ’ 来创建。双引号用来创建可解析的字符串，支持转义，但不能用来引用多行；反引号用来创建原生的字符串字面量，可能由多行组成，但不支持转义，并且可以包含除了反引号外其他所有字符。双引号创建可解析的字符串应用最广泛，反引号用来创建原生的字符串则多用于书写多行消息，html以及正则表达式。

package main

import (
	"fmt"
)

func main() 

	var s1 string = "hello world"

	var s2 string = `
		<html>
			<head><title> hello world </title>
		</html>
	
	`

	fmt.Printf("s1: %v\\n", s1)
	fmt.Printf("s2: %v\\n", s2)

运行结果

s1: hello world
s2: 
                <html>
                        <head><title> hello world </title>
                </html>

2. go语言字符串连接

(1). 使用加号

package main

import (
	"fmt"
)

func main() 

	name := "lyp"
	age := "20"
	msg := name + " is " + age

	fmt.Printf("msg: %v\\n", msg)

	msg = ""
	msg += name
	msg += " is "
	msg += age

	fmt.Printf("msg: %v\\n", msg)

运行结果

msg: lyp is 20
msg: lyp is 20

(2). 使用 fmt.Sprintf() 函数

package main

import (
	"fmt"
)

func main() 

	name := "lyp"
	age := "20"
	msg := fmt.Sprintf("%s is %s", name, age)

	fmt.Printf("msg: %v\\n", msg)

运行结果

msg: lyp is 20

(3). strings.Join()

package main

import (
	"fmt"
	"strings"
)

func main() 

	name := "lyp"
	age := "20"
	msg := strings.Join([]stringname, age, " is ")

	fmt.Printf("msg: %v\\n", msg)

运行结果

msg: lyp is 20

(4). buffer.WriteString()

package main

import (
	"bytes"
	"fmt"
)

func main() 

	var buffer bytes.Buffer
	buffer.WriteString("lyp")
	buffer.WriteString(" is ")
	buffer.WriteString("20")

	fmt.Printf("buffer.String(): %v\\n", buffer.String())

运行结果

buffer.String(): lyp is 20

3. go语言字符串转义字符

Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示

package main

import "fmt"

func main() 

	fmt.Printf("hello\\tworld\\n")

	fmt.Printf("\\"c:\\\\test\\\\\\"")

运行结果

hello   world
"c:\\test\\"

4. go语言字符串切片操作

package main

import "fmt"

func main() 

	str := "hello world"
	n := 3
	m := 5

	fmt.Println(str[n])   //获取字符串索引位置为n的原始字节
	fmt.Println(str[n:m]) //截取得字符串索引位置为 n 到 m-1 的字符串
	fmt.Println(str[n:])  //截取得字符串索引位置为 n 到 len(s)-1 的字符串
	fmt.Println(str[:m])  //截取得字符串索引位置为 0 到 m-1 的字符串

运行结果

108
lo
lo world
hello

5. go语言字符串常用方法

package main

import (
	"fmt"
	"strings"
)

func main() 
	s := "hello world！"
	fmt.Printf("len(s): %v\\n", len(s))
	fmt.Printf("strings.Split(s, \\"\\"): %v\\n", strings.Split(s, " "))
	fmt.Printf("strings.Contains(s, \\"hello\\"): %v\\n", strings.Contains(s, "hello"))
	fmt.Printf("strings.HasPrefix(s, \\"hello\\"): %v\\n", strings.HasPrefix(s, "hello"))
	fmt.Printf("strings.HasSuffix(s, \\"world！\\"): %v\\n", strings.HasSuffix(s, "world！"))
	fmt.Printf("strings.Index(s, \\"l\\"): %v\\n", strings.Index(s, "l"))
	fmt.Printf("strings.LastIndex(s, \\"l\\"): %v\\n", strings.LastIndex(s, "l"))

运行结果

len(s): 14
strings.Split(s, ""): [hello world！]
strings.Contains(s, "hello"): true
strings.HasPrefix(s, "hello"): true
strings.HasSuffix(s, "world！"): true
strings.Index(s, "l"): 2
strings.LastIndex(s, "l"): 9

八. golang格式化输出

package main

import "fmt"

type WebSite struct 
	Name string


func main() 
	site := WebSiteName: "lyp"
	fmt.Printf("site: %v\\n", site)
	fmt.Printf("site: %#v\\n", site)
	fmt.Printf("site: %T\\n", site)

	fmt.Println("%%")

	b := true
	fmt.Printf("b: %t\\n", b)

	i := 8
	fmt.Printf("i: %v\\n", i)
	fmt.Printf("i: %b\\n", i)

	i = 96
	fmt.Printf("i: %c\\n", i)
	fmt.Printf("i: %x\\n", i)

	x := 100
	p := &x
	fmt.Printf("p: %v\\n", p)

运行结果

site: lyp
site: main.WebSiteName:"lyp"
site: main.WebSite
%%
b: true
i: 8
i: 1000
i: `
i: 60
p: 0xc000016120

九. golang运算符

1. 算术运算符

++（自增）和–（自减）在Go语言中是单独的语句，并不是运算符(不能用在表达式中)

package main

import "fmt"

func main() 
	a := 100
	b := 10

	fmt.Printf("(a + b): %v\\n", (a + b))
	fmt.Printf("(a - b): %v\\n", (a - b))
	fmt.Printf("(a * b): %v\\n", (a * b))
	fmt.Printf("(a / b): %v\\n", (a / b))
	fmt.Printf("(a %% b): %v\\n", (a % b))

	a++
	fmt.Printf("a: %v\\n", a)
	b--
	fmt.Printf("b: %v\\n", b)

2. 关系运算符

package main

import "fmt"

func main() 
	a := 1
	b := 2

	fmt.Printf("(a > b): %v\\n", (a > b))
	fmt.Printf("(a < b): %v\\n", (a < b))
	fmt.Printf("(a >= b): %v\\n", (a >= b))
	fmt.Printf("(a <= b): %v\\n", (a <= b))
	fmt.Printf("(a == b): %v\\n", (a == b))
	fmt.Printf("(a != b): %v\\n", (a != b))

3. 逻辑运算符

package main

import "fmt"

func main() 
	a := true
	b := false

	fmt.Printf("(a && b): %v\\n", (a && b))
	fmt.Printf("(a || b): %v\\n", (a || b))
	fmt.Printf("(!a): %v\\n", (!a))
	fmt.Printf("(!b): %v\\n", (!b))

4. 位运算符

package main

import "fmt"

func main() 
	a := 4 // 二进制 100
	fmt.Printf("a: %b\\n", a)
	b := 8 // 二进制 1000
	fmt.Printf("b: %b\\n", b)

	fmt.Printf("(a & b): %v, %b \\n", (a & b), (a & b))
	fmt.Printf("(a | b): %v, %b\\n", (a | b), (a | b))
	fmt.Printf("(a ^ b): %v, %b\\n", (a ^ b), (a ^ b))
	fmt.Printf("(a << 2): %v, %b\\n", (a << 2), (a << 2))
	fmt.Printf("(b >> 2): %v, %b\\n", (b >> 2), (b >> 2))

5. 赋值运算符

package main

import "fmt"

func main() 
	var a int
	a = 100
	fmt.Printf("a: %v\\n", a)
	a += 1 // a = a + 1
	fmt.Printf("a: %v\\n", a)
	a -= 1 // a = a -1
	fmt.Printf("a: %v\\n", a)
	a *= 2 // a = a * 2
	fmt.Printf("a: %v\\n", a)
	a /= 2 // a = a / 2
	fmt.Printf("a: %v\\n", a)

十. golang流程控制

1. if 语句

if 布尔表达式 
   /* 在布尔表达式为 true 时执行 */

(1). 不需使用括号将条件包含起来
(2). 大括号必须存在，即使只有一行语句
(3). 左括号必须在if或else的同一行
(4). 在if之后，条件语句之前，可以添加变量初始化语句，使用；进行分隔
(5). 不能使用0或非0表示真假

func test3() 
	if age := 20; age > 18 
		fmt.Println("你是成年人")
	
	fmt.Printf("程序运行结束")


func main() 
	// test1()
	// test2()
	test3()

func test4() 
	var i = 1
	if i  // 编译失败
		fmt.Println("here")
	
	fmt.Printf("程序运行结束")

2. if else 语句

if 布尔表达式 
   /* 在布尔表达式为 true 时执行 */
 else 
  /* 在布尔表达式为 false 时执行 */

func f2() 
	var s int
	fmt.Println("输入一个数字：")
	fmt.Scan(&s)

	if s%2 == 0 
		fmt.Print("s 是偶数\\n")
	 else 
		fmt.Print("s 不是偶数\\n")
	
	fmt.Print("s 的值是：", s)

3. if else if 语句

if 布尔表达式1 
    // do something
 else if 布尔表达式2 
    // do something else
else 
    // catch-all or default

func f5() 
	if score := 80; score >= 60 && score <= 70 
		fmt.Println("C")
	 else if score > 70 && score <= 90 
		fmt.Println("B")
	 else 
		fmt.Println("A")

4. 嵌套 if 语句

if 布尔表达式 1 
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 
      /* 在布尔表达式 2 为 true 时执行 */

func f2() 
	// 判断男女生及年龄
	gender := "女生"
	age := 16
	if gender == "男生" 
		fmt.Println("男生")
		if age > 18 
			fmt.Println("成年")
		 else 
			fmt.Println("未成年")
		
	 else 
		fmt.Println("女生")
		if age > 18 
			fmt.Println("成年")
		 else 
			fmt.Println("未成年")

4. switch语句

switch var1 
    case val1:
        ...
    case val2:
        ...
    default:
        ...

func f() 
	grade := "A"
	switch grade 
	case "A":
		fmt.Println("优秀")
	case "B":
		fmt.Println("良好")
	default:
		fmt.Println("一般")

多条件匹配

func f() 
	day := 3
	switch day 
	case 1, 2, 3, 4, 5:
		fmt.Println("工作日")
	case 6, 7:
		fmt.Println("休息日")

case 可以是条件表达式

func f() 
	score := 90
	switch 
	case score >= 90:
		fmt.Println("享受假期")
	case score < 90 && score >= 80:
		fmt.Println("好好学习吧！")
	default:
		fmt.Println("玩命学习！")

fallthrough 强制执行后面的一个 case 代码
fallthrough 不能用在switch的最后一个分支

switch 
    case false:
        fmt.Println("The integer was <= 4")
        fallthrough
    case true:
        fmt.Println("The integer was <= 5")
        fallthrough
    case false:
        fmt.Println("The integer was <= 6")
        fallthrough
    case true:
        fmt.Println("The integer was <= 7")
        fallthrough
    case false:
        fmt.Println以上是关于GO 语言基础语法一 (快速入门 Go 语言)的主要内容，如果未能解决你的问题，请参考以下文章 
 学习Go语言快速入门
 Go 语言入门基础语法
 Go 快速入门
 Golang系列之快速入门教程
 我的Go+语言初体验——初学者的快速入门
 Go语言入门篇-命令 与 语法