const bool = JSON.parse('true'); // true
const obj = JSON.parse('{"k":1,"v":2}'); // { k:1 ,v: 2}
const obj2 = JSON.parse('{"k":1,"v":2}',(k,v) => {
    if(k === 'k'){
        return v + 2;
    }
    return v;
}); // { k:3 }
const obj3 = JSON.parse('{"k":1,"v":2}',(k,v) => {
    if(k === 'k'){
        return v + 2;
    }
    // 尤其需要注意這個(gè)特例
   if(k === ""){ return v; }
   return v + 1;
}); // { k:3:,v:3 }

const jsonParser = (() => {
    // ...
    return (source,reviver) => {
        // ...
    }
})();

const jsonParser = (() => {
    let at, // 當(dāng)前字符索引值
        ch, // 當(dāng)前遍歷字符
        text, // 緩存原始json字符串
        escapee = {
          '"': '"',
          '\\': '\\',
          '/': '/',
          b: 'b',
          f: '\f',
          n: '\n',
          r: '\r',
          t: '\t'
        }, // 特殊字符
        error = m => {
          const errorObj = {
                name: 'SyntaxError',
                message: m,
                at,
                text
          };
          console.error(`${JSON.stringify(errorObj)}`); // 控制臺(tái)打印錯(cuò)誤
          // 或者使用throw拋出錯(cuò)誤,即
          // throw errorObj;
        },
        // ...
    return (source,reviver) => {
        // ...
    }
})();

const str = "hello";
str.charAt(0); // h

const jsonParser = (() => {
    let at, 
        //...
        next = c => {
            // 如果有傳入?yún)?shù)，并且該參數(shù)值不等于當(dāng)前字符，則需要給出錯(cuò)誤提示
            if(c && c !== ch){
                error(`預(yù)期${c}代替${ch}`);
            }
            // 根據(jù)索引值讀取當(dāng)前字符
            ch = text.charAt(at);
            at++; // 索引值加1
            //返回當(dāng)前字符
            return ch;
        },
        //...
    return (source,reviver) => {
        // ...
    }
})();

JSON.parse('{"a":"undefined"}'); // { a:"undefined" }
JSON.parse('{"a":undefined}'); // Unexpected token 'u', "{"a":undefined}" is not valid JSON
// 數(shù)組解析同理

const jsonParser = (() => {
    let at, 
        //...
        white = () => {
            // 注意這里為什么是使用<=而非==,因?yàn)檫€有類似\n這樣的空白符
            while(ch && ch <= ' '){
                next();
            }
        },
        word = () => {
            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(`意料之外的值:${ch}`);
        },
        //...
    return (source,reviver) => {
        // ...
    }
})();

const isNumber = v => v >= '0' && v <= '9';

const jsonParser = (() => {
    let at, 
        //...
        number = () => {
            let number,string = ''; // 定義number存儲(chǔ)最終轉(zhuǎn)換成數(shù)字的結(jié)果，定義string變量拼接字符串
            // 符號(hào)的拼接，+號(hào)通常是不會(huì)寫的，因此不需要判斷
            if(ch === '-'){
                string += ch;
                next('-');
            }
            // 循環(huán)數(shù)字
            while(ch >= '0' && ch <= '9'){
                string += ch;
                next();
            }
            //小數(shù)點(diǎn)
            if(ch === '.'){
                string += ch;
                while(next() && ch >= '0' && ch <= '9'){
                    string += ch;
                    next();
                }
            }
            //科學(xué)計(jì)數(shù)法
            if(ch === 'e' || ch === 'E'){
                string += ch;
                next();
                // 科學(xué)計(jì)數(shù)法e字母后還有可能是正負(fù)號(hào)
                if(ch === '-' || ch === '+'){
                    string += ch;
                    next();
                }
                // 科學(xué)計(jì)數(shù)法e字母之后的數(shù)字
                while(ch >= '0' && ch <= '9'){
                    string += ch;
                    next();
                }
            }
            
          // 轉(zhuǎn)換成數(shù)值賦值給number變量
          number = +string;
          //判斷是否是NaN
          if(isNaN(number)){
              error('錯(cuò)誤的數(shù)值');
          }else{
              return number;
          }
     },
    //...
    return (source,reviver) => {
        // ...
    }
})();

const jsonParser = (() => {
    let at, 
        //...
        string = () => {
            let hex,i,string,uChar;
            if(ch === '"'){
                // 從下一個(gè)字符開始循環(huán)
                while(next()){
                    if(ch === '"'){
                        // 如果是另一個(gè)雙引號(hào)，則是字符串的結(jié)束
                        next();
                        return string;
                    }else if(ch === '\\'){
                        // 如果是Unicode字符
                        next();
                        // 如果當(dāng)前字符是u字母
                        if(ch === 'u'){
                            uChar = 0;
                            for(i = 0;i < 4;i++){
                                // 轉(zhuǎn)換成16進(jìn)制數(shù)
                                hex = parseInt(next(),16);
                                // 如果hex不是一個(gè)有限數(shù)值，則跳出循環(huán)
                                if(!isFinite(hex)){
                                    break;
                                }
                                // 計(jì)算uChar
                                uChar = uChar * 16 + hex;
                            }
                        }else if(typeof escapee[ch] === 'string'){
                            // 如果是特殊字符，則直接拼接
                            string += escapee[ch];
                        }else{
                            // 跳出循環(huán)
                            break;
                        }
                        // 拼接最終結(jié)果
                        string += String.fromCharCode(uChar);
                    }else{
                        // 否則當(dāng)成普通字符拼接
                        string += ch;
                    }
                }
            }
            // 如果當(dāng)前字符不是"開頭，則是一個(gè)錯(cuò)誤的字符串
            error('錯(cuò)誤的字符串');
        },
        //...
    return (source,reviver) => {
        // ...
    }
})();

const jsonParser = (() => {
    let at, 
        //...
        value,
        //...
    return (source,reviver) => {
        // ...
    }
})();

const jsonParser = (() => {
    let at, 
        //...
        value,
        array = () => {
            const array = [];
            // [開頭則繼續(xù)下一個(gè)字符，并跳過(guò)空白
            if(ch === '['){
                next('[');
                white();
            }
            // ]則解析結(jié)束，返回結(jié)果
            if(ch === ']'){
                next(']');
                return array;
            }
            // 循環(huán)字符
            while(ch){
                array.push(value());
                white();
                // ]則結(jié)束解析
                if(ch === ']'){
                    next(']');
                    return array;
                }
                // 跳過(guò)逗號(hào)字符的解析
                next(',');
                white();
            }
            // 錯(cuò)誤的數(shù)組數(shù)據(jù)
            error('錯(cuò)誤的數(shù)組');
        }
        //...
    return (source,reviver) => {
        // ...
    }
})();

const jsonParser = (() => {
    let at, 
        //...
        value,
        object = () => {
            let key,object = {}; // 存儲(chǔ)屬性名和結(jié)果所定義的變量
            if(ch === '{'){
                // 跳過(guò){字符解析下一個(gè)字符
                next('{');
                // 可能存在空白字符
                white();
                // 如果是}字符，則結(jié)束解析，并返回結(jié)果
                if(ch === '}'){
                    next('}');
                    return object;
                }
                // 循環(huán)字符
                while(ch){
                    // 屬性名即解析字符串
                    key = string();
                    // 可能存在空白字符，跳過(guò)
                    white();
                    // 跳過(guò):字符
                    next(':');
                    // value值是一個(gè)函數(shù)，下文會(huì)介紹
                    object[key] = value();
                    // 跳過(guò)空白
                    white();
                    // 如果是}，則解析結(jié)束
                    if(ch === '}'){
                        next('}');
                        return object;
                    }
                    // 跳過(guò),字符解析下一個(gè)字符
                    next(',');
                    // 可能存在空白字符，跳過(guò)
                    white();
                }
            }
            // 如果不是以{開頭，則對(duì)象格式不符合，拋出錯(cuò)誤
            error('錯(cuò)誤的對(duì)象');
        },
        //...
    return (source,reviver) => {
        // ...
    }
})();

const jsonParser = (() => {
    let at, 
        //...
        value,
        //...定義完object方法之后再賦值value
        value = () => {
            // 可能存在空白字符，跳過(guò)
            white();
            // 判斷以什么字符開頭
            switch(ch){
                case '{':
                    return object(); // 對(duì)象解析
                case '[':
                    return array(); // 數(shù)組解析
                case '"':
                    return string(); // 字符串解析
                case '-':
                    return number(); // 數(shù)值解析
                default:
                    return ch >= '0' && ch <= '9' ? number() : word(); // 如果是數(shù)字則當(dāng)做是數(shù)值解析，否則當(dāng)做布爾值或null解析
            }
        };
    return (source,reviver) => {
        // ...
    }
})();

const jsonParser = (() => {
    // ...
    return (source,reviver) => {
        // 解析結(jié)果,原始字符串,起始解析索引值,起始解析字符
        let result,text = source,at = 0,ch = ' ';
        // 解析值并賦值
        result = value();
        // 跳過(guò)空白字符
        white();
        // 如果還存在解析字符,則數(shù)據(jù)不符合json規(guī)范，給出錯(cuò)誤
        if(ch){
            error('解析語(yǔ)法錯(cuò)誤,不是一個(gè)合格的json數(shù)據(jù)');
        }
        // 返回
        return typeof reviver === 'function' ? (function walk(holder,key){
            // ...
        })({ '':result },'') : result;
    }
})();

const obj3 = JSON.parse('{"k":1,"v":2}',(k,v) => {
    if(k === 'k'){
        return v + 2;
    }
    // 尤其需要注意這個(gè)特例
   if(k === ""){ return v; }
   return v + 1;
}); // { k:3:,v:3 }

const jsonParser = (() => {
    // ...
    return (source,reviver) => {
        // ...
        return typeof reviver === 'function' ? (function walk(holder,key){
            // 循環(huán)屬性名，緩存屬性值，讀取值
            let k,v,value = holder[key];
            // 如果值是對(duì)象，則需要繼續(xù)解析
            if(value && typeof value === 'object'){
                // 循環(huán)對(duì)象屬性值
                for(k in value){
                    // 如果value中存在該屬性
                    if(Object.hasOwnProperty.call(value,k)){
                        // 繼續(xù)遞歸
                        v = walk(value,k);
                        // 如果屬性值不是undefined則修改屬性值，否則刪除該屬性
                        if(v !== undefined){
                            value[k] = v;
                        }else{
                            delete value[k];
                        }
                    }
                }
            }
            // 返回轉(zhuǎn)換器函數(shù)調(diào)用的結(jié)果
            return reviver.call(holder,key,value);
        })({ '':result },'') : result;
    }
})();