一、JS简介
（1）JS能够改变HTML的内容
（2）JS能够改变HTML的属性
（3）JS能够改变HTMl的样式（也就是CSS）
二、JS的使用
JS可以放到<body>标签或者<head>标签中或者同时放置到<body>和<head>标签中。
注：把JS代码放到<body>底部可以提升显示速度
或者直接在HTML标签里内嵌JS
JS还可以写到一个单独的JS文件中外链进来
外链JS文件的优势：（1）分离了HTML和JS代码
（2）使HTML和JS更易于维护
（3）已缓存的JS文件可以提升加载速度
三、JS输出
（1）window.alert()
（2）document.write()：用于测试
注：在HTML文件完全加载后使用将删除所有已有的HTMl
（3）innerHTML：通常用来修改HTML的内容
e.g：
document.getElementById("demo").innerHTML=要修改的内容;（4）console.log()：通常用来调试
四、JS语法
JS中的值分为字面量（混合值）和变量（变量值）
JS中的标识符对大小写敏感，必须以字母为开头，尽量不以$和_开头，变量命名一般用小驼峰式写法（Camel标记法），JS使用Unicode字符集
五、Let
全局作用域、函数作用域
全局变量有全局作用域；局部变量（在函数内部姓名的变量）拥有函数作用域
ES6之前没有块作用域
用let声明有块作用域的变量，在{}外无法访问{}内声明的变量
用var重新声明会把变量作用域重新变成全局；而用let在块中重新声明变量不会重新声明块外的变量
在块外声明时，var和let声明的变量都拥有全局作用域
var定义的变量属于window对象，可以使用window.变量名；而let定义的变量不属于window对象，不可以使用window.变量名
在同一个块作用域中，不能通过let重新声明一个已经用var/let声明的变量；在同一个块作用域中，不能通过var重新声明一个已经用let声明的变量。
在不同的作用域/块中，通过let重新声明变量是允许的。
var有变量提升，let没有变量提升。就是说用var定义的变量可以先用后定义，但是这个变量提升只是提升了定义这个变量，而并没有给它赋值。
e.g：
{
console.log(a); // 这时候控制台输出undefined
console.log(b); // 这时候控制台会报错
var a = 1;
let b = 3;
}当console.log(b)的时候会报错：
六、Const
const和let类似，但不能重新赋值
const也有块作用域
const在声明变量的时候必须赋值，const在声明一个原始值的时候就不能更改了
若const定义了一个常量对象，可以更改或增加对象属性，但无法重新为常量对象赋值；若const定义了一个常量数组，可以更改或增加数组元素，但无法重新为常量数组赋值。
在同一作用域中，不能将已有的用var/const定义的变量重新声明或赋值给const
在同一个作用域或块中，不能为已有的const变量重新声明或赋值，在另外的作用域中重新声明const是允许的。
七、JS运算符
（1）+、-、*、/、%、++、--
（2）=、+=、-=、*=、/=、%=
（3）== 、===、!=、!==、>、<、>=、<=、?
（4）&&、||、!
（5）typeof、instanceof
（6）&、|、~、^、<<、>>、>>>
八、JS算数
+、-、*、/、%、++、--、**（次幂）：相当于Math.pow(x,y) e.g：5**2=25 <==> Math.pow(5,2)
九、JS数据类型
数值、字符串、数组、对象
typeof运算符：用来确定JS变量的类型。
typeof运算符可以返回以下原始数据类型之一：string、number、Boolean、undefined。
typeof运算符还可以返回以下两种类型之一：function、object。typeof运算符把对象、数组或null返回object。typeof把数组返回为“object”，因为在JS中数组即对象。typeof不会把函数返回object，typeof把函数返回为function。
Undefined：没有值的变量和typeof都是undefined
空值：e.g：var car = " "; car的值是“ ”，类型是string
null："nothing" 注：可以通过设置对象的值为null来清空对象
注：undefined与null的值相等，但数据类型不一样（undefied的数据类型是undefined，null的数据类型是object）。
十、JS函数
JS函数通过function关键字进行定义，其后是函数名和括号()。
函数名可包含字母、数字、下划线和美元符号（规则与变量名相同）。
圆括号可包括有逗号分隔的参数，由函数执行的代码被放置在花括号中：{}
e.g:
function name(参数1,参数2,参数3,......){
// 这里放要执行的代码
}当js到达return语句，函数将立即停止。可以通过() 运算符来调用函数。
可以把函数当作变量值直接使用。
在函数中参数是局部变量，在JS函数中声明的变量，会成为函数的局部变量。局部变量只能在函数内访问。由于局部变量只能被其函数识别，因此可以在不同函数中使用相同名称的变量。
局部变量在函数开始时被创建，在函数完成时被拆除。
附：
（1）arguments对象
在函数代码中，使用特殊对象arguments,开发者无需指明参数名，就能访问它们。
e.g:
{
function A(){
console.log(arguments.length);
console.log(arguments[0]);
}
A("string",10); // 这时候第一行执行结果就是2，第二行执行结果就是string。arguments能获取到这个函数中的参数个数和参数值
}因此，无需明确命名参数，就可以重写函数。函数重写是指在派生类（子类）中重新定义基类（父类）中已有的同名函数的操作。JavaScript允许我们通过重写来为已存在的函数提供修改或者扩展。
①arguments对象可以检测函数的参数个数，引用属性arguments.length即可
e.g:
{
function A(){
console.log(arguments.length);
}
A("string",10,4543); // 这时候执行结果就是3
A(12); // 这时候执行结果就是1
A(); // 这时候执行结果就是0
}注释：与其它设计语言不同，ECMAScript不会验证传递给函数的参数的个数是否会等于函数定义的参数个数。开发者定义的函数都可以接受任意个数的参数(最多可以接受255个)，而不会引发任何错误。任何遗漏的参数都会以undefined传递给函数，多余的参数传进来之后函数会将其忽略。
②arguments对象还可以模拟函数重载：用arguments对象判断传递给函数的参数个数，即可模拟函数重载。
e.g:
{
function A(){
if(arguments.length == 1){
console.log(arguments[0]+20);
}
else if(arguments.length == 3){
console.log(arguments[0]+arguments[1]+arguments[2]);
}
}
A(15); // 这一行控制台输出35
A(20,30,40); // 这一行控制台输出90
}函数重载是一个同名函数完成不同的功能，编译系统在编译阶段通过函数参数个数、参数类型不同，函数的返回值来区分该调用哪一个函数，即实现的是静态的多态性。
重载函数是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。
总的来说，函数重载就是函数名相同，函数的参数不同(包括参数个数和参数类型)，根据参数的不同去执行不同的操作。
在JS中没有真正意义上的函数重载！
（2）ECMAScript Function对象（类）
ECMAScript的函数实际上时功能完整的对象。Function类可以表示开发者定义的任何函数。
用Function类直接创建函数的语法为：
var function_name = new Function(arg1,arg2,...,function_body)
// 在这种形式中每个arg都是一个参数，最后一个参数（function_body是函数主体）。这些参数必须是字符串，每个参数都得带上双引号 "" 或者引号 '' 所有的函数语句都写到最后一个参数里，用引号括起来。e.g:
{
var A = new Function("one","two",'console.log(one,two);console.log("11111");')
A(10,20); // 这里的第一行的输出结果是10 20 第二行的输出结果是11111
}注：尽管可以使用Function构造函数创建函数，但最好不要使用它，因为用它定义函数要比传统方法慢的多。不过，所有函数都应看作Function类的实例。
（3）ECMAScript闭包
闭包，通俗的讲就是函数可以使用函数之外定义的变量。
e.g:
{
var a = 10;
function A(num1,num2){
return num1 + num2 + a
}
A(20,30); // 这时候函数A就是一个闭包，因为它从函数内部调用了函数外部定义的变量
}注意：使用闭包要小心，它可能会变得非常复杂，由于闭包会常驻内存，增加内存使用量，使用不当会造成内存泄漏。使用不当还有可能会造成无效内存的产生，造成内存浪费。
（4） call()、apply()
JS中的每一个function对象都有一个apply()方法和一个call()方法，语法为：
apply()方法:方法A名称.apply(方法B名称,[参数数组]);
call()方法:方法A名称.call(方法B名称,[参数1,参数2,参数3,...,参数N]);
它们都可以用来代替另一个对象调用这个对象中的方法，改变一个函数的对象上下文给另外一个函数。简单的来说就是改变函数对象的this指向。
它们两个的区别就是传入参数的形式不一样，apply()是用参数数组（只有一个参数时也得用数组传），call()是用参数列表。
e.g：
function a(a,b){
return a+b
}
function b(a){
return a-10
}
var a1 = a.apply(b,[2,5]); // 使用apply方法使b方法调用a的方法
var b1 = b.apply(a,[2]); // 使用apply方法使a方法调用b的方法
var a2 = a.call(b,5,6); // 使用call方法使b方法调用a的方法
var b2 = b.call(a,5); // 使用call方法使a调用b的方法
console.log(a1,b1,a2,b2); // 7 -8 11 -5还可以实现继承，
e.g：
function Animal(name){
this.name = name;
this.showName = function(){
alert(this.name);
}
}
function Cat(name){
Animal.apply(this,[name]); // 这样就让Cat函数的上下文指向变成了Animal函数，实例化之后的Cat对象就可以调用Animal函数里的方法了
}
var cat = new Cat("咕咕");
cat.showName();
/*call的用法*/
Animal.call(this,name); // 跟apply方法效果一样还可以多重继承（也就是说一个函数使用apply或者call方法同时改变两个函数对象的上下文指向），
e.g：
function Class10(){
this.showSub = function(a,b){
alert(a - b);
}
}
function Class11(){
this.showAdd = function(a,b){
alert(a + b);
}
}
function Class12(){
Class10.apply(this);
Class11.apply(this);
// Class10.call(this);
//Class11.call(this);
}
var c2 = new Class12();
c2.showSub(3,1); //2
c2.showAdd(3,1); //4
（5）箭头函数
箭头函数属于函数表达式，如果它的函数体只有一个表达式，可以写成一行，省略return和大括号，直接返回该表达式。如果它的参数只有一个，可以省略小括号。
①箭头函数支持参数列表解构，e.g：
let f6 = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + cf6() // 6②箭头函数属于表达式函数，所以不存在函数提升。
③箭头函数相当于匿名函数，不能作为构造函数，不能使用new命令。
④箭头函数没有prototype（原型）属性。
⑤箭头函数不绑定this，它只会从自己的作用域链的上一层继承this。使用call、apply、bind并不会改变箭头函数中的this指向。
⑥箭头函数不绑定arguments，它只会从自己的作用链的上一层继承arguments。
⑦箭头函数可以使用扩展运算符（...）。
十一、JavaScript对象
（1）对象也是变量，但是对象包含很多值。
e.g:
var car = {type:"porsche",modle:"911",color:"white"}值以名称：值对的方式来书写 ，JS对象是被命名值的容器。
JS对象中的名称：值对被成为属性。
对象也可以有方法，方法是在对象上执行的动作，方法以函数定义被存储在属性中。
方法是作为属性来存储的函数。
e.g:
{
var person = {
firstName:"Lisa",
lastName:"Gates",
id:123,
fullName:function(){ // fullName这个方法作为person对象的一个属性写到对象定义里，它实质上是一个函数体
return this.firstName + this.lastName;
}
}
}（2）this关键字
在函数定义中，this引用该函数的“拥有者”，比如在（1）的例子中return this.firstName + this.lastName这段代码中的this指的就是fullName这个方法（也可以叫函数）的“拥有者”person对象。
（3）访问对象属性
有两种方式来访问对象属性：
①对象名.属性名
②对象名["属性名"]
e.g:
{
var person = {
firstName:"Lisa",
lastName:"Gates",
id:123,
fullName:function(){
return this.firstName + this.lastName;
}
}
console.log(person.firstName); // 输出为Lisa
console.log(person["firstName"]); // 输出也为Lisa
}（4）访问对象方法
想要访问对象的方法可以通过以下这种方式来实现：
对象名.方法名()
如果不使用()访问fullName方法，则将返回函数定义
e.g:
{
var person = {
firstName:"Lisa",
lastName:"Gates",
id:123,
fullName:function(){
return this.firstName + this.lastName;
}
}
console.log(person.fullName()); // 输出LisaGates
console.log(person.fullName); // 输出[Function: fullName]这个函数定义
}不要把字符串、数值和布尔值声明为对象！
（5）getter和setter
gettter是一种获得属性值的方法，setter是一种获得属性值的方法。
getter负责查询值，不带任何参数；setter负责设置键值， 值是以擦拭农户的形式传递的，在他的函数体中，所有的return都是无效的。
get和set不是对象的属性，而是属性的特性，特性只有在内部才能用，因此在JS中不能直接访问它们。
get和set有两种使用方式：
①
var person = {
_name:'',
get name(){
return this._name
},
set name(n){
this._name = n;
}
}
console.log(person.name); // 这里调用了对象中的get name方法获取this._name的值（也就是person._name的值）
person.name = 'zhangsan' // 这里调用了对象中的set name方法设置this._name为 zhangsan(也就是把person._name设置成zhangsan)
console.log(person.name); // 这里又调用了对象中的get name方法来获取this。_name（也就是person._name）②
var person = function(){
var _name = '';
var obj = {};
Object.defineProperty(obj,'name',{
configurable:true,
enumerable:true,
get:function(){
return _name
},
set:function(n){
_name = n;
}
})
return obj;
}();
console.log(person.name); // 这里调用了Object.defineProperty中的get方法 注意：用person.name是因为Object.defineProperty的方法名为name,如果这里改成zname就使用person.zname来调用get方法了
person.name = "Zhangsan"; // 这里调用了Object.defineProperty中的set方法设置person中的_name属性
console.log(person.name); // 再次调用Object.defineProperty中的get方法 输出Zhangsan十二、JS事件
（1）一些常见的HTML事件
onchange：HTML元素已经被改变
onclick：用户点击了HTML元素
onmouseover：用户把鼠标移动到HTML元素上
onmouseover：用户把鼠标移开HTML元素
onkeydown：用户按下键盘按键
onload：浏览器已经完成页面加载
十三、JS字符串
（1）JS字符串是引号中的零个或多个字符，可以使用‘单引号或者双引号，只要不匹配围绕字符串的引号即可。
（2）内置属性legth可以返回字符串的长度
（3）特殊字符——转义字符
字符串中有引号输出字符串会被切割，最好的解决办法就是使用转义字符。
通过转义字符把特殊字符转换为字符串字符：
\' ==> ' 转成字符串类型的单引号
\" ==> " 转成字符串类型的双引号
\\ ==> \ 转成字符串类型的反斜杠
（4）长代码换行——反斜杠（\）
一段长代码，你可以在字符串中使用反斜杠对它进行换行，但是不能通过反斜杠对代码进行换行，\方法并不是JS标准，某些浏览器也不允许\之后的空格。
对长字符串最安全的做法（但是有点慢）是使用字符串加法。
（5）JS字符串的创建
JS字符串是原始值，通过字面量方式创建
e.g：
var a = "asdf"但是字符串也可以通过关键词new定义为对象
e.g：
var a = new String("asdf")注：不要把字符串创建为对象，他会拖慢执行速度。
new关键字使代码复杂化。它可能会产生一些意外：
假如通过字面量的形式定义了一个字符串变量，又通过new关键字形式定义了一个字符串变量，当使用==时，相等字符串是相等的，当使用===时，相等字符串时不相等的
e.g:
var a = "asdf"
var b = new String("asdf")
console.log(a == b) // 输出结果是true
console.log(a === b) // 输出结果是false 因为a的数据类型是字符串类型，b的数据类型是对象类型十四、JS的字符串方法
注意：所有的字符串方法都会返回新字符串，它们不会修改原始字符串。
正式的说：字符串是不可变的，字符串不能更改，只能替换。
（1）字符串长度——length
length属性返回字符串的长度
e.g：
var a = "asdf"
console.log(a.length)（2）查找字符串中的字符串——indexOf()和lastIndexOf()
①indexOf()方法返回字符串中指定文本首次出现的索引（位置）
可以传入两个参数：第一个是查找的字符串内容（必选），第二个参数是检索起始位置（从检索起始位置到尾）（可选）
如果未找到文本，返回-1
e.g：
{
var a = "asdfgh";
console.log(a.indexOf("df")); // 输出2
console.log(a.indexOf("df",1)); // 输出2，从a这个字符串的第二位开始往后找df这个字符串，返回的还是字符串下标（找出来的位置不会因为查找的起始位置而改变，除非是查找不到这个字符串）
console.log(a.indexOf("sa")); // 输出-1 查找不到sa这个字符串
}②lastIndexOf()方法返回字符串中指定文本最后一次出现的索引（位置）
它也可以传入两个参数：第一个是查找的字符串内容（必选），第二个参数是检索起始位置（从检索起始位置到头）（可选）
如果未找到文本，返回-1
e.g：
{
var str = "hellohellohi";
console.log(str.lastIndexOf("llo")); // 输出7
console.log(str.lastIndexOf("llo",7)); // 输出7，从str这个字符串下标为7的位置开始往前查，下标七位上的数字是l，虽然是从这个l往前查，但是也会去读这个l后面是什么，虽然lastIndexOf是从后往前查，但是排序还是从前往后算的
console.log(str.lastIndexOf("llo",6)); // 输出2，这个时候是从str中下标6开始往前查的，第二个llo就查不到了，第一个llo也就变成了最后一个，所以输出2
console.log(str.indexOf("sa")); // 输出-1 查找不到sa这个字符串
}indexOf()和lastIndexOf()无法设置更加强大的搜索值（正则表达式）
（3）检索字符串中的字符串——search()
search()方法搜索特定值的字符串，并返回匹配的位置
search()方法无法设置第二个位置参数
e.g：
var str = "I love china";
console.log(str.search("chi")); // 输出7 注意：空格也占位置（4）提取部分字符串——slice(start,end)、substring(start,end)、substr(start,length)
①slice()提取字符串的某个部分并在新字符串中返回被提取的部分。两个参数：第一个参数 开始截取的位置（必选）；第二个参数 终止截取的位置（必选）
e.g：
var str = "Apple,Banana,Mango";
console.log(str.slice(6,12)); // 输出Banana如果某个参数为负数，就从字符串的结尾开始计数（负值部分不适用于internet Explorer 8及其更早版本）
e.g：
var str = "Apple,Banana,Mango";
console.log(str.slice(-12,-6)); // 输出Banana -12指的是从字符串尾部往前数13位数，-6指的是从字符串尾部往前数7位数②substring()类似于slice()。但是它无法接受负值。两个参数：第一个参数 开始截取的位置（必选）；第二个参数 终止截取的位置（可选），如果省略了第二个参数，就会截取字符串的剩余部分。
e.g：
var str = "Apple,Banana,Mango";
console.log(str.substring(6,12)); // 输出Banana
console.log(str.substring(6)); // 输出Banana,Mango③substr()类似于slice()。但是它的第二个参数变成了被提取部分的长度。两个参数 第一个参数 开始截取的位置（必选）；第二个参数 需要截取的长度（可选），如果省略了第二个参数，就会截取字符串的剩余部分。
e.g：、
var str = "Apple,Banana,Mango";
console.log(str.substr(6,7)); // 输出Banana
console.log(str.substr(6)); // 输出Banana,Mango如果首个参数为负，则从字符串尾部往前找开始截取的位置，然后往后截取一段长度
e.g:
var str = "Apple,Banana,Mango";
console.log(str.substr(-12,6)); // 输出Banana
console.log(str.substr(6)); // 输出Banana,Mango注：substr()在现版本的vscode中已被弃用
（4）替换字符串内容——replace()
replace()方法不会调用它本身的字符串，它返回的是新字符串。
replace()默认只替换首个匹配。如果要替换所有匹配就使用正则表达式/g（全局搜索）。
replace()默认对大小写敏感。如果要执行大小写不敏感的替换，就使用正则表达式/i（大小写不敏感）。
注意：正则表达式不带引号
e.g：
var str = "Apple,BANANA,Banana,Mango,Banana";
console.log(str.replace("Banana","aaaa")); // 输出Apple,BANANA,aaaa,Mango,Banana 说明replace()方法对大小写敏感，所以第一个BANANA不会被替换 replace()默认只对第一个查到的匹配对象生效，所以最后一个Banana不会被替换
console.log(str.replace(/Banana/i,"aaaa")); // 输出Apple,aaaa,Banana,Mango,Banana 通过 /i来使replace变成大小写不敏感的
console.log(str.replace(/Banana/g,"aaaa")); // 输出Apple,BANANA,aaaa,Mango,aaaa 通过/g来使replace进行全局替换，但是注意这时候没有使用/i replace还是大小写敏感的
console.log(str.replace(/Banana/gi,"aaaa")); // 输出Apple,aaaa,aaaa,Mango,aaaa 通过/gi来使replace进行全局替换并且不区分大小写
console.log(str); // 输出Apple,BANANA,Banana,Mango,Banana 说明replace不会改变原字符串，它返回的是一个新字符串（5）转换为大写和小写——toUpperCase()、toLowerCase()
①通过toUpperCase()方法把字符串转换为大写
e.g：
var str = "Apple,BANANA,Banana,Mango,Banana";
console.log(str.toUpperCase()); // 输出APPLE,BANANA,BANANA,MANGO,BANANA②通过toLowerCase()方法把字符串转换为小写
e.g:
var str = "Apple,BANANA,Banana,Mango,Banana";
console.log(str.toLowerCase()); // 输出apple,banana,banana,mango,banana（6）连接两个字符串——concat()
concat()连接两个或多个字符串
concat()方法不会修改原始字符串，它会返回新字符串
e.g：
var str = "aaa"
var str1 = "bbb"
var str2 = "ccc"
var str3 = "ddd"
var str4 = "eee"
console.log(str.concat(str1,str2,str3,str4)); // 输出结果是aaabbbcccdddeee 也就是说它的参数可以无限多
console.log(str); // 输出aaa 说明原str字符串不变concat()方法可以用于代替加运算符
e.g：
var str = "aaa"
var str1 = "bbb"
console.log(str.concat(str1)); // 输出aaabbb
console.log(str + str1); // 输出aaabbb 上面这两行是等效的（7）删除字符串两端的空白符——trim()
trim()方法用于删除字符串两端的空白符，但是这个方法消除不了字符串中间的空白符。
e.g：
var str = " aaa bbb "
console.log(str); // 输出“ aaa bbb ”
console.log(str.trim()); // 输出“aaa bbb” 这个方法消除不了字符串中间的空白符注意：Interne Explorer 8或更低版本不支持trim()方法
如果需要支持IE 8，可以使用replace()方法配合正则表达式代替实现：
e.g：
var str = " Hello World! ";
console.log(str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''));还可以使用上面的 replace 方案把 trim 函数添加到JavaScript的String.prototype中
像下面这样：
if (!String.prototype.trim) {
String.prototype.trim = function () {
return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
};
}然后就可以直接用trim()方法去除字符串两端的空白符了
（8）提取字符串字符——chatAt(position)、chatCodeAt(position) 这是两个提取字符串的安全方法。
①chatAt()方法
chatAt()方法返回字符串中指定下标（位置）的字符串
e.g：
var str = "Hello World!";
console.log(str.charAt(1)); // 输出e②chatCodeAt()方法
chatCodeAt()方法返回字符串中指定索引的字符的unicode编码
e.g：
var str = "Hello World!";
console.log(str.charAt(1)); // 输出e（9）属性访问——StringName[]
ES5开始允许对字符串的属性进行访问[]
e.g：
var str = "Hello World!";
console.log(str[0]); // 输出H但是使用属性访问有点不靠谱：①不适用与Internet Explorer 7或之前的版本
②如果找不到字符，[]返回undefined，而chatAt()返回空字符串
③它是只读的。str[0] = "A"不会产生错误，但是它也不会工作！
④它看起来像数组，但是并不是
（10）把字符串转换为数组——split()
可以通过split(）方法将字符串转换为数组
如果省略分隔符，被返回的数组将包含index[0]中的整个字符串
如果分隔符是""，被返回的数组将是间隔单个字符的数组
e.g：
var str = "Hello World,Hi";
console.log(str.split()); // 输出['Hello World,Hi']
console.log(str.split("")); // 输出['H','e','l','l','o',' ','W','o','r','l','d', ',','H','i']
console.log(str.split(" ")); // 输出['Hello','World,Hi']
console.log(str.split(",")); // 输出['Hello World','Hi']十五、字符串搜索
字符串搜索有几种种方法：String.indexOf()、String.lastIndexOf()、String.search()、String.match()、String.includes()、String.startsWith()、String.endsWith()
其中String.indexOf()、String.lastIndexOf()和String.search()在十四点中已经讲了，这里主要说String.match()、String.includes()、String.startsWith()、String.endsWith()这四种方法
（1）String.match(regexp)
match()方法根据正则表达式在字符串中搜索匹配项，并将匹配项以数组对象返回，这个方法有一个参数：填需要搜索的值，必须用正则表达式写，必选项
e.g：
var str = "Hello World,Hi,hello.hello.";
console.log(str.match(/llo/g)); // 输出[ 'llo', 'llo' ]如果要进行不区分大小写的全局搜索，应该下面这样写：
var str = "Hello World,Hi,heLLO.hello.";
console.log(str.match(/llo/gi)); // 输出[ 'llo', 'LLO', 'llo' ]（2）String.includes()
十五、AJAX
Ajax是用来页面局部刷新的技术
步骤：
{
var xhttp = new XMLHttpRequest();
xhttp.open(method,url,async); // （方法，路径，异步还是同步（true还是false））
xhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded"); // 设置请求头
xhttp.onreadystatechange = function(){ // 判断请求状态
if(this.readyState == 4 && this.status == 200){
console.log(this.responseText);
}
}
xhttp.send("fname=Bill&lname=Gates"); // 发送数据
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
