蹒跚学Go第一天-初识GO语言

编程语言第一步从Hello word开始

package main    //定义一个包名mian,main是可执行程序的包名,也是所有Go程序的头部声明,Go使用包来管理命名空间
import "fmt"    //应用外部的包,可以为标准库/第三方库
func main(){    //定义个主函数main
    fmt.Println("你好,世界!")
}

go version  #查看当前的版本
go run begin.go #直接运行
go build begin.go   #编译GO程序后执行
./begin.go

基础数据类型

类型 名称 长度 零值 说明
bool 布尔类型 1 false 其值不为真即为假,不可以用数字代表true或false
byte 字节型 1 0 uint8别名
rune 字符类型 4 0 专用于存储unicode编码,等价于uint32
int, uint 整型 4或8 0 有符号32位或无符号64位
int8 整型 1 0 -128 ~ 127,
uint8 整型 1 0 0 ~ 255
int16 整型 2 0 -32768 ~ 32767,
uint16 整型 2 0 0 ~ 65535
int32 整型 4 0 -2147483648 到 2147483647
uint32 整型 4 0 0 到 4294967295(42亿)
int64 整型 8 0 0 到 18446744073709551615(1844京)
uint64 整型 8 0 -9223372036854775808到 9223372036854775807
float32 浮点型 4 0.0 小数位精确到7位
float64 浮点型 8 0.0 小数位精确到15位
complex64 复数类型 8 none
complex128 复数类型 16 64 位实数和虚数
uintptr 整型 4或8 none ⾜以存储指针的uint32或uint64整数
string 字符串 “” none utf-8字符串

1.例子:布尔型

func main()  {
    var  a  bool
    //默认声明的Bool变量值为false
    fmt.Println("a = ",a)
    a = true
    fmt.Println("a = ",a)
    var b  = false
    fmt.Println("b = ",b)
    //自动推倒类型
    c := false
    fmt.Println("c = ",c)
    fmt.Printf("c = %t -> 字符串",c)
}

2.例子:字符类型

func main()  {
    //第一种方式
    var cha   byte
    cha = 'a'
    fmt.Printf("%c\n",cha)
    //第二种方式,ASCII转码
    cha = 97
    fmt.Printf("%c",cha)
}

3.例子:字符串类型

func main()  {
    var str string
    var qq string
    str = "字符串"
    fmt.Println("str = ",str)
    fmt.Scanf("%s", &qq)
    fmt.Printf("内容:%s",qq)
}

字符与字符串区分

  • 字符:单引号,往往只有一个字符转义字符除外’\n’

  • 字符串:双引号,字符串有一个或多个组成,所有字符串都隐藏了一个结束符号’\0′

转义字符

  • \”:表示一个英文半角的双引号

  • \t:表示一个tab键的空格(可以用来对输出的内容进行排版)

  • \:表示一个(主要用在表示磁盘目录上,根据磁盘目录获取文件然后进行读取,写入等操作)

rune类型

Go内置两种字符类型:一种是byte的字节类类型(byte是uint的别名),另一种是表示Unicode 编码的字符rune。rune在Go内部是int32类型的别名,占用4个字节。Go语言默认的字符编码就是UTF-8类型的,如果需要特殊的编码转换,则使用Unicode/UTF-8标准包。

符合数据类型

格式化输出

输出格式 格式说明
%% 一个%字面量
%b 一个二进制整数值(基数为2),或者是一个(高级的)用科学计数法表示的指数为2的浮点数
%c 字符型。可以把输入的数字按照ASCII码相应转换为对应的字符
%d 一个十进制数值(基数为10)
%e 以科学记数法e表示的浮点数或者复数值
%E 以科学记数法E表示的浮点数或者复数值
%f 以标准记数法表示的浮点数或者复数值
%g 以%e或者%f表示的浮点数或者复数,任何一个都以最为紧凑的方式输出
%G 以%E或者%f表示的浮点数或者复数,任何一个都以最为紧凑的方式输出
%o 一个以八进制表示的数字(基数为8)
%p 以十六进制(基数为16)表示的一个值的地址,前缀为0x,字母使用小写的a-f表示
%q 使用Go语法以及必须时使用转义,以双引号括起来的字符串或者字节切片[]byte,或者是以单引号括起来的数字
%s 字符串。输出字符串中的字符直至字符串中的空字符(字符串以’\0‘结尾,这个’\0’即空字符)
%t 以true或者false输出的布尔值
%T 使用Go语法输出的值的类型
%U 一个用Unicode表示法表示的整型码点,默认值为4个数字字符
%v 使用默认格式输出的内置或者自定义类型的值,或者是使用其类型的String()方式输出的自定义值,如果该方法存在的话
%x 以十六进制表示的整型值(基数为十六),数字a-f使用小写表示
%X 以十六进制表示的整型值(基数为十六),数字A-F使用小写表示

即时练习

  • 问用户喜欢吃什么水果(fruits),假如用户输入”苹果”,则显示”哈哈,这么巧,我也喜欢吃苹果”
func main()  {
    var fruits string
    fmt.Println("你喜欢什么水果:")
    fmt.Scanf("%s",&fruits)
    if fruits == "苹果"{
        fmt.Println("哈哈,这么巧,我也喜欢吃苹果")
    }else {
        fmt.Println("哦我们喜欢不一样")
    }
}
  • 计算平均值

  • Go语言中不允许隐式转换,所有类型转换必须显式声明(强制转换),而且转换只能发生在两种相互兼容的类型之间

func main()  {
    var chinese int = 90
    var math int = 80
    var english int = 69
    //var b = int(math) 这种会报错的
    fmt.Printf("总分:%d,平均分:%f",chinese + math + english,float64((chinese + math + english)/3))
}

变量

使用一个名称来绑定一块内存地址,该内存地址中存放的数据类型由定义变量时指定的类型决定,该内存地址里面存放的内容可以改变。

如何声明变量

var varName dataType [ = value]

  • 关键字var用于变量声明。

  • varName是变量名标识符。

  • data Type是基本类型。

  • value是变量的初始值,初始值可以是字面量,也可以是其他变量名,还可以是一个表达式;如果不指定初始值,则Go默认将该变量初始化为类型的零值。

  • Go的变量声明后就会立即为其分配空间。

系统预定义的变量

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

常量

常量使用一个名称来绑定一块内存地址,该内存地址中存放的数据类型由定义常量时指定的类型决定,而且该内存地址里面存放的内容不可以改变 Go 中常量分为布尔型、宇符串型和数值型常量常量存储在程序的只读段里。

  • 常量:程序运行期间,不可以被改变的量声明方式 -> const

  • 预声明标识符:iota,经常在定义常量的时候使用,初始值为0,当一组中的多个声明常量同时使用iota会自增,可以理解为自增枚举变量

func main()  {
    const (
    a1 = iota // a1 == 0
    a2 = iota // a2 == 1
    )
    //简写模式
    const (
        b1 = iota
        b2
    )
    const (
        a = iota * 99 // a = 0
        b = iota * 99 // b == 99
        c = iota * 99 // c == 198
    )
    const  q  = iota // 不在组每次定义都是从0开始
    const  w  = iota
}

问题:什么场景下会用到常量呢?

在程序开发中,我们用常量存储一直不会发生变化的数据,例如:π,身份证号码等。像这类的数据,在整个程序中运行中都是不允许发生改变的。

2.Go接受键盘输出类似C语言

  • Scanf()函数来接收用户键盘输入的数据

  • %d接受的数据格式

  • fmt.Printf格式化输出

package main

import "fmt"

func main()  {
    var age int
    fmt.Println("Plase Input You age:")
    fmt.Scanf("%d",&age)
    fmt.Printf("a=%d",age)
}

3.简单的圆周率计算

//导入主函数的包
package main

import "fmt"

//注释不参与程序编译
//main 主函数主入口
func main(){
    //fmt系统的默认包,Println -> ln说明换行
    var PI float64 = 3.1415926
    var r float64 = 2.5
    //计算面积
    s := PI*r*r
    //计算周长
    l := PI*2*r
    fmt.Println("面积:",s)
    fmt.Println("周长:",l)
}

4.简单的取出内存地址

func main()  {
    //声明变量
    var a int
    //&运算符 取地址 scan等待终端输出取值
    fmt.Scan(&a)
    //%p 占位符:表示输出一个数据对应的内存地址 &a
    fmt.Printf("%p",&a)
    //运行结果:0xc04204a080  -> 0X十六进制地址
}

运算符

运算符 术语 示例 结果
+ 10 + 5 15
10 – 5 5
* 10 * 5 50
/ 10 / 5 2
% 取模(取余) 10 % 3 1
++ 后自增,没有前自增不能运用在表达式中 a=0; a++ a=1
后自减,没有前自减不能运用在表达式中 a=2; a– a=1
func main()  {
    var a int = 10
    var b int = 20
    //求和
    fmt.Println("a + b =",a+b)
    //减法运算
    fmt.Println("a - b =",a-b)
    //乘法
    fmt.Println("a x b =",a*b)
    //除法
    fmt.Println("a / b =",a/b)
    //取余
    fmt.Println("a % b =",a%b)
}

容易出错的点

  • 大类型的数据装换成小的数据类型有可能导致数据溢出,Go语言中习惯将类型装换成高类型保障数据的完整性
func main()  {
    var num1 int = 35
    var num2 int = 40
    var avg float64
    //如此执行方式会报错num1/2都是整数而avg是浮点无转换无法赋值
    //avg = (num1+num2)/2
    //解决方式
    avg = float64((num2 + num1)/2)
    fmt.Printf("%f",avg)
}

测试练习

  • int 转float 强制转换,多小数

  • float转int强制转换,丢精度

func main()  {
    var time float64 = 107653
    fmt.Printf("107653秒是:%d天%d小时%d分钟%d秒",int(time/60/60/24),int(time/60/60)%24,int(time/60)%60,int(time)%60)
}
运行结果:
107653秒是:1天5小时54分钟13秒

关系运算符

运算符 术语 示例 结果
== 相等于 4 == 3 false
!= 不等于 4 != 3 true
< 小于 4 < 3 false
> 大于 4 > 3 true
<= 小于等于 4 <= 3 false
>= 大于等于 4 >= 1 true

赋值运算符

运算符 说明 示例
= 普通赋值 c = a + b 将 a + b 表达式结果赋值给 c
+= 相加后再赋值 c += a 等价于 c = c + a
-= 相减后再赋值 c -= a 等价于 c = c – a
*= 相乘后再赋值 c *= a 等价于 c = c * a
/= 相除后再赋值 c /= a 等价于 c = c / a
%= 求余后再赋值 c %= a 等价于 c = c % a
func main()  {
    var a  int=10
    a += 5
    a -=5
    a *=5
    a /=5
    a %=5
    fmt.Println(a)
}

逻辑运算符

运算符 术语 示例 结果
! !a 如果a为假,则!a为真;如果a为真,则!a为假。
&& a && b 如果a和b都为真,则结果为真,否则为假。
|| a || b 如果a和b有一个为真,则结果为真,二者都为假时,结果为假。
  • 逻辑运算符号常常与Bool结合在一起
func main()  {
    a := 20
    b := 30
    //a不等于B -> 为假 -> ! -> 为真
    fmt.Println(!(a==b))
    //a<b ->真 ; a>b -> 为假 ; && -> 都要为真 -> 输出:结果为假
    fmt.Println(a<b && a>b)
    //a<b ->真 ; a>b -> 为真 ; && -> 满足一个为真 -> 输出:结果为真
    fmt.Println(a<b || a>b)
}

其他运算符

运算符 术语 示例 说明
& 取地址运算符 &a 变量a的地址
* 取值运算符 *a 指针变量a所指向内存的值

运算符优先级

在Go语言中,一元运算符(一些只需要一个操作数的运算符称为一元运算符(或单目运算符)。)拥有最高的优先级,二元运算符的运算方向均是从左至右

优先级 运算符
7 ^ ! .
6 * / % << >> & &^
5 + – | ^
4 == != < <= >= >
3 <-
2 &&
1 |||

常规练习

  • 条件一:普通闰年:能被4整除但不能被100整除的年份为普通闰年。
  • 条件二:世纪闰年:能被400整除的为世纪闰年。
func main()  {
    var year int
    var b,a bool
    fmt.Println("输下年份看看是不是闰年:")
    fmt.Scanf("%d",&year)
    b = (year%400 == 0)||(year%4 == 0 && year%100 != 0)
    fmt.Println(b)
}

流程控制

  • 顺序结构:程序按顺序执行,不发生跳转。

  • 选择结构:依据是否满足条件,有选择的执行相应功能。

  • 循环结构:依据条件是否满足,循环多次执行某段代码。

if判断

if判断

if结构基本语法
 if 条件判断{
   代码语句
}

if-else

if 条件判断{
  代码语句1
}else{
 代码语句2
}

switch结构

程序执行到switch处,首先将变量或者表达式的值计算出来,然后拿着这个值依次跟每个case后面所带的值进行匹配,一旦匹配成功,则执行该case所带的代码,执行完成后,跳出switch-case结构。如果,跟每个case所带的值都不匹配。就看当前这个switch-case结构中是否存在default,如果有default,则执行default中的语句,如果没有default,则该switch-case结构什么都不做。

if与switch的异同点

  • 相同点: 都可以实现多分支结构

  • 不同点(根据个人习惯进行选择)

  • if-else if:可以处理范围

  • switch:一般用于等值比较

结构表达式:

  • GO语言中switch-case结构中,case后面默认自带break(终止程序执行),这是与其它语言不同的地方。

  • case 后面跟着的代码执行完毕后,不会再执行后面的case,而是跳出整个switch结构, 相当于每个case后面都跟着break(终止),但是如果我们想执行完成某个case后,强制执行后面的case,可以使用fallthrough

switch 变量或者表达式的值{
    case 值1:
        要执行的代码
    case 值2:
        要执行的代码
    case 值3:
        要执行的代码
    ………………………………..
    default:
        要执行的代码
}

func main()  {
    var w int
    fmt.Println("输入1-3:")
    fmt.Scan(&w)
    switch w {
    case 1:
        fmt.Printf("你的输入被+1:%d",w+1)
    case 2:
        fmt.Printf("你的输入被+2:%d",w+2)
    case 3:
        fmt.Printf("你的输入被*3:%d",w*3)
    default:
        fmt.Printf("不在范围内:%d",w)
    }
}

练习

  • 请用户输年份,再输入月份,输出该月的天数.(结合之前如何判断闰年来做)
func main()  {
    //定义年月日
    var year,month,day int
    fmt.Println("请输入年份")
    fmt.Scanf("%d\n", &year)
    fmt.Println("请输入月份")
    fmt.Scanf("%d", &month)
    if year >=0 && (month <= 12 && month >=0){
        switch month {
        case 1:
            fallthrough
        case 3:
            fallthrough
        case 4:
            fallthrough
        case 5:
            fallthrough
        case 6:
            fallthrough
        case 7:
            fallthrough
        case 8:
            fallthrough
        case 10:
            fallthrough
        case 11:
            fallthrough
        default:
            day=30
        case 12:
            day = 31
        case 2: //需要判断是否为闰年
            if (year%400 == 0) || (year%4 == 0 && year%100 != 0) {
                day = 29
            } else {
                day = 28
            }
        }
        fmt.Printf("%d年%d月共%d天", year, month, day)
    }else {
        fmt.Println("不在范围内")
    }
}

循环结构

在GO语言中,我们有专门实现这种循环的结构就是for结构(GO语言中只有for循环结构,没有while,do-while结构)

基本的表达式:

  • 表达式1:定义一个循环的变量,记录循环的次数

  • 表达式2:一般为循环条件,循环多少次

  • 表达式3:一般为改变循环条件的代码,使循环条件终有一天不再成立

  • 循环体:重复要做的事情。

for 表达式1;表达式2;表达式3{
    循环体
}

习例子

  • 1到100的累加值和偶数和
func main()  {
    var sum,sum1 int
    for i:=0;i<=100;i++{
        if i%2 == 0 {
            sum1 += i
        }
        sum += i

    }
    fmt.Println("sum::",sum)
    fmt.Println("sum偶数::",sum1)
}
  • 小鸡8w,年增长25%,多少年10w只?
func main()  {
    var p float64 = 80000
    var year  int
    for i:=0;p<=200000;i++{
        p += p*0.25
        year+= i
    }
    fmt.Println("时间:",year,"年")
}
  • 100-999的水仙花数

分析:水仙花数指的就是 这个百位数字的,百位的立方+十位的立方+个位的立方==当前这个百位数字

func main()  {
    for i := 100; i <= 999; i++ {
        ge := i/100
        shi := i%100/10
        bai := i%10
        if ge+shi*shi+bai*bai*bai == i{
            fmt.Println("水仙花数:",i)
        }
    }
}

跳转语句

  • break, continue, goto

输入账号密码,三次错误退出程序正确退出程序

func main()  {
    var user,passwd string
    a:= "ddy"
    b:= "123"
    for i := 0; i < 3; i++ {
        fmt.Println("输入账号:")
        fmt.Scanf("%s",&user)
        fmt.Println("输入密码:")
        fmt.Scanf("%s",&passwd)
        if user==a && passwd==b{
            fmt.Println("输入正确!")
            os.Exit(0)
        }
    }
    fmt.Println("超过次数!")
}
  • continue语句:立即结束本次循环,判断循环条件,如果成立,则进入下一次循环,否则退出循环.

发表评论