Od samego początku swojego istnienia Bing (oraz usługi Windows Live) stawiał sobie za cel zdetronizowanie Google (przynajmniej na rynku wyszukiwarek). Wyszukiwarka, której funkcjonalności są coraz częściej kopiowane przez Google, zdobywa coraz większy rynek. Wraz z wyszukiwarką na podbój rynku ruszyły przeglądarkowy pakiet biurowy oraz nowa wersja poczty Hotmail.

Zdobywanie nowych użytkowników jest ważne dla rozwoju usług, jednak nie mniej ważne jest pozyskiwanie nowych programistów, dzięki którym będą powstawać kolejne aplikacje na bazie oferowanych usług (podobnie jak ma to miejsce w przypadku map Google). Ostatnio Microsoft “przypuścił atak” na społeczność PHP (wystarczy wspomnieć o wydaniu drugiej wersji sterownika SQL Server dla PHP).

Kolejnym krokiem do zjednania sobie społeczności PHP jest udostępnienie Bing Maps SDK. Programiści PHP zyskali możliwość korzystania z usług sieciowych REST i SOAP oraz z danych przestrzennych. Od teraz z poziomu PHP można między innymi wyszukiwać adresy, pobierać współrzędne geograficzne, a nawet wyświetlać mapę. Co więcej, programista ma możliwość dodawania markerów na mapie oraz wyznaczania tras dojazdu. Trasę taką można następnie nałożyć na mapę, np przy pomocy biblioteki GD (również z poziomu PHP).

Jedynym, dosyć poważnym w naszych realiach, minusem Bing Maps jest brak lokalizacji usługi. Dopóki nie będzie można wyszukiwać lokalnych adresów, Bing nie prześcignie Google.

Siedzę sobie w domu na urlopie i uskuteczniam to, co lubię najbardziej czyli programuję. Niektórzy lubią wylegiwać się na plaży czekając aż czerniak łaskawie zawita na ich skórę, inni chodzą po zagranicznych targowiskach i pilnują portfela, a ja lubię siedzieć sobie wygodnie przed komputerem cały dzień i dłubać. Dzisiaj przedmiotem mojego dłubania jest implementacja kolejek [...]

W niedawnym wpisie na liście php.internals, Pierrick Charron poinformował o stworzeniu patch’a dodającego obsługę adnotacji do php. Patch ten jest napisany zgodnie z odpowiednim RFC. Rozszerza on składnie języka, dodaje obsługę do refleksji i dwie nowe klasy ‘ReflectionAnnotation’ i ‘Inherited’ – pierwsza umożliwia tworzenie własnych adnotacji, natomiast druga umożliwia dziedziczenie adnotacji przez klasy dziedziczące z jakiejś klasy.

Jak dla mnie to ciekawy dodatek do języka, natomiast ja chętnie bym również widział jakąś implementacje Pythonowych dekoratorów o których już wcześniej wspominałem. A wy co o tym sądzicie ?

Na pytanie jak wysłać POST’a bez submitowania formularza, padają dwie odpowiedzi – AJAX lub cURL. Okazuje się, że jest jeszcze trzecia odpowiedź. Można skorzystać z kontekstu oraz standardowej funkcji operującej na plikach, np file_get_contents.

Kontekst umożliwia zmianę… kontekstu requesta. Najprościej będzie to wyjaśnić na przykładzie:

// przygotowanie zmiennych do wysłania
$post = http_build_query(array(
	'zmienna1' => 'wartosc 1',
	'zmienna2' => 'wartosc2'
));

// wysyłane nagłówki
$headers = array(
	'Content-type: application/x-www-form-urlencoded'
);

// utworzenie kontekstu
$context  = stream_context_create(array(
	'http' => array(
		'method' => 'POST',
		'header' => implode("\r\n", $headers),
		'content' => $post
	)
));

// wysłanie POST-a i zapisanie odpowiedzi do zmiennej
$content = file_get_contents('http://example.com/file.php', false, $context);

Kluczowym elementem powyższego kodu jest funkcja stream_context_create. To ona odpowiada za modyfikację standardowego zachowania funkcji file_get_contents. Stream_context_create przyjmuje dwa parametry. Pierwszym jest tablica zawierająca konfigurację kontekstu, drugim tablica zawierająca dodatkowe parametry.

Dlaczego warto korzystać z kontekstów zamiast cURL-a? Przede wszystkim nie wymaga instalacji. Wiem, że cURL jest zazwyczaj dostęny, ale… Ponadto użycie kontekstu jest prostsze i wymaga mniej kodu oraz umożliwia skorzystanie z funkcji zwrotnej. Oto przykład takiej funkcji zaczerpnięty z maunala.

function stream_notification_callback($notification_code, $severity, $message, $message_code, $bytes_transferred, $bytes_max) {

    switch($notification_code) {
        case STREAM_NOTIFY_RESOLVE:
        case STREAM_NOTIFY_AUTH_REQUIRED:
        case STREAM_NOTIFY_COMPLETED:
        case STREAM_NOTIFY_FAILURE:
        case STREAM_NOTIFY_AUTH_RESULT:
            var_dump($notification_code, $severity, $message, $message_code, $bytes_transferred, $bytes_max);
            /* Ignore */
            break;

        case STREAM_NOTIFY_REDIRECTED:
            echo "Being redirected to: ", $message;
            break;

        case STREAM_NOTIFY_CONNECT:
            echo "Connected...";
            break;

        case STREAM_NOTIFY_FILE_SIZE_IS:
            echo "Got the filesize: ", $bytes_max;
            break;

        case STREAM_NOTIFY_MIME_TYPE_IS:
            echo "Found the mime-type: ", $message;
            break;

        case STREAM_NOTIFY_PROGRESS:
            echo "Made some progress, downloaded ", $bytes_transferred, " so far";
            break;
    }
    echo "\n";
}

Dodanie funkcji zwrotnej do kontekstu jest niezwykle proste i sprowadza się do wskazania jej nazwy w drugim parametrze funkcji stream_context_create.

$context  = stream_context_create(
	array(
		'http' => array(
			'method' => 'POST',
			'header' => implode("\r\n", $headers),
			'content' => $post
		)
	),
	array(
		'notification' => 'stream_notification_callback'
	)
);

Wywołaniu funkcji file_get_contenst z kontekstem zawierającym funkcję zwrotną spowoduje wyświetlenie:

Connected...
Found the mime-type: text/html
Made some progress, downloaded 0 so far
Made some progress, downloaded 8192 so far
Made some progress, downloaded 16384 so far
Made some progress, downloaded 24216 so far

Prawda, że proste?

Dobra, trochę na speedzie jest pisany ten wpis, także może być w nim parę nieścisłości i niedociągnięć, ale mam nadzieje że poprawicie mnie w komentarzach. O co chodzi? Kod tutaj opisany poniżej nie jest mojego autorstwa, niektóre treści też zrzynam bezpośrednio z książki bo nie ma innych słów by to opisać. Jest prawie na żywca zdarty z książki „PHP 5 Zaawansowane Programowanie”, także odczepić się proszę, nie piszę że ja to napisałem, jak już ktoś coś wymyślił, to nie mam zamiaru wymyślać koła na nowo, tylko poskładać wszystko do kupy i połączyć by to działało. No dobra to jedziemy. Trochę nie po kolei, z tymi klasami, ale wybaczcie. Zaczynamy.

Słowem wstępu

Jest sobie taki interfejs w php, który się zwie Iterator, posiadający 5 metod, które informują foreach jak sobie ma radzić z argumentami niebędącymi tablicą. On zaś (co jeszcze dziwniejsze) dziedziczy po kolejnym interfejsie który się zwie Travesrable. To co poniżej zobaczycie w pełnej krasie, jest implementacją mapy. Ale do rzeczy, po cholerę nam takie pyszne rzeczy? Otóż jeżeli chcielibyśmy sobie obiektowo przechowywać elementy w zmiennej nie będącej tablicą i przeiterować jest foreachem, to jak to zrobicie? No to pokaże Wam jak to można było by zrobić:

 
/* odpowiedni foreach dla ($objIt as $key => $value ) */
$objIt = new MyIterator();
for( $objIt->rewind(); $obj->valid(); $objIt->next() ) {
  $key = $objIt->key();
  $member = $objIt->current();
}

Trochę mało to Wam mówi jeszcze, ale jak spojrzycie na dalszą część tekstu to się sami przekonacie.

Klasa Collection

Na omówieniu tej klasy, przysłużę się przykładem z książki.

Pisząc aplikację, często zachodzi potrzeba utworzeniu obiektów, które zawierają w sobie grupę innych obiektów. Na przykład w systemie obsługi dziekanatu potrzebna będzie klasa Student oraz Course. Obiekt Student zapewne będzie miał przypisany więcej niże jeden obiekt Course. Pierwsze nasuwające się rozwiążanie to dodanie tablicy obiektów Course jako zmiennej składowej obiektu Student.

Przykład z książki:

class Student {
  public $courses = array();
  //... itd
}
 
$objStudent = new Student( 124 );
foreach( $objStudent->courses as $objCourse ) {
  print $objCourse->name;
}

I wracamy do omówienia problemu:

Oczywiście gdyby taki sposób był najlepszy, to by nie było mowy o klasie Collection (trochę to przerobiłem )

Powyższe rozwiązanie sprawia kilka problemów. Po pierwsze, publiczny dostęp do tablicy obiektów Course nie jest zgodny z zasadą hermetyzacji. Nie ma możliwości weryfikacji zmian w tablicy czy modyfikacji stanu obiektu Student, gdyby zaszła taka potrzeba. Po drugie, taka implementacja nie określa porządku elementów w tablicy ani sposobu odnalezienia poszukiwanego obiektu. Po trzecie, i najważniejsze, aby zapewnić dostęp do informacji o kursach każdemu użytkownikowi klasy Student, informacje te muszą zostać pobrane z bazy danych za każdym razem, gdy pobierane są informacje o studencie. Oznacza to że nawet jeśli konieczne jest jedynie wyświetlenie imienia studenta, pobierane są wszystkie informacje o kursach. Niepotrzebnie zwiększa to obciążenie serwera baz danych i zmniejsza wydajność aplikacji. Klasa Collection została zaprojektowana tak, aby rozwiązać wszystkie te problemy. Zapewnia obiektową otoczkę dla tablicy i implementuje mechanizm leniwej konkretyzacji, czyli opóźnienia procesu tworzenia elementów kolekcji aż do czasu, gdy są one naprawdę potrzebne. Nazywa się ją „leniwą”, ponieważ decyzja o tym, kiedy tworzyć konkretne egzemplarze obiektów, jest podejmowana przez samą aplikację.

Dobra, o co ogólnie chodzi? Chodzi o to że nasza klasa Collection, jak sama nazwa wskazuje jest kolekcją obiektów, czyli dodajemy do niej obiekty, a ona zgrabnie je przechowuje w swoim ciele. I to by było na tyle z filozofią klasy Collection, żeby zbytnio nie przeciągać, to poniżej mamy już dwie gotowe klasy które razem z sobą współpracują, są na żywca wydarte z mojego FW, także BDT_Loader, jak po samej nazwie można się domyślić, wczytuje klasy, także nie mam tu nic więcej do dodania. Klasa BDT_Collection_Exception jest po prostu klasą wyjątków, i tu też nie mam nic więcej do dodania. W naszym przykładzie będziemy potrzebowali dwie klasy, Collection (BDT_Collection) oraz CollectionIterator (BDT_Collection_Iterator). Obiekt klasy CollectionIterator jest tworzony w metodzie getIterator. Pod ciałem klasy, krótki opis.

Czytaj dalej tutaj (rozwija treść wpisu)
Czytaj dalej na blogu autora...

Zwiń
Czytaj na blogu autora...

Nie od dziś wiadomo, że PHP obsługuje operacje wejścia/wyjścia. Nic nie stoi na przeszkodzie, aby pisać aplikacje konsolowe, które “rozmawiają” z użytkownikiem. Generalnie wszystko sprowadza się do jednego wiersza kodu, który pobiera wpisany przez użytkownika tekst, a następnie zwraca go na przykład do zmiennej.

$input = trim(fgets(STDIN));
echo $input;

Dane od użytkownika można pobierać w pętli, dzięki czemu istnieje możliwość przeprowadzenia dłuższej konwersacji.

while(true) {
 echo 'Introduce yourself (to quit, type Q): ';
 $input = trim(fgets(STDIN));
 if($input === 'Q') break;
 echo "Your name is: " . $input . PHP_EOL;
}

echo 'Bye' . PHP_EOL;

Wprawdzie powyższy skrypt będzie w kółko nas pytał o imię, ale i tak jest to spory postęp w stosunku do pierwszego skryptu. Idąc dalej, można udostępnić użytkownikowi możliwość wywoływania funkcji (uwaga! kod jest nieco zabałaganiony – jego celem jest tylko prezentacja możliwości komunikacji z użytkownikiem).

echo 'Type function name to run (Q to quit): ';

$functionToCall = null;
$args = array();

while(true) {
 $input = trim(fgets(STDIN));
 if($input === 'Q') break;
 if($input === 'F') {
  echo call_user_func_array($functionToCall, $args);
  echo PHP_EOL;
  $functionToCall = null;
  $args = array();
  echo 'Type function name to run (Q to quit): ' . PHP_EOL;
  continue;
 }

 if($functionToCall === null) {
  $functionToCall = $input;
  echo 'Type function arg (F to finish): ';
 }
 else {
  echo 'Type function arg (F to finish): ';
  $args[] = $input;
 }
}

echo 'Bye' . PHP_EOL;

function Foo($arg1, $arg2)
{
 return 'Hello from Foo! - args: ' . $arg1. ', ' . $arg2;
}

function Bar()
{
 return 'Hello from Bar!';
}

Na koniec pozostawiłem ciekawą funkcjonalność – przekazywanie parametrów do skryptu.

echo 'Number of args passed: ' . $argc;
echo PHP_EOL;
echo 'Args passed: ';
print_r($argv);

Powyższy kod po wywołaniu go z wiersza poleceń z dodatkowymi parametrami

php skrypt.php -a -b "tekst ze spacjami" -c

wyświetli

Number of args passed: 5
Args passed: Array
(
    [0] => skrypt.php
    [1] => -a
    [2] => -b
    [3] => tekst ze spacjami
    [4] => -c
)

Pierwszym elementem tablicy jest nazwa wywołanego skryptu, kolejnymi – oddzielone spacjami parametry. Jeśli zmienne $argv oraz $argc z jakiegoś powodu nie zawierają żadnych danych, proponuję skorzystać z ich odpowiedników $_SERVER[‘argv’] oraz $_SERVER[‘argc’].

W ten oto prosty sposób można rozmawiać z PHP.

W jednym z wpisów na php.internals w dyskusji o dacie wersji alpha releasu kolejnej wersji php (5.4 ?) Johannes Schlüter który jest release managerem dla brancha 5.3, zaproponował by publikacje nowych wersji języka przeprowadzać w pewnych konkretnych cyklach. Cykle wydawnicze php miały by być oparte o model cykli Ubuntu. Co to oznacza ? Mniej więcej tyle, że istniałby stabliny branch typu LTS (long term support) który żył by określoną z góry ilość czasu (np. 2 lata) i otrzymywał by przez ten czas tylko poprawki (np. 5.3), równolegle istniał by kolejny branch (5.4) z pewną ilością zmian w stosunku do poprzedniej wersji, który otrzymywałby poprawki do czasu aż nie wyszedł by kolejny (5.5) z nowymi featurami. Taka polityka ma kilka zasadniczych zalet:

• szybkie wprowadzanie nowości do języka
• większa motywacja dla deweloperów by nowości do języka wprowadzali sprawniej
• określony cykl wydawniczy pozwalający końcowym użytkownikom prowadzenie efektywnej polityki migracji

Z ostatnich wpisów na liście wynika, że prawdopodobnie propozycja ta zostanie zaakceptowana, a nowe wersje języka będą pojawiały się raz do roku.

Co wy o tym sądzicie ?