Содержание

Math.round() — JavaScript | MDN

Метод Math.round() возвращает число, округлённое к ближайшему целому.

Параметры

Если дробная часть числа больше, либо равна 0,5, аргумент будет округлён до ближайшего большего целого. Если дробная часть числа меньше 0,5, аргумент будет округлён до ближайшего меньшего целого.

Поскольку метод round() является статическим методом объекта Math, вы всегда должны использовать его как Math.round(), а не пытаться вызывать метод на созданном экземпляре объекта Math (поскольку объект Math не является конструктором).

Пример: использование метода

Math.round()

x = Math.round(20.49);


x = Math.round(20.5);


x = Math.round(-20.5);


x = Math.round(-20.51);




x = Math.round(1.005*100)/100;

Пример: корректировка округления десятичных дробей


(function() {
  
  function decimalAdjust(type, value, exp) {
    
    if (typeof exp === 'undefined' || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    
    if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
      return NaN;
    }
    
    value = value.
 
 toString().split('e');
    value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
    
    value = value.toString().split('e');
    return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
  }

  
  if (!Math.round10) {
    Math.round10 = function(value, exp) {
      return decimalAdjust('round', value, exp);
    };
  }
  
  if (!Math.floor10) {
    Math.floor10 = function(value, exp) {
      return decimalAdjust('floor', value, exp);
    };
  }
  
  if (!Math.ceil10) {
    Math.ceil10 = function(value, exp) {
      return decimalAdjust('ceil', value, exp);
    };
  }
})();


Math.round10(55.55, -1);   
Math.round10(55.549, -1);  
Math.round10(55, 1);       
Math.round10(54.9, 1);     
Math.round10(-55.55, -1);  
Math.round10(-55.551, -1); 
Math.round10(-55, 1);      
Math.round10(-55.1, 1);    
Math.round10(1.005, -2);   

Math.floor10(55.59, -1);   
Math.floor10(59, 1);       
Math.floor10(-55.51, -1);  
Math.floor10(-51, 1);      

Math.ceil10(55.51, -1);    
Math.
 
 ceil10(51, 1);        
Math.ceil10(-55.59, -1);   
Math.ceil10(-59, 1);
ВозможностьChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Базовая поддержка(Да)(Да)(Да)(Да)(Да)
ВозможностьAndroidFirefox Mobile (Gecko)IE PhoneOpera MobileSafari Mobile
Базовая поддержка(Да)(Да)(Да)(Да)(Да)

Math.random() — JavaScript | MDN

Метод Math.random() возвращает псевдослучайное число с плавающей запятой из диапазона [0, 1)

, то есть, от 0 (включительно) до 1 (но не включая 1), которое затем можно отмасштабировать до нужного диапазона. Реализация сама выбирает начальное зерно для алгоритма генерации случайных чисел; оно не может быть выбрано или сброшено пользователем.

Примечание: метод Math.random() не предоставляет криптографически стойкие случайные числа. Не используйте его ни для чего, связанного с безопасностью. Вместо него используйте Web Crypto API (API криптографии в вебе) и более точный метод window.crypto.getRandomValues().

Возвращаемое значение

Псевдослучайное число с плавающей запятой от 0 (включительно) до 1 (не считая).

Обратите внимание, что поскольку числа в JavaScript являются числами с плавающей запятой стандарта IEEE 754 с поведением при округлении к ближайшему чётному, все эти диапазоны (исключая диапазон с простым вызовом Math.random()), не точны. Если заданы очень большие границы (253 или выше), возможен крайне редкий случай вычисления обычно исключённой верхней границы.

Получение случайного числа от 0 (включительно) до 1 (не включая)

function getRandom() {
  return Math.random();
}

Получение случайного числа в заданном интервале

Этот пример возвращает случайное число в заданном интервале. Возвращаемое значение не менее (и может быть равно) min и не более (и не равно) max.

function getRandomArbitrary(min, max) {
  return Math.random() * (max - min) + min;
}

Получение случайного целого числа в заданном интервале

Этот пример возвращает случайное целое число в заданном интервале. Возвращаемое значение не менее min (или следующее целое число, которое больше min, если min не целое) и не более (но не равно) max.

function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min; 
}

Может показаться заманчивым использовать Math. round() для округления, но это может сделать распределение неравномерным, что может оказаться неприемлимым для ваших нужд.

Получение случайного целого числа в заданном интервале, включительно

Функция getRandomInt() выше включает минимальное значение, но не включает максимальное. Но что если вам нужно, чтобы влючалось и минимальное, и максимальное значение? Функция getRandomIntInclusive() решает этот вопрос.

function getRandomIntInclusive(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min; 
}

BCD tables only load in the browser

Математические функции | Руководство LESS (Примеры)

Для удобства работы с числами доступны математические функции, которые представляют собой прослойку между Less-функциями и встроенным объектом Math в JavaScript.

Кратко рассмотрим основные функции, которые могут пригодиться при работе с препроцессором при построении фреймворков и максимально унифицированных less-файлов.

Округление значений

При необходимости значения, получаемые после проведения математических операций, можно округлять, используя стандартные методы

ceil(), floor() и round(), представленные в Less в виде функций. Кроме того, Less предоставляет новую функцию percentage().

Функция ceil() всегда округляет значения в большую сторону до целой части:

ceil(14.3) // 15
ceil(13.9) // 14
ceil(14.5) // 15

Функция floor() всегда округляет значения в меньшую сторону до целой части (отбрасывает дробную часть):

floor(14.3) // 14
floor(13.9) // 13
floor(14.5) // 14

Функция round() округляет значения в соответствии с правилами математики и заданным количеством знаков после запятой:

round(14.3) // 14
round(13.9) // 14
round(14.5) // 15

// Знаки после запятой
round(14. 0714)    // 14
round(14.0714, 1) // 14.1
round(14.0714, 2) // 14.07
round(14.0714, 3) // 14.071
round(14.0714, 4) // 14.074
round(14.0714, 7) // 14.074

Функция percentage() преобразует дробное значение в процентное:

percentage(0.25) // 25%
percentage(1 / 25) // 4%

Важно заметить, что дробная запись

1 / 25 сначала вычисляется как математическая операция, а уже потом передаётся в функцию. То есть, по сути своей, работает с числами с плавающей запятой.

Прочие функции

Математические функции, представленные ниже, являются вторичными и применяются крайне редко. Дело в том, что возможность применять Less для сложных вычислений предоставляется очень редко, ведь это всего-лишь надстройка над CSS.

Тригонометрические функции:

  • sin(value)
  • cosvalue)
  • tan(value)

Обратные тригонометрические функции:

  • asin(value)
  • acos(value)
  • atan(value)

Модуль числа, модуль между числами:

  • abs(value)
  • mod(valueOne, valueTwo)

Поиск минимального и максимального значения:

  • min(list) // min(1, 14, 19, 0. 3)
  • max(list) // max(1%, 10%, 4%, 8%)

Работа со степенями (квадратный корень и степень):

  • sqrt(value)
  • pow(value, power) // value в power степени

Математические константы:

«Чистые» и «нечистые» функции в JavaScript

«Чистые» функции — это любые функции, исходные данные которых получены исключительно из их входных данных и не вызывают побочных эффектов в приложении. Математические функции являются примерами «чистых» функций. «Нечистые» функции бывают разных форм и размеров. Вот некоторые примеры:

  • функции, вывод которых зависит от внешнего / глобального состояния;
  • функции, которые возвращают разные исходные данные при одинаковых входных;
  • функции, которые изменяют состояние приложения;
  • функции, которые изменяют «внешний мир».

Функциональное программирование основано на использовании «чистых» функций и строгом контроле побочных эффектов. Способность распознавать любой тип функции является ключевым для функционального программирования.

«Чистая» функция — это функция, которая выводит свои данные основываясь исключительно на свои входные данные и не вызывает побочных эффектов в приложении.

Например у нас есть функция, которая получает одно значение x и возвращает в данном случае x + 1:

Довольно легко понять, что это «чистая» функция. Мы получаем тот же результат при вызове этой функции, с тем же входным значением; плюс у нас нет внешних зависимостей, которые бы вызывали побочные эффекты. Чтобы понять это далее, давай сравним это с несколькими «нечистыми» функциями.

Первая «нечистая» функция

Первая «нечистая» функция, которую мы собираемся сделать — это та, чей результат не основан исключительно на её входных данных. Например, давай рассмотрим функцию totalPrice. У нас есть глобальная переменная —COST_OF_ITEM, которая содержит цену на товар. Функция totalPrice берет quantity и умножает ее на эту переменную.



const COST_OF_ITEM = 250;

const totalPrice = quantity => COST_OF_ITEM * quantity;

На первый взгляд может показаться, что это «чистая» функция, потому что мы всегда получаем один и тот же результат на основе одного и того же входного значения. Это можно увидеть, вызвав её несколько раз с одним и тем же значением, и вывив в консоль. В обоих случаях мы получаем 500.



const COST_OF_ITEM = 250;

const totalPrice = quantity => COST_OF_ITEM * quantity;

console.log(totalPrice(2)); 
console.log(totalPrice(2));

Хоть мы и получаем тот же результат, но это «нечистая» функция, так как состояние нашего приложения влияет на вывод нашей функции. Мы можем увидеть это, изменив значение COST_OF_ITEM и посмотреть снова в консоль.

const COST_OF_ITEM = 200;

const totalPrice = quantity => COST_OF_ITEM * quantity;

console. log(totalPrice(2)); 
console.log(totalPrice(2));

Вторая «нечистая» функция

Наш второй пример «нечистой» функции — это функция, которая получает один и тот же аргумент, но возвращает разные результаты. Часто в наших приложениях нам нужно создавать объекты, которые имеют уникальные идентификаторы, такие как id.

Давай создадим функцию generateID. Эта функция будет возвращать целое число в случайном порядке. Это «нечистая» функция, так как вызвав её несколько раз, каждый раз мы получим разный результат.

const generateID = () => Math.floor(Math.random() * 10000);

console.log(generateID()); 
console.log(generateID()); 
console.log(generateID());

Давай используем нашу «нечистую» функцию generateID внутри фабричной функции для создания пользовательских объектов. Чтобы создать пользователя, createUser принимает два параметра: name и age, и возвращает объект с id, используя функцию generateID для его создания, а также name и age.

const generateID = () => Math.floor(Math.random() * 10000);

const createUser = (name, age) => ({
  id: generateID(),
  name,
  age
});

Вызовем createUser несколько раз, с одинаковыми аргументами.

const generateID = () => Math.floor(Math.random() * 10000);

const createUser = (name, age) => ({
  id: generateID(),
  name,
  age
});
console.log(createUser("Alex", 28)); 
console.log(createUser("Alex", 28)); 
console.log(createUser("Alex", 28));

Если посмотрим в консоль, то увидим, что мы получили похожие объекты, но они не одинаковые — id у всех разный.

«Нечистота» функции generateID делает нашу фабричную функцию createUser «нечистой». Для того чтобы исправить это — можно переместить «нечистую» функцию за пределы фабрики и вызвать её где-нибудь, где мы ожидаем побочный эффект, и передать id в качестве параметра в нашу фабрику createUser.

Третья «нечистая» функция

Третий пример. Как и в примере с глобальной переменной, мы можем создавать функции, которые изменяют состояние нашего приложения, вызывая побочный эффект.

Допустим, мы отслеживаем изменяемое значение (в данном случае id). Если мы создадим функцию, которая изменяет это значение, у нас будет «нечистая» функция. Например фабричная функция createPersone.

let id = 0;

const createPersone = name => ({
  id: ++id,
  name
});

Если мы генерируем наш id для этого объекта, изменяя значение глобального id, то это «нечистая» функция. Вызвав эту функции несколько раз с разными name, то увидим, что id увеличился как мы и ожидали, но если мы также выведем в консоль глобальное значение id, то увидим, что оно тоже изменилось.

let id = 0;

const createPersone = name => ({
  id: ++id,
  name
});

console. log(createPersone("Alex")); 
console.log(createPersone("Julia")); 
console.log(id);

Четвертая «нечистая» функция

Последний четвертый пример «нечистой» функции — это побочный эффект “внешнего мира”. console.log — «нечистая» функция, так как она создает побочный эффект во “внешнем мире”.

Каждый раз, когда мы используем console.log, это влияет на нашу консоль, а это побочный эффект. Если у нас есть какая-либо функция, использующая console.log, (например, функция logger, которая принимает сообщение и выводит его) это тоже «нечистая» функция.

const logger = msg => {
  console.log(msg);
};

logger("Всем привет!");

[ Задача JavaScript ]: массивы, циклы, условные операторы

Во время решения следующей задачи будут задействованы массивы, циклы, условные операторы, генератор случайных чисел и математические функции.

Задача

  1. Сформировать для ученика список состоящий из n элементов, каждый элемент которого — это оценка от 2 до 5.
    Подсчитать среднее арифметическое и в соответствии с этим дать определение ученику: отличник, хорошист, троечник, двоечник.
  2. Подсчитать количество каждой полученной оценки.

Решение

Для решения первой части задачи требуется сгенерировать массив с оценками, при этом для формирования каждой оценки потребуется генератор случайных чисел.

Необходимо определить количество оценок, которое получал ученик, минимальный и максимальный баллы и пустой массив, который будет содержать оценки ученика, а также переменную, которая будет содержать средний балл и переменную, содержащую определение ученику:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

// кол-во полученных учеником оценок

var n = 20;

 

// определение массива, содержащего оценки ученика

var scores = [];

 

// минимальная оценка, которую может получить ученик

var min = 2;

 

// максимальная оценка, которую может получить ученик

var max = 5;

 

// средняя арифметическая оценка ученика

var sum = 0;

 

// определение переменной содержащей определение ученика

var who = »;

Теперь необходимо провести цикл в котором будет случайным образом генерироваться оценка и помещаться в массив, цикл должен повториться n раз, чтобы набралось определенное ранее количество оценок в массиве:

// цикл формирования списка оценок

for ( var i = 0; i < n; i++ ) {

 

// формирование оценки путем выбора случайного числа от min до max и помещение этой оценки в список всех оценок

scores[ i ] = Math. floor( Math.random() * (max — min + 1) ) + min;

 

// подсчет суммы всех оценок

sum += scores[ i ];

}

Также в цикле считается среднее арифметическое между всеми оценками:

К текущей сумме баллов прибавляется текущий балл, который был добавлен строкой выше и который является i-ым элементом массива, поэтому к нему можно обращаться указав его порядковый номер, что мы и делаем.

После окончания цикла необходимо полученную сумму в переменной sum разделить на количество оценок в сформированном массиве. Можно было бы узнать размер массива с помощью .length, но так как мы сами задавали размер в переменной n достаточно будет просто разделить на n, а за тем округлить результат.

sum = Math.round( sum / n );

После всего проделанного осталось дать определение ученику:

switch ( sum ) {

case 5:

who = ‘отличник’;

break;

case 4:

who = ‘хорошист’;

break;

case 3:

who = ‘троечник’;

break;

case 2:

who = ‘двоечник’;

break;

default:

who = ‘не ясно кто’;

}

…и вывести результат:

// вывод информации в консоль

console. log( ‘Оценки: ‘ + scores );

console.log( ‘Средняя оценка — ‘ + sum );

console.log( ‘Ученик — ‘ + who );

Вторая часть задачи

Для выполнения второй части задания до цикла необходимо определить переменную, которая будет содержать в себе количества каждой из оценок. Так как оценок несколько, то переменная, хранящая информацию о количестве каждой оценки, должна быть массивом. Мы условимся, что нулевой элемент будет содержать количество двоек, полученных учеником, первый — количество троек и так далее. В начальный момент мы еще не сформировали список оценок ученика, поэтому количество каждой из оценок равно нулю:

var most = [ 0, 0, 0, 0 ];

Внутри цикла необходимо добавить подсчет количества оценок. Это можно сделать с помощью условного оператора switch:

switch ( scores[ i ] ) {

case 5:

most[ 3 ]++;

break;

case 4:

most[ 2 ]++;

break;

case 3:

most[ 1 ]++;

break;

case 2:

most[ 0 ]++;

break;

}

Но данный подход не рационален, так как если максимальный балл увеличится с пятерки, скажем до 100, придется писать слишком много условий, поэтому мы запишем гораздо проще:

// увеличение кол-ва конкретных оценок, так как порядковый номер для оценок соответствует формуле score — min

most[ scores[ i ] — min ]++;

В данном случае мы вычисляем индекс элемента, который надо увеличить на единицу: scores[ i ] - min

scores[ i ] — это только что сгенерированная оценка, например 5, а min — это минимальная оценка, равная 2. Если вычесть из пяти два, получится три, 3 — это порядковый номер элемента в массиве most, который хранит количество пятерок и именно его значение мы увеличиваем на единицу.

После всего этого необходимо вывести информацию о количестве полученных оценок:

// определение счетчика равного максимально возможной оценке

i = max;

 

// перебор оценкок, которые, по значению, больше min

while ( i >= min ) {

 

// вывод кол-ва каждой оценки

console.log( ‘Кол-во ‘ + i + ‘-к: ‘ + most[ i — 2 ] );

 

// декремент счетчика

i—;

}

Результат выполнения скрипта


JavaScript · Loginom Help

При установке синтаксиса JavaScript область кода выражения должна содержать скрипт JavaScript. Следующий пример демонстрирует вычисление суммы двух полей Калькулятора:


let result;
result = COL1 + COL2;

return result;

В теле скрипта можно использовать ссылки на другие поля или переменные Калькулятора, в том числе новые, созданные в списке выражений.

Примечание: В выражении возможно использовать ссылки на ранее вычисленные выражения, т.е. находящиеся выше в списке выражений. В связи с этим неверная позиция в списке может приводить к ошибке.

В данном примере для вычисления переменной result используются ссылки на поля с именами COL1 и COL2.

Для вывода результата в вычисляемое поле калькулятора используется команда return, которая возвращает значение переменной result, содержащей вычисленную сумму полей Калькулятора.

Важно: скрипт необходимо завершать командой return, которая выводит результат в вычисляемое поле калькулятора. В противном случае скрипт будет выполнен, но результат не будет выведен в вычисляемое поле.

Компактный вариант кода вычисления суммы полей калькулятора:


return COL1 + COL2;

Пример вычисления степени числа:


function pow(x, n) {
  if (n != 1) {
    return x * pow(x, n - 1);
  } else {
    return x;
  }
}

return pow(COL1, COL2);

В данном скрипте определена функция pow(x, n), принимающая в качестве аргументов число и степень, в которую оно возводится. Для вывода результата скрипта в вычисляемое поле калькулятора используется команда return pow(COL1, COL2), где pow(COL1, COL2) — вызов объявленной функции с передачей параметрам х и n значений из полей (или переменных) калькулятора COL1 и COL2 соответственно.

В коде JavaScript можно использовать встроенные функции Калькулятора:

function my_concat(x, n) {
 let s;
 
 s = Concat(x,n);       

return s;
}

return my_concat(COL1, COL2);

Наименования встроенных функций Калькулятора и JavaScript не пересекаются. Функции Калькулятора всегда начинаются с большой буквы, однако, их можно переопределить в коде JS. Явного импорта функций Калькулятора (как это делается в компоненте JavaScript) делать не нужно.

Примечание: в отличии от компонента JavaScript в Калькуляторе не поддерживается объект Promise.