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

DISCORD: https://discord.gg/UsduDqw
YOUTUBE: https://www.youtube.com/user/HuemersonSUPER
FACEBOOK: https://www.facebook.com/Fmgsamprpgvr

In Game: Ao logar compre seu vip e aproveite as vantagens.
Todos os jogadores ganham Coins [Moedas Virtuais] no primeiro login, para comprar itens no menu vip ou adquirir org vip - / menuvip ou /pegarorg.
FMGARCIA - SAMP
Gostaria de reagir a esta mensagem? Crie uma conta em poucos cliques ou inicie sessão para continuar.

Últimos assuntos
» PK XD, novo jogo da PlayKids
Operadores EmptySex 25 Set 2020, 08:58 por HuemersonFMG

» A Lei Maria da Penha - Viver sem violência.
Operadores EmptyQui 10 Set 2020, 17:03 por HuemersonFMG

» 12 de outubro dia de Nossa Senhora Aparecida
Operadores EmptyTer 08 Set 2020, 09:43 por HuemersonFMG

» Almôndegas ao Molho
Operadores EmptySab 05 Set 2020, 14:05 por HuemersonFMG

» DETRAN - Departamento Estadual de Transito
Operadores EmptySab 29 Ago 2020, 23:46 por HuemersonFMG

» Jogos do Fórum
Operadores EmptyQui 27 Ago 2020, 09:44 por HuemersonFMG

» 2.908.848 casos de pessoas recuperadas do coronavírus
Operadores EmptyQui 27 Ago 2020, 08:18 por HuemersonFMG

» Evento de Futebol - 1 x 1
Operadores EmptyQui 20 Ago 2020, 08:56 por HuemersonFMG

» The Dust - Guerrilha
Operadores EmptySab 08 Ago 2020, 22:36 por HuemersonFMG

» Corridas Vip - Empresa de corridas
Operadores EmptySab 08 Ago 2020, 22:23 por HuemersonFMG

» Organizações e Territórios
Operadores EmptySab 08 Ago 2020, 20:59 por HuemersonFMG

» Construct 2/3 - Expressões Nativas
Operadores EmptyQua 05 Ago 2020, 10:37 por HuemersonFMG

» Policia Federal Ø
Operadores EmptySex 31 Jul 2020, 10:37 por HuemersonFMG

» Baixar Emuladores
Operadores EmptySex 10 Jul 2020, 09:39 por HuemersonFMG

» Brasil registra 441,7 mil curados do coronavírus.
Operadores EmptyQua 17 Jun 2020, 10:23 por HuemersonFMG


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 : 424
Pontos : 23706
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