From Wikipedia, the free encyclopedia
by squaring is a general method for fast computation of large
powers of a , or more generally of an element of a , like a
or a . Some variants are commonly referred to as square-and-multiply algorithms or binary exponentiation. These can be of quite general use, for example in
or powering of matrices. For semigroups for which
is commonly used, like
used in , this method is also referred to as double-and-add.
The method is based on the observation that, for a positive integer n, we have
 is odd
 is even
{\displaystyle x^{n}={\begin{cases}x\,(x^{2})^{\frac {n-1}{2}},&{\mbox{if }}n{\mbox{ is odd}}\\(x^{2})^{\frac {n}{2}},&{\mbox{if }}n{\mbox{ is even}}.\end{cases}}}
This method uses the bits of the exponent to determine which powers are computed.
This example shows how to compute
{\displaystyle x^{13}}
using this method. The exponent, 13, is 1101 in binary. The bits are used in left to right order. The exponent has 4 bits, so there are 4 iterations.
First, initialize the result to 1:
{\displaystyle r\leftarrow 1\,(=x^{0})}
{\displaystyle r\leftarrow r^{2}\,(=x^{0})}
; bit 1 = 1, so compute
{\displaystyle r\leftarrow r\cdot x\,(=x^{1})}
{\displaystyle r\leftarrow r^{2}\,(=x^{2})}
; bit 2 = 1, so compute
{\displaystyle r\leftarrow r\cdot x\,(=x^{3})}
{\displaystyle r\leftarrow r^{2}\,(=x^{6})}
; bit 3 = 0, so we are
{\displaystyle r\leftarrow r^{2}\,(=x^{12})}
; bit 4 = 1, so compute
{\displaystyle r\leftarrow r\cdot x\,(=x^{13})}
This may be implemented as the following :
Function exp_by_squaring(x, n)
then return exp_by_squaring(1 / x, -n);
else if n = 0
then return
else if n = 1
then return
else if n is even
then return exp_by_squaring(x * x,
else if n is odd
then return x * exp_by_squaring(x * x, (n - 1) / 2);
Although not , this algorithm may be rewritten into a tail recursive algorithm by introducing an auxiliary function:
Function exp_by_squaring(x, n)
exp_by_squaring2(1, x, n)
Function exp_by_squaring2(y, x, n)
then return exp_by_squaring2(y, 1 / x, - n);
else if n = 0
then return
else if n = 1
then return
else if n is even
then return exp_by_squaring2(y, x * x,
else if n is odd
then return exp_by_squaring2(x * y, x * x, (n - 1) / 2).
The iterative version of the algorithm also uses a bounded auxiliary space, and is given by
Function exp_by_squaring_iterative(x, n)
if n & 0 then
x := 1 / x;
if n = 0 then return 1
while n & 1 do
if n is even then
x := x * x;
n := n / 2;
y := x * y;
x := x * x;
n := (n – 1) / 2;
return x * y
A brief analysis shows that such an algorithm uses
{\displaystyle \lfloor \log _{2}n\rfloor }
squarings and at most
{\displaystyle \lfloor \log _{2}n\rfloor }
multiplications, where
{\displaystyle \lfloor \;\rfloor }
denotes the . More precisely, the number of multiplications is one less than the number of ones present in the
of n. For n greater than about 4 this is computationally more efficient than naively multiplying the base with itself repeatedly.
Each squaring results in approximately double the number of digits of the previous, and so, if multiplication of two d digit numbers is implemented in O(dk) operations for some fixed k then the complexity of computing xn is given by:
{\displaystyle \sum \limits _{i=0}^{O(\log(n))}(2^{i}O(\log(x)))^{k}=O((n\log(x))^{k})}
This algorithm calculates the value of xn after expanding the exponent in base 2k. It was first proposed by
in 1939. In the algorithm below we make use of the following function f(0) = (k,0) and f(m) = (s,u) where m = u·2s with u odd.
Algorithm:
An element x of G, a parameter k & 0, a non-negative integer n = (nl-1, nl-2, ..., n0)2k and the precomputed values
{\displaystyle x^{3},x^{5},...,x^{2^{k}-1}}
The element xn in G
1. y := 1; i := l-1
2. while i&=0 do
(s,u) := f(ni)
for j:=1 to k-s do
for j:=1 to s do
10. return y
For optimal efficiency, k should be the smallest integer satisfying
{\displaystyle \log(n)&{\frac {k(k+1)\cdot 2^{2k}}{2^{k+1}-k-2}}+1.}
This method is an efficient variant of the 2k-ary method. For example, to calculate the exponent 398 which has binary expansion (110 001 110)2, we take a window of length 3 using the 2k-ary method algorithm we calculate 1,x3,x6,x12,x24,x48,x49,x98,x99,x198,x199,x398. But, we can also compute 1,x3,x6,x12,x24,x48,x96,x192,x199, x398 which saves one multiplication and amounts to evaluating (110 001 110)n2
Here is the general algorithm:
Algorithm:
An element x of G,a non negative integer n=(nl-1,nl-2,...,n0)2, a parameter k&0 and the pre-computed values
{\displaystyle x^{3},x^{5},...,x^{2^{k}-1}}
The element xn ∈ G
Algorithm:
y := 1; i := l-1
while i & -1 do
if ni=0 then y:=y2' i:=i-1
s:=max{i-k+1,0}
while ns=0 do s:=s+1
for h:=1 to i-s+1 do y:=y2
u:=(ni,ni-1,....,ns)2
11. return y
Many algorithms for exponentiation do not provide defence against . Namely, an attacker observing the sequence of squarings and multiplications can (partially) recover the exponent involved in the computation. This is a problem if the exponent should remain secret, as with many . A technique called
Ladder addresses this concern.
of a positive, non-zero integer n=(nk-1...n0)2 with nk-1=1 we can compute xn as follows:
x1=x; x2=x2
for i=k-2 to 0 do
If ni=0 then
x2=x1*x2; x1=x12
x1=x1*x2; x2=x22
The algorithm performs a fixed sequence of operations ( log n): a multiplication and squaring takes place for each bit in the exponent, regardless of the bit's specific value.
This specific implementation of Montgomery's ladder is not yet protected against cache : memory access latencies might still be observable to an attacker as you access different variables depending on the value of bits of the secret exponent.
There are several methods which can be employed to calculate xn when the base is fixed and the exponent varies. As one can see,
play a key role in these algorithms.
Yao's method is orthogonal to the 2k-ary method where the exponent is expanded in radix b=2k and the computation is as performed in the algorithm above. Let "n", "ni", "b", and "bi" be integers.
Let the exponent "n" be written as
{\displaystyle n=\sum _{i=0}^{w-1}n_{i}b_{i}}
{\displaystyle 0\leqslant n_{i}&h}
{\displaystyle i\in [0,w-1]}
Let xi = xbi. Then the algorithm uses the equality
{\displaystyle x^{n}=\prod _{i=0}^{w-1}{x_{i}}^{n_{i}}=\prod _{j=1}^{h-1}{{\bigg [}\prod _{n_{i}=j}x_{i}{\bigg ]}}^{j}}
Given the element 'x' of G, and the exponent 'n' written in the above form, along with the precomputed values xb0....xbw-1 the element xn is calculated using the algorithm below.
y=1,u=1 and j=h-1
while j & 0 do
for i=0 to w-1 do
if ni=j then u=u*xbi
If we set h=2k and bi = hi then the ni's are simply the digits of n in base h. Yao's method collects in u first those xi which appear to the highest power
{\displaystyle h-1}
; in the next round those with power
{\displaystyle h-2}
are collected in u as well etc. The variable y is multiplied
{\displaystyle h-1}
times with the initial u,
{\displaystyle h-2}
times with the next highest powers etc. The algorithm uses
{\displaystyle w+h-2}
multiplications and
{\displaystyle w+1}
elements must be stored to compute xn.
The Euclidean method was first introduced in Efficient exponentiation using precomputation and vector addition chains by P.D Rooij.
This method for computing
{\displaystyle x^{n}}
in group G, where n is a natural integer, whose algorithm is given below, is using the following equality recursively:
{\displaystyle {x_{0}}^{n_{0}}\cdot {x_{1}}^{n_{1}}={\left(x_{0}\cdot {x_{1}}^{q}\right)}^{n_{0}}\cdot {x_{1}}^{n_{1}\mod {n_{0}}}}
{\displaystyle q=\left\lfloor {\frac {n_{1}}{n_{0}}}\right\rfloor }
(in other words a Euclidean division of the exponent n1 by n0 is used to return a quotient q and a rest n1 mod n0).
Given the base element x in group G, and the exponent
{\displaystyle n}
written as in Yao's method, the element
{\displaystyle x^{n}}
is calculated using
{\displaystyle l}
precomputed values
{\displaystyle x^{b_{0}},...,x^{b_{l_{i}}}}
and then the algorithm below.
Begin loop
{\displaystyle M\in \left[0,l-1\right]}
, such that
{\displaystyle \forall i\in \left[0,l-1\right],{n_{M}}\geq {n_{i}}}
{\displaystyle N\in \left(\left[0,l-1\right]-M\right)}
, such that
{\displaystyle \forall i\in \left(\left[0,l-1\right]-M\right),{n_{N}}\geq {n_{i}}}
Break loop if
{\displaystyle {n_{N}}=0}
{\displaystyle q=\left\lfloor {n_{M}}/{n_{N}}\right\rfloor }
, and then let
{\displaystyle {n_{N}}=\left({n_{M}}{\bmod {n_{N}}}\right)}
Compute recursively
{\displaystyle {x_{M}}^{q}}
, and then let
{\displaystyle {x_{N}}={x_{N}}\cdot {x_{M}}^{q}}
{\displaystyle x^{n}={x_{M}}^{n_{M}}}
The algorithm first finds the largest value amongst the ni and then the supremum within the set of { ni \ i ≠ M }. Then it raises xM to the power q, multiplies this value with xN, and then assigns xN the result of this computation and nM the value nM modulo nN.
The same idea allows fast computation of large
a number. Especially in , it is useful to compute powers in a
of . It can also be used to compute integer powers in a , using the rule
Power(x, -n) = (Power(x, n))-1.
The method works in every
and is often used to compute powers of .
For example, the evaluation of
13789722341 (mod 2345)
would take a very long time and lots of storage space if the na?ve method were used: compute 13789722341 then take the
when divided by 2345. Even using a more effective method will take a long time: square 13789, take the remainder when divided by 2345, multiply the
by 13789, and so on. This will take less than
{\displaystyle 2\log _{2}(722340)\leq 40}
modular multiplications.
Applying above exp-by-squaring algorithm, with "*" interpreted as x*y = xy mod 2345 (that is a multiplication followed by a division with remainder) leads to only 27 multiplications and divisions of integers which may all be stored in a single machine word.
This is a non-recursive implementation of the above algorithm in .
n=n-1 is redundant when n=n/2 implicitly rounds towards zero, as lower level languages would do. n[0] is the rightmost bit of the binary representation of n, so if it is 1, the number is odd, if it is zero, the number is even. It is also n modulo 2.
def power(x,n)
result = 1
while n.nonzero?
if n[0].nonzero?
result *= x
return result
parameter x =
parameter n = 10
result := 1
Iteration 1
n = 10 -& n is even
x := x2 = 32 = 9
n := n / 2 = 5
Iteration 2
n = 5 -& n is odd
-& result := result * x = 1 * x = 1 * 32 = 9
n := n - 1 = 4
x := x2 = 92 = 34 = 81
n := n / 2 = 2
Iteration 3
n = 2 -& n is even
x := x2 = 812 = 38 = 6561
n := n / 2 = 1
Iteration 4
n = 1 -& n is odd
-& result := result * x = 32 * 38 = 310 = 9 * 6561 = 59049
n := n - 1 = 0
return result
result := 3
bin := "1010"
Iteration for digit 2:
result := result2 = 32 = 9
1010bin - Digit equals "0"
Iteration for digit 3:
result := result2 = (32)2 = 34
1010bin - Digit equals "1" --& result := result*3 = (32)2*3 = 35
Iteration for digit 4:
result := result2 = ((32)2*3)2 = 310
1010bin - Digit equals "0"
return result
JavaScript-Demonstration:
Exponentiation by squaring may also be used to calculate the product of 2 or more powers. If the underlying group or semigroup is
then it is often possible to reduce the number of multiplications by computing the product simultaneously.
The formula a7×b5 may be calculated within 3 steps:
((a)2×a)2×a (four multiplications for calculating a7)
((b)2)2×b (three multiplications for calculating b5)
(a7)×(b5) (one multiplication to calculate the product of the two)
so one gets eight multiplications in total.
A faster solution is to calculate both powers simultaneously:
((a×b)2×a)2×a×b
which needs only 6 multiplications in total. Note that a×b the result could be stored after the first calculation, which reduces the count of multiplication to 5.
Example with numbers:
27×35 = ((2×3)2×2)2×2×3 = (62×2)2×6 = 722×6 = 31,104
Calculating the powers simultaneously instead of calculating them separately always reduces the count of multiplications if at least two of the exponents are greater than 1.
The example above a7×b5 may also be calculated with only 5 multiplications if the expression is transformed before calculation:
a7×b5 = a2×(ab)5 with ab := a×b
ab := a×b (one multiplication)
a2×(ab)5 = ((ab)2×a)2×ab (four multiplications)
Generalization of transformation shows the following scheme:
For calculating aA×bB×...×mM×nN
1st: define ab := a×b, abc = ab×c, ...
2nd: calculate the transformed expression aA-B×abB-C×...×abc..mM-N×abc..mnN
Transformation before calculation often reduces the count of multiplications but in some cases it also increases the count (see the last one of the examples below), so it may be a good idea to check the count of multiplications before using the transformed expression for calculation.
For the following expressions the count of multiplications is shown for calculating each power separately, calculating them simultaneously without transformation, and calculating them simultaneously after transformation.
a7×b5×c3
a5×b5×c3
a7×b4×c1
[((a)2×a)2×a] × [((b)2)2×b] × [(c)2×c]
( 11 multiplications )
[((a)2)2×a] × [((b)2)2×b] × [(c)2×c]
( 10 multiplications )
[((a)2×a)2×a] × [((b)2)2] × [c]
( 8 multiplications )
simultaneous
((a×b)2×a×c)2×a×b×c
( 8 multiplications )
((a×b)2×c)2×a×b×c
( 7 multiplications )
((a×b)2×a)2×a×c
( 6 multiplications )
transformation
a := 2   ab := a×b   abc := ab×c
( 2 multiplications )
a := 2   ab := a×b   abc := ab×c
( 2 multiplications )
a := 2   ab := a×b   abc := ab×c
( 2 multiplications )
calculation after that
(a×ab×abc)2×abc
( 4 multiplications => 6 in total )
(ab×abc)2×abc
( 3 multiplications => 5 in total )
(a×ab)2×a×ab×abc
( 5 multiplications => 7 in total )
In certain computations it may be more efficient to allow negative coefficients and hence use the inverse of the base, provided inversion in G is 'fast' or has been precomputed. For example, when computing x2k-1 the binary method requires k-1 multiplications and k-1 squarings. However one could perform k squarings to get x2k and then multiply by x-1 to obtain x2k-1.
To this end we define the
of an integer n in radix b as
 with 
{\displaystyle n=\sum _{i=0}^{l-1}n_{i}b^{i}{\text{
}}|n_{i}|&b}
Signed binary representation corresponds to the particular choice b=2 and
{\displaystyle n_{i}\in \{-1,0,1\}}
. It is denoted by
{\displaystyle (n_{l-1}\dots n_{0})_{s}}
. There are several methods for computing this representation. The representation is not unique, for example take n=478. Two distinct signed-binary representations are given by
{\displaystyle (10{\bar {1}}1100{\bar {1}}10)_{s}}
{\displaystyle (100{\bar {1}}1000{\bar {1}}0)_{s}}
{\displaystyle {\bar {1}}}
is used to denote -1. Since the binary method computes a multiplication for every non-zero entry in the base 2 representation of n, we are interested in finding the signed-binary representation with the smallest number of non-zero entries, that is, the one with minimal . One method of doing this is to compute the representation in , or NAF for short, which is one that satisfies
 for all 
{\displaystyle n_{i}n_{i+1}=0{\text{ for all }}i\geqslant 0}
and denoted by
{\displaystyle (n_{l-1}\dots n_{0})_{\text{NAF}}}
. For example the NAF representation of 478 is equal to
{\displaystyle (1000{\bar {1}}000{\bar {1}}0)_{\text{NAF}}}
. This representation always has minimal Hamming weight. A simple algorithm to compute the NAF representation of a given integer
{\displaystyle n=(n_{l}n_{l-1}\dots n_{0})_{2}}
{\displaystyle n_{l}=n_{l-1}=0}
is the following:
{\displaystyle c_{0}=0}
for i = 0 to l - 1 do
{\displaystyle c_{i+1}=\left\lfloor {\frac {1}{2}}(c_{i}+n_{i}+n_{i+1})\right\rfloor }
{\displaystyle n_{i}'=c_{i}+n_{i}-2c_{i+1}}
{\displaystyle (n_{l-1}'\dots n_{0}')_{\text{NAF}}}
Another algorithm by Koyama and Tsuruoka does not require the condition that
{\displaystyle n_{i}=n_{i+1}=0}
; it still minimizes the Hamming weight.
Exponentiation by squaring can be viewed as a suboptimal
algorithm: it computes the exponent via an
consisting of repeated exponent doublings (squarings) and/or incrementing exponents by one (multiplying by x) only. More generally, if one allows any previously computed exponents to be summed (by multiplying those powers of x), one can sometimes perform the exponentiation using fewer multiplications (but typically using more memory). The smallest power where this occurs is for n=15:
{\displaystyle a^{15}=x\times (x\times [x\times x^{2}]^{2})^{2}\!}
(squaring, 6 multiplies)
{\displaystyle a^{15}=x^{3}\times ([x^{3}]^{2})^{2}\!}
(optimal addition chain, 5 multiplies if x3 is re-used)
In general, finding the optimal addition chain for a given exponent is a hard problem, for which no efficient algorithms are known, so optimal chains are typically only used for small exponents (e.g. in
where the chains for small powers have been pre-tabulated). However, there are a number of
algorithms that, while not being optimal, have fewer multiplications than exponentiation by squaring at the cost of additional bookkeeping work and memory usage. Regardless, the number of multiplications never grows more slowly than (log n), so these algorithms only improve asymptotically upon exponentiation by squaring by a constant factor at best.
In this line, the loop finds the longest string of length less than or equal to 'k' which ends in a non zero value. And not all odd powers of 2 up to
{\displaystyle x^{2^{k}-1}}
need be computed and only those specifically involved in the computation need be considered.
Cohen, H.; Frey, G., eds. (2006). Handbook of Elliptic and Hyperelliptic Curve Cryptography. Discrete Mathematics and Its Applications. Chapman & Hall/CRC.  .
Montgomery, Peter L. (1987).
(PDF). Math. Comput. 48 (177): 243–264.。l!命令格式：ls&[选项]&[目录名]命令功能：列出目标目录中所有的子目录和文件。常用参数：-a,&–all&列出目录下的所有文件，包括以&.&开头的隐含文件-c&&配合&-lt：根据&ctime&排序及显示&ctime&(文件状态最后更改的时间)配合&-l：显示&ctime&但根据名称排序否则：根据&ctime&排序：-l&除了文件名之外，还将文件的权限、所有者、文件大小等信息详细列出来。&&&常用范例：例一：列出/home/peidachang文件夹下的所有文件和目录的详细资料命令：ls&-l&-R&/home/peidachang在使用&ls&命令时要注意命令的格式：在命令提示符后，首先是命令的关键字，接下来是命令参数，在命令参数之前要有一短横线“-”，所有的命令参数都有特定的作用，自己可以根据需要选用一个或者多个参数，在命令参数的后面是命令的操作对象。在以上这条命令“&ls&-l&-R&/home/peidachang”中，“ls”&是命令关键字，“-l&-R”是参数，“&/home/peidachang”是命令的操作对象。在这条命令中，使用到了两个参数，分别为“l”和“R”，当然，你也可以把他们放在一起使用，如下所示：命令：ls&-lR&/home/peidachang这种形式和上面的命令形式执行的结果是完全一样的。另外，如果命令的操作对象位于当前目录中，可以直接对操作对象进行操作;如果不在当前目录则需要给出操作对象的完整路径，例如上面的例子中，我的当前文件夹是peidachang文件夹，我想对home文件夹下的peidachang文件进行操作，我可以直接输入&ls&-lR&peidachang，也可以用&ls&-lR&/home/peidachang。&例二：列出当前目录中所有以“t”开头的目录的详细内容，可以使用如下命令：命令：ls&-l&t*&&&可以查看当前目录下文件名以“t”开头的所有文件的信息。其实，在命令格式中，方括号内的内容都是可以省略的，对于命令ls而言，如果省略命令参数和操作对象，直接输入“&ls&”，则将会列出当前工作目录的内容清单。例三：文件下的命令：ls&-F&/opt/soft&|grep&/$&&列出&/opt/soft&文件下面的子目录输出：[root@localhost&opt]#&ls&-F&/opt/soft&|grep&/$jdk1.6.0_16/subversion-1.6.1/tomcat6.0.32/命令：ls&-l&/opt/soft&|&grep&"^d"列出&/opt/soft&文件下面的子目录详细情况输出：[root@localhost&opt]#&&ls&-l&/opt/soft&|&grep&"^d"drwxr-xr-x&10&root&root&&&&&&&18:17&jdk1.6.0_16drwxr-xr-x&16&&&&&&&&03:25&subversion-1.6.1drwxr-xr-x&&9&root&root&&&&&&-01&tomcat6.0.32例四：命令：输出：[root@localhost&opt]#&ls&-ltr&s*src:总计&0script:总计&0soft:总计&350644drwxr-xr-x&&9&root&root&&&&&&-01&tomcat6.0.32-rwxr-xr-x&&1&root&root&&-17&18:15&jdk-6u16-linux-x64.bindrwxr-xr-x&10&root&root&&&&&&&18:17&jdk1.6.0_16-rw-r--r--&&1&root&root&-17&18:33&apache-tomcat-6.0.32.tar.gz-rw-r--r--&&1&root&root&&&-21&00:23&tomcat6.0.32.tar.gz-rw-r--r--&&1&root&root&&&-10&11:08&subversion-deps-1.6.1.tar.gz-rw-r--r--&&1&root&root&&&-10&11:08&subversion-1.6.1.tar.gzdrwxr-xr-x&16&&&&&&&&03:25&subversion-1.6.1例五：命令：输出：[root@localhost&opt]#&ls&-AFlog/&&script/&&soft/&&src/&&svndata/&&web/例六：计算当前目录下的文件数和目录数命令：ls&-l&*&|grep&"^-"|wc&-l&---文件个数&&ls&-l&*&|grep&"^d"|wc&-l&&&&---目录个数例七:&在ls中列出文件的绝对路径命令：ls&|&sed&"s:^:`pwd`/:"输出：& & [root@localhost&opt]#&ls&|&sed&"s:^:`pwd`/:"&& & /opt/log& & /opt/script& & /opt/soft& & /opt/src& & /opt/svndata& & /opt/web例九：列出当前目录下的所有文件（包括隐藏文件）的绝对路径，&对目录不做递归命令：find&$PWD&-maxdepth&1&|&xargs&ls&-ld输出：[root@localhost&opt]#&find&$PWD&-maxdepth&1&|&xargs&ls&-lddrwxr-xr-x&8&root&root&&03:43&/optdrwxr-xr-x&2&root&root&-08&/opt/logdrwxr-xr-x&2&root&root&-08&/opt/scriptdrwxr-xr-x&5&root&root&&03:21&/opt/softdrwxr-xr-x&2&root&root&-08&/opt/srcdrwxr-xr-x&4&root&root&&05:22&/opt/svndatadrwxr-xr-x&4&root&root&&00:45&/opt/web例十：递归列出当前目录下的所有文件（包括隐藏文件）的绝对路径命令：&find&$PWD&|&xargs&ls&-ld&例十一：指定文件时间输出格式命令：&ls&-tl&--time-style=full-iso输出：[root@localhost&soft]#&ls&-tl&--time-style=full-iso&总计&350644drwxr-xr-x&16&96&&03:25:58.&+0800&subversion-1.6.1&ls&-ctl&--time-style=long-iso输出：[root@localhost&soft]#&ls&-ctl&--time-style=long-iso总计&350644drwxr-xr-x&16&&&&&&&-11&03:25&subversion-1.6.1扩展：1.&显示彩色目录列表& & 打开/etc/bashrc,&加入如下一行:& & alias&ls="ls&--color"& & 下次启动bash时就可以像在Slackware里那样显示彩色的目录列表了,&其中颜色的含义如下:& & 1.&蓝色--&目录& & 2.&绿色--&可执行文件& & 3.&红色--&压缩文件& & 4.&浅蓝色--&链接文件& & 5.&灰色--&其他文件
阅读(...) 评论()}