Go语言入门（一）
Go语言简介
官方介绍
Google推出的一门编程语言
开源编程语言，结构简单，可靠，高效
Go语言的主要开发者
2007年有Robert Griesemer，Rob Pikle，Ken Thompson主持开发
2009年11月开源
Go语言的特点
简洁，快速，安全
并发，开源
内存管理，数据安全，编译迅速
跨平台
Go语言环境安装
安装步骤如下
下载地址： https://studygolang.com/dl
根据平台安装不同的安装包
安装路径不要出现中文
开发环境
Goland： 破解方法参考（https://www.cnblogs.com/zhangguosheng1121/p/11448194.html）
Vscode
第一个Go语言程序
helloworld
package main

// package 表示该文件所属的包

// 导入包
import “fmt”

//行注释，可以注释单行
/*
块注释
可以注释多行
*/

// func 函数
//main 主函数名，主函数名有且只有一个，作为程序的主入口
// () 函数参数列表
// {} 函数体
// fmt.Println 打印
// hello world
func main01() {
//Println：打印并换行
fmt.Println(“Hello World!”)
fmt.Println(“哈哈哈哈”)
}
编译过程
go run hello.go #运行程序
go fmt hello.go # 格式化代码
go build -o hello hello.go #编译成本平台使用的hello程序
跨平台编译:
mac下编译Linux和Windows64位可执行程序
GOOS=linux GOARCH=adm64 go build -o hello hello.go
GOOS=windows GOARCH=adm64 go build -o hello hello.go

• Linux下编译windows和mac可执行程序
  GOOS=darwin GOARCH=adm64 go build -o hello hello.go
  GOOS=windows GOARCH=adm64 go build -o hello hello.go
• Windows下编译Linux和mac可执行程序
  GOOS=darwin GOARCH=adm64 go build -o hello hello.go
  GOOS=linux GOARCH=adm64 go build -o hello hello.go
  变量和常量
  变量
  概念： 程序运行过程中其值可以发生改变的量称之为变量
  定义：
  声明式变量： var 变量名 数理类型
  变量赋值： var 变量名 = 值
  自动推导类型： 变量名 := 值
  多重赋值： 变量1，变量2，变量3 := 值1，值2，值3
  package main

import “fmt”

var (
h1 = 122
h2 = 144
)

var (
a,b,c = 1,2,“abc”
d = 999
)

func Variables() {
//变量定义的格式
// var 变量名 数据类型
var h1 int = 186
var h2 int= 163
h3 := 144
fmt.Println(h3)
fmt.Println(h1 - h2)
var main int = 1
fmt.Println(main)
}

func calCycleSqure() {
// 计算圆的面积和周长
/*
面积=PIrr
周长=2PIr
%T是一个占位符，表示输出一个变量对应的数据类型
*/
PI := 3.14
r := 2
fmt.Printf("%T\n",PI)
fmt.Printf("%T\n",r)
// 圆的面积
s := PI * float64® * float64®
// 圆的周长
l := 2 * PI * float64®
fmt.Println(“面积”,s)
fmt.Println(“周长”,l)
fmt.Printf(“面积：%.2f\n” ,s)
fmt.Printf(“周长： %.2f\n”,l)
println(“aaaa”)
}

func mutiValue() {
// 多重赋值
/*
多重赋值可以是不同类型的变量，但是值的个数必须要和变量的个数保持一致
*/
var a,b,_ int = 3,4,5
c,d := 123,“sss”
fmt.Println(a,b)
fmt.Println(c,d)
}

func exchangeValue() {
a := 10
b := 20

// 使用临时变量交换
//tmp := a
//a = b
//b = tmp
//fmt.Println(a,b)// 使用运算符交换两个变量的值
//a = a + b
//b = a - b
//a = a - b
//fmt.Println(a,b)// 异或操作
//a = a ^ b
//b = a ^ b
//a = a ^ b
//fmt.Println(a,b)//多重赋值交换
a,b = b,a
fmt.Println(a,b)

}

func constDefine() {
// 常量的定义格式，常量值不能用于计算，
/*
const 常量名 数据类型 = 值
*/
const A int = 100
const B = “aaa”
fmt.Println(B)
a:=100
// & 是取内存地址运算符，获取变量的内存地址 内存地址是一个无符号十六进制整型数据格式
// & 不允许获取常量的内存地址
println(&a)
fmt.Println(A)
}

func main() {
Variables()
//calCycleSqure()
//mutiValue()
//exchangeValue()
}
常量
概念： 字啊程序运行过程中其值不可以发生改变的量
用途： 存储一些一直不发生变化的数据，例如：π，证件号码等
定义： const 常量名 数据类型 = 值
注意： 自动推导类型的常量不使用:,常量不能用于计算;常量不能获取其内存地址（&(const a int = 10)）
func constDefine() {
// 常量的定义格式，常量值不能用于计算，
/*
const 常量名 数据类型 = 值
*/
const A int = 100
const B = “aaa”
fmt.Println(B)
a:=100
// & 是取内存地址运算符，获取变量的内存地址 内存地址是一个无符号十六进制整型数据格式
// & 不允许获取常量的内存地址
println(&a)
fmt.Println(A)
}
常量集与iota枚举
常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化常量，但是不用每行都写一遍初始化表达式
注意：
在一个const声明语句中，在第一个常量所在的行，iota都会置0，以后再每一个有常量声明的行加一
func constSet() {
const(
a = iota
b
c
d
e = “hello”
f
)
const(
a1 = “word”
b1 = iota
c1,d1 = iota,iota
)
fmt.Println(a,b,c,d,e,f,a1,b1,c1,d1)
}
Go语言命名规则
允许使用字母下划线作为开头，但不能使用Go语言关键字
区分大小写
命名采用驼峰命名
小驼峰
大驼峰
标准输入与输出
标准输入
Scan：扫描，必须所有参数被填充之后换行才结束扫描
Scanf：格式化扫描
Scanln：遇到换行就结束扫描
标准输出
Print
Println
Printf
func inputOutput() {
x,y := 0,0
fmt.Scan(&x,&y)
fmt.Print(x,y)
name,score := “”,0
fmt.Scanf(“请输入你的姓名%s\n”,&name)
fmt.Scanf(“请输入你的成绩%d\n”,&score)
fmt.Printf(“姓名%s,成绩%d\n”,name,score)
job := “”
fmt.Scanln(&job)
fmt.Println(name,score,job)
}