Ⅰ 红帽linux6.5 计算器指令
bc
带小数就用 bc -l
Ⅱ linux下的bc计算器做出结果后答案怎么复制
可以直接输出到文件里。
你在原有执行的bc命令及其后的数和计算等一系列内容（你算数用的所有内容）之后空一个格，添加
>> filename
，filename是文件名，最好不是已经在当前目录下已经存在的文件，否则会把结果附在原来文件的最后处。这样执行bc过程中的全部输出都不会出现在屏幕上，而是输入到filename这个文件里面。
Ⅲ linux计算器余数代码怎么写
http://jingyan..com/article/1e5468f974a17a484861b770.html
Ⅳ Linux：如何在命令行里直接算加减乘除呢现在需要算东西我还要开个计算器=。=
echo $((2+5*9))
这样，前面有个$,然后将算式放在括号里（前后圆括号各有两个),这个只支持整数四则运算
Ⅳ 怎么样称得上是Linux下优秀的命令行计算器
windows里面在命令界面输入calc就可以打开计算器，linux里面输入什么命令可以打开计算器？比如我在terminal输入firefox，它就打开了firefox。
我要输入什么才能打开计算器？
比如打开 画图板 word 控制面板 计算器 等这些 一些比较常用的工具 谢谢咯~！！
Ⅵ windows有没有一个类似linux下的计算器命令行 bc 指令 ，求分享，谢谢！
没有，因为windows是视窗操作系统，为了方便用户操作，很少有命令行的常用应用程序。
linux是原生命令行系统，所以绝大多数的工具、程序都有命令行的版本。
Ⅶ 在Linux下，用shell编写一个简单的计算器，要实现加减乘除4个功能就行了
不用写吧，本来有个 bc 命令可用，没有下载就成.
非要写一个，zsh 的function里有一个，名 zcalc,
贴上来给你
#!/usr/bin/zsh -i
#
# Zsh calculator. Understands most ordinary arithmetic expressions.
# Line editing and history are available. A blank line or `q' quits.
#
# Runs as a script or a function. If used as a function, the history
# is remembered for reuse in a later call (and also currently in the
# shell's own history). There are various problems using this as a
# script, so a function is recommended.
#
# The prompt shows a number for the current line. The corresponding
# result can be referred to with $<line-no>, e.g.
# 1> 32 + 10
# 42
# 2> $1 ** 2
# 1764
# The set of remembered numbers is primed with anything given on the
# command line. For example,
# zcalc '2 * 16'
# 1> 32 # printed by function
# 2> $1 + 2 # typed by user
# 34
# 3>
# Here, 32 is stored as $1. This works in the obvious way for any
# number of arguments.
#
# If the mathfunc library is available, probably understands most system
# mathematical functions. The left parenthesis must be adjacent to the
# end of the function name, to distinguish from shell parameters
# (translation: to prevent the maintainers from having to write proper
# lookahead parsing). For example,
# 1> sqrt(2)
# 1.4142135623730951
# is right, but `sqrt (2)' will give you an error.
#
# You can do things with parameters like
# 1> pi = 4.0 * atan(1)
# too. These go into global parameters, so be careful. You can declare
# local variables, however:
# 1> local pi
# but note this can't appear on the same line as a calculation. Don't
# use the variables listed in the `local' and `integer' lines below
# (translation: I can't be bothered to provide a sandbox).
#
# Some constants are already available: (case sensitive as always):
# PI pi, i.e. 3.1415926545897931
# E e, i.e. 2.7182818284590455
#
# You can also change the output base.
# 1> [#16]
# 1>
# Changes the default output to hexadecimal with numbers preceded by `16#'.
# Note the line isn't remembered.
# 2> [##16]
# 2>
# Change the default output base to hexadecimal with no prefix.
# 3> [#]
# Reset the default output base.
#
# This is based on the builtin feature that you can change the output base
# of a given expression. For example,
# 1> [##16] 32 + 20 / 2
# 2A
# 2>
# prints the result of the calculation in hexadecimal.
#
# You can't change the default input base, but the shell allows any small
# integer as a base:
# 1> 2#1111
# 15
# 2> [##13] 13#6 * 13#9
# 42
# and the standard C-like notation with a leading 0x for hexadecimal is
# also understood. However, leading 0 for octal is not understood --- it's
# too confusing in a calculator. Use 8#777 etc.
#
# Options: -#<base> is the same as a line containing just `[#<base>],
# similarly -##<base>; they set the default output base, with and without
# a base discriminator in front, respectively.
#
#
# To do:
# - separate zcalc history from shell history using arrays --- or allow
# zsh to switch internally to and from array-based history.
emulate -L zsh
setopt extendedglob
local line ans base defbase forms match mbegin mend psvar optlist opt arg
local compcontext="-math-"
integer num outdigits outform=1
# We use our own history file with an automatic pop on exit.
history -ap "${ZDOTDIR:-$HOME}/.zcalc_history"
forms=( '%2$g' '%.*g' '%.*f' '%.*E' )
zmodload -i zsh/mathfunc 2>/dev/null
: ${ZCALCPROMPT="%1v> "}
# Supply some constants.
float PI E
(( PI = 4 * atan(1), E = exp(1) ))
# Process command line
while [[ -n $1 && $1 = -(|[#-]*) ]]; do
optlist=${1[2,-1]}
shift
[[ $optlist = (|-) ]] && break
while [[ -n $optlist ]]; do
opt=${optlist[1]}
optlist=${optlist[2,-1]}
case $opt in
('#') # Default base
if [[ -n $optlist ]]; then
arg=$optlist
optlist=
elif [[ -n $1 ]]; then
arg=$1
shift
else
print "-# requires an argument" >&2
return 1
fi
if [[ $arg != (|\#)[[:digit:]]## ]]; then
print - "-# requires a decimal number as an argument" >&2
return 1
fi
defbase="[#${arg}]"
;;
esac
done
done
for (( num = 1; num <= $#; num++ )); do
# Make sure all arguments have been evaluated.
# The `$' before the second argv forces string rather than numeric
# substitution.
(( argv[$num] = $argv[$num] ))
print "$num> $argv[$num]"
done
psvar[1]=$num
while vared -cehp "${(%)ZCALCPROMPT}" line; do
[[ -z $line ]] && break
# special cases
# Set default base if `[#16]' or `[##16]' etc. on its own.
# Unset it if `[#]' or `[##]'.
if [[ $line = (#b)[[:blank:]]#('[#'(\#|)(<->|)']')[[:blank:]]#(*) ]]; then
if [[ -z $match[4] ]]; then
if [[ -z $match[3] ]]; then
defbase=
else
defbase=$match[1]
fi
print -s -- $line
line=
continue
else
base=$match[1]
fi
else
base=$defbase
fi
print -s -- $line
case ${${line##[[:blank:]]#}%%[[:blank:]]#} in
q) # Exit if `q' on its own.
return 0
;;
norm) # restore output format to default
outform=1
;;
sci[[:blank:]]#(#b)(<->)(#B))
outdigits=$match[1]
outform=2
;;
fix[[:blank:]]#(#b)(<->)(#B))
outdigits=$match[1]
outform=3
;;
eng[[:blank:]]#(#b)(<->)(#B))
outdigits=$match[1]
outform=4
;;
local([[:blank:]]##*|))
eval $line
line=
continue
;;
*)
# Latest value is stored as a string, because it might be floating
# point or integer --- we don't know till after the evaluation, and
# arrays always store scalars anyway.
#
# Since it's a string, we'd better make sure we know which
# base it's in, so don't change that until we actually print it.
eval "ans=\$(( $line ))"
# on error $ans is not set; let user re-edit line
[[ -n $ans ]] || continue
argv[num++]=$ans
psvar[1]=$num
;;
esac
if [[ -n $base ]]; then
print -- $(( $base $ans ))
elif [[ $ans = *.* ]] || (( outdigits )); then
printf "$forms[outform]\n" $outdigits $ans
else
printf "%d\n" $ans
fi
line=
done
return 0
支援小数点，+ - * / , ok
Ⅷ linux借用外部命令expr,实现计算器功能，利用管道，进程
test指令（使用指令man查询）
功能：检查文件类型，值比较。
test的各种参数和使用。
test EXPRESSION1 –a EXPRESSION2
当表达式1和表达式2同时为真时值为真
test EXPRESSION1 –o EXPRESSION2
当表达式1或者表达式2为真时值为真
test –n STRING
或者
test STRING
当STRING串的长度不为零时值为真
test –z STRING
当STRING串长度为零时值为真
test STRING1 = STRING2
当STRING1和STRING2相同时值为真
test STRING1 != STRING2
当STRING1 和 STRING2不同时值为真
test INTEGER1 –eq INTEGER2
当INTEGER1等于INTEGER2时值为真
test INTEGER1 –ge INTEGER2
当INTEGER1大于或者等于INTEGER2时值为真
test INTEGER1 –gt INTEGER2
当INTEGER1 大于INTEGER2时值为真
test INTEGER1 –le INTEGER2
当INTEGER1小于等于INTEGER2时值为真
test INTEGER1 –lt INTEGER2
当INTEGER1 小于INTEGER2时值为真
test INTEGER1 –ne INTEGER2
当INTEGER1不等于INTEGER2时值为真
test FILE1 –ef FILE2
当FILE1和FILE2有同样的device和inode号时为真（详细见linux文件学习笔记）
test FILE1 –nt FILE2
当FILE1修改时间比FILE2新时值为真
test FILE1 –ot FILE2
当FILE1修改时间比FILE2旧时值为真
test –b FILE
FILE存在并且内容是block类型的
test –c FILE
FILE存在并且是字符类型的
test –d FILE
FILE存在并且是一个目录
test –e FILE
FILE是否存在
test –f FILE
FILE存在并且是一个正则表达式类型的文档
test –g FILE
FILE存在并且是 set-group-ID也就是SGID（详细见后文学习笔记）
test –G FILE
FILE存在并且由有效的GROUP ID所拥有（详细见后文学习笔记）
test –h FILE
FILE存在并且是一个符号链接（详细见后文学习笔记）
test –k FILE
FILE存在并且设置了sticky bit set（详细见后文学习笔记）
test –L FILE
FILE存在并且是一个符号链接
test –O FILE
FILE存在并且由一个有效的USER ID所拥有
test –p FILE
FILE存在并且是一个命名管道（命名管道见后文学习笔记）
test –r FILE
FILE存在并且授予了可读的权限
test –s FILE
FILE存在并且size大于0
test –S FILE
FILE存在并且是一个socket
test –t FD
文件的描述符FD在终端打开
test –u FILE
FILE存在并且SUID已经被设置
test –w FILE
FILE存在并且授予了写操作权限
test –x FILE
FILE存在并且授予了可执行的权限
----------------------------------------------------------------------------------------------------------------------------------------------------
expr
expr是linux的手工命令行计数器，它可以帮助我们完成一些基本的表达式值运算。同时它也是一个字符串处理工具
（1） 整数运算
$expr ARG1 | ARG2
$expr ARG1 & ARG2
$expr ARG1 < ARG2
$expr ARG1 <= ARG2
$expr ARG1 = ARG2
$expr ARG1 != ARG2
$expr ARG1 >= ARG2
$expr ARG1 > ARG2
$expr ARG1 + ARG2
$expr ARG1 – ARG2
$expr ARG1 * ARG2
使用乘法时，需要使用反斜杠进行转义
$expr ARG1 % ARG2
（2） 字符串操作
$expr length “xxx” //计算字符串长度
$expr substr “this is a”pos length //从第pos位开始截取length长度的子串
$expr index “tesr”e //获取e在主串中首次出现的位置
（3） 增量计数
例子
loop=3
loop=`expr $loop + 1`
echo $loop
结果是4，在第二行代码中，使用反引号，shell会将反引号中的内容作为一个系统命令，这样一来，就好像我们在命令行内输入了expr $loop + 1然后这个命令的返回结果被赋值到loop。
（4） 模式匹配（按照正则表达式模式匹配串）
通过指定冒号选项计算字符串中字符数。.*意即任何字符重复0次或多次。
> VALUE=account.doc
> expr $VALUE : ’.*’
8
在expr中可以使用字符串匹配操作，这里使用模式抽取.doc文件附属名。
$expr $VALUE : ‘\(.*\).doc’
accounts
（5） 其他
+ TOKEN
将TOKEN解释为串，不管它是一个关键字或者一个操作符
延伸知识：
引号的作用
1 双引号（“”）
1）使用””可引用除字符$(美元符号)、`（反引号）、\（反斜线）外的任意字符或字符串。双引号不会阻止shell对这三个字符做特殊处理（标示变量名、命令替换、反斜线转义）。
Eg：name=gezn; echo “User name:$name”//将打印User name :gezn
Echo “The date is:`date +date-%d-%m-%Y`”//将打印The date is: 03-05-2009
Echo –e “$USER\t$UID” //将打印gezn 500
2）如果要查新包含空格的字符串经常用到双引号
2 单引号（’’）
1) 如果用单引号把字符串括起来，则dayi9nhao内字符串中的任何特殊字符的特殊含义均被屏蔽。
2) 举例：echo –e ‘$USER\t$UID’//将打印$USER $UID(没有屏蔽\t,是因为选项“-e”的缘故)
echo ‘USER\t$UID’ //将打印$USER\t$UID
3 反引号（``）
1) shell将反引号中的内容作为一个系统命令，并执行其内容。使用这种方法可以替换输出为一个变量
2) 举例：a=`date + date-%d-%m-%Y` //将打印The date is: 03-05-2009
4.反斜线（\）
1）如果下一个字符有特殊含义，反斜线防止shell误解其含义，即屏蔽其特殊含义。
2）下属字符包含有特殊含义：& * + $ ` “ | ?
3) 在打印字符串时要加入八进制字符（ASCII相应字符）时，必须在前面加反斜线，否则shell作普通数字处。
举例： bj=Beijing; echo ”variable\$bj=$bj”//将打印variable $bj = beijing
------------------------------------------------------------------------------------------------------------------------------------------------
Shell特殊变量
在Shell中，预先定义了几个有特殊含义的Shell变量，它们的值只能由Shell根据实际情况进行赋值，而不能通过用户重新设置。shell的特殊变量包括它的位置和一些系统变量.
(一)常用位置变量:
$# 命令行上实际参数的个数，但不包含Shell脚本名。
$？ 上一条命令执行后的返回值（也称作 “退出码”）。它是一个十进制数。多数Shell命令执行成功时，则返回值为0；如果执行失败，则返回非0值。
$$ 当前进程的进程号。
$！ 上一个后台命令对应的进程号，这是一个由1~5位数字构成的数字串。
$- 由当前Shell设置的执行标志名组成的字符串。例如：
set －xv 这个命令行给Shell设置了标志-x和-v（用于跟踪输出）。
$* 表示在命令行中实际给出的所有实参字符串，它并不仅限于9个实参。
$@ 它与$*基本功能相同，但是使用时加引号，并在引号中返回每个参数
$0 脚本名称
$1..$9 第N个参数
下面的aaa bbb 为变量名
${aaa:-bbb} 如果$aaa为空或未定义,则取值$bbb.否则取值$aaa
${aaa:+bbb} 如果$aaa非空,则取值$bbb,否则取值为空
${aaa:=bbb} 如果$aaa非空,则取值$aaa,否则取值$bbb而且赋值(aaa=bbb)
${aaa:3} 如果aaa=abcdefg,则${aaa:3}的值为:defg ,相当于substr,计数从0开始
${aaa:3:2} 如上; ${aaa:3:2}取值为: de.相当于substr
${#aaa} 字符串$aaa的长度.
（二）常用系统变量:
$HOME 用户的主目录
$USER 用户名称
$GROUP 用户所属组名
$PATH 默认的搜索路径
$HOSTNAME 主机名称
$TZ 时区
$MAIL 存放邮件的路径名
练手：
#!/bin/bash
echo $0
echo $*
echo $@
echo $#
echo $$
echo $_
在terminal窗口中执行：
./test.sh -a -b –c /home
./test.sh
-a -b -c /home
-a -b -c /home
4
3250
/home
区别$*和$@编写如下test.sh脚本：
#!/bin/bash
function testargs
{
echo "$# args"
}
testargs "$*"
testargs "$@"
unset -f testargs
在terminal窗口中执行：
./test.sh -a -b /home
1 args //很明显就一个嘛，传入的是$*这个串，不是解释后的参数
3 args //$@必须和引号搭配，所以结果正确
#!/bin/bash
function testargs
{
echo "$# args"
}
testargs $*
testargs $@
unset -f testargs
再次执行有：
./test.sh -a -b /home
3 args
3 args
作者：Aga.J
出处：http://www.cnblogs.com/aga-j
Ⅸ 怎么在linux里的mono下用C#编写计算器功能或者记事本的功能
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace WindowsApplication4
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
txtHidden1.Text = "";
txtHidden1.Visible = false;
txtHidden2.Text = "";
txtHidden2.Visible = false;//txtHidden1和txtHidden2的功能都是临时存放操作符
txtTemp.Text = "";//txtTemp的功能是存放临时结果
txtTemp.Visible = false;
txtResult.Text = "0";
txtResult.ReadOnly = true;//txtResult的功能是结果的显示以及数字的输入
}
private void btn0_Click(object sender, EventArgs e)//按钮0
{
PressNumBtn(sender);
}
private void btn1_Click(object sender, EventArgs e)//按钮1
{
PressNumBtn(sender);
}
private void btn2_Click(object sender, EventArgs e)//按钮2
{
PressNumBtn(sender);
}
private void btn3_Click(object sender, EventArgs e)//按钮3
{
PressNumBtn(sender);
}
private void btn4_Click(object sender, EventArgs e)//按钮4
{
PressNumBtn(sender);
}
private void btn5_Click(object sender, EventArgs e)//按钮5
{
PressNumBtn(sender);
}
private void btn6_Click(object sender, EventArgs e)//按钮6
{
PressNumBtn(sender);
}
private void btn7_Click(object sender, EventArgs e)//按钮7
{
PressNumBtn(sender);
}
private void btn8_Click(object sender, EventArgs e)//按钮8
{
PressNumBtn(sender);
}
private void btn9_Click(object sender, EventArgs e)//按钮9
{
PressNumBtn(sender);
}
private void btnDian_Click(object sender, EventArgs e)//按钮小数点
{
if (txtResult.Text == "")
{
return;
}
else if (txtResult.Text.Contains("."))
{
return;
}
else
{
txtResult.Text = txtResult.Text + ".";
}
}
private void BtnJia_Click(object sender, EventArgs e)//按钮+
{
PressOperBtn(sender);
}
private void btnJian_Click(object sender, EventArgs e)//按钮－
{
PressOperBtn(sender);
}
private void btnCheng_Click(object sender, EventArgs e)//按钮*
{
PressOperBtn(sender);
}
private void btnChu_Click(object sender, EventArgs e)//按钮除
{
PressOperBtn(sender);
}
private void btnEqual_Click(object sender, EventArgs e)//按钮＝
{
if (txtHidden2.Text != "" && txtTemp.Text != "")
{
txtResult.Text = WorkOut();
}
txtHidden1.Text = "";
txtHidden2.Text = "";
txtTemp.Text = "";
}
private void btnCE_Click(object sender, EventArgs e)//按钮清0
{
txtResult.Text = "0";
txtHidden1.Text = "";
txtHidden2.Text = "";
txtTemp.Text = "";
}
private void PressNumBtn(object sender)//操作数字键从0到9
{
Button btn = sender as Button;
string tag = btn.Text;
if (txtHidden1.Text == "")
{
if (txtResult.Text == "0")
{
txtResult.Text = tag;
}
else
{
txtResult.Text = txtResult.Text + tag;
}
}
else
{
txtHidden2.Text = txtHidden1.Text;
txtHidden1.Text = "";
txtResult.Text = tag;
}
}
private void PressOperBtn(object sender)//操作加、减、乘、除
{
Button btn = sender as Button;
string tag = btn.Text;
if (txtHidden2.Text != "" && txtTemp.Text != "")
{
txtResult.Text = WorkOut();
}
txtHidden1.Text = tag;
txtTemp.Text = txtResult.Text;
}
private string WorkOut()//核心功能：计算
{
string oper = txtHidden2.Text;
double num1 = Convert.ToDouble(txtTemp.Text);
double num2 = Convert.ToDouble(txtResult.Text);
double result=0;
switch (oper)
{
case "+": result = num1 + num2; break;
case "-": result = num1 - num2; break;
case "*": result = num1 * num2; break;
case "/": result = num1 / num2; break;
default: break;
}
string Result = result.ToString();
return Result;