Answer 1

您需要处理此操作，而无需属于许多关系，并且必须创建一个中间或枢轴模型。

class OrderProduct extends Model {
    // optional belongs to order and product method
    protected $fillable = [
        'product_id',
        'order_id',
        'color',
        'quantity'
    ];
}

更改订单和产品模型（如果您不使用的产品模型可选）

class Order extends Model {
    public function order_products()
    {
        return $this->hasMany(OrderProduct::class);
    }
}

并且需要在控制器更新方法中

//假设您的请求结构是

[
    'id' => 1, // Order id,
    'order_attribute_1', // Any of your order model attribute
    'order_attribute_2', // Any of your order model attributes
    'products' => [
        [
            'id' => null, // id of the order_product table so, null cause is a new added product
            'order_id' => 1, // id of order
            'product_id' => 1// id of product
            'color' => 'blue',
            'quantity' => 12
        ],
        [
            'id' => 1, // id of the order_product table so, has id cause are you updating an existent product in the order
            'order_id' => 1, // id of order
            'product_id' => 1// id of product
            'color' => 'blue',
            'quantity' => 5
        ]
    ]
]

您需要创建自己的同步方法，

public function update(AdminUpdateOrderRequest $request, $id)
{
    $orderValidated = $request->validated();

    $order = Order::findOrFail($id);

    $order->update($orderValidated);
    
    // start simulation of sync method
    $new_order_products = [];
    // id of order_product to preserve
    $order_products_to_keep = [];

    // I hope you have the corresponding products validation on your request class
    foreach ($request['products'] as $request_product) {
        // need to create new product in order
        if (empty($request_product['id'])) {
            $new_order_products[] = [
                'product_id' => $request_product['product_id'],
                'order_id' => $request_product['order_id'],
                'color' => $request_product['color'],
                'quantity' => $request_product['quantity']
            ]
        } else {
            // find the order_order product register
            $order_product = OrderProduct::find(request_product['id']);
            // update all except the order id
            $order_product->update([
                'product_id' => $request_product['product_id'],
                'color' => $request_product['color'],
                'quantity' => $request_product['quantity']
            ]);
            // as exists this order_product will be preserved
            $order_products_to_keep[] = $order_product->id;
        }
    }

    // calculate the order_products to delete (if not present means that needs to be deleted)
    foreach ($order->order_products as $order_product) {
        if (!in_array($order_products_to_keep, $order_product->id)) {
            $order_product->delete();
        }
    }

    // mass insertion of new order_products
    $order->order_products()->createMany($new_order_products);

    DB::table
    return OrderResource::make($order)->additional([
        'success' => true,
    ]);
}

那么我希望这对您有帮助，并且可能需要您使用交易预防错误，并添加相应的验证

Answer 2

在大多数情况下（包括此），返回将立即退出。但是，如果返回是在中尝试带有随附的最后 block block中的最后始终执行并可以“覆盖” 在中返回尝试。

function foo() {
    try {
        for (var i = 0; i < 10; i++) {
            if (i % 3 == 0) {
                return i; // This executes once
            }
        }
    } finally {
        return 42; // But this still executes
    }
}

console.log(foo()); // Prints 42

Answer 3

尽管零值是浮动的，而不是问题所暗示的，但这似乎给出了所需的输出。

I5 = [[(0.5, -0.5), (1.5, -0.5)], [(0.5, -0.5), (0.5, -1.5)], [(1.5, -0.5), (1.5, -1.5)], [(0.5, -1.5), (1.5, -1.5)]]
I6 = []

for e1, e2 in I5:
    I6.append([e1, (e2[0]-e1[0], e2[1]-e1[1])])

print(I6)

输出：

[[(0.5, -0.5), (1.0, 0.0)], [(0.5, -0.5), (0.0, -1.0)], [(1.5, -0.5), (0.0, -1.0)], [(0.5, -1.5), (1.0, 0.0)]]

Answer 4

使用 is（）类选择器

:is(.parent1, .parent2, ...) > child {
    ...
}

Answer 5

这种方法没有错。这里可能的问题是
您正在使用对称键。通过这种方法，您正在使用相同的键来签名令牌和验证其签名。这意味着您需要与身份验证过程中所涉及的所有应用程序共享用于签名令牌的密钥，而这些应用程序并非总是可能的，并且资源服务器具有太多的功率。

为了保留授权服务的关键，资源服务器中有一个选项使用授权服务曝光的特殊端点来验证令牌。

另一种方法是使用不对称的钥匙对签名和验证令牌。在这种情况下，专用密钥将仅分配给授权服务，并且可以与身份验证过程中涉及的所有应用程序共享公共密钥。

@Bean
public ReactiveJwtDecoder jwtDecoder() throws GeneralSecurityException {
    RSAPublicKey key = (RSAPublicKey) KeyFactory.getInstance("RSA")
            .generatePublic(new X509EncodedKeySpec(getKeySpec(properties.getPublicKey())));
    return NimbusReactiveJwtDecoder.withPublicKey(key)
            .signatureAlgorithm(SignatureAlgorithm.from(properties.getSignatureAlgorithm()))
            .build();
}

Answer 6

否。我们无法做到这一点，同时仍在程序中使用相同名称定义变量。但是，您可以将变量重新定义为参数：

define variable myVariable as integer no-undo.

procedure myProcedure1:
  message "myProcedure1:" myVariable.
end.

procedure myProcedure2:
  define variable myVariable as integer no-undo.
  message "myProcedure2:" myVariable.
end.

procedure myProcedure3:
  define input parameter p1 as integer no-undo.
  define variable myVariable as integer no-undo.
  message "myProcedure3:" myVariable p1.
end.

procedure myProcedure4:
  define input parameter myVariable as integer no-undo.
  message "myProcedure4:" myVariable.
end.


myVariable = 123.

run myProcedure1.
run myProcedure2.
run myProcedure3 ( myVariable ).
run myProcedure4 ( myVariable ).

Answer 7

正如我之前提到的那样，我得到了解决方案，也说在否则中犯了一些错误的部分，因此进行了一些更改，现在正在

更新逻辑：

        if (nestedObj?.[parentEle]?.[index]) {
          nestedObj[parentEle][index] = Object.assign(
            {},
            nestedObj[parentEle][index],
            eachValue[index]
          );
        } else {
          nestedObj[parentEle] = nestedObj[parentEle]
            ? nestedObj[parentEle]
            : [];
          eachValue = { [fieldName]: e.target.value };
          nestedObj[parentEle][index] = eachValue;
        } 

如果有人甚至可以建议一些更好的东西或者，如果可以简化，请更新

Answer 8

为了了解 import 语句中使用卷曲括号的使用，首先，您必须了解 破坏 在 es6

1. 中引入的

     var Bodybuilder = {
     firstName：'kai'，
     最后一个名称：“ greene”，
     昵称：“捕食者”
   };
   
   var {firstName，lastName} = ModyBuilder;
   console.log（firstName，lastName）; // Kai Greene
   
   firstName ='Morgan';
   lastname ='aste';
   
   console.log（firstName，lastName）; //摩根·阿斯特
    

2. 数组破坏

     var [firstgame] = ['gran turismo'，'burnout'，'gta'];
   
   console.log（firstgame）; // Gran Turismo
    

   使用列表匹配

     var [，secondgame] = ['gran turismo'，'burnout'，'gta'];
     console.log（第二游戏）; //倦怠
    

   使用传播操作员

     var [firstgame，... reth] = ['gran turismo'，'burnout'，'gta'];
   console.log（firstgame）; // gran turismo
   console.log（rets）; // ['Burnout'，'gta'];
    

，因为我们已经解决了这一点，在 es6 中，您可以导出多个模块。然后，您可以使用以下毁灭对象进行破坏。

假设您有一个名为 module.js 的模块，

    export const printFirstname(firstname) => console.log(firstname);
    export const printLastname(lastname) => console.log(lastname);

您想将导出的功能导入到 index.js ;

    import {printFirstname, printLastname} from './module.js'

    printFirstname('Taylor');
    printLastname('Swift');

您也可以使用不同的变量名称

    import {printFirstname as pFname, printLastname as pLname} from './module.js'

    pFname('Taylor');
    pLanme('Swift');

Answer 9

调用函数时，该过程需要能够初始化该字符串。即使清除了存储在堆栈上的值，它仍将保留在加载的二进制中。您了解：

无论我们在代码中添加什么，都不足以阻止专业网络安全工程师在二进制中找到或生成的密码，而无需添加单独的密钥。

我们将密码的内存归零，因为该密码在程序开始之前不存在，因此我们可以最大程度地减少其保留在内存中的时间。没有安全的方法将密码存储在二进制中，但是我们可以做一些技巧来更难找到。我们可以通过存储密码的编码版本来假装具有安全性。但是，仍然很难以一种防止编译器将密码重新优化为纯文本表单的方式存储。

理想情况下，密码（或私钥）只能存储在受信任的系统上。该二进制文件将传递给不受信任的系统，这些系统必须将请求发送到受信任的系统。然后，受信任的系统代表他们采取行动，同时忽略了恶意或畸形的请求。

旁注：这个问题可能是 xy问题的结果。您为什么要存储密码？您实际想做什么？您的问题可能会有更简单的答案，不需要将密码存储在二进制中。

Answer 10

”此处复制

（从a .cpp 文件中使用我的所有功能，无论它们是模板函数还是常规功能。并且有一种方法可以使用一些基本 #ifndef 魔术。这是您可以做的：

main.cpp

#include "myclass.hpp"

int main()
{
  // ...
}

myclass.hpp

#ifndef MYCLASS
#define MYCLASS

template<class T>
class MyClass
{
  T val;
public:
  MyClass(T val_);
}

#define MYCLASS_FUNCTIONS
#include "myclass.cpp"

#endif

myclass.cpp

#ifndef MYCLASS_FUNCTIONS
#include "myclass.hpp"

// regular functions:
// ...

#else
 
// template functions:
template<class T>
MyClass<T>::MyClass(T val_)
    :val(val_)
{}

// ...
#endif

这是预编译器如何看待它。我们有两个 .cpp 文件。

1. 当我们编译main.cpp时，我们：
2. include myClass.hpp
3. 检查 myClass 不确定，它是
4. 定义的，它
5. 为编译器提供了生成类的定义（来自模板类）
6. 包括 myClass.cpp
7. 定义 myClass_functions
8. 检查是否定义了 myClass_functions ，它是定义的，
9. 给出了编译器的定义（从模板函数）
10. 在我们时 compile myclass.cpp
11. 检查是否定义了 myClass_functions ，它不
12. 包括 myClass.hpp
13. 检查 myclass not n defined n n
14. dewindine
15. 给编译器类的定义
16. 包括 myClass.cpp
17. include myClass.hpp ye Reme
18. this Time myClass 定义了什么都不在内部做任何事情，请返回<<代码> myClass.cpp
19. 检查是否定义了 myClass_functions ，它为
20. 编译器提供了生成的函数的定义（来自模板函数）
21. 退出包括两次
22. 通过到编译器的所有常规函数

Answer 11

剪接返回一个数组，因此您需要从中实际检索值，因此 [0] 。

Answer 12

除了@martin prikryl提案外，我们还可以动态地覆盖标准 Storbinary（）方法。

首先定义 new_storbinary（）方法：

try:
    import ssl
except ImportError:
    _SSLSocket = None
else:
    _SSLSocket = ssl.SSLSocket

def new_storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None):

  self.voidcmd('TYPE I')
  with self.transfercmd(cmd, rest) as conn:
    while 1:
      buf = fp.read(blocksize)
      if not buf: break
      conn.sendall(buf)
      if callback: callback(buf)
    # shutdown ssl layer
    if _SSLSocket is not None and isinstance(conn, _SSLSocket):
      # HACK: Instead of attempting unwrap the connection, pass here
      pass
  return self.voidresp()

然后在实例级别替换该方法，使用 types 模块：

import types
ftps = ftplib.FTP_TLS()
ftps.storbinary = types.MethodType(new_storbinary, ftps)

请注意， retrbinary（）， retrines（）和 storlines（）方法也可能受到影响

Answer 13

我发现我做错了什么，它是the the的CLI，而不是Solana CLI

spl-token wrap 1

Answer 14

简短答案：对您的两个问题是的。

答案稍长：.NET 4是一个就地的升级，这意味着每个升级都在同一文件位置覆盖以前的版本，因此只安装了一个版本。如果您在服务器上安装了.NET 4.7框架，则代码是否针对4.5或4.6.2或4.7。

注意：我将安装.NET 4.8，因为这是最后一个最新版本的最新版本。

Answer 15

我正在尝试实施类似的事情，但预测一个类似的问题，前端会变得凌乱。因此，在我的情况下，我将尝试在后端存储哈希图像。

如果您仅使用NextJ，则可以尝试在NextJS Backend中执行此操作。
我认为您可以从杰克·赫林顿（Jack Herrington） https://www.youtube.com/watch?v=ffhsiio4acu＆amp; t = 803S