abonnement Unibet Coolblue Bitvavo
  woensdag 19 februari 2014 @ 21:18:39 #76
63192 ursel
"Het Is Hier Fantastisch!
pi_136907364
conferences, gebruikersgroepen bezoeken en webinars volgen om te zien waar technieken heen gaan vandaag de dag. :Y
pi_136908516
quote:
0s.gif Op woensdag 19 februari 2014 21:12 schreef zoem het volgende:
Het werken met een degelijk framework (Zend Framework, Symfony, etc) helpt ook om grip te krijgen op de werking en gedachte achter OOP-structuren. Echter moet je dan wel al wat basiskennis bezitten. Iets maken is uiteindelijk de beste leerschool.
quote:
0s.gif Op woensdag 19 februari 2014 21:15 schreef totalvamp het volgende:

[..]

Een framework is handig inderdaad, ik zou het alleen niet bij 1 laten.
quote:
0s.gif Op woensdag 19 februari 2014 21:18 schreef ursel het volgende:
conferences, gebruikersgroepen bezoeken en webinars volgen om te zien waar technieken heen gaan vandaag de dag. :Y
Helemaal mee eens, maar als je nog niet weet wat een array is, heb je nog wel een héééééééle lange weg te gaan voordat je je in ditsoort dingen wilt gaan verdiepen.
pi_136916348
quote:
0s.gif Op woensdag 19 februari 2014 20:42 schreef totalvamp het volgende:

[..]
<knip>
Dankzij jouw uitleg snap mijn code nu wat beter, dankjewel!

Ik heb een debugger in het form gezet en ik krijg het volgende:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Data Array:
Array
(
    [option] => com_chronoforms
    [tmpl] => component
    [chronoform] => inschrijf_form
    [event] => submit
    [Itemid] => 
    [input_text_12] => naam
    [input_text_13] => straat
    [input_text_14] => postcode / plaats
    [input_text_15] => tel
    [input_text_16] => email
    [input_radio_17] => radiobox keuze
    [chrono_verification] => AE3zY
    [input_submit_18] => Submit
    [a65f6c919aedc844149f022974440e8d] => 1
)

Validation Errors:
Array
(
)

Ik kan twee keuzes maken bij de radiobox. Welke keuze ik ook maak, de debugger geeft altijd [input_radio_17] aan. (trial & error :') !)
Je tip via DM (het niet bestaan van $form->data['radioboxes']) heeft mij doen beseffen dat ik in de PHP een verwijzing moet hebben naar die [input_radio_17] en naar de naam van het formulier.
De naam van het formulier is: inschrijf_form

De PHP mét inschrijf_form en input_radio_17:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
if ( !isset($inschrijf_form->data['input_radio_17']) || count($inschrijf_form->data['input_radio_17']) == ) {
  return;
}
$files_array = array (
    
    
=>    JPATH_SITE.'http://www.etcetera.pdf',
    
=>     JPATH_SITE.'http://www.etcetera.pdf',
);
$attach_files = array();
foreach ( 
$files_array as $k => $v ) {
  if ( 
in_array($k$inschrijf_form->data['input_radio_17']) ) {
    
$attach_files[] = $v;
  }
}
$inschrijf_form->data['file_array'] = $attach_files;

print_r($_POST)
?>

Het formulier verstuurt nog steeds geen PDF naar de gebruiker.
Mijn vraag is echter of het formulier en de PHP in theorie zou moeten werken.
Zo ja; dan weet ik dat de code klopt en dat ik verder zoeken naar een instelling die ik over het hoofd zie.
  Moderator / Redactie Sport / Devops donderdag 20 februari 2014 @ 00:38:08 #79
176766 zoem
zoemt
pi_136916713
Even los van de bijlage, wordt er uberhaupt wel een mail gestuurd na het submitten van het formulier? Als dat al niet werkt ligt het probleem niet bij de bijlage.

Even door de chronoforms library gebladerd, maar wat is dat anno 2014 slechte code zeg...
pi_136916783
quote:
0s.gif Op donderdag 20 februari 2014 00:38 schreef zoem het volgende:
Even los van de bijlage, wordt er uberhaupt wel een mail gestuurd na het submitten van het formulier? Als dat al niet werkt ligt het probleem niet bij de bijlage.
Ja, de admin ontvangt een email met daarin de ingevulde gegevens.
  Moderator / Redactie Sport / Devops donderdag 20 februari 2014 @ 00:55:51 #81
176766 zoem
zoemt
pi_136916994
De vraag is nu waar het fout gaat. Komen de formuliergegevens juist door? Zo ja, gaat het verwerken ervan goed? Indien ja, via welke code wordt de emailinhoud samengesteld en hoe wordt het verzonden? Je zult stap voor stap steeds een stukje dieper de code in moeten duiken door functie-aanroepen te volgen tot het punt waar je de fout tegenkomt. Soms heb je het zo gevonden, maar soms kun je ook úren bezig zijn om een klein foutje eruit te vissen. Goed kunnen debuggen is een kunst op zich :)
pi_136920014
quote:
5s.gif Op donderdag 20 februari 2014 00:18 schreef karton2 het volgende:


De PHP mét inschrijf_form en input_radio_17:
[ code verwijderd ]

Het formulier verstuurt nog steeds geen PDF naar de gebruiker.
Mijn vraag is echter of het formulier en de PHP in theorie zou moeten werken.
Zo ja; dan weet ik dat de code klopt en dat ik verder zoeken naar een instelling die ik over het hoofd zie.
Probeer eerst eens terug begrijpen wat je code precies doet voordat je random dingen gaat aanpassen. wat je nu hebt staan slaat namelijk helemaal nergens op.

Zoek eens op php.net op wat de gebruikte functies en loops doen. Zorg dat je helder hebt wat er in de variabelen staat die je gebruikt. Op deze manier met hagel schieten brengt je nergens.
  donderdag 20 februari 2014 @ 09:48:48 #83
25889 Sitethief
Fulltime Flapdrol
pi_136920606
Ik had een vraagje over Exceptions, ik ben nu bezig mezelf aan te leren om die vaker te gebruiken ipv steed false terug te geven als er iets mis gaat. Ik stuur nu veel exceptions terug naar de plek van aanroep door verschillende functies heen, alleen ik heb nu het idee dat het eigenlijk niet de beste manier is zoal ik dat nu doe. Volgens mij kan ik namelijk ook alle exceptions in 1 try catch doorsturen. Maar ook vraag ik me af of dit wel nodig is, omdat de class aanroep zelf ook al in een try catch zit. Het wordt anders wel een hele lang lijst met try catch...
Zie deze code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
<?php
/**
     * Bouw generieke generator op met eventuele extra data uit child classes
     * 
     * Voorbeeld voor de options
     * $options = array(
     *                  'allTpls'           =>  'getAllFormTpls',
     *                  'listTpl'           =>  '/generator/listTemplates',
     *                  'elementTpl'        =>  '/generator/element',
     *                  'generatorTpl'      =>  '/generator/generator',
     *                  'modifyTpl'         =>  '/generator/modify',
     *                  'configurationTpl'  =>  '/generator/configuration',
     *   );
     * 
     * @param string $type Generator type, bijv. report, form. Zal bijv. worden gebruikt in de benanimg van id's in html etc
     * @param array $options array met opties, zie hierboven voor alle mogelijk onderdelen
     * @throws \library\generator\Exception    Rethrows alle exceptions
     * @return void
     */
    
public function __construct($type$options) {
        
parent::__construct($this->dbOptions);          //bouw db in de OMS parent class op
        
try {
            
$this->setOptions($options);                //set $this->options
        
} catch (Exception $exc) {
            throw 
$exc//rethrow
        
}
        
$this->setObjects($this->dbOptions);            //haal alle toegankelijke objecteninformatie op dmv een functie in de ixPlanta class
        
$this->secure = new Secure();                   //instantieer de secure class
        
try {
            
$this->setType($type);                      //set $this->type
        
} catch (Exception $exc) {
            throw 
$exc//rethrow
        
}
        try {                                           
//set $this->company  
            
$this->setCompany(true);                    //@TODO ondersteuning voor meerdere companies inbouwen?  
        
} catch (Exception $exc) {
            throw 
$exc//rethrow
        
}
        
$this->setProject();                            //set project en projectDbName gebaseerd op de IXPLATTFORM constante
        
$this->setDesign();                             //set design doc gebaseerd op de IXPLATTFORM constante
        
try {
            
$this->setViews();                          //set $this->views met alle views uit $this->options
        
} catch (Exception $exc) {
            throw 
$exc//rethrow
        
}
        try {
            
$this->setTemplates();                      //set $this->templates met alle templates uit $this->options
        
} catch (Exception $exc) {
            throw 
$exc//rethrow
        
}
        try {
            
$this->setChunkTplChunks();                 //set $this->chunktpl met alle templates uit $this->templates
        
} catch (Exception $exc) {
            throw 
$exc//rethrow
        
}
        try {
            
$this->setUserGroupNames();                 //set $this->userGroupNames
        
} catch (Exception $exc) {
            throw 
$exc//rethrow
        
}        
    }

    public function 
setType($type){
        if (isset(
$type) && is_string($type)) {
            
$this->type $type;                        //set type
        
} else {
            throw new \
Exception('Invalid type');
        }
    }
?>
Stroek: Sitethief, die is heel groot en sterk :Y.
Faat: *zucht* zoals gewoonlijk hoor Sitethief weer in de bocht &gt;:)
  donderdag 20 februari 2014 @ 10:07:46 #84
25889 Sitethief
Fulltime Flapdrol
pi_136920995
Hmm, ik heb ze nu gewoon verwijderd, las net ergens dit:
quote:
You should not be catching the exception unless you intend to do something meaningful.
En dat is nu niet het geval.
Stroek: Sitethief, die is heel groot en sterk :Y.
Faat: *zucht* zoals gewoonlijk hoor Sitethief weer in de bocht &gt;:)
pi_136925569
Wat je hebt gedaan is goed. In je testsuite zie je vanzelf dat het doodgaat als de onderliggende meuk dood gaat. Tenzij je iets doet als:

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
try { 
   
ga_dood();

catch (
Exception $e) { 
    
# Ik weet dat ik doodga, maar het boeit niet, tenzij ik foutmelding X krijg
    
if ($e->getMessage() == "Nu moet je wel doodgaan") { 
        throw(
$e);
    }
}

# life is like a box of chocolates
?>

Wat ik vaak doe is dat ik ga kijken of de situatie goed is om iets te doen, meestal assert ik dan de opties en ga ik ook dood als het fout gaat.

Dus als $this->set_company($company); doodgaat omdat company undef is:

Dan zorg ik ervoor dat 1) de param niet undef kan zijn en dat m'n caller er gelijk uitklapt en $company bijvoorbeeld bepaalde waarde is controleer ik vooraf of die waarde wel correct is en dat doen we dan met bijvoorbeeld een constante. En dan kan je door je gehele applicatie dat checken en mogelijk Exceptions throwen.

[ Bericht 14% gewijzigd door slacker_nl op 20-02-2014 12:58:32 ]
In theory there is no difference between theory and practice. In practice there is.
pi_136928219
quote:
0s.gif Op donderdag 20 februari 2014 10:07 schreef Sitethief het volgende:
Hmm, ik heb ze nu gewoon verwijderd, las net ergens dit:

[..]

En dat is nu niet het geval.
Ik las heel jouw post en dacht ik ga posten erop, tot ik deze post las :P

Met elke functie die een actie doet met gevolgen, zorg je ervoor dat je een return false hebt bijvoorbeeld.
Exceptions maak je eigenlijk zelden gebruik van, Alleen als je wilt dat je script ermee stop op het moment van de exceptie (meestal een fatal error)
pi_136954297
quote:
0s.gif Op donderdag 20 februari 2014 10:07 schreef Sitethief het volgende:
Hmm, ik heb ze nu gewoon verwijderd, las net ergens dit:

[..]

En dat is nu niet het geval.
De belangrijkste regels voor het werken met excepties zijn:
1. Gebruik excepties alleen voor exceptionele situaties.
2. Gooi nooit Exception (maar bijvoorbeeld een InvalidArgumentException)
3. Vang altijd Exception, niet alleen het specifieke type dat wordt gegooid

Dus als je bijvoorbeeld user input aan het controleren bent, moet je geen excepties gooien. Het is (in mijn ogen) verwacht gedrag dat die input niet voldoet aan de eisen die je eraan stelt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
/**
 * @param string $type
 *
 * @throws \InvalidArgumentException
 */
public function setType($type)
{
    if (!
is_string($type) {
        throw new \
InvalidArgumentException('$type must be a string');
    }

    
$this->type $type;
}
?>

Docblocks zijn heel handig om aan te geven wat een functie doet, welke argumenten er worden verwacht, welk type er teruggegeven wordt en wat er aan excepties kan worden verwacht. Je kunt er uiteraard ook bijzetten wat een functie doet.
pi_136954564
quote:
0s.gif Op donderdag 20 februari 2014 12:51 schreef slacker_nl het volgende:

Wat ik vaak doe is dat ik ga kijken of de situatie goed is om iets te doen, meestal assert ik dan de opties en ga ik ook dood als het fout gaat.

Dus als $this->set_company($company); doodgaat omdat company undef is:

Dan zorg ik ervoor dat 1) de param niet undef kan zijn en dat m'n caller er gelijk uitklapt en $company bijvoorbeeld bepaalde waarde is controleer ik vooraf of die waarde wel correct is en dat doen we dan met bijvoorbeeld een constante. En dan kan je door je gehele applicatie dat checken en mogelijk Exceptions throwen.
Asserts hebben het nadeel dat ze uitgezet kunnen worden. Ik kan dus instellen dat ze bij mij niet afgaan, waardoor ik niet gewaarschuwd wordt voor ongeldige waardes. Om die reden vind ik asserts eigenlijk geen geschikte optie voor public API, en wel voor private en protected functies.
  vrijdag 21 februari 2014 @ 09:39:54 #90
25889 Sitethief
Fulltime Flapdrol
pi_136963806
quote:
0s.gif Op donderdag 20 februari 2014 23:04 schreef Light het volgende:

[..]

De belangrijkste regels voor het werken met excepties zijn:
1. Gebruik excepties alleen voor exceptionele situaties.
2. Gooi nooit Exception (maar bijvoorbeeld een InvalidArgumentException)
3. Vang altijd Exception, niet alleen het specifieke type dat wordt gegooid

Dus als je bijvoorbeeld user input aan het controleren bent, moet je geen excepties gooien. Het is (in mijn ogen) verwacht gedrag dat die input niet voldoet aan de eisen die je eraan stelt.
[ code verwijderd ]

Docblocks zijn heel handig om aan te geven wat een functie doet, welke argumenten er worden verwacht, welk type er teruggegeven wordt en wat er aan excepties kan worden verwacht. Je kunt er uiteraard ook bijzetten wat een functie doet.
Alleen zijn al die dingen geen userinput maar input van classes die op deze class bouwen, die dus een generator willen opbouwen met hun instellingen, dus bijv. een class van mijn collega gebouwd.

(Even kort antwoord, bedankt voor de tips van allebei de posters)
Stroek: Sitethief, die is heel groot en sterk :Y.
Faat: *zucht* zoals gewoonlijk hoor Sitethief weer in de bocht &gt;:)
  Moderator / Redactie Sport / Devops vrijdag 21 februari 2014 @ 10:26:31 #91
176766 zoem
zoemt
pi_136965052
quote:
0s.gif Op donderdag 20 februari 2014 12:51 schreef slacker_nl het volgende:
Wat je hebt gedaan is goed.
Als je de code gepost door Sitethief bedoelt: die (constructor) is fout, maar hij heeft het daarna op de juiste manier gecorrigeerd. Het tussendoor opvangen van exceptions en het daarna gelijk rethrowen is natuurlijk onzinnig. Niet alleen vanwege het feit dat het overbodige code is, maar het kan ook de call stack trace beïnvloeden. Ik ben het dan ook geheel eens met Light over het gebruik van exceptions.
quote:
Wat ik vaak doe is dat ik ga kijken of de situatie goed is om iets te doen, meestal assert ik dan de opties en ga ik ook dood als het fout gaat.
Hoe vaak ben je al 'doodgegaan' als ik vragen mag? Ik vind het zo'n gekke bewoording :P
  vrijdag 21 februari 2014 @ 10:42:14 #92
187069 slacker_nl
Sicko pur sang
pi_136965489
quote:
14s.gif Op vrijdag 21 februari 2014 10:26 schreef zoem het volgende:

[..]

Als je de code gepost door Sitethief bedoelt: die (constructor) is fout, maar hij heeft het daarna op de juiste manier gecorrigeerd. Het tussendoor opvangen van exceptions en het daarna gelijk rethrowen is natuurlijk onzinnig. Niet alleen vanwege het feit dat het overbodige code is, maar het kan ook de call stack trace beïnvloeden. Ik ben het dan ook geheel eens met Light over het gebruik van exceptions.

[..]

Hoe vaak ben je al 'doodgegaan' als ik vragen mag? Ik vind het zo'n gekke bewoording :P
Ik ben al heel vaak doodgegaan. En m'n code nog meer!

En ik doelde op de correctie ja ;)

[ Bericht 5% gewijzigd door slacker_nl op 21-02-2014 10:54:21 ]
In theory there is no difference between theory and practice. In practice there is.
  vrijdag 21 februari 2014 @ 10:50:55 #93
187069 slacker_nl
Sicko pur sang
pi_136965739
quote:
0s.gif Op donderdag 20 februari 2014 23:04 schreef Light het volgende:

Dus als je bijvoorbeeld user input aan het controleren bent, moet je geen excepties gooien. Het is (in mijn ogen) verwacht gedrag dat die input niet voldoet aan de eisen die je eraan stelt.
Je frontend code moet dat goed afvangen, je backend code moet doodgaan op het moment dat de input incorrect is. Ipv Exceptions zou je ook nog trigger_error kunnen gebruiken.
In theory there is no difference between theory and practice. In practice there is.
  vrijdag 21 februari 2014 @ 10:53:57 #94
187069 slacker_nl
Sicko pur sang
pi_136965848
quote:
0s.gif Op donderdag 20 februari 2014 23:08 schreef Light het volgende:

[..]

Asserts hebben het nadeel dat ze uitgezet kunnen worden. Ik kan dus instellen dat ze bij mij niet afgaan, waardoor ik niet gewaarschuwd wordt voor ongeldige waardes. Om die reden vind ik asserts eigenlijk geen geschikte optie voor public API, en wel voor private en protected functies.
Dat is waar, maar ik maak asserts publiek, zodat als je ze wilt gebruiken het wel kan, en als je het niet doet, doe ik het alsnog voor je, alleen kan je vooraf al zien of een call zou gaan werken of niet. Het is een beetje defensief programeren.
In theory there is no difference between theory and practice. In practice there is.
pi_136970313
quote:
0s.gif Op vrijdag 21 februari 2014 10:53 schreef slacker_nl het volgende:

[..]

Dat is waar, maar ik maak asserts publiek, zodat als je ze wilt gebruiken het wel kan, en als je het niet doet, doe ik het alsnog voor je, alleen kan je vooraf al zien of een call zou gaan werken of niet. Het is een beetje defensief programeren.
Ik heb zelf dit in mijn code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<?php
namespace System\Core;

use \
System\Core\Container;
use 
System\Core\Traits\ArrayAccessor;
use 
System\Core\Traits\ArrayIterate;

/**
 * Class Base
 * @package System\Core
 */
class Base implements \ArrayAccess, \Iterator {

    use 
ArrayAccessorArrayIterate;

    
/**
     * @param callable $closure
     */
    
public function __construct(\Closure $closure null) {
        if(
is_callable($closure)) {
            return 
$closure($this);
        }
        return 
$this;
    }

    
/**
     * @param Container\Settings $settings
     */
    
public function setSettings(Container\Settings $settings null) {
        if(
is_object($settings)) {
            foreach(
$settings as $k => $v) {
                
$this->{$k} = $v;
            }
        }
    }

    
/**
     * @param Container\Settings $settings
     */
    
public function setDependencies(Container\Settings $settings null) {
        
$this->setSettings($settings);
    }

    
/**
     * @param $name
     * @param array $args
     * @return bool
     */
    
public function __call($name, Array $args = []) {
        
$type substr($name03);
        
$var strtolower(substr($name3));
        switch(
$type) {
            case 
'set':
                
$this->$var $args[0];
            break;
            case 
'get':
                return isset(
$this->$var)?$this->var:false;
            break;
        }
    }
}

Elke class die dus base extend, heeft toegang tot automagische get en set calls.
Nu heb ik geen foutafhandeling er nog inzitten, meer omdat er niet echt wat fout kan gaan :P
pi_136975571
quote:
0s.gif Op vrijdag 21 februari 2014 10:50 schreef slacker_nl het volgende:

[..]

Je frontend code moet dat goed afvangen, je backend code moet doodgaan op het moment dat de input incorrect is. Ipv Exceptions zou je ook nog trigger_error kunnen gebruiken.
Ik heb ook code gezien die gebruikt werd om te bepalen of iets wel of niet geldig is en die een exceptie gooide in het geval de input niet geldig was. Als de input wel geldig was, werd gewoon netjes true teruggegeven.

Afhankelijk van de situatie kan het valide zijn om inputcontrole bij een setter te plaatsen, en dan een exceptie te gooien als de input niet geldig is. Je kunt er ook voor kiezen dat niet te doen en in de class een method validate() oid te implementeren die dan gewoon true of false teruggeeft afhankelijk van de waardes van de verschillende velden. En daar zijn ook combinaties van mogelijk.
pi_136976535
quote:
0s.gif Op vrijdag 21 februari 2014 15:06 schreef Light het volgende:

[..]

Ik heb ook code gezien die gebruikt werd om te bepalen of iets wel of niet geldig is en die een exceptie gooide in het geval de input niet geldig was. Als de input wel geldig was, werd gewoon netjes true teruggegeven.

Afhankelijk van de situatie kan het valide zijn om inputcontrole bij een setter te plaatsen, en dan een exceptie te gooien als de input niet geldig is. Je kunt er ook voor kiezen dat niet te doen en in de class een method validate() oid te implementeren die dan gewoon true of false teruggeeft afhankelijk van de waardes van de verschillende velden. En daar zijn ook combinaties van mogelijk.
Ja bij sommige frameworks zie je inderdaad een InvalidInputException o.i.d.

Wat ik zelf doe is de validatie op de validate() manier
Dit is bijvoorbeeld mijn logincontroller
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?php
namespace Controller;

use 
Model\User;
use 
System\Core\Controller;
use 
System\Core\Form\Element;
use 
System\Core\Form\Input;
use 
System\Helpers\Html;

/**
 * Class Login
 * @package Controller
 */
class Login extends Controller {
    public function 
index() {
        
$this->form->addElement(new Element\Fieldset([
            
'elements' => [
                new 
Input\Text([
                    
'name' => 'username',
                    
'required' => true,
                    
'baseValue' => 'Username',
                    
'validator' => ['Length' => ['min' => 3]]
                ]),
                new 
Input\Password([
                    
'name' => 'password',
                    
'baseValue' => 'Password',
                    
'validator' => ['Length' => ['min' => 5]]
                ]),
                new 
Element\Submit([
                    
'name' => 'login',
                    
'value' => 'Login'
                
])
            ]
        ]));
        if(
$this->request->isPost()) {
            if(
$this->form->validate()) {
                
$user User::find_by_username($this->request->post('username'));
                if(isset(
$user->id)) {
                    if(
password_verify($this->request->post('password'),$user->password)) {
                        
$_SESSION['user'] = ['id' => $user->id];
                        
$user->login_attempts 0;
                        
$this->url->redirect($this->url->createUrl());
                    } else {
                        
$user->login_attempts += 1;
                    }
                    
$user->save();
                }
            }
        }
        
$this->template->load('login', ['form' => $this->form]);
        echo 
$this->template;
    }

Form class:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
<?php
namespace System\Core;

/**
 * Class Form
 * @package System\Core
 */
class Form extends Base {
    private 
$elements = array();

    public 
$method 'post';

    public 
$name '';

    public 
$valid true;

    public 
$enctype 'application/x-www-form-urlencoded';

    
/**
     * @param $element
     */
    
public function addElement($element) {
        
$this->elements[$element->name] = $element;
    }

    public function 
show() {
        foreach(
$this->elements as $e) {
            echo 
$e;
        }
    }

    
/**
     * @return bool
     */
    
public function validate() {
        foreach(
$this->elements as $e) {
            if(
false === $e->validate()){
                
$this->valid false;
            }
        }
        return 
$this->valid;
    }

    
/**
     * @return array
     */
    
public function __sleep() {
        return 
$this->elements;
    }

    
/**
     * @return string
     */
    
public function __toString() {
        
$output '<form method="' $this->method '" name="' $this->name '" enctype="'.$this->enctype.'">';
        foreach(
$this->elements as $e) {
            
$output .= $e;
        }
        
$output .= '</form>';
        return 
$output;
    }
}

Input class:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
<?php
namespace System\Core\Form;

use \
System\Core;

use \
System\Core\Form\Validator;

/**
 * Class Input
 * @package System\Core\Form
 */
class Input extends Element {
    public 
$required false;
    public 
$baseValue '';
    public 
$checked false;
    public 
$validator;
    public 
$description;
    public 
$options = array();
    public 
$value '';
    public 
$min;
    public 
$max;
    public 
$step;
    public 
$validMessage '';
    public 
$valid;
    protected 
$settings;

    use 
Core\Traits\getObjVars;

    
/**
     * @param array $data
     */
    
public function __construct(array $data) {
        foreach(
$data as $k => $v) {
          
$this->$k $v;
        }

        if(
$this->request->isPost()) {
            if(
false !== $this->request->post($this->name)) {
                
$this->value $this->request->post($this->name);
            }
        }
    }

    
/**
     * @return string
     */
    
public function getClass() {
        return isset(
$this->class)?' class="'.$this->class.'"':'';
    }

    
/**
     * @return string
     */
    
public function getRequired() {
        return 
false === $this->required?'':' required aria-required="true"';
    }

    
/**
     * @return string
     */
    
public function getMinMaxStep() {
        return 
' min="'.$this->min.'" max="'.$this->max.'" step="'.$this->step.'" ';
    }

    
/**
     * @return string
     */
    
public function getValue() {
        return 
' value="'.$this->value.'"';
    }

    
/**
     * @return string
     */
    
public function getLabel() {
        return isset(
$this->label)?'<label for="'.$this->name.'">'.$this->label.'</label>':'';
    }

    
/**
     * @return string
     */
    
public function getDescribed() {
        return isset(
$this->description)?'aria-describedby="'.$this->name.'-format"':'';
    }

    
/**
     * @return string
     */
    
public function getDescription() {
        return isset(
$this->description)?'<span id="'.$this->name.'-format" class="help">'.$this->description.'</span>':'';
    }

    
/**
     * @param $value
     */
    
public function setValue($value) {
        
$this->value $value;
    }
}
pi_136993866
quote:
0s.gif Op vrijdag 21 februari 2014 15:27 schreef totalvamp het volgende:

[..]

Ja bij sommige frameworks zie je inderdaad een InvalidInputException o.i.d.

Wat ik zelf doe is de validatie op de validate() manier
Dit is bijvoorbeeld mijn logincontroller
[ code verwijderd ]

Form class:
[ code verwijderd ]

Input class:
[ code verwijderd ]

Ik zou in die Form class geen field $valid maken maar het resultaat gewoon binnen de functie houden. Verder kun je die validate() functie nog wat optimaliseren door te stoppen met valideren zodra je een element gevonden hebt dat niet valid is (maar dat kan uiteraard niet als validate() meer doet dan alleen valideren).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
    
/**
     * @return bool
     */
    
public function validate() {
        
$valid true;
        foreach(
$this->elements as $e) {
            if(
false === $e->validate()){
                
$valid false;
                break;
            }
        }
        return 
$valid;
    }
?>
pi_136996046
quote:
_O- _O- _O_
pi_137000915
quote:
0s.gif Op vrijdag 21 februari 2014 21:54 schreef Light het volgende:

[..]

Ik zou in die Form class geen field $valid maken maar het resultaat gewoon binnen de functie houden. Verder kun je die validate() functie nog wat optimaliseren door te stoppen met valideren zodra je een element gevonden hebt dat niet valid is (maar dat kan uiteraard niet als validate() meer doet dan alleen valideren).
[ code verwijderd ]

Dit is meer voor eventueel een extra optie zodat je later in de code ook kan kijken of je form geldig was.
Dit werkt niet lekker, aangezien je niet meerdere elementen een error mee kan geven dan.

Ik heb ook niet alle code laten zien aangezien alles op elkaar aansluit.

Het is een behoorlijk class heavy form class.

Als je hem volledig wilt zien (nog niet af)
http://sourceforge.net/p/totalfw/code/ci/master/tree/

[ Bericht 4% gewijzigd door #ANONIEM op 22-02-2014 00:24:25 ]
  zaterdag 22 februari 2014 @ 17:08:27 #101
187069 slacker_nl
Sicko pur sang
pi_137019271
quote:
0s.gif Op vrijdag 21 februari 2014 15:06 schreef Light het volgende:

[..]

Ik heb ook code gezien die gebruikt werd om te bepalen of iets wel of niet geldig is en die een exceptie gooide in het geval de input niet geldig was. Als de input wel geldig was, werd gewoon netjes true teruggegeven.

Afhankelijk van de situatie kan het valide zijn om inputcontrole bij een setter te plaatsen, en dan een exceptie te gooien als de input niet geldig is. Je kunt er ook voor kiezen dat niet te doen en in de class een method validate() oid te implementeren die dan gewoon true of false teruggeeft afhankelijk van de waardes van de verschillende velden. En daar zijn ook combinaties van mogelijk.
In Perl, mijn dagelijkse brood, heb je Moose en verschillende parameter check modules, Params::Check, Params::Validate en Data::FormValidator. Bij Moose kan je gewoon zeggen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package My::Fok;

use Moose;

has 'fok' => (
  is => 'rw',
  isa => 'Int', # Str, ArrayRef, etc etc 'Class::Name' 
  required => 0,
  default => sub { return 1},
);

1;

## Elders in je code base
use My::Fok;
my $fok = My::Fok->new(fok => 100);

En dan kan het alleen van dat type zijn.

Params::Check en consorten kan je gebruiken voor functies. Dat maakt een heel hoop code, die bij sommige hier zo verweven zit in je code overbodig.

Dan krijg je zulke dingen:

1
2
3
4
5
6
sub my_func {
    my $args = check({foo => { required => 1, isa => "My::Fok" }}, {@_});
}

my $fok = My::Fok->new(fok => 100);
my_func(foo => $fok);

Als je iets anders erin stopt gaat de validator mekkeren en ga je dood of niet. En dat is zo handig! Zo kan je heel fine grained bepalen of input voldoet aan de eisen die je stelt en anders: b0rk.
In theory there is no difference between theory and practice. In practice there is.
pi_137092426
quote:
0s.gif Op zaterdag 22 februari 2014 17:08 schreef slacker_nl het volgende:

[..]

In Perl, mijn dagelijkse brood, heb je Moose en verschillende parameter check modules,
Werk je toevallig bij Booking.com dat je nog in Perl werkt ;) ?
🕰️₿🕰️₿🕰️₿🕰️₿🕰️₿🕰️ TikTok next Block
  maandag 24 februari 2014 @ 16:14:45 #103
187069 slacker_nl
Sicko pur sang
pi_137093995
quote:
0s.gif Op maandag 24 februari 2014 15:30 schreef raptorix het volgende:

[..]

Werk je toevallig bij Booking.com dat je nog in Perl werkt ;) ?
Nope.
In theory there is no difference between theory and practice. In practice there is.
pi_137210185
Hoe werken functions in PHP? Ik gebruik een los PHP bestand om data in een database te manipuleren maar ik kan daarbij geen gebruik maken van functions. Bijvoorbeeld onderstaande code werkt niet, maar als ik dezelfde mysqli_query buiten de function zet werkt het prima. Werkt een php functie alleen als er een echo of return in zit?

test();

function test(){
mysqli_query(blalba);
}
  Moderator / Redactie Sport / Devops donderdag 27 februari 2014 @ 19:34:57 #105
176766 zoem
zoemt
pi_137210501
De functies zullen eerst gedeclareerd moeten worden alvorens ze aangeroepen kunnen worden. In je voorbeeld moet de call naar test() dus onder de include staan. Dat is hoe php werkt.

[ Bericht 3% gewijzigd door zoem op 27-02-2014 21:33:12 ]
pi_137217114
quote:
0s.gif Op donderdag 27 februari 2014 19:34 schreef zoem het volgende:
De functies zullen eerst gedeclareerd moeten worden alvorens ze aangeroepen kunnen worden. In je voorbeeld moet de call naar test() er dus onder staan. Dat is hoe php werkt.
Nee, dat is niet hoe php werkt. Je kunt prima een functie aanroepen en daarna declareren. Je kunt ook twee functies maken die elkaar aanroepen zonder dat je daar spannende extra dingen voor hoeft te doen.
pi_137217353
quote:
0s.gif Op donderdag 27 februari 2014 19:28 schreef terdege het volgende:
Hoe werken functions in PHP? Ik gebruik een los PHP bestand om data in een database te manipuleren maar ik kan daarbij geen gebruik maken van functions. Bijvoorbeeld onderstaande code werkt niet, maar als ik dezelfde mysqli_query buiten de function zet werkt het prima. Werkt een php functie alleen als er een echo of return in zit?

test();

function test(){
mysqli_query(blalba);
}
Dat zou gewoon moeten werken. Maar het is wat lastig om je te helpen zolang niet duidelijk is wat er gebeurt als je de code in functies hebt staan.

Tip: plaats php code tussen [php] en [/php] voor leuke kleurtjes en regelnummers enzo.
  Moderator / Redactie Sport / Devops donderdag 27 februari 2014 @ 21:34:42 #108
176766 zoem
zoemt
pi_137217441
quote:
0s.gif Op donderdag 27 februari 2014 21:29 schreef Light het volgende:

[..]

Nee, dat is niet hoe php werkt. Je kunt prima een functie aanroepen en daarna declareren. Je kunt ook twee functies maken die elkaar aanroepen zonder dat je daar spannende extra dingen voor hoeft te doen.
Dat werkt alleen als het binnen hetzelfde bestand staat. Hij heeft een losse file met functies die waarschijnlijk later pas geinclude wordt. En dan gaat je verhaal niet op. Heb even m'n reactie aangepast zodat het duidelijker is.
pi_137217888
quote:
0s.gif Op donderdag 27 februari 2014 21:34 schreef zoem het volgende:

[..]

Dat werkt alleen als het binnen hetzelfde bestand staat. Hij heeft een losse file met functies die waarschijnlijk later pas geinclude wordt. En dan gaat je verhaal niet op. Heb even m'n reactie aangepast zodat het duidelijker is.
Ja ok :) Je moet een file eerst includen voordat je de code daarin kunt aanspreken.
pi_137218347
quote:
0s.gif Op donderdag 27 februari 2014 21:42 schreef Light het volgende:

[..]

Ja ok :) Je moet een file eerst includen voordat je de code daarin kunt aanspreken.
Wat een stom principe zeg
In theory there is no difference between theory and practice. In practice there is.
pi_137218689
quote:
10s.gif Op donderdag 27 februari 2014 21:50 schreef slacker_nl het volgende:
Wat een stom principe zeg
Autoloaders _O_

[ Bericht 7% gewijzigd door #ANONIEM op 27-02-2014 21:57:47 ]
pi_137218961
quote:
Die werken voor classes, niet voor bestanden met losse functies.
pi_137219162
quote:
0s.gif Op donderdag 27 februari 2014 22:00 schreef Light het volgende:

[..]

Die werken voor classes, niet voor bestanden met losse functies.
Welke dinosaurus werkt er dan ook nog zonder classes :')

[ Bericht 7% gewijzigd door #ANONIEM op 27-02-2014 22:05:12 ]
pi_137220197
quote:
1s.gif Op donderdag 27 februari 2014 22:04 schreef CrashO het volgende:

[..]

Welke dinosaurus werkt er dan ook nog zonder classes :')
Terdege misschien?
pi_137220426
Dan zijn wij hier om hem te vertellen. Get to class(es) :+

[ Bericht 0% gewijzigd door #ANONIEM op 27-02-2014 22:26:11 ]
pi_137221390
quote:
1s.gif Op donderdag 27 februari 2014 22:04 schreef CrashO het volgende:

[..]

Welke dinosaurus werkt er dan ook nog zonder classes :')
niet alles hoeft OO te zijn he
In theory there is no difference between theory and practice. In practice there is.
  vrijdag 28 februari 2014 @ 09:15:38 #117
25889 Sitethief
Fulltime Flapdrol
pi_137229471
quote:
1s.gif Op donderdag 27 februari 2014 22:04 schreef CrashO het volgende:

[..]

Welke dinosaurus werkt er dan ook nog zonder classes :')
Niet alle functies wil je in een class hebben.
Stroek: Sitethief, die is heel groot en sterk :Y.
Faat: *zucht* zoals gewoonlijk hoor Sitethief weer in de bocht &gt;:)
pi_137232663
quote:
0s.gif Op vrijdag 28 februari 2014 09:15 schreef Sitethief het volgende:

[..]

Niet alle functies wil je in een class hebben.
Behalve de autoload functie, over wat voor functies heb jij het?
  vrijdag 28 februari 2014 @ 11:38:17 #119
187069 slacker_nl
Sicko pur sang
pi_137233006
quote:
1s.gif Op vrijdag 28 februari 2014 11:26 schreef totalvamp het volgende:

[..]

Behalve de autoload functie, over wat voor functies heb jij het?
Een bunch aan helper functies? Waarom zou je dat in een class willen frotten?
In theory there is no difference between theory and practice. In practice there is.
pi_137233499
quote:
0s.gif Op vrijdag 28 februari 2014 11:38 schreef slacker_nl het volgende:

[..]

Een bunch aan helper functies? Waarom zou je dat in een class willen frotten?
Zodat je alle die functies op 1 centrale overzichtelijke plek hebt.
Daarnaast heb je verschillende soorten helpers, miss wil je het wel opdelen.

Html helpers
Url helpers
Helper helpers
Parse helpers

Met classes blijf je overzichtelijk en is het duidelijk waar een functie vandaan komt.

En je kunt functienamen normaal houden, zodat je niet met dezelfde functienamen eindigt voor verschillende dingen.
  vrijdag 28 februari 2014 @ 12:31:50 #121
187069 slacker_nl
Sicko pur sang
pi_137234346
quote:
1s.gif Op vrijdag 28 februari 2014 11:54 schreef totalvamp het volgende:

[..]

Zodat je alle die functies op 1 centrale overzichtelijke plek hebt.
Daarnaast heb je verschillende soorten helpers, miss wil je het wel opdelen.

Html helpers
Url helpers
Helper helpers
Parse helpers

Met classes blijf je overzichtelijk en is het duidelijk waar een functie vandaan komt.

En je kunt functienamen normaal houden, zodat je niet met dezelfde functienamen eindigt voor verschillende dingen.
En dan moet je... wat doen precies?

1
2
3
4
include_once("Utils.php");

my $helper = new Helper;
$helper->parse_url();

of..

1
2
3
include_once("Utils.php");

parse_url();

Ik mis je punt. Of word alles een static functie?

Er is een plek voor OO en er is een plek voor non-OO en die werelden kun je best mixen. Wij doen redelijk aan OO, maar we hebben ook zeker non-OO componenten, dat zijn Util functies, het fijne is wel dat we precies kunnen zeggen wat we willen gebruiken uit een module.

[ Bericht 8% gewijzigd door slacker_nl op 28-02-2014 12:37:28 ]
In theory there is no difference between theory and practice. In practice there is.
pi_137236071
quote:
0s.gif Op vrijdag 28 februari 2014 12:31 schreef slacker_nl het volgende:
Ik mis je punt. Of word alles een static functie?
De include kan je weglaten bij de OO versie want die kan je met autoload laten afhandelen.
Dan is het dus precies evenlang als de niet OO versie. En imo een stuk onderhoudbaarder want je kunt helpers specifiek inrichten op een taak en alles netjes bij elkaar gouden, in dit geval een url helper.

En die dan niet static maken, maar wel inladen via bijv een (static) loader. Waarbij Loader bijhoudt of er al een instantie draait en die dan teruggeven, of een nieuwe aanmaken.

Dan krijg je iets als:
1
2
$uh = Loader::helper('url');
$uh->parse_url();


[ Bericht 14% gewijzigd door #ANONIEM op 28-02-2014 13:27:47 ]
pi_137238039
1
2
3
4
<?php
$url 
= new Url('http://www.fok.nl');
echo 
$url->getHost();
?>

+ psr-0 autoloader en de rest gaat automatisch. geen includes, geen loader class. eleganter kan niet denk ik :P
..///
pi_137239794
quote:
0s.gif Op vrijdag 28 februari 2014 14:23 schreef wipes66 het volgende:

[ code verwijderd ]

+ psr-0 autoloader en de rest gaat automatisch. geen includes, geen loader class. eleganter kan niet denk ik :P
_O_
pi_137239964
quote:
0s.gif Op vrijdag 28 februari 2014 14:23 schreef wipes66 het volgende:

[ code verwijderd ]

+ psr-0 autoloader en de rest gaat automatisch. geen includes, geen loader class. eleganter kan niet denk ik :P
Zo doe ik het ook ^^
  vrijdag 28 februari 2014 @ 18:22:19 #126
187069 slacker_nl
Sicko pur sang
pi_137245644
quote:
0s.gif Op vrijdag 28 februari 2014 14:23 schreef wipes66 het volgende:

[ code verwijderd ]

+ psr-0 autoloader en de rest gaat automatisch. geen includes, geen loader class. eleganter kan niet denk ik :P
Huiverig wordt ik ervan, automatisch files laden, expliciet aangeven welke klasse je wilt gebruiken in je module.

Hoe werkt autoloader eigenlijk, als ik t/inc/Net/LDAP.php heb en een lib/Net/LDAP.php, kan ik dan zeggen dat t/inc gebruikt moet worden of dat lib gebruikt moet worden?
In theory there is no difference between theory and practice. In practice there is.
  Moderator / Redactie Sport / Devops vrijdag 28 februari 2014 @ 18:36:00 #127
176766 zoem
zoemt
pi_137245943
quote:
0s.gif Op vrijdag 28 februari 2014 18:22 schreef slacker_nl het volgende:

[..]

Huiverig wordt ik ervan, automatisch files laden, expliciet aangeven welke klasse je wilt gebruiken in je module.

Hoe werkt autoloader eigenlijk, als ik t/inc/Net/LDAP.php heb en een lib/Net/LDAP.php, kan ik dan zeggen dat t/inc gebruikt moet worden of dat lib gebruikt moet worden?
Ja, want de classloaders kunnen het pad achterhalen dmv de classname of namespace. Vroeger zag je vaak de "Vendor_My_Awesome_Class" constructie, waarbij underscores door slashes werden vervangen in de autoloader. Moderne frameworks gebruiken nu namespaces, waarbij de namespace separator wordt gebruikt voor het resolven van het pad. Een vereiste is dus dat er een toplevel namespace moet zijn.

Zie verder https://github.com/php-fi(...)er/accepted/PSR-0.md
pi_137246605
@ OO discussie. Ik weet hoe ik OO moet programmeren maar ik heb geen ervaring met PHP. Ik heb vervolgens geleerd om aparte PHP bestanden te maken voor verschillende taken die dan aan te roepen met behulp van JSON. Bijvoorbeeld: als iemand op een rode knop drukt wordt rodeknop.php uitgevoerd. Dit is dus geen goede manier om PHP te gebruiken?

quote:
0s.gif Op donderdag 27 februari 2014 21:33 schreef Light het volgende:

[..]

Dat zou gewoon moeten werken. Maar het is wat lastig om je te helpen zolang niet duidelijk is wat er gebeurt als je de code in functies hebt staan.

Tip: plaats php code tussen
[ code verwijderd ]

voor leuke kleurtjes en regelnummers enzo.
Vanuit HTML wordt een PHP bestand met deze code aangeroepen als iemand ergens op klikt. Het is vrij simpel. Alles werkt gewoon zoals het hoort, alleen de functies worden niet uitgevoerd.

1
2
3
4
5
6
7
8
9
<?php
    
include 'dbconnect.php';
    
test();

    function 
test(){
        
mysqli_query($link'UPDATE tablename SET Rowname=5');
    }
    
mysqli_close($link);
?>
pi_137246907
quote:
0s.gif Op vrijdag 28 februari 2014 18:59 schreef terdege het volgende:
Alles werkt gewoon zoals het hoort, alleen de functies worden niet uitgevoerd.
$link binnen je functie `test` gaat niet werken. Die zit in een andere scope. Als je hem daar wilt gebruiken zal je hem moeten meegeven. (of OO gaan en een property binnen je class aanspreken O-) )
SPOILER
Om spoilers te kunnen lezen moet je zijn ingelogd. Je moet je daarvoor eerst gratis Registreren. Ook kun je spoilers niet lezen als je een ban hebt.


[ Bericht 16% gewijzigd door #ANONIEM op 28-02-2014 19:09:51 ]
pi_137246962
quote:
0s.gif Op vrijdag 28 februari 2014 18:59 schreef terdege het volgende:
@ OO discussie. Ik weet hoe ik OO moet programmeren maar ik heb geen ervaring met PHP. Ik heb vervolgens geleerd om aparte PHP bestanden te maken voor verschillende taken die dan aan te roepen met behulp van JSON. Bijvoorbeeld: als iemand op een rode knop drukt wordt rodeknop.php uitgevoerd. Dit is dus geen goede manier om PHP te gebruiken?

[..]

Vanuit HTML wordt een PHP bestand met deze code aangeroepen als iemand ergens op klikt. Het is vrij simpel. Alles werkt gewoon zoals het hoort, alleen de functies worden niet uitgevoerd.
[ code verwijderd ]

Wat je doet heeft niets met OO te maken, maar dat wil niet zeggen dat het 'geen goede manier'is. Als je OO wilt programmeren zul je toch echt classes, namespaces, methods enz. moeten gaan gebruiken.

Je functie in dat voorbeeld zal waarschijnlijk een foutmelding geven dat $link niet gedefinieerd is maar ik zie niet waarom hij niet uitgevoerd zou worden.
  Moderator / Redactie Sport / Devops vrijdag 28 februari 2014 @ 19:12:06 #131
176766 zoem
zoemt
pi_137247023
Daarom ook altijd error reporting aanzetten :)
pi_137247758
OOP vind ik vreselijk werken in PHP. Het is niet lekker om MVC te programmeren zonder dat je die frameworks gebruikt.
pi_137248349
Waarom wordt er voor require_once/require/include haakjes gebruikt met daarin het bestand, terwijl het ook zonder haakjes kan?
pi_137248384
quote:
9s.gif Op vrijdag 28 februari 2014 19:29 schreef robin007bond het volgende:
OOP vind ik vreselijk werken in PHP. Het is niet lekker om MVC te programmeren zonder dat je die frameworks gebruikt.
PHP was in beginsel ook niet voor OOP gemaakt. Als je graag OOP wilt doen, dan zou ik m'n licht opsteken bij C++/Java/C#.
pi_137248440
quote:
0s.gif Op vrijdag 28 februari 2014 19:42 schreef Robuustheid het volgende:
Waarom wordt er voor require_once/require/include haakjes gebruikt met daarin het bestand, terwijl het ook zonder haakjes kan?
Netheid? Dat je ook dit "kan" doen met echo's betekend ook niet dat je het moet.
1
2
3
<?php
echo "ik echo deze $waarde naar buiten op een nekshot waardige manier";
?>
Zoals zoveel dingen in php kan je het netjes doen en het ranzig doen.
Shorthand notaties zijn ook zoiets. :r
1
2
3
<?php
echo ($ditIsTrue) ? 'dit was dus waar' 'dit niet';
?>
En vanaf PHP5 kan je heel aardig OO werken en vanaf PHP 5.3/5.4 is het imo prima voor elkaar.

[ Bericht 12% gewijzigd door #ANONIEM op 28-02-2014 19:52:29 ]
  Moderator / Redactie Sport / Devops vrijdag 28 februari 2014 @ 19:53:16 #136
176766 zoem
zoemt
pi_137248775
Wat is er mis met de ternary operator? Daar zijn prima use cases voor, maar niet elk conditional statement leent zich ervoor.
pi_137249330
quote:
99s.gif Op vrijdag 28 februari 2014 19:45 schreef CrashO het volgende:

[..]

Netheid? Dat je ook dit "kan" doen met echo's betekend ook niet dat je het moet.
[ code verwijderd ]

Zoals zoveel dingen in php kan je het netjes doen en het ranzig doen.
Shorthand notaties zijn ook zoiets. :r
[ code verwijderd ]

En vanaf PHP5 kan je heel aardig OO werken en vanaf PHP 5.3/5.4 is het imo prima voor elkaar.
Haakjes gebruiken met include etc is iets van de vroegere PHP versies, tegenwoordig zou ik ze niet meer gebruiken.

Shorthand is juist onwijs handig en maak ik dankbaar gebruik van.

1
2
3
4
5
6
7
8
9
<?php
if($true) {
  return 
'ja';
} else {
  return 
'nee';
}

return 
$true?'ja':'nee';
?>
pi_137249815
quote:
0s.gif Op vrijdag 28 februari 2014 19:53 schreef zoem het volgende:
Wat is er mis met de ternary operator? Daar zijn prima use cases voor, maar niet elk conditional statement leent zich ervoor.
Ik denk dat CrashO doelde op de <?= shorthand.
Schuimpje... mijn liefste. Verlaat mij nimmer weer...
  Moderator / Redactie Sport / Devops vrijdag 28 februari 2014 @ 20:27:47 #139
176766 zoem
zoemt
pi_137249994
quote:
3s.gif Op vrijdag 28 februari 2014 20:21 schreef papernote het volgende:

[..]

Ik denk dat CrashO doelde op de <?= shorthand.
Ik zie geen short open tag staan in zijn reactie :?
pi_137250114
quote:
0s.gif Op vrijdag 28 februari 2014 20:27 schreef zoem het volgende:

[..]

Ik zie geen short open tag staan in zijn reactie :?
Dat fixte de php tag van Fok ongewild automagisch voor me :P, stond er wel.
Maar ik bedoel ook op beide de shorthand (shorthand echo en shorthand if/else (met tarnary operator).
Wilde eigenlijk zoiets neerzetten.
<?=($ditIsTrue) ? 'dit was dus waar' : 'dit niet'?>

[ Bericht 1% gewijzigd door #ANONIEM op 28-02-2014 20:32:00 ]
pi_137250833
Met PHP,

In plaats van <?php en ?>

Kun je ook slechts bij <?= houden.

Maar dan krijg ik vreemde dingen te zien.

Als ik zo doe:

1
2
3
4
<?=

require 'test.php';
echo 1;

Dan is de output 11.

Als ik vervolgens require weglaat, dan krijg ik een error met melding dat-ie de echo niet verwachtte. Hoe zit dit precies?
pi_137250993
quote:
0s.gif Op vrijdag 28 februari 2014 20:51 schreef Robuustheid het volgende:
Met PHP,
In plaats van <?php en ?>

Kun je ook slechts bij <?= houden.
Eh. Nee. Dat probeerden we hierboven ook allemaal uit te leggen :P
<?=$henk?> doet feitelijk hetzelfde als <?php echo $henk; ?>

Wat jij nodig hebt is <? (shorttags) . Dit doet hetzelfde als <?php
(maar het is netter omdat overal altijd gewoon <?php te gebruiken omdat shorttags in de config aan moeten staan om ze te kunnen gebruiken. En <?php gewoon overal werkt.

Wat bij jou nu gebeurt is dat <?=require 'test.php'; de response van de require echo't (dat is true wanneer het includen lukt, dus 1). en daarna de echo '1'. Dus dan krijg je 11. Als je de require weglaat doe je eigenlijk echo echo '1'; en staat er dus een echo teveel waarop hij dood gaat :P

[ Bericht 8% gewijzigd door #ANONIEM op 28-02-2014 20:58:04 ]
pi_137251612
Zeer verhelderende uitleg, thanks CrashO!
pi_137255485
quote:
0s.gif Op vrijdag 28 februari 2014 19:42 schreef Robuustheid het volgende:
Waarom wordt er voor require_once/require/include haakjes gebruikt met daarin het bestand, terwijl het ook zonder haakjes kan?
In PHP heb je bij language constructs als require/include/reuquire_once/include_once (en ook echo, en nog een aantal) geen haakjes nodig. Je mag ze wel gebruiken, dan ziet het er iets meer uit als een gewone functie-aanroep.
  Moderator / Redactie Sport / Devops zaterdag 1 maart 2014 @ 00:15:32 #145
176766 zoem
zoemt
pi_137260427
Op SO staat wel een leuke uitleg over language constructs, mocht iemand zin hebben om er meer over te lezen. Zie ook de list of keywords op php.net.
pi_137260670
quote:
1s.gif Op vrijdag 28 februari 2014 19:43 schreef Robuustheid het volgende:

[..]

PHP was in beginsel ook niet voor OOP gemaakt. Als je graag OOP wilt doen, dan zou ik m'n licht opsteken bij C++/Java/C#.

Die talen kan ik ook wel. Het probleem is dat het niet zo geschikt is voor web development. Je hebt wel JSP, maar dat schijnt niet zo lekker te werken. C# kan i.c.m. ASP.net, maar ik heb een gruwelijke hekel aan Microsoft dus dat gaat 'em niet worden. ;(

Misschien is Python i.c.m. Django dan nog het beste.
  zaterdag 1 maart 2014 @ 00:25:57 #147
12221 Tijn
Powered by MS Paint
pi_137260675
quote:
99s.gif Op vrijdag 28 februari 2014 20:31 schreef CrashO het volgende:

[..]

Dat fixte de php tag van Fok ongewild automagisch voor me :P, stond er wel.
Maar ik bedoel ook op beide de shorthand (shorthand echo en shorthand if/else (met tarnary operator).
Wilde eigenlijk zoiets neerzetten.
<?=($ditIsTrue) ? 'dit was dus waar' : 'dit niet'?>
In views/templates is deze syntax echt superhandig. Sowieso zou ik bij het toewijzen van een waarde aan een variabele op basis van een conditie altijd de ternary operator gebruiken, dan heb je maar 1x de variabele nodig die je wilt vullen.
pi_137263102
quote:
1s.gif Op zaterdag 1 maart 2014 00:25 schreef robin007bond het volgende:

[..]

Die talen kan ik ook wel. Het probleem is dat het niet zo geschikt is voor web development. Je hebt wel JSP, maar dat schijnt niet zo lekker te werken. C# kan i.c.m. ASP.net, maar ik heb een gruwelijke hekel aan Microsoft dus dat gaat 'em niet worden. ;(

Misschien is Python i.c.m. Django dan nog het beste.
Python was oorspronkelijk niet zo gericht op OO, omdat de bedenker ervan de OO niet zo relevant vond. Maar het leent zich ook beter voor dan PHP. Python is sowieso een betere taal dan PHP, er zitten geen rare syntax-gewoonten in. En PHP is sterk gefragmenteerd met al die frameworks zoals Symfony, Zend, CodeIgniter, etc. Dat kost je meer tijd om te leren dan de taal zelf. Met Python zit je meestal vast aan Django, dus dat scheelt je naar verhouding minder tijd.
pi_137263106
Trouwens, een vraag:
1
2
3
4
5
6
7
8
<script>
  document.write("test")
</script>
<?php 

echo 0; 

?> 

Output:
quote:
test 0
Waar komt die spatie vandaan? Die kan toch niet door Javascript geïmplementeerd zijn?
  zaterdag 1 maart 2014 @ 08:46:38 #150
187069 slacker_nl
Sicko pur sang
pi_137263953
quote:
0s.gif Op zaterdag 1 maart 2014 03:00 schreef Robuustheid het volgende:

[..]

Python was oorspronkelijk niet zo gericht op OO, omdat de bedenker ervan de OO niet zo relevant vond. Maar het leent zich ook beter voor dan PHP. Python is sowieso een betere taal dan PHP, er zitten geen rare syntax-gewoonten in. En PHP is sterk gefragmenteerd met al die frameworks zoals Symfony, Zend, CodeIgniter, etc. Dat kost je meer tijd om te leren dan de taal zelf. Met Python zit je meestal vast aan Django, dus dat scheelt je naar verhouding minder tijd.
Python was juist gemaakt voor OO.
In theory there is no difference between theory and practice. In practice there is.
abonnement Unibet Coolblue Bitvavo
Forum Opties
Forumhop:
Hop naar:
(afkorting, bv 'KLB')