Гайд для начинающих: как написать javascript

«var» обрабатываются в начале запуска функции

Объявления переменных обрабатываются в начале выполнения функции (или запуска скрипта, если переменная является глобальной).

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

Т.е. этот код:

…Технически полностью эквивалентен следующему (объявление переменной перемещено в начало функции):

…И даже коду ниже (как вы помните, блочная область видимости игнорируется):

Это поведение называется «hoisting» (всплытие, поднятие), потому что все объявления переменных «всплывают» в самый верх функции.

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

Объявления переменных «всплывают», но присваивания значений – нет.

Это проще всего продемонстрировать на примере:

Строка состоит из двух действий:

1. Объявление переменной
2. Присвоение значения в переменную .

Объявление переменной обрабатывается в начале выполнения функции («всплывает»), однако присвоение значения всегда происходит в той строке кода, где оно указано. Т.е. код выполняется по следующему сценарию:

Поскольку все объявления переменных обрабатываются в начале функции, мы можем ссылаться на них в любом месте. Однако, переменные имеют значение до строки с присвоением значения.

В обоих примерах выше вызов происходил без ошибки, потому что переменная уже существовала. Но её значение ещё не было присвоено, поэтому мы получали .

Приведение типов

Когда мы производим какие-то действия с переменными, то нужно следить за типами. Нельзя умножать котов на футбольные мячи, это противоречит здравому смыслу. Также и с переменными. Если вы присваиваете переменной одного типа значение другого типа, то вспоминайте теорию. Например, вы без проблем можете присвоить значение типа int переменной типа long, так как все числа из диапазона типа int гарантировано помещаются в диапазон чисел long. В этом случае Java выполнит преобразование автоматически, вы даже ничего не заметите.

Представим обратную картину — мы хотим присвоить переменной типа byte значение типа double. Java не сможет автоматически выполнить ваше желание. Не все числа типа double могут стать числом типа byte. Но часть чисел может, например, число 9. В таком случае используется так называемое приведение типов, чтобы подсказать Java о допустимости операции.

Итак, автоматическое преобразование типов осуществляется, если оба типа совместимы и длина целевого типа больше длины исходного типа. В этом случае происходит преобразование с расширением. Вы всегда можете преобразовать любое число типа byte в число типа int. Такая операция произойдёт без вашего участия автоматически.

Таблица выглядит следующим образом.

Сплошные линии обозначают преобразования, выполняемые без потери данных. Штриховые линии говорят о том, что при преобразовании может произойти потеря точности.

Типы целых чисел и чисел с плавающей точкой совместимы частично. Например, число 5 вполне может быть числом с плавающей точкой (5.0).

Совсем не совместимы, например, char и boolean.

С автоматическим приведением мы разобрались. Рассмотрим вариант, когда нужно преобразовать число типа int в число типа byte. Преобразование автоматически невозможно, поскольку byte меньше int. Но, например, число 99 вполне можно использовать и как int и как byte. В этом случае используется явное приведение типов, то есть преобразование из одного типа в другой (преобразование с сужением).

Выглядит это следующим образом:

Как видите, вы в скобках указываете тип, к которому нужно явно привести переменную.

Существует ещё вариант приведения с усечением. Это когда число с плавающей точкой приводится к целочисленному типу. В этом случае отбрасывается дробная часть (хвост). Например, число 3.14 будет усечено до числа 3:

Если размер целочисленной части слишком велик для целочисленного типа, то значение будет уменьшено до результата деления по модулю на диапазон целевого типа.

Например, попробуйте преобразовать число 454.874 в тип byte:

У меня вывелся удивительный результат: b равно -58.

Рассмотрим такой пример. Допустим у нас есть выражение, где промежуточное значение может выходить за пределы допустимого диапазона:

При умножении переменных a * b промежуточный результат вышел за пределы диапазона допустимых значений для типов byte. Java во время вычисления промежуточных результатов автоматически повышает тип каждого операнда до int и ошибки не происходит.

Это удобно, но может поставить в тупик в следующем примере:

С виду всё правильно. Если не слишком больше число типа byte, а итоговый результат тоже не выходит за диапазон допустимых значений. Но Java не позволит вам написать подобный код. Происходит следующее. Во время вычисления выражения тип операндов был автоматически повышен до int, как об этом говорилось выше. При этом тип результата тоже был повышен до int. Получается, что результат вычисления равен типу int, а мы пытаемся его присвоить переменной b, которая у нас объявлена как byte. И это несмотря на то, что итоговый результат может быть типом byte. Как же выйти из этого положения? Следует использовать явное приведение типов:

Мы рассмотрели единичные примеры. Пора обобщить и запомнить несколько правил.

Типы всех значений byte, short, char повышаются до типа int, как это было рассмотрено выше.

Если один операнд имеет тип long, то тип всего выражения повышается до long.

Если один операнд имеет тип float, то тип всего выражения повышается до float.

Если один операнд имеет тип double, то тип всего выражения повышается до double.

В первом промежуточном выражении (f * b) тип переменной b повышается до float и промежуточный результат также становится float. В следующем выражении (i / c) тип у переменной c повышается до int и промежуточный результат также становится типом int. В выражении (d * s) тип переменной s повышается до double и промежуточное выражение также становится double. В результате у нас появились три промежуточные значения типов: float, int, double. При сложении float и int мы получаем float, затем при вычитании с использованием float и double тип повышается до double, который и становится окончательным типом результата выражения.

10) addEvent()

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

function addEvent(elem, evType, fn) {
	if (elem.addEventListener) {
		elem.addEventListener(evType, fn, false);
	}
	else if (elem.attachEvent) {
		elem.attachEvent('on' + evType, fn)
	}
	else {
		elem = fn
	}
}

Этот код обладает двумя достоинствами — он простой и кросс-браузерный.

Основной его недостаток — в том, он не передает в обработчик для IE. Точнее, этого не делает .

Для передачи правильного this можно заменить соответствующую строку на:

elem.attachEvent("on"+evType, function() { fn.apply(elem) })

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

Существует два варианта обхода проблемы:

1. Возвращать функцию, использованную для назначения обработчика:

   function addEvent(elem, evType, fn) {
   	if (elem.addEventListener) {
   		elem.addEventListener(evType, fn, false)
                   return fn
   	}
   
           iefn = function() { fn.call(elem) } 
           elem.attachEvent('on' + evType, iefn)
   	return iefn
   }
   
   function removeEvent(elem, evType, fn) {
   	if (elem.addEventListener) {
   		elem.removeEventListener(evType, fn, false)
                   return
   	}
    
           elem.detachEvent('on' + evType, fn)
   }
   

   Используется так:

   function handler() { 
       alert(this) 
   }
   var fn = addEvent(elem, "click", handler)
   ...
   removeEvent(elem, "click", fn)
   

2. Можно не использовать в обработчике события вообще, а передавать элемент через замыкание:

   function handler() { 
      // используем не this, а переменную, ссылающуюся на элемент
       alert(*!*elem*/!*) 
   }
   ...
   

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

FSTB – работа с файлами в Node.js без боли

Когда я работаю с файлами в Node.js, меня не оставляет мысль, что я пишу очень много однотипного кода. Создание, чтение и запись, перемещение, удаление, обход файлов и подкаталогов, всё это обрастает неимоверным количеством бойлерплейта, который еще усугубляется странными названиями функций модуля fs. Со всем этим можно жить, но меня не оставляла мысль, что можно сделать удобнее. Хотелось, чтобы такие элементарные вещи, как, например, чтение или запись текста (или json) в файл можно было написать в одну строчку.

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

Популярные ошибки и подводные камни

Из-за сложных манипуляций с промисами и async/await концепциями вы можете встретиться с различными тонкостями, что может привести к ошибкам.

Не забывайте await

Частая ошибка заключается в том, что перед промисом забывается ключевое слово :

Обратите внимание, здесь не используется ни , ни. Функция всегда будет завершаться с (без задержки в 1 секунду)

Тем не менее, промис будет выполняться. Если промис будет выдавать ошибку либо реджект, то будет вызываться .

async-функции в обратных вызовах

async-функции часто используются в . или . в качестве коллбэков. Вот пример — допустим, существует функция , которая возвращает количество открытых репозиториев на GitHub. Есть 3 пользователя, чьи показатели нужно взять. Используется такой код:

И для того, чтобы получить количество репозиториев пользователей (), код должен выглядеть как-то так:

Обратите внимание на слово в обратном вызове функции. Можно было бы ожидать, что переменная будет содержать число — количество репозиториев

Но как было сказано ранее, все async-функции возвращают промисы. Следовательно, будет массивом промисов. вызывает анонимной коллбэк для каждого пользователя.

Слишком последовательное использование await

Допустим, есть такой код:

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

Если на обработку одного пользователя будет уходить 300 мс, то на всех пользователей уйдёт почти секунда. В этом случае затрачиваемое время будет линейно зависеть от количества пользователей. Поскольку получение количества репозиториев не зависит друг от друга, то можно распараллелить эти процессы. Тогда пользователи будут обрабатываться одновременно, а не последовательно. Для этого понадобятся и .

на входе получает массив промисов и возвращает промис. Возвращаемый промис завершается после окончания всех промисов в массиве либо при первом реджекте. Возможно, все эти промисы не запустятся строго одновременно. Чтобы добиться строгого параллелизма, взгляните на p-map. А если нужно, чтобы async-функции были более адаптивными, посмотрите на Async Iterators.

Перевод статьи «Deeply Understanding JavaScript Async and Await with Examples»

ИЛИ «||» находит первое истинное значение

Описанная выше логика соответствует традиционной. Теперь давайте поработаем с «дополнительными» возможностями JavaScript.

Расширенный алгоритм работает следующим образом.

При выполнении ИЛИ || с несколькими значениями:

Оператор выполняет следующие действия:

• Вычисляет операнды слева направо.
• Каждый операнд конвертирует в логическое значение. Если результат , останавливается и возвращает исходное значение этого операнда.
• Если все операнды являются ложными (), возвращает последний из них.

Значение возвращается в исходном виде, без преобразования.

Другими словами, цепочка ИЛИ возвращает первое истинное значение или последнее, если такое значение не найдено.

Например:

Это делает возможным более интересное применение оператора по сравнению с «чистым, традиционным, только булевым ИЛИ».

1. Получение первого истинного значения из списка переменных или выражений.

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

   С помощью :

   Если бы и , и были ложными, в качестве результата мы бы наблюдали .

2. Сокращённое вычисление.

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

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

   В приведённом ниже примере не изменяется:

   Если бы первый аргумент имел значение , то приступил бы к вычислению второго и выполнил операцию присваивания:

   Присваивание – лишь один пример. Конечно, могут быть и другие побочные эффекты, которые не проявятся, если вычисление до них не дойдёт.

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

   В большинстве случаев лучше использовать «обычный» , чтобы облегчить понимание кода, но иногда это может быть удобно.

Объявление функции

Для создания функций мы можем использовать объявление функции.

Пример объявления функции:

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

Наша новая функция может быть вызвана по её имени: .

Например:

Вызов выполняет код функции. Здесь мы увидим сообщение дважды.

Этот пример явно демонстрирует одно из главных предназначений функций: избавление от дублирования кода.

Если понадобится поменять сообщение или способ его вывода – достаточно изменить его в одном месте: в функции, которая его выводит.

Декомпиляция node.js в Ghidra

Приветствую,

Вам когда-нибудь хотелось узнать, как же именно работает программа, которой вы так активно пользуетесь, игра, в которую часто играете, прошивка какого-нибудь устройства, которое что-то делает по расписанию? Если да, то для этого вам потребуется дизассемблер. А лучше — декомпилятор. И если с x86-x64, Java, Python ситуация известная: этих ваших дизассемблеров и декомпиляторов полным-полно, то с другими языками всё обстоит немного сложнее: поисковые машины уверенно утверждают — «It’s impossible».

Что ж, мы решили оспорить данное утверждение и произвести декомпиляцию NodeJS, а именно выхлоп, который выдаёт npm-пакет bytenode. Об этом подробнее мы и расскажем по ходу статьи. Заметим, что это уже вторая статья в серии о нашем плагине для Ghidra (первый материал был также опубликован в нашем блоге на Хабре). Поехали.

|| (ИЛИ)

Оператор ИЛИ выглядит как двойной символ вертикальной черты:

Логическое ИЛИ в классическом программировании работает следующим образом: «если хотя бы один из аргументов , то возвращает , иначе – «. В JavaScript, как мы увидим далее, это не совсем так, но для начала рассмотрим только логические значения.

Получается следующая «таблица результатов»:

Если значение не логического типа – то оно к нему приводится в целях вычислений. Например, число будет воспринято как , а – как :

Обычно оператор ИЛИ используется в , чтобы проверить, выполняется ли хотя бы одно из условий, например:

Можно передать и больше условий:

Цикл while()

Цикл while() называют еще циклом с предусловием. Это значит, что вы записываете в скобках после ключевого слова while некое условие, которое возвращает либо , либо . Если возвращается , цикл выполняется, если же , то нет. Синтаксис этого цикла таков:

Цикл while()

JavaScript

while( условие ){
//код цикла
операция 1;
…
операция n;
}

1 2 3 4 5 6

while(условие){ //код цикла операция1; … операцияn; }

Если переводить JavaScript-код на русский язык, то смысл цикла while можно выразить такой фразой: пока (while) выполняется условие, мы будем делать некоторые операции.

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

Использование цикла while для подсчете чисел в заданном диапазоне

JavaScript

<form name=»numbers»>
<p>
<label for=»from»>От числа</label> <input type=»number» min=»1″ max=»50″ value=»1″ id=»from»>
</p>
<p>
<label for=»to»>До числа</label> <input type=»number» min=»1″ max=»50″ value=»5″ id=»to»>
</p>
<p><input type=»button» value=»Подсчитать» id=»countBtn»></p>
</form>
<script>
document.numbers.countBtn.onclick = countNumbers;
function countNumbers () {
let from = +document.numbers.from.value,
to = +document.numbers.to.value;
if(from > to) {
let temp = from;
from = to;
to = temp;
}
let sum = from;
while(to>from){
from++;
sum += from;
}
alert(sum);
}
</script>

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

<form name=»numbers»> <p> <label for=»from»>Отчисла<label><input type=»number»min=»1″max=»50″value=»1″id=»from»> <p> <p> <label for=»to»>Дочисла<label><input type=»number»min=»1″max=»50″value=»5″id=»to»> <p> <p><input type=»button»value=»Подсчитать»id=»countBtn»><p> <form> <script> document.numbers.countBtn.onclick=countNumbers; functioncountNumbers(){ let from=+document.numbers.from.value, to=+document.numbers.to.value; if(from>to){ let temp=from; from=to; to=temp; } let sum=from; while(to>from){ from++; sum+=from; } alert(sum); } </script>

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

Попробуйте сами:

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

Использование диалогового окна confirm() в цикле while()

JavaScript

const prediction = ;
while (confirm(«Хотите получить предсказание»)) {
let rand = Math.floor(Math.random() * prediction.length);
alert(prediction);
}

1 2 3 4 5 6 7 8

constprediction=»У вас сегодня удачный день»,»Вам нужно задуматься о вашем выборе», «Сегодня вас ждет сюрприз»,»Вы — любимчик удачи»,»Попробуйте еще раз»,»Азартные игры не для вас», «Учите JavaScript — и вас ждет успех»,»Пора сделать зарядку»,»Перерыв на кофе-чай-печеньки сейчас будет кстати», «Пора выбросить мусор из квартиры»,»У вас отличный вкус»,»Нечего заглядываться на чужих жен»,»Пора поработать»; while(confirm(«Хотите получить предсказание»)){ let rand=Math.floor(Math.random()*prediction.length); alert(predictionrand); }

Давайте немножко погадаем:

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

Примечание: цикл while — это тот цикл, с помощью которого лучше всего обычно получается «подвесить» браузер. Т.е. вы можете таким образом сформулировать условие в нем, что оно всегда будет возвращать , соответственно, цикл будет бесконечным и будет замедлять работу браузера.

Что может JavaScript в браузере?

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

Возможности JavaScript сильно зависят от окружения, в котором он работает. Например, Node.JS поддерживает функции чтения/записи произвольных файлов, выполнения сетевых запросов и т.д.

В браузере для JavaScript доступно всё, что связано с манипулированием веб-страницами, взаимодействием с пользователем и веб-сервером.

Например, в браузере JavaScript может:

• Добавлять новый HTML-код на страницу, изменять существующее содержимое, модифицировать стили.
• Реагировать на действия пользователя, щелчки мыши, перемещения указателя, нажатия клавиш.
• Отправлять сетевые запросы на удалённые сервера, скачивать и загружать файлы (технологии AJAX и COMET).
• Получать и устанавливать куки, задавать вопросы посетителю, показывать сообщения.
• Запоминать данные на стороне клиента («local storage»).

Параметры по умолчанию

Если параметр не указан, то его значением становится .

Например, вышеупомянутая функция может быть вызвана с одним аргументом:

Это не приведёт к ошибке. Такой вызов выведет . В вызове не указан параметр , поэтому предполагается, что .

Если мы хотим задать параметру значение по умолчанию, мы должны указать его после :

Теперь, если параметр не указан, его значением будет

В данном случае это строка, но на её месте могло бы быть и более сложное выражение, которое бы вычислялось и присваивалось при отсутствии параметра. Например:

Вычисление параметров по умолчанию

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

В примере выше будет вызываться каждый раз, когда вызывается без параметра .

Использование параметров по умолчанию в ранних версиях JavaScript

Ранние версии JavaScript не поддерживали параметры по умолчанию. Поэтому существуют альтернативные способы, которые могут встречаться в старых скриптах.

Например, явная проверка на :

…Или с помощью оператора :

Инкремент/декремент

Одной из наиболее частых числовых операций является увеличение или уменьшение на единицу.

Для этого существуют даже специальные операторы:

• Инкремент увеличивает переменную на 1:

• Декремент уменьшает переменную на 1:

Важно:

Инкремент/декремент можно применить только к переменной. Попытка использовать его на значении, типа 5++, приведёт к ошибке.

Операторы и могут быть расположены не только после, но и до переменной.

• Когда оператор идёт после переменной — это «постфиксная форма»: .
• «Префиксная форма» — это когда оператор идёт перед переменной: .

Обе эти инструкции делают одно и то же: увеличивают на .

Есть ли разница между ними? Да, но увидеть её мы сможем, только если будем использовать значение, которое возвращают .

Давайте проясним этот момент. Как мы знаем, все операторы возвращают значение. Операторы инкремента/декремента не исключение. Префиксная форма возвращает новое значение, в то время как постфиксная форма возвращает старое (до увеличения/уменьшения числа).

Чтобы увидеть разницу, вот небольшой пример:

В строке префиксная форма увеличивает и возвращает новое значение . Так что покажет .

Теперь посмотрим на постфиксную форму:

В строке постфиксная форма также увеличивает , но возвращает старое значение (которое было до увеличения). Так что покажет .

Подведём итоги:

• Если результат оператора не используется, а нужно только увеличить/уменьшить переменную, тогда без разницы, какую форму использовать:

• Если хочется тут же использовать результат, то нужна префиксная форма:

• Если нужно увеличить и при этом получить значение переменной до увеличения – нужна постфиксная форма:

Инкремент/декремент можно использовать в любых выражениях

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

Например:

Сравните с:

Хотя технически здесь всё в порядке, такая запись обычно делает код менее читабельным. Одна строка выполняет множество действий – нехорошо.

При беглом чтении кода можно с лёгкостью пропустить такой , и будет неочевидно, что переменная увеличивается.

Лучше использовать стиль «одна строка – одно действие»:

Куда развиваться JavaScript-программисту

Изучив основы JavaScript, можно копать так глубоко, как хочется.

Хорошо освоить библиотеки и фреймворки для JavaScript — наборы готовых классов с функциями. Некоторые из них настолько мощные, что полностью меняют сценарии программирования. Для JavaScript самые популярные фреймворки и библиотеки — React, jQuery и Angular2.

Код в обеих строках делает одно и то же — скрывает элемент с идентификатором «helloDiv»

Кроме фреймворков полезно изучить надстройки над JavaScript: CoffeeScript, TypeScript и Dart. Одни надстройки сделают ваш код чище и компактнее, другие — строже.

Наконец, можно взяться за серверное программирование и Node.js. Это трендовая технология, которую используют BMW, Amazon, Apple и другие серьезные компании. Так вы расширите область своих знаний JavaScript за пределы управления веб-страницей.

Для JavaScript-программиста нет потолка развития

Хотите написать колонку для Нетологии? Читайте наши условия публикации. Чтобы быть в курсе всех новостей и читать новые статьи, присоединяйтесь к Телеграм-каналу Нетологии

Участники

Список ниже включает всех участников-авторов 10+ строк учебника. Более полный список участников есть в GitHub.

Чтобы войти в этот список, напишите статью или пришлите исправления в учебник через PR в репозиторий.

Участник	Строк	В процентах
Ilya Kantor	51576	71.62%
xcurveballx	2164	3.00%
kichik	1653	2.30%
Alexey Pyltsyn	1431	1.99%
Dmitry G. Anderson	1428	1.98%
vadim.pimonenkov	867	1.20%
Khimtsov Anton Igorevich	573	0.80%
Daniil Stepanov	537	0.75%
alfill	477	0.66%
MrShtein	469	0.65%
Nikita Glazov	409	0.57%
Roman Konkin	386	0.54%
Alexander Shchegol	366	0.51%
webben	363	0.50%
ksimanov	335	0.47%
Metre-Ray	324	0.45%
Anton Kolesnikov	288	0.40%
smyagkov	285	0.40%
aruseni	280	0.39%
Vse Mozhe Buty	279	0.39%
rutigl	262	0.36%
Stanislav Dolgachov	261	0.36%
egorzot	260	0.36%
Aleksey Sereda	233	0.32%
phrixothrixa	218	0.30%
Anna Tuzova	217	0.30%
Mykhaliuk Vladimir	212	0.29%
Daria Serova	211	0.29%
Timur	208	0.29%
hisbvdis	200	0.28%
Alexander Ivanov	190	0.26%
Andrew Buter	185	0.26%
root	184	0.26%
Vladimir Yurchenko	182	0.25%
dima	181	0.25%
h_type	163	0.23%
Oleksandr Onufrienko	157	0.22%
Kirill255	155	0.22%
throwable	137	0.19%
Konstantin Alikhanov	122	0.17%
Alexander	114	0.16%
Alfiya	112	0.16%
Sergey	110	0.15%
Tani-Tani	109	0.15%
perepichai	101	0.14%
Nick S	93	0.13%
Kirill	92	0.13%
Daniil Kiyanov	88	0.12%
Andrey Barkalov	83	0.12%
Sergey Vakhrameev	81	0.11%
HomeDAN	78	0.11%
Siarhei Pakhuta	78	0.11%
Tagir	76	0.11%
EnchantressSam	74	0.10%
Denis Popov	72	0.10%
Brent Guffens	70	0.10%
Mikhail V. Null	68	0.09%
Anton Frolovsky	66	0.09%
Albert Abdulmanov	66	0.09%
emiklyaev	66	0.09%
Yaroslav Smirnov	64	0.09%
Zulcom	59	0.08%
Anton Loyko	59	0.08%
romaldowoho	53	0.07%
Sasha Sushko	52	0.07%
Minira Samadova	52	0.07%
mikuhann	52	0.07%
Alexey Onikov	51	0.07%
Vladimir Troyanenko	50	0.07%
masterov	47	0.07%
Danil Kolumbet	47	0.07%
adsurov	43	0.06%
Tanya Ten	41	0.06%
Dmitry Lebedev	40	0.06%
decorator-factory	39	0.05%
anastasiaeremina	38	0.05%
Simon Bliznyuk	37	0.05%
Anton Yershov	35	0.05%
eidolonzx	34	0.05%
Igor Kazakov	33	0.05%
Alexey Zakhlestin	32	0.04%
juliastetskaya	31	0.04%
Yesset	30	0.04%
webistomin	30	0.04%
Denis Blazhkun	30	0.04%
Maxim P	30	0.04%
Alexey Smolyakov	29	0.04%
Steamhammer	26	0.04%
simmayor	26	0.04%
Иван Багаев	24	0.03%
Sovgut Sergey	24	0.03%
bedrosenator	23	0.03%
Rinat Akhunyanov	23	0.03%
Mau Di Bert	21	0.03%
11un	16	0.02%
Paul	16	0.02%
Alexander Ogilvie	15	0.02%
IgorKennyPavlov	14	0.02%
Terr1bus	13	0.02%
Mojtaba Javan	12	0.02%
Alex Shakun	12	0.02%
Евгений Сергеевич Михайлов	12	0.02%
Prokhor	10	0.01%
Екатерина Пугачева	10	0.01%

Показать всех ▾

Google Sheets — как разноплановый помощник для непростых задач или как я делал анализатор футбольный матчей

Из песочницы

Лежу я ночью, пытаюсь уснуть. И как обычно тысяча мыслей, и среди них я сумел зацепился за одну. А звучала она так: «почему бы не сделать анализатора футбольных матчей, где нужно будет лишь ввести участников игры и получить выборку из их статистики общей и какие-то описание, чего ждать в грядущем матче». Действительно, почему нет?!

На следующий день, когда я проснулся, я первым же делом пошел гуглить, есть ли такое сейчас, потому что что-то подсказывало, что в нашем мире это слишком банальная затея (та ладна!?). Но я то не просто хотел складывать и делить числа из статистики, мне хотелось учитывать различные факторы спортивного мероприятия, а их большое количество.

Гугл дал свой результат, впрочем как всегда. Я нашел кучу калькуляторов ставок, которые продается за 3-5к рублей, и прочие таблицы расчетов в свободном доступе. Я как бы и так помнил расчеты тоталов голов, но мне нужно было их улучшить и получить на выходе собственно целого «мага/колдуна/вангу» спортивных событий. Или хотя бы формулку, которая выдаст результат после ввода данных.