Énumérer ou de la liste de toutes les variables dans un programme de [votre langue préférée ici]

En python, en utilisant les habitants qui retourne un dictionnaire contenant toutes les liaisons, ainsi, d'éviter eval:

>>> foo1 = "Hello world"
>>> foo2 = "bar"
>>> foo3 = {"1":"a",
...         "2":"b"}
>>> foo4 = "1+1"

>>> import pprint
>>> pprint.pprint(locals())
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__name__': '__main__',
 'foo1': 'Hello world',
 'foo2': 'bar',
 'foo3': {'1': 'a', '2': 'b'},
 'foo4': '1+1',
 'pprint': <module 'pprint' from '/usr/lib/python2.5/pprint.pyc'>}

En php, vous pourriez faire ceci:

$defined = get_defined_vars(); 
foreach($defined as $varName => $varValue){
 echo "$varName is of type ".gettype($varValue)." and has value $varValue <br>";
}

IPython:

whos

Vous pourrait aussi recommander Spyder à votre ami qui montre que les variables à peu près comme Matlab ne et fournit une interface utilisateur graphique pour la, ligne par ligne, de débogage.

Un récursives, PHP one-liner:

print_r(get_defined_vars());

Perl. Ne gère pas les my les habitants, et ne filtre pas certains inutile de références, mais tout dans l'étendue d'un package peut être vu.

my %env = %{__PACKAGE__ . '::'};
while (($a, $b) = each %env) {
    print "$$a = $$b\n";
    print "\@$a = (@$b)\n";
    print "%$a = (@{[%$b]})\n";
    print "*$a = $b\n";
}

En java, le problème serait similaire à C#, mais en plus le mode verbose (je sais, JE SAIS 😉 Java est verbeux... vous avez fait clair que déjà 😉 )

Vous pouvez accéder aux champs d'objet par le biais de Réfection, mais vous ne pouvez pas accéder facilement à la méthode des variables locales. Donc la suite n'est pas pour l'analyse statique de code, mais pour le runtime debugging seulement.

package test;

import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.PrivilegedAction;

/**
 * 
 * @author <a href="https://stackoverflow.com/users/6309/vonc">VonC</a>
 */
public class DisplayVars
{

    private static int field1 = 1;
    private static String field2 = "~2~";
    private boolean isField = false;

    /**
     * @param args
     */
    public static void main(final String[] args)
    {
        final Field[] someFields = DisplayVars.class.getDeclaredFields();
        try
        {
            displayFields(someFields);
        } catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
    }

    /**
     * @param someFields
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     */
    @SuppressWarnings("unchecked")
    public static void displayFields(final Field[] someFields)
            throws IllegalAccessException
    {
        DisplayVars anObject = new DisplayVars();
        Object res = null;
        for (int ifields = 0; ifields < someFields.length; ifields++)
        {
            final Field aField = someFields[ifields];
            AccessController.doPrivileged(new PrivilegedAction() {
                public Object run()
                {
                    aField.setAccessible(true);
                    return null; //nothing to return
                }
            });
            res = aField.get(anObject);
            if (res != null)
            {
                System.out.println(aField.getName() + ": " + res.toString());
            } else
            {
                System.out.println(aField.getName() + ": null");
            }
        }
    }
}

En REBOL, toutes les variables vivre à l'intérieur d'un contexte de type object!. Il y a un contexte mondial, et chaque fonction a sa propre implicite du contexte local. Vous pouvez créer de nouveaux contextes explicitement par la création d'une nouvelle object! (ou à l'aide de la context fonction). Ceci est différent de langues traditionnelles parce que les variables (appelés "mots" dans REBOL) effectuer une référence à leur contexte avec eux, même quand ils ont quitté le "champ" dans lequel elles ont été définies.

Donc, la ligne de fond est que, dans un contexte donné, nous pouvons lister les variables qu'il définit. Nous allons utiliser Ladislav Mecir de contexte-mots? fonction.

context-words?: func [ ctx [object!] ] [ bind first ctx ctx ]

Maintenant, nous pouvons liste de tous les mots définis dans le contexte mondial. (Il y a un beaucoup d'entre eux.)

probe context-words? system/words

Nous pouvons aussi écrire une fonction qui affiche les variables qu'il définit.

enumerable: func [a b c /local x y z] [
  probe context-words? bind? 'a
]

Ce que nous ne peut pas faire en REBOL, pour autant que je sais, c'est marcher le contexte de l'arbre, bien que l'interprète semble être en mesure de le faire parfaitement bien quand il décide de la façon de lier les mots de leur contexte. Je pense que c'est parce que le contexte de l'arbre (c'est à dire, le champ d'application) peut avoir une "forme" à la fois un mot est lié, mais tout à fait une autre, à la fois, c'est évaluée.

Common Lisp:

(do-all-symbols (x) (print x))

Aussi de montrer tous liés valeurs:

(do-all-symbols (x) (print x) (when (boundp x) (print (symbol-value x))))

C'est une longue liste, et pas particulièrement utile. Je voudrais vraiment utiliser le débogueur intégré.