Hello Haxe篇 - 技术栈

前言

在 初见Haxe篇 中我们已经成功的将环境配置好了，如果没有请去看一眼，这一篇我要讲的是重头戏Haxe的语法 ，希望你能有所收获。致力于用最通俗的方式讲。当然你也可以去看Haxe官网的。

Haxe：4.3.7
设备：Windows 10专业版 x64
工具：VS Code

让我们开始吧>w<

我们一般使用微软的VS Code 进行源代码编程

Haxe的源码文件一般以.hx或者.hxs为文件后缀

1.Hello World！

此示例文件 HellowWorld.zip

haxe 复制代码

class HelloWorld {
    static public function main() {
        trace("Hello World");
    }
}

这是来自Haxe官方的第一个Haxe程序示例，我带你一行一行解释。
我们写代码一般采用三角形结构，因为这能让代码更加可读（因为三角形具有稳定性？

class HelloWorld {}

你可能会疑惑：欸第一行不应该没有}吗，这就是我想给你解释的

我们一般把成对的花括号内部包起来 的代码称之为代码块 ，代码块前面的即class叫关键字

一个代码块的判断就是：离自己最近的另一半并且配的这一半没有被其他花括号配成对儿。

第一行中的 {对应的就是最底下那一行的}，通常情况下，语法高亮一般会标注两个配对的花括号，这也是为什么写代码提倡写成三角形结构，你能够更好判断代码块从哪里开始到结束

就像告诉编译器：兄弟我这花括号括起来的是一个整体，不要把这里面的东西和其他地方的东西搞混了！

class：类，用来定义当前类，类的名称就是class后面的这个HelloWorld，我们口头上一般说成 class的名称/类名。注意：类名必须是大写开头，比如写成 helloWorld是错误的。
static public function main() {}

这是一个标准的函数代码块入口 ，我们口头上一般说成函数，这个函数是整个程序的入口。
- static：静态修饰符 ，声明这个叫main的函数是静态的。
- public：公开修饰符，声明该函数可以外部访问。
- function：函数定义 ，这个关键字的后面就是函数名。
- main：函数名，你可以大写开头但是官方不建议。
- ()：参数列表，接收传入的参数的，此处为空即无参。
trace("Hello World");

这里调用了Haxe的内部函数trace()，并把"Hello World"作为参数传递了进去，这个函数的作用是在控制台打印东西。

注意，末尾的;叫做语句终止符，他告诉编译器这个函数在这里结束（是英文的;不要打错成中文的；了）。

根据zip文件里的食用方法.txt 你会得到：

如果他像图片里面那样显示了HelloWorld.hx:3: Hello World

那么恭喜你成功编译成功了你的第一个Haxe程序，但是注意，这个程序运行在Haxe的neko虚拟机上（你得在安装的时候勾上，默认勾上了的）

中文避坑

如果你尝试打印中文，那么他可能会出现乱码的情况，那么就需要输入chcp 65001

2.关键字

Haxe内部提前定好了的有特殊用处的字段，本章重点讲解包管理，访问修饰符，实例化高频关键字。

公开私有静态

此示例文件KnockDoor.rar

KnockDoor.hx 复制代码

package;

import house.House;

class KnockDoor {
    static public function main() {
        House.broadcast(); // 可以
        // House.managerTalk(); // 不行，private

        var myHouse = new House();
        myHouse.knock();    // 可以
        // myHouse.whisper(); // 不行，private
        
        myHouse.testPrivate(); // 可以间接用public的函数调用内部的private函数
    }
}

house/House.hx 复制代码

package house;

class House {
    public function new(){}


    public function knock() {
        trace("我是家门门铃 → 必须有房子才能敲");
    }
    
    private function whisper() {
        trace("我是私房话 → 只有房子内部能听见");
    }

    static public function broadcast() {
        trace("我是小区广播 → 不用盖房，谁都能听");
    }

    static private function managerTalk() {
        trace("我是物业内部讲话 → 只有物业自己能用");
    }

    public function testPrivate() {
        whisper();    // 可以
        // managerTalk(); // 也可以
    }
}

运行后输出

house/House.hx:19: 我是小区广播 → 不用盖房，谁都能听

house/House.hx:9: 我是家门门铃 → 必须有房子才能敲

house/House.hx:14: 我是私房话 → 只有房子内部能听见

包管理器：package / import ：

package：规定了当前类在哪个包，直接跟;为根目录，package house; 表示当前类属于house包。
PS：文件名称建议与类名完全一致

import：导入其他包中的类，语法为 import 包名.类名，导入后可在当前类中使用目标类的功能。

访问修饰符：public / private 用于声明类/函数/变量的访问权限，核心区分「外部可访问」和「仅内部可访问」：

public ：公开，类实例化后，外部可直接调用；
private ：私有，即使类实例化，外部也无法调用，仅当前类内部可访问；
无修饰符的函数/变量：默认等价于private。
static：静态修饰符，声明静态的函数/变量，无需实例化类，可直接通过类名.函数名/变量名调用；

注意：静态函数内部，只能调用静态的函数/变量，无法调用非静态内容。

实例化关键字：new()

创建类的实例（对象），语法为var object = new 类名();
非静态的public函数/变量，必须通过类的实例才能调用。

这需要你自己去感受发掘，自己探寻他们之间的规律。

变量声明·数据类型

此示例文件Who.rar

haxe 复制代码

class Who {
    static var name:String = "MaoPou";
    static var years:Int = 16;
    static var height:Float = 175.8;
    static var man:Bool = true;

    static public function main() {

        var home:Array<String> = ["dad", "mom", "bro"];
        var familyTall:Array<Float> = [170, 165.8, 130];
        var famValue:Array<Dynamic> = [111, 1.23, "awa"];
        var huhArray:Array<Array<Float>> = [ [11, 12.2], [654, 222.3] ];

        var idk = null;
        var someValues:Dynamic = 1;

        trace(name);

        hello("LiHua");
    }

    static function hello(human:String) {
        trace("Hello !" + human);
    }
}

编译程序你会得到

Who.hx:17: MaoPou

Who.hx:23: Hello !LiHua

变量声明

var：声明变量，var的位置决定了哪些代码块能够调用他 ，代码块之间的变量不互通。可以搭配private/public/static 等关键字
注意：静态函数只能使用声明为静态的变量！非静态函数可以使用 静态/非静态 变量。
简化声明若省略数据类型，Haxe会自己判断类型
var idk = null：自动推断此变量为Null类型

基础数据类型

1.String字符串

String：字符串类型，简单来说就是用来存文本的，内容必须使用一对英文单/双引号包起来。

你可以这样给字符串赋值：

haxe 复制代码

  static var name1:String = "MaoPou";  //双引号
  static var name2:String = "123456";  //纯数字
  static var name3:String = '123acb';  //单引号

String字符串拼接

拼接方法

haxe 复制代码

var str1:String = "我爱";
var str2:String = "Haxe";
var Str3:String = "666";

trace("我爱" + "Haxe" + " " + "666"); //输出: 我爱Haxe 666
trace(str1 + str2 + " " + str3); //输出: 我爱Haxe 666

插值方法

haxe 复制代码

var str1:String = "我爱"; 
var str2:String = "Haxe";

//特别注意，只有单引号括起来的字符串才能使用${}进行插值
trace('你好！${str1}${str2}'); //输出: 你好！我爱Haxe
trace("你好！${str1}${str2}"); //输出: 你好！${str1}${str2}

2.Int/Float型

Int：整数型，储存整数（支持负数）
Float：浮点型，储存小数（浮点数，支持负数）

Float可以存整数但是注意一定要带上小数点 var infloat:Float = 60.0;

支持加减法

haxe 复制代码

var num1:Int = 50;
var num2:Float = 51.0;

var num3 = num1 + num2; //为101.0，类型为Float

3.Bool型

Bool：布尔型，表示真假，仅仅可以为 true/false

就像这样var man:Bool = false;

4.Array数组

Array：数组类型

语法：var home:Array<元数据类型> = [];

分为：一维数组（只有一个Array），多维数组（数组里面又套数组的）

如二维数组：var huhArray:Array<Array<Float>>

数组一般使用索引访问，

haxe 复制代码

var testArray:Array<String> = ["dad", "mom", "bro"];

数组的第一个对象索引从0开始，所以
trace(testArray[0]) 输出："dad"
trace(testArray[2]) 输出："bro"

数组一般用push写入数据，直接在数组的末尾添加

haxe 复制代码

//数组实际名称.push(元素或者对象);
testArray.push("aunt");
trace(testArray); //输出：["dad", "mom", "bro", "aunt"];

当然你也可以用索引修改对于对应的值

haxe 复制代码

testArray[0] = "me";`  
trace(testArray);  //输出：["me", "mom", "bro"]

移除对象

haxe 复制代码

testArray.remove(要移除的元素或者对象)
//如果你的数组里面存的都是string，那么他会移除从左往右第一个与他匹配的
huhArray:Array<String> = ["Java", "C", "Java", "Haxe"];
huhArray.remove("Java"); //变成了 ["C", "Java", "Haxe"];

//--------\\
testArray.splice(起始索引, 移除个数);
testArray.splice(1,2); //从索引1（"mom"）开始切除，切除2个对象，最终变成["dad"];

//--------\\
testArray.pop(); //移除最后一个成员
testArray.shift(); //移除第一个成员

5.Dynamic动态类型

Dynamic: 可以储存任意类型没有现在，一般只在不确定当前变量为什么类型的时候使用，不建议大量使用，会导致代码不好维护

6.Null空类型

Null: 表示变量为空，需要搭配基础类型Null<Int>，值为null。

想必你对Haxe有了一定的认识，我可能讲的不太周全，类型和一小些关键字就讲到这里，下一篇文章讲判断句等语法的应用