atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title><![CDATA[netwjx]]></title>
  <link href="http://netwjx.github.com/atom.xml" rel="self"/>
  <link href="http://netwjx.github.com/"/>
  <updated>2013-02-02T16:35:44+08:00</updated>
  <id>http://netwjx.github.com/</id>
  <author>
    <name><![CDATA[netwjx]]></name>
    <email><![CDATA[netwjx@mail.com]]></email>
    <uri>http://netwjx.github.com/</uri>
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>
  <icon>/favicon.png</icon>
  <subtitle><![CDATA[混乱与有序]]></subtitle>

  
  <entry>
    <title type="html"><![CDATA[滑雪备忘]]></title>
    
      <category term="Live" />
    
      <category term="Memo" />
    
    <link href="http://netwjx.github.com/blog/2013/01/27/skiing-memo/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2013-01-27T19:40:00+08:00</published>
    <updated>2013-01-27T19:40:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2013/01/27/skiing-memo</id>
    <content type="html"><![CDATA[<p>前阵子去滑雪, 提前在网上找了一些滑雪的注意事项和准备, 但是等自己亲身体验后感觉还缺点, 这里整理了一些注意事项和准备.</p>

<h2>行程</h2>

<p>一般滑雪场都在郊区, 从起床到进入雪场, 一般需要至少3小时, 雪场开始营业的时间是早8点左右, 结束是一般下午4 5点种, 中间可能需要在雪场用餐. 这个时间要计算好, 免得玩的不够尽兴.</p>

<p>滑雪多数时间是在上山, 途径拖牵, 缆车, 传送带(也叫魔毯). 滑下速度很快, 没有太多消耗体力的地方, 一般体能也能持续很长时间, 只要休息好了.</p>

<p>如果赶到人流多的时候, 在进入, 领服装, 雪鞋, 雪板, 换服装也会消耗很多时间.</p>

<h2>吃喝拉撒</h2>

<p>雪场一般都有餐厅, 价格不算很便宜, 不过附近一般也没什么地方有卖吃的, 有条件的话自己带吃喝.</p>

<p>不能吃太饱, 差不多吃吃就行了, 运动前的常识, 吃完不宜立即剧烈运动.</p>

<p>带上一些高能量食品, 如巧克力, 如果饿了可以先垫点.</p>

<p>带上水杯, 雪场有温水, 也可以自己带水. 水喝多了没事, 雪场应该有卫生间, 一般在雪道底部一侧. 刚进雪场的时候可以先踩踩点, 熟悉周边设施.</p>

<h2>穿着</h2>

<h3>贴身衣物</h3>

<p>内衣最好是透湿, 有弹性, 保暖还行的内衣, 滑雪是持续运动中, 只要吃够了, 外套防风 防水, 基本不会有冷的感觉, 滑完之后可以加件保暖夹层. 贴身不要穿纯棉的, 吸汗之后会湿, 容易着凉.</p>

<p>我穿的是 迪卡依Equarea面料的<a href="http://detail.tmall.com/item.htm?id=12651330117">上身</a>和<a href="http://detail.tmall.com/item.htm?id=12652566120">下身</a>, 保暖一般, 滑雪不感觉到冷, 不活动的时候再加件抓绒上衣, 我穿的是 迪卡依Stratermic面料的<a href="http://detail.tmall.com/item.htm?id=7129791687">抓绒衣</a>.</p>

<h3>保暖夹层</h3>

<p>中间夹层一般建议穿背心, 不会影响到手臂的活动, 温度合适的话, 可以不用加背心. 背心一般是填充的羽绒.</p>

<p>也可以是类似冲锋衣内胆哪种抓绒衣物, 保暖程度主要考虑当天的气温如何.</p>

<h3>防风防雨外套</h3>

<p>外套主要是要防风和防水, 能保暖也行, 就可以少穿一件保暖夹层, 如果自己有冲锋衣裤也可以, 手脚和腰是缩口的最好, 防止摔倒之后进雪. <strong>雪场也有滑雪服租用</strong>, 一般团购的票里面就带有滑雪服租用费.</p>

<p>不建议在日常外套外面穿滑雪服, 会十分影响四肢活动, 而且还可能太热.</p>

<p>一般滑雪服都使用尼龙魔术贴固定的, 租用的可能魔术贴老化而贴不牢, 可以考虑带条腰带, 比较宽, 有一些弹性, 对运动影响小最好. 如果有战术腰带也可, 方便下文要说的腰包. 衣服口袋都是拉链, 可以看看口袋是不是完好, 必要的话可以要求调换.</p>

<h3>袜子</h3>

<p>雪靴一般都比较硬, 加上持续的活动, 建议至少穿两双袜子.</p>

<ul>
<li>里面是加厚的线袜, 能防止脚魔伤, 线袜空隙大, 透湿效果也挺好.</li>
<li>外套吸汗的袜子, 比如纯棉的, 还因为租用的鞋子可能有气味.</li>
</ul>


<h3>帽子</h3>

<p>即使在无风的天气, 下滑的速度也会产生挺大的风, <strong>最好能对耳朵保护下</strong>, 还能有一定的保暖, 可以减少大量的热量消耗.</p>

<p>一般如抓绒帽, 线帽都可以, 防风 不吸水的为主.</p>

<p>我的是这个<a href="http://detail.tmall.com/item.htm?id=6948230189">围脖</a>, 将收缩绳拉上就是个帽子了, 有长发的女孩子还可以把长发从缩口中拉出来, 滑行中更有型.</p>

<h3>手套</h3>

<p>不带手套的话, 手会很快冻僵, 摔倒沾到雪, 湿了之后<strong>就更容易冻伤</strong>, 所以最好有手套, 依旧是防水 防风的, 毛线手套空隙太大的不行, 会透风, 下滑时风会进入手套. 手套最好能方便挂到手上或脖子上, 避免丢失. 我的是<a href="http://detail.tmall.com/item.htm?id=13348736509">这个手套</a>.</p>

<h3>滑雪镜</h3>

<p>如果是初级滑道, 当天也没有风的话是没必要考虑眼镜, 后面的中级滑道就需要眼镜了, 主要是挡风, 不然滑下时风太大, 会流眼泪, 影响视野. 滑雪镜和前面几个的不太一样的是, 基本没什么别的场合可以使用(除非在东北, 大风下雪天气), 可以考虑租用滑雪镜. 如果有畏光, 雪盲, 看到大量雪会难受则一定要找个滑雪镜. 不建议传统太阳镜, 摔倒脱落的话有可能伤到眼睛. 滑雪镜不是潜水镜, 周围是海绵垫着的, 不会对眼球产生负压.</p>

<h3>口罩/围巾</h3>

<p>如果受不了迎风直接吸冷风, 则还需要口罩, 或者是围巾, 能对直接刮来的冷风有点削减的就行.</p>

<h3>穿着总结</h3>

<p>总结起来就是:</p>

<ul>
<li>贴身衣物 透湿, 弹性好, 不吸汗的.</li>
<li>夹层根据天气情况穿件保暖的背心, 可以不穿保暖裤.</li>
<li>外穿的都需要防风 防水.

<ul>
<li>外套可以在雪场租用, 自备可以用冲锋衣.</li>
<li>外套颜色不要白色的, 选择其它鲜艳点的颜色, 方便雪地中辨识.</li>
<li>手套和帽子可以防止冻伤, 建议准备上.</li>
</ul>
</li>
<li>透湿的厚袜子.</li>
</ul>


<h3>随身物品</h3>

<p>建议把平时多数随身物品都存上, 免得滑雪中掉落, <strong>可以随身携带的有</strong>:</p>

<ul>
<li>手机(充满电的), 雪场比较大, 方便联系同伴.

<ul>
<li>领到的储物柜钥匙很可能不在一起, 换完服装如果先不和同伴碰头, 进了雪场空间太大就很难找到了, 所以最好大家随身带手机.</li>
</ul>
</li>
<li>滑雪场寄存柜的钥匙, 计费卡, 没这个就回不了家啦.</li>
<li>巧克力(高能量食品, 感觉冷或饿的时候可以先垫点), 不能放太热的地方, 会化掉.</li>
</ul>


<p>水可以放寄存柜, 需要的话回来开柜取出来.</p>

<p>最简单的就是把所有东西都放到滑雪服的拉链口袋, 切记用完后要拉好拉链, 防止掉落.</p>

<p>如果东西多可以考虑用一个贴身的小双肩背包, 防水, 能在腰间绑一圈固定的最好.</p>

<p>如果对滑雪服的拉链口袋不满意, 可以用腰包, 一般军品店哪种战术腰带也行, 可以根据需要挂接腰包模块, 足够放手机和钥匙就行, 腰包一定要可靠, 不能中途物品掉落.</p>

<h2>取雪鞋 雪板 雪杖</h2>

<p>雪板和雪鞋可能会不匹配, 拿到之后建议在原地试试, 是否能卡紧, 卡不紧可以要求调整或者调换. 顺便了解下怎么脱离雪板, 然后在进入雪场.</p>

<p>一般雪板都是可以摔倒自动脱离, 正常的脱离是用雪杖扎到卡住雪鞋后跟哪个机关的小凹坑上, 使劲压, 可能需要双手压, 脚后跟就能起来了. 如果有同伴就让同伴用雪鞋帮踩压哪个机关.</p>

<p>领取这些东西一般会有一个领用凭据之类的, 这个要保存好, 最好随身携带. 雪板和雪杖不要丢失, 会扣钱的. 有些雪杖前面的帽会脱落, 能换个好点的就换吧.</p>

<p>雪场一般有雪板和雪杖的寄存处, 应该是免费的, 需要休息, 去卫生间等可以把雪板和雪杖先寄存. 或者是同伴帮看着.</p>

<h2>用雪杖推行</h2>

<p>不要把雪杖扎到自己的脚前面, 那样十分费劲, 雪杖最多扎到和脚后跟平行, 不要想着能一次把自己推多远, 少量多次就可以了, 后面可以学习脚怎么配合一些滑行的动作, 能省力很多.</p>

<p>不推荐新手只在平地上滑行, 极其消耗体力, 还会玩的很痛苦.</p>

<h2>滑道中滑行</h2>

<p>滑道会有难度标识, 建议新人从练习道和初级道开始, 这两个的坡度很小, 速度会慢一些.</p>

<p>上滑道一般是三种途径:</p>

<ul>
<li>拖牵 拖牵是有一根垂直下来, 能伸缩的金属杆, 末端一个橡胶盘, 双腿夹住金属杆, 不用太紧, 然后橡胶盘会推着屁股前行. 这个是事实上山速度最快的途径, 就是需要滑到有点高的地方才有拖牵, 拖行中因为雪面会有轻微的起伏, 所以会有速度变化, 需要自己控制一点左右防止摔倒. 拖牵可以随时从拖牵道出来滑下.</li>
<li>魔毯 我觉得就是传送带, 比较简单, 可以穿或者不穿雪板, 因为是传送带哪种, 所以速度比拖牵慢.</li>
<li>缆车 缆车应该是很快的, 但是因为太多人都想乘缆车, 所以排队十分长, 如果队伍短可以用缆车.</li>
</ul>


<p>还有雪地摩托, 但是好像这个只能进入专用滑雪道, 它上山是直接在滑雪道上逆行的.</p>

<p>雪场有教练服务, 费用还是很贵的, 建议找同伴中比较熟悉的人学习, 或者是在教练附近蹭学, 不要蹭太久了, 可以远处看着也行.</p>

<p>水平横在雪道下坡就可以停住, 实在停不住可以向左右一侧倒, 但要注意后面有没有跟随的人, 避免被后面的人撞上, 人多的时候就不建议这样做.</p>

<p>雪杖不要脱手, 会造成其它人摔倒.</p>

<h2>本次去的滑雪场软硬件设施</h2>

<p>这次去的是<a href="http://www.yuyangski.com.cn/">平谷渔阳滑雪场</a>.</p>

<ul>
<li>面积很大, 高级滑道没有上去过, 主要是乘缆车人太多了.</li>
<li>雪场随处都能看到有工作人员, 或者雪场的教练, 有什么麻烦可以找他们. 一般有统一独特的服装, 很好认.</li>
<li>大厅和雪场都有卫生间, 雪场的卫生间过去比较方便.</li>
<li>最底部有儿童乐园类似的地方, 会有小孩用的哪种比较安全的滑雪圈, 不过是额外收费的.

<ul>
<li>其它还有拍照, 冰面碰碰车好像.</li>
</ul>
</li>
<li>有餐厅, 如果是自助餐要赶早, 不然就没什么好东西吃了, 可以看看团购卷里面是否包含, 正价是58/每人, 提前问好用餐时间.</li>
<li>有卖小吃的地方, 我没仔细看, 不知道价格, 味道估计不会特别的好.</li>
<li>生态餐厅就是内部有大量的植被, 人工河(好像是不动的, 但是里面有鱼).</li>
<li>雪场有自己的班车, 早上7:30发车，16:00集合，16:30返程, 40/每人, 团购会便宜点.</li>
</ul>


<h3>酒店</h3>

<p>雪场的酒店, 是别墅木屋哪种, 两层, 三室, 全部独立卫生间 淋浴, 如果是很多人会比较划算, 最近房子刚刚装修, 气味比较重.</p>

<p>其它就只能住附近了, 当然最后行程是当天, 不过夜.</p>

<h2>后记</h2>

<ul>
<li>去雪场切记不要落下东西, 我这次去就把东西给忘在雪场了.

<ul>
<li>后来抱着希望给雪场打电话, 想不到他们帮找到了, 过段时间找快递发回来.</li>
</ul>
</li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2013/01/27/skiing-memo/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[函数的Currying (Javascript 和 Scala)]]></title>
    
      <category term="Javascript" />
    
      <category term="Memo" />
    
      <category term="Scala" />
    
    <link href="http://netwjx.github.com/blog/2012/12/05/function-currying-in-javascript-and-scala/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-12-05T13:52:00+08:00</published>
    <updated>2012-12-05T13:52:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/12/05/function-currying-in-javascript-and-scala</id>
    <content type="html"><![CDATA[<p>Currying或者Curry, 中文有翻译成<a href="http://book.51cto.com/art/200806/77578.htm">科里化</a>. 我最早了解它是在一篇讲<a href="http://www.ibm.com/developerworks/cn/java/j-pg08235/">Groovy中函数式编程</a>的文章中, 之后又在<a href="http://www.python.org/">Python</a>中<a href="http://code.activestate.com/recipes/52549/">遇到同样的东西</a>. 最近在看<a href="http://www.scala-lang.org/">Scala</a>的介绍时<a href="http://www.scala-lang.org/node/135">又看到了</a>, 而且发现<a href="http://www.scala-lang.org/">Scala</a>设计的明显更好, 然后就成了这篇文章, 使用Javascript作为主要语言是因为我使用Javascript的时间更长, 并且Javascript这门语言的表达能力<a href="http://www.nafine.com/Work_View.php?id=271">奇强</a>&#94;-&#94;.</p>

<p>我不确定把Currying记作<a href="http://book.51cto.com/art/200806/77578.htm">科里化</a>是否更容易理解, 所以下文还是依旧使用Currying吧.</p>

<p>Currying是<a href="http://www.ibm.com/developerworks/cn/java/j-cb12196/">函数式编程</a>中一种<a href="http://zh.wikipedia.org/wiki/%E9%AB%98%E9%98%B6%E5%87%BD%E6%95%B0">高阶函数</a>的典型应用, 如果非要把它对应到传统OO中的话, 那么它类似<a href="https://www.google.com/search?q=builder+pattern">Builder模式</a>, 一般译作构建器模式 建造者模式.</p>

<p>Builder模式可以简单理解为创建一个复杂的对象需要依赖多个参数, 要提供的参数又依赖于不同的方法, 使用Builder模式让每个方法只关注自己提供的参数, 最终根据全部参数创建出对象来. 对象实例最终是拿来调用的, 可以把这个过程想象成调用一个参数很多的函数.</p>

<p>Javascript中完全可以按照传统OO的方式实现Builder模式, 但使用Currying更轻量级 简单, 考虑下面的代码:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">function</span> <span class="nx">filter</span><span class="p">(</span><span class="nx">list</span><span class="p">,</span> <span class="nx">func</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">ret</span> <span class="o">=</span> <span class="p">[];</span>
</span><span class='line'>    <span class="k">for</span> <span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">list</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>        <span class="kd">var</span> <span class="nx">v</span> <span class="o">=</span> <span class="nx">list</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="nx">func</span><span class="p">(</span><span class="nx">v</span><span class="p">))</span> <span class="p">{</span>
</span><span class='line'>            <span class="nx">ret</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">v</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">ret</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="kd">function</span> <span class="nx">modN</span><span class="p">(</span><span class="nx">n</span><span class="p">,</span> <span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">x</span> <span class="o">%</span> <span class="nx">n</span> <span class="o">===</span> <span class="mi">0</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">];</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filter</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">modN</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="nx">x</span><span class="p">);</span>
</span><span class='line'><span class="p">}));</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filter</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">modN</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="nx">x</span><span class="p">);</span>
</span><span class='line'><span class="p">}));</span>
</span></code></pre></td></tr></table></div></figure>




<!-- more -->


<p>执行输出</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">8</span>
</span><span class='line'><span class="mi">3</span><span class="p">,</span><span class="mi">6</span>
</span></code></pre></td></tr></table></div></figure>


<p>modN函数有2个参数, 示例中可以同时提供所有的参数, 当然这是相当理想的情况. 实际可能不同的参数在不同的阶段提供:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">var</span> <span class="nx">p</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">];</span>  <span class="c1">// 提供相关参数</span>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filter</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="nx">x</span><span class="p">;</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">modN</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="k">this</span><span class="p">,</span> <span class="nx">p</span><span class="p">);</span>
</span><span class='line'><span class="p">}));</span>
</span><span class='line'>
</span><span class='line'><span class="nx">p</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="mi">3</span><span class="p">;</span>  <span class="c1">// 提供相关参数</span>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filter</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="nx">x</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">modN</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="k">this</span><span class="p">,</span> <span class="nx">p</span><span class="p">);</span>
</span><span class='line'><span class="p">}));</span>
</span></code></pre></td></tr></table></div></figure>


<p>这种方式需要有一个变量用来保存参数, 而如果使用Currying可以这样:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filter</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="nx">modN</span><span class="p">.</span><span class="nx">curry</span><span class="p">(</span><span class="mi">2</span><span class="p">)));</span>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filter</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="nx">modN</span><span class="p">.</span><span class="nx">curry</span><span class="p">(</span><span class="mi">3</span><span class="p">)));</span>
</span></code></pre></td></tr></table></div></figure>


<p>根据需要可以<code>curry()</code>多个参数或<code>curry()</code>多次. 上文中使用的<code>curry</code>函数的实现:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="nb">Function</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">curry</span> <span class="o">=</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">func</span> <span class="o">=</span> <span class="k">this</span><span class="p">,</span>
</span><span class='line'>        <span class="nx">p</span> <span class="o">=</span> <span class="nb">Array</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">slice</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">arguments</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
</span><span class='line'>    <span class="k">return</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>        <span class="k">return</span> <span class="nx">func</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="k">this</span><span class="p">,</span> <span class="nx">p</span><span class="p">.</span><span class="nx">concat</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="nx">p</span><span class="p">,</span> <span class="nx">arguments</span><span class="p">));</span>
</span><span class='line'>    <span class="p">};</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>这是最轻量级 最简单的实现方式, 深入挖掘Javascript语言的表达力应该还会出现更巧妙的设计.</p>

<h2>Currying的来由</h2>

<p>考虑体积计算公式<code>体积 = 长 x 宽 x 高</code>, 假设已知长为10, 那么这个公式就变成了<code>体积 = 10 x 宽 x 高</code>, 进一步已知宽为7, 那么公式就变为<code>体积 = 10 x 7 x 高</code>, 这种转换即Currying.</p>

<p>这是最通俗的描述, 比较正式的可以参考<a href="http://www.wikipedia.org/">维基百科</a>的<a href="http://en.wikipedia.org/wiki/Currying">Currying</a>词条.</p>

<h2>Scala语言中的Currying</h2>

<p>之所以要额外提<a href="http://www.scala-lang.org/">Scala</a>, 是因为它是原生支持Currying的语言, 相对比通过类库支持能提供更巧妙的语法, 参见下面的代码:</p>

<figure class='code'><figcaption><span>A Tour of Scala: Currying </span><a href='http://www.scala-lang.org/node/135'>来源</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">object</span> <span class="nc">CurryTest</span> <span class="k">extends</span> <span class="nc">Application</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// 这种声明就是支持Currying的函数, 每个参数用 ( ) 分隔开</span>
</span><span class='line'>  <span class="k">def</span> <span class="n">modN</span><span class="o">(</span><span class="n">n</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=</span> <span class="o">((</span><span class="n">x</span> <span class="o">%</span> <span class="n">n</span><span class="o">)</span> <span class="o">==</span> <span class="mi">0</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// 参数p是有1个Int类型参数的函数, 返回Boolean类型</span>
</span><span class='line'>  <span class="k">def</span> <span class="n">filter</span><span class="o">(</span><span class="n">xs</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">Int</span><span class="o">],</span> <span class="n">p</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=&gt;</span> <span class="nc">Boolean</span><span class="o">)</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span> <span class="k">=</span>
</span><span class='line'>    <span class="k">if</span> <span class="o">(</span><span class="n">xs</span><span class="o">.</span><span class="n">isEmpty</span><span class="o">)</span> <span class="n">xs</span>
</span><span class='line'>    <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">p</span><span class="o">(</span><span class="n">xs</span><span class="o">.</span><span class="n">head</span><span class="o">))</span> <span class="n">xs</span><span class="o">.</span><span class="n">head</span> <span class="o">::</span> <span class="n">filter</span><span class="o">(</span><span class="n">xs</span><span class="o">.</span><span class="n">tail</span><span class="o">,</span> <span class="n">p</span><span class="o">)</span>
</span><span class='line'>    <span class="k">else</span> <span class="n">filter</span><span class="o">(</span><span class="n">xs</span><span class="o">.</span><span class="n">tail</span><span class="o">,</span> <span class="n">p</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">nums</span> <span class="k">=</span> <span class="nc">List</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="mi">2</span><span class="o">,</span> <span class="mi">3</span><span class="o">,</span> <span class="mi">4</span><span class="o">,</span> <span class="mi">5</span><span class="o">,</span> <span class="mi">6</span><span class="o">,</span> <span class="mi">7</span><span class="o">,</span> <span class="mi">8</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// modN2引用的是包含1个Int类型参数, 并返回Boolean类型的函数, 结尾的下划线是Scala中的语法</span>
</span><span class='line'>  <span class="k">val</span> <span class="n">modN2</span> <span class="k">=</span> <span class="n">modN</span><span class="o">(</span><span class="mi">2</span><span class="o">)</span><span class="k">_</span>
</span><span class='line'>  <span class="n">println</span><span class="o">(</span><span class="n">filter</span><span class="o">(</span><span class="n">nums</span><span class="o">,</span> <span class="n">modN2</span><span class="o">))</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// 不需要赋值的就不需要结尾的下划线了</span>
</span><span class='line'>  <span class="n">println</span><span class="o">(</span><span class="n">filter</span><span class="o">(</span><span class="n">nums</span><span class="o">,</span> <span class="n">modN</span><span class="o">(</span><span class="mi">3</span><span class="o">)))</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>上述代码只是加了额外的注释, 调整了下顺序, 和来源中的代码等价.</p>

<p>最重要的, <a href="http://www.scala-lang.org/">Scala</a>是静态类型语言, 开发环境可以提供每次<code>Currying</code>之后的<strong>函数提示信息</strong>, 并能够做<strong>编译时检查</strong>, 而<a href="http://groovy.codehaus.org/">Groovy</a>, <a href="http://www.python.org/">Python</a>, Javascript只能依赖约定, 错误会在运行时发生, 必须有其它的措施确保同步修改关联的代码.</p>

<h2>偏函数 Partial function</h2>

<p>可以译作偏函数, 即提供部分参数值的函数, 和Currying很像, 只是另外一种更灵活的语法, 可以不按照参数顺序提供参数.</p>

<p>在<a href="http://ejohn.org/blog/">John Resig</a>的Blog有一篇<a href="http://ejohn.org/blog/partial-functions-in-javascript/">介绍Partial function和Currying的文章</a>, 贴个简单的代码片段:</p>

<figure class='code'><figcaption><span>Partial Application in JavaScript </span><a href='http://ejohn.org/blog/partial-functions-in-javascript/'>代码来源</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'>  <span class="kd">var</span> <span class="nx">delay</span> <span class="o">=</span> <span class="nx">setTimeout</span><span class="p">.</span><span class="nx">partial</span><span class="p">(</span><span class="kc">undefined</span><span class="p">,</span> <span class="mi">10</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>  <span class="nx">delay</span><span class="p">(</span><span class="kd">function</span><span class="p">(){</span>
</span><span class='line'>    <span class="nx">alert</span><span class="p">(</span> <span class="s2">&quot;A call to this function will be temporarily delayed.&quot;</span> <span class="p">);</span>
</span><span class='line'>  <span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>partial()</code>的实现:</p>

<figure class='code'><figcaption><span>Partial Application in JavaScript </span><a href='http://ejohn.org/blog/partial-functions-in-javascript/'>代码来源</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="nb">Function</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">partial</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(){</span>
</span><span class='line'>  <span class="kd">var</span> <span class="nx">fn</span> <span class="o">=</span> <span class="k">this</span><span class="p">,</span> <span class="nx">args</span> <span class="o">=</span> <span class="nb">Array</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">slice</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">arguments</span><span class="p">);</span>
</span><span class='line'>  <span class="k">return</span> <span class="kd">function</span><span class="p">(){</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">arg</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span><span class='line'>    <span class="k">for</span> <span class="p">(</span> <span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">args</span><span class="p">.</span><span class="nx">length</span> <span class="o">&amp;&amp;</span> <span class="nx">arg</span> <span class="o">&lt;</span> <span class="nx">arguments</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">)</span>
</span><span class='line'>      <span class="k">if</span> <span class="p">(</span> <span class="nx">args</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">===</span> <span class="kc">undefined</span> <span class="p">)</span>
</span><span class='line'>        <span class="nx">args</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">arguments</span><span class="p">[</span><span class="nx">arg</span><span class="o">++</span><span class="p">];</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">fn</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="k">this</span><span class="p">,</span> <span class="nx">args</span><span class="p">);</span>
</span><span class='line'>  <span class="p">};</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>里面还有一个<code>curry</code>函数, 基本和上文中的差不多, 有兴趣的可以点<a href="http://ejohn.org/blog/partial-functions-in-javascript/">Partial Application in JavaScript</a></p>

<p><a href="http://www.scala-lang.org/">Scala</a>也有Partial function的实现, 依旧是静态类型, 示例代码:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">def</span> <span class="n">add</span><span class="o">(</span><span class="n">i</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">j</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=</span> <span class="n">i</span> <span class="o">+</span> <span class="n">j</span>
</span><span class='line'><span class="k">val</span> <span class="n">add5</span> <span class="k">=</span> <span class="n">add</span><span class="o">(</span><span class="k">_:</span> <span class="kt">Int</span><span class="o">,</span> <span class="mi">5</span><span class="o">)</span>
</span><span class='line'><span class="n">println</span><span class="o">(</span><span class="n">add5</span><span class="o">(</span><span class="mi">2</span><span class="o">))</span>
</span></code></pre></td></tr></table></div></figure>


<p>参考[Wikipedia][]的<a href="http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application">Contrast with partial function application</a> 和 <a href="http://en.wikipedia.org/wiki/Partial_function">Partial function</a></p>

<h2>Javascript中更常见的传递大量参数的方式</h2>

<p>Javascript是动态语言, 开发环境无法提供太多提示信息, 上文提到的Currying更适合一些比较稳定的, 不经常变动的API.</p>

<p>实际项目中如果函数参数很多, 并且可能在不同的地方提供参数, 则会使用参数对象的方式:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">function</span> <span class="nx">modN</span><span class="p">(</span><span class="nx">opt</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">opt</span><span class="p">.</span><span class="nx">num</span> <span class="o">=</span> <span class="nx">opt</span><span class="p">.</span><span class="nx">num</span> <span class="o">||</span> <span class="mi">1</span><span class="p">;</span>
</span><span class='line'>    <span class="nx">opt</span><span class="p">.</span><span class="nx">x</span> <span class="o">=</span> <span class="nx">opt</span><span class="p">.</span><span class="nx">x</span> <span class="o">||</span> <span class="mi">1</span><span class="p">;</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">opt</span><span class="p">.</span><span class="nx">x</span> <span class="o">%</span> <span class="nx">opt</span><span class="p">.</span><span class="nx">num</span> <span class="o">===</span> <span class="mi">0</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">opt2</span> <span class="o">=</span> <span class="p">{</span> <span class="nx">num</span><span class="o">:</span> <span class="mi">2</span> <span class="p">},</span>
</span><span class='line'>    <span class="nx">opt3</span> <span class="o">=</span> <span class="p">{</span> <span class="nx">num</span><span class="o">:</span> <span class="mi">3</span> <span class="p">};</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filter</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">opt2</span><span class="p">.</span><span class="nx">x</span> <span class="o">=</span> <span class="nx">x</span><span class="p">;</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">modN</span><span class="p">(</span><span class="nx">opt2</span><span class="p">);</span>
</span><span class='line'><span class="p">}));</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filter</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">opt3</span><span class="p">.</span><span class="nx">x</span> <span class="o">=</span> <span class="nx">x</span><span class="p">;</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">modN</span><span class="p">(</span><span class="nx">opt3</span><span class="p">);</span>
</span><span class='line'><span class="p">}));</span>
</span></code></pre></td></tr></table></div></figure>


<p>这个看起来和Builder模式十分相像, 参数都提供有默认值, <code>num</code>和<code>x</code>可以使用更有意义的名称以使阅读性更好一些, 但也付出了不少编码工作.</p>

<p>从<a href="http://www.mozilla.org/en-US/firefox/fx/#desktop">Firefox 2.0</a>开始支持<strong>解构赋值</strong><a href="https://developer.mozilla.org/en-US/docs/JavaScript/New_in_JavaScript/1.7#Destructuring_assignment_%28Merge_into_own_page.2Fsection%29">New in JavaScript 1.7: Destructuring assignment</a>, 这个特性可以让实现<code>modN</code>少了一些纠结:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">function</span> <span class="nx">modN</span><span class="p">(</span><span class="nx">opt</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="kd">var</span> <span class="p">{</span> <span class="nx">num</span><span class="p">,</span> <span class="nx">x</span> <span class="p">}</span> <span class="o">=</span> <span class="nx">opt</span><span class="p">;</span>
</span><span class='line'>    <span class="nx">num</span> <span class="o">=</span> <span class="nx">num</span> <span class="o">||</span> <span class="mi">1</span><span class="p">;</span>
</span><span class='line'>    <span class="nx">x</span> <span class="o">=</span> <span class="nx">x</span> <span class="o">||</span> <span class="mi">1</span><span class="p">;</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">x</span> <span class="o">%</span> <span class="nx">num</span> <span class="o">===</span> <span class="mi">0</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>原文中还有解构赋值的很多<a href="https://developer.mozilla.org/en-US/docs/JavaScript/New_in_JavaScript/1.7#Looping_across_values_in_an_array_of_objects">高级用法</a>, 但是到目前为之还没看到其它浏览器提供支持, 也没有进入ECMAScript标准, 只能在比如Firefox扩展开发时爽爽.</p>

<h2>参考资料</h2>

<ul>
<li><a href="http://www.cnblogs.com/fox23/archive/2009/10/22/intro-to-Lambda-calculus-and-currying.html">Lambda演算与科里化(Currying)</a></li>
<li><a href="http://book.51cto.com/art/200806/77578.htm">《JavaScript王者归来》第二十二章 科里化（Currying）小节</a></li>
<li><a href="http://www.ibm.com/developerworks/cn/java/j-pg08235/">实战 Groovy: 用 curry 过的闭包进行函数式编程</a></li>
<li><a href="http://code.activestate.com/recipes/52549/">curry &#8211; associating parameters with a function (Python recipe)</a></li>
<li><a href="http://www.scala-lang.org/node/135">A Tour of Scala: Currying</a></li>
<li><a href="http://www.ibm.com/developerworks/cn/java/j-cb12196/">跨越边界: JavaScript 语言特性</a></li>
<li><a href="http://zh.wikipedia.org/wiki/%E9%AB%98%E9%98%B6%E5%87%BD%E6%95%B0">维基百科 高阶函数 词条</a></li>
<li><a href="http://en.wikipedia.org/wiki/Currying">维基百科 Currying 词条</a></li>
<li><a href="http://en.wikipedia.org/wiki/Partial_function">维基百科 Partial function 词条</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/JavaScript/New_in_JavaScript/1.7#Destructuring_assignment_%28Merge_into_own_page.2Fsection%29">New in JavaScript 1.7 : Destructuring assignment 解构赋值</a></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/12/05/function-currying-in-javascript-and-scala/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Dropbox, Stack Overflow 和 Ruby on Rails 杂念]]></title>
    
      <category term="Book" />
    
      <category term="IT" />
    
      <category term="Memo" />
    
      <category term="Saas" />
    
    <link href="http://netwjx.github.com/blog/2012/11/24/dropbox-stack-overflow-and-ruby-on-rails/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-11-24T21:08:00+08:00</published>
    <updated>2012-11-24T21:08:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/11/24/dropbox-stack-overflow-and-ruby-on-rails</id>
    <content type="html"><![CDATA[<p>它们有什么联系? 其实没什么特别的联系, 所以是杂念, 没什么头绪, 就是想到了, 我一个个说来.</p>

<h2>Dropbox的故事</h2>

<p><a href="http://dropbox.com/">Dropbox</a>是很出名的网盘服务, 也可以叫它云端存储服务, 它的客户端能够自动同步多个电脑间的文件夹, 当然这个功能在现在十分常见了, 只是在他出现之前, 多数网盘服务都是以Web形式为主的. 它给免费用户提供2G空间, 通过邀请其它用户可以扩容空间, 基本上后来的网盘都是这种套路. 额外还有根据订购的套餐按月付费.</p>

<p><a href="http://ycombinator.com/">Y Combinator</a>是一家很有意思的风险投资公司, 它只向最早期的创业团队投资. 而<a href="http://dropbox.com/">Dropbox</a>是它最成功的投资之一.</p>

<p><img class="right" src="http://www.ruanyifeng.com/images/hnp_cover_b.jpg" width="318" title="Hackers and Painters" ></p>

<p><a href="http://ycombinator.com/">Y Combinator</a>的创始人是<a href="http://www.paulgraham.com/">Paul Grahm</a>, 被誉为<a href="http://www.programmer.com.cn/11408/">硅谷创业之父</a>, 他曾经从事过程序员的工作. <a href="http://www.ruanyifeng.com/blog/">阮一峰的网络日志</a> <a href="http://www.ruanyifeng.com/blog/2009/12/i_will_translate_paul_graham.html">我要翻译Paul Graham了</a>上面介绍的很不错, 引用首段:</p>

<blockquote><p>下面，我就告诉你，我为什么那么想翻译Paul Graham。</p><p>他1964年出生于英国，在康奈尔大学读完本科，然后在哈佛大学获得计算机科学博士学位。1995年，他创办了Viaweb，帮助个人用户在网上开店，这是世界上第一个互联网应用程序。1998年夏天，Yahoo!公司收购了Viaweb，收购价约为5000万美元。</p><p>此后，他架起了个人网站paulgraham.com，在上面撰写了许许多多关于软件和创业的文章，以深刻的见解和清晰的表达而著称，迅速引起了轰动。2005年，他身体力行，创建了风险投资公司Y Combinator，将自己的理论转化为实践，目前已经资助了80多家创业公司。现在，他是公认的互联网创业权威。</p><footer><strong>阮一峰</strong> <cite><a href='http://www.ruanyifeng.com/blog/2009/12/i_will_translate_paul_graham.html'>我要翻译Paul Graham了</a></cite></footer></blockquote>




<!-- more -->


<p>这就引出了<a href="http://www.paulgraham.com/">Paul Grahm</a>写的书<a href="http://www.amazon.com/exec/obidos/tg/detail/-/0596006624">Hackers and Painters: Big Ideas from the Computer Age</a>, 注意英文副标题, 可以直译为<strong>计算机时代的伟大想法</strong>. 这本书的中译版是<a href="http://www.ruanyifeng.com/docs/pg/">黑客与画家</a>, 译者是上面提到的<a href="http://www.ruanyifeng.com/blog/">阮一峰</a>.</p>

<p>这里有一个有趣的故事, <a href="http://www.syncoo.com/why-dropbox-is-more-popular-than-similar-tools.htm">为什么 Dropbox 比其它同类产品更受欢迎?</a> 有趣的在于其中回答这个问题的人中有<a href="http://dropbox.com/">Dropbox</a>的竞争产品 - <a href="http://www.syncplicity.com/">Syncplicity</a>的联合创始人, 其中不乏他的多年思考总结, 以及一些行业的内幕轶事.</p>

<p>这是<a href="http://dropbox.com/">Dropbox</a>的故事.</p>

<h2>Stack Overflow的故事</h2>

<p><a href="http://stackoverflow.com/">Stack Overflow</a>是一个免费的问答网站, 很类似国内的<a href="http://zhidao.baidu.com/">百度知道</a>, 不过它有浓郁的Geek和技术文化, <code>Stack Overflow</code>在程序中是堆栈溢出错误, 这是软件开发工作中一种很棘手, 很不容易处理的严重错误, <a href="http://stackoverflow.com/">Stack Overflow</a>还有相关的其它领域的一系列问答网站, 如体育, 各种外语, 电影电视, 个人理财等.</p>

<p>对我来说, 我日常工作中Google搜索问题时, 能在<a href="http://stackoverflow.com/">Stack Overflow</a>上得到十分有价值的答案, 甚至可以将工作分为<a href="http://heikezhi.com/2011/05/12/does-stackoverflow-make-us-lazy/">有Stack Overflow前和有了Stack Overflow之后</a>.</p>

<p><a href="http://stackoverflow.com/">Stack Overflow</a>属于<a href="http://stackexchange.com/">Stack Exchange</a>公司的产品, <a href="http://stackexchange.com/">Stack Exchange</a>下的一系列问答网站全都没有广告, 也没有向用户收费的服务, <a href="http://stackexchange.com/">Stack Exchange</a>也获得了风险投资, 不过这里要说的是在哪之前.</p>

<p><a href="http://www.joelonsoftware.com/">Joel Spolsky</a>是<a href="http://stackexchange.com/about/team">Stack Exchange的联合创始人</a>, 可以看到<a href="http://stackexchange.com/">Stack Exchange</a>团队很多人耍宝的GIF动画, <a href="http://www.joelonsoftware.com/">Joel Spolsky</a>同时也是<a href="http://www.fogcreek.com/">Fog Creek</a>的创始人, <a href="http://www.fogcreek.com/">Fog Creek</a>有一些不错的团队协作产品:</p>

<ul>
<li><a href="https://trello.com/">Trello</a>  在线协作工具, 在一个界面上组织多个项目, 实时沟通, 分派任务等.</li>
<li><a href="http://www.fogcreek.com/fogbugz/">FogBugz</a>  Bug跟踪工具, 在线申请立即开通, 可以和第三方工具和服务集成.</li>
<li><a href="http://www.fogcreek.com/kiln/">Kiln</a>  分布式版本控制系统(基于<a href="http://mercurial.selenic.com/">Mercurial</a>), 代码审查工具, 仍然是在线申请开通, 可以和FogBugz集成.</li>
<li><a href="https://www.copilot.com/">Copilot</a>  提供在线技术支持, 主要是修正电脑使用中的一些问题.</li>
</ul>


<p>除了<a href="https://trello.com/">Trello</a>是免费的外(无广告), 其它的都是免费试用 + 根据套餐按月付费, 提供基于Web和移动平台的客户端.</p>

<p><img class="right" src="http://i260.photobucket.com/albums/ii7/ruanyf/blog/bg2009120201.jpg" width="318" title="软件随想录" ></p>

<p><a href="http://www.joelonsoftware.com/">Joel Spolsky</a>的个人Blog名字叫<a href="http://www.joelonsoftware.com/">Joel on Software</a>, 他将自己Blog上的一些文章整理到一起, 出了本书叫<a href="http://www.amazon.com/More-Joel-Software-Occasionally-Developers/dp/1430209879">More Joel on Software</a>, 国内有出中文翻译<a href="http://www.ruanyifeng.com/mjos/">软件随想录</a>, 译者还是上文提到的<a href="http://www.ruanyifeng.com/blog/">阮一峰</a>, <a href="http://www.ruanyifeng.com/mjos/">点击这里</a>进去可以看到部分篇章, 里面讨论了软件开发中很多有趣的话题.</p>

<p>这里引用一段<a href="http://www.joelonsoftware.com/">Joel Spolsky</a>的介绍:</p>

<blockquote><p>Joel Spolsky（乔尔•斯波尔斯基）是一个世界闻名的软件开发流程专家。</p><p>他的网站“Joel谈软件”在全世界程序员中非常流行，被译成了30多种语言。</p><p>作为纽约的Fog Creek Software公司的创始人，他开发了FogBugz软件，这是一个在软件开发团队中非常流行的项目管理系统。</p><p>Joel曾经在微软公司工作，是Excel开发团队的一员，他设计了VBA（Excel的宏语言）。他还曾在Juno Online Services公司工作，开发了几百万用户使用的互联网客户端。</p><p>他已经出版了三本书：User Interface Design for Programmers（《程序员之用户界面设计》，Apress, 2001），《Joel谈软件》（Joel on Software, Apress, 2004），以及Smart and Gets Things Done（《巧妙完成工作》，Apress, 2007）。</p><p>他还是The Best Software Writing I（《最佳软件文选（第一辑）》，Apress, 2005）的编辑。</p><p>Joel从耶鲁大学获得计算机科学本科学位。</p><p>他曾在以色列国防军（Israeli Defense Forces）中服伞兵役，并且是以色列哈纳顿集体农场（Kibbutz Hanaton）的共同创始人之一。</p><footer><strong>阮一峰</strong> <cite><a href='http://www.ruanyifeng.com/blog/2008/10/i_will_translate_more_joel_on_software.html'>我要翻译《Joel on Software》了！</a></cite></footer></blockquote>


<p>这是<a href="http://stackoverflow.com/">Stack Overflow</a>的故事.</p>

<h2>Ruby on Rails的故事</h2>

<p><a href="http://rubyonrails.org/">Ruby on Rails</a>是我在做Java工程师时接触到的, 感叹它巧妙的设计, 在当时给Java世界带来了巨大的震撼, 原来Web应用也可以这样开发! 时至今日, <a href="http://rubyonrails.org/">Ruby on Rails</a>依然是<a href="http://www.ruby-lang.org/en/">Ruby</a>社区中的明星项目.</p>

<p>在之后的多年中我还陆续接触过<a href="http://groovy.codehaus.org/">Groovy</a> <a href="http://www.djangoproject.com/">Django</a> <a href="http://www.web2py.com/">web2py</a> <a href="http://www.playframework.org/">Apache Play</a> <a href="http://www.asp.net/mvc">ASP.Net MVC</a>, 它们或多或少都能看到<a href="http://rubyonrails.org/">Ruby on Rails</a>的影子.</p>

<p><img class="right" src="http://37signals.com/images/front-cover.png" width="318" title="REWORK: The new business book from 37signals." ></p>

<p><a href="http://rubyonrails.org/">Ruby on Rails</a>的作者是<a href="http://david.heinemeierhansson.com/">David Heinemeier Hansson</a>, 以下是他自己的简介, 我简单翻译成中文:</p>

<blockquote><p>我是Ruby on Rails的作者, 37signals的合伙人, 纽约时报(NYT)畅销书作家, 公开演说家, 业余摄影师, 和赛车手.</p><footer><strong>David Heinemeier Hansson</strong> <cite><a href='http://david.heinemeierhansson.com/'>David Heinemeier Hansson</a></cite></footer></blockquote>


<p>这里畅销书指的是<a href="http://37signals.com/rework">Rework</a>, 除了<a href="http://www.nytimes.com/">纽约时报(NYT)</a>外还有<a href="http://wsj.com/">华尔街日报(WSJ)</a>和<a href="http://www.thesundaytimes.co.uk/">The Sunday Times</a>, 由<a href="http://37signals.com/svn/writers/jf">Jason Fried</a>和<a href="http://david.heinemeierhansson.com/">David Heinemeier Hansson</a>合著, 封面是个揉了的纸团, 豆瓣网有<a href="http://book.douban.com/subject/5320866/">Rework</a>的中文简介.</p>

<p>还有一本<a href="http://gettingreal.37signals.com/">Getting Real</a>, 副标题是: 小规模，更快速，更高质量的软件构建方法, 翻译引用自<a href="http://cnborn.net/docs/getting_real/index.html">CNBorn</a>. 这是一本更多讲软件开发, 非技术方面的东西.</p>

<p>上面这两本书都可以<strong>免费</strong>从作者网站上下载的, 但是它们的实体书同样销售的不错, 也确实, 这种书需要反复的来回看, 领悟.</p>

<p><a href="http://37signals.com/">37signals</a>这家公司同样很有意思, 他们有几个在线协作产品:</p>

<ul>
<li><a href="http://basecamp.com/">Basecamp</a>  项目管理工具, 跟踪项目的讨论, 相关文件, 事件.</li>
<li><a href="http://highrisehq.com/">Highrise</a>  简单的CRM系统, 保存整理便笺和Email会话, 跟踪客户反馈和交易, 在公司 部门 团队中共享信息.</li>
<li><a href="http://campfirenow.com/">Campfire</a>  实时沟通, 类似IM, 但是专门设计用于小组.</li>
</ul>


<p>这些产品都是基于Web, 以及提供移动平台客户端, 并根据套餐按月付费.</p>

<p>他们有与众不同的内部工作方式, <a href="http://www.aqee.net/jason-fried-why-i-run-a-flat-company/">为什么我要把公司做成扁平型</a>, 作者是<a href="http://37signals.com/">37signals</a>的创始人<a href="http://37signals.com/svn/writers/jf">Jason Fried</a>.</p>

<p>在<a href="http://37signals.com/about">关于</a>还可以看到<a href="http://en.wikipedia.org/wiki/Jeff_Bezos">Jeff Bezos</a>, 他是作为<a href="http://37signals.com/">37signals</a>的顾问, 当然他更出名的是作为<a href="http://www.amazon.com/">亚马逊 Amazon.com</a>的创始人和CEO.</p>

<p>这是<a href="http://rubyonrails.org/">Ruby on Rails</a>的故事.</p>

<h2>末尾</h2>

<p>上面提到的网站和产品多数是英文的, 还有受限于我国的网络问题而无法访问.</p>

<p>上面提及的书基本都不涉及技术细节, 都很适合IT从业者反复阅读, 而<a href="http://37signals.com/rework">Rework</a>更是适合各种人群阅读.</p>

<p>即使未来不打算从事创业, 但是也很有助于辨别优秀的创业者, 合作方, 投资目标, 抑或是改善自己的日常工作</p>

<p>我仍旧无法用概括性的文字来描述我为什么要写上面的文字, 暂且作为对一些有趣资料的介绍吧.</p>

      <p><a href="http://netwjx.github.com/blog/2012/11/24/dropbox-stack-overflow-and-ruby-on-rails/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Javascript异步加载]]></title>
    
      <category term="Javascript" />
    
    <link href="http://netwjx.github.com/blog/2012/11/04/javascript-async-load/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-11-04T17:50:00+08:00</published>
    <updated>2012-11-04T17:50:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/11/04/javascript-async-load</id>
    <content type="html"><![CDATA[<p>这是8月份写了一份草稿, 但是一直都觉得这个主题组织起来比较纠结, 现在觉得不该再拖了, 先把之前的理解都整理出来吧.</p>

<p>异步加载这个名称不是很贴切, 实际上有三部分, 非阻塞(不暂停页面渲染) 下载 执行. 只是叫异步加载字数少点, 请不要完全从这个字面理解其意义.</p>

<p>主要用于外链的js文件, 会带来下面的好处:</p>

<ul>
<li>页面内容显示更快, 特别对于定义在<code>&lt;head&gt;</code>和文档开始处的外链js.</li>
<li>使用第三方Javascript时, 如果第三方无法访问, 也不会使页面很长时间是空白.</li>
<li>使用一些手法可以控制页面内容的显示顺序, 比如重要的先显示.</li>
<li>模块化Javascript, 使用<a href="#jsloader">Javascript模块加载器</a>管理大量相互依赖的Javascript.</li>
</ul>


<p>如果仅仅想页面内容显示的更快, 可以简单的把脚本放置在文档结尾, 比如<code>&lt;/body&gt;</code>标签前.</p>

<p>异步加载的js文件有一个限制的:</p>

<ul>
<li>不能使用<code>document.write()</code>, 因为页面已经加载完成, 再调用会覆盖现有页面的内容.</li>
</ul>


<p>下面是异步加载的一些实现方式.</p>

<h2>使用script标签的defer属性</h2>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span> <span class="na">defer</span> <span class="na">src=</span><span class="s">&quot;javascript.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>使用了<code>defer</code>属性的<code>&lt;script&gt;</code>标签下载时不会暂停页面渲染, 当页面解析完后执行, 即常说的<code>DOM Ready</code>之后, <code>window load</code>之前.</p>

<p>如果有多个<code>&lt;script defer&gt;</code>将会按照DOM中的顺序执行, 多个前后依赖的脚本可以放心使用.</p>

<!-- more -->


<p><code>defer</code>属性在html 4中就定义了, 各浏览器兼容性如下:</p>

<ul>
<li>Chrome, Safari支持.</li>
<li>Firefox 3.5开始支持, 从3.6开始对行内脚本忽略<code>defer</code>属性, 将会立即执行.</li>
<li>IE 4开始支持, 对于行内脚本的<code>defer</code>属性IE6会有一些特殊的规则.</li>
<li>Opera 不支持.</li>
</ul>


<p>行内脚本(inline script)是指相对于使用<code>src</code>属性外链的脚本来说的, 即下面的代码:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nx">alert</span><span class="p">(</span><span class="s1">&#39;inline script&#39;</span><span class="p">);</span>
</span><span class='line'><span class="nt">&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>IE6中外链脚本的<code>defer</code>属性符合上文描述的规则, 但是行内脚本遵循下面的规则.</p>

<ul>
<li><code>&lt;head&gt;</code>中定义的会在<code>&lt;head&gt;</code>标签解析完成执行.</li>
<li><code>&lt;body&gt;</code>中定义的会在<code>&lt;body&gt;</code>标签解析完成执行.</li>
</ul>


<h2>使用script标签的async属性</h2>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span> <span class="na">async</span> <span class="na">src=</span><span class="s">&quot;javascript.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>使用了<code>async</code>属性的脚本下载时同样不会暂停页面渲染, 但是它会在下载完成时就执行, 在多个外链脚本时, 可能会有无法控制的执行顺序, 前后依赖的多个脚本不能使用这种方式加载.</p>

<p><code>async</code>属性在html 5中定义, 各浏览器兼容性如下:</p>

<ul>
<li>Chrome, Safari支持.</li>
<li>Firefox 3.6开始支持.</li>
<li>IE 10开始支持.</li>
<li>Opera不支持.</li>
</ul>


<h3>async和defer的异同</h3>

<ul>
<li>同样都可以在下载时不暂停页面渲染.</li>
<li>下载完<code>async</code>会立即执行, 而<code>defer</code>会在页面解析完按照DOM树中的顺序执行.</li>
</ul>


<p>如果浏览器支持的话, <code>async</code>的优先级比<code>defer</code>高, 即如果<code>async</code>为<code>true</code>的话, 会忽略<code>defer</code>属性.</p>

<h2>使用Javascript编码方式</h2>

<p>上述拥有<code>defer</code> <code>async</code>属性的<code>&lt;script&gt;</code>标签都可以通过Javascript编码方式插入到DOM树中, 代码如下:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="p">(</span><span class="kd">function</span><span class="p">(){</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">node</span> <span class="o">=</span> <span class="nb">document</span><span class="p">.</span><span class="nx">createElement</span><span class="p">(</span><span class="s1">&#39;script&#39;</span><span class="p">);</span>
</span><span class='line'>    <span class="nx">node</span><span class="p">.</span><span class="nx">type</span> <span class="o">=</span> <span class="s1">&#39;text/javascript&#39;</span><span class="p">;</span>
</span><span class='line'>    <span class="nx">node</span><span class="p">.</span><span class="nx">async</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span> <span class="c1">// 使用async, 请根据实际需要修改</span>
</span><span class='line'>    <span class="nx">node</span><span class="p">.</span><span class="nx">defer</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span> <span class="c1">// 使用defer, 请根据实际需要修改</span>
</span><span class='line'>    <span class="nx">node</span><span class="p">.</span><span class="nx">src</span> <span class="o">=</span> <span class="s1">&#39;javascript.js&#39;</span><span class="p">;</span>
</span><span class='line'>    <span class="nb">document</span><span class="p">.</span><span class="nx">getElementsByTagName</span><span class="p">(</span><span class="s1">&#39;head&#39;</span><span class="p">)[</span><span class="mi">0</span><span class="p">].</span><span class="nx">appendChild</span><span class="p">(</span><span class="nx">node</span><span class="p">);</span>
</span><span class='line'><span class="p">}());</span>
</span><span class='line'><span class="nt">&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>上述代码适合放到<code>&lt;body&gt;</code>中, 因为<code>&lt;head&gt;</code>标签未解析完成的情况下不能插入元素.</p>

<p>也可以在页面加载后(<code>window.onload</code>)插入, 代码如下:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">w</span><span class="p">,</span> <span class="nx">d</span><span class="p">){</span>
</span><span class='line'>    <span class="k">if</span> <span class="p">(</span><span class="nx">w</span><span class="p">.</span><span class="nx">addEventListener</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>        <span class="nx">w</span><span class="p">.</span><span class="nx">addEventListener</span><span class="p">(</span><span class="s1">&#39;load&#39;</span><span class="p">,</span> <span class="nx">onLoad</span><span class="p">,</span> <span class="kc">false</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nx">w</span><span class="p">.</span><span class="nx">attachEvent</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>        <span class="nx">w</span><span class="p">.</span><span class="nx">attachEvent</span><span class="p">(</span><span class="s1">&#39;onload&#39;</span><span class="p">,</span> <span class="nx">onLoad</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span><span class='line'>        <span class="nx">w</span><span class="p">.</span><span class="nx">onload</span> <span class="o">=</span> <span class="nx">onLoad</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">function</span> <span class="nx">onLoad</span><span class="p">(){</span>
</span><span class='line'>        <span class="kd">var</span> <span class="nx">node</span> <span class="o">=</span> <span class="nx">d</span><span class="p">.</span><span class="nx">createElement</span><span class="p">(</span><span class="s1">&#39;script&#39;</span><span class="p">);</span>
</span><span class='line'>        <span class="nx">node</span><span class="p">.</span><span class="nx">type</span> <span class="o">=</span> <span class="s1">&#39;text/javascript&#39;</span><span class="p">;</span>
</span><span class='line'>        <span class="nx">node</span><span class="p">.</span><span class="nx">src</span> <span class="o">=</span> <span class="s1">&#39;javascript.js&#39;</span><span class="p">;</span>
</span><span class='line'>        <span class="nx">d</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">appendChild</span><span class="p">(</span><span class="nx">node</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}(</span><span class="nb">window</span><span class="p">,</span> <span class="nb">document</span><span class="p">));</span>
</span><span class='line'><span class="nt">&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>更常用的是<code>DOM Ready</code>之后插入, 相对会更早点, 鉴于完整的<code>DOM Ready</code>代码量比较多, 下面例子使用jQuery的<code>DOM Ready</code>实现:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="nx">jQuery</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">$</span><span class="p">){</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">file</span> <span class="o">=</span> <span class="s1">&#39;javascript.js&#39;</span><span class="p">;</span>
</span><span class='line'>    <span class="nx">$</span><span class="p">(</span><span class="s1">&#39;&lt;script type=&quot;text/javascript&quot;&gt;&#39;</span><span class="p">).</span><span class="nx">attr</span><span class="p">(</span><span class="s1">&#39;src&#39;</span><span class="p">,</span> <span class="nx">file</span><span class="p">).</span><span class="nx">appendTo</span><span class="p">(</span><span class="s1">&#39;head&#39;</span><span class="p">);</span>
</span><span class='line'><span class="p">});</span>
</span><span class='line'><span class="nt">&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Javascript编码方式也是<a href="#jsloader">Javascript模块加载器</a>基本原理.</p>

<p><a name="jsloader"></a></p>

<h2>使用Javascript模块加载器</h2>

<p>这是更重量级的做法, 适用于大量互相依赖的Javascript的异步加载, 一般需要遵循模块加载器的规则编写自己的模块以用于异步加载.</p>

<p>下面是常见Javascript模块加载器和简单的使用代码.</p>

<h3>RequireJS</h3>

<p><a href="http://requirejs.org/">RequireJS</a></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;head&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">data-main=</span><span class="s">&quot;scripts/main&quot;</span> <span class="na">src=</span><span class="s">&quot;scripts/require.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="c">&lt;!-- RequireJS加载完成后会加载 scripts/main.js, 其内容见下面的代码 --&gt;</span>
</span><span class='line'><span class="nt">&lt;/head&gt;</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span>scripts/main.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="nx">require</span><span class="p">([</span><span class="s2">&quot;helper/util&quot;</span><span class="p">],</span> <span class="kd">function</span><span class="p">(</span><span class="nx">util</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="c1">// 这个函数会在 scripts/helper/util.js 加载后调用.</span>
</span><span class='line'>    <span class="c1">// 参数 util 是 helper/util 模块, 其包括 helper/util.js 中使用 define() 定义的值和函数.</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<h3>Head JS</h3>

<p><a href="http://headjs.com/">Head JS</a> 除了提供加载js之外还可以加载css, css js和浏览器特性检测等. 这里只贴加载js的示例代码.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="nx">head</span><span class="p">.</span><span class="nx">js</span><span class="p">(</span><span class="s2">&quot;/path/to/jquery.js&quot;</span><span class="p">,</span> <span class="s2">&quot;/google/analytics.js&quot;</span><span class="p">,</span> <span class="s2">&quot;/js/site.js&quot;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>   <span class="c1">// all done</span>
</span><span class='line'><span class="p">});</span>
</span><span class='line'><span class="nt">&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<h3>SeaJS</h3>

<p><a href="http://seajs.org">SeaJS</a> 是 <a href="https://github.com/lifesinger">lifesinger</a> 发起的项目, 提供有完整的中文文档和相关预编译, 打包部署工具. 并且其模块化API遵循<a href="http://www.commonjs.org/" title="CommonJS">CommonJS</a>的标准.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;assets/sea-modules/seajs/1.3.0/sea.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="c1">// 加载入口模块</span>
</span><span class='line'><span class="nx">seajs</span><span class="p">.</span><span class="nx">use</span><span class="p">(</span><span class="s1">&#39;./assets/src/hello.js&#39;</span><span class="p">);</span>
</span><span class='line'><span class="nt">&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span>/assets/src/hello.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="nx">define</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">require</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>  <span class="c1">// 得到 Spinning 函数类</span>
</span><span class='line'>  <span class="kd">var</span> <span class="nx">Spinning</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./spinning&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// 初始化</span>
</span><span class='line'>  <span class="kd">var</span> <span class="nx">s</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Spinning</span><span class="p">(</span><span class="s1">&#39;#container&#39;</span><span class="p">);</span>
</span><span class='line'>  <span class="nx">s</span><span class="p">.</span><span class="nx">render</span><span class="p">();</span>
</span><span class='line'><span class="p">})</span>
</span></code></pre></td></tr></table></div></figure>


<p>使用spm打包部署</p>

<figure class='code'><figcaption><span>/assets/src/hello.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="nx">$</span> <span class="nx">cd</span> <span class="nx">hello</span><span class="o">-</span><span class="nx">seajs</span><span class="o">/</span><span class="nx">assets</span>
</span><span class='line'><span class="nx">$</span> <span class="nx">spm</span> <span class="nx">build</span>
</span><span class='line'><span class="p">...</span>
</span><span class='line'><span class="nx">BUILD</span> <span class="nx">SUCCESS</span><span class="o">!</span>
</span><span class='line'><span class="nx">$</span>
</span></code></pre></td></tr></table></div></figure>


<h2>作为第三方提供嵌入代码的建议</h2>

<p>如果打算让别的网站通过一段代码来嵌入自己网站的内容, 建议提供下面这种风格的嵌入代码.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;widget&quot;</span><span class="nt">&gt;&lt;/div&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">type=</span><span class="s">&quot;text/javascript&quot;</span> <span class="na">defer</span> <span class="na">async</span>
</span><span class='line'>    <span class="na">src=</span><span class="s">&quot;http://domain.com/widgets/username/?appendTo=widget&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="nt">&lt;/script&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<ul>
<li><code>id="widget"</code> 是用于放置第三方组件的容器.</li>
<li><code>script</code> 定义了 <code>defer</code> <code>async</code> 用于异步加载, 不会暂停页面渲染.</li>
<li><code>src</code> 属性的URL定义了用户相关的数据(<code>/username</code>), 以及指定把组件添加到<code>id="widget"</code>的标签中.</li>
</ul>


<p>其Javascript大概是这样的</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">var</span> <span class="nx">ele</span> <span class="o">=</span> <span class="nb">document</span><span class="p">.</span><span class="nx">getElementById</span><span class="p">(</span><span class="s1">&#39;widget&#39;</span><span class="p">),</span>
</span><span class='line'>    <span class="nx">html</span> <span class="o">=</span> <span class="p">[];</span>
</span><span class='line'>
</span><span class='line'><span class="nx">html</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="s1">&#39;&lt;a href=&quot;http://domain.com/username&quot;&gt;username&lt;/a&gt;&#39;</span><span class="p">);</span>
</span><span class='line'><span class="c1">// ...</span>
</span><span class='line'><span class="nx">ele</span><span class="p">.</span><span class="nx">innerHTML</span> <span class="o">=</span> <span class="nx">html</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<h2>延迟解析Javascript</h2>

<p>在参考资料中 <a href="https://developers.google.com/speed/docs/best-practices/mobile#DeferParsingJS" title="Defer parsing of JavaScript">Defer parsing of JavaScript</a> 提及在移动应用中一般会减少使用外链脚本的数量, 这样可能行内脚本会增多, 对于哪些不是必须立即执行的行内脚本可以尝试的延迟解析, 不仅仅是延迟执行.</p>

<p>具体做法比如将其写为注释或任何能让浏览器忽略的格式, 等需要的时候再使用<code>eval()</code>执行.</p>

<p>当然也可以简单的将所有<code>&lt;script&gt;</code>放在文档结尾.</p>

<h2>参考资料</h2>

<ul>
<li><a href="http://ued.ctrip.com/blog/?p=3121">script的defer和async 携程UED</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/HTML/Element/Script">script - HTML | MDN</a></li>
<li><a href="http://www.commonjs.org/" title="CommonJS">CommonJS</a></li>
<li><a href="https://developers.google.com/speed/docs/best-practices/rtt#PreferAsyncResources">Prefer asynchronous resources - Make the Web Faster - Google Developers</a></li>
<li><a href="https://developers.google.com/speed/docs/best-practices/payload#DeferLoadingJS">Defer loading of JavaScript - Make the Web Faster - Google Developers</a></li>
<li><a href="https://developers.google.com/speed/docs/best-practices/mobile#DeferParsingJS" title="Defer parsing of JavaScript">Defer parsing of JavaScript - Make the Web Faster - Google Developers</a></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/11/04/javascript-async-load/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[笔记本购买备忘]]></title>
    
      <category term="Memo" />
    
      <category term="Notebook" />
    
    <link href="http://netwjx.github.com/blog/2012/10/12/buy-notebook-memo/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-10-12T21:58:00+08:00</published>
    <updated>2012-10-12T21:58:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/10/12/buy-notebook-memo</id>
    <content type="html"><![CDATA[<p>很早就想过要对笔记本购买做个备忘, 方便自己也方便别人查阅, 前几天列了个大纲, 现在把具体的填完.</p>

<p>这不是针对特定品牌, 特定型号的备忘, 只是对购买笔记本中注意点的记录, 从软硬件, 到卖场交易等等.</p>

<h2>更新日志</h2>

<p>最近的修改在列表开始</p>

<ol>
<li>2012-12-07  补充一些卖场交易注意事项</li>
<li>2012-12-03  增加颜色, CPU规格链接</li>
<li>2012-10-16  增加验机篇章</li>
</ol>


<h2>外观</h2>

<p>购买时需要首先确定一些重要的外观需求, 比如大小, 接口设计, 键盘.</p>

<h3>屏幕</h3>

<p>屏幕从整体上决定了后面要说的体积和重量, 所以放在最开始.</p>

<p>屏幕尺寸, 14英寸的为主, 15英寸的会有额外的小键盘区域, 13及更低的<strong>可能会没有光驱</strong>.</p>

<p>屏幕长宽比, 之前的都是4:3的, 现在的主要是16:9和16:10, 这个影响最大的是<strong>打算另外买笔记本包的时候</strong>, 一定要确定电脑包的长度是否足够, 避免到时候不能用.</p>

<p>屏幕解析度, 目前主流是1366x768, 13 14 15英寸多数都一样, 未来可能会有解析度更高的屏幕出现.</p>

<p>液晶屏幕面板, 现在主要是TN面板, 主要响应速度快, 也有一些是IPS面板, 显示色彩更多, 更逼真, 就是响应慢点, 可能会有轻微拖尾.</p>

<p>哑光和镜面屏, 主要是在背后有强光的时候, 屏幕是否会反光. 另外, 哑光屏仔细看可能会看到很多彩色的点, 镜面屏一般比较清澈.</p>

<!-- more -->


<h3>体积和重量</h3>

<p>上段也大概提到了, 屏幕尺寸和比例决定了长宽, 一般14英寸, 16:9的笔记本长宽分别为35cm 24cm左右. 其它尺寸和长宽比的可以自行估计.</p>

<p>厚度按照最厚的地方算, 一般在2cm-3.5cm之间.</p>

<p>重量一般14英寸的笔记本带上电池在2-2.5kg之间, 如果再加电源的话, 在3kg左右.</p>

<h3>材质和颜色</h3>

<p>主要外壳部分一般是工程塑料, 磨砂或镜面处理. 掌托部分有些可能会使用金属拉丝的工艺, 当然仍旧是工程塑料的材质.</p>

<p>磨砂的反光少, 镜面的沾指纹看起来很明显, 但是也容易擦. 表面有光泽的样子比较吸引人.</p>

<p>另一类材料是镁铝合金, 价格会高一些, 这个手摸就能分辨出来.</p>

<p>红色白色等亮丽的颜色对女性可能更有吸引力, 可能不耐脏, 很容易显灰尘, 有划痕的话也会很明显, 需要在使用中多注意养护.</p>

<h3>周边接口</h3>

<p>笔记本的多数接口都在侧面, 接口主要考虑的是位置, 下面所说的<strong>前是指面向使用者的侧面</strong>, <strong>后就是面向前方的侧面</strong>.</p>

<p>下面的条目只是说好的设计怎么样, 一般很难能同时满足所有的, 实际应当根据自己的主要需求进行取舍.</p>

<ul>
<li>电源和网线可能是经常使用的接口, 应当放到的左右两边靠后侧的位置, 有些会直接设计到后侧.

<ul>
<li>选择的时候可以考虑自己的使用环境选择某一侧接口.</li>
</ul>
</li>
<li>多数人都是右撇子, 一般会随机赠送一个有线鼠标, 所以最好<strong>右侧有一个在靠后的USB接口</strong>用于连接鼠标.</li>
<li>USB接口是用的最多的, 好的设计会把两个接口距离设计的远点. 免得有些USB设备太大挡住了其它的接口.</li>
<li>耳麦接口有时可能是一体兼容接口, 买耳麦的话就不能同时使用耳机和麦克风了, 不过一般都是接耳机.</li>
<li>有时可能会考虑外接显示器, 或者是连接投影仪使用, VGA和HDMI接口出来的线应避免正好对着出风口.</li>
<li>散热器出风口应该避免对着连接附近接口的线, 否则会把线表面吹热的.

<ul>
<li>出风口一定不能对着前侧, 或者对着右侧的手吹.</li>
</ul>
</li>
</ul>


<h3>转轴</h3>

<p>一般分下沉式和上浮式, 下沉式的转轴比较多一些, 原因多种多样, 成本, 美观, 适用程度.</p>

<ul>
<li>下沉式转轴成本低点, 可能现在已经差距不明显了.</li>
<li>下沉式转轴合起来之后笔记本正面基本看不到铰链, 比较简洁美观.</li>
<li>下沉式转轴无法把屏幕打开到和键盘面平行, 即180度, 而上浮式转轴一般能做到, 当然这种场景不是很多.</li>
<li>下沉式转轴会让屏幕挡住后侧, 这一侧基本就不能有什么接口了, 有些散热器出风口对着这个方向, 结果是屏幕底沿被吹的比较热.</li>
</ul>


<h3>键盘</h3>

<p>鼠标和键盘作为操作笔记本的主要途径, 鼠标可以另配, 键盘就不方便换了, 所以应该一开始就明确自己可以适应怎么样的键盘.</p>

<ul>
<li>最主要的差异是笔记本键盘上的Fn键, 有的在左下的最外侧, 有的在Win和Alt键中间的位置(接近台式机键盘), 我一般要求必须是后一种, 因为会经常在台式机上操作, 在两种习惯上切换太别扭了.</li>
<li>方向键的大小, 有些设计的比较小, 我更倾向和其它键一样大小的设计.</li>
<li>键盘整体大小, 这个主要在小于14英寸的笔记本上需要注意, 更大的键盘面积当然用着更爽.</li>
<li>键帽是凹的还是平的, 凹的感觉更接近一般台式机的键盘, 平的用起来可能会有敲击时打滑的感觉, 特别是用指甲敲击时, 这个可以用加个键盘膜补足, 不过哪会是另外一种怪怪的感觉, 需要适应一段时间.</li>
<li>键距我感觉差别不是很明显, 还是整体面积更重要, 一般14寸的没啥特别明显的差别.</li>
<li>键程, 笔记本的都是超薄的, 击键的距离肯定比台式机短很多.</li>
</ul>


<h3>外观总结</h3>

<p>一般很难有能完全做到上面所说的最好的设计, 就算有, 可能也会在价格, 体积, 重量上有对应的改变. 所以只能根据各自的首要需求做出取舍.</p>

<p>选择型号的时候, 一般主要型号范围内全部使用一样的模具, 在了解了其中一个型号的外观后, 其它详细型号的外观差异基本没有.</p>

<p>每个品牌的型号规则差别很大, 可以自行了解, 辨别起来还是很容易的.</p>

<h2>内在</h2>

<h3>电池,功耗和续航</h3>

<p>这部分和笔记本的主要用途息息相关, 将能决定其它的主要配件和价格.</p>

<p>现在主流14寸笔记本续航时间在2-3小时之间, 具体看使用情况, 玩游戏最耗电, 看文章, 运行更少的程序, 开笔记本品牌商场提供的省电软件耗电会低.</p>

<p>电池现在基本都是锂电池了, 我不清楚笔记本是否大量使用锂聚合物电池, 不过仍旧属于锂电池, 对续航影响差距不大, 需要更长的续航时间就需要更大的电池. 聚合物电池相对安全性好些, 不会有爆炸的情况.</p>

<p>但是仍旧应该在合适的温度下使用笔记本.</p>

<p>如果没有特别强烈的需要电池续航的话, 可以不考虑太苛刻的电池和续航时间, 事实也是很多人仅仅把笔记本当作<strong>方便移动的台式机</strong>来使用.</p>

<p>功耗一般和机器性能有关, 在满负荷运转下, 性能越高, 功耗越高. 对应的发热也越高, 对散热要求会更高.</p>

<p>笔记本内部设计的十分紧凑, 所以应清楚自己的使用环境, 选择合适的配置, 新机器散热可能没问题, 但是长期使用, 散热风道积聚灰尘之后散热能力会下降, 在过热的环境下笔记本除了可能会罢工外, 还有损坏的风险.</p>

<h3>显卡</h3>

<p>显卡关乎游戏性能, 更好的显卡能流畅的运行高需求的游戏, 同时功耗, 发热量也上来了.</p>

<p>大概的显卡范围一般比较容易确定, 如果要在相近的几个型号中选择, 可以参考这个<a href="http://www.notebookcheck.net/Mobile-Graphics-Cards-Benchmark-List.844.0.html">Laptop Video Graphics Cards - Benchmark List</a>.</p>

<p>一般游戏都是使用特定DirectX版本, 而显卡性能测试软件3DMark系列分别针对不同的DirectX版本, 其对应关系如下:</p>

<ul>
<li>DirectX 9 -> 3DMark05 和 3DMark06</li>
<li>DirectX 10 -> 3DMark Vantage</li>
<li>DirectX 11 -> 3DMark 11</li>
</ul>


<p>所以可以先考虑主要玩的游戏所需要的DirectX版本, 然后考虑对应得分更高的显卡. 当然价格也是很重要的因素.</p>

<p>这里有一个笔记本显卡分级<a href="http://www.notebookcheck.net/Comparison-of-Laptop-Graphics-Cards.130.0.html">Comparison of Laptop Graphics Cards</a>, 给出了高端游戏显卡, 中端, 中低端, 低端, 办公用等显卡和相关的性能测试结果.</p>

<p>可以从中看到, 现在Intel HD Graphics 4000显卡, 也就是Intel酷睿i系列第三代处理器集成的显卡, 已经能达到中低端显卡的范畴了, 和NVIDIA GeForce GT 620M, NVIDIA GeForce GT 525M, NVIDIA GeForce GT 330M, AMD Radeon HD 7450M在同一范围, 如果你的选择范围在这个里面, 可以考虑一下CPU集成显卡.</p>

<p>其实这么说来, Intel超级本的游戏性能对付一般游戏还是可以接受的.</p>

<h3>内在总结</h3>

<p>没有提CPU? 我感觉CPU这东西是一分钱一分货, 性能参考<a href="http://www.notebookcheck.net/Mobile-Processors-Benchmarklist.2436.0.html">Comparison of Mobile Processors (CPU Benchmarks)</a>. 一般主流价位的笔记本其CPU性价比最高.</p>

<p>CPU详细的对比参见下面这两个链接, 分别来自Intel和AMD的官方, 目前多数笔记本都是Intel的CPU:</p>

<ul>
<li><a href="http://ark.intel.com/zh-cn#MobileProducts-MobileProcessors">Intel 查找和比较英特尔产品规格</a></li>
<li><a href="http://www.amd.com/CN/PRODUCTS/NOTEBOOK/APU/MAINSTREAM/Pages/mainstream.aspx#7">AMD  采用AMD加速处理器的笔记本</a></li>
</ul>


<p>内存一般看主流, 现阶段比较尴尬, 因为普遍笔记本能识别的只有3G左右内存, 等64位Windows和相关的软件流行的时候才能使用更大的内存.</p>

<p>硬盘基本什么大小的都够用, 固态, 或者混合硬盘相应的价格更高, 性能更好, 还是一分钱一分货.</p>

<h2>购买</h2>

<p>现实不是决定选择什么型号的机器然后购买就完了.</p>

<h3>卖场</h3>

<p>去卖场能够看到真实的机器, 上面的外观方面主要是到卖场是亲身感受为主, 但是卖场还是会存在各种坑人的事.</p>

<ul>
<li>临到提货的时候说没货了, 然后建议你换个型号, 很多被坑就是这样的.</li>
<li>把标配的鼠标, 电脑包当成赠品, 并依次和买家讨价还价. 实际上一般除了标配的外, 商家还会免费送屏幕膜, 外壳膜, 鼠标垫, 清洁套装, 笔记本散热器之类的, 只要你真的购买.</li>
<li>有些商家会有一些存货, 不太容易处理, 所以会不遗余力的给你推荐某个机型, 这些机型可能确实有些不错的特点, 但是不建议买, 看看就行了, 一般这样的机型它的市场价格已经比商家的报价低很多了.</li>
<li>商家的牌子可以完全无视, 什么旗舰店, 总店, 和他们的信誉完全没有关联, 不坑你坑谁, 还是自己有主意靠谱.</li>
</ul>


<p>在卖场一定要坚持一个原则, 不在卖场内做决定, 卖场内的商家会十分的热情, 环境也比较吵杂, 闷热, 这种情况下做出决定往往就是个不怎么好的决定, 建议在出了卖场后, 休息或者吃饭的时候再决定, 有朋友一起更好.</p>

<p>卖场中越大的店给推荐换型号时, 越倾向于推荐库存型号, 店大欺客是必然的.</p>

<p>在卖场中一定要注意防盗, 人多的地方什么事都可能发生, 特别是自己的注意力在别的东西上时, 最好多人一起, 一个人和商家交涉, 另一个打酱油.</p>

<p>逛卖场会比较累, 最好随身携带水, 吃饭也不要吃太多, 人在累的时候最容易被说服.</p>

<h3>网购</h3>

<p>网购主要是指在淘宝上网购, 因为淘宝上的规则目前都是到买家有利, 所以也不失为一个渠道. 网购的货源比较多, 卖场中哪些缺货的事不存在. 在自己家, 做决定也不是在紧张的环境中.</p>

<p>主流品牌的行货笔记本都有全国联保, 一般淘宝商城的都是行货. 如果你很在乎质保期限, 一定要商家开单据证明购买时间. 否则一般售后会按照出厂时间 + 3个月作为购买时间. 有些品牌的售后要求必须是发票才能证明购买时间, 请了解具体品牌的售后政策.</p>

<p>售后的工作流程会很麻烦, 时间也长, 就算说的再好的售后, 也难免遇到自己有特殊情况. 所以哪些品牌宣传中所谓的售后可以不用过多考虑, 我更在乎的是产品的质量, 什么售后补足产品质量是扯淡, 钱都收了, 做的好是人情, 耍赖是本份.</p>

<p>网店如果对买入的不满意, 可以要求退货或者换货, 退换的时间甚至可以达到1个月左右(利用淘宝有利买家的规则).</p>

<p>寄回的邮费可能需要自己出, 如果对自己的选机型的能力不够自信, 又觉得来回折腾又费心, 那么就不建议考虑网购了.</p>

<p>利用淘宝的规则还有卖家的承诺, 完全可以做到很好的维护自己的权益. 其实重点是买家可以在淘宝上给差评, 低评分, 举报等. 就算交易完成了, 还可以拍些东西给差评, 然后说没收到货, 拒绝支付.</p>

<p>这方面买家骚扰的成本比卖家反骚扰的成本低多了, 比卖场的情况好.</p>

<p>网购一般标配送的东西都齐全, 但是额外的可能就没有了, 毕竟价格低嘛, 要的话可以和卖家交涉.</p>

<p>目前笔记本的网购配送主要是顺丰快递, 这个快递还是很可靠的, 无论是速度还是对包裹的保护上.</p>

<h2>验机</h2>

<p>在卖场购买的话, 建议头天晚上决定好, 第2天上午在中意的几家当中交涉, 然后午饭后购买, 验机, 速度快的话, 能在下午6点前回家吃晚饭.</p>

<p>网购的话, 一般有好几天确认的时间, 还是比较宽裕的.</p>

<p>多数情况到这一步基本都没啥问题了, 但是难免有些个体差异, 如果让自己遇到了当然是越早发现越好, 所以验机步骤不能少.</p>

<p>拿到机器后先看包装和外观</p>

<ol>
<li>外包装一般侧面会有一块白底黑字的贴纸, 上面标的具体型号, 可以确认是否是自己购买的, 一般上面有关键的配置信息.</li>
<li>卖场中购买的话, 一般厂家或代理会给商家有返点, 商家会提前把机器拆开, 拿走里面的保卡作为证明, 网购的话具体问商家, 如果加了配件的话也可能会拆过.</li>
<li>看外包装有没有明显被碰撞的地方, 凹陷什么的.</li>
<li>拆开, 里面的包装纸是泡沫塑料的, 可以垫桌子上.</li>
<li>看主机的外壳是否有<strong>划痕</strong>, 对着光看, 还有屏幕和键盘那一面.</li>
<li>主机掌托可能会贴一些厂商的标签, 比如Intel Core的标签, 标签上的染料有些是指甲扣不掉的, 有些能扣掉.

<ul>
<li>我这是Intel, nVIDIA的扣不掉.</li>
<li>nVIDIA Optimus上面的能扣掉.</li>
</ul>
</li>
<li>看电池和主机上电池触点是否有<strong>磨损的痕迹</strong>, 出厂测试会留下一次痕迹.</li>
<li>后盖螺丝是否有<strong>螺丝刀的痕迹</strong>, 工厂的加工很精细, 一般不会有明显螺丝刀的痕迹.</li>
</ol>


<p>然后装上电池, 接通电源, 装系统或者启动.</p>

<p>先看看屏幕是否有亮点, 暗点, 万里有个一的话就和卖家交涉. 测试软件可以使用<a href="https://www.google.com.hk/search?ie=UTF-8&amp;oe=UTF-8&amp;sourceid=navclient&amp;gfns=1&amp;q=everest">EVEREST</a>, 工具菜单中有显示器测试.</p>

<p>接下来主要的接口测试, 比如USB, 网线接口, 耳麦接口, 读卡器, 有光驱的试试光驱弹出, 关闭. 有条件的还可以测试VGA或者HDMI接口.</p>

<p>网络部分WiFi, 有蓝牙的用手机试试蓝牙.</p>

<p>内部的硬件检测可以使用上面提到的<a href="https://www.google.com.hk/search?ie=UTF-8&amp;oe=UTF-8&amp;sourceid=navclient&amp;gfns=1&amp;q=everest">EVEREST</a>.</p>

<p>或者是<a href="http://www.ludashi.com/">鲁大师</a>, 比较简单直观, 有一个界面可以快速以习惯的词汇描述的硬件配置.</p>

<p>如果要跑分一般是<a href="http://www.3dmark.com/zh-hans/">3DMark</a>.</p>

<h2>附:关于Intel的超级本</h2>

<p>现在超级本还不是很多, 相信不远的未来这方面会多出很多. 所以有必要提提超级本.</p>

<p>超级本是Intel提出的概念, 对消费者来说就是Intel要求品牌厂商的笔记本至少要满足一些条件, 就可以使用超级本来做宣传, 也就是一些保底的要求, 对消费者来说主要是下面这些:</p>

<ul>
<li>薄, 最多2cm.</li>
<li>轻, 最多1.4kg.</li>
<li>超长待机, 至少5-8小时.</li>
<li>快速启动, 最多20秒.</li>
<li>快速唤醒, 最多4秒.</li>
</ul>


<p>这些是外在特点, 具体这些还需要很多相关内在的变化才能做到.</p>

<p>启动时间得依据实际的软件使用情况, 可能没有那么短, 不过一般出厂预装的软件环境应该是可以达到的.</p>

<p>综合起来说就是对付一般游戏, 典型的应用环境完全足够, 现阶段的价格还比较高, 不过未来成本降低的情况下相对传统的笔记本很有竞争力的, 所以我也相信它会在未来成为热点.</p>

<p><a href="http://www.intel.com/cn/ultrabook/">Intel超级本宣传页</a></p>

      <p><a href="http://netwjx.github.com/blog/2012/10/12/buy-notebook-memo/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[在Firefox下设置location不生效]]></title>
    
      <category term="Error" />
    
      <category term="Firefox" />
    
      <category term="Javascript" />
    
      <category term="Memo" />
    
      <category term="jQuery" />
    
    <link href="http://netwjx.github.com/blog/2012/10/01/set-location-is-invalid-in-firefox/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-10-01T16:26:00+08:00</published>
    <updated>2012-10-01T16:26:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/10/01/set-location-is-invalid-in-firefox</id>
    <content type="html"><![CDATA[<p>项目中使用的窗口组件加载内容是使用<code>iframe</code>实现的, 以前遇到的各种问题总是在IE下, 但是之前又发现一个很奇怪的问题, 仅在Firefox下出现.</p>

<p>具体表现为窗口组件关闭时再将相关的父级或<code>iframe</code>重定向到新的地址, 结果在Firefox下没看到重定向, 也没在错误控制台看到任何错误信息.</p>

<p>前提: 以下所有的都不涉及跨域的问题, 只描述Firefox下运行的情况, 目前我的Firefox版本是15.0.1.</p>

<p>关键结构如下, <code>$</code>表示jQuery:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="nt">&lt;script&gt;</span>
</span><span class='line'>    <span class="kd">function</span> <span class="nx">dialog</span><span class="p">()</span>
</span><span class='line'>        <span class="kd">var</span> <span class="nx">ifrm</span> <span class="o">=</span> <span class="nx">$</span><span class="p">(</span><span class="s1">&#39;&lt;iframe id=&quot;Dialog1&quot;&gt;&#39;</span><span class="p">).</span><span class="nx">appendTo</span><span class="p">(</span><span class="s1">&#39;body&#39;</span><span class="p">)[</span><span class="mi">0</span><span class="p">];</span>
</span><span class='line'>        <span class="nx">ifrm</span><span class="p">.</span><span class="nx">openWindow</span> <span class="o">=</span> <span class="nb">window</span><span class="p">;</span>
</span><span class='line'>        <span class="c1">// ...</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">function</span> <span class="nx">dialogClose</span><span class="p">(</span><span class="nx">frameElement</span><span class="p">,</span> <span class="nx">url</span><span class="p">)</span>
</span><span class='line'>        <span class="nx">$</span><span class="p">(</span><span class="nx">frameElement</span><span class="p">).</span><span class="nx">remove</span><span class="p">();</span>
</span><span class='line'>        <span class="p">(</span><span class="nx">frameElement</span><span class="p">.</span><span class="nx">openWindow</span> <span class="o">||</span> <span class="nb">window</span><span class="p">).</span><span class="nx">location</span> <span class="o">=</span> <span class="nx">url</span><span class="p">;</span>
</span><span class='line'><span class="nt">&lt;/script&gt;</span>
</span><span class='line'>
</span><span class='line'><span class="nt">&lt;iframe</span> <span class="na">id=</span><span class="s">&quot;main&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nt">&lt;button</span> <span class="na">onclick=</span><span class="s">&quot;parent.dialog()&quot;</span><span class="nt">&gt;</span>打开<span class="nt">&lt;/button&gt;</span>
</span><span class='line'>
</span><span class='line'><span class="c">&lt;!-- 打开窗口时 --&gt;</span>
</span><span class='line'><span class="nt">&lt;iframe</span> <span class="na">id=</span><span class="s">&quot;Dialog1&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nt">&lt;button</span> <span class="na">onclick=</span><span class="s">&quot;parent.dialogClose(frameElement, &#39;other.html&#39;)&quot;</span><span class="nt">&gt;</span>关闭并重定向 #main 的地址<span class="nt">&lt;/button&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>一些需要说明的实际情况</p>

<ul>
<li>窗口是指顶级页面的<code>window</code>和<code>iframe</code>中的<code>window</code>. 窗口下是指<code>window.document</code>和下面的所有DOM元素.</li>
<li>在<code>#main</code>中<code>parent.dialog()</code>实际是自动探测或指定在哪个父级打开窗口.

<ul>
<li>在<code>Dialog1</code>中<code>parent.dialogClose</code>实际是哪个窗口打开就重定向那个窗口, 或者指定重定向哪个窗口.</li>
</ul>
</li>
<li><code>&lt;iframe id="Dialog1"&gt;</code> 是按照实际打开的情况自动分配的id, 这里使用固定的id方便说明.</li>
</ul>


<p>上述代码运行后的结果没有产生重定向, 加了<code>try catch</code>后:</p>

<pre><code>An error occurred throwing an exception
</code></pre>

<p>出错行在 <code>(frameElement.openWindow || window).location = url;</code>.</p>

<!-- more -->


<p>怀疑可能是不能识别默认属性, 换成<code>location.href</code>试试</p>

<pre><code>"Component returned failure code: 0x804b000a (NS_ERROR_MALFORMED_URI) [nsIDOMLocation.href]"
</code></pre>

<p>在<a href="https://developer.mozilla.org/en-US/docs/DOM/window.location#Methods">MDN window.location</a>发现有<code>assign</code>和<code>replace</code>也可以用来重定向</p>

<p><code>assign</code>正常执行了, 但是<code>replace</code></p>

<pre><code>"Component returned failure code: 0x804b000a (NS_ERROR_MALFORMED_URI) [nsIDOMLocation.replace]"
</code></pre>

<p>想到可能和上下文有关吧, 试试用目标<code>window.setTimeout</code>, 传入字符串参数, 执行正常了.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="p">(</span><span class="nx">frameElement</span><span class="p">.</span><span class="nx">openWindow</span> <span class="o">||</span> <span class="nb">window</span><span class="p">).</span><span class="nx">setTimeout</span><span class="p">(</span><span class="s1">&#39;location=&quot;&#39;</span> <span class="o">+</span> <span class="nx">url</span> <span class="o">+</span> <span class="s1">&#39;&quot;&#39;</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
</span></code></pre></td></tr></table></div></figure>


<p>上述所有尝试的代码示例:</p>

<iframe style="width: 100%; height: 510px" src="http://jsfiddle.net/sLDmC/69/embedded/js,resources,html,css,result/light/"></iframe>


<ul>
<li>所有<code>iframe</code>加载的页面都在这一个里面, 根据不同的Url Query执行不同的代码.</li>
<li><code>openWindow.</code>表示重定向的是按钮所在窗口.</li>
<li>水平分割线下面的是重定向当前窗口.</li>
<li>蓝线以下是一些输出的信息, 以及发生异常时的异常信息.</li>
<li>重定向成功会显示一个红色背景的成功, 发生异常会在日志中显示出来.</li>
<li>重定向成功后, <strong>Result</strong>标签页右边有个<strong>Run again</strong>可以恢复开始状态.</li>
</ul>


<h2>另一方面</h2>

<p>虽然问题算是解决了, 但是为什么在哪种情况会发生异常, 仅在Firefox下. 还有没有其它可以回避这个异常的方式.</p>

<p>想想上面代码有些怪怪的就是, 先从DOM树中移除了<code>iframe</code>, 如果想办法调整一下移除和重定向的顺序, 就有了下面的示例:</p>

<iframe style="width: 100%; height: 510px" src="http://jsfiddle.net/sLDmC/68/embedded/js,resources,html,css,result/light/"></iframe>


<p>可以看到所有的重定向都成功了.</p>

<h2>总结</h2>

<ul>
<li>尽量避免使用<code>iframe</code>.</li>
<li>尽量使用一种方式进行跨<code>iframe</code>间的调用, 比如setTimeout方式.

<ul>
<li>调用参数尽量用基本类型, 比如字符串, 数字, 复杂的可以用JSON格式字符串.</li>
</ul>
</li>
<li>尽量规避从DOM树移除当前<code>iframe</code>后还需要执行代码的情况.

<ul>
<li>实在无法规避就需要十分注意前后的执行顺序.</li>
</ul>
</li>
</ul>


<p>当然如果和我一样是维护原有项目, 有很多地方不能随便修改, 遇到麻烦就只能大量摸索了. 比如上文中的尝试.</p>

<h2>附:使用location的assign()和replace()的注意点</h2>

<p>在<code>iframe</code>中<code>location.assign()</code>必须确保当前<code>iframe</code>已加载一个页面, 不然会发生错误</p>

<pre><code>"Component returned failure code: 0x804b000a (NS_ERROR_MALFORMED_URI) [nsIDOMLocation.assign]"
</code></pre>

<p>对于已加载页面的则正常, 例子:</p>

<iframe style="width: 100%; height: 370px" src="http://jsfiddle.net/gQvmx/13/embedded/js,resources,html,css,result/light/"></iframe>


      <p><a href="http://netwjx.github.com/blog/2012/10/01/set-location-is-invalid-in-firefox/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[自动运行和关机批处理]]></title>
    
      <category term="Bat" />
    
      <category term="Cmd" />
    
      <category term="Command" />
    
      <category term="Shell" />
    
      <category term="Windows" />
    
    <link href="http://netwjx.github.com/blog/2012/09/02/auto-run-and-powerdown/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-09-02T13:43:00+08:00</published>
    <updated>2012-09-02T13:43:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/09/02/auto-run-and-powerdown</id>
    <content type="html"><![CDATA[<p>之前在使用下载软件的完成后自动关机时, 关机失败, 还有导致无法启动, 可能是第三方软件在关机时的实现不够可靠吧. 也懒得找网上专门的自动关机软件, 就写了个自动关机的批处理, 也顺带实现自动运行程序的功能.</p>

<p>使用方式:</p>

<ul>
<li>复制下来用记事本保存为bat文件, 可以放桌面.</li>
<li><p>自动关机</p>

<p>双点批处理, 按照提示输入要等待的分钟数, 可以输入<code>3*60+15</code>这样的数学表达式, 只能是整数, 确定后就会在指定时间之后关机.</p></li>
<li><p>自动运行程序</p>

<p>将打算自动运行的程序或快捷方式拖到这个批处理文件上, 然后会出现和自动关机相似的提示, 一样的输入, 确定后不要关闭, 时间到之后会自动运行这个程序并关闭自身.</p>

<p>命令行下也可以, 第一个参数是要运行的程序, 后续的是要运行程序的参数. 然后按照提示信息来, 和上面的一样.</p></li>
</ul>


<!-- more -->


<p>代码部分:</p>

<figure class='code'><figcaption><span>Auto-Powerdown.bat</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
<span class='line-number'>53</span>
<span class='line-number'>54</span>
<span class='line-number'>55</span>
<span class='line-number'>56</span>
<span class='line-number'>57</span>
<span class='line-number'>58</span>
<span class='line-number'>59</span>
<span class='line-number'>60</span>
<span class='line-number'>61</span>
</pre></td><td class='code'><pre><code class='bat'><span class='line'><span class="p">@</span><span class="k">echo</span> <span class="k">off</span>
</span><span class='line'><span class="k">if</span> <span class="s2">&quot;%1&quot;</span><span class="o">==</span><span class="s2">&quot;&quot;</span> (<span class="k">goto</span> <span class="nl">POWERDOWN</span>) <span class="k">else</span> <span class="k">goto</span> <span class="nl">RUN</span>
</span><span class='line'>
</span><span class='line'><span class="nl">:POWERDOWN</span>
</span><span class='line'>title 自动关机
</span><span class='line'>shutdown <span class="n">/a</span> <span class="m">2</span><span class="p">&gt;</span><span class="n">nul</span>
</span><span class='line'><span class="k">if</span> not <span class="k">errorlevel</span> <span class="m">1</span> (
</span><span class='line'>    <span class="k">echo</span> 已取消上次设置的自动关机
</span><span class='line'>    <span class="k">echo</span>.
</span><span class='line'>)
</span><span class='line'><span class="k">echo</span> 请输入多久之后关闭计算机?
</span><span class='line'><span class="k">goto</span> <span class="nl">INPUT</span>
</span><span class='line'>
</span><span class='line'><span class="nl">:POWERDOWN1</span>
</span><span class='line'><span class="k">echo</span> 现在时间: <span class="nv">%date%</span> <span class="nv">%time%</span><span class="p">,</span> 将在<span class="nv">%mins%</span>分钟后关闭计算机.
</span><span class='line'><span class="k">set</span> <span class="n">/a</span> mins<span class="o">=</span><span class="nv">%mins%</span>*<span class="m">60</span>
</span><span class='line'>shutdown <span class="n">/s</span> <span class="n">/t</span> <span class="nv">%mins%</span> <span class="p">&gt;</span><span class="n">nul</span> <span class="m">2</span>&gt;&amp;<span class="m">1</span>
</span><span class='line'><span class="k">echo</span>.
</span><span class='line'><span class="k">echo</span> 成功<span class="p">,</span> 任意键关闭窗口<span class="p">,</span> 取消自动关机请重新双点 <span class="nv">%~nx0</span>.
</span><span class='line'><span class="k">pause</span> <span class="p">&gt;</span><span class="n">nul</span>
</span><span class='line'><span class="k">goto</span> <span class="nl">:EOF</span>
</span><span class='line'>
</span><span class='line'>
</span><span class='line'>
</span><span class='line'><span class="nl">:RUN</span>
</span><span class='line'>title <span class="nv">%~n1</span> 自动运行
</span><span class='line'><span class="k">echo</span> 请输入多久之后运行程序
</span><span class='line'><span class="k">echo</span>   <span class="nv">%1</span>
</span><span class='line'><span class="k">goto</span> <span class="nl">INPUT</span>
</span><span class='line'>
</span><span class='line'><span class="nl">:RUN1</span>
</span><span class='line'><span class="k">echo</span> 现在时间: <span class="nv">%date%</span> <span class="nv">%time%</span><span class="p">,</span> 将在<span class="nv">%mins%</span>分钟后运行程序 <span class="nv">%~nx1</span>
</span><span class='line'><span class="k">echo</span>.
</span><span class='line'><span class="k">echo</span> 等待中<span class="p">,</span> 请不要关闭当前窗口<span class="p">,</span> 取消自动运行请直接关闭当前窗口.
</span><span class='line'><span class="k">set</span> <span class="n">/a</span> mins<span class="o">=</span><span class="nv">%mins%</span>*<span class="m">60</span>+<span class="m">1</span>
</span><span class='line'>ping -l <span class="m">0</span> -n <span class="nv">%mins%</span> <span class="m">127</span>.<span class="m">0</span>.<span class="m">0</span>.<span class="m">1</span> <span class="p">&gt;</span><span class="n">nul</span>
</span><span class='line'><span class="k">echo</span>.
</span><span class='line'><span class="k">echo</span> 运行程序 <span class="nv">%1</span>
</span><span class='line'>start <span class="s2">&quot;&quot;</span> <span class="s2">&quot;%1&quot;</span> <span class="s2">&quot;%2&quot;</span> <span class="s2">&quot;%3&quot;</span> <span class="s2">&quot;%4&quot;</span> <span class="s2">&quot;%5&quot;</span> <span class="s2">&quot;%6&quot;</span> <span class="s2">&quot;%7&quot;</span> <span class="s2">&quot;%8&quot;</span> <span class="s2">&quot;%9&quot;</span>
</span><span class='line'><span class="k">echo</span>.
</span><span class='line'><span class="k">echo</span> 成功<span class="p">,</span> <span class="m">10</span>秒后自动关闭.
</span><span class='line'>ping -l <span class="m">0</span> -n <span class="m">10</span> <span class="m">127</span>.<span class="m">0</span>.<span class="m">0</span>.<span class="m">1</span> <span class="p">&gt;</span><span class="n">nul</span>
</span><span class='line'><span class="k">goto</span> <span class="nl">:EOF</span>
</span><span class='line'>
</span><span class='line'>
</span><span class='line'><span class="nl">:INPUT</span>
</span><span class='line'><span class="k">echo</span> 单位:分钟<span class="p">,</span> 例如: <span class="m">3</span>*<span class="m">60</span>+<span class="m">15</span> 表示<span class="m">3</span>小时<span class="m">15</span>分钟后
</span><span class='line'><span class="k">set</span> <span class="n">/p</span> str<span class="o">=</span>:
</span><span class='line'><span class="k">if</span> not <span class="k">defined</span> str <span class="k">goto</span> <span class="nl">INPUTERROR</span>
</span><span class='line'>
</span><span class='line'><span class="k">set</span> <span class="n">/a</span> mins<span class="o">=</span><span class="nv">%str%</span>
</span><span class='line'><span class="k">if</span> <span class="nv">%mins%</span> <span class="o">LEQ</span> <span class="m">0</span> <span class="k">goto</span> <span class="nl">INPUTERROR</span>
</span><span class='line'>
</span><span class='line'><span class="k">if</span> <span class="s2">&quot;%1&quot;</span><span class="o">==</span><span class="s2">&quot;&quot;</span> (<span class="k">goto</span> <span class="nl">POWERDOWN1</span>) <span class="k">else</span> <span class="k">goto</span> <span class="nl">RUN1</span>
</span><span class='line'>
</span><span class='line'>
</span><span class='line'><span class="nl">:INPUTERROR</span>
</span><span class='line'><span class="k">echo</span> 请输入有效的数字<span class="p">,</span> 任意键继续<span class="p">,</span> 退出请直接关闭.
</span><span class='line'><span class="k">pause</span> <span class="p">&gt;</span><span class="n">nul</span>
</span><span class='line'><span class="k">echo</span>.
</span><span class='line'><span class="k">goto</span> <span class="nl">INPUT</span>
</span></code></pre></td></tr></table></div></figure>


<ul>
<li><a href="http://netwjx.github.com/blog/2012/07/29/windows-shell-and-bat-skills/">Windows命令行和批处理技巧</a></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/09/02/auto-run-and-powerdown/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[关于PM2.5]]></title>
    
      <category term="Live" />
    
      <category term="Memo" />
    
    <link href="http://netwjx.github.com/blog/2012/08/26/about-pm2-dot-5/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-08-26T14:18:00+08:00</published>
    <updated>2012-08-26T14:18:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/08/26/about-pm2-dot-5</id>
    <content type="html"><![CDATA[<p>这里整理了一些关于空气质量主要指标PM2.5的相关资料, 主要参考自<a href="http://songshuhui.net/archives/tag/pm2-5">科学松鼠会关于PM2.5相关的文章</a>, 和<a href="http://blogs.america.gov/mgck/2012/06/12/pm/">雾谷飞鸿关于空气质量的文章</a>, 只是将我认为关键点用简短的话列出来.</p>

<ul>
<li>空气污染主要检测可吸入颗粒物, 臭氧, 二氧化碳, 二氧化硫.</li>
<li>颗粒物对人体影响是是最直接和严重的.</li>
<li>小于10微米(下称PM10)的颗粒物就可能被吸入肺, 而小于2.5微米(下称PM2.5)的穿透力更强, 更不易被粘膜吸附或咳嗽排出.</li>
<li>PM10主要来源于机械过程, 包括建筑施工, 道路扬尘和风.</li>
<li>PM2.5主要来源于燃烧, 包括木材, 烟草, 煤炭, 柴油, 汽油.</li>
<li>PM2.5比PM10能够吸附更多的有毒物质, 对呼吸系统和心血管系统危害大于PM10.</li>
<li>PM2.5也极易吸附有机污染物和重金属, 使致癌和基因突变几率明显提高.</li>
<li>所以联合国世界卫生组织(下称WHO)关于<strong>颗粒物空气质量准则(AQG)</strong>依据是PM2.5而不是PM10.</li>
<li>空气污染物检测指标单位是<strong>μg/m<sup>3</sup> </strong>, 即<strong>微克/立方米</strong>.</li>
<li>一般播报的是空气污染指数(API), 其相应的PM2.5浓度见下文的表格.</li>
<li>背景PM2.5浓度在3-5之间, 即没有人为污染, 自然情况下的浓度.</li>
<li>PM2.5浓度高的最明显的表现是<strong>天空变成灰蒙蒙一片</strong>, 空气能见度降低.</li>
</ul>


<!-- more -->


<h2>空气污染指数(API)和PM2.5浓度对应的限值</h2>

<table class="mytable">
    <tr>
        <td>PM2.5浓度<br/>μg/m<sup>3</sup></td>
        <td>15</td>
        <td>40</td>
        <td>65</td>
        <td>150</td>
        <td>250</td>
        <td>350</td>
        <td>500</td>
    </tr>
    <tr>
        <td>API</td>
        <td>50</td>
        <td>100</td>
        <td>150</td>
        <td>200</td>
        <td>300</td>
        <td>400</td>
        <td>500</td>
    </tr>
    <tr>
        <td>国内标准</td>
        <td style="background:#00e319">优</td>
        <td style="background:#fefe1f">良</td>
        <td style="background:#ff7d0a" colspan="2">轻微污染</td>
        <td style="background:#ff0302">中度污染 API&lt;250</td>
        <td style="background:#7d0122" colspan="2">重度污染 大于250</td>
    </tr>
    <tr>
        <td>美国标准</td>
        <td style="background:#00e319">良好</td>
        <td style="background:#fefe1f">中等</td>
        <td style="background:#ff7d0a">对敏感人群不健康</td>
        <td style="background:#ff0302">不健康</td>
        <td style="background:#98024b">非常不健康</td>
        <td style="background:#7d0122" colspan="2">有毒害</td>
    </tr>
    <tr>
        <td>香港标准</td>
        <td style="background:#00e319">轻微 API&lt;25<br/>中等 API&lt;50</td>
        <td style="background:#fefe1f">偏高</td>
        <td style="background:#ff0302" colspan="2">甚高</td>
        <td style="background:#7d0122" colspan="3">严重</td>
    </tr>
    <tr>
        <td>加拿大标准</td>
        <td style="background:#00e319">良好 API&lt;25<br/>中等 API&lt;50</td>
        <td style="background:#fefe1f">较差</td>
        <td style="background:#7d0122" colspan="5">极差</td>
    </tr>
</table>


<p>例如: PM2.5在15到40之间, 那么API就在50到100之间, 按照国内标准评级的话, 就是良.</p>

<h2>WHO关于颗粒物空气质量准则和过渡期目标</h2>

<p>由于优先选择PM2.5, 所以PM10的就不列出来了, 想看可以看开头参考的文章.</p>

<table class="mytable">
    <tr>
        <th>&nbsp;</th>
        <th>PM2.5 μg/m<sup>3</sup> 年均</th>
        <th>PM2.5 μg/m<sup>3</sup> 日均</th>
    </tr>
    <tr>
        <td>过渡期-1</td>
        <td>35</td>
        <td>75</td>
    </tr>
    <tr>
        <td>过渡期-2</td>
        <td>25</td>
        <td>50</td>
    </tr>
    <tr>
        <td>过渡期-3</td>
        <td>15</td>
        <td>37.5</td>
    </tr>
    <tr>
        <td>准则(AQG)</td>
        <td>10</td>
        <td>25</td>
    </tr>
</table>


<h2>一张图片</h2>

<p>2001-2006年卫星图片显示的全球PM2.5均值</p>

<p><img src="http://songshuhui.net/wp-content/uploads/2011/08/483910main1_Global-PM2.5-map-670-600x300.jpg" width="618" height="309" title="2001-2006年卫星图片显示的全球PM2.5均值" ></p>

<p>上图来自 <a href="http://www.nasa.gov/topics/earth/features/health-sapping.html">New Map Offers a Global View of Health-Sapping Air Pollution</a></p>

<p>国内尚没有执行WHO的颗粒物空气质量准则和过渡期目标(拟于2016年实施过渡期-1的目标), 但是北京和东 南沿海各个省份已经在发布PM2.5空气质量指数, 可以自行找当地的环保部门网站查看.</p>

<p>智能手机可以找找有没有当地的空气质量报告软件, 有些地方性的手机软件有PM2.5的指数, 比如我现在用的是<a href="https://play.google.com/store/apps/details?id=com.cas.airquality">全国空气质量</a>.</p>

<h2>关于防护</h2>

<p>颗粒物分类, 包括PM2.5和PM10</p>

<ul>
<li>非油性颗粒物, 一般记作N, 典型的有水泥粉尘.</li>
<li>油性颗粒物, 一般记作P, 典型的有厨房油烟, 汽车尾气, 沥青烟雾.</li>
</ul>


<p>避免接触为上策, 没办法的时候只能先用口罩.</p>

<p>无论国内还是国外检测口罩防护效果使用的都是氯化钠气溶胶和石蜡油, 其粒径在0.02-2微米到之间, 捕获率是按照最小计算, 而不是平均值, 所以可以理解为对PM2.5的防护能力.</p>

<p>NiOSH标准, 测试空气流量：85L/分钟</p>

<table class="mytable">
    <tr>
        <th>等级</th>
        <th>捕获率</th>
    </tr>
    <tr>
        <td>N95 R95 P95</td>
        <td>≥95%</td>
    </tr>
    <tr>
        <td>N99 R99 P99</td>
        <td>≥99%</td>
    </tr>
    <tr>
        <td>N100 R100 P100</td>
        <td>≥99.97%</td>
    </tr>
</table>


<ul>
<li>N针对非油性颗粒物.</li>
<li>R和P针对油性和非油性颗粒物.</li>
<li>R用于油性颗粒物防护使用时间不能超过8小时.</li>
<li>P的使用时间遵循制造商的建议.</li>
</ul>


<p>中国GB2626-2006标准, 测试空气流量：85L/分钟</p>

<table class="mytable">
    <tr>
        <th>等级</th>
        <th>捕获率</th>
    </tr>
    <tr>
        <td>KN90 KP90</td>
        <td>≥90%</td>
    </tr>
    <tr>
        <td>KN95 KP95</td>
        <td>≥95%</td>
    </tr>
    <tr>
        <td>KN100 KP100</td>
        <td>≥99.97%</td>
    </tr>
</table>


<ul>
<li>KN针对非油性颗粒物.</li>
<li>KP针对油性颗粒物.</li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/08/26/about-pm2-dot-5/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[在Eclipse中的Java开发技巧(3)]]></title>
    
      <category term="Eclipse" />
    
      <category term="Java" />
    
      <category term="Tips" />
    
    <link href="http://netwjx.github.com/blog/2012/08/19/java-development-tips-in-eclipse-3/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-08-19T13:29:00+08:00</published>
    <updated>2012-08-19T13:29:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/08/19/java-development-tips-in-eclipse-3</id>
    <content type="html"><![CDATA[<ul>
<li>2012-09-10 增加和网友交流发现的很实用的快捷键, 和补充一些快捷键</li>
</ul>


<p>这篇主要是默认设置下的常用的快捷键, 类似vim这类编辑器, 形成一个标准可以带来一些好处, 诸如方便交流, 不需要备份恢复太多自定义配置.</p>

<p>主要挑哪些很实用, 比较容易按到的.</p>

<h2>自动完成</h2>

<p>基本上有语法分析的编辑环境都会有自动完成, 经常的目的是提示类的方法等, Eclipse中自动完成是按<strong>Alt + /</strong>, 重复按可以在几个不同类目切换, 具体可以自己试试.</p>

<p><strong>Alt + Shift + /</strong> 是用于参数提示, 和<strong>Alt + /</strong>效果差不多, 甚至有时能相互通用, 不过这个参数提示比较简单, 只有类型和参数名, 详细的还得在看方法提示时右边出现的说明.</p>

<p><strong>Ctrl + Enter</strong> 这个不是单独使用, 而是在按了<strong>Alt + /</strong>之后使用, 用于修改一个方法调用, 因为按<strong>Enter</strong>将是插入代码. 具体见下图</p>

<p><img src="http://netwjx.github.com/i/e/content-assist.png" alt="Content Assist" /></p>

<p>在类一级, 即方法外面按<strong>Alt + /</strong>会提示可重写的方法.</p>

<!-- more -->


<h2>在不同场景下的 Ctrl+1</h2>

<p><strong>Ctrl + 1</strong>是快速修正, 不同场合会有十分不同的功能, 我觉得它是Eclipse中使用频率仅次于<strong>Alt+/</strong>的快捷键.</p>

<h3>创建变量方法和类</h3>

<p>直接写变量赋值而不写变量类型时, 按<strong>Ctrl + 1</strong></p>

<p><img src="http://netwjx.github.com/i/e/quick-fix-1.png" alt="Quick Fix" /></p>

<p>快速修正的列表中</p>

<ul>
<li><p><strong>Create local variable &#8216;a&#8217;</strong></p>

<p>创建方法内变量, 上面已经有截图.</p></li>
<li><p><strong>Create field &#8216;a&#8217;</strong></p>

<p>创建类变量.</p></li>
<li><p><strong>Create parameter &#8216;a&#8217;</strong></p>

<p>创建方法参数.</p></li>
<li><p><strong>Remove assignment</strong></p>

<p>删除.</p></li>
</ul>


<p>直接写方法调用<code>foo("bar")</code>, 而不实现方法时, 按<strong>Ctrl + 1</strong>, 会有<strong>Create method &#8216;methodName(paramType)&#8217;</strong>, <strong>Enter</strong>后会在合适的位置创建指定的方法空实现, 并且参数都已经写好, 按<strong>Tab</strong>键可以切换到返回类型和参数类型上调整, 最后<strong>Enter</strong>两次完成.</p>

<p>类也可以用相似的方式创建, 先写<code>new Foo("Name")</code>, 然后<strong>Ctrl + 1</strong>, 选<strong>Create class &#8216;Foo&#8217;</strong>. 如果是在方法调用中这么写<code>foo(new Bar())</code>, 并且<code>foo</code>方法的参数有具体的类型限制, 那么创建的类会继承参数指定的类型或实现参数的接口类型.</p>

<p>如果现有类里面有, <strong>Ctrl + 1</strong>会出现<strong>Import &#8216;Xxx&#8217; (xxx.xx)</strong>, 用于引入现有类.</p>

<h3>添加接口方法的默认实现</h3>

<p>在类声明上写了<code>implements IFoo</code>后, 按<strong>Ctrl + 1</strong>会有</p>

<ul>
<li><p><strong>Add unimplemented methods</strong></p>

<p>添加未实现的接口方法.</p></li>
<li><p><strong>Make type &#8216;Xxx&#8217; abstract</strong></p>

<p>修改当前类为抽象.</p></li>
</ul>


<p>还有抽象类的抽象方法也有类似的提示, 具体可以自行尝试, 套路基本和上面的一样.</p>

<p>结合上段, 使用匿名内部类时, 输入<code>new InterfaceClass(){}</code>之后按<strong>Ctrl + 1</strong>, 也有<strong>Add unimplemented methods</strong>, 这在写UI程序时添加事件回调很有用.</p>

<h3>移除默认生成的TODO</h3>

<p>所有默认生成的方法都会有<code>// TODO Auto-generated method stub</code> 这段, 可以在那一行按<strong>Ctrl + 1</strong> -> <strong>Remove task tag</strong></p>

<p>不过直接按删除行更直接点, <strong>Ctrl + D</strong></p>

<h3>对没有错误的代码按<strong>Ctrl + 1</strong></h3>

<p>这一般是在打算调整代码时用, 十分通用的比如重命名, 可以按<strong>Alt + Shift + R</strong>更直接点.</p>

<p>在变量声明或赋值上按<strong>Ctrl + 1</strong>, 下面是一些比较有用的.</p>

<ul>
<li><p><strong>Convert local variable to field</strong></p>

<p>把本地变量转换为类变量.</p></li>
<li><p><strong>Split variable declaration</strong></p>

<p>和下一项相反, 把变量声明和赋值分离, 在操作外部资源, 用<code>try finally</code>时很有用.</p></li>
<li><p><strong>Join variable declaration</strong></p>

<p>将变量赋值和声明合并为一行.</p></li>
<li><p><strong>Extract to local variable</strong></p>

<p>把变量扩展为本地变量, 一般是优化时使用, 访问本地变量比类变量快.</p></li>
</ul>


<p>在类变量上按<strong>Ctrl + 1</strong>有<strong>Create getter and setter for &#8216;xxx&#8217;</strong>用于创建类变量的<code>get</code>和<code>set</code>方法, 如果是<code>boolean</code>类型会把<code>get</code>变成<code>is</code>.</p>

<p>不过常见的情况是用菜单栏<strong>Source</strong> -> <strong>Generate Getters and Setters</strong>, 可以一次性把选择的类变量生成<code>get</code> <code>set</code>方法.</p>

<h3>快速打开文件</h3>

<p>在多数情况下, 项目中名称重复的文件并不多, 特别是在做jsp开发的时候, 可以使用<strong>Ctrl + Shift + R</strong>, 输入文件名称就能很快的打开相关的文件.</p>

<p>这段来自和网友的交流.</p>

<h3>快速在当前文件内的方法间跳转</h3>

<p>上篇介绍的<strong>Breadcrumb</strong>需要鼠标点才能完成上述目的, 也可以用<strong>Ctrl + O</strong>打开临时的<strong>Outline</strong>试图, 可以输入文本过滤, 或者用方向键选择, 最后按<strong>Enter</strong>转向到指定的方法.</p>

<p>这个在全屏编辑的时候很有用.</p>

<h3>Eclipse的使用方法就是经常<strong>Ctrl + 1</strong></h3>

<p>上面是我遇到的常用的地方, 还有很多地方都可以按<strong>Ctrl + 1</strong>, 可以自行尝试.</p>

<h2>在最近编辑的地方跳转</h2>

<ul>
<li><p><strong>Ctrl + Q</strong></p>

<p>在修改代码的时候很有用, 快速跳到刚刚修改的地方, 而不撤销代码的修改.</p></li>
<li><p><strong>Alt + 方向左/方向右</strong></p>

<p>这个也是在最近的相关文件的行中跳转, 但是我也不是很理解具体的规则, 只是偶尔用用看.</p></li>
</ul>


<h2>查看JavaAPI Doc</h2>

<p>默认鼠标移上去就能看到, 但是需要悬停一会, 如果不想碰鼠标, 可以将光标移动到相关的类或者方法上按<strong>F2</strong>, 和鼠标悬停弹出的完全一样.</p>

<h2>最大化编辑区域</h2>

<p><strong>Ctrl + M</strong>, 看个人喜好, 我一般是临时用用, Eclipse可以把编辑窗口拖出来分离成左右或上下的, 最大化时仍旧保持左右或上下, 适合对比分析代码, 比如一个客户端, 一个服务端的代码.</p>

<h2>关闭文件</h2>

<p><strong>Ctrl + W</strong> 和几乎所有主流浏览器的关闭窗口快捷键一样, 大量的编辑器也是这个键, 经常用的话就会很自然了.</p>

<h2>查找快捷键</h2>

<p>上面提到的常用快捷键肯定有遗漏, 如果想自己找相关快捷键可以这样操作.</p>

<p>菜单栏 <strong>Window</strong> -> <strong>Preferences</strong>, 在左侧顶部输入<code>Keys</code>, 一般就一个, 可以看到如下界面</p>

<p><img src="http://netwjx.github.com/i/e/keys.png" alt="Keys" /></p>

<p>一般<strong>Scheme</strong>保持<strong>Default</strong>不变, 在<strong>type filter text</strong>输入自己想知道的快捷键锁功能相关的单词, 然后在下面出现的快捷键上找, 并尝试.</p>

<h2>基本通用的编辑快捷键</h2>

<p>这些不限于在Eclipse中使用, 很多地方也可以用这些快捷键, <strong>彻底不了解的可以看, 其他人可无视</strong>.</p>

<ul>
<li><p><strong>Ctrl + 方向左/方向右</strong></p>

<p>光标向左/右移动一个单词, 中文没有单词可能不适用, 不过在代码中很常用.</p></li>
<li><p><strong>Shift + 方向左/方向右</strong></p>

<p>向左/右选择一个字符, 可以重复按选择多个.</p></li>
<li><p><strong>Shift + 方向上/方向下</strong></p>

<p>从当前光标位置向上/下选一行, 可以配合左/右, 重复按来调整选择区域.</p></li>
<li><p><strong>Ctrl + Shift + 方向左/方向右</strong></p>

<p>向左/右选择一个单词, 可以配合上面提到的细节调整选择区域.</p></li>
<li><p><strong>Ctrl + 方向上/方向下</strong></p>

<p>滚动条上下滚动, 光标不移动, 一般是一次滚动一行.</p></li>
<li><p><strong>Home</strong> <strong>End</strong></p>

<p>移动到行首/行末, 配合<strong>Shift</strong>可以变成选择到行首/行末. 有些编辑器能自动检测行首缩进.</p></li>
<li><p><strong>Page Down</strong> <strong>Page Up</strong></p>

<p>上翻页, 下翻页, 配合<strong>Shift</strong>可以选择上一页/下一页的内容.</p></li>
<li><p><strong>Ctrl + X/C/V</strong></p>

<p>Windows平台最常用的, 剪贴, 复制, 粘贴.</p></li>
<li><p><strong>Tab</strong></p>

<p>单独按就是缩进, 根据编辑器的设置, 可能被替换为空格. 配合选中多行, <strong>Tab</strong>可以调整多行的缩进. 配合<strong>Shift</strong>可以反缩进, 即减少缩进, 文本向左移动. 这个不是十分通用, 不过多数编程环境都是这样的.</p></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/08/19/java-development-tips-in-eclipse-3/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[在Eclipse中的Java开发技巧(2)]]></title>
    
      <category term="Eclipse" />
    
      <category term="Java" />
    
      <category term="Tips" />
    
    <link href="http://netwjx.github.com/blog/2012/08/12/java-development-tips-in-eclipse-2/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-08-12T12:46:00+08:00</published>
    <updated>2012-08-12T12:46:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/08/12/java-development-tips-in-eclipse-2</id>
    <content type="html"><![CDATA[<p>这是这个系列的第2篇, 还是十分简单的技巧.</p>

<h2>调试时的ScrapBook</h2>

<p>上篇介绍到了ScrapBook, 在断点调试时也有类似的功能.</p>

<p><img src="http://netwjx.github.com/i/e/display.png" alt="Display" /></p>

<p>通过<strong>Window</strong> -> <strong>Show View</strong> -> <strong>Other</strong>, 在<strong>Show View</strong>窗口顶部的文本框输入<code>Display</code>, 应该会在下面看到<strong>Display</strong>, 点击即可打开上图所示界面.</p>

<p>具体功能和上篇的ScrapBook基本一致, 只是用于调试时, 这个主要是可以在调试时, 把一些变量的值直接以文本方式展示, 甚至可以自己填些说明, 方便后续的调试参考.</p>

<!-- more -->


<h2>快速找到当前文件在项目中的位置</h2>

<p>经常会需要查看当前编辑的文件在项目文件系统中的路径, 标签上只显示了文件名, 鼠标移上去可以看到路径, 但是如果想查看同目录下其它的文件就比较麻烦了. 下面是个快速找到当前文件在项目中位置的方式.</p>

<p><img src="http://netwjx.github.com/i/e/link-with-editor.png" alt="Link With Editor" /></p>

<p>因为点了<strong>Link With Editor</strong>后, 切换编辑的文件将总会自动转到对应的项目路径, 所以一般我会点两次恢复默认.</p>

<h2>快速在临近的类和方法中跳转</h2>

<p>上一段说的是针对所有文件都能生效的方法, 但是对于Java类来说, 想知道它在项目中的路径, 挺多时候实际目的是查看和它临近类, 那么可以使用<strong>Breadcrumb</strong>.</p>

<p><img src="http://netwjx.github.com/i/e/breadcrumb.png" alt="Breadcrumb" /></p>

<h2>两种不同风格的包浏览结构</h2>

<p>在项目上可以显示两种不同的Java包结构, 通过点击<strong>Package Explorer</strong>或<strong>Project Explorer</strong>窗口右上的<strong>View Menu</strong> -> <strong>Package Presentation</strong> -> <strong>Flat</strong>或<strong>Hierarchical</strong>在两种风格中切换, 实际效果如图:</p>

<p><img src="http://netwjx.github.com/i/e/package-presentation.png" alt="Package Presentation" /></p>

      <p><a href="http://netwjx.github.com/blog/2012/08/12/java-development-tips-in-eclipse-2/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[在Eclipse中的Java开发技巧(1)]]></title>
    
      <category term="Eclipse" />
    
      <category term="Java" />
    
      <category term="Tips" />
    
    <link href="http://netwjx.github.com/blog/2012/07/31/java-development-tips-in-eclipse-1/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-07-31T21:12:00+08:00</published>
    <updated>2012-07-31T21:12:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/07/31/java-development-tips-in-eclipse-1</id>
    <content type="html"><![CDATA[<p>这是我以前使用Eclipse时经常使用的一些小技巧, 多数都是比较基础的, 涉及的方面也比较的多. 觉得比较实用, 就整理成文.</p>

<p>不分先后顺序, 只是想到什么就写什么, 因为内容比较多, 所以这篇是1.</p>

<p>以英文版的介绍为主, 因为我发现很多人基本都只使用英文版.</p>

<h2>快速测试简短代码</h2>

<p>不是很熟悉字符串的查找, 截取等到底返回的是多少? 不清楚日期返回的年月日分别是几? 不清楚某个静态方法给特定值返回的是多少?</p>

<!-- more -->


<p>这些经常会遇到的小问题, 基本都可以建立一个测试Java项目写个包含main的静态方法, 在里面写测试代码就行了. 但是这样始终很麻烦. 可以试试下面的这个功能:</p>

<p>先确保右上已经选择的是 <strong>Java</strong>(Java perspective), 在随便一个Java项目中右键 -> <strong>New</strong> -> <strong>Other</strong>, 选择树状结构中的<strong>Java -> Java Run/Debug -> Scrapbook Page</strong>, 如下图</p>

<p><img src="http://netwjx.github.com/i/e/scrapbook.png" alt="ScrapBook" /></p>

<p>然后<strong>Next</strong>, 输入文件名, 比如<code>test</code>, <strong>Finish</strong>. 打开的窗口中可以输入类似下面的代码, 选择所有代码后点工具栏上的<strong>Display Result of Evaluating Selected Text</strong>, 如下图:</p>

<p><img src="http://netwjx.github.com/i/e/scrapbook-1.png" alt="ScrapBook" /></p>

<p>鼠标右键菜单中也有和菜单栏按钮等价的菜单项:</p>

<p><img src="http://netwjx.github.com/i/e/scrapbook-2.png" alt="ScrapBook" /></p>

<ul>
<li><p>Inspect</p>

<p>可以在弹出的小窗口中显示, 类似Eclipse中调试Java代码时的Inspect</p></li>
<li><p>Display</p>

<p>上文已经说过了, 它可以将这段表达式或最后一行语句的结果显示在编辑器中</p></li>
<li><p>Execute</p>

<p>这个和直接运行差不多, <code>System.out.println</code>这些会输出</p></li>
<li><p>Set Imports</p>

<p>设置默认导入哪些类, 包, 类似Java中<code>import</code>语句</p></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/07/31/java-development-tips-in-eclipse-1/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[批量删除Catch.com笔记的小工具]]></title>
    
      <category term="Bookmarklet" />
    
      <category term="Javascript" />
    
    <link href="http://netwjx.github.com/blog/2012/07/29/batch-delete-catch-notes-bookmarklet/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-07-29T18:12:00+08:00</published>
    <updated>2012-07-29T18:12:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/07/29/batch-delete-catch-notes-bookmarklet</id>
    <content type="html"><![CDATA[<h2>变更日志</h2>

<ul>
<li>2012-09-01 <strong>Catch.com新版本已经可以批量删除了, 不再需要这个工具了</strong></li>
<li>2012-08-11 Catch.com的代码有变, 修改了一下中间的CSS选择器</li>
</ul>


<hr />

<p>目前手机上使用<a href="https://catch.com/">Catch</a>来记录和收集手机上看到的各种信息, 在电脑上查看之后会删除, 但是奇怪的是<a href="https://catch.com/">Catch.com</a>网站的<strong>My Ideas</strong>不显示删除按钮, 而别的都会显示, 但是在手机上收集的信息默认不选择的时候都会保存到<strong>My Ideas</strong>分类里面, 所以就有了下面这个工具.</p>

<p><a href="javascript:(function(d, l) {if (!/https:\/\/catch\.com\/m/.test(l.href)) {alert(&#39;only in https://catch.com/m/ is work !&#39;);return;}var notes = d.querySelectorAll(&#39;[class$=-notelist] div[id&#94;=full-]&#39;);for (var i = 0; i < notes.length; i++) {var chk = notes[i].querySelector(&#39;input[type=checkbox]&#39;);if (chk.checked) {notes[i].querySelector(&#39;input[value=delete]&#39;).click();}}}(document, location));">Catch.com批量删除当前选中的笔记</a></p>

<p>这是一个Bookmarklet, 使用方式是在上面这个链接上鼠标右键</p>

<ul>
<li>IE <strong>添加到收藏夹</strong>, 使用了querySelector, 所以需要IE8及更高版本才支持.</li>
<li>Firefox <strong>将此链接加为书签</strong></li>
<li>Chrome 按<strong>Ctrl + Shift + B</strong>显示书签栏后把链接拖到书签栏上</li>
</ul>


<p>然后访问<a href="https://catch.com/">Catch.com</a>, 登录后点<strong>My Ideas</strong>, 先找个笔记点删除, 默认会弹出确认删除, 选中<strong>Do not show me this message again</strong> -> <strong>Delete</strong>.</p>

<p>然后依次选中想删除的笔记, 在收藏夹(IE)/书签菜单(Firefox)/书签栏(Chrome)中点刚刚保存的书签, 就可以看到笔记被一个个的删除.</p>

<!-- more -->


<p>上述Bookmarklet的源码是</p>

<figure class='code'><figcaption><span>bookmarklet.js Catch.com批量删除当前选中的笔记</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">,</span> <span class="nx">l</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="sr">/https:\/\/catch\.com\/m/</span><span class="p">.</span><span class="nx">test</span><span class="p">(</span><span class="nx">l</span><span class="p">.</span><span class="nx">href</span><span class="p">))</span> <span class="p">{</span>
</span><span class='line'>        <span class="nx">alert</span><span class="p">(</span><span class="s1">&#39;only in https://catch.com/m/ is work !&#39;</span><span class="p">);</span>
</span><span class='line'>        <span class="k">return</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">notes</span> <span class="o">=</span> <span class="nx">d</span><span class="p">.</span><span class="nx">querySelectorAll</span><span class="p">(</span><span class="s1">&#39;div[class$=-notelist] div[id^=full-]&#39;</span><span class="p">);</span>
</span><span class='line'>    <span class="k">for</span> <span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">notes</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>        <span class="kd">var</span> <span class="nx">chk</span> <span class="o">=</span> <span class="nx">notes</span><span class="p">[</span><span class="nx">i</span><span class="p">].</span><span class="nx">querySelector</span><span class="p">(</span><span class="s1">&#39;input[type=checkbox]&#39;</span><span class="p">);</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="nx">chk</span><span class="p">.</span><span class="nx">checked</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>            <span class="nx">notes</span><span class="p">[</span><span class="nx">i</span><span class="p">].</span><span class="nx">querySelector</span><span class="p">(</span><span class="s1">&#39;input[value=delete]&#39;</span><span class="p">).</span><span class="nx">click</span><span class="p">();</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}(</span><span class="nb">document</span><span class="p">,</span> <span class="nx">location</span><span class="p">));</span>
</span></code></pre></td></tr></table></div></figure>


<p>这里有一篇关于Bookmarklet和编写的资料, <a href="http://www.ruanyifeng.com/blog/2011/06/a_guide_for_writing_bookmarklet.html">Bookmarklet编写指南</a>.</p>

<p>一个简单的在线Bookmarklet编写网页, <a href="http://ted.mielczarek.org/code/mozilla/bookmarklet.html">Bookmarklet Crunchinator</a>.</p>

      <p><a href="http://netwjx.github.com/blog/2012/07/29/batch-delete-catch-notes-bookmarklet/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Windows命令行和批处理技巧]]></title>
    
      <category term="Bat" />
    
      <category term="Cmd" />
    
      <category term="Command" />
    
      <category term="Shell" />
    
      <category term="Windows" />
    
    <link href="http://netwjx.github.com/blog/2012/07/29/windows-shell-and-bat-skills/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-07-29T18:05:00+08:00</published>
    <updated>2012-07-29T18:05:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/07/29/windows-shell-and-bat-skills</id>
    <content type="html"><![CDATA[<p>有时不方便使用通用编程语言完成一些常见的目标, 会考虑使用命令行, 但是命令行的资料不容易找, 主要因为它有不少是字母和符号, 基本上搜索引擎会忽略这些特殊符号, 所以这里收集一些这方面的技巧.</p>

<p>下面代码示例中<code>rem</code>表示对下一行的注释, 一般下一行以<code>&gt;</code>开始, 表示在命令提示符中输入的, 再下一行表示大概的输出. 整块的代码一般是文件内容, 将会以文件中的形式表现.</p>

<!-- more -->


<h2>更新日志</h2>

<p>最近的修改在列表开始</p>

<ol>
<li>2012-07-29  增加<strong>环境变量扩展增强</strong>特性的说明, 增加<strong>对环境变量使用参数修饰符</strong>, 更详细的说明<strong>延缓环境变量扩展</strong>特性</li>
<li>2012-07-23  <strong>延缓环境变量扩展</strong>特性的说明</li>
<li>2012-06-16  完善输出重定向, for命令的tokens参数说明</li>
<li>2012-05-19  完成最初计划的内容</li>
<li>2012-05-13  初稿, 未完成</li>
</ol>


<h2>打开命令行</h2>

<p>除了<code>Win+R cmd</code>打开外, 还可以在文件窗口中按住<strong>Shift + 鼠标右键</strong>, <strong>在此处打开命令窗口</strong>, 在文件夹上<strong>Shift + 鼠标右键</strong>同样有这个菜单项.</p>

<h2 id="multi-commands">在一行执行多个命令</h2>


<ul>
<li><p><code>command1 &amp; command2</code></p>

<p>先执行command1, 然后是command2, 一般在<code>cmd</code>开启新的命令提示符窗口时比较有用</p>

<pre><code>cmd echo 1 &amp;&amp; echo 2 &amp;&amp; echo 3
</code></pre></li>
<li><p><code>command1 &amp;&amp; command2</code></p>

<p>先执行command1, 如果执行成功(退出码为0), 将会接着执行command2</p></li>
<li><p><code>command1 || command2</code></p>

<p>和<code>&amp;&amp;</code>相反, 如果command1执行失败将会执行command2</p></li>
<li><p><code>(command1 &amp; command2)</code></p>

<p><code>()</code>用于组合嵌入多个命令, 可以在其中使用换行符, 将类似<code>&amp;</code>的效果, 只是写成了多行, 在<code>for</code>和<code>if</code>中很有用</p>

<pre><code>if not defined foo (
    set foo = bar
)
</code></pre></li>
<li><p><code>command1 param1;param2</code></p>

<p>分割命令的参数, 也可以使用符号<code>,</code>.</p></li>
</ul>


<p>如果命令参数中有<code>&amp;</code> <code>|</code> <code>()</code> <code>&gt;</code> <code>&lt;</code> <code>^</code>则需要使用<code>^</code>转义</p>

<pre><code>&gt;echo ^&amp;
&amp;
</code></pre>

<h2>环境变量</h2>

<p>set命令用于基本的查看和设置环境变量</p>

<pre><code>&gt;set
....
USERNAME=netwjx

&gt;set user
USERNAME=netwjx

&gt;set username
USERNAME=netwjx

&gt;set myvar=varvalue
</code></pre>

<p>同样的, 如果变量值包含<code>&amp;</code> <code>|</code> <code>&gt;</code> <code>&lt;</code> <code>^</code>, <a href="#multi-commands">使用<code>^</code>转义符</a></p>

<p>set命令的进一步使用可用来计算数字</p>

<pre><code>&gt;set /p expr=输入时间,单位分钟,例如:5*60+35
输入时间,单位分钟,例如:5*60+35
&gt;3*60+11
&gt;set /a sec=%expr%
191
&gt;echo %sec%
191
</code></pre>

<p>使用环境变量</p>

<pre><code>&gt;echo %myvar%&gt; foo.txt
</code></pre>

<p><code>%myvar%</code>将会被扩展成<code>myvar</code>环境变量的值, 后面的<a href="#pipe-and-redirect">输出重定向</a>将这个值输出到<code>foo.txt</code>.</p>

<p>在执行一行命令时, <code>%myvar%</code>将只扩展一次</p>

<pre><code>set VAR=before
if "%VAR%" == "before" (
    set VAR=after
    if "%VAR%" == "after" @echo If you see this, it worked
)
</code></pre>

<p>因为<code>if</code>和后面括号中的多行命令只属于一个<code>if</code>命令, 括号内的<code>%VAR%</code>在指定外面的<code>if</code>命令时已经被扩展了, 所以括号内的<code>if</code>命令实际是</p>

<pre><code>if "before" == "after" @echo If you see this, it worked
</code></pre>

<p>将始终不会输出, 类似的, 在<code>for</code>命令和使用括号的组合命令中同样会有上述现象.</p>

<p>如果要使用<code>VAR</code>被修改后的值, 则需要使用<strong>延缓环境变量扩展</strong>, 下列命令用于开启<strong>延缓环境变量扩展</strong></p>

<pre><code>setlocal enabledelayedexpansion
</code></pre>

<p>然后在延缓环境变量扩展的地方将<code>%</code>替换为<code>!</code>, 如下</p>

<pre><code>set VAR=before
if "%VAR%" == "before" (
    set VAR=after
    if "!VAR!" == "after" @echo If you see this, it worked
)
</code></pre>

<p>要关闭<strong>延缓环境变量扩展</strong>特性除了</p>

<pre><code>setlocal disabledelayedexpansion
</code></pre>

<p>还可以</p>

<pre><code>endlocal
</code></pre>

<p>只有<code>for</code>命令的循环变量是个特例, 每次执行循环都会被扩展为具体的值.</p>

<h3>环境变量扩展增强</h3>

<p>字符串替换</p>

<pre><code>&gt;set foo=abcdef
&gt;echo %foo:bcd=_%
a_ef
&gt;echo %foo:bcd=%
aef
</code></pre>

<p>字符串截取</p>

<pre><code>&gt;echo %foo:~1%
bcdef
&gt;echo %foo:~-1%
f
&gt;echo %foo:~1,2%
bc
&gt;echo %foo:~-3,2%
de
&gt;echo %foo:~1,-2%
bcd
</code></pre>

<p>输出如上所示, 使用2个数字时, 第2个是截取长度, 负数表示截取到字符串结尾还剩指定个字符, 第2个是负数时表示截取到离结尾还有指定个字符.</p>

<h3>　检测环境变量是否有定义</h3>

<pre><code>if not defined foo (
    echo need %foo%
)
</code></pre>

<h3>获取一个命令行的输出到环境变量</h3>

<p>执行<code>set</code>命令, 并将每行的内容作为循环变量%i输出</p>

<pre><code>&gt;for /f %i in ('set') do @echo %i
...
windir=C:\windows
</code></pre>

<p>有时可能不方便使用单引号<code>'</code>, 可以使用反引号<code>`</code></p>

<pre><code>&gt;for /f "usebackq" %i in (`set`) do @echo %i
...
windir=C:\windows
</code></pre>

<p>更多关于<a href="#for-command"><code>for</code>命令</a></p>

<h3>对环境变量使用参数修饰符</h3>

<p>环境变量扩展增强没有能获取文件名, 文件路径等等的功能, 也不能直接使用<a href="#batch-param-modifiers">参数修饰符</a>来实现获取文件名等目的, 但是可以配合上一段介绍的来实现</p>

<figure class='code'><figcaption><span>foo.bat</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bat'><span class='line'><span class="p">@</span><span class="k">echo</span> <span class="nv">%~nx1</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>foo.bat</code>用于输出第一个参数的文件名部分, 下面是获取环境变量值的文件名部分</p>

<pre><code>&gt;set foo=%cd%\bar.foo
&gt;for /f %i in ('foo.bat %foo%') do set foo=%i
&gt;echo %foo%
bar.foo
</code></pre>

<h3 id="built-in-var">内建环境变量</h3>


<p>内建环境变量是在执行环境变量扩展的时候最先检查的, 其中有一些比较有用的</p>

<ul>
<li><p><code>%ALLUSERSPROFILE%</code></p>

<p>返回<strong>所有用户</strong>的数据目录, 对于Win7, 它是<code>C:\ProgramData</code></p></li>
<li><p><code>%APPDATA%</code></p>

<p>返回当前用户的应用程序数据存储目录</p></li>
<li><p><code>%CD%</code></p>

<p>返回当前活动目录</p></li>
<li><p><code>%CMDCMDLINE%</code></p>

<p>返回当前命令行解释器的路径, 结果是被双引号<code>"</code>括起来的</p></li>
<li><p><code>%CMDEXTVERSION%</code></p>

<p>返回当前命令行处理扩展的版本号</p></li>
<li><p><code>%COMPUTERNAME%</code></p>

<p>返回当前计算机名称</p></li>
<li><p><code>%COMSPEC%</code></p>

<p>和<code>%CMDCMDLINE%</code>基本一样, 只是结果不是被双引号<code>"</code>括起来的</p></li>
<li><p><code>%DATE%</code></p>

<p>返回当前的日期, 格式和<code>date /t</code>命令相同, 这个还和系统的区域和语言设置有关, 实际处理起来通用性不是很好.</p></li>
<li><p><code>%ERRORLEVEL%</code></p>

<p>返回最近一次命令的执行结果, 一般非0表示发生了错误.</p></li>
<li><p><code>%HOMEDRIVE%</code></p>

<p>返回用户目录所在的盘符, 格式如<code>C:</code></p></li>
<li><p><code>%HOMEPATH%</code></p>

<p>返回用户目录的路径, 不包括盘符, 格式如<code>\Users\netwjx</code></p></li>
<li><p><code>%HOMESHARE%</code>, <code>%LOGONSEVER%</code></p>

<p>文档中有, 但是我没测试出来有效值</p></li>
<li><p><code>%NUMBER_OF_PROCESSORS%</code></p>

<p>返回系统的处理器数量</p></li>
<li><p><code>%OS%</code></p>

<p>返回操作系统名称, 基本上Win2000以后都是<code>Windows_NT</code></p></li>
<li><p><code>%PATH%</code></p>

<p>可执行文件的搜索路径</p></li>
<li><p><code>%PATHEXT%</code></p>

<p>可执行文件后缀</p></li>
<li><p><code>%PROCESSOR_ARCHITECTURE%</code></p>

<p>返回处理器架构, <code>x86</code> <code>IA64</code></p></li>
<li><p><code>%PROCESSOR_IDENTIFIER%</code></p>

<p>返回处理器描述</p></li>
<li><p><code>%PROCESSOR_LEVEL%</code></p>

<p>返回处理器的系列编号</p></li>
<li><p><code>%PROCESSOR_REVISION%</code></p>

<p>返回处理器的修订编号</p></li>
<li><p><code>%PROMPT%</code></p>

<p>返回当前命令提示符窗口的提示符, 可以通过<code>prompt</code>命令修改</p></li>
<li><p><code>%RANDOM%</code></p>

<p>返回一个随机数字, 范围在0到32767之间</p></li>
<li><p><code>%SYSTEMDRIVE%</code></p>

<p>返回操作系统所在的盘符</p></li>
<li><p><code>%SYSTEMROOT%</code></p>

<p>返回操作系统的根路径, 包含盘符</p></li>
<li><p><code>%TEMP%</code> <code>%TMP%</code></p>

<p>返回当前用户的临时目录</p></li>
<li><p><code>%TIME%</code></p>

<p>返回当前的时间, 格式类似<code>time /t</code>命令返回的, 这个还和系统的区域和语言设置有关, 实际处理起来通用性不是很好.</p></li>
<li><p><code>%USERDOMAIN%</code></p>

<p>返回当前用户所在的域, 或工作组名</p></li>
<li><p><code>%USERNAME%</code></p>

<p>返回当前登录的用户</p></li>
<li><p><code>%USERPROFILE%</code></p>

<p>返回当前用户目录</p></li>
<li><p><code>%WINDIR%</code></p>

<p>返回当前操作系统的路径, 类似<code>%SYSTEMROOT%</code></p></li>
</ul>


<p>在内建环境变量中没有指定名称的变量后, 会依次从下面的位置查找</p>

<ul>
<li>系统变量</li>
<li>当前用户变量</li>
<li>Autoexec.bat 中定义的变量</li>
<li>登录脚本中定义的变量(如果有提供登录脚本)</li>
<li>当前命令提示符窗口或批处理中定义的变量</li>
</ul>


<h2 id="pipe-and-redirect">管道和重定向</h2>


<p>一个常见的场景, 查找使用特定网络端口的应用程序</p>

<pre><code>&gt;netstat -ano | find ":4000"
  UDP    0.0.0.0:4000           *:*                                    3876
</code></pre>

<p>其中最右边的<strong>3876</strong>是应用程序的进程ID, 而<code>|</code>是管道操作符.</p>

<p>管道操作将会把左边命令的输出, 作为右边命令的输入. 上面例子中<code>netstat -ano</code>将会输出本机的网络连接和对应的进程, <code>find ":4000"</code>则是在输入中找包含字符串<code>:4000</code>的行.</p>

<p>重定向和管道也很相似, 典型的用途是将一个命令的输出保存为文本文件.</p>

<pre><code>&gt;netstat -ano &gt; foo.txt
</code></pre>

<p>可以在当前目录中看到<code>foo.txt</code>, 其内容是<code>netstat -ano</code>命令的输出.</p>

<p>可以和管道操作结合, 将查出来的本地网络连接信息保存到文件</p>

<pre><code>?netstat -ano | find ":4000" &gt; foo.txt
</code></pre>

<p><code>&gt;</code>会始终覆盖原来的文件, 使用<code>&gt;&gt;</code>则会在文件结尾添加</p>

<pre><code>&gt;netstat -ano &gt;&gt; foo.txt
</code></pre>

<p>随着反复的运行, <code>foo.txt</code>的结尾会一直增加.</p>

<p>有一个特殊的管道目标叫<code>clip</code>, 可以用来操作系统剪贴板</p>

<p>还有一个特殊的输出设备叫<code>nul</code>, 它不会产生任何文件, 效果就像执行了命令, 但是不回显命令的输出, 在<a href="#sleep-ping">延迟 Sleep</a>有这个例子.</p>

<p>上述可以将命令正常执行的结果重定向到文件, 但是错误信息仍旧会输出到命令提示符窗口(<strong>标准输出</strong>)</p>

<pre><code>&gt;netstat -x &gt; nul

显示协议统计和当前 TCP/IP 网络连接。

NETSTAT [-a] [-b] [-e] [-f] [-n] [-o] [-p proto] [-r] [-s] [-t] [interval]
....
</code></pre>

<p>默认错误信息输出的目标叫<strong>标准错误输出</strong>, 仍旧可以让其不显示</p>

<pre><code>&gt;netstat -x &gt; nul 2&gt;&amp;1
</code></pre>

<p>其中<code>&gt;&amp;</code>也是重定向操作符, 需要配合<code>&gt;</code> <code>&gt;&gt;</code>使用, 2<strong>标准错误输出</strong>, 1表示<strong>标准输出</strong>.</p>

<p><code>&gt; nul 2&gt;&amp;1</code>表示在将标准输出重定向到<code>nul</code>的同时将<strong>标准错误输出</strong>重定向到<strong>标准输出</strong>, 这样就完成了完全隐藏命令行输出的正常信息和错误信息.</p>

<p>关于重定向的数字下面是完整的参考</p>

<ul>
<li><p><code>0</code> STDIN</p>

<p>标准输入, 键盘输入</p></li>
<li><p><code>1</code> STDOUT</p>

<p>标准输出, 命令提示符窗口输出</p></li>
<li><p><code>2</code> STDERR</p>

<p>标准错误输出, 命令提示符窗口输出</p></li>
<li><p><code>3-9</code> UNDEFINED</p>

<p>未定义, 参考文档中描述其在特定应用程序中会使用, 但是没找到具体使用的例子, 所以我目前也不清楚具体使用是怎么样的.</p></li>
</ul>


<p>如果仅想取得命令的错误信息可以这样</p>

<pre><code>&gt;netstat -x 2&gt; foo.txt
</code></pre>

<p>在<a href="#ref-links">参考链接</a>中<strong>Using filters</strong>有管道和重定向混合使用示例.</p>

<h3>输入重定向</h3>

<p>上面的重定向都是输出重定向, 这里开始介绍输入重定向.</p>

<p>在介绍管道的时候使用了<code>find</code>命令, 它会在<strong>标准输入</strong>中查找指定字符串, 除了使用管道外, 还可以使用输入重定向</p>

<pre><code>&gt; netstat -ano &gt; foo.txt
&gt; find ":4000" &lt; foo.txt
  UDP    0.0.0.0:4000           *:*                                    3876
</code></pre>

<p>这会使用中间文件<code>foo.txt</code></p>

<p>而<strong>标准输入</strong>实际是个特殊的输入设备<code>con</code></p>

<pre><code>&gt;find "foo" &lt; con
</code></pre>

<p>等价于</p>

<pre><code>&gt;find "foo"
</code></pre>

<p>每当输入包含foo的字符串并回车后, 会立即回显一次.</p>

<p>比如使用用户输入来创建文件</p>

<pre><code>&gt;copy con foo.txt
&gt;bar
&gt;hello world
&gt;^Z
已复制         1 个文件。
</code></pre>

<p>其中<code>^Z</code>表示<code>Ctrl+Z</code>, 输入结束.</p>

<p>除了<code>find</code>会使用标准输入外, 常见的还有下列命令也会使用标准输入</p>

<ul>
<li><p><code>more</code></p>

<p>用于逐屏显示标准输入</p></li>
<li><p><code>sort</code></p>

<p>按行排序标准输入</p></li>
</ul>


<p>还有一个<code>&lt;&amp;</code>重定向操作符, 文档中的解释是会从右边的设备读取输入, 并从左边输出, 我实在想不出来这具体是在什么场景下使用, 所以也不知道如何介绍.</p>

<p>在<a href="#ref-links">参考链接</a>中<strong>Using filters</strong>有管道和重定向混合使用示例.</p>

<h2>在多个目录间切换工作目录</h2>

<pre><code>&gt;pushd d:\foo
</code></pre>

<p>将当前工作目录保存后, 立即将工作目录切换到<code>d:\foo</code>.</p>

<pre><code>&gt;popd
</code></pre>

<p>将当前工作目录切换到最近一次<code>pushd</code>时所在的工作目录.</p>

<p>很典型的一个栈stack结构, push和pop. stack为空时pop将没有任何效果.</p>

<p>比<code>cd</code>命令好用的是<code>cd</code>在跨盘符的时候还需要手工切换盘符.</p>

<h2 id="sleep-ping">延迟 Sleep</h2>


<pre><code>&gt;ping -n 4 -w 1000 127.0.0.1 &gt; nul
</code></pre>

<p>这将会延迟3秒, 其中<code>-n</code>参数表示的是重复ping的次数, 将决定最终的延迟的时间.</p>

<p>因为<code>ping 127.0.0.1</code>会立即返回, 所以实际延迟的时间是 <code>-n</code>参数 - 1 的秒数.</p>

<h2>echo特殊字符</h2>

<p>一般使用<code>%</code>作为转义字符</p>

<pre><code>&gt;echo %username%
netwjx

&gt;echo %%username%
%netwjx
</code></pre>

<p>但是<code>&amp;</code> <code>|</code>需要使用<code>^</code>转义, 这个在上面<a href="#multi-commands">在一行执行多个命令</a>已经有描述</p>

<pre><code>&gt;echo ping -n 3 127.0.0.1^&gt;nul
ping -n 3 127.0.0.1^&gt;nul

&gt;echo netstat -ano^|find ":80"
netstat -ano|find ":80"
</code></pre>

<p>P.S. Linux下echo转义符号是<code>\</code></p>

<p>空行, 在echo紧跟<code>.</code></p>

<pre><code>&gt;echo.
</code></pre>

<p>使用echo和输出重定向可以产生文本文件, 可以用来产生脚本批处理等.</p>

<h2 id="for-command">for命令</h2>


<p>如果在批处理文件中使用<code>for</code>则需要将<code>%i</code>写为<code>%%i</code>, 象下面这样</p>

<pre><code>&gt;for /f %%i in ('set') do @echo %%i
</code></pre>

<p>使用<code>for</code>命令的循环变量时, 可以使用类似批处理哪样的<a href="#batch-param-modifiers">参数修饰符</a></p>

<pre><code>&gt;for %I in (*.log) do @echo %~nxI
log.log
....
</code></pre>

<p>下面例子将使用在命令提示符窗口中的写法, 而不是批处理文件中的写法.</p>

<p><code>for</code>命令一般是用于处理多个文件, 文件的多行, 也可以用于处理另外一个命令的输出. 下面是显示<code>*.log</code>文件的例子</p>

<pre><code>&gt;for %i in (*.log) do @echo %i
C:\Log\log.log
....
</code></pre>

<p>匹配目录</p>

<pre><code>&gt;for /d %i in (.*) do @echo %i
.svn
....
</code></pre>

<p>枚举当前目录所有<strong>.txt</strong>文件</p>

<pre><code>&gt;for /r %i in (*.txt) do @echo %i
C:\foo.txt
C:\bar\foo.txt
....
</code></pre>

<p>枚举所有名字以<code>.</code>开始目录, 主要是指<code>.svn .hg</code>这些</p>

<pre><code>&gt;for /d /r %i in (.*) do @echo %i
C:\Users\Netwjx\.ssh
....
</code></pre>

<p>数字的循环变量</p>

<pre><code>&gt;for /l %i in (0, 1, 5) do @echo %i
0
1
2
3
4
5
</code></pre>

<p>注意初始值<code>0</code>和最大值<code>5</code>, 都会包含在内, 也就是这个循环将执行<strong>6次</strong>.</p>

<p>显示文件中的每行, 从开始到第一个空格到<code>tab</code>之间的字符串</p>

<pre><code>&gt;for /f %i in (mylog.log) do @echo %i
15:07:50.947:
15:07:50.947:
15:07:50.947:
....
</code></pre>

<p><code>/f</code>还可以使用一些参数, 下面将会把<code>path</code>环境变量的第一个<code>;</code>之前的内容输出</p>

<pre><code>&gt;for /f "usebackq delims=;= tokens=2" %i in (`set path`) do @echo %i
C:\Ruby\bin
.COM
</code></pre>

<p>详细参数如下, 空格分割</p>

<ul>
<li><p><code>eol=c</code></p>

<p>指定行注释字符, 以<code>c</code>字符开始的行将被忽略</p></li>
<li><p><code>skip=n</code></p>

<p>指定忽略开始的n行</p></li>
<li><p><code>delims=xxx</code></p>

<p>指定分割字符, 可以指定多个, 配合<code>tokens</code>参数使用, 类似传统编程语言中<code>split</code>函数的分割字符</p></li>
<li><p><code>tokens=x,y,m-n</code></p>

<p>将<code>x y</code>以及<code>m-n</code>之间的字符串返回给循环变量, 下标从1开始, 如果有<code>y*</code>, 则表示从第<code>y</code>个往后的所有都返回, 下一段有详细的使用示例.</p></li>
<li><p><code>usebackq</code></p>

<p>表示使用<code>`</code>符号表示一个命令行, 而不是传统的<code>'</code>符号</p></li>
</ul>


<p>配合自定义的命令行程序, 可以自行处理命令提示符窗口的输入和输出, 以及弥补<a href="#built-in-var">内建环境变量</a>中<code>%date%</code>和<code>%time%</code>格式不固定的问题.</p>

<h3>使用for的tokens参数</h3>

<p><code>tokens</code>参数可以用来提取命令行或文件的返回值, 最基本的如:</p>

<pre><code>&gt;for /f "tokens=2" %i in ("1 2 3 4 5 6 7 8") do @echo %i
2
</code></pre>

<p><code>tokens</code>可以指定多个, 会隐式的将对应索引的值赋给按照字母顺序命名的循环变量:</p>

<pre><code>&gt;for /f "tokens=2,4,6-8" %i in ("1 2 3 4 5 6 7 8") do @echo %i %j %k %l %m %n
2 4 6 7 8 %n
</code></pre>

<p>可以看到<code>tokens=2,4,6-8</code>分别会给<code>%i %j %k %l %m</code>赋值, 而<code>%n</code>则原样显示.</p>

<p>还有<code>y*</code>的例子</p>

<pre><code>&gt;for /f "tokens=2*" %i in ("1 2 3 4 5 6 7 8") do @echo %j %k
3 4 5 6 7 8 %k
&gt;for /f "tokens=2*" %i in ("1 2 3 4 5 6 7 8") do @echo %i %j %k
2 3 4 5 6 7 8 %k
</code></pre>

<p><code>2*</code>将会把从第2个开始(不包括)往后所有的都赋给了<code>%j</code></p>

<h3>查询注册表</h3>

<p>这是个使用<code>for</code>执行命令并取得命令执行结果到变量的典范.</p>

<pre><code>&gt;for /f "tokens=3 skip=2" %i in ('reg query HKEY_CLASSES_ROOT\txtfile\shell\open\command /ve') do @echo %i
C:\windows\notepad.exe
</code></pre>

<p>其中<code>reg query</code>命令是读取注册表, 返回的内容类似下面</p>

<pre><code>HKEY_CLASSES_ROOT\txtfile\shell\open\command
(默认)    REG_SZ    C:\windows\notepad.exe %1
</code></pre>

<p>因为其开始会有一个空行, 所以<code>/f</code>参数有<code>skip=2</code></p>

<h2>批处理文件</h2>

<p>批处理文件可以是<code>bat</code>后缀, 也可以是<code>cmd</code>后缀.</p>

<p>批处理文件需要保存为ANSI格式, 对于中文Windows是GBK, 不建议用<strong>UTF-8</strong>, 也不建议有<strong>BOM</strong></p>

<h3>不回显输入的命令</h3>

<p>以<code>@</code>开始的命令将不会回显</p>

<pre><code>&gt;@echo hello
</code></pre>

<p>同时可以使用<code>echo off</code>关闭回显, 如果两者结合的话就是</p>

<pre><code>&gt;@echo off
</code></pre>

<p>一般在批处理文件第一行, 可以使所有命令都不回显.</p>

<p>一般调试时可能会需要在某行之后回显, 可以再<code>echo on</code>打开回显.</p>

<h3>批处理参数</h3>

<p>使用<code>%1</code>到<code>%9</code>获取, 其中<code>%0</code>是当前批处理文件的路径.</p>

<figure class='code'><figcaption><span>Foo\test.bat</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='bat'><span class='line'><span class="p">@</span><span class="k">echo</span> <span class="k">off</span>
</span><span class='line'><span class="k">echo</span> <span class="nv">%0</span>
</span><span class='line'><span class="k">echo</span> <span class="nv">%1</span>
</span><span class='line'><span class="k">echo</span> <span class="nv">%2</span>
</span><span class='line'><span class="k">echo</span> <span class="nv">%3</span>
</span><span class='line'><span class="k">echo</span> <span class="nv">%4</span>
</span></code></pre></td></tr></table></div></figure>


<p>使用示例</p>

<pre><code>&gt;Foo\test.bat 1 2 3 4
Foo\test.bat
1
2
3
4
</code></pre>

<p><code>%0</code> 可用来删除脚本自身, 不过这行必须放结尾, 因为一旦删除就会脚本执行出错.</p>

<p>可以用<code>if</code>检测参数是否提供</p>

<pre><code>&gt;if not "%4"=="" echo %4
</code></pre>

<p>1-9不够用可以使用<code>shift</code></p>

<pre><code>&gt;rem 将参数队列弹出一个, 这将会使旧的%1值被移除, 旧的%2变成%1, 旧的%3变成%2
&gt;shift
&gt;rem 和上面的类似, 只是一次弹出2个, 旧的%1 %2被移除, 旧的%3 %4 %5将变成%1 %2 %3
&gt;shift /2
</code></pre>

<p>如果仅需要将当前的参数原封不动的传递给别的命令行程序, 使用<code>%*</code></p>

<pre><code>&gt;call foo.bat %*
</code></pre>

<p><code>%*</code>将包含原始的<code>%1-%n</code>的参数, 不受<code>shift</code>影响, <code>%*</code><strong>不能使用</strong><a href="#batch-param-modifiers">参数修饰符</a></p>

<h3 id="batch-param-modifiers">参数修饰符</h3>


<p>参数修饰可以将指定参数扩展为文件或目录名, 使用当前的盘符和目录信息.</p>

<pre><code>&gt;rem 把%1参数扩展为包含盘符和路径的字符串
&gt;echo %~dp1
</code></pre>

<p>完整的修饰符列表</p>

<ul>
<li><p><code>%~1</code></p>

<p>扩展%1参数并移除参数两边的双引号<code>"</code></p></li>
<li><p><code>%~f1</code></p>

<p>扩展%1参数为完整的路径</p></li>
<li><p><code>%~d1</code></p>

<p>扩展%1参数为盘符</p></li>
<li><p><code>%~p1</code></p>

<p>扩展%1参数为路径, 不包括盘符和文件名</p></li>
<li><p><code>%~n1</code></p>

<p>扩展%1参数为文件名, 不包括扩展名</p></li>
<li><p><code>%~x1</code></p>

<p>扩展%1参数为扩展名, 包含点</p></li>
<li><p><code>%~s1</code></p>

<p>扩展%1参数为仅包含短名称目录名的路径</p></li>
<li><p><code>%~a1</code></p>

<p>扩展%1参数为文件属性, 格式如<code>--a------</code>, 其它标志位的字母可以自行测试</p></li>
<li><p><code>%~t1</code></p>

<p>扩展%1参数为文件修改时间, 格式如<code>2011/07/31 17:04</code></p></li>
<li><p><code>%~z1</code></p>

<p>扩展%1参数为文件大小的数字, 单位字节</p></li>
<li><p><code>%~$PATH:1</code></p>

<p>在PATH环境变量中指定的所有目录中(分号<code>;</code>分割的目录路径)搜索名为%1的文件名, 返回第一个发现的文件路径, 如果环境变量不存在或者找不到文件, 将返回空白的字符串</p></li>
</ul>


<p>上述的修饰符和多重叠加</p>

<pre><code>&gt;rem 搜索PATH环境变量的路径中名为%1的文件, 并返回第一个找到的文件的盘符和路径
&gt;echo %~dp$PATH:1
</code></pre>

<h3>调用其它批处理</h3>

<p>一般是可以直接<code>other.bat</code>, 但是可能会发生一些奇怪的现象, 如后续的命令未执行之类的, 所以</p>

<pre><code>&gt;call other.bat arg1 arg2
</code></pre>

<h3>goto跳转到标记</h3>

<p>和传统编程语言中的用法一样</p>

<pre><code>if "%1"=="" goto help

echo running
....
goto end

:help
echo help message
goto :EOF

:end
echo completed
</code></pre>

<p>标记使用<code>:label</code>来定义, 然后是<code>goto label</code>跳转.</p>

<p>有一个特殊标记<code>:EOF</code>表示结束, 使用时是<code>goto :EOF</code>.</p>

<h2 id="ref-links">参考链接</h2>


<ul>
<li><p><a href="http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/batch.mspx?mfr=true">Using batch files</a></p></li>
<li><p><a href="http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/percent.mspx">Using batch parameters</a></p></li>
<li><p><a href="http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx?mfr=true">Using command redirection operators</a></p></li>
<li><p><a href="http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/filters.mspx?mfr=true">Using filters</a></p></li>
<li><p><a href="http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/cmd.mspx">Cmd</a></p></li>
<li><p><a href="http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/ntcmds_shelloverview.mspx">Command shell overview</a></p></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/07/29/windows-shell-and-bat-skills/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[移动电源备忘]]></title>
    
      <category term="Memo" />
    
      <category term="Portable" />
    
      <category term="Power" />
    
    <link href="http://netwjx.github.com/blog/2012/07/19/portable-power-memo/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-07-19T21:17:00+08:00</published>
    <updated>2012-07-19T21:17:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/07/19/portable-power-memo</id>
    <content type="html"><![CDATA[<p>买了移动电源之后就计划写点关于移动电源的事, 翻看todo的时候才想起来该把这个补上.</p>

<p>因为有2个手机和NDS, 手机一个是之前提过的黑莓8310, 另外一个是小米手机, 而平时玩小米手机时间挺多, 再加上临近过年, 要回家, 路上肯定会玩手机, 很可能电力不足.</p>

<p>在淘宝上搜移动电源的话, 品牌主要是<a href="http://www.yoobao.com/">羽博</a>和<a href="http://www.pisen.com.cn/">品胜</a>的, 外观时尚, 体积和电容量给设备充一次是没问题.</p>

<p>在电玩网站发现还有<a href="http://www.powerunite.com.cn/">联力众(续航大师)</a>, <a href="http://www.sino-ele.cn/">西诺电子</a>, <a href="http://www.tposchina.com/">TPOS</a>, <a href="http://www.fanmei.net/">微发</a>, 因为是给电玩充电的, 所以电容量都比较大, 相应体积重量也提高了.</p>

<p>另外还有淘宝聚划算和淘宝试用中心还有一些我感觉很冷门的品牌, 如力杰, 还是做时尚外观, 电容量一般充一次没问题.</p>

<p>移动电源目前都是锂电池, 因为锂电池有可能发生爆炸, 所以我专门找了些关于锂电池拆机的评测, 主要在电玩网站上有, 下面是我根据回忆整理的一些信息.</p>

<!-- more -->


<h2>锂电池和聚合物电池</h2>

<p><img class="left" src="http://image.made-in-china.com/2f0j00QMbtBfNRaIqk/Li-ion-Battery-Cylinder-18650-18490-17650-14500-.jpg" width="260" title="18650锂电芯" alt="18650锂电芯"></p>

<p><strong>锂电池</strong> 指的是传统的锂离子电池, 一般移动电源中使用的锂电池是18650圆柱形锂电芯, 18650的意思是18mm直径, 65mm高度的圆柱形.</p>

<p>羽博和品胜的移动电源使用的是这个电芯, 多数笔记本也使用的是这样的电池.</p>

<p>在高温中工作是一定会爆炸的, 漏液什么的现在应该几乎见不到了.</p>

<hr />

<p><img class="right" src="http://i05.c.aliimg.com/img/ibank/2011/502/186/449681205_886818038.jpg" width="260" title="ATL聚合物电芯" alt="ATL聚合物电芯"></p>

<p><strong>聚合物电池</strong> 指的是聚合物锂离子电池, 还是锂电池, 只是一般聚合物电池的特性可以做成片状, 现在新的手机哪些高容量电池都是这种的. 而且聚合物电池不会爆炸,</p>

<p>电玩网站提到的移动电源基本都使用的是ATL电芯.</p>

<p>我看过一个视频是把电池放下面点火的铁盘上加热, 最后膨胀, 冒烟, 但是没有爆炸. 对照视频中的锂离子电池在加热到一定程度就爆炸, 电池残骸飞出去了.</p>

<h2>移动电源的电容量</h2>

<p>电池的电容量一般是mhA标注, 1000mhA的意思是以1000mA电流, 电池的额定电压放电, 能持续放电1小时.</p>

<p>考虑电容量不能简单的除以现在电池的容量, 应按照放电时间来计算是比较靠谱的.</p>

<p>比如我的小米手机充电器的放电是5V 1A, 充满1930mhA的小米手机电池, 需要2小时40分钟左右.</p>

<p>我购买的微发移动电源, 电容量是8800mhA, 因为锂电池的放电电压不足5V, 所以会有升压电路. 如果要提供5V 1A的输出, 输出电流可能在1300mhA左右, 因为锂电池会随着持续放电而电压降低, 一般是从4.2V到3.2V, 低于3V会使电芯受损, 所以一般都有过放电保护, 越往后需要的输出电流越多.</p>

<p>使用1300mhA计算, 那么8800mhA以5V 1A输出能持续放电6小时46分钟左右, 用总放电时间除以充满一次点需要的时间, 结果就是2次半左右, 以我实际使用的测试情况来计算也是如此.</p>

<blockquote><p>简单估算方法: 充满1000mhA的电池, 移动电源需要消耗大概1800mhA的电量.</p></blockquote>


<h2>移动电源的输出效率</h2>

<p>简单的可以理解为转换效率高能对电池利用的更多, 比如微发8800mhA电源在1A的输出下可以达到97%的输出效率. 一般在90%以上为佳.</p>

<p>这个参数一般看不到, 最好是看看评测, 一般移动电源有一个最佳的放电电流, 能够得到十分高的转换效率, 在这种情况下工作对移动电源利用的最多.</p>

<p>和这个参数关联最大的是移动电源的电路用料, 这个我不是很熟悉, 就是看到微发的拆解中提到钽电容, 可以作为参考.</p>

<h2>接口, 线材, 设计</h2>

<p><img class="right" src="http://image.shutterstock.com/display_pic_with_logo/427411/427411,1277141040,1/stock-photo-usb-mini-usb-and-micro-usb-cable-55662274.jpg" width="300" title="USB, Mini-USB, Micro-USB" alt="USB, Mini-USB, Micro-USB"></p>

<p>移动电源上的接口最好是标准USB口, 大, 牢固, 也很耐用. 一般还有独立的充电接口, 会为了和放电接口区分开而使用不同的接口, 我觉得最好是其它USB接口, 这样比较通用, 比如目前流行的MicroUSB, 以及以前挺流行的MiniUSB. MicroUSB更好点, 它更牢固.</p>

<p>充电线一般有1拖2 + N种转接头, 或者是1拖2固定接口, 我建议用固定接口, 因为转接头可能会有接触不良, 而成为最薄弱的环节.</p>

<p>再者现在很多设备充电线都是USB口, 移动电源的充电线不一定总是能用到, 针对没有USB口充电线的设备买个对应的充电线就行了.</p>

<p>设计其实没什么好说的, 高亮LED用于照明, 接口尽量设计为方便放包中的同时给设备充电为好.</p>

<h2>总结</h2>

<p>以前看的时候羽博和品胜还没有明显能确定是聚合物电芯的移动电源, 现在应该都有了吧, 这个得找具体的评测.</p>

<p>当时我购买的是微发8800mhA的, 但是并不推荐现在仍旧购买这个, 因为现在已经有超过10000mhA的移动电源了.</p>

<p>电容量篇说过如何评估移动电源能充电的次数, 一般越大越重, 体积也越大, 选购应先确定一个理想的电容量范围, 然后就是自己决定外观接口设计, 品牌, 电芯类型这些东西.</p>

<p>电池这个东西是一分钱一分货, 只要不是特别去挑便宜, 一般不会被骗到.</p>

<p>虽然聚合物电池不会爆炸, 但是高温环境电池还是会膨胀, 也会影响到电器性能的, 所以应该减少和避免移动电源和电子设备在高温环境中.</p>

<h3>附</h3>

<p>在找这些资料的时候, 还发现有人自己做移动电源, 用的都是上乘的材料, 主要是外壳看起来比较粗糙, 后来的好很多, 有开淘宝店卖自己做的电源, 有兴趣的可以看看. <a href="http://shop67813373.taobao.com/">小于电源</a></p>

<p>文中图片来自搜索引擎找到的, 懒得自己处理, 上面的水印还在, 不是我可以给做广告啊.</p>

      <p><a href="http://netwjx.github.com/blog/2012/07/19/portable-power-memo/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[服装布料常识]]></title>
    
      <category term="Live" />
    
      <category term="Memo" />
    
    <link href="http://netwjx.github.com/blog/2012/07/15/garment-fabric-knowledge/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-07-15T11:39:00+08:00</published>
    <updated>2012-07-15T11:39:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/07/15/garment-fabric-knowledge</id>
    <content type="html"><![CDATA[<p>平时买衣服发现有很多的布料种类, 还有很多别名, 各自的特性, 舒适也总搞不清, 这里整理一些我所知道的一些布料和特性.</p>

<h2>棉</h2>

<p>棉(Cotton) 是天然植物纤维, 日常使用的最多的一种, 柔软, 穿着舒适, 吸湿, 透气, 弹性几乎没有, 容易折皱, 需要熨烫才能弄平, 可以机洗, 必然会缩水.</p>

<p>一般洗多次之后表面会起毛, 根据材料和织法, 轻重程度不同.</p>

<p>容易染色, 白色的不能和褪色的衣物一起洗, 有些衣服图案使用的印染技术不好图案会花, 发粘, 我说的是在以纯买的一件.</p>

<!-- more -->


<p>纯棉(Pure Cotton) 一般还会和一些别的纤维混纺, 以拥有两种纤维的特性, 多数是合成纤维.</p>

<h3>莱卡/氨纶/聚氨酯 + 棉</h3>

<p>莱卡(Lycra) 是杜邦公司的注册商标, 也就是只有杜邦授权的才能叫莱卡, 否则都叫氨纶(Spandex).</p>

<p>加了氨纶的服装会弹性十分好, 能防止缩水, 也不会折皱, 吸水后比纯棉干的快, 洗多次后表面起毛比纯棉少很多.</p>

<p>其它特性和纯棉一致. 一般T恤中氨纶会占1%-10%.</p>

<h3>涤纶/聚酯纤维/的确凉 + 棉</h3>

<p>涤纶(Terylene) 聚酯纤维(Polyester Fiber)算是第一大合成纤维, 价格可能比氨纶的便宜点.</p>

<p>弹性比纯棉好, 但是比氨纶的差, 和纯棉混纺会有轻微缩水, 折皱情况和涤纶的含量有关, 越多折皱越不容易, 但是涤纶自身透气吸湿较差. 平时穿着不是很容易折皱, 洗多次后表面起毛少.</p>

<p>其它特性和纯棉一致. 一般T恤中涤纶会占15%左右.</p>

<h3>锦纶/尼龙/聚酰胺纤维 + 棉</h3>

<p>尼龙(Nylon) 聚酰胺纤维(Polyamide Fibre) 是最早的合成纤维, 有光泽, 手感顺滑, 耐磨, 会折皱, 容易产生静电.</p>

<p>一般会用于服装的面料, 比如羽绒服. 或者是需要耐磨的, 比如袜子.</p>

<p>靠近火焰会缩, 燃烧有毛发味, 挺多把这个当羊毛材料用.</p>

<h3>麻/亚麻 + 棉</h3>

<p>亚麻(Flax) 是天然植物纤维, 透气效果极好, 吸湿, 吸水后干的十分快, 纯亚麻的穿着会有刺痒, 一般都是和纯棉混纺, 麻含量从35%到60%都有.</p>

<p>一般亚麻混纺的织法都很粗犷, 有薄而不透的效果.</p>

<p>不耐磨, 所以一般是不能机洗的, 只是现在可以有洗衣袋装起来洗, 避免扭到一起. 手洗的话也不能揉搓和使劲扭. 清洗时也不能使用酸性和碱性洗涤剂, 只能使用专用的中性洗涤剂. 洗多次之后会越来越软.</p>

<h2>莫代尔/再生纤维素纤维</h2>

<p>莫代尔(Modal) 原料是欧洲的灌木林, 和棉一样属于天然纤维, 柔软, 有光泽, 吸湿, 透气较纯棉好一些. 不容易被染色, 几乎不缩水, 特别是加了氨纶后.</p>

<p>一般会和一些合成纤维混纺, 使布料具有一定的弹性. 也有和纯棉混纺.</p>

<p>清洗多次没有明显的变化.</p>

<h2>丝/蚕丝</h2>

<p>丝(Silk) 天然动物纤维, 属于蛋白质纤维(Protein Fibre). 有光泽, 柔软, 透气优于纯棉, 会缩水.</p>

<p>一般也可能加其它合成纤维, 比如氨纶, 以增加弹性, 减少缩水.</p>

<p>只适合手洗, 不可揉搓, 不可拧干, 不能用洗衣粉, 洗衣皂, 香皂等洗涤品. 只能用专门的洗涤剂, 或者洗发水, 不能暴晒, 只能阴干.</p>

<h2>帆布</h2>

<p>帆布(Canvas) 是粗厚的棉织物或麻织物, 日常主要是帆布鞋, 帆布包. 坚硬, 耐磨, 相对于皮革比较透气, 重量轻.</p>

<h2>皮革</h2>

<p>主要是指动物毛皮, 衣服主要有牛皮, 猪皮, 小牛皮, 山羊皮, 绵羊皮. 皮革衣服普遍很贵, 并且只适用于特定场合, 所以基本不普及, 很多场合也有特性更好的合成纤维代替.</p>

<p>另一个大量使用皮革的是鞋, 主要有牛皮, 羊皮, 猪皮, 当然现在也有部分场合被人造革代替.</p>

<p>皮革都需要特别的护理, 不宜浸水, 需要防霉, 防蛀.</p>

<h3>人造革/合成革</h3>

<p>人造革主要是高分子聚合物, 主要原料是PVC, PU, 无纺布.</p>

<p>早期的人造革耐磨都不如皮革, 还有过以人造革假冒皮革的, 但是现代制造出了一些比较好的人造革. 现在多数运动鞋都使用人造革, 比皮革轻, 有光泽, 颜色美观, 耐磨程度相当, 还易于加工, 日常护理相对较皮革容易.</p>

<p>目前人造革就是透气上可能不如皮革, 一般鞋会通过设计透气孔, 搭配其它材料来改善透气.</p>

<p>合成革和人造革据说是不同的东西, 不过我现在区分不出来, 在运动鞋的材料说明上很多也写的有合成革.</p>

<p>白色运动鞋清洗完最好使用吸水纸包裹避光晾干, 也避免鞋面发黄.</p>

<h2>参考</h2>

<p>前文参考了以下网站的资料</p>

<ul>
<li><a href="http://zh.wikipedia.org/">Wikipedia 中文</a></li>
<li><a href="http://en.wikipedia.org/">Wikipedia 英文</a></li>
<li><a href="http://www.hudong.com/">互动百科</a></li>
<li><a href="http://baike.baidu.com/">百度百科</a></li>
</ul>


<p>使用 <a href="http://www.google.com/">Google</a> 搜索.</p>

      <p><a href="http://netwjx.github.com/blog/2012/07/15/garment-fabric-knowledge/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Unicode转义(\uXXXX)的编码和解码]]></title>
    
      <category term="CSharp" />
    
      <category term="Decode" />
    
      <category term="Encode" />
    
      <category term="Java" />
    
      <category term="Javascript" />
    
      <category term="RegExp" />
    
    <link href="http://netwjx.github.com/blog/2012/07/07/encode-and-decode-unicode-escape-string/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-07-07T12:23:00+08:00</published>
    <updated>2012-07-07T12:23:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/07/07/encode-and-decode-unicode-escape-string</id>
    <content type="html"><![CDATA[<p>在涉及Web前端开发时, 有时会遇到<code>\uXXXX</code>格式表示的字符, 其中<code>XXXX</code>是16进制数字的字符串表示形式, 在js中这个叫Unicode转义字符, 和<code>\n</code> <code>\r</code>同属于转义字符. 在其他语言中也有类似的, 可能还有其它变形的格式.</p>

<p>多数时候遇到需要解码的情况多点, 所以会先介绍解码decode, 后介绍编码encode.</p>

<p>下文会提供Javascript C# Java三种语言下不同方法的实现和简单说明, 会涉及到正则和位运算的典型用法.</p>

<!-- more -->


<h2>Javascript的实现</h2>

<h3>解码的实现</h3>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">function</span> <span class="nx">decode</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">unescape</span><span class="p">(</span><span class="nx">s</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/\\(u[0-9a-fA-F]{4})/gm</span><span class="p">,</span> <span class="s1">&#39;%$1&#39;</span><span class="p">));</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>unescape</code>是用来处理<code>%uXXXX</code>这样格式的字符串, 将<code>\uXXXX</code>替换成<code>%uXXXX</code>后<code>unescape</code>就可以处理了.</p>

<h3>编码的实现</h3>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">function</span> <span class="nx">encode1</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">escape</span><span class="p">(</span><span class="nx">s</span><span class="p">).</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/%(u[0-9A-F]{4})|(%[0-9A-F]{2})/gm</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">$0</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$2</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>        <span class="k">return</span> <span class="nx">$1</span> <span class="o">&amp;&amp;</span> <span class="s1">&#39;\\&#39;</span> <span class="o">+</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">toLowerCase</span><span class="p">()</span> <span class="o">||</span> <span class="nx">unescape</span><span class="p">(</span><span class="nx">$2</span><span class="p">);</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>和解码中相对应, 使用<code>escape</code>编码, 然后将<code>%uXXXX</code>替换为<code>\uXXXX</code>, 因为<code>escape</code>还可能把一些字符编码成<code>%XX</code>的格式, 所以这些字符还需要使用<code>unescape</code>还原回来.</p>

<p><code>escape</code>编码结果<code>%uXXXX</code>中的<code>XXXX</code>是大写的, 所以后面的<code>replace</code>只处理大写的<code>A-F</code>.</p>

<h3>另一种编码的实现</h3>

<p>不使用正则和<code>escape</code></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">function</span> <span class="nx">encode2</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">c</span><span class="p">,</span> <span class="nx">ret</span> <span class="o">=</span> <span class="p">[],</span>
</span><span class='line'>        <span class="nx">pad</span> <span class="o">=</span> <span class="s1">&#39;000&#39;</span><span class="p">;</span>
</span><span class='line'>    <span class="k">for</span> <span class="p">(</span><span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">s</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>        <span class="nx">c</span> <span class="o">=</span> <span class="nx">s</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="nx">i</span><span class="p">);</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="nx">c</span> <span class="o">&gt;</span> <span class="mi">256</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>            <span class="nx">c</span> <span class="o">=</span> <span class="nx">c</span><span class="p">.</span><span class="nx">toString</span><span class="p">(</span><span class="mi">16</span><span class="p">);</span>
</span><span class='line'>            <span class="nx">ret</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;\\u&#39;</span> <span class="o">+</span> <span class="nx">pad</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">4</span> <span class="o">-</span> <span class="nx">c</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="o">+</span> <span class="nx">c</span><span class="p">;</span>
</span><span class='line'>        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span><span class='line'>            <span class="nx">ret</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">ret</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>遍历字符串中的字符, 那些<code>charCode</code>大于256的会转换成16进制字符串<code>c.toString(16)</code>, 如果不足4位则左边补0<code>pad.substr(0, 4 - c.length)</code>. 结尾将遍历的结果合并成字符串返回.</p>

<h2>C#的实现</h2>

<h3>解码的实现</h3>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="k">static</span> <span class="n">Regex</span> <span class="n">reUnicode</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Regex</span><span class="p">(</span><span class="s">@&quot;\\u([0-9a-fA-F]{4})&quot;</span><span class="p">,</span> <span class="n">RegexOptions</span><span class="p">.</span><span class="n">Compiled</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="k">public</span> <span class="k">static</span> <span class="kt">string</span> <span class="nf">Decode</span><span class="p">(</span><span class="kt">string</span> <span class="n">s</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="n">reUnicode</span><span class="p">.</span><span class="n">Replace</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">m</span> <span class="p">=&gt;</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">short</span> <span class="n">c</span><span class="p">;</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="kt">short</span><span class="p">.</span><span class="n">TryParse</span><span class="p">(</span><span class="n">m</span><span class="p">.</span><span class="n">Groups</span><span class="p">[</span><span class="m">1</span><span class="p">].</span><span class="n">Value</span><span class="p">,</span> <span class="n">System</span><span class="p">.</span><span class="n">Globalization</span><span class="p">.</span><span class="n">NumberStyles</span><span class="p">.</span><span class="n">HexNumber</span><span class="p">,</span> <span class="n">CultureInfo</span><span class="p">.</span><span class="n">InvariantCulture</span><span class="p">,</span> <span class="k">out</span> <span class="n">c</span><span class="p">))</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="s">&quot;&quot;</span> <span class="p">+</span> <span class="p">(</span><span class="kt">char</span><span class="p">)</span><span class="n">c</span><span class="p">;</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>        <span class="k">return</span> <span class="n">m</span><span class="p">.</span><span class="n">Value</span><span class="p">;</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>正则和js中的一样, 将<code>XXXX</code>转换以16进制<code>System.Globalization.NumberStyles.HexNumber</code>解析为<code>short</code>类型, 然后直接<code>(char)c</code>就能转换成对应的字符, <code>"" + (char)c</code>用于转换成字符串类型返回.</p>

<p>由于正则中也有<code>\uXXXX</code>, 所以需要写成<code>\\uXXXX</code>来表示匹配字符串<code>\uXXXX</code>, 而不是具体的字符.</p>

<p>上面使用到了Lambda, 需要至少dotnet 4的SDK才能编译通过, 可以在dotnet 2下运行.</p>

<h3>编码的实现</h3>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="k">static</span> <span class="n">Regex</span> <span class="n">reUnicodeChar</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Regex</span><span class="p">(</span><span class="s">@&quot;[^\u0000-\u00ff]&quot;</span><span class="p">,</span> <span class="n">RegexOptions</span><span class="p">.</span><span class="n">Compiled</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="k">public</span> <span class="k">static</span> <span class="kt">string</span> <span class="nf">Encode</span><span class="p">(</span><span class="kt">string</span> <span class="n">s</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="n">reUnicodeChar</span><span class="p">.</span><span class="n">Replace</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">m</span> <span class="p">=&gt;</span> <span class="kt">string</span><span class="p">.</span><span class="n">Format</span><span class="p">(</span><span class="s">@&quot;\u{0:x4}&quot;</span><span class="p">,</span> <span class="p">(</span><span class="kt">short</span><span class="p">)</span><span class="n">m</span><span class="p">.</span><span class="n">Value</span><span class="p">[</span><span class="m">0</span><span class="p">]));</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>和C#的解码实现正好相反, 0-255之外的字符, 从<code>char</code>转换成<code>short</code>, 然后<code>string.Format</code>以16进制, 至少输出4位.</p>

<h2>Java的实现</h2>

<h3>解码的实现</h3>

<p>和C#相似的, 使用正则</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">static</span> <span class="kd">final</span> <span class="n">Pattern</span> <span class="n">reUnicode</span> <span class="o">=</span> <span class="n">Pattern</span><span class="o">.</span><span class="na">compile</span><span class="o">(</span><span class="s">&quot;\\\\u([0-9a-zA-Z]{4})&quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">static</span> <span class="n">String</span> <span class="nf">decode1</span><span class="o">(</span><span class="n">String</span> <span class="n">s</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">Matcher</span> <span class="n">m</span> <span class="o">=</span> <span class="n">reUnicode</span><span class="o">.</span><span class="na">matcher</span><span class="o">(</span><span class="n">s</span><span class="o">);</span>
</span><span class='line'>    <span class="n">StringBuffer</span> <span class="n">sb</span> <span class="o">=</span> <span class="k">new</span> <span class="n">StringBuffer</span><span class="o">(</span><span class="n">s</span><span class="o">.</span><span class="na">length</span><span class="o">());</span>
</span><span class='line'>    <span class="k">while</span> <span class="o">(</span><span class="n">m</span><span class="o">.</span><span class="na">find</span><span class="o">())</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">m</span><span class="o">.</span><span class="na">appendReplacement</span><span class="o">(</span><span class="n">sb</span><span class="o">,</span>
</span><span class='line'>                <span class="n">Character</span><span class="o">.</span><span class="na">toString</span><span class="o">((</span><span class="kt">char</span><span class="o">)</span> <span class="n">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">m</span><span class="o">.</span><span class="na">group</span><span class="o">(</span><span class="mi">1</span><span class="o">),</span> <span class="mi">16</span><span class="o">)));</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>    <span class="n">m</span><span class="o">.</span><span class="na">appendTail</span><span class="o">(</span><span class="n">sb</span><span class="o">);</span>
</span><span class='line'>    <span class="k">return</span> <span class="n">sb</span><span class="o">.</span><span class="na">toString</span><span class="o">();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Java语言没有内嵌正则语法, 也没有类似C#的<code>@"\u1234"</code>原始形式字符串的语法, 所以要表示正则中匹配<code>\</code>, 就需要<code>\\\\</code>, 其中2个是用于Java中字符转义, 2个是正则中的字符转义.</p>

<p>Java语言中没有设计函数或者委托的语法, 所以它的正则库提供的是<code>find</code> <code>appendReplacement</code> <code>appendTail</code>这些方法的组合, 等价于js和C#中的<code>replace</code>.</p>

<p>这里使用<code>StringBuffer</code>类型是由于<code>appendReplacement</code>只接受这个类型, <code>StringBuffer</code>有线程安全的额外操作, 所以性能差一点. 也许第三方的正则库能把API设计的更好用点.</p>

<p><code>Integer.parseInt(m.group(1), 16)</code>用于解析为<code>int</code>类型, 之后再<code>(char)</code>, 以及<code>Character.toString</code>转换成字符串.</p>

<h3>解码的另一种实现</h3>

<p>因为<code>StringBuffer</code>的原因, 不使用正则的实现</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">static</span> <span class="n">String</span> <span class="nf">decode2</span><span class="o">(</span><span class="n">String</span> <span class="n">s</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">StringBuilder</span> <span class="n">sb</span> <span class="o">=</span> <span class="k">new</span> <span class="n">StringBuilder</span><span class="o">(</span><span class="n">s</span><span class="o">.</span><span class="na">length</span><span class="o">());</span>
</span><span class='line'>    <span class="kt">char</span><span class="o">[]</span> <span class="n">chars</span> <span class="o">=</span> <span class="n">s</span><span class="o">.</span><span class="na">toCharArray</span><span class="o">();</span>
</span><span class='line'>    <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">chars</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
</span><span class='line'>        <span class="kt">char</span> <span class="n">c</span> <span class="o">=</span> <span class="n">chars</span><span class="o">[</span><span class="n">i</span><span class="o">];</span>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">c</span> <span class="o">==</span> <span class="sc">&#39;\\&#39;</span> <span class="o">&amp;&amp;</span> <span class="n">chars</span><span class="o">[</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="o">]</span> <span class="o">==</span> <span class="sc">&#39;u&#39;</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="kt">char</span> <span class="n">cc</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
</span><span class='line'>            <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="mi">4</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span> <span class="o">{</span>
</span><span class='line'>                <span class="kt">char</span> <span class="n">ch</span> <span class="o">=</span> <span class="n">Character</span><span class="o">.</span><span class="na">toLowerCase</span><span class="o">(</span><span class="n">chars</span><span class="o">[</span><span class="n">i</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">+</span> <span class="n">j</span><span class="o">]);</span>
</span><span class='line'>                <span class="k">if</span> <span class="o">(</span><span class="sc">&#39;0&#39;</span> <span class="o">&lt;=</span> <span class="n">ch</span> <span class="o">&amp;&amp;</span> <span class="n">ch</span> <span class="o">&lt;=</span> <span class="sc">&#39;9&#39;</span> <span class="o">||</span> <span class="sc">&#39;a&#39;</span> <span class="o">&lt;=</span> <span class="n">ch</span> <span class="o">&amp;&amp;</span> <span class="n">ch</span> <span class="o">&lt;=</span> <span class="sc">&#39;f&#39;</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                    <span class="n">cc</span> <span class="o">|=</span> <span class="o">(</span><span class="n">Character</span><span class="o">.</span><span class="na">digit</span><span class="o">(</span><span class="n">ch</span><span class="o">,</span> <span class="mi">16</span><span class="o">)</span> <span class="o">&lt;&lt;</span> <span class="o">(</span><span class="mi">3</span> <span class="o">-</span> <span class="n">j</span><span class="o">)</span> <span class="o">*</span> <span class="mi">4</span><span class="o">);</span>
</span><span class='line'>                <span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
</span><span class='line'>                    <span class="n">cc</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
</span><span class='line'>                    <span class="k">break</span><span class="o">;</span>
</span><span class='line'>                <span class="o">}</span>
</span><span class='line'>            <span class="o">}</span>
</span><span class='line'>            <span class="k">if</span> <span class="o">(</span><span class="n">cc</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                <span class="n">i</span> <span class="o">+=</span> <span class="mi">5</span><span class="o">;</span>
</span><span class='line'>                <span class="n">sb</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">cc</span><span class="o">);</span>
</span><span class='line'>                <span class="k">continue</span><span class="o">;</span>
</span><span class='line'>            <span class="o">}</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>        <span class="n">sb</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">c</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>    <span class="k">return</span> <span class="n">sb</span><span class="o">.</span><span class="na">toString</span><span class="o">();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>手工做就是麻烦很多, 代码中也一坨的符号.</p>

<p>遍历所有字符<code>chars</code>, 检测到<code>\u</code>这样的字符串, 检测后续的4个字符是否是16进制数字的字符表示. 因为<code>Character.isDigit</code>会把一些其它语系的数字也算进来, 所以保险的做法<code>'0' &lt;= ch &amp;&amp; ch &lt;= '9'</code>.</p>

<p><code>Character.digit</code>会把<code>0-9</code>返回为<code>int</code>类型的0-9, 第2个参数是16时会把<code>a-f</code>返回为<code>int</code>类型的10-15.</p>

<p>剩下的就是用<code>|=</code>把各个部分的数字合并到一起, 转换成char类型. 还有一些调整遍历位置等.</p>

<h3>编码的实现</h3>

<p>考虑到Java正则的杯具, 还是继续手工来吧, 相对解码来说代码少点.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">static</span> <span class="n">String</span> <span class="nf">encode</span><span class="o">(</span><span class="n">String</span> <span class="n">s</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">StringBuilder</span> <span class="n">sb</span> <span class="o">=</span> <span class="k">new</span> <span class="n">StringBuilder</span><span class="o">(</span><span class="n">s</span><span class="o">.</span><span class="na">length</span><span class="o">()</span> <span class="o">*</span> <span class="mi">3</span><span class="o">);</span>
</span><span class='line'>    <span class="k">for</span> <span class="o">(</span><span class="kt">char</span> <span class="n">c</span> <span class="o">:</span> <span class="n">s</span><span class="o">.</span><span class="na">toCharArray</span><span class="o">())</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">c</span> <span class="o">&lt;</span> <span class="mi">256</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">sb</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">c</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">sb</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="s">&quot;\\u&quot;</span><span class="o">);</span>
</span><span class='line'>            <span class="n">sb</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">Character</span><span class="o">.</span><span class="na">forDigit</span><span class="o">((</span><span class="n">c</span> <span class="o">&gt;&gt;&gt;</span> <span class="mi">12</span><span class="o">)</span> <span class="o">&amp;</span> <span class="mh">0xf</span><span class="o">,</span> <span class="mi">16</span><span class="o">));</span>
</span><span class='line'>            <span class="n">sb</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">Character</span><span class="o">.</span><span class="na">forDigit</span><span class="o">((</span><span class="n">c</span> <span class="o">&gt;&gt;&gt;</span> <span class="mi">8</span><span class="o">)</span> <span class="o">&amp;</span> <span class="mh">0xf</span><span class="o">,</span> <span class="mi">16</span><span class="o">));</span>
</span><span class='line'>            <span class="n">sb</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">Character</span><span class="o">.</span><span class="na">forDigit</span><span class="o">((</span><span class="n">c</span> <span class="o">&gt;&gt;&gt;</span> <span class="mi">4</span><span class="o">)</span> <span class="o">&amp;</span> <span class="mh">0xf</span><span class="o">,</span> <span class="mi">16</span><span class="o">));</span>
</span><span class='line'>            <span class="n">sb</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">Character</span><span class="o">.</span><span class="na">forDigit</span><span class="o">((</span><span class="n">c</span><span class="o">)</span> <span class="o">&amp;</span> <span class="mh">0xf</span><span class="o">,</span> <span class="mi">16</span><span class="o">));</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>    <span class="k">return</span> <span class="n">sb</span><span class="o">.</span><span class="na">toString</span><span class="o">();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>对应于上文Java编码的实现正好是反向的实现, 依旧遍历字符, 遇到大于256的字符, 用位运算提取出4部分并使用<code>Character.forDigit</code>转换成16进制数对应的字符.</p>

<p>剩下就是<code>sb.toString()</code>返回了.</p>

<h2>总结</h2>

<ul>
<li>编码从逻辑上比解码简单点.</li>
<li>对付字符串, js还是最顺手的, 也方便测试.</li>
<li>位运算的性能很高.</li>
<li>Java的正则库设计的很不方便, 可以考虑第三方.</li>
<li>Java的语法设计现在看来呆板, 落后, 也没有js那种灵活.</li>
<li>上文Java的非正则实现可以写成等价的C#代码.</li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/07/07/encode-and-decode-unicode-escape-string/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[黑莓使用备忘]]></title>
    
      <category term="BlackBerry" />
    
      <category term="Memo" />
    
    <link href="http://netwjx.github.com/blog/2012/07/01/blackberry-memo/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-07-01T18:58:00+08:00</published>
    <updated>2012-07-01T18:58:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/07/01/blackberry-memo</id>
    <content type="html"><![CDATA[<p>我曾经使用过将近1年时间黑莓的手机, 期间零零碎碎的有一些使用资料, 这段时间整理成一篇独立的文章, 算是对过去的一些留念吧.</p>

<h2>概况</h2>

<p>购买黑莓主要是想试试全键盘的手机, 黑莓全键盘手机主要是两个系列, Bold 经典设计, Curve 小巧设计, 其实Curve和Bold的大小差异就是几毫米.</p>

<p>不同时期黑莓手机就是屏幕, 性能, 外观差异, 比如7xxx 87xx 83xx 85xx 89xx. 同一时期的主要是网络制式, GPS, WiFi, 发行地区, 键盘Y/Z倒置之类的差异.</p>

<p>黑莓的型号数字大小和发布日期最初是有些对应关系的, 但是后来就很混乱了, 不仔细找资料还真很难区分.</p>

<h2>硬件</h2>

<p><img class="right" src="http://netwjx.github.com/i/bb8310.png" title="BlackBerry 8310" alt="BlackBerry 8310"></p>

<p>我购买的是水货的<a href="http://cn.blackberry.com/devices/blackberrycurve8300/">BlackBerry Curve 8310</a>, 以下简称<strong>bb8310</strong>, 铁灰色, 和图片上哪种颜色不同.</p>

<ul>
<li><p>GSM网络制式, 国内能用移动和联通的2G网络.</p></li>
<li><p>支持GPRS/EDGE上网, EDGE是GPRS升级, 理论上快一点, 但是我没感觉到. EDGE移动的基站支持的比较多, 联通挺多的还是GPRS.</p></li>
<li><p>Intel PXA901 312 MHz, 就实际使用的流畅感觉来说, <strong>所有点击操作都有延迟的感觉, 列表滚动经常短暂的卡顿.</strong></p></li>
<li><p>内置存储 64M, 精简ROM后还能剩30M左右, 安装第三方应用都需要占用内置存储空间.</p></li>
<li><p>支持MicroSD(TF)卡, 应该是不支持SDHC, 不过实际我用的是2G的, <strong>因为bb8310读写速度极慢, 写入速度低于1M/s</strong>.</p></li>
<li><p>320x240解析度的TFT屏幕, <strong>阳光下可以看清字, 因为会自动调整背光强度.</strong></p></li>
<li><p>带GPS, 带200w像素的摄像头, 无自动对焦, 带闪光灯, <strong>闪光灯实际当手电筒使用</strong>.</p></li>
<li><p>无WiFi, <strong>有WiFi的那个型号只能使用系统自带浏览器上网, 第三方应用要折腾导入服务预订</strong></p></li>
<li><p>轨迹球导航键, <strong>比侧边的滚轮能提供4个方向导航, 但是比更新型号的光学触控板更容易变油腻, 老化明显.</strong></p></li>
<li><p>图片JPG, BMP, TIFF. 音乐AMR, MP3, WMA. 视频MPEG4, 3GP(H.263), <strong>不建议考虑视频, 即使是录制的视频质量也太差</strong>, 没有实际意义.</p></li>
</ul>


<!-- more -->


<p>硬件参数什么的只能说是, 哪个时期, 水货哪个价格还行, 行货价格极高.</p>

<h3>硬件设计方面</h3>

<ul>
<li><p>正面的LED灯十分有用, 能够表示未接来电, 新短信, 充电中, 充电完成, 电量低. 配合第三方软件还可以有其它的提醒用途.</p></li>
<li><p>侧面框和顶部都是橡胶油涂层, 手感好, 但是bb8310有点问题, 用一段时间后, 磨损等会让所有涂层都脱落, 就剩塑料了.</p></li>
<li><p>外部扬声器在顶部, 有缝隙, 不怕手机压到什么地方后声音太小.</p></li>
<li><p>bb8310的键盘按键有些特殊, 是比较硬的哪种, 按下后会响. 由于是Curve的小巧设计, 有些人可能会觉得按键太小, 我感觉还好.</p></li>
<li><p>左右两侧中部的按键可以设置为启动自定义的软件, 我是其中一个设置为摄像机, 用于开启闪光灯, 当手电筒用, 另外一个设置为百度输入法, 具体为何会在下文说明.</p></li>
<li><p>最好也买一个休眠套, 一般是牛皮的, 除了省电外, 还能在拿出休眠套后自动点亮屏幕, 可以理解为直板手机的翻盖开关.</p></li>
</ul>


<h2>软件</h2>

<p>黑莓中可以安装的软件主要是alx, jad, cod:</p>

<ul>
<li><p>alx是黑莓自己的格式, 可以使用黑莓的PC工具中带的AppLoader刷机工具安装.</p></li>
<li><p>jad是JavaME的标准, 一般是在线安装, 如果已经下载好了可以用 <strong>多媒体</strong> 中 <strong>黑莓键</strong> - <strong>浏览</strong> 打开来安装.</p></li>
<li><p>cod, 上面2个一般都是安装描述格式, 这个才是软件自身, 一般需要使用工具生成alx或jad然后来安装, 也可以使用BerryBox直接安装.</p></li>
</ul>


<h3>常用软件</h3>

<p>排名不分先后.</p>

<ul>
<li><p><a href="http://www.uc.cn/product/product_choose_browser.shtml">UC浏览器黑莓版</a></p>

<p>比黑莓自带的浏览器靠谱很多的第三方浏览器.</p></li>
<li><p><a href="http://m.google.cn/maps/">Google 地图</a></p>

<p>bb8310只能使用在线地图, 必须将 <strong>选项</strong> - <strong>高级选项</strong> - <strong>TCP</strong> 中的 <strong>APN</strong> 设置为<code>cmnet</code>才行, 非中国移动的设置成对应的<code>XXnet</code>. 感觉Google地图的定位速度比较快.</p></li>
<li><p><a href="http://www.gpslook.net/">乐图</a></p>

<p>可以使用离线地图包, 也可以制作自己的地图包. 地图保存在TF卡上, 刷机后一般建议重新导入离线地图包.</p></li>
<li><p><a href="http://bbdev.org/">黑莓来电助手</a> <a href="http://bbdev.org/active/">注册</a></p>

<p>来电归属地显示, 不过这个在bb8310上并不总是一定能看到, 还好可以在通话记录中手工查找归属地, 归属地数据库不定期更新.</p>

<p>提供IP拨号功能, 可能受限于API, 不能高度和系统集成, 只是拨号时增加了一个菜单项.</p>

<p>提供接通震动, 拨号后等待接通的这段时间可以不必要一直听着手机.</p></li>
<li><p><a href="http://bbdev.org/">黑莓热键大师</a></p>

<p>和来电助手是同一个开发者, 是一个快捷启动软件的工具, 用来对付哪些没有设置快捷键的软件.</p></li>
<li><p>百度黑莓输入法</p>

<p>曾经叫点讯梅花输入法, 利用黑莓键盘最下方的5个键来选字, 比默认的输入法选字速度快, 支持双拼(自定义双拼方案).</p>

<p>在bb8310上缺点是它是在独立程序 <strong>百度记事本</strong> 中输入好之后再粘贴的, 基本上BlackBerry OS 4.5的第三方输入法全都是这样, 黑莓的公司一直以来对开发者不怎么待见. 所以我设置为右侧中部按键启动 <strong>百度记事本</strong>.</p>

<p>由于基本都是泄漏出来的, 所以没有什么官方地址, 自行Google或者到<a href="http://www.bber.info/post/baiduinput">这里下载</a></p></li>
<li><p><a href="http://hi.baidu.com/feng131719/archive/tag/%E7%81%B0%E5%A4%AA%E7%8B%BC%E5%85%88%E7%94%9F-%E9%BB%91%E8%8E%93%E4%B8%93%E5%8C%BA">黑莓键盘锁 AutoLock</a></p>

<p>直板手机都有的, 因为黑莓提供了休眠套, 所以黑莓自身没有超时自动锁键盘的功能, 所以用这个软件来完成超时自动锁键盘.</p></li>
<li><p><a href="http://www.berryon.com/blackberry/1051.htm">桌面农历 LunarHome</a></p>

<p>桌面图标显示为农历的日期, 包括24节气什么的.</p>

<p>还有一个PanvsCalendar, 功能更多一些, 收费的, 和桌面农历不是同一个开发者, <a href="http://panvs.taobao.com/">PanvsCalendar作者的淘宝店</a>.</p></li>
<li><p><a href="http://www.mowriter.com">MoWriter</a></p>

<p>黑莓上的微博工具, 支持<a href="http://weibo.com/">新浪微博</a>, <a href="http://jie.pn">街旁网</a>, 做啥网, 我多数时候用新浪微博.</p>

<p>不过bb8310及同系列的, 要么没WiFi, 要么第三方软件不能使用WiFi, GPRS速度太慢了, 就算是EDGE也没太大提高.</p></li>
<li><p>贝贝词典</p>

<p>十分快速小巧的词典软件, 可以自定义词库, 作者提供有一个英汉词典.</p>

<p>作者没有设置网站, 主要在maxpda论坛发布, 可以自行Google或者到<a href="http://bbs.maxpda.com/thread-24798-1-1.html">这里下载</a></p>

<p>连接电脑后, 使用导入客户端导入时必须同时启动手机上的贝贝词典.</p>

<p>需要注意的是词库会导入到黑莓的数据库, 这会在使用黑莓桌面工具备份数据库的时候速度极慢.</p></li>
<li><p><a href="http://coolove.pcriot.com">BBNotePad</a></p>

<p>如名字所示, 记事本, 可以编辑txt和系统内部的记事本. 名字是英文的, 但是界面有中文.</p>

<p>可以用这个把系统记事本保存到TF卡上.</p></li>
<li><p>GBBReader</p>

<p>文本格式阅读器, 打开速度极快, 我觉得这个是作为BBNotePad的搭配, 这个阅读十分方便, 中文字体可以开反锯齿, 效果会好点.</p>

<p>作者没有设置网站, 我也没找到主要在什么网站发布, 只能自行Google.</p></li>
<li><p>Nintaii</p>

<p>磨时间的移植类游戏, 自行Google</p></li>
<li><p><a href="http://oteam.cn/BerryBox/">BerryBox</a></p>

<p>这是个PC端工具, 需要dotnet 2.0运行环境, 可以实现黑莓上的安装软件, 备份软件, cod生成alx和jad, 完整刷机前的清除, 同步时间, 截屏, 工程模式激活码, OTA下载功能.</p></li>
</ul>


<h3>初次拨号前的设置</h3>

<p><strong>拨号键</strong> - <strong>黑莓键</strong> - <strong>选项</strong> - <strong>智能拨号</strong> 中 <strong>国家地区号码</strong>设置为<code>+86</code>表示中国, <strong>国内号码长度</strong>设置为<code>11</code>表示国内的手机号码长度.</p>

<p>这样可以避免一些拨号的问题, 国行应该不需要这样的设置吧.</p>

<h3>导入SIM卡中的联系人</h3>

<p>在通讯簿中, <strong>黑莓键</strong> - <strong>SIM 电话簿</strong> - <strong>黑莓键</strong> - <strong>全部复制到通讯簿</strong>.</p>

<h3>快速查找联系人</h3>

<p>bb8310的通讯簿不能以拼音索引联系人, 必须输入汉字才行, 这算是黑莓做本地化的失败之处. 听说新的机型已经支持拼音索引了.</p>

<p>替代办法是给联系人设置上公司名字, 可以仅填上首字母, 或者按照英文人名规则哪样空格分割.</p>

<p>有一个软件叫 <strong>通讯簿批量添加拼音缩写小工具</strong> , 来自uulab.org, 但是目前只能访问<a href="http://uulab.cn/">uulab.cn</a>, 第三方网站上还能下载到, <a href="http://www.52blackberry.com/thread-418860-1-1.html">比如这里</a></p>

<p>还有<a href="http://berryware360.cn/">莓软360</a>的<strong>凌波微步 SmartDial</strong>通过独立实现通讯簿方式实现按拼音索引, 但都受限于黑莓的API, 和系统集成的不是很好.</p>

<p>通讯簿可以给联系人设置头像, 但是哪个却限制为一个很小的图片, 来电时会显示一个很小的头像, 很莫名其妙的设计.</p>

<h3>字体</h3>

<p>bb8310默认带的字体在英文的表现比较好, 中文的则必须把字号设置大一点才方便看, 中文没有反锯齿.</p>

<p>但是奇怪的是GBBReader中显示中文却可以反锯齿, 难道是黑莓有意为之?</p>

<h3>黑莓断网问题</h3>

<p>断网主要是在APN为net接入点时, 第三方软件间歇性无法访问网络, 原因比较奇怪, 看表现应该是黑莓对运营商的新旧网络设备不兼容.</p>

<p>这个问题在比bb8310更新的机型中也存在, 我不知道最新的是否有解决这个问题.</p>

<h3>黑莓桌面工具无法和手机连接</h3>

<p>这个一般是在安装一些主题或软件后会发生, 处理办法是将语言设置为英文后重启, 重启方法见下文.</p>

<h3>手电筒</h3>

<p>我看过黑莓的应用程序开发SDK, 没有发现任何明确的, 控制手电筒的API, 也没有找到能单独打开闪光灯的应用, 这个好像都只有在新的黑莓手机和SDK中存在.</p>

<p>所以只能将左侧的键设置为摄像机, 用空格键切换闪光灯为强制开, 以后要开手电筒就按左侧的键, 等一会就能打开, 只是需要过一会动一下滚迹球, 否则会自动锁屏.</p>

<h3>彩信</h3>

<p>发送彩信基本没有什么特殊的设置, 但是接收彩信需要确保是下面的设置</p>

<ul>
<li><p><strong>选项</strong> - <strong>高级选项</strong> - <strong>浏览器推入</strong>中, 选中<strong>启用 WAP 推入</strong>.</p></li>
<li><p><strong>选项</strong> - <strong>彩信</strong>中, <strong>多媒体接收</strong>和<strong>自动检索</strong>选中, <strong>消息过滤中的拒绝</strong>最好取消掉.</p></li>
</ul>


<p>接收彩信必须打开<strong>移动网络</strong>中的<strong>数据服务</strong>.</p>

<h3>用数据线连接电脑作为U盘使用</h3>

<p><strong>选项</strong> - <strong>媒体卡</strong>中的</p>

<ul>
<li><strong>外部存储器支持</strong> : 开</li>
<li><strong>加密模式</strong> : 无</li>
<li><strong>&#8220;大容量模式&#8221;支持</strong> : 开</li>
<li><strong>连接时自动启用&#8221;大容量模式&#8221;</strong> : 是</li>
</ul>


<p>然后连接电脑就应该能看到新的盘符.</p>

<p>需要注意的是, bb8310确实是USB 2.0的接口, 使用的TF卡确实是Class 4的, 读取至少在10M/s以上, 写入至少在4M/s. 但是在bb8310上读取在1M/s左右, 写入大概0.8M/s左右, 不确定是硬件还是软件限制的原因. 所以如果是大文件建议拔出来用读卡器.</p>

<h3>关机和重启手机</h3>

<p>bb8310桌面上的<strong>关闭电源</strong>会有<strong>关闭</strong>和<strong>完全切断电源</strong>两个选择</p>

<ul>
<li><p><strong>关闭</strong>类似待机, 如果设置了自动开机会生效, 启动很快.</p></li>
<li><p><strong>完全切断电源</strong>类似休眠, 自动开机不会生效, <strong>闹钟也不会生效</strong>, 但是启动很快.</p></li>
</ul>


<p>bb8310没有通过软件真正关机的办法, 只能是拔电池. 下次安装电池就会自动开机.</p>

<p>推荐使用 <strong>左Alt + 右Shift(左下角和右下角的键) + Del</strong> 重启, 毕竟拔电池再安装太麻烦了.</p>

<p>重启速度很慢, 大概3分钟.</p>

<h3>浏览器的首页被锁定</h3>

<p>这个是黑莓故意为之, 他会配合运营商限制用户对手机的一些功能的使用和设置, 包括浏览器, 彩信, WiFi.</p>

<p>这么做的好处是运营商相关的一些网络配置是自动化设置好的, 坏处是运营商会在很多地方和用户为敌, 而黑莓正好处处配合运营商.</p>

<p>网上有导入<strong>服务预订 Service Book</strong>设置的可以解除锁定, 我觉得很复杂, 用过一次, 结果不能上网了.</p>

<h3>蓝牙传输文件</h3>

<p>发送文件一般比较简单, 但是用黑莓接收就需要绕点弯了.</p>

<p><strong>多媒体</strong> - <strong>黑莓键</strong> - <strong>使用蓝牙接收</strong>, 后续按照屏幕指示就可以了.</p>

<p>没有自动接收, 批量接收, 总体感觉蓝牙的使用极其繁琐.</p>

<h3>把通讯簿的联系人复制到SIM卡</h3>

<p>在通讯簿中, 查看一个联系人的信息, 将光标移动到联系人的号码上, <strong>黑莓键</strong> - <strong>复制到SIM电话簿</strong>.</p>

<p>没有批量操作方式, 我也没找到第三方软件有这样的功能, 好像是黑莓的API限制.</p>

<p>黑莓桌面工具的同步功能可以将通讯簿导出为逗号分割的文本格式, 可以在Excel或者WPS表格中编辑, 但是这个操作过程还是很麻烦的.</p>

<h3>快捷键启动软件</h3>

<p>设计很是奇怪, 软件的快捷键启动方式可以由</p>

<ul>
<li>软件自身设置, 比如启动BBNotePad的快捷键是<strong>P</strong>.</li>
<li>界面皮肤设置, 很多第三方皮肤都设置了大量的快捷键.</li>
</ul>


<p>没有快捷键设置的软件可以使用上文中提到的<a href="http://bbdev.org/">黑莓热键大师</a>, 黑莓系统内的快捷键可以<a href="http://www.google.com.hk/search?q=%E9%BB%91%E8%8E%93%E5%BF%AB%E6%8D%B7%E9%94%AE">自行Google</a></p>

<h3>通话录音</h3>

<p>黑莓禁止这种功能, 估计最新的API也不提供这样的功能.</p>

<h3>音乐播放一段时间后自动停止</h3>

<p>目的是睡觉前使用, 在睡着后自动停止.</p>

<p>bb8310的音乐播放功能好像完全被系统自身的音乐播放器控制, 所有的音乐都由系统自身的音乐播放器来播放.</p>

<p>我没有找到bb8310可用的这种音乐播放软件.</p>

<h3>工程模式</h3>

<p>进入工程是 <strong>Alt + Shift + H</strong>, 然后在BerryBox中输入这个界面上看到的PIN, 应用程序版本, 启动时间等信息, 然后选择一个进入工程模式的时间, 点击<strong>获取激活码</strong>, 得到的应该是8位的字符, 在黑莓上直接输入哪些字符就会进入工程模式, 之后在工程模式的时间内, 按 <strong>Alt + Shift + H</strong> 会直接进入工程模式的界面.</p>

<p>我也没发现工程模式中有什么特别有用的功能.</p>

<h3>一些Bug</h3>

<ul>
<li><p>自带的拼音输入法, 在极个别的情况下会导致系统死机, 我没有能找出重现这个现象的方法, 但是出现过一次. 输入法应该除了黑莓开发的, 就是黑莓的合作运营商开发的.</p></li>
<li><p>在插入耳机的情况下, 并且使用了自动开关机, 自动开机后可能闹钟不使用外放, 而使用耳机播放闹钟的音乐.</p></li>
</ul>


<h2>刷机</h2>

<p>一般水货商卖的机器会安装好很多东西, 也基本够用, 如果想精简成完全适合自己的就需要刷机了. 当然也可以是为了使用更新版本的ROM而刷机.</p>

<p>刷机前先要确定使用哪个版本的ROM, 不同的机型对应不同的ROM, 我的bb8310主要用过的是</p>

<ul>
<li>174版本 <code>8310EastAsia_PBr4.5.0_rel294_PL2.7.0.105_A4.5.0.174_Hutchison_maxpda.exe</code></li>
<li>182版本 <code>8310EastAsia_PBr4.5.0_rel306_PL2.7.0.106_A4.5.0.182_AT_amp_T.exe</code></li>
</ul>


<p>相关的下载可以用文件名搜. 这两个ROM实际差异感觉不明显, 后一个第三方软件兼容好一点点, 只是因为黑莓的软件不多而显得可能比较明显.</p>

<p>可靠的刷机方式是使用黑莓桌面工具中的<strong>AppLoader</strong>, 路径是<code>C:\Program Files\Common Files\Research In Motion\AppLoader\Loader.exe</code>.</p>

<p>一般完整刷机(WIPE刷机)需要1小时, 再加上安装和配置软件什么的估计需要2小时, 赶上重装Windows了.</p>

<p><strong>AppLoader</strong>也用于安装alx格式的软件, 不过我更推荐使用<a href="http://oteam.cn/BerryBox/">BerryBox</a>作为日常安装软件, 除非某些软件必须使用AppLoader.</p>

<p>刷机或者安装软件后可能需要重启, 这个重启近乎和<strong>左Alt + 右Shift(左下角和右下角的键) + Del</strong>一样, 启动需要3分钟左右, 显然黑莓给自己留了重启的API.</p>

<h4>输入法</h4>

<p>使用AppLoader刷机时会看到有2个拼音输入法和2个笔画输入法, 每个里面第2个是繁体的, 简体中文只需要选中第一个.</p>

<h3>ROM的精简</h3>

<p>ROM中一般会携带一些运营商和合作伙伴的软件, 很多的其实用不到, 所以就出现了<a href="http://www.google.com.hk/search?q=%E9%BB%91%E8%8E%93+rom+%E7%B2%BE%E7%AE%80">各种ROM精简方法</a>.</p>

<p><a href="https://gist.github.com/raw/3027972/6592d22d4339af83ea8ca7a57841f345273a20f7/minify-bb8310-os45.bat">这里有个批处理</a>, 是针对8310 os4.5 rom的精简批处理脚本, 保存后, 将比如<code>C:\Program Files\Common Files\Research In Motion\Shared\Loader Files\8310-v4.5.0.182_P2.7.0.106</code>这样的目录拖到批处理文件上, 或者在命令行下手工指定路径运行这个批处理, 就可以对指定路径的ROM精简, 精简掉的文件都移动到了rom目录下的<strong>backup</strong>目录.</p>

<h3>刷机的备份和恢复</h3>

<p>黑莓桌面工具可以完整的备份黑莓中的配置, 但不包括安装上的软件. 恢复也是覆盖式恢复, 不会合并, 实际用途好像仅限于刷机前的备份.</p>

<p>能有价值备份的也主要是联系人, 短信, 通讯记录, 日程, 任务, 笔记之类的.</p>

<p>全面备份可能会因为类似贝贝词典这样的软件而中间卡很长时间.</p>

<p>备份的格式是ipd格式, 一种私有的2进制格式, 不是很方便修改.</p>

<h2>现状</h2>

<p>在黑莓公司开始下坡之前, 一直都和各个国家的运营商走的近, 上文多处也提到一些事的端倪.</p>

<p>对开发者比较不待见, 比如曾经不给中国开发者提供SDK下载. 在Android大量抢夺开发者的时候, 黑莓仍旧搞的和苹果一样, 对开发者收取软件签名用的证书费用, 后来降成1$, 最后免费, 不过为时已晚. SDK的维护不力, 大量私有的API. 后来情况有些改观, 但是也是太晚了, 坏的印象留下就无法抹去, 况且当时Android和iOS已经抢了主要的开发者.</p>

<p>对最终用户有一种很奇怪的态度, 一方面积极完善BIS BES这种&#8221;企业级&#8221;应用, 另一方面对旧产品疏于维护, 甚至一些问题会从旧的到新的产品中持续存在. 迟迟到来的应用商店对旧型号的支持还不如应用商店中的一些软件, 即应用商店中的软件支持这个旧机型, 但是应用商店自身却不支持. 虽然四处和运营商合作, 但是黑莓的网站仍旧慢的可以, 无论是用户还是开发者的感受会十分差. 大肆扩张业务的国家和地区, 但是相应的本地化却太肤浅, 至少我觉得和中国地区的一些优秀本地化应用开发者或公司合作太少, 感觉还是走亲近运营商的老路了.</p>

<p>中国地区的BIS好不容易才能用, 不过感觉还是太贵了, 多数人可能更在乎的是手机上方便的发邮件, 收邮件并不需要实时, 况且我根本不相信运营商能提供足够稳定的服务实现实时接收. BES好像还没什么消息, 除了贵之外, 可能也和国内公司没有使用Email的习惯吧.</p>

<p>黑莓公司现在的状况很差, 股价大跌, 公司高层的频繁变动, 还有政策变动, 裁员, 新产品销量达不到预期, 可能和Android关系更多, 反正是这个坎很难过.</p>

      <p><a href="http://netwjx.github.com/blog/2012/07/01/blackberry-memo/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Jekyll插件:分类云]]></title>
    
      <category term="Jekyll" />
    
      <category term="Octopress" />
    
      <category term="Plugin" />
    
      <category term="Ruby" />
    
    <link href="http://netwjx.github.com/blog/2012/06/03/category-cloud-plugin-with-jekyll/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-06-03T14:55:00+08:00</published>
    <updated>2012-06-03T14:55:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/06/03/category-cloud-plugin-with-jekyll</id>
    <content type="html"><![CDATA[<p>Octopress默认有存档页, 但是没有能列出所有分类的页面, 我试图找这方面的插件, 但是尝试使用的一些都不是很理想, 所以尝试自己写了一个这样的插件, 效果就如导航栏链接<a href="http://netwjx.github.com/blog/categories/">分类</a> 哪样.</p>

<p>以下是代码, 多数代码都是从Jeykll插件示例中抄的, 第一次写实用的ruby程序, 也没多想注释什么的.</p>

<!-- more -->




<figure class='code'><figcaption><span>plugins/category_cloud.rb</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">module</span> <span class="nn">Jekyll</span>
</span><span class='line'>  <span class="k">class</span> <span class="nc">CategoryCloudPage</span> <span class="o">&lt;</span> <span class="no">Page</span>
</span><span class='line'>    <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">site</span><span class="p">,</span> <span class="n">base</span><span class="p">,</span> <span class="n">dir</span><span class="p">,</span> <span class="n">cloud</span><span class="p">)</span>
</span><span class='line'>      <span class="vi">@site</span> <span class="o">=</span> <span class="n">site</span>
</span><span class='line'>      <span class="vi">@base</span> <span class="o">=</span> <span class="n">base</span>
</span><span class='line'>      <span class="vi">@dir</span> <span class="o">=</span> <span class="n">dir</span>
</span><span class='line'>      <span class="vi">@name</span> <span class="o">=</span> <span class="s1">&#39;index.html&#39;</span>
</span><span class='line'>
</span><span class='line'>      <span class="nb">self</span><span class="o">.</span><span class="n">process</span><span class="p">(</span><span class="vi">@name</span><span class="p">)</span>
</span><span class='line'>      <span class="nb">self</span><span class="o">.</span><span class="n">read_yaml</span><span class="p">(</span><span class="no">File</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">base</span><span class="p">,</span> <span class="s1">&#39;_layouts&#39;</span><span class="p">),</span> <span class="s1">&#39;category_cloud.html&#39;</span><span class="p">)</span>
</span><span class='line'>
</span><span class='line'>      <span class="nb">self</span><span class="o">.</span><span class="n">data</span><span class="o">[</span><span class="s1">&#39;cloud&#39;</span><span class="o">]</span> <span class="o">=</span> <span class="n">cloud</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">class</span> <span class="nc">CategoryCloudGenerator</span> <span class="o">&lt;</span> <span class="no">Generator</span>
</span><span class='line'>    <span class="n">safe</span> <span class="kp">true</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">def</span> <span class="nf">generate</span><span class="p">(</span><span class="n">site</span><span class="p">)</span>
</span><span class='line'>      <span class="k">if</span> <span class="n">site</span><span class="o">.</span><span class="n">layouts</span><span class="o">.</span><span class="n">key?</span> <span class="s1">&#39;category_cloud&#39;</span>
</span><span class='line'>        <span class="n">dir</span> <span class="o">=</span> <span class="n">site</span><span class="o">.</span><span class="n">config</span><span class="o">[</span><span class="s1">&#39;category_dir&#39;</span><span class="o">]</span> <span class="o">||</span> <span class="s1">&#39;categories&#39;</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">count</span> <span class="o">=</span> <span class="n">site</span><span class="o">.</span><span class="n">categories</span><span class="o">.</span><span class="n">map</span> <span class="k">do</span> <span class="o">|</span><span class="n">item</span><span class="o">|</span>
</span><span class='line'>          <span class="o">[</span><span class="n">item</span><span class="o">[</span><span class="mi">0</span><span class="o">]</span><span class="p">,</span> <span class="n">item</span><span class="o">[</span><span class="mi">1</span><span class="o">].</span><span class="n">length</span><span class="o">]</span>
</span><span class='line'>        <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">maxsize</span> <span class="o">=</span> <span class="mi">5</span>
</span><span class='line'>        <span class="n">minsize</span> <span class="o">=</span> <span class="mi">1</span>
</span><span class='line'>        <span class="n">min</span><span class="p">,</span> <span class="n">max</span> <span class="o">=</span> <span class="n">count</span><span class="o">.</span><span class="n">map</span><span class="p">(</span><span class="o">&amp;</span><span class="ss">:last</span><span class="p">)</span><span class="o">.</span><span class="n">minmax</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">cloud</span> <span class="o">=</span> <span class="n">site</span><span class="o">.</span><span class="n">categories</span><span class="o">.</span><span class="n">map</span> <span class="k">do</span> <span class="o">|</span><span class="nb">name</span><span class="p">,</span> <span class="n">posts</span><span class="o">|</span>
</span><span class='line'>          <span class="p">{</span>
</span><span class='line'>            <span class="s2">&quot;title&quot;</span> <span class="o">=&gt;</span> <span class="nb">name</span><span class="p">,</span>
</span><span class='line'>            <span class="s2">&quot;rank&quot;</span>  <span class="o">=&gt;</span> <span class="n">maxsize</span> <span class="o">+</span> <span class="n">minsize</span> <span class="o">-</span> <span class="p">((</span><span class="n">posts</span><span class="o">.</span><span class="n">length</span> <span class="o">-</span> <span class="n">min</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">maxsize</span> <span class="o">-</span> <span class="n">minsize</span><span class="p">)</span> <span class="o">/</span> <span class="p">(</span><span class="n">max</span> <span class="o">-</span> <span class="n">min</span><span class="p">)</span> <span class="o">+</span> <span class="n">minsize</span><span class="p">),</span>
</span><span class='line'>            <span class="s2">&quot;link&quot;</span>  <span class="o">=&gt;</span> <span class="s2">&quot;/</span><span class="si">#{</span><span class="n">dir</span><span class="si">}</span><span class="s2">/</span><span class="si">#{</span><span class="nb">name</span><span class="o">.</span><span class="n">gsub</span><span class="p">(</span><span class="sr">/_|\P{Word}/</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">gsub</span><span class="p">(</span><span class="sr">/-{2,}/</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">downcase</span><span class="si">}</span><span class="s2">/&quot;</span>
</span><span class='line'>          <span class="p">}</span>
</span><span class='line'>        <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">index</span> <span class="o">=</span> <span class="no">CategoryCloudPage</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">site</span><span class="p">,</span> <span class="n">site</span><span class="o">.</span><span class="n">source</span><span class="p">,</span> <span class="n">dir</span><span class="p">,</span> <span class="n">cloud</span><span class="p">)</span>
</span><span class='line'>        <span class="n">index</span><span class="o">.</span><span class="n">render</span><span class="p">(</span><span class="n">site</span><span class="o">.</span><span class="n">layouts</span><span class="p">,</span> <span class="n">site</span><span class="o">.</span><span class="n">site_payload</span><span class="p">)</span>
</span><span class='line'>        <span class="n">index</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">site</span><span class="o">.</span><span class="n">dest</span><span class="p">)</span>
</span><span class='line'>        <span class="n">site</span><span class="o">.</span><span class="n">pages</span> <span class="o">&lt;&lt;</span> <span class="n">index</span>
</span><span class='line'>      <span class="k">end</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span>sass/partials/_category_cloud.scss</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='scss'><span class='line'><span class="nc">.category-cloud</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">@for</span> <span class="nv">$i</span> <span class="ow">from</span> <span class="mi">1</span> <span class="ow">through</span> <span class="mi">5</span> <span class="p">{</span>
</span><span class='line'>        <span class="nc">.rank-</span><span class="si">#{</span><span class="nv">$i</span><span class="si">}</span> <span class="p">{</span> <span class="na">font-size</span><span class="o">:</span> <span class="nf">nth</span><span class="p">(</span><span class="mi">230</span><span class="kt">%</span> <span class="mi">210</span><span class="kt">%</span> <span class="mi">180</span><span class="kt">%</span> <span class="mi">140</span><span class="kt">%</span> <span class="mi">90</span><span class="kt">%</span><span class="o">,</span> <span class="nv">$i</span><span class="p">);</span> <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>    <span class="nc">.rank-1</span><span class="o">,</span> <span class="nc">.rank-2</span><span class="o">,</span> <span class="nc">.rank-3</span><span class="o">,</span> <span class="nc">.rank-4</span> <span class="p">{</span> <span class="nt">font-weight</span><span class="nd">:bold</span><span class="o">;</span> <span class="p">}</span>
</span><span class='line'>    <span class="nt">span</span> <span class="p">{</span> <span class="na">line-height</span><span class="o">:</span> <span class="mi">1</span><span class="mf">.25</span><span class="kt">em</span><span class="p">;</span> <span class="na">padding</span><span class="o">:</span><span class="mi">0</span> <span class="mi">5</span><span class="kt">px</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>需要修改<code>sass/_partials.scss</code>, 结尾加入一行</p>

<figure class='code'><figcaption><span>sass/_partials.scss</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='scss'><span class='line'><span class="k">@import</span> <span class="s2">&quot;partials/category_cloud&quot;</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span>source/_layouts/category_cloud.html</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'>---
</span><span class='line'>layout: page
</span><span class='line'>title: 分类
</span><span class='line'>footer: false
</span><span class='line'>---
</span><span class='line'>
</span><span class='line'><span class="nt">&lt;div</span> <span class="na">class=</span><span class="s">&quot;category-cloud&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    {% for item in page.cloud %}
</span><span class='line'>        <span class="nt">&lt;span</span> <span class="na">class=</span><span class="s">&quot;rank-{{ item.rank }}&quot;</span><span class="nt">&gt;&lt;a</span> <span class="na">href=</span><span class="s">&quot;{{ item.link }}&quot;</span><span class="nt">&gt;</span>{{ item.title }}<span class="nt">&lt;/a&gt;&lt;/span&gt;</span>
</span><span class='line'>    {% endfor %}
</span><span class='line'><span class="nt">&lt;/div&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>目前只做了生成分类页面, 侧边栏还没有做, 以后有做的冲动了再说吧.</p>

<h2>参考资料</h2>

<ul>
<li><p><a href="http://vitobotta.com/how-to-migrate-from-wordpress-to-jekyll/">Migrating from Wordpress to Jekyll - Part 2</a> Tag cloud 段落</p></li>
<li><p><a href="http://blog.16codes.com/2007/12/how-to-create-tag-cloud-with-formula.html">How to create a tag cloud? (With formula and sample calculation) </a> 算法</p></li>
<li><p><a href="https://github.com/imathis/octopress/blob/master/plugins/category_generator.rb">octopress / plugins / category_generator.rb</a> Octopress修改的具体分类页面生成插件</p></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/06/03/category-cloud-plugin-with-jekyll/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[使用.Net Remoting的IpcChannel时发生 RemotingException : 拒绝访问 异常]]></title>
    
      <category term="CSharp" />
    
      <category term="IPC" />
    
      <category term="Remoting" />
    
      <category term="Windows" />
    
    <link href="http://netwjx.github.com/blog/2012/06/03/remotingexception-access-is-denied-in-net-remoting-ipcchannel/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-06-03T12:09:00+08:00</published>
    <updated>2012-06-03T12:09:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/06/03/remotingexception-access-is-denied-in-net-remoting-ipcchannel</id>
    <content type="html"><![CDATA[<p>在一个使用IPC进行单机跨进称的通讯时发生了 <code>RemotingException : 拒绝访问</code> 异常, 期间查找异常原因的时候发现中文不大容易搜到正确的答案, 也可能是因为Remoting是已经不再支持的技术吧, 因为历史的原因还不能使用WCF, 所以这里将这个异常的原因和解决办法介绍一下.</p>

<p>发生这个异常的场景是一个Windows服务程序在IPC信道注册, 另外一个桌面程序连接到IPC信道通讯, 重点是在IPC信道注册的程序是Windows服务, 默认情况下它将运行在LocalSystem帐号下, 连接这个IPC信道的是另外的用户启动的进程.</p>

<p>错误的原因是向IPC信道注册时, 默认的授权是相同用户的进程才可以访问这个IPC信道, 可以通过下面的代码修改默认授权:</p>

<!-- more -->




<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="kt">var</span> <span class="n">dict</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Dictionary</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">,</span> <span class="kt">string</span><span class="p">&gt;();</span>
</span><span class='line'><span class="n">dict</span><span class="p">[</span><span class="s">&quot;name&quot;</span><span class="p">]</span> <span class="p">=</span> <span class="n">dict</span><span class="p">[</span><span class="s">&quot;portName&quot;</span><span class="p">]</span> <span class="p">=</span> <span class="n">portName</span><span class="p">;</span>
</span><span class='line'><span class="n">dict</span><span class="p">[</span><span class="s">&quot;authorizedGroup&quot;</span><span class="p">]</span> <span class="p">=</span> <span class="s">&quot;Everyone&quot;</span><span class="p">;</span>
</span><span class='line'><span class="n">serverChannel</span> <span class="p">=</span> <span class="k">new</span> <span class="n">IpcServerChannel</span><span class="p">(</span><span class="n">dict</span><span class="p">,</span> <span class="k">null</span><span class="p">);</span>
</span><span class='line'><span class="n">ChannelServices</span><span class="p">.</span><span class="n">RegisterChannel</span><span class="p">(</span><span class="n">serverChannel</span><span class="p">,</span> <span class="k">false</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>其中<code>portName</code>变量是IPC信道的名称</p>

<p>在IIS中运行的Web应用一般也是由一个<code>IUSER_xxxxx</code>的用户运行, 所以还有通过<code>web.config</code>配置方式在IPC信道注册的方式:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
</pre></td><td class='code'><pre><code class='xml'><span class='line'><span class="cp">&lt;?xml version=&quot;1.0&quot;?&gt;</span>
</span><span class='line'><span class="nt">&lt;configuration&gt;</span>
</span><span class='line'> <span class="nt">&lt;system.runtime.remoting&gt;</span>
</span><span class='line'>   <span class="nt">&lt;application&gt;</span>
</span><span class='line'>     <span class="nt">&lt;client&gt;</span>
</span><span class='line'>       <span class="nt">&lt;wellknown</span> <span class="na">type=</span><span class="s">&quot;fragrank.FragRankRemoting,FragRankLogic&quot;</span> <span class="na">url=</span><span class="s">&quot;ipc://FragRankChannel/FragRank&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>     <span class="nt">&lt;/client&gt;</span>
</span><span class='line'>     <span class="nt">&lt;channels&gt;</span>
</span><span class='line'>       <span class="nt">&lt;channel</span> <span class="na">ref=</span><span class="s">&quot;ipc&quot;</span> <span class="na">authorizedGroup=</span><span class="s">&quot;Everyone&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>         <span class="nt">&lt;clientProviders&gt;</span>
</span><span class='line'>          <span class="nt">&lt;formatter</span> <span class="na">ref=</span><span class="s">&quot;binary&quot;</span><span class="nt">/&gt;</span>
</span><span class='line'>         <span class="nt">&lt;/clientProviders&gt;</span>
</span><span class='line'>       <span class="nt">&lt;/channel&gt;</span>
</span><span class='line'>     <span class="nt">&lt;/channels&gt;</span>
</span><span class='line'>   <span class="nt">&lt;/application&gt;</span>
</span><span class='line'> <span class="nt">&lt;/system.runtime.remoting&gt;</span>
</span><span class='line'><span class="nt">&lt;/configuration&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<h2>参考资料</h2>

<ul>
<li><p><a href="http://www.codedblog.com/2007/09/01/calling-a-windows-service-from-aspnet-via-remoting-ipcchannel/">Calling a Windows Service from ASP.NET via Remoting &amp; IpcChannel</a></p>

<p>MSDN的文档对属性值并没有太多的说明, 这个里面有多个示例.</p></li>
<li><p><a href="http://msdn.microsoft.com/zh-cn/library/bb397847.aspx">信道属性</a></p></li>
<li><p><a href="http://msdn.microsoft.com/zh-cn/library/bb397831.aspx">服务器信道属性</a></p></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/06/03/remotingexception-access-is-denied-in-net-remoting-ipcchannel/#comments">查看评论</a></p>]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[C#委托和Lambda表达式]]></title>
    
      <category term="CSharp" />
    
      <category term="Delegate" />
    
      <category term="Functional" />
    
      <category term="Lambda" />
    
    <link href="http://netwjx.github.com/blog/2012/05/19/csharp-delegate-and-lambda/"/>
    <author>
      <name><![CDATA[netwjx]]></name>
      <uri>http://netwjx.github.com/</uri>
    </author>
    <published>2012-05-19T19:54:00+08:00</published>
    <updated>2012-05-19T19:54:00+08:00</updated>
    <id>http://netwjx.github.com/blog/2012/05/19/csharp-delegate-and-lambda</id>
    <content type="html"><![CDATA[<p>C#算是个多范式编程语言, 除了传统的OO风格, 还可以在部分范围中使用函数式编程的风格, 这里整理一下C#中委托和Lambda实践中的各种写法.</p>

<p>这里不会解释具体的代码含义, 仅仅介绍写法, 可能不适合刚开始学习.</p>

<h2>声明委托类型</h2>

<p>使用前必须要有具体的委托类型, 下面的例子中会使用到这些常用的委托类型</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="k">delegate</span> <span class="k">void</span> <span class="nf">Action</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'><span class="k">delegate</span> <span class="k">void</span> <span class="n">Action</span><span class="p">&lt;</span><span class="k">in</span> <span class="n">T1</span><span class="p">,</span> <span class="k">in</span> <span class="n">T2</span><span class="p">&gt;(</span><span class="n">T1</span> <span class="n">arg1</span><span class="p">,</span> <span class="n">T2</span> <span class="n">arg2</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="k">delegate</span> <span class="kt">bool</span> <span class="n">Predicate</span><span class="p">&lt;</span><span class="k">in</span> <span class="n">T</span><span class="p">&gt;(</span><span class="n">T</span> <span class="n">obj</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="k">delegate</span> <span class="n">TResult</span> <span class="n">Func</span><span class="p">&lt;</span><span class="k">in</span> <span class="n">T1</span><span class="p">,</span> <span class="k">in</span> <span class="n">T2</span><span class="p">,</span> <span class="k">out</span> <span class="n">TResult</span><span class="p">&gt;(</span><span class="n">T1</span> <span class="n">arg1</span><span class="p">,</span> <span class="n">T2</span> <span class="n">arg2</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>Action</code>和<code>Action&lt;in T1, in T2&gt;</code>是在dotnet 3.5 sp1出现的一个很实用的委托, 类似的还有1-16个参数的, 这里主要使用这2种.</p>

<p><code>Predicate</code>是从dotnet 2.0就出现的, 一般是在泛型集合的查询中使用.</p>

<p><code>Func&lt;in T1, in T2, out TResult&gt;</code>也是dotnet 3.5 sp1出现的, 和<code>Action</code>基本一样, 也有1-16个参数的, 和Action不同的是这个委托都声明有返回值类型, 而不是<code>Action</code>的void.</p>

<!-- more -->


<h2>最初的写法</h2>

<p>最简单的<code>Action</code></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">Action</span> <span class="n">foo</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Action</span><span class="p">(</span><span class="n">Foo</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">static</span> <span class="k">void</span> <span class="nf">Foo</span><span class="p">()</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="c1">// ...</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>对于复杂的委托, 比如<code>Func</code></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">Func</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;</span> <span class="n">foo</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Func</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;(</span><span class="n">Foo</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">static</span> <span class="kt">bool</span> <span class="nf">Foo</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">,</span> <span class="kt">string</span> <span class="n">s</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="c1">// ...</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2>匿名委托</h2>

<p>和上一个区别就是不需要创建<code>Foo</code>方法了</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">Action</span> <span class="n">foo</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Action</span><span class="p">(</span><span class="k">delegate</span><span class="p">()</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="c1">// ...</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>Predicate</code>就是这样的</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">Predicate</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;</span> <span class="n">foo</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Predicate</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;(</span><span class="k">delegate</span><span class="p">(</span><span class="kt">string</span> <span class="n">s</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="k">false</span><span class="p">;</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p>右边的<code>new xxxx()</code> 可以省略</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">Action</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">&gt;</span> <span class="n">foo</span> <span class="p">=</span> <span class="k">delegate</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">,</span> <span class="kt">string</span> <span class="n">s</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="c1">// ...</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>由于也是一行代码, 结尾的分号还是必须的.</p>

<p>也适用于<strong>最初的写法</strong></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">Func</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;</span> <span class="n">foo</span> <span class="p">=</span> <span class="n">Foo</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">static</span> <span class="kt">bool</span> <span class="nf">Foo</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">,</span> <span class="kt">string</span> <span class="n">s</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="c1">// ...</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>如果使用的是dotnet 4的编译器, 可以使用<code>var</code>, 看起来就像是颠倒过来了</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="kt">var</span> <span class="n">foo</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Func</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;(</span><span class="k">delegate</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">,</span> <span class="kt">string</span> <span class="n">s</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="k">false</span><span class="p">;</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>var</code>是编译器提供的<strong>魔法</strong>, 会自动推导<code>=</code>右边的类型, 当然前提是右边的可以推导出来类型, 无法推导出来就会编译错误.</p>

<h2>Lambda登场</h2>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">Action</span> <span class="n">foo</span> <span class="p">=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;hello, world&quot;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="n">Action</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">&gt;</span> <span class="n">foo</span> <span class="p">=</span> <span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">s</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">i</span> <span class="p">+</span> <span class="n">s</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="n">Predicate</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;</span> <span class="n">foo</span> <span class="p">=</span> <span class="n">s</span> <span class="p">=&gt;</span> <span class="n">s</span><span class="p">.</span><span class="n">startsWith</span><span class="p">(</span><span class="s">&quot;bar&quot;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="n">Func</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;</span> <span class="n">foo</span> <span class="p">=</span> <span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">s</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="n">s</span><span class="p">.</span><span class="n">Length</span> <span class="p">&lt;</span> <span class="n">i</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure>


<p>语法方面, 无参数要写成<code>()</code>, 1个参数可以省略括号, 2个及更多参数则必须括号<code>()</code>; <code>=&gt;</code> 右边必须有表达式; 表达式结果必须是委托的返回值类型, 如果委托返回值类型是void则无所谓表达式结果类型.</p>

<p>Lambda也算是编译器魔法, 上述Lambda表达式特点都是左边的委托类型明确, 即委托的参数, 返回值也是明确的, 和<code>var</code>相似, 类型是可推导出来的, 那么就可以使用Lambda, 这样就省了写一堆的参数类型和return语句.</p>

<p>实际使用中可能是这样的</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">List</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;</span> <span class="n">list</span> <span class="p">=</span> <span class="k">new</span> <span class="n">List</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;();</span>
</span><span class='line'><span class="c1">// ...</span>
</span><span class='line'>
</span><span class='line'><span class="n">list</span><span class="p">.</span><span class="n">FindAll</span><span class="p">(</span><span class="n">s</span> <span class="p">=&gt;</span> <span class="n">s</span><span class="p">.</span><span class="n">startsWith</span><span class="p">(</span><span class="s">&quot;bar&quot;</span><span class="p">));</span>
</span></code></pre></td></tr></table></div></figure>


<p>即除了声明变量, 参数是明确的委托类型时, 也可以使用Lambda.</p>

<p>Lambda的<code>=&gt;</code>右边也可以是多行代码</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">Func</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;</span> <span class="n">foo</span> <span class="p">=</span> <span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">s</span><span class="p">)</span> <span class="p">=&gt;</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="k">false</span><span class="p">;</span>
</span><span class='line'><span class="p">};</span>
</span><span class='line'>
</span><span class='line'><span class="n">ThreadPool</span><span class="p">.</span><span class="n">QueueUserWorkItem</span><span class="p">(</span><span class="n">o</span> <span class="p">=&gt;</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="c1">// ...</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<h2>委托可以叠加</h2>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">Action</span> <span class="n">foo</span><span class="p">;</span>
</span><span class='line'><span class="c1">// ...</span>
</span><span class='line'><span class="n">foo</span> <span class="p">+=</span> <span class="p">()=&gt;</span> <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;bar&quot;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="n">Func</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;</span> <span class="n">foo</span>
</span><span class='line'><span class="c1">// ...</span>
</span><span class='line'><span class="n">foo</span> <span class="p">+=</span> <span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">s</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="n">s</span><span class="p">.</span><span class="n">Length</span> <span class="p">&lt;</span> <span class="n">i</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure>


<p>执行时会按照先加先执行的顺序, 如果有返回值, 那么将使用最后加进来的委托的返回值.</p>

<p>同样也可以从叠加的里面减去, 不过这里是按引用, 所以需要保留一个加进去的委托引用.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">Action</span> <span class="n">foo</span><span class="p">;</span>
</span><span class='line'><span class="c1">// ...</span>
</span><span class='line'><span class="n">Action</span> <span class="n">bar</span> <span class="p">=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;foo&quot;</span><span class="p">);</span>
</span><span class='line'><span class="n">foo</span><span class="p">+=</span><span class="n">bar</span><span class="p">;</span>
</span><span class='line'><span class="c1">// ...</span>
</span><span class='line'><span class="n">foo</span><span class="p">-=</span><span class="n">bar</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure>


<h3>事件</h3>

<p>C#提供了一个<code>event</code>关键字用于声明一种特殊的委托, 可以在类外部<code>+=</code> <code>-=</code>, 但是执行委托只能在内部</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="k">event</span> <span class="n">EventHandle</span> <span class="n">Foo</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="k">void</span> <span class="nf">Bar</span><span class="p">()</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">Foo</span> <span class="p">+=</span> <span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span> <span class="p">=</span> <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;Foo Event&quot;</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">void</span> <span class="nf">Bar2</span><span class="p">()</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">Foo</span><span class="p">(</span><span class="k">new</span> <span class="kt">object</span><span class="p">(),</span> <span class="n">EventArgs</span><span class="p">.</span><span class="n">Empty</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>默认的事件实现中<code>+=</code> <code>-=</code>是线程安全的, 这点可以在反编译<code>event</code>的源码中看到, 如果要自行实现<code>event</code>的<code>+=</code> <code>-=</code>则需要自行处理线程安全.</p>

<h2>总结</h2>

<p>使用委托可以避免创建太多的中间方法, 而使用Lambda, 则可以使在写委托的时候避免大量的<code>delegate</code>关键字和重复的委托参数类型声明.</p>

<p>也许会让代码不是很容易理解, 但是只要遵循一些约定, 熟悉了还是没关系的.</p>

<p>重要的是这会少写很多重复的东西, 同样修改时也少修改一些东西.</p>

<h2>参考链接</h2>

<ul>
<li><a href="http://msdn.microsoft.com/zh-cn/library/aa664629%28v=vs.71%29">C# 语言规范 1.10 委托</a></li>
<li><a href="http://msdn.microsoft.com/zh-cn/library/ms173171%28v=vs.80%29.aspx">委托（C# 编程指南）</a></li>
<li><a href="http://msdn.microsoft.com/zh-cn/library/900fyy8e%28v=vs.80%29.aspx">委托（C# 参考）</a></li>
<li><a href="http://msdn.microsoft.com/zh-cn/library/x53a06bb%28v=vs.80%29.aspx">C# 关键字</a></li>
<li><a href="http://msdn.microsoft.com/zh-cn/library/bb397687.aspx">Lambda 表达式（C# 编程指南）</a></li>
<li><a href="http://msdn.microsoft.com/en-us/library/bfcke1bz">Predicate<T> Delegate</a></li>
<li><a href="http://msdn.microsoft.com/en-us/library/bb549311">Action&lt;T1, T2> Delegate</a></li>
<li><a href="http://msdn.microsoft.com/en-us/library/system.action">Action Delegate</a></li>
<li><a href="http://msdn.microsoft.com/en-us/library/bb534647">Func&lt;T1, T2, TResult> Delegate</a></li>
</ul>


      <p><a href="http://netwjx.github.com/blog/2012/05/19/csharp-delegate-and-lambda/#comments">查看评论</a></p>]]></content>
  </entry>
  
</feed>