Fetch the repository succeeded.
简介
函数 启动(){
打印('世界你好')
}
>> 世界-你好!
// 单行注释
/* 多行注释
/* 嵌套注释 */
// 嵌套注释
*/
函数 启动(){
世界 := '世界'
你好 := '你好'
世界你好 := `{世界}-{你好}!`
打印(世界你好)
}
:=
作为初始化声明变量 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])
对象
对象 对象名称 {
属性名:类型名:`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 | || |
Sign in for post a comment
Comments ( 0 )