谁给我来点计算机的参考文献啊

最新问答

• 大庆张总

  正则表达式基础知识
  
  一个正则表达式就是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。如：
  JScript VBScript 匹配
  /^\[ \t]*$/ "^\[ \t]*$" 匹配一个空白行。
  /\d{2}-\d{5}/ "\d{2}-\d{5}" 验证一个ID 号是否由一个2位数字，一个连字符以及一个5位数字组成。
  /<(.*)>.*<\/\1>/ "<(.*)>.*<\/\1>" 匹配一个 HTML 标记。
  
  下表是元字符及其在正则表达式上下文中的行为的一个完整列表：
  字符 描述
  \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。
  ^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
  $ 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
  * 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
  + 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
  ? 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
  {n} n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
  {n,} n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
  {n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
  ? 当该字符紧跟在任何一个其他符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
  . 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
  (pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '\(' 或 '\)'。
  (?:pattern) 匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
  (?=pattern) 正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
  (?!pattern) 负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
  x|y 匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
  [xyz] 字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
  [^xyz] 负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
  [a-z] 字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
  [^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
  \b 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
  \B 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
  \cx 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
  \d 匹配一个数字字符。等价于 [0-9]。
  \D 匹配一个非数字字符。等价于 [^0-9]。
  \f 匹配一个换页符。等价于 \x0c 和 \cL。
  \n 匹配一个换行符。等价于 \x0a 和 \cJ。
  \r 匹配一个回车符。等价于 \x0d 和 \cM。
  \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
  \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
  \t 匹配一个制表符。等价于 \x09 和 \cI。
  \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
  \w 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
  \W 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
  \xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。正则表达式中可以使用 ASCII 编。.
  \num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。
  \n 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
  \nm 标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
  \nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
  \un 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (©)。
  
  下面看几个例子：
  "^The"：表示所有以"The"开始的字符串（"There"，"The cat"等）；
  "of despair$"：表示所以以"of despair"结尾的字符串；
  "^abc$"：表示开始和结尾都是"abc"的字符串——呵呵，只有"abc"自己了；
  "notice"：表示任何包含"notice"的字符串。
  
  '*'，'+'和'?'这三个符号，表示一个或一序列字符重复出现的次数。它们分别表示“没有或
  更多”，“一次或更多”还有“没有或一次”。下面是几个例子：
  "ab*"：表示一个字符串有一个a后面跟着零个或若干个b。（"a", "ab", "abbb",……）；
  "ab+"：表示一个字符串有一个a后面跟着至少一个b或者更多；
  "ab?"：表示一个字符串有一个a后面跟着零个或者一个b；
  "a?b+$"：表示在字符串的末尾有零个或一个a跟着一个或几个b。
  也可以使用范围，用大括号括起，用以表示重复次数的范围。
  "ab{2}"：表示一个字符串有一个a跟着2个b（"abb"）；
  "ab{2,}"：表示一个字符串有一个a跟着至少2个b；
  "ab{3,5}"：表示一个字符串有一个a跟着3到5个b。
  请注意，你必须指定范围的下限（如："{0,2}"而不是"{,2}"）。还有，你可能注意到了，'*'，'+'和
  '?'相当于"{0,}"，"{1,}"和"{0,1}"。
  还有一个'¦'，表示“或”作：
  "hi¦hello"：表示一个字符串里有"hi"或者"hello"；
  "(b¦cd)ef"：表示"bef"或"cdef"；
  "(a¦b)*c"：表示一串"a""b"混合的字符串后面跟一个"c"；
  '.'可以替代任何字符：
  "a.[0-9]"：表示一个字符串有一个"a"后面跟着一个任意字符和一个数字；
  "^.{3}$"：表示有任意三个字符的字符串（长度为3个字符）；
  方括号表示某些字符允许在一个字符串中的某一特置出现：
  "[ab]"：表示一个字符串有一个"a"或"b"（相当于"a¦b"）；
  "[a-d]"：表示一个字符串包含小写的'a'到'd'中的一个（相当于"a¦b¦c¦d"或者"[abcd]"）；
  "^[a-zA-Z]"：表示一个以字母开头的字符串；
  "[0-9]%"：表示一个百分号前有一位的数字；
  ",[a-zA-Z0-9]$"：表示一个字符串以一个逗号后面跟着一个字母或数字结束。
  你也可以在方括号里用'^'表示不希望出现的字符，'^'应在方括号里的第一位。（如："%[^a-zA-Z]%"表
  示两个百分号中不应该出现字母）。
  为了逐字表达，必须在"^.$()¦*+?{\"这些字符前加上转移字符'\'。
  请注意在方括号中，不需要转义字符。
  
  五种常见的 PHP 设计模式
  
  设计模式只是为 Java™ 架构师准备的 —— 至少您可能一直这样认为。实际上，设计模式对于每个人都非常有用。如果这些工具不是 “架构太空人” 的专利，那么它们又是什么？为什么说它们在 PHP 应用程序中非常有用？本文解释了这些问题。
  设计模式 一书将设计模式引入软件，该书的作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides Design（俗称 “四人帮”）。所介绍的设计模式背后的核心概念非常简单。经过多年的软件开发实践，Gamma 等人发现了某些具有固定设计的模式，就像建筑师设计房子和建筑物一样，可以为浴室的位置或厨房的构造方式开发模板。使用这些模板或者说设计模式 意味着可以更快地设计更好的建筑物。同样的概念也适用于软件。
  设计模式不仅代表着更快开发健壮软件的有用方法，而且还了以友好的术语封装大型理念的方法。例如，您可以说您正在编写一个松散耦合的消息传递系统，也可以说你正在编写名称为观察者 的模式。
  用较小的示例展示模式的价值是非常困难的。这往往有些大材小用的意味，因为模式实际上是在大型代库中发挥作用的。本文不展示大型应用程序，所以您 需要思索的是在您自己的大型应用程序中应用示例原理的方法 —— 而不是本文演示的代本身。这不是说您不应该在小应用程序中使用模式。很多良好的应用程序都以小应用程序为起点，逐渐发展到大型应用程序，所以没有理由不 以此类扎实的编实践为基础。
  既然您已经了解了设计模式以及它们的有用之处，现在我们来看看 PHP V5 的五种常用模式。
  工厂模式
  最初在设计模式 一书中，许多设计模式都鼓励使用松散耦合。要理解这个概念，让我们最好谈一下许多开发人员从事大型系统的艰苦历程。在更改一个代片段时，就会发生问题，系统其他部分 —— 您曾认为完全不相关的部分中也有可能出现级联破坏。
  该问题在于紧密耦合 。系统某个部分中的函数和类严重依赖于系统的其他部分中函数和类的行为和结构。您需要一组模式，使这些类能够相互通信，但不希望将它们紧密绑定在一起，以避免出现联锁。
  在大型系统中，许多代依赖于少数几个关键类。需要更改这些类时，可能会出现困难。例如，假设您有一个从文件读取的 User 类。您希望将其更改为从库读取的其他类，但是，所有的代都引用从文件读取的原始类。这时候，使用工厂模式会很方便。
  工厂模式 是一种类，它具有为您创建对象的某些方法。您可以使用工厂类创建对象，而不直接使用 new。这样，如果您想要更改所创建的对象类型，只需更改该工厂即可。使用该工厂的所有代会自动更改。
  清单 1 显示工厂类的一个示列。等式的服务器端包括两个部分：库和一组 PHP 页面，这些页面允许您反馈、请求反馈列表并获取与特定反馈相关的文章。
  
  清单 1. Factory1.php
  interface IUser
  {
  function getName();
  }
  
  class User implements IUser
  {
  public function __construct( $id ) { }
  
  public function getName()
  {
  return "Jack";
  }
  }
  
  class UserFactory
  {
  public static function Create( $id )
  {
  return new User( $id );
  }
  }
  
  $uo = UserFactory::Create( 1 );
  echo( $uo->getName()."\n" );
  ?>
  
  IUser 接口定义用户对象应执行什么作。IUser 的实现称为 User，UserFactory 工厂类则创建 IUser 对象。此关系可以用图 1 中的 UML 表示。
  
  图 1. 工厂类及其相关 IUser 接口和用户类
  
  如果您使用 php 解释器在命令行上运行此代，将得到如下结果：
  % php factory1.php
  Jack
  %
  
  测试代会向工厂请求 User 对象，并输出 getName 方法的结果。
  有一种工厂模式的变体使用工厂方法。类中的这些公共静态方法构造该类型的对象。如果创建此类型的对象非常重要，此方法非常有用。例如，假设您需要先 创建对象，然后设置许多属性。此版本的工厂模式会将该进程封装在单个位置中，这样，不用复制复杂的初始化代，也不必将复制好的代在在代库中到处粘 贴。
  清单 2 显示使用工厂方法的一个示例。
  
  清单 2. Factory2.php
  interface IUser
  {
  function getName();
  }
  
  class User implements IUser
  {
  public static function Load( $id )
  {
  return new User( $id );
  }
  
  public static function Create( )
  {
  return new User( null );
  }
  
  public function __construct( $id ) { }
  
  public function getName()
  {
  return "Jack";
  }
  }
  
  $uo = User::Load( 1 );
  echo( $uo->getName()."\n" );
  ?>
  
  这段代要简单得多。它仅有一个接口 IUser 和一个实现此接口的 User 类。User 类有两个创建对象的静态方法。此关系可用图 2 中的 UML 表示。
  
  图 2. IUser 接口和带有工厂方法的 user 类
  
  在命令行中运行脚本产生的结果与清单 1 的结果相同，如下所示：
  % php factory2.php
  Jack
  %
  
  如上所述，有时此类模式在规模较小的环境中似乎有些大材小用。不过，最好还是学习这种扎实的编形式，以便应用于任意规模的项目中。
  单元素模式
  某些应用程序是独占的，因为有且只有一个此类型的。例如，通过库句柄到库的连接是独占的。您希望在应用程序享库句柄，因为在保持连接打开或关闭时，它是一种开销，在获取单个页面的过程中更是如此。
  单元素模式可以满足此要求。如果应用程序每次包含且仅包含一个对象，那么这个对象就是一个单元素（Singleton）。清单 3 中的代显示了 PHP V5 中的一个库连接单元素。
  
  清单 3. Singleton.php
  require_once("DB.php");
  
  class DatabaseConnection
  {
  public static function get()
  {
  static $db = null;
  if ( $db == null )
  $db = new DatabaseConnection();
  return $db;
  }
  
  private $_handle = null;
  
  private function __construct()
  {
  $dsn = 'mysql://root:st/photos';
  $this->_handle =& DB::Connect( $dsn, array() );
  }
  
  public function handle()
  {
  return $this->_handle;
  }
  }
  
  print( "Handle = ".DatabaseConnection::get()->handle()."\n" );
  print( "Handle = ".DatabaseConnection::get()->handle()."\n" );
  ?>
  
  此代显示名为 DatabaseConnection 的单个类。您不能创建自已的 DatabaseConnection，因为构造函数是专用的。但使用静态 get 方法，您可以获得且仅获得一个 DatabaseConnection 对象。此代的 UML 如图 3 所示。
  
  图 3. 库连接单元素
  
  在两次调用间，handle 方法返回的库句柄是相同的，这就是最好的证明。您可以在命令行中运行代来观察这一点。
  % php singleton.php
  Handle = Object id #3
  Handle = Object id #3
  %
  
  返回的两个句柄是同一对象。如果您在整个应用程序中使用库连接单元素，那么就可以在任何地方重用同一句柄。
  您可以使用全局变量存储库句柄，但是，该方法仅适用于较小的应用程序。在较大的应用程序中，应避免使用全局变量，并使用对象和方法访问。
  观察者模式
  观察者模式为您了避免组件之间紧密耦合的另一种方法。该模式非常简单：一个对象通过一个方法（该方法允许另一个对象，即观察者 注册自己）使本身变得可观察。当可观察的对象更改时，它会将消息发送到已注册的观察者。这些观察者使用该信息执行的作与可观察的对象无关。结果是对象可以相互对话，而不必了解原因。
  一个简单示例是系统中的用户列表。清单 4 中的代显示一个用户列表，用户时，它将发送出一条消息。用户时，通过发送消息的日志观察者可以观察此列表。
  
  清单 4. Observer.php
  interface IObserver
  {
  function onChanged( $sender, $args );
  }
  
  interface IObservable
  {
  function addObserver( $observer );
  }
  
  class UserList implements IObservable
  {
  private $_observers = array();
  
  public function addCustomer( $name )
  {
  foreach( $this->_observers as $obs )
  $obs->onChanged( $this, $name );
  }
  
  public function addObserver( $observer )
  {
  $this->_observers []= $observer;
  }
  }
  
  class UserListLogger implements IObserver
  {
  public function onChanged( $sender, $args )
  {
  echo( "'$args' added to user list\n" );
  }
  }
  
  $ul = new UserList();
  $ul->addObserver( new UserListLogger() );
  $ul->addCustomer( "Jack" );
  ?>
  
  此代定义四个元素：两个接口和两个类。IObservable 接口定义可以被观察的对象，UserList 实现该接口，以便将本身注册为可观察。IObserver 列表定义要通过怎样的方法才能成为观察者，UserListLogger 实现 IObserver 接口。图 4 的 UML 中展示了这些元素。
  
  图 4. 可观察的用户列表和用户列表日志程序
  
  如果在命令行中运行它，您将看到以下输出：
  % php observer.php
  'Jack' added to user list
  %
  
  测试代创建 UserList，并将 UserListLogger 观察者到其中。然后一个消费者，并将这一更改通知 UserListLogger。
  认识到 UserList 不知道日志程序将执行什么作很关键。可能存在一个或多个执行其他作的侦听程序。例如，您可能有一个向新用户发送消息的观察者，欢迎新用户使用该系统。这种方法的价值在于 UserList 忽略所有依赖它的对象，它主要关注在列表更改时维护用户列表并发送消息这一工作。
  此模式不限于内存中的对象。它是在较大的应用程序中使用的库驱动的消息查询系统的基础。
  命令链模式
  命令链 模式以松散耦合主题为基础，发送消息、命令和请求，或通过一组处理程序发送任意内容。每个处理程序都会自行判断自己能否处理请求。如果可以，该请求被处理，进程停止。您可以为系统或移除处理程序，而不影响其他处理程序。清单 5 显示了此模式的一个示例。
  
  清单 5. Chain.php
  interface ICommand
  {
  function onCommand( $name, $args );
  }
  
  class CommandChain
  {
  private $_commands = array();
  
  public function addCommand( $cmd )
  {
  $this->_commands []= $cmd;
  }
  
  public function runCommand( $name, $args )
  {
  foreach( $this->_commands as $cmd )
  {
  if ( $cmd->onCommand( $name, $args ) )
  return;
  }
  }
  }
  
  class UserCommand implements ICommand
  {
  public function onCommand( $name, $args )
  {
  if ( $name != 'addUser' ) return false;
  echo( "UserCommand handling 'addUser'\n" );
  return true;
  }
  }
  
  class MailCommand implements ICommand
  {
  public function onCommand( $name, $args )
  {
  if ( $name != 'mail' ) return false;
  echo( "MailCommand handling 'mail'\n" );
  return true;
  }
  }
  
  $cc = new CommandChain();
  $cc->addCommand( new UserCommand() );
  $cc->addCommand( new MailCommand() );
  $cc->runCommand( 'addUser', null );
  $cc->runCommand( 'mail', null );
  ?>
  
  此代定义维护 ICommand 对象列表的 CommandChain 类。两个类都可以实现 ICommand 接口 —— 一个对邮件的请求作出响应，另一个对用户作出响应。 图 5 给出了 UML。
  
  图 5. 命令链及其相关命令
  
  如果您运行包含某些测试代的脚本，则会得到以下输出：
  % php chain.php
  UserCommand handling 'addUser'
  MailCommand handling 'mail'
  %
  
  代首先创建 CommandChain 对象，并为它两个命令对象的实例。然后运行两个命令以查看谁对这些命令作出了响应。如果命令的名称匹配 UserCommand 或 MailCommand，则代失败，不发生任何作。
  为处理请求而创建可扩展的架构时，命令链模式很有价值，使用它可以解决许多问题。
  策略模式
  我们讲述的最后一个设计模式是策略 模式。在此模式中，算法是从复杂类提取的，因而可以方便地替换。例如，如果要更改搜索引擎中排列页的方法，则策略模式是一个不错的选择。思考一下搜索引擎 的几个部分 —— 一部分遍历页面，一部分对每页排列，另一部分基于排列的结果排序。在复杂的示例中，这些部分都在同一个类中。通过使用策略模式，您可将排列部分放入另一个 类中，以便更改页排列的方式，而不影响搜索引擎的其余代。
  作为一个较简单的示例，清单 6 显示了一个用户列表类，它了一个根据一组即插即用的策略查找一组用户的方法。
  
  清单 6. Strategy.php
  interface IStrategy
  {
  function filter( $record );
  }
  
  class FindAfterStrategy implements IStrategy
  {
  private $_name;
  
  public function __construct( $name )
  {
  $this->_name = $name;
  }
  
  public function filter( $record )
  {
  return strcmp( $this->_name, $record ) <= 0;
  }
  }
  
  class RandomStrategy implements IStrategy
  {
  public function filter( $record )
  {
  return rand( 0, 1 ) >= 0.5;
  }
  }
  
  class UserList
  {
  private $_list = array();
  
  public function __construct( $names )
  {
  if ( $names != null )
  {
  foreach( $names as $name )
  {
  $this->_list []= $name;
  }
  }
  }
  
  public function add( $name )
  {
  $this->_list []= $name;
  }
  
  public function find( $filter )
  {
  $recs = array();
  foreach( $this->_list as $user )
  {
  if ( $filter->filter( $user ) )
  $recs []= $user;
  }
  return $recs;
  }
  }
  
  $ul = new UserList( array( "Andy", "Jack", "Lori", "Megan" ) );
  $f1 = $ul->find( new FindAfterStrategy( "J" ) );
  print_r( $f1 );
  
  $f2 = $ul->find( new RandomStrategy() );
  print_r( $f2 );
  ?>
  
  此代的 UML 如图 6 所示。
  
  图 6. 用户列表和用于选择用户的策略
  
  UserList 类是打包名称数组的一个包装器。它实现 find 方法，该方法利用几个策略之一来选择这些名称的子集。这些策略由 IStrategy 接口定义，该接口有两个实现：一个随机选择用户，另一个根据指定名称选择其后的所有名称。运行测试代时，将得到以下输出：
  % php strategy.php
  Array
  (
  [0] => Jack
  [1] => Lori
  [2] => Megan
  )
  Array
  (
  [0] => Andy
  [1] => Megan
  )
  %
  
  测试代为两个策略运行同一用户列表，并显示结果。在第一种情况中，策略查找排列在 J 后的任何名称，所以您将得到 Jack、Lori 和 Megan。第二个策略随机选取名称，每次会产生不同的结果。在这种情况下，结果为 Andy 和 Megan。
  策略模式非常适合复杂管理系统或处理系统，二者在筛选、搜索或处理的方式方面需要较高的灵活性。
  结束语
  本文介绍的仅仅是 PHP 应用程序中使用的几种最常见的设计模式。在设计模式 一书中演示了更多的设计模式。不要因架构的神秘性而放弃。模式是一种绝妙的理念，适用于任何编程语言、任何技能水平。

  浏览 278赞 117时间 2024-01-29
• yk小康哥

  首先建议您仔细地阅读一下《计算机科学与技术导论》这本书，即使您对计算机已是一知半解（注：这本书相当枯燥，需要一点耐心）。而后，你完全可以根据书上的内容选择你认为需要的深入的地方。如果喜欢编程可选购《C程序设计》或《C++程序设计》或《Java程序设计》等…

  浏览 292赞 149时间 2022-10-29