Как работает

Писал данный скрипт для одного из разрабатываемых проектов. Принцип прост: грузится RSS-лента нужного вам пользователя, выбирается последняя запись и, при необходимости, кешируется в текстовом файле. XML обрабатывается через DOMDocument.

Атрибут public $cache_file определяет расположение файла кеша.

Атрибут public $cache_period отвечает за частоту обновления кеша. Указывается в секундах (3600 соответствует 1 часу). Если значение равно 0, кеш игнорируется.

Все остальное, думаю, понятно. Если есть вопросы, задавайте.

Кстати возник вопрос, если интегрировать этот скрипт в какой-либо сайт, допустим в блог, увеличит ли это частоту посещения сайта роботом поисковиков? Ведь с каждым новым обновлением в твиттере будет изменяться частичка контент почти на всех страницах сайта.

Скомпонованный код

class GetLastTwitt{

    public $cache_file = './last_twitt.txt';
    public $cache_period = 3600;

    private $username;
    private $dom;

    function __construct($username){
        $this->username = $username;
    }

    private function setEnv(){
        $feed_url = 'http://twitter.com/statuses/user_timeline/'.$this->username.'.rss';

        $this->dom = new DOMDocument();
        $this->dom->load($feed_url);
    }

    private function returnLastTwitt (){
        if ($this->cache_period != 0)
            if (file_exists($this->cache_file))
                if ($this->cache_period > $this->getCacheDateDiff())
                    return $this->getLastFromCache();

        return $this->getLastFromWeb($this->username);
    }

    private function getLastFromWeb($username){
        $this->setEnv();
        $rows = $this->dom->getElementsByTagName('item');
        $last_twitt = $rows->item(0)->getElementsByTagName('title')->item(0)->nodeValue;
        $this->cache_twitt($last_twitt);
        return $last_twitt;
    }

    private function cache_twitt($msg){
        $handle = fopen($this->cache_file,'w');
        fwrite($handle, $msg);
        fclose($handle);
    }

    private function getCacheDateDiff(){
        return date('U') — filemtime($this->cache_file);
    }

    private function getLastFromCache(){
        $handle = fopen($this->cache_file,'r');
        $cached_twitt = fread($handle, filesize($this->cache_file));
        fclose($handle);
        return $cached_twitt;
    }

    final function getLast(){
        return $this->returnLastTwitt();
    }

}

$a = new GetLastTwitt('skaizer');
echo $a->getLast();

Скомпонованный готовый скрипт можно скачать здесь.

У вас есть Twitter аккаунт?
Если да, можете подписаться на мой микроблог, а я, в свою очередь, подпишусь на ваш.

Итак, наиболее простое решение — это создать метод (wrapper) который в качестве параметров будет принимать название и параметр вызываемого метода. В данном случае метод wrapper и является той самой «оберткой». Реализация этого решения может быть следующей:

Exceptions.php

class ExceptionDb extends Exception {}
class ExceptionModel extends Exception {}

ModelExtension.php

class ModelExtension {

  function wrapper($method, $data = null) {
    try {

      if (!is_callable(array($this, $method)))
        throw new ExceptionModel('Method "' . $method . '" not found'."\n");

      try {
        return $this->$method($data);
      } catch(ExceptionDb $e) {
        echo $e->getMessage();
      }

    } catch(ExceptionModel $e) {
      echo $e->getMessage();
    }
  }
}

MyModel.php

class MyModel extends ModelExtension {

  function query() {
    if (true) {
      echo 'Method "query" is loaded'."\n";
    } else {
      throw new ExceptionDb('Error in method "query"'."\n");
    }
  }

  function errorQuery() {
    if (false) {
      echo 'method "errorQuery" is loaded'."\n";
    } else {
      throw new ExceptionDb('Error in method "errorQuery"'."\n");
    }
  }
}

index.php

include 'Exceptions.php';
include 'ModelExtension.php';
include 'MyModel.php';

$myModel = new MyModel();
$myModel->wrapper('query');
$myModel->wrapper('errorQuery');
$myModel->wrapper('anotherQuery'); 

Давайте разберем что я тут понаписал.

В примере участвуют несколько файлов:

• Exceptions.php - в нем созданы в исключения, для перехвата ошибок в запросах ExceptionDb и в модели ExceptionModel.
• ModelExtension.php - родительский класс модели. От него наследуются все модели используемые в проекте. В нем же описан метод wrapper. В качестве первого аргумента он принимает название вызываемого метода, вторым аргументом идут данные, передаваемые в вызываемый метод. Перед вызовом метода, через функцию is_callable проверяется что он существует и может быть вызван, в противном случае генерируется исключение ExceptionModel, которое тут же и перехватывается, т.к. конструкция if - else помещена в блок try - catch. Если метод существует, то он вызывается помещенный при этом в блок try - catch, который перехватывает исключения ExceptionDb запросов в БД. Именно этот момент и нужно было реализовать.
• MyModel.php - тестовая модель. Класс MyModel расширяет ModelExtension. В нем описаны тестовые методы, выполняющиеся успешно (метод query) или завершающиеся возвратом исключения ExceptionDb (метод errorQuery).
• index.php - собирает все файлы и запускает тестовый пример.

Результатом работы этого примера будут сообщения:

Method «query» is loaded
Error in method «errorQuery»
Method «anotherQuery» not found

Все работает как и ожидалось. Однако очевидно, что конструкция
$model-<wrapper(method [,data]) не совсем удачно решение. Куда удобнее и привычнее использовать $model-<method([data]). Сделать это нам поможет один из «магических» методов PHP, а именно метод __call. Напомню, что он вызывается всякий раз, когда запрашивается несуществующий метод класса. Можно создать псевдо-класс модели, в котором будет описан только метод __call(), который будет перенаправлять вызов методов на реальный класс модели. Чтобы воплотить задуманное, нужно модифицировать имеющийся код:

ModelLoader.php

class ModelLoader {
  private $_modelName;
  private $_model;
  private $_isLoad = false;

  function __construct($name) {
    $this->_modelName = $name;
  }

  function __call($method, $data = null) {
    try {

      if ($this->_isLoad === false) {
        if (!is_callable(array($this->_modelName, '__construct')))
          throw new ExceptionModel('Model class "' . $this->_modelName . '" not found');

        $this->_create_model_();
        $this->_isLoad = true;
      }

      if (!is_callable(array($this->_modelName, $method)))
        throw new ExceptionModel('Method "' . $method . '" not found'."\n");

      try {
        return $this->_model->$method($data);
      } catch(ExceptionDb $e) {
        echo $e->getMessage();
      }

    } catch(ExceptionModel $e) {
      echo $e->getMessage();
    }
  }

  private function _create_model_() {
    $this->_model = new $this->_modelName();
  }
}

MyModel.php

class MyModel {

  function __construct() {}
  ...

}

index.php

include 'Exceptions.php';
include 'ModelLoader.php';
include 'MyModel.php';

$myModel = new ModelLoader('MyModel');
$myModel->query();
$myModel->errorQuery();
$myModel->anotherQuery();

В этом примере мы избавились от класса ModelExtension, и добавили новый — ModelLoader.

При создании объекта ModelLoader в него передается название класса модели. Метод __call в классе ModelLoader полностью повторяет метод wrapper, с небольшим дополнением, при первом вызове создается экземпляр модели. Перед созданием проверяется, существует ли вызываемый класс. Для того чтобы осуществить эту проверку, мы дополнили класс MyModel функцией __construct.

Вот впринципе и все. Если запустить index.php то результат будет идентичный результату первого примера.

Акция «Обмен постовыми» продолжается!

Скомпонованный готовый скрипт можно скачать здесь.

В прошлый раз мы описали базовую функциональность класса, позволяющую управлять своим содержимым. Но в таком виде его использование не является удобным. В этой статье мы это исправим.

Добавляя данные в массив, мы привыкли использовать конструкцию $objArray[key] = value и врядли мы нас устроит текущая альтернатива — $objArray->add(value, key). Так же в текущей реализации невозможно просмотреть массив с помощью конструкции foreach, поэтому если мы добавляем элемент без ключа (ключ будет присвоен автоматически), то мы фактически «теряем» элемент.

К счастью, разработчики PHP позаботились об этом, и предоставили в наше распоряжение различные предопределенные интерфейсы, которые позволяют выполнять несвойственные объектам операции.

Наш класс ObjectsArr будет реализовывать интерфейсы: ArrayAccess, IteratorAggregate и Countable. Также будет создан новый класс ObjectsArrInrerator, реализующий интерфейс Iterator.

Теперь обо всем по порядку:

Интерфейс ArrayAccess — позволяет обращаться к объекту, используя принцип обращения к обычному массиву.

Интерфейс Countable — позволяет применять функцию count к объекту.

Класс ObjectsArrInrerator в связке с интерфейсом IteratorAggregate — позволяет просматривать массив, используя оператор foreach.

Реализация интерфейса ArrayAccess

//обновляем строку инициализации класса
class ObjectsArr implements ArrayAccess {
  //добавляем новые методы
  public function offsetSet($key, $value) {
        $this->add($value, $key);
  }
  public function offsetUnset($key) {
    $this->del($key);
  }
  public function offsetGet($key) {
    return $this->get($key);
    }
  public function offsetExists($key) {
    return $this->exist($key);
  }
  //остальное описание класса …
}

Как вы можете видеть, новые методы являются оберткой уже существующих, но именно с помощью них можно обращаться к объекту, как к массиву. В частности теперь возможно:

• использовать $objArray[key] = value вместо $objArray->add(value, key)
• использовать unset($objArray[key]) вместо $objArray->del(key)
• использовать $objArray[key] вместо $objArray->get(key)
• использовать isset($objArray[key]) или empty($objArray[key]) вместо $objArray->exist (key)

Реализация интерфейса Countable

//обновляем строку инициализации класса
class ObjectsArr implements ArrayAccess, Countable {
//добавляем новые методы
  public function count() {
    return $this->length();
  }
//остальное описание класса …
}

Как и в предыдущем случае, теперь можно использовать count($objArray) вместо $objArray->length().

Разработка класса ObjectsArrInrerator и  реализация интерфейса IteratorAggregate

Новый класс, который будет использоваться при просмотре объекта в foreach:

class ObjectsArrInrerator implements Iterator {
  private $_list;
  private $_current;
  private $_keys;

  function __construct(ObjectsArr $obj) {
    $this->_list = $obj;
    $this->_keys = $this->_list->keys();
  }

  function rewind() {
    $this->_current = 0;
  }

  function valid() {
    return $this->_current < $this->_list->length();
  }

  function key() {
    return $this->_keys[$this->_current];
  }

  function next() {
    $this->_current++;
  }

  function current() {
    return $this->_list->get($this->_keys[$this->_current]);
  }
}

Готово! Эти методы объяснять думаю не стоит. Названия у них говорят сами за себя. Они будут использоваться конструкцией foreach при просмотре объекта. Если Вам интересна последовательность их вызова, добавьте в каждый из них echo с названием метода, и увидите как foreach «смотрит» наш объект.

И последнее на сегодня:

//обновляем строку инициализации класса
class ObjectsArr implements ArrayAccess, Countable, IteratorAggregate {
  //добавляем новые методы
  function getIterator() {
    return new ObjectsArrInrerator (clone $this);
  }
  //остальное описание класса …
}

Метод getIterator будет вызываться при попытке просмотреть объект через foreach.

В PHP существует сразу встроенный аналог только что созданного нами класса. Это класс ArrayObject. Но попытка изменения объекта в ходе перебора его элементов, может привести к плачевным последствиям. Об этом я написал в комментарии, к предыдущей статье. Избежать такого поведения позволяет передача интератору, не самого просматриваемого объекта, а его копии — return new ObjectsArrInrerator(clone $this).

Тестирование класса ObjectsArr

Осталось только протестировать наш класс. Для тестирования я взял тот же пример, что и в предыдущей статье, чтобы наглядно было видно как изменился наш класс.

$clientsList = new ObjectsArr();
try {
$clientsList['ivan'] = new Client('Ваня'); //Добавляем нового клиента
$clientsList['alexander'] = new Client('Саша'); //Добавляем нового клиента
$clientsList['petr'] = new Client('Петя'); //Добавляем нового клиента

$objIvan = $clientsList['ivan']; //Извлекаем клиента
echo $objIvan; // выведет ->  Клиент - "Ваня"

foreach ($clientsList as $key => $value) { //Просмотр всей коллекции объектов
  echo $key . ' -> ' . $value . "\r\n";
}

unset($clientsList['ivan']); //удаляем клиента

$clientsList['petr'] = new Client('Петр Иванович'); /*перехват исключения, т.к. ключ "petr" уже используется
                                                          выведет -> Ключ "petr" уже используется. */
} catch (Exception $e) {
  echo $e->getMessage();
}

На данный момент все. Мы реализовали еще одно из предъявленных к классу ObjectsArr требований, а именно:

возможность перебора всей коллекции элементов

Использование класса так же стало более удобным. Теперь его трудно отличить от обычного массива.

В следующей — заключительной статье мы добавим механизм заполнения массива при первом обращении к нему.

Но для начала давайте разберемся, чем нас не устраивает обычный массив. Предположим, Вы разрабатываете какое-либо корпоративное приложение, и в нем необходим перечень менеджеров с прилагающимся списком обслуженных клиентов.

class Client  {
  public $name;
//описание класса
}
class Manager  {
  public $clients = array();
//описание класса
//где-то в нем происходит  заполнение массива
//объектами класса Client
}
//просмотр список обслуженных клиентов
$objManager  = new Manager(‘id’);
foreach ($objManager->clients as $client) {
  echo $client->name;
}

В принципе мы получили что хотели — список клиентов. Однако данный подход не является хорошим решением по нескольким причинам:

• открытый массив $objManager->clients нарушает инкапсуляцию. Массив можно сделать закрытым с доступом к нему через метод $objManager->getClients(). Но такой подход не поможет, в случае если возникнет необходимость его модифицировации по ходу его просмотра. Если же оставить массив открытым для возможности модификации, то мы не сможем контролировать и/или фильтровать информацию заносящуюся в него.
• информация по клиентам будет загружена при создании объекта, даже если нужно только имя менеджера и не больше. Конечно, можно создать метод $objManager->loadClientsInfo(), только после вызова которого будет подгружена информация о клиентах, однако удобнее было бы если информация будет подгружена автоматически в момент когда к ней обратятся.

Для решения этих проблем создадим класс ObjectsArr — оболочку вокруг массива объектов. Предъявим к нему следующие требования:

1. предоставление механизма добавления, удаления и извлечения элементов;
2. заполнение информации по клиентам при первом обращении к ней;
3. возможность перебора всей коллекции элементов. (for, foreach)

Описание реализации этих требований довольно громоздко, поэтому разобьем нашу статью на несколько частей. В каждой новой части мы будем наращивать функциональность класса ObjectsArr.

Итак, давайте создадим класс ObjectsArr и прикрутим к нему механизм управления содержимым.

Класс ObjectsArr

class ObjectsArr {
  private $_list = array();
}

Метод добавления элемента

public  function add($value, $key = null) {
  if ($key === null || empty($key)){
    $this->_list[] = $data;
    return;
  }
 
  if (!isset($this->_list[$key])){
    $this->_list[$key] = $data;
  } else {
    throw new Exception('Ключ "' . $key . '" уже  используется.');
  }
}

Метод add принимает 2 аргумента, добавляемый элемент и его ключ. Ключ является необязательным, если его опустить, то он будет генерироваться автоматически. При попытке добавить элемент с уже существующим ключом будет сгенерировано исключение.

Метод удаления элемента

public  function del($key)  {
  if (isset($this->_list[$key])) {
    unset($this->_list[$key]);
  } else {
    throw new Exception('Элемент с ключем  "' . $key . '" отсутсвует.');
  }
}

Удаляет элемент по его ключу. Если ключ отсутствует, то генерируется исключение.

Метод извлечения элемента

public  function get($key) {
  if (isset($this->_list[$key])) {
    return $this->_list[$key];
  } else {
    throw new Exception('Элемент с ключем  "' . $key .  '" отсутсвует.');
  }
}

Извлекает элемент по его ключу. Если ключ отсутствует, то генерируется исключение.

Метод проверки наличия элемента

public function exist($key) {
  return isset($this->_list[$key]);
}

Поскольку добавление элемента с существующим ключем сгенерирует исключение, то данная функция позволяет проверить, используется ли ключ или нет.

Метод получения всех элементов

public function keys() {
  return array_keys($this->_list);
}

Эта функция позволяет получить все имеющиеся ключи добавленных элементов.

Метод подсчета добавленных элементов

public function length() {
  return count($this->_list);
}

Эта функция возвращает количество установленных элементов.

Весь класс, полностью

Это все. Полностью класс ObjectsArr будет выглядеть так:

class ObjectsArr {
  private $_list = array();
 
  public function add($value, $key = null) {
    if ($key === null || empty($key)){
      $this->_list[] = $data;
      return;
    }
   
    if (!isset($this->_list[$key])){
      $this->_list[$key] = $data;
    } else {
      throw new Exception('Ключ "' . $key . '" уже  используется.');
    }
  }
 
  public function del($key) {
    if (isset($this->_list[$key])) {
      unset($this->_list[$key]);
    } else {
      throw new Exception('Элемент с  ключем "' . $key .  '" отсутсвует.');
    }
  }
 
  public function get($key) {
    if (isset($this->_list[$key])) {
      return $this->_list[$key];
    } else {
      throw new Exception('Элемент с  ключем "' . $key .  '" отсутсвует.');
    }
  }
 
  public function exist($key) {
    return isset($this->_list[$key]);
  }
 
  public function keys() {
    return array_keys($this->_list);
  }
 
  public function length() {
    return count($this->_list);
  }
}

Тестирование класса ObjectsArr

$clientsList = new ObjectsArr();
try {
$clientsList->add(new Client('Ваня'), 'ivan'); //Добавляем нового клиента
$clientsList->add(new Client('Саша'), 'alexander'); //Добавляем нового клиента
$clientsList->add(new Client('Петя'), 'petr'); //Добавляем нового клиента

$objIvan = $clientsList->get('ivan'); //Извлекаем клиента
echo $objIvan; // выведет ->  Клиент - "Ваня"
$clientsList->del('ivan'); //удаляем клиента
$clientsList->add(new Client('Петр Иванович'), 'petr'); /*перехват исключения, т.к. ключ "petr" уже используется
                                                          выведет -> Ключ "petr" уже используется. */
} catch (Exception $e) {
  echo $e->getMessage();
}

Добавляемую информацию, так же можно фильтровать. Я намеренно не стал этого делать, т.к. от приложения к приложению требования (а значит и фильтры) могут меняться. Все их можно добавить, расширив базовый класс ObjectsArr. Для примера, реализуем возможность добавления только объектов в коллекцию:

class MyObjectsArr extends ObjectsArr {
  public function add(object $value, $key = null) {
    parent::add($value, $key);
  }
}

Или

class MyObjectsArr extends ObjectsArr {
  public function add($value, $key = null) {
    if (!is_object($value))
      throw new Exception('Добавляемый элемент не является объектом.');

    parent::add($value, $key);
  }
}

Итак, класс ObjectsArr функционирует и отвечает нашему первому требованию:

предоставление механизма добавления, удаления и извлечения элементов

Использовать класс в таком виде, в каком он представлен сейчас — неудобно. Связано это с тем что мы не реализовали все требования предъявленные к нему.

В следующий статьях мы продолжим наращивать его функциональность.

JSON — компактный текстовый формат данных. Может применяться как в интернет-службах передачи данных, так и для хранения информации в структурированном виде.

Описание JSON из википедии:

JSON (англ. JavaScript Object Notation) — текстовый формат обмена данными, основанный на JavaScript и обычно используемый именно с этим языком. Как и многие другие текстовые форматы, JSON легко читается людьми.

Несмотря на происхождение от JavaScript (точнее, от подмножества языка стандарта ECMA-262 1999 года), формат считается языконезависимым и может использоваться практически с любым языком программирования. Для многих языков существует готовый код для создания и обработки данных в формате JSON.

Практическая польза использования JSON открывается при использовании технологии AJAX. Формат JSON является более кратким и удобочитаемым по сравнению с XML, является «родным» для Javascript. Кроме того, в JSON-код возможна вставка вполне работоспособных функций.

Да, именно в технологии AJAX, на мой взгляд, его основное применение. Так как технология AJAX подразумевает отправку запроса клиентов на сервер. Далее на сервере запрос обрабатывается, и результат отправляется в ответ клиенту.

Вид данных в формате JSON

JSON поддерживает все основные форматы данных: строки, числа, булевые значения, а так же массивы и объекты (комбинации ключ: значение, разделенные запятыми и заключающимися в фигурные скобки).

Приведем пример представления данных в формате JSON:

{"id":"1","name":"ivan","country":"Russia","office":["yandex","management"]}

Давайте разберем, что этой строкой можно передать: человек с именем «ivan», под идентификатором «1», проживающий в стране «Russia» работает в компании «yandex» в отделе «management».

Приведем еще один пример. На сайте имеется форма обратной связи, работающая по технологии AJAX. Посетитель заполняет информацию, далее она отправляется на сервер для проверки, если ошибок не найдено, информация сохраняется в базу данных и отправляется ответ об успешном сохранении. Но если найдены ошибки, то возвращается ответ с типами ошибок.

Пример ответа об ошибке в формате JSON:

{"error":"1","errorcode":["empty_pers","empty_mail","empty_phone","empty_letter","empty_scode"]}

Что, к примеру, означает:

• Необходимо заполнить поле «Контактное лицо»
• Необходимо заполнить поле «E-mail»
• Необходимо заполнить поле «Телефон»
• Введите текст сообщения
• Необходимо заполнить поле «Число на картинке»

В случае, если ошибок нет, то возвращается ответ:

{"error":"0"}

Что говорит об успешной отправке данных.

В PHP, для представления данных в формате JSON служит расширение JSON extension. В версиях PHP старше 5.2.0 поддержка JSON встроена в ядро, в более ранних версиях необходимо подключать к вашему скрипту дополнительный файл с функциями.

Итак в PHP, за работу с данными в формате JSON отвечают две функции: json_encode() и json_decode().

Конвертация данных в формат JSON

$json_data = array ('id'=>1,'name'=>"ivan",'country'=>'Russia',"office"=>array("yandex"," management"));
echo json_encode($json_data);

Обратное преобразование данных из формата JSON

$json_string='{"id":1,"name":"ivan","country":"Russia","office":["yandex"," management"]} ';
$obj=json_decode($json_string);

Теперь в $obj будут содержаться JSON данные переведенные в PHP-объект, доступ к которым вы сможете получить следующим образом:

echo $obj->name; //Отобразит имя ivan
echo $obj->office[0]; //Отобразит компанию yandex

Как видите, $obj->office является массивом.

foreach($obj->office as $val)
  echo $val;

Работа с JSON позволяет обмениваться с сервером данными в «чистом виде». Полностью отпадает необходимость пересылать громоздкие куски HTML кода.

Этот метод актуален только для объектно-ориентированного стиля программирования, и будет работать в версии PHP 5.1.2 и выше.

Давайте рассмотрим пример. Имеем два файла:

Файл example.php:

<?php
class example {
  static  function call() {
    echo  'You call "' . __CLASS__ . '" class.';
  }
}
?>

Файл index.php:

<?php
  include 'example.php';
  example::call();
?>

Оба файла находятся в одной директории. В первом файле example.php объявлен класс example. Во втором файле мы подключаем example.php и вызываем метод call класса example. Метод call является статическим, поэтому нам не обязательно создавать экземпляр класса example для его вызова.

Результатом выполнения этого скрипта будет сообщение «You call "example" class.»

Для использования класса example, нам нужно было подгрузить соответствующий файл — example.php.

А теперь представьте, что классов у вас сотни, и вам нужно вручную каждый раз прописывать инклуды файлов с классами, чтобы все их использовать.

Давайте поступим проще! Напишем функцию, которая будет автоматически подгружать нужный нам файл с классом только тогда, когда мы начинаем использовать этот класс. То есть, если класс в ходе выполнения сценария не используется, то и подключать с ним файл нет необходимости.

Модифицируем предыдущий пример:

Файл autoload.php:

<?php
spl_autoload_register ('autoload');
function autoload ($className) {
  $fileName = $className . '.php';
  include  $fileName;
  }
?>

Файл example.php:

<?php
  class example {
  static  function call() {
  echo  'You call "' . __CLASS__ . '" class.';
  }
  }
?>

Файл index.php:

<?php
  include 'autoload.php';
  example::call();
?>

Мы добавили новый файл autoload.php и подгрузили его в index.php. Обратите внимание — мы все также вызываем example::call(), и вместо «Fatal error: Class "example" not found in …» получаем прежний результат — «You call "example" class.». Даже без ручной подгрузки файла example.php, класс example нашелся и его метод вызвался. Как так получилось?

PHP позволяет задать обработчик (функцию или метод класса) который будет вызываться всякий раз при обращении к классу, который еще не определен. Аргументом функции-обработчика является имя вызываемого класса. Обработчик мы определяем с помощью функции spl_autoload_register(). Если в качестве обработчика выступает функция, то аргументом spl_autoload_register() будет являться строка с именем функции (как в примере). Если же в качестве обработчика выступает метод класса, то аргументом spl_autoload_register() будет являться массив, первый элемент которого соответствует названию класса, а второй названию метода этого класса — spl_autoload_register(array('someoneClass', 'someoneMethod')). Метод-обработчик должен быть статическим.

В нашем примере, в качестве обработчика я использовал функцию autoload(). К имени вызываемого класса она добавляет расширение «.php» и пытается подгрузить файл <class>.php, где <class> — имя вызываемого класса.

Мы привели простой пример, чтобы вы поняли, как работает метод автоматической подгрузки файлов с классами, в следующий раз покажем реальное применение, где это может использоваться.

PHP — хороший язык, но в нем всегда полно сюрпризов. И сегодня я увидел интересную статью в блоге Арнольда Дэниэлса. Он рассуждает о «временных переменных» в РНР. Этот прием полезен для «ленивых» разработчиков, которые даже не задумываются о названиях переменных. Они предпочитают такое наименование, как «${0}» и «0» — ведь это хорошее название для переменной, почему нет…

Но я уверен, что когда нет переменной, нет и проблемы. Поэтому приведу несколько приемов, которые делают Ваш код короче и труднее для восприятия :)

1. Используйте || (или) и && (и) вместо if

   Много кода:

   $status = fwrite($h, 'some text');
   if(!$status) {
       log('Writing failed');
   }

   Меньше кода:

   ${0} = fwrite($h, 'some text');
   if(!${0}) log('Writing failed');

   Еще меньше кода:

   fwrite($h, 'some text') or log('Writing failed');

2. Используйте «тернарный оператор»

   Много кода:

   if($age < 16) {
       $message = 'Welcome!';
   }
   else {
     $message = 'You are too old!';
   }

   Меньше кода:

   $message = 'You are too old!';
   if($age < 16) {
       $message = 'Welcome!';
   }

   Еще меньше кода:

   $message = ($age < 16) ? 'Welcome!' : 'You are too old!';

3. Используйте «for» вместо «while»

   Много кода:

   $i = 0;
   while($i < 100) {
     $source[] = $target[$i];
     $i += 2;
   }

   Меньше кода:

   for($i = 0; $i < 100; $source[] = $target[$i+=2]);

4. В некоторых случаях PHP требует от вас создания переменной. Например, при получении массива элементов, когда массив возвращается функцией:

   $ext = pathinfo('file.png')['extension'];

   Результат: Parse error: syntax error, unexpected ’[' in … on line …

   Чтобы справиться с этими ситуациями Вы можете создать несколько небольших функций для быстрого вызова часто используемых операций:

   // Возвращает ссылку на создаваемый объект
   function &r($v) {
   	return $v;
   }
   
   // Возвращает сдвиг массива
   function &a(&$a, $i) {
   	return $a[$i];
   }
   

5. Исследуйте язык, который используете

   PHP — очень мощный язык и содержит множество функций и интересных аспектов, которые могут сделать Ваш код рациональнее и короче.

6. Пишите комментарии

   В тех случаях, когда лучше написать больше кода и потом легко его читать, не ленитесь. Потратьте на пару секунд больше и напишите комментарий и более читаемую структуру. Это единственный прием из списка, который действительно может помочь сэкономить часы, а не минуты.

Класс DOMDocument в PHP позволяет обращаться к XML файлам и данным в XML формате, а так же создавать их. Он имеет ряд методов, которые будут нам полезны при создании Sitemap.XML.

Данный метод полностью основан на ООП, что позволяет легко улучшить или изменить для себя исходный код.

Данная статья посвящена именно генерации Sitemap.XML с помощью DOMDocument. Описание, что это такое вы можете найти на официальном сайте.

Наша группа занималась разработкой портала «VLG Navigator», представляющего собой Каталог организаций Волгограда с позиционированием на карте города.

Передо мной стояла задача – организовать возможность создавать Sitemap.XML из административного интерфейса. Все объекты в каталоге размещались администратором и, допустим, после добавления порядка 30 объектов в каталог необходимо было как можно быстрее оповестить о них поисковые системы.

В моем случае, каждый узел с URL в карте сайта был следующего типа:

<url>
  <loc>http://www.vlg-nav.ru/</loc>
  <lastmod>2008-07-24</lastmod>
  <changefreq>daily</changefreq>
  <priority>1.0</priority>
</url>

Каждый из узлов URL я решил хранить в соответствующем объекте. Для этого был написан класс SitemapUrl:

class SitemapUrl{

  private $loc;
  private $lastmod;
  private $changefreq;
  private $priority;

  final function __construct($loc,$lastmod,$changefreq,$priority){

    $this->loc = $loc;
    unset ($loc);

    $this->lastmod = $lastmod;
    unset ($lastmod);

    $this->changefreq = $changefreq;
    unset ($changefreq);

    $this->priority = $priority;
    unset ($priority);

  }

  final function getLoc(){
    return $this->loc;
  }

  final function getLastmod(){
    return $this->lastmod;
  }

  final function getChangefreq(){
    return $this->changefreq;
  }

  final function getPriority(){
    return $this->priority;
  }
}

Таким образом, в переменных $this->loc, $this->lastmod, $this->changefreq, $this->priority хранятся соответствующие значения элементов конкретного узла карты сайта.

Допустим в карту сайта Sitemap.XML нам необходимо сохранить URL http://www.webpp.ru, с датой 2008-07-08, приоритетностью 1.0 и ежедневной частотой обновления. Создадим объект класса SitemapUrl:

<?php
$webpp = new SitemapUrl ('http://www.webpp.ru','2008-07-08','daily','1.0');
// Так мы создали объект $webpp класса SitemapUrl с необходимыми нам аргументами.
// В $webpp->loc хранится значения для  <loc>.
// В $webpp->lastmod хранится значения для  <lastmod>.
// В $webpp->changefreq хранится значения для  <changefreq>.
// В $webpp->priority хранится значения для  <priority>.
?>

Почемы я выбрал храненение значений в объектах, а не ,скажем, в массиве? Поясню на практике.

Допустим источником данных для построения карты сайта является некая база данных, в которой значение даты, необходимое нам в построении карты сайта хранится в собственном формате (формате базы данных). Нам нужно организовать преобразование, из формата базы данных в необходимый нам.

Хорошо, если генерация объектов происходит в одном месте, в этом случае мы можем на уровне выборки данных из БД преобразовать их в нужный нам формат каким-либо алгоритмом. А если точек генерации объектов десятки или сотни? Тогда нам нужно всех их пройти и внести в код заполнения наш алгоритм?

Поступим проще! Воспользуемся конструктором нашего класса function __construct.

Конструктор класса вызывается при объявлении объекта этого класса. В него помещают код, который нужно выполнить сразу же, как только объект был создан. В версиях PHP ниже 5й, чтобы объявить конструктор класса, функцию класса должна иметь одинаковое с классом название. В Версиях PHP 5 и выше конструктор объявляется функцией __construct(). Так же существует и деструктор класса — __destruct(), который выполняется перед уничтожением объекта класса.

Поместим в конструктор нашего класса алгоритм преобразования над датой:

  final function __construct($loc,$lastmod,$changefreq,$priority){

    $this->loc = $loc;
    unset ($loc);

    // Допустим функция algoritm($lastmod) производит преобразование
    // даты из формата БД в нужный нам формат.
    $this->lastmod = algoritm($lastmod);
    unset ($lastmod);
    // Теперь значение даты будет храниться в таком виде, в каком нам нужно.

    $this->changefreq = $changefreq;
    unset ($changefreq);

    $this->priority = $priority;
    unset ($priority);

  }

Добавив один раз в конструкторе класса SitemapUrl преобразование даты, мы автоматически организовали преобразование во всех точках создания объектов этого класса.

Теперь собственно нужно получить списки URL и параметры для них, и организовать для них хранение в объектах класса SitemapUrl.

Напишем еще один класс SiteMapUrlGenerator ,содержащий в себе логику, по которой будут извлекаться списки URL, и все параметры для них, и сохраняться в массив объектов класса SitemapUrl.

Если Вы захотите переписать мой скрипт под свои нужды, то редактировать Вам нужно будет только этот класс. В моем случае он содержит набор статических страниц, которые так же должны присутствовать в карте сайта, но по тем или иным причинам отсутствуют в базе данных. Т.е. если мнеизвестны страницы, которых нет в БД, но они мне также нужны, я просто укажу их руками.

Так как в нашем проекте нужно было создать карты сайта только для каталога организаций и для объявлений, то я заточил этот класс именно под эти нужды. Повторюсь, для своих проектов Вам нужно будет переписать данный класс.

class SiteMapUrlGenerator {

  //Приоритетность URL каждого объявления
  private $ad_priority = '0.8';

  //Периодичность посещения поисковой системой URL объявления
  private $ad_changefreq = 'weekly';

  //Приоритетность URL каждого объекта каталога
  private $cat_priority = '0.9';

  //Периодичность посещения поисковой системой URL объектов каталога
  private $cat_changefreq = 'weekly';

 /*
  Я храню эти значения в открытом виде, так сказать "по умолчанию", так как в нашем проекте не предусмотрена логика вычислений данных значений.
  В вашем случая ничего не мешает вместо статических значений подставить результат выполнения какого-либо собственного алгоритма.
*/

  var $urlList = array(); //Массив объектов, в котором будут
  //храниться все экземпляры класса SitemapURL

  var $db_conn; // Сюда будет создаваться объект написанного нами класса
  // для работы с БД. В вашем случае он может быть не обязательным.

  final function __construct() {

    $this->db_conn = $GLOBALS['db_conn']; //Объявляем класс для работы с БД

    // Ниже вставляем в массив $this->urlList все нужные нам на карте сайта
    // статические URL.

    $this->urlList[] = new SitemapUrl ('http://'.$_SERVER['HTTP_HOST'].'/',
                                      '2008-07-24',
                                      'daily',
                                      '1.0');

    $this->urlList[] = new SitemapUrl ('http://'.$_SERVER['HTTP_HOST'].'/ad/',
                                      '2008-07-20',
                                      'daily',
                                      '0.7');

    $this->urlList[] = new SitemapUrl ('http://'.$_SERVER['HTTP_HOST'].'/cat/',
                                      '2008-07-20',
                                      'daily',
                                      '0.7');

    $this->urlList[] = new SitemapUrl ('http://'.$_SERVER['HTTP_HOST'].
                                      '/contact/',
                                      '2008-07-20',
                                      'weekly',
                                      '0.5');

    $this->urlList[] = new SitemapUrl ('http://'.$_SERVER['HTTP_HOST'].
                                      '/advertising/',
                                      '2008-07-20',
                                      'weekly',
                                      '0.5');

    $this->urlList[] = new SitemapUrl ('http://'.$_SERVER['HTTP_HOST'].'/map/',
                                      '2008-07-20',
                                      'never',
                                      '0.6');
  }

  final function getUrls() {

    $this->getCatUrlList();
    $this->getAdUrlList();

    return $this->urlList;

  }

  final function getAdUrlList() {
    // Данння функция получает из БД все ссылки объектов каталога объявлений
    // не буду вдаваться в ее описание, так как оно не имеет значения.
    // Главное получить нужные нам URL, а каким способом неважно.

    //Объявляем шаблон по которому будет строиться строиться URL объявлений.
    $shablon = 'http://'.$_SERVER['HTTP_HOST'].'/ad/';

    $ads = $this->db_conn->SelAll('ad_records','`id`,`post_date`');

    if($ads) {
      foreach($ads as $ad) {
        // Выполняем заполнение массива объектов класса SitemapUrl
        // его экземплярами, сгенерированными для каталога объявлений.

        $this->urlList[] = new SitemapUrl ($shablon.$ad['id'].'/',
        $ad['post_date'],
        $this->ad_changefreq,
        $this->ad_priority);
      }
    }

  }

  final function getCatUrlList() {
   // Данная функция получает из БД все ссылки объектов каталога организаций
   // не буду вдаваться в ее описание, так как оно не имеет значения.
   // Главное получить нужные нам URL, а каким способом неважно.

  //Объявляем шаблон по которому будет строиться URL каталога организаций.
    $shablon = 'http://'.$_SERVER['HTTP_HOST'].'/cat/'; 

    $query = "SELECT `icons_info`.`icon_id`,`icons_info`.`edit_date`";
    $query.= " FROM `icons_info`";

    $cats = $this->db_conn->SelQuery($query);

    if($cats) {
      foreach($cats as $record) {
        // Выполняем заполнение массива объектов класса SitemapUrl
        // его экземплярами, сгенерированными для каталога организаций.

        $this->urlList[] = new SitemapUrl ($shablon.$record['icon_id'].'/',
        $record['edit_date'],
        $this->cat_changefreq,
        $this->cat_priority);
      }
    }

  }

}

Абсолютно все URL хранятся в объектах класса SitemapUrl и хранятся в одном массиве $this->urlList .

Думаю понять как работает данный класс и написать свой подобный труда не составит. Главной генерировать нужные Вам URL и записывать их объекты класса SitemapURL. И вернуть в виде массива объектов.

Ну и осталось написать самый главный класс, который будет все это собирать в кучу и выдавать XML файл карты сайта.

class Sitemap {

  //Нужно пинговать поисковики или нет.
  var $needPing = False;

  // Флаг, существует ли файл sitemap.xml или нет
  private $XMLsitemapExist = False;

  // Относительный путь до XML файла карты сайта.
  private $XMLsitemapSaveFile = '../sitemap.xml';

  // Флаг, существует ли файл sitemap.txt или нет
  private $TXTsitemapExist = False;

  // Относительный путь до TXT файла карты сайта.
  private $TXTsitemapSaveFile = '../sitemap.txt';

  // Сюда будет происходить сохранение списка URL для
  // текстовой версии карты сайта
  private $TXTsitemapDump;

  // Сюда будем записывать массив объектов с URL для XML версии
  private $urlList;

  // Адрес, по которому пинговать Google, что карта сайта обновилась
  private $googlePingUrl;

  // Адрес, по которому пинговать Yahoo, что карта сайта обновилась
  private $yahooPingUrl;

  // Хранится полный URL до файла sitemap.xml
  private $sitemapFile;

  // Сюда будем создавать экземпляр класса DOMDocument
  private $dom;

  final function generate() {
    /*
    Главный метод класса Sitemap. Собвственно он и
    выполняет генерацию карты сайта с помощью DOMDocument.
    */

    // Так как объект класса DOMDocument у нас уже объявлен, а с ним и корневой
    // элемент <xml>, то создаем дочерний элемент <urlset>
    $root = $this->dom->appendChild($this->dom->createElement('urlset'));

    // Добавляем необходимые атрибуты.
    $root->setAttribute('xmlns','http://www.sitemaps.org/schemas/sitemap/0.9');
    $root->setAttribute('xmlns:xsi','http://www.w3.org/2001/XMLSchema-instance');
    $root->setAttribute('xsi:schemaLocation',
              'http://www.sitemaps.org/schemas/sitemap/0.9'.' '.
              'http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd');

    // Запускаем генерацию массива объектов типа SitemapUrl
    $SiteMapUrlGenerator = new SiteMapUrlGenerator;
    $this->urlList = $SiteMapUrlGenerator->getUrls();

    // Очищаем память, так как массив был успешно создан
    // и более объект не требуется.
    unset($SiteMapUrlGenerator);

    // Перебираем значения полученного массива и формируем XML
    for($i=0;$i<sizeof($this->urlList);$i++) {

     // Создаем узел <url>
      $url = $root->appendChild($this->dom->createElement('url'));

      // Создаем дочерний узел <loc> и заполняем его информацией.
      $url->appendChild($this->dom->createElement('loc',
                                    $this->urlList[$i]->getLoc()));

      // Создаем дочерний узел <lastmod> и заполняем его информацией.
      $url->appendChild($this->dom->createElement('lastmod',
                                    $this->urlList[$i]->getLastmod()));

      // Создаем дочерний узел <changefreq> и заполняем его информацией.
      $url->appendChild($this->dom->createElement('changefreq',
                                    $this->urlList[$i]->getChangefreq()));

      // Создаем дочерний узел <priority> и заполняем его информацией.
      $url->appendChild($this->dom->createElement('priority',
                                    $this->urlList[$i]->getPriority()));

      // Так же создаем список URL для текстовой версии карты сайта.
      $this->TXTsitemapDump .= $this->urlList[$i]->getLoc()."\n";

    }

    // Если файл sitemap.xml существует, то удаляем его.
    if($this->XMLsitemapExist) {
      unlink($this->XMLsitemapSaveFile);
    }

    // Сохраняем сгенерированные XML данные в файл sitemap.xml
    $this->dom->save($this->XMLsitemapSaveFile);

    // Сохраняем сгенерированные TXT данные в файл sitemap.txt
    // Если файл sitemap.txt существует, он будет удален и создан новый.
    fwrite(fopen($this->TXTsitemapSaveFile,"w-", $this->TXTsitemapDump);

    // Если требуется пинговка поисковиков, то выполняем.
    if($this->needPing) {
      $this->pingGoogle();
      $this->pingYahoo();
    }
  }

  final function pingGoogle() {

    //Метод, выполняющий пинг Google, о том, что карта сайта обновилась
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $this->googlePingUrl);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    $result = curl_exec($ch);
  }

  final function pingYahoo() {

    //Метод, выполняющий пинг Yahoo, о том, что карта сайта обновилась
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $this->yahooPingUrl);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    $result = curl_exec($ch);
 }

  final function __construct() {
    // Производим инициализацию объектов. Объявляем переменные окружения класса.

    // Объявляем URL до файла sitemap.xml
    $this->XMLsitemapFile = 'http://'.$_SERVER['HTTP_HOST'].'/sitemap.xml';

    // Объявляем URL по которому пинговать Google
    $this->googlePingUrl = 'http://www.google.com/webmasters/sitemaps/'.
                           'ping?sitemap=';
    $this->googlePingUrl .= urlencode($this->XMLsitemapFile);

    // Объявляем URL по которому пинговать Yahoo
    $this->yahooPingUrl = 'http://search.yahooapis.com/SiteExplorerService/V1/'.
                          'ping?sitemap=';
    $this->yahooPingUrl .= .urlencode($this->XMLsitemapFile);

    // Создаем объект класса DOMDocument
    $this->dom = new DOMDocument('1.0','UTF-8');
    $this->dom->formatOutput = true;

    // Так, на всякий случай
    $this->TXTsitemapDump = '';

    // Проверяем, существует ли уже файл sitemap.xml
    $this->XMLsitemapExist = file_exists($this->XMLsitemapFile);

    // Проверяем, существует ли уже файл sitemap.txt
    $this->TXTsitemapExist = file_exists($this->TXTsitemapSaveFile);
  }

}

Вот собственно и все, старался ясно описывать все действия в комментариях, но повторюсь еще раз.

Итак, мы объявили наш класс Sitemap. Из чего он состоит? Первоначально мы создаем внутренние переменные класса, которые будут использоваться в нем, такие как флаги, существуют ли уже файлы карты сайта или нет. Адреса пинга поисковиков Google и Yahoo. Полный путь до файлов карты сайта. URL адрес файла sitemap.xml. И прочие необходимые нам переменные.

Далее они инициализируются в конструкторе класса. Так же в конструкторе класса происходит создание объекта класса DOMDocument, через который мы будем производить все манипуляции с XML данными.

Методы pingGoogle() и pingYahoo() поизводят пинг поисковых систем, о том, что карта сайта обновилась. Эти методы работают через библиотеку curl которая должна быть подключена в PHP.

Ну и основной метод generate(). Он и управляет самой генерацией карты сайта Sitemap.XML и TXT версии. Порядок, в котором работает данный метод описан в комментариях к коду.

Теперь осталось только создать объект класса Sitemap и вызвать генерацию XML карты сайта. Вместе с ней создастся и TXT версия.

$sitemap = new Sitemap;
$sitemap->generate();

Все, готово! Таким образом мы получили нужную нам карту сайта со всеми выбранными URL.

Прошу прощения за возможно корявые подходы, вроде наращивания строк, где казалось бы можно было без этого обойтись. Сделано это для того, чтобы код корректно отображался в браузерах, т.к. слишком длинные строки выходят за рамки поля для контента.

Надеюсь, что Вы найдете эту статью полезной, и будете применять описанный мной метод в своих проектах. Повторюсь, для затачивания его под себя, нужно переписать только класс выборки данных для URL адресов, а именно SiteMapUrlGenerator. Все остальное можно оставить без изменений.

Скомпонованный готовый скрипт можно скачать здесь.

Когда это может понадобиться? Допустим у Вас имеется каталог объявлений, в котором каждый час появляются новые, соответственно, каждое из объявлений имеет уникальный URL-адрес, который побыстрее нужно сообщить поисковой системе посредством карты сайта. Или же для Вас важна динамическая генерация как «sitemap.xml» так и карты текстовой (TXT) карты сайта, содержащей просто список всех URL.

Решить данную задачу можно с помощью модуля «mod_rewrite» сервера «Apache». Требуется создать правила, которые будут при каждом обращении к файлам «sitemap.xml» или «sitemap.txt» запускать PHP-скрипт, передавая параметры, какую из карт запросили. PHP-скрипт в свою очередь соберет необходимые данные и создаст требуемую карту сайта.

Добавьте в файл «.htaccess» следующие строки:

RewriteRule ^sitemap.xml$ /sitemap.php?type=xml [L]
RewriteRule ^sitemap.txt$ /sitemap.php?type=txt [L]

Эти два правила осуществляют подмену запросов к файлу карты сайта формата «xml» (sitemap.xml) и к файлу карты сайта формата «txt» (sitemap.txt).

Подмена происходит следующим образом: как только пользователь или поисковая система запросили файл «sitemap.xml», срабатывает правило, которое отсылает запрос скрипту «sitemap.php» с параметром «type=xml». Скрипт генерирует карту сайта, с помощью какой-либо своей собственной логики и выдает ее с помощью функции «echo».

Т.е. обратившись например по адресу http://localhost/sitemap.xml, на самом деле Вы получаете результат работы скрипта «sitemap.php».

Аналогично происходит и для текстовой версии карты сайта.

В скрипте «sitemap.php» необходимо проверить значение элемента «type» суперглобального массива «$_GET»:

switch ($_GET['type']){
  case 'xml':
    //Выполняем генерацию XML версии карты сайта.
    //Лучше написать и вызвать в этом месте соответствующую функцию.
  break;

  case 'txt':
    //Выполняем генерацию TXT версии карты сайта.
    //Лучше написать и вызвать в этом месте соответствующую функцию.
  break;

  default:
    echo 'Генератор поисковых карт сайта.';
    echo 'Заходите на www.codeisart.ru';
}

Преимущества

• карта сайта содержит самые последние URL на момент обращения;
• легко можно добавить статические элементы в набор URL карты сайта.

Недостатки

• при большом количестве URL на сайте, генерация карты может оказаться достаточно длительным и ресурсоемким процессом.

Подобным образом можно перехватывать обращения к любым файлам на сервере. Особенно это может быть актуально для файла «robots.txt».

Лично я сам не пользуюсь данным методом, т.к. он создает большую нагрузку на сервер, но может быть Вам материал этой статьи когда-нибудь пригодится.

В ближайшем будущем опубликую статью, в которой постараюсь описать объектно-ориентированный метод генерации карт (как XML-версию, так и TXT) сайта с использованием «DOMDocument» в PHP.