【GoLang】基础语法(上)

Go基础语法(上)

文章目录

01注释

注释主要的功能就是为了增强代码的可读性，不参与程序的一切功能，G0语言的注释主要分成两类:

单行注释
多行注释

package main

import"fmt"/*
*多行注释
这是一个main函数，这是go语言启动的入口
*/funcmain(){//单行注释//fmt.Println ：打印一句话，然后执行完毕且换行
    fmt.Println("Hello,World")
    fmt.Println("Hello,World")
    fmt.Println("Hello,World")}

写注释是一个十分良好的习惯，我们都应该按照要求给自己代码写好注释，为了自己，也为了他人。很多大公司里也是对注释有严格要求的。

02变量

搞清楚注释之后，接下来我们了解一个程序中十分重要的东西，变量！
在数学概念中，变量表示没有固定值且可改变的数。比如×=1，×=2：
字面上的意思理解：变量就是会变化的量。比如我定一个了一个变量叫做名字，它在Go语言中是这样表示的：这个值既可以是张三，也可以是李四。那么在这里，这个name就是变量。可以变化的量。

package main

import"fmt"funcmain(){//name 变量var name string="ikun"
    name ="jay"

    fmt.Println(name)//结果jay}

定义

Go语言是静态类型语言，就是所有的类型我们都需要明确的去定义。

这里先了解

strig

,我们用它来表示字符串！
在Go语言中，我们声明一个变量一般是使用

var

关键字：

格式如下：

var name typevar 变量名 变量类型
/*
var：代表的是声明变量的关键字，固定写法
name：变量的名字
type：变量的类型
*/

示例代码：

//定义一个数字符串变量 namevar name string//定义一个数字类型变量 agevar age int//指针var a， b *int//定义多个变量var(
        name string
        age  int
        addr string)//string默认值：空//int默认值： 0
    fmt.Println(name, age, addr)

变量的命名规则遵循骆驼命名法，即首个单词小写，每个新单词的首字母大写

var形式的声明语句往往是用于需要显式指定变量类型地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方。

当一个变量被声明之后，如果没有显示的给他赋值，系统自动赋予它该类型的零值：

整型和浮点型变量的默认值为0和0.0。
字符串变量的默认值为空字符串。
布尔型变量默认为false。
切片、函数、指针变量的默认为nil。

初始化

package main
import"fmt"funcmain(){/**
    定义多个变量
    */var(
        name string
        age  int
        addr string)
    name ="jay"
    age =27
    addr ="China"//string默认值：空//int默认值： 0
    fmt.Println(name, age, addr)}

其实Go语言这里做了一个语法糖：短变量声明且初始化

:=

//:=  自动推导
name :="jay"
age :=27
addr :="China"

package main
import"fmt"funcmain(){//:= 自动推导
    name :="jay"
    age :=27
    addr :="China"
    fmt.Println(name, age, addr)//Printf "%T,%T,%T", ---> 求变量类型
    fmt.Printf("%T,%T,%T", name, age, addr)}/**
*输出结果：
* jay 27 China
* string,int,string
*/

这是Go语言的推导声明写法，编译器会自动根据右值类型推断出左值的对应类型。
它可以自动的推导出一些类型，但是使用也是有限制的：

定义变量，同时显式初始化。
不能提供数据类型。
只能用在函数内部。不能随便到处定义

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。

注意：由于使用

:=

，而不是赋值的

，因此推导声明写法的左值变量必须是没有定义过的变量。若定义过，将会发生编译错误。

打印内存地址

package main

import"fmt"funcmain(){var num int
    num =100//取地址符 ： &
    fmt.Printf("num:%d,内存地址：%p", num,&num)
    fmt.Println()
    num =200
    fmt.Printf("num:%d,内存地址：%p", num,&num)}//num:100,内存地址：0xc0000a6058//num:200,内存地址：0xc0000a6058
内存地址不变

变量交换

package main
import"fmt"/*
在编程中，最简单的算法就是变量交换了，一般常见方式就是定义中间变量
var a int = 100
var b int = 200
var t int
t = a
a = b
b = t
fmt.Println(a,b)
但是在Go语言中，就不用中间变量了，如下示例代码：
*/funcmain(){var a int=100var b int=200
    b, a = a, b
    fmt.Println(a, b)}

匿名变量

匿名变量的特点是一个下画线

”_”

，

“_“

本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它)，但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变呈对其它变量进行赋值或运算。使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。例如：

package main

import"fmt"functest()(int,int){return100,200}funcmain(){//a, b := test()//对象：User 匿名变量
    a,_:=test()
    fmt.Println(a)}

在编码过程中，可能会遇到没有名称的变量、类型或方法。虽然这不是必须的，但有时候这样做可以极大地增强代码的灵活性，这些变量被统称为匿名变量。

匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

变量的作用域

局部变量

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存失败,源站可能有防盗链机制,建议将图片保存下来直接上传上传(imUu3xvC6rf0-1690464718694)(C:\Users\86159\AppData\Roaming\Typora\typora-user-images\image-20230725200127697.png)(C:\Users\86159\AppData\Roaming\Typora\typora-user-images\image-20230725200127697.png)]$

全局变量

在这里插入图片描述

03常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量的定义“

const

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

我们可以省略类型说明符

type

，因为编译器可以根据变量的值来推断其类型。

显式类型定义：const b string = "abc"
隐式类型定义：const b = "abc"

多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2

示例代码如下：

package main

import"fmt"funcmain(){const URL string="www.baidu.com"//显式类型定义const URL2 ="www.baidu.com"//隐式类型定义const a, b, c =3.14,false,"ikun"

    fmt.Printf(URL)
    fmt.Printf(URL2)}

iota

iota,特殊常量，可以认为是一个可以被编译器修改的常量。iota是go语言的常量计数器
iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)

const(
        a =iota
        b =iota
        c =iota)

第一个iota等于0，每当iota在新的一行被使用时，它的值都会自动加1；所以a=0,b=1,c=2可以简写为如下形式：

const(//一维常量中，如果某个常量没有初始值，默认和上一行一致
        a =iota
        b 
        c
    )

在这里插入图片描述

04基本数据类型

布尔类型

布尔型的值只能是

true

false

下面给出示例代码：

funcmain(){//bool 默认值 falsevar b1 boolvar b2 bool
    b1 =true
    b2 =false

    fmt.Println(b1, b2)
    fmt.Printf("%T,%T", b1, b2)}//输出：truefalsebool,bool

数字类型

整型int和浮点型float32、float64,GO语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。

整型

序号类型及描述1****uint8无符号8位整型（0-255）2****uint16无符号16位整型3****uint32无符号32位整型4****uint64无符号64位整型5****int8有符号8位整型（-128-127）6****int16有符号16位整型7****int32有符号32位整型8****int64有符号64位整型

浮点型

序号类型及描述1****float32IEE-754 32位浮点型数2****float64IEE-754 64位浮点型数3****complex6432位实数和虚数4****complex12864位实数和虚数

关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位
尾数数部分可能丢失，造成精度损失。-123.0000901

package main
import"fmt"funcmain(){//定义一个整型var age int=18
    fmt.Printf("%T,%d\n", age, age)//定义一个浮点型//默认6位小数var money float64=3.14var money1 float64=3.19
    fmt.Printf("%T,%f\n", money, money)
    fmt.Printf("%T,%.2f\n", money, money)
    fmt.Printf("%T,%.1f\n", money1, money1)}//输出int,18float64,3.140000float64,3.14float64,3.2

以下是其他更多的数字类型：
序号类型及描述1****byte类似uint8（0-255）2****rune类似int323****uint32或64位4****int与uint同大5****uintptr无符号整型，用于存放指针

字符与字符串

package main

import"fmt"funcmain(){var str string
    str ="Hello,ikun"
    fmt.Printf("%T,%s\n", str, str)//单引号 字符， 整型-ASCLL字符码//拓展：//所有中国字的编码表：GBK//全世界编码表：Unicode编码表
    v1 :='A'
    v2 :="A"
    fmt.Printf("%T,%d\n", v1, v1)//int32,65
    fmt.Printf("%T,%s\n", v2, v2)//编码表ASCLL//字符串连接 +
    fmt.Println("hello"+"world")//转义字符 \
    fmt.Println("hello\"666")
    fmt.Println("hello\n666")// \n换行
    fmt.Println("hello\t666")// \t制表符//输出string,Hello,ikun
int32,65string,A
helloworld
hello"666
hello
666
hello   666}

在这里插入图片描述

05数据类型转换

valueofTypeB =typeB(valueofTypeA)

funcmain(){
    a :=5.0
    b :=int(a)

    fmt.Printf("%T,%f\n", a, a)
    fmt.Printf("%T,%d\n", b, b)}//输出float64,5.000000int,5

整型不能转换为布尔类型

类型转换只能在定义正确的情况下转换成功，例如从一个取值范国较小的类型转换到一个取值范围较大的类型（将int16转换为int32)。当从一个取值范固较大的类型转换到取值范固较小的类型时（将int32转换为int16或将float32转换为int),会发生 精度丢失(截断) 的情况。

06运算符

算术运算符

+-*/%++--

关系运算符

==!=><>=<=

逻辑运算符

&&||!

位运算符

（这里涉及电路问题，偏底层，不详细介绍）
运算符描述&按位与运算符"&"是双目运算符。都是1结果为1，否则是0|按位或运算符"|"是双目运算符。都是0结果为0，否是是1^按位异或运算符"^"是双目运算符。不同则为1，相同为0&^位清空，a&^b,对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0.<<左移运算符"<<“是双目运算符。左移n位就是乘以2的次方。其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。>>右移运算符">>“是双目运算符。右移n位就是除以2的次方。其功能是把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。
具体例子如下：

funcmain(){/**
    首先了解一下二进制 0  1 逢2进1
              1      1
              2      10
              3      11
              4      100
    *///位运算： 二进制上的 0 false 1 true// & ： 我和你 1 1 结果为 1// | ： 我或你 0 1 结果才为1//前提：A=60 ： 0011 1100//     B=13 ： 0000 1101//---------------------------// &：         0000 1100  我和你同时满足// |：         0011 1101  我或你 一个满足即可// ^:          0011 0001  不同为1 相同为0// &^:         0011 0000  位清空 对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0.// >>：2// <<: 2var a uint=60var b uint=13//位运算var c uint=0

    c = a & b
    //fmt.Println(c)
    fmt.Printf("%d,二进制%b", c, c)//12,二进制1100

    c = a | b
    fmt.Printf("%d,二进制%b", c, c)//61,二进制111101

    c = a ^ b
    fmt.Printf("%d,二进制%b", c, c)//49,二进制110001//A=60 ： 0011 1100
    c = a <<2
    fmt.Printf("%d,二进制%b", c, c)// 1111 0000
    a =60
    c = a >>2
    fmt.Printf("%d,二进制%b", c, c)// 0000 1111}

赋值运算符

=+=-=*=/=%=<<=>>=&=^=|=

07获取键盘输入

package main
import"fmt"funcmain(){var x intvar y float64/**
    定义了两个变量 想用键盘来录入这个两个变量
    fmt.Println() --> 打印并换行
    fmt.Printf()  --> 格式化输出
    fmt.Print()   --> 打印输出
    fmt.Scanln()  --> 接收输入
    fmt.Scanf()   --> 接受输入 格式化
    fmt.Scan()    --> 接受输入
    */

    fmt.Println("请输入两个数：1.整数 2.浮点数")//变量取地址 & 变量
    fmt.Scanln(&x,&y)
    fmt.Println("x = ", x)
    fmt.Println("y = ", y)}

在这里插入图片描述

至此，Go基础语法(上)介绍到此，近期会更新Go基础语法(下)。

标签： golang 开发语言后端

本文转载自: https://blog.csdn.net/m0_73075027/article/details/131969084
版权归原作者 不想成为小白菜 所有，如有侵权，请联系我们删除。

【GoLang】基础语法(上)

Go基础语法(上)

文章目录

01注释

02变量

定义

初始化

打印内存地址

变量交换

匿名变量

变量的作用域

03常量

iota

04基本数据类型

布尔类型

数字类型

整型

浮点型

字符与字符串

05数据类型转换

06运算符

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

07获取键盘输入

发表评论

“【GoLang】基础语法(上)”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航