1s cycle transition to the next iteration. Cycle interruptions. combining conditions. Hotkeys: form management

Which cycle is faster? Testing 1C

• High performance ,
• Abnormal programming,
• Programming

I've been programming 1C for several years now, and then the thought came to me - “Should I take some kind of training course, what if there are some gaps in my knowledge that I didn’t even suspect about before?” No sooner said than done. I’m sitting, listening to the course, I get to cyclic operators and then the second thought (yes, they don’t come to me often) - “Which cycle is faster”? We should check it out.
So I found five ways, how you can organize a cycle using 1C.

The first type of cycle, let's call it conditionally "ForPo" looks like that:

For n = 0 by Number of Iterations Cycle SomeActions(); EndCycle;
Second type "For each":

For Each Collection Element from the Collection Cycle SomeActions(); EndCycle;
Third "Bye":

Bye<>Number of Iterations Cycle SomeActions(); n = n + 1; EndCycle;
Then I remembered my assembler youth - a cycle "If":

~Start of Cycle: If n<>Number of Iterations Then SomeActions(); n = n + 1; Go ~StartCycle; endIf;
And finally "Recursion"

Procedure RecursiveLoop(n, Number of Iterations) SomeActions(); If n<>NumberIterations Then RecursiveLoop(n+1, NumberIterations); endIf; End of Procedure
Naturally, it is not entirely correct to classify recursion as loops, but nevertheless, with its help you can achieve similar results. Let me make a reservation right away that recursion was not involved in further testing. Firstly, all tests were carried out with 1,000,000 iterations, and recursion occurs already at 2,000. Secondly, the speed of recursion is tens of times less than the speed of other loops.

Last retreat. One of the conditions was to perform some actions in the loop. Firstly, the empty loop is used very rarely. Secondly, the “ForEveryone” cycle is used for some collection, which means that other cycles must work with the collection so that testing takes place under the same conditions.

Well, let's go. The body of the loop was reading from a pre-filled array.

or, when using the “ForEach” loop

TestValueReceiver = Element;
Testing was carried out on platform 8.3.5.1231 for three types of interface ( Regular application, Managed Application and Taxi).
The numbers are the time in milliseconds obtained using the function CurrentUniversalDateInMilliseconds(), which I called before the loop and after it completed. The numbers are fractional because I used the arithmetic average of five measurements. Why didn't I use Performance Measurement? I had no goal to measure the speed of each line of code, only the speed of cycles with the same result.

It would seem that’s all, but - test, test!
Result for platform 8.2.19.106
On average, platform 8.2 is 25% faster than 8.3. I didn't expect such a difference and decided to test it on another machine. I won’t give the results, but you can generate them yourself using this configuration. I’ll just say that 8.2 was 20 percent faster.

Why? I don’t know, disassembling the kernel was not part of my plans, but I still looked at the performance measurement. It turned out that the cyclic operations themselves are somewhat faster in 8.3 than in 8.2. But on the line
TestValueReceiver = TestArray.Get(n);
that is, there is a significant performance hit when reading a collection element into a variable.

Eventually:
What is all this for? I made several conclusions for myself:

1. If it is possible to use a specialized cycle - “For Everyone”, then it is better to use it. By the way, it itself takes longer to complete than other loops, but its access speed to a collection element is much higher.
2. If you know the number of iterations in advance, use “ForPo”. “For now” will work slower.
3. If you use the “If” loop, other programmers will clearly not understand you.

  21
 //The function generates an easy-to-read representation of values. // Examples of number formatting ValueFormat = Format(123456.789, " NRT=10; NRT=2"); //ValueFormat = "123,456.79"ValueFormat = Format(123456.789, "HH=0; NHV=2"); //Value   16
 Full text search - will allow you to find text information, placed almost anywhere in the configuration used. In this case, you can search for the necessary data either throughout the entire configuration as a whole, or by narrowing...   8
 "Point in time" is a virtual field, not stored in the database. Contains a Point in Time object (which includes a date and a LINK TO A DOCUMENT) In 7.7 there was the concept of Document Position, and in 8.x Point in Time To get...   6
 For 8.x FindByLinks (FindDataByRef) Syntax: FindByLinks (List of Links) Parameters: List of Links Required Type: Array. An array with a list of links to objects whose links need to be found. ...

In this article we will consider such a construction of the 1C programming language as Cycles.

There are three ways to organize loops.

1. Loops using a logical expression (executed until logical expression true)
2. Looping through collections

Let's look at each of these methods.

Loops using a loop counter variable

Syntax:

With this method of organizing loops, a counter variable is assigned a certain initial value and it is executed as long as the value of the counter variable is less than or equal to the specified final value.

With each iteration, the counter value increases by one. Here is the most basic example of such a loop:

Unlike many other programming languages, 1C does not provide the ability to specify a step in a cycle. If necessary, this can be done by adding the desired value to the counter inside the loop

Loops Using Boolean Expressions

Syntax:

Refuse = False ; GeneratorRandom = NewRandomNumberGenerator(1) ; Until Failure Cycle RandomNumber = GeneratorRank. RandomNumber(0, 10); If RandomNumber > 5 Then Failure = True ; EndIf ; EndCycle ;

That is, the loop will run until a random number greater than five is generated.

Looping through collections

In the 1C programming language there is such a thing as a collection. It is a set of elements contained within an object.

We can include such objects as a collection: an array, a table of values, a selection from a query result, metadata, etc. This concept is quite conventional, but it appears at every step in the syntax assistant. Very often we encounter a task when we need to sequentially iterate through all the elements of a collection in order to perform some actions on them. That's why it exists syntactic construction:

Here <ЭлементКоллекции> is a variable into which elements from the collection are sequentially placed. And inside the loop it is processed accordingly.
As an example, I’ll give you a loop of traversing the rows of a table of values. Let it be called TableProducts and looks like this:

Let's go through this table in a loop and for each row we will display a message with the name and price of the product:

In fact, the same thing can be done using the first option, that is, in a loop using a counter:

Number of Rows = TableProducts. Quantity() ; For Counter = 0 By Number of Rows - 1 Cycle Table Row = TableProducts[ Counter] ; Name = Table Row. Name; Price = TableRow. Price; Message = New MessageToUser; Message. Text = "Name of product: "+ Name + "; Price: " + Price; Message. To report() ; EndCycle ;

But as we can see, using traversal of collection elements is much simpler and more convenient

Auxiliary Operators

There is often a situation where, depending on something, it is necessary to interrupt the execution of a loop or move on from the next iteration.

Interruption is carried out using the operator Abort. In this case, the execution of the loop is interrupted and control is transferred to the language construct that follows the loop. If you need to move to the next iteration, you must use the operator Continue. Then control is transferred to the beginning of the loop. Let's illustrate with a small example:

We skip zero, because You cannot divide by zero. And the loop will be executed five times in total, for the values ​​of the variable Counter from 0 to 4

Each 1C solution on the 1C:Enterprise 8 platform has a wide range of capabilities. However, there are universal techniques that can be used in any configuration. With this article we are opening a series of publications in which 1C methodologists will talk about the universal capabilities of the 1C:Enterprise 8 platform. Let's start with one of the most important methods for increasing work efficiency - with a description of “hot” keys (actions from the keyboard, as a rule, are performed faster than those through the menu using the mouse). Having mastered the hotkeys, you will simplify the execution of frequently repeated actions.

Table 1

Hotkeys: global actions

Global actions are actions that you can perform in any program state. It doesn’t matter what this moment open in 1C:Enterprise. The main thing is that the application is not busy performing any task.

Global actions are actions that can be called anywhere in the running 1C:Enterprise 8 platform. Regardless of what exactly happens in running configuration, the meaning of global actions does not change (for example, pressing Ctrl+N will always bring up the dialog for creating a new document).

Table 1

Hotkeys for global actions

Hotkeys: general actions

General actions- actions that have the same meaning in different configuration objects, but the behavior of the 1C:Enterprise 8 platform changes depending on where exactly you use this or that general action. For example, pressing the "Del" key marks the current directory element for deletion if you are in the list of directory elements window. Or deletes the contents of the current cell of a spreadsheet document if you are editing it.

table 2

Hotkeys for common actions

Hotkeys: window management

This section combines hotkeys common to all windows and forms of the 1C:Enterprise platform.

Table 3

Hotkeys for managing windows

Hotkeys: form management

Here are collected "hot" keys that simplify and speed up work with various forms that were created in configurations written on the 1C:Enterprise platform.

Table 4

Hotkeys for managing forms

Hotkeys: working with lists and trees

The hotkeys in this section will help you work effectively without using a mouse in numerous lists and trees that are actively used in various configuration objects on the 1C:Enterprise 8 platform.

Table 5

Hotkeys for working with lists and trees

Hotkeys: input field

Entry field- an actively used control element in many places in configuration forms. Hotkeys for an input field allow you to quickly perform frequently used actions on it. It is especially useful to use these keys where the configuration developer has not provided the input field control buttons you need.

Table 6

Hotkeys for the input field

Hot keys: image field

Picture field- this is a standard element of the 1C:Enterprise 8 platform for displaying graphic images. Hot keys will help, for example, to comfortably view an image located in the picture field.

Table 7

Hotkeys for the image field

Hotkeys: Spreadsheet Document Editor

This section contains grouped hotkeys for various spreadsheet documents. They can be very useful if you frequently edit data in such documents.

Table 8

Hotkeys for the spreadsheet editor

Hotkeys: text document editor

Hotkeys when editing text in text areas and documents can significantly speed up and simplify the process.

Table 9

Hotkeys for the editor text documents

You can exit the loop and transfer control to the first executable statement following the loop by using the Abort operator. To skip some of the loop statements and move on to the next iteration, use the Continue statement. In this case, control is transferred to the operator at the beginning of the loop, to the For or While operator. The Abort and Continue operators are not used separately, but are built into “if” constructs.

Example. Report the value of the first non-periodic constant numeric type.

// Procedure that prints the value of the first non-periodic constant of numeric type

// Runs from processing Sample procedure Execute()

// Output flag

totalConstant = Metadata.Constant(); for in = 1 for all Constant loop

if Metadata.Constant(in).Periodic = 1 then

continue; // Transfer control to the operator For endIf;

if Metadata.Constant(in).Type = "Number" then

ideas = Metadata.Constant(in).Identifier;

Report(iden +" " + Constant.GetAttribute(iden)); // Balance of Days 1 Output flag = 1;

interrupt; // Exit the loop early For

endIf; endCycle; // For

if Output flag = 0 then

endProcedure // Execute

Comment. Sometimes programmers in the For loop, instead of the Abort operator, resort to changing the value of the loop variable in. So, in our case, the Abort operator could be replaced by the operator

in = totalConst;

Such actions, however, are classified as bad programming style.

Some programmers believe that loop interrupt operators (in 1C these are Continue and Abort) worsen the structure of the program, and therefore, whenever possible, refuse to use them. Instead it is used combining conditions.

Let us also follow the principles structured programming, by writing code that solves the above problem using the union of conditions. In this code, we will have to abandon the For loop, replacing it with the While loop.

// A procedure that uses a combination of conditions and prints the value of the first

// non-periodic constant of numeric type. Runs from processing Sample procedure Execute()

variable allConstants, Output flag, in, ideas; ClearMessageWindow();

// Output flag will take the value 1 if detected

// non-periodic constant of numeric type Output flag = 0;

totalConstant = Metadata.Constant();

in = 1; // Constant number for now (in<= всегоКонстант) и (флагВывода = 0) цикл

if (Metadata.Constant(in).Periodic = 0) and (Metadata.Constant(in).Type = "Number") then

ideas = Metadata.Constant(in).Identifier; Report(iden + " " + Constant.GetAttribute(iden)); Output flag = 1;

endIf;

in = in + 1; // Don't forget to move to the next constant end of the Loop; // For

if Output flag = 0 then

Report("There are no non-periodic constants of numeric type in the configurator."); endIf;

endProcedure // Execute

In the above code, the union of conditions is used when writing the LP twice: (in<= всегоКонстант) и (флагВывода = 0)

(Metadata.Constant(in).Periodic = 0) and (Metadata.Constant(in).Type = "Number") This allowed us to exclude the Continue and Abort operators from the procedure.