Penggunaan fungsi XMLPARSER pada PHP

Suatu hari saya mulai mengerjakan ulang sistem pelaporan internal perusahaan saya, tentang struktur umum yang saya tulis belum lama ini. Tanpa membengkokkan hati saya, saya akan mengatakan bahwa saya tumbuh di atas diri saya dalam hal PHP, dan, sebagai hasilnya, saya menyadari bahwa algoritma sistem cukup bengkok bagi saya untuk menulis ulang.

Sebelum ini, dokumen XML diurai menggunakan fungsi yang dipinjam dari PHP 4. Namun, PHP5 memberi dunia hal yang sangat berguna yang disebut SimpleXML. Cara bekerja dengannya akan dibahas hari ini.

Sebaiknya dimulai dengan fakta bahwa SimpleXML adalah plug-in terpisah, dan oleh karena itu harus terhubung terlebih dahulu di server yang digunakan.

Sekarang kita bisa bekerja!

Untuk memproses dokumen, kami menggunakan fungsi simplexml_load_file(). Sebagai parameter, alamat file diteruskan dalam format Bahasa Markup yang Diperluas (XML - K.O. Anda).

Kelebihan dari fungsi ini adalah Anda dapat dengan mudah mentransfer file dari server mana pun. Dengan demikian, kami memiliki kemampuan untuk memproses unggahan xml eksternal (misalnya, Yandex-XML atau umpan RSS pihak ketiga).

Fungsi mengeluarkan array di pintu keluar. Perangkap yang saya temui adalah bahwa XML dapat memiliki struktur yang canggung, dan oleh karena itu saya menyarankan Anda untuk memulai dengan jejak figuratif dan menampilkan larik untuk memahami bagaimana fungsi menanganinya. Setelah itu, Anda dapat mulai memproses data yang diterima.

Sebagai contoh, saya akan mengambil konstruksi sederhana dari sini:

>
>
> PHP: Memperkenalkan Parser >
>
>
> MS. pembuat kode >
> Aktor Onlivia >
>
>
> Bapak. pembuat kode >
> El ActÓ r >
>
> > Bapak. Pengurai > > John doe > > >
>
Jadi itu adalah bahasa. Itu masih bahasa pemrograman. Atau
apakah itu bahasa skrip? Semuanya terungkap dalam film dokumenter ini
seperti film horor.
>
>
> PHP menyelesaikan semua tugas web saya >
>
7>
5>
PG > >
>

Biarkan itu menjadi file export.xml, yang terletak tepat di root server saya, bersama dengan skrip yang memprosesnya.
Array dibangun sesuai dengan struktur elemen DOM dalam dokumen XML. Pemrosesan dimulai dari akar. Untuk mendapatkan nama Ny. Coder, kita harus membangun jalur berikut: $ xml-> film-> film-> karakter-> karakter-> nama.
Harap dicatat bahwa kami memilih nilai tertentu. Di sinilah karakter semacam ini diambil - jangan lupa bahwa kita bekerja dengan array!

Seperti halnya array apa pun, data kami dapat diproses menggunakan loop foreach. Kodenya akan seperti ini:

$xml = simplexml_load_file("ekspor.xml"); // upload file
$ttl = $xml -> film -> film -> judul; // mendapat judul. itu satu, jadi tidak perlu memberi nilai lain

foreach ($ xml -> film -> film -> karakter sebagai $ crc) // dan sekarang mari kita bekerja dalam dinamika
{
// menampilkan nama-nama pahlawan
$ nama = $ crc -> caracter -> nama;
gema (" $ nama
" ) ;
}

Kode ini akan menempatkan teks "PHP: Parser Appearance" pada variabel $ttl, lalu menampilkan nama-nama hero baris demi baris
MS. Koder, Pak. Koder, Pak. Pengurai.

28.3K

Saya telah melihat banyak parser xml, tetapi saya belum menyentuh pemrograman web. Sekarang saya ingin mencari tahu dan belajar dengan Anda cara membuat parser xml sederhana di php.

Untuk apa? Diperlukan!

Tidak, sebenarnya: file xml adalah hal yang sangat berguna. Dan profesional mana pun harus ... tidak, dia tidak boleh, tetapi harus tahu bagaimana bekerja dengan mereka. Apakah kita ingin menjadi profesional? Jika Anda berada di blog saya, maka Anda memiliki keinginan seperti itu.

Kami akan berasumsi bahwa kami tahu apa itu XML dan tidak akan menjelaskannya di sini. Nah, jika kita tidak tahu, maka kita dapat dengan mudah mencari tahu di sini: http://ru.wikipedia.org/wiki/XML

Saat mencari cara untuk mengurai XML di PHP, saya menemukan satu set fungsi sederhana di PHP untuk bekerja dengan file XML yang disebut "Fungsi Parser XML". Parsing dimulai dengan menginisialisasi parser dengan memanggil fungsi xml_parser_create:

$xml_parser = xml_parser_create();

Kemudian kita perlu memberi tahu parser fungsi mana yang akan memproses tag xml yang ditemuinya dan informasi teks dalam proses penguraian. Itu. anda perlu menginstal beberapa penangan:

xml_set_element_handler ($ xml_parser, “startElement”, “endElement”);

Fungsi ini bertanggung jawab untuk mengatur awal elemen dan akhir penangan elemen. Misalnya, jika kombinasi ditemukan dalam teks file xml, maka fungsi startElement akan dipicu saat parser menemukan elemen, dan fungsi endElement saat ditemukan.

Fungsi startElement dan endElement sendiri mengambil beberapa parameter sesuai dengan dokumentasi php:

Tapi bagaimana Anda membaca data dari file? Kami belum melihat parameter tunggal untuk ini di salah satu fungsi! Dan lebih banyak lagi nanti: membaca file adalah tanggung jawab programmer, mis. kita harus menggunakan fungsi standar untuk bekerja dengan file:

Dibuka filenya. Dan sekarang Anda perlu membacanya baris demi baris dan memasukkan baris baca ke fungsi xml_parse:

Kesalahan XML: ".xml_error_string (xml_get_error_code ($ xml_parser)); echo" pada baris ".xml_get_current_line_number ($ xml_parser); break;))?>

Ada dua hal yang sangat penting untuk diperhatikan di sini. Yang pertama adalah bahwa fungsi xml_parse pada parameter ketiga harus melewati tanda membaca baris terakhir (benar - jika baris terakhir, salah - jika tidak). Yang kedua adalah, seperti dalam bisnis apa pun, kita harus berhati-hati terhadap kesalahan di sini. Fungsi xml_get_error_code dan xml_error_string bertanggung jawab untuk ini. Fungsi pertama menerima kode kesalahan, dan yang kedua, berdasarkan kode yang diterima, mengembalikan deskripsi tekstual dari kesalahan. Apa yang akan terjadi sebagai akibat dari kesalahan - kami akan pertimbangkan nanti. Tidak kurang fungsi yang berguna xml_get_current_line_number akan memberi tahu kami nomor baris yang sedang diproses dalam file.

Dan seperti biasa, kita harus melepaskan sumber daya yang ditempati oleh sistem. Untuk mem-parsing XML, ini adalah fungsi xml_parser_free:

xml_parser_free ($ xml_parser);

Di sini, kami telah membahas fungsi utama. Saatnya melihat mereka berlatih. Untuk ini saya membuat file xml dengan struktur yang sangat sederhana:

123
71234567890

Mari kita panggil file ini data.xml dan coba parsing menggunakan kode berikut:

Elemen: $nama
"; // nama elemen $ depth ++; // menambah kedalaman sehingga browser menampilkan indentasi foreach ($ attrs sebagai $ attr => $ value) (echo str_repeat (" ", $ depth * 3); // indentasi // menampilkan atribut nama dan nilainya echo "Attribute:". $attr. "=". $ value."
";)) function endElement ($ parser, $ name) (global $ depth; $ depth--; // kurangi kedalaman) $ depth = 0; $ file =" data.xml "; $ xml_parser = xml_parser_create (); xml_set_element_handler ($ xml_parser, "startElement", "endElement"); if (! ($ fp = fopen ($ file, "r"))) (die ("tidak dapat membuka input XML");) while ($ data = fgets ($ fp)) (if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (gema "
Kesalahan XML: "; echo xml_error_string (xml_get_error_code ($ xml_parser)); echo" pada baris ".xml_get_current_line_number ($ xml_parser); break;)) xml_parser_free ($ xml_parser);?>

Sebagai hasil dari skrip paling sederhana yang kami kembangkan, browser menampilkan informasi berikut di jendelanya:

Elemen: ROOT
Elemen: INFO
Atribut: WHO = milikku
Elemen: ALAMAT

Atribut: KVARTIRA = 12
Atribut: DOM = 15
Elemen: TELEPON

Mari kita coba merusak file XML dengan mengganti tag Pada dan membiarkan tag penutup tetap sama:

Elemen: ROOT
Elemen: INFO
Atribut: WHO = milikku
Elemen: ALAMAT
Atribut: ULICA = jalanku!!
Atribut: KVARTIRA = 12
Atribut: DOM = 15
Elemen: TELEPON

Kesalahan XML: Tag tidak cocok pada baris 5

Wow! Pesan kesalahan berfungsi! Selain itu, mereka cukup informatif.

Eh, saya lupa satu hal lagi... Kami tidak menampilkan teks yang terdapat di dalam alamat dan tag telepon. Kami memperbaiki kekurangan kami - kami menambahkan penangan teks menggunakan fungsi xml_set_character_data_handler:

xml_set_character_data_handler ($ xml_parser, 'stringElement');

Dan tambahkan fungsi handler itu sendiri ke kode.

Pengurai xml adalah program yang mengekstrak dari sumber data format xml data dan simpan atau gunakan untuk tindakan selanjutnya.

Mengapa parser xml diperlukan?

Terutama karena format xml itu sendiri populer di kalangan standar komputer. File XML terlihat seperti ini:

itu. sebenarnya ada tag, ada beberapa aturan yang tag harus saling mengikuti.

Alasan popularitas file xml adalah karena sangat mudah dibaca manusia. Dan fakta bahwa itu relatif mudah ditangani dalam program.

Kekurangan file xml.

Kelemahannya adalah, pertama-tama, sejumlah besar ruang disk yang digunakan data ini. Karena fakta bahwa tag, yang terus-menerus diulang, dengan data dalam jumlah besar, saya mengambil jumlah megabita yang relatif besar, yang hanya perlu diunduh dari sumbernya, dan kemudian diproses. Apakah ada alternatif? Ada, tentu saja, tetapi semua sama, parser xml dan xml saat ini adalah salah satu format paling sederhana dan paling dapat diandalkan dan populer secara teknologi.

Bagaimana parser XML ditulis?

Parser ditulis dalam bahasa pemrograman. Seperti yang mereka katakan, mereka ditulis dalam semua, tetapi tidak lebih. Perlu dipahami bahwa ada bahasa pemrograman yang sudah memiliki pustaka bawaan untuk mem-parsing file xml. Tetapi bagaimanapun juga, bahkan jika tidak ada perpustakaan, Anda selalu dapat menemukan perpustakaan yang cocok untuk kasus ini dan menggunakannya untuk mengekstrak data dari file.

Secara global, ada 2 pendekatan berbeda tentang cara mengurai file xml.

Yang pertama adalah memuat file xml sepenuhnya ke dalam memori dan kemudian melakukan manipulasi ekstraksi data.

Yang kedua adalah opsi streaming. Dalam hal ini, bahasa pemrograman mendefinisikan tag tertentu yang perlu ditanggapi oleh fungsi parser xml yang dihasilkan, dan programmer sendiri yang memutuskan apa yang perlu dilakukan jika tag tertentu ditemukan.

Keuntungan dari pendekatan pertama adalah kecepatan. Segera saya memuat semuanya ke dalam file, lalu dengan cepat menelusuri memori saya dan menemukan apa yang dibutuhkan dan yang paling penting, pemrograman itu mudah. tapi ada Minus dan sangat penting - itu adalah

memori yang besar diperlukan untuk mengoperasikannya. Kadang-kadang, saya bahkan akan mengatakan sering terjadi bahwa tidak mungkin untuk memproses dan mengurai file xml, mis. buat parser xml agar berfungsi dengan benar dengan cara pertama. Mengapa demikian? Yah, misalnya, batasan untuk aplikasi 32-bit di bawah Windows memungkinkan program untuk menempati memori maksimum 2 gigabyte - tidak lebih.

Namun, sulit untuk memprogram menggunakan opsi streaming. Kompleksitas dengan ekstraksi yang cukup serius tumbuh secara signifikan, yang karenanya mempengaruhi waktu dan anggaran.

Validitas file xml dan parser.

Semuanya akan baik-baik saja dengan file xml dan parser xml, tetapi ada masalah. Karena fakta bahwa "setiap siswa" dapat membuat file xml, tetapi pada kenyataannya itu (karena banyak kode ditulis oleh anak sekolah, file yang tidak valid muncul, yaitu yang salah. Apa artinya ini dan apa risikonya ? , ini adalah bahwa kadang-kadang tidak mungkin untuk mengurai file yang tidak valid dengan benar. Misalnya, tagnya tidak ditutup seperti yang diharapkan oleh standar, atau misalnya pengkodean tidak diatur dengan benar. Masalah lain adalah jika, misalnya , Anda melakukan parser di .net, lalu Anda dapat membuat apa yang disebut pembungkus , dan hal yang paling menjengkelkan terjadi ketika Anda membuat pembungkus seperti itu, dan kemudian Anda membacanya sebuah file yang dibuat oleh "siswa", tetapi file tersebut tidak valid dan tidak mungkin untuk membacanya. = karena banyak orang membuat file xml tanpa menggunakan perpustakaan standar dan dengan keengganan total untuk semua standar file xml. Sulit untuk menjelaskan kepada pelanggan. Mereka sedang menunggu hasilnya - pengurai xml yang mengubah data dari file asli ke format lain.

Cara membuat parser xml (opsi pertama)

Ada bahasa untuk menanyakan data XML seperti Xpath. Bahasa ini memiliki dua edisi, kami tidak akan membahas secara spesifik setiap versi. Pemahaman yang lebih baik tentang bahasa ini akan menunjukkan contoh bagaimana menggunakannya untuk mengambil data. Sebagai contoh.

// div [@ class = "guru pendukung"] / a

apa yang dilakukan permintaan ini. Dibutuhkan semua tag yang memiliki rentang yang berisi teks catalog.xml?Hid = dan tag ini harus div anak dengan kelas yang sama dengan supcat guru.

Ya, untuk pertama kalinya mungkin tidak cukup jelas, tetapi, bagaimanapun, Anda dapat mengetahuinya jika Anda mau. Titik awal bagi saya adalah http://en.wikipedia.org/wiki/XPath dan saya menyarankan Anda.

publikasi artikel ini hanya diperbolehkan dengan tautan ke situs web penulis artikel

Pada artikel ini, saya akan menunjukkan contoh cara mengurai file XML besar. Jika server Anda (hosting) tidak melarang peningkatan waktu berjalan skrip, maka Anda dapat mengurai file XML dengan berat setidaknya gigabyte, ia secara pribadi hanya mem-parsing file dari ozon seberat 450 megabyte.

Ada dua masalah saat mengurai file XML besar:
1. Memori tidak cukup.
2. Tidak ada cukup waktu yang dialokasikan untuk skrip bekerja.

Masalah kedua dengan waktu dapat diselesaikan jika server tidak melarangnya.
Tetapi masalah dengan memori sulit dipecahkan, bahkan jika kita berbicara tentang server Anda sendiri, maka tidak mudah untuk memindahkan file 500 megabita, dan tidak mungkin menambah memori di hosting dan VDS.

PHP memiliki beberapa opsi pemrosesan XML bawaan - SimpleXML, DOM, SAX.
Semua opsi ini dirinci dalam banyak artikel contoh, tetapi semua contoh menunjukkan bekerja dengan dokumen XML lengkap.

Berikut adalah salah satu contoh, kami mendapatkan objek dari berkas XML

Sekarang Anda dapat memproses objek ini, TAPI ...
Seperti yang Anda lihat, seluruh file XML dibaca ke dalam memori, lalu semuanya diurai menjadi objek.
Artinya, semua data masuk ke memori, dan jika memori yang dialokasikan kecil, maka skrip berhenti.

Untuk diproses file besar opsi ini tidak cocok, Anda perlu membaca file baris demi baris dan memproses data ini secara bergantian.
Dalam hal ini, pemeriksaan validitas dilakukan dengan cara yang sama seperti data diproses, jadi Anda harus dapat melakukan rollback, misalnya, menghapus semua data yang dimasukkan ke dalam database jika file XML tidak valid, atau membuat dua melewati file, pertama membaca untuk validitas, kemudian membaca untuk memproses data.

Berikut adalah contoh teoritis dari parsing file XML besar.
Skrip ini membaca satu karakter pada satu waktu dari file, mengumpulkan data itu ke dalam blok, dan mengirimkannya ke parser XML.
Pendekatan ini benar-benar memecahkan masalah memori dan tidak menyebabkan stres, tetapi memperburuk masalah dari waktu ke waktu. Bagaimana mencoba memecahkan masalah dari waktu ke waktu, baca di bawah ini.

Fungsi webi_xml ($ file)
{

########
### fungsi untuk bekerja dengan data

{
cetak $data;
}
############################################

{
cetak $nama;
print_r ($attrs);
}

## fungsi tag akhir
fungsi endElement ($ parser, $ nama)
{
cetak $nama;
}
############################################

($xml_parser, "data");

// buka filenya
$fp = fopen ($file, "r");

$ perviy_vxod = 1; $data = "";

{

$ simvol = fgetc ($fp); $ data. = $ simvol;

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

$data = "";
}
ftutup ($fp);

Webi_xml("1.xml");

?>

Dalam contoh ini, saya meletakkan semuanya dalam satu fungsi webi_xml () dan di bagian paling bawah Anda dapat melihat panggilannya.
Script itu sendiri terdiri dari tiga fungsi utama:
1. Fungsi yang menangkap pembukaan tag startElement ()
2. Fungsi yang menangkap penutup tag endElement()
3. Dan fungsi penerimaan data data().

Misalkan isi file 1.xml adalah beberapa resep

< title >Roti sederhana
< ingredient amount = "3" unit = "стакан" >Tepung
< ingredient amount = "0.25" unit = "грамм" >Ragi
< ingredient amount = "1.5" unit = "стакан" >Air hangat
< ingredient amount = "1" unit = "чайная ложка" >Garam
< instructions >
< step > Campur semua bahan dan uleni sampai rata.
< step > Tutup dengan kain dan biarkan selama satu jam di ruangan yang hangat..
< step > Uleni lagi, letakkan di atas loyang dan masukkan ke dalam oven.
< step > Kunjungi situs situs

Kita mulai semua dengan memanggil fungsi umum webi_xml ("1.xml");
Selanjutnya dalam fungsi ini, parser dimulai dan semua nama tag diubah menjadi huruf besar sehingga semua tag memiliki huruf besar yang sama.

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

Sekarang kami menunjukkan fungsi mana yang akan berfungsi untuk menangkap pembukaan tag, menutup, dan memproses data

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

Berikutnya adalah pembukaan file yang ditentukan, ulangi file satu karakter pada satu waktu dan tambahkan setiap karakter ke variabel string hingga karakter ditemukan > .
Jika ini adalah akses pertama ke file, maka sepanjang jalan semua yang berlebihan di awal file akan dihapus, semua yang ada sebelumnya , ini adalah tag yang harus dimulai dengan XML.
Untuk pertama kalinya, variabel string akan mengumpulkan string

Dan kirim dia ke parser
xml_parse ($ xml_parser, $ data, feof ($ fp));
Setelah pengolahan data, variabel string dibuang dan pengumpulan data ke dalam string dimulai lagi dan string dibentuk untuk kedua kalinya

Di ketiga
</b><br>pada keempat <br><b>Roti sederhana

Harap dicatat bahwa variabel string selalu dibentuk oleh tag selesai > dan tidak perlu mengirim tag terbuka dan tertutup dengan data ke laba-laba misalnya
Roti sederhana
Penting bagi pawang ini untuk mendapatkan tag yang utuh tidak rusak, setidaknya satu tag terbuka, tetapi pada langkah selanjutnya tag tertutup, atau segera dapatkan 1000 baris file, tidak masalah, yang utama adalah tag tidak pecah, misalnya

le> Roti sederhana
Anda tidak dapat mengirim data ke pawang dengan cara ini, karena tag telah rusak.
Anda dapat membuat metode Anda sendiri untuk mengirim data ke handler, misalnya, mengumpulkan masing-masing 1 megabyte data dan mengirim ke handler untuk meningkatkan kecepatan, pastikan tag selalu lengkap dan data dapat dipecah
Sederhana</b><br><b>roti

Jadi, sebagian, sesuai keinginan, Anda dapat mengirim file besar ke dalam pawang.

Sekarang mari kita lihat bagaimana data ini diproses dan bagaimana mendapatkannya.

Mari kita mulai dengan fungsi tag pembuka startElement ($ parser, $ nama, $ attrs)
Misalkan pemrosesan telah mencapai garis
< ingredient amount = "3" unit = "стакан" >Tepung
Kemudian, di dalam fungsi, variabel $ name akan sama dengan bahan yaitu, nama tag terbuka (belum sampai menutup tag).
Juga, dalam hal ini, array atribut dari tag $ attrs ini akan tersedia, di mana akan ada data jumlah = "3" dan satuan = "gelas".

Setelah itu, pengolahan data tag terbuka dengan fungsi data ($ pengurai, $ data)
Variabel $ data akan berisi semua yang ada di antara tag pembuka dan penutup, dalam kasus kami ini adalah teks Tepung

Dan pemrosesan string kami diselesaikan oleh fungsi endElement ($ parser, $ nama)
Ini adalah nama tag tertutup, dalam kasus kami $ name akan sama dengan bahan

Dan setelah itu, semuanya berjalan dalam lingkaran lagi.

Contoh di atas hanya menunjukkan prinsip pemrosesan XML, tetapi untuk penggunaan nyata perlu ditingkatkan.
Biasanya, Anda harus mem-parsing XML besar untuk memasukkan data ke dalam database, dan untuk pemrosesan data yang benar, Anda perlu mengetahui tag terbuka mana yang dimiliki data tersebut, level penyarangan tag mana, dan tag mana yang terbuka dalam hierarki yang lebih tinggi. Dengan informasi ini, Anda dapat memproses file dengan benar tanpa masalah.
Untuk melakukan ini, Anda perlu memasukkan beberapa variabel global yang akan mengumpulkan informasi tentang tag terbuka, bersarang, dan data.
Berikut adalah contoh yang dapat Anda gunakan

Fungsi webi_xml ($ file)
{
global $ webi_depth; // counter untuk melacak kedalaman sarang
$ kedalaman_webi = 0;
global $ webi_tag_open; // akan berisi array yang terbuka di saat ini tag
$ webi_tag_open = larik();
global $ webi_data_temp; // array ini akan berisi data dari satu tag

####################################################
### fungsi untuk bekerja dengan data
fungsi data ($ parser, $ data)
{
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;
// tambahkan data ke array yang menunjukkan tag bersarang dan saat ini terbuka
$ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"]. = $ data;
}
############################################

####################################################
### fungsi tag pembuka
fungsi startElement ($ parser, $ nama, $ attrs)
{
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;

// jika level bersarang tidak lagi nol, maka satu tag sudah terbuka
// dan data darinya sudah ada dalam array, Anda dapat memprosesnya
jika ($ kedalaman_webi)
{

" ;

cetak "
" ;
print_r ($ webi_tag_open); // larik tag terbuka
cetak "

" ;

// setelah memproses data, hapus untuk mengosongkan memori
tidak disetel ($ GLOBALS ["webi_data_temp"] [$ webi_depth]);
}

// sekarang pembukaan tag berikutnya telah dimulai dan pemrosesan lebih lanjut akan dilakukan pada langkah berikutnya
$ kedalaman_webi++; // tingkatkan bersarang

$ webi_tag_open [$ webi_depth] = $ nama; // tambahkan tag terbuka ke array informasi
$ webi_data_temp [$ webi_depth] [$ nama] ["attrs"] = $ attrs; // sekarang tambahkan atribut tag

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

#################################################
## fungsi tag akhir
fungsi endElement ($ parser, $ nama) (
global $ webi_depth;
global $ webi_tag_open;
global $ webi_data_temp;

// di sinilah pemrosesan data dimulai, misalnya, menambahkan ke database, menyimpan ke file, dll.
// $ webi_tag_open berisi rantai tag terbuka dengan level bersarang
// misalnya $ webi_tag_open [$ webi_depth] berisi nama tag terbuka yang informasinya sedang diproses
// $ level sarang tag webi_depth
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"] larik atribut tag
// $ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"] data tag

Cetak "data". $ webi_tag_open [$ webi_depth]. "-". ($ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["data"]). "
" ;
print_r ($ webi_data_temp [$ webi_depth] [$ webi_tag_open [$ webi_depth]] ["attrs"]);
cetak "
" ;
print_r ($ webi_tag_open);
cetak "

" ;

Tidak disetel ($ GLOBALS ["webi_data_temp"]); // setelah memproses data, hapus seluruh array dengan data, karena tag ditutup
tidak disetel ($ GLOBALS ["webi_tag_open"] [$ webi_depth]); // hapus informasi tentang tag terbuka ini ... sejak ditutup

$ kedalaman_webi -; // kurangi bersarang
}
############################################

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

// tentukan fungsi mana yang akan berfungsi saat membuka dan menutup tag
xml_set_element_handler ($xml_parser, "startElement", "endElement");

// tentukan fungsi untuk bekerja dengan data
xml_set_character_data_handler($xml_parser, "data");

// buka filenya
$fp = fopen ($file, "r");

$ perviy_vxod = 1; // tandai untuk memeriksa entri file pertama
$data = ""; // di sini kami mengumpulkan data dari file dalam beberapa bagian dan mengirimkannya ke parser xml

// loop sampai akhir file ditemukan
while (!feof ($fp) dan $fp)
{
$ simvol = fgetc ($fp); // membaca satu karakter dari file
$ data. = $ simvol; // tambahkan simbol ini ke data yang akan dikirim

// jika karakter bukan tag akhir, maka kita kembali ke awal loop dan menambahkan karakter lain ke data, dan seterusnya hingga tag akhir ditemukan
if ($ simvol! = ">") (lanjutkan;)
// jika tag penutup ditemukan, sekarang kirim data yang dikumpulkan ini untuk diproses

// periksa apakah ini entri pertama ke dalam file, lalu hapus semua yang ada sebelum tag// karena terkadang sampah dapat ditemukan sebelum awal XML (editor kikuk, atau file diterima oleh skrip dari server lain)
if ($ perviy_vxod) ($ data = strstr ($ data, "

// sekarang kita membuang data ke dalam parser xml
if (! xml_parse ($ xml_parser, $ data, feof ($ fp))) (

// di sini Anda dapat memproses dan mendapatkan kesalahan untuk validitas ...
// segera setelah kesalahan ditemukan, penguraian berhenti
gema "
Kesalahan XML: ". Xml_error_string (xml_get_error_code ($ xml_parser));
gema "pada baris". xml_get_current_line_number ($ xml_parser);
merusak;
}

// setelah parsing, buang data yang dikumpulkan untuk langkah siklus berikutnya.
$data = "";
}
ftutup ($fp);
xml_parser_free ($ xml_parser);
// hapus variabel global
tidak disetel ($ GLOBALS ["webi_depth"]);
tidak disetel ($ GLOBALS ["webi_tag_open"]);
tidak disetel ($ GLOBALS ["webi_data_temp"]);

Webi_xml("1.xml");

?>

Seluruh contoh disertai dengan komentar, sekarang uji dan eksperimen.
Harap dicatat bahwa dalam fungsi bekerja dengan data, data tidak hanya dimasukkan ke dalam array, tetapi ditambahkan menggunakan " .=" karena data mungkin tidak datang secara keseluruhan dan jika Anda membuat tugas sederhana, maka dari waktu ke waktu Anda akan menerima data dalam potongan.

Nah, itu saja, sekarang ada cukup memori saat memproses file dengan ukuran apa pun, tetapi waktu menjalankan skrip dapat ditingkatkan dengan beberapa cara.
Di awal skrip, masukkan fungsi
set_time_limit (6000);
atau
ini_set("max_execution_time", "6000");

Atau tambahkan teks ke file .htaccess Anda
php_value max_execution_time 6000

Contoh-contoh ini akan meningkatkan waktu berjalan skrip menjadi 6000 detik.
Anda dapat menambah waktu dengan cara ini hanya dalam mode dinonaktifkan.

Jika Anda memiliki akses untuk mengedit php.ini, Anda dapat menambah waktu dengan
max_execution_time = 6000

Misalnya, pada masterhost hosting pada saat penulisan ini, penambahan waktu skrip dilarang, meskipun dinonaktifkan mode aman, tetapi jika Anda seorang profesional, Anda dapat membuat rakitan php sendiri di masterhost, tetapi ini bukan tentang itu di artikel ini.

Di artikel terakhir kami bersama Anda, dan saya berjanji bahwa di artikel berikutnya kami akan menguraikannya. Dan hari ini saya akan menunjukkan kepada Anda bagaimana Anda bisa parsing dokumen XML dalam PHP.

Saya mengusulkan untuk mengurai dokumen yang kami buat di artikel terakhir, dan cukup menampilkan data dari sana ke browser. Berikut adalah kode skripnya:

$dom = new domDocument("1.0", "utf-8"); // Buat dokumen XML versi 1.0 dengan pengkodean utf-8
$dom-> load("users.xml"); // Muat dokumen XML dari file ke objek DOM
$ root = $ dom-> documentElement; // Dapatkan elemen root
$ anak = $ root-> childNodes; // Dapatkan anak-anak dari elemen root
/ * Kami mengulangi elemen yang diterima * /
untuk ($i = 0; $i< $childs->panjang; $i++) (
$ pengguna = $ anak-> item ($ i); // Dapatkan item berikutnya dari NodeList
$lp = $user-> childNodes; // Dapatkan anak-anak dari simpul "pengguna"
$id = $user-> getAttribute("id"); // Dapatkan nilai atribut "id" dari node "user"
$ login = $ lp-> item (0) -> nodeValue; // Dapatkan nilai dari simpul "login"
$ password = $ lp-> item (1) -> nodeValue; // Dapatkan nilai dari simpul "kata sandi"
/ * Mencetak data yang diterima * /
echo "ID: $id
";
echo "Masuk: $login
";
echo "Kata Sandi: $ kata sandi
";
gema "-----------------------
";
}
?>

Dari kode ini, Anda tidak hanya harus mengerti cara mengurai dokumen XML di PHP tapi juga diriku sendiri proses parsing tergantung pada struktur dokumen... Artinya, Anda harus tahu apa strukturnya, jika tidak maka akan bermasalah untuk mengurai dokumen semacam itu. Saya sudah pernah menulis bahwa yang utama fitur XML adalah keketatan sintaks... Saya harap Anda sekarang mengerti mengapa ini sangat penting. Tanpa ini " kekakuan kode"akan sangat sulit untuk mengurai dokumen, dan hal ini sangat sering diperlukan. Ini dasar ketika mengimpor beberapa data dari berkas XML dengan penempatan berikutnya mereka dalam database.