Golang快速入门

Golang基础学习笔记整理,快速了解Golang的基础语法。

学习资料

一、开发环境配置

golang的安装非常简单,直接从golang的官网上下载对应系统的安装包直接安装即可;不过golang的官网:https://golang.org 国内由于特殊原因无法访问;因此请使用这个:https://golang.google.cn/

Windows和Mac安装直接根据安装界面一路next下去即可;唯一需要注意的是安装路径问题,如果不想用默认的可以修改安装路径(Windows的建议换一个没有空格的目录)。安装成功后输入go version 即可看到安装的版本。Mac 默认安装在/usr/local/go 目录下。

由于国内网络原因,有些包无法下载;因此需要配置GOPROXY来解决问题;即在环境变量里面配置添加GOPROXY的配置;下面是一些可用的国内源配置:

  • 阿里云的https://mirrors.aliyun.com/goproxy/
go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/
  • goproxy.io提供的服务 https://goproxy.io/zh/
# 配置 GOPROXY 环境变量
go env -w GOPROXY=https://goproxy.io,direct
# 还可以设置不走 proxy 的私有仓库或组,多个用逗号相隔(可选)
export GOPRIVATE=git.mycompany.com,github.com/my/private

二、常用命令

编译
go build go文件名称

# 自定义生成的exe文件名称
go build -o 自定义名字.exe go文件名称

# 示例
go build hello.go
go build main.go
go build -o hello.exe hello.go
运行程序
go run hello.go
格式化文件
gofmt -w hello.go
运行测试
go test -v
查看环境变量配置
go env
查看资源竞争情况
go build -race demo.go

三、基础语法和概念

这个基本和其他语言没有太大的差别,不同之处在于:golang的定义是将类型写变量的后面,同时不支持自动类型转换需要手动转换;包含的基础类型:bool、float32、float64、string、byte(uint8)、int、int8、int16、int32、int64、rune(int32,常用来处理unicode或utf-8字符);其他类型的切片、结构体、函数、接口、map。同时golang不需要在语句末尾写符号。

注意事项
  • 区分大小写;
  • 可以不写分号;
  • 定义或引入了的必须使用;
  • 一个文件夹下的.go文件中只能有一个main函数;
  • 不支持隐式转换;必须显示转换;
  • 函数不支持重载
  • 结构体中为属性的分配的地址是连续的
  • 结构体是使用的值传递
  • 结构体进行强制转换的时候需要2个结构体的属性都相同才可以

定义变量

语法如下,注意golang会自动设置初始值。

// 声明变量不赋值,将使用默认值, int 默认值为0
var a int

// 声明变量并赋值
var b int = 10

// 简化var关键词的写法
c := 100

// 根据值自动判断变量类型
var d = 10

// 一次性声明多个类型相同的变量
var n1, n2, n3 int

// 一次性声明多个变量,且类型不同
var age, nickName, addr = 10, "jerry", "北京"

// 一次性声明多个变量,简写var关键词
email, phone, pwd := "1314@qq.com", 9580, "123456"

// 声明多个全局变量时可以直接用一个var包裹
var (
    ok_status = "ok"
    ok_code = 200
)

// 如果字符在ascii表,则可以直接使用byte
var ch byte = 'a'
fmt.Println(ch)
var ch2 int = '蒲'
fmt.Println(ch2)
fmt.Printf("%c", ch2)

// rune处理unicode或utf-8字符;因为string底层使用的byte存储的,因此可以通过rune来解决中文问题
arr2 := []rune(str)
arr2[1] = '李'
str = string(arr2)
fmt.Println("str=", str)
字符串注意事项

注意字符串一旦赋值后就不能修改了,比如下面的这样是错误的

// 字符串赋值后不能修改
var str string = "help"
str[0] = 'a'

字符串拼接直接使用 + 即可;但是需要注意的是golang如果需要换行 + 必须放在上一行;如下:

// 需要把加号放到后面
var str4 = "hello" +
 "word"
 fmt.Println(str4)
数组的定义

数组在定义时就必须设置大小;不同空间大小的数组的类型是不一样的;注意:在函数中传递数组时,进行的是值传递;要和切片区分开。

var arr [6]int
arr[0] = 5

var arr1 [3]int = [3]int{
   1, 2, 3}
fmt.Println("arr1=", arr1)

var arr2 = [3]int{
   4, 5, 6}
fmt.Println("arr2=", arr2)

// 这里的...是固定写法;最终大小根据后面设置的初始值个数决定
var arr3 = [...]int{
   7, 8, 9}
fmt.Println("arr3=", arr3)

var arr4 = [...]int{
   1: 10, 0: 11, 2: 12}
fmt.Println("arr3=", arr4)

// 二维数组
var arr [6][6]int
arr[1][2] = 1
切片的定义

golang中的切片可以简单的认为就是一个动态扩容的数组。切片在底层分配的内存是连续的。


// 切片的定义和数组的很像,不指定大小
var slice []int
// 注意没有赋初始值的切片,必须通过make方法申请空间
slice = make([]int, 0)

// 赋初始值的切片
var slice2 []string = []string{
   "tom","jerry"}

// 从一个数组或者是切片中截取一段数据
arr := [...]int{
   1, 2, 3, 4}
// [1:3] 表示引用arr数组下标1到3的值(不包含3)
slice := arr[1:4]
// [:]这样表示拿全部;同时切片可以再切片
slice := arr[:]

// 查看slice的元素个数
fmt.Println("slice的元素个数:", len(slice))
// 查看slice的容量
fmt.Println("slice的容量", cap(slice))

// 添加新的元素到切片中
slice = append(slice, 40)
// 添加多个新的元素到切片中
slice = append(slice, 50, 60, 70)

arr[1] = 100
函数变量定义和使用

golang的函数也是一种变量,因此可以将函数也赋值给变量;写法其实和js的语法很像。下面是示例:

package main

import (
	"fmt"
	"strings"
)

// 累加
func AddUpper() func (int) int  {
   
	var n int = 0;
	return func (x int) int  {
   
		n = n+x;
		return n;
	}
}

// 判断是否包含后缀
func makeSuffix(suffix string) func (string) string {
   
	
	return func(name string) string {
   
		 if !strings.HasSuffix(name, suffix) {
   
			 return name + suffix
		 }
		 return name
	}
}

func main()  {
   
	// 将AddUpper函数赋值给变量f;即可通过f调用(有点像取了个别名)
	f := AddUpper()
	fmt.Println(f(1))

	suffix := makeSuffix(".jpg")
	fmt.Println(suffix("1.png"))
	fmt.Println(suffix("1.jpg"))
}
map
// 申明map
var a map[string]string

// map 需要手动分配初始空间
a = make(map[string]string, 2)

// 赋值 
a["no1"] = "张三"


// 定义的时候就分配空间
var map2 = make(map[string]string, 10)
map2["s1"] = "100"
fmt.Println(map2)

// 定义的时候就赋值
map3 := map[string]string {
   
    "address":"成都",
}
fmt.Println(map3)

// map<string, map>的结构
map4 := make(map[string]map[string]string, 2)
map4["001"] = make(map[string]string, 1)
map4["001"]["name"] = "jerry"
map4["001"]["age"] = "26"
map4["002"] = map3
fmt.Println(map4)

// 删除map中的值
delete(map4, "002")

// 如果想删全部的key,需要一个个的遍历来删除;或者重新开辟个空间
for k, _ := range map4 {
   
    delete(map4, k)
}
// 重新开辟个空间
map4 = make(map[string]map[string]string)

// map的查找, key 存在ex为true
val, ex := map3["address"]
fmt.Println(val, ex)

// map 切片的使用
var map5 []map[string]string
map5 = make([]map[string]string, 2)

// 这里不建议使用具体的数组下标来处理,因为容易越界
if map5[0] == nil {
   
    map5[0] = make(map[string]string, 2)
    map5[0]["name"] = "唐僧"
    map5[0]["store"] = "1000"
}
// 对应动态增加的,推荐使用下面这种方式
newMap := map[string]string {
   
    "name":"悟净",
    "store": "5000",
}
map5 = append(map5, newMap)
fmt.Println(map5)

// map的遍历
for k, v := range map6 {
   
    fmt.Println(k, "--", v)
}

// map 排序
map6 := map[int]int{
   1:1, 2:2, 4:4, 3:3,}
var keys []int
for k, _ := range map6 {
   keys = append(keys, k)}
for k, v := range map6 {
   fmt.Println(k, "--", v)}
sort.Ints(keys)
fmt.Println(keys)
结构体
type Person struct {
   
    Name string
    Age int
}

// 使用
p2 := Person{
   "jerry", 26}

// 定义指针类的
var p3 *Person = new(Person)
(*p3).Name = "tom"
// golang的设计者为让开发者使用方便,可以直接这样写
p3.Age = 26
fmt.Println(*p3)

// 定义指针类的
var p4 *Person = &Person{
   }
(*p4).Name = "tj"
// golang的设计者为让开发者使用方便,可以直接这样写
p4.Age = 0
fmt.Println(*p4)

// 定义指针类的简化写法
p5 := &Person{
   Name: "jerry", Age: 100}
p5.Age = 26
fmt.Println(p5)

// 为json序列化时设置别名
type Message struct {
   
    Type string `json:"type"`
    Data string `json:"data"`
}

类型的转换

golang不支持隐式转换;必须显示转换。

var a int = 100
var b float32 = float32(100)

var c int = 100
var d int32 = int32(100)
基于 fmt.Sprintf方法实现类型转换
var str string

// int 转string
var num1 int = 99
str = fmt.Sprintf("%d", num1)
fmt.Println(str)

// float转string
var num2 float64 = 23.456
str = fmt.Sprintf("%f", num2)
fmt.Println(str)

// bool转string
var b bool = true
str = fmt.Sprintf("%t", b)
fmt.Println(str)

// byte转string
var myChar byte = 'h'
str = fmt.Sprintf("%c", myChar)
fmt.Println(str)
fmt.Printf("str type %T, str=%q", str, str)

// byte数组转string
arr1 := []byte(str)
arr1[0] = 'z'
str = string(arr1)
fmt.Println("str=", str)

基于
  • 1
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值