XML:: Simple - это самый сложный XML-анализатор, доступный

Основная проблема с XML:: Simple заключается в том, что результирующая структура чрезвычайно сложна для правильной навигации. $ele->{ele_name} может возвращать любое из следующего (даже для элементов, которые следуют той же спецификации):

[ { att => 'val', ..., content => 'content' }, ... ]
[ { att => 'val', ..., }, ... ]
[ 'content', ... ]
{ 'id' => { att => 'val', ..., content => 'content' }, ... }
{ 'id' => { att => 'val', ... }, ... }
{ 'id' => { content => 'content' }, ... }
{ att => 'val', ..., content => 'content' }
{ att => 'val', ..., }
'content'

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

Параметры для создания более правильного дерева не соответствуют

Вы можете использовать следующие параметры для создания более регулярного дерева:

ForceArray => 1, KeyAttr => [], ForceContent => 1

Но даже с этими параметрами требуется много проверок для извлечения информации из дерева. Например, получение узлов /root/eles/ele из документа является общей операцией, которая должна быть тривиальной для выполнения, но при использовании XML:: Simple требуется следующее:

# Requires: ForceArray => 1, KeyAttr => [], ForceContent => 1, KeepRoot => 0
# Assumes the format doesn't allow for more than one /root/eles.
# The format wouldn't be supported if it allowed /root to have an attr named eles.
# The format wouldn't be supported if it allowed /root/eles to have an attr named ele.
my @eles;
if ($doc->{eles} && $doc->{eles}[0]{ele}) {
    @eles = @{ $doc->{eles}[0]{ele} };
}

В другом парсере можно использовать следующее:

my @eles = $doc->findnodes('/root/eles/ele');

XML:: Simple накладывает многочисленные ограничения, и в нем отсутствуют общие функции

• Это совершенно бесполезно для создания XML. Даже с ForceArray => 1, ForceContent => 1, KeyAttr => [], KeepRoot => 1 имеется слишком много деталей, которые невозможно контролировать.

• Он не сохраняет относительный порядок детей с разными именами.

• Он ограничен (с бэкэндом XML:: SAX) или нет (с поддержкой XML:: Parser) для пространств имен и префиксов пространства имен.

• Он не может обрабатывать элементы как с текстом, так и с элементами в виде дочерних элементов (что означает, что он не может обрабатывать XHTML, среди прочих).

• Некоторые серверы (например, XML:: Parser) не могут обрабатывать кодировки, не основанные на ASCII (например, UTF-16le).

• Элемент не может иметь дочерний элемент и атрибут с тем же именем.

• Он не может создавать XML-документы с комментариями.

Игнорируя основные проблемы, о которых упоминалось ранее, XML:: Simple все еще можно использовать с этими ограничениями. Но почему вы столкнулись с проблемой проверки того, может ли XML:: Simple обрабатывать ваш формат документа и рискнуть переключиться на другой парсер позже? Вы можете просто использовать лучший парсер для всех ваших документов с самого начала.

Мало того, что некоторые другие синтаксические анализаторы не подвергают вас этим ограничениям, они дополнительно предоставляют множество других полезных функций. Ниже перечислены некоторые функции, которые могут иметь, что XML:: Simple не делает:

• Скорость. XML:: Simple чрезвычайно медленный, особенно если вы используете бэкэнд, отличный от XML:: Parser. Я говорю на порядки медленнее, чем другие парсеры.

• Селектора XPath или аналогичные.

• Поддержка чрезвычайно больших документов.

• Поддержка печати. ​​

Является ли XML:: простым когда-либо полезным?

Единственный формат, для которого XML:: Simple является самым простым, - это тот, где ни один элемент не является обязательным. У меня был опыт работы с бесчисленными форматами XML, и я никогда не сталкивался с таким форматом.

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

Альтернативы

Я использую XML:: LibXML. Это чрезвычайно быстрый, полнофункциональный синтаксический анализатор. Если мне когда-либо понадобилось обрабатывать документы, которые не вписывались в память, я бы использовал XML:: LibXML:: Reader (и его copyCurrentNode(1)) или XML:: Twig (используя twig_roots).

Я не согласен с документами

Я буду возражать и сказать, что XML::Simple - это просто.. просто. И мне всегда было легко и приятно пользоваться. Проверьте его с помощью ввода, который вы получаете. Пока вход не меняется, вы в порядке. Те же люди, которые жалуются на использование XML::Simple, жалуются на использование JSON::Syck для сериализации Moose. Документы ошибочны, поскольку они учитывают правильность эффективности. Если вас беспокоит только следующее, вы хорошо:

• не выбрасывать данные
• построение с предоставленным форматом, а не абстрактная схема

Если вы создаете абстрактный парсер, который не определен приложением, а по спецификации, я бы использовал что-то еще. Я работал в компании один раз, и нам пришлось принять 300 различных схем XML, ни один из которых не имел спецификации. XML::Simple легко выполнил работу. Другие варианты потребовали бы, чтобы мы наняли кого-то, чтобы выполнить работу. Все думают, что XML - это то, что отправлено в жестком всеохватывающем специфицированном формате, так что если вы напишете один парсер, вы добры. Если в этом случае не используется XML::Simple. XML, до JSON, был всего лишь "дампом этого и гуляющего" формата с одного языка на другой. Люди действительно использовали такие вещи, как XML::Dumper. Никто не знал, что вышло. Работа с этим сценарием XML::Simple is greattt! Сэйнские люди все еще сбрасывают JSON без спецификации для достижения того же самого. Это как работает мир.

Хотите прочитать данные и не беспокоиться о формате? Хотите пересечь структуры Perl, а не возможности XML? Перейти XML::Simple.

По расширению...

Аналогично, для большинства приложений JSON::Syck достаточно сбрасывать это и ходить. Хотя, если вы отправляете много людей, я бы предложил вам не использовать сопло для душа и делать спецификацию, на которую вы экспортируете. Но, вы знаете, что.. Когда-нибудь вы получите звонок от кого-то, с кем вы не хотите говорить, кто хочет, чтобы его данные не экспортировались обычно. И вы собираетесь пропустить его через JSON::Syck voodoo и позволить им беспокоиться об этом. Если они хотят XML? Зарядите их еще на 500 долларов и запустите ole XML::Dumper.

Уберите

Он может быть менее совершенным, но XML::Simple эффективен. Каждый час, сэкономленный на этой арене, вы можете потратить на более полезную арену. Это реальное мировоззрение.

Другие ответы

У Look XPath есть некоторые проблемы. Каждый ответ здесь сводится к предпочтению XPath над Perl. Это здорово. Если вы предпочитаете использовать стандартизованный XML-язык для доступа к вашему XML, имейте это в виду!

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

var $xml = [ { foo => 1 } ];  ## Always w/ ForceArray.

var $xml = { foo => 1 };

Получение значения foo здесь в этих двух контекстах может быть сложным. XML::Simple знает это и то, почему вы можете заставить первого. Однако, даже с ForceArray, если элемент отсутствует, вы будете выкидывать ошибку.

var $xml = { bar => [ { foo => 1 } ] };

теперь, если bar не является обязательным, вы получите доступ к нему $xml->{bar}[0]{foo}, а @{$xml->{bar}}[0] выдаст ошибку. Во всяком случае, это просто перл. Это связано с XML::Simple imho. И я признал, что XML::Simple не подходит для построения спецификации. Покажите мне данные, и я могу получить к нему доступ с помощью XML:: Simple.