小编Ars*_*min的帖子

由于我使用了大量相同指令和.css类的输入,我想将重复的代码提取到某个组件,如下所示:

  @Component({
  selector: "app-input",
  template: `
    <div class="...">
      <input type="..." name="..." class="..." [(ngModel)]="value" someDirectives...>
      <label for="...">...</label>
    </div>
  `,
  ...
  })
  export class InputComponent implements OnInit {
    // some implementation connecting external ngModel with internal "value" one
  }

这里的问题是以这样的方式创建一个组件,它可以与ngModel一起用作普通输入:

<app-input [(ngModel)]="externalValue" ... ></app-input>

我在互联网上找到了几个可以部分或完全过时的解决方案,如: Angular 2自定义表单输入 这可以在角度6中以更好的方式完成吗？

我想data使用库函数交换切片的元素,但由于多次借用它不起作用:

mem::swap(&mut data[i], &mut data[j]); //error

它可以像往常一样手动完成:

let temp = data[i];
data[i] = data[j];
data[j] = temp;

但我不认为每次使用这段代码都很棒.是否有任何其他解决方案通常使用库交换切片？

根据DynamoDB doc:https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-general-nosql-design.html

"您应该在DynamoDB应用程序中维护尽可能少的表.大多数设计良好的应用程序只需要一个表."

但根据我的经验,由于分区键设计,你总是要做相反的事情.

让我们考虑下一个情况.我们有几个用户角色,例如"admin","manager","worker".管理员的常用工作流程是CRUD管理器数据,其中读取操作不是一个管理员而是所有管理员列表.同样是经理 - 他CRUD工人数据.对于这两种情况,我们只有两种关键用法:

• 获取所有项目的列表(项目键无关紧要)
• 使用其完整密钥处理特定项目.

当然,我们应该有统一分布的分区键(正如文档强调的那样),所以我们不能为它选择用户角色,应该使用用户ID.由于我们已经将分区键作为一个随机ID,因此我们根本不需要排序键,因为它根本不起作用 - 我们只使用分区键部分就可以访问一个用户.此时我们意识到用户ID就像CUD操作的魅力一样,但对于每个R操作,我们需要扫描所有表,然后按用户角色过滤结果,这是无效的.如何改进？非常自然 - 让每个用户类型都有自己的表!然后我们将从管理员API扫描管理员列表,从管理员列表扫描员工列表.

我使用DynamoDB差不多一年了,仍然无法得到它.对我来说,现实情况是,对于现实生活场景,排序键是你永远不能使用的东西(我唯一的真实情况是访问属于同一时间的两个不同类型用户的"协议"项,所以主键是{partion:"managerId",sort:"userId"},二级全局索引是{partition:"userId",sort:"managerId"}所以我可以有效地查询所有特定的经理协议列表或所有特定用户协议列表仅提供查询的相应管理器或用户ID.该方法在以下文档中讨论:https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html).

我觉得我根本不理解这个概念.对于两个用户类型,只使用一个 DynamoDB表,提供示例的关键模式的有效方法是什么？

我使用 VS Code 开发 AWS 托管的无服务器应用程序。该应用程序使用 Lambda。最近，我决定开始使用 Lambda Layers 来提取和重用公共代码。我遇到的问题是 AWS Lambda 需要 Lambda 层的以下导入：

const layer = require("/opt/layer");

我想在层导出函数上获得智能感知：

module.exports = {
    f1(param1, param2) {
        // ...
    },

    f2(paramX, paramY, paramZ) {
        // ...
    }
}

尽管我同时拥有 lambda 和 lambda 层代码，但 VS Code 自然无法解析层文件的路径，因此 Intellisense 不起作用。

我发现如果我将下一个 jsconfig.json 文件放在项目中的任何位置：

{
    "compilerOptions": {
        "target": "ES6",
        "module": "commonjs"
    },
    "exclude": [
        "node_modules",
        "**/node_modules/*"
    ]
}

require 语句停止显示为红色，并且允许一些基本文本自动完成。但它并没有真正正确地显示带有参数的图层导出函数。

我不想创建解决方案，例如在开发期间使用自定义导入，然后在部署到 AWS 期间用“require(”/opt/layer”)”替换它们（或者至少有一些自动化的东西）。

可以做什么？

我有一个data编译时大小未知的向量.我想创建一个确切大小的新矢量.这些变体不起作用:

let size = data.len();

let mut try1: Vec<u32> = vec![0 .. size]; //ah, you need compile-time constant
let mut try2: Vec<u32> = Vec::new(size); //ah, there is no constructors with arguments

我有点沮丧 - 在Rust API,book,reference或rustbyexample.com中没有关于如何使用vector执行这样简单的基本任务的任何信息.这个解决方案有效,但我不认为这样做很好,一个接一个地生成元素很奇怪,我不需要任何精确的元素值:

let mut temp: Vec<u32> = range(0u32, data.len() as u32).collect();

在我的游戏应用程序中，我希望有一个用于处理套接字连接和授权的通用类以及几个用于事件处理的类，如下所示：

//loading game/lobby/other socket routers
...

var socketRouter = function(server) {
    var io = Io(server);

    io.use(socketioJwt.authorize({
        secret: config.secretKey,
        handshake: true
    }));

    io.on("connection", function(socket) {
        lobbySocketRouter(socket);
        gameSocketRouter(socket);
        //other routers
        ...

        socket.on("disconnect", function() {
            console.log("DISCONNECTED", socket.id);
        });
    });
};

为不同的路由器生成唯一的事件名称以互不干扰不是问题。问题在于断开连接事件 - 我希望每个路由器都有可能对其执行正确的操作。在每个路由器中添加自己的处理程序来断开事件是否正确，这样每个路由器都会触发：

        //lobbySocketRouter
        socket.on("disconnect", function() {
            //handling lobbySocketRouter special actions
        });
...
        //gameSocketRouter
        socket.on("disconnect", function() {
           //handling gameSocketRouter special actions
        });

？

我的程序中有这种惰性的初始化代码：

let user = null;        
let getUser = async () => {
  if(!user) {
    user = await getUserSomehow();
  }
  return user;
};

我了解这是不安全的，因为如果我有下一个代码，可能会出现竞争情况：

// one place of the program
let u1 = await getUser();
...
// another place of the program running during getUserSomehow() for u1 still hasn't finished
let u2 = await getUser();

getUserSomehow() 将被调用两次而不是一次。

如何避免这种情况？

我有 Lambda，它对 DynamoDB 执行多次调用，创建一个大型字符串化 JSON 对象作为响应，并通过 API 网关传递到客户端应用程序。当然，API Gateway 具有“启用内容编码”选项集，并且所有数据都以压缩形式通过互联网传递。

问题在于 Lambda 响应本身未压缩，并且达到了 6MB 响应限制。是否可以压缩 Lambda 响应，然后以某种自然的方式在客户端解压缩？

我检查了 JSZip 和 ADM Zip 等 Node.js 库，令我惊讶的是，尽管它们允许在内存中输出解压数据，但它们不允许在内存中输入，如字符串、缓冲区或其他内容，而仅允许文件。Lambda 已经有一些与处理文件相关的限制和意外，因此我想避免以下冗余工作流程：

1. 创建 JSON 对象
2. 将其保存为 lambda 环境中的临时文件
3. 通过压缩库加载文件进行压缩并返回API网关

有没有更自然的方法来处理这个问题？

在代码块可以以逗号结束或不以逗号结束时,Rust中存在许多情况.例如:

enum WithoutComma 
{
    x,
    y
}

要么

enum WithComma
{
    x,
    y,
}

还有其他"匹配"等的例子.似乎两种变体都会产生相同的结果.现在我知道放置或删除逗号更改行为的唯一情况,它是1元素元组声明(但它不是块):

let just_int = (5);
let tuple = (5,);

问题是为什么在块的末尾可以使用逗号？为什么语言中存在这种二元论,其原因是什么？

阅读 Amazon DynamoDB 文档，我仍然无法理解将它用于最常见任务的最佳方式是什么 - 拥有多种类型的文档（例如，“用户”、“事件”、“新闻”），所有文档都具有唯一的 ID . 据我了解，由于 DynamoDB 仅暗示对文档主键的限制，我们可以在其中存储任何具有主键的数据。因此，最自然的解决方案看起来像：

- partion key 'type' is document type - 'user', 'event' etc
- sort key is uuid

但这与官方文档相矛盾，根据它，更好的是：

- partition key 'id' is just uuid
- sort key is type - 'user', 'event'

但由于关键名称，这与常识相矛盾。最后，我们可以为用户、事件和新闻创建 3 个不同的 DynamoDB 实例，所有实例都使用 uuid 作为分区键，没有排序键。哪种解决方案是 DynamoDB 使用的最佳或常见做法？

有时我的 angular 应用程序会更新。该应用程序已经上线，一些常见的使用场景是当用户根本没有关闭带有应用程序的浏览器选项卡时，因此可以永远使用没有检查的过时版本。

我已经实现了一种机制来检查后端端的应用程序版本，因此所有来自过时版本的调用都会被拒绝。

下一步是向用户显示一些“需要更新”对话框，以防出现此类后端拒绝和确认的情况，最好不要强制用户手动按“Ctrl + F5”，而是从应用程序自动执行.

是否可以？

现在我从类中获得了线程安全字段的实现:

int A::GetValue() const
{
    _mutex.Lock();
    int temp = _value;
    _mutex.Unlock();
    return temp;
}

我想用这样的锁/范围保护实现替换它(LockGuard类只有构造函数/析构函数和Mutex*_mutex字段):

LockGuard::LockGuard(Mutex & mutex) : _mutex(&mutex)
{
    _mutex->Lock();
}

LockGuard::~LockGuard()
{
    _mutex->Unlock();
}

并重构代码:

int A::GetValue() const
{
    LockGuard lockGuard(_mutex);
    return _value;
}

我突然意识到我不确定这是否安全实施.是否保证首先将_value的副本传递出函数,并且只有已经存在此副本的_mutex才会被解锁？请不要提供C++ 11替代实现示例 - 我有嵌入式系统,不幸的是不能使用它们.

我是Rust的新手,我正在尝试找到解析文本文件的最简单有效的方法,如:

1
2
3
4
5

到我的代码中的u32向量.现在我有一个解决方案,用于读取文件作为字符串(它正好来自rustbyexample.com,我稍微改了一下):

let path = Path::new("J:/IntegerArray.txt");
let display = path.display();

let mut file = match File::open(&path)
{
    Err(why) => panic!("couldn't open {}: {}", display, why.desc),
    Ok(file) => file,
};

let data_str = match file.read_to_string()
{
    Err(why) => panic!("couldn't read {}: {}", display, why.desc),
    Ok(string) =>
    {
        string
    }
};

然后我解析它:

let mut data : Vec<u32> = vec![];

for str in data_str.lines_any()
{
    data.push(match str.trim().parse() { Some(x) => x, None => continue, } );
}

但是我认为有一个解决方案可以在没有循环的情况下在一行中完成,例如: …