php利用file_get_contents批量采集网站内容

file_get_contents函数是一个可以读取本地与远程服务器文件的函数了，下面我们就来介绍利用file_get_contents做一个小的采集功能。

[root@web20 php]# base64 --helpUsage: base64 [OPTION] [FILE]Base64 encode or decode FILE, or standard input, to standard output.-w, --wrap=COLS       Wrap encoded lines after COLS character (default 76).Use 0 to disable line wrapping.-d, --decode          Decode data.-i, --ignore-garbage  When decoding, ignore non-alphabet characters.--help            Display this help and exit.--version         Output version information and exit.如果[文件]缺省，或者[文件]为 - ，则读取标准输入。The data are encoded as described for the base64 alphabet in RFC 3548.Decoding require compliant input by default, use --ignore-garbage to
attempt to recover from non-alphabet characters (such as newlines) in
the encoded stream.

%20%20%5B%E8%AF%86%E8%AE%B0%5D%E4%BC%9A%E8%AE%A1%E7%9A%84%E6%B6%B5%E4%B9%89%E6%98%AF%E4%BB%80%E4%B9%88%EF%20%20

http://www.baidu.com/s?word=%B2%E2%CA%D4&tn=sitehao123

<?php
for ($i=18291; $i<=18788 ;$i++ ){
$content = file_get_contents("http://www.XXX.com/test.php?wiki_id=".$i);//echo $content;
$spwt1=explode("问题：",$content);
$spwt2=explode('));<',$spwt1[1]);
$spdn=explode("答案：",$spwt2[1]);//echo $spwt2[0];//echo $spdn[1];
preg_match('/base64decode("(.*?)"/',$spwt2[0],$matchesw);
$wen=urldecode(base64_decode($matchesw[1]));
echo $wen;
echo "n";
echo "n";
preg_match('/base64decode("(.*?)"/',$spdn[1],$matchesd);
$da=urldecode(base64_decode($matchesd[1]));
echo $da;}?>

下面来给各位介绍PHP实现数组按数组方式访问和对象方式访问例子，希望下文可以帮助到大家．

如何实现如下需求：

$data = array('x' => 'xx', 'y' => 'yy');
echo $data['x'];//输出xx
echo $data->x;//输出xx

方法一：构造一个类，实现ArrayAccess接口和__get,__set魔术方法

class Test implements ArrayAccess {
    private $data = null;
    public function __construct($data){
        $this->data = $data;
    }
    public function offsetGet($offset){
        return ($this->offsetExists($offset) ? $this->data[$offset] : null);
    }
    public function offsetSet($offset, $value){
        $this->data[$offset] = $value;
    }
    public function offsetExists($offset){
        return isset($this->data[$offset]);
    }
    public function offsetUnset($offset){
        if($this->offsetExists($offset)){
            unset($this->data[$offset]);
        }
    }
    public function __get($offset){
        return ($this->offsetExists($offset) ? $this->data[$offset] : null);
    }
    public function __set($offset, $value){
        $this->data[$offset] = $value;
    }
}

测试代码

$data = array('x' => 'x', 'y' => 'y');
$t = new Test($data);
printf("数组方式访问(＼$t['x'])输出：%s <br />", $t['x']);
printf("对象方式访问(＼$t->y)输出：%s <br />", $t->y);
//数组方式赋值，对象方式访问
$t['x1'] = 'x1';
printf("数组方式赋值%s <br />", "＼$t['x1']='x1'");
printf("对象方式访问(＼$t->x1)输出：%s <br />", $t->x1);
//对象方式赋值，数组方式访问
$t->y1 = 'y1';
printf("对象方式赋值%s <br />", "＼$t->y1='y1'");
printf("数组方式访问(＼$t['y1'])输出：%s <br />", $t['y1']);

方法二

$data = array('x' => 'x', 'y' => 'y');
$t = new ArrayObject($data, ArrayObject::ARRAY_AS_PROPS);
printf("数组方式访问(＼$t['x'])输出：%s <br />", $t['x']);
printf("对象方式访问(＼$t->y)输出：%s <br />", $t->y);
//数组方式赋值，对象方式访问
$t['x1'] = 'x1';
printf("数组方式赋值%s <br />", "＼$t['x1']='x1'");
printf("对象方式访问(＼$t->x1)输出：%s <br />", $t->x1);
//对象方式赋值，数组方式访问
$t->y1 = 'y1';
printf("对象方式赋值%s <br />", "＼$t->y1='y1'");
printf("数组方式访问(＼$t['y1'])输出：%s <br />", $t['y1']);
测试结果

Session在开发中是非常重要的一个数据存储变量了，它可以实现不同页面之间的传值了，下面我们来为各位介绍在使用Session时碰到过期无效的一些问题吧．

PHP开发过程中，可能有朋友经常会遇到Session所产生的文件无法自动清除的问题，其实并非真的无法清除，而是有一个概率问题，只要你的站点访问量足够大，那些文件就可以自动被清除掉。如果访问量比较少，又看那些文件不顺眼的话，只要在php.ini里的配置一下即可实现Session文件自动清除的功能，具体配置如下：

找到

session.gc_probability = 1

session.gc_divisor = 1000

上面这两项参数其实就是这个概率，默认情况下是1/1000

将 session.gc_divisor = 1000  改为 session.gc_divisor = 100 即可

如果想达到完全的实时，那么可以把这个参数改为1，这样概率就是100%了

看看session如何工作的

概述：每一次php请求，会有1/100的概率（默认值）触发“session回收”。如果“session回收”发生，那就会检查/tmp/sess_*的文件，如果最后的修改时间到现在超过了1440秒（gc_maxlifetime的值），就将其删除，意味着这些session过期失效。

1. session在server端（一般是Apache with PHP module）如何存在的？

默认的，php会将session保存在/tmp目录下，文件名为这个样子：sess_01aab840166fd1dc253e3b4a3f0b8381。每一个文件对应了一个session（会话）。
more /tmp/sess_01aab840166fd1dc253e3b4a3f0b8381
username|s:9:”jiangfeng”;admin|s:1:”0〃;
#变量名|类型:长度:值
删除这里的session文件，就表示对应的session失效了。
2. session在client端（一般是浏览器）如何存在的？

session在浏览器端，只需要保存session ID（由server端生成的唯一ID）就可以了。有两种保存方式：在cookie中、在url里面。如果cookie中保存session ID，就可以看到浏览器的cookie中有一个PHPSESID变量。如果是URL传递的，就可以看到形如:
index.php?PHPSESID=01aab840166fd1dc253e3b4a3f0b8381的URL。（在server端通过session.use_cookies来控制使用哪一种方式）

3. 在server端，php如何判断session文件是否过期？

如果”最后的修改时间”到”现在”超过了gc_maxlifetime（默认是1440）秒，这个session文件就被认为是过期了，在下一次session回收的时候，如果这个文件仍然没有被更改过，这个session文件就会被删除（session就过期了）。
简单的说，如果我登录到某网站，如果在1440秒（默认值）内没有操作过，那么对应的session就认为是过期了。
所以，修改php.ini文件中的gc_maxlifetime变量就可以延长session的过期时间了：（例如，我们把过期时间修改为86400秒）
session.gc_maxlifetime = 86400
然后，重启你的web服务（一般是apache）就可以了。
注意：php5里面session过期使用了回收机制。这里设置时间为86400秒，如果session在86400秒内没有被修改过，那么在下一次“回收”时才真的被删除。

3. session“回收”何时发生？

默认情况下，每一次php请求，就会有1/100的概率发生回收，所以可能简单的理解为“每100次php请求就有一次回收发生”。这个概率是通过以下参数控制的
#概率是gc_probability/gc_divisor
session.gc_probability = 1
session.gc_divisor = 100
注意1：假设这种情况gc_maxlifetime=120，如果某个session文件最后修改时间是120秒之前，那么在下一次回收（1/100的概率）发生前，这个session仍然是有效的。
注意2：如果你的session使用session.save_path中使用别的地方保存session，session回收机制有可能不会自动处理过期session文件。这时需要定时手动（或者crontab）的删除过期的session：cd /path/to/sessions; find -cmin +24 | xargs rm

4. 一些特殊情况

因为回收机制会检查文件的“最后修改时间”，所以如果某个会话是活跃的，但是session的内容没有改变过，那么对应的session文件也就没有改变过，回收机制会认为这是一个长时间没有活跃的session而将其删除。这是我们不愿看到的，可以通过增加如下的简单代码解决这个问题：
<?php if(!isset($_SESSION['last_access'])||(time()-$_SESSION['last_access'])>60) $_SESSION['last_access'] = time(); ?>
代码会每隔60秒，尝试修改修改一次session。
总结：如果想修改session过期时间，修改变量gc_maxlifetime就可以了。php5的session采用被动的回收机制（garbage collection）。过期的session文件不会自己消失，而是通过触发“回收”来处理过期的session。

我们下面来详细看看一些其它的设置session时间的问题

Session 过期时间参数

设定过期时间参数, 主要是设定 session.gc_maxlifetime 的参数即可, 再保险一点的设定, 就设定下面这两个参数.

ini_set('session.cookie_lifetime', 0); // 可用 print_r(session_get_cookie_params()); 观察
ini_set('session.gc_maxlifetime', 3600); // 可用 echo ini_get("session.gc_maxlifetime"); 观察
session_cookie_lifetime 设为 0 的话, 代表等到 browser 才把此 cookie 清掉.(session 和 browser cookie 是有相关的)

如果懒得想这些, 直接用下面的 function 就可以了~ :P

Session 过期时间程式

下述程式转载自: Cross-Browser Session Starter

<?php
function start_session($expire = 0)
{
    if ($expire == 0) {
        $expire = ini_get('session.gc_maxlifetime');
    } else {
        ini_set('session.gc_maxlifetime', $expire);
    }

    if (empty($_COOKIE['PHPSESSID'])) {
        session_set_cookie_params($expire);
        session_start();
    } else {
        session_start();
        setcookie('PHPSESSID', session_id(), time() + $expire);
    }
}
?>

使用方式

于程式最上方加入: start_session(600); // 代表 600 秒后会过期 (取代原本 session_start())
如果要再延长过期时间, 只要再做修改即可.

但是有个问题要注意, 就是 PHP 的 session 预设是存成 file, 所以 /tmp 可能会因这样设定而爆掉(档案太多), 通常解法是把 session 存进 DB/memcache 中.

在php中array_search和in_array函数都是用来查找数组中的值了，那么这们两他们的区别是什么呢？下面小编为各位介绍一下吧．

array_search和in_array都可以用来查找值是否存在与数组中，顾名思义，一个是搜寻数组，一个是判断是否在数组，array_search和in_array有什么区别呢？以及性能上有什么差异？

in_array用法

参数	描述
value	必需。规定要在数组搜索的值。
array	必需。规定要搜索的数组。
type	可选。如果设置该参数为 true，则检查搜索的数据与数组的值的类型是否相同。

array_search示例：

$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');
 
$key = array_search('green', $array); // $key = 2;
$key = array_search('red', $array);   // $key = 1;
第一个参数是要查找的值，第二个参数是数组，它返回的是查找到的值的“键”。而in_array只能判断是否存在，返回布尔值。在效率上in_array与array_search效率几乎相同，in_array仅返回真伪，array_search同时返回

array_search语法

参数	描述
value	必需。规定在数组中搜索的值。
array	必需。被搜索的数组。
strict	可选。可能的值： true false - 默认 如果值设置为 true，还将在数组中检查给定值的类型。（参见例子 2）

再如：

public function add_rewrite_tag( $tag, $regex, $query ) {
 $position = array_search( $tag, $this->rewritecode );
 if ( false !== $position && null !== $position ) {
  $this->rewritereplace[ $position ] = $regex;
  $this->queryreplace[ $position ] = $query;
 } else {
  $this->rewritecode[] = $tag;
  $this->rewritereplace[] = $regex;
  $this->queryreplace[] = $query;
 }
}

利用array_search返回位置，可以直接存放到需要标记位置的数组中。

Hash算法我们多少会了解一点了，下面来介绍利用php实现Hash表的一个例子，希望这些例子可以给各位带来帮助。

  Hash表作为最重要的数据结构之一，也叫做散列表。使用PHP实现Hash表的功能。PHP可以模拟实现Hash表的增删改查。通过对key的映射到数组中的一个位置来访问。映射函数叫做Hash函数，存放记录的数组称为Hash表。
Hash函数把任意长度的和类型的key转换成固定长度输出。不同的key可能拥有相同的hash。
Hash表的时间复杂度为O(1)

代码如下

复制代码

<?php class HashTable{     private $arr = array();     private $size = 10;     public function __construct(){         //SplFixedArray创建的数组比一般的Array()效率更高，因为更接近C的数组。创建时需要指定尺寸         $this->arr = new SplFixedArray($this->size);     }     /**      * Description: 简单hash算法。输入key，输出hash后的整数      * @param $key      * @return int      */     private function simpleHash($key){         $len = strlen($key);         //key中每个字符所对应的ASCII的值         $asciiTotal = 0;         for($i=0; $i<$len; $i++){             $asciiTotal += ord($key[$i]);         }         return $asciiTotal % $this->size;     }     /**      * Description: 赋值      * @param $key      * @param $value      * @return bool      */     public function set($key, $value){         $hash = $this->simpleHash($key);         $this->arr[$hash] = $value;         return true;     }     /**      * Description: 取值      * @param $key      * @return mixed      */     public function get($key){         $hash = $this->simpleHash($key);         return $this->arr[$hash];     }     public function getList(){         return $this->arr;     }     public function editSize($size){         $this->size = $size;         $this->arr->setSize($size);     } } ?>

下面对我们的HashTable进行测试。

代码如下

复制代码

<?php //测试1 $arr = new HashTable(); for($i=0; $i<15; $i++){     $arr->set('key'.$i, 'value'.$i); } print_r($arr->getList()); //SplFixedArray Object //( //    [0] => value14 //    [1] => value4 //    [2] => value5 //    [3] => value6 //    [4] => value7 //    [5] => value8 //    [6] => value10 //    [7] => value11 //    [8] => value12 //    [9] => value13 //) //不同的key可能产生相同的hash值，那么赋值的时候后操作会覆盖前操作。 //测试2 $arr->editSize(15); for($i=0; $i<15; $i++){     $arr->set('key'.$i, 'value'.$i); } print_r($arr->getList()); //SplFixedArray Object //( //    [0] => value14 //    [1] => value4 //    [2] => value0 //    [3] => value1 //    [4] => value2 //    [5] => value3 //    [6] => value10 //    [7] => value11 //    [8] => value12 //    [9] => value13 //    [10] => value14 //    [11] => value9 //    [12] => //    [13] => //    [14] => //) ?>

改变了值之后可以存放更多的元素。但是仍然存在不同的key可能产生相同的hash值，那么赋值的时候后操作会覆盖前操作的问题。这种冲突的问题我们来用拉链法解决。

    拉链法解决冲突。拉链法解决冲突的做法是将所有的相同Hash值的key放在一个链表中，比如key3和key14在hash之后都是0，那么在数组的键为0的地方存储这两个值，形式是链表。如果不能理解我的文字，请看下面的示例，看一下打印信息就明白了。拉链法是什么，就是链表。
    创建一个HashNode类，用来存储key和value的值，并且存储相同hash的另一个元素。在同一条链上，查找越后的元素越费时。时间复杂度为O(n).

代码如下

复制代码

<?php class HashNode{     public $key;     public $value;     public $nextNode;     public function __construct($key, $value, $nextNode=Null){         $this->key = $key;         $this->value = $value;         $this->nextNode = $nextNode;     } } class NewHashTable{     private $arr;     private $size = 10;     public function __construct(){         $this->arr = new SplFixedArray($this->size);     }     private function simpleHash($key){         $asciiTotal = 0;         $len = strlen($key);         for($i=0; $i<$len; $i++){             $asciiTotal += ord($key[$i]);         }         return $asciiTotal % $this->size;     }     public function set($key, $value){         $hash = $this->simpleHash($key);         if(isset($this->arr[$hash])){             $newNode = new HashNode($key, $value, $this->arr[$hash]);         }else{             $newNode = new HashNode($key, $value, null);         }         $this->arr[$hash] = $newNode;         return true;     }     public function get($key){         $hash = $this->simpleHash($key);         $current = $this->arr[$hash];         while(!empty($current)){             if($current->key == $key){                 return $current->value;             }             $current = $current->nextNode;         }         return NULL;     }     public function getList(){         return $this->arr;     } } ?>

对我们新的HashTable进行测试

代码如下

复制代码

<?php //测试1 $newArr = new NewHashTable(); for($i=0; $i<30; $i++){     $newArr->set('key'.$i, 'value'.$i); } print_r($newArr->getList()); var_dump($newArr->get('key3')); //SplFixedArray Object //( //    [0] => HashNode Object //( //    [key] => key23 //            [value] => value23 //            [nextNode] => HashNode Object //( //    [key] => key14 //                    [value] => value14 //                    [nextNode] => HashNode Object //( //    [key] => key3 //                            [value] => value3 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [1] => HashNode Object //( //    [key] => key24 //            [value] => value24 //            [nextNode] => HashNode Object //( //    [key] => key15 //                    [value] => value15 //                    [nextNode] => HashNode Object //( //    [key] => key4 //                            [value] => value4 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [2] => HashNode Object //( //    [key] => key25 //            [value] => value25 //            [nextNode] => HashNode Object //( //    [key] => key16 //                    [value] => value16 //                    [nextNode] => HashNode Object //( //    [key] => key5 //                            [value] => value5 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [3] => HashNode Object //( //    [key] => key26 //            [value] => value26 //            [nextNode] => HashNode Object //( //    [key] => key17 //                    [value] => value17 //                    [nextNode] => HashNode Object //( //    [key] => key6 //                            [value] => value6 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [4] => HashNode Object //( //    [key] => key27 //            [value] => value27 //            [nextNode] => HashNode Object //( //    [key] => key18 //                    [value] => value18 //                    [nextNode] => HashNode Object //( //    [key] => key7 //                            [value] => value7 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [5] => HashNode Object //( //    [key] => key28 //            [value] => value28 //            [nextNode] => HashNode Object //( //    [key] => key19 //                    [value] => value19 //                    [nextNode] => HashNode Object //( //    [key] => key8 //                            [value] => value8 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [6] => HashNode Object //( //    [key] => key29 //            [value] => value29 //            [nextNode] => HashNode Object //( //    [key] => key10 //                    [value] => value10 //                    [nextNode] => HashNode Object //( //    [key] => key9 //                            [value] => value9 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [7] => HashNode Object //( //    [key] => key20 //            [value] => value20 //            [nextNode] => HashNode Object //( //    [key] => key11 //                    [value] => value11 //                    [nextNode] => HashNode Object //( //    [key] => key0 //                            [value] => value0 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [8] => HashNode Object //( //    [key] => key21 //            [value] => value21 //            [nextNode] => HashNode Object //( //    [key] => key12 //                    [value] => value12 //                    [nextNode] => HashNode Object //( //    [key] => key1 //                            [value] => value1 //                            [nextNode] => //                        ) // //                ) // //        ) // //    [9] => HashNode Object //( //    [key] => key22 //            [value] => value22 //            [nextNode] => HashNode Object //( //    [key] => key13 //                    [value] => value13 //                    [nextNode] => HashNode Object //( //    [key] => key2 //                            [value] => value2 //                            [nextNode] => //                        ) // //                ) // //        ) // //) //string(6) "value3" ?>