块block
快语句常用于组合0-多个语句。用一对{}定义
表达式语句
greeting ="Hello"+name;//赋值语句
i*=3;
count++;
delete o.x; //删除
alert(greeting); //函数
window.close();
y=Math.cos(x);
复合语句和空语句
function(){
x=Math.PI;
console.log("x="+x);
}
//初始化一个数组
for(i=0;i<a.length;a[i++]=0);
1.if…else…; else if
2.switch
3.while,do/while,for(in)
4.break,continue,return
5.标签语句
6.throw
<script>
var str="Hello";
function demo(){
try{
var e=document.getElementById("txt").value;
if(e==""){
throw "请输入:";
}
}catch (err){
alert(err);
}
}
demo();
</script>
7.try/ catch/ finally
<script>
var str="Hello";
function demo(){
try{
alert(str);
}catch (err){
alert(err);
}
}
demo();
</script>
8.with(逐渐用的少了)
嵌套很深的时候用with简化代码
document.forms[0].name.value;
document.forms[0].address.value;
document.forms[0].email.value;
//直接访问表单元素
with(document.forms[0]){
name.value="";
address.value="";
email.value="";
}
9.debugger
以调试模式运行
10.use strict
严格代码解析
11.for in
严格模式
一种特殊的执行模式,修复了语言上的不足,提供更强的错误检查,并增强安全性
和普通模式的区别
- 不允许用with
- 不允许没有声明变量赋值
- argument变为参数的静态副本
- 报错delete参数,不可配置属性报错
5.对象字面量重复属性名报错
6.禁止八进制字面量
7.eval独立作用域
function func(){
'use strict';
}
对象
1.对象常见用法:创建、设置、查找、删除、检测、枚举
2.属性特性:可写(是否可以设置值)、可枚举(是否能通过for/in循环返回)、可配置(是否可以删除或修改)
3.对象特性:原型、类、扩展标记
4.分类
(1)内置对象:ECMAScript规范定义的对象或类。如:字符串、数值、数组、函数、日期、正则表达式
(2)宿主对象:JavaScript的解释器所嵌入的宿主环境定义的(如Web浏览器)。如:表示网页结构的HTMLElement
(3)自定义对象:运行中的Javascript代码创建的对象
(4)自有属性:直接在对象中定义的属性
(5)继承属性:在对象的原型对象中定义的属性
对象的构造
1.对象包含一系列的无序的属性
2.每个属性都有一个字符串key和对应的value
??什么是key
var obj={};
obj[1]=1;
obj["1"]=2;
obj; //Object{1:2}
对象结构详解
var obj={};
obj.x=1; //通过两句赋值创建两个属性
obj.y=2;
function f(){};
f.prototype.z=3;
var obj=new f();/*指向的对象obj,它的原型就会指向构造器的prototype属性,值为3.*/
如果访问obj.z属性,发现在对象中没有找到,就会继续查找它的原型,直到找到为止。
除此之外,还有class和extensible标签
创建对象
1.对象直接量
var empty={}; //没有任何属性
var point={x:0,y:0}; //两个属性
var book={
"main title":"JavaScript", //属性名有空格,必须用字符串表示
'sub-title':"The Definitive Guide", //属性名有连字符,必须用字符串
"for":"all audiences", //保留字,必须用引号
author:{
firstname:"David",
surname:"Flanggan"
}
};
2.通过new创建对象
var a=new Array();
var r=new RegExp("js");
3.原型链
普通对象都有原型
所有内置构造函数都具有一个继承自Object.prototype的原型
一系列原型对象就是原型链
/*1.大多数对象都有默认的toString方法,因为它们原型链的末端都有一个Object.prototype*/
typeof obj.toString; //'function'
/*2.z继承自foo.prototype*/
'z' in obj; //true
/*3.但z并不是直接在obj对象上的,而是对象的原型链上的*/
obj.hasOwnProperty('z'); //false
obj.z=5;
obj.hasOwnProperty('z'); //true,obj添加新的属性z
foo.prototpye.z; //仍然是3
obj.z; //返回5,obj对象有z属性,并不会继续查找
obj.z=nudefined;
obj.z; //返回undefined
delete obj.z;//true,删除obj的z属性,才能访问到原型链的z属性3
obj.z; //返回3
delete obj.z;//true,再继续删除obj的z属性,根本不会影响到原型链的z属性
obj.z; //还是3!!!
4.Object.create()创建对象
Object.create()是一个系统内置的函数,一般接受一个对象参数
它也有Object.prototype原型
var obj=Object.create({x:1});
obj.x; //1
typeof obj.toString //"function"
obj.hasOwnProperty('x'); //false
var obj=Object.create(null);
obj.toString; //undefined
5.通过函数创建对象
function people(name,age){
this.name=name;
this.age=age;
}
son=new people("Mike",18);
document.write("name:"+name+" age:"+age);
属性的查询和设置
//查询
var author=book.author;
var title=book["main title"]; //[]内必须是字符串
//设置
book.author="David";
book["main title"]="JavaScript";
继承
在原型链中一直查找,直到null为止
var o={};
o.x=1;//给o一个x属性
var p=inherit(o);
p.y=2;//p继承o,且给p一个y属性
var q=inherit(p);
q.z=3;
var s=q.toString();
q.x+q.y //返回3,x和y分别继承自o和p
首先要检查原型链,判定是否允许复制操作
//例如,继承对象含一个只读属性x
var unitcircle={r:1};
var c=inherit(unitcircle);
c.x=1;
c.y=2;
c.r=2;/*覆盖继承来的r属性*/
unitcircle.r; /*返回1,原型对象没有修改*/
属性访问错误
查询不存在的属性不会报错,返回undefined
var obj={x:1};
obj.y; //undefined
查询不存在的对象(如null和undefined)的属性,会报错
var yz=b=obj.y.z; //报错
obj.y.yz; //报错
设置属性失败:
1.继承只读属性
2.继承已继承且只读的属性
3.没有使用setter方法继承属性???
book.subtitle;//返回undefined,subtitle属性不存在
var length=book.subtitle.length;//抛出类型错误异常,undefined没有length属性
//避免出错的方法
var len=undefined;
if(book){
if(book.subtitle) len=book.subtitle.length;
}
/*或者*/
var len=book&&book.subtitle&&book.subtitle.length;
删除属性
delete只是断开属性和数组对象的联系,而不会去操作属性
delete book.author;//book不再有author属性
delete book["main title"];//book不再有main title属性
只能删除自有属性,不能删除继承属性
删除成功没有任何副作用,返回true
var o={x:1}
delete o.x; //删除x,返回true
delete o['x']; //true
o.x; //undefined
delete o.x; //再次删除依然返回true,此时表示在这个步骤时已经是成功删除状态,并非指在此步骤进行删除的过程
不能删除会返回false的情况
删除不可配置属性(例如,通过var变量声明和函数声明创建的全局对象的属性),报错:类型错误
delete Object.prototype;//不可配置,不能删除
var x=1;//声明一个全局变量
delete this.x;//返回false
var f(){};
delete this f;//返回false
this.x=1;//声明一个可配置的全局属性
delete x;//返回true
检测属性
检测集合中成员的所属关系,通过in运算符、hasOwnPreperty()、propertyIsEnumerable()方法、或者属性查询
in运算符
var cat=new Object;
cat.legs=4;
cat.name="Kitty";
'legs' in cat;//true
"toString" in cat;//true,会向原型链查找
'horn' in car;//false
hasOwnPreperty()
cat.hasOwnPreperty('legs');//true
car.hasOwnPreperty('toString');//false
propertyIsEnumerable()是否可枚举
cat.propertyIsEnumerable('legs');//true
car.propertyIsEnumerable('toString');//false
自定义对象的属性使枚举标签为false
三个参数:对象,属性名称,对象(可以设置标签,默认enumerable:false)
Object.defineProperty(cat,'price',{enumerable:false,value:1000});
propertyIsEnumerable('price');//false
cat.hasOwnPreperty('price');//true
枚举属性
var o={x:1,y:2,z:3};
'toString' in o;//true
o.propertyIsEnumerable('toString');//false
var key;
for(key in o){ //遍历属性
console.log(key); //x,y,z,默认不可枚举
}
var obj=Object.create(o);//创建一个对象obj,它的原型指向o
obj.a=4;
var key;
for(key in obj){
console.log(key); //a,x,y,z,默认可枚举
}
var obj=Object.create(o);
obj.a=4;
var key;
for(key in obj){
if(obj.hasOwnPreperty(key)){ //加obj.hasOwnPreperty判断,只想访问对象属性,而不想访问原型链
console.log(key); //a
}
}
get与set方法(待补充)
var cat={
name:'Kitty',
legs:'4',
get age(){
return new Date().getFullYear()-2017;
},
set age(val){
console.log('Age can\'t be set to'+val);
}
}
console.log(cat.age); //2
cat.age=100; //Age can\'t be set to 100
属性标签
属性级的设置权限
/*该方法返回一个对象,可以显示当前对象下的所有标签*/
Object.getOwnPropertyDescriptior({pro:true},'pro');//两个参数:要判断的对象,字符串的属性名
//Object{value:true,writable:true,enumerable:true,configurable:true}
Object.getOwnPropertyDescriptior({pro:true},'a');
//undefined
创建一个对象,并且管理和设置属性
1.Object.defineProperty三个参数:要接受属性的对象,字符串类型的属性的名字,对象里面具体的标签的值
var person{};
Object.defineProperty(person,'name',{
configurable:false,//不可再被修改,不能通过delete删除
writable:false,//不可写
enumerable:true,//不可被遍历和枚举,影响for in是否会出现
value:'Adeline'
});
person.name;//Adeline
person.name=Cpoy;
person.name;//still Adeline,因为已经设置了不可写,不可修改
delete person.name;//false,因为已经设置不可删除
2.Object.defineProperties两个参数:定义属性的对象,复杂的对象(定义的属性:{属性:属性值,标签:true/false})
标签不特殊写默认为false
Object.defineProperties(person,{
title:{value:'stuff',enumerable:true},
salary:{value:50k,enumerable:true,writable:true}
});
Object.getOwnPropertyDescriptior(person,'salary');
//Object{value:50k,writable:true,enumerable:true}
3.复杂对象还可以用函数定义,形成更复杂的属性
对象标签
[[proto]]原型标签
[[class]]表示对象类型
var toString=Object.prototype.toString;
toString.call(null); //"[Object Null]"
toString.call(undefined); //"[Object Undefined]"
toString.call(1); //"[Object Number]"
[[extensible]]对象是否可扩展
var obj={x:1,y:2};
Object.isExtensible(obj);//默认为true
Object.preventExtensions(obj);
Object.isExtensible(obj);//修改成了false
obj.z=1;
obj.z;//undefined
Object.getOwnPropertyDescriptor(obj,'x');
//Object{value:1,writable:true,enumerable:true,configurable:true}
Object.seal(obj);
Object.getOwnPropertyDescriptor(obj,'x');
//Object{value:1,writable:true,enumerable:true,configurable:false}
Object.isSealed(obj);//true
Object.freeze(obj);
Object.getOwnPropertyDescriptor(obj,'x');
//Object{value:1,writable:write,enumerable:true,configurable:false}
Object.isFrozen(obj);//true
属性的序列化
var obj={x:1,y:true,z:[1,2,3],nullVal:null};
JOSN.stringify(obj);//"{"x":1,"y":true,"z":[1,2,3],"nullVal":null}"
obj={val:undefined,a:NaN,b:Infinity,c:new Date()};
JOSN.stringify(obj);//"{"a":null,"b":null,"c":"2017-08-8T07:36.910Z"}"
obj=JOSN.parse('{"x":1}');
obj.x;//1
其他对象方法
toString转字符串
var obj={x:1,y:2};
obj.toString=function(){return this.x+this.y};
"Result is"+obj;//"Result is 3";
+obj//3
toJOSON字符串序列化
var obj={
x:1,
y:2,
o:{
o1:1,
o2:2,toJSON:function(){
retrun this.o1+this.o2;
}
}
};
JSON.stringify(obj);//"{"x":1,"y":2,"o":3}"
valueOf转基本类型
obj.valueOf=function(){return this.x+this.y+100;};
+obj;//103