问题列表 - 第317999页

我有一个 Angular 应用程序，正在为其创建 Cypress E2E。

该应用程序的一个页面有一个表，其中第三列包含一个类名“link ng-star-inserted”的链接，我希望测试在找到特定行后单击该链接。

我实际上已经进行了执行此操作的测试 - 事实上该链接已被单击。

但它不是很优雅，它将 .click() 方法标记为错误（即使它确实有效）。

我正在寻找一种方法，让它不将 .click() 方法标记为错误。

这是我的代码...

cy.get(SELECTOR.dataTableBody).should('be.visible')
        .contains('tr', 'Text I am looking for in the row I want')
        .then($row => {
            cy.log('found it');
            cy.log('on row ' + $row.index());

            //Yes this is kind of ugly.  I tried it every other way I could think of and this is the only way it worked
            let cellWithLink = $row.find('td:nth-child(3)');
            cellWithLink.children().get(0).getElementsByClassName('link ng-star-inserted').item(0).click();
            
});

这是 IDE 将 click() 标记为错误的镜头 - 尽管它确实有效。

非常感谢！

我需要定义一个接受多个 3D 坐标作为参数的 C++ 模板。当这些坐标的所有维度都定义为单独的整数变量时，参数列表将变得非常长 - 3 个坐标需要 9 个参数，这使得模板难以使用。

因此，非常希望以使用编译时数组的方式声明模板。它们的默认参数也应该直接在模板声明的位置声明为值，而不是变量名。

经过一些实验，令我惊讶的是，我发现 GCC 13 将接受以下 C++ 程序std=c++20：

#include <cstdio>
#include <array>

template <
    std::array<int, 3> offset = {0, 0, 0}
>
struct Array
{
    void operator() (int i, int j, int k) 
    {
        printf("(%d, %d, %d)\n", i + offset[0], j + offset[1], k + offset[2]);
    }
};

int main(void)
{
    Array arr_default;
    arr_default(0, 0, 0);

    Array<{1, 1, 1}> arr;
    arr(0, 0, 0);

    return 0;
}

然而，clang 18 拒绝使用 …

我在网上搜索了Java中“new”的用法，它是用于创建一个全新的类实例。为什么需要通过“new”关键字明确指示？难道不明白构造函数调用会实例化一个新对象吗？例如，如果没有new，很明显会MyClass AnInstance = MyClass(AnArgument)创建一个新对象。

从实际角度来看，我提出这个问题的原因是因为我认为“新”是为了防范危险而设计的，并且我想了解这种危险。

由于 Rust 中数组类型的大小在编译时已知，我想知道没有反向索引的原因是什么？通过反向索引，我的意思arr[-1]是访问数组的最后一个元素arr

我在 Python 中有一个表示某些代码的字符串，如果代码包含像 time.sleep() 这样的方法调用，我想用相应的 from time import sleep 替换 time 的 import 语句。另外，我想用 sleep() 替换方法调用 time.sleep() 。

下面是代码示例：

a = """
import math, numpy, random
import time
from PIL import Image
a = math.sin(90)
time.sleep(3)
"""

我想将此代码转换为：

a = """
import numpy, random
from math import sin
from time import sleep
from PIL import Image
a = sin(90)
sleep(3)
"""

我尝试过使用正则表达式，但无法达到预期的结果。有人可以帮助我为这项任务提供正确的正则表达式和替换逻辑吗？

这是我尝试过的代码：

re.sub(rf'import\s+{re.escape("time")}\s*\n*(\s*{re.escape("time")}\.(\w+)\(([^)]*)\))', lambda m: f'from {m.group(2)} import {m.group(3)}, {m.group(2)}' if 'time' in m.group(2) else f'from {m.group(2)} import {m.group(3)}', …

我正在使用 C++ 和 g++（版本 13.2.1），并且我正在创建一个Determinant<m>接受std::array<std::array<int,m>,m>参数类型并返回该矩阵的行列式的函数。

以下是我写的代码。

行列式：

template <int m>\nint Determinant(std::array<std::array<int,m>,m> arr){\n\n    if(m == 2){\n      return arr[0][0]*arr[1][1] - arr[0][1]*arr[1][0];\n    }else if(m >2){\n      int ans = 0;\n      for(int i =0;i < m;i++){\n        ans += arr[0][i]*Determinant<m-1>(slc<m,m>( arr,i,0 ))*(i%2 ? 1:-1);\n      }\n      return ans;\n    }else{\n      return -1;\n\n    }\n  }\n

slc ：返回一个切片（不是真正的切片，只是删除一行和一列）

template <int m, int n>\nstd::array<std::array<int,(n-1)>,(m-1)> slc(std::array<std::array<int,n>,m> arr, int i,int j){\n  std::array<std::array<int,(n-1)>,(m-1)> ans;\n\n  for(int x = 0;x < m;x ++){\n    for (int y = …

我正在编写使用使用Optionals 的 Java 库的 Kotlin 代码，并且我更愿意在 Kotlin 世界中使用 Kotlin 的可空习惯用法。

例如，我的图书馆可能有一个功能

Optional<Foo> getFoo(String fooId) {
  ...
}

在我的 Kotlin 程序中我想

foo: Foo? = /* something, something */ getFoo(fooId)

我知道我可以做类似的事情

lateinit var foo: Foo?
val fooOpt = getFoo(fooId)
if(fooOpt.isPresent) foo = fooOpt.get()
else foo = null

但是，鉴于 Java 的Optional用途与可空值几乎相同，这似乎不必要地冗长，即使我将其折叠为

val foo: Foo? = getFoo(fooId).orElse(null)

我有一台主机，其主机名是 ，babuntu10而且hostname12我只想从fstab条目中删除主机名之一，但以下sed命令会同时删除它们：

sed -i '/'"$HOSTNAME:"'/,$d' /etc/fstab

输入文件：

babuntu10:/root/products/babuntu10 /root/products/babuntu10 nfs soft,timeo=1,retrans=1 0 0
babuntu12:/root/products/babuntu12 /root/products/babuntu12 nfs soft,timeo=1,retrans=1 0 0

我只需要删除带有主机名的条目。

我正在做来自haskell.mooc.fi/Exercises7的Set7.hs

-- Ex 5: reverse a NonEmpty list.\n--\n-- PS. The Data.List.NonEmpty type has been imported for you\n\n-- below doesn\'t work\n-- reverseNonEmpty :: NonEmpty a -> NonEmpty a\n-- reverseNonEmpty  (h:|tail) = head reversed :| (tail reversed)\n--   where \n--     reversed = reverse (h:tail)\n\n-- below works\nreverseNonEmpty :: NonEmpty a -> NonEmpty a\nreverseNonEmpty (h :| tail) = head reversed :| revTail\n  where\n    reversed = reverse (h : tail)\n    -- revTail = (tail reversed) - this doesn\'t work, but WHY???\n    (_:revTail) …

我对绕过二进制类型转换限制的方法感兴趣，因为 bit_cast 使用复制到堆栈上的变量，这不是很快。但据我所知，普通类型不会在默认构造函数中初始化内存。这是否意味着，对于将 bit_casting 转换为普通类型，我们可以使用放置 new 和指向我们感兴趣的内存的指针，从而保持内存中的字节不变并避免不必要的复制？在这个问题上是否有我找不到的标准立场，并且禁止我将新的位置与一些“非主题”指针一起使用？

例如，第一个选项是其他人如何使用此功能。第二个选项是我想如何使用它。

#include <iostream>
using namespace std;
class Foo 
{ 
    private: int __unused0 : 31; //A little bit of binary magic
    private: int __unused1 :  1; 
    public: Foo() : __unused0(1), __unused1(1) {} //We're still saving trivially_copyable, so we're good
};

int main()
{
    //char bytes[1024];
    //auto* foo = new(bytes) Foo;
    
    Foo bytes{};
    auto* foo = new(&bytes) int;
    
    cout << *foo;
    return 0;
}

UPD：这一切的目的是在不更改容器的情况下处理内存中的原始字节。在最简单的情况下，我需要像“检查寄存器中的高位”这样的小型优化，这是通过单个汇编命令来实现的，例如[x < 0]在处理结构中的位字段时创建一系列命令，例如[x & 0x80][x >> 7][x == …