perldebtut - Интернет в облаке

ПРОГРАММА:

ИМЯ

perldebtut - руководство по отладке Perl

ОПИСАНИЕ

(Очень) легкое введение в использование отладчика perl и указатель на
существующие более глубокие источники информации по отладке программ на Perl.

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

использование строгий

Прежде всего, есть несколько вещей, которые вы можете сделать, чтобы сделать свою жизнь намного проще.
когда дело доходит до отладки программ на Perl, вообще без использования отладчика. К
Продемонстрируйте, что вот простой скрипт с названием "hello" с проблемой:

#!/ usr / bin / perl

$ var1 = 'Привет, мир'; # всегда хотел это сделать :-)
$ var2 = "$ varl \ n";

print $ var2;
Выход;

Хотя он компилируется и работает успешно, он, вероятно, не будет делать то, что от него ожидается, а именно:
вообще не печатает «Hello World \ n»; С другой стороны, он будет делать именно то, что было
сказали делать, компьютеры немного к этому склонны. То есть он распечатает новую строку
символ, и вы получите то, что выглядит как пустая строка. Похоже, есть 2 переменные
когда (из-за опечатки) действительно 3:

$ var1 = 'Привет, мир';
$ varl = undef;
$ var2 = "\ п";

Чтобы поймать эту проблему, мы можем принудительно объявить каждую переменную перед использованием
вставив модуль strict, поместив 'use strict;' после первой строки скрипта.

Теперь, когда вы его запускаете, perl жалуется на 3 необъявленные переменные, и мы получаем четыре ошибки
сообщения, потому что одна переменная упоминается дважды:

Глобальный символ «$ var1» требует явного имени пакета в строке 1 ./t4.
Глобальный символ «$ var2» требует явного имени пакета в строке 1 ./t5.
Глобальный символ «$ varl» требует явного имени пакета в строке 1 ./t5.
Глобальный символ «$ var2» требует явного имени пакета в строке 1 ./t7.
Выполнение ./hello прервано из-за ошибок компиляции.

Лувверли! и чтобы исправить это, мы явно объявляем все переменные, и теперь наш скрипт выглядит
как это:

#!/ usr / bin / perl
использовать строго;

мой $ var1 = 'Привет, мир';
мой $ varl = undef;
мой $ var2 = "$ varl \ n";

print $ var2;
Выход;

Затем мы выполняем (всегда хорошая идея) проверку синтаксиса, прежде чем пытаться запустить ее снова:

> perl -c привет
привет синтаксис ОК

И теперь, когда мы его запускаем, мы все еще получаем "\ n", но, по крайней мере, мы знаем почему. Просто получаю это
скрипт для компиляции предоставил переменную '$ varl' (с буквой 'l') и просто
изменение $ varl на $ var1 решает проблему.

Глядя at данным и -w и v

Хорошо, но как насчет того, чтобы действительно увидеть свои данные, что находится в этой динамической переменной,
непосредственно перед его использованием?

#!/ usr / bin / perl
использовать строго;

мой $ key = 'добро пожаловать';
мои% данные = (
'this' => qw (это),
'tom' => qw (и Джерри),
'welcome' => q (Привет, мир),
'zip' => q (добро пожаловать),
);
мои @data = ключи% данные;

напечатать "$ data {$ key} \ n";
Выход;

Выглядит нормально, после проверки синтаксиса (perl -c scriptname) мы запускаем его и все
мы снова получаем пустую строку! Хмммм.

Одним из распространенных подходов к отладке здесь было бы обильно разбросать несколько операторов печати,
чтобы добавить чек непосредственно перед распечаткой наших данных и еще один сразу после:

напечатайте "All OK \ n", если grep ($ key, keys% data);
напечатать "$ data {$ key} \ n";
печать "готово: '$ data {$ key}' \ n";

И попробуй еще раз:

> данные perl
Все ОК

сделано: ''

После того, как я долго смотрел на тот же кусок кода и не видел леса за деревьями для
Через некоторое время мы выпьем чашку кофе и попробуем другой подход. То есть вносим
кавалерии, дав перлу '-d'включите командную строку:

> perl -d данные
Восстановлен обработчик штампа по умолчанию.

Загрузка подпрограмм БД из perl5db.pl версии 1.07
Доступна поддержка редактора.

Введите h или hh, чтобы получить помощь, или man perldebug, чтобы получить дополнительную помощь.

main :: (./ data: 4): мой $ key = 'добро пожаловать';

Теперь мы запустили встроенный отладчик perl в нашем скрипте. Это
остановился на первой строке исполняемого кода и ждет ввода.

Прежде чем мы пойдем дальше, вы захотите узнать, как выйти из отладчика: используйте только
письмо 'q', а не слова "выйти" или "выйти":

DB <1> q
>

Вот и все, вы снова вернулись на родину.

помощь

Снова запустите отладчик в своем скрипте, и мы посмотрим на меню справки. Есть
несколько способов вызвать помощь: простой 'h'получит сводный список справки,'|h'(труба-ч)
направит справку через ваш пейджер (что (вероятно, «больше» или «меньше»), и, наконец,
'h h'(h-space-h) откроет вам весь экран справки. Вот сводная страница:

D1h

Список / поиск исходных строк: Выполнение сценария управления:
l [ln | sub] Список исходного кода T Трассировка стека
- или . Перечислить предыдущую / текущую строку [выражение] Один шаг [в выражении]
v [строка] Обзор строки n [выражение] Затем переступаем через подпрограммы
f имя файла Просмотреть исходный код в файле Повторить последние n или s
/ узор /? патт? Поиск вперед / назад Возврат из подпрограммы
M Показать версии модуля c [ln | sub] Продолжить до позиции
Элементы управления отладчиком: L Перерыв / наблюдение / действия списка
o [...] Установить параметры отладчика t [выражение] Переключить трассировку [выражение трассировки]
<[<] | {[{] |> [>] [cmd] Выполнить предварительный / последующий запрос b [ln | event | sub] [cnd] Установить точку останова
! [N | pat] Повторить предыдущую команду B ln | * Удалить / все точки останова
H [-num] Показать последнее число команд a [ln] cmd Сделать cmd перед строкой
= [a val] Определить / перечислить псевдоним A ln | * Удалить / все действия
h [db_cmd] Получить справку по команде w expr Добавить контрольное выражение
hh Полная справочная страница W expr | * Удалить все / все выражения для просмотра
| [|] db_cmd Отправить вывод на пейджер! [!] syscmd Выполнить cmd в подпроцессе
q или ^ D Quit R Попытка перезапуска
Проверка данных: expr Выполнить код Perl, см. Также: s, n, t expr
x | m expr Исключает expr в контексте списка, выводит результат или перечисляет методы.
p expr Выражение печати (использует текущий пакет скрипта).
S [[!] Pat] Список имен подпрограмм, [не] соответствующих шаблону
V [Pk [Vars]] Список переменных в пакете. Варианты могут быть ~ шаблон или! Шаблон.
X [Vars] То же, что и "V current_package [Vars]".
y [n [Vars]] Перечислить лексические элементы в более высоком объеме . Варс такой же, как В.
Для получения дополнительной помощи введите h cmd_letter или запустите man perldebug для всех документов.

Более запутанные варианты, чем вы можете представить! Это не так плохо, как кажется и
очень полезно узнать обо всем этом побольше, да и весело!

Есть пара полезных, о которых стоит сразу узнать. Вы бы не подумали, что мы
используя любые библиотеки на данный момент, но 'M'покажет, какие модули в настоящее время
загружены, и их номер версии, а 'm'покажет методы, и'S'показывает все
подпрограммы (по шаблону), как показано ниже. 'V'И'X'показывать переменные в программе
объем пакета и может быть ограничен шаблоном.

ДБ <2> ул.
dumpvar :: stringify
строгий :: бит
строгий :: импорт
строгий :: неимпорт

Использование 'X' и двоюродных братьев требует, чтобы вы не использовали идентификаторы типа ($ @%), а только имя:

DM <3> X ~ ошибка
FileHandle (stderr) => файлно(2)

Помните, что мы находимся в нашей крошечной программе с проблемой, мы должны посмотреть, где мы находимся,
и как выглядят наши данные. Прежде всего, давайте рассмотрим код в нашем текущем положении.
(в данном случае первая строка кода) через 'v':

DB <4> v
1#!/ usr / bin / perl
2: используйте строгое;
3
4 ==> мой $ key = 'добро пожаловать';
5: мои данные% = (
6 'this' => qw (то),
7 'tom' => qw (и Джерри),
8 'welcome' => q (Привет, мир),
9 'zip' => q (добро пожаловать),
10);

В строке номер 4 есть полезный указатель, который сообщает вам, где вы сейчас находитесь. Чтобы увидеть больше
код, введите "v" еще раз:

DB <4> v
8 'welcome' => q (Привет, мир),
9 'zip' => q (добро пожаловать),
10);
11: мои @data = ключи% данные;
12: вывести «Все в порядке \ n», если grep ($ key, keys% data);
13: напечатать «$ data {$ key} \ n»;
14: печать "готово: '$ data {$ key}' \ n";
15: выход;

И если вы хотите снова перечислить строку 5, введите 'l 5' (обратите внимание на пробел):

ДБ <4> l 5
5: мои данные% = (

В этом случае особо не на что смотреть, но, конечно, обычно есть страницы с материалами, которые нужно
продирайтесь, и «я» может быть очень полезным. Чтобы сбросить ваш вид на линию, которую мы собираемся
выполнить, введите одинокий период '.':

БД <5>.
main :: (./ data_a: 4): мой $ key = 'добро пожаловать';

Показанная строка - это та, которая вот-вот будет выполнена. следующий, этого еще не произошло. Так
а мы можем напечатать переменную с буквой 'p', на этом этапе все, что мы получим, - это пустой
(undefined) значение обратно. Что нам нужно сделать, так это перейти к следующему исполняемому файлу
заявление с 's':

DB <6> с
main :: (./ data_a: 5): my% data = (
main :: (./ data_a: 6): 'this' => qw (это),
main :: (./ data_a: 7): 'tom' => qw (и jerry),
main :: (./ data_a: 8): 'welcome' => q (Привет, мир),
main :: (./ data_a: 9): 'zip' => q (добро пожаловать),
main :: (./ data_a: 10):);

Теперь мы можем взглянуть на эту первую ($ key) переменную:

DB <7> p $ ключ
добро пожаловать

строка 13 - это то место, где находится действие, поэтому давайте продолжим туда через букву 'c', который
кстати, вставляет одноразовую точку останова в заданную строку или подпрограмму:

DB <8> c 13
Все ОК
main :: (./ data_a: 13): print "$ data {$ key} \ n";

Мы прошли мимо нашего чека (где было напечатано «Все в порядке») и остановились как раз перед
мясо нашей задачи. Мы могли бы попытаться распечатать пару переменных, чтобы увидеть, что
происходит:

БД <9> p $ data {$ key}

Там не так много, давайте посмотрим на наш хеш:

БД <10> p% данных
Hello Worldziptomandwelcomejerrywelcomethist that

DB <11> p ключей% данных
Привет мир

Что ж, это не очень легко читать, и используя полезное руководство (h h), 'xкоманда
выглядит многообещающе:

БД <12> x% данных
0 "Привет, мир"
1 "застежка-молния"
2 'Том'
3 'и'
4 'добро пожаловать'
5 ундеф
6 'джерри'
7 'добро пожаловать'
8 'это'
9 'это'

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

БД <13> x \% данных
0 HASH / ХЭШ(0x8194bc4)
'Hello World' => 'zip'
'jerry' => 'добро пожаловать'
'это' => 'то'
'tom' => 'и'
'добро пожаловать' => undef

Ссылка действительно сброшена, и мы наконец можем увидеть, с чем имеем дело. Наше цитирование
было совершенно корректно, но неверно для наших целей, поскольку 'and jerry' трактовалось как 2
разделять слова, а не фразу, тем самым выбрасывая структуру хеширования с равномерными парами из
выравнивание.

'-w'switch сказал бы нам об этом, если бы мы использовали его в начале, и сэкономил бы нам
много неприятностей:

> perl -w данные
Нечетное количество элементов в присвоении хэша в строке ./data 5.

Мы исправляем нашу цитату: 'tom' => q (и jerry) и запускаем ее снова, на этот раз мы получаем ожидаемую
вывод:

> perl -w данные
Привет мир

Пока мы здесь, присмотритесь кx', это действительно полезно и будет
весело выгружать вложенные ссылки, полные объекты, частичные объекты - почти
что бы вы ни бросили:

Давайте быстро создадим объект и запустим его, сначала запустим отладчик: он хочет немного
форма ввода из STDIN, поэтому мы даем ей что-то необязательное, ноль:

> perl -de 0
Восстановлен обработчик штампа по умолчанию.

Загрузка подпрограмм БД из perl5db.pl версии 1.07
Доступна поддержка редактора.

Введите h или hh, чтобы получить помощь, или man perldebug, чтобы получить дополнительную помощь.

main :: (- e: 1): 0

Теперь создайте объект на лету из пары строк (обратите внимание на обратную косую черту):

БД <1> $ obj = bless ({'unique_id' => '123', 'attr' => \
cont: {'col' => 'black', 'things' => [qw (это то и т. д.)]}}, 'MY_class')

И давайте посмотрим на это:

DB <2> x $ obj
0 MY_class =HASH / ХЭШ(0x828ad98)
'attr' => HASH / ХЭШ(0x828ad68)
'col' => 'черный'
'вещи' => МНОЖЕСТВО(0x828abb8)
0 'это'
1 'это'
2 'и т. Д.
'unique_id' => 123
БД <3>

Полезно, а? Вы можете оценить практически все, что угодно, и поэкспериментировать с фрагментами кода или
регулярные выражения, пока коровы не вернутся домой:

DB <3> @data = qw (это другая коса теории атеизма)

DB <4> p 'saw ->'. ($ Cnt + = map {print "\ t: \ t $ _ \ n"} grep (/ the /, sort @data))
атеизм
кожа
другими
коса

теория
пила -> 6

Если вы хотите увидеть историю команд, введите 'H':

DB <5> H
4: p 'saw ->'. ($ Cnt + = map {print "\ t: \ t $ _ \ n"} grep (/ the /, sort @data))
3: @data = qw (это другая коса из кожаной теории атеизма)
2: x $ obj
1: $ obj = bless ({'unique_id' => '123', 'attr' =>
{'col' => 'black', 'things' => [qw (это то и т. д.]}}, 'MY_class')
БД <5>

А если вы хотите повторить любую предыдущую команду, используйте восклицательный знак: '!':

DB <5>! 4
p 'saw ->'. ($ cnt + = map {print "$ _ \ n"} grep (/ the /, sort @data))
атеизм
кожа
другими
коса

теория
пила -> 12

Для получения дополнительной информации см. Perlref и perlreftut.

Шагая через код

Вот простая программа, которая конвертирует градусы Цельсия и Фаренгейта, у нее тоже есть
проблема:

#!/ usr / bin / perl -w
использовать строго;

мой $ arg = $ ARGV [0] || '-c20';

if ($ arg = ~ /^\-(c|f)((\-|\+)*\d+(\.\d+)*)$/) {
мой ($ deg, $ num) = ($ 1, $ 2);
мой ($ вход, $ выход) = ($ число, $ число);
if ($ deg eq 'c') {
$ deg = 'е';
$ out = & c2f ($ num);
} Еще {
$ deg = 'c';
$ out = & f2c ($ num);
}
$ out = sprintf ('% 0.2f', $ out);
$ out = ~ s / ^ ((\ - | \ +) * \ d +) \. 0 + $ / $ 1 /;
напечатайте "$ out $ deg \ n";
} Еще {
print "Использование: $ 0 - [c | f] num \ n";
}
Выход;

суб f2c {
мой $ f = сдвиг;
мой $ c = 5 * $ f - 32/9;
return $ c;
}

суб c2f {
мой $ c = сдвиг;
мой $ f = 9 * $ c / 5 + 32;
return $ f;
}

По какой-то причине преобразование Фаренгейта в Цельсия не возвращает ожидаемый результат.
Вот что он делает:

> темп -c0.72
33.30 е

> темп -f33.3
162.94 с

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

мой ($ вход, $ выход) = ($ число, $ число);
$ DB :: single = 2; # вставить в строку 9!
если ($ deg eq 'c')
...

> perl -d темп -f33.3
Восстановлен обработчик штампа по умолчанию.

Загрузка подпрограмм БД из perl5db.pl версии 1.07
Доступна поддержка редактора.

Введите h или hh, чтобы получить помощь, или man perldebug, чтобы получить дополнительную помощь.

main: :( temp: 4): my $ arg = $ ARGV [0] || '-c100';

Мы просто продолжим до нашей предустановленной точки останова с помощью символа 'c':

DB <1> c
main: :( temp: 10): if ($ deg eq 'c') {

Затем следует команда просмотра, чтобы увидеть, где мы находимся:

DB <1> v
7: my ($ deg, $ num) = ($ 1, $ 2);
8: мой ($ in, $ out) = ($ num, $ num);
9: $ DB :: single = 2;
10 ==> if ($ deg eq 'c') {
11: $ deg = 'f';
12: $ out = & c2f ($ num);
13} else {
14: $ deg = 'c';
15: $ out = & f2c ($ num);
16}

И печать, чтобы показать, какие значения мы в настоящее время используем:

DB <1> p ​​$ deg, $ num
f33.3

Мы можем поставить еще одну точку останова на любую строку, начинающуюся с двоеточия, мы будем использовать строку 17 как
это так же, как мы вышли из подпрограммы, и мы хотели бы сделать паузу на этом позже:

DB <2> b 17

По этому поводу нет обратной связи, но вы можете увидеть, какие точки останова установлены, используя список
Команда 'L':

DB <3> L
темп:
17: вывести «$ out $ deg \ n»;
сломать, если (1)

Обратите внимание, что для удаления точки останова вы используете «B».

Теперь мы перейдем к нашей подпрограмме, на этот раз, а не по номеру строки, мы
используйте имя подпрограммы, за которым следует уже знакомая 'v':

DB <3> c f2c
main :: f2c (темп: 30): мой $ f = shift;

DB <4> v
24: выход;
25
26 саб f2c {
27 ==> мой $ f = shift;
28: мой $ c = 5 * $ f - 32/9;
29: возврат $ c;
30}
31
32 саб c2f {
33: мой $ c = shift;

Обратите внимание: если между нами и строкой 29 был вызов подпрограммы, и мы хотели одно-
шаг через него мы могли бы использовать 's'команда, и чтобы перешагнуть через нее, мы будем использовать'n' который
казнил бы субмарину, но не спустился бы в нее для проверки. Но в этом случае мы
просто продолжайте до строки 29:

DB <4> c 29
main :: f2c (темп: 29): возврат $ c;

И посмотрим на возвращаемое значение:

DB <5> p $ c
162.944444444444

Это совсем не правильный ответ, но сумма выглядит верной. Интересно, если это что-нибудь
делать с приоритетом оператора? Мы попробуем с нашей суммой еще несколько вариантов:

DB <6> p (5 * $ f - 32/9)
162.944444444444

DB <7> p 5 * $ f - (32/9)
162.944444444444

ДБ <8> п (5 * $ ф) - 32/9
162.944444444444

DB <9> p 5 * ($ f - 32) / 9
0.722222222222221

:-) это больше походит на это! Хорошо, теперь мы можем установить нашу возвращаемую переменную, и мы вернемся из
сабвуфер с буквой "r":

DB <10> $ c = 5 * ($ f - 32) / 9

DB <11> r
возврат скалярного контекста из main :: f2c: 0.722222222222221

Выглядит хорошо, давайте продолжим с конца скрипта:

DB <12> c
0.72 с
Отлаженная программа прекращена. Используйте q для выхода или R для перезапуска,
используйте O ignit_exit, чтобы избежать остановки после завершения программы,
hq, h R или h O, чтобы получить дополнительную информацию.

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

Заполнитель для a, w, t, T

Действия, переменные наблюдения, трассировки стека и т. Д .: в списке TODO.

a

w

t

T

ОЧЕРЕДНАЯ ВЫРАЖЕНИЯ

Вы когда-нибудь хотели знать, как выглядит регулярное выражение? Вам понадобится perl, скомпилированный с
Флаг DEBUGGING для этого:

> perl -Dr -e '/ ^ pe (a) * rl $ / i'
Компиляция REx `^ pe (a) * rl $ '
размер 17 сначала на 2
редчайший гольц
в 0
1: BOL(2)
2: EXACTF (4)
4: КЕРЛИН [1] {0,32767} (14)
6: НИЧЕГО(8)
8: EXACTF (0)
12: Пока(0)
13: НИЧЕГО(14)
14: EXACTF (16)
16: EOL(17)
17: END(0)
плавающий `'$ в 4..2147483647 (проверка плавающего) stclass` EXACTF '
на якоре (BOL) minlen 4
Без поддержки $ `$ & $ '.

ВЫПОЛНЕНИЕ ...

Освобождение REx: `^ pe (a) * rl $ '

Вы действительно хотели знать? :-) Чтобы узнать больше о том, как получить регулярные выражения в
работы, взгляните на perlre, perlretut и расшифруйте загадочные метки (BOL и
CURLYN и т. Д. Выше), см. Perldebguts.

ВЫВОД СОВЕТЫ

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

$ | = 1;

Чтобы наблюдать за динамически растущим файлом журнала (из командной строки):

хвост -f $ error_log

Обертывание всех вызовов die в подпрограмме обработчика может быть полезно, чтобы увидеть, как и откуда
их вызывают, у perlvar есть дополнительная информация:

НАЧАТЬ {$ SIG {__ DIE__} = sub {требуется карп; Карп :: исповедь (@_)}}

Различные полезные методы перенаправления дескрипторов файлов STDOUT и STDERR:
объяснил в perlopentut и perlfaq8.

CGI

Просто краткая подсказка для всех тех программистов CGI, которые не могут понять, как это сделать.
обойти это приглашение «ожидание ввода» при запуске сценария CGI из команды -
строка, попробуйте что-то вроде этого:

> perl -d my_cgi.pl -nodebug

Конечно, CGI и perlfaq9 расскажут вам больше.

ГПИ

Интерфейс командной строки тесно интегрирован с Emacs расширение и есть vi
интерфейс тоже.

Вам не обязательно делать все это в командной строке, однако есть несколько параметров графического интерфейса.
там. Приятно то, что вы можете навести указатель мыши на переменную и создать дамп
его данные появятся в соответствующем окне или во всплывающем всплывающем окне, больше не утомительно
ввод 'x $ varname' :-)

В частности, поищите следующее:

пткдб Обертка на основе perlTK для встроенного отладчика

ддд отладчик отображения данных

PerlDevKit и PerlBuilder специфичны для NT

NB. (хотелось бы получить больше информации об этих и других).

РЕЗЮМЕ

Мы видели, как поощрять хорошие практики кодирования с помощью использование строгий и -w. Мы можем запустить
отладчик perl Perl -d имя сценария для проверки ваших данных из отладчика perl с помощью
p и x команды. Вы можете пройтись по вашему коду, установить точки останова с помощью b и шаг
через этот код с s or n, продолжить с c и вернуться с подлодки с r. Весьма
интуитивно понятный материал, когда вы к нему приступаете.

Конечно, есть еще много чего узнать, это только начало. В
лучший способ узнать больше - использовать perldoc, чтобы узнать больше о языке, прочитать
он-лайн справка (perldebug, вероятно, следующее место, куда нужно пойти) и, конечно же, поэкспериментировать.

Используйте perldebtut онлайн с помощью сервисов onworks.net