# 以下内容由个人博客[ JsShou](http://jsshou.cn/)摘抄[dart中的list属性与方法](http://jsshou.cn/blog/flutter/dart_list.html#list)

> - List([int length]) 创建一个空数组或者 length 长度的数组
>
> - List.filled(int length,E fill,{bool growable:false}) 创建一个 list，每个元素共享相同的值，growable 表示是 list 长度是否可变，默认 false 固定长度

```dart
List a = new List.filled(10, 1);
print(a);//[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
```

> - List.from(iterable elements,{bool growable:true})

```dart
List a = new List.from([1, "2", 3, 4]);
print(a);//[1, 2, 3, 4]
```

> - List.generate(int length, E generator(int index) 创建一个元素，每个位置创建一个新对象

```dart

List a = new List.generate(10, (value) => value + 1);
print(a);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

> - List.unmodifiable(Iterable elements) 创建一个不可修改的 List
> - first List 中第一个元素
> - last List 中最后一个元素
> - length List 的长度
> - reversed 返回翻转 List 后的值，不改变原 List
> - add() 向数组中添加一个元素
> - addAll() 向数组中添加一个带有 Iterable 接口的类

```dart
List a = new List.from([1, "2", 3, 4]);
a.addAll([5, 6]);
print(a);// [1, 2, 3, 4, 5, 6]
```

>asMap() 返回一个不可修改的 Map,keys 为 List 顺序

```dart
List a = new List.from([1, "2", 3, 4]);
Map b = a.asMap();
print(b);
print(a);
CONSOLE:
{0: 1, 1: 2, 2: 3, 3: 4}
[1, 2, 3, 4]
```

> - cast() 如果 List 中所有类型满足 R,正常工作并返回 List，如果有一个不满足，将会抛出错误

```dart
List a = new List.from([1,"2", 3, 4]);
print(a.cast<int>());//抛出错误：type 'String' is not a subtype of type 'int' in type cas
```

> - clear() 删除所有元素
> - fillRange(int start,int end,[E fillValue]) 在选择的范围插入一个新的元素

```dart
List a = [1, 2, 3, 4];
print(a.getRange(1, 3));//(2, 3)
print(a);//[1, 2, 3, 4]
```

> - indexOf() 找到第一个满足条件的下标

```dart
List a = [1, 2, 3, 4];
print(a.indexOf(3));//2
```

> - indexWhere(bool test(E element),[int start=0]) 迭代 list，返回第一个满足条件的下标

```dart
 List a = [1, 2, 3, 4];
print(a.indexWhere((value) => value % 2 == 0));//1
```

> - insert(int index,E element) 在 index 处插入一个元素

```dart
List a = [1, 2, 3, 4];
a.insert(2, 'jsshou');
print(a);//[1,2,jsshou,3,4]
```

> - nsertAll(int index,iterable iterable) 在 index 处插入一个数组

```dart
List a = [1, 2, 3, 4];
a.insertAll(2, ['jsshou', 'good']);
print(a);//[1, 2, [jsshou, good], 3, 4]
```

> - lastIndexOf(E element, [ int start ]) 类似 indexOf，迭代从后往前
> - lastIndexWhere(bool test(E element), [ int start ]) 类似 indexWhere，迭代从后往前
> - remove(Object value) 删除第一个匹配到的 value

```dart
List a = [1, 2, 3, 4, 3];
a.remove(3);
print(a);// [1,2,4,3]
```

> - removeAt(int index) 删除 index 处的数据

```dart
List a = [1, 2, 3, 4, 3];
a.removeAt(3);
print(a);//[1, 2, 3, 3]
```

> - removeLast() 删除最后一个数据
> - removeRange(int start,int end) 删除 start 到 end 处的数据

```dart
List a = [1, 2, 3, 4, 3];
a.removeRange(2, 3);
print(a);//[1,2,4,3]
```

> - removeWhere() 迭代数据，删除回调中返回 true 的数据

```dart
List a = [1, 2, 3, 4, 3];
a.removeWhere((value) => value % 2 == 0);
print(a);//[1,3,3]
```

> - replaceRange(int start,int end,iterable replacement) 删除 start 到 end 的数据插入 replacement

```dart
List a = [1, 2, 3, 4, 3];
a.replaceRange(2, 4, [10, 11, 12, 13]);
print(a);//[1, 2, 10, 11, 12, 13, 3]
```

> - retainWhere(bool test(E element)) 删除不满足条件的数据

```dart
List a = [1, 2, 3, 4, 3];
a.retainWhere((value) => value % 2 == 0);
print(a);//[2, 4]
```

> - setAll(int index,iterable iterable) 从 index 开始插入一个 iterable 数据（对比 insertAll)
> - 它与 insertAll 的区别是 insertAll 不会删除原数组的值，setAll 会删除插入处一个或多个值

```dart
List a = [1, 2, 3, 4, 5];
a.setAll(2, ['jsshou', 'good']);
print(a); //[1, 2, jsshou, good, 5]
```

> - setRange(int start,int end,Iterable iterable,[int skipCount=0]) 从原数组 start 处开始到 end 结束替换一个 iterable，可选参数 skipCount 表示从 iterable 第 skipCount 处开始复制

```dart
List<int> list1 = [1, 2, 3, 4];
List<int> list2 = [5, 6, 7, 8, 9];
list1.setRange(1, 3, list2, 2);
print(list1.join(', ')); // 1, 7, 8, 4
```

> - shuffle([Random random]) 随机排列 list
> - sort(int compare(E a,E b)) 排序,类似 js 中的 sort

```dart
List<int> list = [1, 2, 3, 4, 9, 8, 7, 6];
list.sort((a, b) => a - b);
///时间排序
[{'createTime' : '2020-09-03 15:03'},{'createTime':'2020-09-03 18:00'}].sort((left,right) => right['createTime'].compareTo(left['createTime']));///结果自己试一试
print(list);//[1, 2, 3, 4, 6, 7, 8, 9]
```

> - sublist(int start,[int end]) 提取 list 数据

```dart
List<int> list = [1, 2, 3, 4, 9, 8, 7, 6];
print(list.sublist(2, 5));
```

> - contains(Object element) 比较原数组中是否包含 element

```dart
List<int> list = [1, 2, 3, 4];
List<int> list2 = [1, 2, 3, 4];
print(list.contains(1));//true
print(list2.contains(5));//false
```

> - elementAt(int index) 返回 index 处的数据

```dart
List<int> list = [1, 2, 3, 4];
print(list.elementAt(2));//3
```

> - every(bool test(E element)) list 每一项是否满足条件

```dart
List<int> list = [1, 2, 3, 4];
List<int> list1 = [0, 2, 4, 6];
print(list.every((item) => item % 2 == 0));//false
print(list1.every((item) => item % 2 == 0));//true
```

> - expand(Iterable f(E element)) 展开 list (类似 js 中的 flat)

```dart
var pairs = [[1, 2], [3, 4]];
var flattened = pairs.expand((pair) => pair).toList();
print(flattened); // => [1, 2, 3, 4];

var input = [1, 2, 3];
var duplicated = input.expand((i) => [i, i]).toList();
print(duplicated); // => [1, 1, 2, 2, 3, 3]
```

> - firstWhere(bool test(E element),{E orElse()}) 迭代元素返回第一个满足 test，如果没有，返回 orElse 调用结果

```dart
var list = [1, 2, 2, 4];
var res = list.firstWhere((pair) => pair == 2);
print(res);//2
```

> - fold(T initialValue,T combine(T previousValue,E element)) 把 initialValue 作为初始值，迭代原数组，返回新的 value，类似 js 中的 reduce，eg:

```dart
var value = initialValue;
for (E element in this) {
  value = combine(value, element);
}
return value;
```

> - followedBy(iterable other) 将 other 数据添加到原数组，返回 Iterable 类型

```dart
List a = new List.from([1, 2, 3, 4]);
Iterable b = a.followedBy([1, 2, 3]);
print(b);//(1, 2, 3, 4, 1, 2, 3)
```

> - forEach(void f(E element)) 迭代数组

```dart
List list = [1, 2, 3, 4];
list.forEach((item) {
    print(item);
});
//1,2,3,4
```

> - join([String separator='']) 把数组转成字符串中间用 separator 隔开

```dart
var list = [1, 2, 2, 4];
var res = list.join('*');
print(res);//1*2*3*4
```

> - lastWhere(bool test(E element),{E orElse})

```dart
var list = [1, 2, 2, 4];
var res = list.lastWhere((pair) => pair == 2);
print(res);//3
```

> - map(T f(E e)) 迭代数组并返回一个新的数组，新数组长度跟原数组长度一样

```dart
var list = [1, 2, 2, 4];
var res = list.map((pair) => pair * 2);
print(res);//(2, 4, 4, 8)
```

> - noSuchMethod(Invocation invocation) 访问不存在的方法或属性调用
> - reduce(E combine(E value,E element)) value 为初始值为原始数组第一项，后面是 combine 返回的项

```dart
List a = new List.from([1, 2, 3, 4]);
var b = a.reduce((a, b) {
  print(a.toString() + ',' + b.toString());
  return a + b;
});
print(b);
//1,2
//3,3
//6,4
//10
```

> - singleWhere(bool test(E element),{E orElse()}) 检查元素以查看是否 test(element)返回 true。如果只满足一个元素 test，则返回该元素。如果找到多个匹配元素，则抛出 StateError。如果未找到匹配元素，则返回结果 orElse。如果 orElse 省略，则默认为抛出 StateError
> - skip(int count) 返回原数组 count 后面的元素

```dart
List a = new List.from([1, 2, 3, 4]);
print(a.skip(2));//(3, 4)  //返回Iterable类型
print(a);//[1, 2, 3, 4]
```



> - skipWhile(bool test(E value))

```dart
List a = new List.from([1, 2, 3, 4]);
print(a.skipWhile((value) {
  print(value);
  if (value == 3) {
    return false;
  }
  return true;
}));
print(a);
输出:
1
2
3
(3, 4)
[1, 2, 3, 4]
```

> - take(int count)

```dart
List a = new List.from([1, 2, 3, 4]);
print(a.take(2));//(1,2)
```

> - takeWhile(bool test(E value)) 遍历迭代器，直到找到 test 返回为 false 的元素，停止遍历返回找到的 iterable

```dart
List a = new List.from([1, 2, 3, 4]);
print(a.takeWhile((value) => value != 2));
//(1)
```

> - toList({bool growable:true}) 将 Iterable 类转为 List
> - toSet() 将 Iterable 类及其子类转为 Set
> - toString()
> - where(bool test(E element)) 遍历元素，返回所有满足条件的元素,类似 js 中的 filter

```dart
List a = new List.from([1, 2, 3, 4]);
print(a.where((value) => value != 2));//（1，3，4）
```

> - whereType() 找到原 list 中带有 T 类型的元素

```dart
List a = new List.from([1, "2", 3, 4]);
print(a.whereType<String>());//(2)
```

dart语言之list操作

Flutter1.0初学时项目使用封装监听滚动
------

**做记录使用大概没得啥博客价值,直接丢代码**

```dart
import 'package:common_utils/common_utils.dart';
import 'package:flutter/cupertino.dart';

/// 提出滚动组件ScrollController滚动计算出显示与隐藏
/// @param 
/// @return 
/// @author 
/// created at 2020/8/19 15:21
///
@optionalTypeArgs
mixin ScrollCalculatedAttributesClientMixin{

  ///滚动最大值做出反应
  @protected
  double get scrollOffsetMax;

  ///滚动为负数时是否停止一切操作
  @protected
  bool  get OffsetNegative;

  ///滚动旧数据
  double _oldScrollOffset = 0.0;
  double get oldScrollOffset => _oldScrollOffset;

  bool _isStay = true;

///
/// @param offset [实时滚动高度]
/// @param dynamicHeight [动态高度,需手动传入] | 可选参数
/// @return  true | false 根据返回值更新数据
/// @author 
/// created at 2020/8/19 11:43
///
  bool setScrollReaction(double offset,[double dynamicHeight]){
    double _scrollOffsetMax = scrollOffsetMax;
    bool _OffsetNegative = OffsetNegative;
//    print("滚动高度 = $offset");
//    print("历史高度 = $_oldScrollOffset");
    if(ObjectUtil.isEmpty(scrollOffsetMax)) _scrollOffsetMax = 20.0;
    if(ObjectUtil.isNotEmpty(dynamicHeight)) _scrollOffsetMax = dynamicHeight;
    if(ObjectUtil.isEmpty(OffsetNegative)) _OffsetNegative = true;
    ///判断 负数后停止操作 & 滚动高度为负数
    if(_OffsetNegative && offset.isNegative){
      _isStay = true;
      _oldScrollOffset = 0.0;
    }else{
      if(offset - _oldScrollOffset >= _scrollOffsetMax){
        _oldScrollOffset = offset;
        _isStay = false;
      }
      if(_oldScrollOffset - offset  >= _scrollOffsetMax){
        _isStay = true;
        _oldScrollOffset = offset;
      }
    }
    return _isStay;
  }

}


```

#### 注意事项

> 使用ScrollController控制器,放在需要滚动的组件上
>
> 在initState里面监听
>
> ```dart
> scrollController.addListener(() {
> //     _scrollController.position.pixels 获取当前滚动部件滚动的距离
> //     当滚动距离大于 单位一屏之后，显示回到顶部按钮
> //scrollController.position.pixels(滚动距离)
> });
> ```
>
> 如果滚动的最大距离(scrollOffsetMax)是变量的 则需要手动传入,常量就不需要了

## 记录原由 

首次发现mixin挺好用的写了个样例

之后逐渐发现使用mixin结合rxdart做数据请求也挺好用的(简单页面仅仅单次请求)

flutter学习之mixin抽离监听滚动

将lodop使用到electron自动调起打印
------

## 记录摸索electron与lodop的辛酸历程

#### 一、放弃在主进程调用CLodopfuncs.js服务吧

> 别挣扎了,当时考虑着是服务端渲染,服务端与客户端分离,打算将lodop服务调用写在主进程中,经历了三天的折磨,没搞出来
>
> 首先获取不到doucment,------------------------绝路
>
> 其次将doucment从渲染进程传到主进程序列化是不可能的
>
> 从序列化转到使用插件 ,因为序列化dom树结果是空,electron通讯不能传输dom,报错 : Error: An object could not be cloned.
>
> 丧心病狂的使用插件XMLserializer +parse5 将dom树解析成XML传输(终于成功了)
>
> 主进程用插件DOMParser解析XML成text/html类型数据
>
> 结果lodop服务里面CLodopfuncs.js文件有些运行不完整   ----------------> 个别几个参数出现 is not defined ,炸不炸裂
>
> 三天 electron不熟悉 lodop第一天就调起以为超简单,什么鬼心态
>
> 想想我现在写着几句话的有多大的怨

#### 二、老老实实在渲染进程调用

> 做好通信
>
> 就算在渲染进程能调用到主进程js(我在开窗口的时候给了nodeIntegrationTo为true,原生html可使用node引入方式),也得走通信,原因是有时候放在global的命名空间也可能获取不到(不晓得是什么原因,心态炸了没细查);
>
> 在壳这边写个小页面来获取doucment(操作烦不烦都无所谓了),放了提示与确定按钮
>
> 大概这个样子

|              |                 |                |
| :----------: | :-------------: | :------------: |
| 正在尝试调起 | 外部打印机,点击 | 确定进行下一步 |
|              |                 |                |
|              |                 |      确定      |

 

> 调起这个界面的时候就发了个通信将需要打印的html经过渲染进程传输到主进程又传输到渲染进程然后保存在这个界面上
>
> 当时想着是在初始化的时候将CLodopfuncs加载一遍到时候用就行了,结果谁想得到获取的服务内容赋值给window上都会变得不一样(反正不知道哪里不一样代码对了下是一样的,大概想了下应该是这玩意必须实时创建)不能用
>
> 然后将加载服务获取到的LODOP拿来调用打印,真是不容易啊!终于成功了
>
> 剩下的就是读文档了[lodop技术文档](https://raw.githubusercontent.com/18487115313/18487115313.github.io/master/screenshot/Lodop技术手册6.2.2.6.doc)

#### 三、lodop真的是只能打印原生界面，样式可以内联，不内联的可以与内容一起拼接成字符串打印,不会的看[样例10](http://www.c-lodop.com/demolist/PrintSample10.html)

#### 四、[lodop官网](http://www.lodop.net)

#### 五、不附代码了



electron学习之lodop打印机

此文档只记录Flutter中sentry搭建上报

**当前教程只负责搭建Flutter模块**

##### 搭建前提

一、需要搭建Sentry服务[Sentry搭建教程](https://www.jianshu.com/p/ca4ad23a2dd6)

二、熟悉Flutter异步异常同步异常

****

##### 入坑注意事项

一、main方法中将所有初始化操作都包含在runZoned中[1.17.0版本以上推荐使用runZonedGuarded]

> 不包含在里面会导致runZoned[runZonedGuarded]失效(现目前测试是此原因)监听不到异常

二、区分异步异常与同步异常

> 具有async以及请求异常为异步异常,try/catch为同步异常

三、教程中Map对象中有\n符号,是为了在服务页面(html页面自动解析\n符号)显示容易解读

##### 着手搭建

一、异常上报数据

​	1、错误标题

​	2、错误详细位置

​	3、设备信息

​	4、用户信息

二、用到插件

​	1、sentry: ">=3.0.0 <4.0.0"；以官网为准[Flutter官方推荐使用样例](https://flutter.dev/docs/cookbook/maintenance/error-reporting)

​	2、device_info；获取设备信息，版本以插件库为准

三、异常分类处理

​	1、RangeError ；dart异常

​	2、FlutterErrorDetails；页面渲染异常

​	3、MissingPluginException； 服务异常

​	4、DioError ；Dio请求异常

> 异常都为自定义可由error.runtimeType.toString()断定为什么异常

四、异常处理

###### 枚举定义

```dart
enum ErrorExceptionEnum{
  /// dart异常
  RangeError,
  ///页面渲染异常
  FlutterErrorDetails,
   ///服务定义异常
  MissingPluginException,
  ///dio请求异常
  DioError
}
```

###### 请求错误定义

```dart
///异常类型与枚举对应
Map<String ,ErrorExceptionEnum> errorMap = {
  'RangeError' : ErrorExceptionEnum.RangeError,
  'FlutterErrorDetails' : ErrorExceptionEnum.FlutterErrorDetails,
  'MissingPluginException' : ErrorExceptionEnum.MissingPluginException,
  'DioError' : ErrorExceptionEnum.DioError,
};

class ErrorParsing{
  static dynamic errorStatus(dynamic error){
      ///判断是否是请求异常
      ///将请求接口地址获取
    if(errorMap[error.runtimeType.toString()] == ErrorExceptionEnum.DioError){
      return {
        '\n msgData' :error?.response?.data??'',
        '\n 请求域名' :error?.request?.baseUrl ??'',
        '\n 请求类型' : error?.request?.method??'',
        '\n 请求地址' : error?.request?.path??'',
        '\n 错误error' : '$error \n'
      };
    }
    return error;
  }
}
```

###### 获取设备信息

1、Android信息处理

```dart
////自己翻译结果  
Map<String, dynamic> _readAndroidBuildData(AndroidDeviceInfo build) {
    return <String, dynamic>{
      ' \n 最新补丁日期':'${build.version.securityPatch}',
      ' \n 操作系统名' : '${build.version.baseOS??'安卓'}',
      ' \n sdkInt':'${build.version.sdkInt}',
      '\n Android版本': '${build.version.release} ',
      '\n 手机品牌 ': '${build.brand} ',
      '\n 手机详细版本': '${build.model} ',
      '\n 外观设计名 ': '${build.device} ',
      '\n 版本号': '${build.display} ',
      '\n 当前手机唯一标识': '${build.fingerprint} ',
      '\n 内核(单词简写)': '${build.hardware} ',
      '\n 主机名 ': '${build.host} ',
      '\n id': '${build.id} ',
      '\n supported32BitAbis': '${build.supported32BitAbis} ',
      '\n supported64BitAbis': '${build.supported64BitAbis} ',
      '\n supportedAbis': '${build.supportedAbis} ',
      '\n 是否真机': '${build.isPhysicalDevice} \n',
    };
  }

///官方插件提供样例device_info
//  Map<String, dynamic> _readAndroidBuildData(AndroidDeviceInfo build) {
//    return <String, dynamic>{
//      'version.securityPatch': build.version.securityPatch,
//      'version.sdkInt': build.version.sdkInt,
//      'version.release': build.version.release,
//      'version.previewSdkInt': build.version.previewSdkInt,
//      'version.incremental': build.version.incremental,
//      'version.codename': build.version.codename,
//      'version.baseOS': build.version.baseOS,
//      'board': build.board,
//      'bootloader': build.bootloader,
//      'brand': build.brand,
//      'device': build.device,
//      'display': build.display,
//      'fingerprint': build.fingerprint,
//      'hardware': build.hardware,
//      'host': build.host,
//      'id': build.id,
//      'manufacturer': build.manufacturer,
//      'model': build.model,
//      'product': build.product,
//      'supported32BitAbis': build.supported32BitAbis,
//      'supported64BitAbis': build.supported64BitAbis,
//      'supportedAbis': build.supportedAbis,
//      'tags': build.tags,
//      'type': build.type,
//      'isPhysicalDevice': build.isPhysicalDevice,
//      'androidId': build.androidId,
//      'systemFeatures': build.systemFeatures,
//    };
//  }

```

2、IOS设备信息获取

```dart
  Map<String, dynamic> _readIosDeviceInfo(IosDeviceInfo data) {
    return <String, dynamic>{
      '\n 设备名': '${data.name} ',
      '\n 操作系统名': '${data.systemName} ',
      '\n 系统版本': '${data.systemVersion} ',
      '\n 设备型号': '${data.model} ',
      ' \n 设备名(本地)': '${data.localizedModel}',
      '\n 当前设备唯一值': '${data.identifierForVendor} ',
      '\n 是否真机': '${data.isPhysicalDevice} ',
      '\n 版本号': '${data.utsname.version} ',
      '\n 硬件类型': '${data.utsname.machine} \n',
    };
  }
///官方插件提供样例device_info
//  Map<String, dynamic> _readIosDeviceInfo(IosDeviceInfo data) {
//    return <String, dynamic>{
//      'name': data.name,
//      'systemName': data.systemName,
//      'systemVersion': data.systemVersion,
//      'model': data.model,
//      'localizedModel': data.localizedModel,
//      'identifierForVendor': data.identifierForVendor,
//      'isPhysicalDevice': data.isPhysicalDevice,
//      'utsname.sysname:': data.utsname.sysname,
//      'utsname.nodename:': data.utsname.nodename,
//      'utsname.release:': data.utsname.release,
//      'utsname.version:': data.utsname.version,
//      'utsname.machine:': data.utsname.machine,
//    };
//  }
```

3、获取设备信息

```dart
 final DeviceInfoPlugin deviceInfoPlugin = DeviceInfoPlugin();
Future<Map<String, dynamic>> initPlatformState() async {
    Map<String, dynamic> deviceData;
    try {
      if (Platform.isAndroid) {
        deviceData = _readAndroidBuildData(await deviceInfoPlugin.androidInfo);
      } else if (Platform.isIOS) {
        deviceData = _readIosDeviceInfo(await deviceInfoPlugin.iosInfo);
      }
    } on PlatformException {
      deviceData = <String, dynamic>{
        'Error:': 'Failed to get platform version.'
      };
    }
   return deviceData;
  }
```

###### 异常数据上报(可上报到Sentry或者进行接口上报)

```dart
 static Future<Null> reportError(dynamic error, dynamic stackTrace) async {
    print("异常收集 error = ${error.toString()}");
    print("error.type = ${error.runtimeType.toString()}");
    initPlatformState().then((res){
      Map<String,dynamic> _errMap = {
        '\n 错误类型' :error.runtimeType.toString(),
        '\n error' : ErrorParsing.errorStatus(error),
        '\n 设备信息' :res,
        '\n 用户信息' :'${App.currentUser.toString()} \n '
      };
      ...Sentry上报或者接口上报
    }).catchError((err){
      Map<String,dynamic> _errMap = {
        '\n 错误类型' :error.runtimeType.toString(),
        '\n error' : ErrorParsing.errorStatus(error),
        '\n 设备信息' :'获取设备信息出错',
        '\n 用户信息' : '${App.currentUser.toString()} \n '
      };
      ...Sentry上报或者接口上报
    });
  }
```

Sentry上报

```dart
import 'package:sentry/sentry.dart'
final String _dsn = 'Sentry服务模块地址';
final RcSentry.SentryClient _sentry = new RcSentry.SentryClient(dsn: _dsn);

		///提交异常到Sentry服务
      _sentry.captureException(
        exception: _errMap,
        stackTrace: stackTrace,
      );
```

##### 错误页面上报

> 定义错误友好页面
>
> 在main -> 首页中定义接收错误ErrorWidget.builder = getErrorWidget;

```dart
///捕获页面异常，建议布局分块布局，以免出现异常异常模块以下都不会显示
Widget getErrorWidget(FlutterErrorDetails error)  {
  print(
      "异常日志开始+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
  print("异常日志=$error");
  print(
      "异常日志结束--------------------------------------------------------------------");
   ///传入错误自动上传
  reportError(error, null);
  return Scaffold(
    body: Center(
        child: Text('错误页面')),
  );
}
```

##### 同步异常上报

```dart
try{
    ...
}catch(err,stack){
    reportError(err, stack);
}
```

##### 异步异常上报

> 只需要在方法上添加async可自行获取异常







Flutter-使用Sentry上报异常搭建


#### **Tree使用**

1、动态加载Tree结构时，默认选中以及默认展开功能问题

> 动态数据默认选中能选中，但是默认展开功能会失效
>
> 解决方案 ： 

```react
/**
*@loop方法 官网中方法
*@this.props.selectedKeys 默认选中数据  string[]  
*@this.props.expandedKeys 默认展开数据 string[]
*/
render(){
    return(
        <div>
         	{
                this.props.treeData && this.props.treeData.length > 0 ? 
                <Tree className="draggable-tree"
             		 defaultSelectedKeys={this.props.selectedKeys}
            		 defaultExpandedKeys={this.props.expandedKeys}
           			 blockNode>
              {loop(this.props.treeData)}
          </Tree > : '暂无数据'
            }   
         <div>
    )
}
```

#### **dva使用详解**

> ​	需要在 config.js文件进行开启配置

```react
plugins :[
    ['umi-plugins-react',{
        dva : true
    }]
]
```

在umi中，约定在src/models文件夹中定义model进行数据处理交互

> 以代码为例，使用dva进行分层

1、page页

```react
import React from 'react'
import { connect } from 'dva'

//model层[namespace]唯一值，提供给page页面找到指定的model数据
const namespace = 'spanModel';

/**
* 第一种写法
* [connect中参数解析]
* @val 作用：将page层与model层进行连接，并将数据绑定到this.props
* @dispatch 作用：调用model层effects中方法
*/
@connect((val) => {
   return {
    spanText : val[namespace].spanText,//spanText是mnodel中定义的值
   }
},(dispatch) =>{
   return {
     OnChange : (val) =>{
      dispatch({
        type : `${namespace}/OnChange`,//调用namespace =spanModel的model中OnChange方法
        payload : val //传值
     });
     }
   }
})
class DvaPage extends React.Component{
    render(){
        return(
            <div>
                <span>{this.props.spanText}</span>
                <button onClick = {this.props.OnChange.bind('嘿嘿')}>点击更改值</button>
            </div>
            //.bind("嘿嘿"),自定义方法传值方式之一
        )
    }
}



/* 
* 第二种写法
* 适用于添加了hooks
*/
const dvaState = ()=>{
    return {
    spanText : val[namespace].spanText,
   }
}
const DvaPage =(props) =>{
   const  OnChange = (val) =>{
     const { dispatch } = props;
      dispatch({
        type : `${namespace}/OnChange`,
        payload : val
     });
   }
    return(
        <div>
                <span>{this.props.spanText}</span>
                <button onClick = {this.props.OnChange.bind('嘿嘿')}>点击更改值</button>
          </div>
    )
}
export default connect(dvaState)(DvaPage)

```

2、model页面

```react
export default {
    namespace: 'spanText',
    state: {
        spanText: '',//树结构数组
    },
    reducers: {
        /**
        * @odlstate 当前state
        * @res effects中put过来的值
        */
      setSpanText: (odlstate, res) => {
            if (res.data) { 
                //给state中的spanText更新值
                //也可以直接返回res.data，会自动复制（不推荐）
                return { ...odlstate, spanText: res.data}; 
            }
        }
    },
    effects: {
        /**
        * 写法一
        * @payload page页面传入的参数
        * @call 请求使用
        * @put 提交数据到reducers进行数据更新
        */
        OnChange({ payload }, { call, put }) {
            yield put({
                type: 'setSpanText',
                data: payload,
            }); // Lo
        },
        //写法二
        //带星号是属于异步进行数据操作：如请求操作
        *OnChange({ payload }, { call, put }){}

    }

}
```

#### **hooks用法**

> 还不熟练  简单写写以后完善

```react
import React ,{ useState } from 'react'
import { connect } from 'dva'
//不能适用类的写法
const namespace = 'spanModel';
const DvaPage =(props) =>{
    /**
    * @text 初始值
    * @setText 更改值得方法
    */
    const {text,setText} = useState('嘿嘿'); //可以规定值得类型 useState<string>('嘿嘿')
    return(
        <div>
               <span>{`显示这个文字${text}`}</span>
               <button onClick={() => setText('哈哈')}>更改值</button>
         </div>
    )
}
export default connect(null)(DvaPage)



```

#### **react-redux运用**

1、树结构详解（切勿多次定义属性名。以免树结构层次变深）

>reducers中返回的命名是state树最底下的名字

```react

//reducers.js
import * as Audit from './auditTypes';

//treeData 最终取值属性名
//treeReducer 可在合并时更改
const treeReducer = (state = [], action) => {
    switch(action.type) {
      case Audit.AUDIT_TREE:
        return {
          ...state, treeData: action.treeData
        }
      default:
        return state
    }
  }
  
  export default treeReducer;
```

```react
import { combineReducers } from 'redux';
import treeReducer from './auditReducers';
//treeReducer在此处还能更改树结构（合并处）
const auditReducers = combineReducers({
    treeReducer,
    //treeData : treeReducer 将treeReducer重命名为treeData
  })
  
  export default auditReducers;
```

> 合并后最上层属性为合并时定义的属性名；如：auditReducers
>
> 当取值时取值依次为：树结构.合并名.单个reducers名.定义名；
>
> 如：

```react
//业务.js(取值操作)
const mapStateToProps = (state, ownProps) => {
  return {
    treeData: state.auditReducers.treeReducer.treeData
  }
}
```

**react对函数式组件优化**



以下内容由个人博客 JsShou摘抄dart中的list属性与方法

Flutter1.0初学时项目使用封装监听滚动

将lodop使用到electron自动调起打印

记录摸索electron与lo

Tree使用