Php this


In PHP, the self and this keyword are used to refer class members within the scope of a class. The class members can be either variables or functions. These PHP keywords differ with the static behavior of the class members.

PHP this keyword refers a non-static member of a class with respect to the class instance created. So, the values or arguments of the class members will be varied based on value with which the instance of the class is created.

php_self_vs_this

If we use this keyword without object context for referring static data, then the following error will be displayed to the browser.

Fatal error: Using $this when not in object context in ... on Line  

So, we should use the self keyword in such places to refer static members of the class to avoid the above error. While using self for referring static data, we need to use scope resolution operator. For example,

class PageUI {  public static $menu;  ...  public static function getMenu() {  return self::$menu;  }  

In the above code sample, we have shown how the static variable $menu is referred by PHP self-keyword.

Difference between PHP self and this



self this
the self-keyword will not be preceded by any symbol; rather we can use as it is. But PHP this keyword should be preceded with a $ sign while referring class members.
PHP scope resolution operator will be used with the self keyword. For example, self::<class-member> -> symbol is used with $this variable as we have used with an object instance to access the property of that object. For example, $this-><class-member>
It will be used for referring a static member of a class. this is used for accessing non-static member with -> operator.
PHP self is referring class members, not for any particular instance; rather, all of the class instances will use same static member by the use of self. But, $this will refer class members for a particular instance of the class.

Example: PHP self Vs this

Let us see the above differences with a simple PHP program as an example to know, how the class members are referred by these two PHP keywords.

<?php  class Toys{  public $toys_name;  public $toys_category;  public static $shop_name;    function Toys($name,$category) {  $this->toys_name = $name;  $this->toys_category = $category;  }    public function getToyName() {   return $this->toys_name;   }  public function getToyCategory() {   return $this->toys_category;   }	  public function getToyShop_nonStatic() {   return self::getToyShop();   }  public static function getToyShop() {   return self::$shop_name;  }  public static function setToyShop($shopname) {   self::$shop_name=$shopname;   }    }    $objToys = new Toys("Battery Car","Battery Toys");  $toys_name = $objToys->getToyName();  $toys_category = $objToys->getToyCategory();  echo "<br/>Toy: " . $toys_name . ", Category: " . $toys_category;    Toys::$shop_name = "Disney";  $shop_name = Toys::getToyShop();  echo "<br/>Shop Name: " . $shop_name;    Toys::setToyShop("ToyShop");  $shopname = Toys::getToyShop_nonStatic();  echo "<br/>Shop Name via non static function: " . $shopname;  ?>  

In the above program, we have three member variables for Toys class. Two of those are non-static, expected to be initialized automatically while creating class instances. And, the class contains only one static variable commonly referred for all instances of the class.

With constructors, the class variables are referred by using $this, for initialization. Again, using $this variable the initialized members variables are referred for class getters defined as a non-static member function, returning required values for a particular class instance.

On the other hand, static members are referred by using a self keyword to return the static value of $shop_name by the static member function getToyShop() of the Toys class.

Outside the class, first, we have created an instance with two arguments, for automatically calling the class constructor. With respect to this object or instance, the non-static member functions are invoked to get the value of $toys_name and $toys_category. Now, member functions use $this to refer those values initialized on instantiation.


And then, the static members are accessed from outside the class by using the class name itself. But, within class scope, we have used self to access those members. In this program, we have retrieved static variable values by using non-static member function getToyShop_nonStatic(), also.

After executing the above PHP program, it will return the following output to the browser to be displayed.

Toy: Battery Car, Category: Battery Toys  Shop Name: Disney  Shop Name via non static function: ToyShop  

Download PHP self Vs this Source Code

This PHP code tutorial was published on August 28, 2013.

↑ Back to Top

phppot.com

У каждого обычно возникает вопрос, что такое $this, что такое self, для чего они используются и в чем разница между ними?
ПРАВИЛА КОТОРЫЕ ВЫ ДОЛЖНЫ ЗАПОМНИТЬ:

  1. Статические функции должны использовать только статические переменные.
  2. self ТОЛЬКО для статических функций, свойств. Но также можно вызвать нестатический метод, КАК СТАТИЧЕСКИЙ через self. Но лучше так не делать, а то папа побьет.
  3. this ТОЛЬКО для нестатических.
  4. this требует, чтобы класс был проинстанцирован, self не требует.

$this — это ССЫЛКА на ТЕКУЩИЙ объект и она нужна, чтобы обратиться к переменной в КОНТЕКСТЕ класса. К примеру:


class human {      public $name;
 public function klassFunc() {};      function getName() {             echo $name; // неправильно, обратиться не к переменной public name             echo $this->name; // правильно                          //вызов метода класса             $this->klassFunc();      } }
 

Обычна нужна, чтобы инициализировать поля в конструкторе, ну и не только:

class human {      public $name;  
 public function __construct($name){

 $this->name = $name;
 $name = $name; //будет ошибка
 } }

$self используется в том, же самом ключе, но уже для СТАТИЧЕСКИХ свойств:

class human {      static $name = "ololo";    
 public function klassFunc() {};      function getName() {             echo self::$name; //обращение к name
 echo $this->name; //null или ошибка. НЕЛЬЗЯ      } }

Проверочная программа которая показывает главную разницу между self и $this:

class Klass {
const       STAT = ‘S’ ; // константы всегда статичныstatic     $stat = ‘Static’ ;
public     $publ = ‘Public’ ;
private    $priv = ‘Private’ ;
protected  $prot = ‘Protected’ ;


function __construct( ){  }

public function show( ){
    print ‘<br> self::STAT: ‘.self::STAT; // ссылается на константу
    print ‘<br> self::$stat: ‘.self::$stat; // статическая переменная.
    print ‘<br>$this->stat: ‘.$this->stat ; // Ошибки нет, но выведет пустую строку. ПРЕДУПРЕЖДЕНИЕ.
    print ‘<br>$this->publ: ‘.$this->publ ; // выведет как надо
    print ‘<br>’ ;
}
}$me = new Klass() ;$me->show() ;

Результат:
self::STAT: S
self::$stat: Static
Strict Standards: Accessing static property Klass::$stat as non static in htdocstesttestReference.php on line ..
Notice: Undefined property: Klass::$stat in C:xampphtdocstesttestReference.php on line 50
$this->stat:
$this->publ: Public
Видно, что php умный и кидает предупреждения глупым программистам. Не делайте так.


Второе главное отличие состоит в том, что

self не использует таблицу виртуальных методов, то есть:
(взято с StackOverflow)

class Person

: transparent; border: 0px; margin: 0px; padding: 0px; vertical-align: baseline;"> $name; public function __construct

und-color: transparent; border: 0px; margin: 0px; padding: 0px; vertical-align: baseline;">{ $this->name = $name; } public function getName() { return $this->name; } public function getTitle() { return $this->getName()." the person"; } public function sayHello() { echo "Hello, I'm ".$this->getTitle()."<br/>"; } public function sayGoodbye() { echo "Goodbye from ".self::getTitle()."<br/>"; } } class Geek extends Person { public function __construct($name) { parent::__construct($name); } public function getTitle() { return $this->getName()." the geek"; } } $geekObj = new Geek("Ludwig"); $geekObj->sayHello(); $geekObj->sayGoodbye();

Выведет:

Hello, I’m Ludwig the geek
Goodbye from Ludwig the person

Пояснение:
Метод sayHello использует this, поэтому виртуальная таблица вызовет Geek::getTitle()
Метод sayGoodbye использует self, поэтому виртуальная таблица будет не задействована и будет вызван parent::getTitle()

Решение:
Используем вместо self, static keyword:
public function sayGoodbye() {
      echo «Goodbye from «.static::getTitle();

Всем, спасибо, за внимание 🙂

evilcoderr.blogspot.com

Что такое PHP и что с помощью него можно делать?

В этом несложном введении в язык PHP объясняются основы PHP и как его можно использовать для создания многофункциональных веб-страниц и приложений. PHP — это язык программирования, который можно использовать для написания веб-приложений. Веб-приложение может быть чем угодно — от простой формы «свяжитесь с нами» до полноценной системы ведения блогов, интернет-магазина, или форума. Ещё  с помощью PHP можно вставлять блоки контекстной рекламы в тексты статей сайта.

PHP — серверный язык

PHP известен, как серверный язык программирования. Это означает, что он работает на веб сервере. Большинство языков веб-программирования являются серверными языками, но некоторые, например, JavaScript, работают на стороне клиента, это означает, что они работают в веб-браузере.

Серверные языки дают вам больше гибкости, так как вы можете то, что трудно осуществить с помощью JavaScript — например, работа с файлами, базами данных, или работа с изображениями. Нужно сказать, что JavaScript распространился очень быстро в наши дни.

Выполнение кода со стороны сервера является более безопасным способом, чем на стороне клиента, как это делает JavaScript. Поскольку код JavaScript отправляется в веб-браузер, для посетителей сайта легко его просмотреть и редактировать. Даже на одной странице сайта можно с легкостью совмещать PHP и JavaScript. Код находящийся на стороне сервера остаётся веб-сервере и недоступен для посетителей сайта. PHP это инструмент, который находится на веб-сервере и там выполняет PHP скрипты.

PHP — программное обеспечение с открытым исходным кодом

PHP представляет собой программное обеспечение с открытым исходным кодом. Это означает, что любой пользователь может получить доступ и работать на PHP. Это помогает быть уверенным, что PHP будет работать в течение длительного времени. PHP можно свободно скачать и использовать. Это является причиной того, что многие хостинг-провайдеры широко используют PHP. Вы обнаружите, что подавляющее большинство веб-хостингом поддерживают работу PHP.

PHP ориентирован на разработку веб-приложений

В то время как многие языки программирования могут быть использованы для создания веб-приложений, PHP является одним из языков специально разработаных для использования в Интернете. PHP имеет множество полезных веб-функций таких, как:

Вы можете смешивать PHP код с HTML-кодом

Одной из замечательных функцией PHP является то, что вы можете включить блоки PHP кода в HTML-страницы.

Вы можете обособить PHP блоки с помощью специальных символов. Когда веб-сервер получает информацию о странице,
все PHP блоки запускаются движком PHP, в то время как, другие части страницы отправляются «как есть» в браузер.

Эта функция позволяет легко делать интерактивными обычные веб-страницы. Отличный инструмент для форм с обратной связью и форм с похожими функциями.

Использование PHP

Вы можете использовать PHP для записи практически любого типа веб-приложения или сценария. Обычные PHP приложения, включают в себя:

Кроме того, многие популярные веб-сайты, в том числе Yahoo!, Википедия, Facebook, Digg разработаны с использованием PHP. Также с помощью языка PHP возможно написание объектно-ориентированного кода.

site.softmaker.kz

Use of $this class in PHP

To access or change a class method or property within the class itself, it’s necessary to prefix the corresponding method or property name with “$this” which refers to this class.

Access current class properties inside current class method

In the above example
Create a class demo with two global properties $first hold 1000 and $second hold 500.
Now want to access these class properties inside class method add( ) and sub( ).
So inside add( ) method call these class properties( to prefix the corresponding property name with “$this”) with the help of “$this”, store the result inside $add variable.
Print the $add variable using echo statement.
Do the same for sub( ) method and store the result in $sub variable.
Now create the object of demo class, using “new” keyword and store the object reference in $obj variable.
call the method add( ) and sub( ) with the help of object(using connector(->) ).


Access current class methods inside other method

In the above example
Create a class demo with two properties $first and $second, three methods add( ), subtract( ) and summary( ). Use the current class property $first and $second, inside add( ) and sub( ) method make calculation and store the result inside $add and $sub variable.

Now Inside summary( ) method call the current class property $first and $second for multiplication, and print the result with the help of echo statement.

Inside summary( ) method, call current class add( ) and sub( ) method using $this.
after closing of class demo body, create object of demo class and store the object reference in $obj variable.

call summary( ) method, with the help of connecter(connect class object with class method) and output will display addition, subtraction, and multiplication.

www.phptpoint.com

I was confused at first about object assignment, because it's not quite the same as normal assignment or assignment by reference. But I think I've figured out what's going on.

First, think of variables in PHP as data slots. Each one is a name that points to a data slot that can hold a value that is one of the basic data types: a number, a string, a boolean, etc. When you create a reference, you are making a second name that points at the same data slot. When you assign one variable to another, you are copying the contents of one data slot to another data slot.

Now, the trick is that object instances are not like the basic data types. They cannot be held in the data slots directly. Instead, an object's "handle" goes in the data slot. This is an identifier that points at one particular instance of an obect. So, the object handle, although not directly visible to the programmer, is one of the basic datatypes.

What makes this tricky is that when you take a variable which holds an object handle, and you assign it to another variable, that other variable gets a copy of the same object handle. This means that both variables can change the state of the same object instance. But they are not references, so if one of the variables is assigned a new value, it does not affect the other variable.

<?php
// Assignment of an object
Class Object{
   public
$foo="bar";
};

$objectVar = new Object();
$reference =& $objectVar;
$assignment = $objectVar

//
// $objectVar --->+---------+
//                |(handle1)----+
// $reference --->+---------+   |
//                              |
//                +---------+   |
// $assignment -->|(handle1)----+
//                +---------+   |
//                              |
//                              v
//                  Object(1):foo="bar"
//
?>

$assignment has a different data slot from $objectVar, but its data slot holds a handle to the same object. This makes it behave in some ways like a reference. If you use the variable $objectVar to change the state of the Object instance, those changes also show up under $assignment, because it is pointing at that same Object instance.

<?php
$objectVar
->foo = "qux";
print_r( $objectVar );
print_r( $reference );
print_r( $assignment );

//
// $objectVar --->+---------+
//                |(handle1)----+
// $reference --->+---------+   |
//                              |
//                +---------+   |
// $assignment -->|(handle1)----+
//                +---------+   |
//                              |
//                              v
//                  Object(1):foo="qux"
//
?>

But it is not exactly the same as a reference. If you null out $objectVar, you replace the handle in its data slot with NULL. This means that $reference, which points at the same data slot, will also be NULL. But $assignment, which is a different data slot, will still hold its copy of the handle to the Object instance, so it will not be NULL.

<?php
$objectVar
= null;
print_r($objectVar);
print_r($reference);
print_r($assignment);

//
// $objectVar --->+---------+
//                |  NULL   |
// $reference --->+---------+
//                          
//                +---------+
// $assignment -->|(handle1)----+
//                +---------+   |
//                              |
//                              v
//                  Object(1):foo="qux"
?>

php.net


You May Also Like

About the Author: admind

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Этот сайт использует Akismet для борьбы со спамом. Узнайте как обрабатываются ваши данные комментариев.