JavaScript基础
Posted HUMILITY
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaScript基础相关的知识，希望对你有一定的参考价值。
什么是javascript
JavaScript是一种运行于JavaScript解释器/引擎中的解释型脚本语言
运行环境：
1.独立安装的JS解释器（NodeJs）
2.嵌入在 浏览器 内核中JS解释器
解释型：
运行之前是不需要编译的，运行之前不会检查错误，知道碰到错误为止
编译型：
对源码进行编译，还能检查语法错误（C/C++）
JS组成
1.核心（ECMAScript）
2.文档对象模型（DOM，Document Object Model）让JS有能力与网页进行对话
3.浏览器对象模型（BOM，Browser Object Model）让JS有能力与浏览器进行对话
将JS脚本嵌入在html页面中指行的步骤
1.将JS代码嵌入在元素“事件”中
onclick：当单击元素时所做的操作
<div id=""onclick="JS代码">xxx</div>
<html>
<body>
<button onclick="console.log(\'Hello World\');">
打印消息
</button>
</body>
</html>2.将JS代码嵌入在 <script>标记中
<script></script>
允许出现网页的任意位置处
<html>
<body>
页头
<hr/>
<script>
document.write(\'<b>欢迎</b>\');
console.log(\'脚本指行结束了。。。\');
</script>
<hr/>
页尾
<body>
</html>3写在外部脚本文件中（**.js）
·创建js文件编写代码*.js
·在页面中引入js文件<script src="js文件路径"></script>
<html>
<head>
<script src="myscript.js"></script>
</head>
<body>
</body>
</html>注意
已经引入外部文件，在此文件不得出现js代码
语法规范
1.语句
允许被JS引擎所解释的代码使用分号来表示结束
console.log();
document.write();
大小写敏感
console.log();正确
Console.log();错误
英文标点符号
console.log("");正确
console.log（""）;错误
由表达式、关键词、运算符组成
2.注释
单行注释：//
多行注释：/**/
变量
就是内存中的一段存储空间
名：内存空间的别名，可以自定义
值：保存在内存空间中的数据
内存：
8bit（比特是表示信息的最小单位）=1byte
1024byte=1kb
1024kb=1mb
1024mb=1gb
1024gb=1tb
变量的声明
声明
var变量名；var userName
赋值 ；var bookPrice=25.5；
变量名=值
声明过程中，尽量不要省略var关键字，否则声明的是“全局变量”
例子：
声明一个变量
保存学员的年龄，值为25
语法
var age；
age=25；
或声明直接赋值
var变量名=值；
ex：var age=25
在console.log()或document.write()使用变量名 取代""打印 变量 stuName的值到控制台上
var stuName="pp.xz"
console.log(stuName);--pp.xz
console.log("stuName");--stuName 加了双引号则输出stuName
一次性声明多个变量赋值
语法
var变量名1，var变量名2，...var变量名n
var stuName="pp.xz",stuAge=25,stuHeight;
等同于
var stuName="pp.xz";
var stuAge=25;
var stuHeight;
变量名 声明规范
1.不允许使用JS的关键字和保留关键字
break case catch continue default delete do else false finally for function if in ......
2.由字母、数字、下划线以及$组成
var stuName
var stuName1
var stu_Name
var stu$Name
3.不能以数字开头
var stuName1
var 1stuName错误
var $stuName正确
4.尽量见名知意
var a,b,c,d,ad,ac;
var stuName,stuAge;更推荐
5.可以采用"驼峰命名法"
变量名为合成词时，第一个单词全小写，从第二个单词开始，每个单词首字符大写 var stuName 如果只有一个单词全小写var name
变量的使用
var stuName="小猪佩奇";
console.log(stuName);
var stuAge;
console.log(stuAge);
变量声明后，从未赋值，称之为未经初始化变量。
变量如果未被定义过，直接打印或使用
console.log(stuHeight);
结果为错误。
对变量的存取操作
1、获取变量的值-GET操作
var usePwd=\'123456\';
console.log(usePwd);
document.write(usePwd);
var newPwd=usePwd;(创建新变量，赋值为已有变量的值）2、保存（设置）变量的值-SET操作
var oldPwd=\'123\'
oldPwd=\'456\';
oldPwd=newPwd;（此语句对于变量newPwd是GET操作；对于变量oldPwd是SET操作）
变量的使用
=出现的话，永远都是将=右边的东西保存在=左边的变量=左边必须是变量
var stuAge=30；//将30保存在stuAge中
35=30;// 将30保存在35中，错误！！！
数据类型
原本类型（基础类型）
1.数字类型
number类型
可以表示32位的整数以及64位的浮点数
整数：32位即4字节
浮点数：即小数，64位，8字节
整数：
十进制：生活中常用数字
八进制：逢八进一
var n1=0123
十六进制：逢十六进一
0-9 A-F组成
var n2=0x123
小数：
var n1=34.56
var n2=4.5e10
2.字符串类型
表示一系列的文本字符数据由Unicode字符，数字，标点组成Unicode下所有的的字符，数字，标点在内存中都占2字节
"张".charCodeAt().toString(16)
查看字符"张"的十六进制表现方式
结果为：5f20
\\u4e00：汉字的起始字符
\\u9fa5：汉字的结束字符
转义字符
1.\\n 换行
2.\\r 回车
3.\\t 一个制表符
3.布尔类型
boolean类型
作用：用于表示 条件的结果
取值：
true：真，肯定的结果
false：假，否定的结果
ex：
var r1=true；
var r2=false；
除条件判断外，做运算时，true当做1运算，false当做0运算
4.空
null 声明对象未赋值
5.未定义
undefined
1.声明变量未赋值
2.访问对象不存在属性
数据类型转换
js是弱类型语言
由数据来决定变量的数据类型是什么
var stu;//undefined
var 20;//number
var "25"//string
不同类型数据在运算过程中如何处理？
var num1=15;//number
var num2=13;//number
var result=num1+num2;//28->number
var str1="15";//string
var result1=num1+str1
隐式转换
自动转换，由JS在运算过程中，自己转换的操作，不需要人为参与
1.函数
typeof()或typeof
ex：
var num1=；
var s=typeof(num1);:获取num1的数据类型
var s1=typeof num1;:获取num1的数据类型
2.NaN
Not A Number不是一个数字
is NaN（数据）：判断 数据是否为 非数字
是不是一个数字
结果为boolean
结果为true：不是一个数字
结果为false：是一个数字
注：所有的数据类型与string做+运算时，最后的结果都为string
显示转换（强制转换）
toString()
将任意类型的数据转换为string类型
变量.toString（）；
会得到一个全新的结果，类型为string
var num=15;
var str=num+"";
parseInt()
整型：Integer
作用：获取指定数据的整数部分
语法：
var result=parseInt（数据）
注意：
parseInt，从左往右依次转换，碰到第一个非整数字符，则停止转换。如果第一个字符就是非整数字符的话，结果为NaN.
parseFloat()
Float:浮点类型->小数
作用：将指定数据转换成小数
语法；var result=parseFloat(数据)
ex：
var result=parseFloat("35.25");//35.25
var result=parseFloat("35.2你好");//35.2
var result=parseFloat("你好35.2");//NaN
Number()
作用：将一个字符串解析为number
语法：var result=Number(数据)
注意：如果包含非法字符，则返回NaN
运算符&表达式
运算符：能够完成数据计算的一组符合，比如：+-*/
表达式：由运算符和操作数所组成的式子叫做表达式，每个表达式都有自己的值。
运算符
算术运算符：加（+）减（-）乘（*）除（/）求余（%）
-：可以表示减号，也可以表示负号，如：x=-y
+：可以表示加法，也可以表示字符串的连接
ex：
var num1=15；
var num2=18；
var num3="15"
console.log(num1+num2);//33
console.log(num1+num3);//1515 （拼接） ✖：15*2=30
/：15/2=7.5
%：
取余操作，俗称 模
作用：取两个数字的余数
ex：
var i=10%3 //i值为1使用场合：
1.判断数字的奇偶性
2.获取数字的最后几位
++：自增，在数值基础上，进行+1操作
--：自减，在数值基础上，进行-1操作
i++； //相当于i=i+1；
i--； //相当于i=i-1；
i=1；
j=i++； //i结果为2，j结果为1（先操作再加）
i=1；
j=++i； //i结果为2，j结果为2（先加再操作）
关系运算符
作用：判断数据之间的大小关系
运算符：
＞：大于
＜：小于
＞=:大于等于
＜=:小于等于
==:判断等于 （不比较类型，只比较数值）
！==：不等于
===：全等 （除数值外，连同类型也一起比较）
！==：不全等
关系表达式的运算结果为boolean类型（true或者false）
逻辑运算符
1作用：关联条件
ex：
判断考试分数是否在60-80之间
var score=52；
条件1：score>=60
条件2：score<=80
2.逻辑运算符
逻辑与：&&
逻辑或：||
逻辑非：！
例子：
逻辑与
关联两个条件，两个条件都为真的时候，整个表达式结果才为真
语法：
条件一&&条件二
问题：判断考试分数是否在60~80之间
var score=52;
条件1：score>=60
条件2：score<=80
var result=score>=60&&score<=80;
逻辑或
关联两个条件，两个条件中，只要有一个为真，那么整个表达式的结果就为真
语法：
条件一||条件二
问题：笔试题和面试题，笔试题或面试题的分数，有一个超过60就认为合格
var bishi=52；
var mianshi=82；
条件一：bishi>=60
条件二：mianshi>=60
var result=bishi>=60||mianshi>=60;
逻辑非
对条件取反
注意：逻辑非，只有一个操作数
语法：！条件
非真既假
非假即真
短路逻辑
短路&&
如果第一个条件已经是false的话，那么就不会再判断第二个条件，那么整个表达式的值，就是false
如果第一个条件是ture的话，则继续判断第二个条件，并且以第二个表达式的值，作为整个表达式的值
短路||
如果第一个条件已经是true的话，那么就不会再判断第二个条件，那么整个表达式的值，就是true
如果第一个条件是false的话，则继续判断第二个条件，并且以第二个表达式的值，作为整个表达式的值
条件运算符
三目运算符：运算符需要三个操作
语法：
表达式1？表达式2：表达式3；
表达式1是一个条件，值为boolean类型
若表达式1的值为true，则指行表达式2的操作，并且以表达式2的结果作为整个表达式的结果
若表达式1的值为false，则指行表达式3的操作，并且以表达式2的结果作为整个表达式的结果
var age=20；
var msg=age>18?"成年人":"未成年人"；
条件运算符的嵌套
输入一个成绩，判断
如果成绩在80以上，则输出优秀
如果成绩在60以上，则输出合格
否则：不合格
var score=85；
var result=score>=80?"优秀"（
score>=60?"合格"："不合格"）；
函数
函数（function），也可被称为方法（method），或者过程（procedure）
是一段预定义好，并且可以被反复使用的代码块。其中可以包含多条可指行语句。
预定义好：事先声明好，但不被指行
反复使用：允许被多个地方（元素，函数中）所应用
代码块：允许包含多条可执行的代码
函数本质上是功能完整的对象
语法：
function函数名(){ 可执行语句 }
ex：创建一个函数 名称为：sayHello,主体功能为，向控制台上输出一句Hello World
function printHello(){
console.log("hello");
console.log("world");
}函数的调用
指行函数中的内容
任何JS的合法位置处， 都允许调用函数
语法：函数名称（）
function sayHello(){
console.log("hello");
console.log("world");
}
sayHello();
定义函数的参数和返回值
转换参数
parseInt（数据）；//将指定数据转换为整数
parseFloat（数据）；//将指定数据转换为小数
console.log（"要打印的话"）；
定义带参数函数
function函数名(参数列表声明){
代码块(函数体，功能体，方法体）}
参数列表：由一个或多个 变量名称来组成声明函数时定义的参数，可以称之叫作"形参"（形式参数）
ex：
function printInfo(userName,ueserPwd){
console.log(\'用户名\'+userName+\'密码:\'+userPwd);
}
printInfo(\'Tom\',\'123\');
在调用函数时所传递的参数值，被称之为"实参"（实际参数）
带返回值的函数
声明：
function 函数名(0或多个参数){
//代码值
return值；
}调用：
var 变量=函数名（参数）；
function add(num1，num2){
return num1+num2;
}
var result=add（10，20）
console.log(result); 输出三十
变量的作用域
什么是作用域
作用域就是变量或函数的可访问范围。它控制着变量或函数的可见性和生命周期
在JS中，变量或函数的作用域可分为：
1.函数作用域，只在当前函数内访问
2.全局作用域，一经定义，代码的任何位置都可以访问
函数作用域中的变量
局部变量
函数作用域中的变量（局部变量）只在当前函数内可访问到，离开此范围就无法访问了。
function add(){
var sum=1+2; //局部
console.log(sum); //正确
}
console.log(sum); //脚本错误
全局变量
全局作用域中的变量，称之为"全局变量"，在代码的任何位置处都能访问
var sum=0; //全局变量
function add(){
sum=1+2;
console.log(sum); //正确
}
console.log(sum); //正确
不推荐使用如下：
function add(){
sum=1+2; //全局变量
}
add() //必须调用一次
console.log(sum); //正确
声明提前
JS在正式执行之前，会将所有的var声明的变量和function声明的函数，预读到所在作用域的顶部。但是，对变量的赋值，还保留在原来的位置处
console.log(a);//不会出错，输出undefined
var a=100；
console.log(a);//100;
var a; //仅声明提前
console.log(a);//undefined
a=100;//赋值仍保留在原位置
console.log(a);//100
按值传递
传参时，实际上是将实参复制了一份副本传给了参数。在函数体内对变量进行修改，实际上是不会影响到外部的实参变量的
var n=100; //全局变量
function fun(n){ //参数变量也是局部变量
n-=3 //修改的局部变量n
console.log(n); //输出的局部变量n
}
fun(n); //按值传递，方法内输出97；
console.log(n); //输出全局变量的值：100
分支结构
分支结构是指程序在运行过程中，根据不同条件，选择执行某些语句
if结构：
当条件满足时，运行某些语句。
当条件不满足时，则不运行这些语句。
语法：
if(条件表达式){
}
流程：
1.判断条件表达式的结果。
2.如果结果为true，则执行语句块内容。
3.如果结果为false，则不执行语句块的内容。
注意：
1.if语句，条件位置处，必须为boolean的值/表达式/变量，如果条件不是Boolean类型的话，JS会自动进行转换，以下情况，if都会认为时false
if(0/0.0/"“/null/undefined/NaN){
}
除以上情况，一律为真
if(1){
console.log("真")；
}
if("我帅吗"){
console.log("真")；
}
2.if语句块{}，可以被省略，如果省略{}，那么if只控制它下面的第一条语句。
if-else：
当条件满足时，运行某些语句。
当条件不满足时 ，运行另外一些语句。
语法：
if(条件){
语块1
}
else{
语块2
}
else if：
复杂if结构或多重if结构
如：
分数判断：
如果成绩大于90，则输出A
如果成绩大于80，则输出B
如果成绩大于60，则输出C
否则输出D
语法：
if(条件1){
语块1；
}
else if(条件2){
语块2；
}
else if(条件3){
语块3；
}...else{
语块n；
}
注意：最后的else模块，可以选择性添加。
switch-case：
switch case语句是一种特殊的分支结构，可以根据一个表达式的不同取值，从不同程序入口开始执行。
流程：
1.计算变量或表达式的值
2.将计算出的值与case后的数值做等值判断，如果判断相等的话，则执行对应的case后的执行语句。
3.如果碰到break，则结束执行，否则，继续向下执行。（联合使用）
使用场合：优先用于等值判断的条件中
语法：
switch(表达式){
case值1:
语句1；
语句2；
break； //break语句作用在于跳出switch结构
case值2:
语句3；
break；
......
default:
语句n；
}switch-case结束机制：
1.碰到break结束。
2.整个结构都执行完毕
两个case或多个case之间没有任何可执行代码，那么就以最后一块的case为主。
switch-case优势：
switch-case常常和break语句结合使用实现分支的功能。
switch-case在实现分支功能时和if-else主要区别在于
1.if...else..可以判定相等或不等的情形适用性更广；
2.switch...case...结构更清晰，效率更高
但一般只用于指定变量相等于某个范围的某个特定的值时我们才去使用。
循环结构
反复一遍又一遍做着相同（相似）的事情
循环两大要素
1.循环条件：
什么时候开始，什么时候结束
2.循环操作：
循环体，循环过程干了什么
循环结构-while循环
语法：
while（boolean表达式）{
循环体语句；
}
流程：
1.判断条件
2.如果条件为真，则执行循环操作
3.在判断条件，如果为真，继续执行循环操作
...
4.判断循环条件，通过条件为假，则退出循环结构
注意：如果循环条件一直为真的话，那么循环就是死循环，尽量避免死循环的产生，要记得更新循环变量（条件）
while语句用于处理循环逻辑
var i=0；
while（i<10）{
console.log(\'你好世界\')；
i++； //循环条件每执行一次就改变一次，使循环结束成为一种可能
}
循环的流程控制：
continue关键字：
作用：用在循环中，用于终止本次循环，继续执行下次循环
break关键字：
作用：用在循环中的话，终止整个循环结构
如：
var i =0;
while(i<100){
console.log(i);
if(i==5){
break;
}
i++;
}输出结果是：0，1，2，3，4，5。当i=5时，退出循环。
do while循环
语法：
do{
可执行语句；
}while(boolean表达式)
流程：
1.先执行循环操作
2.再判断循环条件
如果条件为真，则继续执行循环操作
如果条件为假，则终止循环即退出循环
特点：无论条件满足于否，至少执行一次。
while和do while 区别
1.while
先判断，后执行
最少一次循环都不执行（第一次条件就不满足）
2.do while
先判断，后执行
最少要执行一次循环操作（第一次条件就不满足）
for循环
语法：
for(表达式1;表达式2;表达式3){
循环体语句;}
for循环执行过程：
1.计算表达式1的值；
2.计算表达式2(boolean)的值，如果为true则执行循环体，否则退出循环；
3.执行循环体；
4.执行表达式3；
5.计算表达式2，如果为true则执行循环体，否则退出循环体
6.如此循环往复，直到表达式2的值为false
for循环用于实现固定次数的循环
累加
求1+2+3+4...+100=？
var sum=0;
for(var i=1;i<=100;i++){
sum+=i;
}
console.log("1到100的和为："+sum)；
阶乘
1237.。。10
for，while，do while之间的区别
1.for while
最少执行0次
while：多数用于不确定循环次数时使用
for：多数用于确定循环次数时使用
2.do while
最少执行1次
适合用于不确定循环次数时使用
循环的嵌套
在一个循环体内再出现一个循环
for/while/do while/三种循环在很多情况下是可以互换的；一般情况下，for循环使用最多
数组
什么是数组：内存中连续存储多个数据的数据结构，再起一个统一的名字。
为什么用数组：普通的变量只能存储一个数据程序=数据结构+算法
算法：解决问题的步骤
数据结构：数据在内存中的存储结构，好的数据结构可以极大提高程序的执行效率
什么时候用：只要存储多个连续的数据
索引数组
下标为数字的数组
创建：（两种）
1.数组直接量：var arr=[] ;
2.用new：var arr=new Array();
例子：
var arr1=[];
定义一个不包含元素的数组
var arr=[97,85,79];
定义一个包含三个元素的数组
var arr3=new Array();
定义一个不包含元素的数组
var arr4==new Array("Tom","Mary","John");
定义一个三个字符串元素的数组
创建数组时初始化：
1.数组直接量：var arr={元素1，元素2...};
2.用new：var arr=new Array(元素1，元素2...);
何时：在创建数组时，已经知道数组的元素内容
如：
var array=[4500,5500,5000];
var array=new Array(\'市场部\',\'研发部\',\'运营部\')
创建，先声明空数组，再添加元素
var empArray=[];
empArray[]=\'Scott\';
empArray[1]=\'Smith\';
var mArray=new Array();
mArray[0]=\'三国志\';
mArray[2]=195;
mArray[5]=true;
混合元素类型数组
访问数组中的元素：
元素：数组中每个数据都是一个元素
如何访问：下标：数组中唯一标识每个元素存储位置的序号
特点：从0开始，连续不重复
何时：只要访问数组元素，只能用下标
如何：数组名[i] 用法和单个变量完全一样
数组GET操作与SET操作
设置数组元素的值 SET
var scores=[95.88,100];
scores[2]=98; //将值为100的元素重新赋值为98
scores[3]=75; //在数组尾部添加一个新的元素
下标从0开始，最大到lenth-1
获得数组元素的值 GET
var cities=new Array(\'南京‘,\'杭州\',\'青岛\')；
console.log(cities[1]); //杭州
console.log(cities[3]); //undefined
不会抛出数组下标越界异常
访问数组中的元素：
数组的lenth属性：
记录了数组中理论上的元素个数
lenth属性的值永远是最大下标+1
var arr4=new Array(10);
console.log(arr4.lenth); //长度为10
var arr5=[]; //长度为0
arr5[0]=87; //长度变为1
arr5[3]=98; //长度变为4
数组的遍历：
遍历数组元素，通常选择for循环语句，元素的下标作循环变量
var nums=[50,90,20,10];
for(var i=0;i<nums.lenth;i++){
nums[i]+=10;
}
元素下标从0开始，到lenth-1结束
固定套路:
1.获取数组最后一个元素：arr[arr.lenth-1]
2.获得倒数第n个元素的位置：arr[arr.lenth-n]
3.数组缩容：减小arr.lenth的数值，会删除结尾的多余元素
4.遍历数组：依次访问数组中每个元素，对每个元素执行相同的操作
特殊：三个不限制：
1.不限制数组的元素个数：长度可变
- 不限制下标越界：
获取元素值：不报错！返回undefined
修改元素值：不报错！自动在指定位置创建新元素，并且自动修改lenth属性为最大下标+1
如果下标不连续的数组----稀疏数组
3.不限制元素的数据类型
关联数组：
什么是：可自定义下标名称的数组
为什么：索引数组中的数字下标没有明确的意义
何时：只要希望每个元素都有专门的名称时
如何：
1.创建空数组
2.向空数组中添加新元素，并自定义下标名称
关联数组的创建方式：
var bookInfo=[];
bookInfo[\'bookName\']=\'西游记\';
bookInfo[\'price\']=35.5;
由于关联数组的lenth属性值无法获取其中元素的数量，所以遍历关联数组只能使用for..in循环
遍历关联数组；for in 循环
for(var key in hash){
key //只是元素的下标名
hash[key] //当前元素值
}
索引数组与关联数组的对比
| 索引数组 | vs | 关联数组 |
|---|---|---|
| 以字符串输出 | 不能用字符穿输出 | |
| 下标是数字 | 下表是自定义的字符串 | |
| lenth属性有效 | lenth属性失效（=0） | |
| 访问元素，都用数组名["下标"] | ||
| 可用for循环遍历 | 不能用for循环遍历———for in |
查找：
| 查找： | 索引数组 | hash数组 |
|---|---|---|
| 遍历 | 不用遍历 | |
| 受存储位置影响 | 和存储位置无关 | |
| 受数组元素个数影响 | 和数组中元素个数无关 |
总结：只要希望快速查找元素时，就用hash数组
数组API函数
数组转字符串：
String(arr):将arr中每个元素转为字符串，用逗号分隔
固定套路：对数组拍照，用于鉴别是否数组被修改过
arr.join("连接符"):将arr中每个元素转为字符串，用自定义的连接符分割
//将字符拼接为单词
var chars=["H","e","l","l","o"];
console.log(chars.join("")); //输出hello
固定套路：
1.将字符组成单词：
chars.join(""),无缝拼接
扩展：判断数组是空数组：arr.join("")==""
2.将单词组成句子：
words.join("")
3.将数组转化为页面元素的内容：
"<开始标签>"+arr.join("</结束标签><开始标签>")+"</结束标签>"
拼接和选取
不直接修改原数组，而返回新数组
拼接：
concat()拼接两个或更多的数组，并返回结果
var newArr=arr1.concat(值1,值2,arr2,值3,...)
将值1，值2和arr2中每个元素，以及值3都拼接到arr1的元素之后，返回新数组
其中：arr2的元素会被先打散，再拼接。（因为arr是数组）
var arr1 = [90, 91, 92];
var arr2 = [80, 81];
var arr3 = [70, 71, 72, 73];
var arr4 = arr1.concat(50, 60, arr2, arr3);
console.log(arr1); //现有数组值不变
console.log(arr4); //输出90,91,92,50,60,80,81,70,71,72,73
选取：
slice()返回现有数组的一个子数组
var subArr=arr.slice(starti,endi+1)
选取arr中starti位置开始，到endi结束的所有元素组成新数组返回————原数组保持不变
强调：凡是两个参数都是下标的函数，都有一个特性：含头不含尾
var arr1=[10,20,30,40,50];
var arr2=arr1.slice(1,4); //20,30,40 (含头不含尾）
var arr3=arr1.slice(2); //30,40,50（下标为2到最后）
var arr4=arr1.slice(-4,-2); //20,30（反向选取含头不含尾）
console.loga(rr1); //现有数组元素不变选取简写：
1.如果选取到结尾：可省略第二个参数
2.如果选取的元素离结尾近：可用倒数下标：
arr.slice(length-n,arr.length-m+1)
可简写为：arr.slice(-n,-m+1);
3.复制数组：
arr.slice(0,arr.length);
可简写为：arr.slice();
删除：
splice直接修改原数组
arr.splice(starti,n);
删除arr中starti位置开始的n个元素不考虑含头不含尾
其实：var deletes=arr.splice(starti,n)；
返回值deletes保存了被删除的元素组成的临时数组
var arr1=[10,20,30,40,50];
var arr2=arr1.splice(2,1); //下标为2删除1个（30）
//var arr2=arr1.splice(2,2,21,22,23); //下标为2删除2个并放21，22，23于被删的位置上
//var arr2=arr1.splice(2,2,[91,92,93]);
console.log(arr1);
console.log(arr2);
插入：
arr.splice(starti,0,值1,值2,...)
在arr中starti位置，插入新值1，值2，...原starti位置的值及其之后的值被向后瞬移。
替换：
删除旧的插入新的
arr.splice(starti,n,值1,值2,...)
先删除arr中starti位置的n个值，再在starti位置插入新值
强调：删除的元素个数和插入的新元素个数不必一致。
颠倒：
强调：仅负责原样颠倒数组，不负责排序
reverse()颠倒数组中元素的顺序
arr.reverse();
var arr1=[10,20,30,40,50];
arr1.reverse();
console.log(arr1); //50，40，30，20，10
排序：
将元素按从小到大的顺序重新排列
排序API:
arr.sort():默认将所有元素转为字符串再排列
问题：只能排列字符串类型的元素
解决：使用自定义比较器函数
排序算法：
（手写）冒泡 快速 插入排序
以上是关于JavaScript基础的主要内容，如果未能解决你的问题，请参考以下文章