GO 语言基础（一）

最新推荐文章于 2024-08-23 13:40:49 发布
最新推荐文章于 2024-08-23 13:40:49 发布
阅读量269 收藏
点赞数
文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiuHuan303/article/details/123545677
版权

目录

Go语言基础语法

1，Go标记

2，行分割符

3，注释

4，标识符

5，字符串连接

6,关键字

7，GO语言的空格

8，格式化字符串

Go语言的数据类型

数字类型

浮点型

其他数字类型

GO语言变量

变量声明

多变量声明

Go语言基础语法

1，Go标记

Go程序可以由多个标记组成，可以是关键字,标识符,常量，字符串，符号。如以下GO语句由6个标记组成:

1. frat
3. Printin
4. (
5. "Hel1o, World!"
6. )

2，行分割符

在Go程序中，- 行代表-个语句结束。 每个语句不需要像C家族中的其它语言一样以分号;结尾，因为这些工作都将由Go编译器自动完成。 如果你打算将多个语句写在同一行,它们则必须使用;人为区分，但在实际开发中我们并不鼓励这种做法。 以下为两个语句:

fmt.Print1n("He11o, Wor1d! ")
fmt.Print1n("你好: nihao.com")
package main
​
import "fmt"
​
func main() {
    fmt.Println("hello")
    fmt.Println("world")//分行写后面不需要加分号
}
[Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go"
hello
world
package main
​
import "fmt"
​
func main() {
    fmt.Println("hello");fmt.Println("world")
//写在一行需要加分号 
}
[Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go"
hello
world
​
[Done] exited with code=0 in 0.431 seconds

3，注释

注释不会被编译，每一个包应该有相关注释。 单行注释是最常见的注释形式，你可以在任何地方使用以//开头的单行注释。多行注释也叫块注释,均已以/*开头，并以 */结尾。如: .

//单行注释
/*
行为艺术
多行注释
*/​

4，标识符

标识符用来命名变量、类型等程序实体。-个标识符实际上就是一个或是多 个字母(A-Z和a- z)数字(0-9)、下划线组成的序列，但是第一个字符必须是字母或下划线而不能是数字。 以下是有效的标识符:

mahesh   kumar   abc   move_name   a_123
mynames0   _temp   j    a23b9   retval

以下是无效的标识符:

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

例

 

 

5，字符串连接

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

package main
import "fmt" 
func main() {
fmt.Print1n("lilei " + " hanmeimei")
​
[Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go"
lilei  hanmeimei
​
[Done] exited with code=0 in 0.543 seconds

6,关键字

下面列举了Go代码中会使用到的25个关键字或保留字:

breakdefaultfuncinterfaceselect
casedefergomapstruct
chanelsegotopackageswitch
constfallthroughifrangetype
coontinueforimportreturnvar

除了以上介绍的这些关键字，Go语言还有36个预定义标识符:

appendboolbytecapclosecomplex
intuintfloat32iotanilcomplex64
int8uint8float64lenpaniccomplex128
int16uint16copymakerealprint
int32uint32falsenewrecoveprintln
int64uint64imagturestringuintptr

程序一般由关键字、常量、变量、运算符、类型和函数组成。 程序中可能会使用到这些分隔符:括号（）,中括号[]和大括号{}。 程序中可能会使用到这些标点符号:. , ; : 和... 。

例

package main
​
import "fmt"
​
const ( //定义常量
    a = iota //iota是从0开始每次递增  0
    b        //1
    c        //2
)
​
func main() {
    fmt.Println(a, b, c)
​
}
[Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go"
0 1 2
​
[Done] exited with code=0 in 0.655 seconds

7，GO语言的空格

Go语言中变量的声明必须使用空格隔开（当你没有使用空格时，当你保存crtl+s时会自动格式的统一化）,如:

var age int;

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

fruit=apples+oranges ;

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

fruit = apples + oranges;

8，格式化字符串

Go语言中使用fmt.Sprintf格式化字符串并赋值给新串:

package main
import (
"fmt"
I
)
func main() {
*// %d表示整型数字，%s表示字符串合
var stockcode=123
var enddate="2022-3-10"
var ur1="Code=%d&endDate=%s "
var target_ ur 1=fmt .Spr intf (ur1,stockcode , enddate)
fmt .Print1n(target. ur1)

输出结果为：

Code=12 3&endDate=2022-3-10

例：

package main
​
import "fmt"
​
var number int = 100
var enddate = "this is lili"
​
func main() {
    fmt.Printf("数字为%d,名字是%s", number, enddate)
}
输出
[Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go"
数字为100,名字是this is lili
[Done] exited with code=0 in 0.541 seconds

Go语言的数据类型

在Go编程语言中，数据类型用于声明函数和变量。 数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。

变量：随时变化的数据

go语言是一种强语言类型，类似java。需要声明数据类型

Go语言按类别有以下几种数据类型:

序号类型和描述
1布尔型 布尔型的值只可以是常量true或者false. -个简单的例子: var b bool = true.
2数字类型 整型int和浮点型float32、float64， Go语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
3字符串类型 :字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的
4派生类型:包括: (a) 指针类型(Pointer) (b) 数组类型(C)结构化类型(strucU(d) Channel类型(e)函数类型()切片类型(g)接口类型(interface) (h) Map类型。

例：bool变量声明

package main
​
import "fmt"
​
//布尔值类型变量，默认值是false
var letgo bool
​
func main() {
    fmt.Println("布尔值默认的是：", letgo)
}
输出：
[Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go"
布尔值默认的是： false
​
[Done] exited with code=0 in 0.531 seconds
package main
​
import "fmt"
​
//布尔值类型变量，默认的是false
var letgo bool = true    //赋值可以直接在类型后面
​
func main() {
    fmt.Println("布尔值默认的是：", letgo)
}
​
[Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go"
布尔值默认的是： true  //输出就是所赋的值
​
[Done] exited with code=0 in 0.548 seconds
package main
​
import "fmt"
​
//布尔值类型变量，默认的是false
var letgo bool = true    //全局变量
​
func main() {
    var letgo = false   //局部变量 在函数中赋值
    fmt.Println("布尔值默认的是：", letgo)
}
[Running] go run "f:\goProject\src\dev_code\day2\example3\main\main.go"
布尔值默认的是： false  //不会使用全局变量的赋值，而是使用函数中的赋值 
​
[Done] exited with code=0 in 0.54 seconds

PS：全局变量优先被加载，局部变量只有使用这个方法的时候才会被加载。同时都有时变量的使用时就近原则，哪个离得近就加载哪个。

例：变量声明方式

package main
​
import "fmt"
​
// = 和:= 的区别
var a int = 1 //第一种变量声明方式（完整书写）   int类型不赋值时默认值是0
var b = 2     //第二种变量声明方式（依赖赋值推断出数据类型）
​
func main() {
    //第三种变量声明方式(在函数中直接赋值，无需声明，即定义即赋值，不可在全局)
    c := 3
    fmt.Println(a, b, c)
}
输出：
[Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go"
1 2 3
​
[Done] exited with code=0 in 0.55 seconds

数字类型

Go也有基于架构的类型，例如: int. uint 和uintptr。

序号类型和描述
1uint8无符号8位整型(0到255)
2uint16无符号16位整型(0到65535)
3uint32无符号32位整型(0到4294967295)
4uint64无符号64位整型(0到18446744073709551615)
5int8有符号8位整型(-128到127)
6int16有符号16位整型(-32768到32767)
7int32有符号32位整型(-2147483648到2147483647)
8int64有符号64位整型(-9223372036854775808到9223372036854775807)

浮点型

序号类型和描述
1float32 IEEE-754 32位浮点型数
2float64 IEEE-754 64位浮点型数
3complex64 32位实数和虚数
4complex128 64位实数和虚数

其他数字类型

以下列出了其他更多的数字类型:

序号类型和描述
1byte 类似 uint8
2rune 类似 int32
3uint 32或 64位
4int 与 uint一样大小
5uintptr 无符号整型，用于一个指针

GO语言变量

变量来源于数学,是计算机语言中能储存计算结果或能表示值抽象概念。 变量可以通过变量名访问。 Go语言变量名由字母、数字、下划线组成。其中首个字符不能为数字。 声明变量的一般形式是使用var关键字:

var identifier type
声明  变量名    变量类型  

可以一次声明多个变量:

var identifier1, identifier2 type
声明   变量名1,变量名2        变量类型      

###

package main
import "fmt"
func main() {
var a string = "lilei"
fmt. Print1n(a)
var b,c int =10,20
fmt.print1n(b，c)
}

输出的结果是

lilei
10 20

例

package main
​
import "fmt"
​
var a, b int  //未赋值输出默认值0
​
//变量集体声明
func main() {
    fmt.Println("a=", a, "b=", b)
}
输出
[Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go"
a= 0 b= 0
​
[Done] exited with code=0 in 0.575 seconds
​
赋值定义
package main
​
import "fmt"
​
var a, b int = 10, 20
​
//变量集体声明
func main() {
    fmt.Println("a=", a, "b=", b)
}
输出
[Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go"
a= 10 b= 20
​
[Done] exited with code=0 in 0.559 seconds

变量声明

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

var v_name v_type
v_name = value

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

###

package main
import "fmt"
func main() {
//声明一个变量并初始化*
var a = "lilei"
fmt.Println(a)
//没有初始化就为零值*
var b int
fmt.Println(b)
// bool零值为falser
var c bool
fmt.Println(c)
}
​

以上实例执行结果为：

lilei
0
false

●数值类型(包括complex64/128)为0 ●布尔类型为false ●字符串为”" (空字符串)

●以下几种类型为nil:

例：

package main
​
import "fmt"
​
var name string   //空字符串类型
​
func main() {
    fmt.Println("name=", name)
}
输出
[Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go"
name= 
​
[Done] exited with code=0 in 0.569 seconds

●以下几种类型为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是接口!

###

package main
import "fmt"
func main( {
var i int
var f f1oat64
var b bool
var s string
fmt .Printf("%v %v %v %q\n", i, f, b, s)
}

输出的结果是：

0 0 false ""

第二种：根据值自行判断变量的类型

var v_name = value

###

package main
import "fmt"
func main() {
var d = true
fmt.Println(d)
}

输出的结果为：

true

第三种，如果变量已经使用var声明过了，再使用:=声明变量，就产生编译错误，格式:

v_name := value

例如：

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

例：

 直接使用下面的语句即可：

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

ingVal:=1相等于:

var intva1 int
intva1 =1

可以将var name string = "lilei"简写为name := "lilei":

package main
​
import "fmt"
​
func main() {
    name := "lilei" //var name string = "lilei"
    fmt.Println(name)
}
​
[Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go"
lilei
​
[Done] exited with code=0 in 0.566 seconds

多变量声明

//类型相同多个变量，非全局变量
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
​
import "fmt"
​
func main() {
    //多变量声明
    var a, b, c = 10, 20, 30
    fmt.Println(a, b, c)
}
[Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go"
10 20 30
​
[Done] exited with code=0 in 0.553 seconds

因式分解例：

package main
​
import "fmt"
​
//因式分解声明变量
var (
    a int
    b string
    c float32
)
​
func main() {
    a = 10
    b = "lilei"
    c = 20.00
    fmt.Println(a, b, c)
}
输出：
[Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go"
10 lilei 20
​
[Done] exited with code=0 in 0.552 seconds

####

package main
var x,y int
var ( //这种因式分解关键字的写法一-般用于声明全局变量
a int
b bool
)
var c,d int=1，2
var e,f = 123，"he11o"
//这种不带声明格式的只能在函数体中出现
//g,h := 123，"he11o"
func main(){
g,h := 123,"hel1o"
print1n(x，y，a, b，C，d, e，f, g，h)
}
​

以上实例执行的结果为：

0 0 0 false 1 2 123 he11o 123 he11o
实例：：：
package main
​
import "fmt"
​
var x, y int
var (
    a int
    b bool
)
var c, d int = 1, 2
var e, f = 123, "nihao"
​
func main() {
    g, h := 123, "wohenhao"
    fmt.Println(x, y, a, b, c, d, e, f, g, h)
}
输出：
[Running] go run "f:\goProject\src\dev_code\day2\example4\main\main.go"
0 0 0 false 1 2 123 nihao 123 wohenhao
​
[Done] exited with code=0 in 0.545 seconds
LiuHuan303
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go语言基础（一）
311宿舍
08-18 287
环境搭建 下载去官方下最新稳定版本就好https://golang.google.cn/ windows直接下一步就好，linux下载压缩包，官方建议下到/usr/local/下面然后解压。 linux把环境变量添加到/etc/profile里面，然后source一下就能即刻生效 环境变量解释 GOROOT 是go语言安装的位置 GOPATH 是go语言写的源码文件夹，也既是我们平时说的工程项...
go语言基础（一）
diaolove的博客
11-29 184
前言：在写这篇文章之前，我哥哥跟我讲目前Go语言也挺流行，叫我多接触接触，也凭借着对Go语言的好奇，我来分享一下我的笔记！ 一、了解Go语言 Go 是 2009 年才创建的，它的语法简洁、快速、安全，并行、有趣、开源内存管理、数组安全、编译迅速。Go 不像很多词汇表臃肿的编程语言，小巧便捷。就算减少在线和参考书中搜索答案和语法的时间。仅仅通过阅读来学习 Go 也是可能的，因为它的语法非常清晰，即使是不熟悉它的人，甚至是不懂编程的人，也能阅读代码，并理解它所发生的一切。（见此更是激起我学习的...
go语言语法特色
weixin_47906106的博客
01-04 581
Go语⾔的变量定义 Go语⾔中，变量的声明⽅式如下： var identifier type 也可以选择在声明的时候，直接赋值 var identifier [type] = value 在类型定义的时候，可以省略type，Go语⾔可以⾃动推到数据类型。我们也可以同时定义多个变量，在 赋值的时候，需要注意，等号左右的数量、类型要⼀致。⽐如： var x, y = 123, "hello" var的定义变量⽅法没有区域限制，相⽐⽽⾔，Go开发者更喜欢另外⼀种定义变量且赋值的⽅式，那就 是⽤“:=“，
Go语言基础语法入门
qq_41854911的博客
11-09 2422
一、下载及安装 推荐看一下这个博客：Goland激活码/注册码_Goland下载和安装 二、入门教程 Go 语言结构 在我们开始学习 Go 编程语言的基础构建模块前，让我们先来了解 Go 语言最简单程序的结构。 Go Hello World 实例 Go 语言的基础组成有以下几个部分： 包声明 引入包 函数 变量 语句 & 表达式 注释 接下来让我们来看下简单的代码，该代码输出了"Hello World!": 实例 package main import "fmt" func main()
这段js代码运行不出来，出来的是不对的结果，[Done] exited with code=0 in 0.061 seconds，怎么回事，为什么呢，怎么办呢
weixin_40945354的博客
02-13 8825
let a = 0.1 let b = 0.2 if (a + b == 0.3) { console.log("You got 0.3.") } [Running] node "/Users/ivyone/hami55/ruguo.js" [Done] exited with code=0 in 0.061 seconds
golang type和var区别
嘿嘿
07-16 4721
有一个类type MyPoint struct { X, Y float64 }以下2种声明方式：var Path []MyPoint //定义变量 type Path2 []MyPoint //定义别名
go语言基础.pptx
07-13
Go语言，又称Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的编程语言。它的设计灵感来源于C语言，同时融合了多种现代编程思想，如面向对象、函数式编程和并发处理。Go语言以其简洁、高效...
go语言基础
01-17
**Go语言**(又称**Golang**)是由**Google**开发的一种**静态强类型、编译型、并发型**，且具备**垃圾回收**功能的编程语言。它最初由三位业界知名的大师级人物共同设计和实现：**肯·汤姆逊(Ken Thompson)**、**罗布...
go语言基础语法示例
09-21
Go语言，也称为Golang，是由Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程语言。它的设计目标是提高程序的简洁性、可读性和可维护性，同时也注重性能和效率。Go语言的基础语法简洁而强大，...
GO语言（golang）基础知识
01-21
今天说一些golang的基础知识，还有你们学习会遇到的问题，先讲解hello word 代码如下: package main import “fmt” func main() {  fmt.Println(“你好，软件开发网”); } package name 包机制，每一个独立的go...
Go语言基础教程
04-26
Go语言，也被称作golang，是一种由Google研发的静态强类型、编译型、并发型的编程语言，并且具备垃圾回收机制。作为开源语言，Go使得编写简单、可靠且高效的软件成为可能。Go语言的开发始于2007年末，由Robert ...
Go学习（一、从介绍到运算符，重点变量）
m0_49936845的博客
05-08 401
为什么突然想学习go，因为我一直学的比较杂，想选一个应聘的方向学习，看到了腾讯的一个方向，支持java ，c/c++，go；但是由于java太卷了，最近裁员也多，于是我决定学习go，毕竟go被一些人称做为未来编程 目录Go 语言结构Go 语言基础语法Go 语言数据类型Go 语言变量Go 语言常量Go 语言运算符 学习基础语法，先不配置编译器，采用菜鸟在线编译器 Go 语言结构 Go 语言的基础组成有以下几个部分： 包声明 引入包 函数 变量 语句 & 表达式 注释 package main i
色色找magento bug: $identifierType 不管用 的
过客阵营 -- 简单的就要最简单
10-18 130
创建/更新 ... 删除产品时,api接口文档中 提供了 $identifierType 用于指定是使用 产品id或者sku进行 过滤:   可选值:  "id"  "sku"     但是具体测试中不管咋样都没用,看了下代码 app/code/core/Mage/Catalog/Model/Product/Api.php 中调用 getProduct() 位于 a...
Go语言变量的声明（使用var关键字）
科比不来it
06-29 2910
Go语言是静态类型语言，因此变量（variable）是有明确类型的。编译器会检查函数调用中，变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。 声明变量的一般形式是使用 var 关键字： var identifier type 。 需要注意的是，Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。这...
一文掌握 Go 内存对齐
最新发布
newbietao的博客
08-23 761
例如，对于一个 32 位的整数，如果存储在非 4 字节对齐的地址上，可能需要两次内存读取操作才能获取完整的数据，而在对齐的地址上，一次读取操作即可。内存对齐是一种将数据在内存中进行排列的方式，目的是提高内存访问的效率和保证数据的完整性。数据的内存排列方式最直观的体现就是数据的内存地址，说白了就是数据的内存地址要符合一定规则，以便于CPU读取，这个规则就是下面要讲的内存对齐规则。上面的输出和我们的结论是契合的，内存地址都是对齐值的倍数，另外还有一点，为了减少内存开销，编译器还会优化内存布局，减少内存碎片。
Golang | Leetcode Golang题解之第354题俄罗斯套娃信封问题
weixin_66442839的博客
08-21 405
Golang | Leetcode Golang题解之第354题俄罗斯套娃信封问题
Golang | Leetcode Golang题解之第357题统计各位数字都不同的数字个数
weixin_66442839的博客
08-22 276
Golang | Leetcode Golang题解之第357题统计各位数字都不同的数字个数
【国密SM2、SM3】Go、Java和 IavaScript 签名三端兼容
qiqi123j的博客
08-21 1350
ASN.1 – Abstract Syntax Notation dot one，抽象记法1。所有X.509都是DER编码，DER是指ASN.1的编码规则。2010年12月17日，国家密码管理局关于发布。椭圆曲线方程：y2 = x3 + ax + b。2010年12月17日，国家密码管理局关于发布。推荐使用素数域256位椭圆曲线。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值