PHP Geliştiricileri için XML

Bölüm 2. Gelişmiş XML Ayrıştırma Teknikleri

PHP5'te büyük veya karmaşık XML belgelerini ayrıştırma teknikleri

İçerik Serisi:

PHP5, XML ayrıştırma yöntemlerinin çeşitliliğini artırdı. Artık libxml2 kitaplığını temel alan James Clarke'ın Expat SAX ayrıştırıcısı artık tam özellikli tek ayrıştırıcı değil. DOM'yi W3C standardıyla tam uyumlu olarak kullanarak ayrıştırma olanağına zaten aşinayız. Ek özellikler, Bölüm 1'de (bkz.) ele aldığımız SimpleXML ve anlaşılması daha kolay ve SAX'tan daha hızlı çalışan XMLReader tarafından sunulmaktadır. Tüm XML uzantıları artık GNOME projesindeki libxml2 kitaplığına dayanmaktadır. Bu birleşik kitaplık, farklı uzantıların birbirleriyle etkileşime girmesine izin verir. Bu makale, büyük veya karmaşık XML belgelerine odaklanarak PHP5'teki XML ayrıştırma tekniklerini tartışır. Ayrıştırma tekniklerini ve varsa farklı XML belgelerini ayrıştırmak için en iyi yöntemin seçim kriterlerini açıklar.

SimpleXML

Bu dizinin ilk makalesi, XML hakkında önemli bilgiler ve uygulama programlama arabirimlerini (API'ler) kullanmaya başlama yönergelerini içerir. Belge Nesne Modeli (DOM) ile birlikte SimpleXML'nin basit, tahmin edilebilir ve nispeten kompakt XML belgeleriyle ilgilenen geliştiriciler için ideal bir araç olduğunu gösterdi.

XML ve PHP5

Genişletilebilir İşaretleme Dili (XML), hem biçimlendirme dili hem de metin veri depolama biçimi olarak adlandırılabilir; ağaç yapılarını tanımlamak ve bunları bilgiye uygulamak için metinsel araçlar sağlar.

PHP5, XML ayrıştırma için hem yeni hem de yeniden yazılmış uzantılara sahiptir. SimpleXML, DOM ve XSLT işlemcisi, tüm XML belgesini belleğe yükler. XML için basit API (SAX) ve XMLReader, bir XML belgesini ayrıştıran ayrıştırıcılardır. SAX, PHP4'tekiyle aynı şekilde çalışır, ancak artık expat yerine libxml2'ye dayanmaktadır. Diğer dillerden DOM'a aşina olanlar, PHP5'te çalışmayı PHP'nin önceki sürümlerine göre daha kolay bulacaktır.

XML ayrıştırmanın temelleri

XML'i ayrıştırmanın iki ana yolu vardır: ağaç tabanlı ve akış tabanlı. Ağaç yöntemi, tüm XML belgesini belleğe yükler. Dosyanın ağaç benzeri yapısı, belge öğelerine ve XML düzenlemeye keyfi erişime izin verir. DOM ve SimpleXML, ağaç ayrıştırıcı örnekleridir. Bir ağaç yapısını farklı fakat etkileşimli formatlarda bellekte saklarlar. Akış ayrıştırma ile tüm belge belleğe yüklenmez. Bu durumda, "akış" terimi, ses akışını tanımlarken olduğu gibi kullanılır. Aynısı aynı nedenlerle olur: bant genişliği ve bellek kaynaklarından tasarruf etmek için veriler küçük parçalar halinde alınır. Akış ayrıştırma ile yalnızca o anda ayrıştırılmakta olan düğüm kullanılabilir ve tüm XML belgesinin düzenlenmesi imkansızdır. XMLReader ve SAX, akış ayrıştırıcılarının örnekleridir.

Ağaç Ayrıştırıcıları

Ağaç ayrıştırıcıları tüm belgeyi belleğe yükler, böylece kök bir ağacın gövdesine benzer ve tüm çocuklar, torunlar ve daha uzak torunlar ve nitelikler dallar olarak işlev görür. En ünlü ağaç ayrıştırıcı DOM'dur. En basiti SimpleXML'dir. İkisini de düşünün.

DOM ile ayrıştırma

W3C'ye göre DOM standardı "... programların ve komut dosyalarının belgelere dinamik olarak erişmesine ve içeriklerini, yapılarını ve stillerini düzenlemesine izin veren platformdan ve programlama dilinden bağımsız bir arabirimdir." GNOME projesinin libxml2 kitaplığı, tüm yöntemleriyle birlikte DOM'yi C'de uygular. Tüm PHP5 XML uzantıları libxml2'ye dayalı olduğundan, birbirleriyle tamamen etkileşime girerler. Bu etkileşim, işlevlerini büyük ölçüde geliştirir. Örneğin, bir akış XMLReader ayrıştırıcısı kullanarak bir öğeyi alabilir, onu DOM'a aktarabilir ve verileri XPath kullanarak alabilirsiniz. Bu esneklik kanıtlanmıştır.

DOM ayrıştırıcısı ağaç yöntemine göre çalışır. Bellekteki yapısı orijinal XML belgesine benzediği için anlaşılması ve kullanılması kolaydır. DOM, XML dosyasındaki öğe ağacıyla tamamen aynı olan bir nesne ağacı oluşturarak bilgileri uygulamaya iletir, böylece her XML öğesi o ağaçta bir düğüm görevi görür. DOM, diğer programlama dilleriyle tutarlılığı nedeniyle geliştirici tarafından kabul görmüş bir W3C standardıdır. DOM, tüm belgenin bir ağacını oluşturduğundan, çok fazla bellek ve çok fazla işlemci kaynağı tüketir.

DOM iş başında

Bazı sınırlamalardan dolayı tek bir ayrıştırıcı seçmek zorunda kalırsanız, en azından esnekliği nedeniyle DOM'u seçmek mantıklıdır. DOM, XML belgelerini oluşturmanıza, değiştirmenize, erişmenize, doğrulamanıza ve dönüştürmenize olanak tanır. Ancak, tüm DOM yöntemleri ve özellikleri kullanılabilir.Çoğu ikinci düzey DOM yöntemi, uygun özellik desteği ile uygulanır. DOM'nin aşırı esnekliği nedeniyle, ayrıştırılmış belgeler son derece karmaşık olabilir. Ancak, esnekliğin tüm belgeyi belleğe yükleme pahasına geldiğini unutmayın.

Liste 1'deki örnek, belgeyi ayrıştırmak ve öğeyi getElementById işlevini kullanarak almak için DOM'yi kullanır. Kimliğe başvurmadan önce, validateOnParse = true ayarlanarak belgenin doğrulanması gerekir. DOM standardına göre bu, ID özniteliğini bir ID tipi olarak tanımlayan bir DTD gerektirir.

Liste 1. DOM'yi basit bir belgeyle kullanma

validateOnParse = doğru; $ doc-> Yükle ("basic.xml"); echo "Kimliği myelement olan öğe:". $ doc-> getElementById ("myelement") -> tagName. "\ n"; ?>

getElementsByTagName () işlevi, belirtilen etiket adına sahip öğeleri içeren DOMNodeList sınıfının yeni bir örneğini döndürür. Tabii ki, listeyi kaydırmanız gerekiyor. getElementsByTagName () işlevi tarafından döndürülen NodeList ile çalışırken belge yapısını değiştirmek, birlikte çalıştığınız NodeList'i etkiler (bkz. Liste 2). Bu durumda doğrulama gerekli değildir.

Liste 2. DOM getElementsByTagName yöntemi

DOMDocument (DOMNodeList getElementsByTagName (dize adı);)

Liste 3'teki örnek, XPath ile DOM'yi kullanır.

Liste 3. DOM'u kullanma ve XPath ile ayrıştırma

koruWhiteSpace = yanlış; $ doc-> Yükle ("book.xml"); $ xpath = yeni DOMXPath ($ doc); // Kökten başladık $ sorgusu = "// kitap / bölüm / para / gayri resmi / tgroup / tbody / satır / giriş [. =" En "]"; $ girdileri = $ xpath-> sorgusu ($ sorgusu); foreach ($ giriş olarak $ girişler) (echo "Bulundu ($ giriş-> öncekiKardeş-> öncekiKardeş-> düğümDeğeri),". "tarafından ($ giriş-> öncekiKardeş-> nodeValue) \ n";)?>

DOM hakkında tüm bu güzel şeyleri söyledikten sonra, DOM ile ne yapılmaması gerektiğine dair bir örnek vermek istiyorum ve ardından bir sonraki örnekte, onu nasıl aşacağınızı göstermek istiyorum. Liste 4, yalnızca DomXpath kullanarak tek bir öznitelikten veri çıkarmak için DOM'a büyük bir dosyanın yüklenmesini gösterir.

Liste 4. Büyük bir XML belgesiyle çalışırken DOM'nin XPath ile yanlış kullanımı

yükle ("tooBig.xml"); $ xp = yeni DomXPath ($ dom); $ sonuç = $ xp-> sorgu ("/ blog / girişler / giriş [@ID = 5225] / başlık"); $ sonuç-> item (0) -> nodeValue yazdırın "\ n"; ?>

Son örnek (Liste 5), DOM'yi XPath ile aynı şekilde uygular, ancak verinin genişlet () yöntemi kullanılarak XMLReader'a her seferinde bir öğe iletilmesi dışında. Bu, XMLReader tarafından geçirilen düğümü bir DOMElement'e dönüştürür.

Liste 5. Büyük bir XML belgesiyle çalışırken DOM'nin XPath ile doğru kullanımı

aç ("tooBig.xml"); while ($ okuyucu-> okuma ()) (switch ($ okuyucu-> nodeType) (durum (XMLREADER :: ELEMENT): if ($ okuyucu-> localName == "giriş") (if ($ okuyucu-> getAttribute ( "ID") == 5225) ($ düğüm = $ okuyucu-> genişlet (); $ dom = yeni DomDocument (); $ n = $ dom-> importNode ($ düğüm, true); $ dom-> appendChild ($ n); $ xp = yeni DomXpath ($ dom); $ res = $ xp-> sorgu ("/ giriş / başlık"); echo $ res-> item (0) -> nodeValue;))))?>

SimpleXML ile ayrıştırma

SimpleXML uzantısı, bir XML belgesini ayrıştırmanın başka bir yoludur. SimpleXML uzantısı PHP5 gerektirir ve yerel XPath desteğini kullanır. SimpleXML, karmaşık olmayan XML verileriyle en iyi şekilde çalışır. XML belgesi çok karmaşık, derin ve karışık bir içeriğe sahip olmadığı sürece, adından da anlaşılacağı gibi SimpleXML'nin kullanımı DOM'dan daha kolaydır. Bilinen bir belge yapısıyla çalışıyorsanız sezgiseldir.

SimpleXML iş başında

SimpleXML, DOM'nin birçok avantajına sahiptir ve programlanması daha kolaydır. XML ağacına kolay erişim sağlar, yerleşik doğrulama ve XPath desteğine sahiptir ve XML belgelerinin okunması ve yazılması için destek sağlamak için DOM ile etkileşime girer. SimpleXML tarafından ayrıştırılan belgelerin yazılması kolay ve hızlıdır. Ancak, DOM'da olduğu gibi SimpleXML'nin basitliğinin ve esnekliğinin, tüm XML belgesini belleğe yükleme pahasına geldiğini unutmayın.

Liste 6'daki kod, örnek XML belgesinden öğede bulunan işin planını çıkarır.

Listeleme 6. Bir metin parçasının alınması

Cliff, Güzel Kadınla tanışır. Sadık Köpek uyur, ancak postacıya havlamak için uyanır. 4 9 XML; ?>kitap-> arsa; // "Cliff, Güzel Kadınla tanışıyor. ..."?>

Öte yandan, çok satırlı bir adres çıkarmanız gerekebilir. Aynı ebeveynin birden çok çocuğu olduğunda, olağan yineleme tekniği kullanılır. Liste 7, bu işlevi göstermektedir.

Liste 7. Bir öğenin birden çok örneğini alma

Cliff, Güzel Kadınla tanışır. 4 9 22 3 XML; ?> $ kitap olarak kitap) (echo $ kitap-> arsa, "
"; } ?

SimpleXML, eleman adlarını ve değerlerini okumaya ek olarak, eleman niteliklerine erişebilir. Liste 8, bir öğenin niteliklerine atıfta bulunur; bu, bir dizinin öğelerine erişimle aynı şekilde yapılır.

Liste 8. SimpleXML erişim elemanı özniteliklerinin gösterimi

Cliff, Güzel Kadınla tanışır. 4 9 Muhabir ödüllü bir hikaye icat eder. 22 3 XML; ?>kitap-> başarı olarak $ başarı) (switch ((string) $ başarı ["type")) (case "en çok satanlar": yankı $ başarı, "en çok satanlar listesinde aylarca
"; ara; durum" kitap kulüpleri ": yankı $ başarı," kitap kulübü listeleri
"; ara;))?>

Son örnekte (bkz. Liste 9), SimpleXML ve DOM, XMLReader uzantısıyla birlikte kullanılır. XMLReader kullanılarak veriler, genişlet () yöntemi kullanılarak her seferinde bir öğe olacak şekilde sıralı olarak aktarılır. Bu yöntemi kullanarak, XMLReader tarafından geçirilen düğüm bir DOMElement'e dönüştürülebilir ve ardından SimpleXML'ye geçirilebilir.

Liste 9. Büyük Bir XML Belgesini Ayrıştırmak için SimpleXML ve DOM'yi XMLReader Uzantısıyla Kullanma

aç ("tooBig.xml"); while ($ okuyucu-> okuma ()) (switch ($ okuyucu-> nodeType) (durum (XMLREADER :: ELEMENT): if ($ okuyucu-> localName == "giriş") (if ($ okuyucu-> getAttribute ( "ID") == 5225) ($ düğüm = $ okuyucu-> genişlet (); $ dom = yeni DomDocument (); $ n = $ dom-> importNode ($ düğüm, true); $ dom-> appendChild ($ n); $ sxe = simplexml_import_dom ($ n); echo $ sxe-> başlık;))))?>

Akış ayrıştırıcıları

Akış ayrıştırıcıları, akıştaki ses akışı gibi XML'i bir akışta ayrıştırdıkları için bu şekilde adlandırılır. Zamanın her anında ayrı bir düğümle çalışırlar ve bittiğinde varlığını tamamen unuturlar. XMLReader bir çekme ayrıştırıcısıdır ve bunun için programlama, bir imleç kullanarak bir veritabanı tablosundaki bir sorgunun sonucunu almaya çok benzer. Bu, bilinmeyen veya öngörülemeyen XML dosyalarıyla çalışmayı kolaylaştırır.

XMLReader ile ayrıştırma

XMLReader, genellikle imleç veya çekme ayrıştırıcısı olarak adlandırılan türden bir akış ayrıştırıcısıdır. XMLReader, talep üzerine bir XML belgesinden bilgi çeker. C# XmlTextReader'dan türetilen bir API'ye dayanmaktadır. PHP 5.1'de varsayılan olarak etkinleştirilir ve etkinleştirilir ve libxml2 kitaplığına dayalıdır. PHP 5.1'den önce, XMLReader uzantısı varsayılan olarak etkinleştirilmiyordu, ancak PECL'de mevcuttu (bkz.). XMLReader, DTD ve Relaxed NG dahil olmak üzere ad alanlarını ve doğrulamayı destekler.

XMLReader iş başında

Bir akış ayrıştırıcısı olarak XMLReader, büyük XML belgeleriyle çalışmak için çok uygundur; içinde programlama, SAX'tan çok daha kolay ve genellikle daha hızlıdır. Bu, en iyi akış ayrıştırıcısıdır.

Aşağıdaki örnek (Liste 10), bir XMLReader kullanarak büyük bir XML belgesini ayrıştırır.

Liste 10. Büyük bir XML dosyası içeren XMLReader

aç ("tooBig.xml"); while ($ okuyucu-> okuma ()) (switch ($ okuyucu-> nodeType) (durum (XMLREADER :: ELEMENT): if ($ okuyucu-> localName == "giriş") (if ($ okuyucu-> getAttribute ( "ID") == 5225) (while ($ okuyucu-> okuma ()) (if ($ okuyucu-> nodeType == XMLREADER :: ELEMENT) (if ($ okuyucu-> localName == "başlık") ($ okuyucu-> oku (); echo $ okuyucu-> değer; mola;) if ($ okuyucu-> localName == "giriş") (ara;)))))))?>

SAX ile ayrıştırma

Simple API for XML (SAX) bir akış ayrıştırıcısıdır. Olaylar okunabilir bir XML belgesiyle ilişkilendirilir, bu nedenle SAX bir geri arama stilinde programlanır. Öğe etiketlerini, varlıkları ve ayrıştırma hatalarını açma ve kapatma olayları vardır. XMLReader yerine SAX ayrıştırıcısını kullanmanın ana nedeni, SAX ayrıştırıcısının bazen daha verimli olması ve genellikle daha iyi bilinmesidir. Önemli bir dezavantaj, SAX ayrıştırıcısının kodunun XMLReader'dan daha karmaşık ve yazılmasının daha zor olmasıdır.

SAX iş başında

SAX, PHP4'te XML ile çalışmış olanlara aşina olmalıdır ve PHP5'teki SAX uzantısı, alıştıkları sürümle uyumludur. Bir akış ayrıştırıcısı olduğu için büyük dosyaları iyi işler, ancak XMLReader'dan daha iyi bir seçim değildir.

Liste 11, bir SAX ayrıştırıcısının büyük bir XML belgesini nasıl ayrıştırdığına dair bir örnek gösterir.

Liste 11. Büyük bir XML dosyasını ayrıştırmak için SAX kullanma

isabet = doğru; ) else ($ this-> hit = false;)) if ($ this-> hit && $ elementname == "title") ($ this-> titleHit = true;) else ($ this-> titleHit = false;) ) // her öğenin sonu için geri çağrı function endElement ($ parser_object, $ elementname) () // her öğenin içeriği için geri çağrı function contentHandler ($ parser_object, $ data) (if ($ this-> titleHit) (echo kırp ( $ veri). "
";))) // Tüm değerler ayarlandığında // ve dosya açık olduğunda ayrıştırmayı başlatma işlevi doParse ($ parser_object) (if (! ($ Fp = fopen (" tooBig.xml "," r ") ))); // verilerde gezinirken while ($ data = fread ($ fp, 4096)) (// parse xml_parse ($ parser_object, $ data, feof ($ fp)));)) $ SaxObject = new SaxClass (); $ parser_object = xml_parser_create (); xml_set_object ($ parser_object, $ SaxObject); // Veri durumunu değiştirmeyin xml_parser_set_option ($ parser_object, XML_OPTION_CASE_FOLDING, false); xml_set_element_handler, "$ parser_object"); ); doParse ($ parser_object);?>

Çözüm

PHP5, çok çeşitli ayrıştırma yöntemleri sunar. Artık W3C standardıyla tamamen uyumlu olan DOM ayrıştırma, karmaşık ancak nispeten küçük belgeler için uygun, tanıdık bir seçenektir. SimpleXML, basit, küçük belgelerle çalışmanın yoludur ve SAX'tan daha hafif ve daha hızlı olan XMLReader akış ayrıştırıcısı çok büyük belgeler için tercih edilir.

XML'i ayrıştırmak, esasen bir XML belgesinde gezinmek ve uygun verileri döndürmek anlamına gelir. Giderek artan sayıda web hizmeti verileri JSON biçiminde döndürürken, çoğu hala XML kullanıyor, bu nedenle mevcut tüm API'leri kullanmak istiyorsanız XML ayrıştırmada uzmanlaşmak önemlidir.

Uzantıyı kullanma SimpleXML PHP 5.0'da eklenen PHP'de XML ile çalışmak çok kolay ve anlaşılır. Bu yazıda size bunu nasıl yapacağınızı göstereceğim.

Kullanım temelleri

Aşağıdaki örnekle başlayalım diller.xml:

>

> 1972>
> Dennis Ritchie >
>

> 1995>
> Rasmus Lerdorf >
>

> 1995>
> James kaz yavrusu >
>
>

Bu XML belgesi, her dil hakkında bazı bilgiler içeren bir programlama dilleri listesi içerir: uygulama yılı ve yaratıcısının adı.

İlk adım, XML'i işlevleri kullanarak yüklemektir. simplexml_load_file() veya simplexml_load_string()... Fonksiyonların adından da anlaşılacağı gibi, birincisi bir dosyadan XML yükler ve ikincisi bir dizgeden XML yükler.

Her iki işlev de tüm DOM ağacını belleğe okur ve bir nesne döndürür SimpleXMLEeleman... Yukarıdaki örnekte nesne $ dilleri değişkeninde saklanmaktadır. fonksiyonları kullanabilirsiniz var_dump() veya print_r()İsterseniz, döndürülen nesneyle ilgili ayrıntıları almak için.

SimpleXMLElement Nesnesi
[lang] => Dizi
[0] => SimpleXMLElement Nesnesi
[@ nitelikler] => Dizi
[isim] => C
[göründü] => 1972
[yaratıcı] => Dennis Ritchie
[1] => SimpleXMLElement Nesnesi
[@ nitelikler] => Dizi
[isim] => PHP
[göründü] => 1995
[yaratıcı] => Rasmus Lerdorf
[2] => SimpleXMLElement Nesnesi
[@ nitelikler] => Dizi
[isim] => Java
[göründü] => 1995
[yaratıcı] => James Gosling
)
)

Bu XML, kök öğeyi içerir Diller, içinde üç element bulunan dil. Dizinin her elemanı bir elemana karşılık gelir. dil XML belgesinde.

Operatörü kullanarak bir nesnenin özelliklerine erişebilirsiniz. -> ... Örneğin, $ diller-> lang, size ilk öğeyle eşleşen bir SimpleXMLElement nesnesi döndürür. dil... Bu nesne iki özellik içerir: göründü ve oluşturucu.

$ diller -> lang [0] -> göründü;
$ diller -> lang [0] -> yaratıcı;

Gibi standart bir döngü kullanarak dillerin bir listesini görüntülemek ve özelliklerini göstermek çok kolaydır. her biri için.

foreach ($ dil -> lang as $ lang) (
yazdır (
"" ,
$ lang ["ad"],
$ lang -> göründü,
$ lang -> yaratıcı
) ;
}

Dil adını almak için lang öğesinin öznitelik adına nasıl eriştiğime dikkat edin. Bu şekilde, SimpleXMLElement nesnesi olarak temsil edilen bir elemanın herhangi bir niteliğine erişebilirsiniz.

Ad alanlarıyla çalışma

Çeşitli web servislerinin XML'i ile çalışırken, element ad alanları ile birden fazla karşılaşacaksınız. hadi değiştirelim diller.xml ad alanını kullanma örneğini göstermek için:

xmlns: dc =>

> 1972>
> Dennis Ritchie >
>

> 1995>
> Rasmus Lerdorf >
>

> 1995>
> James kaz yavrusu >
>
>

şimdi eleman yaratıcı ad alanına yerleştirilmiş DC bu da http://purl.org/dc/elements/1.1/ adresini gösterir. Önceki kodumuzu kullanarak dil oluşturucuları yazdırmaya çalışırsanız, çalışmaz. Elementlerin ad alanlarını okumak için aşağıdaki yaklaşımlardan birini kullanmanız gerekir.

İlk yaklaşım, öğenin ad alanına atıfta bulunurken URI'leri doğrudan kodda kullanmaktır. Aşağıdaki örnek bunun nasıl yapıldığını gösterir:

$ dc = $ diller -> dil [1] -> çocuklar ( "http://purl.org/dc/elements/1.1/") ;
echo $dc -> yaratıcı;

Yöntem çocuklar () bir ad alanı alır ve bir önekle başlayan alt öğeleri döndürür. İki argüman alır, birincisi bir XML ad alanı ve ikinci isteğe bağlı argüman, varsayılan olarak YANLIŞ... İkinci bağımsız değişken DOĞRU ise, ad alanı bir önek olarak ele alınacaktır. YANLIŞ ise, ad alanı bir URL ad alanı olarak değerlendirilir.

İkinci yaklaşım, URI adlarını belgeden okumak ve bunları öğe ad alanına atıfta bulunurken kullanmaktır. URI'yi sabit kodlamanız gerekmediği için öğelere erişmenin en iyi yolu budur.

$ ad alanları = $ diller -> getNamespaces (true);
$ dc = $ diller -> dil [1] -> çocuklar ($ ad alanları ["dc"]);

echo $dc -> yaratıcı;

Yöntem GetNamespaces () bir dizi önek adı ve bunlarla ilişkili URI'leri döndürür. Varsayılan olarak ek bir parametre alır. YANLIŞ... gibi ayarlarsanız doğru daha sonra bu yöntem, üst ve alt düğümlerde kullanılan adları döndürür. Aksi takdirde, yalnızca üst düğümde kullanılan ad alanlarını bulur.

Artık diller listesinde aşağıdaki gibi adım atabilirsiniz:

$ diller = simplexml_load_file ("languages.xml");
$ ns = $ diller -> getNamespaces (doğru);

foreach ($ dil -> lang as $ lang) (
$ dc = $ lang -> alt ($ ns ["dc"]);
yazdır (
"

% s, % d içinde göründü ve % s tarafından oluşturuldu.

" ,
$ lang ["ad"],
$ lang -> göründü,
$ dc -> yaratıcı
) ;
}

Örnek Olay - Bir YouTube Video Kanalını Ayrıştırma

Bir YouTube kanalından RSS beslemesi alan ve bu kanaldaki tüm videoların bağlantılarını gösteren bir örneğe bakalım. Bunu yapmak için aşağıdaki adresle iletişime geçmeniz gerekir:

http://gdata.youtube.com/feeds/api/users/xxx/uploads

URL, verilen kanaldaki en son videoların listesini XML biçiminde döndürür. XML'i ayrıştıracağız ve her video için aşağıdaki bilgileri alacağız:

• videoya bağlantı
• Minyatür
• İsim

XML'i bulup yükleyerek başlayacağız:

$ kanal = "KanalAdı";
$ url = "http://gdata.youtube.com/feeds/api/users/"... $ kanal. "/ yüklemeler";
$ xml = file_get_contents ($ url);

$ besleme = simplexml_load_string ($ xml);
$ ns = $ besleme -> getNameSpaces (doğru);

XML beslemesine bakarsanız, orada birkaç öğe olduğunu görebilirsiniz. varlık, her biri bir kanaldan belirli bir video hakkında ayrıntılı bilgi depolar. Ancak yalnızca küçük resimler, video URL'si ve başlık kullanıyoruz. Bu üç öğe, öğenin torunlarıdır. grup hangi sırayla, bir çocuğu giriş:

>
…
>
…


Başlık ... >
…
>
…
>

Sadece tüm unsurları gözden geçireceğiz. giriş ve her biri için gerekli bilgileri çıkarıyoruz. Bunu not et oyuncu, küçük resim ve Başlık medya ad alanındadır. Bu nedenle, önceki örnekte olduğu gibi devam etmeliyiz. İsimleri belgeden alırız ve elementlere atıfta bulunurken isim alanını kullanırız.

foreach ($ feed -> $ giriş olarak giriş) (
$ grup = $ giriş -> çocuklar ($ ns ["medya"]);
$ grup = $ grup -> grup;
$ küçük resim_attrs = $ grup -> küçük resim [1] -> nitelikler ();
$ resim = $ küçük resim_attrs ["url"];
$ oyuncu = $ grup -> oyuncu -> nitelikler ();
$ link = $ oyuncu ["url"];
$ başlık = $ grup -> başlık;
yazdır ( "

" ,
$ oyuncu, $ resim, $ başlık);
}

Çözüm

Artık nasıl kullanılacağını bildiğine göre SimpleXML XML verilerini ayrıştırmak için farklı API'lerle farklı XML akışlarını ayrıştırarak becerilerinizi geliştirebilirsiniz. Ancak SimpleXML'nin tüm DOM'yi belleğe okuduğunu unutmamak önemlidir, bu nedenle büyük bir veri kümesini ayrıştırıyorsanız belleğiniz tükenebilir. SimpleXML hakkında daha fazla bilgi edinmek için belgeleri okuyun.

Herhangi bir sorunuz varsa, uygulamamızı kullanmanızı öneririz.

Şimdi XML ile çalışmayı öğreneceğiz. XML, siteler arasında veri alışverişi için bir biçimdir. XML'in kendi etiketlerine ve niteliklerine izin vermesi dışında HTML'ye çok benzer.

Ayrıştırırken neden XML'e ihtiyacınız var? Bazen, ayrıştırmanız gereken sitenin, istediğinizi çok fazla zorlamadan alabileceğiniz bir API'si vardır. Bu nedenle, sadece bir ipucu - siteyi ayrıştırmadan önce bir API'si olup olmadığını kontrol edin.

API nedir? Bu, bu siteye istek gönderebileceğiniz ve istediğiniz yanıtı alabileceğiniz bir dizi işlevdir. Bu yanıt genellikle XML biçiminde gelir. O halde onu incelemeye başlayalım.

PHP'de XML ile Çalışmak

Diyelim ki XML'iniz var. Bir dizede olabilir veya bir dosyada saklanabilir veya istek üzerine belirli bir URL'ye döndürülebilir.

XML'in bir dizgede saklanmasına izin verin. Bu durumda, bu satırdan kullanarak bir nesne oluşturmanız gerekir. yeni SimpleXMLElement:

$str = " Kolya 25 1000 "; $ xml = yeni SimpleXMLElement ($ str);

Şimdi bir değişkenimiz var $ xml ayrıştırılmış XML içeren bir nesne depolanır. Bu nesnenin özelliklerine erişerek XML etiketlerinin içeriğine erişebilirsiniz. Tam olarak nasıl - biraz aşağıda analiz edeceğiz.

XML bir dosyada saklanıyorsa veya bir URL'ye erişilerek döndürülüyorsa (ki bu genellikle böyledir), işlevi kullanmanız gerekir. simplexml_load_file aynı nesneyi yapan $ xml:

Kolya 25 1000

$ xml = simplexml_load_file (dosya veya url yolu);

nasıl çalışılır

Aşağıdaki örneklerde, XML'imiz bir dosyada veya URL'de saklanır.

Aşağıdaki XML verilsin:

Kolya 25 1000

Çalışanın adını, yaşını ve maaşını alalım:

$ xml = simplexml_load_file (dosya veya url yolu); echo $xml-> isim; // "Kolya" yazdırır echo $ xml-> age; // 25 echo $ xml-> maaş yazdırır; // 1000 yazdıracak

Gördüğünüz gibi $ xml nesnesi, etiketlere karşılık gelen özelliklere sahiptir.

etiketi olduğunu fark etmişsinizdir. adresin hiçbir yerinde görünmüyor. Bunun nedeni kök etiket olmasıdır. Yeniden adlandırabilirsiniz, örneğin - ve hiçbir şey değişmeyecek:

Kolya 25 1000

$ xml = simplexml_load_file (dosya veya url yolu); echo $xml-> isim; // "Kolya" yazdırır echo $ xml-> age; // 25 echo $ xml-> maaş yazdırır; // 1000 yazdıracak

Tıpkı bir etiket gibi, XML'de yalnızca bir kök etiket olabilir. normal HTML'de.

XML'imizi biraz değiştirelim:

Kolya 25 1000

Bu durumda, bir çağrı zinciri alacağız:

$ xml = simplexml_load_file (dosya veya url yolu); echo $ xml-> işçi-> isim; // "Kolya" yazdırır echo $ xml-> işçi-> yaş; // 25 echo $ xml-> işçi-> maaş yazdırır; // 1000 yazdıracak

Niteliklerle çalışma

Bazı verilerin özniteliklerde saklanmasına izin verin:

1 numara

$ xml = simplexml_load_file (dosya veya url yolu); echo $ xml-> işçi ["ad"]; // "Kolya" görüntüler echo $ xml-> işçi ["yaş"]; // 25 yazdırır echo $ xml-> işçi ["maaş"]; // 1000 echo $ xml-> işçi yazdırır; // "1 Numarayı" görüntüler

tirelenmiş etiketler

XML'de kısa çizgili etiketlere (ve niteliklere) izin verilir. Bu durumda, bu tür etiketlere şu şekilde erişilir:

Kolya İvanov

$ xml = simplexml_load_file (dosya veya url yolu); echo $ xml-> işçi -> (ad); // "Kolya" yazdırır echo $ xml-> işçi -> (soyadı); // "Ivanov"u görüntüler

Bir döngü üzerinde yineleme

Şimdi bir değil, birkaç çalışanımız olsun. Bu durumda, bir foreach döngüsü kullanarak nesnemizi yineleyebiliriz:

Kolya 25 1000 Vasya 26 2000 Peter 27 3000

$ xml = simplexml_load_file (dosya veya url yolu); foreach ($ işçi olarak $ xml) (echo $ işçi-> isim; // "Kolya", "Vasya", "Petya" yazdırır)

Nesneden normal diziye

Bir nesneyle çalışmak konusunda rahat değilseniz, aşağıdaki akıllı numarayı kullanarak onu normal bir PHP dizisine dönüştürebilirsiniz:

$ xml = simplexml_load_file (dosya veya url yolu); var_dump (json_decode (json_encode ($ xml), doğru));

Daha fazla bilgi

sitemap.xml tabanlı ayrıştırma

Genellikle sitenin bir sitemap.xml dosyası vardır. Bu dosya, arama motorları tarafından indeksleme kolaylığı için sitenin tüm sayfalarına bağlantılar saklar (indeksleme aslında sitenin Yandex ve Google tarafından ayrıştırılmasıdır).

Genel olarak, bu dosyaya neden ihtiyaç duyulduğunu pek umursamamalıyız, asıl mesele şu ki, eğer varsa, sitenin sayfalarına hiçbir akıllı yöntemle tırmanamazsınız, sadece bu dosyayı kullanın.

Bu dosyanın varlığı nasıl kontrol edilir: site.ru sitesini ayrıştıralım, ardından tarayıcıda site.ru/sitemap.xml adresine gidelim - bir şey görürseniz, oradadır ve görmüyorsanız , sonra ne yazık ki.

Bir site haritası varsa, sitenin tüm sayfalarına XML formatında bağlantılar içerir. Sakince bu XML'i alın, ayrıştırın, ihtiyacınız olan sayfalara sizin için uygun olan herhangi bir şekilde bağlantıları ayırın (örneğin, örümcek yönteminde açıklanan URL'yi ayrıştırarak).

Sonuç olarak, ayrıştırma için bir bağlantı listesi alırsınız, onlara gitmeniz ve ihtiyacınız olan içeriği ayrıştırmanız yeterlidir.

Wikipedia'da sitemap.xml cihazı hakkında daha fazla bilgi edinin.

Sonra ne yapacağız:

Aşağıdaki bağlantıdan sorunları çözmeye başlayın: ders için görevler.

Her şeye karar verdiğinizde, yeni bir konuyu incelemeye devam edin.

Son yazıda sizlerle birlikteyiz ve bir sonraki yazıda onu ayrıştıracağımıza söz verdim. Ve bugün sana nasıl yapabileceğini göstereceğim PHP'de XML belgesini ayrıştır.

Son makalede oluşturduğumuz belgeyi ayrıştırmayı ve verileri oradan tarayıcıya çıkarmayı öneriyorum. İşte komut dosyası kodu:

$ dom = yeni domDocument ("1.0", "utf-8"); // utf-8 kodlamasıyla XML belgesi sürüm 1.0 oluşturun
$ dom-> yükle ("users.xml"); // XML belgesini dosyadan DOM nesnesine yükle
$ kök = $ dom-> documentElement; // Kök elemanı al
$ childs = $ root-> childNodes; // Kök elemanın çocuklarını al
/ * Alınan öğeler üzerinde yineleniriz * /
için ($ ben = 0; $ ben< $childs->uzunluk; $ ben ++) (
$ kullanıcı = $ çocuk-> öğe ($ i); // NodeList'ten sonraki öğeyi al
$ lp = $ kullanıcı-> childNodes; // "user" düğümünün çocuklarını al
$ id = $ user-> getAttribute ("id"); // "user" düğümünün "id" özniteliğinin değerini alın
$ oturum açma = $ lp-> item (0) -> nodeValue; // "login" düğümünün değerini al
$ şifre = $ lp-> item (1) -> nodeValue; // "password" düğümünün değerini alın
/ * Alınan verileri yazdır * /
echo "Kimlik: $ kimlik
";
echo "Giriş: $ giriş
";
echo "Şifre: $ şifre
";
Eko "-----------------------
";
}
?>

Bu koddan, sadece anlamamalısınız PHP'de XML belgesi nasıl ayrıştırılır ama aynı zamanda kendimi ayrıştırma işlemi belgenin yapısına bağlıdır... Yani, yapının ne olduğunu bilmelisiniz, aksi takdirde böyle bir belgeyi ayrıştırmak sorunlu olacaktır. Zaten bir kez ana olduğunu yazdım XML'in özelliği, sözdiziminin katı olmasıdır.... Umarım şimdi bunun neden bu kadar önemli olduğunu anlıyorsunuzdur. Bu olmadan " kod katılığı"belgeleri ayrıştırmak son derece zor olurdu ve bu genellikle çok gereklidir. XML dosyası veritabanına sonraki yerleşimleri ile.

Bu makalenin yayınlanmasına yalnızca makalenin yazarının web sitesine bir bağlantı ile izin verilir.

Bu yazıda size büyük bir XML dosyasının nasıl ayrıştırılacağının bir örneğini göstereceğim. Sunucunuz (barındırma), komut dosyasının çalışma süresinde bir artışı yasaklamıyorsa, en az gigabayt ağırlığındaki bir XML dosyasını ayrıştırabilirsiniz, kişisel olarak yalnızca 450 megabayt ağırlığındaki ozon dosyalarını ayrıştırdı.

Büyük XML dosyalarını ayrıştırırken iki sorun vardır:
1. Yeterli bellek yok.
2. Komut dosyasının çalışması için yeterli zaman ayrılmamıştır.

Zamanla ilgili ikinci sorun, sunucu bunu yasaklamıyorsa çözülebilir.
Ancak, kendi sunucunuz hakkında konuşsak bile, bellekle ilgili sorunu çözmek zordur, o zaman 500 megabaytlık dosyaları taşımak çok kolay değildir ve barındırma ve VDS'de belleği artırmak mümkün değildir.

PHP'nin birkaç yerleşik XML işleme seçeneği vardır - SimpleXML, DOM, SAX.
Bu seçeneklerin tümü birçok örnek makalede ayrıntılı olarak verilmiştir, ancak tüm örnekler eksiksiz bir XML belgesiyle çalışmayı göstermektedir.

İşte bir örnek, bir XML dosyasından nesne alma

Şimdi bu nesneyi işleyebilirsiniz, AMA ...
Gördüğünüz gibi, tüm XML dosyası belleğe okunur, ardından her şey bir nesneye ayrıştırılır.
Yani tüm veriler belleğe gider ve ayrılan bellek küçükse komut dosyası durur.

Bu seçenek büyük dosyaları işlemek için uygun değildir, dosyayı satır satır okumanız ve bu verileri sırayla işlemeniz gerekir.
Bu durumda, geçerlilik kontrolü, veriler işlenirken aynı şekilde gerçekleştirilir, bu nedenle, örneğin, geçersiz bir XML dosyası durumunda veritabanına girilen tüm verileri silebilmeniz veya geri alabilmeniz gerekir. dosyadan iki geçiş yapın, önce geçerlilik için okuyun, ardından verileri işlemek için okuyun.

İşte büyük bir XML dosyasını ayrıştırmanın teorik bir örneği.
Bu komut dosyası, dosyadan bir defada bir karakter okur, bu verileri bloklar halinde birleştirir ve XML ayrıştırıcısına gönderir.
Bu yaklaşım hafıza sorununu tamamen çözer ve strese neden olmaz, ancak zamanla sorunu daha da kötüleştirir. Sorunu zaman içinde nasıl çözmeye çalışılır, aşağıda okuyun.

İşlev webi_xml ($ dosyası)
{

########
### verilerle çalışmak için işlev

{
$ verilerini yazdır;
}
############################################

{
$ adını yazdır;
print_r ($ öz);
}

## bitiş etiketi işlevi
fonksiyon endElement ($ ayrıştırıcı, $ isim)
{
$ adını yazdır;
}
############################################

($ xml_parser, "veri");

// dosyayı aç
$ fp = fopen ($ dosya, "r");

$ perviy_vxod = 1; $veri = "";

{

$ simvol = fgetc ($ fp); $ veri = $ simvol;

if ($ simvol! = ">") (devam;)

Eko "

kırmak;
}

$veri = "";
}
fclose ($ fps);

Webi_xml ("1.xml");

?>

Bu örnekte, her şeyi webi_xml() işlevine koydum ve en altta çağrısını görebilirsiniz.
Komut dosyasının kendisi üç ana işlevden oluşur:
1. startElement() etiketinin açılışını yakalayan fonksiyon
2. endElement() etiketinin kapanışını yakalayan bir işlev
3. Ve veri verisi alma işlevi ().

1.xml dosyasının içeriğinin bazı reçeteler olduğunu varsayalım.

< title >basit ekmek
< ingredient amount = "3" unit = "стакан" >Un
< ingredient amount = "0.25" unit = "грамм" >Maya
< ingredient amount = "1.5" unit = "стакан" >Ilık su
< ingredient amount = "1" unit = "чайная ложка" >Tuz
< instructions >
< step > Tüm malzemeleri karıştırıp iyice yoğurun.
< step > Bir bezle örtün ve ılık bir odada bir saat bekletin..
< step > tekrar yoğurun, bir fırın tepsisine koyun ve fırına koyun.
< step > Site sitesini ziyaret edin

Her şeye webi_xml ("1.xml"); ortak işlevini çağırarak başlıyoruz;
Bu fonksiyonda ayrıca, ayrıştırıcı başlar ve tüm etiket adları büyük harfe dönüştürülür, böylece tüm etiketler aynı harfe sahip olur.

$ xml_parser = xml_parser_create();
xml_parser_set_option ($ xml_parser, XML_OPTION_CASE_FOLDING, true);

Şimdi etiketin açılmasını yakalamak, verileri kapatmak ve işlemek için hangi fonksiyonların çalışacağını belirtiyoruz.

xml_set_element_handler ($ xml_parser, "startElement", "endElement");
xml_set_character_data_handler($ xml_parser, "veri");

Ardından, belirtilen dosyanın açılması gelir, dosya üzerinde her seferinde bir karakter yinelenir ve karakter bulunana kadar her karakter dize değişkenine eklenir. > .
Bu, dosyaya ilk erişimse, o zaman dosyanın başında gereksiz olacak her şey silinecek, daha önce olan her şey , bu, XML'in başlaması gereken etikettir.
İlk kez, dize değişkeni dizeyi toplayacak

Ve onu ayrıştırıcıya gönder
xml_parse ($ xml_parser, $ veri, feof ($ fp));
Veriler işlendikten sonra, dizi değişkeni atılır ve diziye veri toplama yeniden başlar ve dizi ikinci kez oluşturulur.

Üçüncüde

Lütfen dize değişkeninin her zaman bitmiş etiket tarafından oluşturulduğuna dikkat edin. > ve örneğin örümceğe veri içeren açık ve kapalı bir etiket göndermek gerekli değildir

Bu işleyici için tam bir bozuk olmayan etiket, en az bir açık etiket alması önemlidir, ancak bir sonraki adımda kapalı bir etiket veya hemen dosyanın 1000 satırını alması önemli değil, asıl şey şudur: etiket kırılmaz, örneğin

le> Basit ekmek
Etiket bozulduğu için işleyiciye bu şekilde veri gönderemezsiniz.
İşleyiciye veri göndermek için kendi yönteminizi geliştirebilirsiniz, örneğin, her biri 1 megabayt veri toplayın ve hızı artırmak için işleyiciye gönderin, yalnızca etiketlerin her zaman tamamlandığından ve verilerin kırılabildiğinden emin olun.

Böylece istediğiniz kısımlarda büyük bir dosyayı işleyiciye gönderebilirsiniz.

Şimdi bu verilerin nasıl işlendiğine ve nasıl elde edileceğine bakalım.

Etiketleri açma işleviyle başlayalım startElement ($ ayrıştırıcı, $ ad, $ öznitelikler)
İşlemin çizgiye ulaştığını varsayalım
< ingredient amount = "3" unit = "стакан" >Un
Ardından, fonksiyonun içinde $ name değişkeni şuna eşit olacaktır: bileşen yani açık etiketin adı (henüz etiketi kapatmaya gelmedi).
Ayrıca, bu durumda, bu $ attrs etiketinin bir dizi özniteliği mevcut olacaktır ve burada veri olacaktır. miktar = "3" ve birim = "cam".

Daha sonra açık etiketin verilerinin fonksiyon ile işlenmesi veri ($ ayrıştırıcı, $ veri)
$ data değişkeni, açılış ve kapanış etiketleri arasındaki her şeyi içerecektir, bizim durumumuzda bu, Un metnidir.

Ve dizgimizin işlenmesi fonksiyon tarafından tamamlanır. endElement ($ ayrıştırıcı, $ ad)
Bu, kapalı etiketin adıdır, bizim durumumuzda $ name eşittir bileşen

Ve ondan sonra, her şey tekrar bir daire içinde gitti.

Yukarıdaki örnek yalnızca XML işleme ilkesini gösterir, ancak gerçek kullanım için iyileştirilmesi gerekir.
Genellikle, veri tabanına veri girmek için büyük XML'i ayrıştırmanız gerekir ve doğru veri işleme için verilerin hangi açık etikete ait olduğunu, hangi etiket yuvalama düzeyini ve hiyerarşide daha yüksek hangi etiketlerin açık olduğunu bilmeniz gerekir. Bu bilgilerle dosyayı sorunsuz bir şekilde doğru bir şekilde işleyebilirsiniz.
Bunu yapmak için, açık etiketler, yuvalama ve veriler hakkında bilgi toplayacak birkaç global değişken girmeniz gerekir.
İşte kullanabileceğiniz bir örnek

İşlev webi_xml ($ dosyası)
{
küresel $ webi_depth; // yuvalama derinliğini izlemek için sayaç
$ webi_depth = 0;
küresel $ webi_tag_open; // şu anda açık olan bir dizi etiket içerecek
$ webi_tag_open = dizi();
global $ webi_data_temp; // bu dizi bir etiketin verilerini içerecek

####################################################
### verilerle çalışmak için işlev
işlev verileri ($ ayrıştırıcı, $ veri)
{
küresel $ webi_depth;
küresel $ webi_tag_open;
global $ webi_data_temp;
// diziye iç içe geçmiş ve şu anda açık olan etiketi gösteren verileri ekleyin
$ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["veri"]. = $ veri;
}
############################################

####################################################
### açılış etiketleri işlevi
function startElement ($ ayrıştırıcı, $ ad, $ attrs)
{
küresel $ webi_depth;
küresel $ webi_tag_open;
global $ webi_data_temp;

// yuvalama düzeyi artık sıfır değilse, bir etiket zaten açıktır
// ve ondan gelen veriler zaten dizide, onu işleyebilirsiniz
if ($ webi_depth)
{

" ;

Yazdır "
" ;
print_r ($ webi_tag_open); // açık etiketler dizisi
Yazdır "

---

" ;

// verileri işledikten sonra, hafızayı boşaltmak için silin
unset ($ GLOBAL ["webi_data_temp"] [$ webi_depth]);
}

// şimdi bir sonraki etiketin açılması başladı ve sonraki adımda daha fazla işlem yapılacak
$ webi_derinliği ++; // yuvalamayı artır

$ webi_tag_open [$ webi_depth] = $ isim; // bilgi dizisine açık etiketi ekleyin
$ webi_data_temp [$ webi_depth] [$ isim] ["attrs"] = $ attrs; // şimdi etiket niteliklerini ekleyin

}
###############################################

#################################################
## bitiş etiketi işlevi
function endElement ($ ayrıştırıcı, $ ad) (
küresel $ webi_depth;
küresel $ webi_tag_open;
global $ webi_data_temp;

// veri işlemenin başladığı yer burasıdır, örneğin, veritabanına ekleme, bir dosyaya kaydetme vb.
// $ webi_tag_open, yuvalama düzeyine göre bir açık etiketler zinciri içerir
// örneğin $ webi_tag_open [$ webi_depth] bilgileri şu anda işlenmekte olan açık etiketin adını içerir
// $ webi_depth etiket yuvalama düzeyi
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"] etiket öznitelikleri dizisi
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"] etiket verileri

"Veri" yazdırın. $ webi_tag_open [$ webi_depth]. "-". ($ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["veri"]). "
" ;
print_r ($ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"]);
Yazdır "
" ;
print_r ($ webi_tag_open);
Yazdır "

---

" ;

Ayarlanmadı ($ GLOBALS ["webi_data_temp"]); // verileri işledikten sonra, etiket kapatıldığı için verilerle birlikte tüm diziyi silin
ayarlanmamış ($ GLOBAL ["webi_tag_open"] [$ webi_depth]); // kapatıldığından beri bu açık etiket hakkındaki bilgileri kaldırın ...

$ webi_depth -; // yuvalamayı azalt
}
############################################

$ xml_parser = xml_parser_create();
xml_parser_set_option ($ xml_parser, XML_OPTION_CASE_FOLDING, true);

// etiketleri açarken ve kapatırken hangi fonksiyonların çalışacağını belirtin
xml_set_element_handler ($ xml_parser, "startElement", "endElement");

// verilerle çalışmak için bir işlev belirtin
xml_set_character_data_handler($ xml_parser, "veri");

// dosyayı aç
$ fp = fopen ($ dosya, "r");

$ perviy_vxod = 1; // ilk dosya girişini kontrol etmek için bayrak
$veri = ""; // burada dosyadan parça parça veri topluyoruz ve xml ayrıştırıcısına gönderiyoruz

// dosyanın sonu bulunana kadar döngü
while (! feof ($ fp) ve $ fp)
{
$ simvol = fgetc ($ fp); // dosyadan bir karakter oku
$ veri = $ simvol; // gönderilecek verilere bu sembolü ekleyin

// karakter bir bitiş etiketi değilse, döngünün başına geri döneriz ve verilere başka bir karakter ekleriz ve bu şekilde bitiş etiketi bulunana kadar devam ederiz.
if ($ simvol! = ">") (devam;)
// bir kapanış etiketi bulunursa, şimdi bu toplanan verileri işlenmek üzere gönderin

// bunun dosyaya ilk giriş olup olmadığını kontrol edin, ardından etiketten önceki her şeyi silin// çünkü bazen XML'in başlangıcından önce çöp bulunabilir (beceriksiz editörler veya dosya başka bir sunucudan bir komut dosyası tarafından alınır)
if ($ perviy_vxod) ($ data = strstr ($ data, "

// şimdi verileri xml ayrıştırıcısına atıyoruz
if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (

// burada geçerlilik için işleyebilir ve hata alabilirsiniz...
// bir hatayla karşılaşıldığında, ayrıştırma durur
Eko "
XML Hatası: ". Xml_error_string (xml_get_error_code ($ xml_parser));
yankı "hatta". xml_get_current_line_number ($ xml_parser);
kırmak;
}

// ayrıştırdıktan sonra, döngünün bir sonraki adımı için toplanan verileri atın.
$veri = "";
}
fclose ($ fps);
xml_parser_free ($ xml_parser);
// global değişkenleri kaldır
unset ($ GLOBAL ["webi_depth"]);
unset ($ GLOBALS ["webi_tag_open"]);
unset ($ GLOBAL ["webi_data_temp"]);

Webi_xml ("1.xml");

?>

Tüm örneğe yorumlar eşlik etti, şimdi test edin ve deneyin.
Lütfen verilerle çalışma işlevinde verilerin bir diziye basitçe eklenmediğini, ancak " kullanılarak eklendiğini unutmayın. .=" veriler tam olarak gelmeyebileceğinden ve basit bir atama yaparsanız, zaman zaman parçalar halinde veri alırsınız.

Pekala, hepsi bu, artık herhangi bir boyuttaki bir dosyayı işlerken yeterli bellek var, ancak betiğin çalışma süresi birkaç şekilde artırılabilir.
Komut dosyasının başında, işlevi ekleyin
set_time_limit (6000);
veya
ini_set ("max_execution_time", "6000");

Veya metni .htaccess dosyanıza ekleyin
php_value max_execution_time 6000

Bu örnekler, betiğin çalışma süresini 6000 saniyeye çıkaracaktır.
Sadece devre dışı modunda bu şekilde süreyi artırabilirsiniz.

Eğer php.ini düzenleme erişiminiz varsa, süreyi şu şekilde artırabilirsiniz:
max_execution_time = 6000

Örneğin hosting masterhost üzerinde, bu yazının yazıldığı sırada, safe mode devre dışı bırakılmış olmasına rağmen script süresini arttırmak yasaktır fakat pro iseniz masterhost üzerinde kendi php derlemenizi yapabilirsiniz fakat bu öyle değil. Bu makalede bunun hakkında.