整体结构

注释

关键字

var  const  super  this
if  else
switch  case  default
for  do  while  break  continue 
function  return
import  include  echo
native  new  @import
throw  try  catch  finally

保留的关键字

static  instanceof  class  final

操作符

与Java 保持一致,顺序按优先级从高到低

[] . () .~
=> ->
!  ~  ++  --  – (取负)
*  /  %
+  -
<<  >>  >>>
<  <=  >  >=
^
|
&&
||
?:
..
=  +=  -=  *=  /=  %=  ^=  <<=  >>=  >>>=

语句

可设置 engine.looseSemicolon=false 强制不允许省略分号

作用域(代码段) { }

变量/常量

变量声明 var

var a;
var a, b, c=0, d="d";
var [e,f] = ["e","f"];
var [g1,g2,g3,g4] = 1..4;

常量声明 const

常量是不可变量,必须在声明的时候指明初始值,需要是直接量,或者直接量的简单运算

const c1 =1;
const c2 = "aaa";
const c3 = 'a';
const c4 = 2 *  1000;
const c5 = "a" + 1;

//native一个函数/构造方法也将得到一个直接量
const func = native java.util.List.add(Object);
// 如果 是一个public static final 的java字段 也可以作为直接量
const INT_MAX = native Integer.MAX_VALUE;

变量名规则

数据结构

类型

var x;                  //null
var x2 = 6;             //数字
var x3 = "Bill";        //字符串
var x4 = 'a';           //字符
var x5 = [1, "string"]; //数组
var x6 = {};            //Map

字符串

var string = "第一行  \
这还是在第一行
这是第二行\n第三行\n
这是第五行,第四行是空行";

数字

var x1=34;      //Integer
var x2=34L;     //Long
var x3=34.00;   //Double
var x4=34.00D;  //Double
var x5=34.00F;  //Float
var x6 = 0b10101;  //二进制
var x7 = 0123;  //八进制
var x8 = 0x1A;  //十六进制

布尔

var x = true;
var y = false;

数组

带初始值的数组

var array = [
    1,
    "a string",
    book,   // 支持最后一个元素冗余逗号
];
var item;
item = array[0];
item = array[1];
item = array[2];
array[0] = "a new value";

Native 方法声明定长数组,

// 引入生成数组的 native 方法
var new_int_array = native [] int;
var new_Object_array = native [] Object;
var new_DateTime_array = native [] java.util.DateTime;

// 或使用方法引用

var new_int_array2 = int[]::new;

//得到定长数组
var int_array = new_int_array(5); //长度为5 的int数组
var objects = new_Object_array(5);//长度为5 的Object数组
var int_array2 = new_int_array2(4); //长度为4 的int数组
var int_array3 = int[]::new(4); //长度为4 的int数组

var a;
a = objects[4];
objects[4]=4; // 自动 装箱为Integer 然后放入数组
var len = objects.length; //数组长度
len = objects.size; //数组长度

//不定长数组 可使用Java提供的List实现
var new_list = native new java.util.ArrayList();
var list_add = native java.util.List.add(Object);

var list = new_list();
list_add(list,0); 
list_add(list,1);

var a = list[0];
list[0] = "zero";
list[1] = "a string";

Map

var map = {};
var map2 = {1:1,"2","2"};
map["key"] = "a string value";

var value = map[1];
value = map["2"];
value = map["key"];

var id = "9527"
var name = "Mr. T"
var map = {
    id,    // 只提供现有的变量名, 取名作为key, 取值作为值, 等同于 map["id"] = id
    name,  // 同上, 等同于 等同于 map["name"] = name
    nickname: "wit",  // 标识符作为 key, 提供的值作为值
    1 : "a",   // 直接量作为 key
    "1": "b",  // 同上
    '1': "c",  // 同上
    -1 : "d",  // 同上
    [ -1-1 ] : "e",   // 表达式作为 key, 使用 [] 内的表达式的结果作为key, 等同于 map[-1-1] = "e"
    "x-y-z" : "XYZ",  // 支持最后一个元素冗余逗号
};

Java对象

声明

var new_list = native new java.util.ArrayList();
var list = new_list();
var list2 = new_list();

访问属性

var book;
var name = book.name; // book.getName();
book.name = "new name"; //book.setName("new name"); 

访问方法

访问方法必须事先native导入成本地函数

var list_add = native java.util.List.add(Object);
list_add(list, 0);
list_add(list, 1);

动态调用成员方法

list.~add(item);
list.~add(0, item2);
list.~clear();
list.~addAdd(list2);

访问公共静态方法

var now = native java.lang.System.currentTimeMillis();
echo now();
echo "\n";
// 或者使用方法引用
echo java.lang.System::currentTimeMillis();

访问公共静态字段

//对于final的字段,直接得到其值
const INT_MAX = native Integer.MAX_VALUE;

//对于非final的字段,得到其引用,可以即时使用和赋值
var f2 = native StaticFields.field2;
(native StaticFields.field2) = new_value;

函数

声明

var outSideVar;
var a;
var myFunc = function(arg1, arg2){
    var arg3 = arguments[3]; // 如果没有将抛出异常,最好通过 arguments.size确认
    outSideVar = "a new "; //可访问
    var a = 0; //内部变量
    super.a ++ ; //访问上层变量
    var func = function(){ ... }; //内部嵌套函数
}; //不要忘了分号!!!

导入 Java 内的 方法

@import java.lang.System; //实际上默认已经导入  java.lang.* 只是演示使用方法
@import java.util.List;
@import java.util.ArrayList;
var now = native java.lang.System.currentTimeMillis();
var list_add = native List.add(Object);
var new_list = native new ArrayList(); // 导入 构造函数
var new_list2 = native new ArrayList(int); // 导入 构造函数

调用

func(arg1, arg2);
list_add(list, item);

重定向输出符 =>

var out;
var book;
//代码段 输出重定向
{
echo "a String";
>${book.name} <
} => out;
// "a String" 以及 book.name 都将输出到 out

var out;
// 函数 输出重定向
func() => out;
//由于 `=>` 具有较高的优先级,也可以这么些
var a = func(arg1) => out +1; 
//此时 a为 func()+1 , func() 本次执行的输出内容赋值给out

import & include

//相对路径
include "./book-head.wit";
//等同于 
include "book-head.wit";
//绝对路径
include "/copyright.wit";
//动态模板名
var style = "";
import "book-list-"+ style  +".wit";
//可传入参数 函数同样也可以作为变量传输
var func = function(){}; 
var book;
import "book-head.wit"  {"book": book, "func":func};
//导出指定变量
var a;
var b;
//导出 : a 到a ,c 到 b
import "book-head.wit"  {"param1":1}  a,b=c;

关于条件判断的三种情况

三元条件运算符 & 其简写

var a1 = isTrue ? "Yes" : "No";

//自右向左 结合
var x =  expr1 ?  expr3 :  expr2 ? expr4 : expr5;
//这个等同于
var x =  expr1 ?  expr3 :  (expr2 ? expr4 : expr5);
// 如果 是 自左向右 就会变成这样
var x =  (expr1 ?  expr3 :  expr2) ? expr4 : expr5;

判断语句

判断控制语句 if - else if - else

if( ... ){
    ...;
}else if(...){
    ...;
}else{
    ...;
}

循环控制语句

for-in

//集合 数组 等
for(item : list){
    echo item;
    //echo for.iter.index; // .isFirst .hasNext .isOdd .isEven
} else{
    echo "list is empty";
}
//递增 
for(i: 3..6){
    echo i;
}
//递减
for(i: 6..3){
    echo i;
    //支持 for.iter.*
}

遍历Map

for(key, value : map){
    echo key + " = " value;
    echo "\n";
    //同样支持 for.iter.*
}

while do-while

//
var iter;
... ;
while(iter.hasNext){
    var item = iter.next;
    ....;
}
//
do{
    ....;
}while( ... );

Switch

switch(a){
    case 1:
        ....;
        break;
    case "c": //String
        ....;
        break;
    case 'c': //Char
        ....;
        break;
    default:
        ....;
}

break & continue

支持 label

//break continue
outter: for(i: 6..3){
    echo i;
    //支持 for.iter.*
    inner: for(item : list){
        if( ..... ){
           break outter;
        }
        .....;
        break; // break inner;
    }
    //
    switch(a){
        ...;
        case 'x':
           break outter;
        ...;
    }
}

Lambda 表达式

可以认为是 function(..){..} 的简写

()->0;
//等同与
()->{ return 0; };

// 下面几组也分别是等同的
x -> x > 2 || x < 8;
x -> (x > 2 || x < 8);
x -> {return x > 2 || x < 8;};
(x) -> x > 2 || x < 8;

(x, y, z) -> x > y || x < z;
(x, y, z) -> {return x > y || x < z;});

//注意: 你可能会发现,这里会有一个歧义,实际上是个返回一个空map的函数, 而不是一个空函数
()->{};

模板字符串

var id=9527, name="Mr Tang";
var jobs = {
  9527: "Master"
};

var str = `awesome\t\n template
${1+2}, ${id}, ${name}, ${jobs[id]}${(()->",")()}
${((name)->{ var map={func:"bala..bala..bala"}; return "nested function: " + name + " - " + map[name]})("func")}
.`

正在完善。。。