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

留言

121. UDP listen and read

Listen UDP traffic on port p and read 1024 bytes into buffer b.

听端口p上的UDP流量，并将1024字节读入缓冲区b。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import (
    "fmt"
    "net"
    "os"
)
ServerAddr,err := net.ResolveUDPAddr("udp",p)
if err != nil {
	return err
}
ServerConn, err := net.ListenUDP("udp", ServerAddr)
if err != nil {
	return err
}
defer ServerConn.Close()
n,addr,err := ServerConn.ReadFromUDP(b[:1024])
if err != nil {
	return err
}
if n<1024 {
	return fmt.Errorf("Only %d bytes could be read.", n)
}
1
2
3
4
use std::net::UdpSocket;
let mut b = [0 as u8; 1024];
let sock = UdpSocket::bind(("localhost", p)).unwrap();
sock.recv_from(&mut b).unwrap();

122. Declare enumeration

Create an enumerated type Suit with 4 possible values SPADES, HEARTS, DIAMONDS, CLUBS.

声明枚举值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import (
	"fmt"
)

type Suit int

const (
  Spades Suit = iota
  Hearts
  Diamonds
  Clubs
)

func main() {
	fmt.Printf("Hearts has type %T and value %d", Hearts, Hearts)
}

Hearts has type main.Suit and value 1

1
2
3
4
5
6
7
8
9
10
enum Suit {
    Spades,
    Hearts,
    Diamonds,
    Clubs,
}

fn main() {
    let _x = Suit::Diamonds;
}

123. Assert condition

Verify that predicate isConsistent returns true, otherwise report assertion violation.
Explain if the assertion is executed even in production environment or not.

断言条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main

import "fmt"

//
// The code may look fine, but
// obviously we have a bug.
//

func main() {
	salary = 65000
	employees = 120000
	totalPayroll = salary * employees

	if !isConsistent() {
		panic("State consistency violated")
	}
	fmt.Println("Everything fine")
}

var salary int32
var employees int32
var totalPayroll int32

func isConsistent() bool {
	return salary >= 0 &&
		employees >= 0 &&
		totalPayroll >= 0
}
1
2
3
4
5
6
7
8
9
10
11
fn main() {
    // i is odd
    let i = 23687;
    let ii = i * i;
    let is_consistent = ii % 2 == 1;

    // i*i must be odd
    assert!(is_consistent);

    println!("Cool.")
}

Cool.


124. Binary search for a value in sorted array

Write function binarySearch which returns the index of an element having value x in sorted array a, or -1 if no such element.

排序数组中值的二分搜索法

二分查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main

import "fmt"

func binarySearch(a []T, x T) int {
	imin, imax := 0, len(a)-1
	for imin <= imax {
		imid := (imin + imax) / 2
		switch {
		case a[imid] == x:
			return imid
		case a[imid] < x:
			imin = imid + 1
		default:
			imax = imid - 1
		}
	}
	return -1
}

type T int

func main() {
	a := []T{-2, -1, 0, 1, 1, 1, 6, 8, 8, 9, 10}
	for x := T(-5); x <= 15; x++ {
		i := binarySearch(a, x)
		if i == -1 {
			fmt.Println("Value", x, "not found")
		} else {
			fmt.Println("Value", x, "found at index", i)
		}
	}
}

or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import (
	"fmt"
	"sort"
)

func binarySearch(a []int, x int) int {
	i := sort.SearchInts(a, x)
	if i < len(a) && a[i] == x {
		return i
	}
	return -1
}

func main() {
	a := []int{-2, -1, 0, 1, 1, 1, 6, 8, 8, 9, 10}
	for x := -5; x <= 15; x++ {
		i := binarySearch(a, x)
		if i == -1 {
			fmt.Println("Value", x, "not found")
		} else {
			fmt.Println("Value", x, "found at index", i)
		}
	}
}

or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package main

import (
	"fmt"
	"sort"
)

func binarySearch(a []T, x T) int {
	f := func(i int) bool { return a[i] >= x }
	i := sort.Search(len(a), f)
	if i < len(a) && a[i] == x {
		return i
	}
	return -1
}

type T int

func main() {
	a := []T{-2, -1, 0, 1, 1, 1, 6, 8, 8, 9, 10}
	for x := T(-5); x <= 15; x++ {
		i := binarySearch(a, x)
		if i == -1 {
			fmt.Println("Value", x, "not found")
		} else {
			fmt.Println("Value", x, "found at index", i)
		}
	}
}

1


125. Measure function call duration

measure the duration t, in nano seconds, of a call to the function foo. Print this duration.

函数调用时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import (
	"fmt"
	"time"
)

func main() {
	t1 := time.Now()
	foo()
	t := time.Since(t1)
	ns := int64(t / time.Nanosecond)

	// Note that the clock is fixed in the Playground, so the resulting duration is always zero
	fmt.Printf("%dns\n", ns)
}

func foo() {
	fmt.Println("Hello")
}

1
2
Hello
0ns

or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
	"fmt"
	"time"
)

func main() {
	t1 := time.Now()
	foo()
	t := time.Since(t1)
	ns := t.Nanoseconds()
	fmt.Printf("%dns\n", ns)
}

func foo() {
	fmt.Println("Hello")
}
1
2
Hello
0ns
1
2
3
4
5
use std::time::{Duration, Instant};
let start = Instant::now();
foo();
let duration = start.elapsed();
println!("{}", duration);

126. Multiple return values

Write a function foo that returns a string and a boolean value.

多个返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	"fmt"
)

func main() {
	s, b := foo()
	fmt.Println(s, b)
}

func foo() (string, bool) {
	return "Too good to be", true
}

Too good to be true

1
2
3
4
5
6
7
fn foo() -> (String, bool) {
    (String::from("bar"), true)
}

fn main() {
    println!("{:?}", foo());
}

("bar", true)


128. Breadth-first traversing of a tree

Call a function f on every node of a tree, in breadth-first prefix order

树的广度优先遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package main

import "fmt"

func (root *Tree) Bfs(f func(*Tree)) {
	if root == nil {
		return
	}
	queue := []*Tree{root}
	for len(queue) > 0 {
		t := queue[0]
		queue = queue[1:]
		f(t)
		queue = append(queue, t.Children...)
	}
}

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) {
	fmt.Printf("%v (%v)\n", node.Key, node.Deco)
}

func main() {
	tree := &Tree{Key: "World", Deco: "Our planet"}
	tree.AddChild("Europe", "A continent")
	tree.Children[0].AddChild("Germany", "A country")
	tree.Children[0].AddChild("Ireland", "A country")
	tree.Children[0].AddChild("Mediterranean Sea", "A sea")
	tree.AddChild("Asia", "A continent")
	tree.Children[0].AddChild("Japan", "A country")
	tree.Children[0].AddChild("Thailand", "A country")

	tree.Bfs(NodePrint)
}

1
2
3
4
5
6
7
8
World (Our planet)
Europe (A continent)
Asia (A continent)
Germany (A country)
Ireland (A country)
Mediterranean Sea (A sea)
Japan (A country)
Thailand (A country)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
use std::collections::VecDeque;

struct Tree<V> {
    children: Vec<Tree<V>>,
    value: V
}

impl<V> Tree<V> {
    fn bfs(&self, f: impl Fn(&V)) {
        let mut q = VecDeque::new();
        q.push_back(self);

        while let Some(t) = q.pop_front() {
            (f)(&t.value);
            for child in &t.children {
                q.push_back(child);
            }
        }
    }
}

fn main() {
    let t = Tree {
        children: vec![
            Tree {
                children: vec![
                    Tree { children: vec![], value: 5 },
                    Tree { children: vec![], value: 6 }
                ],
                value: 2
            },
            Tree { children: vec![], value: 3 },
            Tree { children: vec![], value: 4 },
        ],
        value: 1
    };
    t.bfs(|v| println!("{}", v));
}
1
2
3
4
5
6
1
2
3
4
5
6

129. Breadth-first traversing in a graph

Call a function f on every vertex accessible from vertex start, in breadth-first prefix order

图的广度优先遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package main

import "fmt"

func (start *Vertex) Bfs(f func(*Vertex)) {
	queue := []*Vertex{start}
	seen := map[*Vertex]bool{start: true}
	for len(queue) > 0 {
		v := queue[0]
		queue = queue[1:]
		f(v)
		for next, isEdge := range v.Neighbours {
			if isEdge && !seen[next] {
				queue = append(queue, next)
				seen[next] = true
			}
		}
	}
}

type Vertex struct {
	Id         int
	Label      string
	Neighbours map[*Vertex]bool
}

type Graph []*Vertex

func NewVertex(id int, label string) *Vertex {
	return &Vertex{
		Id:         id,
		Label:      label,
		Neighbours: make(map[*Vertex]bool),
	}
}

func (v *Vertex) AddNeighbour(w *Vertex) {
	v.Neighbours[w] = true
}

func VertexPrint(v *Vertex) {
	fmt.Printf("%v (%v)\n", v.Id, v.Label)
}

func main() {
	// Some cities
	london := NewVertex(0, "London")
	ny := NewVertex(1, "New York City")
	berlin := NewVertex(2, "Berlin")
	paris := NewVertex(3, "Paris")
	tokyo := NewVertex(4, "Tokyo")

	g := Graph{
		london,
		ny,
		berlin,
		paris,
		tokyo,
	}
	_ = g

	london.AddNeighbour(paris)
	london.AddNeighbour(ny)
	ny.AddNeighbour(london)
	ny.AddNeighbour(paris)
	ny.AddNeighbour(tokyo)
	tokyo.AddNeighbour(paris)
	paris.AddNeighbour(tokyo)
	paris.AddNeighbour(berlin)

	london.Bfs(VertexPrint)
}

1
2
3
4
5
0 (London)
3 (Paris)
1 (New York City)
2 (Berlin)
4 (Tokyo)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Vertex<V> {
    value: V,
    neighbours: Vec<Weak<RefCell<Vertex<V>>>>,
}

type RcVertex<V> = Rc<RefCell<Vertex<V>>>;

struct Graph<V> {
    vertices: Vec<RcVertex<V>>,
}

impl<V> Graph<V> {
    fn new() -> Self {
        Graph { vertices: vec![] }
    }
    
    fn new_vertex(&mut self, value: V) -> RcVertex<V> {
        self.add_vertex(Vertex { value, neighbours: Vec::new() })
    }
    
    fn add_vertex(&mut self, v: Vertex<V>) -> RcVertex<V> {
        let v = Rc::new(RefCell::new(v));
        self.vertices.push(Rc::clone(&v));
        v
    }
    
    fn add_edge(&mut self, v1: &RcVertex<V>, v2: &RcVertex<V>) {
        v1.borrow_mut().neighbours.push(Rc::downgrade(&v2));
        v2.borrow_mut().neighbours.push(Rc::downgrade(&v1));
    }

    fn bft(start: RcVertex<V>, f: impl Fn(&V)) {
        let mut q = vec![start];
        let mut i = 0;
        while i < q.len() {
            let v = Rc::clone(&q[i]);
            i += 1;
            (f)(&v.borrow().value);
            for n in &v.borrow().neighbours {
                let n = n.upgrade().expect("Invalid neighbour");
                if q.iter().all(|v| v.as_ptr() != n.as_ptr()) {
                    q.push(n);
                }
            }
        }
    }
}

fn main() {
    let mut g = Graph::new();
    
    let v1 = g.new_vertex(1);
    let v2 = g.new_vertex(2);
    let v3 = g.new_vertex(3);
    let v4 = g.new_vertex(4);
    let v5 = g.new_vertex(5);
    
    g.add_edge(&v1, &v2);
    g.add_edge(&v1, &v3);
    g.add_edge(&v1, &v4);
    g.add_edge(&v2, &v5);
    g.add_edge(&v3, &v4);
    g.add_edge(&v4, &v5);
    
    Graph::bft(v1, |v| println!("{}", v));
}
1
2
3
4
5
1
2
3
4
5

130. Depth-first traversing in a graph

Call a function f on every vertex accessible for vertex v, in depth-first prefix order

图的深度优先遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package main

import "fmt"

func (v *Vertex) Dfs(f func(*Vertex), seen map[*Vertex]bool) {
	seen[v] = true
	f(v)
	for next, isEdge := range v.Neighbours {
		if isEdge && !seen[next] {
			next.Dfs(f, seen)
		}
	}
}

type Vertex struct {
	Id         int
	Label      string
	Neighbours map[*Vertex]bool
}

type Graph []*Vertex

func NewVertex(id int, label string) *Vertex {
	return &Vertex{
		Id:         id,
		Label:      label,
		Neighbours: make(map[*Vertex]bool),
	}
}

func (v *Vertex) AddNeighbour(w *Vertex) {
	v.Neighbours[w] = true
}

func VertexPrint(v *Vertex) {
	fmt.Printf("%v (%v)\n", v.Id, v.Label)
}

func main() {
	// Some cities
	london := NewVertex(0, "London")
	ny := NewVertex(1, "New York City")
	berlin := NewVertex(2, "Berlin")
	paris := NewVertex(3, "Paris")
	tokyo := NewVertex(4, "Tokyo")

	g := Graph{
		london,
		ny,
		berlin,
		paris,
		tokyo,
	}
	_ = g

	london.AddNeighbour(paris)
	london.AddNeighbour(ny)
	ny.AddNeighbour(london)
	ny.AddNeighbour(paris)
	ny.AddNeighbour(tokyo)
	tokyo.AddNeighbour(paris)
	paris.AddNeighbour(tokyo)
	paris.AddNeighbour(berlin)

	alreadySeen := map[*Vertex]bool{}
	london.Dfs(VertexPrint, alreadySeen)
}

1
2
3
4
5
0 (London)
3 (Paris)
4 (Tokyo)
2 (Berlin)
1 (New York City)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Vertex<V> {
    value: V,
    neighbours: Vec<Weak<RefCell<Vertex<V>>>>,
}

type RcVertex<V> = Rc<RefCell<Vertex<V>>>;

struct Graph<V> {
    vertices: Vec<RcVertex<V>>,
}

impl<V> Graph<V> {
    fn new() -> Self {
        Graph { vertices: vec![] }
    }
    
    fn new_vertex(&mut self, value: V) -> RcVertex<V> {
        self.add_vertex(Vertex { value, neighbours: Vec::new() })
    }
    
    fn add_vertex(&mut self, v: Vertex<V>) -> RcVertex<V> {
        let v = Rc::new(RefCell::new(v));
        self.vertices.push(Rc::clone(&v));
        v
    }
    
    fn add_edge(&mut self, v1: &RcVertex<V>, v2: &RcVertex<V>) {
        v1.borrow_mut().neighbours.push(Rc::downgrade(&v2));
        v2.borrow_mut().neighbours.push(Rc::downgrade(&v1));
    }
    
    fn dft(start: RcVertex<V>, f: impl Fn(&V)) {
        let mut s = vec![];
        Self::dft_helper(start, &f, &mut s);
    }
    
    fn dft_helper(start: RcVertex<V>, f: &impl Fn(&V), s: &mut Vec<*const Vertex<V>>) {
        s.push(start.as_ptr());
        (f)(&start.borrow().value);
        for n in &start.borrow().neighbours {
            let n = n.upgrade().expect("Invalid neighbor");
            if s.iter().all(|&p| p != n.as_ptr()) {
                Self::dft_helper(n, f, s);
            }
        }
    }
}

fn main() {
    let mut g = Graph::new();
    
    let v1 = g.new_vertex(1);
    let v2 = g.new_vertex(2);
    let v3 = g.new_vertex(3);
    let v4 = g.new_vertex(4);
    let v5 = g.new_vertex(5);
    
    g.add_edge(&v1, &v2);
    g.add_edge(&v1, &v4);
    g.add_edge(&v1, &v5);
    g.add_edge(&v2, &v3);
    g.add_edge(&v3, &v4);
    g.add_edge(&v4, &v5);
    
    Graph::dft(v1, |v| println!("{}", v));
}
1
2
3
4
5
1
2
3
4
5

131. Successive conditions

Execute f1 if condition c1 is true, or else f2 if condition c2 is true, or else f3 if condition c3 is true.
Don’t evaluate a condition when a previous condition was true.

连续条件判等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package main

import (
	"fmt"
	"strings"
)

func conditional(x string) {
	switch {
	case c1(x):
		f1()
	case c2(x):
		f2()
	case c3(x):
		f3()
	}
}

func main() {
	conditional("dog Snoopy")
	conditional("fruit Raspberry")
}

func f1() {
	fmt.Println("I'm a Human")
}

func f2() {
	fmt.Println("I'm a Dog")
}

func f3() {
	fmt.Println("I'm a Fruit")
}

var c1, c2, c3 = prefixCheck("human"), prefixCheck("dog"), prefixCheck("fruit")

func prefixCheck(prefix string) func(string) bool {
	return func(x string) bool {
		return strings.HasPrefix(x, prefix)
	}
}
1
2
I'm a Dog
I'm a Fruit
1
if c1 { f1() } else if c2 { f2() } else if c3 { f3() }

or

1
2
3
4
5
6
match true {
    _ if c1 => f1(),
    _ if c2 => f2(),
    _ if c3 => f3(),
    _ => (),
}

132. Measure duration of procedure execution

Run procedure f, and return the duration of the execution of f.

度量程序执行时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main

import (
	"fmt"
	"regexp"
	"strings"
	"time"
)

func clock(f func()) time.Duration {
	t := time.Now()
	f()
	return time.Since(t)
}

func f() {
	re := regexp.MustCompilePOSIX("|A+{300}")
	re.FindAllString(strings.Repeat("A", 299), -1)
}

func main() {
	d := clock(f)

	// The result is always zero in the playground, which has a fixed clock!
	// Try it on your workstation instead.
	fmt.Println(d)
}

0s

1
2
3
4
use std::time::Instant;
let start = Instant::now();
f();
let duration = start.elapsed();

133. Case-insensitive string contains

Set boolean ok to true if string word is contained in string s as a substring, even if the case doesn’t match, or to false otherwise.

不区分大小写的字符串包含

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package main

import (
	"fmt"
	"strings"
)

// Package _strings has no case-insensitive version of _Contains, so
// we have to make our own.
func containsCaseInsensitive(s, word string) bool {
	lowerS, lowerWord := strings.ToLower(s), strings.ToLower(word)
	ok := strings.Contains(lowerS, lowerWord)
	return ok
}

func main() {
	s := "Let's dance the macarena"

	word := "Dance"
	ok := containsCaseInsensitive(s, word)
	fmt.Println(ok)

	word = "dance"
	ok = containsCaseInsensitive(s, word)
	fmt.Println(ok)

	word = "Duck"
	ok = containsCaseInsensitive(s, word)
	fmt.Println(ok)
}

1
2
3
true
true
false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
extern crate regex;
use regex::Regex;

fn main() {
    let s = "Let's dance the macarena";

    {
        let word = "Dance";
        let re = Regex::new(&format!("(?i){}", regex::escape(word))).unwrap();
        let ok = re.is_match(&s);

        println!("{}", ok);
    }
    
    {
        let word = "dance";
        let re = Regex::new(&format!("(?i){}", regex::escape(word))).unwrap();
        let ok = re.is_match(&s);

        println!("{}", ok);
    }
    
    {
        let word = "Duck";
        let re = Regex::new(&format!("(?i){}", regex::escape(word))).unwrap();
        let ok = re.is_match(&s);

        println!("{}", ok);
    }
}

1
2
3
true
true
false

or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
use regex::RegexBuilder;

fn main() {
    let s = "FooBar";
    let word = "foo";
    
    let re = RegexBuilder::new(&regex::escape(word))
        .case_insensitive(true)
        .build()
        .unwrap();

    let ok = re.is_match(s);
    
    println!("{:?}", ok);
}

true

or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
fn main() {
    let s = "Let's dance the macarena";

    {
        let word = "Dance";
        let ok = s.to_ascii_lowercase().contains(&word.to_ascii_lowercase());
        println!("{}", ok);
    }

    {
        let word = "dance";
        let ok = s.to_ascii_lowercase().contains(&word.to_ascii_lowercase());
        println!("{}", ok);
    }

    {
        let word = "Duck";
        let ok = s.to_ascii_lowercase().contains(&word.to_ascii_lowercase());
        println!("{}", ok);
    }
}
1
2
3
true
true
false

134. Create a new list

创建一个新list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
	"fmt"
)

func main() {
	var a, b, c T = "This", "is", "wonderful"

	items := []T{a, b, c}

	fmt.Println(items)
}

type T string

[This is wonderful]

1
2
3
4
5
6
7
fn main() {
    let (a, b, c) = (11, 22, 33);
    
    let items = vec![a, b, c];
    
    println!("{:?}", items);
}

[11, 22, 33]


135. Remove item from list, by its value

Remove at most 1 item from list items, having value x.
This will alter the original list or return a new list, depending on which is more idiomatic.
If there are several occurrences of x in items, remove only one of them. If x is absent, keep items unchanged.

移除列表中的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import (
	"fmt"
)

func main() {
	items := []string{"a", "b", "c", "d", "e", "f"}
	fmt.Println(items)

	x := "c"
	for i, y := range items {
		if y == x {
			items = append(items[:i], items[i+1:]...)
			break
		}
	}
	fmt.Println(items)
}

1
2
[a b c d e f]
[a b d e f]

or

1
2
3
4
5
6
7
8
for i, y := range items {
	if y == x {
		copy(items[i:], items[i+1:])
		items[len(items)-1] = nil
		items = items[:len(items)-1]
		break
	}
}
1
2
3
if let Some(i) = items.first(&x) {
    items.remove(i);
}

136. Remove all occurrences of a value from a list

Remove all occurrences of value x from list items.
This will alter the original list or return a new list, depending on which is more idiomatic.

从列表中删除所有出现的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
	"fmt"
)

func main() {
	items := []T{"b", "a", "b", "a", "r"}
	fmt.Println(items)

	var x T = "b"
	items2 := make([]T, 0, len(items))
	for _, v := range items {
		if v != x {
			items2 = append(items2, v)
		}
	}

	fmt.Println(items2)
}

type T string

1
2
[b a b a r]
[a a r]

or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import (
	"fmt"
)

func main() {
	items := []T{"b", "a", "b", "a", "r"}
	fmt.Println(items)

	x := T("b")
	j := 0
	for i, v := range items {
		if v != x {
			items[j] = items[i]
			j++
		}
	}
	items = items[:j]

	fmt.Println(items)
}

type T string

1
2
[b a b a r]
[a a r]

or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package main

import (
	"fmt"
	"runtime"
)

func main() {
	var items []*image
	{
		red := newUniform(rgb{0xFF, 0, 0})
		white := newUniform(rgb{0xFF, 0xFF, 0xFF})
		items = []*image{red, white, red} // Like the flag of Austria
		fmt.Println("items =", items)

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

	// At this point, red can be garbage collected

	printAllocInfo()

	fmt.Println("items =", items) // Not the original flag anymore...
	fmt.Println("items undelying =", items[:3])
}

type image [1024][1024]rgb
type rgb [3]byte

func newUniform(color rgb) *image {
	im := new(image)
	for x := range im {
		for y := range im[x] {
			im[x][y] = color
		}
	}
	return im
}

func printAllocInfo() {
	var stats runtime.MemStats
	runtime.GC()
	runtime.ReadMemStats(&stats)
	fmt.Println("Bytes allocated (total):", stats.TotalAlloc)
	fmt.Println("Bytes still allocated:  ", stats.Alloc)
}

1
2
3
4
5
items = [0xc000180000 0xc000480000 0xc000180000]
Bytes allocated (total): 6416688
Bytes still allocated:   3259024
items = [0xc000480000]
items undelying = [0xc000480000 <nil> <nil>]
1
2
3
4
5
6
7
8
9
fn main() {
    let x = 1;
    let mut items = vec![1, 2, 3, 1, 2, 3];
    
    items = items.into_iter().filter(|&item| item != x).collect();
    
    println!("{:?}", items);
}

[2, 3, 2, 3]


137. Check if string contains only digits

Set boolean b to true if string s contains only characters in range ‘0’..’9’, false otherwise.

检查字符串是否只包含数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import (
	"fmt"
)

func main() {
	for _, s := range []string{
		"123",
		"",
		"abc123def",
		"abc",
		"123.456",
		"123 456",
	} {
		b := true
		for _, c := range s {
			if c < '0' || c > '9' {
				b = false
				break
			}
		}
		fmt.Println(s, "=>", b)
	}
}

1
2
3
4
5
6
123 => true
 => true
abc123def => false
abc => false
123.456 => false
123 456 => false

or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import (
	"fmt"
	"strings"
)

func main() {
	for _, s := range []string{
		"123",
		"",
		"abc123def",
		"abc",
		"123.456",
		"123 456",
	} {
		isNotDigit := func(c rune) bool { return c < '0' || c > '9' }
		b := strings.IndexFunc(s, isNotDigit) == -1
		fmt.Println(s, "=>", b)
	}
}

1
2
3
4
5
6
123 => true
 => true
abc123def => false
abc => false
123.456 => false
123 456 => false
1
2
3
4
5
6
fn main() {
    let s = "1023";
    let chars_are_numeric: Vec<bool> = s.chars().map(|c|c.is_numeric()).collect();
    let b = !chars_are_numeric.contains(&false);
    println!("{}", b);
}

true

or

1
2
3
4
fn main() {
    let b = "0129".chars().all(char::is_numeric);
    println!("{}", b);
}

true


138. Create temp file

Create a new temporary file on filesystem.

创建一个新的临时文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package main

import (
	"io/ioutil"
	"log"
	"os"
)

func main() {
	content := []byte("Big bag of misc data")

	log.Println("Opening new temp file")
	tmpfile, err := ioutil.TempFile("", "example")
	if err != nil {
		log.Fatal(err)
	}
	tmpfilename := tmpfile.Name()
	defer os.Remove(tmpfilename) // clean up
	log.Println("Opened new file", tmpfilename)

	log.Println("Writing [[", string(content), "]]")
	if _, err := tmpfile.Write(content); err != nil {
		log.Fatal(err)
	}
	if err := tmpfile.Close(); err != nil {
		log.Fatal(err)
	}
	log.Println("Closed", tmpfilename)

	log.Println("Opening", tmpfilename)
	buffer, err := ioutil.ReadFile(tmpfilename)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Read[[", string(buffer), "]]")
}

1
2
3
4
5
6
2009/11/10 23:00:00 Opening new temp file
2009/11/10 23:00:00 Opened new file /tmp/example067319278
2009/11/10 23:00:00 Writing [[ Big bag of misc data ]]
2009/11/10 23:00:00 Closed /tmp/example067319278
2009/11/10 23:00:00 Opening /tmp/example067319278
2009/11/10 23:00:00 Read[[ Big bag of misc data ]]
1
2
3
4
use tempdir::TempDir;
use std::fs::File;
let temp_dir = TempDir::new("prefix")?;
let temp_file = File::open(temp_dir.path().join("file_name"))?;

139. Create temp directory

Create a new temporary folder on filesystem, for writing.

创建一个临时目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
)

func main() {
	content := []byte("temporary file's content")
	dir, err := ioutil.TempDir("", "")
	if err != nil {
		log.Fatal(err)
	}

	defer os.RemoveAll(dir) // clean up

	inspect(dir)

	tmpfn := filepath.Join(dir, "tmpfile")
	err = ioutil.WriteFile(tmpfn, content, 0666)
	if err != nil {
		log.Fatal(err)
	}

	inspect(dir)
}

func inspect(dirpath string) {
	files, err := ioutil.ReadDir(dirpath)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(dirpath, "contains", len(files), "files")
}

1
2
/tmp/067319278 contains 0 files
/tmp/067319278 contains 1 files
1
2
3
extern crate tempdir;
use tempdir::TempDir;
let tmp = TempDir::new("prefix")?;

140. Delete map entry

从map中删除某个key

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import (
	"fmt"
)

func main() {
	m := map[string]int{
		"uno":  1,
		"dos":  2,
		"tres": 3,
	}

	delete(m, "dos")
	delete(m, "cinco")

	fmt.Println(m)
}

map[tres:3 uno:1]

1
2
3
4
5
6
7
8
9
10
11
fn main() {
    use std::collections::HashMap;

    let mut m = HashMap::new();
    m.insert(5, "a");
    m.insert(17, "b");
    println!("{:?}", m);

    m.remove(&5);
    println!("{:?}", m);
}
1
2
{17: "b", 5: "a"}
{17: "b"}