“上下文关键字”KWIC(Key Word in Context，文本中的关键字）检索系统尝试

<?php
//定义全局共享变量
$data = [];
$all = [];
$index = 0;
$yield = null;
/**
*
* 行输入
*
**/
 function input()
 {
    global $data;
    while(1){
        $string = trim(fgets(STDIN));
        //按ctrl+p 结束输入
        if(16 === ord($string)){
            break;
        }
        array_push($data,$string);
    }
    return;
 }
 /**
 *
 *    记录位移过程,累加到到迭代器
 *
 **/
 function shifter()
{
    global $data;
    global $index;
    while($index<count($data)){
        $tempArr = explode(‘ ‘,$data[$index]);
        $count = count($tempArr);
        yield implode(‘ ‘,$tempArr)."\n";
        for($i=0;$i<$count-1;++$i){
            $shift = array_shift($tempArr);
            array_push($tempArr,$shift);
            yield implode(‘ ‘,$tempArr)."\n";
        }
        $index+=1;
    }    
}
/**
*
*    位移过程输出
*
**/
function pcOutput()
{
    global $yield;
    $collector = [];
    foreach($yield as $k=>$v){
        array_push($collector,$v);
        echo $v;
    }
    return $collector;
}
/**
*
* 按字母排序
*
**/
 function alphabetizer()
{
    //使用全局变量
    global $all;
    //排序
    return natcasesort($all);
    
}
/**
*
* 排序结果输出
*
**/
function output()
{
    global $all;
    foreach($all as $v)
    {
        print($v);
    }
}

/**
*
* 主函数
*
**/
function main()
{
    global $yield;
    global $all;
    print("----------input---------\n");
    //输入
    input();
    //循环位移
    $yield = shifter();
    //过程输出
    print("\n---------process--------\n");
    $all = pcOutput();
    //按字母表排序
    alphabetizer();
    //排序结果输出
    print("\n----------output---------\n");
    output();
}

main();


?>

  1 <?php
  2 /**
  3 *
  4 *    过滤器
  5 *
  6 **/
  7     abstract class Filter{
  8         protected abstract function trans();
  9     }
 10 /**
 11 *
 12 *
 13 *    管道类
 14 *
 15 **/
 16     class Pipe{
 17         private $inputPipe = [];
 18         private $outputPipe = [];
 19         private function writeLine(){
 20             $input = new Input();
 21             print("--------input---------\n");
 22             while(1){    
 23                 $buffer = $input->input();
 24                 if($buffer === false)
 25                     break;
 26                 array_push($this->inputPipe,$buffer);    
 27             }
 28             return $this->inputPipe;
 29         }
 30         private function readLine(){
 31             $CircleShift = new CircleShift($this->inputPipe);
 32             $outputPipe  = $CircleShift->trans();
 33             $Alpha = new Alphabetizer($outputPipe);
 34             $outputPipe = $Alpha->trans();
 35             return $outputPipe;
 36         }
 37         public function start(){
 38             return $this->writeLine();
 39         }
 40         public function stop(){
 41             $this->outputPipe = $this->readLine();
 42             $output = new Output($this->outputPipe);
 43             $output->trans();
 44         }
 45     }
 46         
 47     /**
 48     *
 49     *    输入,并将输入过滤生成数组
 50     *
 51     **/
 52     class Input extends Filter{
 53         private $input = ‘‘;
 54         public function input(){
 55             $this->input = trim(fgets(STDIN));
 56             if(ord($this->input) === 16){
 57                 return false;
 58             }
 59             return $this->trans();
 60         }
 61         
 62         public function trans(){
 63             return explode(‘ ‘,$this->input);
 64         }
 65     }
 66     /**
 67     *
 68     *    输出
 69     *
 70     **/
 71     class Output extends Filter{
 72         private $output = null;
 73         function __construct($output){
 74             $this->output = $output;
 75         }
 76         function trans(){
 77             foreach($this->output as $k=>$v){
 78                 print($v);
 79             }
 80         }
 81     }
 82     /**
 83     *
 84     *    循环移位
 85     *
 86     **/
 87     class CircleShift extends Filter{
 88         private $input = null;
 89         private $output = [];
 90         private $index = 0;
 91         function __construct($input){
 92             $this->input = $input;
 93         }
 94         //循环移动单词的位置
 95         public function trans(){
 96         
 97             foreach($this->input as $value){
 98                 $count = count($value);
 99                 array_push($this->output,implode(‘ ‘,$value)."\n");
100                 for($i=0;$i<$count-1;++$i){        
101                     $shift = array_shift($value);
102                     array_push($value,$shift);
103                     array_push($this->output,implode(‘ ‘,$value)."\n");
104                 }
105             }
106 
107             return $this->output;
108         }
109     }
110     /**
111     *
112     *    按照字母排序
113     *
114     **/
115     class Alphabetizer extends Filter{
116         private $data = null;
117         function __construct($data){
118             $this->data = $data;
119         }
120         public function trans(){
121             natcasesort($this->data);
122             return $this->data;
123         }
124     }
125     class KWIC{
126         public function main(){
127             //实例化管道
128             $Pipe = new Pipe();
129             $input = $Pipe->start();
130             $output = $Pipe->stop();
131         }
132     }
133 
134     $kwic = new KWIC();
135     $kwic->main();
136 ?>