Программирование в GPT для чайников. Часть 1

В предыдущей части мы рассмотрели основы работы с ChatGPT для решения задач, связанных с программированием, без непосредственного написания кода. Мы узнали, как правильно формировать промпты, разбивать работу на этапы, логировать действия и получать более предсказуемый результат. В этой части мы перейдём к более продвинутым приёмам работы с ChatGPT, в том числе:

• Выполнение операций с файлами и структурой каталогов

• Создание циклов и условий для управления процессом

• Создание и использование JSON-массивов со сложной структурой

• Сохранение промежуточных результатов и их использование в следующих шагах

• Многоуровневая обработка данных

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

Предварительное замечание

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

Воспринимайте эту статью как приглашение к экспериментам. Если вы новичок в структурировании логики задач, можете использовать отдельные элементы и постепенно внедрять их в свою практику. Если вы обладаете серьёзным опытом, вам, возможно, захочется адаптировать данные подходы под более сложные сценарии. В любом случае, цель данного текста — расширить ваши возможности и вдохновить на создание более эффективных решений.

Логика пошаговой обработки задач

Одно из ключевых преимуществ продуманного промпта — возможность моделировать не просто статичный набор инструкций, а целый динамический процесс, близкий к программированию. Можно представлять это так: вместо того, чтобы дать ChatGPT одно задание, вы описываете комплексную логику, разбиваете её на этапы, задаёте условия перехода от шага к шагу. В итоге ChatGPT становится своеобразным исполнителем ваших текстовых «программ».

Этапы выполнения работ

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

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

Принципы оформления этапов и шагов

При работе с промптами удобно использовать понятную иерархию, которая поможет ChatGPT чётко ориентироваться в поставленной задаче:

1. Этапы выделяйте в качестве заголовков с нумерацией. Например:

## Этапы выполнения работ
### 1. Распаковка архива
...
### 2. Удаление ненужных файлов и папок
...

Таким образом, каждый этап легко обнаружить в тексте, а модель чётко понимает начало и конец отдельного логического блока.

2. Внутри этапа описывайте шаги работы. Если шагов немного, можно использовать обычный ненумерованный список:

- Извлечь содержимое архива в рабочую директорию.
- Проверить структуру распакованных файлов.

3. Если шагов много или требуется описывать их вложенность (например, циклы или условные переходы), используйте многоуровневые нумерованные списки. Это создаст чёткую иерархию и логику:

1. Подготовка данных:
   1.1 Изучить структуру корневой папки.
   1.2 Проверить наличие скрытых или системных файлов.
   1.3 Применить фильтры для исключения ненужных директорий.

2. Обработка каждого файла:
   2.1 Открыть файл.
   2.2 Определить тип файла (PHP, JS, CSS).
   2.3 Проанализировать содержимое и извлечь необходимые данные.

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

Пример структуры этапов

Предположим, вы хотите подготовить документацию по модулю из архива. Ниже приведён возможный пример организации работы:

## Этапы выполнения работ

### 1. Распаковка архива
- Извлечь содержимое архива в рабочую директорию.
- Убедиться, что структура папок сохранена.
- Проверить доступность распакованных файлов.

### 2. Удаление ненужных файлов и папок
1. Определить критерии удаления (файлы с префиксом `_`, директории `lang`, файлы `.DS_Store`).
2. Последовательно обойти файловую структуру:
   2.1 Найти все соответствующие объекты.
   2.2 Удалить каждый из них.
   2.3 В случае ошибок при удалении записать информацию в журнал.

В данном примере принцип оформления этапов и шагов достаточно прост: крупные задачи оформлены как отдельные заголовки с нумерацией, а детальные инструкции указаны в списках. Если в дальнейшем задача усложнится (например, потребуется многократная обработка отдельных папок и файлов с разными условиями), можно углубиться ещё сильнее, добавив многоуровневые нумерованные списки и описания условий в том же стиле.

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

Операции с файлами

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

Примерная постановка задачи

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

1. Загрузить и распаковать архив.

2. Отфильтровать лишние файлы и папки.

3. Сохранить результирующую структуру, чтобы затем проанализировать её содержимое.

Для достижения этого вам понадобится сформулировать промпт, в котором чётко описаны действия на каждом этапе.

Чёткие инструкции для ChatGPT

При работе с файлами и директориями следует придерживаться следующих принципов:

1. Указывать конкретные фильтры для ненужных объектов: Определите критерии, по которым модель будет отсеивать файлы и папки. Например:

   • Удалять все файлы, чьё имя начинается с _.

   • Игнорировать системные файлы наподобие .DS_Store.

   • Удалять директории с названием lang и всё их содержимое.

2. Структурировать процесс пошагово: Разбейте работу на этапы и подэтапы. Например:

   • Этап 1: Распаковка архива.

   • Этап 2: Чистка структуры от ненужных объектов.

   • Этап 3: Сохранение итоговой структуры для дальнейшего анализа.

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

Пример оформления промпта

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

## Этапы выполнения работ

### 1. Распаковка архива
- Извлечь содержимое предоставленного архива в рабочую директорию.
- Убедиться, что структура папок сохранена без изменений.
- Проверить доступность всех распакованных файлов:
  - Если файлы недоступны, вывести сообщение: "Распакованные файлы не обнаружены. Пожалуйста, загрузите архив снова, чтобы продолжить работу."

### 2. Очистка структуры от ненужных файлов и папок
1. Определить критерии удаления:
   1.1 Удалять все файлы, чьё имя начинается с `_`.
   1.2 Удалять все системные файлы типа `.DS_Store`.
   1.3 Удалять все директории `lang` вместе с их содержимым.

2. Последовательно обойти файловую структуру:
   2.1 Найти все объекты, соответствующие критериям удаления.
   2.2 Удалить их, записывая в журнал информацию об удалённых файлах или папках.

3. После завершения очистки проверить итоговую структуру:
   - Убедиться, что файлы, не подпадающие под критерии удаления, остались на месте.
   - Сообщить пользователю о завершении очистки.

Условия

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

Почему это важно?

Условия помогают избегать лишней работы, пропускать ненужные объекты и применять специальные правила для особых случаев. Например, если вы обрабатываете файлы разного типа, можно для каждого типа задавать отдельный сценарий обработки.

Пример условного ветвления

Допустим, в вашем архиве есть файлы с расширениями .php, .js и .css. Вы хотите:

**Условие для .php:** Извлечь константы, классы и функции, описать их назначение.  
**Условие для .js:** Определить ключевые функции и их роль в логике приложения.  
**Условие для .css:** Описать основные стили, их влияние на внешний вид интерфейса.
**Если файл не подходит ни под один из критериев:** Пропустить обработку этого файла.

Таким образом, модель будет смотреть на каждый файл, определять его тип и выбирать подходящий сценарий действий. Это упрощает логику и позволяет не тратить время на обработку нерелевантных данных.

Гибкость и предсказуемость

Чётко прописанные условия делают ваш промпт более гибким. Вы можете добавлять новые условия по мере необходимости, например, при появлении новых типов файлов или сложных ситуаций (вроде отсутствия нужных атрибутов или контента в файле). Кроме того, условия делают поведение модели более предсказуемым и понятным.

Циклы

После того как вы научились задавать условия, стоит перейти к следующему шагу — организации циклов. Циклы позволяют многократно повторять определённый набор действий, пока не будут выполнены все условия или не обработаны все объекты. Это особенно полезно при работе с большим количеством файлов или данных.

Зачем нужны циклы?

Циклы позволяют вам экономить время и силы, не прописывая одну и ту же логику много раз. Представьте, что у вас сотни файлов: вместо того чтобы отдельно описывать обработку для каждого, вы указываете модель «пройтись» по всем объектам, применяя к ним одни и те же правила.

Пример цикла

Допустим, вы уже определили условия для разных типов файлов (как в предыдущем разделе). Теперь вам нужно повторить эту обработку для каждого файла в списке. Пример описания цикла может выглядеть так:

**Цикл обработки файлов:**  
Повторять следующие шаги для каждого необработанного файла:  
1. Определить тип файла (php, js, css или другой).  
2. Применить соответствующие условия (описанные выше) для анализа содержимого.  
3. Добавить результаты анализа в документацию или промежуточную структуру данных.  
4. Отметить файл как обработанный (например, установить флаг processed: true в progress.json).  

Повторять до тех пор, пока все файлы не будут обработаны.

Таким образом, модель будет последовательно брать файлы один за другим, выполнять над ними указанные действия и переходить к следующему, пока не закончатся объекты для обработки или не будут достигнуты другие заданные условия (например, ограничение по времени или количеству шагов).

Расширение логики

Циклы можно усложнять. Например, вы можете создавать вложенные циклы для обработки вложенных директорий, или останавливать цикл при возникновении определённых обстоятельств (ошибок, отсутствия нужных данных и т.д.). Это делает ваш промпт ещё более гибким и похожим на полноценную программу.

Использование JSON-массивов для отслеживания прогресса

Когда ваша задача становится достаточно объёмной, а обработке подлежит множество файлов и данных, возникает потребность в чёткой системе учёта того, что уже сделано, и что ещё предстоит выполнить. JSON-массивы идеально подходят для этой цели. Они служат «картой» вашего проекта, в которой хранится актуальная информация о структуре данных, статусе обработки и необходимых последующих шагах.

Почему именно JSON?

JSON — простой, понятный и универсальный формат, легко интерпретируемый как человеком, так и программой. Он широко используется в веб-разработке, и ChatGPT хорошо понимает этот формат. Используя JSON, вы получаете удобный инструмент для хранения и передачи данных между этапами выполнения работ. Это особенно важно, когда ваш процесс разбит на множество шагов и циклов, а данные нужно переиспользовать без повторной обработки.

Описание структуры с помощью дополнительных промптов

Вы можете заранее определить структуру JSON, которую модель будет использовать для отслеживания прогресса. Например, при работе с архивом и анализом кода в модулях можно создать файл progress.json со следующими полями:

{
  "name": "string",
  "absolute_path": "string",
  "relative_path": "string",
  "type": "folder или file",
  "processed": false или true,
  "children": [ ... ]
}

В данном случае:

• name: имя папки или файла

• absolute_path: абсолютный путь к объекту

• relative_path: путь относительно корня проекта

• type: тип объекта (папка или файл)

• processed: флаг, указывающий, был ли данный объект обработан

• children: массив вложенных объектов (для папок)

Используя дополнительный промпт, вы можете попросить модель заранее сформировать progress.json после очистки структуры от лишних файлов и перед тем, как начать основную обработку. Так вы получите зафиксированную «точку опоры», к которой можно возвращаться. Модель будет понимать, что этот JSON определяет полный перечень объектов и их статус.

Применение JSON-структуры в циклах

После того как progress.json сформирован, вы можете использовать его данные для циклической обработки:

**Цикл обработки объектов из progress.json:**
1. Прочитать progress.json.
2. Найти первый объект (папку или файл), где processed == false.
3. Если это папка — обработать её содержимое (перейти к children).  
   Если это файл — применить условия (описанные ранее для типов файлов).
4. После обработки объекта установить processed = true.
5. Повторять, пока не будут обработаны все объекты, либо пока не встретится условие остановки.

Таким образом, JSON-структура превращается в своего рода «список дел», по которому модель будет автоматически двигаться, отмечая выполненные пункты. Это позволяет легко масштабировать задачу, добавлять новые файлы или менять логику на любом этапе без потери контекста.

Дополнительные возможности

JSON можно использовать не только для фиксации статуса обработки. Вы можете хранить в отдельных полях дополнительную информацию — например, результаты анализа файлов, извлечённые константы или функции, а также ссылки на сформированную документацию. Это позволит вам к концу всех этапов иметь полную картину проекта, не потеряв ни одной детали.

Гибкость и адаптивность

Если впоследствии вы захотите изменить формат JSON или добавить новые поля, вы можете просто обновить инструкцию в промпте. Модель поймёт, что теперь при формировании или обновлении progress.json нужно учитывать новые требования. Это делает ваш процесс не только предсказуемым, но и легко настраиваемым под новые нужды.

Сохранение промежуточных результатов

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

Почему это нужно?

Представьте, что вы проанализировали уже половину файлов архива, извлекли нужные данные, записали их в структуру или документ, а затем вам нужно сделать перерыв. Если вы сохраните текущее состояние, то при следующем запуске не придётся повторять все те же действия. Модель сможет сразу перейти к обработке оставшихся файлов, основываясь на уже полученных результатах.

Как сохранять промежуточные результаты?

Один из удобных способов — использовать файл, например, тот же progress.json, который вы уже сформировали для отслеживания статуса объектов. Расширьте его, добавив новые поля, или создайте отдельный документ, в котором фиксируете итоги каждого этапа. Это могут быть:

• Списки уже обработанных файлов и их свойств.

• Извлечённые данные (константы, функции, их описания), которые затем будут использованы для формирования итоговой документации.

• Статус выполнения каждого шага, чтобы при повторном запуске модель понимала, какой этап завершён, а какой нужно продолжить.

Пример:

Предположим, вы разбираете код из архива, выделяя константы и функции для итоговой документации. После обработки нескольких файлов вы создаёте или обновляете progress.json:

{
  "name": "root",
  "type": "folder",
  "processed": false,
  "children": [
    {
      "name": "admin",
      "type": "folder",
      "processed": true,
      "functions_extracted": ["on_work", "iblock.section.edit"],
      "children": []
    },
    ...
  ]
}

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

Адаптация под любые задачи

Вы можете сохранить не только статус и извлечённые данные, но и настройки или фильтры, которые применялись к файлам. Это упростит расширение или углубление анализа при последующих запусках. Сохранение промежуточных результатов делает процесс гибким: можно при необходимости вернуться к любому этапу, внести изменения и продолжить без потери достигнутого прогресса.

Накопление данных

Помимо сохранения промежуточных результатов во внутренних форматах, таких как JSON, и ведения журналирования, вы можете накапливать всю извлечённую информацию в удобочитаемой форме — файле Markdown. Этот документ станет сводом всех полученных данных и сведений, которые модель собрала по мере прохождения этапов, обработки файлов и применения условий.

Зачем это нужно?

Markdown — простой и гибкий формат, который легко читает человек и который одновременно подходит для автоматической обработки. По мере выполнения шагов, обнаружения констант, функций, классов и прочих элементов, модель может добавлять их описания, пути к файлам и комментарии в Markdown-документ. В итоге вы получаете не просто внутренние структуры для контроля над процессом, но и аккуратное, готовое к использованию описание проекта.

Пример использования:

Представьте, что после каждого этапа обработки модель обновляет doc_{archive_name}.md, добавляя новые разделы и подпункты. Например:

# Документация по модулю {archive_name}
## Структура файлов и папок
(здесь модель вставит дерево каталогов и ссылки)

## Описания файлов
### admin/
- **on_work.php**: Скрипт для обработки определённых операций ...
- **iblock.section.edit.php**: Код редактирования секций ...

## Константы и функции
- **FUNCTION_NAME($param1, $param2)**: Описание назначения функции ...
- **DEFINE('CONST_NAME', 'value')**: Константа для указания ...

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

Возможности расширения:

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

Многоуровневая обработка данных

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

Как это работает на практике?

Представьте, что на начальных этапах вы извлекаете метаданные о каждом файле, определяете его тип, выявляете константы, функции, классы и их взаимосвязи. Все эти данные записываются в промежуточные структуры, такие как progress.json, а затем дополняются в итоговый Markdown-файл. Позже, когда у вас уже есть подробная информация о каждом отдельном файле или разделе кода, вы можете перейти к следующему уровню абстракции:

• Анализ общей архитектуры модуля: Вместо того чтобы смотреть на файлы в отдельности, вы можете рассмотреть их взаимодействия. Например, если несколько файлов подключаются друг к другу или совместно формируют определённый функционал, вы можете использовать ранее собранные данные, чтобы сделать вывод о ключевых точках интеграции или логике работы всего модуля.

• Генерация сводного описания: На основе собранных описаний отдельных файлов можно сформировать более ёмкое резюме — общее назначение модуля, основные задачи, которые он решает, ключевые классы и их роль, а также наиболее значимые функции. Подобная сводка станет ценным конечным продуктом, пригодным для быстрой ориентации в проекте.

• Многопроходная обработка: Вы можете проходить по структуре данных повторно, на каждом цикле добавляя новые уровни информации. Сначала — чистая структура файлов, затем — детальный разбор кода, после — анализ взаимосвязей и, наконец, формирование итогового отчёта.

Преимущества многоуровневой обработки:

Благодаря многоуровневому подходу вам не нужно каждый раз «изобретать велосипед». Информация, однажды собранная и зафиксированная, становится «строительным материалом» для более продвинутых форм анализа. Это сокращает общее время обработки и повышает качество результатов, так как каждый последующий этап опирается на уже проверенные и уточнённые данные.

Гибкость и адаптивность:

Многоуровневая обработка позволяет вам при необходимости возвращаться к ранним этапам, вносить коррективы или дополнять данные. Вы можете улучшать точность выводов, корректировать структуру или добавлять новые типы метаданных, а затем вновь использовать их на поздних этапах. Таким образом, ваш процесс становится не только предсказуемым, но и эволюционирующим — со временем вы адаптируете его под свои нужды, повышая эффективность и удобство анализа.

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

Заключение

Мы рассмотрели широкий спектр приёмов и подходов, позволяющих более эффективно взаимодействовать с моделью: от разбиения задач на этапы до применения условий и циклов, от использования JSON для отслеживания прогресса до сохранения промежуточных результатов и формирования итоговой документации в Markdown. Эти методы превращают общение с моделью в управляемый, предсказуемый и легко масштабируемый процесс, где вы можете гибко адаптировать логику под ваши цели.

Основная идея статьи — показать, что даже без прямого написания кода можно фактически «программировать» модель, задавая ей чёткие текстовые инструкции. С помощью продуманных промптов вы учитесь использовать возможности модели для решения сложных задач: от автоматической генерации документации до анализа структуры кода, от повторной обработки больших объёмов данных до создания многоуровневых систем, позволяющих получать комплексный обзор проекта.

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