写出优雅的Kotlin代码：聊聊我认为的 “Kotlinic”-六虎

“Kotlinic” 一词归于捏造的，参阅的是著名的”Pythonic”，后者可以译为“很Python”，意思是写的代码一看就很有Python味。照这个意思，”Kotlinic”便是“很Kotlin”，很有Kotlin味。

Kotlin程序员们不少是从Java转过来的，包括我；大部分时分，咱们也都把它当大号的Java语法糖在用。但Kotlin总归是一门新言语，而且，在我眼里仍是门挺高雅的言语。所以，或许咱们可以把Kotlin写得更Kotlin些。我想简略浅显的聊聊。

本文期望：聊聊一些好用的、简练的但又不失语义的Kotlin代码

本文不期望：鼓励无脑寻求高超技巧，彻底抛弃了可读性、可保护性，全篇奇技淫巧的操作

受限于自己水平，或许有错误或不严谨之处。如有此类问题，欢迎指出。也欢迎在谈论区讨论交流~

善用with、apply、also、let

with和apply

with和apply，除了能帮忙少打一些代码外，重要的是能让代码区别更明确。比方

val textView = TextView(context)
textView.text = "fish"
textView.setTextColor(Color.BLUE)
textView.setOnClickListener {  }
val imageView = ImageView(context)
// ...

这便是典型的Java写法，天然，没什么问题。但要是相似的代码多起来，总感觉不知道哪里是哪里。假如换用apply呢？

val textView = TextView(context).apply {
  text = "fish"
  setTextColor(Color.BLUE)
  setOnClickListener {  }
}
val imageView = ImageView(context).apply {

}

apply 的大括号轻松划清了边界：我这儿的代码和TextView相关。看着更整齐。

假如后边不需求这个变量，赋值还能省了

 // 设置某个view下的各个控件
with(view) {
  findViewById<TextView>(R.id.some_id).apply {
    text = "fish"
    setTextColor(Color.BLUE)
    setOnClickListener {  }
     }

    findViewById<ImageView>(R.id.some_id).apply {

   }
}

apply的另一个常见场景是用于那些回来自己的函数，比方常见的Builder类的方法

fun setName(name: String): Builder{
  this.name = name
  return this
}

改成apply就简练得多

fun setName(name: String) = apply{ this.name = name }

also

also的常见场景有许多，它的语义便是干完上一件事后附带干点什么事。 举个比方，给个函数：

fun someFunc() : Model{
  // ...
  return Model(name = "model", value = "value")
}

假如咱们突然想加个Log，打印一下回来值，按Java的写法，要这么干：

fun someFunc(): Model{
  // ...
  val tempModel = Model(name = "model", value = "value")
  print(tempModel)
  return tempModel
}

改的不少。可是按Kotlin的写法呢？

fun someFunc() : Model{
  return Model(name = "model", value = "value").also {
        print(it)
   }
}

不需求额定整个变量出来。

相似的，比方上面 apply 的比方，在没有声明变量的情况下，也可以这样用这个值

findViewById<ImageView>(R.id.some_id).apply {
 // ...
}.also{ println(it) }

整在一同

这几个函数结合起来，在针对一些比较杂乱的场景时，对提高代码的可读性仍是挺有协助的。如【唐子玄】在这篇文章里所举的比方：

假设需求如下：“缩放 textView 的一起平移 button ，然后拉长 imageView，动画完毕后 toast 提示”。

“Java”式写法

PropertyValuesHolder scaleX = PropertyValuesHolder.ofFloat("scaleX", 1.0f, 1.3f);
PropertyValuesHolder scaleY = PropertyValuesHolder.ofFloat("scaleY", 1.0f, 1.3f);
ObjectAnimator tvAnimator = ObjectAnimator.ofPropertyValuesHolder(textView, scaleX, scaleY);
tvAnimator.setDuration(300);
tvAnimator.setInterpolator(new LinearInterpolator());

PropertyValuesHolder translationX = PropertyValuesHolder.ofFloat("translationX", 0f, 100f);
ObjectAnimator btnAnimator = ObjectAnimator.ofPropertyValuesHolder(button, translationX);
btnAnimator.setDuration(300);
btnAnimator.setInterpolator(new LinearInterpolator());

ValueAnimator rightAnimator = ValueAnimator.ofInt(ivRight, screenWidth);
rightAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
  @Override
  public void onAnimationUpdate(ValueAnimator animation) {
    int right = ((int) animation.getAnimatedValue());
    imageView.setRight(right);
   }
});
rightAnimator.setDuration(400);
rightAnimator.setInterpolator(new LinearInterpolator());

AnimatorSet animatorSet = new AnimatorSet();
animatorSet.play(tvAnimator).with(btnAnimator);
animatorSet.play(tvAnimator).before(rightAnimator);
animatorSet.addListener(new Animator.AnimatorListener() {
  @Override
  public void onAnimationStart(Animator animation) {}
  @Override
  public void onAnimationEnd(Animator animation) {
    Toast.makeText(activity,"animation end" ,Toast.LENGTH_SHORT).show();
   }
  @Override
  public void onAnimationCancel(Animator animation) {}
  @Override
  public void onAnimationRepeat(Animator animation) {}
});
animatorSet.start();

乱糟糟的。改成“Kotlin式”写法呢？

AnimatorSet().apply {
  ObjectAnimator.ofPropertyValuesHolder(
      textView,
      PropertyValuesHolder.ofFloat("scaleX", 1.0f, 1.3f),
      PropertyValuesHolder.ofFloat("scaleY", 1.0f, 1.3f)
   ).apply {
    duration = 300L
    interpolator = LinearInterpolator()
   }.let {
    play(it).with(
        ObjectAnimator.ofPropertyValuesHolder(
            button,
            PropertyValuesHolder.ofFloat("translationX", 0f, 100f)
         ).apply {
          duration = 300L
          interpolator = LinearInterpolator()
         }
     )
    play(it).before(
        ValueAnimator.ofInt(ivRight,screenWidth).apply { 
          addUpdateListener { animation -> imageView.right= animation.animatedValue as Int }
          duration = 400L
          interpolator = LinearInterpolator()
         }
     )
   }
  addListener(object : Animator.AnimatorListener {
    override fun onAnimationRepeat(animation: Animator?) {}
    override fun onAnimationEnd(animation: Animator?) {
      Toast.makeText(activity,"animation end",Toast.LENGTH_SHORT).show()
     }
    override fun onAnimationCancel(animation: Animator?) {}
    override fun onAnimationStart(animation: Animator?) {}
   })
  start() 
}

从上往下读，层次分明。读起来可以感觉到：

构建动画集，它包含{
   动画1
   将动画1和动画2一同播映
   将动画3在动画1之后播映
   。。。
}

（上面的代码均来自所引文章）

用好拓宽函数

持续上面动画的比方接着说，可以看到，最终的Listener实际上咱们只用了 onAnimationEnd 这一部分，但却写出了一大堆。这时分，拓宽函数就起作用了。

走运的是，Google官方的 androidx.core:core-ktx 现已有了对应的拓宽函数：

public inline fun Animator.doOnEnd(
  crossinline action: (animator: Animator) -> Unit
): Animator.AnimatorListener =
  addListener(onEnd = action)
  
  
public inline fun Animator.addListener(
  crossinline onEnd: (animator: Animator) -> Unit = {} ,
  crossinline onStart: (animator: Animator) -> Unit = {} ,
  crossinline onCancel: (animator: Animator) -> Unit = {} ,
  crossinline onRepeat: (animator: Animator) -> Unit = {}
): Animator.AnimatorListener {
  val listener = object : Animator.AnimatorListener {
    override fun onAnimationRepeat(animator: Animator) = onRepeat(animator)
    override fun onAnimationEnd(animator: Animator) = onEnd(animator)
    override fun onAnimationCancel(animator: Animator) = onCancel(animator)
    override fun onAnimationStart(animator: Animator) = onStart(animator)
   }
  addListener(listener)
  return listener
}

所以上面的最终几行addListener可以改成

doOnEnd { Toast.makeText(activity,"animation end", Toast.LENGTH_SHORT).show() }

是不是简略得多？

当然，弹出Toast似乎也很常用，所以再搞个拓宽函数

inline fun Activity.toast(text: String, duration: Int = Toast.LENGTH_SHORT)
  = Toast.makeText(this, text, duration).show()

上面的代码又可以改成这样

(animation.) doOnEnd  { activity.toast("animation end") }

再比较下本来的

 (animation.) addListener(object : Animator.AnimatorListener {
    override fun onAnimationRepeat(animation: Animator?) {}
    override fun onAnimationEnd(animation: Animator?) {
      Toast.makeText(activity,"animation end",Toast.LENGTH_SHORT).show()
     }
    override fun onAnimationCancel(animation: Animator?) {}
    override fun onAnimationStart(animation: Animator?) {}
})

是不是简练得多？

上面说到 androidx.core:core-ktx ，其实它包含了大量有用的拓宽函数。假如花点时间了解了解，或许能优化不少地方。最近上也有不少相似的文章，可以参阅参阅

/post/711504…

/post/711692…

/post/712171…

用好运算符重载

Kotlin的运算符重载其实很有用，举个栗子

给List增加值

我见过这种代码

val list = listOf(1)
val newList = listOf(1, 2, 3)

val mutableList = list.toMutableList() // 转成可变的
mutableList.addAll(newList) // 增加新的
return mutableList.toList() // 回来，改成不可变的

可是换成运算符重载呢？

val list = listOf(1)
val newList = listOf(1, 2, 3)
return list + newList

一个”+”号，简明扼要。

又比方，想判别

某个View是否在ViewGroup中

最简略的看看索引呗

val group = LinearLayout(this)
val isContain = group.indexOfChild(view) != -1

不过，借助core-ktx供给的运算符，咱们可以写出这样的代码

val group = LinearLayout(this)
val isContain = view in group

语义上更直接

想增加（删去）一个View？除了 addView （removeView），也可以直接”+=”（-=）

val group = LinearLayout(activity)
group += view // 增加子View

group -= view // 移除子View

想遍历？重载下 iterator() 运算符（core-ktx也写好了），就可以直接for了

val group = LinearLayout(this)
for (child in group) {
  //执行操作
}

（这几个View的比方根本也来自上面的文章）

此外，杰出设计的拓宽属性和拓宽函数也能协助写出更契合语意的代码，形如

// 设置view的大小
view.setSize(width = 50.dp, height = 100.dp) 
// 设置文字大小
textView.setFontSize(18.sp)

// 获取三天后的时间
val dueTime = today + 3.days

// 获取文本的md5编码
val md5 = "FunnySaltyFish".md5

上面的代码很简略能看出是要干嘛，而且也非常简略实现，此处就不再赘述了。

DSL

关于DSL，咱们或许都知道有这么个东西，但或许用的都不多。但DSL若用得好，的确能达到化繁为简的成效。关于DSL的根本原理和实现，fundroid大佬在Kotlin DSL 实战:像 Compose 一样写代码 – 中现已写得非常明晰了，自己就不再画蛇添足，接下来仅谈谈或许的运用吧。

构建UI

DSL的一个广泛运用应该便是构建UI了。

Anko（已过时）

较早的时分，一个比较广泛的运用或许便是之前的anko库了。JetBrains推出的这个库允许咱们可以不必xml写布局。放一个来自博客Kotlin之小试Anko(Anko库的导入及运用) – SoClear – 博客园的比方

private fun showCustomerLayout() {
  verticalLayout {
    padding = dip(30)
    editText {
      hint = "Name"
      textSize = 24f
     }.textChangedListener {
      onTextChanged { str, _, _, _ ->
        println(str)
       }
     }
    editText {
      hint = "Password"
      textSize = 24f
     }.textChangedListener {
      onTextChanged { str, _, _, _ ->
        println(str)
       }
     }
    button("跳转到其它界面") {
      textSize = 26f
      id = BTN_ID
      onClick {
        // 界面跳转并带着参数
        startActivity<IntentActivity>("name" to "小明", "age" to 12)
       }
     }

    button("显现对话框") {
      onClick {
        makeAndShowDialog()
       }
     }
    button("列表selector") {
      onClick {
        makeAndShowListSelector()
       }
     }
   }
}

private fun makeAndShowListSelector() {
  val countries = listOf("Russia", "USA", "England", "Australia")
  selector("Where are you from", countries) { ds, i ->
    toast("So you're living in ${countries[i]},right?")
   }
}

private fun makeAndShowDialog() {
  alert("this is the msg") {
    customTitle {
      verticalLayout {
        imageView(R.mipmap.ic_launcher)
        editText {
          hint = "hint_title"
         }
       }
     }

    okButton {
      toast("button-ok")
      // 会自行关闭不需求咱们手动调用
     }
    cancelButton {
      toast("button-cancel")
     }
   }.show()
}

简练高雅，而且由所以Kotlin代码生成的，还省去了解析xml的耗费。不过，因为“现在有更好的挑选”，Anko官方现已停止保护此库；而被引荐的、用于取而代之的两个库分别是：Views DSL 和 Jetpack Compose

Views DSL

关于这个库，Anko官方在引荐时说，它是“An extensible View DSL which resembles Anko.”。二者也的确很相像，但Views DSL在Anko之上供给了更高的拓宽性、对AppCompat的支撑、对Material的支撑，甚至供给了直接预览kt布局的能力！

根本的运用可以看看上图，额定的感兴趣的咱们可以去官网查看，此处就不多赘述。

Jetpack Compose

作为一个用Compose超过一年的萌新，我自己是非常喜爱这个结构的。但一起，目前（2022-07-25）Compose的基建的确还尚不完善，所以对企业项目来说还，是应该充分评价后再考虑。但我仍然引荐你测验一下，因为它简略、易用。即使是在现有的View项目中，也能无缝嵌入部分Compose代码；反之亦然。

Talk is cheap, show me your code. 比方要实现一个列表，View项目（运用RecyclerView）需求xml+Adapter+ViewHolder。而Compose就简练得多：

LazyColumn(Modifier.fillMaxSize()) {
    items(10) { i ->
        Text(text = "Item $i", modifier = Modifier
       .fillMaxWidth()
       .clickable {
                context.toast("点击事情")
       }
            .padding(8.dp), style = MaterialTheme.typography.h4)
   }
}

上面的代码创造了一个全屏的列表，而且增加了10个子项。每个item是一个文本，而且简略设置了其样式和点击事情。即使是彻底不懂Compose，阅读代码也不难猜到各项的意义。运行起来，作用如下：

构建杂乱的“字符串”

拼接字符串是一项常见的作业，不过，当它杂乱起来但又有必定结构时，简略的”+”或许模板字符串看起来就有些杂乱了。这时，DSL就能很高雅的处理这个使命。

举几个常见的比方吧：

Html

运用DSL，可以写出相似这样的代码

val htmlText = buildHtml{
  html{
    body{
      div("id" to "wrapper"){
        p{ +"这是一个阶段" }
        repeat(3){ i ->
          li{ +"Item ${i+1}" }
         }
        img("src" to "https://www.xxx.xxx/", "width" to "100px")
       }
     }
   }
}

上述代码会生成相似这样的html

<!DOCTYPE html>
<html lang="zh-CN">
<body>
  <div id="wrapper">
    <p>这是一个阶段</p>
    <ul>Item 1</ul>
    <ul>Item 2</ul>
    <ul>Item 3</ul>
    <img src="https://www.xxx.xxx/" width="100px">
  </div>
</body>
</html>

简练直接，而且不简略犯错。

你或许比较疑问上面的 +"xxx" 是个啥，其实这是用了运算符重载把String转成了纯文本Tag。代码或许相似于

open class Tag()
open class TextTag(val value: String) : Tag()
operator fun String.unaryPlus() = TextTag(this)

Markdown

相似的，也可以用这种方法生成markdown。代码或许相似于

val markDownText = buildMarkdown {
  text("我是")
  link("FunnyFaltyFish", "https://github.com/FunnySaltyFish")
  newline()
  bold("很快乐见到你~")
}

生成的文本相似于

我是 [FunnySaltyFish](https://github.com/FunnySaltyFish) 
** 很快乐见到你~ **

SpannableString

对Android开发者来说，这个东西估量更常见。但传统的构造方法可以说够杂乱的，所以DSL也能用。好的是，Google现已在 core-ktx 里写好了更简便的方法

运用比方如下：

val build = buildSpannedString {
    backgroundColor(Color.YELLOW) {
      append("我叫")
      bold {
        append("FunnySaltyFish")
       }
      append(",是一名学生")
     }
   }

渲染出的作用如下

待续

本文应该还没有完，不过形似写着写着也不短了，所以就先发了吧（主要是再晚些就赶不上征稿了（笑））。后边我还想聊聊kotlin的署理、协程、Collection……争取下次见！

我正在参加技术社区创作者签约方案招募活动，点击链接报名投稿

写出优雅的Kotlin代码：聊聊我认为的 “Kotlinic”

善用with、apply、also、let

with和apply

also

整在一同

用好拓宽函数

用好运算符重载

给List增加值

某个View是否在ViewGroup中

DSL

构建UI

Anko（已过时）

Views DSL

Jetpack Compose

构建杂乱的“字符串”

Html

Markdown

SpannableString

待续

作者信息

推广

写出优雅的Kotlin代码：聊聊我认为的 “Kotlinic”

善用with、apply、also、let

with和apply

also

整在一同

用好拓宽函数

用好运算符重载

给List增加值

某个View是否在ViewGroup中

DSL

构建UI

Anko（已过时）

Views DSL

Jetpack Compose

构建杂乱的“字符串”

Html

Markdown

SpannableString

待续

相关文章

使用RunnerGo做接口性能、接口自动化测试

二十四、Apk包体积优化

Flutter 打包aab 并上传到google play

拯救 VSCode，试试这款高颜值代码字体

作者信息

推广