一、Go 语言基础语法：Hello World 实例（涉及定义变量；常量；fmt 包、Print、Println、Printf(1)

web展示

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, World!")
    })
    fmt.Println("Please Visit -  http://localhost:8899/")
    http.ListenAndServe(":8899", nil)
}

• Golang 中常见的变量定义方法如下：

1**、**var 定义变量

var
变量名 类型

表达式（类型可以不需要添加，自带类型推导）

package main
import "fmt"
func main(){
        //1.变量的声明
        var age int
        //2.变量的赋值
        age = 18
        //3.变量的使用
        fmt.Println("age = ",age);
        //声明和赋值可以合成一句：
        var age2 int = 19
        fmt.Println("age2 = ",age2);
        // var age int = 20;
        // fmt.Println("age = ",age);

}

2**、类型推导方式定义变量**

a
在函数内部，可以使用更简略的
:=
方式声明并初始化变量。

注意：
短变量只能用于声明局部变量，不能用于全局变量的声明，var可以实现

变量名
:=
表达式（注意：冒号和=要挨着 冒号前和等于号后空格 美观）

错误展示：

package main

import "fmt"

func getuser() (string, int) {
	return "远坂凛",10
}
func main(){

	// var username = "卫宫士郎"
	// fmt.Println(username)
	// var (
	// 	username string = "卫宫士郎"
	// 	age int = 20
	// 	sex string = "男"

	// )
	// fmt.Println(username,age,sex)
	// 变量命名法
	// 变量不能重复命名，但是可以重复赋值
	var username,age = getuser()
	fmt.Println(username,age)
	// 短变量命名法
	a,b,c := 19,20,"archer"
	fmt.Printf("%v.%v,%v",a,b,c)
}

支持一次性声明多个变量（多变量声明）

package main
import "fmt"
//全局变量：定义在函数外的变量
var boyname = "卫宫士郎"
var boyage = 19
//全局变量一次性声明：
var (
        girlage = 20
        girlname = "远坂樱"
)
func main(){
        //定义在{}中的变量叫：局部变量
        //第一种：变量的使用方式：指定变量的类型，并且赋值，
        var num int = 22
        fmt.Println(num)
        //第二种：指定变量的类型，但是不赋值，使用默认值 
        var num2 int
        fmt.Println(num2)
        //第三种：如果没有写变量的类型，那么根据=后面的值进行判定变量的类型 （自动类型推断）
        var num3 = "Archer"
        fmt.Println(num3)
        //第四种：省略var，注意 := 不能写为 =   
        sex := "男"
        fmt.Println(sex)
        fmt.Println("------------------------------------------------------------------")
        //声明多个变量：
        var a,b,c int
        fmt.Println(a)
        fmt.Println(b)
        fmt.Println(c)
        var d,name,e = 10,"sabar",169
        fmt.Println(d)
        fmt.Println(name)
        fmt.Println(e)
        garde,height := 6.9,100.6
        fmt.Println(garde)
        fmt.Println(height)
        fmt.Println(boyname)
        fmt.Println(boyage)
        fmt.Println(girlage)
        fmt.Println(girlname)
}

匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用
匿名变量
（anonymous variable）。 匿

名变量用一个下划线
_
表示，例如：

package main

import "fmt"
func varinfo()(string,int){
	return "远坂凛",21
}
func main() {
	name,age := varinfo()
	fmt.Printf("MY name is %v,age is %v",name,age)

}

package main

import "fmt"
func varinfo()(string,int){
	return "远坂凛",21
}
func main() {
	_,age := varinfo()
	fmt.Printf("age is %v",age)

}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

注意事项：

1
、函数外的每个语句都必须以关键字开始（var、
const
、
func
等）

2
、
:=不能使用在函数外。

3
、
_
多用于占位，表示忽略值。

• fmt 包、Print、Println、Printf

Go
中要打印一个值需要引入
fmt
包

import “fmt”

fmt
包里面给我们提供了一些常见的打印数据的方法，比如：
Print
、
Println
、
Printf
，
在我

们实际开发中
Println
、
Printf
用的非常多。

1、Print 和 Println 区别：

一次输入多个值的时候 Println 中间有空格 Print 没有

Println 会自动换行，Print 不会

2**、**Println 和 Printf 区别：

Printf
是格式化输出，在很多场景下比
Println
更方便，举个例子：

package main

import "fmt"
func main() {
	var(
	name = "卫宫士郎"
	age = 19
	servant = "sabar"
	)
	fmt.Println("我的名字是:" ,name,"年龄:",age,"servant为:",servant)
	fmt.Printf("我的名字是%v,年龄为%v,servant为%v",name,age,servant)
}

Printf
中的占位符与后面的数字变量一一对应。

例如：
%d
是占位符，表示数字的十进制表示。

• Go 语言中的注释

行注释 //     VSCode快捷键：ctrl+/  再按一次取消注释
块注释（多行注释） /**/        VSCode快捷键：shift+alt+a 再按一次取消注释
注意：块注释中不可以嵌套块注释

• Go 语言中的常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把var换成了**const**，常量在定义的时候必须赋值。

代码如下：细分

//整体代码
package main

import "fmt"

func main() {
	const (
		name    = "卫宫士郎"
		serVant = "SABAR"
		age
		number
	)

	const(
		a = iota
		_
		b
		c = 100
		d = iota
		e
		

	)
	fmt.Println(name, serVant,age,number,a,b,c,d,e)

}

声明了上面第一个const中的name和servant这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。（多常量声明法）

单常量声明如下：

const name = "奥特曼"
const age = 123124

注意：const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。

iota

iota是go语言的常量计数器，只能在常量的表达式中使用。

iota在const关键字出现时将被重置为0。

const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

使用iota能简化定义，在定义枚举时很有用。

1**、**iota 只能在常量的表达式中使用。

fmt.Println(iota) //编译错误： undefined: iota

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新！！

wq5e-1715673426704)]

[外链图片转存中…(img-m6MaS87r-1715673426705)]

[外链图片转存中…(img-xcs2X6gn-1715673426707)]

[外链图片转存中…(img-g0x3325P-1715673426707)]

[外链图片转存中…(img-IgTzrwFH-1715673426708)]

[外链图片转存中…(img-CuUQUXdz-1715673426709)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新！！