കഴിഞ്ഞ ലേഖനത്തിൽ ഞാനും നീയും ഞാനും അടുത്ത ലേഖനത്തിൽ നിങ്ങളും ഞാനും അത് പാഴ്സ് ചെയ്യുമെന്ന് വാഗ്ദാനം ചെയ്തു. നിങ്ങൾക്ക് എങ്ങനെ കഴിയുമെന്ന് ഇന്ന് ഞാൻ കാണിച്ചുതരാം PHP-യിൽ XML പ്രമാണം പാഴ്സ് ചെയ്യുക.
കഴിഞ്ഞ ലേഖനത്തിൽ ഞങ്ങൾ സൃഷ്ടിച്ച ഡോക്യുമെൻ്റ് പാഴ്സ് ചെയ്യാനും അവിടെ നിന്ന് ഡാറ്റ ബ്രൗസറിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യാനും ഞാൻ നിർദ്ദേശിക്കുന്നു. സ്ക്രിപ്റ്റ് കോഡ് ഇതാ:
$dom = പുതിയ domDocument("1.0", "utf-8"); // utf-8 എൻകോഡിംഗ് ഉപയോഗിച്ച് ഒരു XML ഡോക്യുമെൻ്റ് പതിപ്പ് 1.0 സൃഷ്ടിക്കുക
$dom->load("users.xml"); // ഒരു ഫയലിൽ നിന്ന് ഒരു DOM ഒബ്ജക്റ്റിലേക്ക് ഒരു XML പ്രമാണം ലോഡ് ചെയ്യുക
$root = $dom->documentElement; // റൂട്ട് ഘടകം നേടുക
$കുട്ടികൾ = $root->childNodes; // റൂട്ട് എലമെൻ്റിൻ്റെ കുട്ടികളെ നേടുക
/* സ്വീകരിച്ച ഘടകങ്ങളിലൂടെ ലൂപ്പ് ചെയ്യുക */
ഇതിനായി ($i = 0; $i< $childs->നീളം; $i++) (
$user = $childs->ഇനം($i); // നോഡ്‌ലിസ്റ്റിൽ നിന്ന് അടുത്ത ഘടകം നേടുക
$lp = $user->childNodes; // "ഉപയോക്തൃ" നോഡിൻ്റെ കുട്ടികളെ നേടുക
$id = $user->getAttribute("id"); // "ഉപയോക്തൃ" നോഡിൻ്റെ "id" ആട്രിബ്യൂട്ടിൻ്റെ മൂല്യം നേടുക
$ലോഗിൻ = $lp->ഇനം(0)->nodeValue; // "ലോഗിൻ" നോഡിൻ്റെ മൂല്യം നേടുക
$password = $lp->ഇനം(1)->nodeValue; // "പാസ്‌വേഡ്" നോഡിൻ്റെ മൂല്യം നേടുക
/* ലഭിച്ച ഡാറ്റ ഔട്ട്പുട്ട് */
echo "ID: $id
";
echo "ലോഗിൻ: $login
";
echo "പാസ്‌വേഡ്: $പാസ്‌വേഡ്
";
പ്രതിധ്വനി "------------------------
";
}
?>
ഈ കോഡിൽ നിന്ന് നിങ്ങൾ മനസ്സിലാക്കുക മാത്രമല്ല PHP-യിൽ ഒരു XML പ്രമാണം എങ്ങനെ പാഴ്സ് ചെയ്യാം, മാത്രമല്ല അവൻ പാഴ്‌സിംഗ് പ്രക്രിയ പ്രമാണത്തിൻ്റെ ഘടനയെ ആശ്രയിച്ചിരിക്കുന്നു. അതായത്, ഘടന എന്താണെന്ന് നിങ്ങൾ അറിഞ്ഞിരിക്കണം, അല്ലാത്തപക്ഷം അത്തരമൊരു ഡോക്യുമെൻ്റ് പാഴ്സ് ചെയ്യുന്നത് പ്രശ്നമായിരിക്കും. പ്രധാനം എന്ന് ഒരിക്കൽ ഞാൻ എഴുതിയിട്ടുണ്ട് XML-ൻ്റെ ഒരു സവിശേഷത വാക്യഘടനയുടെ കർശനതയാണ്. ഇത് വളരെ പ്രധാനമായിരിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് നിങ്ങൾ ഇപ്പോൾ മനസ്സിലാക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. ഇതില്ലാതെ കോഡ് കർശനത"ഡോക്യുമെൻ്റുകൾ പാഴ്സ് ചെയ്യുന്നത് വളരെ ബുദ്ധിമുട്ടായിരിക്കും, ഇത് പലപ്പോഴും ആവശ്യമാണ്. ചില ഡാറ്റ ഇറക്കുമതി ചെയ്യുമ്പോൾ പ്രാഥമികം XML ഫയൽതുടർന്ന് അവയെ ഡാറ്റാബേസിൽ സ്ഥാപിക്കുന്നു.
ഈ ലേഖനത്തിൻ്റെ പ്രസിദ്ധീകരണം ലേഖനത്തിൻ്റെ രചയിതാവിൻ്റെ വെബ്‌സൈറ്റിലേക്കുള്ള ഒരു ലിങ്ക് ഉപയോഗിച്ച് മാത്രമേ അനുവദിക്കൂ
ഈ ലേഖനത്തിൽ ഒരു വലിയ XML ഫയൽ എങ്ങനെ പാഴ്സ് ചെയ്യാം എന്നതിൻ്റെ ഒരു ഉദാഹരണം ഞാൻ കാണിക്കും. നിങ്ങളുടെ സെർവർ (ഹോസ്‌റ്റിംഗ്) സ്ക്രിപ്റ്റിൻ്റെ പ്രവർത്തന സമയം വർദ്ധിപ്പിക്കുന്നത് നിരോധിക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾക്ക് കുറഞ്ഞത് ജിഗാബൈറ്റ് ഭാരമുള്ള ഒരു XML ഫയൽ പാഴ്സ് ചെയ്യാം; 450 മെഗാബൈറ്റ് ഭാരമുള്ള ഓസോണിൽ നിന്നുള്ള ഫയലുകൾ മാത്രമേ ഞാൻ വ്യക്തിപരമായി പാഴ്സ് ചെയ്‌തിട്ടുള്ളൂ.
വലിയ XML ഫയലുകൾ പാഴ്സ് ചെയ്യുമ്പോൾ, രണ്ട് പ്രശ്നങ്ങൾ ഉണ്ടാകുന്നു:
1. മതിയായ മെമ്മറി ഇല്ല.
2. സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ മതിയായ സമയം ഇല്ല.
സെർവർ നിരോധിക്കുന്നില്ലെങ്കിൽ സമയത്തിൻ്റെ രണ്ടാമത്തെ പ്രശ്നം പരിഹരിക്കാൻ കഴിയും.
മെമ്മറിയിലെ പ്രശ്നം പരിഹരിക്കാൻ പ്രയാസമാണ്, ഞങ്ങൾ നിങ്ങളുടെ സ്വന്തം സെർവറിനെക്കുറിച്ച് സംസാരിക്കുകയാണെങ്കിൽപ്പോലും, 500 മെഗാബൈറ്റിൻ്റെ ഫയലുകൾ നീക്കുന്നത് വളരെ എളുപ്പമല്ല, കൂടാതെ ഹോസ്റ്റിംഗിലും വിഡിഎസിലും മെമ്മറി വർദ്ധിപ്പിക്കുന്നത് സാധ്യമല്ല.
PHP-ക്ക് നിരവധി ബിൽറ്റ്-ഇൻ XML പ്രോസസ്സിംഗ് ഓപ്ഷനുകൾ ഉണ്ട് - SimpleXML, DOM, SAX.
ഈ ഓപ്ഷനുകളെല്ലാം ഉദാഹരണങ്ങൾക്കൊപ്പം നിരവധി ലേഖനങ്ങളിൽ വിശദമായി വിവരിച്ചിരിക്കുന്നു, എന്നാൽ എല്ലാ ഉദാഹരണങ്ങളും ഒരു പൂർണ്ണ XML ഡോക്യുമെൻ്റിൽ പ്രവർത്തിക്കുന്നതായി കാണിക്കുന്നു.
ഒരു XML ഫയലിൽ നിന്ന് ഒരു ഒബ്ജക്റ്റ് നേടുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ
ഇപ്പോൾ നിങ്ങൾക്ക് ഈ ഒബ്ജക്റ്റ് പ്രോസസ്സ് ചെയ്യാൻ കഴിയും, പക്ഷേ...
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, മുഴുവൻ XML ഫയലും മെമ്മറിയിലേക്ക് വായിക്കുന്നു, തുടർന്ന് എല്ലാം ഒരു ഒബ്ജക്റ്റിലേക്ക് പാഴ്സ് ചെയ്യുന്നു.
അതായത്, എല്ലാ ഡാറ്റയും മെമ്മറിയിലേക്ക് പോകുന്നു, ആവശ്യത്തിന് അനുവദിച്ച മെമ്മറി ഇല്ലെങ്കിൽ, സ്ക്രിപ്റ്റ് നിർത്തുന്നു.
വലിയ ഫയലുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് ഈ ഓപ്ഷൻ അനുയോജ്യമല്ല; നിങ്ങൾ ഫയൽ വരി വരിയായി വായിക്കുകയും ഈ ഡാറ്റ ഓരോന്നായി പ്രോസസ്സ് ചെയ്യുകയും വേണം.
ഈ സാഹചര്യത്തിൽ, ഡാറ്റ പ്രോസസ്സ് ചെയ്യുമ്പോൾ സാധുത പരിശോധനയും നടക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് റോൾബാക്ക് ചെയ്യേണ്ടതുണ്ട്, ഉദാഹരണത്തിന്, അസാധുവായ XML ഫയലിൻ്റെ കാര്യത്തിൽ ഡാറ്റാബേസിൽ നൽകിയ എല്ലാ ഡാറ്റയും ഇല്ലാതാക്കുക അല്ലെങ്കിൽ രണ്ട് പാസുകൾ നടപ്പിലാക്കുക. ഫയലിലൂടെ, ആദ്യം സാധുതയ്ക്കായി വായിക്കുക, തുടർന്ന് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിന് വായിക്കുക.
ഒരു വലിയ XML ഫയൽ പാഴ്സ് ചെയ്യുന്നതിനുള്ള ഒരു സൈദ്ധാന്തിക ഉദാഹരണം ഇതാ.
ഈ സ്ക്രിപ്റ്റ് ഒരു ഫയലിൽ നിന്ന് ഒരു സമയം ഒരു പ്രതീകം വായിക്കുകയും ഈ ഡാറ്റ ബ്ലോക്കുകളായി ശേഖരിക്കുകയും XML പാഴ്സറിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു.
ഈ സമീപനം മെമ്മറി പ്രശ്നം പൂർണ്ണമായും പരിഹരിക്കുകയും ഒരു ലോഡിന് കാരണമാകില്ല, എന്നാൽ കാലക്രമേണ പ്രശ്നം കൂടുതൽ വഷളാക്കുകയും ചെയ്യുന്നു. കാലക്രമേണ പ്രശ്നം എങ്ങനെ പരിഹരിക്കാൻ ശ്രമിക്കാം, ചുവടെ വായിക്കുക.
ഫംഗ്ഷൻ webi_xml ($file)
{
########
### ഡാറ്റ ഫംഗ്ഷൻ
{
$ഡാറ്റ പ്രിൻ്റ് ചെയ്യുക;
}
############################################
{
$പേര് അച്ചടിക്കുക;
print_r ($attrs);
}
## ക്ലോസിംഗ് ടാഗ് ഫംഗ്ഷൻ
ഫംഗ്ഷൻ endElement ($parser, $name)
{
$പേര് അച്ചടിക്കുക;
}
############################################
($xml_parser, "data");
// ഫയൽ തുറക്കുക
$fp = fopen($file, "r");
$perviy_vxod = 1 ; $ഡാറ്റ = "" ;
{
$simvol = fgetc ($fp); $ഡാറ്റ .= $simvol ;
if($simvol != ">" ) (തുടരുക;)
പ്രതിധ്വനി "
ബ്രേക്ക്;
}
$ഡാറ്റ = "" ;
}
fclose ($fp);
Webi_xml("1.xml");
?>
ഈ ഉദാഹരണത്തിൽ, ഞാൻ എല്ലാം ഒരു ഫംഗ്ഷനിൽ വെബി_xml() ഇട്ടു, ഏറ്റവും താഴെ അതിൻ്റെ കോൾ കാണാം.
സ്ക്രിപ്റ്റിൽ തന്നെ മൂന്ന് പ്രധാന പ്രവർത്തനങ്ങൾ അടങ്ങിയിരിക്കുന്നു:
1. startElement() ടാഗിൻ്റെ ഓപ്പണിംഗ് ക്യാച്ച് ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ
2. ക്ലോസിംഗ് endElement() ടാഗ് പിടിക്കുന്ന ഒരു ഫംഗ്ഷൻ
3. കൂടാതെ ഡാറ്റ സ്വീകരിക്കുന്ന ഫംഗ്ഷൻ ഡാറ്റ () .
1.xml ഫയലിൻ്റെ ഉള്ളടക്കം ഒരു പാചകക്കുറിപ്പാണെന്ന് നമുക്ക് അനുമാനിക്കാം
<
title
>ലളിതമായ അപ്പം
<
ingredient amount
=
"3"
unit
=
"стакан"
>മാവ്
<
ingredient amount
=
"0.25"
unit
=
"грамм"
>യീസ്റ്റ്
<
ingredient amount
=
"1.5"
unit
=
"стакан"
>ചെറുചൂടുള്ള വെള്ളം
<
ingredient amount
=
"1"
unit
=
"чайная ложка"
>ഉപ്പ്
<
instructions
>
<
step
>
എല്ലാ ചേരുവകളും മിക്സ് ചെയ്ത് നന്നായി കുഴയ്ക്കുക.
<
step
>
ഒരു തുണി ഉപയോഗിച്ച് മൂടി ഒരു ചൂടുള്ള മുറിയിൽ ഒരു മണിക്കൂർ വിടുക..
<
step
>
വീണ്ടും കുഴയ്ക്കുക,
ഒരു ബേക്കിംഗ് ഷീറ്റിൽ വയ്ക്കുക, അടുപ്പത്തുവെച്ചു വയ്ക്കുക.
<
step
>
സൈറ്റ് സൈറ്റ് സന്ദർശിക്കുക
പൊതുവായ ഫംഗ്ഷൻ webi_xml ("1.xml" ) എന്ന് വിളിച്ച് ഞങ്ങൾ എല്ലാം ആരംഭിക്കുന്നു;
അടുത്തതായി, പാർസർ ഈ ഫംഗ്ഷനിൽ ആരംഭിക്കുകയും എല്ലാ ടാഗ് നാമങ്ങളും വലിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുകയും ചെയ്യുന്നു, അങ്ങനെ എല്ലാ ടാഗുകൾക്കും ഒരേ കേസ് ലഭിക്കും.
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
ടാഗ് തുറക്കുന്നതിനും അടയ്ക്കുന്നതിനും ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിനും ഏതൊക്കെ ഫംഗ്ഷനുകൾ പ്രവർത്തിക്കുമെന്ന് ഇപ്പോൾ ഞങ്ങൾ സൂചിപ്പിക്കുന്നു
xml_set_element_handler($xml_parser, "startElement", "endElement");
xml_set_character_data_handler($xml_parser, "data");
അടുത്തതായി നിർദ്ദിഷ്ട ഫയലിൻ്റെ ഓപ്പണിംഗ് വരുന്നു, ഫയലിലൂടെ ഒരു സമയം ഒരു പ്രതീകം ആവർത്തിക്കുന്നു, പ്രതീകം കണ്ടെത്തുന്നതുവരെ ഓരോ പ്രതീകവും സ്ട്രിംഗ് വേരിയബിളിലേക്ക് ചേർക്കുന്നു. >
.
ഫയലിലേക്കുള്ള ആദ്യ ആക്സസ് ഇതാണെങ്കിൽ, ഫയലിൻ്റെ തുടക്കത്തിൽ അനാവശ്യമായ എല്ലാം ഇല്ലാതാക്കപ്പെടും, മുമ്പ് വരുന്നതെല്ലാം , XML ആരംഭിക്കേണ്ട ടാഗ് ഇതാണ്.
ആദ്യമായി, ഒരു സ്ട്രിംഗ് വേരിയബിളിൽ ഒരു സ്ട്രിംഗ് അടങ്ങിയിരിക്കും
അത് ഡിസ്അസംബ്ലറിലേക്ക് അയയ്ക്കുക
xml_parse ($xml_parser, $data, feof ($fp));
ഡാറ്റ പ്രോസസ്സ് ചെയ്ത ശേഷം, സ്ട്രിംഗ് വേരിയബിൾ പുനഃസജ്ജമാക്കുകയും ഒരു സ്‌ട്രിംഗിലേക്കുള്ള ഡാറ്റ ശേഖരണം വീണ്ടും ആരംഭിക്കുകയും സ്ട്രിംഗ് രണ്ടാം തവണ രൂപീകരിക്കുകയും ചെയ്യുന്നു.
മൂന്നാമത്തേത്
പൂർത്തിയാക്കിയ ടാഗിൽ നിന്നാണ് എല്ലായ്പ്പോഴും ഒരു സ്ട്രിംഗ് വേരിയബിൾ രൂപപ്പെടുന്നത് എന്നത് ശ്രദ്ധിക്കുക >
കൂടാതെ, കള്ളന് ഒരു തുറന്നതും അടച്ചതുമായ ഒരു ടാഗ് അയയ്‌ക്കേണ്ട ആവശ്യമില്ല, ഉദാഹരണത്തിന്
ഈ ഹാൻഡ്‌ലറിന് ഒരു മുഴുവൻ പൊട്ടാത്ത ടാഗ്, കുറഞ്ഞത് ഒരു ഓപ്പൺ ടാഗ്, അടുത്ത ഘട്ടത്തിൽ ഒരു അടച്ച ടാഗ് എന്നിവ ലഭിക്കുന്നത് പ്രധാനമാണ്, അല്ലെങ്കിൽ ഒരു ഫയലിൻ്റെ 1000 വരികൾ ഉടനടി സ്വീകരിക്കുക, അത് പ്രശ്നമല്ല, പ്രധാന കാര്യം ടാഗ് എന്നതാണ് തകർക്കുന്നില്ല, ഉദാഹരണത്തിന്
ലെ>പ്ലെയിൻ ബ്രെഡ്
ഈ രീതിയിൽ, ടാഗ് കീറിപ്പോയതിനാൽ, ഹാൻഡ്‌ലറിലേക്ക് ഡാറ്റ അയയ്ക്കുന്നത് അസാധ്യമാണ്.
ഹാൻഡ്‌ലറിലേക്ക് ഡാറ്റ അയയ്‌ക്കുന്നതിനുള്ള നിങ്ങളുടെ സ്വന്തം രീതി ഉപയോഗിച്ച് നിങ്ങൾക്ക് വരാം, ഉദാഹരണത്തിന്, വേഗത വർദ്ധിപ്പിക്കുന്നതിന് 1 മെഗാബൈറ്റ് ഡാറ്റ ശേഖരിച്ച് ഹാൻഡ്‌ലറിലേക്ക് അയയ്ക്കുക, ടാഗുകൾ എല്ലായ്പ്പോഴും പൂർത്തിയായിട്ടുണ്ടെന്നും ഡാറ്റ കീറാൻ കഴിയുമെന്നും ഉറപ്പാക്കുക.
അതിനാൽ, നിങ്ങൾ ആഗ്രഹിക്കുന്നതുപോലെ ഭാഗങ്ങളിൽ, നിങ്ങൾക്ക് ഒരു വലിയ ഫയൽ പ്രോസസ്സറിലേക്ക് അയയ്ക്കാൻ കഴിയും.
ഈ ഡാറ്റ എങ്ങനെ പ്രോസസ്സ് ചെയ്യുന്നുവെന്നും അത് എങ്ങനെ നേടാമെന്നും നോക്കാം.
ഓപ്പണിംഗ് ടാഗ് ഫംഗ്ഷനിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം സ്റ്റാർട്ട് എലമെൻ്റ് ($parser, $name, $attrs)
പ്രോസസ്സിംഗ് ലൈനിൽ എത്തിയെന്ന് നമുക്ക് അനുമാനിക്കാം
<
ingredient amount
=
"3"
unit
=
"стакан"
>മാവ്
അപ്പോൾ ഫംഗ്‌ഷനുള്ളിൽ $name എന്ന വേരിയബിൾ തുല്യമായിരിക്കും ഘടകംഅതായത് ഓപ്പൺ ടാഗിൻ്റെ പേര് (ഇതുവരെ ടാഗ് ക്ലോസ് ചെയ്യാൻ എത്തിയിട്ടില്ല).
ഈ സാഹചര്യത്തിൽ, $attrs എന്ന ഈ ടാഗിൻ്റെ ആട്രിബ്യൂട്ടുകളുടെ ഒരു നിര ലഭ്യമാകും, അതിൽ ഡാറ്റ അടങ്ങിയിരിക്കും തുക = "3", യൂണിറ്റ് = "ഗ്ലാസ്".
ഇതിനുശേഷം, ഓപ്പൺ ടാഗിൻ്റെ ഡാറ്റ ഫംഗ്ഷൻ വഴി പ്രോസസ്സ് ചെയ്തു ഡാറ്റ ($parser, $data)
$ഡാറ്റ വേരിയബിളിൽ ഓപ്പണിംഗ്, ക്ലോസിംഗ് ടാഗുകൾക്കിടയിലുള്ള എല്ലാം അടങ്ങിയിരിക്കും, ഞങ്ങളുടെ കാര്യത്തിൽ ഇതാണ് മുക എന്ന വാചകം
ഫംഗ്ഷൻ വഴി ഞങ്ങളുടെ സ്ട്രിംഗിൻ്റെ പ്രോസസ്സിംഗ് അവസാനിക്കുന്നു endElement ($parser, $name)
ഇതാണ് അടച്ച ടാഗിൻ്റെ പേര്, ഞങ്ങളുടെ കാര്യത്തിൽ $name എന്നതിന് തുല്യമായിരിക്കും ഘടകം
അതിനുശേഷം എല്ലാം വീണ്ടും വൃത്തങ്ങളായി.
മുകളിലുള്ള ഉദാഹരണം XML പ്രോസസ്സിംഗിൻ്റെ തത്വം മാത്രമേ കാണിക്കൂ, എന്നാൽ യഥാർത്ഥ ആപ്ലിക്കേഷനായി അത് പരിഷ്ക്കരിക്കേണ്ടതുണ്ട്.
സാധാരണഗതിയിൽ, ഡാറ്റാബേസിലേക്ക് ഡാറ്റ നൽകുന്നതിന് നിങ്ങൾ വലിയ XML പാഴ്സ് ചെയ്യേണ്ടതുണ്ട്, കൂടാതെ ഡാറ്റ ശരിയായി പ്രോസസ്സ് ചെയ്യുന്നതിന് ഡാറ്റ ഏത് ഓപ്പൺ ടാഗിൽ പെടുന്നു, ഏത് ലെവൽ ടാഗ് നെസ്റ്റിംഗ്, ഏത് ടാഗുകൾ മുകളിലുള്ള ശ്രേണിയിൽ തുറന്നിരിക്കുന്നു എന്നിവ നിങ്ങൾ അറിയേണ്ടതുണ്ട്. ഈ വിവരങ്ങൾ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ഒരു പ്രശ്നവുമില്ലാതെ ഫയൽ ശരിയായി പ്രോസസ്സ് ചെയ്യാൻ കഴിയും.
ഇത് ചെയ്യുന്നതിന്, തുറന്ന ടാഗുകൾ, നെസ്റ്റിംഗ്, ഡാറ്റ എന്നിവയെക്കുറിച്ചുള്ള വിവരങ്ങൾ ശേഖരിക്കുന്ന നിരവധി ആഗോള വേരിയബിളുകൾ നിങ്ങൾ അവതരിപ്പിക്കേണ്ടതുണ്ട്.
നിങ്ങൾക്ക് ഉപയോഗിക്കാവുന്ന ഒരു ഉദാഹരണം ഇതാ
ഫംഗ്ഷൻ webi_xml ($file)
{
ആഗോള $webi_depth ; നെസ്റ്റിംഗ് ഡെപ്ത് ട്രാക്ക് ചെയ്യാനുള്ള കൗണ്ടർ
$webi_depth = 0 ;
ആഗോള $webi_tag_open ; // നിലവിൽ തുറന്നിരിക്കുന്ന ടാഗുകളുടെ ഒരു നിര അടങ്ങിയിരിക്കും
$webi_tag_open = അറേ();
ആഗോള $webi_data_temp ; // ഈ അറേയിൽ ഒരു ടാഗിൻ്റെ ഡാറ്റ അടങ്ങിയിരിക്കും
####################################################
### ഡാറ്റ ഫംഗ്ഷൻ
ഫംഗ്ഷൻ ഡാറ്റ ($parser, $data)
{
ആഗോള $webi_depth ;
ആഗോള $webi_tag_open ;
ആഗോള $webi_data_temp ;
// നെസ്റ്റിംഗ് സൂചിപ്പിക്കുന്ന അറേയിലേക്ക് ഡാറ്റ ചേർക്കുക, നിലവിൽ ടാഗ് തുറന്നിരിക്കുന്നു
$webi_data_temp [ $webi_depth ][ $webi_tag_open [ $webi_depth ]][ "data" ].= $data ;
}
############################################
####################################################
### ഓപ്പണിംഗ് ടാഗ് ഫംഗ്ഷൻ
ഫംഗ്ഷൻ സ്റ്റാർട്ട് എലമെൻ്റ് ($പാഴ്സർ, $നെയിം, $attrs)
{
ആഗോള $webi_depth ;
ആഗോള $webi_tag_open ;
ആഗോള $webi_data_temp ;
// നെസ്റ്റിംഗ് ലെവൽ പൂജ്യമല്ലെങ്കിൽ, ഒരു ടാഗ് ഇതിനകം തുറന്നിട്ടുണ്ട്
// കൂടാതെ അതിൽ നിന്നുള്ള ഡാറ്റ ഇതിനകം അറേയിലാണ്, നിങ്ങൾക്ക് ഇത് പ്രോസസ്സ് ചെയ്യാൻ കഴിയും
എങ്കിൽ ($webi_depth)
{
"
;
അച്ചടിക്കുക "
"
;
print_r ($webi_tag_open); // ഓപ്പൺ ടാഗുകളുടെ ഒരു നിര
അച്ചടിക്കുക "
" ;
// ഡാറ്റ പ്രോസസ്സ് ചെയ്ത ശേഷം, മെമ്മറി ശൂന്യമാക്കാൻ അത് ഇല്ലാതാക്കുക
unset($GLOBALS [ "webi_data_temp" ][ $webi_depth ]);
}
// ഇപ്പോൾ അടുത്ത ടാഗ് തുറന്നിരിക്കുന്നു, അടുത്ത ഘട്ടത്തിൽ കൂടുതൽ പ്രോസസ്സിംഗ് സംഭവിക്കും
$webi_depth++; // കൂടു കൂട്ടുക
$webi_tag_open [ $webi_depth ]= $name ; // വിവര ശ്രേണിയിലേക്ക് ഒരു തുറന്ന ടാഗ് ചേർക്കുക
$webi_data_temp [ $webi_depth ][ $name ][ "attrs" ]= $attrs ; // ഇപ്പോൾ ടാഗ് ആട്രിബ്യൂട്ടുകൾ ചേർക്കുക
}
###############################################
#################################################
## ക്ലോസിംഗ് ടാഗ് ഫംഗ്ഷൻ
ഫംഗ്ഷൻ endElement ($parser, $name) (
ആഗോള $webi_depth ;
ആഗോള $webi_tag_open ;
ആഗോള $webi_data_temp ;
// ഡാറ്റ പ്രോസസ്സിംഗ് ഇവിടെ ആരംഭിക്കുന്നു, ഉദാഹരണത്തിന് ഡാറ്റാബേസിലേക്ക് ചേർക്കൽ, ഒരു ഫയലിൽ സംരക്ഷിക്കൽ തുടങ്ങിയവ.
// $webi_tag_open-ൽ നെസ്റ്റിംഗ് ലെവൽ വഴി തുറന്ന ടാഗുകളുടെ ഒരു ശൃംഖല അടങ്ങിയിരിക്കുന്നു
// ഉദാഹരണത്തിന് $webi_tag_open[$webi_depth] എന്നതിൽ നിലവിൽ വിവരങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്ന ഓപ്പൺ ടാഗിൻ്റെ പേര് അടങ്ങിയിരിക്കുന്നു
// $webi_depth ടാഗ് നെസ്റ്റിംഗ് ലെവൽ
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["attrs"] ടാഗ് ആട്രിബ്യൂട്ടുകളുടെ നിര
// $webi_data_temp[$webi_depth][$webi_tag_open[$webi_depth]]["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" ]);
അച്ചടിക്കുക "
"
;
print_r ($webi_tag_open);
അച്ചടിക്കുക "
" ;
സജ്ജീകരിക്കാത്തത്($GLOBALS [ "webi_data_temp" ]); // ഡാറ്റ പ്രോസസ്സ് ചെയ്തതിന് ശേഷം, ടാഗ് അടച്ചതിനാൽ ഞങ്ങൾ ഡാറ്റ ഉപയോഗിച്ച് മുഴുവൻ അറേയും ഇല്ലാതാക്കുന്നു
സജ്ജമാക്കാത്തത്($GLOBALS [ "webi_tag_open" ][ $webi_depth ]); // ഈ ഓപ്പൺ ടാഗിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഇല്ലാതാക്കുക... അത് അടച്ചതിനാൽ
$webi_depth --; // കൂടുകെട്ടൽ കുറയ്ക്കുക
}
############################################
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
// ടാഗുകൾ തുറക്കുമ്പോഴും അടയ്ക്കുമ്പോഴും ഏതൊക്കെ ഫംഗ്ഷനുകൾ പ്രവർത്തിക്കുമെന്ന് സൂചിപ്പിക്കുക
xml_set_element_handler($xml_parser, "startElement", "endElement");
// ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ വ്യക്തമാക്കുക
xml_set_character_data_handler($xml_parser, "data");
// ഫയൽ തുറക്കുക
$fp = fopen($file, "r");
$perviy_vxod = 1 ; // ഫയലിലേക്കുള്ള ആദ്യ എൻട്രി പരിശോധിക്കാൻ ഫ്ലാഗ് ചെയ്യുക
$ഡാറ്റ = "" ; // ഇവിടെ ഞങ്ങൾ ഫയലിൽ നിന്ന് ഡാറ്റ ഭാഗങ്ങളായി ശേഖരിച്ച് xml പാർസറിലേക്ക് അയയ്ക്കുന്നു
// ഫയലിൻ്റെ അവസാനം വരെ ലൂപ്പ് ചെയ്യുക
അതേസമയം (! feof ($fp ) ഒപ്പം $fp )
{
$simvol = fgetc ($fp); // ഫയലിൽ നിന്ന് ഒരു പ്രതീകം വായിക്കുക
$ഡാറ്റ .= $simvol ; // അയയ്‌ക്കേണ്ട ഡാറ്റയിൽ ഈ പ്രതീകം ചേർക്കുക
// പ്രതീകം അവസാന ടാഗല്ലെങ്കിൽ, ലൂപ്പിൻ്റെ തുടക്കത്തിലേക്ക് തിരികെ പോയി ഡാറ്റയിലേക്ക് മറ്റൊരു പ്രതീകം ചേർക്കുക, അങ്ങനെ അവസാന ടാഗ് കണ്ടെത്തുന്നത് വരെ
if($simvol != ">" ) (തുടരുക;)
// ക്ലോസിംഗ് ടാഗ് കണ്ടെത്തിയാൽ, ഇപ്പോൾ ഞങ്ങൾ ഈ ശേഖരിച്ച ഡാറ്റ പ്രോസസ്സിംഗിനായി അയയ്ക്കും
// ഫയലിലേക്കുള്ള ആദ്യ എൻട്രി ഇതാണോയെന്ന് പരിശോധിക്കുക, തുടർന്ന് ടാഗിന് മുമ്പുള്ളതെല്ലാം ഞങ്ങൾ ഇല്ലാതാക്കും// XML ആരംഭിക്കുന്നതിന് മുമ്പ് ചിലപ്പോൾ നിങ്ങൾ മാലിന്യം കണ്ടേക്കാം (വിചിത്രമായ എഡിറ്റർമാർ, അല്ലെങ്കിൽ ഫയൽ മറ്റൊരു സെർവറിൽ നിന്ന് ഒരു സ്ക്രിപ്റ്റ് വഴി സ്വീകരിച്ചു)
if($perviy_vxod ) ( $data = strstr ($data , "
// ഇപ്പോൾ ഡാറ്റ എക്സ്എംഎൽ പാർസറിലേക്ക് എറിയുക
എങ്കിൽ (! xml_parse ($xml_parser, $data, feof ($fp))) (
// ഇവിടെ നിങ്ങൾക്ക് സാധുതയുള്ള പിശകുകൾ പ്രോസസ്സ് ചെയ്യാനും സ്വീകരിക്കാനും കഴിയും...
// ഒരു പിശക് നേരിട്ട ഉടൻ, പാഴ്‌സിംഗ് നിർത്തുന്നു
പ്രതിധ്വനി "
XML പിശക്: ". xml_error_string(xml_get_error_code($xml_parser));
പ്രതിധ്വനി "ലൈനിൽ" . xml_get_current_line_number ($xml_parser);
ബ്രേക്ക്;
}
// പാഴ്സ് ചെയ്ത ശേഷം, സൈക്കിളിൻ്റെ അടുത്ത ഘട്ടത്തിനായി ശേഖരിച്ച ഡാറ്റ ഉപേക്ഷിക്കുക.
$ഡാറ്റ = "" ;
}
fclose ($fp);
xml_parser_free($xml_parser);
// ആഗോള വേരിയബിളുകൾ നീക്കം ചെയ്യുന്നു
അൺസെറ്റ്($GLOBALS [ "webi_depth" ]);
സജ്ജമാക്കാത്തത്($GLOBALS [ "webi_tag_open" ]);
അൺസെറ്റ്($GLOBALS [ "webi_data_temp" ]);
Webi_xml("1.xml");
?>
മുഴുവൻ ഉദാഹരണവും കമൻ്റുകളോടൊപ്പമുണ്ട്, ഇപ്പോൾ പരീക്ഷണവും പരീക്ഷണവും.
ഡാറ്റയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്ന പ്രവർത്തനത്തിൽ, ഡാറ്റ കേവലം ഒരു അറേയിലേക്ക് തിരുകുകയല്ല, പകരം "ഉപയോഗിച്ച് ചേർക്കുകയാണ് ചെയ്യുന്നത്. .="
ഡാറ്റ പൂർണ്ണമായി ലഭിക്കണമെന്നില്ല എന്നതിനാൽ, നിങ്ങൾ ഒരു അസൈൻമെൻ്റ് നടത്തുകയാണെങ്കിൽ, കാലാകാലങ്ങളിൽ നിങ്ങൾക്ക് ഡാറ്റ കഷണങ്ങളായി ലഭിക്കും.
ശരി, അത്രയേയുള്ളൂ, ഇപ്പോൾ ഏത് വലുപ്പത്തിലുള്ള ഒരു ഫയൽ പ്രോസസ്സ് ചെയ്യുമ്പോൾ മതിയായ മെമ്മറി ഉണ്ട്, എന്നാൽ സ്ക്രിപ്റ്റിൻ്റെ പ്രവർത്തന സമയം പല തരത്തിൽ വർദ്ധിപ്പിക്കാൻ കഴിയും.
സ്ക്രിപ്റ്റിൻ്റെ തുടക്കത്തിൽ ഒരു ഫംഗ്ഷൻ ചേർക്കുക
set_time_limit(6000);
അഥവാ
ini_set ("max_execution_time" , "6000" );
അല്ലെങ്കിൽ .htaccess ഫയലിലേക്ക് ടെക്സ്റ്റ് ചേർക്കുക
php_value max_execution_time 6000
ഈ ഉദാഹരണങ്ങൾ സ്ക്രിപ്റ്റ് റണ്ണിംഗ് സമയം 6000 സെക്കൻഡായി വർദ്ധിപ്പിക്കും.
സുരക്ഷിത മോഡ് ഓഫാക്കുമ്പോൾ മാത്രമേ നിങ്ങൾക്ക് ഈ രീതിയിൽ സമയം വർദ്ധിപ്പിക്കാൻ കഴിയൂ.
നിങ്ങൾക്ക് php.ini എഡിറ്റ് ചെയ്യാനുള്ള ആക്സസ് ഉണ്ടെങ്കിൽ അത് ഉപയോഗിച്ച് സമയം വർദ്ധിപ്പിക്കാം
max_execution_time = 6000
ഉദാഹരണത്തിന്, Masterhost ഹോസ്റ്റിംഗിൽ, ഈ ലേഖനം എഴുതുന്ന സമയത്ത്, സുരക്ഷിത മോഡ് ഓഫാക്കിയിട്ടും സ്ക്രിപ്റ്റ് സമയം വർദ്ധിപ്പിക്കുന്നത് നിരോധിച്ചിരിക്കുന്നു, എന്നാൽ നിങ്ങൾ ഒരു പ്രോ ആണെങ്കിൽ, നിങ്ങൾക്ക് Masterhost-ൽ നിങ്ങളുടെ സ്വന്തം PHP ബിൽഡ് ഉണ്ടാക്കാം, പക്ഷേ അതാണ് ഈ ലേഖനത്തിൽ ഇല്ല.
കഴിഞ്ഞ ദിവസം ഞാൻ കമ്പനിയ്‌ക്കായി എൻ്റെ ആന്തരിക റിപ്പോർട്ടിംഗ് സിസ്റ്റം പുനർനിർമ്മിക്കാൻ തുടങ്ങി, അതിൻ്റെ പൊതുവായ ഘടനയെക്കുറിച്ച് ഞാൻ വളരെക്കാലം മുമ്പ് എഴുതിയിട്ടില്ല. മുൻകരുതലുകളില്ലാതെ, PHP-യുടെ കാര്യത്തിൽ ഞാൻ എന്നെക്കാൾ ഉയർന്നുവെന്ന് ഞാൻ പറയും, തൽഫലമായി, സിസ്റ്റത്തിൻ്റെ അൽഗോരിതം അത് മാറ്റിയെഴുതാൻ പാകത്തിന് വളഞ്ഞതാണെന്ന് ഞാൻ മനസ്സിലാക്കി.
ഇതിനുമുമ്പ്, PHP പതിപ്പ് 4-ൽ നിന്ന് കടമെടുത്ത ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് XML പ്രമാണം പാഴ്സ് ചെയ്തു. എന്നിരുന്നാലും, PHP5 ലോകത്തിന് SimpleXML എന്ന വളരെ സൗകര്യപ്രദമായ ഒരു കാര്യം നൽകി. ഇന്ന് നമ്മൾ അത് എങ്ങനെ പ്രവർത്തിക്കണം എന്നതിനെക്കുറിച്ച് സംസാരിക്കും.
SimpleXML ഒരു പ്രത്യേക പ്ലഗ്-ഇൻ മൊഡ്യൂളാണെന്ന വസ്തുതയിൽ നിന്ന് ആരംഭിക്കുന്നത് മൂല്യവത്താണ്, അതിനാൽ നിങ്ങൾ ഉപയോഗിക്കുന്ന സെർവറിൽ ഇത് മുൻകൂട്ടി പ്രവർത്തനക്ഷമമാക്കിയിരിക്കണം.
ഇപ്പോൾ നമുക്ക് പ്രവർത്തിക്കാം!
പ്രമാണം പ്രോസസ്സ് ചെയ്യുന്നതിനായി, ഞങ്ങൾ simplexml_load_file() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. ഒരു പാരാമീറ്റർ എന്ന നിലയിൽ, ഫയലിൻ്റെ വിലാസം എക്സ്റ്റൻഡഡ് മാർക്ക്അപ്പ് ലാംഗ്വേജ് (XML - Your K.O.) ഫോർമാറ്റിൽ കൈമാറുന്നു.
ഏത് സെർവറിൽ നിന്നും നിങ്ങൾക്ക് ഒരു ഫയൽ എളുപ്പത്തിൽ കൈമാറാൻ കഴിയും എന്നതാണ് ഈ ഫംഗ്ഷൻ്റെ ഭംഗി. അങ്ങനെ, ഞങ്ങൾക്ക് ബാഹ്യ xml അപ്‌ലോഡുകൾ പ്രോസസ്സ് ചെയ്യാനുള്ള അവസരമുണ്ട് (ഉദാഹരണത്തിന്, Yandex-XML അല്ലെങ്കിൽ മൂന്നാം-കക്ഷി RSS ഫീഡുകൾ).
ഫംഗ്ഷൻ ഒരു അറേ ഔട്ട്പുട്ട് ചെയ്യുന്നു. XML-ന് ഒരു വിചിത്രമായ ഘടനയുണ്ടാകുമെന്നതാണ് ഞാൻ നേരിട്ട ഒരു പോരായ്മ, അതിനാൽ ഫംഗ്ഷൻ എങ്ങനെ പ്രോസസ്സ് ചെയ്തുവെന്ന് മനസിലാക്കാൻ ആദ്യം ഒരു ആലങ്കാരിക ട്രെയ്സ് നടത്താനും ഒരു അറേ ഔട്ട്പുട്ട് ചെയ്യാനും ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു. ഇതിനുശേഷം, നിങ്ങൾക്ക് ലഭിച്ച ഡാറ്റ പ്രോസസ്സ് ചെയ്യാൻ ആരംഭിക്കാം.
ഉദാഹരണത്തിന്, ഞാൻ ഇവിടെ നിന്ന് ഒരു ലളിതമായ ഡിസൈൻ എടുക്കും:
>
>
അതുകൊണ്ട് അതൊരു ഭാഷയാണ്. ഇത് ഇപ്പോഴും ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. അഥവാ
ഇതൊരു സ്ക്രിപ്റ്റിംഗ് ഭാഷയാണോ? ഈ ഡോക്യുമെൻ്ററിയിൽ അതെല്ലാം വെളിപ്പെടുത്തിയിട്ടുണ്ട്,
ഒരു ഹൊറർ സിനിമ പോലെ.
>
>
>
ഇത് export.xml ഫയലായിരിക്കട്ടെ, അത് പ്രോസസ് ചെയ്യുന്ന സ്ക്രിപ്റ്റിനൊപ്പം എൻ്റെ സെർവറിൻ്റെ റൂട്ടിൽ തന്നെ കിടക്കുന്നു.
XML ഡോക്യുമെൻ്റിലെ DOM ഘടകങ്ങളുടെ ഘടനയ്ക്ക് അനുസൃതമായാണ് അറേ നിർമ്മിച്ചിരിക്കുന്നത്. റൂട്ടിൽ നിന്നാണ് പ്രോസസ്സിംഗ് ആരംഭിക്കുന്നത്. ശ്രീമതി എന്ന പേര് ലഭിക്കാൻ. കോഡർ, നമ്മൾ ഇനിപ്പറയുന്ന പാത നിർമ്മിക്കണം: $xml->സിനിമകൾ->മൂവി->കഥാപാത്രങ്ങൾ->കഥാപാത്രം->പേര്.
ഞങ്ങൾ ഒരു നിർദ്ദിഷ്ട മൂല്യം തിരഞ്ഞെടുക്കുന്നുവെന്നത് ശ്രദ്ധിക്കുക. ഇവിടെ നിന്നാണ് ഇത്തരത്തിലുള്ള പ്രതീക നൊട്ടേഷൻ വരുന്നത് - ഞങ്ങൾ ഒരു അറേ ഉപയോഗിച്ചാണ് പ്രവർത്തിക്കുന്നതെന്ന് മറക്കരുത്!
ഏതൊരു അറേയെയും പോലെ, ഒരു ഫോറെച്ച് ലൂപ്പ് ഉപയോഗിച്ച് ഞങ്ങളുടെ ഡാറ്റ പ്രോസസ്സ് ചെയ്യാൻ കഴിയും. കോഡ് ഇതുപോലെയായിരിക്കും:
$xml = simplexml_load_file ("export.xml" ); //അപ്‌ലോഡ് ചെയ്ത ഫയൽ
$ttl = $xml -> സിനിമകൾ -> സിനിമ -> പേര് ; //തലക്കെട്ട് കിട്ടി. ഒന്ന് മാത്രമേയുള്ളൂ, അതിനാൽ മറ്റൊരു മൂല്യം സജ്ജീകരിക്കേണ്ട ആവശ്യമില്ല
foreach ($xml -> സിനിമകൾ -> സിനിമ -> കഥാപാത്രങ്ങൾ $crc ആയി ) // ഇനി നമുക്ക് ഡൈനാമിക്സിൽ പ്രവർത്തിക്കാം
{
//വീരന്മാരുടെ പേരുകൾ പ്രദർശിപ്പിക്കുക
$പേര് = $crc -> പ്രതീകം -> പേര് ;
പ്രതിധ്വനി (" $പേര്
"
)
;
}
ഈ കോഡ് $ttl വേരിയബിളിൽ "PHP: Parser Appears" എന്ന വാചകം ഇടും, തുടർന്ന് സ്‌ക്രീനിൽ ഹീറോകളുടെ പേരുകൾ വരി വരിയായി പ്രദർശിപ്പിക്കും.
മിസ്. കോഡർ, ശ്രീ. കോഡർ, ശ്രീ. പാർസർ.
Xml പാർസർഒരു സോഴ്‌സ് xml ഫയലിൽ നിന്ന് ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്ത് അത് സേവ് ചെയ്യുന്നതോ തുടർന്നുള്ള പ്രവർത്തനങ്ങൾക്കായി ഉപയോഗിക്കുന്നതോ ആയ ഒരു പ്രോഗ്രാമാണ്.
എന്തുകൊണ്ട് xml പാർസറുകൾ ആവശ്യമാണ്?
ഒന്നാമതായി, കാരണം xml ഫോർമാറ്റ് തന്നെ കമ്പ്യൂട്ടർ സ്റ്റാൻഡേർഡുകളിൽ ജനപ്രിയമാണ്. XML ഫയൽ ഇതുപോലെ കാണപ്പെടുന്നു:
ആ. അടിസ്ഥാനപരമായി ടാഗുകൾ ഉണ്ട്, ടാഗുകൾ പരസ്പരം പിന്തുടരേണ്ട ചില നിയമങ്ങളുണ്ട്.
xml ഫയലുകളുടെ ജനപ്രീതിക്ക് കാരണം അവ മനുഷ്യർക്ക് വളരെ വായിക്കാൻ കഴിയും എന്നതാണ്. പ്രോഗ്രാമുകളിൽ പ്രോസസ്സ് ചെയ്യുന്നത് താരതമ്യേന എളുപ്പമാണ് എന്നതും വസ്തുതയാണ്.
xml ഫയലുകളുടെ പോരായ്മകൾ.
പോരായ്മ, ഒന്നാമതായി, ഈ ഡാറ്റ എടുക്കുന്ന വലിയ ഡിസ്ക് സ്പേസ് ആണ്. വലിയ അളവിലുള്ള ഡാറ്റ ഉപയോഗിച്ച് നിരന്തരം ആവർത്തിക്കുന്ന ടാഗുകൾ താരതമ്യേന നിരവധി മെഗാബൈറ്റുകൾ എടുക്കുന്നു, അവ ഉറവിടത്തിൽ നിന്ന് ഡൗൺലോഡ് ചെയ്യുകയും തുടർന്ന് പ്രോസസ്സ് ചെയ്യുകയും വേണം. എന്തെങ്കിലും ബദലുകളുണ്ടോ? തീർച്ചയായും ഉണ്ട്, പക്ഷേ ഇപ്പോഴും, xml പാഴ്‌സറുകളും xml ഉം ഇന്ന് ഏറ്റവും ലളിതവും വിശ്വസനീയവും സാങ്കേതികമായി ജനപ്രിയവുമായ ഫോർമാറ്റുകളിൽ ഒന്നാണ്.
എങ്ങനെയാണ് XML പാഴ്സറുകൾ എഴുതുന്നത്?
പാഴ്സറുകൾ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ എഴുതിയിരിക്കുന്നു. അവർ പറയുന്നതുപോലെ, അവ എല്ലാവരിലും എഴുതിയിരിക്കുന്നു, പക്ഷേ ചിലത് അല്ല. xml ഫയലുകൾ പാഴ്‌സുചെയ്യുന്നതിന് ഇതിനകം തന്നെ ബിൽറ്റ്-ഇൻ ലൈബ്രറികൾ ഉള്ള പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഉണ്ടെന്ന് മനസ്സിലാക്കണം. എന്തായാലും, ലൈബ്രറി ഇല്ലെങ്കിലും, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഈ വിഷയത്തിന് അനുയോജ്യമായ ഒരു ലൈബ്രറി കണ്ടെത്താനും ഒരു ഫയലിൽ നിന്ന് ഡാറ്റ എക്‌സ്‌ട്രാക്റ്റുചെയ്യാൻ അത് ഉപയോഗിക്കാനും കഴിയും.
ആഗോളതലത്തിൽ, xml ഫയലുകൾ പാഴ്‌സിംഗ് ചെയ്യുന്നതിന് 2 വ്യത്യസ്ത സമീപനങ്ങളുണ്ട്.
ആദ്യത്തേത്, xml ഫയൽ പൂർണ്ണമായും മെമ്മറിയിലേക്ക് ലോഡുചെയ്യുക, തുടർന്ന് ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നതിന് കൃത്രിമങ്ങൾ നടത്തുക എന്നതാണ്.
രണ്ടാമത്തേത് സ്ട്രീമിംഗ് ഓപ്ഷനാണ്. ഈ സാഹചര്യത്തിൽ, സൃഷ്ടിച്ച xml പാർസറിൻ്റെ പ്രവർത്തനങ്ങൾ പ്രതികരിക്കേണ്ട ചില ടാഗുകൾ പ്രോഗ്രാമിംഗ് ഭാഷ നിർവചിക്കുന്നു, കൂടാതെ ഒരു പ്രത്യേക ടാഗ് കണ്ടെത്തിയാൽ എന്തുചെയ്യണമെന്ന് പ്രോഗ്രാമർ തന്നെ തീരുമാനിക്കുന്നു.
ആദ്യ സമീപനത്തിൻ്റെ പ്രയോജനം വേഗതയാണ്. ഞാൻ ഉടൻ തന്നെ ഫയൽ ഡൗൺലോഡ് ചെയ്തു, തുടർന്ന് എൻ്റെ മെമ്മറിയിലൂടെ വേഗത്തിൽ ഓടി, ആവശ്യമുള്ളത് കണ്ടെത്തി, ഏറ്റവും പ്രധാനമായി, പ്രോഗ്രാം ചെയ്യാൻ എളുപ്പമാണ്. എന്നാൽ ഒരു മൈനസ് ഉണ്ട് വളരെ പ്രധാനപ്പെട്ട ഒന്ന് - ഇത്
പ്രവർത്തനത്തിന് വലിയ അളവിലുള്ള മെമ്മറി ആവശ്യമാണ്. ചിലപ്പോൾ, ഒരു xml ഫയൽ പ്രോസസ്സ് ചെയ്യുന്നതും പാഴ്സ് ചെയ്യുന്നതും അസാധ്യമാണെന്ന് പലപ്പോഴും ഞാൻ പറയും, അതായത്. ഒരു xml പാഴ്സർ സൃഷ്ടിക്കുക, അങ്ങനെ ആദ്യ രീതി ശരിയായി പ്രവർത്തിക്കും. എന്തുകൊണ്ടാണത്? ശരി, ഉദാഹരണത്തിന്, വിൻഡോസിന് കീഴിലുള്ള 32-ബിറ്റ് ആപ്ലിക്കേഷനുകളുടെ പരിമിതി പ്രോഗ്രാമിനെ പരമാവധി 2 ജിഗാബൈറ്റ് മെമ്മറി ഉൾക്കൊള്ളാൻ അനുവദിക്കുന്നു - ഇത് ഇനി സാധ്യമല്ല.
എന്നിരുന്നാലും, ത്രെഡ് അടിസ്ഥാനമാക്കിയുള്ള പ്രോഗ്രാമിംഗ് ബുദ്ധിമുട്ടാണ്. വളരെ ഗുരുതരമായ ഒരു വേർതിരിച്ചെടുക്കലിൻ്റെ സങ്കീർണ്ണത ഗണ്യമായി വർദ്ധിക്കുന്നു, അതനുസരിച്ച് സമയപരിധിയെയും ബജറ്റിനെയും ബാധിക്കുന്നു.
xml ഫയലുകളുടെയും പാർസറുകളുടെയും സാധുത.
xml ഫയലുകളും xml പാഴ്‌സറുകളും ഉപയോഗിച്ച് എല്ലാം ശരിയാകും, പക്ഷേ ഒരു പ്രശ്നമുണ്ട്. "ഏത് സ്കൂൾ കുട്ടിക്കും" ഒരു xml ഫയൽ സൃഷ്ടിക്കാൻ കഴിയും എന്ന വസ്തുത കാരണം, വാസ്തവത്തിൽ ഇത് ശരിയാണ് (ധാരാളം കോഡുകൾ സ്കൂൾ കുട്ടികൾ എഴുതിയതിനാൽ), അസാധുവായ ഫയലുകൾ പ്രത്യക്ഷപ്പെടുന്നു, അതായത് തെറ്റാണ്. ഇത് എന്താണ് അർത്ഥമാക്കുന്നത്, എന്താണ് അത് നിറഞ്ഞത് ?ഏറ്റവും വലിയ പ്രശ്നം , ഇത് ചിലപ്പോൾ ഒരു അസാധുവായ ഫയൽ ശരിയായി പാഴ്സ് ചെയ്യുന്നത് അസാധ്യമാണ്, ഉദാഹരണത്തിന്, സ്റ്റാൻഡേർഡ് അനുസരിച്ച് അതിൻ്റെ ടാഗുകൾ അടച്ചിട്ടില്ല, അല്ലെങ്കിൽ ഉദാഹരണത്തിന്, എൻകോഡിംഗ് തെറ്റായി സജ്ജീകരിച്ചിരിക്കുന്നു. മറ്റൊരു പ്രശ്നം ഉദാഹരണത്തിന്, നിങ്ങൾ .net-ൽ ഒരു പാഴ്സർ ഉണ്ടാക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് റാപ്പറുകൾ എന്ന് വിളിക്കപ്പെടുന്നവ സൃഷ്ടിക്കാൻ കഴിയും, ഏറ്റവും അരോചകമായ കാര്യം നിങ്ങൾ അത്തരമൊരു റാപ്പർ ഉണ്ടാക്കുകയും തുടർന്ന് ഒരു "വിദ്യാർത്ഥി" സൃഷ്ടിച്ച ഒരു ഫയൽ വായിക്കാൻ അത് ഉപയോഗിക്കുക എന്നതാണ്. , എന്നാൽ ഫയൽ അസാധുവാണ്, വായിക്കാൻ അസാധ്യമാണ്, അതിനാൽ, നിങ്ങൾ അത് ഒഴിവാക്കുകയും അത്തരം ഫയലുകൾ പാഴ്‌സുചെയ്യുന്നതിന് വളരെ ജനപ്രിയമല്ലാത്ത ഓപ്ഷനുകൾ അവലംബിക്കുകയും വേണം. കൂടാതെ എല്ലാ xml ഫയൽ സ്റ്റാൻഡേർഡുകളോടും പൂർണ്ണമായ വെറുപ്പോടെ ഇത് ഉപഭോക്താക്കൾക്ക് വിശദീകരിക്കാൻ പ്രയാസമാണ്. അവർ ഫലത്തിനായി കാത്തിരിക്കുകയാണ് - യഥാർത്ഥ ഫയലിൽ നിന്നുള്ള ഡാറ്റ മറ്റൊരു ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്ന ഒരു xml പാഴ്സർ.
xml പാർസറുകൾ എങ്ങനെ സൃഷ്ടിക്കാം (ആദ്യ ഓപ്ഷൻ)
XML ഡാറ്റയ്ക്ക് Xpath എന്നൊരു ചോദ്യ ഭാഷയുണ്ട്. ഈ ഭാഷയ്ക്ക് രണ്ട് പതിപ്പുകളുണ്ട്; ഓരോ പതിപ്പിൻ്റെയും സവിശേഷതകളെക്കുറിച്ച് ഞങ്ങൾ വിശദമായി പറയുന്നില്ല. ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നതിന് ഇത് എങ്ങനെ ഉപയോഗിക്കാമെന്നതിൻ്റെ ഉദാഹരണങ്ങളിലൂടെ ഈ ഭാഷയെക്കുറിച്ചുള്ള മികച്ച ആശയം കാണിക്കും. ഉദാഹരണത്തിന്.
//div[@class="supcat guru"]/a
ഈ അഭ്യർത്ഥന എന്താണ് ചെയ്യുന്നത്. catalog.xml?hid= എന്ന ടെക്സ്റ്റ് അടങ്ങുന്ന ഒരു റെഫർ എൻ്റെ പക്കലുള്ള എല്ലാ ടാഗുകളും ഇതിന് എടുക്കുന്നു, ഈ ടാഗ് supcat ഗുരുവിന് തുല്യമായ ഒരു ഡിവി ചൈൽഡ് ആയിരിക്കണം.
അതെ, ഇത് ആദ്യമായി വേണ്ടത്ര വ്യക്തമല്ലായിരിക്കാം, എന്നാൽ നിങ്ങൾക്ക് വേണമെങ്കിൽ അത് കണ്ടെത്താനാകും. എൻ്റെ ആരംഭ പോയിൻ്റ് http://ru.wikipedia.org/wiki/XPath ആണ്, ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു.
വേനൽക്കാലം എത്തി, ജൂലൈ ആദ്യവാരം കടന്നുപോയി. രണ്ടാഴ്‌ചയ്‌ക്കുള്ളിൽ എനിക്ക് എൻ്റെ തീസിസ് പ്രതിരോധിക്കേണ്ടതുണ്ട്, അതിലെ ഒരു ഭാഗമാണ് XML പാഴ്സർ. പക്ഷേ, അത് PHP-യിൽ ഇല്ല എന്നത് ഖേദകരമാണ്. ശരി, സാരമില്ല, ഒരു മിനിറ്റിനുള്ളിൽ ഞങ്ങൾ കണ്ടെത്തും
ഞാൻ ഒരുപാട് xml പാഴ്സറുകൾ കണ്ടിട്ടുണ്ട്, പക്ഷേ വെബ് പ്രോഗ്രാമിംഗിൽ ഞാൻ സ്പർശിച്ചിട്ടില്ല. ഒരു ലളിതമാക്കുന്നത് എങ്ങനെയെന്ന് നിങ്ങളോടൊപ്പം കണ്ടെത്താനും പഠിക്കാനും ഇപ്പോൾ ഞാൻ ആഗ്രഹിക്കുന്നു xml പാഴ്സർ php-ൽ.
എന്തിനായി? അത്യാവശ്യം!
ഇല്ല, ശരിയാണ്, യഥാർത്ഥത്തിൽ: xml ഫയലുകൾ വളരെ ഉപയോഗപ്രദമായ കാര്യമാണ്. ഏതൊരു പ്രൊഫഷണലും വേണം... ഇല്ല, പാടില്ല, എന്നാൽ അവരുമായി എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് അറിഞ്ഞിരിക്കണം. ഞങ്ങൾ പ്രൊഫഷണലുകളാകാൻ ആഗ്രഹിക്കുന്നു, അല്ലേ? നിങ്ങൾ എൻ്റെ ബ്ലോഗിലാണെങ്കിൽ, നിങ്ങൾക്ക് അത്തരമൊരു ആഗ്രഹമുണ്ട്.
XML എന്താണെന്ന് ഞങ്ങൾക്ക് അറിയാമെന്നും അത് ഇവിടെ വിവരിക്കുന്നില്ലെന്നും ഞങ്ങൾ അനുമാനിക്കുന്നു. ശരി, ഞങ്ങൾക്ക് അറിയില്ലെങ്കിൽ, നമുക്ക് ഇവിടെ എളുപ്പത്തിൽ കണ്ടെത്താനാകും: http://ru.wikipedia.org/wiki/XML
PHP-യിൽ XML പാഴ്സ് ചെയ്യാനുള്ള വഴികൾക്കായി തിരയുന്നതിനിടയിൽ, XML ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനായി PHP-യിൽ ഒരു ലളിതമായ ഫംഗ്ഷനുകൾ ഞാൻ കണ്ടെത്തി " XML പാർസർ പ്രവർത്തനങ്ങൾ" xml_parser_create ഫംഗ്ഷൻ വിളിച്ച് പാഴ്സർ ആരംഭിക്കുന്നതിലൂടെ പാഴ്‌സിംഗ് ആരംഭിക്കുന്നു:
$xml_parser = xml_parser_create();
തുടർന്ന്, പാഴ്‌സിംഗ് പ്രക്രിയയിൽ അഭിമുഖീകരിക്കുന്ന xml ടാഗുകളും ടെക്സ്റ്റ് വിവരങ്ങളും ഏത് ഫംഗ്ഷനുകൾ പ്രോസസ്സ് ചെയ്യുമെന്ന് പാഴ്‌സറോട് പറയേണ്ടതുണ്ട്. ആ. നിങ്ങൾ ചില ഹാൻഡ്ലറുകൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്:
xml_set_element_handler($xml_parser, "startElement", "endElement");
മൂലകത്തിൻ്റെ തുടക്കവും എലമെൻ്റ് ഹാൻഡ്‌ലറുകളുടെ അവസാനവും ക്രമീകരിക്കുന്നതിന് ഈ ഫംഗ്ഷൻ ഉത്തരവാദിയാണ്. ഉദാഹരണത്തിന്, ഒരു xml ഫയലിൻ്റെ ടെക്‌സ്‌റ്റിൽ ഒരു കോമ്പിനേഷൻ കണ്ടെത്തിയാൽ, പാർസർ ഘടകം കണ്ടെത്തുമ്പോൾ സ്റ്റാർട്ട് എലമെൻ്റ് ഫംഗ്ഷൻ പ്രവർത്തിക്കും, അത് കണ്ടെത്തുമ്പോൾ endElement ഫംഗ്ഷൻ പ്രവർത്തിക്കും.
സ്റ്റാർട്ട് എലമെൻ്റും എൻഡ് എലമെൻ്റ് ഫംഗ്ഷനുകളും php ഡോക്യുമെൻ്റേഷൻ അനുസരിച്ച് നിരവധി പാരാമീറ്ററുകൾ എടുക്കുന്നു:
// (ഞങ്ങൾക്ക് നിരവധി പാഴ്സറുകൾ ഉപയോഗിക്കാമെന്നതിനാൽ)
// $attrs - കണ്ടെത്തിയ മൂലകത്തിൻ്റെ ആട്രിബ്യൂട്ടുകളുടെ ഒരു നിര
)ഫംഗ്ഷൻ endElement($parser, $name) (
// $parser - പാഴ്സറിൻ്റെ തനതായ ഐഡൻ്റിഫയർ
// $name - കണ്ടെത്തിയ മൂലകത്തിൻ്റെ പേര്
}
?>
എന്നാൽ ഒരു ഫയലിൽ നിന്ന് ഡാറ്റ എങ്ങനെ വായിക്കാം? ഒരു ഫംഗ്ഷനിലും ഇതിനുള്ള ഒരു പാരാമീറ്റർ പോലും ഞങ്ങൾ ഇതുവരെ കണ്ടിട്ടില്ല! ഇതിനെക്കുറിച്ച് പിന്നീട് കൂടുതൽ: ഫയൽ വായിക്കുന്നത് പ്രോഗ്രാമറുടെ ചുമലിലാണ്, അതായത്. ഫയലുകളിൽ പ്രവർത്തിക്കാൻ ഞങ്ങൾ സ്റ്റാൻഡേർഡ് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കണം:
ഫയൽ തുറന്നു. ഇപ്പോൾ നിങ്ങൾ ഇത് വരി വരിയായി വായിക്കുകയും റീഡ് ലൈനുകൾ xml_parse ഫംഗ്‌ഷനിലേക്ക് നൽകുകയും വേണം:
ഇവിടെ നാം വളരെ പ്രധാനപ്പെട്ട രണ്ട് കാര്യങ്ങൾ ശ്രദ്ധിക്കുന്നു. ആദ്യത്തേത്, xml_parse ഫംഗ്ഷൻ മൂന്നാം പാരാമീറ്ററിലെ അവസാന വരി റീഡിംഗ് ഫ്ലാഗ് പാസ്സാക്കേണ്ടതുണ്ട് (ശരി - വരി അവസാനത്തേതാണെങ്കിൽ, തെറ്റ് - ഇല്ലെങ്കിൽ). രണ്ടാമത്തെ കാര്യം, ഏതൊരു ബിസിനസ്സിലെയും പോലെ, ഇവിടെയും നാം തെറ്റുകൾ ശ്രദ്ധിക്കണം. xml_get_error_code, xml_error_string എന്നീ ഫംഗ്ഷനുകൾ ഇതിന് ഉത്തരവാദികളാണ്. ആദ്യ ഫംഗ്‌ഷന് പിശക് കോഡ് ലഭിക്കുന്നു, രണ്ടാമത്തേത്, ലഭിച്ച കോഡിൻ്റെ അടിസ്ഥാനത്തിൽ, പിശകിൻ്റെ ഒരു വാചക വിവരണം നൽകുന്നു. ഒരു പിശകിൻ്റെ ഫലമായി എന്ത് സംഭവിക്കുമെന്ന് പിന്നീട് ചർച്ചചെയ്യും. തുല്യമായ ഉപയോഗപ്രദമായ ഫംഗ്ഷൻ xml_get_current_line_number ഫയലിൽ പ്രോസസ്സ് ചെയ്യുന്ന നിലവിലെ ലൈനിൻ്റെ എണ്ണം ഞങ്ങളോട് പറയും.
എല്ലായ്പ്പോഴും എന്നപോലെ, സിസ്റ്റം കൈവശപ്പെടുത്തിയിരിക്കുന്ന വിഭവങ്ങൾ ഞങ്ങൾ സ്വതന്ത്രമാക്കണം. XML പാഴ്സിങ്ങിന്, ഇതാണ് xml_parser_free ഫംഗ്ഷൻ:
xml_parser_free($xml_parser);
ഇവിടെ ഞങ്ങൾ പ്രധാന പ്രവർത്തനങ്ങൾ പരിശോധിച്ചു. അവർ പ്രവർത്തിക്കുന്നത് കാണേണ്ട സമയമാണിത്. ഇതിനായി ഞാൻ വളരെ ലളിതമായ ഘടനയുള്ള ഒരു xml ഫയൽ കൊണ്ടുവന്നു:
123
നമുക്ക് ഈ ഫയലിനെ data.xml എന്ന് വിളിക്കാം, ഇനിപ്പറയുന്ന കോഡ് ഉപയോഗിച്ച് ഇത് പാഴ്സ് ചെയ്യാൻ ശ്രമിക്കാം:
ഫംഗ്ഷൻ സ്റ്റാർട്ട് എലമെൻ്റ്($പാഴ്സർ, $നെയിം, $attrs) (
ആഗോള $depth;echo str_repeat(" ", $depth * 3); // ഇൻഡൻ്റേഷൻ
പ്രതിധ്വനി " ഘടകം: $പേര്
"; // മൂലകത്തിൻ്റെ പേര്
$ഡെപ്ത്++; // ഡെപ്ത് വർദ്ധിപ്പിക്കുക, അങ്ങനെ ബ്രൗസർ ഇൻഡൻ്റേഷൻ കാണിക്കുന്നു
xml_set_element_handler($xml_parser, "startElement", "endElement");
എങ്കിൽ (!($fp = fopen($file, "r"))) (
ഡൈ ("എക്സ്എംഎൽ ഇൻപുട്ട് തുറക്കാൻ കഴിഞ്ഞില്ല");
}
അതേസമയം ($data = fgets ($fp)) (
എങ്കിൽ (!xml_parse ($xml_parser, $data, feof ($fp))) (
പ്രതിധ്വനി "
XML പിശക്: ";
echo xml_error_string(xml_get_error_code($xml_parser));
echo " എന്ന വരിയിൽ ".xml_get_current_line_number($xml_parser);
ബ്രേക്ക്;
}
}
xml_parser_free($xml_parser);
?>
ഞങ്ങൾ വികസിപ്പിച്ച ഏറ്റവും ലളിതമായ സ്ക്രിപ്റ്റിൻ്റെ ഫലമായി, ബ്രൗസർ അതിൻ്റെ വിൻഡോയിൽ ഇനിപ്പറയുന്ന വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നു:
ഘടകം: റൂട്ട് ഘടകം: INFO ആട്രിബ്യൂട്ട്: WHO = എൻ്റെ ഘടകം: ADDRESS ആട്രിബ്യൂട്ട്: ULICA = എൻ്റെ തെരുവ്!! ആട്രിബ്യൂട്ട്: KVARTIRA = 12 ആട്രിബ്യൂട്ട്: DOM = 15 ഘടകം: PHONE
ടാഗ് മാറ്റി XML ഫയൽ കേടാക്കാൻ ശ്രമിക്കാം
ഘടകം: റൂട്ട് ഘടകം: INFO ആട്രിബ്യൂട്ട്: WHO = എൻ്റെ ഘടകം: ADDRESS ആട്രിബ്യൂട്ട്: ULICA = എൻ്റെ തെരുവ്!! ആട്രിബ്യൂട്ട്: KVARTIRA = 12 ആട്രിബ്യൂട്ട്: DOM = 15 ഘടകം: TELEPHONE
XML പിശക്: വരി 5-ലെ ടാഗ് പൊരുത്തപ്പെടുന്നില്ല
വൗ! പിശക് സന്ദേശങ്ങൾ പ്രവർത്തിക്കുന്നു! കൂടാതെ തികച്ചും വിജ്ഞാനപ്രദവും.
ഓ, ഞാൻ ഒരു കാര്യം കൂടി മറന്നു... വിലാസത്തിലും ഫോൺ ടാഗുകളിലും ഉള്ള വാചകം ഞങ്ങൾ പ്രദർശിപ്പിച്ചില്ല. ഞങ്ങളുടെ പോരായ്മ ഞങ്ങൾ ശരിയാക്കുന്നു - xml_set_character_data_handler ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഒരു ടെക്സ്റ്റ് ഹാൻഡ്‌ലർ ചേർക്കുക:
xml_set_character_data_handler($xml_parser, 'stringElement');
കൂടാതെ കോഡിലേക്ക് ഹാൻഡ്‌ലർ ഫംഗ്ഷൻ തന്നെ ചേർക്കുക:
ഇനി ഔട്ട്പുട്ട് നോക്കാം:
ഘടകം: റൂട്ട് ഘടകം: INFO ആട്രിബ്യൂട്ട്: WHO = എൻ്റെ ഘടകം: ADDRESS ആട്രിബ്യൂട്ട്: ULICA = എൻ്റെ തെരുവ്!! ആട്രിബ്യൂട്ട്: KVARTIRA = 12 ആട്രിബ്യൂട്ട്: DOM = 15 സ്ട്രിംഗ്: 123 ഘടകം: ഫോൺ സ്ട്രിംഗ്: +71234567890
കുറിച്ച്! ഇപ്പോൾ എല്ലാം പുറത്തെടുത്തു!
വഴിയിൽ, ടാഗ്, ആട്രിബ്യൂട്ട് പേരുകൾ എല്ലാം വലിയ അക്ഷരങ്ങളിൽ എഴുതിയിരിക്കുന്നത് ആരെങ്കിലും ശ്രദ്ധിച്ചിട്ടുണ്ടോ? വിചിത്രം... നമ്മുടെ xml ഫയലിൽ അവ ചെറിയ അക്ഷരങ്ങളിൽ സൂചിപ്പിച്ചിരിക്കുന്നു. പ്രത്യക്ഷത്തിൽ ചില ക്രമീകരണങ്ങൾ വലിയക്ഷരം ചെയ്യാൻ എവിടെയോ സജ്ജീകരിച്ചിരിക്കുന്നു...
ആഹ്, കണ്ടെത്തി! xml_parser_set_option എന്ന ഫംഗ്‌ഷനും ഉണ്ടെന്ന് ഇത് മാറുന്നു:
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 0);
ഈ കോൾ ഉപയോഗിച്ച് ഞങ്ങൾ ആട്രിബ്യൂട്ട് പേരുകളുടെയും ടാഗ് നാമങ്ങളുടെയും വലിയ അക്ഷരങ്ങളിൽ അച്ചടിക്കുന്നത് റദ്ദാക്കുന്നു:
മൂലകം: റൂട്ട് ഘടകം: വിവരം ആട്രിബ്യൂട്ട്: ആരാണ് = എൻ്റെ ഘടകം: വിലാസം ആട്രിബ്യൂട്ട്: ulica = എൻ്റെ തെരുവ്!! ആട്രിബ്യൂട്ട്: kvartira = 12 ആട്രിബ്യൂട്ട്: dom = 15 സ്ട്രിംഗ്: 123 ഘടകം: ഫോൺ സ്ട്രിംഗ്: +71234567890
ഈ ലേഖനത്തിൽ, ഞങ്ങൾ ഏറ്റവും ലളിതമായ, എന്നാൽ മിക്ക ജോലികൾക്കും, XML ഫയലുകളിൽ നിന്ന് വിവരങ്ങൾ വേർതിരിച്ചെടുക്കുന്നതിനുള്ള മതിയായ മാർഗ്ഗം നോക്കി. കൂടുതൽ ശക്തമായ മറ്റു ചില രീതികളെക്കുറിച്ചും ഞാൻ കേട്ടിട്ടുണ്ട്, എന്നാൽ ഞാൻ സ്വയം പഠിക്കുമ്പോൾ അവ പരിഗണിക്കും
നിക്ക, നിങ്ങൾ ഒരു കോൾ ചേർക്കേണ്ടതുണ്ട്
xml_set_character_data_handler($xml_parser, 'stringElement');
ശേഷം
xml_set_element_handler($xml_parser, "startElement", "endElement");
പൊതുവേ, ശരിയായ പ്രദർശനത്തിനായി നിങ്ങൾ ഇനിപ്പറയുന്നവ നിരീക്ഷിക്കേണ്ടതുണ്ട്:
1. xml ഫയൽ UTF-8 എൻകോഡിംഗിലായിരിക്കണം
2. xml ഫയലിലെ ആദ്യ വരി ഇതുപോലെയായിരിക്കണം:
< ?xml version="1.0" encoding="UTF-8"?>
3. നിങ്ങൾ ഇതുപോലെ പാഴ്സർ സമാരംഭിക്കേണ്ടതുണ്ട്:
xml_parser_create("UTF-8?);
4. xml ഫയലിൻ്റെ ഉള്ളടക്കങ്ങൾ ബ്രൗസറിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യുന്നതിന് മുമ്പ്, നിങ്ങൾ രണ്ടാമത്തേത് UTF-8 എൻകോഡിംഗിലേക്ക് കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്:
തലക്കെട്ട് ("ഉള്ളടക്ക-തരം: വാചകം/html; charset=utf-8?);
റഷ്യൻ ഭാഷയിൽ വാചകം പ്രദർശിപ്പിക്കുന്നതിന് ഞങ്ങൾ ഉപയോഗിക്കുന്നു
iconv("UTF-8?,"windows-1251?, $attr), ഇവിടെ $attr ആണ് ഔട്ട്പുട്ട് ചെയ്യേണ്ടത്.
സ്റ്റാൻഡേർഡ് PHP5 ലൈബ്രറിയിൽ രസകരമായ രണ്ട് ക്ലാസുകളുണ്ട് - DOMDocument() കൂടാതെ XSLTPprocesor() ഞാൻ വളരെ വലിയ പ്രോജക്ടുകളിൽ ഉപയോഗിച്ചു - ഞാൻ പരാതിപ്പെടുന്നില്ല =)
പൊതുവേ, SAX തത്വം ഉപയോഗിച്ച് XML പാഴ്സ് ചെയ്യുന്നതിനായി PHP-ക്ക് മറ്റൊരു ലൈബ്രറി ഉണ്ട് - XMLReader എന്ന് വിളിക്കുന്നു.
മാന്യരേ, സിംപ്ലക്‌സ്എംഎൽ ഉപയോഗിച്ച് xml-ൽ നിന്ന് നിലവാരമില്ലാത്ത ടാഗുകൾ എങ്ങനെ ഔട്ട്പുട്ട് ചെയ്യാം?
$text = $item->yandex:full-text പോലെയുള്ള ഒരു വേരിയബിൾ പ്രവർത്തിക്കുന്നില്ല.
എല്ലാം ശരിയാണ്, ഇനിപ്പറയുന്ന പാരാമീറ്ററിൻ്റെ സാന്നിധ്യം ശ്രദ്ധിക്കുക,
ഫംഗ്ഷൻ cdata($parser, $cdata)
{
var_dump ($ പാർസർ, $ cdata);
}
xml_set_character_data_handler($this->parser, "cdata");
അതില്ലാതെ, CDATA ഉപയോഗിച്ച് XML പാഴ്സ് ചെയ്യാൻ അയാൾ ആഗ്രഹിക്കുന്നില്ല…. 1.5 മീറ്റർ വലിപ്പം
2Nika, ഹെഡർ() ഫംഗ്ഷൻ അതിന് മുമ്പ് ഒന്നും ഔട്ട്പുട്ട് ചെയ്‌തില്ലെങ്കിൽ മാത്രമേ പ്രവർത്തിക്കൂ, അതായത്, അത് ആദ്യം നിർവ്വഹിച്ചത്, കാരണം ടെക്സ്റ്റ് UTF-8 എൻകോഡിംഗിലേക്ക് പരിവർത്തനം ചെയ്യേണ്ടതുണ്ടെന്ന് ഞങ്ങളോട് പറയുന്ന തലക്കെട്ടുകൾ ഞങ്ങൾ ഈ പേജിലേക്ക് അയയ്ക്കുന്നു. നിങ്ങളുടെ പിശകിൻ്റെ അടിസ്ഥാനത്തിൽ, നിങ്ങൾക്ക് ലൈനുകൾ നഷ്‌ടമായതിനാൽ ഇത് ഇതുപോലെ ചെയ്യുക:
മൂല്യം == വരി ക്രമ സംഖ്യ
തലക്കെട്ട് ("ഉള്ളടക്ക-തരം: വാചകം/html; charset=utf-8?); == 2
വാസ്തവത്തിൽ എല്ലാം വളരെ ലളിതമാണ്
yurban.ru/development/php_xml_parser
