函数
1、函数声明
没有参数的函数
function kd(){ console.log('hello'); } kd(); //函数的直接调用法有参数的函数
function kd(name,age){ console.log('姓名：'+name+' , 年龄：'+age); } kd('杜兰特',31); // 姓名：杜兰特 , 年龄：31
2、return返回值
用return的好处：
可以退出函数
return返回与直接调用函数的区别是，return返回是在函数外面输出值，这种方法最常用
返回的值可以赋值给变量
function kd(){ return '死神-杜兰特'; } kd(); //如果直接调用，就会变成下面这样 "死神-杜兰特" console.log(kd()); //无参数的函数返回 // 死神-杜兰特 ------------------------------------------ function kd(name,age){ return'姓名：'+name+' , 年龄：'+age; } console.log(kd('杜兰特',31));//有参数的函数返回 //姓名：杜兰特 , 年龄：31 ------------------------------------------- function add(n1,n2){ return n1+n2; } var sum=add(1,2); //函数返回值赋给变量sum console.log(sum); // 3
3、argument对象
运用argument对象的length属性实现累加运算
对象和数组
一、object类型
主要用于封装数据，引用类型是一种数据结构,用于将数据和功能组织在一起
创建方法：
var kd = new Object(); //使用new运算符创建,new可省略 kd.name='杜兰特'; //创建属性字段 kd.age=31; ----------------------- var kd={ //字面量方式创建，属性与值之间有（：）连接 name:'杜兰特', //属性与属性之间用逗号连接 age:31 //最后一个属性不加逗号 } ------------------------ var kd={} //字面量的传统赋值方式 kd.name='杜兰特'; kd.age=31;属性输出方式：
var kd={ name:'杜兰特', age:31 } console.log(kd.name); //以点运算符输出 // 杜兰特 console.log(kd['age']); //以数组的方式输出，引号不可以省略，但这种方式太麻烦 // 31为对象创建方法（方法即表示函数）
第一种方式：
var add={ ad:function kd(num1,num2){ //带参数的函数 return num1+num2; } } console.log(add.ad(1,4)); // 5 ----------------------------- var obj={ run:function (){ //不带参数的函数 return 'sdhkf'; } } console.log(obj.run); //如果run后面不加（），将打印出函数本身 /* ƒ (){ return 'sdhkf'; }*/ console.log(obj.run()); //run后面带参数才能打印出结果 //sdhkf第二种传统方式：
function kd(){ return '杜兰特'; } var obj=new Object(); obj.run=kd; obj.age=31; alert(obj.run()); alert(obj.age);delete删除对象属性：
var kd={ name:'du', age:31 } console.log(kd); //{name: "du", age: 31} //删除前结果 delete kd.age;结果 console.log(kd); //{name: "du"} //删除后向函数传递对象：
function kd(obj){ //kd（）内的obj可以不写，但调用该函数时必须传入obj console.log(obj.age); } var obj={ name:'杜兰特', age:31 } kd(obj); //函数调用时，必须传入对象obj // 31
二、Array（数组）类型
数组属于object类型,数组中可以包含对象、数组、字符串、数值等
创建数组：两种方式，使用new关键字创建，使用字面量创建
var kd=new Array(); //new关键字方式 var kd=new Array(10); //定义数组元素个数，括号内只能是单个数字，否则会被当作元素处理 var kd=Array('杜兰特'，'31'，'死神')
逆序输出一组数：
function print(num){ for (var i=num.length-1;i>=0;i--) { console.log(num[i]); } } var num=Array(1,2,3,4,5,6,7,8,9,10); print(num); //10,9,8,7,6,5,4,3,2,1使用length属性为数组增加元素：
var kd=['kd',31,'杜兰特']; //增加前 console.log(kd); /*(3) ["kd", 31, "杜兰特"] 0: "kd" 1: 31 2: "杜兰特" length: 3 __proto__: Array(0)*/ ---------------------- kd[kd.length]='死神'; //增加后 console.log(kd) /*(4) ["kd", 31, "杜兰特", "死神"] 0: "kd" 1: 31 2: "杜兰特" 3: "死神" length: 4 __proto__: Array(0)*/
三、对象中的方法
1、转换方法
var kd=['杜兰特',31,'USA'];
console.log(kd.join("|"));
//杜兰特|31|USA 使用join方法的运行结果，不该变原数组的类型
console.log(kd)
// ["杜兰特", 31, "USA"] 原数组不发生改变
2、栈方法（先进后出）
3、队列（先进先出）
4、总结：
- push()方法：数组末尾添加元素，并返回长度
- pop（）方法：移除数组末尾元素，并返回该元素
- shift（）方法：移除数组开头元素，并返回该元素
- unshift（）方法：数组开头添加元素 IE浏览器不识别，因此该方法不常用
5、重排序方法（两种方法均返回object类型）
var sum=[5,7,3,1,4,6,8,]; console.log(sum.reverse());//reverse()方法：实现逆序排列 //[8, 6, 4, 1, 3, 7, 5] console.log(sum) //[8, 6, 4, 1, 3, 7, 5] //可以看到，原数组发生改变 console.log(sum.sort()) //sort（）方法：实现从大到小排列 //[1, 3, 4, 5, 6, 7, 8] console.log(sum) //[1, 3, 4, 5, 6, 7, 8] //同样，原数组发生改变
sort（）方法对数字进行排序的缺陷：
var num=[24,15,0,5,36];
console.log(num.sort())
//[0, 15, 24, 36, 5] 该方法会把数字当成字符串只对第一个数字进行排序，造型排序不正确
//改进方法：可以对sort方法传入一个函数
var num=[3,45,5,7,-1,-4];
console.log(num.sort())
// [-1, -4, 3, 45, 5, 7]
function sortnum(a,b){
return a-b;
}
console.log(num.sort(sortnum)); //传入函数后排序正常，不过我也没搞明白这是为啥，期待有一天会理解
//[-4, -1, 3, 5, 7, 45]
6、操作方法
concat():在原数组后添加元素，返回新数组，不改变原数组
slice（）：在原数组中截取一部分形成新数组
splice（）：有三个功能，可以对原数组进行删除，替换，插入
var num =[1,2,3,4,5,6]; var num1=num.concat(0); console.log(num1); // [1, 2, 3, 4, 5, 6, 0] var num3=num.slice(1,4); //从第一个位置截取到第四个位置，一个逗号表示一个位置 console.log(num3) // [2, 3, 4] var num4=num.splice(0,3); //splice第一个参数0表示从第0个位置开始删除，第二个参数3表示删除3个 console.log(num4); // [1, 2, 3] console.log(num) //删除过后的数组 // [4, 5, 6] var num5=num.splice(1,0,10,100); //从第一个位置删除0个，然后插入10、100两个参数 console.log(num5) // [] console.log(num) //插入后的数组 // [4, 10, 100, 5, 6] var num6=num.splice(3,1,1000);//替换 console.log(num) // [4, 10, 100, 1000, 6]
日期和时间
1、Date类型
时间零点是指：1970年1月1日 00:00:00
不带参数
--------------------//如果直接调用Date，则把当前时间以字符串的方式输出 Date() //"Sat Jun 29 2019 12:14:16 GMT+0800 (中国标准时间)" --------------------//创建Date函数 var time= new Date(); //不传参数的情况下，则返回当前时间 console.log(time); // Sat Jun 29 2019 11:29:53 GMT+0800 (中国标准时间)
带参数
var time=Date('03/4/2018'); //如果省略new，则相当于直接调用Date，只能返回当前时间
console.log(time);
//Sat Jun 29 2019 12:13:11 GMT+0800 (中国标准时间)
var time= new Date('03/4/2018');
console.log(time);
//Sun Mar 04 2018 00:00:00 GMT+0800 (中国标准时间)
new Date('2013-2-15')
new Date('2013/2/15')
new Date('02/15/2013')
new Date('2013-FEB-15')
new Date('FEB, 15, 2013')
new Date('FEB 15, 2013')
new Date('February, 15, 2013')
new Date('February 15, 2013')
new Date('15 Feb 2013')
new Date('15, February, 2013')
// Fri Feb 15 2013 00:00:00 GMT+0800 (CST)
各个参数的取值范围如下。
年：使用四位数年份，比如2000。如果写成两位数或个位数，则加上1900，即10代表1910年。如果是负数，表示公元前。
月：0表示一月，依次类推，11表示12月。
日：1到31。
小时：0到23。
分钟：0到59。
秒：0到59
毫秒：0到999
当为Date传递参数是，最少传递两个，即年和月不可省略
new Date(2013) // Thu Jan 01 1970 08:00:02 GMT+0800 (CST)
上面代码中，2013被解释为毫秒数，而不是年份。
new Date(2013, 0) // Tue Jan 01 2013 00:00:00 GMT+0800 (CST) new Date(2013, 0, 1) // Tue Jan 01 2013 00:00:00 GMT+0800 (CST) new Date(2013, 0, 1, 0) // Tue Jan 01 2013 00:00:00 GMT+0800 (CST) new Date(2013, 0, 1, 0, 0, 0, 0) // Tue Jan 01 2013 00:00:00 GMT+0800 (CST)
上面代码中，不管有几个参数，返回的都是2013年1月1日零点。
new Date(2013,15) //Tue Apr 01 2014 00:00:00 GMT+0800 (中国标准时间) new Date(2018,-1) //Fri Dec 01 2017 00:00:00 GMT+0800 (中国标准时间)
上面代码中,但日期超限或者为负数时，函数会自动对时间进行加减运算，比如第一个2013年15月，就会折算为2014年4月，2018年-1月变为2017年11月
日期运算
var t1=new Date(2018,4); var t2=new Date(2018,5); console.log(t1-t2); //进行减法运算会返回毫秒数 // -2678400000 undefined console.log(t1+t2); //进行加法运算会返回连接后的字符串 //Tue May 01 2018 00:00:00 GMT+0800 (中国标准时间)Fri Jun 01 2018 00:00:00 GMT+0800 (中国标准时间)
静态方法
Date.now()方法：返回当前时间距离时间零点的毫秒数
Date.parse()方法：解析日期字符串，返回该时间距离时间零点（1970年1月1日 00:00:00）的毫秒数，如果日期解析失败，就返回NaN
Date.UTC()方法：
// 格式 Date.UTC(year, month[, date[, hrs[, min[, sec[, ms]]]]]) // 用法 Date.UTC(2011, 0, 1, 2, 3, 4, 567) // 1293847384567
2、通用方法
valueOf()方法：返回当前时间距离时间零点的毫秒数
var kd=new Date(); kd.valueOf() //1561814916892
toString（）方法：返回时间字符串
kd.toString() //"Sat Jun 29 2019 21:28:36 GMT+0800 (中国标准时间)"
3、日期格式化方法（To类方法）
toUTCString():返回对应的 UTC 时间，也就是比北京时间晚8个小时。
toISOString()：同样返回UTC时间，
var d = new Date(2013, 0, 1); d.toISOString() // "2012-12-31T16:00:00.000Z" ISO8601 写法
toJSON()：返回的时间为json格式
var kd=new Date('2018/2/3') kd.toJSON() //"2018-02-02T16:00:00.000Z"toTimeString方法返回时间字符串（不含年月日）toLocaleString()：返回本地时间
不带参数的情况：
var kd=new Date(); kd.toLocaleString() //"2019/6/29 下午10:27:26" kd.toLocaleDateString() //"2019/6/29" kd.toLocaleTimeString() //"下午10:27:26"
带参数的情况：
这三个方法都有两个可选的参数。
dateObj.toLocaleString([locales[, options]]) dateObj.toLocaleDateString([locales[, options]]) dateObj.toLocaleTimeString([locales[, options]])
这两个参数中，
locales是一个指定所用语言的字符串，options是一个配置对象。下面是locales的例子。var d = new Date(2013, 0, 1); d.toLocaleString('en-US') // "1/1/2013, 12:00:00 AM" d.toLocaleString('zh-CN') // "2013/1/1 上午12:00:00" d.toLocaleDateString('en-US') // "1/1/2013" d.toLocaleDateString('zh-CN') // "2013/1/1" d.toLocaleTimeString('en-US') // "12:00:00 AM" d.toLocaleTimeString('zh-CN') // "上午12:00:00"下面是
options的例子。var d = new Date(2013, 0, 1); // 时间格式 // 下面的设置是，星期和月份为完整文字，年份和日期为数字 d.toLocaleDateString('en-US', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }) // "Tuesday, January 1, 2013" // 指定时区 d.toLocaleTimeString('en-US', { timeZone: 'UTC', timeZoneName: 'short' }) // "4:00:00 PM UTC" d.toLocaleTimeString('en-US', { timeZone: 'Asia/Shanghai', timeZoneName: 'long' }) // "12:00:00 AM China Standard Time" // 小时周期为12还是24 d.toLocaleTimeString('en-US', { hour12: false }) // "00:00:00" d.toLocaleTimeString('en-US', { hour12: true }) // "12:00:00 AM"
4、get（）与set（）方法
正则表达式
1、什么是正则表达式
概念：正则表达式即为ECMAScript的RegExp类型
功能： 给定一个正则表达式和另一个字符串，我们可以达到如下的目的：
1、给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）；
- 可以通过正则表达式，从字符串中获取我们想要的特定部分。
简单点说，正则表达式跟平时用的字符串操作功能函数类似，但比这些函数的功能要强大的多。
举例说，你爱看某本非常之流行的小说，你想要从某个网站下载，并将这些内容分章节保存到你的计算机里，但直接下载的话，可能网页里面有很多不想要的（比如一些讨厌的广告什么的），如果要用字符串替换也可以做到，但许多广告字符串蛮狡猾滴说，老是有些小变化来着，如果每个都替换一下会累似人的，这时正则表达式就可以大有用处了，它可以通过某些规则适应这些变化，而自动删除。
ECMAScript：ECMAScript是一种由Ecma国际（前身为欧洲计算机制造商协会,英文名称是European Computer Manufacturers Association）通过ECMA-262标准化的脚本程序设计语言。这种语言在万维网上应用广泛，它往往被称为JavaScript或JScript，所以它可以理解为是JavaScript的一个标准,但实际上后两者是ECMA-262标准的实现和扩展。
2、创建正则表达式
两种方法创建：
测试方法：RegExp包含两种方法，test（）、exec（），即为自带的方法
/*test（）方法 返回的值布尔类型*/ var kd=new RegExp('Java'); var str='java'; console.log(kd.test(str)); // false var kd=new RegExp('Java','i'); //可以看到，当传入参数i时，此时返回true var str='java'; console.log(kd.test(str)); // true console.log(/java/i.test(str)) //简写方式，太凌乱，不常用 //true /*exec（）方法 返回的是数组*/ var t1=/kd/; var t2='his name is kd'; console.log(t1.exec(t2)); //["kd", index: 12, input: "his name is kd", groups: undefined] var t1=/ss/; var t2='his name is kd'; console.log(t1.exec(t2)); // null思考：问题来了，以上代码显示，正则表达式可以比较字符串，那么为什么不用传统==的方法比较？
/*传统方法*/ var t1='kd'; var t2='Kd'; console.log(t1==t2)//flase /*正则方法*/ var t1=/kd/; var t2='his name is kd'; console.log(t1.test(t2));// true
以上代码显示，传统方法只能比较大小写不同或相同的字符串，而正则方法可以比较一句话中是否有kd；
使用字符串的正则表达式的方法（String对象提供的方法）
1、match()方法：返回数组，可以实现全局搜索的功能
var kd=/java/i; //未加全局搜索 var str='i like java'; console.log(str.match(kd)); //["java", index: 7, input: "i like java", groups: undefined] var kd=/java/ig; //添加全局搜索 var str='i like java,but i do not like Java'; console.log(str.match(kd)); // ["java", "Java"]
2、search()：返回所要查找的对象的位置，如果未匹配到则返回-1
var kd=/java/i; var str='i like java'; console.log(str.search(kd)); // 7 返回7是因为空格也会占数组空间
3、replace()、split()方法
var kd=/ /i; //以空格进行拆分，返回数组 var str='i like java'; console.log(str.split(kd)); // ["i", "like", "java"]
4、静态属性：使用前必须先执行一下
ps:短命的使用方法
常规写法：alert(RegExp(str))=alert(RegExp['$_'])，但是input属性比较特殊也可以写为
alert(RegExp(str))=alert(RegExp.$_)
5、实例方法
3、获取控制
视屏截图
分组模式匹配
var kd=/java{3,4}/; //表示匹配最后一个字母 a 3-4次时返回true var str='javaaajavajava'; console.log(kd.test(str)) //true var kd=/(java){3,4}/; //匹配字符串Java3-4次 var str='javajavajava'; console.log(kd.test(str)) // true var kd=/a(.*)a/; var str='javajavajava'; kd.test(str);//必须先运行一下 console.log(RegExp.$1) //获取模式中第一个分组中所对应匹配的字符串 //vajavajav <---------replace方法结合分组实现替换------------> var kd=/0(.*)0/; var str='i like 0java0'; console.log(str.replace(kd,'python')) //i like python var kd=/0(.*)0/; var str='i like 0java0'; console.log(str.replace(kd,'$1'))//$1代表模式中取出的字符串.$1必须用引号扩起来 // i like java <---------repalce方法结合分组实现位置交换----------> var kd=/(.*)\s(.*)/; var str='java python'; console.log(str.replace(kd,'$2 $1')) //$1\$2分别代表第一与第二所匹配的字符串 // python java贪婪和惰性问题
<-------------典型贪婪-------------> var kd=/0(.*)0/; var str='0java0 0java0 0java0'; console.log(str.replace(kd,'$1')) // java0 0java0 0java <------------解决办法--------------> /***惰性解决法***/ var kd=/0(.*?)0/; //不带全局属性仍解决不了 var str='0java0 0java0 0java0'; console.log(str.replace(kd,'$1')) //java 0java0 0java0 var kd=/0(.*?)0/g; //带上全局 var str='0java0 0java0 0java0'; console.log(str.replace(kd,'$1')) // java java java /***另一种方法***/ var kd=/0([^0]*)0/g; var str='0java0 0java0 0java0'; console.log(str.replace(kd,'$1')) // java java java
exec返回数组，如果是分组模式返回则会造成捕获型分组返回，因此需要非捕获型分组
<-----------返回数组-----------> var str='java 3310'; var kd=/^([a-z]+)\s([0-9]{4})$/; //使用分组的方式 console.log(kd.exec(str)) // ["java 3310", "java", "3310"] <-----------捕获型分组，返回所有的分组------> var kd=/(\d+)([a-z])/; //\d也可以修改为【0-9】 var str='124rty'; console.log(kd.exec(str)); // ["124r", "124", "r"] //‘123r’也返回 <-----------非捕获型分组------------------> var kd=/(\d*)(?:[a-z])/; //分组内加上?: var str='124rty'; console.log(kd.exec(str)); // ["124r", "124"] var kd=/(?:\d*)(?:[a-z])/; var str='124rty'; console.log(kd.exec(str)); // ["124r"] <------------前瞻性捕获------------ > var kd=/java(?=python)/; var str='javapython'; console.log(kd.exec(str)); // ["java"] <------------特殊符号的获取-----------> var kd=/\#/; //用一个反斜杠获取特殊符号 var str='#'; console.log(kd.test(str)) VM814:3 true <------------换行模式----------> var kd=/\d+/; //未开始换行模式时，只有第一行的数字替换成0 var str='1.java\n2.html\n3/css'; console.log(str.replace(kd,'0')) /* 0.java 2.html 3/css */ var kd=/\d+/gm; //开启换行模式后各行的数字均变为0 var str='1.java\n2.html\n3/css'; console.log(str.replace(kd,'0')) /* 0.java 0.html 0/css */
4、常用的正则
检查电话号码码
var str='15650624038'; var tel=/[1][0-9]{10}/; console.log(tel.test(str)) // true检查qq邮箱格式
var yx=/\d{9,11}@qq.com/ var str="749866529@qq.com" console.log(yx.test(str)) true删除空格
var kd=/\s/g; var str="1 2 3 4 5 6 " console.log(str.replace(kd,""))//实际就是将空格替换掉 123456
删除首尾空格
var kd=/^\s+(.+?)\s+$/; var str=" 123456 " console.log(str.replace(kd,"$1"))//$1表示获取表达式中的第一个分组 123456