atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

  <title><![CDATA[王晓晓的技术札记]]></title>
  <link href="http://wangyunico.github.io/atom.xml" rel="self"/>
  <link href="http://wangyunico.github.io/"/>
  <updated>2015-03-14T22:08:26+08:00</updated>
  <id>http://wangyunico.github.io/</id>
  <author>
    <name><![CDATA[wangyunico]]></name>
    
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[iOS UITouch 事件处理机制]]></title>
    <link href="http://wangyunico.github.io/blog/2015/03/14/ios-uitouch-shi-jian-chu-li-ji-zhi/"/>
    <updated>2015-03-14T21:55:03+08:00</updated>
    <id>http://wangyunico.github.io/blog/2015/03/14/ios-uitouch-shi-jian-chu-li-ji-zhi</id>
    <content type="html"><![CDATA[<h4>UIEvent 传播的机制</h4>

<h5>场景：</h5>

<p>在<code>UIView</code>中绘制了一个<code>ContainerView</code>;在<code>ContainerView</code>中增加了一个<code>button</code>,但是该<code>button</code>的<code>frame</code>在<code>ContainerView</code>的外面，点击<code>button</code>后该button不能被响应。</p>

<h4>事件捕获：</h4>

<p>事件处理分两个过程：事件的传递(捕获)和事件的冒泡，分别由父视图到子视图以及由子视图到父视图
处理流程如下所示：
1. 当用户点击屏幕时会触发一个事件，并且将事件加入到<code>UIApplication</code>管理的事件队列中
2. UIApplication会从事件队列中取出最前面的事件进行分发，首先发给UIWindow
3. UIWindow会执行事件传递（捕获流程),主要调用两个函数分别为
  <pre><code>
   hitTest:withEvent:
   pointInside: withEvent:
</code></pre></p>

<p> hitTest:withEvent处理流程如下：</p>

<ol>
<li>调用当前视图的<code>pointInside:withEvent</code>判断点击的点(已经转换以当前视图为基准视图的坐标点)是否在当前视图内:

<ol>
<li>如果返回值为<code>false</code>说明触摸点不在当前视图内，<code>hitTest:</code>返回为<code>nil</code></li>
<li>如果返回<code>true</code>,那么默认地执行(可执行事件捕获阶段的拦截)所有子视图的<code>hitTest:withEvent</code>的调用。如此递归地执行调用，如果所有子视图都返回空，则返回该视图自己。</li>
</ol>
</li>
<li>最终会得到一条事件捕获的链，当拿到这个响应的<code>View</code>时，会调用该<code>UIView</code>的<code>touches</code>方法。</li>
</ol>


<h4>事件冒泡</h4>

<p>在默认的事件捕获的流程中，当最终的<code>view</code>捕获到该事件后，就进行对事件的处理，调用响应链<code>nexResponder</code>一点一点地将消息传递到<code>UIApplicationDelgate</code>中，完成事件冒泡的过程。</p>

<p><strong>注意</strong></p>

<ol>
<li><p>在<code>iOS</code>事件处理环节当中，如果传递的事件被处理了默认就不再向父层传递(当<code>View</code>手动处理<code>hitTest</code>事件，强制返回某个<code>子view</code>而不是本身的<code>View</code>来响应事件的捕获，事件的冒泡就默认停止)</p></li>
<li><p>如果不想让冒泡停止，如在某一个<code>View</code>中强制返回某个需要响应的<code>子view</code>,就需要在<code>子view</code>的touches事件做处理，调用相应的<code>nextResponder</code>继续冒泡的过程,例如：
<pre><code>- (void)touchesBegan:(NSSet<em>)touches withEvent:(UIEvent </em>)event{
[ self.nextResponder touchesBegan:touches withEvent:event];
}
</code></pre></p></li>
<li>当不让某个View收到消息，设置<code>View.userInteractionEnable=NO</code>;</li>
</ol>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Swift 设计模式]]></title>
    <link href="http://wangyunico.github.io/blog/2015/01/25/swift-she-ji-mo-shi/"/>
    <updated>2015-01-25T16:41:37+08:00</updated>
    <id>http://wangyunico.github.io/blog/2015/01/25/swift-she-ji-mo-shi</id>
    <content type="html"><![CDATA[<h4>责任链模式</h4>

<ul>
<li><h5><strong>定义：</strong></h5>

<p>使多个对象都有机会处理请求,目的是避免发送者与接受者之间的耦合关系,将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止</p></li>
<li><h5><strong>示例代码：</strong></h5></li>
</ul>


<pre><code> 接口:  class Handler{
                    var successor:Handler? 
                     func handleRequest()->SomeType?{}
                    }
</code></pre>


<ul>
<li><h5>如何构建链</h5>

<ol>
<li><p>处理多种请求</p>

<p>普通的方式：</p>

<ol>
<li>. 定义一个通用的抽象请求对象：RequestModel, model中有一个区分业务的标识，用于在职责对象实现中对业务进行处理</li>
<li>. 定义一个通用的处理职责对象的接口与抽象方法</li>
<li>. 针对不同的业务场景对通用的请求对象进行实现</li>
<li>. 在责任链的实现中,根据不同的请求对象类型进行处理</li>
</ol>
</li>
<li><p>功能链</p>

<ol>
<li>并不是职责对象只有一种职责，完成对象请求后就结束整个职责链</li>
<li>每个职责链分为不同的功能，在职责链的传递上对请求对象实现各自的功能</li>
<li>与Decorator 模式的区别</li>
</ol>
</li>
</ol>
</li>
</ul>


<hr />

<h4>迭代器模式</h4>

<ul>
<li><h5>定义：</h5>

<p> 提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示</p></li>
<li><h5>实现：</h5>

<ol>
<li>聚合对象（内部定义一个迭代器，迭代器将根据聚合对象的实现来实现访问接口）</li>
<li>迭代器抽象：定义迭代器的遍历元素的接口

<ul>
<li>start() 访问起始位置</li>
<li>next () 迭代访问下一个位置</li>
<li>isDone() 迭代器是否访问完</li>
</ul>
</li>
</ol>
</li>
<li><h5>swift的实现:</h5>

<p>对应两个协议</p>

<ol>
<li><p> GeneratorType 协议内容:func next() 对应迭代器对象</p></li>
<li><p> SequenceType 协议内容 func generate() -> Generator 对用聚合对象
<code>for ... in</code> 方法的实质
<pre> <code>
var g = array.generate() //取出生成器对象
while let obj = g.next(){ //do some thing }
</code> </pre></p></li>
<li><p> 一个更简单的方法 swift 中的 GeneratorOf</p>

<ul>
<li> 例 访问数组元素的迭代器</li>
</ul>
</li>
</ol>
</li>
</ul>


<pre> <code>         
      sturct NovellaCollection <T>{  
                let novellas: [T]  
        } 

        extension NovellaCollection: SequenceType {
         typealias Generator = GeneratorOf<T>   
            func generate() -> Generator {           
                      var i = 0;  
                      return Generator({ return i >=  self.novellas.count ? nil : self.novellas[i++]    })      
                  }
              }
</code> </pre>


<ul>
<li>由此可以看出GeneratorOf 接受一个<code>() -&gt; T?</code> 类型的匿名函数做为初始化，将该函数的值复制给内部的<code>mutating</code>类型的<code>next()-&gt; T?</code>函数，初始化的时候传入闭包的局部变量i,被保存下来</li>
</ul>


<hr />

<h4>命令模式</h4>

<ul>
<li><h5>定义：</h5>

<p>将一个<strong>请求封装为一个对象</strong>，从而使你可用不同的请求对客户进行参数化，对<strong>请求排队或记录请求日志</strong>，以及<strong>支持可撤销的操作</strong></p></li>
<li><h5>实现：</h5>

<ol>
<li> 命令接口：声明执行方法</li>
<li> 命令具体实现：持有接收者，并调用接收者的功能完成命令执行</li>
<li> 接受者：真正执行命令的对象</li>
<li> Invoker: 命令对象的入口（持有命令对象的抽象）</li>
<li> 命令组装： Receiver &ndash;>Command(设置与接收者关系) &ndash;> Invoker(持有命令对象)</li>
<li> 客户端调用： Invoker &ndash;> command.execute &ndash;> receiver.action</li>
</ol>
</li>
<li><h5>应用场景：</h5>

<ol>
<li> 命令参数可配置(不同命令根据client传参不同进行调用)</li>
<li> 支持撤销（1.补偿式，存储恢复式[备忘录模式结合]）</li>
</ol>
</li>
<li><h5>swift 实现</h5>

<ol>
<li> 采用protocol来做命令对象的抽象</li>
<li> 为每个命令(class)生成具体的命令</li>
</ol>
</li>
</ul>

]]></content>
  </entry>
  
</feed>