eval 啥意思？

Posted 2023-05-17

function myselect(t)
var checked_tmp=document.all.checked_tmp.value;
if(t!=checked_tmp)

eval("document.all.t"+t+".className='clicked';");
eval("if(checked_tmp!='')document.all.t"+checked_tmp+".className='';");
document.all.checked_tmp.value=t;
<%if allow_edit then %>
document.all.B2.disabled=false;
<%end if%>




里面的eval（）是什么意思

1. 和其他解释性语言一样，javascript 同样可以解释运行由javascript源代码组成的字符串，javascript 通过eval()来完成。
2. eval() 其实是一个函数，是javascript很早版本中就已经存在，但是javascript设计者和解释器对其进行了许多的限制，看起来eval更像一个运算符。但是作为用于动态执行代码，eval存在这样的问题，解释器无法对动态代码做进一步的优化。如果将它看做一个函数，那它是可以被赋予其他名字的：
var A = eval;
var B = A;
如果是这样的话，那么解释器就无法优化调用B()的函数了。因此设计者赋予eval一些运算符的特性（作为保留字）之后这些问题得到解决。当然它还有更多的限制，留待读者慢慢体会。

3. Eval 只有一个参数，如果传入的不是字符串的话，它直接返回这个参数；如果是字符串，那么首先会进行编译，如编译失败则爆出语法错误；编译成功则执行代码。更主要的是eval可以使用调用它的变量作用域环境，也就是说它查找的变量或者新增的变量作用域跟代码的完全一样。
如：
function A()

eval(\'var x ;\');
eval("x=1"); //在一个函数中定义或者更改，那就是针对局部变量。


4. 全局eval
eval 可以动态执行代码，并申明或者改变变量，当然可以对全局变量进行上述操作。如
var globalEval = eval; //定义全局eval函数别名
var a =\'global\', b = \'global\'; //全局变量
function c()

var a = \'local\'; //局部变量
eval(\'a+="changed"\'); //直接更改局部变量的值
return a; //返回更改后的局部变量

function d()

var b = \'local\';
globalEval("b+=\'changed\'");
return b;


console.log(c(), a); //localchanged global
console.log(d() , b) //local globalchanged
更强的是，全局的eval还可以更改局部变量的能力，不过这也是javascript优化的一个大问题。 当然在严格模式下，eval更像一个运算符，不可以用别名来覆盖eval。 参考技术A eval,执行字符串的内容
eval("document.all.t"+t+".className='clicked';");
比如t=2这一句意思就是
document.all.t2.className='clicked';本回答被提问者采纳 参考技术B eval 函数允许 JScript 源代码的动态执行。

eval、exec 和 compile 有啥区别？

【中文标题】eval、exec 和 compile 有啥区别？

【英文标题】：What's the difference between eval, exec, and compile?eval、exec 和 compile 有什么区别？

【发布时间】：2011-01-14 07:26:13

【问题描述】：

我一直在研究 Python 代码的动态评估，遇到了 eval() 和 compile() 函数，以及 exec 语句。

谁能解释一下eval和exec之间的区别，以及compile()的不同模式如何适应？

【参考方案1】：

简短的回答，或 TL;DR

基本上，eval 用于评估单个动态生成的 Python 表达式，exec 用于执行仅针对其动态生成的 Python 代码副作用。

eval和exec有这两个区别：

eval 只接受一个单个表达式，exec 可以采用包含 Python 语句的代码块：循环、try: except:、class 和函数/方法definitions 和很快。

Python 中的表达式可以作为变量赋值中的任何值：

a_variable = (anything you can put within these parentheses is an expression)

eval 返回给定表达式的值，而 exec 忽略其代码中的返回值，并始终返回 None（在 Python 2 中它是一个语句并且不能用作表达式，所以它真的不返回任何东西）。

在 1.0 - 2.7 版本中，exec 是一个语句，因为 CPython 需要为使用 exec 的函数生成不同类型的代码对象，因为它在函数内部产生副作用。

在 Python 3 中，exec 是一个函数；它的使用对使用它的函数的编译字节码没有影响。

---

因此基本上：

>>> a = 5
>>> eval('37 + a')   # it is an expression
42
>>> exec('37 + a')   # it is an expression statement; value is ignored (None is returned)
>>> exec('a = 47')   # modify a global variable as a side effect
>>> a
47
>>> eval('a = 47')  # you cannot evaluate a statement
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    a = 47
      ^
SyntaxError: invalid syntax

---

compile 在'exec' 模式下将任意数量的语句编译成隐式总是返回None 的字节码，而在'eval' 模式下它将单个 表达式编译成 em>返回该表达式的值。

>>> eval(compile('42', '<string>', 'exec'))  # code returns None
>>> eval(compile('42', '<string>', 'eval'))  # code returns 42
42
>>> exec(compile('42', '<string>', 'eval'))  # code returns 42,
>>>                                          # but ignored by exec

在'eval' 模式下（如果传入字符串，则使用eval 函数），如果源代码包含语句或超出单个表达式的任何其他内容，compile 将引发异常：

>>> compile('for i in range(3): print(i)', '<string>', 'eval')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    for i in range(3): print(i)
      ^
SyntaxError: invalid syntax

---

实际上，“eval 只接受一个表达式” 语句仅适用于将字符串（包含 Python 源代码）传递给 eval 时。然后使用compile(source, '<string>', 'eval')在内部编译成字节码，这才是真正的区别所在。

如果将 code 对象（包含 Python 字节码）传递给 exec 或 eval，它们的行为相同，除了 @ 987654375@ 忽略返回值，始终返回None。所以可以使用eval 来执行有语句的东西，如果你只是在compiled 之前把它转换成字节码而不是将它作为字符串传递：

>>> eval(compile('if 1: print("Hello")', '<string>', 'exec'))
Hello
>>>

即使编译后的代码包含语句，也可以正常工作。它仍然返回None，因为这是从compile返回的代码对象的返回值。

在'eval' 模式下（如果传入字符串，则使用eval 函数），如果源代码包含语句或超出单个表达式的任何其他内容，compile 将引发异常：

>>> compile('for i in range(3): print(i)', '<string>'. 'eval')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    for i in range(3): print(i)
      ^
SyntaxError: invalid syntax

更长的答案，也就是血淋淋的细节

exec 和 eval

exec 函数（原为a statement in Python 2）用于执行动态创建的语句或程序：

>>> program = '''
for i in range(3):
    print("Python is cool")
'''
>>> exec(program)
Python is cool
Python is cool
Python is cool
>>> 

eval 函数对single expression 执行相同的操作，并且返回表达式的值：

>>> a = 2
>>> my_calculation = '42 * a'
>>> result = eval(my_calculation)
>>> result
84

exec 和 eval 都接受程序/表达式作为包含源代码的 str、unicode 或 bytes 对象运行，或者作为 code 对象运行 em> 其中包含 Python 字节码。

如果将包含源代码的str/unicode/bytes 传递给exec，则其行为等同于：

exec(compile(source, '<string>', 'exec'))

和eval 的行为类似：

eval(compile(source, '<string>', 'eval'))

---

由于所有表达式都可以用作 Python 中的语句（这些在 Python 中称为 Expr 节点 abstract grammar；反之则不然），如果您不需要返回，则始终可以使用 exec价值。也就是说eval('my_func(42)')或者exec('my_func(42)')都可以使用，区别在于eval返回的是my_func返回的值，而exec将其丢弃：

>>> def my_func(arg):
...     print("Called with %d" % arg)
...     return arg * 2
... 
>>> exec('my_func(42)')
Called with 42
>>> eval('my_func(42)')
Called with 42
84
>>> 

在这 2 个中，只有 exec 接受包含语句的源代码，例如 def、for、while、import 或 class，赋值语句（又名 a = 42），或整个程序：

>>> exec('for i in range(3): print(i)')
0
1
2
>>> eval('for i in range(3): print(i)')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    for i in range(3): print(i)
      ^
SyntaxError: invalid syntax

---

exec 和 eval 都接受 2 个额外的位置参数 - globals 和 locals - 这是代码看到的全局和局部变量范围。这些默认为globals() 和locals() 在称为exec 或eval 的范围内，但任何字典都可以用于globals 和任何mapping 用于locals（当然包括dict ）。这些不仅可以用来限制/修改代码看到的变量，还经常用于捕获executed 代码创建的变量：

>>> g = dict()
>>> l = dict()
>>> exec('global a; a, b = 123, 42', g, l)
>>> g['a']
123
>>> l
'b': 42

（如果显示整个g 的值，会更长，因为exec 和eval 将内置模块作为__builtins__ 自动添加到全局变量中，如果它缺失）。

在 Python 2 中，exec 语句的官方语法实际上是 exec code in globals, locals，如

>>> exec 'global a; a, b = 123, 42' in g, l

不过，替代语法 exec(code, globals, locals) 也一直被接受（见下文）。

compile

通过预先将源代码编译为code 对象，可以使用内置的compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) 来加速使用exec 或eval 重复调用相同的代码。 mode 参数控制compile 函数接受的代码片段类型以及它产生的字节码类型。选项有'eval'、'exec' 和'single'：

'eval' 模式需要一个表达式，并且会生成字节码，运行时会返回那个表达式的值：

>>> dis.dis(compile('a + b', '<string>', 'eval'))
  1           0 LOAD_NAME                0 (a)
              3 LOAD_NAME                1 (b)
              6 BINARY_ADD
              7 RETURN_VALUE

'exec' 接受从单个表达式到整个代码模块的任何类型的 python 构造，并像执行模块***语句一样执行它们。代码对象返回None：

>>> dis.dis(compile('a + b', '<string>', 'exec'))
  1           0 LOAD_NAME                0 (a)
              3 LOAD_NAME                1 (b)
              6 BINARY_ADD
              7 POP_TOP                             <- discard result
              8 LOAD_CONST               0 (None)   <- load None on stack
             11 RETURN_VALUE                        <- return top of stack

'single' 是'exec' 的有限形式，如果最后一个语句是表达式语句，则它接受包含单个 语句（或由; 分隔的多个语句）的源代码，结果字节码还将该表达式的值的repr 打印到标准输出（！）。

if-elif-else 链、带有else 和try 及其except、else 和finally 块的循环被视为单个语句。

包含 2 个***语句的源代码片段对于 'single' 来说是一个错误，但在 Python 2 中存在一个错误，有时允许代码中有多个***语句；只有第一个被编译；其余的被忽略：

在 Python 2.7.8 中：

>>> exec(compile('a = 5\na = 6', '<string>', 'single'))
>>> a
5

在 Python 3.4.2 中：

>>> exec(compile('a = 5\na = 6', '<string>', 'single'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    a = 5
        ^
SyntaxError: multiple statements found while compiling a single statement

这对于制作交互式 Python shell 非常有用。但是，表达式的值不会返回，即使你eval 得到的代码也是如此。

因此exec 和eval 的最大区别实际上来自compile 函数及其模式。

---

除了将源代码编译成字节码，compile还支持将abstract syntax trees（Python代码的解析树）编译成code对象；并将源代码转换为抽象语法树（ast.parse 是用 Python 编写的，只调用 compile(source, filename, mode, PyCF_ONLY_AST)）；例如，它们用于动态修改源代码，也用于动态代码创建，因为在复杂情况下，将代码作为节点树而不是文本行来处理通常更容易。

---

虽然eval 只允许您评估包含单个表达式的字符串，但您可以eval 整个语句，甚至可以将整个模块compiled 转换为字节码；也就是说，在 Python 2 中，print 是一个语句，不能直接为evalled：

>>> eval('for i in range(3): print("Python is cool")')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    for i in range(3): print("Python is cool")
      ^
SyntaxError: invalid syntax

compile它与'exec'模式转换成一个code对象，你可以eval它; eval 函数将返回 None。

>>> code = compile('for i in range(3): print("Python is cool")',
                   'foo.py', 'exec')
>>> eval(code)
Python is cool
Python is cool
Python is cool

如果查看 CPython 3 中的 eval 和 exec 源代码，这是非常明显的；他们都使用相同的参数调用PyEval_EvalCode，唯一的区别是exec explicitly returns None。

Python 2 和 Python 3 之间exec 的语法差异

Python 2 的主要区别之一是exec 是一个语句，eval 是一个内置函数（两者都是 Python 3 中的内置函数）。 众所周知，Python 2 中exec 的官方语法是exec code [in globals[, locals]]。

与大多数 Python 2-to-3 porting guides seem to suggest 不同，CPython 2 中的 exec 语句也可以与 看起来 完全是类似于 Python 3 中的 exec 函数调用。原因是 Python 0.9.9 具有 exec(code, globals, locals) 内置函数！并且该内置函数被替换为exec 语句somewhere before Python 1.0 release。

由于不希望破坏与 Python 0.9.9 的向后兼容性，Guido van Rossum added a compatibility hack in 1993：如果 code 是长度为 2 或 3 的元组，并且 globals 和 locals 未传递到 @ 987654511@ 声明，否则，code 将被解释为元组的第二个和第三个元素分别是 globals 和 locals。即使在Python 1.4 documentation (the earliest available version online) 中也没有提到兼容性黑客；因此，许多移植指南和工具的作者并不知道，直到 documented 又是 in November 2012：

第一个表达式也可以是长度为 2 或 3 的元组。在这种情况下，必须省略可选部分。 exec(expr, globals) 等价于exec expr in globals，而exec(expr, globals, locals) 等价于exec expr in globals, locals。 exec 的元组形式提供了与 Python 3 的兼容性，其中 exec 是一个函数而不是语句。

是的，在 CPython 2.7 中，它被方便地称为前向兼容选项（为什么人们会因为完全有后向兼容选项而感到困惑）， 当它实际上已经存在了 20 年的向后兼容性。

因此，exec 在 Python 1 和 Python 2 中是一个语句，在 Python 3 和 Python 0.9.9 中是一个内置函数，

>>> exec("print(a)", globals(), 'a': 42)
42

可能在每个广泛发布的 Python 版本中都有相同的行为；并在 Jython 2.5.2、PyPy 2.3.1 (Python 2.7.6) 和 IronPython 2.6.1 中工作（对他们密切关注 CPython 的未记录行为表示赞赏）。

在 Python 1.0 - 2.7 及其兼容性黑客中，你不能做的是将 exec 的返回值存储到一个变量中：

Python 2.7.11+ (default, Apr 17 2016, 14:00:29) 
[GCC 5.3.1 20160413] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = exec('print(42)')
  File "<stdin>", line 1
    a = exec('print(42)')
           ^
SyntaxError: invalid syntax

（这在 Python 3 中也没有用，因为 exec 总是返回 None），或者传递对 exec 的引用：

>>> call_later(exec, 'print(42)', delay=1000)
  File "<stdin>", line 1
    call_later(exec, 'print(42)', delay=1000)
                  ^
SyntaxError: invalid syntax

某人可能实际使用过的模式，尽管不太可能；

或者在列表推导中使用它：

>>> [exec(i) for i in ['print(42)', 'print(foo)']
  File "<stdin>", line 1
    [exec(i) for i in ['print(42)', 'print(foo)']
        ^
SyntaxError: invalid syntax

这是对列表推导的滥用（请改用for 循环！）。

【讨论】：

[i for i in globals().values() if hasattr(i, '__call__')][0] 是语句还是表达式？如果是表达式，为什么不能用@作为装饰器呢？

这是一个表达式。 42 也是一个表达式，不能和@ 一起作为装饰器使用。

装饰器语法为decorator ::= "@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE；即你不能使用任意表达式作为装饰器，只能使用一个（可能是虚线的）标识符，后跟可选的调用参数。

没有任何东西可以放在赋值的右侧并且仍然可以编译是表达式。例如，a = b = c 是一个完全有效的语句，它的右侧 b = c 也是如此 - 这不是一个表达式。

值得一提的是ast.literal_eval，它比eval 和exec 更受限制但使用起来也更安全。我经常使用它来评估可能代表bool、int、float、...的字符串。

【参考方案2】：

exec 不是表达式：Python 2.x 中的语句和 Python 3.x 中的函数。它编译并立即评估字符串中包含的语句或语句集。示例：

 exec('print(5)')           # prints 5.
 # exec 'print 5'     if you use Python 2.x, nor the exec neither the print is a function there
 exec('print(5)\nprint(6)')  # prints 5newline6.
 exec('if True: print(6)')  # prints 6.
 exec('5')                 # does nothing and returns nothing.

eval 是一个内置函数（不是语句），它计算表达式并返回表达式产生的值。示例：

 x = eval('5')              # x <- 5
 x = eval('%d + 6' % x)     # x <- 11
 x = eval('abs(%d)' % -100) # x <- 100
 x = eval('x = 5')          # INVALID; assignment is not an expression.
 x = eval('if 1: x = 4')    # INVALID; if is a statement, not an expression.

compile 是exec 和eval 的较低级别版本。它不会执行或评估您的语句或表达式，而是返回一个可以执行此操作的代码对象。模式如下：

compile(string, '', 'eval') 返回如果你完成eval(string) 将会执行的代码对象。请注意，您不能在此模式下使用语句；只有一个（单个）表达式是有效的。

compile(string, '', 'exec') 返回如果您完成exec(string) 将执行的代码对象。您可以在此处使用任意数量的语句。

compile(string, '', 'single') 类似于exec 模式，但只需要一个表达式/语句，例如compile('a=1 if 1 else 3', 'myf', mode='single')

【讨论】：

在 Python 3 中，exec() 现在实际上是一个函数。

因为（正如您所指出的），exec 是您所针对的版本中的一个声明，包含这些括号具有欺骗性，如果您尝试使用 in globals, locals，也会出现问题。

@MikeGraham exec 支持括号和 Python 2 中类似调用的函数。

@AnttiHaapala 就分配“支持括号”而言，因为您可以执行x = (y)，这可能是真的。另一个语句转函数是print；在python 2和3中比较print(1, 2, 3)的结果。

@habnabit 不是这样的。请在此处阅读my answer 的底部并感到惊讶。

【参考方案3】：

exec 是 for 语句，不返回任何内容。 eval 用于表达式，返回表达式的值。

表达式的意思是“某事”，而语句的意思是“做某事”。

【讨论】：

第二段被简化得几乎成了一个谎言，一个表达式如果包含一个函数调用就可以做很多事情。