"Os programadores inteligentes usam Delphi!" Agora, mais e mais pessoas estão começando a usar Delphi. No entanto, afinal, existem alguns especialistas, e iniciantes como eu estão por toda parte, haha. Como sou um novato, naturalmente tenho muitas perguntas muito boas, como como configurar isso e como escrever isso ... então, abaixo, farei um discurso resumido com base na pouca experiência que acumulei e As pequenas perguntas comuns no fórum.
＝＝ Aplicações do sistema ＝＝
UM. A Delphi substituiu um grande número de controles comumente usados, como o Delphi5, e o Delphi6 lançado este ano é 1,5 vezes o do Delphi5. Com tantos controles, mesmo com a resolução de 1024*768, eles não podem exibir todos os seus painéis de componentes, e é realmente inconveniente pressionar esses dois botões pequenos para exibir mais painéis a cada vez! No entanto, ao adicionar o seguinte valor da chave do registro, o painel do componente pode ser expandido automaticamente:
[Hkey_current_user/software/borland/delphi/x.0/extras]
"AutoPaletteselect" = "1"
(Nota: X.0 indica o número da versão do seu Delphi; se não houver uma chave primária de extras, basta criar um novo, o mesmo abaixo)
Ｂ． Toda vez que crio um novo formulário e depois defino sua fonte e tamanho ... é realmente problemático! Em seguida, adicione o seguinte valor de chave e deixe o sistema defini -lo automaticamente:
[Hkey_current_user/software/borland/delphi/x.0/formdesign]
"DefaultFont" = "宋体, 9, _"
(Nota: _ representa o espaço e também pode ser substituído por negrito (negrito) etc.)
C. Personalize o ambiente de trabalho para torná -lo mais adequado para você.
• Barra de ferramentas de configurações. Clique com o botão direito do mouse na barra de ferramentas Delphi, selecione Personalizar, selecione o botão necessário e arraste a ferramenta e arraste as indesejadas para fora. O que eu costumo usar é: Projeto aberto, salvar, salvar tudo, desfazer, refazer na barra de ferramentas padrão; Barra de ferramentas da paleta de componentes.
• Defina o layout da janela. Para poder escrever programas com eficiência, é importante organizar cada janela razoavelmente. Minhas janelas comumente usadas são: Inspetor de Objeto, Gerenciador de Projetos (View | Project Manager), Lista de relógios (Run | Adicionar relógio ...).
Depois de configurar cada formulário, pressione o botão Salvar a área de trabalho atual na barra de ferramentas da área de trabalho para salvar.
• Defina a cor da tela. Torne a cor do código mais alinhada com seus hábitos, o que é propício ao pensamento claro ao escrever. Ferramentas | Opções do editor Abra as propriedades do editor, selecione a guia Color e defina a cor do código. Aqui estão apenas alguns comumente usados:
Espaço em branco: o espaço em branco, ou seja, o fundo;
Comentário: Comentário;
Palavra reservada: palavras reservadas;
String: string;
Número: Número;
Ponto de execução: a linha atual sendo executada (ou seja, a linha que chega quando F7 entra);
Quebra ativada: ponto de interrupção;
Linha de erro: a linha de erro ocorreu;
Ｄ． Dominar algumas teclas de atalho na programação Delphi pode melhorar bastante a eficiência e não o tornará entediado por muitas configurações chatas. Aqui estão algumas teclas de atalho que costumo usar:
ESC: selecione o contêiner do componente atualmente selecionado (geralmente painel, grupo de grupo, formulário etc.);
Tecla de seta Ctrl+: move o componente selecionado por um pixel;
Ctrl+Shift+Teclas de seta: Mova o componente selecionado por uma grade grande (semelhante ao efeito de manter a mudança nos fogos de artifício e depois se mover com as teclas de seta);
Chaves de shift+dragão: ajuste o tamanho do componente selecionado, um pixel de cada vez;
Shift+Selecione componentes: mantenha pressionado a tecla Shift e clique no componente com o mouse.
Ctrl+Botão do mouse esquerdo: use outras funções no procedimento (como um processo personalizado). Vá diretamente para a parte da implementação desta função chamada. Eu usei mais essa função, tornando -o muito conveniente para eu encontrar módulos!
Ctrl+Shift+C: Declare um método em um objeto e, em seguida, coloque o cursor nele, pressione Ctrl+Shift+C para estabelecer uma estrutura básica para sua implementação, como:
Tform1 = classe (tform)
Privado
{Declarações privadas}
público
{Declarações públicas}
procedimento mina;
fim;
Coloque o cursor na linha da mina do procedimento, pressione Ctrl+Shift+C, e o código a seguir será inserido automaticamente na unidade:
procedimento tform1.mine;
Começar
fim;
＝＝ Operações de formulário ＝＝
Em programas com vários formulários, os padrões da Delphi para criar todos eles quando o programa é iniciado (está apenas oculto, apenas um formulário principal é exibido), de modo que essas formas que são temporariamente desnecessárias para começar a ocupar muito espaço de memória. Portanto, precisamos transferir os formulários que não são iniciados por enquanto, de "formulários de criação automática" para "formulários disponíveis" na guia Formulários do Projeto de Menu | Opções ... Dessa forma, a criação e a liberação desses formulários exigem código para implementar.
UM. Comparação de duas maneiras de criar um formulário. Para esses formulários não automaticamente criados, devemos criá-los antes de mostrar (self) ou criar (aplicativo). Por exemplo, form.creat (self) e form.create (aplicação), mas qual é a diferença entre eles? Na verdade, não há muita diferença entre os dois.
Mas se o proprietário pertencer a outra janela ou controle, quando seu proprietário for liberado, o que o proprietário tiver será lançado. A principal diferença é quem gerencia os recursos do formulário. Criado no primeiro método, os recursos do formulário são gerenciados pelo programador;
Ｂ． Várias maneiras de liberar formas. Como é para salvar a memória, o formulário usado deve "afastar" a memória. Aqui vou listar alguns métodos semelhantes:
(1)
procedimento TForm1.Button1Click (remetente: TOBJECT);
Começar
......
se form2 = nil então
Form2: = TForm2.Create (Application);
Form.ShowModal;
......
fim;
Procedimento TForm2.Close (remetente: TObject; var ação: tcloSeAction);
Começar
ModalResult: = mRnone;
Ação: = cafree;
Form2: = nil;
fim;
(2)
procedimento TForm1.Button1Click (remetente: TOBJECT);
Começar
Se não for atribuído (Form2), então
Começar
Application.CreatEform (TForm2, Form2);
tentar
Form.ShowModal;
Finalmente
Form.Free;
Form2: = nil;
fim;
fim
outro
Form.ShowModal;
fim;
(3)
procedimento TForm2.Button1Click (remetente: TOBJECT);
Começar
Form2.close;
Form.Release;
fim;
＝＝ Controle o uso
UM. O famoso pacote de controle RXLIB é escrito por três especialistas russos e é muito excelente! No entanto, há muito conteúdo e não é fácil usá -lo bem. Vou apenas dizer alguns pontos aqui para Rxrichedit.
• Muitas pessoas perguntaram como instalar o RXLIB, parece ser um pouco complicado, haha, então também direi a propósito:
Execute rxinst.exe para instalar o rxlib em/programas arquivos/borland/delphi5 (ou 6)/rx pasta e depois abra o delphi, selecione Arquivo/Abra ... e gire rxctl5.dpk, rxdb5.dpk, rxbde5.dpk após a abertura , pressione compilar, continue a abrir: dclrx5.dpk, dclrxdb5.dpk e dclrxbd5.dpk.
• Propriedade de permitir objectos. A configuração padrão do Win98 é verdadeira. Mas quando false, será exibido normalmente. Portanto, para compatibilidade do sistema, é necessário determinar a versão atual do sistema operacional:
procedimento tFormMain.FormCreate (remetente: TObject);
var
Osvi: OsversionInfo;
......
Começar
Osvi.dwosversionInfosize: = sizeof (OsversionInfo);
GetVersionEx (OSVI);
case osvi.dwplatformid de
1: rxrichedit1.lowObjects: = true;
2: rxrichedit1.allowObjects: = false;
fim;
.........
fim;
Mas não sei por que esse atributo tem esse problema, então espero que o especialista me dê alguns conselhos.
• Evento OnurlClick. O RXRICHEDIT converte automaticamente endereços da página da web em formato de hiperlink, mas o comportamento específico ainda requer código de gravação por si só, caso contrário, esses endereços se tornarão conchas vazias:
procedimento tFormMain.rxrichedit1urlClick (remetente: tabject; const urltext: string; botão: tmouseButton);
Começar
se botão = mbleft então
Shellexecute (alça, nil, pchar (urltext), nil, nil, sw_show);
fim;
Ｂ． Para salvar a memória e otimizar a operação, sempre criamos componentes dinamicamente. Mas depois de usá -lo, se não for liberado da memória a tempo, será contra nossa intenção original. Mas como "matar" o componente criado? Isso apenas libera o espaço de memória apontado pela edição, mas o ponteiro não está definido como nulo. gerado ....mistake. Portanto, precisamos dar um pouco do ponteiro após a edição gratuita: = nil ou freeandnil (válido apenas em Delphi5) para garantir a operação normal no futuro.
C. Exibe o texto rápido de cada controle na linha de status. O evento OnHint deste aplicativo pode ser usado, mas como a aplicação é um objeto incompatível, o método a seguir pode ser usado:
......
público
Procedimento DisplayHint (remetente: Tobject);
fim;
......
Procedimento TForm1.DisplayHint (remetente: Tobject);
Começar
StatusBar1.simpleText: = getLonghint (Application.hint);
fim;
procedimento TForm1.FormCreate (remetente: Tobject);
Começar
Application.onhint: = DisplayHint;
fim;
Dessa forma, o texto exibido na barra de status é o mesmo que a caixa prompt (a pequena caixa amarela que aparece automaticamente). E se você quiser que o texto rápido na barra de status seja mais detalhado? De fato, desde que a propriedade do controle seja escrita assim: MyHint | É apenas um myhint!, O conteúdo antes "| "É exibido na barra de status. Agora.
Ｄ． Alguns pontos -chave no uso do ListView. A seguir, é apresentado uma ListView de duas colunas como exemplo.
→ Adicione uma linha:
com listView1 do
Começar
ListItem: = items.add;
ListItem.caption: = 'Primeira coluna conteúdo';
ListItem.subitems.add ('Segunda coluna conteúdo');
fim;
→ Clear ListView1:
ListView1.items.clear;
→ Obtenha o número da linha da linha atualmente selecionada e exclua a linha atual:
Para i: = 0 a listView1.items.count-1 do
Se listView1.items [i] .Selected então //i=ListView1.Selected.index
Começar
ListView1.items.Delete (i);
fim;
Obviamente, o ListView possui um evento OnSelectItem, que pode determinar qual linha você selecionou e atribui a uma variável global.
→ Operação da leitura de uma linha e uma coluna:
Edit1.text: = listView1.items [i] .Caption;
Edit2.text: = listView1.items [i] .subitems.strings [0];
Edit3.text: = listView1.items [i] .subitems.strings [1];
Por analogia, toda a coluna pode ser lida usando um loop.
→ Mova o foco em uma linha:
Para i: = 0 a listView1.items.count-1 do
If (listView1.items [i] .Selected) e (i> 0) então
Começar
ListView1.setFocus;
ListView1.items.item [i-1] .Selected: = true;
fim;
No entanto, no Delphi6, o ListView possui um atributo ItemIndex, então apenas
ListView1.setFocus;
ListView1.ItemIndex: = 3;
Você pode definir o foco.
＝＝ Outros ＝＝
• Para otimizar o software e torná -lo mais perfeito, as matrizes dinâmicas são frequentemente usadas ao usar matrizes. Ao declarar, como: a: matriz de string e, antes de usar a matriz, setLength (a, 3) define o comprimento da matriz para 3, ou seja, a [0], a [1], a [2], Então é isso. Quando é necessário expandir o comprimento da matriz, novamente: Seclenth (a, 5), então a [3] e a [4] são adicionados e, no anterior a [0], a [1], a [2] O valor de, não será limpo; 2] são automaticamente limpos da memória. Nota: Matrizes dinâmicas começam com "0", então após o SetLength (a, 1) de altura (a) = 0! !
Finalmente, quando essa matriz dinâmica não é mais usada e o programa ainda não saiu, a fim de salvar a memória, usar: a: = nil para lançar essa matriz, e agora ele realmente atinge "Proteção Ambiental e Verde e Ambiental" :)
• A pergunta "Como obter o caminho para o programa atual em execução" pode ser visto em fóruns. De fato, essa função é usada de tempos em tempos na programação. Na verdade, existem várias funções que podem alcançar esse efeito:
→ getCurrentDirectory (): função winapi, o uso específico é o seguinte:
var
MyCurrentDir: Array [0..144] de char;
Começar
GetCurrentDirectory (sizeof (myCurrentDir), myCurrentDir);
MyCurrentDir: = myCurrentDir+'/mySoftName.exe';
fim;
→ getCurrentDir (): uma função encapsulada pelo getCurrentDirectory por Delphi, o uso é simples: myCurrentDir: = getCurrentDir. O formato final é: c:/windows/sistema
Também existem funções que podem obter diretamente o caminho: ExtractFilePath (Paramstr (0)), ExtractFilePath (Application.Exename), etc.
• Mensagens de desligamento do sistema, reinicialização, etc. Esta também é uma pergunta que as pessoas fazem, e eu mencionarei aqui:
Desligamento: exitwindowsex (ewx_shutdown, 32);
Reiniciar: exitwindowsex (ewx_reboot, 32);
Logout: exitwindowsex (ewx_logoff, 32);
Power Off: ExitWindowsex (EWX_Poweroff, 32);
• Em Delphi, além de usar o #39, como lidar com "citações únicas" em um programa (como o showMessage)? Both ''' and ''''''''''''''''''''''''''''''''''''''''''''' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' ' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' 'O De fato, quatro citações únicas representam uma única citação, isto é, '' '', o segundo e o terceiro indicam que isso é um "'", e o primeiro e o quarto indicam que esse é um tipo de caractere. Haha, muito interessante :)
• Questões chinesas no showMessage. Os botões do showMessage estão todos em texto eletrônico, o que faz as pessoas se sentirem desconfortáveis. De fato, depois de nosso bricolage, podemos transformá -los em chinês.
Primeiro, salve o projeto atual e, em seguida, selecione o Projeto | Languages | Adicionar ... A caixa de diálogo Adicionar idioma aparece, selecione o projeto que você deseja ao chinês (você também pode personalizar a pasta), em seguida; China), a seguir; Encontre o item "const_smsgdlgok" na lista, altere seu padrão "chinês (traduzido)" para "ok" (original)) e saia após a economia. Agora, execute o programa novamente, haha, é apenas o botão chinês?
No entanto, uma caixa de diálogo de mensagem de ShowMessage é muito simples e pode ser exibida para desenvolvedores durante a depuração do sistema. Mas como é muito simples, recomendo não usar essas caixas de diálogo na versão oficial do software. Além disso, é melhor usar o MessageBox em vez do ShowMessage para reduzir o tamanho do software. !