Базовый курс. Занятие №2
07.04.2011
комментария 142
Второе занятие по 0-му блоку базового курса.
Необходимо изучить следующие главы.
Глава 12. Примитивные типы данных
Глава 13. Контекст исполнения кода
Глава 14. Объектная техника
Глава 15. Сервисные средства по написанию кода
Также нужно выполнить домашнее задание, текст которого доступен на странице.
В этой же теме необходимо написать отчет о выполнении задания.
ps. Участники курса без доступа в мастер-группу отчитываться по домашним заданиям не могут.
К сожалению, у Вас недостаточно прав для просмотра этой записи. Если Вы еще не залогинены на сайте
— залогиньтесь.
напишите нам на e-mail поддержки.
— залогиньтесь.
Если не активировали токен — посмотрите видео-инструкцию (видео N5)
Если вы залогинены, у Вас активирован токен доступа, но вы все равно видите эту запись —напишите нам на e-mail поддержки.
Прорешала 2ую домашку.
1. в первую секунду просмотра кода на бумажке подумала: “обычный цикл со счётчиком”, уж слишком смущает форматирование кода:) в следующие пару секунд увидела массив и использование метода Добавить(), поняла что цикл будет бесконечным и массив будет заполнятся булевым “Ложь”.
2. Самостоятельно догадалась только с ответами А и В.
3. С промежуточной переменной, это просто:
<code>Начислено = 1000; Выплачено = 2000; Временная = Начислено; Начислено = Выплачено; Выплачено = Временная;</code>
Без переменной: не догадалась. Были идеи использовать вместо переменной массив, загнать туда в первую строку Начислено, во вторую Выплачено и прочитать в обратном порядке. Вроде и массив не переменная, но с другой стороны задействовали новый объект и вроде как противоречим условиям задачи. вторая бредовая идея была просто написать: Начислено = 1000; Выплачено = 2000; Начислено = Начислено * 2; Выплачено = Выплачено /2; вот такая вот бредятина. Ознакомилась с видео ответом. Как вариант вместо сложения и вычитания будет так же работать умножение и деление:)
Из более толковой идеи придумала алгоритм аналог нашего без переменной, но с вариантом что значение Выплата и Начисление будут преобразовываться в строки.
Вот что получилось:
<code>Начислено = 1000;
Выплачено = 2000;
//Преобразуем числа в строки
Начислено = Строка(Начислено); //”1000″
Выплачено = Строка(Выплачено);//”2000″
Начислено = Начислено+Выплачено;//”10002000″
Выплачено = Лев(Начислено, СтрДлина(Начислено) – СтрДлина(Выплачено));//”1000″
Начислено = Прав(Начислено, СтрДлина(Начислено)-СтрДлина(Выплачено));//”2000″
//Преобразуем строки в числовой тип
Выплачено = Число(Выплачено);
Начислено = Число(Начислено);</code>
Для данной задачи возможно не самый оптимальный алгоритм, но при необходимости поменять значение строковых без лишней переменной, имеет право на жизнь:)
Сейчас ознакомилась с ответами представленными ниже, увидила пару постов по 3-ей задачи с вариантами перевода в строки у пользователей Cos и relen. Оба использовали алгоритм: “” + Переменная1+”НекийРазделитель”+Переменная2;
И далее у обоих используется для вычисления количества обрезаемых символов вариант с поиском строки в подстроке т.е. нашего НекоегоРазделителя. В часности код у relen:
Значение2 = Лев(Значение1, (СтрДлина(Значение1) – Найти(Значение1, «@»)))
Но тут есть один подвох при использовании таких вещей с переменными строкового типа. приведу пример:
Пусть пользователю доступно самостоятельно задание значений переменных, т.е. Значение1 и Значение2, это реквизиты строкового типа вынесенные на форму.
Пользователь задал:
Значение1= “lam@mail.ru”;
Значение2 = “lam@yandex.ru”;
смотрим что у нас по коду дальше идёт
Значение1 будет = “lam@mail.ru@lam@yandex.ru”
Т.е. не сложно догадаться какой результат мы получим на выходе с поиском подстроки. Метод использовать можно, но обязательно необходим контроль на вхождение разделительных символов в значении переменных перед склейкой.
Ну а самый оптимальный вариант это простой подсчет длинны строки второй переменной, как в моём предыдущем посте:)
PS: простите если много пишу.
>простите если много пишу.
В этом нет ничего плохого, наоборот это хорошо.
Сделал. п.3 не выдержал, посмотрел.
1. Бесконечный цикл. Хотя я подумал, что цикл по условию.
В массив добавляется каждый раз элемент с новым индексом, причем тип – булево. Т.е. в скобках проводится проверка на равенство, результат – ложь и этот элемент добавляется в массив. Затем по циклу повторяется. И в массив добавлятся новый элемент булево – ложь.
Вывод – так счетчик не поменяешь. 8)
2. Проверил. опять шляпа. Получается, что унарные операции изменяют строку на число, и арифметические операции с строкой тоже переводят ее в число. У операции конкатенации приоритет – последний.
3. Без доп переменной пытался что-то придумать через передачу ссылки параметра и значения параметра по одной из переменных. Не доделал.
1.Зацикливание – счетчик не меняется.
2. 010010
01010
1
“010”+”-10″+”1″ = 010-101
3. а) В=Начислено;
Начислено= Выплачено;
Выплачено=Начислено;
б) Начислено=Начислено+Выплачено;
Выплачено=Начислено-Выплачено;
Начислено=Начислено-Выплачено;
Задание выполнил.
Задание №1 интересное – полезно было понять, что в отличие от других языков программирования в 1С не получится использовать присваивание в параметрах функций: подобные конструкции будут восприняты как сравнение.
В задании №2 сюрпризом оказался символ “-” в итоговой строке. Тоже полезное задание на внимательность в понимание принципов преобразования типов в языке 1С.
Решение задания №3 знал.
Бесконечный цикл, условие выхода или окончания не соблюдается. В некоторых средах, но не в 1С еще на этапе проверки синтаксиса среда разработки сообщает об этом. В массив в каждый следующий элемент постоянно пишется Ложь
“010010”, “010010”, 1, “010-0101” можно еще включить “010”-+”010″+1 в тест
С переменной <code>ВременнаяПерем = Начисленно; Выплачено = Выплачено – ВременнаяПерем; Начислено = Начислено + ВременнаяПерем;</code>
Без переменной <code>Выплачено = Выплачено – Начислено; Начислено = Начислено + Выплачено;</code>
Ваше решение задачи №3 варианта “без дополнительной переменной” заинтересовало меня тем, что оно является неверным, но дает ожидаемый результат.
Оно будет давать правильный результат только в том случае, если одна из переменных будет больше другой ровно в 2 раза. Во всех остальных случаях значения переменных меняться не будут! Например при Выплачено = 120 и Начислено = 7 результат будет неверным!
Все верно!
1. Ложь
2. Кроме первого – не угадал :(
3.1
ВремПерем = Выплачено;
Выплачено = Начислено;
Начислено = ВремПерем;
3.2
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
Затруднений при изучении 0 блока не возникало, материал в видео уроках изложен очень доступно. В 8-ке я новичок, поэтому пока не все получается, но ужасно интересно :)
Дальше будет еще интереснее :)
1. Создается массив с беск. количеством элементов Ложь.
2.Сложение строк 010010
не понял (хотя и посчитал в табло)
строки приводятся к числу, ответ 1
не понял (хотя и посчитал в табло)
3. с промежуточной переменной просто.
без промежуточной через
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
.
Забавные особенности языка открываются. Никогда не задавался такими вопросами, а оказалось все интереснее, чем кажется.
Итог:
1. Ошибся, проверил, удивился :)
2. Местами угадал
3. Первый вариант без комментария.
Второй – ступил, подсмотрел.
1) По аналогии а=б=1 где б=0; В массиве всегда будет Ложь, т.к массиву присваивается результат сравнения, а не сложения.
2) Исходя из порядка преобразования с права на лево:
а. Сложение двух строк дает строку ; б.Сложение строки “010” и числа +”010″=10 дает 01010 в. разница двух одинаковых строк дает 0 и +1 дает 1 г.Сложение строки “010” числа -10 и +1 дает строку 010-101 г.
3) 1-й …..
2-й Начислено = Начислено+Выплачено //3000
Выплачено = Начислено-Выплачено //1000
Начислено = Начислено-Выплачено/2000
1. Здесь я ошибся, так как думал что цикл пройдет тысячу раз и закончится, а в действительности он зациклился.
3. С временной переменной я думаю тут понятно, а на счет второго способа то это можно сделать добавлениями и вычитанием
Виплачено = Начислено + Виплачено;
Начислено = Виплачено – Начислено;
Виплачено = Виплачено – Начислено;
Виплачено = Начислено + Виплачено;
Начислено = Виплачено – Начислено;
Виплачено = Виплачено – Начислено;
2. Задание зделал ошыбки в 2 и 3 пунктах.
1. Произойдет зацикливание.
2.
010010
01010
1
010-101
010010 ,01010,1 в последнем варианте ошибся.
3. С использование промежуточной переменной тривиально.
Без нее Начислено=Начислено-Выплачено
Выплачено=Выплачено+Начислено
Начислено=Выплачено-Начислено
1)Прочитав внимательней функцию допёр что метод массива не увеличивает счётчик, правда сначала два раза застопорил отладчик. “Вычислить выражение” показало один элемент массива = 1.
2)Ошибся в 3из4 ожидая преобразования в число.
3)С использованием промежуточной переменной элементарно,без неё по такому принципу;
a=2; b=3;
a=a+b; //5
b=a-b; //2
a=a-b; //3
1. Получается бесконечный цикл, потому как присвоение не происходит.
2. Ошибся в пункте Г
3. Решил через сложение и вычитание.
1. Получается бесконечный цикл, потому как присвоение не происходит.
2. Ошибся в пункте Г
3. Без вспомогательной переменной решил через сложение и вычитание.
Домашнее задание 2:
1) В метод массива Добавить() передаётся выражение, но в метод необходимо передавать Значение, соответственно выражение должно быть преобразовано, левая часть от знака равенства будет сравниваться с правой, в левой ноль в правой один, соответственно выражение вернет значение булевского типа Ложь, и произойдет зацикливание
2) а) “010” + “010” значение “010010”.
б) “010” ++ “010” значение “01010”. (+”010″ унарная операция получит значение типа число 10)
в) “010” – “010”+1 = 1 (ошибся)
г) “010” +- “010” + 1 = 010 – 101 (ошибся)
3) с промежуточной переменной:
<code>
Процедура ПриОткрытии(Отказ)
Начислено=1000;
Выплачено=2000;
ПромежуточнаяПеременная=Выплачено;
Выплачено=Начислено; Начислено=ПромежуточнаяПеременная;
КонецПроцедуры
</code>
без промежуточной переменной:
<code>
Процедура ПриОткрытии(Отказ)
Начислено=1000;
Выплачено=2000;
Выплачено = Выплачено – Начислено;
Начислено = Выплачено + Начислено;
КонецПроцедуры
</code>
У вас, как и у Константина, та же ошибка в решении.
Ваше решение будет давать правильный результат только в том случае, если одна из переменных будет больше другой ровно в 2 раза. Во всех остальных случаях значения переменных меняться не будут! Например при Выплачено = 23 и Начислено = 700 результат будет неверным!
1. бесконечный цикл из-за отсутствия приращения счетчика
2.значения в уме подтвердились при помощи табло (из уроков по преобразованию типов)
3.при помощи доп переменной не возникло проблемм, а вот без пришлось задуматься , но инет пришлось пошерстить и найти арифметическое решение , сам не додумался.
1. Значение переменной Счетчик не будет меняться – поэтому цикл бесконечен
2. “010” + “010” = “010010” (строка + строка = строка)
“010” ++ “010” = “010” + 10= “01010”
“010” – “010”+1 = 1 (010 приводится к числу)
“010” +- “010” + 1 = “010 – 101” (результат посмотрел в табло, сам так и не смог разобраться почему так происходит)
3. &НаКлиенте
Процедура ПриОткрытии(Отказ)
Тысяча = 1000;
ДвеТысячи = 2000;
//ДополнитПеремен = ДвеТысячи;
//ДвеТысячи = Тысяча;
//Тысяча = ДополнитПеремен;
Тысяча = Тысяча + ДвеТысячи;
ДвеТысячи = Тысяча – ДвеТысячи;
Тысяча = Тысяча – ДвеТысячи;
ПоказатьОповещениеПользователя(“Тысяча – ” + Тысяча + ” ДвеТысячи – ” + ДвеТысячи);
КонецПроцедуры
1.С циклом не угадал
2. Б и Г ошибся
3. 1 вариант понятно, а второй все элементарно, но подсмотрем – надо было на 5 мин. подольше подумать.
Массив заполненный значениями “Ложь”. Счетчик не увеличивается => цикл бесконечный
Значение1 = 1000
Значение2 = 2000
//С промежуточной переменной
ВремПерем = Значение1;
Значение1 = Значение2;
Значение2 = ВремПерем;
//Через строки (как я понял не то, что требовалось, но тем не менее один из вариантов)
Значение1 = “” + Значение1 + “@” + Значение2;
Значение2 = Лев(Значение1, (СтрДлина(Значение1) – Найти(Значение1, “@”)));
Значение1 = Прав(Значение1, (СтрДлина(Значение1) – Найти(Значение1, “@”)));
//Через арифметику
Значение1 = Значение1 + Значение2;
Значение2 = Значение1 – Значение2;
Значение1 = Значение1 – Значение2;
010010 (две строки)
01010 (второй аргум. из-за унарной операции преобр. к числу, но строка + число = строка)
1 (операция ‘-‘ для строк не определена => 10-10+1 = 1)
010-101 (операция -“010” дает -10 => “010” + – 10 + 1) и все равно ясности нет
//первоначальный ответ: 010-10+1 => 10-10+1 = 1)
Выполнено
1 Бесконечный цикл
2
а. 010010
б. 01010
в. 1
г. 010-101
3
Начислено = 1000;
Выплачено = 2000;
Перем1 = Начислено;
Начислено = Выплачено;
Выплачено = Перем1;
Начислено = 1000;
Выплачено = 2000;
Выплачено = Выплачено – Начислено;
Начислено = Выплачено + Начислено;
Попробуйте во втором варианте – без дополнительной переменной – задать другие начальные значения, например Начислено = 83, Выплачено = 256 и посмотрите поменяются ли переменные местами :)
Пожалуй нужно поменять данные контрольного примера в задании :)
Сделал. В цикле заметил ошибку, понял.
С операторами, увы, ошибся в 3 из 4 случаев, сделал работу над ошибками :)
С задачей – решение через промежуточную переменную было очевидно, а вот со вторым способом чего-то задумался, но в итоге разобрался. Спасибо за задание, было интересно!
1) Произойдет зацикливание.
Чтобы цикл работал, внесла исправления:
Пока Счетчик<1000 Цикл
Счетчик=Счетчик+1;
М.Добавить(Счетчик);
2) А 010010 Б 01010 В 1 Г ошиблась
3) С промежуточной переменной
А=Начисленно;
Начисленно=Выплаченно;
Выплаченно=А;
Без промежуточной переменной на ум пришло только решение в лоб через Если.
Правильное решение посмотрела в комментариях. Оказалось все очень просто.
1. В уме подумал, что цикл будет исполняться до 1000, запустив программу убедился, что она зависнет. Почитал комментарии других участников понял почему. Вспомнил д/з №1.
Попробовал исправить, чтобы работало.
2. Ошибся в Г. Остальные посчитал правильно (А 010010, Б 01010, В 1).
3. С промежуточной переменной
Начислено = 2000;
Выплачено = 1000;
С = Начислено;
Начислено = Выплачено;
Выплачено = С;
без промежуточной переменной
сам не смог придумать посмотрел у пользователей оказалось не сложно.
Задание выполнил.
1. Видно что массив заполняется результатом сравнения, счетчик не меняется.
2. Все просто, нужно помнить что система пытается привести последующие операнды к типу первого.
3. С промежуточной переменной все понятно,
если без неё то можно с помощью арифметических операций, ничего оригинального и простого в голову что-то не приходит (по крайней мере не в среде 1С)
1) Непонял сначала почему будет бесконечный цикл
потом вычитал у trambalda
2) Правильно ответил только на 1уже сейчас 8.2 начинает выносить мне мозг, что будет дальше
3) Начислено = 10000;
Выплачено = 20000;
а = выплачено;
выплачено = начислено;
Начислено = а;
сообщить(“1 вариант с переменной было: Начислено = 10000″ + ” стало ” + Начислено );
сообщить(“1 вариант с переменной было: ВЫплачено = 20000″ + ” стало ” + Выплачено );
// 2 вариант за 15 минут не догадался, нашел в нете за минуту
Начислено = 10000;
Выплачено = 20000;
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
//
сообщить(“2 вариант с переменной было: Начислено = 10000″ + ” стало ” + Начислено );
сообщить(“2 вариант с переменной было: ВЫплачено = 20000″ + ” стало ” + Выплачено );
на 8ке можно сделать что-то подобное?
код из паскаля
а:=a xor b;
b:=b xor a;
>на 8ке можно сделать что-то подобное?
Нет, не возможно.
Вообще никаких операций по бинарному сдвигу и прочих система не поддерживает.
1.
При анализе кода предположил, что
произойдет зацикливание. Нет увеличения счетчика цикла.
После запуска убедился, что предположение верное
2.
Ошибся в пунктах В и Г :(
3.
вариант А
А = Начислено;
Начислено=Выплачено;
Выплачено = А;
вариант Б
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
1. происходит зацикливание.
2. выполнено без проблем
3.
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено-Выплачено;
1. Этот вариан рассматривался в вопросах участников, иначе бы ошибся.
2. Ошибся в Б и Г.
3. а) С = А;
А = В;
В = С;
б)А = А + В;
В = А – В;
А = А – В; ( с трудом вспомнил, сталкивался уже с таким решением)
По курсу копится масса вопросов, пока записываю их в надежде получить ответы по ходу обучения.
>По курсу копится масса вопросов, пока записываю их в надежде получить ответы по ходу обучения
Можете задавать вопросы в мастер-группу, если они соответствуют тематике курса.
1 Зацикливание т.к счетчик не увеличивается
2 А: 010010 строка
Б:01010 строка
В:1 число
Г 010-101 строка
3 а) Трет =Начислено;
Начислено=Выплачено;
Выплачено=Трет;
Б) Начислено=Начислено+Выплачено;
Выплачено=Начислено-Выплачено;
Начислено=Начислено-Выплачено;
1. Понял, что будет бесконечный цикл с формированием “ложного” массива (интересно, какова максимальная емкость).
2. Немного озадачило выражение В, после его осознания с Г легко посчитал.
3. Пример с временной переменной рассматривался в 11 главе:
<code>
Врем = Начислено;
Начислено = Выплачено;
Выплачено = Врем;
</code>
Без третьей переменной:
<code>
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
</code>
Так получилось, что задание сделал вперед ознакомления с материалом занятия. После урока “Приоритеты арифметических операций” заминок во втором пункте ДЗ возникать не должно :)
Ок :)
>интересно, какова максимальная емкость
Скорее всего около 2Gb. Именно столько может адресовать 32 разрядная система для каждого приложения.
Если в Boot.ini написать /3GB то будет 3GB,
но таким способом лучше не пользоваться. Лучше переходить на 64 разрядную систему.
Разумеется.
1) С циклом ошибся
2) Ошибся в “Г”
3) а) Временная=Выплачено;
Выплачено=Начислено;
Начислено=Выплачено;
б) Выплачено=Начислено+Выплачено;
Начислено=Выплачено-Начислено;
Выплачено=Выплачено-Начислено;
Добрый день!
1. Глядя на задачу, сразу понял, что в массив будет писаться результат вычисления логического выражения Счетчик = Счетчик + 1, т.е. Ложь. Но вот сомневался – будет ли цикл бесконечен, или ограничится 1000 «оборотов».
Практика показала – что цикл бесконечен. :)
Между тем – мозг продолжает сомневаться – насколько бесконечен цикл? Ограничивает ли 1С размер массива? Или его ограничит только заполнение «под завязку» памяти?
2. И снова не смог в уме правильно ответить на все вопросы. Мне каждый раз казалось, что 1С должна перевести строковые выражения из примера в числа.
Запустив табло, я убедился в степени моего заблуждения. :)
3. Ну уж тут я развернулся! :)
========================
Функция ПоменятьМестамиНачисленоВыплачено(Начислено, Выплачено, Способ)
Если Способ = 1 Тогда
врКейс = Начислено;
Начислено = Выплачено;
Выплачено = врКейс;
ИначеЕсли Способ = 2 Тогда
Начислено = “С” + Начислено + “;” + Выплачено;
ПозРазделителя = Найти(Начислено, “;”);
Выплачено = Число(Сред(Начислено, 2, ПозРазделителя – 2));
Начислено = Число(Сред(Начислено, ПозРазделителя + 1));
КонецЕсли;
========================
> Или его ограничит только заполнение «под завязку» памяти?
Скорее всего так.
1.
Происходит зацикливание (массив заполняется значением «ЛОЖЬ»)
2.
Самостоятельно ответил на первый и второй пункт:
А.”010″+”010″=010010
Б.”010″++”010″=01010
В.”010″-“010″+1=1
Г.”010″+-“010″+1=010-101
3.
С использование промежуточной переменной
Временно=Начислено;
Начислено=Выплачено;
Выплачено=Временно;
Без её использования
Начислено=Начислено+Выплачено;
Выплачено=Начислено–Выплачено;
Начислено=Начислено–Выплачено;
1. Выполнено
2. Ошибся в (Г). Разобрался понял ,что там происходит конкатенация. После чего мне стала интересно ,а если сделать два минуса “010”–“010″+1 может там будет сложение и оказалось так и есть получилось число 21.
“010”–“010” = 20, “010”–“021″+12=43
Можно сказать ,что у строк есть и сложение.
3. мПерем = Начислено;
Начислено = Выплачено;
Выплачено = мПерем;
Начислено= Начислено*Выплачено;
Выплачено = Начислено/Выплачено;
Начислено = Начислено/Выплачено;
1. Выполнено2. Ошибся в (Г). Разобрался понял ,что там происходит конкатенация. После чего мне стала интересно ,а если сделать два минуса “010”–“010″+1 может там будет сложение и оказалось так и есть получилось число 21.”010”–“010” = 20, “010”–“021″+12=43 Можно сказать ,что у строк есть и сложение.3. мПерем = Начислено;Начислено = Выплачено;Выплачено = мПерем;
Начислено= Начислено*Выплачено;Выплачено = Начислено/Выплачено;Начислено = Начислено/Выплачено;
Задание оказалось очень полезным.
1. Зацикливание: в вызове метода Добавить() используется булевское выражение сравнения, нет приращения счетчика.// Помогли ответы на вопросы.
2. А. “010”+”010″ //” 010010″
Б. “010” ++ “010” // “01010”
В. “010” – “010” // 1 -число
Г. “010” +- “010” +1 // “010-101”
3. А. ПеремОбмена = Начислено;
Начислено = Выплачено;
Выплачено = ПеремОбмена;
Б. Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
1.Если бы читал в программе, пропустил бы, а так как был задан вопрос, догадался, сто в скобках булево, следовательно зацикливание.
2. В варианте Г. “лопухнулся” (“01011” вместо “010-101”)
3. В=А+В
А=В-А
В=В-А
воткнули факел знаний -> не знал как коменты в Запросах писать, да и Автозамену включил видьмо навсегда
Это хорошо :)
1. В метод массива Добавить() передается результат вычисления выражения: Счетчик = Счетчик +1. Это логическая операция сравнения. Очевидно, что результатом является ЛОЖЬ. Т. о. на каждом витке цикла в массив добавляется элемент типа Булево со значением ЛОЖЬ. Переменная Счетчик на каждом витке цикла остается равной 0. Получаем теоретически бесконечный цикл. На практике все же конечный, но очень длинный – пока хватит памяти под массив.
2. А. «010» + «010» результат «010010».
Конкатенация строк.
Б. «010» ++ «010» результат «01010».
Сначала унарная операция +«010» преобразует строку «010» в число 10, затем оно преобразуется к строке «10» и «склеивается» со строкой «010».
В. «010» – «010» + 1 – результатом является число 1.
Так как вычитание не применимо для строк, то «010» преобразуется к числу 10.
Г. «010» +- «010» + 1 – результатом является «010-101».
Сначала унарная операция -«010» преобразует строку «010» в число 10 с минусом, затем оно преобразуется к строке «-10» и «склеивается» со строкой «010». В конце к результирующей строке добавляется еще строка «1».
3. А. ПромПерем = Начислено;
Начислено = Выплачено;
Выплачено = ПромПерем;
Б. Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
1. Бесконечный цикл, так как счетчик = счетчик + 1 в данном контексте – логическая операция сравнения.
2. Проверил в “табло”.
3.
Перем Начислено, Выплачено;
Начислено = ЗначА;
Выплачено = ЗначВ;
СменитьЗначения(Начислено,Выплачено);
&НаКлиенте
Процедура СменитьЗначения(Начислено, Выплачено)
//Вариант 1 – с буфером
//Буфер = Начислено ;
//Начислено = Выплачено;
//Выплачено = Буфер;
//Вариант 2 – без буфера
Начислено = Начислено – Выплачено;
Выплачено = Выплачено + Начислено;
Начислено = Выплачено – Начислено;
КонецПроцедуры
1. В 1С присваивание внутри вызова процедуры/функции/метода “не работает”, поэтому Счетчик = Счетчик + 1 будет вычислено как Ложь – сначала выполняется вычисление выражения справа от равенства, а затем проверяется условие на равенство, поэтому значение переменной не изменится, в итоге получаем бесконечный цикл.
2. а) обычная конкатенация строк, результат “010010”; б) “лишний” знак плюс заставляет 1С преобразовывать второй операнд в число 10, затем это число обратно приводится к строке, так как первый операнд – строка, результат “01010”; в) для строк операция вычитания не определена, поэтому обе строки “010” приводятся к числу, результат 1; г) здесь повтор ситуации из пункта “б” – второй операнд приводится к числу -10, но так как первый операнд строка, то все обратно приводится к строке результат “010-101”
3. С промежуточной переменной решение очевидное:
с = Выплачено;
Выплачено = Начислено;
Начислено = с;
без промежуточной, через сложение-вычитание:
Начислено = Начислено + Выплачено;
Выплачено = Начислено – Выплачено;
Начислено = Начислено – Выплачено;
Также можно “сократить” этот вариант, неявно, через функцию “Присвоить” изменив переменную Выполнено, но за подобный код в приличной обществе расстреливают.
Начислено = Начислено + Выплачено – Присвоить(Начислено, Выплачено);
Функция Присвоить(Оп1, Оп2)
Оп2 = Оп1;
Возврат Оп1;
КонецФункции