

Bash é o nome do shell do Unix, que também é distribuído como shell do sistema 
operacional GNU e como shell padrão para a maioria das distros Linux.

Praticamente todos  os exemplos abaixo podem fazer parte de um shell script e podem ser executados
diretamente no shell.

[Leia mais sobre](http://www.gnu.org/software/bash/manual/bashref.html)

### Olá, mundo!

```bash
#!/bin/bash
# A primeira linha do script é o shebang (#!), que conta para o sistema como 
# executar o script: http://en.wikipedia.org/wiki/Shebang_(Unix)
# Como você já deve ter percebido, comentários começam com #. 
# Shebang também é um comentário.

```

Exemplo simples de hello world:

```bash
#!/bin/bash
echo Hello World!
```

Cada comando começa com uma nova linha, ou após um ponto e vírgula:

```bash
#!/bin/bash
echo 'Essa é a primeira linha'; echo 'Essa é a segunda linha'
```

### Variáveis

A declaração de variáveis é mais ou menos assim:

```bash
Variavel="Alguma string"

# Mas não assim:
Variavel = "Alguma string"
# Bash interpretará Variavel como um comando e tentará executar e lhe retornará
# um erro porque o comando não pode ser encontrado.

# Ou assim:
Variavel= 'Alguma string'
# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornará
# um erro porque o comando não pôde ser encontrado. (Nesse caso a a parte 'Variavel=' 
# é vista com uma declaração de variável válida apenas para o escopo do comando 'Uma string').
```

Usando a variável:

```bash
echo $Variavel
echo "$Variavel"
echo '$Variavel'
# Quando você usa a variável em si — declarando valor, exportando, etc — você escreve
# seu nome sem o $. Se você quer usar o valor da variável você deve usar o $.
# Note que ' (aspas simples) não expandirão as variáveis!

# Substituição de strings em variáveis
echo ${Variavel/Alguma/Uma}
# Isso substituirá a primeira ocorrência de "Alguma" por "Uma"

# Substring de uma variável
Tamanho=7
echo ${Variavel:0:Tamanho}
# Isso retornará apenas os 7 primeiros caracteres da variável

# Valor padrão de uma variável
echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"}
# Isso funciona para nulo (Foo=) e (Foo=""); zero (Foo=0) retorna 0.
# Note que isso apenas retornará o valor padrão e não mudará o valor da variável.
```

#### Variáveis especiais

Bash inclui por padrão variáveis muito úteis, como:

```bash
#!/bin/bash
echo "O ultimo retorno do programa: $?"
echo "PID do script: $$"
echo "Numero de argumentos passados para o script $#"
echo "Todos os argumentos passados para o script $@"
echo "Os argumentos do script em variáveis diferentes: $1, $2..."

# Lendo o valor do input:
echo "Qual o seu nome?"
read Nome # Note que nós não precisamos declarar a variável
echo Ola, $Nome

# Agora que sabemos como imprimir e usar variáveis,
# bora aprender alguns dos outros princípios básicos do bash! 

# Nosso diretório atual está disponível através do comando `pwd`. 
# `pwd` significa "print working directory" ou "imprima o diretório atual".
# Também podemos usar a variável especial `$PWD`.
# Observe que os seguintes comandos são equivalentes:
echo "I'm in $(pwd)" # executa o comando `pwd` e interpola seu output
echo "I'm in $PWD" # interpola o valor da variável $PWD
```
#### Arrays

```bash
# Declara uma array com 6 elementos 
array0=(um dois tres quatro cinco seis)
# Imprime o primeiro elemento
echo $array0 # => "um"
# Imprime o primeiro elemento
echo ${array0[0]} # => "um"
# Imprime todos os elementos
echo ${array0[@]} # => "um dois tres quatro cinco seis"
# Imprime número de elementos
echo ${#array0[@]} # => "6"
# Imprime o número de caracteres no terceiro elemento
echo ${#array0[2]} # => "5"
# Imprime 2 elementos a partir do quarto
echo ${array0[@]:3:2} # => "quatro cinco"
# Imprime todos os elementos. Cada um deles em nova linha. 
for i in "${array0[@]}"; do
    echo "$i"
done

# Brace Expansion { }
# Usada para gerar strings arbitrárias 
echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
# Isso imprimirá a faixa de valores do inicial ao valor final
```

### Condicionais

Nós temos a estrutura if normal:

```bash
# use 'man test' para mais informações sobre as condicionais
if [ $Nome -ne $USER ]
then
	echo "Seu nome não é o seu username"
else
	echo "Seu nome é seu username"
fi
```

A execução condicional:

```bash
echo "Sempre executado" || echo "Somente executado se o primeiro falhar"
echo "Sempre executado" && "Só executado se o primeiro NÃO falhar"

# Para usar && e || com o if, você precisa multiplicar os pares de colchetes
if [ $Nome == "Estevao"] && [ $Idade -eq 15]
then
	echo "Isso vai rodar se $Nome é igual Estevao E $Idade é 15."
fi

fi [ $Nome == "Daniela" ] || [ $Nome = "Jose" ] 
then
	echo "Isso vai rodar se $Nome é Daniela ou Jose."
fi
```

### Expressões e execução de comandos
```bash
# Expressões são escritas com o seguinte formato
echo $(( 10 + 5))

# Diferentemente das outras linguagens de programação, bash é um shell, então ele 
# funciona no diretório atual. Você pode listar os arquivos e diretórios no diretório
# atual com o comando ls:
ls

# Esse comando tem opções que controlam sua execução
ls -l # Lista todo arquivo e diretório em linhas separadas

# Os resultados do comando anterior podem ser passados para outro comando como input.
# O comando grep filtra o input com o padrão passado. É assim que listamos apenas
# os arquivos .txt no diretório atual:
ls -l | grep "\.txt"

# Você pode redirecionar o comando de input e output (stdin, stdout e stderr).
# Lê o stdin até ^EOF$ e sobrescreve hello.py com as linhas entre "EOF":
cat > hello.py << EOF
#!/usr/bin/env python
from __future__ imprt print_function
import sys
print("#stdout", file=sys.stdout)
print("stderr", file=sys.stderr)
for line in sys.stdin:
	print(line, file=sys.stdout)
EOF

# Rode hello.py com várias instruções stdin, stdout e stderr:
python hello.py < "input.in"
python hello.py > "ouput.out"
python hello.py 2> "error.err"
python hello.py > "output-and-error.log" 2>&1
python hello.py > /dev/null 2>&1
# O erro no output sobrescreverá o arquivo se existir,
# se ao invés disso você quiser complementar, use ">>":
python hello.py >> "output.out" 2>> "error.err"

# Sobrescreve output.out, complemente para error.err e conta as linhas
info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
wc -l output.out error.err

#Roda um comando e imprime o desencriptador (e.g. /dev/fd/123)
# veja: man fd
echo <(echo "#helloworld")

# Sobrescreve ouput.out com "#helloworld":
cat > output.out <(echo "#helloworld")
echo "#helloworld" > output.out
echo "#helloworld" | cat > output.out
echo "#helloworld" | tee output.out > /dev/null

# Limpa os arquivos temporários detalhando quais foram deletados (use '-i' para confirmar exclusão)
rm -v output.out error.err output-and-error.log

# Comando podem ser substituídos por outros comandos usando $( ):
# O comando a seguir mostra o número de arquivos e diretórios no diretório atual
echo "Existem $(ls | wc -l) itens aqui."

# O mesmo pode ser feito usando crase `` mas elas não podem ser aninhadas - dá se 
# preferência ao uso do $( )
echo "Existem `ls | wc -l` itens aqui."

# Bash usa o comando case que funciona de uma maneira similar ao switch de Java e C++:
case "$Variavel" in
	# Lista de parametros para condições que você quer encontrar
	0) echo "Isso é um Zero.";;
	1) echo "Isso é um Um.";;
	*) echo "Isso não é null.";;
esac

# loops for iteragem para quantos argumentos passados:
# O conteudo de $Variavel é exibido três vezes.
for Variavel in {1..3}
do
	echo "$Variavel"
done

# Ou use o loop da "maneira tradicional":
for ((a=1; a <= 3; a++))
do
	echo $a
done

# Eles também podem ser usados em arquivos...
# Isso irá rodar o comando 'cat' em arquivo1 e arquivo2
for Variavel in arquivo1 arquivo2
do
	cat "$Variavel"
done

# ...ou o output de um comando
# Isso irá usar cat no output do ls.
for Output in $(ls)
do
	cat "$Output"
done

# loop while:
while [ true ]
do
	echo "corpo do loop aqui..."
	break
done
```

### Funções
```bash
# Definição:
function foo() {
	echo "Argumentos funcionam bem assim como os dos scripts: $@"
	echo "E: $1 $2..."
	echo "Isso é uma função"
	return 0
}

# ou simplesmente
bar () {
	echo "Outro jeito de declarar funções!"
	return 0
}

# Chamando sua função
foo "Meu nome é" $Nome
```

### Misc

Outros comandos úteis:
```bash
# exibe as 10 ultimas linhas de arquivo.txt
tail -n 10 arquivo.txt
# exibe as primeiras 10 linhas de arquivo.txt
head -n 10 arquivo.txt
# ordena as linhas de arquivo.txt
sort arquivo.txt
# reporta ou omite as linhas repetidas, com -d você as reporta
uniq -d arquivo.txt
# exibe apenas a primeira coluna após o caractere ','
cut -d ',' -f 1 arquivo.txt
# substitui todas as ocorrencias de 'okay' por 'legal' em arquivo.txt (é compativel com regex)
sed -i 's/okay/legal/g' file.txt
# exibe para o stdout todas as linhas do arquivo.txt que encaixam com o regex
# O exemplo exibe linhas que começam com "foo" e terminam com "bar"
grep "^foo.*bar$" arquivo.txt
# passe a opção "-c" para ao invés de imprimir o número da linha que bate com o regex
grep -c "^foo.*bar$" arquivo.txt
# se você quer literalmente procurar por uma string,
# e não pelo regex, use fgrep (ou grep -F)
fgrep "^foo.*bar$" arquivo.txt


# Leia a documentação interna do shell Bash com o comando interno 'help':
help
help help
help for 
help return
help source
help .

# Leia a página principal da documentação com man
apropos bash
man 1 bash
man bash

# Leia a documentação de informação com info (? para ajuda)
apropos info | grep '^info.*('
man info
info info 
info 5 info 

# Leia a documentação informativa do Bash:
info bash
info bash 'Bash Features'
info bash 6
info --apropos bash 
```


Visão geral sobre o formato do arquivo, variáveis, condicionais e outras coisas úteis.

Entendendo bash script


Dentro de uma pasta você pode **l**i**s**tar todos os arquivos que a pasta contém usando o comando `ls`:

```sh
ls
```

Se você adicionar um nome ou caminho de uma pasta, ele imprimirá conteúdo dessa pasta:

![Retorno do comando `ls /bin`](/img/ls.png)


Listando os arquivos de uma pasta no linux

O comando `ls`


O texto do atributo `alt` descreve o conteúdo da imagem, dando a ela um texto alternativo. Um atributo `alt` ajuda nos casos onde a imagem não carrega ou não pode ser vista pelo usuário. Os mecanismos de busca também o utilizam para compreender o que uma imagem contém para a incluir nos resultados de pesquisa.

Aqui está um exemplo:

```html
<img src="gato.jpeg" alt="Gato brincando">
```

Pessoas com deficiências visuais dependem de leitores de tela para converter conteúdo da web em uma interface de áudio. Eles não vão obter informações se elas forem apresentadas apenas visualmente.

Para imagens, os leitores de tela podem acessar o atributo `alt` e ler seu conteúdo para fornecer informações importantes. Um bom texto no atributo `alt` fornece ao leitor uma breve descrição da imagem. 

Você sempre deve incluir um atributo `alt` na sua imagem. Segundo a especificação do HTML5, isso agora é considerado obrigatório.

## O que devo colocar no meu atributo `alt`?

A regra genérica para o conteúdo do atributo `alt` é: use um texto que cumpra a mesma função que a imagem.

Algumas regras mais específicas:

* se a imagem for simplesmente um texto decorado, coloque o texto no atributo alt
* se a imagem for apenas decorativa, não há problema em ter um atributo alt vazio (por exemplo, `alt=""`), mas nesses casos é melhor inserir a imagem via CSS.
* se a imagem apresentar muitas informações importantes, tente resumir em uma linha curta para o atributo `alt`


Como adicionar um texto alternativo em imagens para melhorar a acessibilidade

Entendendo o atributo `<img alt>`


A forma mais simples de servir um arquivo HTML usando apenas módulos já inclusos no Node.js é a seguinte:

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

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'text/html' }) // MIME type HTML
  fs.createReadStream('index.html').pipe(res) // arquivo que será entregue
})

// Usa a variável de ambiente PORT ou a porta 3000
server.listen(process.env.PORT || 3000)
```

Sem nenhum módulo externo.

Coloque isso em um arquivo `app.js`, crie uma página `index.html` na mesma pasta e rode `node app.js`.

A página estará acessível em [`http://localhost:3000/`](http://localhost:3000/).

Perceba que o código acima não dá suporte à servir os outros arquivos estáticos, apenas entrega o conteúdo do `index.html` para todas as requisições.


Descubra como entregar um arquivo `index.html` usando Node.js sem nenhuma dependência externa

códigoLivre

Entendendo bash script

O comando `ls`

Entendendo o atributo `<img alt>`

Servindo uma página HTML usando Node.js