Rust vs Go:常用语法对比(十一)（2）

package main
import (
  "fmt"
  "os"
)
func main() {
  path := "foo"
  _, err := os.Stat(path)
  b := !os.IsNotExist(err)
  fmt.Println(path, "exists:", b)
  err = os.Mkdir(path, os.ModeDir)
  if err != nil {
    panic(err)
  }
  info, err2 := os.Stat(path)
  b = !os.IsNotExist(err2)
  fmt.Println(path, "exists:", b)
  fmt.Println(path, "is a directory:", info.IsDir())
}

foo exists: false
foo exists: true
foo is a directory: true

package main
import (
  "fmt"
  "os"
)
func main() {
  path := "foo/bar"
  _, err := os.Stat(path)
  b := !os.IsNotExist(err)
  fmt.Println(path, "exists:", b)
  err = os.Mkdir(path, os.ModeDir)
  if err != nil {
    fmt.Println("Could not create", path, "with os.Mkdir")
  }
  info, err2 := os.Stat(path)
  b = !os.IsNotExist(err2)
  fmt.Println(path, "exists:", b)
  err = os.MkdirAll(path, os.ModeDir)
  if err != nil {
    fmt.Println("Could not create", path, "with os.MkdirAll")
  }
  info, err2 = os.Stat(path)
  b = !os.IsNotExist(err2)
  fmt.Println(path, "exists:", b)
  fmt.Println(path, "is a directory:", info.IsDir())
}

foo/bar exists: false
Could not create foo/bar with os.Mkdir
foo/bar exists: false
foo/bar exists: true
foo/bar is a directory: true

use std::fs;
use std::path::Path;
fn main() {
    let path = "/tmp/goofy";
    let b: bool = Path::new(path).is_dir();
    println!("{} exists: {}", path, b);
    let r = fs::create_dir(path);
    match r {
        Err(e) => {
            println!("error creating {}: {}", path, e);
            std::process::exit(1);
        }
        Ok(_) => println!("created {}: OK", path),
    }
    let b: bool = Path::new(path).is_dir();
    println!("{} exists: {}", path, b);
}

/tmp/goofy exists: false
created /tmp/goofy: OK
/tmp/goofy exists: true

use std::fs;
use std::path::Path;
fn main() {
    let path = "/tmp/friends/goofy";
    let b: bool = Path::new(path).is_dir();
    println!("{} exists: {}", path, b);
    // fs::create_dir can't create parent folders
    let r = fs::create_dir(path);
    match r {
        Err(e) => println!("error creating {}: {}", path, e),
        Ok(_) => println!("created {}: OK", path),
    }
    let b: bool = Path::new(path).is_dir();
    println!("{} exists: {}", path, b);
    // fs::create_dir_all does create parent folders
    let r = fs::create_dir_all(path);
    match r {
        Err(e) => println!("error creating {}: {}", path, e),
        Ok(_) => println!("created {}: OK", path),
    }
    let b: bool = Path::new(path).is_dir();
    println!("{} exists: {}", path, b);
}

/tmp/friends/goofy exists: false
error creating /tmp/friends/goofy: No such file or directory (os error 2)
/tmp/friends/goofy exists: false
created /tmp/friends/goofy: OK
/tmp/friends/goofy exists: true

package main
import (
  "fmt"
  "os"
)
func main() {
  path := "foo"
  info, err := os.Stat(path)
  b := !os.IsNotExist(err) && info.IsDir()
  fmt.Println(path, "is a directory:", b)
  err = os.Mkdir(path, os.ModeDir)
  if err != nil {
    panic(err)
  }
  info, err = os.Stat(path)
  b = !os.IsNotExist(err) && info.IsDir()
  fmt.Println(path, "is a directory:", b)
}

foo is a directory: false
foo is a directory: true

use std::path::Path;
fn main() {
    let path = "/etc";
    let b: bool = Path::new(path).is_dir();
    println!("{}: {}", path, b);
    let path = "/goofy";
    let b: bool = Path::new(path).is_dir();
    println!("{}: {}", path, b);
}

/etc: true
/goofy: false

package main
import (
  "fmt"
  "strings"
  "unicode/utf8"
)
func main() {
  m := 3
  c := "-"
  for _, s := range []string{
    "",
    "a",
    "ab",
    "abc",
    "abcd",
    "é",
  } {
    if n := utf8.RuneCountInString(s); n < m {
      s = strings.Repeat(c, m-n) + s
    }
    fmt.Println(s)
  }
}

---
--a
-ab
abc
abcd
--é

use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
if let Some(columns_short) = m.checked_sub(s.width()) {
    let padding_width = c
        .width()
        .filter(|n| *n > 0)
        .expect("padding character should be visible");
    // Saturate the columns_short
    let padding_needed = columns_short + padding_width - 1 / padding_width;
    let mut t = String::with_capacity(s.len() + padding_needed);
    t.extend((0..padding_needed).map(|_| c)
    t.push_str(&s);
    s = t;
}

package main
import (
  "archive/zip"
  "bytes"
  "io"
  "io/ioutil"
  "log"
  "os"
)
func main() {
  list := []string{
    "readme.txt",
    "gopher.txt",
    "todo.txt",
  }
  name := "archive.zip"
  err := makeZip(list, name)
  if err != nil {
    log.Fatal(err)
  }
}
func makeZip(list []string, name string) error {
  // Create a buffer to write our archive to.
  buf := new(bytes.Buffer)
  // Create a new zip archive.
  w := zip.NewWriter(buf)
  // Add some files to the archive.
  for _, filename := range list {
    // Open file for reading
    input, err := os.Open(filename)
    if err != nil {
      return err
    }
    // Create ZIP entry for writing
    output, err := w.Create(filename)
    if err != nil {
      return err
    }
    _, err = io.Copy(output, input)
    if err != nil {
      return err
    }
  }
  // Make sure to check the error on Close.
  err := w.Close()
  if err != nil {
    return err
  }
  N := buf.Len()
  err = ioutil.WriteFile(name, buf.Bytes(), 0777)
  if err != nil {
    return err
  }
  log.Println("Written a ZIP file of", N, "bytes")
  return nil
}
func init() {
  // Create some files in the filesystem.
  var files = []struct {
    Name, Body string
  }{
    {"readme.txt", "This archive contains some text files."},
    {"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
    {"todo.txt", "Get animal handling licence.\nWrite more examples."},
  }
  for _, file := range files {
    err := ioutil.WriteFile(file.Name, []byte(file.Body), 0777)
    if err != nil {
      log.Fatal(err)
    }
  }
}

use zip::write::FileOptions;
let path = std::path::Path::new(_name);
let file = std::fs::File::create(&path).unwrap();
let mut zip = zip::ZipWriter::new(file); zip.start_file("readme.txt", FileOptions::default())?;                                                          
zip.write_all(b"Hello, World!\n")?;
zip.finish()?;

use zip::write::FileOptions;
fn zip(_name: &str, _list: Vec<&str>) -> zip::result::ZipResult<()>
{
    let path = std::path::Path::new(_name);
    let file = std::fs::File::create(&path).unwrap();
    let mut zip = zip::ZipWriter::new(file);
    for i in _list.iter() {
        zip.start_file(i as &str, FileOptions::default())?;
    }
    zip.finish()?;
    Ok(())
}

package main
import (
  "fmt"
)
type T int
func main() {
  a := []T{4, 5, 6, 7, 8, 9, 10}
  b := []T{1, 3, 9, 5, 7, 9, 7, 7}
  // Convert to sets
  seta := make(map[T]bool, len(a))
  for _, x := range a {
    seta[x] = true
  }
  setb := make(map[T]bool, len(a))
  for _, y := range b {
    setb[y] = true
  }
  // Iterate in one pass
  var c []T
  for x := range seta {
    if setb[x] {
      c = append(c, x)
    }
  }
  fmt.Println(c)
}

use std::collections::HashSet;
fn main() {
    let a = vec![1, 2, 3, 4];
    let b = vec![2, 4, 6, 8, 2, 2];
    let unique_a = a.iter().collect::<HashSet<_>>();
    let unique_b = b.iter().collect::<HashSet<_>>();
    let c = unique_a.intersection(&unique_b).collect::<Vec<_>>();
    println!("c: {:?}", c);
}

use std::collections::HashSet;
fn main() {
    let a = vec![1, 2, 3, 4];
    let b = vec![2, 4, 6, 8, 2, 2];
    let set_a: HashSet<_> = a.into_iter().collect();
    let set_b: HashSet<_> = b.into_iter().collect();
    let c = set_a.intersection(&set_b);
    println!("c: {:?}", c);
}

package main
import (
  "fmt"
  "regexp"
)
// regexp created only once, and then reused
var whitespaces = regexp.MustCompile(`\s+`)
func main() {
  s := `
  one   two
     three
  `
  t := whitespaces.ReplaceAllString(s, " ")
  fmt.Printf("t=%q", t)
}

use regex::Regex;
fn main() {
    let s = "
  one   two
     three
  ";
    let re = Regex::new(r"\s+").unwrap();
    let t = re.replace_all(s, " ");
    println!("{}", t);
}

t := []interface{}{
  2.5,
  "hello",
  make(chan int),
}

fn main() {
    let mut t = (2.5, "hello", -1);
    t.2 -= 4;
    println!("{:?}", t);
}