javascript学习笔记（-）-CSDN博客

本文链接：https://blog.csdn.net/qq_45922060/article/details/114275026

js代码从上到下一行一行的执行

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script>
        alert("梅西踢球真帅");
        document.write("你永不独行");//body里面输出一个内容
        console.log("安小鸟想要飞也飞不高");
    </script>
</head>
<body>
    
</body>
</html>

js的编写位置

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <!-- 
        可以将js代码编写到外部的js文件中，然后通过script标签引入
        写到外部文件中可以在不同的页面中同时引用，也可以利用浏览器的缓存机制
        推荐使用的方式
    -->

    <!-- 
        script标签一旦用于引入外部文件了，就不能在编写代码了，即使编写了浏览器也会忽略
        如果需要则可以在创建一个新的script标签用于编写内部代码
     -->
    <script type="text/javascript" src="js/script.js"></script>
    <script type="text/javascript">
        alert("我是内部的js代码")
    </script>

    <!-- 
        可以将js代码编写到script标签
        <script type="text/javascript">
            alert("我是script标签中的代码")
        </script> 
    -->
</head>
<body>
    <!-- 
        可以将js代码编写到标签的onclick属性中
        当我们点击按钮时，js代码才会执行

        虽然可以写在标签的属性中，但是他们属于结构与行为耦合，不方便维护，不推荐使用

    -->
    <button onclick="alert('你太用力了，要轻一点~');">点一点</button>
    <!-- 可以将js代码写在超链接的herf属性中,这样点击超链接是，会执行js代码 -->
    <a href="javascript:alert('让我们一起想一想');">跳起来</a>
    <!-- 空链接 -->
    <a href="javascript:;">动起来</a> 
    
</body>
</html>

js注释

 /*
 	多行注释
  */
  //单行注释
  js会忽略多空格和换行，可以利用空格和换行对代码进行格式化

变量标识符

在js中使用var关键字来声明一个变量
标识符：

 1. 标识符中可以含有数字、字母、下划线 、$
 2. 标识符不能以数字开头
 3. 标识符不能是ES中的关键字和保留字
 4. 标识符一般都采用驼峰命名法
 		首字母小写，每个单词开头大写，其余字母小写
 		helloWorld  xxxYyZzz
 
 js底层保存标识符时实际上是采用的Unicode编码
 所以理论上讲，所有的utf-8含有的内容都可以作为标识符

数据类型

六种数据类型
String 字符串
Number 数值
Boolean 布尔值
Null 空值
Undefined 未定义
Object 对象
前五个是基本数据类型
Object属于引用数据类型

字符串：

在字符串中可以使用\作为转义字符
\" 表示 "    \' 表示  '
\n换行    \t 制表符
\\表示\

数值：

js中所有的数值都是Number类型
包括整数和浮点数

表示数字的最大值： Number.MAX_VALUE
	1.7976931348623157e+308
	如果使用Number表示的数字超过了最大值，则会返回一个Infinity表示正无穷
	使用typeof检查Infinity也会返回Number
	
NaN是一个特殊的数字，表示Not A  Number
	使用typeof检查NaN也会返回Number

表示数字的最小值： Number.MIN_VALUE  (大于0的最小值)
	5e-324

在js中整数运算基本可以保证精确
浮点数运算可能得到一个不精确的结果

typeof

可以使用运算符typeof来检查一个变量的类型
语法：typeof 变量
例：
console.log(typeof a);

布尔值

boolean 布尔值
 	true  false
 	使用typeof检查布尔值会返回boolean

Null

Null类型只有一个值：null
null值专门用来表示一个为空的对象
使用typeof检查null值会返回Object

Undefined（未定义)

Undefined类型的值只有一个就是undefined
当声明一个变量，但是并不给变量赋值时3，他的值就是undefined

强制类型转换

将其他数据转换为String

	方式一：
		调用被转换数据类型的toString()方法
		var a = 123;
		var b = a.toString();
		该方法不会影响原变量，它会将转换的结果返回
		注意：null和undefined这两个值没有toString()方法
		
	方法二：
		调用String()函数，并将被转换的数据作为参数传递给函数
		var a = 231;
		a = String(a);
		使用String()函数做强制类型转换是，
			对于Number和Boolean实际上就是调用的toString()方法
			但是对于null和undefined，就不会调用toString（）方法
				它会将null直接转换为“null”
				将undefined直接转换为“undefined”

将其他数据转换为Number

方式一：
 	使用Number（）函数
 		字符串 --> 数字
 		 	var a= "123";
 			a = Number(a);
 			1、如果是纯数字的字符串，则直接将其转换为数字
 			2、如果字符串中有非数字的内容，则转换为NaN 
 			3、如果字符串是一个空串或者是一个全是空格的字符串，则转换为0
 			
 		布尔 --> 数字
 			true 转成 1
 			false 转成 0	

		Null --> 数字 0
		
		undefined --> 数字  NaN

方式二：
	这种方式专门用来对付字符串
	parseInt()把一个字符串转换为一个整数
	parseFloat（）把一个字符串转换为一个浮点数
	var  a = "123px";
	a = parseInt(a);
 	parseInt()可以将一个字符串中的有效的整数内容取出来
 	a = 12.345
 	a = parseInt(a)//12
 	
 	parseFloat()可以将一个字符串中的有效的小数内容取出来
 	
	如果对非String使用parseInt()或parseFloat()
	他会将其转换为String，然后在操作
 	a = true；
 	a = parseInt(a) // NaN

其他类型的数字

如果需要表示16进制的数字，则需要以0x开头
如果需要表示8进制的数字，则需要以0开头
如果需要表示2进制的数字，则需要以0b开头(但是不是所有浏览器都支持）
var a = 0xff;
console.log(a); //255

//像“070”这种字符串，有些浏览器会当成8进制解析，有些会当成10进制解析
a = "070"
//可以在parseInt（）中传递一个第二个参数，来指定数字的进制
a = parseInt(a,10);
console.log(typeof a);
console.log(a);

其他类型的转换为Boolean

使用Boolean函数()
	数字 ---> 布尔
		除了0和NaN是false,其余都是true
	字符串 ---> 布尔
		除了空串，其余都是true
	null和undefined 都会转换成 false
	对象也会转换为 true
var  a = 123;
a = -111; //true
a = Infinity;//true
a = NaN;//false
a = 0;//false
a = false;//true
a = Boolean(a);
console.log(a);//true

运算符

任何值和NaN运算都得NaN
+ 可以对字符串进行拼接，- 不能
b = 100-"1";//99

a="18"
a= +a;//typeof  a  ：number
可以对一个其他的数据类型使用+，来将其转换为Number
原理和Number（）函数一样

相等运算符
console.log(a == 4);//false
console.log("4" == 4);//true
console.log(true == "1");//true
console.log(nul == 0);//false

undefined 衍生自null 所以这两个值做相等判断时，会返回true
console.log(undefined == null);

NaN不和任何值相等，包括它本身
console.log(NaN == NaN);//false

判断一个之是否是NaN: isNaN()函数
是NaN返回true，否则返回false
var b = NaN;
console.log(isNaN(b));

===:全等
和==类型但是不会做自动的类型转换，类型不同返回false

!==不全等
和!=类型但是不会做自动的类型转换，类型不同返回true

Unicode编码

在字符串中使用转义字符输入Unicode编码
\u四位编码
console.log("\u2620");

在网页中使用Unicode编码   &#编码；这里的编码需要的是10进制
 <p style="font-size: 16;">&#9760;</p>

代码块

我们的程序是由一条条语句构成的
	语句是按照自上而下的顺序一条一条执行的
	在js中可以使用{}来为语句分组，
		同一个{}中的语句我们称为是一组语句
		他们要么都执行，要么都不执行
		一个{}中的语句我们也称为叫一个代码块
		在代码块后面就不用再写分号了
js中的代码块，只具有分组的作用，没有其他的用途
	代码块里面的内容在外部是完全可见的
	
    <script type="text/javascript">
        {
            var a = 10;
            alert("hello");
            console.log("您好");
            document.write("语句");
        }

        console.log("a="+a);

    </script>

分支与循环的练习

if练习

 <script type="text/javascript">
    //从键盘输入小明的期末成绩：
    //当成绩为100时：奖励一辆BMW
    //当成绩为80-99时：奖励一台iphone15s
    //当成绩为60-80时：奖励一本参考书
    //其他时，什么奖励也没有

    //prompt()可以弹出一个提示框，该提示框中会带有一个文本框

        var score = prompt("请输入小明的成绩（1~100）：");

        if(score > 100 || score < 0 || isNaN(score)){
            alert("您输入的数据不合理");
        }else {
            if(score == 100){
                alert("宝马拿走");
            }else if(score >= 80){
                alert("手机拿走");
            }else if(score >= 60){
                alert("参考书拿走");
            }else{
                alert("gun");
            }
        } 

    </script>

注：prompt()函数返回值时String类型
若要变成Number类型
var num = +prompt("请输入数字");

witch-case

<script type="text/javascript">
    //对于成绩大于60分的：输出合格，低于60分的：输出不合格
        var score = 60;

        // switch(parseInt(score/10)){
        //     case 10:
        //     case 9:
        //     case 8:
        //     case 7:
        //     case 6:
        //         console.log("合格");
        //         break;
        //     default:
        //         console.log("不合格");
        //         break;
        // }

        switch(true){
            case score >= 60:
                console.log("合格");
                break;
            default:
                console.log("不合格");
                break;
        }
    </script>

while练习

  while(true){
  	var score = prompt("请输入小明的成绩（1~100）：");
  	if(score >= 0 && score <= 100){
  		break;
  	}
  	alert("您输入的数据有误，请重新输入");
  }

  if(score == 100){
       alert("宝马拿走");
   }else if(score >= 80){
       alert("手机拿走");
   }else if(score >= 60){
       alert("参考书拿走");
   }else{
       alert("gun");
   }

for循环练习

//输出质数
    <script type="text/javascript">
        //console.time("计时器的名字")可以用来开启一个计时器
        //需要一个字符串作为参数，这个字符串作为计时器的标识
        console.time("test");
        // var num = prompt("请输入一个数：");
        for(var i = 2; i <= 10000; i++){
            var flag = true;
            for(var j = 2; j < Math.sqrt(i); j++){
                if(i % j == 0){
                    flag = false;
                    break;
                }
            }
            if(flag){
                console.log(i);
            }
            
        }
        //终止计时器
        //console.timeEnd()用来终止一个计时器，需要一个计时器的名字作为参数
        console.timeEnd("test");

    </script>

对象

对象的分类：
 	1、内建对象
 			由ES标准中定义的对象，在任何的ES的实现中都可以使用
 			比如：Math String Number Boolean Function Object
 	2、宿主对象
 			由js的运行环境提供的对象，目前来讲主要指由浏览器提供的对象
 			比如BOM DOM(console  document)
	3、自建对象
			有开发人员自己创建的对象

创建对象
var obj = new Object();
console.log(typeof obj);

添加属性
语法：对象.属性名 = 属性值;
obj.name = "梅西";
obj.gender = "男";
obj.age = 33;
console.log(obj);

读取对象中的属性
语法：对象.属性名
如果读取对象中没有的属性，不会报错会返回undefined
console.log(obj.name);
console.log(obj.hello);

修改对象属性
语法：对象.属性名 = 新值;
obj.name = "tom";

删除对象属性
语法： delete 对象.属性名;
delete obj.name;
console.log(obj.name);

对象的属性名可以是关键字，不强制遵守标识符规范：
obj.var = "hello";
console.log(var);

如果要使用特殊的属性名，不能采用.的方式来操作
语法：对象["属性名"] = 属性值;
obj(("123") = 789;
console.log(obj["123"]);

使用[]这种形式更加灵活
	在[]中可以直接传递一个变量，这样变量值是多少就会读取那个属性
obj["123"] = 789;
var n = "123";
console.log(obj[n]);

js对象的属性值，可以是任意的数据类型，甚至可以是一个对象
  var obj = new Object();
  var obj2 = new Object();
  obj2.name = "猪八戒";
  obj.test = obj2;
  obj.name = "孙悟空";
  console.log(obj);
  console.log(obj.test);
  console.log(obj.test.name);

in 运算符
通过该运算符可以检查一个对象中是否含有指定的属性
如果有则返回true，没有则返回fasle
语法：“属性” in 对象
console.log("test2" in obj);
console.log("test" in obj);
console.log("name" in obj);

js中的变量都是保存在栈内存中的，
	基本数据类型的值直接在栈内存中存储
	值与值之间是独立存在，修改一个变量不会影响其他的变量
     
     对象是保存到堆内存中的，每创建一个新的对象，就会在堆内存中开辟一个新的空间
     而变量保存的是对象的内存地址（对象的引用），如果两个变量保存的是同一个对象的引用，当一个通过一个变量修改属性时，另一个也会受到影响

使用对象字面量来创建一个对象
var obj = {};//var boj = new Object();
console.log(obj name);

使用对象字面量，可以在创建对象时，直接指定对象中的属性
语法：{属性名:属性值,属性名:属性值.....}
对象字面量的属性名可以加引号也可以不加，建议不加
如果使用一些特殊的名字，则必须加引号
属性名和属性值是一组一组的明值对构成
	明和值之间使用":"链接，多个名值对之间使用","隔开
	如果一个属性之后没有其他的属性了，就不要写","
var obj2 = {
	name:"猪八戒",
	age:28,
	gender:"男",
	test:{name:"沙和尚"}
	
};
console.log(obj2);

函数

创建一个函数对象
var fun = new Function("console.log('helloworld!')");
console.log(typeof fun);//返回function

调用函数语法：函数对象()
当调用函数时，函数中封装的代码会按照顺序执行
fun();

实际开发中:

使用函数声明来创建一个函数
语法：function 函数名([形参1,形参2...形参N]){
	 }
function fun2(){
    document.write("1");
    alert("2");
}
// console.log(fun2);
fun2();

使用函数表达式创建一个函数
语法：var 函数名 = function([形参1,形参2...形参N]){
	 }
var fun3 = function(){
	console.log("我是匿名函数中的封装的代码");
}
fun3();

定义一个用来求两个数和的函数
function sum(a,b){
	console.log(a+b);
}
//sum(1,3);
//sum(true,false);
调用函数时解析器不会检查实参的类型
所以要注意，是否可能会接收到非法的参数，如果可能则需要检查实参的类型
函数的实参可以是任意的数据类型 也可以是一个对象

调用函数时，解析器也不会检查实参的数量
多余实参不会被赋值
如果实参的数量小于形参的数量，则没有对应实参的形参将是undefined
sum(222,444,55,5,true);//666
sum(11)//NaN

返回值  return
在函数中return后的语句都不会执行
如果return语句后不跟任何值相当于返回一个undefined
如果函数中不写return 则也会返回undefined
alert()没有返回值,返回一个undefined
function sum(a,b,c){
	var d = a + b + c;
	return d;
}
var res = sum(4,5,6);
console.log(res);

实参是对象
var obj = {
   name:"孙悟空",
   age:77,
   gender:"男",
   address:"花果山"
};

function sayhello(o){
   // console.log("o="+o);
   console.log("我是"+o.name+"我住在"+o.address+"我"+o.age+"岁了");
}
sayhello(obj);
                
实参是函数
function hanshu(a){
    console.log("a="+a);
    a(obj);
}
hanshu(sayhello);
hanshu(function(){alert("hello")});  
 
mianji() 调用函数
			相当于使用的函数返回值
mianji 函数对象
			相当于使用函数对象
function mianji(r){
    return 3.14*r*r;
}     
function hanshu(a){
    console.log("a="+a);
    // a(obj);
}   
hanshu(mianji);
hanshu(mianji(10)); 

返回值可以是任意值可以是一个对象,也可以是函数
function fun2(){
	var obj = {name:"梅西"};
	return obj;
}  
var a = fun2();
console.log("a="+a.name);  

function fun3(){
    function fun4(){
        alert("我是fun4");
    }
    //fun4();//一
    //将fun4函数对象作为返回值返回
    return fun4;
}
//fun3();//一
//console.log(a);//打印fun4函数
//a();//调用fun4
fun3()();

立即执行函数
//调用匿名函数
//立即执行函数往往只会执行一次
(function(){
	alert("我是一个匿名函数");
})();
(function(a,b){
    console.log("a="+a);
    console.log("b="+b);
})(123,456);

对象的属性可以是任何的数据类型，也可以是个函数
var obj = new Object();
obj.name = "孙悟空";
obj.age = 99;
obj.sayName = function(){
    console.log(obj.name);
}
// console.log(obj.sayName);
//调方法
obj.sayName();
function fun(){
    console.log(obj.name);
}
//掉函数
fun();
/*
    函数也可以成为对象的属性
    如果一个函数作为一个对象的属性保存
    那么我们称这个函数是这个对象的方法
    调用这个函数就说调用对象的方法（method）
    但是它只是名称上的区别没有其他的区别

*/

var obj = {
    name:"猪八戒",
    age:18,
    sayName:function(){
        console.log("obj2.name");
    }
};
obj2.sayName();

枚举对象中的属性
for in 语句
语法： for(var 变量 in 对象){
	   }	   
var obj = {
    name:"猪八戒",
    age:18,
    gender:"男",
    address:"水帘洞"	
    
};
for (var n in obj) {
    console.log("属性名"+n);
    console.log("属性值："+obj[n]);

}

全局作用域

作用域
	1.全局作用域
		- 直接编写在script 标签中的js代码，都在全局作用域
		- 全局作用域在页面打开时创建，在页面关闭时销毁
		- 在全局作用域中有一个全局对象window
			它代表的时一个浏览器的窗口，它由浏览器创建我们可以直接使用
			console.log(window)
		在全局作用域中
			创建的变量都会作为window对象的属性保存
			var  a = 10;
			console.log(window.a);
			创建的函数都会作为window对象的方法
			function fun(){
				console.log("我是fun函数“);
			}		
			window.fun();
			window.alert("hello");
			
	
		变量的声明提前
			使用var关键字声明的变量，会在所以的代码执行之前被声明（但是不会赋值）
				但是如果声明变量时不使用var关键字，则变量不会被声明提前
			console.log("a ="+a);//undefined  没有var 报错
			var a = 123;
		
		函数的声明提前
			使用var关键字声明的变量，会在所有的代码执行之前被声明(但是不会赋值)
				它会在所有的代码执行之前就被创建，所以我们可以在函数声明前来调用函数。
			使用函数表达式创建的函数，不会被声明提前，所以不能在声明前调用
			//fun();
			fun2();//报错
			function fun(){
				console.log("我是一个fun函数”);
			}
			var fun2 = function(){
				console.log("我是fun2函数")；
			}
			
		- 全局作用域中的变量都是全局变量
			在页面的任意部分都可以访问
	
	2.函数作用域
		- 调用函数时创建函数作用域，函数执行完毕后，函数作用域销毁
		- 没调用一次函数就会创建一个新的函数作用域，他们直接相互独立
		- 在函数作用域中可以访问到全局作用域的变量
			在全局作用域中无法访问到函数作用域的变量
		- 当在函数作用域操作一个变量时，它会先在自身作用域中寻找，如果有就直接使用
			如果没有则向上一级作用域中寻找，直到找到全局作用域
			如果全局作用域中依然没有找到，则会报错referenceError
		- 在函数中要访问全局变量可以使用window对象
		- 在函数作用域中也有声明提前的特性。
			使用var关键字声明的变量，会在函数中所有的代码之前被声明		
			函数声明也会在所有的代码执行之前执行
			function fun(){
				fun2();
				console.log(a);//undefined
				var a = 35;
				function fun2(){
					alert("我是函数fun2");
				}
			}
			fun();
			
		- 在函数中，不使用var声明的变量都会称为全局变量
			var c = 33
			function fun(){
				console.log("c="+c);//33
				c = 10;
			}
			fun5()
			console.log("c="+c);//10
		- 定义形参相当于在函数作用域中声明了变量
			var e = 23;
			function fun(e){
				alert(e);//undefined
			}
			fun6();

debug

sources里面选择文件
在需要调试的某一行加点然后刷新
给变量添加监控 选择某一个变量 右键->add selected next to watch
单机step over next 即可进行调试

this

解析器在调用函数每次都会向函数内部传递进一个隐含的参数，
	这个隐含的参数是this  this指向的是一个对象
	这个对象我们称为函数执行的上下文对象
	根据函数的调用方式的不同，this会指向不同的对象
		1、以函数的形式调用。this永远都是window
		2、以方法的形式调用。this就是方法的那个对象
function fun(){
	console.log(this.name);
}
var name = "全局的name属性";
//以函数的形式调用
fun();//window
创建一个对象
var obj = {
	name:"孙悟空"，
	sayName:fun
};
var obj2= {
	name:"猪八戒"，
	sayName:fun
};
console.log(obj.sayName == fun);//true
//以方法的形式调用
obj.sayName();//object

使用工厂的方法创建对象

//创建一个对象
var obj = {
    name:"孙悟空",
    age:18,
    gneder:"男",
    sayName:function(){
        alert(this.name);
    }
};
//使用工厂方法创建对象
//通过该方法可以大批量创建对象
function createPerson(name, age, gender){
    //创建一个新的对象
    var obj = new Object();
    obj.name = name;
    obj.age = age;
    obj.gender = gender;
    obj.sayName = function(){
        alert(this.name);
    };

    //将新的对象返回
    return obj;
}
var obj2 = createPerson("猪八戒",28,"男");
var obj3 = createPerson("沙和尚","男"); 
console.log(obj2);
console.log(obj3);
obj3.sayName();

构造函数

创建一个构造函数，专门用来创建Person对象的
	构造函数就是一个普通的函数，创建方式和普通函数没有区别
	不同的是构造函数习惯上首字母大写

构造函数和普通函数的区别就是调用方式的不同
	普通函数就是直接调用，构造函数需要使用new关键字调用

构造函数的执行流程
	1.立刻创建一个新的对象
	2.将新建的对象设置为函数中的this，在构造函数中可以使用this来引用新建的对象
	3.逐行执行函数中的代码
	4.将新建的对象作为返回值返回
	
使用同一个构造函数创建的对象，我买称为一类对象，也将一个构造函数成为一个类
	我们将通过一个构造函数创建的对象，称为该类的实例
     function Person(){
         alert(this);//Object
     }
     var per = new Person();
     var per1 = Person();
     console.log(per);//Object
     console.log(per1);//undefined

      function Person(name, age, gender){
          this.name = name;
          this.age = age;
          this.gender = gender;
          this.sayName = function(){
              alert(this.name);
          };
      }

      function Dog(){

      }

      var per = new Person("诸葛亮",33,"男");
      var per1 = new Person("曹操",66,"男");
      var per2 = new Person("刘备",99,"男");

      var dog = new Dog();

       console.log(per);
       console.log(per1);
       console.log(per2);

       console.log(dog);

       使用instaceof 可以检查一个对象是否是一个类的实例
       语法：
       		对象 instanceof 构造函数
       console.log(per instanceof Person);
       console.log(per instanceof Object);
       所有的对象都是Object的后代

this的情况：
	1、当函数形式调用时，thi是window
	2、当以方法的形式调用时，谁调用方法this就是谁
	3、当以构造函数的形式调用时，this就是新创建的那个对象

-------------------------------------------------

创建一个Person构造函数
 	在Person构造函数中为每一个对象都添加了一个sayName方法
 		目前我们的方法是在构造函数内部创建的
 			也就是构造函数每执行一次就会创建一个新的方法
 				执行1000次就会创建1000个新的方法，而1000个方法都是一模一样的
 				这完全没有必要，完全可以使所以的对象共享同一个方法
         function Person(name, age, gender){
            this.name = name;
            this.age = age;
            this.gender = gender;

            this.sayName = function(){
                alert("hello大家好，我是："+this.name);
            }
        }
        var per = new Person("孙行者",1999,"男");
        var per1 = new Person("猪悟能",1999,"男");
        console.log(per.sayName());
        console.log(per.sayName == per1.sayName)//false;

改动：
        function Person(name, age, gender){
            this.name = name;
            this.age = age;
            this.gender = gender;

            this.sayName = fun;
        }
        //将sayName的方法在全局作用域中定义
        //将函数定义在全局作用域，污染了全局作用域的命名空间
        //而且定义在全局作用域也不安全
        function fun(){
                alert("hello大家好，我是："+this.name);
        }
        var per = new Person("孙行者",1999,"男");
        var per1 = new Person("猪悟能",1999,"男");
        console.log(per.sayName());
        console.log(per.sayName == per1.sayName)//true

prototype原型

我们所创建的每一个函数，解析器都会向函数中添加一个属性prototype
	这个属性对应着一个对象。这个对象就是我们所谓的原型对象
如果函数作为普通函数调用prototype没有任何作用
当函数以构造函数的形式调用时，它所创建的对象中都会有一个隐含属性
	指向该构造函数的原型对象，我们可以通过__proto__来访问该属性
原型对象就相当于一个公共的区域，所有同一个类的实例都可以访问到这个原型对象
	我们可以将对象中共有的内容，统一设置到原型对象中

当我们访问对象的一个属性或方法时，它会先在对象自身中寻找，如果有则直接使用，如果没有则会去原型对象中寻找，如果找到则直接使用
以后我们创建构造函数时，可以将这些对象共有的属性和方法，统一添加到构造函数的原型对象中
	这样不用分别为每一个对象添加，也不会影响到全局作用域，就可以使每个对象都具有这些方法和属性了

function Person(){
}
function MyClass(){
}
console.log(MyClass.prototype == Person.prototype);//false
------------------------------------------------------------
 function MyClass(){

}
//向MyClass的原型中添加属性a
MyClass.prototype.a = 123;

//向MyClass的原型中添加一个方法
MyClass.prototype.sayHello = function(){
    alert("hello");
}
var mc = new MyClass();
var mc2 = new MyClass();

console.log(mc2.__proto__ == MyClass.prototype);//true
console.log(mc.a);//123

mc.a = "我是mc中的a";
console.log(mc.a);

mc.sayHello();

在这里插入图片描述

原型对象也是对象，所以它也有原型，
	当我们使用一个对象的属性或方法时，会先在自身中寻找，
		自身中如果有，则直接使用，
		如果没有则去原型对象中寻找，如果原型对象中有，则使用，
		如果没有则去原型的原型中寻找，直到找到Object对象的原型，
		Object的对象没有原型，如果在Object中依然没有找到，则返回undefined
-----------------------
        function MyClass(){

        }
        //向MyClass的原型中添加一个name属性
        MyClass.prototype.name = "我是原型中的名字";

        var mc = new MyClass();
        mc.age = 18;

        console.log(mc.name);

        //使用in检查对象中是否含有某个属性时，如果对心中没有但是原型中有，也会返回true
        //console.log("name" in mc);

        //可以使用对象的hasOwnProperty()来检查对象自身中是否含有该属性
        //使用该方法只有当自身中含有属性时，才会返回true
        console.log(mc.hasOwnProperty("age"));

        console.log(mc.hasOwnProperty("hasOwnProperty"));//fasle

        console.log(mc.__proto__.hasOwnProperty("hasOwnProperty"));//false
        console.log(mc.__proto__.__proto__.hasOwnProperty("hasOwnProperty"));//true
        console.log(mc.__proto__.__proto__);
        console.log(mc.__proto__.__proto__.__proto__);//null

在这里插入图片描述

toString

 function Person(name, age, gender){
     this.name = name;
     this.age = age;
     this.gender = gender;
 }
 //创建Person原型的toString
 Person.prototype.toString = function(){
     return "Person[name="+this.name+",age="+this.age+",gender="+this.gender+"]";
 }
 //创建一个Person实例
 var per  = new Person("孙悟空",18,"男");
 var per2  = new Person("安小鸟",48,"女");
 //当我们直接在页面中打印一个对象时，事件上是输出的对象的toString()方法的返回值
 //如果我们希望在输出对象时不输出[Object Object],可以为对象添加一个toString()方法

 // per.toString = function(){
 //     return "我是一只小小小鸟";
 // };
 var result = per.toString();
 // console.log("result="+result);
 // console.log(per.__proto__.__proto__.hasOwnProperty("toString"))
 console.log(per.toString());
 console.log(per2.toString());

垃圾回收机制

- 当一个对象没有任何的变量或属性对它进行引用，此时我们将永远无法操作该对象
	此时这种对象就是一个垃圾，这种对象过多会占用大量的内存空间，导致程序运行变慢，所以这种垃圾必须进行清理
- 在js中拥有自动的垃圾回收机制，会自动将这些垃圾对象从内存中销毁。
	我们不需要也不能进行垃圾回收的操作
- 我们需要做的只是要将不再使用的对象设置null即可

数组

        //创建数组对象
        var arr = new Array();

        //使用typeof 检查一个数组时会返回object
        // console.log(typeof arr);
        
        //向数组中添加元素
        //语法： 数组[索引] = 值
        arr[0] = 10;
        arr[1] = 8;
        // arr[5] = 5;

        console.log(arr);

        //读取数组中的元素
        //语法：数组[索引]
        //如果读取不存在的索引，不会报错而是返回undefined

        console.log(arr[2]);        
        
        //获取数组长度
        //语法：数组.length
        //对于非连续的数组，使用length会获取到数组的最大的索引+1
        //尽量不要创建非连续性数组
        console.log(arr.length);

        // 修改length
        //如果修改的length大于原长度，则多出部分会空出来
        //如果修改的length小于原长度，则多出的部分会被删除
        arr.length = 10;

        //像数组的最后一个位置添加元素
        //语法：数组[数组.length] = 值;
        arr[arr.length] = 70;
        console.log(arr);

数组字面量

        //使用字面量来创建数组
        //语法：[]
        var arr = [];
        console.log(typeof arr);
        
        //使用字面量创建数组时，可以在创建时就指定数组中的元素
        var arr = [1,22,33,5];

        //使用构造函数创建数组时，可以同时添加元素
        var arr2 = new Array(10,20,30);
        console.log(arr2);

        //创建一个数组中只有一个元素10
        arr = [10];

        //创建一个长度为10的数组
        arr2 = new Array(10);
        console.log(arr2.length);

        //数组中的元素可以是任意的数据类型
        arr = ["hello",1,true,null,undefined];

        //也可以是对象
        var obj = {name:"孙悟空"};
        arr[arr.length] = obj;

        console.log(arr[5].name);

        arr = [{name:"刘备"},{name:"张飞"},{name:"关羽"}];
        console.log(arr);

        //也可以是一个函数
        arr = [function(){alert(1)},function(){alert(2)}];
        console.log(arr);
        //调用
        arr[0]();

        //也可以是一个数组，如下称为二维数组
        arr = [[1,2,3],[4,5,6],[7,8,9]];
        console.log(arr[1]);

数组方法

 //创建一个数组
 var arr = ["孙悟空","猪八戒","沙和尚"];
 /*
     push()
         该方法可以像数组的末尾添加一个或多个元素，并返回数组的新的长度
         可以将要添加的元素作为方法的参数传递
         该方法会将数组新的长度作为返回值返回
 */
 var res = arr.push("李白","猴子","赵云");
 console.log(arr);
 // console.log("res="+res);//6

 /* 
     pop()
     该方法可以删除数组的最后一个元素，并将删除的元素作为返回值返回
 
 */
 res = arr.pop();
 console.log(arr);
 console.log("res="+res);

 /* 
     unshift()
     像数组开头添加一个或多个元素，并返回新的数组长度
     向前边插入元素以后，其他的元素索引会依次调整
 */
 arr.unshift("牛魔","小明");
 console.log(arr);

 /* 
     shift()
     可以删除数组的第一个元素，并将被删除的元素作为返回值返回

 */
 res = arr.shift();
 console.log(arr);
 console.log("res="+res);

数组练习

function Person(name, age){
     this.name = name;
     this.age = age;
     
 }
 Person.prototype.toString = function(){
     return "Person[name="+this.name+"age="+this.age+"]";
 }
 var p = new Person("李白",67);
 var p1 = new Person("韩信",87);
 var p2 = new Person("赵云",77);

 var arr = [p,p1,p2];
 function getAdult(arr){
     var newArr = [];
     for(var i = 0; i < arr.length; i++){
         if(arr[i].age>78){
             newArr.push(arr[i]);
         }
     }
     return newArr;
 }
 var res = getAdult(arr);
 console.log(res);

数组的遍历

/* 
    ForEach() 
    - 像这种函数，由我们创建但是不由我们调用，我们称为回调函数
    - 数组中有几个元素函数就会执行几次，每次执行时，
        浏览器会将遍历到的元素以实参的形式传递进来，我们可以来定义形参，来读取这些内容

    - 浏览器会在回调函数中传第三个参数
        第一个参数，就是当前正在遍历的元素
        第二个参数，就是当前正在遍历的元素的索引
        第三个参数，就是正在遍历的数组

*/
var arr = ["李白","貂蝉","韩信"];
arr.forEach(function(value, idnex, obj){
    console.log(value);
});

slice 和 splice

var arr = ["孙悟空","猪八戒","小白龙","哪吒"]
/* 
    slice()
    -
    \
*/
var res = arr.slice(0,2);
console.log(res);
console.log(arr);

/* 
    splice()
    - 可以用于删除数组中的指定元素
    - 使用splice()会影响到原数组，会将指定元素从原数组中删除
        并将删除的元素作为返回值
    - 参数
        第一个 表示开始位置的索引
        第二个 表示删除的数量
        第三个及 可以传递一些新的元素，这些元素将会自动插入到开始位置索引前边
*/
arr = ["孙悟空","猪八戒","小白龙","哪吒"]
// var result = arr.splice(1,2);//splice(1,0) 表示一个都没删
// var result = arr.splice(1,1,"李白","庄周");
var result = arr.splice(1,0,"李白","庄周");

console.log(arr);
console.log(result);

数组去重练习

var arr = [1,4,5,5,4,3,2,2];
for(var i = 0; i < arr.length; i++){
    for(var j = i+1; j < arr.length; j++){
        if(arr[i] == arr[j]){
            arr.splice(j,1);
            //当删除了当前j所在的元素以后，后面的元素会自动补位
            //此时将不会再比较这个元素，我需要再比较一次j所在位置的元素
            j--;
        }
        
    }
}
console.log(arr);

数组中的一些方法

var arr = ["李白","露娜","韩信","百里"];
var arr1 = ["鲁班","刘备","虞姬"];
/* 
    concat() 连接两个或多个数据
    该方法不会对原数组产生影响

*/
var res = arr.concat(arr1,"庄周","鲁班");


/* 
    jion()
    - 该方法可以将数据转换为一个字符串
    - 该方法不会对原数组产生影响，而是将转换后的字符串作为结果返回
    - 在join()中可以指定一个字符串作为参数，这个字符串将会称为数组中元素的连接符
        如果不指定连接符，则默认使用","作为连接符
*/
res = arr.join("+");    

/* 
    reverse()
    该方法用来反转数组
    会直接修改原数组
*/
arr.reverse();
console.log(arr);
console.log(res);

/* 
    sort()
    可以用来对数组进行排序
    也会影响原数组 默认会按照Unicode编码进行排序
    对数字排序时可能会得到错误的结果
*/
var sarr = [7,4,3,6,11];
//    sarr.sort();
/*      
    可以自己来指定排序规则
    在sort()添加一个回调函数来指定排序规则
    回调函数中定义两个形参
    浏览器将会分别使用数组中的两个元素作为实参去调回调函数
        使用哪个元素不确定，但是肯定的是在数组中a一定在b前边
    浏览器会根据回调函数的返回值来决定元素的顺序
        返回值大于0,则元素交换位置
        返回值小于0，则元素位置不变
        返回一个0，则认为两个元素相等不交换位置
 */

sarr.sort(function(a,b){
/*             
    if(a > b){
        return 1;
    }else if(a < b){
        return -1;
    }else{
        return 0;
    }
*/
    //升序
    // return a - b;
    //降序
    return b - a;
});


console.log(sarr);

call()和apply()

function fun(){
    // alert("我是fun函数");
    alert(this);
}
/* 
    call()和apply()
    - 这两个方法都是函数对象方法，需要通过函数对象来调用
    - 当函数调用call()和apply()都会调用函数执行
    - 在diaoyongcall()和apply()可以将一个对象指定为第一个参数
        此时这个对象将成为函数执行时的this
*/
var obj = {
   
};
// fun.call();
fun();//window
fun.call(obj);//object
----------------------------------
function fun(){
       alert(this.name);
   }
   /* 
       call()和apply()
       - 这两个方法都是函数对象方法，需要通过函数对象来调用
       - 当函数调用call()和apply()都会调用函数执行
       - 在调用call()和apply()可以将一个对象指定为第一个参数
           此时这个对象将成为函数执行时的this
       - call()方法可以将实参在对象之后依次传递
       - apply()方法需要将实参封装到一个数组中统一传递
   */
   var obj = {
       name:"obj",
       sayName:function(){
           alert(this.name);
       }
   };
   var obj2 = {name:"obj2"};

   obj.sayName();//obj
   obj.sayName.apply(obj2);//obj2
--------------------
function fun(a,b){
           console.log("a=" + a);
           console.log("b=" + b);
       }
       var obj = {
           name:"obj",
           sayName:function(){
               alert(this.name);
           }
       };
       // fun.call(obj);//a=undefined b=undefined
       fun.call(obj,2,3);
       fun.apply(obj,[2,3]);
       
       
     总结this情况：
            1.以函数形式调用时，this永远都是window
            2.以方法的方式调用时，this是调用方法的对象
            3.以构造函数的形式调用时，this是新创建的那个对象
            4.使用call和apply方法时，this是指定的那个对象

arguments

/* 
    在调用函数时，浏览器每次都会传递两个隐含的参数
        1.函数的上下文对象this
        2.封装实参的对象arguments
            - arguments是一个类数组对象，他可以通过索引来操作数据，也可以获取长度
            - 在调用函数时，我们所传递的实参都会封装到arguments中保存
            - arguments.length 可以用来获取实参的个数
            - 我们即使不定义形参，也可以通过arguments来使用实参
                arguments[0] 表示第一个实参
                arguments[1] 表示第二个实参
            - 它里面有一个属性叫做callee
                这个属性对应一个函数对象，就是当前正在指向的函数的对象

*/
function fun(){
   //类数组对象不是对象
//    console.log(arguments instanceof Array);//false
//    console.log(Array.isArray(arguments));//false
console.log(arguments.length);
console.log(arguments[0]);
console.log(arguments.callee);
console.log(arguments.callee == fun);
   
}
fun("李白","猴子","露娜");

Date

 /* 
     Date对象
         - 在js中使用Date对象来表示一个时间
 
 */
 //创建一个Date对象
 //如果直接使用构造函数创建一个Date对象，则会封装文件当前代码执行的时间
 var d = new Date();
 //创建一个指定的时间
 //需要在构造函数中传递一个表示时间段字符串作为参数
 //日期的格式 月份/日/年 时:分:秒
 var d2 = new Date("12/21/2021 12:10:40");
 console.log(d2);

 /* 
     getDate()
     获取当前日期对象时几日
 */
 var date = d2.getDate();
 console.log("date="+date);

 /* 
     getDay()
     获取当前日期对象是周几
     会返回一个0-6的值
         0表示周日

 */
 var day = d.getDay();
 console.log("day="+day);

 /* 
     getMonth()
     获取当前时间对象的月份
     会返回一个0-1的值
         0表示1月
         ....
         11表示12月

 */
 var month = d2.getMonth();

 /* 
     getFullyear()
     获取当前日期对象的年份

 */
 var year = d2.getFullYear();

 /* 
     getTime()
         获取当前日期对象的时间戳
         时间戳 指的是从格林威治标准时间的1970年1月1日，0时0分0秒
             到当前日期所花费的毫秒数
         计算机底层在保存时间时使用的都是时间戳

 */
 var time = d2.getTime();
 console.log(time/1000/60/60/24/365);

 var d3 = new Date("1/1/1970 0:0:0");
 time = d3.getTime();
 console.log(time);//北京时间差了8个时区

 var start = Date.now();//获取当前的时间戳

 //可以利用时间戳来测试代码执行的性能
 for(var i = 0; i<100; i++){
     console.log(i);
 }
 var end = Date.now();
 console.log("执行了："+(end-start)+"毫秒");

Math

/* 
     Math
         - Math和其他的对象不同，它不是一个函数
             它属于一个工具类不用创建对象，它里边封装了数学运算相关的属性和方法

 */
 /* 
     abs()可以用来计算一个数的绝对值
 */
 console.log(Math.abs(-1));

 /* 
     Math.ceil()
         可以对一个数进行向上取整，小数位只要有值就自动进1
     Math.floor()
         可以对一个数进行向下取整，小数部分会被舍掉
     Math.round()
         可以对一个数进行四舍五入取整
 */
 console.log(Math.ceil(1.4));
 console.log(Math.floor(1.99));
 console.log(Math.round(1.5));

 /* 
     Math.random()
     可以用来生成一个0-1之间的随机数(开区间)
     生成一个0-x的随机数
         Math.round(Math.random()*x)
     生成一个x-y之间的随机数
         Math.round(Math.random()*(y-x)+x)

 */
//生成一个0-10的随机数(闭区间)
 console.log(Math.round(Math.random()*10));
 // 生成一个1-10的随机数
 console.log(Math.round(Math.random()*9)+1)

 /* 
     max() 可以获取多个数中的最大值
     min() 可以获取多个数中的最小值
 */
 var max = Math.max(10,20,30);
 var min = Math.min(10,38.99);
 console.log(min);

 /* 
     Math.pow(x,y)
     返回x的y次幂
     Math.sqrt()
     用于对一个数进行开方运算
 */
 console.log(Math.pow(12,3));
 console.log(Math.sqrt(4));

包装类

/* 
基本数据类型
String Number Boolean Null Undefined
引用数据类型
Object

在js中为我们提供了包装类，通过这三个包装类可以将基本数据转换为对象
String()
    可以将基本数据类型字符串转换为String对象
Number()
    可以将基本数据类型数字转换为Number对象
Boolean()
    可以将基本数据类型的布尔值转换为Boolean对象

但是注意：我们在实际应用中不会使用基本数据类型的对象
如果使用基本数据类型对象再做一些比较时可能会带来一些不可预期的结果
    
*/
//创建一个Number类型的对象
//num = 3
var num = new Number(3);
console.log(typeof num);
var bool = new Boolean(true);


//向num添加一个属性
num.hello = "abc";
console.log(num.hello);

var b = new Boolean(false);
/*         if(b){
alert("我运行了");//会进行自动类型转换，对象转换为布尔值时true
}
*/
/* 
方法和属性中能添加给对象，不能添加给基本数据类型
当我们对一些基本数据类型的值去调用属性和方法时
    浏览器会临时使用包装类将其转换为对象，然后在调用对象的属性和方法
    调用完以后，在将其转换为基本数据类型
*/
var s = 123;
s = s.toString();
console.log(typeof s);

s.hello = "你好";
console.log(s.hello);//undefined 进行了两次转换

String方法

var str = "hello";
/* 
    在底层字符串是以数组的形式保存的
    ["h","e","l","l","o"]
*/

/* 
    charAt();
    可以返回字符串中指定位置的字符

*/
var res = str.charAt(0);
console.log(res);

/* 
    charCodeAt()
    获取指定位置字符的字符编码(Unicode)
*/

res = str.charCodeAt(0);
console.log(res);

/* 
    String.formCharCode()
    可以根据字符编码去获取字符
*/
res = String.fromCharCode(72);
console.log(res);
/* 
    concat()
    可以用来连接字符串
    作用和"+"一样
*/
res = str.concat("你好");
console.log(res);

/* 
    indexof()
        检索一个字符串中是否含有指定内容
        如果字符串中含有该内容则会返回第一次出现的索引
        如果没有找到指定内容则返回-1
        可以指定第二个参数，指定开始查找的位置
    lastindexof()
        用法和indexof一样
        不同的是indexof从前往后找
        lastindexof是从后往前找
        也可以指定第二个参数，指定开始查找的位置
    
*/
str = "hello wohrld"
res = str.indexOf("h")
res = str.lastIndexOf("h",5);
console.log(res);

/* 
    slice()
    - 可以截取指定的内容
    - 该方法不会影响原字符串，而是将截取到的元素返回
    - 参数
        1.截取开始的位置的索引
        2.截取结束的位置的索引
            第二个参数可以省略不写，此时会截取从开始索引往后的所有元素
        3.左闭右开
        4.索引可以传递一个负值，如果传递一个负值则从后往前计算
            -1：倒数第一个   -2：倒数第二个

*/
str = "ddasfhdfc"
res = str.slice(0,2);

/* 
    substring()
    - 可以用来截取一个字符串，和slice()类似
    - 参数
        1.截取开始的位置的索引
        2.截取结束的位置的索引
            第二个参数可以省略不写，此时会截取从开始索引往后的所有元素
        3.左闭右开
        4.不同的是这个方法不能接受负值作为参数
            如果传递了一个负值则默认使用0
            而且他还自动调整参数的位置，如果第二个参数小于第一个则自动交换
*/
res = str.substring(1,-1);
console.log(res);

/* 
    substr()
    - 用来截取字符串
    - 参数
        1.截取开始位置的索引
        2.截取的长度

*/
res = str.substr(3,2);
console.log(res);

/* 
    split()
    - 可以将一个字符串拆分为一个数组
    - 参数
        - 需要一个字符串作为参数，将会根据该字符串去拆分数组
*/
str = "ab,cd,ef,gh";
res = str.split(",");
console.log(res);

/*      
    toUpperCase()
        将一个字符串转换为大写字母并返回
    toLowerCase()
        将一个字符串转换为小写字母并返回
 */

正则表达式

	/* 
	   创建正则表达式
	   语法：
	       var 变量 = new RegExp("正则表达式","匹配模式");
	       使用typeof检查正则对象，会返回object
	       这个正则表达式可以检查一个字符串中是否含有a
	   在构造函数中可以传递一个匹配模式作为第二个参数
	       可以是
	           i 忽略大小写
	           g 全局匹配模式
	*/
	var reg = new RegExp("a");
	var str = "a";
	/* 
	   正则表达式的方法：
	       test()
	       - 使用这个方法可以用来检查一个字符串是否符合正则表达式的规则
	           如果符合则返回true 否则返回false
	
	*/
	var res = reg.test(str);
	console.log(res);
	
	/* 
	   使用字面量来创建正则表达式
	       语法： var 变量 = /正则表达式/匹配模式
	
	*/
	reg = /a/i;
	console.log(reg.test("abc"));
	
	// 创建一个正则表达式，检查一个字符串是否有a或b 
	reg = /a|b/
	console.log(reg.test("bdd"));
	
	/* 
	   []里的内容也是或的关系
	   [ab] == a|b
	   [a-z] 任意小写字母
	   [A-Z] 任意大写字母
	   [A-z] 任意字母
	   [0-9] 任意数字
	*/
	
	reg = /[A-z]/;
	console.log(reg.test("c"));
	
	//检查一个字符串中是否含有abc或adc或aec
	reg = /a[bde]c/;
	
	//[^ ]除了
	reg = /[^ab]/;//除了ab以外的

字符串和正则表达式

var str = "1h2fc9j4f9e";

 /* 
     split()
         可以将一个字符串拆分为一个数组
         方法中可以传递一个正则表达式作为参数，
             这样方法将会根据正则表达式去拆分字符串
         这个方法即使不指定全局匹配，也会全都拆分

 */
 //根据任意字母将字符串拆分
 var res = str.split(/[A-z]/);
 

 /* 
     search()
         可以搜索字符串中是否含有指定的内容
         如果搜索到指定内容，则会返回第一个出现的索引，如果没有搜索到返回-1
         它可以接受一个正则表达式作为参数，然后根据正则表达式去检索字符串
         只会查找第一个，即使设置全局匹配也没用
 */
 
 str = "hello abc aec afc";
 res = str.search(/a[bef]c/);

 /* 
     match()
         可以根据正则表达式，从一个字符串中将符合条件的内容提取出来
         默认情况下我们的match只会找到第一个符合要求的内容找到以后就停止检索
             我们可以设置正则表达式为全局模式，这样就会匹配到所有的内容
             可以为一个正则表达式设置多个匹配模式，且顺序无所谓
         mathch()会将匹配到的内容封装到一个数组中返回，即使只查询到一个结果
 */

 str = "1h2fc9j4f9e10K11P";
 res = str.match(/[a-z]/gi)
 console.log(Array.isArray(res));//true
 console.log(res);

 /* 
     replace()
         可以将字符串中指定内容替换为新的内容
         参数
             1.被替换的内容 2.新的内容
         默认只会替换第一个
 */
 res = str.replace(/[a-z]/gi,"");
 console.log(res);
 ------------------------
//创建一个正则表达式检查一个字符串中是否含有aaa
/* 
   量词
   - 通过量词可以设置一个内容出现的次数
   - 量词只对它前边一个内容起作用
   - {n} 正好出现n次
   - {m,n} 出现m~n次
   - {m,} m次以上
   - + 至少一个，相当于{1}
   - * 0给或多个，相当于{0,}
   - ? 0个或1个，相当于{0,1}
*/
var reg = /a{3}/;
reg = /(ab){3}/;
console.log(reg.test("ababab"));

/* 
   检查一个字符串中是否以a开头
   ^ 表示开头
   $ 表示结尾
*/
reg = /^a/;//匹配开头的a
reg = /a$/;//匹配结尾的a
console.log(reg.test("dacc"));

//如果在正则表达式中同时使用^$则要求字符串必须完全符合正则表达式
reg = /^a$/;//只匹配一个a
reg = /^a|a$/;//以a开头或者以a结尾

/* 
   创建一个正则表达式，用来检查一个字符串是否是一个合法的手机号

   手机号的规则：
   1 3 567894899

   1.以1开头
   2.第二位3-9任意数字
   3.三位以后任意数字9个

   ^1 [3-9] [0-9]{9}$

*/
var phoneStr = "13567894899";
var phoneReg = /^1[3-9][0-9]{9}$/;
console.log(phoneReg.test(phoneStr));
------------------------------------
/* 
    检查一个字符串是否含有.
    .表示任意字符
    在正则表达式中使用\作为转义字符
    \. 来表示.
    \\ 来表示\

    注意：使用构造函数时，由于它的参数是一个字符串，而\是字符串中转义字符
        如果要使用\则需要使用\\来代替

*/
var reg = /\./;

reg = /\\/;

reg = new RegExp("\\.");

console.log(reg.test("b.\\"));
console.log("b.\\");/	/b.\

/* 
    \w
        任意数字、字母、下划线  [A-z0-9_]
    \W
        除了字母、数字、下划线  [^A-z0-9_]
    \d
        任意数字[0-9]
    \D
        除了数字[^0-9]
    \s
        空格
    \S
        除了空格
    \b
        单词边界
    \B
        除了单词边界

*/
//创建一个正则表达式检查一个字符串中是否含有单词child
reg = /\bchild\b/;
console.log(reg.test("hello children"));

var str = "       james smith       "
//去除字符串前后的空格
//去除空格就是使用""来代替空格
// str = str.replace(/\s/g,"");

//去除开头的空格
// str = str.replace(/^\s*/,"");
//去除结尾的空格
// str = str.replace(/\s$/,"");

str = str.replace(/^\s*|\s*$/g,"")//去除开头结尾的空格
console.log(str);

邮件的正则

/* 
     电子邮件

     任意字母数字下划线 .任意字母数字下划线 @ 任意字母数字 .任意字母(2-5位) .任意字母(2-5位)
     \w{3,} (\.\w+)* @ [A-z0-9]+ (\.[A-z]{2,5}){1,2}
 
 */
 var emailReg = /^\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}$/;

 var email = "abc@abc.com";

 console.log(emailReg.test(email));