collection d'objets

18 juil. 2008, 09:49

Et aussi parce que .Net c'est un peu chiant … Si tu veux faire du libre et bien bien puissant, tournes-toi vers C++ ou Objective C, tu vas te faire plaisir

.

Mais PHP c'est bien aussi, hein !

18 juil. 2008, 10:36

c'est different et on fait bien sur la meme chose >> asp.net pour le net

.net n'est pas chiant , et le C# est bien plus souple que C++ ou java

18 juil. 2008, 11:24

asp.net pour le net

asp est une blague. Si tu regardes bien les seuls sites qui plantent sont en asp. C'est un langage qui fait du code lourd donc inadapté à un site web. Le principe d'un site web c'est que la page doit être générée en quelques dixièmes de secondes, et le serveur doit être en mesure de supporter plusieurs dizaines de générations concourantes. Pour cela, tu es obligé d'opter pour une technologie légère, ce que sont le PHP ou le PERL, mais ce que n'est pas l'ASP.NET...
C'est pour cette raison que je dis que cela ne sert pas à la même chose. A la rigueur tu feras des applications web avec, des programmes qui ne nécessiteront pas forcément une performance critique, mais pas trop des sites web...

18 juil. 2008, 11:30

ASP...blablabla...

Mais PHP blabla...

Les vieilles rengaines...Mais de la a dire que ASP est une daube qui fait planter les sites...La c'est de la mauvaise foie

18 juil. 2008, 12:27

asp <> asp.net et asp.net est tres performant , le codage est genial pour un programmeur
bref meme geguerre que MAC <> PC , Nikon <> Canon
ca m'interresse pas
si je veux faire du php c'est uniquement car c'est du libre et rien d'autre sinon je me ferais pas chier avec ca

18 juil. 2008, 12:33

Uè t'as raison, et pis tout le monde sait que Mac c'est meilleur que PC, alors ça sert à rien de débattre

(et paf, les pieds dans le plat

) !

Plus sérieusement, la philosophie PHP est proche de Java dans sa partie objet, c'est très intéressant. Bienvenu dans le monde PHP

.

18 juil. 2008, 13:45

20 juil. 2008, 15:58

je trouve pas comment remplir ces objets

par exemple

Code : Tout sélectionner

class MenuItems
{
	public $sm;
	public $id_menu;
	public $menu;
}

$mi = array(new MenuItems());

while($row = mysql_fetch_array($result))
{
$mi[$sm] = $row['SM'];
$mi[$id_menu] = $row['id_menu'];
$mi[$menu] = $row['$menu'];
}

echo $mi[$sm][0];
exit;

ne marche pas , je devrais obtenir la valeur du premier $sm du tableau

comment je peux remplir ce tableau d'objets dans ma boucle ?
et comment dans ce cas precis je peux iterer et recuperer mon tableau de 3 valeurs ?
merci

20 juil. 2008, 16:54

Aïe, il y a des petites confusions.

Dans ton cas précis, un objet n'est pas utile. Un simple tableau à plusieurs dimensions seraient utiles. Si tu veux ajouter des manipulations particulières sur les données, alors un objet serait intéressant.

Voici ce que je te propose :

Première solution, on souhaite stocker uniquement les données. Les manipulations sont minimes et atomiques, pas besoin d'un objet, un tableau est amplement suffisant. Alors

/**
 * On définit quelques constantes pour se faciliter la vie.
 */
define('SM',   'sm');
define('ID',   'id_menu');
define('MENU', 'menu');

/**
 * Notre tableau principal.
 */
$array = array();

/**
 * On remplit notre tableau.
 */
while($row = mysql_fetch_assoc($result))
    $array[] = array(
        SM   => $row['SM'],
        ID   => $row['id_menu'],
        MENU => $row['menu']
    );

/**
 * On affiche le résultat.
 */
print_r($array);

Seconde solution : on va utiliser une collection d'objet. En fait, chaque sous-tableau du premier exemple va être un objet.
On commence donc par décrire notre objet :

class MenuItem {

    /**
     * Nos différentes données.
     *
     * @var MenuItem string|int
     */
    protected $sm   = null;
    protected $id   = 0;
    protected $menu = null;



    /**
     * Pendant la construction de l'objet, soit on reçoit un
     * tableau et on appelle les setters, soit on appellera les setters
     * nous-même plus tard (comme ils sont publiques, pas de problème).
     *
     * @access  public
     * @param   array  $array    Notre tableau d'initialisation.
     * @return  void
     */
    public function __construct ( Array $array = array() ) {

        if(empty($array))
            return;

        if(isset($array['SM']))
            $this->setSM($array['SM']);

        // etc.
    }

    /**
     * On définit SM.
     *
     * @access  public
     * @param   string  $sm    SM (d'ailleurs, ça veut dire quoi ici ^^ ?).
     * @return   string
     */
    public function setSM ( $sm = null ) {

        $old      = $this->sm;
        $this->sm = $sm;

        return $old;
    }

    // etc.
}

On a alors deux façons d'utiliser cet objet :

/**
 * Notre collection.
 */
$collection = array();

while($row = mysql_fetch_assoc($result))
    $collection[] = new MenuItem(array(
                        'SM'      => $row['SM'],
                        'id_menu' => $row['id_menu'],
                        'menu'    => $row['menu']
                    ));

print_r($collection);

Ou alors :

/**
 * Notre collection.
 */
$collection = array();

/**
 * Une variable temporaire.
 */
$handle = null;

while($row = mysql_fetch_assoc($result)) {

    $handle = new MenuItem();
    $handle->setSM($row['SM']);
    $handle->setIDMenu($row['id_menu']);
    $handle->setMenu($row['menu']);

    // On ajoute notre objet à la collection.
    $collection[] = $handle;
}

print_r($collection);

Ce sont deux solutions, mais il en existe encore d'autre. L'objet standard StdClass est également très pratique. On peut définir n'importe quel attribut dessus, c'est entièrement dynamique.
Tout dépend de tes besoins

.

Pour parcourir la collection ou le tableau obtenu, une simple boucle foreach fera l'affaire

.

20 juil. 2008, 17:26

class MenuItems
{
   public $sm;
   public $id_menu;
   public $menu;
}

$mi = array();

while($row = mysql_fetch_object($result))
{
  $mi[] = (MenuItems)$row;
}

echo $mi[0]->sm;
exit;

20 juil. 2008, 17:45

Oui aussi, mais il faut que les noms des attributs correspondent exactement.

20 juil. 2008, 17:49

class MenuItems
{
   public $sm;
   public $id_menu;
   public $menu;
}

$mi = array();

$result = mysql_query("select sm, id_menu, menu from ....");

while($row = mysql_fetch_object($result))
{
  $mi[] = (MenuItems)$row;
}

foreach ($mi as $menuItem) {
    echo $menuItem->sm, $menuItem->id_menu, $menuItem->menu;
}
exit;

20 juil. 2008, 17:55

$menuItem*

(attention au dollars

)

20 juil. 2008, 22:53

je rentre juste et je vais toutes les tester demain

par contre je suis assez largué par ces variables qui poussent comme des champignons définies nulle part et surtout non typées
par exemple sadeq pour appeler la class ne se sert pas de new, ou bien comment dans son $mi[] = (MenuItems)$row; il trouve quoi correspond a quoi sans rien définir ?

est il possible de bien typer les variables ? un peu comme le fait HyWaN >>
protected $sm = null;
protected $id = 0;
protected $menu = null;

ou plus precis ?

protected string $sm = null;
protected integer $id = 0;
protected string $menu = null;

je comprend que tu dises HyWaN qu'une collection d'objet dans ce cas n'est pas nécessaire mais c'est un exemple simple juste pour saisir le fonctionnement , sinon sincèrement c'est ce qui m'a fait fuir php juste la : un code qui me semblait approximatif sur le pouce et non typé, un peu comme l'était asp 3 que je n'ai jamais aimé
avec php 5 les objets apparaissent et php 6 , 7 , ... iront vers ça

des structures ou class typees et les collection de ces structures avec methodes proprietes evenements sont un formidable outil et j'aimerais trouver en php ce qui s'en approche le plus (me manque la syntaxe propre au php) , .. il me semble que ta seconde solution en est tres proche, et je crois que c'est exactement ce que je cherchais

en tout cas merci beaucoup pour vos réponses et le temps passé , je prend un grand café demain matin et j'essaye de comprendre le fonctionnement de vos méthodes

en tout cas ca me plait beaucoup

20 juil. 2008, 23:29

Bien.

PHP est un langage a typage faible, voire très faible. Néanmoins, on peut faire un code très propre avec. Tu ne peux certes pas typer les variables comme entier, chaîne, etc. On peut uniquement faire un typage de tableau ou objet.

La solution de Sadeq est astucieuse, je n'y avais pas pensé (honte à moi quand même). Si tu fais attention, il utilise la fonction mysql_fetch_objet, c'est à dire que cette fonction va sortir un objet au lieu d'un tableau (obtenu avec mysql_fetch_assoc). Donc $row est un objet, et il le caste (transtype) vers ton objet. PHP va prendre les variables de l'objet contenu dans $row et les assigner à un nouvel objet MenuItems qu'il aura créer dynamiquement. Enfin, un cast quoi. J'imagine que ça te cause.

PHP est très populaire car très accessible. On arrive vite à un résultat « satisfaisant ». Ça force est également sa faiblesse. On peut faire un code complètement pourri comme un code très bien construit. Il suffit de savoir programmer ou pas … Si tu regardes Symfony ou Zend Framework, c'est un code très propre et très professionnel.

En même temps, Sékil l'a très bien dit : PHP est un langage qui répond à des contraintes particulières et pas des plus simples : le Web. Il faut que le script s'exécute très vite. PHP répond très bien à cette contrainte. Apparemment (à vérifier), une application 100% objet se pète la tronche sur des grosses montés en charge. PHP 5.3 et surtout PHP 6 tendent à devenir de plus en plus objet, c'est une très bonne chose.
Mais il faut qu'il reste toujours accessible, c'est sa force

.

collection d'objets

Qui est en ligne