haxe 第一期 入门骗 （谷歌翻译+转载）

/* 
   欢迎在15分钟内学习Haxe 3。http://www.haxe.org 
   这是一个可执行的教程。
   您可以使用haxe编译器编译并运行它，
   而在与LearnHaxe.hx相同的目录中：   haxe -main LearnHaxe3 -x out 
   
   （只是把老外的文章谷歌翻译了而已，然后稍微整理了一下，可能有漏洞，还是推荐去看原文）
   
   （欢迎看原汁原味原网址，垃圾的我表示看不懂英文）
   https://github.com/jdonaldson/learnxinyminutes-docs/blob/master/haxe.html.markdown
   
   （附上一个看到的博客，里面文章对大家应该有帮助）
   http://blog.csdn.net/rocks_lee/article/details/10166573


*/


//我们从评论开始...这是一个单行评论


/* 
   这是多行的。多行注释也用于为haxedoc生成javadoc风格的文档。
   如果它们在类，类函数或类变量之前，它们将被使用。（传说中的代码提示）
*/


/* 
   这是你第一个实际的haxe代码，它宣布一个空的包。
   一个包不是必需的，
   但是如果要为代码创建一个命名空间
   （例如org.module.ClassName），这是非常有用的。*/ 


package;  //空包，没有命名空间。


/* 
   如果从其他文件导入代码，则必须在其余
   代码
之前声明。*/ 


import  haxe.ds.ArraySort ;


//您可以使用“*” 
import  haxe.ds. * 一次导入许多类/模块;


/* 您还可以以特殊方式导入类，使其能够扩展 其他类的功能。*/ 
   
using  StringTools ;


/* Typedefs类似于变量...。它们必须在任何代码之前声明。 */ 


typedef  FooString  =  String;


// Typedefs也可以使用“结构”类型，更多的也在以后！
typedef  FooObject  =  {  foo： String  } ;


class LearnHaxe01{
    /* 
       如果你希望某些代码自动运行，你需要把它放在
       一个静态的主要功能，并在编译器参数指定类。
       在这种情况下，我们在上面的编译器参数中指定了“LearnHaxe3”类。     */ 
  
   static function main(){
        /* 
           Trace是将haxe表达式打印到屏幕的默认方法。
  不同的目标将有不同的实现方法。例如，java，c ++，c＃等将打印出来。
  Javascript将打印到console.log，flash将打印到一个嵌入的TextField。
  所有痕迹都附带默认换行符。
           最后，可以通过使用编译器上的“--no-traces”参数来防止跟踪显示。         */




       trace("Hello World, with trace()!");


        /* 
           Trace可以处理任何类型的值或对象。它将尝试最好地打印
           表达式的表示。您也可以连接字符串用“+”操作符：
         */ 
  
         trace(
            " Integer: " + 10 +
            " Float: " + 3.14 +
            " Boolean: " + true
            );


/*新增 抛出错误*/
try
{
throw "invalid foo"; //抛出错误后记得关闭运行的文件，否则一直编译报错，不明所以


}catch (e:String){}  //不同于as3的抛出错误

/*新增 确定值类型*/
var a:Int = 0;
$type(a);  //能输出值的类型，但是会报错


        /* 
           记住我所说的表达式需要分号吗？
  如果需要，您可以在一行上放置多个表达式。
         */ 
  
        trace('two expressions..'); trace('one line');


        ////////////////////////////////////////////////// //////////////// 
        //类型和变量
        /////////////////////////// ///////////////////// 

       trace("***Types & Variables***");




        /* 可以使用 “var”关键字保存数据结构的值和引用*/


        var an_integer:Int = 1;
        trace(an_integer + ' is the value for $an_integer');  
/*新增 注意上面这行代码，在字符串中加了一个 $ 后面接变量名就可以代表变量了
* 注意 仅在单引号内有效
* */


        /* 
           Haxe是静态类型的，所以“an_integer”被声明为具有“Int”类型，而其余的表达式将赋值为“1” 
           。在许多情况下不需要声明类型。这里，haxe编译器推断another_integer的类型应该是“Int”。
         */


        var another_integer = 2;
        trace(another_integer + " is the value for another_integer");




        // $ type（）方法打印编译器分配的类型：
        $type(another_integer);


        //您也可以用十六进制表示整数：
        var hex_integer = 0xffffff;


        /* 
           Haxe使用Int和Float尺寸的平台精度。
  它还使用平台行为溢出。
           （使用特殊库可以使用其他数字类型和行为）         */


        /* 
           除了诸如整数，浮点数和布尔值之类的简单值之外，
           Haxe为常见的数据结构（如字符串，数组，列表和映射）提供标准库实现：         */


        var a_string = "some" + 'string';    //字符串可以有双引号或单引号,好像在调用的时候也没啥差别

        trace(a_string + " is the value for a_string");


        var x = 1;
        var an_interpolated_string = 'the value of x is $x';


        /* 
           字符串是不可变的，实例方法将返回部分或全部字符串的副本。
           （另请参见StringBuf类）。
         */ 
  
       var a_sub_string = a_string.substr(0,4);
       trace(a_sub_string + " is the value for a_sub_string");


        /* 
           数组是零索引的，动态的和可变的。缺少值被
           定义为null。
         */ 
  
/*新增  注意这里
* 
* 在as3中，通常我们在写数组时会 
* 
* var arr:Array = new Array(); 
* 
* 但是在haxe里，这样是错误的，而且
* 
* var a:Array = new Array<String>();
* 
* 这样写同样会报错
* 
* */ 
 
        var a = new Array<String>();   //包含字符串
        a[0] = 'foo';
        trace(a.length + " is the value for a.length");
        a[9] = 'bar';
        trace(a.length + " is the value for a.length (after modification)");
        trace(a[3] + " is the value for a[3]");


        /* 数组是*通用*，所以你可以用一个类型参数来指出它们包含的值：  */ 

        var a2 = new Array<Int>();// Ints的数组
        var a3 = new Array<Array<String>>();   //数组数组（字符串）。


        /* 地图是简单的键/值数据结构。键和值可以是任何类型。 */ 

        var m = new Map<String, Int>();   //键是字符串，值是Ints。
        m.set('foo', 4);

        //你也可以使用数组符号; 

/*新增 注释  总觉得这东西有点像dictionary
* 你可以通过一下几个方法访问m    
*  m['foo'];
*  m.get("foo");
* */

        m['bar'] = 5;

/*确定一个键值是否存在*/
        trace(m.exists('bar') + " is the value for m.exists('bar')");

        trace(m.get('bar') + " is the value for m.get('bar')");
        trace(m['bar'] + " is the value for m['bar']");

/*新增 注释 可以用下面这种方法来添加数据*/
var m2 =  ['foo' => 4, 'baz' => 6]; // Alternative map syntax
        trace(m2 + " is the value for m2");




        /* 
           记住，你可以使用类型推断。Haxe编译器将
           在您首次传递设置类型参数的参数时决定变量的类型。         */ 
  
var m3 = new Map();
        m3.set(6, 'baz'); // m3 is now a Map<Int,String>
        trace(m3 + " is the value for m3");


        /* 
           Haxe在haxe.ds模块中有更多常见的数据结构，例如
           List，Stack和BalancedTree 
         */




        ////////////////////////////////////////////////// //////////////// 
        //操作员
        ///////////////////////////// //////////////////// 
        trace("***OPERATORS***");


        //基本算术
        trace((4 + 3) + " is the value for (4 + 3)");
        trace((5 - 1) + " is the value for (5 - 1)");
        trace((2 * 4) + " is the value for (2 * 4)");
        trace((8 / 4) + " is the value for (8 / 3) (division always produces Floats)");
        trace((12 % 4) + " is the value for (12 % 4)");




        //基本比较
        trace((3 == 2) + " is the value for 3 == 2");
        trace((3 != 2) + " is the value for 3 != 2");
        trace((3 >  2) + " is the value for 3 > 2");
        trace((3 <  2) + " is the value for 3 < 2");
        trace((3 >= 2) + " is the value for 3 >= 2");
        trace((3 <= 2) + " is the value for 3 <= 2");


        //按位运算符
         /*
        ~       Unary bitwise complement
        <<      Signed left shift
        >>      Signed right shift
        >>>     Unsigned right shift
        &       Bitwise AND
        ^       Bitwise exclusive OR
        |       Bitwise inclusive OR
        */


        // increment 
var i = 0;
        trace("Increments and decrements");
        trace(i++); //i = 1. Post-Incrementation
        trace(++i); //i = 2. Pre-Incrementation
        trace(i--); //i = 1. Post-Decrementation
        trace(--i); //i = 0. Pre-Decrementation


        ////////////////////////////////////////////////// //////////////// 
        //控制结构
        //////////////////////////// //////////////////// 
         trace("***CONTROL STRUCTURES***");


        // if statements 
        var j = 10;
        if (j == 10){
            trace("this is printed");
        } else if (j > 10){
            trace("not greater than 10, so not printed");
        } else {
            trace("also not printed.");
        }


        // there is also a "ternary" if:
        (j == 10) ?  trace("equals 10") : trace("not equals 10");


        /* 
           最后，还有一种形式的控制结构
           在编译时运行：条件编译。
         */ 
  
#if neko
trace('hello from neko');
#elseif js
trace('hello from js');
#else
trace('hello from another platform!');
#end

        /* 
           编译后的代码将根据平台目标而有所不同。
           由于我们正在为neko（-x或-neko）进行编译，所以我们只得到了neko的
           问候语。
         */
  
trace("循环和迭代");
        // while loop 
        var k = 0;
        while(k < 100){
            // trace（counter）; //将打印出数字0-99 
            k++;
        }


        // do-while loop 
         var  l = 0;
        do{
            trace("do statement always runs at least once");
        } while (i > 0);


        // 循环
        /* 
           Haxe中没有c-style for循环，因为它们容易出错，而不是必需的。
  相反，Haxe有一个使用迭代器的更简单和更安全的版本（更多在以后）。     
*/ 
  
        var m = [1,2,3];
        for (val in m){
            trace(val + " is the value for val in the m array");
        }


        //请注意，您可以使用范围
       
var n = ['foo', 'bar', 'baz'];
        for (val in 0...n.length){
            trace(val + " is the value for val (an index for m)");
        }




       trace("Array Comprehensions");


        //数组解析使您能够遍历数组
        //同时创建过滤器和修改。
         var filtered_n = [for (val in n) if (val != "foo") val];
        trace(filtered_n + " is the value for filtered_n");


        var modified_n = [for (val in n) val += '!'];
        trace(modified_n + " is the value for modified_n");


        var filtered_and_modified_n = [for (val in n) if (val != "foo") val += "!"];
        trace(filtered_and_modified_n + " is the value for filtered_and_modified_n");




        ////////////////////////////////////////////////// ////////////// 
        // //切换语句（值类型）
        //////////////////////// ////////////////////// 
        trace("***SWITCH STATEMENTS (VALUE TYPES)***");


        /* 
           在Haxe中的切换语句非常强大。除了处理
           诸如字符串和int之类的基本值之外，它们还可以处理
           枚举中的广义代数数据类型（稍后更多的枚举）。          
  这里有一些基本的价值实例：
         */ 
  
/*新增 注释 注意这里 switch语句没有break 要注意这里和其他语言的区别
* 但是我们可以这样写   case 1,2  用逗号把选项分开
* */
  
        var my_dog_name = "fido";
        var favorite_thing  = "";
        switch(my_dog_name){
            case "fido" : favorite_thing = "bone";
            case "rex"  : favorite_thing = "shoe";
            case "spot" : favorite_thing = "tennis ball";
            default     : favorite_thing = "some unknown treat";
            // case _   : "some unknown treat"; // same as default
        }
        //上面的“_”一个“通配符”值,将匹配任何东西。相当于default


        race("My dog's name is" + my_dog_name
                + ", and his favorite thing is a: "
                + favorite_thing);


        ////////////////////////////////////////////////// //////////////// 
        //表达陈述
        //////////////////////////// //////////////////// 
       
trace("***表达声明***");

        /*  Haxe控制语句非常强大，因为每个语句也是一个表达式*/

/*新增 注释 太强大 先吃一粒定心丸，可能有点颠覆我们的习惯*/


        // if statements 
        var k = if (true){
            10;
        } else {
            20;
        }




        trace("K equals ", k);   //输出10


        var other_favorite_thing = switch(my_dog_name) {
            case "fido" : "teddy";
            case "rex"  : "stick";
            case "spot" : "football";
            default     : "some unknown treat";
        }


        trace("My dog's name is" + my_dog_name
                + ", and his other favorite thing is a: "
                + other_favorite_thing);


        ////////////////////////////////////////////////// ////////////// 
        // //转换价值类型
        /////////////////////////// ///////////////////// 
       
trace("***转换类型***");


        //您可以很容易地将字符串转换为int。


        // string to integer 
        Std.parseInt("0");  //返回0 
        Std.parseFloat("0.4");  //返回0.4;


        // integer to string 
        Std.string(0);  //返回“0”; 
        //串联与字符串将自动转换为字符串。
         0 + "";    //返回“0”; 
        true + "";  //返回“true”; 
        //有关详细信息，请参阅Std中的解析文档。

/*新增 注释 Std 这个类提供了一些常用的数值运算 可以点进入类看看，方法不是很多,且提供了类型判断
* 在as3中 我比较习惯直接 用is 来判断类型，
* 但是在haxe中 is会报错,
* 但是我们可以使用 Std.is(123.1315,Int); 来判断
* */




        ////////////////////////////////////////////////// //////////////// 
        //处理类型
        /////////////////////////// /////////////////////////////////////


        /*


           如前所述，Haxe是一种静态类型的语言。总而言之
           ，静态打字是一件奇妙的事情。
  它启用自动完成，可以非常彻底地检查程序的正确性。
  另外，Haxe编译器超级快。你可能不会在等待它了。


           *无论如何*，有时您只希望编译器会让
           某些东西滑动，而不要在有限的情况下抛出类型错误。


           为了做到这一点，Haxe有两个单独的关键字。第一个是
           “Dynamic”类型：
         */ 
        var dyn: Dynamic = "any type of variable, such as this string";


        /* 
           所有你知道的一个动态变量是
           编译器不再担心它是什么类型。它就像一个
           通配符变量：你可以传递它，而不是任何变量类型，
           你可以分配任何你想要的变量类型。


           另一个更极端的选项是“无类型”关键字
         */


            untyped {
                var x:Int = 'foo';
                var y:String = 4;
            }


        /* 
           untyped关键字在整个* block *代码上运行，跳过
           任何可能需要的类型检查。该关键字应该
           非常谨慎地使用，例如在有条件编译的
           情况下，类型检查是一种阻碍。


           一般来说，跳过类型检查是*不*推荐。使用
           枚举，继承或结构类型模型来验证程序的正确性。
  只有当您确定所有类型型号都不工作时，您应该使用“动态”或“无类型”。         */


        ////////////////////////////////////////////////// ////////////// 
        //基础面向对象编程
        ////////////////////////// //////////////////// 
        
trace("***基于对象的面向对象编程***");


        /* 
           创建一个FooClass的实例。这些类在文件的末尾。         */


       var instance = new FooClass(3);


        //读取公共变量通常
        trace(instance.public_any + " is the value for instance.public_any");


        //我们可以读此变量
        trace(instance.public_read + " is the value for instance.public_read");
        //但不写它
        // instance.public_write = 4; //如果取消注释，这将抛出一个错误：
        // trace（instance.public_write）; //就这样


        trace(instance + " is the value for instance");  //调用toString方法
        trace(instance.toString() + " is the value for instance.toString()");  // 一样




        /* 
           实例具有“FooClass”类型，而acceptBaseFoo具有
           BaseFooClass类型。但是，由于FooClass扩展了BaseFooClass，
           所以被接受。
         */ 
  
        BaseFooClass.acceptBaseFoo(instance);


        /* 
           下面的类有一些更高级的例子，“example（）” 
           方法将在这里运行。
         */ 
  
        SimpleEnumTest.example();
        ComplexEnumTest.example();
        TypedefsAndStructuralTypes.example();
        UsingExample.example();


    }


}


/* 
  这是主要的LearnHaxe3类的“子类” 
*/ 
class FooClass extends BaseFooClass implements BaseFooInterface{
    public var public_any:Int;  //公共变量是随时随地访问
    public var public_read (default,null): Int;  //使用此样式仅启用公共读取
    public var public_write (null, default): Int; //或public write 
    public var property (get, set): Int;  //使用此样式来启用getter / setter


    //私有变量在类之外是不可用的。
    // see @：allow for around around this。
    var _private:Int;   //如果变量未标记为public，则变量为private


    // public 
    public function new(arg:Int){
        super();  //调用父对象的构造函数，因为我们扩展了BaseFooClass


        this.public_any= 0;
        this._private = arg;


    }


    // getter for _private 
    function get_property() : Int {
        return _private;
    }


    // setter for _private 
   function set_property(val:Int) : Int {
        _private = val;
        return val;
    }


    //每当将实例转换为字符串时调用的特殊函数。
   public function toString(){
        return _private + " with toString() method!";
    }




    //这个类需要定义这个函数，因为它实现了BaseFooInterface接口。
    public function baseFunction(x: Int) : String{
        // convert the int to string automatically
        return x + " was passed into baseFunction!";
    }
}


/* 
    一个简单的类来扩展
*/ 
class BaseFooClass {
    var base_variable:Int;
    public function new(){
        base_variable = 4;
    }
    public static function acceptBaseFoo(b:BaseFooClass){
    }
}


/* 
    一个简单的接口来实现
*/ 
interface BaseFooInterface{
    public function baseFunction(x:Int):String;
}


////////////////////////////////////////////////// ////////////// 
//枚举和切换语句
////////////////////////// //////////////////////////////////////


/* Haxe中的枚举非常强大。枚举是最简单的形式，它是一个数量有限的类型：*/


enum SimpleEnum {
    Foo;
    Bar;
    Baz;
}


//这是一个使用它的类：


class SimpleEnumTest{
    public static function example(){
        var e_explicit:SimpleEnum = SimpleEnum.Foo; //可以指定“完整”名称
        var  e  =  Foo ;  //但推论也会奏效。

switch(e){
            case Foo: trace("e was Foo");
            case Bar: trace("e was Bar");
            case Baz: trace("e was Baz"); // 注释此行以抛出错误。
        }


        /* 
           这与字符串上的简单值开关看起来没有什么不同。
           但是，如果我们不包括* all *的状态，
  编译器会抱怨。您可以通过注释上面的一行来尝试。


           您还可以为枚举开关指定默认值：
         */ 
        switch(e){
            case Foo: trace("e was Foo again");
            default : trace("default works here too");
        }
    } 
}


/* 
    枚举远远超过简单的状态，
我们也可以枚举 *构造函数*，
但是我们需要一个更复杂的枚举例子
*/ 
enum ComplexEnum{
    IntEnum(i:Int);
    MultiEnum(i:Int, j:String, k:Float);
    SimpleEnumEnum(s:SimpleEnum);
    ComplexEnumEnum(c:ComplexEnum);
}
//注意：上面的枚举可以包括*其他*枚举，包括自己！


class ComplexEnumTest{
    public static function example(){
        var e1:ComplexEnum = IntEnum(4); //指定枚举参数

        /* 现在我们可以打开枚举，并提取它可能有的任何参数。         */ 

        switch(e1){
            case IntEnum(x) : trace('$x was the parameter passed to e1');
            default: trace("Shouldn't be printed");
        }




        //这里的另一个参数本身就是枚举枚举枚举？
        var e2 = SimpleEnumEnum(Foo);
        switch(e2){
            case SimpleEnumEnum(s): trace('$s was the parameter passed to e2');
            default: trace("Shouldn't be printed");
        }


        //枚举一路向下
var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3)));
case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : {
                trace('$i, $j, and $k were passed into this nested monster');
            }
            default: trace("（“不应打印”");
        }

        /* 查看“广义代数数据类型”（GADT），了解更多关于为什么这么大的细节。   */ 

    } 
}


class TypedefsAndStructuralTypes {
    public static function example(){

        //这里我们要使用typedef类型，而不是基类型。

         var t1:FooString = "some string";


        /* 
           我们可以使用typedef作为“结构类型”。
  这些类型由它们的字段结构定义，而不是类继承。
  这是一个名为“foo”的String字段的匿名对象：*/


        var fooObj = { foo: 'hi' };


        /* 
           记住在我们宣布FooObj typedef的顶部？
           由于fooObj与该结构相匹配，
  所以我们可以在任何需要“FooObject”的地方使用它。         */


        var f = function(fo:FooObject){
            trace('$fo was passed in to this function');
        }
        f(fooObj);  //用fooObj调用FooObject签名函数。


        /* 
           请注意，typedef还可以包含可选字段，标有“？”
 
            typedef OptionalFooObj = {
                ?optionalString: String,
                requiredInt: Int
           }
  
         */


        /* 
           Typedef与条件编译工作良好。例如，
           我们可以将其包含在文件的顶部：
  


#if（js）
typedef Surface = js.html.CanvasRenderingContext2D; 
#elseif（nme）
typedef Surface = nme.display.Graphics; 
#elseif（！flash9）
typedef Surface = flash8.MovieClip; 
#elseif（java）
typedef Surface = java.awt.geom.GeneralPath; 
＃结束

这将给我们一个单一的“表面”类型，以便在所有这些平台上使用。
        */ 
    } 
}


class UsingExample {
    public static function example() {


        /* 
           “using”import关键字是一种特殊的类导入，
  它改变了类中任何静态方法的行为。


           在这个文件中，我们将“using”应用于“StringTools”，
  它包含了一些用于处理String类型的静态方法。
         */ 
  
         trace(StringTools.endsWith("foobar", "bar") + " should be true!");


        /* 
           使用“using”导入时，第一个参数类型将使用该
           方法进行扩展。这意味着什么？那么，既然“的endsWith”具有第一 “字符串”，
  这意味着所有的字符串类型现在有的参数类型“的endsWith”的方法：
         */ 
  
        trace("foobar".endsWith("bar") + " should be true!");


        /* 
           这种技术可以为某些类型提供很好的表达，
           同时限制对单个文件的修改范围。

           请注意，String实例在运行时是*不*修改。
           新附加的方法不是附加
           实例的一部分，编译器仍然生成等效于静态方法的代码。      
*/ 
      }


}