学习kotlin第六天_包、控制流、返回和跳转

ゝ一世哀愁。 2022-06-15 07:25 161阅读 0赞

*今天继续跟着**kotlin**官方文档踩坑，还是那句话，仅为记录我的学习过程，不喜勿喷。*

*调整心态，遇到新知识不要嫌弃，不要怕，它以后会成为手中的利剑。*

坑1、包......在第一天就见了一面......默认导入的包我现在也不了解这些包里有啥也不介绍了。需要导入的包IDE一般能自动导入。此外，kotlin中没有“import static”语法。

坑2、kotlin中，if...else...表达式取代了三目运算符。这前面已经见过，就算没见过也好理解。if...else...分支可以是代码块，最后的表达式的值为该块的返回值。

坑3、when表达式前面已经见过了，类似于if表达式，也既能当表达式使用也能当语句使用。

坑4、for循环之前也见过了，它可以遍历任何提供了迭代器的对象，这段话我实在是翻译不通顺，尽管已经被翻译成汉语了，先贴下来看一眼有个印象以后再慢慢理解。

![Center][]

坑5、对数组的for  循环会被编译为并不创建迭代器的基于索引的循环。因此有如下两种遍历方式。

**fun** main(args: Array<String>) \{   
    **val** array = *arrayOf*(1, 2, 3)  
    **for** (i **in** array.*indices*) \{   
        *print*(**"the element at "** \+ i + **" is "** \+ array\[i\] + **" \\t"**)  
    \}  
    *println*()  
    **for** ((index, value) **in** array.*withIndex*()) \{   
        *print*(**"the element at $**index** is $**value**\\t"**)  
    \}  
\}

坑6、while循环和do...while循环前面也已经提过。循环中的break和continue也和传统的一样，作用于最直接包含它的循环。

坑7、新玩意儿来了——标签。标签是在标识符后加@符号，可以用来限制break和continue。标签限制的 break 跳转到刚好位于该标签指定的循环后面的执行点。 continue 继续标签指定的循环的下一次迭代

**fun** main(args: Array<String>) \{   
    **for** (i **in** 1..5) \{   
        loop@ **for** (j **in** 1..5) \{ *//跳到loop标记的循环外,即当前循环  
            print*(**"i"** \+ i + **"j"** \+ j + **"\\t"**)  
            **break**@loop  
        \}  
    \}  
    *println*()  
    loop@ **for** (i **in** 1..5) \{ *//跳到loop标记的循环外,即外层循环  
        ***for** (j **in** 1..5) \{   
            *print*(**"i"** \+ i + **"j"** \+ j + **"\\t"**)  
            **break**@loop  
        \}  
    \}  
\}

坑8、我们知道return是退出当前函数，但如果我们想要仅仅退出当前lambda表达式时，可以使用标签加以限制。

**fun** main(args: Array<String>) \{   
    *println*(*foo*())  
    *println*(*foo2*())  
\}  
**fun** foo() \{   
    **val** ints = *listOf*(0, 1, 2, 3)  
    ints.*forEach* **\{   
        if** (**it** == 0) **return***//从函数返回，退出foo,输出：kotlin.Unit  
        print*(**it**)  
    **\}**  
\}  
**fun** foo2() \{   
    **val** ints = *listOf*(0, 1, 2, 3)  
    ints.*forEach* lit@ **\{   
        if** (**it** == 0) **return**@lit*//从当前lambda表达式返回，退出当前循环,输出：123kotlin.Unit  
        print*(**it**)  
    **\}**  
\}

此外，还支持隐式标签和匿名函数来跳出当前lambda表达式。

**fun** foo3() \{   
    **val** ints = *listOf*(0, 1, 2, 3)  
        ints.*forEach* **\{   
            if** (**it** == 0) **return**@forEach*//隐式标签，和接受该lambda函数同名  
            print*(**it**)  
        **\}**  
\}  
**fun** foo4() \{   
    **val** ints = *listOf*(0, 1, 2, 3)  
    ints.*forEach*(**fun**(value: Int) \{ *//匿名函数，return只跳出当前函数  
        ***if** (value == 0) **return  
        ***print*(value)  
    \})  
\}

此外，带返回值的优先选择带标签限制的return 即return@a 1;

可惜我没找到合适的例子，foreach返回的类型是Unit类型。

[Center]: /images/20220615/715f040e81ba466089b23922ba081c79.png