精选文章 【js实例】js中的5种基本数据类型和9种操作符

【js实例】js中的5种基本数据类型和9种操作符

作者:辛苦的码农20200609 时间: 2020-08-04 10:20:40
辛苦的码农20200609 2020-08-04 10:20:40

js中的5中基本数据类型

js标识符

  1. 第一个字符必须为字母,下划线,或美元符
  2. 其他字符可以是字母,下划线,美元符,数字
  3. js标识符区分大小写
  4. 标识符不能使关键字和保留字

关键字:

breakdoinstanceoftypeof
caseelsenewvar
catchfinallyreturnvoid
continueforswitchwhile
debuggerfunctionthiswith
defaultifthrow 
deleteintry 

保留字:

abstractenumintshort
booleanexportinterfacestatic
byteextendslongsuper
charfinalnativesynchronized
classfloatpackagethrows
constgotoprivatetransient
debuggerimplementprotectedvolatile
doubleimportpublic 

 

js注释

//单行注释

/*

多行注释

*/

 

js模式

严格模式:使用 use strict 

混杂模式:不加 use strict 

 

 

js数据类型

js中有5中简单数据类型,也成为基本数据类型:Undefined, Null, Boolean, Number, String

/*
=======================================================
Undefined类型只有一个值:undefined,表示未定义这个量
为初始化的变量会自动赋予undefined值
*/

var message;
alert(typeof message);    //undefined
alert(age);                //出错,不执行这条语句

var message2;
alert(typeof message2);    //undefined
alert(typeof age);        //undefined


/*
Null类型也只有一个值:null
*/

alert(typeof null);    //返回object,从逻辑角度来看,null值表示一个空对象指针
                        实际上是浏览器的bug一直延续至今
alert(undefined == null);    //返回true,undefined派生自null值


/*
Boolean类型只有两个值:true和false。注意:TRUE,True,FALSE,False不是Boolean类型,而是标识符
可以对任何数据类型调用Boolean函数,总会返回一个Boolean值
数据类型            转换为true的值                            转换为fasle的值
Boolean             true                                     false
String             任何非空字符串                            ""(空字符串)
Number            任何非零数值(包括无穷大)                    0和NaN
Object            任何对象                                    null
Undefined         不适用                                    undefined
*/

alert(Boolean(true));        //true
alert(Boolean(false));        //false

alert(Boolean("s"));        //true
alert(Boolean(""));            //false

alert(Boolean(2));            //true
alert(Boolean(Infinity));    //true
alert(Boolean(0));            //false
alert(Boolean(NaN));        //false

alert(Boolean(new Object()));//true
alert(Boolean(null));        //false

alert(Boolean(undefined));    //false


/*
Number类型
进行算数运算时,所有的八进制和十六进制会转化为十进制数值
*/

//十进制
alert(23);         //23
alert(23.3);    //23.3
alert(2.3e4);    //23000

//若数字为0开头则视为八进制,注意:八进制在严格模式下无效
alert(070);        //56

//十六进制的前两位为0x
alert(0x33);    //51

alert(Number.MAX_VALUE);//1.7976931348623157e+308
alert(Number.MIN_VALUE);//5e-324

/*
若数值不在MIN_VALUE和Number.MAX_VALUE之间,
1.num < 0, 返回-Infinity
2.num > 0, 返回Infinity
*/

var num = Number.MAX_VALUE + 1;
alert(num);        //Infinity
num = Number.MIN_VALUE - Number.MAX_VALUE;
alert(num);        //-Infinity


/*
NaN:非数值,not a number。表示一个本来返回数值的操作数未返回数值的情况
1.任何涉及NaN的操作都会返回NaN
2.NaN和任何值都不相等
*/
alert(NaN - 10);    //NaN
alert(NaN == NaN);    //false

/*
isNaN()接受一个参数x,若x不是数值则返回true,反之返回false
isNaN()接受参数x时会尝试将x转化为数值
*/
alert(isNaN(NaN));        //true
alert(isNaN(10));        //false
alert(isNaN("10"));        //false "10"可以转化为数值10
alert(isNaN("blue"));    //true     "blue"不可以转化为数值
alert(isNaN(false));    //false true可转为1,fasle可转为0


/*
数值转换:Number(), parseInt()和parseFloat()
*/

//1.如果是Boolean值,则true返回1,false返回0
alert(Number(true));    //1
alert(Number(false));    //0

//2.如果是数值,则只是简单的传入和返回
alert(Number(23));    //23

//3.如果是null则返回0
alert(Number(null));    //0

//4.如果是undefined则返回NaN
alert(Number(undefined));    //NaN

//5.如果是NaN则返回NaN
alert(Number(NaN));    //NaN


//6.字符串
//6.1:若字符串中包含数字则将其转换为十进制数即可;忽略前导0
alert(Number("23"));    //23
alert(Number("23.3"));    //23.3
alert(Number("023"));    //23
alert(Number("023.3"));    //23.3
alert(Number("0xA"));    //10
//6.2:若是空字符串,则转换为0
alert(Number(""));        //0
//6.3:若字符串包含上述格式之外的字符则将其转换为NaN
alert(Number("23#"));    //NaN

//7.若是对象,则调用valueOf()方法,按上述方法转换;若转换为NaN则调用toString()方法再次按上述方法转换
var a = new Object();
alert(Number(a));        //NaN
a = "23";
alert(Number(a));        //23


//parseInt在解析字符串时和Number有点区别
//1.忽略空格,若第一个字符为数字字符,则解析到非数字字符为止
alert(parseInt("   123 4blue"));    //123,4前面的空格符是非数字字符
//2.空字符串返回NaN,无法识别字符串也返回NaN
alert(parseInt(""));            //NaN
alert(parseInt("AF"));            //NaN
//3.能解析各种格式整数
alert(parseInt("0xA"));            //10
alert(parseInt("70"));            //70
alert(parseInt("070"));            //56,ECMAScript3认为是56,ECMAScript5认为是70
alert(parseInt("0xf"));            //15
//4.解析浮点数时,正数向下取整,负数向上取整
alert(parseInt(22.9));            //22
alert(parseInt(-22.9));            //-22


//可以给parseInt传递第二个参数,指定转换的进制
alert(parseInt("A", 16));    //10
alert(parseInt(110, 2));    //6
alert(parseInt(110, 8));    //72
alert(parseInt(110, 10));    //110
alert(parseInt(110, 16));    //272


/*
parseFloat()与parseInt类似;不过parseFloat()只解析十进制;若parseFloat()解析的是整数(也可没有小数点,或者小数点后全为0),
则返回整数
*/
alert(parseFloat("0xA"));    //10
alert(parseFloat("2.000"));    //2
alert(parseFloat(2.000));    //2

/*
String类型
EMCAScript中的字符串是不可变的,字符串一旦创建它们的值就不能改变。
要改变某个变量保存的字符串,首先要销毁原来的字符串,然后再用一个包含新值得字符串填充该变量
*/

var lang = "Java";
lang = lang + "Script";    //先创建一个字符串用"JavaScipt填充",再销毁原来的Java和Script字符串

//Boolean,Number,String,Object类型都有toString()方法,但是null和undefined没有
var t = true;    
alert(t.toString());//true

var num = 16;
alert(num.toString());        //16
alert(num.toString(2));        //10000
alert(num.toString(8));        //20
alert(num.toString(10));    //16
alert(num.toString(16));    //10
num = 10;
alert(num.toString(16));    //a

var str = "23";
alert(str.toString());        //23

var a = new Object("2#");    //2#
alert(a.toString());

/*
String()方法:如果值有toString()方法,则调用该方法;如果值是null则返回null;如果值是undefined则返回undefined
*/
var value1 = 10;
var value2 = true;
var value3 = null;
var value4;

alert(String(value1));    //10
alert(String(value2));    //true
alert(String(value3));    //null
alert(String(value4));    //undefined


/*
Obejct类型
Object的每个实例都有下列属性和方法
constructor:保存着用于创建当前对象的函数
hasOwnProperty(propertyName):用于检查给定的属性当前对象实例中(不是实例的原型)是否存在
isPrototypeOf(object):用于检查传入的对象是否是当前对象的原型
proPertyIsEnumerable(propertyName):用于检查给定的属性是否能使用for-in语句来枚举
toLocaleString():返回对象的字符串表示
toString():返回对象的字符串表示
valueOf():返回对象的字符串,数值或布尔值表示
*/
var o = new Object();    //创建对象
var o = {
    "age" : 13
}

//给对象添加属性
o.name = "libra";
o.money = "100";

//访问属性
alert(o.age);        //13
alert(o.name);        //libra
alert(o["name"]);    //100


//检测类型
var str = "Nicholas";
var bool = true;
var int = 22;
var undi;
var nul = null;
var ob = new Object();
var arr = new Array();

//typeof常用来检测基本类型值,也可用来检测引用类型值
alert(typeof str);        //string
alert(typeof bool);        //boolean
alert(typeof int);        //number
alert(typeof undi);        //undifined
alert(typeof nul);        //null
alert(typeof ob);        //object
alert(typeof arr);        //object

/*
instanceof 常用来检测引用类型值
*/
//注意:所有引用类型值为Object实例,所以始终会返回true,但是基本类型不是对象,则返回false;
alert(ob instanceof Object);        //true
alert(str instanceof Object);        //false
alert(arr instanceof Object);        //true
alert(arr instanceof Array);        //true

 

js操作符

js有9种操作符:一元操作符,位操作符,布尔操作符,乘性操作符,加性操作符,关系操作符,相等操作符,条件操作符,赋值操作符

/*
一元操作符:+, -, ++, --
+, -, ++, --可以作用于任何值
*/
var age = 10;
alert(age++);    //10,下一个age是11
alert(++age);    //执行++后为12
alert(age--);    //12,下一个age是11
alert(age);        //11
alert(--age);    //执行--后为10
alert(age + 10);    //20
alert(age - 10);    //0

//连接符
alert("我有" + age + "岁了!");    //我有10岁了!


/*
位操作符:~, &, |, ^, <<, >>, >>>
若对非数值应用位操作符,会先使用Number()函数将该值转换为一个数值(自动完成),然后再应用位操作。
*/

//按位非~:操作数的负数减一
alert(~1);            //-2
alert(~"1");        //-2
//按位与&:对应的二进制数进行逻辑与操作,返回1或0
alert(25 & 3);        //1
//按位与|:对应的二进制数进行逻辑或操作,返回1或0
alert(25 | 35);        //59
//按位与^:对应的二进制数进行逻辑异或操作,返回1或0
alert(25^3);        //26
//左移:二进制数左移n位,空位用0填充;a << n = a * 2^n;
alert(2 << 3);        //16
//有符号右移:二进制数右移n位,空位用符号位填充
alert(25 >> 3);        //3
//无符号右移对于正数,和有符号右移一样
alert(64 >>> 5);    //2
//无符号右移对于负数,二进制数右移n位,空位用0填充
alert(-64 >>> 5);    //134217726


/*
布尔操作符:!, &&, ||
&&, || 为短操作,即若是第一个操作数能决定结果则不会对第二个操作数求值
可以应用于任何类型的操作数,返回布尔值true或false或操作数
*/
//1.若操作数是一个对象则返回false
alert(!new Object(2));    //false
//2.若操作数是空字符串则返回true
alert(!"");                //true
//3.若操作数是任何非空字符串则返回false
alert(!"@#4");            //false
//4.若操作数是数值0则返回true
alert(!0);                //true
//5.若操作数是任何非零数值(包括无穷)则返回false
alert(!12);                //false
alert(!Infinity);        //false
//6.若操作数是null,NaN,undefined则返回true
alert(!null);            //true
alert(!NaN);            //true
alert(!undefined);        //true

//对于逻辑与操作,若第一个操作数为false则结果为false
//1.若第一个操作数为对象则返回第二个操作数
alert(new Object("23") && "34");//34
//2.若第二个操作数为对象,则当第一个操作数为true时返回该对象
alert(true && new Object(2));    //2
alert(false && new Object(2));    //false
//3.//若两个操作数都为对象则返回第二个操作数
alert(new Object("23") && new Object(2));    //2
//4.若有一个操作数是null则返回null
alert(null && 2);                //null
alert(2 && null);                //null
//5.若有一个操作数是NaN则返回NaN
alert(NaN && 2);                //NaN
alert(2 && NaN);                //NaN
//6.若有一个操作数是undefined则返回undefined
alert(undefined && 2);            //undefined
alert(2 && undefined);            //undefined
//7.任何数值(包括Infinity)为true
alert(0 && 3);

//对于逻辑或操作,若第一个操作数为true则结果为true
//1.若第一个操作数是对象则返回该对象
alert(new Object(2) || false);    //2
//2.若第二个操作数是对象,则当第一个操作数为false时返回该对象
alert(false || new Object(2));    //2
//3.若两个操作数是对象,则返回第一个操作数
alert(new Object(33) || new Object(3));//33
//4.若两个操作数是null, NaN, Undefined,当操作数一样时则返回它们本身,不一样是返回第二个操作数
alert(null || null);            //null
alert(NaN || NaN);                //NaN
alert(undefined || undefined);    //undefined
alert(NaN || undefined);        //undefined


/*
乘性操作符:*, /, %
*/
//乘法:*
//1.若操作数都是数值则返回数值,若数值范围超过了ECMAScript的表示范围则返回Infinity和-Infinity
alert(2 * 3.3);            //6.6
alert(2 * Number.MAX_VALUE);//Infinity
//2.任何NaN的操作返回NaN
alert(2 * NaN);            //NaN
//3.Infinity * 0 返回NaN
alert(Infinity * 0);    //NaN
//4.Infinity乘以非零数值则返回Infinity或者-Infinity
alert(Infinity * 2);    //Infinity
alert(Infinity * -2);    //-Infinity
alert(Infinity * Infinity);        //Infinity
alert(Infinity * -Infinity);    //-Infinity
//5.若有操作数不是数值,则后台调用Number()方法转换,在应用上述规则
alert(2 * "2");            //4
alert(2 * "2#");        //NaN, 应为"2#"用Number()转换后为NaN


//除法:/
//1.若操作数都是数值则返回数值,若数值范围超过了ECMAScript的表示范围则返回Infinity和-Infinity
alert(2 / 2);            //1
alert(2 / Number.MIN_VALUE);//Infinity
//2.任何NaN操作都返回NaN
alert(2 / NaN);            //NaN
//3.Infinity / Infinity返回NaN
alert(Infinity / Infinity);    //NaN
//4. 0 / 0 返回NaN
alert(0 / 0);            //NaN
//5.非零有限数被零除则返回Infinity或-Infinity
alert(0 / 23);            //0
alert(23 / 0);            //Infinity
//6.Infinity被任何非零数值除,则返回Infinity或-Infinity
alert(Infinity / 4);    //Infinity
alert(4 / Infinity);    //0
//7.若有操作数不是数值,则后台调用Number()方法转换,在应用上述规则
alert(2 / "2");            //1
alert(2 / "2#");        //NaN, 应为"2#"用Number()转换后为NaN



//求模:%
//1.若操作数是数值则按常规计算
alert(5 % 12);            //2
//2.被除数是无穷,除数是有限数值则返回NaN
alert(Infinity % 2);    //NaN
alert(-Infinity % 2);    //NaN
//3.若被除数是有限数值, 除数是无穷则返回被除数
alert(2 % Infinity);    //2
//4.若被除数是有限数值,除数是零则返回NaN
alert(2 % 0);            //NaN
//5.若被除数和除数都是Infinity则返回NaN
alert(Infinity % Infinity);    //NaN
//6.若被除数是0则结果是0
alert(0 % 32);            //0
//7.若有操作数不是数值,则后台调用Number()方法转换,在应用上述规则
alert(2 % "2");            //0
alert(2 % "2#");        //NaN, 应为"2#"用Number()转换后为NaN


/*
加性操作符:+, -
*/
//加法+
//1.任何NaN操作返回NaN
alert(1 + NaN);                //NaN
//2.Infinity + Infinity = Infinitu;Infinity - Infinity = NaN;
alert(Infinity + Infinity);    //Infinity
alert(Infinity + -Infinity);    //NaN
alert(-Infinity + -Infinity);    //-Infinity, -(Infinity + Infinity)
//3. 0 + 0 = 0; 0 - 0 = 0;
alert((+0) + (+0));            //+0, +(0 + 0)
alert((+0) + (-0));            //+0, +(0 - 0)
alert((-0) + (-0));            //-0, -(0 + 0)
//4.若操作数中有字符串,则+就是连接符,则调用toString(), 或String()方法将操作数变成字符串再进行拼接
alert("##" + 23);            //"##23"
alert(null + "3");            //"null3"


//减法-
//1.任何NaN操作返回NaN
alert(1 - NaN);                    //NaN
//2.Infinity + Infinity = Infinitu;Infinity - Infinity = NaN;
alert(Infinity - Infinity);        //NaN
alert(Infinity - -Infinity);    //Infinity, Infinity + Infinity
alert(-Infinity - Infinity);    //-Infinity, -(Infinity + Infinity)
//3. 0 + 0 = 0; 0 - 0 = 0;
alert((+0) - (+0));                //+0, +(0 - 0)
alert((+0) - (-0));                //+0, +(0 + 0)
alert((-0) - (-0));                //-0, -(0 - 0)
//4.若操作数中有字符串,则+就是连接符,则调用toString(), 或String()方等法将操作数变成字符串再进行拼接
alert("##" - 23);                //NaN, "##"转换后为NaN
alert(null - "3");                //-3,
alert(3 - null);                //3
alert(undefined - "3");            //NaN
alert(3 - undefined);            //NaN


/*
关系操作符:>, <, <=, >= 返回true或false
*/
//若两个操作数是数值,则执行数值比较
alert(2 >= 3);//false
//如果两个操作数是字符串,则比较两个字符串对应的字符编码值
alert("a" > "3");//true
//若有操作数不是数值,则将其转换为字符串进行比较
alert(2 < "3");//true
//若操作数是对象则调用valueOf(),toString()等方法转换后进行比较
alert(new Object("2") >= 3);//false
//若操作数是布尔值则先将其转换为数值再执行比较
alert(true >= false);//true


/*
相等操作符:==, !=, ===, !==
==, !=:先转换再比较
===, !==:仅比较不转换
*/
alert(true == 1);                //true
alert(false == 0);                //true
alert(true == 2);                //false
alert(false == -1);                //false
alert("23" == "23");            //true
alert(new Object(2) == "2");    //true
alert(null == undefined);    //true
alert(null == 0);            //false
alert(undefined == 0);        //false
alert(NaN != NaN);            //true

alert("2" == 2);    //true, 先将"2"转换为数值2在比较
alert("2" === 2);    //false,直接进行比较
alert("2" !== 2);    //true


/*
条件操作符: expression ? result1 : result2;
*/
var num = 1 > 2 ? 3 : 4;
alert(num);            //4, 1 > 2 为假
num = 1 < 2 ? 3 : 4;
alert(num);            //3, 1 < 2 为真



/*
赋值和计算
*/
var num1, num2;
num1 = num2 = 2;
alert(num1 *= num2);//4
num1 = num2 = 2;
alert(num1 /= num2);//1
num1 = num2 = 2;
alert(num1 %= num2);//0
num1 = num2 = 2;
alert(num1 += num2);//4
num1 = num2 = 2;
alert(num1 -= num2);//0
num1 = num2 = 2;
alert(num1 <<= num2);//8
num1 = num2 = 2;
alert(num1 >>= num2);//0
num1 = num2 = 2;
alert(num1 >>>=num2);//0

 

勿删,copyright占位
分享文章到微博
分享文章到朋友圈

上一篇:gc 垃圾收集器(视频文字)

下一篇:vscode支持matlab 完全小白

您可能感兴趣

  • 前端实习生面试题分析(一)

    最近面试拿了很多公司的实习offer,只要是面试的都通过了。 接下来就分析下面试题,也能给自己一个提升吧,以便后续的面试更轻车熟路些,题目没什么顺序,想起什么写什么,还有我面试过程中的一些小套路。 估计要写好多,每天写几道题,而且有些经验性的东西也不容易写出来 这篇写的都是类似一些概念性的理论东西。 1.JS防抖和节流 先说为什么要做防抖和节流,针对一些会频繁触发的事件,像scroll、re...

  • Web前端常见跨域解决方案

    一、通过Jsonp跨域 二、document.domain+iframe 跨域 三、location.hash+iframe 跨域 四、window.name+iframe 跨域 五、postMessage 跨域 六、跨域共享资源 (CORS) 七、nginx 代理跨域 八、node js中间件代理跨域 九、WebSocket 协议跨域 1、通过Jsonp跨域: 通常为了减轻Web服务器的负...

  • 工作流学习2(书本)

    1、流程引擎的创建。 1.1、ProcessEngineConfiguration的buildProcessEngine方法 使用ProcessEngineConfiguration的create方法可以得到ProcessEngineConfiguration的实例。ProcessEngineConfiguration中提供了一个buildProcessEngine方法,该方法返回一个Pro...

  • Yolo系列详解

    零、图像基本概念 图像表示为二维的矩阵  灰阶图像 0-255,0表示黑色,255表示白色,其余表示灰色。 图像的坐标轴   彩色图像  注意:颜色信息对于任务有时候有用,有时候没用。 一、什么是目标检测 目标检测是计算机视觉中的经典的原子问题,即通过输入的图像来完成物体的检测,它需要解决两个问题: 物体在哪里 物体是什么 目标检测算法的传统实现 sift hog 等算法。这些算法的...

  • C++基础知识(四)-友元和运算符重载

    整理码字不易,养成好习惯,点赞关注,你的支持就是我写下去的动力,谢谢老板。 本文为C++第三篇后续接着这篇文章写,大家可以持续关注,前三篇在主页 4.5 友元 类的主要特点之一是数据隐藏,即类的私有成员无法在类的外部(作用域之外)访问。但是,有时候需要在类的外部访问类的私有成员,怎么办? 解决方法是使用友元函数,友元函数是一种特权函数,c++允许这个特权函数访问私有成员。这一点从现实生活中也...

  • 盘一盘 Python 特别篇 20 - SciPy 稀疏矩阵

    本文含 6057 字,13 图表截屏 建议阅读 32 分钟 本文是 Python 系列的特别篇的第二十篇 特别篇 1 - PyEcharts TreeMap 特别篇 2 - 面向对象编程 特别篇 3 - 两大利「器」 特别篇 4 - 装饰器 特别篇 5 - Sklearn 0.22 特别篇 6 - Jupyter Notebook 特别篇 7 - 格式化字符串 特别篇 8 - 正则表达式 特...

  • python学习001

    前言: 1、运维/网络为什么要学习编程? (1)运维/网络中所有已学的命令其实都是已经编制好的程序,创造命令就是编写程序; (2)在云计算领域中,繁琐的命令配置已经不能满足日常需求,深入发展是需要贴近业务/研发的,因此就要能够创造命令/编写程序/开发; (3)网络安全领域中,可以深入理解渗透、攻防等细节,Kali-Linux ,SDN(命令对应网络)夯实技术; (4)对于校招而言,大型互联网...

  • 论文|从DSSM语义匹配到Google的双塔深度模型召回和广告场景中的双塔模型思考...

    点击标题下「搜索与推荐Wiki」可快速关注 ▼ 相关推荐 ▼ 1、基于DNN的推荐算法介绍 2、传统机器学习和前沿深度学习推荐模型演化关系 3、论文|AGREE-基于注意力机制的群组推荐(附代码) 4、论文|被“玩烂”了的协同过滤加上神经网络怎么搞? 本文包含(文章较长,建议先收藏再阅读,点击文末的阅读原文,查看更多推荐相关文章): DSSM DSSM的变种 MV-DNN Google Tw...

华为云40多款云服务产品0元试用活动

免费套餐,马上领取!
CSDN

CSDN

中国开发者社区CSDN (Chinese Software Developer Network) 创立于1999年,致力为中国开发者提供知识传播、在线学习、职业发展等全生命周期服务。