load help;

@[name]
dao.data
@[name]

@[title]
常量，变量和定变量
@[title]

@[text]

道支持显式地声明常量，局域变量，静态变量，全局变量和定变量(Invariable)。


@[table]
##关键词     ##在顶层作用域    ##在局部作用域    ##在类定义体里
##const      &&全局常量        &&局部常量        &&类常量
##var        &&全局变量        &&局部变量        &&类实例变量
##invar      &&全局定变量      &&局部定变量      &&类实例定变量
##static     &&静态变量        &&静态变量        &&类静态变量
@[table]
@[text]





@[name]
dao.data.const
@[name]

@[title]
常量
@[title]

@[text]
常量可由关键词const声明：
@[code]
const DEFAULT_INDEX = 123
const DEFAULT_NAME  = "abc"
@[code]
常量只能由常量表达式来初始化。


顶层作用域声明的常量将是全局常量。
其他的将是局部常量。
@[code]
const konst = "global constant"
for(var i = 1 : 5 ) {
	const konst = 123
	if( i > 3 ) {
		const konst = "local constant"
		io.writeln( konst )  # 输出: local constant
	}
	io.writeln( konst )  # 输出: 123
}
io.writeln( konst )  # 输出: global constant
@[code]

在类体里面，@[green]const@[green]可用来声明类常量。
类常量被储存在类对象里，可直接通过类对象访问。
@[code]
class Klass
{
	const name = "Klass"
}
io.writeln( Klass.name )
@[code]

@[text]





@[name]
dao.data.var
@[name]

@[title]
变量
@[title]

@[text]

关键词 var可用来声明局域或全局变量。
@[code]
var current_index = 456    # global variable;
var current_name  = "def"  # global variable;
@[code]
变量可通过任意表达式初始化。


同样顶层作用域声明的变量将是全局变量，其他的将是局域变量。
@[code]
var variable = "global variable"
for(var i = 1 : 5 ) {
	var variable = 123
	if( i > 3 ) {
		var variable = "local variable"
		io.writeln( variable )  # 输出: local variable
	}
	io.writeln( variable )  # 输出: 123
}
io.writeln( variable )  # 输出: global variable
@[code]

在类体里，@[green]var@[green]可用来声明类实例变量。
类实例变量由类实例储存，也只能通过类实例访问。
@[code]
class Klass
{
	const name = "Klass"
	var   value = 123
}
io.writeln( Klass.value )  # Error!

var klass = Klass()
io.writeln( klass.value )  # OK!
@[code]

@[text]





@[name]
dao.data.invar
@[name]

@[title]
定变量
@[title]

@[text]

在每个可以使用@[green]var@[green]的地方，@[green]invar@[green]也可被使用。
@[green]invar@[green]则声明的是局部，全局或成员定变量。
@[code]
invar invariable = "global invariable"
for(var i = 1 : 5 ) {
	invar invariable = 123
	if( i > 3 ) {
		invar invariable = "local invariable"
		io.writeln( invariable )  # 输出: local invariable
	}
	io.writeln( invariable )  # 输出: 123
}
io.writeln( invariable )  # 输出: global invariable
@[code]


定变量和常量很像，也是一旦被初始化了，就不能再被改变。
但不象常量那样一定要用常量表达式初始化，定变量可由普通变量或表达式初始化。
尽管定变量的值不能通过定变量本身去改变，它的值还是可通过其他变量改变。
@[code]
var   varlist = { 123 }
invar invlist = varlist

varlist.append( 456 )  # 可以! 现在, invlist = { 123, 456 }
invlist.append( 456 )  # 错!
@[code]


另外@[green]invar@[green]还可用在函数参数里，表示定变量参数。
@[code]
routine Rout( invar abc = 123 )
{
	abc += 1  # Error!
}
@[code]


尽管定变量的值在声明后不能在被修改，它的值却可以在声明处被替换。例如：
@[code]
for(var i = 1 : 3 ){
	invar index = i  # 好，可以替换!
	index += i       # 错，不可以修改!
}
@[code]


但是类实例的定变量可以在类构造函数里任意地方初始化。
@[code]
class Klass
{
	invar mapping = {=>}

	routine Klass( name: string, value: int ) {
		mapping = { name => value }  # OK!
	}
	routine Method() {
		mapping = { "abc" => 123 }  # Error!
		mapping[ "abc" ] = 123      # Error!
	}
}
@[code]

@[green]invar@[green]也可被用来定义类似于C++里的常方法，
即参数列表括号后面带@[green]invar@[green]的方法不可修改
其类实例的成员变量。
@[code]
class Klass
{
	var value = 123

	routine Modify() {
		value += 456
	}
	routine Method() invar {
		Modify()      # Error!
		value += 456  # Error!
		return value + 456
	}
}
@[code]

@[text]





@[name]
dao.data.static
@[name]

@[title]
静态变量
@[title]

@[text]

另一种变量类型是以@[green]static@[green]关键字声明的静态变量。
静态变量必须以常量表达式初始化。
@[code]
static stat = "static variable"
for(var i = 1 : 5 ) {
	static stat = 123
	if( i > 3 ) {
		static stat = "local static variable"
		static nested = [1,2,3]
		io.writeln( stat )  # 输出: local static variable
	}
	io.writeln( stat )    # 输出: 123
	io.writeln( nested )  # 错! "nested"这里不可见.
}
io.writeln( stat )  # 输出: static variable

static abc = rand(100)  # 错! 需要常量表达式.
@[code]


在类定义体外，静态变量将作仅局部可见的全局变量，也就是其储存方式跟全局变量
一样是存在命名空间对象里，但它们的可见性跟局部变量一样。
当一个含静态变量的函数被多次调用运行时，它访问的是同一静态变量。
@[code]
routine Test()
{
	static aux = 0
	aux += 1
	io.writeln( aux )
}
Test() # 输出: 1
Test() # 输出: 2
Test() # 输出: 3
@[code]


类定义体里的静态变量则是保存在类对象里，而不是类实例对象里。
因此它们可通过类对象直接访问。
@[code]
class Klass
{
	static state = [1,2,3]
}
io.writeln( Klass.state )
@[code]


@[text]