Atribuir variável na declaração da condição if, boa prática ou não? [fechadas]

Há um ano, mudei de linguagens OO clássicas, como Java, para JavaScript. O código a seguir definitivamente não é recomendado (ou mesmo incorreto) em Java:

if(dayNumber = getClickedDayNumber(dayInfo))
{
    alert("day number found : " + dayNumber);
}
function getClickedDayNumber(dayInfo)
{
    dayNumber = dayInfo.indexOf("fc-day");
    if(dayNumber != -1) //substring found
    {
        //normally any calendar month consists of "40" days, so this will definitely pick up its day number.
        return parseInt(dayInfo.substring(dayNumber+6, dayNumber+8));
    }
    else return false;
}

Basicamente, acabei de descobrir que posso atribuir uma variável a um valor em uma instrução da condição if e verificar imediatamente o valor atribuído como se fosse booleano.

Para uma aposta mais segura, normalmente separo isso em duas linhas de código, atribuo primeiro e depois verifico a variável, mas agora que descobri isso, estou apenas me perguntando se é uma boa prática ou não aos olhos dos desenvolvedores de JavaScript experientes.

Eu não recomendaria. O problema é que parece um erro comum quando você tenta comparar valores, mas usa um único em =vez de ==ou ===. Por exemplo, quando você vê isto:

if (value = someFunction()) {
    ...
}

você não sabe se é isso que eles pretendiam fazer ou se pretendiam escrever isto:

if (value == someFunction()) {
    ...
}

Se você realmente quiser fazer a atribuição no local, recomendo fazer uma comparação explícita também:

if ((value = someFunction()) === <whatever truthy value you are expecting>) {
    ...
}

Não vejo prova de que não seja uma boa prática. Sim, pode parecer um erro, mas isso é facilmente remediado por comentários criteriosos. Tomemos por exemplo:

if (x = processorIntensiveFunction()) { // declaration inside if intended
    alert(x);
}

Por que essa função deve ser executada uma segunda vez com:

alert(processorIntensiveFunction());

Porque a primeira versão PARECE ruim? Não posso concordar com essa lógica.

Eu fiz isso muitas vezes. Para ignorar o aviso de JavaScript, adiciono dois parênteses:

if ((result = get_something())) { }

Você deve evitá-lo, se você realmente deseja usá-lo, escreva um comentário acima dele dizendo o que está fazendo.

Você também pode fazer isso em Java. E não, não é uma boa prática. :)

(E use o ===em Javascript para a igualdade de tipos. Leia o livro The Good Parts de Crockford sobre JS.)

Há um caso em que você faz isso, com while-loops.
Ao ler arquivos, você geralmente faz assim:

void readFile(String pathToFile) {
    // Create a FileInputStream object
    FileInputStream fileIn = null;
    try {
        // Create the FileInputStream
        fileIn = new FileInputStream(pathToFile);
        // Create a variable to store the current line's text in
        String currentLine;
        // While the file has lines left, read the next line,
        // store it in the variable and do whatever is in the loop
        while((currentLine = in.readLine()) != null) {
            // Print out the current line in the console
            // (you can do whatever you want with the line. this is just an example)
            System.out.println(currentLine);
        }
    } catch(IOException e) {
        // Handle exception
    } finally {
        try {
            // Close the FileInputStream
            fileIn.close();
        } catch(IOException e) {
            // Handle exception
        }
    }
}

Observe o while-loop na linha 9. Lá, uma nova linha é lida e armazenada em uma variável e, em seguida, o conteúdo do loop é executado. Eu sei que isso não é umif afirmação, mas acho que um loop while também pode ser incluído em sua pergunta.

A razão para isso é que, ao usar um FileInputStream, toda vez que você chama FileInputStream.readLine(), ele lê a próxima linha no arquivo, então se você o tivesse chamado do loop apenas fileIn.readLine() != nullsem atribuir a variável, em vez de chamar(currentLine = fileIn.readLine()) != null , e depois chamado de dentro do loop também, você obteria apenas cada segunda linha.

Espero que você entenda e boa sorte!

Você também pode fazer atribuições em instruções if em Java. Um bom exemplo seria ler e escrever algo:

http://www.exampledepot.com/egs/java.io/CopyFile.html?l=new

O código:

// Copies src file to dst file.
// If the dst file does not exist, it is created
void copy(File src, File dst) throws IOException 
{
    InputStream in = new FileInputStream(src);
    OutputStream out = new FileOutputStream(dst);

    // Transfer bytes from in to out
    byte[] buf = new byte[1024];
    int len;
    while ((len = in.read(buf)) > 0) {
        out.write(buf, 0, len);
    }
    in.close();
    out.close();
}

Se você fosse consultar o livro de Martin Fowlers Refactoring, melhorando o design do código existente ! Então, há vários casos em que seria uma boa prática, por exemplo. condicionais complexos longos para usar uma chamada de função ou método para afirmar seu caso:

"Motivação

Uma das áreas mais comuns de complexidade em um programa reside na lógica condicional complexa. Conforme você escreve código para testar condições e fazer várias coisas dependendo de várias condições, você rapidamente acaba com um método muito longo. O comprimento de um método é em si um fator que o torna mais difícil de ler, mas as condições aumentam a dificuldade. O problema geralmente reside no fato de que o código, tanto nas verificações de condição quanto nas ações, diz a você o que acontece, mas pode facilmente obscurecer por que isso acontece.

Como acontece com qualquer bloco grande de código, você pode tornar sua intenção mais clara decompondo-a e substituindo pedaços de código por uma chamada de método com o nome da intenção desse bloco de código. > Com as condições, você pode receber mais benefícios ao fazer isso para a parte condicional e cada uma das alternativas. Desta forma, você destaca a condição e torna claro o que você está ramificando. Você também destaca o motivo da ramificação. "

E sim, sua resposta também é válida para implementações Java. Ele não atribui a função condicional a uma variável nos exemplos.

Não é uma boa prática. Você logo ficará confuso sobre isso. Parece semelhante a um erro comum: uso indevido dos operadores "=" e "==".

Você deve dividi-lo em 2 linhas de códigos. Isso não apenas ajuda a tornar o código mais claro, mas também facilita a refatoração no futuro. Imagine que você muda a condição IF? Você pode acidentalmente remover a linha e sua variável não obter mais o valor atribuído a ela.

Eu consideraria isso mais um estilo C da velha escola; não é uma prática muito boa em JavaScript, portanto, você deve evitá-la.

você poderia fazer algo assim:

if (value = /* sic */ some_function()){
  use_value(value)
}

Eu vim de Golang, onde é comum ver algo como

if (err := doSomething(); err != nil) {
    return nil, err
}

Em que errtem como escopo ifapenas aquele bloco. Como tal, aqui está o que estou fazendo no es6, o que parece muito feio, mas não faz com que minhas regras bastante rígidas do eslint passem despercebidas e alcança o mesmo.

{
  const err = doSomething()
  if (err != null) {
    return (null, err)
  }
}

As chaves extras definem um novo, uh, "escopo léxico"? O que significa que posso usar conste errnão está disponível para o bloco externo.