Zephir入门 —— 语法篇

Zephir里的变量名不需要像PHP那样带$符号，且有两种声明的方式：

// 可以使用var来定义变量，或者指定具体的变量类型
var a;
int b;
bool c = true;

// 可以在一行里声明多个变量
var a = "hello", b = 0, c;

要修改变量，属性或者数组的值，需要使用let关键字。

let name = "Tony";           // 变量
let this->name = "Tony";     // 对象属性
let data["name"] = "Tony";   // 数组
let self::_name = "Tony";    // 静态变量

Zephir不支持全局变量，也不允许访问用户域的全局变量，但是可以访问PHP的超级全局变量：

var price = _POST["price"];

var requestMethod = _SERVER["REQUEST_METHOD"];

Zehpir支持动态和静态类型。

动态类型变量跟PHP一样，可以在赋值后修改为不同类型的值。动态类型变量必须用var来声明。

var a, b, c;

// 初始化变量
let a = "hello", b = false;

// 改变它们的值
let a = 10, b = "140";

// 对它们进行操作
let c = a + b;

Zephir不会检查整型的溢出，如果要操作比较大的数字，可以使用浮点型或者静态型变量"unsigned long"：

unsigned long my_number = 2147483648;

Zephir不支持在字符串里使用变量的方式，你可以使用拼接方式：

var name = "peter";

echo "hello: " . name;

数组的定义要用中括号[]，且字符串型的键需要使用双引号：

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

静态变量一旦声明类型后就不能再改变。虽然失去了动态型变量的灵活性，但是在编译时静态变量能进行更多的优化。

Zephir支持以下的静态类型：

boolean： A boolean expresses a truth value. It can be either ‘true’ or ‘false’.

integer： Signed integers. At least 16 bits in size.

unsigned integer： Unsigned integers. At least 16 bits in size.

char： Smallest addressable unit of the machine that can contain basic character set.

unsigned char： Same size as char, but guaranteed to be unsigned.

long： Long signed integer type. At least 32 bits in size.

unsigned long： Same as long, but unsigned.

float/double： Double precision floating-point type. The size is platform-dependent.

string： A string is series of characters, where a character is the same as a byte.

unsigned long： Same as long, but unsigned.

array： An structure that can be used as hash, map, dictionary, collection, stack, etc.

布尔型，非布尔值会自动转化为true或者false：

boolean a;

let a = true,
    a = 100, // 自动转换为true
    a = null, // 自动转换为false
    a = "hello"; // 抛出编译器异常

整型：

int a;

let a = 50,
    a = -70,
    a = 100.25, // 自动转换为100
    a = null, // 自动转换为0
    a = false, // 自动转换为0
    a = "hello"; // 抛出编译器异常

无符号整型，带符号整型的值会自动转换为无符号。另外要注意的是，无符号整型的最大值要比普通整型大一倍，所以在把无符号整型的值赋予普通整型时要注意下：

uint a, int b;

let a = 50,
    a = -70, // 自动转换为70

let a = 2147483648,
    b = a; // 可能会丢失数据

长整型/无符号长整型变量的值范围是普通整型/无符号整型的两倍，除此以外跟普通整型/无符号整型一致。

ulong a, long b;

let a = 4294967296,
    b = a; // 可能会丢失数据

字符型：

har ch, string name = "peter";

let ch = name[2]; // 存储"t"
let ch = "Z"; // 需要用单引号

字符串：

string a;

let a = "",
    a = "hello", // 使用用双引号
    a = "A", // 自动转换为"A"
    a = null; // 自动转换为""

  
更详细的类型语法请看这里：http://zephir-lang.com/types.html

Zephir支持的运算符基本跟PHP一致：

// 算术运算符
// Zephir支持PHP中除了`$a ** $b`（PHP 5.6才开始支持）这种方式外的算术运算符。
let c = a + b;

// 比较运算符
// Zephir支持的比较运算符跟PHP一致（除了PHP 7增加支持的两个比较运算符外）。
if a == b {
    return 0;
} 

// 逻辑运算符
// Zephir支持`&&`、`||`和`!`这三个逻辑运算符，但不支持PHP里`And`、`Or`和`Xor`这三个逻辑运算符。
if a && b || !c {
    return -1;
}

// 位运算符
// 跟PHP一致
if a & SOME_FLAG {
    echo "has some flag";
}

// 三元运算符
// 跟PHP一致
let b = a == 1 ? "x" : "y"; 

然后，Zephir还支持empty、isset等特殊的运算符：

// empty
// 如果表达式的值为null、空字符串或者空数组，则为empty
let someVar = "";
if empty someVar {
    echo "is empty!";
}

// isset
// 用于检查数组的索引或者对象的属性是否已定义
// 功能更类似于PHP中的array_key_exists方法
let someArray = ["a": 1, "b": 2, "c": 3];
if isset someArray["b"] {
    echo "yes, it has an index "b"
";
}

// fetch
// 用于简化在PHP中以下的操作：
if (isset($myArray[$key])) {
    $value = $myArray[$key];
    echo $value;
}
// 使用fetch可以用以下代码实现，只有在key存在的情况下，fetch才返回true：
if fetch value, myArray[key] {
    echo value;
}

// typeof
// 用于检查变量的类型
if (typeof str == "string") {
    echo str;
}

  
更详细的操作符语法请看这里：http://zephir-lang.com/operators.html

数组可以使用关键字var和array进行声明：

var a = []; // 类型可以改变
array b = []; // 运行过程中，类型不可以改变

数组使用中括号进行创建，操作方式跟PHP一样：

let elements = [];

let elements = [1, 3, 4];

let elements = ["first", 2, true];

let elements[0] = "bar";

let elements = ["foo": "bar", "bar": "foo"];

let foo = elements["foo"];

  
更详细的数组操作语法请看这里：http://zephir-lang.com/arrays.html

前面说过，每个zephir文件都必须包含一个类，而且只能包含一个类。

Zehpir的类支持final和abstract两个修饰符，修饰符的作用跟PHP中的一致，例如：

namespace Test;

/**
 * 这个类不能被扩展
 */
final class MyClass
{

}

类的成员方法支持的可见性修饰符也跟PHP一致，支持public、protected和private，但Zephir强制方法必须显式的带上修饰符。

同时方法还支持final和deprecated两个修饰符：

// 这个方法不能被重写
public final function foo()
{   
}

// 调用此方法会抛出E_DEPRECATED 异常
public deprecated function foo()
{  
}

方法的参数也支持PHP中可选参数的方式，同时也支持静态类型：

public function doSum(a, b = 3)
{
    return a + b;
}

public function doSum2(int a = 4, int b = 2)
{
    return a + b;
}

使用静态类型参数时，如果传入的参数类型不一致，Zephir会试图对传入值进行类型的转换。如果基于某些考虑不想Zephir自动去做这个事情，我们可以通过添加一个!号禁止这个行为：

public function filterText(string! text, boolean escape=false)
{
    //...
}

另外我们还能通过const关键字设置参数为只读：

// a为只读
public function getSomeData(const string a)
{
    // 这里会抛出编译错误
    let a = "hello";
}

Zephir还提供了方法返回类型的提示功能，使得编译器可以知道方法返回的类型：

namespace App;

class MyClass
{
    public function getSomeData() -> string
    {
        // 这里会抛出编译异常。因为返回值是布尔型，跟期待的返回类型不一致
        return false;
    }

    public function getSomeOther() -> 
    {
        // 这里会抛出编译异常，如果返回的对象不是AppMyInterface接口的一个实现
        return new AppMyObject;
    }

    public function process()
    {
        var myObject;

        // 类型提示会告诉编译器myObject是AppMyInterface的一个实例
        let myObject = this->getSomeOther();

        // 编译器会检查AppMyInterface是否实现了一个叫someMethod的方法
        echo myObject->someMethod();
    }

    // 一个方法可以有多个的返回类型，使用|进行分隔
    public function getSomeData2(a) -> string | bool
    {
        if a == false {
            return false;
        }
        return "error";
    }

    // 如果返回类型为void，则表示此方法不允许返回任何数据
    public function setConnection(connection) -> void
    {
        let this->_connection = connection;
    }

}

类的属性同样支持public、protected和private三个修饰符，而且必须显式指定：

namespace Test;

class MyClass
{

    public myProperty1;
    protected myProperty2;
    private myProperty3;

    // 属性可以赋予默认值，但是这个值必须在编译的时候就能知道而不需要依赖于运行环境
    protected myProperty4 = 5;
    protected myProperty5 = "my value";

    public function setMyProperty1(var myProperty)
    {
        // 修改属性的值
        let this->myProperty1 = myProperty;
    }

    public function getMyProperty1()
    {
        // 读取属性的值
        return this->myProperty1;
    }

}

Zephir还提供了一个快捷的方式去实现Getter和Setter，例如下面的代码：

namespace App;

class MyClass
{
    protected myProperty {
        set, get, toString
    };

    protected someProperty = 10 {
        set, get
    };

}

相当于：

namespace Test;

class MyClass
{
    protected myProperty;

    protected someProperty = 10;

    public function setMyProperty(myProperty)
    {
        this->myProperty = myProperty;
    }

    public function getMyProperty()
    {
        return this->myProperty;
    }

    public function setSomeProperty(someProperty)
    {
        this->someProperty = someProperty;
    }

    public function getSomeProperty()
    {
        return this->someProperty;
    }

    public function __toString()
    {
        return this->myProperty;
    }

 }

另外常量的使用也是支持的：

namespace Test;

class MyClass
{

    const MYCONSTANT1 = false;
    const MYCONSTANT2 = 1.0;

    public function someMethod()
    {
        return MyClass::MYCONSTANT1;
    }
}

  
更详细的类和对象的使用方式请看这里：http://zephir-lang.com/oop.html

Zephir自身也内置了不少的方法，这些方法基本都是PHP中某些方法的OO实现。例如：

public function foo(string! s)
{
    return strlen(s);
}

// 使用内置方法
public function foo(string! s)
{
    return s->length();
}

  
更详细的内置方法使用方式请看这里：http://zephir-lang.com/builtin-methods.html

条件判断语句中，if和switch语句跟PHP类似，但需要注意的是，条件表达式的括号可以省略：

if a > 100 {
    echo "to big";
} elseif a < 0 {
    echo "to small";
} else {
    echo "ok";
}

switch count(items) {
}

循环语句中，用while、loop和for三种语句。

while语句跟PHP差不多，loop为Zephir增加的语句，用于创建一个无限的循环：

let n = 40;
loop {
    let n -= 2;
    if n % 5 == 0 { break; }
    echo x, "
";
}

for的用法跟PHP有很大不同，例如：

// 循环数组
for item in ["a", "b", "c", "d"] {
    echo item, "
";
}

let items = ["a": 1, "b": 2, "c": 3, "d": 4];

for key, value in items {
    echo key, " ", value, "
";
}

// 遍历字符串
string language = "zephir"; char ch;

for ch in language {
    echo "[", ch ,"]";
}

三种循环语句中均支持break语句和continue语句。

Zephir中也提供了类似PHP中require语句的语句：

if file_exists(path) {
    require path;
}

注意这个语句只能用于包含PHP文件，而不能包含zephir文件。

  
更详细的流程控制语法请看这里：http://zephir-lang.com/control.html

异常处理跟PHP也类似：

try {

    // 可以在这里抛出异常
    throw new Exception("This is an exception");

} catch Exception, e {

    // 异常处理
    echo e->getMessage();
}

如果不需要的话，保存异常信息的变量e可以省略：

try {

    throw new Exception("This is an exception");

} catch Exception {

    echo e->getMessage();
}

同时捕捉不同类型的异常：

try {

    throw new Exception("This is an exception");

} catch RuntimeException|Exception, e {

    echo e->getMessage();
}

  
更详细的异常处理的使用方式请看这里：http://zephir-lang.com/exceptions.html

可以直接调用PHP中内置的函数，例如调用base64_encode函数：

namespace MyLibrary;

class Encoder
{

    public function encode(var text)
    {
        if strlen(text) != 0 {
            return base64_encode(text);
        }
        return false;
    }
}

用户自己定义的函数也可以调用：

namespace MyLibrary;

class Encoder
{

    public function encode(var text)
    {
        if strlen(text) != 0 {
            if function_exists("my_custom_encoder") {
                return my_custom_encoder(text);
            } else {
                return base64_encode(text);
            }
        }
        return false;
    }
}

由于PHP的函数只接收和返回动态变量，所以如果你传入静态变量的话，Zephir会隐式的创建一个临时变量用于函数的调用。而返回的结果如果要赋值给静态变量的话，需要作适当的类型转换：

namespace MyLibrary;

class Encoder
{

    public function encode(string text)
    {
        string encoded = "";

        if strlen(text) != 0 {
            let encoded = (string) base64_encode(text);
            return "(" . encoded . ")";
        }
        return false;
    }
}

最后，如果我们需要动态的对函数进行调用，可以使用以下的方式：

namespace MyLibrary;

class Encoder
{

    public function encode(var callback, string text)
    {
        return {callback}(text);
    }
}

  
更详细的函数的调用方法请看这里：http://zephir-lang.com/functions.html

Zephir里也支持闭包和匿名函数，你可以把它返回给PHP：

namespace MyLibrary;

class Functional
{

    public function map(array! data)
    {
        return function(number) {
            return number * number;
        };
    }
}

也可以直接调用：

namespace MyLibrary;

class Functional
{

    public function map(array! data)
    {
        return data->map(function(number) {
            return number * number;
        });
    }
}

另外Zephir还提供了一个短语法用来定义闭包：

namespace MyLibrary;

class Functional
{

    public function map(array! data)
    {
        return number => number * number;
    }
}

http://zephir-lang.com/index.html