Articolul este dedicat analizării, în special analizării site-ului web, analizării paginilor, analizării web, analizării conținutului html a site-ului web.

În procesul de dezvoltare a diverselor servicii web, întâlnim foarte des sarcini în care este necesară obținerea rapidă a diverselor tipuri de informații în volume mari. Acest lucru este legat în principal de acaparare, furt de informații, cum vrei să-i spui. Ideea este că informațiile sunt accesibile și deschise. Particularitatea analizei este colectarea rapidă și automată a datelor și a conținutului de pe paginile site-ului web.

În zilele noastre este foarte popular să scrape în mediul web, și anume să scrape un site care conține cel puțin o anumită valoare și relevanță pentru oameni. De o valoare deosebită este catalogul de produse, inclusiv imagini, baze de date directoare și multe altele care pot fi utile concurenților.

Să încercăm să analizăm informațiile necesare în html, să încercăm să obținem toate linkurile din mai multe pagini ale site-ului nostru.

În primul rând, trebuie să obținem conținutul site-ului în format html. Pentru a face acest lucru, trebuie doar să cunoaștem adresele paginilor necesare.

Vreau să arăt 2 modalități principale de a obține conținut de pe o pagină de site:

Mai întâi de toate, să pregătim o matrice cu adresele de pagină necesare:

//3 link-uri către site-ul nostru: $urls = array("http://hello-site..ru/games/");

Opțiunea 1 - funcția php file_get_contents. Funcția returnează un șir html pe care îl vom analiza în link-uri:

//puneți fiecare link în funcția file_get_contents foreach($urls as $urlsItem)( $out .= file_get_contents($urlsItem); //și adăugați conținutul fiecărei pagini la linie ) echo $out; //aici este conținutul tuturor celor trei pagini

Opțiunea 2 - CURL. O bibliotecă care este susținută de php și are un set mare de setări, de la solicitări POST până la lucrul cu FTP. Să luăm în considerare un apel standard la biblioteca curl, care ne va oferi conținutul site-ului:

foreach($urls ca $urlsItem)( //trimite fiecare link într-o buclă $output = curl_init(); //conectați curl curl_setopt($output, CURLOPT_URL, $urlsItem); //trimite adresa paginii curl_setopt($output, CURLOPT_RETURNTRANSFER, 1); curl_setopt($output, CURLOPT_HEADER, 0 .= curl_exec($output); //aici este conținutul tuturor celor trei pagini

Acum linia noastră $out conține conținutul tuturor celor trei pagini. Deci, să trecem direct la analizarea șirului nostru.

Din nou, vreau să arăt 3 opțiuni pentru rezolvarea problemei noastre: metoda „nativă” în PHP, folosind biblioteca încorporată DOMDocument și biblioteca SimpleHTMLDOM.

1. funcția php explode. Funcția găsește caracterul căutat sau o parte dintr-un șir și împarte întregul șir în elemente de matrice.

Repet, trebuie să obținem valorile tuturor atributelor href ale etichetelor a, pentru aceasta vom împărți șirul general în câteva părți\segmente:

// explode $hrefs = explode("

Dacă imprimăm matricea noastră, va arăta cam așa:

Array ( => / => /hello => /timer/ => /leftmenu/ => /faq/ => /blog/ => /web-notes/ => /ordersite/ => /jocuri)

2. bibliotecă DOMDocument încorporată. Lucrăm cu clasa aproximativ după cum urmează:

//domelement $dom = nou DOMDocument; //creează un obiect $dom->loadHTML($out); //încărcare conținut $node = $dom->getElementsByTagName("a"); //ia toate etichetele a pentru ($i = 0; $i< $node->lungime; $i++) ( $hrefText = $node->item($i)->getAttribute("href"); //obțineți atributul href din etichetă) foreach($hrefText as $hrefTextItem)( //scăpați de legături cu un atribut gol href if($hrefTextItem!="")( $clearHrefs=$hrefTextItem; ) ) $clearHrefs = array_unique($clearHrefs); //scapa de linkurile identice print_r($clearHrefs); // la final avem o matrice cu toate linkurile din 3 pagini

Rezultatul acestui cod este exact același cu utilizarea funcției de explozie.

3. Biblioteca SimpleHTMLDOM. Trebuie inclus dintr-un fișier. Lucrarea este aproximativ similară cu DOMDocument. Lucrul cu clasa:

//simplehtml include("simple_html_dom.php"); //include un fișier cu clasa SimpleHTMLDOM $html = new simple_html_dom(); //cream un obiect $html->load($out); //plasați conținutul nostru $colecție = $html->find("a"); //colectați toate etichetele un foreach($colecție ca $collectionItem) ( $articles = $collectionItem->attr; //matrice de toate atributele, href inclusiv ) foreach($articles as $articlesItem)( $hrefText = $articlesItem[ " href"]; //să colecteze valorile subbaryului cu cheia href într-o matrice) foreach($hrefText ca $hrefTextItem)( //scăpați de legăturile cu un atribut href gol if($hrefTextItem!="" )( $clearHrefs=$hrefTextItem; ) ) $clearHrefs = array_unique($clearHrefs); //scapa de linkurile identice print_r($clearHrefs); // la final avem o matrice cu toate linkurile din 3 pagini

Repet, rezultatul din matrice este exact același ca în cele două de mai sus.

Acum, având o matrice cu toate link-urile colectate de pe trei pagini ale site-ului, puteți trimite link-urile în direcția corectă, totul depinde de sarcină și imaginație. Având astfel de capacități, puteți analiza o cantitate mare de date de diferite tipuri de informații, imagini, texte, jurnale etc. Informațiile altcuiva sunt în mâinile tale, aruncă-le după cum vrei, dar apără-te, deși acest lucru este imposibil)

Pentru a scrie un script bun și funcțional pentru analizarea conținutului, trebuie să petreceți mult timp. Și în cele mai multe cazuri, merită să abordați individual site-ul donator, deoarece există o mulțime de nuanțe care pot complica soluția sarcinii noastre. Astăzi vom analiza și implementa un script parser folosind CURL și, de exemplu, vom obține categoriile și produsele unuia dintre magazinele populare.

Dacă ați ajuns la acest articol dintr-o căutare, atunci probabil că aveți o sarcină specifică în față și încă nu v-ați gândit la ce altceva ați putea avea nevoie de un parser. Prin urmare, înainte de a pătrunde în teorie și direct în cod, vă sugerez să citiți articolul anterior - unde a fost luată în considerare una dintre opțiunile simple și mă voi referi periodic la aceasta.

Vom lucra cu CURL, dar mai întâi, să ne dăm seama ce înseamnă această abreviere. CURL este un program de linie de comandă care ne permite să comunicăm cu serverele folosind diverse protocoale, în cazul nostru HTTP și HTTPS. Pentru a lucra cu CURL, PHP are biblioteca libcurl, ale cărei funcții le vom folosi pentru a trimite cereri și a primi răspunsuri de la server.

După cum puteți vedea din captură de ecran, toate categoriile sunt într-o listă nenumerată și subcategorii:

În interiorul elementului de listă de hoteluri în același nenumerotat. Structura este simplă, rămâne doar să o obțineți. Vom prelua bunurile din secțiunea „Toate telefoanele”:

Pe pagina sunt 24 de produse, din fiecare vom extrage: o poza, nume, link catre produs, caracteristici si pret.

Scrierea unui script parser

Dacă ați citit deja articolul anterior, atunci s-ar putea sublinia că procesul și scriptul de analiză a site-ului constă din două părți:

1. Trebuie să obținem codul HTML al paginii de care avem nevoie;
2. Analizarea codului primit, salvarea datelor și procesarea ulterioară a acestuia (ca și în primul articol despre analizare, vom folosi phpQuery, în el veți găsi și cum să îl instalați prin compozitor).

Pentru a rezolva primul punct, vom scrie o clasă simplă cu o singură metodă statică, care va fi un wrapper peste CURL. În acest fel codul poate fi folosit în viitor și, dacă este necesar, modificat. Primul lucru pe care trebuie să-l decidem este ce vor fi numite clasa și metoda și ce parametri necesari vor avea:

Class Parser(funcția publică statică getPage($params = )( if($params)( if(!empty($params["url"]))( $url = $params["url"]; // Scrieți restul a codului aici ) ) return false;

Metoda principală pe care o vom avea este getPage() și are un singur parametru necesar, URL-ul paginii pe care o vom analiza. Ce altceva va putea face metoda noastră minunată și ce valori vom procesa în ea:

• $useragent – ​​este important pentru noi să putem seta antetul User-Agent, astfel încât să ne putem face apelurile către server asemănătoare cu apelurile din browser;
• $timeout – va fi responsabil pentru timpul de executare a cererii către server;
• $connecttimeout – este de asemenea important să specificați timpul de expirare a conexiunii;
• $head – dacă trebuie să verificăm doar anteturile pe care serverul le oferă solicitării noastre, vom avea nevoie pur și simplu de acest parametru;
• $cookie_file – totul este simplu aici: un fișier în care cookie-urile donatorului nostru de conținut vor fi înregistrate și transferate atunci când sunt accesate;
• $cookie_session – uneori poate fi necesar să interziceți transferul cookie-urilor de sesiune;
• $proxy_ip – un parametru care spune, IP-ul serverului proxy, astăzi vom analiza câteva pagini, dar dacă sunt necesare câteva mii, atunci nu există nicio cale fără proxy;
• $proxy_port – respectiv portul serverului proxy;
• $proxy_type – tip proxy CURLPROXY_HTTP, CURLPROXY_SOCKS4, CURLPROXY_SOCKS5, CURLPROXY_SOCKS4A sau CURLPROXY_SOCKS5_HOSTNAME;
• $headers – mai sus am indicat parametrul responsabil pentru antetul User-Agent, dar uneori trebuie să trecem și alții în plus față de acesta, pentru asta avem nevoie de o matrice de anteturi;
• $post – pentru trimiterea unei cereri POST.

Desigur, există o mulțime de valori procesate și nu toate vor fi folosite pentru sarcina noastră astăzi, dar merită să le sortăm, deoarece atunci când analizați mai mult de o pagină, o mare parte din ceea ce este descris mai sus va fi util. Și să le adăugăm la scriptul nostru:

$useragent = !empty($params["useragent"]) ? $params["useragent"] : "Mozilla/5.0 (Windows NT 6.3; W...) Gecko/20100101 Firefox/57.0"; $timeout = !empty($params["timeout"]) ? $params["timeout"]: 5; $connecttimeout = !empty($params["connecttimeout"]) ? $params["connecttimeout"] : 5; $head = !empty($params["head"]) ? $params["head"] : false; $cookie_file = !empty($params["cookie"]["fișier"]) ? $params["cookie"]["fișier"] : false; $cookie_session = !empty($params["cookie"]["session"]) ? $params["cookie"]["session"] : fals; $proxy_ip = !empty($params["proxy"]["ip"]) ? $params["proxy"]["ip"] : fals; $proxy_port = !empty($params["proxy"]["port"]) ? $params["proxy"]["port"] : false; $proxy_type = !empty($params["proxy"]["tip"]) ? $params["proxy"]["tip"] : fals; $headers = !empty($params["headers"]) ? $params["headers"] : false; $post = !empty($params[„post”]) ? $params[„post”] : fals;

După cum puteți vedea, toți parametrii au valori implicite. Să trecem mai departe și să scriem o bucată de cod în următoarea linie care va șterge fișierul cookie atunci când vi se va solicita:

If($fișier_cookie)( fișier_pus_conținut(__DIR__."/".$fișier_cookie, ""); )

Astfel ne vom proteja de o situație în care dintr-un motiv oarecare fișierul nu este creat.

Pentru a lucra cu CURL, trebuie mai întâi să inițializam sesiunea și să o închidem atunci când lucrarea este finalizată. , vom face acest lucru în felul următor:

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); // În continuare continuăm codificarea aici curl_setopt($ch, CURLINFO_HEADER_OUT, true); $conținut = curl_exec($ch); $info = curl_getinfo($ch); $eroare = fals; if($conținut === fals)( $date = fals; $eroare["mesaj"] = curl_error($ch); $error["code"] = self::$error_codes[ curl_errno($ch) ]; )else( $date["conținut"] = $conținut; $date["informații"] = $informații; ) curl_close($ch); return [ "data" => $date, "error" => $eroare ];

Primul lucru pe care îl puteți observa este proprietatea statică $error_codes, pe care o accesăm, dar nu a fost încă descrisă. Aceasta este o matrice cu codurile pentru funcția curl_errno() decriptate, să o adăugăm și apoi să ne uităm la ce se întâmplă mai sus.

Private static $error_codes = [ "CURLE_UNSUPPORTED_PROTOCOL", "CURLE_FAILED_INIT", // Sunt peste 60 de elemente, în arhivă veți găsi întreaga listă "CURLE_FTP_BAD_FILE_LIST", "CURLE_CHUNK_FAILED" ];

După ce am inițializat conexiunile prin funcția curl_setopt(), vom seta câțiva parametri pentru sesiunea curentă:

• CURLOPT_URL – prima și obligatorie este adresa căreia ne adresăm;
• CURLINFO_HEADER_OUT – o matrice cu informații despre conexiunea curentă.

Folosind funcția curl_exec(), facem direct o solicitare folosind CURL și salvăm rezultatul în variabila $content În mod implicit, după procesarea cu succes, rezultatul va fi afișat pe ecran și $content va fi setat la adevărat. Funcția curl_getinfo() ne va ajuta să urmărim informațiile conexe în timpul unei solicitări. De asemenea, este important ca, dacă apare o eroare, rezultatul comunicării va fi fals, prin urmare, mai jos în cod folosim egalitatea strictă ținând cont de tipuri. Rămâne de luat în considerare încă două funcții: curl_error() - va returna un mesaj de eroare și curl_errno() - codul de eroare. Rezultatul metodei getPage() va fi o matrice și, pentru a o vedea, să-l folosim și, pentru testare, să facem o cerere către serviciul httpbin pentru a obține IP-ul nostru.

Apropo, un serviciu foarte convenabil care vă permite să depanați apelurile către server. Deoarece, de exemplu, pentru a afla IP-ul nostru sau anteturile trimise prin CURL, ar trebui să scriem o cârjă.

$html = Parser::getPage([ "url" => "http://httpbin.org/ip" ]);

Dacă îl afișați pe ecran, ar trebui să aveți o imagine similară:

Dacă apare o eroare, rezultatul va arăta astfel:

Dacă cererea are succes, primim o celulă completată a matricei de date cu conținut și informații despre cerere, dacă există o eroare, celula de eroare este completată. De la prima captură de ecran, poate ați observat prima problemă, despre care am scris mai sus, conținutul nu a fost salvat într-o variabilă, ci a fost desenat pe pagină. Pentru a rezolva acest lucru, trebuie să adăugăm un alt parametru de sesiune, CURLOPT_RETURNTRANSFER.

Curl_setopt($ch, CURLOPT_RETURNTRANSFER, adevărat);

La accesarea paginilor, putem constata că acestea redirecționează către altele, pentru a obține rezultatul final adăugăm:

Curl_setopt($ch, CURLOPT_FOLLOWLOCATION, adevărat);

Acum puteți vedea o imagine mai plăcută:

Curl_setopt($ch, CURLOPT_USERAGENT, $useragent); curl_setopt($ch, CURLOPT_TIMEOUT, $timeout); curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $connecttimeout);

Pentru a obține antetele răspunsului, va trebui să adăugăm următorul cod:

If($head)( curl_setopt($ch, CURLOPT_HEADER, adevărat); curl_setopt($ch, CURLOPT_NOBODY, adevărat); )

Am dezactivat ieșirea corpului documentului și am activat ieșirea antetului ca rezultat:

If(strpos($url, "https") !== false)( curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, adevărat); curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, adevărat); )

Primim deja un script de analiză de conținut foarte bun, am ajuns la cookie-uri și aici este de remarcat că o problemă comună este atunci când acestea nu sunt salvate. Unul dintre motivele principale poate fi specificarea unei căi relative, așa că ar trebui să luăm în considerare acest lucru și să scriem următoarele rânduri:

If($cookie_file)( curl_setopt($ch, CURLOPT_COOKIEJAR, __DIR__."/".$cookie_file); curl_setopt($ch, CURLOPT_COOKIEFILE, __DIR__."/".$cookie_file); if($cookie_session)($cookie_session) , CURLOPT_COOKIESESSION, adevărat);

Vă sugerez să-l verificați și, pentru a face acest lucru, voi încerca să scot cookie-uri de pe site-ul meu:

If($proxy_ip && $proxy_port && $proxy_type)( curl_setopt($ch, CURLOPT_PROXY, $proxy_ip.":".$proxy_port); curl_setopt($ch, CURLOPT_PROXYTYPE, $proxy_type); ) if($headers)( curl_setopt $ch, CURLOPT_HTTPHEADER, $headers ) if($post)( curl_setopt($ch, CURLOPT_POSTFIELDS, $post); )

Aceasta este o mică parte din parametrii cu care puteți lucra; documentația oficială PHP. Acum am terminat cu ambalajul nostru, este timpul să analizăm ceva!

Analizarea categoriilor și a produselor de pe site

Acum, folosind clasa noastră Parser, putem face o solicitare și obținem o pagină cu conținut. Hai să o facem:

$html = Parser::getPage([ "url" => "https://www.svyaznoy.ru/catalog" ]);

Următorul pas este să analizați răspunsul primit și să salvați numele categoriei și linkul în matricea rezultată:

If(!empty($html["date"]))( $conținut = $html["date"]["conținut"]; phpQuery::newDocument($conținut); $categorii = pq(".b-category) -menu")->find(".b-category-menu__link"); $tmp = ; foreach($categorii ca $cheie => $categorie)( $categorie = pq($categorie); $tmp[$cheie] = [ "text" => trim($categorie->text()), "url" => trim($categorie->attr("href")) ] $submeniu = $categorie->next(".b -category-submeniu")->find(".b-category-submeniu__link"); foreach($submeniu ca $submen)( $submen = pq($submen); $tmp[$key]["submeniu"] = [ "text" => trim($submen->text()), "url" => trim($submen->attr("href")) ] ) phpQuery::unloadDocuments();

Am discutat despre lucrul cu phpQuery mai detaliat în primul articol despre analizarea conținutului. Pe scurt, trecem prin arborele DOM și scoatem datele de care avem nevoie. Am decis să le tăiem pentru a elimina spațiile suplimentare; Acum să afișăm categoriile pe ecran:

• " target="_blank">
  • " target="_blank">

$html = Parser::getPage([ "url" => "https://www.svyaznoy.ru/catalog/phone/224", "timeout" => 10 ]);

Primim pagina, aici am mărit timpul de conectare, deoarece 5 secunde nu au fost suficiente și o analizăm, parsând conținutul necesar:

If(!empty($html["date"]))( $conținut = $html["date"]["conținut"]; phpQuery::newDocument($content); $produse = pq(".b-listing__generated) -container")->find(".b-product-block .b-product-block__content"); $tmp = ; foreach($produse ca $cheie => $produs)( $produs = pq($produs); $tmp = [ "nume" => trim($produs->find(".b-product-block__name")->text()), "image" => trim($produs->find(".b- product-block__image img")->attr("data-original"), "price" => trim($product->find(".b-product-block__misc .b-product-block__visible-price")-> text()), "url" => trim($product->find(".b-product-block__info .b-product-block__main-link")->attr("href")) ]; product->find(".b-product-block__info .b-product-block__tech-chars li"); foreach($chars as $char)( $tmp[$key]["chars"] = pq($char) ->text(); ) phpQuery::unloadDocuments();

Acum să verificăm ce avem și să-l afișăm pe ecran:

" target="_blank" class="tovar"> " alt="" />

Așa că am scris un parser de conținut PHP, după cum puteți vedea, nu este nimic complicat, folosind acest script puteți analiza cu ușurință paginile oricărui site, dar înainte de a termina articolul, am vrut să clarific câteva puncte. În primul rând, dacă doriți să analizați mai mult de o pagină, atunci nu trebuie să uitați că procesul de analizare a unei resurse în sine este o operațiune costisitoare, așa că în mod ideal este mai bine ca scriptul să fie mutat pe un server separat, unde va fi rulați prin cron. Încă un punct - fiecare donator ar trebui abordat individual, pentru că, în primul rând: au cod HTML diferit și se poate schimba în timp, și în al doilea rând: pot exista diferite protecții împotriva analizării și verificării, așa că pentru a selecta necesarul un set de anteturi și parametrii pot necesita un proxy de depanare (eu folosesc Fiddler). Și ultimul lucru pe care îl voi adăuga este să folosesc proxy-uri pentru parsare, și cu cât mai mulți, cu atât mai bine, pentru că atunci când mii de solicitări sunt trimise către serverul donatorului, inevitabil IP-ul de la care se face cererea va fi interzis, așa că merită trimis. solicitările dvs. prin intermediul unui server proxy.

Puteți găsi un exemplu complet cu biblioteca phpQuery pe github.

Excelent articol. Multumesc. În acest moment învăț despre PHP și subiectul analizatorilor.

Ma bucur ca ti-a placut articolul. Într-una dintre următoarele, vă voi spune despre soluții gata făcute pentru analizarea site-urilor web.

Dacă trebuie să analizați un document HTML, expresiile regulate nu sunt cea mai bună modalitate de a face acest lucru. În plus, scrierea lor este un proces care necesită multă muncă și reduc viteza aplicației PHP. În acest articol, veți învăța cum să utilizați un parser HTML gratuit pentru a citi, modifica și extrage unele elemente DOM din paginile HTML. Mai mult, resursa HTML poate fi o sursă externă. Adică adresa unei pagini HTML pe un alt domeniu. Folosind site-ul ca exemplu sitear.ru, veți învăța cum să obțineți și să afișați o listă cu toate materialele publicate pe pagina principală a site-ului. Cu alte cuvinte, vei face ceea ce trebuie să faci, analizând HTML folosind PHP. În acest caz, PHP înseamnă biblioteca simplă HTML DOM.

Doar urmați toți pașii din articol și veți învăța o mulțime de lucruri noi și utile pentru dvs.!

Pasul 1 – Pregătire

Mai întâi, trebuie să descărcați o copie simplu HTML dom biblioteci. Descărcați gratuit.

În arhivă veți găsi mai multe fișiere, dar avem nevoie doar de unul - simple_html_dom.php. Toate celelalte sunt exemple și documentație.

Pasul 2 – Noțiuni de bază pentru analizarea HTML

Această bibliotecă este foarte ușor de utilizat, dar totuși, trebuie să înțelegeți câteva elemente de bază înainte de a o folosi.

$html = new simple_html_dom(); // Încarcă dintr-un șir $html->load("

Salut Lume!

"); // Încarcă un fișier $html->load_file("http://site/");

Este simplu, poți crea un obiect încărcând HTML dintr-un șir. Sau încărcați codul HTML dintr-un fișier. Puteți descărca fișierul de la adresa URL sau de pe sistemul de fișiere local (server).

Important de reținut: Metoda load_file() funcționează folosind funcția PHP file_get_contents. Dacă în fișierul dvs. php.ini, parametrul allow_url_fopen nu este setat la true, nu veți putea primi fișiere HTML la adresa de la distanță. Dar, veți putea descărca aceste fișiere folosind biblioteca CURL. Apoi, citiți conținutul folosind metoda load().

Accesarea obiectelor HTML DOM

Să presupunem că avem deja un obiect DOM cu o structură ca cea din imaginea de mai sus. Puteți începe să lucrați cu el folosind metoda find() și creând colecții. Colecțiile sunt grupuri de obiecte găsite folosind selectoare - sintaxa este oarecum similară cu jQuery.

Salut Lume!

Suntem aici.

Folosind acest exemplu de cod HTML, vom învăța cum să accesăm informațiile conținute în al doilea paragraf (p). De asemenea, vom modifica informațiile primite și vom afișa rezultatul pe afișaj.

// creează un obiect parser și obține HTML include("simple_html_dom.php"); $html = new simple_html_dom(); $html->load("

Salut Lume!

"); // obținerea de matrice de paragrafe $element = $html->find("p"); // schimbarea informațiilor din interiorul unui paragraf $element->innertext .= "și noi suntem aici pentru a rămâne."; // iese echo $html->save();

După cum puteți vedea, este foarte ușor să implementați analiza PHP a unui document HTML folosind biblioteca simplă HTML DOM. În principiu, totul din această bucată de cod PHP poate fi înțeles intuitiv, dar dacă aveți îndoieli, ne vom uita la cod.

Linia 2-4: conectăm biblioteca, creăm un obiect de clasă și încărcăm cod HTML dintr-un șir.

Linia 7: Folosind această linie, găsim totul

etichete în codul HTML și stocate într-o variabilă ca o matrice. Primul paragraf va avea indicele 0, celelalte paragrafe vor fi indexate 1,2,3...

Linia 10: Obținem conținutul celui de-al doilea paragraf din colecția noastră. Indicele acestuia va fi 1. De asemenea, facem modificări textului folosind atributul innertext. Atributul innertext modifică tot conținutul din interiorul etichetei specificate. De asemenea, putem schimba eticheta în sine folosind atributul de text extern.

Să adăugăm o altă linie de cod PHP care va atribui o clasă de stil paragrafului nostru.

$element->class = "nume_clasa"; echo $html->salvare();

Rezultatul executării codului nostru va fi următorul document HTML:

Salut Lume!

Suntem aici și suntem aici pentru a rămâne.

Alti selectori

Mai jos sunt alte exemple de selectoare. Dacă ați folosit jQuery, atunci sintaxa din biblioteca simplă html dom este oarecum similară.

// obțineți primul element cu id="foo" $single = $html->find("#foo", 0); // la parsare, primește toate elementele cu clasa class="foo" $collection = $html->find(".foo"); // primește toate etichetele la analizarea unui document html $collection = $html->find("a"); // primește toate etichetele , care sunt plasate în etichetă

$colecție = $html->find("h1 a"); // primește toate imaginile cu title="himom" $collection = $html->find("img"); !}

Utilizarea primului selector atunci când php analizează un document html este foarte simplă și de înțeles. Unicitatea sa este că returnează un singur element html, spre deosebire de altele care returnează o matrice (colecție). Cu al doilea parametru (0), indicăm că avem nevoie doar de primul element al colecției noastre. Sper că înțelegeți toate opțiunile pentru selectoare din biblioteca simplă HTML DOM, dacă nu înțelegeți ceva, încercați metoda experimentului științific. Chiar dacă nu a ajutat, vă rugăm să comentați articolul.

Documentație simplă a bibliotecii HTML DOM

Puteți găsi documentația completă despre utilizarea bibliotecii simple HTML DOM la această adresă:

http://simplehtmldom.sourceforge.net/manual.htm

Vă voi oferi doar o ilustrare care arată posibilele proprietăți ale unui element DOM HTML selectat.

Pasul 3 – Exemplu real de analiză PHP a unui document HTML

Pentru un exemplu de analizare și punere în acțiune a bibliotecii HTML DOM, vom scrie un dispozitiv de prindere a materialelor pe un site web. În continuare, vom afișa toate articolele sub forma unei liste, care va indica numele articolelor. Când scrieți grabbers, amintiți-vă că furtul de conținut este pedepsit prin lege! Dar nu atunci când pagina conține un link activ către documentul sursă.

Include("simple_html_dom.php"); $articole = array(); getArticles("http://site/");

Începem prin a conecta biblioteca și a apela funcția getArticles, care va analiza documentele HTML în funcție de adresa paginii care este transmisă ca parametru de funcție.

De asemenea, indicăm o matrice globală în care vor fi stocate toate informațiile despre articole. Înainte de a începe să analizăm un document HTML, să vedem cum arată.

Acesta este șablonul de bază pentru această pagină. Când scrieți un parser html, trebuie să examinați cu atenție documentul, precum și comentarii precum, acestia sunt si descendenti. Cu alte cuvinte, în ochii simplei biblioteci HTML DOM, acestea sunt elemente care sunt echivalente cu alte etichete de pe pagină.

Pasul 4 – Scrieți funcția principală PHP HTML parser

funcția getArticles($page) ( global $articole; $html = new simple_html_dom(); $html->load_file($page); // ... mai multe vor veni... )

La începutul funcției, numim matricea noastră globală pe care am specificat-o mai devreme. Creați un nou obiect simple_html_dom. În continuare, încărcăm pagina pe care o vom analiza.

Pasul 5 – Găsiți informațiile de care aveți nevoie

$items = $html->find("div"); foreach($articole ca $nume) ( $articole = matrice($post->children(0)->text simplu); )

În această bucată de cod totul este extrem de simplu, găsim toate div-urile cu class=name_material. În continuare, citim colecția de elemente și selectăm denumirile materialelor. Toate materialele vor fi salvate într-o matrice sub această formă:

$articles = "Numele materialului 1"; $articles = "Numele materialului 2"; ...

Pasul 6 – Ieșiți rezultatul analizei

Pentru început, vom instala câteva stiluri pentru a face ca informațiile afișate pe care le-am primit în timpul parsării să pară frumoase.

Element ( padding:10px; color:#600; font:bold 40px/38px helvetica, verdana, sans-serif; )

"; echo $articol; ecou "