scala string转int（string转int类型的语法为）

投稿用户 • • 网络营销 • 阅读 682

上海园区招商办公室

联系人：梁经理

联系电话：15000456391

欢迎来电咨询，竭诚为你服务!


scala string转int（string转int类型的语法为）

总结了golang中结构体，字符串，各种int类型的相互转换方式

//string转成int：int, err := strconv.Atoi(string)//string转成int64：int64, err := strconv.ParseInt(string, 10, 64)//int转成string：string := strconv.Itoa(int)//int64转成string：string := strconv.FormatInt(int64,10)

总结了golang中结构体，map 转byte 之间的相互转换方式

map1 := make(map[string]interface{}) map1["1"] = "hello" map1["2"] = "world" // map to []byte str, err := json.Marshal(map1) if err != nil { fmt.Println(err) } // byte to map map2 := make(map[string]interface{}) err = json.Unmarshal(str, &map2) if err != nil { fmt.Println(err) } fmt.Println("json to map ", map2) fmt.Println("The value of key1 is", map2["1"])

float,bool和string之间的相互转换方式

s := strconv.FormatBool(true)fmt.Println(reflect.TypeOf(s)) //stringfmt.Println(s) //truea, _ := strconv.ParseBool(s)fmt.Println(reflect.TypeOf(a)) //boolfmt.Println(a) //trues1 := strconv.FormatFloat(13.1415, 'E', -1, 64)fmt.Println(reflect.TypeOf(s1)) //stringfmt.Println(s1) //1.31415E+01s2, _ := strconv.ParseFloat(s1,64)fmt.Println(reflect.TypeOf(s2)) //float64fmt.Println(s2) //13.1415

断言

类型断言被用于检查接口类型变量所持有的值是否实现了期望的接口或者具体的类型。

类型断言的语法定义如下：

PrimaryExpression.(Type)

PrimaryExpression 可以在 Go 语言规范中找到，并且它可以是标识符，特定索引的数组元素，切片等等。

Type 既可以是类型标识符，也可以是类型字面量，比如：

type I interface {
   walk()
   quack()
}

type S struct{}

func (s S) walk() {}
func (s S) quack() {}

var i I
i = S{}
fmt.Println(i.(interface {
    walk()
}))
PrimaryExpression 必须是接口类型，否则就会产生一个编译时错误：
type I interface{
   walk()
  quack()
}

type S struct{}

S{}.(I) // 无效类型断言：S{}.(I)(操作符左边的 S 并不是个接口类型)

如果表达式为 nil，类型断言就不会成立。

动态类型

变量除了有静态类型外（变量声明中的类型），接口变量还有动态类型。就是在当前接口类型变量中设置的一种类型的值。在程序执行的过程当中，接口类型的变量具有相同的静态类型，但是其动态类型会随着其实现的接口不同，而其值也会随之改变。

type I interface {
walk()
}

type A struct{}

func (a A) walk() {}

type B struct{}

func (b B) walk() {}

func main() {
var i I
i = A{} // i 的动态类型是 A
fmt.Printf("%T\n", i.(A))
i = B{} // i 的动态类型是 B
fmt.Printf("%T\n", i.(B))
}

接口类型

如果 T 来自 v.(T) 是一个接口类型，这样的断言检查，可以用来检测 v 的动态类型是否实现了接口 T：

type I interfacce {
    walk()
}

type J interface {
   quack()
}

type K interface {
   bark()
}

type S struc{}

func (s S) walk() {}

func (s S) quack() {}

func main() {
var i I
i = S{}
  fmt.Printf("%T\n", i.(J))
  fmt.Printf("%T\n", i.(K)) // panic: 接口转换: main.S 不是 main.K: 缺少方法 bark
}

非接口类型

如果 T 来自 v.(T) 不是接口类型，这样断言检查动态类型 v 是否与 T 类型相同：

type I interface {
  walk()
}

type A struct{}

func (a A) walk() {}

type B struct{}

func (b B) walk() {}

func main() {
var i I
i = A{}
   fmt.Printf("%T\n", i.(A))
   fmt.Printf("%T\n", i.(B)) // panic: 接口转换: main.I 是 main.A, 不是 main.B
}

在非接口类型情况下进行类型传递就必须实现接口 I，如果不满足这个要求的话就会在编译时被捕获：

type C struct{}
fmt.Prinf("%T\n", i.(C))

输出：

impossible type assertion: C does not implement I (missing walk method)

不要 panic

在上述情况下，当断言不能成立时，运行时 panic 将会被触发。为了优雅的处理错误，这里有特殊的形式来赋值或者初始化：

type I interface {
   walk()
}
type A struct {
   name string
}
func (a A) walk() {}
type B struct {
   name string
}
func (b B) walk() {}
func main() {
var i I
i = A{name: "foo"}
valA, okA := i.(A)
  fmt.Printf("%#v %#v\n", valA, okA)
valB, okB := i.(B)
   fmt.Printf("%#v %#v\n", valB, okB)
}
输出：
main.A{name:"foo"} true
main.B{name:""} false

当断言不成立时，第一个值将会作为测试类型的零值

总结 ：在使用GO语言时候，总会遇到类型转换，各种场景下的转换，GO存在4中类型转换分别是断言，强制，隐式，显式。

相关文章：

  1. 日志级别由低到高trace（哪个日志级别最高）
  2. 如何做一个网址（网站制作教程）
  3. 四1班8名同学参加少先队知识竞赛（少先队知识竞赛答题卡）
  4. 执行力强怎么写简历（简历如何体现执行力）
  5. 每日计划的app（每日计划打卡表）
本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 792114587@qq.com 举报，一经查实，本站将立刻删除。
如若转载，请注明出处：https://www.qiked.com/6838.html
赞 (0)
投稿用户
0
上一篇 2022年6月23日 pm11:24
下一篇 2022年6月24日 am3:24

相关推荐