Apa cara paling elegan untuk membatasi angka ke suatu segmen?

Katakanlah x, adan bangka. Saya perlu membatasi xbatasan segmen [a, b].

Saya bisa menulis Math.max(a, Math.min(x, b)), tetapi saya rasa itu tidak mudah dibaca. Apakah ada yang punya cara pintar untuk menulis ini dengan cara yang lebih mudah dibaca?

Cara Anda melakukannya cukup standar. Anda dapat mendefinisikan clampfungsi utilitas :

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

(Meskipun built-in bahasa tambahan umumnya disukai)

pendekatan yang kurang berorientasi "Matematika", tetapi juga harus bekerja, dengan cara ini, tes </> diekspos (mungkin lebih dimengerti daripada minimaxing) tetapi itu benar-benar tergantung pada apa yang Anda maksud dengan "dibaca"

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

Pembaruan untuk ECMAScript 2017:

Math.clamp(x, lower, upper)

Tetapi perhatikan bahwa pada hari ini, ini adalah proposal Tahap 1 . Sampai mendapat banyak dukungan, Anda dapat menggunakan polyfill .

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

Ini tidak ingin menjadi jawaban "just-use-a-library" tetapi jika Anda menggunakan Lodash Anda dapat menggunakan .clamp:

_.clamp(yourInput, lowerBound, upperBound);

Yang seperti itu:

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

Berikut ini implementasinya, diambil dari sumber 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;
}

Juga, perlu dicatat bahwa Lodash membuat metode tunggal tersedia sebagai modul mandiri, jadi jika Anda hanya membutuhkan metode ini, Anda bisa menginstalnya tanpa perpustakaan:

npm i --save lodash.clamp

Jika Anda dapat menggunakan fungsi panah ES6, Anda juga bisa menggunakan pendekatan aplikasi parsial:

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

Jika Anda tidak ingin mendefinisikan fungsi apa pun, menulis seperti Math.min(Math.max(x, a), b)itu tidak terlalu buruk.

Dalam semangat keseksian panah, Anda bisa membuat penjepit mikro / constrain / gate / & c. berfungsi menggunakan parameter istirahat

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

Lalu, berikan tiga nilai

clamp(100,-3,someVar);

Artinya, sekali lagi, jika secara seksi, maksud Anda 'pendek'

Ini memperluas opsi ternary ke jika / jika minified yang setara dengan opsi ternary tetapi tidak mengorbankan keterbacaan.

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

Diminimalkan ke 35b (atau 43b jika menggunakan function):

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

Juga, tergantung pada alat atau browser apa yang Anda gunakan, Anda mendapatkan berbagai hasil apakah implementasi berbasis matematika atau implementasi berbasis terner lebih cepat. Dalam hal kinerja yang kira-kira sama, saya akan memilih keterbacaan.

Kesukaanku:

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