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

这篇具有很好参考价值的文章主要介绍了Rust vs Go:常用语法对比(十三)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Rust vs Go:常用语法对比(十三),后端

题图来自 Go vs. Rust: The Ultimate Performance Battle


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{112233}
  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 := 1122
  a := []*int{&x, &y}
  fmt.Println(a)
 }
}

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

fn main() {
    let a = [112233];

    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 := 78
  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{12345678910}
 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{12345678910} {
  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![12345678910];
    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![12345678910];

    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, 20)
 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([]intlen(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


本文由 mdnice 多平台发布文章来源地址https://www.toymoban.com/news/detail-608521.html

到了这里,关于Rust vs Go:常用语法对比(十三)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

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

    题图来自 Go vs. Rust performance comparison: The basics 61. Get current date 获取当前时间 Now is 2009-11-10 23:00:00 +0000 UTC m=+0.000000001 or SystemTime { tv_sec: 1526318418, tv_nsec: 699329521 } 62. Find substring position 字符串查找 查找子字符串位置 i is the byte index of y in x, not the character (rune) index. i will be -1 if y i

    2024年02月16日
    浏览(40)
  • Rust vs Go:常用语法对比(三)

    题图来自 When to use Rust and when to use Go [1] 41. Reverse a string 反转字符串 输出 or 输出 ❤ roma tis rölod müspi mérol 42. Continue outer loop Print each item v of list a which in not contained in list b. For this, write an outer loop to iterate on a and an inner loop to iterate on b. 打印列表a中不包含在列表b中的每个项目

    2024年02月16日
    浏览(38)
  • Rust vs Go:常用语法对比(六)

    题图来自 [1] 101. Load from HTTP GET request into a string Make an HTTP request with method GET to URL u, then store the body of the response in string s. 发起http请求 res has type *http.Response. buffer has type []byte. It is idiomatic and strongly recommended to check errors at each step. GET response: 200 Hello Inigo Montoya or or 102. Load from H

    2024年02月15日
    浏览(45)
  • Rust vs Go:常用语法对比(五)

    题图来自 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). 按规则取整 2.71828 3 82. Count substring occurrences 统计子字符串出现次数 1 Disjoint ma

    2024年02月15日
    浏览(45)
  • Rust vs Go:常用语法对比(八)

    题目来自 Golang vs. Rust: Which Programming Language To Choose in 2023? [1] 141. Iterate in sequence over two lists Iterate in sequence over the elements of the list items1 then items2. For each iteration print the element. 依次迭代两个列表 依次迭代列表项1和项2的元素。每次迭代打印元素。 1 2 3 a b c 142. Hexadecimal digits of

    2024年02月15日
    浏览(34)
  • Rust vs Go:常用语法对比(十一)

    题目来自 Rust Vs Go: Which Language Is Better For Developing High-Performance Applications? [1] 202. Sum of squares Calculate the sum of squares s of data, an array of floating point values. 计算平方和 +1.094200e+000 32.25 205. Get an environment variable Read an environment variable with the name \\\"FOO\\\" and assign it to the string variable foo. If i

    2024年02月15日
    浏览(39)
  • 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。 122. Declare enumeration Create an enumerated type Suit with 4 possible values SPADES, HEARTS, DIAMONDS, CLUBS. 声明枚举值 Hearts

    2024年02月15日
    浏览(38)
  • Java VS Go 还在纠结怎么选吗,(资深后端4000字带你深度对比)

    今天我们来聊一下Go 和Java,本篇文章主要是想给对后台开发的初学者和有意向选择Go语言的有经验的程序员一些建议,希望能帮助各位自上而下的来了解一下Java和Go的全貌。 作为一个多年的Java后端开发,用的时间久了就会发现Java语言一些问题,所谓婚前风花雪月,婚后柴米

    2024年02月04日
    浏览(37)
  • 【字节跳动青训营】后端笔记整理-1 | Go语言入门指南:基础语法和常用特性解析

    **本人是第六届字节跳动青训营(后端组)的成员。本文由博主本人整理自该营的日常学习实践,首发于稀土掘金:🔗Go语言入门指南:基础语法和常用特性解析 | 青训营 本文主要梳理自 第六届字节跳动青训营(后端组)-Go语言原理与实践第一节(王克纯老师主讲) 。同时

    2024年02月13日
    浏览(55)
  • 【Rust日报】2023-02-14 Rust GUI 框架对比: Tauri vs Iced vs egui

    Rust GUI 框架对比: Tauri vs Iced vs egui Tauri:使用系统的 webview 来渲染 HTML/JS 的前端。你可以选择任何前端框架。后台是用Rust编写的,可以通过内置的方法与前台通信。 Iced: 受 Elm 启发的(响应式)GUI库。在桌面上使用 wgpu 进行渲染;实验性的web后端创建DOM进行渲染。所有代码

    2024年02月02日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包