Vous devez connaître les fonctions intégrées couramment utilisées en PHP

//================================Heure et date========== == ===================

//y renvoie les deux derniers chiffres de l'année, le nombre à quatre chiffres de l'année Y, le nombre du mois m, et le mois M en anglais. d numéro du mois, D jour de la semaine en anglais

$date=date("Y-m-d");

$date=date("Y-m-d H:i:s"); //avec heures, minutes et secondes

//include,include_once.require,require_once

//require("file.php") Avant l'exécution du programme PHP, le fichier spécifié par require sera lu. Une erreur est fatale.

//include("file.php") peut être placé n'importe où dans le programme PHP. Le fichier spécifié par include ne sera pas lu tant que le programme PHP n'est pas exécuté. Si une erreur se produit,

sera invité //===============================Impression de sortie======== ======== ================

//sprintf("%d","3.2");//Formatage uniquement, renvoie la chaîne formatée, Aucune sortie.

//printf("%d","3.2") ;//Formatage et sortie

//print("3.2") ;//Sortie uniquement

//echo "nihao","aa";//Peut générer plusieurs chaînes

//print_r(array("a","b","c"));// Afficher les valeurs clés ​​et les éléments du tableau en séquence

//================================ Caractères communs Fonction de chaîne ================================

//Obtenir la longueur de la chaîne, comment il y a beaucoup de caractères, les espaces sont également comptés

$str=" sdaf sd ";

$len=strlen($str);

//Utilisez la chaîne dans le premier paramètre, concatène chaque élément du tableau suivant et renvoie une chaîne.

$str=implode("-",array("a","b","c"));

//Méthode de fractionnement de chaîne, renvoie un tableau, en utilisant le Les caractères d'un paramètre divisent la chaîne suivante et interceptent les caractères avant, après et entre les caractères spécifiés. Si le caractère spécifié est au début ou à la fin, l'élément au début ou à la fin du tableau renvoyé sera une chaîne vide.

// S'il n'est pas divisé en chaînes, une valeur nulle sera renvoyée à l'élément correspondant du tableau. La dernière limite renvoie la longueur du tableau. S'il n'y a pas de limite, il continuera à être divisé.

$array=explode("a","asddad addadassd dasdadfsdfasdaaa",4);

//print_r($array);

//Éliminer le côté gauche de la chaîne d'espaces au début, et renvoie

//S'il y a un deuxième paramètre, supprimez les espaces au début à gauche et remplacez-le par la suppression de la chaîne dans le deuxième paramètre

$str=ltrim(" a asd ","a");

//Supprimez les espaces au début du côté droit de la chaîne

$str=rtrim(" asd ");

//Supprimer la première Les chaînes commençant par le deuxième paramètre de part et d'autre d'une chaîne sont éliminées. S'il n'y a pas de deuxième paramètre, les espaces au début des deux côtés de la chaîne seront supprimés par défaut

$str=trim(" sdsdfas ","a");

/ /De la première chaîne La longueur (nombre) de caractères à partir de la position spécifiée dans le paramètre La position du premier caractère dans la chaîne est calculée à partir de 0.

//Si le deuxième paramètre est négatif, quelle est la longueur de la chaîne à partir du dernier nombre à la fin de la chaîne. Le dernier caractère à la fin compte pour -1, et le sens d'interception est toujours de gauche à droite

$str=substr("abcdefgh",0,4);

// Modifier le troisième paramètre La première chaîne de paramètres est remplacée par la deuxième chaîne de paramètres

$str=str_replace("a","","abcabcAbca");

//L'utilisation est la identique à str_replace, sauf insensible à la casse

//$str=str_ireplace("a"," ","abcabcAbca");

//Renvoyer les caractères de la chaîne entre parenthèses Toutes les chaînes en majuscules

$str=strtoupper("sdaf");

//Convertissez la première chaîne entre parenthèses en majuscules et renvoyez

$str =ucfirst("asdf");

//Lorsque vous utilisez echo etc. pour imprimer la chaîne entre parenthèses sur la page Web, la chaîne entre parenthèses sera imprimée telle quelle, y compris les caractères d'étiquette

$ str=htmlentities("
");

//Renvoie le nombre de fois où la deuxième chaîne de paramètre apparaît dans la première chaîne

$int=substr_count ("abcdeabcdeablkabd", "ab");

//Renvoie la position où la deuxième chaîne apparaît pour la première fois dans la première chaîne, la position du premier caractère est comptée comme 0

$ int=strpos ("asagaab","ab");

//Renvoie la position où la deuxième chaîne apparaît en dernier dans la première chaîne, la position du premier caractère est comptée comme 0

$ int=strrpos("asagaabadfab","ab");

//Intercepter et renvoyer la chaîne du premier caractère du paramètre deux au dernier caractère du paramètre un de gauche à droite dans le paramètre un

$str=strstr("sdafsdgaababdsfgs","ab");

//Intercepter et renvoyer le dernier paramètre 2 de gauche à droite dans le paramètre 1 jusqu'au dernier paramètre 1 Chaîne de caractères

$str=strrchr("sdafsdgaababdsfgs","ab");

//Ajouter " pour chaque caractère du paramètre deux avant le même caractère du paramètre un "

$str= addcslashes("abcdefghijklmn","akd");

//Pall la chaîne du paramètre un à la longueur spécifiée par le paramètre deux (nombre de caractères simples), le paramètre trois est la chaîne de remplissage spécifiée, ne pas écrire l'espace par défaut

//Position de remplissage du paramètre quatre, 0 est rempli au début du côté gauche du paramètre un, 1 est rempli sur le côté droit et 2 est rempli au début des deux côtés. S'il n'est pas écrit, le remplissage par défaut sera

$str=str_pad("abcdefgh",10,"at",0);

//Comparez tour à tour les valeurs du code Asker des caractères correspondants dans les deux chaînes. Si la première paire est différente, si le paramètre un est supérieur au paramètre deux, 1 sera renvoyé. renvoyé Si les deux chaînes sont exactement les mêmes, 0 sera renvoyé

$int1=strcmp("b","a");

//Renvoie le format numérique formaté de. le premier paramètre et le deuxième paramètre doivent conserver quelques décimales. Le paramètre trois consiste à remplacer la virgule décimale par le paramètre trois. Le paramètre quatre indique les caractères utilisés pour séparer tous les trois chiffres dans la partie entière

. //Si les trois derniers paramètres ne sont pas écrits, la partie décimale sera supprimée par défaut, et les entiers seront séparés tous les trois. Séparez les trois chiffres par des virgules. Le paramètre trois et le paramètre quatre doivent exister en même temps

$str=number_format(1231233.1415,2,"d","a");

//= = =============================Méthodes de tableau couramment utilisées================ == =============

$arr=array("k0"=>"a","k1"=>"b","k2"= > "c");

//Renvoyer le nombre d'éléments du tableau

$int=count($arr);

//Déterminer si l'élément du tableau le deuxième paramètre Il y a le premier élément de paramètre

$bool=in_array("b",$arr);

//Renvoie un nouveau tableau composé de toutes les valeurs clés​​de le tableau entre parenthèses. Le tableau d'origine ne change pas

$array=array_keys($arr);

//Déterminer si le tableau du deuxième paramètre contient la valeur clé du premier paramètre. et renvoie vrai ou faux

$bool =array_key_exists("k1",$arr);

//Renvoie un nouveau tableau composé de toutes les valeurs d'éléments​ ​dans le tableau d'origine.​​les valeurs clés ​​incrémentent à partir de 0 et le tableau d'origine reste inchangé

$array=array_values($arr);

//Renvoie la valeur clé pointée. vers par le pointeur de tableau actuel

$key=key($arr);

//Renvoie la valeur de l'élément pointée par le pointeur de tableau actuel

$value=current ($arr);

//Renvoie un tableau composé de la valeur clé et de la valeur de l'élément pointé par le pointeur de tableau actuel, puis pousse le pointeur vers le bit suivant, et enfin le pointeur pointe vers un élément vide.Renvoyer vide

//Il y a quatre valeurs clés fixes dans le tableau renvoyé. Les valeurs d'élément correspondantes sont la valeur clé et l'élément de l'élément renvoyé Value, où 0, '. key' key value all correspond à la valeur clé de l'élément renvoyé, 1, 'value' key value all correspond à la valeur de l'élément renvoyé

$array=each($arr);

// Poussez d'abord le pointeur du tableau sur le bit suivant, puis renvoyez la valeur de l'élément pointé après le déplacement du pointeur

$value=next($arr);

//Poussez le pointeur du tableau vers le haut un bit, puis renvoie la valeur de l'élément pointé après le déplacement du pointeur

$value=prev($arr);

//Réinitialise le pointeur du tableau pour qu'il pointe vers le premier élément et renvoie la valeur de l'élément

$value=reset($arr);

//Pointez le pointeur du tableau sur le dernier élément et renvoyez la valeur du dernier élément

$value=end ($ arr);

//Ajouter les paramètres après le premier paramètre en tant qu'éléments à la fin du premier tableau de paramètres. L'index est calculé à partir de la plus petite valeur inutilisée. La longueur du tableau après le retour est <.>

$int=array_push($arr,"d","dfsd");

//Ajouter tous les paramètres après le premier tableau de paramètres en tant qu'éléments au début du premier tableau de paramètres, Le la valeur de clé est réaccumulée à partir du premier élément avec 0, la valeur de clé non numérique d'origine reste inchangée, la position de tri de l'élément d'origine reste inchangée et la longueur du tableau renvoyée est

$int=

array_unshift($arr,"t1","t2");

//Retour pour extraire la valeur du dernier élément de la fin du tableau et supprimer le dernier élément du tableau d'origine

$value =array_pop($arr);

//array_pop Au contraire, extrayez et renvoyez la valeur du premier élément du tableau, et supprimez le premier élément du tableau d'origine

$value=array_shift($arr);

//Laissez le premier tableau de paramètres atteindre la longueur de la valeur du deuxième paramètre, ajoutez le troisième paramètre en tant qu'élément à la fin du premier tableau de paramètres, et l'index commence à partir de la plus petite valeur inutilisée et renvoie , le tableau d'origine ne change pas

$array1=array_pad($arr,10,"t10");

//Renvoie un nouveau tableau avec les éléments en double inutiles supprimés du tableau d'origine. Le tableau d'origine Le tableau ne change pas

$array=array_unique($array1);

//Casser la valeur de la clé du tableau d'origine et re -trier la valeur du code Asker de la valeur de l'élément de petit à grand, et l'index est à partir du nombre 0. Commencez à recompter

$int=sort($array);

// Contrairement au tri, triez à nouveau par ordre décroissant de la valeur de l'élément Asko code value et recalculez l'index à partir de 0

$int=rsort($array);

// Renvoie un tableau dans lequel chaque valeur d'élément du premier tableau de paramètres est à son tour payée en tant que valeur clé au deuxième tableau de paramètres. La longueur des deux tableaux doit être cohérente, le tableau d'origine ne change pas

$. array=

array_combine(array("a","b","c","d","e"),$arr);

//Fusionner les deux tableaux et renvoie le tableau d'origine inchangé

$array=array_merge($arr,array("a","b","c"));

//Dans le premier tableau de paramètres, intercepter la valeur de la clé du tableau + l'élément de la position de la deuxième valeur du paramètre à la longueur de la troisième valeur du paramètre et la renvoie. La position du premier élément du tableau est comptée à partir de 0

$array=array_slice($arr,2,1. );

//La fonction d'interception est la même que array_slice(), sauf que la partie interceptée est supprimée du tableau d'origine

$array=

array_splice

($ arr,2,1);

// Prenez le premier paramètre comme premier élément, incrémentez la valeur du paramètre trois à chaque fois, puis stockez-le comme élément dans le tableau jusqu'à ce que la valeur atteigne la valeur du paramètre deux et enregistrez-le dans le tableau. renvoie ce tableau

//Paramètre un, le paramètre deux peut être un nombre ou un seul caractère. Un seul caractère est calculé en fonction de la valeur du code ASCO. Si le troisième paramètre n'est pas écrit, il sera incrémenté par défaut. .1

$array=range(3,9,2);

//Réorganiser la correspondance entre les éléments du tableau d'origine et les valeurs clés correspondantes de manière aléatoire et renvoyer vrai ou faux

$bool=shuffle($arr);

//Calculer la somme de toutes les valeurs d'éléments numériques dans le tableau

$int=array_sum(array("a ",2,"cssf") );

//Diviser un tableau en nouveaux blocs de tableau. Chaque élément du nouveau tableau est un tableau. Le nombre d'éléments dans chaque élément du nouveau tableau est déterminé par paramètre deux

//Le troisième paramètre détermine si la valeur clé de l'élément conserve la valeur clé d'origine. True signifie la conserver. La valeur par défaut est false et ne la conserve pas. =array_chunk(array("a"=>"a" ,"b","c","d","e","f","g","h"),2,true);

//json_encode() convertit le tableau en chaîne au format JSON return

$arr = array('k1'=>'val1','k2'=>'val2',' k3'=>array('v3','v4 '));

echo $encode_str = json_encode($arr);

//json_decode() convertit une chaîne au format JSON en un objet qui peut être contraint dans un tableau et renvoie des caractères au format JSON. Lorsque les clés et les valeurs de la chaîne doivent être placées entre guillemets, elles doivent être placées entre guillemets doubles

$decode_arr = (array )json_decode($encode_str);

var_dump($decode_arr);

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!