Comando Linux / Unix: expr

Nome

expr - Avaliar unha expresión

Sinopse

expr arg ? arg arg ... ?

Concatenar arg 's (engadindo espazos separadores entre eles), avalía o resultado como expresión Tcl, e devolve o valor. Os operadores permitidos nas expresións Tcl son un subconxunto dos operadores permitidos nas expresións C e teñen o mesmo significado e precedencia que os operadores C correspondentes. As expresións producen sempre resultados numéricos (valores de punto enteiro ou flotante). Por exemplo, a expresión

expr 8.2 + 6

avalía a 14.2. As expresións Tcl difieren das expresións C na forma en que se especifican os operandos. Ademais, as expresións Tcl admiten operandos non numéricos e comparacións de cordas.

Operandos

A expresión Tcl consiste nunha combinación de operandos, operadores e parénteses. O espazo branco pode ser usado entre os operandos e os operadores e os parénteses; ignórase polas instrucións da expresión. Cando sexa posible, os operandos son interpretados como valores enteiros. Os valores enteiros pódense especificar en decimal (o caso normal), en octal (se o primeiro carácter do operando é 0 ), ou en hexadecimal (se os dous primeiros caracteres do operando son 0x ). Se un operando non ten ningún dos formatos enteiros dados anteriormente, trátase como un número de punto flotante se isto é posible. Os números de punto flotante pódense especificar en calquera das formas aceptadas por un compilador C compatible con ANSI (agás que os sufixos F , F , L e L non estarán permitidos na maioría das instalacións). Por exemplo, todos os seguintes son números de coma flotante válidos: 2.1, 3., 6e4, 7.91e + 16. Se ningunha interpretación numérica é posible, entón un operando queda como unha cadea (e só se pode aplicar a un conxunto limitado de operadores).

Os operandos poden especificarse de calquera das seguintes formas:

[1]

Como un valor numérico, enteiro ou punto flotante.

[2]

Como unha variable Tcl, usando notación $ estándar. O valor da variable usará como operando.

[3]

Como unha cadea encerrada en comiñas dobres. O analizador de expresións realizará substitucións alternativas, variables e orde na información entre as comiñas e usar o valor resultante como o operando.

[4]

Como unha cadea encerrada en chaves. Os caracteres entre a chave aberta e a chave de atado correspondente serán utilizados como operando sen substitucións.

[5]

Como un comando Tcl encerrado entre parénteses. O comando executarase e o seu resultado será usado como operando.

[6]

Como función matemática cuxos argumentos teñen algunha das formas anteriores para operandos, como o pecado ($ x) . Vexa a continuación unha lista de funcións definidas.

Cando as substitucións ocorran anteriormente (por exemplo, as cadeas dentro das citas), son realizadas polas instrucións da expresión. Non obstante, un parche de comando xa puido realizar unha capa adicional de substitución antes de que se chamase o procesador de expresión. Como se discute a continuación, normalmente é mellor incluír expresións nos aparellos para evitar que o analizador de comando realice substitucións nos contidos.

Para algúns exemplos de expresións sinxelas, supoña que a variable a ten o valor 3 ea variable b ten o valor 6. A continuación, o comando no lado esquerdo de cada unha das liñas a continuación producirá o valor no lado dereito da liña:

expr 3.1 + $ a6.1 expr 2 + "$ a. $ b" 5.6 expr 4 * [lonxitude "6 2"] 8 expr {{word one} <"palabra $ a"} 0

Operadores

Os operadores válidos están listados a continuación, agrupados en orde decreciente de precedencia:

- + ~!

Unary minus, unary plus, bit-wise NOT, non lóxico. Ningún destes operandos pode ser aplicado a operandos de cadea, e NOT bitwise non se pode aplicar só aos enteiros.

* /%

Multiplique, divida, resto. Ningún destes operandos pode ser aplicado aos operandos de corda, e os restantes só se poden aplicar a enteiros. O resto sempre terá o mesmo signo que o divisor e un valor absoluto menor que o divisor.

+ -

Engadir e restar. Válido para todos os operandos numéricos.

<< >>

Cambio de esquerda e dereita. Válido só para operandos enteiros. Un cambio dereito sempre propaga o bit de sinal.

<> <=> =

Booleano menor, maior, menor ou igual, e maior ou igual. Cada operador produce 1 se a condición é verdadeira, 0 se non. Estes operadores poden ser aplicados a cadeas e operandos numéricos, en cuxo caso úsase a comparación de cordas.

==! =

Booleano igual e non igual. Cada operador produce un resultado cero / un. Valido para todos os tipos de operando.

&

E pouco sabio. Válido só para operandos enteiros.

^

OR exclusivo bit-wise. Válido só para operandos enteiros.

|

OR pouco sabio. Válido só para operandos enteiros.

&&

Lóxico AND. Produce un resultado 1 se ambos os operandos non son cero, 0 se non. Válido só para operadores booleanos e numéricos (enteiros ou puntos flotantes).

||

OR lóxico. Produce un resultado 0 se ambos os operandos son cero, 1 se non. Válido só para operadores booleanos e numéricos (enteiros ou puntos flotantes).

x ? y : z

Se, entón, máis, como en C. Se x avalía a non cero, entón o resultado é o valor de y . Se non, o resultado é o valor de z . O operando x debe ter un valor numérico.

Vexa o manual C para obter máis detalles sobre os resultados producidos por cada operador. Todos os grupos de operadores binarios de esquerda a dereita dentro do mesmo nivel de precedencia. Por exemplo, o comando

expr 4 * 2 <7

devolve 0.

The && , || , e ?: os operadores teñen unha avaliación '' preguiza '', tal como ocorre en C, o que significa que os operandos non son avaliados se non son necesarios para determinar o resultado. Por exemplo, no comando

expr {$ v? [a]: [b]}

só un de [a] ou [b] será efectivamente avaliado, dependendo do valor de $ v . Teña en conta, non obstante, que isto só é verdadeiro se toda a expresión está incluída nas teclas; Se non, o analizador Tcl avaliará [a] e [b] antes de invocar o comando expr .

Funcións matemáticas

Tcl admite as seguintes funcións matemáticas nas expresións:

abs logos de logs sqrt acos double log10 srand asin exp pow tan atan floor rand tanh atan2 fmod round ceil hypot sin cos int sinh

abs ( arg )

Devolve o valor absoluto de arg . Arg pode ser enteiro ou punto flotante, e o resultado é devolto no mesmo formulario.

acos ( arg )

Devolve o arco coseno de arg , no rango [0, pi] radiáns. Arg debería estar dentro do intervalo [-1,1].

asin ( arg )

Devolve o arco sinus de arg , no rango [-pi / 2, pi / 2] radiáns. Arg debería estar dentro do intervalo [-1,1].

atan ( arg )

Devolve o arco tanxente de arg , no rango [-pi / 2, pi / 2] radiáns.

atan2 ( x, y )

Devolve o arco tanxente de y / x , no intervalo [-pi, pi] radiáns. x e y non poden ser ambos 0.

ceil ( arg )

Devolve o valor do menor enteiro menor que o arg .

cos ( arg )

Devolve o coseno de arg , medido en radianes.

cosh ( arg )

Devolve o coseno hiperbólico de arg . Se o resultado causase un desbordamiento, devólvese un erro.

dobre ( arg )

Se arg é un valor flotante, retorna arg , doutro xeito converte arg para flotar e devolve o valor convertido.

exp ( arg )

Devolve o exponencial de arg , definido como e ** arg . Se o resultado causase un desbordamiento, devólvese un erro.

chan ( arg )

Devolve o maior valor integral non maior que o arg .

fmod ( x, y )

Devolve o resto flotante da división de x por y . Se y é 0, devolve un erro.

hipot ( x, y )

Calcula a lonxitude da hipotenusa dun triángulo rectángulo ( x * x + y * y ).

int ( arg )

Se arg é un valor enteiro, retorna arg , doutro xeito converte arg ao enteiro por trunco ​​e devolve o valor convertido.

rexistro ( arg )

Devolve o logaritmo natural de arg . Arg debe ser un valor positivo.

log10 ( arg )

Devolve o logaritmo base 10 de arg . Arg debe ser un valor positivo.

pow ( x, y )

Computa o valor de x elevado á potencia y . Se x é negativo, y debe ser un valor enteiro.

rand ()

Devolve un número de punto flotante de cero a algo menos que un ou, en términos matemáticos, o rango [0,1]. A semente vén do reloxo interno da máquina ou pode ser configurado manualmente coa función srand.

rolda ( arg )

Se arg é un valor enteiro, retorna arg , doutro xeito converte arg ao enteiro redondeando e devolve o valor convertido.

pecado ( arg )

Devolve o seno da arg , medido en radianes.

sinh ( arg )

Devolve o seno hiperbólico de arg . Se o resultado causase un desbordamiento, devólvese un erro.

sqrt ( arg )

Devolve a raíz cadrada de arg . Arg non debe ser negativo.

srand ( arg )

O arg , que debe ser un número enteiro, úsase para restablecer a semente para o xerador de números aleatorios. Devolve o primeiro número aleatorio desa semente. Cada intérprete ten a súa propia semente.

tan ( arg )

Devolve a tanxente de arg , medida en radianes.

Tanh ( arg )

Devolve a tanxente hiperbólica de arg .

Ademais destas funcións predefinidas, as aplicacións poden definir funcións adicionais usando Tcl_CreateMathFunc ().

Tipos, desbordamiento e precisión

Todos os cálculos internos que impliquen enteiros están feitos co tipo C longo , e todos os cálculos internos que inclúen o punto flotante realízanse co dobre do tipo C. Ao converter unha cadea a punto flotante, detéctase o exceso de expoñente e obtén un erro Tcl. Para a conversión a número enteiro da cadea, a detección do desbordamiento depende do comportamento dalgunhas rutinas na biblioteca C local, polo que debe considerarse como non fiable. En todo caso, o desbordamento e o subflujo de enteiros xeralmente non se detectan de forma fiable por resultados intermedios. O desbordamento e o fluxo de flotante son detectados ao grao soportado polo hardware, que xeralmente é moi fiable.

A conversión entre as representacións internas dos operadores de enteiro, flotante e de secuencia realízase automaticamente segundo o necesario. Para cálculos aritméticos, utilízanse enteiros ata que se introduce un número de punto flotante, despois do cal se usa o punto flotante. Por exemplo,

expr 5/4

devolve 1, mentres

expr 5 / 4.0 expr 5 / ([lonxitude da cadea "abcd"] + 0.0)

ambas retornan 1.25. Os valores de punto flotante sempre se devolven cun `` . ou un e para que non parezan valores enteiros. Por exemplo,

expr 20.0 / 5.0

devolve 4.0 , non 4 .

Operacións de corda

Os valores de cadea poden ser usados ​​como operandos dos operadores de comparación, aínda que o evaluador de expresións tenta facer comparacións como enteiro ou punto flotante cando poida. Se un dos operandos dunha comparación é unha cadea eo outro ten un valor numérico, o operando numérico converteuse de novo en unha cadea empregando o especificador de formato Sprintf C % d para enteiros e % g para valores de punto flotante. Por exemplo, os comandos

expr {"0x03"> "2"} expr {"0y" <"0x12"}

ambas retornan 1. A primeira comparación faise usando a comparación de números enteiros, ea segunda faise usando a comparación de cordas despois de que o segundo operando se converte á cadea 18 . Debido á tendencia de Tcl a tratar valores como números sempre que sexa posible, non adoita ser unha boa idea usar operadores como == cando realmente desexa comparacións de cordas e os valores dos operandos poden ser arbitrarios; é mellor nestes casos usar o comando string .

Consideracións de rendemento

Inclúe expresións nas teclas para a mellor velocidade e os menores requisitos de almacenamento. Isto permite que o compilador de bytecode Tcl para xerar o mellor código.

Como se mencionou anteriormente, as expresións son substituídas dúas veces: unha vez polo analizador Tcl e unha vez polo comando expr . Por exemplo, os comandos

configure un conxunto de 3 b {$ a + 2} expr $ b * 4

devolve 11, non un múltiplo de 4. Isto é porque o analizador Tcl substitúe primeiro a $ a + 2 para a variable b , entón o comando expr avaliará a expresión $ a + 2 * 4 .

A maioría das expresións non requiren unha segunda rolda de substitucións. Ou están encerrados en chaves ou, no caso contrario, as súas substitucións variables e de orde dan números ou secuencias que non requiren substitucións. Non obstante, debido a que algunhas expresións non abertas precisan dúas roldas de substitucións, o compilador bytecode debe emitir instrucións adicionais para xestionar esta situación. O código máis caro é necesario para expresións non abertas que conteñan substitucións de comandos. Estas expresións deben implementarse xerando un novo código cada vez que se executa a expresión.

Palabras clave

aritmética, booleano , comparación, expresión, comparación difusa

Importante: use o comando man ( % home ) para ver como se usa un comando na súa computadora particular.