Go语言学习第一天

发布时间:2023年12月28日

Go语言简介

  1. go语言的特性:

    • 一个目录下的同级文件属于同一个包。

    • 包名可以与其目录名不同 ?。

    • main包是Go语言程序的入口包,一个Go语言程序必须有且仅有一个main包,如果一个程序没有main包,那么编译事就会出错,无法生成可执行文件。(main函数只能声明在main包中)

  2. 导入的包中不能含有代码中没有使用的包,否则Go编译器会出错。

    import(

    "name1"

    "name2"

    )

  3. func 函数名 (参数列表) (返回值列表) {

    函数体

    }

    • go build 命令可以将Go语言程序代码编译成二进制的可执行文件,但是需要我们手动运行该二进制文件;

    • go run 命令则更加方便,它会在编译后直接运行Go语言程序,编译过程中会产生一个临时文件,但不会生成可执行文件,这个特点很适合用来调试程序

Go语言基本语法

    • var 变量名 变量类型

    • 当一个变量被声明之后,系统自动赋予它该类型的零值:int 为 0,float 为 0.0,bool 为 false,string 为空字符串,指针为 nil 等。所有的内存在 Go 中都是经过初始化的

    • var (
       ?  a int
       ?  b string
       ?  c []float32
       ?  d func() bool
       ?  e struct {
       ? ? ?  x int
       ?  }
      )
    • 名字 := 表达式 (简短变量声明被广泛用于大部分的局部变量的声明和初始化。var 形式的声明语句往往是用于需要显式指定变量类型地方,或者因为变量稍后会被重新赋值而初始值无关紧要的地方)

      • 定义变量,同时显式初始化

      • 不能提供数据类型

      • 只能用在函数内部

    • 匿名变量 _ 将被抛弃

    • 作用域 (Go语言会在编译时检查每个变量是否使用过,一旦出现未使用的变量,就会报编译错误。如果不能理解变量的作用域,就有可能会带来一些不明所以的编译错误。)

      • 函数内定义的变量称为局部变量

      • 函数外定义的变量称为全局变量 (在函数体外声明的变量称之为全局变量,全局变量只需要在一个源文件中定义,就可以在所有源文件中使用,当然,不包含这个全局变量的源文件需要使用“import”关键字引入全局变量所在的源文件之后才能使用这个全局变量。)(全局变量声明必须以 var 关键字开头,如果想要在外部包中使用全局变量的首字母必须大写)

      • 函数定义中的变量称为形式参数

    • Go语言同时提供了有符号和无符号的整数类型,其中包括 int8、int16、int32 和 int64 四种大小截然不同的有符号整数类型,分别对应 8、16、32、64 bit(二进制位)大小的有符号整数,与此对应的是 uint8、uint16、uint32 和 uint64 四种无符号整数类型。

    • 浮点类型

      • 常量 math.MaxFloat32 表示 float32 能取到的最大数值,大约是 3.4e38;

      • 常量 math.MaxFloat64 表示 float64 能取到的最大数值,大约是 1.8e308;

      • float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324

      • 一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度,而 float64 则可以提供约 15 个十进制数的精度,通常应该优先使用 float64 类型,因为 float32 类型的累计计算误差很容易扩散,并且 float32 能精确表示的正整数并不是很大。

        • var f float32 = 16777216 // 1 << 24
          fmt.Println(f == f+1) ?  // "true"!
      • 浮点数在声明的时候可以只写整数部分或者小数部分

        • const e = .71828 // 0.71828
          const f = 1. ? ? // 1
      • 很小或很大的数最好用科学计数法书写,通过 e 或 E 来指定指数部分

        • const Avogadro = 6.02214129e23  // 阿伏伽德罗常数
          const Planck ? = 6.62606957e-34 // 普朗克常数
          ?
      • 用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数

    • 复数 Go语言中复数的类型有两种,分别是 complex128(64 位实数和虚数)和 complex64(32 位实数和虚数),其中 complex128 为复数的默认类型

      • var name complex128 = complex(x, y)

      • name := complex(x, y)

      • 对于一个复数z := complex(x, y),可以通过Go语言的内置函数real(z)来获得该复数的实部,也就是 x;通过imag(z)获得该复数的虚部,也就是 y

      • 复数也可以用==!=进行相等比较,只有两个复数的实部和虚部都相等的时候它们才是相等的

    • Go语言中不允许将整型强制转换为布尔型

    • 定义字符串

      • 可以使用双引号""来定义字符串,字符串中可以使用转义字符来实现换行、缩进等效果,常用的转义字符包括:

        • \n:换行符

        • \r:回车符

        • \t:tab 键

        • \u 或 \U:Unicode 字符

        • \:反斜杠自身

      • 在Go语言中,使用双引号书写字符串的方式是字符串常见表达方式之一,被称为字符串字面量(string literal),这种双引号字面量不能跨行,如果想要在源码中嵌入一个多行字符串时,就必须使用```反引号

        • const str = `第一行
          第二行
          第三行
          \r\n
          `
          fmt.Println(str)
    • Go语言的字符有以下两种:

      • 一种是 uint8 类型,或者叫 byte 型,代表了 ASCII 码的一个字符。

        • 在 ASCII 码表中,A 的值是 65,使用 16 进制表示则为 41,所以下面的写法是等效的:

          var ch byte = 65 或 var ch byte = '\x41' //(\x 总是紧跟着长度为 2 的 16 进制数)

          另外一种可能的写法是\后面紧跟着长度为 3 的八进制数,例如 \377

      • 另一种是 rune 类型,代表一个 UTF-8 字符,当需要处理中文、日文或者其他复合字符时,则需要用到 rune 类型。rune 类型等价于 int32 类型

        • Go语言同样支持 Unicode(UTF-8),因此字符同样称为 Unicode 代码点或者 runes,并在内存中使用 int 来表示。在文档中,一般使用格式 U+hhhh 来表示,其中 h 表示一个 16 进制数。

        • 在书写 Unicode 字符时,需要在 16 进制数之前加上前缀\u或者\U。因为 Unicode 至少占用 2 个字节,所以我们使用 int16 或者 int 类型来表示。如果需要使用到 4 字节,则使用\u前缀,如果需要使用到 8 个字节,则使用\U前缀。

      • var ch int = '\u0041'
        var ch2 int = '\u03B2'
        var ch3 int = '\U00101234'
        fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer
        fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character
        fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes
        fmt.Printf("%U - %U - %U", ch, ch2, ch3) ? // UTF-8 code point
        • 格式化说明符%c用于表示字符,当和字符配合使用时,%v%d会输出用于表示该字符的整数,%U输出格式为 U+hhhh 的字符串

        • Unicode 包中内置了一些用于测试字符的函数,这些函数的返回值都是一个布尔值,如下所示(其中 ch 代表字符):

          • 判断是否为字母:unicode.IsLetter(ch)

          • 判断是否为数字:unicode.IsDigit(ch)

          • 判断是否为空白符号:unicode.IsSpace(ch)

    • 类型 B 的值 = 类型 B(类型 A 的值)

      • valueOfTypeB = typeB(valueOfTypeA)

    • 指针(pointer)在Go语言中可以被拆分为两个核心概念:

      • 类型指针,允许对这个指针类型的数据进行修改,传递数据可以直接使用指针,而无须拷贝数据,类型指针不能进行偏移和运算。

      • 切片,由指向起始元素的原始指针、元素数量和容量组成

      • 每个变量在运行时都拥有一个地址,这个地址代表变量在内存中的位置。Go语言中使用在变量名前面添加&操作符(前缀)来获取变量的内存地址(取地址操作)

        • ptr := &v // v 的类型为 T

          • 其中 v 代表被取地址的变量,变量 v 的地址使用变量 ptr 进行接收,ptr 的类型为*T,称做 T 的指针类型,*代表指针

        • 量、指针和地址三者的关系是,每个变量都拥有地址,指针的值就是地址

        • 取地址操作符&和取值操作符*是一对互补操作符,&取出地址,*根据地址取出地址指向的值

        • 变量、指针地址、指针变量、取地址、取值的相互关系和特性如下:

          • 对变量进行取地址操作使用&操作符,可以获得这个变量的指针变量。

          • 指针变量的值是指针地址。

          • 对指针变量进行取值操作使用*操作符,可以获得指针变量指向的原变量的值。

        • Go语言还提供了另外一种方法来创建指针变量

          • new(类型)

        • 堆(heap):堆是用于存放进程执行中被动态分配的内存段。它的大小并不固定,可动态扩张或缩减。当进程调用 malloc 等函数分配内存时,新分配的内存就被动态加入到堆上(堆被扩张)。当利用 free 等函数释放内存时,被释放的内存从堆中被剔除(堆被缩减);

        • 栈(stack):栈又称堆栈, 用来存放程序暂时创建的局部变量,也就是我们函数的大括号{ }中定义的局部变量。

        • 在Go语言中,你可以省略类型说明符 [type],因为编译器可以根据变量的值来推断其类型。

          • 显式类型定义: const b string = "abc"

          • 隐式类型定义: const b = "abc"

文章来源:https://blog.csdn.net/qq_36379719/article/details/135247903
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。