Rust vs Go:常用语法对比(13)

241. Yield priority to other threads

Explicitly decrease the priority of the current process, so that other execution threads have a better chance to execute now. Then resume normal execution and call function busywork.

将优先权让给其他线程

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	go fmt.Println("aaa")
	go fmt.Println("bbb")
	go fmt.Println("ccc")
	go fmt.Println("ddd")
	go fmt.Println("eee")

	runtime.Gosched()
	busywork()

	time.Sleep(100 * time.Millisecond)
}

func busywork() {
	fmt.Println("main")
}

After Gosched, the execution of the current goroutine resumes automatically.

aaa
eee
ccc
bbb
ddd
main

---

::std::thread::yield_now();
busywork();

242. Iterate over a set

Call a function f on each element e of a set x.

迭代一个集合

package main

import "fmt"

type T string

func main() {
	// declare a Set (implemented as a map)
	x := make(map[T]bool)

	// add some elements
	x["A"] = true
	x["B"] = true
	x["B"] = true
	x["C"] = true
	x["D"] = true

	// remove an element
	delete(x, "C")

	for e := range x {
		f(e)
	}
}

func f(e T) {
	fmt.Printf("contains element %v \n", e)
}

contains element A 
contains element B 
contains element D 

---

use std::collections::HashSet;

fn main() {
    let mut x = HashSet::new();
    x.insert("a");
    x.insert("b");

    for item in &x {
        f(item);
    }
}

fn f(s: &&str) {
    println!("Element {}", s);
}

x is a HashSet

Element a
Element b

243. Print list

Print the contents of list a on the standard output.

打印 list

package main

import (
	"fmt"
)

func main() {
	{
		a := []int{11, 22, 33}
		fmt.Println(a)
	}

	{
		a := []string{"aa", "bb"}
		fmt.Println(a)
	}

	{
		type Person struct {
			First string
			Last  string
		}
		x := Person{
			First: "Jane",
			Last:  "Doe",
		}
		y := Person{
			First: "John",
			Last:  "Doe",
		}
		a := []Person{x, y}
		fmt.Println(a)
	}

	{
		x, y := 11, 22
		a := []*int{&x, &y}
		fmt.Println(a)
	}
}

[11 22 33]
[aa bb]
[{Jane Doe} {John Doe}]
[0xc000018080 0xc000018088]

---

fn main() {
    let a = [11, 22, 33];

    println!("{:?}", a);
}

[11, 22, 33]

244. Print map

Print the contents of map m to the standard output: keys and values.

打印 map

package main

import (
	"fmt"
)

func main() {
	{
		m := map[string]int{
			"eleven":     11,
			"twenty-two": 22,
		}
		fmt.Println(m)
	}

	{
		x, y := 7, 8
		m := map[string]*int{
			"seven": &x,
			"eight": &y,
		}
		fmt.Println(m)
	}
}

map[eleven:11 twenty-two:22]
map[eight:0xc000100040 seven:0xc000100028]

---

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("Áron".to_string(), 23);
    m.insert("Béla".to_string(), 35);
    println!("{:?}", m);
}

{"Béla": 35, "Áron": 23}

245. Print value of custom type

Print the value of object x having custom type T, for log or debug.

打印自定义类型的值

package main

import (
	"fmt"
)

// T represents a tank. It doesn't implement fmt.Stringer.
type T struct {
	name      string
	weight    int
	firePower int
}

// Person implement fmt.Stringer.
type Person struct {
	FirstName   string
	LastName    string
	YearOfBirth int
}

func (p Person) String() string {
	return fmt.Sprintf("%s %s, born %d", p.FirstName, p.LastName, p.YearOfBirth)
}

func main() {
	{
		x := T{
			name:      "myTank",
			weight:    100,
			firePower: 90,
		}

		fmt.Println(x)
	}
	{
		x := Person{
			FirstName:   "John",
			LastName:    "Doe",
			YearOfBirth: 1958,
		}

		fmt.Println(x)
	}
}

Will be more relevant if T implements fmt.Stringer

{myTank 100 90}
John Doe, born 1958

---

#[derive(Debug)]

// T represents a tank
struct T<'a> {
    name: &'a str,
    weight: &'a i32,
    fire_power: &'a i32,
}

fn main() {
    let x = T {
        name: "mytank",
        weight: &100,
        fire_power: &90,
    };

    println!("{:?}", x);
}

Implement fmt::Debug or fmt::Display for T

T { name: "mytank", weight: 100, fire_power: 90 }

246. Count distinct elements

Set c to the number of distinct elements in list items.

计算不同的元素的数量

package main

import (
	"fmt"
)

func main() {
	type T string
	items := []T{"a", "b", "b", "aaa", "c", "a", "d"}
	fmt.Println("items has", len(items), "elements")

	distinct := make(map[T]bool)
	for _, v := range items {
		distinct[v] = true
	}
	c := len(distinct)

	fmt.Println("items has", c, "distinct elements")
}

items has 7 elements
items has 5 distinct elements

---

use itertools::Itertools;

fn main() {
    let items = vec!["víz", "árvíz", "víz", "víz", "ár", "árvíz"];
    let c = items.iter().unique().count();
    println!("{}", c);
}

3

247. Filter list in-place

Remove all the elements from list x that don’t satisfy the predicate p, without allocating a new list.
Keep all the elements that do satisfy p.
For languages that don’t have mutable lists, refer to idiom #57 instead.

就地筛选列表

package main

import "fmt"

type T int

func main() {
	x := []T{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	p := func(t T) bool { return t%2 == 0 }

	j := 0
	for i, v := range x {
		if p(v) {
			x[j] = x[i]
			j++
		}
	}
	x = x[:j]

	fmt.Println(x)
}

[2 4 6 8 10]

or

package main

import "fmt"

type T int

func main() {
	var x []*T
	for _, v := range []T{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} {
		t := new(T)
		*t = v
		x = append(x, t)
	}
	p := func(t *T) bool { return *t%2 == 0 }

	j := 0
	for i, v := range x {
		if p(v) {
			x[j] = x[i]
			j++
		}
	}
	for k := j; k < len(x); k++ {
		x[k] = nil
	}
	x = x[:j]

	for _, pt := range x {
		fmt.Print(*pt, " ")
	}
}

2 4 6 8 10

---

fn p(t: i32) -> bool {
    t % 2 == 0
}

fn main() {
    let mut x = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let mut j = 0;
    for i in 0..x.len() {
        if p(x[i]) {
            x[j] = x[i];
            j += 1;
        }
    }
    x.truncate(j);
    println!("{:?}", x);
}

[2, 4, 6, 8, 10]

or

fn p(t: &i64) -> bool {
    t % 2 == 0
}

fn main() {
    let mut x: Vec<i64> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    x.retain(p);

    println!("{:?}", x);
}

[2, 4, 6, 8, 10]

249. Declare and assign multiple variables

Define variables a, b and c in a concise way.
Explain if they need to have the same type.

声明并分配多个变量

package main

import (
	"fmt"
)

func main() {
	// a, b and c don't need to have the same type.

	a, b, c := 42, "hello", 5.0

	fmt.Println(a, b, c)
	fmt.Printf("%T %T %T \n", a, b, c)
}

42 hello 5
int string float64 

---

fn main() {
    // a, b and c don't need to have the same type.

    let (a, b, c) = (42, "hello", 5.0);

    println!("{} {} {}", a, b, c);
}

42 hello 5

251. Parse binary digits

Extract integer value i from its binary string representation s (in radix 2)
E.g. “1101” -> 13

解析二进制数字

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	s := "1101"
	fmt.Println("s is", reflect.TypeOf(s), s)

	i, err := strconv.ParseInt(s, 2, 0)
	if err != nil {
		panic(err)
	}

	fmt.Println("i is", reflect.TypeOf(i), i)
}

s is string 1101
i is int64 13

---

fn main() {
    let s = "1101"; // binary digits
    
    let i = i32::from_str_radix(s, 2).expect("Not a binary number!");
    
    println!("{}", i);
}

13

252. Conditional assignment

Assign to variable x the value “a” if calling the function condition returns true, or the value “b” otherwise.

条件赋值

package main

import (
	"fmt"
)

func main() {
	var x string
	if condition() {
		x = "a"
	} else {
		x = "b"
	}

	fmt.Println(x)
}

func condition() bool {
	return "Socrates" == "dog"
}

b

---

x = if condition() { "a" } else { "b" };

258. Convert list of strings to list of integers

Convert the string values from list a into a list of integers b.

将字符串列表转换为整数列表

package main

import (
	"fmt"
	"strconv"
)

func main() {
	a := []string{"11", "22", "33"}

	b := make([]int, len(a))
	var err error
	for i, s := range a {
		b[i], err = strconv.Atoi(s)
		if err != nil {
			panic(err)
		}
	}

	fmt.Println(b)
}

[11 22 33]

---

fn main() {
    let a: Vec<&str> = vec!["11", "-22", "33"];

    let b: Vec<i64> = a.iter().map(|x| x.parse::<i64>().unwrap()).collect();

    println!("{:?}", b);
}

[11, -22, 33]

259. Split on several separators

Build list parts consisting of substrings of input string s, separated by any of the characters ‘,’ (comma), ‘-‘ (dash), ‘_’ (underscore).

在几个分隔符上拆分

package main

import (
	"fmt"
	"regexp"
)

func main() {
	s := "2021-03-11,linux_amd64"

	re := regexp.MustCompile("[,\\-_]")
	parts := re.Split(s, -1)
	
	fmt.Printf("%q", parts)
}

["2021" "03" "11" "linux" "amd64"]

---

fn main() {
    let s = "2021-03-11,linux_amd64";

    let parts: Vec<_> = s.split(&[',', '-', '_'][..]).collect();

    println!("{:?}", parts);
}

["2021", "03", "11", "linux", "amd64"]

266. Repeating string

Assign to string s the value of string v, repeated n times and write it out.
E.g. v=”abc”, n=5 ⇒ s=”abcabcabcabcabc”

重复字符串

package main

import (
	"fmt"
	"strings"
)

func main() {
	v := "abc"
	n := 5

	s := strings.Repeat(v, n)

	fmt.Println(s)
}

abcabcabcabcabc

---

fn main() {
    let v = "abc";
    let n = 5;

    let s = v.repeat(n);
    println!("{}", s);
}

abcabcabcabcabc

文章目录

1. 241. Yield priority to other threads
2. 242. Iterate over a set
3. 243. Print list
4. 244. Print map
5. 245. Print value of custom type
6. 246. Count distinct elements
7. 247. Filter list in-place
8. 249. Declare and assign multiple variables
9. 251. Parse binary digits
10. 252. Conditional assignment
11. 258. Convert list of strings to list of integers
12. 259. Split on several separators
13. 266. Repeating string

原文链接: https://dashen.tech/2021/09/14/Rust-vs-Go-常用语法对比-13/

版权声明: 转载请注明出处.