Trabalho de Power Shelll

Trabalho de power shell

1- Introdução

Nesse trabalho iremos falar de power shell tanto windows power shel como o shell do linux, baseado em varias pesquisas, da internet foi verificado muitas fontes de estudo sobre power shell. Uma das fontes está nesse contexto que iremos falar nesse trabalho. Indice

1- introdução

2- versões

3- antecedentes

4- resumo 4.1- Cmdlets 4.2- PowerShell scripts 4.3- Funções PowerShell 4.4- Programas executáveis. 5- cmdlets

6- pipeline

7- script

8- hospedagem

9- PowerShell 2.0 10- O que é shell linux? 11- Comandos a. Ls

 b. Pwd c. Cd d. Mkdir  e. Rmdir  f. Rm g. Dv h. Df  i. Free  j. Find k. Whoami l. Who m. Hosname n. Su o. Echo  p. Mount q. Umount r. Cat s. More t. Grep u. Ps v. Top w. Tar  x. Pipe 12- redirecionamento 13- usando o bash 14- conceito de variaveis de shell script 15- comando de fluxo com if  16- outras alternativas 17- se aprofundando mais 18- case 19- for while 20- until 21- usando varios scripts em um só 22- variaveis especiais

 b. Pwd c. Cd d. Mkdir  e. Rmdir  f. Rm g. Dv h. Df  i. Free  j. Find k. Whoami l. Who m. Hosname n. Su o. Echo  p. Mount q. Umount r. Cat s. More t. Grep u. Ps v. Top w. Tar  x. Pipe 12- redirecionamento 13- usando o bash 14- conceito de variaveis de shell script 15- comando de fluxo com if  16- outras alternativas 17- se aprofundando mais 18- case 19- for while 20- until 21- usando varios scripts em um só 22- variaveis especiais

23- funções 24- exemplo final 25- janelas graficas 26- conclusao 27- bibliografias

2- Versões

Inicialmente, utilizando o nome de código "Monad", PowerShell foi exibido publicamente na Professional Developers Conference, em setembro de 2003. Atualmente existem duas versões do PowerShell suportado pela Microsoft [6]. A versão 1.0 foi lançada em 2006 para o Windows XP SP2/SP3, Windows Server 2003 e Windows Vista. Para o Windows Server 2008, é incluído como um recurso opcional. A versão 2.0 está integrado com o Windows 7 e Windows Server 2008 R2 e é liberado para o Windows XP com Service Pack 3, Windows Server 2003 com Service Pack 2, Windows Vista com Service Pack 1 e Windows Server 2008 [7]. 3- Antecedentes

Cada versão lançada do Microsoft DOS e do Microsoft Windows para computadores pessoais tenha incluído uma ferramenta de interface de linha de comando (shell). Estes são COMMAND.COM (nas instalações confiando em MS-DOS, incluindo o Windows 9x) e cmd.exe (nos sistemas operacionais Windows NT familiar). Estes são os intérpretes de comando de linha regular que o apoio de alguns comandos básicos. Para outros fins, um aplicativo separado do console deve ser fornecida, a ser invocado a partir destes reservatórios. Incluem também uma linguagem de script (batch files), que pode ser usado para automatizar várias tarefas. No entanto, eles não podem ser  usados para automatizar todas as facetas da funcionalidade do GUI, em parte por  causa da linha de comandos equivalentes de operações expostas através da interface

gráfica são limitados, ea linguagem é fundamental e não permite a criação de scripts complexos. No Windows Server 2003, a situação melhorou [8], mas o apoio script foi ainda considerado insatisfatório. Microsoft tentou abordar algumas destas deficiências com a introdução do Windows Script Host, em 1998, com Windows 98, e sua linha de comando baseado em host: cscript.exe. Ele se integra com o mecanismo de script ativo e permite que os scripts sejam escritos em linguagens compatíveis, como o JScript e VBScript, alavancando as APIs expostas por aplicações via COM. No entanto, ele também tem suas próprias deficiências: não é integrado com o shell, sua documentação não é muito acessível, e rapidamente ganhou uma reputação como um vetor de vulnerabilidade do sistema depois de vários vírus de computador de alto perfil explorar fraquezas em suas disposições de segurança. Diferentes versões do Windows desde vários efeitos especiais intérpretes de linha de comando (como netsh e WMIC) com os seus conjuntos de comando próprio. Nenhum deles estava integrado com o shell de comando, nem eram interoperáveis. Em 2003 a Microsoft começou a desenvolver um novo shell chamada Monad (também conhecido como a Shell ou a Microsoft MSH). Mônada era para ser um novo comando shell extensível com um novo design que seria capaz de automatizar uma ampla gama de tarefas administrativas do núcleo. A Microsoft publicou a primeira versão beta pública sobre Mônada 17 de junho de 2005, Beta 2 em 11 de setembro de 2005, e Beta 3 em 10 de janeiro de 2006. Eles anunciaram em 25 de abril de 2006 que tinha sido rebatizada Mônada Windows PowerShell, posicionando-o como uma parte significativa das suas ofertas de tecnologia de gestão [9]. Release Candidate 1 do PowerShell foi lançado ao mesmo tempo. Release Candidate 2 do PowerShell foi lançado em 26 de setembro de 2006 e lançado para a web (RTW) em 14 de novembro de 2006. PowerShell para o Vista foi lançado em 30 de janeiro de 2007. [10] A previsão de última tecnologia da comunidade (CTP) do Windows PowerShell v2.0 foi disponibilizado em dezembro de 2008. PowerShell v2.0 foi concluído e liberado para fabricação, em agosto de 2009, como parte integrante do Windows 7 e Windows Server 2008 R2. As versões do PowerShell para o Windows XP, Windows Server 2003, Windows Vista e Windows Server 2008 foram liberados em outubro de 2009 e estão disponíveis para download para os de 32 bits e plataformas de 64 bits [11].

4- Resumo

Existem quatro tipos de comandos do Windows PowerShell pode executar: * "Cmdlets", o que são. NET programas, escritos por um desenvolvedor, compilado em uma biblioteca de vínculo dinâmico e carregado por um script PowerShell, * PowerShell scripts (arquivos com o sufixo '. Ps1), * Funções PowerShell, * Programas executáveis. Se um comando é um programa executável, PowerShell lança-lo em um processo separado, se ele é um cmdlet, é executado no processo de PowerShell. PowerShell também fornece uma interface de linha de comando interativo, onde os comandos podem ser inseridos e sua produção exibida. A interface do usuário, com base no console Win32, oferece a conclusão de tabulação personalizados, mas não tem destaque de sintaxe. PowerShell também permite a criação de apelidos para cmdlets, textualmente, que são traduzidos por PowerShell em invocações dos comandos originais. PowerShell também oferece suporte a parâmetros nomeados e posicionais para os comandos. Ao executar um cmdlet, a tarefa de vincular o valor do argumento para o parâmetro é feito através do PowerShell em si, mas, para executáveis externos, os argumentos são passados através do argv (ou equivalente) de matriz variável a ser  analisada pelo executável. Outro conceito utilizado pelo PowerShell é o de um gasoduto. Como Unix gasodutos, oleodutos PowerShell são usados para compor comandos complexos, permitindo a saída de um comando a ser passado como entrada para outro. Um pipeline é configurado por uma tubagem de saída de um comando (ou pipeline) para outro comando, usando o operador |. Mas, ao contrário de suas contrapartes Unix, o gasoduto PowerShell é um objeto de pipeline, ou seja, os dados passados entre cmdlets são totalmente digitado objetos, ao invés de caráter córregos. Quando os dados são encaminhados como objetos, os elementos que encapsulam manter a sua estrutura e tipos em todo cmdlets, sem necessidade de qualquer serialização ou análise explícita do fluxo, como seria o personagem precisa se apenas córregos foram compartilhadas. Um objeto também pode encapsular determinadas funções que

trabalham sobre os dados contidos. Estes também ficam disponíveis para o comando do destinatário para usar. [12] [13] Para o cmdlet passado em um gasoduto, PowerShell automaticamente tubos de seu objeto de saída para o cmdlet Out-padrão, que transforma os objetos em um fluxo de objetos de formato e, em seguida, torna os para a tela. [14] [15] Como todos os objetos são PowerShell. NET, eles compartilham uma. ToString (), que recupera a representação de texto de dados em um objeto. Windows PowerShell usa esse método para converter um objeto de texto. Além disso, ele também permite que as definições de formatação para ser especificado, para a representação do texto dos objetos podem ser personalizados, escolhendo quais os elementos de dados para exibir, e como. No entanto, a fim de manter compatibilidade com versões anteriores, se um executável externo é utilizado em um oleoduto, que recebe um fluxo de texto que representa o objeto, e não se integram com o sistema de tipo PowerShell. O PowerShell Extended Type System (ETS) é baseada no tipo de sistema. NET, mas com uma semântica estendida (por exemplo propertySets e 3 de extensibilidade do partido). Por exemplo, ele permite a criação de pontos de vista diferentes de objetos, expondo apenas um subconjunto dos campos de dados, propriedades e métodos, bem como especificar a formatação personalizada e classificação de comportamento. Estas visões são mapeados para o objeto original usando arquivos de configuração baseada em XML [16].

5- Cmdlets

Cmdlets são especializados comandos no ambiente PowerShell que implementam funções específicas. Estes são os comandos nativos do PowerShell pilha. Cmdlets seguir um - padrão de nomenclatura, como Get-ChildItem, ajudando a torná-las auto-descritivo [17] saída Cmdlets seus resultados como objetos ou coleções de suas obras (incluindo matrizes), e opcionalmente pode receber a entrada. dessa forma, tornando-os adequados para uso como destinatários de um gasoduto. Mas, enquanto PowerShell permite matrizes e outras coleções de objetos a serem gravados para o gasoduto, cmdlets sempre objetos de processo individualmente. Para coleções de objetos, PowerShell chama o cmdlet em cada objeto na coleção, em seqüência [17].

Cmdlets são especializados. NET, que o tempo de execução PowerShell instancia e chama quando eles são executados. Cmdlets derivar a partir Cmdlet ou PSCmdlet, sendo esta última utilizada quando o cmdlet precisa interagir com o tempo de execução PowerShell [17] Estas classes base especificar determinados métodos -. BeginProcessing (), ProcessRecord () e EndProcessing () - uma das quais a execução do cmdlet substituições para fornecer a funcionalidade. Sempre que um cmdlet é executado, esses métodos são invocados pelo PowerShell em seqüência, com ProcessRecord () sendo chamado, se ele receber input pipeline. [18] Se uma coleção de objetos é encanada, o método é invocado para cada objeto na coleção. A classe que implementa o cmdlet deve ter um atributo NET -. CmdletAttribute - que especifica o verbo eo substantivo que compõem o nome do cmdlet. Verbos comuns são fornecidos como um enum. Se um cmdlet recebe uma ou outra entrada gasoduto ou de linha de comando de entrada de parâmetro, deve haver uma propriedade correspondente na classe, com uma implementação modificador. PowerShell invoca o modificador com o parâmetro ou valor de entrada do pipeline, que é salvo pela implementação modificador de variáveis de classe. Estes valores são então encaminhados para com os métodos que implementam a funcionalidade. Propriedades que os parâmetros mapa para linha de comando são marcadas por ParameterAttribute [19] e são definidos antes da chamada para BeginProcessing (). Aqueles que mapeiam a entrada do pipeline são também ladeada por ParameterAttribute, mas com o conjunto de parâmetros atributo ValueFromPipeline [20]. A implementação destas classes cmdlet pode se referir a qualquer. NET API e podem ser em qualquer idioma. NET. Além disso, o PowerShell faz certas APIs disponíveis, como WriteObject (), que é usado para acessar as funcionalidades específicas do PowerShell, como escrever objetos resultantes do gasoduto. Cmdlets pode usar. NET APIs de acesso a dados diretamente ou usar a infra-estrutura do PowerShell PowerShell Providers, que fazem armazena dados endereçáveis usando caminhos únicos. armazena dados são expostos, usando letras de unidade, e hierarquias dentro deles, tratados como diretórios. O Windows PowerShell com os fornecedores para o sistema de arquivo, registro, armazenamento de certificados, bem como os namespaces para aliases de comando, variáveis e funções. [21] O Windows PowerShell também inclui vários cmdlets para gerenciar vários sistemas Windows, incluindo o sistema de arquivos, ou usando o Windows Management Instrumentation para controlar os componentes do Windows. Outras aplicações podem se registrar 

com o PowerShell cmdlets, permitindo assim que a gerenciá-los e, se envolver  qualquer armazenamento de dados (como bancos de dados), eles podem adicionar  provedores específicos também. Em PowerShell V2, uma versão mais portátil do Cmdlets chamados módulos foram adicionados. O PowerShell V2 liberação estado notas, Módulos "permitem que os desenvolvedores e administradores de script para particionar e organizar as suas código do Windows PowerShell em auto-contido, unidades reutilizáveis. Código de um módulo é executado em seu próprio contexto auto-suficiente e não afeta o estado fora do o módulo. módulos também permitem que você defina um ambiente restrito espaço de execução usando um script ". 6- Pipeline

PowerShell, como conchas Unix / Linux based, implementa um pipeline. Este oleoduto permite a saída de um cmdlet para ser canalizado como entrada para outro cmdlet. Por exemplo, a saída do cmdlet Get-Process pode ser canalizada para o processo de triagem de objetos (por exemplo, para classificar os objetos de contagem de identificador) e depois para o Where-Object para filtrar qualquer processo que, menos de 1 MB de paginada memória e, finalmente, para o cmdlet Selecionar Objeto para selecionar apenas os primeiros 10 (ou seja, os 10 processos com base na contagem de identificador). Enquanto Unix / Linux há muito tempo empregado o conceito de dutos, PowerShell é diferente no que se passou entre as fases do pipeline. Em Unix a saída de um comando é canalizada para a próxima fase do gasoduto tipicamente como texto puro. Com o PowerShell, o gasoduto consiste. NET Objects. Usando objetos elimina a necessidade de analisar a saída do texto arbitrário de um comando para extrair dados uma vez que todos os objetos exportar uma interface consistente [22]. 7- Script

O Windows PowerShell inclui uma linguagem dinamicamente tipada script que pode executar operações complexas usando os cmdlets imperativa. A linguagem de script suporta variáveis, funções, ramificação (if-then-else), loops (while, do, for e foreach), erro estruturado / manipulação de exceção e encerramentos expressões / lambda, bem como integração com o. NET. Variáveis em scripts PowerShell têm nomes que

começam com $, pois eles podem ser atribuído qualquer valor, incluindo a saída de cmdlets. Embora a linguagem não é digitado, internamente, as variáveis são armazenadas com os seus tipos, que podem ser tipos primitivos ou objetos. Strings podem ser delimitados por aspas simples ou aspas duplas: quando se utilizam aspas, variáveis será ampliado mesmo que estejam dentro das aspas. De acordo com a sintaxe da variável, se o caminho para um arquivo é colocado entre chaves precedidas por um cifrão ($ {como em C: \ foo.txt}), refere-se ao conteúdo do arquivo. Se ele é usado como um valor de L, qualquer coisa que lhe é atribuída será gravada no arquivo. Quando usado como um valor-R, que será lido do arquivo. Se um objeto é atribuído, é serializado antes de guardá-lo. Membros do objeto pode ser acessado usando. notação, como na sintaxe C #. PowerShell fornece variáveis especiais, tais como $ args, que é uma matriz de todos os argumentos de linha de comando passados para uma função na linha de comando, e $ _, que se refere ao objeto atual no pipeline [23]. PowerShell também fornece matrizes e matrizes associativas. A linguagem de script PowerShell também avalia expressões aritméticas entrou na linha de comando imediatamente, e ele analisa as abreviações comuns, como GB, MB e KB. Usando a palavra-chave function, PowerShell prevê a criação de funções, que podem aceitar parâmetros. Um problema comum para pessoas que PowerShell é que os argumentos da função são separadas por espaços, e não vírgulas: 1. : Chama a função com dois argumentos. (Estes argumentos podem ser vinculados a parâmetros declarados na definição da função ou acessado pela posição do array $ args). 2. (, ): Chama a função com um único argumento, uma matriz de dois elementos. PowerShell permite que qualquer método a ser chamado de NET, fornecendo os seus espaços entre parênteses ([]), e em seguida, usando um par de dois pontos. (:) Para indicar o método estático [24] Por exemplo, [System.Console].: : WriteLine ("PowerShell"). Os objetos são criados usando o cmdlet New-Object. Chamando métodos de objetos. NET é realizado usando o regular. notação [24]. Para o tratamento de erros, PowerShell fornece uma. Mecanismo de manipulação NET baseado exceção. Em caso de erros, os objetos que contenham informações

sobre o erro (objeto de exceção) são lançados, que são pegos usando a palavrachave armadilha. No entanto, a ação ou de erro é configurável, em caso de erro, o PowerShell pode ser configurado para continuar a execução em silêncio, sem aprisionamento de exceção [25]. Os scripts escritos usando o PowerShell pode ser feita para persistir ao longo das sessões em um arquivo. Ps1. Mais tarde, tanto o script inteiro ou funções individuais no script pode ser usado. Scripts e funções são usadas de forma análoga com os cmdlets, na medida em que podem ser usados como comandos nos oleodutos, e os parâmetros podem ser vinculados a eles. Pipeline objetos podem ser passados entre as funções, scripts e cmdlets perfeitamente. No entanto, a execução do script é desativado por padrão e deve ser ativado explicitamente [26]. Scripts PowerShell pode ser assinado para verificar sua integridade, e estão sujeitas Code Access Security. A linguagem de script PowerShell suporta a notação de prefixo binário semelhante à notação científica apoiada por muitas linguagens de programação C na família.

8- Hospedagem

Outro uso do PowerShell está sendo incorporado em um aplicativo de gerenciamento, que usa o runtime PowerShell para implementar a funcionalidade de gestão. Para isso, PowerShell fornece uma API de hospedagem gerenciada. Via as APIs, a aplicação pode instanciar um espaço de execução (uma instanciação do tempo de execução PowerShell), que será executado no processo do aplicativo e é exposto como um objeto de espaço de execução. [2] O estado do espaço de execução é encerrada em um objeto sessionState. Quando o espaço de execução é criado, o Windows PowerShell runtime inicializa a instanciação, inicialização, incluindo os prestadores e enumerando os cmdlets, e atualiza o objeto sessionState conformidade. O espaço de execução, em seguida, deve ser aberto para qualquer processamento síncrono ou assíncrono processamento. Depois disso ele pode ser usado para executar comandos. Para executar um comando, um oleoduto (representada por um objeto de pipeline) deve ser criado e associado com o espaço de execução. O objeto de pipeline é então preenchida com os cmdlets que compõem o duto. Para operações seqüenciais (como em um script PowerShell), um objeto de Pipeline é criado para cada afirmação e aninhado dentro de outro objeto de Pipeline. [2] Quando é criado um gasoduto, o

Windows PowerShell invoca o processador pipeline, o que resolve os cmdlets em suas respectivas assembléias (o processador de comando) e adiciona uma referência a eles para o gasoduto, e associa-los com um, InputPipe Outputpipe ErrorOutputPipe e objetos, para representar a conexão com o gasoduto. . Os tipos são verificados e os parâmetros vinculados usando reflexão [2] Uma vez que o gasoduto esteja configurado, o apresentador chama o método invoke () para executar os comandos, ou seu equivalente assíncrona - InvokeAsync (). Se o gasoduto tem o cmdlet write-host no final do gasoduto, que escreve o resultado na tela do console. Se não, os resultados são entregues ao host, que pode ser aplicado tanto a processamento posterior ou exibi-lo em si. As APIs de hospedagem são utilizadas pelo Microsoft Exchange Server 2007 para fornecer a sua gestão GUI. Cada operação exposta na interface do usuário é mapeado para uma seqüência de comandos do PowerShell (ou gasodutos). O host cria o gasoduto e executa-los. Na verdade, o PowerShell console interativo em si é um host PowerShell, que interpreta os scripts entrou na linha de comando e cria os objetos necessários Pipeline e invoca-los. 9- PowerShell 2.0

Windows PowerShell ISE, com várias sessões abertas PowerShell (espaços de execução) no Windows PowerShell 2,0 A Microsoft lançou o PowerShell 2.0 com o Windows 7 e Windows Server 2008 R2. Windows PowerShell 2.0 está instalado por padrão no Windows Server 2008 R2 e Windows 7. [27] Para plataformas mais antigas que está disponível através do Windows Management Framework [28]. PowerShell V2 inclui alterações para a linguagem de scripting e API de hospedagem, além de incluir mais de 240 novos cmdlets. [29] [30] Uma lista não exaustiva dos novos recursos incluídos no PowerShell V2 é: [31] [32[33] * PowerShell Remoting: Usando o WS-Management, PowerShell 2.0 permite que os scripts e os cmdlets para ser chamado em uma máquina remota ou a um grande conjunto de máquinas remotas. * Background Empregos: Também chamado de PSJob, permite que uma sequência de comandos (script) ou por oleoduto para ser chamado de forma assíncrona. Os

trabalhos podem ser executados no computador local ou em vários computadores remotos. Um cmdlet interativa em blocos PSJob a execução do trabalho até a entrada do usuário é fornecido. * Transações: cmdlet Enable e desenvolvedores de provedor para executar  operações transacionais. PowerShell 2.0 inclui cmdlets transação para a partida, cometendo, e reversão de uma PSTransaction bem como recursos para gerenciar e dirigir a operação para o cmdlet participantes e as operações do provedor. O PowerShell provedor Secretaria oferece suporte a transações. * ScriptCmdlets: Estes são os cmdlets escrito usando a linguagem de script PowerShell. NOTA: O nome preferido para cmdlets script está agora Funções Avançadas. SteppablePipelines *: Isso permite que o usuário controle quando o BeginProcessing (), ProcessRecord () e EndProcessing () funções de um cmdlet são chamados. * Módulos: Este script permite que desenvolvedores e administradores de organização e de partição de scripts PowerShell em auto-contido, unidades reutilizáveis. Código de um módulo é executado em seu próprio contexto autosuficiente e não afeta o estado fora do módulo. Os módulos podem definir um ambiente restrito espaço de execução usando um script. Eles têm um estado persistente, bem como os membros públicos e privados. * Dados Idioma: Um subconjunto de domínio específico da linguagem de script PowerShell, que permite a definição dos dados deverá ser dissociada dos scripts e permitir que recursos seqüência localizada a ser importado para o script em tempo de execução (Script Internacionalização). * Script Debugging: Ela permite que os pontos de interrupção a ser definido em um script PowerShell ou função. Breakpoints podem ser definidas em linha linhas, e colunas, comandos e ler ou escrever acesso de variáveis. Ele inclui um conjunto de cmdlets para controlar os pontos de interrupção via script. * Evento: Este recurso permite que ouvir, encaminhar e actuar em eventos de gestão e de sistema. Eventos PowerShell permite hosts para ser notificado sobre as mudanças de estado às suas entidades geridas. Ele também permite que os scripts do PowerShell para assinar ObjectEvents, PSEvents e WmiEvents e processá-los de forma síncrona e assíncrona. * Windows PowerShell Integrado Scripting Ambiente (ISE): PowerShell 2.0 inclui uma interface gráfica baseada em host PowerShell (anteriormente conhecido como gráfico do Windows PowerShell) que fornece depurador integrado, sintaxe destacando, preenchimento de guias e até 8 PowerShell habilitado para Unicode

consoles (espaços de execução) em uma interface com abas, bem como a habilidade de executar somente as partes selecionadas em um script. * Rede de Transferência de Arquivo:. Suporte nativo para a transferência de prioridade, estrangulado, e assíncrona de arquivos entre máquinas usando o Background Intelligent Transfer Service (BITS) [34] * Novo Cmdlets Incluindo: Out-GridView que exibe dados tabulares no objeto GridView WPF. * Novos operadores:-Split, Join-e splatting (@) operadores. * Exceção com Try-Catch-Finally:. Ao contrário de outros idiomas NET, isso permite que múltiplos tipos de exceção de um único bloco catch. * Aqui Nestable-Strings: PowerShell Aqui-Cordas foram melhorados e agora pode ninho [35]. * Comentários Bloco: PowerShell 2.0 suporta comentários em bloco usando como delimitadores [36]. * Novas APIs: A gama de novas APIs de entregar mais controle sobre o analisador  PowerShell e tempo de execução para o acolhimento, a criação e gerenciamento de coleção de espaços de execução (RunspacePools), bem como a capacidade de criar  espaços de execução restrita que só permite um subconjunto configurado de PowerShell ser invocado. As novas APIs também apoiar a participação em um Windows PowerShell conseguiu transação.

10- O que é Shell linux?

Relembrando os artigos de "Linux mais a fundo" , shell é um programa que permite ao usuário iteragir com o sistema operacional através de comandos digitados do teclado. No DOS o shell era o command.com, que permitia executar alguns comandos como: cd, dir, ... O shell mais famoso de Linux é o Bash, pois o mesmo oferece vários recursos que facilitam a vida do usuário. O mais básico é o sh. Em todos estes é possível criar  scripts (mini-programas) que executam sequências de comandos, como se estivessem sidos digitados pelo usuário.

Lembremos que para um usuário normal, o shell aparece com o símbolo $ . Já para o root, o símbolo é o # . 11- Comandos

Qualquer dúvida em um dos comandos abaixo, rode o man. Por exemplo, se estiver  com dúvida no comando ls : $ man ls LS

O ls é o comando mais básico de um shell. Ele serve para listar o conteúdo de um diretório, mostrando os arquivos que estão no mesmo. Exemplos: Listar o diretório atual: $ ls Listar o diretório /etc: $ ls /etc Listar o diretório atual mostrando todos os detalhes dos arquivos: $ ls -l Mostrar arquivos ocultos (que começam com . (ponto final)): $ ls -a Combinando os dois últimos comandos acima: $ ls -la PWD

O pwd mostra o diretório atual: $ pwd CD CD vem de C hange D irectory (mudar de diretório) e serve justamente para mudar o

diretório atual. Exemplo: $ pwd /home/luke

$ cd / $ pwd / MKDIR

O mkdir cria diretórios: $ mkdir tmp RMDIR

O rmdir apaga diretórios vazios (como o tmp acima): $ rmdir tmp RM

O rm serve para apagar arquivos: $ rm imagem.jpg Para apagar diretórios e seu conteúdo: $ rm -rf tmp DU

O comando du verifica o tamanho de diretórios e seus subdiretórios: $ du /etc DF

O df verifica o quanto você tem disponível nas suas partições e o quanto foi gasto: $ df  Para visualizar melhor (em MegaBytes): $ df -h FREE

O free mostra quanto você tem de memória RAM e swap, gastos e livres: $ free FIND

O find procura por arquivos em um diretório e seus subdiretórios. Neste exemplo vou procurar arquivos JPG a partir do diretório atual: $ find . -name *jpg Agora vou procurar arquivos MPG no diretório do CDROM: $ find /cdrom -name *mpg

WHOAMI

O whoami retorna o usuário logado no momento (que executou este comando): $ whoami WHO

O who mostra os usuários logados no sistema: $ who HOSTNAME

O hostname retorna o nome do computador (na rede, ou não) que se está usando: $ hostname SU

O su muda para o root ou para outro usuário: $ su Passwd: ou $ su baptista Passwd: $ ECHO

O echo escreve um conjunto de caracteres na tela: $ echo "OLinux é um bom site!" OLinux é um bom site! MOUNT

O mount monta (ativa) devices: $ mount /floppy UMOUNT

O umount desmonta (desativa) devices: $ umount /floppy CAT

O cat imprime arquivos na tela: $ cat README

MORE

O more imprime arquivos a tela, porém para esperando um retorno do teclado a cada tela cheia: $ more README GREP

O grep é uma ferramenta muito poderosa, principalmente para programadores. GREP = Generalized Regular Expression Parser. Facilitando para entender, ele procura por  um texto dentro de uma arquivo. Neste exemplo procuro por "autor" dentro do "README": $ grep autor README PS

O ps mostra todos os processos (programas) que estão rodando na memória. Vendo os processos do usuário: $ ps Vendo todos os processos do sistema (de todos os usuários): $ ps aux TOP

O top mostra todos os processos que estão rodando com várias outras informações do sistema: $ top TAR

O tar server para compactar e descompactar arquivos no formato .tar.gz (tar e gzip). Compactando: $ tar cvfz arquivo.tar.gz [arquivos|diretório] Descompactando: $ tar xvfz arquivo.tar.gz Pipe

Podemos usar o símbolo especial | para fazer o que chamamos de pipe, que nada mais é do que a conexão da saída de dois programas. Neste exemplo, eu vou procurar em todos os processos do sistema pelo que contém o texto "init": $ ps aux | grep init

Ou seja, a saída de ps aux funciona como o arquivo para o grep init . É como fazer  ps aux e gravar sua saída num arquivo chamado teste , por exemplo. E depois fazer  grep init teste . Só que o pipe faz tudo automático, conectando a saída do ps com a

entrada do grep neste exemplo (sem a necessidade de um arquivo intermediário). Outro exemplo: $ ls -l | more Neste exemplo a saída do ls é usada pelo more . Ou seja, o ls -l é impresso na tela pausadamente, como se fosse um arquivo usado pelo more . 12- Redirecionamento

Além do pipe, podemos usar o redirecionamento. Para isso, usamos os símbolos < e > , significando entrada e saída respectivamente. Vamos a um exemplo. Imagine que eu queira guardar o resultado do ls na tela. Então faria assim: $ ls > teste O arquivo teste foi criado com o que o ls imprimiria na tela. 13- Usando o Bash

Agora vamos ver algumas facilidades do bash. O bash possui história, ou seja, cada vez que apertamos a tecla que representa uma seta para cima, temos um comando já executado anteriormente. Se apertamos uma vez, temos o último comando executado. Se apertamos duas vezes, temos o penúltimo comando executado. E assim por diante. Quando estamos digitando um diretório ou arquivo, ao apertarmos a tecla TAB, nos aparece o nome do arquivo todo. Ou seja, ele é completado automaticamente para você. Caso não seja, o bash emite um som via speaker. Se você apertar o TAB e sair  este som, aperte de novo o TAB que ele irá lhe mostrar as opções de complemento de nome. Por exemplo, imagine que no diretório atual eu tenho dois arquivos: teste1.txt e teste2.txt . Agora digito (sem apertar ENTER):

$ cat t Agora aperto TAB e ele completa o nome e emite o som:

$ cat teste Então aperto TAB novamente e me aparecem as opções (pois ele não sabe qual eu quero): $ cat teste teste1.txt teste2.txt Basta eu digitar mais um caractere (1 ou 2): $ cat teste1 E apertar TAB novamente: $ cat teste1.txt ENTER

ou variações como o bash. O ue muita gente não sabe é que o sh ou o bash têm uma “poderosa” linguagem de script embutido nelas mesmas. Diversas pessoas utilizam-se desta linguagem para facilitar a realização de inúmeras tarefas administrativas no Linux, ou até mesmo criar seus próprios programinhas. Patrick Volkerding, criador da distribuição Slackware, utiliza esta linguagem para toda a instalação e configuração de sua distribuição. Você poderá criar scripts para automar as tarefas diárias de um servidor, para efetuar backup automático regularmente, procurar textos, criar  formatações, e muito mais. Para você ver como esta linguagem pode ser útil, vamos ver  alguns passos introdutórios sobre ela. Interpretadores de comandos são programas feitos para intermediar o usuário e seu sistema. Através destes interpretadores, o usuário manda um comando, e o interpretador  o executa no sistema. Eles são a “Shell” do sistema Linux. Usaremos o interpretador de comandos bash, por ser mais “extenso” que o sh, e para que haja uma melhor  compreensão das informações obtidas aqui, é bom ter uma base sobre o conceito de lógica de programação. Uma das vantagens destes shell scripts é que eles não precisam ser compilados, ou seja,  basta apenas criar um arquivo texto qualquer, e inserir comandos à ele. Para dar à este arquivo a definição de “shell script”, teremos que incluir uma linha no começo do arquivo (#!/bin/bash) e torná-lo “executável”, utilizando o comando chmod. Vamos seguir com um pequeno exemplo de um shell script que mostre na tela: “Nossa! Estou vivo!”: #!/bin/bash echo 'Nossa! Estou vivo!'

A primeira linha indica que todas as outras linhas abaixo deverão ser executadas pelo  bash (que se localiza em /bin/bash), e a segunda linha imprimirá na tela a frase “Nossa! Estou vivo!”, utilizando o comando echo, que serve justamente para isto. Como você  pôde ver, todos os comandos que você digita diretamente na linha de comando, você  poderá incluir no seu shell script, criando uma série de comandos, e é essa combinação de comandos que forma o chamado shell script. Tente também dar o comando ‘file arquivo’ e veja que a definição dele é de Bourne-Again Shell Script (Bash Script).

Contudo, para o arquivo poder se executável, você tem de atribuir o comando de executável para ele. E como citamos anteriormente, o comando chmod se encarrega disto: $ chmod +x arquivo

Pronto, o arquivo poderá ser executado com um simples “./arquivo”. 14- Conceito de Variáveis em shell script

Variáveis são caracteres que armazenam dados, uma espécie de atalho. O bash reconhece uma variável quando ela começa com $, ou seja, a diferença entre ‘palavra’ e ‘$palavra’ é que a primeira é uma palavra qualquer, e a outra uma variável. Para definir  uma variável, utilizamos a seguinte sintaxe: variavel="valor"

O ‘valor’ será atribuído a ‘variável ‘. Valor pode ser uma frase, números, e até outras variáveis e comandos. O valor pode ser expressado entre as aspas (“”), apóstrofos (”) ou crases (“). As aspas vão interpretar as variáveis que estiverem dentro do valor, os apóstrofos lerão o valor literalmente, sem interpretar nada, e as crases vão interpretar  um comando e retornar a sua saída para a variável. exemplos: $ variavel="Eu estou logado como usuário $user" $ echo $variavel Eu estou logado como usuário cla $ variavel='Eu estou logado como usuário $user' $ echo $variavel Eu estou logado como usuário $user $ variavel="Meu diretório atual é o `pwd`" $ echo $variavel Meu diretório atual é o /home/cla

Se você quiser criar um script em que o usuário deve interagir com ele, é possível que você queira que o próprio usuário defina uma variável, e para isso usamos o comando read, que dará uma pausa no script e ficarará esperando o usuário digitar algum valor e teclar enter. Exemplo: echo "Entre com o valor para a variável: " ; read variavel (O usuário digita e tecla enter, vamos supor que ele digitou 'eu sou um profissional em linux') echo $variavel eu sou um profissional em linux

15- Controle de fluxo com o if 

Controle de fluxo são comandos que vão testando algumas alternativas, e de acordo com essas alternativas, vão executando comandos. Um dos comandos de controle de

fluxo mais usados é certamente o if, que é baseado na lógica “se acontecer isso, irei fazer isso, se não, irei fazer aquilo”. exemplo: if [ -e $linux ] then echo 'A variável $linux existe.' else echo 'A variável -eq igual $linux não existe.' -ne diferente fi -gt maior -lt menor -o ou O que este pedaço de -d se for um diretório código faz? O if testa -e se existir a seguinte expressão: -z se estiver vazio Se a variável $linux -f se conter textos existir, então (then) -o se o usuário for o dono ele diz que que existe -r se o arquivo pode ser lido com o echo, se não -w se o arquivo pode ser alterado (else), ele diz que -x Se o arquivo pode ser executado não existe. O operador -e que usei é pré-definido, e você pode encontrar a listagem dos operadores na tabela:

16- Outras alternativas

Existem inúmeros comandos no Linux, e para explicar todos, teríamos de publicar um verdadeiro livro. Mas existem outras possibilidades de aprendizado desta língua, que também é usado em todas as programações. Primeiro de tudo você pode dar uma olhada na manpage do bash (comando man bash), que disponibilizará os comandos embutidos no interpretador de comandos. Uma das coisas essencias para o aprendizado é sair  coletando exemplos de outros scripts e ir estudando-os minuciosamente. Procure sempre

comandos e expressões novas em outros scripts e em manpages dos comandos. E por  último, mas não o menos importante, praticar bastante!  Na tabela a seguir, você pode encontrar uma listagem de comandos para usar em sua shell script: echo read exit sleep clear stty tput if case for Whil

Imprime texto na tela Captura dados do usuário e coloca numa variável Finaliza o script Da uma pausa em segundos no script Limpa a tela Configura o terminal temporariamente Altera o modo de exibição Controle de fluxo que testa uma ou mais expressões Controle de fluxo que testa varias expressões ao mesmo tempo Controle de fluxo que testa uma ou mais expressões Controle de fluxo que testa uma ou mais expressões

17- Se aprofundando mais

Falamos sobre o conceito da programação em Shell Script, e demos o primeiro passo  para construir nossos próprios scripts. Agora vamos nos aprofundar nos comandos mais complicados, aprendendo a fazer programas ainda mais úteis. Nestes comandos estão inclusos o case e os laços for, while e until. Além disso, vamos falar de funções e, por  último, teremos um programa em shell script. 18- Case

O case é para controle de fluxo, tal como é o if. Mas enquanto o if testa expressões não exatas, o case vai agir de acordo com os resultados exatos. Vejamos um exemplo: case $1 in parametro1) comando1 ; comando2 ;; parametro2) comando3 ; comando4 ;; *) echo "Você tem de entrar com um parâmetro válido" ;; esac

Aqui aconteceu o seguinte: o case leu a variável $1 (que é o primeiro parâmetro passado  para o programa), e comparou com valores exatos. Se a variável $1 for igual à “parametro1″, então o programa executará o comando1 e o comando2; se for igual à “parametro2″, executará o comando3 e o comando4, e assim em diante. A última opção (*), é uma opção padrão do case, ou seja, se o parâmetro passado não for igual a nenhuma das outras opções anteriores, esse comando será executado automaticamente. Você pode ver que, com o case fica muito mais fácil criar uma espécie de “menu” para o shell script do que com o if. Vamos demonstrar a mesma função anterior, mas agora usando o if: if [ -z $1 ]; then

echo "Você tem de entrar exit elif [ $1 = "parametro1" ]; comando1 comando2 elif [ $1 = "parametro2" ]; comando3 comando4 else echo "Você tem de entrar fi

com um parâmetro válido" then then

com um parâmetro válido"

Veja a diferença. É muito mais prático usar o case! A vantagem do if é que ele pode testar várias expressões que o case não pode. O case é mais prático, mas o if pode substituí-lo e ainda abrange mais funções. Note que, no exemplo com o if, citamos um “comando” não visto antes: o elif – que é uma combinação de else e if. Ao invés de fechar o if para criar outro, usamos o elif para testar uma expressão no mesmo comando if. 19- For 

O laço for vai substituindo uma variável por um valor, e vai executando os comandos  pedidos. Veja o exemplo: for i in * do cp $i $i.backup mv $i.backup /usr/backup done

Primeiramente o laço for atribuiu o valor de retorno do comando “*” (que é equivalente a um ls sem nenhum parâmetro) para a variável $i, depois executou o bloco de comandos. Em seguida ele atribui outro valor do comando “*” para a variável $1 e reexecutou os comandos. Isso se repete até que não sobrem valores de retorno do comando “*”. Outro exemplo: for original in *; do resultado=`echo $original | tr '[:upper:]' '[:lower:]'` if [ ! -e $resultado ]; then mv $original $resultado fi done

Aqui, o que ocorre é a transformação de letras maiúsculas para minúsculas. Para cada arquivo que o laço lê, uma variável chamada $resultado irá conter o arquivo em letras minúsculas. Para transformar em letras minúsculas, usei o comando tr. Caso não exista um arquivo igual e com letras minúsculas, o arquivo é renomeado para o valor da variável $resultado, de mesmo nome, mas com letras minúsculas. Como os exemplos ilustram, o laço for pode ser bem útil no tratamento de múltiplos arquivos. Você pode deixá-los todos com letras minúsculas ou maiúsculas sem precisar  renomear cada um manualmente, pode organizar dados, fazer backup, entre outras coisas.

20- While

O while testa continuamente uma expressão, até que ela se torne falsa. Exemplo: variavel="valor" while [ $variavel = "valor" ]; do comando1 comando2 done

O que acontece aqui é o seguinte: enquanto a “$variavel” for igual a “valor”, o while ficará executando os comandos 1 e 2, até que a “$variavel” não seja mais igual a “valor”. Se no bloco dos comandos a “$variavel” mudasse, o while iria parar de executar os comandos quando chegasse em done, pois agora a expressão $variavel = “valor” não seria mais verdadeira. 21- Until

Tem as mesmas características do while, a única diferença é que ele faz o contrário. Veja o exemplo abaixo: variavel="naovalor" until [ $variavel = "valor" ]; do comando1 comando2 done

Ao invés de executar o bloco de comandos (comando1 e comando2) até que a expressão se torne falsa, o until testa a expressão e executa o bloco de comandos até que a expressão se torne verdadeira. No exemplo, o bloco de comandos será executado desde que a expressão $variavel = “valor” não seja verdadeira. Se no bloco de comandos a variável for definida como “valor”, o until pára de executar os comandos quando chega ao done. Vejamos um exemplo para o until que, sintaticamente invertido, serve para o while também: var=1 count=0 until [ $var = "0" ]; do comando1 comando2 if [ $count = 9 ]; then var=0 fi count=`expr $count + 1` done

Primeiro, atribuímos à variável “$var” o valor “1″. A variável “$count” será uma contagem para quantas vezes quisermos executar o bloco de comandos. O until executa os comandos 1 e 2, enquanto a variável “$var” for igual a “0″. Então usamos um if para atribuir o valor 0 para a variável “$var”, se a variável “$count” for igual a 9. Se a variável “$count” não for igual a 0, soma-se 1 a ela. Isso cria um laço que executa o

comando 10 vezes, porque cada vez que o comando do bloco de comandos é executado, soma-se 1 à variável “$count”, e quando chega em 9, a variável “$var” é igualada a zero, quebrando assim o laço until. 22- Usando vários scripts em um só

Pode-se precisar criar vários scripts shell que fazem funções diferentes, mas, e se você  precisar executar em um script shell um outro script externo para que este faça alguma função e não precisar reescrever todo o código? É simples, você só precisa incluir o seguinte comando no seu script shell: . bashscript2

Isso executará o script shell “bashscript2″ durante a execução do seu script shell. Neste caso ele será executado na mesma script shell em que está sendo usado o comando. Para utilizar outra shell, você simplesmente substitui o “.” pelo executável da shell, assim: sh script2 tcsh script3

 Nessas linhas o script2 será executado com a shell sh, e o script3 com a shell tcsh. 23 - Variáveis especiais

$0 $1-$9 $# $? $$

Nome do script que esta sendo executado Parâmetros passados a linha de comando Numero de parâmetros passado Valor de retorno do ultimo comando em todo o shell script Número do PID (Process ID)

Você também encontra muitas variáveis, já predefinidas, na página de manual do bash (comando “man bash”, seção Shell Variables). 24- Funções

Funções são blocos de comandos que podem ser definidos para uso posterior em qualquer parte do código. Praticamente todas as linguagens usam funções que ajudam a organizar o código. Vejamos a sintaxe de uma função: funcao() { comando1 comando2 ... }

Fácil de entender, não? A função funcionará como um simples comando próprio. Você executa a função em qualquer lugar do script shell, e os comandos 1, 2 e outros serão executados. A flexibilidade das funções permite facilitar a vida do programador, como no exemplo final.

25- Exemplo Final

Agora vamos dar um exemplo de um programa que utilize o que aprendemos com os artigos. #!/bin/bash # Exemplo Final de Script Shell Principal() { echo "Exemplo Final sobre o uso de scripts shell" echo "------------------------------------------" echo "Opções:" echo echo "1. Trasformar nomes de arquivos" echo "2. Adicionar um usuário no sistema" echo "3. Deletar um usuário no sistema" echo "4. Fazer backup dos arquivos do /etc" echo "5. Sair do exemplo" echo echo -n "Qual a opção desejada? " read opcao case $opcao in 1) Transformar ;; 2) Adicionar ;; 3) Deletar ;; 4) Backup ;; 5) exit ;; *) "Opção desconhecida." ; echo ; Principal ;; esac } Transformar() { echo -n "Para Maiúsculo ou minúsculo? [M/m] " read var if [ $var = "M" ]; then echo -n "Que diretório? " read dir for x in `/bin/ls` $dir; do y=`echo $x | tr '[:lower:]' '[:upper:]'` if [ ! -e $y ]; then mv $x $y fi done elif [ $var = "m" ]; then echo -n "Que diretório? " read dir for x in `/bin/ls` $dir; do y=`echo $x | tr '[:upper:]' '[:lower:]'` if [ ! -e $y ]; then mv $x $y fi done fi } Adicionar() { clear echo -n "Qual o nome do usuário a se adicionar? " read nome adduser nome Principal } Deletar() {

clear echo -n "Qual o nome do usuário a deletar? " read nome userdel nome Principal } Backup() { for x in `/bin/ls` /etc; do cp -R /etc/$x /etc/$x.bck mv /etc/$x.bck /usr/backup done } Principal

26- janelas graficas

 Nos dois topicos anteriores, vimos algumas coisas básicas e lógicas de programação em shell no Linux. Agora para completar, darei aqui dicas de como usar janelas gráficas em seus shell-scripts. Isso mesmo, janelas que rodam no ambiente gráfico, utilizadas facilmente em seu shell-script. Com esse recurso, vai ser possível deixar o seu programa  bem amigável.  Não vai ser preciso saber muita coisa de programação em shell, pois é muito simples. Através do programa Xdialog, você poderá criar os mais variados tipos de janelas para o  programa: caixas de texto, seleçÕes, radios, etc. O Xdialog é uma idéia que vem do dialog/cdialog, um programa para console que gera “janelas” no console (aquelas da instalação do Slackware) usando a biblioteca ncurses. O Xdialog ao invés de usar a  biblioteca ncurses, usa a Xlib para criar as janelas no ambiente gráfico. Primeiro de tudo será necessário você obter o Xdialog no seu sistema. Não é comum o Xdialog estar incluso nas distribuições, então você terá de pegar e compilar o programa. Obtenha o programa no CD da Revista ou visite o endereço oficial do Xdialog, que é http://xdialog.free.fr. Aqui eu peguei o arquivo Xdialog-1.4.5.tar.bz2, e agora vamos aos passos básicos para instalar ele. Primeiro descompacte-o com o comando bunzip2 Xdialog-1.4.5.tar.bz2, e logo em seguida tar xpvf Xdialog-1.4.5.tar. Um diretório chamado Xdialog-1.4.5 será criado, e entrando nele você estará pronto para compilá-lo e instalá-lo. Para fazer isso use os comandos ./configure, depois make e por último make install. No passo do make install, o binário do Xdialog será colocado em /usr/local/bin. Pronto, agora você já poderá utilizar o Xdialog através de qualquer shellscript. E agora vamos à ação! Como aprendemos nos artigos anteriores, em shell-script é só colocar o comando dentro do arquivo que ele já vai ser executado quando o script for  executado. Então só o que temos de aprender aqui é como usar o Xdialog. Vamos ver  um primeiro exemplo: #!/bin/bash Xdialog --title "Exemplo número 1!" --center --stdout --yesno \ "Isto é legal?" \ 0 0 echo $?

Como você pôde ver, o programa Xdialog gerou uma janela com título “Exemplo número 1!”, perguntando “Isto é legal?” e com opções de Sim e Não. Note que a \ (barra) serve para indicar à shell para continuar o comando da linha seguinte, então estas três linhas são que nem uma só. Como último comando do exemplo dado, temos o echo $?, que eu coloquei apenas para indicar qual foi o retorno da pergunta. Caso o usuário apertou em Sim, o retorno vai ser 0, e se apertou em Não, vai ser 1. Podemos usar este retorno para controlar o que o usuário escolher. Vejamos um exemplo: Xdialog --title "Exemplo número 2!" --center --stdout --yesno \ "Neste exemplo, vamos ver o que você quer fazer. Você deseja continuar com o programa?" \ 0 0 if [ $? = "0" ]; then echo "Que bom! Você continuou o programa! Parabéns!" elif [ $? = "1" ]; then echo "Você saiu do programa..." fi

Viu como funciona? Agora vamos ver outros recursos que o Xdialog pode oferecer. Eu vou dar vários exemplos aqui e sair comentando cada opção. Você precisará praticar   bastante e conhecer as várias opções. Primeiro vamos gerar uma simples mensagem pro usuário ver: Xdialog --title "Aviso" --center --stdout --msgbox \ "Este programa é apenas um exemplo para você ver como o Xdialog \ \nfunciona. Apropósito, se você praticar bastante pode criar \ \nprogra mas incríveis e facilmente, que daria muito mais \ \ntrabalho fazendo em outras linguagens." \ 0 0

O usuário aperta Ok e o shell-script continua normalmente. No primeiro exemplo eu usei a opção –yesno que gerava o sim e não. Agora usei o –msgbox. Mas e se você quiser que o usuário digite algo e isto seja gravado em um arquivo por exemplo? Vamos ver este exemplo: Xdialog --title "Que Anime que você mais gosta?" --center --inputbox \ "Se você sabe o que é Anime, e gosta, qual o seu preferido?\n \ Sua resposta será gravada no arquivo resposta." \ 0 0 2> resposta

Depois que o usuário preenche o campo e dá Ok, a resposta que este usuário digitou será gravada no arquvio resposta. Isto ocorreu pelo fato de eu ter colocado o direcionador 2> para o arquivo resposta. Se eu colocasse a opção –stdout na linha de comando do Xdialog, a resposta do usuário apareceria na tela. Tente você. Vamos ver agora seleção de itens, que é uma das coisas mais importantes num  programa. Desta vez usaremos a opção –menubox para gerar um menu com os itens a serem selecionados. Mais uma vez, vamos ao exemplo: Xdialog --title "Exemplo de Menu" --center --stdout --menubox \ "Qual sua distribuição Linux favorita?" \ 20 50 0 \ 1 "Slackware" \ 2 "Debian" \

3 "Red Hat" \ 4 "Conectiva Linux" \ 5 "Eu tenho minha própria distribuição"

Viu como é fácil? O que o usuário escolher vai aparecer como resultado no console (por  causa da opção –stdout). Se eu colocasse o redirecionador 2>, poderia ir para um arquivo como no exemplo anterior. Vamos esclarecer uma coisa aqui também… Depois do texto “Qual sua distribuição Linux favorita?”, há 2 números. Estes dois números correspondem à altura e comprimento da janela. Nos exemplos anteriores eu coloquei “0 0″ pois aí o Xdialog dimensiona automaticamente o tamanho da janela. Então já sabe, se quiser mudar o tamanho da janela, é só mudar estes dois números. Agora como último exemplo, vamos criar uma janela em que o usuário poderá escolher  uma ou mais opções. Isto é chamado de checklist, e pode ser visto no exemplo a seguir: Xdialog --title "Último exemplo - checklist" --center --checklist \ "Como se pronuncia Linux?" \ 0 0 0 \ "Opção 1" "Láinucs" off \ "Opção 2" "Lenocs" off \ "Opção 3" "Linúcs" off \ "Opçào 4" "Línucs" on \ "Opção 5" "GNUUU/Linux" off

Veja agora a diferença entre esta checklist e o menu do exemplo anterior. Verifique que depois de cada opção há o on e o off. O on indica que esta opção deverá já estar  marcada, e o off que não deverá estar marcada. Se o usuário escolher 3 opções, as mesmas serão o resultado. Bem fácil criar uma interface amigável para suas shell-scripts. Se você pensa que isto é tudo, ainda tem muito mais por trás do Xdialog. Para não ter que ficar comentando cada opção, vou dar uma lista de parâmetros e a descrição de suas funções. O que você deverá fazer é sair testando todas as opções e se impressionar :) –yesno  –msgbox  –infobox  –inputbox  –rangebox  –textbox  –editbox  –menubox  –checklist  –radiolist  –treeview –gauge –tailbox  –fselect  –dselect  –calendar

Uma janela com opções de “Sim” ou “Não” Apenas mostra um texto informativo Mesmo que –msgbox, só que desaparece automaticamente em um determinado tempo O usuário preenche um campo Escolhe um número entre X e Y, com uma barra de rolagem Mostra o conteúdo de um arquivo numa caixa de texto Edita o conteúdo de um arquivo numa caixa de texto Cria um Menu de opções, onde se seleciona um item Mesmo que –menubox, só que pode-se selecionar vários itens Mesmo que –menubox, mas agora em outro estilo Opções organizadas em forma de “árvore” (interessante) Um indicador de processo Mostra o conteúdo de um arquivo Abre uma janela de seleção de um arquivo Abre uma janela de seleção de um diretório Mostra um calendário para escolher uma data