第四章 javascript的语句、对象、属性笔记摘要

块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

严格模式

一种特殊的执行模式，修复了语言上的不足，提供更强的错误检查，并增强安全性
和普通模式的区别

1. 不允许用with
2. 不允许没有声明变量赋值
3. argument变为参数的静态副本
   
4. 报错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