Rust vs Go:常用语法对比
这个网站 可以列出某门编程语言的常用语法，也可以对比两种语言的基本语法差别。
在此对比Go和Rust
1. Print Hello World
打印Hello World
package main
import "fmt"
func main() {
fmt.Println("Hello World")
}
fn main() {
println!("Hello World");
}
Rust 输出文字的方式主要有两种：println!() 和 **print!()**。这两个"函数"都是向命令行输出字符串的方法，区别仅在于前者会在输出的最后附加输出一个换行符。当用这两个"函数"输出信息的时候，第一个参数是格式字符串，后面是一串可变参数，对应着格式字符串中的"占位符"，这一点与 C 语言/ Go语言 中的 printf 函数很相似。但是，Rust 中格式字符串中的占位符不是"% + 字母"的形式，而是一对 {}。
2. Print Hello 10 times
打印10次Hello World
package main
import (
"fmt"
)
func main() {
for i := 0; i < 10; i++ {
fmt.Println("Hello")
}
}
or
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Print(strings.Repeat("Hello\n", 10))
}
fn main() {
for _ in 0..10 {
println!("Hello");
}
}
or
fn main() {
print!("{}", "Hello\n".repeat(10));
}
3. Create a procedure
Like a function which doesn't return any value, thus has only side effects (e.g. Print to standard output)
创建一个方法，没有返回值，打印一些内容
package main
import "fmt"
func finish(name string) {
fmt.Println("My job here is done. Good bye " + name)
}
func main() {
finish("Tony")
}
fn main(){
finish("Buddy")
}
fn finish(name : &str) {
println!("My job here is done. Goodbye {}", name);
}
4. Create a function which returns the square of an integer
创建一个函数,返回一个整数的平方
func square(x int) int {
return x*x
}
fn square(x: u32) -> u32 {
x * x
}
fn main() {
let sq = square(9);
println!("{}", sq);
}
5. Create a 2D Point data structure
Declare a container type for two floating-point numbers x and y
声明一个容器类型,有x、y两个浮点数
package main
import "fmt"
type Point struct {
x, y float64
}
func main() {
p1 := Point{}
p2 := Point{2.1, 2.2}
p3 := Point{
y: 3.1,
x: 3.2,
}
p4 := &Point{
x: 4.1,
y: 4.2,
}
fmt.Println(p1)
fmt.Println(p2)
fmt.Println(p3)
fmt.Println(p4)
}
输出
{0 0}
{2.1 2.2}
{3.2 3.1}
&{4.1 4.2}
use std::fmt;
struct Point {
x: f64,
y: f64,
}
impl fmt::Display for Point {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "({}, {})", self.x, self.y)
}
}
fn main() {
let p = Point { x: 2.0, y: -3.5 };
println!("{}", p);
}
or
use std::fmt;
struct Point(f64, f64);
impl fmt::Display for Point {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "({}, {})", self.0, self.1)
}
}
fn main() {
let p = Point(2.0, -3.5);
println!("{}", p);
}
6. Iterate over list values
Do something with each item x of an array-like collection items, regardless indexes.
遍历列表的值
for _, x := range items {
doSomething(x)
}
package main
import (
"fmt"
)
func main() {
items := []int{11, 22, 33}
for _, x := range items {
doSomething(x)
}
}
func doSomething(i int) {
fmt.Println(i)
}
输出
11
22
33
fn main() {
let items = vec![11, 22, 33];
for x in items {
do_something(x);
}
}
fn do_something(n: i64) {
println!("Number {}", n)
}
or
fn main() {
let items = vec![11, 22, 33];
items.into_iter().for_each(|x| do_something(x));
}
fn do_something(n: i64) {
println!("Number {}", n)
}
7. Iterate over list indexes and values
遍历列表的索引和值
package main
import "fmt"
func main() {
items := []string{
"oranges",
"apples",
"bananas",
}
for i, x := range items {
fmt.Printf("Item %d = %v \n", i, x)
}
}
输出
Item 0 = oranges
Item 1 = apples
Item 2 = bananas
fn main() {
let items = ["a", "b", "c"];
for (i, x) in items.iter().enumerate() {
println!("Item {} = {}", i, x);
}
}
or
fn main() {
let items = ["a", "b", "c"];
items.iter().enumerate().for_each(|(i, x)| {
println!("Item {} = {}", i, x);
});
}
8. Initialize a new map (associative array)
Create a new map object x, and provide some (key, value) pairs as initial content.
创建一个新的map,提供一些键值对 作为初始内容
package main
import "fmt"
func main() {
x := map[string]int{"one": 1, "two": 2}
fmt.Println(x)
}
输出
map[one:1 two:2]
use std::collections::BTreeMap;
fn main() {
let mut x = BTreeMap::new();
x.insert("one", 1);
x.insert("two", 2);
println!("{:?}", x);
}
输出为：
("one", 1)
("two", 2)
or
use std::collections::HashMap;
fn main() {
let x: HashMap<&str, i32> = [
("one", 1),
("two", 2),
].iter().cloned().collect();
println!("{:?}", x);
}
输出为：
("two", 2)
("one", 1)
分 BTreeMap 和 HashMap，且都需要use进来； 前者无序，后者有序
9. Create a Binary Tree data structure
The structure must be recursive because left child and right child are binary trees too. A node has access to children nodes, but not to its parent.
创建一个二叉树
type BinTree struct {
Value valueType
Left *BinTree
Right *BinTree
}
package main
import "fmt"
type BinTree struct {
Value int
Left *BinTree
Right *BinTree
}
func inorder(root *BinTree) {
if root == nil {
return
}
inorder(root.Left)
fmt.Printf("%d ", root.Value)
inorder(root.Right)
}
func main() {
root := &BinTree{1, nil, nil}
root.Left = &BinTree{2, nil, nil}
root.Right = &BinTree{3, nil, nil}
root.Left.Left = &BinTree{4, nil, nil}
root.Left.Right = &BinTree{5, nil, nil}
root.Right.Right = &BinTree{6, nil, nil}
root.Left.Left.Left = &BinTree{7, nil, nil}
inorder(root)
}
输出
7 4 2 5 1 3 6
struct BinTree {
value: T,
left: Option<Box>>,
right: Option<Box>>,
}
10. Shuffle a list
Generate a random permutation of the elements of list x
随机排序一个list
package main
import (
"fmt"
"math/rand"
)
func main() {
x := []string{"a", "b", "c", "d", "e", "f", "g", "h"}
for i := range x {
j := rand.Intn(i + 1)
x[i], x[j] = x[j], x[i]
}
fmt.Println(x)
}
输出
[f e c g h a d b]
or
package main
import (
"fmt"
"math/rand"
)
func main() {
x := []string{"a", "b", "c", "d", "e", "f", "g", "h"}
y := make([]string, len(x))
perm := rand.Perm(len(x))
for i, v := range perm {
y[v] = x[i]
}
fmt.Println(y)
}
输出
[f h c g b a d e]
rand.Perm(x)挺有意思的一个函数，perm应该是permutation的缩写，即置换，排列。
会输出一个从0-(x-1)随机顺序排列的数组，类似洗牌，总数不变，打乱顺序
or
package main
import (
"fmt"
"math/rand"
)
func main() {
x := []string{"a", "b", "c", "d", "e", "f", "g", "h"}
rand.Shuffle(len(x), func(i, j int) {
x[i], x[j] = x[j], x[i]
})
fmt.Println(x)
}
输出
[f a h b c d g e]
or
package main
import (
"fmt"
"math/rand"
)
func main() {
x := []string{"a", "b", "c", "d", "e", "f", "g", "h"}
for i := len(x) - 1; i > 0; i-- {
j := rand.Intn(i + 1)
x[i], x[j] = x[j], x[i]
}
fmt.Println(x)
}
输出
[g d a h e f c b]
extern crate rand;
use rand::{Rng, StdRng};
let mut rng = StdRng::new().unwrap();
rng.shuffle(&mut x);
or
use rand::seq::SliceRandom;
use rand::thread_rng;
fn main() {
let mut x = [1, 2, 3, 4, 5];
println!("Unshuffled: {:?}", x);
let mut rng = thread_rng();
x.shuffle(&mut rng);
println!("Shuffled: {:?}", x);
}
11. Pick a random element from a list
从列表中选择一个随机元素
package main
import (
"fmt"
"math/rand"
)
var x = []string{"bleen", "fuligin", "garrow", "grue", "hooloovoo"}
func main() {
fmt.Println(x[rand.Intn(len(x))])
}
输出
fuligin
or
package main
import (
"fmt"
"math/rand"
)
type T string
func pickT(x []T) T {
return x[rand.Intn(len(x))]
}
func main() {
var list = []T{"bleen", "fuligin", "garrow", "grue", "hooloovoo"}
fmt.Println(pickT(list))
}
输出
fuligin
use rand::{self, Rng};
fn main() {
let x = vec![11, 22, 33];
let choice = x[rand::thread_rng().gen_range(0..x.len())];
println!("I picked {}!", choice);
}
or
use rand::seq::SliceRandom;
fn main() {
let x = vec![11, 22, 33];
let mut rng = rand::thread_rng();
let choice = x.choose(&mut rng).unwrap();
println!("I picked {}!", choice);
}
12. Check if list contains a value
Check if list contains a value x. list is an iterable finite container.
检查列表中是否包含一个值
package main
import "fmt"
func Contains(list []T, x T) bool {
for _, item := range list {
if item == x {
return true
}
}
return false
}
type T string
func main() {
list := []T{"a", "b", "c"}
fmt.Println(Contains(list, "b"))
fmt.Println(Contains(list, "z"))
}
输出
true
false
fn main() {
let list = [10, 40, 30];
{
let num = 30;
if list.contains(&num) {
println!("{:?} contains {}", list, num);
} else {
println!("{:?} doesn't contain {}", list, num);
}
}
{
let num = 42;
if list.contains(&num) {
println!("{:?} contains {}", list, num);
} else {
println!("{:?} doesn't contain {}", list, num);
}
}
}
or
fn main() {
let list = [10, 40, 30];
let x = 30;
if list.iter().any(|v| v == &x) {
println!("{:?} contains {}", list, x);
} else {
println!("{:?} doesn't contain {}", list, x);
}
}
or
fn main() {
let list = [10, 40, 30];
let x = 30;
if (&list).into_iter().any(|v| v == &x) {
println!("{:?} contains {}", list, x);
} else {
println!("{:?} doesn't contain {}", list, x);
}
}
13. Iterate over map keys and values
Access each key k with its value x from an associative array mymap, and print them
遍历关联数组中的每一对 k-v， 并打印出它们
package main
import "fmt"
func main() {
mymap := map[string]int{
"one": 1,
"two": 2,
"three": 3,
"four": 4,
}
for k, x := range mymap {
fmt.Println("Key =", k, ", Value =", x)
}
}
输出
Key = two , Value = 2
Key = three , Value = 3
Key = four , Value = 4
Key = one , Value = 1
use std::collections::BTreeMap;
fn main() {
let mut mymap = BTreeMap::new();
mymap.insert("one", 1);
mymap.insert("two", 2);
mymap.insert("three", 3);
mymap.insert("four", 4);
for (k, x) in &mymap {
println!("Key={key}, Value={val}", key = k, val = x);
}
}
14. Pick uniformly a random floating point number in [a..b)
Pick a random number greater than or equals to a, strictly inferior to b. Precondition : a < b.
选出一个随机的浮点数，大于或等于a，严格小于b，且a< b
package main
import (
"fmt"
"math/rand"
)
func main() {
x := pick(-2.0, 6.5)
fmt.Println(x)
}
func pick(a, b float64) float64 {
return a + (rand.Float64() * (b - a))
}
输出
3.1396124478267664
extern crate rand;
use rand::{thread_rng, Rng};
fn main() {
let (a, b) = (1.0, 3.0);
let c = thread_rng().gen_range(a..b);
println!("{}", c);
}
15. Pick uniformly a random integer in [a..b]
Pick a random integer greater than or equals to a, inferior or equals to b. Precondition : a < b.
选出一个随机的整数，大于或等于a，小于或等于b，且a< b
package main
import (
"fmt"
"math/rand"
)
func main() {
x := pick(3, 7)
// Note that in the Go Playground, time and random don't change very often.
fmt.Println(x)
}
func pick(a, b int) int {
return a + rand.Intn(b-a+1)
}
输出
4
fn pick(a: i32, b: i32) -> i32 {
let between = Range::new(a, b);
let mut rng = rand::thread_rng();
between.ind_sample(&mut rng)
}
or
use rand::distributions::Distribution;
use rand::distributions::Uniform;
fn main() {
let (a, b) = (3, 5);
let x = Uniform::new_inclusive(a, b).sample(&mut rand::thread_rng());
println!("{}", x);
}
17. Create a Tree data structure
The structure must be recursive. A node may have zero or more children. A node has access to children nodes, but not to its parent.
创建树数据结构, 该结构必须是递归的。一个节点可以有零个或多个子节点,节点可以访问子节点，但不能访问其父节点
type Tree struct {
Key keyType
Deco valueType
Children []*Tree
}
package main
import "fmt"
type Tree struct {
Key key
Deco value
Children []*Tree
}
type key string
type value string
func (t *Tree) String() string {
str := "("
str += string(t.Deco)
if len(t.Children) == 0 {
return str + ")"
}
str += " ("
for _, child := range t.Children {
str += child.String()
}
str += "))"
return str
}
func (this *Tree) AddChild(x key, v value) *Tree {
child := &Tree{Key: x, Deco: v}
this.Children = append(this.Children, child)
return child
}
func main() {
tree := &Tree{Key: "Granpa", Deco: "Abraham"}
subtree := tree.AddChild("Dad", "Homer")
subtree.AddChild("Kid 1", "Bart")
subtree.AddChild("Kid 2", "Lisa")
subtree.AddChild("Kid 3", "Maggie")
fmt.Println(tree)
}
输出
(Abraham ((Homer ((Bart)(Lisa)(Maggie)))))
use std::vec;
struct Node {
value: T,
children: Vec>,
}
impl Node {
pub fn dfsFn(&T)>(&self, f: F) {
self.dfs_helper(&f);
}
fn dfs_helperFn(&T)>(&self, f: &F) {
(f)(&self.value);
for child in &self.children {
child.dfs_helper(f);
}
}
}
fn main() {
let t: Node<i32> = Node {
children: vec![
Node {
children: vec![
Node {
children: vec![],
value: 14
}
],
value: 28
},
Node {
children: vec![],
value: 80
}
],
value: 50
};
t.dfs(|node| { println!("{}", node); });
}
输出：
50
28
14
80
18. Depth-first traversing of a tree
Call a function f on every node of a tree, in depth-first prefix order
树的深度优先遍历。按照深度优先的前缀顺序，在树的每个节点上调用函数f
package main
import . "fmt"
func (t *Tree) Dfs(f func(*Tree)) {
if t == nil {
return
}
f(t)
for _, child := range t.Children {
child.Dfs(f)
}
}
type key string
type value string
type Tree struct {
Key key
Deco value
Children []*Tree
}
func (this *Tree) AddChild(x key, v value) {
child := &Tree{Key: x, Deco: v}
this.Children = append(this.Children, child)
}
func NodePrint(node *Tree) {
Printf("%v (%v)\n", node.Deco, node.Key)
}
func main() {
tree := &Tree{Key: "Granpa", Deco: "Abraham"}
tree.AddChild("Dad", "Homer")
tree.Children[0].AddChild("Kid 1", "Bart")
tree.Children[0].AddChild("Kid 2", "Lisa")
tree.Children[0].AddChild("Kid 3", "Maggie")
tree.Dfs(NodePrint)
}
输出
Abraham (Granpa)
Homer (Dad)
Bart (Kid 1)
Lisa (Kid 2)
Maggie (Kid 3)
use std::vec;
struct Tree {
children: Vec>,
value: T
}
impl Tree {
pub fn new(value: T) -> Self{
Tree{
children: vec![],
value
}
}
pub fn dfsFn(&T)>(&self, f: F) {
self.dfs_helper(&f);
}
fn dfs_helperFn(&T)>(&self, f: &F) {
(f)(&self.value);
for child in &self.children {
child.dfs_helper(f);
}
}
}
fn main() {
let t: Tree<i32> = Tree {
children: vec![
Tree {
children: vec![
Tree {
children: vec![],
value: 14
}
],
value: 28
},
Tree {
children: vec![],
value: 80
}
],
value: 50
};
t.dfs(|node| { println!("{}", node); });
}
输出：
50
28
14
80
19. Reverse a list
Reverse the order of the elements of list x. This may reverse "in-place" and destroy the original ordering.
反转链表
package main
import "fmt"
func main() {
s := []int{5, 2, 6, 3, 1, 4}
for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
s[i], s[j] = s[j], s[i]
}
fmt.Println(s)
}
输出
[4 1 3 6 2 5]
fn main() {
let x = vec!["Hello", "World"];
let y: Vec<_> = x.iter().rev().collect();
println!("{:?}", y);
}
输出：
["World", "Hello"]
or
fn main() {
let mut x = vec![1,2,3];
x.reverse();
println!("{:?}", x);
}
输出:
[3, 2, 1]
20. Return two values
Implement a function search which looks for item x in a 2D matrix m. Return indices i, j of the matching cell. Think of the most idiomatic way in the language to return the two values at the same time.
实现在2D矩阵m中寻找元素x，返回匹配单元格的索引 i，j
package main
import "fmt"
func search(m [][]int, x int) (bool, int, int) {
for i := range m {
for j, v := range m[i] {
if v == x {
return true, i, j
}
}
}
return false, 0, 0
}
func main() {
matrix := [][]int{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9},
}
for x := 1; x <= 11; x += 2 {
found, i, j := search(matrix, x)
if found {
fmt.Printf("matrix[%v][%v] == %v \n", i, j, x)
} else {
fmt.Printf("Value %v not found. \n", x)
}
}
}
输出
matrix[0][0] == 1
matrix[0][2] == 3
matrix[1][1] == 5
matrix[2][0] == 7
matrix[2][2] == 9
Value 11 not found.
fn searchEq>(m: &Vec<Vec>, x: &T) -> Option<(usize, usize)> {
for (i, row) in m.iter().enumerate() {
for (j, column) in row.iter().enumerate() {
if *column == *x {
return Some((i, j));
}
}
}
None
}
fn main() {
let a = vec![
vec![0, 11],
vec![22, 33],
vec![44, 55],
];
let hit = search(&a, &33);
println!("{:?}", hit);
}
输出：
Some((1, 1))
本文由 mdnice 多平台发布