• 关于

    OR运算工作原理

    的搜索结果

回答

问的这个问题还很不能自己打给你了 复制些详细的给你看吧电脑为何采用二进制1.二进制只需用两种状态表示数字,容易实现计算机是由电子元器件构成的,二进制在电气、电子元器件中最易实现。它只有两个数字,用两种稳定的物理状态即可表达,而且稳定可靠。比如磁化与未磁化,晶体管的载止与导通(表现为电平的高与低)等。而若采用十进制,则需用十种稳定的物理状态分别表示十个数字,不易找到具有这种性能的元器件,即使有,其运算与控制的实现也极复杂。2.二进制的运算规则简单加法是最基本的运算。乘法是连加,减法是加法的逆运算(利用补码原理,还可以转化为加法运算,类似钟表拨针时的计算),除法是乘法的逆运算。其余任何复杂的数值计算也都可以分解为基本算术运算复合进行。为提高运算效率,在计算机中除采用加法器外,也直接使用乘法器。众所周知,十进制的加法和乘法运算规则的口诀各有100条,根据交换率去掉重复项,也各有55条。用计算机的电路实现这么多运算规则是很复杂的。相比之下,二进制的算术运算规则非常简单,加法、乘法各仅四条:0+0=0 0×0=0O+1=1 0×1=01+0=l l×O=0l+1=10 1×1=l根据交换率去掉重复项,实际各仅3条。用计算机的脉冲数字电路是很容易实现的。3.用二进制容易实现逻辑运算计算机不仅需要算术运算功能,还应具备逻辑运算功能,二进制的0和1分别可用来表示假(false)和真(true),用布尔代数的运算法则很容易实现逻辑运算。4.二进制的弱点可以克服二进制主要的弱点是表示同样大小的数值时,其位数比十进制或其他数制多得多,难写难记,因而在日常生活和工作中是不便使用的。但这个弱点对计算机而言,并不构成困难。在计算机中每个存储记忆元件(比如由晶体管组成的触发器)可以代表一位数字,“记忆”是它们本身的属性,不存在“记不住”或“忘记”的问题。至于位数多,只要多排列一些记忆元件就解决了,鉴于集成电路芯片上元件的集成度极高,在体积上不存在问题。对于电子元器件,0和1两种状态的转换速度极快,因而运算速度是很高的。二进制运算1.算术运算前面已经讲过,二进制算术运算规则非常简单,现举二例加以说明。即1110B+1011B=11001B即1110B×10llB=10011010B2.逻辑运算在计算机中还经常用二进制数进行逻辑运算。逻辑运算在二进制数位之间进行,不存在进位或借位。在逻辑运算中,二进制数中的“1”表示“真”,“0”表示“假”。(1)或(OR)运算或运算又称逻辑加,运算符为“∨”或者“+”。运算规则是:0∨0=0O∨1=l1∨O=l1∨1=l也就是说,参加运算的逻辑值只要有一个为1,运算结果即为1,否则为0。(2)与(AND)运算与运算又称逻辑乘,运算符为“∧”或者“×”。运算规则是:0∧0=00∧1=O1∧O=01∧1=1也就是说,当参加运算的逻辑值均为1时,运算结果才为1,否则为0。(3)非(NOT)运算非运算即对每个二进制位的逻辑值取反,运算符为在二进制数字上方加一横线。运算规则是:0=11=0(4)异或(XOR)运算异或运算即按位相加(不进位),运算符常记为。运算规则是:00=00l=1l0=lll=0可以看出,如果参加运算的两个逻辑值相同,运算结果为0,否则为l。下面举例说明二进制数的逻辑运算。设 X=10110101B Y=ll010110B则 X∨Y=11110111BX∧Y=10010100B XY=01100011B更多的参考资料吧,复制也复制不上来了参考资料: http://ced.xxjy.cn/Resource/Book/Edu/JSJCKS/TS003063/0003_ts003063.htm
一键天涯 2019-12-02 01:27:55 0 浏览量 回答数 0

回答

二进制只需用两种状态表示数字,容易实现计算机是由电子元、器件构成的,二进制在电气、电子元器件中最易实现。它只有两个数字,用两种稳定的物理状态即可表达,而且稳定可靠。比如磁化与未磁化,晶体管的载止与导通(表现为电平的高与低)等。而若采用十进制,则需用十种稳定的物理状态分别表示十个数字,不易找到具有这种性能的元器件。即使有,其运算与控制的实现也极复杂。 二进制的运算规则简单加法是最基本的运算。乘法是连加,减法是加法的逆运算(利用补码原理,还可以转化为加法运算,类似钟表拨针时的计算),除法是乘法的逆运算。其余任何复杂的数值计算也都可以分解为基本算术运算复合进行。为提高运算效率,在计算机中除采用加法器外,也直接使用乘法器。 众所周知,十进制的加法和乘法运算规则的口诀各有100条,根据交换率去掉重复项,也各有55条。用计算机的电路实现这么多运算规则是很复杂的。 相比之下,二进制的算术运算规则非常简单,加法、乘法各仅四条: 0+0=00×0=0 0+1=10×1=0 1+0=11×0=0 1+1=101×1=1 根据交换率去掉重复项,实际各仅3条。用计算机的脉冲数字电路是很容易实现的。 3.用二进制容易实现逻辑运算计算机不仅需要算术功能,还应具备逻辑运算功能,二进制的0,1分别 可用来表示假(false)和真(true),用布尔代数的运算法则很容易实现逻辑运算。 4.二进制的弱点可以克服二进制主要的弱点是表示同样大小的数值时,其位数比十进制或其他数制多得多,难写难记,因而在日常生活和工作中是不便使用的。但这个弱点对计算机而言,并不构成困难。在计算机中每个存储记忆元件(比如由晶体管组成的触发器)可以代表一位数字,“记忆”是它们本身的属性,不存在“记不住”或“忘记”的问题。至于位数多,只要多排列一些记忆元件就解决了,鉴于集成电路芯片上元件的集成度极高,在体积上不存在问题。对于电子元、器件,0和1两种状态的转换速度极快,因而运算速度是很高的。 二进制运算 1.算术运算前面已经讲过,二进制算术规则非常简单,现举二例加以说明。 即1110B+1011B=11001B 即1110B×1011B=10011010B 2.逻辑运算在计算机中还经常用二进制数进行逻辑运算。逻辑运算在二进制数位之间进行,不存在进位或借位。在逻辑运算中,二进制数中的“1”表示“真”,“0”表示“假”。 (1)或(OR)运算 或运算又称逻辑加,运算符为“∨”或者“+”。运算规则是: 0∨0=0 0∨1=1 1∨0=1 1∨1=1 也就是说,当参加运算的逻辑值只要有一个1,运算结果即为1,否则为0。 (2)与(AND)运算 与运算又称逻辑乘,运算符为“∧”或“×”。运算规则是: 0∧0=0 0∧1=0 1∧0=0 1∧1=1 也就是说,当参加运算的逻辑值均为1时,运算结果才为1,否则为0。 (3)非(NOT)运算 非运算即对每个二进制位的逻辑值取反,运算符为在二进制数字上方加 一横线。运算规则是: 0=1 1=0 (4)异或(XOR)运算 异或运算即按位相加(不进位),运算符常记为,运算规则是: 00=0 01=1 10=1 11=0 可以看出,如果参加运算的逻辑值只要有一个为1,运算结果即为1,否则为0。 下面举例说明二进制数的逻辑运算。 设X=10110101BY=11010110B X∨Y=11110111B X∧Y=10010100B X==D1001010Y00101001BB XY=011000i11B 十进制数与二进制数的转换 我们在日常生活和工作中使用十进制数,在计算机中使用二进制数,因此在计算机输入时要将十进制数转换为二进制数,在计算机输出时要将二进制数转换为十进制数。这种转换过程,是由计算机自动完成的。为简便起见,这里我们只介绍整数间转换。 1 .十进制数转换为二进制数整数的转换,通常采用除2取余法。即将十进制数依次除以2,再把每次得到的余数从后向前依次排列就得到相应的二进制数。例如:实际上,直接将十进制数用2的n次幂展开更为方便。例如: 75=64+8+2+1 =26×1+26×0×24×0+23×1+22×0+21×1+20×1 =1001011B 2.二进制数转换为十进制数将二进制数每一位的数值用十进制表达并相加即得到相应的十进制数。 例如: 11010010B=27×1+26×1+25×0+24×1+23×0+22×0+21×1+20×1 =128+64+16+2 =210
小旋风柴进 2019-12-02 01:28:12 0 浏览量 回答数 0

回答

十进制有0~9共十个数字。以此类推,二进制应当只有两个数字,记为0、1。基数不是一个独立的数字。 2.逢基数进一 凡某位运算结果为基数就要进位,本数位的值记为0,进位值为1。在十进制中,逢十进一。在二进制中,逢二进一。 3.每一位的权(数位值)是基数的方幂,指数自右至左递增1 十进制:…10410310210110010-110-210-3…… 二进制:…24232221202-12-22-3…… 需要特别指出的是,为说明方便,此处二进制数是用十进制数的数字表达的。 4.每一位的数值等于该位上的权与数字的乘积 例如: 1995=1000×1+100×9+100×9+1×5 1001.101B=23×1+20×1+2-1×1+2-3×1 同样,为说明方便,此处等号右边的二进制数是用十进制数字表达的。 电脑为何采用二进制 l.二进制只需用两种状态表示数字,容易实现 计算机是由电子元器件构成的,二进制在电气、电子元器件中最易实现。它只有两个数字,用两种稳定的物理状态即可表达,而且稳定可靠。比如磁化与未磁化,晶体管的载止与导通(表现为电平的高与低)等。而若采用十进制,则需用十种稳定的物理状态分别表示十个数字,不易找到具有这种性能的元器件,即使有,其运算与控制的实现也极复杂。 2.二进制的运算规则简单 加法是最基本的运算。乘法是连加,减法是加法的逆运算(利用补码原理,还可以转化为加法运算,类似钟表拨针时的计算),除法是乘法的逆运算。其余任何复杂的数值计算也都可以分解为基本算术运算复合进行。为提高运算效率,在计算机中除采用加法器外,也直接使用乘法器。 众所周知,十进制的加法和乘法运算规则的口诀各有100条,根据交换率去掉重复项,也各有55条。用计算机的电路实现这么多运算规则是很复杂的。 相比之下,二进制的算术运算规则非常简单,加法、乘法各仅四条: 0+0=0 0×0=0 O+1=1 0×1=0 1+0=l l×O=0 l+1=10 1×1=l 根据交换率去掉重复项,实际各仅3条。用计算机的脉冲数字电路是很容易实现的。 3.用二进制容易实现逻辑运算 计算机不仅需要算术运算功能,还应具备逻辑运算功能,二进制的0和1分别可用来表示假(false)和真(true),用布尔代数的运算法则很容易实现逻辑运算。 4.二进制的弱点可以克服 二进制主要的弱点是表示同样大小的数值时,其位数比十进制或其他数制多得多,难写难记,因而在日常生活和工作中是不便使用的。但这个弱点对计算机而言,并不构成困难。在计算机中每个存储记忆元件(比如由晶体管组成的触发器)可以代表一位数字,“记忆”是它们本身的属性,不存在“记不住”或“忘记”的问题。至于位数多,只要多排列一些记忆元件就解决了,鉴于集成电路芯片上元件的集成度极高,在体积上不存在问题。对于电子元器件,0和1两种状态的转换速度极快,因而运算速度是很高的。 二进制运算 1.算术运算 前面已经讲过,二进制算术运算规则非常简单,现举二例加以说明。 即1110B+1011B=11001B 即1110B×10llB=10011010B 2.逻辑运算 在计算机中还经常用二进制数进行逻辑运算。逻辑运算在二进制数位之间进行,不存在进位或借位。在逻辑运算中,二进制数中的“1”表示“真”,“0”表示“假”。 (1)或(OR)运算 或运算又称逻辑加,运算符为“∨”或者“+”。运算规则是: 0∨0=0 O∨1=l 1∨O=l 1∨1=l 也就是说,参加运算的逻辑值只要有一个为1,运算结果即为1,否则为0。 (2)与(AND)运算 与运算又称逻辑乘,运算符为“∧”或者“×”。运算规 则是: 0∧0=0 0∧1=O 1∧O=0 1∧1=1 也就是说,当参加运算的逻辑值均为1时,运算结果才为1,否则为0。(3)非(NOT)运算非运算即对每个二进制位的逻辑值取反,运算符为在二进制数字上方加一横线。运算规则是: 0=1 1=0 (4)异或(XOR)运算异或运算即按位相加(不进位),运算符常记为Å。运算规则是: 0Å0=0 0Ål=1 lÅ0=l lÅl=0 可以看出,如果参加运算的两个逻辑值相同,运算结果为0,否则为l。下面举例说明二进制数的逻辑运算。 设 X=10110101B Y=ll010110B 则 X∨Y=11110111B X∧Y=10010100B XÅY=01100011B 十进制数与二进制数的转换 我们在日常生活和工作中使用十进制数,在计算机中使用二进制数,因此在计算机输入时要将十进制数转换为二进制数,在计算机输出时要将二进制数转换为十进制数。这种转换过程,是曲计算机自动完成的。为简便起见,这里我们只介绍整数间的转换。 1.十进制数转换为二进制数 整数的转换,通常采用除2取余法。即将十进制数依次除以2,再把每次得到的余数从后向前依次排列就得到相应的二进制数。例如: 即 75=1001011B 实际上,直接将十进制数用2的n次幂展开更为方便。例如: 75=64+8+2+1 =26×1+25×O+24×O+23×1+22×0+21×1+20×1 =1001011B 2.二进制数转换为十进制数 将二进制数每一位的数值用十进制表达并相加即得到相应的十进制数。例如: 11010010B=27×1+26×1+25×0+24×1+23×0+22 ×O+21×1+20×1 =128+64+16+2 =210
祁同伟 2019-12-02 01:28:03 0 浏览量 回答数 0

万券齐发助力企业上云,爆款产品低至2.2折起!

限量神券最高减1000,抢完即止!云服务器ECS新用户首购低至0.95折!

回答

在这个问题中,我们集中讨论根据特殊语法去解析文本的问题。为了这样做,你首先要以BNF或者EBNF形式指定一个标准语法。比如,一个简单数学表达式语法可能像下面这样: expr ::= expr + term | expr - term | term term ::= term * factor | term / factor | factor factor ::= ( expr ) | NUM 或者,以EBNF形式: expr ::= term { (+|-) term }* term ::= factor { (|/) factor } factor ::= ( expr ) | NUM 在EBNF中,被包含在 {...}* 中的规则是可选的。*代表0次或多次重复(跟正则表达式中意义是一样的)。 现在,如果你对BNF的工作机制还不是很明白的话,就把它当做是一组左右符号可相互替换的规则。一般来讲,解析的原理就是你利用BNF完成多个替换和扩展以匹配输入文本和语法规则。为了演示,假设你正在解析形如 3 + 4 * 5 的表达式。这个表达式先要通过使用2.18节中介绍的技术分解为一组令牌流。结果可能是像下列这样的令牌序列: NUM + NUM * NUM 在此基础上, 解析动作会试着去通过替换操作匹配语法到输入令牌: expr expr ::= term { (+|-) term }* expr ::= factor { (|/) factor } { (+|-) term }* expr ::= NUM { (|/) factor } { (+|-) term }* expr ::= NUM { (+|-) term }* expr ::= NUM + term { (+|-) term }* expr ::= NUM + factor { (|/) factor } { (+|-) term }* expr ::= NUM + NUM { (|/) factor} { (+|-) term }* expr ::= NUM + NUM * factor { (|/) factor } { (+|-) term }* expr ::= NUM + NUM * NUM { (|/) factor } { (+|-) term }* expr ::= NUM + NUM * NUM { (+|-) term }* expr ::= NUM + NUM * NUM 下面所有的解析步骤可能需要花点时间弄明白,但是它们原理都是查找输入并试着去匹配语法规则。第一个输入令牌是NUM,因此替换首先会匹配那个部分。一旦匹配成功,就会进入下一个令牌+,以此类推。当已经确定不能匹配下一个令牌的时候,右边的部分(比如 { (/) factor } )就会被清理掉。在一个成功的解析中,整个右边部分会完全展开来匹配输入令牌流。 有了前面的知识背景,下面我们举一个简单示例来展示如何构建一个递归下降表达式求值程序: #!/usr/bin/env python -- encoding: utf-8 -- """ Topic: 下降解析器 Desc : """ import re import collections Token specification NUM = r'(?P \d+)' PLUS = r'(?P +)' MINUS = r'(?P -)' TIMES = r'(?P *)' DIVIDE = r'(?P /)' LPAREN = r'(?P ()' RPAREN = r'(?P ))' WS = r'(?P \s+)' master_pat = re.compile('|'.join([NUM, PLUS, MINUS, TIMES, DIVIDE, LPAREN, RPAREN, WS])) Tokenizer Token = collections.namedtuple('Token', ['type', 'value']) def generate_tokens(text): scanner = master_pat.scanner(text) for m in iter(scanner.match, None): tok = Token(m.lastgroup, m.group()) if tok.type != 'WS': yield tok Parser class ExpressionEvaluator: ''' Implementation of a recursive descent parser. Each method implements a single grammar rule. Use the ._accept() method to test and accept the current lookahead token. Use the ._expect() method to exactly match and discard the next token on on the input (or raise a SyntaxError if it doesn't match). ''' def parse(self, text): self.tokens = generate_tokens(text) self.tok = None # Last symbol consumed self.nexttok = None # Next symbol tokenized self._advance() # Load first lookahead token return self.expr() def _advance(self): 'Advance one token ahead' self.tok, self.nexttok = self.nexttok, next(self.tokens, None) def _accept(self, toktype): 'Test and consume the next token if it matches toktype' if self.nexttok and self.nexttok.type == toktype: self._advance() return True else: return False def _expect(self, toktype): 'Consume next token if it matches toktype or raise SyntaxError' if not self._accept(toktype): raise SyntaxError('Expected ' + toktype) # Grammar rules follow def expr(self): "expression ::= term { ('+'|'-') term }*" exprval = self.term() while self._accept('PLUS') or self._accept('MINUS'): op = self.tok.type right = self.term() if op == 'PLUS': exprval += right elif op == 'MINUS': exprval -= right return exprval def term(self): "term ::= factor { ('*'|'/') factor }*" termval = self.factor() while self._accept('TIMES') or self._accept('DIVIDE'): op = self.tok.type right = self.factor() if op == 'TIMES': termval *= right elif op == 'DIVIDE': termval /= right return termval def factor(self): "factor ::= NUM | ( expr )" if self._accept('NUM'): return int(self.tok.value) elif self._accept('LPAREN'): exprval = self.expr() self._expect('RPAREN') return exprval else: raise SyntaxError('Expected NUMBER or LPAREN') def descent_parser(): e = ExpressionEvaluator() print(e.parse('2')) print(e.parse('2 + 3')) print(e.parse('2 + 3 * 4')) print(e.parse('2 + (3 + 4) * 5')) # print(e.parse('2 + (3 + * 4)')) # Traceback (most recent call last): # File " ", line 1, in # File "exprparse.py", line 40, in parse # return self.expr() # File "exprparse.py", line 67, in expr # right = self.term() # File "exprparse.py", line 77, in term # termval = self.factor() # File "exprparse.py", line 93, in factor # exprval = self.expr() # File "exprparse.py", line 67, in expr # right = self.term() # File "exprparse.py", line 77, in term # termval = self.factor() # File "exprparse.py", line 97, in factor # raise SyntaxError("Expected NUMBER or LPAREN") # SyntaxError: Expected NUMBER or LPAREN if name == 'main': descent_parser() 讨论 文本解析是一个很大的主题, 一般会占用学生学习编译课程时刚开始的三周时间。如果你在找寻关于语法,解析算法等相关的背景知识的话,你应该去看一下编译器书籍。很显然,关于这方面的内容太多,不可能在这里全部展开。 尽管如此,编写一个递归下降解析器的整体思路是比较简单的。开始的时候,你先获得所有的语法规则,然后将其转换为一个函数或者方法。因此如果你的语法类似这样: expr ::= term { ('+'|'-') term }* term ::= factor { (''|'/') factor } factor ::= '(' expr ')' | NUM 你应该首先将它们转换成一组像下面这样的方法: class ExpressionEvaluator: ... def expr(self): ... def term(self): ... def factor(self): ... 每个方法要完成的任务很简单 - 它必须从左至右遍历语法规则的每一部分,处理每个令牌。从某种意义上讲,方法的目的就是要么处理完语法规则,要么产生一个语法错误。为了这样做,需采用下面的这些实现方法: 如果规则中的下个符号是另外一个语法规则的名字(比如term或factor),就简单的调用同名的方法即可。这就是该算法中”下降”的由来 - 控制下降到另一个语法规则中去。有时候规则会调用已经执行的方法(比如,在 factor ::= '('expr ')' 中对expr的调用)。这就是算法中”递归”的由来。 如果规则中下一个符号是个特殊符号(比如(),你得查找下一个令牌并确认是一个精确匹配)。如果不匹配,就产生一个语法错误。这一节中的 _expect() 方法就是用来做这一步的。 如果规则中下一个符号为一些可能的选择项(比如 + 或 -),你必须对每一种可能情况检查下一个令牌,只有当它匹配一个的时候才能继续。这也是本节示例中 _accept() 方法的目的。它相当于_expect()方法的弱化版本,因为如果一个匹配找到了它会继续,但是如果没找到,它不会产生错误而是回滚(允许后续的检查继续进行)。 对于有重复部分的规则(比如在规则表达式 ::= term { ('+'|'-') term }* 中),重复动作通过一个while循环来实现。循环主体会收集或处理所有的重复元素直到没有其他元素可以找到。 一旦整个语法规则处理完成,每个方法会返回某种结果给调用者。这就是在解析过程中值是怎样累加的原理。比如,在表达式求值程序中,返回值代表表达式解析后的部分结果。最后所有值会在最顶层的语法规则方法中合并起来。 尽管向你演示的是一个简单的例子,递归下降解析器可以用来实现非常复杂的解析。比如,Python语言本身就是通过一个递归下降解析器去解释的。如果你对此感兴趣,你可以通过查看Python源码文件Grammar/Grammar来研究下底层语法机制。看完你会发现,通过手动方式去实现一个解析器其实会有很多的局限和不足之处。 其中一个局限就是它们不能被用于包含任何左递归的语法规则中。比如,加入你需要翻译下面这样一个规则: items ::= items ',' item | item 为了这样做,你可能会像下面这样使用 items() 方法: def items(self): itemsval = self.items() if itemsval and self._accept(','): itemsval.append(self.item()) else: itemsval = [ self.item() ] 唯一的问题是这个方法根本不能工作,事实上,它会产生一个无限递归错误。 关于语法规则本身你可能也会碰到一些棘手的问题。比如,你可能想知道下面这个简单扼语法是否表述得当: expr ::= factor { ('+'|'-'|''|'/') factor } factor ::= '(' expression ')' | NUM 这个语法看上去没啥问题,但是它却不能察觉到标准四则运算中的运算符优先级。比如,表达式 "3 + 4 * 5" 会得到35而不是期望的23.分开使用”expr”和”term”规则可以让它正确的工作。 对于复杂的语法,你最好是选择某个解析工具比如PyParsing或者是PLY。下面是使用PLY来重写表达式求值程序的代码: from ply.lex import lex from ply.yacc import yacc Token list tokens = [ 'NUM', 'PLUS', 'MINUS', 'TIMES', 'DIVIDE', 'LPAREN', 'RPAREN' ] Ignored characters t_ignore = ' \t\n' Token specifications (as regexs) t_PLUS = r'+' t_MINUS = r'-' t_TIMES = r'*' t_DIVIDE = r'/' t_LPAREN = r'(' t_RPAREN = r')' Token processing functions def t_NUM(t): r'\d+' t.value = int(t.value) return t Error handler def t_error(t): print('Bad character: {!r}'.format(t.value[0])) t.skip(1) Build the lexer lexer = lex() Grammar rules and handler functions def p_expr(p): ''' expr : expr PLUS term | expr MINUS term ''' if p[2] == '+': p[0] = p[1] + p[3] elif p[2] == '-': p[0] = p[1] - p[3] def p_expr_term(p): ''' expr : term ''' p[0] = p[1] def p_term(p): ''' term : term TIMES factor | term DIVIDE factor ''' if p[2] == '*': p[0] = p[1] * p[3] elif p[2] == '/': p[0] = p[1] / p[3] def p_term_factor(p): ''' term : factor ''' p[0] = p[1] def p_factor(p): ''' factor : NUM ''' p[0] = p[1] def p_factor_group(p): ''' factor : LPAREN expr RPAREN ''' p[0] = p[2] def p_error(p): print('Syntax error') parser = yacc() 这个程序中,所有代码都位于一个比较高的层次。你只需要为令牌写正则表达式和规则匹配时的高阶处理函数即可。而实际的运行解析器,接受令牌等等底层动作已经被库函数实现了。 下面是一个怎样使用得到的解析对象的例子: parser.parse('2') 2 parser.parse('2+3') 5 parser.parse('2+(3+4)*5') 37
景凌凯 2020-04-16 19:33:06 0 浏览量 回答数 0

问题

SSH面试题

1.什么是struts2?struts的工作原理? struts2:1)经典的  mvc (Model  View  Controller) 框架                          ...
琴瑟 2019-12-01 21:46:22 3489 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 企业建站模板