Reflection/List properties: Difference between revisions

=={{header|C sharp}}==

{{works with|C sharp|7}}

using System.Collections.Generic;

using System.Linq;

}

 

{{out}}

<pre>

 

=={{header|D}}==

 

struct S {

printProperties!S;

printProperties!C;

{{out}}

<pre>Properties of S:

Properties of C:

b</pre>

 

=={{header|Elena}}==

import system'dynamic;

import extensions;

class MyClass

{

}

public program()

{

this Y := "String";

};

{

}

{{out}}

<pre>

=={{header|Factor}}==

Mirrors present an object's slots and slot values as an associative structure.

 

TUPLE: foo

 

"apple" "banana" 200 <foo> <mirror>

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

}

fmt.Println()

{{out}}

<pre>

=={{header|Groovy}}==

{{trans|Java}}

 

@SuppressWarnings("unused")

}

}

{{out}}

<pre>All public fields (including inherited):

 

=={{header|Java}}==

 

public class ListFields {

}

}

{{out}}

<pre>

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. Properties in JavaScript can be enumerable or non-enumerable; enumerable properties are accessable when looping over the object with <code>for</code>. <code>Object.getOwnPropertyNames()</code>.

 

name: 'proto',

proto: true,

Object.entries(obj);

//[["name", "obj"], ["obj", true], ["doStuff", function()]]

 

=={{header|jq}}==

 

'''Example'''

# Use jq's built-ins to generate a (recursive) synopsis of .

def synopsis:

true, null, [1,2], {"a": {"b": 3, "c": 4}, "x": "Rosetta Code"}, now

| ("\n\(.) ::", synopsis)

{{out}}

<pre>

{{works with|Julia|0.6}}

 

println("\nObject: $obj\nDescription:")

dump(obj)

 

{{out}}

 

=={{header|Kotlin}}==

 

import kotlin.reflect.full.memberProperties

println("${prop.name.padEnd(13)} -> ${prop.get(example)}")

}

 

{{out}}

 

=={{header|Lingo}}==

obj.foo = 23

obj.bar = 42

repeat with i = 1 to cnt

put obj.getPropAt(i)&" = "&obj[i]

 

{{Out}}

 

=={{header|Lua}}==

b = 2.0

c = "hello world"

listProperties(_G)

print("Package properties")

{{out}}

<pre>Global properties

 

=={{header|Nanoquery}}==

class Fields

declare static field1 = "this is a static field. it will not be listed"

for fieldname in Fields.getFieldNames()

println fieldname

 

{{out}}

field4</pre>

=={{header|Nim}}==

Foo = object

a: float

let f = Foo(a: 0.9, b: "hi", c: @[1,2,3])

for n, v in f.fieldPairs:

{{out}}

<pre>a: 0.9

 

=={{header|Objective-C}}==

#import <objc/runtime.h>

 

 

return 0;

{{out}}

<pre>

 

Many of these options are also supported by other REXX implementations.

/* test values */

d.1=''

Say ol

End

{{out}}

<pre> A B I L M N O S U V W X 9 datatype(v)

=={{header|Perl}}==

In Perl's bare-bones native OO system, an object is sometimes nothing more than a hash blessed into a class. It's properties could be simply listed by iterating over the keys. However more complex data structures can be present, so the safest option is always to use <code>Data::Dumper</code> to examine an object.

package Point;

use Class::Spiffy -base;

say Dumper $p1;

say Dumper $c1;

{{out}}

<pre>$VAR1 = bless( {

Technically the code below is re-fetching tid and flags before returning them in a textual format.

 

<span style="color: #008080;">class</span> <span style="color: #000000;">c</span> <span style="color: #7060A8;">nullable</span>

<span style="color: #004080;">integer</span> <span style="color: #004080;">int</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

 

{{out}}

 

=={{header|PHP}}==

class Foo {

}

 

var_dump(get_object_vars($obj));

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

First we define a rectangle class <code>+Rectangle</code> as subclass of a shape class <code>+Shape</code>:

 

# The Rectangle class

(class +Rectangle +Shape)

(dm draw> ()

(drawRect (: x) (: y) (: dx) (: dy)) ) # Hypothetical function 'drawRect'

 

 

: (setq R (new '(+Rectangle) 0 0 30 20))

-> $177356065126400

 

 

 

 

Here we find the properties of a <code>[DateTime]</code> object:

Get-Date | Get-Member -MemberType Property

 

{{Out}}

</pre>

The "Add" methods of a <code>[DateTime]</code> object:

Get-Date | Get-Member -MemberType Method -Name Add*

{{Out}}

<pre>

The <code>[https://docs.python.org/3.5/library/functions.html#dir dir()]</code> function and Python's <code>[https://docs.python.org/3.5/library/inspect.html#module-inspect inspect]</code> module both will list properties.

 

__priv = 'private'

inspect.getmembers(chld)

#[('__class__', <class '__main__.Child'>), ..., ('args', (0, 'I', 'two')), ('args_bleh', "(0, 'I', 'two') bleh"), ('doNothing', <bound method Child.doNothing of Child(chld, 0, 'I', 'two')>), ('doStuff', <bound method Child.doStuff of Child(chld, 0, 'I', 'two')>), ('name', 'chld'), ('name_bleh', 'chld bleh'), ('own', "chld's own"), ('own_bleh', "chld's own bleh"), ('reBleh', <_sre.SRE_Pattern object at 0x10067bd20>), ('reBleh_bleh', '<_sre.SRE_Pattern object at 0x10067bd20> bleh')]

 

=={{header|Raku}}==

Each is represented as an <tt>Attribute</tt> object that contains a bunch of info:

 

has $!a = now;

has Str $.b;

for $object.^attributes {

say join ", ", .name, .readonly, .container.^name, .get_value($object);

 

{{out}}

 

A simplistic example:

abc.j= -4.12

 

 

<br><br>

===version 2===

/* put_data2('a.') to show all a.tail values isn't that easy :-) */

j=2

put_data:

Parse Arg variable

{{out}}

<pre>abc.2='-4.12'

 

=={{header|Ruby}}==

@@xyz = nil

def initialize(name, age)

p Foo.class_variable_get(:@@xyz) #=> :xyz

p Foo.class_variable_set(:@@abc, 123) #=> 123

 

=={{header|Scala}}==

===Java Interoperability===

{{Out}}Best seen running in your browser [https://scastie.scala-lang.org/MdkPxH6yTlS4W8TaXYxSgA Scastie (remote JVM)].

private val obj = new {

val examplePublicField: Int = 42

println("\nAll declared fields (excluding inherited):")

clazz.getDeclaredFields.foreach(f => println(s"${f}}"))

 

=={{header|Tcl}}==

 

For objects supporting this protocol, you can list all options by invoking the <tt>configure</tt> method without arguments (result split over multiple lines for readability):

8.6.5

% . configure

{-highlightcolor highlightColor HighlightColor #000000 #000000}

{-highlightthickness highlightThickness HighlightThickness 0 0} {-padx padX Pad 0 0} {-pady padY Pad 0 0}

 

Two-element sublists (eg <tt>-bd -borderwidth</tt>) represent aliases, and five-element sublists are of the form <tt>{optionName dbName dbClass defaultValue currentValue}</tt>. <tt>dbName</tt> and <tt>dbClass</tt> are related to how the option is specified in the <i>option database</i>.

Simply listing the option names is like this:

 

-borderwidth -class -menu -relief -screen -use -background -colormap -container -cursor -height

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>{ Name = PublicNumber, Value = 4 }

 

Note that, since attributes are stored internally as a map, the order in which the property names appear is undefined.

#! instance_properties(p, q, r)

class C {

var c = C.new() // create an object of type C

System.print("List of properties available for object 'c':")

 

{{out}}

 

Every object has a "properties" method, which returns a list of property names [for that object].

properties.println();

List(1,2,3).property(properties[0]).println(); // get value

List(1,2,3).Property(properties[0])().println(); // method that gets value

{{out}}

<pre>