Un service RESTful simple en PHP natif. $_SERVER - Informations sur le serveur et l'environnement d'exécution Ce que notre service RESTful devrait être capable de faire
Les possibilités d'organiser, de rechercher et de diffuser efficacement l'information intéressent depuis longtemps les spécialistes du domaine de la technologie informatique. Étant donné que l'information est principalement du texte composé de caractères alphanumériques, le développement de moyens de recherche et de traitement de l'information selon des modèles qui décrivent le texte est devenu l'objet de recherches théoriques sérieuses.
La recherche de modèles vous permet non seulement de trouver des fragments de texte spécifiques, mais également de les remplacer par d'autres fragments. Un exemple standard de correspondance de modèles est celui des commandes rechercher/remplacer dans les éditeurs de texte, par exemple MS Word, Emacs et mon éditeur préféré, vi. Tous les utilisateurs UNIX connaissent des programmes tels que sed, awk et grep ; La richesse des capacités de ces programmes est en grande partie due à leurs capacités de recherche de modèles. Les mécanismes de recherche de modèles résolvent quatre problèmes principaux :
- rechercher des chaînes qui correspondent exactement à un modèle donné ;
- rechercher des fragments de chaîne correspondant à un modèle donné ;
- remplacer des chaînes et des sous-chaînes à l'aide d'un modèle ;
- rechercher des chaînes avec un modèle donné ne correspond pas.
L'avènement du Web a créé un besoin pour des outils de recherche de données plus rapides et plus efficaces qui permettent aux utilisateurs du monde entier de trouver les informations dont ils ont besoin sur des milliards de pages Web. Les moteurs de recherche, les services financiers en ligne et les sites de commerce électronique seraient totalement inutiles sans les moyens d’analyser les énormes volumes de données dans ces secteurs. En effet, les moyens de traitement des informations de chaîne constituent un élément essentiel de presque tous les secteurs liés d'une manière ou d'une autre aux technologies de l'information modernes. Ce chapitre se concentre sur les fonctionnalités de traitement de chaînes en PHP. Nous examinerons quelques fonctions de chaîne standard (il y en a plus de 60 dans le langage !), et les définitions et exemples fournis vous donneront les informations dont vous avez besoin pour créer des applications Web. Mais avant d’entrer dans les détails de PHP, je souhaite vous présenter le mécanisme de base qui rend possible la correspondance de modèles. Nous parlons d'expressions régulières.
Expressions régulières
Les expressions régulières sont à la base de toutes les technologies modernes de correspondance de modèles. Une expression régulière est une séquence de caractères simples et de service qui décrivent le texte recherché. Parfois, les expressions régulières sont simples et claires (par exemple, le mot chien), mais elles contiennent souvent des caractères spéciaux qui ont une signification particulière dans la syntaxe des expressions régulières - par exemple,<(?)>.*<\/.?>.
Il existe deux familles de fonctions en PHP, chacune étant un type différent d'expression régulière : de style POSIX ou de style Perl. Chaque type d'expression régulière a sa propre syntaxe et est abordée dans la partie appropriée du chapitre. De nombreux manuels ont été écrits sur ce sujet et peuvent être trouvés aussi bien sur le Web qu'en librairie. Par conséquent, je ne fournirai que des informations de base sur chaque type, et vous pourrez trouver de plus amples informations par vous-même si vous le souhaitez. Si vous n'êtes pas déjà familier avec le fonctionnement des expressions régulières, assurez-vous de lire le court didacticiel d'introduction qui reprend le reste de cette section. Et si vous maîtrisez bien ce domaine, n'hésitez pas à passer à la section suivante.
Syntaxe des expressions régulières (POSIX)
La structure des expressions régulières POSIX rappelle quelque peu la structure des expressions mathématiques typiques - différents éléments (opérateurs) sont combinés les uns avec les autres pour former des expressions plus complexes. Cependant, c’est le sens de la combinaison d’éléments qui fait des expressions régulières un outil si puissant et expressif. Les capacités ne se limitent pas à la recherche de texte littéral (comme un mot ou un nombre spécifique) ; vous pouvez rechercher des chaînes avec une sémantique différente mais une syntaxe similaire – par exemple, toutes les balises HTML d'un fichier.
L'expression régulière la plus simple correspond à un seul caractère littéral ; par exemple, l'expression g correspond à des chaînes telles que g , marchander et sac. Une expression résultant de la concaténation de plusieurs caractères littéraux correspond selon les mêmes règles : par exemple, la séquence gan correspond à n'importe quelle chaîne contenant ces caractères (par exemple, gang, organise ou Reagan).
Opérateur | (barre verticale) teste si l'une des nombreuses alternatives correspond. Par exemple, l'expression régulière php | zend vérifie la chaîne pour php ou zend.
Crochets
Les crochets () ont une signification particulière dans le contexte des expressions régulières : ils signifient « tout caractère répertorié entre parenthèses ». Contrairement à une expression régulière php, qui correspond à toutes les lignes contenant du texte littéral php, l'expression correspond à n'importe quelle ligne contenant les caractères p ou h. Les crochets jouent un rôle important lorsque vous travaillez avec des expressions régulières, car le processus de recherche implique souvent la tâche de trouver des caractères dans un intervalle donné. Vous trouverez ci-dessous quelques intervalles couramment utilisés :
- -- correspond à n'importe quel chiffre décimal de 0 à 9 ;
- -- correspond à n'importe quel caractère minuscule de a à z ;
- -- correspond à n'importe quel caractère majuscule de A à Z ;
- -- correspond à n'importe quel caractère minuscule ou majuscule de a à z.
Bien entendu, les intervalles énumérés ci-dessus ne font que démontrer le principe général. Par exemple, vous pouvez utiliser l'espacement pour représenter n'importe quel chiffre décimal de 0 à 3, ou l'espacement pour représenter n'importe quel caractère minuscule de b à v. Bref, les intervalles sont déterminés de manière totalement arbitraire.
Quantificateurs
Il existe une classe spéciale de caractères de service qui indiquent le nombre de répétitions d'un seul caractère ou d'une construction entourée de crochets. Ces caractères spéciaux (+, * et (...)) sont appelés quantificateurs. Le principe de leur fonctionnement est le plus simple à expliquer avec des exemples :
- p+ signifie un ou plusieurs p caractères consécutifs ;
- p* signifie zéro ou plusieurs p caractères consécutifs ;
- R? signifie zéro ou un caractère p ;
- p(2) signifie deux p symboles d'affilée ;
- p(2,3) signifie deux à trois p caractères d'affilée ;
- p(2,) signifie deux ou plusieurs p caractères consécutifs.
Autres personnages de service
Les caractères de service $ et ^ ne correspondent pas à des symboles, mais à des positions spécifiques dans la chaîne. Par exemple, l'expression p$ signifie une chaîne qui se termine par le caractère p et l'expression ^p signifie une chaîne qui commence par le caractère p.
- La construction [^a-zA-Z] correspond à n'importe quel caractère non inclus aux intervalles indiqués (a-z et A-Z).
- Symbole de service. (point) signifie "n'importe quel caractère". Par exemple, l'expression p.p correspond au caractère p, suivi d'un caractère arbitraire, suivi à nouveau du caractère p.
La combinaison de symboles de service donne lieu à des expressions plus complexes. Regardons quelques exemples :
- ^.(2)$ -- toute chaîne contenant lisse deux personnages ;
- (.*)-- une séquence arbitraire de caractères entre<Ь>Et(probablement des balises HTML pour afficher du texte en gras) ;
- p(hp)* -- le caractère p suivi de zéro ou plusieurs instances de la séquence hp (par exemple, phphphp).
Parfois, vous devez rechercher des caractères spéciaux dans des chaînes au lieu de les utiliser dans le contexte spécial décrit. Pour ce faire, les caractères de service sont échappés avec une barre oblique inverse (\). Par exemple, pour rechercher une somme d’argent, vous pouvez utiliser l’expression \$+, c’est-à-dire « un signe dollar suivi d’un ou plusieurs chiffres décimaux ». Notez la barre oblique inverse avant le $. Les correspondances possibles pour cette expression régulière sont 42 $, 560 $ et 3 $.
Expressions d'intervalle standard (classes de caractères)
Pour faciliter la programmation, le standard POSIX a défini quelques expressions d'intervalle standard, également appelées classes de personnages(classes de personnages). Une classe de caractères définit un caractère dans une plage donnée, par exemple une lettre de l'alphabet ou un chiffre :
- [[:alpha:]] -- caractère alphabétique (aA-zZ) ;
- [[:digit:]]-chiffre (0-9);
- [[:alnum:]] -- caractère alphabétique (aA-zZ) ou chiffre (0-9) ;
- [[:space:]] -- espaces (nouvelles lignes, tabulations, etc.).
Fonctions PHP pour travailler avec des expressions régulières (conformes POSIX)
PHP prend actuellement en charge sept fonctions de recherche utilisant des expressions régulières de style POSIX :
- ereg();
- ereg_replace();
- érégi();
- eregi_replace();
- diviser();
- diviser();
- sql_regcase().
Les descriptions de ces fonctions sont fournies dans les sections suivantes.
La fonction ereg() recherche dans une chaîne donnée une correspondance pour un modèle. Si une correspondance est trouvée, TRUE est renvoyé, sinon FALSE est renvoyé. La syntaxe de la fonction ereg() est :
int ereg (modèle de chaîne, chaîne chaîne [, correspondances de tableau])
La recherche s'effectue en tenant compte de la casse des caractères alphabétiques. Un exemple d'utilisation de ereg() pour rechercher dans les chaînes domains.com :
$is_com - ereg("(\.)(com$)", $email) :
// La fonction renvoie TRUE si $email se termine par les caractères ".com"
// En particulier, la recherche aboutira pour les chaînes
// "www.wjgilmore.com" et " [email protégé]"
Notez qu'en raison de la présence du symbole $, l'expression régulière ne correspond que si la chaîne se termine par des caractères .com. Par exemple, il correspondra à la chaîne « www.apress.com », mais ne correspondra pas dans la ligne "www.apress.com/catalog".
Le paramètre facultatif match contient un tableau de correspondances pour toutes les sous-expressions entre parenthèses dans l’expression régulière. Le listing 8.1 montre comment utiliser ce tableau pour diviser une URL en plusieurs segments.
Inscription 8.1. Impression des éléments du tableau $regs
$url = "http://www.apress.com" ;
// Divise $url en trois composants : "http://www". "apress" et "com"
$www_url = ereg("^(http://www)\.([[:alnum:]+\.([[:alnum:]]+)". $url, $regs);
if ($www_url) : // Si $www_url contient une URL
écho $regs; // La chaîne entière "http://www.apress.com"
imprimer "
";
écho $regs[l]; // "http://www"
imprimer "
";
écho $regs; // "appuyer"
imprimer "
";
écho $regs; // fin "com" ;
L'exécution du script dans le listing 8.1 produit le résultat suivant :
http://www.apress.com http://www apress com
La fonction ereg_replace() recherche dans une chaîne donnée une correspondance pour un modèle et la remplace par un nouveau fragment. Syntaxe de la fonction ereg_replace() :
string ereg_replace (modèle de chaîne, remplacement de chaîne, chaîne chaîne)
La fonction ereg_replace() fonctionne sur le même principe que ereg(), mais ses capacités sont étendues de la simple recherche à la recherche avec remplacement. Après avoir effectué le remplacement, la fonction renvoie la chaîne modifiée. Si correspond
sont manquants, la ligne reste dans le même état. La fonction ereg_replace(), comme ereg(), est sensible à la casse. Vous trouverez ci-dessous un exemple simple illustrant l'utilisation de cette fonction :
$copy_date = "Droit d'auteur 1999" :
$copy_date = ereg_replace("(+)". "2000", $copy_date);
print $copy_date : // Imprime la chaîne "Copyright 2000"
Une fonctionnalité intéressante des outils de recherche et de remplacement de PHP est la possibilité d'utiliser des références arrière à des parties de l'expression principale entre parenthèses. Les références arrière sont similaires aux éléments du paramètre facultatif de correspondance de ereg(), à une exception près : les références arrière sont écrites sous la forme \0, \1, \2, etc., où \0 correspond à la chaîne entière, \1 correspond à une correspondance réussie. première sous-expression, etc. L’expression peut contenir jusqu’à 9 backlinks. L'exemple suivant remplace tous les liens URL dans le texte par des hyperliens fonctionnels :
$url = "Apress (http://www.apress.com");
$url = ereg_replace("http://(()*)", " \\0", $url);
// La ligne s'affiche :
// Apress (http://www.apress.com)
La fonction eregi() recherche dans une chaîne donnée une correspondance pour un modèle. Syntaxe de la fonction eregi() :
int eregi (modèle de chaîne, chaîne chaîne [, correspondances de tableau])
La recherche est en cours à l'exclusion cas des caractères alphabétiques. La fonction eregi() est particulièrement utile pour vérifier la validité des chaînes saisies (par exemple, les mots de passe). L'utilisation de la fonction eregi() est démontrée dans l'exemple suivant :
$mot de passe = "abc" ;
if (! eregi("[[:alnum:]](8.10), $password) :
print "Mot de passe invalide ! Les mots de passe doivent comporter entre 8 et 10 caractères.";
// Suite à l'exécution de ce fragment, un message d'erreur s'affiche.
// car la longueur de la chaîne "abc" n'est pas comprise dans l'intervalle autorisé
// de 8 à 10 caractères.
La fonction eregi_replace() fonctionne exactement de la même manière que ereg_replace(), à une exception près : la recherche n'est pas sensible à la casse. Syntaxe de la fonction ereg_replace() :
string eregi_replace (modèle de chaîne, remplacement de chaîne, chaîne de chaîne)
La fonction split() divise une chaîne en éléments dont les limites sont déterminées par un modèle donné. La syntaxe de la fonction split() est :
fractionnement du tableau (modèle de chaîne, chaîne chaîne [, seuil int])
Le paramètre facultatif de seuil spécifie le nombre maximum d'éléments dans lesquels la chaîne est divisée de gauche à droite. Si le modèle contient des caractères alphabétiques, la fonction spl it() est sensible à la casse. L'exemple suivant montre l'utilisation de la fonction split() pour diviser une adresse IP canonique en triplets :
$ip = "123.345.789.000" ; // Adresse IP canonique
$iparr = split ("\.", $ip) // Parce que le point est un caractère de service.
// il doit être échappé.
imprimer "$iparr
"; // Sorties "123"
imprimer "$iparr
"; // Sorties "456"
imprimer "$iparr
"; // Sortie "789"
imprimer "$iparr
"; // Sortie "000"
La fonction spliti() fonctionne exactement comme son prototype split(), à une exception près : elle ne prend pas en compte registre de caractères. La syntaxe de la fonction spliti() est :
tableau spliti (modèle de chaîne, chaîne chaîne [, seuil int])
Bien entendu, la casse n’est importante que si le modèle contient des caractères alphabétiques. Pour les autres personnages, exécuter spliti() est exactement la même chose que split().
La fonction d'assistance sql_regcase() entoure chaque caractère de la chaîne d'entrée entre crochets et y ajoute le caractère correspondant. Syntaxe de la fonction sql_regcase() :
chaîne sql_regcase (chaîne chaîne)
Si un caractère alphabétique existe en deux variantes (majuscule et minuscule), l'expression entre crochets contiendra les deux variantes ; sinon, le caractère original est répété deux fois. La fonction sql_regcase() est particulièrement utile lors de l'utilisation de PHP avec des progiciels prenant en charge les expressions régulières à cas unique. Un exemple de conversion d'une chaîne à l'aide de la fonction sql_regcase() :
$version = "php 4.0" ;
print sql_regcase($version);
// Affiche la chaîne [..]
Syntaxe des expressions régulières de style Perl
Conversion d'une chaîne en majuscules et minuscules
Il existe quatre fonctions en PHP conçues pour changer la casse d'une chaîne :
- strtolower();
- strtoupper();
- ucfirst();
- ucwords().
Toutes ces fonctionnalités sont décrites en détail ci-dessous.
strtoinférieur()
La fonction strtolower() convertit tous les caractères alphabétiques d'une chaîne en minuscules. La syntaxe de la fonction strtolower() est :
chaîne strtolower(chaîne chaîne)
Les caractères non alphabétiques ne sont pas modifiés par la fonction. La conversion d'une chaîne en minuscules à l'aide de la fonction strtolower() est illustrée dans l'exemple suivant :
$phrase = strtolower($phrase);
// "Cuisiner et programmer php sont mes deux passe-temps favoris !"
Les chaînes peuvent être converties non seulement en minuscules, mais également en majuscules. La conversion est effectuée par la fonction strtoupper(), qui a la syntaxe suivante :
chaîne strtoupper (chaîne chaîne)
Les caractères non alphabétiques ne sont pas modifiés par la fonction. La conversion d'une chaîne en majuscules à l'aide de la fonction strtoupper() est illustrée dans l'exemple suivant :
$sentence = "Cuisiner et programmer PHP sont mes deux passe-temps préférés !";
$phrase = strtoupper($phrase);
// Après avoir appelé la fonction $phrase contient la chaîne
// " LA CUISINE ET LA PROGRAMMATION PHP SONT MES DEUX PASSE-TEMPS PRÉFÉRÉS ! "
La fonction ucfirst() convertit le premier caractère d'une chaîne en majuscule, à condition qu'il s'agisse d'un caractère alphabétique. Syntaxe de la fonction ucfirst() :
chaîne ucfirst (chaîne chaîne)
Les caractères non alphabétiques ne sont pas modifiés par la fonction. La conversion du premier caractère d'une chaîne par la fonction ucfirst() est démontrée dans l'exemple suivant :
&sentence = "la cuisine et la programmation PHP sont mes deux passe-temps favoris !";
$phrase = ucfirst($phrase);
// Après avoir appelé la fonction $phrase contient la chaîne
// "Cuisiner et programmer PHP sont mes deux passe-temps préférés !"
La fonction ucwords() convertit la première lettre de chaque mot d'une chaîne en majuscule. Syntaxe de la fonction ucwords() :
chaîne ucwords (chaîne chaîne")
Les caractères non alphabétiques ne sont pas modifiés par la fonction. Un « mot » est défini comme une séquence de caractères séparés des autres éléments de la chaîne par des espaces. L'exemple suivant montre comment la fonction ucwords() convertit les premiers caractères des mots :
$sentence = "Cuisiner et programmer PHP sont mes deux passe-temps préférés !";
$phrase = ucwords($phrase);
// Après avoir appelé la fonction $phrase contient la chaîne
// "La cuisine et la programmation PHP sont mes deux passe-temps préférés !"
Projet : Identification du navigateur
Tout programmeur essayant de créer un site Web convivial doit prendre en compte les différences de formatage des pages lors de la visualisation du site dans différents navigateurs et systèmes d'exploitation. Bien que le consortium W3 (http://www.w3.org) continue de publier des normes que les programmeurs doivent respecter lors de la création d'applications Web, les développeurs de navigateurs aiment ajouter leurs propres petites « améliorations » à ces normes, ce qui finit par provoquer chaos et confusion. . Les développeurs résolvent souvent ce problème en créant des pages différentes pour chaque type de navigateur et de système d'exploitation. Cela augmente considérablement la charge de travail, mais le site résultant est idéal pour chaque utilisateur. Le résultat est une bonne réputation pour le site et la confiance que l'utilisateur le visitera à nouveau.
Pour permettre à l'utilisateur de visualiser la page dans un format approprié à son navigateur et à son système d'exploitation, les informations sur le navigateur et la plateforme sont extraites de la demande de page entrante. Après avoir reçu les données nécessaires, l'utilisateur est redirigé vers la page souhaitée.
Le projet ci-dessous (sniffer.php) montre comment utiliser les fonctions PHP pour travailler avec des expressions régulières afin de récupérer des informations à partir de requêtes. Le programme détermine le type et la version du navigateur et du système d'exploitation, puis affiche les informations reçues dans la fenêtre du navigateur. Mais avant de passer à l'analyse proprement dite du programme, je souhaite présenter l'un de ses principaux composants - la variable PHP standard $HTTP_USER_AGENT. Cette variable stocke diverses informations sur le navigateur et le système d'exploitation de l'utilisateur sous forme de chaîne - exactement ce qui nous intéresse. Ces informations peuvent être facilement affichées à l'écran avec une seule commande :
écho $HTTP USER_AGENT ;
Lorsque vous exécutez Internet Explorer 5.0 sur un ordinateur Windows 98, le résultat ressemblera à ceci :
Mozilla/4.0 (compatible ; MSIE 5.0 ; Windows 98 ; DigExt)
Pour Netscape Navigator 4.75, les données suivantes sont affichées :
Mozilla/4.75 (Win98 ; U)
Sniffer.php extrait les données nécessaires de $HTTP_USER_AGENT à l'aide de fonctions de traitement de chaînes et d'expressions régulières. Algorithme du programme en pseudocode :
- Définissez deux fonctions pour identifier le navigateur et le système d'exploitation : browser_info() et opsys_info(). Commençons par le pseudocode de la fonction browser_info().
- Déterminez le type de navigateur à l'aide de la fonction eged(). Bien que cette fonction soit plus lente que les fonctions de chaîne simplifiées comme strstr(), elle est plus pratique dans ce cas car l'expression régulière vous permet de déterminer la version du navigateur.
- Utilisez la construction if/elseif pour identifier les navigateurs suivants et leurs versions : Internet Explorer, Opera, Netscape et un navigateur de type inconnu.
- Renvoie les informations sur le type et la version du navigateur sous forme de tableau.
- La fonction opsys_info() détermine le type de système d'exploitation. Cette fois, la fonction strstr() est utilisée, puisque le type de système d'exploitation est déterminé sans utiliser d'expressions régulières.
- Utilisez la construction if/elseif pour identifier les systèmes suivants : Windows, Linux, UNIX, Macintosh et système d'exploitation inconnu.
- Renvoie des informations sur le système d'exploitation.
Inscription 8.3. Identification du type de navigateur et du système d'exploitation client
Fichier : sniffer.php
Objectif : Identification du type/version du navigateur et de la plateforme
// Fonction : info_navigateur
// Objectif : renvoie le type et la version du navigateur
fonction browser_info ($agent) (
// Détermine le type de navigateur
// Recherche de signature Internet Explorer
if (ereg("MSIE (.(1,2))", $agent, $version))
$browse_type = "IE" ;
$version de navigation = $version ;
// Recherche de la signature Opera
elseif (ereg("Opera (.(1,2))". $agent, $version)) :
$browse_type = "Opéra" :
$browse_version = $version :
// Recherche de la signature Netscape. Vérification du navigateur Netscape
// *doit* être fait après avoir vérifié Internet Explorer et Opera,
// parce que tous ces navigateurs aiment signaler le nom
// Mozilla avec son vrai nom.
elseif (ereg("Mozilla/(.(1,2))". $agent, $version)) :
$browse_type = "Netscape" ;
$browse_version = $version ;
// Sauf s'il s'agit d'Internet Explorer, Opera ou Netscape.
// signifie que nous avons détecté un navigateur inconnu,
$browse_type = "Inconnu" ;
$browse_version = "Inconnu" ;
// Renvoie le type et la version du navigateur sous forme de tableau
tableau de retour ($browse_type, $browse_version);
) // Fin de la fonction browser_info
// Fonction : opsys_info
// Objectif : renvoie des informations sur le système d'exploitation de l'utilisateur
fonction opsys_info($agent) (
// Identifier le système d'exploitation
// Recherche de signature Windows
if (strstr($agent. "win")) :
$opsys = "fenêtres" ;
// Recherche de signature Linux
elseif (strstr($agent, "Linux")) :
$ opsys = "Linux" ;
// Recherche de signature UNIX
elseif (strstr (Sagent, "Unix")) :
$ opsys = "Unix" ;
// Rechercher la signature Macintosh
elseif (strstr($agent, "Mac")) :
$ opsys = "Macintosh" ;
// Autre plateforme inconnue :
$opsys = "Inconnu" ;
// Renvoie des informations sur le système d'exploitation
liste ($browse_type. $browse_version) = navigateur_info ($HTTP_USER_AGENT); Soperating_sys = opsysjnfo($HTTP_USER_AGENT);
print "Type de navigateur : $browse_type
";
print "Version du navigateur : $browse_version
";
print "Système d'exploitation : $operating_sys
":
C'est tout! Par exemple, si l'utilisateur utilise le navigateur Netscape 4.75 sur un ordinateur Windows, le résultat suivant s'affichera :
Type de navigateur : Netscape
Version du navigateur : 4.75
Système d'exploitation : Windows
Dans le chapitre suivant, vous apprendrez à naviguer entre les pages et même à créer des feuilles de style pour des systèmes d'exploitation et des navigateurs spécifiques.
Résultats
Ce chapitre a couvert beaucoup de matière. À quoi sert un langage de programmation si vous ne pouvez pas y travailler avec du texte ? Nous avons abordé les sujets suivants :
- informations générales sur les expressions régulières dans les styles POSIX et Perl ;
- fonctions PHP standard pour travailler avec des expressions régulières ;
- changer la longueur de la ligne ;
- déterminer la longueur d'une chaîne ;
- fonctions PHP alternatives pour traiter les informations de chaîne ;
- convertir du texte brut en HTML et vice versa ;
- changer la casse des caractères dans les chaînes.
Le chapitre suivant ouvre la deuxième partie du livre - d'ailleurs, mon préféré. Dans ce document, nous commencerons à explorer les outils Web de PHP, à examiner le processus de création dynamique de contenu, y compris de fichiers, et à créer des modèles communs. Les chapitres ultérieurs de la partie 2 couvrent l'utilisation des formulaires HTML, des bases de données, du suivi des données de session et des outils de modèles avancés. Tenez bon, la fête est sur le point de commencer !
Contenu
$utilisateur_info
Ce sont toutes les clés définies pour $user_info dans loadUserSettings(). Certains sont explicites, bien sûr.
groupes
tableau. Tous les groupes de membres possibles sont également associés à un utilisateur. Les clés n'ont pas d'importance. Les valeurs sont les groupes, nettoyés comme int, juste au cas où. Ceci comprend:
- Groupe principal
- Groupe de comptage de publications
- Groupes supplémentaires. Ceux-ci sont stockés dans la base de données sous forme de chaîne délimitée par des virgules.
éventuellement_robot
bouffon. C'est vrai si l'agent correspond à un spider connu si la fonctionnalité est activée, et si elle est désactivée, fait une supposition éclairée.
identifiant
int Correspond à la valeur de la base de données du membre "id_member".!}
nom d'utilisateur
nom
chaîne. Leur nom affiché.
mot de passe
langue
est_invité
est_admin
thème
Dernière connexion
int. Horodatage Unix.
adresse IP
$_SERVEUR["REMOTE_ADDR"]
ip2
$_SERVEUR["BAN_CHECK_IP"]
des postes
int. Nombre de messages.
format de l'heure
chaîne. Format personnalisé pour strtftime().
décalage_heure
int. Décalage horaire de l'utilisateur par rapport à l'heure du forum.
avatar
- URL: chaîne
- nom de fichier: chaîne
- rép_personnalisé : booléen
- id_attach : entier
smiley_set
messages
int. Nombre de PM dont ils disposent.
messages_non lus
int. Nombre de MP non lus dont ils disposent.
total_time_logged_in
copains
Chaîne. La liste de leurs copains délimités par des virgules.
ignorer les tableaux
Chaîne. La liste des forums qu'ils ont ignorés, délimitée par des virgules.
ignorer les utilisateurs
Chaîne. La liste des utilisateurs qu'ils ont choisi d'ignorer, délimitée par des virgules.
- Dans SMF 1.1.x, seuls les PM sont ignorés.
- Dans SMF 2.0.x et versions ultérieures, cette fonctionnalité a été améliorée pour masquer également les publications de l'utilisateur ignoré.
avertissement
int. Leurs points d’avertissement.
autorisations
query_see_board
La liste de toutes les cartes qu'ils peuvent voir dans le cadre d'une instruction SQL préparée.
query_wanna_see_board
La liste des cartes qu'ils VEULENT voir dans le cadre d'une instruction SQL préparée.
mod_cache
est_mod
Booléen. Est faux sauf dans les forums où le membre est modérateur. C’est toujours réglé.
Ceux qui ont étudié plus ou moins sérieusement PHP sachez qu'il existe un tableau global très utile dans PHP qui est appelée $_SERVEUR. Et dans cet article, je voudrais analyser les clés les plus populaires et leurs valeurs dans ce tableau, car leur connaissance est tout simplement obligatoire même pour un débutant Programmeur PHP.
Avant de commencer tableau global $_SERVER en PHP, je vais vous donner un petit indice tout de suite. Il y a une fonctionnalité intéressante intégrée PHP, qui est appelée phpinfo(). Donnons immédiatement un exemple de son utilisation :
phpinfo();
?>
À la suite de l'exécution de ce script simple, vous verrez un immense tableau avec divers Paramètres de l'interpréteur PHP, y compris, vers la fin, il y aura un tableau de valeurs tableau global $_SERVER. Il listera toutes les clés et toutes leurs valeurs correspondantes. Comment cela peut-il vous aider ? Et le fait est que si vous avez besoin de telle ou telle valeur et que vous oubliez comment s'appelle la clé, alors en utilisant la fonction phpinfo() Vous vous souviendrez toujours de son nom. En général, vous exécuterez ce script et vous me comprendrez immédiatement.
Passons maintenant aux plus populaires aux clés du tableau $_SERVER:
- HTTP_USER_AGENT- cette clé permet de connaître les caractéristiques du client. Dans la plupart des cas, il s'agit certainement du navigateur, mais pas toujours. Et encore une fois, s'il s'agit d'un navigateur, alors lequel, vous pouvez le découvrir dans cette variable.
- HTTP_REFERER- contient le chemin absolu de ce fichier ( Script PHP, Page HTML), à partir duquel nous sommes passés à ce script. En gros, d'où vient le client.
- SERVER_ADDR - adresse IP serveur.
- REMOTE_ADDR - adresse IP client.
- DOCUMENT_ROOT- chemin physique vers le répertoire racine du site. Cette option est définie via Fichier de configuration du serveur Apache.
- SCRIPT_FILENAME- chemin physique vers le script appelé.
- CHAÎNE DE REQUÊTE- une valeur très utile qui vous permet d'obtenir une chaîne avec une requête, puis d'analyser cette chaîne.
- REQUEST_URI- une valeur encore plus utile qui contient non seulement la requête elle-même, mais aussi le chemin relatif vers le script appelé depuis la racine. Ceci est très souvent utilisé pour supprimer la duplication de index.php, c'est-à-dire quand nous avons un tel URL: "http://mysite.ru/index.php" Et " http://monsite.ru/" mène à une page, et URL différent, donc duplication, ce qui aura un effet néfaste sur l'optimisation des moteurs de recherche. Et avec l'aide REQUEST_URI on peut déterminer : avec index.php ou non, le script a été appelé. Et on peut faire une redirection avec index.php(s'il était présent dans REQUEST_URI) allumé sans index.php. En conséquence, lors de l'envoi d'une telle demande : " http://mysite.ru/index.php?id=5", nous aurons une redirection vers URL: "http://monsite.ru/?id=5". Autrement dit, nous nous sommes débarrassés de la duplication en supprimant de URL ce index.php.
- SCRIPT_NAME- chemin relatif vers le script appelé.
Ce sont peut-être tous les éléments tableau global $_SERVER en PHP qui sont utilisés régulièrement. Vous devez les connaître et pouvoir les utiliser lorsque cela est nécessaire.
5 février , 2017
Je ne connais aucun framework PHP. C’est triste et honteux, mais ce n’est pas encore interdit par la loi. Mais en même temps, je veux jouer avec l'API REST. Le problème est que php par défaut ne prend en charge que $_GET et $_POST. Et pour un service RESTful, vous devez également être capable de travailler avec PUT, DELETE et PATCH. Et il n'est pas très évident de savoir comment traiter culturellement de nombreuses demandes telles que OBTENIR http://site.ru/users, SUPPRIMER http://site.ru/goods/5 et autres obscénités. Comment regrouper toutes ces requêtes en un seul point, les analyser universellement en parties et exécuter le code nécessaire pour traiter les données ?
Presque n'importe quel framework PHP peut le faire immédiatement. Par exemple, Laravel, où le routage est implémenté de manière claire et simple. Mais que se passe-t-il si nous n'avons pas besoin d'étudier un nouveau sujet important pour le moment, mais que nous souhaitons simplement démarrer rapidement un projet avec le support de l'API REST ? Ceci sera discuté dans l’article.
Que devrait être capable de faire notre service RESTful ?
1. Prend en charge les 5 principaux types de requêtes : GET, POST, PUT, PATCH, DELETE.
2. Résolvez différents itinéraires de la vue
POSTE /marchandises
METTRE /goods/(goodId)
OBTENIR /users/(userId)/info
et autres chaînes arbitrairement longues.
Attention : cet article ne concerne pas les bases de l'API REST
Je suppose que vous connaissez déjà l'approche REST et comprenez son fonctionnement. Sinon, il existe de nombreux articles intéressants sur Internet sur les bases de REST - je ne veux pas les dupliquer, mon idée est de montrer comment travailler avec REST dans la pratique.
Quelle fonctionnalité allons-nous prendre en charge ?
Considérons 2 entités : les produits et les utilisateurs.
Pour les produits, les options sont les suivantes :
- 1. OBTENIR /goods/(goodId)— Obtenir des informations sur le produit
- 2. POSTE /marchandises— Ajout d'un nouveau produit
- 3. METTRE /goods/(goodId)— Modification d'un produit
- 4. PATCH /goods/(goodId)— Modification de certains paramètres du produit
- 5. SUPPRIMER /goods/(goodId)— Supprimer un produit
Pour les utilisateurs, pour plus de variété, envisageons plusieurs options avec GET
- 1. OBTENIR /utilisateurs/(IDutilisateur)— Informations complètes sur l'utilisateur
- 2. OBTENIR /users/(userId)/info— Uniquement des informations générales sur l'utilisateur
- 3. OBTENIR /users/(userId)/orders— Liste des commandes des utilisateurs
Comment cela fonctionnera-t-il avec PHP natif ?
La première chose que nous ferons est de configurer .htaccess afin que toutes les requêtes soient redirigées vers le fichier index.php. C'est lui qui se chargera de l'extraction des données.
Deuxièmement, décidons des données dont nous avons besoin et écrivons le code pour les obtenir - dans index.php.
Nous nous intéressons à 3 types de données :
- 1. Méthode de requête (GET, POST, PUT, PATCH ou DELETE)
- 2. Données de l'URL, par exemple, users/(userId)/info - les 3 paramètres sont nécessaires
- 3. Données du corps de la demande
.htaccess
Créons un fichier .htaccess à la racine du projet
RewriteEngine sur RewriteCond %(REQUEST_FILENAME) !-f RewriteRule ^(.+)$ index.php?q=$1
Avec ces lignes mystérieuses, nous vous ordonnons de faire ceci :
1 - envoyer toutes les requêtes de toute nature au fichier king index.php
2 - rendre la chaîne de l'URL disponible dans index.php dans le paramètre get q. Autrement dit, les données d'une URL telle que /utilisateurs/(IDutilisateur)/info nous obtiendrons de $_GET["q"].
index.php
Regardons index.php ligne par ligne. Tout d’abord, obtenons la méthode de requête.
// Définir la méthode de requête $method = $_SERVER["REQUEST_METHOD"];
Ensuite, les données du corps de la requête
// Récupère les données du corps de la requête $formData = getFormData($method);
Pour GET et POST, il est facile d'extraire des données des tableaux $_GET et $_POST correspondants. Mais pour d'autres méthodes, il faut être un peu pervers. Le code correspondant est extrait du flux php://entrée, le code est facile à utiliser pour Google, je viens d'écrire un wrapper général - la fonction getFormData($method)
// Récupération des données du corps de la requête, fonction getFormData($method) ( // GET ou POST : renvoie les données telles quelles if ($method === "GET") return $_GET ; if ($method === "POST" ) return $_POST; // PUT, PATCH ou DELETE $data = array(); éclater("&", file_get_contents("php://input")); ("=", $pair); if (count($item) == 2) ( $data = urldecode($item); ) ) renvoie $data;
Autrement dit, nous avons obtenu les données nécessaires en masquant tous les détails dans getFormData - eh bien, super. Passons à la partie la plus intéressante : le routage.
// Analyser l'url $url = (isset($_GET["q"])) ? $_GET["q"] : ""; $url = rtrim($url, "/"); $urls = exploser("/", $url);
Nous avons appris ci-dessus que .htaccess placera les paramètres de l'URL dans le paramètre q du tableau $_GET. Autrement dit, $_GET["q"] contiendra quelque chose comme ceci : utilisateurs/10. Quelle que soit la méthode que nous utilisons pour exécuter la requête.
UN exploser("/", $url) convertit cette chaîne en un tableau pour nous, avec lequel nous pouvons déjà travailler. Ainsi, faites des chaînes de requêtes aussi longues que vous le souhaitez, par exemple :
OBTENIR /goods/page/2/limit/10/sort/price_asc
Et rassurez-vous, vous recevrez un tableau
$urls = array("goods", "page", "2", "limite", "10", "sort", "price_asc");
Maintenant que nous avons toutes les données, nous devons en faire quelque chose d’utile. Et seulement 4 lignes de code suffiront
// Définir le routeur et les données url $router = $urls; $urlData = array_slice($urls, 1); // Connectez le fichier du routeur et exécutez la fonction principale include_once "routers/" . $routeur. ".php" ; route ($ méthode, $ urlData, $ formData);
Tu as compris? Nous créons un dossier routers dans lequel nous plaçons les fichiers qui manipulent une entité : produits ou utilisateurs. Dans le même temps, nous convenons que les noms des fichiers coïncident avec le premier paramètre de urlData - ce sera le routeur, $router. Et ce routeur doit être supprimé de urlData, nous n'en avons plus besoin et ne sert qu'à connecter le fichier requis. array_slice($urls, 1) et nous donnera tous les éléments du tableau sauf le premier.
Il ne reste plus qu'à connecter le fichier de routeur souhaité et à exécuter la fonction de route avec trois paramètres. Quelle est cette route fonctionnelle ? Convenons que dans chaque fichier du routeur, une fonction sera définie qui, sur la base des paramètres d'entrée, déterminera quelle action l'utilisateur a initiée et exécutera le code requis. Maintenant, cela deviendra plus clair. Considérons la première demande : obtenir des données sur un produit.
OBTENIR /goods/(goodId)
Fichiers routeurs/goods.php
// Fonction de routeur route($method, $urlData, $formData) ( // Obtention d'informations sur un produit // GET /goods/(goodId) if ($method === "GET" && count($urlData) == = 1) ( // Récupère l'identifiant du produit $goodId = $urlData; // Extrait le produit de la base de données... // Affiche la réponse au client echo json_encode(array("method" => "GET", "id" => $goodId, "good" => "phone", "price" => 10000)); // Retourne l'en-tête d'erreur ("HTTP/1.0 400 Bad Request"); erreur" => "Requête incorrecte") "));
Le contenu du fichier est une grande fonction de route qui, en fonction des paramètres transmis, effectue les actions nécessaires. Si la méthode GET et 1 paramètre (goodId) sont transmis à urlData, il s'agit alors d'une requête pour obtenir des données sur un produit.
Attention : l'exemple est très simplifié
Dans la vraie vie, bien sûr, vous devez également vérifier les paramètres d'entrée, par exemple, que goodId est un nombre. Au lieu d'écrire le code ici, vous inclurez probablement la classe requise. Et pour recevoir le produit, créez un objet de cette classe et appelez une méthode dessus.
Ou peut-être transférer le contrôle à un contrôleur, qui se chargera déjà d'initialiser les modèles nécessaires. Il existe de nombreuses options, nous ne considérons que la structure générale du code.
Dans la réponse au client, nous affichons les données nécessaires : le nom du produit et son prix. L'identifiant du produit et la méthode sont totalement facultatifs dans une application réelle. Nous les montrons uniquement pour nous assurer que la bonne méthode est appelée avec les bons paramètres.
Essayons avec un exemple : ouvrez la console de votre navigateur et exécutez le code
$.ajax((url : "/examples/rest/goods/10", méthode : "GET", dataType : "json", succès : function(response)(console.log("response:", réponse))) )
Le code enverra une requête au serveur sur lequel j'ai déployé une application similaire et affichera une réponse. Assurez-vous que l'itinéraire qui vous intéresse est /marchandises/10 vraiment travaillé. Sur l'onglet Réseau, vous remarquerez la même demande.
Et oui, /examples/rest est le chemin racine de notre application de test vers le site
Si vous êtes plus habitué à utiliser curl dans la console, exécutez-le dans le terminal - la réponse sera la même, et même avec les en-têtes du serveur.
Curl -X OBTENIR https://site/examples/rest/goods/10 -i 
A la fin de la fonction nous avons écrit le code suivant.
// Renvoie un en-tête d'erreur ("HTTP/1.0 400 Bad Request"); echo json_encode(array("error" => "Bad Request"));
Cela signifie que si nous avons fait une erreur avec les paramètres ou si l'itinéraire demandé n'est pas défini, nous renverrons l'erreur 400 Bad Request au client. Par exemple, ajoutez quelque chose comme ceci à l'URL : marchandises/10/autre_param et vous verrez une erreur dans la console et une réponse 400 - la demande tordue n'a pas abouti.
Par codes http de réponse du serveur
Nous ne nous embêterons pas à générer des codes différents, même si cela vaut la peine de le faire selon REST. Il existe de nombreuses erreurs client. Même dans notre cas simple, un 405 est approprié en cas de méthode mal transmise. Je ne veux pas compliquer les choses volontairement.
En cas de succès, notre serveur renverra toujours 200 OK. Heureusement, lors de la création d'une ressource, vous devez donner 201 Created. Mais encore une fois, en termes de simplification, nous écarterons ces subtilités, mais dans un projet réel, vous pouvez facilement les mettre en œuvre vous-même.
En toute honnêteté, l’article est terminé. Je pense que vous comprenez déjà l'approche, comment tous les itinéraires sont résolus, les données sont récupérées, comment les tester, comment ajouter de nouvelles requêtes, etc. Mais pour compléter l'image, je vais donner l'implémentation des 7 requêtes restantes que nous avons décrites au début de l'article. En cours de route, je ferai quelques commentaires intéressants et, à la fin, je publierai une archive avec le code source.
POSTE /marchandises
Ajouter un nouveau produit
// Ajout d'un nouveau produit // POST /goods if ($method === "POST" && empty($urlData)) ( // Ajout d'un produit à la base de données... // Sortie de la réponse au client echo json_encode (array("method" => "POST", "id" => rand(1, 100), "formData" => $formData));
urlData est maintenant vide, mais formData est utilisé - nous l'afficherons simplement au client.
Comment faire « correctement » ?
Selon les canons de REST, dans une demande de publication, vous devez renvoyer uniquement l'identifiant de l'entité créée ou l'url par laquelle cette entité peut être obtenue. Autrement dit, la réponse sera soit juste un chiffre - (bon identifiant), ou /marchandises/(bonId).
Pourquoi ai-je écrit « correctement » entre guillemets ? Oui, car REST n’est pas un ensemble de règles strictes, mais des recommandations. Et la manière dont vous le mettrez en œuvre dépend de vos préférences ou des accords déjà acceptés sur un projet spécifique.
Gardez simplement à l'esprit qu'un autre programmeur lisant le code et conscient de l'approche REST attendra dans la réponse à une requête de publication l'identifiant de l'objet créé ou une URL à partir de laquelle les données sur cet objet peuvent être récupérées avec une requête get.
Test depuis la console
$.ajax((url : "/examples/rest/goods/", méthode : "POST", données : (bon : "notebook", prix : 20000), dataType : "json", succès : fonction (réponse)( console.log("réponse:", réponse))))
Curl -X POST https://site/examples/rest/goods/ --data "good=notebook&price=20000" -i
METTRE /goods/(goodId)
Modifier un produit
// Mettre à jour toutes les données du produit // PUT /goods/(goodId) if ($method === "PUT" && count($urlData) === 1) ( // Obtenir l'identifiant du produit $goodId = $urlData; / / Mettre à jour tous les champs de produits dans la base de données... // Afficher la réponse au client echo json_encode(array("method" => "PUT", "id" => $goodId, "formData" => $formData)) ;
Ici, toutes les données sont déjà utilisées au maximum. L'identifiant du produit est extrait de urlData et les propriétés sont extraites de formData.
Test depuis la console
$.ajax((url : "/examples/rest/goods/15", méthode : "PUT", données : (bon : "notebook", prix : 20000), dataType : "json", succès : fonction (réponse) (console.log("réponse:", réponse))))
Curl -X PUT https://site/examples/rest/goods/15 --data "good=notebook&price=20000" -i
PATCH /goods/(goodId)
Mise à jour partielle du produit
// Mise à jour partielle des données du produit // PATCH /goods/(goodId) if ($method === "PATCH" && count($urlData) === 1) ( // Récupère l'identifiant du produit $goodId = $urlData; // Nous mettons à jour uniquement les champs de produit spécifiés dans la base de données... // Afficher la réponse au client echo json_encode(array("method" => "PATCH", "id" => $goodId, "formData" => $formData));
Test depuis la console
$.ajax((url : "/examples/rest/goods/15", méthode : "PATCH", données : (prix : 25 000), dataType : "json", succès : fonction (réponse) (console.log (" réponse :", réponse))))
Curl -X PATCH https://site/examples/rest/goods/15 --data "price=25000" -i
Pourquoi tout ce show-off avec PUT et PATCH ?
Un PUT n'est-il pas suffisant ? N'effectuent-ils pas la même action : mettre à jour les données de l'objet ?
C'est vrai - extérieurement, l'action est une. La différence réside dans les données transmises.
PUT suppose que Tous champs d'objet et PATCH - uniquement modifié. Ceux envoyés dans le corps de la demande. Veuillez noter que dans le PUT précédent, nous avons transmis à la fois le nom du produit et le prix. Et dans PATCH - seulement le prix. Autrement dit, nous avons envoyé uniquement les données modifiées au serveur.
Si vous avez besoin de PATCH, décidez vous-même. Mais rappelez-vous ce programmeur de lecture de code que j'ai mentionné ci-dessus.
SUPPRIMER /goods/(goodId)
Supprimer un produit
// Suppression d'un produit // DELETE /goods/(goodId) if ($method === "DELETE" && count($urlData) === 1) ( // Récupère l'identifiant du produit $goodId = $urlData; // Supprimer le produit de la base de données... // Afficher la réponse au client echo json_encode(array("method" => "DELETE", "id" => $goodId));
Test depuis la console
$.ajax((url : "/examples/rest/goods/20", méthode : "DELETE", dataType : "json", succès : function(response)(console.log("response:", réponse))) )
Curl -X SUPPRIMER https://site/examples/rest/goods/20 -i
Tout est clair avec la requête DELETE. Voyons maintenant comment travailler avec les utilisateurs - le routeur des utilisateurs et, par conséquent, le fichier users.php
OBTENIR /utilisateurs/(IDutilisateur)
Récupération de toutes les données utilisateur. Si la requête GET ressemble à /utilisateurs/(IDutilisateur), nous renverrons toutes les informations sur l'utilisateur si cela est également spécifié /Info ou /ordres, puis, en conséquence, uniquement des informations générales ou une liste de commandes.
// Fonction de routeur route($method, $urlData, $formData) ( // Obtention de toutes les informations sur l'utilisateur // GET /users/(userId) if ($method === "GET" && count($urlData) = = = 1) ( // Récupère l'identifiant du produit $userId = $urlData; // Extrait toutes les données sur l'utilisateur de la base de données... // Affiche la réponse au client echo json_encode(array("method" => " GET", "id" => $userId, "info" => array("email" => " [email protégé]", "name" => "Webdevkin"), "orders" => array(array("orderId" => 5, "summa" => 2000, "orderDate" => "01/12/2017"), array (" orderId" => 8, "summa" => 5000, "orderDate" => "02/03/2017")))); return ) // Renvoie l'en-tête d'erreur ("HTTP/1.0 400 Bad Request" ); echo json_encode( array("erreur" => "Requête incorrecte"));
Test depuis la console
$.ajax((url : "/examples/rest/users/5", méthode : "GET", dataType : "json", succès : function(response)(console.log("response:", réponse))) )
Curl -X GET https://site/examples/rest/users/5 -i
OBTENIR /users/(userId)/info
Informations générales sur l'utilisateur
// Obtention d'informations générales sur l'utilisateur // GET /users/(userId)/info if ($method === "GET" && count($urlData) === 2 && $urlData === "info") ( // Récupère l'identifiant du produit $userId = $urlData; // Extrait les données générales sur l'utilisateur de la base de données... // Affiche la réponse au client echo json_encode(array("method" => "GET", "id " => $userId, " info" => array("email" => " [email protégé]", "nom" => "Webdevkin"))); return; )
Test depuis la console
$.ajax((url : "/examples/rest/users/5/info", méthode : "GET", dataType : "json", succès : fonction (réponse)(console.log ("response :", réponse) )))
Curl -X OBTENIR https://site/examples/rest/users/5/info -i
OBTENIR /users/(userId)/orders
Obtenir une liste des commandes des utilisateurs
// Recevoir les commandes des utilisateurs // GET /users/(userId)/orders if ($method === "GET" && count($urlData) === 2 && $urlData === "orders") ( // Récupérer product id $userId = $urlData; // Récupère les données sur les commandes de l'utilisateur de la base de données... // Affiche la réponse au client echo json_encode(array("method" => "GET", "id" => $ userId, "orders" => array(array("orderId" => 5, "summa" => 2000, "orderDate" => "01/12/2017"), array("orderId" => 8, "summa " => 5000, "orderDate " => "02/03/2017")))); retour; )
Test depuis la console
$.ajax((url : "/examples/rest/users/5/orders", méthode : "GET", dataType : "json", succès : fonction (réponse)(console.log ("response :", réponse) )))
Curl -X OBTENIR https://site/examples/rest/users/5/orders -i
Résultats et sources
Sources à partir d'exemples d'articles -
Comme vous pouvez le constater, organiser le support de l'API REST en PHP natif s'est avéré pas si difficile et de manière tout à fait légale. L'essentiel est la prise en charge des routes et des méthodes PHP non standard PUT, PATCH et DELETE.
Le code principal qui implémente ce support tient dans 3 douzaines de lignes d'index.php. Le reste n’est qu’un harnais qui peut être mis en œuvre comme bon vous semble. J'ai proposé de le faire sous forme de fichiers de routeur plug-in dont les noms correspondent aux entités de votre projet. Mais vous pouvez utiliser votre imagination et trouver une solution plus intéressante.
Obtient un objet WP_User qui contient toutes les données de l'utilisateur spécifié.
Les données renvoyées par les fonctions correspondent entièrement aux champs des tables de la base de données : wp_users et wp_usermeta (description de la table).
Il s'agit d'une fonctionnalité enfichable - c'est-à-dire il peut être remplacé depuis le plugin. Cela signifie qu'il ne fonctionnera (se connectera) qu'une fois que tous les plugins auront été connectés, et jusqu'à ce point, la fonction n'a pas encore été définie... Par conséquent, vous ne pouvez pas appeler cela et les fonctions qui en dépendent directement à partir du code du plugin. Ils doivent être appelés via le hook plugins_loaded ou une version ultérieure, comme le hook init.
Remplacement de fonction (remplacement) - dans le plugin, vous pouvez créer une fonction avec le même nom, elle remplacera ensuite la fonction actuelle.
✈ 1 fois = 0,000296s = rapide| 50 000 fois = 0,78 s = très vite| PHP 7.1.2RC1, WP 4.7.2
Il n'y a pas de crochets.
Retour
WP_Utilisateur/false. Objet de données, ou false si l'utilisateur spécifié est introuvable.
Usage
get_userdata($userid); $IDutilisateur (numéro) (obligatoire) ID de l'utilisateur dont vous souhaitez récupérer les données.Par défaut : non
Exemples
#1 Comment extraire des données d'un objet de données reçu
$user_info = get_userdata(1); echo "Nom d'utilisateur : " . $user_info->user_login . "\n" ; echo "Niveau d'accès : " . $user_info->user_level . "\n" ; echo "ID : " . $user_info->ID . "\n" ; /* Sorties : Nom d'utilisateur : admin Niveau d'accès : 10 ID : 1 */#1.2 Données dans une variable
Autre exemple, seulement ici nous allons d'abord écrire les données dans des variables, puis les afficher à l'écran :
$utilisateur = get_userdata(1); $username = $user->user_login ; $first_name = $user->first_name ; $nom_dernier = $utilisateur->nom_dernier ; echo "$first_name $last_name connecté au site sous le login : $username."; /* Objet $user : WP_User Object( => stdClass Object( => 80 => kogian => $P$BJFHKJfUKyWv1TwLOVAENYU0JGNsq. => kogian => [email protégé]=> http://example.com/ => 01/09/2016 00:34:42 => => => kogian) => 80 => Array( => 1) => wp_capabilities => Array( => abonné) => Array( => 1 => 1 => 1) => => 1) */
#2 Méthodes de classe
L'objet obtenu par get_userdata() est une instance de la classe et possède des méthodes qui peuvent être utilisées. Parfois, cela peut s'avérer utile. Voici un exemple simple d'obtention d'une option utilisateur à l'aide de la méthode $user->get() :
$utilisateur = get_userdata(1); echo $username = $user->get("user_login");
Liste de quelques méthodes :
- set_role($role) - définit le rôle de l'utilisateur ;
get($key) - renvoie la valeur de l'option ;
has_prop($key) - vérifie si l'option spécifiée est installée ;
has_cap($cap) - vérifie si l'utilisateur dispose de la capacité ou du rôle spécifié ;
get_role_caps() - Récupère toutes les capacités du rôle de l'utilisateur et les combine avec les capacités individuelles de l'utilisateur ;
add_role($role) - ajoute un rôle à l'utilisateur ;
remove_role($role) - supprime un rôle d'un utilisateur ;
Remarques
Voici quelques valeurs utiles des champs de table wp_users et wp_usermeta que vous pouvez utiliser pour récupérer des données :
- Afficher un nom
utilisateur_meta
-
description de l'utilisateur
wp_capabilities (tableau)
admin_color (thème du panneau d'administration. Par défaut - frais)
page_boîtes aux lettres fermées
- domaine_source
A noter également que depuis la version 3.2, les données renvoyées ont légèrement changé : l'objet WP_User est renvoyé. Les données de l'objet sont divisées en groupes : données, casquettes, rôles (auparavant les données étaient renvoyées dans une liste générale).
Cependant, grâce aux méthodes « magiques » (utilitaires) de PHP, les données peuvent être obtenues comme avant, par exemple, maintenant les données sont stockées comme ceci : get_userdata(1)->data->rich_editing , mais vous pouvez les obtenir comme ceci : get_userdata(1)->rich_editing , même si var_dump() n'affichera pas cette relation.
Code récupérer les données utilisateur : wp-includes/pluggable.php WP 5.2.2
document.write("");
