javascript判断变量是否为对象

1. javascript如何判断是不是一个对象

比如有一个变量a，

js">vara=xxxxxxxx;
if(typeofa=="number"){
//a是数
}elseif(typeofa=="string"){
//a是字符串
}elseif(typeofa=="undefined"){
//a是未定义
}elseif(typeofa=="boolean"){
//a是bool变量
}elseif(typeofa=="object"){
//a是对象
}

或者使用instance of：

varb=newDate();
if(binstanceofDate){
//b是Date类型的
}
varc=[];
if(cinstanceofArray){
//c是数组
}

2. 中如何判断变量是数组，函数还是对象类型

JavaScript中检测对象的方法
1.typeof操作符
这种方法对于一些常用的类型来说那算是毫无压力，比如Function、String、Number、Undefined等，但是要是检测Array的对象就不起作用了。

代码如下:

alert(typeof null); // "object"
alert(typeof function () {
return 1;
}); // "function"
alert(typeof '梦龙小站'); // "string"
alert(typeof 1); // "number"
alert(typeof a); // "undefined"
alert(typeof undefined); // "undefined"
alert(typeof []); // "object"

2.instanceof操作符
这个操作符和JavaScript中面向对象有点关系，了解这个就先得了解JavaScript中的面向对象。因为这个操作符是检测对象的原型链是否指向构造函数的prototype对象的。
var arr = [1,2,3,1];
alert(arr instanceof Array); // true
3.对象的constructor属性
除了instanceof，每个对象还有constructor的属性，利用它似乎也能进行Array的判断。

代码如下:

var arr = [1,2,3,1];
alert(arr.constructor === Array); // true

第2种和第3种方法貌似无懈可击，但是实斗闷禅际上还是有些漏洞的，当你在多个frame中来空尘回穿梭的时候，这两种方法就亚历山大了。由于每个iframe都有一套自己的执行环境，跨frame实例化的对象彼此是不共享原型链的，因此导致上述检测代码失效!

代码如下:

var iframe = document.createElement('iframe'); //创建iframe
document.body.appendChild(iframe); //添加到body中
xArray = window.frames[window.frames.length-1].Array;
var arr = new xArray(1,2,3); // 声明数组[1,2,3]
alert(arr instanceof Array); // false
alert(arr.constructor === Array); // false

检测数组类型方法
以上那些方法看上去无懈可击，但是终究会有些问题，接下来向大家提供一些比较不错的方法，可以说是无懈可击了。
1.Object.prototype.toString
Object.prototype.toString的行为：首先，取得对象的一个内部属性[[Class]]，然后依据这个属性，返回一个类似于"[object

Array]"的字符串作为结果(看过ECMA标准的应该都知道，[[]]用来表示语言内部用到的、外部不可直接访问的属性，称为“内部属性”)。利用这
个方法，再配合call，我们可以取得任何对象的内部属性[[Class]]，然后把类型检测转化为字符串比较，以达到我们的目的。

代码如下:

function isArrayFn (o) {
return Object.prototype.toString.call(o) === '[object Array]';
}
var arr = [1,2,3,1];
alert(isArrayFn(arr));// true

call改变toString的this引用为待检测的对象，返回此对象的字符串表示，然后对比此字符串是否是'[object
Array]'，以判断其是否是Array的实例。为什么不直接o.toString()?嗯，虽然Array继承自Object，也会有
toString方法，但是这个方法有可能会被改写而达不到我们的要求，而Object.prototype则是老虎的屁股，很少有人敢去碰它的，所以能一定程度保证其“纯洁性”罩液：)

JavaScript 标准文档中定义: [[Class]] 的值只可能是下面字符串中的一个： Arguments,
Array, Boolean, Date, Error, Function, JSON, Math, Number, Object,
RegExp, String.
这种方法在识别内置对象时往往十分有用，但对于自定义对象请不要使用这种方法。
2.Array.isArray()
ECMAScript5将Array.isArray()正式引入JavaScript，目的就是准确地检测一个值是否为数组。IE9+、
Firefox 4+、Safari 5+、Opera 10.5+和Chrome都实现了这个方法。但是在IE8之前的版本是不支持的。
3.较好参考
综合上面的几种方法，有一个当前的判断数组的最佳写法：

代码如下:

var arr = [1,2,3,1];
var arr2 = [{ abac : 1, abc : 2 }];
function isArrayFn(value){
if (typeof Array.isArray === "function") {
return Array.isArray(value);
}else{
return Object.prototype.toString.call(value) === "[object Array]";
}
}
alert(isArrayFn(arr));// true
alert(isArrayFn(arr2));// true

3. js里判断变量是数组还是对象的四种方法

因为无论是数组还是对象，对于typeof的操作返回值都为object，所以就有了区分数组类型和对象类型的需要：
方一：通过length属性：一般情况下对象没有length属性值，其值为undefiend，而数组的length值为number类型
缺点：非常不实用，当对象的属性存在length，且其值为number（比如类数组），则该方法失效，不建议使用，看看即可。
*方二：通过instanceof来判断区分
var arr = [1, 2, 3]; var obj = {name: 'lyl',age: 18, 1: 'name'}console.log(arr instanceof Array); //trueconsole.log(obj instanceof Array); //false
*方三：通过constructor
var arr = [1, 2, 3]; var obj = {name: 'lyl',age: 18, 1: 'name'}console.log(arr.constructor === Array); //trueconsole.log(obj.constructor === Array); //false

4. JS有几种方法判断变量的类型

1、使用typeof检测，当需要判断变量是否是number，string，boolean，function，undefined等类型时，可以使用typeof进行判断。

2、使用instanceof检测，instanceof运算符与typeof运算符相似，用于识别正在处理的对象的类型。与typeof方法不同的是，instanceof方法要求开发者明确地确认对象为某特定类型。

3、使用constructor检测，construction本来是原型对象上的属性，指向构造函数。但是根据实例对象寻找属性的顺序，若实例对象上没有实例属性或方法时，就去原型链上寻找，因此，实例对象也是能使用constructor属性的。

5. JS判断对象是否存在的十种方法

可以参考下面的两种方法：

1、直接判断对象不为null

if (!myObj) {

var myObj = { };

}

Javascript语言是"先解析，后运行"，解析时就已经冲宏完成局镇了变量声明

2、使用window对象判断某对象是否存在

if (!window.myObj) {

var myObj = { };

}

(5)javascript判断变量是否为对象扩展阅读：

javascript函数

charCodeAt(index)返回一个整数,该整数表现String对象中指定位置处的字符的Unicode编码

concat(string2)衔接两条或少条字符串

fromCharCode(num1, num2, …,BB霜, numN)获取指定的Unicode值并返回字符串

indexOf(searchString, startIndex) 返回字符串中第一个呈现指定字符串的地位

lastlndexOf(searchString, startIndex) 返回字符串中最后一个呈现指定字散腊册符串的地位

match(regex) 在字符串中查觅指定值

6. 如何判断变量是数组还是对象

在JavaScript中所有数据类型严格意义上都是对象，但实际使拦磨用中我们还是有类型之分，如果要判断一个变量是数组还是对简昌斗象使用typeof搞不定，因为它全都返回object

var o = { 'name':'lee' };
var a = ['reg','blue'];

var getDataType = function(o){
if(typeof o == 'object'){
if( typeof o.length == 'number' ){
return 'Array';
}else{
return 'Object';
}
}else{
return 'param is no object type';
}
};

alert( getDataType(o) ); //迅皮 Object
alert( getDataType(a) ); // Array
alert( getDataType(1) ); // param is no object type
alert( getDataType(true) ); // param is no object type
alert( getDataType('a') ); // param is no object type

7. Javascript如何判断一个变量是普通变量还是数组还是对象

1、使用typeof操作符检测变量类型
数组、Null、Object
为
object
类型
字符串
为
string
类型
true和false
为
boolean
类型
整型、浮点型为
number
类型
2、如果要区分数组和非数组对象，需要使用构造函数来判断
if(arr.constructor==Array)
//
arr
是数组
else
//
arr
不是数组

8. javascript 中的this如何判断他是代表哪一个对象呢

一．This对象的概述
在javascript编程中，我们经常用到this关键字，但有时也经常被它搞得头晕，下面将说明this的作用范围与以及它所指代的对象。
This特指当前对象，所有通过this.attr赋予的属性，都属于当前对象；那当前对象是什么呢，它的作用范围又是什么呢，在不同情况下，this对象的表现形式各不相同，下面就讲讲我对this对象的理解。

二．This所指代的对象

1． 对于javascript，它的编写方式比较随意，但扩展性很强，我们可以使用面向过程的编写方式，也可以使用面向对象的编写方式，在这两种编写方式下，this的表现形式是不同的，下面我们先看一下定义变量的一些方式。
下面我们看一个示例（这是一个面向过程的调用方式，先不急于看结果，你可以自己想一下执行结果该是什么）：
functiontest(){
var1=100;
varvar2=100;
this.var3=100;
f1=function(){}
varf2=function(){}
functionf3(){}
this.f4=function(){}
}
test();
alert(typeof var1);
alert(typeof var2);
alert(typeof var3);
alert(typeof f1);
alert(typeof f2);
alert(typeof f3);
alert(typeof f4);

//======以下是上面的执行结果======
1.number
2.undefined
3.number
4.function
5.undefined
6.undefined上面f2的写法等价于f3的写法
7.function
解析：我们可以把window看成一个大对象，它是Window对象的实例化，我们编写的所有javascript代码都包含在该对象内，因此，当前对象this特指window实例。
1. alert(typeof var1);//number
var1是一个未明确定义的变量，根据作用域范围定义，该对象属于window实例的对象，它的作用范围为全局。
2. alert(typeof var2);//undefined
var2是一个明确定义枯核液的变量，根据作用域范围定义，该对象的作用域范围为函数级别，即test函数所属范围，因此不可访问。
3. alert(typeof var3);
var3是以对象属性的方式定义的，但是test调用的时候却是氏手以过程的方式调用，也就是说test没有被实例化成对象，并且test属于window对象，那么当前对象this仍然是window，所以var3属性是属于window的。
4. alert(typeof f1);
f1函数与var1变量同理
5. alert(typeof f2);
f2函数与var2变量同理
6. alert(typeof f3);
f3函数与var2变量同理
7. alert(typeof f4);
f4函数与var3变量同理
//===============================

下面是一个面向对象的调用示例：
functiontest(){
var1=100;
varvar2=100;
this.var3=100;
f1=function(){}
varf2=function(){}
functionf3(){}
this.f4=function(){}
}
t =newtest();
alert(typeof var1);
alert(typeof var2);
alert(typeof var3);
alert(typeof t.var3);
alert(typeof f1);
alert(typeof f2);
alert(typeof f3);
alert(typeof f4);
alert(typeof t.f4);
//======以下是上面的执行结果======
1． Number
2． Undefined
3． Undefined
4． Number
5．没物 Function
6． Undefined
7． Undefined
8． Undefined
9． Function
解析：这次test是使用面向对象的方式调用的，下面我们看一下，为何执行结果会是如此：
1． alert(typeof var1);还是作用域的问题，未明确定义为全局变量
2． alert(typeof var2);明确定义，为函数级别变量
3． alert(typeof var3);
因为test当前是使用面向对象的方式调用的，那么test对象中的当前对象为实例化的test，即this已经不是window对象了，而是test的实例化t
4． alert(typeof t.var3);
由上面解析可知，var3属于对象t，那么自然可以获得此变量
5． alert(typeof f1);同理var1
6． alert(typeof f2);同理var2
7． alert(typeof f3);同理var2
8． alert(typeof f4);同理var3
9． alert(typeof t.f4);同理var3

三．This的操作与修改
上面我们了解了一下this指代的对象和作用范围，但实际上this是可以被指定修改的，我们可以通过call,apply等函数指定当前函数的this对象，通常这些函数也用于继承的实现。
如上面的函数通过call来调用指定this对象，将获得完全不同的执行结果，以下我们通过call实现了javascript的继承。
functionf1(){
this.age=27;
}
functiontest(){
f1.call(this);
this.address='地址';
}
t=newtest();
alert(t.age);
alert(t.address);

不是原创的，希望对你有帮助。

9. nodejs中怎么判断一个对象类型

代码如下：

function checkUnfined(value){

if(typeof(value)=='undefined'){

return "";

}

return value;

}

10. js判断一个变量或对象是否存在

1、首先创建两个文件，一个jstest.html，一个jstest.js文件。