Watch 2 Star 3 Fork 1

372681370@QQ.com / klang

Join us
Explore and code with more than 2 million developers,Free private repositories !:)
Sign up
This repository doesn't specify license. Without author's permission, this code is only for learning and cannot be used for other purposes.
Nothing here. spread retract

Clone or download
Cancel
Notice: Creating folder will generate an empty file .keep, because not support in Git
Loading...
README.md

简介

世界你好


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

>> 世界-你好!

注释


// 单行注释

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

函数


  • 函数允许多返回值
  • 支持可选参数, 默认参数, 命名参数, 传址, 传值
  • 匿名函数, 箭头函数
函数 启动(){
    世界 := '世界'
    你好 := '你好'
    世界你好 := `{世界}-{你好}!`
    打印(世界你好)
}

变量


  • 不支持全局变量
  • 局部作用域变量不能与父作用域变量重名(禁止覆盖)
  • 变量作用域按声明位置区分
  • := 作为初始化声明
变量 a: 整数
a = 100

变量 b = 100

c := 100

常量


  • 只能在初始化赋值 赋值后不能再次赋值

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

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

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

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

类型


基本类型

类型名称 有无符号 字节数
整数8 8
整数16 16
整数32 32
整数64 64
正整数8 8
正整数16 16
正整数32 32
正整数64 64
整数 整数32
正整数 正整数32
小数 小数32
小数32
小数64
符文 与 整数32 等价
字节 与 整数8 等价
安全指针 -

派生类型

数组

  • 任意同类型数据
  • 格式
  • 变量 名称: 类型名[数量][多维] = {初始化}
  • 或 名称 := 类型名[数量][多维] {{初始化},{初始化}}
 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])

对象

  • 相当于go 结构体
对象 对象名称 {

   属性名:类型名:`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)
    }

}

关键字

  • 关键字
名域 导入 启动
变量 常量 枚举
函数 方法 接口 类型
结构 执行 创建 遍历 返回
获取 延迟 删除

  • 流程关键字
循环 继续 跳出
假如 若是 默认 下个 选择
如果 否则 另如

  • 类型关键字
整数 整数8 整数16 整数32 整数64
正整数 正整数8 正整数16 正整数32 正整数64
小数 小数32 小数64
通用 复数 复数64 复数128
虚数 实数 安全指针 符文
真假
字节 文字 正则
未定 空值

  • 其他
数组 列表 对象 词典 通道
添加 关闭
复制 长度 上限 抛出 恢复

运算符

下表列出了所有Go语言的算术运算符。假定 A 值为 10,B 值为 20。

运算符 描述 实例
+ 相加 A + B 输出结果 30
- 相减 A - B 输出结果 -10
* 相乘 A * B 输出结果 200
** 乘方 A*A 输出结果 100
/ 相除 B / A 输出结果 2
% 求余 B % A 输出结果 0
++ 自增 A++ 输出结果 11
-- 自减 A-- 输出结果 9

关系运算符

运算符 描述 实例
:== 检查两个值是否相等,如果相等返回 True 否则返回 False。 (A := B) 为 False
!:= 检查两个值是否不相等,如果不相等返回 True 否则返回 False。 (A != B) 为 True
> 检查左边值是否大于右边值,如果是返回 True 否则返回 False。 (A > B) 为 False
< 检查左边值是否小于右边值,如果是返回 True 否则返回 False。 (A < B) 为 True
>= 检查左边值是否大于等于右边值,如果是返回 True 否则返回 False。 (A >= B) 为 False
<= 检查左边值是否小于等于右边值,如果是返回 True 否则返回 False。 (A <= B) 为 True

逻辑运算符

下表列出了所有Go语言的逻辑运算符。假定 A 值为 True,B 值为 False。

运算符 描述 实例
&& 逻辑 AND 运算符。 如果两边的操作数都是 True,则条件 True,否则为 False。 (A && B) 为 False
|| 逻辑 OR 运算符。 如果两边的操作数有一个 True,则条件 True,否则为 False。 (A || B) 为 True
! 逻辑 NOT 运算符。 如果条件为 True,则逻辑 NOT 条件 False,否则为 True。 !(A && B) 为 True

位运算符

Go 语言支持的位运算符如下表所示。假定 A 为60,B 为13:

运算符 描述 实例
& 按位与运算符'&'是双目运算符。 (A & B) 结果为 12, 二进制为 0000 1100
| 按位或运算符'|'是双目运算符。 (A | B) 结果为 61, 二进制为 0011 1101
^ 按位异或运算符'^'是双目运算符。 (A ^ B) 结果为 49, 二进制为 0011 0001
<< 左移运算符'<<'是双目运算符。左移n位就是乘以2的n次方。 A << 2 结果为 240 ,二进制为 1111 0000
>> 右移运算符'>>'是双目运算符。右移n位就是除以2的n次方。 A >> 2 结果为 15 ,二进制为 0000 1111

赋值运算符

下表列出了所有Go语言的赋值运算符。

运算符 描述 实例
:= 初始化赋值运算符 C := A 声明一个变量 C 并初始化为 A
= 简单的赋值运算符,将一个表达式的值赋给一个左值 C = A + B 将 A + B 表达式结果赋值给 C
+= 相加后再赋值 C += A 等于 C = C + A
-= 相减后再赋值 C -= A 等于 C = C - A
*= 相乘后再赋值 C *= A 等于 C = C * A
/= 相除后再赋值 C /= A 等于 C = C / A
%= 求余后再赋值 C %= A 等于 C = C % A
<<= 左移后赋值 C <<= 2 等于 C = C << 2
>>= 右移后赋值 C >>= 2 等于 C = C >> 2
&= 按位与后赋值 C &= 2 等于 C = C & 2
^= 按位异或后赋值 C ^= 2 等于 C = C ^ 2
|= 按位或后赋值 C |= 2 等于 C = C | 2

其他运算符

下表列出了Go语言的其他运算符。

运算符 描述 实例
& 返回变量存储地址 &a;将给出变量的实际地址。
* 指针变量。 *a; 是一个指针变量

优先级

运算符优先级 有些运算符拥有较高的优先级,二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级,由上至下代表优先级由高到低: |优先级|运算符| |:---:|:---| | 7 | ^ ! | | 6 | * / % << >> & &^ | | 5 | + - | ^ | | 4 | :== != < <= >= > | | 3 | <- | | 2 | && | | 1 | || |

Comments ( 0 )

Sign in for post a comment

1
https://gitee.com/HTWX/klang.git
git@gitee.com:HTWX/klang.git
HTWX
klang
klang
master

Help Search