函数 启动(){
 打印('世界你好')
}

>> 世界-你好!

// 单行注释

/* 多行注释
    /* 嵌套注释 */
    // 嵌套注释 
*/

函数 启动(){
    世界 := '世界'
    你好 := '你好'
    世界你好 := `{世界}-{你好}!`
    打印(世界你好)
}

变量 a: 整数
a = 100

变量 b = 100

c := 100

常量 a = '我是常量' // 常量的类型可推断 不能是`通用`型

a := '这样就错误了' // 不允许初始化方法

a = '这样就错误了' // 再次赋值错误

常量 b = 列表({1,2,3}[1:2]) // 初始值为数组\列表\结构等其他类型可对成员重新赋值

 a := {1,2,3} // 整数[3] 类型 及 长度推断

 变量 b:整数[3] // 无初始 {0,0,0}

 // 使用前赋值

 b = {1,2,3}

 // 初始值数量必须小于或等于设定长度
 变量 s:文字[3] = {'a','b','c'}

a := [4]整数{1,2,3,4}   // 固定长度数组
a := []整数{1,2}        // 推断长度数组 

a:[2]整数               // 初始为2个单位的数组

a:[...]整数             // 动态数组
a := [...]整数{1,2,3}

词典[{1,2},{2,3}]



// { 1, 2, 3, - , - }
lb := [3:5]整数{1,2,3}

lb := [3:5]整数

// { 0, 0, 0, - , - }
lb := 列表(整数,3,5)

// { 2, - , - , - , - }
lb := 创建(a[1:2:5])
 
// { 2, 3, - , -, - }
lb := 创建(a[1:-1:5])

// { 1, 2, 3, - , - }
lb := 创建(a[-1:5])

// { 2, 3 }
lb := 创建(a[1:3])

对象 对象名称 {

   属性名:类型名:`json:p`

   _私有属性:类型名

   匿名属性 // 直接指定类型名, 如有同名 后面的覆盖前面的

}

属性格式 _属性名_:_类型名_:_序列化标签_ 或 _类型名_

 // *号 和 &号 _取值_ 和 _取址_
 a := 10

 p := &a

 c := 新建(文字)

 *c = '我是文字'

 打印(p)

 打印(*p)

 打印(c)

 打印(*c)

// 与 go语言 map 相同

名域 启动

函数 启动(){

    // 没初始化的声明
    变量 m : 词典[文字,整数] 
    m = 创建一个新的词典()
    打印(长度(m))

    m2 := 创建(词典[文字,整数], 10)
    m2['abc'] = 123

    打印(长度(m2))
 
    循环(键 := 遍历 m2){
        打印(m2[键])
    }

    值, 存在 = m2['abc']
    如果(存在){
        打印(值)
    }

}

函数 创建一个新的词典() 词典[文字]整数{
    m := 词典[文字]整数 {}
    返回 m
}

// 与 go语言 chan 相同

名域 启动

导入(
  '时间'
)

函数 启动(){
    ch := 创建(通道 整数) 
    执行 ()=> {
        循环(i := 5; i < 0; i--){
            ch <- i
            时间.暂停(时间.秒)
        }
    }()

    循环(数据 := 遍历 ch){

         打印(数据)
 
        如果(数据 :== 0){
            跳出
        }
    }
}

如果(_条件_){

}
另如(_条件_){
    ...
}
否则{
    ...
}

// 循环头部可有标签 配合关键字`跳出`及`继续`

循环(_条件_){
    ...
}

// 相当于 循环(真){}
循环(){
    ...
}

循环(i := 0; i< 10; i++){
    ...
}

循环(i := 0; ; i++){
    ...
}

循环(值 := 遍历 变量实例){
    ...
}

函数 启动(){

    i := 0
    ii := 0
    标签1:循环(){
            标签2:循环(){
                如果(i :== 5){
                    i += 2
                    继续
                }
                如果(i :== 10){
                    跳出 标签2
                }
                i++
            }
            如果(ii :== 10){
                跳出 标签1
            }
        ii++
    }

}

// 假如 若是 默认 下个

函数 启动(){
    a := 'aaa'
    假如(a){
        若是 'aaa','bbb',`ccc`:
            打印(a)
        若是 'ee':
            打印(a)
         默认:
            打印('我是默认')
    }

    变量 t:通用
    假如(s := t.(类型)){
        若是 未定:
            打印(未定义)
        若是 真假, 文字:
            打印(`类型是真假或文字`)
         默认:
            打印(s)
    }  

    b := 真

    假如(b){
        若是 真:
            打印('真 ')
            下个
        若是 假:
            打印('这个会执行)
        默认:
            打印('我是默认')
    }

}

函数 启动() {

    c1 := 创建(通道 整数)
    c2 := 创建(通道 整数)
    c3 := 创建(通道 整数)

    变量 i1:整数
    变量 i2:整数

    选择 {
        若是 i1 = <- c1:
            打印('收到 ', i1, ' 来自 c1\n')
        若是 c2 <- i2:
            打印('发送 ', i2, ' 到 c2\n')
        若是 i3, 成功 := (<- c3):
            如果(成功) {
                打印('收到 ', i3, ' 来自 c3\n')
            } 
            否则{
               打印('c3 是关闭的\n')
            }
        默认:
            打印('没有连接\n')
    }

}

名域 启动

结构 学生 {
    姓名:文字
    年龄:整数
}

/*
使用值接收器的方法。
*/
方法 改变姓名(e: 学生, 新姓名: 文字) {
    e.姓名 = 新姓名
}

/*
使用指针接收器的方法。
*/
方法 改变年龄(e: *学生, 新年龄: 整数) {
    e.年龄 = 新年龄
}

函数 启动() {

    e := 学生{
    姓名: '小李',
    年龄: 5,
    }

    打印(`同学小李的姓名改变为小李子`)
    e.改变姓名('小李子')

    // 接收器不是指针, 对调用者不可见 
    打印(`现在的姓名是`, e.姓名 )

    打印(`同学小李的年龄修改为10岁`)
    e.改变年龄(10)
    打印(`现在的姓名是`, e.年龄 )

}

// 接口是一组方法签名的集合

名域 启动


接口 编辑{
    改变姓名(新姓名:文字):空值
    改变年龄(新年龄:数组):空值
}

结构 学生{
    姓名:文字
    年龄:整数
}

/*
使用值接收器的方法。
*/
方法 改变姓名(e: 学生, 新姓名: 文字) {
    e.姓名 = 新姓名
}

/*
使用指针接收器的方法。
*/
方法 改变年龄(e: *学生, 新年龄: 整数) {
    e.年龄 = 新年龄
}

函数 启动() {

    e := 学生{
    姓名: '小李',
    年龄: 5,
    }

    编辑姓名(e, '小李子')
}

函数 编辑姓名(e: 编辑, 新名字: 文字){
    e.改变姓名(新名字)
}

// 获取变量的类型

名域 启动

接口 编辑{
    改变姓名(新姓名:文字): 空值
    改变年龄(新年龄:数组): 空值
}

结构 学生{
    姓名: 文字
    年龄: 整数
}

方法 改变姓名(e: 学生, 新姓名: 文字) {
    e.姓名 = 新姓名
}

方法 改变年龄(e: *学生, 新年龄: 整数) {
    e.年龄 = 新年龄
}

函数 启动() {

    e := 学生{
        姓名: '小李',
        年龄: 5,
    }

    接口类型, 成功 := e.(编辑)

    如果 (成功) {
        打印(接口类型)
    }

    变量 i:通用 = 10

    变量类型, 成功2 := i.(整数)

    如果 (成功2) {
        打印(变量类型)
    }
}

// 判断类型是否实现了某接口

名域 启动

接口 编辑{
    改变姓名(新姓名:文字): 空值
    改变年龄(新年龄:数组): 空值
}

结构 学生{
    姓名: 文字
    年龄: 整数
}

方法 改变姓名(e: 学生, 新姓名: 文字) {
    e.姓名 = 新姓名
}

方法 改变年龄(e: *学生, 新年龄: 整数) {
    e.年龄 = 新年龄
}

函数 启动() {

    e := 学生{
        姓名: '小李',
       年龄: 5,
    } 
    类型判断(e)
}

函数 类型判断(i:通用){

    假如(t := i.(类型)){
        若为 文字:
            ...
            打印('文字类型')
        默认:
           打印(t)
    }

}