语言基础

/*
多行
*/
fn main() {
  println('hello world') //注释
}

fn add(x int, y int) int {  
  return x + y  
}
pub fn public_function() {
}

a:='hi' #字符串用单引号
a,b:=1,2 支持多个
c := i64(b) 类型转换T(v)
mut a:=1 可变变量
println('输出${a}') 字符串中输出变量

• bool 布尔型
• string 字符串默认utf8编码

  s:='No'
  println(s[0].ascii_str()) 输出N s[0] 78
  print(s.len) 长度2
  s1:=s.bytes() 转换成字节码 [78,111]
  print(s1.bytestr()) 还原字节码为字符串 No
  print(s.runes()) 转换成unicode 
  s := r'hello\nworld' 转移不处理加r
  print('22'.int()) 转换整数
  print('aa'+'bb') 字符串链接+
  print(12.str()) 转换成字符串
  rocket := `🚀` 符文使用反引号,是unicode编码 u32 rune,用str()转换成utf8

• int(i32) i8 i16 i64 i128 rune(i32 是unicode) 有符号整数
  0x十六进制 0b二进制 0o八进制

  print('${1234.56:010}') 0001234.56 不够十位用0占位
  print('${1234.567:5.2f}') 1234.57 保留两位小数浮点数四舍五入
  print('${1234:o}') 转换成八进制
  print('${1234:b}') 二进制
  print('${1234:X}') 十六进制 小写x是小写字母

• u8(byte) u16 u32 u64 u128 无符号
• f32 f64 浮点数
  支持科学计数 10e-2 10e2
• 数组

  mut n:=[1,2,3]
  n[0]=0 输出[0,2,3]
  n << 0
  n << [7,8,9] 追加多个
  print(7 in n) 判断7在不在数组中 true
  7 !in n 不在n中
  print(n.len) 长度 7
  print(n.cap) 保留空间长度12
  n=[] 清空数组
  []int []i64 []string定义
  arr.str() 转换成字符串数组
  nums := [1, 2, 3, 4, 5, 6]
  nums.filter(it % 2 == 0) 过滤支持函数
  words := ['hello', 'world']
  upper := words.map(it.to_upper()) 映射
  n.repeat(2) 重复两次数组[1,2,3,1,2,3] 返回新数组
  n.insert(0,1) 头部插入1,也可以插入数组,[1,1,2,3]
  n.insert(n.len,1) 尾部插入[1,2,3,1],无返回
  n.clear() n.trim(0) 清空数组,功能相同 无返回
  n.trim(n.len-1)截取数组,最大n.len 无返回
  n.delete_many(0,2) 从开头删除两元素 无返回
  n.delete(1)n.delete_many(1,1) 删除1位置元素 功能相同,无返回
  n.delete_last() 删除最后一个元素,无返回
  n.first() n[0] 返回第一个元素
  a.last(),n[n.len - 1] 返回最后一个
  n.pop() 删除最后一个并返回这个值
  n1:=n.reverse() 数组反序并返回这个数组
  n.sort(a>b) 排序从大到小 n.sort()从小到大,不返回修改原数组,支持结构体和map
  n1:=n.sorted(a>b) n1:=n.sorted() 原数组不变
  print(n[1..3]) 截取1-3 两个组成的新数组
  n[..] 全部 n[1..] 到结尾 n[..2]开头到2
  print(n#[-3..-1]) 负数截取最后一个-1 
  mut n:=[3]int{} 固定大小数组

• map,映射
  映射可以具有 string、rune、integer、float 或 voidptr 类型的键

  mut m:=map[string]int{}
  m['a']=1
  m['b']=7
  m := {'one':1,'two':2,'three':3}
  m2 := {1 :'a', 2 :'b', 3 :'c'}
  print('c' in m) 返回false,不在m中
  println(m.keys()) key组成的新数组
  print(m.values()) val组成的新数组
  if v:=m['a']{ 判断key是否存在
    println(v)
  }

a,b:=1,2
  if a>2{
      println('a>2')
  }else if b<0{
      println('a<0')
  }else{
      println('a=0')
  }
  ###
      num := 2
s := if num % 2 == 0 { '偶数' } else { '奇数' }
###
os := 'windows'
match os {
  'darwin' { println('macOS.') }
  'linux' { println('Linux.') }
  else { println(os) }
}
###
循环,只有for in一种
numbers := [1, 2, 3, 4, 5]
for num in numbers {
  println(num)
}
for i,num in numbers {
  println('$i,$num')
}
mp:={'a':1,'b':2,'c':3} 换行写不用,
  for k,v in mp{
      print('$k=>$v')
  }
for i in 0 .. 5 { 输出01234
  print(i)
}
###
mut sum:=0
mut i:=0
for i<=100 {
  sum+=i
  i++
}
print(sum)
###
mut s:=0
for i:=0;i<=100;i++{
s+=i
}
print(s)

struct Point {
  x int
  y int
}
p:=Point{1,2}
print(p.x)
### 引用用&
struct Cat {
  mut:
   x int
      y int
}
mut p:=&Cat{1,2}
p.x=4
print(p.x)
struct Foo {
  n   int    // n is 0 
  s   string // s is ''
  a   []int  // a is `[]int{}` 
  pos int = -1 // 自定义-1
  m int @[required] 必须初始化
  pub mut:
  x int
}
### 匿名结构体
x:=struct{
      a:1
      b:2
  }

struct User {
 mut: age int
}
fn (u User) get_age() bool {
  return u.age > 16
}
user := User{
  age: 10
}
println(user.get_age())
### 联合体
union Cat{
  User
  name string
}
u1:=  Cat{
  name:"cat"
}
unsafe{println(u1.name)} 输出必须包含在unsafe中
#可变参数
struct Car {
  name string
 mut:
  year int
  color string
}
fn (mut c Car)get_color() {
  c.color='黑色'
}
mut c:=Car{}
c.get_color()
println(c.color) 输出黑色
###参数个数可变
fn sum(a ...int) int {
  mut total := 0
  for x in a {
      total += x
  }
  return total
}
###匿名函数
fx := fn (n int) int {
      return n + n
  }
  dump(fx(1))
  ###闭包,显示出来
  mut i := 1
func := fn [i] () int {
  return i
}
println(func())
i=3
print(func())输出依然是1
###外部可修改 &是引用 *是取消引用
mut i := 1
mut j:=&i
func := fn [j] () int {
  return *j
}
println(func())
i=123
print(func()) 输出123

const e = 2.71828
pub const golden_ratio = 1.61803 公开常量
const numbers = [1, 2, 3]
struct Color {
  r int
  g int
  b int
}
const red = Color{
  r: 255
  g: 0
  b: 0
}
fn rgb(r int, g int, b int) Color {
  return Color{
      r: r
      g: g
      b: b
  }
}
const blue = rgb(0, 0, 255)

enum Cx {
      a
      b
      c
  }
  cc:=int(Cx.b) 输出1
  print(Cx.b.str()) 输出b

struct Dog {
  breed string
}
fn (d Dog) speak() string {
  return 'woof'
}
struct Cat {
  breed string
}
fn (c Cat) speak() string {
  return 'meow'
}
interface Speaker {
  breed string
  speak() string
}

fn compare[T](a T, b T) int {
  if a < b {
      return -1
  }
  if a > b {
      return 1
  }
  return 0
}

fn p(a f64, b f64) {
  c := math.sqrt(a * a + b * b)
  println(c)
}
h:=spawn p(3,4)
  h.wait()
  j:=spawn p(5,12)
  go p(1,1)
  j.wait()
  ###大量任务,thread数组
  mut threads := []thread{}
  threads << spawn task(1, 500)
  threads << spawn task(2, 900)
  threads << spawn task(3, 100)
  threads.wait()
  ###通道
  ch := chan int{cap: 1}
  n:=5
  ch<-n 发送消息
  m := <-ch 读取消息
  print(m)
  ###计数器
  mut wg:=sync.new_waitgroup() 创建WaitGroup
  wg.add(int) 递增计数
  wg.done() 递减计数
  wg.wait() 阻塞等待,直到计数归零

struct User { 
  age           int
  nums          []int @[required]
  last_name     string @[json:lastName] // 设置对应的json字段名
  is_registered bool @[json:IsRegistered] // 设置对应的json字段名
  type           int @[json:'type'] //如果json中的字段是V关键字,需要加''
  skip_filed    string @[skip] // 使用了skip注解,这个字段会被忽略不参与编码和解码
}
data  := '{"age": 10, "nums": [1,2,3], "type":1, "lastName": "Johnson", "IsRegistered": true}'
user := json.decode(User, data) or {exit(1)}
----编码---key不能是数字map
struct User1 {
  name  string
  score i64
}
user1 := &User1{
  name:  'Pierre'
  score: 1024
}
data1:= json.encode(user1)
dump(data1)
mut data2 :=  {'aa':1,'bb':2}
dump(json.encode(data2))

fn hello() string {
  return 'Hello world'
}
assert hello() == 'Hello world' 不输出就是正确,否则显示信息
unsafe{ //不安全代码}
print(sizeof(9)) 类型大小字节 8