Question

我有多个选择，而且当我尝试传递未定义的变量时，第三方api很不喜欢。它会给我一个签名错误！

所需的是side，symbol，order_type，qty和time_in_force

这就是我在下面的示例中传递的内容

mutation {
  setActiveOrder(
    side: "Buy", 
    symbol: "BTCUSD", 
    order_type: "Market", 
    qty: 1, 
    time_in_force: "GoodTillCancel"
  ) {
      data
  }
}

但有时需要(order_type === "Limit")和price

有时，以上两种可能性中的一种可能同时存在take_profit和stop_loss中的一个或两个。

话虽这么说，我试图找出最好的方法来有选择地传递变量，而不必为每种可能性编写if语句，这是很难的方法

我想换个角度

    settActiveOrder: async (
      _,
      {
        side,
        symbol,
        order_type,
        qty,
        price,
        time_in_force,
        take_profit,
        stop_loss,
        reduce_only,
        close_on_trigger,
        order_link_id,
      },
      ctx
    ) => {
      const setActiveOrder = async () => {
        try {
          return await cclient.placeActiveOrder({
            side: side,
            symbol: symbol,
            order_type: order_type,
            qty: qty,
            // price: price,
            time_in_force: time_in_force,
            // take_profit: take_profit,
            // stop_loss: stop_loss,
            // reduce_only: reduce_only,
            // close_on_trigger: close_on_trigger,
            // order_link_id: order_link_id,
          });
        } catch (error) {
          console.error(error);
        }
      };
      const data = await setActiveOrder();
      return { data: data };
    },

Answer 1

恐怕您不会回避if语句，但是比编写所有组合更好的方法是声明字典并为请求附加首选变量

类似这样的东西：

var dictForRequest = {

        side: side,
        symbol: symbol,
        order_type: order_type,
        qty: qty,
        time_in_force: time_in_force,
 };
 if(wantPrice)
   dictForRequest["price"] = price;
 if(wantTakeProfit)
   dictForRequest["take_profit"] = take_profit;
 ....

比dictForRequest传递给

       ...
      const setActiveOrder = async () => {
    try {
      return await cclient.placeActiveOrder(dictForRequest);        
    } catch (error) {
      console.error(error);
    }

Answer 2

如果您需要构建一个新对象（如您在示例中所做的那样），并且api本身不处理“未定义”值，那么您确实需要一种检查输入并有条件地构建该对象的方法，但是您可以循环执行。

为澄清起见，请再次在此处添加代码并加上注释：

settActiveOrder: async (
    _,
    // here you are using "object destructuring".
    // Not existing properties will become a valid,
    // existing variable with the value >>undefined<<
    { side, symbol, order_type, qty, /* ... */ }, 
    ctx
) => { 
    /* ... */

    // here your are building a new object,
    // possibly having existing properties with the value >>undefined<<,
    // but you want these properties to not exist
    return await cclient.placeActiveOrder({
        side: side,
        symbol: symbol,
        order_type: order_type,
        qty: qty,
        /* ... */
    });
    /* ... */
};

解决方案：

您可以引用原始对象，而不是使用对象分解，并遍历其属性，例如：

settActiveOrder: async ( _, originalParams, ctx ) => { // <-- no object destructuring
    /* ... */

    // build new object in a loop, but skip undefined properties
    const passedParams = Object.keys( originalParams ).reduce(( acc, key ) => {
        if( typeof originalParams[ key ] === 'undefined' ){
            return acc;
        } else {
            return {
                ...acc,
                [key]: originalParams[ key ]
            }
        }
    }, {});

    return await cclient.placeActiveOrder( passedParams );
    /* ... */
});

替代解决方案：

如果您只需要传递所有定义的属性，而不必真正构建新的对象，则可以直接按原样传递整个对象，而不用使用对象分解。

然后，不存在的属性将保持为不存在的属性，而不是成为不带值的不存在属性 。

settActiveOrder: async ( _, originalParams, ctx ) => {
    /* ... */
    return await cclient.placeActiveOrder( originalParams );
    /* ... */
});

Answer 3

您可以使用三元运算符。这是if else语句，但是更短，更容易编写。

{
  price: price ? price : 0,
}

// The above code translates to:

if(price) {
  price = price
  } else {
    price = 0
  }

此外，对于ES6，您不必这样写：

{
  side: side,
  symbol: symbol,
  order_type: order_type,
}

// These two are the same. You can write it like below.

{
  side,
  symbol,
  order_type
}

上面的代码是有效的，只要键的名称和作为值传递给键的变量名称相同即可。 JS可以找出正确的值并将其映射到正确的键，但是它们的名称必须完全相同。同样，此规则区分大小写。因此，价格：价格不一样。必须是价格：该规则成立的价格。

如果您正在寻找除三元运算符之外的其他选项，则可以在声明变量时对其进行初始化。但是，请使用let关键字而不是const对其进行初始化。由于const变量是不可变的-> let price = 0;

（可选）传递变量/参数

3 个答案:

解决方案：

替代解决方案：