Reprise du message précédent :

alert(console);

IE7  
 
enfin celà dit tenter d'utiliser une variable non défini sans la tester avant, ça me parait un peu bourrin

C'est du debug là
C'est justement le test qui fait tout sauter.
 
Enfin qui *faisait*, avec window.console ça marche...

bon zou, je teste code igniter sur mon mini projet qui commence à devenir bordelique

ok effectivement
 
je crois que j'avais eu pas mal de déboire aussi avec IE pour tester l'existance d'une variable, me souviens plus comment ça s'était finit cette histoire, probablement mal comme souvent avec IE

Je pense qu'il s'emmêle les pinceaux avec le scope...

Vous savez que IE 8 affiche des miniatures lissées ?    
 
par exemple si j'ai une image de 500*500px et que je l'affiche via <img src="" alt="" width="200" height="200" /> ben le résultat est parfait, comme si avait resizé l'image...  alors que sous FF c'est tout pixélisé
 
edit: Chrome aussi lisse les images  

Les flasheux de chez nous ont fait (enfin, "presque fini" ) un truc propre, modulaire, configurable, machin truc

Bilan : ~250 hits au chargement

edit : yen a même un qui me suggérait d'enregistrer mes réponses PHP en cookie pour éviter les hits alors qu'il a mis un anticache sur ses 180 xml/swf

hits ?

Edhit:

J'connaissais pas ce terme

T'as jamais acheté un Greatest Hits ?

si, de Frédéric François

T'as jamais regarder les stats des ton/tes sites ?

Bin si, mais j'ai jamais fais vraiment gaffe aux hits vu que je ne savais pas à quoi ça correspondait

pareils, sauf que j'ai été curieux
 
surtout que des chiffres pareils, tu te demandes bien qu'est c'que ça peu être

Plein de petites images pour les boutons et autres.
 
Ou alors, s'ils sont vraiment bêtes, plein de petits fichiers XML, paske chaque partie "modulaire" a le sien

ouais du coup 250 ça fait beaucoup C'est autant de requete HTTP j'imagine ...

hits == requetes HTTP
 
donc oui

A ton avis

Le must étant qu'ils font aussi 30 requetes PHP, 1 pour chaque méthode appelée dans les services (alors que c'est groupable avec AMF). Bien sûr ça ne les aurait jamais gêné si j'avais pas remarqué...
Ah, si, à un moment ils trouvaient ça lent et c'était de ma faute

Ah merde j'avais raté le le compte

IE7 aussi mais faut demander gentiment: -ms-interpolation-mode:bicubic;  
et y a un filtre CSS pour IE6

Sous OSX, tous les navigateurs font du resizing en bicubique Y compris Firefox

edit: d'ailleurs c'est visible sur la page liée par phosphoreloaded

Marche pas pour les PNG par contre, juste les jpeg

tin mais c'est le top ce truc, plus besoin de se faire chier a faire des miniatures... maintenant tout le monde est en 20 Mega, c'est pas bien grave de charger 50ko au lieu de 10

 
J'ai piqué l'idée chez Martin Fowler C'est absolument pas dégeu

"mmm, ce singleton n'est pas assez configurable, il me pose problème"
"je sais, je vais injecter mon singleton dans mon singleton!"
 

Nan
 
C'est un Service Locator dynamique. C'est tout. Lis A Dynamic Service Locator, et prend-en de la graine.

Ton service locator pourri reste implémenté via un singleton de merde, l'un n'exclus pas l'autre

C'est soit ça, soit d'la dependy injection enterprisey dont j'ai absolument pas envie  
 
Un singleton de base pose évidemment un tas de problèmes, le choix d'instancier un locator, initialiser les services (db, logger, config générale, etc.), et de proposer un accès statique à cette instance est parfaitement judicieux.
 
Pas de problèmes pour les tests unitaires (on peut changer l'instance à la volée, pour utiliser des mocks par exemple). Pas d'objets qui se baladent partout.
 
Un des seuls défauts est que ça planque un peu certaines dépendances. N'étant pas injectés dans les constructeurs/méthodes, certains paramètres ne sont pas obvious.

Faire de la DI ça veut pas dire être enterprisey hein, t'es pas obligé d'utiliser Spring et d'avoir du XML partout, de la DI ça peut tout aussi bien se faire à la main.

Alternativement, tu peux utiliser un truc dont, si je me souviens bien, PHP dispose: des paramètre par défaut. C'est très fréquent en Python, tu "injectes" un service en collant ton objet "de prod" comme valeur par défaut du paramètre, et quand tu testes, ben tu passes un paramètre explicite dans ta fonction ou ton constructeur (notes que je ne sais pas si tu peux avoir des objets/variables comme valeurs par défaut en PHP, si ça se trouve tu peux pas ).

Ouais ben voilà Oublie pas le paramètre "PHP" dans l'équation
 
J'injecte à la main quand je peux, mais pour certains trucs c'était plus simple de passer par un locator.

Ah j'ignorais. Mais en général PNG = pictos et images de fond qu'on répète mais qu'on redimensionne pas, JPG = photos et miniatures de photos
 
Reste les sites en largeur fluide où toutes les images sont en taille relative et vive les CMS qui retaillent les images avec GD2

 
Tu peux pas, par contre tu peux mettre null en valeur par défaut et instancier l'objet par défaut dans la méthode (si le param est null).

Bah non mais le principe c'est que la valeur injectée est créée ailleurs et potentiellement partagée entre nombre de fonctions/objets
 
Donc c'est plutôt null par défaut et récupérer l'objet par défaut

Je comprends pas Le but c'est pas de pouvoir faire de l'injection si besoin est, et d'utiliser/créer un objet par défaut sinon ?
 
En fait c'est surtout je vois pas la différence entre ta solution et la mienne, à part l'implémentation

T'injectes dans tous les cas, la différence est entre le comportement de production (injecter un objet par défaut) et le comportement de test (injecter un objet type mock).

Dans tous les cas, t'injectes un service extérieur, parce que c'est potentiellement une ressource partagée toussa.

Dans ta solution, tous les modèles db-backed vont créer leur propre connection à la DB, au lieu de passer par un service qui gèrera l'interaction entre l'objet-modèle et la DB.

Tu peux écrire vite fait un exemple de ta solution en Python, histoire d'être certain que je suis à côté de la plaque ?

google_translate = GoogleTranslateClient()
# plein de code, voire dans un autre fichier
def do_something(foo, bar, translator=google_translate):
    'blah blah blah'

utilisation/prod:

# whatever
result = do_something(arg_foo, arg_bar)
# whatever bis

testcase:

def test_something():
    mock_translator = MockTranslator()
    assertEqual(do_something(arg_foo, arg_bar, translator=mock_translator),
                result_I_want)

google_translate = GoogleTranslateClient()
# plein de code, voire dans un autre fichier
def do_something(foo, bar, translator=google_translate):
    'blah blah blah'

Ah ouais c'est spécial, ça
 
Du coup l'équivalent en PHP serait plutôt d'avoir un param par défaut à null, et d'aller chercher une variable globale dans ce cas
 
En mieux avec les namespaces de php 5.3.

Je trouve pas C'est Fabulous

Voila, un truc du style

puré ben quand on sort d'un projet ou les gars ont tenté de réinventer la roue version carré (genre en essayant de faire un FW mais en tout pourrit), Symfony parait presque trop simple

Un framework bien foutu, ça fait toujours ça la première fois

Si y'a des Djangoistes dans le coins, vous voyez un moyen de faire ça moins cradotement (ie. pas tapper dans les parties privées du parser, déjà que c'est pas le parser qui pose ces données dedans....) :

from django import template
from django.template.loader_tags import ExtendsNode
 
register = template.Library()
 
@register.tag(name='instance')
def do_instance(parser, token):
    """
    Includes an in-place extension of a given template.
    
    Example:
    
    # block.html
    <div class="block {% block classes %}{% endblock %}">
        <b class="decor_top"><b></b></b>
        <h2>{% block title %}{% endblock %}</h2>
        <div class="content">{% block content %}{% endblock %}</div>
        <b class="decor_bottom"><b></b></b>
    </div>
    
    # other-file-using-the-block-widget.html
    <body>
        {% instance "block.html" %}
        {% block title %}My custom title{% endblock %}
        {% block content %}Some custom content{% endblock %}
        {% endinstance %}
        
        {% instance "block.html" %}
        {% block title %}Another custom block{% endblock %}
        {% block content %}With different content{% endblock %}
        {% endinstance %}
    </body>
    
    """
    bits = token.split_contents()
    if len(bits) != 2:
        raise TemplateSyntaxError, "'%s' takes one argument" % bits[0]
    parent_name, parent_name_expr = None, None
    if bits[1][0] in ('"', "'" ) and bits[1][-1] == bits[1][0]:
        parent_name = bits[1][1:-1]
    else:
        parent_name_expr = parser.compile_filter(bits[1])
    # Hide the loaded blocks outside of the instance tag
    # while parsing the instance content, yeeeww
    loaded_blocks, parser.__loaded_blocks = parser.__loaded_blocks, []
    nodelist = parser.parse(('endinstance',))
    parser.delete_first_token()
    parser.__loaded_blocks = loaded_blocks
    return WrappingNode(ExtendsNode(nodelist, parent_name, parent_name_expr))
    
class WrappingNode(template.Node):
    """
    Hides the ExtendsNode from its own check for other extends node on the same
    document.
    """
    def __init__(self, inner):
        self.inner = inner
    def __repr__(self):
        return "<WrappingNode: %s >" % self.inner 
    def render(self, context):
        return self.inner.render(context)