/*
这是你的第一个Braise程序。
*/
str = "hello, world";
str.println();
//这是一行注释
/*
多行注释，
可以这样写
*/
/*
这里说明操作符和表达式
Braise支持的操作符和C++一致：
操作符 说明 优先级（数值越低就越先执行） 例句
-
两个值相加 4 J = k + 100;
-
两个值相减 4 J = k - 100;
-
两个值相乘 3 J = k * 100;
/ 两个值相除 3 J = k * 100;
&& 两个布尔值求并 11 C = a && b;
|| 两个布尔值求或 12 C = a || b;
= 赋值 14 A = 100;
== 判断是否相等 7 if(a == 100)
!= 判断是否不等于 7 if(a != b)
判断是否大于 6 if(a>b)= 判断是否大于等于 6 if(a>=b)
< 判断是否小于 6 if(a<b)
<= 判断是否小于等于 6 if(a<=b)
注意：如果有括号，先计算括号里面的。如果有多个括号，从左到右执行。
特别说明：
Braise支持“++”和“--”操作符，但使用有限制，仅支持有限的场景，如作为独立语句：
var_name++; //等价于： var_name = var_name + 1;
var_name--; //等价于： var_name = var_name - 1;
或者在循环语句中：
for(i = 0; i < 10; i++)
{
i.println();
}
表达式是操作符和变量的组合。
Braise 的表达式语法和C++/Java等几乎一致，支持任意复杂度的表达式：
x = a * b + c / d - 100;
y = a && b || c ;
assert 断言，就是可以进行结果预期判断，如果结果和我们预期的一致，会打印ok，不一致就失败，然后结束程序执行。
*/
i = 10 + 30 - 20 * (100/20);
assert("a", i == -60);
assert("b", (2 * 3 == 6) && (3 * 3 == 9));
assert("c", (2 * 3 == 6) || (3 * 3 == 8));
assert("d", 3 != 5);
assert("e", 3 < 5);
assert("f", 3 <= 5);
assert("g", 30 >= 5);
assert("h", 30 > 5);
//表达式里面可以有函数调用：
i = rand.get_int() * 2+ 100;
i.println();
/*
这里演示了逻辑判断
Braise 的 if /if else 语法和C++/Java等完全一致
*/
i = 100;
/*
() 里面是表达式，可以无限复杂，见 express.bs
如果表达式的结果是true，那么执行{}里面的内容。
*/
if(i > 10)
{
io.println("true");
}
/*
() 里面同上
如果表达式的结果是true，那么执行if后面{}里面的内容，否则执行else后面{}里面的内容
*/
if(i > 10)
{
io.println("true");
}
else
{
io.println("false");
}
/*
可以有多个else
*/
if(i > 100)
{
io.println("i > 100");
}
else if(i > 50)
{
io.println("i > 50");
}
else if(i > 10)
{
io.println("i > 10");
}
else
{
io.println("i <= 10");
}
/*
这里演示了如何使用for关键字来实现循环
Braise 的 for 语法和C++/Java等完全一致
常规的for语法如下：
for(CODE1; EXP; CODE2)
{
CODE3
}
首先执行且仅执行一次CODE1，
再循环计算条件表达式EXP，如果满足，就执行{}里面的代码CODE3，否则结束循环。
CODE3里面可以包含break关键字，表示跳出当前循环。
也可以包含continue关键字，表示跳到计算表达式EXP。
在第二次及以后计算EXP之前，都会先执行一次CODE2
另外，为了和较新版的C++、Java规范保持一致，Braise还支持以下格式的for：
for(ITEM : LIST)
{
CODE
}
//多个&表示ITEM是引用方式，这样对ITEM的赋值，会导致会LIST[x]的赋值。如果不加&，对ITEM的赋值，不影响LIST[x]
for(ITEM& : LIST)
{
CODE
}
上述for的意思是：从头到尾遍历列表LIST，逐一把LIST中的元素赋值给变量ITEM，然后执行CODE。
CODE里面可以包含break关键字，表示跳出当前循环。
也可以包含continue关键字，表示跳开CODE，继续遍历下一个元素。
上述for的一个增强版是：
for(INDEX, ITEM : LIST)
{
CODE
}
for(INDEX, ITEM& : LIST)
{
CODE
}
其中的INDEX是一个整数，从0开始自增。
特别注意：
for里面的ITEM，INDEX等都是for里面的临时变量，出了for就会自动删除。
*/
/*
以下代码的效果是，连续执行3次i.println();，每次的i的值都不同，依次是0,1,2
*/
for(i = 0; i < 3; i++)
{
i.println();
}
/*
以下代码的效果是，试图连续执行30次 i.println(); 执行过程中，i不断加1，如果 i == 3，那么立即跳出for循环。
*/
for(i = 0; i < 30; i++)
{
if(i == 3)
{
break;
}
i.println();
}
/*
以下代码的效果是，连续执行5次，当 i == 3 时，不打印i的值，其他情况，打印i的值。
*/
for(i = 0; i < 5; i++)
{
if(i == 3)
{
continue;
}
i.println();
}
/*
以下代码的效果是，遍历列表 l_s，对列表中的每一个字符串，先打印内容，再更新其值。
*/
l_s_org = {"abc", "xyz", "123"};
l_s = l_s_org;
for(s : l_s)
{
s.println();
//可以对s执行赋值，但是不会影响到 l_s
s = "update " + s;
}
for(i, s : l_s)
{
io.println("i:" + i + ", s " + s);
}
assert("s", l_s_org == l_s);
for(s& : l_s)
{
s.println();
//可以对s执行赋值，并且会影响到 l_s对应的元素：
s = "update " + s;
}
assert("s2", l_s_org != l_s);
str = "abcde";
for(c : str)
{
c.println();
//可以对c执行赋值，但是不会影响到 str
c = c - 32;
}
assert("c", str == "abcde");
/*
以下代码的效果是，遍历字符串str的每一个字符，先打印字符，再转化为大写。
*/
for(c& : str)
{
c.println();
c = c - 32;
}
assert("c2", str == "ABCDE");
/*
以下代码的效果是，遍历列表l_m，对列表中的每一个结构体，先打印内容，再更新其值。
*/
m.x = 100;
m.y = 200;
l_m = {};
l_m.push(m);
m.x = 300;
m.y = 400;
l_m.push(m);
for(m_item& : l_m)
{
m_item.println();
m_item.x = m_item.x + 1;
m_item.y = m_item.y + 1;
}
l_m.println();
buf = buffer();
buf.alloc(10);
for(by : buf)
{
by.println();
by = 10;
}
buf.println();
for(by& : buf)
{
by.println();
by = 10;
}
buf.println();
return;
/*
以下代码示范了一个错误的写法，i是整数，不是列表，因此程序运行后会抛出异常。
*/
i = 100;
for(x : i)
{
x.println();
}
好了，今天就先分享到这里，剩下的下次再继续，braise最多只有14个关键字，语法像极了c，tcl，很适合做小工具快速开发，做大型工具也可以哦。