我想要做的是获取传递给函数的变量的名称和该变量的值，并且只需将一个变量传递给函数。所以：
var x = "anything";
function showName() {
}
showName(x);
或
showName("x");
这将返回：“x = 任何东西”。
现在，我必须指定变量两次：
showName("x", x);
为了获取我传入的变量的名称和值。
请注意，我对showName原型中的参数名称不感兴趣，而是调用函数中的变量名称。另外，传递的变量可能是本地的，所以无法使用window对象来查找变量。
【问题讨论】：
yourfunction({yourvariable}); 那么 insta 构建的字典包含键值对，键是名称，值是你的变量的值。
标签： javascript arguments
简短的回答是你不能。
更长的，邪恶的答案是，你可以有一些真正的肮脏。它只在从另一个函数调用时才有效。
有两个有趣的属性可以帮助您
arguments.callee 来电者
让 fn 做这样的事情：
(function(){
var showMe = function(s){
alert(arguments.callee.caller.toString().match(/showMe\((\S)\)/)[1] +
' = '+ s)
}
x = 1
showMe(x)
})()
arguments.callee.caller.toString().match(..)[1] 所做的是在调用它的函数中查找被调用的 showMe 并打印它及其值。
但这仍然非常有限，因为它只会触发 showMe(x) 的第一次调用。因此，如果有两次调用它，它将不起作用。
但是，玩这些神秘的东西很有趣。
【讨论】：
caller 是null 时，这将在Firefox 和Safari 上出错
策略 1：
如果您可以在函数调用期间控制数据结构，那么您可以传递一个字典，它将名称编码为键，并与其值配对，注意隐身花括号：
var foo = "bar";
yourfunction({foo});
其中传递了一个如下所示的 javascript 字典：
{foo : "bar"}
当yourfunction(被执行时，解压名称和值：
yourfunction = function(dict) {
var name = Object.keys(dict)[0];
var value = dict[name];
console.log(name); //prints foo
console.log(value); //prints bar
}
策略 2：
如果您可以在全局范围内维护一个随用随用的名称-值对列表，那么反射和自省始终可用于设置和获取，例如：
var my_global_stack = [];
yourfunction = function() {
//Chomp the stack
var dict = my_global_stack.pop();
//The name is the key at index 0
var name = Object.keys(dict)[0];
//Fetch the value by keyname:
var value = dict[name];
console.log(name); //prints foo
console.log(value); //prints bar
}
foo = "bar";
my_global_stack.push({foo});
yourfunction();
策略 3：
如果用户恶意输入不是问题，您可以使用eval( 重新发现给定变量名的值，例如：
yourfunction = function(somevariable) {
console.log(somevariable); //prints foo
console.log(eval(somevariable)); //prints bar
}
foo = "bar";
yourfunction("foo");
人们在这里说eval( 是邪恶的，因为如果恶意用户能够在任何时候覆盖内存中foo 的值，那么他们就可以进行操作系统命令注入并运行他们想要的任何命令。
http://cwe.mitre.org/top25/#Guidance
【讨论】：
var x = "anything";
function showName(s) {
alert(s + " = " + eval(s));
}
showName("x");
不推荐，但是有。
【讨论】：
您可以创建一个哈希并将其传入：
var x = {a: 1,b:2}
function showVars(y) {
for (var z in y) { alert(z + " is " + y[z]); }
}
showVars(x);
这不一定显示变量的名称，但它确实允许键值对，这可能更符合您的需要。
【讨论】：
这是我用来调试的。没有全局变量，没有 eval，没有 arguments.callee 或 arguments.caller：
var Helpers = (function () {
// ECMAScript 5 strict mode
'use strict';
var Module = {};
Module.debug = function () {
var i;
for (i = 0; i < arguments.length; i++) {
console.log(arguments[i] + ':', this[arguments[i]]);
}
};
Module.SomeObject = function SomeObject() {
this.someMember = 1;
this.anotherMember = 'Whatever';
Module.debug.call(this, 'someMember', 'anotherMember');
var privateMember = {
name: 'Rip Steakface',
battleCry: 'Raaaaaaaaahhhhhhhhhrrrrrrrrrg!'
};
Module.debug.call(privateMember, 'name', 'battleCry');
};
return Module;
}());
对于那些想知道为什么要这样做的人来说，这只是一种有效地记录多个变量及其名称的方法。
如果您希望能够记录嵌套成员，如Module.debug.call(obj, 'hair.fluffiness')，您可以像这样修改函数：
Module.debug = function () {
var i, j, props, tmp;
for (i = 0; i < arguments.length; i++) {
tmp = this;
props = arguments[i].split('.');
for (j = 0; j < props.length; j++) {
tmp = tmp[props[j]];
}
console.log(arguments[i] + ':', tmp);
}
};
不幸的是，我找不到任何方法来有效地记录多个不是对象成员的私有变量，例如var roll = 3, value = 4; Module.debug.call(???);
【讨论】：
不确定你是否可以直接从 JavaScript 中得到你想要的，因为变量名没有与它引用的值一起携带（把变量名想象成只有编译器知道的标识符；但是在运行时被丢弃）。
但是，您可以做一些稍微不同的事情，这允许传递命名参数。创建一个匿名对象并将其传递给您的函数：
function showNames(o)
{
for( var ix in o )
{
alert( ix + ":" + o[ix] );
}
}
var z = { x : "Anything" }
showNames( z );
// or
showNames( { a : "ay", b : "bee", c: "see" } )
对于迭代对象属性，我倾向于使用函数式，例如：
Array.iteri = function(o, f)
{
for(var i in o) { f(i, o[i]) }
}
function showNames(o)
{
Array.iteri( o, function(i,v)
{
alert( i + ": " + v )
});
}
showNames( { a : "ay", b : "bee", c: "see" } )
【讨论】：
下面的代码是你能做的最好的。不幸的是，函数中的局部变量是隐藏调用对象的属性，因此无法从像 window[a] 这样的 Javascript 中访问它们，其中 a 是窗口对象的属性。
x = "this is x";
var say = function(a) {
document.write(a + " = " + window[a]);
}
say("x");
var wrapper = function () {
var x = "this is x";
document.write(x + " = " + eval("x"))
}
wrapper()
【讨论】：