function userRegistration(array $data) : array
            {
                // ................

                $dbh = dbConnect();

                // Создаем тело SQL-запроса
                $stmt = $dbh->prepare("INSERT INTO `users` (`login`, `email`, `password`) VALUES (:login, :email, :password)");

                /**
                * Согласно документации к PHP, мы для подготовки пароля пользователя к сохранению в БД
                * будем использовать функцию password_hash() https://www.php.net/manual/ru/function.password-hash
                * Причем, согласно рекомендации, начиная с версии PHP 8.0.0 не нужно указывать соль для пароля. Значит, и не будем
                */
                // Хэшируем пароль
                $sPassword = password_hash($sPassword, PASSWORD_BCRYPT);

                // Подготавливаем запрос
                $stmt->bindParam(':login', $sLogin);
                $stmt->bindParam(':email', $sEmail);
                $stmt->bindParam(':password', $sPassword);

                // Выполняем запрос
                $stmt->execute();

                // ....................
            }
        
    

Да, сейчас не очевидно, что же такого мы получили в виде выгоды, написав такую реализацию. Но это именно пока. В тот момент, пока мы говорим лишь о регистрации и авторизации. К тому же, сам класс PDO в PHP значительно упрощает взаимодействие с СУБД.

Очевидно, что изменения произошли и в классах Core_Database и Core_Database_Pdo. Посмотрим на них сейчас.

6. Классы Core_Database и Core_Database_Pdo

    
        <?php
        // Запрещаем прямой доступ к файлу
        defined('MYSITE') || exit('Прямой доступ к файлу запрещен');

        /**
        * Абстраактый класс
        * Обеспечивает подключение к СУБД
        * Класс является абстрактным, так как оставляет пользователю право определять, через какой
        * модуль будет реализовано взаимодействие с СУБД
        * 
        * Реализация такого взаимодействия должна быть написана в дочерних классах
        * Например, вызов Core_Database::instance('mysql') вернет экземпляр класса Core_Database_Mysql
        */
        abstract class Core_DataBase
        {
            // Экземпляр класса
            static protected $_instance = [];

            // Параметры подключение к СУБД
            protected $_config = [];

            // Здесь будет храниться последний выполненный запрос к БД
            protected $_lastQuery = NULL;

            /**
            * Подключение к СУБД
            * @var resource
            */
            protected $_connection = NULL;

            /**
            * Число строк в результате запросе
            * @var int
            */
            protected $_lastQueryRows = NULL;

            /**
            * Перечень полей для запроса SELECT
            * @var array
            */
            protected $_select = [];

            /**
            * Имя таблицы для запроса SELECT
            * @var string
            */
            protected $_from = NULL;
            
            /**
            * Перечень полей для запроса INSERT
            * @var array
            */
            protected $_fields = [];
            
            /**
            * Перечень значений для запроса INSERT
            * @var array
            */
            protected $_values = [];

            /**
            * Имя таблицы для запроса INSERT
            * @var string
            */
            protected $_tableName = NULL;

            /**
            * Перечень условий для оператора WHERE
            * @var array
            */
            protected $_where = [];
            
            /**
            * Тип SQL-запроса:
            * 0 - SELECT
            * 1 - INSERT
            * 2 - UPDATE
            * 3 - DELETE
            */
            protected $_queryType = NULL;
            
            /** Абстрактные методы не имеют реализации. Они должны быть реализованы в дочерних классах */

            // Подключение к СУБД
            abstract public function connect();

            // Отключение от СУБД
            abstract public function disconnect();

            // Установка кодировки соединения
            abstract public function setCharset($charset);

            // Экранирование данных
            abstract public function escape($unescapedString);

            // Представление результата в виде объекта
            abstract public function asObject();

            // Представление результата в виде ассоциативного массива
            abstract public function asAssoc();

            // Установка SQL-запроса
            abstract public function query($query);

            // Выполнение запроса
            abstract public function result();

            // Имена методов говорят сами за себя
            abstract function select();
            abstract function insert(string $tableName);
            abstract function from(string $from);
            abstract function fields();
            abstract function values();
            abstract function where(string $field, string $condition, $value);
            abstract function execute();
            abstract function lastInsertId();

            /**
            * Защищенный конструктор класса, который невозможно вызвать откуда-либо, кроме как из самого класса
            * Получает параметры подключения к СУБД
            */
            protected function __construct(array $config)
            {
                $this->setConfig($config);
            }

            /**
            * Возвращает и при необходимости создает экзепляр класса
            * @return object Core_Database
            */
            static public function instance(string $name = 'pdo')
            {
                // Если экземпляр класса не был создан
                if (empty(static::$_instance[$name]))
                {
                    // Получаем параметры подключения к СУБД
                    $aConfig = Core::$config->get('core_database', array());
                    
                    if (!isset($aConfig[$name]))
                    {
                        throw new Exception('Для запрошенного типа подключения к СУБД нет конфигурации');
                    }

                    // Определяем, какой именно класс будем использовать
                    // Он будет именоваться Core_Database_{$name}, например Core_Database_Pdo или Core_Database_Mysql
                    $driver = __CLASS__ . "_" . ucfirst($name);
                    
                    self::$_instance[$name] = new $driver($aConfig[$name]);
                }

                // Возвращем вызову экземпляр класса для работы с СУБД
                return static::$_instance[$name];
            }

            public function setConfig(array $config)
            {
                $this->_config = $config + [
                    'host' => 'localhost',
                    'user' => '',
                    'password' => '',
                    'dbname' => NULL,
                    'charset' => 'utf8'
                ];

                return $this;
            }

            /**
            * Получает перечень полей таблицы из БД
            * @param string $tableName имя таблицы
            * @param string $likeCondition значение для применения оператора LIKE
            * @return array
            */
            public function getColumnNames(string $tableName, string $likeCondition = NULL) : array
            {
                // Подключаемся к СУБД
                $this->connect();

                // Составляем строку запроса
                $sQuery = "SHOW COLUMNS FROM " . $this->quoteColumnNames($tableName);

                // Если есть значения для условия оператора LIKE
                if (!is_null($likeCondition))
                {
                    $sQuery .= ' LIKE ' . $this->quote($likeCondition);
                }

                // Выполняем запрос, результат получаем в виде ассоциативного массива
                $result = $this->query($sQuery)->asAssoc()->result();

                $return = [];
                
                // Собираем информацию о столбцах
                foreach ($result as $row)
                {
                    $column['name'] = $row['Field'];
                    $column['columntype'] = $row['Type'];
                    $column['null'] = ($row['Null'] == 'YES');
                    $column['key'] = $row['Key'];
                    $column['default'] = $row['Default'];
                    $column['extra'] = $row['Extra'];
                    
                    $return[$column['name']] = $column;
                }
                
                // Возвращаем вызову результат
                return $return;
            }

            /**
            * Экранирует имена полей или таблиц для применения в строке SQL-запроса
            * @param string $value
            * @return string
            */
            public function quoteColumnNames(string $value) : string
            {
                return preg_replace('/(?<=^|\.)(\w+)(?=$|\.)/ui', '`$1`', $value);
            }

            /**
            * Возвращает строку последнего выполненного запроса
            * @return string | NULL
            */
            public function getLastQuery()
            {
                return $this->_lastQuery;
            }

            /**
            * Возвращает число строк из последнего результата запроса
            */
            public function getRowCount()
            {
                return $this->_lastQueryRows;
            }

            /**
            * Устанавливает тип запроса SELECT, INSERT и т.п.
            * @param integer $queryType
            * @return object self
            */
            public function setQueryType(int $queryType)
            {
                $this->_queryType = $queryType;

                return $this;
            }

            /**
            * Возвращает тип запроса
            * @return integer
            */
            public function getQueryType()
            {
                return $this->_queryType;
            }
        }
        ?>
    

Файл снабжен обширными комментариями, которые должны донести суть описанного. Перейдем к классу Core_Database_Pdo.

    
        <?php
        // Запрещаем прямой доступ к файлу
        defined('MYSITE') || exit('Прямой доступ к файлу запрещен');

        class Core_Database_Pdo extends Core_DataBase
        {
            /** Результат выполнения запроса
            * @var resource | NULL
            */
            protected $_result = NULL;

            /**
            * Представление результата запроса в виде ассоциативного массива либо объекта
            */
            protected $_fetchType = PDO::FETCH_OBJ;

            /**
            * Возвращает активное подключение к СУБД
            * @return resource
            */
            public function getConnection()
            {
                $this->connect();

                return $this->_connection;
            }

            /**
            * Подключается к СУБД
            * @return boolean TRUE | FALSE
            */
            public function connect()
            {
                // Если подключение уже выполнено, ничего не делаем
                if ($this->_connection)
                {
                    return TRUE;
                }
                $this->_config += array(
                    'driverName' => 'mysql',
                    'attr' => array(
                        PDO::ATTR_PERSISTENT => FALSE
                    )
                );

                // Подключаемся к СУБД
                try {
                    // Адрес сервера может быть задан со значением порта
                    $aHost = explode(":", $this->_config['host']);
                    
                    // Формируем строку источника подключения к СУБД
                    $dsn = "{$this->_config['driverName']}:host={$aHost[0]}";

                    // Если был указан порт
                    !empty($aHost[1])
                        && $dsn .= ";port={$aHost[1]}";

                    // Указываем имя БД
                    !is_null($this->_config['dbname'])
                        && $dsn .= ";dbname={$this->_config['dbname']}";
                    
                    // Кодировка
                    $dsn .= ";charset={$this->_config['charset']}";

                    // Подключаемся, и сохраняем подключение в экземпляре класса
                    $this->_connection = new PDO(
                        $dsn,
                        $this->_config['user'],
                        $this->_config['password'],
                        $this->_config['attr']
                    );
                    
                    // В случае ошибок будет брошено исключение
                    $this->_connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                    
                }
                catch (PDOException $e)
                {
                    throw new Exception("<p><strong>Ошибка при подключении к СУБД:</strong> {$e->getMessage()}</p>");
                }
                
                // Если ничего плохого не произошло
                return TRUE;
            }
            
            /**
            * Закрывает соединение с СУБД
            * @return self
            */
            public function disconnect()
            {
                $this->_connection = NULL;

                return $this;
            }
            
            /**
            * Устанавливает кодировку соединения клиента и сервера
            * @param string $charset указанное наименование кодировки, которое примет СУБД
            */
            public function setCharset($charset)
            {
                $this->connect();

                $this->_connection->exec('SET NAMES ' . $this->quote($charset));

                return $this;
            }
            
            /**
            * Экранирование строки для использования в SQL-запросах
            * @param string $unescapedString неэкранированная строка
            * @return string Экранированная строка
            */
            public function escape($unescapedString) : string
            {
                $this->connect();

                $unescapedString = addcslashes(strval($unescapedString), "\000\032");

                return $this->_connection->quote($unescapedString);
            }

            /**
            * Возвращает результат работы метода PDO::quote()
            * @return string
            */
            public function quote(string $value) : string
            {
                return $this->_connection->quote($value);
            }

            /**
            * Возвращает идентификатор последней вставленной записи в БД, если такой имеется
            * @return integer|string|NULL
            */
            public function lastInsertId()
            {
                return $this->getConnection()->lastInsertId();
            }

            /**
            * Устанавливает строку запроса, который будет выполнен позднее
            * @param string $query
            * @return object self
            */
            public function query($query)
            {
                // Переданную строку запроса сохраняем, чтобы её потом можно было просмотреть
                $this->_lastQuery = $query;

                // По умолчанию устанавливаем, что результат запроса хотим получать в виде объекта
                $this->_fetchType = PDO::FETCH_OBJ;

                return $this;
            }

            /**
            * Устанавливает тип представления данных в результате запроса в виде объекта
            * @return object self
            */
            public function asObject()
            {
                $this->_fetchType = PDO::FETCH_OBJECT;

                return $this;
            }

            /**
            * Устанавливает тип представления данных в результате запроса в виде ассоциативного массива
            * @return object self
            */
            public function asAssoc()
            {
                $this->_fetchType = PDO::FETCH_ASSOC;

                return $this;
            }

            /**
            * Выполняет запрос SELECT, возвращает результат выполнения
            * @return object PDOStatement
            */
            public function result() : PDOStatement
            {
                // Результат выполнения запроса сохраняем внутри объекта
                $this->_result = $this->_connection->query($this->_lastQuery, $this->_fetchType);

                // Определяем количество строк в результате запроса, сохраняем внутри объекта
                $this->_lastQueryRows = $this->_result->rowCount();

                return $this->_result;
            }

            /**
            * Устанавливает перечень полей для запроса SELECT
            * @param string|array $data = "*"
            * @return object self
            */
            public function select($data = "*")
            {
                // Устанавливаем в объекте тип выполняемого запроса как SELECT
                $this->getQueryType() != 0 && $this->setQueryType(0);

                // Если методу не был передан перечень полей, очищаем все возможно установленные ранее поля
                if ($data == "*")
                {
                    $this->clearSelect();
                }

                // Сохраняем поля
                try {
                    // Если перечень полей был передан в виде строки
                    if (is_string($data))
                    {
                        // Добавляем их к массиву в объекте
                        $this->_select[] = $data;
                    }
                    // Если был передан массив, его нужно интерпретировать как указание имени поля и его псевдонима в запросе
                    elseif (is_array($data))
                    {
                        // Если в переданном массиве не два элемента, это ошибка
                        if (count($data) != 2)
                        {
                            throw new Exception("<p>При передаче массива в качестве аргумента методу " . __METHOD__ . "() число элементов этого массива должно быть равным двум</p>");
                        }
                        // Если элементы переданного массива не являются строками, это ошибка
                        elseif (!is_string($data[0]) || !is_string($data[1]))
                        {
                            throw new Exception("<p>При передаче массива в качестве аргумента методу " . __METHOD__ . "() его элементы должны быть строками</p>");
                        }
                        // Если ошибок нет, сохраняем поля в массиве внутри объекта
                        else
                        {
                            // Имена полей экранируем
                            $this->_select[] = $this->quoteColumnNames($data[0]) . " AS " . $this->quoteColumnNames($data[1]);
                        }
                    }
                }
                catch (Exception $e)
                {
                    print $e->getMessage();

                    die();
                }
                
                return $this;
            }

            /**
            * Очищает перечень полей для оператора SELECT
            * @return object self
            */
            public function clearSelect()
            {
                $this->_select = [];

                return $this;
            }

            /**
            * Устанавливает имя таблицы для оператора SELECT
            * @param string $from
            * @return object self
            */
            public function from(string $from)
            {
                try {

                    if (!is_string($from))
                    {
                        throw new Exception("<p>Методу " . __METHOD__ . "() нужно передать имя таблицы для запроса</p>");
                    }
                    
                    // Экранируем данные
                    $this->_from = $this->quoteColumnNames($from);
                }
                catch (Exception $e)
                {
                    print $e->getMessage();

                    die();
                }

                return $this;
            }

            /**
            * Сохраняет перечень условий для оператора WHERE в SQL-запросе
            * @param string $field
            * @param string $condition
            * @param string $value
            * @return object self
            */
            public function where(string $field, string $condition, $value)
            {
                try {
                    if (empty($field) || empty($condition))
                    {
                        throw new Exception("<p>Методу " . __METHOD__ . "() обязательно нужно передать значения имени поля и оператора сравнения</p>");
                    }

                    // Экранируем имена полей и значения, которые будут переданы оператору WHERE
                    $this->_where[] = $this->quoteColumnNames($field) . " " . $condition . " " . $this->_connection->quote($value);
                }
                catch (Exception $e)
                {
                    print $e->getMessage();

                    die();
                }

                return $this;
            }

            /**
            * Очищает массив условий отбора для оператора WHERE
            * @return object self
            */
            public function clearWhere()
            {
                $this->_where = [];

                return $this;
            }

            /**
            * Устанавливает имя таблицы для оператора INSERT
            * @param string $tableName
            * @return object self
            */
            public function insert(string $tableName)
            {
                // Экранируем имя таблицы
                $this->_tableName = $this->quoteColumnNames($tableName);

                // Устанавливаем тип запроса INSERT
                $this->_queryType = 1;

                return $this;
            }

            /**
            * Устанавливает перечень полей для оператора INSERT
            * @return object self
            */
            public function fields()
            {
                try {
                    // Если не было передано перечня полей
                    if (empty(func_get_args()))
                    {
                        throw new Exception("Метод " . __METHOD__ . "() нельзя вызывать без параметров. Нужно передать перечень полей либо в виде строки, либо в виде массива");
                    }

                    // Сохраняем перечень полей в переменную
                    $mFields = func_get_arg(0);

                    // Если передан массив
                    if (is_array($mFields))
                    {
                        // Просто сохраняем его
                        $this->_fields = $mFields;
                    }
                    // Если передана строка
                    elseif (is_string($mFields))
                    {
                        // Разбираем её, полученный массив сохраняем
                        $this->_fields = explode(',', $mFields);
                    }
                    // В ином случае будет ошибка
                    else
                    {
                        throw new Exception("Метод " . __METHOD__ . "() ожидает перечень полей либо в виде строки, либо в виде массива");
                    }
                }
                catch (Exception $e)
                {
                    print $e->getMessage();

                    die();
                }

                return $this;
            }

            /**
            * Устанавливает перечень значений, которые будут переданы оператору INSERT
            * @return object self
            */
            public function values()
            {
                try {
                    // Если значения не переданы, это ошибка
                    if (empty(func_get_args()))
                    {
                        throw new Exception("Метод " . __METHOD__ . "() нельзя вызывать без параметров. Нужно передать перечень значений либо в виде строки, либо в виде массива");
                    }

                    // Сохраняем переденные значения в переменную
                    $mValues = func_get_arg(0);

                    // Если был передан массив
                    if (is_array($mValues))
                    {
                        // Просто сохраняем его
                        $this->_values[] = $mValues;
                    }
                    // Если была передана строка
                    elseif (is_string($mValues))
                    {
                        // Разбираем её, полученный массив сохраняем в объекте
                        $this->_values[] = explode(',', $mValues);
                    }
                    // В ином случае будет ошибка
                    else
                    {
                        throw new Exception("Метод " . __METHOD__ . "() ожидает перечень значений либо в виде строки, либо в виде массива");
                    }
                }
                catch (Exception $e)
                {
                    print $e->getMessage();

                    die();
                }

                return $this;
            }

            /**
            * Выполняет SQL-запрос к СУБД
            */
            public function execute() : PDOStatement | NULL
            {
                // Результат запроса будет представлен в виде объекта
                $this->_fetchType = PDO::FETCH_OBJ;

                // Пустая строка для SQL-запроса
                $sQuery = "";

                // Строка оператора WHERE
                $sWhere = " WHERE ";

                // Сначала собираем строку для оператора WHERE
                foreach ($this->_where as $index => $sWhereRow)
                {
                    // Для каждого из сохраненного массива для оператора WHERE формируем строку
                    $sWhere .= (($index) ? " AND" : "") . " " . $sWhereRow;
                }

                // Создаем данные, которые вернем в ответ на вызов
                $return = NULL;

                // Пробуем выполнить запрос
                try {

                    // В зависимости от типа запроса
                    switch ($this->getQueryType())
                    {
                        // SELECT
                        case 0:
                            $sQuery .= "SELECT " . implode(", ", $this->_select) . " FROM {$this->_from}" . $sWhere;

                            $return = $this->query($sQuery)->result();
                        break;
                        
                        // INSERT
                        case 1:
                            /**
                            * Здесь мы воспользуемся механизмом подготовки запроса от PDO
                            * https://www.php.net/manual/ru/pdo.prepared-statements.php
                            */
                            $sPseudoValues = "(";
                            $sFields = "(";

                            foreach ($this->_fields as $index => $sField)
                            {
                                $sPseudoValues .= (($index) ? "," : "") . "?";
                                $sFields .= (($index) ? "," : "") . $this->quoteColumnNames($sField);
                            }

                            $sPseudoValues .= ")";
                            $sFields .= ")";

                            $sQuery .= "INSERT INTO " . $this->_tableName . " " . $sFields . " VALUES " . $sPseudoValues;

                            $stmt = $this->getConnection()->prepare($sQuery);
                            
                            foreach ($this->_values as $aValues)
                            {
                                for ($i = 1; $i <= count($aValues); ++$i)
                                {
                                    $stmt->bindParam($i, $aValues[$i - 1]);
                                }

                                $stmt->execute();
                            }

                            $return = $stmt;

                        break;
                    }
                    
                    // Сохраняем строку запроса в объекте
                    $this->_lastQuery = $sQuery;

                }
                catch (PDOException $e)
                {
                    throw new Exception($e->getMessage());
                }

                return $return;
            }
        }
        ?>
    

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

7. Авторизация пользователя через класс User

Класс User был немного дополнен. Отметим здесь лишь внесенные изменения

    
        <?php
        // Запрещаем прямой доступ к файлу
        defined('MYSITE') || exit('Прямой доступ к файлу запрещен');

        /**
        * Класс пользователя клиентского раздела сайта
        * Объект класса может создаваться как для существующих пользователей, так и для несуществующих с целью их регистрации
        */
        class User
        {
            // ..................
            
            /**
            * Результируйщий объект запроса к БД
            * @var stdClass|NULL
            */
            protected $_user = NULL;

            // ..................
            
            /**
            * Получает данные о пользователе сайте
            * @return mixed self|NULL
            */
            protected function _getUserData()
            {
                $return = NULL;
                
                // Если внутри объекта нет информации о пользователе, пробуем получить её из сессии
                if (is_null($this->_user))
                {
                    if (!empty($_SESSION['password']))
                    {
                        $sPassword = strval($_SESSION['password']);
                        $sValue = strval((!empty($_SESSION['email'])) ? $_SESSION['email'] : $_SESSION['login'] );

                        $stmt = $this->getByLoginOrEmail($sValue);
                        
                        if (!is_null($stmt))
                        {
                            $this->_user = $stmt->fetch();

                            $return = $this;
                        }
                    }
                }
                else
                {
                    $return = $this;
                }

                return $return;
            }

            // ..................

            /**
            * Получает информацию об авторизованном пользователе
            * @return mixed self | NULL если пользователь не авторизован
            */
            public function getCurrent()
            {
                $return = NULL;

                /**
                * Информация о пользователе, если он авторизован, хранится в сессии
                * Поэтому нужно просто проверить, имеется ли там нужная информация
                * Если в сессии её нет, значит пользователь не авторизован
                */
                (!empty($_SESSION['login']) 
                    && !empty($_SESSION['email']) 
                    && !empty($_SESSION['password']))
                        && $return = $this->_getUserData();
                
                // Возвращаем результат вызову
                return $return;
            }

            /**
            * Устанавливает в сесии параметры пользователя, прошедшего авторизацию
            * @return object self
            */
            public function setCurrent()
            {
                $_SESSION['login'] = $this->_user->login;
                $_SESSION['email'] = $this->_user->email;
                $_SESSION['password'] = $this->_user->password;

                return $this;
            }

            // ..................

            /**
            * Обрабатывает данные, которыми пользователь заполнил форму
            * @param array $post
            */
            public function processUserData(array $post)
            {
                // ..................

                // А вот электропочта и повтор пароля будут только в случае регистрации
                if ($bRegistrationUser)
                {
                    // ..................
                }
                // Если пользователь авторизуется
                else
                {
                    // Проверяем, не был ли пользователь ранее авторизован
                    if ($this->_checkCurrent($sLogin))
                    {
                        $aReturn['success'] = TRUE;
                        $aReturn['message'] = "Вы ранее уже авторизовались на сайте";
                    }
                    // Если авторизации не было
                    else 
                    {
                        // Если не передан пароль
                        if (empty($sPassword))
                        {
                            $aReturn['message'] = "Поле пароля не было заполнено";
                            $aReturn['data'] = $post;
                        }
                        else 
                        {
                            // Ищем соответствие переданной информации в БД
                            $stmt = $this->getByLoginOrEmail($sLogin);
                            
                            // Если были найдены записи
                            if (!is_null($stmt))
                            {
                                // Получаем объект с данными о пользователе
                                $oUser = $this->_user = Core_Database::instance()->result()->fetch();
                                
                                // Проверяем пароль пользователя
                                // Если хэш пароля совпадает
                                if ($this->checkPassword($sPassword, $oUser->password))
                                {
                                    // Авторизуем пользователя
                                    $this->setCurrent();

                                    $aReturn['success'] = TRUE;
                                    $aReturn['message'] = "Вы успешно авторизовались на сайте";
                                    $aReturn['data'] = $post;
                                    $aReturn['data']['user_id'] = $oUser->id;
                                }
                                else
                                {
                                    $aReturn['message'] = "Для учетной записи <strong>{$sLogin}</strong> указан неверный пароль";
                                    $aReturn['data'] = $post;
                                }
                            }
                        }
                    }
                }

                return $aReturn;
            }
            
            /**
            * Ищет в БД запись по переданному значению полей login или email
            * @param string $value
            * @return object PDOStatement|NULL
            */
            public function getByLoginOrEmail(string $value) : PDOStatement | NULL
            {
                // Определяем тип авторизации: по логину или адресу электропочты
                $sType = NULL;
                $sType = match($this->validateEmail($value)) {
                            TRUE => 'email',
                            FALSE => 'login'
                };

                // Выполняем запрос SELECT
                $oCore_Database = Core_Database::instance();
                $oCore_Database->select()
                    ->from('users')
                    ->where($sType, '=', $value)
                    ->where('deleted', '=', 0)
                    ->where('active', '=', 1);
                
                $stmt = $oCore_Database->execute();

                // Если такой пользователь есть в БД, вернем объект с результатом запроса
                return ($oCore_Database->getRowCount() > 0) ? $stmt : NULL;
            }

            /**
            * Проверяет пароль пользователя, совпадает ли он с хранимым в БД
            * @param string $password пароль пользователя
            * @param string $hash хэш пароля пользователя из БД
            * @return boolean TRUE|FALSE
            */
            public function checkPassword(string $password, string $hash) : bool
            {
                /**
                * Согласно документации к PHP, мы для подготовки пароля пользователя к сохранению в БД
                * мы использовали функцию password_hash() https://www.php.net/manual/ru/function.password-hash
                * Теперь для проверки пароля для авторизации нам нужно использовать функцию password_verify()
                * https://www.php.net/manual/ru/function.password-verify.php
                */
                return password_verify($password, $hash);
            }

            // ..................
        }
        ?>
    

Сессию теперь стартуем при инициализации ядра сайта. Для этого в конец метода Core::init() небольшой кусок кода

    
        <?php
        defined('MYSITE') || exit('Прямой доступ к файлу запрещен');

        class Core 
        {
            // ....................

            static public function init()
            {
                // ...............

                // Запускаем сессию
                if (session_status() !== PHP_SESSION_ACTIVE)
                {
                    session_start();
                }
            }

            // ....................
        }
        ?>
    

Теперь пользователь может и авторизоваться. У нас после авторизаии пользователь перенаправляется на стартовую страницу сайта /index.php. Давайте внесем в неё небольшие изменения относительно предыдущей версии.

    
        <?php
        // Подключаем файл с основными функциями
        require_once('bootstrap.php');

        // Создаем объект авторизованного пользователя
        $oCurrentUser = (new User())->getCurrent();
        ?>
        <!DOCTYPE html>
        <html lang="ru">
        <head>
            <meta charset="UTF-8">
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <title>Авторизация/регистрация. PHP+MySQL+JavaScript,jQuery</title>
            <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
            <script src="https://cdn.jsdelivr.net/npm/@popperjs/core@2.11.8/dist/umd/popper.min.js" integrity="sha384-I7E8VVD/ismYTF4hNIPjVp/Zjvgyol6VFvRkX/vR+Vc4jQkC+hVqc2pM8ODewa9r" crossorigin="anonymous"></script>
            <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.min.js" integrity="sha384-BBtl+eGJRgqQAUMxJ7pMwbEyER4l1g+O15P+16Ep7Q9Q+zqX6gSbd85u4mG4QzX+" crossorigin="anonymous"></script>
        </head>
        <body>
            <div class="container-md container-fluid">
                <h1 class="my-3">Добро пожаловать на сайт</h1>
                <p class="h6">
                    Вы зашли на сайт примера авторизации и регистрации пользователя. 
                </p>
                <p>
                    Сейчас вы <?php echo (!is_null($oCurrentUser)) ? "авторизованы" : "не авторизованы";?> на сайте. <br />
                    <?php
                    if (!is_null($oCurrentUser))
                    {
                        // Для вывода даты регистрации пользователя значение из формата TIMESTAMP, 
                        // в котором оно хранится в MySQL, нужно преобразовать
                        $oDateTime = new DateTime($oCurrentUser->registration_date);
                        
                        echo "<p>Ваш логин: <strong>" . $oCurrentUser->login . "</strong>.</p>";
                        echo "<p>Ваша электропочта: <strong>" . $oCurrentUser->email . "</strong>.</p>";
                        echo "<p>Вы зарегистрировались: <strong>" . $oDateTime->format("d.m.Y") . "</strong>.</p>";
                        echo "<p>Вы можете <a href='/users.php?action=exit'>выйти</a> из системы.</p>";
                    }
                    else
                    {
                        ?>
                        <p>На этом сайте вам доступно:</p>
                        <ul class="list-unstyled">
                            <li>
                                <a href="/users.php">Авторизация и регистрация</a>
                            </li>
                        </ul>
                        <?php
                    }
                    ?>
                </p> 
            </div>
        </body>
        </html>
    

Для авторизованных пользователей мы добавили вывод информации о email и дате регистрации. Для того, чтобы выражение вроде $oCurrentUser->email возвращало что-либо кроме NULL, нужно добавить реализацию магического метода User::__get(), заодно реализуем метод User::unsetCurrent(), ведь нам ещё нужно обеспечить возможность выхода из системы для пользователя.

    
        <?php
        // Запрещаем прямой доступ к файлу
        defined('MYSITE') || exit('Прямой доступ к файлу запрещен');

        /**
        * Класс пользователя клиентского раздела сайта
        * Объект класса может создаваться как для существующих пользователей, так и для несуществующих с целью их регистрации
        */
        class User
        {
            // .....................

            /**
            * Завершает сеанс пользователя в системе
            * @return object self
            */
            public function unsetCurrent()
            {
                // Уничтожение данных о пользователе в сессии
                unset($_SESSION['login']);
                unset($_SESSION['email']);
                unset($_SESSION['password']);

                // Обновляем страницу
                header("Refresh:0;"); die();

                return NULL;
            }

            // .....................

            /**
            * Магический метод для получения значения необъявленного свойства класса
            * Вернет значение из запрошенного поля таблицы, если оно разрешено в массиве $_allowedProperties
            * @return mixed string|NULL
            */
            public function __get(string $property) : string | NULL
            {
                return (in_array($property, $this->_allowedProperties) ? $this->_user->$property : NULL);
            }
        }
        ?>
    

После выхода из системы и очистки сессии, страница обновляется. Сеанс пользователя завершен.

Заключение

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

«Программируйте на уровне интерфейса, а не на уровне реализации.»

Опытный читатель же обратит внимание, и, возможно, даже, наберётся наглости написать в комментариях о том, что стиль конечно объектно-ориентированный, но с ним что-то не так. Реализация какая-то то ли незаконченная, то ли беcцелевая какая-то, что ли. Это так. Но это тема для следующих статей.

Таблица `users` с прошлой статьи у нас не менялась.

--
-- Структура таблицы `users`
--

CREATE TABLE `users` (
`id` int(10) UNSIGNED NOT NULL,
`login` char(16) NOT NULL,
`email` char(32) NOT NULL,
`password` char(255) NOT NULL,
`registration_date` timestamp NOT NULL DEFAULT current_timestamp(),
`active` tinyint(1) UNSIGNED NOT NULL DEFAULT 1,
`deleted` tinyint(1) UNSIGNED NOT NULL DEFAULT 0
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

--
-- Индексы сохранённых таблиц
--

--
-- Индексы таблицы `users`
--
ALTER TABLE `users`
ADD PRIMARY KEY (`id`),
ADD KEY `active` (`active`),
ADD KEY `deleted` (`deleted`);

--
-- AUTO_INCREMENT для сохранённых таблиц
--

--
-- AUTO_INCREMENT для таблицы `users`
--
ALTER TABLE `users`
MODIFY `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT;