Don2Quixote's questions

我为 mongodb 创建了数据库连接池：

type dbcp struct {
    sync.Mutex
    connections map[*mongo.Client]struct{}
}

3个主要功能dbcp：

func newDBConnection() *mongo.Client {
    // Возвращает новое соединение
}

func getDBConnection() *mongo.Client {
    if len(dbcp.connections) {
        // Если пул не пустой, возвращает соединение из пула
    }
    // Если пул пустой, возвращает новое соединение:
    return newDBConnection():
}

func (c *mongo.Client) release() {
    // Добавляет соединение в пул и устанавливает таймаут
    // закрытия этого соединения и удаления из пула
}

每个请求有条件地/test?id=123打开一个连接，id=123从数据库中获取数据，使用该方法将连接发送到池c.release()

无论有多少请求同时进入 - 1000、2000 或 10000，我的计算机上池中的连接永远不会超过 6 个。我是否正确理解Gogoroutine 中处理的每个请求都会阻塞一个线程？我一直认为 goroutine 在等待 I/O 操作时会自行切换（也就是说，它们不会阻塞）。如果是这样，如何处理？如何让一台服务器同时支持大量连接？

UPD：我检查了Node.js- 连接数仍然是 6，尽管该语言是在单线程环境中解释的。

带文档的条件集合：

{ _id: ObjectId(...), value: 19293 },
{ _id: ObjectId(...), value: 32123 }

我想删除所有文档 where value % 1000 == 123，以便集合留下：

{ _id: ObjectId(...), value: 19293 }

我知道如何找到正确的文件aggregate-

db.test.aggregate([
    { $addFields: { filterValue: { $mod: ["$value", 1000] } } },
    { $match: { filterValue: 123 } }
])

然后你可以删除你找到的东西。但我有兴趣立即删除 中的必要文​​件db.test.deleteMany({ ??? })，无需进行初步搜索。我不能这样做：

db.test.deleteMany({
    { $mod: ["$value", 1000] }: 123
})

怎么做才对？

一个托管在不同端口（81 和 82）上托管 2 个应用程序。Nginx 侦听端口 80，根据请求子域，它代理到所需的应用程序。例如：app1.domain.com和app2.domain.com

这些指令nginx是：

• proxy_pass: http://domain.com:81/events- 请求/events，因为这是连接到 websocket 的 URL，为此您需要添加单独的指令
• proxy_pass: http://domain.com:81/- 对于所有其他请求

第一个问题：

checkOrigin该应用程序使用 websockets，默认情况下库中的实现检查 Origin 标头和请求 URL 之间的匹配（在 librarygorilla/websocket中以 language调用函数Go） - 因此请求失败，因为 Origin:app1.domain.com/events和请求网址：domain.com:81/events. 该库允许您重新定义函数checkOrigin，以便它始终返回true并跳过请求。但我对如何代理来自 nginx 的请求感兴趣，这样就不需要编辑应用程序本身的代码 - 也就是说，使 Origin 与请求 URL 匹配。

第二个问题：

我是否正确理解在这种情况下 ( proxy_pass: http://domain.com/) 请求再次通过 DNS，从而增加了响应之前的延迟？我是否理解正确，那么最好做什么或proxy_pass: http://localhost:81/添加一行？127.0.0.1 domain.com/etc/hosts

我想将命令的输出写入变量netctl list。如果在终端调用它，输出将是这样的：

* WIFI-1
  WIFI-2
  WIFI-3

星号“*”表示活动的 Wi-Fi 配置文件。但是，如果您尝试将此输出写入变量：

profiles=$(netctl list)

然后将删除所有到新行的转换，以及星号“*”。也就是说，变量将是：

WIFI-1 WIFI-2 WIFI-3

如何改变 bash 的这种行为？

更新：

这是一个场景：

#!/usr/bin/bash

profiles=$(netctl list)

echo $profiles

一般显示

wifi.sh WIFI-1 WIFI-2 WIFI-3

其中“wifi.sh”是脚本文件的名称。毕竟，我不会在任何地方显示这个名字。

我需要编写一个函数来测量文件大小（以字节为单位）。这是发生的事情：

#include <stdio.h>
#include <stdint.h>

uint64_t file_size(char *file_path) {
    FILE *file = fopen(file_path, "rb");
    uint64_t size = 0;
    for (; fgetc(file) != EOF; size++);
    fclose(file);
    return size;
}

int main() {
    printf("%llu\n", file_size("file"));
    return 0;
}

一切正常。然后我就产生了兴趣EOF。毕竟，它只是一个等于 的常数-1。如果文件将包含一个字节-1（即FF）怎么办？

我编写了一个程序，它创建一个三个字节的文件，每个字节都是FF.

fputc(-1, file); fputc(-1, file); fputc(-1, file);

用 hexdump'om 重新检查该文件确实包含 3 个字节 ( FF FF FF)。

然后我使用函数检查了文件大小，该函数的代码是我一开始写的。该函数返回正确的大小 - 3 个字节。

我将函数中的循环从

for (; fgetc(file) != EOF; size++);

在

for (char c = fgetc(file); c != EOF; c = fgetc(file), size++);

我又查了一下——函数开始返回文件大小为0，因为第一个字节等于EOF，即文件结束常量。客观地说，这个功能应该和它一样工作。怎么了？这个怎么运作？文件结尾常量 EOF 如何等于文件中的字节之一？这是谁想出来的？也许我错过了什么？我检查了一切10次。魔法。

char *data = malloc(5);
data++;
free(data);

程序将如何处理这样的代码？内存会从新地址中释放出来，还是什么都不会释放？

有一个代码：

#include <stdlib.h>

struct Data {
    int size;
    char *bin;
};

int main() {
    struct Data *data = (struct Data *) malloc(sizeof(struct Data));
    data->bin = (char *) malloc(3);
    data->size = 3;
    free(data);
}

它会释放free(data)指向的内存data->bin吗？

我有 Windows x64。我想使用 NASM 为这个系统在汇编程序中编写一些工作（尽管世界你好）。在 DosBox 下，一切都变得比以往更容易，在 dosbox 中编译、启动——它可以工作。

$ nasm -f bin code.asm -o main.com

在 Windows 下 - 不可能弄清楚是什么。试过：

$ nasm -f win64 code.asm -o main.exe

试过：

$ nasm -f win64 code.asm -o code.o
$ gcc code.o -o main.exe

试过：

$ nasm -f elf code.asm -o code.o
$ gcc code.o -o main.exe

没有任何效果。我不明白你为什么需要使用链接器？为什么dosbox代码只是一系列命令，而Windows代码由部分组成.text，.data而其他...

例如，我想在 Windows 上执行此操作，而不是在 DosBox 中：

mov ah, 0x2
mov dl, 'X'
int 0x21
ret

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *numbers = (int *) malloc(sizeof(int) * 3);
    numbers[0] = 2; numbers[1] = 3; numbers[2] = 4;
    numbers = numbers + 1;
    /* Далее ещё какой-то код */
    return 0;
}

为 type 的 3 个值分配内存int，然后将指向该内存区域的指针右移。

指针左侧的内存是否被认为是空闲的，还是仍然是垃圾？将来使用它是否安全？

设置此类路由的处理：

app.get('/users/:username', (req, res) => {
    let username = req.params.username;
    // ...
});

如果昵称username不包含任何特殊字符，则一切正常。也就是说，当通过引用传递时，正确的值会被写入http://localhost/users/Don2Quixote到变量中。username如果昵称看起来像这样：new_user#0003，那么“#0003”部分将被丢弃，username只有new_user.

此外，如果您使用req.originalUrl，输出将是/users/new_user：我敢假设，有必要使用 URL Encode 吗？

该怎么办？

void *copy(void *element, size_t element_size) {
    void *element_copy = malloc(element_size);
    *element_copy = *element; // incomplete type 'void' is not assignable
    return element_copy
}

void实际上，我不能使用指向. 可以做什么？如何将指针转换为指向element_copy某个抽象(?)*element类型的指针，我可以用它从to写入值*element_copy？

#include <stdio.h>

int main(void) {
    int *arr;
    arr[0] = 2;
    arr[1] = 3;
    printf("%d, %d", *arr, *(arr + 1));
    getchar();
    return 0;
}

代码使用在线 IDE（repl.it，C 代码在 OS Linux 下运行）正常启动和运行，但在我的计算机（Windows 10）上发生了一些奇怪的事情。编译 ( gcc main.c -o main) 时，不会发生错误，但程序不会执行任何操作。一个空的控制台打开 1-2 秒然后消失。

如果在初始化指向数组的指针时，将函数执行的结果分配给它malloc，那么一切都会正常工作。

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *arr = (int *) malloc(sizeof(int) * 2);
    ...
}

它真的与操作系统有关吗？在这种情况下，我在哪里可以了解程序的行为？

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>  

typedef bool (*pf_bool)();

bool is_less_than_10(int);
int* intarr_filter(int[], int, pf_bool, unsigned*);

int main(void) {
    int arr[] = {1, 10, 3, 6, 9, 22, 1, 20, 17, 9, 5, 14, 2, 1, 12, 11};
    int sorted_arr_length;
    int* sorted_arr = intarr_filter(arr, sizeof(arr) / sizeof(arr[0]), is_less_than_10, &sorted_arr_length);
    for (int i = 0; i < sorted_arr_length; i++) {
        printf("%d ", sorted_arr[i]);
    }
}

bool is_less_than_10(int number) {
    return number < 10;
}

int* intarr_filter(int arr[], int length, pf_bool pf, unsigned* sorted_arr_length) {
    int fits = 0;
    for (int i = 0; i < length - 1; i++) {
        if (pf(arr[i])) fits++;
    }
    int* sorted_arr = (int*) malloc(sizeof(int) * fits);
    *sorted_arr_length = fits;
    int current_index = 0;
    for (int i = 0; i < length - 1; i++) {
        if (pf(arr[i])) {
            sorted_arr[current_index] = arr[i];
            current_index++;
        }
    }
    return sorted_arr;
}

有一个函数intarr_filter使用传递的函数过滤数组的值，并返回一个指向只包含匹配值的新数组的指针。我可以安全地传递一个函数is_less_than_10并获得预期的结果。但是如果我需要一个带有多个参数的过滤函数呢？如果我有这样的功能怎么办：

bool is_less(int number1, int number2) {
    return number1 < number2;
}

如果我不提前知道我需要比较什么数字怎么办？如何将多个参数传递给我传入的回调函数intarr_filter？

#include <stdio.h>
#include <stdlib.h>

int* create_arr(int number1, int number2, int number3) {
    int* arr = (int*) malloc(sizeof(int) * 3);
    arr[0] = number1;
    arr[1] = number2;
    arr[2] = number3;
    return arr;
}

int main(void) {
    int* arr = create_arr(2, 3, 4);
    printf("%lu\n", sizeof(arr));
}

printf在main输出中4。这是有道理的，因为这就是指针在我的系统上占用的字节数。但是如果我想显示结果数组的所有值呢？如何找到数组的结尾？

在上面的示例中，我当然知道该函数create_arr创建了一个包含 3 个值的数组，但我正在尝试创建一个返回匹配值数组的数组过滤器函数。这样一个数组的大小将取决于原始数组，我不知道它会是什么。那该怎么办？如何显示结果？

例如，有 Visual Studio Code，它在安装期间提供将自身添加到上下文菜单中。然后可以使用 VSC 通过上下文菜单在文件管理器中打开文件。我有一个用 Python 3 编写的简单应用程序。我这样称呼它：

$ python3 encdec e text.txt output.ena // Ключ "e" - "encode"
$ python3 encdec d output.ena decoded.txt // Ключ "d" - "decode"

我希望我可以使用上下文菜单来做到这一点。有条件地 - 按钮“使用 encdec 编码”和“使用 encdec 解码”。重要的是您可以在 Windows 和 Linux 上执行此操作。

我没有在互联网上找到如何做到这一点。

有一个代码：

let x = 5;
let formula = '2 + 4';
ley y = ...;

我如何使用它来y使用公式为新变量赋值'2 + 4'？我可以将公式转换为这样的数组：['2', '+', '4']. 接下来，找到数组中的数学运算，得到这个数学运算的结果，其中两个操作数位于数组的左侧和右侧。

在这种情况下如何：

let x = 5;
let formula = 'x + 4';
let y = ...;

? 因为那样我就能做到['x', '+', '4']。我无法使用变量来计算它x。eval不考虑。这就是我正在寻找的替代方案。我也想没有图书馆，尽管它们是可以接受的。

有一个类Foo：

class Foo:

    def __init__(self, data = None):
        if data == None:
            self.__del__()

    def __del__(self):
        print('Error')

f = Foo()    # Error
print(f)     # <__main__.Foo object at 0x7fc1210de1d0>

我有这个问题：

如果创建了一个类的实例，我需要检查一个参数是否被传递data。如果不是，则应取消类创建。我从一个方法调用一个__init__方法__del__，但实例保留在内存中，这可以用print(f). 我已经这样做过一次，也许我忘记了什么，但我根本不明白：如何修复以及谷歌什么？

编码：

#include <stdio.h>

int main(void) {
    int arr[10];
    arr[0] = 1;
    arr[1] = 2;
    for (int i = 0; i < 10; ++i) {
        printf("arr[%d] = %d;\n", i, arr[i]);
    }
    return 0;
}

结论：

arr[0] = 1;
arr[1] = 2;
arr[2] = 0;
arr[3] = 0;
arr[4] = 4195632;
arr[5] = 0;
arr[6] = 4195344;
arr[7] = 0;
arr[8] = -669909312;
arr[9] = 32765;

是什么决定了屏幕上显示的值？

#include <stdio.h>
#include <stdlib.h>

union IFC {
    int i;
    float f;
    char c;
};

int main(void) {
    union IFC ifc = {.f = 3.14};
    printf("Union's float is %.2f\n", ifc.f); // 3.14
    ifc.i = 2;
    printf("Union's integer is %d\n", ifc.i); // 2
    ifc.c = 'A';
    printf("Union's character is %c\n", ifc.c); // A
    printf("Union's float is %.2f\n", ifc.f); // 0.00
    return 0;
}

此代码如何在计算机内存级别工作？联合使用时0.00y的值从何而来？我知道一个联合在任何允许的状态下（在我的情况下/ / ）占用相同的字节数。但是这些字节只存储一个值。为什么，如果符号“A”当前存储在那里，我仍然可以参考联合来获取实数吗？虽然它不是我曾经问过的，虽然它总是等于零，但它仍然返回。这个怎么运作？inf.finf.cintfloatcharinf.f

#include <stdio.h>
#include <stdlib.h>

union IFC {
    int i;
    float f;
    char c;
};

int main(void) {
    union IFC ifc = {5, 3.14, 'A'};
    printf("Union is -\ninteger: %d;\nfloat: %.2f;\ncharacter: %c;\n", ifc.i, ifc.f, ifc.c);
    return 0;
}

代码编辑器在第 11 行加下划线3.14。悬停在上面时，会弹出一个工具提示：“联合初始化程序中的多余元素。” 我的联合应该采用 3 个变量，并且它报告第二个变量已经过多。怎么了？

编译和执行输出将如下所示：