php教程分享

  1. php教程首页
  2. php类库

php文件缓存类汇总

•php类库•阅读 290

这篇文章主要介绍了php文件缓存类,实例汇总了常见的文件缓存类及其用法,非常具有实用价值,需要的朋友可以参考下

本文实例讲述了php的文件缓存类。分享给大家供大家参考。具体分析如下：

缓存类是我们开发应用中会常用使用到的功能，下面就来给大家整理几个php文件缓存类了，各个文件缓存类写法不同，但在性能上会有区别，有兴趣测试的朋友可测试一下这些缓存类。

例1代码如下:

  1. <?php
  2. $fzz = new fzz_cache;
  3. $fzz->kk = $_SERVER; //写入缓存
  4. //$fzz->set("kk",$_SERVER,10000); //此方法不与类属性想冲突，可以用任意缓存名；
  5. print_r($fzz->kk); //读取缓存
  6. //print_r($fzz->get("kk"));
  7. //unset($fzz->kk); //删除缓存
  8. //$fzz->_unset("kk");
  9. var_dump(isset($fzz->kk)); //判断缓存是否存在
  10. //$fzz->_isset("kk");
  11. //$fzz->clear(); //清理过期缓存
  12. //$fzz->clear_all(); //清理所有缓存文件
  13. class fzz_cache{
  14. public $limit_time = 20000; //缓存过期时间
  15. public $cache_dir = "data"; //缓存文件保存目录
  16. //写入缓存
  17. function __set($key , $val){
  18. $this->_set($key ,$val);
  19. }
  20. //第三个参数为过期时间
  21. function _set($key ,$val,$limit_time=null){
  22. $limit_time = $limit_time ? $limit_time : $this->limit_time;
  23. $file = $this->cache_dir."/".$key.".cache";
  24. $val = serialize($val);
  25. @file_put_contents($file,$val) or $this->error(__line__,"fail to write in file");
  26. @chmod($file,0777);
  27. @touch($file,time()+$limit_time) or $this->error(__line__,"fail to change time");
  28. }
  29. //读取缓存
  30. function __get($key){
  31. return $this->_get($key);
  32. }
  33. function _get($key){
  34. $file = $this->cache_dir."/".$key.".cache";
  35. if (@filemtime($file)>=time()){
  36. return unserialize(file_get_contents($file));
  37. }else{
  38. @unlink($file) or $this->error(__line__,"fail to unlink");
  39. return false;
  40. }
  41. }
  42. //删除缓存文件
  43. function __unset($key){
  44. return $this->_unset($key);
  45. }
  46. function _unset($key){
  47. if (@unlink($this->cache_dir."/".$key.".cache")){
  48. return true;
  49. }else{
  50. return false;
  51. }
  52. }
  53. //检查缓存是否存在，过期则认为不存在
  54. function __isset($key){
  55. return $this->_isset($key);
  56. }
  57. function _isset($key){
  58. $file = $this->cache_dir."/".$key.".cache";
  59. if (@filemtime($file)>=time()){
  60. return true;
  61. }else{
  62. @unlink($file) ;
  63. return false;
  64. }
  65. }
  66. //清除过期缓存文件
  67. function clear(){
  68. $files = scandir($this->cache_dir);
  69. foreach ($files as $val){
  70. if (filemtime($this->cache_dir."/".$val)<time()){
  71. @unlink($this->cache_dir."/".$val);
  72. }
  73. }
  74. }
  75. //清除所有缓存文件
  76. function clear_all(){
  77. $files = scandir($this->cache_dir);
  78. foreach ($files as $val){
  79. @unlink($this->cache_dir."/".$val);
  80. }
  81. }
  82. function error($msg,$debug = false) {
  83. $err = new Exception($msg);
  84. $str = "<pre>
  85. <span >error:</span>
  86. ".print_r($err->getTrace(),1)."
  87. </pre>";
  88. if($debug == true) {
  89. file_put_contents(date('Y-m-d H_i_s').".log",$str);
  90. return $str;
  91. }else{
  92. die($str);
  93. }
  94. }
  95. }
  96. ?>

例2.从CI社区的stblog和CI的file_helper类中提取出来的php文件缓存类,一个简单的基于文件的key->value缓存类。

这个类可以用来缓存一些基本信息,比如博客的header,footer,sidebar中的一些不经常变化，从数据库中取出的内容,取数据前先判断文件缓存中的内容是否过期,如果没过期取出来,过期了则连接数据库查询,并将结果重新写入文件缓存,更新过期时间。跟memcache使用类似,不过更方便。用在一些小的应用上足够了.

具体代码如下:

  1. <?php
  2. define('DIRECTORY_SEPARATOR','/');
  3. define('FOPEN_WRITE_CREATE_DESTRUCTIVE','wb');
  4. define('FOPEN_WRITE_CREATE','ab');
  5. define('DIR_WRITE_MODE', 0777);
  6. class FileCache {
  7. /**
  8. * 缓存路径
  9. *
  10. * @access private
  11. * @var string
  12. */
  13. private $_cache_path;
  14. /**
  15. * 缓存过期时间，单位是秒second
  16. *
  17. * @access private
  18. * @var int
  19. */
  20. private $_cache_expire;
  21. /**
  22. * 解析函数，设置缓存过期实践和存储路径
  23. *
  24. * @access public
  25. * @return void
  26. */
  27. public function __construct($expire, $cache_path)
  28. {
  29. $this->_cache_expire = $expire;
  30. $this->_cache_path = $cache_path;
  31. }
  32. /**
  33. * 缓存文件名
  34. *
  35. * @access public
  36. * @param string $key
  37. * @return void
  38. */
  39. private function _file($key)
  40. {
  41. return $this->_cache_path . md5($key);
  42. }
  43. /**
  44. * 设置缓存
  45. *
  46. * @access public
  47. * @param string $key 缓存的唯一键
  48. * @param string $data 缓存的内容
  49. * @return bool
  50. */
  51. public function set($key, $data)
  52. {
  53. $value = serialize($data);
  54. $file = $this->_file($key);
  55. return $this->write_file($file, $value);
  56. }
  57. /**
  58. * 获取缓存
  59. *
  60. * @access public
  61. * @param string $key 缓存的唯一键
  62. * @return mixed
  63. */
  64. public function get($key)
  65. {
  66. $file = $this->_file($key);
  67. /** 文件不存在或目录不可写 */
  68. if (!file_exists($file) || !$this->is_really_writable($file))
  69. {
  70. return false;
  71. }
  72. /** 缓存没有过期，仍然可用 */
  73. if ( time() < (filemtime($file) + $this->_cache_expire) )
  74. {
  75. $data = $this->read_file($file);
  76. if(FALSE !== $data)
  77. {
  78. return unserialize($data);
  79. }
  80. return FALSE;
  81. }
  82. /** 缓存过期，删除之 */
  83. @unlink($file);
  84. return FALSE;
  85. }
  86. function read_file($file)
  87. {
  88. if ( ! file_exists($file))
  89. {
  90. return FALSE;
  91. }
  92. if (function_exists('file_get_contents'))
  93. {
  94. return file_get_contents($file);
  95. }
  96. if ( ! $fp = @fopen($file, FOPEN_READ))
  97. {
  98. return FALSE;
  99. }
  100. flock($fp, LOCK_SH);//读取之前加上共享锁
  101. $data = '';
  102. if (filesize($file) > 0)
  103. {
  104. $data =& fread($fp, filesize($file));
  105. }
  106. flock($fp, LOCK_UN);//释放锁
  107. fclose($fp);
  108. return $data;
  109. }
  110. function write_file($path, $data, $mode = FOPEN_WRITE_CREATE_DESTRUCTIVE)
  111. {
  112. if ( ! $fp = @fopen($path, $mode))
  113. {
  114. return FALSE;
  115. }
  116. flock($fp, LOCK_EX);
  117. fwrite($fp, $data);
  118. flock($fp, LOCK_UN);
  119. fclose($fp);
  120. return TRUE;
  121. }
  122. function is_really_writable($file)//兼容各平台判断文件是否有写入权限
  123. {
  124. // If we're on a Unix server with safe_mode off we call is_writable
  125. if (DIRECTORY_SEPARATOR == '/' AND @ini_get("safe_mode") == FALSE)
  126. {
  127. return is_writable($file);
  128. }
  129. // For windows servers and safe_mode "on" installations we'll actually
  130. // write a file then read it. Bah...
  131. if (is_dir($file))
  132. {
  133. $file = rtrim($file, '/').'/'.md5(rand(1,100));
  134. if (($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE)
  135. {
  136. return FALSE;
  137. }
  138. fclose($fp);
  139. @chmod($file, DIR_WRITE_MODE);
  140. @unlink($file);
  141. return TRUE;
  142. }
  143. elseif (($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE)
  144. {
  145. return FALSE;
  146. }
  147. fclose($fp);
  148. return TRUE;
  149. }
  150. }
  151. $cache = new FileCache(30,'cache/');
  152. $cache->set('test','this is a test.');
  153. print $cache->get('test');
  154. /* End of file FlieCache.php */

例3.自己觉得很好用的php文件缓存，代码如下:

  1. <?php
  2. class cache
  3. {
  4. private static $_instance = null;
  5. protected $_options = array(
  6. 'cache_dir' => "./",
  7. 'file_name_prefix' => 'cache',
  8. 'mode' => '1', //mode 1 为serialize model 2为保存为可执行文件
  9. );
  10. /**
  11. * 得到本类实例
  12. *
  13. * @return Ambiguous
  14. */
  15. public static function getInstance()
  16. {
  17. if(self::$_instance === null)
  18. {
  19. self::$_instance = new self();
  20. }
  21. return self::$_instance;
  22. }
  23. /**
  24. * 得到缓存信息
  25. *
  26. * @param string $id
  27. * @return boolean|array
  28. */
  29. public static function get($id)
  30. {
  31. $instance = self::getInstance();
  32. //缓存文件不存在
  33. if(!$instance->has($id))
  34. {
  35. return false;
  36. }
  37. $file = $instance->_file($id);
  38. $data = $instance->_fileGetContents($file);
  39. if($data['expire'] == 0 || time() < $data['expire'])
  40. {
  41. return $data['contents'];
  42. }
  43. return false;
  44. }
  45. /**
  46. * 设置一个缓存
  47. *
  48. * @param string $id 缓存id
  49. * @param array $data 缓存内容
  50. * @param int $cacheLife 缓存生命 默认为0无限生命
  51. */
  52. public static function set($id, $data, $cacheLife = 0)
  53. {
  54. $instance = self::getInstance();
  55. $time = time();
  56. $cache = array();
  57. $cache['contents'] = $data;
  58. $cache['expire'] = $cacheLife === 0 ? 0 : $time + $cacheLife;
  59. $cache['mtime'] = $time;
  60. $file = $instance->_file($id);
  61. return $instance->_filePutContents($file, $cache);
  62. }
  63. /**
  64. * 清除一条缓存
  65. *
  66. * @param string cache id
  67. * @return void
  68. */
  69. public static function delete($id)
  70. {
  71. $instance = self::getInstance();
  72. if(!$instance->has($id))
  73. {
  74. return false;
  75. }
  76. $file = $instance->_file($id);
  77. //删除该缓存
  78. return unlink($file);
  79. }
  80. /**
  81. * 判断缓存是否存在
  82. *
  83. * @param string $id cache_id
  84. * @return boolean true 缓存存在 false 缓存不存在
  85. */
  86. public static function has($id)
  87. {
  88. $instance = self::getInstance();
  89. $file = $instance->_file($id);
  90. if(!is_file($file))
  91. {
  92. return false;
  93. }
  94. return true;
  95. }
  96. /**
  97. * 通过缓存id得到缓存信息路径
  98. * @param string $id
  99. * @return string 缓存文件路径
  100. */
  101. protected function _file($id)
  102. {
  103. $instance = self::getInstance();
  104. $fileNmae = $instance->_idToFileName($id);
  105. return $instance->_options['cache_dir'] . $fileNmae;
  106. }
  107. /**
  108. * 通过id得到缓存信息存储文件名
  109. *
  110. * @param $id
  111. * @return string 缓存文件名
  112. */
  113. protected function _idToFileName($id)
  114. {
  115. $instance = self::getInstance();
  116. $prefix = $instance->_options['file_name_prefix'];
  117. return $prefix . '---' . $id;
  118. }
  119. /**
  120. * 通过filename得到缓存id
  121. *
  122. * @param $id
  123. * @return string 缓存id
  124. */
  125. protected function _fileNameToId($fileName)
  126. {
  127. $instance = self::getInstance();
  128. $prefix = $instance->_options['file_name_prefix'];
  129. return preg_replace('/^' . $prefix . '---(.*)$/', '$1', $fileName);
  130. }
  131. /**
  132. * 把数据写入文件
  133. *
  134. * @param string $file 文件名称
  135. * @param array $contents 数据内容
  136. * @return bool
  137. */
  138. protected function _filePutContents($file, $contents)
  139. {
  140. if($this->_options['mode'] == 1)
  141. {
  142. $contents = serialize($contents);
  143. }
  144. else
  145. {
  146. $time = time();
  147. $contents = "<?phpn".
  148. " // mktime: ". $time. "n".
  149. " return ".
  150. var_export($contents, true).
  151. "n?>";
  152. }
  153. $result = false;
  154. $f = @fopen($file, 'w');
  155. if ($f) {
  156. @flock($f, LOCK_EX);
  157. fseek($f, 0);
  158. ftruncate($f, 0);
  159. $tmp = @fwrite($f, $contents);
  160. if (!($tmp === false)) {
  161. $result = true;
  162. }
  163. @fclose($f);
  164. }
  165. @chmod($file,0777);
  166. return $result;
  167. }
  168. /**
  169. * 从文件得到数据
  170. *
  171. * @param sring $file
  172. * @return boolean|array
  173. */
  174. protected function _fileGetContents($file)
  175. {
  176. if(!is_file($file))
  177. {
  178. return false;
  179. }
  180. if($this->_options['mode'] == 1)
  181. {
  182. $f = @fopen($file, 'r');
  183. @$data = fread($f,filesize($file));
  184. @fclose($f);
  185. return unserialize($data);
  186. }
  187. else
  188. {
  189. return include $file;
  190. }
  191. }
  192. /**
  193. * 构造函数
  194. */
  195. protected function __construct()
  196. {
  197. }
  198. /**
  199. * 设置缓存路径
  200. *
  201. * @param string $path
  202. * @return self
  203. */
  204. public static function setCacheDir($path)
  205. {
  206. $instance = self::getInstance();
  207. if (!is_dir($path)) {
  208. exit('file_cache: ' . $path.' 不是一个有效路径 ');
  209. }
  210. if (!is_writable($path)) {
  211. exit('file_cache: 路径 "'.$path.'" 不可写');
  212. }
  213. $path = rtrim($path,'/') . '/';
  214. $instance->_options['cache_dir'] = $path;
  215. return $instance;
  216. }
  217. /**
  218. * 设置缓存文件前缀
  219. *
  220. * @param srting $prefix
  221. * @return self
  222. */
  223. public static function setCachePrefix($prefix)
  224. {
  225. $instance = self::getInstance();
  226. $instance->_options['file_name_prefix'] = $prefix;
  227. return $instance;
  228. }
  229. /**
  230. * 设置缓存存储类型
  231. *
  232. * @param int $mode
  233. * @return self
  234. */
  235. public static function setCacheMode($mode = 1)
  236. {
  237. $instance = self::getInstance();
  238. if($mode == 1)
  239. {
  240. $instance->_options['mode'] = 1;
  241. }
  242. else
  243. {
  244. $instance->_options['mode'] = 2;
  245. }
  246. return $instance;
  247. }
  248. /**
  249. * 删除所有缓存
  250. * @return boolean
  251. */
  252. public static function flush()
  253. {
  254. $instance = self::getInstance();
  255. $glob = @glob($instance->_options['cache_dir'] . $instance->_options['file_name_prefix'] . '--*');
  256. if(emptyempty($glob))
  257. {
  258. return false;
  259. }
  260. foreach ($glob as $v)
  261. {
  262. $fileName = basename($v);
  263. $id = $instance->_fileNameToId($fileName);
  264. $instance->delete($id);
  265. }
  266. return true;
  267. }
  268. }
  269. /* 初始化设置cache的配置信息什么的 */
  270. cache::setCachePrefix('core'); //设置缓存文件前缀
  271. cache::setCacheDir('./cache'); //设置存放缓存文件夹路径
  272. //模式1 缓存存储方式
  273. //a:3:{s:8:"contents";a:7:{i:0;i:1;i:1;i:2;i:2;i:3;i:3;i:34;i:4;i:5;i:5;i:6;i:6;i:6;}s:6:"expire";i:0;s:5:"mtime";i:1318218422;}
  274. //模式2 缓存存储方式
  275. /*
  276. <?php
  277. // mktime: 1318224645
  278. return array (
  279. 'contents' =>
  280. array (
  281. 0 => 1,
  282. 1 => 2,
  283. 2 => 3,
  284. 3 => 34,
  285. 4 => 5,
  286. 5 => 6,
  287. 6 => 6,
  288. ),
  289. 'expire' => 0,
  290. 'mtime' => 1318224645,
  291. )
  292. ?>
  293. *
  294. *
  295. */
  296. cache::setCacheMode('2');
  297. if(!$row = cache::get('zj2'))
  298. {
  299. $array = array(1,2,3,34,5,6,6);
  300. $row = cache::set('zj2',$array);
  301. }
  302. // cache::flush(); 清空所有缓存
  303. print_r($row);

文件缓存 class，代码如下:

  1. <?php
  2. /**
  3. * 文件缓存类
  4. * @date 2011-08-17
  5. */
  6. class cache
  7. {
  8. const FILE_LIFE_KEY = 'FILE_LIFE_KEY';
  9. const CLEAR_ALL_KEY = 'CLEAR_ALL';
  10. static $_instance = null;
  11. protected $_options = array(
  12. 'cache_dir' => './cache',
  13. 'file_locking' => true,
  14. 'file_name_prefix' => 'cache',
  15. 'cache_file_umask' => 0777,
  16. 'file_life' => 100000
  17. );
  18. static function &getInstance($options = array())
  19. {
  20. if(self::$_instance === null)
  21. {
  22. self::$_instance = new self($options);
  23. }
  24. return self::$_instance;
  25. }
  26. /**
  27. * 设置参数
  28. * @param array $options 缓存参数
  29. * @return void
  30. */
  31. static function &setOptions($options = array())
  32. {
  33. return self::getInstance($options);
  34. }
  35. /**
  36. * 构造函数
  37. * @param array $options 缓存参数
  38. * @return void
  39. */
  40. private function __construct($options = array())
  41. {
  42. if ($this->_options['cache_dir'] !== null) {
  43. $dir = rtrim($this->_options['cache_dir'],'/') . '/';
  44. $this->_options['cache_dir'] = $dir;
  45. if (!is_dir($this->_options['cache_dir'])) {
  46. mkdir($this->_options['cache_dir'],0777,TRUE);
  47. }
  48. if (!is_writable($this->_options['cache_dir'])) {
  49. exit('file_cache: 路径 "'. $this->_options['cache_dir'] .'" 不可写');
  50. }
  51. } else {
  52. exit('file_cache: "options" cache_dir 不能为空 ');
  53. }
  54. }
  55. /**
  56. * 设置缓存路径
  57. * @param string $value
  58. * @return void
  59. */
  60. static function setCacheDir($value)
  61. {
  62. $self = & self::getInstance();
  63. if (!is_dir($value)) {
  64. exit('file_cache: ' . $value.' 不是一个有效路径 ');
  65. }
  66. if (!is_writable($value)) {
  67. exit('file_cache: 路径 "'.$value.'" 不可写');
  68. }
  69. $value = rtrim($this->_options['cache_dir'],'/') . '/';
  70. $self->_options['cache_dir'] = $value;
  71. }
  72. /**
  73. * 存入缓存数据
  74. * @param array $data 放入缓存的数据
  75. * @param string $id 缓存id(又名缓存识别码)
  76. * @param cache_life 缓存时间
  77. * @return boolean True if no problem
  78. */
  79. static function save($data, $id = null, $cache_life = null)
  80. {
  81. $self = & self::getInstance();
  82. if (!$id) {
  83. if ($self->_id) {
  84. $id = $self->_id;
  85. } else {
  86. exit('file_cache:save() id 不能为空!');
  87. }
  88. }
  89. $time = time();
  90. if($cache_life) {
  91. $data[self::FILE_LIFE_KEY] = $time + $cache_life;
  92. }
  93. elseif
  94. ($cache_life != 0){
  95. $data[self::FILE_LIFE_KEY] = $time + $self->_options['file_life'];
  96. }
  97. $file = $self->_file($id);
  98. $data = "<?phpn".
  99. " // mktime: ". $time. "n".
  100. " return ".
  101. var_export($data, true).
  102. "n?>"
  103. ;
  104. $res = $self->_filePutContents($file, $data);
  105. return $res;
  106. }
  107. /**
  108. * 得到缓存信息
  109. *
  110. * @param string $id 缓存id
  111. * @return string|array 缓存数据
  112. */
  113. static function load($id)
  114. {
  115. $self = & self::getInstance();
  116. $time = time();
  117. //检测缓存是否存在
  118. if (!$self->test($id)) {
  119. // The cache is not hit !
  120. return false;
  121. }
  122. //全部清空识别文件
  123. $clearFile = $self->_file(self::CLEAR_ALL_KEY);
  124. $file = $self->_file($id);
  125. //判断缓存是否已被全部清除
  126. if(is_file($clearFile) && filemtime($clearFile) > filemtime($file))
  127. {
  128. return false;
  129. }
  130. $data = $self->_fileGetContents($file);
  131. if(emptyempty($data[self::FILE_LIFE_KEY]) || $time < $data[self::FILE_LIFE_KEY]) {
  132. unset($data[self::FILE_LIFE_KEY]);
  133. return $data;
  134. }
  135. return false;
  136. }
  137. /**
  138. * 写入缓存文件
  139. *
  140. * @param string $file 缓存路径
  141. * @param string $string 缓存信息
  142. * @return boolean true 成功
  143. */
  144. protected function _filePutContents($file, $string)
  145. {
  146. $self = & self::getInstance();
  147. $result = false;
  148. $f = @fopen($file, 'ab+');
  149. if ($f) {
  150. if ($self->_options['file_locking']) @flock($f, LOCK_EX);
  151. fseek($f, 0);
  152. ftruncate($f, 0);
  153. $tmp = @fwrite($f, $string);
  154. if (!($tmp === false)) {
  155. $result = true;
  156. }
  157. @fclose($f);
  158. }
  159. @chmod($file, $self->_options['cache_file_umask']);
  160. return $result;
  161. }
  162. /**
  163. * 格式化后的缓存文件路径
  164. *
  165. * @param string $id 缓存id
  166. * @return string 缓存文件名(包括路径)
  167. */
  168. protected function _file($id)
  169. {
  170. $self = & self::getInstance();
  171. $fileName = $self->_idToFileName($id);
  172. return $self->_options['cache_dir'] . $fileName;
  173. }
  174. /**
  175. * 格式化后的缓存文件名字
  176. *
  177. * @param string $id 缓存id
  178. * @return string 缓存文件名
  179. */
  180. protected function _idToFileName($id)
  181. {
  182. $self = & self::getInstance();
  183. $self->_id = $id;
  184. $prefix = $self->_options['file_name_prefix'];
  185. $result = $prefix . '---' . $id;
  186. return $result;
  187. }
  188. /**
  189. * 判断缓存是否存在
  190. *
  191. * @param string $id Cache id
  192. * @return boolean True 缓存存在 False 缓存不存在
  193. */
  194. static function test($id)
  195. {
  196. $self = & self::getInstance();
  197. $file = $self->_file($id);
  198. if (!is_file($file)) {
  199. return false;
  200. }
  201. return true;
  202. }
  203. /**
  204. * 得到缓存信息
  205. *
  206. * @param string $file 缓存路径
  207. * @return string 缓存内容
  208. */
  209. protected function _fileGetContents($file)
  210. {
  211. if (!is_file($file)) {
  212. return false;
  213. }
  214. return include $file;
  215. }
  216. /**
  217. * 清除所有缓存
  218. *
  219. * @return void
  220. */
  221. static function clear()
  222. {
  223. $self = & self::getInstance();
  224. $self->save('CLEAR_ALL',self::CLEAR_ALL_KEY);
  225. }
  226. /**
  227. * 清除一条缓存
  228. *
  229. * @param string cache id
  230. * @return void
  231. */
  232. static function del($id)
  233. {
  234. $self = & self::getInstance();
  235. if(!$self->test($id)){
  236. // 该缓存不存在
  237. return false;
  238. }
  239. $file = $self->_file($id);
  240. return unlink($file);
  241. }
  242. }

存入数据，代码如下:

  1. <?php
  2. $config = array(
  3. 'name' => 'xiaojiong',
  4. 'qq' => '290747680',
  5. 'age' => '20',
  6. );
  7. //第一个参数 缓存data
  8. //第二个参数 缓存id
  9. //第三个参数 cache_life 0 永不过期(cache::clear()清空所有除外) 默认cache_life 为option_cache_life
  10. cache::save($config,'config',0);

载入数据，代码如下:

  1. <?php
  2. //只有一个参数 cache_id
  3. $config = cache::load('config');
  4. 清空缓存
  5. <?php
  6. //清空指定缓存
  7. cache::del('config');
  8. //清空所有缓存
  9. cache::clear();
  10. cache信息配置
  11. //在执行所有cache_func前调用
  12. $_options = array(
  13. 'cache_dir' => './cache', //缓存文件目录
  14. 'file_name_prefix' => 'cache',//缓存文件前缀
  15. 'file_life' => 100000, //缓存文件生命
  16. );
  17. cache::setOptions($options);
  18. //再执行 就会按着新配置信息执行，否则是默认信息
  19. cache::save($arr,'arr');

这个方法貌似不合理，感兴趣的朋友可以加以改进。希望本文所述对大家的PHP程序设计有所帮助。

赞 (8)
上一篇10-29
下一篇 11-5

相关推荐

  • 简单的php缓存类分享

    简单的php缓存类分享这篇文章主要介绍了一个php缓存类,文件名使用md5加密，大家参考使用吧代码如下:<?phpclassCache{private$dir="data/cache/";//定义缓存目录private$key='c_…
    •php会话
    2015-02-139501

  • 汇总PHP编程中常用到的PHP类库

    汇总PHP编程中常用到的PHP类库图表库下面的类库可以让你很简的创建复杂的图表和图片。当然，它们需要GD库的支持。pChart-一个可以创建统计图的库。Libchart-这也是一个简单的统计图库。JpGraph–一个面向对象的图片创建类。O…
    •php类库
    2015-11-254369

  • 汇总PHP编程中常用到的PHP类库

    汇总PHP编程中常用到的PHP类库图表库下面的类库可以让你很简的创建复杂的图表和图片。当然，它们需要GD库的支持。pChart-一个可以创建统计图的库。Libchart-这也是一个简单的统计图库。JpGraph–一个面向对象的图片创建类。O…
    •php类库
    2016-07-314961

  • PHP 数据库缓存Memcache操作类

    操作类就是把一些常用的一系列的数据库或相关操作写在一个类中,这样调用时我们只要调用类文件,如果要执行相关操作就直接调用类文件中的方法函数就可以实现了,下面整理了一个Memcache数据缓存操作类库文件,希望对各位会有帮助了.PHP数据库缓存Memcache操作类代码如下:classmemcachedInit{private$memcache;/***Memcache缓存-设置缓存*设置缓存key，…
    •php类库
    2023-06-05288

  • php将数组存储为文本文件方法汇总

    这篇文章主要介绍了php将数组存储为文本文件的三种方法，每个方法都有利弊，需要的朋友可以参考下。php缓存数组形式的变量，实际上就是将php将数组写入到一个文本文件或者后缀名为.php存储起来，使用的时候直接调用这个文件。那么如何使用php将数组保存为文本格式的文件呢？下面分享三种方法实现将php数组写入到文件以缓存数组。（1）利用serialize将数组序列化存储为文本文件，调用时候再使用uns…
    •php数组
    2023-07-25273

  • php上传文件问题汇总

    这篇文章主要给大家汇总介绍了一些php上传文件问题,需要的朋友可以参考下1.先做个最简单的上传文件，代码如下:<html><head><metahttp-equiv="Content-Type"content="text/html;charset=utf-8"></head><body><formaction="upload_fil…
    •php上传下载
    2023-08-09143

  • PHP文件缓存类实现代码

    这篇文章主要介绍了PHP文件缓存类实现代码，php中缓存分类数据库缓存，文件缓存和内存缓存，对php缓存感兴趣的朋友可以学习学习下面的文章。php中缓存分类数据库缓存，文件缓存和内存缓存，下面我来给各位同学详细介绍PHP文件缓存类实现代码，有需要了解的朋友可参考。页面缓存类：<?php/*include("cache.php");$cache=newcache(30);$cache->…
    •php文件操作
    2023-08-20243

  • PHP文件操作方法汇总

    这篇文章主要介绍了PHP文件操作方法汇总的相关资料,需要的朋友可以参考下在data文件中写入数据：<?php/***CreatedbyPhpStorm.*User:Administrator*Date:2015/6/29*Time:17:05*/header("Content-type:text/html;charset=utf-8");//writedata$f=fopen('data',…
    •php文件操作
    2023-08-21264