cvmachine.com - 申博开户网

查找: 您的方位主页 > 网络频道 > 阅览资讯:Go编程言语攻略 学习笔记

Go编程言语攻略 学习笔记

2019-03-31 11:20:16 来历:www.cvmachine.com 【

网址:https://tour.go-zh.org/welcome/1

假如是为了将代码编译成一个可履行程序,那么package有必要是main

fmt 是go的一个体系库

fmt.println()则能够打印输出

界说变量和赋值能够一步完结经过: 变量名 := 值

var 变量名 变量类型;变量名 = 值。这儿需求留意:go言语中界说的变量有必要被用到,不然会报错

go的结构开发标准:

// 当时程序的包名
package main
//导入其他的包
import "fmt"
//常量的界说
const PI=3.14
//全局变量的声明和赋值
var name = "gopher"
//一般类型声明
type newType int
//结构的声明
type gopher struct{}
//接口的声明
type golang interface{}
//由main函数作为程序进口点发动
func main(){
  fmt.Println("Hello world! 你好国际")
}

defer 句子会将函数推延到外层函数回来之后履行。推延的函数调用会被压入一个栈中。当外层函数回来时,被推延的函数会依照后进先出的顺序调用。

package main

import "fmt"

func main() {
  fmt.Println("counting")

  for i := 0; i < 10; i++ {
    defer fmt.Println(i)
  }

  fmt.Println("done")
}

打印:counting done 9 8 7 6 5 4 3 2 1 0

go指针

Go 具有指针。指针保存了值的内存地址。类型 *T 是指向 T 类型值的指针。其零值为 nil

& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

* 操作符表明指针指向的底层值。

fmt.Println(*p) // 经过指针 p 读取 i
*p = 21     // 经过指针 p 设置 i
package main
import "fmt"
func main() {
i, j := 42, 2701
p := &i     // 指向 i
fmt.Println(*p) // 经过指针读取 i 的值
*p = 21     // 经过指针设置 i 的值
fmt.Println(i) // 检查 i 的值
p = &j     // 指向 j
*p = *p / 37  // 经过指针对 j 进行除法运算
fmt.Println(j) // 检查 j 的值
}
//42 31 73
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
v := Vertex{1, 2}
v.X = 4
fmt.Println(v.X)
fmt.Println(v.Y)
}
//4 2 

结构体字段能够经过结构体指针来访问。假如咱们有一个指向结构体的指针 p,那么能够经过 (*p).X 来访问其字段 X。直接写 p.X 就能够。

特别的前缀 & 回来一个指向结构体的指针。

package main
import "fmt"
type Vertex struct {
X, Y int
}
var (
v1 = Vertex{1, 2} // 创立一个 Vertex 类型的结构体
v2 = Vertex{X: 1} // Y:0 被隐式地赋予
v3 = Vertex{}   // X:0 Y:0
p = &Vertex{1, 2} // 创立一个 *Vertex 类型的结构体(指针)
)
func main() {
fmt.Println(v1, p, v2, v3)
}
//{1 2} &{1 2} {1 0} {0 0}

类型 [n]T 表明具有 nT 类型的值的数组。

package main
import "fmt"
func main() {
var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0], a[1])
fmt.Println(a)
primes := [6]int{2, 3, 5, 7, 11, 13}
fmt.Println(primes)
}
//Hello World
//[Hello World]
//[2 3 5 7 11 13]

类型 []T 表明一个元素类型为 T 的切片。切片经过两个下标来界定,即一个上界和一个下界,二者以冒号分隔:

a[low : high] 它会挑选一个半开区间,包括第一个元素,但扫除最终一个元素。
更改切片的元素会修正其底层数组中对应的元素。与它同享底层数组的切片都会观测到这些修正。切片的零值是 nil。
package main
import "fmt"
func main() {
names := [4]string{
"John",
"Paul",
"George",
"Ringo",
}
fmt.Println(names)
a := names[0:2]
b := names[1:3]
fmt.Println(a, b)
b[0] = "XXX"
fmt.Println(a, b)
fmt.Println(names)
}
//[John Paul George Ringo]
//[John Paul] [Paul George]
//[John XXX] [XXX George]
//[John XXX George Ringo]

切片下界的默许值为 0,上界则是该切片的长度。

切片的长度便是它所包括的元素个数。切片的容量是从它的第一个元素开端数,到其底层数组元素结尾的个数。

切片 s 的长度和容量可经过表达式 len(s)cap(s) 来获龋

package main
import "fmt"
func main() {
s := []int{2, 3, 5, 7, 11, 13}
printSlice(s)
// 截取切片使其长度为 0
s = s[:0]
printSlice(s)
// 拓宽其长度
s = s[:4]
printSlice(s)
// 放弃前3个值
s = s[3:]
printSlice(s)
}
func printSlice(s []int) {
fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}
//len=6 cap=6 [2 3 5 7 11 13]
//len=0 cap=6 []
//len=4 cap=6 [2 3 5 7]
//len=1 cap=3 [7]

%d 十进制表明

%v 相应值的默许格局

切片能够用内建函数 make 来创立,这也是创立动态数组的办法。a := make([]int, 5) // len(a)=5

要指定它的容量,需向 make 传入第三个参数: b := make([]int, 0, 5) // len(b)=0, cap(b)=5

//留意这儿的参数
package main
import "fmt"
func main() {
a := make([]int, 5)
printSlice("a", a)
b := make([]int, 0, 5)
printSlice("b", b)
c := b[:2]
printSlice("c", c)
d := c[2:5]
printSlice("d", d)
}
func printSlice(s string, x []int) {
fmt.Printf("%s len=%d cap=%d %v\n",
s, len(x), cap(x), x)
}
//a len=5 cap=5 [0 0 0 0 0]
//b len=0 cap=5 []
//c len=2 cap=5 [0 0]
//d len=3 cap=3 [0 0 0]

Println 与 Printf 的差异:

fmt 包完成了格局化 I/O 函数,类似于 C 的 printf 和 scanf。Println 与Printf 都是fmt 包中的公共办法,在需求打印信息时需求用到这二个函数。

Println :能够打印出字符串,和变量。Printf 在运用时需求给它指定一个格局化规矩,即第一个参数。留意参数输出数量和占位符数量要共同。
Printf : 只能够打印出格局化的字符串,能够输出字符串类型的变量,不能够输出整形变量和整形。

也便是说,当需求格局化输出信息时一般挑选 Printf,其他时分用 Println 就能够了,比方:

a := 10
fmt.Println(a)//right
fmt.Println("abc")//right
fmt.Printf("%d",a)//right
fmt.Printf(a)//error

向切片追加元素:Go 供给了内建的 append 函数。append 的第一个参数 s 是一个元素类型为 T 的切片,其他类型为 T 的值将会追加到该切片的结尾。append 的结果是一个包括原切片一切元素加上新增加元素的切片。

package main
import "fmt"
func main() {
var s []int
printSlice(s)
// 增加一个空切片
s = append(s, 0)
printSlice(s)
// 这个切片会按需增加
s = append(s, 1)
printSlice(s)
// 能够一次性增加多个元素
s = append(s, 2, 3, 4)
printSlice(s)
}
func printSlice(s []int) {
fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}
//len=0 cap=0 []
//len=1 cap=2 [0]
//len=2 cap=2 [0 1]
//len=5 cap=8 [0 1 2 3 4]

指针接收者的办法能够修正接收者指向的值。

package main
import (
"fmt"
"math"
)
type Vertex struct {
X, Y float64
}
func (v Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func (v *Vertex) Scale(f float64) {
v.X = v.X * f
v.Y = v.Y * f
}
func main() {
v := Vertex{3, 4}
v.Scale(10)
fmt.Println(v.Abs())
}
//50
//移除第 16 行 Scale 函数声明中的 *,输出5

带指针参数的函数有必要承受一个指针,而以指针为接收者的办法被调用时,接收者既能为值又能为指针。

for 循环的 range 方法可遍历切片或映射。当运用 for 循环遍历切片时,每次迭代都会回来两个值。第一个值为当时元素的下标,第二个值为该下标所对应元素的一份副本。能够将下标或值赋予 _ 来疏忽它。

package main
import "fmt"
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
func main() {
for i, v := range pow {
fmt.Printf("2**%d = %d\n", i, v)
}
}
//2**0 = 1
//2**1 = 2
//2**2 = 4
//2**3 = 8
//2**4 = 16

映射将键映射到值

映射的创立办法:

func main() {
  map1 := make(map[string]string) // map1: map[]
  map2 := make(map[string]string,5) // map2: map[]
  map3 := map[string]string{"num1":"num1","num2":"num2"} // map3: map[num1:num1 num2:num2]
  map4 := map[string]string{} // map4: map[]
}
package main
import "fmt"
type Vertex struct {
Lat, Long float64
}
var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}
func main() {
fmt.Println(m)
}
//map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]

 

 
 

本文地址:http://www.cvmachine.com/a/question/100148.html
Tags: 学习 编程言语 攻略
修改:申博开户网
关于咱们 | 联络咱们 | 友情链接 | 网站地图 | Sitemap | App | 回来顶部