Écrire devant
Aujourd'hui, je souhaite consulter les connaissances des types de nœuds et le type de connaissances que je veux résumer. J'ai vu un article sur Google, mais le lien d'origine a disparu. J'ai retiré cet article dans l'instantané. Si l'auteur d'origine a des questions, veuillez me contacter!
Cet article est basé sur certains JS, et les experts le sauteront automatiquement! Je n'ai pas beaucoup écrit sur JS auparavant, et cet aspect est relativement faible, donc j'ai également rencontré des problèmes lors de l'écriture de nœuds. Voici un complément à mes connaissances!
texte
La base de Node.js est JavaScript, la langue de script. Une caractéristique commune de la plupart des langages de script est "Type faible".
Contrairement à PHP, même s'il existe de nouvelles variables dans PHP, il n'est pas nécessaire de les déclarer, tandis que JavaScript a encore besoin de VAR pour les déclarer. Ce var couvre tous les types de significations telles que int, string, char, etc. en C ++, et même les fonctions.
Tout le contenu de cet article et de l'article suivant sont modifiés à l'aide de VIM dans Linux ou Cygwin (sinon, veuillez le convertir en votre propre méthode), puis afficher les résultats sous la ligne de commande.
Syntaxe de base
Déclaration variable
En C / C ++, nous déclarons des variables comme ceci:
`` C ++
La copie de code est la suivante:
void foo () {}
int a = 0;
char b = 'a';
float c = 1,0f;
void (* d) () = foo; /// <oublié si c'est ce que j'ai écrit, en bref, c'est un pointeur de fonction
Et dans Node.js, cela ressemble à ceci:
`` `JavaScript
La copie de code est la suivante:
fonction foo () {}
var a = 0;
var b = 'a';
var c = 1,0;
var d = foo;
Ainsi, quel que soit le type de variable, il est résolu avec un var dans Node.js.
Déclaration de boucle
pour… je
Cette instruction LOOP est fondamentalement la même que C / C ++, les deux
`` C ++
La copie de code est la suivante:
pour (int i = 0; i <foo; i ++)
{
// ...
}
Et puisque Node.js est un type faible, juste besoin:
`` `JavaScript
La copie de code est la suivante:
pour (var i = 0; i <foo; i ++) {
// ...
}
pour… dans
Il s'agit d'une déclaration de boucle post-forme, similaire à Foreach de PHP.
Par exemple, nous avons un objet JSON comme suit:
javascrip
La copie de code est la suivante:
var foo = {
"Bonjour le monde",
"nœud": "js",
"Blahblah": "bar"
};
À l'heure actuelle, nous pouvons utiliser pour ... pour faire un peu à travers:
javascrip
La copie de code est la suivante:
pour (clé var dans foo) {
console.log (key + ":" + foo [key]);
}
Si nous tapons la commande suivante dans la ligne de commande:
La copie de code est la suivante:
$ node foo.js
Le contenu suivant sera affiché à l'écran:
La copie de code est la suivante:
Bonjour
: monde
Node: JS
blahblah: barre
Astuce: D'après ce qui précède, l'instruction FOR ... est utilisée pour traverser les noms clés des objets, des tableaux et des objets JSON, sans fournir de traversée de valeurs clés. Si vous souhaitez obtenir la valeur clé, vous ne pouvez l'obtenir que sous la forme de FOO [<Nom de la clé actuel>]. C'est encore un peu différent de PHP Forach.
tandis que… faites, faites…
Je n'expliquerai pas autant, ce n'est pas une grande différence par rapport aux autres langues. Ce n'est rien de plus que s'il y a une déclaration variable, il suffit d'utiliser VAR.
Opérateurs
+, -, *, /
C'est le cas avec ces opérateurs, il faut prêter attention à +. Il peut agir à la fois sur les chaînes et les opérations numériques. Bien que les langues de type faible disent que les types sont faibles, les nombres peuvent parfois apparaître sous la forme de chaînes et que les chaînes peuvent parfois apparaître sous la forme de valeurs numériques, mais si nécessaire, vous devez toujours parler du type. Nous pouvons utiliser le code suivant pour voir les résultats:
La copie de code est la suivante:
var a = "1";
var b = 2;
console.log (a + b);
console.log (parseint (a) + b);
Ici, ParseInt est une fonction intégrée de Node.js, qui est utilisée pour analyser une chaîne dans une variable de type int.
Le résultat de l'exécution de code ci-dessus est:
La copie de code est la suivante:
12
3
Remarque: le résultat de la première console.log est 12. Puisque A est une chaîne, B est également ajouté en tant que chaîne par le système. Le résultat est que les deux chaînes sont collées ensemble et deviennent 12. Le résultat de la deuxième console.log est 3 parce que nous convertissons le premier AT en type int, et avons ajouté deux variables de type int, c'est-à-dire, ajouter des valeurs, et bien sûr, le résultat est 3.
==, == ,! = ,! ==
Voici un point pour expliquer que lorsque la longueur de cet opérateur logique est 2 (== ,! =), elle détermine seulement si la valeur externe est la même, mais ne détermine pas le type. comme
La copie de code est la suivante:
var a = 1, b = "1";
console.log (a == b);
Le résultat de sa sortie est vrai. Mais si nous ajoutons un signe égal lorsque nous faisons des jugements au milieu, nous porterons un jugement strict. Ce ne sera vrai que lorsque le type et la valeur sont les mêmes, sinon ce sera faux. C'est-à-dire
La copie de code est la suivante:
var a = 1, b = "1";
console.log (a === b);
Quand, le résultat renvoyé est faux, car A est de type int, tandis que B est une chaîne.
Soit dit en passant, parlons de la déclaration conditionnelle. En fait, si ici n'est pas différent des autres langues, ce n'est qu'un problème de deux signes égaux et de trois signes égaux pour plusieurs opérateurs logiques. Je ne ferai donc pas beaucoup de déclaration fatigante.
typeof
Ici, je le considérerai comme un opérateur plutôt que comme une fonction.
La fonction de cet opérateur est de juger le type de variable, et renvoie une chaîne, c'est-à-dire le nom de type. Vous saurez si vous exécutez le code suivant:
La copie de code est la suivante:
fonction foo () {}
var a = 0;
var b = 'shh ~ La soupe des fleurs d'oeuf dort. ';;
var c = 1,0;
var d = foo;
var e = {"a": a};
var f = [1, 2, 3];
var g = null;
var h = non défini;
console.log (typeof a);
console.log (type de b);
console.log (typeof c);
console.log (typeof d);
console.log (typeof e);
console.log (typeof f);
console.log (typeof g);
console.log (typeof h);
Le résultat de l'exécution ici sera:
La copie de code est la suivante:
nombre
chaîne
nombre
fonction
objet
objet
objet
indéfini
nul, indéfini, nan
Dans JavaScript, il existe trois valeurs spéciales, comme indiqué dans le titre. Tout le monde connaît peut-être le premier. Il y a aussi C / C ++, mais il est capitalisé, et son essence en est une.
`` C ++
définir null 0
En JavaScript, les significations de ces trois valeurs sont différentes.
### nul ###
Null est un objet spécial, ce qui signifie à peu près vide. Par exemple:
var a = null;
Tout le monde peut le comprendre, donc je ne l'expliquerai pas. Mais contrairement à C / C ++, ce null n'est pas égal à 0.
### Undefined ###
Ce que cette chose signifie, c'est que cette variable n'est pas déclarée. Afin de mieux distinguer NULL, notre exemple de code est le suivant:
`` `JavaScript
La copie de code est la suivante:
var a = {
"Foo": null
};
console.log (a ["foo"]);
console.log (a ["bar"]);
Dans le code ci-dessus, nous rendons la valeur d'un ["foo"] vide, c'est-à-dire nul. Et il n'est pas du tout déclaré, il n'est même pas vide. Tout le monde aurait dû deviner les résultats de sortie:
La copie de code est la suivante:
nul
indéfini
Nan
Il s'agit d'une valeur vide, un nombre spécial. Son nom complet n'est pas un numéro. C'est un peu étrange. Vous pouvez le comprendre comme une variable de type numérique qui n'est pas un formulaire numérique ou une variable de type numérique avec des erreurs.
Il se produit souvent lorsque des erreurs de fonctionnement numériques à virgule flottante (comme la division par 0), ou même l'utilisateur peut faire une variable égale à Nan par lui-même pour renvoyer une valeur d'erreur afin que tout le monde sache que la fonction a eu une erreur de fonctionnement.
Petit
Les autres déclarations restantes sont similaires à d'autres langues existantes, telles que la rupture, le commutateur, la poursuite, etc.
Type variable
Cette section parle principalement d'objets JavaScript, et d'autres types sont presque les mêmes.
Type de base
Les types de base contenus dans Node.js sont presque les suivants:
nombre
chaîne
booléen
tableau
Les trois premiers types peuvent être attribués directement et l'affectation du tableau n'est qu'une affectation de référence. Si une certaine valeur est modifiée dans une nouvelle variable, la valeur de l'ancienne variable changera également. Vous pouvez essayer directement le code suivant:
javascrip
var foo = [1, 2, 3];
var bar = foo;
bar [0] = 3;
console.log (foo);
Il en résulte:
javascrip
[3, 2, 3]
En d'autres termes, si un tableau est copié dans un nouveau tableau, il ne peut pas être utilisé pour attribuer directement des valeurs, mais doit être "profondément copié".
Ici, nous devons parler des trois façons de créer un tableau.
Le premier type:
javascrip
La copie de code est la suivante:
var dog = new Array ();
chien [0] = "shh ~";
chien [1] = "soupe de fleur d'oeuf";
chien [2] = "dormir";
Le deuxième type:
javascrip
La copie de code est la suivante:
Var Dog = Nouveau tableau ("Shh ~", "Oeuf Flower Soup", "Sleeping");
Le quatrième type:
javascrip
La copie de code est la suivante:
Var Dog = [
"Shh ~",
"Soupe de fleur d'oeuf",
"Dormir"
]]
Je préfère personnellement la troisième façon d'écrire, ce qui est relativement concis.
Objets JSON
Ici, je retire l'objet JSON séparément au lieu de le classer comme un objet JavaScript. Si je pense que je suis un peu trompeur, je peux ignorer cette section directement.
Ma distinction entre les objets JSON et les objets JavaScript est de savoir s'il est utilisé pour stocker les données uniquement, plutôt que l'instanciation d'une classe. En fait, l'essence de JSON est la notation d'objet JavaScript.
Pour plus d'informations sur JSON, veuillez vous-même encyclopédie.
Déclarer un objet JSON dans Node.js est très simple:
javascrip
La copie de code est la suivante:
var dog = {
"pre": "shh ~",
"sub": {
"nom": "soupe de fleurs d'oeufs",
"Act": "Sleeping",
"Temps": 12
},
"Suf": ["J'ai dit", "ça dort", "ça dort"]
};
Il existe deux façons d'obtenir la valeur clé d'un certain nom de clé dans un objet JSON. La première consiste à le connecter avec des points, et le second est d'utiliser des supports:
javascrip
La copie de code est la suivante:
chien
.pré;
chien ["pre"];
Remarque: Lorsque vous utilisez des points ci-dessus, la clé de JSON est directement suivie. Si vous traitez la clé comme une variable, vous ne pouvez l'essayer qu'avec un chien [clé]: Vous pouvez maintenant l'essayer vous-même et utiliser pour ... pour traverser l'objet JSON ci-dessus. N'oubliez pas d'utiliser le type de ~
La base d'une classe (objet)
À strictement parler, la classe de Node.js ne peut pas être considérée comme une classe. En fait, ce n'est qu'une collection de fonctions, ajoutant certaines variables membre. Son essence est en fait une fonction.
Cependant, pour le bon sens, nous l'appellerons "classe" suivant et ultérieure, et l'instancié est appelé "objet".
Parce qu'une classe a de nombreuses fonctions, ou que son essence est une fonction, nous pouvons parler des bases de la fonction lorsque nous ne faisons pas attention.
Déclaration et instanciation des classes
Déclarer un cours est très simple, ne riez pas:
javascrip
fonction foo () {
// ...
}
Ok, nous avons écrit une classe FOO.
Vrai ou faux? ! réel.
Vous ne le croyez pas? Si vous ne le croyez pas, vous pouvez taper un code et le lire:
javascrip
var bar = new foo ();
Ne le considérez pas comme une fonction, si elle est écrite sous une telle forme (nouvelle), c'est une instanciation de cette classe.
Et ce soi-disant foo () est en fait le constructeur de cette classe foo ().
Variables des membres
Il existe deux bonnes façons d'obtenir des variables membres.
La première consiste à utiliser ce. <Nom de la variable> dans le constructeur de classe ou n'importe quel constructeur. Vous pouvez déclarer une variable de membre à tout moment et cela n'affectera pas l'utilisation à l'extérieur. Quoi qu'il en soit, même si vous l'utilisez lorsqu'il n'est pas déclaré, il y aura un non défini pour le soutenir. C'est donc la première méthode:
La copie de code est la suivante:
javascrip
fonction foo () {
this.hello = "world";
}
Remarque: il s'agit de la variable membre de la classe d'appel uniquement lorsque cela est ajouté, sinon il ne s'agit qu'une variable locale dans la fonction. Il est nécessaire de distinguer s'il existe la portée d'action de cette variable.
La deuxième méthode consiste à le déclarer en dehors du constructeur ou de toute fonction membre, et son format est <nom de classe> .prototype. <Nom de la variable>:
javascrip
La copie de code est la suivante:
fonction foo () {
// ...
}
foo.prototype.hello = "world";
Peu importe laquelle de la méthode ci-dessus est une déclaration de variables membres, nous pouvons voir l'effet:
javascrip
La copie de code est la suivante:
var bar = new foo ();
console.log (bar.hello);
Vous pouvez même modifier cette classe comme ceci:
javascrip
La copie de code est la suivante:
fonction foo () {
this.hello = "world";
}
foo.prototype.hello = "soupe de fleur d'oeuf";
Utilisez ensuite le code ci-dessus pour le sortir.
Réfléchissez à la raison pour laquelle la production est le monde au lieu de la soupe aux œufs.
Constructeur
Nous avons déjà dit que Foo () est en fait un constructeur. Alors évidemment, nous pouvons transmettre des paramètres au constructeur, nous avons donc le code suivant:
javascrip
La copie de code est la suivante:
// Code 2.1
fonction foo (bonjour) {
if (Hello === Undefined) {
this.hello = "world";
} autre {
this.hello = bonjour;
}
}
Nous voyons un étrange jugement à ce sujet si (Hello === Undefined). À quoi sert ce jugement? La première possibilité est que le développeur a spécialement envoyé une douleur non définie. Pour le moment, il n'est pas défini.
Il y a une autre situation. Nous avons dit depuis le début que JavaScript est une langue de type faible. En fait, ce n'est pas seulement un type faible, mais ses paramètres de transmission sont également très désagréables. Vous pouvez passer plus ou moins (tant que vous vous assurez que le programme ne fait aucune erreur lorsque vous passez plus ou moins), il est correct en principe. Les paramètres de plusieurs passes seront automatiquement ignorés, tandis que les paramètres de quelques passes seront complétés par non défini.
Regardez simplement le code suivant et vous comprendrez:
javascrip
La copie de code est la suivante:
// Connectez le code 2.1 sur
var bar1 = new foo ();
var bar2 = nouveau foo ("soupe de fleur d'oeuf");
Veuillez produire deux variables Hello Bar par vous-même, et vous constaterez que l'un est le monde et l'autre est une soupe aux œufs. De toute évidence, lorsque notre premier BAR1 a été déclaré, il a été automatiquement considéré comme par node.js:
javascrip
La copie de code est la suivante:
var bar1 = new foo (non défini);
Il y a donc un dicton que c'est le monde.
Également dans ce constructeur, nous voyons que le paramètre passé est bonjour, et il y a une variable de membre dans cette classe qui est ceci.hello. Cependant, nous avons déjà dit que la portée était différente quand il y a cela et ce n'est pas le cas. Ce paramètre n'est utilisé que dans le constructeur, tandis que celui avec ceci est une variable de membre. Utilisez-le pour les distinguer immédiatement, donc cela n'a pas d'importance même si le même nom est.
Fonctions membres
Déclaration de fonction des membres
La déclaration d'une fonction membre est similaire à la deuxième méthode de déclaration d'une variable de membre, c'est-à-dire <nom de classe> .prototype. <Nom de fonction> = <fonction>;
javascrip
La copie de code est la suivante:
// Connectez le code 2.1 sur
fonction sethello (bonjour) {
this.hello = bonjour;
}
foo.prototype.sethello = Sethello;
Bar1.Sethello ("Egg Cake");
Comme le code ci-dessus est évident, nous implémentons la fonction Sethello de la classe FOO, à travers laquelle nous pouvons modifier la valeur de foo.hello.
Mais n'est-ce pas un peu gênant d'écrire comme ça? Ensuite, je parlerai d'une fonctionnalité importante des fonctions JavaScript.
★ Fonctions anonymes ★
Plusieurs fois, certaines de nos fonctions ne sont référencées ou appelées qu'en un seul endroit, il est donc trop utile de donner un nom à cette fonction, et il n'y a pas besoin, nous pouvons donc écrire cette fonction temporairement et demander directement à la personne qui le fait référence pour le référencer, et la personne qui l'appelle pour l'appeler. Par conséquent, la fonction peut omettre le nom de la fonction, tel que:
javascrip
La copie de code est la suivante:
fonction (bonjour) {
this.hello = bonjour;
}
Quant à la façon de le citer ou de l'appeler? Si la classe ci-dessus doit être citée, elle est écrite comme ceci:
javascrip
La copie de code est la suivante:
foo.prototype.sethello = fonction (bonjour) {
this.hello = bonjour;
}
Cette méthode d'écriture est la même que la déclaration de la fonction des membres et enregistre beaucoup de code. Et en fait, fondamentalement, la déclaration des fonctions des membres de la classe est déclarée de cette manière de fonctions anonymes.
Quant à savoir comment faire appeler les fonctions anonymes? Ceci est généralement écrit comme celui-ci lors du passage dans une fonction qui n'est appelée que par une certaine fonction.
Par exemple, nous avons un prototype d'une fonction:
javascrip
La copie de code est la suivante:
/ **
* Nous passerons en deux variables A et B,
* Après avoir calculé la valeur de A + B, remettez-la à Func (NUM)
* Aller à la sortie
* /
fonction sumab (a, b, func) {
var c = a + b;
func (a, b, c);
}
Par exemple, nous avons deux versions des fonctions de sortie, l'une est la sortie chinoise et l'autre est une sortie anglaise. Donc, si nous n'utilisons pas de fonctions anonymes:
javascrip
La copie de code est la suivante:
fonction zh (a, b, sum) {
La valeur de console.log (a + "+" + b + "est:" + sum);
}
fonction en (a, b, sum) {
console.log (a + "plus" + b + "est" + sum);
}
Sumab (1, 2, Zh);
Sumab (3, 4, en);
Exécutez ce code une fois, et la sortie sera:
La valeur de 1 + 2 est: 3
3 Plus 4 est 7
Si un tel code se présente sous la forme de fonctions anonymes, ce sera:
javascrip
La copie de code est la suivante:
sumab (1, 2, fonction (a, b, sum) {
La valeur de console.log (a + "+" + b + "est:" + sum);
});
sumab (3, 4, fonction (a, b, sum) {
console.log (a + "plus" + b + "est" + sum);
});
Ce formulaire est généralement utilisé dans les fonctions de rappel. Le mécanisme de rappel est l'essence de Node.js ou JavaScript. Je vais le présenter dans les prochains chapitres.
Comment déclarer la fonction anonyme dans la déclaration des fonctions des membres
Bien que j'en ai parlé dans la section précédente, je vais simplement en parler.
Habituellement, lorsque nous déclarons une fonction de membre de la classe, nous utilisons des fonctions anonymes pour la déclarer, car de toute façon, cette fonction n'est qu'une fonction membre de cette classe et ne sera pas référencée ou appelée séparément dans d'autres endroits, donc le code suivant est disponible:
javascrip
La copie de code est la suivante:
// Connectez le code 2.1 sur
foo.prototype.sethello = fonction (bonjour) {
this.hello = bonjour;
}
De cette façon, nous avons la fonction Sethello dans la classe FOO.
2.3.4. Classe arbitraire
Ceci est à nouveau mon non-sens. Le soi-disant aléatoire des classes signifie qu'en JavaScript, vous pouvez modifier votre classe n'importe où, qui a certaines similitudes avec Ruby.
Par exemple, la chaîne est en fait une classe, avec des variables membres telles que la longueur et des fonctions membres telles que l'indexof et le substr. Mais si nous pensons que certaines parties de cette chaîne ne sont pas parfaites et que nous voulons ajouter notre propre méthode, nous pouvons y ajouter une fonction où vous voulez, comme:
javascrip
La copie de code est la suivante:
String.prototype.sb = fonction () {
var newstr = "";
for (var i = 0; i <this.length; i ++) {
if (i% 2 === 0) newsr + = "s";
else newr + = "b";
}
retour newsr;
};
La signification de cette fonction est de remplir une chaîne pour en faire l'incarnation de SB.
Tessons-le:
La copie de code est la suivante:
var str = "shh ~ ovule fleur soupe dort.";
console.log (str.sb ());
Vous obtiendrez le résultat suivant:
sbsbsbsbsbsbs
Si vous dites "Shhh ~ Egg Flower Soup dort." Votre ordinateur vous grondera pour être un imbécile quatre fois et demi. (Le casser rapidement)
3. Attaché
3.1. Copie profonde
La soi-disant copie profonde est de créer un nouveau tableau ou un nouveau objet par vous-même, et de copier manuellement les valeurs de variable de type de base dans le tableau ou l'objet source un par un, au lieu de simplement prendre les références au tableau ou à l'objet source. Cela implique donc un appel récursif ou quelque chose.
Vous trouverez ci-dessous une fonction de copie profonde que j'ai implémentée. Vous pouvez écrire un des vôtres et l'ajouter à votre propre base de connaissances Node.js.
javascrip
La copie de code est la suivante:
fonction clonoobject (src) {
var dest = {};
pour (clé var dans src) {
if (typeof src === "objet") dest [key] = cloneObject (src [key]);
else dest [key] = src [key];
}
retour dest;
}