Php 010基础面试题

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

<?php
class FileSessionHandler{
    private $savePath;
    //第一个参数$save_path对应的是ini_get('session.save_path')
    //第二个参数$name对应的是ini_get('session.name')
    function open($savePath, $sessionName){
        $this->savePath = $savePath;
        if (!is_dir($this->savePath)) {
            mkdir($this->savePath, 0777);
        }
        return true;
    }

    function close(){
        return true;
    }

    function read($id){
        return (string)@file_get_contents("$this->savePath/sess_$id");
    }

    function write($id, $data){
        return file_put_contents("$this->savePath/sess_$id", $data) === false ? false : true;
    }

    function destroy($id){
        $file = "$this->savePath/sess_$id";
        if (file_exists($file)) {
            unlink($file);
        }
        return true;
    }

    function gc($maxlifetime){
        foreach (glob("$this->savePath/sess_*") as $file) {
            if (filemtime($file) + $maxlifetime < time() && file_exists($file)) {
                unlink($file);
            }
        }

        return true;
    }
}

$handler = new FileSessionHandler();
session_set_save_handler(
        array($handler, 'open'),
        array($handler, 'close'),
        array($handler, 'read'),
        array($handler, 'write'),
        array($handler, 'destroy'),
        array($handler, 'gc')
    );

// the following prevents unexpected effects when using objects as save handlers
register_shutdown_function('session_write_close');

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107

class DatabaseSession implements SessionHandlerInterface{
    /**
     * Reference to the table handling the session data
     */
    protected $_table;

    /**
     * Number of seconds to mark the session as expired
     */
    protected $_timeout;

    /**
     * Constructor. Looks at Session configuration information and
     * sets up the session model.
     * @param array $config The configuration for this engine. It requires the 'model'
     * key to be present corresponding to the Table to use for managing the sessions.
     */
    public function __construct(array $config = []){
        if (empty($config['model'])) {
            $config = TableRegistry::exists('Sessions') ? [] : ['table' => 'sessions'];
            $this->_table = TableRegistry::get('Sessions', $config);
        } else {
            $this->_table = TableRegistry::get($config['model']);
        }
        $this->_timeout = ini_get('session.gc_maxlifetime');
    }

    /**
     * Method called on open of a database session.
     * @param string $savePath The path where to store/retrieve the session.
     * @param string $name The session name.
     * @return bool Success
     */
    public function open($savePath, $name){
        return true;
    }

    /**
     * Method called on close of a database session.
     *
     * @return bool Success
     */
    public function close(){
        return true;
    }

    /**
     * Method used to read from a database session.
     *
     * @param int|string $id The key of the value to read
     * @return mixed The value of the key or false if it does not exist
     */
    public function read($id){
        $result = $this->_table
            ->find('all')
            ->select(['data'])
            ->where([$this->_table->primaryKey() => $id])
            ->hydrate(false)
            ->first();

        if (empty($result)) {
            return false;
        }
        return $result['data'];
    }

    /**
     * Helper function called on write for database sessions.
     *
     * @param int $id ID that uniquely identifies session in database
     * @param mixed $data The value of the data to be saved.
     * @return bool True for successful write, false otherwise.
     */
    public function write($id, $data){
        if (!$id) {
            return false;
        }
        $expires = time() + $this->_timeout;
        $record = compact('data', 'expires');
        $record[$this->_table->primaryKey()] = $id;
        $result = $this->_table->save(new Entity($record));
        return (bool)$result;
    }

    /**
     * Method called on the destruction of a database session.
     * @param int $id ID that uniquely identifies session in database
     * @return bool True for successful delete, false otherwise.
     */
    public function destroy($id){
        return (bool)$this->_table->delete(new Entity(
            [$this->_table->primaryKey() => $id],
            ['markNew' => false]
        ));
    }

    /**
     * Helper function called on gc for database sessions.
     *
     * @param string $maxlifetime Sessions that have not updated for the last maxlifetime seconds will be removed.
     * @return bool True on success, false on failure.
     */
    public function gc($maxlifetime){
        $this->_table->deleteAll(['expires <' => time() - $maxlifetime]);
        return true;
    }
}