რელიზი!
PHP 8.1 — PHP ენის დიდი განახლება.
ის შეიცავს ბევრ ახალ შესაძლებლობას, მათ შორის ჩამოთვლები, readonly-თვისებები, callback-ფუნქციები როგორც პირველი კლასის ობიექტები, ფაიბერები, ტიპების კვეთა, წარმადობის გაუმჯობესება და სხვა მრავალი.

ჩამოთვლები RFC დოკუმენტაცია

PHP < 8.1
class Status
{
const
DRAFT = 'draft';
const
PUBLISHED = 'published';
const
ARCHIVED = 'archived';
}
function
acceptStatus(string $status) {...}
PHP 8.1
enum Status
{
case
Draft;
case
Published;
case
Archived;
}
function
acceptStatus(Status $status) {...}
გამოიყენეთ ჩამოთვლები კონსტანტების ნაკრების ნაცვლად, კოდის შესრულების დროს, მათი ავტომატური ვალიდაციისთვის.

Readonly-თვისებები RFC დოკუმენტაცია

PHP < 8.1
class BlogData
{
private
Status $status;

public function
__construct(Status $status)
{
$this->status = $status;
}

public function
getStatus(): Status
{
return
$this->status;
}
}
PHP 8.1
class BlogData
{
public readonly
Status $status;

public function
__construct(Status $status)
{
$this->status = $status;
}
}

Readonly თვისებების შეცვლა შეუძლებელია ინიციალიზაციის შემდეგ (ანუ მას შემდეგ რაც მათ მიენიჭება მნიშვნელობა).
ისინი ძალიან სასარგებლო იქნება ისეთი ობიექტების განხორციელებისას, როგორიცაა VO და DTO.

Callback-ფუნქციები როგორც პირველი კლასის ობიექტები RFC დოკუმენტაცია

PHP < 8.1
$foo = [$this, 'foo'];

$fn = Closure::fromCallable('strlen');
PHP 8.1
$foo = $this->foo(...);

$fn = strlen(...);

ახალი სინტაქსით, ნებისმიერ ფუნქციას შეუძლია იმოქმედოს როგორც პირველი კლასის ობიექტი. ამრიგად, ის ჩაითვლება როგორც ჩვეულებრივი მნიშვნელობა, რომელიც შეიძლება, მაგალითად, შევინახოთ ცვლადში.

ობიექტის გაფართოებული ინიციალიზაცია RFC

PHP < 8.1
class Service
{
private
Logger $logger;

public function
__construct(
?
Logger $logger = null,
) {
$this->logger = $logger ?? new NullLogger();
}
}
PHP 8.1
class Service
{
private
Logger $logger;

public function
__construct(
Logger $logger = new NullLogger(),
) {
$this->logger = $logger;
}
}

ახლა ობიექტები შეიძლება გამოყენებულ იქნას როგორც ნაგულისხმევი პარამეტრის მნიშვნელობები, სტატიკური ცვლადებისა და გლობალური კონსტანტებში, და ასევე ატრიბუტების არგუმენტებში.

ამრიგად, შესაძლებელი გახდა ჩაშენებული არგუმენტების გამოყენება.

PHP < 8.1
class User
{
/**
* @Assert\All({
* @Assert\NotNull,
* @Assert\Length(min=5)
* })
*/
public string $name = '';
}
PHP 8.1
class User
{
#[
\Assert\All(
new
\Assert\NotNull,
new
\Assert\Length(min: 5))
]
public
string $name = '';
}

ტიპების კვეთა RFC დოკუმენტაცია

PHP < 8.1
function count_and_iterate(Iterator $value) {
if (!(
$value instanceof Countable)) {
throw new
TypeError('value must be Countable');
}

foreach (
$value as $val) {
echo
$val;
}

count($value);
}
PHP 8.1
function count_and_iterate(Iterator&Countable $value) {
foreach (
$value as $val) {
echo
$val;
}

count($value);
}

გამოიყენეთ კვეთის ტიპები, როდესაც მნიშვნელობას სჭირდება ერთდროულად მრავალი ტიპის შეზღუდვის დაკმაყოფილება.

ამ დროისთვის, ტიპის კვეთა არ შეიძლება გამოყენებულ იქნას გაერთიანებულ ტიპებთან ერთად., მაგალითად, A&B|C.

Never დაბრუნების ტიპი RFC დოკუმენტაცია

PHP < 8.1
function redirect(string $uri) {
header('Location: ' . $uri);
exit();
}

function
redirectToLoginPage() {
redirect('/login');
echo
'Hello'; // <- dead code
}
PHP 8.1
function redirect(string $uri): never {
header('Location: ' . $uri);
exit();
}

function
redirectToLoginPage(): never {
redirect('/login');
echo
'Hello'; // <- dead code detected by static analysis
}

ფუნქცია ან მეთოდი, რომელიც გამოცხადებულია never ტიპთან ერთად, მიუთითებს იმაზე, რომ ისინი არ დააბრუნებენ მნიშვნელობას და ან გამოიტანს გამონაკლისს, ან დაასრულებს სკრიპტის შესრულებას ფუნქციის die(), exit(), trigger_error() გამოძახებით, ან რაიმე მსგავსით.

კლასის საბოლოო კონსტანტები RFC დოკუმენტაცია

PHP < 8.1
class Foo
{
public const
XX = "foo";
}

class
Bar extends Foo
{
public const
XX = "bar"; // No error
}
PHP 8.1
class Foo
{
final public const
XX = "foo";
}

class
Bar extends Foo
{
public const
XX = "bar"; // Fatal error
}

უკვე, კლასის კონსტანტები შესაძლებელია გამოცხადდეს როგორც საბოლოო (final), რათა მათი ხელახლა გამოცხადება არ მოხდეს შვილ კლასებში.

აშკარა რვაობითი რიცხვითი აღნიშვნა RFC დოკუმენტაცია

PHP < 8.1
016 === 16; // false because `016` is octal for `14` and it's confusing
016 === 14; // true
PHP 8.1
0o16 === 16; // false — not confusing with explicit notation
0o16 === 14; // true

ახლა თქვენ შეგიძლიათ ჩაწეროთ რვაობითი რიცხვები აშკარა პრეფიქსით 0o prefix.

ფაიბერები RFC დოკუმენტაცია

PHP < 8.1
$httpClient->request('https://example.com/')
->
then(function (Response $response) {
return
$response->getBody()->buffer();
})
->
then(function (string $responseBody) {
print
json_decode($responseBody)['code'];
});
PHP 8.1
$response = $httpClient->request('https://example.com/');
print
json_decode($response->getBody()->buffer())['code'];

ფაიბერები - ეს არის პრიმიტივები მსუბუქი საერთო კონკურენციის განსახორციელებლად. ისინი წარმოადგენენ კოდის ბლოკების შექმნის საშუალებას, რომელიც შეიძლება შეჩერდეს და განახლდეს, გენერატორების მსგავსად, მაგრამ სტეკის ნებისმიერი წერტილიდან. ფაიბერები თავისთავად არ იძლევა ამოცანების ასინქრონულად შესრულების შსაძლებლობას, მაინც უნდა არსებობდეს მოვლენის მართვის ციკლი. თუმცა, ისინი საშუალებას აძლევენ მბლოკავ და არამბლოკავ რეალიზაციება გამოიყენონ ერთი და იგივე იგივე API.

ფაიბერები საშუალებას გაძლევთ თავიდან აიცილოთ შაბლონური კოდი, რომელსაც ადრე იყენებდნენ Promise::then() გამოყენებით ან გენერატორზე დაფუძნებული კორუტინები. ბიბლიოთეკები ჩვეულებრივ ქმნიან დამატებით აბსტრაქციებს ფაიბერების ირგვლივ, ამიტომ არ არის საჭირო მათთან უშუალო ურთიერთობა.

მასივების ჩამოქაფების მხარდაჭერა სტრიქონიანი გასაღებებით RFC დოკუმენტაცია

PHP < 8.1
$arrayA = ['a' => 1];
$arrayB = ['b' => 2];

$result = array_merge(['a' => 0], $arrayA, $arrayB);

// ['a' => 1, 'b' => 2]
PHP 8.1
$arrayA = ['a' => 1];
$arrayB = ['b' => 2];

$result = ['a' => 0, ...$arrayA, ...$arrayB];

// ['a' => 1, 'b' => 2]

PHP ადრე გამოიყენება მასივების ჩამოქაფებას ოპერატორის ... დახმარებით, მაგრამ მხოლოდ იმ შემთხვევაში, თუ მასივები იყო მთელი რიცხვების გასაღებით. ახლა თქვენ ასევე შეგიძლიათ ჩამოქაფოთ მასივები სტრიქონიანი გასაღებებით.

შესრულების გაუმჯობესება

Symfony-ის დემო აპლიკაციის მოთხოვნის დრო
25 ზედიზედ გაშვება, 250 მოთხოვნა (წმ)
(რაც ნაკლები მით უკეთესი)

შედეგი (PHP 8.0-თან შედარებით):

  • Symfony დემო აპლიკაციის დაჩქარება 23.0%-ით
  • WordPress-ის 3.5%-ით დაჩქარება

ფუნქციონალურობა გაუმჯობესებული შესრულებით PHP 8.1-ში:

  • JIT ბექენდი ARM64 (AArch64)-თვის
  • მემკვიდრეობითი ქეში (თავიდან აირიდეთ კლასების ხელახლა დაკავშირება ყველა მოთხოვნაში)
  • კლასის სახელის სწრაფი გარჩევადობა (მოერიდეთ მცირე რეგისტრს და ჰეშში ძიებას)
  • შესრულების გაუმჯობესება timelib და ext/date.
  • SPL ფაილური სისტემის იტერატორების გაუმჯობესება.
  • serialize()/unserialize() ფუნქციების ოპტიმიზაცია.
  • ზოგიერთი შიდა ფუნქციის ოპტიმიზაცია (get_declared_classes(), explode(), strtr(), strnatcmp(), dechex())
  • JIT-ის გაუმჯობესება და შესწორებები.

ახალი კლასები, ინტერფეისები და ფუნქციები

  • დამატებულია ახალი ატრიბუტი #[ReturnTypeWillChange].
  • დამატებულია ფუნქციები fsync და fdatasync.
  • დამატებულია ახალი ფუნქცია array_is_list.
  • ახალი ფუნქციები Sodium XChaCha20.

მოძველებული ფუნქციონალობა და ცვლილებები უკუ თავსებადობაში

  • NULL მნიშვნელობების ჩაშენებული ფუნქციის პარამეტრებზე გადაცემა, მოძველებულია.
  • დაბრუნების წინასწარი ტიპები რომლებიც აბრუნებს მნიშვნელობებს PHP-ის ჩაშენებული კლასის მეთოდებში
  • Serializable ინტერფეისი მოძველებულია.
  • HTML ერთეულის კოდირების/დეკოდირების ფუნქციები გარდაქმნის ერთმაგ ბრჭყალებს და ცვლის არასწორ სიმბოლოებს იუნიკოდის შემცვლელი სიმბოლოთი.
  • $GLOBALS ცვლადის გამოყენების შეზღუდვები.
  • MySQLi: ნაგულისხმევი შეცდომის რეჟიმი დაყენებულია გამონაკლისებზე.
  • იმპლიციტური შეუთავსებელი რიცხვის მცოცავი წერტილიდან მთელ რიცხვამდე კონვერტაცია მოძველებულია.
  • finfo მოდული: file_info რესურსები ახლა წარმოდგენილია როგორც finfo ობიექტი.
  • IMAP: imap რესურსები ახლა წარმოდგენილია როგორც IMAP\Connection ობიექტი.
  • FTP Extension: Connection რესურსები ახლა წარმოდგენილია როგორც FTP\Connection ობიექტი.
  • GD Extension: Font identifiers тახლა წარმოდგენილია როგორც GdFont ობიექტი.
  • LDAP: რესურსები ახლა წარმოდგენილია როგორც ობიექტი LDAP\Connection, LDAP\Result, და LDAP\ResultEntry objects.
  • PostgreSQL: რესურსები ახლა წარმოდგენილია როგორც ობიექტი PgSql\Connection, PgSql\Result, და PgSql\Lob.
  • Pspell: რესურსები pspell, pspell config წარმოდგენილია როგორც ობიექტი PSpell\Dictionary, PSpell\Config
To Top