Роман

const Authorized = require('../moduls/authorized')
const auth = new Authorized();


// так
router.get("path/",auth.isAuthorized.bind(auth));
// или так
router.get("path/",(...a)=>auth.isAuthorized(...a));

isAuthorized(){
   return (req, res, next)=>{
      console.log('isAuth',this)
      // тут код мидлвара
  }
}

router.get("path/",auth.isAuthorized());
// или
router.post("path/",auth.isAuthorized());
// или
router.use(auth.isAuthorized());

const obj = {
  sv1 : 'a',
  sv2: 'b',
  sv3: 'c'
}

if( obj.hasOwnProperty("sv") ) obj.sv = 'z';

const arr = [obj];

...
document.querySelector('#translate_btn').addEventListener('click', function(){
  var word = document.getElementById("translate_form"); //поле ввода слова

  // добавьте эти две  строчки!!!!!
  if( !word.value ) return;
  url = 'https://translate.yandex.net/api/v1.5/tr.json/translate';


  var langTranslate = document.querySelector('.lang_list');//выбор языка перевода
  var translate = document.querySelector('.translate');//блок, куда вставляется перевод
  var translate = document.querySelector('.translate');//блок, куда вставляется перевод
  var req = new XMLHttpRequest();

...

var button = document.getElementsByName('but');
for(let i = 0; i < button.length; i++) {
   button[i].addEventListener('change', function() {        
      document.getElementById('aaa').innerHTML = 
      button[i].value;
   });
}

...

function delay(func, timeOut) {
    // при вызове delay(func, timeOut) мы создаем анонимную функцию и возвращаем ее
    // но при этом внутри нее мы обращаемся к переданному параметру func 
    // создавая тем самым замыкание на него
    return function() {
        // внутри возвращаемой анонимной функции мы запускаем таймер
        // которому передаем параметр func являющейся функцией, определенной 
        // где то вовне этот таймер выполнит func но при этом внутри самой func 
        // уже будет не видны параметры переданные для анонимной функции. 
        // Внутри анонимной функции эти параметры можно получить через arguments.
        // Тля того, чтобы func могла получить к ним доступ, мы используем apply, 
        // привязывая к func контент вызова анонимной функции и ее arguments
        // тем самым создавая замыкания к this и arguments анонимной функции
        setTimeout(func.apply(this, arguments), timeOut);
        // как правильно подсказал @bingo347, эту строчку надо немного переписать
        setTimeout(func.bind(this, ...arguments), timeOut);
    }
}

// примерно того же эффекта можно было добиться следующим кодом
function delay(func, timeOut) {
    return function(text) {
        setTimeout(()=>func(text), timeOut);
    }
}

// можно даже добиться не примерно такого, а точно такого же эффекта
// (за исключением привязки контекста анонимной функции через this
// который влияет лишь на возможность обратится непосредственно
// к методам и свойствам самой анонимной функции, которых в вашем
// примере не объявлено ))) 
function delay(func, timeOut) {
    return function(...args) {
        setTimeout(()=>func(...args), timeOut);
    }
}
...

function f(argument1, argument2) {
    alert(argument1 + " " + argument2);
}
let f1000 = delay(f, 1000);
f1000("1111", "2222"); // показывает "1111 2222" после 1000 мс

function f(argument1, argument2, argument3) {
    alert(argument1 + " " + argument2 + " " + argument3);
}
let f1000 = delay(f, 1000);
f1000("1111", "2222", "3333"); // показывает "1111 2222 3333" после 1000 мс

import re
...
pattern = re.compile('\u0621-\u064A')
result = pattern.search('ваша проверяемая строка')

if result is not None:
      print('есть арабские символы')
else:
      print('арабских символов нет')
...

var arr1 = [1487, 1847, 4817, 4871, 7481, 7841, 8147, 8741];
var res1 = search(arr1);
console.log(res1); 
// найдена 1 прогрессия. выведет:
// [ 
//   [ 1487, 4817, 8147 ] 
// ]



var arr2 = [1487, 1847, 4817, 4871, 7481, 7841, 8147, 8741, 10001];
var res2 = search(arr2);
console.log(res2); 
// найдено 2 прогрессии. выведет:
// [ 
//   [ 1487, 4817, 8147 ],
//   [ 7481, 8741, 10001 ]
// ]






function search(a){
	// создадим массив, в который будем заносить данные о найденых прогрессиях
	var result = [];

	// проверяем в цикле все числа
	for(var start=0; start<a.length; start++){
		for(var i=start+1; i<a.length; i++){

			// вычисляем предпологаемый шаг прогрессии
			var step = a[i]-a[start]; 

			// и проверяем его.

			// создаем массив, в который складываем 
			// числа предполагаемой прогрессии
			var list = [ a[start], a[i] ]; 

			// смотрим в цикле следующие числа
			for(var j = i+1; j< a.length; j++){
				// если следующее число - шаг прогрессии равно
				// последнему занесенному в массив list
				// то добавляем его в массив list
				if( a[j]-step == list[list.length-1]){
					list.push(a[j]);
				}
			}

			// если в массиве 3 элемента или более, то считаем что
			// еще одна прогрессия найдена и запоминаем ее в
			// массиве с результатами
			if( list.length>2){
				result.push(list);
			}

			console.log(start, i, step, list)
		}
	}

	// возвращаем массив результатов
	return result;
}

// Скроллим еще ниже
  if(scrollBottom == true){
    //alert("Скроллим вниз");
    objDiv.scrollTop = objDiv.scrollHeight;
  }

// Скроллим еще ниже
  if(scrollBottom == true){
    //alert("Скроллим вниз");
    setTimeout(()=>{
       objDiv.scrollTop = objDiv.scrollHeight;
    },1000);
  }

let products = obj.data

products = []

obj.data

{
᠌ ᠌᠌ ᠌ ᠌ "foo": {
᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ "0": {
᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ "first": 111
᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ },
᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ "1": {
᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ "first": 222
᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ }
᠌ ᠌᠌ ᠌ ᠌ },
᠌ ᠌᠌ ᠌ ᠌ "bar": {
᠌ ᠌᠌ ᠌ ᠌ ᠌ ᠌᠌ ᠌ ᠌ "second": 333
᠌ ᠌᠌ ᠌ ᠌ }
}

const insert = (target,path,value) => path.split(".").reduce((a,k,i,l)=>a[k]=i+1==l.length?value:a[k]||{},target);

const parse = (list,result={}) => Object.keys(list).forEach(k=>insert(result,k,list[k]))||result;

const output = parse(input);

// так как name.names(...) асинхронный, то для того, чтобы получить 
// результат запроса в "синхронном стиле" используем await

// await можно использовать только внутри асинхронной функции.
// для этой цели обернем блок с вызовами name.names(...) в
// само вызывающуюся асинхронную функцию
(async () => {

   var n = await name.names('text', { data });
   console.log(n);

})()