js基础

js基础第一天

1、js的作用

1、远古时期：表单校验
2、现代无所不能:前端、后端node.js、交互ajax、命令行工具开发(node.js)、桌面程序、app开发、游戏开发、物联网

2、js概念和组成

2.1、js概念

1、js是一种运行在浏览器端的脚本语言，现在也能运行在服务端
2、javascript=ECMAScript+（DOM+BOM=WebAPI）

2.2、js组成

1、ECMAScript:一套标准，规定了js的基本语法(js基础)
2、DOM：文档对象模型[document(指当前的页面) object model]：一套操作网页中元素的方法（WebAPI）
3、BOM:浏览器对象模型：一套操作浏览器的方法(WebAPI)

3、js注意点

1、script能写在页面的任意位置，但是一般写在body标签的最后
2、在js中写文本，需要用‘’包来，注意带有src属性的script标签内部的js代码，浏览器直接过滤
3、多行注释：alt+shift+a

4、js中的5中输出语句(前期写js代码，每一句写完加；)

1、alert()：弹框
2、confirm():确认框(确认框+取消)—》返回值是布尔类型
3、prompt();输入框(输入框+确认框+取消)—》返回值是string类型
4、document.write();在当前网页中写内容
注意点：通过document.write写标签，浏览器会解析标签document.write(“我是一个行内标签”);
5、console.log(); 在控制台输出(打印)信息
console:控制台
log:日志、信息

5、js中的变量

1、变量：可以变化的量(相当于一个储存数据的容器 但是变量中同时只能存储一个数据)
2、作用：储存数据
3、规范：在使用变量之前先声明变量(var)

5.4.1、变量使用的几种形式,先声明 再使用

    1、先声明 后赋值(变量只需要声明一次，如果声明了多次，第二个声明相当于没写，但是赋值有效)
    2、同时声明和赋值
    3、同时声明多个变量且赋值：var age1 = 18, age2 = 19;

    不规范的写法：
    1、不声明 直接赋值
    2、只声明 不赋值 undefined
    3、不声明 不赋值  浏览器报错，报错之后的代码浏览器就不执行了                                                                                                                                                                                                                                                                                                              

5.4.2、变量的命名的规则和规范：

1、变量命名的规则(相当于法律》必须遵守)：
  1、由数字 、字母 、_ 、$、组成，不能以数字开头
  2、变量名区分大小写
  3、变量名不能是关键字和保留字
2、变量命名的规范(相当于道德规范》建议遵守):
  1、变量名要有意义
   2、驼峰命名法：从第二个单词开始 首字母大写

5.4.2、交换变量的值：倒可乐（var temp = a; a=b; b=temp;）

6、js中的数据类型

1、简单数据类型(基本数据类型)：
    1、数字类型：number--》所有的数字
    2、字符串类型：string--》只要用‘’或“”包裹起来的字符都是字符串类型
    3、布尔类型：boolean --》true false
    4、undefined--》一个变量只声明未赋值，变量中默认undefined
    5、null --》空类型(再web api 中才会遇到)
2、复杂数据类型：
    1、数组：Array
    2、函数：function
    3、对象：object

6.1、js中的数据类型数字类型基本介绍：(控制台蓝色)

    1、所有的数字都是数字类型
    2、以0开头的数字表示8进制(以console.log打印出来的都是10进制)
    以0x开头的数字表示16进制(和颜色表示不一样)
    3、小数(浮点数)
    4、科学计数法：e表示10的几次方 5e4 = 5*10^4(看几个0)
    5、浮点数的精度丢失问题：一般进行计算的时候，会避免使用浮点数进行运算--》
    一般直接转换为整数来算(浮点数*10)

6.2、字符串类型：(控制台的颜色是黑色)

1、字符串类型的数据是通过length属性来获取字符串的长度(获取字符串中字符的个数) str.length
2、字符串中的转义字符
1、单引号不能直接包裹单引号
2、双引号不能直接包裹双引号
3、单双引号互相嵌套
4、" --> " ’ --> ’ \n --> 换行 类似转义字符
3、字符串的拼接(拼串)
1、规则：+的功能：
2、字符串的拼接：如果其中有一个是字符串类型，此时就是拼接
3、加法运算：如果都是数字类型，才是加法运算
注意：如果一个字符没有用引号包起来，表示变量

6.3、boolean类型(深蓝)：true/false

6.4、(非正常值) undefined(灰色)(变量声明未赋值变量默认undefined)和null(在web api阶段，如果需要通过js获取页面中的元素，没有获取到，此时就是null(灰色)(空)) null是object类型(特殊情况)

6、字面量赋值与变量赋值：

1、字面量(直接量)：值固定不变，浏览器可以直接识别的量(如果可以一眼看出来是什么类型的数据，就是一个字面量)
字面量赋值：var num = 123;
变量赋值 : var age = num;

7、运算符：

1、算数运算符的介绍：+ - * / %
除了+以外的其他运算符，只有运算的功能(不看类型)
2、赋值运算符：= += -= *= /=
3、一元运算符 (只需要一个操作数/变量的运算符)：++ – ！
二元运算符(需要2个操作的运算符)
1、自增运算符： 相同点(代码执行完最后都是让自身加1)
不同点：代码执行的时候中途拿过去赋值或者运算(++num ++在前，表示先加1 再返回 值)(num++ 表示先返回 值，再加1)
4、逻辑运算符(一般逻辑运算符之后的结果为布尔类型)：与&& 或|| 非 ！，！!！–得正

js基础第二天

1、display:有transition属性，但是没有transition效果
2、比较运算符(关系运算符)：== 只看内容，不看类型；=== 内容类型都看
<、 <= 、> 、>=、==、!= 只看内容，不看类型
3、运算符的优先级：()最高，&&,||优先级最低，一元也高，中间是算数和比较，先算出来再比较
1、()优先级最高
2、一元运算符：++ – ! 前提++在前
3、算数运算符：先 / % 再 + -
4、比较运算符：先> >= < <= 后 == != === !=
5、逻辑运算符：先&& 后 ||*
4、表达式的基本介绍：表达式的特点：表达式是有结果的,只要有结果的就是表达式
5、数据类型的转换：
1、转换成数字类型：number
1、Number(值)
2、parseInt(值)：转换为整数 --》取整(从前往后检测到第一个不是数字的截止。看到第一个点就停止)
3、parseFloat(值)：转换成浮点数/小数(从前往后检测到第一个不是数字的截止。看到第一个点会忽略掉)、

2、转换成字符串类型：string
1、String(值)
2、值.tostring();
3、拼接一个空串： 值 + “”(空串)
4、进行不会改变值的计算：- * / %
5、正号：+ 正号写前面，用的最多 -号：会改变数据本身
3、转换成布尔类型：boolean（所有的数据都能转换为boolean类型）记住6个转换为false的："" 0 undefined null false(每种简单的数据类型中有一个) NaN
1、Bollean(值);
2、!!：非非 和! 非
4、NaN:表示这不是一个可以用数字表示的数据，本质还是一个数据类型：在js中，如果把无法用数字表示的值转换为数字类型，此时浏览器比较宽容，也会帮你转换成功，不过提示NaN
注意点：1、NaN就是一个数据类型的
2、NaN不等于(相等全等都不行)任何值，包括它自己比较极端(六亲不认)

6、流程控制语句
1、顺序结构：浏览器默认从上往下一行一行顺序执行
2、分支结构(选择结构)：根据不同的情况，执行对应的代码(比如一个二叉路口 或者路过一家烤鸭店)
1、if语句：当有多个条件式时候，需要用&&或||表示，不能 10<age<29;
条件1不满足才会看条件2
2、三元运算符：处理简单的判断：一般用于简单的判断,除此之外，使用if较多
var result = 判断条件 ？ 表达式1 ：表达式2； 先判断条件是否成立，成立–》结果就是表达式1的结果 不成立–》结果就是表达式2的结果==== if(){}else{}
3、switch(表达式):一般用于具体值的判断：default(默认)。判断表达式和case是否相同
先计算表达式的结果
注意点：1、switch语句进行全等比较！！！！switch语句只会比较一次
2、注意：每一个case结束的时候最好需要写一个break;
switch(表达式的结果) {
case 值:
代码
break;
default:
代码
}
4、分支结构的使用场景：if范围性的判断，，switch语句：具体值的判断。。三元。。改写简单的if语句
3、循环结构：重复做的一件事情判断一下条件
1、while循环：在循环体中需要能改变判断条件中的变量，如果不能改变判断条件中的变量，就是死循环
2、for循环：先执行初始化语句，判断条件是否成立，执行循环体，再自增或自减

7、console.log里面可以打印多个，用逗号隔开

js基础第三天

1、一行的个数等于i的最大值
2、输出完成一行需要换行
3、直角三角形：一行的个数等于当前的行数（i +""+ j +"=" + ij）
4、字符串和变量之间用字符串的拼接
5、break;结束整个循环
continue:结束本次循环，直接到自增和自减了
6、for循环：明确循环次数
while循环：次数不明确
do…while循环：适用于不管条件是否成立，都要执行一遍循环体
7、数组（Array）：存储大量的数据
1、概念：一组有序值的集合
2、创建数组的方式：
1、字面量(浏览器直接识别的量)[ ]例子：123 “abc”
2、构造函数：Array() 需要配合new来创建一个新的数组： var arr = new Array();表示用构造函数创建出一个新数组
3、注意：在数组中可以存任意类型的数据，但是一般数组中所储存的数据一般一样
4、数组下标取值范围：[0,arr.length-1]
1、如果下标存在，此时会返回这个数据
2、如果下标是不存在的，此时会一个undedined与变量不同
6、数组的存值
1、数组名[下标] = 值；
2、如果下标是存在的，那会覆盖
3、如果下标不存在，会创建这个数组项，类似火车，中间是空的
4、一般如果需要往数组中添加新数据–》一般会把数据添加到最后一项：arr[arr.length] = “值”；
5、往数组的最后添加数据的方法：arr.push(值)
7、数组的遍历：把数组中每一项数据拿到
1、从前往后遍历:只需要通过循环得到所有的下标—》确定下标的范围
2、arr.join("|");
8、冒泡排序：
1、两两比较，大的数往后沉，一趟一个最大值两趟2个最大值
2、中极版：每趟少比较j次
3、假设成立法：每一趟开始前先假设想法是对的，找打脸的情况
8、函数的基本知识：特点（一次声明，多次使用）
1、函数的声明：function 函数名() {函数体也就是重复的需求代码} 函数名一般是动词+名词的形式
加粗样式 2、函数的调用：函数名()

js基础第四天

函数基础：
1、函数的参数：
函数声明的小括号里面叫形参，默认没有具体的值或者类型，作用：占位置
调用小括号里面的叫实际参数：默认有具体的值和类型。作用：给形参传值
注意点：正常情况下，形参个数和实参保持一致
函数体里面的变量需要存到形参里面
如果函数实参(参数)传少了，前几个会一一对应，没有接收到的形参，默认是undefined(就是变量未赋值)
如果函数实参(参数)传多了，前几个会一一对应，多出来的实参虽然已经传进去了，但是必须通过arguments才能拿到
2、函数的返回值
1、在函数内部声明的变量，在函数外拿不到，所以需要哇哈哈，需要返回出来给我喝：return：哇哈哈；返回出来后，如果函数调用之后就是一个值
2、如果函数中没有设置返回值，此时得到的返回值默认是：undefined;
3、在函数return之后的代码，浏览器不执行
4、函数返回，返回的值是传到调用它的地方
3、函数的参数：函数名，函数的参数(可以没有)，函数的返回值(可以没有)

函数高级：
1、函数内部可以调用函数
2、针对于函数的断点调试：
1、第一个按钮(f8)让代码瞬间执行到下一个断点处，如果没有下一个断点，此时会直接执行到最后
2、第二个按钮(f10)：让代码往下执行一步，但是如果遇到的是函数的调用，此时会直接把函数的调用结束完
3、第三个按钮(f11)：让代码往下执行一步，但是如果遇到的是函数的调用，此时会进入函数的调用一步一步执行
4、第四个按钮(shift+f11)：瞬间执行完当前函数的代码，出函数的调用
3、函数作用域：
1、在函数内部声明的变量，在函数外是拿不到的
2、局部作用域：函数的内部是局部作用域
局部变量：在函数内部声明的变量就是局部变量
特点：只能在当前函数内部使用
3、全局作用域：在script标签内以及函数外就是全局作用域
全局变量：在script标签内，函数外声明的变量就是全局变量
特点：全局变量在任意位置都可以使用
4、如果自己作用域中有声明这个变量，就用自己的
如果自己作用域中没有声明这个变量，就用全局的
4、隐式全局变量：不声明，直接赋值的变量就是隐式全局变量，浏览器会默认把该变量提升成隐式全局变量
如果浏览器发现一个变量从头到尾都没有声明，直接赋值，浏览器默认在全局生成一个隐式全局变量
5、预解析的介绍(预先解析代码)：浏览器执行js代码的步骤，先会把所有的声明，提升到代码的最前面！！！(在当前作用域代码的最前面)，然后再一行一行的执行代码
浏览器执行js代码的步骤：
1、预解析：
1、会把所有变量的声明，提升到代码的最前面，但是赋值不会提升
2、会把所有的函数声明，提升到代码的最前面 ，但是调用不会提升
3、如果同时声明了多个同名的变量，此时之后提升第一个声明，后面的声明会忽略
4、如果同时声明了多个同名的函数，此时后面的会覆盖前面的
5、如果同时声明了多个同名的变量和函数，此时会以函数优先
6、打印函数名出来就是函数本身，也可以给函数赋值数字而覆盖掉函数
7、注意：代码规范：函数一般先声明后使用，不要让函数名和变量名同名
8、其实每一个作用域中都有预解析的过程
2、再去一行一行执行js代码
6、定义函数的两种方式
1、函数声明式：
function fn() {} 调用：fn() 等于（function fn() {}）（）
2、函数表达式：函数属于数据类型，可以看成一种数据,赋值给变量
var fn = function fn() {} 调用：fn()
3、两种定义函数方式的区别：
1、函数声明：此时可以先调用后声明。原因：js存在预解析，会把所有函数的声明提升到最前面
2、函数表达式：只能先声明赋值，再调用。原因：js存在预解析，但是只能提升变量的声明，不会提升变量的赋值，没有必要写名字，写起来用不上
7、匿名函数：
1、函数表达式：没有必要写名字，写起来用不上
2、匿名函数自调用：
自调用：普通的函数都可以自调用（function fn(){函数体}）()
如果需要函数声明之后立马调用一次，此时可以直接在函数声明后() -->需要用()把函数声明包裹起来，此时函数名fn没有用了，可以删掉
8、匿名函数自调用的应用：沙箱模式(隔离起来的模型)—>解决全局变量污染的问题
在实际开发时，所有开发者用的都是全局变量，如果变量名相同，会出现互相覆盖的问题
如果需要解决以上问题：可以将每一个人的代码中的变量变为局部变量即可(用函数包裹起来)
(function(){//写小戴的代码})();
数组：一组有序值得集合，用来存储大量数据
函数：解决重复代码—>函数一次声明，多次调用

对象：在js中存现实生活中的对象----------->现实中可以描述出来的事物，都是对象
对象：一组无序的键值对的集合(键值对：属性名：属性值；)
如果用之前的简单数据类型一个一个的储存变量和函数——》但是此时会用到很多的变量——》真正一般会使用js中的对象储存
1、创建对象的两种方法
1、字面量(使用较多)：123、“str”、，[] 以后遇到{}，它就是对象的字面量，注意：每一项通过逗号隔开
var obj = { 特征(属性) name:‘小王’，height：160，行为/函数(方法) eat：function（）{} };
20
2、浏览器自定义的：var obj = new Object({ 特征(属性) name:‘小王’，height：160，行为(方法) eat：function（）{} }); 创建出一个空对象

js基础第五天

对象：(一组无序的键值对的集合)
1、对象的取值与赋值的语法：
点语法(点后面只能写属性名，不能写变量)：对象名.属性名
1、对象的取值：
1、如果属性名存在，此时返回属性值
2、如果属性名不存在，返回undefined
3、针对于对象中的方法：一般不会直接打印函数，需要调用函数
2、对象的赋值：对象名.属性名 = 新值
1、如果属性名存在，此时会覆盖
2、如果属性名不存在，浏览器会默认添加
中括号语法()：后面写的是一个字符串或者是变量（对象名[‘属性名’]）
(关联数组语法：把对象类似的当做是一个数组来进行取值和赋值）
1、取值语法：对象名[‘属性名’]
1、如果属性名存在，此时返回属性值
2、如果属性名不存在，返回undefined
2、赋值语法：
1、如果属性名存在，此时会覆盖
2、如果属性名不存在，浏览器会默认添加
如果是中括号语法，可以动态的改变对象数据
如果在开发中发现属性名就是一个变量，就用中括号语法
2、遍历对象：把对象中的每一个属性值都拿出来
for…in语句
for （var key in obj）{代码块}
key表示键—》指属性名
obj表示遍历的是哪个对象
注意:for…in语句中的代码------》会执行对象键值对的个数次
需要打印属性名：直接在代码块里面执行
console.log(key);
需要打印属性值：console.log(fm[key]);因为key是一个变量，所以必须是用[]语法
3、批量创建对象
1、使用工厂函数批量创建对象
2、重复的需求：函数；重复相同的代码：循环
4、构造函数的介绍：通过工厂函数创建出来的对象，默认是没有具体的类型—》只会显示object,但是用构造函数创建出来的对象，这个对象就是构造函数类型的
1、构造函数的特点：
1、本质就是函数
2、一般会把构造函数函数名首字母大写
3、在js中已经右写好的构造函数：Array() Object()
4、可以自己定义构造函数
2、使用构造函数步骤：
1、先声明：函数名首字母大写
2、再调用：使用构造函数创建对象和之前使用Object构造函数一样需要配合new来创建对象
var stu = new Student(); var obj = new Object();
3、new所做的四件事情：
1、浏览器执行到这一步，通过new先创建出一个空对象-----》此时空对象已经是有具体的类型
2、把构造函数中的this指向了(当前对象)当前创建的空对象
3、把构造函数中的代码执行一遍-----》给空对象添加属性或者方法
4、把创建出来的对象返回出去
4、new的作用：
1、通过new来创建出对象
5、构造函数的作用：添加属性或者方法------》实例化对象，
6、用都是一样用，就是创建不一样
7、使用构造函数创建出来的对象是有具体的类型的
5、值类型和引用类型：
基本数据类型(值类型)：number、string、boolean、undefined、null
复杂数据类型(引用类型)：array、function、object
值类型：在变量中储存的是值本身，赋值也是复制值
引用类型：在变量中储存的是内存地址，赋值也是复制内存地址
6、值类型和引用类型的参数传递
1、值类型----》变量中储存的是值本身-----》赋值的是值本身------》传参传的也是值本身
注意：形参相当于局部变量
将实参赋值给形参，相当于在函数里var 形参 = 实参
7、内置对象：js中自带的对象，供开发者使用，这些对象提供了一些常用的功能
1、Math对象：js已经生成好的对象，直接用即可，有很多数学相关的属性方法
1、圆周率：Math.PI
2、求最大值：Math.max()
3、求最小值：Math.min()
4、向上取整：Math.ceil()
5、向下取整：Math.floor()
6、四舍五入：Math.round()
7、随机数 ：Math.random() 取值[0，1)
8、求绝对值：Math.abs()
9、次幂/次方: Math.pow(num1,num2) num1的num2次方
10、开方 ：Math.sqrt(num) //num的开方 100的开方是10
2、Date对象：js提供了一个Date构造函数，不是一个写好的对象，通过Date构造函数可以创建不同的日期对象
var now = new Date();//不传参，默认是一个当前时间的对象
1、获取年：
var year = now.getFullYear();
2、获取月：0~11,需要获得正确的月份，直接加1
var month = now.getMonth() + 1;
3、获取日：
var day = now.getDate();
4、获取时
var hour = now.getHours();
5、获取分
var minutes = now.getMinutes();
6、获取秒：
var seconds = now.getSeconds()

js基础第六天

Date对象
1、时间戳：日期的数字格式
1、含义：从1970年1月1日00：00：00到现在所过去的毫秒数
2、应用：计算时间差
3、使用场景：
1、计算代码执行的时间：代码的执行的时间 = 代码结束的时间 - 代码的开始时间
2、倒计时：见案例

Array对象：
1、把数组中的每一项拼接成字符串，默认以逗号隔开：arr.join()；
如果需要以其他的分隔符隔开，此时就直接往()传对应的字符串即可
应用：如果需要字符串中没有分隔符—》往括号里传空串
2、数组的增删操作：(会改变原数组)
1、push:在数组的最后面添加数据并且可以添加一项或者多项,并且返回新数组的长度
2、pop:在数组的最后删除一项，返回被删除的这一项
3、unshift:在数组的最前面添加数据并且可以添加一项或者多项,并且返回新数组的长度
4、shift：在数组的最前面删除一项，返回被删除 的这一项
5、记忆技巧：看键盘上的键：右边是后面，长的增加，短的删除
3、数组的反转与排序：
1、arr.reverse()数组的反转-----》会改变原数组
2、arr.sort()数组的排序(冒泡排序法)----》会改变原数组
注意：sort默认会按把数组中每一项当作字符串来排
如果需要设置排序的规则，需要传参：arr.sort(function(a,b) {})
a表示前一项，b表示后一项，如果当前函数的返回值大于0，此时会交换位置
如果需要从小到大排序：return:a-b;
如果需要从大到小排序：return:b-a
记忆方法：比身高
4、数组的合并和截取：
1、数组的合并：arr.concat(arr1,arr2,arr3…);------->返回合并好的新数组
2、数组的截取：arr.slice()----->会返回截取后的新数组
1、直接写arr.slice()，表示从数组的第1项直接截取到最后一项，等于复制了新数组
2、arr.slice(begin);begin表示开始的下标，从开始一直截取到最后
3、arr.slice(begin,end)从begin开始截取到end，不包括end（begin和end表示下标）和随机数一样（有始无终）
5、在数组任意位置的删除、添加、(删除和添加一起用就是)替换（会改变原来的数组）splice（slice加p）
1、arr.splice(从哪里开始删除，删除几个，添加项1，添加项2…)哪里表示下标
从哪里开始增加，从哪里开始添加，写0默认从第一项删除到最后一项
6、查找数组中元素的位置：
1、indexOf():表示查找元素在数组中第一次出现的下标
1、如果查找的数据在数组中是存在的，此时会返回对应的下标
2、如果查找的数据在数组中是不存在的，此时会返回-1
可以通过判断indexOf的结果是否为-1,来判断数据在数组中是否存在
2、lastIndexOf()：表示查找元素在数组中最后一次出现的下标
1、如果查找的数据在数组中是存在的，此时会返回对应的下标
2、如果查找的数据在数组中是不存在的，此时会返回-1
7、清空数组：
1、arr = [];
2、arr.length = 0;
3、arr.splice(0,arr.length)从下标为0位置开始删除arr.length个

基本包装类型：
1、简单数据类型是没有任何属性和方法的
2、如果浏览器发现使用到简单数据类型的属性或者方法-----》此时会在底层把简单数据类型包装成复杂数据类型
Number()
String()
Boolean()
1、如果浏览器发现使用到简单数据类型的属性或者方法-----》此时会在底层把简单数据类型包装成复杂数据类型
2、可以通过复杂数据类型获取想要的属性和方法
3、会把复杂数据类型恢复成简单数据类型
3、Number对象：
1、num.toString()：把数字转换成字符串
2、num.toFixed(保留几位小数)：帮助我们保留几位小数，拿到的结果是字符串类型
4、Boolean对象：
1、flag.toString():布尔类型的数据转换成字符串类型
5、String对象：(字符串类似数组，但不是真数组)
1、字符串可以进行遍历—》字符串啊可以类似地当作是数组来进行取值，但是本身不是数组，没有数组的方法，
2、查找指定字符地下标
1、indexOf()表示查找元素在字符串中第一次出现的下标
1、如果查找的字符在字符串中是存在的，此时会返回对应的下标
2、如果查找的字符在字符串中是不存在的，此时会返回-1
2、lastIndexOf()表示查找元素在字符串中最后一次出现的下标
1、如果查找的字符在字符窜中是存在的，此时会返回对应的下标
2、如果查找的字符在字符串中是不存在的，此时会返回-1
3、去除字符串首尾的空格：str.trim()
4、字母的大小写转换：str.toUpperCase()转大写、str.toLowerCase()转小写
5、字符串地拼接和截取：用法和数组一样
1、字符串的拼接：concat()或者 +
2、字符串的截取：str.slice(begin,end)从begin开始截取到end，不包括end（begin和end表示下标）和随机数一样（有始无终）
3、字符串的截取：str.substring(begin,end)从begin开始截取到end，不包括end（begin和end表示下标）和随机数一样（有始无终）
4、字符串的截取：str.substr(begin,length)从begin开始截取length个
6、split("|")|为落刀处 把字符串分割成数组：和arr.join()正好相反
7、字符串的替换：
str.replace(‘a’,‘bb’):把字符串中第一个a替换成bb,会返回替换之后的字符串
正则替换：str.replace(/垃圾/g,"**")