欢迎光临
我的个人博客网站

JavaScript基础-04-对象、函数

对象


 1. 对象:使用基本数据类型的数据,创建的变量都是独立的,不能成为一个整体

         对象属于一个复合数据类型,在对象中可以保存多个不同数据类型的属性。

对象的分类:

(1)内建对象:由ES标准中定义的对象,在任何的ES的实现中都可以使用(Mathstring,number

(2)宿主对象:由JS的运行环境提供的对象,目前来说主要指由浏览器提供的对象(BOM

(3)自定义对象:由开发人员自己创建的对象

 

2. 创建对象

  使用new关键字调用的函数,是构造函数constructor

  构造函数是专门用来创建对象的函数

  在对象中保存的值称为属性,向对象添加属性

语法:对象.属性名=属性值;

  向obj中添加一个name/gender/age属性

  Obj.name=”孙悟空”;obj.gender=”男”;obj.age=18;

 

3. 读取对象中的属性

语法:对象.属性名

  console.log(obj.gender);

  var obj=new Object();
  obj.name=”孙悟空“;
  obj.age=18;
  obj.gender=”“;
  console.log(obj.name);

 

4. 修改对象属性值

语法:对象.属性名=新值;

   删除对象的属性

语法:delete 对象.属性名

  delete obj.age

 

5. 对象的属性名不强制要求准守标识符的规范,任何名字都可以

  obj.var=”hello”;

 如果要使用特殊的属性名不能采用.的方式来操作,需要使用另一种方式

语法:对象[“属性名”]=属性值

  var obj=new Object();
  obj[“123”]=234;
  var n=”123″;
  console.log(obj[n]);

 

6. 属性值:JS对象的属性值,可以是任意的数据类型,也可以是一个对象。

  var obj=new Object( );
  obj.test=”作比较“;
  var obj2=new Object( );
  obj2.name=”信息“;
  obj.test=obj2;
  console.log(obj.test.name);

 

7. in 运算符

  通过该运算符可以检查一个对象中是否含有指定的属性,若有则返回一个true,没有返回false;

语法:“属性名”in 对象

  console.log(“test2” in obj);

 

8. 基本和引用数据类型

基本数据类型(值类型):保存值

string字符串;number数值;boolean布尔值;null空值;undefined 未定义;

引用数据类型:object对象  保存地址

var obj=new Object();
obj.name=”花花“;
var obj2=obj;
obj.name=”大大
console.log(obj.name);
console.log(obj2.name);

 

JS中的变量都是保存到栈内存中,基本数据类型直接保存在栈内存中,值与值之间是独立存在,修改一个变量不会影响其他的变量。

对象保存在堆内存中的,每创建一个新的对象,就会在堆内存中开辟一个新的空间,而变量保存的是对象的内存地址(对象的引用)。如果两个变量保存的是同一个对象引用,当一个通过一个变量修改属性时,另一个也会受到影响。

变量

 

 

b

123

a

123

 
1. 对象字面量

使用对象字面量来创建一个对象,使用对象字面量,可以创建对象时,直接指定对象中的属性。

语法:{属性名:属性值,属性名:属性值,……}

对象字面量的属性名可以加引号也可以不加,建议不加;但特殊的名字,则必须加引号。

var obj={
   name:’猪八戒‘,
   age:18,
   gender:’‘,
   ‘123’:123
};
console.log(obj);

函数function


 

1. 函数也是一个对象,函数可以封装一些功能(代码),在需要时可以执行这些功能(代码)

创建一个函数对象:

var fun=new Function()  

可以将要封装的代码以字符串的形式传递给结构函数,封装到函数中的代码不会立即执行。函数中的代码会在函数调用的时候执行。调用函数时,函数中封装的代码会按照顺序执行。

调用函数:函数对象()   //fun( );

var fun=new Function(“console.log(‘第一个函数‘)”)
fun();

 

2.  使用函数声明来创建一个函数

语法:function 函数名([形参1,形参2….形参N]{

语句…….

}

function f() {
   console.log(‘er个函数‘)
}
f();

 

3.  使用函数表达式来创建一个函数

var 函数名=function ([形参1,形参2形参n]) {

语句….

}

 

4. 函数()中可以指定一个或多个形参,形参之间利用,隔开,声明形参就相当于在函数内部声明对应的变量,但不赋值。

在调用函数时,可以在()中指定实参,将会赋值给函数中对应的形参。

 

注意:调用函数时解析器不会检查实参的类型。实参可以是任意的数据类型。

调用函数时,解析器也不会检查实参的数量,多余实参不会被赋值。若实参的数量少于形参的数量,则没有对应实参的形参将是undefined

  1. 返回值

可以使用return来设置函数的返回值

语法:return

var sum=function (a,b) {
   var c=a+b;
   return c;}
sum(3,5);

return后的值将会作为函数的执行结果返回,可以定义一个变量,来接收该结果

var sum=function (a,b) {
   var c=a+b;
   return c;}
var result=sum(3,5);
console.log(result);

  2. 返回值的类型

返回值可以是任意类型:对象,数值,函数…..

function fun1() {
      return {name:’黎明‘};}
var a=fun1();
console.log(‘a=’+a.name);

嵌套函数:fun2函数在fun1内,fun1调用fun2,外部执行fun1,就会调用fun2

function fun1() {
      function fun2() {
         alert(‘我是fun2′)}
      fun2();}
fun1();//a=fun1();console.log(a);//a();//fun1()();

 

5. 立即执行函数

函数定义之后立即被执行,往往只会执行一次。

(function () {
      alert(‘这是一个匿名函数‘);
})();

 

6.  方法

函数也可以称为对象的属性,一个函数作为对象的属性保存,该函数称为这个对象的方法。调用函数就是调用对象的方法。—–封装在对象中的函数叫方法

var obj=new Object();
obj.name=’小明‘;
obj.sayName=function () {
   console.log(obj.name);};
obj.sayName();

 

7.  枚举对象中的属性

使用for….in语句

语法:

for(var 变量 in 对象){

console.log(‘hello’);}           //出现几次就执行几次

每次执行时,会将对象中的一个属性的名字赋值给变量

var obj=new Object();
obj.name=’小李‘;
obj.age=43;
obj.gender=’‘;
obj.address=’华夏小区‘;
for(var n in obj){
   console.log(n);属性名}  //console.log(obj[n]);属性值

 

8. 作用域

一个变量的作用范围:

全局作用域:直接编写在script标签中的JS代码,在页面打开时创建,在页面关闭时销毁。在全局作用域中有一个全局对象window,代表一个浏览器的窗口,由浏览器创建可直接使用。

创建的变量都可以作为window对象的属性保存;创建的函数都会作为window对象的方法保存。

全局变量,在页面任意的部分都可以访问。

var a=10;
console.log(window.a);

 

9.  变量声明提前:使用var关键字声明的变量,会在所有代码执行之前被声明,不会赋值

console.log(a);
var a=10;  //不会报错,但a=10会报错

 

10.  函数声明提前:使用函数声明形式创建的函数function函数(){},会在所有代码执行之前被创建,所以可以在函数声明前来调用。

  使用函数表达式创建的函数,不会被声明提前,所以不能在声明前调用。

fun();  //会被执行!!
fun2(); //不会被执行!!
function fun() {
   console.log(‘我是一个fun函数‘);}
var fun2=function () {
   console.log(‘我是一个fun2函数‘)}

 

11. 函数作用域:调用函数时创建函数作用域,函数执行完毕以后,函数作用域销毁。每调用一次函数就会创建一个新的函数作用域,之间相互独立。

函数作用域中可以访问到全局变量,全局作用域无法访问到函数作用域的变量。在函数作用域操作一个变量时,会先在自身作用域中寻找,若有直接使用,若没有则向上一级作用域中寻找,直到找到全局作用域,若没有就会报错。

在函数作用域也会有声明提前的特性,使用var关键字声明的变量,会在函数中所有的代码执行之前被声明。

函数中,不适用var声明的变量都会变成全局变量。

var c=10;
function fun1() {  //fun1(c) 定义形参=在函数作用域中声明变量
   console.log(c);
   c=10;  //var c=10结果为undefined
}
fun1();

  1. debug

F12–>脚本–>断点

    2. this

解析器在调用函数每次都会向函数内部传递进一个隐含的函数thisthis指向的是一个对象,根据函数的调用方式的不同,this会指向不同的对象。

谁调用函数,this就会指向谁;

 

12.  函数方式调用,this指向window

function fun() {
   console.log(this);
}

fun();          //结果为windo

 

以方法形式调用时,this就是调用方法的对象

function fun() {console.log(this);}
var obj={name:’小明‘,
   sayName:fun};
obj.sayName();   //结果为对象obj

 以构造函数的形式调用时,this就是新创建的那个对象

 

13.  根据调用者的不同调用:

var name=’全局‘;
function fun() { console.log(this.name);} //不用this只会显示全局
var obj1={ name:’小明‘,
   sayName:fun};
var obj2={ name:’花花‘,
   sayName:fun};
obj2.sayName();

 

14.  使用工厂方法创建对象

通过该方法大批量的创建对象,将公共代码写成一个函数,不用重复写代码

缺点:创建对象都是object这个类型,导致无法区分多种不同类型的对象。

function createPerson(name,age,gender) {
   // 创建一个新的对象
   var obj=new Object();
   // 向对象中添加属性
   obj.name=name;
   obj.age=age;
   obj.gender=gender;
   obj.sayName=function () {
      console.log(this.name); }
   // 将新的对象返回
   return obj;}
var obj1=createPerson(‘小敏‘,13,’‘);
obj1.sayName();

 

15. 构造函数 new

创建一个构造函数,专门来创建Person对象,构造函数是一个普通的函数,创建方式和普通函数没有区别,不同的是构造函数习惯上首字母大写

区别:构造函数和普通函数的区别就是调用方式不同,普通函数直接调用,构造函数需要使用new关键字来调用。

 

构造函数的执行流程:

  1. 立刻创建一个新的对象
  2. 将新建的对象设置为函数中this,在构造函数中可以使用this来引用新建的对象
  3. 逐行执行函数中的代码
  4. 将新建的对象作为返回值返回

 

普通函数:

function Person() {
}
var per=Person();   //结果为undefined

 

构造函数:

function Person() {
   alert(this);
}
var per=new Person();
console.log(per);    //结果为 object

 

例如:(类)

function Person(name,age,gender) {
   this.name=name;
   this.age=age;
   this.gender=gender;
   this.sayName=function () {
      alert(this.name);
   }
}
var per=new Person(‘花花‘,12,’‘);
console.log(per);

 

 16.  使用instanceof可以检查一个对象是否是一个类的实例

语法:对象 instanceof 构造函数  (per  instanceof  Person

如果是,则返回true,否则返回false

console.log(per instanceof Person);
console.log(dog instanceof Person);

 

17. 所有的对象都是object的后代,所以任何对象和Objectinstanceof检查时会被返回true

console.log(per instanceof Object);

 

18.   构造函数的修改

创建一个Person构造函数:在Person构造函数中,为每一个对象都添加一个sayName方法,目前的方法是在构造函数内部创建的,所以构造函数每次执行都会创建一个新的sayName方法,每一个构造函数sayName都是唯一的。

解决方法:

1.sayName方法在全局作用域中定义

function Person(name,age,gender) {
   this.name=name;
   this.age=age;
   this.gender=gender;
   this.sayName=fun;}
function fun() {
   alert(this.name);}

但是将函数定义在全局作用域,污染了全局作用域的命名空间,而且很不安全

2. 原型prototype:创建的每一个函数,解析器都会向函数中添加一个属性prototype

该属性对应一个对象,这个对象就是原型对象

如果函数作为普通函数调用prototype没有任何作用;当函数以构造函数的形式调用时,它所构建的对象中都会有一个隐含的属性,指向该构造函数的原型对象,可通过__proto__来访问该属性。

 

原型对象==一个公共区域,所有同一个类的实例都可以访问到这个原型对象,可以将对象中共有的内容,统一设置到原型对象中。

当访问对象的一个属性或方法时,它会先在对象自身中寻找,若有则直接使用。

function Person() { }
// Person的原型中添加属性a
Person.prototype.a=123;
//Person的原型中添加一个方法
Person.prototype.sayHello=function () {
   alert(‘hello’);}
var mc1=new Person();
var mc2=new Person();
mc1.a=’我是mc中的a’;
console.log(mc1.a); //先在mc1中寻找,有,a=’我是mc中的a’
console.log(mc2.a); //mc中未找到,在原型对象中寻找a=123
mc2.sayHello();

 

20.  原型对象

使用in检查对象中是否含有某个属性时,若对象中没有但原型中有,返回true

使用对象的hasOwnProperty()来检查对象中是否含有该属性,使用该方法只有当对象自身含有属性时,才会返回true

function MyClass() {}使用对象的hasOwnProperty()来检查对象中是否含有该属性
MyClass.prototype.name=’我是原型中的名字‘;
var mc=new MyClass();
//使用in检查对象中是否含有某个属性时,若对象中没有但原型中有,返回true
// console.log(‘name’ in mc);
//使用对象的hasOwnProperty()来检查对象中是否含有该属性
         mc.a=123;
         console.log(mc.hasOwnProperty(‘name’)); //结果false
         console.log(mc.hasOwnProperty(‘a’));  //结果true

 原型对象也是对象,所以它也有原型,当使用一个对象的属性或方法时,会先在自身中寻找,自身有则直接使用,若没有则去原型对象中寻找,若原型对象中有就使用,若没有则去原型的原型中寻找,直到找到Object对象的原型,Object象的原型没有原型,如果在Object中依然没有找到,则返回undefined

console.log(mc.__proto__.__proto__.hasOwnProperty(‘hasOwnProperty’)) 

赞(0) 打赏
未经允许不得转载:张拓的天空 » JavaScript基础-04-对象、函数
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

专业的IT技术经验分享 更专业 更方便

联系我们本站主机

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏