cat

dabaicai has a cat

0%

发表于 更新于 分类于
  • 1.28去安吉参加婚礼，本来呢还想着去玩玩的，结果没啥时间去玩，就第二天的下午去了一个庙去逛了下，晚上吃完席也就回杭州了
  • 3.16夏友谊婚礼
  • 5.12章如玉婚礼，天气有点不好下雨，看到了高中的数学陈丽华老师，很亲切，和在高中一样，可惜没去说说话，当时在帮忙干活呢
  • 8.30 家里多了一个新成员，元宝，元宝生日是2.8，大大的一个有6.22斤，到10.22的时候竟然有7.74斤了，在店里的时候还是很活泼的，不怕人，一摸头就躺下了。只是眼泪有重，带回家先给他关了几天的笼子，期间也放出来过，到家也不怕人也不怕胖宝。但是吧胖宝一看到他的时候就哈他，把他关厨房的笼子再加关门也哈，期间胖哈人的时候就不给摸，猫猫拳估计已经是大成了。
  • 9.4
  • 9.8
  • 9.10

发表于 分类于 
24年已经过去半个多月了，本想着在23年年底写完的，但是那啥一言难尽，拖到了现在才动手，还是得写点啥。

​ 先来聊聊为啥拖了这么久吧，主要还是自己的原因吧，不能说懒，就是拖延症，最早计划年底写，再变成了元旦的时候去宁波看看有没有空写，其次就是元旦回来做的规划在24年的第一个星期写完，最后到了今天才开始新建文件开始动笔。其次是工作上的变动也有影响，直接通知没有岗位了还是挺无语的，赶人的速度也不是一般的快，就真的是职场只有利益吗，整的挺恶心的。

​ 好了，聊完上面的开始对23年做的来捋一下吧。想了一会有挺多的但是不知道如何表述，先聊聊工作吧，印象最深的就是23年也就是兔年回来上班之后不久原来小组是坐在13楼的，搬到了4楼去，那13楼就剩下了4个人，因为二个女同学怀孕了才留下了4个人，四人组在兔年的工作就是维护几乎所有的老项目了，之后的半年内工作就变得很轻松了，几乎不用做新的功能，在上班的时间也就有很多空闲的时间了，其实也没有闲着自我感觉还是看了挺多东西的，可能效率不是那么的高，看的东西现在要我来说是什么也忘的七七八八了，其一过了一遍flutter的一些基本原理，感觉要做flutter的话原理源码啥的还是需要拥有的，这部分的知识主要来自于掘金小册上，自我感觉知识面很全了，就是看了一遍没有怎么去实践，内容到现在就是GG，想着啥时候有时间在去刷刷（无他，唯手熟尔，这个境界想想就牛逼）；其二就是即刻时间上看了几个专栏确实没有学到什么东西，甚至于到现在讲啥都不太知道了，我这是到了忘他的境界了吗，看了也有一些：“手把手带你写一个MiniSpring”、“超级访谈：对话玉伯”、“计算机基础实战课”、“Linux0.11源码趣读”、“深入浅出计算机组成原理”、“从0开发一款iOS App”。在极客时间上差不多好像应该看了这些；其三就是学了一点点的ios相关的一些东西，不能说会了，只能说能看懂一点点了；总结一下：看的挺多但是记得不多，哈哈，还是要相信看的东西都会进脑子里面的。与此相关的还有就是晚上的学习了，看了有stm32的一些知识，但是搁置了（7-12月，下次启动从操作系统篇开始看起），还有就是很良心的一个课程，码牛大大滴好，从买课到现在起码二年了，还在上课更新，真的很良心了，看了课程中的车载部分，有点收获但是也忘了。。。。。。

​ 接下来就该是周末的私人时间了，因为买了车所以去年就去了杭州挺多的地方玩，想去哪儿就去哪儿（见2023进度条）。看到这个还有就是去年一年都有好好坚持跑步，还去了千岛湖的半马，完赛成绩二小时十二分，感觉后面五公里真的真的是跑不动，腿就像不是自己的一样，接下来有个问题就是想想要是今年还有机会的话我想想还会参加吗，参加的话是半马还是全马呢，现在的我不知道，但是应该还是会参加，想体验一次全马，也想要挑战一下自己（ps争取完赛拿到奖牌加油加油）；24年多陪点爸爸妈妈，23年因为自己也不算小了叫抓紧时间，所以也老是聊不到一块去，就酱紫吧。去年还买了相机和无人机，要好好苦练无人机和拍照技术了，不能白买了。

阅读全文 »

发表于 更新于 分类于

  • 代码

    1
    2
    3
    4
    5
    6
      ---->[01/01]----
      void main() {
        runApp(const ColoredBox(color: Colors.red));
      }
      
    <!--more-->

  • 源码

    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
    void runApp(Widget app) {
      // 返回一个 WidgetsBinding 对象
      WidgetsFlutterBinding.ensureInitialized()
        // 分析 1
        ..scheduleAttachRootWidget(app)
        // 分析 2
        ..scheduleWarmUpFrame();
    }

      static WidgetsBinding ensureInitialized() {
        if (WidgetsBinding._instance == null) {
          // 本身没有构造函数，调用父类构造函数
          WidgetsFlutterBinding();
        }
        return WidgetsBinding.instance;
      }

      BindingBase() {
        ...
          //初始化根渲染对象 即 renderview
        initInstances();
        ...
        initServiceExtensions();
        ...
      }

  • ..scheduleAttachRootWidget(app) 

    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
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
      // rootWidget 是 runApp 穿进来的 ColorBox
    	@protected
      void scheduleAttachRootWidget(Widget rootWidget) {
        Timer.run(() {
          attachRootWidget(rootWidget);
        });
      }

      void attachRootWidget(Widget rootWidget) {
        final bool isBootstrapFrame = renderViewElement == null;
        _readyToProduceFrames = true;
        // _renderViewElement 是根元素节点
        // RenderObjectToWidgetAdapter 是根widget节点
        // 首先构造出了根widget节点 RenderObjectToWidgetAdapter
      	// 再由根 widget 节点的 attachToRenderTree 方法返回了根元素节点
        _renderViewElement = RenderObjectToWidgetAdapter<RenderBox>(
          container: renderView,
          debugShortDescription: '[root]',
          child: rootWidget,
        ).attachToRenderTree(buildOwner!, renderViewElement as RenderObjectToWidgetElement<RenderBox>?);
        if (isBootstrapFrame) {
          SchedulerBinding.instance.ensureVisualUpdate();
        }
      }

    // RenderObjectToWidgetAdapter 类及主要方法
    class RenderObjectToWidgetAdapter<T extends RenderObject> extends RenderObjectWidget {
      // 构造函数单纯赋值
      RenderObjectToWidgetAdapter({
        this.child,
        required this.container,
        this.debugShortDescription,
      }) : super(key: GlobalObjectKey(container));

      final Widget? child;

      final RenderObjectWithChildMixin<T> container;

      final String? debugShortDescription;

      @override
      RenderObjectToWidgetElement<T> createElement() => RenderObjectToWidgetElement<T>(this);

      @override
      RenderObjectWithChildMixin<T> createRenderObject(BuildContext context) => container;
      
      // element ：根节点 现在为null
      // owner ：
      RenderObjectToWidgetElement<T> attachToRenderTree(BuildOwner owner, [ RenderObjectToWidgetElement<T>? element ]) {
        if (element == null) {
          owner.lockState(() {
            // 创建了 RenderObjectToWidgetElement 类型的根元素节点
            element = createElement();
            assert(element != null);
            // 在父类中赋值 _owner = owner;
            element!.assignOwner(owner);
          });
          owner.buildScope(element!, () {
            element!.mount(null, null);
          });
        } else {
          element._newWidget = this;
          element.markNeedsBuild();
        }
        return element!;
      }
    }
    	// 主要执行了 callback 方法，也就是 RenderObjectToWidgetAdapter 类中的 createElement() 方法创建了根元素节点
      void lockState(VoidCallback callback) {
        try {
          callback();
        } finally {
          assert(() {
            _debugStateLockLevel -= 1;
            return true;
          }());
        }
      }

    	// 主要执行了 callback 方法，即 element!.mount(null, null); 即 RenderObjectToWidgetElement 的 mount(null, null) 方法来进行节点的挂载
      void buildScope(Element context, [ VoidCallback? callback ]) {
        		try {
              callback();
            } finally {
              assert(() {
                context._debugSetAllowIgnoredCallsToMarkNeedsBuild(false);
                assert(_debugCurrentBuildTarget == context);
                _debugCurrentBuildTarget = debugPreviousBuildTarget;
                _debugElementWasRebuilt(context);
                return true;
              }());
            }
      }

    #RenderObjectToWidgetElement.mount(null, null)
      
      @override
      void mount(Element? parent, Object? newSlot) {
        assert(parent == null);
      	// 一直到父类 RenderObjectElement 有 mount 重写
      	// 总结： 1.元素节点 持有了 渲染节点 2.更新了元素树信息和深度等
        super.mount(parent, newSlot);
      	// 
        _rebuild();
        assert(_child != null);
      }
    #RenderObjectElement
      @override
      void mount(Element? parent, Object? newSlot) {
      	// 再到父类 Element
        super.mount(parent, newSlot);
        。。。
        // widget 是 RenderObjectToWidgetElement 构造函数里面的参数，在 RenderObjectToWidgetAdapter 类中传入了 this，即 widget = RenderObjectToWidgetAdapter
        // 即调用了 RenderObjectToWidgetAdapter 中的 createRenderObject 方法并将自己（RenderObjectToWidgetElement）传进去 返回了一个 RenderObjectToWidgetAdapter 中的 container ，即 container = renderview 根渲染对象
        // 此时 RenderObjectToWidgetElement 类型持有了根渲染对象
        _renderObject = (widget as RenderObjectWidget).createRenderObject(this);
       	。。。
        attachRenderObject(newSlot);
        _dirty = false;
      }

    	// newSlot = null
    	// 但是由于该节点是根节点，相当于什么都没有执行
    	// 看完此方法，再回到 RenderObjectToWidgetElement的mount方法中接着向下执行
      @override
      void attachRenderObject(Object? newSlot) {
        assert(_ancestorRenderObjectElement == null);
        _slot = newSlot;
        // 从元素树中向上寻找首位 RenderObjectElement 类型的节点，作为先祖节点 _ancestorRenderObjectElement 。
        _ancestorRenderObjectElement = _findAncestorRenderObjectElement();
        // 调用先祖元素节点的 insertRenderObjectChild 方法，将自身持有的 renderObject 对象插入渲染树中。从这里可以看出 渲染树 节点是由 元素 进行维护的
        _ancestorRenderObjectElement?.insertRenderObjectChild(renderObject, newSlot);
        // 通过 _findAncestorParentDataElement 方法，从元素树中向上寻找首位 ParentDataElement<ParentData> 类型的节点。如果非空，执行 _updateParentData 更新渲染对象的 ParentData。
        final ParentDataElement<ParentData>? parentDataElement = _findAncestorParentDataElement();
        if (parentDataElement != null) {
          _updateParentData(parentDataElement.widget as ParentDataWidget<ParentData>);
        }
      }
    #Element
      //主要就是维护一些成员属性信息。
      //对 _parent 属性的赋值表示：这里是树形结构形成的地点。
      //由于这里是根节点，使用父级是 null ；_depth 表示元素的树级深度，父级为空表示根节点，深度为 1 ,如果父级非空，就是父级深度 +1 。其实到这里，就标志着根元素节点的挂载成功。
      void mount(Element? parent, Object? newSlot) {
        _parent = parent;
        _slot = newSlot;
        _lifecycleState = _ElementLifecycle.active;
        _depth = _parent != null ? _parent!.depth + 1 : 1;
        if (parent != null) {
          _owner = parent.owner;
        }
        final Key? key = widget.key;
        if (key is GlobalKey) {
          owner!._registerGlobalKey(key, this);
        }
        _updateInheritance();
        attachNotificationTree();
      }

发表于 更新于 分类于
  • 书籍
    • 安卓传奇
    • 毕业
    • 圆圈正义
    • 小岛经济学
    • 中国哲学简史（未完）
    • 阿里咸鱼flutter（未完）
    • 我的志愿
      阅读全文 »

发表于 更新于 分类于 
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
  @override
  Widget build(BuildContext context) {
    var gestures = <Type, GestureRecognizerFactory>{
      TapGestureRecognizer: GestureRecognizerFactoryWithHandlers<TapGestureRecognizer>(
        () => TapGestureRecognizer(),
        (TapGestureRecognizer instance) {
          instance.onTapDown = _tapDown;
<!--more-->
          instance.onTapUp = _tapUp;
          instance.onTap = _tap;
          instance.onTapCancel = _tapCancel;
        },
      ),
    };
    return RawGestureDetector(
      gestures: gestures,
      child: Container(
          width: 100.0,
          height: 100.0,
          color: color,
          alignment: Alignment.center,
          child: Text(
            "action:$action",
            style: TextStyle(color: Colors.white),
          )),
    );
  }
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
RawGestureDetector

  @override
  void initState() {
    super.initState();
    _semantics = widget.semantics ?? _DefaultSemanticsGestureDelegate(this);
    _syncAll(widget.gestures);
  }
  
  @override
  Widget build(BuildContext context) {
    Widget result = Listener(
      onPointerDown: _handlePointerDown,
      onPointerPanZoomStart: _handlePointerPanZoomStart,
      behavior: widget.behavior ?? _defaultBehavior,
      child: widget.child,
    );
    if (!widget.excludeFromSemantics) {
      result = _GestureSemantics(
        behavior: widget.behavior ?? _defaultBehavior,
        assignSemantics: _updateSemanticsForRenderObject,
        child: result,
      );
    }
    return result;
  }
  
  点击事件会进入 _handlePointerDown 中
  
  void _handlePointerDown(PointerDownEvent event) {
    assert(_recognizers != null);
    for (final GestureRecognizer recognizer in _recognizers!.values) {
      recognizer.addPointer(event);
    }
  }
  

	到父类 GestureRecognizer 中
	
  void addPointer(PointerDownEvent event) {
    _pointerToKind[event.pointer] = event.kind;
    if (isPointerAllowed(event)) {
      addAllowedPointer(event);
    } else {
      handleNonAllowedPointer(event);
    }
  }
  
  
    @override
  void addAllowedPointer(PointerDownEvent event) {
    assert(event != null);
    if (state == GestureRecognizerState.ready) {
      // If there is no result in the previous gesture arena,
      // we ignore them and prepare to accept a new pointer.
      if (_down != null && _up != null) {
        assert(_down!.pointer == _up!.pointer);
        _reset();
      }

      assert(_down == null && _up == null);
      // `_down` must be assigned in this method instead of `handlePrimaryPointer`,
      // because `acceptGesture` might be called before `handlePrimaryPointer`,
      // which relies on `_down` to call `handleTapDown`.
      _down = event;
    }
    if (_down != null) {
      // This happens when this tap gesture has been rejected while the pointer
      // is down (i.e. due to movement), when another allowed pointer is added,
      // in which case all pointers are simply ignored. The `_down` being null
      // means that _reset() has been called, since it is always set at the
      // first allowed down event and will not be cleared except for reset(),
      super.addAllowedPointer(event);
    }
  }
  
  >>>>>>>>>> PrimaryPointerGestureRecognizer
  
  @override
  void addAllowedPointer(PointerDownEvent event) {
    super.addAllowedPointer(event);
    if (state == GestureRecognizerState.ready) {
      _state = GestureRecognizerState.possible;
      _primaryPointer = event.pointer;
      _initialPosition = OffsetPair(local: event.localPosition, global: event.position);
      if (deadline != null) {
        _timer = Timer(deadline!, () => didExceedDeadlineWithEvent(event));
      }
    }
  }
  
  >>>>>>>>>> OneSequenceGestureRecognizer
  
  @override
  @protected
  void addAllowedPointer(PointerDownEvent event) {
    startTrackingPointer(event.pointer, event.transform);
  }
  
  @protected
  void startTrackingPointer(int pointer, [Matrix4? transform]) {
    // 点击事件处理由 handleEvent 函数完成
    GestureBinding.instance.pointerRouter.addRoute(pointer, handleEvent, transform);
    _trackedPointers.add(pointer);
    assert(!_entries.containsValue(pointer));
    // _addPointerToArena(pointer) 应该是将 pointer 加入到手势竞技场中
    // _entries 里面有竞技场相关的东西，之后通过 pointer 取出竞技场开始竞争
    _entries[pointer] = _addPointerToArena(pointer);
  }

  GestureArenaEntry _addPointerToArena(int pointer) {
    if (_team != null) {
      return _team!.add(pointer, this);
    }
    return GestureBinding.instance.gestureArena.add(pointer, this);
  }

	// GestureBinding 中会初始化 GestureArenaManager
  GestureArenaEntry add(int pointer, GestureArenaMember member) {
    final _GestureArena state = _arenas.putIfAbsent(pointer, () {
      assert(_debugLogDiagnostic(pointer, '★ Opening new gesture arena.'));
      return _GestureArena();
    });
    state.add(member);
    assert(_debugLogDiagnostic(pointer, 'Adding: $member'));
    return GestureArenaEntry._(this, pointer, member);
  }


  之后再回到 PrimaryPointerGestureRecognizer 中的 addAllowedPointer 方法中
    
  @override
  void addAllowedPointer(PointerDownEvent event) {
    super.addAllowedPointer(event);
    if (state == GestureRecognizerState.ready) {
      _state = GestureRecognizerState.possible;
      _primaryPointer = event.pointer;
      _initialPosition = OffsetPair(local: event.localPosition, global: event.position);
      if (deadline != null) {
        // deadline = 100 ms
        // 就是说 100ms 之后会会执行 didExceedDeadlineWithEvent 这个方法
        _timer = Timer(deadline!, () => didExceedDeadlineWithEvent(event));
      }
    }
  }

  @protected
  void didExceedDeadlineWithEvent(PointerDownEvent event) {
    didExceedDeadline();
  }

  void _checkDown() {
    if (_sentTapDown) {
      return;
    }
    handleTapDown(down: _down!);
    _sentTapDown = true;
  }

  @protected
  @override
  void handleTapDown({required PointerDownEvent down}) {
    final TapDownDetails details = TapDownDetails(
      globalPosition: down.position,
      localPosition: down.localPosition,
      kind: getKindForPointer(down.pointer),
    );
    switch (down.buttons) {
      case kPrimaryButton:
        if (onTapDown != null) {
          // 执行 onTapDown 方法，也就是在一开始构造函数中传入的回调方法
          invokeCallback<void>('onTapDown', () => onTapDown!(details));
        }
        break;
			......
    }
  }


最后分析 OneSequenceGestureRecognizer 中 startTrackingPointer 方法中的 handleEvent 方法
  @override
  void handleEvent(PointerEvent event) {
    assert(state != GestureRecognizerState.ready);
    if (state == GestureRecognizerState.possible && event.pointer == primaryPointer) {
      // ！_gestureAccepted && 移动的距离大余 18
      final bool isPreAcceptSlopPastTolerance =
          !_gestureAccepted &&  // 接受手势或者停止检测才会是 true
          preAcceptSlopTolerance != null && // 18
          _getGlobalDistance(event) > preAcceptSlopTolerance!;
      // _gestureAccepted && 移动的距离大余 18
      final bool isPostAcceptSlopPastTolerance =
          _gestureAccepted &&
          postAcceptSlopTolerance != null && // 18
          _getGlobalDistance(event) > postAcceptSlopTolerance!;
			
      // 点击手势走 else ，移动手势走 if
      if (event is PointerMoveEvent && (isPreAcceptSlopPastTolerance || isPostAcceptSlopPastTolerance)) {
        resolve(GestureDisposition.rejected);
        stopTrackingPointer(primaryPointer!);
      } else {
        handlePrimaryPointer(event);
      }
    }
    stopTrackingIfPointerNoLongerDown(event);
  }

  @override
  void handlePrimaryPointer(PointerEvent event) {
    if (event is PointerUpEvent) {
      _up = event;
      // 回调构造时闯进来的回调函数，完成本次事件
      _checkUp();
    } else if (event is PointerCancelEvent) {
      resolve(GestureDisposition.rejected);
      if (_sentTapDown) {
        _checkCancel(event, '');
      }
      _reset();
    } else if (event.buttons != _down!.buttons) {
      resolve(GestureDisposition.rejected);
      stopTrackingPointer(primaryPointer!);
    }
  }

发表于 更新于 分类于

  • 5月份给他做了很多事，绝育啦、洗澡啦、给他买了冻干，绝育怕他营养不良呢。下次不去那家洗澡啦，环境差

  • 6月我们搬家了，小家伙对新家一点都不陌生呢

  • 最近准备搞点猫蒲荷水试试效果如何

  • 12月

阅读全文 »

发表于 分类于

  • Future

    • 通过 dart 的 event loop 实现
    • 延时任务，通过 Timer 来实现
      • Future.delayed(Duration(second:3),()=>print(“delayed task”));
    • 创建一个返回指定 value 的 Future
      • Future.value(“abc”).then((res)=>print(res));
    • 执行顺序
阅读全文 »

发表于 分类于
  • 过年回来了，好粘人，睡觉都敢在手摸得到的地方睡了，抢我被子，大佬我睡觉。
  • 耳朵10几天没洗好脏，不会又有耳螨了吧，要每天开始洗耳朵了

发表于 分类于
  • 1.6-这个月开始，早上还没睡醒的时候会来差不多胸口地方来踩奶，一摸全是口水。。。。。
  • 开始准备刷 leetcode ，美区37，73吧

发表于 更新于 分类于

&emsp;&emsp;时间真感觉过得挺快的，写总结的时候再过不久又该过年了吧。今年过得格外的平静，在今年互联网的环境下，头部大厂没有一个不在裁员的，可到了我所处的环境，周围没有听说有人离职或者被毕业的。与外面的大环境显的那么格格不入，反思一下是不是钱给的太少，老板都要惯着你呢。哈哈哈

&emsp;&emsp;聊聊今年做了什么或者有什么变化吧

&emsp;&emsp;工作上从时间线来看看，前面的几个月在干什么好像有点忘记了，隐约记得有在看 matrix 的代码，看了几个月还是一个月的，可能看的不是那么的仔细吧，才没有很深的印象吧，其他的好像真的没有做还是老年人记忆力不行了。之后的时间点就来到了4月中旬，为什么记得那么仔细呢，因为看了一眼博客，在 4.23 的时候发了今年的第一篇博客，算是我性能优化的开篇吧，之前一直在看别人写。也该轮到我了吧，虽然写的没有达到预期的目标，因为好多知识不了解（c++ 的一些语法，linux 底层，没有接触过的一些东西，头都大了），会去参考别人的（也直接抄了一部分，感觉自己写不出更好的，要写的话也只能参考然后加上自己又整理一遍的话术，还不如直接 copy 来的快呢），前前后后也写了4个月吧，20篇文章，但是就 matrix 来说，还是没有写完，在系列文章的最后也有提到后续会去补上，但是到现在还没有再次去正儿八经的打开 matrix 的代码或者去看其中提及到有不了解的知识，还是有点懒了，不，是非常懒了。时间点就来到了8月份，这时候就开始21年的第二个目标，音视频，因为太菜了所以又去看视频，这次看的比较仔细，算是先看后敲。那么8、9月就过去了，到了10月国庆之后，基本没有在干其他的了，都在准备软考高级信息管理师。所幸的是没有辜负一个月的努力，在前几天可查成绩时以微弱的优势过了分数线，45及格分别考了48,47,46。哈哈也是运气好。再就到了11、12月了，这两个月好像没有很强的动力去做事情，脑子里想的是找点事情干干，但是实际上不是很想去做。期间开始看 bagutree 分享的视频，视频分享的很有意思也挺有意义的，也捡起了之前的音视频，但到现在为止音视频还没有完结，估摸着半个月到一个月写完，之后再有个把月来整理一下吧。此外又多了一项技能，会写 flutter 了，好像目前只会写 ui。

&emsp;&emsp;生活上，在七月初南湖边上散步时，买了一个小喵咪回来，带回家时还没有巴掌大，家里什么猫咪用品也灭有，急急忙忙的出去安排上，所幸成功养到了现在，5.7斤的大个子，期间虽然有那么几个念头不想养了，贼不听话，但是不后悔带回家。忘记了，它的名字叫鸡蛋饼（卷），可能就它自己不知道自己叫啥。今年的下半年开始，不爱读书的我也看了几本书，极简生活、古人生活一百天（是不是叫这个名字？）、毕业、小王子和一本关于 flutter 的书，还有就是目前还在看的一本叫如何阅读一本书。为什么想到读书，可能觉得法外狂徒张三说的很有道理，书籍是和历史的伟人精神思想交流的那啥，有忘记炸说的了。也可能是良心发现，自己不应该浪费 26 岁的年纪，在本该灿烂的年华去做去看一些没有意义的事情，比如直播，短视频等等，但是直播，短视频真的很有意思（…………），只能少点时间去看，多去想想。最后再来聊聊疫情，在前段时间突然放开了，随即而来就是一大群小羊人出现，生活和工作上都受到一些影响，放开的那个时间点还觉得没有什么，同事提醒去囤药也没有，直到自己中招了，感觉挺焦虑的，什么药也没有囤，所幸的是不知道什么时候家里还有一个退烧药，于是乎，买了酒精喷雾，n95口罩，去抢抗原，跑好几个药店去问有没有药，现在想想也是有点后悔，有些东西又tm的买贵了，真是狗日的，但是那种环境下自己多买一点心理的安全便会多一分，看见有也就直接买了，哎，韭菜说的就是我吧，但是那几天是真的难受尤其是喉咙，以前是吃一个梨就好了，这次就硬抗3天自己消退，吃梨、各种清火的东西、喝盐水、梨汤几乎没有效果，太难受，疫情也真的不是好东西。今年看爸爸妈妈的次数也少，微信真是个好东西，自己挺不是东西的。

阅读全文 »