The Core Hosting

Contact Info

2205 W 136th Avenue Ste 106 PMB 64269 Broomfield, CO 80023

+1(833) 321-5499

sales@thecorehosting.net

PHP 7.4 est enfin apparu ! Cette version qui est nouvelle publiée le 28 novembre 2019, est maintenant disponible sur tous les Le gars  de l’hébergement Serveurs. Les développeurs peuvent s’attendre à des améliorations en termes de lisibilité du code, de maintenance et de facilité d’utilisation. Regardons quelques-unes des fonctionnalités qui sont de nouveaux ajustements de performance ainsi que d’autres facteurs pour lesquels vous devez migrer vers PHP 7.4.

Table des matières : 

Que signifie PHP 7.4 pour vous ?

PHP continue d’évoluer, en publiant sa nouvelle mise à jour PHP 7.4, riche en nouvelles fonctionnalités. Comme nous l’avons observé dans les versions précédentes de PHP 7, la vitesse et les performances ne cessent de s’améliorer. L’une des fonctionnalités les plus intéressantes qui sont le nouveau préchargement *********************). Cela peut aider le script qui accélère également la capacité d’avoir une règle plus rapide et plus propre, grâce à la simplification des lignes de règle typiques.

Les bonnes personnes en charge de PHP ont réellement entendu les opinions et les besoins de leur public et y ont répondu en toute leur force. Depuis, ils ont été le code qui change continuellement devenir plus intuitif et mieux pour basculer entre les langages de développement.

PHP peut être utilisé dans plus de 78,9% de la plupart des sites Web. D’après W3techs, les sites Web les plus utilisés par PHP qui utilisent sont, Pinterest et Twitter pour en appeler plusieurs.

(nous pouvons voir une double augmentation de vitesse ****************) Si nous regardons spécifiquement les sites WordPress exécutant PHP, en comparant PHP 5 et 7. Les sites Web alimentés par WordPress gagnent certainement le plus en utilisant la dernière version de PHP. Les utilisateurs de Hosting Guy peuvent surcharger leurs sites WordPress à des hauteurs qui sont nouvelles simplement un clic sur un bouton.

Statistiques D’utilisation De Php

Vous voyez chacun de ces chiffres qui sont cool? Ce graphique crache une certaine vérité sur les sites Web qui utilisent sérieusement PHP. Are 39 191 714  Des sites Web en direct suffisent-ils à attirer votre attention? C’est exactement combien utilisent PHP en ce moment. De plus, PHP 7.4 teste beaucoup mieux que PHP 7.3 avec des performances améliorées ainsi que d’autres améliorations du bien-être.

Le graphique ci-dessous programme l’ensemble Test  de référence sur les nouvelles et anciennes variantes de PHP. Quelques-unes des exigences testées étaient la simplicité d’utilisation, le taux et la gratification, entre autres.

Moyenne Géométrique Php De Tous Les Résultats

Changer votre variante PHP

Prêt à effectuer la mise à niveau ? Je le pensais. Le gars de l’hébergement le rend aussi simple que jamais avec vos quatre étapes simples. Vous allez jouer avec votre nouvelle version améliorée qui est PHP pratiquement pas le temps.

  1. Connectez-vous à votre compte The Hosting man et appuyez sur le  commutateurHome .
  2. Sur votre page d’accueil, faites défiler sérieusement jusqu’à la section Hébergement, puis cliquez sur l’icône  Gérer  .
  3. Dans le champ de recherche, saisissez la configuration PHP, puis cliquez à ce sujet.
  4. Sélectionnez PHP 7.4 et cliquez simplement sur Enregistrer.
Activation De Php 7.4 Dans Hostinger Hpanel

Félicitations! À ce stade, vous obtenez la meilleure et la plupart des PHP qui sont à jour là-bas.

Pour vérifier votre version globale qui est PHP, tout ce que vous avez à faire est de visiter le Hébergement  et consultez le panneau de pièces restantes pour Variation PHP. S’il s’agit d’un montant nettement inférieur à 7.4, allez-y et mettez à niveau.

Quoi de neuf dans PHP 7.4?

Depuis 2016, PHP7 publiait des mises à jour qui sont des échecs annuels. Chacun d’eux offre de nouvelles fonctionnalités, des ajouts et la possibilité d’écrire un code plus propre qui rend le langage plus fiable et convivial pour ceux qui l’exécutent sur leurs sites Web. ( année*******************)

Creusons et jetons simplement un meilleur coup d’œil à un certain nombre de modifications qui ont été apportées à partir de l’ajout de PHP 7.4. Pour une liste complète leur changelog ici.

Préchargement

Parlons de règle. Lors de l’utilisation d’un framework ou de bibliothèques, ses fichiers doivent être liés et chargés à chaque demande. Le préchargement est lorsque vous pouvez charger des frameworks et des bibliothèques dans OPCache. Il permet au serveur de charger les fichiers PHP et de les stocker en mémoire pendant le démarrage et de les rendre disponibles pour toutes les demandes futures. Mentionnez que les choses vont vite!

Le préchargement est exécuté par un php.ini  directive: opache.preload. Cela a obtenu le compilateur de script PHP et s’exécute une fois que l’hôte démarre. Il est également utilisé pour précharger plus de fichiers et choisir de les inclure ou de les compiler.

Néanmoins, dans le cas où pour obtenir les fichiers préchargés jamais modifiés, le serveur doit être redémarré. Les fichiers préchargés restent mis en cache dans la mémoire OPCache pour toujours.

Cependant, ces fichiers préchargés restent conçus pour tous les besoins futurs au cas où vous auriez besoin de les utiliser à nouveau.

Opérateur de propagation dans les expressions de tableau

À l’époque où PHP 5.6 a été créé, PHP a commencé un argument qui prend en charge (opérateur de propagation) mais maintenant, avec 7.4, nous sommes en mesure d’utiliser cette fonction avec une phrase de sélection. Le décompression d’arguments est une syntaxe permettant de décompresser des tableaux et des traversables dans des listes d’arguments. Et, pour mener à bien donc, il suffit d’être précédé par … (3 points.) Voilà.

Comprenons cet exemple :

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

Nous sommes maintenant en mesure d’étendre une sélection à partir de n’importe quel endroit où nous voulons un tableau supplémentaire, simplement en utilisant la syntaxe Spread Operator.

$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]

Non seulement cela, vous pouvez également l’utiliser dans une fonction. Prenons l’exemple suivant :

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]

De plus, vous êtes maintenant en mesure de décompresser les baies et les générateurs qui sont renvoyés par une fonction directement dans un tableau qui est nouveau

Voici un exemple de règle :

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

Et avec PHP 7.4, il pourrait imprimer:

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"
}

Avec cette matrice qui est nouvelle, les opérateurs de propagation devraient avoir des moyens de meilleures performances tout au long de la 7.3 array_merge. La raison en est que l’opérateur de propagation est une structure de langage alors que   array_merge est une fonction. De plus, parce que l’opérateur de propagation prend en charge Objets  Mise en œuvre traversable et   array_merge Ne prend en charge que les tableaux.

Quelques considérations à noter, il est possible d’utiliser simplement des tableaux indexés puisque les pointes de séquence ne sont pas prises en charge. Si elle est utilisée, une erreur récupérable est jetée dans l’écran d’affichage, une fois qu’une touche de chaîne est disponible.

Un autre avantage glorieux de 7.4 peut être l’élimination de la array_merge. Adieu au redoutable changement d’indice !

Par exemple, comprenons ce long tableau qui est enroulé ci-dessous:

$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"

Un autre avantage de la version 7.4 est l’utilisation de la fonction génératrice. Un Fonction  générateur Fonctionne exactement comme une fonction qui est normale sauf qu’au lieu de renvoyer une valeur, une fonction génératrice donne autant de valeurs car elle le nécessite.

Sortez de la règle d’instance ci-dessous :

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

Recommandations faibles

Maintenant, PHP 7.4 a une classe WeakReference, qui ne sera jamais confondue en utilisant la classe WeakRed ou l’extension Weakref .

FaiblesseRéférences  Laissez le programmeur se souvenir d’un guide pour un élément. Ceci est certainement utile car cela n’empêche pas l’article d’être endommagé. Ils ont été idéaux pour appliquer des structures de type cache.

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

Paramètres contravariants et retour covariant

Actuellement, PHP utilise des paramètres qui sont principalement des types invariants et de retour. Cela signifie que le paramètre de sous-type ou le type de retour doit également être de type X. ( si une méthode a un paramètre ou un type de retour de X************************)

Maintenant, avec PHP 7.4, il propose d’autoriser  covariant (ordonné de particulier à générique) etcontravariant   (inversant votre ordre) sur les types de paramètres et  de retour.

Voici un bon exemple des deux:

Exemple de type de retour covariant :

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

Exemple de type de paramètre contravariant :

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

Caractéristiques typées 2.0

Depuis PHP 5, les conseils de type sont une fonctionnalité qui vous permet de spécifier le type de variable qui doit être passé à une fonction ou une classe. L’ajout de l’ objet  Le type de données a donné l’espoir que plus serait disponible à l’avenir dans les migrations PHP 7.2. Le long terme est actuellement.

Dans cette nouvelle version 7.4, PHP a la capacité d’offrir la liste des types:

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

Notez que le typeparent peut être utilisé dans les  classes et n’a pas besoin de posséder une mère et un père conformément au paramètre et au type de retour.

Notez également que void et callable ne sont pas pris en charge.  Vide  a été éliminé car il n’avait pas été utile et avait une sémantique qui n’est pas claire*********************)Callable, parce que son comportement avait été dépendant du contexte.

Parcourons encore plus d’exemples.

Voici un cours, écrit pour 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;
    }
}

En PHP 7.4, sans avoir à sacrifier la sécurité des types, un cours peut maintenant être écrit aussi simple que :

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

Découvrez des exemples de la plupart des types pris en charge par la version 7.4 :

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;
}

Fonctions fléchées 2.0

Les fonctions anonymes en PHP sont généralement verbeuses et longues, même si elles ne font vraiment que des opérations simples. Cela est dû en partie à une quantité importante de passe-partout, et en partie à la nécessité d’importer manuellement les facteurs utilisés.

Cela rend la règle qui utilise des fermetures qui sont simples à apprendre ainsi que plus difficiles à connaître.

Voyons une règle que vous utiliseriez avec PHP 7.3:

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

Maintenant, ce qui suit est la syntaxe plus concise de 7.4:

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

Par conséquent, les fonctions de flèche sont en possession de cette forme:

fn(parameter_list) = expr

Ci-dessous, vous pouvez observer un bon exemple de deux fonctions $fn 1 (7,3)  et $fn 2 (7,4)  côte à côte. Ils ont le résultat qui est le même aspect varié:

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

Cela peut également fonctionner si les fonctions de flèche sont imbriquées :

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

Juste ici la fonction qui est outer*********************)$z. Ensuite, la fonction interne capture  également$z de la fonction externe. Avec 7.4, la plage externe devient accessible dans la fonction interne. C’est certainement une chose que 7.3 n’était pas en mesure de faire.

La syntaxe de la fonction de flèche active de nombreuses fonctions différentes telles que, par exemple, les variadiques, les valeurs standard, les types de paramètres et de retour, en plus du déplacement et du retour par référence. Tout en conservant une apparence propre et lisible. Voici la plupart des fonctions de flèche valides (qui est maintenant disponible*******************)

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

Une chose à noter est le fait que les fonctions de flèche ont en fait la priorité la moins chère. Commencez à voir l’exemple :

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

Dépréciations

De nombreuses dépréciations se produisent en utilisant la fusion vers la version 7.4. Liste qui suit une brève vue d’ensemble des fonctions ciblées pour l’obsolescence. Vous pouvez trouver un plus détaillé ici:|*************) qui est explanation( » class=”synonym”>*************) qui est explanation  (

  • Le vrai type
  • Magic cite l’héritage
  • array_key_exists()  avec des objets
  •   FILTER_SANITIZE_MAGIC_QUOTES filtre
  • Méthodesd’exportation par  réflexion 
  • mb_strrpos()  avec l’encodage comme 3ème argument
  • imploser()  Mélange de commandes de paramètres
  • Détachement  $this des fermetures non statiques
  • hebrevc()  fonction
  • convert_cyr_string()  fonction
  • money_format()  fonction
  • ezmlm_hash()  fonction
  • restore_include_path()  fonction
  •   allow_url_include ini directiv

Certains éléments essentiels à noter seraient les dépréciations après deux étapes.

Modification de la priorité d’un opérateur de concaténation

Actuellement, la priorité de ‘.’, ‘+’ et les opérateurs qui sont tous égaux. Toute combinaison de ces opérateurs sera résolue simplement de gauche à droite.

Comprenons cette règle dans PHP 7.3:

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

Avec PHP 7.4, ‘+’ et ‘-‘ auraient simplement la priorité sur ‘.’ afin que les améliorations et les soustractions soient effectuées avant toujours la chaîne. Cela ressemblerait au ( qui suit **********************)

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

Cette proposition en deux étapes vise à devenir moins sujet aux erreurs et plus instinctif. PHP 7.4 est actuellement dans le stade qui est d’abord un avis d’obsolescence des expressions non entre parenthèses de ‘+’, ‘-‘ et ‘.’ En attendant le vote/changement qui est définitif en PHP 8.

Opérateur ternaire associatif gauche

Contrairement à presque tous les autres langages, l’opérateur qui est PHP ternaire est associatif gauche par opposition à associatif droit. Non seulement inhabituel, mais il est également déroutant pour les codeurs qui passent d’une langue à l’autre. PHP 7.4 propose de se débarrasser de l’associativité gauche et a plutôt besoin de l’utilisation de parenthèses.

Jetons un coup d’œil à la règle ci-dessous:

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

Dans presque toutes les autres langues, il sera interprété comme:

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

alors qu’en PHP, il est vraiment interprété alternativement comme:

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

Cela peut causer des erreurs car ce n’est généralement peut-être pas ce que l’on voulait dire.

Grâce à une proposition différente en deux étapes, PHP 7.4 a implémenté l’utilisation explicite de parenthèses comme avertissement de dépréciation et comportera certainement idéalement une erreur d’exécution de compilation dans les variations futures.

Conclusion

Juste avec le temps pour la saison des fêtes, PHP 7.4 apporte des fonctionnalités qui sont de nouvelles améliorations de bien-être pour plusieurs développeurs PHP.

Les sites Web WordPress profiteront sûrement de ces améliorations et leurs utilisateurs peuvent obtenir des temps d’exécution plus rapides beaucoup moins d’utilisation de la mémoire chaque fois que PHP utilise 7.4 avec des incarnations antérieures.

Avec l’ajout de déclarations de type domestique de première classe et d’allusions aimables, de fonctions de fusion de flèches et d’un taux ridiculement meilleur, le 7.4 améliorera certainement à la fois le taux et la qualité de son flux de travail.

Share this Post
0 0 votes
Article Rating
Subscribe
Notify of
guest
0 Comments
Inline Feedbacks
View all comments
0
Would love your thoughts, please comment.x
()
x