Declaração condicional se mais. JavaScript: if e else - instruções para condições Javascript se duas condições forem atendidas, exibe uma mensagem

A fonte deste exemplo interativo está armazenada em um repositório GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone https://github.com/mdn/interactive-examples e envie-nos uma solicitação pull.

Sintaxe

instrução1 Instrução que será executada se a condição for verdadeira. Pode ser qualquer instrução, incluindo outras instruções if aninhadas. Para executar múltiplas instruções, use uma instrução de bloco ((...)) para agrupar essas instruções. Para não executar nenhuma instrução, use uma instrução vazia.

instrução2 Instrução que será executada se a condição for falsa e a cláusula else existir. Pode ser qualquer instrução, incluindo instruções em bloco e instruções if aninhadas.

Descrição

Várias instruções if...else podem ser aninhadas para criar uma cláusula else if. Observe que não existe palavra-chave elseif (em uma palavra) em JavaScript.

If (condição1) instrução1 else if (condição2) instrução2 else if (condição3) instrução3 ... else instruçãoN

Para ver como isso funciona, seria assim se o aninhamento fosse recuado corretamente:

If (condição1) instrução1 else if (condição2) instrução2 else if (condição3) ...

Para executar múltiplas instruções dentro de uma cláusula, use uma instrução de bloco ((...)) para agrupar essas instruções. Em geral, é uma boa prática sempre usar instruções em bloco, especialmente em códigos que envolvem instruções if aninhadas:

If (condição) (declarações1) else (declarações2)

Não confunda os valores booleanos primitivos verdadeiro e falso com veracidade ou falsidade do objeto booleano. Qualquer valor que não seja false , undefined , null , 0 , -0 , NaN ou a string vazia (""), e qualquer objeto, incluindo um objeto booleano cujo valor seja false, é considerado verdadeiro quando usado como condição. Por exemplo:

Var b = novo Booleano(falso); if (b) // esta condição é verdadeira

Usando if...else

if (cipher_char === from_char) ( resultado = resultado + to_char; x++; ) else ( resultado = resultado + clear_char; )

If (x > 50) ( /* faça a coisa certa */ ) else if (x > 5) ( /* faça a coisa certa */ ) else ( /* faça a coisa certa */ )

Atribuição dentro da expressão condicional

É aconselhável não usar atribuições simples em uma expressão condicional, pois a atribuição pode ser confundida com igualdade ao examinar o código. Por exemplo, não use o seguinte código:

Se (x = y) ( /* faça a coisa certa */ )

Se você precisar usar uma atribuição em uma expressão condicional, uma prática comum é colocar parênteses adicionais ao redor da atribuição. Por exemplo:

Se ((x = y)) ( /* faça a coisa certa */ )

Especificações

Compatibilidade do navegador

A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira https://github.com/mdn/browser-compat-data e envie-nos uma solicitação pull.

Atualizar dados de compatibilidade no GitHub

Neste exemplo, primeiro declaramos quatro variáveis ​​usando a palavra-chave var e imediatamente as atribuímos valores numéricos. A seguir, usando os operadores de incremento e decremento, alteramos os valores dos números. As informações são exibidas usando a função Eco(ver artigo ""). Para não escrever mais uma vez o nome do objeto, utilizei a construção com().

Operadores lógicos

Operadores lógicos são utilizados na verificação de condições, para não me repetir, farei uma abreviatura: o operando esquerdo é L.O., e o operando direito é P.O.

• && - "E" lógico
• || - "OU"
• ! - "NÃO"
• > - L.O. mais P.O.
• >= - L.O. maior ou igual a P.O.
• < - Л.О. меньше П.О.
• <= - Л.О. меньше или равен П.О.
• == - L.O. igual a P.O.
• != - L.O. não é igual a P.O.
• |= - L.O. igual a si mesmo OU P.O.
• &= - L.O. igual a si mesmo I P.O.
• ^= - EXCLUSIVO OU

Agora considere o seguinte script:

b== 100) //verdadeiro msg2 = "VERDADEIRO"; senão msg2 = "FALSO"; Popup (msg2, 5, título, vbInformation); //instrução condicional js if else if (! a) //false msg3 = "TRUE" ; senão msg3 = "FALSO"; Popup (msg3, 5, título, vbInformation); if (a&= 100 ) //falso msg4 = "TRUE" ; senão msg4 = "FALSO"; Popup (msg4, 5, título, vbInformation);)

Assim como no roteiro anterior, aqui utilizei a construção

uma=- 2 ; b= 6; c = 20;//Procurando por um discriminante

d= Matemática .pow (b, 2 ) - 4 * a* c;

if (d== 0 ) ( x= b/ (2 * a) ; mensagem=

"A equação tem uma solução, x é exatamente"

A instrução if avalia primeiro a expressão condicional especificada entre parênteses, cujo resultado é um valor booleano. Se o resultado obtido for verdadeiro, a instrução é executada. Se a expressão retornar falso, a instrução não será executada. Uma expressão de qualquer complexidade pode ser usada como condição.

Se o corpo da instrução if usar apenas uma instrução, será possível colocá-la entre chaves, mas não é necessário. No entanto, se você precisar executar mais de uma instrução no corpo de uma instrução if, essas diversas instruções deverão ser colocadas entre chaves. Observe que não deve haver ponto e vírgula após a chave de fechamento.

O código a seguir demonstra o uso da instrução if:

As instruções if podem ser aninhadas dentro de outras instruções if:

Observe último exemplo: a instrução não precisa ser escrita exatamente sob a instrução if; se a instrução não for grande, ela poderá ser escrita em uma linha;

instrução if else

E assim aprendemos que a instrução if permite executar instruções se a condição for verdadeira. Se a condição for falsa, nenhuma ação será executada. No entanto, muitas vezes é necessário executar algumas instruções se uma determinada condição for verdadeira e outras instruções se a condição for falsa. É para esses casos que a ramificação if else é usada. Consiste em uma instrução if seguida por um bloco de instruções e uma palavra-chave else seguida por outro bloco de instruções.

A sintaxe da instrução if else é:

A instrução else é opcional. O bloco de instruções localizado depois de else é executado por padrão, ou seja, quando a expressão condicional em if retorna false . A instrução else não pode ser usada separadamente da instrução if. O bloco else só deve aparecer após a instrução if, podendo ser considerado a ação padrão.

Modificando ligeiramente nosso exemplo anterior, podemos ver como a instrução if else funciona se a condição retornar falso:

A instrução if else pode ser aninhada. Essas declarações condicionais aninhadas ocorrem com bastante frequência na prática. Uma instrução if será aninhada se estiver aninhada dentro de outro bloco if ou else. Se o seu código usa várias instruções if seguidas, o else sempre se refere ao if mais próximo:

O último else não se aplica a if($a) porque não está em unidade interna, então o mais próximo disso é if($i) . A instrução else dentro do bloco está relacionada a if($b) porque este if é o mais próximo dele.

elseif/else if construir

A instrução if/else avalia o valor de uma expressão condicional e executa uma parte específica do código do programa. Mas e se você precisar executar um dos muitos fragmentos? Se você precisar verificar várias condições seguidas, então a construção elseif ou else if é adequada para isso (esta é a mesma construção, apenas escrita de forma diferente). Formalmente, não é uma construção PHP independente - é apenas um estilo de programação comum que consiste no uso repetido de instruções if/else. Ele permite que condições adicionais sejam testadas até que true seja encontrado ou o bloco else seja alcançado. elseif/else if construir deve aparecer após a instrução if e antes da instrução else, se houver.

Aqui são verificadas três condições e, dependendo do valor da variável $username, diferentes ações são executadas.

Não há realmente nada de especial nesta peça. É simplesmente uma sequência de instruções if, onde cada instrução if faz parte da cláusula else da instrução if anterior. Para aqueles que encontraram esta forma de notação pela primeira vez e não entendem realmente como ela funciona, reescreveremos o mesmo exemplo, apenas em uma forma sintática equivalente que mostre completamente o aninhamento de estruturas:

Declarações condicionais

Instruções condicionais permitem pular ou executar outras instruções dependendo do valor de uma expressão especificada. Estas declarações são pontos de decisão em um programa e às vezes também são chamadas operadores de filiais.

Se você imaginar que um programa é uma estrada, e o interpretador JavaScript é um viajante caminhando por ela, então as declarações condicionais podem ser pensadas como encruzilhadas onde o código do programa se ramifica em duas ou mais estradas, e nessas encruzilhadas o intérprete deve escolher qual caminho a seguir.

declaração if/else

A instrução if é uma instrução de controle básica que permite ao interpretador JavaScript tomar decisões ou executar instruções com mais precisão, com base em condições. A instrução if tem duas formas. Primeiro:

instrução if (expressão)

Nesta forma, a expressão é avaliada primeiro. Se o resultado obtido for verdadeiro, a instrução é executada. Se a expressão retornar falso, a instrução não será executada. Por exemplo:

If (username == null) // Se a variável username for nula ou indefinida username = "Alex"; //defini-lo

Observe que os parênteses em torno de uma expressão condicional são uma parte obrigatória da sintaxe da instrução if.

A segunda forma da instrução if introduz uma cláusula else que é executada quando a expressão é avaliada como falsa. Sua sintaxe é:

if (expressão) instrução1 else instrução2

Este formulário executa a instrução1 se a expressão for avaliada como verdadeira e a instrução2 se a expressão for avaliada como falsa. Por exemplo:

If (n == 1) console.log("1 nova mensagem recebida."); else console.log("Recebidas " + n + " novas mensagens.");

senão declaração if

A instrução if/else avalia o valor de uma expressão e executa uma ou outra parte do código do programa, dependendo do resultado. Mas e se você precisar executar um dos muitos fragmentos? Maneira possível para fazer isso é usar a instrução else if. Formalmente ele não é operador independente JavaScript; Este é apenas um estilo de programação comum de usar uma instrução if/else repetida:

If (n == 1) ( // Executa o bloco 1 ) else if (n == 2) ( // Executa o bloco 2 ) else if (n == 3) ( // Executa o bloco 3 ) else ( // Se nenhum dos dois uma das instruções else anteriores não foi executada, execute o bloco 4)

Não há nada de especial nesta peça. É simplesmente uma sequência de instruções if, onde cada instrução if faz parte da cláusula else da instrução anterior.

declaração de mudança

Uma instrução if cria uma ramificação no fluxo do programa, e a ramificação multiestado pode ser implementada usando várias instruções if. Contudo isto nem sempre é melhor solução, especialmente se todas as ramificações dependerem do valor da mesma expressão. Neste caso, é um desperdício reavaliar a mesma expressão em múltiplas instruções if.

A instrução switch foi projetada especificamente para tais situações. A palavra-chave switch é seguida por uma expressão entre parênteses e um bloco de código entre chaves:

switch(expressão) ( instruções )

Entretanto, a sintaxe completa de uma instrução switch é mais complexa do que a mostrada aqui. Vários lugares no bloco são marcados com uma palavra-chave caso, seguido por uma expressão e dois pontos.

Quando uma instrução switch é executada, ela avalia o valor da expressão e então procura um rótulo case que corresponda a esse valor (a correspondência é determinada usando o operador de identidade ===). Se o rótulo for encontrado, o bloco de código será executado, começando com a primeira instrução após o rótulo case. Se um rótulo case com um valor correspondente não for encontrado, a execução começa com a primeira instrução após o rótulo especial padrão:. Se o rótulo default: estiver faltando, todo o bloco de instrução switch será ignorado.

A operação da instrução switch é difícil de explicar em palavras; uma explicação parece muito mais clara com um exemplo. A seguinte instrução switch é equivalente às instruções if/else repetidas mostradas no exemplo anterior:

Switch(n) ( case 1: // Executado if n === 1 // Executa o bloco 1 break; // Para aqui case 2: // Executado if n === 2 // Executa o bloco 2 break; // Para aqui case 3: // Execute if n === 3 // Execute o bloco 3 break; // Pare aqui default: // Se tudo mais falhar... // Execute o bloco 4 break )

Preste atenção na palavra-chave quebrar no final de cada bloco de caso. A instrução break faz com que o controle seja transferido para o final da instrução switch e a execução das instruções seguintes continue. As instruções case em uma instrução switch especificam apenas o ponto inicial do código do programa a ser executado, mas não especificam nenhum ponto final.

Se não houver instruções break, a instrução switch começará a executar o bloco de código com o rótulo case correspondente ao valor da expressão e continuará executando as instruções até chegar ao final do bloco. Em casos raros, isso é útil para escrever código que passa de um rótulo de caso para o próximo, mas em 99% dos casos você deve terminar cuidadosamente cada bloco de caso com uma instrução break. (Ao usar um switch dentro de uma função, você pode usar uma instrução return em vez de um break. Ambas as instruções servem para encerrar a instrução switch e evitar que ela vá para o próximo rótulo de caso.)

Abaixo está um exemplo mais prático de uso da instrução switch, ela converte um valor em uma string de uma forma que depende do tipo do valor:

Função convert(x) ( switch(typeof x) ( // Converte um número em um inteiro hexadecimal case "number": return x.toString(16); // Retorna uma string entre aspas case "string": return """ + x + """; // Qualquer outro tipo é convertido da maneira usual padrão: return x.toString(); ) ) console.log(convert(1067)); // Resultado "42b"

Observe que nos dois exemplos anteriores, as palavras-chave case foram seguidas por números ou literais de string. É assim que a instrução switch é usada com mais frequência na prática, mas o padrão ECMAScript permite especificar expressões arbitrárias após o caso.

A instrução switch avalia primeiro a expressão após a palavra-chave switch e, em seguida, as expressões case na ordem em que são especificadas, até que um valor correspondente seja encontrado. O fato de uma correspondência é determinado usando o operador de identidade === em vez do operador de igualdade ==, portanto, as expressões devem corresponder sem qualquer conversão de tipo.

Como nem todas as expressões case são avaliadas cada vez que uma instrução switch é executada, você deve evitar usar expressões case que tenham efeitos colaterais, como chamadas de função e atribuições. É mais seguro limitar as expressões case a expressões constantes.

Conforme explicado anteriormente, se nenhuma expressão case corresponder a uma instrução switch, a instrução switch começa a executar a instrução rotulada como default:. Se o rótulo default: estiver faltando, o corpo da instrução switch será totalmente ignorado. Observe que nos exemplos anteriores, o rótulo default: aparece no final do corpo da instrução switch, depois de todos os rótulos case. Este é um lugar lógico e comum para isso, mas na verdade pode estar localizado em qualquer lugar dentro de uma instrução switch.

Instruções de controle- São instruções que permitem controlar a execução do código do programa. Normalmente, o código em execução em uma instrução de controle é chamado de corpo dessa instrução.

As instruções de controle podem ser aninhadas e também usadas dentro de outras instruções de controle.

Instruções condicionais

Por padrão, o interpretador JavaScript executa instruções uma após a outra na ordem em que aparecem. código fonte. Nos casos em que a execução ou não execução de algumas instruções deva depender do cumprimento ou não cumprimento de alguma condição, são utilizadas instruções condicionais.

declaração if

A instrução if tem duas formas. Sintaxe da primeira forma:

A expressão entre parênteses é chamada condição para cumprimento if declarações ou condições breves. Primeiro, o valor da expressão é calculado. O valor resultante é convertido implicitamente em um tipo booleano, se necessário. Se o resultado da avaliação de uma expressão for verdadeiro, então a instrução é executada. Se a expressão retornar false , a instrução não será executada:

If (true) alert("Concluído!"); if (false) alert("Não será executado!");

A sintaxe if permite executar apenas uma instrução, mas se precisar executar mais de uma instrução, você precisará usar uma instrução composta:

If (true) (var str = "Olá!"; alert(str); )

Sintaxe da segunda forma:

Declaração If (expressão); declaração else;

A palavra-chave else permite adicionar uma instrução que será executada se a condição for avaliada como falsa:

If (falso) alert("Falha"); senão alert("Em execução");

Como já mencionado, as instruções de controle podem ser aninhadas, o que permite criar as seguintes construções:

Var num = 2; if (num == 1) ( alert("num valor: " + num); ) else if (num == 2) ( alert("num valor: " + num); ) else ( alert("Eu não conheço esse número!"); )

Não há nada de especial neste código. É simplesmente uma sequência de instruções, onde cada instrução if é uma outra parte da instrução if anterior. Esta forma de notação pode não parecer totalmente clara à primeira vista, então vamos considerar uma forma sintaticamente equivalente mostrando o aninhamento de instruções if:

Var num = 2; if (num == 1) ( alert("num valor: " + num); ) else ( if (num == 2) ( alert("num valor: " + num); ) else ( alert("Não não conheço esses números!"); ) )