encodeURI() 编码

函数通过将特定字符的每个实例替换为一个、两个、三或四转义序列来对统一资源标识符 (URI) 进行编码 (该字符的 UTF-8 编码仅为四转义序列) 由两个 "代理" 字符组成)。

// 编码高 - 低位完整字符 ok
console.log(encodeURI("\uD800\uDFFF"));

// 编码单独的高位字符抛出 "Uncaught URIError: URI malformed"
console.log(encodeURI("\uD800"));

// 编码单独的低位字符抛出 "Uncaught URIError: URI malformed"
console.log(encodeURI("\uDFFF"));

decodeURI() 解码

decodeURI() 函数能解码由encodeURL创建或其他流程得到的统一资源标识符（URI）。

const uri = 'https://mozilla.org/?x=шеллы';
const encoded = encodeURI(uri);
console.log(encoded);
// Expected output: "https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B"

try {
  console.log(decodeURI(encoded));
  // Expected output: "https://mozilla.org/?x=шеллы"
} catch (e) {
  // Catches a malformed URI
  console.error(e);
}

parseInt()

parseInt(string, radix) 解析一个字符串并返回指定基数的十进制整数，radix 是 2-36 之间的整数，表示被解析字符串的基数。

radix:

从 2 到 36 的整数，表示进制的基数。例如指定 16 表示被解析值是十六进制数。如果超出这个范围，将返回 NaN。假如指定 0 或未指定，基数将会根据字符串的值进行推算。注意，推算的结果不会永远是默认值 10！

console.log(parseInt('123'));
// 123 (default base-10)
console.log(parseInt('123', 10));
// 123 (explicitly specify base-10)
console.log(parseInt('   123 '));
// 123 (whitespace is ignored)
console.log(parseInt('077'));
// 77 (leading zeros are ignored)
console.log(parseInt('1.9'));
// 1 (decimal part is truncated)
console.log(parseInt('ff', 16));
// 255 (lower-case hexadecimal)
console.log(parseInt('0xFF', 16));
// 255 (upper-case hexadecimal with "0x" prefix)
console.log(parseInt('xyz'));
// NaN (input can't be converted to an integer)

parseFloat()

parseFloat(string) 函数解析一个参数（必要时先转换为字符串）并返回一个浮点数。同时parseFloat 是个全局函数，不属于任何对象，需要注意的是：

第二个小数点的出现也会使解析停止（在这之前的字符都会被解析）。
参数首位和末位的空白符会被忽略。
如果参数字符串的第一个字符不能被解析成为数字，则 parseFloat 返回 NaN。
parseFloat 也可以解析并返回 infinity。
parseFloat 解析 Bigint 为 Numbers, 丢失精度。因为末位 n 字符被丢弃。

function circumference(r) {
  return parseFloat(r) * 2.0 * Math.PI;
}

console.log(circumference(4.567));
// Expected output: 28.695307297889173

console.log(circumference('4.567abcdefgh'));
// Expected output: 28.695307297889173

console.log(circumference('abcdefgh'));
// Expected output: NaN

浅拷贝

浅拷贝：创建一个新的对象，来接受你要重新复制或引用的对象值。如果对象属性是基本的数据类型，复制的就是基本类型的值给新对象；但如果属性是引用数据类型，复制的就是内存中的地址，如果其中一个对象改变了这个内存中的地址所指向的对象，肯定会影响到另一个对象。

//浅拷贝
            var myobj1 = {name:"kewin"}
            var myobj2 = {}
            for(var i in myobj1) {
                myobj2[i] = myobj1[i]
            }
            myobj2.name = "xiaoming"
            console.log(myobj1,myobj2)//{name: "kewin"}{name: "xiaoming"}
            
            var myobj3 = {...myobj1}
            myobj3.name = "tiechui"
            
            console.log(myobj3);//{name:"tiechui"}

在浅拷贝之中，上面代码可以看到，在拷贝基础数据类型是他是完全没问题的，修改value值并不会影响到原来的对象

我们对上面的代码修改一下

var myobj1 = {name:"kewin",location:{city:"dalian",province:"liaoning"}}
            var myobj2 = {}
            for(var i in myobj1) {
                myobj2[i] = myobj1[i]
            }
            myobj2.name = "xiaoming"
            console.log(myobj1,myobj2)
            
            var myobj3 = {...myobj1}
            myobj3.name = "tiechui"
            
            myobj1.location.city = "shengyang"
            console.log(myobj3);

输出如下：我们只修改了myobj3的city值，却把myobj1，myobj2的值影响到了

深拷贝的方法方式

var myobj1 = {name:"kewin",location:{city:"dalian",province:"liaoning",
            a:{b:{c:1}}},hobby:["xxx","yyy","zzz"]}
            
            var myobj2 = {}
            
            function deepCopy(o2,o1){
                for(var i in o1){
                    if(o1[i].toString()==='[object Object]'){
                        o2[i] = {}
                        deepCopy(o2[i],o1[i])
                    }else if(Object.prototype.toString.call(o1[i])==='[object Array]'){
                        o2[i] = []
                        deepCopy(o2[i],o1[i])
                    }else{
                        o2[i] = o1[i]
                    }
                }
            }
            
            deepCopy(myobj2,myobj1)//在后台，myobj1的基础数据类型和复杂数据都拷贝到了myobj2中，

JSON 概念

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，采用完全独立于语言的文本格式，是理想的数据交换格式。同时，JSON是 JavaScript 原生格式，这意味着在 JavaScript 中处理 JSON数据不须要任何特殊的 API 或工具包。

JSON.parse()

JSON.parse() 方法用来解析 JSON 字符串，构造由字符串描述的 JavaScript 值或对象。提供可选的 reviver 函数用以在返回之前对所得到的对象执行变换 (操作)。

const json = '{"result":true, "count":42}';
const obj = JSON.parse(json);

console.log(obj.count);
// Expected output: 42

console.log(obj.result);
// Expected output: true

JSON.parse()的其他使用方法

JSON.parse("{}"); // {}
JSON.parse("true"); // true
JSON.parse('"foo"'); // "foo"
JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
JSON.parse("null"); // null

JSON.stringify()

JSON.stringify() 方法将一个 JavaScript 对象或值转换为 JSON 字符串，如果指定了一个 replacer 函数，则可以选择性地替换值，或者指定的 replacer 是数组，则可选择性地仅包含数组指定的属性。

console.log(JSON.stringify({ x: 5, y: 6 }));
// Expected output: '{"x":5,"y":6}'

console.log(
  JSON.stringify([new Number(3), new String('false'), new Boolean(false)]),
);
// Expected output: '[3,"false",false]'

console.log(JSON.stringify({ x: [10, undefined, function () {}, Symbol('')] }));
// Expected output: '{"x":[10,null,null,null]}'

console.log(JSON.stringify(new Date(2006, 0, 2, 15, 4, 5)));
// Expected output: '"2006-01-02T15:04:05.000Z"'

Date.prototype.toJSON()

toJSON() 方法返回 Date 对象的字符串形式。

const event = new Date('August 19, 1975 23:15:30 UTC');

const jsonDate = event.toJSON();

console.log(jsonDate);
// Expected output: "1975-08-19T23:15:30.000Z"

console.log(new Date(jsonDate).toUTCString());
// Expected output: "Tue, 19 Aug 1975 23:15:30 GMT"