章节10.内置对象：Global、Math对象，变量、作用域和内存问题

# 1、内置对象： Global对象

前言
对内置对象的定义是：“由js提供的、不依赖宿主环境的对象，这些对象在js程序执行之前就已经存在了。”意思就是说，开发人员不必显示地实例化内置对象(不用new操作符)；因为它们已经实例化了。js只定义了两个内置对象：Global和 Math。

# ① Global对象

Global(全局)对象是js中一个特别的对象，因为这个对象是不存在的。在js中不属于任何其他对象的属性和方法，都属于Global对象的属性和方法。所以，事实上，并不存在全局变量和全局函数；所有在全局作用域定义的变量和函数，都是 Global 对象的属性和方法。（这句话，在大家学习完面向对象后，才会自我理解，但是在学习面向对象前，我们需要先学习一些基础）
因为js没有定义怎么调用 Global 对象，所以，Global.属性或者 Global.方法()都是无效的。【Web 浏览器将 Global 作为 window 对象的一部分加以实现，即web浏览器用window对象代替Global】
var text = '迪丽热巴';  
console.log(window.text); // '迪丽热巴'
console.log(Global.text); //报错 Global is not defined

# ② Global对象内置的属性和方法：URI 编码方法

我们向浏览器提交数据，比如：网站上面的留言板，你提交你的姓名、电话等等信息，有些信息的字符服务器无法识别，导致一些问题和错误。有些浏览器会自动编码，但有些老版本的浏览器没有自动编码产生错误，这个时候，URI 编码可以对链接、提交的信息进行编码，以便发送给服务器。它们采用特殊的 UTF-8 编码替换所有无效字符，从而让浏览器或者我们的服务器能够接受和理解。
例如：我们将学习文档网址复制粘贴到我们的记事本上，看网址的变化

# ③ URI 编码方法：encodeURI()、encodeURIComponent()

encodeURI():
encodeURI()不会对本身属于 URI 的特殊字符进行编码，例如冒号、正斜杠、问号和#号
encodeURIComponent():
encodeURIComponent()则会对它发现的任何非标准字符进行编码,比 encodeURI()编码来的更加彻底，一般来说encodeURIComponent()使用频率要高一些。
let text = '空姐 //wang';
//encodeURI()编码
let t1 = encodeURI(text);        //只编码了中文
console.log(t1);                 //%E7%A9%BA%E5%A7%90%20//wang
//encodeURIComponent()编码
let t2 = encodeURIComponent(text);//特殊字符和中文编码了
console.log(t2);                 //%E7%A9%BA%E5%A7%90%20%2F%2Fwang

# ④ URI 解码方法：decodeURI()、decodeURIComponent()

console.log(decodeURI('%E7%A9%BA%E5%A7%90%20//wang'));//返回： '空姐 //wang'
console.log(decodeURIComponent('%E7%A9%BA%E5%A7%90%20%2F%2Fwang'));//返回： '空姐 //wang'

# ⑤ eval()方法

eval()方法主要担当一个字符串解析器的作用，他只接受一个参数，而这个参数就是要执行的 JavaScript 代码的字符串。
'var text = 100';
alert(text);//报错，text is not defined

eval('var text = 100');
alert(text);

eval('alert(100)');//弹出 100
//由内向外执行，先弹窗100，然后打印 eval('alert(100)')是 undefined,说明eval()没有返回值
alert(eval('alert(100)'));

//函数也可以
eval('function text() {return 100}'); 
alert(text());
注意：eval()方法的功能非常强大，但也非常危险。因此使用的时候必须极为谨慎。特别是在用户输入数据的情况下，非常有可能导致程序的安全性，比如代码注入等等。场景：比如说，你做了一个留言板的接口表单给用户使用，你用了eval()方法，对填写的表单数据进行包装整合，但是，如果同行写了一个非常危险的js代码，你在运行提交的时候，这段危险的代码就会执行，就会去攻击你的服务器，所以eval()方法要慎用。

# ⑥ Global对象的属性

Global 对象包含了一些属性：undefined、NaN、Object、Array、Function、Date 等等，可直接调用打印。
console.log(Array);//返回构造函数
console.log(Object);//返回构造函数 

# ⑦ window 对象

前面已经说了，Global 没有办法直接访问，而 Web 浏览器可以使用 window 对象来实现一全局访问。
console.log(window.Array);//返回构造函数
console.log(window.Object);//返回构造函数 

# 2、内置对象： Math 对象

js为保存数学公式和信息提供了一个对象，即 Math 对象，方便我们快速计算。

# ① Math 对象的属性

Math 对象包含的属性大都是数学计算中可能会用到的一些特殊值。

属性说明

Math.E 自然对数的底数，即常量 e 的值

Math.LN10 10 的自然对数

Math.LN2 2 的自然对数

Math.LOG2E 以 2 为底 e 的对数

Math.LOG10E 以 10 为底 e 的对数

Math.PI ∏的值 (圆周率)

Math.SQRT1_2 1/2 的平方根

Math.SQRT2 2 的平方根
console.log(Math.E); //2.718281828459045
console.log(Math.LN10);//2.302585092994046
console.log(Math.LN2);//0.6931471805599453
console.log(Math.LOG2E);//1.4426950408889634
console.log(Math.LOG10E);//0.4342944819032518
console.log(Math.PI);//3.141592653589793
console.log(Math.SQRT1_2);//0.7071067811865476
console.log(Math.SQRT2);//1.4142135623730951
# ② Math.min()和 Math.max()方法分别求一组数值中的最小值、最大值

Math.min()用于确定一组数值中的最小值。Math.max()用于确定一组数值中的最大值。
console.log(Math.min(4,7,45,842,478,115,14,15)); //返回： 4
console.log(Math.max(4,7,45,842,478,115,14,15)); //返回：842
# ③ Math.ceil()向上舍入、Math.floor()向下舍入、Math.round()四舍五入

比如：我们给好评或者给几颗星，就用到这些方法。
//向上舍入
console.log(Math.ceil(10.9)); //11
console.log(Math.ceil(10.5)); //11
console.log(Math.ceil(10.1)); //11
//向下舍入
console.log(Math.floor(10.9)); //10
console.log(Math.floor(10.5)); //10
console.log(Math.floor(10.1)); //10
//四舍五入
console.log(Math.round(10.9)); //11
console.log(Math.round(10.5)); //11
console.log(Math.round(10.1)); //10
# ④ Math.random() 产生一个0 到 1 之间随机数，不包括 0 和 1

Math.random()方法返回介于 0 到 1 之间一个随机数，不包括 0 和 1。
for(let i=0;i<50;i++){
   console.log(Math.random());//随机数，0-1之间，不包含0和1
} 
如果想大于这个范围的话，可以套用一下公式：
值 = Math.floor(Math.random() * 总数 + 第一个值)
# 1. 随机产生 1-10 之间的任意数

比如说，网站首页有10张图片，图片名称从1.jpg一直到10.jpg共10张，我希望每个用户打开网站的时候，随机显示一张图片，而不是固定的，这个时候就需要产生一个1-10直接的随机整数，怎么做呢？
let t1 = Math.random() * 10;
//Math.random()* 10，由于随机数是大于0小于1，所以范围是：大于0，小于10之间的任意数
console.log(t1); 

let t2 = Math.random() * 10 + 1;//此时范围就是：大于1，小于11之间的任意数
//此时，如果希望取到1-10之间的随机整数，可配合Math.floor使用
//此时向下舍入，由于最小的随机数是大于1，向下舍入就是1，最大的随机数小于11，向下舍入就是10
console.log(Math.floor(t2));
console.log(Math.floor(Math.random() * 10 + 1));
# 思考：如果取2-13之间的随机数呢 (包括2和13) ？

主要要思考，随机数乘以几？ 乘以几 = 最大数 - 最小数 + 1
公式： 取a-b之间的随机整数 = Math.floor(Math.random() * (b-a+1) + a);
// Math.floor(Math.random() * (13-2+1) + 2);
let t = Math.floor(Math.random() * 12 + 2);
console.log(Math.floor(t));
# ⑤ 取任意两个数之间的随机整数通用函数（方法）
function randomBetween(min, max) {
    let sum = max - min + 1; 
    return Math.floor(Math.random() * sum + min);
}
console.log(randomBetween(5,20));

//随机取30个数字，范围在5-20之间
for(let i=0;i<30;i++){
    console.log(randomBetween(5,20));
}
随机数的用法非常广泛，广泛用在抽奖、生成登录验证码等等很多场景上。

# ⑥ 其他方法

方法说明

Math.abs(num) 返回 num 的绝对值

Math.exp(num) 返回 Math.E 的 num 次幂

Math.log(num) 返回 num 的自然对数

Math.pow(num,power) 返回 num 的 power 次幂

Math.sqrt(num) 返回 num 的平方根

Math.acos(x) 返回 x 的反余弦值

Math.asin(x) 返回 x 的反正弦值

Math.atan(x) 返回 x 的反正切值

Math.atan2(y,x) 返回 y/x 的反正切值

Math.cos(x) 返回 x 的余弦值

Math.sin(x) 返回 x 的正弦值

Math.tan(x) 返回 x 的正切值
console.log(Math.abs(-10));//返回 10
console.log(Math.pow(2,3));//返回 8   2的3次幂 2*2*2 = 8
以上方法用得不多，用的时候回来查看

属性	说明
Math.E	自然对数的底数，即常量 e 的值
Math.LN10	10 的自然对数
Math.LN2	2 的自然对数
Math.LOG2E	以 2 为底 e 的对数
Math.LOG10E	以 10 为底 e 的对数
Math.PI	∏的值 (圆周率)
Math.SQRT1_2	1/2 的平方根
Math.SQRT2	2 的平方根

方法	说明
Math.abs(num)	返回 num 的绝对值
Math.exp(num)	返回 Math.E 的 num 次幂
Math.log(num)	返回 num 的自然对数
Math.pow(num,power)	返回 num 的 power 次幂
Math.sqrt(num)	返回 num 的平方根
Math.acos(x)	返回 x 的反余弦值
Math.asin(x)	返回 x 的反正弦值
Math.atan(x)	返回 x 的反正切值
Math.atan2(y,x)	返回 y/x 的反正切值
Math.cos(x)	返回 x 的余弦值
Math.sin(x)	返回 x 的正弦值
Math.tan(x)	返回 x 的正切值

# 3、变量

js的变量与其他语言的变量有很大区别，是松散型的(不强制类型)本质，决定了它只是在特定时间用于保存特定值的一个名字而已。比如说，一开始我声明的变量是整型，然后过一会我又把这个变量设置成字符串型，在过一会我又把变量设置成引用类型，比如对象，这在其他语言如java、C#等等是不行的，但是js是可以这么做的。

# ① 基本类型和引用类型的值

基本类型值指的是那些保存在栈内存中的简单数据段，即这种值完全保存在内存中的一个位置。而引用类型值则是指那些保存在堆内存中的对象，意思是变量中保存的实际上只是一个指针，这个指针指向内存中的另一个位置，该位置保存对象。

基本类型值有以下几种：Undefined、Null、Boolean、Number 和 String。这些类型在内存中分别占有固定大小的空间，他们的值保存在栈空间，我们通过按值来访问的。

如果赋值的是引用类型的值，则必须在堆内存中为这个值分配空间。由于这种值的大小不固定，因此不能把它们保存到栈内存中。但内存地址大小是固定的，因此可以将内存地址保存在栈内存中。这样，当查询引用类型的变量时，先从栈中读取内存地址，然后再通过地址找到堆中的值。对于这种，我们把它叫做按引用访问。

# ② 动态属性

基本类型值和引用类型值可以执行的操作不一样
// 创建引用类型
let text = new Object();// 或者 let text = {};
text.name = '迪丽热巴'; //新增一个属性
console.log(text.name); //正常输出 '迪丽热巴'

//如果是基本类型的值添加属性的话，就会出现问题
let love = '迪丽热巴'; //创建一个基本类型，是个字符串
love.age = 31; //给基本类型添加属性
console.log(love.age); //返回：undefined  不是引用类型，无法输出
# ③ 复制变量值

在变量复制方面，基本类型和引用类型也有所不同。基本类型复制的是值本身，而引用类型复制的是引用地址。也就是说，不管是基本类型还是引用类型，它们复制的都是栈内存的数据，堆内存的数据是没有办法复制的。
先看基本类型
let text = '迪丽热巴'; //在栈内存生成一个变量text 值为 '迪丽热巴'
// 在声明一个变量love, 将变量text的值复制给love
let love = text; //实际情况是：在栈内存再生成一个变量love  值为'迪丽热巴'
console.log(text);// '迪丽热巴'
console.log(love);// '迪丽热巴'

// 表面上看两个一样，实际上它们两个是独立的，也就是说，两个变量分别操作时互不影响
love = '古力娜扎';// 基本类型保持独立，love的修改不会影响到text
console.log(love);// '古力娜扎'
console.log(text);// '迪丽热巴'
但如果是引用类型的对象，就不一样了
let text = new Object(); //创建一个引用类型
text.name = '迪丽热巴'; //新增一个属性
let love = text; //实际情况：把引用地址赋值给 love，对象数据是在堆内存中
console.log(love.name);//love.name就是text.name，返回：'迪丽热巴'
console.log(text.name);//返回：'迪丽热巴'

// 如果此时love.name改一下
love.name = '古力娜扎';
console.log(love.name);// 返回：'古力娜扎'
// 由于它们指向的是同一个object，同一个name, 不管修改谁，大家都修改了
console.log(text.name);// 返回：'古力娜扎' 
总结：在引用类型中，love 其实就是 text，因为它们指向的是同一个对象。如果这个对象中的 name 属性被修改了，love.name 和 text.name 输出的值都会被相应修改掉了。
# ④ 传递参数：按值传参

js中所有函数的参数都是按值传递的，言下之意就是说，参数不会按引用传递，虽然变量有基本类型和引用类型之分。注意和上面的我们访问要区别，基本类型我们通过按值来访问的，引用类型我们按引用访问。
function text(i){ 
    i += 10; // i = i + 10; //这里的 i 是局部变量，全局无效
    return i;
}

var i = 100;
console.log(text(i)); // 110
//在输出i,思考，这个i是函数里面的i,还是外面的i
console.log(i);// 100 打印的是外面的i，就是按值传递
//如果按照引用传递，那么函数里面的i会成为类似全局变量，把外面的i替换掉
//也就是i最后应该输出110，但是输出的100，所以是按值传递的
# ⑤ 传递参数：传递一个引用类型的参数（对象），但是它不是按引用传递，它是按值传递的
 function text(obj){
    obj.name = '迪丽热巴';
 }
 
 let obj = new Object();
 text(obj);//执行一下函数
 //思考，能输出obj.name吗？我们上面的例子，说的是obj.name是一个局部变量，应该是没有的
 //那么我们这里可以输出吗？
 console.log(obj.name);// '迪丽热巴'
 //可以访问，原因是：我们把外面的obj传递给了函数，而函数里面只是将obj这个引用地址里面新增了一个属性name,赋值叫'迪丽热巴'
 //我外面访问obj,就是访问堆内存里面的数据，是可以访问到的

//延伸一下
function text(obj){
   obj.name = '迪丽热巴';
   var obj = new Object();
   obj.name = '古力娜扎';
   //如果obj是按照引用传递的话，下面应该打印 '古力娜扎'
   //因为下面的obj.name 会替换上面的 obj.name , 通过输出得知 依然是 '迪丽热巴'
  //说明不是按照引用传递的，原因是 函数里面声明的obj，外面看不到
   //如果此时拿到外面来，就能看到
   //所以js没有按引用传参的功能，但是传递参数的时候，可以传递一个对象过去，这在后面我们用得很多
}

var obj = new Object();
text(obj);
console.log(obj.name); // '迪丽热巴'
总结：如果js按引用传递的话，那么函数里的那个变量将会是全局变量，在外部也可以访问。很显然，通过上面的例子，函数里面的变量，外面无法访问，也就是js不是按引用来传递的，是按值来传递的，函数的参数都是局部变量，外面无法访问。
# ⑥ 检测变量类型：typeof()、instanceof()

要检测一个变量的类型，我们可以通过 typeof 运算符来判别
let text = '迪丽热巴';
console.log(typeof text); // string
虽然 typeof 运算符在检查基本数据类型的时候非常好用，但检测引用类型的时候，它就不是那么好用了。通常，我们并不想知道它是不是对象，而是想知道它到底是什么类型的对象。因为数组也是 object，null 也是 Object 等等。
这时我们应该采用 instanceof 运算符来查看.
//是否是数组
let text1 = [1,2,3];
console.log(text1 instanceof Array); //返回： true

//是否是对象
let text2 = {};
console.log(text2 instanceof Object); //返回： true

//是否是字符串对象
let text3 = new String('迪丽热巴');
console.log(text3 instanceof String); //返回： true

//当使用 instanceof 检查基本类型的值时，它会返回 false，所以检查基本类型用typeof
let text = '迪丽热巴';
console.log(typeof text);//string
console.log(text instanceof String);//false
关于new String('迪丽热巴')查看章节2.javascript基础_4、数据类型_Object 类型提到过

# 4、作用域（执行环境）

执行环境是 js 中最为重要的一个概念。执行环境定义了变量或函数有权访问的其他数据，决定了它们各自的行为。全局执行环境是最外围的执行环境。在 Web 浏览器中，全局执行环境被认为是 window 对象。因此所有的全局变量和函数都是作为 window 对象的属性和方法创建的。

# ① 全局执行环境

var text = '迪丽热巴'; //声明一个全局变量
function mygirl() {
   console.log(text); //全局变量可以在函数里访问
}
mygirl(); //执行函数

全局的变量和函数，都是 window 对象的属性和方法。

var text = '迪丽热巴'; // 注意换成let后的变化
function mygirl() {
   console.log(window.text); //全局变量，最外围，即 window 的属性
}
window.mygirl(); //全局函数，最外围，即 window 的方法

注意：当执行环境中的所有代码执行完毕后，该环境被销毁，保存在其中的所有变量和函数定义也随之销毁。如果是全局环境下，需要程序执行完毕，或者网页被关闭才会销毁。

# 1、内置对象： Global对象

# ① Global对象

# ② Global对象内置的属性和方法：URI 编码方法

# ③ URI 编码方法：encodeURI()、encodeURIComponent()

# ④ URI 解码方法：decodeURI()、decodeURIComponent()

# ⑤ eval()方法

# ⑥ Global对象的属性

# ⑦ window 对象

# 2、内置对象： Math 对象

# ① Math 对象的属性

# ② Math.min()和 Math.max()方法分别求一组数值中的最小值、最大值

# ③ Math.ceil()向上舍入、Math.floor()向下舍入、Math.round()四舍五入

# ④ Math.random() 产生一个0 到 1 之间随机数，不包括 0 和 1

# 1. 随机产生 1-10 之间的任意数

# 思考：如果取2-13之间的随机数呢 (包括2和13) ？

# ⑤ 取任意两个数之间的随机整数通用函数（方法）

# ⑥ 其他方法

# 3、变量

# ① 基本类型和引用类型的值

# ② 动态属性

# ③ 复制变量值

# ④ 传递参数： 按值传参

# ⑤ 传递参数： 传递一个引用类型的参数（对象），但是它不是按引用传递，它是按值传递的

# ⑥ 检测变量类型：typeof()、instanceof()

# 4、作用域（执行环境）

# ① 全局执行环境

# ② 局部执行环境

# 1. 那么如何将局部换成全局呢？

# 2. 通过传参，可以替换函数体内的局部变量，但作用域仅限在函数体内这个局部环境

# 3. 函数体内的函数

# ③ 没有块级作用域（var 操作符声明的变量）

# 1. if语句里面的变量是全局变量

# 2.for循环里面的变量也是全局变量

# 3.var 关键字在函数里的区别

# 4. 变量查询中，访问局部变量要比全局变量更快，因为不需要向上搜索作用域链

# 5、 内存问题

# 课程其它章节

# ④ 传递参数：按值传参

# ⑤ 传递参数：传递一个引用类型的参数（对象），但是它不是按引用传递，它是按值传递的

# 5、内存问题