这次写一下关于Swift中AnyClass的使用以及动态类型的实例化和使用场景

AnyClass与AnyObject

Swift中，任何自定义的对象都是AnyClass的子类，类似于Java的Object类（但注意，这和Objective-C的NSObject不同，后者在Swift中是专门的UIKit或者AppKit框架里面定义的类型，而非语言所规定的类型）

AnyClass
The protocol to which all class types implicitly conform.

Declaration
typealias AnyClass = AnyObject.Type

AnyObject

React-Native VS Cocoa Touch – 下一代UI编程思维

React 与状态

React.js自从Facebook一推出，就受到Web前端工程师的强烈推崇。虽说曾经火过一时的Angular.js颠覆了前端的工程，但是React更多颠覆的，是下一代UI编程的思维。

传统UI编程，基本很多地方都需要将数据来源，绑定到对应的UI对象，比如用户点击了一个操作，更改了名称，那么你需要更新执行一个回调函数来处理点击操作，并且把新的数据更新原有的UI对象的属性，比如大概就是这样的东西

1
2
3
4
5

func onClick(sender) {
    var data = getData(sender);
    self.button.title = data.name;
    self.button.color = data.color;
}

这样虽然说直观，但是有很大的问题。试想，假如有很多种的回调函数，每个回调函数监听不同的操作，比如onMounseDown,onMouseUp,onKeyDown,onScroll……甚至根据不同的sender，我们会有不同的操作，我们就必须得手写很多机械的

MIT Open Course

MIT-retroactive-data-structure

Time line

Insert(time, ops); Delete(time, ops); Query(time, query);

How to insert ops into two times? -> BST || linked list

How to deal with side effect? -> save all the ops except delete

BST插入顺序与平衡性

众所周知，二查搜索树(BST)的搜索、插入、删除的复杂度等于树高，所以平衡度越高，越接近$ O(nlogn) $，越有序越退化为$ O(n) $

• 对于左侧的BST来说，只有唯一的构造序列：$ <1,2,\dots,14> $
• 但对于右侧的BST，可以存在21964800种不同序列

也就是说，随即插入序列到二叉树所形成的平衡度，将大于部分有序插入所形成的二叉树

形式化证明可以得到（具体证明过程，参见Open Data Structures：

我保证，不再在网上又发布一篇Monad教程(By Erik Meijer)

自我娱乐，附赠各种Functional with OO，参见GitHub

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

//Define
Monad = function() {
    this.value = arguments[0];
};
Monad.prototype.unit = function (value) {
    this.value = value;
    return this;
}
Monad.prototype.bind = function (func) {
    var value = func(this.value);
    var monad = new Monad(value);
    return monad;
}
Monad.prototype.extract = function () {
    return this.value;
}

//Use
var monad = new Monad;
var monad = new Monad(10);

monad.unit(20);
monad.unit(new Monad(30));

monad.bind(function (value) { return value });
var result = monad.bind(function (value) {
    return value.extract() * 2;
})

console.log(result.extract());//60

//Test
var monad = new Monad;
monad.unit(10);

console.log(monad.extract());//10

var firstMonad = monad.bind(function (value) {
    return value / 2;
});

console.log(firstMonad.extract());//5

var secondMonad = monad.bind(function (value) {
    return value + 1;
}).bind(function (value) {
    return value + 2;
}).bind(function (value) {
    return value + 3;
});

console.log(monad.extract())//10
console.log(secondMonad.extract());//16

Promise简介

Promise是一种解决异步回调问题而发展的编程语言特性，在各种语法中都有支持，比如在JavaScript（ECMAScript 6）／Java（8）／Node.js（0.12）都有原生的支持，而没有原生支持的语言更可以通过第三方框架来简单引入（比如大名鼎鼎的Q）

为什么说异步回调不是好的解决方案

1.Callback Hell

1
2
3
4
5
6
7
8
9
10
11

loadScript("a.js",function(){
    loadScript("b.js",function(){
        loadScript("c.js",function(){
            loadScript("d.js",function(){
                loadScript("e.js",function(){
                    console.log("Fuck to load async files")
                }
            })
        })
    })
})

2.依赖习惯编码

又是一个学期过去了，我在软件工程这条路上又迈出一步，这只是写给自己的，对自己这一学期的总结罢了。

最后的PHP？

学期初，最开始便是做的一个基于ThinkPHP的毕业生投票网站，也做了一个简单的微信和手机Web版本。

嘛，关于PHP我还是比较冷静的，PHP适用于传统中等业务逻辑和低并发要求的Web应用。

毕竟没有太多时间，我和另一个同学就直接用了ThinkPHP这种简单无脑框架(当然，还理所应当的踩了坑，这些细节就不说了)

所谓国人自己的框架——ThinkPHP

1. 线程和锁

   • 线程锁的的问题:

   时序问题

   原子操作问题(Java内存读写机制->读.改.写)

   竞态条件(操作取决于线程执行的先后顺序)

   JVM优化导致的问题（编译器静态优化，JVM动态优化，硬件指令的乱序执行）

   两把锁：死锁问题

   外部方法或者对象的线程安全问题

   效率问题synchronized()

   ThreadLocal额外讲解，线程级别的局部变量，适用于数据库连接，网络请求

   • 使用concurrency

   ReetrantLock的手动加锁解锁

   死锁也能中断(不推荐的方式lockInterruptibly())

   tryLock()虽然能设定超时自动解锁，但是缺点明显：活锁（同时死锁再同时超时）

   条件锁：Condition类

   原子操作：Atomic 简单的解决方法，坑和缺点

   线程池 内置的Exeutors.newFixedThreadPool()

2. 函数式方法

   • 变量与可变状态导致的并发难题的终极解决方法->去掉变量

   函数式基础概念：顺序无关 map reduce 无穷序列和惰性求值 尾递归

   Clojure简单方法：pmap

   两种Clojure并发模型：Future(给定一个函数在新线程跑，返回一个future对象) Promise（立即返回，惰性，调用deliver才会执行）

   原子变量(atom)，代理(deref @)，由引用(ref)构成的软件事务内存(STM)。对任何多个并发事务进行修改发生冲突，将会导致重试

3. actor的魔力（略）

   • 纯粹的消息式的交流，几乎没有限制的进程数，随时加入和进行任务，任由错误发生，集中处理

   actor：真正的消息传递，轻量级的进程开销

   分布式map，每个进程分配子map