javascript 實現JSON.parse 字符串解析爲JSON json_decode

* json_parse.js

var json_parse = function() {
    // 這是一個能把JSON文本解析成javascript數據結構的函數
    // 它是一個簡單的遞歸降序解析器
    var at = 0, 	    // 當前字符的索引
        ch = '';			// 當前字符

    var escapee = {
            '"': '"',
            '\\': '\\',
            '/': '/',
            b: 'b',
            f: '\f',
            n: '\n',
            r: '\r',
            t: '\t'
        },
        text = "",
        error = function(m) {
        // 當某處出錯時, 調用error
            throw {
                name: 'SyntaxError',
                message: m,
                at: at,
                text: text
            };
        },
        next = function(c) {
            // 若是提供了參數c, 那麼檢查它是否匹配當前字符
            if (c && c !== ch) {
                error("Expected '"+c+"' instead of '"+ch+"'");
            }
            // 獲取下一個字符。當沒有下一個字符時, 返回一個空字符串
            ch = text.charAt(at);
            at += 1;
            return ch;
        },
        number = function() {
            // 解析一個數字值
            var number, string = '';
            if (ch === '-') {
                string = '-';
                next('-');
            }
            while (ch >= '0' && ch <= '9') {
                string += ch;
                next();
            }
            if (ch === '.') {
                string += '.';
                while (next() && ch >= '0' && ch <= '9') {
                    string += ch;
                }
            }
            if (ch === 'e' || ch === 'E') {
                string += ch;
                next();
                if (ch === '-' || ch === '+') {
                    string += ch;
                    next();
                }
                while (ch >= '0' && ch <= '9') {
                    string += ch;
                    next();
                }
            }
            number = +string;
            if (isNaN(number)) {
                error("Bad number");
            } else {
                return number;
            }
        },
        string = function() {
            // 解析一個字符串值
            var hex, i, string = '', uffff;
            // 當解析字符串值時, 咱們必須找到"和\字符
            if (ch === '"') {
                while(next()) {
                    if (ch === "\"") {
                        next();
                        return string;
                    } else if (ch === '\\') {
                        next();
                        if (ch === 'u') {
                            uffff = 0;
                            for (i = 0; i < 4; i+=1) {
                                hex = parseInt(next(), 16);
                                if (!isFinite(hex)) {
                                    break;
                                }
                                uffff = uffff * 16 +hex;
                            }
                            string += String.fromCharCode(uffff);
                        } else if (typeof escapee[ch] === 'string') {
                            string += escapee[ch];
                        } else {
                            break;
                        }
                    } else {
                        string += ch;
                    }
                }
            }
            error("Bad string");
        },
        white = function() {
            // 跳過空白
            while (ch && ch <= ' ') {
                next();
            }
        },
        word = function() {
            // true, false, null
            switch (ch) {
                case 't':
                    next('t'); next('r'); next('u'); next('e');
                    return true;
                case 'f':
                    next('f'); next('a'); next('l'); next('s'); next('e');
                    return false;
                case 'n':
                    next('n'); next('u'); next('l'); next('l');
                    return null;
            }
            error("Unexpected '"+ch+"'");
        },
        array = function() {
            // 解析一個數組值
            var array = [];
            if (ch === '[') {
                next('[');
                white();
                if (ch === ']') {
                    next(']');
                    return array; // 空數組
                }
                while (ch) {
                    array.push(value());
                    white();
                    if (ch === ']') {
                        next(']');
                        return array;
                    }
                    next(',');
                    white();
                }
            }
            error("Bad array");
        },
        object = function() {
            // 解析一個對象值
            var key, object = {};
            if (ch === '{') {
                next('{');
                white();
                if (ch === '}') {
                    next('}');
                    return object; // 空對象
                }
                while(ch) {
                    key = string();
                    white();
                    next(':');
                    object[key] = value();
                    white();
                    if (ch === '}') {
                        next('}');
                        return object;
                    }
                    next(',');
                    white();
                }
            }
            error("Bad object");
        },
        value = function() {
            // 解析一個JSON 值 它能夠是對象數組、字符串、數字或一個詞
            white();
            switch (ch) {
                case '{':
                    return object();
                case '[':
                    return array();
                case '"':
                    return string();
                case '-':
                    return number();
                default:
                    return ch >= '0' && ch <= '9' ? number() : word();
            }
        };
    // 返回json_parse函數 它能訪問上述全部的函數和變量
	return function(source, reviver) {
		var result;

		text = source;
		at = 0;
		ch = ' ';
		result = value();
		white();
		if (ch) {
			error("Syntax error");
		}

		// 若是存在reviver函數，咱們就遞歸地對這個新結構調用walk函數,
        // 開始時先建立一個臨時的啓動對象, 並以一個空字符串做爲鍵名保存結果，
        // 而後傳遞每一個 name=>value 對給reviver函數去處理可能存在的轉換。
        // 若是沒有reviver函數，咱們就簡單地返回這個結果
		return typeof reviver === 'function' ?
            function walk(holder, key) {
			let k, v, value = holder[key];
			if (value && typeof value === 'object') {
			    for (k in value) {
			        if (Object.hasOwnProperty.call(value, k)) {
			            v = walk(value, k);
			            if (v !== undefined) {
			                value[k] = v;
                        } else {
			                delete value[k];
                        }
                    }
                }
            }
            return reviver.call(holder, key, value);
		}({'': result}, '') : result;
	}
}();

test case:

var s = "{\"websocket\":true,\"origins\":[\"*:*\"],\"cookie_needed\":false,\"entropy\":477811126}";
var o = json_parse(s);
console.log(o);
console.log(o.origins[0]);

node.js運行結果: 

在瀏覽器上運行結果: