Partie de l'objet JavaScript
1: partie de base
1. Toutes les variables en JavaScript sont des objets, à deux exceptions nuls et non définies.
2.JScript prend en charge quatre types d'objets: objets internes, objets générés, objets donnés par l'hôte (tous les objets BOM et DOM sont des objets hôtes.), Et des objets ActiveX (composants externes).
3. Microsoft JScript fournit 11 objets internes (ou "intégrés"). Ce sont des objets Array, Boolean, Date, Function, Global, Math, Number, Object, Regexp, Error et String.
4. 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 le prototype, pas basé sur les classes.
5. Attribut: est 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.
6. Les objets JScript sont des collections 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.
7. Les objets JavaScript sont basés sur les fonctions du constructeur. Lorsque vous utilisez des fonctions de 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 ();
8. 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.
La copie de code est la suivante:
<script type = "text / javascript">
// L'objet est une collection de paires de noms / valeur
Var Browser = {// L'objet est enfermé en accolades bouclées
Nom: "Firefox",
noyau: "gecko"
};
</cript>
La copie de code est la suivante:
// Accédez aux propriétés de l'objet via DOT (.) Ou "[]"
Browser.name // "Firefox"
Browser ["Kernel"] // "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 une fonction d'objet spécial, 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.
Clarifier le concept:
"Object-basé = orienté objet" dans JS 4. Il n'y a pas de classe (classe) dans JS, mais il prend un nouveau nom appelé "Prototype Object", donc "Class = Prototype Object"
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:
La copie de code est la suivante:
<script type = "text / javascript">
var boy = {}; // Créer un objet vide
boy.name = "xiao ming"; // attribuer des valeurs en fonction des propriétés de l'objet prototype
boy.age = 12;
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:
La copie de code est la suivante:
<script type = "text / javascript">
Personne de fonction (nom, âge) {
this.name = name;
this.age = âge;
}
</cript>
Nous pouvons maintenant générer des objets d'instance.
La copie de code est la suivante:
<script type = "text / javascript">
var boy = new personne ("xiao ming", "12");
var girl = nouvelle personne ("xiaohong", "10");
alerte (boy.name); // Xiao Ming
alerte (boy.age); // 12
</cript>
À l'heure actuelle, Boy and Girl contiendra automatiquement un attribut de constructeur pointant vers leur constructeur.
La copie de code est la suivante:
alerte (boy.constructor == personne); //vrai
alerte (girl.constructor == personne); //vrai
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 l'instance du constructeur.
Cela signifie que nous pouvons définir directement ces propriétés et méthodes inchangées sur l'objet Prototype.
La copie de code est la suivante:
<script type = "text / javascript">
Personne de fonction (nom, âge) {
this.name = name;
this.age = âge;
}
Personne.protype.type = "humain";
Personne.protype.eat = function () {
alerte ("manger du riz");
}
</cript>
Ensuite, générez l'instance:
La copie de code est la suivante:
<script type = "text / javascript">
var boy = new personne ("xiao ming", "12");
var girl = nouvelle personne ("xiaohong", "10");
alerte (boy.type); // humain
boy.eat (); // manger
</cript>
À 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 qui étendent les 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.
La copie de code est la suivante:
<script type = "text / javascript">
/ * Définir une classe de personne * /
Personne de fonction (_name, _age, _salary) {
// Les attributs publics de la classe de personne, les attributs publics de la classe sont définis comme: "Ce nom d'attribut"
this.name = _name;
// Les attributs privés de la classe de personne, les attributs privés de la classe sont définis comme: "Nom d'attribut var"
var age = _age;
var salaire = _salary;
// définir la méthode publique (méthode privilégiée) de la classe de personne, la définition de la méthode publique de la classe
Oui: "this.functionname = function () {......}"
this.show = function () {
alert ("age =" + age + "/ t" + "salaire =" + salaire); // l'accès aux propriétés privées de la classe dans la méthode publique est autorisée
}
</cript>
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 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 d'attributs.
La copie de code est la suivante:
<script type = "text / javascript">
Var Company = {
Nom: "Microsoft",
Âges: 39 ans,
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.
La copie de code est la suivante:
<script type = "text / javascript">
var dog = {
Nom: "Husky",
Âge: 2 ans,
run: function () {
retourner "123";
}
}
alert (dog.run ()); // si vous entrez dog.run, le code de la partie de la fonction après qu'il apparaîtra
</cript>
Partie du tableau javascript
1.Assurez-vous objet
Objet Array: fournit une prise en charge de la création de tableaux de tout type de données.
La copie de code est la suivante:
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 l'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.
La copie de code est la suivante:
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
3 Propriétés du tableau Array: Attribut de 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.
La copie de code est la suivante:
fonction array_max ()
{
var i, max = this [0];
for (i = 1; i <this.length; i ++)
{
if (max <this [i])
max = this [i];
}
retourner 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:
La copie de code est la suivante:
x = new String ("Hi");
if (x.constructor == String) // Process (la condition est vraie).
//ou
fonction myfunc {
// Corps de fonction.
}
y = new myfunc;
if (y.constructor == myfunc) // processus (la condition est vraie).
Pour les tableaux:
y = new Array ();
Méthode du tableau:
Attaché un éventail de cartes mentales: