枚举或列出[您最喜欢的语言]程序中的所有变量[关闭]
https://stackoverflow.com/questions/430811
-
08-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
一位朋友上周问我如何枚举或列出程序/函数/等中的所有变量。出于调试的目的（基本上获取所有内容的快照，以便您可以查看设置了哪些变量，或者是否设置了它们）。我环顾了一下，为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的部分方式（由链接文字提供）但它只列出所有变量及其类型，而不是内容：
<?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 ＆QUOT ;.结果 如果您不同意，只需编辑并删除标记和链接。
解决方案
在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'>}
其他提示
这就是 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" 在php中你可以这样做：
$defined = get_defined_vars();
foreach($defined as $varName => $varValue){
echo "$varName is of type ".gettype($varValue)." and has value $varValue <br>";
}
在Lua中，基本数据结构是表，甚至全局环境_G也是一个表。因此，一个简单的枚举就可以解决问题。
for k,v in pairs(_G) do
print(k..' is '..type(v)..' and is equal to '..tostring(v))
end
<强>击：
set
免责声明：不是我最喜欢的语言！
一个完全递归的PHP一行代码：
print_r(get_defined_vars());
首先，我只是使用调试器;-p 例如，Visual Studio具有“本地”和“本地”。和“观察”窗口将显示您想要的所有变量等，完全可扩展到任何级别。
在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);
}
}
}
}
Matlab的：
who
的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";
}
在java中，问题与C＃类似，只是在更详细的模式中（我知道， 我知道 ;;）Java很冗长...... 你已经明确了这一点;））
您可以通过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");
}
}
}
}
在R语言
ls()
并从工作记忆中删除所有对象
rm(list=ls(all=TRUE))
在REBOL中，所有变量都存在于 object！类型的 context 中。有一个全局上下文，每个函数都有自己的隐式本地上下文。您可以通过创建新的对象！（或使用 context 函数）显式创建新的上下文。这与传统语言不同，因为变量（在REBOL中称为“单词”）带有对它们周围的上下文的引用，即使它们已经离开了“范围”。他们被定义了。
所以，最重要的是，给定一个上下文，我们可以列出它定义的变量。我们将使用Ladislav Mecir的 上下文单词？ 功能。
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中做的是走向上下文树，虽然解释器似乎能够在决定如何绑定时完美地做到这一点他们的语境。我认为这是因为上下文树（即范围）可以具有一个“形状”。在一个单词被绑定的时候，但在它被评估时是另一个单词。
如果安装了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);
}
})();
Common Lisp：
(do-all-symbols (x) (print x))
还要显示所有绑定值：
(do-all-symbols (x) (print x) (when (boundp x) (print (symbol-value x))))
这是一个很长的清单，并不是特别有用。我真的会使用集成的调试器。
这是oo-languages的想法。
首先，您需要使用Java中的toString（）来打印有意义的内容。 第二 - 你必须将自己限制在一个对象层次结构中。在根对象的构造函数中（如在Eiffel中的Any），您可以在某种全局列表中创建实例。在销毁期间，您取消注册（确保使用一些允许快速插入/搜索/删除的数据结构）。在程序执行期间的任何时候，您都可以遍历此数据结构并打印在那里注册的所有对象。
由于它的结构，埃菲尔可能非常适合这个目的。其他语言对于非用户定义的对象（例如jdk-classes）存在问题。在Java中，可以使用一些开源jdk创建自己的Object类。
