Reflection/List methods: Difference between revisions

 

;Task:

 

Some languages offer [[Respond to an unknown method call|dynamic methods]], which in general can only be inspected if a class' public API includes a way of listing them.

 

=={{header|JavaScript}}==

In JavaScript, methods are properties that are functions, so methods are retrieved by [[Reflection/List properties|getting properties]] and filtering. There are multiple ways of getting property names, each of which include different subsets of an object's properties, such as enumerable or inherited properties.

 

function Super(name) {

this.name = name;

Object.entries(sub)

.filter(function(p) {return typeof p[1] == 'function';})

 

=={{header|Python}}==

In Python, methods are properties that are functions, so methods are retrieved by [[Reflection/List properties|getting properties]] and filtering, using (e.g.) <code>[https://docs.python.org/3.5/library/functions.html#dir dir()]</code> and a list comprehension. Python's <code>[https://docs.python.org/3.5/library/inspect.html#module-inspect inspect]</code> module offers a simple way to get a list of an object's methods, though it won't include wrapped, C-native methods (type 'method-wrapper', type 'wrapper_descriptor', or class 'wrapper_descriptor', depending on version). Dynamic methods can be listed by overriding <code>[https://docs.python.org/3/reference/datamodel.html#object.__dir__ __dir__]</code> in the class.

 

 

# Sample classes for inspection

# names using inspect

map(lambda t: t[0], inspect.getmembers(sub, predicate=inspect.ismethod))

=={{header|Ruby}}==

Ruby has various properties that will return lists of methods:

Dynamic methods can be listed by overriding these methods. Ancestor methods can be filtered out by subtracting a list of methods from the ancestor.

 

class Super

CLASSNAME = 'super'

def initialize(name)

@name = name

"Super(#{@name})"

end

def doSup

'did super stuff'

end

def self.superClassStuff

'did super class stuff'

end

protected

def protSup

"Super's protected"

end

private

def privSup

include Other

def initialize(name, *args)

@rest = args;

@dynamic = {}

def self.subOwn

end

end

def methods(regular=true)

super + @dynamic.keys

end

def method_missing(name, *args, &block)

return super unless @dynamic.member?(name)

end

if method.lambda?

if method.parameters[-1][0] != :rest

args = args[0,method.arity]

end

end

end

end

'did sub stuff'

end

def self.subClassStuff

'did sub class stuff'

end

protected

def protSub

"Sub's protected"

end

private

def privSub

sub.dynamic[:incr] = proc {|i| i+1}

 

 

 

 

 

# singleton/eigenclass methods