仓颉关键字、操作符

Posted on | In |

仓颉关键字

关键字 关键字 关键字
as abstract break
Bool case catch
class const continue
Rune do else
enum extend for
func false finally
foreign Float16 Float32
Float64 if in
is init import
interface Int8 Int16
Int32 Int64 IntNative
let mut main
macro match Nothing
open operator override
prop public package
private protected quote
redef return spawn
super static struct
synchronized try this
true type throw
This unsafe Unit
UInt8 UInt16 UInt32
UInt64 UIntNative var
VArray where while

仓颉操作符

下表列出了仓颉支持的所有操作符的优先级及结合性，其中优先级一栏数值越小，对应操作符的优先级越高。

操作符 优先级 含义 示例 结合方向
@ 0 宏调用 @id 右结合
. 1 成员访问 expr.id 左结合
[] 1 索引 expr[expr] 左结合
() 1 函数调用 expr(expr) 左结合
++ 2 自增 var++ 无
– 2 自减 var– 无
? 2 问号 expr?.id, expr?[expr], expr?(expr), expr?{expr} 无
! 3 按位求反、逻辑非 !expr 右结合
- 3 一元负号 -expr 右结合
** 4 幂运算 expr ** expr 右结合
*, / 5 乘法，除法 expr * expr, expr / expr 左结合
% 5 取模 expr % expr 左结合
+, - 6 加法，减法 expr + expr, expr - expr 左结合
<< 7 按位左移 expr << expr 左结合
>> 7 按位右移 expr >> expr 左结合
.. 8 区间操作符 expr..expr 无
..= 8 含步长的区间操作符 expr..=expr 无
< 9 小于 expr < expr 无
<= 9 小于等于 expr <= expr 无
> 9 大于 expr > expr 无
>= 9 大于等于 expr >= expr 无
is 9 类型检查 expr is Type 无
as 9 类型转换 expr as Type 无
== 10 判等 expr == expr 无
!= 10 判不等 expr != expr 无
& 11 按位与 expr & expr 左结合
^ 12 按位异或 expr ^ expr 左结合
| 13 按位或 expr | expr 左结合
&& 14 逻辑与 expr && expr 左结合
| 15 逻辑或 expr | expr 左结合
?? 16 coalescing 操作符 expr ?? expr 右结合
|> 17 pipeline 操作符 id |> expr 左结合
~> 17 composition 操作符 expr ~> expr 左结合
= 18 赋值 id = expr 无
**= 18 复合运算符 id **= expr 无
*= 18 复合运算符 id *= expr 无
/= 18 复合运算符 id /= expr 无
%= 18 复合运算符 id %= expr 无
+= 18 复合运算符 id += expr 无
-= 18 复合运算符 id -= expr 无
<<= 18 复合运算符 id <<= expr 无
>>= 18 复合运算符 id >>= expr 无
&= 18 复合运算符 id &= expr 无
^= 18 复合运算符 id ^= expr 无
|= 18 复合运算符 id |= expr 无
&&= 18 复合运算符 id &&= expr 无
|= 18 复合运算符 id |= expr 无

仓颉操作符函数

下表列出了仓颉支持的所有操作符函数。

操作符函数 函数签名 示例
[] （索引取值） operator func [](index1: T1, index2: T2, …): R this[index1, index2, …]
[] （索引赋值） operator func [](index1: T1, index2: T2, …, value!: TN): R this[index1, index2, …] = value
() operator func ()(param1: T1, param2: T2, …): R this(param1, param2, …)
! operator func !(): R !this
** operator func **(other: T): R this ** other
* operator func *(other: T): R this * other
/ operator func /(other: T): R this / other
% operator func %(other: T): R this % other
+ operator func +(other: T): R this + other
- operator func -(other: T): R this - other
<< operator func <<(other: T): R this << other
>> operator func >>(other: T): R this >> other
< operator func <(other: T): R this < other
<= operator func <=(other: T): R this <= other
> operator func >(other: T): R this > other
>= operator func >=(other: T): R this >= other
== operator func ==(other: T): R this == other
!= operator func !=(other: T): R this != other
& operator func &(other: T): R this & other
^ operator func ^(other: T): R this ^ other
| operator func |(other: T): R this | other

仓颉TokenKind 类型

fold title:TokenKind类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
public enum TokenKind <: ToString {
    DOT|                      /*  "."           */
    COMMA|                    /*  ","           */
    LPAREN|                   /*  "("           */
    RPAREN|                   /*  ")"           */
    LSQUARE|                  /*  "["           */
    RSQUARE|                  /*  "]"           */
    LCURL|                    /*  "{"           */
    RCURL|                    /*  "}"           */
    EXP|                      /*  "**"          */
    MUL|                      /*  "*"           */
    MOD|                      /*  "%"           */
    DIV|                      /*  "/"           */
    ADD|                      /*  "+"           */
    SUB|                      /*  "-"           */
    INCR|                     /*  "++"          */
    DECR|                     /*  "--"          */
    AND|                      /*  "&&"          */
    OR|                       /*  "||"          */
    COALESCING|               /*  "??"          */
    PIPELINE|                 /*  "|>"          */
    COMPOSITION|              /*  "~>"          */
    NOT|                      /*  "!"           */
    BITAND|                   /*  "&"           */
    BITOR|                    /*  "|"           */
    BITXOR|                   /*  "^"           */
    BITNOT|                   /*  "~"           */
    LSHIFT|                   /*  "<<"          */
    RSHIFT|                   /*  ">>"          */
    COLON|                    /*  ":"           */
    SEMI|                     /*  ";"           */
    ASSIGN|                   /*  "="           */
    ADD_ASSIGN|               /*  "+="          */
    SUB_ASSIGN|               /*  "-="          */
    MUL_ASSIGN|               /*  "*="          */
    EXP_ASSIGN|               /*  "**="         */
    DIV_ASSIGN|               /*  "/="          */
    MOD_ASSIGN|               /*  "%="          */
    AND_ASSIGN|               /*  "&&="         */
    OR_ASSIGN|                /*  "||="         */
    BITAND_ASSIGN|            /*  "&="          */
    BITOR_ASSIGN|             /*  "|="          */
    BITXOR_ASSIGN|            /*  "^="          */
    LSHIFT_ASSIGN|            /*  "<<="         */
    RSHIFT_ASSIGN|            /*  ">>="         */
    ARROW|                    /*  "->"          */
    BACKARROW|                /*  "<-"          */
    DOUBLE_ARROW|             /*  "=>"          */
    RANGEOP|                  /*  ".."          */
    CLOSEDRANGEOP|            /*  "..="         */
    ELLIPSIS|                 /*  "..."         */
    HASH|                     /*  "#"           */
    AT|                       /*  "@"           */
    QUEST|                    /*  "?"           */
    LT|                       /*  "<"           */
    GT|                       /*  ">"           */
    LE|                       /*  "<="          */
    GE|                       /*  ">="          */
    IS|                       /*  "is"          */
    AS|                       /*  "as"          */
    NOTEQ|                    /*  "!="          */
    EQUAL|                    /*  "=="          */
    WILDCARD|                 /*  "_"           */
    INT8|                     /*  "Int8"        */
    INT16|                    /*  "Int16"       */
    INT32|                    /*  "Int32"       */
    INT64|                    /*  "Int64"       */
    INTNATIVE|                /*  "IntNative"   */
    UINT8|                    /*  "UInt8"       */
    UINT16|                   /*  "UInt16"      */
    UINT32|                   /*  "UInt32"      */
    UINT64|                   /*  "UInt64"      */
    UINTNATIVE|               /*  "UIntNative"  */
    FLOAT16|                  /*  "Float16"     */
    FLOAT32|                  /*  "Float32"     */
    FLOAT64|                  /*  "Float64"     */
    RUNE|                     /*  "Rune"        */
    BOOLEAN|                  /*  "Bool"        */
    NOTHING|                  /*  "Nothing"     */
    UNIT|                     /*  "Unit"        */
    STRUCT|                   /*  "struct"      */
    ENUM|                     /*  "enum"        */
    CFUNC|                    /*  "CFunc"       */
    VARRAY|                   /*  "VArray"      */
    THISTYPE|                 /*  "This"        */
    PACKAGE|                  /*  "package"     */
    IMPORT|                   /*  "import"      */
    CLASS|                    /*  "class"       */
    INTERFACE|                /*  "interface"   */
    FUNC|                     /*  "func"        */
    MACRO|                    /*  "macro"       */
    QUOTE|                    /*  "quote"       */
    DOLLAR|                   /*  "$"           */
    LET|                      /*  "let"         */
    VAR|                      /*  "var"         */
    CONST|                    /*  "const"       */
    TYPE|                     /*  "type"        */
    INIT|                     /*  "init"        */
    THIS|                     /*  "this"        */
    SUPER|                    /*  "super"       */
    IF|                       /*  "if"          */
    ELSE|                     /*  "else"        */
    CASE|                     /*  "case"        */
    TRY|                      /*  "try"         */
    CATCH|                    /*  "catch"       */
    FINALLY|                  /*  "finally"     */
    FOR|                      /*  "for"         */
    DO|                       /*  "do"          */
    WHILE|                    /*  "while"       */
    THROW|                    /*  "throw"       */
    RETURN|                   /*  "return"      */
    CONTINUE|                 /*  "continue"    */
    BREAK|                    /*  "break"       */
    IN|                       /*  "in"          */
    NOT_IN|                   /*  "!in"         */
    MATCH|                    /*  "match"       */
    FROM|                     /*  "from"        */
    WHERE|                    /*  "where"       */
    EXTEND|                   /*  "extend"      */
    WITH|                     /*  "with"        */
    PROP|                     /*  "prop"        */
    STATIC|                   /*  "static"      */
    PUBLIC|                   /*  "public"      */
    PRIVATE|                  /*  "private"     */
    PROTECTED|                /*  "protected"   */
    OVERRIDE|                 /*  "override"    */
    REDEF|                    /*  "redef"       */
    ABSTRACT|                 /*  "abstract"    */
    SEALED|                   /*  "sealed"      */
    OPEN|                     /*  "open"        */
    FOREIGN|                  /*  "foreign"     */
    INOUT|                    /*  "inout"       */
    MUT|                      /*  "mut"         */
    UNSAFE|                   /*  "unsafe"      */
    OPERATOR|                 /*  "operator"    */
    SPAWN|                    /*  "spawn"       */
    SYNCHRONIZED|             /*  "synchronized */
    UPPERBOUND|               /*  "<:"          */
    MAIN|                     /*  "main"        */
    IDENTIFIER|               /*  "x"           */
    INTEGER_LITERAL|          /*  e.g. "1"      */
    FLOAT_LITERAL|            /*  e.g. "'1.0'"  */
    COMMENT|                  /*  e.g. "//xx"     */
    NL|                       /*  newline         */
    END|                      /*  end of file     */
    SENTINEL|                 /*  ";"             */
    RUNE_LITERAL|             /*  e.g. "r'x'"      */
    STRING_LITERAL|           /*  e.g. ""xx""     */
    JSTRING_LITERAL|          /*  e.g. "J"xx""     */
    MULTILINE_STRING|         /*  e.g. """"aaa""""   */
    MULTILINE_RAW_STRING|     /*  e.g. "#"aaa"#"     */
    BOOL_LITERAL|             /*  "true" or "false"  */
    UNIT_LITERAL|             /*  "()"               */
    DOLLAR_IDENTIFIER|        /*  e.g. "$x"          */
    ANNOTATION|               /*  e.g. "@When"       */
    ILLEGAL
}