最近被golang获取日期搞得十分头大,语言自带的方式简直反人类

所以我自己开发了一个项目

go get github.com/wang-sitong/d

import (
    "github.com/wang-sitong/d"
)
func main() {
    // "2024-02-19 14:25:22" 当前时间
    date := d.Date()
    // "2024-02-20 15:38:49" 明天
    date = d.Date("Y-m-d H:i:s", 1)
    // "2024-02-18 15:39:24" 昨天
    date = d.Date("Y-m-d H:i:s", -1)
    // "2024" 年
    date = d.Date("Y") 
    // "02" 月
    date = d.Date("m")
    // "19" 日
    date = d.Date("d")
    // "15" 时
    date = d.Date("H")
    // "42" 分
    date = d.Date("i")
    // "25" 秒
    date = d.Date("s")
}

这下终于想怎么取就怎么取了

# X86
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o new_name main.go
 
# ARM
CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build main.go

# X86
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build main.go
 
# ARM
CGO_ENABLED=0 GOOS=windows GOARCH=arm64 go build main.go


# X86
CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build main.go
 
# ARM
CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build main.go

值类型
包括：基本数据类型 int、float、bool、string；数组、结构体struct
声明一个值类型的变量，变量直接存储的是值，内存通常在 栈 上分配

引用类型
包括：指针、切片slice、map、管道channel、interface
声明一个引用类型的变量，变量存储的是一个地址，这个地址对应的内存空间中存储的才是具体的值，内存通常在 堆 上分配，当没有任何变量引用这个地址的时候，该地址对应的内存空间会被 GC 回收

基本数据类型

var a int //声明一个int类型的变量

var b struct { //声明一个结构体
    Name string
}

var a = 8 //声明变量的同时赋值,编译器自动推导其数据类型

var a int = 8 //声明变量的同时赋值

var { //批量声明变量,简洁
    a int
    b string
}
var (
    a int
    b bool
    xx,yy,dd string="xx","yy","dd"
    //这里省略变量类型也是可以的.
    zz,aa="zz","aa"
)
//已声明,但未使用
var a=1
//标识为已抛弃的变量.未使用的变量编译会报错
_=a
//简化方法，:=无法定义全局变量

var tmpStr = ""
var tmpStr string = ""
tmpStr :=""

复杂数据类型

//数组
var a [3]intname [nums]type
r := [...]int{99 ：-1}
//数组长度位置出现省略号表示由初始化元素个数来确定长度。
//数组长度是类型的一部分（不同长度类型不同编译会发生报错），数组长度必须是常量表达式。
//如果一个数组元素类型可以比较，那数组之间可以比较。
//使用数组指针是高效的。

//slice切片
//一个拥有相同类型元素的可变长序列。通常写作[ ]T。它看上去像没有长度的数组类型。切片是一个很小的对象，对底层数组 进行了抽象。
//轻量级数据结构，可以用来访问数组部分或全部元素，而这个数组称为slice的底层数组。
//slice三个特性：长度 容量 指针。指针指向数组的第一个可访问的元素。
//因为slice包含了指向数组的指针，所以将一个slice传递给函数的时候，可以在函数内部修改底层数组的元素。
//创建和初始化：make([]type,len,cap)。如果只有len，则len=cap。
//另一种是切片字面量声明：slice := [ ]string{"1","2","3"}
//切片也可以像数组一样使用索引声明slice := []int{99 ：-1}

slice :=[]int{10,20,30,40} //len=cap=4
append(slice, 50)

//需要复制所有的值到新数组 len=4 cap=4*2
// append扩展容量的算法：cap<1000成倍增加，大于1000,1.25倍增加。
//创建切片时可以使用三个索引：slice := source[i:j:k]

source :=[]string{"a","b","c","d","e"}
slice := source[2:3:4]

package main
import "fmt"

func main() {

    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := slice1[2:3]
    slice2 = append(slice2, 6)

    fmt.Printf("%v", slice1)
    fmt.Printf("%v", slice2)

}