golang：时间转换总结

男娘i 2022-04-02 21:06 955阅读 0赞

# 判断是不是星期天 #

package main
    
    import "fmt"
    
    var weekday = [7]string{
        "周日", "周一", "周二", "周三", "周四", "周五", "周六"}
    
    func main() {
        
    
    	var a, b, c uint16 = 2020, 4, 3
    
    	fmt.Printf("%d年%d月%d日是:%s\n", a, b, c, ZellerFunction2Week(a, b, c))
    
    }
    
    func ZellerFunction2Week(year, month, day uint16) string {
        
    
    	var y, m, c uint16
    
    	if month >= 3 {
        
    
    		m = month
    
    		y = year % 100
    
    		c = year / 100
    
    	} else {
        
    
    		m = month + 12
    
    		y = (year - 1) % 100
    
    		c = (year - 1) / 100
    
    	}
    
    	week := y + (y / 4) + (c / 4) - 2*c + ((26 * (m + 1)) / 10) + day - 1
    
    	if week < 0 {
        
    
    		week = 7 - (-week)%7
    
    	} else {
        
    
    		week = week % 7
    
    	}
    
    	which_week := int(week)
    
    	return weekday[which_week]
    
    }

# 求两个日期的间隔天数 #

func timeSub(t1, t2 time.Time) int {
        
    	t1 = time.Date(t1.Year(), t1.Month(), t1.Day(), 0, 0, 0, 0, time.Local)
    	t2 = time.Date(t2.Year(), t2.Month(), t2.Day(), 0, 0, 0, 0, time.Local)
    
    	return int(t1.Sub(t2).Hours() / 24)
    }
    func TimeTest(){
        
    	t1 := time.Date(2019, 12, 1, 12, 0, 0, 0, time.Local)
    	t2 := time.Date(2019, 11, 1, 12, 0, 0, 0, time.Local)
    	fmt.Println("just one day: should return 1 but got %v", timeSub(t1, t2))
    }

# golang的time包：秒、毫秒、纳秒时间戳输出 #

菜鸟的时候只知道时间戳有10位、13位、还有好长位数的。
    
    入坑久了才明白
    10位数的时间戳是以 秒 为单位；
    13位数的时间戳是以 毫秒 为单位；
    19位数的时间戳是以 纳秒 为单位；
    
    golang中可以这样写：
    ```go
    package main
    
    import (
    	"time"
    	"fmt"
    )
    
    func main() {
    	fmt.Printf("时间戳（秒）：%v;\n", time.Now().Unix())
    	fmt.Printf("时间戳（纳秒）：%v;\n",time.Now().UnixNano())
    	fmt.Printf("时间戳（毫秒）：%v;\n",time.Now().UnixNano() / 1e6)
    	fmt.Printf("时间戳（纳秒转换为秒）：%v;\n",time.Now().UnixNano() / 1e9)
    }

输出结果为：

时间戳（秒）：1530027865;
    时间戳（纳秒）：1530027865231834600;
    时间戳（毫秒）：1530027865231;
    时间戳（纳秒转换为秒）：1530027865;

作者：oOMirageOo  
原文：https://blog.csdn.net/mirage003/article/details/80822608

# 获取今天是本年第几周
    ```go
    package main
    
    import (
    	"fmt"
    	"time"
    )
    
    func week_of_year()(int){
    	yearDay := time.Now().YearDay()
    	week := yearDay / 7
    	yu := yearDay % 7
    	if yu == 0{
    		return week
    	}
    	return week + 1
    }
    func main() {
    	fmt.Println(week_of_year())
    }

# 日期格式化为字符串 #

1.1、获取当前时间并转换为一定格式的字符串

func main(){
        
    	//日期格式化为字符串
    	t := time.Now().Format("2006-01-02 15:04:05")
    	fmt.Println(t, reflect.TypeOf(t))  //2018-12-21 14:17:04 string
    
    	t = time.Now().Format("2006-01-02 ")
    	fmt.Println(t, reflect.TypeOf(t))  //2018-12-21   string
    
    	t = time.Now().Format("2006/01/02 ")
    	fmt.Println(t, reflect.TypeOf(t))  // 2018/12/21  string
    
    	t = time.Now().Format("2006\\01\\02")   //注意2018\12\21会报错，在go中如果想要输出\----->\\
    	fmt.Println(t, reflect.TypeOf(t))  //2018\12\21   string
    }

# 获取本月的第一天、最后一天 #

//获取传入的时间所在月份的第一天，即某月第一天的0点。如传入time.Now(), 返回当前月份的第一天0点时间。
    func GetFirstDateOfMonth(d time.Time) time.Time {
        
    	d = d.AddDate(0, 0, -d.Day() + 1)
    	return GetZeroTime(d)
    }
    //获取传入的时间所在月份的最后一天，即某月最后一天的0点。如传入time.Now(), 返回当前月份的最后一天0点时间。
    func GetLastDateOfMonth(d time.Time) time.Time {
        
    	return GetFirstDateOfMonth(d).AddDate(0, 1, -1)
    }
    
    //获取某一天的0点时间
    func GetZeroTime(d time.Time) time.Time {
        
    	return time.Date(d.Year(), d.Month(), d.Day(), 0, 0, 0, 0, d.Location())
    }
    
    func main() {
        
    	d := time.Now()
    
    	fmt.Println( GetFirstDateOfMonth(d))
    	fmt.Println( GetFirstDateOfMonth(d))
    	fmt.Println( GetLastDateOfMonth(d))
    	
    }

# 今天是星期几 #

d := time.Now()
    
    	fmt.Println(int(d.Weekday()))

# golang 获取指定年份中的所有天数 #

func main() {
        
    	days := make([]string, 0)
    
    	year := time.Now().Year()
    
    	for month := 1; month <= 12; month++ {
        
    		for day := 1; day <= 31; day++ {
        
    			//如果是2月
    			if month == 2 {
        
    				if isLeapYear(year) && day == 30 {
         //闰年2月29天
    					break
    				} else if !isLeapYear(year) && day == 29 {
         //平年2月28天
    					break
    				} else {
        
    					days = append(days, fmt.Sprintf("%d-%02d-%02d", year, month, day))
    				}
    			} else if month == 4 || month == 6 || month == 9 || month == 11 {
         //小月踢出来
    				if day == 31 {
        
    					break
    				}
    				days = append(days, fmt.Sprintf("%d-%02d-%02d", year, month, day))
    			} else {
        
    				days = append(days, fmt.Sprintf("%d-%02d-%02d", year, month, day))
    			}
    		}
    	}
    
    	fmt.Println(days)
    
    }

## 万年历 ##

package main
     
    import (
    	"flag"
    	"fmt"
    	"os"
    )
     
    var year int
    var month int
    var fs *flag.FlagSet
    var showVersion, showUsage bool
     
    func init() {
        
    	//初始化解析参数
    	fs = flag.NewFlagSet("calendar", flag.ExitOnError)
    	fs.BoolVar(&showUsage, "help", false, "Show this message")
    	fs.BoolVar(&showUsage, "h", false, "Show this message")
    	fs.BoolVar(&showVersion, "version", false, "Print version information.")
    	fs.BoolVar(&showVersion, "v", false, "Print version information.")
     
    	fs.IntVar(&year, "year", 2019, "Input year.")
    	fs.IntVar(&year, "y", 2019, "Input year.")
    	fs.IntVar(&month, "month", 8, "Input month.")
    	fs.IntVar(&month, "m", 8, "Input month.")
    }
     
    func perpetualCalendar(year int, month int) {
        
    	var monthDays int = 0
    	var totalDyas int = 0
    	var isLeapYear bool = false
    	fmt.Println("query date is:", year, month)
     
    	if year%400 == 0 || (year%4 == 0 && year%100 != 0) {
        
    		isLeapYear = true
    		fmt.Println(year, "is leap year")
    	} else {
        
    		isLeapYear = false
    		fmt.Println(year, "is not lear year")
    	}
     
    	//计算距离1900年的天数
    	for i := 1900; i < year; i++ {
        
    		if i%400 == 0 || (i%4 == 0 && i%100 != 0) {
        
    			totalDyas += 366
    		} else {
        
    			totalDyas += 365
    		}
    	}
     
    	//计算截至到当月1号前的总天数
    	for j := 1; j <= month; j++ {
        
    		switch j {
        
    		case 1, 3, 5, 7, 8, 10, 12:
    			monthDays = 31
    			break
    		case 2:
    			if isLeapYear {
        
    				monthDays = 29
    			} else {
        
    				monthDays = 28
    			}
    			break
    		case 4, 6, 9, 11:
    			monthDays = 30
    			break
    		default:
    			fmt.Println("input month is error.")
    		}
     
    		if j != month {
        
    			totalDyas += monthDays
    		}
    	}
     
    	//计算当月1号是星期几
    	var weekDay int = 0
    	weekDay = 1 + totalDyas%7
    	if weekDay == 7 {
        
    		weekDay = 0
    	}
     
    	fmt.Println("weekDay is: ", weekDay)
     
    	//展示日期
    	fmt.Println("星期日\t" + "星期一\t" + "星期二\t" + "星期三\t" + "星期四\t" + "星期五\t" + "星期六\t")
    	for k := 0; k < weekDay; k++ {
        
    		fmt.Printf("\t")
    	}
     
    	for m := 1; m <= monthDays; m++ {
        
    		fmt.Printf("%d\t", m)
    		if (weekDay+m)%7 == 0 {
        
    			fmt.Println()
    		}
    	}
    	fmt.Println()
    }
     
    func main() {
        
    	//开启main 函数的解析功能
    	fs.Parse(os.Args[1:])
    	if showUsage {
        
    		fs.PrintDefaults()
    		os.Exit(0)
    	}
    	if showVersion {
        
    		fmt.Println("version:v1.0")
    		os.Exit(0)
    	}
    	perpetualCalendar(year, month)

原文：https://blog.csdn.net/qq\_21794823/article/details/86098594

# 获取本周周一 #

func main() {
        
    	now := time.Now()
    
    	offset := int(time.Monday - now.Weekday())
    	if offset > 0 {
        
    		offset = -6
    	}
    
    	weekStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, offset)
    	fmt.Println(weekStart)
    
    	
    
    }

# 获取前N周 #

func SetXWeek(x int){
        
    	now := time.Now()
    
    	offset := int(time.Monday - now.Weekday())
    	if offset > 0 {
        
    		offset = -6
    	}
    
    	thisMon := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, offset)
    
    	xMon := thisMon.AddDate(0, 0, -7*x).Format("20060102150405")
    	xSun := thisMon.AddDate(0, 0, -7*x+6).Format("20060102150405")
    
    	fmt.Printf(xMon, xSun)
    }

# 获取前10分钟 #

time.Now().Add(-time.Minute * 10)

# 格林时间转换普通时间 #

func main() {
        
    
    	strTime := "2018-03-24T20:01:00+08:00"
    	t, err := time.ParseInLocation("2006-01-02T15:04:05+08:00", strTime, time.Local)
    	fmt.Println(t, err)
    
    	strTime = strTime[:len(strTime)-6]
    	t, err = time.ParseInLocation("2006-01-02T15:04:05", strTime, time.Local)
    	fmt.Println(t, err, )
    
    
    	b := t.String()
    	fmt.Println(b[:20])
    }