TYPHONE

Proxy: getProperty and setProperty

2007-08-12T11:15:00.000+08:00

getProperty and setProperty are methods used in Proxy classes that are used to manage property access. When a property not defined within a proxy instance is retrieved, getProperty is called to retrieve it. When set, setProperty is used to set it.

As with all methods of the Proxy class, getProperty and setProperty are defined within the flash_proxy namespace (flash.utils.flash_proxy) to prevent conflicts with public. When you override these methods within your own Proxy subclasses, you will want to be sure to use the flash_proxy namespace.

The following example, CustomObject, extends Proxy and uses getProperty and setProperty to manage dynamic properties set for its instances.

ActionScript Code:

package {

import flash.utils.Proxy;
import flash.utils.flash_proxy;

dynamic public class CustomObject extends Proxy {

public var classProperty:String = "classProperty"; // generic class variable
private var customProperties:Object = new Object(); // store custom variables

public function CustomObject() {
}

// called when getting dynamic variables
override flash_proxy function getProperty(name:*):* {
if (name in customProperties) {
return customProperties[name];
}
return "Property does not exist";
}
// called when setting dynamic variables
override flash_proxy function setProperty(name:*, value:*):void {
customProperties[name] = "Property "+name+": "+value;
}
}
}

ActionScript Code:

// usage example
var myObj:CustomObject = new CustomObject();
trace(myObj.foo); // Property does not exist
myObj.foo = "bar";
trace(myObj.foo); // Property foo: bar

trace(myObj.classProperty); // classProperty
myObj.classProperty = "bar";
trace(myObj.classProperty); // bar

Notice that when getting and setting the foo property, getProperty and setProperty are used to control its ultimate value which is stored within a customProperties defined for the class. Also, since classProperty is not a dynamic variables, instead being one defined for the class, getProperty and setProperty to not apply.

Design Pattern: Bridge 模式

2007-08-11T19:23:00.000+08:00

在 Gof 的書中指到Bridge模式的目的：「將抽象部份與它的實現部份分離，使它們都可以獨立地變化。」

這句話寫得簡短，這邊再作進一步的解釋，抽象部份指的是行為方面定義，實現方面指的是與特定平台相依的代碼實現。

一個實際的例子在Gof書中有提到，假設您定義了一個IWindo介面，這個介面只定義一些抽象的繪圖行為，而不涉及平台的實作，今天您可以繼承這個類來開發適用於X Windo的XWindow類，也可以繼承這個類來開發適用於Windows X系統的WindowsXP類，為了善用系統資源，您在實作IWindow介面時，會將與系統相關的實現代碼撰寫在介面的實作中。

假設今天您繼承了IWindow介面撰寫了一個I3DWindo介面，當中擴充一個drawBox()方法用於3圖形的繪製，簡單的說， I3DWindo介面擴充了抽象行為，為了讓實現I3DWindow的類別也能在XWindow與Windows XP兩個不同的系統中運行，您必須再度撰寫與系統相關的實現代碼。

簡單的說，抽象行為定義與平台相關實現混雜在一起了，為了將抽象部份與它的實現部份分離，使它們都可以獨立地變化，您可以使用以下的結構。

在上圖的右邊中，與平台相關的實現部份，被與右邊抽象行方面的發展分開了，左邊的抽象部份您可以一直發展下去，而不再因為綁定了平台特定實作方法，而使得整個結構越來越失去彈性。

Bridge模式UML 類別結構圖如下

in Operator

2007-08-11T18:49:00.000+08:00

The in operator (in operator) is a new operator in ActionScript 3 that is used to see if a value exists within an object. This is similar to hasOwnProperty but will also work for inherited values.

ActionScript Code:

trace("PI" in Math); // true
trace("myProperty" in Math); // false

Proxy Class

2007-06-17T22:34:00.000+08:00

ActionScript 3 introduces a new class to take the place of ActionScript 1 and ActionScript 2's addProperty method and __resolve handler for objects. This class is the Proxy Class (flash.utils.Proxy).

In ActionScript 1 and ActionScript 2:

addProperty() - used to dynamically add a getter/setter property for an object or class. This dynamically created a variable that was set and whose value was retrieved through functions passed into the addProperty call.
__resolve - a handler that, when defined for an object, would be called when a property or method was accessed that did not exist for that object. This let you capture unresolved references from an object and react accordingly

In ActionScript 3 you create a class that extends Proxy to take advantage of all its features. They include

Capturing property setting
Capturing property getting
Capturing property checking (if exists)
Capturing property deletion
Capturing method calls
Capturing decendant access
Capturing attribute checking
Handling property iteration

Though these features hold a lot of advange over what was available with AS1 and AS2, there are some drawbacks to using Proxy:

Instance typing is limited since classes need to extend Proxy; you tend to have to rely on interfaces
You cannot have Proxy classes that inherit from classes that don't already inherit from Proxy
Display objects cannot be Proxy classes

Proxy classes are generally used for variable container classes that need extra the flexibility.

The Proxy class will be covered in more detail in later tips

MXMLC: SWF Metadata Tag

2007-06-13T22:07:00.000+08:00

If you're using MXMLC (the MXML and ActionScript 3 stand alone, command line compiler provided with the free Flex 2 SDK) to compile your ActionScript 3 SWFs, you can use the SWF metadata tag to set common properties for your movie. The SWF metadata tag supports 4 properties

width
height
frameRate
backgroundColor

Example:

ActionScript Code:

package {
[SWF(width="500", height="450", frameRate="24", backgroundColor="#FFFFFF")]
public class MyApp extends Sprite {

}
}

When compiled, the above makes a SWF 500x450 in size with a background color of white and a framerate of 24.

放松下身上的壓力，很好聽的歌曲哦

2007-06-12T11:36:00.000+08:00

歌曲：夏虫

歌手：清风组合 专辑：最爱的清风~

虫儿爬在我的琴上听着乐曲轻轻响
等着音符划过脸上织出透明的情网
蛐蛐蹲在我的身旁哼着动听的声响
心中却想着明天的午餐和谁去分享
不能忘那寂寥
到少现实自己扛
多盼望放下所有奔向虫儿的家乡

虫儿飞虫儿叫虫儿追着虫儿跑
虫儿笑虫儿跳虫儿伴着我逍遥
虫儿美虫儿俏虫儿都很爱炫耀
虫儿疯虫儿闹虫儿总能感动所有煎熬

风儿停在我的身上亲吻我着的肩膀
我并不在意只是觉得它稍稍有点痒
听过虫儿你呀这个世界变的更明亮
就算乌云遮天也能看到星星的微光
不去想真荒唐
自己让自己受伤
多希望放下一切冲向虫儿的天堂

虫儿飞虫儿叫虫儿追着虫儿跑
虫儿笑虫儿跳虫儿伴着我逍遥
虫儿美虫儿俏虫儿都很爱炫耀
虫儿疯虫儿闹虫儿总能感动所有煎熬

Prevent Overriding and Subclassing with final

2007-06-11T09:29:00.000+08:00

The final keyword (Toplevel final keyword) is an attribute for classes and methods that lets you prevent overriding (methods) and subclassing (classes).

When a method is marked as final, no subclasses of that class can create a method of the same name that overrides that method. This ensures that when the method is called, it will always be the method marked final.

ActionScript Code:

final public function methodName() {
// your statements here
}

Similarly, for classes, if a class is marked final, no subclasses can be created that extend that class.

ActionScript Code:

package{
final public class ClassName {
// your statements here
}
}

Note: it is pointless to have methods marked as final in a class marked as final since that class cannot be extended. Since it cannot be extended, there would be no way for methods to be overridden as that only occurs within subclasses of the original class.

太有才了!!!

2007-06-07T15:41:00.000+08:00

Creating a mouseWithin Event

2007-06-06T11:17:00.000+08:00

There are times where you might want to have actions only run when the mouse is within a sprite or movie clip. Director's Lingo programing language has a mouseWithin event that facilitates this. Flash, however, has no such event. However, with ActionScript 3's event model, you can easily create your own.

A mouseWithin event is essentially an enterFrame event that only runs when the mouse is within or touching the display object in which its associated. So, in making your own, all you need to do is define an enterFrame event when the mouse enters the object and remove it when the mouse leaves the object. And yes, technically you could do this in ActionScript 1 and ActionScript 2, but it would mean using up event handlers like onRollOver and onEnterFrame which could interfere with other actions for your movie clip (since you can only have one per movie clip).

For ActionScript 3, implementing a mouseWithin event just means giving your sprite or movie clip class a few event handlers and setting up some listeners, e.g.

ActionScript Code:

// methods managing mouseWithin
private function addMouseWithin(event:MouseEvent):void {
addEventListener(Event.ENTER_FRAME, mouseWithin);
}
private function removeMouseWithin(event:MouseEvent):void {
removeEventListener(Event.ENTER_FRAME, mouseWithin);
}
private function mouseWithin(event:Event):void {
dispatchEvent(new MouseEvent("mouseWithin"));
}

// in constructor
public function MySpriteClass() {
addEventListener(MouseEvent.MOUSE_OVER, addMouseWithin);
addEventListener(MouseEvent.MOUSE_OUT, removeMouseWithin);
}

With that, a mouseWithin event fires every frame whenever the mouse is within the sprite. To add listeners for it, just use:

ActionScript Code:

addEventListener("mouseWithin", mouseWithinHandler);

dynamic is Not Inherited

2007-06-04T10:26:00.000+08:00

Like ActionScript 2, ActionScript 3 allows you to create dynamic classes using the dynamic keyword (dynamic keyword). Dynamic classes are classes you can add properties to dynamically without needing to declare or define them within the class definition. An example of a dynamic class would be Array. When you create an Array instance, you can assign to it any variariable you want despite it not being within the Array class definiton.

In AS2, when you extended a class that was dyanmic, that subclass too became dynamic.

ActionScript Code:

// superclass.as
dynamic class superclass {
}

// subclass.as
class subclass extends superclass {
}

// main movie
var instance:subclass = new subclass();
trace(instance.anything); // ok since subclass inherited dynamic

This is no longer the case with AS3. Subclasses of dynamic classes are no longer dynamic unless specified as being dynamic themselves

ActionScript Code:

// superclass.as
package {
dynamic class superclass {
}
}

// subclass.as
package {
class subclass extends superclass {
}
}

// main movie
var instance:subclass = new subclass();
trace(instance.anything); // error, property not defined (not dynamic)

Namespaces: Name Qualifier Operator (::)

2007-06-01T15:16:00.000+08:00

When you want to access a class member in a namespace, you need to reference that member through the namespace in which it was defined. One way to do this is through the name qualifier operator (name qualifier operator).

The name qualifier operator takes the form of two colons that connects the namespace with the member of the class you are trying to access that exists within that namespace, eg. namespace::member. Ex:

ActionScript Code:

package {

public class UsingNameSpaces {

public namespace company = "http://www.example.com/company";
public namespace individual = "http://www.example.com/individual";

company var value:int = 10;
individual var value:int = 2;

public function UsingNameSpaces(){
company::showValue(); // traces 10
individual::showValue(); // traces 2
}

company function showValue() {
trace(company::value);
}

individual function showValue() {
trace(individual::value);
}
}
}

Note that even though showValue is being called within the namespace, the namespace is still needed to reference variables (or other members) in namespaces used within the function body.

Support for Namespaces

2007-05-31T12:02:00.001+08:00

ActionScript 3 now supports namespaces. Namespaces in AS3 are similar to namespaces in XML and provide a way to separate code in to separate "spaces" or collections identifiable through a name (namespace). Namespaces in this respect act much like packages. In the same manner that packages allow you to have different classes with the same name in one application (only defined in different packages), namespaces allow you to have different methods with the same name in one class (defined in different namespaces). Though you may not have known it, chances are you've already been using namespaces. Predefined namespaces include public, private, protected, and internal.

When you use a namespace, you have to declare it just like you declare any other class member. Namespaces are declared using the namespace keyword (namespace Keyword). Once declared you can use it to separate members into different namespaces. Ex:

ActionScript Code:

package {

public class UsingNameSpaces {

public namespace company;
public namespace individual;

company var value:int = 10;
individual var value:int = 2;

public function UsingNameSpaces(){
}

company function showValue() {
}

individual function showValue() {
}
}
}

Two namespaces were used here, company and individual. They were used to defined a value variable and a showValue method - one for each namespace. Though they have the same names, since they are in different namespaces, they are allowed.

Additionally, namespaces can otionally be defined with a namespace uri when declared in the class:

ActionScript Code:

package {

public class UsingNameSpaces {

public namespace company = "http://www.example.com/company";
public namespace individual = "http://www.example.com/individual";

company var value:int = 10;
individual var value:int = 2;

public function UsingNameSpaces(){
}

company function showValue() {
}

individual function showValue() {
}
}
}

中国应借地谋势，共建“大金鸡”格局[轉]

2007-05-30T11:55:00.000+08:00

发贴者：akaaaa　2007/05/29 10:27　来源论坛：东方军事　点击：2175次　我来说两句

如果把我国的蓝色海洋国土作为背景，只看陆地国土的形状，确实象一只昂首挺立的雄鸡，屹立在世界的东方。对于这只“难鸡”，笔者收复领土联盟曾在《破局：中国地缘战略的思考》、《战略支点支撑起中国的大国雄心》等一系列帖子中作过深入的探讨，作为一个大国，中国有不可替代的优势，也有受困于人的劣势。如何发扬我国的优势，补救面临的劣势？收复领土联盟提出了借地谋势，共建“大金鸡”格局的战略构想。

此构想从周边各国战略定位的角度，探讨一下中国与部分国家实现和谐共赢之策。因本帖内容敏感，笔者曾犹豫过一段时间，怕被“有关部门”扣帽子、打棍子、抓辫子、穿小鞋，也怕被外国敌对势力用来炒作“中国威胁论”。但这仅是收复领土联盟个人的一孔之见，影响微小，实行的可能性更小。何况一旦真正实行起来，对周边国家也只有好处，没有坏处，实在没必要因噎废食。即使少数人想拿来作“中国威胁论”的论据，怕是也拿不到台面上。因此还是写出来的好。
一、“大金鸡”格局的基本构想

“大金鸡”格局的构想是，立足于中国金鸡形状的本土，并以朝鲜半岛为“鸡嘴”，以蒙古为“鸡翅”，以缅甸和越南为两条“鸡腿”或者是“鸡爪”，借助上述周边国家的地利优势，解决中国的“东北困局”和“马六甲困局”（相关论述见本人拙作），实现中国与周边国家的共同发展，共同进步，共同富裕，共同崛起。这与我国 “和平崛起”，实行“睦邻、安邻、富邻”的友好政策，与周边国家世世代代作好邻居、好伙伴、好朋友的宗旨是一脉相承的，是不以领土占有为目的的一种多边合作的构想。收复领土联盟觉得，还是先建立一个小范围的“和谐周边”作样板，再逐步开展“和谐世界”吧。但这种想法，仅是个人的一厢情愿，至于周边国家干不干，那就不好说了。收复领土联盟认为，这事急不得，慢慢来，不强求，不相逼，成熟一个，发展一个，最终周边的国家会找到各自的战略定位的。举个不恰当的例子，这事就象现在的上合组织，作为观察员国的伊朗现在就想进来，但中俄现阶段还不能答应呢！

二、周边小国应有恰当的国家战略定位

不谋全局者不足以谋一域，不谋万世者不足以谋一时。其实每个国家采取什么样的国家战略，就象一个人如何发展一样，有什么样的条件，采取什么样的方法，最终能达到何种高度成就什么样的事业，自己应该有自知之明。一个国家也应该有自知之明，应该采取最有利于自身国家发展的战略。这是关系到一个国家长远发展的战略定位、战略方向的大问题，也是关系到民族、民生福祉的大事，有关各国的当政者应当深思。

2006年上半年，巴基斯坦总统穆沙拉夫公开说，巴基斯坦今后要把本国作为中国的能源走廊和贸易走廊，实际上是作为中国进出印度洋的一个战略走廊。并说要同中国共同崛起！这是对自己国家准确的战略定位。收复领土联盟听着舒服，觉着佩服！事实上，这不但不丢人，还会极大的增强该国的战略地位和综合国力，是一举多得的好事！也是得民心，顺民意的英明、务实之举。这对于周边其他小国有很大的借鉴意义和示范作用。周边小国不要觉得那样做成了中国的“小跟班”，低人一等，矮人一头，好象有一种不平等的耻辱感，其实中国人对所有国家不分大小、强弱、贫富，都是平等相待、一视同仁的，并不会以老子国、老子党自居，不会去搞以大欺小、以强凌弱那一套的。象周边的个别国家，在历史上未能准确定位，以国力之弱，作非分之想，行非分之事，差一点就国破族亡，教训不可谓不惨痛，不可不引以为戒。

三、共同的基础、共同的利益和共同的关切是共建“大金鸡”格局的有利条件

蒙古、朝鲜、韩国、缅甸、越南都是我周边的重要邻国，具有重要的战略地位。蒙古在历史上曾是我国领土，朝鲜、韩国、缅甸、越南在历史上曾是我藩属国。蒙古族、朝鲜族、京族都是我国与周边的跨境民族，缅甸的边民与我国云南的边民有胞波情谊。应该说，中蒙朝韩缅越六国山水相连，地域相邻，历史相近，文化相通，民族相亲，风俗相似，彼此在历史上曾经长期友好交往，共存共荣，共建“大金鸡”格局有着较好的历史积淀和心理基础，有着较为有利的条件。当然这些只是共性，并且是从有利的方面来说的；虽然会面临着其他不利的因素，面临着曲折甚至反复，但为了区域共同利益，周边各国最终会走向理智、和平和合作的。

（一）朝鲜半岛：锐利的“鸡嘴”

朝鲜半岛位于亚洲大陆东北部，三面环海，海岸线曲折漫长，北与中国接壤，东北角与俄罗斯相连，西隔渤海、黄海与中国大陆相望，东隔日本海与日本列岛相邻。朝鲜半岛与我国陆海相连，是我东北地区的天然屏障，对我东北和京津地区的重要性是不言而喻的。朝鲜半岛直面日本列岛，距离日本本土非常近，且控制着日本本土南北联系的要道，战略位置十分重要。我国在朝鲜有重大的安全利益，历史上曾多次为朝鲜半岛付出过重大的代价。明朝有援朝抗倭，清朝有黄海之战、甲午之战，民国有抗日战争，建国后抗美援朝，历史已经无数次地证明：不论我国与朝鲜半岛国家间的关系如何，朝鲜半岛对于我国的安全屏障作用始终未变。朝鲜半岛国家一旦与我国形成良好的战略协作关系，则说成会我雄鸡锐利的“鸡嘴”，对于我化解美日同盟、应对外来威胁、破解东北战略困局都有着不可替代的重要作用。

朝鲜在历史上是长期是我国的属国，曾经长期使用中国汉字，同属于中华文化圈，与中国一起长期共同繁荣。直到甲午之战后，清政府与日本签订城下之盟，朝鲜在获得短暂的名义上的“独立”后，迅速亡国，二战后又分裂为两个国家，这是朝鲜半岛脱离中国后的悲惨遭遇，是个可怕的教训。

从现实方面来看，双方有共同的安全关切和战略合作的基础和条件。其一，朝、韩都是小国，两方地域狭小，难有大的发展和作为，在当今和可预见的未来，国际上丛林法则和实力论盛行，小国只能在大国的夹缝中生存，难以保持事实上的独立。朝、韩本身就是大国划分势力范围的受害者，它们二国想必体会更深。其二，朝、韩最为关切的半岛统一问题遥遥无期，未来不排除长期、甚至永久分裂下去的可能。实际上，中国在朝鲜半岛的影响力是其他大国无法双拟的，这在朝核六方会谈上已由事实作了明证。韩国在还未统一时已经漏出了森森狼牙，篡改高句丽历史，觊觎我东北领土，与朝鲜一起，在黄海划界上与我争执。在此情况下，我国不能不对我东北的安全有所关切，不能不对朝鲜半岛的统一有所顾忌，我们再也不能竭尽全力去再造一个白眼狼式的“越南第二”了！未来的朝鲜半岛双方谁也难以吃掉谁，没有中国的支持或默许，难有朝韩的统一，这是美国也难做到的事情。其三，朝、韩的生命线几乎全掐在中国手里，美国拿不去，俄罗斯也替不了，即使朝、韩两国想依附区外大国，怕是也难以做到。因此，中国与朝韩两国的关系，想坏也坏不到哪里去。如果说朝韩两国追求统一可以理解的话，那他觊觎我领土则纯属痴心妄想，属于神经病！是根本无法实现的。从前段时间，发生的韩国运动员“长白山事件”来看，确实很蠢，事实与他们所要达到的目的背道而驰。两个小国的政治家幻想着一旦实现统一，半岛上立即出现一个中等规模的国家，届时，就会出现“一家有女四家求”的局面，他们可以在中美俄日四国间寻求平衡，获取最大利益。但是即便如此，他们还是无能力和实力侵占中国的领土，也还不足以实现真正的独立。中国与朝鲜和韩国只有战略合作才是共赢的唯一出路。

（二）蒙古：展翅欲飞的“鸡翅膀”

蒙古是我国北方天然的外围屏障。她的丧失使中国北方的地缘环境极度恶化。蒙古面积156万多平方公里，连接起中国的三北地区。她的丧失使我三北地区不能连成直线，只能是条弧线，北边少了一大块。由蒙古西出可以威胁新疆，东进可以威胁东北，南下可威胁京津，使我北方的战略纵深大大缩短，使我国的东北地区成为 “四战之地”，战略态势对我极为不利。蒙古的独立，是苏美肢解二战后的弱国中国的罪恶行径，是极不光彩的。从此，中国的北方多了一个蒙古国，蒙古同胞遭到了分割。蒙古地处中俄领土的包围之中，蒙古虽然把美国、日本等西方国家视为第三邻国，事实上是没有第三邻国的。蒙古的离去不过才60年。之后尽管走过不少曲折之路，中蒙最终走向接近是迟早的事。蒙古要发展经济，改善民生，不得不依靠中国。蒙古要走向外界，不得不依赖中国。中国的天津港是距离蒙古最近的海港。蒙古与中国实现战略合作，搭上中国经济发展的快车，对蒙古只有好处，没有害处。以蒙古之弱，千万不要去玩弄什么“平衡”，施展什么手段，不要有危害中国的非分之想。蒙古是最有希望成为上合的成员国的。无论是对中俄，还是对西方，接纳蒙古转正，都还能接受。蒙古将眼光转向中俄，是一件好事。与中国接近，是一件幸事。如果中蒙实现战略合作，那蒙古就成为雄鸡背上的鸡翅！中国北方的缺陷将有效弥补，蒙古也可借力中国提高其国力和影响力，对双方来说都非常有利。

（三）缅甸、越南：两条凶猛的“鸡爪”

缅甸虽然领土达67 万多平方公里，但仍然是个三流国家，也必然会依附大国，且面临着中国、印度和区外大国美国的争夺。美国屡次欲对缅甸动手，幸亏中国出手相助才安然无恙。背靠大树好乘凉。缅甸无论是从依附的角度，还是从国家发展的战略高度来考虑，中国都是不二的最佳选择。因为印度的份量不够，区外大国远水解不了近渴。面临着强国争夺的形势，缅甸势必难以保持骑墙之态，与中国接近会使缅甸获益良多。其实，如果缅甸把国家的战略定位于中国西南最佳的战略出海通道，那是会相当不错的。收复领土联盟在多个帖子里对此进行了详尽的论述。缅甸是中国借之迈向印度洋的不得多得的战略支点。对中国的战略意义非同一般。同样，只要缅甸的国家战略定位准确了，其国内政治、经济、安全等各个方面就都有了切实保障。中缅合作是双方互利共赢的大好事，既利于眼前，更利于后世，是关系到子孙万代的大事。对于这一点，缅甸政府是会看清的。

越南国土南北狭长，纵深狭小，整体上呈“了”字型分布，从地缘上来看，本质上就是南海的一条边，对于我控制南海具有天然的地利！

对于对越自卫反击战，网上多有不同的声音，主要的分歧集中在有无必要打、打得值不值上。实际上，收复领土联盟是非常佩服邓总的战略眼光的。对越自卫反击战的战略目的，显然不仅仅在于教训越南，将其赶出其侵占的中国南方领土，最根本的着眼点在于打掉其妄图借力苏联，侵吞别国，称霸中南半岛的战略野心！中国在西南已经有了一个劲敌印度，是绝不会容忍再在南方出现一个强敌越南的，何况这个敌人还有当时的一个超级大国苏联的背后支持！因此，收复领土联盟将对越自卫反击战，看作是战略意义不亚于抗美援朝的一次战略行动！邓总，绝对英明。其实，越南作为一个小国，长久以来却有着不小的野心，越南“多年来有个成立中南半岛联邦的美梦”。就连胡志明也有过这种想法。越南把中国视为实现中南半岛联邦的最大障碍，一旦借力中国实现国家统一，随即变本加厉地反中国，在国内消灭汉字，把大批越南华裔驱逐出境。越南把侵略目标指向了国力弱小的老挝和柬埔寨，目的就是增加其战略纵深，后来其侵占中国的西沙、南沙都是同种目的。老挝、柬埔寨都是联合国承认的正当国家，何况老挝还曾为中国属国，中国人有什么理由坐视越南侵吞别国而无动于衷？何况中南半岛联邦一旦变为现实，越南并不会停止侵略步伐。届时，越南还会成为苏联南下进军印度洋的环球战略的一步棋。越南的惨败，是个惨痛的历史教训，这对于妄想借助美国实现称霸野心的日本同样是个借鉴！小国依靠大国去挑战另一个大国，下场会很惨的。这就是一个国家忘记了本分，狂妄自大，目空一切的恶果，怨不得别人。

现在，越南还占领着中国的大部分南沙岛礁，中国是绝不会善罢甘休的。越南如果不乖乖地交出来，那是会付出惨重的代价的。越南比朝鲜半岛更易于被截为南北两半，更经不起军事打击。越南幻想以侵占我国的南沙群岛的方式来增加其防御纵深，是完全错误的，具有极大的风险，其风险之大如鱼游于釜中、燕巢于幕上，危如累卵。希望越南当局能够吸取历史教训，改弦更张，多做有利于两国和平、合作的好事。实际上，如果越南与中国实现战略合作，中国借助于越南领土，实现对南海的有效控制和对南海资源的有效利用，对于越南也绝没有坏处。如果中国未来将越南的金兰湾等地作为我国航母的补给地，那会极有利于中国海空军的战略部署。中国对越南没有领土野心，越南犯不上对中国疑虑。中越实现合作还有不少阻力，越南现在已全部实行了拉丁文，并将中国的南海称作东海，对于那场战争也还会难以释怀，历史的恩怨还会牵惹两国人民的情绪。但越南现在还幻想着永久侵占南沙，既不可能，也不现实，且要承担着极大的风险。该解决的始终会解决，只不过是个时机和时间长短问题。可怜的越南，是既抗不住打，又经不起折腾了。越南与中国合作是个极佳的战略定位，也是唯一的战略定位。作为中国未来的一条“鸡腿”或者说“鸡爪”，其战略地位和国家实力会逐步上升的。这是收复领土联盟为越南指出的一个光明的前途。做于不做，要看它的了。

（四）台湾、海南：雄鸡的蛋蛋，宝贝疙瘩

有网友将台湾和海南作为中国的两条腿，实际上，不是很恰当。缅甸和越南才是中国真正的两条“鸡腿”或者 “鸡爪”，台湾和海南太短了点。台湾和海南是中国海防要地，是不可多得的金蛋蛋和宝贝疙瘩，更是海空军的战略支点，是未来航母的天然良港。关于台湾和海南，不是本帖的论述重点，故从略。

蒙、朝、韩、缅、越五国是我国的重要邻国，战略地位极为重要。上述诸国的得失对我国有着生死攸关的巨大利害关系。在历史上，蒙、朝、韩、缅、越或者是我国的领土，或者是我国的属国，我国曾经为了朝鲜、缅甸、越南和蒙古而付出过惨重的代价。如果沿历史的路径往上走走就成了一家人。但也正因如此，历史的、现实的、文化的、民族的各种利益纷争频仍。现在，我国与上述诸国又存在着领土或领海的纠葛，涉及到具体的利益，彼此又都难以割舍，难以退让，难解难分。我国与上述诸国实实在在是一对“冤家”，彼此又爱又恨，可在大的原则上，在战略利益上，又是辅车相依，唇亡齿寒，谁也离不开谁。中国与上述国家建立“大金鸡”格局，是一个上上之选。她会将各种历史的、现实的恩怨化解于无形，会使各方共同的利益和关切最大化地得以实现，是实现各国有利的战略定位，共谋发展，共创和谐，共建良好国际关系的一个良策、奇策、妙策。希望有关各国的当政者认真思考、决断。

收复领土联盟

for..in and for each..in

2007-05-30T09:34:00.000+08:00

ActionScript 3 has a new iteration statement: for each..in (for each..in). for each..in works much like for..in (for..in) execpt it loops through the values of an object rather than its keys. Example:

ActionScript Code:

var object:Object = new Object();
object.name = "senocular";
object.id = 2867;
object.isModerator = true;
for each (var value:* in object){
trace(value);
}
/* Output:
true
2867
senocular
*/

Respectively, a for..in would look like:

ActionScript Code:

var object:Object = new Object();
object.name = "senocular";
object.id = 2867;
object.isModerator = true;
for (var key:String in object){
trace(key + ": " + object[key]); // object[key] is value
}
/* Output:
isModerator: true
id: 2867
name: senocular
*/

Note that the key is not available in for each..in.

ActionScript 3 also maintains array element order (using numeric array indices) when using for..in and for each..in rather than basing order off of when the value was created as was the case in ActionScript 1 and 2. Example:

ActionScript Code:

var array:Array = new Array();
array[1] = 1;
array[0] = 2;
array[2] = 3;
for (var key:String in array){
trace("array[" + key + "] = "+ array[key]);
}

Output AS 1 & AS 2:

Code:

array[2] = 3

array[0] = 2

array[1] = 1

Output AS 3:

Code:

array[0] = 2

array[1] = 1

array[2] = 3

This provices a more intuitive order when iterating through arrays with for..in and for each..in.

Note: To use the for each..in statement with an instance of a user-defined class, you must declare the class with the dynamic attribute.

ByteArray Class

2007-05-28T17:56:00.000+08:00

ActionScript 3 adds to the Flash player support for working with binary data through use of the ByteArray class (flash.utils.ByteArray). The ByteArray class is a special kind of an array (though is not a subclass of Array (Top level Array)) which holds data (bytes) that relates to data as found in computer memory.

Default Values for Function Parameters

2007-05-26T21:12:00.000+08:00

ActionSript 3 now allows you to specify default values for your function's parameters. In doing so, that parameter then becomes optional and the default value assigned to the respective argument in the function call if a value is explicitly not provided.

ActionScript Code:

function method(required:String, optional:String = "default"):void {
trace(required +" "+optional);
}
method("Hello"); // "Hello default"

You can only place parameters with default values after all required parameters. In other words you can't have

ActionScript Code:

// Incorrect:
function method(required:String = "default", optional:String):void { ...

since there would be no way for optional to be set without required having to be set as well.

Undetermined Number of Arguments With ...(rest)

2007-05-25T13:44:00.001+08:00

Since ActionSript 3 checks argument count when functions are called you are not able to pass any number of arguments to any function like you could in ActionScript 1 or ActionScript 2. Instead, to allow for this, you need to use a new special kind of parameter called ...(rest) (Keyword: ...(rest)).

The ...(rest) parameter is a special parameter placed at the end of a parameter list in a function that specifies that there can be any number of additional arguments of any type passed into that function when its called. The form of the parameter is 3 periods followed by a keyword. When the function is called, the additional arguments are assigned to that keyword in the form of an array.

ActionScript Code:

function usingRest(required:Number, ... optionalArgs):void {
trace(required); // 1
trace(optionalArgs); // [2, 3, 4]
}
usingRest(1, 2, 3, 4);

IT人不可不听的10个职场故事

2007-05-24T21:07:00.000+08:00

其实不仅是IT人，场中人皆在其列。
　　 (1)
　　有一次，一个老强盗带着徒弟去抢劫银行，被警方追捕。两人狂逃，差点儿连裤子都跑掉了。好不容易甩掉了警察，两人上气不接下气，瘫倒在地上。
　　良久，惊魂稍定，徒弟说:“师父啊师父，要是这个世界上没有警察，该有多么美好啊!”师父骂道:“放屁!要是没有警察，我们还有饭吃吗?!”徒弟大惑不解。师父“语重心长”地说:“你只知其一不知其二啊!你想想，如果没有了警察，是不是大家都敢去偷、去抢了?正因为有了这些警察，把那些能人挡住了，我们才有生存空间啊!和他们相比，我们算什么东西?有什么本事啊?我们不就是仅仅凭着一颗贼胆，敢干他们不敢干的事，才混得一口饭吃吗?有了警察，才有我们啊!没有警察，哪里有我们的好日子过啊!”
　　你看成功人士多么风光，但是，你只看到一面，没有看到另外一面，你“只看到贼吃肉，没有看到贼挨打”，没有看到他们为成功所流的汗水、泪水，甚至鲜血!即使，你看到了“贼挨打”，你也只愿意做“只吃肉不挨打的贼”。天下哪里有这样便宜的好事!上面那个老强盗的经验，我们是可以好好借用一下的。只要有一点点勇气、自信，就足够用来突破生理和心理的障碍。
　
　 (2)
　　两个食人族到某公司上班，老板说:“如果你们在公司吃人，立马开除!”三个月下来大家相安无事，突然一天老板把这两个人叫到办公室大骂一顿:“TMD，叫你们不要吃人你们还吃，明天你们不用来上班了!” 两食人族收拾东西离开，出门时一个忍不住骂另一个:“告诉过你多少遍，不要吃干活儿的人，三个月来我们每天吃一个部门经理，什么事都没有，昨天你吃了一个清洁工，今天就被他们发现了!”
　　
(3)
　　小狗汤姆到处找工作，忙碌了好多天，却毫无所获。他垂头丧气地向妈妈诉苦说:“我真是个一无是处的废物，没有一家公司肯要我。”
　　妈妈奇怪地问:“那么，蜜蜂、蜘蛛、百灵鸟和猫呢?”
　　汤姆说:“蜜蜂当了空姐，蜘蛛在搞网络，百灵鸟是音乐学院毕业的，所以当了歌星，猫是警官学校毕业的，所以当了保安。和他们不一样，我没有接受高等教育的经历和文凭。”
　　妈妈继续问道:“还有马、绵羊、母牛和母鸡呢?”
　　汤姆说:“马能拉车，绵羊的毛是纺织服装的原材料，母牛可以产奶，母鸡会下蛋。和他们不一样，我是什么能力也没有。”
　　妈妈想了想，说:“你的确不是一匹拉着战车飞奔的马，也不是一只会下蛋的鸡，可你不是废物，你是一只忠诚的狗。虽然你没有受过高等教育，本领也不大，可是，一颗诚挚的心就足以弥补你所有的缺陷。记住我的话，儿子，无论经历多少磨难，都要珍惜你那颗金子般的心，让它发出光来。”
　　汤姆听了妈妈的话，使劲地点点头。
　　在历尽艰辛之后，汤姆不仅找到了工作，而且当上了行政部经理。鹦鹉不服气，去找老板理论，说:“汤姆既不是名牌大学的毕业生，也不懂外语，凭什么给他那么高的职位呢?”
　　老板冷静地回答说:“很简单，因为他是一只忠诚的狗。”
　　
(4)
　　去过庙的人都知道，一进庙门，首先是弥勒佛，笑脸迎客，而在他的背面，则是黑口黑脸的韦陀。但相传在很久以前，他们并不在同一个庙里，而是分别掌管不同的庙。
　　弥勒佛热情快乐，所以来的人非常多，但他什么都不在乎，丢三拉四，没有好好的管理账务，所以依然入不敷出。而韦陀虽然管账是一把好手，但成天阴着个脸，太过严肃，搞得人越来越少，最后香火断绝。
　　佛祖在查香火的时候发现了这个问题，就将他们俩放在同一个庙里，由弥勒佛负责公关，笑迎八方客，于是香火大旺。而韦陀铁面无私，锱珠必较，则让他负责财务，严格把关。在两人的分工合作中，庙里一派欣欣向荣景象。
　　其实在用人大师的眼里，没有废人，正如武功高手，不需名贵宝剑，摘花飞叶即可伤人，关键看如何运用。
　　
(5)
　　曾经有个小国到中国来，进贡了三个一模一样的金人，把皇帝高兴坏了。可是这小国不厚道，同时出一道题目:这三个金人哪个最有价值?
　　皇帝想了许多的办法，请来珠宝匠检查，称重量，看做工，都是一模一样的。怎么办?使者还等着回去汇报呢。泱泱大国，不会连这个小事都不懂吧?
　　最后，有一位退位的老大臣说他有办法。
　　皇帝将使者请到大殿，老臣胸有成足地拿着三根稻草，插入第一个金人的耳朵里，这稻草从另一边耳朵出来了。第二个金人的稻草从嘴巴里直接掉出来，而第三个金人，稻草进去后掉进了肚子，什么响动也没有。老臣说:第三个金人最有价值!使者默默无语，答案正确。
　　这个故事告诉我们，最有价值的人，不一定是最能说的人。老天给我们两只耳朵一个嘴巴，本来就是让我们多听少说的。善于倾听，才是成熟的人最基本的素质。
　　
(6)
　　父子两住山上，每天都要赶牛车下山卖柴。老父较有经验，坐镇驾车，山路崎岖，弯道特多，儿子眼神较好，总是在要转弯时提醒道:“爹，转弯啦!”
　　有一次父亲因病没有下山，儿子一人驾车。到了弯道，牛怎么也不肯转弯，儿子用尽各种方法，下车又推又拉，用青草诱之，牛一动不动。
　　到底是怎么回事?儿子百思不得其解。最后只有一个办法了，他左右看看无人，贴近牛的耳朵大声叫道:“爹，转弯啦!”
　　牛应声而动。
　　牛用条件反射的方式活着，而人则以习惯生活。一个成功的人晓得如何培养好的习惯来代替坏的习惯，当好的习惯积累多了，自然会有一个好的人生。
　　
(7)
　　一只乌鸦坐在树上，整天无所事事。一只小兔子看见乌鸦，就问:“我能象你一样整天坐在那里，什么事也不干吗?”乌鸦答道:“当然啦，为什么不呢?”于是，兔子便坐在树下，开始休息。突然，一只狐狸出现了。狐狸跳向兔子……并把它给吃了。
　　这个故事的寓意是……要想坐在那里什么也不干，你必须坐(做)得非常非常高。
　　
(8)
　　一只小鸟正在飞往南方过冬的途中。天气太冷了，小鸟冻僵了，从天上掉下来，跌在一大片农田里。它躺在田里的时候，一只母牛走了过来，而且拉了一泡屎在它身上。冻僵的小鸟躺在牛屎堆里，发掘牛粪真是太温暖了。牛粪让它慢慢缓过劲儿来了!它躺在那儿，又暖和又开心，不久就开始高兴地唱起歌来了。一只路过的猫听到了小鸟的歌声，走过来查个究竟。顺着声音，猫发现了躲在牛粪中的小鸟，非常敏捷地将它刨了出来，并将它给吃了!
　　这个故事的寓意是……
　　1) 不是每个在你身上拉屎的都是你的敌人。
　　2) 不是每个把你从屎堆中拉出来的都是你的朋友。
　　3) 而且，当你陷入深深的屎堆当中(身陷困境)的时候，闭上你的鸟嘴!
　　
(9)
　　有七个人曾经住在一起，每天分一大桶粥。要命的是，粥每天都是不够的。
　　一开始，他们抓阄决定谁来分粥，每天轮一个。于是乎每周下来，他们只有一天是饱的，就是自己分粥的那一天。后来他们开始推选出一个道德高尚的人出来分粥。强权就会产生腐败，大家开始挖空心思去讨好他，贿赂他，搞得整个小团体乌烟障气，高尚的人也腐败了。然后大家开始组成三人的分粥委员会及四人的评选委员会，但他们常常互相攻击，扯皮下来，粥吃到嘴里全是凉的。最后想出来一个方**:**流分粥，但分粥的人要等其它人都挑完后拿剩下的最后一碗。为了不让自己吃到最少的，每人都尽量分得平均，就算不平，也只能认了。大家快快乐乐，和和气气，日子越过越好。
　　同样是七个人，不同的分配制度，就会有不同的风气。所以一个单位如果有不好的工作习气，一定是机制问题，一定是没有完全公平公正公开，没有严格的奖勤罚懒。如何制订这样一个制度，是每个领导需要考虑的问题。
　　
(10)
　　战国时期魏惠王因为齐威王违背了盟约，所以想要发兵攻打齐国。身为国相的惠施为了劝导魏王息兵，请来了国都的一位贤士戴晋人。戴晋人见了魏王问道:“关于蜗牛，君王知道吗?”魏王说:“知道。”戴普人说:“蜗牛长着两只触角。左面的角上有一个国家，称为触氏;右面的角上有一个国家，称为蛮氏。为了争夺领地，两国交兵开战，伏尸数万，胜者追了十又五天，才收兵回营。”魏王不以为然地笑说:“这不都是虚假之言吗?”戴晋人说:“不是虚假之言，不信的话，我来为你论证一下:以君王看来，四方上下有穷尽吗?”魏王说:“没有穷尽。”戴晋人又问:“人的心巡游过无穷无尽的宇宙之后，返回到人世，可不可以说人世渺小到了似有似无?”魏王说:“对。”戴晋人紧跟着又问:“人世既然渺小到了可有可无的地步，而魏国只是人世间的一个很小的地方，国都又是魏国之中很小的一块地方，君王又是国都中很小的一个形体，那么，相对于无穷无尽的宇宙而言，跟蜗牛右角上蛮氏国的国王又有什么分别呢?”魏王说:“没有什么分别。”
　　戴晋人离去了。魏王好似被引入了空旷无际的太空，看不到人世，更看不到魏国，体悟到人世和国土的渺小，感受到了征战和扩疆的无聊，认识到交兵争胜，所得不过蜗牛一角之地，实在没有多大意义。于是称赞戴晋人为“大人”，认为他有如此眼光，远远超过了圣人。
　　
故事告诉我们，职场的一切得失都是渺小的，没有人会在临死的时候，后悔自己没有多花点时间在办公室工作。
幸福，才是人的一生中最重要的事情。

getBounds() vs getRect()

2007-05-24T11:29:00.001+08:00

Like ActionScript 1 and 2, ActionScript 3 has a getBounds() (flash.display.DisplayObject.getBounds()) method for determining the bounds of a movie clip (display object) in the coordinate space of any timeline. In ActionScript 3, however, getBounds has changed to return a Rectangle (flash.geom.Rectangle) instance instead of a generic object with the properties xMin, xMax, yMin, and yMax.

ActionScript 3 also adds an additional method similar to getBounds called getRect() (flash.display.DisplayObject.getRect()). The getRect() method works just like getBounds except it doesn't take into consideration strokes on shapes.

The following example shows the differences between the rectangle shape returned by getBounds and that returned by getRect.

ActionScript Code:

var sprite:Sprite = new Sprite();
sprite.graphics.beginFill(0x999999);
sprite.graphics.lineStyle(10, 0x333);
sprite.graphics.drawCircle(100, 100, 50);
sprite.graphics.endFill();
addChild(sprite);

addChild(createRectShape(sprite.getRect(this), 0xFF00FF));
addChild(createRectShape(sprite.getBounds(this), 0xFF0000));

function createRectShape(rect:Rectangle, color:uint):Shape {
var rectShape:Shape = new Shape();
rectShape.graphics.lineStyle(0, color);
rectShape.graphics.drawRect(rect.left, rect.top, rect.width, rect.height);
return rectShape;
}

Running the above script draws a circle with a stroke of 10 px with two rectangles around it, one which fits to the vector shape of the circle (getRect) and the other which fits to the bounds of the whole object including the stroke (getBounds).

The rectangle returned by getRect relates to width and height values associated with the display object (which doesn't account for strokes) while getBounds returns a rectangle associated with the visual boundaries of the display object. Note that filters are not accounted for in either method.

Flash 9: BitmapData and Bitmaps from the Library

2007-05-23T16:43:00.000+08:00

Flash 8 let you load bitmap information from the library using a linkage ID and the BitmapData.loadBitmap() method. This is no longer the case with Flash 9 and ActionScript 3. Now, as with timelines and movie clips in the library, Bitmaps are associated with classes. If you do not specify a specific class to be related to your bitmap in the library, you can name one which will be created automatically when publishing the SWF.

Classes associatated with bitmaps in the library are subclasses of BitmapData (flash.display.BitmapData). These are then instantiated as instances in ActionScript using the new keyword. As BitmapData instances, before being able to be seen on the screen, they would need to be associated with a Bitmap (flash.display.Bitmap) instance which is a display object capabale of being added to a display list (BitmapData instances cannot be added to display lists).

As an example, lets say you imported a bitmap of Rome in your library. In the linkage dialog for that bitmap, give it a class name of RomeImage - note that you don't have to create this class yourself; it will be created automatically. Then, to display it on the screen in ActionScript, use:

ActionScript Code:

// create instance of RomeImage bitmap data
var romeImageData:RomeImage = new RomeImage();

// create a bitmap instance that references the RomeImage instance
var romeImageBitmap:Bitmap = new Bitmap(romeImageData);

// add the new bitmap to the display list
addChild(romeImageBitmap);

Changes in typeof

2007-05-22T09:53:00.000+08:00

The typeof operator lets you determine the basic type of any value. Note that this does not give you actual class association information, but only provides a simplistic indication of the type of variable its used with. For more information regarding specific class relation, use instanceof, getQualifiedClassName, or describeType.

In ActionScript 1 and 2, typeof returned the following values:

boolean
function
movieclip
null
number
object
string
undefined

In ActionScript 3, typeof returns:

boolean
function
number
object
string
xml
undefined

Notice that MovieClip instances are, in AS3, no longer recognized by typeof. They are now seen as objects. Additionally, there is no null value (also seen as an object) and xml is seen as being of type xml.

The new number types in AS3, int and uint, when used with typeof both return number.

Also, primitive values (boolean, number, and string) created with their constructors and the new keyword are now recognized as those primitive types by typeof and not as objects as they were in AS1 and AS2.

ActionScript Code:

// AS1 & AS2
trace(typeof new XML()); // object

trace(typeof my_mc); // movieclip

trace(typeof null); // null

trace(typeof true); // boolean
trace(typeof 1); // number
trace(typeof ""); // string

trace(typeof new Boolean()); // object
trace(typeof new Number()); // object
trace(typeof new String()); // object

ActionScript Code:

// AS3
trace(typeof new XML()); // xml

trace(typeof my_mc); // object

trace(typeof null); // object

trace(typeof true); // boolean
trace(typeof 1); // number
trace(typeof ""); // string

trace(typeof new Boolean()); // boolean
trace(typeof new Number()); // number
trace(typeof new String()); // string

trace(typeof int(1)); // number
trace(typeof uint(1)); // number

美经济学家评价毛泽东：不仅仅是开国元勋[轉]

2007-05-21T16:16:00.000+08:00

作者:akaaaa 发表时间: 2007/05/21 15:48 点击:56次

毛泽东是今天中国经济长足发展的制度设计人

　　美国新经济学家梅森说,当时中国军队经商,警察违法,海关走私,基层干部大面积结合贪污,严重威胁中国存亡的时候,中国平民阶层在50--80年三个十年的长足发展中已占社会的主流,累积了能够打倒这批新贵的社会综合力量.如果中国没有三反五反到文化革命等一系列趋向于平民化的过程,中国九十年代的反贪,很可能是印尼和巴西的样子。

　　中国今天的反贪,比和她一个省下边的地区差不多大的对岸还要好,同样,巴西和印尼比中国大陆经济早起飞二十年,他们的军队,警察和地方新贵勾结起来,盘根错节,普通百姓和中央的一批改革派几乎无能为力实行任何有意义的改革,两国不仅经济结构缺胳膊少腿,而且再行发展的经济动力也不够。

　　这说明中国在社会基本力量的分布上,已经是个平民阶层主导社会发展的格局.这是个现代化国家的政体.虽然她与西方现代化国家整体的表面构造不一样.印尼巴西和印度是传统落后国家的政体,虽然她们在表面构造上和西方现代化国家政体相同.中国土地改革到文化革命的洪炉化掉了社会中的传统筋骨,使其在构造成分上达到了现代国家的比例。

　　文化革命是快了些,委屈了一批人,尤其是不到社会3%的教育科技人员和地方乡绅,这是它的副作用,但文化革命不仅在当时,即使在今天和明天也堵死了中国走向传统社会力量分配格局的路,它偏向了中国普通老百姓.在今天看来,如果从这个意义上来理解文化革命,毛泽东是今天中国经济长足发展的制度设计人,而绝对不仅仅是开国元勋。

Weak References

2007-05-21T12:20:00.000+08:00

If you want a reference to exist for an object that will not be counted towards the reference count used by the Garbage collector, then you can use a weak reference. Weak references are ignored by the reference counter and can exist even if the object is deleted.

You can't use weak references anywhere, however. There are only two places you can use weak references in ActionScript 3. One place is with Dictionary objects. The Dictionary constructor allows one optional parameter that specifies whether or not keys within the instance are weak references or not. False is the default value which means strong references. If you pass true, the Dictionary instance will use weak references

ActionScript Code:

var dict:Dictionary = new Dictionary(true); // use weak references as keys

If you do this for Dictionary instances, the keys you use to store values will not be counted towards that object's reference count.

ActionScript Code:

var obj:Object = new Object();
dict[obj] = true;
delete obj; // obj can be garbage collected since the dict reference isnt counted

The EventDispatcher's addEventListener is the other place you can specify weak references. addEventListener has a parameter that lets you specify the listener reference as being weak (since listeners internally require a reference to the object they are listening to).

ActionScript Code:

// addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
addEventListener(MouseEvent.CLICK, clickHandler, false, 0 true); // use weak references

For addEventListener, the default is also false, using strong references, though it's good habit to use weak listeners to help with garbage collection.

Garbage Collection: Reference Counting & Mark and Sweep

2007-05-20T22:54:00.000+08:00

Garbage collection (GC) is the automatic process in Flash that removes variables from memory when they are no longer needed. There are two processes that handle garbage collection in Flash, reference counting, and mark and sweep.

Reference counting is a process that keeps track of all the variables referencing an object in memory. When a new reference is created to point to an object, its reference count is updated and incremented by one.

ActionScript Code:

var a:Object = new Object(); // new Object in memory given reference count of 1
var b:Object = a; // Object now has reference count of 2

When ever there are no longer any references pointing to an object in memory, that object is purged from memory and permanently forgotten by the player.

ActionScript Code:

delete a; // Object has reference count of 1
delete b; // Object has reference count of 0, removed from memory

Note: remember, the delete operator only removes variable association, it does not delete objects in memory, the GC is responsible for that. Also delete will only work on non class member variables.

There are certain times when reference counting does not work. For example, if you have two objects that reference themselves but reference nothing else, they remain to have a reference count greater than 0 but they are in no way accessible to you, the programmer, so are in all other means as good as gone.

ActionScript Code:

var a:Object = new Object(); // reference(a) count 1
var b:Object = new Object(); // reference(b) count 1
a.b = b; // reference(b) count 2
b.a = a; // reference(a) count 2
delete a; // reference(a) count 1
delete b; // reference(b) count 1

Here both a and b are removed from the current scope so are no longer accessible. b is accessible from a and a is accessible from b, but since you can never get to a or b there's no way to get to b or a. These objects are as good as deleted from the programmer, however, they will remain in memory because they still contain a reference count greater than 0. This is where mark and sweep comes into play.

Mark and sweep is a process that scans all references and object from a base location (such as the root or stage scope) and marks each one found. All of those not found are inaccessible and are therefore deleted. Given the example with a and b, since a and b are no longer accessible from any object path derived from root, they are not marked and eventually get garbage collected.

Code:

[root] <- scan...

[objectRef (marked)] <- scan...

...

[delete all objects not marked]

Mark and sweep is a more expensive process compared to reference counting so it takes longer and is performed less often. In fact, provided little or no activity in your movie, many frames could elapse before mark and sweep kicks in. What this means is that you could potentially have variables in memory for a long time after you assumed them to be gone. For objects that have actions associated with them, such as events coming off of enterFrame events, this could be something to be concerned about since those events could still operate after the object should technically be deleted. You should always make sure you "cleanup" your events for situations where they might remain in memory longer than you want.

Number() Conversion No Longer Interprets Octals

2007-05-18T09:36:00.000+08:00

In ActionScript 1 and 2, when you convert String values into their number equivalents using Number(), if the number was preceded by a "0", the value would be interpreted as an octal value (base 8) much in the same way a preceding "0x" means hex (base 16).

ActionScript Code:

// ActionScript 1 and 2
trace(Number("010")); // 8

This could often cause problems for 'normal' values that, more often than not, you'd rather stay decimal (base 10). In ActionScript 3, this is no longer the case. String values with preceding "0"s are no longer treated as octals (though "0x" still means hex).

ActionScript Code:

// ActionScript 3
trace(Number("010")); // 10

If you want to interpret a string as an octal, you would then use parseInt specifying a radix of 8

ActionScript Code:

trace(parseInt("010", 8)); // 8

Get Sound Spectrum Information

2007-05-17T09:26:00.000+08:00

Using ActionScript 3 you can now obtain sound spectrum information from audio played through Flash. This lets you create visualizations like those seen in popular in media player applications. The class that provides this information is the SoundMixer class (flash.media.SoundMixer). It's computeSpectrum method (static) places sound spectrum information in a ByteArray instance which can then be used to generate a visualization.

ActionScript Code:

// play sound...
var spectrumInfo:ByteArray = new ByteArray();
SoundMixer.computeSpectrum(spectrumInfo);
// spectrumInfo is now a byte array with sound spectrum info

Event Propagation Support

2007-05-16T09:20:00.000+08:00

ActionScript 3 now supports event propagation - the transference of a single event applying to multiple objects to each of those objects instead of one - in Display objects. In ActionScript 1 and 2, "Button" events (such as onPress, onRelease, etc.) handled by movie clips were not propagated to that movie clip's children. This means that though visually you were clicking on a child of a movie clip handling an onPress event, that onPress would never make it to the child because the parent movie clip handling the event would intercept it and prevent the propagation of the onPress event to that child.

Example; movie clip parent_mc contains child_mc:

ActionScript Code:

// AS1 and AS2
parent_mc.onPress = function(){
trace("parent pressed");
}
parent_mc.child_mc.onPress = function(){
trace("child pressed");
}

/* click child output:
parent pressed
*/

ActionScript Code:

// AS3
parent_mc.addEventListener(MouseEvent.CLICK, parentClick);
parent_mc.child_mc.addEventListener(MouseEvent.CLICK, childClick);

function parentClick(event:MouseEvent):void {
trace("parent pressed");
}
function childClick(event:MouseEvent):void {
trace("child pressed");
}

/* click child output:
child pressed
parent pressed
*/

In ActionScript 1 and 2, the child is never able to receive the event. In ActionScript 3, both movie clips are able to receieve it as the event is propagated to each movie clip to which it applies.

XML: @ Operator for Attributes

2007-05-15T13:45:00.000+08:00

E4X (XML used in ActionScript 3) has new operators to access values in XML. One operator is the @ operator which accesses attributes. It can be used in place of the attribute() (Top level XML.attribute()) method for obtaining attribute values. Ex:

ActionScript Code:

var myXML:XML = name="senocular" id="2867" />;
trace(myXML.attribute("name")); // senocular
trace(myXML.attribute("id")); // 2867
trace(myXML.@name); // senocular
trace(myXML.@id); // 2867

You can also use an asterisk (*) with the @ operator to get a list of all attributes associated with an XML node in the form of an XMLList object. This is equivalent to the attributes() (Top level XML.attributes()) method. Ex:

ActionScript Code:

var myXML:XML = name="senocular" id="2867" />;
var atts:XMLList;

atts = myXML.attributes();
trace(atts.toXMLString());
/* Output:
senocular
2867
*/
atts = myXML.@*;
trace(atts.toXMLString());
/* Output:
senocular
2867
*/

Render Event

2007-05-14T09:31:00.000+08:00

ActionScript has long since relied on the enterFrame (onEnterFrame) event for time-based actions, especially animation and actions relating to frame playback. In comparison, Director's Lingo language has, not only an enterFrame event, but two other frame events, prepareFrame and exitFrame. Though ActionScript 3 has not aquired prepareFrame or exitFrame, it has gained a new frame event, render, or Event.RENDER (flash.events.Event.RENDER).

The render event in AS3 is a frame event that occurs after enterFrame (flash.events.Event.ENTER_FRAME) allowing one more chance to do what you need to do before the screen updates its display.

Unlike enterFrame, however, the render event will not be called unless the display object using it is attached to a stage (or in any display list attached to the stage). Also, render is not automatically called every frame, even if attached to the stage. In order for render to be called for the current frame, you must make a call to stage.invalidate() (flash.display.Stage.invalidate());

Ex:

ActionScript Code:

var sprite:Sprite = new Sprite();
stage.addChild(sprite);

sprite.addEventListener(Event.ENTER_FRAME, enterFrame);
sprite.addEventListener(Event.RENDER, render);
stage.addEventListener(MouseEvent.CLICK, click);

function enterFrame(event:Event):void {
trace("enter frame");
}
function render(event:Event):void {
trace("render");
}
function click(event:MouseEvent):void {
trace("click");
stage.invalidate();
}

Code:

Output:

enter frame

click

enter frame

render

enter frame

...

RegExp: Email Validation

2007-05-12T15:03:00.000+08:00

Here's an example of how one might validate email using ActionScript 3's Regular Expression class (Top level RegExp):

ActionScript Code:

function isValidEmail(email:String):Boolean {
var emailExpression:RegExp = /^[a-z][\w.-]+@\w[\w.-]+\.[\w.-]*[a-z][a-z]$/i;
return emailExpression.test(email);
}
//...
trace(isValidEmail("senocular@example.com")); // true
trace(isValidEmail("@example.com")); // false
trace(isValidEmail("senocular@example")); // false
trace(isValidEmail("seno\\cular@example.com")); // false

Flash 9: Timelines as Classes

2007-05-11T11:10:00.001+08:00

In Flash 9, you are able to associate all timelines with classes, including the root timeline. Movie clip timelines are associated with classes the same way as ActionScript 2 using the linkage dialog. The root timeline can be given a class association through the property inspector or through the publish settings (in ActionScript settings).

If you do not associate a timeline with a class, one is automatically created for that timeline by Flash. When this happens, variables become class variables, all named functions (declared using function functionName(){}) become methods of that class, and all scripts within the frames associated with methods that are automatically called when that frame is reached (minus the variable and method definitions). Because of this, you can only declare variables and named functions of any specific name for a function once. Variables you can redefine, but not redeclare. Functions (methods) are locked. Note: You cannot mix classes associated with timelines and timeline scripts.

The following timeline script in Flash 9

ActionScript Code:

var num:Number = 1;
function showNum():void {
trace(num);
}
showNum();

essentially becomes the following AS3 class that gets associated with that timeline:

ActionScript Code:

package {
class TimelineClass extends MovieClip {

public var num:Number = 1;

public function showNum():void {
trace(this.num);
}
public function frame1():void {
showNum();
}
}
}

is Operator (vs instanceof)

2007-05-10T09:40:00.000+08:00

The is operator (is operator) is a new keyword that lets you check to see if an instance is of a certain object type. This works for ActionScript 3 class instances checked against class types as well as interfaces. Ex:

ActionScript Code:

var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite); // true
trace(mySprite is DisplayObject); // true
trace(mySprite is IEventDispatcher); // true

The is operator is a replacement for instanceof (instanceof operator) from ActionScript 1 and 2. The is operator, however, is specific to AS3 classes and is used to check the inheritance specific to those classes. This will not work on dynamic classes created with AS1-style constructor functions. In that situation, you would use instanceof since instanceof checks the prototype chain of an instance as opposed to class inheritance (which is does). Because an AS3 class's class inheritance is mirrored in its prototype chain, this means that instanceof will also work for AS3 classes, though is is prefered then (and less typing!).

ActionScript Code:

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof Sprite); // true
trace(mySprite instanceof DisplayObject); // true
trace(mySprite instanceof IEventDispatcher); // false - not in prototype chain

ActionScript Code:

var AS1StyleClass:Function = function(){}
AS1StyleClass.prototype = new MovieClip();

var as1Instance:* = new AS1StyleClass();
trace(as1Instance instanceof AS1StyleClass); // true
trace(as1Instance instanceof MovieClip); // true
trace(as1Instance is AS1StyleClass); // true
trace(as1Instance is MovieClip); // false - cant see prototype chain

Loading Text and XML with URLLoader

2007-05-09T11:45:00.000+08:00

In previous versions of ActionScript, there were a couple of classes who had the capability of loading external text, namely LoadVars and XML. The loading responsibilities of these classes has moved to one single class in ActionScript 3, URLLoader (flash.net.URLLoader). This class is a lot like LoadVars. The big difference is that it is used for XML since the responsibility of loading XML from an external source has been removed from the XML class. Instead, you would load the text with URLLoader and then give that text to an XML object for parsing.

Like LoadVars, URLLoader has a load() method that is used to load text from an external source. This accepts 1 argument, a URLRequest instance (NOT a URL string). You can then use events from URLLoader to determine when the loading is complete. When complete, the text loaded is available in the data property of URLLoader.

Example:

ActionScript Code:

var loader:URLLoader;
// ...
loader = new URLLoader();
loader.addEventListener(Event.COMPLETE, xmlLoaded);

var request:URLRequest = new URLRequest("file.xml");
loader.load(request);
//...
function xmlLoaded(event:Event):void {
var myXML:XML = new XML(loader.data);
//...
}

XML vs. XMLDocument

2007-05-08T11:39:00.000+08:00

XML has changed for ActionScript 3. The new way of dealing with XML revolves around E4X - ECMAScript's XML specification. This provides a different, more efficient interface for dealing with XML nodes and attributes. These are all associated with the new XML (top level XML) class.

ActionScript Code:

var myXML:XML = new XML(objectToConvert);

ActionScript Code:

var myXML:XML = ;

The old class, as it was used in ActionScript 1 and 2, is still around. However, it has been renamed to XMLDocument (flash.xml.XMLDocument). If you want to work with XML the way you did with AS1 and AS2, you would use XMLDocument instead of XML.

ActionScript Code:

var myXML:XMLDocument = new XMLDocument("");

URLRequest for URL Strings

2007-05-07T11:31:00.000+08:00

Methods relying on URL strings in ActionScript 3 now use URLRequest (flash.net.URLRequest) instances instead of direct string values for URLs. URLRequest instances contain the following properties:
• contentType:String
• data:Object
• method:String
• requestHeaders:Array
• url:String
which relates to the URL itself (specified in the url property).

For example, when using navigateToURL() (flash.net.navigateToURL) (getURL() replacement), instead of passing a string of the URL to navigate to, you use a URLRequest instance.
ActionScript Code:
var request:URLRequest = new URLRequest("http://www.adobe.com/");
navigateToURL(request);

Calling Event Handlers without Events

2007-05-06T11:41:00.000+08:00

When you define event handlers in ActionScript 3, the functions need to accept 1 parameter of the type Event. When these methods are called by the events, those event objects are then passed into the handler.

If you have an event handler that you want to use as a normal function call, you can call that function with a new Event object passed into it like so:

ActionScript Code:

myHandler(new Event(someEventType));

However, that can be a hassle and a little confusing (plus you are creating an event that probably has nothing to do with the function). If you just want to be able to call the event handler without having to worry about that event but still have it work for calls coming from events, you can define the handler with your event parameter having a default value of null. This way you can call the function without an event but still have it work when the event is passed from an actual event call.

ActionScript Code:

public function myHandler(event:Event = null):void {...}
...
// call normally without event
myHandler();

Note: this will not work if your event handler relies on information from the event object.

Multiple Arguments in trace()

2007-05-05T11:17:00.000+08:00

As with previous versions of ActionScript, there exists a trace function for outputing messages into the Output panel in Flash. In ActionScript 1 and 2, trace accepted one argument that was outputed to the Output panel in Flash. In ActionScript 3, trace now accepts any number of arguments and outputs them each.

ActionScript Code:

trace(value1, value2, value3);

Note: You could get essentially the same effect in AS1 and AS2 using

ActionScript Code:

trace([value1, value2, value3]);

using an array

Determining Current Frame Label

2007-05-04T21:11:00.000+08:00

MovieClip (flash.display.MovieClip) instances in ActionScript 3 have a couple of new properties called currentLabels and currentLabel. currentLabels is an array of FrameLabel (flash.display.FrameLabel) instances describing the frame labels within the movie clip's timeline. Each FrameLabel in the currentLabels array contains two properties: name, and frame. Name provides the name of the label and frame is the frame number on which it exists. currentLabel returns the name of the label associated with the current frame.

ActionScript Code:

var label:String = my_mc.currentLabel;

super() Placement (Now Anywhere)

2007-05-03T11:58:00.000+08:00

In ActionScript 2, the call to super() in the constructor of a class inheriting from another class had to be the first statement within the constructor. If you didn't add it explicitly yourself, it was added for you.

In ActionScript 3, super will still be added for you if you did not include it yourself, but now you are allowed to place it anywhere within your constructor, even after other statements; it no longer has to be the first statement in your constructor.

ActionScript Code:

package {
public class SubClass extends SuperClass {
protected var value:int;
public function SubClass(value:int = 0) {
this.value = value;
super(20);
}
}
}

Determine Instance Class or Superclass

2007-05-02T11:45:00.000+08:00

ActionScript 3 lets you easily obtain any instances class name using a new function called getQualifiedClassName (flash.utils.getQualifiedClassName).

ActionScript Code:

var sprite:Sprite = new Sprite();
trace(getQualifiedClassName(sprite)); // "flash.display::Sprite"

You can also use the getQualifiedSuperclassName (flash.utils.getQualifiedSuperclassName) function to find its superclass

ActionScript Code:

trace(getQualifiedSuperclassName(sprite)); // "flash.display::DisplayObjectContainer"

If you want to go backwards, and convert a string into an actual class reference, you can use getDefinitionByName (flash.utils.getDefinitionByName).

ActionScript Code:

trace(getDefinitionByName("flash.display::Sprite")); // [class Sprite]

Also see describeType() (flash.utils.describeType) in the following post...

Writing Inline XML

2007-05-01T11:15:00.000+08:00

In ActionScript 3, you can define XML variables using inline XML in your script. You don't even need to enclose it in Strings like you did in previous versions of ActionScript. The ActionScript 3 compiler will automatically parse the XML in the code and recognize when it stops and when normal AS code starts.

ActionScript Code:

var myXml:XML =

text1

text2

;

Events and Event Types

2007-04-30T10:39:00.000+08:00

Event objects used with EventDispatcher in ActionScript 3 are a little less generic than those used with ActionScript 2. In AS 3, each event object has its own class. The most common event classes are Event (flash.events.Event) for general events and MouseEvent (flash.events.MouseEvent) for events associated with the mouse. Other event classes can be found in the flash.events package, all of which inherit from Event.

When using EventDispatcher.dispatchEvent(), you pass in an Event instance that is specific to the event being dispatched. The type of event dispatched is defined within the Event instance used. For example, dispatching an "enterFrame" event would mean using dispatchEvent with an Event instance instantiated with the type "enterFrame".

ActionScript Code:

dispatchEvent(new Event("enterFrame"));

When an event handler is executed as a result of this event, that event object is passed into the function as a single argument. Properties from that event can then be extracted to learn more about the event that occured. For example, the type property from the Event class tells which event was dispatched.

ActionScript Code:

addEventListener("enterFrame", eventHandler);
dispatchEvent(new Event("enterFrame"));
...
private function eventHandler(event:Event):void {
trace(event.type); // "enterFrame"
}

Though event types are strings, all common Flash events are available in Flash through static constants of the Event classes. The "enterFrame" event type, for example, is accessible using Event.ENTER_FRAME. Mouse events are within the MouseEvent class. Click events, for example, are MouseEvent.CLICK. These constants are prefered over their string representations.

ActionScript Code:

addEventListener(Event.ENTER_FRAME, eventHandler);
dispatchEvent(new Event(Event.ENTER_FRAME));

When making your custom Events, you can use the Event object with a custom type or alternatively, extend the Event class creating a new kind of Event instance to be used with your events.

EventDispatcher

2007-04-24T11:33:00.000+08:00

ActionScript 3 uses the EventDispatcher (flash.events.EventDispatcher) class for all event handling. This class was available in ActionScript 2, but it existed as an external class in the mx framework. Now, it is built into the player (and in being so, improves performance).

Whenever you want to create an event handler to be called during a certain event, whether it be every frame (enterFrame event), or at the press of a button (mouseDown event), in AS 3, you will need to use EventDispatcher. This means there are no more onEnterFrame of onPress functions you can define that will automatically handle these events, nor are there any simple addListener methods for generalized event listening. EventDispatcher and addEventListener (and related methods) does it all.

Methods

addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
dispatchEvent(event:Event):Boolean
hasEventListener(type:String):Boolean
removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void
willTrigger(type:String):Boolean

Note that addEventListener only takes functions as listeners, not objects. Also remember that class methods are bound to their instances so when used as listeners, 'this' in the event call still references the orginal class instance no matter what object dispatched the event.

Basic Example:

ActionScript Code:

package {

import flash.display.Sprite;
import flash.events.Event;

public class MyDispatcher extends Sprite {

public function MyDispatcher() {
addEventListener("customEvent", handleEvent);
dispatchEvent(new Event("customEvent"));
}

private function handleEvent(event:Event):void {
trace(event.type); // "customEvent"
}
}
}

By extending the EventDispatcher class or any class that inherits from it like Sprite (all DisplayObjects are inherently EventDispatchers), your class gains access to the EventDispatcher methods. Then, other instances (or the class instance itself) can add methods to instances of that class using addEventListener and in turn they can call those events through dispatchEvent.

If there is some reason your class cannot inherit from the EventDispatcher class (for example, if its already inheriting from another class which does not inherit from EventDispatcher), then you can use the EventDispatcher constructor to intialize your class instance with the methods of EventDispatcher via aggregation (composition). Just make sure you implement the IEventDispatcher interface (flash.events.IEventDispatcher). Ex:

ActionScript Code:

package {

import flash.display.Sprite;
import flash.events.Event;

public class MyDispatcher extends Sprite {

public function MyDispatcher() {
var dispatcher:CustomDispatcher = new CustomDispatcher();
dispatcher.addEventListener("customEvent", handleEvent);
dispatcher.dispatchEvent(new Event("customEvent"));
}

private function handleEvent(event:Event):void {
trace(event.type); // "customEvent"
}
}
}

import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IEventDispatcher;

class CustomDispatcher implements IEventDispatcher {

private var eventDispatcher:EventDispatcher;

public function CustomDispatcher() {
eventDispatcher = new EventDispatcher(this);
}

public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void {
eventDispatcher.addEventListener.apply(null, arguments);
}
public function dispatchEvent(event:Event):Boolean {
return eventDispatcher.dispatchEvent.apply(null, arguments);
}

public function hasEventListener(type:String):Boolean {
return eventDispatcher.hasEventListener.apply(null, arguments);
}

public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void {
eventDispatcher.removeEventListener.apply(null, arguments);
}

public function willTrigger(type:String):Boolean {
return eventDispatcher.willTrigger.apply(null, arguments);
}
}

The CustomDispatcher helper class above doesn't inherit from EventDispatcher but uses aggregation to obtain EventDispatcher functionality through an instance of EventDispatcher initialized in the constructor.

Approach to Depth Sorting

2007-04-19T10:04:00.000+08:00

Because of how the display list works with ActionScript 3, some methods of depth sorting will no longer work. One in particular is sorting objects on the screen based on their y location. In ActionScript 1 and 2, you could simply tell the clip to swapDepths at its _y location and be done with it. With AS3, this is no longer possible since no gaps can exist within the depths display list ("array").

An approach to obtaining the same functionality in AS3 is possible through an sorted array. Store the objects you want to arrange in an array. Then sort that array based on the y properties of the display objects within. All you have to do after that is place them in the display list in the order sorted. Ex:

ActionScript Code:

var sortedItems:Array = new Array(mc1, mc2, mc3);
function arrange():void {
sortedItems.sortOn("y", Array.NUMERIC);
var i:int = sortedItems.length;
while(i--){
if (getChildAt(i) != sortedItems[i]) {
setChildIndex(sortedItems[i], i);
}
}
}

Here the sortedItems array stores the display objects being sorted (mc1 - mc3). In the arrange function, that array is sorted based on their y properties and then added to the display list at their locations within the array (if not already there).

Though this is not quite as easy as swaping to the depth of the _y property, it still proves a fairly efficient means of sorting objects on the screen based on their y location.

Timer Class

2007-04-15T11:48:00.000+08:00

ActionScript 3 introduces a new class to ActionScript called the Timer class (flash.utils.Timer). This class is kind of like a suped-up setInterval (flash.utils.setInterval()) that sends event messages out over a period of time measured in milliseconds. Because it uses events (flash.events.TimerEvent) and not a callback like setInterval, a single Timer instance can be used to call many different functions as long as they are made listeners of that instance. Additionally, Timer gives you the ability to control how many times it repeats, unlike setInterval which repeats indefinitely until clearInterval is used to shut it down, as well as the ability to start and stop the timer on command.

Example:

ActionScript Code:

var timer:Timer = new Timer(500, 10);

timer.addEventListener(TimerEvent.TIMER, notifier);
timer.addEventListener(TimerEvent.TIMER, stopper);
stage.addEventListener(MouseEvent.CLICK, continuer);

function notifier(event:TimerEvent):void {
trace(timer.currentCount);
}
function stopper(event:TimerEvent):void {
switch (timer.currentCount) {
case 5:
timer.stop();
break;
case timer.repeatCount:
timer.reset();
break;
}
}
function continuer(event:MouseEvent):void {
timer.start();
}

timer.start();

This timer instance sends a TimerEvent.TIMER event every 500 milliseconds and repeats 10 times. There are 2 event listeners responding to these events, one tracing the current count of the timer and the other which will either stop (on current count of 5) or reset the timer (on current count of total count) based on the timer's current count. A mouse click to the stage will allow you to restart the timer as a result of it being stopped in the stopper listener. What you end up getting is

Code:

(pause; click to continue)

...

Regular Expression (RegExp) Support

2007-04-14T23:28:00.000+08:00

ActionScript 3 now supports regular expressions! The implementation is much like the one used in JavaScript. You can create new regexp patterns with the RegExp class constructor (top level) and a string or using the literal text format (defined like a string only replacing quotes with a forward slash (/). Ex:

ActionScript Code:

var reCon:RegExp = new RegExp("\\w+", "i");
var reLit:RegExp = /\w+/i;

RegExp methods include:

RegExp.exec()
RegExp.test()

String methods that work with regular expressions include:

String.match()
String.replace()
String.search()

Using prototype

2007-04-13T09:24:00.001+08:00

The prototype object in ActionScript is an object that exists among classes whose values are shared among all instances of the class to which it belongs. In ActionScript 1 and 2, it was used to control class inheritance. When a subclass instance references a variable, it first checks for that variable in the instance, followed by the class's prototype, followed by the superclass's prototype and so on through the prototype (inheritance) chain until there are no more classes.

In ActionScript 3, inheritance is primarily managed through Class inheritance and does not depend on the prototype object. However, the prototype object still exists and still provides much of the same functionality it did in AS1/AS2.

Each class and (non-method) function created in AS3 has a prototype object associated with it. For classes, prototype is read-only, meaning you cannot redefine it with a new value. However, it doesn't mean you cannot define new values within it (otherwise it would be pointless ). Function prototypes are not read only. This allows you to create dynamic classes using the old style of class definitions through functions and set up inheritance through redefining the prototype.

Example:

ActionScript Code:

package {

import flash.display.Sprite;

public dynamic class MyClass extends Sprite {

public function MyClass(){

// prototype = new Object(); // ERROR, cannot change prototype of class
prototype.newValue = 1; // OK, adding (or removing) prototyped values

trace(this.newValue); // 1
trace(prototype.toString); // function Function() {}
trace(prototype.addChild); // undefined
trace(addChild); // function Function() {}

// dynamic ("old style") class definition
var TempClass:Function = function():void {
trace("Create TempClass");
}

TempClass.prototype = prototype; // OK, can set up inheritance

var tempObject:* = new TempClass(); // "Create TempClass"

trace(tempObject.newValue); // 1
}
}
}

Note that you should always prefix dynamic variable references with the this keyword. Also note that the Object class methods are dynamic and are defined in the prototype (which is why they are not overridden with the override keyword). You may also notice that the tempObject is typed as * instead of TempClass. This is because TempClass is only recognized as being a Function in AS3, not an actual class though it can still be used as one. Though a Class type exists, dynamic classes created like TempClass will always be recognized as Functions so creating instances with them always generates instances typed as a generic object.

The override Keyword

2007-04-10T09:49:00.000+08:00

Overriding a method of a class means redefining a method for a class which would otherwise be inherited. The new method is then used in place of the inherited one (though the inherited method can still be invoked using super).

For ActionScript 3, when you override a method or property of a superclass, you need to use the override attribute with your new method. This specifies that the member you are creating is overriding that which would otherwise be inherited. If you do not use override with a method that already exists in a superclass, an error is thrown at compile time.

Ex:

ActionScript Code:

package {
import flash.display.*;
class MySprite extends Sprite {

private var children:Array = new Array();

public function MySprite() {
}

public override function addChild(child:DisplayObject):DisplayObject {
children.push(child);
super.addChild(child);
return child;
}
}
}

Since addChild exists in the Sprite superclass, the override attribute is needed to successfully define the new addChild method which also adds the child passed to a children array.

Note that the method signature needs to match that of the overriden method

Override works with both normal class methods as well as getter/setter methods (properties), but it will not work with any of the following:

Variables
Constants
Static methods
Methods that are not inherited
Methods that implement an interface method
Inherited methods that are marked as final in the superclass

Also be aware that override is not needed for methods inherited directly from the Object class. These include:

hasOwnProperty
isPrototypeOf
propertyIsEnumerable
setPropertyIsEnumerable
toString
valueOf

These methods are added dynamically and are not part of the actual class definition. The override keyword is to be used only with methods which are part of a class's original definition.

However, if extending a class which uses a method above as part of its defnition, the override keyword is required. For example, if you are extending Object, you do not need to use the override keyword for the toString method. But, if you extend the Sprite class, you will need to override toString since the Sprite class has its own unique toString which is part of its class definition.

Design Pattern: Adapter 模式 - Class Adapter[轉]

2007-04-09T11:55:00.000+08:00

Adapter模式的另一種作法是Class Adapter模式，在這個模式下，Adapter直接繼承Adaptee（要引進的新類別），以擁有當中的成員及方法，在C++中的話可以這麼作：

C++中可以多重繼承，但在Java中不行，所以在Java中若要採用Class Adapter，必須作點修改，一方面繼承Adaptee，一方面實作Target的介面：

代碼的實現是這樣的：

public class Adapter extends Adaptee implements Target {
// ....
}

當然，這必須您原先的Target定義了共同的介面，所以Class Adapter在Java中適用的場合較少，事實上，也比較建議使用Object Adapter，這樣的Adapter模式比較有彈性，例如，您可以在Adapter上加上個setter，以隨時可以抽換Adaptee。

在Java中，Class Adapter的一個應用場合是達到多重繼承的效果，您一定在很多時候聽別人說，介面（interface）可以達到多重繼承的效果，這是怎麼回事？

其實要討論這個問題，首先您對於C++中多重繼承要先有認識，新手看了書說介面可以達到多重繼承，切莫人云亦云，尤其是沒有學過C++的新手們，如果您對於C++多重繼承想要有所認識，請先看看多重繼承（一）與多重繼承（二）。

Java不能多重繼承，但為何說Java中可以使用介面（interface）來達到多重繼承的效果，首先效果之一，就如多重繼承（二）中描述的「多重繼承時通常其中一個基底類別作為private實作體，而其它的用以表現完全的抽象介面。」，在Java中這個效果可以使用介面來達到，介面此時所扮演的即多重繼承（二）中的抽象類別，一個完全的抽象介面，這個效果的達成方式，如介面（interface）型態中所介紹的，您可以直接對應這兩個主題中的程式實作來瞭解，瞭解Java中如何使用介面（interface）來達到C++中所謂多重繼承的「一種」效果。

來看看另一個情況。

如果有SomeClass類別與OtherClass類別，您想要SomeAndOther類別可以同時擁有SomeClass類別與 OtherClass類別中已定義好的操作，並可以進行多型操作，在C++中可以用多重繼承來達到，但在Java中顯然的無法使用多重繼承，怎麼辦？您可以在設計上先繞個彎，先使用兩個介面分別定義好SomeClass與OtherClass兩個類別的公開方法，例如：

public interface ISome {
public void doSome();
}

public interface IOther {
public void doOther();
}

接著讓SomeClass與OtherClass分別實作兩個介面：

public class SomeClass implements ISome {
      public void doSome() {
          ....
      }
  }
 

public class OtherClass implements IOther {
public void doOther() {
....
}
}

SomeAndOther如何同時擁有兩個SomeClass與OtherClass類別已定義好的操作？並可以多型操作？SomeAndOther可以繼承其中之一，並擁有其中之一，例如：

public class SomeAndOther extends SomeClass implements IOther {
private IOther other = new OtherClass();

public void doOther() {
other.doOther();
}
}

雖不滿意，但至少解決了目前的問題，當然這邊只是其中一例，畢竟C++是C++，Java是Java，兩者語法並不是一對一的關係，視實際需求還可以變化一下。