全部问题(coding)

我想知道为什么会出现这种情况，因为它与我的预期相反。这与 C# 中如何解释通用可空类型有关。

  public static int? MyFunction(){
    return default;
  }

  public static T MyFunctionGeneric<T>() {
    return default;
  }

  public static T? MyFunctionGenericNullable<T>(){
    return default;
  }

  public static void main(string[] args){
    Console.WriteLine(MyFunction());
    Console.WriteLine(MyFunctionGeneric<int?>());
    Console.WriteLine(MyFunctionGenericNullable<int>());
  }

正如预期的那样，当我将返回类型定义为int?默认返回值时null。

当我定义一个返回自身类型的泛型时也是这样的，因为int?传入了，所以默认返回值是null。

然而，在第三种情况下，即使返回类型从技术上讲是int?，默认返回值也是0。我必须传入int?作为我的类型参数才能获得null响应。请注意，即使我明确声明return default(T?)

这有点出乎意料，有人可以解释一下吗？

我一直在 Rust 中研究 Future 实现，但遇到了一些我无法完全理解的行为。具体来说，我在方法std::sync::mpsc::Receiver内部使用poll，并尝试在while let和之间做出选择if let以接收消息。

这是我的轮询方法的简化版本：

fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
    let this = self.get_mut();

    // Option 1: Using `while let`
    while let Ok(new_attributes) = this.receiver.try_recv() {
        // Process the message
    }

    // Option 2: Using `if let`
    if let Ok(new_attributes) = this.receiver.try_recv() {
        // Process the message
    }

    Poll::Pending
}

我观察到的情况

当我使用 while let 时，一切似乎都按预期工作：当新消息到达时，Future 会重新轮询。但是，当我使用 if let 时，Future 似乎挂起了，并且永远不会再次唤醒，即使有新消息可用。

我的理解

我知道 Waker 应该用于通知执行者应该重新轮询 Future。鉴于我的轮询函数始终返回 Poll::Pending，我预计 Future 将继续被重复轮询，除非进程本身停止。但是，我不明白为什么 while let 确保 Waker 被正确触发，而 if let 似乎没有这样做。

其他背景信息

未来是这样产生的：

ctx.task_executor()
    .spawn_critical_blocking("transaction execution service", Box::pin(fut_struct));

spawn_critical_blocking 函数的工作原理如下：

pub fn spawn_critical_blocking<F>(&self, name: &'static str, fut: F) -> JoinHandle<()>
where
    F: Future<Output = ()> + Send + 'static,
{
    self.spawn_critical_as(name, fut, TaskKind::Blocking)
}

在内部：

fn spawn_critical_as<F>(
    &self,
    name: &'static str,
    fut: F,
    task_kind: TaskKind,
) -> JoinHandle<()>
where
    F: Future<Output = ()> + Send + 'static,
{
    // Wrapping the future and handling task errors
    let task = std::panic::AssertUnwindSafe(fut)
        .catch_unwind()
        .map_err(...);

    let task = async move {
        // Handling task shutdown and execution
        let task = pin!(task);
        let _ = select(on_shutdown, task).await;
    };

    self.spawn_on_rt(task, task_kind)
}

然后该spawn_on_rt方法使用spawn_blocking。

我的问题

• 为什么使用 while let 可以确保 Waker 被触发，但使用 if let
• 做

不是？

• 导致这种行为差异的根本机制是什么？

如有任何见解或解释我将不胜感激！

给定一个数组 A、错误的行索引和错误的列索引，是否可以使用切片来创建一个没有这些行或列的新数组？

可以使用 np.delete 完成如下操作：

import numpy as np
A=np.random.rand(20,16)
bad_col=np.arange(0,A.shape[1],4)[1:]
bad_row=np.arange(0,A.shape[0],4)[1:]
Anew=np.delete(np.delete(A,bad_row,0),bad_col,1)
print('old shape ',A.shape)
print('new shape ',Anew.shape)

我还知道可以使用切片从数组中选择某些列和行。但我想知道它是否可以用于排除某些列和行？如果不行，除了np.delete这样做之外最好的方法是什么。

编辑：根据评论，可能无法使用切片。使用高级索引创建新数组怎么样？

可以使用以下代码完成，但速度很慢，需要寻找更快的替代方案：

good_col = [i for i in range(A.shape[1]) if i==0 or i % 4 != 0]
good_row=[ i for i in range(A.shape[0]) if i==0 or i % 4 != 0]

Anew2=A[good_row,:][:,good_col]
print('new shape ',Anew2.shape)

谢谢

我有一个运行两个线程的小应用程序。

一个线程发送一个 UDP 多播数据包（到组 239.0.0.1），另一个线程读取同一个多播数据包。

当我使用 Visual Studio 在 Windows 上运行此应用程序时，它可以正常工作 - 数据包已成功发送和接收。我在 Wireshark 上看到了它。我还有一个嵌入式目标，此应用程序最终运行在该目标上，运行 VxWorks RTOS，并且它也可以在 VxWorks 上运行。

我在使用 WSL2 的 Linux 上尝试过。sendto() 成功，但 recvfrom() 失败。但是我在 Wireshark 上看到了数据包，并且 Wireshark 上没有报告任何错误。

我降级到 WSL1 并且它可以工作。

WSL2 中是否存在某些特定问题，可能会导致多播失败，但在 WSL1、Windows 和 VxWorks 上可以工作？如果我切换到单播，它可以在 WSL2 上运行。

以下是一些代码片段：

接收线程：

uint32_t  ip_addr_mgrp;
uint32_t  ip_addr_mifc;
inet_pton(AF_INET, (char*)"172.18.19.53", &ip_addr_mifc);
inet_pton(AF_INET, (char*)"239.0.0.1", &ip_addr_mgrp);

int fd = socket(AF_INET, SOCK_DGRAM, SOCKET_PROTOCOL);

struct sockaddr_in server_addr;

server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = ip_addr_mifc;
server_addr.sin_port = htons(45007);

bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));

struct ip_mreq mreq;
mreq.imr_multiaddr.s_addr = ip_addr_mgrp;
mreq.imr_interface.s_addr = ip_addr_mifc;

setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq));

// code to set to non-blocking

// Loop for reading

// Call select()
// Call FD_ISSET()
// Call recvfrom()

TX 线程：

uint32_t  ip_addr_mgrp;
uint32_t  ip_addr_mifc;
inet_pton(AF_INET, (char*)"172.18.19.53", &ip_addr_mifc);
inet_pton(AF_INET, (char*)"239.0.0.1", &ip_addr_mgrp);

int fd = socket(AF_INET, SOCK_DGRAM, SOCKET_PROTOCOL);

struct ip_mreq mreq;
mreq.imr_multiaddr.s_addr = ip_addr_mgrp;
mreq.imr_interface.s_addr = ip_addr_mifc;

setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq));

setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, (const char*)&mreq.imr_interface.s_addr, sizeof(struct in_addr));

char loop = 1;
setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, (char*)&loop, sizeof(loop));

// code to set to non-blocking

// Loop for sending

// Call sendto() to 237.0.0.1:45007

当我阅读的文档时fflush，它说如果成功则返回 0，否则返回 EOF（我的机器上的 EOF 为 -1）。（请参阅https://man7.org/linux/man-pages/man3/fflush.3.html或https://en.cppreference.com/w/c/io/fflush）

因此我创建了以下示例：

#include<cstdio>
#include<iostream>

int main()
{
    FILE* fp = std::fopen("/tmp/test", "w+");
    std::fclose(fp);

    std::cout << std::fflush(fp) << std::endl;
    return 0;
}

g++ minimal.cpp如果我使用或进行编译g++ -O2 -DNDEBUG minimal.cpp，它会打印 -1。这正是我所期望的。

g++ minimal.cpp -fsanitize=address但是，当我用或编译它时g++ minimal.cpp -fsanitize=thread，它只打印 0。

我也可以用 clang 重现同样的问题。

怎么会这样？

我在我的 Debian 12 amd64 机器上使用了 g++-12 和 clang-15。结果始终相同（即fflush返回 0 而不是 -1）。

这里：https: //logging.apache.org/log4j/2.x/manual/getting-started.html#best-practice-concat

关于在 log4j 中使用字符串连接，他们是这样说的：

更重要的是，这种方法很容易受到攻击！想象一下用户提供的 userId 包含以下内容：不存在的参数的占位符会触发失败：{} {} {dangerousLookup}

有人能解释一下为什么这很危险吗？我不明白字符串连接与这个“dangerousLookup”有什么关系。

我正在尝试将平面的账户余额列表转换为基于唯一代码列表的分层账户树列表。我不知道该如何解决这个问题，因为我不知道该采取什么步骤。

如果您考虑 Excel 表，那么帐户余额将是一行，而代码字段表示该行被分解为多少个级别的列。这实际上意味着第一个代码 [0] 是第一级，代码 [1] 将是下一个，依此类推。通过将帐户余额转换为帐户树，我希望正确地对每个级别（代码类型和代码）的 amountOut 求和，然后将其作为帐户树添加到 subAccounts 数组中。

下面我添加了所有使用的类型并提供了输入和输出的示例。

interface AccountBalance {
    id: string
    codes: Code[]
    amountOut: number
}

type Code = {
    id: string
    codeType: CodeTypes
    code: string
    description: string
}

enum CodeTypes {
    account = "account",
    responsible = "responsible",
    project = "project",
    object = "object",
    counterPart = "counterPart",
    free = "free",
}

type AccountTree = {
    id: string
    name: string
    code: string
    amountOut: number
    subAccounts: AccountTree[]
}

输入示例：

const accountBalances: AccountBalance[] = [
            {
                id: "671769fbd36fcd6c2c7f2d9b",
                codes: [
                    {
                        id: "671769fbd36fcd6c2c7f2c2d",
                        codeType: codeTypeEnum.account,
                        code: "1250",
                        description: "Column A",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bd5",
                        codeType: codeTypeEnum.responsible,
                        code: "17",
                        description: "Column B",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bf7",
                        codeType: codeTypeEnum.counterPart,
                        code: "20",
                        description: "Column C",
                    },
                ],
                amountOut: 24510549,
            },
            {
                id: "671769fbd36fcd6c2c7f2d9c",
                codes: [
                    {
                        id: "671769fbd36fcd6c2c7f2c2d",
                        codeType: codeTypeEnum.account,
                        code: "1250",
                        description: "Column A",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bee",
                        codeType: codeTypeEnum.responsible,
                        code: "40",
                        description: "Column B",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2c08",
                        codeType: codeTypeEnum.counterPart,
                        code: "S3",
                        description: "Column C",
                    },
                ],
                amountOut: 0,
            },
            {
                id: "671769fbd36fcd6c2c7f2d9d",
                codes: [
                    {
                        id: "671769fbd36fcd6c2c7f2c2d",
                        codeType: codeTypeEnum.account,
                        code: "1250",
                        description: "Column A",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bdb",
                        codeType: codeTypeEnum.responsible,
                        code: "80",
                        description: "Column B",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bdc",
                        codeType: codeTypeEnum.counterPart,
                        code: "52",
                        description: "Column C",
                    },
                ],
                amountOut: 6381398,
            },
        ]

我想要的输出，例如：

const expected: AccountTree = {
            id: "671769fbd36fcd6c2c7f2c2d",
            name: "Column A",
            code: "1250",
            amountOut: 30891947,
            subAccounts: [
                {
                    id: "671769fbd36fcd6c2c7f2bd5",
                    name: "Column B",
                    code: "17",
                    amountOut: 24510549,
                    subAccounts: [
                        {
                            id: "671769fbd36fcd6c2c7f2bf7",
                            name: "Column C",
                            code: "20",
                            amountOut: 24510549,
                            subAccounts: [],
                        },
                    ],
                },
                {
                    id: "671769fbd36fcd6c2c7f2bee",
                    name: "Column B",
                    code: "40",
                    amountOut: 0,
                    subAccounts: [
                        {
                            id: "671769fbd36fcd6c2c7f2c08",
                            name: "Column C",
                            code: "S3",
                            amountOut: 0,
                            subAccounts: [],
                        },
                    ],

                },
                {
                    id: "671769fbd36fcd6c2c7f2bdb",
                    name: "Column B",
                    code: "80",
                    amountOut: 6381398,
                    subAccounts: [
                        {
                            id: "671769fbd36fcd6c2c7f2bdc",
                            name: "Column C",
                            code: "52",
                            amountOut: 6381398,
                            subAccounts: [],
                        },
                    ],
                },
            ],
        }

到目前为止我得到的是

const uniqueCodeTypes = [
        ...new Set(
            accountBalances.reduce<CodeTypes[]>(
                (acc, balance) => [
                    ...acc,
                    ...balance.codes.flatMap((code) => code.codeType),
                ],
                [],
            ),
        ),
    ]

    const uniqueCodesForCodeType = uniqueCodeTypes.map((codeType) => {
        const uniqueCodesForCodeType = [
            ...new Map(
                accountBalances.reduce<Code[]>((acc, balance) => {
                    const code = balance.codes.find(
                        (code) => code.codeType === codeType,
                    )
                    return code ? [...acc, code] : acc
                }, []).map((code) => [code.code, code])
            ).values(),
        ]
        return uniqueCodesForCodeType
    })

但我不知道此后该如何继续。

如果这个问题之前有人问过，我很抱歉，这个问题确实困扰了我几个小时，看起来相对简单。我在单个文件中通过 awk 识别了两个模式。

awk '/\[code\.change\..*\]/ {found=1; print; next} found && NF {print} found && !NF {exit}' filename
awk '/\[code\.test\..*\]/ {found=1; print; next} found && NF {print} found && !NF {exit}' filename

我可以将这两个 awk 合二为一来交换块吗？

配置文件的示例如下： file.cfg

[code.change.1]
file.path=filename
file.contact=manager
file.active=TRUE

[code.test.1]
ls -la filepath
pwd
find . -name filename

只需交换配置的顺序即可。谢谢

我有一个使用 GridPane 构建带有 TextFields 数组的网格的类。我需要将此网格插入到只接受 setContent() 方法中的 Node 的 ScrollPane 中。因此我从 GridPane 扩展了此类。Grid 类由 MainViewController.java 类的 onMnuItemNewAction 方法在 ScrollPane 中实例化和设置，但网格未显示。感谢您的帮助。

主视图.fxml

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.control.Menu?>
<?import javafx.scene.control.MenuBar?>
<?import javafx.scene.control.MenuItem?>
<?import javafx.scene.control.ScrollPane?>
<?import javafx.scene.layout.BorderPane?>
<?import javafx.scene.layout.VBox?>

<BorderPane prefHeight="277.0" prefWidth="495.0" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1" 
fx:controller="br.com.ablogic.crossword.MainViewController">
    <top>
       <VBox prefWidth="100.0" BorderPane.alignment="CENTER">
         <children>
            <MenuBar fx:id="mnuBar" prefHeight="25.0" prefWidth="360.0">
              <menus>
                <Menu mnemonicParsing="false" text="File">
                  <items>
                    <MenuItem fx:id="mnuItemNew" mnemonicParsing="false" onAction="#onMnuItemNewAction" text="New grid" />
                  </items>
                </Menu>
              </menus>
            </MenuBar>
         </children>
      </VBox>
   </top>
   <center>
      <ScrollPane fx:id="scpGrid" fitToHeight="true" fitToWidth="true" pannable="true" style="-fx-background-color: #dbbb92; -fx-background: #dbbb92;" BorderPane.alignment="CENTER" />
   </center>
</BorderPane>

主程序

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.stage.Stage;
import java.io.IOException;

public class Main extends Application {
    @Override
    public void start(Stage stage) throws IOException {

        FXMLLoader fxmlLoader = new FXMLLoader(Main.class.getResource("MainView.fxml"));
        Scene scene = new Scene(fxmlLoader.load(), 800, 600);
        stage.setTitle("Grid Demo");
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }

}

MainViewController.java（调用方法）

import javafx.geometry.Pos;
import javafx.scene.control.MenuItem;
import javafx.scene.control.ScrollPane;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import java.net.URL;
import java.util.ResourceBundle;

public class MainViewController implements Initializable {

    @FXML
    private MenuItem mnuItemNew;

    @FXML
    private ScrollPane scpGrid;

    @FXML
    public void onMnuItemNewAction() {
        int cols = 10;
        int rows = 10;
        int horizontalGap = 1;
        int verticalGap = 1;
        int fieldHorizontalSize = 40;
        int fieldVerticalSize = 40;
        var newGrid = new Grid(cols, rows, horizontalGap, verticalGap, fieldHorizontalSize, fieldVerticalSize);
        scpGrid.setContent(newGrid);
        newGrid.setAlignment(Pos.CENTER);
    }

    @Override
    public void initialize(URL url, ResourceBundle rb) {

    }

}

网格.java

import javafx.fxml.Initializable;
import javafx.scene.control.TextField;
import javafx.scene.layout.GridPane;
import java.net.URL;
import java.util.ResourceBundle;

public class Grid extends GridPane implements Initializable {
    private final int totalColumnFields;
    private final int totalRowFields;
    private final int horizontalGap;
    private final int verticalGap;
    private final int fieldHorizontalSize;
    private final int fieldVerticalSize;
        
    public Grid(int totalColumnFields, int totalRowFields, int horizontalGap, int verticalGap, int fieldHorizontalSize, int fieldVerticalSize) {
        this.totalColumnFields = totalColumnFields;
        this.totalRowFields = totalRowFields;
        this.horizontalGap = horizontalGap;
        this.verticalGap = verticalGap;
        this.fieldHorizontalSize = fieldHorizontalSize;
        this.fieldVerticalSize = fieldVerticalSize;
    }

    @Override
    public void initialize(URL url, ResourceBundle rb) {

        this.setHgap(horizontalGap);
        this.setVgap(verticalGap);
        TextField[][] arrayLetterField = new TextField[totalColumnFields][totalRowFields];

        for (int row = 0; row < totalRowFields; row++) {
            for (int col = 0; col < totalColumnFields; col++) {
                arrayLetterField[col][row] = new TextField();
                arrayLetterField[col][row].setMinSize(fieldHorizontalSize, fieldVerticalSize);
                arrayLetterField[col][row].setMaxSize(fieldHorizontalSize, fieldVerticalSize );
                this.add(arrayLetterField[col][row], col, row);
            }
        }            
    }    
}

我有以下数据：

df <- structure(list(id = c("1358792", "1358792", "333482", "333482", "747475", "747475"),
                     x = c("123", "123", "456", "456", NA, NA),
                     all_x = list("123", "123",
                                  c("456", "789"),
                                  c("456", "789"),
                                  list(),
                                  list())),
                row.names = c(NA, -6L),
                class = "data.frame")
    
       id    x    all_x
1 1358792  123      123
2 1358792  123      123
3  333482  456 456, 789
4  333482  456 456, 789
5  747475 <NA>     NULL
6  747475 <NA>     NULL

all_x 列是一个包含 EMPTY/NULL 值、单个字符或字符向量的列表。

我想创建一个新列（tidyverse 样式），其逻辑如下：当列all_x有一个值或没有值时，只需从中取值x。如果它有两个值（即字符向量），我们希望按id行号分组并取对应的元素，即对于第一个 id 值，取字符向量的第一个元素，对于第二个 id 元素，取第二个字符值，依此类推。

所需的输出将是一个带有相应值的附加字符列，即

       id    x    all_x   x2
1 1358792  123      123  123
2 1358792  123      123  123
3  333482  456 456, 789  456
4  333482  456 456, 789  789
5  747475 <NA>     NULL <NA>
6  747475 <NA>     NULL <NA>

我已尝试过多种变体，包括if_else，ifelse以及取消列出和索引，但由于all_x列的混合结构，仍然总是会出现错误。

以下是我得到的最接近的答案：

library(tidyverse)
df |>
  mutate(x2 = if_else(lengths(all_x) > 1, all_x[[1]][row_number()], x), .by = id)

但是，显然，我没有成功。