찾다

집  >  기사  >  웹 프론트엔드  >  프로젝트에서 PHP 정적 바인딩을 사용하는 방법

프로젝트에서 PHP 정적 바인딩을 사용하는 방법

php中世界最好的语言
php中世界最好的语言원래의
2018-06-14 15:15:501413검색

이번에는 프로젝트에서 PHP 정적 바인딩을 사용하는 방법과 프로젝트에서 PHP 정적 바인딩을 사용할 때 주의 사항에 대해 설명하겠습니다. 실제 사례를 살펴보겠습니다.

기본 지식

1. 범위 결정 연산자(::)

  • 는 정적 멤버, 클래스 상수에 액세스하는 데 사용할 수 있으며 클래스의 속성과 메서드를 재정의하는 데에도 사용할 수 있습니다.

  • 세 가지 특수 키워드 self, parent 및 static은 클래스 정의 내의 해당 속성이나 메서드에 액세스하는 데 사용됩니다.

  • parent는 상위 클래스에서 재정의된 속성이나 메서드를 호출하는 데 사용됩니다(표시되는 경우 해당 클래스의 상위 클래스로 확인됩니다).

  • self는 이 클래스의 메서드나 속성을 호출하는 데 사용됩니다(표시되는 경우 해당 클래스로 구문 분석됩니다. $this와의 차이점에 유의하세요. $this는 현재 인스턴스화된 개체를 가리킵니다).

  • 하위 클래스가 상위 클래스의 메서드를 재정의하면 PHP는 상위 클래스의 재정의된 메서드를 호출하지 않습니다. 상위 클래스의 메소드 호출 여부는 하위 클래스에 따라 다릅니다.

2. PHP 커널은 "컴파일 단계"에 클래스의 상속 구현을 배치합니다. 

<?php
class A{
 const H = &#39;A&#39;;
 const J = &#39;A&#39;;
 static function testSelf(){
  echo self::H; //在编译阶段就确定了 self解析为 A
 }
}
class B extends A{
 const H = "B";
 const J = &#39;B&#39;;
 static function testParent(){
  echo parent::J; //在编译阶段就确定了 parent解析为A
 }
 /* 若重写testSelf则能输出“B”, 且C::testSelf()也是输出“B”
 static function testSelf(){
  echo self::H;
 }
 */
}
class C extends B{
 const H = "C";
 const J = &#39;C&#39;;
}
B::testParent();
B::testSelf();
echo "\n";
C::testParent();
C::testSelf();

실행 결과:

AA
AA

결론:

self:: 및 parent:: 나타남 in 특정 클래스 X의 정의에서는 상위 클래스의 메서드가 하위 클래스에서 재정의되지 않는 한 해당 클래스 X로 해결됩니다.

3.Static(정적) 키워드

Function:

- 함수 본문의 변수를 수정하는 static 키워드는 정적 지역 변수를 정의하는 데 사용됩니다.
- 클래스 멤버 함수 및 멤버 변수를 수정할 때 정적 멤버를 선언하는 데 사용됩니다.
- (PHP5.3 이후) 범위 확인자(::) 이전에 정적 지연 바인딩을 나타내는 특수 클래스입니다.

예:

정적 지역 변수 정의(발생: 로컬 함수에서)

특징: 정적 변수는 지역 함수 범위에만 존재하지만 프로그램 실행이 이 범위를 벗어나도 해당 값은 손실되지 않습니다. 

<?php
function test()
{
 static $count = 0;
 $count++;
 echo $count;
 if ($count < 10) {
  test();
 }
 $count--;
}

정적 메서드, 정적 속성 정의

a) 클래스 속성이나 메서드를 정적으로 선언하면 클래스를 인스턴스화하지 않고도 직접 액세스할 수 있습니다.

b) 정적 속성은 클래스의 인스턴스화된 개체를 통해 액세스할 수 없습니다(그러나 정적 메서드는 가능함).

c) 액세스 제어가 지정되지 않으면 속성과 메서드는 기본적으로 공개로 설정됩니다.

d) 정적 메서드에서는 개체 호출이 필요하지 않으므로 정적 메서드에서는 의사 변수 $this를 사용할 수 없습니다.

e) 객체는 -> 연산자를 통해 정적 속성에 액세스할 수 없습니다.

f) 비정적 메서드를 정적으로 호출하면 E_STRICT 수준 오류가 발생합니다.

g) 다른 모든 PHP 정적 변수와 마찬가지로 정적 속성은 표현식이 아닌 리터럴이나 상수로만 초기화할 수 있습니다. 따라서 정적 속성은 정수 또는 배열로 초기화될 수 있지만 다른 변수나 함수 반환 값으로 초기화될 수 없으며 개체를 가리킬 수도 없습니다.

a. 정적 메소드 예시(외모: 클래스의 메소드 정의) 

<?php
class Foo {
 public static function aStaticMethod() {
  // ...
 }
}
Foo::aStaticMethod();
$classname = &#39;Foo&#39;;
$classname::aStaticMethod(); // 自PHP 5.3.0后，可以通过变量引用类
?>

b. 정적 속성 예시(외모: 클래스의 속성 정의) 

<?php
class Foo
{
 public static $my_static = &#39;foo&#39;;
 public function staticValue() {
  return self::$my_static; //self 即 FOO类
 }
}
class Bar extends Foo
{
 public function fooStatic() {
  return parent::$my_static; //parent 即 FOO类
 }
}
print Foo::$my_static . "\n";
$foo = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n";  // Undefined "Property" my_static 
print $foo::$my_static . "\n";
$classname = 'Foo';
print $classname::$my_static . "\n"; // As of PHP 5.3.0
print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?>

c. 후기 정적 바인딩에 사용됨(외모: 클래스의 메소드, 수정에 사용됨) 변수 또는 메소드)

자세한 분석은 다음과 같습니다

후기 정적 바인딩(late static Binding)

PHP 5.3.0부터 PHP에는 정적으로 호출된 클래스를 참조하기 위해 다음을 사용하는 후기 정적 바인딩이라는 기능이 추가되었습니다. 상속 범위.

1. 전달된 통화 및 전달되지 않은 통화

전달된 통화:

는 self::, parent::, static:: 및forward_static_call() 방식으로 이루어진 정적 호출을 의미합니다.

전달되지 않은 호출:

클래스 이름을 명확하게 지정하는 정적 호출(예: Foo::foo())

비정적 호출(예: $foo->foo())

2. 후기 정적 바인딩 작업 원리

원리: 이전 "비전달 호출"의 클래스 이름이 저장됩니다. 이는 순방향 호출인 정적 호출을 호출할 때 실제로 호출되는 클래스가 이전 비전달 호출의 클래스라는 것을 의미합니다.

例子分析：

<?php
class A {
 public static function foo() {
  echo __CLASS__."\n";
  static::who();
 }
 public static function who() {
  echo __CLASS__."\n";
 }
}
class B extends A {
 public static function test() {
  echo "A::foo()\n";
  A::foo();
  echo "parent::foo()\n";
  parent::foo();
  echo "self::foo()\n";
  self::foo();
 }
 public static function who() {
  echo __CLASS__."\n";
 }
}
class C extends B {
 public static function who() {
  echo __CLASS__."\n";
 }
}
C::test();
/*
 * C::test(); //非转发调用 ，进入test()调用后，“上一次非转发调用”存储的类名为C
 *
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function test() {
 *  A::foo(); //非转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为A，然后实际执行代码A::foo(), 转 0-0
 *  parent::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为C， 此处的parent解析为A ,转1-0
 *  self::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为C， 此处self解析为B, 转2-0
 * }
 *
 *
 * 0-0
 * //当前的“上一次非转发调用”存储的类名为A
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为A， 故实际执行代码A::who(),即static代表A，进入who()调用后，“上一次非转发调用”存储的类名依然为A，因此打印 “A”
 * }
 *
 * 1-0
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为C， 故实际执行代码C::who(),即static代表C，进入who()调用后，“上一次非转发调用”存储的类名依然为C，因此打印 “C”
 * }
 *
 * 2-0
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为C， 故实际执行代码C::who(),即static代表C，进入who()调用后，“上一次非转发调用”存储的类名依然为C，因此打印 “C”
 * }
 */
故最终结果为：
A::foo()
A
A
parent::foo()
A
C
self::foo()
A
C

3.更多静态后期静态绑定的例子

a)Self, Parent 和 Static的对比

<?php
class Mango {
 function classname(){
  return __CLASS__;
 }
 function selfname(){
  return self::classname();
 }
 function staticname(){
  return static::classname();
 }
}
class Orange extends Mango {
 function parentname(){
  return parent::classname();
 }
 function classname(){
  return __CLASS__;
 }
}
class Apple extends Orange {
 function parentname(){
  return parent::classname();
 }
 function classname(){
  return __CLASS__;
 }
}
$apple = new Apple();
echo $apple->selfname() . "\n";
echo $apple->parentname() . "\n";
echo $apple->staticname();
?>
运行结果：
Mango
Orange
Apple

b)使用forward_static_call()

<?php
class Mango
{
 const NAME = &#39;Mango is&#39;;
 public static function fruit() {
  $args = func_get_args();
  echo static::NAME, " " . join(&#39; &#39;, $args) . "\n";
 }
}
class Orange extends Mango
{
 const NAME = &#39;Orange is&#39;;
 public static function fruit() {
  echo self::NAME, "\n";
  forward_static_call(array(&#39;Mango&#39;, &#39;fruit&#39;), &#39;my&#39;, &#39;favorite&#39;, &#39;fruit&#39;);
  forward_static_call(&#39;fruit&#39;, &#39;my&#39;, &#39;father\&#39;s&#39;, &#39;favorite&#39;, &#39;fruit&#39;);
 }
}
Orange::fruit(&#39;NO&#39;);
function fruit() {
 $args = func_get_args();
 echo "Apple is " . join(&#39; &#39;, $args). "\n";
}
?>
运行结果：
Orange is
Orange is my favorite fruit
Apple is my father's favorite fruit

c)使用get_called_class()

<?php
class Mango {
 static public function fruit() {
  echo get_called_class() . "\n";
 }
}
class Orange extends Mango {
 //
}
Mango::fruit();
Orange::fruit();
?>
运行结果：
Mango
Orange

应用

前面已经提到过了，引入后期静态绑定的目的是：用于在继承范围内引用静态调用的类。
所以， 可以用后期静态绑定的办法解决单例继承问题。

先看一下使用self是一个什么样的情况：

<?php
// new self 得到的单例都为A。
class A
{
 protected static $_instance = null;
 protected function __construct()
 {
  //disallow new instance
 }
 protected function __clone(){
  //disallow clone
 }
 static public function getInstance()
 {
  if (self::$_instance === null) {
   self::$_instance = new self();
  }
  return self::$_instance;
 }
}
class B extends A
{
 protected static $_instance = null;
}
class C extends A{
 protected static $_instance = null;
}
$a = A::getInstance();
$b = B::getInstance();
$c = C::getInstance();
var_dump($a);
var_dump($b);
var_dump($c);
运行结果：
E:\code\php_test\apply\self.php:37:
class A#1 (0) {
}
E:\code\php_test\apply\self.php:38:
class A#1 (0) {
}
E:\code\php_test\apply\self.php:39:
class A#1 (0) {
}

通过上面的例子可以看到，使用self，实例化得到的都是类A的同一个对象

再来看看使用static会得到什么样的结果

<?php
// new static 得到的单例分别为D，E和F。
class D
{
 protected static $_instance = null;
 protected function __construct(){}
 protected function __clone()
 {
  //disallow clone
 }
 static public function getInstance()
 {
  if (static::$_instance === null) {
   static::$_instance = new static();
  }
  return static::$_instance;
 }
}
class E extends D
{
 protected static $_instance = null;
}
class F extends D{
 protected static $_instance = null;
}
$d = D::getInstance();
$e = E::getInstance();
$f = F::getInstance();
var_dump($d);
var_dump($e);
var_dump($f);
运行结果：
E:\code\php_test\apply\static.php:35:
class D#1 (0) {
}
E:\code\php_test\apply\static.php:36:
class E#2 (0) {
}
E:\code\php_test\apply\static.php:37:
class F#3 (0) {
}

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

如何操作JS遍历多维数组

如何操作vue代码规范检测

위 내용은 프로젝트에서 PHP 정적 바인딩을 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명：
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
이전 기사：ReactNative를 사용하여 Toast를 구현하는 방법다음 기사：ReactNative를 사용하여 Toast를 구현하는 방법

관련 기사

더보기