Andi Gutmans, Stig Bakken და Derick Rethans-ის ახალი წიგნის “PHP 5 Power Programming” II თავი.
ორიგინალის მისამართი: http://www.zend.com/php5/andi-book-excerpt.php
- შესავალი
- ენის ახალი შესაძლებლობები
- ახალი ობიექტზე-ორიენტირებული მოდელი
- ახალი ობიექტზე-ორიენტირებული მიდგომა ენის სხვა ახალი შესაძლებლობები
- PHP-ში შესული ძირითადი ცვლილებები
- XML და ვებ სერვისები
- ახალი გაფართოება MySQLi (დახვეწილი MySQL)
- გაფართოება SQLite
- Tidy გაფართოება
- Perl გაფართოება
- PHP 5-ის სხვა სიახლეები
- დასკვნა
საუკეთესო გზა რათა მოვემზადოთ მომავლისათვის – ეს არის მისი გამოგონება. John Sculley
შესავალი
მხოლოდ დრო გვაჩვენებს, იქნება PHP 5 ისეთივე წარმატებული, როგორც მისი წინამორბედები (PHP 3 და PHP 4). ახალი შესაძლებლობები და თვისებები მიმართულია PHP – ს სუსტი მხარეების აღმოსაფხვრელად, და ლიდერის სტატუსის შესანარჩუნებლად ვებში.
ეს წიგნი ეძღვნება PHP 5-ის ახალი შესაძლებლობების მიმოხილვას. თუ თქვენ კარგად იცნობთ PHP 4-ს და დაინტერესებული ხართ PHP 5-ის ახალი შესაძლებლობებით, მაშინ ეს განყოფილება განკუთვნილია თქვენთვის.
ამ განყოფილებაში განხილულ იქნება:
- ენის ახალი შესაძლებლობები;
- სიახლეები, PHP – ს გაფართოებების (extensions) შესახებ;
- სხვა ცვლილებები, რომლებიც ყურადღებას იმსახურებს.
ენის ახალი შესაძლებლობები
ახალი ობიექტზე-ორიენტირებული მოდელი
როდესაც ზივ სერასკიმ (Zeev Suraski) დაამატა ობიექტზე-ორიენტირებული (ОО) სინტაქსი PHP 3-ში, ამის განხილვა შეიძლებოდა როგორც „სინტაქსური დამატკბობელი კლასების მხარდაჭერისათვის“ (“syntactic sugar for accessing collections”). ობიექტზე-ორიენტირებულმა მოდელმა მიიღო მემკვიდრეობის მხარდაჭერა და კლასსა (და ობიექტს) მიეცა საშუალება გაეერთიანებინა მეთოდები და თვისებები, მაგარამ არა უმეტეს. როდესაც ზივმა და ენდიმ გადაწერეს ძრავი PHP 4-სთვის, ეს იყო სრულიად ახალი ძრავი, რომელიც მუშაობდა საგრძნობლად სწრაფად, ბევრად სტაბილურად და დამატებით გააჩნდა სხვა უამრავი საშუალება. მაგრამ, ეს ცვლილებები პრაქტიკულად არ შეხებია ობიექზე-ორიენტირებულ მოდელს, რომელიც დანერგილი იყო ჯერ კიდევ PHP 3 – ში.
თუმცა ობიექტურ მოდელს გააჩნდა სერიოზული შეზღუდვები, ის ფართოდ გამოიყენებოდა, ხშირად ძალზე დიდ PHP აპლიკაციებში. ობიექტური მოდელის ასეთმა შეზღუდულმა სახემ PHP 4-ში, ცენტრალურ საკითხად აქცია აღნიშნული მოდელის შეცვლა PHP-ს ახალ რელიზში.
რა შეზღუდვები იყო PHP 3-სა და 4-ში? ყველაზე დიდი შეზღუდვა (რომელიც იწვევდა ყველა სხვა შეზღუდვას) იყო ის ფაქტი, რომ ობიექტის ეგზემპლარის სემანტიკა იყო იგივე, რაც მშობლიური ტიპებისათვის. როგორ აისახებოდა ეს პროგრამისტებზე? როდესაც თქვენ ანიჭებდით ცვლადს (რომელიც მიუთითებდა ობიექტზე) სხვა ცვლადს, იქმნებოდა ობიექტის დუბლიკატი. გარდა იმისა, რომ ეს ზემოქმედებას ახდენდა წარმადობაზე, ეს ფაქტი ხშირად იწვევდა შეცდომებს აპლიკაციაში, მიზეზი ამისა იყო ის, რომ ბევრი პროგრამისტი ფიქრობდა, რომ ორივე ცვლადი მიუთითებდა ერთსა და იმავე ობიექტს. სინამდვილეში ეს ცვლადები მიუთითებდნენ ერთი და იგივე ობიექტის სხვადასხვა დუბლიკატებს, ამიტომ, ერთი ობიექტის ცვლილებისას, ჩვენ არ ვცვლიდით მეორე ობიექტს.
მაგალითად:
კოდი:
[php]
class Person {
var $name;
function getName() {
return $this->name;
}
function setName($name) {
$this->name = $name;
}
function Person($name) {
$this->setName($name);
}
}
function changeName($person, $name) {
$person->setName($name);
}[/php]
კოდი:
[php]
$person = new Person(“Andi”);
changeName($person, “Stig”);
print $person->getName();[/php]
PHP 4-ში ეს კოდი გამოიტანს “Andi” – ს. მიზეზი მდგომარეობს იმაში, რომ ჩვენ ფუნქციას changeName() გადავცემთ $person ობიექტს მნიშვნელობით (By Value), და არა მისამართით (By Reference) ამგვარად, იბიექტი $person იქნება დუბლირებული, და ფუნქცია changeName() უკვე იმუშავებს $person ობიექტის დუბლიკატთან.
ასეთი ქმედება არ არის ინტუიციურად გასაგები. სინამდვილეში, ბევრი პროგრამისტი მოელოდა Java-ს მსგავს ქმედებას. Java-ში, ცვლადები ფაქტობრივად არიან მაჩვენებლები ობიექტზე, და ამიტომ დუბლირებისას მოხდება მაჩვენებლის კოპირება, და არა თვით ობიექტისა.
იყვნენ ორი სახის პროგრამისტები: ისინი, ვინც იცოდნენ ამ პრობლემის შესახებ, და ისინი, ვინც ეს არ იცოდნენ. უკანასკნელნი, ჩვეულებრივ, არ აწყდებოდნენ ამ პრობლემას, იმიტომ რომ მათი კოდი იყო დაწერილი ისე, რომ არ ქონდა მნიშვნელობა, არსებობდა თუ არა ასეთი პრობლემა. რა თქმა უნდა, ასეთი ტიპის პროგრამისტები ხშირად ატარებდნენ უძილო ღამეებს ასეთი „ზებუნებრივი“ შეცდომების ძიებაში. პირველ კატეგორიას ასევე გააჩნდა პრობლემა, რამდენადაც მათ ხელოვნურად უწევდათ ობიექტის მისამართით გადაცემა, რითიც უკრძალავდნენ ძრავს ობიექტების დუბლირებას, რის გამოც კოდი აჭრელებული იყო უამრვაი ‘&’ ნიშნით.
ძველი ობიექტური მოდელს მივყევართ არა მარტო ზემოთ ხსენებულ პრობლემებთან, არამედ ფარდას ხდის სხვა ფუნდამენტურ პრობლემებს, რომლებიც ხელს უშლიდნენ სხვა შესაძლებლობების განხორციელებას არსებულ ობიექტურ მოდელში.
PHP 5-ში ობიექტური მოდელი მთლიანად გადაწერილი იყო იმისათვის, რომ თავიდანვე შესაძლებელი გამხდარიყო ობიექტების მაჩვენებლებთან მუშაობა. თუ თქვენ ღიად არ ახდენთ ობიექტის კლონირებას, საკვანძო სიტყვა clone – ს გამოყენებით, მაშინ თქვენ არ მოგიწევთ ობიექტის დუბლიკატთან მუშაობა. PHP 5 – ში უკვე აღარ არის საჭირო ღიად ობიექტების გადაცემა მისამართით, ეს ხორციელდება ავტომატურად.
შენიშვნა: ღიად მისამართით გადაცემისა და მინიჭების მხარდაჭერა კვლავ ფუნქციონირებს, იმ შემთხვევისათვის, თუ თქვენ გინდათ ობიექტისა ან ცვლადის მნიშვნელობის შეცვლა.
ახალი ობიექტზე-ორიენტირებული მიდგომა
ობიექტური მოდელის ახალი შესაძლებლობები მეტად მრავალრიცხვოვანია, იმისათვის რომ სრულად იყოს განხილული ამ თავში. თავში, რომელიც ეძღვნება ობიექტურ მოდელს, დეტალურად იქნება განხილული ყველა ახალი შესაძლებლობა.
ქვევით მოყვანილია ძირითადი ცვლილებების მიმოხილვა:
1.public/private/protected – მოდიფიკატორები მეთოდებსა და თვისებებზე მიმართვისათვის.
საშუალებას გვაძლევენ ვაკონტროლოთ მეთოდებთან და თვისებებთან მიმართვა.
კოდი:
[php]
class MyClass {
private $id = 18;
public function getId() {
return $this->id;
}
}[/php]
2. უნიფიცირებული კონსტრუქტორი __construct()
კონსტრუქტორი, რომელიც ადრე ემთხვეოდა კლასის სახელს, ამჟამად აუცილებელია გამოვაცხადოთ როგორც __construct(), რაც საშუალებას მოგვცემს უფრო მარტივად გადავაადგილოთ კლასები იერარქიაში.
კოდი:
[php]class MyClass {
function __construct() {
print “Inside constructor”;
}
}[/php]
3. კლასის დესტრუქტორის მხარდაჭერა, განსაზღვრული როგორც მეთოდი __destructor()
საშუალებას გვაძლევს განვსაზღვროთ ფუნქცია დესტრუქტორი, რომელიც შესრულებული იქნება ობიექტის განადგურებისას.
კოდი:
[php]class MyClass {
function __destruct() {
print “Destroying object”;
}
}[/php]
4. ინტერფეისები
კლასს შეუძლია მემკვიდრეობით მიიღოს მხოლოდ ერთი კლასი, მაგრამ ამავ დროულად მას შეუძლია გააჩნდეს იმდენი ინტერფეისი რამდენიც საჭიროა.
კოდი:
[php]interface Display {
function display();
}
class Circle implements Display {
function display() {
print “Displaying circle “;
}
}[/php]
5. ოპერატორი instanceof
სხვა ობიექტებზე დამოკიდებულების შემოწმების საშუალება. PHP 4 – ის ფუნქციის is_a() გამოყენება არ არის რეკომენდირებული, მის მაგივრად გამოიყენება instanceof:
კოდი:
[php]if ($obj instance of Circle) {
print ‘$obj is a Circle’;
}[/php]
6. final მეთოდები
საკვანძო სიტყვა final საშუალებას გაძლევთ მონიშნოთ მეთოდი, რათა მემკვიდრე კლასმა ვერ შესძლოს მისი გადატვირთვა.
კოდი:
[php]class MyClass {
final function getBaseClassName() {
return __CLASS__;
}
}[/php]
7. final კლასები
კლასი გამოცხადებული როგორც final არ შეიძლება იყოს მემკვიდრეობით მიღებული სხვა კლასის მიერ. შემდეგი მაგალითი გამოიწვევს შეცდომას:
კოდი:
[php]final class FinalClass { }
class BogusClass extends FinalClass { }[/php]
8. ობიექტის ღიად კლონირება
იმისათვის რომ მოვახდინოთ ობიექტის კლონირება, თქვენ უნდა გამოიყენოთ საკვანძო სიტყვა clone. თქვენ შეგიძლიათ გამოაცხადოთ მეთოდი __clone(), რომელიც გამოძახებული იქნება ობიექტის კოპირებისას (მას შემდეგ, რაც ყველა თვისება იქნება კოპირებული საწყისი ობიექტიდან).
კოდი:
[php]class MyClass {
function __clone() {
print “Object is being cloned”;
}
}
$obj = new MyClass();
clone $obj;[/php]
9. კლასის კონსტანტები
კლასების განსაზღვრებებში უკვე შესაძლებელია კონსტანტების ჩართვა, და ობიექტების გამოყენებით მათზე მიმართვა.
კოდი:
[php]class MyClass {
const SUCCESS = “Success”;
const FAILURE = “Failure”;
}
print MyClass::SUCCESS;[/php]
10. კლასის სტატიკური
წევრები უკვე შესაძლებელია განვსაზღვროთ კლასის სტატიკური წევრები (თვისებები და მეთოდები), რომელთანაც კავშირი ხორციელდება კლასის მეშვეობით. სტატიკური წევრების ზოგადი გამოყენება ნაჩვენებია მაგალითში:
კოდი:
[php]class Singleton {
static private $instance = NULL;private function __construct() { }
static public function getInstance() {
if (self::$instance == NULL) {
self::$instance = new Singleton();
}
return self::$instance;
}
}[/php]
11. სტატიკური მეთოდები
თქვენ უკვე შეგიძლიათ განსაზღვროთ სტატიკური მეთოდები, რაც საშუალებას მოგცემთ გამოიძახოთ ისინი ობიექტის კონტექსტს მიღმა. სტატიკური მეთოდები არ განისაღვრება $this ცვლადის მეშვეობით, რამდენადაც ისინი არ უნდა იყვნენ შეზღუდულნი ობიექტის განსაზღვრით.
კოდი:
[php]class MyClass {
static function helloWorld() {
print “Hello, world”;
}
}
MyClass::helloWorld();[/php]
12. აბსტრაქტული კლასები
კლასი შესაძლებელია გამოცხადებული იყოს როგორც აბსტრაქტული საკვანძო სიტყვა abstract-ის გამოყენებით, რათა ძრავის მიერ გამოირიცხოს მისი აღწერა, თუმცა თქვენ შეგიძლიათ აბსტრაქტული კლასის მემკვიდრეობით გადაცემა:
კოდი:
[php]abstract class MyBaseClass {
function display() {
print “Default display routine being called”;
}
}[/php]
13. აბსტრაქტული მეთოდები
მეთოდი შესაძლებელია გამოცხადებული იყოს როგორც აბსტრაქტული, რითიც მისი განსაზღვრის პრეროგატივას ვუტოვებთ მემკვიდრე კლასს. კლასი, რომელიც შეიცავს აბსტრაქტულ მეთოდებს, უნდა იყოს გამოცხადებული როგორც abstract.
კოდი:
[php]abstract class MyBaseClass {
abstract function display();
}[/php]
14. კლასის როგორც ტიპის მითითება
ფუნქციის განსაზღვრა შეიძლება შეიცავდეს კლასის ტიპის მაჩვენებელს გადასაცემი პარამეტრებისათვის, თუ ფუნქცია გამოძახებული იქნება არასწორი ტიპით, წარმოიშვება შეცდომა.
კოდი:
[php]function expectsMyClass(MyClass $obj) { }[/php]
16. იტერატორები
PHP 5 საშუალებას გვაძლევს მიმდევრობით მივმართოთ კლასის ელემენტებს froeach() კონსტრუქციის მეშვეობით.
კოდი:
[php]$obj = new MyIteratorImplementation();
foreach ($obj as $value) {
print “$value”;
}[/php]
17. __autoload()
მრავალი პროგრამისტი, რომლებიც წერენ ობიექტზე-ორიენტირებულ აპლიკაციებს, ქმნიან ერთ ფაილს, რომელიც შეიცავს კლასის განსაზღვრას. საკმაოდ მოუხერხებელია ყოველი სკრიპტის დასაწყისში ჩასართავი ფაილების გრძელი სიის ჩამოწერა (თითო ფაილი თითო კლასისათვის).
PHP 5 – ში აღარ არსებობს ამის აუცილებლობა. თქვენ შეგიძლიათ განსაზღვროთ ფუნქცია __autoload(), რომელიც ავტომატურად იქნება გამოძახებული იმ კლასის გამოყენების შემთხვევაში რომელიც არ იყო ჩართული ფაილში მანამდე. აღნიშნული ფუნქციის გამოძახებით, Zend Engine იძლევა საშუალებას ფაილი ჩაიტვირთოს მანამდე, ვიდრე დაგენერირდება შეტყობინება შეცდომეის შესახებ და შეჩერდება სკრიპტის მუშაობა.
კოდი:
[php]function __autoload($class_name) {
include_once($class_name . “php”);
}
$obj = new MyClass1();
$obj2 = new MyClass2();[/php]
ენის სხვა ახალი შესაძლებლობები
1.შეცდომების დამუშავება
PHP 5 – ში დამატებულია შეცდომების დამუშავების დამუშავების ახალი მექანიზმი, try/throw/catch სტრუქტურის შემოტანით. თქვენ მხოლოდ გჭირდებათ ობიექტის შექმნა, რომელიც მემკვიდრეობით მიიღებს შეცდომების დამუშავების კლასს Exception.
კოდი:
[php]class SQLException extends Exception {
public $problem;
function __construct($problem) {
$this->problem = $problem;
}
}
try {
…
throw new SQLException(“Couldn’t connect to database”);
…
} catch (SQLException $e) {
print “Caught an SQLException with problem $obj->problem”;
} catch (Exception $e) {
print “Caught unrecognized exception”;
}[/php]
დღეს დღეობით უკუ თავსებადობის მიზნით შიდა ფუნქციების უმეტესობა არ იყენებს შეცდომების დამუშავების აღწერილ მეთოდს. თუმცა, ყველა ახალ გაფართოებას ექნება ასეთი საშუალება, და თქვენ შეგიძლიათ გამოიყენოთ ასეთი კონსტრუქცია თქვენს საწყის კოდებში. გარდა ამისა, უკვე არსებული ფუნქციის set_error_handler() ნაცვლად, თქვენ შეგიძლიათ გამოიყენოთ set_exception_handler(), რათა მოხდეს დაუმუშავებელი შეცდომების დაჭერა მანამდე, სანამ დასრულდება სკრიპტის შესრულება.
2. foreach მისამართით
PHP 4-ში თქვენ არ შეგეძლოდ მასივის იტერაციის დროს გეცვალათ მისი ელემენტების მნიშვნელობები. PHP 5-ში დაშვებული foreach() – ის შესრულებ, მისმართის აღმნიშვნელის (‘&’) გამოყენებით, ამგვარად, ცვლადის შეცვლისას, თქვენ ცვლით მასივის ელემენტს, რომელზეც ხორციელდება იტერაცია.
კოდი:
[php]foreach ($array as &$value) {
if ($value === “NULL”) {
$value = NULL;
}
}[/php]
3. მისამართით გადაცემული პარამეტრების წინასწარ განსაზღვრული მნიშვნელობები
PHP 4-ში მნიშვნელობის წინასწარ განსაზღვრა პარამეტრისათვის შესაძლებელი იყო მხოლოდ იმ შემთხვევაში თუ ის გადაეცემოდა მნიშვნელობით. ამჟამად შესაძლებელია მისამართით გადაცემული პარამეტრებისათვის მნიშვნელობების წინასწარ განსაზღვრა.
კოდი:
[php]function my_func(&$arg = null) {
if ($arg === NULL) {
print ‘$arg is empty’;
}
}my_func();[/php]
PHP-ში შესული ძირითადი ცვლილებები
XML და ვებ სერვისები
ენასთან დაკავშირებული ცვლილებების გარდა, XML-თან მუშაობაში შეტანილი ცვლილებები PHP 5-ის ერთ ერთი არსებითი და მნიშვნელოვანი მხარეა. XML-თან სამუშაო ფუნქციონალური საშუალებების გაფართოება PHP 5-ში, ქსელში გამოყენებადი სხვა ენების თანასწორს ხდის მას.
საფუძვლები
XML-ის მხარდაჭერა PHP 4-ში ბაზირებული იყო სხვადასხვა XML ბიბლიოთეკებზე. SAX-ის მხარდაჭერა ხორციელდებოდა Expat-ის ძველი ბიბლიოთეკის მეშვეობით, XSLT-ს გამოსაყენებლად საჭირო იყო Sablotron ბიბლიოთეკა, DOM-თან სამუშაოდ გამოიყენებოდა უფრო მძლავრი libxml2 – პროექტი GNOME-ს ბიბლიოთეკა.
სხვადასხვა გარეშე ბიბლიოთეკების გამოყენება არ ანიჭებდა არანაირ უპირატესობას PHP 4-ს სხვა ენებთან მიმართებაში როდესაც საქმე ეხებოდა XML-ს მხარდაჭერას. გაფართოებების ბიბლიოთეკების მხარდაჭერა იყო სუსტი, XML-ს ახალი სტანდარტები არ იყო ყოველთვის რეალიზებული, წარმადობა არ იყო იმდენად კარგი რამდენადაც ეს იყო შესაძლებელი, ურთიერთქმედება XML-ს სხვადასხვა გაფართოებებს შორის არ არსებობდა.
PHP 5-ში XML-ს ყველა გაფართოება იყო ხელმეორედ გადაწერილი, რათა გამოყენებული ყოფილიყო libxml2 (http://www.xmlsoft.org/)-ის მიერ წარმოდგენილი ინსტრუმენტების განსხვავებული კრებული. ეს არის შესაძლებლობებით მდიდარი ბიბლიოთეკა, რემელშიც ეფექტურად არის რეალიზებული XML სტანდარტები, რაც საშუალებას აძლევს PHP-ს გამოიყენოს XML ტექნოლოგიის მოწინავე შესაძლებლობები.
ყველა ზემოთ ხსენებული გაფართოებები (SAX, DOM и XSLT) ამჟამად იყენებს libxml2-ს, ისევე როგორც ახალი დამატებით გაფართოებები – SimpleXML da SOAP.
SAX
როგორც ზემოთ ითქვა, SAX-ის ახალი რეალიზაცია გადაყვანილია Expat-ის გამოყენებიდან libxml2-ზე. თუმცა ახალი გაფართოება უნდა იყოს თავსებადი, შესაძლოა არსებობდეს გარკვეული სხვაობები. დეველოპერები, რომლებსაც სურთ განაგრძონ მუშაობა Expat ბიბლიოთეკასთან, შეუძლიათ, დააკონფიგურირონ PHP შესაბამისი სახით (არ არის რეკომენდირებული).
DOM
თუმცა DOM-ის მხარდაჭერა PHP 4-ში ასევე ეყრდნობოდა libxml2 ბიბლიოთეკას, მასში იყო უამრავი შეცდომა, და აღნიშნული API ხშირ შემთხვევაში არ ესადაგებოდა W3C რეკომენდაციებს. DOM გაფართოება მთლიანად იქნა გადაწერილი PHP 5-სათვის. გარდა ამისა, გაფართოება იყო საფუძველშივე შეცვლილი, ამჟამად იგი შეესაბამება W3C რეკომენდაციებს. მაგალითად, ფუნქციების დასახელებები იყენებენ ნოტაციას studlyCaps (სახელების მინიჭება სხვადასხვა რეგისტრის სიმბოლოების გამოყენებით) როგორც განსაზღვრულია W3C სტანდარტში, რაც ამარტივებს თქვენს მიერ W3C დოკუმენტაციაში წაკითხულის გამოყენებას PHP-ში. გარდა ამისა, DOM გაფართოება მხარს უჭერს XML დოკუმენტის ვალიდაციის სამ სქემას – DTD, XML Schema და RelaxNG.
ამ ცვლილებების შედეგაც კოდი, დაწერილი PHP 4-ისათვის რომელშიც გამოყენებულია DOM, ყოველთვის არ იმუშავებს PHP 5 ში. თუმცა, მარტივი შესწორება ფუნქციების დასახელებებში ახალი სტანდარტის შესაბამისად ხშირ შემთხვევაში ხსნის პრობლემას.
XSLT
PHP 4-ში, იყო ორი გაფართოება, რომლებიც უზრუნველყოფდნენ XSL-გარდაქმნას. პირველი გაფართოება იყენებდა Sablotron-ს, მეორე XSLT მხარდაჭერას DOM გაფართოებიდან. PHP 5-ში ახალი გაფართოება XSL იყო დაფუძნებული libxml2-ის გამოყენებაზე. მაგალითად PHP 5-ში XSL-გარდაქმნა არ ღებულობს XSLT სტილების ცხრილს პარამეტრის სახით, მაგრამ დამოკიდებულია DOM-ზე, რათა ჩატვირთოს ის. შესაძლებელია სტილების ცხრილის კეშირება მეხსიერებაში, და დასაშვებია მისი გამოყენება მრავალ დოკუმენტთან შესრულების დროის არსებითი ეკონომიისათვის.
SimpleXML
ალბათ, ერთი ან ორი წლის მერე, როდესაც მოვიხედავთ უკან, შევძლებთ ვთქვათ, რომ SimpleXML-მა ძირეულად შეცვალა XML დოკუმენტებთან მუშაობა PHP პროგრამისტებისათვის. SimpleXML-ს მართლაც შეიძლება ვუწოდოთ „XML დამწყებთათვის“. იმის მაგივრად, რომ საქმე გვქონდეს DOM-თან ან, რაც უფრო უარსეია, SAX-თან, SimpleXML საშუალებას გვაძლევს წარმოადგინოთ თქვენი XML დოკუმენტი როგორც PHP-ს მშობლიური ობიექტი. თქვენ შეგიძლიათ წაიკითოთ, ჩაწეროთ ან უბრალოდ გადაურბინოთ თქვენს XML დოკუმენტს და მარტივად მიმართოთ დოკუმენტის ელემენტებსა და ატრიბუტებს.
გადახედეთ შემდეგ XML დოკუმენტს:
კოდი:
[xml]
[/xml]
კოდის შემდეგი ფრაგმენტი ბეჭდავს ყოველი კლიენტის სახელს და მისი ანგარიშის ნომერს:
კოდი:
[php]$clients = simplexml_load_file(‘clients.xml’);
foreach ($clients->client as $client) {
print “$client->name has account number $client->account_number “;
}[/php]
როგორც მაგალითიდან ვხედავთ, SimpleXML მართლაც მარტივია.
იმ შემთხვევაში, თუ არის აუცილებლობა იმისა რომ გააკეთოთ ისეთი რამ რაც სცილდებ SimpleXML-ს შესაძლებლობებს, თქვენ შეგიძლიათ გარდაქმნათ თქვენი ობიექტი SimpleXML DOM-ის ხეთ, dom_import_simplexml() ფუნქციის გამოძახებით, შეასრულოთ საჭირო ოპერაციები, და დაუბრუნდეთ კვლავ SimpleXML-ს, simplexml_import_dom() ფუნქციის გამოძახებით. გამომდინარე იქიდან, რომ ორივე გაფართოება რეალიზებულია ერთ XML ბიბლიოთეკაში, მათ შორის გადართვა უკვე სავსებით რეალურია.
SOAP
PHP 4-ში SOAP-ის ოფიციალური მხარდაჭერა არ არსებობდა. საერთოდ, SOAP-ის გამოყენების საჭიროების შემთხვევაში, საჭირო ხდებოდა PEAR (PHP Extension and Application Repository http://pear.php.net/) გამოყენება, მაგრამ რამდენადაც კოდი დაწერილი იყო მთლიანად PHP-თი, აპლიკაციებს არ შეეძლოთ ისე შესრულება როგორც ინტეგრირებულ C-გაფართოებებს. სხვა არსებულმა C გაფართოებებმა ვერ შეძლეს მიეღწიათ სტაბილური ვერსიებისათვის, და ამიტომ არ მოხდა მათი ჩართვა PHP 5-ში.
SOAP-ის მხარდაჭერა PHP 5-ში მთლიანად იქნა გადაწერილი როგორც C გაფართოება და, თუმცა ამჟამად იმყოფება ბეტა ტესტირების უკანასკნელ სტადიაზე, მიღებულ იქნა გადაწყვეტილება მისი ჩართვა სტანდარტულ დისტრიბუტივში, რამდენადაც მასში სავსებით არის რეალიზებული SOAP სტანდარტი.
შემდეგი კოდით ხორციელდება WSDL ფაილში განსაზღვრული SomeFunction() ფუნქციის გამოძახება:
კოდი:
[php]$client = new SoapClient(“some.wsdl”);
$client->SomeFunction($a, $b, $c);[/php]
ახალი გაფართოება MySQLi (დახვეწილი MySQL)
PHP 5-ში MySQL AB (http://www.mysql.com/) – სთვის იყო დაწერილი ახალი გაფართოება MySQL, რომელიც საშუალებას გაძლევთ სრულად გამოიყენოთ MySQL 4.1-ის და უფრო ახალი ვერსიების ფუნქციონალური საშუალებების უპირატესობები. გაფართოების ძველი ვერსიის საპირისპიროდ ახალი გაფართოება გაძლევთ საშუალებას გამოიყენოთ ორივე ინტერფეისი: ფუნქციონალური და ობიექტზე-ორიენტირებული. გაფართოებაში რეალიზებულია რიგი ახალი შესაძლებლობები, მათ შორის ტრანზაქციების კონტროლი, რეპლიკაცია, SSL და მრავალი სხვა…
გაფართოება SQLite
SQLite-ს (http://www.sqlite.org/) მხარდაჭერა თავდაპირველად დანერგილი იყო PHP 4.3.x ვერსიებში. ეს არის SQL-ის ინტეგრირებული ბიბლიოთეკა, რომელიც არ საჭიროებს SQL-სერვერებს. დასახელების მიუხედავად, SQLite გააჩნია მდიდარი შესაძლებლობები და უზრუნველყოფს ტრანზაქციებს, Sub Selects, Views.
Tidy გაფართოება
PHP 5-ში ასევე უზრუნველყოფილია ძალზედ საჭირო ბიბლიოთეკა Tidy (http://tidy.sf.net/). იგი HTML დოკუმენტის გარჩევის, გასუფთავების და აღდგენის საშუალებას გვაძლევს. Tidy უზრუნველყოფს როგორც ფუნქციონალურ, ასევე ობიექტზე-ორიენტირებულ ინტერფეისს, და მის API-ში გამოიყენება PHP 5-ში არსებული შეცდომების დამუშავების მექანიზმი.
Perl გაფართოება
Perl გაფართოება საშუალებას გაძლევთ გამოიძახოთ Perl-სკრიპტები, გამოიყენოთ Perl ობიექტები და გამოიყენოთ Perl-ის სხვა ფუნქციონალური საშუალებები უშუალოდ PHP კოდიდან. ეს ახალი გაფართოება შეიძლება მოიძიოთ მისამართზე http://pecl.php.net/package/perl..
PHP 5-ის სხვა სიახლეები
მეხსიერების ახალი მენეჯერი
Zend Engine იყენებს მეხსიერების ახალ მენეჯერს. ორი უმთავრესი მისი უპირატესობა: გაუმჯობესებული მხარდაჭერა მრავალნაკადური გარემოსი (განაწილებული ბლოკები აღარ საჭიროებენ ურთიერთ ბლოკირებას) და ის, რომ ყოველი მიმართვის შემდეგ უფრო ეფექტურად თავისუფლდება მეხსიერების ბლოკები. რამდენადაც ეს ეხება ძირითადად ინფრასტრუქტურის ცვლილებას, თქვენ, როგორც საბოლოო მომხმარებელი, ვერ შენიშნავთ ამას.
შეწყვეტილია Windows 95-ის მხარდაჭერა
PHP-ს გაშვება Windows 95 პლატფორმაზე შეუძლებელია, რადგან შეუძლებელია იმ ფუნქციონალური შესაძლებლობების გამოყენება, რომელსაც იყენებს PHP.
დასკვნა
ალბათ შთაბეჭდილება მოახდინა თქვენზე PHP 5-ში განხორციელებულმა ცვლილებების რაოდენობამ. როგორც ზემოთ ითქვა, ეს თავი ვერ შეძლებს ყველა გაუმჯობესების წარმოჩენას, აქ ასახვა ჰპოვა მხოლდ მთავარმა საკითხებმა. წიგნის შემდეგი თავები მოგცემთ საშუალებას ყოველ მხრივ გაეცნოთ ნახსენებ ახალ შესაძლებლობებს და ასევე სხვებს, რომლებიც აქ არ ყოფილა ნახსენები.
ტეგები: PHP
[...] სხვაობა უცნობია შეუძლიათ წაიკითხონ ეს პოსტი რომელიც რამდენიმე წლის წინ ვთარგმნე, [...]