GO语言学习（持续更新）

置顶彼岸吖

已于 2022-04-02 17:50:47 修改

阅读量499

点赞数

分类专栏： golong 文章标签： golang go

于 2022-04-02 17:50:28 首次发布

本文链接：https://blog.csdn.net/weixin_57837701/article/details/123925629

版权

golong 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

变量区域的数据值可以在同一类型范围内不断变化，变量在同一个作用域内不能重名

输出Hello world

package main
import "fmt"

func main() {
  fmt.Println ("hello world")
}

认识变量

package main
import "fmt"

func main(){
  //定义变量/声明变量
  var i int
  //给i赋值
  i = 10
  //使用变量
   fmt.Println("i=", i)
}

变量的三种方式

package main
import "fmt"

func main () {
  //第一种方式. int的默认值是0。指定变量类型，声明后若不赋值，使用默认值
  var i int
  fmt.Println("i=", i)

   //第二种方式根据值自行判定变量类型（类型推倒）
   var num = 10.22
   fmt.Println("num=", num)

   //第三种方式省略var，注意 := 左侧的变量不应该是已经声明过的，否则会导致编译错误
   //下面的方式等价于 var name      = "tom"
   name := "tom"
   fmt.Println("name=", name)
}

输出结果：

go run bianlaing.go
i= 0
num= 10.22
name= tom

多变量声明

package main
import "fmt"
func main () {

//该案例演示golong如何一次性声明多个变量
var n1, n2, n3 int
fmt.Println("n1=", n1,"n2=", n2,"n3=", n3)

//一次性声明多个变量方式2
var n4, n5, n6 = 11 , 22 , "qwe"
fmt.Println("n4=",n4, "n5=",n5, "n6=",n6)

//一次性使用变量方式3
n7, n8, n9 := 121, 131, "qwsa"
fmt.Println("n7=",n7,"n8=",n8,"n9",n9)
}

输出结果：

go run bianlaing.go
n1= 0 n2= 0 n3= 0
n4= 11 n5= 22 n6= qwe
n7= 121 n8= 131 n9 qwsa

全局变量

package main
import "fmt"
  var n1 =100
  var n2 =200
  var n3 ="sad"
func main () {

  fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)
}

或者这样子写

package main
import "fmt"
var (   
        n1 = 100
        n2 = 200
        n3 = "sad"
)
func main() {
        fmt.Println("n1=", n1, "n2=", n2, "n3=", n3)
}

输出结果：

go run bianlaing.go
n1= 100 n2= 200 n3= sad

变量区域的数据值可以在同一类型范围内不断变化，变量在同一个作用域内不能重名

package main

import "fmt"

func main() {

        var i int = 10
        i = 20
        i = 40
        fmt.Println("i=", i)
}

输出结果：

go run bianlaing.go
i= 40

符号

+（数字运算）

package main

import "fmt"

func main() {
        var (
        i = 1
        a = 2
        j = i + a
)
        fmt.Println("j=", j)
}

输出结果：

go run fuhao.go
j= 3

单词拼接

package main
import "fmt"

func main() {
        var (
        i = "hello"
        a = "wolld"
        j = i + a
)
        fmt.Println("j=", j)
}

输出结果：

go run fuhao.go
j= hellowolld

整数类型

例一

package main
import "fmt"

func main(){
  var i int = 1
  fmt.Println("i=",i)

  //测试一下int8的范围 -128～127，
  //其它的 int16，int32，int64，类推
  var j int8 = 127
  fmt.Println("j=",j)

  //测试一下 unit8的范围（0-255），qi它的unit16，unit32，unit64类推即可
  var a int16 = 255
  fmt.Println("a=",a)

  //int,unit,rune,byte的使用
  var b int =9000
  var c uint = 1
  var d byte = 255
  fmt.Println("b=",b)
  fmt.Println("c=",c)
  fmt.Println("d=",d)
}

输出结果：

go run zhengshu.go
i= 1
j= 127
a= 255
b= 9000
c= 1
d= 255

例二

package main
import "fmt"
import "unsafe"

//另外一种引包的方式
//import （
//    "fmt"
//    "unsafe"
//  ）

func main() {
  //整数类型的使用细节
  //这里介绍一下如何查看某个变量的数据类型
  //fmt.Printf()可以用于做格式化输出
  var i = 1002
  fmt.Printf("i 的类型%T\n", i)

  //如何使用程序查看某个变量占用的字节大小和数据类型
   //unsafe.Sizeof(s) 是unsafe包的一个函数，可以返回s变量占用的字节数
  var s int64 =10850
  fmt.Printf("s的数据类型%T,占用的字节数是%d\n",s,unsafe.Sizeof(s))
}

输出结果：

go run zhengshu.go
i 的类型int
s的数据类型int64,占用的字节数是8
浮点数类型

例三

package main
import (
  "fmt"
)

func main(){
var q float32 = -122.1131454       //尾数部分可能丢失造成精度损失
var w float64 = -122.1131454       //golong的默认浮点型默认float64
var e = 5.331        //十进制数形式 5.331  .5331(必需有小数点)
var r = .5331        // =》0.5331
var a = 5.1234e2     //5.1234 * 10的2次方
var s = 5.1234E2     //大小写e相同效果
var d = 5.1234E-2    //5.1234 * 10的-2次方
fmt.Println("q=",q,"w=",w,"e=",e,"r=",r,"a=",a,"s=",s,"d=",d)
}

输出结果：

go run fudianshu.go
q= -122.113144 w= -122.1131454 e= 5.331 r= 0.5331 a= 512.34 s= 512.34 d= 0.051234

字符类型

（1）如果字符在ASCII表中，如【0-1，a-z，A-Z..】可以直接保存到byte
（2）如果字符对应的码值大于255，可以使用 int uint
（3）如果需要按照字符的方式输出，则需要格式化输出，即fmt.Printf("%c",a1)

package main
import "fmt"

func main(){

  var i byte = 'a'
  var a byte = '0'
  //直接输出byte值，就是输出了对应的字符的码值
  fmt.Println("i=",i)
  fmt.Println("a=",a)

  //如果要输出对应字符，需要使用格式化输出
  fmt.Printf("i=%c a=%c\n",i,a)

  // var s byte = '阿' overflow溢出
  var s int = '阿'
  fmt.Printf("s=%c s对应码值=%d",s,s)

  //可以给某一个变量赋一个数字，然后按格式化输出时%c，会输出数字对应的unicode字>符
  var w int = 12214
  fmt.Printf("w=%c\n",w)

  //字符类型是可以进行运算的，相当于一个整数，运算时按照码值运行
  var num = 10 + 'a'  //a的码值是97
  fmt.Println("num",num)
}

输出结果：

go run zifu.go
i= 97
a= 48
i=a a=0
s=阿 s对应码值=38463
w=⾶
num 107

布尔类型

布尔类型只能取true 或 false

package main

import "fmt"
import "unsafe"

func main() {
  var a = false
  fmt.Println("a=", a)
  fmt.Println("a字节=", unsafe.Sizeof(a))
}

输出结果：

go run bool.go  
a= false
a字节= 1

彼岸吖

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
GO语言学习（持续更新）

输出Hello worldpackage mainimport "fmt"func main() { fmt.Println ("hello world")}认识变量package mainimport "fmt"func main(){ //定义变量/声明变量 var i int //给i赋值 i = 10 //使用变量 fmt.Println("i=", i)}变量的三种方式package mainimport "fmt".
复制链接

扫一扫