go基础

// 包声明
// 引入包
// 函数
// 变量
// 语句&表达式
// 注释

// go 标记   关键字 标识符 常量 字符串 符号
// 行分隔符 一行代表一个语句结束 如果多个语句一行需要；分隔，不建议
// 注释  //单行  /*  */ 多行
// 标识符  用来命名变量，类型等程序实体，第一个是字母或者下划线 ，不可以用数字开头
// 字符串连接  +  "ddd"+"dddd"
// 关键字 
// 变量声明用空格分隔

// 布尔型 var b bool = true
// 数字 int float
// 字符串
// 派生类型 包括 ：指针，数组，结构化，联合体，函数，切片，接口，map，channel

// 变量
// 声明变量用 var 关键字  
// 第一种  var name type   声明不赋值 ，使用 默认值
// 第二种  var name="" 自行判定变量类型
// 第三种  c:=1    省略var
// 示例
/*
package main
var a = "w3cschoolW3Cschool教程"
var b string = "w3cschool.cn"
var c bool

func main(){
    println(a, b, c)
}
*/

// 多变量声明
// var name1 name2 = v1,v2
// vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误
//类型不同多个变量, 全局变量, 局部变量不能使用这种方式
// var (
//     vname1 v_type1
//     vname2 v_type2
// )

// package main 
// var x, y int =1, 2
// func main(){
//     print(x, y)
// }

// 赋值
// var a  int =20 在声明一次变量之后，如果给相同的变量赋新的值，则使用 a=15

// 注意事项：
// 在go中，如果声明了变量却没有引用，则会抛出错误 ，但是在全局变量中允许声明但不使用


// 常量是一个简单值的标识符，在程序运行时，不会被修改的量
// 常量：布尔型，数字，字符串
// 定义格式： const a =2
// const (
//     a=1
//     b=2
//     c=3
// )
// 常量表达式中，函数必须是内置函数，否则编译不过：
// import "unsafe"
// const (
//     a = "abc"
//     b = len(a)
//     c = unsafe.Sizeof(a)
// )


// iota 特殊常量，认为是一个被编译器修改的常量
// 在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。
// iota 可以被用作枚举值：
// const (
//     a = iota
//     b = iota
//     c = iota
// )
// 第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：
// const (
//     a = iota
//     b
//     c
// )


// 语言运算符

// 算数运算  逻辑运算 关系运算 位运算 （转为二进制运算）   赋值运算
// package main

// func main(){
//     var a int = 2
//     // a>>=2

//     print(a)
// }


// 条件语句
// if else else if  switch select 

// 循环语句 for break continue goto (理解)


// 函数
// package main
// func main() {
//    /* 定义局部变量 */
//    var a int = 100
//    var b int = 200
//    var ret int

//    /* 调用函数并返回最大值 */
//    ret = max(a, b)

//    print( "最大值是 : ", ret )
// }

// func max(num1, num2 int) int{
//     /* 声明局部变量 */
//     var result int
 
//     if (num1 > num2) {
//        result = num1
//     } else {
//        result = num2
//     }
//     return result 
//  }


// 闭包
// package main

// import "fmt"

// func getSequence() func() int {
//    i:=0
//    return func() int {
//       i+=1
//      return i  
//    }
// }

// func main(){
//    /* nextNumber 为一个函数，函数 i 为 0 */
//    nextNumber := getSequence()  

//    /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
//    fmt.Println(nextNumber())
//    fmt.Println(nextNumber())
//    fmt.Println(nextNumber())
   
//    /* 创建新的函数 nextNumber1，并查看结果 */
//    nextNumber1 := getSequence()  
//    fmt.Println(nextNumber1())
//    fmt.Println(nextNumber1())
// }


// 变量作用域

// 数组
// 声明数组  var balance [5] float32 
// var balance=[3]float32{1.0,2.0,3.0}
// var balance=[]float{1.0}


// 指针
// 一个指针变量可以指向任意一个值的内存地址它指向那个值的内存地址
// 声明指针
// var a *int *号用于指定变量是作为一个指针
// 空指针 nil 代表零值或者空值 var ptr *int  一个指针变量通常缩写为ptr


// 结构体
// 在结构体中可以为不同项定义不同的数据类型，结构体是由一系列具有相同类型或者不同类型的数据构成的数据集合
// 定义结构体：定义结构体需要type和struct语句，strucr语句定义一个新的数据类型，结构体中有一个或多个成员，格式如下：
// type struct_variable_type struct{
//     member definition
// }
// 定义结构体类型，声明变量：variable_name:=struct_variable_type(value)
// 访问结构体成员：使用 （.）操作符。格式为：“结构体.成员名”

// 切片
// Go 语言切片是对数组的抽象。
// Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),\
// 与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

// slice,range,map 

// 类型转换
// 一种数据类型的变量转换成另一种类型的变量：type_name(expression)


//接口
// Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口

// 错误处理
package main

func main() {
    print("hello")
    
}