您的位置:首页 > Web前端 > JavaScript

Javascript 知识与经验(一)—— 基本数据类型

2016-09-03 15:42 701 查看
1、数值类型 Number,Javascript 中的数值都是按照IEEE-754 双精度存储的:

1 的表示方式:1,0000000001(八进制数),0x0001(十六进制)1e1,1e0(科学计数法),1e+1(科学计数法),1e-1(科学计数法)

-0.001 的表示方式:-0.001,-1e-3,-.001

特殊值:Infinity(无穷大),-Infinity(负无穷大),NaN(不是数值,类型为number)

console.log(NaN + 0.1);// NaN;
console.log(0.2+0.3);//0.30000000000000004(不精确);
console.log(0.1+1);//1.1(精确);
console.log(0.20 + null);// 0.2;
console.log(0.2 + undefined);// NaN
console.log(0.2 / 0); //Infinity
console.log(0.2 / 0);// -Infinity
console.log(0.2 / -0);// Infinity(注意,可见js运算时先进行符号处理了)
console.log(isNaN(NaN));//true
console.log(isNaN(undefined));// true
console.log(isNaN(Infinity));//false
console.log(isNaN(null));//fasle


  参数为 Number 类型的常用函数:isNaN,toFixed,toPrecision

2、字符串类型 String,特殊的 Object 类型:

类型判断 typeof str === “string”

‘这是一个字符串’ (使用单引号或双引号括起来的表达式)

‘我说:”我爱你!”’(单引号中使用双引号或双引号中使用单引号)

”或“”(空字符串)

var str = "abc"; //类型为 string
str = "\u{41}\u{42}\u{43}"; //"ABC" ES6 Unicode 字符的新表示法
var str2 = new String("abc"); //类型为 object,明确指明 str2 为引用类型的 String 类型,防止js解释器混淆字符串和数值
表达式的值:
console.log('这是一个字符串'+null); // 这是一个字符串null
console.log('这是一个字符串'+undefined); // 这是一个字符串undefined
console.log('这是一个字符串'+NaN); // 这是一个字符串NaN
console.log('这是一个字符串'+Infinity); // 这是一个字符串Infinity (可见特殊对象都是先调用了toString转为了字符串


3、布尔类型 boolean,true和false:

在布尔判断上下文中(如if语句,?:三元判断,!0 等!求非运算),空串、NaN、null、undefined、0(数值0,0.00等)和关键字 false都被认为是 布尔值false,其他值都被解析为布尔true,常使用 !0、!undefined、!null表示 true,,!!0、!1 表示 false

类型判断 typeof bool === “boolean”

4、对象类型 Object:

类型判断:typeof obj === “object”

类型继承,参见 Function 代码

对象的重要属性:

  constructor:返回对创建此对象的函数的引用

  prototype:用于给对象类型添加属性和方法。

  hasOwnProperty: 判断一个对象是否有某个属性,不检查对象的类原型链

  isPrototypeOf:判断其

var obj = new Object();//使用构造函数创建对象
obj.prop = {name:"张三"};//为对象obj 添加一个对象属性 prop  的类型也是一个对象,该对象使用了json对象表达方式构造
console.log(obj.prop.name);//输出obj的 prop 属性的name属性的值
Object.prototype.name = "李四";//给类型Object添加一个类型属性name,该类型属性为对象类型
var newObj = {};//使用 json 对象表达式方式构造创建一个新对象
console.log(newObj.name);//由于给类型Object 添加了name属性,newObj 可使用到类的属性,于是输出 李四
console.log(obj.name);//虽然给类 Object 添加属性在 obj 构造调用之后,但该属性也附加到对象 obj 上了
Object.prototype.prop = {name:"王五"};
console.log(newObj.prop.name);//输出 王五 无疑义
console.log(obj.prop.name); //优先使用 对象的属性
newObj.prop2 ={name:"prop2"};
Object.prototype.prop2 = {name:"Object prop2"}
console.log(newObj.prop2.name);//证明优先使用 对象的属性,类的属性没有覆盖掉 对象的属性
var prop;
for(prop in obj){
console.log(prop+":"+obj[prop]);//属性值对
}


5、函数类型 Function:

类型判断:typeof func === “function”

var func = function(){}
console.log(func.name); //输出 func
var strToJson = function(str) { return  new Function('return '+str)();}//使用json字符串构造json对象
console.log(strToJson('{name:"张三"}'));// 生成对象 Object{name:'张三'}
function Parent(){console.log('构造Parent父类');}
function Base(){console.log("构造Base基类")}
Base.prototype.eat = function(){console.log('基类吃饭!');}
Parent.prototype = new Base();//使用继承
Parent.prototype.work = function(){console.log('父类工作!');}
var p = new Parent();
p.eat();
p.work();//基类工作 或 父类工作,取决于下一句是否重写了基类方法
Parent.prototype.eat = function(){console.log("父类吃饭!");}//该句注释将对上一句结果影响,说明js语句并非按顺序处理,而是按照先类型定义后代码调用的方式执行
p.work();
//闭包函数:它处于一个函数体重,并引用了函数体当前执行上下文中的变量
var name = "Tom";
var hello = (function(name){
console.log("参数:"+name);//仅在闭包函数被定义并构建时调用一次,以后闭包函数执行时不变
return function(){
console.log("Hello "+name);
}
})(name);//闭包在创建时因为其执行上下文已经被确定
hello(); // Hello Tom
name = "Peter";
console.log(name);//n
hello();// Hello Tom
hello("Li Li");// Hello Tom
hello();// Hello Tom


6、Undefined 类型:

类型判断:typeof undefinedVar === “undefined”;

已存在一个该类型对象 undefined,其他未定义的符合变量命名规则的变量均被认为是 undefined 类型

console.log(typeof v === "undefined");//true
console.log(typeof undefined === "undefined");//true
console.log(null == undefined);//true null是内存中没有引用(或地址),与undefined 相同
console.log(NaN == undefined);//false NaN不是数值 是一个对象,是有引用(地址)的
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签:  javascript 数据类型