javascript自学之路（三）————js对象类型之本地对象

最新推荐文章于 2024-09-23 15:59:21 发布

孙文峰

最新推荐文章于 2024-09-23 15:59:21 发布

阅读量1.3k

点赞数 2

分类专栏： javascript 文章标签： javascript 对象 javasc数据类型

本文链接：https://blog.csdn.net/z893196569/article/details/48685961

版权

javascript 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本篇博客为初稿，稍微整理了一下，有些地方说的不准确。仅作为个人学习心得记录使用。

本地对象相对于宿主对象而言，都是属于object数据类型的范畴。

以下讲解的所有的对象都是本地对象，而本地对象又分为内置对象和自定义对象，除去Global对象和Math对象肯定为内置对象外，其他所有的对象在直接使用字面的情况下作为内置对象，在使用new构造、普通函数名构造或者字面量形式构造的对象都是自定义对象。自定义对象不可以使用内置对象中全大写的属性（相当于java中类的常量的概念）

一、Global对象

全局对象是特殊的内置对象。无法使用new关键字创建实例

所有的全局方法都集中在这个对象中。包含isNaN（）、parseInt（）、String（）等方法

除了本身具有的undefined、NaN等属性外，在顶层 JavaScript 代码中声明的所有变量都将成为全局对象的属性。

它具有的详细的方法和属性参考：http://www.w3school.com.cn/jsref/jsref_obj_global.asp。

二、 Math对象

和Global对象一样，作为特殊的内置对象，不使用new关键字。

Math 对象用于执行数学任务。

var pi_value=Math.PI;

var sqrt_value=Math.sqrt(15);

它具有的详细的方法和属性参考：http://www.w3school.com.cn/jsref/jsref_obj_math.asp。

三、 String对象

1.创建 String 对象的语法：

构造方法创建形式：new String(s);

全局方法创建形式：String(s); （全局方法，是Global对象的方法）

字面量定义形式：var x = “xx”（下面都提到）

说明：

a)        当 String() 和运算符 new 一起作为构造函数使用时，它返回一个新创建的 String 对象，存放的是字符串 s 或 s 的字符串表示。

b)        当不用 new 运算符调用 String() 时，它只把 s 转换成原始的字符串，并返回转换后的值。

c)         字面量形式本质上没有创建对象，但是编译器会将其当做对象处理，该对象xx的引用x具有String对象的一切性质

2.对象的属性

属性          描述

constructor        对创建该对象的函数的引用

length       字符串的长度

prototype 允许您向对象添加属性和方法

3.对象的方法

参考：http://www.w3school.com.cn/jsref/jsref_obj_string.asp。

四、 Number对象

1.创建对象的语法：

var myNum=new Number(value);

var myNum=Number(value); （全局方法，是Global对象的方法）

字面量形式：var myNum = 1；

说明：当 Number() 和运算符 new 一起作为构造函数使用时，它返回一个新创建的 Number 对象。如果不用 new 运算符，把 Number() 作为一个函数来调用，它将把自己的参数转换成一个原始的数值，并且返回这个值（如果转换失败，则返回 NaN）。

2.对象的属性

constructor 对创建该对象的函数的引用

prototype 允许您向对象添加属性和方法

注：其中大写的属性比较特殊，类似于java中的常量，并不属于对象的实例，也并不能通过对象的实例调用，而是应该通过对象直接访问。

比如这样使用属性 MAX_VALUE 是正确的：

var big = Number.MAX_VALUE

但是这样是错误的：

var n= new Number(2);

var big = n.MAX_VALUE

3.对象的方法

valueOf 返回一个 Number 对象的基本数字值。

toString 把数字转换为字符串，使用指定的基数。

更多方法和属性参考：http://www.w3school.com.cn/jsref/jsref_obj_number.asp。

五、 Boolean对象

1.创建的语法：

new Boolean(value); //构造函数

Boolean(value); //转换函数

字面量形式：var x = true；

注：如果省略 value 参数，或者设置为 0、-0、null、""、false、undefined 或 NaN，则该对象设置为 false。否则设置为 true（即使 value 参数是字符串 "false"）。

2.对象属性

属性          描述

constructor         返回对创建此对象的 Boolean 函数的引用

prototype          使您有能力向对象添加属性和方法。

3.对象方法

方法          描述

toSource()          返回该对象的源代码。

toString()          把逻辑值转换为字符串，并返回结果。

valueOf()          返回 Boolean 对象的原始值。

六、 Array对象

1.创建对象的语法：

new Array();

new Array(size);

new Array(element0, element1, ..., elementn);

字面量形式：var x =[1,2]；

2. Array对象属性

属性          描述

constructor         返回对创建此对象的数组函数的引用。

length       设置或返回数组中元素的数目。

prototype 使您有能力向对象添加属性和方法。

3. Array 对象方法

push() 向数组的末尾添加一个或更多元素，并返回新的长度。

reverse() 颠倒数组中元素的顺序。

toString() 把数组转换为字符串，并返回结果。

valueOf() 返回数组对象的原始值

七、 Date对象

1. 创建 Date 对象的语法：

var myDate=new Date()

Date 对象会自动把当前日期和时间保存为其初始值。

2. Date 对象属性

属性描述

constructor 返回对创建此对象的 Date 函数的引用。

prototype 使您有能力向对象添加属性和方法

3. Date 对象方法

方法非常多，参考：http://www.w3school.com.cn/jsref/jsref_obj_date.asp。

八、 RegExp对象

RegExp 对象表示正则表达式，它是对字符串执行模式匹配的强大工具。

1. 直接量语法

/pattern/attributes

2. 创建 RegExp 对象的语法：

new RegExp(pattern, attributes);

说明：

参数

参数 pattern 是一个字符串，指定了正则表达式的模式或其他正则表达式。

参数 attributes 是一个可选的字符串，包含属性 "g"、"i" 和 "m"，分别用于指定全局匹配、区分大小写的匹配和多行匹配。ECMAScript 标准化之前，不支持 m 属性。如果 pattern 是正则表达式，而不是字符串，则必须省略该参数。

返回值

一个新的 RegExp 对象，具有指定的模式和标志。如果参数 pattern 是正则表达式而不是字符串，那么 RegExp() 构造函数将用与指定的 RegExp 相同的模式和标志创建一个新的 RegExp 对象。

如果不用 new 运算符，而将 RegExp() 作为函数调用，那么它的行为与用 new 运算符调用时一样，只是当 pattern 是正则表达式时，它只返回 pattern，而不再创建一个新的 RegExp 对象。

抛出

SyntaxError - 如果 pattern 不是合法的正则表达式，或 attributes 含有 "g"、"i" 和 "m" 之外的字符，抛出该异常。

TypeError - 如果 pattern 是 RegExp 对象，但没有省略 attributes 参数，抛出该异常。

3. 具体使用

请详细阅读http://www.w3school.com.cn/jsref/jsref_obj_regexp.asp。

八、 Function对象

Function对象即函数，每个函数都是一个Function对象实例。

因为函数创建方法多样，所以Function对象创建也就有多种方式。

1. 创建对象

1)        通过Function对象的构造方法或全局方法创建

new Function( [ argName1 [,argName1 [, argNameN... [, funcBody ]]]] )

Function( [argName1 [, argName1 [, argNameN... [, funcBody ]]]] )

参数

参数    描述

argName1    可选/String类型        定义的第1个参数的名称。

argName2    可选/String类型         定义的第2个参数的名称。

argNameN   可选/String类型         定义的第N个参数的名称，可以有任意多个。

funcBody      可选/String类型         定义的函数主体，即函数内部的执行代码，默认为空字符串("")。Function()会把传入的最后一个参数作为函数定义的执行代码，之前的所有参数均依次作为函数定义的参数。

代码示例：
// 定义一个求和函数：带有2个参数x、y。
var sum = new Function("x", "y", "return x +y;");
// 定义一个输出函数：没有定义参数，输出"CodePlayer"
var foo = Function('var name="CodePlayer";document.writeln(name);');
 
// 执行函数
document.writeln( sum( 12, 23 ) ); // 35
foo(); // CodePlayer
 
document.writeln( typeof sum ); // function
document.writeln( sum instanceof Function ); // true
document.writeln( sum instanceof Object ); //true

2) 字面量形式：直接以function关键字形式声明函数，一旦申明即创建Function对象（就像string字符串，可以new，也可以直接以字面量形式创建虽然不是对象，但是相当于对象，具有对象的所有性质。）：

a) 声明式：

   function funcName(argName1, argName2, argNameN){
    // funcBody 这里是函数的执行代码
}
                                                        代码举例：
                                                                      function sum(x, y){
    return x + y;  
}
 
function foo(){
    var name = "CodePlayer";
    document.writeln( name );
}
 
// 执行函数
document.writeln(sum( 12, 23 ) ); // 35
foo(); //CodePlayer    此时的foo就是一个Function对象，使用只需要加（），无需再new foo（）
 
document.writeln(typeof sum ); // function
document.writeln(sum instanceof Function ); // true
document.writeln(sum instanceof Object ); // true

b) 匿名表达式：

var foo =function(){
    var name = "CodePlayer";
    document.writeln( name );
};
foo(); // CodePlayer

c) 匿名自调用：

// 在匿名函数的定义代码外面必须加小括号，表示强迫计算并返回计算结果(否则JS只是解析该匿名函数，但无法获得函数引用，进而无法执行该函数)
// 定义代码后面加上小括号，里面可以传入执行所需的参数(这里为2和3)
( function(x, y){
    document.writeln( x + y );
} )(2, 3); // 5
 
// 上述匿名函数立即执行的代码，还可以如下书写(请注意小括号的位置和匹配)：
( function(x, y){
    document.writeln( x + y );
}(2, 3) ) ; // 5

2. 对象属性

属性    描述

arguments    返回该函数执行时内置的arguments对象。

caller   返回调用当前函数的函数。

constructor   返回创建该对象的构造函数。

length 返回函数定义的参数个数。

prototype      返回创建该对象的函数的原型对象

arguments属性进一步理解：

arguments属性是正在执行的函数的内置属性，返回该函数的arguments对象。arguments对象包含了调用该函数时所传入的实际参数信息(参数个数、参数值等)。

arguments对象有以下三个属性：

length属性，返回实际传入的参数个数。

caller属性，返回调用当前函数的函数，值为Function对象。

0...n属性，以顺序索引访问传入的具体参数。例如，使用arguments[0]可以访问传入的第1个参数，arguments[1]可以访问传入的第2个参数。

注：arguments对象具有length属性和0...n属性，看起来与数组的访问方式相同，但arguments并不是数组，它没有数组对象所具备的其他成员属性和方法。

代码举例：

function test(){
document.writeln("实际传入的参数个数：" +arguments.length); // 实际传入的参数个数：3
    /* "test."可以省略 */
    for(var i = 0; i <test.arguments.length; i++){
        document.writeln("传入的第" + (i + 1)+"个参数：" + arguments[i]); 
    }
    // 传入的第1个参数：1 传入的第2个参数：张三 传入的第3个参数：true
    // callee属性返回的就是当前函数
    document.writeln( arguments.callee === test); // true
};
test(1, "张三", true);

3. 对象方法

方法       描述

apply()          调用当前Function对象，可同时改变函数内的this指针引用，函数参数以数组或arguments对象的形式传入。

call()             调用当前Function对象，可同时改变函数内的this指针引用，函数参数一个个分别传入。

toString()      返回定义该Function对象的字符串。

valueOf()               返回Function对象本身。

call ()方法进一步理解：

call()函数用于调用当前函数functionObject，并可同时使用指定对象thisObj作为本次函数执行时函数内部的this指针引用。

1.语法: functionObject.call( [ thisObj [, arg1 [, arg2 [, args...]]]] )

2.参数：

         参数描述

thisObj 可选/Object类型指定执行functionObject函数时，函数内部this指针引用的对象。

arg1      可选/任意类型调用functionObject函数时传入的第1个参数。

arg2      可选/任意类型调用functionObject函数时传入的第2个参数。

args      可选/任意类型调用functionObject函数时传入的更多参数，可以有多个。

注：如果为该函数所属的functionObject对象提供了传入参数，则必须提供thisObj参数。

3.代码举例：
 var obj = {name:"李四", age: 20};
                function foo(a, b){
                            document.writeln(this.name);   
                            document.writeln(a);   
                            document.writeln(b);   
}
// 改变this引用为obj，同时传递两个参数
foo.call(obj, 12, true); // 李四 12 true

apply ()方法进一步理解：

apply()函数用于调用当前函数functionObject，并可同时使用指定对象thisObj作为本次函数执行时函数内部的this指针引用。call()函数是将Function对象的参数一个个分别传入，apply()函数是将Function对象的参数以一个数组或arguments对象的形式整体传入。

1.       语法：functionObject.apply( [ thisObj [, argsArray ]] )

2.       参数：

参数   描述

thisObj        可选/Object类型指定执行functionObject函数时，函数内部this指针引用的对象。

argsArray    可选/Array|argumens对象调用functionObject函数时所传入的参数数组或arguments对象。

注：如果提供了argsArray参数，则该参数必须是一个数组，或者arguments对象。数组中的每个元素(arguments对象中的每个属性0...n)将按照顺序作为参数传入该函数。如果提供了argsArray参数，则必须提供thisObj参数。

4．Function对象使用难点之闭包。

闭包（closure）：闭包，就是在function对象内部return 一个内嵌方法，该内嵌方法中操作着对象中的局部变量（私有属性），在外部通过该Function对象实际控制了该局部变量。好处就是减少了全局变量的使用以及其引起的命名空间的冲突。

看代码：

var add = (function () {
    var counter = 0;
    return function () {return counter += 1;}
})();

add();
add();
add();
// 计数器为 3

即add= function () {return counter += 1;}，那么add就是该Function对象的引用（注意并不是自调用的函数的对象，自调用的Function对象只运行一次，但是自调用的Function对象在内存中依然存在），通过add（）调用return的Function对象，从而对自调用Function对象中的counter私有属性产生影响。这就是闭包。

九、 Object对象

首先，object是一种数据类型，而Object作为一种对象，是object数据类型中的一种。

Object对象，是JS中所有对象的基对象，包括以上的所有对象，类似于java中的Object基类的概念。Object对象主要用于将任意数据封装成对象形式。

以上的所有对象都是对于Object对象的扩展，添加了属性和方法。

1. 创建对象

用法一：充当Object对象的构造函数使用 new Object( [value ] )

用法二：当作普通函数使用，其行为与用法一(使用new关键字)完全一致 Object([ value ] )

Object()将会根据参数value的数据类型，返回对应类型的对象：

如果value为基元数据类型"Boolean"、"Number"、"String"，则返回对应类型的对象，例如：Boolean对象、Number对象、String对象。

如果value本身为对象，则不对其作任何更改，返回其本身。

如果省略了value参数，或value为null、undefined，则返回自身无任何属性的Object对象。

代码举例：

// 基元数据类型 => 对应类型的对象
var strObj = new Object( "CodePlayer" ); // 返回一个String对象，相当于newString("CodePlayer");
var numObj = new Object( 18 ); // 返回一个Number对象，相当于new Number(18);
var boolObj = new Object( true ); // 返回一个Boolean对象，相当于new Boolean(true);
document.writeln( strObj instanceof String ); // true
document.writeln( numObj instanceof Number ); // true
document.writeln( boolObj instanceof Boolean ); // true

// 对象 => 对象本身
var arr = [ 2, 3, 5];
var regex = /^\d$/;
function test(){
    alert("HelloWorld!");
}
var arrObj = new Object( arr );
var regObj = new Object( regex );
var funObj = new Object( test );
document.writeln( arrObj === arr ); // true
document.writeln( regObj === regex ); // true
// 虽然typeof funObj返回的是"function"，但它本身就是一个Function对象
document.writeln( funObj === test ); // true

// null => 空对象
var obj = new Object( null );
document.writeln( obj instanceof Object ); //true

用法三：以字面值形式创建一个自定义对象：{ property1:value1, property2:value2,propertyN:valueN }

// 将上述自定义对象obj以字面值形式声明
var o = {
    // 所有的属性名称都可以加上引号
    name: "CodePlayer",
    age: 18,
    sayHi: function(){
        alert("HelloWorld!");
    },
    "foo-bar": "包含特殊字符"
};

2. 对象的属性

属性    描述

constructor   返回创建该对象的构造函数

prototype      返回创建该对象的函数的原型对象

3. 对象的方法

方法          描述

hasOwnProperty(x)      指示对象是否具有指定名称的属性。

isPrototypeOf(x) 指示对象是否存在于另一个对象的原型链中。

propertyIsEnumerable(x)      指示指定属性是否为对象的一部分以及该属性是否是可枚举的。

toLocaleString() 以字符串的形式返回值，该值适合于宿主环境的当前区域设置。

toString()   返回表示对象的字符串。

valueOf()   返回对象的原始值。

4. 对象的属性和方法的动态操作

所有基于Object对象的对象都支持expando属性。

1) Object对象不同于以上的内置对象，它的属性和方法可以动态添加、修改和删除（有些内置属性和方法除外）。

代码举例：

 var obj = newObject();
obj.name = "CodePlayer";
obj.age = 18;
obj.sayHi = function( ){
    alert("HelloWorld!"); 
};
document.writeln( obj.age ); // 18
 
// 移除age属性
delete obj.age;
document.writeln( obj.age ); // undefined

2) 在JS中对象的属性可以通过两种方式访问：object.property和object["property"]。

代码举例：

var obj = newObject();
obj.name = "CodePlayer";
obj.age = 18;
obj.sayHi = function( ){
    alert("HelloWorld!"); 
};
 
// 包含特殊字符的属性只能以此方式访问
obj["foo-bar"] = "包含特殊字符";
 
document.writeln( obj.age ); // 18
document.writeln( obj['age'] ); // 18
document.writeln( obj["foo-bar"] );// 包含特殊字符e

十、 Error对象

Error对象主要用于存储JS中错误或异常的相关描述信息。

1. 对象属性

属性     描述

constructor    返回创建该对象的构造函数。

message        返回错误或异常的相关描述信息。

name    返回错误或异常的类型名称。

prototype       返回创建该对象的函数的原型对象

2. 对象方法

方法描述

toString() 返回包含相关错误信息的字符串。

说明：

1. 所有的对象都有自己的构造方法，在new时其实就是调用了自身的构造方法创建对应的对象。该方法在上面的对象方法列表中没有写出来

2. 在创建对象时很多都是没有new关键字而直接使用方法创建，只是调用了一个普通的方法，因此返回的并不是对象，而是一个简单的基础类型，本质和3相同。该方式只存在于三个有基础数据类型对应的对象类型，包括String、Boolean、Number。以及Array对象、Function对象和Object对象中。

3. 字面量形式，只存在于三个有基础数据类型对应的对象类型，包括String、Boolean、Number。以及Array对象、Function对象和Object对象中。

以上部分参考：http://www.365mini.com/page/tag/javascript-function-object。

发现一篇声明变量的五种方式的好文章，有助于理解创建不同类型的变量：http://www.jb51.net/article/34191.htm。

附：

1.instanceof 运算符

格式：x instanceof y ：

含义：X是否是y类型，返回值为boolean。如果x在对象y的原型链 (prototype chain) 中被发现，那么instanceof操作符将返回true，否则返回false.

在使用 typeof 运算符时采用引用类型存储值会出现一个问题，无论引用的是什么类型的对象，它都返回 "object"。ECMAScript 引入了另一个 Java运算符 instanceof 来解决这个问题。

instanceof 方法要求开发者明确地确认对象为某特定类型。例如：

var oStringObject =new String("hello world");
alert(oStringObjectinstanceof String);          //输出 "true"
 
 varuw3c=new Function()
console.log(testinstanceof(uw3c))//true
  console.log(test instanceof(Function))//false
console.log(uw3c instanceof(Function))//false
console.log(test instanceof(Object))//true
 
  console.log(Functioninstanceof(Object))//true
  console.log(Objectinstanceof(Function))//true
 
  console.log(Array instanceof(Function))//true
  console.log(Stringinstanceof(Function))//true
  console.log(Functioninstanceof(Function))//true

发现： 1. 对象的实例属于对象的类型或者是Object对象类型，却不属于Function对象类型，

2. 内置对象（包括Object对象）都属于Function对象类型，但是Function对象也属于Object对象类型，也就是所有内置对象(包括Object和Function对象本身)既属于Function对象类型，也属于Object对象类型

2.JS的基础类型与引用类型

ECMAScript变量包含两种不同类型的值：基本类型值、引用类型值；

1.         基本类型值：指的是保存在栈内存中的简单数据段；

2.         引用类型值：指的是那些保存在堆内存中的对象，意思是，变量中保存的实际上只是一个指针，这个指针执行内存中的另一个位置，由该位置保存对象；

两种访问方式：

1.         基本类型值：按值访问，操作的是他们实际保存的值；

2.         引用类型值：按引用访问，当查询时，我们需要先从栈中读取内存地址，然后再顺藤摸瓜地找到保存在堆内存中的值；

注意图中的Number、Boolean、Null、String、Undefined都是基础类型，不是代表的对象

两种类型复制：

1.         基本类型变量的复制：从一个变量向一个变量复制时，会在栈中创建一个新值，然后把值复制到为新变量分配的位置上；

2.         引用类型变量的复制：复制的是存储在栈中的指针，将指针复制到栈中未新变量分配的空间中，而这个指针副本和原指针执行存储在堆中的同一个对象；复制操作结束后，两个变量实际上将引用同一个对象；因此改变其中的一个，将影响另一个；

两种变量类型检测

1.         Typeof操作符是检测基本类型的最佳工具；

2.         Instanceof用于检测引用类型，可以检测到具体的，它是什么类型的实例；

以上部分内容来源于：http://blog.sina.com.cn/s/blog_6fd4b3c10101d0va.html。

3.constructor属性详解

每个对象都有一个属性constructor，该属性以字符串形式返回对应对象的构造方法。

代码举例：

function employee(name,job,born) {
this.name=name;
this.job=job;
this.born=born;
}
var bill=new employee("BillGates","Engineer",1985);
document.write(bill.constructor);
 
输出：
function employee(name, job, born) {this.name = name;this.jobtitle = job; this.born = born;}

4.prototype属性详解

prototype叫做原型，官方说法是：返回对象类型原型的引用。

有文档

特别说明：

1.       关于类与对象这个概念的申明：

Js中没有类的概念，对比java，java中的类对应js的对象，java中的对象/实例对应js中的对象实例。在 ECMA-262 中根本没有出现“类”这个词。ECMAScript定义了“对象定义”，逻辑上等价于其他程序设计语言中的类。

2.       方法和函数不是一回事

         函数是一个Function对象，具有相应的属性和方法，而方法内置于各种对象中，只是为了完成相应的功能而已

3.       区分以下五者的区别：

1.       Function

2.       function

3.       var x =function（）{ }

4.       var x = new Function（）

5.       var xx = new x（）

说明：

1.       是作为一个内置对象，直接使用：Function.prototype

2.       作为一个关键字，用于创建自建Function对象，也用于创建对象中的方法

3.       字面量形式创建自建Function对象，也可作为一般的方法，使用x（）执行该方法，x为引用类型

4.       构造方法形式创建自建对象Function，x为引用类型，指向该自建对象

5.       创建自建对象Function的一个实例，x为正常的Function对象（引用），xx为该对象的一个实例，拥有对象的属性和方法对应的实际意义的值，它的内容的改变不能影响对象的内容。

特别注意：创建实例，肯定是自建对象类型。而对应的自建对象却必须是Function对象类型，其他所有自建对象类型都不可以创建实例！这也是Function对象很特殊的一点。

测试：
var uw3c = newObject()
var test = newuw3c();//Uncaught TypeError: uw3c is not a function

4. 对Function对象的实例进一步分析

var uw3c=new Function()
uw3c. myname="myname"
uw3c.myfunc=function(){alert("myfunc")}
uw3c.prototype.propname="propname"
uw3c.prototype.propfunc=function(){alert("propfunc")}
var test = newuw3c();
 test.func=function(){alert("testfunc")}
console.log(typeof test);//object
  console.log(testinstanceof(Function));//false
 console.log(test instanceof(Object));//true
 
 
console.log(test. myname);//undefined
 test.myfunc()//UncaughtTypeError: test.myfunc is not a function
 
console.log(test. propname);//propname
 test.propfunc()//propfunc
test. func()//func

测试发现：Function对象的实例的类型为object类型的Object对象。而不是Function对象。且在new uw3c()时候会执行uw3c()。因为是Object对象，与原来的Function对象没有关系了，所以Function对象的属性和方法就自然访问不到了，后加给实例的属性和方法本质上是加到Object对象中去了。这里涉及到原型，将在原型中具体讲解。

console.log(test.__proto__== uw3c.prototype)//true

创建Function对象的实例的本质是：test.__proto__ = uw3c.prototype。

test为Object对象，uw3c为Function对象，两者的联系不是他们的属性和方法，只是在创建实例的时候产生了实例的Object对象的__proto__属性赋值了原Function对象的prototype属性。

这样产生一个问题：当实例的Object对象被赋值的属性和方法和原Function对象的proptype属性储存的属性和方法名称一样怎么办：

var uw3c=new Function()
uw3c.prototype.propname="propname"
 uw3c.prototype.propfunc=function(){alert("propfunc")}
  var test = new uw3c();
  test.propname="testpname"
 test.propfunc=function(){alert("testfunc")}
 
  console.log(test.propname);//testpname
  test.propfunc()//testfunc