php-notes.md

resource which I must study continously and carefully:

1. https://www.php.net/manual/en/langref.php
2. https://github.com/phpinternalsbook/PHP-Internals-Book
3. https://www.npopov.com/2015/06/19/Internal-value-representation-in-PHP-7-part-2.html
4. https://phpsecurity.readthedocs.io/en/latest/index.html

PHPStorm notes:

1. how zoom all the IDE?
   • press ctrl + backtick
   • select zoom

important notes in PHP:

1. new feature added in php 8.0 called constructor property promotion.
2. VO: value object
3. DTO: data transfer object
4. in php it is not possible to typ hint properties with callable type.
5. The object operator, ->, is used in object scope to access methods and properties of an object.
6. Null-safe operator is a new syntax in PHP 8.0, that provides optional chaining feature to PHP. e.g. $foo?->bar?->baz;
7. isset() => Determine if a variable is declared and is different than null.
8. Null coalescing operator => The null coalescing operator (??) has been added as syntactic sugar for the common case of needing to use a ternary in conjunction with isset(). It returns its first operand if it exists and is not null; otherwise it returns its second operand.

note: null coalescing operator does not work on methods. what does it mean?

$transction = new Transction;
$transction->getCustomer()->getProfiler()->id ?? 'something1';

the above code does not work properly becuase null coalescing operator does not work on methods. the right way to write above code is to use nullsafe operator.

    $transction = new Transction;
    $transction->getCustomer()?->getProfiler()?->id ?? 'something1';

9. importing classes in php is per file, which means if in file A we have some use statement to import other classes and also in this file we have include statement to include file B, then imported classes in file A is not availabe in file B.

10. a final class in php can not be extended.

11. a final method in a class in php can not be overwritten by child class.

*** final keyword is used to prevent class extension and method override.

13. a child class just can increase visibility of public and protected properties of parent class but can not decrease the visibility of those properties.

example:

class A {
  protected a;
}

class B extends A {
  public a;
}

14. php does not allow multiple inheritance but it supports multi level inhertance which cause hierarchal inheritance.

15. child class can not access to private properties and methods of parent class => so it can not override private and protected proprties and methods of parent class.

16. in php, interface could not have any property but it could have constant.

note: the constant which is defined in an interface could not be overridden with other classes who implemented target interface.

17. magic method __get() is called when trying to access a non-exsiting or inaccessible property in an object.

18. magic method __set() is called whenever trying to assign a value for a non-exsiting or inaccessible property in an object.

19. magic method __call() is called whenever a non existing or inaccessible method get called on target object.

20. magic method __callStatic is called when a static method on a class is called and that method does not exists.

21. for implementing single action classes, a method called __invoke must be declared in the class. so by default objects are not callable, but if a class has __invoke method, then the object from that class is callable. (session 46 Programming with Gio)

22. __debugInfo is called whenever trying to var_dump the object. in __debugInfo method we could specify which properties of object is allowed to be printed. becuase in defult mode, when printing an object; all of its private properties also get printed.

23. in oop, this keyword refers to "calling object". 24.in oop, self refers to where the method is defined, and not where the method is called. in here where means which class.

$this resolve the class at run time. self resolve the class at compile time.

###note: so there is a concept named: early binding and late binding.

25. there is two types of binding.

early binding which happens at => compile time and late bindind which happens at => run time.

25. $this => late binding => considers current calling object
26. self => early binding => considers in which class the calling method locate and consider that class.
27. static keyword is called in run time so it is late binding. static considers the method is called in which class, and not is defined in which class.

note: seld keyword resolves the class at compile time. this is the limitation of self keyword.

28. spl_object_id() which returns the object identifier.

29. php does not support multiple inheritance, but we can implement multiple inheritance by using traits and interfaces in php.

30. in php traits precendece in important. suppose there is a parent class called parentClass and a child class called childClass and a trait called sampleTrait.
    if there is a common method in childClass and in the trait, the the method in childClass is considered.
    if there is a common method in parentClass and in trait, then the method in trait is considered.
    

  trait sampleTrait {
    public function method2() {
      //
    }
  }
  
  class parentClass {
  
    public function method1() {
      //
    }
  }
  
  class childClass extends parenrClass {
      use sampleTrait;
         
  }

31. in php trait. there might be a conflict between traits methods. suppose we have a class called classA and this class uses two different traits:

trait TraitA {

    public function method1()
    {
        echo "method1 from " . static::class . PHP_EOL;
    }
}

trait TraitB
{
    public function method1()
    {
        echo "method1 from " . static::class . PHP_EOL;
    }
}

to solve the conflict problem, we must determine that method1 from which trait should be considered. also we could rename method1 for each trait by definig an alias to it.

class ClassA
{
    use TraitA {
        TraitA::method1 insteadof TraitB;
    }
    use TraitB {
        TraitB::method1 as originalMethod1;
    }
}

require_once dirname(__DIR__) . '/app/traitA.php';
require_once dirname(__DIR__) . '/app/TraitB.php';
require_once dirname(__DIR__) . '/app/ClassA.php';

$classa = new ClassA();
$classa->method1();
$classa->originalMethod1();

32. it is possible to change visibility of a trait's method in target class. suppose we have a class called classA which uses a trait named TraitA like this:

trait TraitA {

    private function method1()
    {
        echo "method1 from " . static::class . PHP_EOL;
    }
}


class ClassA
{
    use TraitA{
        TraitA::method1 as public;
    }
}

and then:

$classa = new ClassA();
$classa->method1();

33. if a property is defined in a trait, then the underlying class can not have the same property unless it would be fully compatible, which means "visiblity level", "data type", and "initial value" should be the same.

34. important note: 😊 =? trait could have abstract method! (Programming with Gio/Lesson 48) ==> be it is not a good idea to have abstract method in a trait. because abstract method is some how some type of contract, and contract is better implemeted by abstract class or better interface. trait is jut for simple code reuse.

35. we all know in a abstract class, all methods could be public or protected. in other words, it is not possible to define an abstract method as private method. but please not since php 8, it is possible to define an abstract method in a trait as private. please note this is olny possible for traits. (Programming with Gio/Lesson 48)

36. important note: if a parent class has a static property, then this static property is shared among all child classes, this means if any one of child classes changed the parent class static property, then this static property got change in all places. because it is shared. BUT in traits this is not true. if TraitA is used in both classA and classB; then if TraitA has a static property, this property is not shared among other classes and each class which uses traitA has its own static property. (Programming with Gio/Lesson 48)

37. magic constant __CLASS__ => if this magic constant is used in a trait, then it points to a class which uses the trait.

38. traits => are for code reuse

39. interfaces => are for contract

40. another important rule which could be considered is that if in a base class a method is defined as final, then this method can not be overriden in derived classes. BUT this rule is not true in trait. in a trait if any method defined as final, then the class which uses the trait can redefine that method/

41. note: trait allows non related and also independent classes share common functionality.

Gio(session 50):
42. === => identity operator / strict equality operator
== => comparison operator/ equal operator

42. in comparing two objects by == : the two objects are equal if both are instance of same class and have same properties with same value.

43. in comparing two objects by ===: the two objects are equal if both of them point or refer to the same instance of the same class.

44. PHP already has support for void type. It is only allowed as a return type because using void anywhere else wouldn't make any sense.
    In PHP 8.0 Union Types, the void type is not allowed to be combined with any other type.

45. for copying an object, we can clone that object like this:\

  $obj1 = new sampleClass();
  $obj2 = clone $obj1;

note: when cloning an object, the constructor method does not get called when cloning the object.
when cloning an object, a method called __clone get called.

46. cloning an object is considered as shallow copy but serializing/deserializing an object is considered as deep copy.

47. Serializable interface is deprecated in php 8.1 and will be removed in php 9.\

48. there are four magic methods related to serialization: __sleep , __wakeup , __serialize , __unserialize.

49. __sleep is called before serialization start. __wakeup method is called after desialization.

50. if unserialization process failed, then unserialize function returns false and also generate notice error.

51. __serialize magic method is just like __sleep magic method. both of them are called before serializing the object. but the difference is that ==> in __serialize method we could specify which properties of the object must be in seialize process and if any change on any property is needed before serialization process it is possible to define these changes in __serialize method. but on the other hand for __sleep method it is possible to just define which properties of object must be serialize and it is not possible to define any change which is needed to be taken before serialization. also note that __serialize method has precendence over __sleep method.

52. there is __wakeup and __unserialize method. they work just like above notes mentioned but in reverse manner. both methods are called after deserializing the object. __unserialize method has more precedence than __wakeup method.

53. exception handling is the OOP way of error handling.

54. in europe date format is: day-month-year

55. in U.S. date format is: month/day/year

56. in php if date format is seperated by / ==> php by default consider it as U.S. date format by id date is seperated by . or -, then php consider it as european date format.

57. output_buffering directive is always off in PHP-CLI.

58. php has variable variable and also variable functions. e.g.:

$func = "sqrt";
print $func(49);

As variable functions are quite unusual and also easy to get wrong, there is a special PHP function, is_callable(), that takes a string as its only parameter and returns true if that string contains a function name that can be called using a variable function. Thus, our script becomes this: (source: http://www.hackingwithphp.com/)

  $func = "sqrt";
  if (is_callable($func)) {
      print $func(49);
  }

As an alternative to variable functions, you can use call_user_func() and call_user_func_array(), which take the function to call as their first parameter. The difference between the two is that call_user_func() takes the parameters to pass into the variable function as multiple parameters to itself, whereas call_user_func_array() takes an array of parameters as its second parameter.

This next script demonstrates both of these two performing a functionally similar operation, replacing "monkeys" with "giraffes" in a sentence using str_replace(): (source: http://www.hackingwithphp.com/)

  $func = "str_replace";
  $output_single = call_user_func($func, "monkeys", "giraffes", "Hundreds and thousands of monkeys\n");
  $params = array("monkeys", "giraffes", "Hundreds and thousands of monkeys\n");
  $output_array = call_user_func_array($func, $params);
  echo $output_single;
  echo $output_array;

59. Covariance
    covariance allows a child's method to return a more specific type than the return type of its parent's method.

60. Contravariance
    contravariance allows a parameter type to be less specific in a child method, than that of its parent.

61. PHP supports:

    • covariant return type
    • contravariant parameter type

62. single quotes ('') vs double quotes (""):
    In PHP, single quotes ('') are generally faster than double quotes ("") because with single quotes, PHP does not evaluate the contents for variables or special characters, whereas with double quotes, PHP performs variable interpolation and evaluates escape sequences.

When you use double quotes, PHP needs to scan the string for variables and special characters to replace them with their values, which adds a slight overhead compared to single quotes where no such processing is needed.

However, the performance difference between single and double quotes is usually negligible unless you're dealing with a massive number of string manipulations or in a very performance-critical application. In most cases, the readability and convenience of using double quotes outweigh any minor performance considerations.

63. when using try-catch block, if it is needed to use multiple exceptions, it is possible to use bit wise or operator. the sample code is:\

try {
    ... throws ReflectiveOperationException ...
}
catch (ClassNotFoundException | IllegalAccessException ex) {
    ... body ...
}

63. there is two way for comparing two objects in php:\

• loos comparison
• strict comparison

in loos comparison --> it just compares object property values
in strict comparison --> compares object identities\

64. when making any change in autoload section of composer.json file, then it is needed to composer dump-autoload or composer du.