É melhor retornar ʻundefined` ou `null` de uma função javascript?

Tenho uma função que escrevi que basicamente se parece com isto:

function getNextCard(searchTerms) {
  // Setup Some Variables

  // Do a bunch of logic to pick the next card based on termed passed through what I'll call here as 'searchTerms' all of this logic is omitted because it's not important for my question.
  // ...

  // If we find a next card to give, than give it
  if (nextCardFound)
    return nextCardFound;

  // Otherwise - I'm returning undefined
  return undefined;
}

Pergunta: Seria melhor retornar "nulo" aqui?

Posso devolver o que quiser - obviamente ... Só não tinha certeza de qual é a melhor coisa a usar.

O código que chama esta função sabe como lidar com indefinidos (na verdade, nunca realmente acontecerá, a menos que algo dê terrivelmente errado)

Estou fazendo essa pergunta porque ouvi em algum lugar algo que soou como "Não atribua variáveis ​​indefinidas a variáveis" ou algo assim - que tornará mais difícil depurar. Portanto, o fato de que eu posso ver que nullé passado de volta me diz que o retorno está funcionando - mas basicamente funciona de forma semelhante a undefined.

Documentação:

Mozilla Docs não respondeu minha pergunta ... o google também não: \

Esta pergunta SO - era muito ampla para o que estou tentando descobrir aqui.

Eu argumentarei que não existe a melhor maneira, e mesmo as funções padrão às vezes escolhem um ou outro.

Por exemplo:

• [[Protótipo]]

  Objetos comuns têm um slot interno [[Prototype]], que determina de qual outro objeto eles herdam. Claro, deve haver uma maneira de dizer que um objeto não herda de nenhum outro. Nesse caso, "esse objeto não existe" é representado por null.

• Object.getOwnPropertyDescriptor

  Espera-se retornar um descritor de propriedade, ou seja, um objeto que descreve uma propriedade (por exemplo, valor, capacidade de escrita, enumerabilidade e configurabilidade). No entanto, a propriedade pode não existir. Nesse caso, "essa propriedade não existe" é representado por undefined.

• document.getElementById

  Espera-se que ele retorne o elemento com o ID fornecido. No entanto, pode não haver nenhum elemento com esse ID. Nesse caso, "esse elemento não existe" é representado por null.

Portanto, escolha o que você preferir ou achar que faz mais sentido para o seu caso específico.

Indefinido normalmente se refere a algo ao qual ainda não foi atribuído um valor (ainda). Nulo se refere a algo que definitivamente não tem valor. Nesse caso, eu recomendaria retornar um valor nulo. Observe que uma função sem valor de retorno especificado retorna implicitamente indefinido.

Da especificação ECMAScript2015

4.3.10 valor indefinido

valor primitivo usado quando uma variável não recebeu um valor

4.3.12 valor nulo

valor primitivo que representa a ausência intencional de qualquer valor de objeto

http://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-undefined-type

Leitura adicional:

Quando é nulo ou indefinido usado em JavaScript?

Darei a você minha maneira opinativa de escolher entre os dois.

Minha pergunta simples é: o valor, dado outra entrada / estado / contexto, pode ser definido para algo?

Se a resposta for sim, use nullelse use undefined. Mais geralmente, qualquer função que retorna um objeto deve retornar nullquando o objeto pretendido não existe. Porque poderia existir dado outra entrada / estado / contexto.

nullrepresenta a ausência de valor para uma determinada entrada / estado / contexto. Significa implicitamente que o conceito do próprio valor existe no contexto de seu aplicativo, mas pode estar ausente. Em seu exemplo, o conceito de uma próxima carta existe, mas a própria carta pode não existir. nulldeve ser usado.

undefinedrepresenta implicitamente a ausência de significado desse valor no contexto do seu aplicativo. Por exemplo, se eu manipular um userobjeto com um determinado conjunto de propriedades e tentar acessar a propriedade pikatchu. O valor dessa propriedade deve ser definido como undefinedporque, em meu contexto, não faz sentido ter tal propriedade.

undefinednão é algo que você deva atribuir. Você pode querer retornar algo diferente de undefined. No seu caso, mesmo que você não retorne nada, o resultado undefinedjá será . Então, eu sugiro ir com null.

Considere esta amostra,

function getSomething() {
     // .. do something
     return undefined;
}

function doSomething() {
     // .. I'm not gonna return anything.
}

var a = getSomething();
var b = doSomething();

Resultado da amostra acima em a === b, que é undefined. A diferença é que você salva 1 execução de instrução.

Depende do que você precisa fazer com o valor retornado.

typeof null retorna um objeto. esse objeto tem um valor de indefinido

typeof undefined retorna undefined

Aqui está um exemplo onde undefinedfaz mais sentido do que null:

Eu uso uma função de wrapper para JSON.parseconverter sua exceção emundefined :

// parses s as JSON if possible and returns undefined otherwise
// return undefined iff s is not a string or not parseable as JSON; undefined is not a valid JSON value https://stackoverflow.com/a/14946821/524504
function JSON_parse_or_undefined(s) {
    if ("string" !== typeof s) return undefined

    try {
        const p = JSON.parse(s)
        return p
    } catch (x){}

    return undefined
}

Observe que nullé válido em JSON, enquanto undefinednão é.

A primeira resposta está certa. Eles têm significados teoricamente diferentes. No entanto, nem sempre está claro qual escolher.

Eu tendo a usar null no meu desenvolvimento, embora eu ache que isso seja uma coisa completamente subjetiva.

Eu uso isso principalmente porque:

1. variável indefinida pode ser substituída em navegadores antigos, portanto, devolvê-la é um pouco mais complicado. Esse mesmo problema o força a usar typeof var === 'undefined'ao obter resultados de funções. ligação

2. Outras linguagens tendem a usar null amplamente, muitas delas nem mesmo têm undefined (php por exemplo). Isso me dá um tipo de consistência ao alternar rapidamente entre os idiomas.

Eu acho que é muito discutível o que usar. Eu prefiro um código que seja semanticamente o mais preciso possível, então acho que undefinedé apropriado neste caso.

Eu penso em nullatribuições como significando "uma variável definida para nada". Isso é o oposto deundefined significar "essa coisa não está lá"

Como uma resposta anterior apontou, retornar undefinedtem problemas e você decide se isso o incomoda. Isso não me incomodaria.

Eu diria que, neste caso, nulldeve ser devolvido.

Se você considerar a questão de um ponto de vista teórico da ciência da computação, undefined é usado para indicar não terminação / não computabilidade (isto é, o espaço reservado para um ponto indefinido xde uma função parcial f que é freqüentemente escrita f(x) = ⊥).

getNextCardno entanto, parece ser capaz de calcular a próxima carta (se houver) e também ser capaz de calcular se não houver uma próxima carta. Em outras palavras, a função é total, pois termina para cada entrada.

Dito isto, é necessária uma terminação de sinalização de valor especial sem resultado significativo (ou seja, "não há cartão que eu possa retornar para esta entrada") e isso para mim nullnão é undefined.

NOTAS:

Você pode ver algum suporte para esse argumento em algumas outras linguagens tipadas, bem como onde a terminação sem resultado significativo é expressa usando um tipo de opção (às vezes também referido como tipo anulável ). Um exemplo disso é Maybe in Haskell .

Por outro lado, é claro que não sabemos o que undefinedem JavaScript realmente significa. Então, a analogia com indefinido é um pouco tênue. Além disso, como sempre queremos trabalhar com funções totais, isso equivale a dizer "nunca retorne undefinedde uma função". O que parece ser um pouco estrito, pois limitaria o uso de undefinedpropriedades / variáveis ​​que não foram definidas.

No final, minha preferência pessoal é nunca mais voltar undefinedaonde eu possa voltar nulle eu também argumentaria que essa é a melhor convenção de codificação (porque, entre outras coisas, x !== nullé mais curta do que typeof x !== 'undefined').

Minha opinião pessoal de acordo com minha experiência é não use undefined e null se você não quiser travar seu código. Pelo menos eu o evitaria pessoalmente. Existem muitas funções em Javascript que retornam indefinidas e ok devemos usar para isso. Mas quando você projetar seu código, não o use. É importante sempre devolver algo, "false"pelo menos. Se você tem um array, por exemplo, e mapeia sobre ele. Não é bom voltar [undefined, undefined.....]nem justo undefined. É melhor se você mantiver o tipo do array original. Exemplo:

 const mapper:Map <string[],boolean[]>  
['i', 'dont', 'use', 'null or undefined'] -> [false, true, false, true, false]
or ['', dont, '', '', use] 
or al the stuff above and then filter(v => v)
that will keep all undefined and null out

Essa é a ideia. Eu tento o tempo todo evitar isso. Porque um nullou undefinedpode facilmente travar seu código