Noteikti jums mājās ir skapis vai kumode. To lietošanas princips ir vienkāršs: tur ievietojam lietas, kas mums šobrīd nav vajadzīgas, bet pēc kāda laika var būt vajadzīgas.

Mainīgie ir sakārtoti tieši tāpat. Varat tajās ievietot kādu vērtību un uzglabāt to tur, līdz tas jums ir nepieciešams.

Mainīgo izveide

Varat ievietot vērtību mainīgajā, piemēram:

Iepriekš minētajā kodā mēs izveidojām mainīgo $name un ievietojām tajā vērtību Ivan, pēc tam izveidojām mainīgo $age un piešķīrām tam vērtību 20.

Nosaukums "mainīgais" nozīmē, ka tā vērtība var mainīties skripta izpildes laikā:

Dažās valodās mainīgais vispirms ir “jādeklarē” un pēc tam jāizmanto. PHP nav deklarācijas - mainīgais tiek izveidots brīdī, kad tajā ievietojat vērtību.
Tomēr PHP programmētāji bieži saka "deklarē mainīgo", nevis "izveidot mainīgo".

Turklāt tā vietā, lai “ievietojiet vērtību mainīgajam”, viņi bieži saka “piešķirt vērtību”.
Iemesls ir vienkāršs - simbolu =, pateicoties kuram mēs saglabājam vērtību mainīgajā, sauc par “piešķiršanas operatoru”. Līdz ar to termins "piemērots".

Mainīgo nosaukšanas noteikumi

1. Mainīgā nosaukums sākas ar simbolu $.

2. Otrā rakstzīme var būt burts vai pasvītra _

Mainīgo nosaukumi ir reģistrjutīgi. $name un $Name ir dažādi mainīgie.

Mainīgā vērtības parādīšana ekrānā

Varat parādīt mainīgo, izmantojot mums jau zināmo echo komandu:

Echo komanda ļauj vienlaikus parādīt vairākas vērtības:

Ņemiet vērā, ka mēs nodevām 2 vērtības, kas tika atdalītas ar komatu. Tādā veidā mēs varam nodot tik daudz vērtību, cik vēlamies. Šie divi piemēri dos tādu pašu rezultātu:

Ir arī saīsināta sintakse mainīgo parādīšanai PHP. Tā vietā

Pirms PHP 5.4 saīsinātā sintakse darbojās tikai tad, ja tā bija iekļauta PHP iestatījumi short_open_tag direktīva, kas arī ļauj izmantot saīsinātu sākuma tagu

Mainīgā lieluma vērtības pārbaude

Echo komanda ne vienmēr ir ērta, lai pārbaudītu mainīgā lieluma pašreizējo vērtību. Piemēram, ja mēģināt parādīt tukšu virkni "", ekrānā netiks parādīts absolūti nekas. Un nav skaidrs, kāds ir iemesls - tukšs mainīgais vai bojāts kods.

Tāpēc, lai pārbaudītu mainīgā lieluma vērtību, tiek izmantota funkcija var_dump():

Skripta izpildes rezultāts:

String(5) "Vasya" virkne(0) ""

Kā redzat, PHP parādīja ne tikai mainīgā saturu, bet arī rakstzīmju skaitu un pat mainīgā (virknes) veidu. Turpmākajās nodarbībās sīkāk aplūkosim datu tipus.

Mainīgo noņemšana

Esošu mainīgo var noņemt, izmantojot funkciju unset():

Tagad ir laiks nedaudz trenēties.

Atcerieties, ka gandrīz jebkurai PHP problēmai var būt vairāki risinājumi. Tāpēc, ja jūsu risinājumi atšķiras no šajā vietnē rakstītajiem, tas nebūt nenozīmē, ka esat izdarījis kaut ko nepareizi.

Uzrakstiet skriptu, kas:
1. Izveido mainīgos ar nosaukumiem virsraksts un saturs un dažas vērtības.
2. Parāda nosaukuma mainīgā vērtību h1 tagā un satura mainīgā vērtību tagā div.

Rādīt risinājumu

", $title, ""; atbalss"

Vēlos vēlreiz vērst jūsu uzmanību uz to, ka šis lēmums nav vienīgais pareizais. Piemēram, šāds kods radīs tādu pašu rezultātu:

Mainīgie php- tas ir sava veida informācijas konteiners, kas var saturēt dažādi veidi dati (teksts, cipari, masīvi utt.). Kopumā mainīgie ļauj izveidot, uzglabāt, mainīt un vēlāk ātri piekļūt tajos norādītajai informācijai.

Kā izveidot mainīgo PHP

Kā jūs varat nosaukt mainīgos:

$var
$mainīgs
$ 1945 gads
$_mainīgs
Kā nenosaukt mainīgos:

$1 - sastāv tikai no cipariem
$1var — mainīgā nosaukumu nevar sākt ar skaitli
$/var - no papildu rakstzīmēm ir atļauta tikai pasvītra _
$mainīgs — PHP dokumentācijā ir atļauta kirilica, taču tā nav ieteicama
$var iable — atstarpes nevar izmantot

Katram mainīgajam tiek piešķirta vērtība. Zīme tiek izmantota, lai piešķirtu vērtību = (vienāds). Skripta apstrādes laikā mainīgā vērtība var mainīties atkārtoti atkarībā no dažādiem apstākļiem.

$pilsēta = "Maskava"; // mainīgajam $city tika piešķirta virknes (pēdiņās) vērtība Maskava
$ gads = 1147; // un mainīgajam $year tika piešķirta skaitliskā vērtība 1147
?>

$vārds = "Aleksandrs";
$Name = "Aleksejs";
atbalss "$nosaukums, $nosaukums"; // drukās "Aleksandrs, Aleksejs"
?>

PHP mainīgo drukāšana

// Šādi mēs iestatām mainīgo vērtības
$name1 = "Aleksejs";
$name2 = "Aleksandrs";

// Izvades mainīgie
atbalss $nosaukums2; // Izvade: Aleksandrs
echo "nosaukums1 ir $nosaukums1"; // vārds1 ir Aleksejs

// Lietojot vienas pēdiņas, izvadiet
// mainīgā nosaukums, nevis vērtība
echo "nosaukums1 ir $nosaukums1"; // izvadīs: name1 ir $name1

// jūs varat vienkārši parādīt mainīgo vērtības
atbalss $nosaukums1; // Aleksejs
atbalss $nosaukums1,$nosaukums2; // Aleksejs Aleksandrs
echo $name1." ".$name2; // Aleksejs Aleksandrs
atbalss "$nosaukums1, $nosaukums2"; // Aleksejs, Aleksandrs

Atbalss<<Izvadīšanai tiek izmantota "šeit dokumenta" sintakse
vairākas rindas ar $mainīgā mainīgā aizstāšanu.
BEIGAS;

Darbības ar PHP mainīgajiem

-$a(negācija) Mainiet $a zīmi.
$a + $b(papildinājums) $a un $b summa.
$a - $b(atņemšana) $a un $b starpība.
$a * $b(reizināšana) $a un $b reizinājums.
$a / $b(dalījums) $a koeficients dalīts ar $b.
$a % $b(modulo dalījums) Vesela skaitļa atlikums, kad $a tiek dalīts ar $b.
Apskatīsim piemērus

$a = 2; // ņemiet vērā, ka skaitļu gadījumā pēdiņas netiek izmantotas
$b = 3; // ņemiet vērā, ka skaitļu gadījumā pēdiņas netiek izmantotas

$rezultāts = $a + $b; // pievienot mainīgos
atbalss $rezultāts; // izdrukās 5

$rezultāts = $b - $a; // pievienot mainīgos
atbalss $rezultāts; // izdrukās 1

Palielināšanas un samazināšanas darbības PHP
Šīs darbības noderēs galvenokārt ciklu konstruēšanā, par ko runāsim nedaudz vēlāk.
Prefikss- operatori, kas rakstīti PIRMS mainīgā ( --$a; +$a). Atgriež mainīgā vērtību pirms izmaiņām.
Postfix- operatori, kas rakstīti aiz mainīgā ( $a--; $a--). Atgriež mainīgā vērtību ar izmaiņām.
Pieaugums- vērtības palielināšana.
Samazinājums- vērtības samazināšanās.

+$a Prefiksa pieaugums. Palielina $a par vienu un atgriež $a vērtību.
$a++ Postfix pieaugums. Atgriež $a vērtību un pēc tam palielina $a par vienu.
--$a Prefiksa samazināšana. Samazina $a par vienu un atgriež $a vērtību.
$a-- Postfix samazinājums. Atgriež $a vērtību un pēc tam samazina $a par vienu.
atbalss"

Postfix pieaugums

Atbalss"

Prefiksa pieaugums

Atbalss"

Postfix samazinājums

Atbalss"

Prefiksa samazināšana

Piešķiršanas operācijas PHP
Pamatoperators izskatās = . No pirmā acu uzmetiena var šķist, ka tas ir vienlīdzības operators. Patiesībā tā nav taisnība. Faktiski piešķiršanas operators nozīmē, ka kreisais operands ņem labās izteiksmes vērtību (tas ir, to nosaka iegūtā vērtība). Kombinētie operatori- tie ir operatori, kas ļauj izmantot iepriekšējās mainīgo vērtības turpmākajām darbībām (pievienot virknes mainīgajam (ar tekstu) vai pievienot skaitliskās vērtības).

$a = ($b = 2) + 4; // rezultāts: $a ir iestatīts uz 6, mainīgajam $b ir piešķirts 2.

$a = 2;
$a += 3; // iestata $a uz 5, līdzīgi kā rakstot: $a = $a + 3;
$b = "Sveiki";
$b .= "Miers!"; // iestata $b uz virkni "Sveika pasaule!", piemēram, $b = $b . "Tur!";

Ir arī salīdzināšanas operācijas Un loģiski, bet par tiem mēs runāsim turpmākajās nodarbībās. Es centīšos jūs uzreiz nebiedēt ar lielu informācijas daudzumu!)

Šī apmācība aptver PHP mainīgo jomu. Izskaidro atšķirību starp lokālo un globālo tvērumu, parāda, kā funkcijā piekļūt globālajiem mainīgajiem, kā strādāt ar superglobāļiem un izveidot statiskus mainīgos.

Kad sākat mācīties PHP un sākat strādāt ar funkcijām un objektiem, mainīgā tvērums ir nedaudz mulsinošs. Par laimi, PHP noteikumi šajā ziņā ir ļoti viegli saprotami (salīdzinājumā ar citām programmēšanas valodām).

Kas ir darbības joma?

Mainīgo lielumu apjoms ir konteksts, kurā mainīgais tika definēts un kur tam var piekļūt. PHP ir divi mainīgie tvērumi:

• Globāli- mainīgajiem var piekļūt jebkurā skripta vietā
• Vietējais- mainīgajiem var piekļūt tikai tajā funkcijā, kurā tie tika definēti

Mainīgā lieluma apjoms, jo īpaši lokālais, ievērojami vienkāršo koda pārvaldību. Ja visi mainīgie būtu globāli, tos varētu mainīt jebkurā skripta vietā. Tas izraisītu haosu un lielus skriptus, jo ļoti bieži dažādās skripta daļās tiek izmantoti mainīgie ar vienādiem nosaukumiem. Ierobežojot darbības jomu ar lokālo kontekstu, jūs definējat koda robežas, kas var piekļūt mainīgajam, kas padara kodu izturīgāku, modulārāku un vieglāk atkļūdojamu.

Mainīgie ar globālā zona redzamība tiek saukta par globālu, bet ar lokālu tvērumu - par lokālu.

Šeit ir piemērs, kā darbojas globālie un lokālie mainīgie.

"; ) sayHello(); echo "\$globalName vērtība: "$globalName"
"; echo "\$localName vērtība: "$localName"
"; ?>

Sveiks Harij! $globalName vērtība: "Zoe" $localName vērtība: ""

Šajā skriptā mēs izveidojām divus mainīgos:

• $globalName-Šo globāli mainīgs
• $localName-Šo vietējais mainīgais, kas tiek izveidots funkcijā sayHello().

Pēc mainīgā un funkcijas izveides skripts izsauc sayHello(), kas izdrukā "Hello Harry!" . Pēc tam skripts mēģina izvadīt divu mainīgo vērtības, izmantojot atbalss funkciju. Lūk, kas notiek:

• Jo $globalName tika izveidots ārpus funkcijas, tas ir pieejams jebkurā skripta vietā, tāpēc tiek izvadīts "Zoe".
• $localName būs pieejams tikai funkcijā sayHello(). Tā kā atbalss izteiksme atrodas ārpus funkcijas, PHP nenodrošina piekļuvi vietējam mainīgajam. Tā vietā PHP sagaida, ka kods izveidos jaunu mainīgo ar nosaukumu $localName , kura noklusējuma vērtība būs tukša virkne. tāpēc otrais echo izsaukums izvada vērtību "" mainīgajam $localName.

Piekļuve globālajiem mainīgajiem funkcijā

Lai piekļūtu globālajam mainīgajam ārpus funkcijas Pietiek tikai uzrakstīt viņas vārdu. Bet, lai piekļūtu globālajam mainīgajam funkcijas iekšpusē, vispirms funkcijā ir jādeklarē mainīgais kā globāls, izmantojot globālo atslēgvārdu:

Funkcija myFunction() ( globālais $globalVariable; // Piekļūstiet globālajam mainīgajam $globalVariable )

Ja jūs to nedarāt, PHP pieņem, ka veidojat vai izmantojat lokālo mainīgo.

Šeit ir skripta piemērs, kas funkcijā izmanto globālo mainīgo:

"; globāls $globalName; echo "Sveiki, $globalName!
"; ) sakiet Sveiki(); ?>

Pēc izpildes skripts izvadīs:

Sveiks Harij! Sveika, Zoja!

Funkcija sayHello() izmanto globālo atslēgvārdu, lai deklarētu mainīgo $globalName par globālu. Pēc tam viņa var piekļūt mainīgajam un izvadīt tā vērtību (“Zoe”).

Kas ir superglobāļi?

PHP ir īpašs iepriekš definētu globālo masīvu komplekts, kas satur dažādu informāciju. Tādus masīvus sauc superglobāļi, jo tie ir pieejami no jebkuras vietas skriptā, ieskaitot iekšējo funkciju telpu, un tie nav jādefinē, izmantojot globālo atslēgvārdu.

Šeit ir saraksts ar superglobāliem, kas pieejami PHP versijā 5.3:

• $GLOBALS — visu globālo mainīgo saraksts skriptā (izņemot superglobālos)
• $_GET - satur visu veidlapas lauku sarakstu, ko pārlūkprogramma ir iesniegusi, izmantojot GET pieprasījumu
• $_POST — satur visu veidlapas lauku sarakstu, ko pārlūkprogramma nosūtījusi, izmantojot POST pieprasījumu
• $_COOKIE - satur visu pārlūkprogrammas nosūtīto sīkfailu sarakstu
• $_REQUEST — satur visas atslēgu/vērtību kombinācijas, kas ietvertas $_GET, $_POST, $_COOKIE masīvos
• $_FILES — satur visu pārlūkprogrammas lejupielādēto failu sarakstu
• $_SESSION — ļauj saglabāt un izmantot pašreizējās pārlūkprogrammas sesijas mainīgos
• $_SERVER - satur informāciju par serveri, piemēram, izpildāmā skripta faila nosaukumu un pārlūkprogrammas IP adresi.
• $_ENV - satur PHP nodoto vides mainīgo sarakstu, piemēram, CGI mainīgos.

Ja palaižat iepriekš minēto skriptu, izmantojot URL http://www.example.com/script.php?yourName=Fred, tas izvadīs:

Sveiks Fred!

Brīdinājums! Reālā skriptā šādu datu pārsūtīšanu nekad nevajadzētu izmantot vājas drošības dēļ. Jums vienmēr ir jāpārbauda vai jāfiltrē dati.

Superglobālais $GLOBALS ir ļoti ērti lietojams, jo tas ļauj funkcijā organizēt piekļuvi globālajiem mainīgajiem, neizmantojot globālo atslēgvārdu. Piemēram:

"; ) sayHello(); // Drukā "Sveika, Zoja!" ?>

Statiskie mainīgie: tie ir kaut kur tuvumā

Kad funkcijā izveidojat lokālo mainīgo, tas pastāv tikai funkcijas darbības laikā. Kad funkcija ir pabeigta, lokālais mainīgais pazūd. Kad funkcija tiek izsaukta vēlreiz, tiek izveidots jauns lokālais mainīgais.

Vairumā gadījumu tas darbojas lieliski. Tādējādi funkcijas ir autonomas un vienmēr darbojas vienādi katru reizi, kad tās tiek izsauktas.

Tomēr ir situācijas, kad būtu ērti izveidot lokālo mainīgo, kas funkciju izsaukšanas starplaikos "atceras" savu vērtību. Šādu mainīgo sauc par statisku.

Lai funkcijā izveidotu statisku mainīgo, pirms mainīgā nosaukuma ir jāizmanto statiskais atslēgvārds un noteikti piešķiriet tam sākotnējo vērtību. Piemēram:

Funkcija myFunction() ( statiska $myVariable = 0; )

Apskatīsim situāciju, kad ir ērti izmantot statisko mainīgo. Pieņemsim, ka izveidojat funkciju, kas, izsaucot, izveido logrīku un parāda jau izveidoto logrīku skaitu. Varat mēģināt rakstīt kodu šādi, izmantojot vietējo mainīgo:

"; echo createWidget() . " mēs jau esam izveidojuši.
"; echo createWidget() . " mēs jau esam izveidojuši.>
"; ?>

Bet, tā kā mainīgais $numWidgets tiek izveidots katru reizi, kad tiek izsaukta funkcija, mēs iegūsim šādu rezultātu:

Mēs izveidojam dažus logrīkus... Mēs jau esam izveidojuši 1. Mēs jau esam izveidojuši 1. Mēs jau esam izveidojuši 1.

Bet, izmantojot statisku mainīgo, mēs varam saglabāt vērtību no viena funkcijas izsaukuma uz otru:

"; echo createWidget() . " mēs jau esam izveidojuši.
"; echo createWidget() . " mēs jau esam izveidojuši.
"; echo createWidget() . " >mēs jau esam izveidojuši.
"; ?>

Tagad skripts sniegs gaidīto rezultātu:

Mēs izveidojam dažus logrīkus... Mēs jau esam izveidojuši 1. Mēs jau esam izveidojuši 2. Mēs jau esam izveidojuši 3.

Lai gan statiskais mainīgais saglabā savu vērtību starp funkciju izsaukumiem, tas ir derīgs tikai skripta darbības laikā. Kad skripts ir pabeidzis izpildi, tiek iznīcināti visi statiskie mainīgie, kā arī lokālie un globālie mainīgie.

Tas arī viss! Lūdzu, bieži skatiet savu PHP dokumentāciju.

pirms 13 gadiem

Nedaudz uzmanīties:

Ja izslēdzat RegisterGlobals un saistītos, pēc tam izmantojat get_defined_vars(), iespējams, redzēsit kaut ko līdzīgu:

Masīvs
[ GLOBALS ] => Masīvs
[ GLOBALS ] => Masīvs
*RECURSION*
[_POST] => Masīvs()
[_GET] => Masīvs()
[_COOKIE] => Masīvs()
[_FILES] => Masīvs()
)

[_POST] => Masīvs()
[_GET] => Masīvs()
[_COOKIE] => Masīvs()
[_FILES] => Masīvs()

)
?>

Ņemiet vērā, ka $_SERVER nav, šķiet, ka php ielādē superglobālo $_SERVER, ja tas tiek kaut kur izmantots.

drukāt "

" . htmlspecialchars(print_r(get_defined_vars(), true))."

" . htmlspecialchars (print_r ($_SERVER , true )) . "

pirms 6 gadiem

Tā kā get_defined_vars() iegūst mainīgos tikai tajā brīdī, kad izsaucat funkciju, ir vienkāršs veids, kā iegūt mainīgos, kas definēti pašreizējā tvērumā.

// Jūsu php skripta augšdaļa
$vars = get_defined_vars();

// Tagad dari savas lietas
$foo = "foo" ;
$bar = "josla" ;

// Iegūstiet visus mainīgos, kas definēti pašreizējā tvērumā
$vars = masīva_diff(get_defined_vars(), $vars);

atbalss"

"
;
print_r($vars); 
atbalss"

pirms 15 gadiem

Šeit ir funkcija, kas ģenerē atkļūdošanas pārskatu displejam vai e-pastam
izmantojot get_defined_vars. Lieliski piemērots detalizēta momentuzņēmuma iegūšanai bez
paļaujoties uz lietotāja ievadi.

function generateDebugReport ($method, $defined_vars, $email = "undefined")(
// Funkcija, lai izveidotu atkļūdošanas pārskatu, ko parādīt vai nosūtīt pa e-pastu.
// Lietošana: generateDebugReport(method,get_defined_vars(),email);
// Kur metode ir "pārlūkprogramma" vai "e-pasts".

// Izveidojiet ignorēšanas sarakstu atslēgām, kuras atgriež "get_defined_vars".
// Piemēram, HTTP_POST_VARS, HTTP_GET_VARS un citi ir
// lieks (tāds pats kā _POST, _GET)
// Iekļaujiet arī variantus, kurus vēlaties ignorēt drošības apsvērumu dēļ - t.i. PHPSESSID.
$ignorelist =array("HTTP_POST_VARS" , "HTTP_GET_VARS",
"HTTP_COOKIE_VARS", "HTTP_SERVER_VARS",
"HTTP_ENV_VARS", "HTTP_SESSION_VARS",
"_ENV" , "PHPSESSID" , "SESS_DBUSER" ,
"SESS_DBPASS" , "HTTP_COOKIE");

$laikspiedols = datums ("m/d/g h:m:s" );
$message = "Atkļūdošanas atskaite izveidota $timestamp \n" ;

// Labam mērījumam iegūstiet pēdējo SQL kļūdu, kur $link ir resursa identifikators
// mysql_connect. Komentējiet vai mainiet datubāzi vai abstrakcijas iestatījumus.
globālā $saite ;
$sql_error = mysql_error($saite);
if($sql_error )(
$message .= "\nMysql ziņojumi:\n" . mysql_error($saite);
}
//Beigt MySQL

// Šeit varētu izmantot rekursīvu funkciju. Tu saprati domu ;-)
foreach($defined_vars kā $key => $val )(
if(is_masīvs ($val ) && ! in_array ($key , $ignorelist ) && skaits ($val ) > 0 )(
$message .= "\n $atslēgu masīvs (key=value):\n" ;
foreach($val kā $subkey => $subval )(
if(! in_array ($subkey , $ignorelist ) && ! is_array ($subval ))(
$ziņa .= $apakšatslēga . " = " . $subval. "\n" ;
}
elseif(! in_array ($subkey, $ignorelist) && ir_masīvs ($subval ))(
foreach($subval kā $subsubkey => $subsubval )(
if(! in_array ($subsubkey, $ignorelist))(
$ziņojums .= $apakšatslēga . " = " . $subsubval . "\n" ;
}
}
}
}
}
elseif(! ir_masīvs ($val ) && ! in_array ($key , $ignorelist ) && $val )(
$message .= "\nMainīgais" . $key . " = " . $val. "\n" ;
}
}

If($method == "pārlūkprogramma" )(
echo nl2br($ziņojums);
}
elseif($method == "e-pasts")(
if($email == "nenodefinēts" )(
$email = $_SERVER [ "SERVER_ADMIN"];
}

$mresult = pasts ($email , "Atkļūdošanas atskaite for " . $_ENV [ "HOSTNAME" ]. "" , $message );
if($mresult == 1 )(
atbalss "Atkļūdošanas pārskats veiksmīgi nosūtīts.\n";
}
cits(
atbalss "Neizdevās nosūtīt atkļūdošanas pārskatu.\n";
}
}
}
?>

pirms 17 gadiem

Vienkārša rutīna get_defined_vars objekta konvertēšanai uz XML.

funkcija obj2xml ($v, $indent = "" ) (
while (saraksts($key , $val ) = katrs ($v )) (
if ($key == "__attr" ) turpināt;
// Pārbaudiet __attr
if (is_objekts ($val -> __attr )) (
while (saraksts($key2 , $val2 ) = katrs ($val -> __attr )) (
$attr .= " $key2 =\" $val2 \"" ;
}
}
else $attr = "" ;
if (is_masīvs ($val ) || is_object ($val )) (
print(" $indent< $key$attr >\n" );
obj2xml($val, $indent. "");
print(" $indent\n" );
}
else print(" $indent< $key$attr >$val\n" );
}
}

//Piemēra objekts
$x -> vārds -> pirmais = "Jānis" ;
$x -> vārds -> pēdējais = "Smits" ;
$x -> arr [ "Fruit" ] = "Banāns" ;
$x -> arr [ "Veg" ] = "Burkāns" ;
$y -> klients = $x ;
$y -> klients -> __attr -> id = "176C4" ;

$z = get_defined_vars();
obj2xml($z["y"]);
?>
izvadīs:


Jānis
Smits


Banāns
Burkāns

pirms 11 gadiem

Piezīme: get_defined_vars() neatgriež mainīgo atsauču kopu (kā es cerēju). Piemēram:

// definēt mainīgo
$my_var = "foo";

// iegūstiet mūsu definēto mainīgo sarakstu
$defined_vars = get_defined_vars();

// tagad mēģiniet mainīt vērtību, izmantojot atgriezto masīvu
$defined_vars [ "my_var" ] = "josla" ;

echo $my_var , "\n" ;

?>

izvadīs "foo" (sākotnējā vērtība). Būtu jauki, ja get_defined_vars() būtu neobligāts arguments, lai padarītu tās atsauces, taču es iedomājos, ka tas ir diezgan specializēts pieprasījums. Varat to izdarīt pats (mazāk ērti), izmantojot kaut ko līdzīgu:

$definēti_vari = masīvs();
$var_nosaukumi = masīva_atslēgas(get_defined_vars());

foreach ($var_names kā $var_name)
{
$defined_vars [ $var_name ] =& $ $var_name ;
}

?>

pirms 1 gada

Es šeit iepriekš publicēju informāciju par to, ka "šis" ir get_defined_vars.

Izrādās, ka tas ne vienmēr ir, bet dažos gadījumos tas neizskaidrojami parādīsies.

Php -r "
klases ieskaite(
publiskā funkcija a() (var_dump(array_keys(get_defined_vars()));$a = 123;)
publiskā funkcija b() (var_dump(array_keys(get_defined_vars()));$this;)
}
$t = new Test();
$t->a();
$t->b();
"

Masīvs()
masīvs ("šis")

Tas nenotiek PHP 7.2, bet gan PHP 5.6.

pirms 1 gada

Daži komentāri norāda, ka šī funkcija neatgriež atsauces. Tomēr tas atgriež vārdus, un nosaukumi ir "atsauces".

Es neieteiktu šeit sniegtos ieteikumus, kas to pārvērš atsaucēs.

Publiskā funkcija x($a, $b, $c) (
foreach(array_keys(get_defined_vars()) kā $key)
if($key !== "this")
$this->y($($key));
}

Publiskā funkcija y(&$input) (
$input++;
}

$() vietā varat izmantot arī $$.

Savā laikā esmu izdarījis dažas dīvainas lietas, lai izveidotu ārkārtīgi vispārīgu kodu, taču man nekad nav bijis jādara nekas līdzīgs iepriekšminētajam. Tas var pat nedarboties (bet vajadzētu, jo tas neatšķiras no $a[$key]).

Jūs varētu arī darīt $$key++, bet es nekad neesmu redzējis tādu kodu, kas nebūtu šausmīgi slikts (izmantojot dinamisko, kur dinamika nav izdevīga).

Ja jūs darāt kaut ko līdzīgu, veiciet papildu pārbaudi.

pirms 13 gadiem

Nedaudz uzmanīties:

Ja izslēdzat RegisterGlobals un saistītos, pēc tam izmantojat get_defined_vars(), iespējams, redzēsit kaut ko līdzīgu:

Masīvs
[ GLOBALS ] => Masīvs
[ GLOBALS ] => Masīvs
*RECURSION*
[_POST] => Masīvs()
[_GET] => Masīvs()
[_COOKIE] => Masīvs()
[_FILES] => Masīvs()
)

[_POST] => Masīvs()
[_GET] => Masīvs()
[_COOKIE] => Masīvs()
[_FILES] => Masīvs()

)
?>

Ņemiet vērā, ka $_SERVER nav, šķiet, ka php ielādē superglobālo $_SERVER, ja tas tiek kaut kur izmantots.

drukāt "

" . htmlspecialchars(print_r(get_defined_vars(), true))."

" . htmlspecialchars (print_r ($_SERVER , true )) . "

pirms 6 gadiem

Tā kā get_defined_vars() iegūst mainīgos tikai tajā brīdī, kad izsaucat funkciju, ir vienkāršs veids, kā iegūt mainīgos, kas definēti pašreizējā tvērumā.

// Jūsu php skripta augšdaļa
$vars = get_defined_vars();

// Tagad dari savas lietas
$foo = "foo" ;
$bar = "josla" ;

// Iegūstiet visus mainīgos, kas definēti pašreizējā tvērumā
$vars = masīva_diff(get_defined_vars(), $vars);

atbalss"

"
;
print_r($vars); 
atbalss"

pirms 15 gadiem

Šeit ir funkcija, kas ģenerē atkļūdošanas pārskatu displejam vai e-pastam
izmantojot get_defined_vars. Lieliski piemērots detalizēta momentuzņēmuma iegūšanai bez
paļaujoties uz lietotāja ievadi.

function generateDebugReport ($method, $defined_vars, $email = "undefined")(
// Funkcija, lai izveidotu atkļūdošanas pārskatu, ko parādīt vai nosūtīt pa e-pastu.
// Lietošana: generateDebugReport(method,get_defined_vars(),email);
// Kur metode ir "pārlūkprogramma" vai "e-pasts".

// Izveidojiet ignorēšanas sarakstu atslēgām, kuras atgriež "get_defined_vars".
// Piemēram, HTTP_POST_VARS, HTTP_GET_VARS un citi ir
// lieks (tāds pats kā _POST, _GET)
// Iekļaujiet arī variantus, kurus vēlaties ignorēt drošības apsvērumu dēļ - t.i. PHPSESSID.
$ignorelist =array("HTTP_POST_VARS" , "HTTP_GET_VARS",
"HTTP_COOKIE_VARS", "HTTP_SERVER_VARS",
"HTTP_ENV_VARS", "HTTP_SESSION_VARS",
"_ENV" , "PHPSESSID" , "SESS_DBUSER" ,
"SESS_DBPASS" , "HTTP_COOKIE");

$laikspiedols = datums ("m/d/g h:m:s" );
$message = "Atkļūdošanas atskaite izveidota $timestamp \n" ;

// Labam mērījumam iegūstiet pēdējo SQL kļūdu, kur $link ir resursa identifikators
// mysql_connect. Komentējiet vai mainiet datubāzi vai abstrakcijas iestatījumus.
globālā $saite ;
$sql_error = mysql_error($saite);
if($sql_error )(
$message .= "\nMysql ziņojumi:\n" . mysql_error($saite);
}
//Beigt MySQL

// Šeit varētu izmantot rekursīvu funkciju. Tu saprati domu ;-)
foreach($defined_vars kā $key => $val )(
if(is_masīvs ($val ) && ! in_array ($key , $ignorelist ) && skaits ($val ) > 0 )(
$message .= "\n $atslēgu masīvs (key=value):\n" ;
foreach($val kā $subkey => $subval )(
if(! in_array ($subkey , $ignorelist ) && ! is_array ($subval ))(
$ziņa .= $apakšatslēga . " = " . $subval. "\n" ;
}
elseif(! in_array ($subkey, $ignorelist) && ir_masīvs ($subval ))(
foreach($subval kā $subsubkey => $subsubval )(
if(! in_array ($subsubkey, $ignorelist))(
$ziņojums .= $apakšatslēga . " = " . $subsubval . "\n" ;
}
}
}
}
}
elseif(! ir_masīvs ($val ) && ! in_array ($key , $ignorelist ) && $val )(
$message .= "\nMainīgais" . $key . " = " . $val. "\n" ;
}
}

If($method == "pārlūkprogramma" )(
echo nl2br($ziņojums);
}
elseif($method == "e-pasts")(
if($email == "nenodefinēts" )(
$email = $_SERVER [ "SERVER_ADMIN"];
}

$mresult = pasts ($email , "Atkļūdošanas atskaite for " . $_ENV [ "HOSTNAME" ]. "" , $message );
if($mresult == 1 )(
atbalss "Atkļūdošanas pārskats veiksmīgi nosūtīts.\n";
}
cits(
atbalss "Neizdevās nosūtīt atkļūdošanas pārskatu.\n";
}
}
}
?>

pirms 17 gadiem

Vienkārša rutīna get_defined_vars objekta konvertēšanai uz XML.

funkcija obj2xml ($v, $indent = "" ) (
while (saraksts($key , $val ) = katrs ($v )) (
if ($key == "__attr" ) turpināt;
// Pārbaudiet __attr
if (is_objekts ($val -> __attr )) (
while (saraksts($key2 , $val2 ) = katrs ($val -> __attr )) (
$attr .= " $key2 =\" $val2 \"" ;
}
}
else $attr = "" ;
if (is_masīvs ($val ) || is_object ($val )) (
print(" $indent< $key$attr >\n" );
obj2xml($val, $indent. "");
print(" $indent\n" );
}
else print(" $indent< $key$attr >$val\n" );
}
}

//Piemēra objekts
$x -> vārds -> pirmais = "Jānis" ;
$x -> vārds -> pēdējais = "Smits" ;
$x -> arr [ "Fruit" ] = "Banāns" ;
$x -> arr [ "Veg" ] = "Burkāns" ;
$y -> klients = $x ;
$y -> klients -> __attr -> id = "176C4" ;

$z = get_defined_vars();
obj2xml($z["y"]);
?>
izvadīs:


Jānis
Smits


Banāns
Burkāns

pirms 11 gadiem

Piezīme: get_defined_vars() neatgriež mainīgo atsauču kopu (kā es cerēju). Piemēram:

// definēt mainīgo
$my_var = "foo";

// iegūstiet mūsu definēto mainīgo sarakstu
$defined_vars = get_defined_vars();

// tagad mēģiniet mainīt vērtību, izmantojot atgriezto masīvu
$defined_vars [ "my_var" ] = "josla" ;

echo $my_var , "\n" ;

?>

izvadīs "foo" (sākotnējā vērtība). Būtu jauki, ja get_defined_vars() būtu neobligāts arguments, lai padarītu tās atsauces, taču es iedomājos, ka tas ir diezgan specializēts pieprasījums. Varat to izdarīt pats (mazāk ērti), izmantojot kaut ko līdzīgu:

$definēti_vari = masīvs();
$var_nosaukumi = masīva_atslēgas(get_defined_vars());

foreach ($var_names kā $var_name)
{
$defined_vars [ $var_name ] =& $ $var_name ;
}

?>

pirms 1 gada

Es šeit iepriekš publicēju informāciju par to, ka "šis" ir get_defined_vars.

Izrādās, ka tas ne vienmēr ir, bet dažos gadījumos tas neizskaidrojami parādīsies.

Php -r "
klases ieskaite(
publiskā funkcija a() (var_dump(array_keys(get_defined_vars()));$a = 123;)
publiskā funkcija b() (var_dump(array_keys(get_defined_vars()));$this;)
}
$t = new Test();
$t->a();
$t->b();
"

Masīvs()
masīvs ("šis")

Tas nenotiek PHP 7.2, bet gan PHP 5.6.

pirms 1 gada

Daži komentāri norāda, ka šī funkcija neatgriež atsauces. Tomēr tas atgriež vārdus, un nosaukumi ir "atsauces".

Es neieteiktu šeit sniegtos ieteikumus, kas to pārvērš atsaucēs.

Publiskā funkcija x($a, $b, $c) (
foreach(array_keys(get_defined_vars()) kā $key)
if($key !== "this")
$this->y($($key));
}

Publiskā funkcija y(&$input) (
$input++;
}

$() vietā varat izmantot arī $$.

Savā laikā esmu izdarījis dažas dīvainas lietas, lai izveidotu ārkārtīgi vispārīgu kodu, taču man nekad nav bijis jādara nekas līdzīgs iepriekšminētajam. Tas var pat nedarboties (bet vajadzētu, jo tas neatšķiras no $a[$key]).

Jūs varētu arī darīt $$key++, bet es nekad neesmu redzējis tādu kodu, kas nebūtu šausmīgi slikts (izmantojot dinamisko, kur dinamika nav izdevīga).

Ja jūs darāt kaut ko līdzīgu, veiciet papildu pārbaudi.