Como concatenar strings na shell do Linux

Concatenar ou juntar cadeias de caracteres (ou, simplesmente, strings), na shell (ou linha de comando) do Linux é um trabalho fácil e descomplicado.
Apenas fique atento a alguns detalhes… e tudo terminará bem. 😉

O procedimento pode ser muito útil dentro de shell scripts ou para uso em arquivos de configuração do Bash.
Você pode concatenar strings dentro do seu .bashrc, para obter resultados ou “hackear” o seu sistema.

Para sermos objetivos, abra um terminal e vamos definir as seguintes variáveis, como exemplo:


variavel1="elias"
variavel2=".praciano"
variavel3=".com"

A concatenação consiste, de maneira resumida, em juntar os valores das 3 strings, acima. Isto pode ser feito assim:


meusite=$variavel1$variavel2$variavel3
echo $meusite

elias.praciano.com

Note que não precisa usar o símbolo ‘$’ ao definir as variáveis. Mas é obrigatório no momento de se referir e fazer operações com elas.

Variáveis de ambiente no Linux

As variáveis de ambiente são usadas para armazenar valores, que podem ser usados por scripts, executados a partir da shell.
Algumas variáveis de ambiente já fazem parte do sistema. Outras podem ser criadas por você.
No Bash, há 2 tipos de variáveis de ambiente ou (environment variables):

  1. locais — visíveis apenas dentro da shell, na qual foram criadas.
  2. globais — visíveis a todos os processos em execução numa shell.

Você pode usar o comando printenv, para ver quais são e como estão definidas as variáveis globais no seu ambiente atual:
Veja algumas das minhas:


printenv

LS_COLORS=di=7;32:fi=32:ln=4;32:pi=5;32:so=5;32:bd=5;32:cd=5;32:or=5;32:mi=5;32:ex=1;32:*.png=1;4;32:*.jpg=1;4;32
XDG_MENU_PREFIX=gnome-
LANG=pt_BR.UTF-8
GDM_LANG=pt_BR.UTF-8
DISPLAY=:0
COLORTERM=truecolor
USERNAME=justincase
DESKTOP_SESSION=gnome-xorg
WINDOWPATH=2
TERM=xterm-256color
SHELL=/bin/bash
VTE_VERSION=4602
XDG_CURRENT_DESKTOP=GNOME
GDMSESSION=gnome-xorg
GNOME_DESKTOP_SESSION_ID=this-is-deprecated
PATH=/opt/Komodo-Edit-10/bin:/opt/Telegram/Telegram:/usr/local/bin:/usr/bin:/bin:/usr/games
_=/usr/bin/printenv

Para ver apenas uma das variáveis, use o comando echo:


echo $HOME

/home/justincase

Experimente ver outras variáveis no seu sistema.
Depois, experimente criar sua primeira variável de sistema:


meusite="https://elias.praciano.com"

echo $meusite

https://elias.praciano.com

Fique atento: os nomes das variáveis são sensíveis à caixa (case sensitive).
Por isso, $meusite e $MEUSITE são coisas totalmente diferentes.
variáveis de ambiente sistema linux

Como prática recomendada, use sempre as letras minúsculas, para nomear as suas variáveis.
Assim você evita confusão com as variáveis do sistema.

Antes de abordarmos o próximo tópico, vale lembrar que as variáveis declaradas em uma sessão ou dentro de uma janela de um console não terão validade em outra sessão ou console.

Como declarar uma variável global

Para definir uma variável global, é necessário declarar (como você já deve saber) uma variável local.
Depois disto, a exportamos com o comando export:


autor='Elias Praciano'
echo $autor

Elias Praciano

export autor

Note que não se usa o ‘$’ à frente do nome da variável, quando a passamos para o comando export.
O último passo, para tornar uma variável persistente entre as sessões, é editar o arquivo ~/.bashrc.
Inclua, ao final dele, a linha com o comando export:


export autor='Elias Praciano'

Após este procedimento, a variável autor poderá ser sempre invocada no seu sistema, com o valor ‘Elias Praciano” — ou até você mudar o seu valor ou remover a linha do arquivo .bashrc.

Como descartar variáveis de ambiente no Linux

O comando unset pode ser usado para remover variáveis da memória do sistema:


echo $autor

Elias Praciano

unset autor
echo $autor

Remova também as declarações referentes à variável do seu arquivo .bashrc, ou ela ressurgirá na próxima sessão.

Como ajustar o PATH no Linux

Se você precisa definir um caminho para um diretório, no sistema ou dentro do seu próprio HOME, pode fazer isto ajustando a váriavel $PATH da shell
A variável é composta de uma lista de caminhos, separados por 2 pontos, que é consultada pela shell, para buscar arquivos de comandos ou importantes para o sistema.
linux user path
A palavra path, quer dizer ‘caminho’, em inglês. E é disso que a variável trata.
Existe a variável path padrão do sistema e a específica de cada usuário.
A primeira, é estabelecida pelo próprio sistema, durante a instalação do Bash ou pelo administrador.
A segunda pode ser definida livremente por qualquer usuário.
Para verificar o atual valor de seu PATH, use o comando echo:

echo $PATH

Como é possível observar (abaixo), o meu resultado mostra os valores padrão de um sistema recém instalado. Ainda não ajustei a variável para as minhas necessidades.

/usr/local/bin:/usr/bin:/bin:/usr/games

Dentro de um script, é possível usar a seguinte linha de comando:

printf "%s\n", $PATH

O resultado deve ser o mesmo obtido anteriormente.
Se você tem um diretório local, onde você guarda seus próprios scripts ou binários (como jogos, por exemplo), pode adicioná-lo PATH, para não precisar digitar o caminho completo, toda vez que for fazer uso de um deles.
Veja como acrescentar o caminho ‘/home/justincase/bin’ ao PATH de usuário:

# acrescentando o novo valor à variável $PATH:
PATH=$PATH:/home/justincase/bin/

# verificando a nova varável:
echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/games:/home/justincase/bin/

Uma outra forma, que vai dar o mesmo resultado, é acrescentar a variável $HOME ao PATH.
Veja o seu conteúdo:

echo $HOME
/home/justincase

Basta acrescentar o diretório ‘/bin’ ao PATH. Veja:

PATH=$HOME/bin/:$PATH

Como tornar este ajuste permanente

A variável PATH vai ser reiniciada após um reboot do sistema.
Portanto, ela precisa receber seus valores novamente, quando você se reautenticar.
Para tornar o valor, que você quiser, permanente, faça o ajuste da variável dentro do arquivo ‘.profile’ ou ‘.bash_profile’ (você deve ter um dos dois).
No meu sistema (Debian 9), está presente o arquivo ‘.profile’. Este é seu conteúdo:

cat .profile 
# ~/.profile: executed by the command interpreter for login shells.
# This file is not read by bash(1), if ~/.bash_profile or ~/.bash_login
# exists.
# see /usr/share/doc/bash/examples/startup-files for examples.
# the files are located in the bash-doc package.

# the default umask is set in /etc/profile; for setting the umask
# for ssh logins, install and configure the libpam-umask package.
#umask 022

# if running bash
if [ -n "$BASH_VERSION" ]; then
    # include .bashrc if it exists
    if [ -f "$HOME/.bashrc" ]; then
	. "$HOME/.bashrc"
    fi
fi

# set PATH so it includes user's private bin directories
export PATH="$HOME/bin:$HOME/.local/bin:$PATH"

A linha a ser ajustada é a última.
Abra o arquivo com o seu editor de textos favorito:

vi ~/.profile

Em seguida, ajuste a linha do PATH, para o que achar melhor. No meu caso, vai ficar assim:

export PATH="$HOME/bin:$HOME/.local/bin:$PATH"

Grave e feche o arquivo.
Os novos ajustes só terão efeito após se reautenticar no sistema.
Se quiser carregar os novos valores, sem fazer logout/login, entre o seguinte comando, no terminal:

source ~/.profile

ou, caso você tenha alterado o ‘.bash_profile’:

source ~/.bash_profile

E, antes de finalizarmos este tutorial, faça uma verificação:

echo $PATH

Referências

https://www.cyberciti.biz/faq/how-to-add-to-bash-path-permanently-on-linux/.

Por que precisamos usar ./ antes do nome de um script para executá-lo no Linux?

A combinação de um ponto seguido por uma barra é comumente usada para preceder comandos ou scripts no Linux e em outros sistemas operacionais UNIX.
Ainda que esta característica seja um tanto confusa ou chata para novos usuários, ela existe por uma boa razão e pode ser interessante saber qual é esta razão.
O que acontece é que os comandos em sistemas UNIX ou GNU/Linux são do tipo embutidos (memorizados) ou arquivos executáveis.
No primeiro caso, temos comandos como o cd, echo, kill, ls, pwd etc. Estes são parte da shell, em execução — e, portanto, ela é sempre capaz de localizá-los.
Linux tux ninja
No segundo caso, a shell precisa de ajuda para encontrar os comandos dos arquivos executáveis.
Estes arquivos podem ser tanto scripts (programas em Python, Perl, Bash etc.) como programas compilados.
Um programa compilado é um programa cujo código fonte (ou seja, seu código original, legível por humanos) tenha sido convertido em um arquivo executável, em linguagem de máquina e está pronto para rodar de imediato, sem que suas instruções precisem passar por uma interpretação prévia.
Uma shell é um programa que provê uma interface entre o usuário e o sistema — ela pode ser gráfica ou pode ser um terminal, onde você interage com o sistema em modo texto (que nem os hackers nos filmes).
O emulador de terminal ou o console é uma forma de interagir com a shell do seu sistema. A principal função da shell é ler os comandos que são digitados e executá-los.

Um script é um programa curto, escrito em uma linguagem de programação que é lido por um interpretador (Python, Perl, PHP, Bash etc.), que executa suas instruções.

Quando um texto é fornecido na linha de comandos da shell e, você pressiona Enter, esta assume que forneceu um comando.
A partir daí, a shell imediatamente verifica se a primeira string (sequência de caracteres) dada é um dos comandos embutidos dela ou um dos arquivos executáveis (que ficam guardados em diretórios apropriados).
A shell sabe quais são os diretórios de executáveis, por que eles estão armazenados em uma variável de ambiente do sistema, chamada PATH.

A variável de ambiente PATH é escrita em letras maiúsculas.
Em inglês, a palavra quer dizer “caminho”.
Sua função é informar ao sistema onde se encontram os comandos ou programas de que ele precisa.

Se nenhuma destas condições for atendida, a busca continuará nos diretórios listados na variável de ambiente PATH do usuário.
Ao ser encontrado, o comando é executado, desde que não haja qualquer outro problema.
Se não for encontrado, o usuário recebe uma mensagem de erro: “comando não encontrado” ou “command not found“.
Muitos usuários trabalham, na maior parte do tempo, em seus diretórios home e nos seus subdiretórios — por uma questão de conveniência e/ou segurança.
Contudo, o padrão do sistema operacional é não incluir estes diretórios na variável de ambiente PATH.
Portanto, se o usuário criar um script ou compilar um programa dentro de seu próprio diretório e tentar executá-lo, digitando seu nome, ele irá obter uma mensagem de erro.
Este problema pode ser facilmente resolvido com o uso de ‘./’ (um ponto e uma barra) — em inglês, é chamado de dot slash.
Trata-se, meramente, de uma forma abreviada de informar à shell que o caminho absoluto do arquivo que se está tentando executar é o diretório atual (aquele em que o usuário está trabalhando).

O uso de ./ antes de comandos locais é uma questão de segurança

Arquivos comuns, no diretório atual, podem ser acessados com uma referência simples, se acompanhados de um comando. Veja alguns exemplos:

ls Downloads/
cat lshw.log

Não há necessidade de indicar o caminho absoluto do arquivo, neste caso.
Mas, quando há a necessidade de executar alguma coisa fora dos caminhos usuais, o sistema requer que você informe exatamente o que deseja executar.
Este é um mecanismo de segurança.

Vamos supor uma situação em que você seja o administrador do sistema (root) e entra no diretório de algum dos usuários e comete o erro de digitar o comando ‘sl’, em vez de ‘ls’ — um erro comum.
Se houver algum programa malicioso, neste diretório, com este nome, ele simplesmente será ignorado e o sistema informará que não encontrou o comando.


É possível incluir o diretório /home do usuário no PATH. Basta incluir ‘.’ (ponto) na variável de ambiente PATH.
Ao fazer isto, todo os seus programas e scripts passarão a ser executados direto, sem a necessidade de indicar o caminho deles com um ‘./’.
Mas esta prática, obviamente, não é recomendada — ela põe a segurança do seu sistema em risco.
Se você fizer isto, a shell, pela ordem, irá procurar primeiro dentro do seu diretório de trabalho os comandos de execução. O que significa que, se houver um comando ‘ls’ (ou qualquer outro) lá dentro, ele é que será executado.
Se você necessita executar várias vezes seus scripts e está se incomodando com este “obstáculo de segurança”, há maneiras mais inteligentes e seguras de contorná-lo.

Como alterar a variável de ambiente PATH

Uma forma profissional de lidar com esta situação, em segurança, é criar um subdiretório no seu diretório local, para guardar seus scripts e seus programas compilados.
É seguro, então, informar este diretório específico ao PATH.
Você pode ver o conteúdo da variável de ambiente $PATH com o comando echo:

echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games

Portanto, crie um subdiretório, no seu home, chamado ‘bin’, e o inclua no PATH. Assim:

mkdir bin
export PATH=$PATH:$HOME/bin
echo $PATH

Note, ao final da linha, o novo diretório ‘/home/justincase/bin’ foi incluído:

/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/home/justincase/bin

Esta alteração só vale para a sessão atual.
Se você quiser torná-la permanente, inclua a linha export PATH=$PATH:$HOME/bin ao final do arquivo ‘.bashrc’.
Seja cuidadosa(o) e brinque com segurança.

Referências

http://www.linfo.org/dot_slash.html
http://stackoverflow.com/questions/6331075/why-do-you-need-dot-slash-before-script-name-to-run-it-in-bash

Como pesquisar sequências de caracteres dentro de strings, com a função LOCATE, no MySQL

A função LOCATE() do MySQL permite encontrar sequência dentro de uma cadeia de caracteres. Ou seja, a função pode ser usada para identificar uma substring dentro de uma string.
A função LOCATE() recebe dois argumentos: a substring que você deseja encontrar e o texto dentro do qual ela será procurada.
Capa do tutorial - como encontrar sequências de caracteres no MySQL
Se a busca for bem sucedida, a função retorna a posição em que a substring desejada se encontra ou o valor 0 (zero), caso ela não esteja presente.
Opcionalmente, é possível fornecer um terceiro argumento à função — para indicar em que posição, dentro da string principal, a busca deve ter início.

Exemplos de uso da função locate no MySQL

Neste primeiro exemplo, vou mostrar como criar uma variável no MySQL e, em seguida, como efetuar uma busca dentro dela com a função LOCATE().

SET @minhavar="O mysqladmin é um cliente para executar operações administrativas no MySQL. Ele pode ser usado para verificar a configuração do servidor e seu estado atual, além de criar e apagar bancos de dados - entre outras coisas.";
SELECT LOCATE("cliente",@minhavar);
+-----------------------------+
| LOCATE("cliente",@minhavar) |
+-----------------------------+
|                          19 |
+-----------------------------+
1 row in set (0.00 sec)

A busca efetuada é insensível a caixa das letras, ou seja, tanto faz procurar por “cliente” como “ClIEnTE” — para a função LOCATE(), as duas strings são a mesma coisa.

A função LOCATE() era sensível à caixa das letras nas versões do MySQL anteriores a 4.0.0
— MySQL Cookbook by Paul DuBois

O exemplo abaixo mostra como fazer a busca dentro do banco de dados:

SELECT CidadeCliente FROM ClientesCidades WHERE LOCATE('co',CidadeCliente);

O comando, acima, ordena uma pesquisa dentro da tabela ClientesCidades por CidadeCliente, em cujo texto, tenha a substring “co”. Veja o resultado:

+------------------------+
| CidadeCliente          |
+------------------------+
| Girifalco              |
| San Costantino Calabro |
| Rocourt                |
| Beaconsfield           |
| Rachecourt             |
| Vancouver              |
| Lacombe                |
| Port Lincoln           |
| Corroy-le-Grand        |
| Recco                  |
| Coalhurst              |
| San Demetrio Corone    |
| Lakeland County        |
| Beaconsfield           |
| Colonnella             |
+------------------------+
15 rows in set (0.01 sec)