Базовый курс. Занятие №2
24.01.2011
комментариев 138
Второе занятие по 0-му блоку базового курса.
Необходимо изучить следующие главы.
Глава 12. Примитивные типы данных
Глава 13. Контекст исполнения кода
Глава 14. Объектная техника
Глава 15. Сервисные средства по написанию кода
Также нужно выполнить домашнее задание, текст которого доступен на странице.
В этой же теме необходимо написать отчет о выполнении задания.
ps. Участники курса без доступа в мастер-группу отчитаться по домашним заданиям не получиться.
К сожалению, у Вас недостаточно прав для просмотра этой записи. Если Вы еще не залогинены на сайте
— залогиньтесь.
напишите нам на e-mail поддержки.
— залогиньтесь.
Если не активировали токен — посмотрите видео-инструкцию (видео N5)
Если вы залогинены, у Вас активирован токен доступа, но вы все равно видите эту запись —напишите нам на e-mail поддержки.
на первый взгляд задания показались простыми, но в процессе выполнения результаты оказались совершенно неожиданны
1. программа “зациклилась”: Счетчик не увеличивается, Массив не заполняется – результат “Ложь”;
2. А. “010”+”010″ “010010” Строка
Б. “010”++”010″ “01010” Строка
В. “010”-“010″+1 1 Число
С. “010”+-“010″+1 “010-101” Строка
3.1 Начислено=1000 Выплачено=2000
Врем=Начислено Начислено=Выплачено Выплачено=Врем
3.2 Начислено=Начислено+Выплачено
Выплачено=Начислено-Выплачено
Начислено=Начислено-Выплачено
или
Начислено=Начислено*Выплачено
Выплачено=Начислено/Выплачено
Начислено=Начислено/Выплачено
Выполнил:
1. Первые две строчки – это определение переменных и их начальное заполнение.
Далее цикл с предусловием (Счетчик < 1000), в котором происходит добавление в массив М значений булевого выражения (Счетчик = Счетчик + 1), которое равно Ложь.
В итоге цикл будет бесконечный. Отладчик подтвердил мой результат.
В языке Си можно было бы написать (Счетчик++), которое привело бы к увеличению 1 и в итоге к массиву М с тысячью элементами от 1 до 1000. А также в языке Си можно было бы написать (++Счетчик), которое привело бы к увеличению 1 после и в итоге к массиву М с тысячью элементами от 0 до 999.
2А. “010” + “010” это сложение строк. резульатт “010010”
2Б. “010” ++ “010” вначале выолняется + “010” , т.к. имеет больший приоритет перед сложением, т.е. правая строка “10” должна стать положительной. для этого правая строка “10” преобразуется в число 10 и потом становиться положительным. И в итоге к левой строке “010” прибавляется число 10. А по правилам первый аргумент определяет тип. В итоге происходит сложение строк “010” и преобразованной “10”. Результат “01010”
2В. Операция «-» для строк не определена. Тем не менее, результатом выражения “010” – “010” будет преобразование операндов в числа и вычитание, которое будет равно 0. Далее произойдет прибавление 1. Результат 1
2Г. Вначале будет выполняться из-за приоритета отрицание средней строки, преобразованной в число 10, т. е. -10. Далее все операнды приведутся к типу первого, т.е. строка и произойдет конкатенация трех строк “010” + “-10” + “1”. результат “010-101”
3А
Временная = Начислено;
Начислено = Выплачено;
Выплачено = Временная;
3Б1 Начислено и Выплачено числового типа без дополнительных переменных
Начислено = Начислено * Выплачено;
Выплачено = Начислено / Выплачено;
Начислено = Начислено / Выплачено;
3Б2 Начислено и Выплачено любого типа без дополнительных переменных (чуть более ресурсоёмкий)
Начислено = Новый Структура( “Элемент1, Элемент2”, Начислено, Выплачено );
Выплачено = Начислено[“Элемент1”];
Начислено = Начислено[“Элемент2”];
Задание Выполнено
1. Бесконечный цикл..
Метод “Добавить”
добавляет значение в массив
и происходит вычисление значения выражения, для получения значения параметра метода Добавить, соответственно здесь = это оператор сравнения, а не оператор присваивания, увеличения счетчика цикла
2.
А. Результат Строка, “+” это операция конткатенации строк
Б. Результат Строка, сначала второй операнд преобразуется в число
(приоритет унарной операции),
потом строка+число дает строку, по типу первого операнда
В. результат число, тут “-” это операция вычитания, а поскольку
над строками определена только операция конткатенации, то система
пытается перевести операнды в числа, это ей удается и поэтому результат
число.
Г.результат строка, поскольку здесь “-” это унарная операция, которая сначала преобразует
второй операнд в число, а потом строка+числа, дает строку, по типу первого операнда
3.
С Использованием переменной:
Темп=Начислено
Начислено=Выплачено
Выплачено=Темп
Без использования переменной:
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
По первому пункту, сразу не понял, что присваивание всегда должно быть отдельным оператором, итог печален… бесконечный цикл, который заканчивался где-то через 30 сек. с ошибкой “Недостаточно память”.
Перед 2-м пунктом еще раз изучил материал по преобразованиям и снова не угадал. Но после того, как в табло проверил итоги по двум операциям: “010”++”010″ (результат “01010”, тип строка) и “010”+-“010” (результат “010-10”, тип строка) все стало понятно и дальнейшее (В. и Г.) трудностей не вызвало.
По третьему пункту. Первый вариант через временную переменную:
ВремПерем = Начислено;
Начислено = Выплачено;
Выплачено = ВремПерем;
Еще один вариант вариант из пунка 1, через массив:
<code>
Начислено = 2000;
Выплачено = 1000;
Массив = Новый Массив;
Массив.Добавить(Начислено);
Массив.Добавить(Выплачено);
Начислено = Массив[1];
Выплачено = Массив[0];
</code>
Вариант с функцией куда передаются переменные по ссылке и по значению, тоже рассматривался, но его уже приводили в пример, повторять смысла не вижу.
1) Бесконечный цикл. (операция сравнения)
2)<<010>>+<<010>> = 010010
<<010>>++<<010>> =01010
<<010>>-<<010>>+1=1
<<010>+- <<010>>+1=010-101
3)Вариант через временную переменную
Начислено=1000;
Выплачено=2000;
Вр=Начислено; //1000
Начислено=Выплачено; //2000
Выплачено=Вр; //1000
Вариант через * /
Начислено=1000;
Выплачено=2000;
Начислено=Начислено*Выплачено; //2000000
Выплачено=Начислено/Выплачено; //1000
Начислено=Начислено.Выплачено; //2000
Вариант через +-
Начислено=1000;
Выплачено=2000;
Начислено=Начислено+Выплачено; //3000
Выплачено=Начислено-Выплачено; //1000
Начислено=Начислено-Выплачено;//2000
1. Сразу предположил, что будет бесконечный цикл, потом стал сомневаться, но отладка поставила все на свои места.
2. Неожиданным был результат в п. Г, думал, будет равен п. В
3. С вариантом без промежуточной переменной сначала потормозил, но потом решил сложением и вычитанием.
1. Признаться, тоже попал на бесконечный цикл с заполнением массива “бесконечной ложью”, не ожидая этого, со стороны авторов – хороший розыгрыш.
2.Данный пункт требует понимание логики работы платформы с конкатенацией и преобразованием типов. Внимательно прослушал пункт “Приоритеты выполнения арифметических операций”, проблем не возникло.
З. Обмен получился 2-мя процедурами:
<code>
Процедура ЭксченджСПромежуточнойПеременной(Начислено,Выплачено)
Перем Промежуточная;
Промежуточная = Начислено;
Начислено = Выплачено;
Выплачено = ПРомежуточная;
КонецПроцедуры
Процедура ЭксченджБезПромежуточныхПеременных(Начислено,Выплачено)
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
КонецПроцедуры
</code>
, причем первая процедура обменяет значения переменных любых типов, 2 вторая – только числового(того,с которым поддерживаются подобные арифметические операции)
1. Ожидал что массив.Количество() = 1000.
но, оказалось то операция сравнения.
2. Ожидал что
2.А = 20;
2.Б = “010010”;
2.В 1;
2.Г Ошибка;
Оказалось.
2.А – “010010”;
2.Б. – “01010”;
2.В. – 1;
2.Г. – “010-101”;
3.
//1-ый вариант
А = 2000;
Б = 1000;
С = А+Б;
Б = С-Б;
А = С-А;
//2-ый вариант
А = 2000;
Б = 1000;
А = А+Б;
Б = А-Б;
А = А-Б;
//1-ый вариант А = 2000; Б = 1000;
С = А+Б; Б = С-Б; А = С-А;
//2-ый вариант А = 2000; Б = 1000;
А = А+Б; Б = А-Б; А = А-Б;
вроде работает )
1. Будет бесконечный цикл
2.
«010» + «010» = “010010”
«010» ++ «010» = “01010”
«010» – «010» + 1 = 1
«010» +- «010» + 1 = “010-101”
3
1ый способ
Е = Начисленно;
Начислено = Выплачено;
Выплачено = Е;
2-ой способ
Начислено = Начислено + Выплачено
Выплачено = Начислено – Выплачено
Начислено = Начислено – Выплачено
1. В теле цикла “Пока” нет увеличения счетчика, поэтому будет бесконечный цикл, в котором будут создаваться элементы массива с булевым значением Ложь.
2. Задание трудностей не вызвало. Ручной результат совпал с результатами работы Табло.
3.
Вариант 1: с доп. переменной
Темп = Начислено;
Начислено = Выплачено;
Выплачено = Темп;
Вариант 1: с доп. переменной
Темп = Начислено;
Начислено = Выплачено;
Выплачено = Темп;
Вариант 2: без доп. переменной
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
1. Приведёт к зацикливанию,в массив бесконечно будет добавляться ложь, так как ноль не равен 1.
2. Очень интересное задание, в уме насчитал что попало, так как сам привёл всё к числу. С помощью табло разобрался, как и объяснялось в уроке преобразование операторов происходит по типу первого аргумента.
3. 1Способ
Начислено=100;
Выдано=200;
Temp=Начислено ;
Начислено=Выдано;
Выдано=Temp;
2Способ
Начислено=Начислено+Выдано;
Выдано=Начислено-Выдано;
Начислено=Начислено-Выдано;
3Способ
Вроде как есть 3 способ, читал читал про него но так и не понял как реализовать в 1с.
A=А xor В;
В=А xor В;
A=А xor В;
Если у кого получиться поделитесь!
А вообще очень интересные задания, на первый взгляд кажется что так просто всё, а когда начинаешь пробывать на платформе выходит совсем не так то просто.
У многих получилось, см. комментарии к этой записи.
Был даже универсальный способ, на зависящий от типов данных.
Задание выполнено.
1. Бесконечный цикл. Операция (Счетчик = Счетчик + 1) является операцией сравнения, а не присваивания, потому что она используется как аргумент функции Добавить(). Соответственно значение счетчика не изменяется, в бесконечном цикле в массив будут добавляться элементы со значением Ложь.
2. А. “010010”.
Б. “01010”. Второй плюс преобразовывает +”010″ в число 10, а первый плюс преобразовывает это число в строку “10” и конкатенирует строки “010” и “10”.
В. 1. Минус преобразовывает строки в числа, в ответе число.
Г. “010-101”. Аналогично Б. второй минус преобразовывает “010” в число -10, а первый плюс преобразовывает это число в строку “-10” и происходит конкатенация строк.
3. С использованием промежуточной переменной:
ДопЗначение = Начислено;
Начислено = Выплачено;
Выплачено = ДопЗначение;
Без использования:
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
1. попутал оператор присваивания с сравнением
2.сперва вапще не понял как работает ++ в строках, оказывается сперва отдельно работает +и строка “010” преобразовывается в число 10 а потом т.к. первое значение строка второе значение преобразуется к строке. Забавно что если меж строками – платформа решает преобразовывать все в число…. непонятно
3.
Начислено = Выплачено + Начислено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
Н = Строка(В)+”,”+Строка(Н); В = Лев(Н,Найти(Н,”,”)); Н = Прав(Н,СтрДлина(Н)-Найти(Н,”,”));
Н = В + Н; В = Н – В; Н = Н – В;
Выполнила.
Получаем бесконечный цикл, добавляющий в массив элементы с значением «Нет».
Проверила с помощью процедуры:
Счетчик = 0;
М = Новый Массив;
Пока Счетчик < 1000 Цикл
М.Добавить(Счетчик = Счетчик + 1);
Сообщить(Счетчик);
Сообщить(М.Получить(Счетчик));
Если Счетчик > 3 Тогда
Прервать;
КонецЕсли;
Счетчик = Счетчик + 1;
КонецЦикла;
Результат совпал с ожидаемым.
Узнала кое-что новое.
Вариант с использованием временной переменной:
Начислено = 1000;
Выплачено = 2000;
ВремПерем = Начислено;
Начислено = Выплачено;
Выплачено = ВремПерем;
Вариант 2:
Начислено = 1000;
Выплачено = 2000;
Начислено = Начислено * Выплачено;
Выплачено = Начислено / Выплачено;
Начислено = Начислено / Выплачено;
Задание напомнило ANSI C там
операция ++, перестановка значений в переменных и преобразование типов которое может быть внезапно неожиданным для программиста.
Код не характерен для 8.2
Задание Выполнено.
1. Не вызвало затруднений.
2. Пришлось крепко подумать, но справился.
3. Известная задача, встречалась как-то на собеседовании в качестве 2-го варианта. Еще тогда решил сходу. Решать задачу для строковых переменных не догадался :)
Кстати, если делать задание 3 вариант 2 для строк, то так:
Начислено = строка(Начислено)+строка(Выплачено);
Выплачено = Лев(Начислено, стрДлина(Начислено)-стрДлина(Выплачено));
Прав(Начислено, стрДлина(Начислено)-стрДлина(Выплачено));
Кстати, если делать задание 3 вариант 2 для строк, то так:
Начислено = строка(Начислено)+строка(Выплачено);
Выплачено = Лев(Начислено, стрДлина(Начислено)-стрДлина(Выплачено));
Начислено = Прав(Начислено, стрДлина(Начислено)-стрДлина(Выплачено));
в этом случае неважно из каких символов состоят строки
Задание выполнил. Но отчитаюсь только по последнему пункту:
Рассмотрел несколько частных решений. Кое-что подсмотрел в Интернете.
Бензин и вода
Переливаем воду в ведро, где бензин
Сливаем всплывший бензин в ведро, где раньше была вода
Два числа: См. решение у Seducer
Две строки
<code>
Str1=Str1+Str2;
Str2=Сред(Str1,1,Найти(Str1,Str2)-1);
Str1=Прав(Str1,СтрДлина(Str2));
Str1=Str1+Str2;
Str2=Сред(Str1,1,Найти(Str1,Str2)-1);
Str1=Прав(Str1,СтрДлина(Str2));
</code>
Потом практически сразу пришло решение в общем виде для обмена любыми (в том числе и разными типами данных)
<code> Процедура ПриОткрытии(Отказ)
Перем1=1200; Перем2=”2-я переменная”;
Chng(Перем1,Перем2,Перем1,Перем2);
КонецПроцедуры
Процедура Chng(Ссылка1, Ссылка2, Знач Var1, Знач Var2)
Ссылка1 = Var2;
Ссылка2 = Var1;
КонецПроцедуры
</code>
Хорошее, универсальное решение.
Думал только о числах, а тут для всех типов. Интересно.
У нас похожие решения, но у меня вопрос. Зачем передается 4 переменных в процедуру?
А разве в данном случае не используется 4 переменных ?! А по условию их должно быть 2.
Вы правы, по факту в области памяти создается 4 переменных.
при анализе кода пункта 1 сначала ошиблась – приняла «Счетчик = Счетчик +1″ именно за вычисление выражения, но в отладчике поняла что ошиблась: это операция сравнения, которая всегда возвращает ложь, соответственно цикл будет бесконечным.
при проверки выражений из п.2 забыла про приоритет унарных операций – получила не то что ожидала. Как результат – пересмотрена глава про приоритет операций.
С использование промежуточной переменной все действительно понятно:<code>ВремПерем = Начислено;
Начислено = Выплачено;
Выплачено = ВремПерем;</code>. А вот без использования доп. переменной пришлось подумать, и действительно, т.к. переменные числа, то можно решить через сложении и вычитание: <code>Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено; </code>
Валентина к вашему сообщению добавляются ссылки на вредоносные сайты.
Рекомендую срочно поставить последнее обновление антивируса и проверить систему полностью.
1. Цикл будет выполнятся бесконечно, т.к. Счетчик внутри цикла не изменяется. Метод добавить будет добавлять в массив м результат логического выражения Счетчик = Счетчик + 1, т.е. Ложь
2. А. -в результате будет тип строка, т.к. в выражении учавствуют только строковые переменные и операция “+” определена для строковых переменных
Б. – результат будет преобразован к типу строка т.к. первая переменная имеет тип Строка и операция “+” определена для строковых переменных. Вторая переменная будет преобразована сначала к типу число (10) а затем в строковую “10”
В. – результатом будет число, т.к. операция “-” не определена для строковых переменных
Г. – результат будет преобразован к типу строка т.к. первая переменная имеет тип Строка и операция “+” определена для строковых переменных. Вторая переменная будет преобразована сначала к типу число (-10) а затем в строковую “10”, третья переменная будет преобразована к типу строка “1”
3. к ответу Seducer – нечего добавить )
1. Счетчик=Счетчик+1 вернет ложь, переменная сама не изменится и, как следствие, бесконечный цикл
2.Интересные моменты. 2 и 4 не правильно вычислил. Именно поэтому предпочитаю для подобных операций явные указания типа
3. с переменной без проблем:
НачисленоСтарая=Начислено;
начислено=выплачено;
выплачено=НачисленоСтарая;
без переменной пришлось подумать:
Начислено=Начислено+Выплачено;
Выплачено=Начислено-Выплачено;
Начислено=Начислено-Выплачено;
Соответственно работать будет только для чисел
1. Создается 1000 элемента в массиве “М” типа:
М[0] = 1
М[1] = 2
М[2] = 3
*****
М[999] = 1000
2. Решение:
“010” + “010” Равно 20
“010” ++ “010” Равно 20
“010” – “010” +1 Равно 1
“010” +- “010” +1 Равно 1
3. Вариант 1 (А = 1000; Б = 2000):
Вр = А;
А = Б;
Б = Вр;
Вариант 2 (А = 1000; Б = 2000) :
А = А + Б;
Б = А – Б;
А = А – Б;
ДЗ сделано БЕЗ ***
>Создается 1000 элемента в массиве «М» типа:
Рекомендую проверить.
Цикл не прекращается. Нужно поправить процедуру Добавить() :
М.Добавить(Счетчик);
Счетчик = Счетчик + 1;
Ок.
ДЗ выполнено
1. Произойдет зацикливание так-как условие выхода из цикла в теле цикла недостижимо.
2. Некоторые результаты вычислил неверно. Разбирался некоторое время….
3. С использованием промежуточной переменной результат получается при передаче в промежуточную переменную одного из значений и дальнейшее его использование.
Без использования временной переменной одна из двух переменных используется для хранения временного вычисляемого значения:
А = А+В
В = А-В
А = А-В
Здравствуйте!
1. Бесконечный цикл.
2. Почти везде ошибся….:(
3. Обычно на собеседованиях при устройстве на работу програмистом предлагают такую задачку.
Через промежуточную просто. Без оной – через сумму, с последующими вычитанием из нее.
Замечу, что задачки олимпиадные какие то… В реальной жизни в коде никогда так не видел. Да и затрудняют понимание логики кода.
>Замечу, что задачки олимпиадные какие то…
Прежде чем решать задачи учета, нужно немного размяться. Что и делаем в 0-вом блоке.
1. Хорошее задание на внимательность, ведь выхода из цикла не будет.
2. Действительно интересное поведение, а оно вообще 1Сом регламентировано или это временное явление?
3. А после этого задания почемуто захотелось посмотреть “Крепкий Орешек 3” :)
&НаКлиенте
Процедура ОбработкаКоманды(ПараметрКоманды, ПараметрыВыполненияКоманды)
Начислено = 1000;
Выплачено = 2000;
ВыполнитьЗамену1(Начислено, Выплачено);
ВыполнитьЗамену2(Начислено, Выплачено);
Сообщение = Новый СообщениеПользователю;
Сообщение.Текст = “Начислено: ” + Начислено + “, Выплачено: ” + Выплачено;
Сообщение.Сообщить();
КонецПроцедуры
&НаКлиенте
Процедура ВыполнитьЗамену1(Начислено, Выплачено);
Временно = Начислено;
Начислено = Выплачено;
Выплачено = Временно;
КонецПроцедуры
&НаКлиенте
Процедура ВыполнитьЗамену2(Начислено, Выплачено);
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
КонецПроцедуры
>Действительно интересное поведение, а оно вообще 1Сом регламентировано или это временное явление?
Все эти операции являются штатными, поведение системы объяснимо. Чуть позже будет решение.
Правило для СТРОКА ( +-)(-+)(++)(–) СТРОКА
Конечная операция может производится над операторами только одного типа (общее правило)
Если два знака между операторами
1 Сначала выполняется(второй оператор) Унарная операция над предварительно преобразованным оператором к типу “число”
2 Если первый ” + “то второй оператор Преобразуется в СТРОКУ И реализуется КОНКАТЕНАЦИЯ СТРОК
5 Если первый ” – ” Тогда Осуществляется попытка преобразования первого оператора в ЧИСЛО, если удачно, то
Выполняется операция вычитания чисел,
Если не удалось получить операторы одного типа, то ОШИБКА:
&НаСервере
Процедура ПриСозданииНаСервере(Отказ, СтандартнаяОбработка)
Начислено = 1000;
Выплачено = 2000;
Изменение(Начислено,Выплачено);
Переключение(Начислено,Выплачено);
КонецПроцедуры
&НаСервере
Процедура Изменение(Начислено,Выплачено)
А= Выплачено + Начислено ;
Выплачено= А- Выплачено;
Начислено = А – Начислено ;
КонецПроцедуры
&НаСервере
Процедура Переключение(Начислено,Выплачено)
ПромежуточнаяПеременная = Начислено;
Начислено = Выплачено;
Выплачено=ПромежуточнаяПеременная;
КонецПроцедуры
Задачки несложные, удивил только вариант Г 2-го задания.
1. Бесконечный цикл (элемент массива есть результат сравнения)
2. Как уже сказал – не угадал вариант Г
3. С переменной все просто (разбирался в каком то из видео уроков)
Вариант без переменной реализуется через операции сложения\вычитания (информатика 5-го класса:) )
1. думал будет или ошибка или бесконечный цикл, оказалось – цикл; в добавить передается результат сравнения – булево: ложь; массив заполняется этими значениями
2. в уме получилось только в А и В, Б и Г были сюрпризом, но объяснимым – происходит преобразование сначала в число, по приоритету унарной операции; потом снова в строку – т.к. первый операнд строка и операция + , поэтому теряется ноль но минус остается
3. с переменной – все понятно; без –
ничего красивого в голову не приходит, кроме: можно одно число умножить на 10 в степени заведомо больше длины обоих, потом сложить, присвоить одному; второму присвоить соответсвенно разницу, потом вернуть первое: т.е.
а=а+б*10**6;
б=а-б*10**6;
а=(а-б)/10**6;
наверное будут решения получше
1. Приведет к вечному циклу, т.к. в цикле нет операции присваивания , есть операция сравнения, значение счетчика остается в прежнем значении.
2.
А) Строки объединятся , операция конкатенация.
Б) Лев операнд без изменений прав. Операнд будет сначала приведен к числу а потом
при конкатенации будет приведен опять к строке.
В) оба операнда будут приведены к типу число , итог будет равен 0 и + 1 = 1.
Г) поведение платформы для меня оказалось не совсем очевидным, в данном случае будет произведено приведение типа к числу среднего операнда со знаком – , потом опять к строке и крайний правый будет приведен к строке.
3. А) с использованием пром. переменой
А,Б,В
В = А;
А = Б;
Б = В;
Б) без пром. переменой
А,Б
А = А + Б;
Б = А – Б;
А = А – Б;
1. Зациклилось, как и ожидалось
2. Как показало табло – ни одного правильного ответа.
3. а=а+б;
б=а-б;
а=а-б;
1. Выполнение данного кода
– к зацикливанию.. (счетчик внутри скобок).
2. А. “010” + “010” = “010010”
Б. “010” ++ “010” = “01010”
В. “010” – “010” + 1 = 1
Г. “010” +- “010” + 1 = несяно, но табло показало “010-101”, что-то невероятное..
3. “Начислено” равно 1000, “Выплачено” = 2000.
Вариант 1.
Temp = Начислено;
Начислено = Выплачено;
Выплачено = Temp;
Вариант 2.
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
Да и когда возможно будет скачать 1 блок,… а то за все выходные прошел 0 блок.
В ближайшие дни
Задание №2 выполнено. Каких-то сложностей не возникло. По пунктам:
1) Т.к. счетчик не увеличивается, то программа зацикливается, что и было предсказано до запуска. При этом массив заполняется значениями “ложь”, т.к. 0 всегда не равен 1.
2) Результаты выражений тоже все были предсказаны верно, достаточно понять в каком случае “+” конкатенацией, а в каком – унарной операцией (сложение чисел в этих примерах вообще не встречается). Вообще, понял что в 1С хитрая система неявных преобразований типов и надо быть внимательным, чтобы не наступать на грабли в будущем :)
3. Обмен значений переменных с использованием 3-й переменной тривиален и приведен в уроке, а без использования (в случае числовых переменных, как в задании) можно сделать так:
<code>
Начислено = Начислено+Выплачено;
Выплачено = Начислено-Выплачено;
Начислено = Начислено-Выплачено;
</code>
1. Оценил, что хотели запустать переносом строки со счетчиком. Раскусил, результат совпал с ожидаемым :)
2. На втором задании закрепил что у строк определена только конкатенация, в остальных случаях будут попытки преобразовать в число, плюс приведение всего выражения к типу первого аргумента(строка)
3.
a) С использованием промежуточной переменной код приводить не вижу смысла.
б) Реализуется через сложение переменных(результат помещается в любую из двух переменных), и поочередное вычитание из полученной суммы (+было на мисте).
1. Проанализировал программный код и сразу заметил, что цикл бесконечный, так как для выполнения цикла (Пока.. Цикл) нужен счетчик, а он помещен в Массив – добавление элемента массива.
Не смог сразу понять почему в массиве все значения Ложь(0), а не Истина(1). Надо рассматривать Счетчик = Счетчик +1, как логическую операцию сравнения, то есть 0 = 0+1, =>0=1 – это Ложь.
2.А. строка + строка = 010010
Б. Строка+число = 01010
В. Число – Число + 1 = 1
Г. Строка + (-Число) + 1 = Строка + 1 = 010-101, где 1 – как строка.
Г – сразу не понял, помогло Табло :)
3. Первый способ с помощью новой переменной:
С=Б
Б=А
А=С
или
Второй способ через сложение и вычитание:
Б=А+Б
А=Б-А
Б=Б-А
Задание выполнено.
1. Выполнение программного кода приведет к бесконечному циклу, так как в самом цикле значение счетчика не меняется, а в массив добавляется булевское значение от выражения Счетчик = Счетчик +1. В данном случае всегда будет Ложь. Проверка по отладчику подтвердила мою версию.
2. Интерес вызвали результаты вычисления Б и Г. В уме вычислил неправильно.
Б. Полагаю сначала было преобразовано “010” в число 10, а затем конкатенацией строк обратно в “10”. Получилось “01010”.
Г. Тут вообще не до конца понял как получилось “010-101”
3. Вариант с промежуточной переменной:
Перем Врем
Врем = Начислено;
Начислено = Выплачено;
Выплачено = Врем;
Вариант без доп. переменной
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
1. Получился массив из элементов ЛОЖЬ.
Глядя на строчку Счетчик = Счетчик+1 были сомнения, будет ли изменяться счетчик цикла. Проверка показала, что не изменяется – получается бесконечный цикл, соответсвенно бесконечный массив.
2. Получилось не совсем то что ожидал))) но после того как посмотрел в отладчике, стало понятно, что преобразуется к типу первого операнда.
3. Сделал с использованием промежуточной переменной. Второй вариант – пока затрудняюсь…
1. Попробовал. Вывод: Оператор присваивания должен быть в строке первым оператором.
2.Попробовал. Вывод: лучше не допускать такой код. Результат бывает неожиданным.
3. Варианты решения
Начислено = 1000;
Выплачено = 2000;
Сообщить(“Начислено=”+Начислено+”; “+”Выплачено=”+Выплачено);
// С использованием дополнительной переменной
ДопПеременная = Начислено;
Начислено = Выплачено;
Выплачено = ДопПеременная;
Сообщить(“Начислено=”+Начислено+”; “+”Выплачено=”+Выплачено);
// Без использования промежуточной переменной
// Вариант 1
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
Сообщить(“Начислено=”+Начислено+”; “+”Выплачено=”+Выплачено);
// Вариант 2
Начислено = Начислено * Выплачено;
Выплачено = Начислено / Выплачено;
Начислено = Начислено / Выплачено;
Сообщить(“Начислено=”+Начислено+”; “+”Выплачено=”+Выплачено);
// С использованием функций работы со строкой
Начислено = строка(Начислено)+” “+строка(Выплачено);
Выплачено = Лев(Начислено,Найти(Начислено, ” “));
Начислено = Прав(Начислено,стрДлина(Начислено)-Найти(Начислено, ” “));
Сообщить(“Начислено=”+Начислено+”; “+”Выплачено=”+Выплачено);
// Вариант допускающий использование строк с пробелами в качестве переменных
Начислено = “Одна тысяча”;
Выплачено = “Две тысячи”;
Выплачено = строка(Начислено)+строка(Выплачено);
Начислено = Прав(Выплачено,стрДлина(Выплачено)-стрДлина(Начислено));
Выплачено = Лев(Выплачено,стрДлина(Выплачено)-стрДлина(Начислено));
Сообщить(“Начислено=”+Начислено+”; “+”Выплачено=”+Выплачено);
Задание выполнено.
1. Первая мысль – 1000 значений ложь, но потом становится ясно, что счетчик не изменяется, поэтому массив бесконечно заполняется значениями ложь. Бесконечный цикл.
2. Удивили значения в результатах “010”++”010″ и “010”+-“010″+1. Почему так – разобрался. Нужно заучить поведение платформы. Не очевидный результат.
3. С использованием промежуточной переменной – вопроса не возникло. Без переменной – кажется в уроках не было. Мысль вначале была правильная, но подумал, что не получится. Подсмотрел в другом месте и по первому оператору понял , что подумал правильно написал остальное.
Начислено = 1000;
Выплачено = 2000;
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
Сообщить(“Начислено “+Начислено);
Сообщить(“Выплачено “+Выплачено);
Но, вот какая штука – хотелось использовать операторы ++ и — говорит “Неопознанный оператор”. Пишу это в модуле формы обработки с серверным контекстом. Евгений, не могли бы вы подсказать что у меня не так с этими операторами?
>Евгений, не могли бы вы подсказать что у меня не так с этими операторами?
Приведите строки кода, разберемся.
Вот такой код в обработке
<code>
&НаСервере
Процедура ПриСозданииНаСервере(Отказ, СтандартнаяОбработка)
Начислено = 1000;
Выплачено = 2000;
Начислено ++Выплачено;
Выплачено = Начислено – Выплачено;
Начислено +-Выплачено;
Сообщить(“Начислено “+Начислено);
Сообщить(“Выплачено “+Выплачено);
КонецПроцедуры
</code>
Вот такие ошибки во время компиляции
<code>
{Обработка.Обработка1.Форма.Форма.Форма(7,12)}: Неопознанный оператор
Начислено <<?>>++Выплачено; (Проверка: Сервер)
{Обработка.Обработка1.Форма.Форма.Форма(9,12)}: Неопознанный оператор
Начислено <<?>>+-Выплачено; (Проверка: Сервер)
{Обработка.Обработка1.Форма.Форма.Форма(7,12)}: Неопознанный оператор
Начислено <<?>>++Выплачено; (Проверка: Тонкий клиент)
{Обработка.Обработка1.Форма.Форма.Форма(9,12)}: Неопознанный оператор
Начислено <<?>>+-Выплачено; (Проверка: Тонкий клиент)
</code>
>Начислено ++Выплачено;
Не является оператором, поэтому система сообщает об ошибке.
Нужно было писать так:
Сообщить(Начислено ++Выплачено);
или
А = Начислено ++Выплачено;
Сообщить(А);
Собственно, даже, если в эту процедуру втавить вот такой код из видео:
i = 0;
i++1;
то на него выдается подобная ошибка. Я чего-то не понимаю :)
>i++1;
Не является оператором.
Можно было писать вот так:
i = i++1;
Евгений, благодарю!
Свою ошибку я понял, но, если честно, тогда, не могу найти практическое применение таким выражениям как ++ или +-. Можете подсказать какие-нибудь примеры такого использования? Если в курсе есть и я пропустил, то прошу так и сказать :)
Практических примеров, пожалуй, нет.
Однако, частенько встречаются ошибки программистов такого рода:
Сообщить(“Телефон скорой помощи “+
+ “03”);
Многие ожидают, что итоговое сообщение будет таким: “Телефон скорой помощи 03”.
А Вы знаете, что это заблуждение..
Т.е. задание выполнено
1. Результат: вечный цикл с заполнением массива одинаковым значением, ложью – ожидаем, а вот то что с помощью Shift+F5 – Отладка\Завершить не удастся закрыть
предприятие и конфигуратор зависнет тоже – уже была новость, хотя релиз 8.2.13.205 :). В 8.1 работало.
2. Вариант Г. результат был неожиданным, но проверив стало все понятно.
3. Получилось вот так:
Начислено = 1000; Выплачено = 2000;
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
Сообщить(“Начислено=”+Начислено+” Выплачено=”+Выплачено);
> Отладка\Завершить не удастся закрыть
Нужно поставить точку останова, добиться что отладчик остановился. И нажать Shift + F5.
1. Произойдет зависание. Это и не удивительно. При вычислении “Счетчик = Счетчик +1” мы получаем в результате Ложь. Ошибка при выполнении “Пока Счетчик < 1000 Цикл” не будет выдаваться, т.к. Ложь преобразуется в 0. Поэтому этот цикл никогда не завершится, т.к. счетчик всегда будет 0. Вот если “Счетчик = Счетчик +1” вынести в отдельную строку кода, а в массив передавать просто Счетчик, тогда все будет нормально.
2. Хм… довольно интересное поведение.Признаюсь, не везде я был прав.
3. С помощью промежуточной переменной все просто.
ВременнаяПеременная = Начислено;
Начислено = Выплачено;
Выплачено = ВременнаяПеременная;
Без использования промежуточной переменной. Для этого нам нужно не потерять оба значения. Т.к. они оба числовые, можно воспользоваться сложением и вычитанием.
Начислено = Начислено + Выплачено //1000 + 2000 = 3000
Выплачено = Начислено – Выплачено //3000 – 2000 = 1000
Начислено = Начислено – Выплачено //3000 – 1000 = 2000