34.js--fn.fn的题、原型

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

目录

        1.fn.fn的题重讲

        2.原型

        （1）typeof()

        3.object function为js中的引用数据

         4、原型案例

1.fn.fn的题重讲

案例：

            function fn() {}
			function fm() {
				this.fm = 100
				fn.fm=100
			}

			fn.hqyj=1000
			fn.sayName=function(){}
			console.log(fn.hqyj)
			fn.sayName()
			

			fn.fn =100 
			var obj={}
			obj.obj=100
			fn.fn = fm

			
			fn()
			fn.fn()
		
			console.log(fn.fn, fn.fm)

注释：
    fn.fn =100 //fm

	
	fn()//把fn函数运行一遍
	fn.fn()//把fn对象的fn方法运行一遍


    console.log(fn.fn, fn.fm)
	// console.log(window.fm)

运行结果：

 函数也是一个特殊的对象

2.原型

（1）typeof()

typeof是一个系统提供的全局函数 它的返回值是一个字符串:

        string number boolean null undefined  object function

3.object function为js中的引用数据

object function为js中的引用数据

            引用数据==> 就是一种内存空间,是一种数据容器

            数组是一种有下标的数据容器

            对象是一种键值对的数据容器

            函数是一个有代码块和作用域的数据容器

数据容器就是可以存储很多数据的引用

案例：

            function  fn (a) {
				console.log(123)
			}
			fn["age"]=100
			console.log(fn.age,fn["age"])

运行结果：

 

函数有哪些属性

            //name  保存了一个字符串 就是函数的名字

                    console.log(typeof fn.name)

            //length 保存了一个数字 就是函数的形参的个数

                    console.log(typeof fn.length,fn.length)

            //prototye 保存了一个对象,这个对象是new Object()

案例2：

            function  fn () {				
			}
			function fm(){				
			}
			fn.fn=fm        //fn函数对象添加一个属性 属性名叫fn  这个属性引用了fm函数
			fn.fm=fn        //fn函数对象添加一个属性 属性名叫fm  这个属性引用了fn函数 			
			console.log(fn.fn,fn.fm,fm.fn,fm.fm)        //fm fn  und und			
			                                            // window.x=window

运行结果：

 4、原型案例

原型案例1：

        所有的对象都有一个属性叫 __proto__  代表的是这个对象的原型对象

           function  fn (firstName) {
				this.life=1
				this.firstName=firstName
				this.sayName=function(){
					console.log(this.firstName)
				}
			}
			
			 var f1=new fn("张")        //{life:1,firstName:"张",sayName}
			 f1.sayName()  
			 

			 console.log(f1.life)
			 console.log(f1.toString)
			 

			 console.log(f1)
			 

			var f2=new fn("李")
			console.log(f2)
			 
			 
			console.log(f1==f2)


            console.log(f1.__proto__===f2.__proto__)

运行结果：

原型案例2：

           	function  fn (firstName) {
				this.life=1
				this.firstName=firstName
				this.sayName=function(){
					console.log(this.firstName)
				}
			}

			var f1=new fn("张")
			var f2=new fn("李")
			f1.__proto__.age=23

			console.log(f2.age,f2)
			console.log(f1,f2)

运行结果：

 

 原型的思想:  内存共用

原型案例3：

           function  fn () {
				this.life=1
			}
			//隐式操作:fn.prototye={}
			

			function fm(){
				this.color="black"
			}
			//隐式操作:fm.prototye={}
			

			var f1=new fn()
			var f2=new fm()
			
			console.log(f1.__proto__===f2.__proto__)
			console.log(f1.__proto__===fn.prototype,111111)
			console.log(f2.__proto__===fm.prototype,222222)
			console.log(f1.__proto__===fm.prototype,333333)

运行结果：

          所有函数都有name,lebgth,prototye属性,用函数创建对象,

            创建出来的对象的原型对象就是prototye属性引用的对象          

            prototye属性中引用了一个系统内置的对象:new Object()/{}

 new fn()

            1.创建一个空对象==> 创建一个空对象{}  给它添加一个属性 __proto__  这个属性引用fn.prototye

  案例：

            function  fn () {
				this.life=1
			}
			fn.prototype.color="red"
			
			
			var f1=new fn()
			f1.age=20
			
			
			var f2=new fn()
			var f3=new fn()
			
			console.log(f1.color,f2.color,f3.color)
			console.log(f2.age)

运行结果：

            对象有__proto__属性 代表它的原型对象

            函数有prototye属性 代表创建的对象的原型对象

            原型对象可以访问成员

举例1：

         function fn(){

                this.a=20

            }

            //隐式操作:fn.prototye={}

举例2：

          function  fm () {

                this.a=30

            }

            //隐式操作:fm.prototye={fn:{a:20,__proto__:{}}}

            //new fn()==>{__proto__:fn.prototye}==>{a:20,__proto__:{}}

           fm.prototype.fn=new fn()

        

            var f1=new fm()

            //new fm()

            //{__proto__:fm.prototype,a:30}==>{__proto__:{fn:{a:20,__proto__:{}}},a:30}