Escreva na frente
Hoje, quero verificar o conhecimento dos tipos de nós e que tipo de conhecimento eu quero resumir. Eu vi um artigo no Google, mas o link original se foi. Puxei este artigo no instantâneo. Se o autor original tiver alguma dúvida, entre em contato comigo!
Este artigo é baseado em alguns JS, e os especialistas irão pular automaticamente! Eu não escrevi muito sobre JS antes, e esse aspecto é relativamente fraco, então também encontrei problemas ao escrever nós. Aqui está um suplemento ao meu conhecimento!
texto
A base do Node.js é JavaScript, a linguagem de script. Uma característica comum da maioria dos idiomas de script é o "tipo fraco".
Ao contrário do PHP, mesmo que haja novas variáveis no PHP, não há necessidade de declará -las, enquanto o JavaScript ainda precisa de VAR para declará -las. Esse VAR abrange todos os tipos de significados, como int, string, char, etc. em C ++ e até funções.
Todo o conteúdo deste artigo e o artigo a seguir são editados usando o VIM em Linux ou Cygwin (se não, convertê -lo em seu próprio método) e, em seguida, veja os resultados na linha de comando.
Sintaxe básica
Declaração variável
Em C/C ++, declaramos variáveis como esta:
`` `C ++
A cópia do código é a seguinte:
void foo () {}
int a = 0;
char b = 'a';
flutuar c = 1,0f;
void (*d) () = foo; /// esqueceu se é isso que eu escrevi, em resumo, é um ponteiro de função
E no node.js, parece o seguinte:
`` `JavaScript
A cópia do código é a seguinte:
function foo () {}
var a = 0;
var b = 'a';
var c = 1,0;
var d = foo;
Portanto, não importa que tipo de variável seja, ela é resolvida com um var no node.js.
Declaração de loop
para… i
Esta declaração de loop é basicamente a mesma que C/C ++, ambos
`` `C ++
A cópia do código é a seguinte:
para (int i = 0; i <foo; i ++)
{
// ...
}
E como o Node.js é um tipo fraco, só preciso:
`` `JavaScript
A cópia do código é a seguinte:
for (var i = 0; i <foo; i ++) {
// ...
}
para… in
Esta é uma declaração de loop pós-forma, semelhante à foreach do PHP.
Por exemplo, temos um objeto JSON da seguinte forma:
JavaScript
A cópia do código é a seguinte:
var foo = {
"Olá": "mundo",
"Node": "JS",
"Blahblah": "Bar"
};
Neste momento, podemos usar para ... para fazer um loop através de:
JavaScript
A cópia do código é a seguinte:
para (tecla var no foo) {
console.log (chave + ":" + foo [key]);
}
Se digitarmos o seguinte comando na linha de comando:
A cópia do código é a seguinte:
$ node foo.js
O conteúdo a seguir será exibido na tela:
A cópia do código é a seguinte:
olá
: mundo
Nó: JS
Blahblah: Bar
Dica: a partir do exposto, a declaração for ... é usada para atravessar os nomes de chave de objetos, matrizes e objetos JSON, sem fornecer travessal de valor-chave. Se você deseja obter o valor da chave, só poderá obtê -lo na forma de Foo [<Nome da chave atual>]. Isso ainda é um pouco diferente do PHP foreach.
Enquanto ... faça, faça ... WHILL
Não vou explicar isso, não é uma grande diferença de outros idiomas. Não é nada mais que isso, se houver uma declaração variável, basta usar o VAR.
Operadores
+, -, *, /
É o caso desses operadores, deve -se prestar atenção ao +. Pode agir em cordas e operações numéricas. Embora os idiomas do tipo fraco digam que os tipos são fracos, os números às vezes podem aparecer na forma de cordas, e as cordas às vezes podem aparecer na forma de valores numéricos, mas quando necessário, você ainda precisa falar sobre o tipo que é. Podemos usar o seguinte código para ver os resultados:
A cópia do código é a seguinte:
var a = "1";
var b = 2;
console.log (a + b);
console.log (parseint (a) + b);
Aqui, o Parseint é uma função interna do Node.js, que é usada para analisar uma string em uma variável do tipo int.
O resultado da execução do código acima é:
A cópia do código é a seguinte:
12
3
Nota: O resultado do primeiro console.Log é 12. Como A é uma string, B também é adicionado como uma string pelo sistema. O resultado é que as duas cordas são coladas e se tornam 12. O resultado do segundo console.Log é 3 porque convertemos o primeiro A em Tipo INT e adicionamos duas variáveis do tipo int, ou seja, adicionamos valores e, é claro, o resultado é 3.
==, == ,! =,! ==
Aqui está um ponto para explicar que, quando o comprimento deste operador lógico é 2 (== ,! =), ele apenas determina se o valor externo é o mesmo, mas não determina o tipo. como
A cópia do código é a seguinte:
var a = 1, b = "1";
console.log (a == b);
O resultado de sua saída é verdadeiro. Mas se adicionarmos um sinal igual quando fizermos julgamentos no meio, faremos um julgamento estrito. Só será verdadeiro quando o tipo e o valor forem iguais, caso contrário, será falso. Isto é, dizer
A cópia do código é a seguinte:
var a = 1, b = "1";
console.log (a === b);
Quando o resultado retornado é falso, porque A é do tipo int, enquanto B é uma string.
A propósito, vamos falar sobre a declaração condicional. De fato, se aqui não for diferente de outros idiomas, é apenas um problema de dois sinais iguais e três sinais iguais para vários operadores lógicos. Então, não vou dar uma declaração muito cansativa.
typeof
Aqui vou considerá -lo um operador e não como uma função.
A função deste operador é julgar o tipo de variável e retornará uma string, ou seja, o nome do tipo. Você saberá se executar o seguinte código:
A cópia do código é a seguinte:
function foo () {}
var a = 0;
var b = 'shh ~ sopa de flores de ovo está dormindo. ';
var c = 1,0;
var d = foo;
var e = {"a": a};
var f = [1, 2, 3];
var g = null;
var H = indefinido;
console.log (tipo de A);
console.log (tipo de b);
console.log (tipo de c);
console.log (tipo de d);
console.log (tipo de e);
console.log (tipo de f);
console.log (typeof g);
console.log (tipo de h);
O resultado da execução aqui será:
A cópia do código é a seguinte:
número
corda
número
função
objeto
objeto
objeto
indefinido
nulo, indefinido, nan
No JavaScript, existem três valores especiais, conforme mostrado no título. Todos podem estar familiarizados com o primeiro. Existem também C/C ++, mas é capitalizado e sua essência é uma.
`` `C ++
Defina nulo 0
Em JavaScript, os significados desses três valores são diferentes.
### nulo ###
Null é um objeto especial, que significa aproximadamente vazio. Por exemplo:
var a = nulo;
Todo mundo pode entender, então não vou explicar. Mas, diferentemente do C/C ++, esse nulo não é igual a 0.
### indefinido ###
O que essa coisa significa é que essa variável não é declarada. Para distinguir melhor o NULL, nosso código de exemplo é o seguinte:
`` `JavaScript
A cópia do código é a seguinte:
var a = {
"Foo": nulo
};
console.log (a ["foo"]);
console.log (a ["bar"]);
No código acima, tornamos o valor de um ["foo"] vazio, isto é, nulo. E não é declarado, nem está vazio. Todos deveriam ter adivinhado os resultados da saída:
A cópia do código é a seguinte:
nulo
indefinido
Nan
Este é um valor vazio, um número especial. Seu nome completo não é um número. É um pouco estranho. Você pode entendê -lo como uma variável de tipo de número que não é um formulário numérico ou uma variável de tipo de número com erros.
Muitas vezes, ocorre quando os erros de operação numérica do ponto flutuante (como a divisão por 0) ou mesmo o usuário podem fazer uma variável igual a NAN por si mesmo para retornar um valor de erro para que todos saibam que a função teve um erro em operação.
Pequeno diverso
As outras declarações restantes são semelhantes a outros idiomas existentes, como quebra, troca, continuação, etc.
Tipo variável
Esta seção fala principalmente sobre objetos JavaScript e outros tipos são quase os mesmos.
Tipo básico
Os tipos básicos contidos no Node.js são quase os seguintes:
número
corda
booleano
variedade
Os três primeiros tipos podem ser atribuídos diretamente e a atribuição de matriz é apenas uma tarefa de referência. Se um determinado valor for alterado em uma nova variável, o valor da variável antiga também mudará. Você pode tentar diretamente o seguinte código:
JavaScript
var foo = [1, 2, 3];
var bar = foo;
bar [0] = 3;
console.log (foo);
Resulta em:
JavaScript
[3, 2, 3]
Em outras palavras, se uma matriz for copiada em uma nova matriz, ela não poderá ser usada para atribuir valores diretamente, mas deve ser "profundamente copiada".
Aqui precisamos falar sobre as três maneiras de criar matriz.
O primeiro tipo:
JavaScript
A cópia do código é a seguinte:
var cão = novo array ();
cachorro [0] = "shh ~";
cachorro [1] = "sopa de flores de ovo";
cachorro [2] = "dormindo";
O segundo tipo:
JavaScript
A cópia do código é a seguinte:
var cão = nova matriz ("shh ~", "sopa de flores de ovo", "dormindo");
O quarto tipo:
JavaScript
A cópia do código é a seguinte:
var cão = [
"Shh ~",
"Sopa de flores de ovo",
"Dormindo"
];
Pessoalmente, prefiro a terceira maneira de escrever, que é relativamente concisa.
Objetos json
Aqui eu retiro o objeto JSON separadamente, em vez de classificá -lo como um objeto JavaScript. Se eu acho que sou um pouco enganador, posso pular esta seção diretamente.
Minha distinção entre objetos JSON e objetos JavaScript é se ele é usado para armazenar apenas dados, em vez de instanciação de uma classe. De fato, a essência do JSON é a notação de objeto JavaScript.
Para mais informações sobre o JSON, por favor, enciclopédia você mesmo.
Declarar um objeto JSON no Node.js é muito simples:
JavaScript
A cópia do código é a seguinte:
var cão = {
"pré": "shh ~",
"sub": {
"Nome": "Sopa de flores de ovo",
"ACT": "Sleeping",
"Time": 12
},
"Suf": ["Eu disse", "está dormindo", "está dormindo"]
};
Existem duas maneiras de obter o valor chave de um certo nome de chave em um objeto JSON. O primeiro é conectá -lo com pontos, e o segundo é usar colchetes:
JavaScript
A cópia do código é a seguinte:
cachorro
.pré;
cachorro ["pré"];
Nota: Ao usar pontos acima, a chave no JSON é seguida diretamente. Se você tratar a chave como uma variável, só poderá experimentá -la com o cão [chave]: agora você pode experimentar você mesmo e usar ... para atravessar o objeto JSON acima. Não se esqueça de usar o tipoof ~
A base de uma classe (objeto)
Estritamente falando, a classe do Node.js não pode ser considerada uma classe. De fato, é apenas uma coleção de funções, adicionando algumas variáveis de membros. Sua essência é na verdade uma função.
No entanto, por uma questão de senso comum, chamaremos de "classe" a seguir e mais tarde, e o instanciado é chamado de "objeto".
Como uma classe tem muitas funções, ou sua essência é uma função, podemos falar sobre o básico da função quando não tomamos cuidado.
Declaração e instanciação de classes
Declarar uma aula é muito simples, não ria:
JavaScript
function foo () {
// ...
}
Ok, escrevemos uma aula Foo.
Verdadeiro ou falso? ! real.
Não acredita? Se você não acredita, pode digitar um código e lê -lo:
JavaScript
var bar = new Foo ();
Não olhe para ele como uma função, se escrito de tal forma (novo), é uma instanciação dessa classe.
E este chamado Foo () é na verdade o construtor desta classe Foo ().
Variáveis de membros
Existem duas boas maneiras de obter variáveis de membros.
O primeiro é usar isso. <Nome da variável> No construtor de classe ou em qualquer construtor. Você pode declarar uma variável de membro a qualquer momento e isso não afetará o uso externo. De qualquer forma, mesmo se você o usar quando não for declarado, haverá um indefinido para apoiá -lo. Portanto, este é o primeiro método:
A cópia do código é a seguinte:
JavaScript
function foo () {
this.hello = "mundo";
}
Nota: esta é a variável de membro da classe de chamada somente quando isso é adicionado, caso contrário, é apenas uma variável local na função. É necessário distinguir se existe o escopo de ação dessa variável.
O segundo método é declará -lo fora do construtor ou de qualquer função de membro, e seu formato é <nome da classe> .Prototype. <Nome da variável>:
JavaScript
A cópia do código é a seguinte:
function foo () {
// ...
}
foo.prototype.hello = "World";
Independentemente do método acima é uma declaração de variáveis de membros, podemos ver o efeito:
JavaScript
A cópia do código é a seguinte:
var bar = new Foo ();
console.log (bar.hello);
Você pode até modificar esta classe como esta:
JavaScript
A cópia do código é a seguinte:
function foo () {
this.hello = "mundo";
}
foo.prototype.hello = "sopa de flores de ovo";
Em seguida, use o código acima para produzi -lo.
Pense no motivo pelo qual a produção é mundo em vez de sopa de ovo.
Construtor
Dissemos antes que Foo () é realmente um construtor. Então, obviamente, podemos passar parâmetros para o construtor, por isso temos o seguinte código:
JavaScript
A cópia do código é a seguinte:
// Código 2.1
função foo (olá) {
se (hello === indefinido) {
this.hello = "mundo";
} outro {
this.hello = olá;
}
}
Vemos um julgamento estranho sobre ele se (hello === indefinido). Qual é o uso desse julgamento? A primeira possibilidade é que o desenvolvedor tenha enviado especialmente um indefinido de dor. Neste momento, está indefinido.
Há outra situação. Dissemos desde o início que o JavaScript é um idioma do tipo fraco. De fato, não é apenas um tipo fraco, mas seus parâmetros de transmissão também são muito inúteis. Você pode passar mais ou menos (desde que garanta que o programa não cometa erros ao passar mais ou menos), está tudo bem em princípio. Os parâmetros de várias passes serão ignorados automaticamente, enquanto os parâmetros de poucos passes serão complementados com indefinidos.
Basta olhar para o código a seguir e você entenderá:
JavaScript
A cópia do código é a seguinte:
// Conecte o código 2.1 em
var bar1 = new Foo ();
var bar2 = novo foo ("sopa de flores de ovo");
Por favor, produza duas variáveis Hello Hello, e você descobrirá que uma é o mundo e a outra é a sopa de ovos. Obviamente, quando nosso primeiro bar1 foi declarado, foi automaticamente considerado pelo Node.js:
JavaScript
A cópia do código é a seguinte:
var bar1 = novo foo (indefinido);
Portanto, há um ditado que é mundo.
Também neste construtor, vemos que o parâmetro passado é olá, e há uma variável de membro nesta classe que é essa. No entanto, dissemos antes que o escopo é diferente quando existe isso e isso não é. Esse parâmetro é usado apenas no construtor, enquanto aquele é uma variável de membro. Use isso para distingui -los imediatamente, para que não importa, mesmo que seja o mesmo nome.
Funções de membros
Declaração da função do membro
A declaração de uma função de membro é semelhante ao segundo método de declaração de uma variável de membro, ou seja, <nome da classe> .Protótipo. <Nome da função> = <ctuncion>;
JavaScript
A cópia do código é a seguinte:
// Conecte o código 2.1 em
função sethello (olá) {
this.hello = olá;
}
foo.prototype.Sethello = Sethello;
bar1.sethello ("bolo de ovo");
Como o código acima é óbvio, implementamos a função Sethello da classe Foo, através da qual podemos modificar o valor de foo.hello.
Mas não é um pouco problemático escrever assim? Em seguida, falarei sobre uma característica importante das funções JavaScript.
★ funções anônimas ★
Muitas vezes, algumas de nossas funções são referenciadas ou chamadas apenas em um só lugar, por isso vale muito a pena dar a essa função um nome, e não há necessidade, para que possamos escrever essa função temporariamente e pedir diretamente à pessoa que a referencia a fazer referência a ela, e a pessoa que a chama para chamá -la. Portanto, a função pode omitir o nome da função, como:
JavaScript
A cópia do código é a seguinte:
função (olá) {
this.hello = olá;
}
Quanto a como citar ou chamá -lo? Se a classe acima precisar ser citada, ela será escrita assim:
JavaScript
A cópia do código é a seguinte:
foo.prototype.sethello = function (hello) {
this.hello = olá;
}
Este método de escrita é o mesmo que a declaração da função do membro e economiza muito código. E, de fato, basicamente a declaração das funções de membro da classe é declarada dessa maneira de funções anônimas.
Quanto a como fazer as funções anônimas serem chamadas? Isso geralmente é escrito assim ao passar em uma função que é chamada apenas por uma determinada função.
Por exemplo, temos um protótipo de uma função:
JavaScript
A cópia do código é a seguinte:
/**
* Vamos passar em duas variáveis A e B,
* Depois de calcular o valor de A+B, entregue -o para func)
* Vá para a saída
*/
função sumab (a, b, func) {
var c = a + b;
func (a, b, c);
}
Por exemplo, temos duas versões das funções de saída, uma é a saída chinesa e a outra é a saída em inglês. Então, se não usarmos funções anônimas:
JavaScript
A cópia do código é a seguinte:
função zh (a, b, soma) {
O valor do console.log (a + " +" + b + "é:" + soma);
}
função pt (a, b, soma) {
console.log (a + "plus" + b + "é" + soma);
}
Sumab (1, 2, Zh);
Sumab (3, 4, en);
Execute este código uma vez e a saída será:
O valor de 1 + 2 é: 3
3 mais 4 é 7
Se esse código estiver na forma de funções anônimas, será:
JavaScript
A cópia do código é a seguinte:
Sumab (1, 2, função (a, b, soma) {
O valor do console.log (a + " +" + b + "é:" + soma);
});
Sumab (3, 4, função (a, b, soma) {
console.log (a + "plus" + b + "é" + soma);
});
Este formulário geralmente é usado nas funções de retorno de chamada. O mecanismo de retorno de chamada é a essência do Node.js ou JavaScript. Vou apresentá -lo em futuros capítulos.
Como declarar função anônima na declaração de função de membro
Embora tenha falado sobre isso na seção anterior, vou falar sobre isso novamente.
Geralmente, quando declaramos uma função de membro da classe, usamos funções anônimas para declará -la, porque de qualquer maneira essa função é apenas uma função de membro dessa classe e não será referenciada ou chamada separadamente em outros lugares, portanto o código a seguir está disponível:
JavaScript
A cópia do código é a seguinte:
// Conecte o código 2.1 em
foo.prototype.sethello = function (hello) {
this.hello = olá;
}
Dessa forma, temos a função Sethello na classe Foo.
2.3.4. Classe arbitrária
Esta é a minha bobagem novamente. A chamada aleatoriedade das classes significa que, no JavaScript, você pode modificar sua classe em qualquer lugar, o que tem certas semelhanças com o Ruby.
Por exemplo, a String é na verdade uma classe, com variáveis de membros, como comprimento e funções de membro, como indexOF e substr. Mas se pensamos que algumas partes dessa string não são perfeitas e querem adicionar nosso próprio método, podemos adicionar uma função a ela onde você quiser, como:
JavaScript
A cópia do código é a seguinte:
String.prototype.sb = function () {
var Newsstr = "";
for (var i = 0; i <this.length; i ++) {
if (i % 2 === 0) newsr += "s";
else Newsr += "b";
}
retornar Newsr;
};
O significado dessa função é preencher uma string para transformá -la na encarnação de SB.
Vamos testar:
A cópia do código é a seguinte:
var str = "SHH ~ Sopa de flores de ovo está dormindo.";
console.log (str.sb ());
Você receberá o seguinte resultado:
SBSBSBSBSBSBS
Se você disser "Shhh ~ sopa de flores de ovo está dormindo". Seu computador o repreende por ser um tolo quatro vezes e meia. (Esmbregue -o rapidamente)
3. Anexado
3.1. Cópia profunda
A chamada cópia profunda é criar uma nova matriz ou objeto sozinho e copiar manualmente os valores variáveis do tipo básico na matriz ou objeto de origem um por um, em vez de apenas levar as referências à matriz ou objeto de origem. Portanto, isso envolve uma chamada recursiva ou algo assim.
Abaixo está uma função de cópia profunda que implementei. Você pode escrever um de seus próprios e adicioná -lo à sua própria base de conhecimento node.js.
JavaScript
A cópia do código é a seguinte:
função cloneObject (src) {
var dest = {};
para (tecla var no src) {
if (typeof src === "object") dest [key] = cloneObject (src [key]);
else dest [key] = src [key];
}
retorno dest;
}