Question

一位朋友上周问我如何枚举或列出程序/函数/等中的所有变量。出于调试的目的（基本上获取所有内容的快照，以便您可以查看设置了哪些变量，或者是否设置了它们）。我环顾了一下，为Python找到了一个比较好的方法：

#!/usr/bin/python                                                                                                                                                                                                                           
foo1 = "Hello world"
foo2 = "bar"
foo3 = {"1":"a",
        "2":"b"}
foo4 = "1+1"

for name in dir():
    myvalue = eval(name)
    print name, "is", type(name), "and is equal to ", myvalue

将输出如下内容：

__builtins__ is <type 'str'> and is equal to  <module '__builtin__' (built-in)>
__doc__ is <type 'str'> and is equal to  None
__file__ is <type 'str'> and is equal to  ./foo.py
__name__ is <type 'str'> and is equal to  __main__
foo1 is <type 'str'> and is equal to  Hello world
foo2 is <type 'str'> and is equal to  bar
foo3 is <type 'str'> and is equal to  {'1': 'a', '2': 'b'}
foo4 is <type 'str'> and is equal to  1+1

到目前为止，我已经在PHP中找到了部分方法（由link text提供），但它只列出了所有变量及其类型，而不是内容：

<?php
// create a few variables
$bar = 'foo';
$foo ='bar';
// create a new array object
$arrayObj = new ArrayObject(get_defined_vars());
// loop over the array object and echo variables and values
for($iterator = $arrayObj->getIterator(); $iterator->valid(); $iterator->next())
        {
        echo $iterator->key() . ' => ' . $iterator->current() . '<br />';
        }
?>

所以我把它告诉你：你如何用你喜欢的语言列出所有变量及其内容？

按VonC编辑：我建议这个问题遵循一点“code-challenge”的精神。
如果您不同意，只需编辑并删除标记和链接。

Answer 1

在python中，使用返回包含所有本地绑定的字典的locals，因此，避免使用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'>}

Answer 2

这就是Ruby中的样子：

#!/usr/bin/env ruby

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

b = binding
local_variables.each do |var|
  puts "#{var} is #{var.class} and is equal to #{b.local_variable_get(var).inspect}"
end

将输出

foo1 is String and is equal to "Hello world"
foo2 is String and is equal to "bar"
foo3 is String and is equal to {"1"=>"a", "2"=>"b"}
foo4 is String and is equal to "1+1"

但是，您不是要输出变量引用的对象类型而不是用于表示变量标识符的类型吗？ IOW，foo3的类型应该是Hash（或dict）而不是String，对吗？在这种情况下，代码将是

#!/usr/bin/env ruby

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

b = binding
local_variables.each do |var|
  val = b.local_variable_get(var)
  puts "#{var} is #{val.class} and is equal to #{val.inspect}"
end

，结果是

foo1 is String and is equal to "Hello world"
foo2 is String and is equal to "bar"
foo3 is Hash and is equal to {"1"=>"a", "2"=>"b"}
foo4 is String and is equal to "1+1"

Answer 3

在php中你可以这样做：

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

Answer 4

在Lua中，基本数据结构是表，甚至全局环境_G也是一个表。因此，一个简单的枚举就可以解决问题。

for k,v in pairs(_G) do
  print(k..' is '..type(v)..' and is equal to '..tostring(v))
end

Answer 5

<强>击：

set

免责声明：不是我最喜欢的语言！

Answer 6

一个完全递归的PHP一行代码：

print_r(get_defined_vars());

Answer 7

IPython的：

whos

你也可以向你的朋友推荐Spyder，它显示那些与Matlab非常相似的变量，并提供逐行调试的GUI。

Answer 8

首先，我只是使用调试器;-p 例如，Visual Studio有“Locals”和“Watch”窗口，它们将显示您想要的所有变量等，可以完全扩展到任何级别。

在C＃中，你不能很容易地得到方法变量（编译器很好地删除它们） - 但你可以通过反射访问字段等：

static class Program { // formatted for minimal vertical space
    static object foo1 = "Hello world", foo2 = "bar",
                  foo3 = new[] { 1, 2, 3 }, foo4;
    static void Main() {
        foreach (var field in typeof(Program).GetFields(
                BindingFlags.Static | BindingFlags.NonPublic)) {
            var val = field.GetValue(null);
            if (val == null) {
                Console.WriteLine("{0} is null", field.Name);
            } else {
                Console.WriteLine("{0} ({1}) = {2}",
                    field.Name, val.GetType().Name, val);
            }
        }
    }
}

Answer 9

Matlab的：

who

Answer 10

的Perl。不处理my本地，并且不会过滤掉一些无用的引用，但可以看到包范围内的所有内容。

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

Answer 11

在java中，问题类似于C＃，只是在更详细的模式中（我知道， I KNOW ;）Java是冗长的... you made that clear already ;)）

您可以通过Refection访问对象字段，但您可能无法轻松访问方法局部变量。因此，以下内容不适用于静态分析代码，而仅适用于运行时调试。

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");
            }
        }
    }
}

Answer 12

在R语言

ls()

并从工作记忆中删除所有对象

rm(list=ls(all=TRUE))

Answer 13

在REBOL中，所有变量都存在于object!类型的上下文中。有一个全局上下文，每个函数都有自己的隐式本地上下文。您可以通过创建新的object!（或使用context函数）显式创建新的上下文。这与传统语言不同，因为变量（在REBOL中称为“单词”）带有对它们周围环境的引用，即使它们已经离开了定义它们的“范围”。

所以，最重要的是，给定一个上下文，我们可以列出它定义的变量。我们将使用Ladislav Mecir的context-words?函数。

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

现在我们可以列出全局上下文中定义的所有单词。（它们有很多。）

probe context-words? system/words

我们还可以编写一个函数，然后列出它定义的变量。

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

据我所知，我们不能在REBOL中做的是走向上下文树，虽然解释器似乎能够在决定如何绑定时完美地做到这一点他们的语境。我认为这是因为上下文树（即范围）在单词绑定时可能有一个“形状”，但在评估单词时可能有另一个“形状”。

Answer 14

如果安装了FireBug（或其他带有console.log的浏览器），则快速而脏的JavaScript解决方案。如果不这样做，则必须将console.log更改为document.write，并在其末尾作为内联脚本运行。将MAX_DEPTH更改为您想要的递归级别（小心！）。

(function() {
    var MAX_DEPTH = 0;
    function printObj(name, o, depth) {
        console.log(name + " type: '"+typeof o+"' value: " + o);

        if(typeof o == "function" || depth >= MAX_DEPTH) return;
        for(var c in o) {
            printObj(name+"."+c, o[c], depth+1);
        }
    }
    for(var o in window) {
        printObj(o, window[o], 0);
    }
})();

Answer 15

Common Lisp：

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

还要显示所有绑定值：

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

这是一个很长的清单，并不是特别有用。我真的会使用集成的调试器。

Answer 16

这是oo-languages的想法。

首先，您需要使用Java中的toString（）来打印有意义的内容。第二 - 你必须将自己限制在一个对象层次结构中。在根对象的构造函数中（如在Eiffel中的Any），您可以在某种全局列表中创建实例。在销毁期间，您取消注册（确保使用一些允许快速插入/搜索/删除的数据结构）。在程序执行期间的任何时候，您都可以遍历此数据结构并打印在那里注册的所有对象。

由于它的结构，埃菲尔可能非常适合这个目的。其他语言对于非用户定义的对象（例如jdk-classes）存在问题。在Java中，可以使用一些开源jdk创建自己的Object类。

枚举或列出[您最喜欢的语言]程序中的所有变量

16 个答案: