Tefter Webdeveloper.BG

Dummy objects are passed around but never actually used. Usually they are just used to fill parameter lists.

Stubs

Просто методите на stubs са хардкоднати да връщат винаги даден предефиниран резултат при различни сценарии. Дори не хвърлят и exceptions или каквото и да е от самата бизнес логика.

A stub provides predetermined responses to calls made during a test. For example, if testing a payment gateway, a stub can simulate both successful and failed transactions, ensuring your code responds appropriately.

Example: Your test class depends on a method Calculate() taking 5 minutes to complete. Rather than wait for 5 minutes you can replace its real implementation with stub that returns hard-coded values; taking only a small fraction of the time.

Or the network connection to twitter API is very slow, which make my test slow. I know it will return timelines, so I made a stub simulating HTTP twitter API, so that my test will run it very fast, and I can running the test even I’m offline.

Mocks

Very similar to Stub but interaction-based rather than state-based. This means you don’t expect from Mock to return some value, but to assume that specific order of method calls are made.
Example: You’re testing a user registration class. After calling Save, it should call SendConfirmationEmail.

Stubs and Mocks are actually sub types of Mock, both swap real implementation with test implementation, but for different, specific reasons.

Stubs don’t fail your tests, mock can.

Stub – for replacing a method with code that returns a specified result.

Mock – a stub with an assertion that the method gets called.

С mock например можеш да провериш дали при дадени сценарии тестваният метод ще хвърли или не exception, дали минава или фейлва например някаква валидация…
Със stub – не, там просто се връща нещо хардкоднато.

Example in JavaScript:

var Stub = {
   method_a: function(param_a, param_b){
      return 'This is an static result';
   }
}

var Mock = {
   calls: {
      method_a: 0
   }

   method_a: function(param_a, param_b){
     this.method_a++; 
     console.log('Mock.method_a its been called!');
   }
}

Литература:

https://www.bairesdev.com/blog/stub-vs-mock

https://stackoverflow.com/questions/3459287/whats-the-difference-between-a-mock-stub

https://martinfowler.com/articles/mocksArentStubs.html

Или каква е разликата между comparison operator (==) и identity operator (===)

Comparison operator дава true, когато „Two object instances are equal if they have the same attributes and values (values are compared with ==), and are instances of the same class.„
Демек, когато данновата им част (пропъртитата) са еднакви, и са различни обекти, но от един и същи клас. А както знем класът по принцип е един вид тип. И също знаем, че по принцип Comparison operator (двойното равно) не се интересува от типът на сравняваните променливи, ако са скаларни. Но очевидно, и ако са обекти.

Демек това ще върне true.

var_dump(123 == '123');

Но това ще върне false.

var_dump(123 === '123');

Identity operator от друга стана ще върне true само ако двата обекта са всъщност една и съща инстанция, демек, когато: When using the identity operator (===), object variables are identical if and only if they refer to the same instance of the same class.

Демек, едното – ако са различни обекти, но от един клас, и с еднакви properties, другото – когато са един и същ обект.

Литература:

https://www.php.net/manual/en/language.oop5.object-comparison.php

Readonly classes

До сега можеше да декларираме отделни пропъртита на даден клас като readonly.
Вече може всички пропъртита да ги декларираме readonly ако декларираме целият клас readonly.

Вместо:

class MyClass
{
	public readonly string $myValue,
	public readonly int $myOtherValue
	public readonly string $myAnotherValue
	public readonly int $myYetAnotherValue
}

това:

readonly class MyClass
{
	public string $myValue,
	public int $myOtherValue
	public string $myAnotherValue
	public int $myYetAnotherValue
}

Важно е, че в такъв случай, когато целият клас е readonly, всичките му пропъртита трябва задължително да имат тип, дори и да е mixed.

Също и, че не може да се декларират като readonly – enum, interface и trait. Само класове.

Dynamic class properties

Вече не може да се използват клас пропъртита, които не са декларирани.

From PHP 8.2 onwards, dynamic properties are deprecated. Setting a value to an undeclared class property will emit a deprecation notice the first time the property is set.

However, from PHP 9.0 onwards, setting the same will throw an ErrorException error.

…if you want to stop these deprecation notices after upgrading to PHP 8.2, you can use PHP 8.2’s new #[AllowDynamicProperties] attribute to allow dynamic properties on classes.

new standalone types

Вече имаме типове като true, false и null, демек такива, които са по принцип values, a не типове, могат вече да се използват и като типове. Демек, функция например може да ти връща тип null, или тип false, или тип true.

Но да не забравяме, че true и false са union type на bool. Демек, не можем да декларираме параметър или тип на връщана стойност като например bool|false.
Both true and false types are essentially a union type of PHP’s bool type. To avoid redundancy, you cannot declare these three types together in a union type. Doing so will result in a compile-time fatal error.

Disjunctive Normal Form (DNF) Types

sensitive parametters

Има случаи, в които волно или неволно можем да логнем например пароли, в различни log файлове или подобни по предназначение системи.

За да избегнем това програмно, ако подобна информация е например клас пропърти или параметър на функция, можем да ги декларираме като т.н. SensitiveParameter с помощта на атрибутът [\SensitiveParameter] по следният начин.

function example(
    $ham,
    #[\SensitiveParameter] $eggs,
    $butter
) {
    throw new \Exception('Error');
}

example('ham', 'eggs', 'butter');

/*
Fatal error: Uncaught Exception: Error in test.php:8
Stack trace:
#0 test.php(11): test('ham', Object(SensitiveParameterValue), 'butter')
#1 {main}
thrown in test.php on line 8
*/

When you generate a backtrace, any parameter with the \SensitiveParameter attribute will be replaced with a \SensitiveParameterValue object, and its real value will never be stored in the trace. The SensitiveParameterValue object encapsulates the actual parameter value — if you need it for any reason.

Fetch enum Properties in const Expressions

https: // kinsta.com/blog/php-8-2/#fetch-enum-properties-in-const-expressions

Allow Constants in Traits

Вече и в traits може да се дефинират константи.

trait Foo {
    public const FLAG_1 = 1;
    protected const FLAG_2 = 2;
    ...

Deprecate Partially Supported Callables

Първо, какво значи „partially supported callables“?

These callables are termed „partially supported“ because you cannot interact with them directly via $callable(). You can only get to them with the call_user_func($callable) function.

From PHP 8.2 onwards, any attempts to invoke such callables — such as via call_user_func() or array_map() functions — will throw a deprecation warning.

Демек, следващият със същото име пренабива предишният от дясно на ляво.

localhost/i.php?aaa=111&bbb=222&aaa=333

array(2) {
    ["aaa"]=> string(3) "333"
    ["bbb"]=> string(3) "222"
}

За POST заявки – аналогично, следващият аргумент със същото име пренабива предишният.

Да видим какво пише тук:

As with normal exceptions, these Error exceptions will bubble up until they reach the first matching catch block. If there are no matching blocks, then any default exception handler installed with set_exception_handler() will be called, and if there is no default exception handler, then the exception will be converted to a fatal error and will be handled like a traditional error.

An exception handler handles exceptions that were not caught before. It is the nature of an exception that it discontinues execution of your program – since it declares an exceptional situation in which the program cannot continue (except you catch it).

Ако такъв блок не бъде намерен, се надяваме, че поне глобално имаме зададен exception handler с помощта на set_exception_handler()

Ако и такъв хендлър нямаме зададен, ще имаме fatal error.

Демек, хвърлен exception трябва да бъде прихванат задължително!

Добър въпрос е ако вече и в set_exception_handler() възникне грешка, дали ще се изпълни хендлърът, зададен с set_error_handler()?

Да, ще се. Нека разгледаме следният пример:

set_error_handler(function (int $errno, string $errstr, string $errfile, int $errline,): bool {
    echo "Error has occurred: ", $errstr, PHP_EOL;

    /**
     * It is important to remember that the standard PHP error handler is completely bypassed
     * for the error types specified by error_levels UNLESS the callback function returns false.
     * Демек, ако върнем FALSE за даденият тип грешка, това ще значи,
     * че обработването и (на този тип грешка)
     * ще продължи И КЪМ стандартният обработчик.
     * Демек, върнем ли TRUE - до там! Няма да използваме и стандартният обработчик.
     * Но пак да кажем - до там само за даденият тип грешка.
     */
    return false;
});

set_exception_handler(function (Throwable $ex): void {
    echo "Uncaught exception: ", $eXd->getMessage(), PHP_EOL;
});

throw new Exception('Catch me if you can.');

echo "Not Executed" . PHP_EOL;

Имаме ли грешка в set_exception_handler(), демек по време на хвърляне на ексепшън, ще влезем и в set_error_handler()

class Parend
{
    public const JJJ = 123;
}

class Chilt extends Parend
{
    public const JJJ = 456;

    static public function getJjj(): void
    {
        var_dump(self::JJJ);
    }
}

Chilt:: getJjj();    // int(456)

Е, ако родителската констата е private, резултатът пак ще е 456 но не в следствие на overrid-ване, а защото Child::JJJ ще се смята за напълно отделна константа, предвид видимостта и.

Първо нека си припомним какво е callback function.
Callback function is any reference to executable code that is passed as an argument to another piece of code.
Демек, код който се предава на друг код, под формата на аргумент, за да бъде изпълнен.

А относно статични и динамични callbacks, имаме две положения:

DYNAMIC Anonymous Functions

Когато имаме анонимна функция В КЛАС, това значи че $this променливата e ДОСТЪПНА в тази анонимна функция, демек става част от скоупа му, защото „the default behavior is that the class is automatically bound to the closure“.

Eто следният пример:

<?php

class Foo
{
    public function bar(): \Closure
    {
        return function (): void {
            var_dump($this);
        };
    }
}

$foo = new Foo();
$foo->bar()();

Първо, кой е callback-ът в даденият пример? Това е методът bar(). Защо? Защото какво връща той? Връща код, не конкретна стойност. Който код, може да бъде предаден като аргумент на друг код.

Второ, var_dump()-ът ще дъмпне самият обект – object(Foo)#1 (0) {}

Което очевидно значи, че щом даденият callback е динамичен то за всеки обект от класа Foo, ще имаме достъп до обектната променлива ($this), указваща към този даден обект, в който сме към даденият момент.

Static Anonymous Functions

Нека разгледаме горният код, но с една малка разлика – callback функцията нека е статична.

<?php

class Foo
{
    public function bar(): \Closure
    {
        return static function (): void {
            var_dump($this);
        };
    }
}

$foo = new Foo();
$foo->bar()();

Ще имаме Fatal error: Uncaught Error: Using $this when not in object context…

Вече, ако имаме статично пропърти на класа или статичен метод, можем да го достъпим, но чрез self

<?php
class Foo
{
    private static string $a = 'Hello world';

    public static function bar(): \Closure
    {
        return static function (): void {
            var_dump(self::$a);
        };
    }
}

$foo = new Foo();
$foo->bar()();      // Hello world

Литература:

https://en.wikipedia.org/wiki/Callback_(computer_programming)

https://www.designcise.com/web/tutorial/what-are-static-anonymous-functions-in-php

<?php
class Jazz
{
    public function __call(string $method, array $args): int
    {
        echo 'Majic ';
        return array_sum($args) * 2;
    }

    private function multiply(int $arg): int
    {
        echo 'No majic ';
        return $arg * 2;
    }
}

$class = new Jazz;
echo $class->multiply(3);      // Majic 6
echo PHP_EOL;
echo $class->multiply(15, 5);  // Majic 40

„variables_order“ PHP директивата задава на кои суперглобални масиви да бъдат зададени стойности. Задаваме кои от GET, POST, COOKIE, ENV и SERVER ще презапишат една друга.

This directive determines which super global arrays are registered when PHP
starts up. G,P,C,E & S are abbreviations for the following respective super globals: GET, POST, COOKIE, ENV and SERVER. There is a performance penalty paid for the registration of these arrays and because ENV is not as commonly used as the others, ENV is not recommended on productions servers. You can still get access to the environment variables through getenv().

Демек, използването на „E“ не се препоръчва, защото натоварва сървъра с още един масив, което е безсмислено, при условие че стойностите му могат така или иначе да се вземат с getenv()

А ако искаме да зададем РЕДЪТ НА ПРЕЗАПИСВАНЕ, това става с директивата „request_order“, която задава въпросният ред на презаписване.

Ето един пример:
Ако имаме request_order = „GP“, това значи, че ако имаме GET и POST променливи с еднакви имена, то стойността на дадената POST променлива ще презапише тази на съответната GET променлива.

Демек, редът на презаписване е – десните презаписват левите.

Какво, ако не зададем стойност на тази директива – „request_order“?
Leaving this value empty will cause PHP to use the value set in the variables_order directive. It does not mean it will leave the super globals array REQUEST empty.
Демек, ще използва стойността на директивата „variables_order“ и пак ще имаме $REQUEST масив със стойности.

Друго, което се вижда, че информацията в ENV e аналогична с тази, получена от getenv().

А разликата между ENV и SERVER e, че първото съдържа информация по-скоро за операционната система, както и такива, зададени от командният ред, такива, зададени с putenv()

А SERVER- променливи на ниво конкретен уебсърв, apache, nginx…

Литература:

https://www.php.net/manual/en/reserved.variables.request.php

https://stackoverflow.com/questions/43157933/what-is-the-request-precedence