defektologs.lv Par web izstrādes lietām

Draudzīgas saites būvēšana

Kā jau ierasts, runa ir par informācijas meklētājiem draudzīgām saitēm, izmantojot mod_rewrite moduli. Principā saites ģenerēšana vairumā gadījumu nav sarežģīts process, šī lieta tiek sarežģīta brīdī, kad izejot no vienas lapas, nepieciešams saražot lielu daudzumu citu saišu – visbiežāk meklēšana vai lapas karte.

Iepriekš savos rakstos esmu parādījis, kā nevajadzētu darīt, diemžēl, šoreiz tas izpaliks, jo rakstīšana ar savu jauno mini-datoru nebūt nav tik viegla. Biežāk izmantotais risinājums šai problēmai saistās ar pieprasījumu veidošanu uz datubāzi ciklā, patiesībā cikls ciklā – tiek atrasti vajadzīgie ieraksti datubāzē, ciklējot caur ierakstiem tiek izsaukta saites ģenerēšanas funkcija, kas arī satur ciklu.

Mans risinājums. Atkal pieņemam, ka strādājam ar klasisko koka struktūru.

+----+-----------+----------+----------+
| id | parent_id | name     | url      |
+----+-----------+----------+----------+
| 1  | 0         | Sākums   | home     |
+----+-----------+----------+----------+
| 2  | 0         | Kontakti | contacts |
+----+-----------+----------+----------+
| 3  | 1         | Raksti   | news     |
+----+-----------+----------+----------+
| 4  | 1         | Foto     | photo    |
+----+-----------+----------+----------+
| 5  | 2         | Karte    | map      |
+----+-----------+----------+----------+

Lai mums katru reizi nevajadzētu pieprasīt sadaļu sarakstu no jauna, saglabājam vajadzīgo masīvā, izejot no funkcijai padotās sadaļas id, izveidosim saiti.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<?
  function url($id){
    global $urldata;
	if(!is_array($urldata)){
	  return false;
	}elseif(!array_key_exists($id,$urldata)){
	  return "";
	}
	$url=$urldata[$id][0];
	$url.=$urldata[$id][1];
	return $url;
  }
  $urldata=array();
  $sql="SELECT id, parent_id, url FROM `topics`";
  $res=mysql_query($sql);
  while($row=mysql_fetch_object($res)){
    $urldata[$row->id]=array($row->parent_id,$row->url);
  }
?>

Pēc tam jau viss notiek vienkārši

Lasam urli.

Nu jau kāds laiks pagājis, kopš parādijies tāds brīnums kā mod_rewrite priekš Apache. Tas padara mūsu mājaslapas draudzīgākas gūglei un cilvēkiem. Kāpēc? Jo jau saitē mēs redzam ar ko saistīta konkrētā sadaļa vai raksts. Pats personīgī, šķiet, bez šī rīka vairs īsti nemāku strādāt.

Sāksim ar rewrite nosacījumu uzstādīšanu. Iespējas ir dažādas un atkarīgas no vajadzībām, piemēram, mēs varam, caur slešiem atdalītus vārdus, padot kā $_GET mainīgos vai ļaut rakstīt jebko un padoto saiti apstrādāt ar server-side skriptiem. Esmu piekopis otro metodi un lai labāk saprastu, parādīšu savu RewriteRule.

<VirtualHost *>
    DocumentRoot /home/www/domens
    ServerName domens.lv
    ServerAlias www.domens.lv

    RewriteEngine On
    AcceptPathInfo On
    RewriteRule ^/lv/(.*) /lv.php/$1
    RewriteRule ^/ru/(.*) /ru.php/$1
    RewriteRule ^/en/(.*) /en.php/$1
</VirtualHost>

Jā, rewrite nosacījumus rakstu Apache konfigurācijas failā, nevis .htaccess failā. Lūk, manā gadījumā, viss, kas sekos aiz domens.lv/lv/, tiks pārrakstīts.

Iekš lv.php, ru.php, en.php tiek definēti izvēlētās valodas apzīmējoši mainīgiem un inklūdots fails, kas inklūdo pārējos failus, taisa konekcijas ar datubāzi un, protams, apstrādā padoto saiti.

Apskatīsim mūsu mājaslapas sadaļu tabulu, kas dzīvo MySQLā. Manā gadījumā tā izskatās līdzīga šai:

+----+-----------+----------+----------+----------+----------+----------+
| id | parent_id | position | url      | name_lv  | name_ru  | name_en  |
+----+-----------+----------+----------+----------+----------+----------+
| 1  | 0         | 1        | main     | Sākums   | Начало   | Home     |
+----+-----------+----------+----------+----------+----------+----------+
| 2  | 0         | 2        | contacts | Kontakti | Контакты | Contacts |
+----+-----------+----------+----------+----------+----------+----------+
| 3  | 1         | 2        | news     | Jaunumi  | Новости  | News     |
+----+-----------+----------+----------+----------+----------+----------+
| 4  | 1         | 1        | photo    | Foto     | Фото     | Photo    |
+----+-----------+----------+----------+----------+----------+----------+
| 5  | 2         | 1        | map      | Karte    | Карта    | Map      |
+----+-----------+----------+----------+----------+----------+----------+

Tagad Iedomāsimies, ka cilvēks ir ieradies lapā, ar adresi domens.lv/lv/contacts/map. Atvērtās sadaļas ID ir 5. Kā mēs to noskaidrosim ar PHP? Sākumā apstrādāsim saņemto saiti:

1
2
3
4
5
6
7

<?
  $xpieces=explode("/",$_SERVER['PATH_INFO']);
  $cnt=count($xpieces);
  if(empty($xpieces[--$cnt])){
    unset($xpieces[$cnt]);
  }
?>

Kā redzams, izmantoju $_SERVER['PATH_INFO'] mainīgo (to ir iespējams ieslēgt tikai Apaches konfigurācija un noklusējuma uzstādījumos šis mainīgais neparādās), šis mainīgais man atgriež “lv/contacts/map”.

Tiksim pie atvērtās sadaļas ID! Atkal jāsaka, ka esmu redzējis dažādus variantus – tādus, kas skatās tikai pēc pēdējās sadaļas un tādus, kas uz katru direktoriju taisa jaunu pieprasījumu uz datubāzi.
Pirmais variants būs pietiekami ātrs, bet ceļš netiks ņemts vērā, kā arī kolonai “url”, datubāzē, jābūt unikālai vērtībai.
Otrs variants jau būs labāks, katras sadaļas saitei (”url” kolona datubāzē) jābūt unikālai pie katra “parent_id”. Turklāt, meklējot atvērtās sadaļas id, ir iespējams savākt datus par iepriekšējām sadaļām, ja nu kādam tas ir vajadzīgs. Rādīšu kolēģa rakstītu piemēru:

1
2
3
4
5
6
7
8
9
10
11
12
13

<?
  function get_lastid($pid,$i=1){
    global $xpieces;
    $sql="SELECT id FROM `topics` WHERE parent_id=".intval($pid)." AND url='".mysql_real_escape_string($xpieces[$i])."' LIMIT 1";
    $res=mysql_query($sql);
    if(mysql_num_rows($res)<1){
      return $pid;
    }
    $row=mysql_fetch_object($res);
    return get_lastid($row->id,++$i);
  }
  $lastid = get_lastid(0);
?>

Šī funkcija veiks pārāk daudz lieku pieprasījumu uz datubāzi, turklāt, ja kāda sadaļa, datubāzē, būs ar tukšu “url” lauku un parent_id būs vienāds ar atvērtās sadaļas ID, tad funkcija mainīgajam $lastid piešķirs šīs sadaļas ID. Tādēļ ķersimies klāt vienam selektam un masīviem.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?
  function get_lastid($arr,$pid=0,$i=1){
    global $xpieces;
    if(!is_array($arr[$pid])){
      return $pid;
    }
    $n=array_search($xpieces[$i],$arr[$pid]);
    if(!$n){
      return $pid;
    }
    return get_lastid($arr,$n,++$i);
  }
 
  $all=array();
  $allsql="SELECT id, parent_id, url FROM `topics` ORDER BY position ASC";
  $allres=mysql_query($allsql);
  while($allrow=mysql_fetch_object($allres)){
    $all[$allrow->parent_id][$allrow->id]=$allrow->url;
  }
  $lastid=get_lastid($all);
?>

Rekursīva lapas karte

Tā nu ir sanācis, ka esmu mājaslapu izstrādātājs un šoreiz gribu padalīties ar kādu jauku algoritmu – lapas karte.

Sākumā apstāstīšu, ar ko esmu saskāries vairumā gadījumu. Liela daļa mājaslapu ir būvētas klasiskajā koka algoritmā, ko es atbalstu – id, parent_id. Šajā gadījumā tabula izskatīsies, aptuveni, šādi:

+----+-----------+----------+----------+
| id | parent_id | name     | position |
+----+-----------+----------+----------+
| 1  | 0         | Sākums   | 1        |
+----+-----------+----------+----------+
| 2  | 0         | Kontakti | 2        |
+----+-----------+----------+----------+
| 3  | 1         | Raksti   | 2        |
+----+-----------+----------+----------+
| 4  | 1         | Foto     | 1        |
+----+-----------+----------+----------+
| 5  | 2         | Karte    | 1        |
+----+-----------+----------+----------+

Funkcija, kuru izmanto veidojot rekursīvu lapas karti, uz šāda tipa datubāzes struktūras, visbiežāk izskatās šādi:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<?  
  function sitemap($pid){
    $sql="SELECT id, name FROM `topics` WHERE parent_id=".intval($pid)." ORDER BY position ASC";
    $res=mysql_query($sql);
    if(mysql_num_rows($res)<1){
      return "";
    }
    $s='<ul>';
    while($row=mysql_fetch_object($res)){
      $s.='<li>';
      $s.=$row->name;
      $s.=sitemap($row->id);
      $s.='</li>';
    }
    $s.='</ul>';
    return $s;  	
  }       
  echo sitemap(0);
?>

Iedomājamies, ka ir tāda nopietnāka lapa, piemēram, ar 10 pirmā līmeņa sadaļām un katrai pirmā līmeņa sadaļai ir 5 apkšsadaļas. Cik pieprasījumi tiks sūtīti uz datubāzi?  1+10*5=26
Kapēc veidot 26 pieprasījumus, ja var iztikt ar vienu? Izmantosim sarežģītāku, taču ātrāku, algoritmu.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?
  function sitemap($pid,$arr){
    if(!is_array($arr[$pid])){
      return "";
    }
    $s='<ul>';
    foreach($arr[$pid] as $key=>$value){
      $s.='<li>';
      $s.=$value;
      $s.=sitemap($key,$arr);
      $s.='</li>';
    }
    $s.='</ul>';
    return $s;
  }
 
  $topics=array();
  $sql="SELECT id, parent_id, name FROM `topics` ORDER BY position ASC";
  $res=mysql_query($sql);
  while($row=mysql_fetch_object($res)){
    $topics[$row->parent_id][$row->id]=$row->name;
  }
  echo sitemap(0,$topics); 
?>

Testējot koda izpildes laiku (uz lēnas kastes, lai atšķirību vieglāk pamanīt), pirmā algoritma izpildes laiks bija ~ 0.77 sekundes, bet otrā ~ 0.015 sekundes. Atšķirība ir diezgan paliela, ņemot vērā, ka lapai, uz kuras tika veikts tests, nebija diezko daudz sadaļu.