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

题图来自 Go vs Rust: Which will be the top pick in programming?^[1]

121. UDP listen and read

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

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

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)
}

---

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.

声明枚举值

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

---

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.

断言条件

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
}

---

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.

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

二分查找

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

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

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)
  }
 }
}

---

125. Measure function call duration

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

函数调用时间

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")
}

Hello
0ns

or

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")
}

Hello
0ns

---

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.

多个返回值

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

---

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

树的广度优先遍历

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)
}

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)

---

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

129. Breadth-first traversing in a graph

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

图的广度优先遍历

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)
}

0 (London)
3 (Paris)
1 (New York City)
2 (Berlin)
4 (Tokyo)

---

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

130. Depth-first traversing in a graph

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

图的深度优先遍历

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)
}

0 (London)
3 (Paris)
4 (Tokyo)
2 (Berlin)
1 (New York City)

---

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

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.

连续条件判等

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)
 }
}

I'm a Dog
I'm a Fruit

---

if c1 { f1() } else if c2 { f2() } else if c3 { f3() }

or

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.

度量程序执行时间

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

---

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.

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

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)
}

true
true
false

---

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);
    }
}

true
true
false

or

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

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);
    }
}

true
true
false

134. Create a new list

创建一个新list

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]

---

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.

移除列表中的值

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)
}

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

or

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
 }
}

---

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.

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

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

[b a b a r]
[a a r]

or

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

[b a b a r]
[a a r]

or

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)
}

items = [0xc000180000 0xc000480000 0xc000180000]
Bytes allocated (total): 6416688
Bytes still allocated:   3259024
items = [0xc000480000]
items undelying = [0xc000480000 <nil> <nil>]

---

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.

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

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)
 }
}

123 => true
 => true
abc123def => false
abc => false
123.456 => false
123 456 => false

or

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)
 }
}

123 => true
 => true
abc123def => false
abc => false
123.456 => false
123 456 => false

---

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

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

true

138. Create temp file

Create a new temporary file on filesystem.

创建一个新的临时文件

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), "]]")
}

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 ]]

---

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.

创建一个临时目录

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")
}

/tmp/067319278 contains 0 files
/tmp/067319278 contains 1 files

---

extern crate tempdir;
use tempdir::TempDir;
let tmp = TempDir::new("prefix")?;

140. Delete map entry

从map中删除某个key

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]

---

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);
}

{17: "b", 5: "a"}
{17: "b"}

参考资料

[1]

Go vs Rust: Which will be the top pick in programming?: https://www.appventurez.com/blog/go-vs-rust

本文由 mdnice 多平台发布