├── 5_Date.js
├── 5_Date_ES6.js
├── 1_functions_ES6.js
├── 2_functions_ES6.js
├── 2_functions.js
├── 1_functions.js
├── 8_Heranca.js
├── 8_Heranca_ES6.js
├── 6_Operadores_ES6.js
├── 6_Operadores.js
├── 4_Expressoes_regulares.js
├── 4_Expressoes_regulares_ES6.js
├── ReadMe.md
├── 7_Statements_ES6.js
├── 7_Statements.js
├── 3_arrays_ES6.js
├── 9_Heranca_ES6.js
├── 3_arrays.js
└── 9_Heranca.js


/5_Date.js:
--------------------------------------------------------------------------------
 1 | //Criando data com new Date, utilizando Função Construtora.
 2 | var hoje = new Date();
 3 | console.log(hoje); // 2016-05-25T17:49:53.556Z
 4 | console.log(hoje.getTime()); // 1464198593556  Milisegundos
 5 | var natal = new Date(1464199028000)
 6 | console.log(natal); //2016-05-25T17:57:08.000Z
 7 | 
 8 | 
 9 | //Criando data com Date, utilizando Função Fábrica.
10 | var hoje = Date()
11 | console.log(hoje); // 'Wed May 25 2016 14:53:37 GMT-0300 (BRT)'
12 | console.log(Date.parse(hoje)); // 1464199028000
13 | var natal = Date(1464199028000)
14 | console.log(natal); // 'Wed May 25 2016 14:57:56 GMT-0300 (BRT)'
15 | 
16 | //Date API
17 | //getDate - Retorna o dia
18 | //getDay - Retorna o dia da semana
19 | //getFullYear - Retorna o ano
20 | //getHours - Retorna as horas
21 | //getMilliseconds - Retorna os milisegundos
22 | //getMinutes - Retorna os minutos
23 | //getMonth - Retorna o mês
24 | //getSeconds - Retorna os segundos
25 | //getTime - Retorna o tempo em Milisegundos
26 | //toString - Retorna a data em String
27 | 
28 | //Função Construtora. (UTILIZA O OPERADOR NEW)
29 | console.log(Date.parse('2016/05/25')); // 1464145200000
30 | console.log(new Date(1464145200000)); // 2016-05-25T03:00:00.000Z
31 | console.log(new Date('2016-05-25T16:20:00-00:00')); //2016-05-25T16:20:00-00:00'
32 | var data = new Date();
33 | console.log(data.getDate()); // 25
34 | console.log(data.getDay()); // 3
35 | console.log(data.getHours()); // 15
36 | console.log(data.getFullYear()); // 2016
37 | console.log(data.getMilliseconds()); // 916
38 | console.log(data.getMinutes()); // 26
39 | console.log(data.getMonth()); // 4
40 | console.log(data.getSeconds()); // 9
41 | console.log(data.getTime()); // 1464200769916
42 | console.log(data.toString()); // Wed May 25 2016 15:26:09 GMT-0300 (BRT)
43 | 
44 | 
45 | //Função Fábrica.
46 | console.log(Date.parse('05/25/2016')); // 1464145200000
47 | console.log(Date(1464145200000)); // Wed May 25 2016 15:12:02 GMT-0300 (BRT)
48 | 


--------------------------------------------------------------------------------
/5_Date_ES6.js:
--------------------------------------------------------------------------------
 1 | //Criando data com new Date, utilizando Função Construtora.
 2 | var hoje = new Date();
 3 | console.log(hoje); // 2016-05-25T17:49:53.556Z
 4 | console.log(hoje.getTime()); // 1464198593556  Milisegundos
 5 | var natal = new Date(1464199028000)
 6 | console.log(natal); //2016-05-25T17:57:08.000Z
 7 | 
 8 | 
 9 | //Criando data com Date, utilizando Função Fábrica.
10 | var hoje = Date()
11 | console.log(hoje); // 'Wed May 25 2016 14:53:37 GMT-0300 (BRT)'
12 | console.log(Date.parse(hoje)); // 1464199028000
13 | var natal = Date(1464199028000)
14 | console.log(natal); // 'Wed May 25 2016 14:57:56 GMT-0300 (BRT)'
15 | 
16 | //Date API
17 | //getDate - Retorna o dia
18 | //getDay - Retorna o dia da semana
19 | //getFullYear - Retorna o ano
20 | //getHours - Retorna as horas
21 | //getMilliseconds - Retorna os milisegundos
22 | //getMinutes - Retorna os minutos
23 | //getMonth - Retorna o mês
24 | //getSeconds - Retorna os segundos
25 | //getTime - Retorna o tempo em Milisegundos
26 | //toString - Retorna a data em String
27 | 
28 | //Função Construtora. (UTILIZA O OPERADOR NEW)
29 | console.log(Date.parse('2016/05/25')); // 1464145200000
30 | console.log(new Date(1464145200000)); // 2016-05-25T03:00:00.000Z
31 | console.log(new Date('2016-05-25T16:20:00-00:00')); //2016-05-25T16:20:00-00:00'
32 | const data = new Date();
33 | console.log(data.getDate()); // 25
34 | console.log(data.getDay()); // 3
35 | console.log(data.getHours()); // 15
36 | console.log(data.getFullYear()); // 2016
37 | console.log(data.getMilliseconds()); // 916
38 | console.log(data.getMinutes()); // 26
39 | console.log(data.getMonth()); // 4
40 | console.log(data.getSeconds()); // 9
41 | console.log(data.getTime()); // 1464200769916
42 | console.log(data.toString()); // Wed May 25 2016 15:26:09 GMT-0300 (BRT)
43 | 
44 | 
45 | //Função Fábrica.
46 | console.log(Date.parse('05/25/2016')); // 1464145200000
47 | console.log(Date(1464145200000)); // Wed May 25 2016 15:12:02 GMT-0300 (BRT)
48 | 


--------------------------------------------------------------------------------
/1_functions_ES6.js:
--------------------------------------------------------------------------------
  1 | //Function Declaration: A função é carregada antes do código ser interpretado.
  2 | console.log(soma(2,3)); // 5
  3 | 
  4 | function soma(a, b) {
  5 |   return a + b;
  6 | }
  7 | 
  8 | 
  9 | 
 10 | //Function Expression: A função é carregada durante a interpretação do código.
 11 | var soma = (a, b) => a + b
 12 | console.log(soma(2,2)); // 4
 13 | 
 14 | 
 15 | 
 16 | //Invocando uma função diretamente no escopo global.
 17 | var soma = (a, b) => a + b
 18 | console.log(soma(2, 4)); // 6
 19 | 
 20 | 
 21 | 
 22 | //Passando uma função como parametro.
 23 | var helloWorld = () => "Hello World_1!";
 24 | console.log(helloWorld); // [Function]
 25 | console.log(helloWorld()); // Hello World_1!
 26 | 
 27 | 
 28 | 
 29 | //Passando uma função dentro de uma função como parametro.
 30 | var helloWorld = () => () => "Hello World_2!";
 31 | console.log(helloWorld); // [Function]
 32 | console.log(helloWorld()); // [Function]
 33 | console.log(helloWorld()()); // Hello World_2!
 34 | const hw = helloWorld();
 35 | console.log(hw()); // Hello World_2!
 36 | 
 37 | 
 38 | 
 39 | //Utilizando uma função como método, declarado dentro do objeto.
 40 | var pessoa = {
 41 |   nome: 'joão',
 42 |   idade: 20,
 43 |   getIdade() {
 44 |     return this.idade;
 45 |   }
 46 | };
 47 | 
 48 | console.log(pessoa); // {nome: 'joão', idade: 20, getIdade: [Function]}
 49 | console.log(pessoa.getIdade()); // 20
 50 | 
 51 | 
 52 | 
 53 | //Utilizando a função com call e apply
 54 | const getIdade = function(extra) {
 55 |   console.log(arguments);
 56 |   return this.idade + extra;
 57 | };
 58 | 
 59 | var pessoa = {
 60 | nome: 'João',
 61 | idade: 22,
 62 | getIdade
 63 | };
 64 | 
 65 | console.log(pessoa.getIdade(2)); // { '0': 2 } 24
 66 | console.log(getIdade.call(pessoa, 3, 1)); // { '0': 3, '1': 1 } 25
 67 | console.log(getIdade.apply(pessoa, [5, 1, 2])); // { '0': 5, '1': 1, '2': 2} 27
 68 | 
 69 | 
 70 | 
 71 | //(Funções Fábrica VS. Função Construtora)
 72 | 
 73 | //Função Fábrica.
 74 | const criar = (nome, idade) => ({
 75 |   nome,
 76 |   idade
 77 | });
 78 | 
 79 | console.log(criar('pedro', 20)); // { nome: 'pedro', idade: 20 }
 80 | console.log(criar('maria', 30)); // { nome: 'maria', idade: 30 }
 81 | console.log(criar('rafael', 40)); // {nome: 'rafael', idade: 40 }
 82 | 
 83 | 
 84 | 
 85 | //Função Construtora, utiliza o operador new
 86 | const Pessoa = function(nome, idade) {
 87 |   this.nome = nome;
 88 |   this.idade = idade;
 89 | };
 90 | 
 91 | console.log(new Pessoa('Pedro', 20)); // { nome: 'pedro', idade: 20 }
 92 | console.log(new Pessoa('Maria', 30)); // { nome: 'maria', idade: 30 }
 93 | console.log(new Pessoa('Rafael', 40)); // { nome: 'rafael', idade: 40 }
 94 | 
 95 | const pedro = {};
 96 | Pessoa.call(pedro, 'Pedro', 20);
 97 | console.log(pedro); // { nome: 'Pedro', idade: 20 }
 98 | 
 99 | const maria = {};
100 | Pessoa.call(maria, 'Maria', 30);
101 | console.log(maria); // { nome: 'Maria', idade: 30 }
102 | 


--------------------------------------------------------------------------------
/2_functions_ES6.js:
--------------------------------------------------------------------------------
  1 | //Função incrementar contador count.
  2 | var count = 0;
  3 | var add = () => ++count;
  4 | console.log(add()); // 1
  5 | console.log(add()); // 2
  6 | console.log(add()); // 3
  7 | 
  8 | 
  9 | 
 10 | ////Função adicionar item em array.
 11 | var itens = [];
 12 | var add = item => {
 13 |   itens.push(item);
 14 |   return itens;
 15 | };
 16 | console.log(add('A')); // [ 'A' ]
 17 | console.log(add('B')); // [ 'A', 'B' ]
 18 | console.log(add('C')); // [ 'A', 'B', 'C' ]
 19 | console.log(add()); // [ 'A', 'B', 'C', undefined ]
 20 | 
 21 | 
 22 | 
 23 | //Função incrementar contador count.
 24 | var count = {
 25 |   value: 0,
 26 |   add() {
 27 |       return ++this.value;
 28 |   }
 29 | };
 30 | console.log(count.add()); // 1
 31 | console.log(count.add()); // 2
 32 | console.log(count.add()); // 3
 33 | count.value = undefined;
 34 | console.log(count.add()); //undefined
 35 | 
 36 | 
 37 | 
 38 | //Função adicionar item em array.
 39 | var itens = {
 40 |   value: [],
 41 |   add(item) {
 42 |     this.value.push(item);
 43 |     return this.value;
 44 |   }
 45 | };
 46 | console.log(itens.add('A')); // [ 'A' ]
 47 | console.log(itens.add('B')); // [ 'A', 'B' ]
 48 | console.log(itens.add('C')); // [ 'A', 'B', 'C' ]
 49 | 
 50 | 
 51 | 
 52 | //Função Fábrica
 53 | var count = () => {
 54 |   let value = 0;
 55 |   return {
 56 |         add() {
 57 |         return ++value;
 58 |     }
 59 |   };
 60 | };
 61 | var c = count();
 62 | console.log(c.value);
 63 | console.log(c.add()); // 1
 64 | console.log(c.add()); // 2
 65 | console.log(c.add()); // 3
 66 | 
 67 | 
 68 | 
 69 | //Função Construtora
 70 | var count = function() {
 71 |   let value = 0;
 72 |   this.add = () => ++value;
 73 | };
 74 | var c = new count();
 75 | console.log(c.value);
 76 | console.log(c.add()); // 1
 77 | console.log(c.add()); // 2
 78 | console.log(c.add()); // 3
 79 | 
 80 | 
 81 | 
 82 | //Função Module Pattern -- Encapsula tudo o que tiver como préfixo anderline(_)
 83 | var count = ((() => {
 84 |   let _value = 0;
 85 |   return {
 86 |         add() {
 87 |         return ++_value;
 88 |     },
 89 |     reset() {
 90 |       _value = 0;
 91 |     }
 92 |   };
 93 | }))();
 94 | console.log(count.value);
 95 | console.log(count.add()); // 1
 96 | console.log(count.add()); // 2
 97 | console.log(count.add()); // 3
 98 | count.reset(); // reseta
 99 | console.log(count.add()); // 1
100 | 
101 | 
102 | //Função Revealing Module Pattern -- Encapsula tudo o que tiver como préfixo anderline(_)
103 | var count = ((() => {
104 |   let _value = 0;
105 |   const _add = () => ++_value;
106 |   const _reset = () => {
107 |     _value = 0;
108 |   };
109 |   return {
110 |     add: _add,
111 |     reset: _reset
112 |   };
113 | }))();
114 | console.log(count.value);
115 | console.log(count.add()); // 1
116 | console.log(count.add()); // 2
117 | console.log(count.add()); // 3
118 | count.reset(); // reseta
119 | console.log(count.add()); // 1
120 | 


--------------------------------------------------------------------------------
/2_functions.js:
--------------------------------------------------------------------------------
  1 | //Função incrementar contador count.
  2 | var count = 0;
  3 | var add = function() {
  4 |     return ++count;
  5 | };
  6 | console.log(add()); // 1
  7 | console.log(add()); // 2
  8 | console.log(add()); // 3
  9 | 
 10 | 
 11 | 
 12 | ////Função adicionar item em array.
 13 | var itens = [];
 14 | var add = function(item) {
 15 |   itens.push(item);
 16 |   return itens;
 17 | };
 18 | console.log(add('A')); // [ 'A' ]
 19 | console.log(add('B')); // [ 'A', 'B' ]
 20 | console.log(add('C')); // [ 'A', 'B', 'C' ]
 21 | console.log(add()); // [ 'A', 'B', 'C', undefined ]
 22 | 
 23 | 
 24 | 
 25 | //Função incrementar contador count.
 26 | var count = {
 27 |   value: 0,
 28 |   add: function() {
 29 |       return ++this.value;
 30 |   }
 31 | };
 32 | console.log(count.add()); // 1
 33 | console.log(count.add()); // 2
 34 | console.log(count.add()); // 3
 35 | count.value = undefined;
 36 | console.log(count.add()); //undefined
 37 | 
 38 | 
 39 | 
 40 | //Função adicionar item em array.
 41 | var itens = {
 42 |   value: [],
 43 |   add: function(item) {
 44 |     this.value.push(item);
 45 |     return this.value;
 46 |   }
 47 | };
 48 | console.log(itens.add('A')); // [ 'A' ]
 49 | console.log(itens.add('B')); // [ 'A', 'B' ]
 50 | console.log(itens.add('C')); // [ 'A', 'B', 'C' ]
 51 | 
 52 | 
 53 | 
 54 | //Função Fábrica
 55 | var count = function() {
 56 |   var value = 0;
 57 |   return {
 58 |         add: function() {
 59 |         return ++value;
 60 |     }
 61 |   };
 62 | };
 63 | var c = count();
 64 | console.log(c.value);
 65 | console.log(c.add()); // 1
 66 | console.log(c.add()); // 2
 67 | console.log(c.add()); // 3
 68 | 
 69 | 
 70 | 
 71 | //Função Construtora
 72 | var count = function() {
 73 |   var value = 0;
 74 |   this.add = function() {
 75 |     return ++value;
 76 |   };
 77 | };
 78 | var c = new count();
 79 | console.log(c.value);
 80 | console.log(c.add()); // 1
 81 | console.log(c.add()); // 2
 82 | console.log(c.add()); // 3
 83 | 
 84 | 
 85 | 
 86 | //Função Module Pattern -- Encapsula tudo o que tiver como préfixo anderline(_)
 87 | var count = (function() {
 88 |   var _value = 0;
 89 |   return {
 90 |         add: function() {
 91 |         return ++_value;
 92 |     },
 93 |     reset: function() {
 94 |       _value = 0;
 95 |     }
 96 |   };
 97 | })();
 98 | console.log(count.value);
 99 | console.log(count.add()); // 1
100 | console.log(count.add()); // 2
101 | console.log(count.add()); // 3
102 | count.reset(); // reseta
103 | console.log(count.add()); // 1
104 | 
105 | 
106 | //Função Revealing Module Pattern -- Encapsula tudo o que tiver como préfixo anderline(_)
107 | var count = (function() {
108 |   var _value = 0;
109 |   var _add = function() {
110 |       return ++_value;
111 |   };
112 |   var _reset = function() {
113 |     _value = 0;
114 |   };
115 |   return {
116 |     add: _add,
117 |     reset: _reset
118 |   };
119 | })();
120 | console.log(count.value);
121 | console.log(count.add()); // 1
122 | console.log(count.add()); // 2
123 | console.log(count.add()); // 3
124 | count.reset(); // reseta
125 | console.log(count.add()); // 1
126 | 


--------------------------------------------------------------------------------
/1_functions.js:
--------------------------------------------------------------------------------
  1 | //Function Declaration: A função é carregada antes do código ser interpretado.
  2 | console.log(soma(2,3)); // 5
  3 | 
  4 | function soma(a, b) {
  5 |   return a + b;
  6 | }
  7 | 
  8 | 
  9 | 
 10 | //Function Expression: A função é carregada durante a interpretação do código.
 11 | var soma = function(a, b) {
 12 |   return a + b;
 13 | }
 14 | 
 15 | console.log(soma(2,2)); // 4
 16 | 
 17 | 
 18 | 
 19 | //Invocando uma função diretamente no escopo global.
 20 | var soma = function(a, b) {
 21 |   return a + b;
 22 | }
 23 | console.log(soma(2, 4)); // 6
 24 | 
 25 | 
 26 | 
 27 | //Passando uma função como parametro.
 28 | var helloWorld = function() {
 29 |         return "Hello World_1!";
 30 |     };
 31 | 
 32 | console.log(helloWorld); // [Function]
 33 | console.log(helloWorld()); // Hello World_1!
 34 | 
 35 | 
 36 | 
 37 | //Passando uma função dentro de uma função como parametro.
 38 | var helloWorld = function() {
 39 |     return function(){
 40 |         return "Hello World_2!";
 41 |     };
 42 | };
 43 | 
 44 | console.log(helloWorld); // [Function]
 45 | console.log(helloWorld()); // [Function]
 46 | console.log(helloWorld()()); // Hello World_2!
 47 | var hw = helloWorld();
 48 | console.log(hw()); // Hello World_2!
 49 | 
 50 | 
 51 | 
 52 | //Utilizando uma função como método, declarado dentro do objeto.
 53 | var pessoa = {
 54 |   nome: 'joão',
 55 |   idade: 20,
 56 |   getIdade: function() {
 57 |     return this.idade;
 58 |   }
 59 | };
 60 | console.log(pessoa); // {nome: 'joão', idade: 20, getIdade: [Function]}
 61 | console.log(pessoa.getIdade()); // 20
 62 | 
 63 | 
 64 | 
 65 | //Utilizando a função com call e apply
 66 | var getIdade = function(extra) {
 67 |   console.log(arguments);
 68 |   return this.idade + extra;
 69 | }
 70 | 
 71 | var pessoa = {
 72 | nome: 'João',
 73 | idade: 22,
 74 | getIdade: getIdade
 75 | };
 76 | 
 77 | console.log(pessoa.getIdade(2)); // { '0': 2 } 24
 78 | console.log(getIdade.call(pessoa, 3, 1)); // { '0': 3, '1': 1 } 25
 79 | console.log(getIdade.apply(pessoa, [5, 1, 2])); // { '0': 5, '1': 1, '2': 2} 27
 80 | 
 81 | 
 82 | 
 83 | //(Funções Fábrica VS. Função Construtora)
 84 | 
 85 | //Função Fábrica.
 86 | var criar = function(nome, idade) {
 87 |   return {
 88 |     nome: nome,
 89 |     idade: idade
 90 |   };
 91 | };
 92 | 
 93 | console.log(criar('pedro', 20)); // { nome: 'pedro', idade: 20 }
 94 | console.log(criar('maria', 30)); // { nome: 'maria', idade: 30 }
 95 | console.log(criar('rafael', 40)); // {nome: 'rafael', idade: 40 }
 96 | 
 97 | 
 98 | 
 99 | //Função Construtora, utiliza o operador new
100 | var Pessoa = function(nome, idade) {
101 |   this.nome = nome;
102 |   this.idade = idade;
103 | };
104 | 
105 | console.log(new Pessoa('Pedro', 20)); // { nome: 'pedro', idade: 20 }
106 | console.log(new Pessoa('Maria', 30)); // { nome: 'maria', idade: 30 }
107 | console.log(new Pessoa('Rafael', 40)); // { nome: 'rafael', idade: 40 }
108 | 
109 | var pedro = {};
110 | Pessoa.call(pedro, 'Pedro', 20);
111 | console.log(pedro); // { nome: 'Pedro', idade: 20 }
112 | 
113 | var maria = {};
114 | Pessoa.call(maria, 'Maria', 30);
115 | console.log(maria); // { nome: 'Maria', idade: 30 }
116 | 


--------------------------------------------------------------------------------
/8_Heranca.js:
--------------------------------------------------------------------------------
  1 | //Um objeto é uma coleção dinâmica de chaves e valores, que podem ser de qualquer tipo, e um protótipo que pode ser
  2 | //objeto ou null. A propriedade do protótipo não pode ser acessada diretamente de um objeto. Apenas é possivel
  3 | //acessar determinada propriedade do protótipo passando o objeto pai e em sequencia a propriedade.
  4 | //Herança baseada em protótipo basicamente é um modelo de herança diferente da herança de orientação a objetos.
  5 | //que possibilita herdar propriedades e metodos de objetos existentes.
  6 | //Exemplo 1 - Criando objetos diretamente e atribuindo protótipo com __proto__
  7 | var homem = {
  8 |     sexo: 'masculino'
  9 | };
 10 | 
 11 | var mulher = {
 12 |     sexo: 'feminino'
 13 | };
 14 | 
 15 | var joao = {
 16 |     nome: 'João',
 17 |     idade: 20,
 18 |     __proto__: homem
 19 | };
 20 | 
 21 | var maria = {
 22 |     nome: 'Maria',
 23 |     idade: 18,
 24 |     __proto__: mulher
 25 | };
 26 | 
 27 | console.log(joao); // { nome: 'João', idade: 20 }
 28 | console.log(joao.sexo); // masculino
 29 | console.log(maria); // { nome: 'Maria', idade: 18 }
 30 | console.log(maria.sexo); // feminino
 31 | 
 32 | 
 33 | 
 34 | //Apesar da propriedade __proto__ ser suportada por todos os navegadores ela não é adotada por todos os interpretadores,
 35 | //então prefira utilizar Object.getPrototypeOf e Object.setPrototypeOf para interagir com o protótipo do objeto;
 36 | //Exemplo 2 - Criando objeto diretamente e atribuindo protótipo com Object.setPrototypeOf.
 37 | var homem = {
 38 |     sexo: 'masculino'
 39 | };
 40 | 
 41 | var joao = {
 42 |     nome: 'João',
 43 |     idade: 20,
 44 | };
 45 | 
 46 | console.log(joao); // { nome: 'João', idade: 20 }
 47 | console.log(joao.sexo); // undefined
 48 | Object.setPrototypeOf(joao, homem);
 49 | console.log(joao.sexo); // masculino
 50 | 
 51 | 
 52 | 
 53 | //Exemplo 3 - Criando objeto diretamente e atribuindo protótipo com Object.create. Que possibilita usar um objeto
 54 | //existente como protótipo. >>Melhor suporte entre os Browser<< RECOMENDADO
 55 | var homem = {
 56 |     sexo: 'masculino'
 57 | };
 58 | 
 59 | var jose = {
 60 |     nome: 'José',
 61 |     idade: 25,
 62 | };
 63 | 
 64 | console.log(jose); // { nome: 'José', idade: 25 }
 65 | console.log(jose.sexo); // undefined
 66 | var jose = Object.create(homem)
 67 | console.log(jose.sexo); // masculino
 68 | 
 69 | 
 70 | 
 71 | //Shadowing(sombra). O objeto busca a propriedade requisitada primeiro em sua própria estrutura, caso exista
 72 | //ele finaliza o processo. Ou seja, ele só vai buscar em outros protótipo caso não tenha a propriedade em sua própria estrutura.
 73 | //Exemplo 4 - Criando objeto diretamente, usando um delete para apagar a propriedade sexo, atribuindo protótipo com
 74 | //Object.setPrototypeOf. E, utilizando Object.keys para ver as propriedades do objeto.
 75 | var homem = {
 76 |     sexo: 'masculino'
 77 | };
 78 | 
 79 | var maria = {
 80 |     nome: 'Maria',
 81 |     idade: 25,
 82 |     sexo: 'feminino'
 83 | };
 84 | 
 85 | delete maria.sexo;
 86 | 
 87 | console.log(maria); // { nome: 'Maria', idade: 25 }
 88 | console.log(maria.sexo); // undefined
 89 | Object.setPrototypeOf(maria, homem);
 90 | console.log(maria.sexo); // masculino
 91 | console.log(Object.keys(maria)); // [ 'nome', 'idade' ]
 92 | 
 93 | 
 94 | 
 95 | //Exemplo 5 - Usando For in para buscar as propriedades do objeto, incluindo as protótipadas.
 96 | var homem = {
 97 |     sexo: 'masculino'
 98 | };
 99 | 
100 | var lucas = {
101 |     nome: 'Lucas',
102 |     idade: 25,
103 |     sexo: 'feminino'
104 | };
105 | 
106 | delete lucas.sexo;
107 | 
108 | console.log(lucas); // { nome: 'Lucas', idade: 25 }
109 | console.log(lucas.sexo); //undefined
110 | Object.setPrototypeOf(lucas, homem);
111 | console.log(lucas.sexo); // masculino
112 | 
113 | for(var property in lucas) {
114 |   console.log(property);
115 | }
116 | // nome
117 | // idade
118 | // sexo
119 | 
120 | 
121 | 
122 | //Exemplo 8 - Usando For in para buscar as propriedades do objeto. Utilizando hasOwnProperty para retornar apenas
123 | //as propriedades inerentes ao objeto.
124 | var homem = {
125 |     sexo: 'masculino'
126 | };
127 | 
128 | var junior = {
129 |     nome: 'Junior',
130 |     idade: 25,
131 |     sexo: 'feminino'
132 | };
133 | 
134 | delete junior.sexo;
135 | 
136 | console.log(junior); // { nome: 'Junior', idade: 25 }
137 | console.log(junior.sexo);
138 | Object.setPrototypeOf(junior, homem);
139 | console.log(junior.sexo); // masculino
140 | 
141 | for(var property in junior) {
142 |   if (!junior.hasOwnProperty(property)) continue;
143 |   console.log(property);
144 | }
145 | // nome
146 | // idade
147 | 


--------------------------------------------------------------------------------
/8_Heranca_ES6.js:
--------------------------------------------------------------------------------
  1 | //Um objeto é uma coleção dinâmica de chaves e valores, que podem ser de qualquer tipo, e um protótipo que pode ser
  2 | //objeto ou null. A propriedade do protótipo não pode ser acessada diretamente de um objeto. Apenas é possivel
  3 | //acessar determinada propriedade do protótipo passando o objeto pai e em sequencia a propriedade.
  4 | //Herança baseada em protótipo basicamente é um modelo de herança diferente da herança de orientação a objetos.
  5 | //que possibilita herdar propriedades e metodos de objetos existentes.
  6 | //Exemplo 1 - Criando objetos diretamente e atribuindo protótipo com __proto__
  7 | var homem = {
  8 |     sexo: 'masculino'
  9 | };
 10 | 
 11 | const mulher = {
 12 |     sexo: 'feminino'
 13 | };
 14 | 
 15 | var joao = {
 16 |     nome: 'João',
 17 |     idade: 20,
 18 |     __proto__: homem
 19 | };
 20 | 
 21 | var maria = {
 22 |     nome: 'Maria',
 23 |     idade: 18,
 24 |     __proto__: mulher
 25 | };
 26 | 
 27 | console.log(joao); // { nome: 'João', idade: 20 }
 28 | console.log(joao.sexo); // masculino
 29 | console.log(maria); // { nome: 'Maria', idade: 18 }
 30 | console.log(maria.sexo); // feminino
 31 | 
 32 | 
 33 | 
 34 | //Apesar da propriedade __proto__ ser suportada por todos os navegadores ela não é adotada por todos os interpretadores,
 35 | //então prefira utilizar Object.getPrototypeOf e Object.setPrototypeOf para interagir com o protótipo do objeto;
 36 | //Exemplo 2 - Criando objeto diretamente e atribuindo protótipo com Object.setPrototypeOf.
 37 | var homem = {
 38 |     sexo: 'masculino'
 39 | };
 40 | 
 41 | var joao = {
 42 |     nome: 'João',
 43 |     idade: 20,
 44 | };
 45 | 
 46 | console.log(joao); // { nome: 'João', idade: 20 }
 47 | console.log(joao.sexo); // undefined
 48 | Object.setPrototypeOf(joao, homem);
 49 | console.log(joao.sexo); // masculino
 50 | 
 51 | 
 52 | 
 53 | //Exemplo 3 - Criando objeto diretamente e atribuindo protótipo com Object.create. Que possibilita usar um objeto
 54 | //existente como protótipo. >>Melhor suporte entre os Browser<< RECOMENDADO
 55 | var homem = {
 56 |     sexo: 'masculino'
 57 | };
 58 | 
 59 | var jose = {
 60 |     nome: 'José',
 61 |     idade: 25,
 62 | };
 63 | 
 64 | console.log(jose); // { nome: 'José', idade: 25 }
 65 | console.log(jose.sexo); // undefined
 66 | var jose = Object.create(homem)
 67 | console.log(jose.sexo); // masculino
 68 | 
 69 | 
 70 | 
 71 | //Shadowing(sombra). O objeto busca a propriedade requisitada primeiro em sua própria estrutura, caso exista
 72 | //ele finaliza o processo. Ou seja, ele só vai buscar em outros protótipo caso não tenha a propriedade em sua própria estrutura.
 73 | //Exemplo 4 - Criando objeto diretamente, usando um delete para apagar a propriedade sexo, atribuindo protótipo com
 74 | //Object.setPrototypeOf. E, utilizando Object.keys para ver as propriedades do objeto.
 75 | var homem = {
 76 |     sexo: 'masculino'
 77 | };
 78 | 
 79 | var maria = {
 80 |     nome: 'Maria',
 81 |     idade: 25,
 82 |     sexo: 'feminino'
 83 | };
 84 | 
 85 | delete maria.sexo;
 86 | 
 87 | console.log(maria); // { nome: 'Maria', idade: 25 }
 88 | console.log(maria.sexo); // undefined
 89 | Object.setPrototypeOf(maria, homem);
 90 | console.log(maria.sexo); // masculino
 91 | console.log(Object.keys(maria)); // [ 'nome', 'idade' ]
 92 | 
 93 | 
 94 | 
 95 | //Exemplo 5 - Usando For in para buscar as propriedades do objeto, incluindo as protótipadas.
 96 | var homem = {
 97 |     sexo: 'masculino'
 98 | };
 99 | 
100 | const lucas = {
101 |     nome: 'Lucas',
102 |     idade: 25,
103 |     sexo: 'feminino'
104 | };
105 | 
106 | delete lucas.sexo;
107 | 
108 | console.log(lucas); // { nome: 'Lucas', idade: 25 }
109 | console.log(lucas.sexo); //undefined
110 | Object.setPrototypeOf(lucas, homem);
111 | console.log(lucas.sexo); // masculino
112 | 
113 | for(var property in lucas) {
114 |   console.log(property);
115 | }
116 | // nome
117 | // idade
118 | // sexo
119 | 
120 | 
121 | 
122 | //Exemplo 8 - Usando For in para buscar as propriedades do objeto. Utilizando hasOwnProperty para retornar apenas
123 | //as propriedades inerentes ao objeto.
124 | var homem = {
125 |     sexo: 'masculino'
126 | };
127 | 
128 | const junior = {
129 |     nome: 'Junior',
130 |     idade: 25,
131 |     sexo: 'feminino'
132 | };
133 | 
134 | delete junior.sexo;
135 | 
136 | console.log(junior); // { nome: 'Junior', idade: 25 }
137 | console.log(junior.sexo);
138 | Object.setPrototypeOf(junior, homem);
139 | console.log(junior.sexo); // masculino
140 | 
141 | for(var property in junior) {
142 |   if (!junior.hasOwnProperty(property)) continue;
143 |   console.log(property);
144 | }
145 | // nome
146 | // idade
147 | 


--------------------------------------------------------------------------------
/6_Operadores_ES6.js:
--------------------------------------------------------------------------------
  1 | //Comparando valor(numero) com frase(string). Utilizando ==
  2 | console.log(0 == ''); // true
  3 | console.log(10 == '10'); // true
  4 | console.log(null == undefined); //true
  5 | 
  6 | 
  7 | 
  8 | //Exemplo justificando o porque dos resultados anteriores.
  9 | console.log(10 == new Number(10)); // true
 10 | const dez = new Number(10);
 11 | console.log(dez); // [Number: 10]
 12 | console.log(dez.valueOf()); // 10
 13 | console.log(10 == dez); // true
 14 | 
 15 | 
 16 | 
 17 | //Comparando dois objetos em JS.
 18 | var x = {} // undefined
 19 | const y = {}; // undefined
 20 | x == y // false
 21 | x === y // false
 22 | x = y // {}
 23 | x == y // true
 24 | x === y // true
 25 | 
 26 | 
 27 | 
 28 | //Retornar o proprio operando
 29 | 0 || 2 // 2 - Compara todos os valores, e retorna o último true(verdadeiro).
 30 | 0 && 2 // 0 - Compara a príncipio só o primeiro valor, caso for true(verdadeiro), retorna-o, e finaliza a comparação.
 31 | -1 && 2 // 2 - Compara o segundo só se o primeiro for false(falso).
 32 | 
 33 | 
 34 | 
 35 | //Exemplo função. retorna(true) => 'ok'
 36 | if(10) {
 37 |   console.log('Ok');
 38 | }
 39 | 
 40 | 
 41 | //Exemplo negação.
 42 | !!0 // false
 43 | !!NaN // false
 44 | !!'' // false
 45 | !!false // false
 46 | !!null // false
 47 | !!undefined //false
 48 | 
 49 | 
 50 | 
 51 | //Exemplo prático utilizando generateSerial.
 52 | const generateSerial = max => {
 53 |   if (max === undefined || max === null || max === 0) {
 54 |     max = 1000;
 55 |   }
 56 |   return Math.floor(Math.random() * max);
 57 | };
 58 | console.log(generateSerial(1000)); //903
 59 | console.log(generateSerial(100)); // 24
 60 | console.log(generateSerial(10)); // 6
 61 | console.log(generateSerial()); // 201
 62 | 
 63 | 
 64 | 
 65 | //Exemplo simplificado 1.
 66 | var gSerial = max => {
 67 |   if(!max) {
 68 |     max = 1000;
 69 |   }
 70 |   return Math.floor(Math.random() * max);
 71 | };
 72 | console.log(gSerial(1000)); // 432
 73 | console.log(gSerial(100)); // 74
 74 | console.log(gSerial(10)); // 8
 75 | console.log(gSerial()); // 854
 76 | 
 77 | 
 78 | 
 79 | //Exemplo simplificado 2.
 80 | var gSerial = max => {
 81 |   max = max || 1000;
 82 |   return Math.floor(Math.random() * max);
 83 | };
 84 | console.log(gSerial(1000)); // 652
 85 | console.log(gSerial(100)); // 22
 86 | console.log(gSerial(10)); // 3
 87 | console.log(gSerial()); // 235
 88 | 
 89 | 
 90 | 
 91 | //Operadores lógicos (| e & e os || e &&).
 92 | console.log(1 | 2); // 3
 93 | console.log(1 & 2); // 0  //(0001 = 1) + (0010 = 2) = (0000) = 0
 94 | console.log(1 || 2); // 1
 95 | console.log(1 && 2); // 2
 96 | 
 97 | 
 98 | 
 99 | //Operadores Especiais
100 | //typeof, retorna o typo da variavel
101 | console.log(typeof 10); // number
102 | console.log(typeof "JavaScript"); // string
103 | console.log(typeof true); // boolean
104 | console.log(typeof undefined); // undefined
105 | console.log(typeof null); // object
106 | console.log(typeof {}); // object
107 | console.log(typeof /abc/); //object
108 | console.log(typeof []); // object
109 | console.log(typeof new Date()); // object
110 | 
111 | 
112 | 
113 | //new, cria um objeto com uma Função Construtora.
114 | const Pessoa = function(nome, idade) {
115 |   this.nome = nome;
116 |   this.idade = idade;
117 | };
118 | const pedro = new Pessoa('Pedro', 20);
119 | console.log(pedro); //{ nome: 'Pedro', idade: 20 }
120 | 
121 | 
122 | 
123 | //instanceof, verifica se o objeto possui uma determinada 'prototipagem' herança.
124 | console.log(pedro instanceof Pessoa); // true, verifica se pedro é uma Pessoa.
125 | console.log(pedro instanceof Date); // false, verifica se o pedro é uma Date.
126 | 
127 | 
128 | 
129 | //in, verifica se o objeto possui determinado atributo.
130 | console.log('nome' in pedro); // true, verifica se pedro tem o atributo nome.
131 | console.log('idade' in pedro); // true, verifica se pedro tem o atributo idade.
132 | delete pedro.nome;
133 | console.log('nome' in pedro); // false, pois o nome foi apagado.
134 | 
135 | 
136 | 
137 | //Operadores de comparação (>, <, <=, >=).
138 | console.log(9 >= 3); // true
139 | console.log(10 <= 7); // false
140 | console.log('Fernando' > 'Lucas'); // false, Porque o F é 'menor' que o L.
141 | console.log('Fernando' < 'Lucas'); // true, Porque o F é 'menor' que o L.
142 | 
143 | 
144 | 
145 | //Operadores aritméticos (+, -, *, / e %).
146 | console.log('Fernando' + ' Lucas'); // Fernando Lucas
147 | console.log(12 * 6); // 72
148 | console.log(10 % 2); // 0
149 | 
150 | 
151 | 
152 | //Operadores de atribuição (+=, -=, *=, /= e %=)
153 | var x = 10;
154 | console.log(x = x + 2); // 12  Normal
155 | var x = 10;
156 | console.log(x += 2); // 12  Simplificado
157 | var x = 10;
158 | console.log(x = x - 3); // 7  Normal
159 | var x = 10;
160 | console.log(x -= 3); // 7  Simplificado
161 | 
162 | 
163 | 
164 | //Operador de incremento e decremento (++ e --)
165 | var x = 0;
166 | console.log(++x); // 1
167 | var x = 10;
168 | console.log(--x); // 9
169 | var x = 0;
170 | console.log(x++); // 0
171 | console.log(x); // 1
172 | var x = 10;
173 | console.log(x--); // 10
174 | console.log(x); // 9
175 | 
176 | 
177 | 
178 | //Operação ternária (expressão) ? true : false.
179 | const idade = 22;
180 | const retorno = (idade >= 18) ? "Maior de idade" : "Menor de idade";
181 | console.log(retorno); // Maior de idade
182 | 


--------------------------------------------------------------------------------
/6_Operadores.js:
--------------------------------------------------------------------------------
  1 | //Comparando valor(numero) com frase(string). Utilizando ==
  2 | console.log(0 == ''); // true
  3 | console.log(10 == '10'); // true
  4 | console.log(null == undefined); //true
  5 | 
  6 | 
  7 | 
  8 | //Exemplo justificando o porque dos resultados anteriores.
  9 | console.log(10 == new Number(10)); // true
 10 | var dez = new Number(10);
 11 | console.log(dez); // [Number: 10]
 12 | console.log(dez.valueOf()); // 10
 13 | console.log(10 == dez); // true
 14 | 
 15 | 
 16 | 
 17 | //Comparando dois objetos em JS.
 18 | var x = {} // undefined
 19 | var y = {} // undefined
 20 | x == y // false
 21 | x === y // false
 22 | x = y // {}
 23 | x == y // true
 24 | x === y // true
 25 | 
 26 | 
 27 | 
 28 | //Retornar o proprio operando
 29 | 0 || 2 // 2 - Compara todos os valores, e retorna o último true(verdadeiro).
 30 | 0 && 2 // 0 - Compara a príncipio só o primeiro valor, caso for true(verdadeiro), retorna-o, e finaliza a comparação.
 31 | -1 && 2 // 2 - Compara o segundo só se o primeiro for false(falso).
 32 | 
 33 | 
 34 | 
 35 | //Exemplo função. retorna(true) => 'ok'
 36 | if(10) {
 37 |   console.log('Ok');
 38 | }
 39 | 
 40 | 
 41 | //Exemplo negação.
 42 | !!0 // false
 43 | !!NaN // false
 44 | !!'' // false
 45 | !!false // false
 46 | !!null // false
 47 | !!undefined //false
 48 | 
 49 | 
 50 | 
 51 | //Exemplo prático utilizando generateSerial.
 52 | var generateSerial = function(max) {
 53 |   if (max === undefined || max === null || max === 0) {
 54 |     max = 1000;
 55 |   }
 56 |   return Math.floor(Math.random() * max);
 57 | };
 58 | console.log(generateSerial(1000)); //903
 59 | console.log(generateSerial(100)); // 24
 60 | console.log(generateSerial(10)); // 6
 61 | console.log(generateSerial()); // 201
 62 | 
 63 | 
 64 | 
 65 | //Exemplo simplificado 1.
 66 | var gSerial = function(max) {
 67 |   if(!max) {
 68 |     max = 1000;
 69 |   }
 70 |   return Math.floor(Math.random() * max);
 71 | };
 72 | console.log(gSerial(1000)); // 432
 73 | console.log(gSerial(100)); // 74
 74 | console.log(gSerial(10)); // 8
 75 | console.log(gSerial()); // 854
 76 | 
 77 | 
 78 | 
 79 | //Exemplo simplificado 2.
 80 | var gSerial = function(max) {
 81 |   max = max || 1000;
 82 |   return Math.floor(Math.random() * max);
 83 | };
 84 | console.log(gSerial(1000)); // 652
 85 | console.log(gSerial(100)); // 22
 86 | console.log(gSerial(10)); // 3
 87 | console.log(gSerial()); // 235
 88 | 
 89 | 
 90 | 
 91 | //Operadores lógicos (| e & e os || e &&).
 92 | console.log(1 | 2); // 3
 93 | console.log(1 & 2); // 0  //(0001 = 1) + (0010 = 2) = (0000) = 0
 94 | console.log(1 || 2); // 1
 95 | console.log(1 && 2); // 2
 96 | 
 97 | 
 98 | 
 99 | //Operadores Especiais
100 | //typeof, retorna o typo da variavel
101 | console.log(typeof 10); // number
102 | console.log(typeof "JavaScript"); // string
103 | console.log(typeof true); // boolean
104 | console.log(typeof undefined); // undefined
105 | console.log(typeof null); // object
106 | console.log(typeof {}); // object
107 | console.log(typeof /abc/); //object
108 | console.log(typeof []); // object
109 | console.log(typeof new Date()); // object
110 | 
111 | 
112 | 
113 | //new, cria um objeto com uma Função Construtora.
114 | var Pessoa = function(nome, idade) {
115 |   this.nome = nome;
116 |   this.idade = idade;
117 | };
118 | var pedro = new Pessoa('Pedro', 20);
119 | console.log(pedro); //{ nome: 'Pedro', idade: 20 }
120 | 
121 | 
122 | 
123 | 
124 | //instanceof, verifica se o objeto possui uma determinada 'prototipagem' herança.
125 | console.log(pedro instanceof Pessoa); // true, verifica se pedro é uma Pessoa.
126 | console.log(pedro instanceof Date); // false, verifica se o pedro é uma Date.
127 | 
128 | 
129 | 
130 | //in, verifica se o objeto possui determinado atributo.
131 | console.log('nome' in pedro); // true, verifica se pedro tem o atributo nome.
132 | console.log('idade' in pedro); // true, verifica se pedro tem o atributo idade.
133 | delete pedro.nome;
134 | console.log('nome' in pedro); // false, pois o nome foi apagado.
135 | 
136 | 
137 | 
138 | //Operadores de comparação (>, <, <=, >=).
139 | console.log(9 >= 3); // true
140 | console.log(10 <= 7); // false
141 | console.log('Fernando' > 'Lucas'); // false, Porque o F é 'menor' que o L.
142 | console.log('Fernando' < 'Lucas'); // true, Porque o F é 'menor' que o L.
143 | 
144 | 
145 | 
146 | //Operadores aritméticos (+, -, *, / e %).
147 | console.log('Fernando' + ' Lucas'); // Fernando Lucas
148 | console.log(12 * 6); // 72
149 | console.log(10 % 2); // 0
150 | 
151 | 
152 | 
153 | //Operadores de atribuição (+=, -=, *=, /= e %=)
154 | var x = 10;
155 | console.log(x = x + 2); // 12  Normal
156 | var x = 10;
157 | console.log(x += 2); // 12  Simplificado
158 | var x = 10;
159 | console.log(x = x - 3); // 7  Normal
160 | var x = 10;
161 | console.log(x -= 3); // 7  Simplificado
162 | 
163 | 
164 | 
165 | //Operador de incremento e decremento (++ e --)
166 | var x = 0;
167 | console.log(++x); // 1
168 | var x = 10;
169 | console.log(--x); // 9
170 | var x = 0;
171 | console.log(x++); // 0
172 | console.log(x); // 1
173 | var x = 10;
174 | console.log(x--); // 10
175 | console.log(x); // 9
176 | 
177 | 
178 | 
179 | //Operação ternária (expressão) ? true : false.
180 | var idade = 22;
181 | var retorno = (idade >= 18) ? "Maior de idade" : "Menor de idade";
182 | console.log(retorno); // Maior de idade
183 | 


--------------------------------------------------------------------------------
/4_Expressoes_regulares.js:
--------------------------------------------------------------------------------
  1 | //Exemplo criar expressão regular. Modelo Fábrica.
  2 | var regExp = /abc/;
  3 | console.log(regExp); // /abc/
  4 | 
  5 | //Exemplo criar expressão regular. Modelo Construção(Utiliza o new).
  6 | var regExp = new RegExp('def');
  7 | console.log(regExp); // /def/
  8 | 
  9 | 
 10 | 
 11 | //Passo 1) Reconhecer numero de telefone.
 12 |  var regExp = /9999-9999/;
 13 |  var telefone = '9999-9999';
 14 | //Modelo exec
 15 |  console.log(regExp.exec(telefone)); //[ '9999-9999', index: 0, input: '9999-9999' ]
 16 | //Modelo test
 17 | console.log(regExp.test(telefone)); //true
 18 | 
 19 | 
 20 | 
 21 | //Passo 2) Reconhecer numero de telefone com DDD.
 22 |  var regExp = /\(46\) 9999-9999/;
 23 |  var telefone = '(46) 9999-9999';
 24 | //Modelo exec
 25 |  console.log(regExp.exec(telefone)); //[ '9999-9999', index: 0, input: '9999-9999' ]
 26 | //Modelo test
 27 | console.log(regExp.test(telefone)); //true
 28 | 
 29 | 
 30 | 
 31 | //Passo 3) Reconhecer numero de telefone em uma String
 32 | var regExp = /\(46\) 9999-9999/;
 33 | var telefone = 'O telefone é (46) 9999-9999, tratar com o Jose';
 34 | //Modelo exec
 35 | console.log(regExp.exec(telefone)); //[ '(46) 9999-9999', index: 13, input: 'O telefone é (46) 9999-9999, tratar com o Jose' ]
 36 | //Modelo test
 37 | console.log(regExp.test(telefone)); //true
 38 | 
 39 | 
 40 | 
 41 | //ER (Expressão Regular)
 42 | //Passo 4) Flexibilizar a ER para reconhecer qualquer numero de telefone que esteja de acordo com o padrão pré-definido
 43 | var regExp = /^\([0-9][0-9]\) [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]$/; // ^ -> inicio da ER, $ -> fim da ER
 44 | var telefone = '(46) 8899-9999';
 45 | //Modelo exec
 46 | console.log(regExp.exec(telefone)); //[ '(46) 8899-9999', index: 0, input: '(46) 8899-9999' ]
 47 | //Modelo test
 48 | console.log(regExp.test(telefone)); //true
 49 | 
 50 | 
 51 | 
 52 | //Exemplo 1) Quantificador
 53 | //Passo 5) Facilitar ER anterior, com as {}.
 54 | var regExp = /^\([0-9]{2}\) [0-9]{4}-[0-9]{4}$/; // ^ -> inicio da ER, $ -> fim da ER, {x} -> x indica a quantidade de numeros
 55 | var telefone = '(46) 8899-9999';
 56 | //Modelo exec
 57 | console.log(regExp.exec(telefone)); //[ '(46) 8899-9999', index: 0, input: '(46) 8899-9999' ]
 58 | //Modelo test
 59 | console.log(regExp.test(telefone)); //true
 60 | 
 61 | 
 62 | 
 63 | //Passo 6) Flexibilizar ER anterior. Caso o numero tenha 4 ou 5 digitos.
 64 | var regExp = /^\([0-9]{2}\) [0-9]{4,5}-[0-9]{4}$/; // ^ -> inicio da ER, $ -> fim da ER, {x} -> x quantidade de numeros
 65 | var telefone = '(46) 58899-9999';
 66 | //Modelo exec
 67 | console.log(regExp.exec(telefone)); //[ '(46) 58899-9999', index: 0, input: '(46) 58899-9999' ]
 68 | //Modelo test
 69 | console.log(regExp.test(telefone)); //true
 70 | 
 71 | 
 72 | 
 73 | //Exemplo 2) Quantificador
 74 | //Passo 7) Flexibilizar ER anterior, utilizando '?' para dizer que o '-' é opcional.
 75 | var regExp = /^\([0-9]{2}\) [0-9]{4,5}-?[0-9]{4}$/; // ^ -> inicio da ER, $ -> fim da ER, {x} -> x quantidade de numeros
 76 | var telefone1 = '(46) 688999999';
 77 | var telefone2 = '(54) 98763-3434';
 78 | //Modelo exec
 79 | console.log(regExp.exec(telefone1)); //[ '(46) 688999999', index: 0, input: '(46) 688999999' ]
 80 | console.log(regExp.exec(telefone2)); //[ '(54) 98763-3434', index: 0, input: '(54) 98763-3434' ]
 81 | //Modelo test
 82 | console.log(regExp.test(telefone1)); //true
 83 | console.log(regExp.test(telefone2)); //true
 84 | 
 85 | 
 86 | 
 87 | //Passo 8) Reconhecer numeros de telefone dentro de uma tabela.
 88 | var regExp = /<table><tr>(<td>\([0-9]{2}\) [0-9]{4,5}-?[0-9]{4}<\/td>)+<\/tr><\/table>/; // ()+ -> um ou mais, ou ()* -> zero ou mais
 89 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
 90 | //Modelo exec
 91 | console.log(regExp.exec(telefone)); //
 92 | //Modelo test
 93 | console.log(regExp.test(telefone)); // true
 94 | 
 95 | 
 96 | 
 97 | //Metacaracteres
 98 | // . - representa qualquer caracter
 99 | // \w - representa o conjunto [a-zA-Z0-9]
100 | // \W - representa o conjunto [^a-zA-Z0-9] || ^ -> negação do conjunto
101 | // \d - representa o conjunto [0-9]
102 | // \D - representa o conjunto [^0-9] || ^ -> negação do conjunto
103 | // \s - representa um espaço em branco
104 | // \S - representa um não espaço em branco
105 | // \n - representa uma quebra de linha
106 | // \t - representa um tab
107 | //Passo 9) Reconhecer numero de telefone dentro de uma tabela, utilizando as tags de Metacaracteres
108 | var regExp = /<table><tr>(<td>\(\d{2}\)\s\d{4,5}-?\d{4}<\/td>)+<\/tr><\/table>/; // \d e \s -> utilizando metacaracteres
109 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
110 | //Modelo exec
111 | console.log(regExp.exec(telefone)); //
112 | //Modelo test
113 | console.log(regExp.test(telefone)); // true
114 | 
115 | 
116 | 
117 | //Passo 10) Exemplo match da String API. Para pegar somente o primeiro telefone.
118 | var regExp = /\(\d{2}\)\s\d{4,5}-?\d{4}/; // Reconhecer somente o primeiro telefone. \d e \s -> metacaracteres
119 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
120 | console.log(telefone.match(regExp)); //[ '(80) 994534543', index: 15 .....] pegou só o primeiro.
121 | 
122 | 
123 | 
124 | //Modificadores
125 | // i - Case-insensitive mtching
126 | // g - Global matching
127 | // m - Multiline matching
128 | //Passo 11) Exemplo de da String API. Buscar todos os telefones da tabela utilizando modificadores.
129 | var regExp = /\(\d{2}\)\s\d{4,5}-?\d{4}/g; // Reconhecer somente os telefones || g -> todos os matching || \d e \s -> metacaracteres
130 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
131 | console.log(telefone.match(regExp)); //[ '(80) 994534543', '(70) 34353-4543', '(60) 77774543' ]
132 | 
133 | //Buscar somente os telefones sem os préfixos.
134 | var regExp = /\d{4,5}-?\d{4}/g; // Reconhecer somente os telefones || g -> todos os matching || \d e \s -> utilizando metacaracteres
135 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
136 | console.log(telefone.match(regExp)); // [ '994534543', '34353-4543', '77774543' ]
137 | 
138 | 
139 | 
140 | //Passo 12) Exemplo replace da String API. Substitui todos os telefones da tabela.
141 | var regExp = /\(\d{2}\)\s\d{4,5}-?\d{4}/g; // Reconhecer somente os telefones || g -> todos os matching || \d e \s -> metacaracteres
142 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
143 | console.log(telefone.replace(regExp, 'Telefone'));
144 | 


--------------------------------------------------------------------------------
/4_Expressoes_regulares_ES6.js:
--------------------------------------------------------------------------------
  1 | //Exemplo criar expressão regular. Modelo Fábrica.
  2 | var regExp = /abc/;
  3 | console.log(regExp); // /abc/
  4 | 
  5 | //Exemplo criar expressão regular. Modelo Construção(Utiliza o new).
  6 | var regExp = new RegExp('def');
  7 | console.log(regExp); // /def/
  8 | 
  9 | 
 10 | 
 11 | //Passo 1) Reconhecer numero de telefone.
 12 |  var regExp = /9999-9999/;
 13 |  var telefone = '9999-9999';
 14 | //Modelo exec
 15 |  console.log(regExp.exec(telefone)); //[ '9999-9999', index: 0, input: '9999-9999' ]
 16 | //Modelo test
 17 | console.log(regExp.test(telefone)); //true
 18 | 
 19 | 
 20 | 
 21 | //Passo 2) Reconhecer numero de telefone com DDD.
 22 |  var regExp = /\(46\) 9999-9999/;
 23 |  var telefone = '(46) 9999-9999';
 24 | //Modelo exec
 25 |  console.log(regExp.exec(telefone)); //[ '9999-9999', index: 0, input: '9999-9999' ]
 26 | //Modelo test
 27 | console.log(regExp.test(telefone)); //true
 28 | 
 29 | 
 30 | 
 31 | //Passo 3) Reconhecer numero de telefone em uma String
 32 | var regExp = /\(46\) 9999-9999/;
 33 | var telefone = 'O telefone é (46) 9999-9999, tratar com o Jose';
 34 | //Modelo exec
 35 | console.log(regExp.exec(telefone)); //[ '(46) 9999-9999', index: 13, input: 'O telefone é (46) 9999-9999, tratar com o Jose' ]
 36 | //Modelo test
 37 | console.log(regExp.test(telefone)); //true
 38 | 
 39 | 
 40 | 
 41 | //ER (Expressão Regular)
 42 | //Passo 4) Flexibilizar a ER para reconhecer qualquer numero de telefone que esteja de acordo com o padrão pré-definido
 43 | var regExp = /^\([0-9][0-9]\) [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]$/; // ^ -> inicio da ER, $ -> fim da ER
 44 | var telefone = '(46) 8899-9999';
 45 | //Modelo exec
 46 | console.log(regExp.exec(telefone)); //[ '(46) 8899-9999', index: 0, input: '(46) 8899-9999' ]
 47 | //Modelo test
 48 | console.log(regExp.test(telefone)); //true
 49 | 
 50 | 
 51 | 
 52 | //Exemplo 1) Quantificador
 53 | //Passo 5) Facilitar ER anterior, com as {}.
 54 | var regExp = /^\([0-9]{2}\) [0-9]{4}-[0-9]{4}$/; // ^ -> inicio da ER, $ -> fim da ER, {x} -> x indica a quantidade de numeros
 55 | var telefone = '(46) 8899-9999';
 56 | //Modelo exec
 57 | console.log(regExp.exec(telefone)); //[ '(46) 8899-9999', index: 0, input: '(46) 8899-9999' ]
 58 | //Modelo test
 59 | console.log(regExp.test(telefone)); //true
 60 | 
 61 | 
 62 | 
 63 | //Passo 6) Flexibilizar ER anterior. Caso o numero tenha 4 ou 5 digitos.
 64 | var regExp = /^\([0-9]{2}\) [0-9]{4,5}-[0-9]{4}$/; // ^ -> inicio da ER, $ -> fim da ER, {x} -> x quantidade de numeros
 65 | var telefone = '(46) 58899-9999';
 66 | //Modelo exec
 67 | console.log(regExp.exec(telefone)); //[ '(46) 58899-9999', index: 0, input: '(46) 58899-9999' ]
 68 | //Modelo test
 69 | console.log(regExp.test(telefone)); //true
 70 | 
 71 | 
 72 | 
 73 | //Exemplo 2) Quantificador
 74 | //Passo 7) Flexibilizar ER anterior, utilizando '?' para dizer que o '-' é opcional.
 75 | var regExp = /^\([0-9]{2}\) [0-9]{4,5}-?[0-9]{4}$/; // ^ -> inicio da ER, $ -> fim da ER, {x} -> x quantidade de numeros
 76 | const telefone1 = '(46) 688999999';
 77 | const telefone2 = '(54) 98763-3434';
 78 | //Modelo exec
 79 | console.log(regExp.exec(telefone1)); //[ '(46) 688999999', index: 0, input: '(46) 688999999' ]
 80 | console.log(regExp.exec(telefone2)); //[ '(54) 98763-3434', index: 0, input: '(54) 98763-3434' ]
 81 | //Modelo test
 82 | console.log(regExp.test(telefone1)); //true
 83 | console.log(regExp.test(telefone2)); //true
 84 | 
 85 | 
 86 | 
 87 | //Passo 8) Reconhecer numeros de telefone dentro de uma tabela.
 88 | var regExp = /<table><tr>(<td>\([0-9]{2}\) [0-9]{4,5}-?[0-9]{4}<\/td>)+<\/tr><\/table>/; // ()+ -> um ou mais, ou ()* -> zero ou mais
 89 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
 90 | //Modelo exec
 91 | console.log(regExp.exec(telefone)); //
 92 | //Modelo test
 93 | console.log(regExp.test(telefone)); // true
 94 | 
 95 | 
 96 | 
 97 | //Metacaracteres
 98 | // . - representa qualquer caracter
 99 | // \w - representa o conjunto [a-zA-Z0-9]
100 | // \W - representa o conjunto [^a-zA-Z0-9] || ^ -> negação do conjunto
101 | // \d - representa o conjunto [0-9]
102 | // \D - representa o conjunto [^0-9] || ^ -> negação do conjunto
103 | // \s - representa um espaço em branco
104 | // \S - representa um não espaço em branco
105 | // \n - representa uma quebra de linha
106 | // \t - representa um tab
107 | //Passo 9) Reconhecer numero de telefone dentro de uma tabela, utilizando as tags de Metacaracteres
108 | var regExp = /<table><tr>(<td>\(\d{2}\)\s\d{4,5}-?\d{4}<\/td>)+<\/tr><\/table>/; // \d e \s -> utilizando metacaracteres
109 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
110 | //Modelo exec
111 | console.log(regExp.exec(telefone)); //
112 | //Modelo test
113 | console.log(regExp.test(telefone)); // true
114 | 
115 | 
116 | 
117 | //Passo 10) Exemplo match da String API. Para pegar somente o primeiro telefone.
118 | var regExp = /\(\d{2}\)\s\d{4,5}-?\d{4}/; // Reconhecer somente o primeiro telefone. \d e \s -> metacaracteres
119 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
120 | console.log(telefone.match(regExp)); //[ '(80) 994534543', index: 15 .....] pegou só o primeiro.
121 | 
122 | 
123 | 
124 | //Modificadores
125 | // i - Case-insensitive mtching
126 | // g - Global matching
127 | // m - Multiline matching
128 | //Passo 11) Exemplo de da String API. Buscar todos os telefones da tabela utilizando modificadores.
129 | var regExp = /\(\d{2}\)\s\d{4,5}-?\d{4}/g; // Reconhecer somente os telefones || g -> todos os matching || \d e \s -> metacaracteres
130 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
131 | console.log(telefone.match(regExp)); //[ '(80) 994534543', '(70) 34353-4543', '(60) 77774543' ]
132 | 
133 | //Buscar somente os telefones sem os préfixos.
134 | var regExp = /\d{4,5}-?\d{4}/g; // Reconhecer somente os telefones || g -> todos os matching || \d e \s -> utilizando metacaracteres
135 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
136 | console.log(telefone.match(regExp)); // [ '994534543', '34353-4543', '77774543' ]
137 | 
138 | 
139 | 
140 | //Passo 12) Exemplo replace da String API. Substitui todos os telefones da tabela.
141 | var regExp = /\(\d{2}\)\s\d{4,5}-?\d{4}/g; // Reconhecer somente os telefones || g -> todos os matching || \d e \s -> metacaracteres
142 | var telefone = '<table><tr><td>(80) 994534543</td><td>(70) 34353-4543</td><td>(60) 77774543</td></tr></table>';
143 | console.log(telefone.replace(regExp, 'Telefone'));
144 | 


--------------------------------------------------------------------------------
/ReadMe.md:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | ### "A linguagem JavaScript é a única que as pessoas acham que não precisam aprender antes de começar a utilizar."
 4 | (Douglas Crockford)
 5 | 
 6 | ## O que é?
 7 | 
 8 |  JavaScript é uma linguagem de programação, criada por Dan Winkler em 1987 para a plataforma HyperCard da Apple. A princípio   denominada HyperTalk, que era uma linguagem orientada a eventos, que veio para simplificar, a proposta do criador era de fazer uma linguagem para iniciantes.
 9 |  A Netscape quando viu, ficou impressionada com a simplicidade da linguagem, e teve a idéia de embarcar ela no browser. Foi ai que o tão famoso Brendan Eich, conhecido como o criador do JavaScript entrou em cena. A Netscape então contratou-o para implementar uma linguagem para o seu browser. Tendo em vista que a Netscape buscava algo simples, o Brendan Eich se baseou nas linguagens Java, Scheme, Self, e Perl. A seguir será esplanado superficialmente quais são as origens do JavaScript.
10 | 
11 | **Java:**
12 |   - Sintaxe; Sintaxe familiar, exemplo do objeto Math que faz operações, porém uma coisa não tem nada a
13 | ver com a outra.
14 |   - Algumas convenções; CamelCase, nome de função e variável com letra minuscúla, dentre algumas outras
15 | similaridades.
16 | 
17 | **Scheme:**
18 |   - Lambda; Função anônima.
19 |   - Closure; Acontece quando uma função é criada dentro de outra função.
20 |   - Tipagem Fraca; Torna possível fazer operações com valores de tipos diferentes, convertendo o tipo dos
21 | valores e fazendo concatenção.
22 | 
23 | **Self:**
24 |   - Herança baseada em protótipos; É um estilo de programação orientada a objetos na qual não existe classes, em vez disso, a reutilização de comportamento(equivalente a herança das linguagens baseadas em classes) é realizada através de um processo de decorar(expandir) objetos existentes que servem como protótipos.Basicamente objetos herdam de outros objetos.
25 |   - Objetos dinâmicos; Permite que você defina seus próprios objetos. Em JavaScript pode-se adicionar métodos a objetos individuais, sem a necessidade de reusos adicionais. Isso dá enorme poder, uma vez quese pode escrever menos, com mais simplicidade e menor complexidade de código. É importante lembrar que objetos em JavaScript são como hashtables. Assim, se pode adicionar novos valores a qualquer momento.Já se o valor é  uma função, então se torna um método.
26 | 
27 | **Perl:**
28 |   - Expressões Regulares; São padrões utilizados para selecionar cadeias de caracteres de interesse em um texto. Em JavaScript, expressões regulares são também objetos. Por exemplo elas podem ser utilizadas com os métodos exec e test do objeto RegExp, e com os métodos match, replace, search, e split do objeto String.
29 | 
30 |    O primeiro nome da linguagem foi Mocha, sugerido pelo fundador da Netcape Marc Andreessen, porém acabou nem indo para o mercado. A linguagem foi lançada oficialmente em Setembro de 1995 com o nome de LiveScript na versão beta do Netscape Navigator 2.0. A partir de então a Netscape estava entrando com tudo no mundo dos browsers e a Microsoft não quis perder a carona e se deu início ao internet explorer.
31 |    Em dezembro, o nome da linguagem mudou para JavaScript, a partir de um acordo feito com a Sun com o objetivo de destruir a Microsoft. A Sun então registrou o JavaScript como uma marca de uso exclusivo da Netscape, impossibilitando a Microsoft de utilizar a linguagem. Ainda assim a Microsoft fez uma engenharia reversa da linguagem JavaScript e criou a linguaguem JScript.
32 |    A Netscape com medo de perder o controle, buscou padronizar a linguagem em entidades respeitadas, até que em 1997 junto a ECMA(European Computer Manufacturers Association) Internacional, conseguiu padronizar a linguagem nomeando-a ECMAScript como nome oficial, JavaScript é apenas o nome fantasia.
33 | 
34 | 
35 | ## Características
36 | 
37 |   - JavaScript é uma linguagem interpretada, não é preciso instalar nada na sua máquina, nem um tipo de
38 | compilador a não ser que voce queira interpretá-la.
39 |   - Utiliza de uma orientação a objetos baseada em protótipos, basicamente não usa classes para promover
40 | heranças, mas sim os próprios objetos. Simplesmente objetos herdam de objetos. *
41 |   - É uma linguagem que possui tipagem fraca e dinâmica, isto quer dizer que a gente tem uma liberdade
42 | muito grande, só que isso gera um pouco de insegurança já que a gente não tem garantia dos nossos tipos,
43 | com JavaScript é possível concatenar valores de tipos diferentes.
44 |   - A linguagem não apresenta suporte a programação multi-thread, mas nada impede que seus interpretadores
45 | implementem esta habilidade de fazer algum tipo de processamento em paralelo.
46 | 
47 | 
48 | ## Como funciona?
49 | 
50 |   Esta linguagem vem sendo bastante utilizada para o desenvolvimento de aplicações web, atualmente tanto no lado do cliente para promover os estilos nas páginas HTML com animações em CSS, quanto no lado do servidor
51 | para fazer a manipulação e validação dos dados utilizando NodeJS. A linguagem permite que a aplicação seja
52 | totalmente funcional e dinâmica, sendo possível também modelar e manipular até o banco de dados através da
53 | linguagem utilizando MongoDB.
54 |   Hoje esta presente nos Browsers, a até nas Tvs, como nas samsungs smart. Usa o V8 que é o motor de
55 | renderização da linguagem, que funciona como uma máquina virtual que compila o código em JavaScript para
56 | o formato nativo de máquina antes de executá-lo, tendo como propósito aumentar o desempenho da aplicação.
57 | 
58 | 
59 | ## Por convenção aconselha-se criar as variáveis seguindo as regras:
60 | 
61 |   - Devem começar por uma letra, $, ou _
62 |   - Após a primeira letra, podem conter números.
63 |   - Começam com letra minúscula e usam camelCase
64 |   - É case-sensitive
65 | 
66 | 
67 | **Introção ao JavaScript**
68 | 
69 | 1. [Funções 1](https://github.com/fernandobd42/Introducao_JS/blob/master/1_functions.js)
70 | 1. [Funções 1 em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/1_functions_ES6.js)
71 | 2. [Funções 2](https://github.com/fernandobd42/Introducao_JS/blob/master/2_functions.js)
72 | 2. [Funções 2  em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/2_functions_ES6.js)
73 | 3. [Array](https://github.com/fernandobd42/Introducao_JS/blob/master/3_arrays.js)
74 | 3. [Array em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/3_arrays_ES6.js)
75 | 4. [Expressões Regulares](https://github.com/fernandobd42/Introducao_JS/blob/master/4_Expressoes_regulares.js)
76 | 4. [Expressões Regulares em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/4_Expressoes_regulares_ES6.js)
77 | 5. [Date](https://github.com/fernandobd42/Introducao_JS/blob/master/5_Date.js)
78 | 5. [Date em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/5_Date_ES6.js)
79 | 6. [Operadores](https://github.com/fernandobd42/Introducao_JS/blob/master/6_Operadores.js)
80 | 6. [Operadores em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/6_Operadores_ES6.js)
81 | 7. [Declarações](https://github.com/fernandobd42/Introducao_JS/blob/master/7_Statements.js)
82 | 7. [Declarações em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/7_Statements_ES6.js)
83 | 8. [Herança 1](https://github.com/fernandobd42/Introducao_JS/blob/master/8_Heranca.js)
84 | 8. [Herança 1 em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/8_Heranca_ES6.js)
85 | 9. [Herança 2](https://github.com/fernandobd42/Introducao_JS/blob/master/9_Heranca.js)
86 | 9. [Herança 2 em ES6](https://github.com/fernandobd42/Introducao_JS/blob/master/9_Heranca_ES6.js)
87 | 


--------------------------------------------------------------------------------
/7_Statements_ES6.js:
--------------------------------------------------------------------------------
  1 | //Statement(Declaração) - (for, if, else, continue, while, switch, break, throw, try e catch)
  2 | 
  3 | //Exemplo 0 - Retornando um caractere por vez. FOR para ler cada caractere do texto
  4 | text = 'Introdução a JavaScript'
  5 | const exemplo0 = text => {
  6 |   for(let i = 0; i < text.length; i++ )
  7 |   console.log(text.charAt(i));
  8 | };
  9 | exemplo0(text); // Retornou um caractere da varviavel text por linha.
 10 | 
 11 | 
 12 | 
 13 | //Exemplo 1 - Substituindo determinado valor da string FOR para ler cada caractere do texto e IF para fazer a substituição.
 14 | text = 'Ola Mundo Louco'
 15 | const exemplo1 = text => {
 16 |   const array = [];
 17 |   for(let i = 0; i < text.length; i++ ) {
 18 |     if (text.charAt(i) === 'o') {
 19 |       array.push(0);
 20 |     } else {
 21 |       array.push(text.charAt(i));
 22 |     }
 23 |   }
 24 |   return array.join(',');
 25 | };
 26 | console.log(exemplo1(text)); // 'O,l,a, ,M,u,n,d,0, ,L,0,u,c,0'
 27 | 
 28 | 
 29 | 
 30 | //Exemplo 2 - Substituindo determinados valores da string. FOR para ler cada caractere do texto e IF para fazer a substituição.
 31 | text = 'Ola Mundo Sinistro'
 32 | const exemplo2 = text => {
 33 |   const array = [];
 34 |   for(let i = 0; i < text.length; i++ ) {
 35 |     if (text.charAt(i) === 'o') {
 36 |       array.push(0);
 37 |       continue;
 38 |     }
 39 |     if (text.charAt(i) === 'a') {
 40 |       array.push(4);
 41 |       continue;
 42 |     }
 43 |     if (text.charAt(i) === 'i') {
 44 |       array.push(1);
 45 |       continue;
 46 |     }
 47 |     if (text.charAt(i) === 't') {
 48 |       array.push(7);
 49 |       continue;
 50 |     }
 51 |       array.push(text.charAt(i));
 52 |     }
 53 |   return array.join('-');
 54 | };
 55 | console.log(exemplo2(text));// 'O-l-4- -M-u-n-d-0- -S-1-n-1-s-7-r-0'
 56 | 
 57 | 
 58 | 
 59 | //Exemplo 3 - Substituindo determinados valores da string. FOR para ler cada caractere do texto e
 60 | // SWITCH no lugar do IF para aperfeiçoar a substituição.
 61 | text = 'Ola Mundo Sinistro'
 62 | const exemplo3 = text => {
 63 |   const array = [];
 64 |   for(let i = 0; i < text.length; i++ ) {
 65 |     switch (text.charAt(i)) {
 66 |       case 'o':
 67 |         array.push(0);
 68 |         break;
 69 |       case 'a':
 70 |         array.push(4);
 71 |         break;
 72 |       case 'i':
 73 |         array.push(1);
 74 |         break;
 75 |       case 't':
 76 |         array.push(7);
 77 |         break;
 78 |       default:
 79 |         array.push(text.charAt(i));
 80 |     }
 81 |   }
 82 |   return array.join(',');
 83 | };
 84 | console.log(exemplo3(text)); // 'O,l,4, ,M,u,n,d,0, ,S,1,n,1,s,7,r,0'
 85 | 
 86 | 
 87 | 
 88 | //Exemplo 4 - Substituindo determinados valores da string. WHILE no lugar do FOR para ler cada caractere do texto e
 89 | // SWITCH no lugar do IF para aperfeiçoar a substituição.
 90 | text = 'Ola Mundo Sinistro'
 91 | const exemplo4 = text => {
 92 |   const array = [];
 93 |   let i = 0;
 94 |   while( i < text.length) {
 95 |     switch (text.charAt(i)) {
 96 |       case 'o':
 97 |         array.push(0);
 98 |         break;
 99 |       case 'a':
100 |         array.push(4);
101 |         break;
102 |       case 'i':
103 |         array.push(1);
104 |         break;
105 |       case 't':
106 |         array.push(7);
107 |         break;
108 |       default:
109 |         array.push(text.charAt(i));
110 |     }
111 |     i++;
112 |   }
113 |   return array.join('/');
114 | };
115 | console.log(exemplo4(text)); // 'O/l/4/ /M/u/n/d/0/ /S/1/n/1/s/7/r/0'
116 | 
117 | 
118 | 
119 | //Exemplo 5 - Tratamento de erros utilizando throw para lançar a string.
120 | text = 'Ola Mundo Sinistro'
121 | const exemplo5 = text => {
122 |   // 0 , Nan, "", false, null e undefined. Caso seja algum destes, o (!text) será verdadeiro
123 |   if(!text) throw " Invalid text.";
124 |   const array = [];
125 |   let i = 0;
126 |   while( i < text.length) {
127 |     switch (text.charAt(i)) {
128 |       case 'o':
129 |         array.push(0);
130 |         break;
131 |       case 'a':
132 |         array.push(4);
133 |         break;
134 |       case 'i':
135 |         array.push(1);
136 |         break;
137 |       case 't':
138 |         array.push(7);
139 |         break;
140 |       default:
141 |         array.push(text.charAt(i));
142 |     }
143 |     i++;
144 |   }
145 |   return array.join('');
146 | };
147 | try {
148 |   console.log(exemplo5());
149 | } catch(e) {
150 |   console.log(`Error:${e}`); //Error: Invalid text
151 | }
152 | console.log(exemplo5(text)); // 'Ol4 Mund0 S1n1s7r0'
153 | 
154 | 
155 | 
156 | 
157 | //Exemplo 6 - Tratamento de erros utilizando throw. Utiliza (!text) lançando a Função Construtora(new) para chamar
158 | //variável VarError que passa uma função.
159 | text = 'Ola Mundo Sinistro'
160 | 
161 | var VarError = function(message) {
162 |   this.message = message;
163 |   this.nome = "Função armazenada na viriável VarError";
164 | };
165 | 
166 | const exemplo6 = text => {
167 |   // 0 , Nan, "", false, null e undefined. Caso seja algum destes, o (!text) será verdadeiro
168 |   if(!text) throw new VarError(" Invalid text.");
169 |   const array = [];
170 |   let i = 0;
171 |   while( i < text.length) {
172 |     switch (text.charAt(i)) {
173 |       case 'o':
174 |         array.push(0);
175 |         break;
176 |       case 'a':
177 |         array.push(4);
178 |         break;
179 |       case 'i':
180 |         array.push(1);
181 |         break;
182 |       case 't':
183 |         array.push(7);
184 |         break;
185 |       default:
186 |         array.push(text.charAt(i));
187 |     }
188 |     i++;
189 |   }
190 |   return array.join('+');
191 | };
192 | try {
193 |   console.log(exemplo6());
194 | } catch(e) {
195 |   console.log(`Error:${e.message} ${e.nome}`); // Error Invalid text. Função armazenada na viriável VarError
196 | }
197 | console.log(exemplo6(text)); // 'O+l+4+ +M+u+n+d+0+ +S+1+n+1+s+7+r+0'
198 | 
199 | 
200 | 
201 | //Exemplo 7 - Tratamento de erros utilizando throw.
202 | //Verificando se o text é falso, e retornando mensagem. Utiliza (!text) e typeof lançando a Função Construtora(new)
203 | //para chamar variável VarError que passa uma função.
204 | text = 'Ola Mundo Sinistro'
205 | 
206 | var VarError = function(message) {
207 |   this.message = message;
208 |   this.nome = "Função armazenada na viriável VarError";
209 | };
210 | 
211 | const exemplo7 = text => {
212 |   // 0 , Nan, "", false, null e undefined. Caso seja algum destes, o (!text) será verdadeiro
213 |   if(!text) throw new VarError("Invalid text.");
214 |   if(typeof text !== "string") throw new VarError("Invalid type.");
215 |   const array = [];
216 |   let i = 0;
217 |   while( i < text.length) {
218 |     switch (text.charAt(i)) {
219 |       case 'o':
220 |         array.push(0);
221 |         break;
222 |       case 'a':
223 |         array.push(4);
224 |         break;
225 |       case 'i':
226 |         array.push(1);
227 |         break;
228 |       case 't':
229 |         array.push(7);
230 |         break;
231 |       default:
232 |         array.push(text.charAt(i));
233 |     }
234 |     i++;
235 |   }
236 |   return array.join('=');
237 | };
238 | try {
239 |   console.log(exemplo7());
240 | } catch(e) {
241 |   console.log(`Error: ${e.message} ${e.nome}`); // Error Invalid text. Função armazenada na viriável VarError
242 | }
243 | try {
244 |   console.log(exemplo7(10));
245 | } catch(e) {
246 |   console.log(`Error: ${e.message} ${e.nome}`); // Error: Invalid type. Função armazenada na viriável VarError
247 | }
248 | console.log(exemplo7(text)); // 'O=l=4= =M=u=n=d=0= =S=1=n=1=s=7=r=0'
249 | 


--------------------------------------------------------------------------------
/7_Statements.js:
--------------------------------------------------------------------------------
  1 | //Statement(Declaração) - (for, if, else, continue, while, switch, break, throw, try e catch)
  2 | 
  3 | //Exemplo 0 - Retornando um caractere por vez. FOR para ler cada caractere do texto
  4 | text = 'Introdução a JavaScript'
  5 | var exemplo0 = function(text) {
  6 |   for(var i = 0; i < text.length; i++ )
  7 |   console.log(text.charAt(i));
  8 | };
  9 | exemplo0(text); // Retornou um caractere da varviavel text por linha.
 10 | 
 11 | 
 12 | 
 13 | //Exemplo 1 - Substituindo determinado valor da string FOR para ler cada caractere do texto e IF para fazer a substituição.
 14 | text = 'Ola Mundo Louco'
 15 | var exemplo1 = function(text) {
 16 |   var array = [];
 17 |   for(var i = 0; i < text.length; i++ ) {
 18 |     if (text.charAt(i) === 'o') {
 19 |       array.push(0);
 20 |     } else {
 21 |       array.push(text.charAt(i));
 22 |     }
 23 |   }
 24 |   return array.join(',');
 25 | };
 26 | console.log(exemplo1(text)); // 'O,l,a, ,M,u,n,d,0, ,L,0,u,c,0'
 27 | 
 28 | 
 29 | 
 30 | //Exemplo 2 - Substituindo determinados valores da string. FOR para ler cada caractere do texto e IF para fazer a substituição.
 31 | text = 'Ola Mundo Sinistro'
 32 | var exemplo2 = function(text) {
 33 |   var array = [];
 34 |   for(var i = 0; i < text.length; i++ ) {
 35 |     if (text.charAt(i) === 'o') {
 36 |       array.push(0);
 37 |       continue;
 38 |     }
 39 |     if (text.charAt(i) === 'a') {
 40 |       array.push(4);
 41 |       continue;
 42 |     }
 43 |     if (text.charAt(i) === 'i') {
 44 |       array.push(1);
 45 |       continue;
 46 |     }
 47 |     if (text.charAt(i) === 't') {
 48 |       array.push(7);
 49 |       continue;
 50 |     }
 51 |       array.push(text.charAt(i));
 52 |     }
 53 |   return array.join('-');
 54 | };
 55 | console.log(exemplo2(text));// 'O-l-4- -M-u-n-d-0- -S-1-n-1-s-7-r-0'
 56 | 
 57 | 
 58 | 
 59 | //Exemplo 3 - Substituindo determinados valores da string. FOR para ler cada caractere do texto e
 60 | // SWITCH no lugar do IF para aperfeiçoar a substituição.
 61 | text = 'Ola Mundo Sinistro'
 62 | var exemplo3 = function(text) {
 63 |   var array = [];
 64 |   for(var i = 0; i < text.length; i++ ) {
 65 |     switch (text.charAt(i)) {
 66 |       case 'o':
 67 |         array.push(0);
 68 |         break;
 69 |       case 'a':
 70 |         array.push(4);
 71 |         break;
 72 |       case 'i':
 73 |         array.push(1);
 74 |         break;
 75 |       case 't':
 76 |         array.push(7);
 77 |         break;
 78 |       default:
 79 |         array.push(text.charAt(i));
 80 |     }
 81 |   }
 82 |   return array.join(',');
 83 | };
 84 | console.log(exemplo3(text)); // 'O,l,4, ,M,u,n,d,0, ,S,1,n,1,s,7,r,0'
 85 | 
 86 | 
 87 | 
 88 | //Exemplo 4 - Substituindo determinados valores da string. WHILE no lugar do FOR para ler cada caractere do texto e
 89 | // SWITCH no lugar do IF para aperfeiçoar a substituição.
 90 | text = 'Ola Mundo Sinistro'
 91 | var exemplo4 = function(text) {
 92 |   var array = [];
 93 |   var i = 0;
 94 |   while( i < text.length) {
 95 |     switch (text.charAt(i)) {
 96 |       case 'o':
 97 |         array.push(0);
 98 |         break;
 99 |       case 'a':
100 |         array.push(4);
101 |         break;
102 |       case 'i':
103 |         array.push(1);
104 |         break;
105 |       case 't':
106 |         array.push(7);
107 |         break;
108 |       default:
109 |         array.push(text.charAt(i));
110 |     }
111 |     i++;
112 |   }
113 |   return array.join('/');
114 | };
115 | console.log(exemplo4(text)); // 'O/l/4/ /M/u/n/d/0/ /S/1/n/1/s/7/r/0'
116 | 
117 | 
118 | 
119 | //Exemplo 5 - Tratamento de erros utilizando throw para lançar a string.
120 | text = 'Ola Mundo Sinistro'
121 | var exemplo5 = function(text) {
122 |   // 0 , Nan, "", false, null e undefined. Caso seja algum destes, o (!text) será verdadeiro
123 |   if(!text) throw " Invalid text.";
124 |   var array = [];
125 |   var i = 0;
126 |   while( i < text.length) {
127 |     switch (text.charAt(i)) {
128 |       case 'o':
129 |         array.push(0);
130 |         break;
131 |       case 'a':
132 |         array.push(4);
133 |         break;
134 |       case 'i':
135 |         array.push(1);
136 |         break;
137 |       case 't':
138 |         array.push(7);
139 |         break;
140 |       default:
141 |         array.push(text.charAt(i));
142 |     }
143 |     i++;
144 |   }
145 |   return array.join('');
146 | };
147 | try {
148 |   console.log(exemplo5());
149 | } catch(e) {
150 |   console.log("Error:" + e); //Error: Invalid text
151 | }
152 | console.log(exemplo5(text)); // 'Ol4 Mund0 S1n1s7r0'
153 | 
154 | 
155 | 
156 | 
157 | //Exemplo 6 - Tratamento de erros utilizando throw. Utiliza (!text) lançando a Função Construtora(new) para chamar
158 | //variável VarError que passa uma função.
159 | text = 'Ola Mundo Sinistro'
160 | 
161 | var VarError = function(message) {
162 |   this.message = message;
163 |   this.nome = "Função armazenada na viriável VarError";
164 | };
165 | 
166 | var exemplo6 = function(text) {
167 |   // 0 , Nan, "", false, null e undefined. Caso seja algum destes, o (!text) será verdadeiro
168 |   if(!text) throw new VarError(" Invalid text.");
169 |   var array = [];
170 |   var i = 0;
171 |   while( i < text.length) {
172 |     switch (text.charAt(i)) {
173 |       case 'o':
174 |         array.push(0);
175 |         break;
176 |       case 'a':
177 |         array.push(4);
178 |         break;
179 |       case 'i':
180 |         array.push(1);
181 |         break;
182 |       case 't':
183 |         array.push(7);
184 |         break;
185 |       default:
186 |         array.push(text.charAt(i));
187 |     }
188 |     i++;
189 |   }
190 |   return array.join('+');
191 | };
192 | try {
193 |   console.log(exemplo6());
194 | } catch(e) {
195 |   console.log("Error:" + e.message + " " + e.nome); // Error Invalid text. Função armazenada na viriável VarError
196 | }
197 | console.log(exemplo6(text)); // 'O+l+4+ +M+u+n+d+0+ +S+1+n+1+s+7+r+0'
198 | 
199 | 
200 | 
201 | //Exemplo 7 - Tratamento de erros utilizando throw.
202 | //Verificando se o text é falso, e retornando mensagem. Utiliza (!text) e typeof lançando a Função Construtora(new)
203 | //para chamar variável VarError que passa uma função.
204 | text = 'Ola Mundo Sinistro'
205 | 
206 | var VarError = function(message) {
207 |   this.message = message;
208 |   this.nome = "Função armazenada na viriável VarError";
209 | };
210 | 
211 | var exemplo7 = function(text) {
212 |   // 0 , Nan, "", false, null e undefined. Caso seja algum destes, o (!text) será verdadeiro
213 |   if(!text) throw new VarError("Invalid text.");
214 |   if(typeof text !== "string") throw new VarError("Invalid type.");
215 |   var array = [];
216 |   var i = 0;
217 |   while( i < text.length) {
218 |     switch (text.charAt(i)) {
219 |       case 'o':
220 |         array.push(0);
221 |         break;
222 |       case 'a':
223 |         array.push(4);
224 |         break;
225 |       case 'i':
226 |         array.push(1);
227 |         break;
228 |       case 't':
229 |         array.push(7);
230 |         break;
231 |       default:
232 |         array.push(text.charAt(i));
233 |     }
234 |     i++;
235 |   }
236 |   return array.join('=');
237 | };
238 | try {
239 |   console.log(exemplo7());
240 | } catch(e) {
241 |   console.log("Error: " + e.message + " " + e.nome); // Error Invalid text. Função armazenada na viriável VarError
242 | }
243 | try {
244 |   console.log(exemplo7(10));
245 | } catch(e) {
246 |   console.log("Error: " + e.message + " " + e.nome); // Error: Invalid type. Função armazenada na viriável VarError
247 | }
248 | console.log(exemplo7(text)); // 'O=l=4= =M=u=n=d=0= =S=1=n=1=s=7=r=0'
249 | 


--------------------------------------------------------------------------------
/3_arrays_ES6.js:
--------------------------------------------------------------------------------
  1 | //Iniciando array vazio e atribuindo valores depois.
  2 | var carros = []
  3 | 
  4 | console.log(carros[0] = 'KA'), // KA
  5 | console.log(carros[1] = 'Palio'), // Palio
  6 | console.log(carros[2] = 'Punto'), // Punto
  7 | console.log(carros) // [ 'KA', 'Palio', 'Punto' ]
  8 | 
  9 | 
 10 | 
 11 | //Iniciando array com new e atribuindo valores depois.
 12 | var carros = new Array()
 13 | 
 14 | console.log(carros[0] = 'Fusca'), // Fusca
 15 | console.log(carros[1] = 'Brasilia'), // Brasilia
 16 | console.log(carros[2] = 'Chevete'), // Chevete
 17 | console.log(carros) // [ 'Fusca', 'Brasilia', 'Chevete' ]
 18 | 
 19 | 
 20 | 
 21 | //Iniciando array in line.
 22 | var carros = ['Ka', 'Palio', 'Punto'];
 23 | console.log(carros) // [ 'KA', 'Palio', 'Punto' ]
 24 | 
 25 | 
 26 | 
 27 | //Iniciando array in line com new.
 28 | var carros = new Array('Fusca', 'Brasilia', 'Chevete');
 29 | console.log(carros) //[ 'Fusca', 'Brasilia', 'Chevete' ]
 30 | 
 31 | 
 32 | 
 33 | //Determinando tamanho INICIAL do array. (LEMBRANDO QUE EM JS O ARRAY NAO TEM TAMANHO FIXO)
 34 | var carros = new Array(10)
 35 | console.log(carros) // [ , , , , , , , , ,  ]
 36 | 
 37 | 
 38 | 
 39 | //Exemplo valueOf no array. Retorna o Array.
 40 | var carros = ['HRV', 'Jetta', 'Hillux'];
 41 | console.log(carros.valueOf()); // [ 'HRV', 'Jetta', 'Hillux' ]
 42 | 
 43 | 
 44 | 
 45 | //Exemplo toString no array. Retorna a String.
 46 | var carros = ['HRV', 'Jetta', 'Hillux'];
 47 | console.log(carros.toString()); // 'HRV,Jetta,Hillux'
 48 | 
 49 | 
 50 | 
 51 | //Exemplo length no array. Retorna a quantidade de objetos existentes no array.
 52 | var carros = ['HRV', 'Jetta', 'Hillux'];
 53 | console.log(carros.length) // 3
 54 | 
 55 | 
 56 | 
 57 | //Exemplo push no array. Insere um elemento no final do array.
 58 | console.log(carros.push('Gol')) // 4
 59 | 
 60 | 
 61 | 
 62 | //Exemplo unshift no array. Insere um elemento no início do array.
 63 | console.log(carros.unshift('Lamborghine')) // 5
 64 | 
 65 | 
 66 | 
 67 | //Exemplo pop no array. Remove o último elemento do array.
 68 | console.log(carros.pop()) // 'Gol'
 69 | 
 70 | 
 71 | 
 72 | //Exemplo shit no array. Remove o primeiro elemento do array.
 73 | console.log(carros.shift()) // 'Lamborghine'
 74 | 
 75 | 
 76 | 
 77 | //Exemplo indexOf no array. Retorna o indice de um objeto do array.
 78 | console.log(carros.indexOf('Jetta')) //1
 79 | 
 80 | 
 81 | 
 82 | //Exemplo de splice no array. Remove objetos do array utilizando o índice,
 83 | //sendo possível remover mais de um elemento de uma vez
 84 | console.log(carros.splice(1, 2)) //[ 'Jetta', 'Hillux' ]
 85 | 
 86 | 
 87 | 
 88 | //Exemplo de splice no array. Adiciona um ou mais elementos no array.
 89 | console.log(carros.splice(1, 0, 'jetta', 'hillux'))
 90 | //1 -> busca elemento com índice 1, 0 -> remove 0 objetos do array, 'jetta', 'hillux' -> elementos dicionados.
 91 | 
 92 | 
 93 | 
 94 | //Exemplo de iniciar array vazio e adicionar um elemento por vez com dois valores em cada elemento.
 95 | var carros = [];
 96 | 
 97 | carros[0] = {marca:'ford', modelo:'ka'};
 98 | carros[1] = {marca:'chevrolet', modelo:'corsa'}
 99 | carros[2] = {marca: 'fiat', modelo: 'palio'}
100 | 
101 | 
102 | 
103 | //Exemplo de iniciar array in line, adicionando três elementos de uma vez com dois valores em cara elemento.
104 | var carros = [{marca: 'ford', modelo: 'ka'}, {marca:'chevrolet', modelo:'corsa'}, {marca:'fiat', modelo:'Palio'}];
105 | 
106 | 
107 | 
108 | //Exemplo de forEach no array. Busca todos os elementos do array. Evolução do for, mais simples.
109 | carros.forEach(car => {
110 |   console.log(car);
111 | });
112 | // { marca: 'ford', modelo: 'ka' }
113 | // { marca: 'chevrolet', modelo: 'corsa' }
114 | // { marca: 'fiat', modelo: 'Palio' }
115 | 
116 | 
117 | 
118 | //Exemplo de filter no array. Busca determinado elemento com algum(a) filtro(característica) específico.
119 | carros.filter(car => car.marca === 'ford');
120 | // [ { marca: 'ford', modelo: 'ka' } ]
121 | 
122 | 
123 | 
124 | //Exemplo de filter no array. Atribui função à variável carrosFord.
125 | const carrosFord = carros.filter(car => car.marca === 'ford');
126 | carrosFord // [ {marca: 'ford', modelo: 'ka' } ]
127 | 
128 | 
129 | 
130 | //Exemplo de every no array. Verifica se todos os elementos são da marca ford, funciona como um boolean.
131 | carros.every(car => car.marca === 'ford'); //false
132 | 
133 | 
134 | 
135 | //Exemplo de some no array. Verifica se algum dos elementos é da marca ford, funciona como um boolean.
136 | const s = carros.some(car => car.marca === 'ford');
137 | s //true
138 | 
139 | 
140 | 
141 | //Exemplo de map no array. Mapeia os elementos por características.
142 | //Mapeia a marca de todos os elementos do array
143 | carros.map(car => car.marca); // ['ford', 'chevrolet', 'fiat']
144 | 
145 | //Mapeia quantos caracteres tem a marca de cada elemento do array
146 | const mapLength = carros.map(car => car.marca.length);
147 | mapLength // [4 ,9, 4]
148 | 
149 | 
150 | 
151 | //Exemplo diferença de forEach para reduce no array.
152 | var carros = [];
153 | 
154 | carros[0] = {marca:'ford', modelo:'ka', preco: 25000};
155 | carros[1] = {marca:'chevrolet', modelo:'corsa', preco: 35000}
156 | carros[2] = {marca: 'fiat', modelo: 'palio', preco: 38000}
157 | 
158 | //ForEach
159 | let total = 0;
160 | carros.forEach(car => {
161 |   total += car.preco;
162 | });
163 | total // 98000
164 | 
165 | 
166 | //Reduce
167 | carros.reduce((prev, cur) => prev + cur.preco, 0); //98000 || prev -> elemento anterior + cur -> elemento atual, 0 -> começa do elemento 0
168 | 
169 | 
170 | 
171 | //Criando 2 arrays, um de carros e um de motos
172 | var carros = ['ka', 'corsa', 'palio']
173 | const motos = ['honda', 'yamaha'];
174 | 
175 | 
176 | 
177 | //Exemplo de concat no array. Criando um array de veiculos, contendo os arrays carros e motos
178 | const veiculos = carros.concat(motos);
179 | veiculos // [ 'ka', 'corsa', 'palio', 'honda', 'yamaha' ]
180 | veiculos.length // 5
181 | 
182 | 
183 | 
184 | //Exemplo de splice no array. Busca determinados elemetos pré-definidos
185 | veiculos.slice(0,2) // [ 'ka', 'corsa' ]
186 | veiculos.slice(0,4) // [ 'ka', 'corsa', 'palio', 'honda' ]
187 | veiculos.slice(3,5) // [ 'honda', 'yamaha' ]
188 | 
189 | 
190 | 
191 | //Exemplo reverse no array. Reverte a ordem da listagem de elementos.
192 | veiculos.reverse() // [ 'yamaha', 'honda', 'palio', 'corsa', 'ka' ]
193 | veiculos // [ 'yamaha', 'honda', 'palio', 'corsa', 'ka' ]
194 | veiculos.reverse() // [ 'ka', 'corsa', 'palio', 'honda', 'yamaha' ]
195 | veiculos // [ 'ka', 'corsa', 'palio', 'honda', 'yamaha' ]
196 | 
197 | 
198 | 
199 | //Exemplo de sort no array. Ordena por ordem alfabetica, preco, ou qualquer outra caracteristica do elemento.
200 | var carros = [];
201 | 
202 | carros[0] = {marca: 'fiat', modelo: 'palio', preco: 38000}
203 | carros[1] = {marca:'ford', modelo:'ka', preco: 25000};
204 | carros[2] = {marca:'chevrolet', modelo:'corsa', preco: 35000}
205 | 
206 | //Ordenar por preço, do menor para o maior.
207 | carros.sort((a, b) => a.preco - b.preco);
208 | // [ { marca: 'ford', modelo: 'ka', preco: 25000 },
209 | //   { marca: 'chevrolet', modelo: 'corsa', preco: 35000 },
210 | //   { marca: 'fiat', modelo: 'palio', preco: 38000 } ]
211 | 
212 | //Ordenar por preço, do maior para o menor.
213 | carros.sort((a, b) => b.preco - a.preco);
214 | // [ { marca: 'fiat', modelo: 'palio', preco: 38000 },
215 | //   { marca: 'chevrolet', modelo: 'corsa', preco: 35000 },
216 | //   { marca: 'ford', modelo: 'ka', preco: 25000 } ]
217 | 
218 | 
219 | 
220 | //Exemplo join no array. Junta elementos com um separados pré-determinado.
221 | var carros = ['ka', 'corsa', 'palio', 'gol'];
222 | carros.join('/') // 'ka/corsa/palio/gol' || / -> separador dos elementos na String
223 | carros.join('-') // 'ka-corsa-palio-gol' || - -> separador dos elementos na String
224 | 


--------------------------------------------------------------------------------
/9_Heranca_ES6.js:
--------------------------------------------------------------------------------
  1 | //Exemplo 1 - Criando objetos diretamente.
  2 | const jose = {
  3 |     nome: 'José',
  4 |     idade: 22,
  5 |     sexo: 'masculino'
  6 | };
  7 | 
  8 | const maria = {
  9 |     nome: 'Maria',
 10 |     idade: 20,
 11 |     sexo: 'feminino'
 12 | };
 13 | 
 14 | console.log(jose); // { nome: 'José', idade: 22, sexo: 'masculino' }
 15 | console.log(maria); // { nome: 'Maria', idade: 20, sexo: 'feminino' }
 16 | 
 17 | 
 18 | 
 19 | //Exemplo 2 - Criando objetos com Função Fábrica. (Mais recomendada que a forma anterior).
 20 | const criarPessoa = (nome, idade, sexo) => ({
 21 |   nome,
 22 |   idade,
 23 |   sexo
 24 | });
 25 | 
 26 | const joao = criarPessoa('João', 30, 'masculino');
 27 | const lucia = criarPessoa('Lúcia', 35, 'feminino');
 28 | console.log(joao); // { nome: 'João', idade: 30, sexo: 'masculino' }
 29 | console.log(lucia); // { nome: 'Lúcia', idade: 35, sexo: 'feminino' }
 30 | 
 31 | 
 32 | 
 33 | //Exemplo 3 - Criando objetos com Função Construtora, usando o operador new.
 34 | var Pessoa = function(nome, idade, sexo) {
 35 |   this.nome = nome;
 36 |   this.idade = idade;
 37 |   this.sexo = sexo;
 38 | };
 39 | 
 40 | const roger = new Pessoa('Roger', 12, 'masculino');
 41 | const julia = new Pessoa('Julia', 10, 'feminino');
 42 | console.log(roger); // { nome: 'Roger', idade: 12, sexo: 'masculino' }
 43 | console.log(julia); // { nome: 'Julia', idade: 10, sexo: 'feminino' }
 44 | 
 45 | 
 46 | 
 47 | //Exemplo 4 - Criando objeto com Função Construtora, utilizando call.
 48 | var Pessoa = function(nome, idade, sexo) {
 49 |   this.nome = nome;
 50 |   this.idade = idade;
 51 |   this.sexo = sexo;
 52 | };
 53 | 
 54 | const isabella = {};
 55 | Pessoa.call(isabella, 'Isabella', 18, 'feminino');
 56 | console.log(isabella); //{ nome: 'Isabella', idade: 18, sexo: 'feminino' }
 57 | 
 58 | 
 59 | 
 60 | //Exemplo 4 - Criando objeto com Função Construtora, utilizando apply(adicionar []).
 61 | var Pessoa = function(nome, idade, sexo) {
 62 |   this.nome = nome;
 63 |   this.idade = idade;
 64 |   this.sexo = sexo;
 65 | };
 66 | 
 67 | const fernando = {};
 68 | Pessoa.apply(fernando, ['Fernando', 21, 'masculino']);
 69 | console.log(fernando); // { nome: 'Fernando', idade: 21, sexo: 'masculino' }
 70 | 
 71 | 
 72 | 
 73 | //O objeto que tem protótipo é completamente diferente da propriedade prototype. Diferença entre [[Prototype]] e prototype:
 74 | //[Prototype]] -> O conceito de protótipo é abstrato, é o protótipo que pode ser um objeto ou null.
 75 | //prototype -> Basicamente é uma propriedade de prototype que só as funções tem, capaz de inserir manipular e/ou
 76 | //transformar os objetos, inserindo, alterando ou excluindo propriedades em todos os objetos de uma só vez.
 77 | //É considerado orientação a objetos baseada em protótipo porque os objetos reusam(herdam) propriedades e métodos de
 78 | //outros objetos.
 79 | //Exemplo 5 - Definindo prototype e inserindo em todos os objetos. Basicamente os objetos não tem a propriedade
 80 | //sexo, quem a tem é o protótipo.
 81 | var Pessoa = function(nome, idade) {
 82 |   this.nome = nome;
 83 |   this.idade = idade;
 84 | };
 85 | 
 86 | Pessoa.prototype.sexo = 'masculino'; // >>atribuindo propriedade sexo a Pessoa.<<
 87 | 
 88 | var gabriel = new Pessoa('Gabriel', 23);
 89 | console.log(gabriel); // { nome: 'Gabriel', idade: 23 }
 90 | console.log(gabriel.sexo); // masculino
 91 | 
 92 | var rafael = {};
 93 | rafael.__proto__ = Pessoa.prototype; // >>Atribuindo o protótipo a rafael.<<
 94 | Pessoa.apply(rafael, ["Rafael", 18]);
 95 | console.log(rafael); // { nome: 'Rafael', idade: 18}
 96 | console.log(rafael.sexo); // masculino
 97 | 
 98 | Pessoa.prototype.sexo = 'feminino'; // >>Alterando propriedade sexo do prototype para 'feminino'<<
 99 | console.log(gabriel.sexo); // feminino
100 | console.log(rafael.sexo); // feminino
101 | 
102 | 
103 | 
104 | //Em JavaScript quando você faz um new array, new object, new date, dentre outros. Todos eles são criados por meio de
105 | //uma Função Construtora. Caso você esteja usando Função Construtora e queira usar herança, para manipular e/ou transformar
106 | //os objetos, você pode utilizar o prototype para definir propriedades e inserir, alterar ou excluir em todos os objetos
107 | //de uma vez.
108 | //Exemplo 6 - Inserindo prototype direto na função new.
109 | var _new = f => {
110 |   const obj = {};
111 |   obj.__proto__ = f.prototype; // >>O protótipo do objeto recebe a Função Construtora(f.prototype);<<
112 |   f.apply(obj, ['Rafael', 18]); // >>Invoco a Função Cosnstrutora, passando o seu contexto, no caso object e um array com as propriedades do objeto <<
113 |   return obj;
114 | }; // >> Função generica <<
115 | 
116 | var Pessoa = function(nome, idade) {
117 |   this.nome = nome;
118 |   this.idade = idade;
119 | }; // >> Função direta <<
120 | 
121 | Pessoa.prototype.sexo = 'masculino';
122 | 
123 | var gabriel = new Pessoa('Gabriel', 23);
124 | console.log(gabriel); // { nome: 'Gabriel', idade: 23 }
125 | console.log(gabriel.sexo); // masculino
126 | 
127 | var rafael = _new(Pessoa, "Rafael", 18);
128 | 
129 | console.log(rafael);  // { nome: 'Rafael', idade: 18 }
130 | console.log(rafael.sexo); // masculino
131 | 
132 | 
133 | 
134 | //Exemplo 7 - Inserindo prototype direto na função new, utilizando um array, de um modo dinâmico.
135 | var _new = function(f) {
136 |   const obj = {};
137 |   obj.__proto__ = f.prototype; // >>O protótipo do objeto recebe a Função Construtora(f.prototype);<<
138 |   f.apply(obj,Array.prototype.slice.call(arguments, 1)); // >>Invoco a Função Cosnstrutora, passando o seu contexto, no caso object e um array com as propriedades do objeto <<
139 |   return obj;
140 | }; // >> Função generica <<
141 | 
142 | var Pessoa = function(nome, idade) {
143 |   this.nome = nome;
144 |   this.idade = idade;
145 | }; // >> Função direta <<
146 | 
147 | Pessoa.prototype.sexo = 'masculino';
148 | 
149 | var gabriel = new Pessoa('Gabriel', 23);
150 | console.log(gabriel); // { nome: 'Gabriel', idade: 23 }
151 | console.log(gabriel.sexo); // masculino
152 | 
153 | var rafael = _new(Pessoa, "Rafael", 18);
154 | 
155 | console.log(rafael);  // { nome: 'Rafael', idade: 18 }
156 | console.log(rafael.sexo); // masculino
157 | 
158 | 
159 | 
160 | //Exemplo 8 - Inserindo prototype direto na função new, utilizando um array, de um modo dinâmico. Exemplo 2.
161 | var _new = function(f) {
162 |   const obj = {};
163 |   obj.__proto__ = f.prototype; // >>O protótipo do objeto recebe a Função Construtora(f.prototype);<<
164 |   f.apply(obj,Array.prototype.slice.call(arguments, 1)); // >>Invoca a Função Cosnstrutora, passando o seu contexto, no caso object e um array com as propriedades do objeto <<
165 |   return obj;
166 | }; // >> Função generica <<
167 | 
168 | var Pessoa = function(nome, idade) {
169 |   this.nome = nome;
170 |   this.idade = idade;
171 | }; // >> Função direta <<
172 | 
173 | Pessoa.prototype.sexo = 'masculino';
174 | 
175 | var gabriel = _new (Pessoa, 'Gabriel', 23);
176 | console.log(gabriel); // { nome: 'Gabriel', idade: 23 }
177 | console.log(gabriel.sexo); // masculino
178 | 
179 | var rafael = _new(Pessoa, "Rafael", 18);
180 | 
181 | console.log(rafael);  // { nome: 'Rafael', idade: 18 }
182 | console.log(rafael.sexo); // masculino
183 | 
184 | 
185 | 
186 | //Pseudo código do new
187 | var _new = function(f) {
188 |   const res = {};
189 | if(f.prototype !== null) {
190 |   res.__proto__ = f.prototype;
191 | }
192 | 
193 |  const ret = f.aplly(res, Array.prototype.slice.call(arguments, 1));
194 |  if((typeof ret === 'object' || typeof ret === 'function') && ret !== null) {
195 |   return ret;
196 |   }
197 |   return res;
198 | }
199 | //Esclarecendo, [[prototype]] é uma propriedade que existe em todos os objetos do JavaScript que pode ser um objeto ou null.
200 | //Já prototype é uma propriedade exclusiva de funções, é utilizado para manipular e/ou transformar os objetos,
201 | //você pode utilizar o prototype para definir propriedades e inserir, alterar ou excluir em todos os objetos de uma vez.
202 | 
203 | //Retrospectiva: Todo mundo é objeto, porém JavaScript 'não possui classes'. Todo objeto possui um [[prototype]].
204 | 


--------------------------------------------------------------------------------
/3_arrays.js:
--------------------------------------------------------------------------------
  1 | //Iniciando array vazio e atribuindo valores depois.
  2 | var carros = []
  3 | 
  4 | console.log(carros[0] = 'KA'), // KA
  5 | console.log(carros[1] = 'Palio'), // Palio
  6 | console.log(carros[2] = 'Punto'), // Punto
  7 | console.log(carros) // [ 'KA', 'Palio', 'Punto' ]
  8 | 
  9 | 
 10 | 
 11 | //Iniciando array com new e atribuindo valores depois.
 12 | var carros = new Array()
 13 | 
 14 | console.log(carros[0] = 'Fusca'), // Fusca
 15 | console.log(carros[1] = 'Brasilia'), // Brasilia
 16 | console.log(carros[2] = 'Chevete'), // Chevete
 17 | console.log(carros) // [ 'Fusca', 'Brasilia', 'Chevete' ]
 18 | 
 19 | 
 20 | 
 21 | //Iniciando array in line.
 22 | var carros = ['Ka', 'Palio', 'Punto'];
 23 | console.log(carros) // [ 'KA', 'Palio', 'Punto' ]
 24 | 
 25 | 
 26 | 
 27 | //Iniciando array in line com new.
 28 | var carros = new Array('Fusca', 'Brasilia', 'Chevete');
 29 | console.log(carros) //[ 'Fusca', 'Brasilia', 'Chevete' ]
 30 | 
 31 | 
 32 | 
 33 | //Determinando tamanho INICIAL do array. (LEMBRANDO QUE EM JS O ARRAY NAO TEM TAMANHO FIXO)
 34 | var carros = new Array(10)
 35 | console.log(carros) // [ , , , , , , , , ,  ]
 36 | 
 37 | 
 38 | 
 39 | //Exemplo valueOf no array. Retorna o Array.
 40 | var carros = ['HRV', 'Jetta', 'Hillux'];
 41 | console.log(carros.valueOf()); // [ 'HRV', 'Jetta', 'Hillux' ]
 42 | 
 43 | 
 44 | 
 45 | //Exemplo toString no array. Retorna a String.
 46 | var carros = ['HRV', 'Jetta', 'Hillux'];
 47 | console.log(carros.toString()); // 'HRV,Jetta,Hillux'
 48 | 
 49 | 
 50 | 
 51 | //Exemplo length no array. Retorna a quantidade de objetos existentes no array.
 52 | var carros = ['HRV', 'Jetta', 'Hillux'];
 53 | console.log(carros.length) // 3
 54 | 
 55 | 
 56 | 
 57 | //Exemplo push no array. Insere um elemento no final do array.
 58 | console.log(carros.push('Gol')) // 4
 59 | 
 60 | 
 61 | 
 62 | //Exemplo unshift no array. Insere um elemento no início do array.
 63 | console.log(carros.unshift('Lamborghine')) // 5
 64 | 
 65 | 
 66 | 
 67 | //Exemplo pop no array. Remove o último elemento do array.
 68 | console.log(carros.pop()) // 'Gol'
 69 | 
 70 | 
 71 | 
 72 | //Exemplo shit no array. Remove o primeiro elemento do array.
 73 | console.log(carros.shift()) // 'Lamborghine'
 74 | 
 75 | 
 76 | 
 77 | //Exemplo indexOf no array. Retorna o indice de um objeto do array.
 78 | console.log(carros.indexOf('Jetta')) //1
 79 | 
 80 | 
 81 | 
 82 | //Exemplo de splice no array. Remove objetos do array utilizando o índice,
 83 | //sendo possível remover mais de um elemento de uma vez
 84 | console.log(carros.splice(1, 2)) //[ 'Jetta', 'Hillux' ]
 85 | 
 86 | 
 87 | 
 88 | //Exemplo de splice no array. Adiciona um ou mais elementos no array.
 89 | console.log(carros.splice(1, 0, 'jetta', 'hillux'))
 90 | //1 -> busca elemento com índice 1, 0 -> remove 0 objetos do array, 'jetta', 'hillux' -> elementos dicionados.
 91 | 
 92 | 
 93 | 
 94 | //Exemplo de iniciar array vazio e adicionar um elemento por vez com dois valores em cada elemento.
 95 | var carros = [];
 96 | 
 97 | carros[0] = {marca:'ford', modelo:'ka'};
 98 | carros[1] = {marca:'chevrolet', modelo:'corsa'}
 99 | carros[2] = {marca: 'fiat', modelo: 'palio'}
100 | 
101 | 
102 | 
103 | //Exemplo de iniciar array in line, adicionando três elementos de uma vez com dois valores em cara elemento.
104 | var carros = [{marca: 'ford', modelo: 'ka'}, {marca:'chevrolet', modelo:'corsa'}, {marca:'fiat', modelo:'Palio'}];
105 | 
106 | 
107 | 
108 | //Exemplo de forEach no array. Busca todos os elementos do array. Evolução do for, mais simples.
109 | carros.forEach(function (car) {
110 |   console.log(car);
111 | });
112 | // { marca: 'ford', modelo: 'ka' }
113 | // { marca: 'chevrolet', modelo: 'corsa' }
114 | // { marca: 'fiat', modelo: 'Palio' }
115 | 
116 | 
117 | 
118 | //Exemplo de filter no array. Busca determinado elemento com algum(a) filtro(característica) específico.
119 | carros.filter(function(car) {
120 |   return car.marca === 'ford';
121 | });
122 | // [ { marca: 'ford', modelo: 'ka' } ]
123 | 
124 | 
125 | 
126 | //Exemplo de filter no array. Atribui função à variável carrosFord.
127 | var carrosFord = carros.filter(function(car) {
128 |   return car.marca === 'ford';
129 | });
130 | carrosFord // [ {marca: 'ford', modelo: 'ka' } ]
131 | 
132 | 
133 | 
134 | //Exemplo de every no array. Verifica se todos os elementos são da marca ford, funciona como um boolean.
135 | carros.every(function(car) {
136 |   return car.marca === 'ford';
137 | }); //false
138 | 
139 | 
140 | 
141 | //Exemplo de some no array. Verifica se algum dos elementos é da marca ford, funciona como um boolean.
142 | var s = carros.some(function(car) {
143 |   return car.marca === 'ford';
144 | });
145 | s //true
146 | 
147 | 
148 | 
149 | //Exemplo de map no array. Mapeia os elementos por características.
150 | //Mapeia a marca de todos os elementos do array
151 | carros.map(function(car) {
152 |   return car.marca;
153 | }); // ['ford', 'chevrolet', 'fiat']
154 | 
155 | //Mapeia quantos caracteres tem a marca de cada elemento do array
156 | var mapLength = carros.map(function(car) {
157 |   return car.marca.length;
158 | });
159 | mapLength // [4 ,9, 4]
160 | 
161 | 
162 | 
163 | //Exemplo diferença de forEach para reduce no array.
164 | var carros = [];
165 | 
166 | carros[0] = {marca:'ford', modelo:'ka', preco: 25000};
167 | carros[1] = {marca:'chevrolet', modelo:'corsa', preco: 35000}
168 | carros[2] = {marca: 'fiat', modelo: 'palio', preco: 38000}
169 | 
170 | //ForEach
171 | var total = 0;
172 | carros.forEach(function(car) {
173 |   total += car.preco;
174 | });
175 | total // 98000
176 | 
177 | 
178 | //Reduce
179 | carros.reduce(function(prev, cur) {
180 |   return prev + cur.preco;
181 | }, 0); //98000 || prev -> elemento anterior + cur -> elemento atual, 0 -> começa do elemento 0
182 | 
183 | 
184 | 
185 | //Criando 2 arrays, um de carros e um de motos
186 | var carros = ['ka', 'corsa', 'palio']
187 | var motos = ['honda', 'yamaha']
188 | 
189 | 
190 | 
191 | //Exemplo de concat no array. Criando um array de veiculos, contendo os arrays carros e motos
192 | var veiculos = carros.concat(motos);
193 | veiculos // [ 'ka', 'corsa', 'palio', 'honda', 'yamaha' ]
194 | veiculos.length // 5
195 | 
196 | 
197 | 
198 | //Exemplo de splice no array. Busca determinados elemetos pré-definidos
199 | veiculos.slice(0,2) // [ 'ka', 'corsa' ]
200 | veiculos.slice(0,4) // [ 'ka', 'corsa', 'palio', 'honda' ]
201 | veiculos.slice(3,5) // [ 'honda', 'yamaha' ]
202 | 
203 | 
204 | 
205 | //Exemplo reverse no array. Reverte a ordem da listagem de elementos.
206 | veiculos.reverse() // [ 'yamaha', 'honda', 'palio', 'corsa', 'ka' ]
207 | veiculos // [ 'yamaha', 'honda', 'palio', 'corsa', 'ka' ]
208 | veiculos.reverse() // [ 'ka', 'corsa', 'palio', 'honda', 'yamaha' ]
209 | veiculos // [ 'ka', 'corsa', 'palio', 'honda', 'yamaha' ]
210 | 
211 | 
212 | 
213 | //Exemplo de sort no array. Ordena por ordem alfabetica, preco, ou qualquer outra caracteristica do elemento.
214 | var carros = [];
215 | 
216 | carros[0] = {marca: 'fiat', modelo: 'palio', preco: 38000}
217 | carros[1] = {marca:'ford', modelo:'ka', preco: 25000};
218 | carros[2] = {marca:'chevrolet', modelo:'corsa', preco: 35000}
219 | 
220 | //Ordenar por preço, do menor para o maior.
221 | carros.sort(function(a,b) {
222 |   return a.preco - b.preco;
223 | });
224 | // [ { marca: 'ford', modelo: 'ka', preco: 25000 },
225 | //   { marca: 'chevrolet', modelo: 'corsa', preco: 35000 },
226 | //   { marca: 'fiat', modelo: 'palio', preco: 38000 } ]
227 | 
228 | //Ordenar por preço, do maior para o menor.
229 | carros.sort(function(a,b) {
230 |   return b.preco - a.preco;
231 | });
232 | // [ { marca: 'fiat', modelo: 'palio', preco: 38000 },
233 | //   { marca: 'chevrolet', modelo: 'corsa', preco: 35000 },
234 | //   { marca: 'ford', modelo: 'ka', preco: 25000 } ]
235 | 
236 | 
237 | 
238 | //Exemplo join no array. Junta elementos com um separados pré-determinado.
239 | var carros = ['ka', 'corsa', 'palio', 'gol'];
240 | carros.join('/') // 'ka/corsa/palio/gol' || / -> separador dos elementos na String
241 | carros.join('-') // 'ka-corsa-palio-gol' || - -> separador dos elementos na String
242 | 


--------------------------------------------------------------------------------
/9_Heranca.js:
--------------------------------------------------------------------------------
  1 | //Exemplo 1 - Criando objetos diretamente.
  2 | var jose = {
  3 |     nome: 'José',
  4 |     idade: 22,
  5 |     sexo: 'masculino'
  6 | };
  7 | 
  8 | var maria = {
  9 |     nome: 'Maria',
 10 |     idade: 20,
 11 |     sexo: 'feminino'
 12 | };
 13 | 
 14 | console.log(jose); // { nome: 'José', idade: 22, sexo: 'masculino' }
 15 | console.log(maria); // { nome: 'Maria', idade: 20, sexo: 'feminino' }
 16 | 
 17 | 
 18 | 
 19 | //Exemplo 2 - Criando objetos com Função Fábrica. (Mais recomendada que a forma anterior).
 20 | var criarPessoa = function(nome, idade, sexo) {
 21 |   return {
 22 |     nome: nome,
 23 |     idade: idade,
 24 |     sexo: sexo
 25 |   };
 26 | };
 27 | 
 28 | var joao = criarPessoa('João', 30, 'masculino');
 29 | var lucia = criarPessoa('Lúcia', 35, 'feminino');
 30 | console.log(joao); // { nome: 'João', idade: 30, sexo: 'masculino' }
 31 | console.log(lucia); // { nome: 'Lúcia', idade: 35, sexo: 'feminino' }
 32 | 
 33 | 
 34 | 
 35 | //Exemplo 3 - Criando objetos com Função Construtora, usando o operador new.
 36 | var Pessoa = function(nome, idade, sexo) {
 37 |   this.nome = nome;
 38 |   this.idade = idade;
 39 |   this.sexo = sexo;
 40 | };
 41 | 
 42 | var roger = new Pessoa('Roger', 12, 'masculino');
 43 | var julia = new Pessoa('Julia', 10, 'feminino');
 44 | console.log(roger); // { nome: 'Roger', idade: 12, sexo: 'masculino' }
 45 | console.log(julia); // { nome: 'Julia', idade: 10, sexo: 'feminino' }
 46 | 
 47 | 
 48 | 
 49 | //Exemplo 4 - Criando objeto com Função Construtora, utilizando call.
 50 | var Pessoa = function(nome, idade, sexo) {
 51 |   this.nome = nome;
 52 |   this.idade = idade;
 53 |   this.sexo = sexo;
 54 | };
 55 | 
 56 | var isabella = {};
 57 | Pessoa.call(isabella, 'Isabella', 18, 'feminino');
 58 | console.log(isabella); //{ nome: 'Isabella', idade: 18, sexo: 'feminino' }
 59 | 
 60 | 
 61 | 
 62 | //Exemplo 4 - Criando objeto com Função Construtora, utilizando apply(adicionar []).
 63 | var Pessoa = function(nome, idade, sexo) {
 64 |   this.nome = nome;
 65 |   this.idade = idade;
 66 |   this.sexo = sexo;
 67 | };
 68 | 
 69 | var fernando = {};
 70 | Pessoa.apply(fernando, ['Fernando', 21, 'masculino']);
 71 | console.log(fernando); // { nome: 'Fernando', idade: 21, sexo: 'masculino' }
 72 | 
 73 | 
 74 | 
 75 | //O objeto que tem protótipo é completamente diferente da propriedade prototype. Diferença entre [[Prototype]] e prototype:
 76 | //[Prototype]] -> O conceito de protótipo é abstrato, é o protótipo que pode ser um objeto ou null.
 77 | //prototype -> Basicamente é uma propriedade de prototype que só as funções tem, capaz de inserir manipular e/ou
 78 | //transformar os objetos, inserindo, alterando ou excluindo propriedades em todos os objetos de uma só vez.
 79 | //É considerado orientação a objetos baseada em protótipo porque os objetos reusam(herdam) propriedades e métodos de
 80 | //outros objetos.
 81 | //Exemplo 5 - Definindo prototype e inserindo em todos os objetos. Basicamente os objetos não tem a propriedade
 82 | //sexo, quem a tem é o protótipo.
 83 | var Pessoa = function(nome, idade) {
 84 |   this.nome = nome;
 85 |   this.idade = idade;
 86 | };
 87 | 
 88 | Pessoa.prototype.sexo = 'masculino'; // >>atribuindo propriedade sexo a Pessoa.<<
 89 | 
 90 | var gabriel = new Pessoa('Gabriel', 23);
 91 | console.log(gabriel); // { nome: 'Gabriel', idade: 23 }
 92 | console.log(gabriel.sexo); // masculino
 93 | 
 94 | var rafael = {};
 95 | rafael.__proto__ = Pessoa.prototype; // >>Atribuindo o protótipo a rafael.<<
 96 | Pessoa.apply(rafael, ["Rafael", 18]);
 97 | console.log(rafael); // { nome: 'Rafael', idade: 18}
 98 | console.log(rafael.sexo); // masculino
 99 | 
100 | Pessoa.prototype.sexo = 'feminino'; // >>Alterando propriedade sexo do prototype para 'feminino'<<
101 | console.log(gabriel.sexo); // feminino
102 | console.log(rafael.sexo); // feminino
103 | 
104 | 
105 | 
106 | //Em JavaScript quando você faz um new array, new object, new date, dentre outros. Todos eles são criados por meio de
107 | //uma Função Construtora. Caso você esteja usando Função Construtora e queira usar herança, para manipular e/ou transformar
108 | //os objetos, você pode utilizar o prototype para definir propriedades e inserir, alterar ou excluir em todos os objetos
109 | //de uma vez.
110 | //Exemplo 6 - Inserindo prototype direto na função new.
111 | var _new = function(f) {
112 |   var obj = {};
113 |   obj.__proto__ = f.prototype; // >>O protótipo do objeto recebe a Função Construtora(f.prototype);<<
114 |   f.apply(obj, ['Rafael', 18]); // >>Invoco a Função Cosnstrutora, passando o seu contexto, no caso object e um array com as propriedades do objeto <<
115 |   return obj;
116 | }; // >> Função generica <<
117 | 
118 | var Pessoa = function(nome, idade) {
119 |   this.nome = nome;
120 |   this.idade = idade;
121 | }; // >> Função direta <<
122 | 
123 | Pessoa.prototype.sexo = 'masculino';
124 | 
125 | var gabriel = new Pessoa('Gabriel', 23);
126 | console.log(gabriel); // { nome: 'Gabriel', idade: 23 }
127 | console.log(gabriel.sexo); // masculino
128 | 
129 | var rafael = _new(Pessoa, "Rafael", 18);
130 | 
131 | console.log(rafael);  // { nome: 'Rafael', idade: 18 }
132 | console.log(rafael.sexo); // masculino
133 | 
134 | 
135 | 
136 | //Exemplo 7 - Inserindo prototype direto na função new, utilizando um array, de um modo dinâmico.
137 | var _new = function(f) {
138 |   var obj = {};
139 |   obj.__proto__ = f.prototype; // >>O protótipo do objeto recebe a Função Construtora(f.prototype);<<
140 |   f.apply(obj,Array.prototype.slice.call(arguments, 1)); // >>Invoco a Função Cosnstrutora, passando o seu contexto, no caso object e um array com as propriedades do objeto <<
141 |   return obj;
142 | }; // >> Função generica <<
143 | 
144 | var Pessoa = function(nome, idade) {
145 |   this.nome = nome;
146 |   this.idade = idade;
147 | }; // >> Função direta <<
148 | 
149 | Pessoa.prototype.sexo = 'masculino';
150 | 
151 | var gabriel = new Pessoa('Gabriel', 23);
152 | console.log(gabriel); // { nome: 'Gabriel', idade: 23 }
153 | console.log(gabriel.sexo); // masculino
154 | 
155 | var rafael = _new(Pessoa, "Rafael", 18);
156 | 
157 | console.log(rafael);  // { nome: 'Rafael', idade: 18 }
158 | console.log(rafael.sexo); // masculino
159 | 
160 | 
161 | 
162 | //Exemplo 8 - Inserindo prototype direto na função new, utilizando um array, de um modo dinâmico. Exemplo 2.
163 | var _new = function(f) {
164 |   var obj = {};
165 |   obj.__proto__ = f.prototype; // >>O protótipo do objeto recebe a Função Construtora(f.prototype);<<
166 |   f.apply(obj,Array.prototype.slice.call(arguments, 1)); // >>Invoca a Função Cosnstrutora, passando o seu contexto, no caso object e um array com as propriedades do objeto <<
167 |   return obj;
168 | }; // >> Função generica <<
169 | 
170 | var Pessoa = function(nome, idade) {
171 |   this.nome = nome;
172 |   this.idade = idade;
173 | }; // >> Função direta <<
174 | 
175 | Pessoa.prototype.sexo = 'masculino';
176 | 
177 | var gabriel = _new (Pessoa, 'Gabriel', 23);
178 | console.log(gabriel); // { nome: 'Gabriel', idade: 23 }
179 | console.log(gabriel.sexo); // masculino
180 | 
181 | var rafael = _new(Pessoa, "Rafael", 18);
182 | 
183 | console.log(rafael);  // { nome: 'Rafael', idade: 18 }
184 | console.log(rafael.sexo); // masculino
185 | 
186 | 
187 | 
188 | //Pseudo código do new
189 | var _new = function(f) {
190 |   var res = {};
191 | if(f.prototype !== null) {
192 |   res.__proto__ = f.prototype;
193 | }
194 | 
195 |  var ret = f.aplly(res, Array.prototype.slice.call(arguments, 1));
196 |  if((typeof ret === 'object' || typeof ret === 'function') && ret !== null) {
197 |   return ret;
198 |   }
199 |   return res;
200 | }
201 | //Esclarecendo, [[prototype]] é uma propriedade que existe em todos os objetos do JavaScript que pode ser um objeto ou null.
202 | //Já prototype é uma propriedade exclusiva de funções, é utilizado para manipular e/ou transformar os objetos,
203 | //você pode utilizar o prototype para definir propriedades e inserir, alterar ou excluir em todos os objetos de uma vez.
204 | 
205 | //Retrospectiva: Todo mundo é objeto, porém JavaScript 'não possui classes'. Todo objeto possui um [[prototype]].
206 | 


--------------------------------------------------------------------------------