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 命名建议使用驼峰命名或者帕斯卡命名

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

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

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

我们上课一般使用驼峰

变量的细节语法

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

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

变量可以重新赋值

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

报错:

数据类型

数字类型

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

以及在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]);
 }
// 最终就把每一个属性的值输出了

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

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

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

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

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

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

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

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

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

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

javaScript基础-LMLPHP

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
07-21 12:45