Array  break  case  catch  const  continue  default  Date  do Error  else  Function  false  finally  for

function  if  in  instanceof  Infinity  Math  NaN  Number  new  null  Object  Promise  prototype  RegExp

return  String  switch  this  then  throw  try  true  undefined  var  with  while
	
alert(s)
appendChild(tagName)
fillRect()
pow(base, n)
sin(radians)
cos(radians)
random()
isNaN()
test()
sqrt(n)
prompt(s)
parseInt(s) parseFloat(s)
floor(f) 
ceil(f)
charAt(n)
indexOf(substring, offset)
substring(start, end)
replace(pattern, replacement)
toLowerCase(s)
toUpperCase(s)
abs(n)
splice(start, length, newItem1, newItem2, ...)
split(pattern, limit)
toString()
createElement(tagName)

getElementById(id)

getContext(contextType)

removeChild(domElement)

strokeText(text, x, y)

fillText(text, x, y)

measureText(text)

setItem(key, value)

join(delimeter)

round(floatNumber)
	

Циклы

Использование for

Составить программу для проверки утверждения: «Результатами вычислений по формуле х2 + х + 41 при 0 <= х <= 40 являются простые числа». Все результаты вывести на экран.

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

Если знаем, то вспоминаем, что это число которое делится без остатка только на 1 и на само себя.

Для организации цикла можно использовать операторы for или while

function checkSimpleNumber() {
	"use strict"
	var s = '', x = 0, n, j, ctrl1, ctrl2;
	for (x; x <= 40; x = x + 1) {
		n = x*x + x + 41;
		for (j = 2; j < n; j++) {
			ctrl1 = n / j;
			ctrl2 = Math.floor(ctrl1);
			if (ctrl1 == ctrl2) {
				writeln("При x = " + x + " получаем непростое число n = " + n + ", делящееся без остатка на " + j + ". Утверждение неверно!");
				return;
			}
		}
		s += n + ' ';
		if (x % 5 == 0 && x !== 0) {
			s += '\n';
		}
	}
	writeln(s);
}

Итак, что здесь происходит. Я использовал цикл for. Если вы внимательно прочтете подсказку к этому ключевому слову, вы поймете что тело цикла будет выполнено 41 раз, при этом переменная x будет принимать значения от 0 до 40.

Новички могут пойматься, записав определение цикла for (x; x < 40; x = x + 1)

В этом случае действительно все полученные числа будут простыми, вот только не выполнится условие из текста задачи: икс должен изменяться от 0 до 40, включая 0 и 40. А при x = 40 мы получаем по данной в задаче формуле число, которое делится на 41 без остатка.

Посмотрим подробнее, как я проверяю, что число простое или не простое. Самый простой способ - это попробовать разделить полученное по формуле число n на все значения от 2 (на единицу простое число делится без остатка) до n, не включая n, так как на само себя простое число делится также без остатка. Я делаю это во втором цикле. Вы можете видеть, что в нем я использую для увеличения j конструкцию j++, в то время как в первом (внешнем) цикле я использую x = x + 1. При использовании в цикле for эти конструкции по смыслу вполне эквивалентны. j++ увеличивает значение переменной j на единицу всякий раз после того, как тело цикла выполнено. Одно такое выполнение тела цикла называется итерацией.

Если стало интересно, почему я подчеркнул, что j++ и j = j + 1 эквивалентны только при использовании в цикле for, внимательно прочитайте комментарии к коду и выполните код:
function plusPlusBehavior() {
	var a, d, b = 1, c = 1;
	a = b++;//Записали в a значение b, после чего увеличили b на единицу 
	d = ++c;//увеличили c на единицу, после чего записали в d значение c
	writeln('a = ' + a + ', b = ' + b + ', c = ' + c + ', d = ' + d);
}

В каждой итерации внутреннего цикла я делю полученное во внешнем цикле число n на j, после чего передаю результат методу объекта Math.floor. Этот метод отбрасывает дробную часть, если она есть. Сравнив результат его работы с частным n / j я могу понять, делилось n на j без остатка или нет. Если это так, значит я вывожу сообщение и завершаю работу программы, используя оператор return.

Иначе я продолжаю собирать полученные значения n в строку s, ведь мне надо вывести все простые числа если утверждение истинно.

Через каждые пять итераций я добавляю символ новой строки \n, чтобы вывести эти числа компактно: восемь строк по пять цифр. Вы можете это видеть, если временно измените условный оператор внешнего цикла с <= на <. Для отсчета этих пяти итераций я использую операцию получения остатка от целочисленного деления %. Например, 12 % 10 равно двум (частное 1, остаток 2)

Использование while

В предыдущем примере вполне можно было бы использовать while вместо for. Внешний цикл выглядел бы тогда:

while(x <= 40) {
	//...
	x++;
}
а суть осталось той же. То же касается и внутреннего цикла. Я буду использовать while в следующем примере.

Вычислить

при a не равном 1

function endingSum() {
	"use strict"
	var a = parseInt( readln('Введите a') ),
		sum = 1 / a, n = 2, prevSum = sum;
	if(isNaN(a) || a == 1 ) {//если a не число или равен 1
		writeln('a должно быть числом не равным 1!');
		return;
	}
	while (true) {
		sum += 1 / Math.pow(a, 2 * n - 2);
		n++;
		if (sum == prevSum) {
			break;
		}
		prevSum = sum;
	}
	writeln(sum);
}

От нас требуют найти сумму членов последовательности, каждый член которой, за исключением первого, вычисляется по формуле единица деленная на (а в степени 2*n - 2). При этом n равно номеру слагаемого, при нумерации их с единицы. Понятно, что чем больше n, тем больше делитель очередного слагаемого. Если вспомнить пределы последовательностей и функций, можно сказать, что делитель стремится к бесконечности, при n стремящемся к бесконечности.

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

Решение этой задачи на языке JavaScript облегчается тем, что числовая переменная в JavaScript может принимать специальное значение Infinity - бесконечность.

И если мы попытаемся разделить единицу на переменную, содержащую это значение, мы получим ноль, как и положено в математическом анализе.

Следующий простой код позволит убедиться, что это действительно так:

function infinityExample() {
	"use strict"
	var n = 1 / 0; //Получили бесконечность
	writeln('n = ' + n); //Убедились, что это так
	writeln('1 / n = ' + (1 / n)); //Убедились, что единица деленная на бесконечность равна  0
}

Итак, я вправе ожидать, что по мере роста n делитель очередного слагаемого станет равен бесконечности, а значит сумма перестанет расти.

В коде примера endingSum я получаю от пользователя значение a и контролирую, не равен ли он нулю или единице.

Далее, инициализую переменную, в которой буду накапливать сумму, значением первого члена последовательности, n присваиваю значение 2, так как меня интересуют члены последовательности от второго и дальше. Также, я объявляю переменную prevSum, в которой буду хранить значение предыдущей суммы. Используя эту переменную я смогу понять, что сумма перестала расти, значит, можно прекращать вычисления.

Для организации цикла я использовал слово while. Этот цикл будет выполняться, пока логическое выражение в круглых скобках после while будет равно true. Но мне ничего не мешает вместо выражения поместить в эти круглые скобки значение true, объявив таким образом бесконечный цикл.

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

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

Вычисление с заданной точностью

Найти сумму ряда с точностью e = 0,001, общий член которого:

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

function precisionSum() {
	"use strict"
	var e = 0.001,
		sum = 0, n = 1, prevSum = sum;
	function factorial(n) {
		n = parseInt(n);
		if (!n) {
			n = 0;
		}
		if (n < 2) {
			return 1;
		}
		var result = 1;
		for (var i = 1; i <= n; i++) {
			result = result * i;
		}
		return result;
	}
	while (true) {
		sum += factorial(n) / factorial(2 * n);
		n++;
		if (sum - prevSum <= e) {
			break;
		}
		prevSum = sum;
	}
	writeln('S = ' + sum);
}

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

Если не знаем, что такое n! смотрим в поисковой системе [подставьте ту, которой пользуетесь], что это такое и узнаем что это факториал. И даже, что факториал целого числа n равен произведению целых членов ряда [1 .. n] то есть все целые числа от одного до n включительно надо перемножить, тогда получим факториал.

Я вынес этот нехитрый алгоритм в функцию factorial и использую ее при решении основной задачи.

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

Производительность циклов. Что неплохо знать о циклах JavaScript программисту, стремящемуся писать код грамотно

(По книге Стояна Стефанова «JavaScript. Шаблоны»)

В циклах часто приходится перебирать массивы. При этом часто можно встретить в чужом коде и в том числе в коде который приводил я здесь такое определение цикла:

for (var i = 0; i < array.length; i++) { //Для i меньшей, чем длина массива делать и увеличивать i  на единицу ... 
	//тут что-то делаем
}

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

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

Поэтому лучше так:

for (var i = 0, length = array.length; i < length; i++) { //Вычислили длинну массива один раз
	//тут что-то делаем
}

Если не имеет значения, в каком направлении обходить массив, слева направо или справо налево, то можно сделать еще лучше:

for (var i = array.length - 1; i >= 0; i--) { //Будет выполняться, пока i > 0, сравнение с нулем происходит быстрее чем с любым другим числом
	//тут что-то делаем
}

Также, можно использовать цикл while:

var i = array.length;
while (i--) {//Будет выполняться, пока i > 0, сравнение с нулем происходит быстрее чем с любым другим числом
	//тут что-то делаем
}
На самом деле пример

for (var i = array.length - 1; i >= 0; i--)

В книге Стефанова выглядит так:

for (var i = array.length; i--)

Но мой firefox с этим не согласен: требует недостающую точку с запятой. Далее, если даже её поставить,

for (var i = array.length;; i--)

первая итерация приходится на несуществующий элемент массива, так как элемента с индексом равным array.length в массиве быть не может. Хорошо, запишем так:

for (var i = array.length - 1;; i--)

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

for (var i = array.length - 1; i >= 0; i--)

А вообще, книга «JavaScript. Шаблоны» хорошая. Если кто-то сможет нормально выполнить цикл с определением близким к

for (var i = array.length; i--)

напишите пожалуйста в комментариях.
Тест на новые слова

  • Несохраненный_файл.js
Строка: 0, Символ: 0

  • {name}
  • У вас пока нет файлов
 

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

 

Правильно!

Не забывайте переодически проходить этот тест по мере чтения новых статей.

 

Ошибка!

 

Осталось: 0 сек.

Health:

Score:

 

Что значит:

 

 

 


Информация

Загрузите файл с исходным кодом программы на языке яваскрипт.

Файл должен содержать одну главную функцию, имя которой должно совпадать с именем файла.

Например, файл называется task1.js, имя главной функции должно быть task1.

Все остальные функции должны быть определены внутри главной.

*

Информация

Сохраняемый код должен содержать одну главную функцию.

Например:

function myFirstProgram() {
	//Тут все остальное, включая вспомогательные функции
}
					




Простой пароль
Пароли не совпадают