小编kfe*_*v91的帖子

if (someVar.hasOwnProperty('someProperty') ) {
 // do something();
} else {
 // do somethingElse();
}

什么是正确的使用/解释hasOwnProperty('someProperty')？

为什么我们不能简单地someVar.someProperty用来检查对象是否someVar包含具有名称的属性someProperty？

在这种情况下,什么是财产？

这个javascript检查什么属性？

在编写函数时，如何决定是引用还是使用输入参数？

例如，我应该这样做吗？

fn foo(val: Bar) -> bool { check(val) } // version 1

或者使用引用参数代替？

fn foo(val: &Bar) -> bool { check(*val) } // version 2

在客户端，如果我只有第二个版本但想要消耗我的价值，我必须这样做：

// given in: Bar
let out = foo(&in); // using version 2 but wanting to consume ownership
drop(in);

另一方面，如果我只有第一个版本但想保留我的参考，我必须这样做：

// given in: &Bar
let out = foo(in.clone()); // using version 1 but wanting to keep reference alive

那么哪个是首选，为什么？

做出此选择时是否有任何性能考虑？或者编译器是否使它们在性能方面等效，以及如何实现？

您什么时候想提供两个版本（通过特征）？在那些时候，您如何编写这两个函数的底层实现——您是否复制每个方法签名中的逻辑，或者您是否有一个代理到另一个函数？哪个到哪个，为什么？

我使用 ，在这方面取得了一些进展into_actor().spawn()，但我很难访问ctx异步块内的变量。

我将首先显示 Web 套接字处理程序的编译片段，然后是处理程序的失败片段，最后显示完整的代码示例以供参考。

工作片段：

聚焦比赛案例Ok(ws::Message::Text(text))

/// Handler for `ws::Message`
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWebSocket {
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        // process websocket messages
        println!("WS: {:?}", msg);
        match msg {
            Ok(ws::Message::Ping(msg)) => {
                self.hb = Instant::now();
                ctx.pong(&msg);
            }
            Ok(ws::Message::Pong(_)) => {
                self.hb = Instant::now();
            }
            Ok(ws::Message::Text(text)) => {
                let future = async move {
                    let reader = processrunner::run_process(text).await;
                    let mut reader = reader.ok().unwrap();
                    while let Some(line) = reader.next_line().await.unwrap() …

我想编写一个函数来读取文件的内容，并在失败时引发错误。我想从 python 脚本调用这个函数，所以我在下面提到了一些 Python 以防它可能相关。

正如我在评论中尝试显示的那样，可能会发生更多的工作，从而引发其他类型的错误，因此，如果可能的话，我想使用通用错误（如果 Rust 中可以实现）（？）。如何返回错误，以便可以对其进行处理并将其包装在 python 错误中，如图所示do_work？不确定我导致以下错误的方法是否方向正确。

fn work_with_text() -> Result<(), dyn std::error::Error> {
    let content = match std::fs::read_to_string("text.txt") {
        Ok(t) => t,
        Err(e) => return Err(e),
    };
    // do something with content that may cause another type of error (rusqlite error)
    Ok(())
}
    

#[pyfunction]
fn do_work(_py: Python) -> PyResult<u32> {
    match work_with_text() {
        Ok(_) => (0),
        Err(e) => {
            let gil = Python::acquire_gil();
            let py = gil.python();
            let error_message = format!("Error happened {}", e.to_string()); …

我有这个简单的通用函数：

fn add_five<T: Into<i32>>(t: T) -> i32 {
    5_i32 + t.into()
}

我想使用From特征而不是特征来表达Into，但是我尝试重构：

fn add_five<T, i32: From<T>>(t: T) -> i32 {
    5_i32 + <i32 as From<T>>::from(t)
}

抛出这个编译错误：

error[E0277]: cannot add `i32` to `i32`
  --> src/main.rs:24:11
   |
   |     5_i32 + <i32 as From<T>>::from(t)
   |           ^ no implementation for `i32 + i32`
   |
   = help: the trait `Add<i32>` is not implemented for `i32`

这很令人困惑，因为impl Add<i32> for i32标准库中确实有一个，那么真正的问题是什么？

我写 Laravel 代码已经有一段时间了。目前，我尝试从 github 克隆一个项目并在本地编辑。我在我的项目目录中安装了 composer 但不包含供应商文件夹，我尝试运行composer install但我给了我这个错误

Your lock file does not contain a compatible set of packages. Please run composer update

我该如何解决？

注意：我试过composer update在以前的克隆上运行，但没有奏效。

a是一个Vec<i32>可以在一个表达式中可变且不可变地引用的 a ：

fn main() {
    let mut a = vec![0, 1];
    a[0] += a[1]; // OK
}

我认为这个编译是因为i32implements Copy，所以我创建了另一种类型，Copy它像第一个例子一样实现和编译它，但它失败了：

use std::ops::AddAssign;

#[derive(Clone, Copy, PartialEq, Debug, Default)]
struct MyNum(i32);

impl AddAssign for MyNum {
    fn add_assign(&mut self, rhs: MyNum) {
        *self = MyNum(self.0 + rhs.0)
    }
}

fn main() {
    let mut b = vec![MyNum(0), MyNum(1)];
    b[0] += b[1];
}

操场

error[E0502]: cannot borrow `b` as immutable because it is also borrowed …

我想将一个相当深的 JSON 反序列化为 Rust 结构：

{
  "root": {
    "f1": {
      "f2": {
         "f3": 123
       }
    }
  }
}

推导时Deserialize，我将不得不创建太多的结构 - 对于上述 JSON 的每个级别一个：

struct Root {
  f1: Field1
}
struct Field1 {
  f2: Field2
}
struct Field3 {
  f3: Field3
}
// ...

有什么方法可以避免拥有这么多的结构。我没有找到任何对派生有帮助的属性。我想要这样的东西：

struct Root {
  // some attr?
  f3: u64
}

当然，可以实现自定义反序列化，但我想知道是否有默认的方法来实现这一点。

我想在我的react组件中有一个自动完成位置搜索栏，但是不知道如何实现它。该文件说包括

<script src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&libraries=places&callback=initMap" async defer></script>

在HTML文件中，然后有一个指向元素的初始化函数-我该如何使用我的react组件/ JSX来做到这一点？我想我必须导入api链接，但是我不知道从那里去哪里。

import React from 'react';
import "https://maps.googleapis.com/maps/api/js?key=MYKEY&libraries=places&callback=initMap";

const SearchBar = () => (   
    <input type="text" id="search"/> //where I want the google autocomplete to be
);

export default SearchBar;

我正在为康威的生命游戏学习 Rust WASM 教程。

调用文件中最简单的函数之一Universe.render（它用于渲染表示游戏状态的字符串）。当我运行时它会导致错误wasm-pack build：

Fatal: error in validating input
Error: failed to execute `wasm-opt`: exited with exit code: 1
  full command: "/home/vaer/.cache/.wasm-pack/wasm-opt-4d7a65327e9363b7/wasm-opt" "/home/vaer/src/learn-rust/wasm-game-of-life/pkg/wasm_game_of_life_bg.wasm" "-o" "/home/vaer/src/learn-rust/wasm-game-of-life/pkg/wasm_game_of_life_bg.wasm-opt.wasm" "-O"
To disable `wasm-opt`, add `wasm-opt = false` to your package metadata in your `Cargo.toml`.

如果我删除该函数，则代码构建时不会出错。如果我用以下函数替换它，构建将失败并出现相同的错误：

pub fn wtf() -> String {
    String::from("wtf")
}

似乎任何返回 a 的函数都会String导致此错误。为什么？

以下是我的全部代码：

mod utils;

use wasm_bindgen::prelude::*;

// When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
// …