MTD blog

Zend_search czyli Zend_Search_Lucen to phpowa implemnetacja popularnej Javowej wyszukiwarki Lucen. Lucen jest pełnotekstową wyszukiwarką opartą na plikach, więc do jej obsługi nie potrzebujemy bazy danych.

Główne zalety to mi. Zwracanie wyniku według trafności wyszukiwania, możliwość tworzenie różnego rodzju zapytań, czy wyszukiwanie po polach tekstowych(np. autor, title, content).

Wyszukiwarkę możemy zaimplementować na różne sosoby w zaleźności od tego czego potrzebujemy.
Ja stworzyłęm sobie dodatkowy model, w którym stworzyłem 4 metody: search(), addSearch(), updateSearch(), delSeaarch(). Dodatkowo stworzyłem sobie skrypt, który indeksuje rekordy już znajdujące się w bazie (nie będę go tutaj opisywał, powstał na potrzeby projektu).

Tego co robią metod chyba nie trzeba opisywać, nazwy mówią wszystko. metoda updateSearch() słada się tak naprawdę z dwóch metod poniewasz Lucen nie obsługuje aktualizacji rekordów. więc trzeba najpierw usunąć stary rekord a później dodać nowy.
Czytaj więcej…

Po przeczytaniu kilku artykułów na temat ZF postanowiłem napisać kilka słów od siebie o tym tzw pseudo frameworku.

Dlaczego pseudo?

Zend framework jest zestawem klas które przy odrobinie wysiłku z naszej strony może stać się doskonałym narzędziem do twonenia aplikacj webowych. Klasyczne frameworki oferują kompletne rozwiązania nie musimy wszystkiego łaczyć samodzielnie tak by tworzyły aplikację.
Wynika to z tego że programiści zenda nie chcą narzucać (swoich) gotowych rozwiązań użytkownikom w kwestii kształtu aplikacji dają użytkownikowi wolną rękę. Jest to jedna z nielicznych wad ZF, ja osobiście wolałbym mieś jedno docelowe rozwiązanie co wyjaśniło by mi pewne niejasności. No ale cóż nie jest to aż taka duża wada no i wystarczy raz napisać pewne rzeczy i później możemy wielokrotnie je wykorzystywać. (Zagorzałym przeciwnikom po prostu chyba nie chce się podjąć wysiłku przy tworzeniu bazowej aplikacji, wolą mieć wszystko podane na tacy…)

Dlaczego warto go używać?

Poza dużymi możliwościami które daje cały czas powiększający się zestaw klas głównymi zaletami ZF (jak dla mnie) są szybkość i łatwość tworzenia aplikacji. W porównaniu np. do symfony, zend bywa czasem dwa a nawet trzy razy szybszy (nawet z podłączonymi szablonami smarty). Natomiast jeśli chodzi o samo tworzenie aplikacji to jest to dość banalne.
Oczywiście najpierw trzeba zbudować sobie jakąś aplikację bazową co może zająć trochę czasu szczególnie mniej doświadczonym programistom, ale zawsze można posłużyć się gotowcami ściągniętymi z netu.

Jak już mamy swoją bazową aplikację to żeby wygenerować jakiś prosty widok wystarczy nam stworzyć odpowiednią strukturę modułu, domyślny kontroler, domyślny widok, umieścić jakąś treść w widoku i już gotowe. Jeśli chcemy czegoś więcej np.zaciągnąć dane z bazy to też jest to proste. wystarczy właściwie stworzyć model i w odpowiednim miejscu go wywołać. Do tworzenia prostych aplikacji wystarczy nam minimalna wiedza na temat modeli i controlerów (Zend_Db i Zend_Controller) nie musimy nawet specjalnie wiele wiedzieć na temat widoków.

Poza tym ZF ma bardzo dobrą dokumentację co pomaga w szybkim poznawani pozostałych bardziej zaawansowanych komponentów frameworka, które mogą się nam przydać przy tworzeniu bardziej rozbudowanych aplikacji (Zend Cache, Zend_Feed, Zend_Pdf).

A i jeszcze jedna ważna zaleta, Tworząc aplikacje od początku, to my decydujemy co w niej umieścimy nie musimy się zastanawiać jak wyłączyć niepotrzebne opcje.

Właściwie staram się szukać zalet niż wynajdować nowe wady, jak dla mnie praca z ZF jest bardzo wygodna i dzięki niemu mogę zaoszczędzić wiele czasu mimo że niektóre rzeczy trzeba napisać sobie samemu. Od jakiegoś czasu staram się przekonać do symfony ale na razie jeszcze wydaje mi się zbyt kobylasty, kto wie może w przyszłości będę musiał pracować na symfony.

Niedawno w jednym z serwisów, które napisałem zaistniała potrzeba zaciągnięcia pewnych danych z bazy Firebird/Interbase. Jako, że serwis jest napisany w zend zajżałem więc do katalogu DB, no i niestety wcześniej nie zdawałem sobie z tego sprawy, ale zend w wersji 1.6 nie posiada adaptera Firebird/Interbase.
Zacząłem więc przeszukiwać internet w poszukiwaniu rozwiązania. W końcu dotarłem do Zend Incubator gdzie można ściągnąć poszukiwany przezemnie sterownik.
Jest on dopiero rozwijany ale pewnie już niedługo zostanie włączony do głównej dystrybucji ZF.

A oto krótkie info jak go używać, sprawa jest prosta i właściwie standardowa.

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

/* database.ini
[firebird]
      db.adapter = FIREBIRD
      db.config.host = localhost
      db.config.username = SYSDBA
      db.config.password = masterkey
      db.config.dbname = /home/db/newdb.fdb
*/
 
//zaciągany konfigurację z pliku .ini
$Config = new Zend_Config_Ini( './configs/database.ini', 'firebird' );
$cfgConfig = $Config->db->config->toArray();
$cfgConfig['options'] = array(Zend_Db::CASE_FOLDING => Zend_Db::CASE_UPPER);
 
//standardowo za pomoca metody factory łaczymy się z bazą
$db = Zend_Db::factory($Config->db->adapter, $cfgConfig );
$db->setFetchMode(Zend_Db::FETCH_ASSOC);

jeśli łaczymy się z dwiema bazami musimy uzyć rejestru.

1
2
3
4
5
6
7
8
9

 
$Config = new Zend_Config_Ini( './configs/database.ini', 'mysql' );
$db = Zend_Db::factory($Config->db->adapter, $Config->db->config->toArray());
Zend_Db_Table::setDefaultAdapter($db);
Zend_Registry::set('db', $db);
 
$Config = new Zend_Config_Ini( './configs/database.ini', 'firebird' );
$fdb = Zend_Db::factory($Config->db->adapter, $Config->db->config->toArray());
Zend_Registry::set('fdb', $fdb);

Później przy wywołaniu modelu musimy pobrać z rejestru odpowiednie połaczenie i przekazać je do konstruktora modelu.

1
2

$db = Zend_Registry::get('fdb);
$model = new NewModel(array('fdb' => $db));

Właściwie obsługa Firebird/Interbase w zend jest identyczna ja w przypadku innych baz, wystarczy tylko zmienić odpowiednie opcje konfiguracji wybarać adapter i używać.

Od wersji 1.5 Zend framwork wyposarzony jest w zend layout, wzorzec który umożliwia nam proste zarządzanie layoutami.
Do uruchomienia layoutów nie potrzebujemy zbyt wiele kodu, na dobrą sprawę wystarczy nam tylko jedna linijka

1

$layout = Zend_Layout::startMvc();

Layout inicjujemy w “bazowym kontrolerze” po którym dziedziczą wszystkie kontrolery u mnie jest to My_Controller_Action który dziedziczy po Zend_Controller_Action.

Jako że kożystam ze smarty ustawiam sufix dla szablonów i kilka innych opcji

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

$options = array(
                'layout'     => 'main', //nazwa głównego layout'u
                'layoutPath' => './frontend/templates/', // ścieżka
                'contentKey' => 'content', //klucz do którego zostaną przypisane zrenderowane szablony poszczególnych akcji
                );
 
$layout = Zend_Layout::startMvc($options);
$layout->setViewSuffix('tpl');
 
//Przypisujemy $layout do właściwości głównego kontrolera 
//$this->layout dzięki czemu $layout będzie dostępny 
//we wszystkich potomnych kontrolerach
$this->layout = $layout; 
 
//pzrzypisujemy $layout do szablonu
$this->view->assign( 'layout', $layout );

I właściwie całą pracę związaną z konfiguracją mamy już za sobą, teraz możemy już korzystać z layoutów.

Layouty możemy bardzo łatwo zmieniać w zależności od tego jakiego potrzebujemy dla danej akcji. Możemy to zrobić na dwa sposoby wpisując w akcji:

public function indexAction() 
{
        //Wywołujemy layout foobaz.tpl
	$this->_helper->layout->setLayout('foobaz');
        //lub
	$this->layout->setLayout('foobaz');
}

Wywołanie $this->layout… jest o tyle “lepsze”, że dostajemy jedynie obiekt layoutu zamiast obiektu helper z layoutem.

Zend layout jest o tyle wygodny, że możemy przypisać do niego zmienne tak samo jak przypisujemy zmienne do szablonów akcji poprzez $this->view->zmienna1 = ‘Bla bla bla’;, oczywiście mozemy to też zrobić poprzez obiekt layoutu $this->layout->zmienna2 = ‘La la la’;

Z mojego doświadczenia wynika, że rzadko używam innych layautów niż główny (wcześniej musiałęm sobie symulować coś w rodzaju laya), ale bez tego wzorca ciężko jest się obejść w niektórych sytuacjach, a jak się go już ma trzeba z niego korzystać.

Dostałem ostatnio w pracy do napisania klasę do exportu danych z bazy do exela. Jako że trochę byłem ograniczony czasowo, poszedłem po najmniejszej linii oporu, czyli odpaliłem google i zacząłem szukać.
Najprostsze rozwiązanie do zapisu surowych danych to export to csv’ a. Znalazłem dość prosty skrypt i zacząłem go przerabiać.
Czytaj więcej…

Oto prosty sposób na sortowanie tablicy względem wielkości elementów (ilości liter w jednym elemencie).
Wszystko robimy za pomocą funkcji usort(), która jako swój pierwszy parametr przyjmuje tablicę, a jako drugi funkcję zwrotną, która posłuży do sortowania.

Najprościej można to zrobić tak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

function cmp ($left, $right)
{
    //żeby uzyskać odwrotne sortowanie należy:
    //$diff = strlen ($right) - strlen ($left);
    $diff = strlen ($left) - strlen ($right);
    if (!$diff) 
    {
        return strcmp ($left, $right);
    }
    return $diff;
}
 
$a = array('asfasfafasfa','sddd','dasdas','asd');
 
usort ($a, 'cmp');
 
foreach ($a as $item) {
    print $item . "<br />";
}
 
/* 
na wyjściu otrzymujemy tablicę posortowaną 
od najmniejszego do największego elementu
Array
(
    [0] => asd
    [1] => sddd
    [2] => dasdas
    [3] => asfasfafasfa
)
*/

To bardzo prosty i wygodny sposób.
Można jeszcze napisać prostą klasę do sortowania, na wyjściu otrzymujemy wtedy tablicę obiektów (którą możemy prze iterować wedle potrzeb).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

 
class ArrSort
{
    public $name;
 
    public function __construct($name)
    {
          $this->name = $name;
    }
 
    public function cmp($left, $right)
    {
        $diff = strlen ($left->name) - strlen ($right->name);
        if (!$diff) 
        {
            return strcmp ($left, $right);
        }
        return $diff;
    }
}
 
 
$aa = array('asfasfafasfa','sddd','dasdas','asd');
 
//tworzymy tablicę obiektów potrzebną do sortowania
foreach($aa as $bb)
{
    $cc[] = new ArrSort($bb);
}
 
uasort($cc, array("ArrSort", "cmp"));
 
/*
Array
(
    [3] => ArrSort Object
        (
            [name] => asd
        )
    [1] => ArrSort Object
        (
            [name] => sddd
        )
    [2] => ArrSort Object
        (
            [name] => dasdas
        )
    [0] => ArrSort Object
        (
            [name] => asfasfafasfa
        )
)
*/
 
//tablicę można stworzyć też tak:
$a[] = new ArrSort("csdsaewrwfewewfsd");
$a[] = new ArrSort("basdasdas");
$a[] = new ArrSort("dasdasdasdasdas");
 
uasort($a, array("ArrSort", "cmp"));
 
foreach ($a as $item) {
    print $item->name . "<br />";
}

Ostatnio dużo myślę o optymalizacji moich stronek i ulepszeniu mojego cms’a, stąd kolejny art o cachowaniu tym razem będzie mowa o Zend Cache.

Jako że pracuje na Zend framework z podłaczonym systemem szablonów Smarty rozpatruje użycie jednego z dwóch dostępnych dla mnie rozwiązań czyli Zend Cache i Cache smarty.

Wcześniej nie widziałem potrzeby buforowania szablonów, nie było mi to raczej potrzebne ale w miarę wzrastania cmsa i projektów którymi się zajmuje postanowiłem to zmienić.

Ale do rzeczy …

Zend cache można zainicjować w bardzo prosty sposób i ustawiając na początek kilka opcji

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

 
//includujemy plik z klasą Zend_Cache
require_once 'Zend/Cache.php';
 
//ustawiamy opcje frontend 
$frontendOptions = array(
   'lifetime' => 7200,     // czas życia cacha
   'automatic_serialization' => true    //włączmy automatyczną serializacje domyśnie ustawiona jest na false
);
 
//ustawiamy opcje backend
$backendOptions = array(
    'cache_dir' => './tmp/' // folder gdzie będziemy przechowywać pliki cacha
);
 
//frontend  czyli to co chcemy cachować
//dostępne opcje: Core, Output, Class, File, Function, Page
$frontend = 'Core';
 
 //backend czyli to gdzie chcemy cachować
//dostępne opcje: File, Sqlite, Memcached, Apc, ZendPlatform
$backend = 'File';
 
// odpalamy cacha za pomocą metody factory
$cache = Zend_Cache::factory($frontend, $backend, $frontendOptions, $backendOptions);

Opcję $frontend = ‘Core’ możemy zastosować do buforowania zapytań do bazy danych np.

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

 
if(!$result = $cache->load('myresult')) {
 
    // gdy nie macacha pobieramy dane z bazy
    $result = $db->fetchAll('SELECT * FROM huge_table');
 
    // i zapisujemy cache
    $cache->save($result, 'myresult');
 
}
//dane możemy dalej przetwarzać lub wydrukować
print_r($result);

Do cachowania wyjścia używamy trochę innych metod (start i end):

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

 
//ustawiamy opcję Output w metodzie factory
$cache = Zend_Cache::factory('Output', 'File', $frontendOptions, $backendOptions);
 
// do metody start musimy przekazać unikalny identyfikator
if(!$cache->start('mypage')) {
    echo 'Hello world! ';
    echo 'This is cached ('.time().') ';
 
    $cache->end(); // zapisujemy wyjście i wysyłąmy do przegklądarki
 
echo 'This is never cached ('.time().').';

Tagi

Zend Cache ma przydatną opcję tagowania cacha, pomocne jest to do kategoryzowania buforów i przydatne przyczyszczeniu określonych grup (kategorii) cachy.

1
2

 
$cache->save($dane, 'uniqueID', array('tagA', 'tagB', 'tagC'));

Czyszczenie cachy

Zeby usunąć cache o określonym id wystarczy użyć metody

1
2

 
$cache->remove('idDoUsuniecia');

Żeby usunąć większą ilość zbuforowanych danych można się posłużyć metodą clean(), przyczym metoda ta może przyjmować różne przydatne opcje.

Do usunięcia wszystkich buforów użyjemy opcji Zend_Cache::CLEANING_MODE_ALL.

1
2

 
$cache->clean(Zend_Cache::CLEANING_MODE_ALL);

Do usunięcia starych (wygasłych) buforów użjemy clean() z opcją Zend_Cache::CLEANING_MODE_OLD

1
2

 
$cache->clean(Zend_Cache::CLEANING_MODE_OLD);

Do usunięcia buforów oznaczonych tagami Zend_Cache::CLEANING_MODE_MATCHING_TAG

1
2

 
$cache->clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG, array('tagA', 'tagC'));

Do usunięcia buforów nie oznaczonych danymi tagami CLEANING_MODE_NOT_MATCHING_TAG (podajemy również tablicę tagów)

1
2

 
$cache->clean(Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG, array('tagA', 'tagC'));

Zend Cache posiada jeszcze kilka ciekawych opcji, ale te opisane powyżej w zupełności wystarczą by używać tego narzędzia.

Smarty jest bardzo popularnym systemem szablonów dla php oprócz podstawowych funkcjonalności charakterystycznych dla systemów szablonów posiada on całkiem niezły system cachowania zawartości.

Podstawy buforowania w smarty

Cachowanie dla szablonów jest domyślnie wyłączone , można je włączyć w skrypcie ustawiając właściwości $smarty->caching = 1 .

1
2
3
4
5
6

<?php
include_once('smarty/Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = 1;
$smarty->display('templates/template.tpl');
?>

Dzięki ustawieniu zmiennej caching na 2 mamy dodatkowe możliwości regulowania czasu przechowywania bufora $smarty->cache_lifetime = 7200 (dwie godziny).

Jeśli zachodzi potrzeba odświeżenia szablonu w buforze np. gdy szablon został zmodyfikowany możemy użyć zmiennej $smarty->compile_check = true, wtedy smarty sprawdza czy plik szablonu powiązany z plikiem w buforze nie został zmieniony, jeśli tak bufor jest odświeżany. Nie jest to zbyt wydajne ale możemy zastosować to ustawienie np. podczas pracy nad szablonami.

Smarty daje nam również możliwość sprawdzenia czy dany szablon znajduje się w buforze,
robimy to za pomocą $smarty->is_cached(‘templates/template.tpl’).

1
2
3
4
5
6
7

...
if(!$smarty->is_cached('templates/template.tpl'))
{
    //pobieramy dane
    //przypisujemy dane do szablonu
}
$smarty->display('templates/template.tpl');

Czyszczenie bufora
Pliki z bufora możemy usuwać bezpośrednio odwołując się do nich poprzez nazwę
$smarty->clear_cache(‘templates/template.tpl’)

lub wyczyścić cały bufor poprzez:
$smarty->clear_all_cach()

Możemy również utworzyć skrypt który będzie nam usuwał nieaktualne pliki z bufora podając jako parametr czas ważności bufora jeśli w jakimś pliku czas jest przekroczony to zostanie on automatycznie usunięty (może to być skrypt uruchamiany przez crona).

$expiration_time = 2*60*60; //dwie godziny
$smarty->clear_all_cach($expiration_time);

Zawansowane możliwości buforowanie w smarty

W przypadku bardziej skomplikowanych witryn smarty oferuje nam bardziej zaawansowane możliwości cachowania. Normalnie bufor jest przypisany do szablonu, jak wiemy szablon wykorzystywany jest zwykle wielokrotnie np. w aktualnościach. Smarty pozwala na utworzenie wielu buforów dla jednego szablonu. Wystarczy do metody display przekazać drugi parametr np. id aktualności.

1
2
3
4
5
6
7
8
9
10
11

...
$smarty->template_dir = 'templates/';
 
$newsId = (int) $_GET['id'];
// $_GET['id'] np. 125
if(!$smarty->is_cached('template.tpl', 'template|'.$newsId))
{
    //pobieramy dane
    //przypisujemy dane do szablonu
}
$smarty->display('template.tpl', $newsId);

Bufory dla wszystkie newsów zostaną utworzone w folderze cache (jeśli go wcześnie ustawiliśmy w konfiguracji smarty), będzie to np. template^125^%%…news.tpl.

Przy jeszcze bardziej złożonych witrynach gdzie liczbę newsów i artykułów liczymy czasem w tysiącach, nie jest to jednak najlepsze rozwiązanie ponieważ wszystkie pliki bufora dla wszystkich działów są umieszczane w tym samym katalogu co może spowolnić dostęp do tych plików.

Grupy buforów
Kolejną możliwością buforowania w smarty jest rozdzielenie poszczególnych grup buforów na foldery ustawiając zmienną $smarty->use_sub_dir = true i dodanie w metodzie display nazwy folderu dla grupy buforów

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

...
$smarty->template_dir = 'templates/';
$smarty->use_sub_dirs = true;
 
$newsId = (int) $_GET['id'];
// $_GET['id'] np. 125
if(!$smarty->is_cached('template.tpl', 'template|'.$newsId))
{
    //pobieramy dane
    //przypisujemy dane do szablonu
}
$smarty->display('template.tpl', 'template|'.$newsId);

W wyniku tego w folderze cache smart tworzy określoną strukturę
cache\template\125\%%…template.tpl

Czyszczenie grup buforów
Czyszczenie grup buforów jest tak samo proste jak pojedynczych buforów
$smarty->clear_cache(null, ‘template’).

Smarty daje nam również możliwość zablokowanie cachowania, możemy to zrobić na trzy sposoby:

- Zablokowanie buforowania dla pliku poprzez ustawienie zmiennej $smarty->caching = 0
- Zastosowanie dla dynamicznej zawartości funkcji {insert}
- Utworzenie własnej wtyczki, która blokuje buforowanie wskazanej części szablonu np. {nocache}{/nocache}

Podsumowanie
W systemach, których integralną częścią jest smarty, możliwość cachowania może być doskonałym rozwiązaniem poprawiającym wydajność całej witryny. Dodatkowe informacje na ten temat można znaleźć w dokumentacji smarty i w dziale caching.

Oststnio miałem do napisania skrypt który miał pokazywać pozycję danej strony w googlach pod daną frazę (taka prosta wyszukiwarka). Jak zwykle po googlowałem trochę i po jakimś czasie znalazłem dwa skrypty. Jeden korzystał z Curl’a a drugi z fopen. Odpaliłem pierwszy na localu i wszystko łądnie działa. Kilka przeróbek i dostosowałem go do swoich potrzeb. Oczywiście nie sprawdziłem wcześniej czy na serwerze docelowym jest dostępny Curl. No i zonk! Po krótkim kontakcie z administratorem dowiedziałem się że muszę użyć czegoś innego…

Odpalam więc drugi skrypt z wykorzystaniem fopen(“http://www.google.pl/sear…”) otrzymałem w prezencie informację, że wywołanie funkcji fopen z parametrem w formie url’a zostało zablokowane (ze względów bezpieczeństwa…), wiec koniec końców wykorzystując powyższe skrypty i używając fsockopen() wykombinowałem kawałek własnego kodu…

Kod jest dosyć prosty. Zastanawiałem się nad przerobieniem go na bajdziej rozbudowane rozwiązanie w formie obiektowej jednak na dzień dzisiejszy wystarcza mi to.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

<?php
 
// słowa kluczowe
$string = 'php';
 
//szukana strona
$site    =  str_replace('http://','',str_replace('www.','',trim(strip_tags('php.pl'))));
 
//ilość przeszukanych wyników w google
$searchAmount = 40;
 
$RegExp = '/<h2 class=r><a href="([^"]+)" class=l/i';
$query = str_replace(" ","+",$string);
 
$query = str_replace("%26","&",$query);
$fp =  fsockopen("www.google.com", 80, $errno, $errstr, 30);
 
if (!$fp)
{
    $err = "$errstr ($errno)";
}
else
{
    $out = "GET http://www.google.pl/search?hl=pl&num={$searchAmount}&q={$query}&btnG=Szukaj+w+Google&lr=HTTP1.1\r\n" ;
    $out .= "Host: www.google.com\r\n" ;
    $out .= "Connection: Close\r\n\r\n" ;
    fwrite($fp, $out);
 
    $data = '';
 
    while (!feof($fp))
    {
        $data .= fgets($fp);
    }
    fclose($fp);
 
    preg_match_all($RegExp, $data, $results);
    $results = array_pop($results);
 
    $iPosition = '';
    foreach($results as $iKey => $sRow)
    {
        if(strpos($sRow, $site) !== false)
        {
        //wyświetlamy najwyższą pozycję
        $iPosition = $iKey + 1;
        break;
        }
    }
    echo $iPosition;
}
?>