一起学Go吧! Go语言基础语法篇一

  • 时间:
  • 浏览:
  • 来源:互联网

在这里插入图片描述

文章目录

  • 前言
  • Go的程序结构
  • Go的基础语法
  • Go语言常见数据类型
  • Go语言定义变量
  • Go的条件语句
  • Go循环语句
  • Go 语言函数
  • Go 语言数组
  • 语法篇一总结

前言

Go的基础语法学好后,对后面项目的进行有极大的帮助!

如果还没安装好环境的童鞋,可以先参照博主的这篇文章进行搭建

一起学Go吧! Go语言入门篇(搭建Go的环境)
在这里插入图片描述


Go的程序结构

Go 语言的基础组成有以下几个部分:

  1. 包声明
    必须在源文件中非注释的第一行指明这个文件属于哪个包,如:package main。package main表示一个可独立执行的程序,每个 Go 应用程序都包含一个名为 main 的包。
  2. 引入包
    import (“fmt”) 告诉 Go 编译器这个程序需要使用 fmt 包(的函数,或其他元素),fmt 包实现了==格式化 IO(输入/输出)==的函数。
  3. 函数
    func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的,一般来说都是在启动后第一个执行的函数(如果有 init() 函数则会先执行该函数)。
  4. 变量
    当标识符(包括常量、变量、类型、函数名、结构字段等等)以一个大写字母开头,如:Group1,那么使用这种形式的标识符的对象就可以被外部包的代码所使用(客户端程序需要先导入这个包),这被称为导出(像面向对象语言中的 public);标识符如果以小写字母开头,则对包外是不可见的,但是他们在整个包的内部是可见并且可用的(像面向对象语言中的 protected )。
  5. 语句 & 表达式
    就是函数中的每一行代码
  6. 注释
    // 是注释,在程序执行时将被忽略。单行注释是最常见的注释形式,你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释,均已以 /* 开头,并以 */ 结尾,且不可以嵌套使用,多行注释一般用于包的文档描述或注释成块的代码片段。注释不会被编译器所编译

打印 Hello World 程序实例

package main   //包声明

import (  //引入包
	"fmt"
)

/*
*  多行注释
*/

func main() {  //main函数,主程序入口
	fmt.Println("Hello World")  //语句&表达式
}

注意点
需要注意的是 { 不能单独放在一行,所以以下代码在运行时会产生错误:(Go在代码风格上强制约束受到许多开发者的厌恶,但那又怎样,Go还是强的一匹😄)

package main

import "fmt"

func main()  
{  // 错误,{ 不能在单独的行上
    fmt.Println("Hello, World!")
}

Go的基础语法

行分隔符
在 Go 程序中,一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾,因为这些工作都将由 Go 编译器自动完成。

如果你打算将多个语句写在同一行,它们则必须使用 ; 人为区分,但在实际开发中我们并不鼓励这种做法。

以下为两个语句:

fmt.Println("Hello, World!")  //不需要加分号
fmt.Println("菜鸟教程:runoob.com")

标识符
标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(AZ和az)数字(0~9)、下划线_组成的序列,但是第一个字符必须是字母或下划线而不能是数字。

以下是有效的标识符:

mahesh   kumar   abc   move_name   a_123
myname50   _temp   j   a23b9   retVal

以下是无效的标识符:

1ab(以数字开头)
case(Go 语言的关键字)
a+b(运算符是不允许的)

字符串连接
Go 语言的字符串可以通过 + 实现:

package main
import "fmt"
func main() {
    fmt.Println("Google" + "Runoob") //打印结果为 GoogleRunoob
}

Go语言的保留关键字

breakdefaultfuncinterfaceselect
casedefergomapstruct
chanelsegotopackageswitch
constfallthroughifrangetype
continueforimportreturnvar

Go 语言的空格
Go 语言中变量的声明必须使用空格隔开,如:

var age int;

语句中适当使用空格能让程序更易阅读。

无空格:

son=father+monther

在变量与运算符间加入空格,程序看起来更加美观,如:

son = father + monther

Go语言常见数据类型

数据类型的出现是为了把数据分成所需内存大小不同的数据,编程的时候需要用大数据的时候才需要申请大内存,就可以充分利用内存。

  1. 布尔型
    布尔型的值只可以是常量 true 或者 false。
    一个简单的例子: var b bool = true。

  2. 数字类型
    整型 int 和浮点型 float32、float64,Go 语言支持整型和浮点型数字,并且支持复数,其中位的运算采用补码。

  3. 字符串类型:
    字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。

  4. 派生类型:

    1. 指针类型(Pointer)
    2. 数组类型
    3. 结构化类型(struct)
    4. Channel 类型
    5. 函数类型
    6. 接口类型(interface)
    7. Map 类型

Go语言定义变量

Go 语言变量名由字母、数字、下划线组成,其中首个字符不能为数字。

声明变量的一般形式是使用 var 关键字:

var identifier type

可以一次声明多个变量:

var identifier1, identifier2 type

实例

package main
import "fmt"
func main() {
    var a string = "CSDN"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)
}

变量声明
第一种,指定变量类型,如果没有初始化,则变量默认为零值。

var v_name v_type
v_name = value

零值就是变量没有做初始化时系统默认设置的值。

package main
import "fmt"
func main() {

    // 声明一个变量并初始化
    var a = "RUNOOB"
    fmt.Println(a)

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

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

字符串的零值为 “”(空字符串)
以下几种类型的零值为nil:

var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

第二种,根据值自行判定变量类型。

var v_name = value
package main
import "fmt"
func main() {
    var d = true // var b bool = true 简写为 var b = true
    fmt.Println(d)
}

第三种,省略 var, 注意 := 左侧如果没有声明新的变量,就产生编译错误,格式:

v_name := value

例如:

var intVal int 

intVal :=1 // 这时候会产生编译错误

intVal,intVal1 := 1,2 // 此时不会产生编译错误,因为有声明新的变量,因为 := 是一个声明语句

可以将 var f string = “Runoob” 简写为 f := “Runoob”:

package main
import "fmt"
func main() {
    f := "Runoob" // var f string = "Runoob"

    fmt.Println(f)
}

多变量声明

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type

vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型,自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的,否则会导致编译错误


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

实例

package main

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

输出结果为
在这里插入图片描述

Go 语言常量
常量是一个简单值的标识符,在程序运行时,不会被修改的量。

常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型。

常量的定义格式:

const identifier [type] = value

你可以省略类型说明符 [type],因为编译器可以根据变量的值来推断其类型。

  • 显式类型定义: const b string = “abc”
  • 隐式类型定义: const b = “abc”

多个相同类型的声明可以简写为:

const c_name1, c_name2 = value1, value2

实例

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5  
   var area int
   const a, b, c = 1, false, "str" //多重赋值

   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d", area)
   println()
   println(a, b, c)  
}

打印结果
在这里插入图片描述


Go的条件语句

if 语句
Go 编程语言中 if 语句的语法如下:

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

实例

package main

import "fmt"

func main() {
	var a int = 6
	if a <= 6 {
		fmt.Print(a)
	} else {
		fmt.Println(a + 1)
	}
}

Switch语句
switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是唯一的,从上至下逐一测试,直到匹配为止。

switch 语句执行的过程从上至下,直到找到匹配项,匹配项后面也不需要再加 break。

switch 默认情况下 case 最后自带 break 语句匹配成功后就不会执行其他 case,如果我们需要执行后面的 case,可以使用 fallthrough 。

Switch实例

package main

import "fmt"

func main() {
	var a int = 6
	switch a {
	case 6:
		fmt.Print(a)
	case 7:
		fmt.Println(a + 1)
	default:
		fmt.Println("default")
	}
}


Go循环语句

  1. for循环语句
    for 循环是一个循环控制结构,可以执行指定次数的循环。
    Go 语言的 For 循环有 3 种形式,只有其中的一种使用分号。
    1. for init; condition; post { }
    2. for condition { }
    3. for { }
  • init: 一般为赋值表达式,给控制变量赋初值;
  • condition: 关系表达式或逻辑表达式,循环控制条件;
  • post: 一般为赋值表达式,给控制变量增量或减量。
  • for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下:
for key, value := range oldMap {
    newMap[key] = value
}

实例

  • 计算 1 到 10 的数字之和
package main

import "fmt"

func main() {
	var sum int = 0
	for i := 1; i <= 10; i++ {
		sum += i
	}
	fmt.Print(sum)
}

For-each range 循环
这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

package main

import "fmt"

func main() {
	strings := []string{"google", "runoob"}
	//i 代表遍历时候的数组下标,s代表数组每一项的值
	for i, s := range strings {
		fmt.Println(i, s)
	}

	//i 代表遍历时候的数组下标,number代表数组每一项的值
	numbers := []int{1, 2, 3, 4}
	for i, number := range numbers {
		fmt.Println(i, number)
	}
}


Go 语言函数

函数是基本的代码块,用于执行一个任务。

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能,逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称,返回类型,和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如,len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度,如果传入的是数组,则返回数组中包含的元素个数。

函数定义

func function_name( [parameter list] ) [return_types] {
   函数体
}

函数定义解析:

  • func:函数由 func 开始声明
  • function_name:函数名称,函数名和参数列表一起构成了函数签名。
  • parameter list:参数列表,参数就像一个占位符,当函数被调用时,你可以将值传递给参数,这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的,也就是说函数也可以不包含参数。
  • return_types:返回类型,函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值,这种情况下
  • return_types 不是必须的。 函数体:函数定义的代码集合。

实例
以下实例为 max() 函数的代码,该函数传入两个整型参数 num1 和 num2,并返回这两个参数的最大值:

package main

import "fmt"

func max(num1, num2 int) int {
	var result int
	if num1 > num2 {
		result = num1
	} else {
		result = num2
	}
	return result
}

func main() {
	fmt.Print(max(1, 2))
}

函数返回多个值
比如交换函数

package main

import "fmt"

func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, b := swap("A", "B")
	fmt.Println(a, b)
}

Go默认采用的函数传值是值传递方式

Go的引用传递实例

package main

import "fmt"

func swap(x *int, y *int) {
	var tmp int
	tmp = *x
	*x = *y
	*y = tmp
}

func main() {
	var a, b int = 1, 2
	//因为要引用传递,所以用 & 符号将变量的地址值传递过去
	swap(&a, &b)
	fmt.Println(a, b)
}


Go 语言数组

Go 语言提供了数组类型的数据结构。

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。

相对于去声明 number0, number1, …, number99 的变量,使用数组形式 numbers[0], numbers[1] …, numbers[99] 更加方便且易于扩展。

数组元素可以通过索引(位置)来读取(或者修改),索引从 0 开始,第一个元素索引为 0,第二个索引为 1,以此类推。

在这里插入图片描述

声明数组
Go 语言数组声明需要指定元素类型及元素个数,语法格式如下:

var variable_name [SIZE] variable_type

定义数组实例

package main

import "fmt"

func main() {
	var nums [10]int
	var sum int = 0
	for i := 0; i <= 9; i++ {
		nums[i] = i
	}
	for i := 1; i <= 9; i++ {
		sum += nums[i]
	}
	fmt.Println("数组的和为 = ", sum)
}

我们也可以通过字面量在声明数组的同时快速初始化数组:

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}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

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

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

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

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

数组程序实例

package main

import "fmt"

func main() {
	var i, j, k int
	// 声明数组的同时快速初始化数组
	balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

	/* 输出数组元素 */
	for i = 0; i < 5; i++ {
		fmt.Printf("balance[%d] = %f\n", i, balance[i])
	}

	balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
	/* 输出每个数组元素的值 */
	for j = 0; j < 5; j++ {
		fmt.Printf("balance2[%d] = %f\n", j, balance2[j])
	}

	//  将索引为 1 和 3 的元素初始化
	balance3 := [5]float32{1: 2.0, 3: 7.0}
	for k = 0; k < 5; k++ {
		fmt.Printf("balance3[%d] = %f\n", k, balance3[k])
	}
}

打印结果
在这里插入图片描述


语法篇一总结

从一些基础的语法上看,与C语言和Python语言会更接近一些,学习要保证持续性,加油!

在这里插入图片描述

看到这的童鞋给博主点个赞呗!👍👍😄


坚持分享,坚持原创,喜欢博主的靓仔靓女们可以看看博主的首页博客!
您的点赞与收藏是我分享博客的最大赞赏!
博主博客地址: https://blog.csdn.net/weixin_43967679

本文链接http://www.dzjqx.cn/news/show-617096.html