php 查找数组值程序

在php中查找数组中指定值的方法有很多，下面我来介绍php中数组查找函数in_array(),array_key_exists(),array_search()用法

查找一个元素是否在数组中，一共有上面三种做法：

in_array  '函数在数组中搜索给定的值。in_array(value,array,type)type 可选。如果设置该参数为 true，则检查搜索的数据与数组的值的类型是否相同。

array_key_exists 'array_key_exists() 函数判断某个数组中是否存在指定的 key，如果该 key 存在，则返回 true，否则返回 false。array_key_exists(key,array)

Example #1 array_key_exists() 例子

代码如下	复制代码
<?php $search_array = array('first' => 1, 'second' => 4); if (array_key_exists('first', $search_array)) {     echo "The 'first' element is in the array"; } ?>

Example #2 array_key_exists() 与 isset() 的对比

isset() 对于数组中为 NULL 的值不会返回 TRUE，而 array_key_exists() 会。

代码如下	复制代码
<?php $search_array = array('first' => null, 'second' => 4); // returns false isset($search_array['first']); // returns true array_key_exists('first', $search_array); ?>

mixed array_search ( mixed $needle, array $haystack [, bool $strict] )
第一个参数是需要查找的值，第二个参数是数组，最后一个参数是指查找的时候是否检查数据类型是否相同。

代码如下	复制代码
<?php $a=array("a"=>"Dog","b"=>"Cat","c"=>"Horse"); echo array_search("Dog",$a); ?> <?php $a=array("a"=>"5","b"=>5,"c"=>"5"); echo array_search(5,$a,true); ?> 上述代码将输出下面的结果： b

从这里来看，在数据量不大的时候，比如小于1000，查找用哪一种都行，都不会成为瓶颈；
当数据量比较大的时候，用array_key_exists比较合适。
当然这里array_key_exists占用的内存比较大，经测算
数组结构是： array(1, 2, 3, ..)和 array(1 => true, 2 => false, ..)
他们内存使用比值为1:2；

注意：array_key_exist，要比in_array效率高十几甚至几十倍

一个简单的算法

假设数组有1000个元素，键值为小于1000000的无序的正整数，且不连续，如下

$arr = array(1 => 'sadas', 20 => 'aasd', 5002 => 'fghfg', 190023 => 'rty', 248 => 'kj', 76 => 'sddd' ,...);

现在要获取数组$arr中键的值大于500小于600的元素，不用foreach完全循环一遍的话是否有更高效的算法？

解答

代码如下	复制代码
$result = array(); for($i = 501; $i < 600; $i++) {     if(!isset($arr[$i])) continue;     $result[] = $arr[$i]; }

想要对对象的属性进行一些设置，如果一个一个设置，会比较麻烦，这时可以使用对象的处理器函数__get()和__set()，不过使用这两个方法的前提，属性需要是protect或private的，如下例：

代码如下	复制代码
class Person {  private $__data = array();    public function __get($property)  {   if (isset($this->__data[$property]))   {    return $this->__data[$property];   }   else   {    return false;   }  }    public function __set($property, $value)  {   $this->__data[$property] = $value;  } }

__set()和__get()方法是针对protect或private属性的,这样可以做到在外界不能直接访问属性，而通过public定义的__set()和__get()方法却可以轻易访问它，同事这两个方法对属性的操作通用性也比较高，也可以限制对象的属性的合法性，只有属于$__data数组中的属性，才可以进行设置，可以防止外界直接对属性进行设置。但是使用__set()和__get()也有些不足之处。第一，这两个方法只会捕捉私有或受保护的属性，即是外界没有访问权限的属性，这样php会报一个致命错误；第二，这两个方法破坏了属性的继承性。如果父对象中有一个__set()方法，而在子类中又实现了自己的__get()方法，那么对象就不会正常的运行，因为父对象的__get()方法是永远调不到的，而且要想检测重写的属性是否存在也不能得到的，因为它不会调用__get()方法。见到有人通过实现__isset()和__unset()来解决上面的问题。代码如下：

 

代码如下	复制代码
public function __isset($property) {  if (isset($this->data[$property]))  {   return true;  }  else  {   return false;  } }   public function __unset($property) {  if (isset($this->data[$property]))  {   return unset($this->data[$property]);  }  else  {   return false;  } }

使用__isset()和__unset()则能保证属性是否真正存在，不过这两个方法只有在PHP5.1后才有效。

PHP中的session有效期默认是1440秒（24分钟）,如果我们要让session记不过期怎么办呢，下在我们先来介绍在不修改程序是最好的方法了，因为如果修改程序，测试部一定非常郁闷像我一样，那么只能修改系统环境配置，其实很简单，打开php.ini设置文件，

修改三行如下：

1、session.use_cookies
把这个的值设置为1，利用cookie来传递sessionid

2、session.cookie_lifetime
这个代表SessionID在客户端Cookie储存的时间，默认是0，代表浏览器一关闭SessionID就作废……就是因为这个所以PHP的session不能永久使用！ 那么我们把它设置为一个我们认为很大的数字吧，999999999怎么样，可以的！就这样。

3、session.gc_maxlifetime
这个是Session数据在服务器端储存的时间，如果超过这个时间，那么Session数据就自动删除！ 那么我们也把它设置为99999999

如果你不能修改php.ini文件

代码如下	复制代码
<?php session_start(); // 启动Session $_SESSION['count']; // 注册Session变量Count isset($PHPSESSID)?session_id($PHPSESSID):$PHPSESSID = session_id(); // 如果设置了$PHPSESSID，就将SessionID赋值为$PHPSESSID，否则生成SessionID   $_SESSION['count']++; // 变量count加1 setcookie('PHPSESSID', $PHPSESSID, time()+3156000); // 储存SessionID到Cookie中 echo $count; // 显示Session变量count的值 ?>

为了达到这种目的，必须保证整个项目有且只有一个实例存在并提供一个访问点供全局访问。这就需要通过调用此类的一个共用静态方法来访问这个实例，也就是说此类不能在类外面去实例化，只能在类内部实例，而且是只能通过共用的静态方法调用实例；

最近在看php高级程序设计、模式、框架与测试一书，颇有感悟，与大家分享：

在做项目时，通常我们希望某些类实例一次就够了，比如共用配置类,模板操作类,数据库连接等等，这些类因为在整个项目开发中是通用的，如果实例多次实例就会占用资源.

为了达到这种目的，必须保证整个项目有且只有一个实例存在并提供一个访问点供全局访问。这就需要通过调用此类的一个共用静态方法来访问这个实例，也就是说此类不能在类外面去实例化，只能在类内部实例，而且是只能通过共用的静态方法调用实例；

那么怎么保证此类不能在外面实例化呢？需要此单例类必须拥有一个构造函数__construct,且设置为private(因为已经有__construct,不考虑默认的构造方法：直接用类名的方法的情况)，这样就保证了不会在外面直接实例化！同时还需要声明一个静态方法变量来保存此类的实例，一个共用的静态方法来访问此实例，（因为要共用，所以声明为静态的，存放内存中的共用代码区部分）。还需要创建一个空的私有的__clone()方法，以防止被克隆。

一个很典型的单例类如下:

代码如下

复制代码

class Simple {  /**   * 单例类实例   *   * @static   * @var object Simple   */  public static $_instance;    //其他成员变量    /**   * 构造方法   *   * @return void   */  private  function __construct()  {   //写构造方法  }    /**   * 单例模式调用方法   *   * @static   * @return object Template   */  public static function getInstance()  {   if (!self::$_instance instanceof self)    self::$_instance = new self();   return self::$_instance;  }    /**   * 声明一个空的私有克隆方法   *   */          private  function __clone()         {         }    //其他方法 }   //调用方式 $Simple = Simple::getInstance(); ?>

上面用到了 instanceof关键字，为比较操作符，返回布尔能够判断某个对象实例是否为制定的类型，或者是否从某个类继承，或者是否实现了某个特定接口

为了确保操作的有效性和完整性，可以通过锁机制将并发状态转换成串行状态。作为锁机制中的一种，PHP的文件锁也是为了应对资源竞争。假设一个应用场景，在存在较大并发的情况下，通过fwrite向文件尾部多次有序的写入数据，不加锁的情况下会发生什么？多次有序的写入操作相当于一个事务，我们此时需要保证这个事务的完整性。

bool flock ( int handle, int operation [, int &wouldblock] );
flock() 操作的 handle 必须是一个已经打开的文件指针。operation 可以是以下值之一：

1.要取得共享锁定（读取程序），将 operation 设为 LOCK_SH（PHP 4.0.1 以前的版本设置为 1）
2.要取得独占锁定（写入程序），将 operation 设为 LOCK_EX（PHP 4.0.1 以前的版本中设置为 2）
3.要释放锁定（无论共享或独占），将 operation 设为 LOCK_UN（PHP 4.0.1 以前的版本中设置为 3）
4.如果你不希望 flock() 在锁定时堵塞，则给 operation 加上 LOCK_NB（PHP 4.0.1 以前的版本中设置为 4）

建两个文件

代码如下	复制代码
(1) a.php ?$file = "temp.txt";     $fp = fopen($file , 'w');     if(flock($fp , LOCK_EX)){          fwrite($fp , "abcn");          sleep(10);          fwrite($fp , "123n");         flock($fp , LOCK_UN);     }     fclose($fp); (2) b.php ?$file = "temp.txt";     $fp = fopen($file , 'r');     echo fread($fp , 100);     fclose($fp);

运行 a.php 后，马上运行 b.php ，可以看到输出：
abc
等 a.php 运行完后运行 b.php ，可以看到输出：
abc
123
显然，当 a.php 写文件时数据太大，导致时间比较长时，这时 b.php 读取数据不完整

修改 b.php 为：

代码如下	复制代码
?$file = "temp.txt";     $fp = fopen($file , 'r');     if(flock($fp , LOCK_EX)){         echo fread($fp , 100);         flock($fp , LOCK_UN);     } else{         echo "Lock file failed...n";     }     fclose($fp);

运行 a.php 后，马上运行 b.php ，可以发现 b.php 会等到 a.php 运行完成后(即 10 秒后)才显示：
abc
123
读取数据完整，但时间过长，他要等待写锁释放。

修改 b.php 为：

代码如下	复制代码
?$file = "temp.txt";     $fp = fopen($file , 'r');     if(flock($fp , LOCK_SH | LOCK_NB)){         echo fread($fp , 100);         flock($fp , LOCK_UN);     } else{         echo "Lock file failed...n";     }     fclose($fp);

运行 a.php 后，马上运行 b.php ，可以看到输出：
Lock file failed…
证明可以返回锁文件失败状态，而不是向上面一样要等很久。

结论：

建议作文件缓存时，选好相关的锁，不然可能导致读取数据不完整，或重复写入数据。
file_get_contents 好像选择不了锁，不知道他默认用的什么锁，反正和不锁得到的输出一样，是不完整的数据。
我是要做文件缓存，所以只需要知道是否有写锁存在即可，有的话就查数据库就可以了。

多次同时执行，虽然都写了100行，但是事务1和事务2的数据交错写入，这并不是我们想要的结果。我们要的是事务完整的执行，此时我们需要有个机制去保证在第一个事务执行完后再执行第二个。在PHP中，flock函数完成了这一使命。在事物1和事务2的循环前面都加上： flock($fp, LOCK_EX); 就能满足我们的需求，将两个事务串行。

当某一个事务执行完flock时，因为我们在这里添加的是LOCK_EX（独占锁定），所以所有对资源的操作都会被阻塞，只有当事务执行完成后，后面的事务才会执行。我们可以通过输出当前的时间的方法来确认这一点。

关于在尾部追加写入，在unix系统的早期版本中存在一个并发写入的问题，如果要在尾部追加，需要先lseek位置，再write。当多个进程同时操作时，会因为并发导致的覆盖写入的问题，即两个进程同时获取尾部的偏移后，先后执行write操作，后面的操作会将前面的操作覆盖。这个问题在后面以添加打开时的O_APPEND操作而得到解决，它将查找和写入操作变成了一个原子操作。

在PHP的fopen函数的实现中，如果我们使用a参数在文件的尾部追加内容，其调用open函数中oflag参数为 O_CREAT|O_APPEND，即我们使用追加操作不用担心并发追加写入的问题。

在PHP的session默认存储实现中也用到了flock文件锁，当session开始时就调用PS_READ_FUNC，且以O_CREAT | O_RDWR | O_BINARY 打开session数据文件，此时会调用flock加上写锁，如果此时有其它进程访问此文件（即同一用户再次发起对当前文件的请求），就会显示页面加载中，进程被阻塞了。加写锁其出发点是为了保证此次会话中对session的操作事务能完整的执行，防止其它进程的干扰，保证数据的一致性。如果一个页面没有session修改操作，可以尽早的调用session_write_close()释放锁。

文件锁是针对文件的锁，除了这种释义，还可以理解为用文件作为锁。在实际工作中，有时为确保单个进程的执行，我们会在程序执行前判断文件是否存在，如果不存在则创建一个空文件，在进程结束后删除这个空文件，如果存在，则不执行。

但是什么时候使用lock_ex什么时候使用lock_sh呢？

读的时候：

如果不想出现dirty数据，那么最好使用lock_sh共享锁。可以考虑以下三种情况：
1. 如果读的时候没有加共享锁，那么其他程序要写的话（不管这个写是加锁还是不加锁）都会立即写成功。如果正好读了一半，然后被其他程序给写了，那么读的后一半就有可能跟前一半对不上（前一半是修改前的，后一半是修改后的）
2. 如果读的时候加上了共享锁（因为只是读，没有必要使用排他锁），这个时候，其他程序开始写，这个写程序没有使用锁，那么写程序会直接修改这个文件，也会导致前面一样的问题
3. 最理想的情况是，读的时候加锁(lock_sh),写的时候也进行加锁(lock_ex),这样写程序会等着读程序完成之后才进行操作，而不会出现贸然操作的情况

写的时候：
 
如果多个写程序不加锁同时对文件进行操作，那么最后的数据有可能一部分是a程序写的，一部分是b程序写的
如果写的时候加锁了，这个时候有其他的程序来读，那么他会读到什么东西呢？
1. 如果读程序没有申请共享锁，那么他会读到dirty的数据。比如写程序要写a,b,c三部分，写完a,这时候读读到的是a，继续写b，这时候读读到的是ab，然后写c，这时候读到的是abc.
2. 如果读程序在之前申请了共享锁，那么读程序会等写程序将abc写完并释放锁之后才进行读。