Por que é null
considerado umobject
em JavaScript?
Está verificando
if ( object == null )
Do something
o mesmo que
if ( !object )
Do something
?
E também:
Qual é a diferença entre null
e undefined
?
Por que é null
considerado umobject
em JavaScript?
Está verificando
if ( object == null )
Do something
o mesmo que
if ( !object )
Do something
?
E também:
Qual é a diferença entre null
e undefined
?
Respostas:
(name is undefined)
Você: O que é name
? (*)
JavaScript name
:? O que é um name
? Não sei do que você está falando. Você nunca mencionou isso name
antes. Você está vendo alguma outra linguagem de script no lado (cliente)?
name = null;
Você: O que é name
?
JavaScript: não sei.
Em resumo; undefined
é onde não existe noção da coisa; não tem tipo e nunca foi mencionado anteriormente nesse escopo; null
é onde a coisa é conhecida por existir, mas não se sabe qual é o valor.
Uma coisa a lembrar é que null
não é, conceitualmente, o mesmo que false
ou aquilo , mesmo que sejam iguais ""
após a conversão do tipo, ou seja,
name = false;
Você: O que é name
?
JavaScript: booleano falso.
name = '';
Você: O que é name
?
JavaScript: String vazia
*: name
neste contexto, entende-se como uma variável que nunca foi definida. Pode ser qualquer variável indefinida, no entanto, name é uma propriedade de praticamente qualquer elemento de formulário HTML. Vai muito, muito tempo atrás e foi instituído bem antes do id. É útil porque os IDs devem ser exclusivos, mas os nomes não precisam ser.
null
é "nada". Nulo é definido com precisão como sem valor. Vazio, nada, nada. Nada.
name
antes" é verdade. No entanto, declarar uma variável sem atribuir um valor a ela ( var somevar;
), surpreendentemente, ainda resultará em undefined
.
A diferença pode ser resumida neste snippet:
alert(typeof(null)); // object
alert(typeof(undefined)); // undefined
alert(null !== undefined) //true
alert(null == undefined) //true
Verificando
object == null
é diferente de verificar if ( !object )
.
Este último é igual a ! Boolean(object)
, porque o unário!
operador converte automaticamente o operando certo em um Booleano.
Desde Boolean(null)
igual a falso então !false === true
.
Portanto, se seu objeto não for nulo , mas falso ou 0 ou "" , a verificação será aprovada porque:
alert(Boolean(null)) //false
alert(Boolean(0)) //false
alert(Boolean("")) //false
String(null)
ver outro exemplo de transmissão. Você pode até fazer coisas tolas como Number(null + 2)
... mas você não deve :-). Excelente resposta de kentaromiura.
typeof
- se é um operador. Você não colocaria o operando entre parênteses pelo mesmo motivo que não escreveria var sum = 1 +(1);
.
null
não é um objeto , é um valor primitivo . Por exemplo, você não pode adicionar propriedades a ele. Às vezes, as pessoas assumem erroneamente que é um objeto, porque typeof null
retorna "object"
. Mas isso é realmente um bug (que pode até ser corrigido no ECMAScript 6).
A diferença entre null
e undefined
é a seguinte:
undefined
: usado por JavaScript e significa "sem valor". Variáveis não inicializadas, parâmetros ausentes e variáveis desconhecidas têm esse valor.
> var noValueYet;
> console.log(noValueYet);
undefined
> function foo(x) { console.log(x) }
> foo()
undefined
> var obj = {};
> console.log(obj.unknownProperty)
undefined
Acessar variáveis desconhecidas, no entanto, produz uma exceção:
> unknownVariable
ReferenceError: unknownVariable is not defined
null
: usado pelos programadores para indicar “sem valor”, por exemplo, como parâmetro para uma função.
Examinando uma variável:
console.log(typeof unknownVariable === "undefined"); // true
var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true
var bar = null;
console.log(bar === null); // true
Como regra geral, você sempre deve usar === e nunca == no JavaScript (== executa todos os tipos de conversões que podem produzir resultados inesperados). A verificação x == null
é um caso delicado, porque funciona para ambos null
e undefined
:
> null == null
true
> undefined == null
true
Uma maneira comum de verificar se uma variável tem um valor é convertê-la em booleano e verificar se é true
. Essa conversão é realizada pela if
instrução e pelo operador booleano! ("não").
function foo(param) {
if (param) {
// ...
}
}
function foo(param) {
if (! param) param = "abc";
}
function foo(param) {
// || returns first operand that can't be converted to false
param = param || "abc";
}
Desvantagem dessa abordagem: Todos os valores a seguir são avaliados false
, então você deve ter cuidado (por exemplo, as verificações acima não podem distinguir entre undefined
e 0
).
undefined
, null
false
+0
, -0
,NaN
""
Você pode testar a conversão em booleano usando Boolean
como uma função (normalmente é um construtor, para ser usado com new
):
> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true
+0
e -0
separadamente se +0 === -0
?
+0
e -0
: 1/+0 !== 1/-0
.
Qual é a diferença entre null e undefined ??
Uma propriedade quando não possui definição é indefinida. null é um objeto. Seu tipo é objeto. null é um valor especial que significa "nenhum valor. undefined não é um objeto, seu tipo é indefinido.
Você pode declarar uma variável, defini-la como nula e o comportamento é idêntico, exceto que você verá "nulo" impresso versus "indefinido". Você pode até comparar uma variável indefinida como nula ou vice-versa, e a condição será verdadeira:
undefined == null
null == undefined
Consulte Diferença de JavaScript entre nulo e indefinido para obter mais detalhes.
e com sua nova edição sim
if (object == null) does mean the same if(!object)
ao testar se o objeto é falso, ambos apenas atendem à condição ao testar se falso , mas não quando verdadeiro
Verifique aqui: Pegcha Javascript
null
não é um objeto. O typeof null == 'object';
retorno é verdadeiro devido a um erro que não pode ser corrigido no JavaScript (atualmente, mas pode mudar no futuro).
Primeira parte da pergunta:
Por que null é considerado um objeto em JavaScript?
É um erro de design do JavaScript que eles não podem corrigir agora. Deveria ter sido do tipo nulo, não do tipo objeto, ou não possuir nenhum. Requer uma verificação extra (às vezes esquecida) ao detectar objetos reais e é fonte de bugs.
Segunda parte da pergunta:
Está verificando
if (object == null)
Do something
o mesmo que
if (!object)
Do something
As duas verificações são sempre falsas, exceto:
O objeto é indefinido ou nulo: ambos são verdadeiros.
O objeto é primitivo e 0, ""
ou falso: primeiro verifica falso, segundo verdadeiro.
Se o objeto não é um primitivo, mas um objeto real, como new Number(0)
, new String("")
, ou new Boolean(false)
, então ambas as verificações são falsas.
Portanto, se 'objeto' for interpretado como um Objeto real, as duas verificações serão sempre as mesmas. Se primitivas forem permitidas, as verificações serão diferentes para 0 ""
, e false.
Em casos como esse object==null
, os resultados não óbvios podem ser uma fonte de erros. O uso de ==
nunca é recomendado, use em ===
vez disso.
Terceira parte da pergunta:
E também:
Qual é a diferença entre nulo e indefinido?
No JavaScript, uma diferença é que nulo é do tipo objeto e indefinido é do tipo indefinido.
Em JavaScript, null==undefined
é verdadeiro e considerado igual se o tipo for ignorado. Por que eles decidiram isso, mas 0 ""
e falso não são iguais, eu não sei. Parece ser uma opinião arbitrária.
Em JavaScript, isso null===undefined
não é verdade, pois o tipo deve ser o mesmo ===
.
Na realidade, nulo e indefinido são idênticos, pois ambos representam a inexistência. O mesmo acontece com 0, e ""
também nesse caso, e talvez nos contêineres vazios []
e {}
. Muitos tipos do mesmo nada são uma receita para bugs. Um tipo ou nenhum é melhor. Eu tentaria usar o mínimo possível.
'false', 'true' e '!' Há outro pacote de worms que pode ser simplificado, por exemplo, if(!x)
e por if(x)
si só são suficientes, você não precisa de verdadeiro e falso.
Um declarado var x
é do tipo indefinido se nenhum valor for fornecido, mas deve ser o mesmo que se x nunca foi declarado. Outra fonte de erro é um contêiner vazio. Portanto, é melhor declarar e defini-lo juntos, como var x=1
.
As pessoas estão girando e girando em círculos tentando descobrir todos esses tipos diferentes de nada, mas é tudo a mesma coisa em roupas diferentes e complicadas. A realidade é
undefined===undeclared===null===0===""===[]==={}===nothing
E talvez todos devam lançar exceções.
[]
tenha uma .push()
função , portanto não há um bom argumento para [] ser nulo. US $ 0,02.
var x = null;
x é definido como nulo
y não está definido; // porque eu não o defini
if (!x)
nulo é avaliado como falso
Uma maneira de entender nulo e indefinido é entender onde cada um ocorre.
Espere um valor de retorno nulo nas seguintes situações:
Métodos que consultam o DOM
console.log(window.document.getElementById("nonExistentElement"));
//Prints: null
Respostas JSON recebidas de uma solicitação Ajax
{
name: "Bob",
address: null
}
Nova funcionalidade que está em um estado de fluxo. O seguinte retorna nulo:
var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));
// But this returns undefined:
Object.getOwnPropertyDescriptor({}, "a");
Todos os outros casos de inexistência são denotados por indefinidos (conforme observado por @Axel). Cada uma das seguintes impressões é "indefinida":
var uninitalised;
console.log(uninitalised);
var obj = {};
console.log(obj.nonExistent);
function missingParam(missing){
console.log(missing);
}
missingParam();
var arr = [];
console.log(arr.pop());
Obviamente, se você decidir escrever var unitialised = null; ou retorne nulo de um método, você terá nulos ocorrendo em outras situações. Mas isso deve ser bastante óbvio.
Um terceiro caso é quando você deseja acessar uma variável, mas nem sabe se ela foi declarada. Nesse caso, use typeof para evitar um erro de referência:
if(typeof unknown !== "undefined"){
//use unknown
}
Em resumo, verifique se há nulo ao manipular o DOM, lidar com o Ajax ou usar determinados recursos do ECMAScript 5. Para todos os outros casos, é seguro verificar indefinidamente com igualdade estrita:
if(value === undefined){
// stuff
}
Comparação de muitas verificações nulas diferentes no JavaScript:
http://jsfiddle.net/aaronhoffman/DdRHB/5/
// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;
...trim...
http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html
nulo e indefinido são falsos para igualdade de valor (nulo == indefinido): ambos são recolhidos para booleano false. Eles não são o mesmo objeto (nulo! == indefinido).
undefined é uma propriedade do objeto global ("janela" nos navegadores), mas é um tipo primitivo e não um objeto em si. É o valor padrão para variáveis e funções não inicializadas que terminam sem uma declaração de retorno.
null é uma instância de Object. null é usado para métodos DOM que retornam objetos de coleção para indicar um resultado vazio, que fornece um valor falso sem indicar um erro.
Algumas precisões:
nulo e indefinido são dois valores diferentes. Um representa a ausência de um valor para um nome e o outro representa a ausência de um nome.
O que acontece de uma maneira if
é a seguinte if( o )
:
A expressão entre parênteses o é avaliada e, em seguida, if
inicia-se a coação do valor da expressão entre parênteses - no nosso caso o
.
Os valores de falsidade (que serão coagidos a falsos) no JavaScript são: '', nulo, indefinido, 0 e falso .
Para adicionar à resposta de Qual é a diferença entre undefined
enull
, no JavaScript Definitive Guide 6th Edition, p.41 nesta página :
Você pode considerar
undefined
anull
ausência de valor no nível do sistema, inesperada ou semelhante a erro e representar a ausência de valor no nível do programa, normal ou prevista. Se você precisar atribuir um desses valores a uma variável ou propriedade ou passar um desses valores para uma função,null
é quase sempre a escolha certa.
null
é um objeto. Seu tipo é nulo. undefined
não é um objeto; seu tipo é indefinido.
null
e undefined
são valores primitivos - typeof null === 'object'
é um erro de linguagem porque:Object(null) !== null
A função a seguir mostra por que e é capaz de resolver a diferença:
function test() {
var myObj = {};
console.log(myObj.myProperty);
myObj.myProperty = null;
console.log(myObj.myProperty);
}
Se você ligar
test();
Você está recebendo
Indefinido
nulo
As primeiras console.log(...)
tentativas para obter myProperty
a partir myObj
enquanto ele ainda não está definida - por isso, recebe de volta "indefinido". Depois de atribuir nulo a ele, o segundo console.log(...)
retorna obviamente "nulo" porque myProperty
existe, mas tem o valornull
atribuído a ele.
Para poder consultar essa diferença, o JavaScript tem null
e undefined
: Enquanto null
é - assim como em outros idiomas, um objeto undefined
não pode ser um objeto porque não há instância (mesmo que não seja uma null
instância) disponível.
Por exemplo window.someWeirdProperty
é indefinido, então
"window.someWeirdProperty === null"
avalia como falso enquanto
"window.someWeirdProperty === undefined"
avalia como verdadeiro.
Além disso checkif if (!o)
não é o mesmo que a verificação if (o == null)
para o
ser false
.
A outra coisa divertida sobre o nulo, em comparação com o indefinido, é que ele pode ser incrementado.
x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0
Isso é útil para definir valores numéricos padrão para contadores. Quantas vezes você definiu uma variável para -1 em sua declaração?
Veja isso:
<script>
function f(a){
alert(typeof(a));
if (a==null) alert('null');
a?alert(true):alert(false);
}
</script>
//return:
<button onclick="f()">nothing</button> //undefined null false
<button onclick="f(null)">null</button> //object null false
<button onclick="f('')">empty</button> //string false
<button onclick="f(0)">zero</button> //number false
<button onclick="f(1)">int</button> //number true
<button onclick="f('x')">str</button> //string true
De "Os Princípios do Javascript Orientado a Objetos", de Nicholas C. Zakas
Mas por que um objeto quando o tipo é nulo? (De fato, isso foi reconhecido como um erro pelo TC39, o comitê que cria e mantém o JavaScript. Você pode considerar que nulo é um ponteiro de objeto vazio, tornando o "objeto" um valor de retorno lógico, mas isso ainda é confuso.)
Zakas, Nicholas C. (07-02-2014). Os princípios do JavaScript orientado a objetos (Locais 226-227 do Kindle). Sem Starch Press. Edição Kindle.
Dito isto:
var game = null; //typeof(game) is "object"
game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {};
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;
Caso indefinido:
var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.
A melhor maneira de pensar em 'nulo' é lembrar como o conceito semelhante é usado nos bancos de dados, onde indica que um campo não contém "nenhum valor".
Essa é uma técnica muito útil para escrever programas que são mais facilmente depurados. Uma variável 'indefinida' pode ser o resultado de um bug ... (como você saberia?) ... mas se a variável contiver o valor 'null', você saberá que "alguém, em algum lugar deste programa, defina-o como 'null.' "Portanto, sugiro que, quando você precisar se livrar do valor de uma variável, não" exclua "... defina-o como 'null.' O valor antigo ficará órfão e em breve será coletado do lixo; o novo valor é "não há valor (agora)". Nos dois casos, o estado da variável é certo: "obviamente, deliberadamente, foi assim".
Indefinido é um tipo em si, enquanto Nulo é um objeto.
3.Javascript pode inicializar qualquer variável não atribuída como indefinida, mas nunca pode definir o valor de uma variável como nulo. Isso deve ser feito programaticamente.