TestAssesment

// ====================================================
// явная/неявная, сильная/слабая, статическая/динамическая типизация
// ____________________________________________________

// Статическая / динамическая типизация. Статическая определяется тем,
// что конечные типы переменных и функций устанавливаются на этапе компиляции.
// Т.е. уже компилятор на 100% уверен, какой тип где находится.
// В динамической типизации все типы выясняются уже во время выполнения программы.


// Сильная / слабая типизация (также иногда говорят строгая / нестрогая).
// Сильная типизация выделяется тем, что язык не позволяет смешивать в выражениях различные типы
// и не выполняет автоматические неявные преобразования, например нельзя вычесть из строки множество.
// Языки со слабой типизацией выполняют множество неявных преобразований автоматически,
// даже если может произойти потеря точности или преобразование неоднозначно.


// Явная / неявная типизация. Явно-типизированные языки отличаются тем,
// что тип новых переменных / функций / их аргументов нужно задавать явно.
// Соответственно языки с неявной типизацией перекладывают эту задачу на компилятор / интерпретатор.

// ====================================================


// ====================================================
// Клиент-серверная модель. Критический путь рендеринга
// ____________________________________________________

// Клиент-серверная модель - архитектура, в которой взаимодействие между компонентами происходят по средствам запросов.
// Сервер ожидают от клиента запросы и предоставляет клиенту свои ресурсы в виде данных или в виде сервисных функций.

// Преимущества:
// 1. Отсутствие дублирования кода программы-сервера программами-клиентами.
// 2. Так как все вычисления выполняются на сервере, то требования к компьютерам,
// на которых установлен клиент, снижаются.
// 3. Все данные хранятся на сервере, который, как правило, защищён гораздо лучше большинства клиентов.
// На сервере проще организовать контроль полномочий, чтобы разрешать доступ к данным
// только клиентам с соответствующими правами доступа.

// Недостатки:
// 1. Неработоспособность сервера может сделать неработоспособной всю вычислительную сеть.
// 2. Поддержка работы данной системы требует отдельного специалиста — системного администратора.
// 3. Высокая стоимость оборудования.

https://medium.com/genesis-media/3933c96467a
// ====================================================


// ====================================================
// Рассказать об особенностях архитектуры flux
// Рассказать о 3-x основных принцыпах редакса
// ____________________________________________________

// особенность - однонаправленный поток данных

// 1. Всё состояние приложения хранится в единственном месте
// 2. Состояние приложения нельзя изменять напрямую
// 3. Все изменения обрабатываются чистой функцией - редьюсером
// ====================================================


// ====================================================
// Написать полифил для Function.prototype.myBind
// ____________________________________________________

// Function.prototype.myBind = function (context, ...props){
//   context = typeof(context) === 'object' && context instanceof Object ? context : null;

//   const helper = (...args) => {
//     return this.call(context, ...props, ...args)
//   }

//   return helper
// }

// ====================================================


// ====================================================
// Написать полифил для Object.create()
// ____________________________________________________

// function myObjCreate(obj){
//   function F(){};
//   F.prototype = obj;

//   return new F
// }

// ====================================================


// ====================================================
// Что будет в консоли?
// ____________________________________________________

// let a = {one: 1}

// let b = a

// a = {two: 2}

// console.log(b)  // {one: 1}

// ====================================================

// ====================================================
// Написать пример работы наследования в js
// ____________________________________________________

// function A(name) {
//   this.name = name
// }

// A.prototype.getName = function() { return this.name }

// function B(name) {
//  A.call(this, name)
// }

// B.prototype = Object.create(A.prototype)
// B.prototype.constructor = B;

// ====================================================

// ====================================================
// Что будет в консоли?
// ____________________________________________________

// const a = {c: 1}
// const b = Object.create(a)

// console.log(b.c) // 1
// delete b.c
// console.log(b.c) // 1
// delete a.c
// console.log(b.c) // undefined

// a.z = 2
// console.log(b.z) // 2
// b.z = 3
// console.log(a.z) // 2

// ====================================================

// ====================================================
// что выведется и в каком порядке?
// ____________________________________________________

// function job(state) {
//     return new Promise(function(resolve, reject) {
//         if (state) {
//             resolve('success');
//         } else {
//             reject('error');
//         }
//     });
// }

// let promise = job(true);

// promise
// .then(function(data) {
//     console.log(data);  // 'success'

//     return job(true);
// })

// .then(function(data) {
//     if (data !== 'victory') {
//         throw 'Defeat';
//     }

//     return job(true);
// })

// .then(function(data) {
//     console.log(data);
// })

// .catch(function(error) {
//     console.log(error); // 'Defeat'

//     return job(false);
// })

// .then(function(data) {
//     console.log(data);

//     return job(true);
// })

// .catch(function(error) {
//     console.log(error); // 'error'

//     return 'Error caught';
// })

// .then(function(data) {
//     console.log(data); // 'Error caught'

//     return new Error('test');
// })

// .then(function(data) {
//     console.log('Success:', data.message);  // 'Success:test'
// })

// .catch(function(data) {
//     console.log('Error:', data.message);
// });

// ____________________________________________________

// let val = 'foo';

// setTimeout(
//   function timeout() {
//     console.log(val, 4, 'foo');
//     val = 'bar';
//   }, 0);

// const p = new Promise((res, rej) => {
//   console.log(val, 1, 'foo');
//   val = 'baz';
//   res(val);
// });

// p.then(res => console.log(val, 3, 'foo') );

// console.log(val, 2, 'baz');
// val = 'foo';

// ====================================================

// ====================================================
// Написать функцию checkMonoInfo
// ____________________________________________________

// const checkMonoInfo = arr => {
//   let result;
//   if (arr.length < 3) return true;

//   for (let i = 2; i < arr.length; i++){
//     result = arr[i - 2] <= arr[i - 1] && arr[i - 1] <= arr[i]
//       || arr[i - 2] >= arr[i - 1] && arr[i - 1] >= arr[i]

//     if (!result) break;
//   };

//   return result
// };


// console.log(checkMonoInfo([1, 1, 1, 1])); // true
// console.log(checkMonoInfo([1, 1, 1, 2])); // true
// console.log(checkMonoInfo([2, 2, 2, 1]) ) // true
// console.log(checkMonoInfo([1, 2, 2, 3])) // true
// console.log(checkMonoInfo([5, 4, 3, 3, 2])); // true

// console.log(checkMonoInfo([1, 2, 2, 3, 2]));  // false

// ====================================================

// ====================================================
// Написать функцию capitalize
// ____________________________________________________

// const capitalize = str => str.split(' ')
//   .map(word => word[0].toUpperCase() + word.substr(1))
//   .join(' ')


// console.log(capitalize('a short sentence')) // 'A Short Sentence'
// console.log(capitalize('a lazy fox')) // 'A Lazy Fox'
// console.log(capitalize('look, it is working!')) // 'Look, It Is Working!'

// ====================================================

// ====================================================
// Написать функцию sum
// ____________________________________________________

// const sum = n => {
//   const buff = [n];
//   let result;
//   const f = (...numbers) => {
//     buff.push(...numbers);

//     if (!numbers.length){
//       result = buff.reduce((a, b) => a + b, 0)
//       return result
//     }

//     return f
//   }

//   f.valueOf = () => buff.reduce((a, b) => a + b, 0)
//   return f
// }


// console.log(sum(1)(4)()) // 5
// console.log(sum(1)(2) - 6) // -3
// console.log(sum(1)(3)(5)) // function sum(){}

// ====================================================

// ====================================================
// * Написать EventEmitter (pub/sub паттерн)
// ____________________________________________________

// const EventEmitter = class {
//   constructor(){
//     this.events = {};
//   }

//   subscribe(eventName, func){
//     if(!this.events[eventName]){
//       this.events[eventName] = [];
//     };

//     this.events[eventName].push(func);

//     return () => {
//       this.events[eventName] = this.events[eventName].filter(eventFn => func !== eventFn);
//     }
//   };

//   emit(eventName, data){
//     if(eventName in this.events){
//       this.events[eventName].forEach(func => func(data));
//     }
//   }
// };

// const Publisher = class {
// constructor (e) {
//     this.EventEmitter = e;
//   }

//   save (data) {
//     console.log('Order saved');
//     this.EventEmitter.emit('order/new', data)
//   }
// }

// const Subscriber = class {
//   constructor (e) {
//     e.subscribe('order/new', this.sendPurchaseEmail)
//   }

//   sendPurchaseEmail (params) {
//     console.log(`Email send to ${params.userEmail}`)
//   }
// }


// const emitter = new EventEmitter();
// const sub = new Subscriber(emitter)
// const pub = new Publisher(emitter)
// pub.save({userEmail: '[email protected]'})

// ====================================================