golang 初识

package main  //非注释区的一个行要引入一个包，这个包的名字必须要是 main

import "fmt"
import "unsafe"



func main(){
  // 这是我的第一个 go 程序
  fmt.Println("This is my first Go programma");
  // myFunc1()  //变量
  // myFunc2()  //常量
  // myFunc3() //运算符
  funcTest()  //函数
}

// 函数
funcTest(){

}
//返回最大值
func max(a,b int) int{

}

// 运算符
func myFunc3(){
  // go 语言中的其它运算符： &(给出变量的实际地址) / *(是一个指针变量)
  var a = 10
  var b int32 = 20
  var c float32
  var d *int
  fmt.Printf("a 的类型为：%T\n",a); //int
  fmt.Printf("a 的类型为：%T\n",b); //int32
  fmt.Printf("a 的类型为：%T\n",c); //float32
  fmt.Printf("a 的类型为：%T\n",d); //*int
  d = &a
  fmt.Println("a 的地址：",d) //0xc04200e0b0 (受多种因素影响)
  fmt.Printf("a 的值为：%d\n",a)  //10
  fmt.Printf("d 地址存储的值为：%d",*d) //10
}


// 变量
var a = 4
var b int = 6
//定义的全部变量，不在在函数外修改它的值：
// syntax error: non-declaration statement outside function body
// a = 444
var c bool
var j,k = "jjj","kkk"
var p,q = 30,"qqq"

func myFunc1(){
  // 这种不带声明格式的只能在函数体中
  d := 777
  a = 444
  //如果在函数内只定义不使用，会报编译错误：y declared and not used
  // y := "fafafa"
  
  fmt.Print(a,b,c,d,"\n") //444 6 false 777
  fmt.Print(p,q,j,k,"\n") //30 qqq jjj kkk
  fmt.Println("j 的值：",j," ; k 的值：",k) //jjj kkk
  
  // 交换两个数的值
  j,k = k,j
  fmt.Println("j 的值：",j," ; k 的值：",k) //kkk jjj
}

// 常量
func myFunc2(){
  // 常量的使用
  const conA = "aaa"
  const conB = "bbb"
  const conC,conD = 888,"ddd"
  // cannot assign to conA
  // conA = "AAA"
  fmt.Println("conA：", unsafe.Sizeof(conA)); //conA： 16 
  //conA： 16 （第一个域是指向该字符串的指针，第二个域是字符串的长度，每个域占8个字节，但是并不包含指针指向的字符串的内容，这也就是为什么sizeof始终返回的是16）
  /*
   * 一、如果 x 为一个切片，sizeof 返回的大小是切片的描述符大小（24），而不是切片所指向的内存的大小。
   * 二、如果 x 是一个数组，（sizeof 总是在编译期就进行求值，而不是在运行时，这意味着 sizeof 的返回值可以赋值给常量）sizeof 在编译期求值，意味着可以获得数组所占的内存大小，因为数组总是在编译期就指明自己的容量，并且在以后都是不可变的。
   * 三、如果 x 是一个字符串，不论字符串的 len 有多大，sizeof 始终返回 16；这是因为字符串类型对应一个结构体，该结构体有两个域，第一个域是指向该字符串的指针，第二个域是字符串的长度，每个域都占 8 个字节，但是并不包含指针指向的字符串的内容。
  */
  fmt.Println(conA,conB,conC,conD)  //aaa bbb 888 ddd

  //枚举（iota 是特殊的常量，在每一个关键字 const 出现时，都会被置为0，然后在下一个 const 出现之前，每出现一个 iota，其值会自动增加 1）
  const (
    it0 = iota  //0
    it1 = iota  //1
    it2 = iota  //2
  )
  const it3 = iota //0
  fmt.Println("iota 测试：", it0, it1, it2, it3);

  const (
    i0 = iota //0
    i1        //1
    i2        //2
  )
  fmt.Println("枚举测试 i0,i1,i2：",i0,i1,i2);

  const (
    aa1 = iota  //0
    aa2         //1
    aa3         //2
    aa4 = "hei" //hei
    aa5         //hei
    aa6 = 100   //100
    aa7         //100
    aa8 = iota  //7
    aa9         //8
  )
  //发现一个有趣的现象：枚举时，如果没有给变量赋值，默认会将前面的值赋值给该变量，并且 iota 都会在之前的基础上每次递增 1，即使其它表达式中没有出现 iota
  fmt.Println("aax：",aa1,aa2,aa3,aa4,aa5,aa6,aa7,aa8,aa9);

  // 再看一个有趣的现象
  const (
    i = 1 << iota
    j = 3 << iota
    k
    l
  )
  fmt.Println("i j k l：",i,j,k,l)  //1 6 12 24
}