JavaScript中使用构造器创建对象无需new的情况说明_javascript技巧
如下
this.name = name;
this.age = age;
}
var p = new Person('lily', 20);
发现某些库代码中创建正则对象的方式无需new,这让人感到奇怪。如下
测试发现使用或不使用new,最后返回的都是正则对象,且typeof它们都是“object”。
var reg2 = RegExp('^he$');
reg1.test('he'); // true
reg2.test('he'); // true
console.log(typeof reg1); // object
console.log(typeof reg2); // object
嗯,挺好,代码运行正常。
如果这样的话干脆就不写new了,这么还节省了代码量。其它类型也是这样吗?试试String/Number/Boolean。
var str2 = String(1);
var num1 = new Number('1');
var num2 = Number('1');
var boo1 = new Boolean(1);
var boo2 = Boolean(1);
console.log(typeof str1); // object
console.log(typeof str2); // string
console.log(typeof num1); // object
console.log(typeof num2); // number
console.log(typeof boo1); // object
console.log(typeof boo2); // boolean
可以看到,与正则的情况不同。正则无论是否new,typeof后都是object。
但String/Number/Boolean类型,new的对象typeof返回是“object”,不new的typeof返回则是“string”。
即不适用new的情况可以将其它类型分别转化成字符串,数字和布尔类型。
好了,再回到篇头的那个Person类。即我们自己写的类可以不用new操作符生成对象吗?
this.name = name;
this.age = age;
}
var p = Person('lily', 20);
console.log(p); // undefined
返回undefined,很明显不行。因此想不用new的情况去创建Person实例是异想天开的。
如果非要实现呢?其实也行,如下
this.name = name;
this.age = age;
if (this===window) {
return new Person(name, age);
}
}
var p = Person('lily', 20); // object
稍微改造了下Person类。实际上内部区分了下Person是作为构造器还是函数执行。

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Solution : 1. Vérifiez l'orthographe et le chemin ; 2. Ajoutez une référence au composant ; 3. Vérifiez le registre ; 4. Exécutez en tant qu'administrateur ; 5. Mettez à jour ou réparez Office ; 7. Utilisez d'autres versions des composants ; messages d'erreur ; 9. Trouver d'autres solutions. Introduction détaillée : 1. Vérifiez l'orthographe et le chemin : assurez-vous qu'il n'y a pas d'erreurs d'orthographe dans le nom et le chemin de l'objet et que le fichier existe dans le chemin spécifié. 2. Ajoutez des références aux composants, etc.

Les étapes pour créer un objet via le mécanisme de réflexion Java sont les suivantes : Chargez la classe cible : Utilisez la méthode Class.forName(). Récupérez le constructeur : utilisez la méthode getDeclaredConstructor(). Créez un objet : utilisez la méthode newInstance() pour transmettre des paramètres.

Comment créer et initialiser des classes et des objets en langage Go. Bien que le langage Go n'ait pas le concept de classes dans les langages orientés objet traditionnels, nous pouvons réaliser des fonctions similaires grâce à des structures et des méthodes. Dans cet article, nous allons apprendre à créer et initialiser des classes et des objets en langage Go. 1. Définir la structure de la classe Dans le langage Go, on peut utiliser la structure pour définir les attributs et les méthodes de la classe. Une structure est un type composite personnalisé qui peut contenir plusieurs champs de types différents. Par exemple, si nous voulons implémenter une classe rectangle, nous pouvons la définir comme

1. Concept Dans le langage Java, l'expression "nouvelle" est responsable de la création d'une instance, dans laquelle le constructeur est appelé pour initialiser l'instance ; le type de valeur de retour du constructeur lui-même est vide, et non "le constructeur renvoie la nouvelle expression créée". Référence d'objet", mais la valeur de la nouvelle expression est une référence à l'objet nouvellement créé. 2. Objectif : créer un objet d'une nouvelle classe. 3. Mécanisme de travail : allouer de l'espace mémoire aux membres de l'objet et spécifier les valeurs par défaut. Initialiser explicitement les variables des membres, effectuer des calculs de méthode de construction et renvoyer souvent des valeurs de référence. signifie en ouvrir de nouveaux en mémoire. L'espace mémoire est alloué dans la zone de tas de la mémoire. Il est contrôlé par jvm et gère automatiquement la mémoire. Ici, nous utilisons la classe String comme exemple. Pu


Comment fonctionne l'opérateur new dans js ? Des exemples de code spécifiques sont nécessaires. L'opérateur new dans js est un mot-clé utilisé pour créer des objets. Sa fonction est de créer un nouvel objet instance basé sur le constructeur spécifié et de renvoyer une référence à l'objet. Lors de l'utilisation de l'opérateur new, les étapes suivantes sont réellement effectuées : créer un nouvel objet vide ; pointer le prototype de l'objet vide vers l'objet prototype du constructeur ; attribuer la portée du constructeur au nouvel objet (cela pointe donc vers new ; objet); exécuter le code dans le constructeur et donner le nouvel objet

Différences : 1. Make ne peut être utilisé que pour allouer et initialiser des données de types slice, map et chan, tandis que new peut allouer n'importe quel type de données. 2. La nouvelle allocation renvoie un pointeur, qui est le type "*Type" tandis que make renvoie une référence, qui est le Type. 3. L'espace alloué par new sera effacé ; une fois que make aura alloué l'espace, il sera initialisé.

Utiliser clone() au lieu de new La manière la plus courante de créer une nouvelle instance d'objet en Java consiste à utiliser le mot-clé new. La prise en charge de new par JDK est très bonne. Lorsque vous utilisez le mot-clé new pour créer des objets légers, cela est très rapide. Cependant, pour les objets lourds, le temps d'exécution du constructeur peut être plus long car l'objet peut effectuer certaines opérations complexes et chronophages dans le constructeur. Le système ne peut donc pas obtenir un grand nombre d’instances à court terme. Pour résoudre ce problème, vous pouvez utiliser la méthode Object.clone(). La méthode Object.clone() peut contourner le constructeur et copier rapidement une instance d'objet. Cependant, par défaut, l'instance générée par la méthode clone() n'est qu'une copie superficielle de l'objet original.
