js如何创建类和对象
Js如何创建类和对象 使用预定义对象只是面向对象语言的能力的一部分，它真正强大之处在于能够创建自己专用的类和对象。 ECMAScript 拥有很多创建对象或类的方法。 工厂方式
原始的方式 因为对象的属性可以在对象创建后动态定义，所有许多开发者都在 JavaScript 最初引入时编写类似下面的代码： var oCar = new Object; oCar.color = "blue"; oCar.doors = 4; oCar.mpg = 25; oCar.showColor = function() { alert(this.color); };
在上面的代码中，创建对象 car。然后给它设置几个属性：它的颜色是蓝色，有四个门，每加仑油可以跑 25 英里。最后一个属性实际上是指向函数的指针，意味着该属性是个方法。执行这段代码后，就可以使用对象 car。
不过这里有一个问题，就是可能需要创建多个 car 的实例。 解决方案：工厂方式
要解决该问题，开发者创造了能创建并返回特定类型的对象的工厂函数（factory function）。 例如，函数 createCar() 可用于封装前面列出的创建 car 对象的操作： function createCar() { var oTempCar = new Object; oTempCar.color = "blue"; oTempCar.doors = 4; oTempCar.mpg = 25; oTempCar.showColor = function() { alert(this.color); }; return oTempCar; } var oCar1 = createCar(); var oCar2 = createCar();
在这里，第一个例子中的所有代码都包含在 createCar() 函数中。此外，还有一行额外的代码，返回 car 对象（oTempCar）作为函数值。调用此函数，将创建新对象，并赋予它所有必要的属性，复制出一个我们在前面说明过的 car 对象。因此，通过这种方法，我们可以很容易地创建 car 对象的两个版本（oCar1 和 oCar2），它们的属性完全一样。
为函数传递参数
我们还可以修改 createCar() 函数，给它传递各个属性的默认值，而不是简单地赋予属性默认值： function createCar(sColor,iDoors,iMpg) { var oTempCar = new Object; oTempCar.color = sColor; oTempCar.doors = iDoors; oTempCar.mpg = iMpg; oTempCar.showColor = function() { alert(this.color); }; return oTempCar; } var oCar1 = createCar("red",4,23); var oCar2 = createCar("blue",3,25); oCar1.showColor(); //输出 "red" oCar2.showColor(); //输出 "blue"
给 createCar() 函数加上参数，即可为要创建的 car 对象的 color、doors 和 mpg 属性赋值。这使两个对象具有相同的属性，却有不同的属性值。 在工厂函数外定义对象的方法 虽然 ECMAScript 越来越正式化，但创建对象的方法却被置之不理，且其规范化至今还遭人反对。一部分是语义上的原因（它看起来不像使用带有构造函数 new 运算符那么正规），一部分是功能上的原因。功能原因在于用这种方式必须创建对象的方法。前面的例子中，每次调用函数 createCar()，都要创建新函数 showColor()，意味着每个对象都有自己的 showColor() 版本。而事实上，每个对象都共享同一个函数。
有些开发者在工厂函数外定义对象的方法，然后通过属性指向该方法，从而避免这个问题： function showColor() { alert(this.color); } function createCar(sColor,iDoors,iMpg) { var oTempCar = new Object; oTempCar.color = sColor; oTempCar.doors = iDoors; oTempCar.mpg = iMpg; oTempCar.showColor = showColor; return oTempCar; } var oCar1 = createCar("red",4,23); var oCar2 = createCar("blue",3,25); oCar1.showColor(); //输出 "red" oCar2.showColor(); //输出 "blue"
在上面这段重写的代码中，在函数 createCar() 之前定义了函数 showColor()。在 createCar() 内部，赋予对象一个指向已经存在的 showColor() 函数的指针。从功能上讲，这样解决了重复创建函数对象的问题；但是从语义上讲，该函数不太像是对象的方法。
所有这些问题都引发了开发者定义 的构造函数的出现。 构造函数方式
创建构造函数就像创建工厂函数一样容易。第一步选择类名，即构造函数的名字。根据惯例，这个名字的首字母大写，以使它与首字母通常是小写的变量名分开。除了这点不同，构造函数看起来很像工厂函数。请考虑下面的例子：
function Car(sColor,iDoors,iMpg) { this.color = sColor; this.doors = iDoors; this.mpg = iMpg; this.showColor = function() { alert(this.color); }; } var oCar1 = new Car("red",4,23); var oCar2 = new Car("blue",3,25);
下面为您解释上面的代码与工厂方式的差别。首先在构造函数内没有创建对象，而是使用 this 关键字。使用 new 运算符构造函数时，在执行第一行代码前先创建一个对象，只有用 this 才能访问该对象。然后可以直接赋予 this 属性，默认情况下是构造函数的返回值（不必明确使用 return 运算符）。
现在，用 new 运算符和类名 Car 创建对象，就更像 ECMAScript 中一般对象的创建方式了。 你也许会问，这种方式在管理函数方面是否存在于前一种方式相同的问题呢？是的。 就像工厂函数，构造函数会重复生成函数，为每个对象都创建独立的函数版本。不过，与工厂函数相似，也可以用外部函数重写构造函数，同样地，这么做语义上无任何意义。这正是下面要讲的原型方式的优势所在。
原型方式
该方式利用了对象的 prototype 属性，可以把它看成创建新对象所依赖的原型。 这里，首先用空构造函数来设置类名。然后所有的属性和方法都被直接赋予 prototype 属性。我们重写了前面的例子，代码如下： function Car() { } Car.prototype.color = "blue"; Car.prototype.doors = 4; Car.prototype.mpg = 25; Car.prototype.showColor = function() { alert(this.color); }; var oCar1 = new Car(); var oCar2 = new Car();
在这段代码中，首先定义构造函数（Car），其中无任何代码。接下来的几行代码，通过给 Car 的 prototype 属性添加属性去定义 Car 对象的属性。调用 new Car() 时，原型的所有属性都被立即赋予要创建的对象，意味着所有 Car 实例存放的都是指向 showColor() 函数的指针。从语义上讲，所有属性看起来都属于一个对象，因此解决了前面两种方式存在的问题。
此外，使用这种方式，还能用 instanceof 运算符检查给定变量指向的对象的类型。因此，下面的代码将输出 TRUE： alert(oCar1 instanceof Car); //输出 "true"
原型方式的问题 原型方式看起来是个不错的解决方案。遗憾的是，它并不尽如人意。 首先，这个构造函数没有参数。使用原型方式，不能通过给构造函数传递参数来初始化属性的值，因为 Car1 和 Car2 的 color 属性都等于 "blue"，doors 属性都等于 4，mpg 属性都等于 25。这意味着必须在对象创建后才能改变属性的默认值，这点很令人讨厌，但还没完。真正的问题出现在属性指向的是对象，而不是函数时。函数共享不会造成问题，但对象却很少被多个实例共享。请思考下面的例子：
function Car() { } Car.prototype.color = "blue"; Car.prototype.doors = 4; Car.prototype.mpg = 25; Car.prototype.drivers = new Array("Mike","John"); Car.prototype.showColor = function() { alert(this.color); }; var oCar1 = new Car(); var oCar2 = new Car(); oCar1.drivers.push("Bill"); alert(oCar1.drivers); //输出 "Mike,John,Bill" alert(oCar2.drivers); //输出 "Mike,John,Bill"
NodeJs中类定义及类使用
2、创建文件test.js，在该文件中创建类对象并使用
//引入类，暂时ES6标准中有import，但NodeJs还不支持 var Point = require('./Point.class'); //新建类对象 var point = new Point(2, 3); //调用对象中的方法 console.log(point.toString()); //调用类中的静态函数 console.log(Point.sayHello('Ence')); //调用类中的静态变量 console.log(Point.para);
如果x与y独立协方差为0但如果x与y的协方差为0二者并不一定是统计独立的
NodeJs中 类 定 义 及 类 使 用
1、首先定义类Point,文件名为point.class.js:
// 定义类 class Point {
//构造函数 constructor(x, y) {
this.x = x;//类中变量 this.y = y; } //类中函数 toString() { return '(' + this.x + ', ' + this.y + ')'; } //静态函数 static sayHello(name){ //修改静态变量 this.para = name; return 'Hello, ' + name; } } //静态变量 Point.para = 'Allen'; module.exports = Point;
js创建对象经典模式全面了解
下面小编就为大家带来一篇js 创建对象经典模式全面了解。
小编觉得挺不错的，现在就分享给大家，也给大家做个参考。
1. 概述通过构造函数创建对象，有时忘记了写new，这时函数就会返回undefined可以创建一个函数createXXX，在内部封装new。
function Student(props){ = || '匿名'; this.grade = props.grade || 1; } Student.prototype.hello = function(){ alert('Hello, '+ + '!');}function createStudent(props){ return new Student(props || {});}注意，如果函数没有显示的写明return xxx; 则返回undefined。
example利用构造函数定义Cat，并让所有的Cat对象有一个name属性，并共享一个方法say()，返回字符串'Hello, xxx!'：'use strict';function Cat(name) { = name;}Cat.prototype.say = function(){ return ('Hello, ' + + '!');}// 测试:var kitty = new Cat('Kitty');var doraemon = new Cat('哆啦A梦');if (kitty && === 'Kitty' && kitty.say && typeof kitty.say === 'function' && kitty.say() === 'Hello, Kitty!' && kitty.say === doraemon.say) { alert('测试通过!');} else { alert('测试失败!');}以上这篇js 创建对象经典模式全面了解就是小编分享给大家的全部内容了，希望能给大家一个参考。
js的create方法
js的create方法我们来看一下create方法的语法。
它的语法非常简单，只需要在一个对象上调用create方法即可，例如：```let newObj = Object.create(oldObj);```在这个例子中，我们通过调用Object对象上的create方法，创建了一个名为newObj的新对象，并且该对象继承了oldObj对象的属性和方法。
简单来说，create方法就是用来创建一个对象，并且让这个对象继承另一个已存在的对象的属性和方法。
那么，为什么我们需要使用create方法呢？其实，使用create方法的好处有很多。
首先，它可以帮助我们实现对象之间的继承关系。
在面向对象的编程中，继承是一个非常重要的概念，它可以帮助我们实现代码的复用和组织。
通过create方法，我们可以轻松地创建一个新对象，并且让这个对象继承另一个对象的属性和方法，从而实现代码的复用。
除了继承之外，create方法还可以帮助我们创建一个干净的对象。
在JS中，对象是一种复杂的数据类型，它可以存储各种属性和方法。
有时候，我们可能只需要一个干净的对象，它不包含任何属性和方法，只是作为一个空容器来存储数据。
使用create方法，我们可以很方便地创建这样一个干净的对象，然后再根据需要添加属性和方法。
那么，如何正确地使用create方法呢？首先，我们需要明确要继承的对象是谁。
在调用create方法时，我们需要将要继承的对象作为参数传入。
例如，如果我们想创建一个新的对象，并且让它继承一个叫做person的对象的属性和方法，可以这样写：```let newObj = Object.create(person);```接下来，我们可以根据需要，给新对象添加属性和方法。
例如，我们可以给newObj对象添加一个名为name的属性和一个名为sayHello的方法：``` = "John";newObj.sayHello = function() {console.log("Hello, my name is " + );};```通过这样的方式，我们就可以根据需要创建新的对象，并且为它们添加属性和方法。
原生JS实现new方法、new一个对象发生的四部、new里面常用的优先级
原⽣JS实现new⽅法、new⼀个对象发⽣的四部、new⾥⾯常⽤的优先级⼀、js中new⼀个对象的过程 ⾸先了解new做了什么，使⽤new关键字调⽤函数（new ClassA(…)）的具体步骤： 1、创建⼀个新对象： var obj = {}; 2、设置新对象的constructor属性为构造函数的名称，设置新对象的__proto__属性指向构造函数的prototype对象； obj.__proto__ = ClassA.prototype; 3、使⽤新对象调⽤函数，函数中的this被指向新实例对象： ClassA.call(obj); //{}.构造函数() 4、将初始化完毕的新对象地址，保存到等号左边的变量中 注意：若构造函数中返回this或返回值是基本类型（number、string、boolean、null、undefined）的值，则返回新实例对象；若返回值是引⽤类型的值，则实际返回值为这个引⽤类型。
var foo = "bar";function test () { this.foo = "foo";}new test(); //test中的this指新对象，并未改变全局的foo属性console.log(this.foo); // "bar"console.log(new test().foo); // "foo";⼆、⽤原⽣JS实现new⽅法// 通过分析原⽣的new⽅法可以看出，在new⼀个函数的时候，// 会返回⼀个func同时在这个func⾥⾯会返回⼀个对象Object，// 这个对象包含⽗类func的属性以及隐藏的__proto__function New(f) {//返回⼀个funcreturn function () {var o = {"__proto__": f.prototype};f.apply(o, arguments);//继承⽗类的属性return o; //返回⼀个Object}} ⾸先写⼀个⽗类⽅法(包含参数name,age)：function Person(name,age){ = name;this.age = age;}//new⼀个Person的实例p1做研究对⽐var p1 = new Person("Richard", 22);//此时p1包含name、age属性，同时p1的__proto__指向Person的prototype;//Richardp1.age;//22 通过⾃定义New⽅法创建⼀个实例对象p2:var p2 = New(Person)("Jack",25);;//Jackp2.age;//25 此时p2 instanceof Person 返回的是true；Person.prototype.gender ="male";p1.gender//malep2.gender//male三、优先级问题 ：⼩括号(xxx) > 属性访问. > new foo() > foo() 注意new Foo()优先级⾼于Foo();function getName(){console.log(1)}function Foo() {this.getName = function () {console.log(2);};return this;}Foo.getName = function () {console.log(3);};//先从.属性访问符号开始往前⾯找⼀个最近的对象，同时注意new Foo()优先于Foo();var a=new Foo.getName();//3;属性.的优先级⾼于new foo()，所以===new (Foo.getName)();返回Foo.getName类型的实例var b=new Foo().getName();//2;new foo()的优先级⾼于foo()，所以就相当于new foo()的属性，===(new Foo()).getName()；返回undefinedvar c=new new Foo().getName();//2;new foo()优先级低于属性.，所以其实相当于就是new⼀个new foo()的getName属性函数，===new (new Foo().getName)();返回Foo.getName类型的实例new Date().getTime();//===((new Date()).getTime)()(new Date).getTime();//===((new Date()).getTime)()new Date.getTime();//Uncaught TypeError: Date(...).getTime is not a function；===new (Date.getTime)() 需要注意的是：new Date 其实也是正确的，和new Date()⼀样。
js对象push方法
js对象push方法JavaScript中的对象是一种非常重要的数据类型，它可以用来表示复杂的数据结构。
在对象中，我们可以使用push()方法来向对象中添加新的属性或值。
具体来说，JavaScript中的对象是由一组属性组成的，每个属性都有一个名称和一个值。
我们可以使用对象字面量或构造函数来创建一个对象。
例如：```// 使用对象字面量创建一个对象const obj1 = {na 'Alice', age: 20};// 使用构造函数创建一个对象function Person(name, age) { = name;this.age = age;}const obj2 = new Person('Bob', 30);```push()方法可以用来向对象中添加新的属性或值。
具体来说，如果对象中不存在指定的属性，则该属性将被添加到对象中；如果对象中已经存在指定的属性，则该属性的值将被替换为新的值。
例如： ```// 向对象中添加新的属性obj1.gender = 'female';console.log(obj1); // {na 'Alice', age: 20, gender:'female'}// 向对象中添加新的属性或更新已有的属性 = 'Amy';console.log(obj1); // {na 'Amy', age: 20, gender:'female'}```需要注意的是，push()方法只能用于数组，不能用于对象。
如果我们想添加新的属性或值到对象中，应该使用上述的方式进行操作。
总之，JavaScript中的对象是一种非常重要的数据类型，我们可以使用push()方法来向对象中添加新的属性或值。
需要注意的是，push()方法只能用于数组，不能用于对象。
class在js中的实际运用
class在js中的实际运用JavaScript中的class是一种用于创建对象的模板或蓝图，它提供了一种方式来定义对象的属性和方法。
在本质上，class就是一个函数，它可以用来创建具有相同属性和行为的多个对象。
class的实际运用非常广泛，下面我们将介绍一些常见的应用场景：1.构造函数class可以用作构造函数，通过使用关键字"class"创建一个类，并在内部使用"constructor"方法定义构造函数。
构造函数会在对象创建时自动执行，用于初始化对象的属性。
这使得我们可以轻松地创建多个具有相同初始状态的对象。
例如，我们可以使用class来创建一个"Person"类，其中包含name和age两个属性：```javascriptclass Person {constructor(name, age) { = name;this.age = age;}}let person1 = new Person("张三", 20);let person2 = new Person("李四"，25);```2.静态方法class还可以定义静态方法，这些方法不会被实例继承，而是直接通过类调用。
```javascriptclass MathUtils {static add(x, y) {return x + y;}static multiply(x, y) {return x * y;}}console.log(MathUtils.add(2, 3)); //输出：5console.log(MathUtils.multiply(2, 3)); //输出：6```静态方法非常适合用于实现一些通用的工具函数，而无需每次都创建一个实例对象。
3.继承JavaScript的class还支持继承，可以通过"extends"关键字来实现类的继承。
js的map对象方法
Map对象是JavaScript中一个用于存储键值对的数据结构，它提供了一系列方法来操作和管理键值对。
本文将介绍Map对象的主要方法，帮助您更好地使用Map对象。
一、Map对象概述Map对象是一个可迭代对象，它以键值对的形式存储数据，每个键值对在Map对象中都是唯一的。
Map对象中的键可以是任何类型的数据，而值则是一个唯一的对象。
通过使用Map对象，您可以方便地存储和检索数据，同时还可以方便地修改和删除数据。
二、Map对象的主要方法1.**构造函数（constructor）**：创建新的Map对象，可以使用新对象的方式或对象字面量方式来初始化。
2.**size**：返回Map对象中键值对的数量。
3.**keys()**：返回一个新的Iterator对象，包含Map对象中的所有键。
4.**values()**：返回一个新的Iterator对象，包含Map对象中的所有值。
5.**entries()**：返回一个新的Iterator对象，包含Map对象中的所有键值对。
6.**forEach()**：对Map对象中的每个键值对执行指定的函数。
7.**get(key)**：根据指定的键获取对应的值。
如果键不存在于Map对象中，则返回undefined。
8.**has(key)**：检查指定的键是否存在于Map对象中。
9.**delete(key)**：从Map对象中删除指定的键及其对应的值。
10.**clear()**：清空Map对象中的所有键值对。
三、示例代码下面是一个使用Map对象的简单示例代码：```javascript//创建一个新的Map对象letmyMap=newMap();//添加键值对到Map对象中myMap.set('name','John');myMap.set('age',30);myMap.set('city','NewYork');//获取指定键的值letname=myMap.get('name');//返回'John'console.log(name);//输出'John'//检查指定键是否存在于Map对象中letexists=myMap.has('age');//返回trueconsole.log(exists);//输出true//删除指定键及其对应的值myMap.delete('age');//从Map对象中删除'age'键及其对应的值console.log(myMap.size);//输出2，因为'age'键已被删除```四、总结本文介绍了JavaScript中Map对象的主要方法，包括构造函数、size属性、keys()、values()、entries()、forEach()、get()、has()、delete()和clear()等。
js class类用法
明代杂剧发展概述及其代表作鉴赏一、明代杂剧的起源与特点明代杂剧是中国戏曲史上的一个重要分支，诞生于明代中期，具有独特的表现形式和审美特点。
明代杂剧以吸收民间艺术和文言戏剧为特色，融合了歌舞、杂耍、说唱等多种元素，展现出丰富多彩的艺术风貌。
其艺术特点主要表现在以下几个方面：1. 劇情生動多样明代杂剧在剧情设置上善于展现人物性格的多样性，情节曲折生动，往往充满悬念和感情冲突，给观众带来强烈的视听享受。
2. 艺术表现形式多样明代杂剧艺术形式灵活多变，既有歌舞曲艺的表演，也有说唱、击掌等特色表现形式，呈现出生动活泼的舞台效果。
3. 表演风格夸张生动杂剧表演风格以夸张生动著称，演员多采用夸张的表情动作和语调，以吸引观众注意力，塑造生动鲜明的人物形象。
二、明代杂剧代表作介绍1. 《汉宫秋》《汉宫秋》是明代著名杂剧作品，由乌木创作，内容以王莽篡位、东汉末年为背景，描写了历史上的悲壮故事。
该剧以婉娜多情的王宫少女为主线，展现出了王莽篡位时的社会动荡和人民疾苦，具有深刻的社会寓意。
2. 《救风尘》《救风尘》是明代著名杂剧作品之一，描写了一个风尘女子面对社会压力、坚守尊严的故事。
该剧通过对风尘女子的内心挣扎和人性张扬，展现了明代社会底层人物的悲欢离合，具有强烈的人文关怀。
3. 《四郎探母》《四郎探母》是明代杂剧中的经典之作，以男女恩怨、母子情深为主线，展现了家国情怀和亲情至上的主题。
该剧通过对宫廷生活和封建礼教的批判，探讨了人性善恶、亲情与道德之间的关系，是一部充满人性关怀的杂剧佳作。
三、明代杂剧对后世的影响明代杂剧作为中国戏曲史上的重要艺术形式，对后世的文化影响深远。
其独特的表现形式和审美特点为后世文艺创作提供了宝贵的借鉴和启示，影响了后世京剧、豫剧等传统戏曲的发展。
同时，明代杂剧将现实主义和浪漫主义相结合，为后世文学作品提供了丰富多彩的表现方式和审美观念，对中国古典文学的繁荣和发展起到了积极的促进作用。
总的来说，明代杂剧以其独特的表现形式和深刻的社会寓意，成为中国戏曲史上的珍贵遗产，不仅为当代文化传承提供了宝贵的历史遗产，也为后世艺术创作提供了重要的艺术源泉和文化资源。
wpsjs createobject用法
wpsjs createobject用法WPSJS CreateObject使用指南WPSJS（WPS Office的JavaScript API）是一种强大的工具，可以帮助开发人员在WPS Office中自动化各种操作。
其中的CreateObject方法是一个常用的函数，用于创建COM（Component Object Model）对象并在脚本中使用。
CreateObject用法示例:```var obj = wpsjs.CreateObject("类名");```以上代码将创建一个指定类名的对象，并将其赋值给变量obj，以便后续操作。
下面是一些常用的类名以及它们对应的对象：1. WPS.Application: 用于与WPS Office应用程序交互的对象。
可以通过这个对象打开、关闭文档，进行文档的编辑、保存等操作。
2. WPS.Document: 代表一个打开的文档，可以对文档进行读写操作，如插入内容、修改样式等。
3. WPS.Range: 表示文档中的一个区域，可以对该区域进行文本操作，如查找替换、格式设置等。
具体使用方法和属性可以根据需要查询相应的文档和API参考手册。
下面是一个示例，展示了如何使用CreateObject和一些常用操作：```javascriptvar wpsApp = wpsjs.CreateObject("WPS.Application");wpsApp.Visible = true; // 显示WPS Office应用程序var doc = wpsApp.Documents.Add(); // 新建一个文档doc.Content.Text = "Hello, WPS Office!"; // 设置文档内容var range = doc.Range(); // 获取文档范围对象range.Collapse(); // 折叠范围到起始位置range.Select(); // 选择该范围内的内容doc.SaveAs("C:\\path\\to\\save\\document.docx"); // 保存文档到指定路径doc.Close(); // 关闭文档wpsApp.Quit(); // 关闭WPS Office应用程序```通过以上的示例代码，我们创建了一个WPS应用程序对象，新建了一个文档，并设置了文档的内容。
js中map对象的方法
js中map对象的方法 Map是JavaScript中一种非常有用的数据结构，它允许我们使用“键（Key）-值（Value）”的方式来存储和管理数据。在本文中，我们将深入了解JS中的Map对象的方法和用法。
一、Map的基本用法 Map对象是一种由键值对组成的集合，其中的键可以是任何类型，而值可以是任何类型的数据。以下是创建Map实例的基本方法：
```javascript let map = new Map(); ```
接下来，我们将通过以下几个方面来学习Map对象的方法： 二、Map的属性和方法 1.大小 Map对象有一个size属性，用于获取map的大小，即键值对的数量。 ```javascript let map = new Map(); map.set("key1", "value1"); map.set("key2", "value2"); console.log("Map Size: " + map.size); // 输出：Map Size: 2 ``` 2.设置键值对 set()方法用于为Map对象设置键值对，它接受两个参数：键和值。 ```javascript let map = new Map(); map.set("key1", "value1"); map.set("key2", "value2"); console.log(map.get("key1")); // 输出：value1 ```
3.获取键值对 get()方法用于获取Map对象中指定键的值。 ```javascript let map = new Map(); map.set("key1", "value1"); map.set("key2", "value2"); console.log(map.get("key1")); // 输出：value1 ```
4.检查是否存在某个键 has()方法用于检查Map对象是否存在某个键。 ```javascript let map = new Map(); map.set("key1", "value1"); console.log(map.has("key1")); // 输出：true console.log(map.has("key2")); // 输出：false ``` 5.删除键值对 delete()方法用于删除Map对象中指定的键值对。 ```javascript let map = new Map(); map.set("key1", "value1"); map.set("key2", "value2"); map.delete("key1"); console.log(map.get("key1")); // 输出：undefined console.log(map.size); // 输出：1 ```