变量的介绍 var
  • 定义变量
  • 给变量赋值
  • 使用变量
例题
package main
import "fmt"
func main(){
    //定义变量
    var i int
    //变量赋值
    i=5
    //使用变量
    fmt.Println("i=",i)
}//基本的入门案列
变量是用的注意事项

1>变量表示内存中的一个储存单位
2>该区域有自己的名称(变量名)还有自己的类型(数据类型)
3>golang变量使用方法:

//a>声明不赋值,会使用默认值
//b>类型推导   ex:
var number = 10 //默认推导number是int(整数型)
//c>忽略var ex:
str := “tom"//":="左边必须是没有定义的变量
多变量声明
var 变量名 数据类型var i int = 10
var n1,n2,n3 int
n1 = 10
n2 = 20
n3 = 30//先定义,再赋值
var n1,n2,n3 = 10,20,"tom"//第一种方法
n1,n2,n3 := 10,20.11,"jack"//第二种方法

3)全局变量的多个声明

var(
    n3 = 40
    n2 = 20.11
    n4 = "mary"
)//定义了三个变量,并且初始化了
该区域数据值同一类型
“+” 的使用

1)
左右两边是数值时间,为相加运算符
2)
左右两边是字符串,是连接运算符

变量的类型
基本类型派生类

整数类型 (int)

  • int表示的有符号型表示范围是 -2n~2(n-1)-1
  • uint表示的是无符号型表示范围是0~2^n-1
  • rune与int32一样(储存空间)但是rune表示的是一个Unlcode码
  • byte同样也可用于储存数字,与uint8(储存空间相同)既可以储存字符也可以储存数字(无符号0~2的8次方-1)

利用的小技巧

  • a>fmt。Printf( )可以勇于格式化输出
    unsafe包中的unsafe.sizeof(i)可以返回i的所占空间大小
    用%T可以可以得到数据的类型,代码表示如下
package main
import(  
    "fmt"
    "unsafe"
)
func main(){
    var i int = 10
    fmt.Printf("i 的数据类型是 %T ,i所占空间大小是 %d",
    i,unsafe.sizeof(i))
}
  • 包的多引用
import(
    "fmt"
    "unsafe"
)

浮点数

介绍:
用于存放小数:1.2 0.23 -1.96
分类:

单精度float324字节
双精度float648字节

浮点 =符号位 +指数位 + 尾数位

  • 尾数位假如过长会导致损失
    如var number float32 = -123.0000901
    格式化输出的是-123.000090尾数位损失了
    但是使用的数据类型假如是float64就不会造成数据损失
float使用细节
  1. Golang浮点型有固定的范围和字段长度,不受Os影响
  2. Golang浮点数据一般默认为float64
  3. 十进制表示:
  4. number1 := 5.123 numbers2 := .123//=>numbers2 ;= 0.123
  5. 12.3456e12=>12.3456*10^12
字符

Golang:

var c1 byte = 'a'
var c2 byte = '0'//字符的‘0’ 
//当我们用fmt.Print ln 来输出时候输出的是ASCII码

一般要需要用fmt.Printf()进行格式化输出
ex:

func min(){
    var(
    c1 = 'a'
    c2 = '0'
    fmt.Printf("c1 = %c  c2 = %c",c1,c2)
    )
}
//如此输出的就是c1c2本身
别与c++

var i int =‘北’//‘北’utf-8码是27211
格式化输出时,按字符输出时,输出的是北这一个字,但是用整数输出的时候输出的是utf-8码即是27211

func main(){
    var ch byte = '北'
    fmt.Printf("ch = %d",ch)//输出的是ch = 21271
    fmt.Printf("ch = %c",ch)//%c字符输出输出的是‘北’这个字符
}
  1. 如果我们保存的字符是ASCII码中的字符,则可以直接用byte储存
  2. 茹过大于ASCII码的最大(255)就像中文,可以用int或则是rune来保存字符
  3. 输出的方式是格式化输出
字符使用细节
  1. 字符用单引号使用’'例如:var ch byte = ‘a’
  2. Golang使用的是utf-8代码(utf-8包含了ASCII)英文使用一个字节,中文三个字节
  3. 字符可以进行计算运算utf-8码数字进行加减
  4. 数字->%c->字符 字符->%d->数字
  5. Golang统一用utf-8
bool 布尔类型

基本:

  • 布尔只能去true和false
  • golang不用0和1来代替true和false
  • bool只占用一个字节
字符串
func main(){
    var address string = "北京 100"
    fmt.Println(adress)
}
使用细节
  1. golang中的字符串不能改变
    (不能这样改变)
func main(){
    var str string = "i love golang"
    str[2] = 'a'//这种方法是错误的改变
}
//只能直接进行赋值改变 str ="  eihue"
  1. 双引号能够识别转义字符
  2. 反单引号以普通文本格式输出
  3. 字符串拼接用“+”号,过长换行时,“+”号要写在上一行的最后一个
  4. %v表示按照默认的值输出
基本数据类型的转换
  • 基本语法 :T(v)将v转换为T 类型
    T是数据类型,v是变量左右类型转换var n int64 = int64(变量)
  • 被转换的是变量储存数据,变量本身数据并没有发生变化
    例如:
func main(){
    var i int64 = 64
    var n int 8 = int8(i)
    //n被赋值了i转化为int8的数据类型,但是i本身还是int64的类型
}
基本类型和string类型的转换

(不是很了解)
有两种方法

  1. 使用的是fmt.Sprintf()函数
  2. 使用的是strconv这个包里面的函数进行转换
指针
  1. 基本数据类型,变量存的就是值,也叫值类型
  2. 获取变量的地址用符号“&”
  3. 指针储存的是一个地址,地址指向的才是一个值
  4. 命名方式:
var ptr *int = &变量
//ptr是一个指针变量名
//ptr指向的是int数据类型的指针
  1. 解密要使用 *ptr
    值类型:int . float . bool . string . struct . 数组
    值类型:指针 . slice 切片 . map . 管道chan . iterfance
标识符的命名规范
  • 对各种变量、方法、函数、等命名时要使用的字符序列叫做标识符
  • 凡是可以起名字的地方都叫标识符
    命名规则:
  1. 由26个英文字母(含大小写),下划线“-”,0~9组成
  2. 不能由数字开头(字母或者下划线开头)
  3. 不含有空格
  4. 不取用关键字(int,float等等)
注意事项
  • 包名尽量要和文件夹相同
  • 首字母大写(公开,可被其他的包访问)
    首字母小写(私有,只能在本包使用)
    引入包名:
    import “路径” //绝对或则相对路径
运算符

1> 算数 4> 逻辑
2> 赋值 5>位运算符
3> 比较 6>其他运算符

算数运算符

“- + / *”++(自加) --(自减)

“/”的运算:
  • 如果运算全为整数,那么相除后,去掉小数部分,保留整数部分
    • 10/4 = 2 、->10.0 / 4 = 2.5
  • 如果需要保留小数部分,则需要有浮点数参与运算,
“%”的使用

a % b = a - a /b * b

++与–细节说明
  1. golang中的自增自减只能够独立使用
    a = i++(这种方法是错误的)
  2. golang中“++”,与“–”只能用在数据后,不能放在数据前
    ex:++i或者–i都是错误的写法
  3. golang去除了c和c++中的前后加减,使得golang更加简洁
关系运算符
  1. 关系运算符的结果是bool型,要么是true要么是false
  2. 关系运算符一般用于if和for语句
    “==” “<” “<=”
    “!=” “>” “>=”
    案例:
func main(){
    var(
		n1 = 9
		n2 = 8
	)
	fmt.Println(n1==n2)//输出的是false
	fmt.Println(n1>n2)//输出的是true
	fmt.Println(n1>=n2)//输出的是true
	fmt.Println(n1<n2)//输出的是false
	fmt.Println(n1<=n2)//输出的是false
	fmt.Println(n1!=n2)//输出的是true
}   

注意点

  • "=="是判断
  • “="是赋值
逻辑运算符

“&&”与 “||”或 “!”非

  1. “&&”两边全是true才为true
  2. “||”两边全是false才是false
  3. “!”true-!>false,false-!>true
    案例:
func main(){
    var age int = 40
    if age > 30 && age < 50{
        fmt.Println("ok1")
    }
    if age >30 || age < 50{
        fmt.Println("ok2")
    }//条件判断为false,不会输出ok2
}
//在golang中if后不加()
注意事项和细节说明

“&&”“||”又叫做”短路与“和“短路或”
短路与:指的是前面第一个条件为false不判断后面的(直接判断为false)
短路或:指的是前面第一个判断为true不判断后面的(直接判断为true)

赋值运算符

“=” “+=” “-=” “/=” “*=” “%=”
将某个运算后的值符给变量

  1. 交换两个变量,需要使用临时变量(也可以使用)
  2. 赋值运算符,从左往右
  3. 赋值运算符左边为变量,右边可以为变量也可以为数值和表达式
  4. 表达式:任何有值得式子
    运算符优先级:
  • 只有单目运算符和赋值运算符是从左往右运算的
  • 大致顺序:
    1>括号、++、–
    2>单目 3>算数 4>移位 5>关系
    6>位运算符 7>逻辑 8>赋值 9>逗号