Go语言入门基础

苡荏

已于 2022-12-26 21:53:04 修改

阅读量741

点赞数 2

文章标签： golang 开发语言后端

于 2022-12-19 16:25:50 首次发布

本文链接：https://blog.csdn.net/weixin_52117223/article/details/128075100

版权

Go语言入门

1. 基本结构
2. 关键字
3. 保留字
4. 变量
5. 常量
6. 基本数据类型
7. 字符串
8. 类型转换
9. IF语句
10. FOR语句
11. SWITCH语句
12. GOTO语句
13. 算术运算符
14. 关系运算符
15. 逻辑运算符
16. 位运算符
17. 赋值运算符

请添加图片描述

1. 基本结构

package main
import "fmt"
func main() {
	fmt.Println("Hello World")
	fmt.Println("Hello Go")
}

2. 关键字

	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

3. 保留字

    Constants:    true  false  iota  nil

    Types:    int  int8  int16  int32  int64  
              uint  uint8  uint16  uint32  uint64  uintptr
              float32  float64  complex128  complex64
              bool  byte  rune  string  error

    Functions:   make  len  cap  new  append  copy  close  delete
                 complex  real  imag
                 panic  recover

4. 变量

Go语言中的非全局变量声明后必须使用

var s1 string = "abcstring"
fmt.Println(s1)

全局变量

//变量声明
var s string

批量声明

//批量声明
var (
	age int
	name string
	status bool
)

类型推导

将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

短变量声明

短变量声明只能在函数中使用

//短变量声明 只能在函数中使用
num := 10
fmt.Println(num)

匿名变量

多重赋值下，如果要忽略某个值，可以使用匿名变量（anonymous variable）接收。用 _ 表示

5. 常量

定义后不能被修改，在定义的时候必须赋值

const pi = 3.14

在没有写值的情况下，默认同上一行

const (
	a = 3
	b = 4
	c	//没有写值 默认同上一行 4
)

iota

只能在常量的表达式中使用
在const关键字出现时被重置为0，const中每新增一行常量声明将使iota计数一次

const (
	i1 = iota	//0
	i2	//1
	_	//2
	i3	//3
)
const i4 = iota	//0

//插队
const (
	c1 = iota	//0
	c2 = 100	//100
	c3 = iota	//2
	c4			//3
)

//多个常量声明在一行
const (
	d1,d2 = iota+1,iota+2	// 1 2
	d3,d4 = iota+1,iota+2	// 2 3
)

//定义数量级
const (
	_ = iota
	KB = 1 << (10 * iota)
	MB = 1 << (10 * iota)
	GB = 1 << (10 * iota)
	TB = 1 << (10 * iota)
	PB = 1 << (10 * iota)
)

6. 基本数据类型

整型

uint8	无符号 8位整型  (0 到 255)
uint16	无符号 16位整型 (0 到 65535)
uint32	无符号 32位整型 (0 到 4294967295)
uint64	无符号 64位整型 (0 到 18446744073709551615)
int8	有符号 8位整型  (-128 到 127)
int16	有符号 16位整型 (-32768 到 32767)
int32	有符号 32位整型 (-2147483648 到 2147483647)
int64	有符号 64位整型 (-9223372036854775808 到 9223372036854775807)

特殊整型

uint	32位操作系统上就是uint32，64位操作系统上就是uint64
int		32位操作系统上就是int32，64位操作系统上就是int64
uintptr	无符号整型，用于存放一个指针

不同进制

var a int = 10	 //10进制
var b int = 074	 //8进制以0开头
var c int = 0xff //16进制以0x开头

浮点型

float32
float64

package main
import (
        "fmt"
        "math"
)
func main() {
        fmt.Printf("%f\n", math.Pi)
        fmt.Printf("%.2f\n", math.Pi)
}

复数

complex64的实部和虚部为32位
complex128的实部和虚部为64位。

var c1 complex64 = 1 + 2i
var c2 complex128
c2 = 1 + 3i
fmt.Println(c1)
fmt.Println(c2)

布尔值

默认为false
不允许将整型强制转换为布尔型.
无法参与数值运算，也无法与其他类型进行转换

7. 字符串

转义字符

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

Go语言中要定义一个多行字符串时，需要使用反引号字符

package main

import "fmt"

func main() {
	var s1 string = "Hello Go"
	fmt.Println(s1)
	fmt.Println("Hello Go")
	var s string = `
		Hello
		World
	`
	fmt.Println(s)
}

Hello Go
Hello Go

		Hello
		World
	

Process finished with exit code 0

常用操作

len(str)			求长度
+或fmt.Sprintf		拼接字符串
strings.Split		分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix		前缀/后缀判断
strings.Index(),strings.LastIndex()		子串出现的位置
strings.Join(a[]string, sep string)		join操作

package main

import (
	"fmt"
	"strings"
)

func main() {
	var s1 string = "Hello Go"
	var s2 string = "Hello World"
	fmt.Println(len(s1))	//打印字符串长度
	var s3 = s1 + s2	//字符串拼接
	s4 := fmt.Sprintf("123-%s", s1)	//字符串拼接
	fmt.Println(s4)
	fmt.Println(s3)
	fmt.Println(s1+s2)

	ret := strings.Split(s4,"-")
	fmt.Println(ret)
	fmt.Println(strings.Contains(s1,"Go"))	//包含
}

8
123-Hello Go
Hello GoHello World
Hello GoHello World
[123 Hello Go]
true

Process finished with exit code 0

字符

uint8类型，或者叫 byte 型，代表一个ASCII码字符。
rune类型，代表一个 UTF-8字符

8. 类型转换

T(表达式)

9. IF语句

if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

package main

import "fmt"

var age = 11

func main() {
	if age>18 {
		fmt.Println("成年")
	} else if age==18 {
		fmt.Println("18岁")
	} else {
		fmt.Println("未成年")
	}
}

func main() {
	if age:=18; age>18 {
		fmt.Println("成年")
	} else if age==18 {
		fmt.Println("18岁")
	} else {
		fmt.Println("未成年")
	}
}

10. FOR语句

基本写法

func main() {
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}

省略写法

func main() {
	i := 0
	for ; i < 10; i++ {
		fmt.Println(i)
	}
}

func main() {
	i := 0
	for i < 10 {
		fmt.Println(i)
		i++
	}
}

无限for循环

for循环可以通过break、goto、return、panic语句强制退出循环。

for {
    循环体语句
}

键值循环

Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。

数组、切片、字符串返回索引和值。
map返回键和值。
通道（channel）只返回通道内的值。

package main

import "fmt"

var s = "Hello"

func main() {
	for i,v := range s{
		fmt.Println(i,v)
	}
}

0 72
1 101
2 108
3 108
4 111

Process finished with exit code 0

11. SWITCH语句

一个switch只能有一个default分支。
一个分支可以有多个值，多个case值中间使用英文逗号分隔。
分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量。
fallthrough语法可以执行满足条件的case的下一个case。

func main() {
	f := 3
	switch f {
	case 1:
		fmt.Println("1")
	case 2:
		fmt.Println("2")
	case 3:
		fmt.Println("3")
	default:
		fmt.Println("ERROR")
	}
}

func main() {
	switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}
}

func switchDemo4() {
	age := 30
	switch {
	case age < 25:
		fmt.Println("age < 25")
		fallthrough
	case age > 60:
		fmt.Println("age > 60")
	default:
		fmt.Println("ERROR")
	}
}

12. GOTO语句

通过标签进行代码间的无条件跳转

func main() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
		}
	}
	return
breakTag:
	fmt.Println("结束循环")
}

13. 算术运算符

+	相加
-	相减
*	相乘
/	相除
%	求余

++（自增）和–（自减）在Go语言中是单独的语句，并不是运算符。

14. 关系运算符

==	检查两个值是否相等，如果相等返回 True 否则返回 False。
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

15. 逻辑运算符

&&	逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
||	逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
!	逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。

16. 位运算符

&	参与运算的两数各对应的二进位相与。
|	参与运算的两数各对应的二进位相或。
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。
<<	左移n位就是乘以2的n次方。“a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
>>	右移n位就是除以2的n次方。“a>>b”是把a的各二进位全部右移b位。

17. 赋值运算符

=	简单赋值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
<<=	左移后赋值
>>=	右移后赋值
&=	按位与后赋值
|=	按位或后赋值
^=	按位异或后赋值

请添加图片描述

苡荏

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫