Go语言笔记1-基本数据类型和语法

Go语言笔记

  • 特点
    • 主要特性
    • 语言用途
  • 执行程序
    • 程序基本组成
    • 关于包
  • 数据类型
    • 布尔类型
    • 数字类型
    • 字符串类型
    • 派生类型
  • 语法
    • 声明变量
    • 多变量声明
    • 值类型和引用类型
    • 空白标识符
    • 常量
      • 常量定义
      • iota
    • 运算符
      • 位运算符
      • 赋值运算符
      • 其他运算符
    • 条件语句
    • 循环语句

初学笔记,有误请多见谅,随着学习的深入会丰富和更新

特点

简洁、快速、安全
并行、有趣、开源
内存管理、数组安全、编译迅速

主要特性

自动垃圾回收
更丰富的内置类型
函数多返回值
错误处理
匿名函数和闭包
类型和接口
并发编程
反射
语言交互性

语言用途

一门应用于搭载 Web 服务器,存储集群或类似用途的巨型中央服务器的系统编程语言
提供了海量并行的支持,适合游戏服务端的开发

执行程序

程序基本组成

package main  //包声明

import "fmt"  //引入包

func main() {  //函数
   // 注释  /* 第一个简单的程序 */
   fmt.Println("Hello, World!")  
   //变量  
   //语句 & 表达式
}

需要注意’{'不能单独一行

执行程序有两种方式

  • go run filename.go
  • go build filename.go生成二进制文件filename
    ./filename

关于包

文件名与包名没有直接关系,不一定要将文件名与包名定成同一个。
文件夹名与包名没有直接关系,并非需要一致。
同一个文件夹下的文件只能有一个包名,否则编译报错。

数据类型

布尔类型

true or false:

var b bool = true;

数字类型

整型 int 和浮点型 float32、float64

字符串类型

Go 的字符串是由单个字节连接起来的
Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本

派生类型

  • 指针类型(Pointer)
  • 数组类型
  • 结构化类型(struct)
  • Channel 类型
  • 函数类型
  • 切片类型
  • 接口类型(interface)
  • Map 类型

语法

声明变量

Go 语言变量名由字母、数字、下划线组成,其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字:

var identifier type

简单例子

var a int //没有初始化就为零值,bool零值为false,string为空串
var b int = 32
var c, d int //声明多个变量
var str1 string = “str”
e := 10 //如果省略var,变量必须是新声明的,并且只能在函数体中出现

多变量声明

类型相同多个变量, 非全局变量

var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

和 python 很像,不需要显示声明类型,自动推断

var vname1, vname2, vname3 = v1, v2, v3

出现在 := 左侧的变量不应该是已经被声明过的,否则会导致编译错误

vname1, vname2, vname3 := v1, v2, v3

这种因式分解关键字的写法一般用于声明全局变量

var (
    vname1 v_type1
    vname2 v_type2
 )

值类型和引用类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型,使用这些类型的变量直接指向存在内存中的值
使用等号 = 将一个变量的值赋值给另一个变量时,如:j = i,实际上是在内存中将 i 的值进行了拷贝
(可以理解为深拷贝)

一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址(数字),或内存地址中第一个字所在的位置
这个内存地址称之为指针,这个指针实际上也被存在另外的某一个值中

当使用赋值语句 r2 = r1 时,只有引用(地址)被复制。
如果 r1 的值被改变了,那么这个值的所有引用都会指向被修改后的内容
(可以理解为浅拷贝)

可以像python一样直接交换两个变量的值:

a, b = b, a

空白标识符

空白标识符 _ 也被用于抛弃值,如值 5 在:_, b = 5, 7 中被抛弃。
_ 实际上是一个只写变量,不能得到它的值。这样做是因为 Go 语言中必须使用所有被声明的变量,但有时并不需要使用从一个函数得到的所有返回值。
比如:

package main

import "fmt"

func main() {
  _,numb,strs := numbers() //只获取函数返回值的后两个
  fmt.Println(numb,strs)
}

//一个可以返回多个值的函数
func numbers()(int,int,string){
  a , b , c := 1 , 2 , "str"
  return a,b,c
}

最后输出结果为2 str

并行赋值也被用于当一个函数返回多个返回值时,比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到:val, err = Func1(var1)。

常量

常量定义

常量的定义格式:

const identifier [type] = value

可以省略[type],编译器会自动推断
显式类型定义: const b string = “abc”
隐式类型定义: const b = “abc”

iota

iota,特殊常量,可以认为是一个可以被编译器修改的常量。

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
)

实例:

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值,iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
    // 0 1 2 ha ha 100 100 7 8
}

左移实例:

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println(i,j,k,l)
    // 1 6 12 24
}

iota 表示从 0 开始自动加 1,所以 i=1<<0, j=3<<1(<< 表示左移的意思),即:i=1, j=6,这没问题,关键在 k 和 l,从输出结果看 k=3<<2,l=3<<3。

简单表述:

i=1:左移 0 位,不变仍为 1;
j=3:左移 1 位,变为二进制 110, 即 6;
k=3:左移 2 位,变为二进制 1100, 即 12;
l=3:左移 3 位,变为二进制 11000,即 24。

注:<

运算符

和C++类似的(可能所有语言都类似):

位运算符

Go语言笔记1-基本数据类型和语法_第1张图片

赋值运算符

Go语言笔记1-基本数据类型和语法_第2张图片

其他运算符

在这里插入图片描述

条件语句

除了if, if…else, if嵌套和switch之外,还有select
select 语句类似于 switch 语句,但是select会随机执行一个可运行的case。如果没有case可运行,它将阻塞,直到有case可运行。

go没有三目运算符

循环语句

for, for嵌套
控制:break, continue, goto

你可能感兴趣的:(Go语言,编程语言,go)