Parte de arrays e objetos que o JavaScript deve aprender diariamente

Parte do objeto　

Tipo Object　

Object é uma coleção não ordenada, pode armazenar qualquer tipo de objeto, e todos os outros objetos herdam deste objeto.　

Existem dois tipos de criação de Object, um é o operador new e o outro é a notação litteral.　

1Criação de Object usando new
　var obj = new Object();//Atenção para maiúsculas, também pode ser escrita diretamente como Object()
Atenção, a criação de novos objetos usando a sintaxe new Object() é equivalente à criação de litterais obj = {}.　

2Criação usando litterais:

 var obj = {
 nome : 'trigkit4',
 idade : 21
};//Ponto-e-vírgula é melhor adicionado 

Ao declarar um objeto Object usando litterais, não é chamado o construtor Object() (exceto no FF)　

Objeto Object.prototype　

Todas as funções construtoras têm uma propriedade prototype, que aponta para um objeto de protótipo.

Object.prototype.print = function(){ console.log(this)};
var obj = new Object();
obj.print() // Object 

A instância obj herda diretamente as propriedades e métodos de Object.prototype
1.Objetos são apenas um tipo especial de dados. Os objetos possuem propriedades e métodos. JavaScript é uma linguagem orientada a objetos, mas não usa classes. JavaScript é baseado em [prototype][1], em vez de baseado em classes.

2.Propriedade: é uma variável que pertence a um objeto específico. Método: é uma função que pode ser chamada apenas por um objeto específico.

3Os objetos .js são conjuntos de propriedades e métodos. Um método é uma função, que é um membro do objeto. Uma propriedade é um valor ou um conjunto de valores (em forma de array ou objeto), que é um membro do objeto.

4Os objetos .js são baseados em funções construtoras, e ao criar um novo objeto usando uma função construtora, podemos dizer que instanciou um novo objeto. As propriedades são variáveis dentro da função construtora.
Objetos instanciados por função construtora:
　cat = new Animal();
Javascript é uma linguagem baseada em (objetos)-Um linguagem baseada em (objetos)，tudo o que você encontrar quase é um objeto. No entanto, não é uma linguagem de programação orientada a objetos (OOP) verdadeira, porque não há class (classe) em sua sintaxe.

 <script type="text/javascript">
 //O objeto é nome/Conjunto de pares de valores
  var browser = {  //O objeto é delimitado por chaves
   name:"Firefox",
   kernel:"Gecko"
  };
</script> 
//Acesso às propriedades do objeto através do ponto (.) ou "[]"
 browser.name   //"Firefox"
 browser["kernel"] //"Gecko" 

Objeto (objct) é um conjunto de propriedades, cada propriedade é composta por 'nome/Constituído por pares de valores, o JavaScript também definiu um objeto especial - array, que é uma coleção ordenada de valores numerados.　

O JavaScript também definiu um objeto especial - função, função é um objeto que possui código executável associado, executando o código através da chamada da função e retornando o resultado da operação.　

Não há classes no JavaScript, mas ele adotou um novo nome chamado 'objeto protótipo', então 'classe == objeto protótipo', detalhes vejam: A escrita da classe do JavaScript (um)　

II. Diferenças e relações entre classe (objeto protótipo) e objeto (instância)
1.classe (objeto protótipo) é abstrata, conceitual, representando uma categoria de coisas.
2.objeto é específico, real, representando uma coisa específica.
3.classe (objeto protótipo) é o modelo de objeto da instância de objeto, a instância de objeto é um indivíduo da classe.
Uma compreensão comum errada é que os valores literais (literais) não são objetos. Isso é porque o analisador do JavaScript tenta interpretar o operador de ponto como parte de um valor literal de ponto flutuante.　

Existem muitos métodos alternativos que podem fazer com que os valores literais de números pareçam ser objetos.
2..toString(); // O segundo ponto pode ser interpretado normalmente
2 .toString(); // Atenção ao espaço antes do ponto
(2).toString(); // 2Primeiro é calculado

Excluir propriedade　

O único método para excluir uma propriedade é usar o operador delete; Definir uma propriedade como undefined ou null não exclui realmente a propriedade, mas apenas remove a associação entre a propriedade e seu valor.　

Três grandes características do orientação a objetos no JavaScript　

Encapsulação: Sem considerar a implementação interna, apenas a utilização das funções
Herança: Criar novos objetos a partir de objetos existentes
Polimorfismo: O que se entende por polimorfismo é que uma referência pode ter vários estados em diferentes situações,

1.encapsulação　

A encapsulação é sobre reunir as características comuns de coisas do mesmo tipo (inclusive propriedades e comportamentos) em uma classe, facilitando seu uso. Por exemplo, a pessoa pode ser encapsulada da seguinte maneira:　

Pessoa{
　Idade (a primeira propriedade)
Altura (a segunda propriedade)
Gênero (a terceira propriedade)

Fazer (o primeiro comportamento)
Andar (o segundo comportamento)
Falar (um dos três comportamentos)
}　

Os benefícios da encapsulação:　

A encapsulação protege a integridade dos dados internos;
A encapsulação facilita a reestruturação de objetos;
Atenua a耦合 entre módulos, aumentando a reutilização dos objetos;
Ajuda a evitar conflitos de espaço de nomes;

Veja o exemplo a seguir:

 <script type="text/javascript"> 
   var boy = {}; //Cria um objeto vazio
     boy.name = "Mingming";//Atribuição de propriedades conforme o objeto prototype
     boy.age = 12;
   Cria um objeto vazio
     girl.name = "Xiaohong";
     girl.age = 10;
 </script> 

Isso é a mais simples encapsulação, encapsulando duas propriedades em um objeto. No entanto, essa abordagem tem duas desvantagens: uma é que, se gerarmos várias instâncias, é muito complicado escrevê-las; a outra é que não há maneira de ver qual é a relação entre a instância e o prototype.　

Padrão de construtor　

Para resolver o problema de geração de instância a partir do objeto prototype, o Javascript oferece um padrão de construtor (Constructor).　

O que chamamos de "construtor" é uma função comum, mas que usa a variável this internamente. Ao usar o operador new com um construtor, podemos gerar instâncias e a variável this será ligada ao objeto de instância.　

Por exemplo, o objeto prototype de boy e girl pode ser escrito assim:

 <script type="text/javascript"> 
  function Person(name,age){
    this.name = name;
    this.age = age;
  }
</script> 

Agora podemos gerar objetos de instância.

 <script type="text/javascript"> 
  var boy = new Person("小明",12);
  var girl = new Person("小红",10);
  alert(boy.name); //Mingming
  alert(boy.age); //12
</script> 

Neste momento, boy e girl automaticamente terão um atributo constructor, que aponta para seus construtores.

alert(boy.constructor == Person); //true

alert(girl.constructor); //Imprime todo o código do construtor, experimente você mesmo
O padrão Prototype do Javascript determina que cada construtor tem um atributo prototype, que aponta para outro objeto. Todas as propriedades e métodos deste objeto serão herdados pelas instâncias do construtor.　

Isso significa que podemos definir diretamente nas propriedades e métodos inalteráveis do objeto prototype.

<script type="text/javascript">
function Person(name,age){
  this.name = name;
  this.age = age;
}
Person.protype.type = "Humano";
Person.protype.eat = function(){
  alert("Comer arroz");
}
</script> 

Depois, gera instância:

 <script type="text/javascript">
var boy = new Person("小明","12");
var girl = new Person("小红","10");
alert(boy.type);//Humano
boy.eat();//Comer
</script> 

Neste momento, todas as propriedades type e métodos eat() dos instâncias são endereços de memória iguais, apontando para o objeto prototype, portanto, melhora a eficiência de execução.
　alert(boy.eat == girl.eat); //true
A propriedade de prototype é uma propriedade interna que especifica o construtor de extensão do objeto.
　Abaixo está o código que adiciona uma nova propriedade size ao construtor Animal, essa nova propriedade é a propriedade de prototype do objeto cat. Ao usar propriedades de prototype, todos os objetos que extendem o construtor Animal podem acessar a propriedade size

cat = new Animal("feline","meow", "walk/run");
cat.prototype.size = "fat"; 

Neste caso, todas as propriedades size dos objetos Animal são "fat" . O prototype é uma nova instância de Object, pois ainda é um objeto, podemos adicionar novas propriedades a ele. Assim como style é um objeto do JavaScript, também podemos adicionar novas propriedades ao estilo.

 <script type="text/javascript">
  /*Definir uma classe Person*/
  function Person(_name,_age,_salary){
   //Propriedades públicas da classe Person, a forma de definir propriedades públicas é: ”this.nomeDoAtributo“
   this.Name=_name;
   //Propriedades privadas da classe Person, a forma de definir propriedades privadas é: ”var nomeDoAtributo“
   var Age=_age;
   var Salary=_salary;
   //Definir métodos públicos (métodos privilegiados) da classe Person, a forma de definir métodos públicos da classe
é: ”this.functionName=function(){.....}“
   this.Show=function(){
 alert("Age="+Age+"\t"+"Salary="+Salary);//É permitido acessar propriedades privadas dentro de métodos públicos
   }
</script> 

Quando um objeto está buscando por um atributo, ele primeiro percorre seus próprios atributos, se não encontrar, continua buscando na referência [[Prototype]] do objeto, se ainda não encontrar, continua buscando na referência [[Prototype]].[[Prototype]] do objeto, e assim por diante, até que [[Prototype]].….[[Prototype]] seja undefined (o [[Prototype]] do Object é undefined)　

Em termos simples, é através do [[Prototype]] do objeto que é salva uma referência para outro objeto, através dessa referência, é feita a busca pelas propriedades para cima, isso é a cadeia de prototypes.　

objeto null　

O propósito de atribuir null a uma variável no JavaScript é:
Atribuir um ponteiro vazio facilita a compreensão de que a variável está destinada a armazenar um objeto. Também facilita o debug.　

objeto global window　

Qualquer função ou variável global no JavaScript é uma propriedade do objeto window.
O objeto self é completamente idêntico ao objeto window, o self é geralmente usado para confirmar que está no contexto da janela atual.　

Os principais objetos principais da window são os seguintes:
　objeto document do JavaScript
objeto frames do JavaScript
objeto history do JavaScript
objeto location do JavaScript
objeto navigator do JavaScript
objeto screen do JavaScript

alguns métodos comuns
　método valueof(): retorna o valor original do objeto especificado
o método split() divide uma string em um array de strings e retorna esse array.
o método indexOf() pode retornar a posição da primeira ocorrência de um valor específico na string.　　　
o método substring() é usado para extrair caracteres entre dois índices específicos de uma string.
o método substr() pode extrair uma quantidade específica de caracteres a partir de uma string, começando do posição startPos.　　　
o método join() é usado para inserir todos os elementos de um array em uma string.
arrayObject.join(qualificador)
o método reverse() é usado para inverter a ordem dos elementos de um array.　　　
o método slice() pode retornar elementos selecionados de um array existente.

expressão literal de objeto　

A expressão literal de objeto é usada para criar um processo que contém muitos atributos, como mostrado a seguir:

 <script type="text/javascript">
 var company = {
  name: "Microsoft",
  ages : 39,
  employees : 99000,
  CEO: "Nadella"
 };  
</script> 

A coisa a ser notada é que os atributos e seus valores são separados por dois pontos (:); múltiplos atributos são separados por vírgulas (,). Uma expressão literal de objeto pode definir métodos, bastando escrever 'function' no atributo do objeto, isso é uma função anônima, para chamá-la, basta escrever o nome do método().

 <script type="text/javascript">
var cão = {
 nome:"cão",
 idade:2,
 run:function(){
    return "123";
}
}
alert(dog.run());//Se a entrada for dog.run, então será exibido o código da parte function seguinte
</script> 

Encapulamento de tipos de valores básicos　

O JavaScript tem cinco tipos básicos de valores: number, string, Boolean, null e undefined. Além de null e undefined, os outros três têm chamados de objetos de encapulamento básico. Pode-se usar os construtores internos Number(), String() e Boolean() para criar objetos de encapulamento.

 var num = new Number(10);
console.log(typeof num);//object 
Método Object()
 Object(); // Retorna um objeto vazio
Object(undefined); // Retorna um objeto vazio
Object(null); // Retorna um objeto vazio
Object(1) // É equivalente a new Number(1)
Object('foo'); // É equivalente a new String('foo')
Object(true); // É equivalente a new Boolean(true)
Object([]); // Retorna o array original
Object({}); // Retorna o objeto original
Object(function(){}); // Retorna a função original 

Parte do array　

1.Objeto Array　

Objeto Array: fornece suporte para criar arrays de qualquer tipo de dados.
arrayObj = new Array()
arrayObj = new Array([tamanho])
arrayObj = new Array([elemento0[, elemento1[ ..., [elementoN]]]])

Definição: var arr = [2,3,45,6]; var arr = new Array(2,4,5,7)　

Ambos não têm diferença de definição, [] tem melhor desempenho devido ao código mais curto.　

Usando arrays e literais de objetos: var aTest = []; É uma boa escolha usar literais de arrays ao criar arrays; De forma semelhante, literais de objetos também podem ser usados para economizar espaço. As duas linhas a seguir são iguais, mas a que usa o literal de objeto é mais curta:

 var oTest = new Object; //Evite usar
 var oTest = { }; //A melhor escolha, ou var 0Test = [ ]; 

Para obter o melhor desempenho na iteração de arrays, recomenda-se usar o classic for loop.

 var list = [1, 2, 3, 4, 5, ...... 100000000];
for(var i = 0, l = list.length; i < l; i++) {
 console.log(list[i]);
} 

O código acima tem uma manipulação, que é o cache do comprimento do array através de l = list.length.　

Construtor Array　

Devido à ambiguidade do construtor Array em como lidar com parâmetros, sempre é recomendável usar a sintaxe literal dos arrays - [] - para criar arrays.　

Portanto, o seguinte código pode ser confuso:
　new Array(3, 4, 5); // Result: [3, 4, 5]
new Array(3) // Result: [], o comprimento deste array é 3
Deve-se evitar ao máximo usar o construtor de array para criar novos arrays. Recomenda-se usar a sintaxe literal dos arrays. Eles são mais curtos e concisos, aumentando assim a legibilidade do código.　

do Array de arrays propriedades　

do Array de arrays3As seguintes propriedades: propriedade length, propriedade prototype, propriedade constructor　

1.length propriedade　

A propriedade length representa o comprimento do array, ou seja, o número de elementos nele. Como os índices do array sempre começam por 0, os limites de um array são: 0 e length-1Diferente de outras linguagens, o atributo length do Array em JavaScript é mutável, o que deve ser notado especialmente.　

2.prototype propriedade　

Retorna a referência ao prototype do objeto. A propriedade prototype é comum a todos os objetos.　

Para exemplificar o uso da propriedade prototype no objeto Array, considere o seguinte exemplo.
　Adicionar um método ao objeto Array que retorna o maior elemento do array. Para fazer isso, declare uma função, adicione-a a Array.prototype e use-a.

 function array_max() 
{ 
var i,max=this[0]; 
for(i=1;i<this.length;i++) 
{ 
if(max<this[i]) 
max=this[i]; 
} 
return max; 
} 
Array.prototype.max=array_max; 
var x=new Array(1,2,3,4,5,6); 
var y=x.max(); 

Após a execução deste código, y armazena o valor máximo do array x, ou seja6.　

3.propriedade constructor　

Representa a função de criação de objetos. Observação: a propriedade constructor é um membro de todos os objetos que têm prototype. Inclui todos os objetos nativos do JScript, exceto os objetos Global e Math. A propriedade constructor armazena uma referência para a função que constrói a instância específica do objeto.　

Por exemplo:

 x = new String("Hi"); 
if(x.constructor==String) //Para processar (condição verdadeira). 
//ou 
function MyFunc{ 
//Corpo da função. 
} 
y=new MyFunc; 

if(y.constructor==MyFunc)//Para processar (condição verdadeira).
Para arrays:
　y = new Array();

Método do objeto Array

Método sort()　

Sintaxe
arrayObject.sort(sortby)
sortby opcional. Determina a ordem de classificação. Deve ser uma função.
var arr = [11,2,28,4,5,1});
console.log(arr.sort());//return [1, 11, 2, 28, 4, 5]
Porque aqui?11、28Não está ordenado? Isso porque o sort sem parâmetros ordena conforme a ordem do código de caractere.　

Então, se quiser ordenar os elementos do array de menor para maior, veja o código a seguir:

 var arr = [11,2,28,4,5,1});
 console.log(arr.sort(function(a,b){
  return a-b;//return [1, 2, 4, 5, 11, 28]
 }); 

Se quiser classificar conforme outros padrões, é necessário fornecer uma função de comparação, que compara dois valores e retorna um número que descreve a ordem relativa desses valores. A função de comparação deve ter dois parâmetros 'a' e 'b', cujos valores de retorno são os seguintes:
　Se a variável 'a' for menor que 'b', na ordem de classificação, 'a' deve aparecer antes de 'b', então retorna um valor menor que 0.
Se a variável 'a' for igual a 'b', retorna 0.
Se a variável 'a' for maior que 'b', retorna um valor maior que 0.

Isso é tudo o que há no artigo, espero que ajude no seu aprendizado e que vocês apoiem o tutorial Gritar.