主页 / user-169252

transient_loop's questions

Martin Hope
unsafe_where_true
Asked: 2025-04-06 02:54:30 +0800 CST
  • 6

我从 API 返回了一个非常长的 JSON 字符串。

基本上它看起来像这样： {"data":{.......},"needs_trial": false, "adjust_time": false,"attempts": 1234}

我需要该data部分内不包含“附录”的所有内容作为字符串。

我尝试在 Go 中解析 JSON 时采用通常的方法：

//fetch the data with http.Get into resp.Body

type MyData struct {
   Data map[string]interface{}
}

var data MyData
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
    return err
}

我当然得到了正确的部分，但现在显然map[string]interface{}。我没能将其转换回字符串...

定义Data字段MyDataasstring也失败。

我不能直接将其剪掉，因为前缀部分是固定的（{"data":），但尾随部分不是。

我不敢相信我还没能做到这一点，因此在这里问...我已经在这上面花了这么多时间，我可以接受反对票...

json
Martin Hope
unsafe_where_true
Asked: 2024-09-23 03:05:18 +0800 CST
  • 5

我正在编写一个命令行任务管理应用程序来自学 Rust。

到目前为止，我有一个 sqllite 和一个内存数据源。

pub struct TaskManager {
    source: Datasource, // here rustc complains
}

经理对 有一个引用Datasource，这是一个特征：

pub trait Datasource {
    type Settings;

    fn start(&self) -> Result<bool>;
}

Main 读取 cli args 并根据它们决定应该实例化哪个数据源。

然而 Rust 告诉我

“- rustc：必须指定关联类型的值 [E0191 Settings] ”source::Datasource

我理解必须在编译时指定类型，并且到目前为止两个源都已指定其类型。

impl Datasource for SqlLiteDataSource {
    type Settings = SqlLiteSettings;
}

impl Datasource for MemoryDataSource {
    type Settings = MemorySettings;
}

并且在解析 cli 参数时，将评估所有分支：

    pub fn new(datasource: Datasources) -> Self {
        let ds: Datasource = match datasource {
            Datasources::SqlLite { path } => SqlLiteDataSource::new(path.to_string()),
            _ => MemoryDataSource::new(),
        };
   }

事实上，rustc 在这里也抱怨同样的错误。

这个想法是每个具体实现都有自己的设置。那么我如何将通用特征变量分配给TaskManager，以便后端根据提供的源完成任务管理？

rust
Martin Hope
unsafe_where_true
Asked: 2024-09-19 01:26:24 +0800 CST
  • 5
 ~/rust/first
   src
  │  app
  │ │  src
  │ │ │  lib.rs
  │ │ └  entry.rs                  E
  │ └  Cargo.toml
  └  main.rs                     E 
   Cargo.lock                     
   Cargo.toml                     

这是我用 Rust 建立的第一个项目。

struct Entry{}在 中有一个。其部分中的src/app/src/entry.rs顶级Cargo.toml列表。-level定义了。members = ["src/app"][workspace]appCargo.toml[package]name="app"

在顶层main.rs我只有let app = app::Entry::new();，但是编译器说“使用未声明的板条箱或模块app”。

为什么在子目录中声明包“app”，然后将其定义为顶层工作区中的成员，这不足以Entry在顶层 main.rs 中看到？

如果我添加app = { path = "./src/app" }到该dependencies部分，那么它就可以工作。但是为什么有工作区成员呢？

我错过了什么？

rust
Martin Hope
unsafe_where_true
Asked: 2024-09-03 03:16:46 +0800 CST
  • 5
pub enum State {
   Started(Vec<Id>),
   InProgress,
   Terminated
}

pub trait Locker {
  async fn start(&mut self, id: Id) -> State; 
}

#[tokio::test]
async fn test_locker() {
   let State::Started(ids) = locker.start().await;
}

我理解编译器会抱怨test_locker没有解决所有的匹配问题。

但我不知道该如何解决这个问题。事实上，在这个测试中，我知道它只能是那种状态，所以我实际上不需要匹配。

我尝试了几件事：

let State::Started(ids) = locker.start().await;
assert!(matches!(ids, State::Started(ids)));

我以为这会失败，因为ids第一行中的已经输入为State::Started。

也尝试过通过声明let ids:Vec<Id>，但这似乎在某种不同的范围内，因为我不能这样做let State::Started(ids) = ...

我想我可以先进行匹配并忽略所有其他选项，但我觉得应该有一种更优雅的方式？

rust
Martin Hope
unsafe_where_true
Asked: 2024-08-27 11:07:21 +0800 CST
  • 4

这个问题可能已经有人问过了，可能措辞不同，但我找不到。如果这个问题因此被关闭，我很抱歉，但我之前确实尝试过。

其实问题很简单：

use std::collections::BTreeSet;

pub struct Service {
    blobs: BTreeSet<u16>,
}

impl Service {
    fn new() -> Self {
        let bt: BTreeSet<u16> = BTreeSet::new();
        Self { blobs: bt }
    }

    fn insert(&self, val: u16) -> bool {
        &self.blobs.insert(val);
        true
    }
    fn print(&self) {
        println!("{}", self.blobs.len());
    }
}
fn main() {
    let s: Service = Service::new();
    s.print();
    s.insert(4);
    s.print();
}

当编译这个时，我得到：

`self` is a `&` reference, so the data it refers to cannot be borrowed as mutable

我在这里理解的是，实际上，我不能只更新树集，因为它是不可变的。

所以我尝试了

pub struct Service {
    blobs: &'static mut BTreeSet<u16>,
}

和

  fn new() -> Self {
        let bt: &mut BTreeSet<u16> = &mut BTreeSet::new();
        Self { blobs: bt }
    }

但结果却如此 creates a temporary value which is freed while still in use （尽管原始错误仍然存​​在，所以现在我有两个......）

我知道我应该以某种方式使其BTreeSet可变，但该怎么做呢？

rust
Martin Hope
unsafe_where_true
Asked: 2024-03-07 00:34:14 +0800 CST
  • 3

我正在散列一个字符串。

let src = String::from("abcd12342020");
let h1 = sha2::Sha256::digest(&src.as_bytes());
let h2 = sha2::Sha256::digest(hex::decode(&src).expect("this is not hex"));

h1并且h2是不同的。其根本原因是什么？字节表示和十六进制解码有什么区别？（试图提供一个游乐场，但hex那里无法创建）

string
Martin Hope
transient_loop
Asked: 2024-03-02 05:35:09 +0800 CST
  • 5

首先：我是 Rust 的新手；学习。

这个问题很可能是由其他语言的思考引起的。因此，最好的解决方案很可能是以完全不同的方式进行。事情甚至还没有编译，所以如果代码有根本问题，我们深表歉意。

我正在定义我的第一个特质。特征函数有 2 个参数，它们将定义输出。

trait SkFormatter {
  fn to_sk(&self, key:Key, is_foreign: bool) -> String;
}

这个想法是，实现将采用一个字符串变量，然后根据键添加一个字符串，并附加一个字符串 if is_foreign（后一部分与问题无关）。

例如

MT-1c2af34
WD-54bdf36-FX
WD-ad3425b

由于这些字符串是不变的，我想我可以将其作为全局映射来完成。所以我首先创建了

pub enum Key {
  // there are 7 items, but keeping it short here
  Metal,
  Wood,
}

然后我想创建映射，事情开始变得棘手。首先尝试了 HashMap：

use std::collections::HashMap;
static KEY_TO_PRE:HashMap<Key,&str> = HashMap::from([
  (Key::Metal,"MT-"),
  (Key::Wood, "WD-"),
]);

但这是在抱怨

Key: std::hash::Hash不满足特征界限

这让我感到惊讶，因为它似乎表明该键不可散列，但我没有为其定义类型，并且我假设“类似单元”的枚举类型（如文档所示）是某种整数或者其他的东西？

我已经看到了这个match习惯用法，也许我应该在实现内部尝试一下（全局或静态的东西对我来说很臭），但我不清楚匹配的东西是否优化了重用，因为它会被一遍又一遍地调用。

刚刚学习...

rust