Jaki jest najbardziej elegancki sposób na ograniczenie liczby do segmentu?

Powiedzmy x, ai bsą liczbami. Muszę zmieścić xsię w granicach segmentu [a, b].

Potrafię pisać Math.max(a, Math.min(x, b)), ale nie wydaje mi się, żeby było łatwe do odczytania. Czy ktoś ma sprytny sposób, aby napisać to w bardziej czytelny sposób?

Sposób, w jaki to robisz, jest dość standardowy. Możesz zdefiniować funkcję narzędziową clamp:

/**
 * Returns a number whose value is limited to the given range.
 *
 * Example: limit the output of this computation to between 0 and 255
 * (x * 255).clamp(0, 255)
 *
 * @param {Number} min The lower boundary of the output range
 * @param {Number} max The upper boundary of the output range
 * @returns A number in the range [min, max]
 * @type Number
 */
Number.prototype.clamp = function(min, max) {
  return Math.min(Math.max(this, min), max);
};

(Chociaż rozszerzenia wbudowanych języków są generalnie źle widziane)

podejście mniej zorientowane na matematykę, ale powinno również działać, w ten sposób test </> jest ujawniony (może być bardziej zrozumiały niż minimaksowanie), ale tak naprawdę zależy od tego, co rozumiesz przez „czytelny”

function clamp(num, min, max) {
  return num <= min ? min : num >= max ? max : num;
}

Aktualizacja dla ECMAScript 2017:

Math.clamp(x, lower, upper)

Należy jednak pamiętać, że na dzień dzisiejszy jest to propozycja etapu 1 . Dopóki nie uzyska szerokiego wsparcia, możesz używać polyfill .

Math.clip = function(number, min, max) {
  return Math.max(min, Math.min(number, max));
}

To nie jest odpowiedź typu „po prostu użyj biblioteki”, ale na wypadek, gdybyś korzystał z Lodash, możesz użyć .clamp:

_.clamp(yourInput, lowerBound, upperBound);

Po to aby:

_.clamp(22, -10, 10); // => 10

Oto jego implementacja, zaczerpnięta ze źródła Lodash :

/**
 * The base implementation of `_.clamp` which doesn't coerce arguments.
 *
 * @private
 * @param {number} number The number to clamp.
 * @param {number} [lower] The lower bound.
 * @param {number} upper The upper bound.
 * @returns {number} Returns the clamped number.
 */
function baseClamp(number, lower, upper) {
  if (number === number) {
    if (upper !== undefined) {
      number = number <= upper ? number : upper;
    }
    if (lower !== undefined) {
      number = number >= lower ? number : lower;
    }
  }
  return number;
}

Warto również zauważyć, że Lodash udostępnia pojedyncze metody jako samodzielne moduły, więc jeśli potrzebujesz tylko tej metody, możesz po prostu zainstalować ją bez reszty biblioteki:

npm i --save lodash.clamp

Jeśli jesteś w stanie używać funkcji strzałek es6, możesz również zastosować częściowe podejście do aplikacji:

const clamp = (min, max) => (value) =>
    value < min ? min : value > max ? max : value;

clamp(2, 9)(8); // 8
clamp(2, 9)(1); // 2
clamp(2, 9)(10); // 9

or

const clamp2to9 = clamp(2, 9);
clamp2to9(8); // 8
clamp2to9(1); // 2
clamp2to9(10); // 9

Jeśli nie chcesz definiować żadnej funkcji, napisanie jej w Math.min(Math.max(x, a), b)ten sposób nie jest takie złe.

W duchu seksowności strzały możesz stworzyć mikro zacisk / ograniczenie / bramkę / i c. funkcja przy użyciu parametrów resztowych

var clamp = (...v) => v.sort((a,b) => a-b)[1];

Następnie podaj po prostu trzy wartości

clamp(100,-3,someVar);

To znaczy, znowu, jeśli mówiąc seksowny, masz na myśli „krótki”

To rozszerza opcję trójskładnikową do if / else, która zminimalizowana jest równoważna opcji trójskładnikowej, ale nie powoduje utraty czytelności.

const clamp = (value, min, max) => {
  if (value < min) return min;
  if (value > max) return max;
  return value;
}

Zmniejsza do 35b (lub 43b, jeśli używasz function):

const clamp=(c,a,l)=>c<a?a:c>l?l:c;

Ponadto, w zależności od używanego narzędzia perf lub przeglądarki, można uzyskać różne wyniki, czy implementacja oparta na matematyce czy implementacja oparta na trzech elementach jest szybsza. W przypadku mniej więcej takiej samej wydajności wybrałbym czytelność.

Mój ulubiony:

[min,x,max].sort()[1]