学胖子的个人博客

发表于 更新于 分类于

flutter练习 - Dart流程控制语句

if 和 else

1
2
3
4
5
6
7
8
void main() {
  int x =10;
  if(x%2==0){
  print("$x 能被2整除");  
  }else{
    print("$x 不能被2整除");
  }
}

for（循环）

1
2
3
4
5
6
7
void main() {
  var message = new StringBuffer("Hello Dart");
  for (var i = 0; i < 10; i++) {
    message.write("!");
  }
  print(message);
}
1
2
3
4
5
6
void main() {
  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  for (var i = 0; i < arr.length; i++) {
    print(i);
  }
}
1
2
3
4
5
6
7
void main() {
 var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  numbers.forEach((number) => print(number));
  numbers.forEach((number) {
    print(number);
  });
}

while 和 do - while (循环)

1
2
3
4
5
6
7
void main() {
  var _temp = 0;
  while (_temp < 5) {
    print("这是一个while循环: ${_temp.toString()}");
    _temp++;
  }
}
1
2
3
4
5
6
7
void main() {
  var _temp = 0;
  do {
    print("这是一个while循环: ${_temp.toString()}");
    _temp++;
  } while (_temp < 5);
}

break 和 continue

1
2
3
4
5
6
7
8
9
void main() {
    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  for (var v in arr) {
    if (v == 4) {
      break;//跳出循环
    }
    print(v);
  }
}
1
2
3
4
5
6
7
8
9
void main() {
  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  for (var v in arr) {
    if (v == 4) {
      continue;//跳出本次循环
    }
    print(v);
  }
}

switch 和 case

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void main() {
  var x = 10;
  switch (x % 3) {
    case 0:
      print("余数: 0");
      break;
    case 1:
      print("余数: 1");
      break;
    case 2:
      print("余数: 2");
      break;
    default:
      print("其他");
      break;
  }
}

assert (断言)

  • assert 语句不会影响生产环境中代码的执行，它仅仅在测试环境中起作用。在 Flutter 的调试模式下可以使用 assert。
  • 如果assert条件为 false，则使用 assert 语句中断执行，并抛出一个断言错误异常AssertionError。
  • 如果assert条件为 true，则继续执行下面的语句。

发表于 分类于

flutter练习 - Dart常见运算符

算数运算符

操作符 含义
+ 加
- 减
- expr 一元减号(负号) expr : 表达式的值
* 乘
/ 除
~/ 返回一个整数值的除法
% 取余数,除法剩下的余数
++var var = var + 1 表达式的值为：var + 1
var++ var = var + 1 表达式的值为：var
–var var = var - 1 表达式的值为：var - 1
var– var =var - 1 表达式的值为：var

关系运算符

操作符 含义
== 等于
!= 不等于
> 大于
< 小于
>= 大于或等于
<= 小于或等于

类型测试操作符

操作符 含义
as 类型转换
is 当对象是相应类型时返回 true
is! 当对象不是相应类型时返回 true

赋值操作符

操作符 含义
a = value ; 将 value 赋值给 a
b??= value ; 如果 b为空，则将value的值赋值给b，否则，b保持不变
a op b a = a op b
a += b a = a + b
a -= b a = a - b

逻辑运算符

操作符 含义
!expr 反转以下表达式( 将 false 更改为 true , 反之亦然)
|| 逻辑或
&& 逻辑与

位运算符

操作符 含义
& 与
| 或
^ 异或
-expr 一元位补码 ( 0s 变为 1s , 1s 变为 0s )
<< 左移
>> 右移

条件表达式

  1. 如果条件为真，返回 expr1,否则返回 expr2 。
    condition ? expr1 : expr2
  2. 如果 expr1 为非空,则返回其值，否则 计算并返回 expr2 的值
    expr1 ?? expr2

级联操作

级联操作符 (…) 可以在同一个对象上连续调用多个函数以及访问成员变量。使用级联操作符可以避免创建临时变量， 并且写出来的代码看起来更加流畅

1
2
3
4
querySelector('#button') // Get an object.
  ..text = 'Confirm'   // Use its members.
  ..classes.add('important')
  ..onClick.listen((e) => window.alert('Confirmed!'));

发表于 分类于

kotlin练习 - Kotlin中的【 ?，?.，?:，!! ，filterNotNull 】含义

? 可空类型，表示当前是否对象可以为空

1
2
var a:String ="123"
a = null //编译报错
1
2
var a:String? ="123"
a = null //编译通过

?. 安全调用操作符

1
2
3
4
var a:String? ="123"
a = null //编译通过
val length = a.length //编译报错 --- 变量"a"可能会为空
val length = a?.length //编译通过 --- 如果 a 非空，就返回 a.length，否则返回 null

?: Elvis 操作符

1
2
3
var a:String? ="123"
a = null //编译通过
val lenght = a?.length?:-1 // 当a不为空时，返回a.length，当a为空时，返回-1

!! 操作符，表示当前对象不为空的情况下执行，为空就抛出异常

1
2
3
var a:String? ="123"
a = null //编译通过
val lenght = a!!.length //如果a不为空，则返回a.length，如果b为空，则抛出异常 NullPointerException

filterNotNull 过滤非空元素

1
2
3
val nullableList: List<Int?> = listOf(1, 2, null, 4)
val intList: List<Int> = nullableList.filterNotNull() 
println(intList.toString())//[1, 2, 4]

发表于 更新于 分类于

kotlin练习 - 作用域函数学习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package com.kymjs.kotlinprimer.unit3


data class User(var name: String)

fun main(args: Array<String>) {

    val user = User("ZhangTao")

    //let与run都会返回闭包的执行结果，区别在于let有闭包参数，而run没有闭包参数
    val letResult = user.let { "let::${it.javaClass}" }
    println(letResult)
    val runResult = user.run { "run::${this.javaClass}" }
    println(runResult)

    //also与apply都不返回闭包的执行结果，区别在于also有闭包参数，而apply没有闭包参数
    user.also {
        println("also::${it.javaClass}")
    }.apply {
        println("apply::${this.javaClass}")
    }.name = "hello"

    //takeIf 的闭包返回一个判断结果，为false时，takeIf函数会返回空
    //takeUnless 与 takeIf 刚好相反， 闭包的判断结果，为true时函数会返回空
    user.takeIf { it.name.length > 0 }?.also { println("姓名为${it.name}") } ?: println("姓名为空")
    user.takeUnless { it.name.length > 0 }?.also { println("姓名为空") } ?: println("姓名为${user.name}")

    //重复执行当前闭包
    repeat(5) {
        println(user.name)
        print(it)
    }

    //with比较特殊，不是以扩展方法的形式存在的，而是一个顶级函数
    with(user) {
        this.name = "with"
    }
//	类似于    user.apply{ this.name = "with"}
}

let

  • 定义：

    fun <T, R> T.let(block: (T) -> R): R

  • 功能：

    调用对象（T）的let函数，则该对象为函数的参数。在函数内可以通过 it指代该对象。返回值为函数的最后一行或指定return表达式。

  • 实例：

1
2
3
4
5
6
7
8
9
10
11
fun main(args: Array<String>) {
    val data = "孙悟空"
    data.let {
        //在函数体内使用it替代object对象去访问其公有的属性和方法
        println(it.toString())
    }
    data?.let {
        // 假如data不为null，代码会执行到此处
        println(it.toString())
    }
}

with

  • 定义：

    fun <T, R> with(receiver: T, block: T.() -> R): R

  • 功能：

    将对象作为函数的参数，在函数内可以通过this指代该对象。返回值为函数的最后一行或return表达式。

  • 实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
fun main(args: Array<String>) {
    var list = with(mutableListOf<String>()) {
        add("1")
        add("2")
        add("3")
        //返回值为函数的最后一行或return表达式
        this
    }
    println(list.toString())//[1, 2, 3]
}

fun main(args: Array<String>) {
    var paint = Paint()
    with(paint) {
        color = Color.BLACK
        strokeWidth = 1.0f
        textSize = 18.0f
        isAntiAlias = true
    }
}

apply

  • 定义：

    fun T.apply(block: T.() -> Unit): T

  • 功能：

    调用对象的apply函数，在函数范围内，可以任意调用该对象的任意方法，并返回该对象。

  • 实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
fun main(args: Array<String>) {
    // apply适用于那些对象初始化需要给其属性赋值的情况。
    var list = mutableListOf<String>().apply {
        add("1")
        add("2")
        add("3")
        //apply返回的是对象本身
    }
    println(list.toString())//[1, 2, 3]
}

fun main(args: Array<String>) {
//apply需要先初始化
    var paint = Paint().apply {
        color = Color.BLACK
        strokeWidth = 1.0f
        textSize = 18.0f
        isAntiAlias = true
    }
}

run

  • 定义：

    1. fun run(block: () -> R): R
    2. fun <T, R> T.run(block: T.() -> R): R

  • 功能：

    调用run函数返回值为函数体最后一行，或return表达式。

  • 实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fun main(args: Array<String>) {
    var list = mutableListOf<String>().run {
        add("1")
        add("2")
        add("3")
        //run返回的是函数体最后一行，或return表达式
        this
    }
    println(list.toString())//[1, 2, 3]
}

fun main(args: Array<String>) {
    var name = run {
        "孙悟空"
    }
    println(name)//孙悟空
}

repeat

  • 定义：

    fun repeat(times: Int, action: (Int) -> Unit)

  • 功能：

    重复执行action函数times次，times从0开始

  • 实例：

1
2
3
4
5
6
7
8
9
10
11
12
fun main(args: Array<String>) {
   repeat(3){
       //从0开始循环3次
       println("repeat:第${it}次")
   }
    for(i in 0..2){
       println("for:第${i}次")
    }
    (0..2).forEach{
       println("forEach:第${it}次")
    }
}

also

  • 定义：

    fun T.also(block: (T) -> Unit): T

  • 功能：

    调用对象的also函数，在函数块内可以通过 it指代该对象,返回值为该对象本身。（注意其和let函数的区别，let返回的是最后一行，also返回的是对象本身）

  • 实例：

1
2
3
4
5
6
7
8
fun main(args: Array<String>) {
    var list = mutableListOf<String>().also {
        it.add("1")
        it.add("2")
        it.add("3")
    }
    println(list.toString())//[1, 2, 3]
}

takeIf

  • 定义：

    fun T.takeIf(predicate: (T) -> Boolean): T?

  • 功能：

    传递一个函数参数，如果函数结果为true，返回T对象，否则返回null。

  • 实例：

1
2
3
4
5
6
7
8
9
10
fun main(args: Array<String>) {
    var list = mutableListOf<String>("1", "2", "3").takeIf {
        it.size > 3//满足条件则返回it,否则返回null
    }
    if (list != null) {
        println(list.toString())
    } else {
        println("list为空")
    }
}

takeUnless

  • 定义：

    fun T.takeUnless(predicate: (T) -> Boolean): T?

  • 功能：

    与takeIf相反，参数函数返回false时返回T对象，否则返回null

  • 实例：

1
2
3
4
5
6
7
8
9
10
fun main(args: Array<String>) {
    var list = mutableListOf<String>("1", "2", "3").takeUnless {
        it.size > 3//不满足条件则返回it,否则返回null
    }
    if (list != null) {
        println(list.toString())
    } else {
        println("list为空")
    }
}

发表于 分类于

EventBus封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
package com.example.eventbus.utils

import com.example.gaokao.event.MessageEvent
import org.greenrobot.eventbus.EventBus
import org.greenrobot.eventbus.meta.SubscriberInfoIndex

/**
 *
 * @author: xue
 * @description EventBus封装
 * @date: 2019/7/5
 */
class EventBusUtil {
    companion object {
        /**
         * 使用索引加速
         * 建议在Application中使用
         */
        fun installIndex(index: SubscriberInfoIndex) {
            EventBus.builder().addIndex(index).installDefaultEventBus()
        }

        /**
         * 注册
         */
        fun register(subscribe: Any) {
            if (!EventBus.getDefault().isRegistered(subscribe)) {
                EventBus.getDefault().register(subscribe)
            }
        }

        /**
         * 取消注册
         */
        fun unregister(subscribe: Any) {
            EventBus.getDefault().unregister(subscribe)
        }

        /**
         * 发布一个订阅事件
         * 必须先注册，才能接收到发布的事件，有点类似于 startActivityForResult（）方法
         */
        fun postEvent(event: MessageEvent) {
            EventBus.getDefault().post(event)
        }

        /**
         * 发布粘性事件（可以先发布事件，在注册后在接收）
         * 粘性事件将最新的信息保存在内存中，取消原始消息，执行最新的消息；
         * 只有注册后，才能接收消息，如果没有注册，消息将保留在内存中。
         */
        fun postStickyEvent(event: MessageEvent) {
            EventBus.getDefault().postSticky(event)
        }

        /**
         * 移除指定的粘性订阅事件
         *  @param eventType 事件类型
         */
        fun <T> removeStickyEvent(eventType: Class<T>) {
            var stickyEvent: T = EventBus.getDefault().getStickyEvent(eventType)
            if (stickyEvent != null) {
                EventBus.getDefault().removeStickyEvent(stickyEvent)
            }
        }
        /**
         * 移除指定的粘性订阅事件
         *  @param eventType 事件类型
         */
        fun removeStickyEvent(eventType:Any) {
            var stickyEvent = EventBus.getDefault().getStickyEvent(eventType as Class<Any>?)
            if (stickyEvent != null) {
                EventBus.getDefault().removeStickyEvent(stickyEvent)
            }
        }

        /**
         * 移除所有的粘性订阅事件
         */
        fun removeAllStickyEvents(){
            EventBus.getDefault().removeAllStickyEvents()
        }

        /**
         * 取消事件
         * 优先级高的订阅者可以终止事件往下传递
         * 只有在事件通过时才能调用（即在事件接收方法中调用）
         *  @param event 事件
         */
        fun cancelEventDelivery(event:Any){
            EventBus.getDefault().cancelEventDelivery(event)
        }

        /**
         * 获取 eventbus 单例
         */
        fun getEventBus():EventBus{
            return EventBus.getDefault()
        }
    }
}