js（数据类型）

数据类型

基本数据类型：Number，String，Boolean，Null，Undefined;

复杂数据类型(引用类型)：Object；

Number:

类型:  整数，浮点数;

浮点数特性：

•   该数值后面必须有小数，不然转化为整数。
•   极大极小浮点数-> e表示法；
•   计算时容易丢失精度：  var num = 0k.1 + 0.2;console.log(num) => 0.30000000000000004;
•    toFixed() 精确到小数点几位；

NaN:

• 任何涉及NaN的操作就会返回NaN;
• NaN与任何值都不相等，包括其本身；
• isNaN函数涉及类型转换：相当于Number() isNaN('2') -> false;

数值转换：

• Number -> 可以将string类型转换成number类型；
• parseInt -> 可以将string类型转换成number整数类型 + 将（数字+非数字）的string（数字必须在前）中的数字提取出来；
• parseFloat->可以将string类型转换成number浮点数类型 + 将（数字+非数字）的string（数字必须在前）中的数字提取出来；

String

单引号与双引号 -> 拼接字符串时html属性要使用双引号与单引号区分开；

字符串有length属性；

类型转换：

 toString():

• 几乎每个值都有toString()方法；
• null,undefined没有undefined；
• 数值 + ' ' 转化为String ；
• 对象的返回值加引号返回字符；
• 对数值使用时可以加参数 var num = 10; num.toString(2) -> '1010';

String():

• 可以对任何值进行转换，包括null与undefined;

Number与String相互转换：

Number -> String

toString()；String()；+ ' ' 操作；

String -> Number

Number()；parseInt()；parseFloat()；

数字与字符串的相加操作 -> 执行字符串的拼接规则；

Boolean

只有两个值：true,false;

类型转换：

• 使用Boolean()方法；
• 一些转换布尔值的地方：
  • if语句  if('sha') ，if([])，if({}) 都会转换成true；
  • &&、|| 的使用
    • &&的优先级更高；
    • computed && clearInterval(timer);
    • cur == iTarget || (bComplete = false,elem.style[attr] = cur + speed + 'px')

null,undefined

null与undefined的区别：

• null:表示没有对象，即该出不应该有值；
  • 作为函数的参数，表示该参数不能为对象；
  • 对象原型链的终点；
  • 空对象指针；
  • isNaN(null) -> false；
• undefined表示缺少值，就是此处该有一个值，但是没有定义。
  • 变量声明了，但是没赋值 var a; -> undefined；
  • 调换函数的时，应该传递的的参数没有提供 function do(){ console.log(name)} undefined；
  • 没有返回值的函数；
  • 对象没有赋值的属性 var obj = {a:'2'}; console.log(obj.b)；
  • isNaN(undefined) -> true；

== 与 === ：

== 会进行类型转换，===不会；

obj.a == null => obj.a === null || obj.a === undefined

Object

array,function 都是从object继承的

array,null的typeof都为object

创建的方式：字面量、函数的返回值、构造函数、Oject.create();

hasOwnProperty() : 判断属性是否存在与实例对象中；

Array:

相关操作：pop,push,shift,unshift,concat,splice,slice,sort,reverse,join;

不改变数组的操作：slice,concat,join;

• slice，splice
  • slice(start,end)
    • 前闭后开；支持负数；产生新数组；
  • splice(start,length;newItem)
    • 支持负数；改变原数组；
• slice,subString,substr
  • slice(start,end)
    • 前小后大，前闭后开；支持负数；产生新Strging;
  • subString(a,b)
    • 较小为start,较大为end；不支持负数，直接转0；
  • substr(start,length)
    • 支持负数
  • 相同点：都不会改变原字符串；

类数组转换成数组：

   Array.prototype.slice.call(arguments);

string与array转换：

• join：Array to String
• split：String to Array
  • 用法：

    function getUrl(str){
    	var search = str.split('?')[1];
    	var obj = {};
    	var searchArr = search.split('&');
    	for(var i =0;i<searchArr.length;i++){
            var key = searchArr[i].split('=')[0];
    		var value = searchArr[i].split('=')[1];
    		obj[key] = value;
        }
    	return obj;
    }

     

拷贝：

slice,concat       数组浅复制；

Object.assign() 对象浅复制；

JSON.parse(JSON.stringify) 对象浅复制；

• JSON.stringify(..) 在对象中遇到 undefined、function 和 symbol 时会自动将其忽略，在数组中则会返回 null(以保证单元位置不变)。

function deepClone(obj){
    var o;
    if(typeof obj === 'object'){
        o = obj instanceof Array?[]:Object.create();
        for(var key in obj){
            obj.hasOwnProperty(key) && (o[key] = deepClone(obj[key]))
        }
    }else{
        o = obj;
    }
    return o;
}

相关知识点：

js按照存储类型分为哪几类，描述其特点。

值类型：number，string，boolean，null，undefined;

引用类型：array，function，object;

特点：

• 值类型不会因为相互引用而互相干扰；
• 引用类型会因为相互引用而相互干扰；

判断数据类型：

1. js中使用typeof能得到那些类型？ -> number,string,boolean,null,undefined,object;
2. 如何准确判断一个变量是数组类型：
   1. instanceof Array
   2. Object.prototype.toString().call().slice(8,-1).toLowerCase()
   3. es6 isArray

描述new 对象的过程

• 创建一个新对象；
• this指向这个新对象；
• 执行函数；
• 返回this；

js中有哪些内置对象：

Number,String,Boolean,Object,Array,Function,Date,Error,RegExp;

数组去重：

• 不开辟新的内存空间去重：

Array.prototype.unique = function(){
    for(var i=0;i<this.length;i++){
        this.indexOf(this[i]) != i && (this.splice(i,1),i--)
    }
    retrun this;
}

Array.prototype.unique = function(){
    this.sort();
    for(var i=0;i<this.length;i++){
        this[i] === this[i+1] && (this.splice(i,1),i--)
    }
    return this;
}

• 开辟新空间

Array.prototype.unique = function(){
    var arr = [];
    for(var i=0;i<this.length;i++){
        arr.indexOf(this[i]) == -1 && (arr.push(this[i]))
    }
    return arr;
}

Array.prototype.unique = function(){
    this.sort();
    var arr = [];
    for(var i=0;i<this.length;i++){
        arr[arr.length-1] !== this[i] && (arr.push(this[i]))
    }
    return arr;
}

Array.prototype.unique = function(){
    this.sort();
    var arr = [];
    for(var i=0;i<this.length;i++){
        arr[arr.length-1] !== this[i] && (arr.push(this[i]))
    }
    return arr;
}

Filter

Arr.filter(function(item,index,array){
    return index === array.indexOf(item);
})