PHP Redis : Comment indexer les clés ?

O
ortolojf
WRInaute accro
Bonjour

Suis en train d'implémenter mes sessions avec PHP Redis.

Les méthode suivantes n'agissent que sur des string du genre : $key : $value.

ttl(), expire(), del(), etc...

Sur mon petit projet, les valeurs $key : $value sont affectées/lues avec : $connId->hSet($id, [key => $value]);

Comment gérer les delete et expire() ?

Suis-je obligé de n'enregistrer que des : ($id . $key) : $value ?

Mes id de session sont des UUID V4.

Pour lire les enreg de $id je ferais ( à peu près ) :

PHP: 
  $array_keys = array();

  $iterator = NULL;
  while($iterator != 0)
  {
                $array_keys = $this->connId->scan($iterator, "[a-z0-9-]+*");

               //   ... etc...
  }

Merci beaucoup de votre aide.
 
O
ortolojf
WRInaute accro
Pardon

J'avais trouvé.

J'ai mis les enregs dans des "hash", un hash par id de session.

Chaque id de session est strictement aléatoire, et ( dans mon cas ), du type UUID v4.

Les expire() ne peuvent être affectés que pour la clé de chaque hash.

Voici mon session_handler.php

Merci de vos avis et critiques.

PHP: 
<?php
require(__DIR__ . '/clientID.php');
define('MAXLIFETIME', ini_get('session.gc_maxlifetime'));
define('MAX_IDLE_TIME', 300);
define('MIN_LEFT_TIME', 30);
class CustomSessionHandler implements SessionHandlerInterface,
        SessionIdInterface,
        SessionUpdateTimestampHandlerInterface
{
        private $redisConn;
        private $lastCreatedId;
        private $fp = null;
        public function    __construct()
        {
                $this->fp = fopen("/var/www/html/php/config/redis.log", "w");
                session_set_save_handler(
                        array($this, "open"),
                        array($this, "close"),
                        array($this, "read"), 
                        array($this, "write"), 
                        array($this, "destroy"), 
                        array($this, "gc"), 
                        array($this, "create_sid"), 
                        array($this, "validateId"), 
                        array($this, "updateTimestamp"));
                fwrite($this->fp, "Running session_set_save_handler();\n");
                // Set the shutdown function
                register_shutdown_function('session_write_close');
                fwrite($this->fp, "Preparing session_write_close();\n");
                // Define and initialise the Session Handler
                session_start();
                return true;
        }
        /**
        * 1ère fonction.
        **/
        public function open($savePath, $sessionName)
        {
                /**
                Parameters
                    host: string. can be a host, or the path to a unix domain socket. Starting from version 5.0.0 it is possible to specify schema port: int, optional
                    timeout: float, value in seconds (optional, default is 0 meaning unlimited)
                    reserved: should be NULL if retry_interval is specified
                    retry_interval: int, value in milliseconds (optional)
                    read_timeout: float, value in seconds (optional, default is 0 meaning unlimited)
                **/
                try
                {
                        $this->redisConn = new Redis();
                        fwrite($this->fp, "Instanciation class Redis done.\n");
                } catch(Exception $e) {
                        fwrite($this->fp, "Erreur instanciation classe Redis : " . $e->getMessage() . "\n");
                        return false;
                }   
                try
                {
                        $this->redisConn->connect('/var/run/redis/redis.sock'); // unix domain socket.
                        fwrite($this->fp, "Connect to Redis server done.\n");
                } catch(Exception $e) {
                        fwrite($this->fp, "Erreur connexion serveur Redis : " . $e->getMessage() . "\n");
                        return false;
                }
                try
                {
                        $this->redisConn->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
                        fwrite($this->fp, "Setting Redis client option done.\n");
                        return true;
                } catch(Exception $e) {
                        fwrite($this->fp, "Erreur setting option client Redis : " . $e->getMessage() . "\n");
                        return false;
                }
                return false;
                /* With PhpRedis >= 5.3.0 you can specify authentication information on connect */
                /**
                if($this->redisConn->connect('/var/run/redis/redis.sock', 1, NULL, 100, 0, ['auth' => ['phpredis', 'phpredis']]) === true)
                {
                    return true;
                }
                **/
                // return value should be true for success or false for failure
        }
        /**
        * 2ème fonction.
        * ( si nouvelle session ).
        **/
        public function create_sid()
        {
                try
                {
                        $this->lastCreatedId = clientID();
                } catch(Exception $e) {
                        fwrite($this->fp, "Erreur création Id : " . $e->getMessage() . "\n");
                        return false;
                }
                // invoked internally when a new session id is needed
                // no parameter is needed and return value should be the new session id created
                $this->affic("Session Id created", $this->lastCreatedId);
                return $this->lastCreatedId;
        }
        public function validateId($sessionId)
        {
                $this->affic("Session Id checked", $sessionId);
                if ($sessionId !== $this->lastCreatedId) {
                        return false;
                }
                fwrite($this->fp, "session_id() checked : " . session_id() . "\n");
                if(preg_match("{^[a-z0-9-]+$}", session_id()))
                {
                        return true;
                }
                return false;
                // return value should be true if the session id is valid otherwise false
                // if false is returned a new session id will be generated by php internally
                // checks session existance
        }
        /**
        * fonction
        * lecture
        * de l'array
        * lue par hGetAll().
        **/
        protected function affic($str, $tmp_array)
        {
                if(is_array($tmp_array))
                {
                        foreach($tmp_array as $key => $value)
                        {
                                fwrite($this->fp, "\t\t" . $str . " : " . $key . " => " . $value . "\n");
                        }
                }
                else
                {
                        fwrite($this->fp, "\t\t" . $str . " : " . $tmp_array . "\n");
                }
        }
        /**
        * Dernière fonction.
        **/
        public function close()
        {
                if($this->gc(MAXLIFETIME) === false)
                {
                        fwrite($this->fp, "\t\tFailed updating session data while closing the session.\n");
                        fclose($this->fp);
                        fwrite($this->fp, "\t\tClosing the session.\n");
                        $this->redisConn->close();
                        return false;
                }
                fwrite($this->fp, "\t\tClosing the session.\n");
                fclose($this->fp);
                return $this->redisConn->close();
                // return value should be true for success or false for failure
        }
        /**
        * 3ème fonction
        * si nouvelle fonction,
        * ou 2ème fonction.
        **/
        public function read($id)
        {
                $array_read        = array();
                try
                {
                        $array_read = $this->redisConn->hGetAll($id);
                } catch(Exception $err) {
                        fwrite($this->fp, "Erreur read Data : " . $e->getMessage() . "\n");
                        return false;
                }
                $this->affic("Data read", $array_read);
                if ((is_array($array_read))&&
                        (count($array_read) > 0))
                {
                        $_SESSION = $array_read;
                        return serialize($array_read);
                }
                return "";
        }
        /**
        * Avant-dernière fonction,
        * ( si session_write_close(); )
        **/
        public function write($id, $data)
        {
                $array_write = array();
                if(strlen($data) > 0)
                {
                        $array_write = unserialize($data);
                        if(count($array_write) > 0)
                        {
                                foreach($array_write as $key => $value)
                                {
                                        if($this->redisConn->hSet($id, $key, $value) === false)
                                        {
                                                $this->affic("Failed writing key : " . $key, $value);
                                                return false;
                                        }
                                }
                                if($this->redisConn->expire($id, MAXLIFETIME) === false)
                                {
                                    $this->affic("Succeded setting key TTL : " . $id . " => " . $key, $value);
                                    return false;
                                }
                        }
                }
                $this->affic("Data written", $array_write);
                return true;
                //                return file_put_contents("$this->savePath/sess_$id", $data) === false ? false : true;
                // return value should be true for success or false for failure
        }
        /**
        * Avant-dernière fonction,
        *         après 
        *    session_regenerate_id(),
        *    session_destroy(),
        *    ou session_decode() === false
        **/
        public function destroy($id)
        {
                /**
                * Seulement
                * pour la session
                *     $id.
                */
                $array_del = array();
                $array_del = $this->redisConn->hGetAll($id);
                $this->affic("Data destroyed", $array_del);
                foreach($array_del as $key => $value)
                {
                        if($this->redisConn->hDel($id, $key) === false)
                        {
                                $this->affic("Failed to destroy the session key : " . $id . " => " . $key, $value);
                                return false;
                        }
                }
                if($this->redisConn->del($id) === false)
                {
                        fwrite($this->fp, "\t\tFailed to destroy the session.\n");
                        return false;
                }
                return true;
                // return value should be true for success or false for failure
        }
        /**
        * Après session_start(),
        * en fonction de 
        * session.gc_divisor, 
        * session.gc_probability, 
        * session.gc_maxlifetime
        **/
        /**
        * Fonction globale
        */
        public function gc($maxlifetime)
        {
                $array_keys = array();
                /**
                * Lecture $str_key
                * des id_sessions.
                **/
                $array_keys = $this->redisConn->keys("*");
                $this->affic("\$array_keys", $array_keys);
                foreach($array_keys as $str_key)
                {
                    if($str_key == $this->lastCreatedId)
                    {
                        continue;
                    }
//                    if(preg_match("#^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$#", $str_key))
                    if(preg_match("#^[a-z0-9-]+$#", $str_key))
                    {
                        unset($ttl);
                        $ttl = $this->redisConn->ttl($str_key);
//                        $this->affic("Key TTL : " . $str_key, $ttl);
                        if(($ttl < 0)&&($ttl != -2))
                        {
//                            $this->affic("Key TTL : " . $str_key, $ttl);
                            $array_del = array();
                            $array_del = $this->redisConn->hGetAll($str_key);
                            $this->affic("Array_keys to delete", $array_del);
                            foreach($array_del as $key => $value)
                            {
                                $this->affic("Key to be deleted = " . $str_key, $key);
                                if($this->redisConn->hDel($str_key, $key) === false)
                                {
                                    $this->affic("Failed deleting key : " . $str_key . " => " . $key, $value);
                                    return false;
                                }
                                else
                                {
                                    $this->affic("Succeded deleting key : " . $str_key . " => " . $key, $value);
                                }
                            }
                            if($this->redisConn->del($str_key) === false)
                            {
                                    $this->affic("Failed deleting key", $str_key);
                                    return false;
                            }
                            else
                            {
                                $this->affic("Succeded deleting key", $str_key);
                            }
                        }
                    }
                }
                return true;
                // return value should be true for success or false for failure
                /**
                foreach (glob("$this->savePath/sess_*") as $file) {
                        if (filemtime($file) + $maxlifetime < time() && file_exists($file)) {
                                unlink($file);
                        }
                }
                **/
        }
        public function updateTimestamp($id, $data)
        {
                $array_updated    = array();
                $array_read        = array();
                $array_read        = unserialize($data);
                //    $array_read = $this->redisConn->hGetAll($id);
                foreach($array_read as $key => $value)
                {
                    $this->affic("Attempting to update the session key " . $key . " TTL = " . $this->redisConn->ttl($key), $value);
                    if($this->redisConn->hExists($this->lastCreatedId, $key) === true)
                    {
                        if($this->redisConn->expire($key, MAX_IDLE_TIME) === false)
                        {
                            $this->affic("Failed while updating the session key TTL" . $key, $value);
                            return false;
                        }
                        $this->affic("Succeded while updating the session key TTL" . $key, $value);
                    }
                }
                       
                return true;
                // return value should be true for success or false for failure
        }
}
$handler = new CustomSessionHandler();
// if (session_status() == PHP_SESSION_NONE) {session_start();}
//    session_set_save_handler ( callable $open , callable $close , callable $read , callable $write , callable $destroy , callable $gc [, callable $create_sid [, callable $validate_sid [, callable $update_timestamp ]]] ) : bool
?>
 
O
ortolojf
WRInaute accro
Rebond.

La fonction gc() ne se déclenche que si (time() % 6000) < 6).

J'obtiens environ 180 clés simultanées dans redis.log.

J'ai mis celà sur mon site.

Prenez si vous voulez.

PHP: 
<?php

/**
  * session_handler.php
 **/
require(__DIR__ . '/clientID.php');
define('MAXLIFETIME', ini_get('session.gc_maxlifetime'));
define('MAX_IDLE_TIME', 300);
define('MIN_LEFT_TIME', 30);
define('ID_KEY', 'x9NNGejdBGrwlZCkBBAqTYZlD82tzj4w');
define('COUNT_KEY', 'COUNT_KEY');
define('GC_PERIOD', 6000);
class CustomSessionHandler implements SessionHandlerInterface,
    SessionIdInterface,
    SessionUpdateTimestampHandlerInterface
{
    private $redisConn;
    private $lastCreatedId;
    private $fp;
    public function    __construct()
    {
        session_set_save_handler(
            array($this, "open"),
            array($this, "close"),
            array($this, "read"), 
            array($this, "write"), 
            array($this, "destroy"), 
            array($this, "gc"), 
            array($this, "create_sid"), 
            array($this, "validateId"), 
            array($this, "updateTimestamp"));
        // Set the shutdown function
        register_shutdown_function('session_write_close');
        // Define and initialise the Session Handler
        session_start();
        return true;
    }
    /**
    * 1ère fonction.
    **/
    public function open($savePath, $sessionName)
    {
                /**
                Parameters
                    host: string. can be a host, or the path to a unix domain socket. Starting from version 5.0.0 it is possible to specify schema port: int, optional
                    timeout: float, value in seconds (optional, default is 0 meaning unlimited)
                    reserved: should be NULL if retry_interval is specified
                    retry_interval: int, value in milliseconds (optional)
                    read_timeout: float, value in seconds (optional, default is 0 meaning unlimited)
                **/
        try
        {
            $this->redisConn = new Redis();
        } catch(Exception $e) {
            return false;
        }   
        try
        {
            $this->redisConn->connect('/var/run/redis/redis.sock'); // unix domain socket.
        } catch(Exception $e) {
            $this->redisConn->close();
            return false;
        }
        try
        {
            $this->redisConn->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
            return true;
        } catch(Exception $e) {
            $this->redisConn->close();
            return false;
        }
        return false;
        /* With PhpRedis >= 5.3.0 you can specify authentication information on connect */
                /**
                if($this->redisConn->connect('/var/run/redis/redis.sock', 1, NULL, 100, 0, ['auth' => ['phpredis', 'phpredis']]) === true)
                {
                    return true;
                }
                **/
        // return value should be true for success or false for failure
    }
    /**
    * 2ème fonction.
    * ( si nouvelle session ).
    **/
    public function create_sid()
    {
        try
        {
            $this->lastCreatedId = clientID();
        } catch(Exception $e) {
            return false;
        }
        // invoked internally when a new session id is needed
        // no parameter is needed and return value should be the new session id created
        return $this->lastCreatedId;
    }
    public function validateId($sessionId)
    {
        if ($sessionId !== $this->lastCreatedId) {
            return false;
        }
        if((strlen(session_id()) > 2)&&(preg_match("#^[a-z0-9-]+$#", session_id())))
        {
            return true;
        }
        return false;
        // return value should be true if the session id is valid otherwise false
        // if false is returned a new session id will be generated by php internally
        // checks session existance
    }
    /**
    * Dernière fonction.
    **/
    public function close()
    {
        /**
        if($this->gc(MAXLIFETIME) === false)
        {
            $this->redisConn->close();
            return false;
        }
        **/
        return $this->redisConn->close();
        // return value should be true for success or false for failure
    }
    /**
    * 3ème fonction
    * si nouvelle fonction,
    * ou 2ème fonction.
    **/
    public function affic($key, $tmp_array)
    {
        if(is_array($tmp_array))
        {
                foreach($tmp_array as $key2 => $value)
                {
                    fwrite($this->fp, $key . " => " . $key2 . " => " . $value . "\n");
                }
        }
        else
        {
            fwrite($this->fp, $key . " => " . $tmp_array . "\n");
        }
        return true;
    }
    /**
    * 3ème fonction
    * si nouvelle fonction,
    * ou 2ème fonction.
    **/
    public function read($id)
    {
        $array_read        = array();
        try
        {
            $array_read = $this->redisConn->hGetAll($id);
        } catch(Exception $err) {
            return false;
        }
        if ((is_array($array_read))&&
            (count($array_read) > 0))
        {
            $_SESSION = $array_read;
            return serialize($array_read);
        }
        return "";
    }
    /**
    * Avant-dernière fonction,
    * ( si session_write_close(); )
    **/
    public function run_gc()
    {
        if((time() % GC_PERIOD) <= 6)
        {
            if($this->gc(MAXLIFETIME) === false)
            {
                $this->redisConn->close();
                return false;
            }
        }
        return true;
    }
    /**
    * Avant-dernière fonction,
    * ( si session_write_close(); )
    **/
    public function write($id, $data)
    {
        $array_write = array();
        if(strlen($data) > 0)
        {
            $array_write = unserialize($data);
            if(count($array_write) > 0)
            {
                foreach($array_write as $key => $value)
                {
                    if($this->redisConn->hSet($id, $key, $value) === false)
                    {
                        $this->redisConn->close();
                        return false;
                    }
                    if($this->redisConn->expire($id, MAXLIFETIME) === false)
                    {
                        $this->redisConn->close();
                        return false;
                    }
                }
            }
        }
        return $this->run_gc();
        //                return file_put_contents("$this->savePath/sess_$id", $data) === false ? false : true;
        // return value should be true for success or false for failure
    }
    /**
    * Avant-dernière fonction,
    *         après 
    *    session_regenerate_id(),
    *    session_destroy(),
    *    ou session_decode() === false
    **/
    public function destroy($id)
    {
        /**
        * Seulement
        * pour la session
        *     $id.
        */
        $array_del = array();
        $array_del = $this->redisConn->hGetAll($id);
        foreach($array_del as $key => $value)
        {
            if($this->redisConn->hDel($id, $key) === false)
            {
                return false;
            }
        }
        if($this->redisConn->del($id) === false)
        {
            return false;
        }
        return true;
        // return value should be true for success or false for failure
    }
    /**
    * Après session_start(),
    * en fonction de 
    * session.gc_divisor, 
    * session.gc_probability, 
    * session.gc_maxlifetime
    **/
    /**
    * Fonction globale
    */
    public function gc($maxlifetime)
    {
        $array_keys = array();
        $i = 0;
        $iterator = null;
        while($iterator !== 0)
        {
            /**
            * Lecture $str_key
            * des id_sessions.
            **/
            $array_keys = $this->redisConn->scan($iterator, '*');
               
            $array_only_keys = preg_filter("{([a-z]+|-)}", $array_keys);
            $i += count($array_keys);
            foreach($array_keys as $str_key)
            {
                if(($str_key == $this->lastCreatedId)||
                        ($str_key == ID_KEY))
                {
                        continue;
                }
                if((strlen($str_key) > 2)&&(preg_match("#^[a-z0-9-]+$#", $str_key)))
                {
                    unset($ttl);
                    $ttl = $this->redisConn->ttl($str_key);
                    if(($ttl < 0)&&($ttl != -2))
                    {
                        $array_del = array();
                        $array_del = $this->redisConn->hGetAll($str_key);
                        foreach($array_del as $key => $value)
                        {
                            if($this->redisConn->hDel($str_key, $key) === false)
                            {
                                return false;
                            }
                        }
                        if($this->redisConn->del($str_key) === false)
                        {
                            return false;
                        }
                    }
                }
            }
        }
        $this->fp = fopen(__DIR__ . "/redis.log", "w");
       
        if($this->redisConn->hSet(ID_KEY, COUNT_KEY, $i) === false)
        {
            $this->affic("\$this->redisConn->hSet(ID_KEY, COUNT_KEY", $this->redisConn->hGet(ID_KEY, COUNT_KEY) . " Keys failed.");
            return false;
        }
        $this->affic("\$this->redisConn->hSet(ID_KEY, COUNT_KEY", $this->redisConn->hGet(ID_KEY, COUNT_KEY) . " Keys succeded.");
        fclose($this->fp);
        return true;
        // return value should be true for success or false for failure
                /**
                foreach (glob("$this->savePath/sess_*") as $file) {
                        if (filemtime($file) + $maxlifetime < time() && file_exists($file)) {
                                unlink($file);
                        }
                }
                **/
    }
    public function updateTimestamp($id, $data)
    {
        $array_updated    = array();
        $array_read        = array();
        $array_read        = unserialize($data);
        //    $array_read = $this->redisConn->hGetAll($id);
        foreach($array_read as $key => $value)
        {
            if($this->redisConn->hExists($id, $key) === true)
            {
                if($this->redisConn->expire($id, MAX_IDLE_TIME) === false)
                {
                    return false;
                }
                return true;
            }
        }
        return true;
        // return value should be true for success or false for failure
    }
}
$handler = new CustomSessionHandler();
// if (session_status() == PHP_SESSION_NONE) {session_start();}
//    session_set_save_handler ( callable $open , callable $close , callable $read , callable $write , callable $destroy , callable $gc [, callable $create_sid [, callable $validate_sid [, callable $update_timestamp ]]] ) : bool
?>
 
O
ortolojf
WRInaute accro
Excusez-moi

J'ai mis le gc.filemtime à 1440 et le gc.divisor à 1000 ( après 100 ).

Je me suis aperçu que la fonction gc() était lancée sans que j'ais besoin de le faire manuellement.

Voici le log.

read Keys c'est le nbre total de clés-enregs

delete Keys c'est le nbre de clés-enregs à deleter.

Le blème, c'est que aucune clé semble exister.

Donc il n'y a pas de delete faits.

Cependant, le nombre de clés total n'augmente pas.

Par quel miracle, les clés sont effacées avant que gc() ne soit lancée ?

Le DELAY c'était quand je faisais moi-même les lancements de gc().

Merci beaucoup de votre aide.

Amicalement.

Code: 
*************************************************************************
    DELAY = 600 secondes, Date mesure = 03/08/2020 11:03:35
*************************************************************************
    $this->redisConn->hSet(ID_KEY, GC_KEY => 128 read Keys succeded.
    $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
*************************************************************************
    DELAY = 600 secondes, Date mesure = 03/08/2020 11:05:07
*************************************************************************
    $this->redisConn->hSet(ID_KEY, GC_KEY => 107 read Keys succeded.
    $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
*************************************************************************
    DELAY = 600 secondes, Date mesure = 03/08/2020 11:12:40
*************************************************************************
    $this->redisConn->hSet(ID_KEY, GC_KEY => 99 read Keys succeded.
    $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
*************************************************************************
    DELAY = 600 secondes, Date mesure = 03/08/2020 11:19:28
*************************************************************************
    $this->redisConn->hSet(ID_KEY, GC_KEY => 89 read Keys succeded.
    $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
*************************************************************************
    DELAY = 600 secondes, Date mesure = 03/08/2020 11:19:38
*************************************************************************
    $this->redisConn->hSet(ID_KEY, GC_KEY => 90 read Keys succeded.
    $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
*************************************************************************
    DELAY = 600 secondes, Date mesure = 03/08/2020 11:20:05
*************************************************************************
    $this->redisConn->hSet(ID_KEY, GC_KEY => 100 read Keys succeded.
    $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
*************************************************************************
    DELAY = 600 secondes, Date mesure = 03/08/2020 11:20:18
*************************************************************************
    $this->redisConn->hSet(ID_KEY, GC_KEY => 98 read Keys succeded.
    $this->redisConn->hSet(ID_KEY, GC_DELETED => 0 delete Keys succeded.
 
Vous devez vous connecter ou vous inscrire pour répondre ici.
1.fr
Discussions similaires
O
Logiciel IA en PHP ?
Réponses
1
Affichages
371
Dr DLP
D
O
Détecter en PHP les commentaires "<!-- -->" dans un DOMDocument.
Réponses
15
Affichages
929
ortolojf
O
O
Comment faire plusieurs queues en PHP ?
Réponses
8
Affichages
731
suppr334822
S
O
install PHP 8.2 sur Fedora 37.
Réponses
2
Affichages
641
ortolojf
O
C
Qui a mis son site wordpress en PHP 8.1 ?
Réponses
5
Affichages
963
caboucadin
C
S
PHP v8.2 fonction utf8_decode déprécié
Réponses
2
Affichages
646
colonies
colonies
E
Bien gérer un script PHP un peu long
Réponses
7
Affichages
1K
emualliug
E
O
En PHP : enregistrer un id de page/user variable.
Réponses
2
Affichages
608
ortolojf
O
O
Indent en mode PHP ?
Réponses
1
Affichages
659
Brokenbol
B
O
Arborescence de classes PHP et séquentialité.
Réponses
8
Affichages
1K
spout
spout
W
Afficher des infos depuis plusieurs page en PHP
Réponses
2
Affichages
2K
wisefun77
W
sim100
Sites de scripts PHP, jQuery, Ajax, etc.
Réponses
3
Affichages
1K
colonies
colonies
O
Détecter arrêt user d'un script PHP ?
Réponses
9
Affichages
1K
ortolojf
O
O
sessions PHP sans cookies ?
Réponses
4
Affichages
2K
ortolojf
O
P
Afficher la dernière version d'un fichier php ?
Réponses
21
Affichages
2K
passion
passion
S
PHP / CURL : interrogation page tiers ne fonctionne plus
Réponses
3
Affichages
1K
passion
passion
S
Actualiser un script php toutes les 10 secondes
Réponses
6
Affichages
1K
chava2b
C
S
PHP : problème de comparaison égalité dans boucle FOR avec incrément décimal de 0.1
Réponses
11
Affichages
2K
colonies
colonies
O
Cache Etag nginx et PHP ?
Réponses
27
Affichages
2K
ortolojf
O
F
Fichier avec ou sans extension php pour le référencement
Réponses
2
Affichages
2K
flexi2202
F
Haut