06.typeof类型转换

好好学习_fighting

已于 2022-09-16 08:28:37 修改

阅读量92

点赞数 1

分类专栏： js基础文章标签： javascript 前端 typescript

于 2022-08-26 10:35:50 首次发布

本文链接：https://blog.csdn.net/qq_40637729/article/details/126538537

版权

js基础专栏收录该内容

26 篇文章 2 订阅

订阅专栏

typeof类型转换

文章目录

typeof类型转换

六种数据类型

number、string、boolean、undefined、object、function

typeof（）或者写成typeof （空格）  // 把数据放到typeof中能判断数据类型

var num = 123;
console.log(typeof(num));  // 打印number

var num = "123";
console.log(typeof num);  // 打印string

var num = true;
console.log(typeof num);  // 打印boolean

var num = {};  // 空对象(数组和null返回的也是object) null是空对象指针，最早是用来给对象占位
console.log(typeof num);  // 打印object

var num = undefined;
console.log(typeof num);  // 打印undefined

var num = function () {};
console.log(typeof num);  // 打印function

类型转换

1.显式类型转换

// Number(mix)
// parseInt(string,radix)
// parseFloat(string)
// toString(radix)
// String(mix)
// Boolean()

// Number(mix)

var demo = '123';  // 把字符串123转换成数字123，并返回给我们(执行之后类型就是num)
var num = Number(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:123

var demo = true; 
var num = Number(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:1 （true是1 false是0）

var demo = false;  
var num = Number(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:0 （true是1 false是0）

var demo = null;  
var num = Number(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:0 

var demo = undefined;  
var num = Number(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:NaN 数字类型

var demo = "a";  
var num = Number(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:NaN 数字类型

var demo = "-123";  
var num = Number(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:-123 数字类型

var demo = "123abc";  
var num = Number(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:123abc 数字类型

// parseInt(string,radix)   转换成整型的数  radix是进制(范围：2 - 36)
// 关注点是把字符串转换成数  把浮点数转换成整型 所以不会关注true false null等
var demo = '123';  
var num = parseInt(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:123

var demo = true;
var num = parseInt(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:NaN

var demo = false;  
var num = parseInt(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:NaN

var demo = null;  
var num = parseInt(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:NaN

var demo = 123.9;  // 转换为整型
var num = parseInt(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:123

var demo = "123.9";  // 转换为整型
var num = parseInt(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:123

var demo = "10";  // 转换成16进制是16  0*16º+1*16¹=16
var num = parseInt(demo,16);  // 这里写16就会认为10是十六进制数，也可以改成其他进制
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:16

// parseInt是从数字位开始看，看到非数字位砍断 然后返回（所以小数点不是数字直接砍断）。
var demo = "123abc";  // 转换为整型
var num = parseInt(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 number:123

// parseFloat(string)  从数字位开始看 看到包括点的非数字位（小数点后的数字也算）
var demo = "100.2";  // 转换为浮点型
var num = parseFloat(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为Number：100.2

// toString(radix)   想把谁转换成字符串谁就用toString
// undefined 和 null不能用toString方法
var demo = 10;  
var num = demo.toString(8);  // 括号里的8表示目标进制  也就是把10转化为8进制
console.log(typeof(num) + " : " + demo);  // 打印结果为 String:12

var demo = 123;  
var num = demo.toString();  // 转换为字符串
console.log(typeof(num) + " : " + demo);  // 打印结果为 String:123

// 二进制10101010转化成十六进制 (先转成十进制再转成十六进制)
var num = 10101010;
var test = parseInt(num,2);   // 这里的2就表示num是二进制数 转化成十进制之后赋值test
console.log(test.toString(16));

// String(mix)
var demo = 123.234;  // 转换为字符串
var num = String(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 String:123.234

var demo = undefined;  // 转换为字符串
var num = String(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 String:undefined

// Boolean()    把值转换成布尔值
var demo = undefined;  // 转换为字符串
var num = Boolean(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 boolean:false

// Boolean()    把值转换成布尔值
var demo = 1;  // 转换为字符串
var num = Boolean(demo);
console.log(typeof(num) + " : " + demo);  // 打印结果为 boolean:true

2.隐式类型转换

// 显式就是明摆着告诉你  隐式就是含蓄一点  比如看了十年才觉得谁谁谁很帅

// 隐式类型转换内部都是调用显式类型的方法
// isNaN()
// ++/-— +/- (一元正负)
// +
// -*/%   -- > Number
// && || !
// < > <= >=
// == !=

// isNaN()  把数放到括号中会判断数是否NaN

console.log(isNaN(NaN));  // 打印结果是true
console.log(isNaN("1234"));  // 打印结果是false
console.log(isNaN("abc"));  // 打印结果是true

// 内部执行过程 把括号中的变量拿到number中转换 转化的结果再拿去和NaN比对
isNaN("abc") // 隐式转换
Number("abc")-- > NaN  // 字符串转换成Number是NaN

console.log(isNaN(null));
Number(null) -- > 0 // 打印结果是false

console.log(isNaN(undefined));
Number(undefined) -- > NaN // 打印结果是true

// ++/-— +/- (一元正负)
var a = "123";
Number(a) -- > 123 
a ++;  // 还没运算之前会把变量转换 转换成数字 所以字符串也能加

var a = "abc";
Number(a) -- > NaN  // "abc"转换成Number就是NaN
a ++;  // NaN(数字类型)

var a = "abc";
+ a;
- a;

var a = +"abc";
console.log(a + " : " + typeof(a));  // 打印NaN（数字类型）

// +
var a = "a" + 1;  // 当+两侧有一个字符串 就会把两个都变成字符串
console.log(a +" : " + typeof(a));  //打印a1:String（数字类型）

// -*/%
var a = "1" * 1;  // 字符串转换成数字
console.log(a +" : " + typeof(a));  //打印1:number（数字类型）

var a = "a" * 1;  // a转换成字符串是NaN
console.log(a +" : " + typeof(a));  //打印NaN:number（数字类型）

// && || !
var a = "a" && 1;  // a转换成数字是NaN 
console.log(a +" : " + typeof(a));  //打印1:number（数字类型）

var a = "a" || 1;  // 没有进行数值转换 直接进行判断
console.log(a +" : " + typeof(a));  //打印a:string

// < > <= >=
var a = 1 > "2";  // "2"转化为数字
console.log(a +" : " + typeof(a));  //打印false:boolean

var a = "3" > "2";  // 字符串和数字比就会转化成数字  字符串和字符串比就会比较ASCII值
console.log(a +" : " + typeof(a));  //打印true:boolean

// == !=
var a = 1 == "2";  // "2"转化为数字
console.log(a +" : " + typeof(a));  //打印false:boolean

var a = 1 != true;  
console.log(a +" : " + typeof(a));  //打印false:boolean

2 > 3 < 1  // 打印结果是true
// 2 > 3 是false false转化成数字是0 0 < 1正确

10 > 100 > 0  // 10>100是false false是0 0=0 所以是false
100 > 10 > 0  // 100>10是true true是1 1>0 所以是true
undefined > 0 // false
undefined < 0 // false
undefined == 0 // false

null > 0 // false
null < 0 // false
null == 0 // false

undefined == null  // true

NaN == NaN  // false   NaN不等于任何数 包括他自己  非数

3.不发生类型转换

===   !==   // 不发生类型转换 要长得一模一样
// === 绝对等于   !== 绝对不等于
1 === 1    // true
1 === "1"  // false
1 !== "1"  // true
1 !== 1    // false

NaN === NaN // false  // 自己都不认呐
NaN !== NaN // true

4.作业

// console.log(typeof(typeof(a)));  
// a未定义 第一个typeof返回undefined,第二个typeof返回"undefined"

// alert是一种弹出框
alert(typeof(a));   // undefined(string)
alert(typeof(undefined));   // undefined(string)
alert(typeof(NaN));   // number
alert(typeof(null));   // object
alert(typeof(NaN));   // number

var a = "123abc";   
alert(typeof(+a));   // number
alert(typeof(!!a));   // boolean
alert(typeof(a +""));   // string
alert(1 == "1");   // true
alert(NaN == NaN);   // false
alert(NaN == undefined);   // false
alert("11"+11);   // 1111
alert(1 === "1");   // false
alert(parseInt("123abc"));   // 123  parseInt截断数字(从数字开始遇到非数字的截断)

var num = 123123.345789;
alert(num.toFixed(3));   // 23123.346   toFixed保留三位有效数字 并且四舍五入
typeof(typeof(a));      // "string"