The Core Hosting

PHP 7.4 ist endlich erschienen! Diese Version, die am 28. November 2019 neu veröffentlicht wurde, ist jetzt auf allen Der Hosting-Typ  Diener. Entwickler können Verbesserungen bei der Lesbarkeit, Wartung und Benutzerfreundlichkeit des Codes erwarten. Schauen wir uns einige der Funktionen an, die neue Leistungsoptimierungen sind, zusammen mit anderen Faktoren, warum Sie auf PHP 7.4 migrieren müssen.

Inhaltsverzeichnis: 

• Was bedeutet PHP 7.4 für Sie?
• Ändern der PHP-Version
• Was ist neu in PHP 7.4?
• Missbilligungen

Was bedeutet PHP 7.4 für Sie?

PHP entwickelt sich weiter, indem es sein neuestes PHP 7.4 up-date veröffentlicht, das reich an brandneuen Funktionen ist. Wie wir in früheren PHP 7-Versionen beobachtet haben, verbessern sich Geschwindigkeit und Leistung ständig. Eines der aufregendsten Features, die neu sind *************************)Preloading. Es kann helfen, Skripte zu beschleunigen, die auch die Fähigkeit bieten, schnellere und sauberere Regeln zu haben, als Ergebnis der Vereinfachung typischer Regellinien.

Die guten Personen, die für PHP verantwortlich sind, haben tatsächlich die Meinungen und Bedürfnisse ihres Publikums gehört und ihnen mit voller Kraft geantwortet. Seitdem ist Code, der sich ständig ändert, intuitiver und besser zwischen Entwicklungssprachen zu wechseln.

PHP kann in über 78,9% der meisten Websites verwendet werden. Laut W3techs, die am häufigsten verwendeten Websites PHP, die verwendet werden, sind Pinterest und Twitter, um mehrere zu nennen.

(wir können eine doppelte Geschwindigkeitssteigerung sehen ****************) Wenn wir uns speziell WordPress-Sites ansehen, auf denen PHP läuft, vergleichen wir PHP 5 und 7. WordPress-basierte Websites gewinnen definitiv am meisten, wenn sie die neueste PHP-Version verwenden. Die Hosting Guy-Benutzer können ihre WordPress-Sites mit nur einem Klick auf eine Schaltfläche auf neue Höhen bringen.

Sehen Sie jede dieser Figuren, die cool sind? Diese Grafik spuckt etwas Wahrheit über Websites, die PHP ernsthaft nutzen. Sind 39.191.714  Live-Websites genug, um Ihre Aufmerksamkeit zu erregen? Genau so viele nutzen PHP gerade. Außerdem testet PHP 7.4 viel besser als PHP 7.3 mit verbesserter Leistung und anderen Verbesserungen des Wohlbefindens.

Die folgende Grafik programmiert die Gesamtwertung Bewertung  auf neuen und alten Variationen von PHP. Einige der getesteten Anforderungen waren unter anderem Einfachheit der Bedienung, Rate und Befriedigung.

Ändern Ihrer PHP-Variation

Bereit für ein Upgrade? Dachte ich. Der Hosting-Typ sorgt dafür, dass es mit Ihren vier einfachen Schritten so einfach wie immer ist. Sie werden praktisch in kürzester Zeit mit Ihrer neuen und verbesserten Version herumspielen, die PHP ist.

1. Melden Sie sich bei Ihrem The Hosting-Man-Konto an und drücken Sie den Home-Schalter .
2. Scrollen Sie auf Ihrer Hausseite ernsthaft nach unten zum  AbschnittHosting und klicken Sie dann auf das Symbol Verwalten .
3. Geben Sie im Suchfeld dasPHP-Setup ein  und klicken Sie dann darauf.
4. Wählen Sie PHP 7.4 und klicken Sie einfach auf Speichern.

Congrats! An dieser Stelle erhalten Sie die beste und aktuellste PHP-Version.

Um Ihre Gesamtversion zu überprüfen, die PHP ist, müssen Sie nur die Hosting  und checken Sie das verbleibende Bauteilfenster für PHP-Variation. Wenn es sich um etwas handelt, das deutlich unter 7.4 liegt, führen Sie ein Upgrade durch.

Was ist neu in PHP 7.4?

Seit 2016 veröffentlicht PHP7 Updates, die jährlich fehlschlagen. Jeder von ihnen bietet neue Funktionen, Ergänzungen und die Möglichkeit, saubereren Code zu schreiben, der die Sprache zuverlässiger und benutzerfreundlicher für diejenigen macht, die sie auf ihren Websites ausführen. ( Jahr*******************)

Lassen Sie uns einen Blick darauf werfen und einfach einen genaueren Blick auf einige der Änderungen werfen, die durch die Hinzufügung von PHP 7.4 vorgenommen wurden. Für eine Liste, die ihr Changelog vollständig ist hier.

Vorabladen

Lassen Sie uns über Regeln sprechen. Bei der Verwendung eines Frameworks oder von Bibliotheken müssen seine Dateien bei jeder Anfrage verknüpft und geladen werden. Beim Vorladen können Sie Frameworks und Bibliotheken in OPCache laden. Es ermöglicht dem Server, die PHP-Dateien zu laden und sie während des Starts im Speicher zu speichern und sie für zukünftige Anfragen verfügbar zu haben. Erwähnen Sie, dass die Dinge schnell in Gang kommen!

Das Vorladen wird von einem bestimmten php.ini  Richtlinie: opache.preload. Dies hat den PHP-Skript-Compiler und wird ausgeführt, sobald der Host startet. Es wird auch verwendet, um mehr Dateien vorab zu laden und sie entweder einzuschließen oder zu kompilieren.

Dies rockt !, aber für den Fall, dass auf diese Weise die vorgeladenen Dateien jemals geändert werden, muss der Server neu gestartet werden. Die vorinstallierten Dateien bleiben für immer im OPCache-Speicher zwischengespeichert.

Diese vorinstallierten Dateien bleiben jedoch für zukünftige Anforderungen konzipiert, falls Sie sie jemals wieder verwenden müssen.

Spread-Operator in Arrayausdrücken

Damals, als PHP 5.6 uraufgeführt wurde, begann PHP ein Argument, das (Spread-Operator) unterstützt, aber jetzt, mit 7.4, können wir diese Funktion mit einer Auswahlphrase nutzen. Das Entpacken von Argumenten ist eine Syntax zum Entpacken von Arrays und Traversables in Argumentlisten. Und um es durchzuführen, muss es nur von … (3 Punkte) Das wars.

Lassen Sie uns dieses Beispiel verstehen:

$animals = ['dog', 'cat'];
$animalkingdom = ['lion', 'elephant', ...$animals, 'giraffe'];
// [‘lion’, ‘elephant’, ‘dog’, ‘cat’, ‘giraffe’];

Wir sind jetzt in der Lage, eine Auswahl von überall aus zu erweitern, wo wir ein zusätzliches Array wünschen, indem wir einfach die Spread-Operator-Syntax verwenden.

$num1 = [1, 2, 3];
$num2 = [...$num1]; // [1, 2, 3]
$num3 = [0, ...$num1]; // [0, 1, 2, 3]
$num4 = array( num1 that is...$ ...$num2, 111); // [1, 2, 3, 1, 2, 3, 111]
$num5 = [...$num1, ...$num1]; // [1, 2, 3, 1, 2, 3]

Nicht nur das, Sie könnten es zusätzlich in einer Funktion verwenden. Betrachten Sie dieses Beispiel:

function getNum() {
  return ['a', 'b'];
}
$num6 = [...getNum(), 'c']; // ['a', 'b', 'c']
$num7 = [...new NumIterator(['a', 'b', 'c'])]; // ['a', 'b', 'c']
function arrGen() {
    for($i = 11; $i < 15; $i++) {
        yield $i;
    }
}
$num8 = [...arrGen()]; // [11, 12, 13, 14]

Darüber hinaus sind Sie jetzt in der Lage, Arrays und Generatoren, die von einer Funktion zurückkommen, direkt in ein neues Array zu entpacken.

Ein Regelbeispiel scheint folgendes zu sein:

function getAnimals(){
  return ['dog', 'cat', 'elephant'];
}
$num1 = [...getAnimals(), 'lion', 'tiger', 'giraffe'];

Und mit PHP 7.4 konnte es drucken:

array(6) {
  [0]=>
  string(3) "dog"
  [1]=>
  string(3) "cat"
  [2]=>
  string(8) "elephant"
  [3]=>
  string(4) "lion"
  [4]=>
  string(5) "tiger"
  [5]=>
  string(7) "giraffe"
}

Mit diesem neuen Array sollten Spread-Operatoren eine bessere Leistung während der gesamten 7.3 array_merge. Der Grund dafür ist, dass der Spread-Operator eine Sprachstruktur ist, während   array_merge ist eine Funktion. Zusätzlich, weil der Spread-Operator unterstützt Objekte  Implementierung von durchführbaren und   array_merge Unterstützt nur Arrays.

Beachten Sie, dass es möglich ist, nur indizierte Arrays zu verwenden, da Sequenztipps nicht unterstützt werden. Wenn verwendet, wird ein Fehler, der behoben werden kann, auf dem Bildschirm ausgelöst, sobald ein Zeichenfolgenschlüssel verfügbar ist.

Ein weiterer glorreicher Vorteil von 7.4 könnte die Beseitigung des array_merge sein. Verabschieden Sie sich von der gefürchteten Indexänderung!

Lassen Sie uns zum Beispiel dieses lange Array verstehen, das unten gewickelt ist:

$array = [‘banana, ‘orange’];
$array[2] = ‘orange’;
$array[1] = ‘apple’; //shifting
var_dump($array); 
// prints 
array(3) {
  [0]=>
  string(6) "banana"
  [1]=>
  string(5) "apple"
  [2]=>
  string(6) "orange"

Ein weiterer Vorteil von 7.4 ist die Nutzung der Generatorfunktion. Ein Generatorfunktion  Funktioniert genau wie eine Funktion, die normal ist, außer an der Stelle des Zurückkommens eines Wertes, eine Generatorfunktion liefert so viele Werte, weil sie dies erfordert.

Sehen Sie sich die folgende Instanzregel an:

function generator() {
  for ($i = 3; $i <= 5; $i++) {
    yield $i;
  }
}
$num1 = [0, 1, 2, ...generator()];

Schwache Empfehlungen

Jetzt hat PHP 7.4 eine WeakReference-Klasse, die niemals mit der Klasse WeakRed oder der Weakref-Erweiterung verwechselt werden kann.

SchwachReferenzen  Lassen Sie den Programmierer sich eine Anleitung zu einem Element merken. Dies ist sicherlich hilfreich, da es nicht verhindert, dass der Artikel beschädigt wird. Sie waren ideal für die Anwendung cacheähnlicher Strukturen.

WeakReference {
/* Methods */
public __construct ( void )
public static create ( object $referent ) : WeakReference
public get ( void ) : ?object

Kontravariante Parameter und Kovariante kommt zurück

Derzeit verwendet PHP Parameter, die meist invariant und Rückgabetypen sind. Das heißt, dann muss der Subtype-Parameter oder Rückgabetyp auch Typ sein Auflage. ( , wenn eine Methode den Parameter oder Rückgabetyp X*********************** hat)

Jetzt, mit PHP 7.4, schlägt es vor,kovariant (geordnet von speziell zu generisch) undkontravariant   (Umkehrung Ihrer Reihenfolge) auf Parameter- und  Rückgabearten zu erlauben .

Hier ist ein gutes Beispiel für beides:

Beispiel für kovariante Rückgabearten:

interface Factory {
  function make(): object;
}
class UserFactory implements Factory {
  function make(): User;
}

Kontravarianter Parameter Art Beispiel:

interface Concatable {
  function concat(Iterator $input); 
}
class Collection implements Concatable {
  // accepts all iterables, not just Iterator
  function concat(iterable $input) {/* . . . */}
}

Typisierte Merkmale 2.0

Seit PHP 5 sind freundliche Tipps eine Funktion, mit der Sie den Typ der Variablen angeben können, die an eine Funktion oder Klasse übergeben werden sollen. Die Hinzufügung der Objekt  Datentyp gab Hoffnung, dass in Zukunft mehr in den PHP 7.2-Migrationen verfügbar sein würde. Die langfristige ist derzeit.

In dieser neuen Version 7.4 hat PHP die Fähigkeit, die Typliste anzubieten:

bool, int, float, string, array, object, iterable, self, parent
any class or interface name
?type // where "type" may be any of the above

Beachten Sie, dass der übergeordnete Typ in Klassen verwendet werden kann und keine Mutter und kein Vater besitzen muss, um dem Parameter und dem Rückgabetyp zu entsprechen.

Beachten Sie außerdem, dass void und callable nicht unterstützt werden.  Leere  wurde eliminiert, da es nicht hilfreich war und eine Semantik hatte, die unklar ist*************************)Callable, da sein Verhalten kontextabhängig war.

Lassen Sie uns noch mehr Beispiele durchstöbern.

Hier ist ein Kurs, geschrieben für PHP 7.3:

class User {
    /** @var int $id */
    private $id;
    /** @var string $name */
    private $name;
 
    public function __construct(int $id, string $name) {
        $this->id = $id;
        $this->name = $name;
    }
 
    public function getId(): int {
        return $this->id;
    }
    public function setId(int $id): void {
        $this->id = $id;
    }
 
    public function getName(): string {
        return $this->name;
    }
    public function setName(string $name): void {
        $this->name = $name;
    }
}

In PHP 7.4, ohne auf Typsicherheit verzichten zu müssen, kann ein Kurs jetzt so einfach geschrieben werden:

class User {
    public int $id;
    public string $name;
 
    public function __construct(int $id, string $name) {
        $this->id = $id;
        $this->name = $name;
    }
}

Sehen Sie sich Beispiele der meisten Typen an, die 7.4 jetzt unterstützt:

class Example {
  
    public int $scalarType;
    protected ClassName $classType;
    private ?ClassName $nullableClassType;
    // Types are also legal on static properties
    public static iterable $staticProp;
    // Types can also be used with the "var" notation
    var bool $flag;
    // Typed properties may have default values (more below)
    public string $str = "foo";
    public ?string $nullableStr = null;
    // The type applies to all properties in one declaration
    public float $x, $y;
    // equivalent to:
    public float $x;
    public float $y;
}

Pfeilfunktionen 2.0

Anonyme Funktionen in PHP sind normalerweise wortreich und lang, auch wenn sie wirklich nur einfache Operationen ausführen. Dies ist teilweise auf eine Menge zurückzuführen, die groß ist, und teilweise auf die manuell importierten verwendeten Faktoren.

Dies macht eine Regel, die Verschlüsse verwendet, die einfach zu erlernen und schwieriger zu wissen sind.

Schauen wir uns eine Regel an, die Sie mit PHP 7.3 verwenden würden:

function array_values_from_keys($arr, $keys) {
    return array_map(function ($x) use ($arr) { return $arr[$x]; }, $keys);
}

Im Folgenden finden Sie die prägnantere Syntax von 7.4:

function array_values_from_keys($arr, $keys) {
    return array_map(fn($x) => $arr[$x], $keys);
}

Daher sind Pfeilfunktionen im Besitz dieser Form:

fn(parameter_list) = expr

Unten sehen Sie ein gutes Beispiel für zwei Funktionen $fn 1 (7,3)  und $fn 2 (7,4)  Seite für Teil. Sie haben das Ergebnis, das gleich aussieht:

$y = 1;
$fn1 = fn($x) => $x + $y;
$fn2 = function ($x) use ($y) 
{
    return $x + $y;
};

Dies kann auch funktionieren, wenn die Pfeilfunktionen verschachtelt sind:

$z = 1;
$fn = fn($x) => fn($y) => $x * $y + $z;

Genau hier die Funktion, die äußer*************************)$z. Dann erfasst  auch die innere Funktion$z von der Funktion, die äußerlich ist. Mit 7.4 wird der externe Bereich in der Funktion erreichbar, die innen ist. Dies ist sicherlich eine Sache, zu der 7.3 nicht in der Lage war.

Die Syntax der Pfeilfunktion ermöglicht viele verschiedene Funktionen wie z.B. Variadik, Standardwerte, Parameter- und Rückgabearten sowie das Verschieben und Zurückkommen von Referenzen. Und das alles unter Beibehaltung eines sauberen, lesbaren Erscheinungsbildes. Hier sind die meisten gültigen Pfeilfunktionen (die jetzt verfügbar sind***********************)

fn(array $x) => $x;
fn(): int => $x;
fn($x = 42) => $x;
fn(&$x) => $x;
fn&($x) => $x;
fn($x, ...$rest) => $rest;

Eine Sache, die zu beachten ist, ist die Tatsache, dass Pfeilfunktionen tatsächlich die billigste Priorität haben. Sehen Sie sich das Beispiel an:

fn($x) => $x + $y
// is
fn($x) => ($x + $y)
// not
(fn($x) => $x) + $y

Missbilligungen

Es gibt zahlreiche Verwerfungen, die bei der Verwendung der Zusammenführung zu 7.4 auftreten. Die Liste, die auf eine kurze Übersicht über die Funktionen folgt, die veraltet sind. Sie können eine detailliertere hier finden:|*************) das ist explanation(” class=”synonym”>*************) das ist explanation  (

• Der echte Typ
• Magic zitiert Vermächtnis
• array_key_exists()  mit Objekten
•   FILTER_SANITIZE_MAGIC_QUOTES Filter
• Reflection export() Methoden
• mb_strrpos()  mit Kodierung als 3. Argument
• implode()  Parameterreihenfolge-Mix
• Unverbindlich $this von nicht-statischen Verschlüssen
• hebrevc()  Funktion
• convert_cyr_string()  Funktion
• money_format()  Funktion
• ezmlm_hash()  Funktion
• restore_include_path()  Funktion
•   allow_url_include INI Directiv

Einige wesentliche, die zu beachten sind, wären die nach zweistufigen Abwertungen.

Ändern der Priorität eines Verkettungsoperators

Derzeit der Vorrang von ‘.’, ‘+’ und Operatoren, die alle gleich sind. Jede Kombination dieser Operatoren wird einfach von links nach rechts gelöst.

Lassen Sie uns diese Regel in PHP 7.3 verstehen:

echo "sum: " . $a + $b; 
// would be evaluated left-to-right
echo ("sum: " . $a) + $b;
// could also look like this

Mit PHP 7.4 würden ‘+’ und ‘-‘ einfach Vorrang vor ‘.’ haben, so dass die Verbesserungen und Subtraktionen immer vor dem String durchgeführt würden. Dies würde wie das (das ist folgende*********************)

echo "sum: " . $a + $b; 
// would be executed as if the code were as follows.
echo "sum :" . ($a + $b);

Diese zweistufigen Vorschläge zielen weniger fehleranfällig und instinktiver ab. PHP 7.4 befindet sich derzeit in der Phase, in der es sich zunächst um eine Deprecation Notice von nicht in Klammern stehenden Ausdrücken von ‘+’, ‘-‘ und ” handelt. Während des Wartens auf die Abstimmung / Änderung, die in PHP 8 endgültig ist.

Linksassoziativer ternärer Operator

Im Gegensatz zu fast allen anderen Sprachen ist der Operator, der ternäres PHP ist, linksassoziativ im Gegensatz zu rechtsassoziativ. Es ist nicht nur ungewöhnlich, sondern auch verwirrend für Programmierer, die zwischen verschiedenen Sprachen wechseln. PHP 7.4 schlägt vor, die Linksassoziativität loszuwerden und benötigt eher die Verwendung von Klammern.

Werfen wir einen guten Blick auf die folgende Regel:

return $a == 1 ? 'one'
     : $a == 2 ? 'two'
     : $a == 3 ? 'three'
     : $a == 4 ? 'four'
               : 'other';

In fast allen anderen Sprachen wird es interpretiert als:

return $a == 1 ? 'one'
     : ($a == 2 ? 'two'
     : ($a == 3 ? 'three'
     : ($a == 4 ? 'four'
               : 'other')))

während es in PHP wirklich alternativ interpretiert wird als:

return ((($a == 1 ? 'one'
     : $a == 2) ? 'two'
     : $a == 3) ? 'three'
     : $a == 4) ? 'four'
               : 'other';

Dies kann zu Fehlern führen, da es im Allgemeinen vielleicht nicht das ist, was gemeint war.

Durch einen anderen zweistufigen Vorschlag hat PHP 7.4 die explizite Verwendung von Klammern als Deprecation-Warnung implementiert und wird sicherlich einen Kompilierungs-Laufzeitfehler in zukünftigen Variationen ausführen.

Schlussfolgerung

Gerade mit der Zeit für die Weihnachtszeit bringt PHP 7.4 Funktionen, die neue Verbesserungen für das Wohlbefinden für mehrere PHP-Entwickler darstellen.

WordPress-Websites werden diese Verbesserungen sicherlich nutzen und ihre Benutzer können schnellere Ausführungszeiten erhalten, viel weniger Speicherverbrauch, wenn PHP, das 7.4 mit früheren Inkarnationen verwendet.

Mit dem Hinzufügen von erstklassigen Heimerklärungen und freundlichen Hinweisen, Pfeilzusammenführungsfunktionen und einer lächerlich besseren Rate wird der 7.4 sicherlich sowohl die Rate als auch die Qualität des eigenen Workflows verbessern.