JavaScript doit apprendre tous les jours

Partie de l'objet

Type d'objet

L'objet est une collection non ordonnée qui peut stocker des objets de tout type, et tous les autres objets sont hérités de cet objet.

Il existe deux types de création d'objets, l'un consiste à utiliser le nouvel opérateur et l'autre est une notation littérale.

1. Créez un objet en utilisant le nouvel opérateur

var obj = new object (); // prêtez attention à la capitalisation, vous pouvez également l'écrire directement en tant qu'objet ()

Notez que la génération d'un nouvel objet via la nouvelle méthode objet () est équivalente à la méthode littérale obj = {}.

2. Créer en utilisant la méthode littérale:

 var obj = {name: 'Trigkit4', âge: 21}; // Le point-virgule est préférable à ajouter

Lors de la déclaration d'un objet d'objet utilisant des littéraux, le constructeur objet () n'est pas appelé (sauf ff)

Objet.prototype objet

Tous les constructeurs ont un attribut prototype qui pointe vers un objet prototype.

 Object.prototype.print = function () {console.log (this)}; var obj = new object (); obj.print () // objet

L'instance obj hérite directement des propriétés et des méthodes de l'objet.prototype

1. Les objets ne sont que des données spéciales. Les objets ont des propriétés et des méthodes. JavaScript est une langue orientée objet, mais JavaScript n'utilise pas de classes. JavaScript est basé sur [Prototype] [1], pas basé sur la classe.

2. Attribut: il s'agit d'une variable affiliée à un objet spécifique. Méthode: c'est une fonction qui ne peut être appelée que par un objet spécifique.

3. Les objets JS sont une collection de propriétés et de méthodes. Une méthode est une fonction, qui est membre d'un objet. Un attribut est une valeur ou un ensemble de valeurs (sous la forme d'un tableau ou d'un objet) qui est membre d'un objet.

4.js L'objet est basé sur la fonction constructeur. Lorsque vous utilisez la fonction constructeur pour créer un nouvel objet, on peut dire qu'un nouvel objet est instancié. Les propriétés sont des variables à l'intérieur de la fonction du constructeur.

Objets instanciés à l'aide de fonctions de constructeur:

chat = nouvel animal ();

JavaScript est une langue basée sur des objets, et presque tout ce que vous rencontrez est un objet. Cependant, ce n'est pas un véritable langage de programmation orienté objet (OOP) car il n'y a pas de classe (classe) dans sa syntaxe.

 <script type = "text / javascript"> // objet est une collection de nom / paires de valeur var navigateur = {// objet est nommé dans des accolades bouclées: "Firefox", kernel: "gecko"}; </ script> // accéder aux attributs de l'objet Browser.name // "Firefox" Browser ["Kernel"] // "Geck" Gecko "

Les objets (OBJCT) sont une collection de propriétés, chaque propriété se compose de "paires de noms / valeur". JS définit également un objet spécial - un tableau, qui est un ensemble ordonné de valeurs numérotées.

JS définit également un objet spécial - une fonction, une fonction est un objet avec un code exécutable qui lui est associé. Il exécute le code en appelant la fonction et renvoie le résultat de l'opération.

Il n'y a pas de classe dans JS, mais il prend un nouveau nom appelé "Prototype Object", donc "class == Prototype Object", voir: Méthode d'écriture de classe JavaScript (i)

2. La différence et la connexion entre les classes (objets prototypes) et les objets (instances)

1. Les classes (objets prototypes) sont abstraits, conceptuels, représentant un type de choses.

2. L'objet est concret, pratique et représente une chose spécifique.

3. La classe (Objet Prototype) est un modèle pour les instances d'objet, et les instances d'objet sont des individus de la classe.

Une idée fausse commune est que la valeur littérale d'un nombre n'est pas un objet. Cela est dû à un bug dans l'analyseur JavaScript qui essaie d'analyser l'opérateur de points dans le cadre de la valeur nominale numérique du point flottant.

Il existe de nombreuses solutions de contournement pour que la valeur littérale d'un nombre ressemble à un objet.

2..ToString (); // Le deuxième point peut être analysé normalement

2.ToString (); // faites attention aux espaces avant le point

(2) .toString (); // 2 est calculé en premier

Supprimer les attributs

La seule façon de supprimer une propriété est d'utiliser l'opérateur de suppression; La définition de la propriété sur Undefined ou NULL ne supprime pas vraiment la propriété, mais supprime simplement l'association entre la propriété et la valeur.

Trois caractéristiques principales de JavaScript objet orienté

Encapsulation: aucune implémentation interne n'est prise en compte, seule une utilisation fonctionnelle est considérée

Héritage: hériter d'un nouvel objet d'un objet existant

Polymorphisme: Le soi-disant polymorphisme fait référence à plusieurs états qui se réfèrent dans différentes situations.

1. Emballage

L'encapsulation signifie regrouper les points communs (y compris les attributs et les comportements) de choses appartenant à la même catégorie dans une classe pour une utilisation facile. Par exemple, la chose humaine peut être encapsulée de la manière suivante:

personnes{

Âge (attribut 1)

Hauteur (attribut 2)

Sexe (attribut trois)

Faire des choses (l'un des comportements)

Marche (comportement 2)

Parler (acte 3)

}

Avantages de l'encapsulation:

L'encapsulation protège l'intégrité des données internes;

L'encapsulation facilite la refactorisation des objets;

Affaiblir le couplage entre les modules et améliorer la réutilisabilité des objets;

Aide à éviter les conflits d'espace de noms;

Voir l'exemple suivant:

 <script type = "text / javascript"> var boy = {}; // Créer un objet vide boy.name = "xiao ming"; // attribuer boy.age = 12 selon les propriétés de l'objet prototype, var girl = {}; girl.name = "xiaohong"; girl.age = 10; </cript>

Il s'agit de l'encapsulation la plus simple, encapsulant deux attributs dans un objet. Cependant, cette méthode d'écriture a deux inconvénients. La première est que si vous générez plus d'instances, il sera très difficile d'écrire; L'autre est qu'il n'y a aucun moyen de savoir s'il existe un lien entre l'instance et le prototype.

Mode constructeur

Pour résoudre le problème de la génération d'instances à partir d'objets prototypes, JavaScript fournit un modèle de constructeur.

Le soi-disant "constructeur" est en fait une fonction ordinaire, mais cette variable est utilisée en interne. L'utilisation du nouvel opérateur pour le constructeur peut générer une instance, et cette variable sera liée à l'objet d'instance.

Par exemple, les objets prototypes de garçon et de fille peuvent être écrits comme ça maintenant:

 <script type = "text / javascript"> Personne de fonction (nom, âge) {this.name = name; this.age = âge; } </ script>

Nous pouvons maintenant générer des objets d'instance.

 <script type = "text / javascript"> var boy = new personne ("xiao ming", 12); var girl = nouvelle personne ("Xiao Hong", 10); alerte (boy.name); // Xiao Ming Alert (Boy.age); // 12 </cript>

À l'heure actuelle, Boy and Girl contiendra automatiquement un attribut de constructeur pointant vers leur constructeur.

alerte (boy.constructor == personne); //vrai

alerte (Girl.Constructor); // Sortie toute la chaîne de code du constructeur, essayez-le vous-même

Prototype Match JavaScript stipule que chaque constructeur a un attribut prototype pointant vers un autre objet. Toutes les propriétés et méthodes de cet objet seront héritées par les instances du constructeur.

Cela signifie que nous pouvons définir directement ces propriétés et méthodes inchangées sur l'objet Prototype.

 <script type = "text / javascript"> Personne de fonction (nom, âge) {this.name = name; this.age = age;} personne.protype.type = "humain"; personne.protype.eat = function () {alert ("manger du riz");} </cript>

Ensuite, générez l'instance:

 <script type = "text / javascript"> var boy = new personne ("xiao ming", "12"); var girl = new personne ("xiao hong", "10"); alert (boy.type); // boy.eat (); // manger </ script>

À l'heure actuelle, les méthodes de type Attributs et EAT () de toutes les instances sont en fait la même adresse mémoire, pointant vers l'objet Prototype, améliorant ainsi l'efficacité du fonctionnement.

alert (boy.eat == girl.eat); //vrai

Une propriété Prototype est une propriété intégrée qui spécifie la fonction du constructeur que l'objet étend.

Le code suivant ajoute une nouvelle taille d'attribut à la fonction du constructeur animal, qui est l'attribut prototype de l'objet CAT. En utilisant des propriétés prototypes, tous les objets s'étendant aux fonctions du constructeur animal peuvent accéder à la propriété de taille

 Cat = nouvel animal ("félin", "Meow", "Walk / Run"); cat.prototype.size = "fat";

Dans ce cas, l'attribut de taille de tous les objets animaux est "gras". Le prototype par défaut est une nouvelle instance d'objet. Puisqu'il s'agit toujours d'un objet, de nouveaux attributs peuvent être ajoutés à l'objet. Tout comme le style est un objet en JavaScript, vous pouvez également continuer à ajouter des propriétés après le style.

 <script type = "text / javascript"> / * définir une classe de personne * / fonction personne (_name, _age, _salary) {// L'attribut public de la classe de personne, l'attribut public de la classe est défini comme: "ce.property name" this.name = _name; // L'attribut privé de la classe de personne, l'attribut privé de la classe est défini comme: "Var Attribut Name" var Age = _age; var salaire = _salary; // Définir la méthode publique (méthode privilégiée) de la classe de personne, la méthode publique de la classe est définie comme: "this.functionname = function () {.....}" this.show = function () {alert ("Age =" + Age + "/ T" + "Salary =" + Salaire); // Accéder aux propriétés privées de la classe dans la méthode publique est autorisée} </ script>

Lorsqu'un objet recherche une certaine propriété, il traversera d'abord ses propres propriétés. Sinon, il continuera de rechercher l'objet référencé par [[Prototype]]. Sinon, il continuera à rechercher l'objet référencé par [[Prototype]]. [[Prototype]], et ainsi de suite jusqu'à [[prototype]].

Autrement dit, c'est pour enregistrer une référence à un autre objet via le [[prototype]] de l'objet et rechercher les attributs via cette référence. Ceci est la chaîne prototype.

objet nul

La fonction de JS attribuant des valeurs nulles aux variables est:

L'attribution d'un pointeur nul permet de comprendre facilement que cette variable est préparée pour stocker des objets. Il est également pratique de régler le mauvais

Objet de fenêtre global

Toute fonction globale ou variable dans JavaScript est une propriété de Window.

L'objet auto est exactement le même que l'objet Window. Self est généralement utilisé pour confirmer qu'il est sous la forme actuelle.

Les principaux objets principaux de la fenêtre sont les suivants:

Objet de document JavaScript

Objet JavaScript Frames

Objet d'histoire JavaScript

Objet d'emplacement JavaScript

Objet JavaScript Navigator

Objet d'écran JavaScript

Plusieurs méthodes courantes

Valeurof () Méthode: Renvoie la valeur d'origine de l'objet spécifié

La méthode Split () divise la chaîne en un tableau de chaîne et renvoie ce tableau.

La méthode indexof () renvoie la première occurrence d'une valeur de chaîne spécifiée dans la chaîne.

La méthode substring () est utilisée pour extraire des caractères dans une chaîne entre deux indices spécifiés.

La méthode substr () extrait le nombre spécifié de chaînes à partir de la position startPOS de la chaîne.

La méthode join () est utilisée pour mettre tous les éléments du tableau dans une chaîne.

ArrayObject.join (Demiter)

La méthode inversée () est utilisée pour inverser l'ordre des éléments dans un tableau.

La méthode Slice () renvoie l'élément sélectionné à partir d'un tableau existant.

Objet littéral

Les littéraux d'objets sont des processus utilisés pour créer un grand nombre de propriétés, comme suit:

 <script type = "text / javascript"> var company = {name: "Microsoft", âges: 39, employés: 99000, PDG: "Nadella"}; </cript>

Il convient de noter ici que les attributs et les valeurs d'attribut sont séparés par des Colons (:); Les attributs multiples sont séparés par des virgules (,). L'objet littéral peut également définir des méthodes. Écrivez simplement la fonction sur les attributs de cet objet. Ceci est une fonction anonyme. Il vous suffit d'écrire son nom de méthode () pour l'appeler.

 <script type = "text / javascript"> var dog = {name: "husky", Âge: 2, run: function () {return "123";}} alert (dog.run ()); // si vous entrez dog.run, le code pour la partie de la fonction derrière il apparaîtra </cript>

Type de valeur de base Wrapper

Il existe cinq types de valeur de base dans JS: Numéro, String, Boolean, NULL et UNDEFINED. À l'exception de Null et non définis, les trois autres ont des objets de base d'emballage de base. Les constructeurs intégrés Number (), String () et Boolean () peuvent être utilisés pour créer des objets wrapper.

 var num = nouveau nombre (10); console.log (typeof num); // objet objet () méthode objet () // renvoie un objet d'objet vide (non défini) // renvoie un objet vide (null) // Renvoie un objet d'objet vide (1) // équivalent à un nouveau numéro (1) objet (Foo ') objet (true) // équivalent à new String (' foo ') Objet booléen (true) ([]) // renvoie l'objet de tableau d'origine ({}) // renvoie l'objet d'origine (fonction () {}) // renvoie la fonction d'origine

Partie arrière

1.Assurez-vous objet

Objet Array: fournit une prise en charge de la création de tableaux de tout type de données.

arrayoBj = new Array ()

arrayoBj = nouveau tableau ([taille])

arrayoBj = nouveau tableau ([élément0 [, élément1 [, ... [, élémentn]]]))

Définition: var arr = [2,3,45,6]; var arr = nouveau tableau (2,4,5,7)

Il n'y a pas de différence de définition entre les deux, [] a des performances élevées car le code est court.

Utilisez des littéraux du tableau et des objets: var aTest = []; Lors de la création de tableaux, l'utilisation de littéraux de tableaux est un bon choix; De même, les littéraux d'objets peuvent également être utilisés pour économiser de l'espace. Les deux lignes suivantes sont égales, mais utilisez les littéraux de l'objet pour être plus courts:

 var otest = nouvel objet; // Essayez de ne pas utiliser var otest = {}; // le meilleur choix, ou var 0Test = [];

Traversion Afin d'atteindre les meilleures performances de la traversée des tableaux, il est recommandé d'utiliser un classique pour la boucle.

 var list = [1, 2, 3, 4, 5, ...... 100000000]; pour (var i = 0, l = list.length; i <l; i ++) {console.log (list [i]);}

Le code ci-dessus a un traitement, qui consiste à mettre en cache la longueur du tableau via l = list.length.

Constructeur de tableau

Étant donné que le constructeur de Array est un peu ambigu quand il s'agit de gérer les arguments, il est toujours recommandé d'utiliser la syntaxe littérale des tableaux - [] - pour créer des tableaux.

Par conséquent, le code suivant sera déroutant:

nouveau tableau (3, 4, 5); // Résultat: [3, 4, 5]

Nouveau tableau (3) // Résultat: [], la longueur de ce tableau est 3

Essayez d'éviter d'utiliser des constructeurs de tableaux pour créer de nouveaux tableaux. Il est recommandé d'utiliser la syntaxe littérale des tableaux. Ils sont plus courts et plus concis, augmentant ainsi la lisibilité du code.

Propriétés du tableau de tableau

Trois propriétés du tableau du tableau: attribut longueur, attribut prototype, attribut constructeur

1. Attribut de longueur

L'attribut de longueur représente la longueur du tableau, c'est-à-dire le nombre d'éléments. Parce que l'indice d'un tableau commence toujours à partir de 0, les limites supérieures et inférieures d'un tableau sont respectivement: 0 et longueur-1. Contrairement à la plupart des autres langues, la propriété de longueur des tableaux JavaScript est mutable, ce qui nécessite une attention particulière.

2.Protype Attribut

Renvoie une référence au prototype de type d'objet. L'attribut prototype est commun à l'objet.

Pour les objets de tableau de tableau, utilisez l'exemple suivant pour illustrer l'objectif de l'attribut Prototype.

Ajoutez une méthode à l'objet du tableau pour renvoyer la valeur d'élément maximale dans le tableau. Pour ce faire, déclarez une fonction, ajoutez-la à array.prototype et utilisez-la.

 fonction 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 = nouveau tableau (1,2,3,4,5,6); var y = x.max ();

Une fois ce code exécuté, Y enregistre la valeur maximale dans le tableau X, ou 6.

3. Attribut de construction

Une fonction qui représente la création d'un objet. Description: L'attribut constructeur est un membre de tous les objets avec prototype. Ils incluent tous les objets natifs JScript à l'exception des objets globaux et mathématiques. La propriété du constructeur contient une référence à la fonction qui construit une instance d'objet spécifique.

Par exemple:

 x = new String ("Hi"); if (x.constructor == String) // Process (la condition est vraie). // ou fonction myfunc {// func. } y = new myfunc;

if (y.constructor == myfunc) // processus (la condition est vraie).

Pour les tableaux:

y = new Array ();

Méthode d'objet de tableau

méthode tri ()

grammaire

ArrayObject.Sort (Sortby)

SORTBY Facultatif. Spécifiez l'ordre de tri. Doit être une fonction.

var arr = [11,2,28,4,5,1];

console.log (arr.sort ()); // retour [1, 11, 2, 28, 4, 5]

Pourquoi les 11 et 28 ici ne sont-ils pas organisés dans l'ordre? En effet, le tri sans paramètres est trié dans l'ordre d'encodage des caractères.

Alors, que se passe-t-il si nous voulons trier les éléments du tableau de petit à grand? Regardez le code suivant:

 var arr = [11,2,28,4,5,1]; console.log (arr.sort (fonction (a, b) {return ab; // return [1, 2, 4, 5, 11, 28]}));

Si vous souhaitez trier par d'autres critères, vous devez fournir une fonction de comparaison qui compare deux valeurs, puis renvoie un nombre qui illustre l'ordre relatif des deux valeurs. La fonction de comparaison doit avoir deux paramètres A et B, et sa valeur de retour est la suivante:

Si A est inférieur à B, A doit apparaître avant B dans le tableau trié, alors une valeur inférieure à 0 est renvoyée.

Si A est égal à B, retournez 0.

Si A est supérieur à B, une valeur supérieure à 0 est renvoyée.

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.