JavaScript的作用

html： 解决页面的结构

css：样式

JS：交互，让页面可以具有动作。后期的js可以实现动态页面的效果

JavaScript是什么

语言：用于交流的-所有的语言都有固定的语法和单词，固定语法是一定要遵守的

脚本：戏剧剧本，只要按照流程一步一步走，就可以把所有的事情做完，脚本语言有一个特性：如果执行到某一行出错了，就会终止执行，不再继续

客户端：是区别于服务端的，目前我们所说的客户端，就是浏览器

JavaScript是：一门运行在浏览器上面的脚本语言

JavaScript的组成

• ECMAScript - 是一个语法的标准 ，这个东西简称：ES

• dom

• BOM

JavaScript初体验

js代码写在哪里？

1. 页面的script标签里面 - 内嵌式

2. 写在js文件里面，使用script标签进行引入 - 外联式

<script src="js文件的路径"></script>

注意点：外联式引入的js代码的script标签里面，写代码是无效的

注释语法

1. 单行注释

// 这就是js的注释的语法

1. 多行注释

/*
    在这一对符号的中间的内容，都是注释
    
*/

其他输入输出的方法

alert() 弹出一个提示框，提示框里面有我们的提示信息

prompt() 弹出一个输入框，输入框可以提供用户的输入

console.log() 在控制台输出，控制台就是开发者工具里面的一个功能，在elements的旁边

document.write() 在body里面输出，如果输出的格式是标签格式，会翻译成标签

变量

什么是变量：变量是js中用于存储数据的容器，通常就是一个单词，使用一个单词，代替一个数据，在程序里面，一个数据是可能不断变化的，不管它怎么变，只要使用变量存储起来，我想要的时候，直接通过变量获取即可

所以变量的作用是： 存储数据

变量如何使用：

// 变量的语法，是一定要学会记住的
var 变量名 = 数据;

补充变量的其他知识点

变量的命名规范

变量的命名是有规则的：

1 字符的有效范围： 字母、数字、下划线、$

2 不能以数字开头

3 不能以关键字或者保留字命名

关键字 - js语法中已经使用的单词，这些单词都是有特殊的语法功能的 (var if else while )

保留字 - js语法中，还不是关键字的单词 - js的功能会在以后的日子里面，不断的强大，此时可能需要新的单词作为关键字，所以，保留了一些单词，不让我们使用，这些称为保留字： 比如： class

4 区分大小写

5 建议命名有意义

6 命名建议使用驼峰命名或者帕斯卡命名

驼峰 第一个单词首字母小写，其他都大写

帕斯卡 所有的单词的首字母都是大写的

具体用哪个： 跟你所在的公司有关系，公司规定用哪个，就用哪个

我们上课一般使用驼峰

变量的细节语法

可以一次性声明多个变量，但是多个变量之间需要使用逗号隔开

也可以一次性声明多个并同时赋值

变量可以重新赋值

在使用变量的时候，不要在变量的两边加上引号

报错：

SyntaxError - 语法错误 - 你的语法已经写错了，肯定是行不通的

报错的右边，会告诉你在第几行出错

A is not defined A 这个变量没有定义

数据类型

数字类型

所有的数字都归数字类型管

以及在js里面有一个特殊的存在，NaN，也是归数字类型管(编程源于生活，但是高于生活)

比如： 整数，小数，负数，正数....

NaN

NaN 是三个单词的缩写： not a number - 不是一个数字，这个东西是专门用来表示某个结果不是数字

字符串类型

固定格式： 在js中所有的字符串都是一个引号包起来(引号包括单引号和双引号)

比如："abc",'abc'

布尔类型

只有两个值，一个是true，一个是false

这个类型，是在编程中专门为了得到判断是否成立的类型

true这个结果表示判断成立

false这个结果，表示判断不成立

undefined 和 null

undefined和null都是只有一个值，

undefined的值就是undefined

null的值也是null

undefined的作用是表示变量声明了没有赋值

null表示一个数据是空的，一般后期会把变量声明为null，和把变量复制null，优化程序的

typeof关键字

在js中，可以使用typeof这个关键字，获取某个数据的类型

用法：

typeof(数据)

得到的结果对应的理解：

string - 说明数据的类型是字符串

number - 说明得到的是数字

boolean - 说明的到的类型是布尔

undefined - 得到的结果是undefined

数据类型的转换

有时候需要把数据的类型进行转换

其他类型转换成数字

Number()

可以把所有的类型都转换成数字，但是只要字符串里面存在非数字字符，转换失败，得到NaN

parseInt()

可以把字符串转换为整数，从左到右，依次转换，直到遇上非数字字符

parseFloat()

可以把字符串转换为小数，从左到右，依次转换，直到遇上非数字字符

其他类型转换为字符串

String();

可以把所有的类型的数据都变成字符串

.toString()

undefined和null无法转换

其他类型变成布尔

Boolean()

可以把所有的数据都变成布尔类型

在js里面只有有限的几个可以变成false

0 '' undefined null NaN false

学习js中常用的运算符(操作符)

算术操作符

+  -  *  /  %

要点：

算术运算符，在进行计算的时候，是会进行隐式转换的

隐式转换的规则

1 字符串+其他类型，优先把前天转换为字符串再相加

2 如果-*/%这些，优先转换为数字再运算

3自增和自减

主要是理解前和后的区别

如果是++--在前面，需要先自增或者自减之后，再运算

如果是++--在后面，先把原来的值参与运算，再自增或者自减

比较操作符

> < >= <= 这些跟以前的数学中的作用是一样的，比较数字大小的
 
 == 判断两个值是否相等
 != 判断两个值是否不相等
 
 ===  判断两个数据是否相等，但是同时比较值和类型
 !==  判断两个数据是否不相等，但是同时比较值和类型

逻辑操作符

&& 把多个连接到一块之后，只有所有连接的判断结果都是true，最终才是true

|| 把多个连接到一块之后，只要有任意一个判断结果是true，最终就是true

用来连接多个条件的，最终的结果也是布尔类型！

用来把结果颠倒是非的

赋值操作符

=

作用： 就是把某个值，赋值给变量

var a = 10; // =号的作用，就是把10存储到a里面，存储的过程，称为赋值的过程

+= -= *= /= %=

以上这么多的运算符，其实就是一个简单的简写

a += 1 相当于  a = a + 1;
a -= 5 相当于  a = a - 5;

操作符的优先级

在数学里面，计算加减乘除，需要先乘除，后加减(优先级)

今天学习了这么多的运算符，也是有优先级

优先级从高到底

1. () . 优先级最高

   1. 一元运算符 ++ -- !

   2. 算数运算符 先* / % 后 + -

   3. 关系运算符 > >= < <=

   4. 相等运算符 == != === !==

   5. 逻辑运算符 先&& 后||

   6. 赋值运算符

简单记忆的口诀：

先算术，再比较，再逻辑，再赋值

表达式和语句

在编程中，有两个重要的组成，所有的编程的代码都是由表达式和语句构成的

表达式

在编程中，能得到一个结果的，就是表达式

比如： 4 > 5 , var a = 10 , 4 > 5 && 4 > 6

目前所看到的表达式，就是使用操作符连接起来，得到一个结果 - 都是表达式

语句

使用多个表达式组成一个语句，使用语句来完成功能

var jx = prompt();

var jb = 400;

var gz = jx + jb; // 两个表达式组成一个计算工资的语句

区分语句： 在js中，使用分号分割不同的语句，每次写完一个语句，尽量都使用分号分割

流程控制

控制代码的执行过程 - 流程控制

js中，代码分为三总：

顺序语句：之前学习的一行一行都执行的
分支语句：只执行一个分支，其他分支不执行
循环语句：不断的重复执行

分支语句

解决的问题：判断的问题

if-结构

语法：

解决单次判断的问题（一个分支）

if (条件表达式) {
	当条件表达式的结果为true的时候执行的代码
}

判断了条件成立和否则的问题(两个分支)

if(条件表达式) {
	条件表达式结果为true的时候执行的代码
}else {
	条件表达式结果为false的时候执行的代码
}

解决多次判断的问题（多个分支）

if(条件表达式1){
  条件表达式1的结果是true的时候执行的代码
}else if(条件表达式2){
  条件表达式2的结果是true的时候执行的代码
}else if(条件表达式3){
  条件表达式3的结果是true的时候执行的代码
}else {
  以上表达式的结果都是false的时候执行的代码
}

switch-case结构

switch(要比较的值){
  case 固定值1:
    当要比较的值 === 固定值1的时候执行的代码
    break;
  case 固定值2:
    当要比较的值 === 固定值2的时候执行的代码
    break;
    ....

    default :
    当要比较的值和所有的固定值都不相等的时候执行的代码
    break;
}

解决的问题：多个固定值判断的问题

注意点：

1. 这里面的判断，都是使用 === 判断的，意思是，必须是类型和值都相等的时候才行

2. 如果两个case之间，没有break，判断是不会停止的，会继续执行下一个case的代码，间接说明一个问题，break的作用，就是停止switch-case里面的判断的代码

三元表达式

解救的问题：可以把if-else的结构简化

语法：
	表达式1 ? 表达式2 : 表达式3；

执行过程：先执行表达式1，如果最终结果是true，继续执行表达式2，把表达式2的执行结果，作为整个三元表达式的结果，如果表达式1的结果发是false，则执行表达式3，并且把表达式3的执行结果作为整个三元表达式的执行结果

循环结构

while循环

语法

while (循环继续的条件表达式){
  表达式结果为true时要执行的代码(循环体)
}

执行过程

1. 判断条件表达式是否为true

2. 如果是true，就执行循环体

3. 再次判断表达式是否为true

4. 如果还是为true，还是会执行循环体

5. 重以上4个步骤，直到条件表达式的结果为false，停止循环

for循环

语法

for(初始化表达式 ; 条件表达式 ; 自增表达式){
  循环体
}

执行过程

1.先执行初始化表达式

2.执行条件表达式

3.如果条件表达式的结果是false，则直接结束

4.如果条件表达式的结果是true,则执行循环体

5，循环体执行结束，执行自增表达式

6.执行条件表达式，重复3-5这几个步骤

do-while循环

语法：

```javascript

do {

循环体

}while(条件)

    执行过程

1. 先执行一次循环体
2. 执行条件表达式，如果条件表达式为false，结束循环
3. 如果条件表达式是true,就继续执行循环体

     4.再执行条件表达式，重复2-3的步骤

### 总结

循环解决的问题是： 重复，只要是重复，就可以使用循环来解决
while  -  一般用来解决未知次数的循环 
do-while - 跟while是一样的，唯一的区别，执行的过程不一样
for   - 一般解决已知次数的循环

补充之前循环的两个关键字：break和continue

break

作用是：让整个循环终止执行,如果将来希望循环就此终止，不再执行，就使用break即可

for(var i = 1; i <= 6; i++){
  console.log("当前到了"+i+"楼");
  // 到3楼就可以了
  if(i === 3){
    // 告诉循环可以不继续执行了，可以使用break把循环终止
    break;
  }
}

continue

作用：终止循环中的某一次，让continue后面的代码不再执行，直接进入下一次的循环

for(var i = 1; i <= 6; i++){
   if(i === 4){
     // 此时4楼没有人下去，就不停，继续想5楼进发
     continue;// 告诉循环，当次循环就不继续向下执行，直接进入到下一个循环
   }
   console.log("当前到了"+i+"楼，电梯停了，请下去");
 }

数组

解决的问题： 大量数据的存储的问题

什么是数组：大量数据有顺序地堆叠到一起(数组就是一个有顺序，有长度的数据集合)

定义

常用的方式： 字面量

var 变量名 = [];

不常用的方式：构造函数的方式

var 数组名 = new Array();

注意点：

如果使用构造函数的方式创建数组的时候，如果在括号里面写了单个数字，会被认为是要设置这个数组的长度。

存值

可以在定义数组的时候，就存值

var arr = [数据1,数据2，数据3，...];

多个数据之间使用逗号隔开

还可以使用索引的方式存值(索引说白了就是一个序号，从0开始的整数)

arr[0] = 数据; arr[1] = 数据;

取值

通过索引取值

arr[索引]，这个东西就是相当于是一个变量

遍历数组

把数组中的所有数据都访问一次，称为遍历数组，一般我们遍历数组就是使用for循环遍历

for (var i = 0; i < arr.length; i++) {
    console.log(arr[i]);
  }

函数和循环的区别

循环解决的问题： 代码的重复执行 - 指的是过程里面有重复的过程

函数解决的问题： 代码的重复使用 - 可以把这段代码，执行过一次之后，想要再次执行还是可以的

函数

什么是函数：函数是一段可以重复执行的代码段(多行代码)

函数的语法

函数的定义：

需要使用函数关键字定义一个函数

function 函数名(参数){
  函数体
}

函数定义好之后，默认里面的代码是不会执行的，在你需要执行的时候，调用这个函数，代码就会执行

一个不常用的定义函数的方式：函数表达式

var 函数名 = function(参数列表){
  函数体
}
例如：
var getSum = function(a,b){
  return a + b;
}

调用函数:

函数名(参数)

函数的执行过程：

1. 函数里面的代码，必须是调用函数的时候才会执行

2. 函数被调用完毕之后，会回到调用该函数的位置继续向下执行

函数里面是可以调用其他函数的

函数的参数

有时候，一个过程里面，会有小部分地方会发生变化，这个变化就可以使用一个参数代替

//求某个随机数，如果每个范围都写一个函数，是非常麻烦的
// 0-5之间，0-7之间，0-99之间 -- 有很多个函数
// 把变化的上限，使用一个变量(参数代替)

// 求0-n之间的随机数
function getRandom(n) {
  var r = Math.random();
  r = r * (n+1);
  r = Math.floor(r);
  console.log(r);
}

当你在实际调用的时候，就告诉这个函数，具体的值即可

函数的参数分两种

形参：形式参数 - 就是定义函数的时候，用来占位置的变量，指导我们在调用函数的时候如何传参
实参：实际参数 - 就是调用函数时，实际写在参数位置上的值

arguments

就是函数里面自带的一个功能，可以获取到函数在调用时的所有的实参

解决的就是那些比形参个数还要多的实参的获取，形参个数不一定的问题

函数的返回值

什么是函数的返回值：函数执行过后会有一个结果，这个结果称为函数的返回值

函数的返回值默认都是undefined，如果想要修改函数的返回值，可以使用return这个关键字实现

function getRandom(n) {
  var r = Math.random();
  r = r * (n+1);
  r = Math.floor(r);
  return r;
}

如上面的代码所示，我们在函数里面使用了return之后，就可以得到这个随机数，而不是只能输出了

写函数的步骤总结

1. 把过程写出来

2. 分析过程中哪些是可变的，哪些是不变的

3. 把可变的作为参数，把不变的作为函数体

4. 按照函数的语法格式写函数

5. 考虑是否需要修改返回值

补充一些需要了解的其他知识点

1.匿名函数

所谓的匿名函数就是一个没有名字的函数，但是js语法是不允许匿名函数单独存在，一般我们也不会直接写一个单独的匿名函数，我们现在用到匿名函数的地方：

函数表达式、后面再学习Webapi的时候用来注册事件也会用到，自调用函数也用到了...

function (参数列表){
  函数体
}

2.自调用函数

定义之后会自动调用的函授

(function(参数列表){
  函数体
})(实参);

一般在我们的技术能力达到一定的高度之后，对某个自己的功能实现封装的时候使用(js面向对象)

3.函数也是数据类型

function fn(){}
typeof fn === 'function'

函数这种数据类型是复杂类型

4.形参和实参的关系

如果在一个函数里面，形参的值发生了改变，是不会影响实参的值的(简单类型里面成立)

形参实参其实互不影响

作用域

在js里面作用域分为全局作用域和局部作用域

什么是作用域： 一个变量或者一个函数的有效范围

全局指的是在页面的任何地方都可以访问

局部指的是只能在函数内部使用

可以认为函数里面就是局部作用域，但是不能认为函数外面就是全局作用域

预解析

js代码在执行之前，会预先解析一次，解析的工作就是把变量和函数的声明提升到当前作用域的最顶端,变量的赋值和函数的调用仍然在原来的位置

比如：
var a = 10;
var b = 20;
预解析之后：
var a;
var b;
a = 10;
b = 20;

函数也是变量，所以可以作为函数的参数

我们发现只要是数据类型就可以作为参数，而函数也是一种数据类型，就把函数也作为参数，也是可以的，我们称作为参数的函数是回调函数

学习逻辑运算的时候，有一个短路运算的法则，没有讲解，今天来补充

其实在开发和学习的过程中，逻辑运算符，绝大部分情况就是使用在连接多个条件表达式的时候，但是也有小部分情况是不一样的

比如 逻辑或 就可以在函数里面设置某个参数的默认值，其原理是： 短路运算

短路运算的法则

1. 如果逻辑或的左边隐式转换为true，就会直接返回左边，否则返回右边

2. 如果逻辑与的左边隐式转换为true，会直接返回右边，否则返回左边

逻辑或的短路一般就是给函数设置一个默认值

逻辑与的短路一般就是在函数里面判断是否把回调函数传入了

素数(解决问题的方法-反证法)

反证法在数学里面是一种证明的思路，先假设某个结论是成立的，尝试找出一个反例(可以推翻之前假设的结论的例子)，只要找到了，就证明假设是不成立的，如果没找到，证明假设是成立的。

反证法解决的问题：但凡是遇上需要证明多个条件同时成立的时候，就使用反证法就行

对象

内置对象

我们以前学习的 new Date(), Math 这些都是js里面字带的对象，称为内置对象，内置对象提供了不少功能，但是迟早有一天，这些功能是不够用的，需要我们自己创建自己的对象，然后指挥这些对象去做事情

面向对象

把万事万物抽象成对象，将来只要想要让某个对象去做事情，就只需要找到对象，指挥对象做事情就行了

到底什么是对象

对象就是属性和方法的无序集合(无序键值对的集合)

创建对象的语法

使用 构造函数的方式创建对象

var 变量名 = new Object();// 此时就已经创建了一个对象

例如：
var lgd = new Object();

字面量的方式创建

var 变量名 = {};
var 变量名 = {
  属性名:属性值,
  方法名: function(){}
}
// 注意点： 多个键值对之间使用 逗号 隔开即可

给对象添加属性和添加方法

对象.属性名 = 属性值;
对象.方法名 = function(){}

例如：
lgd.name = '李狗蛋';
lgd.eat = function(){}

调用对象的属性和方法

lgd.name + '这个人今年' + lgd.age + '岁了';

lgd.eat();

工厂模式

之前所学习的这些语法，只能创建单个对象如果想要方便的创建多个同类型对象，就可以使用工厂模式

function createStudent(name,gender,age) {
  var student = new Object();
  student.name = name;
  student.gender = gender;
  student.age = age;
  student.readBook = function () {
    console.log('从前有座山....');
  }
  return student;
}

自定义构造函数

目前来说，自定义构造函数是我们在js里面最推荐的描述对象的方式

function Student(name,gender,age) {    
    this.name = name;
    this.gender = gender;
    this.age = age;
    this.readBook = function () {
      console.log('从前有座山....');
    }
  }

new 关键字

这是一个专门用户创建新对象的操作符 ，都会配合 构造函数进行使用

一般格式就是：

new 构造函数()

这个new关键字做了什么事情呢

1. 调用构造函数，并且在函数内部创建了一个对象，然把对象存进this这个东西里面

2. 调用构造函数里面的所有的代码，为this，添加属性和方法

3. 把对象返回，也就是把this返回

this关键字

在构造函数里面我们发现有一个新的关键字——this，this在js里面就是一个专门指向一个对象的类似一个变量的东西，可以这么理解，这个this就是一个变量，这个变量只会存储一个对象，这个对象是什么呢？

现在不用太关注，目前大家只要知道，构造函数里面的this，就是我们在new的时候创建的对象，就行

for-in遍历对象

有时候需要把对象里面的每个键值对全都访问一次，这种方式成为 - 遍历对象

有一个特殊的语法可以遍历对象

for (var 变量名 in 你要遍历的对象){
  	通过key得到每个键
  	通过 对象[key] 这个方式得到每个值
}
例如：
 var obj = {
   name :'二狗',
   age : 12,
   gender : '男',
   height: 188
 }
 for(var key in obj){
  console.log(obj[key]);
 }
// 最终就把每一个属性的值输出了

简单类型和复杂类型的本质区别

简单类型和复杂类型，在内存中的存储的方式是不一样的

在内存中，有两块区域，一个叫堆，一个叫栈

堆空间：这个空间里面的每一块的大小是不一样的，并且可以动态分配的，管理起来效率就没那么高

栈空间：这个空间里面的每一块大小是一样的，是不会动态分配的，管理起来效率比较高

简单类型(值类型)，会把他们对应的值，存储在栈空间里面

复杂类型，会把他们的内容存储在堆空间里面

简单类型在栈空间中存储的就是它的值，所以我们称这些简单类型，也是值类型

复杂类型存储在栈空间里面的是对象的内存地址，内存地址有一个别名：引用，所以我们也称复杂类型叫引用类型

通过代码和画图分析，发现，如果是值类型进行参数传递，形参的变化是不会影响实参的，但是如果是引用类型进行参数传递，形参改变了，会改变实参

目标

1. 掌握生成指定时间的方式至少一个

2. 能获取时间的总毫秒数的方式至少一个

3. 掌握Math.floor()/Math.round()/Math.ceil()的使用

4. 掌握Math.min()/Math.max()的使用

5. 掌握instanceof的使用

6. 掌握数组的push()、pop()的使用

7. 掌握数组的concat()、slice()、splice()的使用

8. 掌握数组的foreach()、some()、filter()的使用

9. 掌握数组的indexOf()、join()、reverse()的使用

10. 掌握字符串的concat()、substring()的使用

11. 掌握字符串的index()的使用

12. 掌握字符串的replace()、split()的使用

Math内置对象的一些方法

Math.random()

这个方法可以提供一个随机数，这个随机数产生的区间是从0到1之间的，但是可以获取到0，获取不到1的

Math.floor()

向下取整

Math.ceil()

这个方法是用来对某个数字，进行向上取整，找到一个比这个数字大于或者等于的一个整数

语法

Math.ceil(要取整的数字)

返回值就是取整后的数字

Math.max()

这个方法的作用，就是用来求一堆数字中谁更大

语法：

Math.max(所有想要比较的数字，一个一个的传递)

Date对象的一些补充

想要生成一个指定日期的时间对象

方法1：

new Date(时间格式的字符串)

var date = new Date('2019-04-01');

方法2：

new Date(年,月,日,时,分,秒)

var date = new Date(2019,3,1)

注意点：月份是从0开始的

获取毫秒

毫秒是一种时间单位，换算： 1秒 = 1000毫秒

getMilliseconds()

这个方法就可以获取到当前日期的毫秒

获取总毫秒

有时候需要比较两个日期的大小

比较日期的大小如果直接比较两个字符串，是不规范的，需要比较它们的总毫秒数

获取日期的总毫秒数

1 Date.now()

获取的是从1970年到现在为止，总共经历的所有的毫秒数

2 new Date().getTime()

获取的是从1970年到现在为止，总共经历的所有的毫秒数

3 new Date().valueOf()

补充return关键字的作用

1 可以修改函数的返回值

2 return可以阻止函数继续向下执行(终止函数的执行的)

如果return后面没有跟着东西，函数的返回值被修改了吗？没有，还是undefined

instanceof关键字

在js里面有一个关键字用来判断某个实例对象，是否由这个构造函数所创建

var date = new Date();
date instaceof Date() // true ,如果是true，证明对象确实是由后面的构造函数所创建

数组对象的方法

数组.join()

这个方法可以将数组中的所有元素使用指定的分隔符分隔，返回一个字符串

var arr = ['刘备','关羽','张飞'];
var str = arr.join('&');
  console.log(str); // 刘备&关羽&张飞

用法：

数组.join(分隔符)

返回值：字符串

数组.reverse();

用于将一个数组翻转过来

var arr = [1,2,3,4,5];
arr.reverse();
console.log(arr); // [5, 4, 3, 2, 1]

数组.filter()

这个方法是用于筛选出数组中满足条件的元素，并组成一个新的数组返回的

var array =  [1500,1200,2000,2100,1800];
var arr = array.filter(function(item){
  return item < 2000;// 这个代码的意思，就是筛选出array数组里面满足 < 2000 的元素，并返回
});
console.log(arr);// [1500, 1200, 1800]

数组.forEach()

这个方法专门用于遍历数组

用法：

数组.forEach(function(item,index){
  item 就是数组里面的每个元素
  index 就是每个索引
});

但凡是能够使用for循环遍历数组的时候，都可以使用forEach来代替

数组.push()/数组.pop()

数组.push()用于将一个或者多个元素，从数组的末尾添加进入数组

var arr = [];
arr.push(10,20,30);  // 数组就变成了 [10.20,30]

数组.pop()用于将数组的最后一个元素删除

var arr = [1,2,3];
arr.pop();// 数组里面就只剩下 两个  [1,2]

有两个非常类似： 数组.unshift() 和 数组.shift() - 自己查文档看看

数组.splice(从哪里修改，总共修改多少个,用哪些元素来修改)

可以从数组的指定位置开始，修改数组里面的元素

// 删除中间的元素
  // 数组.splice(从哪里开始删除,总共删除多少个);
  var arr = ['a','b','c','d','e','f'];
  // 把c和d删掉
  arr.splice(2,2);
  console.log(arr);

  // 插入元素
  /// 数组.splice(插入到哪里,0,新元素123456);
  // 在c的后面插入   7  8  9 
  var arr = ['a','b','c','d','e','f'];
  // 从c的后面插入 c 后面的索引就是 3
  arr.splice(3,0,7,8,9);
  console.log(arr);

  // 替换元素
  var arr = ['a','b','c','d','e','f'];
  // 把 c 和 d 替换成 7 8 9 
  // 数组.splice(从哪里开始替换,总共替换几个,替换的元素是哪些);
  arr.splice(2,2,7,8,9)
  console.log(arr);

String对象的方法

字符串其实就是多个字符串联起来，也是有索引有长度的

得到字符串的长度 ： 字符串.length

根据索引得到字符： 字符串[索引] 字符串.charAt(数字)

字符串.indexOf()

这个方法是根据某个字符，查找这个字符在字符串里面的索引，如果存在，返回索引，如果不存在，返回-1

var str = "abc";
console.log(str.indexOf('c')); // 2
console.log(str.indexOf('z')); // -1

字符串.replace()

这个方法是用于将字符串中的某些字符替换成新的字符

// 字符串.replace(旧的字符,新的字符)
var str = 'abc';
// 把c替换成9
var s1 = str.replace('c','9'); // 但是字符串操作是不会修改原来的字符串
console.log(s1); // ab9
console.log(str); // abc

字符串.substring()

用来截取字符串里面的某一部分字符

// 字符串.substring(从哪里开始截取,到哪里结束)
// 注意点，得到的结果，是不包含结束索引的
var str = 'abcdef';
// 截取de
console.log(str.substring(3,5)); // de

链接: https://fly63.com/article/detial/4276