golang的时区和神奇的time.Parse

最新推荐文章于 2022-10-09 00:17:59 发布
最新推荐文章于 2022-10-09 00:17:59 发布
阅读量579 收藏
点赞数
文章标签： golang
原文链接：https://yq.aliyun.com/articles/644751
版权

时区

先写一段测试代码：

 1const TIME_LAYOUT = "2006-01-02 15:04:05"
 2
 3func parseWithLocation(name string, timeStr string) (time.Time, error) {
 4    locationName := name
 5    if l, err := time.LoadLocation(locationName); err != nil {
 6        println(err.Error())
 7        return time.Time{}, err
 8    } else {
 9        lt, _ := time.ParseInLocation(TIME_LAYOUT, timeStr, l)
10        fmt.Println(locationName, lt)
11        return lt, nil
12    }
13}
14func testTime() {
15    fmt.Println("0. now: ", time.Now())
16    str := "2018-09-10 00:00:00"
17    fmt.Println("1. str: ", str)
18    t, _ := time.Parse(TIME_LAYOUT, str)
19    fmt.Println("2. Parse time: ", t)
20    tStr := t.Format(TIME_LAYOUT)
21    fmt.Println("3. Format time str: ", tStr)
22    name, offset := t.Zone()
23    name2, offset2 := t.Local().Zone()
24    fmt.Printf("4. Zone name: %v, Zone offset: %v\n", name, offset)
25    fmt.Printf("5. Local Zone name: %v, Local Zone offset: %v\n", name2, offset2)
26    tLocal := t.Local()
27    tUTC := t.UTC()
28    fmt.Printf("6. t: %v, Local: %v, UTC: %v\n", t, tLocal, tUTC)
29    fmt.Printf("7. t: %v, Local: %v, UTC: %v\n", t.Format(TIME_LAYOUT), tLocal.Format(TIME_LAYOUT), tUTC.Format(TIME_LAYOUT))
30    fmt.Printf("8. Local.Unix: %v, UTC.Unix: %v\n", tLocal.Unix(), tUTC.Unix())
31    str2 := "1969-12-31 23:59:59"
32    t2, _ := time.Parse(TIME_LAYOUT, str2)
33    fmt.Printf("9. str2：%v，time: %v, Unix: %v\n", str2, t2, t2.Unix())
34    fmt.Printf("10. %v, %v\n", tLocal.Format(time.ANSIC), tUTC.Format(time.ANSIC))
35    fmt.Printf("11. %v, %v\n", tLocal.Format(time.RFC822), tUTC.Format(time.RFC822))
36    fmt.Printf("12. %v, %v\n", tLocal.Format(time.RFC822Z), tUTC.Format(time.RFC822Z))
37
38    //指定时区
39    parseWithLocation("America/Cordoba", str)
40    parseWithLocation("Asia/Shanghai", str)
41    parseWithLocation("Asia/Beijing", str)
42}
43testTime()

输出：

 10. now:  2018-09-19 19:06:07.3642781 +0800 CST m=+0.005995601
 21. str:  2018-09-10 00:00:00
 32. Parse time:  2018-09-10 00:00:00 +0000 UTC
 43. Format time str:  2018-09-10 00:00:00
 54. Zone name: UTC, Zone offset: 0
 65. Local Zone name: CST, Local Zone offset: 28800
 76. t: 2018-09-10 00:00:00 +0000 UTC, Local: 2018-09-10 08:00:00 +0800 CST, UTC: 2018-09-10 00:00:00 +0000 UTC
 87. t: 2018-09-10 00:00:00, Local: 2018-09-10 08:00:00, UTC: 2018-09-10 00:00:00
 98. Local.Unix: 1536537600, UTC.Unix: 1536537600
109. str2：1969-12-31 23:59:59，time: 1969-12-31 23:59:59 +0000 UTC, Unix: -1
1110. Mon Sep 10 08:00:00 2018, Mon Sep 10 00:00:00 2018
1211. 10 Sep 18 08:00 CST, 10 Sep 18 00:00 UTC
1312. 10 Sep 18 08:00 +0800, 10 Sep 18 00:00 +0000
14America/Cordoba 2018-09-10 00:00:00 -0300 -03
15Asia/Shanghai 2018-09-10 00:00:00 +0800 CST
16cannot find Asia/Beijing in zip file C:\Go\/lib/time/zoneinfo.zip

从以上代码的测试结果可以得出几点：

 ●  time.Now 得到的当前时间的时区跟电脑的当前时区一样。
 ●  time.Parse 把时间字符串转换为Time，时区是UTC时区。
 ●  不管Time变量存储的是什么时区，其Unix()方法返回的都是距离UTC时间：1970年1月1日0点0分0秒的秒数。
 ●  Unix()返回的秒数可以是负数，如果时间小于1970-01-01 00:00:00的话。
 ●  Zone方法可以获得变量的时区和时区与UTC的偏移秒数，应该支持夏令时和冬令时。
 ●  time.LoadLocation可以根据时区名创建时区Location，所有的时区名字可以在$GOROOT/lib/time/zoneinfo.zip文件中找到，解压zoneinfo.zip可以得到一堆目录和文件，我们只需要目录和文件的名字，时区名是目录名+文件名，比如"Asia/Shanghai"。中国时区名只有"Asia/Shanghai"和"Asia/Chongqing"，而没有"Asia/Beijing"。
 ●  time.ParseInLocation可以根据时间字符串和指定时区转换Time。

 ●  感谢中国只有一个时区而且没有夏令时和冬令时，可怕的美国居然有6个时区，想想都可怕。

神奇的time.Parse

一开始使用time.Parse时很不习惯，因为非常奇怪的layout参数。
除了golang自带定义的layout：

 1const (
 2    ANSIC       = "Mon Jan _2 15:04:05 2006"
 3    UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
 4    RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
 5    RFC822      = "02 Jan 06 15:04 MST"
 6    RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
 7    RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
 8    RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
 9    RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
10    RFC3339     = "2006-01-02T15:04:05Z07:00"
11    RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
12    Kitchen     = "3:04PM"
13    // Handy time stamps.
14    Stamp      = "Jan _2 15:04:05"
15    StampMilli = "Jan _2 15:04:05.000"
16    StampMicro = "Jan _2 15:04:05.000000"
17    StampNano  = "Jan _2 15:04:05.000000000"
18)

还可以自定义layout，比如：

1"2006-01-02 15:04:05"

网上基本上都在传说这个日子是golang项目开始创建的时间，为了纪念生日才这样设计，其实这真是无稽之谈瞎扯淡。
网上文章没有找到说的比较清楚的，幸好有源码，打开time.Parse的源码看了一下，发现这个设计很好很科学。
解析layout的主要代码在nextStdChunk方法中：

  1// nextStdChunk finds the first occurrence of a std string in
  2// layout and returns the text before, the std string, and the text after.
  3func nextStdChunk(layout string) (prefix string, std int, suffix string) {
  4    for i := 0; i < len(layout); i++ {
  5        switch c := int(layout[i]); c {
  6        case 'J': // January, Jan
  7            if len(layout) >= i+3 && layout[i:i+3] == "Jan" {
  8                if len(layout) >= i+7 && layout[i:i+7] == "January" {
  9                    return layout[0:i], stdLongMonth, layout[i+7:]
 10                }
 11                if !startsWithLowerCase(layout[i+3:]) {
 12                    return layout[0:i], stdMonth, layout[i+3:]
 13                }
 14            }
 15
 16        case 'M': // Monday, Mon, MST
 17            if len(layout) >= i+3 {
 18                if layout[i:i+3] == "Mon" {
 19                    if len(layout) >= i+6 && layout[i:i+6] == "Monday" {
 20                        return layout[0:i], stdLongWeekDay, layout[i+6:]
 21                    }
 22                    if !startsWithLowerCase(layout[i+3:]) {
 23                        return layout[0:i], stdWeekDay, layout[i+3:]
 24                    }
 25                }
 26                if layout[i:i+3] == "MST" {
 27                    return layout[0:i], stdTZ, layout[i+3:]
 28                }
 29            }
 30
 31        case '0': // 01, 02, 03, 04, 05, 06
 32            if len(layout) >= i+2 && '1' <= layout[i+1] && layout[i+1] <= '6' {
 33                return layout[0:i], std0x[layout[i+1]-'1'], layout[i+2:]
 34            }
 35
 36        case '1': // 15, 1
 37            if len(layout) >= i+2 && layout[i+1] == '5' {
 38                return layout[0:i], stdHour, layout[i+2:]
 39            }
 40            return layout[0:i], stdNumMonth, layout[i+1:]
 41
 42        case '2': // 2006, 2
 43            if len(layout) >= i+4 && layout[i:i+4] == "2006" {
 44                return layout[0:i], stdLongYear, layout[i+4:]
 45            }
 46            return layout[0:i], stdDay, layout[i+1:]
 47
 48        case '_': // _2, _2006
 49            if len(layout) >= i+2 && layout[i+1] == '2' {
 50                //_2006 is really a literal _, followed by stdLongYear
 51                if len(layout) >= i+5 && layout[i+1:i+5] == "2006" {
 52                    return layout[0 : i+1], stdLongYear, layout[i+5:]
 53                }
 54                return layout[0:i], stdUnderDay, layout[i+2:]
 55            }
 56
 57        case '3':
 58            return layout[0:i], stdHour12, layout[i+1:]
 59
 60        case '4':
 61            return layout[0:i], stdMinute, layout[i+1:]
 62
 63        case '5':
 64            return layout[0:i], stdSecond, layout[i+1:]
 65
 66        case 'P': // PM
 67            if len(layout) >= i+2 && layout[i+1] == 'M' {
 68                return layout[0:i], stdPM, layout[i+2:]
 69            }
 70
 71        case 'p': // pm
 72            if len(layout) >= i+2 && layout[i+1] == 'm' {
 73                return layout[0:i], stdpm, layout[i+2:]
 74            }
 75
 76        case '-': // -070000, -07:00:00, -0700, -07:00, -07
 77            if len(layout) >= i+7 && layout[i:i+7] == "-070000" {
 78                return layout[0:i], stdNumSecondsTz, layout[i+7:]
 79            }
 80            if len(layout) >= i+9 && layout[i:i+9] == "-07:00:00" {
 81                return layout[0:i], stdNumColonSecondsTZ, layout[i+9:]
 82            }
 83            if len(layout) >= i+5 && layout[i:i+5] == "-0700" {
 84                return layout[0:i], stdNumTZ, layout[i+5:]
 85            }
 86            if len(layout) >= i+6 && layout[i:i+6] == "-07:00" {
 87                return layout[0:i], stdNumColonTZ, layout[i+6:]
 88            }
 89            if len(layout) >= i+3 && layout[i:i+3] == "-07" {
 90                return layout[0:i], stdNumShortTZ, layout[i+3:]
 91            }
 92
 93        case 'Z': // Z070000, Z07:00:00, Z0700, Z07:00,
 94            if len(layout) >= i+7 && layout[i:i+7] == "Z070000" {
 95                return layout[0:i], stdISO8601SecondsTZ, layout[i+7:]
 96            }
 97            if len(layout) >= i+9 && layout[i:i+9] == "Z07:00:00" {
 98                return layout[0:i], stdISO8601ColonSecondsTZ, layout[i+9:]
 99            }
100            if len(layout) >= i+5 && layout[i:i+5] == "Z0700" {
101                return layout[0:i], stdISO8601TZ, layout[i+5:]
102            }
103            if len(layout) >= i+6 && layout[i:i+6] == "Z07:00" {
104                return layout[0:i], stdISO8601ColonTZ, layout[i+6:]
105            }
106            if len(layout) >= i+3 && layout[i:i+3] == "Z07" {
107                return layout[0:i], stdISO8601ShortTZ, layout[i+3:]
108            }
109
110        case '.': // .000 or .999 - repeated digits for fractional seconds.
111            if i+1 < len(layout) && (layout[i+1] == '0' || layout[i+1] == '9') {
112                ch := layout[i+1]
113                j := i + 1
114                for j < len(layout) && layout[j] == ch {
115                    j++
116                }
117                // String of digits must end here - only fractional second is all digits.
118                if !isDigit(layout, j) {
119                    std := stdFracSecond0
120                    if layout[i+1] == '9' {
121                        std = stdFracSecond9
122                    }
123                    std |= (j - (i + 1)) << stdArgShift
124                    return layout[0:i], std, layout[j:]
125                }
126            }
127        }
128    }
129    return layout, 0, ""
130}

可以发现layout的所有代表年月日时分秒甚至时区的值都是互斥不相等的。

比如年份：短年份06，长年份2006，

月份：01，Jan，January

日：02，2，_2

时：15，3，03

分：04， 4

秒：05， 5

因为都不相等所以通过遍历layout就可以switch case解析出每个区块的意义和在字符串中的位置，这样输入对应格式的时间字符串就可以顺利解析出来。
这样layout也可以自定义，而且顺序任意，只要符合下列每个区块定义的规则即可，
代码中的注释就是规则写法：

 1const (
 2    _                        = iota
 3    stdLongMonth             = iota + stdNeedDate  // "January"
 4    stdMonth                                       // "Jan"
 5    stdNumMonth                                    // "1"
 6    stdZeroMonth                                   // "01"
 7    stdLongWeekDay                                 // "Monday"
 8    stdWeekDay                                     // "Mon"
 9    stdDay                                         // "2"
10    stdUnderDay                                    // "_2"
11    stdZeroDay                                     // "02"
12    stdHour                  = iota + stdNeedClock // "15"
13    stdHour12                                      // "3"
14    stdZeroHour12                                  // "03"
15    stdMinute                                      // "4"
16    stdZeroMinute                                  // "04"
17    stdSecond                                      // "5"
18    stdZeroSecond                                  // "05"
19    stdLongYear              = iota + stdNeedDate  // "2006"
20    stdYear                                        // "06"
21    stdPM                    = iota + stdNeedClock // "PM"
22    stdpm                                          // "pm"
23    stdTZ                    = iota                // "MST"
24    stdISO8601TZ                                   // "Z0700"  // prints Z for UTC
25    stdISO8601SecondsTZ                            // "Z070000"
26    stdISO8601ShortTZ                              // "Z07"
27    stdISO8601ColonTZ                              // "Z07:00" // prints Z for UTC
28    stdISO8601ColonSecondsTZ                       // "Z07:00:00"
29    stdNumTZ                                       // "-0700"  // always numeric
30    stdNumSecondsTz                                // "-070000"
31    stdNumShortTZ                                  // "-07"    // always numeric
32    stdNumColonTZ                                  // "-07:00" // always numeric
33    stdNumColonSecondsTZ                           // "-07:00:00"
34    stdFracSecond0                                 // ".0", ".00", ... , trailing zeros included
35    stdFracSecond9                                 // ".9", ".99", ..., trailing zeros omitted
36
37    stdNeedDate  = 1 << 8             // need month, day, year
38    stdNeedClock = 2 << 8             // need hour, minute, second
39    stdArgShift  = 16                 // extra argument in high bits, above low stdArgShift
40    stdMask      = 1<<stdArgShift - 1 // mask out argument
41)

时区：
时区使用：MST
时区偏移使用-0700或者Z0700等等。
下面是一个使用时区的例子，Z0700比较特殊，当输入时间直接使用Z时就直接代表UTC时区。

 1func testTimeParse() {
 2    t, _ := time.Parse("2006-01-02 15:04:05 -0700 MST", "2018-09-20 15:39:06 +0800 CST")
 3    fmt.Println(t)
 4    t, _ = time.Parse("2006-01-02 15:04:05 -0700 MST", "2018-09-20 15:39:06 +0000 CST")
 5    fmt.Println(t)
 6    t, _ = time.Parse("2006-01-02 15:04:05 Z0700 MST", "2018-09-20 15:39:06 +0800 CST")
 7    fmt.Println(t)
 8    t, _ = time.Parse("2006-01-02 15:04:05 Z0700 MST", "2018-09-20 15:39:06 Z GMT")
 9    fmt.Println(t)
10    t, _ = time.Parse("2006-01-02 15:04:05 Z0700 MST", "2018-09-20 15:39:06 +0000 GMT")
11    fmt.Println(t)
12}
13输出：
142018-09-20 15:39:06 +0800 CST
152018-09-20 15:39:06 +0000 CST
162018-09-20 15:39:06 +0800 CST
172018-09-20 15:39:06 +0000 UTC
182018-09-20 15:39:06 +0000 GMT

还有疑问的可以看看go自带的测试例子：
Go/src/time/example_test.go


原文发布时间为：2018-09-23

本文作者：云上听风

本文来自云栖社区合作伙伴“Golang语言社区”，了解相关信息可以关注“Golang语言社区”。

weixin_33896069
关注
go time.Parse的一些小知识
qq_26140191的博客
08-01 3727
之前都是写在笔记里，搬到csdn上。。。go的time.Parse时区问题layout模版总结 go的time.Parse 在自己写东西时，遇到了时间转换的一些小问题。 首先是 time.Parse(layout, value), go语言提供的layout模版和我个人使用都略有差别, 转换使用很不习惯。 第二就是时区问题, 服务器的时区不一定是符合国内时区的。 时区问题 时区问题可以使用tim...
【golang】time.Parse 统一时区
qq_28036049的博客
03-22 2364
UTC：世界标准时间（英語：Coordinated Universal Time，法語：Temps Universel Coordonné，简称UTC）是最主要的世界時間標準 CST ：UTC+8时区名称，中国标准时间是其一，详见维基百科释义 GMT：格林尼治平均时间（Greenwich Mean Time），前世界标准时 示例： layout := "2006-01-02 15:04:05" now := time.Now().Format(layout) t1, _ := time.Parse(l
go语言时间和日期的转化
weixin_45533687的博客
05-19 4936
go语言时间和日期的转化
golang time.Parse timezone 时区问题
goddnss的博客
01-12 1025
当使用time.Parse解析日期时，会发现和实际的时间不一致，这是因为parse是默认时区是UTC。解决方案是用ParseInLocation代替Parse import ( "time" ) func main() { t1, err := time.ParseInLocation("2006-01-02 15:04:05.000", "2022-01-12 10:55:00.000", time.Local) } 转载：原文 ...
golang 指定时区和自定义时区
weixin_30764137的博客
11-21 1623
golang指定时区 loc,_:=time.LoadLocation("Asia/Shanghai") t:=time.Now() t = t.In(loc) LoadLocation 有个问题，它依赖于 IANA Time Zone Database (简称 tzdata 吧) 这个数据库，一般linux系统都带了，但是windows系统就没带。 没有 tzdata 就会从...
golang时间、时区、格式的使用方法
01-03
前几天，因为需要实现海外服务端定时停机，涉及到时区的概念。网上搜索了一下，大部分都是谈time.Format中的Layout，非常不成体系，这里就简单总结一下其中的时间初始化、时区转化及格式转换。 开发中，我们对时间的使用是比较多的，其应用场景，按照使用概率，从大到小，通常是： 获取当前或数据库中存储的时间 比较两个时间点的先后 显示打印时间 时区转换 对应到go，也就是几个基本定义： 时间点与时间段：Time,Duration。好比MVC中的M。 时 区：Location，在时间转换上，好比是MVC中的C。 格式化：Format的layout定义，好比MVC中
golang学习系列——11. 时间和日期
night_crow的博客
10-10 289
关于时间在实际开发运用过程中，尤其需要注意系统标准/时区带来的影响（无论何种语言）。 1. 时间标准 UTC 协调世界时（英语：Coordinated Universal Time，法语：Temps Universel Coordonné，简称UTC）是最主要的世界时间标准，其以原子时秒长为基础，在时刻上尽量接近于格林尼治标准时间。 中华民国采用CNS 7648的《资料元及交换...
golang 定时任务方面time.Sleep和time.Tick的优劣对比
热门推荐
Star_CSU的博客
01-25 3万+
golang 写循环执行的定时任务，常见的有以下三种实现方式: 1、time.Sleep方法： for { time.Sleep(time.Second) fmt.Println("我在定时执行任务") } 2、time.Tick函数： t1:=time.Tick(3*time.Second) for { ...
Golang中time.After的使用理解与释放问题
09-20
在Golang中，处理时间是一个常见且重要的任务，而time包提供的After函数是处理超时和延时场景的利器。 time.After函数用于等待指定的时间间隔，并在时间间隔结束后发送当前时间到返回的通道中。它常用于select语句...
Golang讲解的示意图.xlsx
01-21
Golang讲解的示意图.xlsx
golang 时区问题以及time包下常用的一写函数和方法
丁涛的博客
02-26 1482
golang标准库下time包中常用函数 Now() Time 获取当前时间,返回Time类型 Unix(sec int64, nsec int64) Time 根据秒数和纳秒,返回Time类型 Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time 设置年月日返回,Time类型 Since(t...
go time时间偏移_Go冬夏令时时区转换
weixin_33060757的博客
12-27 1876
引言需求：给定一个时间戳 + 时区(Asia/shanghai) + 输出格式，返回该时区下特定格式的时间字符串注意：一定需要考虑到不同国家冬夏令时情况抽象一下：难点在于不同时区不同夏令时(夏时制)间转换基本概念夏时令夏季人为将时间调快一小时，英文为Daylight Saving Time，简称DST冬令时冬季人为把时针拨回一小时注意：大多数时候，也会将...
Golang时间包的“坑” time.Parse
wxs0607
02-27 8917
开发过程中，无意发现的bug 首先看一段代码： func main() { st := "2019-11-21 11:59:01" fmt.Printf("%s\n", st) t, _ := time.Parse("2006-01-02 15:04:05", st) fmt.Println(t.Unix()) tt := time.Unix(t.Unix(), 0) fmt.P...
golang时间解析问题
xiojing的博客
12-23 973
time.Parse() 不会使用系统本地时区解析 指定时区解析时间字符串为Time，需要使用： time.ParseInLocation() timeZone, _ := time.LoadLocation("Asia/Shanghai") timeObj_1, _ := time.Parse("2006-01-02 15:04:05", "2020-12-01 00:00:00") fmt.Println("timeObj_1" , timeObj_1.Unix()) timeObj_2 ,
golang 时间转换 时区转换
oguro的博客
01-18 9186
ParseInLocation类似Parse但有两个重要的不同之处。第一，当缺少时区信息时，Parse将时间解释为UTC时间，而ParseInLocation将返回值的Location设置为loc；第二，当时间字符串提供了时区偏移量信息时，Parse会尝试去匹配本地时区，而ParseInLocation会去匹配loc。 func (t Time) In(loc *Location) Time In返回采用loc指定的地点和时区，但指向同一时间点的Time。如果loc为nil会panic。 .
14-【go】Go中time.Parse()和time.ParseInLocation()的区别
qq_42303254的博客
06-06 1万+
https://blog.csdn.net/maqianQAQ/article/details/78705001
go语言中time包基础内容
weixin_62120659的博客
10-09 1937
一、介绍简单的几个时间UTC、CST、CDT 二、获取时间的函数 三、时间的加Add、减Sub、等Equal 四、判断两时间发生前后after、before 五、周期性定时器 time.Tick(时间间隔) 六、时间也有格式化Fomat 七、时间字符串格式的解析time.FixedZone和time.LoadLocation 八、时区（time zone） 九、Unix Time时间戳
golang time.time time.date 区别
最新发布
05-26
`time.Time` 是 Go 语言中用来表示时间的结构体，它包含了年、月、日、时、分、秒、纳秒、时区等信息。`time.Date` 是 `time.Time` 的一个方法，用于创建一个特定的时间点，需要指定年、月、日、时、分、秒、纳秒、时区等信息。而 `time.Now` 是 `time.Time` 的另一个方法，用于获取当前时间。它返回一个 `time.Time` 类型的值，表示当前时间。 在使用 `time.Time` 进行时间操作时，可以使用其提供的方法，如 `Add`、`Sub`、`Format` 等。比如： ``` now := time.Now() // 获取当前时间 oneHourLater := now.Add(time.Hour) // 将当前时间加上一个小时 fmt.Println(oneHourLater.Format("2006-01-02 15:04:05")) // 输出格式化后的时间字符串 ``` 需要注意的是，`time.Time` 结构体是不可变的，因此在进行时间操作时，每次都会返回一个新的 `time.Time` 对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值