Posts Tagged ‘programming’

Après avoir copié et déplacé le répertoire sous version de mon projet, un simple

git status

m’informait que TOUS les fichiers avaient été modifiés.

Pour revenir à un état stable (rien à commiter), il a fallu :

  1. Ajouter tous les fichiers au prochain commit
  2. Tout commiter, donc
  3. Utiliser le reset pour revenir à la version du serveur central, en annulant le dernier commit

La clef a été de tout commiter.

Publicités

Le contexte : une application PHP/MySQL, un champ BLOB dans l’application avec Symfony. Par défaut, nous avions laissé Propel pour faire nos tests.

Le souci d’un champ BLOB est sa contenance. Lorsque je veux lister tous mes enregistrements, si un des champs est BLOB, il est difficile de l’afficher directement dans le listing. Au niveau de la modélisation, j’ai donc intérêt à prévoir que ce champ sera ramené plus tard.
Symfony-Propel me propose une technique : préciser dans le YAML que ce champ sera rapporté à la demande.
commentaires_longs: {type: blob, lazyLoad: true}

Ensuite, lors de la récupération, j’ai tout intérêt à proposer un lien vers le contenu long (en saupoudrant éventuellement d’Ajax pour fournir à l’utilisateur une prévisualisation au survol). Il serait en effet trop coûteux de rapporter ce champ, en performance et en place sur la page web.
Au moment où je souhaite obtenir le commentaire, je pourrais faire :
$criteria->clearSelectColumns();
$criteria->addSelectColumn(ObjetPeer::COMMENTAIRES_LONG);
$rs =ObjetPeer::doSelectStmt($criteria);

Attention : actuellement, la méthode est doSelectStmt() et plus doSelectRS(), ne vous faites pas avoir.
Ensuite, vous récupérez un objet de la classe PDOStatement, il faut ensuite l’exploiter avec un fetch().

Au niveau de la conception de l’application, on peut imaginer mettre ces champs longs dans des tables séparées, puisqu’il sera rare qu’on les reprenne en même temps que les autres.

Le résultat est toujours retourné tronqué de ses décimales.
Sub FormaterCorrectement()
rem question : Comment formater

Const EURO As Double = 6.55957
Dim mesFrancs As Double
Dim Resultat As Double

mesFrancs = InputBox("Saisissez la somme en francs")
Resultat = CDbl(Format(mesFrancs / EURO, "##.00"))
' Je convertis en Double le formatage à deux décimales du résultat
' sinon le résultat avant l'affichage est casté et la partie décimale tombe

MsgBox(Resultat, 64 , "Résultat de la conversion")

End Sub

On retrouve souvent le mot expression dans la documentation. Notamment avec le fait que print peut faire partie d’une expression, n’étant pas une fonction mais une structure de langage, alors qu’echo ne le peut pas.

La page de PHP.net dédiée aux expressions est assez claire :

En PHP, presque tout ce que vous écrivez est une expression. La manière la plus simple de définir une expression est : « tout ce qui a une valeur ».

PHP est un langage orienté expression, dans le sens où presque tout est une expression.

De façon étonnante en PHP, on peut accéder à une propriété privée de la classe mère, depuis la classe fille, en utilisant une méthode non-redéfinie dans la classe fille. Cela reste dans la logique de PHP, puisque la méthode utilisée est celle de la classe mère

</pre><br />
<pre>class Gateau{<br />
        private $nbParts = 6;</p>
<p>    public function vendre($nbParts, $destinataire)<br />
    {<br />
        echo 'Je vends '.$nbParts. ' parts de gâteau à '.$destinataire;<br />
    }</p>
<p>    public function getParts()<br />
    {<br />
        echo ' Mon objet '.__CLASS__.' a '.$this->nbParts. ' parts.';<br />
    }<br />
}</p>
<p>class Tarte extends Gateau{<br />
    private $nbParts = 8;</p>
<p>    public function vendre($nbParts)<br />
    {<br />
    //Je définis une méthode de la classe fille, dont le prototype m'indique<br />
    // que j'ai  plus d'arguments que la mm méthode de la classe mère</p>
<p>    echo 'Je vends '.$nbParts. ' parts de gâteau';<br />
    }<br />
}</p>
<p>$pie = new Tarte;<br />
$pie->vendre(5);<br />
$pie->getParts();// j'accède à la méthode parente, donc au nb de parts de la classe parente</p>
<p>

Pour les requêtes préparées, avec PDO, on peut mettre en place, lors du binding des arguments, un filtrage sur le type attendu.

La documentation donne des exemples pour les méthodes

/* Exécution d'une requête préparée en liant des variables PHP */
$calories = 150;
$couleur = 'rouge';
$sth = $dbh->prepare('SELECT nom, couleur, calories
    FROM fruit
    WHERE calories bindParam(':calories', $calories, PDO::PARAM_INT);
$sth->bindParam(':couleur', $couleur, PDO::PARAM_STR, 12);
$sth->execute();

Que se passe-t-il lorsque j’envoie un mauvais type ?

PDO s’occupe de caster les variables pour qu’elles correspondent au type attendu.
avec PARAM_INT, si on propose une chaîne, elle devient la valeur 0
avec PARAM_STR, 15 (longueur max de chaîne), la chaîne est tronquée à 15 caractères.

En PHP5, avec l’amélioration de la POO, on a la possibilité de mettre en place des constantes de classe.

Ces constantes permettent d’enregistrer une valeur qu’on réutilise et qui n’est pas modifiée. Ces constantes ne sont accessibles que de manière statique, depuis la classe, et non pas depuis une instance de la classe.


classe Tarte{

const NB_PARTS = 8;

}

//pour y accéder, je dois le faire en statique

echo Tarte::NB_PARTS;

PHP propose un modèle d’héritage strict, qui veut que les méthodes re-déclarées dans la classe fille prennent au minimum le même nombre d’argument que la méthode de la classe mère.

class Gateau{
private $nbParts = 6;
public function vendre($nbParts, $destinataire)
{
echo ‘Je vends ‘.$nbParts. ‘ parts de gâteau à ‘.$destinataire;
}

public function getParts()
{
echo ‘ Mon objet ‘.__CLASS__.’ a ‘.$this->nbParts. ‘ parts.’;
}
}

class Tarte extends Gateau{
private $nbParts = 8;
public function vendre($nbParts)
{
//Je définis une méthode de la classe fille, dont le prototype m’indique
// que j’ai plus d’arguments que la mm méthode de la classe mère
echo ‘Je vends ‘.$nbParts. ‘ parts de gâteau’;
}
}
Mais en réalité, PHP me laisse (toujours la souplesse du langage) définir une méthode fille, dont la signature est différente de la méthode de la classe mère qu’elle redéfinit.La réponse est donc : oui.