/**
 *
 * @author 
 *
 */
class Base64Util {
    public constructor() {
    }

    public static BASE64_CHARS:string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

        public static version:string = "1.0.0";

        public static encode(data:string):string {
            // Convert string to ByteArray
            var bytes: egret.ByteArray = new egret.ByteArray();
            bytes.writeUTFBytes(data);

            // Return encoded ByteArray
            return this.encodeByteArray(bytes);
        }

        private static encodeByteArray(data:egret.ByteArray):string {
            // Initialise output
            var output:string = "";

            // Create data and output buffers
            var dataBuffer:Array<any>;
            var outputBuffer:Array<any> = new Array(4);

            // Rewind ByteArray
            data.position = 0;

            // while there are still bytes to be processed
            while (data.bytesAvailable > 0) {
                // Create new data buffer and populate next 3 bytes from data
                dataBuffer = new Array();
                for (var i:number = 0; i < 3 && data.bytesAvailable > 0; i++) {
                    dataBuffer[i] = data.readUnsignedByte();
                }

                // Convert to data buffer Base64 character positions and 
                // store in output buffer
                outputBuffer[0] = (dataBuffer[0] & 0xfc) >> 2;
                outputBuffer[1] = ((dataBuffer[0] & 0x03) << 4) | ((dataBuffer[1]) >> 4);
                outputBuffer[2] = ((dataBuffer[1] & 0x0f) << 2) | ((dataBuffer[2]) >> 6);
                outputBuffer[3] = dataBuffer[2] & 0x3f;

                // If data buffer was short (i.e not 3 characters) then set
                // end character indexes in data buffer to index of '=' symbol.
                // This is necessary because Base64 data is always a multiple of
                // 4 bytes and is basses with '=' symbols.
                for (var j:number = dataBuffer.length; j < 3; j++) {
                    outputBuffer[j + 1] = 64;
                }

                // Loop through output buffer and add Base64 characters to 
                // encoded data string for each character.
                for (var k:number = 0; k < outputBuffer.length; k++) {
                    output += this.BASE64_CHARS.charAt(outputBuffer[k]);
                }
            }

            // Return encoded data
            return output;
        }

        public static decode(data:string):string {
            // Decode data to ByteArray
            var bytes:egret.ByteArray = this.decodeToByteArray(data);

            // Convert to string and return
            return bytes.readUTFBytes(bytes.length);
        }

        private static decodeToByteArray(data:String):egret.ByteArray {
            // Initialise output ByteArray for decoded data
            var output:egret.ByteArray = new egret.ByteArray();

            // Create data and output buffers
            var dataBuffer:Array<any> = new Array(4);
            var outputBuffer: Array<any> = new Array(3);

            // While there are data bytes left to be processed
            for (var i:number = 0; i < data.length; i += 4) {
                // Populate data buffer with position of Base64 characters for
                // next 4 bytes from encoded data
                for(var j: number = 0; j < 4 && i + j < data.length; j++) {
                    dataBuffer[j] = this.BASE64_CHARS.indexOf(data.charAt(i + j));
                }

                // Decode data buffer back into bytes
                outputBuffer[0] = (dataBuffer[0] << 2) + ((dataBuffer[1] & 0x30) >> 4);
                outputBuffer[1] = ((dataBuffer[1] & 0x0f) << 4) + ((dataBuffer[2] & 0x3c) >> 2);        
                outputBuffer[2] = ((dataBuffer[2] & 0x03) << 6) + dataBuffer[3];

                // Add all non-padded bytes in output buffer to decoded data
                for(var k: number = 0; k < outputBuffer.length; k++) {
                    if (dataBuffer[k+1] == 64) break;
                    output.writeByte(outputBuffer[k]);
                }
            }

            // Rewind decoded data ByteArray
            output.position = 0;

            // Return decoded data
            return output;
        }
}

node配置

app.all('*', function(req, res, next) {
    res.header("Access-Control-Allow-Origin", "*");
    res.header('Access-Control-Allow-Methods', 'PUT, GET, POST, DELETE, OPTIONS');
    res.header("Access-Control-Allow-Headers", "X-Requested-With");
    res.header('Access-Control-Allow-Headers', 'Content-Type');
    next();
});

在开发或调试Node.js应用程序的时候，当你修改js文件后，总是要按下CTRL+C终止程序，然后再重新启动，即使是修改一点小小的参数，也总是要不断地重复这几个很烦人的操作。有没有办法做到当文件修改之后，Node.js自动重新启动（或重新加载文件）以节省时间呢？一开始我是想到用grunt的watch模块来监控文件变化，但后来在网上一查，原来我们想到的，别人早已想到，并且已经做得很好。Node Supervisor正是这样一个可以实现这种需求的Node.js模块。

根据Github上的说明，Node Supervisor原本是用于服务器上Node.js应用崩溃的时候，自己重新启动。当然它也可以监控你的项目的js（或CoffeeScript）文件变化，进而重启来方便我们调试应用程序。

安装方法（以全局模块安装）：

假设你的Node.js程序主入口是app.js，那么只需要执行以下命令，即可开始监控文件变化。

Supervisor还支持多种参数，列举如下：

例子：

实现同样功能的类似产品还有Run.js和Nodeman，这两个我都没用过。但是从文档上来看，前者和Supervisor一样都是极简的5分钟就可以上手的那种，功能比Supervisor稍弱；后者的feature比较多，对应的文档就特别长，估计要研究透也得至少半个小时。选择哪一个，全看项目需求和个人喜好。

2016-11-08

猎杀野蛮人——片子虽然题材不新颖，问题少年浪子回头，但是故事讲得轻松愉悦，有新意，没有大段的煽情。
时间规划局

import urllib.request,os,hashlib; h = 'df21e130d211cfc94d9b0905775a7c0f' + '1e3d39e33b79698005270310898eea76'; pf = 'Package Control.sublime-package'; ipp = sublime.installed_packages_path(); urllib.request.install_opener( urllib.request.build_opener( urllib.request.ProxyHandler()) ); by = urllib.request.urlopen( 'http://packagecontrol.io/' + pf.replace(' ', '%20')).read(); dh = hashlib.sha256(by).hexdigest(); print('Error validating download (got %s instead of %s), please try manual install' % (dh, h)) if dh != h else open(os.path.join( ipp, pf), 'wb' ).write(by)

或手动安装：

下载文件：Package Control.sublime-package，置于Installed Packages/目录。

突然发现一个非常严重的问题，安装好Package Control之后却无法使用，坑坑坑。。。

解决方法：

    打开Preference/Settings-User ，发现     "ignored_packages": 

        [



    Package Control

    ] Package Control竟然被ignore了。。。。 

删除即可。

最近想学习下Html5游戏开发，了解了几个H5游戏引擎，Egret、Cocos2d-js，PharseJs、LayaAir，用哪一种的开发者都有，各有各的优势，各有各的坑。

于是初步看了Egret和Cocos-Js，Egret是用TS（typescript，微软出的一个语言）来开发，然后编译成js的，核心也是由js开发的，对于html5的支持很好，开发html5游戏效率和性能也是很高的;Cocos-Js的母体语言是C++，通过js binding实现H5，从性能上不如Egret，但它对于Native的支持则比Egret强。从开发的角度来看Cocos-js坑很多，很多问题需要修改底层源码，Egret的Bug也不少，开发轻量级的PC Html5游戏自然没有问题，只是对Native的效率还不够。

UIAlertController集合了AlertView和ActionSheet

Alert：

let msgBox:UIAlertController = UIAlertController(title: "Tips", message: "Select "+account_name_arr[indexPath.row], preferredStyle: UIAlertControllerStyle.Alert);
        msgBox.addAction(UIAlertAction(title: "OK", style: .Default, handler: {(action:UIAlertAction)->Void in
            print("->OK")
        }))
msgBox.addAction(UIAlertAction(title: "Cancel", style: .Cancel, handler: {(action:UIAlertAction)->Void in        
        msgBox.addAction(UIAlertAction(title: "Cancel", style: .Cancel, handler: {(action:UIAlertAction)->Void in
            print("->Cancel")
        }))
self.presentViewController(msgBox, animated: true, completion: nil)  

ActionSheet：

let choose_ac:UIAlertController = UIAlertController(title: "提示", message: "添加类型", preferredStyle: .ActionSheet)
        choose_ac.addAction(UIAlertAction(title: "账号", style: UIAlertActionStyle.Default, handler: {(action:UIAlertAction)->Void in
            print("->OK1")
            self.initData()
        }))
        choose_ac.addAction(UIAlertAction(title: "银行卡", style: UIAlertActionStyle.Default, handler: {(action:UIAlertAction)->Void in
            print("->OK2")
        }))
        choose_ac.addAction(UIAlertAction(title: "取消", style: UIAlertActionStyle.Cancel, handler: {(action:UIAlertAction)->Void in
            print("->OK2")
        }))
        self.presentViewController(choose_ac, animated: true, completion: nil)

转自：https://zhongsp.gitbooks.io/typescript-handbook/content/

介绍

除了传统的面向对象继承方式，还流行一种通过可重用组件创建类的方式，就是联合另一个简单类的代码。 你可能在Scala等语言里对mixins及其特性已经很熟悉了，但它在JavaScript中也是很流行的。

混入示例

下面的代码演示了如何在TypeScript里使用混入。 后面我们还会解释这段代码是怎么工作的。

// Disposable Mixin class Disposable {
    isDisposed: boolean;
    dispose() { this.isDisposed = true;
    }

} // Activatable Mixin class Activatable {
    isActive: boolean;
    activate() { this.isActive = true;
    }
    deactivate() { this.isActive = false;
    }
} class SmartObject implements Disposable, Activatable { constructor() {
        setInterval(() => console.log(this.isActive + " : " + this.isDisposed), 500);
    }

    interact() { this.activate();
    } // Disposable isDisposed: boolean = false;
    dispose: () => void; // Activatable isActive: boolean = false;
    activate: () => void;
    deactivate: () => void;
}
applyMixins(SmartObject, [Disposable, Activatable]); let smartObj = new SmartObject();
setTimeout(() => smartObj.interact(), 1000); //////////////////////////////////////// // In your runtime library somewhere //////////////////////////////////////// function applyMixins(derivedCtor: any, baseCtors: any[]) {
    baseCtors.forEach(baseCtor => { Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
            derivedCtor.prototype[name] = baseCtor.prototype[name];
        });
    });
} 

理解这个例子

代码里首先定义了两个类，它们将做为mixins。 可以看到每个类都只定义了一个特定的行为或功能。 稍后我们使用它们来创建一个新类，同时具有这两种功能。

// Disposable Mixin class Disposable {
    isDisposed: boolean;
    dispose() { this.isDisposed = true;
    }

} // Activatable Mixin class Activatable {
    isActive: boolean;
    activate() { this.isActive = true;
    }
    deactivate() { this.isActive = false;
    }
} 

下面创建一个类，结合了这两个mixins。 下面来看一下具体是怎么操作的：

class SmartObject implements Disposable, Activatable { 

首先应该注意到的是，没使用extends而是使用implements。 把类当成了接口，仅使用Disposable和Activatable的类型而非其实现。 这意味着我们需要在类里面实现接口。 但是这是我们在用mixin时想避免的。

我们可以这么做来达到目的，为将要mixin进来的属性方法创建出占位属性。 这告诉编译器这些成员在运行时是可用的。 这样就能使用mixin带来的便利，虽说需要提前定义一些占位属性。

// Disposable isDisposed: boolean = false;
dispose: () => void; // Activatable isActive: boolean = false;
activate: () => void;
deactivate: () => void; 

最后，把mixins混入定义的类，完成全部实现部分。

applyMixins(SmartObject, [Disposable, Activatable]); 

最后，创建这个帮助函数，帮我们做混入操作。 它会遍历mixins上的所有属性，并复制到目标上去，把之前的占位属性替换成真正的实现代码。

function applyMixins(derivedCtor: any, baseCtors: any[]) {
    baseCtors.forEach(baseCtor => { Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
            derivedCtor.prototype[name] = baseCtor.prototype[name];
        })
    });
}

转自：https://zhongsp.gitbooks.io/typescript-handbook/content/

三斜线指令是包含单个XML标签的单行注释。 注释的内容会做为编译器指令使用。

三斜线指令仅可放在包含它的文件的最顶端。 一个三斜线指令的前面只能出现单行或多行注释，这包括其它的三斜线指令。 如果它们出现在一个语句或声明之后，那么它们会被当做普通的单行注释，并且不具有特殊的涵义。

/// <reference path="..." />

/// <reference path="..." />指令是三斜线指令中最常见的一种。 它用于声明文件间的依赖。

三斜线引用告诉编译器在编译过程中要引入的额外的文件。

当使用--out或--outFile时，它也可以做为调整输出内容顺序的一种方法。 文件在输出文件内容中的位置与经过预处理后的输入顺序一致。

预处理输入文件

编译器会对输入文件进行预处理来解析所有三斜线引用指令。 在这个过程中，额外的文件会加到编译过程中。

这个过程会以一些根文件开始； 它们是在命令行中指定的文件或是在tsconfig.json中的"files"列表里的文件。 这些根文件按指定的顺序进行预处理。 在一个文件被加入列表前，它包含的所有三斜线引用都要被处理，还有它们包含的目标。 三斜线引用以它们在文件里出现的顺序，使用深度优先的方式解析。

一个三斜线引用路径是相对于包含它的文件的，如果不是根文件。

错误

引用不存在的文件会报错。 一个文件用三斜线指令引用自己会报错。

使用 --noResolve

如果指定了--noResolve编译选项，三斜线引用会被忽略；它们不会增加新文件，也不会改变给定文件的顺序。

/// <reference no-default-lib="true"/>

这个指令把一个文件标记成默认库。 你会在lib.d.ts文件和它不同的变体的顶端看到这个注释。

这个指令告诉编译器在编译过程中不要包含这个默认库（比如，lib.d.ts）。 这与在命令行上使用--noLib相似。

还要注意，当传递了--skipDefaultLibCheck时，编译器只会忽略检查带有/// <reference no-default-lib="true"/>的文件。

/// <amd-module />

默认情况下生成的AMD模块都是匿名的。 但是，当一些工具需要处理生成的模块时会产生问题，比如r.js。

amd-module指令允许给编译器传入一个可选的模块名：

amdModule.ts

///<amd-module name='NamedModule'/> export class C {
} 

这会将NamedModule传入到AMD define函数里：

amdModule.js

define("NamedModule", ["require", "exports"], function (require, exports) { var C = (function () { function C() {
        } return C;
    })();
    exports.C = C;
}); 

/// <amd-dependency />

注意：这个指令被废弃了。使用import "moduleName";语句代替。

/// <amd-dependency path="x" />告诉编译器有一个非TypeScript模块依赖需要被注入，做为目标模块require调用的一部分。

amd-dependency指令也可以带一个可选的name属性；它允许我们为amd-dependency传入一个可选名字：

/// <amd-dependency path="legacy/moduleA" name="moduleA"/> declare var moduleA:MyType
moduleA.callStuff() 

生成的JavaScript代码：

define(["require", "exports", "legacy/moduleA"], function (require, exports, moduleA) {
    moduleA.callStuff()
});