GO语言基础笔记(一):基本语法与数据类型

基本语法

  1. 变量声明

    • 使用 var 关键字,如 var x int 声明一个整型变量 x
    • 简短声明方式,如 y := 0 直接初始化 y
  2. 函数定义

    • 使用 func 关键字定义函数,如 func add(a int, b int) int { return a + b }
  3. 控制结构

    • if 语句、for 循环等,语法类似于其他编程语言。
  4. 导入包

    • 使用 import 关键字导入包,如 import "fmt"
package main // 定义包名,每个Go程序都是由包组成的

import "fmt" // 导入fmt包,用于格式化输出

// main函数是每个可执行程序的入口点
func main() {
    var x int = 10 // 使用var关键字声明一个整型变量x并初始化为10
    y := 20        // 简短声明方式,声明并初始化变量y为20

    sum := add(x, y) // 调用add函数,传入x和y作为参数
    fmt.Println("Sum:", sum) // 使用fmt包的Println函数打印结果

    // 使用for循环从1加到10
    for i := 1; i <= 10; i++ {
        fmt.Println(i)
    }

    // 使用if语句判断sum是否大于20
    if sum > 20 {
        fmt.Println("Sum is greater than 20")
    } else {
        fmt.Println("Sum is less than or equal to 20")
    }
}

// add函数接收两个int类型的参数,并返回它们的和
// 函数返回值的类型定义在参数列表之后
func add(a int, b int) int {
    return a + b // 返回a和b的和
}

数据类型

基本类型

  1. 整型(Integers)

    • 有符号整型:int8, int16, int32, int64
    • 无符号整型:uint8 (或 byte), uint16, uint32, uint64
    • 通用整型:int, uint(大小依赖于实现,通常为32或64位)
    • 特殊整型:uintptr(用于存储指针)
  2. 浮点型(Floats)

    • float32, float64
  3. 复数型(Complex Numbers)

    • complex64(32位实部和虚部),complex128(64位实部和虚部)
  4. 布尔型(Booleans)

    • bool(值为 truefalse
  5. 字符串(Strings)

    • string(使用双引号 "..." 或反引号 `...`

复合类型

  1. 数组(Arrays)

    • [4]int(含有4个整数的数组)
  2. 切片(Slices)

    • []int(整数的切片,长度可变)
  3. 结构体(Structs)

    • struct { Name string; Age int }
  4. 映射(Maps)

    • map[string]int(键为字符串,值为整数的映射)

引用类型

  1. 指针(Pointers)

    • *int(指向整数的指针)
  2. 切片(Slices)

    • 如前所述,切片是引用类型。
  3. 映射(Maps)

    • 如前所述,映射是引用类型。
  4. 通道(Channels)

    • 用于在不同Goroutines间进行通信,如 chan int
  5. 函数类型(Function Types)

    • func(int) bool(接收一个整数参数,返回布尔值的函数)

接口类型(Interfaces)

  • interface{}(空接口,可以持有任何类型的值)

类型代码示例:

package main

import (
	"fmt"
	"math/cmplx"
	"unsafe"
)

// 定义一个结构体
type Person struct {
	Name string
	Age  int
}

// 定义一个接口
type Geometry interface {
	area() float64
}

// 主函数
func main() {
	// 整型
	var a int8 = 127
	var b uint16 = 65535
	var c int = 10000
	var ptr uintptr = uintptr(unsafe.Pointer(&c))

	// 浮点型
	var d float32 = 3.14
	var e float64 = 2.71828

	// 复数型
	var f complex64 = complex(5, 12)
	var g complex128 = cmplx.Sqrt(-5 + 12i)

	// 布尔型
	var h bool = true

	// 字符串
	var i string = "Hello, Go!"

	// 数组
	var j [4]int = [4]int{1, 2, 3, 4}

	// 切片
	k := []int{5, 6, 7, 8}

	// 结构体
	l := Person{Name: "Alice", Age: 30}

	// 映射
	m := map[string]int{"one": 1, "two": 2}

	// 指针
	n := &c

	// 通道
	o := make(chan int)

	// 函数类型
	var p func(int) bool = func(x int) bool {
		return x%2 == 0
	}

	// 接口
	var q Geometry = l

	// 打印变量值
	fmt.Println("int8:", a)
	fmt.Println("uint16:", b)
	fmt.Println("int:", c)
	fmt.Println("uintptr:", ptr)
	fmt.Println("float32:", d)
	fmt.Println("float64:", e)
	fmt.Println("complex64:", f)
	fmt.Println("complex128:", g)
	fmt.Println("bool:", h)
	fmt.Println("string:", i)
	fmt.Println("array:", j)
	fmt.Println("slice:", k)
	fmt.Println("struct:", l)
	fmt.Println("map:", m)
	fmt.Println("pointer:", *n)
	fmt.Println("function:", p(10))
	fmt.Println("interface:", q.area())

	// 使用通道
	go func() {
		o <- 123
	}()
	fmt.Println("channel:", <-o)
}

// 实现Person类型的area方法
func (p Person) area() float64 {
	return float64(p.Age) // 随意计算的“面积”
}

你可能感兴趣的:(Go,golang,笔记,开发语言)