Golang基础(1) - Golang教程网

GO语言基础

<center>**GO语言基础**
- **前言**
- Go语言的起源
- **Go语言项目**
- 第一章、入门
- - **1.1. Hello World**
  - 1.2.命令行参数
  - 1.3查找重复行
  - 1.4 GIF动画
- **第二章、编程语言**
- - 编程语言介绍
  - 2.1、什么是编程语言
  - 2.2、编译型语言与解释性语言
- 第三章、Go安装
- - 3.1、GO编译器下载
  - 3.2 MAC系统
  - - mac下安装SDK
  - 3.3 WIndows系统
  - - 3.3.1 Windows下安装SDK
    - 3.3.2、Windows下配置环境
  - 3.4、IDE的安装与使用
  - - 安装IDEA
  - 3.5、idea快捷键
- 第四章、基础语法
- - 4.1、注释
  - 4.2 变量
  - - 4.2.1、GO声明变量
    - 4.2.2 变量赋值
    - 4.2.3 匿名变量
    - 4.2.4变量名命名的规则
  - 4.3基本数据类型
  - - 4.3.1整型
    - 4.3.2浮点型
    - 4.3.3布尔类型
    - 4.3.4字符串类型
    - - 4.3.4.1 字符串常用方法
    - 4.3.5转义符
    - 4.3.6 进制转换
    - 4.3.7 数据类型转换
    - 4.3.8 运算符
    - 4.3.9 输入输出函数
    - - 4.3.9.1 输出函数
        4.3.9.2 输入函数
      - 4.3.10 常量与iota
      - 4.3.10.1 iota计数器

前言

“Go是一个开源的编程语言，它很容易用于构建简单、可靠和高效的软件。”（摘自Go语言官
方网站：http://golang ）

“前言、起源，均摘录于GO语言圣经”

Google公司Robert GriesemerRob Pike和Ken Thompson

Go语言有着和C语言类似的语法外表，和C语言一样是专业程序员的必备工具，可以用最小的
代价获得最大的战果。但是它不仅仅是一个更新的C语言。它还从其他语言借鉴了很多好的
想法，同时避免引入过度的复杂性。 Go语言中和并发编程相关的特性是全新的也是有效的，
同时对数据抽象和面向对象编程的支持也很灵活。 Go语言同时还集成了自动垃圾收集技术用
于更好地管理内存。

Go语言尤其适合编写网络服务相关基础设施，同时也适合开发一些工具软件和系统软件。但
是Go语言确实是一个通用的编程语言，它也可以用在图形图像驱动编程、移动应用程序开发
和机器学习等诸多领域。目前Go语言已经成为受欢迎的作为无类型的脚本语言的替代者：因
为Go编写的程序通常比脚本语言运行的更快也更安全，而且很少会发生意外的类型错误。

LinuxFreeBSDOpenBSDMac OSXPlan9系统Microsoft Windows

Go语言的起源

编程语言的演化跟生物物种的演化类似，一个成功的编程语言的后代一般都会继承它们祖先
的优点；当然有时多种语言杂合也可能会产生令人惊讶的特性；还有一些激进的新特性可能
并没有先例。通过观察这些影响，我们可以学到为什么一门语言是这样子的，它已经适应了
怎样的环境。

下图展示了有哪些早期的编程语言对Go语言的设计产生了重要影响

Go语言有“C类似语言”“21世纪的C语言”

Niklaus WirthPascalModula-2语言Oberon语言

Tony HoareTony HoareCSP

Rob PikeSqueak（老鼠间交流的语言）Newsqueak语言NewsqueakNewsqueak语言

Newsqueak

Go语言的iota语法APL语言Scheme语言defer

Go语言项目

所有的编程语言都反映了语言设计者对编程哲学的反思，通常包括之前的语言所暴露的一些
不足地方的改进。Go项目是在Google公司维护超级复杂的几个软件系统遇到的一些问题的反
思（但是这类问题绝不是Google公司所特有的）。

Rob Pike

Fred Brooks

Go项目Go语言自动 垃圾回收一个包系统函数作为一等公民词法作用域系统调用接口只读的UTF8字符串

但是Go语言本身只有很少的特性，也不太可能添加太多的特性。例如，它没有隐式的
数值转换，没有构造函数和析构函数，没有运算符重载，没有默认参数，也没有继承，没有
泛型，没有异常，没有宏，没有函数修饰，更没有线程局部存储。但是，语言本身是成熟和
稳定的，而且承诺保证向后兼容：用之前的Go语言编写程序可以用新版本的Go语言编译器和
标准库直接构建而不需要修改代码。

Go语言C++HaskellGo语言

Go语言鼓励当代计算机系统设计的原则，特别是局部的重要性。它的内置数据类型和大多数
的准库数据结构都经过精心设计而避免显式的初始化或隐式的构造函数，因为很少的内存分
配和内存初始化代码被隐藏在库代码中了。

结构体数组goroutinegoroutinegoroutine

清晰的构建模块和公共接口包含 I/O操作文本处理图像密码学网络分布式应用程序

第一章、入门

本章介绍Go语言的基础组件。本章提供了足够的信息和示例程序，希望可以帮你尽快入门, 写
出有用的程序。本章和之后章节的示例程序都针对你可能遇到的现实案例。先了解几个Go程
序，涉及的主题从简单的文件处理、图像处理到互联网客户端和服务端并发。当然，第一章
不会解释细枝末节，但用这些程序来学习一门新语言还是很有效的。

学习一门新语言时，会有一种自然的倾向, 按照自己熟悉的语言的套路写新语言程序。学习Go
语言的过程中，请警惕这种想法，尽量别这么做。我们会演示怎么写好Go语言程序，所以，
请使用本书的代码作为你自己写程序时的指南。

1.1. Hello World

hello world

gopl.io/ch1/helloworld

package main

import "fmt"

func main() {
	fmt.Println("Hello, 世界")
}

run

$ go run helloworld.go

毫无意外，这个命令会输出：

Hello, 世界

Unicode

如果不只是一次性实验，你肯定希望能够编译这个程序，保存编译结果以备将来之用。可以
用

build

子命令：

$ go build helloworld.go

helloworldhelloworld.exehelloworld.exe

$ ./helloworld

Hello, 世界

fmtPrintln

mainmainmainfmt.Println

hello world

packagefuncvarconsttypepackageimportmain

breakcontinuefallthroughreturn++- -)]}）funcx + y+ ++

gofmtfmtgofmtgofmt

gofmt goimportsimport

$ go get golang.org/x/tools/cmd/goimports

Goland

1.2.命令行参数

大多数的程序都是处理输入，产生输出；这也正是“计算”的定义。但是, 程序如何获取要处理
的输入数据呢？一些程序生成自己的数据，但通常情况下，输入来自于程序外部：文件、网
络连接、其它程序的输出、敲键盘的用户、命令行参数或其它类似输入源。下面几个例子会
讨论其中几个输入源，首先是命令行参数。

ososos.Args

os.Argsstringsliceslices[i]s[m:n]

a = [1, 2, 3, 4, 5]a[0:3] = [1, 2, 3]s[m:n]0 ≤ m ≤ n ≤ len(s)n-m

os.Argsos.Args[0]s[m:n]os.Args[1:len(os.Args)]len(s)os.Args[1:]

Unixechoimportgofmt

gopl.io/ch1/echo1


package main

import (
	"fmt"
	"os"
)

func main() {
	var s, sep string
	for i := 1; i < len(os.Args); i++ {
		s += sep + os.Args[i]
		sep = " "
	}
	fmt.Println(s)
}

////main package

varstringssepzero value""ssep

string

sep + os.Args[i]

sepos.Args

s += sep + os.Args[i]

ssepos.Args[i]s

s = s + sep + os.Args[i]

+=+*

" "echo

ifor:=

i++ii += 1i = i + 1i--ij = i++++----i

forfor

for initialization; condition; post {
    // zero or more statements
}

forpostinitializationinitalizationconditiontruecondition conditionfalse

forinitializationpost

// a traditional "while" loop
for condition {
    // ...
}

condition

// a traditional infinite loop
for {
    // ...
}

breakreturn

forrangeecho

gopl.io/ch1/echo2

package main

import (
	"fmt"
	"os"
)

func main() {
	s, sep := "", ""
	for _, arg := range os.Args[1:] {
		s += sep + arg
		sep = " "
	}
	fmt.Println(s)
}

rangerangetemp

range_echoos.Args

echosseps

s := ""
var s string
var s = ""
var s string = ""

""

+= ss

stringsJoin

gopl.io/ch1/echo3

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	fmt.Println(strings.Join(os.Args[1:], " "))
}

Println

fmt.Println(os.Args[1:])

strings.Join

1.3查找重复行

dupuniq

dupifmapbufio

gopl.io/ch1/dup1

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	counts := make(map[string]int)
	input := bufio.NewScanner(os.Stdin)
	for input.Scan() {
		counts[input.Text()]++
	}

	for line, n := range counts {
		if n > 1 {
			fmt.Printf("%d\t%s\n", n, line)
		}
	}
}

forifelsefalse==makemapmapmapHashMapdicttablehash

dupmapcounts[input.Text()]++

line := input.Text()
counts[line] = counts[line] + 1

mapcounts[line]int

rangecountsmapmapmap

bufioScannerbufio.Scannerinput

input := bufio.NewScanner(os.Stdin)

input.Scan()input.Text()Scantruefalse

printffmt.Printf%d%s

Printf

符号	详细
%d	十进制整数
%x, %o, %b	十六进制，八进制，二进制整数。
%f, %g, %e	浮点数： 3.141593 3.141592653589793 3.141593e+00
%t	布尔：true或false
%c	字符（rune） (Unicode码点)
%s	字符串
%q	带双引号的字符串"abc"或带单引号的字符’c’
%v	变量的自然形式（natural format）
%T	变量的类型
%%	字面上的百分号标志（无操作数）

dup1\t\nPrintflog.Printffmt.ErrorfPrintln%vfomartline

os.Open

gopl.io/ch1/dup2

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	counts := make(map[string]int)
	files := os.Args[1:]
	if len(files) == 0 {
		countLines(os.Stdin, counts)
	} else {
		for _, arg := range files {
			f, err := os.Open(arg)
			if err != nil {
				fmt.Fprintf(os.Stderr, "dup2: %v\n", err)
				continue
			}
			countLines(f, counts)
			f.Close()
		}
	}
	for line, n := range counts {
		if n > 1 {
			fmt.Printf("%d\t%s\n", n, line)
		}
	}
}
func countLines(f *os.File, counts map[string]int) {
	input := bufio.NewScanner(f)
	for input.Scan() {
		counts[input.Text()]++
	}
}

os.Open*os.FileScanner

os.Open errorerrnilNULLCloseerrnilFprintf%vdupcontinuefor

os.Openinput.Scan

countLines

mapmake mapcopymapcountLinescountsmainC++

dupdup3ReadFileio/ioutil

dup3ReadFilemain

gopl.io/ch1/dup3

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"strings"
)

func main() {
	counts := make(map[string]int)
	for _, filename := range os.Args[1:] {
		data, err := ioutil.ReadFile(filename)
		if err != nil {
			fmt.Fprintf(os.Stderr, "dup3: %v\n", err)
			continue
		}
		for _, line := range strings.Split(string(data), "\n") {
			counts[line]++
		}
	}
	for line, n := range counts {
		if n > 1 {
			fmt.Printf("%d\t%s\n", n, line)
		}
	}
}

ReadFilebyte``````slicestrings.Split

bufio.Scannerioutil.ReadFileioutil.WriteFile*os.FileReadWritelower-levelhigher-levelbufioio/ioutil

1.4 GIF动画

imagepackage

译注：要看这个程序的结果，需要将标准输出重定向到一个GIF图像文件（使用 ./lissajous
> output.gif 命令）。下面是GIF图像动画效果：

conststruct

gopl.io/ch1/lissajous

package main

import (
	"image"
	"image/color"
	"image/gif"
	"io"
	"math"
	"math/rand"
	"os"
	"time"
)

var palette = []color.Color{color.White, color.Black}

const (
	whiteIndex = 0 // first color in palette
	blackIndex = 1 // next color in palette
)

func main() {
	// The sequence of images is deterministic unless we seed
	// the pseudo-random number generator using the current time.
	// Thanks to Randall McPherson for pointing out the omission.
	rand.Seed(time.Now().UTC().UnixNano())
	lissajous(os.Stdout)
}
func lissajous(out io.Writer) {
	const (
		cycles  = 5     // number of complete x oscillator revolutions
		res     = 0.001 // angular resolution
		size    = 100   // image canvas covers [-size..+size]
		nframes = 64    // number of animation frames
		delay   = 8     // delay between frames in 10ms units
	)
	freq := rand.Float64() * 3.0 // relative frequency of y oscillator
	anim := gif.GIF{LoopCount: nframes}
	phase := 0.0 // phase difference
	for i := 0; i < nframes; i++ {
		rect := image.Rect(0, 0, 2*size+1, 2*size+1)
		img := image.NewPaletted(rect, palette)
		for t := 0.0; t < cycles*2*math.Pi; t += res {
			x := math.Sin(t)
			y := math.Sin(t*freq + phase)
			img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
				blackIndex)
		}
		phase += 0.1
		anim.Delay = append(anim.Delay, delay)
		anim.Image = append(anim.Image, img)
	}
	gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}

importpackageimage/colorcolor.Whiteimage/colorimage/gif

boolean

[]color.Color{...}和gif.GIF{...}slicestruct

gif.GIFstructstructstructanimstructstructLoopCountnframesstructanimstructDelayImage

lissajousforappendappendappendanimoutio.Writer

SetColorIndexmainlissajous

$ go build gopl.io/ch1/lissajous
$ ./lissajous >out.gif

第二章、编程语言

上面说了那么多，后面我们来步入正题

编程语言介绍

2.1、什么是编程语言

编程语言是用来控制计算机的一系列指令（Instruction），它有固定的格式和词汇（不同编程语言的格式和词汇不一样）。就像我们中国人之间沟通需要汉语，英国人沟通需要英语一样，人与计算机之间进行沟通需要一门语言作为介质，即编程语言。

CjavaGo

010010101001-》ADD

计算机在设计中规定了一组指令（二级制代码），这组指令的集和就是所谓的机器指令系统，用机器指令形式编写的程序称为机器语言。

但由于机器语言的千上万条指令难以记忆，并且维护性和移植性都很差，所以在机器语言的基础上，人们提出了采用字符和十进制数代替二进制代码，于是产生了将机器语言符号化的汇编语言。

虽然汇编语言相较于机器语言简单了很多，但是汇编语言是机器指令的符号化，与机器指令存在着直接的对应关系，无论是学习还是开发，难度依然很大。所以更加接近人类语言，也更容易理解和修改的高级语言就应运而生了，高级语言的一条语法往往可以代替几条、几十条甚至几百条汇编语言的指令。因此，高级语言易学易用，通用性强，应用广泛。

2.2、编译型语言与解释性语言

计算机是不能理解高级语言的，更不能直接执行高级语言，它只能直接理解机器语言，所以使用任何高级语言编写的程序若想被计算机运行，都必须将其转换成计算机语言，也就是机器码。而这种转换的方式分为编译和解释两种。由此高级语言也分为编译型语言和解释型语言。

编译型语言代码编译器可执行文件操作系统+CPU 解释型语言源代码解释器

编译型语言

使用专门的编译器，针对特定的平台，将高级语言源代码一次性的编译成可被该平台硬件执行的机器码，并包装成该平台所能识别的可执行性程序的格式。

exe

1、一次性的编译成平台相关的机器语言文件，运行时脱离开发环境，运行效率高；

2、与特定平台相关，一般无法移植到其他平台；

解释型语言

使用专门的解释器对源程序逐行解释成特定平台的机器码并立即执行。是代码在执行时才被解释器一行行动态翻译和执行，而不是在执行之前就完成翻译。

1.解释型语言每次运行都需要将源代码解释称机器码并执行，执行效率低；

2.只要平台提供相应的解释器，就可以运行源代码，所以可以方便源程序移植；

第三章、Go安装

3.1、GO编译器下载

– 官网：https://golang.google/

– go中文网：https://studygolang/dl

或者联系博主

3.2 MAC系统

mac下安装SDK

作者没用过mac

可以参考此文档，点击跳转

3.3 WIndows系统

3.3.1 Windows下安装SDK

双击我们下载好的Go语言开发包即可启动安装程序，如下图所示，这是Go语言的用户许可协议，无需管它，直接勾选“I accept
…”然后点击“Next”即可。

安装完成后，在我们所设置的安装目录下将生成一些目录和文件，如下图所示:

go env -w GOPROXY=https://goproxy,directgo env -w “GO111MODULE=off

3.3.2、Windows下配置环境

src

GOPATHGOPATH

GOPATHF:\GoWork

GOPATH对应创建的文件夹中里面，手动创建如下3个目录

src 存储go的源代码（需要我们自己手动创建）

pkg 存储编译后生成的包文件（自动生成）

bin 存储生成的可执行文件（自动生成)

3.4、IDE的安装与使用

安装IDEA

GoLand

-联系博主拿激活码以及软件，也可以前往官网自行下载官方下载

-环境配置请参考-----参考文档

3.5、idea快捷键

快捷键	作用
Ctrl + /	单行注释
Ctrl + Shift + /	多行注释
Ctrl + D	复制当前光标所在行
Ctrl + X	删除当前光标所在行
Ctrl + Alt + L	格式化代码
Ctrl + Shift +	方向键上或下将光标所在的行进行上下移动（也可以使用 Alt+Shift+方向键上或下）
Ctrl + Alt + left/right	返回至上次浏览的位置
Ctrl + R	替换
Ctrl + F	查找文本
Ctrl + Shift + F	全局查找

第四章、基础语法

4.1、注释

注释就是对代码的解释和说明，其目的是让人们能够更加轻松地了解代码。注释是开发人员一个非常重要的习惯，也是专业的一种表现。单行注释是最常见的注释形式，你可以在任何地方使用以 //
开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾。

注释在代码运行时不会被运行，

注释是写给人看的，不是写给机器看的

package main

import "fmt"

func main() {
	//  这是注释不会被运行
	//	fmt.Println("不会运行")
	fmt.Println("这是注释外，会运行")
}

4.2 变量

在计算机编程中，我们用变量来保存并管理很多数据，并用变量名来区分、识别和处理这些数据。

变量就是把数据，内存放到一个容器里面

4.2.1、GO声明变量

var

var  变量名 变量类型

package main

import "fmt"

func main() {
	var x int
	var s string
	var b bool

	fmt.Println(x) // 0
	fmt.Println(s) // ""
	fmt.Println(b) // false

}

Go里面声明未赋值默认是零型

int的零型是 0

string—> “”

bool—> false

如果声明多个变量，可以进行简写

package main

import "fmt"

func main() {

	var (
		name string
		age  int
	)
	fmt.Println(name, age)
}

4.2.2 变量赋值

GO中有三种赋值方式

一、变量名=值

先声明再赋值
var name int
name=10

直接声明赋值
var age=10

声明赋值简介版
z:="hello zth"

二、变量名=变量名

    var a = 100
    var b = a // 变量之间的赋值是值拷贝
    fmt.Println(a, b)
    a = 200
    fmt.Println(b)

三、变量名=值 + 值 (变量名)

    var a, b = 10, 20
    var c = a + b
    fmt.Println(c)
    var d = c + 100
    fmt.Println(d)

4.2.3 匿名变量

a,b,c :=4,5,6
fmt.Println(a,b,c)
// 如果只想接受第个变量,可以对前两个变量匿名
_,_,x := 4,5,6
fmt.Println(x)

匿名变量不占用命名空间，不会分配内存

让代码非常清晰，基本上屏蔽掉了可能混淆代码阅读者视线的内容，从而大幅降低沟通的复杂度和代码维护的难度。

4.2.4变量名命名的规则

变量命名是需要遵循一定的语法规范的，否则编译器不会通过。

1、变量名称必须由数字、字母、下划线组成。

2、标识符开头不能是数字。

3、标识符不能是保留字和关键字。

4、建议使用驼峰式命名，当名字有几个单词组成的时优先使用大小写分隔

5、变量名尽量做到见名知意。

6、变量命名区分大小写

go语言中有25个关键字，不能用于自定义变量名

关键字	关键字	关键字	关键字	关键字
break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

都会在后面一一提到

还有30多个预定义的名字，用于内建的常量、类型和函数
// 内建常量:

内建常量	内建类型	内建类型(2)	内型
false	int	float32	make
iota	int8	float64	len
nil	int16	complex128	cap
int32	complex64	new
int64	bool	append
uint	byte	copy
uint8	rune	close
uint16	string	delete
uint32	error	complex
uint64	real
uintptr	imag
panic
recover

4.3基本数据类型

基本数据类型包含整型和浮点型，布尔类型以及字符串，这几种数据类型在几乎所有编程语言中都支持。

4.3.1整型

int8 : -127~127 \\2的8次方个数
uint8 : 0~255
等等
int 在32位系统上就用的int32
int 在64位系统上就用的int64
int8: 一个字节 [-127~128]
uint8 : 从0开始[0~255]

类型	范围
int8	-127到127
int16	-32768到32767
int32	-2147483648到2147483647
uint32	0到4294967295
int64	-9223372036854775808到9223372036854775807
uint64	0到18446744073709551615
uint	与平台相关，32位操作系统上就是uint32，64位操作系统上就是uint64
int	与平台相关，32位操作系统上就是int32，64位操作系统上就是int64

4.3.2浮点型

float类型

float类型

单精度浮点数最多有7位十进制有效数字，如果某个数的有效数字位数超过7位，当把它定义为单精度变量时，超出的部分会自动四舍五入。双精度浮点数可以表示十进制的15或16位有效数字，超出的部分也会自动四舍五入。
浮点类型默认声明为float64。

	var f1 float32
	f1 = 3.15487464
	//reflect.TypeOf  打印数据类型
	fmt.Println(f1, reflect.TypeOf(f1))
	//float32：  单精度浮点型
	
    var f2 float64 // 双精度浮点型
    f2 = 3.1234567890123456789
    fmt.Println(f2, reflect.TypeOf(f2))

    var f3 = 3.1234567890123456789
    fmt.Println(f3, reflect.TypeOf(f2)) // 默认64

4.3.3布尔类型

truefalse

	var b bool // 声明b是一个布尔类型
	b = true
	b = false // 该类型只有true和false两个值，分别代表真假两种状态
	fmt.Println(b, reflect.TypeOf(b))

	fmt.Println(1 == 1) // 比较运算符的结果是一个布尔值
	// fmt.Println(1 == "1") // 报错，mismatched types不能比较
	fmt.Println(3 > 1)

	var name = "yuan"
	var b2 = name == "rain"
	//false ****
	fmt.Println(b2)

4.3.4字符串类型

注意

索引从零开始计数
go语言不支持负索引

	var s = "hello zhang"
	fmt.Println(s)

	// （1）索引取值 slice[index]
	a := s[2]
	fmt.Println(string(a))

	// （2）切片取值slice[start:end], 取出的元素数量为：结束位置 - 开始位置；
	b1 := s[2:5] //
	fmt.Println(b1)
	b2 := s[0:] // 当缺省结束位置时，表示从开始位置到整个连续区域末尾；
	fmt.Println(b2)
	b3 := s[:8] // 当缺省开始位置时，表示从连续区域开头到结束位置；
	fmt.Println(b3)

	// （3）字符串拼接
	var s1 = "hello"
	var s2 = "zhang"
	var s3 = s1 + s2 // 生成一个新的字符串
	fmt.Println(s3)

4.3.4.1 字符串常用方法

方法	介绍
len(str)	求长度
strings.ToUpper,strings.ToLower	生成一个新的全部大写的字符串,生成一个新的全部小写的字符串
strings.ReplaceAll	生成一个新的原字符串被指定替换后的字符串
strings.Contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Trim、	去除字符串两端匹配的内容
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Split	分割，将字符串按指定的内容分割成数组
strings.Join(a[]string, sep string)	join操作，将数组按指定的内容拼接成字符串

4.3.5转义符

转义符	含义
\r	回车符（返回行首）
\n	换行符（直接跳到下一行的同列位置）
\t	制表符
\’	单引号
\"	双引号
\\	反斜杠

4.3.6 进制转换

//	十进制转化
	var n int = 10
	//printf 传输数据进去
	fmt.Printf("%d \n", n) //%d  表示十进制
	fmt.Printf("%o \n", n) // 占位符%o表示八进制
	fmt.Printf("%b \n", n) //占位符%b表示二进制
	fmt.Printf("%x \n", n) //占位符%x表示十六进制
	// 八进制转化
	var b int = 020
	fmt.Printf("%o \n", b) // 20
	fmt.Printf("%d \n", b) // 16
	fmt.Printf("%x \n", b) // 10
	fmt.Printf("%b \n", b) // 10000
	// 十六进制转化
	var c = 0x12
	fmt.Printf("%d \n", c) // 18
	fmt.Printf("%o \n", c) // 22
	fmt.Printf("%x \n", c) // 12
	fmt.Printf("%b \n", c) // 10010

4.3.7 数据类型转换

//（1）整型之间的转换 int8 int16
	var x int8 = 10
	var y int16 = 20
	fmt.Println(x + int8(y))
	// （2）字符串与整型之间的转换 strconv库
	var agestr = "32"
	//var name = 12
	//字符串转整型
	var age, _ = strconv.Atoi(agestr)
	fmt.Println(age)
	//fmt.Println("err: ", err) // <nil>空对象
	price := 100
	//整形转字符
	price_str := strconv.Itoa(price)
	fmt.Println(price_str, reflect.TypeOf(price_str))

	//strconv parse系列函数
	//字符串转整型 base进制   bitSize是比特位 8---int8
	ret, _ := strconv.ParseInt("28", 10, 8)
	fmt.Println(ret, reflect.TypeOf(ret))
	//字符串转换为浮点型
	floats, _ := strconv.ParseFloat("3.1415926", 64)
	fmt.Println(floats, reflect.TypeOf(floats))
	//字符串转换为布尔值
	b, _ := strconv.ParseBool("0")
	b1, _ := strconv.ParseBool("-1")
	b2, _ := strconv.ParseBool("true")
	b3, _ := strconv.ParseBool("T")
	fmt.Println(b, b1, b2, b3)

4.3.8 运算符

和python运算符一样

//计算一个数是为奇数还是偶数
	x, y := 10, 20
	fmt.Println(x%2 == 0, y)

	//关系运算符 与python相同 == != >= <= 返回布尔值
	fmt.Println(x >= y)
	//逻辑运算符
	//与或非运算
	/*
		与&&: 真真-真，真假-假，假假-假 ，
		或||： 真或真-真，真或假为真,假或假为假
		非运算 !：非真为假，非假为真  取反
	*/
	fmt.Println(true && false)
	fmt.Println(true || false)
	fmt.Println(!true || false)
	//database:root 123
	username := "zhang"
	password := 123
	fmt.Println(username == "root" && password == 123)
	/*
		赋值运算
		和python一样
	*/
	var a = 12
	a += 1
	fmt.Println(a)
	var b = 10
	//自加一
	b++
	fmt.Println(b)
	//优先级
	var q, w, z = 1, 2, 3
	fmt.Println(q, w, z)
	var t = q + w
	fmt.Println(t)

4.3.9 输入输出函数

4.3.9.1 输出函数

fmt.Print

PrintPrintlnPrintf Sprintf

//输出函数
	//print println
	var name, age = "yuan", 32
	fmt.Println("hello world")
	fmt.Println(name)
	fmt.Println(age)
	fmt.Println("姓名:", name, "年龄", age)
	//fmt.Print(name)
	//fmt.Print(age)
	var isMarried = false
	fmt.Printf("姓名:%s,年龄:%d,婚否:%t\n", name, age, isMarried)
	//sprintf:
	s := fmt.Sprintf("姓名:%s,年龄:%d,婚否:%t", name, age, isMarried)
	fmt.Println(s)

4.3.9.2 输入函数

fmt

fmt.Scanfmt.Scanffmt.Scanln

1、语法：

func Scan(a ...interface{}) (n int, err error)

	var (
		birth string
	)
	fmt.Println("输入生日格式如:1988-3-16")
	fmt.Scan(&birth)
	birthslice := strings.Split(birth, "-")
	fmt.Printf("您的生日是%s年-%s月-%s日", birthslice[0], birthslice[1], birthslice[2])

2、语法：

func Scanf（format string, a ...interface{}）(n int, err error)

//(2)fmt.scanf  按照指定的格式输入
	var a, b int
	fmt.Scanf("%d+%d", &a, &b)
	fmt.Println(a + b)

3、语法、

func Scanln(a ...interface{}) (n int, err error)

ScanlnScanScanlnScanScan

4.3.10 常量与iota

常量是⼀个简单值的标识符，在程序运⾏时，不会被修改的量。在Python、Java编程规范中，常量⼀般都是全⼤写字母，但是在Golang中，⼤⼩写是具有⼀定特殊含义的，所以不⼀定所有常量都得全⼤写。

const

const 常量名[数据类型] = value

数据类型可以忽略不写，Golang编译器会⾃动推断出数据类型。在使⽤时，要注意以下⼏点：
数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
满⾜多重赋值
常量只定义不使⽤,编译不会报错
常量可以作为枚举，常量组
常量组中如不指定类型和初始化值，则与上⼀⾏⾮空常量右值相同
显⽰指定类型的时候，必须确保常量左右值类型⼀致，需要时可做显⽰类型转换。

     // （1）声明常量
    const pai = 3.1415926
    const e float64 = 2.7182818
    fmt.Println(pai * pai)

    // （2）常量也可以和变量一样一组一起声明
    // const monday, tuesday, wednesday = 1, 2, 3
    // 更推荐下面这种方式
    const (
        monday    = 1
        tuesday   = 2
        wednesday = 3
        thursday  = 4
        friday    = 5
        saturday  = 6
        sunday    = 7
    )

    const (
        female = 0
        male   = 1
    )

    // ⼀组常量中，如果某个常量没有初始值，默认和上⼀⾏⼀致

    const (
        a int = 1
        b
        c = 2
        d
    )
    fmt.Println(a, b, c, d)

4.3.10.1 iota计数器

iotaiotaiotaconstconstiotaiotaconst

package main

import "fmt"

type Weekday int
type Flags uint

//常量生成器iota

const (
	Sunday Weekday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

const (
	FlagUp Flags = 1 << iota
	FlagBroadcast
)

// 无类型常量
const (
	deadful = 0xdeadbeef //无类型整数

)

func main() {
	fmt.Println()
}

部分内容出自于《GO语言圣经》