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

fliter

发布于 2023-09-05 15:39:56

2140

发布于 2023-09-05 15:39:56

文章被收录于专栏：旅途散记旅途散记

题图来自 Rust vs Go 2023[1]

81. Round floating point number to integer

Declare integer y and initialize it with the rounded value of floating point number x . Ties (when the fractional part of x is exactly .5) must be rounded up (to positive infinity).

按规则取整

package main

import (
 "fmt"
 "math"
)

func round(x float64) int {
 y := int(math.Floor(x + 0.5))
 return y
}

func main() {
 for _, x := range []float64{-1.1, -0.9, -0.5, -0.1, 0., 0.1, 0.5, 0.9, 1.1} {
  fmt.Printf("%5.1f %5d\n", x, round(x))
 }
}

fn main() {
    let x : f64 = 2.71828;
    let y = x.round() as i64;
    
    println!("{} {}", x, y);
}

2.71828 3

82. Count substring occurrences

统计子字符串出现次数

package main

import (
 "fmt"
 "strings"
)

func main() {
 s := "Romaromamam"
 t := "mam"

 x := strings.Count(s, t)

 fmt.Println(x)
}

1

fn main() {
    let s = "lorem ipsum lorem ipsum lorem ipsum lorem ipsum";
    let t = "ipsum";

    let c = s.matches(t).count();

    println!("{} occurrences", c);
}

Disjoint matches: overlapping occurrences are not counted.

4 occurrences

83. Regex with character repetition

Declare regular expression r matching strings "http", "htttp", "httttp", etc.

正则表达式匹配重复字符

package main

import (
 "fmt"
 "regexp"
)

func main() {
 r := regexp.MustCompile("htt+p")

 for _, s := range []string{
  "hp",
  "htp",
  "http",
  "htttp",
  "httttp",
  "htttttp",
  "htttttp",
  "word htttp in a sentence",
 } {
  fmt.Println(s, "=>", r.MatchString(s))
 }
}

hp => false
htp => false
http => true
htttp => true
httttp => true
htttttp => true
htttttp => true
word htttp in a sentence => true

extern crate regex;
use regex::Regex;

fn main() {
    let r = Regex::new(r"htt+p").unwrap();
    
    assert!(r.is_match("http"));
    assert!(r.is_match("htttp"));
    assert!(r.is_match("httttp"));
}

84. Count bits set in integer binary representation

Count number c of 1s in the integer i in base 2.

E.g. i=6 → c=2

计算十进制整型的二进制表示中 1的个数

package main

import "fmt"

func PopCountUInt64(i uint64) (c int) {
 // bit population count, see
 // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
 i -= (i >> 1) & 0x5555555555555555
 i = (i>>2)&0x3333333333333333 + i&0x3333333333333333
 i += i >> 4
 i &= 0x0f0f0f0f0f0f0f0f
 i *= 0x0101010101010101
 return int(i >> 56)
}

func PopCountUInt32(i uint32) (n int) {
 // bit population count, see
 // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
 i -= (i >> 1) & 0x55555555
 i = (i>>2)&0x33333333 + i&0x33333333
 i += i >> 4
 i &= 0x0f0f0f0f
 i *= 0x01010101
 return int(i >> 24)
}

func main() {
 for i := uint64(0); i < 16; i++ {
  c := PopCountUInt64(i)
  fmt.Printf("%4d %04[1]b %d\n", i, c)
 }

 for i := uint32(0); i < 16; i++ {
  c := PopCountUInt32(i)
  fmt.Printf("%4d %04[1]b %d\n", i, c)
 }
}

This was useful only before go 1.9. See math/bits.OnesCount instead

package main

import (
 "fmt"
 "math/bits"
)

func main() {
 for i := uint(0); i < 16; i++ {
  c := bits.OnesCount(i)
  fmt.Printf("%4d %04[1]b %d\n", i, c)
 }
}

fn main() {
    println!("{}", 6usize.count_ones())
}

2

85. Check if integer addition will overflow

检查两个整型相加是否溢出

package main

import (
 "fmt"
 "math"
)

func willAddOverflow(a, b int64) bool {
 return a > math.MaxInt64-b
}

func main() {

 fmt.Println(willAddOverflow(11111111111111111, 2))

}

false

fn adding_will_overflow(x: usize, y: usize) -> bool {
    x.checked_add(y).is_none()
}

fn main() {
    {
        let (x, y) = (2345678, 9012345);

        let overflow = adding_will_overflow(x, y);

        println!(
            "{} + {} {}",
            x,
            y,
            if overflow {
                "overflows"
            } else {
                "doesn't overflow"
            }
        );
    }
    {
        let (x, y) = (2345678901, 9012345678);

        let overflow = adding_will_overflow(x, y);

        println!(
            "{} + {} {}",
            x,
            y,
            if overflow {
                "overflows"
            } else {
                "doesn't overflow"
            }
        );
    }
    {
        let (x, y) = (2345678901234, 9012345678901);

        let overflow = adding_will_overflow(x, y);

        println!(
            "{} + {} {}",
            x,
            y,
            if overflow {
                "overflows"
            } else {
                "doesn't overflow"
            }
        );
    }
    {
        let (x, y) = (23456789012345678, 90123456789012345);

        let overflow = adding_will_overflow(x, y);

        println!(
            "{} + {} {}",
            x,
            y,
            if overflow {
                "overflows"
            } else {
                "doesn't overflow"
            }
        );
    }
    {
        let (x, y) = (12345678901234567890, 9012345678901234567);

        let overflow = adding_will_overflow(x, y);

        println!(
            "{} + {} {}",
            x,
            y,
            if overflow {
                "overflows"
            } else {
                "doesn't overflow"
            }
        );
    }
}

2345678 + 9012345 doesn't overflow
2345678901 + 9012345678 doesn't overflow
2345678901234 + 9012345678901 doesn't overflow
23456789012345678 + 90123456789012345 doesn't overflow
12345678901234567890 + 9012345678901234567 overflows

86. Check if integer multiplication will overflow

检查整型相乘是否溢出

package main

import (
 "fmt"
)

func multiplyWillOverflow(x, y uint64) bool {
 if x <= 1 || y <= 1 {
  return false
 }
 d := x * y
 return d/y != x
}

func main() {
 {
  var x, y uint64 = 2345, 6789
  if multiplyWillOverflow(x, y) {
   fmt.Println(x, "*", y, "overflows")
  } else {
   fmt.Println(x, "*", y, "doesn't overflow")
  }
 }
 {
  var x, y uint64 = 2345678, 9012345
  if multiplyWillOverflow(x, y) {
   fmt.Println(x, "*", y, "overflows")
  } else {
   fmt.Println(x, "*", y, "doesn't overflow")
  }
 }
 {
  var x, y uint64 = 2345678901, 9012345678
  if multiplyWillOverflow(x, y) {
   fmt.Println(x, "*", y, "overflows")
  } else {
   fmt.Println(x, "*", y, "doesn't overflow")
  }
 }
}

2345 * 6789 doesn't overflow
2345678 * 9012345 doesn't overflow
2345678901 * 9012345678 overflows

fn main() {
    {
        let (x, y) = (2345, 6789);

        let overflow = multiply_will_overflow(x, y);

        println!(
            "{} * {} {}",
            x,
            y,
            if overflow {
                "overflows"
            } else {
                "doesn't overflow"
            }
        );
    }
    {
        let (x, y) = (2345678, 9012345);

        let overflow = multiply_will_overflow(x, y);

        println!(
            "{} * {} {}",
            x,
            y,
            if overflow {
                "overflows"
            } else {
                "doesn't overflow"
            }
        );
    }
    {
        let (x, y) = (2345678901, 9012345678);

        let overflow = multiply_will_overflow(x, y);

        println!(
            "{} * {} {}",
            x,
            y,
            if overflow {
                "overflows"
            } else {
                "doesn't overflow"
            }
        );
    }
}

fn multiply_will_overflow(x: i64, y: i64) -> bool {
    x.checked_mul(y).is_none()
}

2345 * 6789 doesn't overflow
2345678 * 9012345 doesn't overflow
2345678901 * 9012345678 overflows

87. Stop program

Exit immediately. If some extra cleanup work is executed by the program runtime (not by the OS itself), describe it.

停止程序,立即退出。

package main

import "os"

func main() {

 os.Exit(1)

 print(2222)
}

fn main() {
    std::process::exit(1);
    println!("42");
}

88. Allocate 1M bytes

分配1M内存

package main

import "fmt"

func main() {
 buf := make([]byte, 1000000)

 for i, b := range buf {
  if b != 0 {
   fmt.Println("Found unexpected value", b, "at position", i)
  }
 }
 fmt.Println("Buffer was correctly initialized with zero values.")
}

Buffer was correctly initialized with zero values.

fn main() {
    let buf: Vec<u8> = Vec::with_capacity(1024 * 1024);
    println!("{:?}", buf.capacity());
}

1048576

89. Handle invalid argument

处理无效参数

package main

import "fmt"

// NewSquareMatrix creates a N-by-N matrix
func NewSquareMatrix(N int) ([][]float64, error) {
 if N < 0 {
  return nil, fmt.Errorf("Invalid size %d: order cannot be negative", N)
 }
 matrix := make([][]float64, N)
 for i := range matrix {
  matrix[i] = make([]float64, N)
 }
 return matrix, nil
}

func main() {
 N1 := 3
 matrix1, err1 := NewSquareMatrix(N1)
 if err1 == nil {
  fmt.Println(matrix1)
 } else {
  fmt.Println(err1)
 }

 N2 := -2
 matrix2, err2 := NewSquareMatrix(N2)
 if err2 == nil {
  fmt.Println(matrix2)
 } else {
  fmt.Println(err2)
 }
}

[[0 0 0] [0 0 0] [0 0 0]]
Invalid size -2: order cannot be negative

#[derive(Debug, PartialEq, Eq)]
enum CustomError { InvalidAnswer }

fn do_stuff(x: i32) -> Result<i32, CustomError> {
    if x != 42 {
%2

90. Read-only outside

外部只读

type Foo struct {
 x int
}

func (f *Foo) X() int {
 return f.x
}

x is private, because it is not capitalized.
(*Foo).X is a public getter (a read accessor).

struct Foo {
    x: usize
}

impl Foo {
    pub fn new(x: usize) -> Self {
        Foo { x }
    }

    pub fn x<'a>(&'a self) -> &'a usize {
        &self.x
    }
}

91. Load JSON file into struct

json转结构体

package main

import "fmt"
import "io/ioutil"
import "encoding/json"

func readJSONFile() error {
 var x Person

 buffer, err := ioutil.ReadFile(filename)
 if err != nil {
  return err
 }
 err = json.Unmarshal(buffer, &x)
 if err != nil {
  return err
 }

 fmt.Println(x)
 return nil
}

func main() {
 err := readJSONFile()
 if err != nil {
  panic(err)
 }
}

type Person struct {
 FirstName string
 Age       int
}

const filename = "/tmp/data.json"

func init() {
 err := ioutil.WriteFile(filename, []byte(`
  {
   "FirstName":"Napoléon",
   "Age": 51 
  }`), 0644)
 if err != nil {
  panic(err)
 }
}

{Napoléon 51}

package main

import (
 "encoding/json"
 "fmt"
 "io/ioutil"
 "os"
)

func readJSONFile() error {
 var x Person

 r, err := os.Open(filename)
 if err != nil {
  return err
 }
 decoder := json.NewDecoder(r)
 err = decoder.Decode(&x)
 if err != nil {
  return err
 }

 fmt.Println(x)
 return nil
}

func main() {
 err := readJSONFile()
 if err != nil {
  panic(err)
 }
}

type Person struct {
 FirstName string
 Age       int
}

const filename = "/tmp/data.json"

func init() {
 err := ioutil.WriteFile(filename, []byte(`
  {
   "FirstName":"Napoléon",
   "Age": 51 
  }`), 0644)
 if err != nil {
  panic(err)
 }
}

{Napoléon 51}

#[macro_use] extern crate serde_derive;
extern crate serde_json;
use std::fs::File;
let x = ::serde_json::from_reader(File::open("data.json")?)?;

92. Save object into JSON file

将json对象写入文件

package main

import "fmt"
import "io/ioutil"
import "encoding/json"

func writeJSONFile() error {
 x := Person{
  FirstName: "Napoléon",
  Age:       51,
 }

 buffer, err := json.MarshalIndent(x, "", "  ")
 if err != nil {
  return err
 }
 return ioutil.WriteFile(filename, buffer, 0644)
}

func main() {
 err := writeJSONFile()
 if err != nil {
  panic(err)
 }
 fmt.Println("Done.")
}

type Person struct {
 FirstName string
 Age       int
}

const filename = "/tmp/data.json"

json.MarshalIndent is more human-readable than json.Marshal.

Done.

extern crate serde_json;
#[macro_use] extern crate serde_derive;

use std::fs::File;
::serde_json::to_writer(&File::create("data.json")?, &x)?

93. Pass a runnable procedure as parameter

Implement procedure control which receives one parameter f, and runs f.

以函数作为参数

package main

import "fmt"

func main() {
 control(greet)
}

func control(f func()) {
 fmt.Println("Before f")
 f()
 fmt.Println("After f")
}

func greet() {
 fmt.Println("Hello, developers")
}

Go supports first class functions, higher-order functions, user-defined function types, function literals, and closures.

Before f
Hello, developers
After f

fn control(f: impl Fn()) {
    f();
}

fn hello() {
    println!("Hello,");
}

fn main() {
    control(hello);
    control(|| { println!("Is there anybody in there?"); });
}

Hello,
Is there anybody in there?

94. Print type of variable

打印变量的类型

package main

import (
 "fmt"
 "os"
 "reflect"
)

func main() {
 var x interface{}

 x = "Hello"
 fmt.Println(reflect.TypeOf(x))

 x = 4
 fmt.Println(reflect.TypeOf(x))

 x = os.NewFile(0777, "foobar.txt")
 fmt.Println(reflect.TypeOf(x))
}

string
int
*os.File

package main

import (
 "fmt"
 "os"
)

func main() {
 var x interface{}

 x = "Hello"
 fmt.Printf("%T", x)
 fmt.Println()

 x = 4
 fmt.Printf("%T", x)
 fmt.Println()

 x = os.NewFile(0777, "foobar.txt")
 fmt.Printf("%T", x)
 fmt.Println()
}

string
int
*os.File

#![feature(core_intrinsics)]

fn type_of<T>(_: &T) -> String {
    format!("{}", std::intrinsics::type_name::<T>())
}

fn main() {
    let x: i32 = 1;
    println!("{}", type_of(&x));
}

i32

95. Get file size

获取文件的大小

package main

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

func main() {
 err := printSize("file.txt")
 if err != nil {
  panic(err)
 }
}

func printSize(path string) error {
 info, err := os.Stat(path)
 if err != nil {
  return err
 }
 x := info.Size()

 fmt.Println(x)
 return nil
}

func init() {
 // The file will only contains the characters "Hello", no newlines.
 buffer := []byte("Hello")
 err := ioutil.WriteFile("file.txt", buffer, 0644)
 if err != nil {
  panic(err)
 }
}

5

use std::fs;

fn filesize(path: &str) -> Result<u64, std::io::Error> {
    let x = fs::metadata(path)?.len();
    Ok(x)
}

fn main() {
    let path = "/etc/hosts";
    let x = filesize(path);
    println!("{}: {:?} bytes", path, x.unwrap());
}

/etc/hosts: 150 bytes

use std::path::Path;

fn filesize(path: &std::path::Path) -> Result<u64, std::io::Error> {
    let x = path.metadata()?.len();
    Ok(x)
}

fn main() {
    let path = Path::new("/etc/hosts");
    let x = filesize(path);
    println!("{:?}: {:?} bytes", path, x.unwrap());
}

"/etc/hosts": 150 bytes

96. Check string prefix

Set boolean b to true if string s starts with prefix prefix, false otherwise.

检查两个字符串前缀是否一致

package main

import (
 "fmt"
 "strings"
)

func check(s, prefix string) {

 b := strings.HasPrefix(s, prefix)

 if b {
  fmt.Println(s, "starts with", prefix)
 } else {
  fmt.Println(s, "doesn't start with", prefix)
 }
}

func main() {
 check("bar", "foo")
 check("foobar", "foo")
}

bar doesn't start with foo
foobar starts with foo

fn main() {
    let s = "bananas";
    let prefix = "bana";

    let b = s.starts_with(prefix);

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

true

97. Check string suffix

Set boolean b to true if string s ends with string suffix, false otherwise.

检查字符串后缀

package main

import (
 "fmt"
 "strings"
)

func check(s, suffix string) {

 b := strings.HasSuffix(s, suffix)

 if b {
  fmt.Println(s, "ends with", suffix)
 } else {
  fmt.Println(s, "doesn't end with", suffix)
 }
}

func main() {
 check("foo", "bar")
 check("foobar", "bar")
}

foo doesn't end with bar
foobar ends with bar

fn main() {
    let s = "bananas";
    let suffix = "nas";

    let b = s.ends_with(suffix);

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

true

98. Epoch seconds to date object

Convert a timestamp ts (number of seconds in epoch-time) to a date with time d. E.g. 0 -> 1970-01-01 00:00:00

时间戳转日期

package main

import (
 "fmt"
 "time"
)

func main() {
 ts := int64(1451606400)
 d := time.Unix(ts, 0)

 fmt.Println(d)
}

2016-01-01 00:00:00 +0000 UTC

extern crate chrono;
use chrono::prelude::*;

fn main() {
    let ts = 1451606400;
    let d = NaiveDateTime::from_timestamp(ts, 0);
    println!("{}", d);
}

2016-01-01 00:00:00

99. Format date YYYY-MM-DD

Assign to string x the value of fields (year, month, day) of date d, in format YYYY-MM-DD.

时间格式转换

package main

import (
 "fmt"
 "time"
)

func main() {
 d := time.Now()
 x := d.Format("2006-01-02")
 fmt.Println(x)

 // The output may be "2009-11-10" because the Playground's clock is fixed in the past.
}

2009-11-10

extern crate chrono;

use chrono::prelude::*;

fn main() {
    println!("{}", Utc::today().format("%Y-%m-%d"))
}

2021-07-17

100. Sort by a comparator

Sort elements of array-like collection items, using a comparator c.

根据某个字段排序

package main

import "fmt"
import "sort"

type Item struct {
 label string
 p     int
 lang  string
}

// c returns true if x is "inferior to" y (in a custom way)
func c(x, y Item) bool {
 return x.p < y.p
}

type ItemCSorter []Item

func (s ItemCSorter) Len() int           { return len(s) }
func (s ItemCSorter) Less(i, j int) bool { return c(s[i], s[j]) }
func (s ItemCSorter) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func sortItems(items []Item) {
 sorter := ItemCSorter(items)
 sort.Sort(sorter)
}

func main() {
 items := []Item{
  {"twelve", 12, "english"},
  {"six", 6, "english"},
  {"eleven", 11, "english"},
  {"zero", 0, "english"},
  {"two", 2, "english"},
 }
 fmt.Println("Unsorted: ", items)
 sortItems(items)
 fmt.Println("Sorted: ", items)
}

c has type func(Item, Item) bool.

Unsorted:  [{twelve 12 english} {six 6 english} {eleven 11 english} {zero 0 english} {two 2 english}]
Sorted:  [{zero 0 english} {two 2 english} {six 6 english} {eleven 11 english} {twelve 12 english}]

package main

import "fmt"
import "sort"

type Item struct {
 label string
 p     int
 lang  string
}

type ItemsSorter struct {
 items []Item
 c     func(x, y Item) bool
}

func (s ItemsSorter) Len() int           { return len(s.items) }
func (s ItemsSorter) Less(i, j int) bool { return s.c(s.items[i], s.items[j]) }
func (s ItemsSorter) Swap(i, j int)      { s.items[i], s.items[j] = s.items[j], s.items[i] }

func sortItems(items []Item, c func(x, y Item) bool) {
 sorter := ItemsSorter{
  items,
  c,
 }
 sort.Sort(sorter)
}

func main() {
 items := []Item{
  {"twelve", 12, "english"},
  {"six", 6, "english"},
  {"eleven", 11, "english"},
  {"zero", 0, "english"},
  {"two", 2, "english"},
 }
 fmt.Println("Unsorted: ", items)

 c := func(x, y Item) bool {
  return x.p < y.p
 }
 sortItems(items, c)

 fmt.Println("Sorted: ", items)
}

ItemsSorter contains c, which can be any comparator decided at runtime.

Unsorted:  [{twelve 12 english} {six 6 english} {eleven 11 english} {zero 0 english} {two 2 english}]
Sorted:  [{zero 0 english} {two 2 english} {six 6 english} {eleven 11 english} {twelve 12 english}]

package main

import "fmt"
import "sort"

type Item struct {
 label string
 p     int
 lang  string
}

// c returns true if x is "inferior to" y (in a custom way)
func c(x, y Item) bool {
 return x.p < y.p
}

func main() {
 items := []Item{
  {"twelve", 12, "english"},
  {"six", 6, "english"},
  {"eleven", 11, "english"},
  {"zero", 0, "english"},
  {"two", 2, "english"},
 }
 fmt.Println("Unsorted: ", items)
 
 sort.Slice(items, func(i, j int) bool {
  return c(items[i], items[j])
 })
 
 fmt.Println("Sorted: ", items)
}

Since Go 1.8, a single func parameter is sufficient to sort a slice.

Unsorted:  [{twelve 12 english} {six 6 english} {eleven 11 english} {zero 0 english} {two 2 english}]
Sorted:  [{zero 0 english} {two 2 english} {six 6 english} {eleven 11 english} {twelve 12 english}]

fn main() {
    let mut items = [1, 7, 5, 2, 3];
    items.sort_by(i32::cmp);
    println!("{:?}", items);
}

[1, 2, 3, 5, 7]

参考资料

[1]

Rust vs Go 2023: https://arkiana.com/rust-vs-go/

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2023-07-28，如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自旅途散记微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度