English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Partie de l'objet
Type Object
Object est un ensemble désordonné qui peut contenir n'importe quel type d'objet, et tous les autres objets héritent de cet objet.
Il y a deux manières de créer un type Object, l'une est l'opérateur new, et l'autre est la notation littérale.
1. Création d'Object avec new
var obj = new Object();//Attention à la casse, il peut également être écrit directement en Object()
Attention, la création d'un nouvel objet à l'aide de new Object() est équivalente à la syntaxe de littéral obj = {}.
2. Création via littéraux :
var obj = {
name : 'trigkit4',
age : 21
};//Il est préférable d'ajouter le point-virgule
Lors de la déclaration d'un objet Object à l'aide de littéraux, le constructeur Object() n'est pas appelé (sauf dans FF)
L'objet Object.prototype
Tous les constructeurs ont une propriété prototype, qui pointe vers un objet prototype.
Object.prototype.print = function(){ console.log(this)};
var obj = new Object();
obj.print() // Object
L'instance obj hérite directement des attributs et des méthodes de Object.prototype
1.Les objets ne sont qu'une forme spéciale de données. Les objets possèdent des attributs et des méthodes. JavaScript est un langage orienté objet, mais JavaScript n'utilise pas de classes. JavaScript est basé sur [prototype][1], mais pas basé sur des classes.
2.Les attributs : sont des variables appartenant à un objet spécifique. Les méthodes : sont des fonctions qui ne peuvent être appelées que par un objet spécifique.
3.Les objets js sont une collection d'attributs et de méthodes. Une méthode est une fonction, qui est un membre de l'objet. Un attribut est une valeur ou un ensemble de valeurs (sous forme d'array ou d'objet), qui est également un membre de l'objet.
4.Les objets js sont basés sur des fonctions constructrices, et créer un nouvel objet en utilisant une fonction constructrice, c'est dire qu'on a instancié un nouvel objet. Les attributs sont les variables à l'intérieur de la fonction constructrice.
Utilisation des fonctions constructrices pour instancier des objets :
cat = new Animal();
Javascript est un langage basé sur des objets (object-Un langage basé sur des objets (based) où tout ce que vous rencontrez est presque un objet. Mais ce n'est pas vraiment un langage orienté objet (OOP) car il n'a pas de class (classe) dans sa syntaxe.
<script type="text/javascript">
//L'objet est nom/Collection de paires de valeurs
var browser = { //Les objets sont encadrés par des accolades
name:"Firefox",
kernel:"Gecko"
};
</script>
//Accéder aux propriétés de l'objet via le point (.) ou "[]"
browser.name //"Firefox"
browser["kernel"] //"Gecko"
L'objet (objct) est une collection de propriétés, chaque propriété étant définie par un "nom/Constitué de paires de valeurs, JavaScript définit également un objet spécial - le tableau, qui est une collection ordonnée de valeurs numérotées.
JavaScript définit également un objet spécial - la fonction, qui est un objet avec du code exécutable associé, et le code est exécuté en appelant la fonction et en retournant le résultat de l'opération.
Il n'y a pas de classe en JavaScript, mais il en a pris un nouveau nom appelé "objet prototype", donc "classe == objet prototype", voir détails : Écriture de la classe JavaScript (I)
Deuxième partie : les différences et les relations entre la classe (objet prototype) et l'objet (instance)
1.La classe (objet prototype) est abstraite, conceptuelle, représentant un type de choses.
2.L'objet est concret, réel, représentant une chose concrète.
3.classe (objet prototype) est un modèle d'instance d'objet, et l'instance d'objet est un individu d'une classe.
Une idée fausse courante est que les valeurs littérales (literals) numériques ne sont pas des objets. Cela est dû à une erreur du parseur JavaScript, qui tente de faire de l'opérateur point une partie de la valeur littérale de type flottant.
Il y a de nombreuses méthodes détournées pour faire paraître les valeurs littérales numériques comme des objets.
2..toString(); // Le deuxième point peut être interprété normalement
2 .toString(); // Attention à l'espace avant le point
(2).toString(); // 2Calculé en premier
Suppression de propriété
La seule méthode pour supprimer une propriété est d'utiliser l'opérateur delete ; mettre une propriété à undefined ou null ne supprime pas vraiment la propriété, mais ne supprime que l'association entre la propriété et sa valeur.
Les trois grandes caractéristiques de l'orientation objet en JavaScript
Encapsulation : sans tenir compte de l'implémentation interne, mais uniquement de l'utilisation des fonctionnalités
Héritage : hériter de nouveaux objets à partir d'objets existants
Polymorphisme : le polymorphisme, c'est ce que signifie une référence dans différentes situations sous différentes formes,
1.encapsulation
L'encapsulation consiste à regrouper les caractéristiques et comportements communs des choses d'un même type dans une même classe, ce qui facilite leur utilisation. Par exemple, pour l'homme, on peut l'encapsuler de la manière suivante :
L'homme {
Âge (caractéristique一)
Taille (caractéristique二)
Sexe (caractéristique三)
Faire des choses (comportement之一)
Marcher (comportement之二)
Parler (comportement之三)
}
Les avantages de l'encapsulation :
L'encapsulation protège l'intégrité des données internes ;
L'encapsulation rend la refonte des objets plus facile ;
Atténue la耦合 entre les modules, améliore la réutilisabilité des objets ;
Aide à éviter les conflits de noms d'espace ;
Voyons un exemple ci-dessous :
<script type="text/javascript">
var boy = {}; //Créer un objet vide
boy.name = "xiaoming";//Selon l'affectation des propriétés de l'objet prototype
boy.age = 12;
Créer un objet vide
girl.name = "xiaohong";
girl.age = 10;
</script>
C'est l'encapsulation la plus simple, qui met deux propriétés dans un objet. Cependant, cette méthode a deux inconvénients : d'une part, si plusieurs instances sont générées, c'est très difficile à écrire ; d'autre part, il n'y a aucune manière de voir la relation entre l'instance et le prototype.
Modèle de constructeur
Pour résoudre le problème de génération d'instances à partir de l'objet prototype, Javascript fournit un modèle de constructeur (Constructor).
En réalité, "constructeur" est une fonction ordinaire, mais qui utilise la variable this à l'intérieur. En utilisant l'opérateur new avec un constructeur, on peut générer des instances, et la variable this est liée à l'objet instance.
Par exemple, l'objet prototype de boy et girl peut être écrit ainsi :
<script type="text/javascript">
function Person(name,age){
this.name = name;
this.age = age;
}
</script>
Maintenant, nous pouvons générer des objets instances.
<script type="text/javascript">
var boy = new Person("xiaoming",12);
var girl = new Person("xiaohong",10);
alert(boy.name); //xiaoming
alert(boy.age); //12
</script>
À ce moment-là, boy et girl auront automatiquement une propriété constructor, pointant vers leur constructeur.
alert(boy.constructor == Person); //true
alert(girl.constructor); //Affichez le code de la fonction constructeur complète, essayez-le vous-même.
Le modèle Prototype de Javascript stipule que chaque constructeur a une propriété prototype, qui pointe vers un autre objet. Toutes les propriétés et méthodes de cet objet seront héritées par les instances du constructeur.
Ce signifie que nous pouvons directement définir les propriétés et méthodes invariables sur l'objet prototype.
<script type="text/javascript">
function Person(name,age){
this.name = name;
this.age = age;
}
Person.protype.type = "humain";
Person.protype.eat = function(){
alert("manger du riz");
}
</script>
ensuite, générer des instances:
<script type="text/javascript">
var boy = new Person("xiaoming","12");
var girl = new Person("xiaohong","10");
alert(boy.type);//Humain
boy.eat();//Manger
</script>
Dans ce cas, toutes les propriétés type et les méthodes eat() des instances sont en fait les mêmes adresses mémoire, pointant vers l'objet prototype, ce qui améliore l'efficacité de l'exécution.
alert(boy.eat == girl.eat); //true
Les propriétés prototype sont une propriété intégrée, elle spécifie le constructeur fonction étendu par l'objet.
Le code suivant ajoute une nouvelle propriété size à la fonction constructeur Animal, cette nouvelle propriété est une propriété prototype de l'objet cat. Grâce aux propriétés prototype, tous les objets étendant la fonction constructeur Animal peuvent accéder à la propriété size
cat = new Animal("feline","meow", "walk/run");
cat.prototype.size = "fat";
Dans ce cas, toutes les propriétés size des objets Animal sont "fat" par défaut. L'original est une nouvelle instance d'Object, car il est toujours un objet, on peut donc ajouter de nouvelles propriétés à cet objet. Comme style est un objet de JavaScript, on peut également ajouter des propriétés à la suite de style.
<script type="text/javascript">
/*Définir une classe Person*/
function Person(_name,_age,_salary){
//Les propriétés publiques de la classe Person, la manière de définir les propriétés publiques est : "this.attribut"
this.Name=_name;
//Les propriétés privées de la classe Person, la manière de définir les propriétés privées est : "var attribut"
var Age=_age;
var Salary=_salary;
//Définir une méthode publique (méthode privilégiée) de la classe Person, la manière de définir une méthode publique de la classe
est : "this.functionName=function(){.....}"
this.Show=function(){
alert("Age="+Age+"\t"+"Salary="+Salary);//Il est permis d'accéder aux propriétés privées de la classe dans une méthode publique
}
</script>
Lorsqu'un objet cherche une propriété, il parcourt d'abord ses propres propriétés, s'il ne la trouve pas, il continue de chercher l'objet de référence [[Prototype]], s'il ne la trouve pas non plus, il continue de chercher [[Prototype]].[[Prototype]] l'objet de référence, etc., jusqu'à ce que [[Prototype]].….[[Prototype]] soit undefined (le [[Prototype]] de l'Object est undefined)
En termes simples, c'est par le biais du [[Prototype]] de l'objet qui conserve la référence à un autre objet, à travers cette référence, il est possible de rechercher les attributs vers le haut, c'est la chaîne de prototype.
L'objet null
Le rôle de l'affectation de null à une variable js :
Affecter un pointeur vide, cela rend facile à comprendre que cette variable est préparée pour stocker des objets. Cela facilite également le débogage.
L'objet global window
Toute fonction ou variable globale en JavaScript est une propriété de window.
L'objet self est identique à l'objet window, self est généralement utilisé pour confirmer que c'est dans la fenêtre actuelle.
Les principaux objets de window principaux sont les suivants :
Objet document JavaScript
Objet frames JavaScript
Objet history JavaScript
Objet location JavaScript
Objet navigator JavaScript
Objet screen JavaScript
Quelques méthodes courantes
La méthode valueof() : retourne la valeur originale de l'objet spécifié
La méthode split() divise une chaîne en un tableau de chaînes et retourne ce tableau.
La méthode indexOf() permet de retourner la position de la première apparition d'une valeur spécifiée dans une chaîne.
La méthode substring() est utilisée pour extraire des caractères situés entre deux indices spécifiés dans une chaîne.
La méthode substr() permet d'extrait une chaîne de caractères à partir d'une chaîne, à partir de la position startPos.
La méthode join() est utilisée pour mettre tous les éléments d'un tableau dans une chaîne de caractères.
arrayObject.join(separateur)
La méthode reverse() est utilisée pour inverser l'ordre des éléments dans un tableau.
La méthode slice() permet de retourner des éléments sélectionnés à partir d'un tableau existant.
Objet littéral
Un objet littéral est utilisé pour créer un processus contenant un grand nombre d'attributs, comme indiqué ci-dessous :
<script type="text/javascript">
var company = {
name : "Microsoft",
ages : 39,
employees : 99000,
CEO : "Nadella"
};
</script>
Il est important de noter que les attributs et leurs valeurs sont séparés par des deux points (:); plusieurs attributs sont séparés par des virgules (,). Un objet littéral peut également définir des méthodes, il suffit d'écrire function sur les attributs de cet objet, c'est une fonction anonyme, pour l'appeler, il suffit d'écrire son nom de méthode().
<script type="text/javascript">
var dog = {
name:"husky",
age:2,
run:function(){
return "123";
}
}
alert(dog.run());//Si l'entrée est dog.run, alors le code de la partie function suivant sera affiché
</script>
Enveloppeur de type de valeur de base
js possède cinq types de valeurs de base : number, string, Boolean, null et undefined. Sauf null et undefined, les trois autres ont ce qu'on appelle des objets de base enveloppants. Les objets enveloppants peuvent être créés à l'aide des constructeurs intégrés Number(), String() et Boolean().
var num = new Number(10);
console.log(typeof num);//object
Méthode Object()
Object(); // Retourne un objet vide
Object(undefined); // Retourne un objet vide
Object(null); // Retourne un objet vide
Object(1) // Équivaut à new Number(1)
Object('foo'); // Équivaut à new String('foo')
Object(true); // Équivaut à new Boolean(true)
Object([]); // Retourne l'array original
Object({}); // Retourne l'objet original
Object(function(){}); // Retourne la fonction originale
Partie de l'array
1.L'objet Array
L'objet Array : fournit le support pour créer des tableaux de tout type de données.
arrayObj = new Array()
arrayObj = new Array([size])
arrayObj = new Array([element0[, element1[ ...[, elementN]]]])
Définition : var arr = [2,3,45,6]; var arr = new Array(2,4,5,7)
Il n'y a aucune différence entre les deux en termes de définition, [] est plus performant car le code est plus court.
Utiliser des tableaux et des littéraux d'objets : var aTest = []; Utiliser un littéral de tableau lors de la création d'un tableau est une bonne option ; de même, un littéral d'objet peut également être utilisé pour économiser de l'espace. Les deux lignes suivantes sont égales, mais celle utilisant le littéral d'objet est plus courte :
var oTest = new Object; //Ne pas utiliser
var oTest = { }; //La meilleure option, ou var 0Test = [ ];
Pour parcourir un array, il est recommandé d'utiliser le classic for-loop pour obtenir le meilleur performances.
var list = [1, 2, 3, 4, 5, ...... 100000000];
for(var i = 0, l = list.length; i < l; i++) {
console.log(list[i]);
}
Le code ci-dessus contient une astuce, c'est-à-dire le cache de la longueur de l'array via l = list.length.
Constructeur Array
En raison de la ambiguïté de la manière dont le constructeur Array traite les arguments, il est toujours recommandé d'utiliser la syntaxe littérale des arrays - [] - pour créer un array.
Par conséquent, le code suivant pourrait prêter à confusion :
new Array(3, 4, 5); // Résultat : [3, 4, 5]
new Array(3) // Résultat : [], la longueur de cet array est 3
Il est recommandé d'éviter d'utiliser le constructeur d'array pour créer de nouveaux arrays. Il est préférable d'utiliser la syntaxe littérale des arrays. Elles sont plus courtes et plus concises, ce qui augmente la lisibilité du code.
Les propriétés de l'array Array
Les propriétés de l'array Array3Les propriétés suivantes : propriété length, propriété prototype, propriété constructor
1.length propriété
La propriété length représente la longueur de l'array, c'est-à-dire le nombre d'éléments. Comme les indices des arrays commencent toujours par 0, les bornes d'un array sont : 0 et length-1En ce qui concerne JavaScript, contrairement à la plupart des autres langages, la propriété length des arrays est modifiable, ce qui doit être particulièrement noté.
2.prototype propriété
Retourne une référence à l'original du prototype de l'objet. La propriété prototype est partagée par tous les objets.
Pour illustrer l'utilisation de la propriété prototype pour l'objet Array, voici un exemple.
Ajouter une méthode retournant l'élément maximal d'un array à l'objet array. Pour cela, déclarez une fonction, ajoutez-la à Array.prototype et utilisez-la.
function array_max()
{
var i,max=this[0];
for(i=1;i<this.length;i++)
{
if(max<this[i])
max=this[i];
}
return max;
}
Array.prototype.max=array_max;
var x=new Array(1,2,3,4,5,6);
var y=x.max();
Après l'exécution de ce code, y conserve la valeur maximale de l'array x, ou disons6.
3.attribut constructor
représente la fonction de création d'objet. Explication : l'attribut constructor est un membre de tous les objets ayant un prototype. Ils incluent tous les objets natifs de JScript, à l'exclusion de l'objet Global et Math. L'attribut constructor conserve une référence à la fonction de construction de l'instance spécifique de l'objet.
Par exemple :
x = new String("Hi");
if(x.constructor==String) //Traiter (condition true).
//ou
function MyFunc{
//Corps de la fonction.
}
y=new MyFunc;
if(y.constructor==MyFunc)//Traiter (condition true).
Pour un array :
y = new Array();
Méthode de l'objet Array
Méthode sort()
Syntaxe
arrayObject.sort(sortby)
sortby est optionnel. Définit l'ordre de tri. Doit être une fonction.
var arr = [11,2,28,4,5,1});
console.log(arr.sort());//retourne [1, 11, 2, 28, 4, 5]
Pourquoi ici11、28Ne sont pas classés dans l'ordre ? C'est parce que le sort sans paramètres trie selon l'ordre des caractères codés.
Alors, si vous voulez que les éléments de l'array soient triés de la plus petite à la plus grande valeur, regardez le code suivant :
var arr = [11,2,28,4,5,1});
console.log(arr.sort(function(a,b){
retourne a-b;//retourne [1, 2, 4, 5, 11, 28]
});
Si vous souhaitez trier selon d'autres critères, vous devez fournir une fonction de comparaison, qui doit comparer deux valeurs et retourner un nombre pour indiquer l'ordre relatif de ces deux valeurs. La fonction de comparaison doit avoir deux paramètres, a et b, et son retour doit être comme suit :
Si a est inférieur à b, dans l'array trié, a doit apparaître avant b, retourne une valeur inférieure à 0.
Si a est égal à b, retourne 0.
Si a est supérieur à b, retourne une valeur supérieure à 0.
C'est tout pour cet article. J'espère que cela pourra aider votre apprentissage et j'espère que vous continuerez à soutenir le tutoriel Néon.