go相当详细的基础语法

这篇具有很好参考价值的文章主要介绍了go相当详细的基础语法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

运行命令 go run xx.go或者 go build xx.go + ./xx

package main

import (
	"fmt"
)

func main() {
	fmt.Println("hello world")
}

基础语法

package main

import (
	"fmt"
	"math"
)

func main() {
	var a = "ivanlee"
	var b, c int = 1, 2
	var d = true
	var e float64
	f := float32(e)
	g := a + "_regina"
	fmt.Println(a, b, c, d, e, f)
	fmt.Println("g=", g)

	const s string = "constant"
	const h = 50000000
	const i = 3e20 / h
	fmt.Println(s, h, i, math.Sin(i))
}
  1. 定义变量可分为:var+变量定义,变量 :=
  2. 定义常量时没有类型限制,其可根据上下文自行进行定义

if/else

func main() {
	if 7%2 == 0 {
		fmt.Println("7%2==0")
	} else {
		fmt.Println("7%2!=0")
	}

	if num := 9; num < 0 {
		fmt.Println("num < 0")
	} else if num < 10 {
		fmt.Println("0<num<10")
	} else {
		fmt.Println("num>10")
	}
}

if 条件当中的语句不需要加括号,也可以在if当中添加变量的定义

for循环

go语言当中只有for循环,没有while循环

func main() {
	var i int = 1
	for {
		fmt.Println("loop")
		i = i + 1
		if i == 3 {
			break
		}
	}
	for n := 1; n < 9; n++ {
		
		if n%2 == 0 {
			continue
		}
        fmt.Println("n=",n)
	}

	for i <= 5 {
		fmt.Println("i=", i)
		i = i + 1
	}

}

如果for循环当中没有条件,则相当于python里面的while True,内部没有break则会一直执行

也可以像C++语法中的正常三个条件值进行编写,也可以提前定义变量以后进行范围操作,这一步也类似于while i<=5

switch

func main() {
	a := 2
	switch a {
	case 1:
		fmt.Println("a=1")
	case 2:
		fmt.Println("a=2")
	case 3, 4, 5:
		fmt.Println("a=3 or 4 or 5")
	default:
		fmt.Println("other")
	}

	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("morning")
	default:
		fmt.Println("afternoon")
	}
}

switch分支语句的用法中可以使用任意类型的变量,也可以在case语句当中使用,并且当case被命中之后,会直接跳出当前switch,运行后面的语句

数组

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 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)

定义数组时,大小必须是固定的,所以数组也并不常用。所以一般使用 切片技术,这样也就更像python的数组

s := make([]string, 3)
	s[0] = "a"
	s[1] = "b"

	fmt.Println(s)
	fmt.Println(len(s))

	s = append(s, "c")
	s = append(s, "d", "f")

	fmt.Println(s)

	c := make([]string, len(s))
	copy(c, s)
	fmt.Println(c)

	fmt.Println(c[2:5])
	fmt.Println(c[:5])
	fmt.Println(c[2:])

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

map

m := make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.Println(m)
fmt.Println(m["one"])
fmt.Println(m["regina"]) //没有key时会输出0
value, ok := m["regina"]
fmt.Println(value, ok)
delete(m, "two")

m2 := map[string]int{"three": 3, "four": 4}
var m3 = map[string]int{"five": 5, "six": 6}

fmt.Println(m2, m3)

make函数就是只用于定义,如果要赋值则直接在后面用{}进行赋值

map更像python里面的字典,可以用delete函数删除key,如果map里面没有key,则会有一个false值

range

n := []int{1,2,3,4,5}
sum := 0
for i, num := range n {
    sum += num
    if num == 2 {
        fmt.Println("index:", i, " num:", num)
    }
}
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
    fmt.Println("key:", k, " value:", v)
}
for k := range m {
    fmt.Println("key:", k)
}

函数

func add(a int, b int) int {
	return a + b
}
func add2(a, b int) int {
	return a + b
}
func exist(m map[string]string, k string) (v string, ok bool) {
	v, ok = m[k]
	return v, ok
}
func main() {
	fmt.Println(add(1, 2))
	fmt.Println(add2(2, 3))
	fmt.Println(exist(map[string]string{"a": "A", "b": "B"}, "A"))
	fmt.Println(exist(map[string]string{"a": "A", "b": "B"}, "a"))
}

函数定义时,参数需要类型定义,以及返回时的类型。如果有多个函数返回值,则分别说明类型

指针

func add(n int) {
	n += 2
}

func add2ptr(n *int) {
	*n += 2
}
func main() {
	n := 5
	add(n)
	fmt.Println(n)
	add2ptr(&n)
	fmt.Println(&n)
	fmt.Println(n)
}

结构体

Go 语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

func checkpwd(u user, pwd string) bool {
	if u.password == pwd {
		return true
	} else {
		return false
	}

}

func checkpwd2(u *user, pwd string) bool {
	if u.password == pwd {
		return true
	} else {
		return false
	}
}

func main() {
	a := user{name: "ivanlee", password: "regina"}
	b := user{"ivanlee", "regina"}
	c := user{name: "ivanlee"}
	c.password = "regina"

	var d user
	d.name = "ivanlee"
	d.password = "password"

	fmt.Println(checkpwd(a, "zjr")) //false
	fmt.Println(checkpwd2(&b, "regina")) //true
}

定义一个结构体之后,实例化有abcd四种赋值方法。结构体也拥有其方法,写法要更加简洁

type user struct {
	name     string
	password string
}

func (u user) checkpwd(pwd string) bool {
	return u.password == pwd

}

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

func main() {
	a := user{name: "ivanlee", password: "regina"}
	a.resetpwd("zjr")
	fmt.Println(a.checkpwd("zjr")) //true
}
func (u user) checkpwd(pwd string) bool` { 这种定义函数的方法,可以使得每一个实例化结构体的对象直接调用,把`func(a,pwd)`的写法变成了`a.func(pwd)

字符串操作

func main() {
	a := "hello"
	fmt.Println(strings.Contains(a, "ll"))//包含
	fmt.Println(strings.Count(a, "l"))
	fmt.Println(strings.HasPrefix(a, "he"))
	fmt.Println(strings.HasSuffix(a, "llo"))
	fmt.Println(strings.Index(a, "ll"))
	fmt.Println(strings.Join([]string{"hel", "lo"}, "-"))
	fmt.Println(strings.Repeat(a, 2))
	fmt.Println(strings.Split("a-b-c", "-")) //得到一个数组
	fmt.Println(strings.ToLower(a))
	fmt.Println(strings.ToUpper(a))
	fmt.Println(len(a))
}

字符串格式化

p := point{1, 2}

fmt.Printf("%+v\n", p)
fmt.Printf("%#v\n", p)
fmt.Printf("type: %T\n", p)

fmt.Printf("int %d\n", 123)
fmt.Printf("bin %b\n", 14)
fmt.Printf("char %c\n", 33)
fmt.Printf("hex %x\n", 27)
fmt.Printf("float1 %f\n", 78.9)
fmt.Printf("float2: %e\n", 123400000.0)
fmt.Printf("float3: %E\n", 123400000.0)

fmt.Printf("str1 %s\n", "\"string\"")
fmt.Printf("str2: %q\n", "\"string\"")
fmt.Printf("str3: %x\n", "hex this")

fmt.Printf("pointer: %p\n", &p)

fmt.Printf("width1: |%6d|%6d|\n", 12, 345)
fmt.Printf("width2: |%6.2f|%6.3f|\n", 1.2, 3.45)
fmt.Printf("width3: |%-6.2f|%-6.2f|\n", 1.2, 3.45)
fmt.Printf("width4: |%6s|%6s|\n", "foo", "b")
fmt.Printf("width5: |%-6s|%-6s|\n", "foo", "b")

s := fmt.Sprintf("sprintf: a %s", "string")
fmt.Println(s)

fmt.Fprintf(os.Stderr, "io: an %s\n", "error")

第3行:如果值是一个结构体,%+v 的格式化输出内容将包括结构体的字段名。

第4行:%#v 根据 Go 语法输出值,即会产生该值的源码片段

第5行:需要打印值的类型,使用 %T

第7行:格式化整型数有多种方式,使用 %d 进行标准的十进制格式化。

8-10行:分别是二进制,字符化,16进制

第11行:%f表示浮点数

12-13行:%e%E 将浮点型格式化为(稍微有一点不同的)科学记数法表示形式。

第15行:%s表示输出字符串,如果遇到双引号,使用%q

第17行:%x 输出使用 base-16 编码的字符串, 每个字节使用 2 个字符表示。

第19行:要输出一个指针的值,使用 %p

第21行:要指定整数的宽度,请在动词 “%” 之后使用数字。 默认情况下,结果会右对齐并用空格填充。

第22行:也可以指定浮点型的输出宽度,同时也可以通过 宽度.精度 的语法来指定输出的精度。

第23行:要左对齐,使用 - 标志

第27行:Printf通过 os.Stdout 输出格式化的字符串。 Sprintf 则格式化并返回一个字符串而没有任何输出

第30行:用 Fprintf 来格式化并输出到 io.Writers 而不是 os.Stdout

json

对于一个已有的结构体,只要保证每个字段段第一个字母是大写,也就是公开字段,那么这个结构体就可以用JSON.marshaler去序列化,变成一个json字符串。序列化之后的字符串可以通过JSON.unmarshaler去反序列化到一个空的变量里面。

package main

import (
	"encoding/json"
	"fmt"
)

type user struct {
	Name  string
	Age   int
	Hobby []string
}

func main() {
	a := user{"ivanlee", 18, []string{"basketball", "math"}}
	buf, err := json.Marshal(a)
	if err != nil {
		panic(err)
	}
	fmt.Println(buf)
	fmt.Println(string(buf))

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

	var b user
	err = json.Unmarshal(buf, &b)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", b)
}
  • 只要是可导出成员(变量首字母大写),都可以转成json。

时间处理

  • time.Now 得到的当前时间的时区跟电脑的当前时区一样。
  • time.Parse 把时间字符串转换为Time,时区是UTC时区。其中layout的时间必须是 "2006-01-02 15:04:05"****这个时间,不管格式如何,时间点一定得是这个,如:"Jan 2, 2006 at 3:04pm (MST)","2006-Jan-02"等。如换一个时间解析出来的时间就不对了,要特别注意这一点。
  • 不管Time变量存储的是什么时区,其Unix()方法返回的都是距离UTC时间:1970年1月1日0点0分0秒的秒数。
  • Unix()返回的秒数可以是负数,如果时间小于1970-01-01 00:00:00的话。
func main() {
	now := time.Now()
	fmt.Println(now)
	t1 := time.Date(2000, 1, 27, 1, 25, 36, 0, time.UTC)
	t2 := time.Date(2000, 1, 22, 1, 25, 36, 0, time.UTC)
	fmt.Println(t1)
	fmt.Println(t1.Year(), t1.Month(), t1.Day())
	fmt.Println(t1.Format("2006-01-02 15:04:05"))
	diff := t2.Sub(t1)
	fmt.Println(diff)
	t3, err := time.Parse("2006-01-02 15:04:05", "2022-02-10 01:23:45")
	if err != nil {
		panic(err)
	}
	fmt.Println(t3 == t1)
	fmt.Println(now.Unix())
}

数字和字符转换

在go语言中,字符串和数字之间的转换都存在"STR/conv"包中,可以使用parseint或者parseFloat函数解析一个字符串,可以使用Atoi函数把一个十进制的字符串转换成数字,用itoA函数把数字转换成字符串。

f, _ := strconv.ParseFloat("1.234", 64)
	//inputstring是一个用字符串表示的数字浮点数 bitSize是int类型的参数精度值。对于 float32 可以是 32,对于 float64 可以是 64
	//这个函数总是返回两个值。返回的float64值包含一个浮动数。如果需要,我们可以转换为float32值。如果不能将字符串转换为浮动数,则返回错误值*NumError。
	fmt.Println(f)
	n, _ := strconv.ParseInt("12345", 10, 64)
	//第二个参数代表进制
	fmt.Println(n)
	n1, _ := strconv.ParseInt("0x1000", 0, 64)
	//值为2~36,如果为0,则会根据字符串自动判断前置为"0x"的是16进制;前置为"0"的是8进制;其余的为10进制
	fmt.Println(n1)

	n2, _ := strconv.Atoi("123")
	fmt.Println(n2)
	n3, err := strconv.Atoi("AAA")
	fmt.Println(n3, err)
	n4 := strconv.Itoa(234)
	fmt.Println(n4)

进程信息

func main() {
	fmt.Println(os.Args)
	fmt.Println(os.Getenv("PATH"))
	fmt.Println(os.Setenv("AA", "BB"))
	buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
	//command里面的参数第一个是执行命令,后面所有全部都是参数
    if err != nil {
		panic(err)
	}
	fmt.Println(string(buf))
}

更多相关os模块用法

Getenv 函数会检索并返回名为 key 的环境变量的值。如果不存在该环境变量则会返回空字符串。

Setenv 函数可以设置名为 key 的环境变量,如果出错会返回该错误。文章来源地址https://www.toymoban.com/news/detail-442343.html

到了这里,关于go相当详细的基础语法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 3 Go的基础语法

    概述         在上一节的内容中,我们介绍了第一个Go程序,包括:安装Go环境、编写第一个Go程序、编译并运行程序等。在本节中,我们将介绍Go的基础语法。Go是一门简洁和优雅的语言,有自己特殊的一些语法规则。因此,在介绍Go编程的有关知识之前,先熟悉下Go的基础

    2024年02月08日
    浏览(27)
  • Go 语言面试题(一):基础语法

    := 声明+赋值 = 仅赋值 指针用来保存变量的地址。 例如 运算符,也称为解引用运算符,用于访问地址中的值。 &运算符,也称为地址运算符,用于返回变量的地址。 允许 Go 没有异常类型,只有错误类型(Error),通常使用返回值来表示异常状态。 Goroutine 是与其他函数或方

    2024年02月14日
    浏览(46)
  • 走进 Go 语言基础语法 | 青训营 (1)

    Powered by: NEFU AB-IN Go 语言入门指南:基础语法和常用特性解析 go.mod 这个文件里记录了当前项目里所有依赖包的 git 仓库地址以及对应的 版本号 ,来解决了包依赖管理的问题,后续在构建编译时,就会根据对应的版本号去拉取依赖包。 注意, 如果当前的项目是要给外部使用的

    2024年02月14日
    浏览(42)
  • Go语言入门指南:基础语法和常用特性(下)

    上一节,我们了解Go语言特性以及第一个Go语言程序——Hello World,这一节就让我们更深入的了解一下Go语言的**基础语法**吧! 在 Go 程序中,一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾,因为这些工作都将由 Go 编译器自动完成。 建议不要

    2024年02月12日
    浏览(44)
  • Go 语言入门指南:基础语法和常用特性解析

    代码解释: 变量声明和初始化: var a = \\\"initial\\\" :声明一个名为 a 的变量,初始值为字符串 “initial”。 var b, c int = 1, 2 :声明两个整数变量 b 和 c ,并分别初始化为 1 和 2。 var d = true :声明一个布尔变量 d ,初始值为 true 。 var e float64 :声明一个浮点数变量 e ,因为没有显

    2024年02月11日
    浏览(45)
  • Go语言入门指南:基础语法和常用特性解析(上)

    Go是一种静态类型的编译语言,常常被称作是21世纪的C语言。Go语言是一个开源项目,可以免费获取编译器、库、配套工具的源代码,也是高性能服务器和应用程序的热门选择。 Go语言可以运行在类UNIX系统——比如Linux、OpenBSD、Microsoft Windows等操作系统上。 因为Go语言的特性,

    2024年02月12日
    浏览(40)
  • Go 语言入门指南: 环境搭建、基础语法和常用特性解析 | 青训营

    Go 是一个开源的编程语言,它能让构造简单、可靠且高效的软件变得容易。 Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发,后来还加入了Ian Lance Taylor, Russ Cox等人,并最终于2009年11月开源,在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的,并且

    2024年02月14日
    浏览(35)
  • 推荐windows命令行软件管理工具WinGet,相当方便!

    WinGet是微软推出的支持win10及以上操作系统的软件管理工具,全称为\\\'windows package manager client\\\'。 可以在windows操作系统命令行轻松的安装/卸载或升级应用程序,里面的软件库对接的是\\\'Microsoft Store\\\'(微软应用商店)。 WinGet工具默认是操作系统本身就自带的,若是需要升级可以前

    2024年02月09日
    浏览(85)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包