学习内容：内置对象；Math对象；data对象；Array对象；String对象；简单数据类型和复杂数据类型
1 - 内置对象
1.1 内置对象
JavaScript 中的对象分为3种：自定义对象 、内置对象、 浏览器对象
前面两种对象是JS 基础 内容，属于 ECMAScript； 第三个浏览器对象属于 JS 独有的， JS API 讲解内置对象就是指 JS 语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法），内置对象最大的优点就是帮助我们快速开发
JavaScript 提供了多个内置对象：Math、 Date 、Array、String等
1.2 查文档
查找文档：学习一个内置对象的使用，只要学会其常用成员的使用即可，我们可以通过查文档学习，可以通过MDN/W3C来查询。
Mozilla 开发者网络（MDN）提供了有关开放网络技术（Open Web）的信息，包括 HTML、CSS 和万维网及 HTML5 应用的 API。
MDN:https://developer.mozilla.org/zh-CN/。
1.3 Math对象
Math 对象不是构造函数，它具有数学常数和函数的属性和方法。跟数学相关的运算（求绝对值，取整、最大值等）可以使用 Math 中的成员。
| 属性、方法名 | 功能 |
|---|---|
| Math.PI | 圆周率 |
| Math.floor() | 向下取整 |
| Math.ceil() | 向上取整 |
| Math.round() | 四舍五入版 就近取整 注意 -3.5 结果是 -3 |
| Math.abs() | 绝对值 |
| Math.max()/Math.min() | 求最大和最小值 |
| Math.random() | 获取范围在[0,1)内的随机值 |
注意：上面的方法使用时必须带括号。
- random() 方法可以随机返回一个小数，其取值范围是 [0，1)，左闭右开 0 <= x < 1
- 得到一个两数之间的随机整数，包括两个数在内
获取指定范围内的随机整数：
function getRandom(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
// 1.Math对象随机数方法 random() 返回一个随机的小数 0 =< x < 1
// 2. 这个方法里面不跟参数
// 3. 代码验证
console.log(Math.random());
// 4. 我们想要得到两个数之间的随机整数 并且 包含这2个整数
// Math.floor(Math.random() * (max - min + 1)) + min;
function getRandom(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(getRandom(1, 10));
// 5. 随机点名
var arr = ['张三', '张三丰', '张三疯子', '李四', '李思思', 'pink老师'];
console.log(arr[getRandom(0, arr.length - 1)]);
猜数字游戏
① 随机生成一个1~10 的整数 我们需要用到 Math.random() 方法。
② 需要一直猜到正确为止，所以一直循环。
③ 用while 循环合适更简单。
④ 核心算法：使用 if else if 多分支语句来判断大于、小于、等于。
function getRandom(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
var random = getRandom(1, 10);
while (true) { // 死循环
var num = prompt('你来猜？ 输入1~10之间的一个数字');
if (num > random) {
alert('你猜大了');
} else if (num < random) {
alert('你猜小了');
} else {
alert('你好帅哦，猜对了');
break; // 退出整个循环结束程序
}
}
1.4 日期对象
Date 对象和 Math 对象不一样，Date是一个构造函数，所以使用时需要实例化后才能使用其中具体方法和属性。Date 实例用来处理日期和时间
-
使用Date实例化日期对象
- 获取当前时间必须实例化：
var now = new Date();- 获取指定时间的日期对象
var future = new Date('2019/5/1');注意：如果创建实例时并未传入参数，则得到的日期对象是当前时间对应的日期对象
-
使用Date实例的方法和属性
格式化日期 年月日
// 格式化日期 年月日
var date = new Date();
console.log(date.getFullYear()); // 返回当前日期的年 2019
console.log(date.getMonth() + 1); // 月份 返回的月份小1个月 记得月份+1 呦
console.log(date.getDate()); // 返回的是 几号
console.log(date.getDay()); // 3 周一返回的是 1 周六返回的是 6 但是 周日返回的是 0
// 我们写一个 2019年 5月 1日 星期三
var year = date.getFullYear();
var month = date.getMonth() + 1;
var dates = date.getDate();
var arr = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
var day = date.getDay();
console.log('今天是：' + year + '年' + month + '月' + dates + '日 ' + arr[day]);
格式化日期 时分秒
// 格式化日期 时分秒
var date = new Date();
console.log(date.getHours()); // 时
console.log(date.getMinutes()); // 分
console.log(date.getSeconds()); // 秒
// 要求封装一个函数返回当前的时分秒 格式 08:08:08
function getTimer() {
var time = new Date();
var h = time.getHours();
h = h < 10 ? '0' + h : h;
var m = time.getMinutes();
m = m < 10 ? '0' + m : m;
var s = time.getSeconds();
s = s < 10 ? '0' + s : s;
return h + ':' + m + ':' + s;
}
console.log(getTimer());
-
通过Date实例获取总毫米数
-
总毫秒数的含义
基于1970年1月1日（世界标准时间）起的毫秒数
-
获取总毫秒数
// 获得Date总的毫秒数(时间戳) 不是当前时间的毫秒数 而是距离1970年1月1号过了多少毫秒数 // 1. 通过 valueOf() getTime() var date = new Date(); console.log(date.valueOf()); // 就是 我们现在时间 距离1970.1.1 总的毫秒数 console.log(date.getTime()); // 2. 简单的写法 (最常用的写法) var date1 = +new Date(); // +new Date() 返回的就是总的毫秒数 console.log(date1); // 3. H5 新增的 获得总的毫秒数 console.log(Date.now());
-
/*
输出日期:
.toDateString() 以人类易读（human-readable）的形式返回该日期对象日期部分的字符串。
.toLocaleDateString() 返回一个表示该日期对象日期部分的字符串，该字符串格式与系统设置的地区关联
.toLocaleString()返回一个表示该日期对象的字符串，该字符串与系统设置的地区关联（locality sensitive）。
覆盖了 Object.prototype.toLocaleString() 方法。
.toLocaleTimeString() 返回一个表示该日期对象时间部分的字符串，该字符串格式与系统设置的地区关联。
.toTimeString() 以人类易读格式返回日期对象时间部分的字符串。
.toUTCString() 把一个日期对象转换为一个以UTC时区计时的字符串。
*/
console.log(dt.toDateString())
console.log(dt.toLocaleDateString());//本地日期格式输出日期
console.log(dt.toLocaleTimeString());//以本地格式输出时间
console.log(dt.toTimeString());
console.log(dt.toUTCString());
倒计时效果
// 倒计时效果
// 1.核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时 ，但是不能拿着时分秒相减，比如 05 分减去25分，结果会是负数的。
// 2.用时间戳来做。用户输入时间总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数。
// 3.把剩余时间总的毫秒数转换为天、时、分、秒 （时间戳转换为时分秒）
// 转换公式如下：
// d = parseInt(总秒数/ 60/60 /24); // 计算天数
// h = parseInt(总秒数/ 60/60 %24) // 计算小时
// m = parseInt(总秒数 /60 %60 ); // 计算分数
// s = parseInt(总秒数%60); // 计算当前秒数
function countDown(time) {
var nowTime = +new Date(); // 返回的是当前时间总的毫秒数
var inputTime = +new Date(time); // 返回的是用户输入时间总的毫秒数
var times = (inputTime - nowTime) / 1000; // times是剩余时间总的秒数
var d = parseInt(times / 60 / 60 / 24); // 天
d = d < 10 ? '0' + d : d;
var h = parseInt(times / 60 / 60 % 24); //时
h = h < 10 ? '0' + h : h;
var m = parseInt(times / 60 % 60); // 分
m = m < 10 ? '0' + m : m;
var s = parseInt(times % 60); // 当前的秒
s = s < 10 ? '0' + s : s;
return d + '天' + h + '时' + m + '分' + s + '秒';
}
console.log(countDown('2019-5-1 18:00:00'));
var date = new Date();
console.log(date);
1.5 数组对象
创建数组的两种方式
-
字面量方式
-
示例代码如下：
var arr = [1,"test",true];
-
-
new Array()
-
示例代码如下：
var arr = new Array(); 注意：上面代码中arr创建出的是一个空数组，如果需要使用构造函数Array创建非空数组，可以在创建数组时传入参数
参数传递规则如下：
-
如果只传入一个参数，则参数规定了数组的长度
-
如果传入了多个参数，则参数称为数组的元素
-
-
检测是否为数组
-
instanceof 运算符-
instanceof 可以判断一个对象是否为数组实例
var arr = [1, 23]; var obj = {}; console.log(arr instanceof Array); // true console.log(obj instanceof Array); // false
-
-
Array.isArray(参数); H5新增的方法 ie9以上版本支持-
Array.isArray()用于判断一个对象是否为数组，isArray() 是 HTML5 中提供的方法
var arr = [1, 23]; var obj = {}; console.log(Array.isArray(arr)); // true console.log(Array.isArray(obj)); // false
-
添加删除数组元素的方法
-
数组中有进行增加、删除元素的方法，部分方法如下表
注意：push、unshift为增加元素方法；pop、shift为删除元素的方法
筛选数组
// 有一个包含工资的数组[1500, 1200, 2000, 2100, 1800]，要求把数组中工资超过2000的删除，剩余的放到新数组里面
var arr = [1500, 1200, 2000, 2100, 1800];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] < 2000) {
// newArr[newArr.length] = arr[i];
newArr.push(arr[i]);
}
}
console.log(newArr);
数组排序
-
数组中有对数组本身排序的方法，部分方法如下表
注意：sort方法需要传入参数来设置升序、降序排序
- 如果传入
“function(a,b){ return a-b;}”，则为升序 - 如果传入
“function(a,b){ return b-a;}”，则为降序
- 如果传入
数组排序
// 数组排序
// 1. 翻转数组
var arr = ['pink', 'red', 'blue'];
arr.reverse();
console.log(arr);
// 2. 数组排序（冒泡排序）
var arr1 = [13, 4, 77, 1, 7];
arr1.sort(function(a, b) {
// return a - b; 升序的顺序排列
return b - a; // 降序的顺序排列
});
console.log(arr1);
数组索引方法
-
数组中有获取数组指定元素索引值的方法，部分方法如下表
数组去重
// 数组去重 ['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b'] 要求去除数组中重复的元素。
// 1.目标： 把旧数组里面不重复的元素选取出来放到新数组中， 重复的元素只保留一个， 放到新数组中去重。
// 2.核心算法： 我们遍历旧数组， 然后拿着旧数组元素去查询新数组， 如果该元素在新数组里面没有出现过， 我们就添加， 否则不添加。
// 3.我们怎么知道该元素没有存在？ 利用 新数组.indexOf(数组元素) 如果返回时 - 1 就说明 新数组里面没有改元素
// 封装一个 去重的函数 unique 独一无二的
function unique(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (newArr.indexOf(arr[i]) === -1) {
newArr.push(arr[i]);
}
}
return newArr;
}
// var demo = unique(['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b'])
var demo = unique(['blue', 'green', 'blue'])
console.log(demo);
数组转换为字符串
-
数组中有把数组转化为字符串的方法，部分方法如下表
注意：join方法如果不传入参数，则按照 “ , ”拼接元素
其他方法
-
数组中还有其他操作方法，同学们可以在课下自行查阅学习
1. slice()：
slice(start, end) 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。
使用 start（包含） 和 end（不包含） 参数来指定字符串提取的部分。
start 参数字符串中第一个字符位置为 0, 第二个字符位置为 1, 以此类推，如果是负数表示从尾部截取多少个字符串，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元（包含最后一个元素）。end 参数如果为负数，-1 指字符串的最后一个字符的位置，-2 指倒数第二个字符，以此类推。
2.concat()
3.splice
1.6 字符串对象
String对象原型方法
/* .charAt() 从一个字符串中返回指定位置的字符 位置从 0开始 */
var str="中hello boy";
console.log(str.charAt(0));//获取第一个位置的字符
console.log(str.charAt(1));//获取第二个位置的字符
console.log(str.charAt(2));
console.log('99位置的字符=>',str.charAt(99)); //返回一个 ''
console.log('字符串下标==>',str[0],str[8]); //字符串列表 通过字符串下标获取字符
//.charCodeAt(index) 指定 index 处字符的 UTF-16 编码号(小于 65,536 的值)；如果 index 超出范围，charCodeAt() 返回 NaN
var str2='abcd I love you';
console.log('编码==>',str2.charCodeAt(0));//返回a编码号 97
console.log('编码==>',str2.charCodeAt(1));//返回b编码号 98
console.log('编码==>',str2.charCodeAt(2));//返回c编码号 99
var str3='I love you by zhuYongCheng';
var codeNum=[];
for(var i=0;i<str3.length;i++){
codeNum.push(str3.charCodeAt(i));
}
console.log(codeNum)
//String.fromCharCode(unicode 编码号); 把编码对应的字符还原成字符串
for(var i in codeNum){
var s=String.fromCharCode(codeNum[i]);
// console.log(s)
}
基本包装类型
为了方便操作基本数据类型，JavaScript 还提供了三个特殊的引用类型：String、Number和 Boolean。
基本包装类型就是把简单数据类型包装成为复杂数据类型，这样基本数据类型就有了属性和方法。
// 下面代码有什么问题？
var str = 'andy';
console.log(str.length);
按道理基本数据类型是没有属性和方法的，而对象才有属性和方法，但上面代码却可以执行，这是因为
js 会把基本数据类型包装为复杂数据类型，其执行过程如下 ：
// 1. 生成临时变量，把简单类型包装为复杂数据类型
var temp = new String('andy');
// 2. 赋值给我们声明的字符变量
str = temp;
// 3. 销毁临时变量
temp = null;
字符串的不可变
指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间。
当重新给字符串变量赋值的时候，变量之前保存的字符串不会被修改，依然在内存中重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变。
由于字符串的不可变，在大量拼接字符串的时候会有效率问题
根据字符返回位置()
字符串对象 根据字符返回位置 字符串对象.indexOf('要查找的字符', [起始的位置])
字符串通过基本包装类型可以调用部分方法来操作字符串，以下是返回指定字符的位置的方法：
案例
：查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数
- 先查找第一个o出现的位置
- 然后 只要indexOf 返回的结果不是 -1 就继续往后查找
- 因为indexOf 只能查找到第一个，所以后面的查找，利用第二个参数，当前索引加1，从而继续查找
var str = "oabcoefoxyozzopp";
var index = str.indexOf('o');
var num = 0;
// console.log(index);
while (index !== -1) {
console.log(index);
num++;
index = str.indexOf('o', index + 1);
}
console.log('o出现的次数是: ' + num);
根据位置返回字符(重点)
字符串通过基本包装类型可以调用部分方法来操作字符串，以下是根据位置返回指定位置上的字符：
在上述方法中，charCodeAt方法返回的是指定位置上字符对应的ASCII码，ASCII码对照表如下：
- 有一个对象 来判断是否有该属性 对象['属性名']。
案例：判断一个字符串 ‘abcoefoxyozzopp’ 中出现次数最多的字符，并统计其次数
-
核心算法：利用 charAt(） 遍历这个字符串
-
把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1
-
遍历对象，得到最大值和该字符
var str = 'abcoefoxyozzopp';
var o = {};
for (var i = 0; i < str.length; i++) {
var chars = str.charAt(i); // chars 是 字符串的每一个字符
if (o[chars]) { // o[chars] 得到的是属性值
o[chars]++;
} else {
o[chars] = 1;
}
}
console.log(o);
// 2. 遍历对象
var max = 0;
var ch = '';
for (var k in o) {
// k 得到是 属性名
// o[k] 得到的是属性值
if (o[k] > max) {
max = o[k];
ch = k;
}
}
console.log(max);
console.log('最多的字符是' + ch);
注意：在遍历的过程中，把字符串中的每个字符作为对象的属性存储在对象总，对应的属性值是该字符出现的次数
字符串操作方法（重点）
字符串通过基本包装类型可以调用部分方法来操作字符串，以下是部分操作方法：
substr('截取的起始位置', '截取几个字符');
replace()方法
replace() 方法用于在字符串中用一些字符替换另一些字符，其使用格式如下：
字符串.replace(被替换的字符串， 要替换为的字符串)；
split()方法
split()方法用于切分字符串，它可以将字符串切分为数组。在切分完毕之后，返回的是一个新数组。
其使用格式如下：
字符串.split("分割字符")
String对象和Array总结
字符串对象的常用属性和方法共9个：
内置属性：
length属性 返回字符串的长度
常用方法： 注意，调用这些方法本身不会改变原有字符串的内容，而是返回一个新字符串，共9个
toUpperCase()把一个字符串全部变为大写
toLowerCase()把一个字符串全部变为小写
indexOf() 返回某个指定的字符串值在字符串中首次出现的位置，如果没找到返回-1，indexOf() 方法区分大小写。
match() 用来查找字符串中特定的字符，如果找到，则返回这个字符
replace() 在字符串中用某些字符替换另一些字符
split() 将字符串分割为字符串数组，并返回此数组,
stringObject.split(separator,limit) 如果把空字符串 ("") 用作 separator，那么 stringObject 中的每个字符之间都会被分割。
var str="How are you doing today?";
var n=str.split(" "); // How,are,you,doing,today?
slice(start, end) 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分
使用 start（包含） 和 end（不包含） 参数来指定字符串提取的部分,字符串中第一个字符位置为 0, 第二个字符位置为 1, 以此类推
如果是负数，则该参数规定的是从字符串的尾部开始算起的位置。也就是说，-1 指字符串的最后一个字符，-2 指倒数第二个字符，以此类推
var str="Hello world!";
var n=str.slice(1,5); // ello
substring() 提取字符串中介于两个指定下标之间的字符，string.substring(from, to)
substr() 从字符串中提取指定数目的字符，string.substr(start,length)
trim() 去除字符串两边的空白
charAt() 第一个字符位置为 0, 第二个字符位置为 1,以此类推. 返回指定位置的字符，返回的字符是长度为 1 的字符串。如果参数 index 不在 0 与 string.length-1 之间，该方法将返回一个空字符串
数组对象的常用属性和方法共12个：
JavaScript的Array可以包含任意数据类型，并通过索引来访问每个元素。
length属性：获取Array的长度
常用方法：共12个
//1.-----------------
filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
注意： filter() 不会对空数组进行检测。
注意： filter() 不会改变原始数组。
//.filter(function(){}) 过滤筛选 用回调函数遍历数组里面每一项 并生成一个新数组/
var arr17=[10,5,2,20,11,90,8];
var arr18=arr17.filter(function(value,index,arr){
//回调函数 value 数组里面每一项值 ,index 数组值对应每一项的下标索引 arr是原数组
console.log(value,index,arr);
//回调函数需要返回一个boolean值，用来过滤需要保留的元素. true 保留当前遍历的元素生成一个新数组，false 丢弃
//保留数组里面 大于等于10的数据 并生成一个新的数组 arr18
return value>=10;
});
console.log("arr18==>",arr18);
练习//
var arr19=[
{name:"吴军",age:20},
{name:"乔峰",age:40},
{name:"吴yifan",age:20},
{name:"段誉",age:16},
{name:"罗志",age:18},
]
//选出年龄大于18的用户信息 并生成一个新数组
var filUser=function(ele){// ele就是数组里面每一项.
return ele.age>=18;
}
var arr20=arr19.filter(filUser) ;
console.log(arr20);
//2.----------
forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。
注意: forEach() 对于空数组是不会执行回调函数的。
///.forEach(function(){}) 遍历循环数组 没有额外功能//
var arr23=[5,3,8,1,4];
var arr24=arr23.forEach(function(value,index,arr){
//循环遍历数组里面的每一个值 用 function(){} 处理
//回调函数参数: value 数组里面的项(值) index value对应数组下标 arr原数组
console.log(value,index,arr);
});
console.log(arr24)//undefined
/练习forEach/
//复制 items里面的数据到 copy数组
const items = ['item1', 'item2', 'item3']; //const声明常量. 常量就是只读的量.不能修改.
const copy = []; // 数组是引用类型 ，存储在copy里面是内存地址. 数组里面数据存储在堆里面，所以这里修改copy数组的值其实修改只是堆数据.
// for (let i=0; i<items.length; i++) {
// copy.push(items[i]);
// }
var copyFun=function(item){
copy.push(item);
}
items.forEach(copyFun);//把函数作为参数传递给forEach() copyFun就叫回调函数
console.log('copy==>',copy);
///练习 求两个一维数组的差 值
var arr1=[1,5,7];
var arr2=[2,5,6,7,8];
function diffArray(arr,arr2){
var arrAll=arr.concat(arr2);//合并两个数组
console.log('合并结果==>',arrAll)
var a=arrAll.filter(function(value){//遍历合并之后的数组
//如果value在arr不存在 或 在 arr2里面不存在 那这个值就是 差异值.
return arr.indexOf(value) == -1 || arr2.indexOf(value) == -1;
});
return a;
}
arr1=[1,5,6,7];
arr2=[1,23,43,5,6,7];
var result=diffArray(arr1,arr2);
console.log(result)
//-------------------------------
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
map() 方法按照原始数组元素顺序依次处理元素。
注意： map() 不会对空数组进行检测。
注意： map() 不会改变原始数组。
.map(function(){}) 遍历数组，并把数组里面每个值用回调函数function()处理之后的返回结果组成一个新数组 //
var arr21=[5,4,6,8,10];
var arr22=arr21.map(function(value,index,arr){
//回调函数 value 数组里面每一项值 ,index 数组值对应每一项的下标索引 arr是原数组
//console.log(value,index,arr)
return value*5; //把数组里面的每一项 *5 在生成一个新数组
});
console.log(arr22);
var arr23=arr21.map(x => x*10); // x => x*10 是es6里面箭头函数 等同于 function(x){ return x*10; }
console.log("arr23数组==>",arr23);
//----------------
some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。
some() 方法会依次执行数组的每个元素：
如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
如果没有满足条件的元素，则返回false。
注意： some() 不会对空数组进行检测。
注意： some() 不会改变原始数组。
//--------------------------
every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。
every() 方法使用指定函数检测数组中的所有元素：
如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。
注意： every() 不会对空数组进行检测。
注意： every() 不会改变原始数组。
//3--------------
indexOf() 与String类似，Array也可以通过indexOf()来搜索一个指定的元素的位置
该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。
如果在数组中没找到指定元素则返回 -1。
//4--------------
slice() slice()就是对应String的substring()版本，它截取Array的部分元素，然后返回一个新的Array
arrayObject.slice(start,end)
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 从索引0开始，到索引3结束，但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 从索引3开始到结束: ['D', 'E', 'F', 'G']
注意到slice()的起止参数包括开始索引，不包括结束索引
如果不给slice()传递任何参数，它就会从头到尾截取所有元素。利用这一点，我们可以很容易地复制一个Array
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
var aCopy = arr.slice();
aCopy; // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
aCopy === arr; // false
//5--------------
push和pop push()向Array的末尾添加若干元素，pop()则把Array的最后一个元素删除掉，
注意push()方法返回数组新的长度，而pop()方法则返回删除的元素
var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的长度: 4
arr; // [1, 2, 'A', 'B']
arr.pop(); // pop()返回'B'
arr; // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 连续pop 3次
arr; // []
arr.pop(); // 空数组继续pop不会报错，而是返回undefined
arr; // []
//6--------------
unshift和shift unshift()方法向Array的头部添加若干元素，shift()方法则把Array的第一个元素删掉
注意：unshift()方法返回数组新的长度，而shift()方法则返回删除的元素
var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的长度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 连续shift 3次
arr; // []
arr.shift(); // 空数组继续shift不会报错，而是返回undefined
arr; // []
//7--------------
sort sort()使数组中的元素按照一定的顺序排列，它会直接修改当前Array的元素位置，直接调用时，按照默认顺序排序
var arr = ['B', 'C', 'A'];
arr.sort();
arr; // ['A', 'B', 'C']
数字排序（数字和升序）：
var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});
fruits输出结果：
1,5,10,25,40,100
数字排序（数字和降序）：
var points = [40,100,1,5,25,10];
points.sort(function(a,b){return b-a});
fruits输出结果：
100,40,25,10,5,1
//8.````````````````---------------
reverse reverse()用于颠倒数组中元素的顺序 arrayObject.reverse() 该方法会改变原来的数组，而不会创建新的数组。
var arr = ['one', 'two', 'three'];
arr.reverse();
arr; // ['three', 'two', 'one']
9.//----------------------
splice splice()方法是修改Array的“万能方法”，
它可以从指定的索引开始删除若干元素，然后再从该位置添加若干元素
注意，该方法返回的是删除的元素，若没有删除则返回空数组 []
var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 从索引2开始删除3个元素,然后再添加两个元素:
arr.splice(2, 3, 'Google', 'Facebook'); // 返回删除的元素 ['Yahoo', 'AOL', 'Excite']
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
10.//------------------
concat concat() 方法用于连接两个或多个数组。此方法返回一个新数组，不改变原来的数组。
var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']
实际上，concat()方法可以接收任意个元素和Array，并且自动把Array拆开，然后全部添加到新的Array里
var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]
11.//--------
join join()方法是一个非常实用的方法，arrayObject.join(分隔符)
用于把数组中的所有元素放入一个字符串，并通过指定的分隔符进行分隔，即可把数组转化为字符串
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'
如果Array的元素不是字符串，将自动转换为字符串后再连接
2 - 简单数据类型和复杂数据类型
2.1 简单数据类型
简单类型（基本数据类型、值类型）：在存储时变量中存储的是值本身，包括string ，number，boolean，undefined，null
2.2 复杂数据类型
复杂数据类型（引用类型）：在存储时变量中存储的仅仅是地址（引用），通过 new 关键字创建的对象（系统对象、自定义对象），如 Object、Array、Date等；
2.3 堆栈
- 堆栈空间分配区别：
1、栈（操作系统）：由操作系统自动分配释放存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈；
简单数据类型存放到栈里面。
2、堆（操作系统）：存储复杂类型(对象)，一般由程序员分配释放，若程序员不释放，由垃圾回收机制回收。
复杂数据类型存放到堆里面。
-
简单数据类型的存储方式
值类型变量的数据直接存放在变量（栈空间）中
-
复杂数据类型的存储方式
引用类型变量（栈空间）里存放的是地址，真正的对象实例存放在堆空间中
2.4 简单类型传参
函数的形参也可以看做是一个变量，当我们把一个值类型变量作为参数传给函数的形参时，其实是把变量在栈空间里的值复制了一份给形参，那么在方法内部对形参做任何修改，都不会影响到的外部变量。
function fn(a) {
a++;
console.log(a);
}
var x = 10;
fn(x);
console.log(x)；
运行结果如下：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JQJMzU4o-1618625627500)(images\图片14.png)]](https://i-blog.csdnimg.cn/blog_migrate/1b29366053b864ddd5370884cab706f6.png)
2.5 复杂数据类型传参
函数的形参也可以看做是一个变量，当我们把引用类型变量传给形参时，其实是把变量在栈空间里保存的堆地址复制给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象。
function Person(name) {
this.name = name;
}
function f1(x) { // x = p
console.log(x.name); // 2. 这个输出什么 ?
x.name = "zxy";
console.log(x.name); // 3. 这个输出什么 ?
}
var p = new Person("ldl");
console.log(p.name); // 1. 这个输出什么 ?
f1(p);
console.log(p.name); // 4. 这个输出什么 ?
运行结果如下：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5QzMiV7B-1618625627501)(images\图片15.png)]](https://i-blog.csdnimg.cn/blog_migrate/5fe153d361118fd24a553ca5c4071704.png)
扫一扫
263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
