[Day06] swift & kotlin 入门篇！(4) 基础语法-转型与合并使用

转型与连结

在JS中, 所有的转型与连结都是无感的
也因为太方便太无感常常会跑出意外的结果
例如

console.log(+"1" + "1")  
// 输出 "11"

console.log(+"1" + 1 )  
// 输出 "2"

console.log("1" + 1 )  
// 输出 "11"

console.log("1" + 1  + 1)  
// 输出 "111"

console.log("1" + (1  + 1))  
// 输出 "12"

这种弹性在撰写的时候很方便也很快速
但在程序运作上相对是不稳定的

swift 与 kotlin 都是强行别语言
而swift在严谨度上高了一点

swift

let house = "这个房子 高度"
let height = 200
let level = 2.0

// print(house + height) // 编译错误 字串与数字不能直接串接

print(house + String(height))// 数字转型字串 後可作文字串接
// 输出： 这个房子 高度200

print(house + String(level))// 数字转型字串 可完整转型过去 不会移除小数点
// 输出： 这个房子 高度2.0

// print(house + String(height * level))// 编译错误 Int 与 Double 不能直接计算
print(house + String( Double(height) * level ) )
// 输出： 这个房子 高度400.0

print("这个房子 高度\(height)")// 或者利用字串插值也是个好方法
// 输出： 这个房子 高度200

let numInt: Int = 1
let numDouble: Double = 1.9999 // Double 64bit
let numFloat: Float = 1.9999 // Float 32bit

//print(numInt*numFloat) // 编译错误 不同型别的计算被禁止
//print(numInt+numDouble) // 编译错误 不同型别的计算被禁止
print(numInt*Int(numDouble)) // 输出： 1 , 因为转型过程中 精确度丢失 numDouble =1
print(numInt*Int(numFloat)) // 输出： 1 , 转型过程中 精确度丢失 numFloat =1

print(Int(1.999)) // 输出： 1 ,小数点後直接丢失
print(Int(1.9999999999999999)) //2  转型Int Double 9到小数点後16位会变成2
print(Double(numFloat)) // 1.999899983406067 精确度丢失
print(Float(numDouble)) // 1.9999

swift禁止不同型别间的计算
而转型过程中也会造成精确丢失
依照之前的开发习惯
会尽量避免转型运算这件事情
一开始写程序的时候设计好型别是很重要的

kotlin

fun main() {
    val house = "这个房子 高度"
    val height = 200
    val level = 2.0
	println(house + height) // 这个房子 高度200 同JAVA  当字串处理
    
    println(house + level.toString())// 数字转型字串 可完整转型过去 不会移除小数点
	// 这个房子 高度2.0
	 
	println(house + height * level)//  Int 与 Double 可以直接计算
	// 这个房子 高度400.0

    println("这个房子 ${height}")// 或者利用字串插值也是个好方法
	// 这个房子 高度200
    
    val numInt: Int = 1
    val numDouble: Double = 1.9999 // Double 64bit
    val numFloat: Float = 1.9999F // Float 32bit
    
    println(numInt*numFloat) // 1.9999 可正确计算 虽然没看到F, 但实际上是Float
    println((numInt*numFloat).javaClass.kotlin.simpleName ) // 输出： Float
    
	println(numInt+numDouble) // 2.9999000000000002 转型计算後会产生偏差
    println((numInt+numDouble).javaClass.kotlin.simpleName) // 输出： Double
    
    println(1.999.toInt()) // 1 小数点後直接丢失
    println(1.9999999999999999.toInt()) //2  转型Int Double 9到小数点後16位会变成2
    
    println(1.9999F.toDouble()) // 1.999899983406067 精确度丢失
	println(1.9999.toFloat()) // 1.9999
}

整体写起来较方便
但同时带来的是可能让你忽略精准度遗失问题
这其实偏开发习惯了
是要开发时方便顺手
还是之後程序可读性与可维护性比较高

kotlin & Swift 差异

到目前为止转型算是两种语言间
差异较大的部分
此系列想探讨开发差异与工程师可否同时开发这两种语言
到目前为止语法差异只要了解问题就不大
如果同时开发两种语言
个人偏向用同样严谨的心态。
去撰写kotlin & Swift 就可以拉～
毕竟身为Web开发者
踩过的各种型别的坑多到数不清啊（泪
严谨～小心一点准没错