Einführung in die Anwendungsbeispiele für den Abschluss in PHP

Dieser Artikel stellt hauptsächlich die detaillierte Erklärung der Verwendung von Schließungen in PHP vor. Freunde, die sie benötigen, können auf

Die anonyme Funktion Schließung wird in PHP5.3 eingeführt, auch bekannt als anonyme Funktionen. Die wörtliche Bedeutung ist eine Funktion ohne definierten Namen. Beispielsweise kann der folgende Code (der Dateiname ist do.php)

<?php
function A() {
  return 100;
};
function B(Closure $callback)
{
  return $callback();
}
$a = B(A());
print_r($a);//输出：Fatal error: Uncaught TypeError: Argument 1 passed to B() must be an instance of Closure, integer given, called in D:\web\test\do.php on line 11 and defined in D:\web\test\do.php:6 Stack trace: #0 D:\web\test\do.php(11): B(100) #1 {main} thrown in D:\web\test\do.php on line 6
?>

A() hier niemals als Parameter von B verwendet werden, da A keine „anonyme“ Funktion ist.

Also sollte es wie folgt geändert werden:

<?php
$f = function () {
  return 100;
};
function B(Closure $callback)
{
  return $callback();
}
$a = B($f);
print_r($a);//输出100
<?
$func = function( $param ) {
  echo $param;
};
$func( &#39;hello word&#39; );
//输出：hello word

Abschlüsse implementieren

Anonyme Funktionen als gewöhnliche Funktionsparameter behandeln werden abgegeben und können auch zurückgegeben werden. Dies implementiert einen einfachen Verschluss.

Im Folgenden gebe ich Ihnen drei Beispiele:

<?php
//例一
//在函数里定义一个匿名函数，并且调用它
function printStr() {
  $func = function( $str ) {
    echo $str;
  };
  $func( &#39; hello my girlfriend ! &#39; );
}
printStr();//输出 hello my girlfriend !
//例二
//在函数中把匿名函数返回，并且调用它
function getPrintStrFunc() {
  $func = function( $str ) {
    echo $str;
  };
  return $func;
}
$printStrFunc = getPrintStrFunc();
$printStrFunc( &#39; do you love me ? &#39; );//输出 do you love me ?
//例三
//把匿名函数当做参数传递，并且调用它
function callFunc( $func ) {
  $func( &#39; no!i hate you &#39; );
}
$printStrFunc = function( $str ) {
  echo $str.&#39;<br>&#39;;
};
callFunc( $printStrFunc );
//也可以直接将匿名函数进行传递。如果你了解js，这种写法可能会很熟悉
callFunc( function( $str ) {
  echo $str; //输出no!i hate you
} );

Schlüsselwörter, die Abschlüsse und externe Variablen verbinden: VERWENDEN

Abschlüsse können einige Variablen im Kontext des Codeblocks speichern, den sie enthalten sind in. und Wert. Standardmäßig können anonyme Funktionen in PHP keine Kontextvariablen in dem Codeblock aufrufen, in dem sie sich befinden, sondern müssen das Schlüsselwort use verwenden.

Nehmen wir ein anderes Beispiel (naja, mir fehlt das Geld, ich bin vulgär):

<?php
function getMoney() {
  $rmb = 1;
  $dollar = 8;
  $func = function() use ( $rmb ) {
    echo $rmb;
    echo $dollar;
  };
  $func();
}
getMoney();
//输出：1

Wie Sie sehen können, Dollar wird nicht verwendet Wenn es im Schlüsselwort deklariert ist, kann es in dieser anonymen Funktion nicht abgerufen werden. Achten Sie daher während der Entwicklung auf dieses Problem.

Einige Leute fragen sich vielleicht, ob es möglich ist, Kontextvariablen in anonymen Funktionen zu ändern, aber ich habe festgestellt, dass dies nicht möglich zu sein scheint:

<?php
function getMoney() {
  $rmb = 1;
  $func = function() use ( $rmb ) {
    echo $rmb.&#39;<br>&#39;;
    //把$rmb的值加1
    $rmb++;
  };
  $func();
  echo $rmb;
}
getMoney();
//输出：
//1
//1

Äh , stellt sich heraus, dass es sich bei dem, worauf sich use bezieht, nur um einen Klon der Variablen handelt. Aber was ist, wenn ich die Variable vollständig referenzieren möchte, anstatt sie zu kopieren? Um diesen Effekt zu erzielen, fügen Sie einfach ein &-Symbol vor der Variablen hinzu:

<?php
function getMoney() {
  $rmb = 1;
  $func = function() use ( &$rmb ) {
    echo $rmb.&#39;<br>&#39;;
    //把$rmb的值加1
    $rmb++;
  };
  $func();
  echo $rmb;
}
getMoney();
//输出：
//1
//2

Okay, damit die anonyme Funktion auf den Kontext verweisen kann. Variable. Wenn die anonyme Funktion an die Außenwelt zurückgegeben wird, speichert die anonyme Funktion die durch die Verwendung referenzierten Variablen, die Außenwelt kann diese Variablen jedoch nicht abrufen. Auf diese Weise ist das Konzept des „Schließens“ möglicherweise klarer.

Ändern wir gemäß der Beschreibung das obige Beispiel:

<?php
function getMoneyFunc() {
  $rmb = 1;
  $func = function() use ( &$rmb ) {
    echo $rmb.&#39;<br>&#39;;
    //把$rmb的值加1
    $rmb++;
  };
  return $func;
}
$getMoney = getMoneyFunc();
$getMoney();
$getMoney();
$getMoney();
//输出：
//1
//2
//3

Okay, so viel, was ist, wenn wir eine anonyme Funktion in einer Klasse aufrufen möchten? Gehen Sie direkt zur Demo

<?php
class A {
  public static function testA() {
    return function($i) { //返回匿名函数
      return $i+100;
    };
  }
}
function B(Closure $callback)
{
  return $callback(200);
}
$a = B(A::testA());
print_r($a);//输出 300

, wo A::testA() eine unbenannte Funktion zurückgibt.

Das Konzept der Bindung

Der Abschluss im obigen Beispiel ist nur eine globale anonyme Funktion. Okay, jetzt wollen wir eine Klasse angeben Es gibt eine anonyme Funktion. Es ist auch verständlich, dass der Zugriffsbereich dieser anonymen Funktion nicht mehr global ist, sondern der Zugriffsbereich einer Klasse.

Dann müssen wir „eine anonyme Funktion an eine Klasse“ binden.

<?php
class A {
  public $base = 100;
}
class B {
  private $base = 1000;
}
$f = function () {
  return $this->base + 3;
};
$a = Closure::bind($f, new A);
print_r($a());//输出 103
echo PHP_EOL;
$b = Closure::bind($f, new B , &#39;B&#39;);
print_r($b());//输出1003

Im obigen Beispiel hat die anonyme Funktion f ein unerklärliches this. Dieses Schlüsselwort bedeutet, dass diese anonyme Funktion an die Klasse gebunden werden muss.

Nach der Bindung ist es so, als gäbe es eine solche Funktion in A, aber unabhängig davon, ob diese Funktion öffentlich oder privat ist, gibt der letzte Parameter von bind den aufrufbaren Bereich dieser Funktion an.

Sie haben bindTo oben gesehen, werfen wir einen Blick auf die Einführung auf der offiziellen Website

(PHP 5 >= 5.4.0, PHP 7)

Closure::bind – Kopieren Sie einen Abschluss und binden Sie das angegebene $this-Objekt und den angegebenen Klassenbereich .

Erklärung

public static Closure Closure::bind ( Closure $closure , object $newthis [, Mixed $newscope = 'static' ] )
Diese Methode ist Closure::bindTo( ) statische Version. Weitere Informationen finden Sie in der Dokumentation.

Parameter

Abschluss

Eine anonyme Funktion, die gebunden werden muss.

newthis

erfordert ein Objekt, das an eine anonyme Funktion gebunden ist, oder NULL erstellt einen ungebundenen Abschluss.

newscope

Der Klassenbereich, den Sie an den Abschluss binden möchten, oder „statisch“ bedeutet keine Änderung. Wenn ein Objekt übergeben wird, wird der Typname des Objekts verwendet. Der Klassenbereich wird verwendet, um die Sichtbarkeit privater, geschützter Methoden des $this-Objekts innerhalb des Abschlusses zu bestimmen. (Hinweis: Sie können den Klassennamen oder eine Instanz der Klasse übergeben. Der Standardwert ist „statisch“, was bedeutet, dass keine Änderung erfolgt.)

Rückgabewert:

Einen neuen Abschluss zurückgeben Objekt oder bei Fehler Rückgabe FALSE

<?php
class A {
  private static $sfoo = 1;
  private $ifoo = 2;
}
$cl1 = static function() {
  return A::$sfoo;
};
$cl2 = function() {
  return $this->ifoo;
};
$bcl1 = Closure::bind($cl1, null, &#39;A&#39;);
$bcl2 = Closure::bind($cl2, new A(), &#39;A&#39;);
echo $bcl1(), "\n";//输出 1
echo $bcl2(), "\n";//输出 2

Schauen wir uns ein Beispiel an, um unser Verständnis zu vertiefen:

<?php
class A {
  public $base = 100;
}
class B {
  private $base = 1000;
}
class C {
  private static $base = 10000;
}
$f = function () {
  return $this->base + 3;
};
$sf = static function() {
  return self::$base + 3;
};
$a = Closure::bind($f, new A);
print_r($a());//这里输出103,绑定到A类
echo PHP_EOL;
$b = Closure::bind($f, new B , &#39;B&#39;);
print_r($b());//这里输出1003，绑定到B类
echo PHP_EOL;
$c = $sf->bindTo(null, &#39;C&#39;); //注意这里：使用变量#sf绑定到C类，默认第一个参数为null
print_r($c());//这里输出10003

Schauen wir uns eine andere Demo an:

<?php
/**
 * 复制一个闭包，绑定指定的$this对象和类作用域。
 *
 * @author fantasy
 */
class Animal {
  private static $cat = "加菲猫";
  private $dog = "汪汪队";
  public $pig = "猪猪侠";
}
/*
 * 获取Animal类静态私有成员属性
 */
$cat = static function() {
  return Animal::$cat;
};
/*
 * 获取Animal实例私有成员属性
 */
$dog = function() {
  return $this->dog;
};
/*
 * 获取Animal实例公有成员属性
 */
$pig = function() {
  return $this->pig;
};
$bindCat = Closure::bind($cat, null, new Animal());// 给闭包绑定了Animal实例的作用域，但未给闭包绑定$this对象
$bindDog = Closure::bind($dog, new Animal(), &#39;Animal&#39;);// 给闭包绑定了Animal类的作用域，同时将Animal实例对象作为$this对象绑定给闭包
$bindPig = Closure::bind($pig, new Animal());// 将Animal实例对象作为$this对象绑定给闭包,保留闭包原有作用域
echo $bindCat(),&#39;<br>&#39;;// 输出：加菲猫，根据绑定规则，允许闭包通过作用域限定操作符获取Animal类静态私有成员属性
echo $bindDog(),&#39;<br>&#39;;// 输出：汪汪队, 根据绑定规则，允许闭包通过绑定的$this对象(Animal实例对象)获取Animal实例私有成员属性
echo $bindPig(),&#39;<br>&#39;;// 输出：猪猪侠, 根据绑定规则，允许闭包通过绑定的$this对象获取Animal实例公有成员属性

Anhand der obigen Beispiele ist es eigentlich nicht schwer, die anonyme Bindung zu verstehen.... Wir sehen uns eine erweiterte Demo an (Einführung von Merkmalsfunktionen)

<?php
/**
 * 给类动态添加新方法
 *
 * @author fantasy
 */
trait DynamicTrait {
  /**
   * 自动调用类中存在的方法
   */
  public function __call($name, $args) {
    if(is_callable($this->$name)){
      return call_user_func($this->$name, $args);
    }else{
      throw new \RuntimeException("Method {$name} does not exist");
    }
  }
  /**
   * 添加方法
   */
  public function __set($name, $value) {
    $this->$name = is_callable($value)?
      $value->bindTo($this, $this):
      $value;
  }
}
/**
 * 只带属性不带方法动物类
 *
 * @author fantasy
 */
class Animal {
  use DynamicTrait;
  private $dog = &#39;汪汪队&#39;;
}
$animal = new Animal;
// 往动物类实例中添加一个方法获取实例的私有属性$dog
$animal->getdog = function() {
  return $this->dog;
};
echo $animal->getdog();//输出 汪汪队

Zum Beispiel: Jetzt verwenden wir die Einkaufsumgebung

<?php
/**
 * 一个基本的购物车，包括一些已经添加的商品和每种商品的数量
 *
 * @author fantasy
 */
class Cart {
  // 定义商品价格
  const PRICE_BUTTER = 10.00;
  const PRICE_MILK  = 30.33;
  const PRICE_EGGS  = 80.88; 
  protected  $products = array();
  /**
   * 添加商品和数量
   *
   * @access public
   * @param string 商品名称
   * @param string 商品数量
   */
  public function add($item, $quantity) {
    $this->products[$item] = $quantity;
  }
  /**
   * 获取单项商品数量
   *
   * @access public
   * @param string 商品名称
   */
  public function getQuantity($item) {
    return isset($this->products[$item]) ? $this->products[$item] : FALSE;
  }
  /**
   * 获取总价
   *
   * @access public
   * @param string 税率
   */
  public function getTotal($tax) {
    $total = 0.00;
    $callback = function ($quantity, $item) use ($tax, &$total) {
      $pricePerItem = constant(__CLASS__ . "::PRICE_" . strtoupper($item)); //调用以上对应的常量
      $total += ($pricePerItem * $quantity) * ($tax + 1.0);
    };
    array_walk($this->products, $callback);
    return round($total, 2);
  }
}
$my_cart = new Cart;
// 往购物车里添加商品及对应数量
$my_cart->add(&#39;butter&#39;, 10);
$my_cart->add(&#39;milk&#39;, 3);
$my_cart->add(&#39;eggs&#39;, 12);
// 打出出总价格，其中有 3% 的销售税.
echo $my_cart->getTotal(0.03);//输出 1196.4

Zusätzlicher Hinweis: Schließungen können die USE-Taste verwenden, um externe Variablen zu verbinden.

Zusammenfassung: Die Eigenschaften von PHP-Abschlüssen können mit CLASS tatsächlich ähnliche oder sogar leistungsfähigere Funktionen erreichen, ganz zu schweigen von den Abschlüssen von js. Wir können nur hoffen, dass PHP in Zukunft Verbesserungen unterstützt. Allerdings sind anonyme Funktionen immer noch sehr nützlich, wenn Sie beispielsweise Funktionen wie preg_replace_callback verwenden, müssen Sie keine Callback-Funktion extern deklarieren. Durch die richtige Verwendung von Abschlüssen kann der Code prägnanter und verfeinert werden.

Das obige ist der detaillierte Inhalt vonEinführung in die Anwendungsbeispiele für den Abschluss in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!