Rust vs Go: A Comparison of Common Grammar (9)

161. Multiply all the elements of a list

Multiply all the elements of the list elements by a constant c

Multiply each element in the list by a number

package main

import (
	"fmt"
)

func main(a) {
	const c = 5.5
	elements := []float64{2.4.9.30}
	fmt.Println(elements)

	for i := range elements {
		elements[i] *= c
	}
	fmt.Println(elements)
}

Copy the code

[2 4 9 30]
[11 22 49.5 165]
Copy the code

---

fn main() {
    let elements: Vec<f32> = vec![2.0.3.5.4.0];
    let c = 2.0;

    let elements = elements.into_iter().map(|x| c * x).collect::<VecThe < _ > > ();println!("{:? }", elements);
}

Copy the code

[4.0, 7.0, 8.0]

162. Execute procedures depending on options

execute bat if b is a program option and fox if f is a program option.

Execute the program according to the options

package main

import (
	"flag"
	"fmt"
	"os"
)

func init(a) {
	// Just for testing in the Playground, let's simulate
	// the user called this program with command line
	// flags -f and -b
	os.Args = []string{"program"."-f"."-b"}}var b = flag.Bool("b".false."Do bat")
var f = flag.Bool("f".false."Do fox")

func main(a) {
	flag.Parse()
	if *b {
		bar()
	}
	if *f {
		fox()
	}
	fmt.Println("The end.")}func bar(a) {
	fmt.Println("BAR")}func fox(a) {
	fmt.Println("FOX")}Copy the code

BAR
FOX
The end.
Copy the code

---

if let Some(arg) = ::std::env::args().nth(1) {
    if &arg == "f" {
        fox();
    } else if &arg = "b" {
        bat();
    } else{ eprintln! ("invalid argument: {}", arg),
    }
} else{ eprintln! ("missing argument");
}
Copy the code

or

if let Some(arg) = ::std::env::args().nth(1) {
    match arg.as_str() {
        "f" => fox(),
        "b"= >box(), _ => eprintln! ("invalid argument: {}", arg),
    };
} else{ eprintln! ("missing argument");
}
Copy the code

163. Print list elements by group of 2

Print all the list elements, two by two, assuming list length is even.

Prints array elements in pairs of two

package main

import (
	"fmt"
)

func main(a) {
	list := []string{"a"."b"."c"."d"."e"."f"}

	for i := 0; i+1 < len(list); i += 2 {
		fmt.Println(list[i], list[i+1])}}Copy the code

a b
c d
e f
Copy the code

---

fn main() {
    let list = [1.2.3.4.5.6];
    for pair in list.chunks(2) {
        println!("({}, {})", pair[0], pair[1]); }}Copy the code

(1.2)
(3.4)
(5.6)
Copy the code

164. Open URL in default browser

Open the URL s in the default browser.

Set boolean b to indicate whether the operation was successful.

Open the link in the default browser

import "github.com/skratchdot/open-golang/open"
b := open.Start(s) == nil
Copy the code

or

func openbrowser(url string) {
	var err error

	switch runtime.GOOS {
	case "linux":
		err = exec.Command("xdg-open", url).Start()
	case "windows":
		err = exec.Command("rundll32"."url.dll,FileProtocolHandler", url).Start()
	case "darwin":
		err = exec.Command("open", url).Start()
	default:
		err = fmt.Errorf("unsupported platform")}iferr ! =nil {
		log.Fatal(err)
	}

}
Copy the code

---

use webbrowser;
webbrowser::open(s).expect("failed to open URL");
Copy the code

165. Last element of list

Assign to variable x the last element of list items.

The last element in the list

package main

import (
	"fmt"
)

func main(a) {
	items := []string{ "what"."a"."mess" }
	
	x := items[len(items)- 1]

	fmt.Println(x)
}

Copy the code

mess

---

fn main() {
    let items = vec![5.6.8, -20.9.42];
    let x = items[items.len()-1];
    println!("{:? }", x);
}

Copy the code

42

or

fn main() {
    let items = [5.6.8, -20.9.42];
    let x = items.last().unwrap();
    println!("{:? }", x);
}
Copy the code

42

166. Concatenate two lists

Create list ab containing all the elements of list a, followed by all elements of list b.

Join two lists

package main

import (
	"fmt"
)

func main(a) {
	a := []string{"The "."quick "}
	b := []string{"brown "."fox "}

	ab := append(a, b...)

	fmt.Printf("%q", ab)
}

Copy the code

["The " "quick " "brown " "fox "]

or

package main

import (
	"fmt"
)

func main(a) {
	type T string

	a := []T{"The "."quick "}
	b := []T{"brown "."fox "}

	var ab []T
	ab = append(append(ab, a...) , b...) fmt.Printf("%q", ab)
}

Copy the code

["The " "quick " "brown " "fox "]

or

package main

import (
	"fmt"
)

func main(a) {
	type T string

	a := []T{"The "."quick "}
	b := []T{"brown "."fox "}

	ab := make([]T, len(a)+len(b))
	copy(ab, a)
	copy(ab[len(a):], b)

	fmt.Printf("%q", ab)
}
Copy the code

["The " "quick " "brown " "fox "]

---

fn main() {
    let a = vec![1.2];
    let b = vec![3.4];
    let ab = [a, b].concat();
    println!("{:? }", ab);
}
Copy the code

[1, 2, 3, 4]

167. Trim prefix

Create string t consisting of string s with its prefix p removed (if s starts with p).

Remove the prefix

package main

import (
	"fmt"
	"strings"
)

func main(a) {
	s := "Cafe - society"
	p := "café"

	t := strings.TrimPrefix(s, p)

	fmt.Println(t)
}

Copy the code

-society

---

fn main() {{let s = "pre_thing";
        let p = "pre_";
        let t = s.trim_start_matches(p);
        println!("{}", t);
    }
    {
        // Warning: trim_start_matches removes several leading occurrences of p, if present.
        let s = "pre_pre_thing";
        let p = "pre_";
        let t = s.trim_start_matches(p);
        println!("{}", t); }}Copy the code

thing
thing
Copy the code

or

fn main() {
    let s = "pre_pre_thing";
    let p = "pre_";

    let t = if s.starts_with(p) { &s[p.len()..] } else { s };
    println!("{}", t);
}
Copy the code

pre_thing

or

fn main() {{let s = "pre_thing";
        let p = "pre_";
        let t = s.strip_prefix(p).unwrap_or_else(|| s);
        println!("{}", t);
    }
    {
        // If prefix p is repeated in s, it is removed only once by strip_prefix
        let s = "pre_pre_thing";
        let p = "pre_";
        let t = s.strip_prefix(p).unwrap_or_else(|| s);
        println!("{}", t); }}Copy the code

thing
pre_thing
Copy the code

168. Trim suffix

Create string t consisting of string s with its suffix w removed (if s ends with w).

Remove the suffix

package main

import (
	"fmt"
	"strings"
)

func main(a) {
	s := "Cafe - society"
	w := "society"

	t := strings.TrimSuffix(s, w)

	fmt.Println(t)
}

Copy the code

Cafe -

---

fn main() {
    let s = "thing_suf";
    let w = "_suf";
    let t = s.trim_end_matches(w);
    println!("{}", t);

    let s = "thing";
    let w = "_suf";
    let t = s.trim_end_matches(w); // s does not end with w, it is left intact
    println!("{}", t);

    let s = "thing_suf_suf";
    let w = "_suf";
    let t = s.trim_end_matches(w); // removes several occurrences of w
    println!("{}", t);
}

Copy the code

thing
thing
thing
Copy the code

or

fn main() {
    let s = "thing_suf";
    let w = "_suf";
    let t = s.strip_suffix(w).unwrap_or(s);
    println!("{}", t);

    let s = "thing";
    let w = "_suf";
    let t = s.strip_suffix(w).unwrap_or(s); // s does not end with w, it is left intact
    println!("{}", t);

    let s = "thing_suf_suf";
    let w = "_suf";
    let t = s.strip_suffix(w).unwrap_or(s); // only 1 occurrence of w is removed
    println!("{}", t);
}

Copy the code

thing
thing
thing_suf
Copy the code

169. String length

Assign to integer n the number of characters of string s.

Make sure that multibyte characters are properly handled. n can be different from the number of bytes of s.

String length

package main

import "fmt"
import "unicode/utf8"

func main(a) {
	s := "Hello, world"
	n := utf8.RuneCountInString(s)

	fmt.Println(n)
}

Copy the code

9

---

fn main() {
    let s = "The world";

    let n = s.chars().count();

    println!("{} characters", n);
}

Copy the code

2 characters

170. Get map size

Set n to the number of elements stored in mymap.

This is not always equal to the map capacity.

Gets the size of the map

package main

import "fmt"

func main(a) {
	mymap := map[string]int{"a": 1."b": 2."c": 3}
	n := len(mymap)
	fmt.Println(n)
}
Copy the code

3

---

use std::collections::HashMap;

fn main() {
    let mut mymap: HashMap<&str.i32> = [("one".1), ("two".2)].iter().cloned().collect();
    mymap.insert("three".3);

    let n = mymap.len();

    println!("mymap has {:? } entries", n);
}
Copy the code

mymap has 3 entries

171. Add an element at the end of a list

Append element x to the list s.

Add elements at the end of the list

package main

import "fmt"

func main(a) {
	s := []int{1.1.2.3.5.8.13}
	x := 21

	s = append(s, x)

	fmt.Println(s)
}

Copy the code

[1 1 2 3 5 8 13 21]

---

fn main() {
    let mut s = vec![1.2.3];
    let x = 99;

    s.push(x);

    println!("{:? }", s);
}
Copy the code

[1, 2, 3, 99]

172. Insert entry in map

Insert value v for key k in map m.

Writes elements to the map

package main

import "fmt"

func main(a) {
	m := map[string]int{"one": 1."two": 2}
	k := "three"
	v := 3

	m[k] = v

	fmt.Println(m)
}
Copy the code

map[one:1 three:3 two:2]

---

use std::collections::HashMap;

fn main() {
    let mut m: HashMap<&str.i32> = [("one".1), ("two".2)].iter().cloned().collect();

    let (k, v) = ("three".3);

    m.insert(k, v);

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

Copy the code

{"three": 3, "one": 1, "two": 2}

173. Format a number with grouped thousands

Number will be formatted with a comma separator between every group of thousands.

Format numbers by thousands

package main

import (
	"fmt"

	"golang.org/x/text/language"
	"golang.org/x/text/message"
)

// The Playground doesn't work with import of external packages.
// However, you may copy this source and test it on your workstation.

func main(a) {
	p := message.NewPrinter(language.English)
	s := p.Sprintf("%d\n".1000)

	fmt.Println(s)
	// Output:
	// 1,000
}

Copy the code

1000

or

package main

import (
	"fmt"
	"github.com/floscodes/golang-thousands"
	"strconv"
)

// The Playground takes more time when importing external packages.
// However, you may want to copy this source and test it on your workstation.

func main(a) {
	n := strconv.Itoa(23489)
	s := thousands.Separate(n, "en")

	fmt.Println(s)
	// Output:
	// 23,489
}

Copy the code

23489

---

use separator::Separatable;
println!("{}".1000.separated_string());
Copy the code

174. Make HTTP POST request

Make a HTTP request with method POST to URL u

Initiate an HTTP POST request

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"net"
	"net/http"
)

func main(a) {
	contentType := "text/plain"
	var body io.Reader
	u := "http://" + localhost + "/hello"

	response, err := http.Post(u, contentType, body)
	check(err)
	buffer, err := ioutil.ReadAll(response.Body)
	check(err)
	fmt.Println("POST response:", response.StatusCode, string(buffer))

	response, err = http.Get(u)
	check(err)
	buffer, err = ioutil.ReadAll(response.Body)
	check(err)
	fmt.Println("GET response:", response.StatusCode, string(buffer))
}

const localhost = "127.0.0.1:3000"

func init(a) {
	http.HandleFunc("/hello", myHandler)
	startServer()
}

func myHandler(w http.ResponseWriter, r *http.Request) {
	ifr.Method ! ="POST" {
		w.WriteHeader(http.StatusBadRequest)
		fmt.Fprintf(w, "Refusing request verb %q", r.Method)
		return
	}
	fmt.Fprintf(w, "Hello POST :)")}func startServer(a) {
	listener, err := net.Listen("tcp", localhost)
	check(err)

	go http.Serve(listener, nil)}func check(err error) {
	iferr ! =nil {
		panic(err)
	}
}

Copy the code

POST response: 200 Hello Alice (POST)
GET  response: 400 Refusing request verb "GET"
Copy the code

or

package main

import (
	"fmt"
	"io/ioutil"
	"net"
	"net/http"
	"net/url"
)

func main(a) {
	formValues := url.Values{
		"who": []string{"Alice"},
	}
	u := "http://" + localhost + "/hello"

	response, err := http.PostForm(u, formValues)
	check(err)
	buffer, err := ioutil.ReadAll(response.Body)
	check(err)
	fmt.Println("POST response:", response.StatusCode, string(buffer))

	response, err = http.Get(u)
	check(err)
	buffer, err = ioutil.ReadAll(response.Body)
	check(err)
	fmt.Println("GET response:", response.StatusCode, string(buffer))
}

const localhost = "127.0.0.1:3000"

func init(a) {
	http.HandleFunc("/hello", myHandler)
	startServer()
}

func myHandler(w http.ResponseWriter, r *http.Request) {
	ifr.Method ! ="POST" {
		w.WriteHeader(http.StatusBadRequest)
		fmt.Fprintf(w, "Refusing request verb %q", r.Method)
		return
	}
	fmt.Fprintf(w, "Hello %s (POST)", r.FormValue("who"))}func startServer(a) {
	listener, err := net.Listen("tcp", localhost)
	check(err)

	go http.Serve(listener, nil)}func check(err error) {
	iferr ! =nil {
		panic(err)
	}
}
Copy the code

---

[dependencies]
error-chain = "0.12.4"
reqwest = { version = "0.11.2", features = ["blocking"]}use error_chain::error_chain;
use std::io::Read;
let client = reqwest::blocking::Client::new();
let mut response = client.post(u).body("abc").send()? ;Copy the code

175. Bytes to hex string

From array a of n bytes, build the equivalent hex string s of 2n digits.

Each byte (256 possible values) is encoded as two hexadecimal characters (16 possible values per digit).

Byte to hexadecimal character string

package main

import (
	"encoding/hex"
	"fmt"
)

func main(a) {
	a := []byte("Hello")

	s := hex.EncodeToString(a)

	fmt.Println(s)
}
Copy the code

48656c6c6f

---

use core::fmt::Write;

fn main() -> core::fmt::Result {
    let a = vec![22.4.127.193];
    let n = a.len();
    
    let mut s = String::with_capacity(2 * n);
    for byte in a {
        write!(s, "{:02X}", byte)? ; } dbg! (s);Ok(())}Copy the code

[src/main.rs:12] s = "16047FC1"

176. Hex string to byte array

From hex string s of 2n digits, build the equivalent array a of n bytes.

Each pair of hexadecimal characters (16 possible values per digit) is decoded into one byte (256 possible values).

Hexadecimal string to byte array

package main

import (
	"encoding/hex"
	"fmt"
	"log"
)

func main(a) {
	s := "48656c6c6f"

	a, err := hex.DecodeString(s)
	iferr ! =nil {
		log.Fatal(err)
	}

	fmt.Println(a)
	fmt.Println(string(a))
}

Copy the code

[72 101 108 108 111]
Hello
Copy the code

---

use hex::FromHex
let a: Vec<u8> = Vec::from_hex(s).expect("Invalid Hex String");
Copy the code

178. Check if point is inside rectangle

Set boolean b to true if if the point with coordinates (x,y) is inside the rectangle with coordinates (x1,y1,x2,y2) , or to false otherwise.

Describe if the edges are considered to be inside the rectangle.

Check whether the checkpoint is in the rectangle

package main

import (
	"fmt"
	"image"
)

func main(a) {
	x1, y1, x2, y2 := 1.1.50.100
	r := image.Rect(x1, y1, x2, y2)

	x, y := 10.10
	p := image.Pt(x, y)
	b := p.In(r)
	fmt.Println(b)

	x, y = 100.100
	p = image.Pt(x, y)
	b = p.In(r)
	fmt.Println(b)
}

Copy the code

true
false
Copy the code

---

struct Rect {
    x1: i32,
    x2: i32,
    y1: i32,
    y2: i32,}impl Rect {
    fn contains(&self, x: i32, y: i32) - >bool {
        return self.x1 < x && x < self.x2 && self.y1 < y && y < self.y2; }}Copy the code

179. Get center of a rectangle

Return the center c of the rectangle with coordinates (x1,y1,x2,y2)

Gets the center of the rectangle

import "image"
c := image.Pt((x1+x2)/2, (y1+y2)/2)
Copy the code

---

struct Rectangle {
    x1: f64,
    y1: f64,
    x2: f64,
    y2: f64,}impl Rectangle {
    pub fn center(&self) - > (f64.f64) {((self.x1 + self.x2) / 2.0, (self.y1 + self.y2) / 2.0)}}fn main() {
    let r = Rectangle {
        x1: 5.,
        y1: 5.,
        x2: 10.,
        y2: 10.,};println!("{:? }", r.center());
}
Copy the code

(7.5, 7.5)

180. List files in directory

Create list x containing the contents of directory d.

x may contain files and subfolders.

No recursive subfolder listing.

Lists the files in the directory

package main

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

func main(a) {
	d := "/"

	x, err := ioutil.ReadDir(d)
	iferr ! =nil {
		log.Fatal(err)
	}

	for _, f := range x {
		fmt.Println(f.Name())
	}
}

Copy the code

.dockerenv
bin
dev
etc
home
lib
lib64
proc
root
sys
tmp
tmpfs
usr
var
Copy the code

---

use std::fs;

fn main() {
    let d = "/etc";

    let x = fs::read_dir(d).unwrap();

    for entry in x {
        let entry = entry.unwrap();
        println!("{:? }", entry.path()); }}Copy the code

or

fn main() {
    let d = "/etc";

    let x = std::fs::read_dir(d)
        .unwrap()
        .collect::<Result<Vec<_>, _>>()
        .unwrap();

    for entry in x {
        println!("{:? }", entry.path()); }}Copy the code

"/etc/issue.net"
"/etc/bindresvport.blacklist"
"/etc/rc1.d"
"/etc/hostname"
"/etc/xattr.conf"
"/etc/resolv.conf"
"/etc/pam.conf"
"/etc/mke2fs.conf"
"/etc/e2scrub.conf"
"/etc/update-motd.d"
"/etc/terminfo"
"/etc/alternatives"
"/etc/ld.so.cache"
"/etc/networks"
"/etc/profile"
"/etc/debconf.conf"
"/etc/security"
"/etc/.pwd.lock"
"/etc/gai.conf"
"/etc/dpkg"
"/etc/rc3.d"
"/etc/fstab"
"/etc/gshadow"
"/etc/sysctl.conf"
"/etc/rc2.d"
"/etc/selinux"
"/etc/ld.so.conf.d"
"/etc/os-release"
"/etc/libaudit.conf"
"/etc/login.defs"
"/etc/skel"
"/etc/shells"
"/etc/rc4.d"
"/etc/cron.d"
"/etc/default"
"/etc/lsb-release"
"/etc/apt"
"/etc/debian_version"
"/etc/machine-id"
"/etc/deluser.conf"
"/etc/group"
"/etc/legal"
"/etc/rc6.d"
"/etc/init.d"
"/etc/sysctl.d"
"/etc/pam.d"
"/etc/passwd"
"/etc/rc5.d"
"/etc/bash.bashrc"
"/etc/hosts"
"/etc/rc0.d"
"/etc/environment"
"/etc/cron.daily"
"/etc/shadow"
"/etc/ld.so.conf"
"/etc/subgid"
"/etc/opt"
"/etc/logrotate.d"
"/etc/subuid"
"/etc/profile.d"
"/etc/adduser.conf"
"/etc/issue"
"/etc/rmt"
"/etc/host.conf"
"/etc/rcS.d"
"/etc/nsswitch.conf"
"/etc/systemd"
"/etc/kernel"
"/etc/mtab"
"/etc/shadow-"
"/etc/passwd-"
"/etc/subuid-"
"/etc/gshadow-"
"/etc/subgid-"
"/etc/group-"
"/etc/ethertypes"
"/etc/logcheck"
"/etc/gss"
"/etc/bash_completion.d"
"/etc/X11"
"/etc/perl"
"/etc/ca-certificates"
"/etc/protocols"
"/etc/ca-certificates.conf"
"/ etc/python2.7"
"/etc/localtime"
"/etc/xdg"
"/etc/timezone"
"/etc/mailcap.order"
"/etc/emacs"
"/etc/ssh"
"/etc/magic.mime"
"/etc/services"
"/etc/ssl"
"/etc/ldap"
"/etc/rpc"
"/etc/mime.types"
"/etc/magic"
"/etc/mailcap"
"/etc/inputrc"
Copy the code