Golang分割和解析字符串为不同类型

huangapple
go评论110阅读模式
英文:

Golang split and parse a string to different types

问题

我不确定我的方法是否正确，或者是否太过粗糙。有没有办法改进这段代码？

  1. func splitStatValues(data string) (uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint32, uint32) {
  2.     vals := strings.SplitN(data, ",", 9)
  4.     var lv, str, agi, stm, spr, wis, con uint16
  5.     var ki, exp uint32
  7.     for _, s := range vals {
  8.         xe := strings.SplitN(s, ":", 2)
  10.         if xe[0] == "Lv" {
  11.             _lv, _ := strconv.ParseUint(xe[1], 10, 16)
  12.             lv = uint16(_lv)
  13.         }
  15.         if xe[0] == "STR" {
  16.             _str, _ := strconv.ParseUint(xe[1], 10, 16)
  17.             str = uint16(_str)
  18.         }
  20.         if xe[0] == "AGI" {
  21.             _agi, _ := strconv.ParseUint(xe[1], 10, 16)
  22.             agi = uint16(_agi)
  23.         }
  25.         if xe[0] == "STM" {
  26.             _stm, _ := strconv.ParseUint(xe[1], 10, 16)
  27.             stm = uint16(_stm)
  28.         }
  30.         if xe[0] == "SPR" {
  31.             _spr, _ := strconv.ParseUint(xe[1], 10, 16)
  32.             spr = uint16(_spr)
  33.         }
  35.         if xe[0] == "WIS" {
  36.             _wis, _ := strconv.ParseUint(xe[1], 10, 16)
  37.             wis = uint16(_wis)
  38.         }
  40.         if xe[0] == "CON" {
  41.             _con, _ := strconv.ParseUint(xe[1], 10, 16)
  42.             con = uint16(_con)
  43.         }
  45.         if xe[0] == "KI" {
  46.             _ki, _ := strconv.ParseUint(xe[1], 10, 32)
  47.             ki = uint32(_ki)
  48.         }
  50.         if xe[0] == "EXP" {
  51.             _exp, _ := strconv.ParseUint(xe[1], 10, 32)
  52.             exp = uint32(_exp)
  53.         }
  54.     }
  56.     return lv, str, agi, stm, spr, wis, con, ki, exp
  57. }

要解析的字符串是：

  1. Lv:400,STR:9999,AGI:8888,STM:7777,SPR:6666,WIS:5555,CON:4444,KI:3999999999,EXP:1
英文:

I'm not sure my approach is right or if its too hackish. Is there a way to improve this code?

  1. func splitStatValues(data string) (uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint32, uint32) {
  2. vals := strings.SplitN(data, ",", 9)
  3. var lv, str, agi, stm, spr, wis, con uint16
  4. var ki, exp uint32
  5. for _, s := range vals {
  6. xe := strings.SplitN(s, ":", 2)
  7. if xe[0] == "Lv" {
  8. _lv, _ := strconv.ParseUint(xe[1], 10, 16)
  9. lv = uint16(_lv)
  10. }
  11. if xe[0] == "STR" {
  12. _str, _ := strconv.ParseUint(xe[1], 10, 16)
  13. str = uint16(_str)
  14. }
  15. if xe[0] == "AGI" {
  16. _agi, _ := strconv.ParseUint(xe[1], 10, 16)
  17. agi = uint16(_agi)
  18. }
  19. if xe[0] == "STM" {
  20. _stm, _ := strconv.ParseUint(xe[1], 10, 16)
  21. stm = uint16(_stm)
  22. }
  23. if xe[0] == "SPR" {
  24. _spr, _ := strconv.ParseUint(xe[1], 10, 16)
  25. spr = uint16(_spr)
  26. }
  27. if xe[0] == "WIS" {
  28. _wis, _ := strconv.ParseUint(xe[1], 10, 16)
  29. wis = uint16(_wis)
  30. }
  31. if xe[0] == "CON" {
  32. _con, _ := strconv.ParseUint(xe[1], 10, 16)
  33. con = uint16(_con)
  34. }
  35. if xe[0] == "KI" {
  36. _ki, _ := strconv.ParseUint(xe[1], 10, 32)
  37. ki = uint32(_ki)
  38. }
  39. if xe[0] == "EXP" {
  40. _exp, _ := strconv.ParseUint(xe[1], 10, 32)
  41. exp = uint32(_exp)
  42. }
  43. }
  44. return lv, str, agi, stm, spr, wis, con, ki, exp
  45. }

The string being parsed is:

  1. Lv:400,STR:9999,AGI:8888,STM:7777,SPR:6666,WIS:5555,CON:4444,KI:3999999999,EXP:1

答案1

得分: 2

这是稍微好一点的写法，我认为：

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"strconv"
  6. 	"strings"
  7. )
  9. type statValues struct {
  10. 	lv, str, agi, stm, spr, wis, con uint16
  11. 	ki, exp                          uint32
  12. }
  14. func main() {
  15. 	fmt.Printf("%+v\n", parseStatValues("Lv:400,STR:9999,AGI:8888,STM:7777,SPR:6666,WIS:5555,CON:4444,KI:3999999999,EXP:1"))
  16. }
  18. func parseStatValues(data string) statValues {
  19. 	var sv statValues
  20. 	for _, s := range strings.SplitN(data, ",", 9) {
  21. 		xe := strings.SplitN(s, ":", 2)
  22. 		switch xe[0] {
  23. 		case "Lv":
  24. 			lv, _ := strconv.ParseUint(xe[1], 10, 16)
  25. 			sv.lv = uint16(lv)
  26. 		case "STR":
  27. 			str, _ := strconv.ParseUint(xe[1], 10, 16)
  28. 			sv.str = uint16(str)
  29. 		case "AGI":
  30. 			agi, _ := strconv.ParseUint(xe[1], 10, 16)
  31. 			sv.agi = uint16(agi)
  32. 		case "STM":
  33. 			stm, _ := strconv.ParseUint(xe[1], 10, 16)
  34. 			sv.stm = uint16(stm)
  35. 		case "SPR":
  36. 			spr, _ := strconv.ParseUint(xe[1], 10, 16)
  37. 			sv.spr = uint16(spr)
  38. 		case "WIS":
  39. 			wis, _ := strconv.ParseUint(xe[1], 10, 16)
  40. 			sv.wis = uint16(wis)
  41. 		case "CON":
  42. 			con, _ := strconv.ParseUint(xe[1], 10, 16)
  43. 			sv.con = uint16(con)
  44. 		case "KI":
  45. 			ki, _ := strconv.ParseUint(xe[1], 10, 32)
  46. 			sv.ki = uint32(ki)
  47. 		case "EXP":
  48. 			exp, _ := strconv.ParseUint(xe[1], 10, 32)
  49. 			sv.exp = uint32(exp)
  50. 		}
  51. 	}
  53. 	return sv
  54. }

忽略错误通常是不好的，但是可以通过确保传递给函数的字符串是有效的（例如使用正则表达式）来确保。

英文:

This would be slightly better, I think:

  1. package main
  2. import (
  3. "fmt"
  4. "strconv"
  5. "strings"
  6. )
  7. type statValues struct {
  8. lv, str, agi, stm, spr, wis, con uint16
  9. ki, exp                          uint32
  10. }
  11. func main() {
  12. fmt.Printf("%+v\n", parseStatValues("Lv:400,STR:9999,AGI:8888,STM:7777,SPR:6666,WIS:5555,CON:4444,KI:3999999999,EXP:1"))
  13. }
  14. func parseStatValues(data string) statValues {
  15. var sv statValues
  16. for _, s := range strings.SplitN(data, ",", 9) {
  17. xe := strings.SplitN(s, ":", 2)
  18. switch xe[0] {
  19. case "Lv":
  20. lv, _ := strconv.ParseUint(xe[1], 10, 16)
  21. sv.lv = uint16(lv)
  22. case "STR":
  23. str, _ := strconv.ParseUint(xe[1], 10, 16)
  24. sv.str = uint16(str)
  25. case "AGI":
  26. agi, _ := strconv.ParseUint(xe[1], 10, 16)
  27. sv.agi = uint16(agi)
  28. case "STM":
  29. stm, _ := strconv.ParseUint(xe[1], 10, 16)
  30. sv.stm = uint16(stm)
  31. case "SPR":
  32. spr, _ := strconv.ParseUint(xe[1], 10, 16)
  33. sv.spr = uint16(spr)
  34. case "WIS":
  35. wis, _ := strconv.ParseUint(xe[1], 10, 16)
  36. sv.wis = uint16(wis)
  37. case "CON":
  38. con, _ := strconv.ParseUint(xe[1], 10, 16)
  39. sv.con = uint16(con)
  40. case "KI":
  41. ki, _ := strconv.ParseUint(xe[1], 10, 32)
  42. sv.ki = uint32(ki)
  43. case "EXP":
  44. exp, _ := strconv.ParseUint(xe[1], 10, 32)
  45. sv.exp = uint32(exp)
  46. }
  47. }
  48. return sv
  49. }

Ignoring errors is generally a Bad Thing, but it's of course possible to ensure that the string passed to the function is valid (with a RE, for example).

huangapple
  • 本文由 发表于 2016年2月29日 04:48:11
  • 转载请务必保留本文链接：https://go.coder-hub.com/35688070.html
  • go
  • split
  • string
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定