14.JavaScript基础

1.js简介

js全称JavaScript,是一中轻量级编程语言,可以插入HTML页面由浏览器执行。
版本主要使用5.1 6.0

年份	名称	描述
1997	ECMAScript 1	第一个版本
1998	ECMAScript 2	版本变更
1999	ECMAScript 3	添加正则表达式添加try/catch
	ECMAScript 4	没有发布
2009	ECMAScript 5	添加"strict mode"严格模式添加JSON支持
2011	ECMAScript 5.1	版本变更
2015	ECMAScript 6	添加类和模块
2016	ECMAScript 7	增加指数运算符（**）增加Array.prototype.includes

2.引入方式

1.在script便签内部直接书写js代码。
2.script标签属性引入外部js代码。

3.语法

console.log('holle word'); 
// 不管那么多,上来就 holle word

3.1注释

 // 单行注释
 /*
 多行注释1
 多行注释2
 多行注释3
 */

3.2结束符

js以;作为语句的结束符号,如果不写不会报错,可以正常执行。

4.变量

4.1命令规范

1.变量名可以是数字,字母,下划线_, $的组合
2.不能以数字开头
3.不能与关键字冲突
js推荐使用驼峰式命名
userName
* 变量名是区分大小写的。

4.2关键字

1.关键字 var 作用于全局.
var name = 'kid'
2.关键字 let 作用于局部.
let name = 'kid'

* 5.1版本无法使用let,6.0版本编译器向下兼容。
ES6新增了let命令，用于声明变量。
其用法类似于var，但是所声明的变量只在let命令所在的代码块内有效。

4.3let演示

例如：for循环的计数器就很适合使用let命令。

var i = 0

for (let i = 0; i < 10; i++) {
}
console.log(i)  // 0

for (var i = 0; i < 10; i++) {
}
console.log(i)  // 10

let i = 0
function f1 (){
    let i = 1
    console.log(i)  // 1
}
f1()
console.log(i)  // 0

5.常量

const  定义常量
const P = 3.1415;
常量一旦被定义了就无法修改

const P = 3.1415926

P = 1  // TypeError: Assignment to constant variable.

6.数据类型

js是一门动态类型语言,变量名可以指向任意类型。

var num = 1;  // 定义整型
num = 'abc'  // 变量的类型,在重新赋值就发生变化了

7.数值类型

数值类型 number
js中数值类型包括了整数和浮点数.
浮点数小数点后面全是0 会省略成整数.

7.1定义数值类型

var a = 1;
var b = 1.11;
console.log(typeof a);  // number
console.log(typeof b);  // number

7.2数值计算

var num1 = 1
var num2 = 1.0

console.log(num2)  // 1.0 省略成 1
console.log(num2 + num1)  // 2

7.3常用方法

parseInt() 转整数
parseFloat() 转浮点数
* NaN,表示不是一个数字 --> NOT A NUMBER

parseInt('123456');  // 纯数字字符串
123456
parseFloat('11.11');
11.11
parseInt('11.11');   // 11  保留整数部分
11
parseInt('123asdas'); // 123 识别数字部分,遇到非数字断开,结束转换。
123
parseInt('asdas');    // NaN 非数字
NaN

8.字符类型

字符类型string
定义字符串可以使用单引号或双引号括起来.
多行字符串可以使用``反引号括起来. (称为模板字符串)

8.1字符串的定义

// 单行定义
var s1 = 'aaa'
var s2 = "aaa"

// 多行定义
var s3 = `
aaa
bbb
ccc
`
console.log(typeof s3, s3)

/*
string
aaa
bbb
ccc
*/

8.2格式化输出

${}会自定匹配定义过的变量.

var name = 'kid'
var age = '18'

s1 = `my name is ${name} I'm  ${age} years old.`

console.log(s1)  // my name is kid I'm  18 years old.

8.3字符换的拼接

js中推荐使用+号拼接字符。

var s1 = 'aaa'
var s2 = 'bbb'

var S3  // 需要分两步来定义

s3 = s1 + s2

console.log(s3)  // aaabbb

8.4常用方法

方法	说明
.length	返回长度
.trim()	移除空白
.trimLeft()	移除左边空白
.trimRight()	移除右边空白
.chaerAt()	返回第xx个字符
.concat()	拼接
.indexOf()	子序列位置
.substring()	根据索引获取子序列
.slice()	切片
.toLowerCase()	小写
.toUpperCase()	大写
.splist()	分割

1.获取长度

var name = 'kid'
console.log(name.length)  // 3

2.移除空白

只能移除空白,不能在括号内指定字符移除。

var s1 = ' abc  '
console.log(s1.trim())  // abc

// 指定左边空白
console.log(s1.trimLeft())  // 在pycharm中看不出效果,在网页中测试可以看

// 指定移除右边空白
console.log(s1.trimRight())

3.索引取值

索引都是以0开始,默认不写是空的话对应的是0。

var s1 = '123456789'

console.log(s1.charAt(0))  // 1
console.log(s1.charAt())  // 1

4.查找索引

如果是一个字符串,返回的首个字符的索引。

var s1 = '123456789'

console.log(s1.indexOf(2))  // 1
console.log(s1.indexOf(23))  // 1

5.切片

.sbustring()不识别负数。不用这个。
.slice()识别负数。使用这个。

var s1 = '0123456789'

console.log(s1.substring(0, 5))  // 01234

console.log(s1.slice(-10, -1))  // 012345678

6.大小写转换

var s1 = 'aabbcc'
var s2 = 'AABBCC'

console.log(s1.toUpperCase())  // AABBCC
console.log(s2.toLowerCase())  // aabbcc

7.切分

括号内指定以什么切分,后面跟的数字为切分的次数。

var names ="kid|qz|qq|pp|qaq"

console.log(names.split('|'))  // [ 'kid', 'qz', 'qq', 'pp', 'qaq' ]

var names ="kid|qz|qq|pp|qaq"

console.log(names.split('|', 2))  // [ 'kid', 'qz' ]

8.拼接

js弱类型语言。
concat拼接会自动转换类型,不同的类型会转换相同的类型。

var s1 = "123"
var num = 123

var s2
s2 = s1 + num
console.log(typeof s2, s2)  // string 123123

9.布尔值

布尔值 (boolean)

falst 假 为假的值：0、null、undefined、NaN、数据类型的值为空···
true  真 上面相反的添加
* 全小写

10.null与undefined

null表示值是空,一般在需要指定或清空一个变量时才会使用.
	如 name=null;
undefined表示当声明一个变量但未初始化时,该变量的默认值是undefined。
	还有就是函数无明确的返回值时，返回的也是undefined。

11.对象

JavaScript 中的所有事物都是对象：字符串、数值、数组、函数...此外，
JavaScript 提供多个内建对象，比如 String、Date、Array 等等。
JavaScript 允许自定义对象.

12.数组

数组 (Array)
索引取值时不可以使用负数。

12.1定义数组

数组的值用中括号括起来,元素之间用逗号隔开.
var 变量 = [元素1, 元素2 ...]

var l1 = [1, 2, 3]
console.log(typeof l1)  // object

console.log(l1[1])  // 2
console.log(l1[-1])  // undefined

12.2常用方法

方法	说明
.length	长度
.push()	尾部追加元素
.pop()	获取尾部元素
.undhilt()	头部插入元素
shife()	头部移除元素
.slice()	切片
.reverse()	反转
.join()	将数组元素拼接程字符串
concat()	连接数据
sort()	排序
.forEach()	将数组每个元素传递给回调函数
.splice()	删除元素
.map()	返回一个数组元素调用函数处理后的值的新数组

1获取长度

获取元素的个数。

var l1 =[11,22,33,44];
console.log(l1.length)  // 4

2.元素增删

.push();尾部追加元素
.pop(); 弹出尾部元素 
.shife();头部元素移除
.splice();按切片的方式 移除元素/替换

var l1 =[11,22,33,44];
console.log(l1.push(55))  // 5 返回数组的元素个数

var l1 =[11,22,33,44];
console.log(l1.pop())  // 44 返回尾部弹出元素 

var l1 =[11,22,33,44];
console.log(l1.shift())  // 11 返回头部弹出元素 

var l1 = [11, 22, 33, 44];
console.log(l1.splice(0, 2))  // 11 22 返回被移除的元素
console.log(l1)  // [ 33, 44 ]
console.log(l1.splice())  // [] 什么都不做

var l1 = [11, 22, 33, 44];
console.log(l1.splice(0, 2, 55,66))  // 11 22 返回被替换的元素
console.log(l1)  // [ 55, 66, 33, 44 ]

3.排序

.reverse(); 反转
.sort();排序

var l1 = [1, 2, 3, 4, 5];
console.log(l1.reverse())  
// [ 5, 4, 3, 2, 1 ] 反转并返回反转后的值

var l1 = [2, 5, 1, 4, 3];
console.log(l1.sort())  // [ 1, 2, 3, 4, 5 ]  排序并返回排序后的值

4.拼接

.join();指定符号连接数组内的元素,结果字符串类型。
.concat();连接数组

var l1 = [1, 2, 3];
var s1
s1 = l1.join('|')

console.log(typeof s1, s1)  // string 1|2|3

var l1 = [1, 2, 3];
var l2 = [4, 5, 6]

console.log(l1.concat(l2))  //  [ 1, 2, 3, 4, 5, 6 ]  合并值并返回合并后的值

5.配合回调函数使用

.forEach()将数组每个元素传递给回调函数

.map()返回一个数组元素调用函数处理后的值的新数组

1.获取数组元素给回调函数传值

forEach()语法
forEach(function(currentValue, index, arr), thisValue)

参数	描述
function(currentValue, index, arr)	currentValue必需,当前元素. index可选,当前元素的索引值.arr可选,当前元素所属的数组对象.
thisValue	可选。传递给函数的值(操作的对象)。 如果这个参数为空， “undefined” 会传递给 “this” 值

var l1 = [1, 2, 3];

function f1(values) {
    console.log(values)
}

l1.forEach(f1)  // 将数组的每个元素依次做为参数传递给回调函数

var l1 = [1, 2, 3];

function f1(values, index) {
    console.log(index, values)
}

l1.forEach(f1)  // 将数组的每个元素,和元素的索引 依次做为参数传递给回调函数

var l1 = [1, 2, 3];

function f1(values, index, arr) {
    console.log(index, values, arr)
}

l1.forEach(f1)  // 将数组的每个元素,和元素的索引 数组本身 依次做为参数传递给回调函数

l1.map(function(value){return value * 2},l1);
(4) [2, 4, 6, 8]

2.映射

语法:
map(function(currentValue,index,arr), thisValue)

参数	描述
function(currentValue, index,arr)	currentValue必须,当前元素的值.index可选,当前元素的索引值,arr可选,当期元素属于的数组对象
thisValue	可选。操作的对象,作为该执行回调时使用，传递给函数。 如果省略了 thisValue ，“this” 的值为 “undefined”

var l1 = [1, 2, 3];

function f1(values, index, arr) {
    console.log(index, values, arr);
    return values + 1
}

console.log(l1.map(f1))  // 返回一个新的数组

13.自定义对象

自定义对象 
自定义对象用花括号括起来,元素是k:V键值对形式,元素之间用逗号隔开.
1. var obj = {键: 值, ...}
2. var obj = new Object()

var obj = {'k1': 'v1'}
console.log(typeof obj, obj)  // object { k1: 'v1' }

//  取值方式1
console.log(obj.k1)  // v1  对象.键 取值

// 取值方式2
console.log(obj['k1'])  // v1 对象[键] 取值

// 取值方式3

for (let i in obj){
    console.log(obj[i], i)  // v1 遍历字典的键  再 对象[键] 取值
}

var ll = new Object()
ll.name = 'kid'
ll['age'] = 18
console.log(ll)  // { name: 'kid', age: 18 }

14.运算符

14.1算数运算符

+ - * /  ** %  ++ --

console.log(1 + 1) // 2
console.log(0 - 1) // -1
console.log(1 * 1.0) // 1
console.log(1 / 1.0) // 1

console.log(2 ** 3) // 8
console.log(11 % 3) // 2

var x = 10;

var res1 = x++;  // 先赋值再自增
console.log(res1, x)  // 10 11

var res2 = ++x;  // 先自增再赋值
console.log(res2, x)  // 12 12

14.2比较运算符

> < == ===  != !== 

console.log(1 > 0) // true
console.log(1 < 0) // false

// 弱等于 内部自动转换成相同的类型进行比较。
console.log(1 == '1') // true
console.log(1 != '1') // false

// 强等于 内部不做类型转换。
console.log(1 === '1') // false
console.log(1 !== '1') // true

14.3逻辑运算符

&& || ！
与 或 非
需要住注意什么时候返回布尔值,什么时候返回数据。

console.log(5 && '5') // 5  第一个值为真,就显示第二个值。
console.log(0 && '5') // 0  第一个值为假,结果直接为假。(短路运算)

console.log(0 || 1) // 1
console.log(1 || 0) // 1

console.log(!true) // false
console.log(!false) // true

14.4赋值运算符号

= += -= *= /= %=

var num = 3
console.log(num += 3) // 6

var num = 3
console.log(num -= 3) // 0

var num = 3
console.log(num *= 3) // 9

var num = 3
console.log(num /= 3) // 1

var num = 3
console.log(num %= 3) // 0

15.流程控制

15.1if

if(条件){代码块};


if(条件){代码块}
else{代码块};


if(条件){代码块}
else if (条件){代码块}
else{代码块};

var age = 19
if (age >= 18) {
    console.log('成年了')
}  // 成年了

var age = 16

if (age >= 18) {
    console.log('成年了')
} else {
    console.log('未成年')
} // 未成年

var age = 17

if (age > 18) {
    console.log('成年了')
} else if (age > 16) {
    console.log('看情况培养')
}  //  看情况培养

else {
    console.log('未成年')
}

15.2switch

提现列举好可能出现的条件和解决方法。

switch(表达式){
	case 值1:
		语句体1;
        break;
    case 值2:
        语句体2;
        break;
    default:  // 以上都没有匹配到才执行
    	语句体;
}

每个case代码块中必须要用break
不加break,还会一直往下执行case的代码块,
而且不需要验证,别的代码块的break没法结束它的运行.

var num = 1;
switch (num) {
    case 0:
        console.log('x');
        break;  
    case 1:
        console.log('xx');
        break;
    case 2:
        console.log('xxx');
        break;
    default:  // 以上都没有匹配到才执行
        console.log('没有');
}

15.3for循环

for(条件) {代码块};

// 打印0-8
for (let i = 0; i < 9; i++)
{
	console.log(i)
}

// 不推荐这样写,因为let定义变量在一个外部的名称空间,不在for的名称空间
let i = 0;  
for (; i < 9; i++) {
    console.log(i)
}

// 循环打印出数组的每一个元素
var l1 = [1, 2, 3, 4, 5, 6];
x = l1.length;
for (let i = 0; i < x; i++) {
    console.log(l1[i])
}

15.4while循环

while(表达式){
	代码块;
}

// 打印0-8
var i = 0;

while (i < 9)
{
	console.log(i)
    i++;
}

15.4三元运算

var res = 条件1 > 条件2 ? 条件1成立的值:条件2成立的值;
条件成立,取问号后面的值,条件不成立取冒号后面的值。

var res = 1 > 2 ? 1 : 3;
console.log(res)  // 3

var res = 1 < 2 ? 1 : 3;
console.log(res)  // 1

16.函数

在js中定义函数需要function关键字。
function 函数名 (形参1····){ 代码块; return 返回值;};
先定义后调用。

16.1无参函数

function func1() {
    console.log('holle word');
}

func1();

16.2有参数函数

function func2(a, b) {
    console.log(a, b);
}

// 正常传值
func2(1, 2);  // 1 2


// 参数多了
func2(1, 2, 3);   // 1 2 多了的值不管


// 参数少了
func2(1);         // 1 undefined

16.3获取所有参数

argumens 获取函数内所有的参数

function func2(a, b) {
    console.log(arguments);
    // 数组对象 [Arguments] { '0': 1, '1': 2, '2': 3, '3': 4 }  不是自定义对象
    console.log(arguments[0], arguments[1]);  //  1 2
}

func2(1, 2, 3, 4)

如果参数传多了没有事,如果少了,可能出问题.
写一个函数来提醒.

// 参数判断
function Parameter(count, amount) {
    if (count > amount) {
        let multi = count - amount
        console.log(`参数多了${multi}个`);

    } else if (count < amount) {
        let less = amount - count
        console.log(`参数少了${less}个`);

    }
}

function f1(a, b){
    Parameter(arguments.length, 3)
}


f1(1, 2)  // 参数少了1个

f1()  // 参数少了3个

16.4返回值

关键字 return,如果返回多个值,就是最后那个值返回。
想要返回多个值,把它组织成一个容器类型的值.

function func1() {
    console.log('holle word');
    return 1, 2, 3;
}

res = func1();

console.log(res)  // 3 

function func1() {
    console.log('holle word');
    return [1, '字符串数据', '其他..']  // 先组成一个值,在取出来就可以了
}

res = func1();

console.log(res)  // 3

16.5匿名函数

var x = function (参数1,...){代码块; return 返回值;}

(function (){代码块; return 返回值;})

(function (形参1,...){代码块; return 返回值;})(实参1,...)

var x = function (a, b) {
    return a + b;
}

console.log(x(1, 2))

console.log((function (a, b) {
    return a + b;
})(1, 2))

16.6箭头函数

var 变量名 = (参数1,..) => 返回值

var func1 = v => v;    // 箭头左边的是形参,右边的返回值,
// 等价于
var func1 = function(v){return v;}

var func2 = (arg1,arg2) => arg1 +  arg2
// 等价于
var func2 (arg1,arg2)
{
    return arg1 + arg2
}

16.7全局变量和局部变量

局部变量：
在JavaScript函数内部声明的变量,使用let声明,
只能在函数内部访问它（该变量的作用域是函数内部）。
只要函数运行完毕，本地变量就会被删除。

全局变量：
在函数外声明的变量是全局变量,使用var申明,网页上的所有脚本和函数都能访问它。

变量生存周期：
JavaScript变量的生命期从它们被声明的时间开始。
局部变量会在函数运行以后被删除。
全局变量会在页面关闭后被删除。

作用域
首先在函数内部查找变量，找不到则到外层函数查找，逐步找到最外层。

16.8练习

1.查找顺序
先从函数自己找,再从外层函数,再从全局中查找,再去内置中找.

var city = "BeiJing";

function f() {
    var city = "ShangHai";

    function inner() {
        var city = "ShenZhen";  // 打印深圳
        console.log(city);
    }

    inner();
}

f();  //输出结果是？

2.函数定义阶段发送的事
函数的查找关系在定义阶段就确定了,与调用的位置无关.

var city = "BeiJing";

function Bar() {
    console.log(city);  // 打印北京
}

function f() {
    var city = "ShangHai";
    return Bar;
}

var ret = f();
ret();  // 打印结果是？

3.闭包函数,函数内部使用外层函数的名称.

var city = "BeiJing";

function f() {
    var city = "ShangHai";

    function inner() {
        console.log(city);  // 打印上海 
    }

    return inner;
}

var ret = f();
ret();

17.Date时间对象

Date 时间对象是内置对象.
定义时间对象需要加上关键字 new.

var 变量 = new Date(参数1,...)
* 获取当前时间. 这个时间固定了,之后使用方法都是基这个时间.
* 想要改变时间就要重新在声明.

17.1时间对象的定义

// 定义一个时间对象 获取的显示的时间
let d3 = new Date();

// 定义一个时间对象,定义值 方式2
let d4 = new Date('2020/01/01 11:11:11');
// 定义一个时间对象,定义值 方式2
let d5 = new Date(1111,11,11,11,11,11,11);

console.log(d3)  // 2022-02-20T12:28:59.557Z
console.log(d4)  // 2020-01-01T03:11:11.000Z
console.log(d5)  // 1111-12-11T03:05:28.011Z

17.2传值的区别

let d6 = new Date(1111,11,11,11,11,11,11);  //  月份从o开始的 0 -11月
console.log(d6.toLocaleString())  // "2020/1/1 上午11:11:11"

上面这种格式会月份会自动减1,所以传值要加月份的基础上加1.

// 错误的传值
let d7 = new Date('2020/00/01 11:11:11');   // 00月 不存在
console.log(d7)  // Invalid Date  失效日期

上面这个不直接月份是多少,就转换为多少,不用帮它做月份计算.

let d7 = new Date('2020/01/01 11:11:11');   // 1月
console.log(d7)  // 2020-01-01T03:11:11.000Z

17.3内置方法

toLocaleString  // 本地化时间 年月日 时分秒
toLocaleDateString()  // 本地化时间 年月日 
.getDate();     //  获取日（几月第几日）
.getDay();      //  获取星期 (从0开始 一个星期是从星期天开始)
.getMonth();    //  获取月份 （月份从 0 开始的 0 - 11月）
.getFullYear(); //  获取完整的年份
.getHours();    //  获取小时
.getMinutes();  //  获取分钟
.getSeconds();   //  获取秒
.getMilliseconds(); //  获取毫秒
.getTime();     //  获取时间戳

let d3 = new Date();
console.log(d3.toLocaleString())  // 2022/2/20 下午8:38:56  中国的标准时间
console.log(d3.toLocaleDateString())  // 2022/2/20

let d0 = new Date()
console.log(d0.getDate())  // 20
console.log(d0.getDay())  // 0
console.log(d0.getMonth())  // 1
console.log(d0.getFullYear())  // 2022
console.log(d0.getHours())  // 20
console.log(d0.getMinutes())  // 53
console.log(d0.getSeconds())  //  43
console.log(d0.getMilliseconds())   //  126
console.log(d0.getTime())  // 1645361623126

17.4练习

编写代码，将当前日期按“2022-1-27 11:01:01 星期三”格式输出。

2022-2-20 21:35:3 星期天 
                ↑默认是这样的前面没有0

// 定义一个数字与星期的对应关系对象的对象
const week_map = {
    0: '星期天',
    1: '星期一',
    2: '星期二',
    3: '星期三',
    4: '星期四',
    5: '星期五',
    6: '星期六',
}


function getTime() {
    // 定义一个时间对象
    var td = new Date()

    // 获取 年 月 日
    var year = td.getFullYear()
    var month = td.getMonth() + 1 // 月份是从0开始 所有的月份加1
    var date = td.getDate()

    // 获取时 间 分 秒
    var hour = td.getHours()   // 三元运算 值小于10 就 '0' + 值 
    var minutes = td.getMinutes() < 10 ? '0' + td.getMinutes() : td.getMinutes()
    var seconds = td.getSeconds() < 10 ? '0' + td.getSeconds() : td.getSeconds()

    // 获取星期几
    var week = week_map[td.getDay()]

    console.log(`${year}-${month}-${date} ${hour}:${minutes}:${seconds} ${week}`)
}

getTime()

18.JSON对象

序列化    JSON.stringify()
反序列化  JSON.parse()

var s1 = {'k1': 'v1', 'k2': 'v2'}

// 序列化
var json_str = JSON.stringify(s1)
console.log(json_str)  // {"k1":"v1","k2":"v2"}

// 反序列化
var s2 = JSON.parse(json_str)
console.log(s2)  // { k1: 'v1', k2: 'v2' }

19.ReGxp对象

 在js中使用正则表达式，需要创建正则对象。
 方式1:
 var 对象 = new RegExp('正则表达式')
 方式2:
 var 对象 = /'正则表达式'/

19.1定义对象

// 以字母开头 5~11 位                    逗号后面不要加空格
var reg1 = new RegExp('^[a-zA-Z][a-zA-Z0-9]{5,11}');
var reg2 = /^[a-zA-Z][a-zA-Z0-9]{5,11}/

19.2方法

.test(x)           // 测试匹配的字符串 返回值为布尔值
.match(/x/g);     // 查找字符串中 符合正则 的内容
.search(/x/g);  // 查找字符串中符合正则表达式的内容位置
.split(/x/g);   // 按照正则表达式对字符串进行切割
.replace(/x/g, "s");  // 对字符串按照正则进行替换
.replace(/x/gi, "s"); // 不区分大小写
* /g 全局匹配 /i 不区分大小写

1.匹配文本

var reg2 = /^[a-zA-Z][a-zA-Z0-9]{5,11}/

console.log(reg2.test('aaaaaa'))  // true

2.全局匹配

/* 获取字符中某个字符所有字母 */
vat sss = 'asasasdasdasda';
sss.math(/s/);     // 获取一个就停止
sss.match(/s/g)    // g 全局匹配

/* 获取字符中某个字符所有字母 */
var s1 = 'asasasdasdasda';


// 获取一个就停止
console.log(s1.match(/s/) )  //  [ 's', index: 1, input: 'asasasdasdasda', groups: undefined ]
// 全局匹配
console.log(s1.match(/s/g) )  //  [ 's', 's', 's', 's', 's' ]

3.练习

var s2 = "hello world";

console.log(s2.match(/o/g))
// ["o", "o"]   查找字符串中 符合正则 的内容 返回为数组


console.log(s2.search(/h/g))
// 0   查找字符串中符合正则表达式的内容位置找打一个就返回


console.log(s2.split(/o/g))
// ["hell", " w", "rld"]  按照正则表达式对字符串进行切割 返回为数组


console.log(s2.replace(/o/g, "s"))
// "hells wsrld"    对字符串按照正则进行替换

19.3吐槽点

在用js书写代码需要需要注意这些问题.
lastindex属性 与 匹配 空.

lastindex属性 查看正则匹配字符串中指针的位置.

let reg2 = /^[a-zA-Z][a-zA-Z0-9]{5,11}/g;

console.log(reg2.test('aaaaaaa'))  // true
console.log(reg2.lastIndex)  // 7


console.log(reg2.test('aaaaaaa'))  // false
console.log(reg2.lastIndex)  // 0

/* 在全局匹配，匹配第一个aaaaa，匹配成功在为真,
指针停止在最后一个a的位置后面， 下次匹配还是从这个位置开始匹配，a后面为空，所以为false
下次才会匹配才跳出上次匹配的语句,开始新的匹配,到匹配开头的位置*/

测试数据为 undefined 是测试为true
不给数据 的值默认就是 undefined

/* 案列是2020年的 在2021年测就不同了  */
let reg3 = /^[a-zA-Z][a-zA-Z0-9]{5,11}/;

console.log(reg3.test())  // true

console.log(reg3.test(undefined))  // true

let reg4 = /undefined/  
console.log(reg4.test())  // true

20.Math对象

Math对象收录一些数学相关的方法.

20.1常用方法

abs(x)      返回数的绝对值。
exp(x)      返回 e 的指数。
floor(x)    对数进行下舍入。
log(x)      返回数的自然对数（底为e）。
max(x,y)    返回 x 和 y 中的最高值。
min(x,y)    返回 x 和 y 中的最低值。
pow(x,y)    返回 x 的 y 次幂。
random()    返回 0 ~ 1 之间的随机数。
round(x)    把数四舍五入为最接近的整数。
sin(x)      返回数的正弦。
sqrt(x)     返回数的平方根。
tan(x)      返回角的正切。

console.log(Math.abs(-21))  // 21
console.log(Math.exp(-21))  // 7.582560427911907e-10