text:
# Node.js - Aula 05 - Exercício

**User:** [matheusjkweber](https://github.com/matheusjkweber)

**Autor:** Matheus José Krumenauer Weber

**Date:** 1456875689947

## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0

Instalei o nvm usando esse tutorial.

```
nvm --version
0.31.0

```

## Inicie um projeto novo para essa aula, com o npm e instale, salvando no package.json:
```
    npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
name: (class5) pokemon-api
version: (1.0.0) 1.0.0
description: Api para Pokemons
entry point: (index.js)
test command:
git repository:
keywords: pokemons, api, nodejs, be-mean
author: Matheus Jose Krumenauer Weber
license: (ISC)
About to write to /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5/package.json:

{
  "name": "pokemon-api",
  "version": "1.0.0",
  "description": "Api para Pokemons",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "pokemons",
    "api",
    "nodejs",
    "be-mean"
  ],
  "author": "Matheus Jose Krumenauer Weber",
  "license": "ISC"
}
```

Dependência Local
```
    npm install --save mongoose
```

Dependência Local
```
    npm install --save mongoose

    pokemon-api@1.0.0 /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
└─┬ mongoose@4.4.5
  ├── async@1.5.2
  ├── bson@0.4.21
  ├── hooks-fixed@1.1.0
  ├── kareem@1.0.1
  ├─┬ mongodb@2.1.6
  │ ├── es6-promise@3.0.2
  │ ├─┬ mongodb-core@1.3.1
  │ │ └─┬ require_optional@1.0.0
  │ │   ├── resolve-from@2.0.0
  │ │   └── semver@5.1.0
  │ └─┬ readable-stream@1.0.31
  │   ├── core-util-is@1.0.2
  │   ├── inherits@2.0.1
  │   ├── isarray@0.0.1
  │   └── string_decoder@0.10.31
  ├── mpath@0.2.1
  ├── mpromise@0.5.5
  ├─┬ mquery@1.7.0
  │ ├── bluebird@2.9.26
  │ ├── debug@2.2.0
  │ └── sliced@0.0.5
  ├── ms@0.7.1
  ├── muri@1.1.0
  ├── regexp-clone@0.0.1
  └── sliced@1.0.1

npm WARN pokemon-api@1.0.0 No repository field.

```
Dependência Local de Desenvolvimento
```
    npm i --save-dev jasmine
pokemon-api@1.0.0 /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
└─┬ jasmine@2.4.1
  ├── exit@0.1.2
  ├─┬ glob@3.2.11
  │ └─┬ minimatch@0.3.0
  │   ├── lru-cache@2.7.3
  │   └── sigmund@1.0.1
  └── jasmine-core@2.4.1

npm WARN pokemon-api@1.0.0 No repository field.
```
Dependência Local Opcional
```
    npm i color --save-optional
pokemon-api@1.0.0 /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
└─┬ color@0.11.1
  ├── color-convert@0.5.3
  └─┬ color-string@0.3.0
    └── color-name@1.1.1

npm WARN pokemon-api@1.0.0 No repository field.
matheus@Math:~/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5$
```
## Crie e execute um script, via 'npm', que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
- package.json
```js
    "scripts":{
    "roda": "node script.js"
    },
```
- scripts.js
```js
    console.log("Rodei");
```
- terminal
```
    pokemon-api@1.0.0 roda /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
    > node script.js

    Rodei

```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```
require - inclui um modulo no script.
__dirname - retorna o diretorio que o script esta sendo rodado.
__filename - retorna o arquivo que o script esta sendo rodado.
setTimeout - coloca um intervalo antes de rodar uma funcao.
setInterval - cria um loop de uma funcao.
```

```js
const http = require('http');

console.log(__dirname);

console.log(__filename);

setTimeout(function(){
    console.log("Timeout");
});

setInterval(function(){
    console.log("setInterval");
},200)
```

```
node global.js
/home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
/home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5/global.js
Timeout
setInterval
setInterval
setInterval
setInterval
setInterval
```

## Explique como funciona e de um exemplo de process.
```js
É uma instância de EventEmitter, pode ser acessado de qualquer lugar, eles emitem eventos.

var EventEmitter = require('events').EventEmitter;
var emitter = new EventEmitter();
setInterval(function() {
  console.log(process.memoryUsage().rss);
}, 1000);

node process.js
15593472
15859712
16130048
16130048
```
##Criar um arquivo
```js
/**
* Sync
*/

var fs = require('fs');

var wrtie = fs.writeFileSync('./hello.txt', "Hello world!");

/**
*Async
*/

fs.writeFile("./hello2.txt", "hello again", function(err, result){
  if(err) throw err;
  console.log(result);
});

var writeStream = fs.createWriteStream('./helloStream.txt', {defaultEnconding:'utf8'});

writeStream.write('Hello');
```
##Ler um arquivo
```js
var fs = require('fs')

fs.readFile('./meusArquivos/helloworld.txt',  'utf8', function(err,data){
  if(err) throw err;
  console.log(data);
});

var dataSync = fs.readFileSync('./meusArquivos/helloworld1.txt', {encoding:'utf8'});

console.log(dataSync);
```

##Editar conteúdo desse arquivo
```js
fs.writeFile("./meusArquivos/helloworld.txt", "hello edited", function(err, result){
  if(err) throw err;
  console.log(result);
});
```

##Deletar arquivo
```js
fs.unlink('./meusArquivos/helloworld.txt', function(err,data){
  if(err) throw err;
  console.log("Deletado.");
});
```

##Renomear o arquivo
```js
var fs = require('fs')

fs.rename('./eufuicriadocomnode/', './eufuirenomeadocomnode', function(err){
  if(err) throw err;
});
```

#Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...
Index.html
```
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Be MEAN - Instagram</title>
  <link rel="stylesheet" type="text/css" href="style.css" />
  <script src="script.js"></script>
</head>
<body>
  <h1>Be MEAN - Instagram - html </h1>
</body>
</html>
```
style.css
```

  h1{
    color:green;
  }

```
script.js
```
alert("Funcionou!");
```
server.js
```js
var http = require('http')
, fs = require('fs')
, index=fs.readFileSync('index.html')
, style = fs.readFileSync('style.css')
, scripts = fs.readFileSync('script.js');

http.createServer(function(request,response){
  console.log(request.url);
  if (request.url == "/" || request.url=="/index.html"){
    response.writeHead(200,{'Content-Type':'text/html'});
    response.end(index);
  }else if(request.url == "/style.css"){
    response.writeHead(200,{'Content-Type':'text/css'});
    response.end(style);
  }else if(request.url == "/script.js"){
    response.writeHead(200,{'Content-Type':'text/javascript'});
    response.end(scripts);
  }else{
    response.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
        response.write('<h1>404 - O arquivo não existe</h1>');
  }

}).listen(3000,function(){
  console.log('Servidor rodando em localhost:3000');
})
```
Resultado:


text:
# Node.js - Aula 05 - Exercício
**User:** ronal2do
**Author:** Ronaldo Lima
**Date:**  1468036239552

##### [Exercício-01](#instale-algum-gerenciador-de-vers%C3%A3o-do-nodejs-e-instale-a-vers%C3%A3o-mais-atual-como-padr%C3%A3o-enquanto-escrevo-%C3%A9-a-vers%C3%A3o-540)

##### [Exercício-02](#inicie-um-projeto-novo-para-essa-aula-com-o-npm-e-instale-salvando-no-packagejson)

##### [Exercício-03](#crie-e-execute-um-script-via-npm-que-mostre-uma-mensagem-no-console-com-a-global-que-possui-caminho-para-o-diret%C3%B3rio-atual)

##### [Exercício-04](#cite-5-globais-do-nodejs-e-pelo-menos-1-exemplo-de-cada)

##### [Exercício-05](#explique-como-funciona-e-de-um-exemplo-de-process)

## [Parte 02 ](#nodejs---aula-05-parte-02---exerc%C3%ADcio)

## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0

```
npm install -g webpack
/usr/local/bin/webpack -> /usr/local/lib/node_modules/webpack/bin/webpack.js
/usr/local/lib
└─┬ webpack@1.13.1
  ├─┬ node-libs-browser@0.5.3
  │ └── events@1.1.1
  ├── uglify-js@2.6.4
  └─┬ watchpack@0.2.9
    └─┬ chokidar@1.6.0
      ├─┬ is-binary-path@1.0.1
      │ └── binary-extensions@1.5.0
      └─┬ readdirp@2.1.0
        ├── minimatch@3.0.2
        └── set-immediate-shim@1.0.1

```

```
npm install -g webpack@2.1.0-beta.15
/usr/local/bin/webpack -> /usr/local/lib/node_modules/webpack/bin/webpack.js
- amdefine@1.0.0 node_modules/webpack/node_modules/amdefine
- etc ...
```

## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:

```js
sh-3.2# cat package.json
{
  "name": "aula05",
  "version": "0.0.1",
  "description": "Exercício proposto em aula",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "aula05",
    "test"
  ],
  "author": "ronal2do",
  "license": "MIT"
}

```
* Dependência local

```
npm install --save react

```
* Dependência local
```
npm install --save-dev jasmine

```
* Dependência local
```
npm install --save-optional colors
```
Package.json

```js
sh-3.2# cat package.json
{
  "name": "aula05",
  "version": "0.0.1",
  "description": "Exercício proposto em aula",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "aula05",
    "test"
  ],
  "author": "ronal2do",
  "license": "MIT",
  "dependencies": {
    "react": "^15.2.1"
  },
  "devDependencies": {
    "mocha": "^2.5.3"
  },
  "optionalDependencies": {
    "colors": "^1.1.2"
  }
}

```

## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.

```js
sh-3.2# cat package.json
{
  "name": "aula05",
  "version": "0.0.1",
  "description": "Exercício proposto em aula",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "dir": "node dir.js"
  },
  "keywords": [
    "aula05",
    "test"
  ],
  "author": "ronal2do",
  "license": "MIT",
  "dependencies": {
    "gulp": "^3.9.1",
    "react": "^15.2.1"
  },
  "devDependencies": {
    "jasmine": "^2.4.1",
    "mocha": "^2.5.3"
  },
  "optionalDependencies": {
    "colors": "^1.1.2"
  }
}
```
```js
sh-3.2# cat dir.js
console.log("Meu diretório atual é:" + __dirname);
```
```js
sh-3.2# npm run dir

> aula05@0.0.1 dir /Users/ronaldolima/testes/npm
> node dir.js

Meu diretório atual é:/Users/ronaldolima/testes/npm
```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.

*__dirname*

```js
console.log(__dirname);
```

*__filename*

```js
console.log(__filename);
```

*Buffer*

```js
const buff = new Buffer('Sou um buffer');
console.log(buff.toString());
```

*setTimeout*

```js
setTimeout(()=>{
  console.log('atrasado');
}, 3000);

```

*console*

```js
console.log('Qualquer coisa');

```

## Explique como funciona e de um exemplo de `process`.

Process é um objeto global e é uma instância de `EventEmiter`.

```js
'use strict';

process.nextTick(() => {
	console.log('Eu sou um async');
});
```

# Node.js - Aula 05 parte 02 - Exercício

## File System

### Criar um arquivo.

```js
'use strict';

const fs = require('fs');

fs.writeFile("./arquivo.txt","Salve Loko, fui gerado no Node", (err) => {
  if (err) throw err;
  console.log('File created!');
});
```

Saída:

```
sh-3.2# node create.js && ls
File created!
arquivo.txt	   create.js
```

### Ler um arquivo.

```js
'use strict';

const fs = require('fs');

fs.readFile('mensagem.txt', (err, data) => {
  if (err) throw err;
  console.log(data.toString());
});
```

Saída:

```
sh-3.2# node read.js && ls
Salve Loko, fui gerado no Node
arquivo.txt	  create.js	  read.js
```

### Editar conteúdo desse arquivo.
```js
'use strict';

const fs = require('fs');

fs.readFile('mensagem.txt', 'utf-8', (err, data) => {
    if (err) throw err;

    const content = data + "\n Sou um novo conteúdo adicionado ao arquivo.";

    fs.writeFile('mensagem.txt', content, 'utf-8', (err) => {
        if (err) throw err;
        console.log(content);
    });
});
```

Saída:

```js
sh-3.2# node update.js && ls
Salve Loko, fui gerado no Node
Salve Loko, fui gerado no Node Editado.
arquivo.txt	create.js	read.js		update.js
```

### Deletar arquivo.
```js
'use strict';

const fs = require('fs');

fs.unlink('mensagem.txt', (err) => {
  if (err) throw err;
  console.log('Arquivo deletado com sucesso.');
});
```
Saída:
```
sh-3.2# node delete.js && ls
File destroyed!
create.js	delete.js	read.js		update.js
```
### Renomear o arquivo.
```js
'use strict';

const fs = require('fs');

fs.rename("./arquivo.txt", 'arquivo-renomeado.txt', (err, data) => {
  if (err) throw err;
  console.log('File renamed!');
});

```
Saída:
```
sh-3.2# node rename.js && ls
arquivo-renomeado.txt	delete.js		rename.js
create.js		read.js			update.js
```
# Desafio: Criar um servidor web de arquivos estáticos (CSS, HTML, JS).

app.js
```js
'use strict';

let http = require('http')
  , fs   = require('fs');

http.createServer((req, res)=>{
    if( req.url!=="/" ) {

        let url = "." + req.url;
        fs.readFile(url, (err, data)=>{

            if(err) {
                res.writeHead(404, {'Content-Type': 'text/html'});
                res.write(' <link rel="stylesheet" href="app.css">');
                res.write('<div class="Container"><h1>404</h1></div>');
                res.end();
            } else {
                let type = 'text/' + url.match(/[^\.]+$/g);
                res.writeHead(200, {'Content-Type': type});
                res.write(data);
                res.end();
            }

        });

    } else {

        res.writeHead(200, {'Content-Type': 'text/html'});
        let html = fs.readFileSync('./index.html', 'utf8');
        res.write(html);
        res.end();
    }

}).listen(3000, ()=>{
    console.log('Aplicação rodando em localhost:3000')
});
```

### Acessando HTML

![HTML](https://s32.postimg.org/kuccoljrl/site.png)

### Pagina Não Encontrada.

![404](https://s32.postimg.org/je0u6ggup/404.png)

repo_language: JavaScript

mime_type: text/plain


text:
# Node.js - Aula 05 - Exercício

**User:** [Cerezini](https://github.com/Cerezini)

**Autor:** Mateus Cerezini Gomes

## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0

```shell
> curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh | bash

> nvm install node

> node -v
v5.9.0

> npm -v
3.7.3
```

## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:

- 1 dependência local
- 1 dependência local de desenvolvimento
- 1 dependência local opcional

```shell
> mkdir aula5
> cd aula5
> npm init

> npm i -S moment
> npm i -D react
> npm i -O q

> cat package.json

{
  "name": "aula5",
  "version": "0.0.1",
  "description": "Projeto teste aula 5",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "nodejs",
    "aula5",
    "teste"
  ],
  "author": "Cerezini",
  "license": "ISC",
  "dependencies": {
    "moment": "^2.12.0"
  },
  "devDependencies": {
    "react": "^0.14.7"
  },
  "optionalDependencies": {
    "q": "^1.4.1"
  }
}
```

## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.

```shell
> echo "console.log(__dirname);" > script.js
```

Modifica o arquivo packages.json

```json
"scripts": {
  "test": "echo \"Error: no test specified\" && exit 1",
  "dir": "node script.js"
}
```

```shell
> npm run dir
~/Documentos/Curso/testes/nodejs/aula5
```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.

1. console
2. \__dirname
3. \__filename
4. process
5. require

```js
//1
console.log('potato bread');

//2 e 3
console.log(__dirname);
console.log(__filename);

//4
console.log('Program PID: ', process.pid);

//5
const http = require('http');
```

## Explique como funciona e de um exemplo de `process`.

Process é um objeto global que contém informações referentes ao processo nodejs executando no SO.

```js
//Mostrar PID
>console.log('Program PID: ', process.pid);
Program PID:  5039

//Mostrar caminho do executável node
>console.log('Executable path: ', process.execPath);
Executable path:  ~/.nvm/versions/node/v5.9.0/bin/node

//Finalizar processo
>process.exit(0);
```

## Criar um arquivo

```js

const fs = require('fs');

fs.writeFile('potato.txt', 'Um pão de batata, calzone, essas coisas.', 'utf8', (err) => {
  if (err) throw err;
  console.log('Arquivo criado!');
});

Arquivo criado!
```

## Ler um arquivo

```js
fs.readFile('potato.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

Um pão de batata, calzone, essas coisas.
```

## Editar conteúdo desse arquivo

```js
fs.readFile('potato.txt', 'utf8', (err, data) => {
  if (err) throw err;

  data += ' O meu pai? Romero Brito? Guarapari? Búzios, minha arte?'

  fs.writeFile('potato.txt', data, 'utf8', (err) => {
    if (err) throw err;
    console.log('Arquivo editado!');
  });
});

Arquivo editado!
```

## Deletar arquivo

```js
fs.unlink('calzone.txt', (err) => {
  if (err) throw err;
  console.log('Arquivo deletado!');
});

Arquivo deletado!
```

## Renomear o arquivo

```js
fs.rename('potato.txt', 'calzone.txt', (err) => {
  if (err) throw err;
  console.log('Arquivo renomeado!');
});

Arquivo renomeado!
```

## Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc... UTILIZANDO SOMENTE `fs` E `http`

```js
'use strict';

const http = require('http'),
	fs = require('fs'),
	path = require('path');

http.createServer(function(req, res){
	let file = path.basename(req.url),
		ext = path.extname(file),
		contentType = '';

	switch (ext) {
		case 'html':
			contentType = 'text/html';
			break;
		case 'css':
			contentType = 'text/css';
			break;
		case 'js':
			contentType = 'application/javascript';
			break;
		case 'png':
			contentType = 'image/jpeg';
			break;
		default:
			contentType = 'text/html';
			break;
	}

	fs.readFile(file, 'utf8', (err, data) => {
		if (err) {
			res.writeHead(500, {"Content-Type": "text/html"});
			res.end(err.toString());
		} else {
			res.writeHead(200, {"Content-Type": contentType});
			res.end(data);
		}
	});

}).listen(3000, function(){
	console.log('Servidor rodando em localhost:3000');
});
```


text:
# Node.js - Aula 05 - Exercício

**user:** [fauker](http://github.com/fauker)

**autor:** LUCAS DA SILVA MOREIRA

## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```
 lucasmoreira@faukbook  ~  nvm install 6.0.0
######################################################################## 100,0%
Checksums empty
Now using node v6.0.0
 lucasmoreira@faukbook  ~  node -v
v6.0.0
 lucasmoreira@faukbook  ~  nvm current
v6.0.0
 lucasmoreira@faukbook  ~ 
```

## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
npm init
```

- 1 dependência local
```
npm install --save angularjs
```
- 1 dependência local de desenvolvimento
```
npm install --save-dev mocha
```
- 1 dependência local opcional
```
npm install --save-optional restangular
```

```
cat package.json
{
  "name": "be-mean-instagram-nodejs",
  "version": "1.0.0",
  "description": "Guia de referência do conteúdo ministrado no módulo **Nodejs** do curso gratuíto [*Construa seu Instagram com MEAN*](http://dagora.net/be-mean/) da [Webschool.io](https://github.com/Webschool-io/)",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/fauker/be-mean-instagram-nodejs.git"
  },
  "author": "",
  "license": "ISC",
  "bugs": {
    "url": "https://github.com/fauker/be-mean-instagram-nodejs/issues"
  },
  "homepage": "https://github.com/fauker/be-mean-instagram-nodejs#readme",
  "dependencies": {
    "angularjs": "0.0.1"
  },
  "devDependencies": {
    "mocha": "^2.4.5"
  },
  "optionalDependencies": {
    "restangular": "^1.5.2"
  }
}
```

## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```
script.js -> console.log
"scripts": {
  "test": "echo \"Error: no test specified\" && exit 1",
  "dir": "node script.js"
},
npm run dir

> be-mean-instagram-nodejs@1.0.0 dir /Users/lucasmoreira/Documents/dev/projects/Be MEAN Instagram /be-mean-instagram-nodejs
> node script.js
```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```
//1
console.log(__dirname);
//2
console.log(__filename);
//3
var buffer = new Buffer('Oie');
console.log(buffer.toString());
//4
console.log(process.pid)
//5
var express = require('express');
```

## Explique como funciona e de um exemplo de `process`.
O `process` é um objeto global do `node` e pode ser acessado de qualquer
lugar. É uma instância do `EventEmitter`.

```
process.title
'node'
```

## Criar um arquivo
```
var fs = require('fs');

var write = fs.writeFileSync('file.txt', 'Oieee!!!!');

ls
createFile.js
file.txt
```

## Ler um arquivo
```
var fs = require('fs');

fs.readFile('file.txt', 'utf-8', function(err, data) {
  if (err) throw err;
  console.log(data);
});

node readFile.js
Oieee!!!!
```

## Editar conteúdo desse arquivo
```
var fs = require('fs');

fs.readFile('file.txt', 'utf-8', function(err, data) {
  if (err) throw err;
  console.log('conteúdo antigo: ' + data);
  var novoConteudo = 'Novo conteúdo';
  fs.writeFileSync('file.txt', novoConteudo);
});

node editFile.js
conteúdo antigo: Oieee!!!!
cat file.txt
Novo conteúdo%
```

## Renomear o arquivo
```
var fs = require('fs');

fs.rename('file.txt', 'fileAlterado.txt', function(err, data) {
  if (err) throw err;
  console.log(data);
});

node renameFile.js
undefined
ls
createFile.js    readFile.js
editFile.js      renameFile.js
fileAlterado.txt
```

## Deletar arquivo
```
var fs = require('fs');

fs.unlink('fileAlterado.txt', function(err) {
  if (err) throw err;
  console.log('Sucesso ao remover o arquivo fileAlterado.txt');
});

node deleteFile.js
Sucesso ao remover o arquivo fileAlterado.txt
```


text:
# Node.js - Aula 05 - Exercício

**user:** [fernandobd42](https://github.com/fernandobd42)
**autor:** Fernando Lucas

## 1 - Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
**Instalando NVM**
```
wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.32.1/install.sh | bash

```

**Instalando versão atual do Node**
```
➜  Node_BeMean nvm install node
v7.0.0 is already installed.
Now using node v7.0.0
```

## 2 - Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
➜  Node_BeMean mkdir New_Project
➜  Node_BeMean cd New_Project
➜  New_Project npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
name: (New_Project) New_Project
Sorry, name can no longer contain capital letters.
name: (New_Project) new_project
version: (1.0.0)
description: project nodejs-bemean
entry point: (index.js)
test command:
git repository:
keywords:
author: Fernando Lucas
license: (ISC)
About to write to /home/fernando/Documentos/Node_BeMean/New_Project/package.json:

{
  "name": "new_project",
  "version": "1.0.0",
  "description": "project nodejs-bemean",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Fernando Lucas",
  "license": "ISC"
}

Is this ok? (yes)

➜  New_Project ls
package.json

```

**Dependência Local**
```
npm i --save bower
```

**Dependência de desenvolvimento**
```
npm i --save-dev gulp
```

**Dependência opcional**
```
npm i --save-optional colors
```

**package.json**
```
➜  New_Project cat package.json
{
  "name": "new_project",
  "version": "1.0.0",
  "description": "project nodejs-bemean",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Fernando Lucas",
  "license": "ISC",
  "dependencies": {
    "bower": "^1.8.0"
  },
  "devDependencies": {
    "gulp": "^3.9.1"
  },
  "optionalDependencies": {
    "colors": "^1.1.2"
  }
}
```

##  - Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
**Cógido arquiro dir.js**
```
console.log(__dirname);
```

**Código package.json**
```
{
  "name": "new_project",
  "version": "1.0.0",
  "description": "project nodejs-bemean",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "dirpath": "node dir.js"
  },
  "author": "Fernando Lucas",
  "license": "ISC",
  "dependencies": {
    "bower": "^1.8.0"
  },
  "devDependencies": {
    "gulp": "^3.9.1"
  },
  "optionalDependencies": {
    "colors": "^1.1.2"
  }
}
```

**Código para mostrar o caminho**
```
➜  New_Project npm run-script dirpath

> new_project@1.0.0 dirname /home/fernando/Documentos/Node_BeMean/New_Project
> node dir.js

/home/fernando/Documentos/Node_BeMean/New_Project

```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
**console -> exibe mensagem no console**
```
console.log('Printando');
```

**__filename -> exibe o caminho do arquivo que está sendo executado**
```
console.log(__filename)
```

**__dirname -> exibe o caminho do diretório em que o arquivo está inserido**
```
console.log(__dirname)
```

**require() -> importa um módulo do node**
```
require('http')
```

**setTimeout() -> define uma latência para exibir/executar determinada instrução**
```
setTimeout(() =>  {
  console.log('Latência de 5 segundos para exibir esta mensagem');
  }, 5000);
```

## Explique como funciona e de um exemplo de `process`.
  Process é uma instância do EventEmitter, é uma variável global que emite eventos.

**exibe caminho do node**
```
console.log(process.execPath);
```

**exibe o diretorio atual**
```
console.log(process.cwd());
```

## Criar um arquivo
```
const fs = require('fs');

fs.writeFile('./file.txt','Criando arquivo', (err) => {
  if (err) throw err;
  console.log('Arquivo Criado!');
})
```

## Ler um arquivo
```
const fs = require('fs');

fs.readFile('./file.txt', (err, data) => {
  if (err) throw err;
  console.log(data.toString());
});
```

## Editar conteúdo desse arquivo
```
const fs = require('fs');

fs.readFile('./file.txt', (err, data) => {
  data += ' e Editando';
fs.writeFile('./file.txt', data, (err) => {
    if (err) throw err;
  })
console.log(data.toString());
});
```

## Renomear o arquivo
```
const fs = require('fs');

fs.rename('./file.txt', './file_renamed.txt', (err, data) => {
  if (err) throw err;
  console.log('Arquivo renomeado com sucesso.');
});
```

## Deletar arquivo
```
const fs = require('fs');

fs.unlink('./file_renamed.txt', (err) => {
  if (err) throw err;
  console.log('Arquivo deletado com sucesso.');
});
```


text:
# Node.js - Aula 05 - Exercício

**user:** [FranciscoValerio](https://github.com/FranciscoValerio)

**autor:** Francisco Henrique Ruiz Valério

## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0

```
PS C:\Users\franc> npm -v
3.3.12
PS C:\Users\franc> node -v
v5.4.1
```

## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:

   * 1 dependência local
   * 1 dependência local de desenvolvimento
   * 1 dependência local opcional

```
PS C:\Be-Mean\NodeJS\arquivos-api> npm i --save mongoose
PS C:\Be-Mean\NodeJS\arquivos-api> npm i --save-dev colors
PS C:\Be-Mean\NodeJS\arquivos-api> npm i --save-optional colors
PS C:\Be-Mean\NodeJS\arquivos-api> cat .\package.json
{
   "name": "arquivos-api",
   "version": "0.0.1",
   "description": "API que fornece arquivos",
   "main": "index.js",
   "scripts": {
      "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
    "arquivos",
    "css",
    "html",
    "js"
   ],
   "author": "FranciscoValerio",
   "license": "WTFPL",
   "dependencies": {
      "mongoose": "^4.3.6"
   },
   "devDependencies": {
      "jasmine": "^2.4.1"
   },
   "optionalDependencies": {
    "colors": "^1.1.2"
  }
}
```

## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.

```
//package.json
"scripts": {
   "roda": "node script.js"
}

//Arquivo script.js
console.log( __dirname );

PS C:\Be-Mean\NodeJS\arquivos-api> npm run roda
> arquivos-api@0.0.1 roda C:\Be-Mean\NodeJS\arquivos-api
> node script.js
C:\Be-Mean\NodeJS\arquivos-api
```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.

**require:** Usamos quando queremos chamar um módulos do NodeJS.
```JS
require('http');
```

**__dirname:** Usada para obter o caminho do diretório atual.
```JS
console.log(__dirname);
```

**__filename:** Usada quando queremos obter o caminho do arquivo atual.
```JS
console.log(__filename);
```

**Buffer:** Usada para inserir algo no buffer

```JS
var buffer = new Buffer('I am Buffer!');
console.log(buffer.toString());
```

**process.pid:** Usado quando queremos obter o id do processo sendo executado na máquina.
```JS
console.log(process.pid);
```

## Explique como funciona e de um exemplo de `process`.

O objeto process é um objeto global e pode ser acessado de qualquer lugar. É uma instância de EventEmitter. Normalmente é utilizado quando queremos executar algo quando algum evento ocorrer.

```JS
//Um exemplo que registra cada rejeição não processada para o console

process.on('unhandledRejection',  (reason, p)  =>  {
   console.log("Rejeição Unhandled em: Promise", p,  "razão:", reason);
});

// e aqui um exemplo que irá chamar o unhandledRejection
somePromise.then((response) => {
  return reportToUser(JSON.parse(response));
});
```

##Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...

Os arquivos podem ser encontrados aqui:
(https://github.com/FranciscoValerio/server-files)

**servidor.js:**
```
'use strict';

const http = require( 'http' ),
fs   = require('fs'),
port = 3000;

try{
   fs.accessSync( 'arquivos', fs.F_OK );
}catch (e){
   fs.mkdirSync( 'arquivos' );
}

http.createServer( function( req, res ){

   var path = 'arquivos' + req.url;

   try{
      fs.accessSync( path, fs.R_OK );

      if( fs.lstatSync( path ).isDirectory() ){
         res.writeHeader( 200, { "Content-Type": "text/html;charset=utf-8" } );
         try{
            var indexPath = path + '/index.html';
            res.write( fs.readFileSync( indexPath, 'utf-8' ) );
         }catch(e){
            var files = fs.readdirSync(path);
            files.forEach(file =>{
               res.write('<a href="' + req.url + '/' + file + '">' + file + '</a><br>' );
            });
         }
      }else{
         var typeFile = path.split(".");
         switch(typeFile[typeFile.length-1]){
            case 'css':
               res.writeHeader(200, {"Content-Type": "text/css"});
               break;
            case 'html':
               res.writeHeader(200, {"Content-Type": "text/html;charset=utf-8"});
               break;
            case 'jpg':
               res.writeHeader(200, {"Content-Type": "image/jpeg"});
               break;
            case 'png':
               res.writeHeader(200, {"Content-Type": "image/png"});
               break;
            case 'gif':
               res.writeHeader(200, {"Content-Type": "image/gif"});
               break;
          }
          res.write(fs.readFileSync(path));
      }
   } catch(e){
      res.writeHeader(404, {"Content-Type": "text/html;charset=utf-8"});
      res.write( fs.readFileSync( 'arquivos/not_found.html' ) );
   }

   res.end();

}).listen(port, () => {
    console.log('Waiting in port: ' + port );
});
```

**not_found.js:**
```HTML
<!DOCTYPE html>
<html>
   <head>
      <meta charset="utf-8">
      <title>Servidor de arquivos - Desafio -</title>
      <style>

         body {
            background: url('/img/beer.jpg');
            background-repeat: no-repeat;
            background-size: 100%;
         }

         h1 {
            font-size: 140px;
         }

         h2 {
            font-size: 40px;
         }
      </style>
   </head>
   <body>
      <h1>404 :(</h1>
      <h2>
         Beer not found...
         <br>
         Ops...
         <br>
         Page not found...
      </h2>

   </body>
</html>
```

**Rodando:**

**Home:**
!['Home'](https://github.com/FranciscoValerio/server-files/blob/master/arquivos/img/home.jpg)

**Arquivos JS:**
!['ArquivosJS'](https://github.com/FranciscoValerio/server-files/blob/master/arquivos/img/files.jpg)

**404 - Not found:**
!['404'](https://github.com/FranciscoValerio/server-files/blob/master/arquivos/img/not-found.jpg)


text:
# Node.js - Aula 05 - Exercício
**user:** [ednilsonamaral](https://github.com/ednilsonamaral)
**autor:** Ednilson Amaral

## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0

`node -v`

Saída:

```
ednilson@EDNILSON-NB:~$ node -v
v5.5.0
```

`npm -v`

Saída:

```
ednilson@EDNILSON-NB:~$ npm -v
3.3.12
```

## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios05$ cat package.json
{
  "name": "aula05",
  "version": "1.0.0",
  "description": "Exercícios da Aula 05 de NodeJS do curso Be MEAN",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "node",
    "mean",
    "webschool"
  ],
  "author": "Ednilson Amaral",
  "license": "WTFPL"
}
```

### 1 dependência local; 1 dependência local de desenvolvimento; 1 dependência local opcional

`npm install -S gulp`
`npm install --save-dev jasmine`
`npm install -O moongose`

Arquivo `package.json`:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios05$ cat package.json
{
  "name": "aula05",
  "version": "1.0.0",
  "description": "Exercícios da Aula 05 de NodeJS do curso Be MEAN",
  "main": "index.js",
  "scripts": {
    "executa": "node script.js"
  },
  "keywords": [
    "node",
    "mean",
    "webschool"
  ],
  "author": "Ednilson Amaral",
  "license": "WTFPL",
  "dependencies": {
    "gulp": "^3.9.0"
  },
  "devDependencies": {
    "jasmine": "^2.4.1"
  },
  "optionalDependencies": {
    "mongoose": "^4.3.7"
  }
}
```

## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios05$ npm run executa

> aula05@1.0.0 executa /var/www/be-mean-instagram-nodejs/exercicios05
> node script.js

O diretório atual é listado abaixo:
/var/www/be-mean-instagram-nodejs/exercicios05
```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.

### `__dirname`

Ele mostra o caminho do diretório em que o script atual se encontra. Exemplo:

Em nosso arquivo JS temos:

```js
//script.js
console.log(__dirname);
```

Executando, temos:

```
//node
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$ node script.js
/var/www/be-mean-instagram-nodejs
```

### `__filename`

Ele mostra o caminho do diretório do arquivo que está sendo executado se encontra.

Em nosso arquivo JS temos:

```js
console.log(__filename);
```

Executando, temos:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$ node script.js
/var/www/be-mean-instagram-nodejs/script.js
```

### `setTimeout()`

É uma função global usada para chamar uma função callback após X milissegundos.

Em nosso arquivo JS temos:

```js
function mostra(){
	console.log("Hello, world!");
}

setTimeout(mostra, 3000);
```

Executando, temos:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$ node script.js
Hello, world, após 3 segundos!
```

### `clearTimeout()`

Também é uma função global, utilizada para párar o cronômetro que foi criada no `setTimeout()`.

Em nosso arquivo JS temos:

```js
function printHello(){
   console.log( "Hello, World, após 2 segundos e depois dá um CLEAR!");
}

var t = setTimeout(printHello, 5000);

clearTimeout(t);
```

### `setInterval()`

É uma função global utilizada para executar uma função callback repetidamente após os milissegundos declarados. Para mátar o serviço devemos declarar um `clearInterval()` na função `setTimeout()`.

Em nosso arquivo JS temos:

```js
const time = setInterval(() => console.log("Hello, again and again and again!"), 1000);

setTimeout(() => {
  clearInterval(time);
}, 5000);
```

Executando, temos:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$ node script.js
Hello, again and again and again!
Hello, again and again and again!
Hello, again and again and again!
Hello, again and again and again!
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$
```

## Explique como funciona e de um exemplo de `process`.

É um objeto global que pode ser acessado de qualquer lugar e é uma instância de **EventEmitter**, ou seja, eles emitem eventos. Ele é útil para podermos identificar algumas informações sobre o ambiente de tempo de execução de um aplicativo, os argumentos passados, o diretório atual, etc.

No exemplo abaixo, vemos o processo *exit* do evento, que é emitido quando está prestes a sair. Assim que todos as funções dentro do processo estiverem terminadas, ele vai sair, ou seja, *exit*.

```js
process.on('exit', function(code) {
  setTimeout(function() {
    console.log("Está rodando essa bagaça!");
  }, 0);

  console.log('Sobre esse código:', code);
});

console.log("Código finalizado, vlw flw!");
```

## Criar um arquivo

Arquivo `create.js`:

```js
//criando o arquivo de forma async
var fs = require('fs');

fs.writeFile("./arquivo.txt", "Hello, world!", function(err, result){
  if (err) throw err;

  console.log(result);
});
```

Saída no terminal:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node create.js
undefined

ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ ls
arquivo.txt  create.js

ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ cat arquivo.txt
Hello, world!
```

## Ler um arquivo

Arquivo `read.js`:

```js
//lendo o arquivo de forma async
var fs = require('fs');

fs.readFile('arquivo.txt', 'utf-8', function (err, data){
  if (err) throw err;

  console.log(data);
});
```

Saída no terminal:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node read.js
Hello, world!
```

## Editar conteúdo desse arquivo

Arquivo `edit.js`:

```js
//editando o arquivo de forma async

//primeiro, leio o arquivo; se não der erro na leitura, então acrescento uma nova linha com texto
var fs = require('fs');

fs.readFile('arquivo.txt', 'utf-8', function (err, data) {
  if (err) throw err;

  var update = data + "\nNovo conteúdo no arquivo!";

  fs.writeFile('arquivo.txt', update, 'utf-8', function (err){
    if (err) throw err;

    console.log(update);
  });
});
```

Saída no terminal:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node edit.js
Hello, world!
Novo conteúdo no arquivo!
```

## Deletar arquivo

Arquivo `delete.js`:

```js
//deletando o arquivo de forma async
var fs = require('fs');

fs.unlink('arquivo.txt', function (err){
  if (err) throw err;
});
```

Saída no terminal:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node delete.js
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$
```

## Renomear o arquivo

Arquivo `rename.js`:

```js
//renomeando arquivo de forma async
var fs = require('fs');

fs.rename('arquivo.txt', 'arquivoRenomeado.txt', function (err, data) {
  if (err) throw err;
});
```

Saída no terminal:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node rename.js
/var/www/be-mean-instagram-nodejs/fs/rename.js:5
  if (err) throw err;
           ^

Error: ENOENT: no such file or directory, rename 'arquivo.txt' -> 'arquivoRenomeado.txt'
    at Error (native)
```

Deu esse erro aí porque o arquivo foi deletado, né! Hehehe'

## Desafio

Arquivo `server.js`:

```js
var http = require('http');
var fs = require('fs');

http.createServer(function (request, response){
var path = 'desafio'+ request.url;

//verificando se ele encontra o diretorio, caso não encontre, criar
try{
  fs.accessSync('desafio', fs.F_OK);
} catch (e){
  fs.mkdirSync('desafio');
}

try{
  fs.accessSync(path, fs.R_OK);

  if(fs.lstatSync(path).isDirectory()){
    response.writeHeader(200, {"Content-Type": "text/html"});

    try{
      var indexPath = path+'/index.html';
      response.write(fs.readFileSync(indexPath, 'utf-8'));
    }catch(e){
      var dir = fs.readdirSync(path);

      dir.forEach(nome =>{
        response.write('<a href="'+ request.url +'/'+ nome +'">'+ nome +'</a><br>');
      });
    }
  } else {
    var typeFile = path.split(".");

    switch(typeFile[typeFile.length-1]){
      case 'css':
        response.writeHead(200, {"Content-Type": "text/css"});
        break;
      case 'html':
        response.writeHead(200, {"Content-Type": "text/html"});
        break;
      case 'jpg':
        response.writeHead(200, {"Content-Type": "image/jpeg"});
        break;
      case 'gif':
        response.writeHead(200, {"Content-Type": "image/gif"});
        break;
    }

    response.write(fs.readFileSync(path));
  }
} catch(e){
  response.writeHeader(404, {"Content-Type": "text/html;charset=utf-8"});
  response.write('Página não encontrada');
}

response.end();

}).listen(3000, function(){
  console.log("Servidor rodando em localhost:3000");
});
```

Print no Navegador:

![Desafio](https://raw.githubusercontent.com/ednilsonamaral/be-mean-instagram-nodejs/master/img/desafio.png)


text:
# NodeJS - Aula 05 - Exercício
autor: Wellerson Roberto

# 1) Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão.

Antes do gerenciados de versão:

```
node -v
v5.4.1
```

Versão mais nova no momento que faço esse exercício: 5.6.0

Usei o versionador **nvm-windows**.

Instalando a última versão:
```
nvm install latest
```

Definindo o Node.js em uso:
```
C:\Users\Wellerson>nvm use 5.6.0
Now using node v5.6.0 (64-bit)

C:\Users\Wellerson>node -v
v5.6.0
```

# 2) Inicie um projeto novo pra esse aula, com o **npm** e instale, salvando no **package.json** 1 dependência local, 1 dependência local de desenvolvimento e 1 dependência local opcional:

Iniciando o package.json:
```
npm init
```

Instalando dependência local:
```
npm i consign --save
```

Instalando dependência local de desenvolvimento:
```
npm i mocha --save-dev
```

Instalando dependência opcional:
```
npm i colors --save-optional
```

Package.json ao final:
```
{
  "name": "exercicio",
  "version": "1.0.0",
  "description": "Fazendo exercicio do curso Be Mean",
  "main": "index.js",
  "scripts": {
    "test": "]"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "consign": "^0.1.2"
  },
  "devDependencies": {
    "mocha": "^2.4.5"
  },
  "optionalDependencies": {
    "colors": "^1.1.2"
  }
}
```

# 3) Crie e execute um script, via **npm**, que mostre uma mensagem no console com a global que possui caminho para o diretório atual:

Script:

```
console.log(__dirname);
```

Package.json:

```
...
 "scripts": {
    "roda": "node global.js"
  }
...
```

No console:
```
npm run roda

> exercicio@1.0.0 roda D:\Developer\Curso Mean\workshop-be-mean\nodejs\exercicio rapido
> node global.js

D:\Developer\Curso Mean\workshop-be-mean\nodejs\exercicio rapido
```

# 4) Cite 5 globais do Node.js e pelo menos um exemplo de cada:

**console**

Módulo que provê um console pra depurar.

```
console.log('Testando')
```

**__filename**

Mostra o caminho e o nome do arquivo do script que está sendo executado.

```
console.log(__filename)
```

**require**

Usado para requirir outros módulos

```
var mongoose = require('mongoose');
```

**Buffer**

Usado para lidar com dados binários.
```
var buff = new Buffer('Treinando!');
console.log(buff.toString());
```

**global**

O objeto que representa o namespace global do Node.js.

```
global.curso = 'Be Mean';

console.log(global.curso);
```

# 5) Explique como funciona e dê um exemplo de 'process':

O objeto global **process** é basicamente um **wrapper** do processo atual, sendo uma instância do **EventEmitter**.

Uma das propriedades desse objeto é o **argv**, que trás uma array com todos os argumentos da linha de comando usado para executar o script.

```
console.log(process.argv);

[ 'D:\\NodeJS\\node.exe', 'D:\\Developer\\Curso Mean\\workshop-be-mean\\nodejs\\exercicio rapido\\global' ]
```


text:
# Node.js - Aula 05 - Exercício

**user:** [DouglasHennrich](https://github.com/DouglasHennrich)

**autor:** Douglas Hennrich

## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
Escolhi baixar o [NVM](https://github.com/creationix/nvm).
`node -v v5.4.1`

## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```js
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
name: (pokemon-api)
version: (1.0.0) 0.0.1
description: API para os pokemons
entry point: (index.js)
test command:
git repository:
keywords: api, pokemons, teta
author: Douglas Hennrich
license: (ISC)
About to write to /Users/Odin/Documents/Curso/NodeJS/Exercícios/pokemon-api/package.json:

{
  "name": "pokemon-api",
  "version": "0.0.1",
  "description": "API para os pokemons",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "api",
    "pokemons",
    "teta"
  ],
  "author": "Douglas Hennrich",
  "license": "ISC"
}
```

* 1 dependência local:
  `npm install --save pm2`

* 1 dependência local de desenvolvimento:
  `npm install --save--dev jasmine`

* 1 dependência local opcional:
  `npm install --save-optional colors`

**package.json atualizado**
```js
{
  "name": "pokemon-api",
  "version": "0.0.1",
  "description": "API para os pokemons",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "api",
    "pokemons",
    "teta"
  ],
  "author": "Douglas Hennrich",
  "license": "ISC",
  "dependencies": {
    "pm2": "^1.0.0"
  },
  "optionalDependencies": {
    "colors": "^1.1.2"
  }
}
```

## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
**whereIm.js**
```js
console.log('Where Im ? ', __dirname);
```

**package.json**
```js
"scripts": {
  "test": "echo \"Error: no test specified\" && exit 1"
  , "where": "node whereIm.js"
  }
```

**npm run**
```js
npm run where

> pokemon-api@0.0.1 where /Users/Odin/Documents/Curso/NodeJS/Exercícios/pokemon-api
> node whereIm.js

Where Im ?  /Users/Odin/Documents/Curso/NodeJS/Exercícios/pokemon-api
```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
1. `__dirname` retorna o nome do diretório o qual o script está sendo rodado.
  ```js
  console.log(__dirname); // /Users/Odin/Documents/Curso/NodeJS/Exercícios/pokemon-api
  ```

2. `setTimeout` executa uma função após determinado tempo em milisegundos.
  ```js
  setTimeout(function(){
    console.log('Mostra esse log após 1 segundo');
  }, 1000);
  ```

3. `setInterval` executa a mesma função, a cada milisegundo pré-definido, até ser parado.
  ```js
  setInterval(function(){
    console.log('A cada 1 segundo, esse log vai aparecer!');
  }, 1000);
  ```

4. `require` usado para requirir um módulo ou script.
  ```js
  "use strict";

  var meuScript = require('./meu_script');
  ```

5. `clearInterval` para a execução de um intervalo.
  ```js
  var intervalo = setInterval(function(){
    console.log('Só vai ser executado uma vez, depois será eliminado.');
    clearInterval(intervalo);
  }, 1000);
  ```

## Explique como funciona e de um exemplo de `process`.
Process é uma instancia do [EventEmitter](https://nodejs.org/api/events.html#events_class_events_eventemitter) e é uma variável Global do **NodeJS**. Como ele provem de um módulo de **eventos**, ele funciona "ouvindo" eventos e disparando callbacks sobre esses eventos capturados. Embora alguns eventos são de "mão única", não precisam de um callback.

```js
process.abort();  // Fecha o processo do NodeJS em si
```

## Criar um arquivo
```js
var fs = require('fs');

fs.writeFile('./pokemons.txt', 'Pikachu, Bulbasauro, Squirtle, Charmander', 'utf-8', function(err){
  if(err) throw err;
  console.log('arquivo criado');
});
```

## Ler um arquivo
```js
var fs = require('fs');

fs.readFile('./pokemons.txt', 'utf-8', function(err, data){
  if(err) throw err;
  console.log('Pokemons: ', data); // Pokemons:  Pikachu, Bulbasauro, Squirtle, Charmander
});
```

## Editar conteúdo desse arquivo
```js
var fs = require('fs');

fs.readFile('./pokemons.txt', 'utf-8', function(err, data){
  if(err) throw err;
  console.log('Pokemons: ', data); // Pokemons:  Pikachu, Bulbasauro, Squirtle, Charmander

  fs.writeFile('./pokemons.txt', data + ', Charizard, Blastoise, Suissa', 'utf-8', function(err){
    if(err) throw err;
    console.log('Editado :D');
  });
});
```

## Deletar arquivo
```js
var fs = require('fs');

fs.unlink('./pokemons.txt', function(err){
  if(err) throw err;
  console.log('arquivo deletado!');
});
```

## Renomear o arquivo
```js
var fs = require('fs');

fs.rename('whereIm.js', 'editado.js', function(err){
  if(err) throw err;
  console.log('arquivo renomeado');
});
```

## Desafio

**app.js**
```js
'use strict';

/*
@ Requires
*/
const http = require('http')
  , fs = require('fs')
  , path = require('path')
  , porta = process.env.PORT || 3000
  ;

/*
@ Paths
*/
const html_path = __dirname + '/public';

/*
@ Server
*/
const server = http.createServer((req, res)=>{
  let file = req.url
    , contentType = 'text/html'
    ;

  if(file == '/' ) {
    file = '/hello.html';
  }

  file = html_path + file;
  let extname = path.extname(file);

  //Verifica os tipos de arquivo
  switch ( extname.toLowerCase() ) {
    case '.js':
       contentType = 'text/javascript';
       break;
    case '.css':
       contentType = 'text/css';
       break;
    case '.jpg':
    case '.jpeg':
       contentType = 'image/jpeg';
       break;
  }

  try {
    fs.accessSync(file, fs.F_OK);

    fs.readFile(file, (err, data) =>{
      if(err){
        res.writeHead(500);
        res.end();

      }else{

        if(extname == '.css'){
          res.setHeader("Content-Type", contentType);
          res.end(data);

        }else{
          res.writeHead(200, { contentType: contentType });
          res.end(data, 'utf-8');
        }
      }
    });

  } catch (e) {
    fs.readFile(html_path + '/not-found.html', (err, data) =>{
      if(err){
        res.writeHead(500);
        res.end();

      }else{
        res.writeHead(200, { contentType: 'text/html' });
        res.end(data);
      }
    });
  }

})
  .listen(porta, ()=>{
    console.log('Static Server on localhost:' + porta);
  });
```

**Screen Shots**
![](https://github.com/DouglasHennrich/be-mean-nodejs-exercicio05/blob/master/static.png)

![](https://github.com/DouglasHennrich/be-mean-nodejs-exercicio05/blob/master/not-found.png)


text:
# Node.js - Aula 05 - Exercício

**user:** https://github.com/paulosilva92

**autor:** Paulo Roberto da Silva

**date:** Sun Mar 06 2016 00:53:19 GMT-0300 (BRT)

## Instale algum gerenciador de versão do Node.js e instale a versão mais atua como padrão.

##### Instalação do NVM
```
➜  bemean curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh | bash
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  7766  100  7766    0     0   5608      0  0:00:01  0:00:01 --:--:--  5607
=> Downloading nvm from git to '/home/paulo/.nvm'
=> Cloning into '/home/paulo/.nvm'...
remote: Counting objects: 4402, done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 4402 (delta 0), reused 0 (delta 0), pack-reused 4399
Receiving objects: 100% (4402/4402), 1.10 MiB | 67.00 KiB/s, done.
Resolving deltas: 100% (2582/2582), done.
Checking connectivity... done.
* (HEAD detached at v0.31.0)
  master

=> Appending source string to /home/paulo/.zshrc
=> You currently have modules installed globally with `npm`. These will no
=> longer be linked to the active version of Node when you install a new node
=> with `nvm`; and they may (depending on how you construct your `$PATH`)
=> override the binaries of modules installed with `nvm`:

/usr/lib
├── lodash@4.6.1
├── nativescript@1.6.1
├── nodemon@1.9.1

=> If you wish to uninstall them at a later point (or re-install them under your
=> `nvm` Nodes), you can remove them from the system Node as follows:

     $ nvm use system
     $ npm uninstall -g a_module

=> Close and reopen your terminal to start using nvm
```

##### Instalação da versão mais atual do Node.js

```
➜  bemean nvm install node
Downloading https://nodejs.org/dist/v5.7.1/node-v5.7.1-linux-x64.tar.xz...
######################################################################## 100,0%
Now using node v5.7.1 (npm v3.6.0)
Creating default alias: default -> node (-> v5.7.1)
➜  bemean node -v
v5.7.1
```

## Inicie um projeto novo para essa aula, com o npm e instale, salvando no package.json

```
➜  exercicios git:(master) ✗ mkdir projeto-exercicio
➜  exercicios git:(master) ✗ cd projeto-exercicio
➜  projeto-exercicio git:(master) ✗ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
name: (projeto-exercicio)
version: (1.0.0)
description: "projeto de exercicio para o modulo de nodejs do bemean"
entry point: (index.js)
test command:
git repository:
keywords:
author: Paulo Roberto da Silva
license: (ISC)
About to write to /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio/package.json:

{
  "name": "projeto-exercicio",
  "version": "1.0.0",
  "description": "\"projeto de exercicio para o modulo de nodejs do bemean\"",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Paulo Roberto da Silva",
  "license": "ISC"
}

Is this ok? (yes)
```

### 1 dependência local

```
➜  projeto-exercicio git:(master) ✗ npm i express -S
projeto-exercicio@1.0.0 /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
└─┬ express@4.13.4
  ├─┬ accepts@1.2.13
  │ ├─┬ mime-types@2.1.10
  │ │ └── mime-db@1.22.0
  │ └── negotiator@0.5.3
  ├── array-flatten@1.1.1
  ├── content-disposition@0.5.1
  ├── content-type@1.0.1
  ├── cookie@0.1.5
  ├── cookie-signature@1.0.6
  ├─┬ debug@2.2.0
  │ └── ms@0.7.1
  ├── depd@1.1.0
  ├── escape-html@1.0.3
  ├── etag@1.7.0
  ├─┬ finalhandler@0.4.1
  │ └── unpipe@1.0.0
  ├── fresh@0.3.0
  ├── merge-descriptors@1.0.1
  ├── methods@1.1.2
  ├─┬ on-finished@2.3.0
  │ └── ee-first@1.1.1
  ├── parseurl@1.3.1
  ├── path-to-regexp@0.1.7
  ├─┬ proxy-addr@1.0.10
  │ ├── forwarded@0.1.0
  │ └── ipaddr.js@1.0.5
  ├── qs@4.0.0
  ├── range-parser@1.0.3
  ├─┬ send@0.13.1
  │ ├── destroy@1.0.4
  │ ├─┬ http-errors@1.3.1
  │ │ └── inherits@2.0.1
  │ ├── mime@1.3.4
  │ └── statuses@1.2.1
  ├── serve-static@1.10.2
  ├─┬ type-is@1.6.12
  │ └── media-typer@0.3.0
  ├── utils-merge@1.0.0
  └── vary@1.0.1

npm WARN projeto-exercicio@1.0.0 No repository field.
```

### 1 dependência local de desenvolvimento

```
➜  projeto-exercicio git:(master) ✗ npm i gulp -D

projeto-exercicio@1.0.0 /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
└─┬ gulp@3.9.1
  ├── archy@1.0.0
  ├─┬ chalk@1.1.1
  │ ├─┬ ansi-styles@2.2.0
  │ │ └── color-convert@1.0.0
  │ ├── escape-string-regexp@1.0.5
  │ ├─┬ has-ansi@2.0.0
  │ │ └── ansi-regex@2.0.0
  │ ├── strip-ansi@3.0.1
  │ └── supports-color@2.0.0
  ├── deprecated@0.0.1
  ├─┬ gulp-util@3.0.7
  │ ├── array-differ@1.0.0
  │ ├── array-uniq@1.0.2
  │ ├── beeper@1.1.0
  │ ├─┬ dateformat@1.0.12
  │ │ ├── get-stdin@4.0.1
  │ │ └─┬ meow@3.7.0
  │ │   ├─┬ camelcase-keys@2.0.0
  │ │   │ └── camelcase@2.1.0
  │ │   ├── decamelize@1.2.0
  │ │   ├─┬ loud-rejection@1.3.0
  │ │   │ ├── array-find-index@1.0.1
  │ │   │ └── signal-exit@2.1.2
  │ │   ├── map-obj@1.0.1
  │ │   ├─┬ normalize-package-data@2.3.5
  │ │   │ ├── hosted-git-info@2.1.4
  │ │   │ ├─┬ is-builtin-module@1.0.0
  │ │   │ │ └── builtin-modules@1.1.1
  │ │   │ └─┬ validate-npm-package-license@3.0.1
  │ │   │   ├─┬ spdx-correct@1.0.2
  │ │   │   │ └── spdx-license-ids@1.2.0
  │ │   │   └─┬ spdx-expression-parse@1.0.2
  │ │   │     └── spdx-exceptions@1.0.4
  │ │   ├── object-assign@4.0.1
  │ │   ├─┬ read-pkg-up@1.0.1
  │ │   │ ├─┬ find-up@1.1.2
  │ │   │ │ ├── path-exists@2.1.0
  │ │   │ │ └─┬ pinkie-promise@2.0.0
  │ │   │ │   └── pinkie@2.0.4
  │ │   │ └─┬ read-pkg@1.1.0
  │ │   │   ├─┬ load-json-file@1.1.0
  │ │   │   │ ├── graceful-fs@4.1.3
  │ │   │   │ ├─┬ parse-json@2.2.0
  │ │   │   │ │ └─┬ error-ex@1.3.0
  │ │   │   │ │   └── is-arrayish@0.2.1
  │ │   │   │ ├── pify@2.3.0
  │ │   │   │ └── strip-bom@2.0.0
  │ │   │   └── path-type@1.1.0
  │ │   ├─┬ redent@1.0.0
  │ │   │ ├─┬ indent-string@2.1.0
  │ │   │ │ └─┬ repeating@2.0.0
  │ │   │ │   └─┬ is-finite@1.0.1
  │ │   │ │     └── number-is-nan@1.0.0
  │ │   │ └── strip-indent@1.0.1
  │ │   └── trim-newlines@1.0.0
  │ ├─┬ fancy-log@1.2.0
  │ │ └── time-stamp@1.0.0
  │ ├─┬ gulplog@1.0.0
  │ │ └── glogg@1.0.0
  │ ├─┬ has-gulplog@0.1.0
  │ │ └── sparkles@1.0.0
  │ ├── lodash._reescape@3.0.0
  │ ├── lodash._reevaluate@3.0.0
  │ ├── lodash._reinterpolate@3.0.0
  │ ├─┬ lodash.template@3.6.2
  │ │ ├── lodash._basecopy@3.0.1
  │ │ ├── lodash._basetostring@3.0.1
  │ │ ├── lodash._basevalues@3.0.0
  │ │ ├── lodash._isiterateecall@3.0.9
  │ │ ├─┬ lodash.escape@3.2.0
  │ │ │ └── lodash._root@3.0.1
  │ │ ├─┬ lodash.keys@3.1.2
  │ │ │ ├── lodash._getnative@3.9.1
  │ │ │ ├── lodash.isarguments@3.0.8
  │ │ │ └── lodash.isarray@3.0.4
  │ │ ├── lodash.restparam@3.6.1
  │ │ └── lodash.templatesettings@3.1.1
  │ ├─┬ multipipe@0.1.2
  │ │ └─┬ duplexer2@0.0.2
  │ │   └── readable-stream@1.1.13
  │ ├── object-assign@3.0.0
  │ ├── replace-ext@0.0.1
  │ ├─┬ through2@2.0.1
  │ │ ├─┬ readable-stream@2.0.5
  │ │ │ ├── core-util-is@1.0.2
  │ │ │ ├── isarray@0.0.1
  │ │ │ ├── process-nextick-args@1.0.6
  │ │ │ ├── string_decoder@0.10.31
  │ │ │ └── util-deprecate@1.0.2
  │ │ └── xtend@4.0.1
  │ └─┬ vinyl@0.5.3
  │   ├── clone@1.0.2
  │   └── clone-stats@0.0.1
  ├── interpret@1.0.0
  ├─┬ liftoff@2.2.0
  │ ├── extend@2.0.1
  │ ├─┬ findup-sync@0.3.0
  │ │ └─┬ glob@5.0.15
  │ │   ├── inflight@1.0.4
  │ │   ├── minimatch@3.0.0
  │ │   └── path-is-absolute@1.0.0
  │ ├── flagged-respawn@0.3.1
  │ ├── rechoir@0.6.2
  │ └── resolve@1.1.7
  ├── minimist@1.2.0
  ├─┬ orchestrator@0.3.7
  │ ├─┬ end-of-stream@0.1.5
  │ │ └─┬ once@1.3.3
  │ │   └── wrappy@1.0.1
  │ ├── sequencify@0.0.7
  │ └── stream-consume@0.1.0
  ├── pretty-hrtime@1.0.2
  ├── semver@4.3.6
  ├─┬ tildify@1.1.2
  │ └── os-homedir@1.0.1
  ├─┬ v8flags@2.0.11
  │ └── user-home@1.1.1
  └─┬ vinyl-fs@0.3.14
    ├── defaults@1.0.3
    ├─┬ glob-stream@3.1.18
    │ ├── glob@4.5.3
    │ ├─┬ glob2base@0.0.12
    │ │ └── find-index@0.1.1
    │ ├─┬ minimatch@2.0.10
    │ │ └─┬ brace-expansion@1.1.3
    │ │   ├── balanced-match@0.3.0
    │ │   └── concat-map@0.0.1
    │ ├── ordered-read-streams@0.1.0
    │ ├─┬ through2@0.6.5
    │ │ └── readable-stream@1.0.33
    │ └── unique-stream@1.0.0
    ├─┬ glob-watcher@0.0.6
    │ └─┬ gaze@0.5.2
    │   └─┬ globule@0.1.0
    │     ├─┬ glob@3.1.21
    │     │ ├── graceful-fs@1.2.3
    │     │ └── inherits@1.0.2
    │     ├── lodash@1.0.2
    │     └─┬ minimatch@0.2.14
    │       ├── lru-cache@2.7.3
    │       └── sigmund@1.0.1
    ├── graceful-fs@3.0.8
    ├─┬ mkdirp@0.5.1
    │ └── minimist@0.0.8
    ├─┬ strip-bom@1.0.0
    │ ├── first-chunk-stream@1.0.0
    │ └── is-utf8@0.2.1
    ├─┬ through2@0.6.5
    │ └── readable-stream@1.0.33
    └─┬ vinyl@0.4.6
      └── clone@0.2.0

```

### 1 dependência local opcional

```
➜  projeto-exercicio git:(master) ✗ npm i ejs -S
projeto-exercicio@1.0.0 /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
└── ejs@2.4.1

npm WARN projeto-exercicio@1.0.0 No repository field.
```

## Crie um *script*, via npm, que mostre uma mensagem no console com a global que possui o caminho para o diretório atual

##### Código do arquivo *path.js*

```
console.log(process.cwd());
```

##### Criação do script no package.json

```js
"scripts": {
    "caminho": "node path.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
```

##### Execução do script

```
➜  projeto-exercicio git:(master) ✗ npm run-script caminho

> projeto-exercicio@1.0.0 caminho /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
> node path.js

/home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
```

## Cite 5 globais do Node e pelo menos 1 exemplo de cada

##### __filename

Contém o caminho do arquivo que está sendo executado.

```js
console.log(__filename);
// /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/teste.js
```

##### require();

Utilizado para importar módulos. Tem-se que passar para essa função o caminho onde o módulo se encontra.

```js
const modulo = require('./modulos/modulo.js');
```

##### console

Utilizado para mostrar saidas de texto ou conteudos de variaveis,funções objetos e etc.

```js
> console.log('Ola %s', 'Mundo');
Ola Mundo
```

##### setInterval

Roda uma função repetidamente durante a cada periode de tempo determinado pelo usuário. Essa função recebe dois parâmetros, o primeiro parâmetro é a função que será repetida e o segundo é o tempo entre cada repetição em milisegundos.

```js
setInterval(function(){
  console.log('intervalo');
  },1000)
```

##### setTimeout

Roda uma função após determinado tempo. Essa função recebe dois parâmetros, o primeiro é a função a ser repetida e o segundo é o tempo em milisegundos.

```js
setTimeout(function(){
  console.log('intervalo');
  },2000);
```

## Explique como funciona e de um exemplo de *process*

*process* é uma instância do *EvenEmitter*, ou seja, um objeto global que contém, além de métodos, eventos. É utilizado para manipuar e ver algumas informações sobre o ambiente de execução da aplicação.

```js
setTimeout(function(){
  console.log('intervalo');
  },2000);
console.log(process.uptime()); //mostra a quantidade de tempo que a aplicação está em execução
//Resposta :
//  0.101
//  intervalo
```

## Criar um arquivo

```js
const fs = require('fs');
fs.writeFileSync('teste.txt', 'Esse é um texto para o arquivo de teste', 'utf-8');
```

## Ler um arquivo

```js
var teste = fs.readFileSync('./teste.txt', 'utf-8');
console.log(teste);
//Esse é um texto para o arquivo de teste
```

## Editar um arquivo

```js
fs.writeFileSync('teste.txt', 'Esse é um texto modificado para fazer update no arquivo de teste', 'utf-8');
var teste = fs.readFileSync('./teste.txt', 'utf-8');
console.log(teste);
//Esse é um texto modificado para fazer update no arquivo de teste
```

## Deletar um arquivo

```js
fs.unlinkSync('./teste.txt');
```

## Renomear um arquivo

```js
fs.renameSync('./teste.txt', './novoteste.txt');
var teste = fs.readFileSync('./novoteste.txt', 'utf-8');
console.log(teste);
```

## Desafio: Criar um servidor web de arquivos estáticos: css, html, js e etc;

Colocar este código num arquivo com nome de `app.js` e rodar com o node

```js
const http = require('http');
const fs = require('fs');

http.createServer((req, res)=> {
  fs.readFile(__dirname + req.url, function (err,data) {
    if (err) {
      res.writeHead(404);
      console.log(err);
      res.end("Página não encontrada");
      return;
    }
    res.writeHead(200);
    res.end(data);
  });
}).listen(3000, ()=>{
    console.log('Server rodando na porta 3000');
});
```

Colocando no navegador `http://localhost:3000/app.js` veremos então o código do nosso arquivo que cria o servidor


text:
# Node.js - Aula 05 - Exercício
**user:** [xereda](https://github.com/xereda)
**autor:** Jackson Ricardo Schroeder

## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0

```

nvm install 6.2.1
Downloading https://nodejs.org/dist/v6.2.1/node-v6.2.1-darwin-x64.tar.gz...
######################################################################## 100,0%
Now using node v6.2.1 (npm v3.9.3)

node -v
v6.2.1

npm -v
3.9.3

```

## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:

```

npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
name: (npm) exercicio05-nodejs
version: (1.0.0) 0.0.1
description: Exercício da aula 05 de NodeJS
entry point: (index.js)
test command:
git repository:
keywords: nodejs node aulas aula05 javascript bemean
author: Jackson Ricardo Schroeder
license: (ISC)
About to write to /Users/xereda/Sites/bemean/nodejs/aula05/npm/package.json:

{
  "name": "exercicio05-nodejs",
  "version": "0.0.1",
  "description": "Exercício da aula 05 de NodeJS",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "nodejs",
    "node",
    "aulas",
    "aula05",
    "javascript",
    "bemean"
  ],
  "author": "Jackson Ricardo Schroeder",
  "license": "ISC"
}

Is this ok? (yes) yes

```

- 1 dependência local

```

npm install --save mongoose

```
- 1 dependência local de desenvolvimento

```

npm install --save-dev jasmine

```
- 1 dependência local opcional

```

npm install --save-optional color

```

- Arquivo package.json atualizado

```js

cat package.json
{
  "name": "exercicio05-nodejs",
  "version": "0.0.1",
  "description": "Exercício da aula 05 de NodeJS",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "nodejs",
    "node",
    "aulas",
    "aula05",
    "javascript",
    "bemean"
  ],
  "author": "Jackson Ricardo Schroeder",
  "license": "ISC",
  "dependencies": {
    "mongoose": "^4.4.20"
  },
  "devDependencies": {
    "jasmine": "^2.4.1"
  },
  "optionalDependencies": {
    "color": "^0.11.1"
  }
}

```

## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.

```js

// script.js
console.log("Diretório atual: " + __dirname);

// package.json
"scripts": {
  "test": "echo \"Error: no test specified\" && exit 1",
  "aula": "node script.js"
}

> exercicio05-nodejs@0.0.1 aula /Users/xereda/Sites/bemean/nodejs/aula05/npm
> node script.js

Diretório atual: /Users/xereda/Sites/bemean/nodejs/aula05/npm

```

## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.

```js

//interacao com o console do nodejs (console)
console.log(__dirname);   // __dirname outra global que apresenta o caminho do diretorio atual
console.log(__filename);  // __filename outra global que apresenta o caminho e o nome do módulo atual
require("http");          // require é uma global que requere e incorpora um módulo

// setInterval e setTimeout são exemplos de funcoes globais
// no exemplo abaixo, estamos executando uma rotina a cada dois segundos
const rotina2sec = setInterval(() => {
   console.log("Vai executar a cada 2 segundos: " + Date.now());
}, 2000);

// abaixo a funcao global setTimeout() vai encerrar a execucao
// da rotina acima apos 8 segundos, para isso usamos clearInterval() como parametro
setTimeout(() => {

  console.log("vai encerrar a rotina...");
  clearInterval(rotina2sec);

}, 9000);

```

## Explique como funciona e de um exemplo de `process`.

É um objeto global que pode ser acessado de qualquer lugar e é uma instância de EventEmitter. Alguns eventos suportados pelo process EventEmitter:

- **exit**
- **beforeExit**
- **uncaughtException**
- **Signal Events**

```js

//process.js
"use strict";

const http = require("http");

process.nextTick(() => console.log("Eu sou uma async"));

console.log(process.execPath);
console.log(process.cwd());
console.log(process.pid);

const server = http.createServer((req, res) => {

  res.write("vai sair no browser");
  res.end();

});

server.listen(3000, () => console.log("Servidor rodando na porta 3000"));

process.on("SIGINT", () => {

  console.log("finalizando o servidor");
  process.exit(0);

});

// executando o process.js
node process.js
/usr/local/bin/node
/Users/xereda/Sites/bemean/nodejs/aula05/npm
1819
Eu sou uma async
Servidor rodando na porta 3000
^Cfinalizando o servidor

```

## File System

### Criar um arquivo.

```js

// criar.js
var fs = require('fs')
var write = fs.writeFileSync("ola.txt","Olá mundo!");

$> node criar.js
$> ls
criar.js ola.txt

```

### Ler um arquivo.

```js

// ler.js
var fs = require('fs');

fs.readFile('ola.txt', 'utf8', (err, data) => {
	if (err) throw err;
	console.log(data);
});

$> node ler.js
Olá mundo!

```

### Editar conteúdo desse arquivo.

```js

// file: editar.js
"use strict";

var fs = require('fs');

fs.readFile('ola.txt', 'utf-8', (err, data) => {

	if (err) throw err;

  var update = data + "\nNovo conteúdo no arquivo!";

  fs.writeFile('ola.txt', update, 'utf-8',  err => {

		if (err) throw err;

    console.log(update);

  });
});

$> node editar.js
Olá mundo!
Novo conteúdo no arquivo!

$> more ola.txt
Olá mundo!
Novo conteúdo no arquivo!

```

### Renomear o arquivo.

```js

// renomear.js
var fs = require('fs');

fs.rename('ola.txt', 'ola_renomeado.txt', err => {
	if (err) throw err;
})

$> ls
criar.js editar.js ler.js ola.txt renomear.js

$> node renomear.js

$> ls
criar.js editar.js ler.js ola_renomeado.txt renomear.js

```

### Deletar arquivo.

```js

// file: excluir.js
var fs = require('fs');

fs.unlink('ola_renomeado.txt', err => {
  if (err) throw err;
});

$> ls
criar.js editar.js excluir.js ler.js ola_renomeado.txt renomear.js

$> node excluir.js

$> ls
criar.js editar.js excluir.js ler.js renomear.js

```

## Desafio: Criar um servidor web de arquivos estáticos.

```js

"use strict";

const http 		= require("http");
const url 		= require("url");
const path 		= require("path");
const fs 			= require("fs");
const port 		= process.argv[2] || 8888;

http.createServer((request, response) => {

  var uri = url.parse(request.url).pathname
    , filename = path.join(process.cwd(), uri);

  fs.exists(filename, (exists) => {
    if(!exists) {
      response.writeHead(404, {"Content-Type": "text/html; charset=utf-8"});
      response.write("404 = Arquivo não encontrado\n");
      response.end();
      return;
    }

    if (fs.statSync(filename).isDirectory()) filename += '/index.html';

    fs.readFile(filename, "binary", (err, file) => {
      if(err) {
        response.writeHead(500, {"Content-Type": "text/html; charset=utf-8"});
        response.write(err + "\n");
        response.end();
        return;
      }

      response.writeHead(200);
      response.write(file, "binary");
      response.end();
    });
  });
}).listen(parseInt(port, 10));

console.log("Static file server rodando em \n  => http://localhost:" + port + "/\nCTRL + C to parar execução do servidor");

```


text:
# Node.js - Aula 07 - Exercício

**user:** [FranciscoValerio](https://github.com/FranciscoValerio)

**autor:** Francisco Henrique Ruiz Valério

#1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).#

**arquivo (eventEmitter.js)**
```JS
'use strict';

const EventEmitter = require( 'events' ).EventEmitter;
const util         = require( 'util' );

function Aviso ( data ) {
   this.data = data
   this.on('aviso:init', sendInit);
   this.on('error', sendError);
   EventEmitter.call( this );
}

Aviso.prototype.init = function () {
   if ( this.data.msg ){
      this.emit('aviso:init', this.data);
   } else {
      this.emit('error', new TypeError('Message empty!' ) );
   }
};

util.inherits( Aviso, EventEmitter );

function sendInit( data ) {
   console.log(data.msg);
}

function sendError( err ) {
  throw err;
}

module.exports = Aviso;
```

**arquivo (emitter.js)**
```JS
'use strict';

const Aviso = require( './eventEmitter' );

const aviso = new Aviso({ msg: 'class-07'});

aviso.init();
```

#2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.#

**arquivo (read-dir.js)**
```JS
'use strict';

const fs = require( 'fs' );

function readDirectory(path){
   return new Promise(function(resolve, reject){
      fs.readdir( path, (err, data) => {
        err ? reject( err ) : resolve( data );
      });
   });
}

module.exports = readDirectory;
```

**arquivo (promisse-all)**
```JS
'use strict';

function promiseAll(arr){
   return Promise.all(arr).then( function success(res){
      return res;
   })
   .catch(function error(err){
      throw err;
   });
}

module.exports = promiseAll;
```

**arquivo (app.js)**
```JS
'use strict';
const promiseAll    = require( './promisse-all' );
const readDirectory = require( './read-dir'  );

promiseAll([
   readDirectory( './'  ),
   readDirectory( '../'  ),
])
.then( res => console.log('resposta:', res))
.catch(err => console.error('error:', err));
```

#3 - Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.#

**methods**
> 1 - find().
> 2 - delete().
> 3 - update().

**Exemplo: 1 - find()**
```JS
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/francisco');
const Pokemon = require( './pokemon');

let promise = Pokemon.find({}).exec();
promise.then(success, error);

function success(data){
   console.log('retorno: ', data );
}

function error(err){
   console.error('erro: ', err );
}
```

**Exemplo: 2 - delete()**
```JS
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/francisco');
const Pokemon = require( './pokemon');

let promise = Pokemon.remove({
   _id: '56aa9ca4eabaf61c0fffc3e9'
}).exec();
promise.then(success, error);

function success(data){
   console.log('retorno: ', data );
}

function error(err){
   console.error('erro: ', err );
}
```

**Exemplo: 3 - update()**
```JS
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/francisco');
const Pokemon = require( './pokemon');

const pokemon = {
   name: "Francisco",
   type: "Fire",
   attack: 88,
   defence: 99,
   height: 1.85,
   description: "man"
};

let promise = Pokemon.update({
   _id: '56aa9ca4eabaf61c0fffc3e9'},
   pokemon
).exec();
promise.then(success, error);

function success(data){
   console.log('retorno: ', data );
}

function error(err){
   console.error('erro: ', err );
}
```


text:
# Node.js - Aula 07 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim

### 1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).

#### ex1_init_event.js
```js
'use strict';

const EventEmitter = require('events').EventEmitter;
const util = require('util');

function BazingaEmitter (data) {
    this.data = data;
    this.on('init', init);
    EventEmitter.call(this);
}

BazingaEmitter.prototype.init = function () {
    this.emit('init', this.data);
};

util.inherits(BazingaEmitter, EventEmitter);

function init (data) {
    console.log('init =>', data.text);
}

module.exports = BazingaEmitter;
```

#### ex1_init_event_main.js
```js
'use strict';

const BazingaEmitter = require( './ex1_init_event.js' );
const myBazingaEmitter = new BazingaEmitter({ text: 'Bazinga!!!'});

myBazingaEmitter.init();
```

#### Saída
```
$ node ex1_init_event_main.js
init => Bazinga!!!
```

### 2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.

#### ex2_readdir_promise.js
```js
'use strict';

const fs =  require('fs');

function readDir(path) {
    return new Promise(function (resolve, reject) {
        fs.readdir(path, function (err, res) {
            err ? reject(err) : resolve(res);
        });
    });
}

module.exports = readDir;
```

#### ex2_readdir_promise_main.js
```js
'use strict';

const readDir = require('./ex2_readdir_promise.js');

function myPromiseAll(arr) {
    return Promise.all(arr)
    .then(result => { return result; })
    .catch(err => { throw err; });
}

myPromiseAll([
    readDir('../class07'),
    readDir('../class02')
])
.then(result => console.log(result))
.catch(err => console.log(err));
```

### 3 - Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.

#### 3 - sem `exec()`:
- `find`,
- `create`,
- `remove`

#### 3 - com `exec()`:
- `find`,
- `findOne`,
- `update`

#### ex3_mongoose_promise.js
```js
'use strict';

// Conexão com o mongo
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-modulo-nodejs-exercises');

// Definição do Schema
const Schema = mongoose.Schema;
const bandsSchema = new Schema({
  name:  String
});

// Definição do Model
const BandsModel = mongoose.model('bands', bandsSchema);

const band1 = {
    name: 'Manonas assassinas'
};

// 3 métodos - sem exec()

const findPromise = BandsModel.find({name: 'Linkin Park'});
findPromise.then(success, error);
// [ { name: 'Linkin Park', _id: 56ff424dcb3f181e1d0ae7a6 } ]

const createPromise = BandsModel.create(band1)
createPromise.then(success , error);
// { _id: 56ff4d03d20057e62669be34, name: 'Manonas assassinas', __v: 0 }

const removePromise = BandsModel.remove({name : band1.name });
removePromise.then(success , error);
// result: { ok: 1, n: 1 }

// 3 métodos - com exec()

const findPromiseExec = BandsModel.find({name: 'Ramones'}).exec();
findPromiseExec.then(success, error);
//[ { name: 'Ramones', _id: 56ff422bcb3f181e1d0ae7a5 } ]

const findOnepromise = BandsModel.findOne({ name: 'Metallica' }).exec();
findOnepromise.then(success , error);
//{ name: 'Metallica', _id: 56ff3ef8cb3f181e1d0ae7a4 }

const updatePromise = BandsModel.update({ name : 'Metallica'}, {name: '+Metallica'}).exec();
updatePromise.then(success , error);
//{ ok: 1, nModified: 1, n: 1 }

function success(data) {
    console.log(data);
}

function error (err) {
    console.log(err);
}
```


text:
# Node.js - Aula 07 - Exercício
**user:** [ednilsonamaral](https://github.com/ednilsonamaral)
**autor:** Ednilson Amaral

## 1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 como base (use ele no prototype).

`eventEmitter.js`
```js
'use strict';

//chamando os módulos necessários
const EventEmitter = require('events').EventEmitter;
const util = require('util');

//ouvindo
function HelloWorld(data){
  this.data = data;
  this.on('hello:init', showInit);
  this.on('erro', showError);

  EventEmitter.call(this);
}

//emitindo
HelloWorld.prototype.init = function() {
  if (this.data.msg) {
    this.emit('hello:init', this.data);
  } else {
    this.emit('erro', new TypeError('Nenhuma mensagem para mostrar'));
  }
};

//utilizando o util para herança, inserção de objetos, logs, etc
util.inherits(HelloWorld, EventEmitter);

//função do showInit;
function showInit (data){
  console.log(data.msg);
}

//função do showError
function showError (err){
  throw err;
}

//criando a mensagem para ser mostrada
const mensagem = new HelloWorld({msg: 'Olá, mundo!'});
mensagem.init();
```

Saída no terminal:
```
$ node event.js
Olá, mundo!
```

## 2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.

`readFilesPromise.js`

```js
'use strict';

const fs = require('fs');

function readDir (path) {
  return new Promise(function (res, rej) {
    fs.readdir(path, function (err, data) {
      err ? rej(err) : res(res);
    });
  });
}

readDir('./exemplos/')
  .then(function (data) {
    success(data);
  })
  .catch(function (err){
    error(err);
  });

function success (data) {
  console.log(data);
}

function error (err) {
  console.log(err);
}
```

Saída no terminal:

```
$ node readFilesPromise.js
[Function]
```

Fiz um segundo teste, alterando o caminho desejado, de `./exemplos/` para `./exemploo/`, então obtive o segundo erro, assumindo o estado de *reject*:

```
$ node readFilesPromise.js
{ [Error: ENOENT: no such file or directory, scandir './exemploo/']
  errno: -2,
  code: 'ENOENT',
  syscall: 'scandir',
  path: './exemploo/' }
```

## 3 - Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.

Os *methods* escolhidos foram:

* `create`;
* `find`;
* `update`;
* `delete`.

`createPromise.js`
```js
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bancoTeste');
const Schema = mongoose.Schema;

const _schema = {
  nome: {type: String, match: /^./i },
    idade: {type: Number, min: 1},
    sexo: {type: String, enum: ['M', 'F']},
    cidade: {type: String, maxlength: 10},
    estado: {type: String, minlength: 2}
}

const personData = {
  nome: 'Ednilson Amaral',
  idade: 24,
  sexo: 'M',
  cidade: 'Itapeva',
  estado: 'SP'
}

const personSchema = new Schema(_schema);
const Person = mongoose.model('Person', personSchema);

//create
Person.create(personData).then(success, error);

function success(data) {
  console.log('Inseriu: ', data);
}

function error (error) {
  console.log('Erro: ', error);
}
```

Saída no Terminal:

```
$ node createPromise.js
Inseriu:  { _id: 56d59b09d95812f013f70a68,
  estado: 'SP',
  cidade: 'Itapeva',
  sexo: 'M',
  idade: 24,
  nome: 'Ednilson Amaral',
  __v: 0 }
```

`findPromise.js`
```js
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bancoTeste');
const Schema = mongoose.Schema;

const _schema = {
  nome: {type: String, match: /^./i },
    idade: {type: Number, min: 1},
    sexo: {type: String, enum: ['M', 'F']},
    cidade: {type: String, maxlength: 10},
    estado: {type: String, minlength: 2}
}

const personSchema = new Schema(_schema);
const Person = mongoose.model('Person', personSchema);

const personFind = {nome: /ednilson amaral/i};

//find
let promise = Person.find(personFind).exec();
promise.then(success, error);

function success(data) {
  console.log('Encontrou: ', data);
}

function error (error) {
  console.log('Erro: ', error);
}
```

Saída no terminal:

```
$ node findPromise.js
Encontrou:  [ { __v: 0,
    estado: 'SP',
    cidade: 'Itapeva',
    sexo: 'M',
    idade: 24,
    nome: 'Ednilson Amaral',
    _id: 56d59ae24d6f8ae513f6ff1d },
  { __v: 0,
    estado: 'SP',
    cidade: 'Itapeva',
    sexo: 'M',
    idade: 24,
    nome: 'Ednilson Amaral',
    _id: 56d59b09d95812f013f70a68 } ]
```

`updatePromise.js`
```js
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bancoTeste');
const Schema = mongoose.Schema;

const _schema = {
  nome: {type: String, match: /^./i },
    idade: {type: Number, min: 1},
    sexo: {type: String, enum: ['M', 'F']},
    cidade: {type: String, maxlength: 10},
    estado: {type: String, minlength: 2}
}

const personSchema = new Schema(_schema);
const Person = mongoose.model('Person', personSchema);

//update
const personUpdate = {nome: 'Ed'};
const personId = {"_id": "56d59ae24d6f8ae513f6ff1d"};

let promise = Person.update(personId, personUpdate).exec();
promise.then(success, error);

function success(data) {
  console.log('Encontrou: ', data);
}

function error (error) {
  console.log('Erro: ', error);
}
```

Saída no terminal:

```
$ node updatePromise.js
Encontrou:  { ok: 1, nModified: 1, n: 1 }
```

`deletePromise.js`
```js
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bancoTeste');
const Schema = mongoose.Schema;

const _schema = {
  nome: {type: String, match: /^./i },
    idade: {type: Number, min: 1},
    sexo: {type: String, enum: ['M', 'F']},
    cidade: {type: String, maxlength: 10},
    estado: {type: String, minlength: 2}
}

const personSchema = new Schema(_schema);
const Person = mongoose.model('Person', personSchema);

//remove
const personId = {"_id": "56d59b09d95812f013f70a68"};

let promise = Person.remove(personId).exec();
promise.then(success, error);

function success(data) {
  console.log('Removeu: ', data);
}

function error (error) {
  console.log('Erro: ', error);
}
```

Saída no terminal:

```
$ node deletePromise.js
Removeu:  { result: { ok: 1, n: 1 },
```


text:
# Node.js - Aula 07 - Exercício

**user**: [victorvoid](https://github.com/victorvoid)

**autor**: Victor Igor Gomes Martins

**date**: 1458942620128

# Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).

```js

'use strict';

const EventEmitter = require('events').EventEmitter;
const util = require('util');

function User (data) {
  this.data = data;
  this.on('user:init', olaUser);
  this.on('error', sendError);
  EventEmitter.call(this);
}

User.prototype.init = function () {
  if(this.data.name){
    this.emit('user:init',this.data);
  }
  else {
    this.emit('error', new TypeError('User need an name'));
  }
};

util.inherits(User, EventEmitter);

function olaUser(user) {
  console.log('Olá', user.name);
}

function sendError(err) {
  throw err;
}

const user = new User({name: 'Victor'});
user.init();

```
saida:
```
node app-1.js
Olá Victor

```

# Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.

- fs-promise.js

```js
'use strict';

const fs = require('fs');

module.exports = (path)=>{
  return new Promise((resolve, reject)=>{
    fs.readdir(path, (err, files)=>{
      err ? reject(err) : resolve(files);
    });
  });
}
```

- app.js

```js

'use strict';

const readdir = require('./fs-promise');

readdir('./').then(sucess, failed);

function sucess(data){
  console.log(data);
}
function failed(err) {
  console.log(err);
}

```
saida:

```
 node app.js
[ 'app.js', 'carros.txt', 'fs-promise.js' ]

```

# Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.

- pokemon.js

```js

'use strict';

const mongoose = require('mongoose');
const util = require('util');

function pokemonHandler() {
  let Schema = mongoose.Schema;
  const ObjectId = Schema.ObjectId;

  const schema = new Schema({
    id          : ObjectId,
    name        : {type : String, trin : true},
    type        : {type : String, trin : true},
    attack      : {type : Number},
    defence     : {type : Number},
    height      : {type : Number},
    description : {type : String, trin : true}
  });

  return mongoose.model('Pokemons', schema);
}

module.exports = exports = pokemonHandler();
```

- Find

```js
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-instagram');
const Pokemon  =  require('./pokemon');

let poke = Pokemon.find({name: 'pikachu'}).exec();
poke.then(success, failed);

function success(data) {
  if(data.length <= 0)
    console.log('Nada encontrado');
  else
    console.log(data);
}

function failed (err) {
  console.log(err);
}
```

saida:

```js
node app.js
Nada encontrado

```

- FindOne

```js
'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-instagram');
const Pokemon  =  require('./pokemon');

let poke = Pokemon.findOne({_id: "56f484bffcbb4f03287baa27"}).exec();
poke.then(success, failed);

function success(data) {
  console.log(data);
}

function failed (err) {
  console.log(err);
}
```
saida:

```js

node app.js
{ __v: 0,
  created_at: Thu Mar 24 2016 20:22:23 GMT-0400 (AMT),
  height: 0.7,
  defense: 96,
  attack: 69,
  type: 'terra',
  description: 'Vai que vai',
  name: 'Atomicmon',
  _id: 56f484bffcbb4f03287baa27 }

```

- Remove

```js

'use strict';

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-instagram');
const Pokemon  =  require('./pokemon');

let poke = Pokemon.remove({_id: '56f5ac6eddb43dbb52c3e58b'}).exec();
poke.then(success, failed);

function success(data) {
  console.log(data);
}

function failed (err) {
  console.log(err);
}

```

saida:

```js
node app.js
{ result: { ok: 1, n: 1 },
  connection:
   EventEmitter {
     domain: null,
     _events:
      { close: [Object],
        error: [Object],
        timeout: [Object],
        parseError: [Object],
        connect: [Function] },
     _eventsCount: 5,
     _maxListeners: undefined,
     options:
      { socketOptions: {},
        auto_reconnect: true,
        host: 'localhost',
        port: 27017,
        cursorFactory: [Object],
        reconnect: true,
        emitError: true,
        size: 5,
        disconnectHandler: [Object],
        bson: {},
        messageHandler: [Function],
        wireProtocolHandler: {} },
     id: 0,
     logger: { className: 'Connection' },
     bson: {},
     tag: undefined,
     messageHandler: [Function],
     maxBsonMessageSize: 67108864,
     port: 27017,
     host: 'localhost',
     keepAlive: true,
     keepAliveInitialDelay: 0,
     noDelay: true,
     connectionTimeout: 0,
     socketTimeout: 0,
     destroyed: false,
     domainSocket: false,
     singleBufferSerializtion: true,
     serializationFunction: 'toBinUnified',
     ca: null,
     cert: null,
     key: null,
     passphrase: null,
     ssl: false,
     rejectUnauthorized: false,
     checkServerIdentity: true,
     responseOptions: { promoteLongs: true },
     flushing: false,
     queue: [],
     connection:
      Socket {
        _connecting: false,
        _hadError: false,
        _handle: [Object],
        _parent: null,
        _host: 'localhost',
        _readableState: [Object],
        readable: true,
        domain: null,
        _events: [Object],
        _eventsCount: 8,
        _maxListeners: undefined,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: false,
        destroyed: false,
        bytesRead: 250,
        _bytesDispatched: 226,
        _sockname: null,
        _pendingData: null,
        _pendingEncoding: '',
        _idleNext: null,
        _idlePrev: null,
        _idleTimeout: -1,
        read: [Function],
        _consuming: true },
     writeStream: null,
     hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
     buffer: null,
     sizeOfMessage: 0,
     bytesRead: 0,
     stubBuffer: null } }

```


text:
# NodeJS - Aula 07 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1458281013095

## Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).

```js

'use strict';

const EventEmitter = require('events').EventEmitter,
      util         = require('util');

function Message(data) {
    this.data = data;
    this.on('show', show);
    this.on('error', err);
    EventEmitter.call(this);
}

Message.prototype.init = function() {
    if(this.data) {
        this.emit('show', this.data.name);
    } else {
        this.emit('error', new TypeError('No name'));
    }
}

util.inherits(Message, EventEmitter);

function show(data) {
    console.log(data);
}

function err(error) {
    throw error;
}
const message = new Message({
    name: 'Igor Luíz <Halfeld>'
});

message.init();
```

## Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.

```js

'use strict';

const fs = require('fs');

function readDir(path) {
    return new Promise( (resolve, reject) => {
        fs.readdir(path, (err, data) => err ? reject(err) : resolve(data));
    });
}

function readAll(arr) {
    return Promise.all(arr)
            .then(res => { return res })
            .catch(err => { throw err });
}

readAll([
    readDir('../event-emitter'),
    readDir('../../class-5')
])
.then(res => console.log(res))
.catch(err => console.log(err));
```

## Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.

### Create

#### Código
```js

'use strict';

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/peoples');

const Schema = mongoose.Schema;

const _schema = {
    name: String,
    age: Number,
    height: Number
};

const User = mongoose.model('users', _schema);

// Create

let me = {
    name: "Igor Luíz",
    age: 17,
    height: 1.97
}

User.create(me)
    .then((data) => {
        console.log(`Inseriu isso aí véi: ${data}`);
    })
    .catch(err => {
        throw err ;
    });
```

#### Saída no terminal
```sh
$ node createPromise.js
Inseriu isso aí véi: { _id: 56eb95a5c198f9200bec1134,
  height: 1.97,
  age: 17,
  name: 'Igor Luíz',
  __v: 0 }
```

### Find

#### Código
```js

'use strict';

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/peoples');

const Schema = mongoose.Schema;

const _schema = {
    name: String
};

const User = mongoose.model('users', _schema);

// Find

let query = { name: /igor luíz/i }

let result = User.find(query).exec();
result.then((data) => {
        console.log(`Acho isso aí véi: ${data}`);
    }).catch(err => {
        throw err ;
    });
```

#### Saída no terminal

```sh
$ node findPromise.js
Acho isso aí véi: { __v: 0,
  height: 1.97,
  age: 17,
  name: 'Igor Luíz',
  _id: 56eb95a5c198f9200bec1134 }
```

### Update

#### Código
```js

'use strict';

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/peoples');

const Schema = mongoose.Schema;

const _schema = {
    name: String
};

const User = mongoose.model('users', _schema);

// Update

let query = { name: /igor luíz/i },
    mod = {name: "Igor Luíz | Halfeld"}

let result = User.update(query, mod).exec();
result.then((data) => {
        console.log(data);
    }).catch(err => {
        throw err ;
    });
```

#### Saída no terminal

```sh
$ node updatePromise.js
{ ok: 1, nModified: 1, n: 1 }
```

### Remove

#### Código
```js

'use strict';

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/peoples');

const Schema = mongoose.Schema;

const _schema = {
    name: String
};

const User = mongoose.model('users', _schema);

// Find

let query = {name: /igor luíz | halfeld/i }

let result = User.remove(query).exec();
result.then((data) => {
        console.log(data);
    }).catch(err => {
        throw err ;
    });
```

#### Saída no terminal

```sh
$ node deletePromise.js
{ ok: 1, nModified: 1, n: 1 }
```