菜鸟教程------Golang学习笔记
<的语⾔结构
基础组成部分有：包声明、引⼊包、函数、变量、语句&表达式、注释
eg.
package main
import"fmt"
func main(){
//⼀个简单程序
fmt.Println("Hello, World!")
}
<中的标识符
标识符⽤来命名变量、类型等程序实体。⼀个标识符实际上就是⼀个或是多个字母(A z)数字(0~9)、下划线_组成的序列，但是第⼀个字
Z和a
符必须是字母或下划线⽽不能是数字
*以下是有效的标识符：
mahesh kumar abc move_name a_123
myname50 _temp j a23b9 retVal
*以下是⽆效的标识符：
1ab（以数字开头）
case（Go 语⾔的关键字）
a+b（运算符是不允许的）
2.1 go中标识符⼤⼩写的区分
当标识符（包括常量、变量、类型、函数名、结构字段等等）以⼀个⼤写字母开头，如：Group1，那么使⽤这种形式的标识符的对象就可以被外部包的代码所使⽤（客户端程序需要先导⼊这个包），这被称为导出（像⾯向对象语⾔中的 public）；
标识符如果以⼩写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可⽤的（像⾯向对象语⾔中的 protected ）3.go中各标识符的声明
// 当前程序的包名
package main
// 导⼊其他包
import."fmt"
// 常量定义
const PI =3.14//常量标识符常量名  =  值
// 全局变量的声明和赋值
var name ="gopher"//变量标识符变量名  =  值
// ⼀般类型声明
type newType int
// 结构的声明
type gopher struct{}
// 接⼝的声明
type golang interface{}
// 由main函数作为程序⼊⼝点启动
func main(){
Println("Hello World!")
}
在 Go 编程语⾔中，数据类型⽤于声明函数和变量，数据类型的出现是为了把数据分成所需内存⼤⼩不同的数据，⼤数据分配⼤内存，⼩数据分配⼩内存
1 布尔类型 true false 例：var a bool = true
2 数组类型
2.1整型 int
1）uint8 ⽆符号 8 位整型 (0 到 255)
2）uint16 ⽆符号 16 位整型 (0 到 65535)
3）uint32 ⽆符号 32 位整型 (0 到 4294967295)
4）uint64 ⽆符号 64 位整型 (0 到 18446744073709551615)
5）int8 有符号 8 位整型 (-128 到 127)
6）int16 有符号 16 位整型 (-32768 到 32767)
7）int32 有符号 32 位整型 (-2147483648 到 2147483647)
8）int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
2.2浮点型 float
1）float32 32位浮点型数
2）float64 64位浮点型数
3）complex64 32位实数和虚数
菜鸟教程python面向对象
4）complex128 64位实数和虚数
2.3其他数字类型
1）byte 类似 uint8
2）rune 类似 int32
3）uint 32 或 64 位
4）int 与 uint ⼀样⼤⼩
5）uintptr ⽆符号整型，⽤于存放⼀个指针
3.字符串类型
字符串就是⼀串固定长度的字符连接起来的字符序列，使⽤ + 连接
4.派⽣类型
● (a) 指针类型（Pointer）● (b) 数组类型● © 结构化类型(struct)● (e) 函数类型● (f) 切⽚类型（slice）● (g) 接⼝类型（interface）● (h) Map 类型（集合）
<中数值类型的声明⽅式
全局变量声明（有类型的声明），忽略类型的声明（系统⾃动识别数值类型），简短声明（ := ）,⼀般声明（形式与第⼀种相同），赋值操作
//⽰例代码
var isActive bool// 全局变量声明
var enabled, disabled =true,false// 忽略类型的声明
func test(){    valid :=false// 简短声明（使⽤变量的⾸选形式，但是它只能被⽤在函数体内，⽽不可以⽤于全局变量的声明与赋值。使⽤操作符 := 可以⾼效地创建⼀个新的变量，称之为初始化声明）
var available bool// ⼀般声明
available =true// 赋值操作}
Go 语⾔变量名由字母、数字、下划线组成，其中⾸个字符不能为数字，声明变量的⼀般形式是使⽤ var 关键字
var xxxname（变量名）type
//可以⼀次声明多个变量：
var iden1, iden2 type
常量是指在程序运⾏时，不会被修改的量，它是⼀个简单值的标识符。常量中的数据类型只能是布尔型、数字型（整数型、浮点型和复数）和字符串型
1. 常量的定义格式 const 名字 type = value
可以省略类型说明符 type ，因为编译器可以根据变量的值来推断其类型。
*显式类型定义： const b string = “abc”
*隐式类型定义： const b = “abc”
多个相同类型的声明可以简写为： const c_name1, c_name2 = value1, value2
多重赋值 const a, b, c = 1, false, “str”
2. 在定义常量组时，如果不提供初始值，则表⽰将使⽤上⾏的表达式，使⽤上⾏已经初始化的表达式的值
package mainimport "fmt"const(    a =1    b    c    d)
func main(){
fmt.Println(a)// b、c、d没有初始化，使⽤上⼀⾏(即a)的值
fmt.Println(b)// 输出1
fmt.Println(c)// 输出1
fmt.Println(d)// 输出1
}
3.iota：特殊常量，可以认为是⼀个可以被编译器修改的常量
iota 只是在同⼀个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始
package main
const(    i =iota    j =iota    x =iota)
const xx =iota//新的const关键字出现，iota重新从0开始
const yy =iota//新的const关键字出现，iota重新从0开始
func main(){
println(i, j, x, xx, yy)
}
// 输出是 0 1 2 0 0
运算符⽤于在程序运⾏时执⾏数学或逻辑运算，Go 语⾔内置的运算符有：
算术运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 其他运算符
1.算术运算符
相加 +    相减  -  相乘 *    相除  /
⾃加 ++        ⾃减  --      求余  %
2.关系运算符
== 检查两个值是否相等
!= 检查两个值是否不相等
> 检查左边值是否⼤于右边值
< 检查左边值是否⼤于右边值
>= 检查左边值是否⼤于等于右边值
<= 检查左边值是否⼩于等于右边值
3.逻辑运算符（返回值为布尔值）
&& 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False
|| 逻辑 OR 运算符。 如果两边的操作数有⼀个 True，则条件 True，否则为 False
! 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True
4.位运算符（位运算符对整数在内存中的⼆进制位进⾏操作，即整数转换为⼆进制再操作）
& 按位与，双⽬运算符（要求两个数值参加运算），参与运算的两数各对应的⼆进位相与（相乘）
| 按位或，参与运算的两数各对应的⼆进位相或（相加）
^ 按位异或，运算的两数不同时为true，相同时为false
<< 左移运算符，左移n位就是乘以2的n次⽅
>> 右移运算符，右移n位就是除以2的n次⽅
5.赋值运算符
= 简单的赋值运算符，将⼀个表达式的值赋给⼀个左边的值
+= 相加后再赋值
-= 相减后再赋值
*= 相乘后再赋值
/= 相除后再赋值
<<= 左移后赋值
>>= 右移后赋值
&= 按位与后赋值
^= 按位异或后赋值
|= 按位或后赋值
%= 求余后再赋值
6.其他运算符
& 返回变量存储地址
&a; 将给出变量的实际地址
* 指针变量
*a; 是⼀个指针变量
*指针变量 * 和地址值 & 的区别：指针变量保存的是⼀个地址值，会分配独⽴的内存来存储⼀个整型数字。 当变量前⾯是 * 标识时，且赋给的新变量输出时也是 * 标识时，指向的才是地址中存放的变量值； 变量前⾯是 & 标识，且赋给的新变量输出时没有 * 或 &标识，指向的是地址值
eg.
func main(){
var a int=4
var ptr *int
ptr =&a  println("a的值为", a)// 4
println("*ptr为",*ptr)// 4
println("ptr为", ptr)// 824633794744
}
条件语句需要开发者通过指定⼀个或多个条件，并通过测试条件是否为 true 来决定是否执⾏指定语句，并在条件为 false 的情况在执⾏另外的语句。Go 语⾔提供了以下⼏种条件判断语句：
if 语句 : if 语句 由⼀个布尔表达式后紧跟⼀个或多个语句组成
if…else 语句 : if 语句 后可以使⽤可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执⾏ if 布尔表达式 { /* 在布尔表达式为true 时执⾏ / } else { / 在布尔表达式为 false 时执⾏ */ }
Go 的 if 还有⼀个强⼤的地⽅就是条件判断语句⾥⾯允许声明⼀个变量，这个变量的作⽤域只能在该条件逻辑块内，其他地⽅不起作⽤，
if 还有另外⼀种形式，它包含⼀个 statement 可选语句部分，该组件在条件判断之前运⾏
if嵌套语句 ：可以在 if 或 else if 语句中嵌⼊⼀个或多个 if 或 else if 语句
if 布尔表达式 1 {
/* 在布尔表达式 1 为 true 时执⾏ /
if 布尔表达式 2 {
/
在布尔表达式 2 为 true 时执⾏ */
}
}
switch 语句: ⽤于基于不同条件执⾏不同动作，每⼀个 case 分⽀都是唯⼀的，从上⾄下逐⼀测试，直到匹配为⽌， case 最后⾃带 break 语句，匹配成功后就不会执⾏其他 case，如果需要执⾏后⾯的 case，可以使⽤ fallthrough强制执⾏，也可以使⽤break 。同时测试多个可能符合条件的值，使⽤逗号分割，
使⽤ fallthrough 会强制执⾏后⾯的 case 语句，fallthrough 不会判断下⼀条 case 的表达式结果是否为 true
1. for循环（for 循环是⼀个循环控制结构，可以执⾏指定次数的循环）
for语句执⾏过程如下：
1、先对表达式 1 赋初值；
2、判别赋值表达式 init 是否满⾜给定条件，若其值为真，满⾜循环条件，则执⾏循环体内语句，然后执⾏ post，进⼊第⼆次循环，再判别 condition；否则判断 condition 的值为假，不满⾜条件，就终⽌for循环，执⾏循环体外语句
2.嵌套循环 （在循环内使⽤循环）
3.循环控制语句（循环控制语句可以控制循环体内语句的执⾏过程）
GO 语⾔⽀持以下⼏种循环控制语句：
3.1 break语句
3.2 continue语句
跳过当前循环的剩余语句，然后继续进⾏下⼀轮循环
3.3 goto语句
将控制转移到被标记的语句，通常与条件语句配合使⽤，⽤来实现条件转移， 构成循环，跳出循环体等功能。但是，在结构化程序设计中⼀般不主张使⽤ goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产⽣困难
3.4 ⽆限循环
如果循环中条件语句永远不为 false 则会进⾏⽆限循环，可以通过 for 循环语句中只设置⼀个条件表达式来执⾏⽆限循环
11.函数
1.函数定义
函数是基本的代码块，⽤于执⾏⼀个任务，Go 语⾔最少有个 main() 函数。可以通过函数来划分不同功能，执⾏指定的任务
函数格式如下：
func 函数名 （参数列表 参数类型） 返回值{
函数体
}
参数列表指定的是参数类型、顺序、及参数个数，参数是可选的，函数也可以不包含参数
2.函数调⽤
当创建函数时，定义了函数的功能，则通过调⽤该函数来执⾏指定任务，调⽤函数，向函数传递参数，并返回值
eg.

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。