2 Star 7 Fork 1

372681370@QQ.com / klang

Create your Gitee Account
Explore and code with more than 6 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.
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

About

No description spread retract
Cancel

Releases

No release

Contributors

All

Activities

load more
can not load any more
1
https://gitee.com/HTWX/klang.git
git@gitee.com:HTWX/klang.git
HTWX
klang
klang
master

Search