sábado, 9 de setembro de 2017

CSS3: Transições

Transições em CSS3 é um recurso bastante interessante e pode ser usado substituindo JavaScript para a construção de menus, mas não apenas com essa finalidade, o uso de transições vai até onde sua imaginação permita.

Para estabelecer uma transição devemos ter um primeiro box com as propriedades com seus valores de início e após isso devemos ter outro box com um determinado seletor (aqui usaremos o hover que é acionado quando o ponteiro do mouse passa sobre o elemento afetado) com as propriedades que devem ser modificadas recebendo novos valores.

Exemplo:
   #box-transicao {
    width: 300px;
   height: 300px;
   background: orange;
 }

 #box-transicao:hover {
   width: 400px; /*largura alterada para 400px*/
      background: black; /*Fundo alterado para preto*/ 
   }


No exemplo acima a transição funciona porém ela será realizada de modo abrupto. Para que a transição ocorra de forma suave vamos utilizar uma propriedade chamada "transition". Essa propriedade nos dirá quais propriedades serão afetadas pela transição, o tempo da transição, à curva de velocidade e o atraso. Obviamente, como em outras propriedades não precisamos especificar cada um desses valores. Abaixo colocarei um exemplo utilizando apenas dois desses valores (propriedades afetadas e tempo de execução).

   #box-transicao {
width: 300px;
height: 300px;
background: orange;
 }

 #box-transicao:hover {
width: 400px;
background: black;
transition: background 3s, width 8s; /*Propriedades afetadas pela transição e o tempo que deve durar.*/
 }

OBS.: Se desejado que todas as propriedades do box hover recebam os efeitos de transition da mesma forma podemos substituir os nomes das propriedades por "all".


Além de se escrever a propriedade transition em sua forma simples, vista no exemplo, podemos estabelecer cada um dos valores em propriedade próprias:

 transition-property: xxxxx; /*Propriedades afetadas*/
 transition-duration: Xs; /*Tempo de execução da transição*/
 transition-timing-function: xxxxx; /*Curva de velocidade*/
transition-delay: Xs; /*Tempo de atraso*/


Para curva de velocidade podemos decidir por alguns valores como:
ease (PADRÃO, início lento, acelerado no meio e lento no final);
linear (velocidade constante).

Para buscar mais informações sobre transições como também para qualquer coisa em html, css, JS... recomendo o site da W3Schools. O link estará logo abaixo nas referências.



FONTES:
 Curso completo de Desenvolvimento Web - Udemy: https://www.udemy.com/curso-completo-do-desenvolvedor-web/

segunda-feira, 4 de setembro de 2017

GIT: GitHub

É difícil pensar em git e não pensar em GitHub, na cabeça de alguém que está começando a conhecer o git costuma mesmo estar a ideia de que ambos são uma coisa só. O git é um sistema de controle de versão enquanto que o GitHub é uma plataforma que nos permite ter repositório online trabalhando com git.

O GitHub não é a única plataforma para isso, mas certamente é a mais bem sucedida e com maior fama, servindo por exemplo para que programadores ainda sem experiência de emprego possam mostrar através de seus repositórios no GitHub suas habilidades. Outra utilidade da plataforma, diga-se de passagem muito relevante, é que nela estão muitos projetos open source, incluindo projetos gigantes como o WordPress, projetos onde nós programadores podemos  estudar o código e até mesmo contribuir no desenvolvimento.

O GitHub é gratuito, no entanto apenas para projetos públicos, caso o usuário queira hospedar na plataforma um projeto privado ele terá que pagar.

Os comandos são os mesmos já vistos antes (posts anteriores com comandos e descrições), logo mais abaixo veremos apenas mais um. Para começarmos a trabalhar na plataforma basta:
   1 - criar uma conta;
   2 - Depois de criar a conta usamos o comando "ssh-keygen":
       ssh-keygen /*Esse comando gera um par de chaves ssh que será necessária para que seu PC tenha autorização de acesso a seu repositório no git hub. Da forma mais simples basta confirmar com enter às solicitações do git no bash até que seja gerado um arquivo .pub do qual devemos copiar o conteúdo e levar até nossa conta no GitHub indo em "ssh keys" de "settings" e assim a conexão será permitida pelo servidor*/;
   3 - Criamos, utilizando a interface do GitHub, um repositório;
  4 - Com o repositório criado vamos procurar a ssh do servidor (hoje vamos ao botão "clone or download" na lateral e ao clicar sobre ele entre outras opções estará a chave ssh) e copia-la;
  5 - no git bash vamos usar o comando "git clone" que se diferencia de como o usamos no servidor local apenas que em vez de utilizarmos file:///xxx... vamos colocar a chave ssh retirada do GitHub;
   6 - Agora com o repositório criado basta começarmos a trabalhar em nossos projetos utilizando os comandos já vistos nos postes anteriores.

OBS.: Embora no comando clone tenhamos substituído o nome do servidor pela chave ssh nos comando push, pull e fetch o nome do servidor (origin) que deverá ser usado.



FONTES: Curso Básico de Git do RBtech (recomendo - essas são notas de aula que fiz durante esse curso): https://www.youtube.com/watch?v=1IfAFYQD8u0&list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0&index=7

GIT: Git em servidores locais

Além de usar git em um servidor no próprio PC de desenvolvimento podemos utilizar o git em uma rede local, útil para uma equipe de desenvolvimento de uma empresa por exemplo. A pasta onde estará hospedado o projeto não deve ser iniciada apena com o comando "git init" mas com o comando "git init --bare" assim o repositório será disponível para todos os PCs da rede local.
Os arquivos que em um repositório local ficariam dentro de uma pasta .git aqui ficam soltos diretamente dentro da pasta do projeto, isso é uma característica do init --bare.

git clone file:////NomeDoServidor/xxxx/xxxx xxxx /*Todos os que vão contribuir com o projeto devem executar este comando para clonar o repositório em sua estação de trabalho. O último parâmetro (xxxx) é dispensável sendo que ele é para substituir localmente o nome da da pasta original.*/
git remote /*Comando para ver o nome do servidor remoto no qual estamos conectados.*/
git push xxxx xxxx /*Comando para enviar ao servidor o commit local. O primeiro xxxx é o nome do servidor e o segundo é o nome do nosso branch. Parece a mim ser padrão que o servidor chame-se origin assim como o branch tem por padrão o "master".*/
git pull xxxx xxxx /*Comando para puxar do servidor não o repositório (clone) mas as alterações que estão no servidor fazendo o merge automático com os arquivos locais. Primeiro xxxx é o nome do servidor e o segundo é o nome do branch para o qual traremos as atualizações.*/
git fetch xxxx xxx /*Comando similar ao pull com a diferença de que este não faz o marge entre os arquivos baixados e os do branch local.*/



FONTES: Curso Básico de Git do RBtech (recomendo - essas são notas de aula que fiz durante esse curso): https://www.youtube.com/watch?v=1IfAFYQD8u0&list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0&index=7

GIT:BRANCH

O conceito de branch é um pouco parecido com o das tags, porém é superior, é como se fosse uma conta de usuário linux onde há o master (que seria o root) e outros que podemos criar. Os arquivos de um podem ter conteúdos diferente dos arquivos em outras contas ou mesmo podem haver arquivos em um e não no outro branch. É usado para um melhor controle de versão podendo por exemplo, enquanto que há uma versão estável do sistema sendo executada por clientes criarmos um novo branch onde faremos atualizações e correções de bugs e o sistema usado pelos clientes só terá às modificações quando já tivermos feito todos os testes e liberarmos para o master as atualizações.

git branch /*Lista todos os branchs existentes*/
git branch xxx /*Cria um novo branch*/
git chechout xxx /*Comando para ir para o branch desejado. Feito após a criação de um novo branch migra os arquivos do branch atual para o ditado e o git bash passa a ser operando com o branch ditado.*/
git checkout -b xxx /*Realiza os dois comandos acima de uma só vez.*/
git merge xxx /*Mesclo os arquivos do branch onde estou com os do branch apontado (xxx).*/
git branch -d xxx /*Exclui um branch.*/



FONTES: Curso Básico de Git do RBtech (recomendo - essas são notas de aula que fiz durante esse curso): https://www.youtube.com/watch?v=1IfAFYQD8u0&list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0&index=7

GIT: TAGs git

git tag -a xxx -m "xxxxxx" /* Com esse comando criamos uma tag que irá marcar algum commit. A tag pode ser útil para controlarmos versões e funciona como um ponteiro para um commit. O primeiro campo xxx é onde daremos o nome da tag e o segundo é onde faremos uma descrição dela. Fazendo a tag dessa forma ela será colocada no ultimo commit, caso se deseje por uma tag em um commit diferente deve-se entre o nome da tag e o parâmetro -m por a chave do commit.*/
git tag /*exibe as tags existentes*/
git show xxx /*Comando para exibir detalhes de uma determinada tag.*/
git tag -d xxx /*Este comando deleta uma tag.*/



FONTES: Curso Básico de Git do RBtech (recomendo - essas são notas de aula que fiz durante esse curso): https://www.youtube.com/watch?v=1IfAFYQD8u0&list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0&index=7

GIT: Comandos para consultas

git diff /*Esse comando exibirá o conteúdo de um arquivo commitado que tenha sido alterado e após isso ainda não tenha sido adicionado a stage area. Exibirá o que já havia, o que foi removido e o que foi adicionado, vale ressaltar que por padrão o git colocará a ultima linha escrita antes da alteração como removida (-- "removido em vermelho") e em seguida colocará o mesmo trecho como adicionado (++) não sei se é como se ele removesse e adicionasse ou se de fato ele faz isso, seja como for não vejo nenhum problema e vale apenas como observação desse comportamento.*/
git diff --staged /*com o acréscimo o comando diff exibe agora as alterações em um arquivo que já esteja na stage area.*/
git log /*Esse comando exibe todos os commits já realizados com suas chaves, autor e data de cada commit.*/
git log -p /*Esse comando irá detalhar os commits já realizados mostrando as alterações feitas. O relatório é exibido por paginação por isso é preciso usar a tecla enter para ir mostrando o restante do conteúdo até chegar no commit inicial.
Quando terminarmos a checagem será necessário teclar "q" para que possamos voltar a inserir comandos no terminal.*/
git log -p -n /*Com o comando anterior podemos ter problemas já que possa ser que hajam muitos commits já realizados. acrescentando o parâmetro -n (onde n é um natural qualquer) iremos definir a quantidade de commits que desejamos puchar, se colocarmos "-1" por exemplo, então teremos o relatório do último commit apenas.*/
gitk /*Comando extremamente útil! Ele também exibe relatórios só que dessa vez por meio de uma interface gráfica tornando a leitura mais intuitiva e produtiva.*/
git log --pretty=oneline /*Comando muito útil, ele exibirá os commits realizados cada um em linha única, simplificados, contendo apenas a chave e a anotação feita ao commitar.*/
git commit --amend -m "xxx" /*Esse comando edita o último commit realizado. Se houver novos arquivos na stage area o último commit terá seu conteúdo atualizado com o que está na stage area e também terá a mensagem alterada (parâmetro "xxx") e a chave será também trocada automaticamente. Caso não haja nada na stage area então a alteração se resumirá a mensagem e a chave*/
git reset HEAD xxx.xx /*Esse comando serve para retirar da stage area um arquivo que lá esteja.*/
git checkout -- xxx.xx /*Esse comando desfaz as alterações em um determinado arquivo para o estado do último commit.*/
git rm xxx.xx /*Comando para remover um arquivo do repositório.*/


FONTES: Curso Básico de Git do RBtech (recomendo - essas são notas de aula que fiz durante esse curso): https://www.youtube.com/watch?v=1IfAFYQD8u0&list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0&index=7

GIT: Fazendo com que um arquivo dentro do diretório de trabalho não seja monitorado (gitignore)

Suponhamos que você crie um arquivo de notas ou um código de testes dentro do seu diretório de trabalho e que esses arquivos sejam temporários ou por algum outro motivo você não deseje que ele seja monitorado pelo git. Simplesmente deixar o arquivo lá fará com que a cada consulta com o "git status" o arquivo apareça como ainda não tendo sido commitado ou adicionado para a staging area e ainda por engano podemos acabar adicionando ou commitando esse arquivo. Para fazer com que qualquer arquivo, incluindo pastas, não sejam "vistos" pelo git temos como opção criar um arquivo sem nome com extensão .gitignore. Se você estiver no windows e tentar criar um arquivo sem nome através de um editor de texto comum (incluindo o Bloco de Notas) você terá problemas pois por padrão o windows não irá aceitar um arquivo sem nome. No windows creio que a maneira mais fácil de criar um .gitignore seja utilizando um editor de códigos como o Notepad++, Komodo Edit ou Sublime, se você optar por fazer de uma forma diferente pode buscar na internet outras opções.
Uma vez que você tenha criado o arquivo dentro dele você deve incluir todos os arquivos e pastas que não serão observados pelo git, inclua o próprio ".gitignore". Basta por os nomes dos arquivos com suas extensões, um em cada linha, e no caso de pastas você deve por uma "/" no fim que dirá ao git que se trata de um diretório.




FONTES: Curso Básico de Git do RBtech (recomendo - essas são notas de aula que fiz durante esse curso): https://www.youtube.com/watch?v=1IfAFYQD8u0&list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0&index=7

GIT: O que é + comandos básicos

O que é git?

Git é um sistema de controle de versão desenvolvido originalmente por Linus Torvalds (criador do linux). É um software livre amplamente utilizado em todo o mundo tendo milhões de usuários desde programadores em seus primeiros passos até gigantes como Microsoft, google, facebook e twitter. O git é um VCS (version control system) distribuído o que faz dele uma ferramenta importante no desenvolvimento de códigos por uma equipe.

Estarei, à partir deste, fazendo alguns posts com comandos e suas descrições e outras explicações conceituais.


Iniciando o seu repositório local

Antes de mais nada você deve baixar o git para seu computador https://git-scm.com/downloads, instala-lo e após isso você irá utilizar o git bash para gerenciar seu repositório. Os comandos para navegar pelas pastas do sistema, limpar tela... são os mesmo utilizados no terminal linux mesmo que você esteja usando um PC com Windows. Com essas premissas vamos começar a estudar os comandos do git.

git config --global user.name "xxxx" /*Comando para escolher o nome de usuário.*/
git config --global user.email "xx@xx.xx" /*Após criar o usuário aqui lhe damos um endereço de e-mail.*/

git init /*Após navegar, com o Git Bash, até o diretório onde ficarão seus projetos use este comando para iniciar o monitoramento.*/
git status /*Com este comando verificamos o status do nosso diretório de trabalho, se há alguma alteração, algo à commitar ou a adicionar.*/
git add xxx.xx /*Comando para adicionar um arquivo novo ou um já monitorado porém alterado. Deve-se digitar o nome do arquivo seguido de sua extensão*/
git add *.xx /*Adciona para a staging area todos os arquivos do diretório de trabalho que tenham uma determinada extensão*/
git add . /*Adciona todos os arquivos do diretório*/
git commit -m "xxxxxxx" /*Após adcionar os arquivos a stage area eles passam a ser monitorados porém estão em um tipo de estado intermediário, estão em um ensaio para serem permanentemente armazenados em nosso repositório. Para salvarmos os arquivos adcionados permanentemente em nosso repositório devemos commitalos com esse comando.
OBS.:Entre as aspas fazemos uma breve nota sobre o commit*/
git commit -a -m "xxx" /*Comando para comitar e adcionar de uma única vez, substituindo assim o comando "git add". 
OBS.: Entre as aspas inserimos uma nota sobre a versão.*/



FONTES:
Curso Básico de Git do RBtech (recomendo - essas são notas de aula que fiz durante esse curso) https://www.youtube.com/watch?v=1IfAFYQD8u0&list=PLInBAd9OZCzzHBJjLFZzRl6DgUmOeG3H0&index=7