当前位置：
  1. 首页
  2. 互联网
  3. 正文
本文介绍: / 全局变量和局部变量(定义在main外面的变量都是全局变量)// 简洁方式定义全局变量var (ok = true//局部变量定义了就必须使用，不使用会报错；全局变量定义了之后可以不使用，不会报错。//go是静态语言，静态语言和动态语言相比，定义变量差异很大//1、变量必须想定义后使用 2、变量必须有类型 3、变量类型定下来之后不能改变//定义变量的方式//方式一：var variableName variableTypename = “旺财”//演示：变量类型定下来之后不能改变。

1、go语言介绍

 

2、go开发环境搭建

2.1、go的安装

 

2.2、go的环境变量配置 

goLand的安装、配置

2.3、go开发之hello-world

3、变量和常量

3.1、如何定义变量

package main

import "fmt"

// 全局变量和局部变量(定义在main外面的变量都是全局变量)
//var sex = "male"
//var ok bool = true

// 简洁方式定义全局变量
var (
	sex = "male"
	ok  = true
	age = 18
)

//局部变量定义了就必须使用，不使用会报错；全局变量定义了之后可以不使用，不会报错。

func main() {
	//go是静态语言，静态语言和动态语言相比，定义变量差异很大
	//1、变量必须想定义后使用 2、变量必须有类型 3、变量类型定下来之后不能改变
	//定义变量的方式
	//方式一：var variableName variableType
	var name string
	name = "旺财"
	//演示：变量类型定下来之后不能改变
	//name = 1

	fmt.Print(name)

	/*
		方式二：var variableName = variableValue
		可以省略variableType，因为go可以通过variableValue进行类型推断。
	*/

	var name2 = "小强"
	fmt.Print(name2)

	/*
		方式三：variableName := variableValue
		这种平时用的比较多
	*/

	//var age = 1
	age := 1
	fmt.Print(age)

	//go语言中局部变量定义了但是不使用，是不行的。

	//2、多变量定义
	//2、多变量定义
	//2.1、同时在一行里面定义3个string类型的变量
	var user1, user2, user3 string
	fmt.Print(user1, user2, user3)
	//2.2、同时在一行里面定义3个变量，并且初始化。
	var user4, user5, user6 = "小强", "旺财", 1
	fmt.Print(user4, user5, user6)

	/*
		注意：
			变量必须先定义再使用
			go语言是静态语言，要求变量的类型和赋值类型一致
			局部变量名不能冲突；全局变量和局部变量的变量名可以重复，这种情况下，局部变量的优先级高。
			简洁变量定义不能用于全局变量(方式三：variableName := variableValue)
			变量是有零值的
			局部变量定义了就必须使用，不使用会报错；全局变量定义了之后可以不使用，不会报错。
	*/

}

3.2、常量的定义和使用

package main

import "fmt"

func main() {
	//常量，定义的时候就指定的值，不能修改。
	//常量定义的时候全部大写。多个单词中间加下划线。
	const PI1 float32 = 3.1415926535897932384626 //显式定义
	const PI2 = 3.1415926535897932384626         //隐式定义

    // 同时定义多个常量
	const (
		UNKNOWN = 1
		FEMALE  = 2
		MALE    = 3
	)

    // 同时定义多个常量,并且支持类型定义。
	const (
		X int = 1
		Y
		S = "abc"
		Z
		M
	)
	fmt.Println(X, Y, S, Z, M)

	/*
		1、常量类型只可以定义bool、数值(整数、浮点数和复数) 和 字符串；
		2、不曾使用的常量，没有强制使用的要求；
		3、显式指定类型的时候，必须确保常量 左右值类型一致。
		4、常量在定义的时候如果没有设置类型和值的话，它就用前面的类型和值。
	*/

}

代码执行结果：

         从打印结果可以看出，Y没有定义类型和值，但是Y可以使用前面X的类型和值。M也是同样的道理。

3.3、iota的使用细节

package main

import "fmt"

func main() {
	//iota，特殊常量，可以认为是一个可以被编译器修改的常量。
	const (
		ERR1 = iota + 1
		ERR2
		ERR3
		ERR4 = "abc"
		ERR5
		ERR6 = 100
		ERR7 = iota
	)

	const (
		ERRNEW1 = iota
	)

	fmt.Println(ERR1, ERR2, ERR3, ERR4, ERR5, ERR6, ERR7)
	fmt.Println(ERRNEW1)
	/*
		如果中断了iota那么必须显式的恢复，后续会自动递增。
		自增类型默认是int类型
		iota能简化const类型的定义
		每次出现const的时候，iota初始化为0
	*/

}
代码运行结果：

​

3.4、匿名变量的定义和用途

package main

func a() (int, bool) {
	return 0, false
}

func main() {
	//匿名变量：就是一个下划线
	var _ int
	//r1, ok := a()
	_, ok := a()
	/*
		如果我接下来只想使用ok，不想使用r1，根据Go的局部变量定义规定的，定义了就必须使用，那我就必须在下面被迫的加一个多余的打印r1的代码。
		有什么好办法吗？
		这时，匿名变量就登场了。可以使用"_"代替r1，这样在下面可以不用也不会报错了。
	*/
	if ok {
		//打印
		
	}
}
​

3.5、变量的作用域

package main

import "fmt"

// 全局变量：任何一个函数都可以使用这个变量
var globalVariable = "旺财"

func main() {
	//变量的作用域

	//局部变量
	localVariable := "小强"
	fmt.Print(localVariable)

	{
		//局部变量
		localVariable2 := "张三"
		fmt.Print(localVariable2)
	}
	//在局部变量作用域外部打印该变量会报错
	//fmt.Print(localVariable2)

}
​

4、go的基础数据类型

4.1、数值、浮点数和字符类型

package main

import "fmt"

func main() {
	//基础数据类型
	//var a int8
	//var b int16
	//var c int32
	//var d int64
	//var ua uint8
	//var ub uint16
	//var uc uint32
	//var ud uint64
	动态类型，用的时候就会知道，用起来挺麻烦的
	//var e int
	//
	类型转换需要强转才行
	//a = int8(b)
	//
	//var f1 float32
	//var f2 float64
	//
	//f1 = 3
	//f2 = 3.14

	//主要是用来存放英文字符的
	var c byte
	c = 'a' + 1
	fmt.Println(c)        //值是98
	fmt.Printf("c=%c", c) //打印的是 c=b

	c1 := 97
	fmt.Println()
	fmt.Printf("c1=%c", c1) //打印的是 c=a

	//也是字符，主要是用来存放中文字符的
	var c2 rune
	c2 = '旺'
	fmt.Println()
	fmt.Printf("c=%c", c2) //打印的是 c=旺

	//字符串
	var name string
	name = "My name is Peter Parker,I am a Super Hero. I don't like the Criminals."
	fmt.Println()
	fmt.Println(name)
}

运行结果：

bool类型

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

数值型

  1. 整数型

可以简单讲解一下二进制和位数的关系，以及int和uint的关系

  • int8 有符号 8 位整型 (-128 到 127) 长度：8bit

  • int16 有符号 16 位整型 (-32768 到 32767)

  • int32 有符号 32 位整型 (-2147483648 到 2147483647)

  • int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

  • uint8 无符号 8 位整型 (0 到 255) 8位都用于表示数值：

  • uint16 无符号 16 位整型 (0 到 65535)

  • uint32 无符号 32 位整型 (0 到 4294967295)

  • uint64 无符号 64 位整型 (0 到 18446744073709551615)

  1. 浮点型

  • float32 32位浮点型数

  • float64 64位浮点型数

其他

字符

        Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。 ​ 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。

package main

import (
	"fmt"
)

func main() {

	var a byte
	a = 'a'
	//输出ascii对应码值 。。 这里说明一下什么是ascii码
	fmt.Println(a)
	fmt.Printf("a=%c", a)
}

        字符常量只能使用单引号括起来，例如：var a byte = ‘a’ var a int = ‘a’

package main

import (
	"fmt"
)

func main() {

	var a byte
	a = "a"
	//输出ascii对应码值 。。 这里说明一下什么是ascii码
	fmt.Println(a)
	fmt.Printf("a=%c", a)
}

        字符本质是一个数字， 可以进行加减乘除

package main

import (
	"fmt"
	"reflect"
)

func main() {

	a := 'a'

	//这里注意一下 1. a+1可以和数字计算 2.a+1的类型是32 3. int类型可以直接变成字符

	fmt.Println(reflect.TypeOf(a+1))
	fmt.Printf("a+1=%c", a+1)
}

字符串

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

4.2、基本类型的转换

package main

import (
	"fmt"
	"strconv"
)

func main() {
	//基本类型转换
	//int和int相互转换
	var a int8 = 12
	//var b = uint8(a)
	//fmt.Print(b)

	//float转int
	//var f float32 = 3.14
	//var c = int32(f)
	//fmt.Println(c) //打印的是3

	//int转float
	//var f64 = float64(a)
	//fmt.Println(f64) //打印的是12

	//定义别名
	type IT int //类型要求很严格
	var c = IT(a)
	fmt.Println(c)

	//字符串转数字
	var istr = "12"
	myint, err := strconv.Atoi(istr)
	if err != nil {
		fmt.Println("convert erro")
	}
	fmt.Println(myint)

	//数字转字符串
	var myi = 32
	fmt.Println(strconv.Itoa(myi))
	
}

type 关键字：

        在 Go 语言中，type 关键字常被我们用来创建新的结构体。同样的，type 也可以用来创建其它的用户自定义类型。在创建新类型时，有类型别名和类型定义两种方式，你知道它们的区别吗？

1、type 关键字

        对于使用过 Go 语言的人，相信对type关键字都不陌生，它可以帮助我们定义结构体或接口：

type Student struct{

}

type Man interface {
    Name()
}

        在使用 type 定义结构体时，我们可以把它看作是基于struct{}类型定义了一个新的类型Student。

        其实，除了用于创建新类型，type还有创建类型别名的作用。

2、类型别名 vs 类型定义

基于一个类型创建一个别名，称之为类型别名 (alias)。

基于一个类型创建一个新类型，称之为类型定义 (definition)。

type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型

它们之间的区别是什么呢？

        以上述定义的Int1和Int2为例，我们可以用int类型的变量初始化Int1类型，因为Int1只是int类型的一个别名。

        但如果我们用一个int类型的变量初始化Int2类型时，对Int2类型的初始化会报错，因为Int2是一个新的类型。

type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型

var i int = 0

var i1 Int1 = i
var i2 Int2 = i // error

        不过，Int1类型和Int2类型都可以用相应类型的字面量来初始化。

type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型

var i1 Int1 = 0
var i2 Int2 = 0

4.2.1、简单的转换操作

valueOfTypeB = typeB(valueOfTypeA)
代码块1
// 浮点数
a := 5.0

// 转换为int类型
b := int(a)

//Go允许在底层结构相同的两个类型之间互转。例如：
// IT类型的底层是int类型
type IT int

// a的类型为IT，底层是int
var a IT = 5

// 将a(IT)转换为int，b现在是int类型
b := int(5)

// 将b(int)转换为IT，c现在是IT类型
c := IT(b)

var a int32 = 1
var b int64 = 3
b = int64(a)
fmt.Println(a, b)

/*
    不是所有数据类型都能转换的，例如字母格式的string类型"abcd"转换为int肯定会失败
    低精度转换为高精度时是安全的，高精度的值转换为低精度时会丢失精度。例如int32转换为int16，float32转换为int
    这种简单的转换方式不能对int(float)和string进行互转，要跨大类型转换，可以使用strconv包提供的函数
*/




4.2.2、strconv


Itoa和Atoi


int转换为字符串：Itoa()


println("a" + strconv.Itoa(32))  // a32


string转换为int：Atoi()(表示 alphanumeric to integer)是把字符串转换成整型数的一个函数


i,_ := strconv.Atoi("3")
println(3 + i)   // 6

// Atoi()转换失败
i,err := strconv.Atoi("a")
if err != nil {
    println("converted failed")
}
//由于string可能无法转换为int，所以这个函数有两个返回值：第一个返回值是转换成int的值，第二个返回值判断是否转换成功。




4.3、format进行格式化转换




Parse类函数


        Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。


b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)


ParseInt()和ParseUint()有3个参数：


func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)


说明：


    

  1. 

    bitSize参数表示转换为什么位的int/uint，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8。
    

    2. 

  2. 

    base参数表示以什么进制的方式去解析给定的字符串，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析。
    

    3. 



Format类函数


        将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。


s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16) //表示将-42转换为16进制数，转换的结果为-2a。
s := strconv.FormatUint(42, 16)


        第二个参数base指定将第一个参数转换为多少进制，有效值为2<=base<=36。当指定的进制位大于10的时候，超出10的数值以a-z字母表示。例如16进制时，10-15的数字分别使用a-f表示，17进制时，10-16的数值分别使用a-g表示。


FormatFloat()参数众多：


func FormatFloat(f float64, fmt byte, prec, bitSize int) string


        bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。 ​


        fmt表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为二进制）、‘e’（-d.dddde±dd，十进制指数）、‘E’（-d.ddddE±dd，十进制指数）、‘g’（指数很大时用’e’格式，否则’f’格式）、‘G’（指数很大时用’E’格式，否则’f’格式）。 ​


        prec控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示小数点后的数字个数；对’g’、‘G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。




4.4、运算符和表达式


4.4.1、算数运算符


    

  • 

      

    • 

        

      • 

        / %(求余) ++ –
        

        • 

      

      • 

    

    • 



4.4.2、关系运算符


== != > < >= <=


4.4.3、逻辑运算符






&amp;&amp;
所谓逻辑与运算符。如果两个操作数都非零，则条件变为真






||
所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真




!
所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假






这个和python不一样，python中使用 and or来连接


package main
​
import "fmt"
​
func main() {
   var a bool = true
   var b bool = false
   if ( a &amp;&amp; b ) {
      fmt.Printf("第一行 - 条件为 truen" )
   }
   if ( a || b ) {
      fmt.Printf("第二行 - 条件为 truen" )
   }
   /* 修改 a 和 b 的值 */
   a = false
   b = true
   if ( a &amp;&amp; b ) {
      fmt.Printf("第三行 - 条件为 truen" )
   } else {
      fmt.Printf("第三行 - 条件为 falsen" )
   }
   if ( !(a &amp;&amp; b) ) {
      fmt.Printf("第四行 - 条件为 truen" )
   }
}


4.4.4、位运算符


位运算符对整数在内存中的二进制位进行操作。 ​ 下表列出了位运算符 &, |, 和 ^ 的计算：






P
Q
P & Q
P | Q
P ^ Q






0
0
0
0
0




0
1
0
1
1




1
1
1
1
0




1
0
0
1
1






假定 A = 60; B = 13; 其二进制数转换为： A = 0011 1100 B = 0000 1101


A&B = 0000 1100


A|B = 0011 1101


A^B = 0011 0001 Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：






运算符
描述
实例






&
按位与运算符”&”是双目运算符。 其功能是参与运算的两数各对应的二进位相与。
(A & B) 结果为 12, 二进制为 0000 1100




|
按位或运算符”|”是双目运算符。 其功能是参与运算的两数各对应的二进位相或
(A | B) 结果为 61, 二进制为 0011 1101




^
按位异或运算符”^”是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。
(A ^ B) 结果为 49, 二进制为 0011 0001




<<
左移运算符”<<“是双目运算符。左移n位就是乘以2的n次方。 其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<“右边的数指定移动的位数，高位丢弃，低位补0。
A << 2 结果为 240 ，二进制为 1111 0000




>>
右移运算符”>>”是双目运算符。右移n位就是除以2的n次方。





其功能是把”>>“左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数。
A >> 2 结果为 15 ，二进制为 0000 1111







package main

import "fmt"

func main() {

   var a uint = 60      /* 60 = 0011 1100 */  
   var b uint = 13      /* 13 = 0000 1101 */
   var c uint = 0          

   c = a & b       /* 12 = 0000 1100 */
   fmt.Printf("第一行 - c 的值为 %dn", c )

   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("第二行 - c 的值为 %dn", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("第三行 - c 的值为 %dn", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("第四行 - c 的值为 %dn", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("第五行 - c 的值为 %dn", c )
}


4.4.5、赋值运算符


下表列出了所有Go语言的赋值运算符。






运算符
描述
实例






=
简单的赋值运算符，将一个表达式的值赋给一个左值
C = A + B 将 A + B 表达式结果赋值给 C




+=
相加后再赋值
C += A 等于 C = C + A




-=
相减后再赋值
C -= A 等于 C = C – A




*=
相乘后再赋值
C *= A 等于 C = C * A




/=
相除后再赋值
C /= A 等于 C = C / A




%=
求余后再赋值
C %= A 等于 C = C % A




<<=
左移后赋值
C <<= 2 等于 C = C << 2




>>=
右移后赋值
C >>= 2 等于 C = C >> 2




&=
按位与后赋值
C &= 2 等于 C = C & 2




^=
按位异或后赋值
C ^= 2 等于 C = C ^ 2




|=
按位或后赋值
C |= 2 等于 C = C | 2






package main

import "fmt"

func main() {
   var a int = 21
   var c int

   c =  a
   fmt.Printf("第 1 行 - =  运算符实例，c 值为 = %dn", c )

   c +=  a
   fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %dn", c )

   c -=  a
   fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %dn", c )

   c *=  a
   fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %dn", c )

   c /=  a
   fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %dn", c )

   c  = 200;

   c <<=  2
   fmt.Printf("第 6行  - <<= 运算符实例，c 值为 = %dn", c )

   c >>=  2
   fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %dn", c )

   c &=  2
   fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %dn", c )

   c ^=  2
   fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %dn", c )

   c |=  2
   fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %dn", c )

}


4.4.6、其他运算符


此处讲解一下什么是地址






运算符
描述
实例






&
返回变量存储地址
&a; 将给出变量的实际地址。




*
指针变量。
*a; 是一个指针变量






package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %Tn", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %Tn", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %Tn", c );

   /*  & 和 * 运算符实例 */
   ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %dn", a);
   fmt.Printf("*ptr 为 %dn", *ptr);
}


4.4.7、运算符优先级


有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低






优先级
分类
运算符
结合性






1
逗号运算符
,
从左到右




2
赋值运算符
=、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、|=
从右到左




3
逻辑或
||
从左到右




4
逻辑与
&&
从左到右




5
按位或
|
从左到右




6
按位异或
^
从左到右




7
按位与
&
从左到右




8
相等/不等
==、!=
从左到右




9
关系运算符
<、<=、>、>=
从左到右




10
位移运算符
<<、>>
从左到右




11
加法/减法
+、-
从左到右




12
乘法/除法/取余
*（乘号）、/、%
从左到右




13
单目运算符
!、*（指针）、& 、++、–、+（正号）、-（负号）
从右到左




14
后缀运算符
( )、[ ]、->
从左到右






当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。


package main

import "fmt"

func main() {
   var a int = 20
   var b int = 10
   var c int = 15
   var d int = 5
   var e int;

   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   fmt.Printf("(a + b) * c / d 的值为 : %dn",  e );

   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   fmt.Printf("((a + b) * c) / d 的值为  : %dn" ,  e );

   e = (a + b) * (c / d);   // (30) * (15/5)
   fmt.Printf("(a + b) * (c / d) 的值为  : %dn",  e );

   e = a + (b * c) / d;     //  20 + (150/5)
   fmt.Printf("a + (b * c) / d 的值为  : %dn" ,  e );  
}




5、字符串基本操作


5.1、rune和字符串长度


package main

import "fmt"

func main() {
	//5.1节 rune和字符串长度
	//长度计算
	name := "lvxiaosha学go"
	fmt.Println(len(name))

	//将字符串类型的name转换为切片，然后就可以for循环了。
	bytes := []byte(name)
	fmt.Println(len(bytes))
	//因为 len() 传入 返回字符串所占的字节 ，而中文转 utf8 编码后占 3 字节，英文占 1 字节。所以上面两个输出结果都是：9 + 3 + 2 = 14

	//如果我们想得到字符长度，而不是字节长度，就需要转为 切片 后再计算长度。
	runes := []rune(name)
	fmt.Println(len(runes)) // 10
	
}


运行结果：






5.2、转义符


package main

import "fmt"

func main() {
	//5.2节转义符
	//想在字符串中打印双引号
	//方法1：使用反斜线加双引号(")
	name := ""吕小傻""
	fmt.Println(name)

	//方法2：使用Tab键上面的那个键(`)，注意不是单引号(')。
	//这个和python中的三引号("""xxx""")里面可以随便写内容类似。
	//我们大多数使用的都是这个方法。
	name2 := `"吕小傻"`
	fmt.Println(name2)
}


转义符






转义字符
意义
ASCII码值（十进制）






n
换行(LF) ，将当前位置移到下一行开头
010




r
回车(CR) ，将当前位置移到本行开头
013




t
水平制表(HT) （跳到下一个TAB位置）
009




\
代表一个反斜线字符’’’
092




’
代表一个单引号（撇号）字符
039




“
代表一个双引号字符
034




?
代表一个问号
063






5.3、格式化输出


package main

import (
	"fmt"
	"strconv"
)

func main() {
	//5.3节格式化输出
	userName := "吕小傻"
	address := "山东省青岛市"
	age := 18
	mobile := "13624558575"

	fmt.Println("用户名："+userName, "地址："+address, "年龄："+strconv.Itoa(age), "电话："+mobile) //这种拼接方式极难维护
	fmt.Printf("用户名:%s,地址:%s,年龄:%d,电话:%srn", userName, address, age, mobile)         //这种方式更常用，但是性能没有上一种好。

	userMessage := fmt.Sprintf("用户名:%s,地址:%s,年龄:%d,电话:%s", userName, address, age, mobile)
	fmt.Println(userMessage)

	var ages []int = []int{1, 2, 3}
	agesMessage := fmt.Sprintf("年龄:%#v", ages)
	fmt.Println(agesMessage)
}







缺省格式和类型






格式化后的效果
动词
描述






[0 1]
%v
缺省格式




[]int64{0, 1}
%#v
go语法打印




[]int64
%T
类型打印








整型(缩进, 进制类型, 正负符号)






格式化后的效果
动词
描述






15
%d
十进制




+15
%+d
必须显示正负符号




␣␣15
%4d
Pad空格(宽度为4，右对齐)




15␣␣
%-4d
Pad空格 (宽度为4，左对齐)




1111
%b
二进制




17
%o
八进制




f
%x
16进制，小写








字符(有引号, Unicode)


Value: 65   (Unicode letter A)






格式化后的效果
动词
描述






A
%c
字符




‘A’
%q
有引号的字符




U+0041
%U
Unicode




U+0041 ‘A’
%#U
Unicode 有引号








浮点(缩进, 精度, 科学计数)


Value: 123.456






格式化后的效果
动词
描述






1.234560e+02
%e
科学计数




123.456000
%f
十进制小数








字符串or 字节slice (引号, 缩进, 16进制)


Value: "cafe"






格式化后的效果
动词
描述






cafe
%s
字符串原样输出




␣␣cafe
%6s
宽度为6，右对齐






5.4、高性能字符串拼接-string.builder


package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	//5.4节 高性能字符串拼接-string.builder
	userName := "吕小傻"
	address := "山东省青岛市"
	age := 18
	mobile := "13624558575"

	var builder strings.Builder
	builder.WriteString("用户名:")
	builder.WriteString(userName)
	builder.WriteString(",地址:")
	builder.WriteString(address)
	builder.WriteString(",年龄:")
	builder.WriteString(strconv.Itoa(age))
	builder.WriteString(",电话:")
	builder.WriteString(mobile)

	response := builder.String()
	fmt.Println(response)
}



运行结果：






 5.5、字符串的比较


package main

import "fmt"

func main() {
	//5.5节 字符串的比较
	a := "hello"
	b := "hello"
	fmt.Println(a == b)
	fmt.Println(a != b)

	//字符串的大小比较
	fmt.Println(a > b)

}






5.6、字符串操作常用方法


package main

import (
	"fmt"
	"strings"
)

func main() {
	//5.6节 字符串操作常用方法
	//strings常用方法
	//是否包含
	name := "My name is Peter Parker,I am a Super Hero.I don't like the Criminals."
	fmt.Println(strings.Contains(name, "Peter Parker"))

	//字符串长度
	runes := []rune(name)
	fmt.Println(len(runes))

	//查询字符串出现的次数
	fmt.Println(strings.Count(name, "a"))

	//分割字符串
	fmt.Println(strings.Split(name, ","))

	//字符串是否包含前缀，是否包含后缀。
	fmt.Println(strings.HasPrefix(name, "My"))
	fmt.Println(strings.HasSuffix(name, "Criminals."))

	//查询子串出现的位置
	fmt.Println(strings.Index(name, "Peter Parker"))
	fmt.Println(strings.IndexRune(name, []rune(name)[17]))

	//字符串替换
	fmt.Println(strings.Replace(name, "Peter Parker", "Super Man", 1)) // 1表示只替换第一个
	fmt.Println(strings.Replace(name, "Peter Parker", "Iron Man", -1)) // -1表示全部替换

	//大小写转换
	fmt.Println(strings.ToLower("Peter Parker"))
	fmt.Println(strings.ToUpper("Peter Parker"))

	//去掉字符串左右两边的特殊字符，下面的方法表示，只要字符串两边出现了"#"或"$"，就去掉。
	//除了strings.Trim，还有strings.TrimLeft和strings.TrimRight方法
	fmt.Println(strings.Trim("$#Peter #Parker#", "#$"))

}



运行结果：






6.1、if条件判断


package main

import "fmt"

/*
*

	if 布尔表达式 {
	  逻辑
	}
*/
func main() {
	//6.1节 if条件判断
	age := 18
	country := "中国"
	//简单的if条件判断，布尔表达式的括号省略
	if age < 18 {
		fmt.Println("未成年")
	}

	//复杂的if条件判断，布尔表达式的括号不能省略
	if (age < 18) && (country == "中国") {
		fmt.Println("未成年")
	} else if age == 18 {
		fmt.Println("刚刚成年")
	} else {
		fmt.Println("成年了")
	}

}





6.2、for循环基础用法


package main

import (
	"fmt"
)

/*
 * go语言中只有for循环，没有while循环。
 * for init; condition; post {
 *   //do something
 *	}
 */
func main() {
	//6.1节 for循环基础用法
	//标准写法
	for i := 0; i < 3; i++ {
		fmt.Println(i)
	}

	//初始变量在循环外面定义
	var j int
	for ; j < 3; j++ {
		fmt.Println(j)
	}

	// init; condition; post 都没有，就等效与while(true)
	//var k int
	//for {
	//	//睡眠2秒
	//	time.Sleep(2 * time.Second)
	//	fmt.Println(k)
	//	k++
	//}

	// 可以将post部分放到循环体里面
	var m int
	for m < 3 {
		fmt.Println(m)
		m++
	}

}





6.3、for循环打印九九乘法表


package main

import "fmt"

/*
 * 6.3节 for循环打印九九乘法表
 * for循环打印九九乘法表
 */
func main() {
	//遍历，处理第几行
	for y := 1; y <= 9; y++ {
		//遍历，处理第几列。
		for x := 1; x <= y; x++ {
			fmt.Printf("%d * %d = %dt", x, y, x*y)
		}
		fmt.Println()
	}

}



运行结果:






6.4、for range的循环用法


package main

import (
	"fmt"
)

/*
 * 6.4节 for range的循环用法，主要用于 字符串、数组、切片、map、channel
 */
func main() {
	name := "My name is Peter Parker."
	//for index, value := range name {
	//	fmt.Printf("%d, %crn", index, value)
	//}

	for _, value := range name {
		fmt.Printf("%crn", value)
	}

	/*
	 * 字符串  字符串的索引(key)  字符串对应的索引的字符值的拷贝(index),因为是字符串值的拷贝，所以在字符串循环时是改不了原字符串的  如果不写key,那么index返回的是索引
	 * for index := range name {
	 *     fmt.Printf("%crn", index)
	 * }
	 *
	 * 数组  数组的索引          索引的对应值的拷贝                   如果不写key,那么value返回的是索引
	 * 切片  切片的索引          索引的对应值的拷贝                   如果不写key,那么value返回的是索引
	 * map  字符串的索引(key)    value 返回的是 key 对应值的拷贝      如果不写key,那么value返回的是map的值
	 * channel                value 返回的是 channel 接受的数据
	 */

	//下面这种方式循环字符串时会出现中文乱码
	name2 := "哈哈哈"
	for index := range name2 {
		fmt.Printf("%crn", name2[index])
	}

	//下面这种方式循环字符串时，就不会出现中文乱码
	name3 := "哈哈哈"
	for _, value := range name3 {
		fmt.Printf("%crn", value)
	}

}



6.5、for循环的continue和break语句


package main

import (
	"fmt"
	"time"
)

func main() {
	index := 0
	for {
		time.Sleep(1 * time.Second)
		index++

		//如果index等于5，就直接进入下一次循环，不执行下面的代码。
		if index == 5 {
			continue
		}

		fmt.Println(index)
		if index > 10 {
			//退出循环
			break
		}
	}
}






6.6、goto语句的基本用法


package main

import "fmt"

/*
 * 6.6节 goto语句的基本用法
 * goto语句可以让我们的代码跳到指定的代码块中运行，灵活性很强。但是开发中不建议使用。
 *
 * goto语句可以实现程序的跳转，goto语句使用场景最多的是程序的错误处理，也就是说当程序出现错误的时候统一跳转到相应的标签处，统一处理。
 */
func main() {
	for i := 0; i < 5; i++ {
		for j := 0; j < 5; j++ {
			if j == 2 {
				goto over
			}
			fmt.Println(i, j)
		}

	}

over:
	fmt.Println("over")

}



运行结果：






6.7、switch语法


package main

import "fmt"

/*
 * 6.7节 switch语句 比if语句执行性能更高一些，而且代码更整洁。
 * switch var1 {
 *     case val1:
 *         ...
 *     case val2:
 *         ...
 *     case val3:
 *         ...
 *     default:
 *         ...
 *
 * var1变量可以是任意的变量类型
 */
func main() {
	//中文的星期几，输出对应的英文
	day := "星期三"
	switch day {
	case "星期一":
		fmt.Println("Monday")
	case "星期二":
		fmt.Println("Tuesday")
	case "星期三":
		fmt.Println("Wednesday")
	case "星期四":
		fmt.Println("Thursday")
	case "星期五":
		fmt.Println("Friday")
	case "星期六":
		fmt.Println("Saturday")
	case "星期日":
		fmt.Println("Sunday")
	default:
		fmt.Println("Unknown")
	}

	//还有更灵活的switch用法
	score := 95
	switch {
	case score < 60:
		fmt.Println("E")
	case score >= 60 && score < 70:
		fmt.Println("D")
	case score >= 70 && score < 80:
		fmt.Println("C")
	case score >= 80 && score < 90:
		fmt.Println("B")
	case score >= 90 && score < 100:
		fmt.Println("A")
	default:
		fmt.Println("Unknown")
	}

	//还有可以这样用switch
	count := 90
	switch count {
	case 60, 70, 80:
		fmt.Println("Ordinary")
	case 90:
		fmt.Println("Excellent")
	default:
		fmt.Println("Unknown")
	}
	
}



运行结果：






跳转链接：


下一篇：二、容器、go编程思想






















 原文地址:https://blog.csdn.net/Xx13624558575/article/details/130593241 


本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。


如若转载，请注明出处：http://www.7code.cn/show_33370.html 


如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！





	

		

            
                            
            			
		

		


            
			            
			                
                        
            
		

	




      

          

    

  






	

            	

            
                

                

                    上一篇
                    Golang 打包go项目部署到linux服务器
                

             
        

                    	

            
                

                    下一篇
                    go程序运行提示：package command-line-arguments is not a main package
                

                

            
        

            


    

        
相关文章

        

                      

              
          

                      

              
          

                      

              
          

                      

              
          

                      

              
          

                      

              
          

                      

              
          

                      

              
          

                  

    





    	

		
发表回复 
您的邮箱地址不会被公开。 必填项已用 * 标注
插入图片





 浏览器会保存昵称、邮箱和网站cookies信息，下次评论时使用。