Quelle est la manière la plus élégante de limiter un nombre à un segment?

Disons x, aet bsont des nombres. J'ai besoin de plafonner xaux limites du segment [a, b].

Je sais écrire Math.max(a, Math.min(x, b)), mais je ne pense pas que ce soit très facile à lire. Quelqu'un a-t-il une manière intelligente d'écrire ceci d'une manière plus lisible?

La façon dont vous le faites est assez standard. Vous pouvez définir une clampfonction utilitaire :

/**
 * 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);
};

(Bien que l'extension du langage intégré soit généralement mal vue)

une approche moins orientée "Math", mais qui devrait aussi fonctionner, de cette façon, le test </> est exposé (peut-être plus compréhensible que minimaxing) mais cela dépend vraiment de ce que vous entendez par "lisible"

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

Mise à jour pour ECMAScript 2017:

Math.clamp(x, lower, upper)

Mais notez qu'à partir d'aujourd'hui, c'est une proposition de l' étape 1 . Jusqu'à ce qu'il soit largement pris en charge, vous pouvez utiliser un polyfill .

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

Cela ne veut pas être une réponse "juste utiliser une bibliothèque", mais juste au cas où vous utilisez Lodash, vous pouvez utiliser .clamp:

_.clamp(yourInput, lowerBound, upperBound);

Pour que:

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

Voici sa mise en œuvre, tirée de la source 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;
}

En outre, il convient de noter que Lodash rend des méthodes uniques disponibles en tant que modules autonomes, donc si vous n'avez besoin que de cette méthode, vous pouvez simplement l'installer sans le reste de la bibliothèque:

npm i --save lodash.clamp

Si vous êtes capable d'utiliser les fonctions fléchées es6, vous pouvez également utiliser une approche d'application partielle:

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

Si vous ne voulez définir aucune fonction, l'écrire comme ça Math.min(Math.max(x, a), b)n'est pas si mal.

Dans l'esprit de la sensualité des flèches, vous pourriez créer une micro pince / contrainte / porte / & c. fonction utilisant les paramètres de repos

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

Ensuite, passez simplement trois valeurs

clamp(100,-3,someVar);

C'est, encore une fois, si par sexy, tu veux dire `` court ''

Cela étend l'option ternaire en if / else qui minifié équivaut à l'option ternaire mais ne sacrifie pas la lisibilité.

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

Réduit à 35b (ou 43b si vous utilisez function):

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

En outre, en fonction de l'outil de performance ou du navigateur que vous utilisez, vous obtenez divers résultats quant à savoir si l'implémentation basée sur les mathématiques ou l'implémentation basée sur ternaire est plus rapide. Dans le cas de performances à peu près identiques, j'opterais pour la lisibilité.

Mon préféré:

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