Palestra sobre Javascript realizada no primeiro ciclo do Plano de Geração de Conhecimento realizado em outubro de 2013, no LEMAF - Universidade Federal de Lavras.
O Plano de geração de conhecimento é um trabalho realizado para tutoria de desenvolvedores com estagiários no estudo de tecnologias, com o objetivo de disseminação de conhecimento.
Palestra ministrada por Fernando Simeone, Carlos Eduardo Chessi Melo, Eduardo Assis da Silva e José Henrique Santos Andrade .
### Atualização 20/02/2015
Palestra melhorada, com algumas correções. Reapresentada por Fernando Simeone e Carlos Eduardo Chessi Melo na SETI (Semana de Tecnologia da Informação) na Universidade Federal de Lavras.
3. Carlos Eduardo
Graduando em Sistemas de
Informação;
Desde de 2011 no LEMAF;
Há dois anos atuando na área de
desenvolvimento de software;
4. Fernando Simeone
Graduação em Ciência da Computação
(UFLA);
• Pós-graduação em Engenharia de
Software Centrada em Métodos Ágeis
(UNA);
• Mestrado em Ciência da Computação
(em andamento)
• Há 7 anos trabalhando com
desenvolvimento (desde 2010 no
LEMAF).
12. Declaração
var cargo = “desenvolvedor”;
Palavra
reservada
Nome da
variável
Operador
atribuição
Valor (literal ou outra
variável)
13. Tipos e Literais
String
“Desenvolvedor”
‘DBA’
Number 1 3.14 1e2 1E2 5E2
Boolean true false
Object
{
“id”: 12,
nome: “João”,
perfil: { id: 1 }
}
Array [1, true, ‘test’, {}, [3]]
Function function test (arg) {}
Regular Expression /w+s/
1*(10^2)
5*(10^2)
14. Operações
var a = 10 + 5; // a = 15
a += 4; // a = 19
a++; // a = 20
a = a / 2; // a = 10
a = a * 2; // a = 20
2 == “2”; // true
2 === “2”; // false
16. NaN e isNaN
parseInt(“3“) // 3
parseInt(“tres”) // NaN
isNaN(“4”) // false
isNaN(“3.4”) // false
isNaN(“quatro”) // true
isNaN(4) // false
isNaN(NaN) // true
NaN == NaN // false
typeof NaN // “number”
not a number
18. Operações com
Expressões Lógicas
var user = {};
var rua = user.endereco.rua; // TypeError
var rua = user.endereco && user.endereco.rua;
// trata erro
var i = 1 || 10;
var num = 0 || 10;
20. If
if (user && user.name) {
// ...
} else if (name) {
// ...
} else {
// ...
}
x = (condicao) ? 10 : 20;
21. For
for (i = 0; i < 3; i++) {
// ...
}
• i = 0
• i = 1
• i = 2
{
id: 1,
nome: “João”,
idade: 26
}
• p = “id”
• p = “nome”
• p = “idade”
for (p in obj) {
// ...
}
22. Switchswitch (x) {
case 1:
// ...
break;
case “test”:
// ...
break;
case y:
case w:
// ...
break;
default:
//...
}
Expressão pode gerar
Number ou String
Cláusula Case não
precisa ser constante
29. Arguments
Toda função recebe uma variável arguments, que
é um objeto similar a um array.
function testArgs() {
return arguments.length;
}
testArgs(1, 4, 5, 2); // retorna 4
testArgs(true, false) // retorna 2
testArgs( [1, 2, 3] ) // retorna 1
30. Acessando itens de
arguments
function soma () {
var result = 0,
i = 0;
for (i = 0; i < arguments.length; i++) {
result += arguments[i];
}
return result;
}
soma (1, 3, 6, 1); // retorna 11
32. Escopo
Escopos são definidos por funções.
function () {
var i = 3;
// um monte de código aqui.
for (var i = 0; i < 10; i++) {
// ...
}
}
Declaração
duplicada
33. EscopoArquivo teste.js
Escopo Global
Escopo função soma
Escopo função teste
Escopo função testeInterno
var x = 1;
function soma (n1, n2) {
return n1 + n2;
}
function teste () {
var y = 3;
function testeInterno () {
var z = 4;
w = 10; // variável global
}
}
34. Closure
Closure é uma função que
referencia as variáveis que
foram declaradas no mesmo escopo
que ela.
Em Javascript, todas as funções
são closures.
35. Closure
sayHello = null
msg = “Hello!”
var sayHello = null;
function init() {
var msg = “Hello!”;
sayHello = function() {
alert(msg);
};
}
init();
sayHello = Function
Escopo referenciado pela função
sayHello(); // exibe “Hello!”
37. Chamadas de
Função
• Método
• Função
• Construtor
• Apply e Call
obj.sayHello();
sayHello();
new sayHello();
sayHello.apply(obj, [p1, p2]);
sayHello.call(obj, p1, p2);
38. Chamada tipo “método”
var user = {
name: “João”,
sayHello: function(n) {
this.name = n
alert(this.name);
}
};
Chamada utilizando ponto
user.sayHello(“Pedro”);
// Altera “nome” do objeto e exibe “Teste”
40. Chamada tipo “função”
var user = {
name: “João”,
sayHello: function(n) {
this.name = n
alert(this.name);
}
};
Chamada não utilizando ponto
var hello2 = user.sayHello;
hello2(“teste”);
// Exibe “teste” e retorna undefined e
// não altera o objeto
41. Chamada tipo
“Construtor”function User (username) {
this.name = username;
}
Chamada utilizando new
var user1 = new User(“joao”);
// retorna um novo objeto
// com a propriedade “name” = “joao”.
42. Apply e Call
user.sayHello.apply(obj2, [“teste”]);
var user = {
name: “João”,
sayHello: function(n) {
this.name = n
alert(this.name);
}
};
var obj2 = {};
user.sayHello.call(obj2, “teste”);