JS中的函数+内置对象+数组对象+正则表达式对象

最新推荐文章于 2023-02-02 15:45:02 发布

pigpigpi

最新推荐文章于 2023-02-02 15:45:02 发布

阅读量240

点赞数

分类专栏： JS 文章标签：字符串 js regex 正则表达式 widget

本文链接：https://blog.csdn.net/qq_40733968/article/details/107294914

版权

JS 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一.JS中的函数

1.定义函数的三种方式

函数:类似于Java中的方法

JS中定义函数的三种方式:
定义方式1:
	var 函数名=function(){
			方法体;
		}
	调用方法执行语句;
定义方式2:
	function 函数名(){
			方法体;
		}
	调用方法执行语句;
定义方式3:
	var 方法名=new Function(参数1,参数2,方法体);
	调用方法执行的语句;

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<script type="text/javascript">
			/* 定义函数方式1: */
			var test1=function(){
				alert(39);
			}
			test1();
			
			/* 定义函数方式2: */
			function test2(){
				alert(66);
			}
			test2();
			/* 定义函数方式3: */
			var test3=new Function(11,11,alert(111));
			test3();
		</script>
	</head>
	<body>
	</body>
</html>

2.注意事项

1.JS中函数括号内的形参不需要指定具体类型,因为默认都是var类型.
2.JS函数默认没有返回值,如果需要,可以使用return语句来获得返回值.
3.JS函数中的形参与实参不需要一一对应,多或者少都没有关系.
		没写的参数类型是undefined,多出来的参数会忽略

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>注意事项</title>
		<script type="text/javascript">
			/* 1.JS函数中形参不需要指定具体类型 */
			var test=function(a,b){
				alert(a+b);
			}
			//test(100,200);
			
			/* 2.JS函数默认没有返回值,如果需要,可以使用return语句来获得 */
			function test2(a,b){
				return a+b;
			}
			var sum=test2(1000,200)
			alert(sum);//1200
			
			/* 3.JS函数中的形参与实参不需要一一对应 */
			var sum2=test2();//两个参数是undefined类型
			alert(sum2);//NaN
			var sum3=test2(10,20,30,40);
			alert(sum3);//30,多余的参数会被忽略
		</script>
	</head>
	<body>
	</body>
</html>

3.函数自调用

自调用函数 声明完了，马上进行调用，只能使用一次,,有两种写法

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<script type="text/javascript">
			/* 写法1 */
			var sum = (function test(a, b) {
				return a + b;
			}(100, 200));
			alert(sum);//300
			
			/* 写法2 */
			var sum2=(function test2(a,b){
				return a+b;
			})(100,200);
			alert(sum2);//300
		</script>
	</head>
	<body>
	</body>
</html>

4.函数的arguments 属性

函数也是一个对象,它的属性arguments 是一个数组，可以接收所有实参。

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<script type="text/javascript">
			function test(a,b,c){
				return arguments[0]+arguments[1]+arguments[2];
			}
			var s=test(100,200,300);
			alert(s);//600
		</script>
	</head>
	<body>
	</body>
</html>

5.使用函数打印9*9乘法表

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<script type="text/javascript">
			function test(){
				for(var i=1;i<=9;i++){
					for(var j=1;j<=i;j++){
						document.write(j+"*"+i+"=*"+j*i);
						document.write("&nbsp;&nbsp;&nbsp;&nbsp;")
					}
					document.write("<br>")
				}
			}
			test();
		</script>
	</head>
	<body>
	</body>
</html>

6.void运算符

void运算符常常用来使链接变成一个死链接:阻止跳转功能
当点击这个链接的时候，不会发生地址跳转,只保留点击功能

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<script type="text/javascript">
			function test() {
				if (window.confirm("是否跳转")) {
					window.open("http://www.baidu.com");
				}
			}
		</script>
	</head>
	<body>
		<!-- a标签,有点击功能,还要地址跳转功能 -->
		<a href="http://www.baidu.com">百度一下</a>
		<!-- 只保留点击功能,取消地址跳转功能 -->
		<a href="#">百度一下</a>

		<!-- 使用js来只保留点击功能 -->
		<a href="javascript:void(0);">百度一下</a>
		<!-- 调用函数 -->
		<a href="javascript:void(test());">百度两下</a>
		<!-- 简写 -->
		<a href="javascript:;">百度三下</a>
	</body>
</html>

二.JS中的内置对象

1.String对象

String内置对象用于处理字符串

创建String对象的两种方式:
		new String(s);
		String(s);
		
1.String对象的属性:
length 用来获取字符串的长度

2.注意事项:
	返回值:
	使用new String()方式创建出来的对象,它返回一个新创建的 String 对象,类型是Object
	不使用new直接创建出来的对象，它只把 s 转换成原始的字符串，并返回转换后的值。类型是String

3.String中的方法:	与Java中的方法大致相同
						charAt() 返回在指定位置的字符。 
							例子：var v="abcd";
							          var a=v.charAt(2);   
			 
						concat() 连接字符串。 
							例子：var v="ab";  var a="cd";
								var z=v.concat(a);
							
						indexOf() 根据字符检索此符在字符串中的索引。 
							例子：var v="abcde";
								var z=v.indexOf("c");			
			
						lastIndexOf() 从后向前搜索字符串。 
						substring() 提取字符串中两个指定的索引号之间的字符。 
							var v="abcde";
							var z=v.substring(0,3); 含头不含尾
			
						toLowerCase() 把字符串转换为小写。
			 				例子：
						 var str = "Hello World!";
						 document.write(str.toLocaleLowerCase());
			
			
						  toUpperCase() 把字符串转换为大写。 
			
						replace() 替换字符串。
							例子： 
							var v="abceaaaa";
							var z=v.replace("a","h");  参1：被替换的字符/或字符串   参数2：替换成哪个字符/或字符串
			
						split() 把字符串分割为字符串数组。
			 				例子： 
							var v="a#b#c#d";
							var z=v.split("#");
			
						* trim():去除字符串两端的空格
							例子： 
			                                                             var v="  abcd     ";
							var z=v.trim();
							trimRight();去右端空格
							trimLeft(); 去左端空格

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<!-- 创建String对象的两种方式 -->
		<script type="text/javascript">
			var str=new String("芜湖起飞");
			alert(str);
			
			var str2="啊哈,金色传说"
			alert(str2);
			
			//1.String对象的属性
			alert("aaa".length);//3
			
			//2.注意事项:
			/* 使用new创建出来的对象,返回的是一个新创建的String对象,类型是Object
			 不使用new创建出来的对象,只把 s 转换成原始的字符串，类型是String
			 */
			alert(typeof str);//object
			alert(typeof str2);//string
			
			//3.方法
			alert("abc".indexOf("a"));//0
			alert("aaa".charAt(0));//a
		</script>
	</head>
	<body>
	</body>
</html>

2.Number对象

Number 对象:
			Number 对象是原始数值的包装对象。
			
1.创建 Number 对象的语法：
			var myNum=new Number(value);
			var myNum=Number(value);
			注意:value可以为String类型,如果value为字符串,会根据字符串字母意义上的值计算出相应的值,转换失败为NaN;

2.方法:
	1.toString(radix);将数字转换为字符串,参数radix表示可选,表示进制,如输入2表示2进制
	2.toLocaleString();把Number对象转换为本地格式的字符串,返回值根据本地规范进行格式化
	3.toFixed(num) ;四舍五入,num必需有,num表示小数点后保留的位数,返回值表示四舍五入后的值的字符串的形式

3.属性(变量):
	MAX_VALUE表示最大的数,MIN_VALUE表示最小的数

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<script type="text/javascript">
			/* 1.创建Number对象的两种语法 */
			var num1=new Number(3.14);
			alert(num1);//3.14
			var num2=3.15;
			alert(num2);//3.15
			/* 如果value为字符串,会根据字符串字母意义上的值计算出相应的值,转换失败为NaN */
			var num3=new Number("100");
			var num4=new Number("aaa");
			alert(num3);//100
			alert(num4);//NaN
			
			//方法:
			//1.toString()方法
			//以二进制形式表示
			alert(3.14.toString());//3.14
			alert(3.14.toString(2));//二进制形式表示3.14
			
			//2.toLocaleString();把Number对象转换为本地格式的字符串,返回值根据本地规范进行格式化
			var newNum=new Number(100);
			alert(newNum.toLocaleString());
			
			//3.toFixed(num) ;四舍五入,num表示小数点后保留的位数,返回值表示四舍五入后的值的字符串形式
			var newNum2=new Number(1.234569999);
			alert(newNum2.toFixed(4));//1.2346
			alert(typeof newNum2.toFixed(4));//String
			
			//属性,MAX_VALUE表示最大的数,MIN_VALUE表示最小的数
			alert(Number.MAX_VALUE);//1.7976931348623157e+308
			alert(Number.MIN_VALUE);//5e-324
			
		</script>
	</head>
	<body>
	</body>
</html>

3.Date对象

Date对象用于处理日期和时间

创建 Date 对象的方式：如:
		var myDate=new Date();
注释：Date 对象会自动把当前日期和时间保存为其初始值。

方法:大致与Java中的Date相同
	Date() 构造方法,返回当日的日期和时间。 
	getDate()返回目前日期在本月份中的第几天,如7月14就返回一个14
	getDay() 返回今天是星期几,如星期2返回一个2
	getMonth() 从 Date 对象返回本月月份 (0 ~ 11)。 
	getFullYear() 从 Date 对象以四位数字返回本年年份。 (注意:getYear() 已经被getFullYear() 方法所代替。 )
	getTime() 返回 1970 年 1 月 1 日至今的毫秒数。 
	toLocaleString() 根据本地时间格式，把 Date 对象转换为字符串。

Moment.js 是一个简单易用的轻量级 JavaScript 日期处理类库，提供了日期格式化、日期解析等功能。

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<script type="text/javascript">
			var date=new Date();
			alert(date);//Tue Jul 14 2020 09:21:39 GMT+0800 (中国标准时间)
			
			//返回目前日期在本月份的第几天
			var v1=date.getDate();
			alert(v1);//13
			//返回当前是星期几
			var v2=date.getDay();
			alert(v2);//2
			//返回当前的月份,从0开始
			var v3=date.getMonth();
			alert(v3);//6
			//getTime() 返回 1970 年 1 月 1 日至今的毫秒数。 
			var v4=date.getTime()
			alert(v4);
			//toLocaleString() 根据本地时间格式，把 Date 对象转换为字符串。
			var v5=date.toLocaleString();
			console.log(v5);//2020/7/14 上午11:04:56
			
			/* 使用moment.js 来格式化*/
			var timeString=moment().format('YYYY-MM-DD HH-mm-ss dddd'); // 七月 12日 2020, 10:16:50 上午
			document.write(timeString);//2020-07-14 11-23-30 Tuesday
						
			var n=moment("1985-03-08", "YYYY-MM-DD").fromNow();
			alert(n);//35 years ago
		</script>
	</head>
	<body>
	</body>
</html>

4.Math对象

Math对象不需要new直接调用方法名就可以,大致与Java中的方法相同

方法:
				Math.random()；随机产生0----1 之间的随机数      var  num=Math.random()*100;
			      Math.round(2.36); 对小数进行四舍五入  得到一个整数    var n=Math.round(Math.random()*100);
			      Math.min(15,25); 取最小值
			      Math.max(15,25);取最大值
			      Math. abs(-2) 返回数的绝对值。 
			      Math.floor(2.6);向下取整
			      Math.ceil(3.82);向下取整

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script type="text/javascript">
			//随机产生0----1 之间的随机数 
			var v1=Math.random();
			document.write(v1);
			document.write("<br>");
			//取绝对值
			var v2=Math.abs(-10);
			document.write("<br>");
			document.write(v2);
			//向上取整
			var v3=Math.ceil(3.14);
			document.write(v3);//4
		</script>
	</body>
</html>

5.全局函数和全局变量

NaN
NaN 属性是代表非数字值的特殊值。该属性用于指示某个值不是数字。可以把 Number 对象设置为该值，来指示其不是数字值。
你可以使用 isNaN() 全局函数来判断一个值是否是 NaN 值。

var v=123;//返回的是一个Number类型的数字
varv2=new Number(123);//返回的是一个Object类型的对象

全局方法:
parseInt()和parseFloat()是全局方法
作用:从左向右依次查找，每一位是否是数字，直到遇到不是数字为止。将前边的值转为数字
	功能比正号强大些  var v=+“123”；

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script type="text/javascript">
			//判断一个数字是不是NaN
			alert(NaN == NaN); //== 判断不出来，永远是false
			//判断一个数字是不是NaN，使用方法来判断就能判断出来
			var v = isNaN("abc" * 1);
			alert(v); //true
			var v2 = 100 / "100"; //结果仍为整数
			alert(isNaN(v2)); //false
			alert(isNaN(100 / 0)); //false,Infinity无穷大是一个数字

			/* * 从左向右依次查找，每一位是否是数字，直到遇到不是数字为止。将前边的值转为数字
												比正号强大些  var v=+“123”； */
			var a = parseInt("2000abc");
			var b = parseFloat("3.14abc");
			alert(a + b);//2003.14
		</script>
	</body>
</html>

三.数组对象

1.创建数组对象的三种方式

Array 对象用于在单个的变量中存储多个值。

创建 Array 对象的语法：
		new Array();创建一个空数组,数组长度可变
		new Array(size);创建一个指定大小的数组,当未给数组中的元素赋值时，元素都为undefined
		new Array(element0, element1, ..., elementn); 创建数组时，直接把元素放进去
		
定义数组元素的简便方式:
	var arr=[1,2,3];

数组对象的特点:
JS中的数组大小是可变的，当未给数组中的元素赋值时，元素都为undefined

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>创建数组对象的三种方式</title>
	</head>
	<body>
		<script type="text/javascript">
			/* 1.创建一个空数组,注意数组长度可变 */
			var arr1=new Array();
			/* 给数组中的元素赋值 */
			arr1[0]=1;
			arr1[1]="aaa";
			document.write(arr1[0]);
			document.write("<br>");
			document.write(arr1[1]);
			
			/* 2.创建一个指定大小的数组,当未给数组中的元素赋值时，元素都为undefined */
			var arr2=new Array(4);
			document.write(arr2[0]);//undefined
			document.write(arr2[1]);//undefined
			document.write(arr2[2]);//undefined
			
			document.write("<br>");
			//3.在创建数组时,直接放入元素
			var arr3=new Array(1,2,"aaa",true,3.14);
			document.write(arr3[0]);
			document.write(arr3[1]);
			document.write(arr3[2]);
			
			//定义数组元素的简便方式
			var arr4=[1,2,3];
		</script>
	</body>
</html>

2.JS中的二维数组

与Java中的二维数组类似,JS中的二维数组也是一维数组里的每一个元素都是一个数组

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script type="text/javascript">
			//二维数组
			//定义一个空数组
			var arr=[];
			//二维数组其实就是一维数组的每一个元素都是一个数组
			var arr1=[1,2,3,"aaa"];
			var arr2=[true,false,3.14];
			//把一维数组当成元素赋值给二维数组
			arr[0]=arr1;
			arr[1]=arr2;
			
			/* 如何取出二维数组中的每一个元素?
				遍历
			 */
			for(var i=0;i<arr.length;i++){
				for(var j=0;j<arr[i].length;j++){
					document.write(arr[i][j]);
					document.write("<br>")
				}
			}
			//定义二维数组的简便方式
			var array=[[1,2,3],[true,false,3.14],["aaa",'aaa',false]];
		</script>
	</body>
</html>

3.JS数组对象中的方法

1.indexOf()根据数组元素获得索引
2.push()往数组的末尾添加一个元素,返回值是添加完后数组的长度
3.pop()从数组的末尾删除一个元素,返回的是删除的元素
4.shift()删除数组的第一个元素,返回的是删除的元素
5.reverse()反转数组中的元素
6.unshift()往数组的前面加元素,返回值是添加完元素后数组的长度
7.concat()合并两个数组,返回值是一个新创建的数组
8.join()把两个数组合并成一个字符串,括号内是分隔符,返回值是合并完的字符串
9.sort()排序
	注意:
		sort()空参的排序方式，是按照字典顺序排的。
		如果需要按照元素的大小来排列,需要定义比较器
10.splice() 删除元素，并向数组添加新元素。
11.slice()选取数组的的一部分，并返回一个新数组
	根据起始索引和终止索引，截取旧数组中的一部分元素，到一个新数组中，含头不含尾。

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<script type="text/javascript">
			var arr=[1,2,3];
			var arr2=[4,true,false,3.14];
			//1.indexOf()根据数组元素获得索引
			document.write(arr.indexOf(1));//0
			//2.push()往数组的末尾添加一个元素,返回值是添加完后数组的长度
			var len=arr.push(88);
			document.write(len);//4
			document.write("<br>");
			//3.pop()从数组的末尾删除一个元素,返回的是删除的元素
			var a=arr.pop();
			document.write(a);//88
			//4.shift()删除数组的第一个元素,返回的是删除的元素
			var first=arr2.shift();
			document.write(first);//4
			//5.reverse()反转数组中的元素
			var one=[1,2,3,4];
			one.reverse();
			document.write(one);//4,3,2,1
			//6.unshift()往数组的前面加元素,返回值是添加完元素后数组的长度
			var two=[11,22,33,44];
			two.unshift(true);
			document.write(two);//true,11,22,33,44
			document.write("<br>");
			//7.concat()合并两个数组,返回值是一个新创建的数组
			var th=one.concat(two);
			document.write(th);//4,3,2,1,true,11,22,33,44
			//8.join()把两个数组合并成一个字符串,括号内是分隔符,返回值是合并完的字符串
			document.write("<br>");
			var arrr1=[1,2,3];
			var arrr2=[4,5,6];
			var strr=arrr1.join("%");
			document.write(strr);
			//9.sort()排序
			/* 
			 sort()空参的排序方式，是按照字典顺序排的。
			 */
			var arr111=[55,12,111,333,9];
			document.write(arr111.sort());//111,12,333,55,9
			/* 如果需要按照元素的大小来排列,需要定义比较器 */
			var bjq=function(a,b){
				//按照 正负0来排
				return a-b;
			}
			/* 
						//匿名函数，可以作为参数传递
						function(a,b){
							return a-b; //正 负 0
						} 
						*/
			document.write("<br>");
			var arr222=[55,12,111,333,9];	   
			arr222.sort(function(a,b){
							return a-b; //正 负 0
						});
			alert(arr222);//9,12,55,111,333
			
			//10.splice() 删除元素，并向数组添加新元素。
			var arr22=[1,2,3,4];
			//从1索引出开始删除数组一个元素。999 你把2删了，在补了一个999进去。
			arr22.splice(1,1,999);
			alert(arr22);//1,999,3,4
			 //从1索引处开始，删除两个元素，然后往数组中又补了若干个元素。
			arr22.splice(1,2,300,600,700,8000);
			alert(arr22);//1,300,600,700,8000,4
			
			//11.slice()选取数组的的一部分，并返回一个新数组
			//根据起始索引和终止索引，截取旧数组中的一部分元素，到一个新数组中，含头不含尾。
			var arr33=[1,2,34,5,6];
			var newArr=arr33.slice(0,3);
			alert(newArr);//1,2,34
		</script>
	</head>
	<body>
	</body>
</html>

4.ES6中增加数组的方法

every()	检测数值元素的每个元素是否都符合条件。
filter()	检测数值元素，并返回符合条件所有元素的数组。
forEach()	数组每个元素都执行一次回调函数。
map()	通过指定函数处理数组的每个元素，并返回处理后的数组。
reduce()	将数组元素计算为一个值（从左到右）。可以指定开始的位置

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script type="text/javascript">
			//every()	检测数值元素的每个元素是否都符合条件。
			var arr=[100,99,311.4567,999];
			//判断数组中的每个元素，是否都大于400
			var flag=arr.every(function(ele){
				return ele>400;
			});
			alert(flag);//false
			
			//filter()	检测数值元素，并返回符合条件所有元素的数组。
			var arr2=[100,99,311,4567,999];
			var newArr=arr2.filter(function(ele){
				return ele>400;
			});
			alert(newArr);//4567,999
			
			//forEach()	数组每个元素都执行一次回调函数。
			var arr3=[100,99,311,4567,999];
			arr3.forEach(function(ele,index){
				alert(ele+":"+index);//100:0 99:1 311:2 4567:3 999:4
			});
			
			//map()	通过指定函数处理数组的每个元素，并返回处理后的数组。
			var arr4=[100,99,311,4567,999];
			var newArr2=arr4.map(function(ele){
				return ele*ele;
			});
			alert(newArr2);//10000,9801,96721,20857489,998001
			
			//reduce()	将数组元素计算为一个值（从左到右）。
			var arr5=[100,99,311,4567,999];
			//求和,从0开始
			var s=arr5.reduce(function(sum,ele){
				return sum+ele;
			},0);
			alert(s);//6076
		</script>
	</body>
</html>

四.正则表达式对象

1.JS中的修饰符

JS中的正则表达式类似于Java中的正则表达式

修饰符:
i  忽略大小写
g  执行全局匹配,查找所有匹配而非在找到第一个匹配后停止
m  执行多行匹配
^和$代表整体匹配

方法:
test()	检索字符串中指定的值。返回 true 或 false
exec()	检索字符串中指定的值。返回找到的值，并确定其位置

支持正则表达式的String对象的方法:
search()	检索与正则表达式相匹配的值
match()	找到一个或多个正则表达式的匹配
replace()	替换与正则表达式匹配的子串
split()	把字符串分割为字符串数组

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script type="text/javascript">
			/* 修饰符 */
			var str = "hello999";
			//定义一个正则表达式,用/来分隔,i表示忽略大小写
			//^和$代表整体匹配
			var regx = /^[A-Z0-9]+$/;
			var f = regx.test(str);
			alert("是否匹配?" + f); //false,如果不加^和$返回false

			//获取出，下面字符串中是3个字符组成的单词
			var str2 = "daaa  ABC jia hao hao xue xi aaaa,df?";
			// g 执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）。 
			var reg = /\b[a-z]{3}\b/gi;

			//exec 检索字符串中指定的值。返回找到的值，并确定其位置。 
			var s;
			while ((s = reg.exec(str2)) != null) {
				alert(s);
			}
			
			var str3 = "daaa  ABC jia hao hao xue xi aaaa,df?";
			var reg3 = /\b[a-z]{3}\b/gi;
			
			// 1、String的match()方法
			var r1=str3.match(reg3);
			document.write(r1);//ABC,jia,hao,hao,xue
			
			//2.search()方法，类似于indexOf()方法 比他强大一下，可以根据正则去查找。检索不到返回-1
			var r2=str3.search(reg3);
			document.write(r2);//6,ABC所在索引为6
			
			//3.replace()方法 如果 regexp 具有全局标志 g，那么 replace() 方法将替换所有匹配的子串。否则，它只替换第一个匹配子串
			var regx2=/[A-Z]{3}/g;
			var s=str3.replace(regx2,"+++");
			document.write(s);//ABC,jia,hao,hao,xue6daaa +++ jia hao hao xue xi aaaa,df?
			
			//4.split()	把字符串分割为字符串数组
			var v="111+222+33+444";
			var r=/[+]+/gi;
			var arr=v.split(r);
			document.write(arr);//111,222,33,444
		</script>
	</body>
</html>

pigpigpi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JS中的函数+内置对象+数组对象+正则表达式对象

一.JS中的函数1.定义函数的三种方式函数:类似于Java中的方法JS中定义函数的三种方式:定义方式1: var 函数名=function(){ 方法体; } 调用方法执行语句;定义方式2: function 函数名(){ 方法体; } 调用方法执行语句;定义方式3: var 方法名=new Function(参数1,参数2,方法体); 调用方法执行的语句;<!DOCTYPE html><html> <head>
复制链接

扫一扫

专栏目录