js对象和函数的详细说明

一、目标

它是人们想研究的任何东西，既能表达具体的事物，又能表达抽象的规则、计划或事件。无序的属性集合，每个属性可以保存一个值(原始值、对象、函数)

对象的特性封装在：中，尽可能隐藏对象的一些细节来保护它。仅保留有限数量的接口与外部通信。

在js中使用{}、[]来定义数组和对象

1.{}大括号表示定义一个对象。在大多数情况下，必须有成对的属性和值，或者函数。

2.[]中的括号表示数组，也可以理解为数组对象。

3.{}与[]一起使用。前面说过，{}是一个对象，[]是一个数组，我们可以组成一个对象的数组。

调用时，对象的属性与。(点)/对象名['属性名']，用[下标]访问数组。

其次，Js有两种自定义对象的方法

1.对象初始化器构造对象

Var婚姻={name : '婚姻'，age :2，shout: function () {alert('我是：' this.name '，今年：' this . age ')；}，action:function(){ alert('会吃')；} };alert(marry . name)；警惕(结婚年龄)；marry . shock()；marry . action()；2.分别定义对象的内存

当我们创建一个对象ren时，我们会在堆栈内存中保存一个地址，堆栈是一个长度不变的地址。

并且堆栈中的地址对应于堆中的存储地址。堆中的存储地址，只要实例化就会在堆中打开一个空间，这个地址就是栈的地址，而内容就是实例化对象中的内容，比如名字、性别和eat。您可以通过地址引用来访问内部的属性和方法。

当我们再次实例化一个对象时，我们将保存另一个地址并创建一个空间。

代码片段、公共属性或方法放在代码片段中，而不是堆中。只执行一次，节省内存空间。代码段将保留在内存空间中，直到浏览器关闭。使用原型方法创建

var ren={ }；张三；Ren.sex='男'；ren . eat=function(){ alert(' eat ')；} alert(ren . name)；alert(ren[' name '])；3.工厂模式

工厂模式虽然解决了多次创建相似对象的重复问题，但并没有解决对象识别的问题，即在typeof之后显示object，但具体是什么对象并没有显示。

函数createPerson(姓名、年龄、职务){ var o=new Object()；o.name=nameo.age=年龄；o.job=jobo . SayName=function(){ alert(this . name)；//这是指o}返回o；} var person1=create person ('Tom '，23，' chef ')；person 1 . SayName()；4.构造器模式

构造器模式和工厂模式的区别

1.没有明确的创建对象。

2.属性和方法被分配给此对象。

3.没有退货单。

4.函数名的首字母大写。

构造器模式之所以优于工厂模式，是因为构造器模式中的object实例(Person1)可以通过构造器属性或instanceof运算符验证Person1既是Object的实例，也是person的实例，还可以证明所有对象都来自Object。

功能人员(姓名、年龄、工作){ this.name=namethis.age=年龄；this.job=jobthis . SayName=function(){ alert(this . name)；//这是person } } var person 1=new person(' Tom '，23，' chef ')；person 1 . SayName()；函数Dog(姓名、年龄){ this.name=namethis.age=年龄；this . shock=function(){ alert('我是：' this.name '，今年是：' this . age ')；};This.action=function(){ alert('会吃')；};} var jack=new Dog('jack '，1)；alert(jack . name)；alert(jack . age)；jack . shock()；jack . action()；5.全球范围

但是，构造函数也有缺点。对象是引用类型，对象实例化不是指针的改变，而是对象的方法和属性的简单复制。假设一个对象有成千上万个实例，它会复制成千上万个具有相同功能的方法，这显然是不可取的。

我们还可以在构造函数之外对sayName()函数的定义进行战斗，这样我们将sayName属性设置为等于全局sayName函数，这样实例化的对象在全局范围内共享同一个sayName()，从而解决了多次创建构造函数对象方法的问题。但是全局作用域定义的sayName()函数只能被一个对象调用来谈论全局作用域。如果构造函数对象的方法很多，那么需要定义很多全局函数，于是原型模式就产生了。

功能人员(姓名、年龄、工作){ this.name=namethis.age=年龄；this.job=jobthis.sayName=sayName}函数说出name () {alert (this。name)} var person 1=new person(' Tom '，23，' chef ')；person 1 . SayName()；6.构造函数创建一个对象

定义一个对象模拟数组，参数是js内置对象。

函数myArray(){ var lengs=arguments . length；for(var I=0；回肠；I){这个[I]=参数[I]；}}var arr=new myArray(1，2，3)；警报(arr[0])；7.js动态构建对象

脚本类型='text/javascript' /*函数speak(某物){ alert(某物)；} *//* var p=new Object()；p.name=' Jack//添加属性p.func=动态发言；//动态添加方法预警(p . name)；大家好);*//*删除p . name；//删除属性输出未定义的警报(p . name)；删除p . func；大家好);*//* p . name=undefined；p.func=未定义；alert(p . name)；大家好);*/function person(姓名、年龄){//constructor this . name 2=name；//将属性this.age2=age动态添加到当前对象；函数speak(某物){ alert(某物)；} this.func=speak} var p1=新人(' Jack '，12)；alert(p 1 . name 2)；P1 . func(‘大家好！’);/脚本三。创建对象的原型模式

我们创建的每个函数都有一个原型属性，它是一个指向对象的指针，包含所有对象实例的属性和方法，这个对象就是一个原型对象。一般来说，原型对象中的方法和属性可以被所有对象实例共享，这样对象实例就不需要多次创建相同的方法和属性。

函数Person(){ }；人。原型={name:' Tom '，年龄：23，job3360' Web前端工程师'，说说name3360函数(){alert (this。姓名)；} } var Person 1=new Person()；person 1 . SayName()；

1.工厂函数封装，由函数封装

功能点实(颜色、尺寸、品牌){ var Tv={ }；Tv.color=colorTv.size=sizeTv.brand=品牌；Tv.look=function () {alert('看电视')；}Tv.play=function () {alert('玩游戏')；} Tv . DVD=function(){ alert(' DVD ')；}返回Tv；}var ds=dianshi('red '，' 30inch '，' Sony ')；//alert (ds的类型)//返回对象alert(ds)。颜色)var DS1=dianshi('蓝色'，' 40英寸'，'长')；Alert(ds1['size'])//传递参数2。构造器

功能Tv(颜色、尺寸、品牌){ this.color=color//那个对象指的就是这个意思，对象this.size=sizethis.brand=品牌；This.play=function () {alert('玩游戏')；}this.look=function () {alert('看电视')；}}var sony=new Tv('red '，' 20英寸'，' Sony ')；Alert(sony.color)3 .原型方法

公共属性和方法放在代码段中，以节省内存空间

功能电视(颜色、尺寸、品牌){ this . color=color this . size=sizethis . brand=品牌；this.play=function () {alert('玩游戏');} } Tv。原型。look=function(){ alert('看电视');} Tv。原型。DVD=function(){ alert(' DVD ')；}Tv.prototype.aaa={name: '张三'};//只能共享属性或函数，不能共享对象var索尼=新电视('红色',' 20英寸、‘索尼’)；定义变量长虹=新电视('红色',' 20英寸，‘CH’)；删除索尼。颜色删除sony.play//undefine删除sony.look//能访问到索尼。look()；长虹。look()；sony.aaa.name='李四'//李四changhong.aaa.name//李四全局对象排列扩展增加removeByValue方法数组。原型。removebyvalue=function(val){ for(var I=0；长度；I){ if(this[I]==val){ this。拼接(，1)；打破；} }}虽然可以通过对象实例访问保存在原型对象中的值，但却不能通过对象实例重写原型的值。其实对象实例获取某一属性的值是从本身开始寻找，然后是原型对象，最后是构造函数对象，所以重写对象实例的属性值（这个值可以通过删除操作符删除)仅仅是阻断了获取原型属性值的途径，但是没有改变其中的值。

函数person(){ }；人。原型。名字='汤姆'；人。原型。年龄=23岁；Person.prototype.job='厨师；人。原型。SayName=function(){ alert(this。姓名)；} var Person 1=new Person()；var Person 2=new Person()；人1。名字='迈克'；警报(人员1。姓名)；警报(人员2。姓名)；警报(人员1。姓名)；警报(人员2。姓名)；4.面向对象创建对象

用面向对象语法表示的时候，原型对象的构造器属性不在指向人，因为每创建一个函数，同时会创建它的原型对象，用面向对象语法本质上相当于重写了原型对象，构造函数属性也会变成新对象的构造器属性（这里指向对象)

函数person(){ }；人。原型={构造函数：人，姓名： '汤姆'，年龄：23,职务： '厨师，SayName : FuncTion(){ alert(此。姓名)；} } var Person 1=new Person()；var Person 2=new Person()；人1。名字='迈克'；警报(人员1。姓名)；警报(人员2。姓名)；原型模式的缺点：因为所以对象实例共享原型对象的方法和属性，但是往往实例都有他自己私有的属性，这时候原型模式就不适用了，所以我们可以混合使用构造函数模式和原型模式。

5.混合方法

组合使用构造函数模式和原型模式结合了构造函数和原型模式的优点，构造函数定义实例的私有属性，原型模式定义共享属性和方法。

功能电视(颜色、尺寸、品牌){ this . color=color this . size=sizethis . brand=品牌；this.play=function () { alert('玩游戏');} Tv.prototype.aaa={name: '张三'};} Tv。原型。look=function(){ alert('看电视');} Tv。原型。DVD=function(){ alert(' DVD ')；}}功能人员（姓名、年龄、工作){ this.name=namethis.age=年龄；this . job=job }；人。prototype={ constructor : person，说出name : function(){ alert(this。姓名)；} } var Person 1=new Person(' Tom ')；var person2=新人(“迈克”)；警报(人员1。姓名)；警报(人员2。姓名)；四、js对象属性

如果属性的值是函数，我们叫做他是对象的方法，否则叫做是属性。

1.私有属性，对象属性，类属性

脚本类型='text/javascript '函数C(){ this.objPro='对象属性；C.prototype.objPro2='对象属性2';//原型var privatePro='私有属性；//只能在方法内部使用} C.classPro='类属性；alert(c . class pro)；var c=新c()；alert(c . obj pro)；警报(c . Objpro 2)；/script2 .私有方法，对象方法，类方法

脚本类型='text/javascript '函数c(){ var private func=function(){ alert('私有方法');};私有func()；this.objFunc=function(){ alert('对象方法');};原型。ObjFunc2=function(){ alert('对象方法2');};} C.classFunc=function(){ alert('类方法');};c . ClassFunc()；var c=新c()；c . obj func()；c . obj func 2()；/script五、js函数

1.函数的定义：

1.使用关键字函数来定义

fun(){ alert(' hello everybody ')}//fun()；2.使用匿名函数(使用函数作为名称)

Var a=function(){ alert('我是匿名函数')；}//a()；3.采用新功能()

括号中的最后一个参数是函数体，前面所有的参数都是形式参数。

var b=新函数(' x '，' y '，' z '，' alert(x，y，z)')；//b(3，4，5)；前面是参数，最后是方法体

var say func=new func(' name '，' age '，' alert (name' age '今年老了')')；//sayFunc('李四'，4)；alert(SayFunc方法对象的方法参数数：“SayFunc . length”)；alert(SayFunc . ToString())；//获取源代码预警(SayFunc . Valueof())；//获取源代码2。调用函数：

当调用一个函数时，它是通过函数名、函数名(参数)找到的

初始化功能/自调整功能

(function(){ alert(' function call ')；})();3.函数劫持

函数劫持：改变了javascript的预定义函数

window . alert=function(x){ document . write(x)；} alert(' ABC ')；4.函数表达式

var fun=fun(){ alert('我是函数表达式的形式')} fun()；//函数调用注意：

1.如果两个函数的名称相同，后者将覆盖前者。

2.在基本语法中声明的函数将在代码运行时预先加载到内存中以备将来使用，但是以匿名函数形式命名的函数将在执行时被赋值。

3.在不同的脚本/脚本块中使用和调用函数时，应该先定义然后执行。

4.函数参数参数对象

每次创建函数时，函数都会隐式创建一个参数数组对象，该对象包含传入的实际参数的信息。

1.length检测实际传入参数的数量2 .被呼叫者调用自身来访问传入参数的特定值：([下标])

函数fun (a，b){ for(var I=0；长度；I) {alert(arguments[i])}}如有不足，请指教！希望给大家带来帮助！

摘要

以上就是本文的全部内容。希望本文的内容对大家的学习或工作有一定的参考价值。谢谢你的支持。如果你想了解更多，请查看下面的相关链接