golang入门笔记—变量声明

go语言的执行命令：

go run
像执行脚本文件一样执行Go代码

go install
go install分为两步：
//1.先编译得到一个可执行文件
//2.将可执行文件拷贝到 GO环境变量的bin目录

go build
//编译生成exe文件
./**.exe
//执行exe文件

交叉编译：
Go支持跨平台编译
例如：在windows平台编译一个能在linux平台执行的可执行文件

SET CGO_ENABLED=0 //禁用CGO
SET GOOS=linux   //目标平台是linux
SET GOARCH=am64  //目标处理架构是am64

变量声明：

//可变变量声明
var name string
var age int
var isOk bool

var{
    name string
    age int
    isOk bool
}
//全局变量声明后可以不使用
//批量声明
//变量初始值为空值

func main(){
name="理想"
age=16
isOk=true
//Go语言中变量声明必须使用，不使用就编译不过去

fmt.Print(isOk)     //在终端中输出要打印的内容
fmt.Printf("name:%s",name) //%s：占位符 使用name这个变量去替换占位符
fmt.Println(age)    //打印完换行

var s1 string ="zyj"
fmt.Println(s1)
//声明变量时同时赋值
var s2="20"
//类型推导，根据值判断类型
s3:="hahaha"
//:=是简短变量声明（只能在函数内部声明	） 
s4:=`  asd a
  sadad
`//s4完全复制``里面的内容
}

func foo()(int, string){
   return 10,"QImi"
}
func main(){
   x,_:=foo()
   _,y:=foo()
   fmt.Println("x=",x)
   fmt.Println("y=",y)
   //匿名变量，当使用多重赋值时，如果想要忽略某个值，可以使用匿名变量(anonymous variable)。匿名变量是用一个下划线_表示。匿名变量不占用命名空间，不会分配内存，所以匿名变量不存在重复声明。
}

常量：

const pi=3.1415926

const{
   statusOK = 200
   notFound = 404
}
//常量定义之后不能修改

const{
   n1=100
   n2
   n3
}
//批量声明变量如果后边没给赋值，则跟前面变量的值相同

const{
   n1 = iota  //n1=0
   n2         //n2=1
   n3         //n3=2
}
//iota在const出现时重置为0。之后每次引用iota时都会加一
const{
   b1=inta  //在此const声明时，iota跟上面的const中的iota没关系，所以词iota      等于0
   b2      // 1
   _      
   b3      // 3
}
const{
   c1 = inta //0
   c2=100    //100
   c3        //100
   c4=inta   //1
}
const{
   d1, d2 = iota+1,iota+2 //d1:1 d2:2
   d3, d4 = iota+1,iota+2//d3=3,d4=4
   //新增一行时，iota才会加1
const{
   _=iota
   KB=1<<(10*iota)
   MB=1<<(10*iota)
   GB=1<<(10*iota)
   TB=1<<(10*iota)
   PB=1<<(10*iota)
}
}

Go语言无法直接定义二进制数，关于八进制和十六进制的示例如下：

package main

import "fmt"

func main(){
var a int = 10
fmt.Printf("%d\n",a)
fmt.Printf("%b\n",a) //二进制形式输出

var b int =077
fmt.Printf("%o\n",b) 
//八进制定义以0开头，输出为%o

var c int = 0xff
fmt.Printf("%x\n",c) //ff
fmt.Printf("%X\n",c) //FF

fmt.Printf("%T\n",c) //打印数据类型
}

f1:=1.23456
fmt.Printf("%T\n",f1)
f2:=float32(1.23456)
fmt.Printf("%T\n",f2)
//将64位的float转化为32位
//%t输出bool型，%#d，输出更详细

//布尔值：
//1.布尔变量的默认值位false
//2.Go语言中不允许将整型强制转换为布尔型
//3.布尔型无法参与数值运算，也无法与其他类型进行转换

func main(){
 b1:=true
 var b2 bool
 fmt.Printf("%T\n",b1)
 fmt.Printf("%T value:%v\n",b1,b2)
}

//字符串
//Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int，float32，bool等）一样，Go语言里的字符串的内部实现UTF-8编码，字符串的值为“”中的内容，可以在Go语言的源码中直接添加非ASCII码字符（比如中文）

s:="Hello 沙河"
//单独的字母、汉字、符号表示一个字符
c1:='h'
c2:='1'
c3:='沙'
//字节：1字节=8Bit（8个二进制位）
//1个字符'A'=1个字节
//1个utf8编码的汉字‘沙’=一般占3个字节

func main(){
 path:="'D:\Go\studygo'"
 // \表示转义字符，说明后边的字符为字符串，不是特殊字符

 a := "理想"
 b := "狗屁"
 s := fmt.Sprintf("%s%s", a, b)
 fmt.Println("%s%s",a,b)
 //Sprintf不打印，而是返回一个字符变量
 
s = "我 来自 地球"
ret:=string.Split(s,' ')//用空格来分割字符串 

is_contain=strings.Contains(s,"来自") //is_contain值为true
//Contains函数判断是否包含

index = strings.Index(s,"我") //index值为0
//查找子串的位置
}

//字符串修改
s2 :="白萝卜"
s3 :=[]rune(s2)         //将白萝卜分割成单个汉字的utf-8的码后用列表存储，内容是数字
s3[0]='红'              //把rune切片中第一个元素改为红，注意用单引号
fmt.Println(string（s3）)//把rune切片强制转化为字符串

c1:="H"
c2:='h'
fmt.Printf("c1:%T c2:%T",c1,c2)
//c1是string型，c2是int32类型

//判断回文串
func is_revolve(){
ss:="山西运煤车煤运西山"
r:=make([]rune,len(ss))
for _,c:=range ss{
r =append(r,c)
}
for i:=0;i<len(r)/2;i++{
  if(ss[i]!=ss[len(ss)-1-i]){
  fmt.Println("不是回文")
  return 
  }
}
fmt.Println("是回文串")
}