
Lançado em 27 de maio de 2009, sendo criado por Ryan Dahl, juntamente com alguns colaboradores. O node.js surgiu para facilitar o desenvolvimento de aplicações `real-time` e de alta escalabilidade. Ele utiliza o mecanismo V8 Javascript, que é utilizado pela Google no navegador Chrome. A google criou esse interpretador escrito C++, e é possível fazer o download desse mecanismo e integrá-lo aonde desejar. Um mecanismo `javascript`, interpreta e executa o código. Assim com o V8, essa interpretação e execução é feita no servidor.

O pessoal de front-end, fica muito grato com a existência da plataforma Node.js e assim, conseguindo rodar `javascript`, no lado do servidor. É isso mesmo, para quem já utiliza a linguagem `javascript`, a curva de aprendizado será muito pequena. Portanto, irá desenvolver em `javascript` na plataforma do Node.js.

O Node.js possui vários módulos nativos que possibilitam trabalhar com recursos I/O (entrada/saída) no servidor. Podendo assim, ter várias bibliotecas a sua disposição para trabalhar com: HTTP, DNS, WebSockets e mais. Além de manipular arquivos, criptografias e mais. Com a vantagem desses eventos serem assíncronos.

## Node foundation

O `io.js`, oficialmente lançado em dezembro de 2014, começou com um `fork` do projeto do Node.js, que hoje é mantido pela empresa Joyent, onde Dahl, trabalha. A iniciativa foi tomada por Fedor Indutny, um dos principais membros da comunidade Node.js, que estava insatisfeito com o conselho consultivo da Joyent. Outros importantes colaboradores da comunidade apoiaram a ideia, como: Trevor Norris, Isaac Z. Schlueter e Mikeal Rogers. Schlueter, deixa claro no FAQ do blog do io.js, que o `fork` é para prover um espaço para que os contribuidores do núcleo Node possa continuar fazendo o seu trabalho de melhoria.

Uma das principais queixas, era a falta de versões no projeto do Node.js. E com o io.js, a intenção era de lançar com crescente regularidade, versões que são compatíveis com o ecossistema `npm` construído até o momento para o Node.js.

Em 16 de junho de 2015, a [`Linux foundation`](http://www.linuxfoundation.org.) anunciou que Node.js e io.js, iriam oficialmente fundir suas bases de código e continuar o trabalho como `Node foundation` e seria hospedado pela `Linux Foundation`.

Hoje, já estamos na versão 5.3.0 . Realmente o o ritmo de contribuições com o io.js, acelerou muito as melhorias. Antes da fusão, era curioso ver no `github`. Assim, vemos o poder da comunidade. Parabéns aos envolvidos. :)

## Baseado em Node.js

Tem muitos projetos que são baseados na plataforma e nos ajudam no dia a dia. Alguns deles são:

- **_Grunt ou Gulp_**: Automatizador de tarefas, muito conhecido por quem desenvolve o front-end. O mesmo nos ajuda nas tarefas de minificação de arquivos, compilação e mais.
- **_MeteorJS_**: É um framework web JavaScript open-source escrito em Node.js.
- **_KarmaJS_** - Uma ferramenta que gera um servidor Web que executa o código fonte com o código de teste para cada um dos navegadores conectados.

Mesmo que ainda não tenha usado o Node.js, no lado do servidor, é possível utilizá-lo para outras tarefas. Principalmente, quem é front-end, é quase obrigatório tê-lo instalado na máquina, por causa dos automatizadores de tarefas, citados acima. :)

## Threads (Usuários fazendo requisições para a aplicação)

Em sistemas com arquitetura de `Threads Bloqueantes`, que é o caso dos desenvolvidos em JAVA ou .NET, por exemplo. Quando há acessos simultâneos para o mesmo recurso, eles são enfileirados. Assim, cada um deles utiliza o recurso um de cada vez, garantindo a integridade dos dados, por ter o controle de acesso único. Esse conceito é muito utilizado em aplicações bancárias e e-commerce.

O Node.js segue o conceito de `Threads Não-Bloqueantes`, portanto, é totalmente `single-thread`. Isso traz como vantagem uma alta escalabilidade para aplicações que necessitam de um processamento sem controle de processamento concorrente (threads), pois não há um agente bloqueando e enfileirando threads. Nos casos de aplicações que necessitem de uma resposta rápida, por exemplo, consultas frequentes no banco de dados, o node.js faz esse trabalho muito bem, como: Games Multiplayer, Web Services, Blogs, Redes sociais, Web Analytics, Chats e mais.

## CommonJS

O Node.js utiliza o padrão CommonJS para organização e carregamento dos módulos.
Para carregar um módulo, você fará uso da função `require`.

```
require('nome-do-modulo');
```

E o módulo terá que utilizar as variáveis globais: exports ou module.exports.

```
module.exports = function() {
	// script do módulo
}
```

## Rodando um exemplo

Primeiramente, precisará ter o node instalado, se não tiver é só [acessar o site e baixar](https://nodejs.org/en/).
Depois vamos dar uma conferida no terminal:

```
node -v
```

Com o editor de sua preferência, vamos criar o arquivo `exemplo.js`:

```
var http = require('http');
http.createServer(function(req,res) {
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('Exemplo com Node.js');
}).listen(4000);
console.log('Servidor rodando no endereço localhost:4000');
```

No terminal, você vai até onde está o arquivo ou escreve todo o caminho para executá-lo. No caso abaixo, vamos supor que estou na pasta onde se encontra o arquivo, sendo apenas necessário digitar:

```
node exemplo.js
```

Acessando no navegador da sua preferência, o endereço http://localhost:4000, poderemos ver o texto "Exemplo com Node.js". E assim, temos um exemplo simples com o Node.js.

## Conclusão

Quer deixar um `front-ender` feliz, é só dizer que ele pode escrever em `javascript`, para rodar no servidor. E ele vai a loucura, se disser que pode usar os recursos do ES6. E isso é possível com a nossa querida plataforma Node.js. Acima, você pode conferir algumas informações e nos próximos artigos, terá mais algo prático. Até lá.


Começando com NodeJS


MeteorJS é plataforma completa para construir aplicações web e móveis em tempo real usando JavaScript, o mesmo é escrito em Node.js. Portanto, é mais que um framework. Por padrão, usa MongoDB para o banco de dados e Handlebars como linguagem de template. Ele foi apresentado a comunidade em dezembro de 2011 com o nome de Skybreak. A versão 1.0, foi lançada em dezembro de 2014, sendo uma declaração pública de estabilidade.

A principal característica é que você terá um ambiente completo pra desenvolver e gerenciar uma aplicação desde o banco de dados MongoDB, backend Node.js, frontend JavaScript e build mobile usando Cordova do Phonegap.

## DDP

DDP é muito simples e minimalista. É um protocolo baseado em JSON. Tecnicamente, DDP pode ser implementado em cima de qualquer transporte duplex. A implementação atual do Meteor é baseada em WebSockets e SockJS. SockJS é um transporte de emulação WebSockets, que pode ser usado quando o WebSockets não está disponível.

DDP é o coração do MeteorJS e é o protocolo que o mesmo usa para se comunicar entre o cliente e o servidor. DDP é uma sigla para Distributed Data Protocol. Meteor implementou ambas as implementações de cliente e servidor para DDP. Existem algumas bibliotecas do lado cliente para frameworks e linguagens para se conectar com Meteor via DDP.

## Instalação

### Windows

Para instalar no Windows, basta acessar o [Link](https://install.meteor.com/windows).

### OS X ou Linux

Poderá instalar utilizando a biblioteca cURL.

```bash
curl https://install.meteor.com/ | sh
```

## Meteor Tool

Meteor Tool é uma CLI (Command Line Interface), que gerenciará o que for necessário para o desenvolvimento com o **Meteor**. Para verificar que já pode testar, basta no terminal, executar o comando:

```bash
meteor --version
```

## Princípios do Meteor

- **Dados na rede:** Não envie HTML pela rede e sim apenas dados para deixar o cliente decidir como renderizá-lo.
- **Uma só linguagem:** Escreva código Javascript em ambas camadas: cliente e servidor.
- **Banco de dados em todo lugar:** Utilize uma API de interface única e transparente que te permite acessar o banco de dados tanto no cliente como no servidor.
- **Compensação de latência:** No cliente é usado prefetching e model simulation na API do banco de dados para atingir latência zero no acesso de seus recursos.
- **Atualização automática das camadas:** Por default tudo funciona em real-time. E todas as camadas da aplicação adotam o paradigma orientado à eventos, que é herdado do Node.js.
- **Abrace o ecossistema:** Totalmente open-source o Meteor possui suas convenções pelo qual agrega novos valores ao invés de ser ferramenta uma que vai substituir outros frameworks atuais.
- **Simplicidade igual a Produtividade:** Desenvolva de forma simplificada, utilize APIs fáceis de aprender e implementar, afinal essa será a melhor forma de criar uma aplicação.

## Criando a primeira aplicação

Para criar um novo projeto, basta executar o comando `create` no terminal, junto com o nome que o projeto terá:

```bash
meteor create example
```

Vamos ver o projeto rodando:

```bash
cd example
meteor
// Depois acesse : http://localhost:3000/
```

O Meteor vem com algumas aplicações de demonstração que você pode experimentar. Basta executar uma das sequências dos comandos abaixo no terminal:

```bash
// app de tarefas
meteor create --example todos
cd todos
meteor

// exemplo de aplicação móvel
meteor create --example localmarket
cd localmarket
meteor
```

## Links

- [Site oficial do Meteor](http://meteor.com/)
- [Documentação oficial do Meteor](http://docs.meteor.com/)
- [Meteor Example apps ](http://www.meteor.com/examples)
- [Twitter do Meteor](https://twitter.com/meteorjs)
- [Blog Underground WebDev - Meteor](http://udgwebdev.com/meteor)

## Conclusão

Essa foi uma introdução simples ao MeteorJS. O mesmo tem muitas vantagens como: Desenvolvimento em tempo real, desenvolvimento com uma linguagem única, fácil de aprender, fácil de configurar, recursos úteis, escabilidade e desenvolvimento ágil.

Portanto, tem muito a oferecer para um projeto web ou mobile.


Começando com MeteorJS


Depois de 20 anos, temos a evolução de alguns recursos da linguagem JavaScript. Em junho de 2015, foi anunciada pela Assembleia Geral da Ecma International a aprovação da sexta edição da ECMA-262.

O nome oficial é ECMAScript 2015 e de agora em diante, as novas versões irão em seu nome incluir ECMAScript seguido pelo ano de sua liberação.

O ES6, já mostra que veio com várias melhorias, pela sua documentação com quase 600 páginas, enquanto a documentação do seu antecessor ES 5.1, tem 245 páginas.

## Compatibilidade

Para evitar problemas de compatibilidade, o ES6 é compatível com as versões anteriores. Com isso, não precisa arrancar os cabelos por causa do seu código antigo.

Para ficar por dentro, da compatibilidade com os browsers, confira no [link](http://kangax.github.io/compat-table/es6/), que é mantido pelo [Kangax](https://twitter.com/kangax).

## Transpiler

Atualmente nenhum navegador suporta completamente todos os novos recursos do ES6. Para utilizar os novos recursos sem problemas, é necessário utilizar um `transpiler` para o ES5. Uma dica para esse trabalho, é o [Babel](https://babeljs.io/)

## Algumas novidades

Default Parameters Values - Com certeza, muitos desenvolvedores vão matar uma linha ou mais, podendo já passar em uma função, um parâmetro com um valor `default`.

```
// ES 5
function worked(entry, leave) {
    leave = leave || 18;
    return leave - entry;
}
```

```
// ES 6
function worked(entry, leave = 18) {
    return leave - entry;
}
```

Classes - Agora ficou mais declarativo e fácil de entender e o método constructor para aproximar o javascript com as demais linguagens.

```
// ES 5
function Accordion(element){
	this.container = element;
	this.effect;
}
Accordion.prototype.close = function () {
}

```

```
// ES 6
class Accordion {
    constructor(element) {
        this.container = element;
        this.effect;
    }

    close() {
    }
}
```

O intuito do post é só dar uma introdução, mais exemplos e a documentação, você encontra nos links abaixo.

## Links interessantes

[ECMAScript 2015](http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf)
Especificação da linguaguem com a versão ECMAScript 2015.

[Futuro do Subjuntivo - Quando vós programardes JavaScript](https://goo.gl/PL2bV2)
Palestra muito boa que acompanhei ao vivo no Front Carioca 2015, onde o Jaydson Gomes mostra muito bem algumas novidades.

[ES6: Brincando com o novo JS](http://jsrocks.org/pt-br/2014/11/es6-playing-with-the-new-javascript)
Artigo do Pedro Nauck, que vale a pena dar uma conferida.

[ES6: Using the new Javascript today!](https://www.youtube.com/watch?v=OVPzgq2pBTc)
Video com a apresentação do Pedro Nauck.

## Conclusão

Com a especificação do ECMAScript 2015, muitas coisas melhoraram e por isso já devemos estar utilizando para atualizar os projetos e já atualizar com os novos padrões. E no momento, de preferência com a ajuda de um `transpiler`. Muita gente como eu, aguardava esse momento, ele já chegou e já está passando. Já acabou a meses a época para testar as novidades, devemos utilizar. É claro, que dependendo do projeto, não será uma tarefa fácil ou rápida, mas já temos que conhecer todas as novas melhorias.


Começando com ECMAScript 2015


Variáveis são endereços de memória onde armazenamos dados ou informações. Precisamos declarar as mesmas, para manipular os dados e informações com facilidade e para termos controle durante os processos.

Até a quinta versão do ECMA-262, variáveis não declaradas ou sem valor receberiam o valor `undefined`. Agora com a sexta versão, variáveis declaradas sem valor e não declaradas, terão o valor `string` e `undefined`, respectivamente.

```
// versão 5
var name;
console.log(typeof name); // undefined
console.log(typeof calc); // undefined
```

```
// versão 6
var name;
console.log(typeof name); // string
console.log(typeof calc); // undefined
```

Podemos apenas declarar uma variável sem valor, com isso já estaremos configurando na memória para o seu uso posteriormente. Declarando já com um valor, dizemos que a variável está sendo inicializada.

```
var name = 'Hemerson';
```

É possível declarar uma variável sem usar a palavra-chave var na declaração e atribuir um valor para ela. Trata-se de uma declaração implícita.

```
name = 'Hemerson';
```

Não é possível usar uma variável que nunca tenha sido declarada.

```
var result = width * height;
```

## Nomeação

A linguagem JavaScript é '**case sensitive**', portanto faz distinção entre maiúsculas e minúsculas.

```
var name = 'hemerson';
var Name = 'fulano';

console.log(name) // hemerson
console.log(Name) // fulano
```

Regras para nomear uma variável:

- 1. O caractere inicial deve ser uma letra ASCII ou um caractere de sublinhado(\_). E não pode iniciar por um número
- 2. Os próximo caracteres devem ser letras, números ou sublinhados (\_).
- 3. Não pode ter o nome de uma palavra reservada.

### Palavras reservadas

break - default - function - return - var - case - delete - if - switch - void - catch - do - in - this - while - const - else - instanceof - throw - with - continue - finally - let - try - debugger - for - new - typeof

Pode:

```
var _name;
var Age;
var match_result;
```

Não pode:

```
var 107Test;
var name&age;
```

## E aí, comma-first ou trailing commas?

Comma-first:

```
var name = 'hemerson'
    , age= 28
;
```

Trailing commas:

```
var name = 'hemerson',
    age= 28;
```

O padrão tradicional e o qual muitos estão acostumados, seria com as vírgulas à direita. Com a vírgula na frente, na minha opinião tem facilitado bastante a legibilidade do código e dependendo da ocasião, facilidade para comentar uma variável.

Sendo adepto do comma-first, deixo um [artigo do Suissa](http://nomadev.com.br/comma-first-por-que-usar/) que levanta uns bons pontos.

Essa é uma questão que mesmo tendo uma preferência, deixo aberto que a decisão seja tomada visando o melhor para o projeto e padronização da equipe.

<br><br>

### Série JavaScript

- 1.[Introdução](/tecnologia/artigos/javascript/javascript-introducao)
- 2.[Tipos de dados](/tecnologia/artigos/javascript/javascript-tipos-de-dados)
- 3.[Valores](/tecnologia/artigos/javascript/javascript-valores)
- 4.Variáveis


Javascript - Variaveis


Agora que já conhecemos os tipos de dados que existem na linguagem JavaScript, agora precisamos ver mais sobre os valores em si. Como no caso do tipo `boolean`, que tem apenas 2 valores possíveis, `true` ou `false`.

Podemos inverter o valor do tipo `boolean` com o operador `!`(negação). Ex:

```
var test = true;
console.log(!test); // false
```

Negando 2 vezes `!!`, podemos ter o retorno real do valor. Ex:

```
var test = true;
console.log(!!test); // true
```

Uma coisa muito importante para se levar em conta nas condições que você possa fazer no código JavaScript, é se determinados valores são considerados verdadeiros ou falsos.

Considerados `falsy` (falsos):

- false
- 0 (zero)
- "" (string vazia)
- null
- undefined
- NaN

```
if(false) console.log('true');
else console.log('false');

if(0) console.log('true');
else console.log('false');

if("") console.log('true');
else console.log('false');

if(null) console.log('true');
else console.log('false');

if(undefined) console.log('true');
else console.log('false');

if(NaN) console.log('true');
else console.log('false');
```

Considerados `truthy` (verdadeiros):

- "0" (zero)
- "false"
- function() {}
- []
- {}

```
if("0") console.log('true');
else console.log('false');

if("false") console.log('true');
else console.log('false');

if(function(){}) console.log('true');
else console.log('false');

if([]) console.log('true');
else console.log('false');

if({}) console.log('true');
else console.log('false');
```

Também é importante conhecer os possíveis valores do tipo `number`.

- Inteiro

```
var num = 10;
var num2 = -10;
```

- Decimal

```
var num = 10.12;
var num2 = -10.12;
```

- Com expoente

```
var num = 421e6
console.log(num); //421000000

var num2 = 421e-6
console.log(num2); //0.000421
```

- Hexadecimal

```
var num = 0xFF;
console.log(num); // 255
```

<br><br>

### Série JavaScript

- 1.[Introdução](/tecnologia/artigos/javascript/javascript-introducao)
- 2.[Tipos de dados](/tecnologia/artigos/javascript/javascript-tipos-de-dados)
- 3.Valores
- 4.[Variáveis](/tecnologia/artigos/javascript/javascript-variaveis)


Javascript - Valores


A linguagem JavaScript é uma linguagem de tipagem fraca (ou tipagem dinâmica). Isso significa que variáveis JavaScript não têm nenhum tipo predeterminado. Assim, o tipo de uma variável é o tipo do seu valor.

Em JavaScript, você pode realizar operações em valores de diferentes tipos sem causar uma exceção. O interpretador converte implicitamente um dos tipos de dados no outro e realiza a operação.

Regras para os tipos primários:

```
// string + number
var test = '1' + 1;
console.log(typeof test); // string

// string + boolean
var test2 = '1' + false;
console.log(typeof test2); // string

// number + boolean
var test3 = 1 + false;
console.log(typeof test3); // number

```

### Primários

Os tipos de dados primários (primitivos) são:

String

```
var name = 'Hemerson';
console.log(typeof name); // string
```

Number

```
var age = 29;
console.log(typeof age); // number
```

Boolean

```
var rich = false;
console.log(typeof rich); // boolean
```

Symbol (Novidade com a versão ECMAScript 2015)

```
var symbol1 = Symbol('foo');
console.log(typeof symbol1); // symbol
```

### Compostos

Os tipos de dados compostos (de referência) são:

Object

```
var obj = {};
console.log(typeof obj); // object
```

Array

```
var items = [];
console.log(items instanceof Array); // true
```

### Especiais

Os tipos de dados especiais são:

Null

```
var money = null;
console.log(money); // null
```

Undefined

```
console.log(typeof lost); // undefined
```

<br><br>

### Série JavaScript

- 1.[Introdução](/tecnologia/javascript/javascript-introducao)
- 2.Tipos de dados
- 3.[Valores](/tecnologia/javascript/javascript-valores)
- 4.[Variáveis](/tecnologia/javascript/javascript-variaveis)


Javascript - Tipos de dados


E aqui se inicia a série "JavaScript". A ideia veio depois de ver um número grande de front-enders que ainda não se preocupam em conhecer a linguagem e só apenas usam frameworks e bibliotecas.

Quando perguntado se conhece a linguagem, a resposta mais ouvida foi: **_'Uso jQuery!'_**

Então, vamos falar sobre a linguagem JavaScript, que já foi chamada de Mocha, posteriormente LiveScript e por fim JavaScript. A mesma foi criada por [@BrendanEich](https://twitter.com/brendaneich), e teve sua primeira versão JavaScript 1.0, introduzida no navegador Netscape 2.0 em 1996.

> JavaScript é uma linguagem de programação interpretada . Foi originalmente implementada como parte dos navegadores web para que scripts pudessem ser executados do lado do cliente e interagissem com o usuário sem a necessidade deste script passar pelo servidor, controlando o navegador, realizando comunicação assíncrona e alterando o conteúdo do documento exibido.
> <cite> -- JavaScript
>
> - [Wikipédia](http://pt.wikipedia.org/wiki/JavaScript) > </cite>

> Com JavaScript, podemos controlar o comportamento do navegador em diversos aspectos, como criar janelas pop-up, apresentar mensagens ao usuário, alterar as dimensões do navegador, interferir na barra de status, retirar menus, fechar e abrir janelas.
>
> JavaScript é capaz de acessar os campos e valores digitados em um formulário HTML e proceder à validação dos dados, realizar cálculos e fornecer dicas de preenchimento dos campos.
>
> <cite> -- JavaScript Guia do Programador
>
> - Maurício Samy Silva
>   </cite>

Atualmente, o nome oficial da linguagem JavaScript é ECMAScript e a versão é a ECMA-262 v6 (ECMAScript 2015).

### Tabela 1.1 – Versões da JavaScript

| Versão           | Implementação                                | Mês/ano       |
| ---------------- | -------------------------------------------- | ------------- |
| JavaScript 1.0   | Netscape 2.0                                 | Março 1996    |
| JavaScript 1.1   | Netscape 3.0                                 | Agosto 1996   |
| JavaScript 1.2   | Netscape 4.0 e 4.05                          | Junho 1997    |
| JavaScript 1.3   | Netscape 4.06 e 4.07x                        | Outubro 1998  |
| JavaScript 1.4   | Servidores Netscape                          | -             |
| JavaScript 1.5   | Netscape 6.0 – Firefox 1.0 – Opera 6.0 a 9.0 | Novembro 2000 |
| JavaScript 1.6   | Firefox 1.5 – Safari 3.0 e 3.1               | Novembro 2005 |
| JavaScript 1.7   | Firefox 2.0 – Safari 3.2 e 4.0 – Chrome 1.0  | Outubro 2006  |
| JavaScript 1.8   | Firefox 3.0                                  | Junho 2008    |
| JavaScript 1.8.1 | Firefox 3.5                                  | 2008          |
| JavaScript 1.9   | Firefox 4.0                                  | 2009          |
| JavaScript 1.0   | Internet Explorer 3                          | Agosto 1996   |
| JavaScript 2.0   | Internet Explorer 3 – Windows IIS 3          | Janeiro 1997  |
| JavaScript 3.0   | Internet Explorer 4                          | Outubro 1997  |
| JavaScript 4.0   | Visual Studio 6.0                            | -             |
| JavaScript 5.0   | Internet Explorer 5                          | Março 1999    |
| JavaScript 5.1   | Internet Explorer 5.01                       | -             |
| JavaScript 5.5   | Internet Explorer 5.5                        | Julho 2000    |
| JavaScript 5.6   | Internet Explorer                            | Outubro 2001  |
| JavaScript 5.7   | Internet Explorer 7                          | Novembro 2006 |
| JavaScript 5.8   | Internet Explorer 8                          | Março 2009    |
| ECMA-262 v1      | Navegadores versão 4                         | 1998          |
| ECMA-262 v2      | Versão de testes                             | 1998          |
| ECMA-262 v3      | Navegadores versão 6                         | 1999          |
| ECMA-262 v4      | Navegadores versão 6+                        | 2002          |
| ECMA-262 v5      | Navegadores versão 6+                        | 2009          |
| ECMA-262 v6      | Versão atual                                 | 2015          |

> ECMA (acrônimo para European Computer Manufacturers Association) é uma associação fundada em 1961 dedicada à padronização de sistemas de informação. Desde 1994 passou a se denominar Ecma International para refletir suas atividades internacionais. A associação é aberta a companhias que produzem, comercializam ou desenvolvem sistemas de computação ou de comunicação na Europa.
> <cite> -- Ecma International
>
> - [Wikipédia](http://pt.wikipedia.org/wiki/Ecma_International) > </cite>

> ECMAScript é uma linguagem de programação baseada em scripts, padronizada pela Ecma International na especificação ECMA-262. A linguagem é bastante usada em tecnologias para Internet, sendo esta base para a criação do JavaScript/JScript e também do ActionScript.
> <cite> -- ECMAScript
>
> - [Wikipédia](http://pt.wikipedia.org/wiki/ECMAScript) > </cite>

## Mãos à obra

Conseguimos inserir de algumas formas o código JavaScript em um documento HTML.

Incorporado no `<head>` ou no `<body>`:

```
<!doctype html>
<html>
  <head>
    <script type="text/javascript">
      // Insira o código Javascript aqui
    </script>
  </head>
  <body>
    <script type="text/javascript">
      // Insira o código Javascript aqui
    </script>
  </body>
</html>
```

Linkado no `<head>` ou no `<body>`:

```
<!doctype html>
<html>
  <head>
    <script type="text/javascript" src="arquivo.js"></script>
  </head>
  <body>
  	<script type="text/javascript" src="arquivo.js"></script>
  </body>
</html>
```

Também é possível de forma `inline`, mas não é aconselhável por dificultar a manutenção e etc.

```
<!doctype html>
<html>
  <head>
  </head>
  <body>
    <a href="#" onclick="document.getElementsByTagName('p')[0].style.color = 'red';return false;">clique aqui</a>

    <p>Text 1</p>
    <p>Text 2</p>

  </body>
</html>
```

## EcmaScript 2015

Já podemos utilizar as novas features sem preocupação com o auxílio de um "transpiler", como o [BabelJS](https://babeljs.io/).
Em um próximo artigo, falarei sobre as novas features.

Com isso, temos uma introdução na linguagem. :)

<br><br>

### Série JavaScript

- 1.Introdução
- 2.[Tipos de dados](/tecnologia/artigos/javascript/javascript-tipos-de-dados)
- 3.[Valores](/tecnologia/artigos/javascript/javascript-valores)
- 4.[Variáveis](/tecnologia/artigos/javascript/javascript-variaveis)


UI2CodeGo to Home Page

Javascript

Compartilhar

Compartilhar

Compartilhar

Compartilhar

Compartilhar

Compartilhar

Compartilhar