l第一种构造法:new Object
var a = new Object();
a.x = 1, a.y = 2;
l第二种构造法:对象直接量
var b = { x : 1, y : 2 };
l第三种构造法:定义类型
function Point(x, y){
this.x = x;
this.y = y;
}
var p = new Point(1,2);
2.访问对象
l 中括号表示法: hero['name'] 。、l 点号表示法: hero.name 。l如果访问的属性不存在,会返回undefined。
l方法名后加一对括号:hero.say()。l像访问属性一个访问方法:hero['say']()。
3.删除属性与方法
//创建一个空对象
var hero = {};
//为hero对象增加属性和方法
hero.name = "javascript";
hero.value = "helloworld";
hero.sayName = function(){return "hello " + hero.name;};
//测试
alert(hero.name); //output javascript
alert(hero.sayName()); //output hello javascript
//删除hero对象的name属性
delete hero.name;
//测试
alert(hero.sayName()); //output hello undefined
4.使用this值
//创建一个空对象
var hero = {};
//为hero对象增加属性和方法
hero.name = "javascript";
hero.value = "helloworld";
hero.sayName = function(){return "hello " + this.name;};
//测试
alert(hero.name); //output javascript
alert(hero.sayName()); //output hello javascript
总结:
l这里的this实际上引用的是“这个对象”或“当前对象”。lthis的用法,大部分人的使用问题都比较多。所以不建议过多使用!
5.内建对象
l内建对象大致上可以分为三个组:
l数据封装类对象 —— 包括Object、Array、Boolean、Number和String。这些对象代表着javascript中不同的数据类型,并且都拥有各自不同的typeof返回值,以及undefined和null状态。
l工具类对象 —— 包括Math、Date、RegExp等用于提供遍历的对象。l错误类对象 —— 包括一般性错误对象以及其他各种更特殊的错误类对象。它们可以在某些异常发生时帮助我们纠正程序工作状态。
6.Object对象
lObject是javascript中所有对象的父级对象,这意味着所有对象都继承于Object对象。l创建一个空对象:
var object = {};
var obj = new Object();
7.Array对象
lArray对象用于在单个的变量中存储多个值。l创建一个空Array对象:
var object = {};
例如1: // 反转字符串示例var obj = new Array();
//定义一个字符串
var str = "a,b,c,d,e,f,g";
//利用String对象的split()方法,将字符串切割成一个数组
var arr = str.split(",");
//利用Array对象的reverse()方法,将数组中元素的顺序颠倒。
arr = arr.reverse();
//测试打印
alert(arr.toString());
8.String对象
lString对象与基本的字符串类型之间的区别:
var str = "hello";
var obj = new String("world");
alert(typeof str); //typeof string
例如1: // 判断字符串是否包含指定字符串示例alert(typeof obj); //typeof object
//定义两个要判断的字符串
var str = "abcdefg";
var substr = "efg";
/*
* 定义判断字符串是否包含指定字符串的函数
* * 第一个参数:要判断的字符串
* * 第二个参数:指定的字符串
*/
function sub(str,substr){
//将判断的字符串定义成String对象
var string = new String(str);
//截取判断的字符串
var result = string.substr(string.indexOf(substr),substr.length);
/*
* 判断截取后的字符串是否为空
* * 为空,说明不包含指定字符串
* * 不为空,说明包含指定字符串
*/
if(result==substr){
return true;
}else{
return false;
}
}
alert(sub(str,substr));
l函数本身也是一个包含了方法和属性的对象。而现在我们要研究的就是函数对象的另一个属性 —— prototype。
l利用原型添加方法与属性l利用自身属性重写原型属性l扩展内建对象
l利用原型添加方法与属性
l下面创建一个新的函数对象,并设置一些属性和方法:
function Hero(name, color){
this.name = name;
this.color = color;
this.whatareyou = function(){
return "I am a " + this.color + " " + this.name;
}
}
var hero = new Hero("javascript","red");
alert(hero.whatareyou()); //output I am a red javascript
l为上面的Hero函数对象增加一些属性和方法:
Hero.prototype.price = 100;
Hero.prototype.rating = 3;
Hero.prototype.getInfo = function(){
return "Rating: " + this.rating + " , Price: " + this.price;
}
alert(hero.getInfo()); //output Rating: 3 , Price: 100
l上面的方式,也可以这样去做:
Hero.prototype = {
price : 100,
rating : 3,
getInfo : function(){
return "Rating: " + this.rating + " , Price: " + this.price;
}
};
l 利用自身属性重写原型属性
l如果对象的自身属性与原型属性同名该怎么办呢?答案是对象自身属性的优先级高于原型属性。
function Hero(){
this.name = "jscript";
}
Hero.prototype.name = "javascript";
var hero = new Hero();
alert(hero.name); //output jscript
delete hero.name;
l扩展内建对象alert(hero.name); //output javascript
//为原型 Array对象增加一个判断的函数
Array.prototype.inArray = function(color){
for(var i = 0, len = this.length; i < len; i++){
if(this[i] === color){
return true;
}
}
return false;
}
//定义一个Array对象
var a = ["red", "green", "blue"];
//测试
alert(a.inArray("red")); //true
alert(a.inArray("yellow")); //false
10.继承
l如果两个类都是同一个实例的类型,那么它们之间存在着某些关系,我们把同一个实例的类型之间的泛化关系称为“继承”。l继承关系至少包含三层含义:l子类的实例可以共享父类的方法。l子类可以覆盖父类的方法或扩展新的方法。l子类和父类都是子类实例的“类型”。l在javascript中,并不支持“继承”。也就是说,javascript中没有继承的语法。从这个意义上来说,javascript并不是直接的面向对象语言。
11.原型链
function A(){
this.name = "a";
this.toString = function(){return this.name};
}
function B(){
this.name = "b";
}
function C(){
this.name = "c";
this.age = 18;
this.getAge = function(){return this.age};
}
B.prototype = new A();
C.prototype = new B();
解释说明:
l将对象直接创建在B对象的prototype属性中,并没有去扩展这些对象的原有原型。l通过new A ( ) 另创建了一个新的实体,然后用它去覆盖该对象的原型。ljavascript是一种完全依靠对象的语言,其中没有类(class)的概念。l因此,需要直接用new A ( ) 创建一个实体,然后才能通过该实体的属性完成相关的继承工作。l完成这样的继承实现之后,对 A ( ) 所进行的任何修改、重写或删除,都不会对 B ( ) 产生影响。
l 只继承于原型:
function A(){}
A.prototype.name = "a";
A.prototype.toString = function(){return this.name};
function B(){}
B.prototype = A.prototype;
B.prototype.name = "b";
function C(){}
C.prototype = B.prototype;
C.prototype.name = "c";
C.prototype.age = 18;
C.prototype.getAge = function(){return this.age};
l 对象之间的继承(扩展内容,可以不会)(浅复制)
//该函数接受一个对象并返回它的副本
function extendCopy(p){
var z = {}; //定义一个空的对象z
for(var i in p){ //var i =0 ; i < p.length ; i++
z[i] = p[i]; //都当做数组处理的话,可以理解
}
//uber属性:将p作为z的父级,将z指向p的原型
z.uber = p;
return z;
}
//定义对象a,但是对象a不是函数对象
var a = {
name : "a",
toStr : function(){return this.name;}
}
//定义对象b,但是对象b不是函数对象
var b = extendCopy(a);
b.name = "b";
b.toStr = function(){return this.uber.toStr() + " , " + this.name;};
//定义对象c,但是对象c不是函数对象
var c = extendCopy(b);
c.name = 18;
alert(c.toStr()); //output a , b , 18