[php] Gedefiniërde variabelen binnen een functie krijgen

[Snow_King]

Hallo,

Ik zit niet zozeer met een probleem, maar meer met een vraag van hoe kan dit anders?

Ik maak veel gebruik van functies en zogenaamde config.php bestanden om wat standard configuratie in op te slaan.

Stel ik heb de volgende functie
config.php

PHP:

<?php

$allow_cijfers = 1;  //Als dit 1 is dan zijn cijfers toegestaan in de username

global $allow_cijfers;
?>

Dan een functie

PHP:

<?php

function check_username($username){
if(username_goed_is){
   return 1;
} else {
   return 0;
}
}
?>

Soms moet je aan een functie wel 10 variabelen meegeven.

Ik vind het fijn om vars die je vaak nodig hebt via $GLOBALS door mijn gehele scripts beschikbaar te maken en niet via functie_naam($var1, $var2, $var3, $var4);

Stel je roept die functie wel 15 keer op door al je scripts heen en je wijzigt die functie zodanig dat je een extra var nodig hebt uit config.php, dan moet je dus in al die 15 scripts dat ook aanpassen.

vars doorgeven aan functies doe ik alleen zo

PHP:

if(check_username($_POST["username"])){
   echo("Ja, je username is perfect!");
} else {
   echo("nee, die username is niet goed");
}

Wat vinden jullie van mijn methodes en hoe doen jullie dit?

[ Voor 19% gewijzigd door Snow_King op 28-04-2004 19:50 ]

[djluc]

Alle variablen sla ik op in de array $GLOBALS['settings']. Alle variablen die van buiten komen verstuur ik zoals jij doet alleen gaan ze bij mij *altijd* eerst door de ui (UserInput) functie heen. Die functie kan uitgebreid worden met validatie voor urls, email adressen enzovoorts. Voorlopig heb ik alleen ints en strings ingebouwd. Voorbeeldje:

PHP:

<?
if(check_username(ui($_POST["username"], 'string'))){ 
   echo("Ja, je username is perfect!"); 
} else { 
   echo("nee, die username is niet goed"); 
}
?> 

Ik ben heel consequent wat betreft instellingen. Als de instelling altijd geld haalt de functie deze zelf uit de $GLOBALS['settings'] array. Anders zit deze altijd in de aanroep.

offtopic:
Er zit een blokhaak in je tweede stukje code. Die kent PHP zo niet

[ Voor 33% gewijzigd door djluc op 28-04-2004 19:47 ]

[RedRose]

Kan je een voorbeeld geven van een functie die 10 parameters moet accepteren?

Je kan in ieder geval arrays gebruiken en de waarden die constant blijven, als constant definieren. Bijvoorbeeld:

PHP:

// settings

$DBSettings= array('username' => 'jandevries', 'pw' => 'jan', 'host' => 'localhost');
define ('ALLOW_NON_ALPHA_CHARS',0);
define ('USERNAME_MAX_LENGTH',10);

// username check

function checkUserName($settings)
{
    // $settings is dan de settingsarray die je meegeeft
    echo ALLOW_NON_ALPHA_CHARS;
    echo USERNAME_MAX_LENGTH;
}

Op die manier hoef je eigenlijk bijna nooit wat global te definieren en hou je je parameterlist kort.

Let wel, dit is niet de enige manier, je kan ook overwegen om classes te gaan gebruiken. Lees ook wat over references

[Verwijderd]

Ik doe globale settings met define. Daar is het zo ongeveer wel geschikt voor.

[chris]

je kan inderdaad classes gebruiken, maar global gebruik ik ook wel soms, inderdaad alleen voor settings. imho maakt het niet zoveel uit of je $settings global maakt of $GLOBALS oid gebruikt, zolang je maar niet vieze dingen gaat doen enzo

[da Burp]

Tsja, altijd lastig zoiets.

Ik denk dat voorkomen beter is als genezen. Door goed na te denken over je functies en klasses kan je dit enigzins voorkomen.

Het probleem komt me echter wel bekend voor. Soms is het wel eens op te lossen met een door een var een default value te geven, dat dus niet alle aanroepen hoeft te veranderen.

Het maken van globals is een optie ik vind het echter 'lui'. Ikprobeer zoiets altijd in een klasse op te bergen, en ervoor te zorgen dat anderen klassen die die variabelen nodig hebben toegang hebben tot die klasse.

[Snow_King]

Verwijderd schreef op 28 april 2004 @ 19:48:
Ik doe globale settings met define. Daar is het zo ongeveer wel geschikt voor.

Ja, maar $GLOBALS ook?

[djluc]

Ik vind het fijn dat mijn array wat meer structuur heeft dan losse defines. Alle settings over inloggen staan in $GLOBALS['settings']['login']. Dat vind ik persoonlijk veel handiger omdat je ook met een eenvoudige print_r precies kunt zien welke settings zijn ingesteld e.d.

Het maken van globals is een optie ik vind het echter 'lui'. Ikprobeer zoiets altijd in een klasse op te bergen, en ervoor te zorgen dat anderen klassen die die variabelen nodig hebben toegang hebben tot die klasse.

Voor zaken als settings vind ik dit zeker niet het geval. Het zorgt imo zelfs voor wat extra flexibiliteit aangezien je de settings ook handig beheerbaar kunt maken. Denk hierbij aan het plaatsen van je settings in de database. De enige aanpassing die je moet maken is het config bestand voorzien van een query die de gegevens in de globale array zet. Het systeem hoeft dus verder niet aangepast te worden omdat de gegevens toch weer in dezelfde array te vinden zijn.

edit:
20:00uur en iedereen is ineens pleite. Koffie tijd zeker

[ Voor 64% gewijzigd door djluc op 28-04-2004 20:01 ]

[Snow_King]

Dat ben ik dus met je eens djluc, je kan "groepen" maken met vars.

en da_Burp, waarom is dat lui? het is toch gewoon een functie in php?

[RedRose]

djluc schreef op 28 april 2004 @ 19:53:
Ik vind het fijn dat mijn array wat meer structuur heeft dan losse defines. Alle settings over inloggen staan in $GLOBALS['settings']['login']. Dat vind ik persoonlijk veel handiger omdat je ook met een eenvoudige print_r precies kunt zien welke settings zijn ingesteld e.d.

PHP:

define ('UN_MAX_CHARS',10);
define ('UN_MIN_CHARS',3);
define ('UN_ALLOW_ALPHA',1);

print_r(get_defined_constants());

Voor zaken als settings vind ik dit zeker niet het geval. Het zorgt imo zelfs voor wat extra flexibiliteit aangezien je de settings ook handig beheerbaar kunt maken. Denk hierbij aan het plaatsen van je settings in de database. De enige aanpassing die je moet maken is het config bestand voorzien van een query die de gegevens in de globale array zet. Het systeem hoeft dus verder niet aangepast te worden omdat de gegevens toch weer in dezelfde array te vinden zijn.

Dat kan je ook makkelijk afvangen met defines of het doorpassen van 1 array.

Snow_King schreef op 28 april 2004 @ 19:55:
Dat ben ik dus met je eens djluc, je kan "groepen" maken met vars.

Groepen maken met vars of groeperen van waarden in 1 array vind ik twee verschillende dingen. Het eerste geeft je een overkill aan vars, iets dat onnodig is. Het tweede vind ik wel kunnen, maar dan nog hoeft zo'n array niet global te worden.

[Soultaker]

Je kunt globale variabelen ook gewoon met 'global' importeren; of ging het daar niet om?

PHP:

function check_username($username)
{
    global $allow_numbers;
    if($allow_numbers) 
    ... etc ...
}

Met het gebruik van globale variabelen moet je wel voorzichtig zijn, omdat je ze vrij makkelijk 'per ongeluk' kunt overschrijven. Als je bijvoorbeeld een gebruikersnaam in een globale variabele $username stopt, is de kans vrij groot dat een stuk code dat een gebruikersnaam uit een database haalt (om maar wat te noemen) ook een tijdelijke variable $username gebruikt.

Om dit op te lossen schrijf ik m'n 'echte' globale variabelen met hoofdletters en probeer ik (zoals ook al genoemd is) meerdere waarden in een enkele variabele te stoppen met arrays. In een configuratiebestand staat dan bijvoorbeeld:

PHP:

$DATABASE = array(
    "host"     => "localhost",
    "port"      => 12345,
    "username" => "foo",
    "database" => "bar",
    "connection" => NULL );

Op deze manier kun je er vrij zeker van zijn dat deze variabele niet per ongeluk overschreven zal worden (als je consequent lokale variabelen met kleine letters gebruikt) en bovendien is het erg duidelijk of je aan lokale of globale variabelen refereert. (PHP zelf kent dit onderscheid tussen 'lokaal' en 'globaal' niet echt; alleen variabelen binnen functies/methoden zijn echt 'lokaal').

edit:
Oh ja, ik ben niet zo'n fan van constanten, omdat die kunnen clashen met (bijvoorbeeld) functies en niet zo duidelijk als variabelen herkenbaar zijn. Sowieso zijn constanten vooral geschikt voor 'echte' constanten (variabelen die niet van waarde veranderen) en niet voor globale variabelen die ook wel eens aangepast worden (denk daarbij aan een iets als een database connection). Verder kun je er alleen echte scalaire data in kwijt en geen resources (file handles, database connecties, etc.) of arrays.

[ Voor 22% gewijzigd door Soultaker op 28-04-2004 20:09 ]

[bat266]

In het algemeen is het niet zo slim om globals te gebruiken (wel makkelijk ) vooral als je later je code gaat wijzigen kan het voorkomen dat je per ongeluk een global overschrijft aangezien je snel vergeet hoe het ook al weer in elkaar zat. Ook als je met meerdere personen aan 1 project werkt is het niet zo handig. Verder globals bestaan en kunnen dus gewoon gebruikt worden alleen volgens mij kleven er meer nadelen aan dan voordelen, maja wie ben ik.

[drm]

Soultaker:
Oh ja, ik ben niet zo'n fan van constanten, omdat die kunnen clashen met (bijvoorbeeld) functies en niet zo duidelijk als variabelen herkenbaar zijn. Sowieso zijn constanten vooral geschikt voor 'echte' constanten (variabelen die niet van waarde veranderen) en niet voor globale variabelen die ook wel eens aangepast worden (denk daarbij aan een iets als een database connection). Verder kun je er alleen echte scalaire data in kwijt en geen resources (file handles, database connecties, etc.) of arrays.

Imho zijn constanten (met define) hier uitermate geschikt voor, gezien de levensduur van het script toch request/response is. Ik kan me niet voorstellen dat het zin heeft om een resource in een constante op te slaan , en geen voordeel bedenken van echte constanten (let wel: voor de duur van je script) in variabelen opslaan.

Zeker zaken die je script configureren (dus dingen als database-logingegevens) zet ik altijd in defines. Maar het blijft (denk ik) een kwestie van smaak

[Snow_King]

Nu ik dit zo heb gelezen en voor het eerst *kuch* ben gaan testen met define kom ik er achter dat dit toch wel een stukje netter en fijner werkt dan $GLOBALS

[djluc]

Snow_King schreef op 28 april 2004 @ 20:43:
Nu ik dit zo heb gelezen en voor het eerst *kuch* ben gaan testen met define kom ik er achter dat dit toch wel een stukje netter en fijner werkt dan $GLOBALS

Vertel eens waarom? Behlave dat je wat minder moet typen.

offtopic:
jammer hè dat je dat niet meer als argumentje kunt gebruiken

[Snow_King]

Hierboven wordt gezegt dat je een GLOBAL var gemakkelijk overschrijft en dat moet ik dus toegeven.

Ook staat define wat "netter" en GLOBALS

[djluc]

Snow_King schreef op 28 april 2004 @ 21:40:
Hierboven wordt gezegt dat je een GLOBAL var gemakkelijk overschrijft en dat moet ik dus toegeven.
Ook staat define wat "netter" en GLOBALS

Als je mijn voorbeeldje volgt niet Ik gebruik: $GLOBALS['settings'] waar vervolgens alles onder komt te hangen. Dus overschrijven lijkt mij vrij lastig want er is maar 1 echte settings in mijn systeem... Netter snap ik verder niet maargoed dat is een mening, daar kunnen we verder niet veel mee

[ Voor 13% gewijzigd door djluc op 28-04-2004 22:00 ]

[Dennis]

djluc schreef op 28 april 2004 @ 22:00:
Netter snap ik verder niet maargoed dat is een mening, daar kunnen we verder niet veel mee

Het is netter als je een geheel object-geörienteerde applicatie schrijft, dan hoef je niet met vieze globals te werken. Globals horen inderdaad constant te zijn en anders zijn het eigenlijk geen echte globals .

Kom maar, kom maar, kom maar... .

[4Real]

PHP:

function check_username($username)
{ 
    global $allow_cijfers; 

    if(username_goed_is)
    { 
        return 1; 
    }
    else
    { 
        return 0; 
    } 
}

Waarom zet je die global niet in de functie dat moet toch ook werken?

[ Voor 5% gewijzigd door 4Real op 28-04-2004 22:24 ]

[Dennis]

4Real schreef op 28 april 2004 @ 22:23:
Waarom zet je die global niet in de functie dat moet toch ook werken?

Dat vind ik al helemaal een ruk-oplossing. Nee, constanten gebruiken is hier gewoon de beste, netste en simpelste oplossing. Bovendien neemt het nog eens minder code in beslag omdat je niet steeds in elke functie een global hoeft te gebruiken (zoals in jouw voorbeeld).

[djluc]

ddc schreef op 28 april 2004 @ 22:04:
[...]
Het is netter als je een geheel object-geörienteerde applicatie schrijft, dan hoef je niet met vieze globals te werken. Globals horen inderdaad constant te zijn en anders zijn het eigenlijk geen echte globals .
Kom maar, kom maar, kom maar... .

Even buiten het feit om dat ik het niet fijn vind om in PHP OOP-gebaseerd te werken. Je hebt het neem ik aan over constanten in de vorm van: "het is technisch niet mogelijk iets te veranderen wat constant is." Dan heb je inderdaad een punt. Als ik je echter vertel dat ik alleen in het config.php bestand alle instellingen maak en deze vervolgens in de global array plaats heb ik ook constanten. Ze zijn dan wel niet read-only maar ik heb me er toe verplicht deze later niet meer te veranderen. Dus in mijn redenatie gaat jouw punt nergens over.

[Dennis]

Mag ik vragen waarom je ze dan in een global array plaatst en niet in constanten?