go语言基础语法

最新推荐文章于 2024-04-15 09:10:57 发布

贪睡的蜗牛

最新推荐文章于 2024-04-15 09:10:57 发布

阅读量104

点赞数

分类专栏： Go 文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/baidu_41553551/article/details/123129088

版权

Go 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

由菜鸟教程中做的笔记

package main

import "fmt"

func main() {
fmt.Println("Hello, World!")
}

第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。
下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
使用 fmt.Print("hello, world\n") 可以得到相同的结果。
Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。
当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

1、Go 语言的字符串可以通过 + 实现

2、在变量与运算符间加入空格，程序看起来更加美观，如： fruit = apples + oranges;

3、 // %d 表示整型数字，%s 表示字符串 fmt.Sprintf 格式化字符串并赋值给新串

var stockcode=123
  var enddate="2020-12-31"
  var url="Code=%d&endDate=%s"
  var target_url=fmt.Sprintf(url,stockcode,enddate)
fmt.Println(target_url)

4、定义变量（声明什么类型）

// 没有初始化就为零值
var b int
fmt.Println(b)

// bool 零值为 false
var c bool
fmt.Println(c)

数值类型为0 布尔类型为false 字符串为"" （空字符串）其他的类型一般是nil

5、定义变量（不声明什么类型） 根据值自行判定变量类型

6、定义变量（使用:=确定变量类型并赋值）

var f string = "Runoob" 简写为 f := "Runoob"；

因此

var intVal int 
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明

因此

出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误

只能被用在函数体内，而不可以用于全局变量的声明与赋值。使用操作符 := 可以高效地创建一个新的变量，称之为初始化声明。

7、声明全局变量

// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

8、多变量声明

var c, d int = 1, 2

9、值类型和引用类型

int、float、bool 和 string 这些基本类型都属于值类型这个时候复制是将值进行拷贝

引用类型是= 只是引用

10、定义语言常量

显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"

11、在定义常量组时，如果不提供初始值，则表示将使用上行的表达式。

const (
    a = 1
    b
    c
    d
)

func main() {
    fmt.Println(a)
    // b、c、d没有初始化，使用上一行(即a)的值
    fmt.Println(b)   // 输出1
    fmt.Println(c)   // 输出1
    fmt.Println(d)   // 输出1
}

12、iota 只是在同一个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始。

const (
    i = iota
    j = iota
    x = iota
)
const xx = iota
const yy = iota
func main(){
    println(i, j, x, xx, yy)
}

// 输出是 0 1 2 0 0

13、左移右移

左移运算符 << 是双目运算符。左移 n 位就是乘以 2 的 n 次方。其功能把 << 左边的运算数的各二进位全部左移若干位，由 << 右边的数指定移动的位数，高位丢弃，低位补 0。

右移运算符 >> 是双目运算符。右移 n 位就是除以 2 的 n 次方。其功能是把 >> 左边的运算数的各二进位全部右移若干位， >> 右边的数指定移动的位数。

14、运算符

运算符和其他语言类似

& 返回变量存储地址，&a给出变量的实际地址

*指针变量，*a是一个指针变量

15、for循环

第一种类型

for i := 0; i <= 10; i++ {
sum += i
}

第二种类型

省略两个值

for ; sum <= 10; {
sum += sum
}

简化后（这时候就吧比较类似while语句了）

for sum <= 10{
sum += sum
}

第三种类型

无限循环

for {
sum++ // 无限循环下去
}

第四种类型

For-each range 循环

strings := []string{"google", "runoob"}
  for i, s := range strings {
fmt.Println(i, s)
  }

numbers := [6]int{1, 2, 3, 5}
  for i,x:= range numbers {
fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
  }

0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

第一值从0开始迭代递增

第二个值是直到末尾

16、break语句

跳出循环，继续执行剩下的语句

17、continue语句

跳出本次循环，执行下一次循环

18、语言函数

func 函数名（参数列表）返回类型{

}

如

func max(num1, num2 int) int { //这里参数列表只有一个标明num1，num2都是int类型

}

func swap(x, y string) (string, string) { //返回两个参数
return y, x
}

a, b := swap("Google", "Runoob") //调用的时候赋值给a和b

19、* 和&再次梳理

*代表的是取这个对应的值比如 *a 是取a的地址里面的值

&代表取地址 &a 是取a的地址

定义 *a int ； a是指针变量，专门用于存放地址

&需要与*配合使用，

1、如果p是int *指针变量，那么*&p = p，&*p = p，都是p，但还没定义p指向哪，存的是谁的地址。由于p是指针变量，那么它存放的数据就是正确的某个值的地址，这时候是合法的

2、如果p是一个int变量，那么*&p = p；而&*p是非法的，因为*p非法。

这里p仅是一个正常的变量，p指代的地址是不合法的，因此不能*p，这样是非法的

20、函数引用传递值

func swap(x *int, y *int) {}
调用 swap(&a, &b)

21、数组声明

var balance [10] float32

22、初始化数组

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

简化后

balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

数组长度不确定，使用...代替数组长度，编译器会根据元素个数自行推断数组的长度：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

 balance[4] = 50.0

切片的初始化

s := arr[:] 初始化切片 s，是数组 arr 的引用。

s := arr[:endIndex] 缺省 startIndex 时将表示从 arr 的第一个元素开始。

二维数组初始化

a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11},   /* 第三行索引为 2 */
}

23、go语言指针暂时不加以展开

24、go语言结构体

type Books struct {
title string
author string
subject string
book_id int
}
// 创建一个新的结构体对于没有初始化的字段会默认为0或者空
fmt.Println(Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407})

// 也可以使用 key => value 格式
fmt.Println(Books{title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", book_id: 6495407})

var book1 Books

访问结构体成员 book1.book_id

问题

数组

指针

26、go语言切片

27、go不支持隐式转换类型，只支持显示转换类型

mean = float32(sum)/float32(count)

贪睡的蜗牛

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
go语言基础语法

第一行代码package main定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。下一行import "fmt"告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。下一行func main()是程序开始执行的函数。main 函数是每一个可执行程序所必须包...
复制链接

扫一扫