Ajout d'une méthode à une instance d'objet existant

voix
488

J'ai lu qu'il est possible d'ajouter une méthode à un objet existant (et non dans la définition de la classe) en Python.

Je comprends que ce n'est pas toujours bon de le faire. Mais comment peut-on faire?

Créé 04/08/2008 à 03:17
source utilisateur
Dans d'autres langues...                            


18 réponses

voix
736

En Python, il y a une différence entre les fonctions et les méthodes liées.

>>> def foo():
...     print "foo"
...
>>> class A:
...     def bar( self ):
...         print "bar"
...
>>> a = A()
>>> foo
<function foo at 0x00A98D70>
>>> a.bar
<bound method A.bar of <__main__.A instance at 0x00A9BC88>>
>>>

Les méthodes liées ont été « lié » (comment descriptif) à une instance, et cette instance sera transmis comme premier argument à chaque fois que la méthode est appelée.

Appelables qui sont les attributs d'une classe (par opposition à une instance) sont encore non fixé, cependant, de sorte que vous pouvez modifier la définition de classe chaque fois que vous voulez:

>>> def fooFighters( self ):
...     print "fooFighters"
...
>>> A.fooFighters = fooFighters
>>> a2 = A()
>>> a2.fooFighters
<bound method A.fooFighters of <__main__.A instance at 0x00A9BEB8>>
>>> a2.fooFighters()
fooFighters

sont mis à jour des instances précédemment définies et (aussi longtemps qu'ils ne sont pas eux-mêmes attribut de substitution):

>>> a.fooFighters()
fooFighters

Le problème vient quand vous voulez joindre une méthode à une seule instance:

>>> def barFighters( self ):
...     print "barFighters"
...
>>> a.barFighters = barFighters
>>> a.barFighters()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: barFighters() takes exactly 1 argument (0 given)

La fonction est pas liée automatiquement quand il est attaché directement à une instance:

>>> a.barFighters
<function barFighters at 0x00A98EF0>

Pour lier, on peut utiliser la fonction MethodType dans le module types :

>>> import types
>>> a.barFighters = types.MethodType( barFighters, a )
>>> a.barFighters
<bound method ?.barFighters of <__main__.A instance at 0x00A9BC88>>
>>> a.barFighters()
barFighters

Cette fois-ci d'autres instances de la classe n'ont pas été affectés:

>>> a2.barFighters()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: A instance has no attribute 'barFighters'

Plus d' informations peuvent être trouvées en lisant les descripteurs et métaclasse programmation .

Créé 06/08/2008 à 01:33
source utilisateur

voix
80

Module nouvelle est dépréciée depuis Python 2.6 et supprimé dans la version 3.0, l' utilisation des types

voir http://docs.python.org/library/new.html

Dans l'exemple ci - dessous , je l' ai délibérément retiré la valeur de retour de la patch_me()fonction. Je pense que donner de la valeur de retour peut faire croire ce patch retourne un nouvel objet, ce qui est faux - il modifie celui entrant. Probablement cela peut faciliter une utilisation plus rigoureuse de monkeypatching.

import types

class A(object):#but seems to work for old style objects too
    pass

def patch_me(target):
    def method(target,x):
        print "x=",x
        print "called from", target
    target.method = types.MethodType(method,target)
    #add more if needed

a = A()
print a
#out: <__main__.A object at 0x2b73ac88bfd0>  
patch_me(a)    #patch instance
a.method(5)
#out: x= 5
#out: called from <__main__.A object at 0x2b73ac88bfd0>
patch_me(A)
A.method(6)        #can patch class too
#out: x= 6
#out: called from <class '__main__.A'>
Créé 06/06/2009 à 06:31
source utilisateur

voix
47

Ajout d'une méthode à une instance d'objet existant

J'ai lu qu'il est possible d'ajouter une méthode à un objet existant (par exemple, pas dans la définition de classe) en Python.

Je comprends que ce n'est pas toujours une bonne décision de le faire. Mais, comment peut - on faire?

Oui, il est possible - mais pas recommandé

Je ne recommande pas. C'est une mauvaise idée. Ne pas le faire.

Voici quelques raisons:

  • Vous ajoutez un objet lié à chaque fois que vous faites cela. Si vous faites cela beaucoup, vous aurez probablement perdre beaucoup de mémoire. Les méthodes liées sont généralement créées que pour la courte durée de leur appel, et ils cessent alors d'exister quand automatiquement les déchets collectés. Si vous le faites manuellement, vous aurez un nom de liaison faisant référence à la méthode liée - qui empêchera la collecte des ordures sur l'utilisation.
  • Instances d'objets d'un type donné ont généralement ses méthodes sur tous les objets de ce type. Si vous ajoutez des méthodes ailleurs, certains cas auront ces méthodes et d' autres non. Les programmeurs ne seront pas attendre à ce que , et vous risquez de violer la règle de moindre surprise .
  • Comme il y a d'autres très bonnes raisons de ne pas faire cela, vous allez vous donner plus d'une mauvaise réputation si vous le faites.

Ainsi, je vous suggère de ne pas le faire , sauf si vous avez une très bonne raison. Il est préférable de définir la bonne méthode dans la définition de classe ou moins de préférence singe-patch la classe directement, comme ceci:

Foo.sample_method = sample_method

Comme il est instructif, cependant, je vais vous montrer quelques façons de le faire.

Comment ça peut être fait

Voici un code de configuration. Nous avons besoin d'une définition de classe. Il pourrait être importé, mais il n'a pas d'importance.

class Foo(object):
    '''An empty class to demonstrate adding a method to an instance'''

Créer une instance:

foo = Foo()

Créez une méthode pour y ajouter:

def sample_method(self, bar, baz):
    print(bar + baz)

néant Méthode (0) - utiliser la méthode de descripteur, __get__

Les recherches en pointillé sur les fonctions appellent le __get__procédé de la fonction avec l'exemple, la liaison de l'objet à la méthode et créant ainsi une « méthode liée ».

foo.sample_method = sample_method.__get__(foo)

et maintenant:

>>> foo.sample_method(1,2)
3

Méthode une - types.MethodType

Tout d'abord, les types d'importation, dont nous allons obtenir le constructeur de la méthode:

import types

Maintenant , nous ajoutons la méthode à l'instance. Pour ce faire, nous avons besoin du constructeur MethodType du typesmodule (qui nous importions ci - dessus).

La signature de l' argument pour types.MethodType est (function, instance, class):

foo.sample_method = types.MethodType(sample_method, foo, Foo)

et l'utilisation:

>>> foo.sample_method(1,2)
3

Deuxième méthode: liaison lexical

Tout d'abord, nous créons une fonction wrapper qui lie la méthode à l'instance:

def bind(instance, method):
    def binding_scope_fn(*args, **kwargs): 
        return method(instance, *args, **kwargs)
    return binding_scope_fn

usage:

>>> foo.sample_method = bind(foo, sample_method)    
>>> foo.sample_method(1,2)
3

Troisième méthode: functools.partial

Une fonction partielle applique le premier argument (s) à fonction (et éventuellement les arguments de mots clés), et peut ensuite être appelée avec les arguments restants (et dominante arguments mot-clé). Ainsi:

>>> from functools import partial
>>> foo.sample_method = partial(sample_method, foo)
>>> foo.sample_method(1,2)
3    

Cela est logique si l'on considère que les méthodes liées sont des fonctions partielles de l'instance.

Non consolidé fonction comme un attribut de l'objet - pourquoi cela ne fonctionne pas:

Si nous essayons d'ajouter le sample_method de la même manière que nous pourrions ajouter à la classe, il est non lié de l'instance, et ne prend pas le soi implicite comme premier argument.

>>> foo.sample_method = sample_method
>>> foo.sample_method(1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sample_method() takes exactly 3 arguments (2 given)

Nous pouvons faire le travail de la fonction non liée en passant explicitement l'instance (ou quoi que ce soit, étant donné que cette méthode n'utilise pas réellement la selfvariable d'argument), mais il ne serait pas compatible avec la signature attendue d'autres cas (si nous sommes singe-patcher ce cas):

>>> foo.sample_method(foo, 1, 2)
3

Conclusion

Vous savez maintenant plusieurs façons dont vous pouvez le faire, mais dans tout le sérieux - ne le faites pas.

Créé 21/01/2015 à 05:31
source utilisateur

voix
30

Je pense que les réponses ci-dessus ont manqué le point clé.

Ayons une classe avec une méthode:

class A(object):
    def m(self):
        pass

Maintenant, nous allons jouer avec elle dans ipython:

In [2]: A.m
Out[2]: <unbound method A.m>

Ok, alors m () devient en quelque sorte une méthode non liée de A . Mais est - ce vraiment comme ça?

In [5]: A.__dict__['m']
Out[5]: <function m at 0xa66b8b4>

Il se trouve que m () est juste une fonction, une référence à laquelle est ajouté à un dictionnaire de classe - il n'y a pas de magie. Alors pourquoi Am nous donne une méthode non liée? C'est parce que le point ne se traduit pas à une recherche simple dictionnaire. Il est de fait un appel d'une classe .__ __.__ getattribute __ (A, 'm'):

In [11]: class MetaA(type):
   ....:     def __getattribute__(self, attr_name):
   ....:         print str(self), '-', attr_name

In [12]: class A(object):
   ....:     __metaclass__ = MetaA

In [23]: A.m
<class '__main__.A'> - m
<class '__main__.A'> - m

Maintenant, je ne suis pas sûr de la partie supérieure de ma tête pourquoi la dernière ligne est imprimé deux fois, mais il est clair ce qui se passe là-bas.

Maintenant, ce que le __getattribute__ par défaut fait est qu'il vérifie si l'attribut est un soi-disant descripteur ou non, à savoir si elle met en œuvre une méthode spéciale de __get__. Si elle met en œuvre cette méthode, alors ce qui est retourné est le résultat de l' appel que la méthode de __get__. Pour en revenir à la première version de notre Une classe, c'est ce que nous avons:

In [28]: A.__dict__['m'].__get__(None, A)
Out[28]: <unbound method A.m>

Et parce que les fonctions Python mettre en œuvre le protocole de descripteur, si on les appelle au nom d'un objet, ils se lient à cet objet dans leur méthode de __get__.

Ok, donc comment ajouter une méthode à un objet existant? En supposant que vous ne me dérange pas la classe rapiéçage, il est aussi simple que:

B.m = m

Alors Bm « devient » une méthode non liée, grâce à la magie du descripteur.

Et si vous voulez ajouter une méthode juste pour un seul objet, alors vous devez imiter l'appareil vous-même, en utilisant types.MethodType:

b.m = types.MethodType(m, b)

Au fait:

In [2]: A.m
Out[2]: <unbound method A.m>

In [59]: type(A.m)
Out[59]: <type 'instancemethod'>

In [60]: type(b.m)
Out[60]: <type 'instancemethod'>

In [61]: types.MethodType
Out[61]: <type 'instancemethod'>
Créé 22/01/2012 à 15:20
source utilisateur

voix
16

En Python patching singe fonctionne généralement en réécrivant une signature de classe ou fonctions avec votre propre. Voici un exemple de la Zope Wiki :

from SomeOtherProduct.SomeModule import SomeClass
def speak(self):
   return "ook ook eee eee eee!"
SomeClass.speak = speak

Ce code remplacera / créer une méthode appelée parler de la classe. Dans Jeff Atwood post récent sur rapiéçage de singe . Il montre un exemple en C # 3.0 qui est la langue courante que j'utilise pour le travail.

Créé 04/08/2008 à 03:31
source utilisateur

voix
9

Il y a au moins deux façons de fixer une méthode à une instance sans types.MethodType:

>>> class A:
...  def m(self):
...   print 'im m, invoked with: ', self

>>> a = A()
>>> a.m()
im m, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.m
<bound method A.m of <__main__.A instance at 0x973ec6c>>
>>> 
>>> def foo(firstargument):
...  print 'im foo, invoked with: ', firstargument

>>> foo
<function foo at 0x978548c>

1:

>>> a.foo = foo.__get__(a, A) # or foo.__get__(a, type(a))
>>> a.foo()
im foo, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.foo
<bound method A.foo of <__main__.A instance at 0x973ec6c>>

2:

>>> instancemethod = type(A.m)
>>> instancemethod
<type 'instancemethod'>
>>> a.foo2 = instancemethod(foo, a, type(a))
>>> a.foo2()
im foo, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.foo2
<bound method instance.foo of <__main__.A instance at 0x973ec6c>>

Liens utiles:
Modèle de données - descripteurs invoquant
Descriptor Guide de HowTo - descripteurs invoquant

Créé 26/04/2013 à 16:47
source utilisateur

voix
7

Vous pouvez utiliser lambda pour lier une méthode à une instance:

def run(self):
    print self._instanceString

class A(object):
    def __init__(self):
        self._instanceString = "This is instance string"

a = A()
a.run = lambda: run(a)
a.run()

Ceci est par exemple la chaîne

Procédé fini avec le code de sortie 0

Créé 21/07/2014 à 13:55
source utilisateur

voix
6

Étant donné que cette question posée pour les versions non-Python, voici JavaScript:

a.methodname = function () { console.log("Yay, a new method!") }
Créé 09/03/2012 à 16:07
source utilisateur

voix
6

Qu'est - ce que vous cherchez est setattrje crois. Utilisez cette option pour définir un attribut sur un objet.

>>> def printme(s): print repr(s)
>>> class A: pass
>>> setattr(A,'printme',printme)
>>> a = A()
>>> a.printme() # s becomes the implicit 'self' variable
< __ main __ . A instance at 0xABCDEFG>
Créé 07/08/2008 à 12:30
source utilisateur

voix
5

Ceci est en fait un addon à la réponse de « Jason Pratt »

Bien que Jasons répondre à des œuvres, il ne fonctionne que si l'on veut ajouter une fonction à une classe. Il ne fonctionne pas pour moi quand j'ai essayé de recharger une méthode déjà existante à partir du fichier de code source .py.

Il m'a fallu des siècles pour trouver une solution de contournement, mais l'astuce semble simple ... 1.st importer le code à partir du fichier de code source 2.ème forcer une utilisation reload 3.ème types.FunctionType (...) pour convertir le importé et méthode liée à une fonction, vous pouvez également transmettre les variables globales actuelles, comme la méthode rechargées serait dans un 4.th d'espace de noms différent, vous pouvez maintenant continuer comme suggéré par « Jason Pratt » en utilisant le types.MethodType (... )

Exemple:

# this class resides inside ReloadCodeDemo.py
class A:
    def bar( self ):
        print "bar1"

    def reloadCode(self, methodName):
        ''' use this function to reload any function of class A'''
        import types
        import ReloadCodeDemo as ReloadMod # import the code as module
        reload (ReloadMod) # force a reload of the module
        myM = getattr(ReloadMod.A,methodName) #get reloaded Method
        myTempFunc = types.FunctionType(# convert the method to a simple function
                                myM.im_func.func_code, #the methods code
                                globals(), # globals to use
                                argdefs=myM.im_func.func_defaults # default values for variables if any
                                ) 
        myNewM = types.MethodType(myTempFunc,self,self.__class__) #convert the function to a method
        setattr(self,methodName,myNewM) # add the method to the function

if __name__ == '__main__':
    a = A()
    a.bar()
    # now change your code and save the file
    a.reloadCode('bar') # reloads the file
    a.bar() # now executes the reloaded code
Créé 18/08/2015 à 15:32
source utilisateur

voix
5

Vous devriez vraiment regarder fruit défendu , il est une bibliothèque Python qui fournit un support pour le singe rapiéçage toute catégorie de python, même des chaînes.

Créé 25/08/2013 à 22:56
source utilisateur

voix
5

Jason Pratt réponses La consolidation et le wiki pour la communauté, avec un regard sur les résultats des différentes méthodes de fixation:

Surtout noter comment l' ajout de la fonction de liaison en tant que méthode de classe fonctionne , mais la portée de référencement est incorrect.

#!/usr/bin/python -u
import types
import inspect

## dynamically adding methods to a unique instance of a class


# get a list of a class's method type attributes
def listattr(c):
    for m in [(n, v) for n, v in inspect.getmembers(c, inspect.ismethod) if isinstance(v,types.MethodType)]:
        print m[0], m[1]

# externally bind a function as a method of an instance of a class
def ADDMETHOD(c, method, name):
    c.__dict__[name] = types.MethodType(method, c)

class C():
    r = 10 # class attribute variable to test bound scope

    def __init__(self):
        pass

    #internally bind a function as a method of self's class -- note that this one has issues!
    def addmethod(self, method, name):
        self.__dict__[name] = types.MethodType( method, self.__class__ )

    # predfined function to compare with
    def f0(self, x):
        print 'f0\tx = %d\tr = %d' % ( x, self.r)

a = C() # created before modified instnace
b = C() # modified instnace


def f1(self, x): # bind internally
    print 'f1\tx = %d\tr = %d' % ( x, self.r )
def f2( self, x): # add to class instance's .__dict__ as method type
    print 'f2\tx = %d\tr = %d' % ( x, self.r )
def f3( self, x): # assign to class as method type
    print 'f3\tx = %d\tr = %d' % ( x, self.r )
def f4( self, x): # add to class instance's .__dict__ using a general function
    print 'f4\tx = %d\tr = %d' % ( x, self.r )


b.addmethod(f1, 'f1')
b.__dict__['f2'] = types.MethodType( f2, b)
b.f3 = types.MethodType( f3, b)
ADDMETHOD(b, f4, 'f4')


b.f0(0) # OUT: f0   x = 0   r = 10
b.f1(1) # OUT: f1   x = 1   r = 10
b.f2(2) # OUT: f2   x = 2   r = 10
b.f3(3) # OUT: f3   x = 3   r = 10
b.f4(4) # OUT: f4   x = 4   r = 10


k = 2
print 'changing b.r from {0} to {1}'.format(b.r, k)
b.r = k
print 'new b.r = {0}'.format(b.r)

b.f0(0) # OUT: f0   x = 0   r = 2
b.f1(1) # OUT: f1   x = 1   r = 10  !!!!!!!!!
b.f2(2) # OUT: f2   x = 2   r = 2
b.f3(3) # OUT: f3   x = 3   r = 2
b.f4(4) # OUT: f4   x = 4   r = 2

c = C() # created after modifying instance

# let's have a look at each instance's method type attributes
print '\nattributes of a:'
listattr(a)
# OUT:
# attributes of a:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x000000000230FD88>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x000000000230FD88>>
# f0 <bound method C.f0 of <__main__.C instance at 0x000000000230FD88>>

print '\nattributes of b:'
listattr(b)
# OUT:
# attributes of b:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x000000000230FE08>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x000000000230FE08>>
# f0 <bound method C.f0 of <__main__.C instance at 0x000000000230FE08>>
# f1 <bound method ?.f1 of <class __main__.C at 0x000000000237AB28>>
# f2 <bound method ?.f2 of <__main__.C instance at 0x000000000230FE08>>
# f3 <bound method ?.f3 of <__main__.C instance at 0x000000000230FE08>>
# f4 <bound method ?.f4 of <__main__.C instance at 0x000000000230FE08>>

print '\nattributes of c:'
listattr(c)
# OUT:
# attributes of c:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x0000000002313108>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x0000000002313108>>
# f0 <bound method C.f0 of <__main__.C instance at 0x0000000002313108>>

Personnellement, je préfère la route de fonction ADDMETHOD externe, car il me permet d'attribuer dynamiquement de nouveaux noms de méthode dans un iterator aussi bien.

def y(self, x):
    pass
d = C()
for i in range(1,5):
    ADDMETHOD(d, y, 'f%d' % i)
print '\nattributes of d:'
listattr(d)
# OUT:
# attributes of d:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x0000000002303508>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x0000000002303508>>
# f0 <bound method C.f0 of <__main__.C instance at 0x0000000002303508>>
# f1 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f2 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f3 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f4 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
Créé 28/01/2012 à 01:12
source utilisateur

voix
4

Qu'est-ce que Jason Pratt affiché est correct.

>>> class Test(object):
...   def a(self):
...     pass
... 
>>> def b(self):
...   pass
... 
>>> Test.b = b
>>> type(b)
<type 'function'>
>>> type(Test.a)
<type 'instancemethod'>
>>> type(Test.b)
<type 'instancemethod'>

Comme vous pouvez le voir, Python ne considère pas b () différent d'un (). En Python toutes les méthodes ne sont que des variables qui se trouvent être des fonctions.

Créé 22/08/2008 à 15:40
source utilisateur

voix
3

Si elle peut être d'une aide quelconque, je a récemment publié une bibliothèque Python nommé Gorilla pour rendre le processus de singe patcher plus pratique.

En utilisant une fonction needle()pour patcher un module nommé guineapigse présente comme suit:

import gorilla
import guineapig
@gorilla.patch(guineapig)
def needle():
    print("awesome")

Mais il prend également en charge des cas d'utilisation les plus intéressants , comme indiqué dans la FAQ de la documentation .

Le code est disponible sur GitHub .

Créé 15/07/2014 à 03:12
source utilisateur

voix
2

Je trouve étrange que personne ne mentionne que toutes les méthodes énumérées ci-dessus crée une référence de cycle entre la méthode ajoutée et l'instance, ce qui provoque l'objet à être persistant jusqu'à ce que la collecte des ordures. Il y avait un vieux truc d'ajouter un descripteur par l'extension de la classe de l'objet:

def addmethod(obj, name, func):
    klass = obj.__class__
    subclass = type(klass.__name__, (klass,), {})
    setattr(subclass, name, func)
    obj.__class__ = subclass
Créé 30/04/2017 à 04:57
source utilisateur

voix
2

Cette question a été ouverte il y a quelques années, mais bon, il y a un moyen facile de simuler la liaison d'une fonction à une instance de classe en utilisant les décorateurs:

def binder (function, instance):
  copy_of_function = type (function) (function.func_code, {})
  copy_of_function.__bind_to__ = instance
  def bound_function (*args, **kwargs):
    return copy_of_function (copy_of_function.__bind_to__, *args, **kwargs)
  return bound_function


class SupaClass (object):
  def __init__ (self):
    self.supaAttribute = 42


def new_method (self):
  print self.supaAttribute


supaInstance = SupaClass ()
supaInstance.supMethod = binder (new_method, supaInstance)

otherInstance = SupaClass ()
otherInstance.supaAttribute = 72
otherInstance.supMethod = binder (new_method, otherInstance)

otherInstance.supMethod ()
supaInstance.supMethod ()

Là, quand vous passez la fonction et l'instance au décorateur de liant, il va créer une nouvelle fonction, avec le même objet de code que le premier. Ensuite, l'instance donnée de la classe est stockée dans un attribut de la fonction nouvellement créée. Le décorateur de retour d' une fonction (troisième) appelant automatiquement la fonction copié, donnant l'exemple , comme le premier paramètre.

En conclusion , vous obtenez une fonction simulant est la liaison à l'instance de classe. Laisser la fonction d' origine inchangés.

Créé 21/12/2015 à 21:39
source utilisateur

voix
1
from types import MethodType

def method(self):
   print 'hi!'


setattr( targetObj, method.__name__, MethodType(method, targetObj, type(method)) )

Avec cela, vous pouvez utiliser le pointeur auto

Créé 27/07/2017 à 04:21
source utilisateur

voix
-8

Je ne sais pas la syntaxe Python, mais je sais que Ruby peut le faire, et il est assez trivial. Disons que vous voulez ajouter une méthode à matrice qui imprime la longueur hors norme:

class Array
  def print_length
    puts length
  end
end

Si vous ne voulez pas modifier l'ensemble de la classe, vous pouvez simplement ajouter la méthode à une seule instance du tableau, et pas d'autres tableaux aurez la méthode:

array = [1, 2, 3]
def array.print_length
  puts length
end

Juste être conscient des problèmes liés à l' utilisation de cette fonction. Jeff Atwood fait écrit à ce sujet pas trop longtemps.

Créé 04/08/2008 à 03:36
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more