Functie variable gebruiken buiten functie
Ik heb een vraag over functies en variables in php.
Ik zou graag een variable die in een functie gebruikt worden, gebruiken buiten een functie. (dus niet omgekeerd, een variabele buiten functie gebruiken binnen functie, dat doe je met global).
Stel je hebt bijvoorbeeld:
Code (php)
1
2
3
2
3
function foo() {
$data = 'value';
}
$data = 'value';
}
en je wilt $data gebruiken buiten de functie
Code (php)
1
echo $data;
Maar goed: dat werkt natuurlijk ook omgekeerd:
Of een alternatief: by reference:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
<?php
function bar(&$gegeven)
{
$gegeven = 'value';
}
$data = null;
bar($data);
echo $data;
?>
function bar(&$gegeven)
{
$gegeven = 'value';
}
$data = null;
bar($data);
echo $data;
?>
Code (php)
1
2
3
4
2
3
4
function foo() {
$data = 'value';
return $data;
}
$data = 'value';
return $data;
}
en dan waar je de functie aanroept:
Code (php)
1
2
2
$somevar = foo();
echo $somevar;
echo $somevar;
Tenminste, dat is hoe ik het zou proberen.
Gewijzigd op 15/02/2014 11:17:18 door Kevin Zegikniet
index.php
Code (php)
1
2
3
4
2
3
4
function foo(){
$data = 'value';
require_once 'file.php';
}
$data = 'value';
require_once 'file.php';
}
en daarna $data in file.php gebruiken:
file.php
Gewijzigd op 15/02/2014 11:28:17 door Jony V
Het blijft wat raar in mijn beleving om in een functie een include te gebruiken, maar het kan wel.
Let wel op, wat er precies gebeurt als er in file.php ook weer functie-definities of classes etc voorkomen.
Dan staat er een functie in een functie. Wat is daar dan precies de scope van?
Maar $data zou moeten werken, zoals je het hier toont
index.php
Code (php)
1
2
3
4
2
3
4
function foo() {
$data = 'value';
root::load_file('file.php');
}
$data = 'value';
root::load_file('file.php');
}
Op deze manier werkt het niet, enig idee waarom? Wanneer ik get_included_files() gebruik, staat file.php er nochtans tussen. De class root ziet er als volgt uit:
root.php
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
class root {
function load_file($filename) {
if (file_exists($filename)) {
require_once $filename;
}
}
}
function load_file($filename) {
if (file_exists($filename)) {
require_once $filename;
}
}
}
Gewijzigd op 15/02/2014 12:05:01 door Jony V
Dus hij staat helemaal niet op de plek waar je hem nodig had.
Ik stel altijd, dat een te includen file aanwezig is. Dat is namelijk bij het uploaden van de site zo geregeld.
Er kunnen bij mij geen files toegevoegd worden, of verwijderd worden door het systeem of door gebruikers.
Dus net zo goed als dat index.php als config.php aanwezig zijn, zal ook file.php aanwezig moeten zijn.
Zo niet, dan is dat een harde error waardig.
Ik vind daarmee je omweg met de controle nogal een overkill.
Anders is het als het uit gemakzucht niet 100% zeker is of een bepaalde view file in de map "huidige actie" zit of in "algemene files als footer.php, header.php" te vinden is.
Daar heb ik wel een soort van "zoek de view-file" voor, maar ik weet dan eigenlijk wel zeker dat de file ergens aanwezig is in 1 van de 3 of 4 mogelijke locaties.
Kan ik het op één of andere manier toch op de juiste plaats includen, gebruik makend van de functie in de root-class?
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
function foo() {
$data = 'value';
include root::get_path_for_file('file.php');
}
?>
function foo() {
$data = 'value';
include root::get_path_for_file('file.php');
}
?>
en in root staat dan een static method die inderdaad net als je get_file() method dat path opzoekt, maar ipv include, geeft die functie alleen het complete path retour.
Code (php)
}
Mits je die get_file() nog wilt blijven gebruiken natuurlijk.
Ivo P op 15/02/2014 11:05:17:
dat gaat nu net tegen het algemene nut van functies in.
Misschien een onnozele of rare vraag - ik ben een soort herintredende beginneling na 10 jaar geen php - maar waarom is dat tegen het nut van functies?
Ik gebruik functies vaak om code steeds opnieuw te kunnen gebruiken. Dan is het juist handig om variabelen er uit te kunnen gebruiken. Maar zo 'hoort het niet'?
Kun je me uitleggen waarom niet? Of hoe dan wel? Of een leuk artikel/link?
Alvast erg bedankt.
Hoe dat opgelost wordt intern, moet geen invloed hebben op jouw script.
Voorbeeld: laten we de functie faculteit nemen.
5! = 1 * 2 * 3 * 4 * 5 = 120
het is dat handig dat $i gewoon 5 blijft.
Stel dat er in deze functie nu staat:
Code (php)
$i hoort hier intern in de functie te blijven en niet invloed moeten hebben op de $i in je hoofdscript.
Want anders zou $i ineens 1 zijn en krijg je " 1! = 120" op je scherm...
Andere reden: een functie zou universeel bruikbaar moeten zijn.
er gaan 0, 1 of meer parameters (waarden) in, en er komt iets terug.
Het moet niet zo zijn, dat de functie uit de globale namespace een waarde oppikt om iets mee te doen:
Code (php)
Dit zou dus werken, maar beperkt je functie: je MOET dan $n gebruiken als invoer, en als je $x =10 hebt, dan werkt je functie niet meer.
Je schrijft 'of er komt iets uit terug'. Dat mogen eigenlijk geen variabelen zijn, dus?
Dan even andersom:
ik wil dit graag doen: in een script moet een stukje code een x aantal keer random twee getallen kiezen uit een aangegeven range.
Die random-getallengenerator wil ik in verschillende scripts gebruiken, maar dan steeds voor net iets andere doeleinden. Dan ligt het toch voor de hand om er een functie van te maken, die in een file te zetten en steeds die file te includen? Of zou het theoretisch anders moeten?
Het werkt namelijk op zich prima.
een functie die 2 getallen kiest uit een range
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
<?php
function random_it($min, $max)
{
$aRange = range($min, $max);
shuffle($aRange);
return array_slice($aRange,0,2);
}
?>
function random_it($min, $max)
{
$aRange = range($min, $max);
shuffle($aRange);
return array_slice($aRange,0,2);
}
?>
Er gaat iets in (min en max van de keuze lijst).
Er komt iets terug (een array met 2 waarden).
Zou je met global vars werken, dan moet je overal in je scripts zorgen dat er steeds dezelfde namen voor vars gebruikt worden.
(functie is trouwens uitbreidbaar met een derde parameter die van 2 ook 3, 4 of 10 waarden zou kunnen laten teruggeven.)
Wat is dan het werkelijke verschil tussen een var via global buiten de functie beschikbaar maken en wat jij doet via return?
Code (php)
$a en $b krijgen nu een waarde die veroorzaakt wordt door de aanroep van de functie.
Je geeft nu aan dat je op meerdere pagina's die functie wilt gebruiken.
Op elke pagina heb je dan verplicht een $a en $b nodig.
Dus als je daar met $x en $y wilt werken, dan moet je eerst kijken in de functie "oh ja die gebruikte $a en $b", en dan de waarde van $a maar naar $x en $b naar $y kopieren?
Om nog maar te zwijgen van de mogelijkheid dat je die 2 waarden binnen een andere functie wilt gebruiken.
Het mooie van een functie is nu net dat het een zwarte doos is: je stopt er iets in en je krijgt iets terug. Hoe dat intern gaat, doet er niet toe.
oh:
en je collega heeft een andere functie geschreven: hij bepaalt van een getal het kwadraat:
en nu heeft jouw script zowel jouw functie als die van je collega nodig.
Beide rommelen met $a uit de globale namespace.
Gewijzigd op 22/04/2014 16:10:01 door Ivo P