基础语法·上(golang笔记第一期)

p.s.这是萌新自己自学总结的笔记，如果想学习得更透彻的话还是请去看大佬的讲解

目录

• [hello golang](#hello golang)
• 变量与常量声明
• 函数返回值
• import与init
• 指针
• defer
• 数组
• map

hello golang

package main  // 声明 main 包

import "fmt"  // 导入 fmt 包，用于输入输出
import "time" // 导入 time 包，用于获取当前时间
func main() {  // {  必须与函数名在同一行
    // 输出 Hello World!
    fmt.Println("Hello World!")
    
    // 格式化输出
    name := "张三"
    age := 13; //分号可加可不加

	time.Sleep(2 * time.Second) // 暂停 2 秒钟
    
    // 格式化输出
    fmt.Printf("你好，我叫 %s,今年 %d 岁！\n", name, age)

}

变量与常量声明

package main  

import "fmt"  
func main() { 
	var num int = 1145
	var str string = "Hello, World!"

	//可省去类型，编译器会自动推断
	var num2 = 2024
	
	//最简形式 :=  
	//注意: := 只能在函数内部使用，不能在函数外部即全局变量使用
	str2 := "Go is awesome!"
	num3 := 2024

	fmt.Println(num)
	fmt.Println(num2)
	fmt.Println(num3)//注意:go不允许没使用的变量存在，否则会编译错误
	fmt.Println(str)
	fmt.Println("文本:", str2)

	//多变量声明
	var a,b ="kskbl","zdjd"

	fmt.Println(a)
	fmt.Println(b)

	// 正确写法：只声明变量，代码写在 var() 外面
	var (
    c = "多变量声明"  // ✅ 用 = 而不是 :=
    d = 2024
)

// 然后使用它们
fmt.Println(c)
fmt.Println(d)
}

package main  

import "fmt"  
// 枚举
const(
	//可以使用iota来自动生成枚举值，iota在每个const块中从0开始递增,当然也可以对iota进行加减乘除等运算来生成不同的值
	//iota只能配合const()使用，不能单独使用
	SICHUAN = iota // SICHUAN的值为0
	CHONGQING       // CHONGQING的值为1
	BEIJING         // BEIJING的值为2
	SHANGHAI        // SHANGHAI的值为3
)

func main() { 
	const name string= "World"//常量
	fmt.Printf("Hello, %s!\n", name)
}

函数返回值

package main  

import "fmt"  


func main() { 
	fmt.Println("2 + 3 =", add1(2, 3))
	a,b := add2(2, 3)
	fmt.Println("2 + 3 =", a)
	fmt.Println("2 - 3 =", b)

	a1, a2 := add3(2, 3)
	fmt.Println("2 + 3 =", a1)
	fmt.Println("2 - 3 =", a2)
}

//返回单个值
func add1(x int, y int) int {
	return x + y
}

//返回多个值(返回值匿名)
func add2(x int, y int) (int, int) {
	return x + y, x - y
}

//返回多个值(返回值命名 有默认值)
func add3(x int, y int) (a1 int, a2 int) {
	a1 = x + y
	a2 = x - y
	return
}

import与init

package lib1

import "fmt"

func init(){
	fmt.Println("lib1 init")
}
func Lib1Test(){
	fmt.Println("lib1 test")
}

---------------------------------------------------------------

package main  

import "fmt"  
import "golang/src/lib/lib1"

import {
  _  "lib1"
  mylib  "lib1"//别名导包
}

func main() { 
	lib1.Lib1Test()
}

import _ "fmt"：给fmt包起一个别名，匿名，无法使用当前包的方法，但是会执行当前的包内部的init()方法

import aa "fmt"：给fmt包起一个别名，aa，aa.Println()来直接调用。

import . "fmt"：将当前fmt包中的全部方法，导入到当前本包的作用中，fmt包中的全部的方法可以直接使用API来调用，不需要fmt.API来调用

指针

package main
import "fmt"
func changeValue(p *int) {
*p = 10
}
func main() {
var a int = 1
changeValue(&a)

fmt.Println("a = ", a)
}

defer

package main
import "fmt"

func main() {
	//写入defer关键字
	defer fmt.Println("main end")//defer关键字会将其后面跟随的函数进行延迟处理，直到上层函数(即main函数)返回时才会执行被延迟的函数
	//defer本质为压栈与出栈
	//先执行return语句，返回值被保存到内存中，之后才会执行defer语句
	fmt.Println("main start")
}

数组

静态数组

package main
import "fmt"

func main() {
	//静态数组(固定长度)
	var arr [5]int
	for i := 0; i < len(arr); i++ {
		arr[i] = i + 1
		fmt.Println(arr[i])
	}

	arr2 := [10]int{1,2,3,4,5}
	for index, value := range arr2 {
		fmt.Printf("index: %d, value: %d\n", index, value)
	}
	//查看数据类型
	fmt.Printf("arr type: %T\n", arr)
	fmt.Printf("arr2 type: %T\n", arr2)

	//静态数组函数传参必须保证长度一致，并且还是值拷贝
	//这时可以用动态数组，即切片

}

动态数组、切片

package main

import "fmt"

func printArray(myArray []int) {
	//引用传递
	// _ 表示匿名的变量
	for _, value := range myArray {
		fmt.Println("value = ", value)
	}

	myArray[0] = 100
}

func main() {
	myArray := []int{1, 2, 3, 4} // 动态数组, 切片 slice

	fmt.Printf("myArray type is %T\n", myArray)

	printArray(myArray)
}

---------------------------------------------------------------------
package main

import "fmt"

func main() {
	slice := []int{1,2,3}
	fmt.Println(len(slice))

	//开辟五个空间,默认值为0
	var slice1 = make([]int, 5)
	slice1[0] = 1
	fmt.Println(slice1)
-----------------------------------------------------
package main

import "fmt"

func main() {

// 创建一个长度为3，容量为5的切片
var arr = make([]int,3,4)
fmt.Printf("len=%d cap=%d arr=%v\n",len(arr),cap(arr),arr)

//追加元素
arr = append(arr,1)
fmt.Printf("len=%d cap=%d arr=%v\n",len(arr),cap(arr),arr)

// 再添加一个元素，容量会自动扩容,通常是两倍
}
}

---------------------------------------------------------------------
package main

import "fmt"

func main() {
	s := []int{1, 2, 3}//len=3, cap=3

	s1 := s[0:2]//前闭后开区间

	fmt.Println(s1)

	s1[0] = 100

	fmt.Println(s)
	fmt.Println(s1)

	s2 := make([]int,6)

	copy(s2, s)
	fmt.Println(s2)
}

map

package main

import "fmt"

func main() {
var myMap1 map[string]string
if myMap1 == nil {
    fmt.Println("myMap1 是一个空map")
}

//在使用map前， 需要先用make给map分配数据空间
myMap1 = make(map[string]string, 10)

myMap1["one"] = "1"
myMap1["two"] = "2"
myMap1["three"] = "3"

fmt.Println(myMap1)

//===> 第二种声明方式
myMap2 := make(map[int]string)
myMap2[1] = "111"
myMap2[2] = "222"
myMap2[3] = "333"

fmt.Println(myMap2)

//===> 第三种声明方式
myMap3 := map[string]string{
    "one":   "php",
    "two":   "c++",
    "three": "python",
}
}

package main

import "fmt"

func main() {
	cityMap := make(map[string]string)

	//添加
	cityMap["NY"] = "New York"
	cityMap["LA"] = "Los Angeles"
	cityMap["CHI"] = "Chicago"

	//遍历
	for key, value := range cityMap {
		fmt.Printf("Key: %s, Value: %s\n", key, value)
	}

	//删除
	delete(cityMap, "LA")

	//修改
	cityMap["NY"] = "NYC"

	//再次遍历
	for key, value := range cityMap {
		fmt.Printf("Key: %s, Value: %s\n", key, value)
	}
}