变量下面,属性是第二个选项来处理类中的数据。然而不像变量,它们提供更多的控制哪种类型的字段访问被允许,和它如何被生成。通常用处包括:
> Next to variables (4.1), properties are the second option for dealing with data on a class. Unlike variables however, they offer more control of which kind of field access should be allowed and how it should be generated. Common use cases include:
* 有一个可以被从任何地方读取,但是只能被从定义类写入的字段
* 有一个调用一个getter方法获得读权限的字段
* 有一个调用一个setter方法获得写入权限的字段
> * Have a field which can be read from anywhere,but only be written from within the defining class.
> * Have a field which invokes a getter-method upon read-access.
> * Have a field which invokes a setter-method upon write-access.
当处理属性时,重要的是理解两种类型的访问:
> When dealing with properties, it is important to understand the two kinds of access:
>[warning] 定义:读取访问
> 一个字段的读取访问发生在右手字段访问表达式(第5.7节)使用时。包括通过 obj.field() 形式调用来访问授权读取的字段。
> 定义:写入访问
> 一个字段的写入访问发生在一个字段访问表达式被以obj.field=value格式赋一个值的时候。也可能和读取访问联合出现,对于特别的赋值操作符如 += ,表达式形如 obj.field += value 。
>[warning] Definition: Read Access
A read access to a field occurs when a right-hand side field access expression (5.7) is used. This includes calls in the form of obj.field(), where field is accessed to be read.
>[warning] Definition: Write Access
A write access to a field occurs when a field access expression (5.7) is assigned a value in the form of obj.field = value. It may also occur in combination with read access (4.2) for special assignment operators such as += in expressions like obj.field += value.
读取访问和写入访问直接反映在语法形式,如下面的例子:
> Read access and write access are directly reflected in the syntax, as the following example shows:
~~~
class Main {
public var x(default, null):Int;
static public function main() { }
}
~~~
多数情况,和变量的语法类似,实际上适用同样的规则。属性被识别,通过
> For the most part, the syntax is similar to variable syntax, and the same rules indeed apply. Properties are identified by
* 字段名后开口的括号 ( ,
* 后面跟一个特定的访问标识符(这里是 default),
* 逗号,隔开
* 另一个特殊的访问标识符(这里是null),
* 和一个闭口的括号 )
> * the opening parenthesis ( after the field name,
> * followed by a special access identifier (here: default),
> * with a comma , separating
> * another special access identifier (here: null)
> * before a closing parenthesis ).
访问标识符定义当字段被读取(第一个标识符)的行为,和写入的行为(第二个标识符)。接受的值为:
> The access identifiers define the behavior when the field is read (first identifier) and written (second identifier). The accepted values are:
**default**:如果字段有公开的可见性,则允许普通的字段访问,否则等于 null 访问。
**null**:只允许从定义的类中访问。
**get/set**:访问被生成为一个存取器方法。编译器确保存取器可用。
**dynamic**:类似get/set访问,但是不验证存取器字段的存在。
**never**:不允许访问
> **default**: Allows normal field access if the field has public visibility, otherwise equal to null access.
> **null**: Allows access only from within the defining class.
> **get/set**: Access is generated as a call to an accessor method. The compiler ensures that the accessor is available.
> **dynamic**: Like get/set access, but does not verify the existence of the accessor field.
> **never**: Allows no access at all.
**存取器方法**
>[warning] 定义:存取器方法
一个T类型名为 filed 的字段的一个存取器方法(或者简称为存取器)是一个Void->T类型名为 get_field 的 getter,或者T->T类型名为 set_field的setter。
>[warning] Definition: Accessor method
An accessor method (or short accessor) for a field named field of type T is a getter named get_field of type Void->T or a setter named set_field of type T->T.
**存取器名称**
>[warning] 花絮:存取器名称
在Haxe 2中,任意的标识符允许作为访问标识符,可以使定制的存取器方法名是被认可的。这使得部分实现非常难以处理。特别是,Reflect.getProperty() 和 Reflect.setProterty() 必须假定任何名称可能被使用,需要目标生成器生成元信息和执行查找。我们不允许这些标识符,而使用 get_ 和 set_ 命名约定,大大简化了实现。这是Haxe2 和Haxe 3之间一个阻断式的变更。
>[warning] Trivia: Accessor names
In Haxe 2, arbitrary identifiers were allowed as access identifiers and would lead to custom accessor method names to be admitted. This made parts of the implementation quite tricky todealwith. In particular,Reflect.getProperty() and Reflect.setProperty() had to assume that any name could have been used, requiring the target generators to generate meta-information and perform lookups. We disallowed these identifiers and went for the get_ and set_ naming convention which greatly simplified implementation. This was one of the breaking changes between Haxe 2 and 3.
- 空白目录
- 1.Haxe介绍
- 1.1.Haxe是什么
- 1.2.关于本文档
- 1.2.1.作者及贡献者
- 1.2.2.License
- 1.3Hello World
- 1.4.Haxe的历史
- 2.类型
- 2.1.基本类型
- 2.1.1.数值类型
- 2.1.2.溢出
- 2.1.3.数值运算符
- 2.1.4.Bool类型
- 2.1.5.Void类型
- 2.2.为空性
- 2.2.1.可选参数和为空性
- 2.3.类实例
- 2.3.1.类的构造函数
- 2.3.2.继承
- 2.3.3.接口
- 2.4.枚举实例
- 2.4.1.Enum构造函数
- 2.4.2.使用枚举
- 2.5.匿名结构
- 2.5.1.结构值的JSON形式
- 2.5.2. 结构类型的类记法
- 2.5.3.可选字段
- 2.5.4.性能影响
- 2.6.函数类型
- 2.6.1.可选参数
- 2.6.2.默认值
- 2.7.动态类型
- 2.7.1.Dynamic使用类型参数
- 2.7.2.实现Dynamic
- 2.8.抽象类型
- 2.8.1.隐式类型转换
- 2.8.2.运算符重载
- 2.8.3.数组访问
- 2.8.4.选择函数
- 2.8.5.枚举抽象类型
- 2.8.6.转发抽象类型字段
- 2.8.7.核心类型抽象
- 2.9.单形
- 3.类型系统
- 3.1.Typedef
- 3.1.1.扩展
- 3.2.类型参数
- 3.2.1.约束
- 3.3.泛型
- 3.3.1.泛型类型参数解释
- 3.4.变异
- 3.5.统一
- 3.5.1.类/接口 之间
- 3.5.2.结构子类型化
- 3.5.3.单形
- 3.5.4.函数返回
- 3.5.5.通用基本类型
- 3.6.类型推断
- 3.6.1.由上而下推断
- 3.6.2.局限
- 3.7.模块和路径
- 3.7.1.模块子类型
- 3.7.2.Import
- 3.7.3.解析顺序
- 4.类字段
- 4.1.变量
- 4.2.属性
- 4.2.1.常见访问标识符组合
- 4.2.2.对类型系统的影响
- 4.2.3.getter和setter的规则
- 4.3.方法
- 4.3.1.重写方法
- 4.3.2.变异和访问修饰符的影响
- 4.4.访问修饰符
- 4.4.1.可见性
- 4.4.2.Inline
- 4.4.3.Dynamic
- 4.4.4.Override
- 4.4.5.Static
- 5.表达式
- 5.1.块
- 5.2.常量
- 5.3.二元操作符
- 5.4.一元操作符
- 5.5.数组声明
- 5.6.对象声明
- 5.7.字段访问
- 5.8.数组访问
- 5.9.函数调用
- 5.10.var
- 5.11.局部函数
- 5.12.new
- 5.13.for
- 5.14.while
- 5.15.do-while
- 5.16.if
- 5.17.switch
- 5.18.try/catch
- 5.19.return
- 5.20.break
- 5.21.continue
- 5.22.throw
- 5.23.类型转换
- 5.23.1.不安全转换
- 5.23.2.安全转换
- 5.24.类型检查
- 6.语言特性
- 6.1.条件编译
- 6.2.Externs
- 6.3.静态扩展
- 6.3.1.标准库中的静态扩展
- 6.4.模式匹配
- 6.4.1.介绍
- 6.4.2.枚举匹配
- 6.4.3.变量捕获
- 6.4.4.结构匹配
- 6.4.5.数组匹配
- 6.4.6.Or 模式
- 6.4.7.守护
- 6.4.8.多个值的匹配
- 6.4.9.提取器
- 6.4.10.穷尽性检查
- 6.4.11.无效的模式检查
- 6.5.字符串插值
- 6.6.数组推导
- 6.7.迭代器
- 6.8.函数绑定
- 6.9.元数据
- 6.10.访问控制
- 6.11.内联构造函数
- 7.编译器用法
- 7.1.编译器标记
- 8.编译器功能
- 8.1.内建编译器元数据
- 8.2.无用代码消除
- 8.3.编译器服务
- 8.3.1.概述
- 8.3.2.字段访问完成
- 8.3.3.调用参数完成
- 8.3.4.类型路径完成
- 8.3.5.使用完成
- 8.3.6.位置完成
- 8.3.7.顶级完成
- 8.3.8.完成服务
- 8.4.资源
- 8.4.1.嵌入资源
- 8.4.2.检索文本资源
- 8.4.3.检索二进制资源
- 8.4.4.实现细节
- 8.5.运行时类型信息
- 8.5.1.RTTI 结构
- 8.6.静态分析仪
- 9.宏
- 9.1.宏上下文
- 9.2.参数
- 9.2.1.ExprOf
- 9.2.2.常数表达式
- 9.2.3.其它的参数
- 9.3.具体化
- 9.3.1.表达式具体化
- 9.3.2.类型具体化
- 9.3.3.类具体化
- 9.4.工具
- 9.5.类型构建
- 9.5.1.枚举构建
- 9.5.2.@:autoBuild
- 9.5.3.@:genericBuild
- 9.6.限制
- 9.6.1.Macro-in-Macro
- 9.6.2.静态扩展
- 9.6.3.构建顺序
- 9.6.4.类型参数
- 9.7.初始化宏
- 10.标准库
- 10.1.字符串
- 10.2.数据结构
- 10.2.1.数组
- 10.2.2.向量
- 10.2.3.列表
- 10.2.4.GenericStack
- 10.2.5.Map
- 10.2.6.Option
- 10.3.正则表达式
- 10.3.1.匹配
- 10.3.2.分组
- 10.3.3.替换
- 10.3.4.分割
- 10.3.5.Map
- 10.3.6.实现细节
- 10.4.Math
- 10.4.1.特殊数值
- 10.4.2.数学错误
- 10.4.3.整数数学
- 10.4.4.扩展
- 10.5.Lambda
- 10.6.模板
- 10.7.反射
- 10.8.序列化
- 10.8.1.格式化序列化
- 10.9.Xml
- 10.9.1.开始使用Xml
- 10.9.2.解析Xml
- 10.9.3.编码Xml
- 10.10.Json
- 10.10.1.解析JSON
- 10.10.2.编码JSON
- 10.10.3.实现细节
- 10.11.Input/Output
- 10.12.Sys/sys
- 10.13.远程处理
- 10.13.1.远程连接
- 10.13.2.实现细节
- 10.14.单元测试
- 11.Haxelib
- 11.1.Haxe编译器使用库
- 11.2.haxelib.json
- 11.2.1.版本控制
- 11.2.2.依赖关系
- 11.3.extraParams.hxml
- 11.4.使用Haxelib
- 12.目标平台细节
- 12.1.JavaScript
- 12.1.1.开始使用Haxe/JavaScript
- 12.1.2.使用外部JavaScript库
- 12.1.3.注入原生JavaScript
- 12.1.4.JavaScript untyped函数
- 12.1.5.调试JavaScript
- 12.1.6.JavaScript目标元数据
- 12.1.7.为JavaScript暴露Haxe类
- 12.1.8.使用 require函数加载外部类
- 12.2.Flash
- 12.2.1.开始使用Haxe/Flash
- 12.2.2.嵌入资源
- 12.2.3.使用外部Flash库
- 12.2.4.Flash目标元数据
- 12.3.Neko
- 12.4.PHP
- 12.4.1.开始使用Haxe/PHP
- 12.4.2.PHP untyped函数
- 12.5.C++
- 12.5.1.Using C++定义
- 12.5.2.Using C++ 指针
- 12.6.Java
- 12.7.C#
- 12.8.Python