From 9bf98c039eceebdc85d1411fe5dfa682f26894c2 Mon Sep 17 00:00:00 2001 From: dimabodriagin <65782955+dimabodriagin@users.noreply.github.com> Date: Thu, 11 Jan 2024 09:27:41 +0400 Subject: [PATCH] Add files via upload --- core.js | 168 +++++++++++++++++++++++++++++++++++++++++++++++++++ core.spec.js | 157 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 325 insertions(+) create mode 100644 core.js create mode 100644 core.spec.js diff --git a/core.js b/core.js new file mode 100644 index 0000000..aa7fea7 --- /dev/null +++ b/core.js @@ -0,0 +1,168 @@ +//Напишите функцию, которая проверяет, является ли число целым используя побитовые операторы +function isInteger(n) { + return ~~n == n; +} + +//Напишите функцию, которая возвращает массив четных чисел от 2 до 20 включительно +function even() { + const array = []; + for (let i = 2; i < 21; i += 2) { + array.push(i); + } + //console.log(array); + return array; +} + +//Напишите функцию, считающую сумму чисел до заданного используя цикл +function sumTo(n) { + let ans = 0; + for (let i = 1; i <= n; ++i) { + ans += i; + } + return ans; +} + +//Напишите функцию, считающую сумму чисел до заданного используя рекурсию +function recSumTo(n) { + if (n == 0) { + return 0; + } else { + return recSumTo(n - 1) + n; + } +} + +//Напишите функцию, считающую факториал заданного числа +function factorial(n) { + let ans = 1; + for (let i = 2; i <= n; ++i) { + ans *= i; + } + return ans; +} + +//Напишите функцию, которая определяет, является ли число двойкой, возведенной в степень +function isBinary(n) { + return n && (n & (n - 1)) === 0; +} + +//Напишите функцию, которая находит N-е число Фибоначчи +function fibonacci(n) { + if (n == 1 || n == 2) { + return 1; + } else { + let a = 1; + let b = 1; + let ans = 0; + for (let i = 3; i <= n; ++i) { + ans = a + b; + a = b; + b = ans; + } + return ans; + } +} + +/** Напишите функцию, которая принимает начальное значение и функцию операции + * и возвращает функцию - выполняющую эту операцию. + * Если функция операции (operatorFn) не задана - по умолчанию всегда + * возвращается начальное значение (initialValue) + * @param initialValue + * @param operatorFn - (storedValue, newValue) => {operation} + * @example + * const sumFn = getOperationFn(10, (a,b) => a + b); + * console.log(sumFn(5)) - 15 + * console.log(sumFn(3)) - 18 + */ +function getOperationFn(initialValue, operatorFn) { + let storedValue = initialValue; + if (!operatorFn) { + return () => { + return initialValue; + }; + } else { + return (newValue) => { + return (storedValue = operatorFn(storedValue, newValue)); + }; + } +} + +/** + * Напишите функцию создания генератора арифметической последовательности. + * При ее вызове, она возвращает новую функцию генератор - generator(). + * Каждый вызов функции генератора возвращает следующий элемент последовательности. + * Если начальное значение не передано то оно равно 0. + * Если шаг не угазан, то по дефолту он равен 1. + * Генераторов можно создать сколько угодно - они все независимые. + * + * @param {number} start - число с которого начинается последовательность + * @param {number} step - число шаг полседовательности + * @example + * const generator = sequence(5, 2); + * console.log(generator()); // 5 + * console.log(generator()); // 7 + * console.log(generator()); // 9 + */ +function sequence(start, step) { + start = start ?? 0; + step = step ?? 1; + let storedValue = start - step; + return () => { + return (storedValue += step); + }; +} + +/** + * Напишите функцию deepEqual, которая принимает два значения + * и возвращает true только в том случае, если они имеют одинаковое значение + * или являются объектами с одинаковыми свойствами, + * значения которых также равны при сравнении с рекурсивным вызовом deepEqual. + * Учитывать специфичные объекты(такие как Date, RegExp итп) не обязательно + * + * @param {object} firstObject - первый объект + * @param {object} secondObject - второй оббъект + * @returns {boolean} - true если объекты равны(по сожержанию) иначе false + * @example + * deepEqual({arr: [22, 33], text: 'text'}, {arr: [22, 33], text: 'text'}) // true + * deepEqual({arr: [22, 33], text: 'text'}, {arr: [22, 3], text: 'text2'}) // false + */ +function deepEqual(firstObject, secondObject) { + if (firstObject === secondObject) { + return true; + } + if ( + firstObject === null || + typeof firstObject != 'object' || + secondObject === null || + typeof secondObject != 'object' + ) { + return false; + } + + let propsFirstObject = 0, + propsSecondObject = 0; + for (let prop in firstObject) { + propsFirstObject += 1; + } + for (let prop in secondObject) { + propsSecondObject += 1; + if ( + !(prop in firstObject) || + !deepEqual(firstObject[prop], secondObject[prop]) + ) { + return false; + } + } + return propsFirstObject === propsSecondObject; +} +module.exports = { + isInteger, + even, + sumTo, + recSumTo, + factorial, + isBinary, + fibonacci, + getOperationFn, + sequence, + deepEqual, +}; diff --git a/core.spec.js b/core.spec.js new file mode 100644 index 0000000..07e3b29 --- /dev/null +++ b/core.spec.js @@ -0,0 +1,157 @@ +const assert = require('assert'), + core = require('./core'); + +describe('Задания core js', () => { + describe('#isInteger', () => { + it('Возвращает true на целое число', () => { + assert.equal(core.isInteger(3), true); + }); + + it('Возвращает false на нецелое число', () => { + assert.equal(core.isInteger(1.2), false); + }); + }); + + describe('#even', () => { + it('Возвращает корректный массив', () => { + assert.deepStrictEqual( + core.even(), + [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] + ); + }); + }); + + describe('#sumTo', () => { + it('Возвращает сумму чисел до n', () => { + assert.equal(core.sumTo(4), 10, 'С маленьким числом'); + assert.equal(core.sumTo(100), 5050, 'С большим числом'); + }); + }); + + describe('#recSumTo', () => { + it('Возвращает сумму чисел до n', () => { + assert.equal(core.recSumTo(4), 10, 'С маленьким числом'); + assert.equal(core.recSumTo(100), 5050, 'С большим числом'); + }); + }); + + describe('#factorial', () => { + it('Возвращает факториал n', () => { + assert.equal(core.factorial(5), 120); + assert.equal(core.factorial(4), 24); + }); + }); + + describe('#isBinary', () => { + it('Возвращает true при передаче степени двойки', () => { + assert.equal(core.isBinary(1), true); + assert.equal(core.isBinary(2), true); + assert.equal(core.isBinary(2048), true); + }); + + it('Возвращает false при передаче не степени двойки', () => { + assert.equal(core.isBinary(0), false); + assert.equal(core.isBinary(12), false); + assert.equal(core.isBinary(1023), false); + }); + }); + + describe('#fibonacci', () => { + it('Возвращает n-ое число Фибоначчи корректно', () => { + assert.equal(core.fibonacci(1), 1); + assert.equal(core.fibonacci(2), 1); + assert.equal(core.fibonacci(7), 13); + assert.equal(core.fibonacci(10), 55); + }); + }); + + describe('#getOperationFn', () => { + it('Возвращает функцию', () => { + const sumFn = core.getOperationFn(-1, (a, b) => a + b); + assert.ok(typeof sumFn === 'function'); + }); + + it('Сохраняет внутреннее значение и применяет операцию', () => { + const multFn = core.getOperationFn(-1, (a, b) => a * b); + assert.strictEqual(multFn(-1), 1); + assert.strictEqual(multFn(4), 4); + assert.strictEqual(multFn(2), 8); + }); + + it('По умолчанию всегда возвращает начальное значение, если нет operatorFn', () => { + const staticFn = core.getOperationFn(-1); + assert.strictEqual(staticFn(-1), -1); + assert.strictEqual(staticFn(7), -1); + assert.strictEqual(staticFn(0), -1); + }); + }); + + describe('#sequence', () => { + it('Возвращает функцию с шагом 1 и началом 0, если не переданы значения', () => { + const generator = core.sequence(); + assert.equal(generator(), 0); + assert.equal(generator(), 1); + assert.equal(generator(), 2); + }); + + it('Функция-генератор корректно генерирует значения начиная со start с шагом step', () => { + const generator1 = core.sequence(10, 3); + const generator2 = core.sequence(8, 2); + assert.equal(generator1(), 10); + assert.equal(generator1(), 13); + assert.equal(generator2(), 8); + assert.equal(generator1(), 16); + assert.equal(generator2(), 10); + }); + }); + + describe('#deepEqual', () => { + it('Возвращает true если объекты равны', () => { + assert.equal( + core.deepEqual( + {text: 'some text', count: 3, arr: [11, 22]}, + {text: 'some text', count: 3, arr: [11, 22]} + ), + true + ); + assert.equal( + core.deepEqual( + {obj: {count: 12}, value: null, flag: true}, + {obj: {count: 12}, value: null, flag: true} + ), + true + ); + assert.equal( + core.deepEqual( + {obj: {arr: ['a', 'b']}, value: undefined}, + {obj: {arr: ['a', 'b']}, value: undefined} + ), + true + ); + }); + + it('Возвращает false если объекты не равны', () => { + assert.equal( + core.deepEqual( + {text: 'some text', count: 3, arr: [11, 22]}, + {text: 'some text1', count: 4, arr: [11, 22]} + ), + false + ); + assert.equal( + core.deepEqual( + {obj: {count: 12}, value: null, flag: true}, + {obj: {count: 22}, value: null, flag: false} + ), + false + ); + assert.equal( + core.deepEqual( + {obj: {arr: ['a', 'b']}, value: undefined}, + {obj: {arr: ['a', 'b']}, value: null} + ), + false + ); + }); + }); +});