FMGARCIA - SAMP
Bem vindo ao nosso Fórum, faça o seu registro gratuito.
Respeite as regras do fórum e do servidor.
Nosso servidor é *Role-Playing Game - RPG*.
Nosso lema é: *DIVERSÃO*.
IP: 54.39.145.16:7720
FMG - O MELHOR SERVIDOR RPG SAMP - RADIO ONLINE
Estatísticas
Temos 37 usuários registrados
O último usuário registrado atende pelo nome de MafiosoHD

Os nossos membros postaram um total de 358 mensagens em 312 assuntos
Social bookmarking

Social bookmarking digg  Social bookmarking delicious  Social bookmarking reddit  Social bookmarking stumbleupon  Social bookmarking slashdot  Social bookmarking yahoo  Social bookmarking google  Social bookmarking blogmarks  Social bookmarking live      

Conservar e compartilhar o endereço de FMGARCIA - SAMP em seu site de social bookmarking

Deixe seu Like

Últimos assuntos
» O que é um Analista de sistemas
Operadores EmptyQui 06 Fev 2020, 10:24 por HuemersonFMG

» Lista De Comandos Gerais Do Servidor
Operadores EmptySeg 27 Jan 2020, 12:17 por HuemersonFMG

» BOOPE Ø
Operadores EmptySex 03 Jan 2020, 13:58 por CleidiSilva21

» Carnaval 2020 - Só folia...
Operadores EmptySex 03 Jan 2020, 09:30 por HuemersonFMG

» Ano novo, um recomeço
Operadores EmptyQua 25 Dez 2019, 16:23 por HuemersonFMG

» É natal. E eu queria...
Operadores EmptyTer 24 Dez 2019, 07:46 por HuemersonFMG

» Diferença entre Namorados e Amigos
Operadores EmptySeg 16 Dez 2019, 18:07 por HuemersonFMG

» Como jogar samp pelo android...
Operadores EmptyDom 15 Dez 2019, 13:09 por Convidado

» Dia da Família
Operadores EmptyDom 08 Dez 2019, 12:11 por HuemersonFMG

» Panquecas de banana
Operadores EmptyTer 26 Nov 2019, 10:56 por HuemersonFMG

» Policia Militar Ø
Operadores EmptySeg 25 Nov 2019, 17:07 por HuemersonFMG

» Operadores
Operadores EmptySex 22 Nov 2019, 22:56 por HuemersonFMG

» A receita ideal
Operadores EmptySex 22 Nov 2019, 08:46 por HuemersonFMG

» Google Stadia - serviço de jogos baseado em nuvem
Operadores EmptyQua 20 Nov 2019, 15:04 por HuemersonFMG

» Cultivando suas orquídeas
Operadores EmptyQua 20 Nov 2019, 13:59 por HuemersonFMG


Vagas Administrativas Servidor FMGsamprpgvr

Já pensou em ser membro da nossa equipe de ADMs?
inscreva-se temos vagas no servidor - Leia as REGRAS no fórum - Envie este formulário e aguarde nosso contato. Tem que ser membro do fórum e trazer no minimo cinco amigos para o Servidor.



FMGSAMP

Fevereiro 2020
DomSegTerQuaQuiSexSab
      1
2345678
9101112131415
16171819202122
23242526272829

Calendário Calendário

Membros On Line

Total de visitantes

Bem vindos

Familia Garcia SAMP
Idev Games Categorias
Administradores


Operadores

Ir em baixo

Vip Operadores

Mensagem por HuemersonFMG em Sex 22 Nov 2019, 22:56

Código:
if
Uma instrução if verifica se algo é verdadeiro e faz algo se for.

new
 a = 5;
if (a == 5)
{
 print("a is 5");
}
O código entre parênteses após o "se" é chamado de condição, há várias coisas diferentes que você pode testar (consulte operadores).

No exemplo acima, "a" e 5 são símbolos, as funções também podem ser símbolos:

if (SomeFunction() == 5)
{
 print("SomeFunction() is 5");
}
Isso testará o valor de retorno de SomeFunction (veja abaixo) em relação a 5.

Você também pode combinar verificações para verificar várias coisas:

new
 a = 5,
 b = 3;
if (a == 5 && b != 3)
{
 print("Não será impresso");
}
Esse exemplo verifica se a é igual a 5 AND b não é igual a 3, no entanto b é 3, portanto a verificação falha.

new
 a = 5,
 b = 3;
if (a == 5 || b != 3)
{
 print("Será impresso");
}
Esses exemplos verificam que a é igual a 5 OU b não é igual a 3, b é igual a 3, para que a parte falhe *, no entanto, a é 5, para que a parte seja verdadeira, estamos usando || (ou) para que apenas uma parte precise ser verdadeira (se ambas são verdadeiras, a afirmação ainda é verdadeira, isso é ligeiramente diferente do significado linguístico de "ou" significa apenas uma ou outra), portanto, a afirmação if é verdadeira.

Também é possível encadear as comparações sem o AND explícito de duas comparações diferentes.

new
    idx = 3;
 
if (0 < idx < 5)
{
    print("idx é maior que 0 e menor que 5!");
}
[edit]
Operadores
A seguir estão os símbolos que você pode usar nas comparações e suas explicações. Alguns já foram usados em exemplos.

Operador Significado Uso
== Left is equal to Right if (Left == Right)
!= Left is not equal to Right if (Left != Right)
> Left is greater than Right if (Left > Right)
>= Left is greater than or equal to Right if (Left >= Right)
< Left is less than Right if (Left < Right)
<= Left is less than or equal to Right if (Left <= Right)
Operator Meaning Usage
&& and if (Left && Right)
|| or if (Left || Right)
 ! not if (!Variable)
nor if (!(Left || Right))
nand if (!(Left && Right))
exclusive or (xor, eor) - only one or the other is true, not both if (!(Left && Right) && (Left || Right))
not exclusive or (nxor, neor) - both or neither are true if ((Left && Right) || !(Left || Right))
[edit]
Suportes
O outro aspecto principal das instruções if são colchetes, que controlam a ordem em que as coisas são feitas:

new
 a = 3,
 b = 3,
 c = 1;
if (a == 5 && b == 3 || c == 1)
{
 print("Isso será chamado?");
}
Existem duas maneiras de analisar a declaração acima:

if ((a == 5 && b == 3) || c == 1)
And:

if (a == 5 && (b == 3 || c == 1))
A primeira versão verificará se a é 5 e b é 3, se for falso (ou seja, um ou ambos não são seus respectivos valores), verificará se c é 1. (a == 5 && b == 3) é falso, como você deve saber acima, então substitua esse grupo por FALSE:

if (FALSE || c == 1)
Sabemos que FALSE não pode ser verdadeiro (como não é verdade por definição), no entanto, c é 1 para que metade seja verdadeira e, como estamos usando um OR entre toda a afirmação, é verdade.

A segunda versão verifica se a é 5, se verifica se b é 3 ou c é 1. O jogo fará a parte a == 5 primeiro, mas para maior clareza, faremos isso de trás para a frente. (b == 3 || c == 1) é verdadeiro, ambas as metades são verdadeiras, embora apenas uma precise ser, portanto, entrando em nossa declaração if, temos:

if (a == 5 && TRUE)
(a == 5) é falso, porque a é 3, então temos:

if (FALSE && TRUE)
Obviamente, FALSE é falso, de modo que a instrução não pode ser verdadeira, portanto a verificação falhará.

Este pequeno exemplo mostra como o uso de colchetes pode alterar o resultado de uma verificação. Sem colchetes, o compilador será a primeira das duas versões demonstradas, mas que nem sempre pode ser garantida; portanto, você deve sempre usar colchetes, mesmo que apenas para esclarecer o que está acontecendo para outras pessoas.

(b! = 3) no exemplo OR, na verdade, falha como nunca é chamado, o compilador ordena o código usando uma coisa chamada curto-circuito, como a primeira parte já é verdadeira, não há sentido em verificar a segunda parte, pois ganhou afetará o resultado final, mas, se fosse verificado, falharia.
[editar]
outro
caso contrário, basicamente faz algo se uma verificação if falhar:

new
 a = 5;
if (a == 3) // False
{
 print("Não será chamado");
}
else
{
 print("Será chamado como a verificação falhou");
}
[edit]
else if
Um else if é uma verificação que ocorre se o primeiro if check falhar ao verificar outra coisa:
new
 a = 5;
if (a == 1)
{
 print("Será chamado se a for 1");
}
else if (a == 5)
{
 print("Será chamado se a for 5");
}
else
{
 print("Todos os outros números");
}

103/5000
Você pode ter muitos destes como desejar (você só pode ter um se e outro em um grupo de verificações):

new
 a = 4;
if (a == 1)
{
 // False
}
else if (a == 2)
{
 // False
}
else if (a == 3)
{
 // False
}
else if (a == 4)
{
 // True
}
else
{
 // False
}
caso contrário, o ifs verificará apenas o valor como estava quando o ifs é iniciado, portanto você não pode fazer:

new
 a = 5;
if (a == 5)
{
 // Will be called
 a = 4;
}
else if (a == 4)
{
// Não será chamado porque a primeira verificação não falhou, mesmo que a seja agora 4
}
Para contornar isso, você simplesmente faria o resto se um se.
[edit]
 ?:
'?' and ':' juntos são chamados de operador triádico, eles basicamente agem como uma instrução if dentro de outra instrução:

new
 a,
 b = 3;
if (b == 3)
{
 a = 5;
}
else
{
 a = 7;
}
Esse é um exemplo simples para atribuir uma variável com base em outra variável, mas pode ser muito mais curta:

new
 a,
 b = 3;
a = (b == 3) ? (5) : (7);
A parte antes do '?' é a condicional, é exatamente o mesmo que uma condicional normal. A parte entre o '?' e ':' é o valor a ser retornado se a condição for verdadeira, a outra parte é o valor a ser retornado se a condição for falsa. Você pode empilhá-las da mesma forma que as ifs também:

new
 a,
 b = 3;
if (b == 1)
{
 a = 2;
}
else if (b == 2)
{
 a = 3;
}
else if (b == 3)
{
 a = 4;
}
else
{
 a = 5;
}
Pode ser escrito como:

new
 a,
 b = 3;
a = (b == 1) ? (2) : ((b == 2) ? (3) : ((b == 3) ? (4) : (5)));
Na verdade, isso é mais semelhante a fazer:

new
 a,
 b = 3;
if (b == 1)
{
 a = 2;
}
else
{
 if (b == 2)
 {
 a = 3;
 }
 else
 {
 if (b == 3)
 {
 a = 4;
 }
 else
 {
 a = 5;
 }
 }
}
Mas eles são equivalentes (neste exemplo, de qualquer maneira).

[edit]
Loops
[edit]
while ()
"while" loops fazem algo enquanto a condição especificada é verdadeira. Uma condição é exatamente o mesmo formato que a condição em uma instrução if, é verificada apenas repetidamente e o código é executado se for verdadeiro sempre que for verificado:

new
 a = 9;
while (a < 10)
{
 // Código no loop
 a++;
}
// Código após o loop
Esse código verificará se 'a' é menor que 10. Se for, o código dentro dos chavetas (a ++;) será executado, incrementando 'a'. Quando a chave de fechamento é atingida, a execução do código retorna à verificação e a executa novamente, desta vez a verificação falhará como 'a' é 10 e a execução passará para após o loop. Se 'a' começasse com 8, o código seria executado duas vezes etc.

[edit]
for ()

197/5000
Um loop "for" é essencialmente um loop "while" compactado. Uma declaração "for" possui três seções; inicialização, condição e finalização. Como um loop "for", o exemplo "while" acima seria escrito:

for (new a = 9; a < 10; a++)
{
 // Code in the loop
}
// Código após o loop
Esse é um código simples para percorrer todos os jogadores:

for(new i,a = GetMaxPlayers(); i < a; i++)
{
        if(IsPlayerConnected(i))
        {
                 //faça alguma coisa
  }
}
Qualquer uma das condições pode ser omitida simplesmente não colocando nenhum código nelas:

new
 a = 9;
for ( ; a < 10; )
{
 // Código no loop
  a ++;
}
// Código após o loop
Este exemplo torna um pouco mais fácil mostrar como um loop "for" corresponde a um loop "while". Existem duas diferenças muito pequenas entre os dois loops "for" fornecidos. A primeira é que o segundo exemplo declara 'a' fora do loop "for", isso significa que pode ser usado fora do loop "for", no primeiro exemplo 'o escopo de a (a seção de código para a qual existe uma variável) é somente dentro do loop. A segunda diferença é que o a ++ no segundo exemplo é realmente feito um pouco antes do a ++ no primeiro exemplo, 99% das vezes isso não faz diferença, a única coisa que importa é quando você está usando 'continue' (veja abaixo), 'continue' chamará a ++ no primeiro exemplo, mas ignorará no segundo exemplo.

[edit]
do-while
Um loop do-while é um loop while em que a condição vem após o código dentro do loop, e não antes. Isso significa que o código interno sempre será executado pelo menos uma vez porque é feito antes da verificação:

new
 a = 10;
do
{
 // Código dentro do loop
 a++;
}
while (a < 10); // Observe o ponto e vírgula
// Código após o loop
Se esse fosse um loop while padrão a não seria incrementado, pois a verificação (a <10) é falsa, mas aqui é incrementada antes da verificação. Se um iniciado como 9, o loop também seria feito apenas uma vez, 8 - duas vezes etc.

[edit]
if-goto
Isso é essencialmente o que os loops acima compilam, o uso de goto geralmente é desencorajado, mas é interessante ver exatamente o que um loop está fazendo:

new
 a = 9;
 
loop_start:
if (a < 10)
{
 // Code in the loop
 a++;
 goto loop_start;
}
// Código após o loop
[edit]
OBOE
OBOE significa Desativado por um erro. Este é um erro muito comum em que um loop é executado uma ou duas vezes demais. Por exemplo:

new
 a = 0,
 b[10];
while (a <= sizeof (b))
{
 b[a] = 0;
}
Este exemplo muito simples demonstra um dos OBOEs mais comuns. À primeira vista, as pessoas podem pensar que isso percorrerá todo o conteúdo de b e os definirá como 0; no entanto, esse loop será executado 11 vezes e tentará acessar b [10], o que não existe (seria o 11º slot em b a partir de 0), portanto, pode causar todos os tipos de problemas. Isso é conhecido como erro Fora dos limites (OOB).

Você deve ter um cuidado especial com os OBOEs ao usar loops do-while, pois SEMPRE executam pelo menos uma vez.

[edit]
switch
[edit]
switch
Uma instrução switch é basicamente um sistema if / else if / else estruturado (semelhante a como for um while estruturado). A maneira mais fácil de explicar é com um exemplo:

new
 a = 5;
switch (a)
{
 case 1:
 {
 // Não será chamado
 }
 case 2:
 {
 // Não será chamado
 }
 case 5:
 {
 // Will be called
 }
 default:
 {
 // Não será chamado
 }
}
This is functionally equivalent to:

new
 a = 5;
if (a == 1)
{
 // Won't be called
}
else if (a == 2)
{
 // Won't be called
}
else if (a == 5)
{
 // Will called
}
else
{
 // Won't be called
}
However it is slightly clearer to see what is going on.

An important thing to note here is the different ways in which ifs and switches are processed:

switch (SomeFunction())
{
 case 1: {}
 case 2: {}
 case 3: {}
}
That will call SomeFunction() ONCE and compare it's result 3 times.

if (SomeFunction() == 1) {}
else if (SomeFunction() == 2) {}
else if (SomeFunction() == 3) {}
That will call SomeFunction() three times, which is very inefficient, a switch is more like doing:

new
 result = SomeFunction();
if (result == 1) {}
else if (result == 2) {}
else if (result == 3) {}
For those of you who know C the PAWN switch is slightly different, the individual conditions are NOT fall-through and are bound by braces so there's no need for break statements.

[edit]
case
case statements (the "case X:" parts of the switch statement) can have other options besides a single number. You can compare a value to a list of numbers (replacing fall-through in C) or even a range of values:

case 1, 2, 3, 4:
This case will trigger if the symbol being tested is 1, 2, 3, or 4, it's the same as doing:

if (bla == 1 || bla == 2 || bla == 3 || bla == 4)
but far more concise. Numbers in lists do not have to be consecutive, in fact if they are it's better to do:

case 1 .. 4:
This case will do exactly the same as above but by checking a range instead of a list, it is the same as doing:

if (bla >= 1 && bla <= 4)
new
 a = 4;
switch (a)
{
 case 1 .. 3:
 {
 }
 case 5, 8, 11:
 {
 }
 case 4:
 {
 }
 default:
 {
 }
}
[edit]
default
This is the equivalent to else in if statements, it does something if all the other case statements failed.

[edit]
Single line statements
[edit]
goto
goto is essentially a jump, it goes to a label without question (i.e. there's no condition to need to be true). You can see an example above in the if-goto loop.

goto my_label;
 
// This section will be jumped over
 
my_label: // Labels end in a colon and are on their own line
 
// This section will be processed as normal
The use of gotos is widely discouraged due to their effect on program flow.

[edit]
break
break breaks out of a loop, ending it prematurely:

for (new a = 0; a < 10; a++)
{
 if (a == 5) break;
}
This loop will go 6 times but code after the break will only be executed 5 times.

[edit]
continue
continue basically skips a loop iteration

for (new a = 0; a < 3; a++)
{
 if (a == 1) continue;
 printf("a = %d", a);
}
That will give the output of:

a = 0 a = 2

The continue basically jumps to the closing brace of the loop, as hinted at above you have to be careful when using continue with some loops:

new
 a = 0;
while (a < 3)
{
 if (a == 1) continue;
 printf("a = %d", a);
 a++;
}
This looks very similar to the other example however this time the continue will skip the a++; line, so the loop will get stuck in an infinite loop as a will always be 1.

[edit]
return
return stops a function and goes back to the point in code which called the function in the first place:

main()
{
 print("1");
 MyFunction(1);
 print("3");
}
 
MyFunction(num)
{
 if (num == 1)
 {
 return;
 }
 print("2");
}
That code will give an output of:

1 3

Because the print("2"); line will never be reached.

You can also use return to return a value:

main()
{
 print("1");
 if (MyFunction(1) == 27)
 {
 print("3");
 }
}
 
MyFunction(num)
{
 if (num == 1)
 {
 return 27;
 }
 print("2");
 return 0;
}
That code will give the same output as above, however note that an additional return has been added to the end of the function. The end of a function has a return implied at it, however this return has no value, you cannot return a value and not return a value from the same function so we must explicitly return a value.

The symbol you return can be a number, a variable or even another function (in which case the other function will be called, it will return a value (it MUST return a value if you use it as a return value) and that value will be returned from the first function.

You can also store return values for later use:

main()
{
 print("1");
 new
 ret = MyFunction(1);
 if (ret == 27)
 {
 print("3");
 }
}
 
MyFunction(num)
{
 if (num == 1)
 {
 return 27;
 }
 print("2");
 return 0;
}
See also: Keywords

[Somente moderadores podem ver esta link]
HuemersonFMG
HuemersonFMG
Fundador - ADM
Fundador - ADM

Mensagens : 348
Pontos : 13043
Reputação : 0
Data de inscrição : 11/06/2018
Idade : 47
Localização : Brasil

FMGRPG
FMG:
Operadores Left_bar_bleue200/100Operadores Empty_bar_bleue  (200/100)

https://play.idevgames.co.uk/profile/Huemerson

Voltar ao Topo Ir em baixo

Voltar ao Topo


 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum