Variáveis definidas fora da função devem ser variáveis globais; Variáveis definidas dentro da função, se o VAR for declarado, a variável é uma variável local. Se o VAR não for declarado, a variável é uma variável global.
1. Variáveis globais e locais JavaScript var global = "global"; test (); function test () {var local = "local"; Document.Writeln (Global); document.writeln (local);} document.writeln (global); document.writeln (local);2. Dois tipos de cookies
i) Cookies persistentes serão armazenados no disco rígido do cliente.
ii) Cookie de resposta: ele não será armazenado no disco rígido do cliente, mas será colocado na memória do processo do navegador. Quando o navegador estiver fechado, o cookie da resposta será destruído.
3. Em JavaScript, uma função é um objeto
4. Em JavaScript, não há sobrecarga de conceito de método (função)
5. Objeto de função
Existe um objeto de função no JavaScript e todas as funções personalizadas são do tipo de objeto de função. Todos os parâmetros aceitos pelo objeto de função são do tipo String, o último parâmetro é o corpo da função a ser executado e o parâmetro anterior são os parâmetros que a função realmente precisa aceitar.
6. argumentos de objeto implícitos
No JavaScript, cada função possui argumentos de objeto implícitos, representando os parâmetros realmente passados para a função. Argumentos.Length Representa o número de parâmetros realmente passados.
7. Nome da função.Length
Cada objeto de função possui um atributo de comprimento, indicando o número de parâmetros que a função espera aceitar. É diferente dos argumentos das funções. Argumentos.Length Representa o número de parâmetros realmente aceitos pela função.
8. Existem cinco tipos de dados primitivos em JavaScript
Indefinido, nulo, booleano, número e string. (Nota: em JavaScript, não há tipo de dados de char)
Existe apenas um valor para o tipo de dados indefinido: indefinido;
Existe apenas um valor para o tipo de dados nulo: nulo;
Existem dois valores do tipo de dados booleanos: verdadeiro e falso;
9. Tipoof Operador
TypeOf é um operador unário seguido pelo nome da variável. É usado para obter o tipo de dados da variável. Seus valores de retorno são: indefinido, booleano, número, string e objeto.
10. Em JavaScript, se a função não declarar o valor de retorno, ele retornará o relacionamento entre indefinido11, nulo e indefinido
Indefinido é realmente derivado de Null. Por exemplo:
A relação entre nulo e indefinido
JavaScript
alerta (indefinido == null); // o navegador retorna true
11. Conversão do tipo forçado
Existem 3 moldes em JavaScript: boolean (valor), número (valor), string (valor).
12. Objeto do objeto
No JavaScript, todos os objetos são herdados de objetos de objetos.
Objeto objeto
JavaScript
var object = new Object (); para (var V em objeto) {alert (v);}No código acima, o navegador não imprime nada, o que não significa que o objeto não possui nenhum atributo. O código a seguir testa se as propriedades no objeto podem ser enumeradas. Se False for retornado, isso significa que as propriedades no objeto não podem ser enumeradas.
Propriedades em objetos de objeto não podem ser enumerados
JavaScript
alerta (object.propertyisenumerable ("prototype"));Se o navegador exibir uma caixa de diálogo falsa, isso significa que as propriedades no objeto não poderão ser enumeradas.
Em seguida, vamos ver se as propriedades no objeto da janela podem ser enumeradas.
Propriedades em objetos de janela são enumeráveis
JavaScript
para (var V na janela) {console.log (v);}No Chrome, veremos muitas propriedades impressas no console de depuração do navegador, indicando que as propriedades no objeto da janela podem ser enumeradas.
13. Em JavaScript, você pode adicionar dinamicamente os atributos de um objeto ou excluir dinamicamente os atributos de um objeto.
Adicione/remova dinamicamente as propriedades dos objetos
JavaScript
var object = new Object (); alert (object.UserName); // objeto indefinido.UserName = "Zhangsan"; alert (object.username); // zhangsan object ["senha"] = "123"; object (object.password); // 123 DELETE.
14. A maneira mais comum de definir objetos em JavaScript
A maneira mais comum de definir objetos
JavaScript
var object = {nome de usuário: "zhangsan", senha: 12345}; alert (object.UserName); alert (object.password);15. Array
Definição da matriz
JavaScript
// Método 1 var Array = new Array (); Array.push (1); Array.push (2); Array.push (3); Alert (Array.length); // Método 2 (recomendado) var Array = [1,25,4]; Array.sort (); Alert (Array);
Ligue para o método Sort () da matriz, e o navegador imprime 1, 25, 4, que não é o resultado que esperamos.
Para o método de classificação de JavaScript Array, ele primeiro converterá o conteúdo a ser classificado em uma string (chamado Método ToString ()) e o classificará na ordem das strings.
O método a seguir pode obter os resultados que esperamos (classificados pelo tamanho da matriz):
Classificação da matriz
JavaScript
função compare (num1, num2) {var temp1 = parseint (num1); var temp2 = parseint (num2); if (temp1 <temp2) {return -1; } else if (temp1 == temp2) {return 0; } else {return 1; }} var Array = [1,25,3]; Array.sort (compare); Alert (Array);Em seguida, implementamos isso em funções anônimas:
Classificação da função anônima
JavaScript
var array = [1,25,3]; Array.sort (function (num1, num2) {var temp1 = parseInt (num1); var temp2 = parseint (num2); if (temp1 <temp2) {return -1;} else if (temp1 == temp2) {return 0;} {return 1;}}); alerta (matriz);16. Cinco maneiras de definir objetos em JavaScript (não há conceito de classes em JavaScript, apenas objetos) i) Expanda suas propriedades e métodos baseados em objetos existentes
Expandir suas propriedades e métodos baseados em objetos existentes
JavaScript
var object = new Object (); // Adicione o atributo de nome Object.Name = "Zhangsan"; // Adicione o SayName Method Object.SayName = function (nome) {this.name = name; alert (this.name);}; object.SayName ("Kyle"); // Chame o método SayName, o atributo de nome é modificado para Kyle, e o navegador imprimirá KyleA maneira mais simples não é conveniente de usar e é adequada para exigir temporariamente um objeto.
ii) Crie objetos na fábrica
Método da fábrica sem parâmetros:
JavaScript
// Função de fábrica função createObject () {var object = new object (); // crie um objeto objeto.name = "zhangsan"; // Adicione um atributo de nome objeto.password = "123"; // Adicione um atributo senha object.get = function () {// adicione um método get alert (this.name+"," "+this.Te.pass); }; retornar objeto; // retornar este objeto} var object1 = createObject (); // calendário Um método CreateObject Factory para criar object1Var object2 = createObject (); // CHAMADA CREATOBJETO Método para criar objeto Object2Object1.get (); // Chame o objeto Object Object.Get (); // celular o objeto Get Object.get2.get (); // chamam o objeto Objeto.Método da fábrica com parâmetros:
JavaScript
função createObject (nome, senha) {var object = new Object (); object.name = nome; object.Password = senha; object.get = function () {alert (this.name+","+this.password); }; retornar objeto;} var object1 = createObject ("zhangsan", "123"); var object2 = createObject ("lisi", "456"); object1.get (); object2.get ();Desvantagens dos dois métodos de fábrica acima, sem parâmetros e com parâmetros:
Toda vez que um objeto é criado, um método GET é criado na memória, que é um desperdício de memória e afeta o desempenho. E nossa expectativa é criar dois objetos diferentes cujas propriedades são diferentes, mas os métodos são compartilhados. Então, em seguida, precisamos melhorar o método CreateObject Factory.
Abordagem de fábrica aprimorada:
JavaScript
function get () {alert (this.name+","+this.password);} função createObject (nome, senha) {var object = new Object (); object.name = nome; object.Password = senha; object.get = get; retornar objeto;} var object1 = createObject ("zhangsan", "123"); var object2 = createObject ("lisi", "456"); object1.get (); object2.get ();Defina o método GET fora da função CreateObject, para que o método GET seja compartilhado para cada objeto criado. Faça uma função compartilhar objeto por vários objetos, em vez de cada objeto ter um objeto de função.
iii) método construtor para criar um objeto
Construtor sem parâmetros:
JavaScript
function Person () {// Antes de executar a primeira linha de código, o mecanismo JS gerará um objeto para nós. this.password = "123"; this.getInfo = function () {alert (this.name+","+this.password); }; // Há uma declaração de retorno implícita aqui para retornar o objeto gerado anteriormente (que também é um lugar diferente do método da fábrica)} var p1 = new Person (); p1.getInfo ();Construtor com parâmetros
JavaScript
função pessoa (nome, senha) {this.name = name; this.password = senha; this.getInfo = function () {alert (this.name+","+this.password); };} var p1 = new Pessoa ("Zhangsan", "123"); var p2 = new Pessoa ("lisi", "456"); p1.getinfo (); p2.getinfo ();iv) criação de objeto de protótipo (protótipo)
O protótipo é uma propriedade no objeto
protótipo
JavaScript
function PERS () {} PERSON.Prototype.name = "Zhangsan"; Pessoa.Prototype.password = "123"; Pessoa.prototype.getInfo = function () {alert (this.name+"," this.password);}; var p1 = new pessoa (); var p2 = new Person (); p1.name = "Kyle"; // Após a geração do objeto, altere o atributo p1.getinfo (); p2.getInfo ();Existem dois problemas com o uso de protótipos: primeiro, você não pode atribuir valores iniciais aos atributos no construtor e só pode alterar os valores do atributo após a geração do objeto.
protótipo
JavaScript
function PERS () {} PERSON.Prototype.Name = new Array (); Pessoa.Prototype.Password = "123"; Pessoa.Prototype.getInfo = function () {alert (this.name+","+this.password);}; var p1 = new pessoa (); var p2 = new Person (); p1.name.push ("zhangsan"); p1.name.push ("lisi"); p1.password = "456"; p1.getinfo (); p2.getinfo ()O navegador imprimirá: Zhangsan, Lisi, 456 e Zhangsan, Lisi, 123.
Se um objeto for criado usando o método do protótipo, todos os objetos gerados compartilharão as propriedades no protótipo e, se um objeto alterar a propriedade, ele também será refletido em outros objetos. Portanto, não é possível simplesmente usar o método do protótipo e também precisa ser combinado com outros métodos. Continuaremos a apresentá -lo a seguir.
Use o protótipo + construtor para definir objetos
JavaScript
function Person () {this.name = new Array (); this.password = "123";} pessoa.prototype.getInfo = function () {alert (this.name+","+this.password);}; var p1 = new pessoa (); var p2 = new Person (); p1.name.push ("zhangsan"); p2.name.push ("lisi"); p1.getinfo (); p2.getinfo ();Use o método protótipo + construtor para definir objetos. As propriedades entre objetos não interferem entre si e cada objeto compartilha o mesmo método. Esta é uma maneira melhor.
v) Método de protótipo dinâmico
JavaScript
function Person () {this.name = "zhangsan"; this.password = "123"; if (typeof Person.flag == "Undefined") {alert ("Invocado"); Pessoa.prototype.getInfo = function () {alert (this.name + "," + this.password); } Pessoa.flag = true; }} var p1 = new Person (); var p2 = new Person (); p1.getInfo (); p2.getInfo ();No método de protótipo dinâmico, no construtor, todos os objetos compartilham um método através das quantidades de sinalizador e cada objeto tem seus próprios atributos. Quando o código acima cria um objeto pela primeira vez, ele primeiro usa uma declaração de julgamento para verificar se o atributo de sinalizador foi definido. Se não estiver definido, adicione o método getInfo através do protótipo e defina o sinalizador como true. Então, quando o objeto é criado na segunda vez, a instrução IF é considerada falsa e a execução é ignorada. Isso alcança o resultado desejado, as propriedades do objeto criadas não interferem entre si e os métodos de objeto são compartilhados.
17. Herança de objetos em JavaScript (5 maneiras)
O primeiro método: representação de objeto
Imitar herança do objeto
JavaScript
// clássica presidida função pai (nome de usuário) {this.username = nome de usuário; this.sayhello = function () {alert (this.UserName); };} // Subclasse Função Child (nome de usuário, senha) {// As três linhas de código a seguir são as mais críticas this.method = pai; this.method (nome de usuário); exclua este.method; this.password = senha; this.sayworld = function () {alert (this.password); };} var p = new Parent ("Zhangsan"); var c = novo filho ("lisi", "123"); P.Sayhello (); C.Sayhello (); C.Sayworld ()O segundo método: Call ()
O segundo método de herança de implementação, o método de chamada, o método de chamada é um método definido no objeto de função; portanto, cada função que definimos tem esse método. O primeiro parâmetro do método de chamada será passado para isso na função, começando no segundo parâmetro e atribuído aos parâmetros na função um por um.
Chamada herda a classe dos pais
JavaScript
function teste (str) {alert (this.name+","+str);} var object = new object (); object.name = "zhangsan"; // test.call é equivalente a chamar o teste test.call (objeto, "html5war");Em seguida, usamos o método de chamada para implementar a herança do objeto
JavaScript
// clássica presidida função pai (nome de usuário) {this.username = nome de usuário; this.sayhello = function () {alert (this.UserName); };} // Função da subclasse Child (nome de usuário, senha) {parent.call (este, nome de usuário); this.password = senha; this.sayworld = function () {alert (this.password); };} var p = new Parent ("Zhangsan"); var c = novo filho ("lisi", "123"); p.sayhello (); c.sayhello (); c.sayworld ();O terceiro método: aplicar ()
Aplicar herda a classe dos pais
JavaScript
// clássica presidida função pai (nome de usuário) {this.username = nome de usuário; this.sayhello = function () {alert (this.UserName); };} // Função da subclasse Child (nome de usuário, senha) {parent.apply (esta, nova matriz (nome de usuário)); this.password = senha; this.sayworld = function () {alert (this.password); };} var p = new Parent ("Zhangsan"); var c = novo filho ("lisi", "123"); p.sayhello (); c.sayhello (); c.sayworld ();O método de aplicação é muito semelhante ao método de chamada. O método Apply também é um método definido em um objeto de função; portanto, cada função que definimos tem esse método.
Há uma diferença entre o método Apply e o método de chamada: parent.apply (esta, nova matriz (nome de usuário)); O segundo parâmetro aprovado é uma matriz, enquanto o método de chamada passou alguns parâmetros de dados discretos. Não se pode dizer que esses dois métodos sejam bons e ruins, depende do cenário de uso específico.
O quarto método: método da cadeia de protótipo (não pode passar parâmetros para o construtor)
Herança da cadeia de protótipo
JavaScript
function parent () {} parent.prototype.hello = "hello"; parent.prototype.sayhello = function () {alert (this.hello);}; function filho () {} Child.prototype = new Parent (); Child.prototype.world = "World"; Child.prototype.sayworld = function () {alert (this.world);}; var c = novo filho (); C.Sayhello (); C.Sayworld ();Desvantagens de simplesmente usar o método da cadeia de protótipo: não há como passar os parâmetros, você só pode esperar até que o objeto seja criado antes de modificá -lo. Vamos resolver esse problema em combinação com outras maneiras.
O quinto método: método misto (recomendado)
Use métodos híbridos para implementar a herança do objeto
JavaScript
function pai (hello) {this.hello = hello;} parent.prototype.sayhello = function () {alert (this.hello);} função filho (hello, mundo) {parent.call (this, hello); this.world = mundial;} Child.prototype = new Parent (); Child.prototype.sayworld = function () {alert (this.world);} var c = new Child ("Hello", "World");O resumo acima dos pontos básicos de conhecimento JavaScript (recomendado) é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.