From d9b313fc2bed06cda017267c726fa84e81d0ca72 Mon Sep 17 00:00:00 2001 From: Polyakov Andrey Date: Thu, 25 Oct 2018 11:57:09 +0300 Subject: [PATCH 1/6] dz1 --- src/index.js | 119 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) diff --git a/src/index.js b/src/index.js index e69de29..46a388d 100644 --- a/src/index.js +++ b/src/index.js @@ -0,0 +1,119 @@ +/* ДЗ 1 - Функции */ + +/* + Задание 1: + + 1.1: Добавьте к функции параметр с любым именем + 1.2: Функция должна возвращать аргумент, переданный ей в качестве параметра + + Пример: + returnFirstArgument(10) вернет 10 + returnFirstArgument('привет') вернет `привет` + + Другими словами: функция должна возвращать в неизменном виде то, что поступает ей на вход + */ +function returnFirstArgument(param) { + return param; +} + +/* + Задание 2: + + 2.1: Функция должна возвращать сумму переданных аргументов + + Пример: + sumWithDefaults(10, 20) вернет 30 + sumWithDefaults(2, 4) вернет 6 + + 2.1 *: Значение по умолчанию для второго аргумента должно быть равно 100 + + Пример: + sumWithDefaults(10) вернет 110 + */ +function sumWithDefaults(a, b) { + return a + b; +} + +/* + Задание 3: + + Функция должна принимать другую функцию и возвращать результат вызова этой функции + + Пример: + returnFnResult(() => 'привет') вернет 'привет' + */ +function returnFnResult(fn) { + return fn() +} + +returnFnResult(() => 'hello'); + +/* + Задание 4: + + Функция должна принимать число и возвращать новую функцию (F) + При вызове функции F, переданное ранее число должно быть увеличено на единицу и возвращено из F + + Пример: + var f = returnCounter(10); + + console.log(f()); // выведет 11 + console.log(f()); // выведет 12 + console.log(f()); // выведет 13 + */ +function returnCounter(number) { + return () => ++number; +} + +/* + Задание 5 *: + + Функция должна возвращать все переданные ей аргументы в виде массива + Количество переданных аргументов заранее неизвестно + + Пример: + returnArgumentsArray(1, 2, 3) вернет [1, 2, 3] + */ +function returnArgumentsArray() { + let arr = []; + + for (let i = 0; i < arguments.length; i++) { + arr.push(arguments[i]) + } + + return arr; +} + +/* + Задание 6 *: + + Функция должна принимать другую функцию (F) и некоторое количество дополнительных аргументов + Функция должна привязать переданные аргументы к функции F и вернуть получившуюся функцию + + Пример: + function sum(a, b) { + return a + b; + } + + var newSum = bindFunction(sum, 2, 4); + + console.log(newSum()) выведет 6 + */ +function bindFunction(fn) { + let arr = []; + + for (let i = 1; i < arguments.length; i++) { + arr.push(arguments[i]) + } + + return fn.apply(this, arr) +} + +export { + returnFirstArgument, + sumWithDefaults, + returnArgumentsArray, + returnFnResult, + returnCounter, + bindFunction +} From cc3d1c81f0142bcd76a013497815c9a912b9079a Mon Sep 17 00:00:00 2001 From: Polyakov Andrey Date: Thu, 25 Oct 2018 14:35:09 +0300 Subject: [PATCH 2/6] =?UTF-8?q?=D0=BD=D0=B5=D1=81=D0=BA=D0=BE=D0=BB=D1=8C?= =?UTF-8?q?=D0=BA=D0=BE=20=D0=B2=D0=B0=D1=80=D0=B8=D0=B0=D0=BD=D1=82=D0=BE?= =?UTF-8?q?=D0=B2=20=D1=88=D0=B5=D1=81=D1=82=D0=BE=D0=B3=D0=BE=20=D0=B7?= =?UTF-8?q?=D0=B0=D0=B4=D0=B0=D0=BD=D0=B8=D1=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/index.js | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/src/index.js b/src/index.js index 46a388d..4c482ff 100644 --- a/src/index.js +++ b/src/index.js @@ -100,13 +100,27 @@ function returnArgumentsArray() { console.log(newSum()) выведет 6 */ function bindFunction(fn) { + return fn.call(...arguments); +} + +// вариант 2 +function bindFunctionTwo(fn) { + let arr = [...arguments]; + + arr.splice(0, 1); + + return fn.apply(null, arr); +} + +// Вариант 3 +function bindFunctionThree(fn) { let arr = []; for (let i = 1; i < arguments.length; i++) { arr.push(arguments[i]) } - return fn.apply(this, arr) + return fn.apply(null, arr) } export { @@ -115,5 +129,7 @@ export { returnArgumentsArray, returnFnResult, returnCounter, - bindFunction + bindFunction, + bindFunctionTwo, + bindFunctionThree, } From 1e9bd1f9b2114ecb46b510247ea25ebbb1e4f88f Mon Sep 17 00:00:00 2001 From: Polyakov Andrey Date: Thu, 25 Oct 2018 14:42:00 +0300 Subject: [PATCH 3/6] =?UTF-8?q?=D0=BF=D1=80=D0=B0=D0=BA=D0=B0=20=D0=BF?= =?UTF-8?q?=D0=BE=20=D0=BF=D1=8F=D1=82=D0=BE=D0=BC=D1=83=20=D0=B7=D0=B0?= =?UTF-8?q?=D0=B4=D0=BD=D0=B8=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/index.js | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/index.js b/src/index.js index 4c482ff..d4b8665 100644 --- a/src/index.js +++ b/src/index.js @@ -75,13 +75,7 @@ function returnCounter(number) { returnArgumentsArray(1, 2, 3) вернет [1, 2, 3] */ function returnArgumentsArray() { - let arr = []; - - for (let i = 0; i < arguments.length; i++) { - arr.push(arguments[i]) - } - - return arr; + return [...arguments]; } /* From 7bcb8e365b5d663e865f3ce772705672989a6c81 Mon Sep 17 00:00:00 2001 From: Polyakov Andrey Date: Thu, 25 Oct 2018 15:13:04 +0300 Subject: [PATCH 4/6] =?UTF-8?q?=D0=BF=D1=80=D0=B0=D0=BA=D0=B8=20=D0=BF?= =?UTF-8?q?=D0=BE=20=D1=82=D0=B5=D1=81=D1=82=D1=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/index.js | 4 +- test/index.js | 115 ++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 113 insertions(+), 6 deletions(-) diff --git a/src/index.js b/src/index.js index d4b8665..256b11d 100644 --- a/src/index.js +++ b/src/index.js @@ -30,7 +30,7 @@ function returnFirstArgument(param) { Пример: sumWithDefaults(10) вернет 110 */ -function sumWithDefaults(a, b) { +function sumWithDefaults(a, b = 100) { return a + b; } @@ -61,7 +61,7 @@ returnFnResult(() => 'hello'); console.log(f()); // выведет 12 console.log(f()); // выведет 13 */ -function returnCounter(number) { +function returnCounter(number = 0) { return () => ++number; } diff --git a/test/index.js b/test/index.js index 9d2a198..b8678b3 100644 --- a/test/index.js +++ b/test/index.js @@ -1,7 +1,114 @@ -import assert from 'assert'; +import { assert } from 'chai'; +import { randomValue as random, randomStringArray } from '../helper'; +import { + bindFunction, + sumWithDefaults, + returnArgumentsArray, + returnCounter, + returnFirstArgument, + returnFnResult +} from '../src/index'; -describe('Test', () => { - it('should work', () => { - assert(true == true); +describe('ДЗ 1 - функции', () => { + describe('returnFirstArgument', () => { + it('должна возвращать переданный аргумент', () => { + let value = random(); + let result = returnFirstArgument(value); + + assert.strictEqual(result, value); + }); + }); + + describe('sumWithDefaults', () => { + it('должна возвращать сумму переданных аргументов', () => { + let valueA = random('number'); + let valueB = random('number'); + let result = sumWithDefaults(valueA, valueB); + + assert.strictEqual(result, valueA + valueB); + }); + + it('значение по умолчанию второго аргумента должно быть 100', () => { + let value = random('number'); + let result = sumWithDefaults(value); + + assert.strictEqual(result, value + 100); + }); + }); + + describe('returnArgumentsArray', () => { + it('должна возвращать переданные аргументы в виде массива', () => { + let result; + let value; + + value = random('array', 1); + result = returnArgumentsArray(...value); + assert.deepEqual(result, value); + }); + + it('должна возвращать пустой массив если нет аргументов', () => { + let result = returnArgumentsArray(); + + assert.deepEqual(result, []); + }); + }); + + describe('returnFnResult', () => { + it('должна возвращать результат вызова переданной функции', () => { + function fn() { + return value; + } + + let value = random(); + let result = returnFnResult(fn); + + assert.strictEqual(result, value); + }); + }); + + describe('returnCounter', () => { + it('должна возвращать функцию', () => { + let result = returnCounter(); + + assert.typeOf(result, 'function'); + }); + + it('возвращаемая функция должна увеличивать переданное число на единицу при каждом вызове', () => { + let value = random('number'); + let result = returnCounter(value); + + assert.equal(result(), value + 1); + assert.equal(result(), value + 2); + assert.equal(result(), value + 3); + }); + + it('значение аргумента должно быть 0 по умолчанию', () => { + let result = returnCounter(); + + assert.equal(result(), 1); + assert.equal(result(), 2); + assert.equal(result(), 3); + }); + }); + + describe('bindFunction', () => { + let valuesArr = randomStringArray(); + + function fn(...valuesArr) { + return [...arguments].join(''); + } + + it('должна возвращать функцию', () => { + let result = bindFunction(fn); + + assert.typeOf(result, 'function'); + }); + + it('должна привязывать любое кол-во аргументов возвращаемой функции', () => { + + let result = bindFunction(fn, ...valuesArr); + + assert.equal(result(), valuesArr.join('')); + }); }); }); From 28e5aad1ae5d3f8f61deaead0fc1944b3fe32518 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BD=D0=B4=D1=80=D0=B5=D0=B9=20=D0=9F=D0=BE=D0=BB?= =?UTF-8?q?=D1=8F=D0=BA=D0=BE=D0=B2?= Date: Thu, 25 Oct 2018 22:28:34 +0300 Subject: [PATCH 5/6] =?UTF-8?q?=D0=B4=D0=BE=D0=B2=D0=B5=D0=BB=20=D0=B4?= =?UTF-8?q?=D0=BE=20=D0=BF=D0=BE=D0=BB=D0=BD=D0=BE=D0=B3=D0=BE=20=D0=BF?= =?UTF-8?q?=D1=80=D0=BE=D1=85=D0=BE=D0=B6=D0=B4=D0=B5=D0=BD=D0=B8=D1=8F=20?= =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/index.js | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/src/index.js b/src/index.js index 256b11d..9b6d8f2 100644 --- a/src/index.js +++ b/src/index.js @@ -93,17 +93,13 @@ function returnArgumentsArray() { console.log(newSum()) выведет 6 */ -function bindFunction(fn) { - return fn.call(...arguments); +function bindFunction(fn, ...arr) { + return () => fn.apply(null, arr); } // вариант 2 function bindFunctionTwo(fn) { - let arr = [...arguments]; - - arr.splice(0, 1); - - return fn.apply(null, arr); + return () => fn.call(...arguments); } // Вариант 3 @@ -114,7 +110,7 @@ function bindFunctionThree(fn) { arr.push(arguments[i]) } - return fn.apply(null, arr) + return () => fn.apply(null, arr) } export { From 98c45890d61f8cb71c4c3e6705304f84fa20f73f Mon Sep 17 00:00:00 2001 From: Polyakov Andrey Date: Thu, 1 Nov 2018 15:07:21 +0300 Subject: [PATCH 6/6] =?UTF-8?q?=D0=94=D0=972?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/index.js | 169 +++++++++++++++--------------- test/index.js | 283 ++++++++++++++++++++++++++++++++++++++------------ 2 files changed, 302 insertions(+), 150 deletions(-) diff --git a/src/index.js b/src/index.js index 9b6d8f2..bafff6b 100644 --- a/src/index.js +++ b/src/index.js @@ -1,125 +1,132 @@ -/* ДЗ 1 - Функции */ +/* ДЗ 2 - работа с массивами и объеектами */ /* Задание 1: - 1.1: Добавьте к функции параметр с любым именем - 1.2: Функция должна возвращать аргумент, переданный ей в качестве параметра - - Пример: - returnFirstArgument(10) вернет 10 - returnFirstArgument('привет') вернет `привет` - - Другими словами: функция должна возвращать в неизменном виде то, что поступает ей на вход + Напишите аналог встроенного метода forEach для работы с массивами + Посмотрите как работает forEach и повторите это поведение для массива, который будет передан в параметре array */ -function returnFirstArgument(param) { - return param; +function forEach(array, fn) { + for (let i = 0; i < array.length; i++) { + fn(array[i], i, array) + } } /* Задание 2: - 2.1: Функция должна возвращать сумму переданных аргументов - - Пример: - sumWithDefaults(10, 20) вернет 30 - sumWithDefaults(2, 4) вернет 6 + Напишите аналог встроенного метода map для работы с массивами + Посмотрите как работает map и повторите это поведение для массива, который будет передан в параметре array + */ +function map(array, fn) { + let newArr = []; - 2.1 *: Значение по умолчанию для второго аргумента должно быть равно 100 + for (let i = 0; i 'привет') вернет 'привет' + Напишите аналог встроенного метода reduce для работы с массивами + Посмотрите как работает reduce и повторите это поведение для массива, который будет передан в параметре array */ -function returnFnResult(fn) { - return fn() -} +function reduce(array, fn, initial) { + let i; + + if (initial == undefined) { + initial = array[0]; + i=1; + } else { + i=0; + } + for (; i 'hello'); + return initial; +} /* Задание 4: - Функция должна принимать число и возвращать новую функцию (F) - При вызове функции F, переданное ранее число должно быть увеличено на единицу и возвращено из F + Функция должна перебрать все свойства объекта, преобразовать их имена в верхний регистр и вернуть в виде массива Пример: - var f = returnCounter(10); - - console.log(f()); // выведет 11 - console.log(f()); // выведет 12 - console.log(f()); // выведет 13 + upperProps({ name: 'Сергей', lastName: 'Петров' }) вернет ['NAME', 'LASTNAME'] */ -function returnCounter(number = 0) { - return () => ++number; +function upperProps(obj) { + let arr = []; + let key = Object.keys(obj).length; + + for (let i = 0; i < key; i++) { + arr.push(Object.keys(obj)[i].toUpperCase()); + } + + return arr } /* Задание 5 *: - Функция должна возвращать все переданные ей аргументы в виде массива - Количество переданных аргументов заранее неизвестно - - Пример: - returnArgumentsArray(1, 2, 3) вернет [1, 2, 3] + Напишите аналог встроенного метода slice для работы с массивами + Посмотрите как работает slice и повторите это поведение для массива, который будет передан в параметре array */ -function returnArgumentsArray() { - return [...arguments]; +function slice(array, from = 0, to = array.length) { + let newArr =[]; + + if (from > array.length) { + from = array.length; + } + if (to > array.length) { + to = array.length; + } + if (from < 0 && from + array.length < 0) { + from =0; + } + if (from < 0 && from + array.length > 0) { + from = from + array.length; + } + if (to < 0 && to + array.length < 0) { + to = 0; + } + if (to < 0 && to + array.length > 0) { + to = to + array.length; + } + for (let i = from; i fn.apply(null, arr); -} +function createProxy(obj) { -// вариант 2 -function bindFunctionTwo(fn) { - return () => fn.call(...arguments); -} + let proxy = new Proxy(obj, { + set(target, prop, value) { + target[prop] = value * value; -// Вариант 3 -function bindFunctionThree(fn) { - let arr = []; + return target[prop]; + } + }); - for (let i = 1; i < arguments.length; i++) { - arr.push(arguments[i]) - } - - return () => fn.apply(null, arr) + return proxy; } export { - returnFirstArgument, - sumWithDefaults, - returnArgumentsArray, - returnFnResult, - returnCounter, - bindFunction, - bindFunctionTwo, - bindFunctionThree, -} + forEach, + map, + reduce, + upperProps, + slice, + createProxy +}; diff --git a/test/index.js b/test/index.js index b8678b3..d8069a0 100644 --- a/test/index.js +++ b/test/index.js @@ -1,114 +1,259 @@ +const nativeSlice = Array.prototype.slice; +const nativeMap = Array.prototype.map; +const nativeReduce = Array.prototype.reduce; + import { assert } from 'chai'; -import { randomValue as random, randomStringArray } from '../helper'; +import { randomValue as random, randomNumberArray } from '../helper'; import { - bindFunction, - sumWithDefaults, - returnArgumentsArray, - returnCounter, - returnFirstArgument, - returnFnResult + forEach, + map, + reduce, + upperProps, + slice, + createProxy } from '../src/index'; -describe('ДЗ 1 - функции', () => { - describe('returnFirstArgument', () => { - it('должна возвращать переданный аргумент', () => { - let value = random(); - let result = returnFirstArgument(value); +describe('ДЗ 3 - объекты и массивы', () => { + describe('forEach', () => { + it('должна вызывать функцию для каждого элемента массива и передавать элемент первым аргументом', () => { + let array = randomNumberArray(); + let passed = []; + + forEach(array, el => passed.push(el)); - assert.strictEqual(result, value); + assert.deepEqual(array, passed); }); - }); - describe('sumWithDefaults', () => { - it('должна возвращать сумму переданных аргументов', () => { - let valueA = random('number'); - let valueB = random('number'); - let result = sumWithDefaults(valueA, valueB); + it('должна передавать индекс элемента вторым аргументом', () => { + let array = randomNumberArray(); + let index = 0; - assert.strictEqual(result, valueA + valueB); + forEach(array, (el, i) => assert.equal(i, index++)); }); - it('значение по умолчанию второго аргумента должно быть 100', () => { - let value = random('number'); - let result = sumWithDefaults(value); + it('должна передавать сам массив третьим аргументом', () => { + let array = randomNumberArray(); - assert.strictEqual(result, value + 100); + forEach(array, (el, i, a) => assert.strictEqual(a, array)); }); }); - describe('returnArgumentsArray', () => { - it('должна возвращать переданные аргументы в виде массива', () => { - let result; - let value; + describe('map', () => { + it('должна вызывать функцию для каждого элемента массива и передавать элемент первым аргументом', () => { + let array = randomNumberArray(); + let passed = []; + + map(array, el => passed.push(el)); - value = random('array', 1); - result = returnArgumentsArray(...value); - assert.deepEqual(result, value); + assert.deepEqual(array, passed); }); - it('должна возвращать пустой массив если нет аргументов', () => { - let result = returnArgumentsArray(); + it('должна передавать индекс элемента вторым аргументом', () => { + let array = randomNumberArray(); + let index = 0; - assert.deepEqual(result, []); + map(array, (el, i) => assert.equal(i, index++)); }); - }); - describe('returnFnResult', () => { - it('должна возвращать результат вызова переданной функции', () => { - function fn() { - return value; - } + it('должна передавать сам массив третьим аргументом', () => { + let array = randomNumberArray(); + + map(array, (el, i, a) => assert.strictEqual(a, array)); + }); - let value = random(); - let result = returnFnResult(fn); + it('должна возвращать измененную копию массива', () => { + let array = randomNumberArray(); + let target = nativeMap.call(array, el => el ** 2); + let result = map(array, el => el ** 2); - assert.strictEqual(result, value); + assert.deepEqual(result, target); + }); + + it('не должна изменять оригинальный массив', () => { + let array = randomNumberArray(); + let arrayCopy = nativeSlice.call(array); + + map(array, el => el ** 2); + assert.deepEqual(array, arrayCopy); }); }); - describe('returnCounter', () => { - it('должна возвращать функцию', () => { - let result = returnCounter(); + describe('reduce', () => { + it('должна вызывать функцию для каждого элемента и передавать предыдущий результат первым аргументом', () => { + let array = randomNumberArray(); + let i = 0; + let prevResult = array[0]; + + reduce(array, prev => { + assert.equal(prev, prevResult); + + return prevResult = i++; + }); + }); + + it('должна учитывать initial', () => { + let array = randomNumberArray(); + let passed = []; + let initial = random('number'); + + reduce(array, prev => passed.push(prev), initial); + assert.deepEqual(passed[0], initial); + }); + + it('если initial не указан, то при первой итерации в prev передается первый элемент массива', () => { + let array = randomNumberArray(); + let passed = []; + + reduce(array, prev => passed.push(prev)); + assert.strictEqual(passed[0], array[0]); + }); + + it('должна передавать элемент вторым аргументом', () => { + let array = randomNumberArray(); + let passed = []; + let initial = random('number'); + + reduce(array, (prev, el) => passed.push(el)); + assert.deepEqual(array.slice(1), passed); + + passed = []; + reduce(array, (prev, el) => passed.push(el), initial); // с учетом initial + assert.deepEqual(array, passed); + }); + + it('должна передавать индекс элемента третьим аргументом', () => { + let array = randomNumberArray(); + let index = 1; + let initial = random('number'); + + reduce(array, (prev, el, i) => assert.equal(i, index++)); - assert.typeOf(result, 'function'); + index = 0; + reduce(array, (prev, el, i) => assert.equal(i, index++), initial); // с учетом initial }); - it('возвращаемая функция должна увеличивать переданное число на единицу при каждом вызове', () => { - let value = random('number'); - let result = returnCounter(value); + it('должна передавать сам массив четвертым аргументом', () => { + let array = randomNumberArray(); - assert.equal(result(), value + 1); - assert.equal(result(), value + 2); - assert.equal(result(), value + 3); + reduce(array, (prev, el, i, a) => assert.strictEqual(a, array)); }); - it('значение аргумента должно быть 0 по умолчанию', () => { - let result = returnCounter(); + it('не должна изменять оригинальный массив', () => { + let array = randomNumberArray(); + let arrayCopy = nativeSlice.call(array); - assert.equal(result(), 1); - assert.equal(result(), 2); - assert.equal(result(), 3); + reduce(array, el => el ** 2); + assert.deepEqual(array, arrayCopy); + }); + + it('общая проверка работоспособности', () => { + let array = randomNumberArray(); + let target = nativeReduce.call(array, (prev, el) => prev + el); + let result = reduce(array, (prev, el) => prev + el); + let initial = random('number'); + + assert.deepEqual(result, target); + + target = nativeReduce.call(array, (prev, el) => prev + el, initial); + result = reduce(array, (prev, el) => prev + el, initial); + assert.deepEqual(result, target); + }); + }); + + describe('upperProps', () => { + it('должна возвращать массив с именами свойств и преобразовывать эти имена в верхний регистр', () => { + let obj = { a: 1, b: 2 }; + let target = ['A', 'B']; + let result = upperProps(obj); + + assert.deepEqual(result, target); }); }); - describe('bindFunction', () => { - let valuesArr = randomStringArray(); + describe('slice', () => { + it('общая проверка работоспособности', () => { + let array = [1, 2, 3, 4, 5, 6, 7]; + let target = nativeSlice.call(array); + let result = slice(array); + + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 0); + result = slice(array, 0); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 0, 0); + result = slice(array, 0, 0); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 0, 1); + result = slice(array, 0, 1); + assert.deepEqual(result, target); - function fn(...valuesArr) { - return [...arguments].join(''); - } + target = nativeSlice.call(array, 0, 2); + result = slice(array, 0, 2); + assert.deepEqual(result, target); - it('должна возвращать функцию', () => { - let result = bindFunction(fn); + target = nativeSlice.call(array, 0, 5); + result = slice(array, 0, 5); + assert.deepEqual(result, target); - assert.typeOf(result, 'function'); + target = nativeSlice.call(array, 0, -1); + result = slice(array, 0, -1); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 0, -3); + result = slice(array, 0, -3); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 0, -10000); + result = slice(array, 0, -10000); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 3); + result = slice(array, 3); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 3, -100); + result = slice(array, 3, -100); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 3, 100); + result = slice(array, 3, 100); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 3, 5); + result = slice(array, 3, 5); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, 9999); + result = slice(array, 9999); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, -9999); + result = slice(array, -9999); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, -9999, 4); + result = slice(array, -9999, 4); + assert.deepEqual(result, target); + + target = nativeSlice.call(array, -9999, -4); + result = slice(array, -9999, -4); + assert.deepEqual(result, target); }); + }); + + describe('createProxy', () => { + it('должна вернуть Proxy, который возводит в квадрат любое записываемое значение', () => { + let obj = {}; - it('должна привязывать любое кол-во аргументов возвращаемой функции', () => { + obj = createProxy(obj); - let result = bindFunction(fn, ...valuesArr); + obj.a = 2; + obj.b = 5; - assert.equal(result(), valuesArr.join('')); + assert.deepEqual(obj, { a: 4, b: 25 }); }); }); });