第一个原因是如果新写的代码改用haXe，新写的代码依赖于部分AS代码，而另一部分AS代码又会依赖于haXe，那么就会导致循环依赖。虽然有办 法可以解决，但是每种解决方案都有代价，要么是把现有AS代码拆成两部分来编译，要么是用 ApplicationDomain.getDefinition之类的字符串解耦合办法。这些办法都不是我想要的。

第二个原因在于haXe用的全局变量flash.Lib.current. 把一段haXe代码编译成SWC或者SWF，分别作为静态库和动态库使用时，会有微妙的差异（参见http://haxe.org/doc/advanced/swc）。 而我如果想要在开发期间缩短编译时间，必须要把haXe部分编译成动态链接的SWF。这个问题体现了“全局变量的邪恶性”。全局变量之所以邪恶在于其“全 局”概念的不可控，在模块角度看是全局的东西，到了装载器的角度来看就有时候是而有时候不是了，就会导致行为不一致。

主流的flash开发工具当然是Flex Builder/Flex SDK/Flash创作工具。一般用Flash创作工具生成素材，用Flex SDK来编译代码，喜欢IDE环境的就用用Flex Builder。但除此之外，还有一些非主流的开发工具选择。

现在能生成flash的编译器已经有很多了，真的不必拘泥于龟一般的mxmlc. 前一篇文章，我介绍了haXe。除此之外，另一个选择是swftools中的as3compile，这个编译器号称是要兼容mxmlc，不过就我目前测试的情况来看，它有一个缺陷，即不支持闭包中访问upvalue。

当然我不认为mxmlc慢是因为它用了Java，javac也是Java写的，快得很呢。

由于AVM开源了，还可以用AVM开源后提供的编译器，AVM开源后的项目名叫做Tamarin，源码在这里下载。 这是一个C++编写的编译器，现在想尝尝鲜的话，可以找到Tamarin里面的utils/avmc，里面就是这个编译器。不过avmc编译出来的目标文 件是.abc，还需要包装上swf的文件头才能用，这件事情可以用前面提到的as3compile来做。比较头疼的问题在于如何引用 flashplayer的API，这些API在flex_sdk_3/frameworks/libs/player/playerglobal.swc 里面是有，要把这个playerglobal.swc导出成.abc我没试过，但应该不难。

以上是一些编译器，至于素材的制作，可以考虑swftools中swfc。和官方的Flash创作工具相比，它的优势在于源文件.sc格式是一个文本格式，工具又是命令行工具，因此易于用脚本生成代码。缺点有两个，首先是缺乏“所见即所得”编辑器，其次是一些功能缺失，比如向ActionScript导出元件。用swfc来打包素材已经足用了，我就用swfc来把一些公司自定格式的动画素材批量转换成swf格式。

1. 闭包会产生多余的引用

ActionScirpt3的闭包会引用外层函数的所有局部变量，而不仅仅只是用到的变量。这些多余的引用是不必要的。它们会使垃圾收集器认为这些数据仍然被引用着而不去释放，哪怕这些数据本来已经不可能再被用到。例如，以下代码会导致内存泄露：

package {
  import flash.display.*
  public final class C extends Sprite {
    private static function ref(f:Function):Function {
      return function():void {
      }
    }
    private var f:Function = function():void{}
    public function C() {
      for(var i:uint = 0; i < 1000000; i++) {
        f = ref(f)
      }
    }
  }
}

2. 与JavaScript的异同

ActionScript2和JavaScript一致的地方更多些，而ActionScript3则少一些，这样会迷惑很多用惯JavaScript的人，例如：
http://www.ac.net.blog.163.com/blog/static/1364905620060274329791/
http://www.ac.net.blog.163.com/blog/static/1364905620060297425813/
还有一些区别在ASDoc中也提到了，比如=== 和 == 用在Number、uint、String上时，AS2和AS3行为是不同的。

3. 编译器不检查函数返回值类型

例如，以下代码可以通过编译。

function xxx():uint {
  return 0
}
var a:Array = xxx()

4. 局部变量的范围是整个函数而不是某个区块

例如以下代码会出错：

function f(b:Boolean):void {
  if(b) {
    var a:String = "a"
  } else {
    var a:Array = []
  }
}

这一点对于闭包的使用来说，很麻烦，例如

var a:Array = []
for(var i:uint = 0; i < 10; i++) {
  a[i] = function():uint {
    return i
  }
}
trace(a[3]()) // 输出10而不是3

上述代码会trace出 10 而不是 3

5. const并不真的不可改变

更有甚者，即使你使用 const 关键字声明一个常量，实际上它还是会被改变：

var a:Array = []
for(var i:uint = 0; i < 10; i++) {
  const c:uint = i
  a[i] = function():uint {
    return c
  }
}
trace(a[3]()) // 还是输出10而不是3

6. setTimeout不自动释放对闭包的引用

ASDoc中的的文档有下面这句话：
If you intend to use the clearTimeout() method to cancel the setTimeout() call, be sure to assign the setTimeout() call to a variable (which the clearTimeout() function will later reference). If you do not call the clearTimeout() function to cancel the setTimeout() call, the object containing the set timeout closure function will not be garbage collected.
意思是说，如果是说可以用clearTimeout来取消setTimeout设置的定时器。让人觉得言下之意是，如果不想取消定时器，不调用 clearTimeout也可以。实际上，如果不调用clearTimeout，就会导致内存泄露。setTimeout并不自动释放对闭包的引用。

对数据结构或接口来说，如果能轻易地分辨出哪些数据不会改变，哪些数据可能会改变，以及谁可能改变这些数据，就会非常有用。以上可借助语言的类型系统做到。数据可以被标记为const或immutable，而其默认是可变的（即mutable ） 。

不 可改变的数据可以用immutable表示。immutable数据构建之后，在程序整个运行期间都会保持原值。immutable数据可以放在 ROM（只读存储器）中或者由硬件设为只读的内存中。由于immutable数据不会改变，所以可以得到许多程序优化的机会，还可便于采用函数式编程。

const适用于不能通过引用本身改变数据的引用。不过，这块数据还时可能被其他引用所改变。若向接口传入数据时需要保证该接口中不修改该数据，则应采用const。

immutable和const都是transtive（具有可传递性），这意味着通过immutable引用取得的数据同样也是immutable的，const亦是如此。

immutable存储类

immutable最简单的用法是用作存储类。可以用它来声明明确的常量。

immutable int x = 3; // 将x设为3
x = 4;   // 错误，x不可改变
char[x] s;  // s 是一个包含三个char的数组

数据类型也可以由初始化表达式推断：

immutable y = 4; // y的类型是int
y = 5;   // 错误，y不可改变

如果不写初始化表达式，相应的构造函数也可以初始化immutable数据：

immutable int z;
void test()
{
    z = 3;  // 错误，z不可改变
}
static this()
{
    z = 3;    // 正确，没有静态初始化表达式的immutable数据可以赋值
}

除了函数类的immutable数据外，其他immutable声明的初始化表达式都必须能在编译时求值：

int foo(int f) { return f * 3; }
int i = 5;
immutable x = 3 * 4;      // 正确，12
immutable y = i + 1;      // 错误，无法在编译时求值
immutable z = foo(2) + 1; // 正确，foo(2)能在编译时求得值——7

非静态的局部immutable数据的初始化表达式是在运行时计算的：

int foo(int f)
{
  immutable x = f + 1;  // 运行时求值
  x = 3;                // 错误，x不可改变
}

由于immutable数据具有可传递性，由immutable数据引用的数据也是不变的：

immutable char[] s = "foo";
s[0] = 'a';  // 错误，s指向一块不可改变的数据
s = "bar";   // 错误，s不可改变

immutable声明可以作为左值出现，比如它们的地址都是可以获取到的，再如它们会占据存储空间。

const存储类

除了以下区别之外，以const声明的数据和immutable的完全相同：

• 不能通过const声明来修改它所引用的数据，但这块数据还是可能被指向该数据的其他引用所修改。
• const声明自身也是const的。

immutable类型

一定不会被改变的数据可以标记为immutable。immutable关键字可以被用作type constructor:

immutable(char)[] s = "hello";

括号中的类型被标记为immutable。因此，一方面，s能被设为新的值，另一方面，s[]的内容却不能被改变：

s[0] = 'b';  // 错误，s[]不可改变
s = null;    // 正确，s自身并不是immutable的

immutable具有可传递性，这意味着被immutable类型引用的数据也是immutable的：

immutable(char*)** p = ...;
p = ...;        // 正确，p可以改变
*p = ...;       // 正确，*p可以改变
**p = ...;      // 错误，**p不可改变
***p = ...;     // 错误，***p不可改变

把immutable用作存储类相当于把immutable用作整个声明类型的type constructor：

immutable int x = 3;   // x的类型是immutable(int)
immutable(int) y = 3;  // y不可改变

创建不变数据

第一种方式：使用本来就不变的字面量（literal），比如字符串字面量。字符串字面量始终都是immutable的。

auto s = "hello";   // s的类型是immutable(char)[5]
char[] p = "world"; // 错误，immutable类型不能隐式转换为非immutable类型。

第二种方式是把数据转换为immutable。这样做时，需要由程序员确保不存在其他的对该块数据的可变引用。

char[] s = ...;
immutable(char)[] p = cast(immutable)s;     // 未定义行为
immutable(char)[] p = cast(immutable)s.dup; // 正确，只存在一个引用

使用.idup属性，可以便利的创建某个数组的不变副本。

auto p = s.idup;
p[0] = ...;   // 错误，p[]不可改变

通过转换移除immutable

immutable类型可通过强制转换而被移除。

immutable int* p = ...;
int* q = cast(int*)p;

不过，这并不意味着可以修改这块数据。

*q = 3; // 编译通过，但结果会导致未定义行为

在有些情况下，强制抹除不变性是必要的。比如涉及某个不能更改的库，而库中的静态类型并不正确。有史以来，强制转换一直很直接很有效。使用强制转换抹除不变性时，必须要承担保证数据不变的责任，因为它已经不再由编译器静态保证了。

immutable成员函数

immutable成员函数表示this以及被this引用的任何数据都是不变的。可以这样声明：

struct S
{   int x;

    immutable void foo()
    {
 x = 4;     // 错误，x不可改变
 this.x = 4; // 错误，x不可改变
    }

函数的const和immutable属性也可以写在参数列表的右括号之后：

struct S
{
    void bar() immutable
    {
    }
}

const类型

const类型和immutable类型类似，唯一的区别在于const建立的是数据的只读视图。数据本身随时可能被其他引用了该数据的变量所修改。

const成员函数

在const成员函数中，不允许通过该函数的this指针改变对象任何部分的数据。

隐式转换

immutable和非immutable类型都可以隐式转换为const类型。非immutable类型不能隐式转换为immutable类型，反之亦然。

对比D和C++的immutable/const

//指向指向const int的const指针的指针
const(int*)* p;

//指向指向const int的const指针的指针
const int *const *p;

//指向指向const int的const指针的const指针
const int** p;
**p = 3; // 错误

//指向指向int的指针的const指针
int** const p;
**p = 3;    // 通过

// 指向const int的指针
const(int)* p;
int* q = cast(int*)p; // ok

// 指向const int的指针

const int* p;
int* q = const_cast<int*>p; //ok

// 指向const int的指针
const(int)* p;
int* q = cast(int*)p;
*q = 3;   // 未定义行为

// 指向const int的指针
const int* p;
int* q = const_cast<int*>p;
*q = 3;   // 通过

void foo(int x);
void foo(const int x);  //正确

void foo(int x);
void foo(const int x);  //错误

void foo(const int* x, int* y)
{
   bar(*x); // bar(3)
   *y = 4;
   bar(*x); // bar(4)
}
...
int i = 3;
foo(&i, &i);

void foo(const int* x, int* y)
{
   bar(*x); // bar(3)
   *y = 4;
   bar(*x); // bar(4)
}
...
int i = 3;
foo(&i, &i);

void foo(immutable int* x, int* y)
{
   bar(*x); // bar(3)
   *y = 4;  // 未定义行为
   bar(*x); // bar(??)
}
...
int i = 3;
foo(cast(immutable)&i, &i);

#!/bin/bash
(
 find .  -iname '*.TGA' -exec echo '
  (let ((image (car (file-tga-load 1 "{}" "{}"))))
   (file-png-save-defaults 1 image (car (gimp-image-get-active-drawable image)) "{}.png" "{}.png")
   (gimp-image-delete image)
  )
 ' \;
 echo '(gimp-quit 1)'
) | gimp-console -d -i -b -

print(unpack(t))

for key, value  in pairs(t) do
      print(key, value)
end

local function _iterator_unpack_i(i, f, s, var1, ...)
      if var1 == nil then
            return
      else
            return select(i, var1, ...), _iterator_unpack_i(i, f, s,f(s, var1))
      end
end
local function iterator_unpack_i(i, f, s, var)
      return _iterator_unpack_i(i, f, s, f(s, var))
end


local function _iterator_unpack_f(formatstring, f, s, var1, ...)
      if var1 == nil then
            return
      else
            return format(formatstring, var1, ...), _iterator_unpack_f(formatstring, f, s,f(s, var1))
      end
end
local function iterator_unpack_f(formatstring, f, s, var)
      return _iterator_unpack_f(formatstring, f, s, f(s, var))
end


local function keys(t)
      return iterator_unpack_i(1, pairs(t))
end

local function values(t)
      return iterator_unpack_i(2, pairs(t))
end

print(keys(t))

print(values(t))

print(iterator_unpack_f("%s=%s", pairs(t)))

类似昨天的例子，用递归的实现在参数较少时比用临时表快，而且没有堆内存分配

function f(...)
     print("a", ...)
     print(..., "a")
end
f("1", "2")

a 1 2
1 a

local tinsert = table.insert
local function append(x, ...)
        local t = {...}
        tinsert(t, x)
        return unpack(t)
end

local function append(x, arg1, ...)
        if arg1 == nil then
                return x
        else
                return arg1, append(x, ...)
        end
end