有处理冲突的功能参数的模式吗？

我们有一个API函数，可根据给定的开始日期和结束日期将总金额细分为每月金额。

// JavaScript

function convertToMonths(timePeriod) {
  // ... returns the given time period converted to months
}

function getPaymentBreakdown(total, startDate, endDate) {
  const numMonths = convertToMonths(endDate - startDate);

  return {
    numMonths,
    monthlyPayment: total / numMonths,
  };
}

最近，此API的消费者希望以其他方式指定日期范围：1）通过提供月数而不是结束日期，或2）通过提供每月付款并计算结束日期。为此，API小组将功能更改为以下内容：

// JavaScript

function addMonths(date, numMonths) {
  // ... returns a new date numMonths after date
}

function getPaymentBreakdown(
  total,
  startDate,
  endDate /* optional */,
  numMonths /* optional */,
  monthlyPayment /* optional */,
) {
  let innerNumMonths;

  if (monthlyPayment) {
    innerNumMonths = total / monthlyPayment;
  } else if (numMonths) {
    innerNumMonths = numMonths;
  } else {
    innerNumMonths = convertToMonths(endDate - startDate);
  }

  return {
    numMonths: innerNumMonths,
    monthlyPayment: total / innerNumMonths,
    endDate: addMonths(startDate, innerNumMonths),
  };
}

我觉得此更改使API复杂化。现在，调用者需要有关隐藏与功能的实现启发式担心在确定哪些参数采取偏好被用来计算日期范围（即根据优先顺序monthlyPayment，numMonths，endDate）。如果调用者不注意函数签名，则他们可能会发送多个可选参数，并对endDate被忽略的原因感到困惑。我们确实在功能文档中指定了此行为。

另外，我觉得它树立了一个不好的先例，并增加了它不应该关注的API责任（即违反SRP）。假设额外的消费者想要的功能，以支持更多的使用情况，如计算total从numMonths和monthlyPayment参数。随着时间的流逝，该功能将变得越来越复杂。

我的喜好是保持功能不变，而是要求调用者endDate自行计算。但是，我可能是错的，并且想知道所做的更改是否是设计API函数的可接受方法。

或者，是否存在用于处理此类情况的通用模式？我们可以在API中提供其他高阶函数来包装原始函数，但这会使API膨胀。也许我们可以添加一个额外的标志参数来指定在函数内部使用哪种方法。

看到实现之后，在我看来，您真正需要的是3种不同的功能，而不是一种：

原始的一个：

function getPaymentBreakdown(total, startDate, endDate) 

提供月数而不是结束日期的数字：

function getPaymentBreakdownByNoOfMonths(total, startDate, noOfMonths) 

提供月付款并计算结束日期的人：

function getPaymentBreakdownByMonthlyPayment(total, startDate, monthlyPayment) 

现在，不再有可选参数，并且应该很清楚地将哪个函数称为方法以及用于哪个目的。如评论中所提到的，在严格类型化的语言中，如果不混淆功能的目的，也可以利用函数重载，不一定要通过名称，而是通过签名来区分这三个不同的函数。

请注意，不同的功能并不意味着您必须重复任何逻辑-在内部，如果这些功能共享一个通用算法，则应将其重构为“私有”功能。

是否有处理这种情况的通用模式

我认为没有描述好的API设计的“模式”（就GoF设计模式而言）。使用自描述名称，具有较少参数的函数，具有正交（=独立）参数的函数只是创建可读，可维护和可演化代码的基本原理。并非编程中的每个好主意都一定是“设计模式”。

另外，我觉得它树立了一个不好的先例，并增加了它不应该关注的API责任（即违反SRP）。假设额外的消费者想要的功能，以支持更多的使用情况，如计算total从numMonths和monthlyPayment参数。随着时间的流逝，该功能将变得越来越复杂。

你是完全正确的。

我的喜好是保持功能不变，而是要求调用者自己计算endDate。但是，我可能是错的，并且想知道所做的更改是否是设计API函数的可接受方法。

这也不是理想的选择，因为调用者代码将被无关的样板污染。

或者，是否存在用于处理此类情况的通用模式？

引入一种新的类型，例如DateInterval。添加任何有意义的构造函数（开始日期+结束日期，开始日期+ num月，等等）。将其用作表示系统中日期/时间间隔的通用货币类型。

有时流利的表达对此有帮助：

let payment1 = forTotalAmount(1234)
                  .breakIntoPayments()
                  .byPeriod(months(2));

let payment2 = forTotalAmount(1234)
                  .breakIntoPayments()
                  .byDateRange(saleStart, saleEnd);

let monthsDue = forTotalAmount(1234)
                  .calculatePeriod()
                  .withPaymentsOf(12.34)
                  .monthly();

给定足够的设计时间，您可以提供一个与域特定语言类似的可靠API。

另一个重要的优点是，具有自动完成功能的IDE 几乎可以完全理解API文档，因为它具有可自我发现的功能，因此很直观。

有关于该主题的资源，例如https://nikas.praninskas.com/javascript/2015/04/26/fluent-javascript/或https://github.com/nikaspran/fluent.js。

示例（取自第一个资源链接）：

let insert = (value) => ({into: (array) => ({after: (afterValue) => {
  array.splice(array.indexOf(afterValue) + 1, 0, value);
  return array;
}})});

insert(2).into([1, 3]).after(1); //[1, 2, 3]

好吧，在其他语言中，您将使用命名参数。可以在Javscript中模拟：

function getPaymentBreakdown(total, startDate, durationSpec) { ... }

getPaymentBreakdown(100, today, {endDate: whatever});
getPaymentBreakdown(100, today, {noOfMonths: 4});
getPaymentBreakdown(100, today, {monthlyPayment: 20});

另外，您也可以放弃指定月份数的职责，而将其排除在功能范围之外：

getPaymentBreakdown(420, numberOfMonths(3))
getPaymentBreakdown(420, dateRage(a, b))
getPaymentBreakdown(420, paymentAmount(350))

并且getpaymentBreakdown将接收一个对象，该对象将提供基本月份数

这些将使高阶函数返回例如函数。

function numberOfMonths(months) {
  return {months: (total) => months};
}

function dateRange(startDate, endDate) {
  return {months: (total) => convertToMonths(endDate - startDate)}
}

function monthlyPayment(amount) {
  return {months: (total) => total / amount}
}


function getPaymentBreakdown(total, {months}) {
  const numMonths= months(total);
  return {
    numMonths, 
    monthlyPayment: total / numMonths,
    endDate: addMonths(startDate, numMonths)
  };
}

而且，如果要使用具有区分的并集/代数数据类型的系统，则可以将其传递为，例如TimePeriodSpecification。

type TimePeriodSpecification =
    | DateRange of startDate : DateTime * endDate : DateTime
    | MonthCount of startDate : DateTime * monthCount : int
    | MonthlyPayment of startDate : DateTime * monthlyAmount : float

然后，如果您实际上无法实现一个问题，就不会发生任何问题。