JavaScript数据类型

2021/3/11 00:42:48admin0 阅读0 评论

JavaScript是一门弱语言，不像C或者Java等那种强类型语言，用一个变量，还要先定义数据类型，定义成了int整型，就不能放字符串进去。

JavaScript定义的变量，就是你先放了数字进去，它就变成了数字类型，后面改放了字符串进去，也就变了字符串类型。

所以，在进行一些运算的时候，虽然灵活，但也会出毛病，这也是它的弱点。

<h2>JS中的数据类型：</h2>

Number
String
Boolean
undefined
Symbol
Object
null
function

除了基本类型以外（Number，String，Boolean，undefined ，Symbol ）
其他的都是对象（Object，null，function）

<pre class=“language-javascript line-numbers”><code class=“language-javascript”>
var numa = 18; // number 数字类型
var stra = ‘abc’; // string 字符串
var boola = true; // boolean 布尔值，两个值 true false
var a ; // undefined 未定义
var sya = Symbol (); //Symbol 类型
var b = document // object 对象
var c = null // object 对象(空对象)
var funa = function(){} // function 函数
</code></pre>

<h2>获取检测变量的数据类型:</h2>

<code>typeof</code>可用来获取检测变量的数据类型,它是一个关键字，不是函数

用<code>typeof</code>运算符查看它们的数据类型：不同类型的返回值：<code>number</code>、<code>string</code>、<code>boolean</code>、<code>function</code>、<code>undefined</code>、<code>symbol</code>、<code>object</code>

<pre class=“language-javascript line-numbers”><code class=“language-javascript”>
typeof 18 -> number
typeof “abc” -> string
typeof true -> boolean
typeof undefined -> undefined
typeof null -> object //返回的是Object类型
</code></pre>

字面量：通俗来说，就是字面量表示如何表达这个值。123、“abc”、true
变量：容器，存储的值可以变的存东西，可以改
常量：容器，存储的值是不可变的存东西，不可改

<h2>数据类型转换</h2>
通俗来说，就是把一种数据类型的变量转换成另一种数据类型

<h3>显式类型转换（强制）：</h3>
转换为数字型 <code>Number() </code>
<code>Number() </code>注：首字母大写
<ul>
<li>Number(val) 将数据转换成数字</li>
<li>- 字符串类型，使用 Number() 转换时，规则如下：</li>
<ol>
<li>1.当整段字符串都符合数字规则时，转换为数字返回</li>
<li>2.空字符串,直接返回 0</li>
<li>3.其余情况，直接返回 NaN</li>
</ol>
<li>- 布尔值类型，使用 Number() 转换时，true 返回 1，false 返回 0</li>
<li>- null，使用 Number() 转换时返回 0</li>
<li>- undefined，使用 Number() 转换时返回 NaN</li>
<li>- 对象类型，使用 Number() 转换时，调用的对象的toString()方法，然后再次依照前面字符串的转换规则进行转换</li>
</ul>

<pre class=“language-javascript line-numbers”><code class=“language-javascript”>
console.log(Number(‘12’));
// console.log(Number(‘12’)); ==> 12

// Number它只能转行纯数字的字符串否则返回NaN
var num = ‘123.4a’;
console.log(typeof num) // string

var num2 = Number(num);
console.log(num2) //NaN
console.log(typeof num2) //number
</code></pre>

转换为字符串类型 <code>String()</code>

数字类型，直接转换数据类型原样返回
undefined ，直接返回字符串 undefined
null，直接返回字符串 null
布尔值，直接返回字符串 true 或者 false
函数，直接把整个函数变成字符串返回
对象，直接调用对象的 toString 方法

<pre class=“language-javascript line-numbers”><code class=“language-javascript”>
var num = 123;
var nud = undefined ;
var nul = null ;
var bool = true ;
var fn = function(){} ;
var obj = {a:12} ;

    console.log(String(num))   // 123
    console.log(String(nud))   // undefined
    console.log(String(nul))   // null 
    console.log(String(bool))  // true 
    console.log(String(fn))    // function (){}
    console.log(String(obj))   // toString([object Object])

</code></pre>

转换为布尔型 <code>Boolean()</code>

数字类型：非零的合法数字转换为 true, 零代表 false, NaN 代表 false
字符串类型：空字符串转换为false，非空字符串转换为true
null：转换为false
对象：转换为true
<pre class=“language-javascript line-numbers”><code class=“language-javascript”>

var str = ’ ';
var num = -0.1;
var arr = [];
var nul = null;

console.log(Boolean(num)); // true
console.log(Boolean(str)); // true
console.log(‘arr’,Boolean(arr)); //arr true
console.log(‘null’,Boolean(nul)); arr true

if(12){
console.log(‘真’);
}else{
console.log(‘假’);
}

// 什么是真（true），什么是假（ false） – 有东西就是真，没东西就是假
// 真（true）：非零(正负数)、非空字符串、非空对象
// 假（ false）：零、空字符串、空对象（ 0、‘’、null、undefined ）
</code></pre>

<h3>隐式类型转换（能不用就尽量别用）：</h3>
这是存在一定风险的（出现一些小问题什么的），虽然是比较方便的方法，
但如果想要代码严谨一点，不要依赖隐式转换，而是要消除所有存在的隐式转换。
如果是长期使用的，比如一个库什么的，这时就要避免所有存在的隐式操作了，

//变字符串

- / % // 变数字
  == === // 转成布尔值

var a=‘12’;
var b=‘3’;

// + 号有两重含义，数字相加和字符串连接
console.log(a+b);
// ‘12’ + ‘3’ ==> ‘123’ 变字符串

// - 号就只是存在于数字相减，不存在字符串相减，所以变数字
console.log(a-b);
// ‘12’ - ‘3’ ==> 9 变数字

//-----------------------------

var a=12;
var b=‘12’;

// == 带有隐式转换，会先转换成一样的类型再进行比较
console.log(a==b);
// a==b ==> true

// === 直接比较
console.log(a===b);
// a===b ==> false
</code></pre>

<h3>NaN 和 isNaN</h3>

在使用 NaN 时，要注意 NaN是个特殊的数字，它不等于任何值（包括它自己），也就是 NaN 不等于 NaN。

当我们要检测一条数据是否是 NaN 时，可以使用 isNaN(val) 来进行检测, 在 isNaN 方法中，传入的数据能被转换成合法数字时，就会返回 false，当传入的数据不能被转换成合法数字( 也就是NaN) 时，isNaN 就会返回 true

var str = ‘123.a’;

console.log(str) // 123.a
console.log(isNaN(Number(str))) // true
// isNaN 是一个NaN 返回 true 、反之就是false

var a = NaN;
if(a == NaN){
console.log(‘等于’) // NaN 不等于NaN
}

</code></pre>

<h3>1.三种转换成字符串的方式</h3>

<code>toString()</code> 和 <code>String()</code> 一般情况下没什么大的区别,用谁都行。唯一不同的是<code>toString()</code>本质上是一个方法，当用在某些特殊的值上时区别就出来了

<code>String()</code> 转换成字符串

<code>toString()</code>转换成字符串

<code>+‘’</code>和字符串拼接的结果都是字符串(隐式转换了)

<pre class=“language-javascript line-numbers”><code class=“language-javascript”>
var a=12;
console.log(a,String()); // 12 “”
console.log(a,a.toString()); //12 “12”
console.log(a,a+‘’); // 12 “12”
// a+‘’ ==> String(a)+‘’ ==> “12”
</code></pre>

<h3>2.转换成数字</h3>
<code>parseInt</code>将string类型转换成整数

<code>parseFloat</code>将string类型转换成浮点数（小数）

<code>注意大小写</code>

<pre class=“language-javascript line-numbers”><code class=“language-javascript”>
// 取整
var num = parseInt(12.345);
console.log(num) //12

// 获取浮点数（保留小数） - 将字符串转成数字
var num = ‘123.4’;
console.log(typeof num) //string

var num2 = parseFloat(num);
console.log(num2) //123.4
console.log(typeof num2) //number

</code></pre>