GoLang 01变量常量定义、基本数据类型及相关操作

关键字

    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

保留字

    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

变量

• 由字母数字下划线组成，只能由字母和下划线开头

变量声明

• 基本格式为：var 变量名 变量类型，这是单变量声明的格式

var c int 
var b string

• 批量声明
• 不需要关注缩进，golang默认的会格式化代码，写出来的格式基本一致

var (
c int
b string
a bool
)

• 支持类型推导

var x1,x2=15,'s1'

• 简短变量声明，只能在函数内部声明

func main(){
	m := 10
}

• 匿名变量"_"用于占位，不会占用命名空间并且不会分配内存

常量

• 声明格式与变量声明格式基本一致
• const 常量名 = 值
• 常量定义中如果前一个常量进行了赋值，后一个没有进行，默认保证后一个常量等于前一个常量的值

const x=3  //单个变量声明

const (x1=5 //批量变量声明
x2=3
x3=5
)

• iota,是一个常量累计值，从0开始，每新增一行就加1，

const (
	x1 =iota //x1=iota=0
	x2     //x2=iota=1
	x3=2       //x3=iota=2
	x4       //x4=2,iota=3
	_        // iota=4
	x5       //x5=2,iota=5
	x6=iota  //x6=iota=6

)

const (
 	a,b= iota+1,iota+2 //iota=0,a=1,b=2
 	c,d						// iota=1,c=2,d=3
 	e,f						// iota-2,e=3,f=4
 	)

基本数据类型

• 整型、浮点型、布尔型、字符串
• 数组、切片、结构体、函数、map及通道

整型

• unit/int这个类型与操作系统有关

• 系统64位就unit64/int64,系统32位就是unit32/int32

• unit8,unit16,unit32,unit64

• int8,int16,int32,int64

• uniptr 无符号整型，用于存放指针

• 格式化输出：%b 二进制 %d 十进制 %o八进制 %x十六进制

• %s 字符串 %T 数据类型 %t 布尔值

package main

import "fmt"

func main() {
   const a =11
   var (
   	c bool
   	b = true
   	)
   fmt.Printf("二进制:%b\n 八进制:%o\n 十进制:%d\n 十六进制:%x\n",a,a,a,a)
   fmt.Printf("b:%t\n c:%t\n",b,c)
   fmt.Printf("格式\n a:%T\n b:%T\n c:%T\n",a,b,c)
}

浮点型

• float32，float64
• 有效位数，小数点后7位/15位

复数

• 实部+虚部
• complex64和complex128

布尔值

• true、false
• 整型无法强制转换为布尔值
• 默认位false

字符串

• 默认为UTF-8编码
• 使用双引号" "包裹而不是单引号，单引号’ '表示为字符
• 多行字符串,使用反引号，输出与输入一致都为多行

s3 := `x1
x2
x3`

字符串操作

var s1="ssss1"
var s2 ="s3456"
len(s1)

fmt.Println(s1+s2)

s3=fmt.sptintf("%s-%s",s1,s2)
fmt.Println(len(s3))

• strings.Split
• strings.Contains
• strings.HasPrefix
• strings.HasSuffix
• strings.Index
• strings.LastIndex
  
  
• strings.Join
  

转义符

符号	含义
\r	回车
\n	换行
\t	制表
’	单引号
"	双引号
\\	反斜杠

字符

• 组成字符串的单个元素，用单引号包裹
• byte–>uint8—>ASCII码
• rune—>int32的别名—>UTF-8

package main

import (
	"fmt"

)

// 遍历字符串
func main() {
	s := "hello沙河"
	for i := 0; i < len(s); i++ { //byte
		fmt.Printf("%v(%c) ", s[i], s[i])
	}
	fmt.Println()
	for _, r := range s { //rune
		fmt.Printf("%v(%c) ", r, r)
	}
	fmt.Println()
}

修改字符串

• 听的时候不知道什么情况漏掉了
  学习的博客

类型转换

• 听的时候不知道什么情况漏掉了
  学习的博客

运算符

https://www.liwenzhou.com/posts/Go/03_operators/

• 一些基础的运算

package main
import "fmt"


func main(){
	s1 :=2
	s2 :=10
	fmt.Println(s2/s1)	//+/-/*/%
	fmt.Println(s1==s2) //  <,<=,>,>=,!=
	fmt.Println(s1!=s2 && s1>s2)  //与
	fmt.Println(s1!=s2 || s1>s2) //或
	fmt.Println(!(s1!=s2))    //取反
	
	s1 += 10   // -=,*=,%=,/=
	fmt.Println(s1)

}

• 位运算
• &，|，^ 与，或，异或
• 写出对应的二进制数后方便计算
• 都为1才是1，有一个为1就是1，对应值不一样才是1
• <<,>> 左移与右移

package main
import "fmt"


func main(){
	s1 :=2   //0010  2的一次方
	s2 :=10  //1010  2的三次方+2的一次方
	fmt.Println(s1&s2)  //0010    2
	fmt.Println(s1|s2) //1010   10
	fmt.Println(s1^s2) //1000    8
	fmt.Println(s1<<5)  //1000000  2的六次方
	fmt.Println(s1>>5) //0   0
	fmt.Println(s1>>1) //0001 2的0次方

}

其他

• 由于要分心做其他的加上我学习的慢势必更新会比较慢
• 欢迎指正

参考链接

学习的博客
格式化输出
在线运行