haXe 2 Beginner's Guide: Develop exciting applications with this multi-platform programming language

If you're familiar with Object Oriented Programming (OOP) languages, then there are chances that you at least know the words "packages" and "classes"; if that's not the case, don't panic, you are going to learn all of it here.

There are six types of constants in haXe. We will now take a look at all of them. Some of them are composed of several kinds of them.

Binary and unary operators are two very important concepts in programming because they can both respectively be used to manipulate data. So, let's start with binary operators.

Blocks are important things in haXe, as they can help you write things that might be complicated in some languages in an easy way. Blocks are delimited in the C-style by the { and } characters. What makes them special in haXe is that they have a value and a type. A block's value and type is those of the last expression of this block. Note that empty blocks are of Void type. This type is used to indicate that no value is going to be returned.

Here's an example on how that may ease writing in some cases:

public static function main() : Void
{
   var s : String;
   s = if(true)
      {
         "Vrai";
      } else
      {
         "Faux";
      }
   trace(s);
}

In this example, it will always trace Vrai (which is the French translation of "True"), but I think you get the idea. In most other languages, you would have to write something like:

public static function main() : Void
{
   var s : String;
   if(true)
      {
         s = "Vrai";
      } else
      {
         s = "Faux";
      ...

Understanding how variable declaration is done and its scope is very important.

Now, imagine that we want to create a class named Person. Its instances should have a public name field, a private age field, and the class should have a static and public count field.

Accessing fields and calling methods in haXe is quite easy. All fields of an object (that is all functions that are variables of this object) are accessed by using the dot notation. So, if you want to access the name variable of an object named user you can do so in the following way:

user.name

Calling a function is really easy too, all you have to do is put parentheses after the function's name and eventually write all of your arguments inside the parentheses, separated by commas. Here's how to call a function named sayHelloTo of an object named user, taking two strings as parameters:

user.sayHelloTo("Mr", "Benjamin");

That's all! It's quite easy, really.

Constructing a class instance is done using the new keyword, as follows:

var user = new User("Benjamin");

In this example, we create an instance of the User class. Doing so calls the class' constructor. The class constructor is defined in the class as the public non-static new function. It may take any number of parameters. The following is an example of our User class:

class User
{
   public function new(title : String, name : String)
   {
      //Do things
   }
}

You can call the superclass's constructor by calling super() (with parameters if needed).

You can access the current class instance using the this keyword.

Conditional branching is a very important part of programming because it will allow your program to behave differently depending on the context. So, let's talk about if and switch.

if(age<18)
{
   trace("you are not an adult.");
} else
{
   trace("You are an adult");
}

if(age<18)
   trace("you are not an adult.");
else
   trace("You are an adult");

Loops are one of the basic constructs in a language. So, let's see the loops that haXe supports.

while(condition) exprToBeExecuted;
doexprToBeExecuted while(condition);

public static function main()
{
   var i : Int = 0;
   while(i< 18)
   {
      trace(i); //Will trace numbers from 0 to 17 included
      i++;
   }
}

public static function main()
{
   var i : Int = 0;
   do
   {
      trace(i); //Will...

break and continue are two keywords used inside loops.

The break keyword allows one to exit a loop prematurely. Now, let's imagine that we have a loop that has 10 iterations, but we only want to go through the first eight ones.

Let's write a simple loop from 0 to 9 included. Note that we want to exit this loop as soon as we hit the 9^th one.

for(i in 0...10)
{
   if(i==8)
   {
      break;
   }
   trace(i);
}

Let's say that we want to display the number from 0 to 9 included, but not the number 8. We can use the continue keyword to do so, by directly going to the next iteration of our loop.

Let's write the following code that contains our loop, and a test done at each iteration to jump to the next iteration if needed:

for(i in 0...10)
{
   if(i==8)
   {
      continue;
   }
   trace(i);
}

The return keyword is used to exit from a function or to return a value from a function (and exit it).

function isAdult (age : Int) : Bool
{
   if(age < 18)
   {
      return false;
   }
   return true;
}

This is a function that should help you understand how to use the return keyword. It returns false if the age is inferior to 18, or else it returns true.

Exceptions are messages passed from the inner call of your program to the outer call (it is going through the stack from the most recent call to the older one). In haXe, any object can be thrown as an exception. Exception handling (that is intercepting those messages) is done with the help of the try and catch keywords.

try
{
   doSomething();
} catch (e : Int)
{
   //If do something throws an Int this block of code will be executed.
} catch (e : String)
{
   //If do something throws a String this block of code will be executed.
} catch (e : Dynamic)
{
   //If do something throws something else this block of code will be executed.
}

As you can see in this example, you can specify different types of exceptions to intercept and execute different blocks of code according to these types. The Dynamic type allows you to intercept any type of exception that hasn't been intercepted before. Mind the order in which you write your blocks, as they are evaluated from top to bottom...

Anonymous objects are objects that you create on the fly using brackets. The following is an example:

{ age : 12, name : "Benjamin" };

This object, despite not being created from any class, is typed. Its type is: {age :Int, name : String}.

The following is an example that you can run:

class TesthaXe
{
   public static function main(): Void
   {
      var user = {name : "Benjamin", age:12};
      neko.Lib.println("User " + user.name + " is " + user.age + " years old.");
   }
}

This program will print User Benjamin is 12 years old.

Local functions are functions without a name. (often named "anonymous functions") They are values and as such can be assigned to any variable. The following is an example:

public class User
{
   var sayHello : String->Void;
   
   public function new()
   {
      sayHello =    function(to : String)
               {
                  trace("Hello" + to);   
               };
   }
}

Local functions can access any local variable declared in the same scope as static variables, but cannot access the this variable.

Local functions are typed. The local function in the preceding example is typed as String-> Void. A function that takes a String, an Int, and returns a String would be typed as String ->Int -> String.

So, continuing the previous example, one could call the function in the following way:

public class User
{
   var sayHello : String->Void;
   
   public function new()
   {
      sayHello =    function(to : String)
               {
                  trace("Hello...

This has been a pretty long chapter and we are now going to create something, which takes advantage of all that you have seen!

We are going to create software to manage a fridge. We want to be able to add meals inside it, and to list what is in it. Ok, let's start!

We learned a lot in this chapter about syntax.

Specifically, we covered how to declare classes and variables. We also covered how to iterate on lists and arrays, and how things are organized in haXe.

Don't worry, things will get easier now that we are done with the basics of the language.