實現一個計算器

產生原因：

（１）一直以來，我都想寫一門語言，但無從下手。
（２）我找到了很多編譯原理的教程，但始終覺得內容晦澀，理解不了，所以先嘗試寫一個簡單的，比如：計算器。
（３）網上有很多關於計算器的實現，但大多需要有編譯原理的基礎，對於我這種小白實在難以理解。
（４）我決定采用暴力模擬的方式，需要用正則表達式，但我不想自己實現，所以用js。

最終要實現什么效果

　　

計算器接受一串字符，處理后返回結果。

我們來看一下要做什么：

首先需要知道有哪些“元素”，比如“１２＋３４×５６"的元素有整數１２，加號，整數３４，乘號，整數５６，這個過程稱為詞法分析。

然后根據符號的優先級進行組合，其過程相當於加括號，１２＋（３４＊５６），這個過程稱為語法分析。

借用正則表達式，可以簡單暴力的實現詞法分析。

什么是正則表達式

正則表達式的概念，和編譯原理一樣，都要費好大功夫來理解，當初也是各種查資料。

盡量簡單的講一講吧。

定義：正則表達式是一種生成器，可以生成大量相同模式的字符串。

字符串的概念大家都懂，來看一下正則表達式是怎么生成字符串的。

例子：正則表達式 ab* 可以生成'a' , 'ab' , 'abb' , 'abbb' ...

正則表達式有三種規則（並，或，閉包），其他規則都是由這三個規則組合而成。

並，直接連在一起，表示相連，例如：abc 生成’abc'

或，以符號|分隔，表示或，例如：a|b生成'a'，'b'

閉包，加符號*，表示重復任意次，例如：a* 生成　''，'a'， 'aa'， 'aaa'...

一些常用的規則：

[]，例如：[abcd]等價於a|b|c|d

+，例如：a+等價於aa*

?，例如：a?等價於　a|空

\d，等價於[0123456789]，還可以用[0-9]

\w，等價於[A-Za-z0-9]

\W，非\w

\b，表示\w與\W的交界處

詞法分析

計算器用到的正則表達式：

+：\+

-：-

*：\*

/：/

(：\(

)：\)

number：\b\d+\b

注意：規則中有的字符要轉義，如：+

不斷用正則來匹配輸入的字符串，就可以。

使用js來實現：

function get_words(buf){
    patterns = [
        ['(',        /\(/],
        [')',        /\)/],
        ['+',        /\+/],
        ['-',        /-/],
        ['*',        /\*/],
        ['/',        /\//],
        ['number',     /\b\d+(\.\d+)?\b/]
        ];
    
    words = [];
    flag = true;
    while (buf && flag) {
        flag = false;
        for (p in patterns) {
            buf = buf.trimLeft();
            ex = patterns[p][1].exec(buf);
            if (ex && ex['index'] == 0) {
                str = ex[0];
                flag = true;
                buf = buf.slice(str.length,Infinity);
                words.push([patterns[p][0], parseFloat(str)]);
                break;
            }
        }
    }
    return words;
}

對於'12+34 * (78-56)'，會得到：

number,12
+,NaN
number,34
*,NaN
(,NaN
number,78
-,NaN
number,56
),NaN

至此，詞法分析完成。

語法分析

我們采用類似於正則的方式來描述語法分析的過程，可稱其為文法。

分析一波。

括號優先級最高，所以遇見括號就要計算，文法為：

<factor> => ( '(' <expr> ')' )  | 'number'

引號的稱終結符，尖括號的稱非終結符。

非終結符表示可以繼續推導，終結符表示推導終點。

其中<expr>表示整個算式

乘除優先級比加法高，所以遇見乘除就要計算，文法為：

<term> => <factor> ( ( '*' <factor> ) | ( '/' <factor> ) ) *

然后是加減：

<expr> => <term> ( ( '+' <term> ) | ( '-' <term> ) ) *

 這些都可以用正則來理解。

其中每個非終結符都做成一個函數，翻譯過來就成。

function parse(words) {
    // <expr>     => <term> (('+' <term>) | ('-' <term>))*
    // <term>     => <factor> (('*' <factor>) | ('/' <factor>))*
    // <factor> => ('(' <expr> ')')  | 'number'
    p = 0;　　
    
    function type() {
        if (p >= words.length) return null;
        return words[p][0];
    }
    function match(sym) {
        if (words[p][0] == sym) {
            return words[p++][1];
        }
        console.log('\nerror\n');
    }
    function expr() {
        value = term();
        while (type() == '+' || type() == '-') {
            if (type() == '+') {
                match('+');
                value += term();
            } else {
                match('-');
                value -= term();
            }
        }
        return value;
    }
    function term() {
        value = factor();
        while (type() == '*' || type() == '/') {
            if (type() == '*') {
                match('*');
                value *= factor();
            } else {
                match('/');
                value /= factor();
            }
        }
        return value;
    }
    function factor() {
        if (type() == '(') {
            match('(');
            value = expr();
            match(')');
        } else if (type() == 'number') {
            value =  match('number');
        }
        return value;
    }
    
    return expr();
}

寫完了，哈哈。

總結

用node.js可以簡單的跑起來：

折起來吧，效果在前面。

var readline = require('readline');
var  rl = readline.createInterface(process.stdin, process.stdout);

rl.setPrompt('calc> ');
rl.prompt();

rl.on('line', function(line) {
    words = get_words(line);
    //console.log(words.join('\n'));
    ans = parse(words);
    console.log(ans);
    rl.prompt();
});

rl.on('close', function() {
    console.log('\nbye bye!');
    process.exit(0);
});

function get_words(buf){
    patterns = [
        ['(',        /\(/],
        [')',        /\)/],
        ['+',        /\+/],
        ['-',        /-/],
        ['*',        /\*/],
        ['/',        /\//],
        ['number',     /\b\d+(\.\d+)?\b/]
        ];
    
    words = [];
    flag = true;
    while (buf && flag) {
        flag = false;
        for (p in patterns) {
            buf = buf.trimLeft();
            ex = patterns[p][1].exec(buf);
            if (ex && ex['index'] == 0) {
                str = ex[0];
                flag = true;
                buf = buf.slice(str.length,Infinity);
                words.push([patterns[p][0], parseFloat(str)]);
                break;
            }
        }
    }
    return words;
}

function parse(words) {
    // <expr>     => <term> (('+' <term>) | ('-' <term>))*
    // <term>     => <factor> (('*' <factor>) | ('/' <factor>))*
    // <factor> => ('(' <ecpr> ')')  | 'number'
    p = 0;
    
    function type() {
        if (p >= words.length) return null;
        return words[p][0];
    }
    function match(sym) {
        if (words[p][0] == sym) {
            return words[p++][1];
        }
        console.log('\nerror\n');
    }
    function expr() {
        value = term();
        while (type() == '+' || type() == '-') {
            if (type() == '+') {
                match('+');
                value += term();
            } else {
                match('-');
                value -= term();
            }
        }
        return value;
    }
    function term() {
        value = factor();
        while (type() == '*' || type() == '/') {
            if (type() == '*') {
                match('*');
                value *= factor();
            } else {
                match('/');
                value /= factor();
            }
        }
        return value;
    }
    function factor() {
        if (type() == '(') {
            match('(');
            value = expr();
            match(')');
        } else if (type() == 'number') {
            value =  match('number');
        }
        return value;
    }
    
    return expr();
}