Types¶

Zephir is both dynamically and statically typed. In this chapter we highlight the supported types and their behaviors.

Dynamic Types¶

Dynamic variables are exactly like the ones in PHP. They can be assigned and reassigned to different types without restriction.

A dynamic variable must be declared with the keyword var. The behavior is nearly the same as in PHP:

var a, b, c;

Initialize variables¶

let a = "hello", b = false;

Change their values¶

let a = "hello", b = false;
let a = 10, b = "140";

Perform operations¶

let c = a + b;

They can have eight types:

Type	Description
`array`	An array is an ordered map. A map is a type that associates values to keys.
`boolean`	A boolean expresses a truth value. It can be either `true` or `false`.
`float`/`double`	Floating point numbers. The size of a float is platform-dependent.
`integer`	Integer numbers. The size of an integer is platform-dependent.
`null`	The special NULL value represents a variable with no value.
`object`	Object abstraction like in PHP.
`resource`	A resource holds a reference to an external resource.
`string`	A string is series of characters, where a character is the same as a byte.

Check more info about these types in the PHP manual.

Array¶

The array implementation in Zephir is basically the same as in PHP: ordered maps optimized for several different uses; it can be treated as an array, list (vector), hash table (an implementation of a map), dictionary, collection, stack, queue, and probably more. As array values can be other arrays, trees and multidimensional arrays are also possible.

The syntax to define arrays is slightly different than in PHP:

Square braces must be used to define arrays¶

let myArray = [1, 2, 3];

Double colon must be used to define hashes' keys¶

let myHash = ["first": 1, "second": 2, "third": 3];

Only long and string values can be used as keys:

let myHash = [0: "first", 1: true, 2: null];
let myHash = ["first": 7.0, "second": "some string", "third": false];

Boolean¶

A boolean expresses a truth value. It can be either true or false:

var a = false, b = true;

Float/Double¶

Floating-point numbers (also known as "floats", "doubles", or "real numbers"). Floating-point literals are expressions with one or more digits, followed by a period (.), followed by one or more digits. The size of a float is platform-dependent, although a maximum of ~1.8e308 with a precision of roughly 14 decimal digits is a common value (the 64 bit IEEE format).

var number = 5.0, b = 0.014;

Floating point numbers have limited precision. Although it depends on the system, Zephir uses the same IEEE 754 double precision format used by PHP, which will give a maximum relative error due to rounding in the order of 1.11e-16.

Integer¶

Integer numbers. The size of an integer is platform-dependent, although a maximum value of about two billion is the usual value (that's 32 bits signed). 64-bit platforms usually have a maximum value of about 9E18. PHP does not support unsigned integers so Zephir has this restriction too:

var a = 5, b = 10050;

Integer overflow¶

Contrary to PHP, Zephir does not automatically check for integer overflows. Like in C, if you are doing operations that may return a big number, you should use types such as unsigned long or float to store them:

unsigned long my_number = 2147483648;

Object¶

Zephir allows to instantiate, manipulate, call methods, read class constants, etc from PHP objects:

let myObject = new \stdClass(),
    myObject->someProperty = "my value";

String¶

A string is series of characters, where a character is the same as a byte. As PHP, Zephir only supports a 256-character set, and hence does not offer native Unicode support.

var today = "friday";

In Zephir, string literals can only be specified using double quotes (like in C or Go). Single quotes are reserved for char data type.

The following escape sequences are supported in strings:

Sequence	Description
`\t`	Horizontal tab
`\n`	Line feed
`\r`	Carriage return
`\\`	Backslash
`\"`	double-quote

var today    = "\tfriday\n\r",
    tomorrow = "\tsaturday";

In Zephir, strings don't support variable parsing like in PHP; you need to use concatenation instead:

var name = "peter";

echo "hello: " . name;

Static Types¶

Static typing allows the developer to declare and use some variable types available in C. Variables can't change their type once they're declared as static types. However, they allow the compiler to do a better optimization job. The following types are supported:

Type	Description
`array`	A structure that can be used as hash, map, dictionary, collection, stack, etc.
`boolean`	A boolean expresses a truth value. It can be either `true` or `false`.
`char`	Smallest addressable unit of the machine that can contain basic character set.
`float`/`double`	Double precision floating-point type. The size is platform-dependent.
`integer`	Signed integers. At least 16 bits in size.
`long`	Long signed integer type. At least 32 bits in size.
`string`	A string is a series of characters, where a character is the same as a byte.
`unsigned char`	Same size as `char`, but guaranteed to be unsigned.
`unsigned integer`	Unsigned integers. At least 16 bits in size.
`unsigned long`	Same as `long`, but unsigned.

Boolean¶

A boolean expresses a truth value. It can be either true or false. Contrary to the dynamic behavior detailed above, static boolean types remain boolean (true or false) no mater what value is assigned to them:

boolean a;
let a = true;

automatically casted to `true`¶

let a = 100;

automatically casted to `false`¶

let a = 0;

throws a compiler exception¶

let a = "hello";

Char/Unsigned Char¶

char variables are the smallest addressable unit of the machine that can contain the basic character set (generally 8 bits). A char variable can be used to store any character in a string:

char ch, string name = "peter";

stores 't'¶

let ch = name[2];

`char` literals must be enclosed in single quotes¶

let ch = 'Z';

Integer/Unsigned Integer¶

integer values are like the integer member in dynamic values. Values assigned to integer variables remain integer:

int a;

let a = 50,
    a = -70;

automatically casted to 100¶

let a = 100.25;

automatically casted to 0¶

let a = null;

automatically casted to 0¶

let a = false;

throws a compiler exception¶

let a = "hello";

unsigned integer variables are like integer but they don't have sign, this means you can't store negative numbers in these sort of variables:

uint a;

let a = 50;

automatically casted to 70¶

let a = -70;

automatically casted to 100¶

let a = 100.25;

automatically casted to 0¶

let a = null;

automatically casted to 0¶

let a = false;

throws a compiler exception¶

let a = "hello";

unsigned integer variables are twice bigger than standard integer. Assigning unsigned integer to standard (signed) integer may result in loss of data:

potential loss of data for `b`¶

uint a, int b;

let a = 2147483648,
    b = a;

Long/Unsigned Long¶

long variables are twice bigger than integer variables, thus they can store bigger numbers. As with integer, values assigned to long variables are automatically casted to this type:

long a;

let a = 50,
    a = -70;

automatically casted to 100¶

let a = 100.25;

automatically casted to 0¶

    let a = null;

automatically casted to 0¶

let a = false;

throws a compiler exception¶

let a = "hello";

unsigned long are like long but they are not signed, this means you can't store negative numbers in these sort of variables:

ulong a;

let a = 50;

automatically casted to 70¶

let  a = -70;

automatically casted to 100¶

let a = 100.25;

automatically casted to 0¶

let a = null;

automatically casted to 0¶

let a = false;

throws a compiler exception¶

let a = "hello";

unsigned long variables are twice bigger than standard long; assigning unsigned long to standard (signed) long may result in loss of data:

potential loss of data for `b`¶

ulong a, long b;

let a = 4294967296,
    b = a;

String¶

A string is series of characters, where a character is the same as a byte. As in PHP it only supports a 256-character set, and hence does not offer native Unicode support.

When a variable is declared string it never changes its type:

string a;

let a = "";

string literals must be enclosed in double quotes¶

let  a = "hello";

converted to string "A"¶

let a = 'A';

automatically casted to ""¶

let a = null;

Types¶

Dynamic Types¶

Initialize variables¶

Change their values¶

Perform operations¶

Array¶

Square braces must be used to define arrays¶

Double colon must be used to define hashes' keys¶

Boolean¶

Float/Double¶

Integer¶

Integer overflow¶

Object¶

String¶

Static Types¶

Boolean¶

automatically casted to true¶

automatically casted to false¶

throws a compiler exception¶

Char/Unsigned Char¶

stores 't'¶

char literals must be enclosed in single quotes¶

Integer/Unsigned Integer¶

automatically casted to 100¶

automatically casted to 0¶

automatically casted to 0¶

throws a compiler exception¶

automatically casted to 70¶

automatically casted to 100¶

automatically casted to 0¶

automatically casted to 0¶

throws a compiler exception¶

potential loss of data for b¶

Long/Unsigned Long¶

automatically casted to 100¶

automatically casted to 0¶

automatically casted to 0¶

throws a compiler exception¶

automatically casted to 70¶

automatically casted to 100¶

automatically casted to 0¶

automatically casted to 0¶

throws a compiler exception¶

potential loss of data for b¶

String¶

string literals must be enclosed in double quotes¶

converted to string "A"¶

automatically casted to ""¶

automatically casted to `true`¶

automatically casted to `false`¶

`char` literals must be enclosed in single quotes¶

potential loss of data for `b`¶

potential loss of data for `b`¶