K108
1.Array对象属性
2.定义和用法
3.push() 该方法可以向数组的末尾添加一个或多个元素,并返回数组的新的长度
1)可以将要添加的元素作为方法的参数传递
这些元素将自动添加到数组的末尾
<script>
var arr = ["艾雅法拉","伊芙利特","安洁莉娜"];
arr.push("澄闪");
console.log(arr);
</script>
<script>
var arr = ["艾雅法拉","伊芙利特","安洁莉娜"];
var result = arr.push("艾雅法拉","伊芙利特","安洁莉娜");
arr.push("澄闪");
console.log(arr);
console.log("result ="+ result);
//arr.pop();
//console.log(arr);
</script>
4.pop() 该方法可以删除数组的最后一个元素,并将删除的元素作为返回值返回
<script>
var arr = ["艾雅法拉","伊芙利特","安洁莉娜"];
//arr.push("澄闪");
console.log(arr);
arr.pop();
console.log(arr);
</script>
<script>
var arr = ["艾雅法拉","伊芙利特","安洁莉娜"];
//var result = arr.push("艾雅法拉","伊芙利特","安洁莉娜");
//arr.push("澄闪");
result = arr.pop();
console.log(arr);
console.log("result ="+ result);
//arr.pop();
//console.log(arr);
</script>
5.unshift() 向数组开头添加一个或多个元素,并返回新的新组长度
<script>
var arr = ["艾雅法拉","伊芙利特","安洁莉娜"];
//var result = arr.push("艾雅法拉","伊芙利特","安洁莉娜");
//arr.push("澄闪");
//result = arr.pop();
//console.log(arr);
//console.log("result ="+ result);
//arr.pop();
//console.log(arr);
console.log(arr);
arr.unshift("焰影苇草");
console.log(arr);
</script>
6.shift() 可以是删除数组的第一个元素,并将被删除的元素作为返回值返回
<script>
var arr = ["艾雅法拉","伊芙利特","安洁莉娜"];
//var result = arr.push("艾雅法拉","伊芙利特","安洁莉娜");
//arr.push("澄闪");
//result = arr.pop();
//console.log(arr);
//console.log("result ="+ result);
//arr.pop();
//console.log(arr);
console.log(arr);
arr.unshift("焰影苇草");
console.log(arr);
result = arr.shift();
console.log(arr);
console.log("result = "+ result);
</script>
K109
1.遍历数组
1)将数组中的所有元素都取出来
<script>
var arr = ["玛恩纳","银灰","棘刺","山"];
/*console.log(arr[0]);
console.log(arr[1]);
console.log(arr[2]);
console.log(arr[3]);*/
for(var i = 0; i < 10 ; i++){
console.log(i);
}
</script>
<script>
var arr = ["玛恩纳","银灰","棘刺","山"];
/*console.log(arr[0]);
console.log(arr[1]);
console.log(arr[2]);
console.log(arr[3]);*/
for(var i = 0; i < 10 ; i++){
console.log(arr[i]);
}
</script>
2)创建一个函数,可以将perArr满24岁的提取出来,再封装到一个新的数组返回
<script>
/*var arr = ["玛恩纳","银灰","棘刺","山"];
console.log(arr[0]);
console.log(arr[1]);
console.log(arr[2]);
console.log(arr[3]);
for(var i = 0; i < 10 ; i++){
console.log(arr[i]);
}*/
var per = new Person("玛恩纳",45);
var per2 = new Person("银灰",35);
var per3 = new Person("棘刺",22);
var per4 = new Person("山",23);
var per5 = new Person("傀影",28);
//将这些person对象放入到一个数组中
var perArr = [per,per2,per3,per4,per5];
function getwho(arr){
var newArr = [];
//遍历arr,获取arr中的person对象
for(var i=0 ; i<arr.length; i++){
var p = arr[i];
//console.log(arr[i]);
if(p.age >=18){
//判断person对象的age是大于24
//将对象放到新数组中
newArr.push(p);
}
}
//如果大于24,将其添加到newArr中
//将新的数组返回
return newArr;
}
var result = getwho(perArr);
//console.log(result);
</script>
K110
1.新的forEach遍历数组 (只支持IE8以上浏览器)
1)forEach()方法需要一个函数作为参数
2)像这种函数被称为回调函数(由我们创建但不是由我们调用)
注1:数组中有几个元素函数就会被调用几次
<script>
var arr = ["玛恩纳","银灰","棘刺","山","傀影"];
function fun(){
}
arr.forEach(function(){
console.log("hello");
});
</script>
注2:每次执行时,浏览器会将遍历的所有元素以实参的形式传递过来
<script>
var arr = ["玛恩纳","银灰","棘刺","山","傀影"];
function fun(){
}
arr.forEach(function(a){
//console.log("hello");
console.log("a = "+a);
});
</script>
注3:浏览器会在回调函数中传递三个参数
第一个参数为当前遍历的函数,第二为遍历元素的索引,三为正在遍历的数组
K111
1.slice() 可以用来从数组中提取指定元素
1)语法:arrayObject.slice(start,end)
start:规定从何处开始选取,end:规定从何处开始结束
2)该方法不会改变元素数组,而是将截取到的元素封装到一个新的数组中返回
注1:第二个参数可以省略不写,此时截取从开始索引往后的所有元素
注2:索引可以传递一个负数,若传递一个负数,则从后往前计算
<script>
var arr = ["玛恩纳","银灰","棘刺","山","傀影"];
var result = arr.slice(0,2);
//console.log(arr);
console.log(result);
</script>
2.splice() 可以用于删除数组中的指定元素
1)使用会影响到原数组,会将指定元素从原数组中删除
并将被删除的元素作为返回值返回
<script>
var arr = ["玛恩纳","银灰","棘刺","山","傀影"];
arr.splice(0,2);
console.log(arr);
</script>
2)参数 第一个表示开始位置的索引,第二表删除数量,三及以后可传递新元素
传递的新元素会自动插入到开始位置
K112
1)去除数组中的重复数字
<script>
var arr = [1,2,3,2,1,3,4,2,5,];
//去除数组中的重复数字
//获取数组中的每一个元素
for(var i=0; i<arr.length;i++){
console.log(arr[i]);
//获取元素后的所有元素
for(var j=i+1; j<arr.length;j++){
//console.log("---->"+arr[j]);
//判断两个元素是否相等
if(arr[i] == arr[j]){
//若相等则证明出现了重复的元素,则删除j对应的元素
arr.splice(j,1);
}
}
}
console.log(arr);
</script>
2)优化,相邻较小数
<script>
var arr = [1,2,3,2,2,1,3,4,2,5,];
//去除数组中的重复数字
//获取数组中的每一个元素
for(var i=0; i<arr.length;i++){
console.log(arr[i]);
//获取元素后的所有元素
for(var j=i+1; j<arr.length;j++){
//console.log("---->"+arr[j]);
//判断两个元素是否相等
if(arr[i] == arr[j]){
//若相等则证明出现了重复的元素,则删除j对应的元素
arr.splice(j,1);
//当删除了当前j所在的元素以后,后面的元素会自动补位
//此时不会再比较这个元素,需要再比较一次j所在的位置
//使j自减
j--;
}
}
}
console.log(arr);
</script>
55.K113
1.contact() 可连接两个或多个数组,并将新的数组返回
1)该数组不会对原数组产生影响
<script>
var arr =["玛恩纳","银灰","棘刺"];
var arr2 =["佐菲亚","初雪","艾丽妮"];
arr.concat(arr2);
console.log(arr);
</script>
<script>
var arr =["玛恩纳","银灰","棘刺"];
var arr2 =["佐菲亚","初雪","艾丽妮"];
var result = arr.concat(arr2);
//console.log(arr);
console.log(result);
</script>
2)pro(加)
<script>
var arr =["玛恩纳","银灰","棘刺"];
var arr2 =["佐菲亚","初雪","艾丽妮"];
var arr3 = ["霞光","临光"]
var result = arr.concat(arr2,arr3,"铃兰");
//console.log(arr);
console.log(result);
</script>
2.join() 该方法可以将数组转换为一个字符串
1)该方法不会对原数组产生影响,而是将转换后的结果作为返回值返回
<script>
arr = ["玛恩纳","银灰","棘刺"];
result = arr.join();
console.log(result);
</script>
2)可指定一个字符串作为参数,这个字符串会成为数组中元素的连接符
<script>
arr = ["玛恩纳","银灰","棘刺"];
result = arr.join("QAQ");
console.log(result);
</script>
3.reverse() 该方法用来反转数组(前去后,后去前)
1)该方法直接修改原数组
<script>
arr = ["玛恩纳","银灰","棘刺"];
result = arr.join("QAQ");
//console.log(result);
arr.reverse();
console.log(arr);
</script>
4.sort() 可以对数组进行排序
1)改变原数组,默认Unicode编码排序
<script>
arr = ["b","d","e","a","c"];
arr.sort()
console.log(arr);
</script>
2)纯数字数组仍然按Unicode编码排序
<script>
arr = [3,4,11,2,5];
arr.sort();
console.log(arr);
</script>
3)可自己指定排序顺序,在sort()添加一个回调函数,来指定排序规则
回调函数需要定义两个形参,浏览器将分别使用数组中的元素作为实参调用回调函数
浏览器会根据回调函数的返回值决定元素的顺序,返回>0值,元素交换。<=0值不变
注:逆序:1与-1换位
<script>
arr = [5,4,7,6,1,2,3];
arr.sort(function(a,b){
//console.log("a = "+a);
//console.log("b = "+b);
if(a > b){
return 1;
}else if(a < b){
return -1;
}else{
return 0;
}
});
console.log(arr);
</script>
4)升序排列(降序则是b - a)
<script>
arr = [5,4,7,6,1,2,3];
arr.sort(function(a,b){
//console.log("a = "+a);
//console.log("b = "+b);
return a - b;
});
console.log(arr);
</script>
K114
1.call() 和 apply
1)两者都是函数对象的方法,需要通过函数对象调用
<script>
function fun(){
alert("我是fun函数!");
}
fun.call();
</script>
2)调用call和apply可以将一个参数指定为一个参数
注this:以函数形式调用时,this永远都是window
注this2:以方法形式调用时,this时调用方法的对象
注this3:以构造函数形式调用时,this是新创建的对象
注this4:使用call和apply调用时,this是指定的那个对象
K115
1)在调用函数时,浏览器每次会传递两个隐含的参数
注1:函数的上下文对象:this
注2:封装实参的对象 arguments
2)arguments是一个类数组对象,它可以通过索引来操作数据,也可以获取长度
<script>
function fun(){
console.log(Array.isArray());
}
fun();
</script>
3)在调用函数时,我们所传递的实参都会在arguments中保存
<script>
function fun(){
//console.log(Array.isArray());
console.log(arguments.length);
}
fun();
</script>
4)arguments.length可以用来获取实参的长度
<script>
function fun(){
//console.log(Array.isArray());
console.log(arguments.length);
}
fun("hello",true);
</script>
5)我们即使不定义形参,也可以通过arguments来使用实参
arguments[0] 表示第一个实参
arguments[1] 表示第二个实参
<script>
function fun(){
//console.log(Array.isArray());
//console.log(arguments.length);
console.log(arguments[1]);
}
fun("hello",true);
</script>
K116
1.在JS中使用Date对象来表示一个时间
1)直接使用构造函数创建一个Date对象,会封装当前代码执行时的时间
<script>
var d = new Date();
console.log(d);
</script>
2)创建一个指定的时间对象,在构造函数中传递一个表示时间的字符串作为参数
注:日期的格式:月份/日/年 时:分:秒
<script>
var d = new Date();
var d2 = new Date("12/03/2022");
console.log(d2);
</script>
2.getDate() 获取当前日期对象是几日
<script>
var d = new Date();
var d2 = new Date("12/03/2022 12:27:30");
var date =d2.getDate();
//console.log(d2);
console.log("date = "+date);
</script>
3.getDay() 获取当前日期对象是周几
注:返回0-6, 0表示周日,1表示周一
<script>
var d = new Date();
var d2 = new Date("12/03/2022 12:27:30");
var day =d2.getDay();
//console.log(d2);
//console.log("date = "+date);
console.log("day = "+day);
</script>
4.getMonth() 获取当前日期对象的月份
注:返回0-11, 0表示1月,11表示12月
<script>
var d = new Date();
var d2 = new Date("12/03/2022 12:27:30");
var day =d2.getDay();
var month = d2.getMonth();
//console.log(d2);
//console.log("date = "+date);
//console.log("day = "+day);
console.log("month = "+month);
</script>
5.getFullYear() 获取当前日期对象的年份
<script>
var d = new Date();
var d2 = new Date("12/03/2022 12:27:30");
var day =d2.getDay();
var month = d2.getMonth();
var year = d2.getFullYear();
//console.log(d2);
//console.log("date = "+date);
//console.log("day = "+day);
//console.log("month = "+month);
console.log(year);
</script>
6.getTime() 获取当前日期对象的时间戳
注:时间戳:指从格林威治标准时间的1970.1.1 0:0:0到当前时期的毫秒数
<script>
var d = new Date();
var d2 = new Date("12/03/2022 12:27:30");
var day =d2.getDay();
var month = d2.getMonth();
var year = d2.getFullYear();
var time = d2.getTime();
//console.log(d2);
//console.log("date = "+date);
//console.log("day = "+day);
//console.log("month = "+month);
//console.log(year);
console.log(time);
</script>
7.获取时间戳
time = Date.now();
K117
1)Math和其他对象不同,它不是一个构造函数
属于一个工具类不用创造对象,它里面封装了数学运算相关的属性和方法
2)Math.PI表示圆周率
3)abs()可以计算一个数的绝对值
4)Math.ceil()可以对一个数进行向上取整,有小数位则自动进1
5)Math.floor()可以进行向下取整,小数部分被舍掉
6)Math.round()可以对一个数进行四舍五入取整
7)Math.random()可以生成一个0-1之间的随机数
生成0-10,则Math.random()*10
生成0-x,则Math.random()*x
生成1-10,则(Math.random()*9)+1
生成x-y,则(Math.random( ) * (y-x)+x)
8)max()可以获取多个数中的最大值,min()最小值
9)Math.pow(x,y)返回x的y次幂
10)Math.sqrt()用于对一个数进行开方运算
K118
1.JS中提供了三个包装类,通过这三个包装类可以将基本数据类型的数据转为对象
1)三个:String(转换为string对象) Number(n…) Boolean(b…)
2)方法和对象只能添加给对象,不能添加给基本数据类型
3)当我们对一些基本数据类型的值去调用属性和方法
浏览器会临时使用包装类将其转换为对象,然后再调用对象和方法
调换之后会将其转换为基本数据类型
K119
1)底层字符串是以字符数组的形式保存的
2)length属性可以获取字符串长度
<script>
var str ="Hello Atguigu";
console.log(str.length);
</script>
<script>
var str ="Hello Atguigu";
console.log(str[6]);
</script>
3)charAt()可以返回字符串中指定位置的字符,根据索引获取
4)charCodeAt() 可以获取指定位置的字符编码(unico编码)
5)String.formCharCode()可以根据字符编码去获取字符
6)concat() 可以用来连接两个或多个字符串
7)indexof() 可以检索一个字符中是否含有指定内容
若有,则返回其第一次出现的索引
若无,则返回-1
可指定一第二个参数,指定开始查找的位置 result = str.indexof(“X”,x);
8)lastIndexof() 同上,但从后往前找
9)slice() 可从字符串中截取指定的内容,不影响原字符串,将截取内容返回
参数:第一个,开始位置索引(包括开始位置) 第二个,结束…(不包括)
若省略第二个数,则会截取后面所有的
也可传递一个负数,表现形式为从后向前
10)substring() 可用来截取一个字符串,与slice()类似
参数:第一个,开始位置索引(包括开始位置) 第二个,结束…(不包括)
不同的是,不能接受赋值,传递默认为0
它还可以自动调整参数的位置,若二<一,则自动交换
11)substr() 用来截取字符串或截取的长度
12)split()可以将一个字符串拆分为一个数组
需要一个字符串作为参数,将会根据该字符串去拆分数组
如果传递为一个空串作为参数,则会将每个字符拆分为数组中的一个元素
13)toUpperCase()将一个字符串转换为大写并返回
K120
1.正则表达式
1)邮件的规则
a.前面可以是xxxx之类的
b.后面跟着一个@
c.后面可以是xxxx
d. .com或其他
2)正则表达式用于定义一些字符串的规则
计算机可根据正则表达式,来检查一个字符串是否符合规则
获取将字符串中符合规则的内容提取出来
3)var 变量 = new RegExp(“正则表达式”,“匹配模式”)
4)test()使用这个方法可以用来检查一个字符串是否符合正则表达式的规则
符合返回true,否则返回false
5)在构造函数中可以传递一个匹配模式作为第二个参数
可以是i 忽略大小写 g 全局匹配模式
K121
1.使用字面量来创建正则表达式
1)语法:var 变量 = /正则表达式/匹配模式
注:使用构造函数更加灵活,字面量更简单
<script>
/*var str ="Hello Atguigu";
console.log(str[6]);*/
var reg = new RegExp("a","i");
reg = /a/i;
console,log(typeof reg);
console.log(reg.test("abc"));
</script>
2)| 与 [] 或
reg = /a|b|c|d|e|f|g/;
reg = /[abcdefg]/
注:a-z在[]表示a到z
K122
1)split() 可以将一个字符串拆分为一个组
可传递一个正则表达式作为参数,这样方法将会根据正则表达式去拆分字符串
2)search() 可以搜索字符串中是否含有指定内容
若有,则返回其第一次出现的索引
若无,则返回-1
可以接受一个正则表达式作为参数,然后会根据正则表达式去检索字符串
3)match()可以根据正则表达式,从一个字符串中将符合条件的内容提取出来
默认情况下我们的match只会找到一个符合这种要求的内容,找到后停止
我们可以设置正则表达式为全局匹配模式,这样就会匹配到所有的内容
可以为一个正则表达式设置多个匹配模式,且顺序无所谓
match()会将匹配到的内容封装到一个数组中返回,即使只查询到一个结果
4)replace() 可以将字符串中指定内容替换为新的内容
参数:1.被替换的内容,可以接受一个正则表达式作为参数 2.新的内容
默认只会替换一个
result = str.replace("a","QAQ");
K123
1)量词
注1:通过量词可以设置一个内容出现的次数 {n}正好出现n次
量词只对它前面的一个内容起作用
{m-n}:出现m-n次(m到n)
{m,} :m次以上
+ :至少一个,相当于{1,}
* :0个或多个,相当于{0,}
? :0个或1个,相当于{0,1}
^ :表示开头
$ :表示结尾
注2:在正则表达式中使用^&要求字符串必须完全符合正则表达式
<script>
var reg = /a{3}/;
console.log(reg.test("aaabc"));
</script>
K124
1). :表示任意字符
2)在正则表达式中使用\作为转义字符
3)用\ .表示.
4)用\ \表示斜杠
5)\ w :任意字母、数字、_ [A-Z 0-9_]
6)\ W:除了字母、数字、_ [ ^A-Z 0-9_ ]
7)\ d :任意的数字[0-9]
8)\ D :除了数字[^0-9]
9)\ s :空格
10)\ S :除了空格
11)\ b :单词边界
12)\ B :除了单词边界
K125
1.要求
1)尝试
<script>
var emaiReg = /\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}/;
var email = "abc@abc.com";
console.log(emaiReg.test(email));
</script>
K126
1.JS中的数据:
1)String 字符串
2)Number 数值
3)Boolean 布尔值
4)Null 空值
5)Undefined 未定义
6)Object 对象
A.基本数据类型为单一值
a.示例:在JS中表示一个人的信息(name gender age)
var name = "焰影苇草";
var gender = "女";
var age = "18";
注:使用基本数据类型的数据,所创建的变量都是独立的,不能成为一个整体
B.对象属于一种复合类型
a.在对象中可以保存多个不同数据类型的属性
2.对象的分类
a.内建对象:由ES标准中定义的对象,在任何的ES的实现中都可以使用
如Math String Number Boolean Function Object…
b.宿主对象:由JS的运行环境提供的对象,目前主要指由浏览器提供的对象
如BOM(浏览器对象模型) DOM(文档对象模型)
c.自定义对象:由开发人员自己创建的对象
K127
1.构造函数
var obj = new Object();
注:使用new关键字调用的函数,是构造函数constructor,它专门用来创建对象
1)向对象中添加属性(在对象中保存的值称为属性)
语法:对象.属性名 = 属性值;
例1:向obj中添加一个name属性:
var obj = new Object();
obj.name = "焰影苇草";
例2:再向obj中添加一个gender、age属性:
var obj = new Object();
obj.name = "焰影苇草";
obj.gender = "女";
obj.age = "18";
2)读取对象中的属性
语法:对象.属性名 ;
<script>
var obj = new Object();
obj.name = "焰影苇草";
obj.gender = "女";
obj.age = "18";
console.log(obj);
console.log(obj.name);
console.log(obj.gender);
console.log(obj.age);
</script>
3)修改对象的属性值
语法:对象.属性名 = 新值 ;
4)删除对象的属性
语法:delete 对象.属性名 ;
K128
1.属性名
1)对象的属性名不强制要求遵守标识符的规范
2)使用特殊的属性名(如数字) 语法:对象[“属性名”] = 属性值,读取同形
注:使用[]这种形式去操作属性,更加的灵活,在[]中可以直接传递一个变量
var obj = new Object;
obj["123"] = 789;
var n = "123";
console.log(obj[n]);
//console.log(obj["123"]);
2.属性值
1)JS对象的属性值,可以是任意的数据类型,甚至也可以是一个对象(层层套)
<script>
var obj2 = new Object;
obj2.name = "焰影苇草";
obj.test = obj2;
console.log(obj.test.name)
</script>
3.in 运算符
1)通过该运算符可以检查一个对象中是否含有指定的属性,有->true 无->false
2)语法:“属性名” in 对象;
K129
1.探究基本类型与引用类型的区别
1)基本数据类型
<script>
var a = 123;
var b = a;
a++;
console.log("a = " + a);
console.log("b = " + b);
</script>
2)引用数据类型(原)
<script>
var obj = new Object;
obj.name = "焰影苇草";
var obj2 = obj;
console.log(obj.name);
console.log(obj2.name);
</script>
3)修改属性名(现)
<script>
var obj = new Object;
obj.name = "焰影苇草";
var obj2 = obj;
//修改obj的name属性
obj.name = "法伤十万大C";
console.log(obj.name);
console.log(obj2.name);
</script>
A.JS中的变量都是保存到栈内存中
a.基本数据类型的值直接在栈内存中存储
b.值与值之间是独立存在的,修改一个变量不会影响到其他的变量
c.对象是保存在堆内存中的
d.每创建一个新的对象,就会在堆内存中开辟一个新的空间,而变量保存的是对象的内存地址(对象的引用)
e.如果两个变量保存的是同一个对象引用,当一个通过变量修改时,另一个也会收到影响
4)修改属性值
<script>
var obj = new Object;
obj.name = "焰影苇草";
var obj2 = obj;
//修改obj的name属性
obj.name = "法伤十万大C";
//设置obj2为null
obj2 = null;
console.log(obj);
console.log(obj2);
</script>
5)基本数据类型与引用数据类型的属性同否
<script>
var c = 10;
var d = 10;
console.log(c == d);
var obj3 = new Object;
var obj4 = new Object;
obj3.name = "凯尔希";
obj4.name = "M3发射器";
console.log(obj3 == obj4);
</script>
B.比较类型值
a.比较两个引用数据类型时,是比较对象的内存地址,地址不同返回false
K130
1.使用对象字面量来创建一个对象
1)一般形式: var obj = new Object();
2)使用字面量:var obj = { };
注:使用对象字面量,创建对象时可以直接指定对象中的属性
3)语法:{属性名:属性值,属性名:属性值…}
<script>
var obj = {name:"焰影苇草",gender:"女"};
console.log(obj);
</script>
注:对象字面量属性名可加引号也可不加,建议不加;若要使用特殊名,必须加
31.函数 Function(也是对象)(K51)
1.作用:函数中可以封装一些功能(代码),在需要时可以执行这些功能(代码)
2.创建一个函数对象
1)可以将要封装的代码以字符串的形式传递给构造函数
<script>
var fun = new Function("console.log('第一个函数');");
console.log(fun);
</script>
2)调用函数 语法:函数对象();
<script>
var fun = new Function("console.log('第一个函数');");
//console.log(fun);
fun();
</script>
注:封装到函数中的代码不会立即执行,仅储存,函数中的代码会在函数调用时执行
当调用函数时,函数中封装的代码会按照顺序执行
在实际开发中很少使用构造函数来创建一个函数对象
3.使用 函数声明 来创建一个函数
1)语法:function 函数名([形参1,形参2…形参N]){
语句…
}
<script>
function fun2(){
console.log("第二个函数");
alert("嘤嘤嘤嘤嘤");
document.write("┭┮﹏┭┮");
}
console.log(fun2);
fun2();
</script>
4.使用 函数表达式 来创建一个函数
1)语法:var 函数名 = function([形参1,形参2…形参N]){
语句…
}
K131
1.定义一个求两个数和的函数
<script>
function sum(){
console.log(54+99);
}
sum();
</script>
1)可以在函数的()中来指定一个或多个形参,多个形参用,
隔开
2)在调用函数时,可以在()中指定实参
3)调用函数时解析器不会检查实参的类型(块块显示),但true和false显示1和0
4)多于的形参不会被赋值
5)若实参数少于形参数,则没有对应实参的形参显示undefined
<script>
function sum(a,b){
console.log(a+b);
}
sum(55,99);
</script>
K132
1.return
1)可以使用 return 来设置函数的返回值
2)语法:return 值;
3)return后的值将会作为函数的执行结果返回
4)在函数return后的语句都不会执行
5)若return语句后面不跟如何值就相当于返回一个undefined,若不写re也返回un
<script>
function sum(a,b,c){
var d = a + b + c;
return d;
}
var result = sum(4,5,6);
console.log("result = "+result);
</script>
K133
1.定义一个函数,判断一个数字是否为偶数,是返true,否返false
1)原写
<script>
function isOu(num){
if(num % 2 == 0){
return true;
}else{
return false;
}
}
var result = isOu(2);
console.log("result = "+ result);
</script>
2)优化(震惊)
<script>
function isOu(num){
return num % 2 == 0;
}
var result = isOu(2);
console.log("result = "+ result);
</script>
2.定义一个函数,可根据半径计算一个圆的面积,并返回计算结果
<script>
function S(r){
return 3.14*r*r;
}
result = S(4);
console.log("result ="+ result);
</script>
3.创建一个函数,可以在控制台中输出一个人的信息
1)原写
<script>
function hi(name,age,gender,address){
console.log("我是" + name + ",今年" + age + "岁," + "性别" + gender + ",住在" + address);
}
hi("王维纳","19","女","维多利亚");
</script>
2)简化(以对象为参数,修改属性)
<script>
function hi(o){
console.log("我是" + o.name + ",今年" + o.age + "岁," + "性别" + o.gender + ",住在" + o.address);
}
var obj = {
name:"王维纳",
age:"19",
gender:"女",
address:"维多利亚"
}
hi(obj);
</script>
K134
1.使用括号使语句成为一个整体
1)错句不报错
<script>
(function(){
alert("我是一个匿名函数~~~");
})
</script>
2)网页显示(alert作用显示)
<script>
(function(){
alert("我是一个匿名函数~~~");
})();
</script>
3)它变
<script>
(function(a,b){
console.log("a ="+ a);
console.log("b ="+ b);
})(123,456);
</script>
K135
1.对象补充
1)属性值可以是任何数据类型,也可以是函数
<script>
//创建一个对象
var obj = new Object();
//向对象中添加属性
obj.name = "菲亚梅塔";
obj.age ="21";
//对象的属性值可以是任何的数据类型,也可以是个函数
obj.sayName = function(){
console.log(obj.name);
}
//3) console.log(obj.sayName);//1)显示{}内全内容
obj.sayName();
</script>
2)函数也可称为对象的属性
若一个函数作为一个对象的属性保存,那么我们称这个函数是这个对象的方法
调用这个函数就说调用对象的方法,只是名称上的区别
2.枚举对象中的属性
1)for … in 语句
语法:for(var 变量 in 对象){ }
注1:for … in语句 对象中有几个属性,循环体就会执行几次
<script>
var obj ={
name:"菲亚梅塔",
age:"21",
gender:"女"
};
for(var n in obj){
console.log("苦难陈述者");
}
</script>
注2:每次执行时,会将对象中的一个属性的名字赋值给变量
<script>
var obj ={
name:"菲亚梅塔",
age:"21",
gender:"女"
};
for(var n in obj){
console.log(n);
}
</script>
稍微变化(【】传变量)
<script>
var obj ={
name:"菲亚梅塔",
age:"21",
gender:"女"
};
for(var n in obj){
console.log(obj[n]);
}
</script>
K136
例.域外:
<script>
function fun(){
var a = 123;
}
fun();
console.log(a);
</script>
1.作用域:指一个变量的作用范围(JS中有两种作用域)
A.全局作用域
1)直接编写在script标签中的JS代码,都在全局作用域
2)全局作用域在页面打开时创建,在页面关闭时销毁
3)全局作用域中有一个全局对象Window,它代表一个浏览器的窗口
a.Window由浏览器创建我们可以直接使用
4)全局作用域中,创建的对象都会作为Window对象的属性保存
5)全局作用域中,创建的函数都会作为Window对象的方法保存
6)全局作用域中的变量都是全局变量,在页面任意部分都可以访问到
B.函数作用域(部分作用域)
1)调用函数时创建函数作用域,函数执行完毕后,函数作用域销毁
2)每调用一次就会创建一个新的函数作用域,他们之间互相独立
<script>
//创建一个变量
var a = 10;
function fun(){
console.log("a = "+ a);
}
fun();
</script>
3)在函数作用域中可以访问到全局作用域的变量
4)在全局作用域中无法访问到函数作用域的变量
<script>
//创建一个变量
var a = 10;
function fun(){
var b = 20;
console.log("a = "+ a);
}
fun();
console.log("b = "+ b);
</script>
5)当在函数作用域操作一个变量时,它会先在自身作用域中寻找
有则直接使用,无则向上一级作用域中寻找,直到找到全局作用域
<script>
//创建一个变量
var a = 10;
function fun(){
var a = "我是函数中的变量a";
console.log("a = "+ a);
}
fun();
console.log("a = "+ a);
</script>
6)如果全局作用域中依然没有找到,则会报错ReferenceError
<script>
//创建一个变量
var a = 10;
function fun(){
var a = "我是fun函数中的变量a";
function fun2(){
console.log("a = "+ a);
}
fun2();
}
fun();
//console.log("a = "+ a);
</script>
7)在函数中要访问全局变量可以使用window对象
<script>
//创建一个变量
var a = 10;
function fun(){
var a = "我是fun函数中的变量a";
function fun2(){
console.log("a = "+ window.a);
}
fun2();
}
fun();
//console.log("a = "+ a);
</script>
8)在函数作用域中也有声明提前的特性
使用var关键字声明的变量,会在函数中所有的代码执行前被声明
<script>
function fun3(){
console.log(a);
var a =35;
}
fun3();
</script>
9)函数声明也会在函数中所有的代码执行之前执行
<script>
function fun3(){
fun4();
var a =35;
function fun4(){
alert("I`m fun4");
}
}
fun3();
</script>
10)在函数中,不使用var声明的变量会变为全局变量
<script>
var c =33;
function fun5(){
//console.log("c = "+c);
c = 10;
}
fun5();
//在全局输出c
console.log("c = "+ c);
</script>
2.变量的声明提前
<script>
//a = 123;
var a = 123;//相当于Window.a = 123;
console.log("a = " +a);
</script>
1)使用var关键字声明的变量,会在所有的代码执行之前被声明(但不会被赋值)
<script>
console.log("a = " +a);
var a = 123;
</script>
2)若声明变量时不使用var关键字,则变量不会被提前声明
<script>
console.log("a = " +a);
a = 123;
</script>
3)函数声明提前(fun2形式为函数表达式,会被提前声明,但未被赋值)
<script>
fun();
fun2();
//函数声明,会被提前创建
function fun(){
console.log("伊比利亚至高之术");
}
//函数表达式,不会被提前创建
var fun2 = function(){
console.log("多索雷斯至高之术");
};
</script>
a.使用函数声明形式创建的函数function 函数(){ },会在所有代码执行之前被创建
b.所以可以在函数声明前调用函数
c.使用函数表达式创建的函数,不会被声明提前,使用不能在声明前调用
K137-K140
1.隐含的参数
1)解析器在调用函数每次都会向函数内部传递进一个隐含的参数
<script>
function fun(a,b){
console.log("a = " + a + "b = " + b);
}
fun(123,456);
</script>
2)这个隐含的参数就是this,this指向的是一个对象
这个对象我们称为函数执行的上下文对象
<script>
function fun(a,b){
//console.log("a = " + a + "b = " + b);
console.log(this);
}
fun(123,456);
</script>
3)根据函数的调用方式的不同,this会指向不同的对象
<script>
function fun(a,b){
//console.log("a = " + a + "b = " + b);
console.log(this);
}
fun();
var obj = {
name:"号角",
sayName:fun
};
console.log(obj.sayName == fun);
</script>
4)以函数形式调用时,this永远都是window
<script>
function fun(a,b){
//console.log("a = " + a + "b = " + b);
console.log(this);
}
//fun();
var obj = {
name:"号角",
sayName:fun
};
//console.log(obj.sayName == fun);
//obj.sayName();
fun();
</script>
5)以方法的形式调用时,this就是调用的方法
<script>
function fun(a,b){
//console.log("a = " + a + "b = " + b);
console.log(this);
}
//fun();
var obj = {
name:"号角",
sayName:fun
};
//console.log(obj.sayName == fun);
obj.sayName();
</script>
K141-K145
1.看看吧,敲的挺累的,脑子也麻了
<script>
//创建一个name变量
var name = "全局";
//创建一个fun()函数
function fun(){
console.log(name);
}
//创建两个对象
var obj ={
name:"焰影苇草",
sayName:fun
};
var obj2 ={
name:"深池",
sayName:fun
};
fun();
</script>
<script>
//创建一个name变量
var name = "全局";
//创建一个fun()函数
function fun(){
console.log(name);
}
//创建两个对象
var obj ={
name:"焰影苇草",
sayName:fun
};
var obj2 ={
name:"深池",
sayName:fun
};
//fun();
//我们希望调用obj。sayName()时可以输出obj的名字
obj.sayName();
</script>
<script>
//创建一个name变量
var name = "全局";
//创建一个fun()函数
function fun(){
console.log(obj.name);
}
//创建两个对象
var obj ={
name:"焰影苇草",
sayName:fun
};
var obj2 ={
name:"深池",
sayName:fun
};
//fun();
//我们希望调用obj。sayName()时可以输出obj的名字
obj.sayName();
</script>
<script>
//创建一个name变量
var name = "全局";
//创建一个fun()函数
function fun(){
console.log(this.name);//替换了this
}
//创建两个对象
var obj ={
name:"焰影苇草",
sayName:fun
};
var obj2 ={
name:"深池",
sayName:fun
};
//fun();
//我们希望调用obj。sayName()时可以输出obj的名字
obj2.sayName();//2)在替换this之后,替换obj/obj2可显示不同的name
</script>
K146-K147
1)初始
<script>
var obj ={
name:"假日威龙陈",
age:25,
gender:"女",
sayName:function(){
alert(this.name);
}
};
obj.sayName();
</script>
2)叠变
<script>
var obj ={
name:"假日威龙陈",
age:25,
gender:"女",
sayName:function(){
alert(this.name);
}
};
var obj2 ={
name:"星熊",
age:28,
gender:"女",
sayName:function(){
alert(this.name);
}
};
var obj3 ={
name:"羽毛笔",
age:18,
gender:"女",
sayName:function(){
alert(this.name);
}
};
obj3.sayName();
</script>
3)使用工厂方法创建对象
<script>
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("假日威龙陈",25,"女");
var obj3 = createPerson("星熊",28,"女");
var obj4 = createPerson("羽毛笔",18,"女");
console.log(obj2);
console.log(obj3);
console.log(obj4);
</script>
K147-K150
1)其他类
<script>
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;
}
function createDog(name,age){
var obj = new Object();
obj.name = name;
obj.age = age;
obj.sayHello = function(){
alert("汪汪~~~");
};
return obj;
}
var obj2 = createPerson("假日威龙陈",25,"女");
var obj3 = createPerson("星熊",28,"女");
var obj4 = createPerson("羽毛笔",18,"女");
console.log(obj2);
console.log(obj3);
console.log(obj4);
//创建一个狗的对象
var dog = createDog("旺财",3);
dog.sayHello();
</script>
注:使用工厂方法创建的对象,使用的构造函数都是object,所以创建的对象都是object
1.构造函数
1)构造函数就是一个普通的函数,创建方式和普通函数没有区别
不同的是构造函数习惯上首写字母大写
2)构造函数和普通函数的区别就是调用方式的不同
普通函数就是直接调用,而构造函数需要使用new关键字来调用
<script>
//创建一个构造函数,专门用来创建Person对象
function Person(){
}
var per = new Person();
console.log(per);
</script>
3)构造函数的执行流程:
a.立刻创建一个新的对象
b.将新建的对象设置为函数中的this,在构造函数中可以使用this来引用新建的对象
c.逐行执行函数中的代码
d.将新建对象作为返回值返回
<script>
//创建一个构造函数,专门用来创建Person对象
function Person(){
this.name = "安洁莉娜";
}
var per = new Person();
console.log(per.name);
</script>
<script>
//创建一个构造函数,专门用来创建Person对象
function Person(name,age,gender){
this.name = name;
this.age = age;
this.gender = gender;
this.sayName = function(){
alert(this.name);
};
}
var per = new Person("安洁莉娜",17,"女");
var per2 = new Person("玛恩纳",45,"男");
var per3 = new Person("银灰",35,"男");
console.log(per);
console.log(per2);
console.log(per3);
</script>
<script>
//创建一个构造函数,专门用来创建Person对象
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("安洁莉娜",17,"女");
var per2 = new Person("玛恩纳",45,"男");
var per3 = new Person("银灰",35,"男");
var dog = new Dog();
console.log(per);
//console.log(per2);
//console.log(per3);
console.log(dog);
</script>
注:使用同一类构造函数创建的对象,称之为一类对象,也将一个构造函数称为一个类
我们将通过一个构造函数创建的对象,称为该类的实例
4)使用instanceof可以检查一个对象是否为一个类的实例
语法:对象 instanceof 构造函数
若是,返回true,否则返回false
console.log(per instanceof Person);
5)所有的对象都是object的后代
所以任何对象和object做instanceof检查时都会返回true
注1:当以函数的形式调用时,this是window
注2:当以方法的形式调用时,谁调用方法this就是谁
注3:当以构造函数的形式调用时,this就是新创建的那个对象
K151-K153
1.又是例题
<script>
//创建一个Person函数
function Person(name , age , gender){
this.name = name;
this.age = age;
this.gender = gender;
//向对象中添加方法
this.sayName = function(){
alert("Hello大家好,我是"+ this.name);
};
}
//创建一个person的实例
var per = new Person("玛恩纳",45,"男");
per.sayName();
</script>
1)在创建的person函数中,为每个对象都添加了一个sayName方法
目前我们的方法是在构造函数的内部创建的
也就是构造函数每执行一次就会创建一个新的sayName方法
也就是所有实例的sayName都是唯一的
<script>
//创建一个Person函数
function Person(name , age , gender){
this.name = name;
this.age = age;
this.gender = gender;
//向对象中添加方法
this.sayName = function(){
alert("Hello大家好,我是"+ this.name);
};
}
//创建一个person的实例
var per = new Person("玛恩纳",45,"男");
var per2 = new Person("银灰",35,"男");
//per.sayName();
//per2.sayName();
console.log(per.sayName == per2.sayName);
</script>
2)使一万种方法变为一种
<script>
//创建一个Person函数
function Person(name , age , gender){
this.name = name;
this.age = age;
this.gender = gender;
//向对象中添加方法
this.sayName = fun;
}
//将sayName方法在全局作用域中定义
//将sayName方法在全局作用域中定义
//将函数定义在全局作用域污染了全局作用域的命名空间,且定义在全局作用域也很不安全
function fun(){
alert("Hello大家好,我是"+ this.name);
};
//创建一个person的实例
var per = new Person("玛恩纳",45,"男");
var per2 = new Person("银灰",35,"男");
//per.sayName();
//per2.sayName();
console.log(per.sayName == per2.sayName);
</script>
K154-K156
1.原型prototype
1)我们所创建的每一个函数,解析器都会向函数中添加一个属性prototype
这个属性对应一个对象,这个对象就是原型对象
<script>
function Person(){
}
console.log(Person.prototype);
</script>
2)二维表现
3)若函数作为普通函数调用prototype没有任何作用
当函数通过构造函数形式调用时,它所创建的对象中都会有一个隐含的属性
指向该构造函数的原型对象,可以通过__proto__属性访问
<script>
function Myclass(){
}
var mc = new Myclass();
//console.log(Person.prototype);
console.log(mc.__proto__);
</script>
4)原型对象相当于一个公共的区域,使用同一个类的实例都可访问这个原型对象
我们可以将对象中共有的内容,统一设置到原型对象中
当访问一个对象的属性或方法时,它会先在对象自身中寻找,有则直接使用
无则去原型对象中寻找,找到则直接使用
<script>
function Myclass(){
}
//向Myclass的原型中添加属性值
Myclass.prototype.a = 123;
var mc = new Myclass();
var mc2 = new Myclass();
//console.log(Person.prototype);
console.log(mc.a);
</script>
<script>
function Myclass(){
}
//向Myclass的原型中添加属性值
Myclass.prototype.a = 123;
//向Myclass的原型中添加一个方法
Myclass.prototype.sayHello = function(){
alert("hello");
}
var mc = new Myclass();
var mc2 = new Myclass();
//console.log(Person.prototype);
//console.log(mc.a);
//向mc中添加a属性
mc.a = "我是mc中的a";
mc.sayHello();
</script>
K157
1)原
<script>
//创建一个构造函数
function Myclass(){
}
var mc = new Myclass();
console.log(mc.name);
</script>
2)向Myclass的原型中添加一个name属性
in检查对象原型中含有某属性,若对象中无但原型有,返回true
<script>
//创建一个构造函数
function Myclass(){
}
//向Myclass的原型中添加一个name属性
Myclass.prototype.name = "我是原型的名字";
var mc = new Myclass();
console.log(mc.name);
console.log("name"in mc);
</script>
3)可以使用hasOwnProperty()来检查对象自身中是否含有该属性
使用该方法只有当对象自身含有属性时,才会返回true
<script>
//创建一个构造函数
function Myclass(){
}
//向Myclass的原型中添加一个name属性
Myclass.prototype.name = "我是原型的名字";
var mc = new Myclass();
//console.log(mc.name);
//console.log("name"in mc);
//可以使用hasOwnProperty()来检查对象自身中是否含有该属性
console.log(mc.hasOwnProperty("name"));
</script>
<script>
//创建一个构造函数
function Myclass(){
}
//向Myclass的原型中添加一个name属性
Myclass.prototype.name = "我是原型的名字";
var mc = new Myclass();
//console.log(mc.name);
//console.log("name"in mc);
//可以使用hasOwnProperty()来检查对象自身中是否含有该属性
//console.log(mc.hasOwnProperty("name"));
console.log(mc.hasOwnProperty("hasOwnProperty"));
console.log(mc.__proto__.hasOwnProperty("hasOwnProperty"));
</script>
4)原型对象也是对象,它也有原型
当我们使用一个对象的属性或方法时,会在自身中寻找
自身中美元,则直接使用
如果没有则去原型中寻找,如果原型对象中有,则使用
如果没有则去原型的原型中寻找
<script>
//创建一个构造函数
function Myclass(){
}
//向Myclass的原型中添加一个name属性
Myclass.prototype.name = "我是原型的名字";
var mc = new Myclass();
//console.log(mc.name);
//console.log("name"in mc);
//可以使用hasOwnProperty()来检查对象自身中是否含有该属性
//console.log(mc.hasOwnProperty("name"));
//console.log(mc.hasOwnProperty("hasOwnProperty"));
//console.log(mc.__proto__.hasOwnProperty("hasOwnProperty"));
console.log(mc.__proto__.__proto__.hasOwnProperty("hasOwnProperty"));
</script>
K158
1)淳朴开头
<script>
function Person(name , age , gender){
this.name = name;
this.age = age;
this.gender = gender;
}
//创建一个person实例
var per = new Person("玛恩纳",45,"男");
console.log(per);
</script>
2)在页面上打印一个对象时,实际上是输出对象的toString()方法返回值
<script>
function Person(name , age , gender){
this.name = name;
this.age = age;
this.gender = gender;
}
//创建一个person实例
var per = new Person("玛恩纳",45,"男");
var result = per.toString();
console.log("result =" + result);
</script>
3)如果希望输出对象不输出【object object】,可为对象添加tostring()方法
<script>
function Person(name , age , gender){
this.name = name;
this.age = age;
this.gender = gender;
}
//创建一个person实例
var per = new Person("玛恩纳",45,"男");
per.toString = function(){
return"我是一个快乐的小person";
}
var result = per.toString();
console.log("result =" + result);
</script>
K159
1.需要一个垃圾回收机制来处理程序运行过程中产生的垃圾
2.当一个对象没有任何的变量或属性对它引用,我们将永远无法操作该对象,它是垃圾
这种对象会占用大量的内存,导致程序运行变慢
3.在JS中拥有自动的垃圾回收机制,会自动将这些垃圾对象从内存中销毁
我们不需要也不能进行垃圾回收的操作
K160
1.对象:内建对象、宿主对象、自定义对象(*)
2.数组(Array)
1)数组也是一个对象,也是用来存储对象
2)但普通对象用字符串作为属性名,数组使用数字作为索引操作元素
3)索引:从0开始的整数就是索引
4)使用数组:数组的存储性能比普通对象好
5)创建数组对象
<script>
//创建数组对象
var arr = new Array();
</script>
6)向数组中添加元素 语法:数组[索引] = 值
<script>
//创建数组对象
var arr = new Array();
arr[0] = 10;
arr[1] = 33;
console.log(arr);
</script>
6)读取数组中的元素 语法:数组[索引]
<script>
//创建数组对象
var arr = new Array();
arr[0] = 10;
arr[1] = 33;
console.log(arr[0]);
</script>
7)获取数组的长度(元素的个数)语法:数组.length
<script>
//创建数组对象
var arr = new Array();
arr[0] = 10;
arr[1] = 33;
console.log(arr.length);
</script>
8)对于连续数组,使用length可以获取数组的长度(元素个数)
对于非连续数组,使用length会获取到数组的最大的索引+1
9)修改length,若修改的length大于原长度,多于部分会空出来
若小于原长度,则多出的元素被删除
<script>
//创建数组对象
var arr = new Array();
arr[0] = 10;
arr[1] = 33;
arr[2] = 22;
arr[10] = 31;
arr[100] = 90;
console.log(arr.length);
console.log(arr);
//修改length
arr.length = 10;
console.log(arr.length);
console.log(arr);
</script>
10)向数组的最后一个位置添加元素 语法:数组[数组.length]
K161
1)使用字面创建一个数组时,创建时就可以指定数组中的元素
<script>
//创建一个数组
//var arr = new Array();
//使用字面量来创造数组
//var arr = [];
var arr = [1,2,3,4,5,10];
console.log(arr);
</script>
2)使用构造函数创建数组时,也可以添加元素
要将添加的元素作为构造函数的参数传递,元素之间使用,隔开
<script>
//创建一个数组
//var arr = new Array();
//使用字面量来创造数组
//var arr = [];
var arr = [1,2,3,4,5,10];
//console.log(arr);
var arr2 = new Array(10,20,30);
//console.log(arr2);
//创建一个数组,数组中只有一个元素10
arr = [10];
arr2 = new Array(10);
console.log(arr2);
</script>
<script>
//创建一个数组
//var arr = new Array();
//使用字面量来创造数组
//var arr = [];
var arr = [1,2,3,4,5,10];
//console.log(arr);
var arr2 = new Array(10,20,30);
//console.log(arr2);
//创建一个数组,数组中只有一个元素10
arr = [10];
arr2 = new Array(10);
console.log(arr2.length);
</script>
3)数组中的元素可以是任意的数据类型
<script>
//创建一个数组
//var arr = new Array();
//使用字面量来创造数组
//var arr = [];
var arr = [1,2,3,4,5,10];
//console.log(arr);
var arr2 = new Array(10,20,30);
//console.log(arr2);
//创建一个数组,数组中只有一个元素10
arr = [10];
arr2 = new Array(10);
//console.log(arr2.length);
arr = ["hello",1,true,null,undefined];
console.log(arr);
</script>
4)数组中也可以放对象和函数
5)数组中还可以放数组
<script>
//创建一个数组
//var arr = new Array();
//使用字面量来创造数组
//var arr = [];
var arr = [1,2,3,4,5,10];
//console.log(arr);
var arr2 = new Array(10,20,30);
//console.log(arr2);
//创建一个数组,数组中只有一个元素10
arr = [10];
arr2 = new Array(10);
//console.log(arr2.length);
arr = ["hello",1,true,null,undefined];
//console.log(arr);
arr = [[1,2,3],[3,4,5],[5,6,7]];
console.log(arr[1]);
</script>