Lazarus IDE Tools/ru: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		[[Lazarus Faq/ru\|Lazarus]] IDE - это инструменты библиотеки [[Free Pascal]] для синтаксического анализа и редактирования, называемая "codetools"\[(утилиты кода)\].
2	2
3	3		Эти инструменты предоставляют такие функции для исходников, как "Переход к объявлению", "Завершение кода", "Извлечение", "Перемещение вставки" и "Украшение Паскаля". Эти функции могут сэкономить много времени и пустой работы. Они настраиваются, и каждая функция доступна с помощью ярлыков (см. Editor Options).
4	4
5	5		Поскольку они работают исключительно с исходниками Pascal и понимают коды FPC, [[Delphi]] и [[Kylix]], им не требуются компилированные модули или установленный компилятор Borland/Embarcadero. Код Delphi и FPC можно редактировать одновременно с несколькими версиями Delphi и FPC. Это упрощает перенос кода Delphi в FPC/Lazarus.
6	6
7	7		## Горячие клавиши в IDE
8	8
9	9		\| \| \|
10	10		\|----\|----\|
11		-	\| [[Lazarus IDE Tools\|Переход на объявление]] \| <span class="kbd">Ctrl</span>+ЛКМ или <span class="kbd">Alt</span>+<span class="kbd">Up</span> (Переход на объявление типа или переменной) \|
12		-	\| [[Lazarus IDE Tools/ru\|Переход на метод класса]] \| <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span> (Переход туда сюда между объявлением и телом метода) \|
13		-	~~\| [[Lazarus IDE Tools/ru\|Шаблоны кода]] \| <span class="kbd">Ctrl</span>+<span class="kbd">J</span> \|~~
14		-	~~\| [[Lazarus IDE Tools/ru\|Синхронная правка]] \| <span class="kbd">Ctrl</span>+<span class="kbd">J</span> (Пока текст выделен) \|~~
15		-	~~\| [[Lazarus IDE Tools/ru\|Завершение кода]] (Завершение класса) \| <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> \|~~
16		-	~~\| [[Lazarus IDE Tools\|Завершение идентификатора]] \| <span class="kbd">Ctrl</span>+<span class="kbd">space</span> \|~~
17		-	~~\| [[Lazarus IDE Tools\|Завершение слова]] \| <span class="kbd">Ctrl</span>+<span class="kbd">W</span> \|~~
18		-	~~\| [[Lazarus IDE Tools/ru\|Подсказка для параметров]] \| <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">space</span> \|~~
19		-	~~\| [[Lazarus IDE Tools/ru\|Последовательный поиск]] \| <span class="kbd">Ctrl</span>+<span class="kbd">E</span> \|~~
	11	+	\| [[Lazarus IDE Tools\|Переход на объявление]] \| `Ctrl`+ЛКМ или `Alt`+`Up` (Переход на объявление типа или переменной) \|
	12	+	\| [[Lazarus IDE Tools/ru\|Переход на метод класса]] \| `Ctrl`+`Shift`+`Up` (Переход туда сюда между объявлением и телом метода) \|
	13	+	\| [[Lazarus IDE Tools/ru\|Шаблоны кода]] \| `Ctrl`+`J` \|
	14	+	\| [[Lazarus IDE Tools/ru\|Синхронная правка]] \| `Ctrl`+`J` (Пока текст выделен) \|
	15	+	\| [[Lazarus IDE Tools/ru\|Завершение кода]] (Завершение класса) \| `Ctrl`+`Shift`+`C` \|
	16	+	\| [[Lazarus IDE Tools\|Завершение идентификатора]] \| `Ctrl`+`space` \|
	17	+	\| [[Lazarus IDE Tools\|Завершение слова]] \| `Ctrl`+`W` \|
	18	+	\| [[Lazarus IDE Tools/ru\|Подсказка для параметров]] \| `Ctrl`+`Shift`+`space` \|
	19	+	\| [[Lazarus IDE Tools/ru\|Последовательный поиск]] \| `Ctrl`+`E` \|
20	20
21	21		## Переход между методом и его объявлением
22	22
23		-	Для перехода между телом процедуры (begin..end) и объявлением процедуры (procedure Name;) используйте <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span>.
	23	+	Для перехода между телом процедуры (begin..end) и объявлением процедуры (procedure Name;) используйте `Ctrl`+`Shift`+`Up`.
24	24
25	25		Для примера:
26	26
27	27		``` pascal
28	28		interface
29	29
30	30		procedure DoSomething; // Объявление процедуры
31	31
32	32		implementation
33	33
34	34		procedure DoSomething; // Тело процедуры
35	35		begin
36	36		end;
37	37		```
38	38
39		-	Если курсор стоит на теле процедуры и Вы нажмёте <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span>, то курсор перескочит на объявление, потом опять <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span> и курсор перескочит на тело процедуры, после 'begin'.
	39	+	Если курсор стоит на теле процедуры и Вы нажмёте `Ctrl`+`Shift`+`Up`, то курсор перескочит на объявление, потом опять `Ctrl`+`Shift`+`Up` и курсор перескочит на тело процедуры, после 'begin'.
40	40
41	41		Это так же работает между методами-процедурами класса.
42	42
43	43		Подсказка: Переход осуществляется на процедуру с таким же именем и списком параметров. Если нет точной такой же процедуры, то переход будет на наиболее подходящего кандидата и позиционирует курсор на первое же различие. (Для дельфийцев: Delphi не может этого сделать). Пример процедуры с различными типами параметров:
44	44
45	45		``` pascal
46	46		interface
47	47
48	48		procedure DoSomething(p: char); // Объявление процедуры
49	49
50	50		implementation
51	51
52	52		procedure DoSomething(p: string); // Тело процедуры
53	53		begin
54	54		end;
55	55		```
56	56
57	57		Переход с определения к телу процедуры будет позиционировать курсор на ключевое слово 'string'. Это можно использовать для переименования методов и / или изменения параметров.
58	58
59	59		Пример:\
60	60		Вы переименовываете 'DoSomething' в 'MakeIt':
61	61
62	62		``` pascal
63	63		interface
64	64
65	65		procedure MakeIt; // Объявление процедуры
66	66
67	67		implementation
68	68
69	69		procedure DoSomething; // Тело процедуры
70	70		begin
71	71		end;
72	72		```
73	73
74	74		Тогда можно перейти от MakeIt к телу. IDE ищет подходящее тело и не находит, а, следовательно, ищет нечто похожее. Так как вы переименовали только одну процедуру есть ровно одно тело без определения (DoSomething) и будет переход к DoSomething, курсор встанет справа от "DoSomething". Тогда вы можете просто переименовать его прямо там. Это работает и для параметров.
75	75
76	76		## Включаемые файлы
77	77
78	78		Включаемые файлы это файлы вставленные в исходный код с помощью директив компилятора
79	79
80	80		``` pascal
81	81		{$I filename}
82	82		```
83	83
84	84		или
85	85
86	86		``` pascal
87	87		{$INCLUDE filename}
88	88		```
89	89
90	90		. Lazarus и FPC используют эти вещи чтобы уменьшить избыточность и избежать нечитаемых {\$IFDEF} конструкций при поддержке различных платформ.
91	91
92	92		В отличие от Delphi, Lazarus IDE полностью поддерживает включаемые файлы. Вы можете для примера перепрыгнуть с метода в .pas файле к телу метода во включаемом файле. Все инструменты для работы с кодом, такие как автозавершение кода, просматривают текст во включаемых файлах на предмет специальных связей.
93	93
94	94		Например: когда автозавершение кода добавляет новое тело метода за другим телом метода, он хранит их обоих в одном файле. Таким образом, вы можете помещать целые реализации классов в файлы include, как, например LCL \[делает\] для почти всех элементов управления.
95	95
96	96		Но \[тут\] есть ловушка для новичков: Если вы впервые откроете файл include и попробуете прыгнуть к методу или найди \[его\] объявление, вы получите сообщение об ошибке. IDE не знает, к какому модулю принадлежит файл include. Сначала вы должны открыть модуль.
97	97
98	98		Как только IDE проанализирует модуль, она \[начнет\] анализировать директивы include, и \[затем\] IDE запоминает эти взаимосвязи. Она сохраняет эту информацию при выходе и при сохранении проекта в ~/.lazarus/includelinks.xml. В следующий раз, когда вы откроете этот include-файл и перейдете \[к объявлению\] или найдете \[его поиском\], IDE будет открывать модуль изнутри \[include-файла\], и переход будет работать. Вы также можете указать подсказку IDE, поставив
99	99
100	100		``` pascal
101	101		{%mainunit yourunit.pas}
102	102		```
103	103
104	104		наверху вашего yourinclude.inc.
105	105
106	106		Конечно, этот механизм имеет ограничения. Некоторые include-файлы включаются дважды или более. Например: lcl/include/winapih.inc.
107	107
108	108		Переходы с объявления процедуры/метода в этом include-файле к \[их\] телу зависят от ваших последних действий. Если вы работаете в lcl/lclintf.pp, среда IDE перейдет в winapi.inc. Если вы работаете в lcl/interfacebase.pp, тогда она перейдет в lcl/include/interfacebase.inc (или в один из других включенных файлов). Если вы работаете над обоими, то вы можете запутаться. ;)
109	109
110	110		## Шаблоны кода
111	111
112	112		Шаблоны кода преобразуют идентификатор в текст, или фрагмент кода.
113	113
114		-	По умолчанию горячие клавиши для шаблонов кода <span class="kbd">Ctrl</span>+<span class="kbd">J</span>. Вы можете ввести идентификатор, нажать <span class="kbd">Ctrl</span>+<span class="kbd">J</span> и идентификатор заменится на текст определенный для этого идентификатора. Шаблоны кода можно задать в Environment -\> Editor Options -\> CodeTools.
	114	+	По умолчанию горячие клавиши для шаблонов кода `Ctrl`+`J`. Вы можете ввести идентификатор, нажать `Ctrl`+`J` и идентификатор заменится на текст определенный для этого идентификатора. Шаблоны кода можно задать в Environment -\> Editor Options -\> CodeTools.
115	115
116		-	Пример: Введите идентификатор 'classf', поставьте курсор справа от 'f' и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">J</span>. Идентификатор 'classf' будет заменен на
	116	+	Пример: Введите идентификатор 'classf', поставьте курсор справа от 'f' и нажмите `Ctrl`+`J`. Идентификатор 'classf' будет заменен на
117	117
118	118		``` pascal
119	119		T = class(T)
120	120		private
121	121
122	122		public
123	123		constructor Create;
124	124		destructor Destroy; override;
125	125		end;
126	126		```
127	127
128	128		и курсор будет находится за 'T'.
129	129
130		-	Вы можете посмотреть список шаблонов установив курсор на пустое место (не на идентификатор) и нажав <span class="kbd">Ctrl</span>+<span class="kbd">J</span>. Список шаблонов кода появится. Используйте стрелки, или введите несколько символов чтобы выбрать нужный шаблон. <span class="kbd">Enter</span> создаст выделенный шаблон, а <span class="kbd">Escape</span> закроет список шаблонов.
	130	+	Вы можете посмотреть список шаблонов установив курсор на пустое место (не на идентификатор) и нажав `Ctrl`+`J`. Список шаблонов кода появится. Используйте стрелки, или введите несколько символов чтобы выбрать нужный шаблон. `Enter` создаст выделенный шаблон, а `Escape` закроет список шаблонов.
131	131
132		-	~~Больше всего времени экономит шаблон 'b'+<span class="kbd">Ctrl</span>+<span class="kbd">J</span> для begin..end.~~
	132	+	Больше всего времени экономит шаблон 'b'+`Ctrl`+`J` для begin..end.
133	133
134	134		## Подсказка для параметров
135	135
136	136		Подсказка для параметров позволяет посмотреть список параметров для процедур и функций. Жирным шрифтом выделяется текущий параметр.
137	137
138	138		Например:
139	139
140	140		``` pascal
141	141		Canvas.FillRect();
142	142		```
143	143
144		-	Поместите курсор внутри скобок и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">space</span>. Появится подсказка с параметрами процедуры FillRect.
	144	+	Поместите курсор внутри скобок и нажмите `Ctrl`+`Shift`+`space`. Появится подсказка с параметрами процедуры FillRect.
145	145
146		-	~~<figure>~~
147		-	~~<img src="Parameterhints1.png" title="Parameterhints1.png" />~~
148		-	~~<figcaption>Parameterhints1.png</figcaption>~~
149		-	~~</figure>~~
	146	+	![](/wiki-images/c/c8/Parameterhints1.png)
150	147
151	148		Начиная с версии 0.9.31, справа от каждой декларации имеется кнопка, вставляющая отсутствующие параметры. Это скопирует имена параметров из выбранного объявления в позицию курсора.
152	149
153		-	~~<figure>~~
154		-	~~<img src="Parameterhints2.png" title="Parameterhints2.png" />~~
155		-	~~<figcaption>Parameterhints2.png</figcaption>~~
156		-	~~</figure>~~
	150	+	![](/wiki-images/4/48/Parameterhints2.png)
157	151
158	152		Подсказка: используйте [[Lazarus IDE Tools/ru\|Автозавершение объявления переменной]], чтобы объявить переменные.
159	153
160	154		> Note: Имя ярлычка - "Show code context"\[("Показать контекст кода")\].
161	155
162	156		## Последовательный поиск
163	157
164		-	Последовательный поиск изменяет строку состояния редактора исходного кода. Введите несколько символов, и редактор тут же будет их искать, выделяя все вхождения в тексте. Для вызова поиска, нажмите: <span class="kbd">Ctrl</span>+<span class="kbd">e</span>.
	158	+	Последовательный поиск изменяет строку состояния редактора исходного кода. Введите несколько символов, и редактор тут же будет их искать, выделяя все вхождения в тексте. Для вызова поиска, нажмите: `Ctrl`+`e`.
165	159
166		-	~~- Например, нажмите <span class="kbd">e</span> произведёт поиск и выделение всех букв «е» в коде.~~
167		-	~~- Затем, нажав <span class="kbd">t</span> будет произведён поиск и выделение всех вхождений «et» и так далее.~~
168		-	- Вы можете использовать быстрый переход между найденными позициями в тексте нужной строки. Для быстрого перехода вниз по тексту, используйте <span class="kbd">F3</span> (или <span class="kbd">Ctrl</span>+<span class="kbd">e</span> во время поиска). Для быстрого перехода вверх по тексту, используйте <span class="kbd">Shift</span>+<span class="kbd">F3</span>.
169		-	~~- <span class="kbd">Backspace</span> удаляет последний символ~~
170		-	~~- <span class="kbd">Enter</span> останавливает поиск без добавления новой строки в редакторе.~~
171		-	- Вы можете возобновить последний поиск, нажав <span class="kbd">Ctrl</span>+<span class="kbd">e</span> во второй раз, сразу же после начала последовательного поиска используя <span class="kbd">Ctrl</span>+<span class="kbd">e</span>. т.е. когда строка поиска пуста.
172		-	- Вставка <span class="kbd">Ctrl</span>+<span class="kbd">V</span> добавит строку из буфера обмена к текущему искомому тексту. (так же как в lazarus 0.9.27 r19824).
	160	+	- Например, нажмите `e` произведёт поиск и выделение всех букв «е» в коде.
	161	+	- Затем, нажав `t` будет произведён поиск и выделение всех вхождений «et» и так далее.
	162	+	- Вы можете использовать быстрый переход между найденными позициями в тексте нужной строки. Для быстрого перехода вниз по тексту, используйте `F3` (или `Ctrl`+`e` во время поиска). Для быстрого перехода вверх по тексту, используйте `Shift`+`F3`.
	163	+	- `Backspace` удаляет последний символ
	164	+	- `Enter` останавливает поиск без добавления новой строки в редакторе.
	165	+	- Вы можете возобновить последний поиск, нажав `Ctrl`+`e` во второй раз, сразу же после начала последовательного поиска используя `Ctrl`+`e`. т.е. когда строка поиска пуста.
	166	+	- Вставка `Ctrl`+`V` добавит строку из буфера обмена к текущему искомому тексту. (так же как в lazarus 0.9.27 r19824).
173	167
174	168		### Пример использования последовательного поиска для поиска слова
175	169
176	170		- Поместите курсор на нужное слово, не выделяя его
177		-	- Нажмите <span class="kbd">Ctrl</span>+<span class="kbd">C</span>. Редактор исходного кода выделит слово и скопирует его в буфер обмена.
178		-	~~- Нажмите <span class="kbd">Ctrl</span>+<span class="kbd">E</span> для начала последовательного поиска~~
179		-	~~- Нажмите <span class="kbd">Ctrl</span>+<span class="kbd">V</span> для поиска идентификатора (так же, как в 0.9.27)~~
180		-	- Используйте <span class="kbd">F3</span> и <span class="kbd">Shift</span>+<span class="kbd">F3</span> для быстрого перехода к следующему / предыдущему найденному участку текста.
	171	+	- Нажмите `Ctrl`+`C`. Редактор исходного кода выделит слово и скопирует его в буфер обмена.
	172	+	- Нажмите `Ctrl`+`E` для начала последовательного поиска
	173	+	- Нажмите `Ctrl`+`V` для поиска идентификатора (так же, как в 0.9.27)
	174	+	- Используйте `F3` и `Shift`+`F3` для быстрого перехода к следующему / предыдущему найденному участку текста.
181	175		- Используйте любую клавишу (например курсор влево или вправо), чтобы закончить поиск
182	176
183	177		## Синхронная правка
184	178
185	179		Синхронная правка позволяет редактировать все места присутствия слова в тексте одновременно (синхронно). Вы просто изменяете, слово в одном месте и все остальные вхождения слова в тексте изменяются автоматически.
186	180
187	181		Синхронная правка влияет на все слова в выделенной области текста. Пример использования:
188	182
189	183		- Выделите блок текста
190		-	- Нажмите <span class="kbd">Ctrl</span>+<span class="kbd">J</span> или воспользуйтесь соответствующим значком. (Это работает только, если есть какие-либо слова, которые встречаются более одного раза в выделенном тексте.)
191		-	- Используйте клавишу <span class="kbd">tab</span> для выделения слова, которое вы хотите изменить. (если было выделено несколько разных слов более одного раза)
	184	+	- Нажмите `Ctrl`+`J` или воспользуйтесь соответствующим значком. (Это работает только, если есть какие-либо слова, которые встречаются более одного раза в выделенном тексте.)
	185	+	- Используйте клавишу `tab` для выделения слова, которое вы хотите изменить. (если было выделено несколько разных слов более одного раза)
192	186		- Измените слово
193		-	~~- Нажмите <span class="kbd">Esc</span> для окончание работы с синхронной правкой~~
	187	+	- Нажмите `Esc` для окончание работы с синхронной правкой
194	188
195	189		См. анимированный пример [[New IDE features since\|здесь]]
196	190
197		-	> Note: <span class="kbd">Ctrl</span>+<span class="kbd">J</span> также используется для редактирования шаблона. \[Это сочетание клавиш\] переключает свое значение, если вы выберете какой-то текст.
	191	+	> Note: `Ctrl`+`J` также используется для редактирования шаблона. \[Это сочетание клавиш\] переключает свое значение, если вы выберете какой-то текст.
198	192
199	193		## Поиск следующего / предыдущего вхождения слова
200	194
201	195		Обе функции можно найти в контекстном меню редактора исходного кода
202	196
203	197		- Редактор кода / контекстное меню / Найти / Найти следующее вхождение слова
204	198		- Редактор кода / контекстное меню / Найти / Найти предыдущее вхождение слова
205	199
206	200		Вы можете назначить данным пунктам сочетания клавиш в окне настройки редактора исходного кода. Для этого выберите меню "Сервис-\>Параметры" и в левой части появившегося окна выберите "Редактор-\>Комбинации клавиш".
207	201
208	202		## Автозавершение Кода
209	203
210		-	Автозавершение кода можно найти в меню IDE Edit -\> Complete Code, а так же используя сочетания клавиш: <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>.
	204	+	Автозавершение кода можно найти в меню IDE Edit -\> Complete Code, а так же используя сочетания клавиш: `Ctrl`+`Shift`+`C`.
211	205
212		-	Для Делфистов: В Delphi, это называется "автозавершение кода"(code completion) - специальная функция, показывающая список идентификаторов, в текущей позиции исходного кода ((<span class="kbd">Ctrl</span>+<span class="kbd">Пробел</span>). В Lazarus это называется "автозавершение идентификаторов"(Identifier completion).
	206	+	Для Делфистов: В Delphi, это называется "автозавершение кода"(code completion) - специальная функция, показывающая список идентификаторов, в текущей позиции исходного кода ((`Ctrl`+`Пробел`). В Lazarus это называется "автозавершение идентификаторов"(Identifier completion).
213	207
214	208		Автозавершение кода сочетает в себе несколько мощных функций, например:
215	209
216	210		- [[Lazarus IDE Tools/ru\|Автозавершение класса]]: завершает объявление свойств, добавляет/обновляет тело метода, добавляет переменные и методы в раздел private класса.
217	211		- [[Lazarus IDE Tools/ru\|Автозавершение предварительно объявленной процедуры]]: добавляет тело процедуры.
218	212		- [[Lazarus IDE Tools/ru\|Автозавершение назначенных процедур обработки событий]]: завершает связи с событием, добавляя определения методов и их тел.
219	213		- [[Lazarus IDE Tools/ru\|Автозавершение объявления переменной]]: добавляет определённые локальные переменные.
220	214		- [[Lazarus IDE Tools/ru\|Автозавершение объявления вызываемой процедуры]]: добавляет новую процедуру.
221	215		- Reversed procedure completion: добавление объявления процедур/функций (Прим.перев. 08:28, 26 October 2018 (CEST): Раздел временно отсутствует)
222	216		- [[Lazarus IDE Tools/ru\|Автозавершение предшествующего объявления класса]]: добавление объявления метода для тела метода внутри класса.
223	217
224	218		Какая из этих функций будет использована, зависит от позиции курсора в редакторе кода.
225	219
226		-	Автозавершение кода можно найти в меню IDE Edit -\> Complete Code, \[а также вызвать\] стандартным сочетанием клавиш <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>.
	220	+	Автозавершение кода можно найти в меню IDE Edit -\> Complete Code, \[а также вызвать\] стандартным сочетанием клавиш `Ctrl`+`Shift`+`C`.
227	221
228	222		### Автозавершение класса
229	223
230	224		Наиболее мощная функция завершения кода является "Автозавершение класса". Вы пишете скелет класса, добавляя в него методы и свойства. Автозавершение кода автоматически завершит их объявления, добавив нужные переменные, тело для реализации метода или свойства, определит способ доступа к ним а так же поля класса.
231	225
232	226		Например: создайте класс (для быстроты можете использовать шаблоны кода):
233	227
234	228		``` pascal
235	229		TExample = class(TObject)
236	230		public
237	231		constructor Create;
238	232		destructor Destroy; override;
239	233		end;
240	234		```
241	235
242		-	Поместите курсор где-то внутри класса и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>. Это позволит создать скелет для реализации методов и поместит курсор внутри тела метода:
	236	+	Поместите курсор где-то внутри класса и нажмите `Ctrl`+`Shift`+`C`. Это позволит создать скелет для реализации методов и поместит курсор внутри тела метода:
243	237
244	238		``` pascal
245	239		{ TExample }
246	240
247	241		constructor TExample.Create;
248	242		begin
249	243		\|
250	244		end;
251	245
252	246		destructor TExample.Destroy;
253	247		begin
254	248		inherited Destroy;
255	249		end;
256	250		```
257	251
258	252		> Note: символом '\\|' обозначена позиция курсора в коде.
259	253
260		-	Подсказка: Вы можете переключаться между методом и его телом, используя клавиши <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span>.
	254	+	Подсказка: Вы можете переключаться между методом и его телом, используя клавиши `Ctrl`+`Shift`+`Up`.
261	255
262	256		Вы можете увидеть, что IDE добавило вызов 'inherited Destroy'. Это происходит, когда в объявлении метода используется ключевое слово 'override'.
263	257
264	258		Теперь добавьте метод DoSomething:
265	259
266	260		``` pascal
267	261		TExample = class(TObject)
268	262		public
269	263		constructor Create;
270	264		procedure DoSomething(i: integer);
271	265		destructor Destroy; override;
272	266		end;
273	267		```
274	268
275		-	~~Нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> и IDE завершит его, добавив:~~
	269	+	Нажмите `Ctrl`+`Shift`+`C` и IDE завершит его, добавив:
276	270
277	271		``` pascal
278	272		procedure TExample.DoSomething(i: integer);
279	273		begin
280	274		\|
281	275		end;
282	276		```
283	277
284	278		Вы можете определить поведение вставки кода в Environment \> Codetools Options -\> Code Creation.
285	279
286	280		Завершение свойств\
287	281		Добавьте свойство AnInteger:
288	282
289	283		``` pascal
290	284		TExample = class(TObject)
291	285		public
292	286		constructor Create;
293	287		procedure DoSomething(i: integer);
294	288		destructor Destroy; override;
295	289		property AnInteger: Integer;
296	290		end;
297	291		```
298	292
299	293		Нажмите Ctrl+Shift+C и вы получите:
300	294
301	295		``` pascal
302	296		procedure TExample.SetAnInteger(const AValue: integer);
303	297		begin
304	298		\|if FAnInteger=AValue then exit;
305	299		FAnInteger:=AValue;
306	300		end;
307	301		```
308	302
309		-	Функция автозавершения кода добавила поля класса и метод, используемые при обращении к свойству. Нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span> для просмотра определения класса:
	303	+	Функция автозавершения кода добавила поля класса и метод, используемые при обращении к свойству. Нажмите `Ctrl`+`Shift`+`Up` для просмотра определения класса:
310	304
311	305		``` pascal
312	306		TExample = class(TObject)
313	307		private
314	308		FAnInteger: integer;
315	309		procedure SetAnInteger(const AValue: integer);
316	310		public
317	311		constructor Create;
318	312		procedure DoSomething(i: integer);
319	313		destructor Destroy; override;
320	314		property AnInteger: integer read FAnInteger write SetAnInteger;
321	315		end;
322	316		```
323	317
324	318		Свойство было изменено. Добавлены ключевые слова Read и Write. Класс получил новый раздел 'private' с полем 'FAnInteger' и методом 'SetAnInteger'. Это общий стиль Delphi, использовать в названиях полей букву 'F' (Field). И в методах на запись слово 'Set'. Данные настройки можно изменить в Environment \> Codetools Options -\> Code Creation.
325	319
326	320		Создание свойства только для чтения:
327	321
328	322		``` pascal
329	323		property PropName: PropType read;
330	324		```
331	325
332	326		Будет расширено до:
333	327
334	328		``` pascal
335	329		property PropName: PropType read FPropName;
336	330		```
337	331
338	332		Создание свойства только для записи:
339	333
340	334		``` pascal
341	335		property PropName: PropType write;
342	336		```
343	337
344	338		Будет расширено до:
345	339
346	340		``` pascal
347	341		property PropName: PropType write SetPropName;
348	342		```
349	343
350	344		Создание свойства только для чтения с указанием метода:
351	345
352	346		``` pascal
353	347		property PropName: PropType read GetPropName;
354	348		```
355	349
356	350		Будет добавлена функция GetPropName:
357	351
358	352		``` pascal
359	353		function GetpropName: PropType;
360	354		```
361	355
362	356		Создание свойства с ключевым словом stored:
363	357
364	358		``` pascal
365	359		property PropName: PropType stored;
366	360		```
367	361
368	362		Будет расширено до:
369	363
370	364		``` pascal
371	365		property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
372	366		```
373	367
374	368		Так как ключевое слово `stored` используется для потокового чтения и записи, нужные поля и процедуры также будут добавлены автоматически.
375	369
376	370		Подсказка: Автозавершение идентификатора также распознает неполные свойства и \[взамен\] предлагает имена по умолчанию. Например:
377	371
378	372		``` pascal
379	373		property PropName: PropType read \|;
380	374		```
381	375
382		-	Поместите курсор сразу за ключевым словом read и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Space</span> для автозавершения идентификатора. Он предоставит вам переменную FPropName и процедуру SetPropName.
	376	+	Поместите курсор сразу за ключевым словом read и нажмите `Ctrl`+`Space` для автозавершения идентификатора. Он предоставит вам переменную FPropName и процедуру SetPropName.
383	377
384	378		### Автозавершение предварительно объявленной процедуры
385	379
386	380		"Автозавершение предварительно объявленной процедуры" является частью автозавершения кода и добавляет отсутствующее тело процедуры. Оно вызывается, когда курсор находится в объявлении заданной процедуры.
387	381
388	382		Например: Добавьте новую процедуру в раздел интерфейса:
389	383
390	384		``` pascal
391	385		procedure DoSomething;
392	386		```
393	387
394		-	Поместите в нее курсор и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> для автозавершения кода. Он будет создан в разделе реализации:
	388	+	Поместите в нее курсор и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Он будет создан в разделе реализации:
395	389
396	390		``` pascal
397	391		procedure DoSomething;
398	392		begin
399	393		\|
400	394		end;
401	395		```
402	396
403		-	Подсказка: вы можете быстро перемещаться между объявлением процедуры и ее телом с помощью <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span>.
	397	+	Подсказка: вы можете быстро перемещаться между объявлением процедуры и ее телом с помощью `Ctrl`+`Shift`+`Up`.
404	398
405	399		Новое тело процедуры будет добавлено перед методами класса. Если в интерфейсе уже есть некоторые процедуры, IDE попытается сохранить \[их\] порядок. Например:
406	400
407	401		``` pascal
408	402		procedure Proc1;
409	403		procedure Proc2; // новая процедура
410	404		procedure Proc3;
411	405		```
412	406
413	407		Если тела Proc1 и Proc3 уже существуют, то тело Proc2 будет вставлено между телами Proc1 и Proc3. Такое поведение можно настроить в Environment \> Codetools Options -\> Code Creation.
414	408
415	409		Несколько процедур:
416	410
417	411		``` pascal
418	412		procedure Proc1_Old; // тело [процедуры уже] существует
419	413		procedure Proc2_New; // тело [процедуры еще] не существует
420	414		procedure Proc3_New; // "
421	415		procedure Proc4_New; // "
422	416		procedure Proc5_Old; // тело [процедуры уже] существует
423	417		```
424	418
425	419		Автозавершение кода добавит тела всех 3 процедур(Proc2_New, Proc3_New, Proc4_New).
426	420
427	421		Почему это называется "Автозавершение предварительно объявленной процедуры"?
428	422
429	423		Потому что это работает не только для процедур, определенных в интерфейсе, но и для процедур\[, определенных\] с помощью "предварительно объявленного" модификатора. И потому что утилиты кода обрабатывают процедуры в интерфейсе как имеющие неявный "предварительно объявленный" модификатор.
430	424
431	425		### Автозавершение назначенных процедур обработки событий
432	426
433	427		"Автозавершение назначенных процедур обработки событий" является частью автозавершения кода и завершает единственный оператор Event:=\\|. Он вызывается, когда курсор находится за назначенным событием.
434	428
435	429		Например: В методе, скажем, событие FormCreate, добавьте строку 'OnPaint:=':
436	430
437	431		``` pascal
438	432		procedure TForm1.Form1Create(Sender: TObject);
439	433		begin
440	434		OnPaint:=\|
441	435		end;
442	436		```
443	437
444		-	'\\|' - это курсор, и его не следует вводить. Затем нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> для завершения кода. Оператор будет завершен
	438	+	'\\|' - это курсор, и его не следует вводить. Затем нажмите `Ctrl`+`Shift`+`C` для завершения кода. Оператор будет завершен
445	439
446	440		``` pascal
447	441		OnPaint:=@Form1Paint;
448	442		```
449	443
450	444		Новый метод Form1Paint будет добавлен в класс TForm1. Затем запустится автозавершение класса, и вы получите:
451	445
452	446		``` pascal
453	447		procedure TForm1.Form1Paint(Sender: TObject);
454	448		begin
455	449		\|
456	450		end;
457	451		```
458	452
459	453		Это работает так же, как добавление методов в инспекторе объектов.
460	454
461	455		> Note: Вы должны поместить курсор сразу после оператора присваивания ':='. Если вы поместите курсор на идентификатор (например, OnPaint), то автозавершение кода вызовет «Автозавершение локальной переменной», что не удастся, поскольку OnPaint уже определен.
462	456
463	457		Подсказка:\
464	458		*Вы можете выбрать видимость по умолчанию для нового метода в разделе Tools / Options / Codetools / Class Completion / Default (начиная с версии 1.8)
465	459
466	460		- Вы можете определить имя нового метода самостоятельно. Например:
467	461
468	462		``` pascal
469	463		OnPaint:=@ThePaintMethod;
470	464		```
471	465
472	466		Начиная с 0.9.31 Lazarus автозавершает параметры процедуры. Например
473	467
474	468		``` pascal
475	469		procedure TForm1.FormCreate(Sender: TObject);
476	470		var
477	471		List: TList;
478	472		begin
479	473		List:=TList.Create;
480	474		List.Sort(@MySortFunction\|);
481	475		end;
482	476		```
483	477
484		-	Поместите курсор на 'MySortFunction' и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> для автозавершения кода. Вы получите новую процедуру:
	478	+	Поместите курсор на 'MySortFunction' и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Вы получите новую процедуру:
485	479
486	480		``` pascal
487	481		function MySortFunction(Item1, Item2: Pointer): Integer;
488	482		begin
489	483		\|
490	484		end;
491	485
492	486		procedure TForm1.FormCreate(Sender: TObject);
493	487		var
494	488		List: TList;
495	489		begin
496	490		List:=TList.Create;
497	491		List.Sort(@MySortFunction);
498	492		end;
499	493		```
500	494
501	495		### Автозавершение объявления переменной
502	496
503	497		"Автозавершение объявления переменной" является частью завершения кода и добавляет определение локальной переменной для \[оператора\] `Identifier:=Term` \[(Идентификатор:=Выражение)\]. Он вызывается, когда курсор находится на идентификаторе присвоения или параметра.
504	498
505	499		Например:
506	500
507	501		``` pascal
508	502		procedure TForm1.Form1Create(Sender: TObject);
509	503		begin
510	504		i:=3;
511	505		end;
512	506		```
513	507
514		-	Поместите курсор на '`i`' или сразу за ним. Затем нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> для автозавершения кода, и вы получите:
	508	+	Поместите курсор на '`i`' или сразу за ним. Затем нажмите `Ctrl`+`Shift`+`C` для автозавершения кода, и вы получите:
515	509
516	510		``` pascal
517	511		procedure TForm1.Form1Create(Sender: TObject);
518	512		var
519	513		i: Integer;
520	514		begin
521	515		i:=3;
522	516		end;
523	517		```
524	518
525	519		Утилиты кода сначала проверяют код \[на наличие объявления\] идентификатора '`i`', и если \[таковой не найден\], то добавляют объявление '`var i: integer;`'. Тип идентификатора угадывается из выражения\[, расположенного\] справа от оператора присвоения '`:=`'. Числа, такие как 3, по умолчанию \[будут иметь тип\] Integer.
526	520
527	521		Другой пример:
528	522
529	523		``` pascal
530	524		type
531	525		TWhere = (Behind, Middle, InFront);
532	526
533	527		procedure TForm1.Form1Create(Sender: TObject);
534	528		var
535	529		a: array[TWhere] of char;
536	530		begin
537	531		for Where:=Low(a) to High(a) do writeln(a[Where]);
538	532		end;
539	533		```
540	534
541		-	Поместите курсор на 'Where' и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> для автозавершения кода. Вы получите:
	535	+	Поместите курсор на 'Where' и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Вы получите:
542	536
543	537		``` pascal
544	538		procedure TForm1.Form1Create(Sender: TObject);
545	539		var
546	540		a: array[TWhere] of char;
547	541		Where: TWhere;
548	542		begin
549	543		for Where:=Low(a) to High(a) do writeln(a[Where]);
550	544		end;
551	545		```
552	546
553	547		Начиная с 0.9.11 Lazarus также автозавершает параметры. Например
554	548
555	549		``` pascal
556	550		procedure TForm1.FormPaint(Sender: TObject);
557	551		begin
558	552		with Canvas do begin
559	553		Line(x1,y1,x2,y2);
560	554		end;
561	555		end;
562	556		```
563	557
564		-	Поместите курсор на 'x1' и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> для автозавершения кода. Вы получите:
	558	+	Поместите курсор на 'x1' и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Вы получите:
565	559
566	560		``` pascal
567	561		procedure TForm1.FormPaint(Sender: TObject);
568	562		var
569	563		x1: integer;
570	564		begin
571	565		with Canvas do begin
572	566		Line(x1,y1,x2,y2);
573	567		end;
574	568		end;
575	569		```
576	570
577	571		Начиная с 0.9.31 Lazarus автозавершает параметры указателя. Например
578	572
579	573		``` pascal
580	574		procedure TForm1.FormCreate(Sender: TObject);
581	575		begin
582	576		CreateIconIndirect(@IconInfo);
583	577		end;
584	578		```
585	579
586		-	Поместите курсор в 'IconInfo' и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> для автозавершения кода. Вы получите:
	580	+	Поместите курсор в 'IconInfo' и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Вы получите:
587	581
588	582		``` pascal
589	583		procedure TForm1.FormCreate(Sender: TObject);
590	584		var
591	585		IconInfo: TIconInfo;
592	586		begin
593	587		CreateIconIndirect(@IconInfo);
594	588		end;
595	589		```
596	590
597		-	Во всех приведенных выше примерах вы можете использовать <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">X</span>, чтобы отобразить диалоговое окно создания кода, в котором вы можете установить дополнительные параметры.
	591	+	Во всех приведенных выше примерах вы можете использовать `Ctrl`+`Shift`+`X`, чтобы отобразить диалоговое окно создания кода, в котором вы можете установить дополнительные параметры.
598	592
599	593		### Автозавершение объявления вызываемой процедуры
600	594
601	595		\[Механизм\] автозавершение кода может создать \[тело\] новой процедуры из места ее объявления.
602	596
603	597		Допустим, вы просто написали объявление "`DoSomething(Width);`"
604	598
605	599		``` pascal
606	600		procedure SomeProcedure;
607	601		var
608	602		Width: integer;
609	603		begin
610	604		Width:=3;
611	605		DoSomething(Width);
612	606		end;
613	607		```
614	608
615		-	Поместите курсор над идентификатором "DoSomething" и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>, чтобы получить:
	609	+	Поместите курсор над идентификатором "DoSomething" и нажмите `Ctrl`+`Shift`+`C`, чтобы получить:
616	610
617	611		``` pascal
618	612		procedure DoSomething(aWidth: LongInt);
619	613		begin
620	614
621	615		end;
622	616
623	617		procedure SomeProcedure;
624	618		var
625	619		Width: integer;
626	620		begin
627	621		Width:=3;
628	622		DoSomething(Width);
629	623		end;
630	624		```
631	625
632	626		Это еще не создает функции или методы.
633	627
634	628		### Автозавершение предшествующего объявления класса
635	629
636	630		"Автозавершение предшествующего объявления класса" является частью Code Completion \[(Автозавершения кода), который\] добавляет объявление для текущего тела метода в private \[разделе интерфейсной части модуля\]. Он вызывается, когда курсор находится в теле метода, еще не определенном в классе. Эта функция доступна с Lazarus 0.9.21.
637	631
638	632		Например:
639	633
640	634		``` pascal
641	635		procedure TForm1.DoSomething(Sender: TObject);
642	636		begin
643	637		end;
644	638		```
645	639
646		-	Метод DoSomething еще не объявлен в TForm1. Нажмите <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>, и в IDE будет добавлена "`procedure DoSomething(Sender: TObject);`" в private-разделе TForm1.
	640	+	Метод DoSomething еще не объявлен в TForm1. Нажмите `Ctrl`+`Shift`+`C`, и в IDE будет добавлена "`procedure DoSomething(Sender: TObject);`" в private-разделе TForm1.
647	641
648	642		Для дельфийцев: Автозавершение класса работает в Lazarus всегда одним способом: от класса интерфейсного \[раздела модуля\] к \[разделу\] реализации или наоборот, от класса в \[разделе\] реализации к \[разделу\] интерфейса. Delphi всегда вызывает оба направления. Недостаток способа Delphi заключается в том, что при опечатке легко создать новый метод, не заметив \[этого\].
649	643
650	644		------------------------------------------------------------------------
651	645
652		-	Прим.перев. 09:08, 30 October 2018 (CET): Очевидно имеется ввиду следующее: в Lazarus'е достаточно чуть изменить название метода (справедливо и для параметров) в интерфейсной части модуля и нажать <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>, и механизм Code Completion автоматически внесет правки в название уже имеющегося тела метода в разделе implementation. То же справедливо и для случая, когда меняется название метода (справедливо и для параметров) в разделе implementation, а затем вызывается Code Completion - в разделе interface будут внесены соответствующие правки.
	646	+	Прим.перев. 09:08, 30 October 2018 (CET): Очевидно имеется ввиду следующее: в Lazarus'е достаточно чуть изменить название метода (справедливо и для параметров) в интерфейсной части модуля и нажать `Ctrl`+`Shift`+`C`, и механизм Code Completion автоматически внесет правки в название уже имеющегося тела метода в разделе implementation. То же справедливо и для случая, когда меняется название метода (справедливо и для параметров) в разделе implementation, а затем вызывается Code Completion - в разделе interface будут внесены соответствующие правки.
653	647
654	648		В Delphi, если тело метода уже существует, то изменение имени метода в разделе interface приведет к созданию тела метода в разделе implementation с измененным именем в дополнению к уже имеющемуся со старым именем. Это, естественно, вызовет ошибку при компиляции проекта.
655	649
656	650		------------------------------------------------------------------------
657	651
658	652		### Комментарии и автозавершение кода
659	653
660	654		Автозавершение кода пытается сохранять комментарии, принадлежащие \[завершаемому коду\]. Например:
661	655
662	656		``` pascal
663	657		FList: TList; // список TComponent
664	658		FInt: integer;
665	659		```
666	660
667	661		При вставке новой переменной между FList и FInd комментарий сохраняется в строке FList. То же самое верно для
668	662
669	663		``` pascal
670	664		FList: TList; { список TComponent
671	665		Это комментарий по нескольким строкам, начиная
672	666		со строки FList, поэтому codetools предполагает, что он принадлежит
673	667		к линии FLIst и не будет [терять с ним]
674	668		связь. Код добавляется за комментарием.}
675	669		FInt: integer;
676	670		```
677	671
678	672		Если комментарий начинается со следующей строки, он будет обрабатываться так, как если бы он принадлежал коду ниже. Например:
679	673
680	674		``` pascal
681	675		FList: TList; // список TComponent
682	676		{ Этот комментарий относится к приведенному ниже операнду.
683	677		Новый код вставлен над этим комментарием и
684	678		позади комментария [для] FList.}
685	679		FInt: integer;
686	680		```
687	681
688	682		### Обновление метода
689	683
690	684		Обычно автозавершение класса добавляет все отсутствующие тела методов. (Начиная с 0.9.27). Но если именно один метод отличается между \[объявлением в\] классе и теле, то тело метода обновляется. Например: у вас есть метод DoSomething.
691	685
692	686		``` pascal
693	687		public
694	688		procedure DoSomething;
695	689		end;
696	690
697	691		procedure TForm.DoSomething;
698	692		begin
699	693		end;
700	694		```
701	695
702	696		Теперь добавляем параметр:
703	697
704	698		``` pascal
705	699		public
706	700		procedure DoSomething(i: integer);
707	701		end;
708	702		```
709	703
710		-	и вызываем автозавершение кода (<span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>). Тело метода будет обновлено, а новый параметр будет скопирован:
	704	+	и вызываем автозавершение кода (`Ctrl`+`Shift`+`C`). Тело метода будет обновлено, а новый параметр будет скопирован:
711	705
712	706		``` pascal
713	707		procedure TForm.DoSomething(i: integer);
714	708		begin
715	709		end;
716	710		```
717	711
718	712		## Рефакторинг \[реорганизация кода\]
719	713
720	714		### Инверсия присвоения
721	715
722	716		Аннотация
723	717
724	718		"Invert Assignments" \[("Инверсия присвоения")\] берет некоторые выбранные инструкции pascal и инвертирует все операнды из этого кода. Этот инструмент полезен для преобразования кода "save" в "load" и обратную операцию.
725	719
726	720		Например:\
727	721
728	722		``` pascal
729	723		procedure DoSomething;
730	724		begin
731	725		AValueStudio:= BValueStudio;
732	726		AValueAppartment :=BValueAppartment;
733	727		AValueHouse:=BValueHouse;
734	728		end;
735	729		```
736	730
737	731		Выделите строки с назначением (между началом и концом) и сделайте инвертирование назначений. Все назначения будут инвертированы, а идентификация будет добавлена автоматически. Например:
738	732
739	733		Результат:
740	734
741	735		``` pascal
742	736		procedure DoSomething;
743	737		begin
744	738		BValueStudio := AValueStudio;
745	739		BValueAppartment := AValueAppartment;
746	740		BValueHouse := AValueHouse;
747	741		end;
748	742		```
749	743
750	744		------------------------------------------------------------------------
751	745
752	746		Прим.перев. 14:37, 1 November 2018 (CET): По умолчанию шоткаты для данной операции отсутствуют. Их легко определить самим, вызвав меню Tools --\> Options --\> Editor --\> Key Mappings --\> CodeTools Command --\> Invert Assignment
753	747
754	748		------------------------------------------------------------------------
755	749
756	750		### Заключить выделение \[в какую-либо конструкцию\]
757	751
758		-	Выберите текст и вызовите \[эту команду (ПКМ --\> Enclose Selection) или <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">N</span>\]. Появится диалоговое окно, в котором вы можете выбрать, следует ли включить выделение в try..finally или многие другие общие блоки.
	752	+	Выберите текст и вызовите \[эту команду (ПКМ --\> Enclose Selection) или `Ctrl`+`Shift`+`N`\]. Появится диалоговое окно, в котором вы можете выбрать, следует ли включить выделение в try..finally или многие другие общие блоки.
759	753
760	754		### Переименование идентификатора
761	755
762		-	Поместите курсор на идентификатор и вызовите \[эту команду (ПКМ --\> Rename Identifier) или <span class="kbd">F2</span>\]. Появится диалоговое окно, в котором вы можете настроить область поиска и новое имя.
	756	+	Поместите курсор на идентификатор и вызовите \[эту команду (ПКМ --\> Rename Identifier) или `F2`\]. Появится диалоговое окно, в котором вы можете настроить область поиска и новое имя.
763	757
764	758		- Это переименует все вхождения и только те, которые фактически используют это объявление. Это означает, что он не переименовывает объявления с тем же именем.
765	759		- И это сначала проверит конфликты имен.
766	760		- Ограничения: Это работает только с исходниками pascal, но не переименовывает файлы, не поддерживает ни файлы lfm/lrs, ни файлы lazdoc.
767	761
768	762		### Поиски ссылок на идентификатор
769	763
770		-	Поместите курсор на идентификатор и вызовите \[эту процедуру (ПКМ --\> Find --\> Find Identifier References) или <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">I</span>\]. Появится диалоговое окно, в котором вы можете настроить область поиска. Затем IDE будет искать все вхождения и только те, которые фактически используют это объявление. Это означает, что эта \[процедура\] не отображает другие объявления с таким же именем.
	764	+	Поместите курсор на идентификатор и вызовите \[эту процедуру (ПКМ --\> Find --\> Find Identifier References) или `Ctrl`+`Shift`+`I`\]. Появится диалоговое окно, в котором вы можете настроить область поиска. Затем IDE будет искать все вхождения и только те, которые фактически используют это объявление. Это означает, что эта \[процедура\] не отображает другие объявления с таким же именем.
771	765
772	766		### Показ абстрактных методов
773	767
774	768		Эта функция перечисляет и автоматически завершает виртуальные, абстрактные методы, которые необходимо реализовать. Поместите курсор на объявление класса и вызовите \[эту функцию (ПКМ --\> Refactoring --\> Abstract Methods)\]. Если отсутствуют абстрактные методы, появится диалоговое окно с их перечислением. Выберите методы для реализации, и среда IDE создаст заглушки метода. Начиная с \[версии\] 1.3 Lazarus также добавляет недостающие методы интерфейса класса.
775	769
776	770		### Извлечение процедуры
777	771
778	772		См. [[IDE Window: Extract Procedure/ru\|Extract Procedure]].
779	773
780	774		## Поиск объявлений
781	775
782	776		Поместите курсор на идентификатор и выполните 'Find Declaration' \[("Найти объявление")\]. Тогда это запустит поиск объявления этого идентификатора, откроет файл и перейдет к нему. Если курсор уже находится в объявлении, он перейдет к предыдущему объявлению с тем же именем. Это позволяет находить переназначения и переопределения.
783	777
784	778		Каждое найденное объявление устанавливает точку перехода. Это означает, что вы прыгнете с найденного объявления \[к следующему найденному\] объявлению и легко вернетесь \[назад\] с помощью Search -\> Jump back.
785	779
786	780		Существуют некоторые отличия от Delphi: утилиты кода работают с исходниками, следующим правилам обычного паскаля, вместо использования выходных \[файлов\] компилятора. Компилятор возвращает конечный тип. Утилиты кода видят исходники и все шаги между ними. Например:
787	781
788	782		Свойство Visible сначала определяется в TControl (controls.pp), затем переопределяется в TCustomForm и, наконец, переопределяется в TForm. Вызов поиска объявления для \[свойства\] Visible сначала приведет вас к Visible в TForm. Затем вы снова можете вызвать Find Declaration \[("Поиск объявления")\], чтобы перейти к \[свойству\] Visible в TCustomForm, и снова, \[чтобы\] перейти к \[свойству\] Visible в TControl.
789	783
790	784		То же самое верно и для таких типов, как TColor. Для компилятора это просто \[тип\] 'longint'. Но в исходниках он определяется как
791	785
792	786		``` pascal
793	787		TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
794	788		TColor = TGraphicsColor;
795	789		```
796	790
797	791		И то же самое \[справедливо\] для forward defined classes \[("предшествующего определения классов")\]: например, в TControl, есть private-переменная
798	792
799	793		``` pascal
800	794		FHostDockSite: TWinControl;
801	795		```
802	796
803	797		Поиск объявления в TWinControl перескочит в предшествующее определение
804	798
805	799		``` pascal
806	800		TWinControl = class;
807	801		```
808	802
809	803		А вызов его снова переведет к реальной реализации
810	804
811	805		``` pascal
812	806		TWinControl = class(TControl)
813	807		```
814	808
815	809		Таким образом вы можете отслеживать каждый идентификатор и находить каждую \[его\] перегрузку.
816	810
817	811		### Подсказки
818	812
819		-	~~- перейти назад <span class="kbd">Ctrl</span>+<span class="kbd">H</span>.~~
	813	+	- перейти назад `Ctrl`+`H`.
820	814		- местоположениям через меню: View -\> "jump history"
821	815		- для 5-кнопочной мыши добавьте две дополнительные кнопки для перемещения вперед/назад между посещенными точками
822	816
823	817
824	818		используя [[IDE Window: EditorMouseOptionsAdvanced\|advanced mouse options]], кнопки можно переназначить.
825	819
826	820		## Автозавершение идентификатора
827	821
828		-	"Identifier Completion" \[("автозавершение идентификатора")\] вызывается \[комбинацией клавиш\] <span class="kbd">Ctrl</span>+<span class="kbd">space</span>. Это отображает все идентификаторы в области видимости. Например:
	822	+	"Identifier Completion" \[("автозавершение идентификатора")\] вызывается \[комбинацией клавиш\] `Ctrl`+`space`. Это отображает все идентификаторы в области видимости. Например:
829	823
830	824		``` pascal
831	825		procedure TForm1.FormCreate(Sender: TObject);
832	826		begin
833	827		\|
834	828		end;
835	829		```
836	830
837		-	Поместите курсор между begin и end и нажмите <span class="kbd">Ctrl</span>+<span class="kbd">space</span>. IDE/Утилиты кода теперь будут анализировать весь доступный код и представлять список всех найденных идентификаторов. Утилиты кода кэшируют результаты, поэтому повторное использование этого кода будет намного быстрее.
	831	+	Поместите курсор между begin и end и нажмите `Ctrl`+`space`. IDE/Утилиты кода теперь будут анализировать весь доступный код и представлять список всех найденных идентификаторов. Утилиты кода кэшируют результаты, поэтому повторное использование этого кода будет намного быстрее.
838	832
839	833		> Note: для Дельфийцев: в Дельфи это называется Автозавершение кода.
840	834
841	835		Некоторые идентификаторы, такие как 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' встроены в компилятор и не определены нигде в исходниках. В автозавершении идентификатора также есть много таких вещей. Если вы обнаружите, что хоть один отсутствует, просто создайте запрос функции в багтрекере.
842	836
843		-	Автозавершение идентификатора не автозавершает все ключевые слова. Поэтому вы не можете использовать его для автозавершения \[ключевого слова\] 'repe' до 'repeat'. Для этого используйте <span class="kbd">Ctrl</span>+<span class="kbd">W</span> [[Lazarus IDE Tools/ru\|Автозавершение слова]] или <span class="kbd">Ctrl</span>+<span class="kbd">J</span> [[Lazarus IDE Tools/ru\|Шаблоны кода]]. Начиная с версии 0.9.27 автозавершение идентификатора автозавершает некоторые ключевые слова.
	837	+	Автозавершение идентификатора не автозавершает все ключевые слова. Поэтому вы не можете использовать его для автозавершения \[ключевого слова\] 'repe' до 'repeat'. Для этого используйте `Ctrl`+`W` [[Lazarus IDE Tools/ru\|Автозавершение слова]] или `Ctrl`+`J` [[Lazarus IDE Tools/ru\|Шаблоны кода]]. Начиная с версии 0.9.27 автозавершение идентификатора автозавершает некоторые ключевые слова.
844	838
845	839		Автозавершение идентификатора показывает даже те идентификаторы, которые несовместимы.
846	840
847	841		### Сопоставление только первой части слова
848	842
849	843		Вы можете вызвать автозавершение идентификатора только по первым нескольким символам в слове. Поместите курсор внутри слова. Для поиска идентификаторов будут использоваться только символы слева от курсора. Например:
850	844
851	845		``` pascal
852	846		procedure TForm1.FormCreate(Sender: TObject);
853	847		begin
854	848		Ca\|ption
855	849		end;
856	850		```
857	851
858	852		Во \[всплывающем\] поле будут показаны только идентификаторы, начинающиеся с 'Ca' (\\| указывает позицию курсора).
859	853
860	854		### Клавиши
861	855
862	856		- Буква или цифра: добавьте символ в редактор исходного кода и текущий префикс. Это обновит список.
863	857		- Backspace: удалит последний символ из исходного редактора и префикса. Обновляет список.
864	858		- Return: заменяет целое слово под курсором на выбранный идентификатор и закрывает всплывающее окно.
865	859		- Shift+Return: как Return, но заменяет только префикс (левая часть) слова под курсором.
866	860		- Up/Down: перемещает выделение
867	861		- Escape: закрывает всплывающее окно без изменений
868	862		- Tab: завершает префикс для следующего выбора. Например: текущий префикс 'But', а завершение идентификатора показывает только 'Button1' и 'Button1Click'. Тогда нажатие Tab завершит префикс 'Button1'.
869	863		- Else: как Return и добавляет символ в редактор исходного кода
870	864
871	865		### Методы
872	866
873	867		Когда курсор находится в определении класса, и ваш идентификатор завершает метод, определенный в классе предков, параметры и ключевое слово переопределения будут добавляться автоматически. Например:
874	868
875	869		``` pascal
876	870		TMainForm = class(TForm)
877	871		protected
878	872		mous\|
879	873		end;
880	874		```
881	875
882	876		Завершение MouseDown дает:
883	877
884	878		``` pascal
885	879		TMainForm = class(TForm)
886	880		protected
887	881		procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
888	882		Y: Integer); override;
889	883		end;
890	884		```
891	885
892	886		### Свойства
893	887
894	888		``` pascal
895	889		property MyInt: integer read \|;
896	890		```
897	891
898	892		Автозавершение идентификатора покажет FMyInt и GetMyInt.
899	893
900	894		``` pascal
901	895		property MyInt: integer write \|;
902	896		```
903	897
904	898		Автозавершение идентификатора покажет FMyInt и SetMyInt.
905	899
906	900		### Секции Uses / Имена модулей
907	901
908	902		В разделах uses автозавершение идентификатора будет отображать имена файлов всех модулей в пути поиска. Они все будут отображаться строчными буквами (например, avl_tree), потому что большинство модулей имеют имена файлов в нижнем регистре. По автозавершении они вставляются в том регистре, \[в каком модуль назван\] (например, AVL_Tree).
909	903
910	904		### Операторы
911	905
912	906		``` pascal
913	907		procedure TMainForm.Button1Click(Sender: TObject);
914	908		begin
915	909		ModalRe\|;
916	910		end;
917	911		```
918	912
919	913		будет выглядеть так:
920	914
921	915		``` pascal
922	916		procedure TMainForm.Button1Click(Sender: TObject);
923	917		begin
924	918		ModalResult:=\|;
925	919		end;
926	920		```
927	921
928	922		### Иконки в окне автозавершения
929	923
930	924		В Lazarus 1.9+ существует опция для отображения значков вместо "типов", для строк в окне автозавершения. На рисунке показаны эти значки:
931	925
932		-	~~<figure>~~
933	926		<img src="ide_completion_icons.png" title="ide_completion_icons.png" width="250" />
934		-	~~<figcaption>ide_completion_icons.png</figcaption>~~
935		-	~~</figure>~~
936	927
937	928		------------------------------------------------------------------------
938	929
939	930		Прим.перев. 21:20, 6 November 2018 (CET): По умолчанию показ иконок отключен. Чтобы включить их, необходимо в меню Tools --\> Options --\> Codetools --\> Identifier Completion (Сервис --\> Параметры --\> Code tools --\> Завершение идентификаторов) в разделе Appearance (Внешний вид) отметить галочкой чекбокс "Icons in code completion box" ("Значки в окне автозавершения кода").
940	931
941		-	~~<figure>~~
942	932		<img src="icon_in_code_completion.png" title="icon_in_code_completion.png" width="500" />
943		-	~~<figcaption>icon_in_code_completion.png</figcaption>~~
944		-	~~</figure>~~
945	933
946	934		------------------------------------------------------------------------
947	935
948	936		## Автозавершение слова
949	937
950		-	Word Completion \[(автозавершение слова)\] вызывается \[сочетанием клавиш\] <span class="kbd">Ctrl</span>+<span class="kbd">W</span>. Оно отображает все слова всех открытых в настоящее время редакторов и поэтому может использоваться в не паскалевских исходниках, в комментариях и ключевых словах.
	938	+	Word Completion \[(автозавершение слова)\] вызывается \[сочетанием клавиш\] `Ctrl`+`W`. Оно отображает все слова всех открытых в настоящее время редакторов и поэтому может использоваться в не паскалевских исходниках, в комментариях и ключевых словах.
951	939
952	940		В противном случае это работает так же, как и автозавершение идентификатора.
953	941
954	942		## Словарь Модулей / Идентификатор (Cody)
955	943
956	944		Это диалоговое окно позволяет вам искать идентификаторы в других модулях. Модули не должны использоваться вашим кодом.
957	945
958	946		Эта функция является частью пакета "Cody". Чтобы активировать функцию, установите пакет.
959	947
960	948		## Переход в директиву Include
961	949
962	950		"Goto Include Directive" \[(переход в директиву Include)\] в меню поиска IDE переходит к выражению {\$I filename}, в котором используется текущий файл include.
963	951
964	952		## Публикация проекта
965	953
966	954		Создает копию всего проекта. Если вы хотите отправить кому-то только исходники и параметры компилятора вашего кода, эта функция является вашим другом.
967	955
968	956		Обычный каталог проекта содержит много информации. Большинство из них не нужно публиковать: файл .lpi может содержать информацию о сеансе (например, позицию каретки и закладки закрытых блоков), а каталог проекта содержит много файлов .ppu, .o и исполняемый файл. Чтобы создать файл lpi только с базовой информацией, \[а также создать\] только исходники со всеми подкаталогами, используйте \[опцию\] "Publish Project" \[(опубликовать проект)\].
969	957
970	958		> Note: Начиная с версии 0.9.13, есть новая \[опция в \] Project Option, которая позволяет хранить информацию о сеансе в \[другом\] файле отдельно от обычного файла .lpi. Этот новый файл заканчивается расширением .lps и содержит только информацию о сеансе, что значительно упрощает ваш файл .lpi.
971	959
972	960		В диалоговом окне вы можете настроить фильтр для включения и исключения определенных файлов; с \[возможным выполнением\] команды после того, как вы архивируете выходные файлы.
973	961
974	962		## Советы по комментариям
975	963
976	964		В нескольких местах IDE показывает подсказки для идентификатора. Например, при перемещении мыши по идентификатору в редакторе исходного кода и ожидании нескольких секунд. Когда IDE показывает подсказку для идентификатора, она ищет объявление его и всех его предков, \[а также\] ищет комментарии и файлы fpdoc. Существует много стилей кодирования и много стилей комментариев. Чтобы поддерживать многие общие стили комментариев, среда IDE использует следующий \[механизм\] эвристики:
977	965
978	966		### Комментарии, показанные в подсказке
979	967
980	968		Комментарии перед объявлением без пустой строки и не начинающиеся со знака \<:
981	969
982	970		``` pascal
983	971		var
984	972		{Комментарий}
985	973		Identifier: integer;
986	974		```
987	975
988	976		Комментарии с знаком \< принадлежит к предыдущему идентификатору.
989	977
990	978		Комментарии за идентификатором в одной строке:
991	979
992	980		``` pascal
993	981		var
994	982		identifier, // Комментарий
995	983		other,
996	984		```
997	985
998	986		Комментарии позади определения в той же строке:
999	987
1000	988		``` pascal
1001	989		var
1002	990		identifier:
1003	991		char; // Комментарий
1004	992		```
1005	993
1006	994		Пример для знака \<:
1007	995
1008	996		``` pascal
1009	997		const
1010	998		a = 1;
1011	999		//< комментарий для a
1012	1000		b = 2;
1013	1001		// комментарий для c
1014	1002		c = 3;
1015	1003		```
1016	1004
1017	1005		Поддерживаются все три типа комментариев:
1018	1006
1019	1007		``` pascal
1020	1008		{Комментарий}(Комментарий)//Комментарий
1021	1009		c = 1;
1022	1010		```
1023	1011
1024	1012		### Комментарии, не показываемые в подсказке
1025	1013
1026	1014		Комментарии, начинающиеся с \$ или %, игнорируются. Например, //% Hiddden, //\$ Hidden, (\$ Hidden).
1027	1015
1028	1016		Комментарии спереди, разделенные пустой строкой, рассматриваются как не относящиеся к следующему идентификатору. Например, следующий комментарий заголовка класса не отображается в подсказке:
1029	1017
1030	1018		``` pascal
1031	1019		type
1032	1020		{ TMyClass }
1033	1021
1034	1022		TMyClass = class
1035	1023		```
1036	1024
1037	1025		Комментарии заголовка класса создаются при завершении класса. Вы можете отключить эту \[опцию\] в Options / Codetools / Class completion / Header comment for class (Параметры / Code tools / Завершение классов / Комментарий перед заголовком класса). Если вы хотите показать комментарий заголовка в подсказке, просто удалите пустую строку.
1038	1026
1039	1027		Следующий комментарий будет показан для GL_TRUE, но не для GL_FALSE:
1040	1028
1041	1029		``` pascal
1042	1030		// Boolean
1043	1031		GL_TRUE = 1;
1044	1032		GL_FALSE = 0;
1045	1033		```
1046	1034
1047	1035		## Быстрые исправления
1048	1036
1049	1037		Быстрые исправления - это пункты меню для конкретных сообщений компилятора. Они помогают быстро решить проблему. Выберите сообщение в окне «Сообщения» и щелкните правой кнопкой мыши или щелкните правой кнопкой мыши в редакторе исходного кода на значке слева.
1050	1038
1051	1039		- Unit not found \[модуль не найден\]: удалите из раздела uses
1052	1040		- Unit not found \[модуль не найден\]: найдите модуль в загруженных пакетах и разрешите автоматическое добавление зависимости пакета
1053	1041		- Constructing a class "\$1" with abstract method "\$2" \[Создание класса "\$1" с абстрактным методом "\$2"\]: показ диалогового окна для переопределения всех абстрактных методов
1054	1042		- Local variable "\$1" not used \[Локальная переменная "\$1" не используется\]: удалите определение
1055	1043		- Circular unit reference between \$1 and \$2 \[циркулярная ссылка модуля между \$1 и \$2\]: показывает диалоговое окно зависимостей с полным путем между двумя модулями
1056	1044		- Identifier not found \[Идентификатор не найден\]: поиск через браузер кода
1057	1045		- Identifier not found \[Идентификатор не найден\]: поиск через словарь Cody (нужен пакет [[Cody]])
1058	1046		- Identifier not found \[Идентификатор не найден\]: добавьте локальную переменную
1059	1047		- Recompiling \$1, checksum changed for \$2 \[Перекомпиляция \$1, контрольная сумма изменена для \$2\]: показать диалог с путями поиска и другой информацией
1060	1048		- IDE warning: other sources path of package %s contains directory... \[Предупреждение IDE: другие пути исходников пакета %s содержит каталог ...:\]: откройте пакет
1061	1049		- any hint, note, warning \[любые подсказки, примечания, предупреждения\]: добавьте директиву IDE {%H-}
1062	1050		- any hint, note, warning \[любые подсказки, примечания, предупреждения\]: добавьте директиву компилятора {\$warn id off} (начиная с 1.7)
1063	1051		- any hint, note, warning \[любые подсказки, примечания, предупреждения\]: добавьте опцию компилятора -vm\<messageid\>
1064	1052		- Local variable "i" does not seem to be initialized \[Локальная переменная "i", похоже, не инициализирована\]: вставьте присвоение (начиная с 1.5)
1065	1053		- Inherited method is hidden \[Унаследованный метод скрыт\]: добавьте модификатор override, overload, или reintroduce (начиная с 1.9)
1066	1054
1067	1055		## Контур
1068	1056
1069	1057		Этот параметр находится в диалоговом окне Options --\> Editor --\> Display --\> Markup and Matches --\> Outline (global) \[Параметры --\> Редактор --\> Отображение --\> Подсветка и соответствия --\> Отображать контур блока(глобально)\].
1070	1058
1071	1059		Он выделяет ключевые слова Pascal вместе со своими операторными(begin-end) скобками. Это позволяет видеть вложенность больших блоков.
1072	1060
1073	1061		Например, для такого тела процедуры:
1074	1062
1075	1063		``` pascal
1076	1064		with ADockObject do
1077	1065		begin
1078	1066		if DropAlign = alNone then
1079	1067		begin
1080	1068		if DropOnControl <> nil then
1081	1069		DropAlign := DropOnControl.GetDockEdge(DropOnControl.ScreenToClient(DragPos))
1082	1070		else
1083	1071		DropAlign := Control.GetDockEdge(DragTargetPos);
1084	1072		end;
1085	1073		PositionDockRect(Control, DropOnControl, DropAlign, FDockRect);
1086	1074		end;
1087	1075		```
1088	1076
1089	1077		он подсвечивает:
1090	1078
1091	1079		- внешний with-do-begin-end оранжевым
1092	1080		- следующий if-then-begin-end зеленым
1093	1081		- внутренний if-then-else голубым
1094	1082
1095		-	~~<figure>~~
1096		-	~~<img src="ide_outline.png" title="ide_outline.png" />~~
1097		-	~~<figcaption>ide_outline.png</figcaption>~~
1098		-	~~</figure>~~
	1083	+	![](/wiki-images/3/3c/Ide_outline.png)
1099	1084
1100	1085		---
1101	1086		From the Free Pascal wiki, page "Lazarus IDE Tools/ru", as it stood on 2021-11-19 after a change by AMXS52, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history