Bom, pode parecer simples, mas quando a velocidade é o seu primeiro quesito, isso pode mudar um pouco. Mas espera aí, é apenas ler um arquivo e fazer um split pegar a chave e o valor. Simples assim mesmo, mas quando o assunto é shell script um simples split não é tão simples.
A primera forma de se fazer seria fazer com um cut, veja:
1
| echo "chave=valor" | cut -d = -f 1 |
Legal, funciona, mas quando seu arquivo de properties é grande, ou que esse script rode toda hora, a velocidade do um simples cut que funciona passa a ser um problema.
Uma outra forma de se fazer isso é usar o IFS – Internal Field Separator para fazer isso de uma forma decente.
Então, vamos lá. Pimeiro meu arquivo de propriedades:
sample.properties
1
2
| caminho=/tmp
version=1.0 |
Fiz um script simples para representar o problema. Função rox com IFS e função sux com CUT.
sample.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| #!/bin/bash
rox(){
IFS_OLD=$IFS
IFS="="
while read key value
do
echo "key = $key"
echo "Value = $value"
done < sample.properties
IFS=$IFS_OLD
}
sux(){
while read line
do
key=`echo $line | cut -d = -f 1`
value=`echo $line | cut -d = -f 2`
echo "key = $key"
echo "Value = $value"
done < sample.properties
}
clear
echo "rox--------------------------------------"
time rox
echo "sux--------------------------------------"
time sux |
Veja o resultado:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| rox--------------------------------------
key = caminho
Value = /tmp
key = version
Value = 1.0
real 0m0.001s
user 0m0.000s
sys 0m0.000s
sux--------------------------------------
key = caminho
Value = /tmp
key = version
Value = 1.0
real 0m0.024s
user 0m0.007s
sys 0m0.019s |
Notem a velocidade do script. Não é ser xiita, mas sim fazer da forma correta. 
Um modulo simples para python, cheetah. Ele tem tudo que programadores python gosta, simples, bem documentado, comunidade ativa, rápido, possui um mecanismo de cache entre outras funcionalidades.
Onde baixar?
http://www.cheetahtemplate.org
Instalando
1
| python setup.py install |
1
2
3
4
| class Cliente():
def __init__(self, nome, email):
self.nome = nome
self.email = email |
1
2
3
4
5
6
7
8
9
10
11
12
13
| <html>
<head><title>$title</title></head>
<body>
<div>
#for $cliente in $clientes
<div>
<b>$cliente.nome</b>
(<a href="mailto:$cliente.email">$cliente.email</a>)
</div>
#end for
</div>
</body>
</html> |
1
2
3
4
5
6
7
8
9
10
11
12
| from Cheetah.Template import Template
if __name__ == "__main__":
clientes = [Cliente("Eliezer Rodrigues", "eliezer@teste.net"),
Cliente("Maria", "maria@teste.net")]
template = Template(file="page.tpl")
template.title = "Todos os clientes"
template.clientes = clientes
print str(template) |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| <html>
<head><title>Todos os clientes</title></head>
<body>
<div>
<div>
<b>Eliezer Rodrigues</b>
(<a href="mailto:eliezer@teste.net">eliezer@teste.net</a>)
</div>
<div>
<b>Maria</b>
(<a href="mailto:maria@teste.net">maria@teste.net</a>)
</div>
</div>
</body> |
Curtiu?? para saber mais sobre o projeto entre no guia do usuário e confira tudo sobre o cheetah.
Uma das coisas que considero mais ruins de se ler em um código são os malditos ifs encadeados. Veja, não é fácil de se ler, não é confiável e bem mais propício a bug. Portando se tem muitos ifs, algo não está correto.
Vou utilizar polimorfismo para implementar o padrão de projeto Strategy.
Um fiz um caso simples apenas para exemplificar o estudo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| public class StringUtils {
public static final String REMOVE_ALL_SPACES = "remove-all-spaces";
public static final String FILTER_ONLY_NUMBERS = "filter-only-numbers";
public static String format(String action, String value) {
if (REMOVE_ALL_SPACES.equals(action)) {
return value.replaceAll("\\s", "");
} else if (FILTER_ONLY_NUMBERS.equals(action)) {
return value.replaceAll("\\D", "");
}
return null;
}
} |
Bom não é tão feio, pq tb quem nunca viu algo pior que isso que atire a primeira pedra. Vamos fazer com que esse método format seja mais simples. No caso ele está com apenas duas comparações, mas lembre-se que poderiam ser 18. 
Mas dá pra melhorar e muito utilizando Enum. Veja:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public enum StringFormat {
TRIM_SPACES() {
@Override
public String format(String value) {
return value.replaceAll("\\s", "");
}
},
ONLY_NUMBERS() {
@Override
public String format(String value) {
return value.replaceAll("\\D", "");
}
};
public abstract String format(String value);
} |
E agora o nosso objetivo final, remover os ifs e else do método format:
1
2
3
4
5
6
| public class StringUtils {
public static String format(StringFormat action, String value) {
return action.format(value);
}
} |
Legal né?
