js基础知识点和内置对象及方法

js基础知识点和内置对象及方法

常量：
		 基本数据类型：
  			Java中：
  					整型：byte short int long
  					浮点型：float double
  					布尔型：boolean
  					字符型：char
  			js原始数据类型:
  					number：数字类型，包含整数和小数和 NaN(not a number)
  					string: 字符串和字符类型	""  ''
  					boolean: true 和 false
  					null： 空类型。对象的占位符
  					undefined：未定义,如果一个变量没有初始化值，默认为undefined
变量：
			语法：
				 使用 var定义变量  var i = "abc";
				 js是一门弱类型语言：定义变量时，不需要规定其数据类型。
				 typeof运算符：获取变量的数据类型
				 var关键字如果不书写，该变量则为全局变量
		
			语句：
					if
					switch
					while
					do...while
					for			
运算符:自动类型转换
			一元运算符
				++ --  +(正) -(负)
	注意：在js中，如果传递给运算符的值，和运算符想要接受的值的类型不匹配，则会自动类型转换.
	
			其他类型转为number
				string：将字符串的字面值，转为number，如果字面值不是数字，则转为NaN
				boolean： true为1 false 为0
			比较运算符
				> < >= <=: 
				NaN参与的运算，结果都为fasle，除了(!=)
				字符串比较小大：如果长度一致按照字典顺序比较  长度不一致 那谁的长度长那就谁大
				!=:
				== ===(全等于):
					全等于比较时，先比较类型，如果类型不一致，直接返回false
			
			逻辑运算符
				&& || !
					其他类型转boolean
						number：非0为true，0和NaN为false，
						string: 除了空字符串("")，其他都是true
						null 和 undefined:转为false
						对象:所有对象都为true
			
			算术运算符：
				+ - * / %
				注意:NaN 参与数学运算 结果都为NaN

			赋值运算符
				= += ....
			
			三元运算符
				表达式 ? 值1 : 值2; 
				
对象：
			js是一门基于对象的语言
			基于对象：不能由原生的对象派生出新的对象。换句话说，不存在继承关系
			Function(*****): 代表函数
					创建方式：
					var fun = new Function("参数列表","方法体");
						function 方法名称(形参列表){
								方法体
						  }
						var fun = function(){
						
						  }
					
			属性：
				length：形参的个数
					
			使用：
				函数名称(实参列表);	
					特点：
						1.函数的调用，只与函数名称有关，与实参列表无关
						2.函数内部有内置对象 arguments 封装实参数组
					
					void运算符：拦截返回值，一般结合a标签一起使用
						注销a标签跳转功能，保留可被点击的功能
						<a href="javascript:void(0);" onclick="exit();">退出</a>

JS中的内置对象

String对象

定义方式：

定义方式1：String str=new String(“这是一个String对象”)

定义方式2：var str=“这是一个String对象”

属性：

length：字符串长度；

方法：

charAt() 返回在指定位置的字符。
	例子：var v="abcd";
			var a=v.charAt(2);
		结果：b
		
concat()连接字符串。
	例子：var a="ab";var b="cd";
			var c=a.aoncat(b);
		结果：abcd
		
indexDf()根据字符串检索此符在字符串中的索引。
	例子：var str="asdfghjk";
			var c=str.indexOf("s");
		结果：1
		
lastindexOf()从后向前搜索字符串。
substring()提取字符串中两个指定索引之间的字符。
	例子：var str="abcdefg"
			var c=str.substring(0,3); //含头不含尾；
		结果：abcd
		
toLowerCase()把字符串转换成小写。
	例子：var str="ABcd";
			var c=str.tolowerCase();
		结果：abcd
		
 toUpperCase() 把字符串转换为大写。
 	例子：var str="ABcd";
			var c=str.toupperCase();
		结果：ABCD
		
replace()替换字符串。
	例子： var str="abcdefg";
			var c=str.replace("abc","ijk");
			//参数1：被替换的字符/或者字符串；
			//参数2：替换成那个字符/或者字符串；
		结果：ijkdefg
		
split() 把字符串分割为字符串数组。
 	例子： var v="a#b#c#d";
				var z=v.split("#");
		结果：abcd
		
trim():去除字符串两端的空格
	例子： var v="  abcd     ";
				var z=v.trim();
		结果：abcd
		
trimLeft(); 去掉字符串左端空格
trimRight(); 去掉字符串右端空空格

Math数学对象

定义方式：

特点： 该对象不需要创建 直接对象名点上方法

方法：

Math.min()://取最小值
Math.max()://取最大值
Math.random()://生成随机小数范围 0-1 之间
Math.round()://四舍五入
Math.pow(2,3)://求2的3次方
Math.sqrt(4)://4的平方根
Math.ceil(3.11111);向上取整
Math.floor(3.9);向下取整

Number对象

定义方式：

定义方式1：var num=new Number(555.6666);
定义方式2：var num1=Number(5694)；

方法：

toString():把数字类型转成字符串类型
	例子：	var v=Number(695444);
			var z=v.toString();
		结果：z="695444
toPrecision():把数字格式化为指定的长度。也就是小数后面保留几位
	例子：	var v=Number(3.5999999999999);
			var z=v.toPrecision(4);
		结果：z=3.600

Date 对象

定义方式：

var myDate=new Date();

方法

getTime()   获取从1970-01-01 00:00：00   到当前的毫秒值
toLocaleString()  将时间转化成本地格式 利于阅读
Date.getFullYear();   //从 Date 对象以四位数字返回年份。
			//从零开始数月份 0----11
Date.getMonth();	//从 Date 对象返回月份 (0 ~ 11)。
Date.getDay();	//从 Date 对象返回一周中的某一天 (0 ~ 6)。
Date.getHours(); 	//返回 Date 对象的小时 (0 ~ 23)。
Date.getMinutes();	//返回 Date 对象的分钟 (0 ~ 59)。
Date.getSeconds();  //返回 Date 对象的秒数 (0 ~ 59)。

数组对象

数组：就相当于一个容器，可以存储多个数据

####  定义方式： 

var arr=new Array();
var arr=[];

#### 属性： 

length 数组的长度

特点：

​ 在js中数组可以存储任意类型元素
​ 在js中数组的长度可变

方法：

concat():	//把多个数组中的元素，统一放到一个数组当中。
	例子：
			var arr=[10,20,30];
			var arr2=[100,200,300];
			var arr3=arr.concat(arr2);
			alert(arr3);
		结果：
			arr3=[10,20,30,100,200,300];
			
join(): //把数组中的元素，拼接成一个字符串，元素通过指定的分隔符进行分隔。
	例子：
			var arr=[10,20,30];
			var str=arr.join("-"); 、
			alert(str);
		结果：
			str=10-20-30;
			
unshift() //向数组的开头添加一个或更多元素，并返回新的长度。
	例子：
			var arr=[10,20,30];
			arr.unshift(40);
			alert(arr);
		结果：
			arr=[40,10,20,30]
			
pop() //删除数组中的最后一个元素，返回的就是那个被删除的元素
	例子：
			arr=[40,10,20,30];	
			var num=arr.pop();
			alert(num);
		结果：30
		
shift()	//删除并返回数组的第一个元素
	例子:
			arr=[40,10,20,30];	
			var num=arr.shift();
			alert(num);
		结果：40
		
reverse();//反转数组中的元素
	例子:
			arr=[40,10,20,30];	
			var arr=arr.reverse();
			alert(arr);
		结果: [30,20,10,40]
		
sort() //把数组中的元素，按照从小到大排列(排序方式是按照字典顺序来排序的)
	例子：
			arr=[40,10,20,30];
			arr.sort(arr);
			alert(arr);
		结果:[10,20,30,40]
		
forEach()	//数组每个元素都执行一次回调函数
	例子：
			var arr=[20,30,50];
			arr.forEach(function(ele,index){
				alert(ele);//ele数组中的 元素，数组中的索引
			});
			alert(arr);
//includes() //判断一个数组是否包含一个指定的值。
			var v=arr.includes(500);
			alert(v);
		结果：20
			 30
			 50
			 false
			 
filter()  //检测数值元素，并返回符合条件所有元素的数组。	
		例子:
			var arr=[20,30,50.31,35];
			var Arr=arr.filter（"3"）;
			alret(Arr);
			结果：30,31,35
reduce()  //数组元素累加
		例子:
			var arr=[20,30,50];
			var sum=arr.reduce(function(total,currentValue){
				return total+currentValue;
				// total	必需。初始值, 或者计算结束后的返回值。
				// currentValue	必需。当前元素
				// currentIndex	可选。当前元素的索引
				// arr	可选。当前元素所属的数组对象
			},0); //0是个初始值，可选的。
			alert(sum);
			 结果：100
slice() 从某个已有的数组返回选定数量的元素
		例子:
			 var arr = [10, 2, 30, 50, 30, 100];
			 var newArr = arr.slice(0, 4);
			 alert(newArr);
			结果：[10, 2, 30, 50]
splice() 删除元素，从当前索引删除指定数量元素，并向数组添加新元素。
		例子:
			var arr = [10, 2, 30, 50, 30, 100];
			// index 必需。规定从何处添加/删除元素。
			// 该参数是开始插入和（或）删除的数组元素的下标，必须是数字。
			// howmany 必需。规定应该删除多少元素。必须是数字，但可以是 "0"。
			// 如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
			var arr1=arr.splice(1,3);//删除从1索引开始的三个元素
			// element1 可选。规定要添加到数组的新元素。从 index 所指的下标处开始插入。 
			// elementX 可选。可向数组添加若干元素。 
			var arr2=arr.splice(1,2,3,4)//删除从1索引开始的两个元素，并将3,4从1索引处插入。
			结果：arr1=[10,30,100]
				 arr2=[10,3,4,50,30,100]

Global：全局方法对象

特点：该对象中的方法调用，不需要对象的引用，可直接使用

isNaN() 检查某个值是否是NaN。 
		例子：var v=NaN;  var v1="abc"; var v2=123;
			var b=isNaN(v); 
			var b1=isNaN(v1);
			var  b2=isNaN(v2);	

parseInt() 解析一个字符串并返回一个整数。  
	从左向右依次查找，每一位是否是数字，直到遇到不是数字为止。将前边的值转为数字比正号强大些  var v=+“123”；
				例子：  var v=“152abc”;
						var z=parseInt(v)+1;
						alert(z);
					结果：153

​
​

正则表达式

正则表达式：正确规则的表达式，作用就是用来校验数据是否符合定义的规则。
正则表达式：是一个独立的语法，其他很多语言都支持

	语法：
			regx=/[a,b,c,f,z,A,B]/i;  //i不区分大小写的匹配
		    regx=/[a-z]/;//匹配26个小写字母
			regx=/[A-Z]/;//匹配26个大小写字母
			regx=/[0-9]/;//匹配0-9这个9个数字字符
			regx=/^[a-z]$/;
			regx=/^[a-zA-Z0-9]$/;
			regx=/[^0-9]/; //不是0-9中的某一个字符
			regx=/./; //.匹配任意单个字符
			regx=/\./; //\. 转义  只匹配点本身
			regx=/\w/;//跟他的 [a-zA-Z_0-9] 意思一样
			regx=/\W/;//查找非单词字符。 跟他的 [^a-zA-Z_0-9] 意思一样
			regx=/\d/;//跟[0-9]意思一样  
			regx=/\D/;//查找非数字字符。跟[^0-9]意思一样
			regx=/\s/; //匹配空格字符
			regx=/\S/; //匹配不是空格字符
			\b 匹配单词边界
	判断数据是否匹配上了这个正则表达式
		    regx=/^[a-z0-9A-Z]+$/ //+ 可以出现一个或多个
			regx=/^[a-z0-9A-Z]*$/ //*  0个或多个 1个也算多个 空串算0ge
			regx=/^[a-z0-9A-Z]?$/ //?  0个或1个;
			regx=/^[a-z0-9A-Z]{3}$/ //{3} 正好3个
			regx=/^[a-z0-9A-Z]{3,}$/ //至少3个
			regx=/^[a-z0-9A-Z]{3,10}$/ //至少3个 最多10个
	方法：
		test("数据")  //判断这个数据是否符合我们定义的正则。
	
		 exec() 获取符合正则的数据。
		 
	RegExpObject.exec(string)
	参数描述:string 必需。要检索的字符串。 
	返回值
	返回一个数组，其中存放匹配的结果。如果未找到匹配，则返回值为 null。