phpmyadmin添加普通用户管理账号图文教程

phpmyadmin是一款mysql图形管理的界面了，我们在此来为各位介绍在phpmyadmin增加mysql用户了，希望本文章可以给各位朋友带来帮助。

 

 

 

 

 

 

 

 

 

打印类实现原理很简单就是用户点击打印时把数据保存到数据库，然后由js来调用打印机来打印，如果打印完了把记录删除，再执行一条打印了，具体代码如下。

类实现想法是：先把要打印的数据都收集起来，在用js调用window打印函数。目前就使用于IE。

类提供打印排队功能。（PS,说白了就是一条一条读取数据）

代码如下

复制代码

class Wprint{      //收集打印代码      private $data = array();      //处理打印代码      private $handle;      public function __construct()     {        header("Content-type:text/html;charsetutf-8");        $this->link(); //链接数据库        $this->collect($_POST["username"],$_POST["content"],$_POST["ip"]);        $this->handle();      }       //链接数据库       private function link()      {         $link = mysql_connect('localhost', 'root', '123456');         mysql_select_db('shen', $link);         mysql_query('SET NAMES utf8');       }       //收集打印代码       private function collect($username,$content,$ip)       {          $code["username"] = $username;          $code["content"] = $this->check($content);          $code["ip"] = $ip;          $code["state"] = 0;          $code["priority"] = 0;          array_push($this->data,$code);//数据节点入栈       }       //处理打印代码入库       private function handle()       {         foreach($this->data as $value)         { $sql = "insert into print(username,content,ip,state,priority) values('{$value["username"]}','{$value["content"]}', '{$value["ip"]}','{$value["state"]}','{$value["priority"]}')";           $query = mysql_query($sql);           if($query)           {             $id = mysql_insert_id(); //获取最近insert操作得到的ID             echo "数据收集成功,正在排队打印,排队ID为".$id;             $this->num($id);           }           else           {            echo "数据收集失败,请3秒后再一次提交";           }         }       }        //检查传人数据是否为空       private function check($string)       {         if(strlen($string) == 0 || $string == " ")         {           echo "数据收集失败,打印内容为空";           exit;         }else         {           return $string;         }       }       //获取打印排队人数       private function num($id)       {         $sql = "select id from print where state=0 and id<".$id." order by id asc";         $query = mysql_query($sql);         $num = mysql_num_rows($query);         echo ",您前面还有".$num."个人在排队";       }       //打印数据       public function Yprint()       {          $sql = "select id,content from print where state=0 order by id asc limit 1";          $query = mysql_query($sql);          $row = mysql_fetch_array($query);          if(!empty($row["content"]))          {            echo "<script tyle=\"text/javascript\">                        window.print();                </script>";            $id = $row["id"];            $sql = "update print set state=1 where id=".$id;            mysql_query($sql);              echo "打印处理完成";          }else          {              echo $row["content"];          }       }    }

思想很简单，收集数据再一个一个处理。 这样就不仅解决了网络打印的问题，还避免了网络打印打印过程排队的问题

观察者模式也是php面向对象中的一个不常用的模式了，下面我们一起来看看php面向对象：观察者模式示例，希望对给各位带来帮助。

意图：

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新【GOF95】

又称为发布-订阅（Publish-Subscribe）模式、模型-视图（Model-View）模式、源-监听（Source-Listener）模式、或从属者(Dependents)模式

结构图：

 

主要角色

抽象主题（Subject）角色：主题角色将所有对观察者对象的引用保存在一个集合中，每个主题可以有任意多个观察者。抽象主题提供了增加和删除观察者对象的接口。

抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在观察的主题发生改变时更新自己。

具体主题（ConcreteSubject）角色：存储相关状态到具体观察者对象，当具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个具体子类实现。

具体观察者（ConcretedObserver）角色：存储一个具体主题对象，存储相关状态，实现抽象观察者角色所要求的更新接口，以使得其自身状态和主题的状态保持一致。

优点和缺点

优点：观察者和主题之间的耦合度较小，支持广播通信。

缺点：由于观察者并不知道其它观察者的存在，它可能对改变目标的最终代价一无所知。这可能会引起意外的更新。

适用场景

当一个抽象模型有两个方面，其中一个方面依赖于另一个方面。

当对一个对象的改变需要同时改变其它对象，而不知道具体有多少个对象待改变。

当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换句话说，你不希望这些对象是紧密耦合的。

实现代码

<?php
 
/**
* 观察者模式
 
* @package design pattern
*/
 
/**
* 抽象主题角色
*/
interface Subject {
 
    /**
     * 增加一个新的观察者对象
     * @param Observer $observer
     */
    public function attach(Observer $observer);
 
    /**
     * 删除一个已注册过的观察者对象
     * @param Observer $observer
     */
    public function detach(Observer $observer);
 
    /**
     * 通知所有注册过的观察者对象
     */
    public function notifyObservers();
}
 
/**
* 具体主题角色
*/
class ConcreteSubject implements Subject {
 
    private $_observers;
 
    public function __construct() {
        $this->_observers = array();
    }
 
    /**
     * 增加一个新的观察者对象
     * @param Observer $observer
     */
    public function attach(Observer $observer) {
        return array_push($this->_observers, $observer);
    }
 
    /**
     * 删除一个已注册过的观察者对象
     * @param Observer $observer
     */
    public function detach(Observer $observer) {
        $index = array_search($observer, $this->_observers);
        if ($index === FALSE || ! array_key_exists($index, $this->_observers)) {
            return FALSE;
        }
 
        unset($this->_observers[$index]);
        return TRUE;
    }
 
    /**
     * 通知所有注册过的观察者对象
     */
    public function notifyObservers() {
        if (!is_array($this->_observers)) {
            return FALSE;
        }
 
        foreach ($this->_observers as $observer) {
            $observer->update();
        }
 
        return TRUE;
    }
 
}
 
/**
* 抽象观察者角色
*/
interface Observer {
 
    /**
     * 更新方法
     */
    public function update();
}
 
class ConcreteObserver implements Observer {
 
    /**
     * 观察者的名称
     * @var <type>
     */
    private $_name;
 
    public function __construct($name) {
        $this->_name = $name;
    }
 
    /**
     * 更新方法
     */
    public function update() {
        echo 'Observer', $this->_name, ' has notified.<br />';
    }
 
}
 
   $subject = new ConcreteSubject();
 
        /* 添加第一个观察者 */
        $observer1 = new ConcreteObserver('Martin');
        $subject->attach($observer1);
 
        echo '<br /> The First notify:<br />';
        $subject->notifyObservers();
 
        /* 添加第二个观察者 */
        $observer2 = new ConcreteObserver('phppan');
        $subject->attach($observer2);
 
        echo '<br /> The Second notify:<br />';
        $subject->notifyObservers();
 
        /* 删除第一个观察者 */
        $subject->detach($observer1);
 
        echo '<br /> The Third notify:<br />';
        $subject->notifyObservers();

工厂模式是什么？是不是在工厂做事呢？我相信有一些朋友对于php工厂模式还是有一些不理解，下文整理一些关于工厂模式例子。

简单工厂模式：

①抽象基类：类中定义抽象一些方法，用以在子类中实现
②继承自抽象基类的子类：实现基类中的抽象方法
③工厂类：用以实例化对象

 

先看一种代码:

<?php
    class Calc{
        /**
         * 计算结果
         *
         * @param int|float $num1
         * @param int|float $num2
         * @param string $operator
         * @return int|float
         */
        public function calculate($num1,$num2,$operator){
            try {
                $result=0;
                switch ($operator){
                    case '+':
                        $result= $num1+$num2;
                        break;
                    case '-':
                        $result= $num1-$num2;
                        break;
                    case '*':
                        $result= $num1*$num2;
                        break;
                    case '/':
                        if ($num2==0) {
                            throw new Exception("除数不能为0");
                        }
                        $result= $num1/$num2;
                        break;
                }
            return $result;
            }catch (Exception $e){
                echo "您输入有误:".$e->getMessage();
            }
        }
    }
    $test=new Calc();
//    echo $test->calculate(2,3,'+');//打印:5
    echo $test->calculate(5,0,'/');//打印:您输入有误:除数不能为0
?>
 

优点：以上代码使用了面向对象的封装特性，只要有了include这个类，其他页面就可以随便使用了

缺点：无法灵活的扩展和维护
比如：想要增加一个“求余”运算，需要在switch语句块中添加一个分支语句，代码需要再加一个case进行判断

于是产生了以下问题

①需要改动原有的代码块，可能会在为了“添加新功能”而改动原有代码的时候，不小心将原有的代码改错了
②如果要添加的功能很多，比如：‘乘方’，‘开方’，‘对数’，‘三角函数’，‘统计’，或者添加一些程序员专用的计算功能，比如：And, Or, Not, Xor，这样就需要在switch语句中添加N个分支语句。想象下，一个计算功能的函数如果有二三十个case分支语句，代码将超过一屏，不仅令代码的可读性大大降低，关键是，为了添加小功能，还得让其余不相关都参与解释，这令程序的执行效率大大降低。

解决途径：采用OOP的继承和多态思想

 <?php
     /**
      * 操作类
      * 因为包含有抽象方法，所以类必须声明为抽象类
      */
     abstract class Operation{
         //抽象方法不能包含函数体
         abstract public function getValue($num1,$num2);//强烈要求子类必须实现该功能函数
     }
     /**
      * 加法类
      */
     class OperationAdd extends Operation {
         public function getValue($num1,$num2){
             return $num1+$num2;
         }
     }
     /**
      * 减法类
      */
     class OperationSub extends Operation {
         public function getValue($num1,$num2){
             return $num1-$num2;
         }
     }
     /**
      * 乘法类
      */
     class OperationMul extends Operation {
         public function getValue($num1,$num2){
             return $num1*$num2;
         }
     }
     /**
      * 除法类
      */
     class OperationDiv extends Operation {
         public function getValue($num1,$num2){
             try {
                 if ($num2==0){
                     throw new Exception("除数不能为0");
                 }else {
                     return $num1/$num2;
                 }
             }catch (Exception $e){
                 echo "错误信息：".$e->getMessage();
             }
         }
     }
 ?>
 

 <?php
     /**
      * 操作类
      * 因为包含有抽象方法，所以类必须声明为抽象类
      */
     abstract class Operation{
         //抽象方法不能包含函数体
         abstract public function getValue($num1,$num2);//强烈要求子类必须实现该功能函数
     }
     /**
      * 加法类
      */
     class OperationAdd extends Operation {
         public function getValue($num1,$num2){
             return $num1+$num2;
         }
     }
     /**
      * 减法类
      */
     class OperationSub extends Operation {
         public function getValue($num1,$num2){
             return $num1-$num2;
         }
     }
     /**
      * 乘法类
      */
     class OperationMul extends Operation {
         public function getValue($num1,$num2){
             return $num1*$num2;
         }
     }
     /**
      * 除法类
      */
     class OperationDiv extends Operation {
         public function getValue($num1,$num2){
             try {
                 if ($num2==0){
                     throw new Exception("除数不能为0");
                 }else {
                     return $num1/$num2;
                 }
             }catch (Exception $e){
                 echo "错误信息：".$e->getMessage();
             }
         }
     }
 ?>
 

这里采用了面向对象的继承特性，首先声明一个虚拟基类，在基类中指定子类务必实现的方法（getValue()）

分析：通过采用面向对象的继承特性，我们可以很容易就能对原有程序进行扩展，比如:‘乘方’，‘开方’，‘对数’，‘三角函数’，‘统计’等等。

我们只需要另外写一个类（该类继承虚拟基类）,在类中完成相应的功能（比如：求乘方的运算）,而且大大的降低了耦合度，方便日后的维护及扩展.

现在还有一个问题未解决,就是如何让程序根据用户输入的操作符实例化相应的对象呢？
解决办法：使用一个单独的类来实现实例化的过程，这个类就是工厂.

<?php
    /**
     * 工程类，主要用来创建对象
     * 功能：根据输入的运算符号，工厂就能实例化出合适的对象
     *
     */
    class Factory{
        public static function createObj($operate){
            switch ($operate){
                case '+':
                    return new OperationAdd();
                    break;
                case '-':
                    return new OperationSub();
                    break;
                case '*':
                    return new OperationSub();
                    break;
                case '/':
                    return new OperationDiv();
                    break;
            }
        }
    }
    $test=Factory::createObj('/');
    $result=$test->getValue(23,0);
    echo $result;
?>

我对些的总结就是：根据传递的参数（对象）不同，调用不同的工厂（类）。然后用以实现指定的功能。比较大的好处就是简化了以前函数化编程的switch case,if else之类，进行类的分发，不同的东西调用不同的类。

插入排序是各种排名中一种了，今天小编就为各位介绍插入排序使用php来实现 了，有兴趣的朋友不防进来来看看吧。

排序算法的种类是多种多样，各有各的长处，这几天会一一进行分析。学习应该有一个先后递进的过程，从容易的开始。

先说比较简单的 — 插入排序（由PHP代码实现，这里不讲究效率！）

/**
* 插入排序 -- 比冒泡稍微复杂一点的排序算法 *
*
**/
 
$array = array('5','6','3','1','2','4');
 
/**
   * 插入排序1 -- 使用最暴力的排序
   *
**/
 
function insertSort($array)
    {
       $count = count($array); //先取出一个数据最为比较数据
       for($i=1;$i<$count;$i++)
       {
           $key = $array[$i];
           $j = $i-1;
           while($j>=0 && $array[$j]>$key)
          {
               $array[$j+1] = $array[$j];
               $j = $j-1;
               $array[$j+1] = $key;
            }
           var_dump($array);
      }
   }
 
 insertSort($array);

下面是运行结果：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 嗯，整个算法已经完了！如果你只想要代码的。你事情已经完成了，下面开始讲原理。

插入排序之所以叫插入排序，我们可以形象的理解为：

你摸牌的时候，你手里的牌是有序的，而你从牌堆里摸的牌是随机出现的，你只需跟你手里的牌进行比较排序，就能确定新牌的位置

插入的排序的逻辑可以简单的理解为，从第二个元素前，开始跟第一个元素进行比较，如果比对一个元素小，该元素就插入到第一个元素的前面

如果大，则跟第二个元素进行比较，以此类推。（从效果图中，可以看出来）

再来看看插入排序的时间发杂度：

最优的情况，所有的N-1个元素只需要跟前面的元素比较一次，那么时间复杂度是n-1;
最差的勤快，所有的N-1个元素都需要跟前面的所有元素比较一次，那么时间复杂度是一个等差数列 ((n-1)*(n-2))/2+(n-1);
综上所述：插入排序的时间复杂度应该是位于这两则之间。

空间复杂度： 插入排序是一种线性排序。所有空间复杂度跟参与排序的N有关。