V语言02基础2

我就是我 2022-10-10 09:53 127阅读 0赞

# 数字 #

a := 123

默认为`整`.

a := 0x7B
    b := 0b01111011
    c := 0o173

`2,8,16`进制均可.始终为`整`型.与`形式`无关.以`_`为数字分隔符.

num := 1_000_000 // 1000000
    three := 0b0_11 // 0b11
    float_num := 3_122.55 // 3122.55
    hexa := 0xF_F // 255
    oct := 0o17_3 // 0o173

不同类型,这样转:

a := i64(123)
    b := byte(42)
    c := i16(12345)
    //上为整,下为浮
    f := 1.0
    f1 := f64(3.14)
    f2 := f32(3.14)

默认浮为`f64`,就像整默认为`整`一样.

# 数组 #

相同类型元素的集合.

mut nums := [1, 2, 3]
    println(nums) // `[1, 2, 3]`
    println(nums[0]) // `1`
    println(nums[1]) // `2`
    nums[1] = 5
    println(nums) // `[1, 5, 3]`

数组属性:

<table> 
 <thead> 
  <tr> 
   <th align="left"><code>属性</code></th> 
   <th align="left">意思</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>len</code></td> 
   <td align="left">长度,</td> 
  </tr> 
  <tr> 
   <td align="left"><code>cap</code></td> 
   <td align="left">容量,内存空间,默认自动,可手动优化</td> 
  </tr> 
 </tbody> 
</table>

mut nums := [1, 2, 3]
    println(nums.len) // "3"
    println(nums.cap) // >="3"
    nums = [] // 空数组
    println(nums.len) // "0"

属性只读,用户不可改.  
`[1, 2, 3]`类型为`[]整`.而`["a", "b"]`为`[]串`.  
可在`首元素`显式指定类型如:`[byte(16), 32, 64, 128]`.`数组类型不同,编译不过`:`[1, "a"]`.  
第2种初化语法:

mut a := []int{ len: 10000, cap: 30000, init: 3}
    //指定数组`属性`来初化.

上面创建`10000`个`3`,空间保留为`30000`个元素大小.参数`大小,容量,初化`可选,大小默认为`0`,`初化`默认为相应类型的`默认值`.默认`数值为0,串为""`.保证`容量>=大小`.

arr := []int{ len: 5, init: -1}
    // `arr == [-1, -1, -1, -1, -1]`, arr.cap == 5
    // 声明空数组
    users := []int{ }

置容量,可提升性能,因为不必`再分配`.

mut numbers := []int{ cap: 1000}
    println(numbers.len) // 0
    // 现在附加元素,不会分配
    for i in 0 .. 1000 { 
    	numbers << i
    }

`for`为`区间`,而`<<`为`压`操作符(把`C++`的废物利用好).  
数组元素类型可为:

<table> 
 <thead> 
  <tr> 
   <th align="left"><code>类型</code></th> 
   <th align="left">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>数字</code></td> 
   <td align="left">[]int,[]i64</td> 
  </tr> 
  <tr> 
   <td align="left"><code>串</code></td> 
   <td align="left">[]string</td> 
  </tr> 
  <tr> 
   <td align="left"><code>符文</code></td> 
   <td align="left">[]rune</td> 
  </tr> 
  <tr> 
   <td align="left"><code>布尔</code></td> 
   <td align="left">[]bool</td> 
  </tr> 
  <tr> 
   <td align="left"><code>数组</code></td> 
   <td align="left">[][]int</td> 
  </tr> 
  <tr> 
   <td align="left"><code>构</code></td> 
   <td align="left">[]MyStructName</td> 
  </tr> 
  <tr> 
   <td align="left"><code>通道</code></td> 
   <td align="left">[]chan f64</td> 
  </tr> 
  <tr> 
   <td align="left"><code>函数</code></td> 
   <td align="left">[]MyFunctionType []fn (int) bool</td> 
  </tr> 
  <tr> 
   <td align="left"><code>接口</code></td> 
   <td align="left">[]MyInterfaceName</td> 
  </tr> 
  <tr> 
   <td align="left"><code>和类型(C++的变量类型)</code></td> 
   <td align="left">[]MySumTypeName</td> 
  </tr> 
  <tr> 
   <td align="left"><code>泛型</code></td> 
   <td align="left">[]T</td> 
  </tr> 
  <tr> 
   <td align="left"><code>映射</code></td> 
   <td align="left">[]map[string]f64</td> 
  </tr> 
  <tr> 
   <td align="left"><code>枚举</code></td> 
   <td align="left">[]MyEnumType</td> 
  </tr> 
  <tr> 
   <td align="left"><code>别名</code></td> 
   <td align="left">[]MyAliasTypeName</td> 
  </tr> 
  <tr> 
   <td align="left"><code>线程</code></td> 
   <td align="left">[]thread int</td> 
  </tr> 
  <tr> 
   <td align="left"><code>引用</code></td> 
   <td align="left">[]&amp;f64</td> 
  </tr> 
  <tr> 
   <td align="left"><code>共享</code></td> 
   <td align="left">[]shared MyStructType</td> 
  </tr> 
 </tbody> 
</table>

示例,`构`的`和类型`来创建处理不同类型`点/线`数组.

struct Point { 
    	x int
    	y int
    }
    
    struct Line { 
    	p1 Point
    	p2 Point
    }
    
    type ObjectSumType = Line | Point
    //这就是传说中的`和类型`,C++的变量类型.
    
    mut object_list := []ObjectSumType{ }
    object_list << Point{ 1, 1}//点
    object_list << Line{ //线
    	p1: Point{ 3, 3}//由点构成的线.
    	p2: Point{ 4, 4}
    }
    dump(object_list)//[和(点),和(线(点,点))]

# 多维数组 #

mut a := [][]int{ len: 2, init: []int{ len: 3}}
    a[0][1] = 2
    println(a) // [[0, 2, 0], [0, 0, 0]]
    //上为2维,下为3维
    mut a := [][][]int{ len: 2, init: [][]int{ len: 3, init: []int{ len: 2}}}
    a[0][1][1] = 2
    println(a) // [[[0, 0], [0, 2], [0, 0]], [[0, 0], [0, 0], [0, 0]]]

数组操作,主要是`<<`,类似`C++`的`压后`.也可`附加`整个数组.

mut nums := [1, 2, 3]
    nums << 4
    println(nums) // "[1, 2, 3, 4]"
    //附加数组
    nums << [5, 6, 7]
    println(nums) // "[1, 2, 3, 4, 5, 6, 7]"
    mut names := ["John"]
    names << "Peter"
    names << "Sam"
    // names << 10 //类型不同,编译不过

用`in`表示是否在`数组`中.

names := ["John", "Peter", "Sam"]
    println(names.len) // "3"
    println("Alex" in names) // 假

可用`println(arr)`打印数组,也易这样`s := arr.str()`转为串.

nums := [1, 2, 3]
    nums_copy := nums.clone()
    //这样复制.

过滤映射用`.filter()和.map()`,

nums := [1, 2, 3, 4, 5, 6]
    even := nums.filter(it % 2 == 0)
    println(even) // [2, 4, 6]
    // filter can accept anonymous functions
    even_fn := nums.filter(fn (x int) bool { 
    	return x % 2 == 0
    })
    println(even_fn)
    words := ["你好", "世界"]
    upper := words.map(it.to_upper())
    println(upper) // ["你好", "世界"]
    //映射也可接受(λ函数)
    upper_fn := words.map(fn (w string) string { 
    	return w.to_upper()
    })
    println(upper_fn) // ["你好", "世界"]

`it`为`过滤/映射`内置变量,指代`当前元素`,`it->迭代/它`的意思.  
`.any()和.all()`表示`数组`满足`任一/所有`.

ums := [1, 2, 3]
    println(nums.any(it == 2)) //真
    println(nums.all(it >= 2)) //假

数组内置方法,其实`数组`就是`C++`的`向量`.

<table> 
 <thead> 
  <tr> 
   <th align="left"><code>方法</code></th> 
   <th align="left">意思</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>b := a.repeat(n)</code></td> 
   <td align="left">重复(a,n)</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.insert(i, val)</code></td> 
   <td align="left"><code>i</code>处插入<code>值</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.insert(i, [3, 4, 5])</code></td> 
   <td align="left"><code>i</code>处插入多个值</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.prepend(val)</code></td> 
   <td align="left"><code>0</code>处插入,前插</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.prepend(arr)</code></td> 
   <td align="left">前插数组</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.trim(new_len)</code></td> 
   <td align="left">截断长度</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.clear()</code></td> 
   <td align="left">清理,不改容量<code>==a.截断(0)</code>.</td> 
  </tr> 
  <tr> 
   <td align="left"><code>v := a.first()</code></td> 
   <td align="left"><code>a[0]</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>v := a.last()</code></td> 
   <td align="left"><code>a[$-1]</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>v := a.pop()</code></td> 
   <td align="left">取尾并弹</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.delete_last()</code></td> 
   <td align="left">弹尾</td> 
  </tr> 
  <tr> 
   <td align="left"><code>b := a.reverse()</code></td> 
   <td align="left">逆向</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.reverse_in_place()</code></td> 
   <td align="left">原位逆向</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a.join(joiner)</code></td> 
   <td align="left">用合并器合并串数组</td> 
  </tr> 
 </tbody> 
</table>

# 排序数组 #

mut numbers := [1, 3, 2]
    numbers.sort() // 1, 2, 3
    numbers.sort(a > b) // 3, 2, 1

用`a,b`来描述`自定义排序`.

struct User { 
    	age  int
    	name string
    }
    mut users := [User{ 21, "张三"}, User{ 20, "李四"}, User{ 25, "王五"}]
    users.sort(a.age < b.age) //按年龄排序
    users.sort(a.name > b.name) //按名排序

# 数组切片 #

先是`索引`,增加时`切片`就`复制`成`新数组`了,用`..`表示.要求`右端>=左端`.无右则为`$`,无左,则为`0`.

nums := [0, 10, 20, 30, 40]
    println(nums[1..4]) // [10, 20, 30]
    //这里[1..4]其实是[1,4)左闭右开要注意.
    println(nums[..4]) // [0, 10, 20, 30]
    println(nums[1..]) // [10, 20, 30, 40]

`V`中,切片也是先是`引用`,增加后`实例`.与`d`区别是`分配策略`.

array_1 := [3, 5, 4, 7, 6]
    mut array_2 := [0, 1]
    array_2 << array_1[..3]
    println(array_2) // `[0, 1, 3, 5, 4]`

切片用最小容量创建,即`cap == len`.增加大小时,立即重新分配并移动位置,因而与`父独立`,也叫`增长时复制`.先是`引用`,`切片`增加`元素`就`复制`了.不具备`引用`特点了.

mut a := [0, 1, 2, 3, 4, 5]
    mut b := a[2..4]
    b[0] = 7 // `b[0]`引用`a[2]`
    println(a) // `[0, 1, 7, 3, 4, 5]`//变化了.
    b << 9
    // `b`重新分配,与a独立了.
    println(a) // `[0, 1, 7, 3, 4, 5]`不变了.
    println(b) // `[7, 3, 9]`

添加`父`数组元素,`可能/可能不`会使其与`子切片`独立.要看`容量`.

mut a := []int{ len: 5, cap: 6, init: 2}
    mut b := a[1..4]
    a << 3
    //无分配.
    b[2] = 13 // 修改了`a[3]`
    a << 4
    //分配a,与b独立了.
    b[1] = 3 //与`a`无关了.
    println(a) // `[2, 2, 2, 13, 2, 3, 4]`
    println(b) // `[2, 3, 13]`

在`父/子`新分配`内存`前,则是`引用(非独立)`关系.在`分配`内存后,就是`独立`关系了.

# 固定大小数组 #

长度固定,只能原位`修改`元素.效率更高,占用内存更少,数据在`栈`上,不想分配在堆上时,用作缓冲.  
多数方法定义在`普通`数组(`d的动态数组`)上.可用`切片`转成普通数组:

mut fnums := [3]int{ } //固定3
    fnums[0] = 1
    fnums[1] = 10
    fnums[2] = 100
    println(fnums) // => [1, 10, 100]
    println(typeof(fnums).name) // => [3]int
    
    fnums2 := [1, 10, 100]! //短初化符号,(注意:可能要改)
    
    anums := fnums[0..fnums.len]
    println(anums) // => [1, 10, 100]
    println(typeof(anums).name) // => []int

固定数组的切片,会直接复制.所谓`固定数组`就是`D`的静态数组,就是`C`的`普通数组`.