A leitura deste artigo requer experiência de programação em outros idiomas.
Os tipos simples em JavaScript incluem:
1. Números
2. String
3. Booleano (verdadeiro e falso)
4.null
5.UNDEFINED
Outros tipos são objetos (não devemos nos confundir com o valor de retorno do operador TIPEOF), por exemplo:
1. Função
2.Rray
3. Expressões regulares
4. Objeto (objetos são objetos naturalmente)
Base de objeto
No JavaScript, os objetos são coleções de propriedades (os objetos são matrizes associativas), cada propriedade inclui:
1. O nome do atributo deve ser uma string
2. O valor do atributo pode ser qualquer valor que não seja indefinido
Crie um objeto através do objeto literal:
A cópia do código é a seguinte:
// Crie um objeto vazio através do objeto literal {}
var em vazio_object = {};
O nome do atributo e o valor do atributo do objeto:
A cópia do código é a seguinte:
var stande = {
// "First-Name" é o nome do atributo, e "Jerome" é o valor do atributo
"Primeiro nome": "Jerome",
// "Último Name" é o nome do atributo, e "Howard" é o valor do atributo
"Salta-nome": "Howard"
};
Se o nome do atributo for um identificador legal, as aspas poderão ser omitidas:
A cópia do código é a seguinte:
Var Flight = {
companhia aérea: "Oceanic",
Número: 815,
Departamento: {
Iata: "syd",
Tempo: "2004-09-22 14:55",
Cidade: "Sydney"
},
chegada: {
Iata: "lax",
Tempo: "2004-09-23 10:42",
Cidade: "Los Angeles"
}
};
Vamos dar uma olhada no exemplo de acesso à propriedade:
A cópia do código é a seguinte:
var proprietário = {name: "name5566"};
proprietário.name; // "name5566"
proprietário ["nome"]; // "name5566"
proprietário.job; // indefinido
proprietário.job = "coder"; // ou proprietário ["Job"] = "Coder";
Se o nome do atributo não for um identificador legal, ele precisará ser envolvido em cotações. O valor da propriedade que não existe é indefinido. Os objetos são passados por referência e não por valor:
A cópia do código é a seguinte:
var x = {};
Var proprietário = x;
proprietário.name = "name5566";
x.name; // x.name === "name5566"
Aqui x e proprietários se referem ao mesmo objeto.
Os atributos de um objeto podem ser excluídos usando o operador de exclusão:
A cópia do código é a seguinte:
excluir obj.x; // exclua o atributo x do objeto obj
Protótipo do objeto
Cada objeto está vinculado a um objeto de protótipo e o objeto pode herdar atributos do objeto Prototype. Criamos um objeto através do objeto literal, cujo objeto de protótipo é um objeto.Prototipo Objeto (o objeto.Prototipo em si não possui um objeto de protótipo). Quando criamos um objeto, podemos definir o objeto de protótipo do objeto (e depois discutir o método de configuração específico). Ao tentar obter (não modificar) um atributo de um objeto, se o objeto não existir, o JavaScript tenta obter o atributo do objeto protótipo desse objeto, se não houver esse atributo no objeto protótipo, procure o objeto do protótipo desse protótipo e assim por diante. Comparado à obtenção de atributos, quando modificamos o atributo de um objeto, ele não afetará o objeto do protótipo.
Básicos funcionais
As funções também são objetos no JavaScript, que estão vinculados ao objeto FUNCTOTOTYPE. A função possui uma propriedade chamada protótipo e seu valor é um objeto. Este objeto possui um construtor de propriedades, e o valor do construtor é essa função:
A cópia do código é a seguinte:
var f = function () {}
TIPO DE F.PROTOTIPE; // 'objeto'
typeof f.prototype.Constructor; // 'função'
f === F.Prototype.Constructor; // verdadeiro
As funções são objetos, você pode usar funções como o uso de objetos, ou seja, as funções podem ser salvas em variáveis e matrizes e podem ser passadas como parâmetros para funções, e as funções podem ser definidas nas funções. Como nota lateral, a função possui duas propriedades ocultas:
1. O contexto da função
2. Código da função
A função é criada da seguinte maneira:
A cópia do código é a seguinte:
var f = função add (a, b) {
retornar a + b;
}
console.log (f); // saída [função: add]
O nome da função após a função da palavra -chave é opcional. Formulamos o nome da função principalmente para vários propósitos:
1. Para uma chamada recursiva
2. Debuggers, Ferramentas de Desenvolvimento, etc. são usados para identificar funções
Muitas vezes, não precisamos de nomes de funções, e as funções sem nomes de funções são chamadas de funções anônimas. Uma lista de parâmetros é embrulhada entre colchetes. O JavaScript não requer correspondência de parâmetros reais e parâmetros formais, por exemplo:
A cópia do código é a seguinte:
var add = function (a, b) {
retornar a + b;
}
adicione (1, 2, 3); // O parâmetro real e o parâmetro formal não correspondem
Se houver muitos parâmetros reais, o excesso de parâmetros reais será ignorado. Se houver poucos parâmetros reais, o valor dos parâmetros formais não atribuídos será indefinido. A função deve ter um valor de retorno. Se o valor de retorno não for especificado através da instrução RETURN, o valor de retorno da função será indefinido.
Uma função e as variáveis externas que acesas formam um fechamento. Este é o principal charme do JavaScript.
Chamadas de função
Quando cada função é chamada, dois parâmetros adicionais são recebidos:
1.Este
2. Argumentos
O valor disso está relacionado ao padrão de chamada específico. Existem quatro padrões de chamada em JavaScript:
1. Modo de chamada de método. Se a propriedade de um objeto for uma função, ela é chamada de método. Se um método é chamado através do OM (args), este é um objeto O (que pode ser visto que isso e O são ligados apenas quando chamados), por exemplo:
A cópia do código é a seguinte:
var obj = {
Valor: 0,
incremento: função (v) {
this.value += (typeof v === 'número'? V: 1);
}
};
obj.Increment (); // this === obj
2. Modo de chamada da função. Se uma função não for a propriedade de um objeto, ela será chamada de função, e isso está ligado ao objeto global, por exemplo:
A cópia do código é a seguinte:
mensagem = 'olá mundo';
var p = function () {
console.log (this.Message);
}
p (); // Saída 'Hello World'
Esse comportamento às vezes é confuso, veja um exemplo:
A cópia do código é a seguinte:
obj = {
Valor: 0,
incremento: function () {
var helper = function () {
// Adicione 1 ao valor no objeto global
this.value += 1;
}
// Helper é chamado de função
// Portanto, este é um objeto global
ajudante();
}
};
obj.Increment (); // obj.value === 0
Os resultados que esperamos devem ser:
A cópia do código é a seguinte:
obj = {
Valor: 0,
incremento: function () {
var que = this;
var helper = function () {
that.value += 1;
}
ajudante();
}
};
obj.Increment (); // obj.value === 1
3. Modo de chamada do construtor. As funções que pretendem usar o novo prefixo são chamadas de construtores, por exemplo:
A cópia do código é a seguinte:
// O teste é chamado de construtor
var test = function (string) {
this.Message = String;
}
var mytest = novo teste ("Hello World");
Uma função pode ser chamada com novas (essas funções geralmente começam com a capitalização). Depois de adicionar novos, um objeto vinculado à propriedade Prototype desta função será criado, e esse objeto no construtor é esse objeto.
4. Aplique o modo de chamada. O método de aplicação da função é usado para chamar a função, que possui dois parâmetros, o primeiro é este e o segundo é uma variedade de parâmetros, por exemplo:
A cópia do código é a seguinte:
var add = function (a, b) {
retornar a + b;
}
var ret = add.apply (nulo, [3, 4]); // ret === 7
Ao chamar a função, podemos acessar uma variedade de classes chamadas argumentos (matriz JavaScript não real) que contém todos os argumentos, para que possamos implementar parâmetros de comprimento variável:
A cópia do código é a seguinte:
var add = function () {
var sum = 0;
for (var i = 0; i <argumentos.length; ++ i) {
soma += argumentos [i];
}
soma de retorno;
}
add (1, 2, 3, 4);
anormal
Agora vamos falar sobre o mecanismo de manuseio de exceção do JavaScript. Usamos a declaração de arremesso para lançar exceções e a instrução Try-Cache para capturar e lidar com exceções:
A cópia do código é a seguinte:
var add = function (a, b) {
if (typeof a! == 'número' || tipo de b! == 'número') {
// Jogue uma exceção
lançar {
Nome: 'TypeError',
Mensagem: 'Adicionar números de necessidade'
};
}
retornar a + b;
}
// pegue e lide com exceções
tentar {
add ("sete");
// e é o objeto de exceção jogado
} catch (e) {
console.log (e.name + ':' + e.message);
}
Adicionar propriedades aos tipos de JavaScript
Os construtores existem na maioria dos tipos em JavaScript:
1. O construtor do objeto é objeto
2. O construtor da matriz é uma matriz
3. O construtor da função é a função
4. O construtor da string é
5. O construtor do número é o número
6. O construtor do booleano é booleano
7. O construtor da expressão regular é regexp
Podemos adicionar propriedades (geralmente adicionar métodos) ao protótipo do construtor para que esta propriedade esteja disponível para variáveis relacionadas:
A cópia do código é a seguinte:
Número.prototype.integer = function () {
devolver matemática [este <0? 'teto': 'piso'] (isto);
}
(1.1) .Integer (); // 1
Escopo
JavaScript precisa construir escopos através de funções:
A cópia do código é a seguinte:
function () {
// ...
} ();
Uma função anônima é criada e executada aqui. Escopo para ocultar variáveis que você não deseja ser exposto:
A cópia do código é a seguinte:
var obj = function () {
// Ocultar valor, não pode ser acessado externamente
Valor var = 0;
retornar {
// Somente esse método pode modificar o valor
incremento: function () {
valor += 1;
},
// Somente esse método pode ler o valor
getValue: function () {
valor de retorno;
}
};
} ();
obj.Increment ();
obj.getValue () === 1;
herdar
Existem muitas maneiras de implementar a herança no JavaScript.
Ao criar um objeto, podemos configurar o objeto de protótipo associado ao objeto, e fazemos:
A cópia do código é a seguinte:
// Crie um objeto o com seu protótipo objeto {x: 1, y: 2}
var o = object.create ({x: 1, y: 2});
O método Object.Create é definido no ECMAScript 5. Se você usar o ECMAScript 3, poderá implementar um método Create Yourself:
A cópia do código é a seguinte:
// se o método objeto.create não for definido
if (typeof object.create! == 'function') {
// Crie Object.Create Method
Object.create = function (o) {
var f = function () {};
F.Prototype = O;
// Crie um novo objeto, o protótipo objeto deste objeto é O
retornar novo f ();
};
}
Através do método Object.Create, realizamos herança baseada em protótipo: um novo objeto herda diretamente as propriedades de um objeto antigo (em relação à herança baseada em classe, não há necessidade de existência da classe aqui e o objeto herda diretamente o objeto). exemplo:
A cópia do código é a seguinte:
var myMammal = {
Nome: 'Herb the Mammal',
get_name: function () {
retornar este.name;
},
diz: function () {
devolver isso. Saying || '';
}
};
// herdar MyMammal
var mycat = object.create (myMammal);
mycat.name = 'Henrietta';
mycat.saying = 'mEow';
mycat.purr = function (n) {
var i, s = '';
for (i = 0; i <n; i += 1) {
se (s) {
s += '-';
}
s += 'r';
}
retorno s;
};
mycat.get_name = function () {
Retorne this.says () + '' + this.name + '' + this.says ();
};
O código acima é simples, mas não pode proteger membros particulares. Podemos usar o modo de módulo. No modo de módulo, um certo tipo de objeto é gerado por uma função e usa o escopo da função para proteger os membros privados do acesso externo:
A cópia do código é a seguinte:
// Função de mamíferos, usada para construir objetos de mamíferos
var mammal = function (spec) {
// esse é o objeto construído
var que = {};
// O método público get_name pode ser acessado externamente
that.get_name = function () {
// spec.name não pode ser acessado diretamente de fora
retornar espec.name;
};
// O método público diz que pode ser acessado externamente
that.says = function () {
// Spec.ying sem acesso direto ao externo
Retornar Spec.Saying || '';
};
devolver isso;
};
// Crie um objeto de mamífero
var myMammal = mamífero ({name: 'Herb'});
// Função de gato, usada para construir o objeto CAT
var cat = function (spec) {
Spec.Saying = Spec.Saying || 'Miau';
// Cat herda do mamífero, então primeiro construa o objeto de mamíferos
var que = mamífero (Spec);
// Adicionar método público ronrona
that.purr = function (n) {
var i, s = '';
for (i = 0; i <n; i += 1) {
se (s) {
s += '-';
}
s += 'r';
}
retorno s;
};
// modifica o método público get_name
that.get_name = function () {
Retorne que
'' + that.says ();
devolver isso;
};
};
// Crie um objeto CAT
var mycat = cat ({name: 'henrietta'});
No modo de módulo, a herança é alcançada chamando o construtor. Além disso, também podemos acessar os métodos da classe pai na subclasse:
A cópia do código é a seguinte:
Object.prototype.superior = function (nome) {
var que = this, método = esse [nome];
Return function () {
retorno método.Apply (que, argumentos);
};
};
var coolcat = function (spec) {
// Obtenha o método get_name da subclasse
var que = cat (spec), super_get_name = that.superior ('get_name');
that.get_name = function (n) {
retornar 'como' + super_get_name () + 'bebê';
};
devolver isso;
};