Solucionado (ver solução)
Solucionado
(ver solução)
2
respostas

Não consigo utilizar o operador condicional ternário para substituir o if

Estou tentando substituir o uso do if por meio do operador condicional ternário (condição) ? return if true: return if false.

Exemplo:

--> Com o if:

```
    let data = new Date(...this._inputData.value.split('-')
    .map(
           if (indice == 1){
            return (item - 1);
        }
        return item;
    ));
```

--> Com o uso do operador ternário:

```
let data = new Date(...this._inputData.value.split('-')
.map(
    (item, indice)=>{
        (indice == 1) ? (item - 1) : item;
    }
));
``` 

Porém, quando dou o console.log(data), aparece um Invalid Date.

2 respostas

Talvez só poderia mudar algumas coisas no map e ver se funciona...

let data = new Date(...this._inputData.value.split('-')
.map( (item, indice) => indice == 1  ?  item - 1 : item));
solução!

Uma vez utilizados os brackets ({ }) na declaração de uma arrow function, você precisa deliberadamente declarar o retorno da função com return. Desta forma:

let data = new Date(...this._inputData.value.split('-')
.map((item, indice) => {
        return (indice == 1) ? (item - 1) : item;
    }
));

No entanto, como seu objetivo é reduzir os if statements com o operador ternário, talvez faça mais sentido seguir esta opção:

let data = new Date(...this._inputData.value.split('-')
    .map((item, indice) => indice === 1 ? item-1 : item)

Se não me engano, quando se utiliza arrow functions, só é necessário a utilização dos brackets se o corpo da função tiver mais de um comando. Podemos, também, encadear comandos para que não seja necessária a utilização de brackets. Exemplo:

//Comandos não encadeados
let dataValues = this._inputData.value
let dataArray = dataValues.split('-')
let dataFormat = dataArray.map((item, indice) => indice === 1 ? item-1 : item)
let data = new Date(dataFormat)

//Comandos encadeados
let data = new Date(...this._inputData.value.split('-').map((item, indice) => indice === 1 ? item-1 : item)

De modo que, caso a função tenha só um comando e não utilizarmos brackets, o retorno desta será justamente este comando. Caso contrário, você obrigatoriamente precisa declarar o retorno com return (e isto vale para funções que possuem só um comando em seu corpo, mas mesmo assim utilizam brackets).

Utilizei o operador de igualdade estrita (===) para ter certeza de que nenhum valor seja convertido, ao ser comparado com outro. Ou seja, compara-se, também, o tipo de dado, e é boa prática utilizá-lo.

Referências