js整理1

数组

• 比较时的隐式转化

var a = [1,2,3];
var b = [1,2,3];

a == b; //false
a == '1,2,3'; //true;

//
var c = [];
Boolean(c); //true
c == false; //true
c == 0; //true
c == ''; //true
c == undefined; //false

• 类数组

var arr = Array.prototype.slice.call( arguments );
//es6
var arr = Array.from( arguments );

• 字符串使用数组方法

var a = "foo";

var c = Array.prototype.join.call( a, "-" );
var d = Array.prototype.map.call( a, function(v){
    return v.toUpperCase() + ".";
} ).join( "" );

c;              // "f-o-o"
d;              // "F.O.O."

//
var c = Array.prototype.reverse.call( a ); //error

var c = a.split( "" ).reverse().join( "" );

• 关于undefined

var a = [ undefined, undefined, undefined ];  //[ undefined, undefined, undefined ] 
var b = new Array( 3 );  //[ undefined x 3 ]
var c = [];
c.length = 3;  //[ undefined x 3 ]
var d = [ , , , ];  //[ undefined x 3 ]


a.join( "-" ); // "--"
b.join( "-" ); // "--"


a.map(function(v,i){ return i; }); // [ 0, 1, 2 ]
b.map(function(v,i){ return i; }); // [ undefined x 3 ]

//确实想要表示多个空值而不是不存在；
var a = Array.apply( null, { length: 4 } );
a; // [ undefined, undefined, undefined ,undefined]

数值

• 浮点数精确度

0.1 + 0.2 === 0.3; // false

//

if (!Number.EPSILON) { //es6
    Number.EPSILON = Math.pow(2,-52);
}
function numbersCloseEnoughToEqual(n1,n2) {
    return Math.abs( n1 - n2 ) < Number.EPSILON;
}

var a = 0.1 + 0.2;
var b = 0.3;

numbersCloseEnoughToEqual( a, b );                  // true
numbersCloseEnoughToEqual( 0.0000001, 0.0000002 );  // false

• 判断正负0

function isNegZero(n) {
    n = Number( n );
    return (n === 0) && (1 / n === -Infinity);
}

• 数值化(Number)
  • 对于原始类型: false//0, true//1, null//0, 数值字符串//数值, 其他//NaN;
  • 对于其他类型: 调用其valueOf, toString，对返回的原始类型进行操作；否则报错;

Number( "" );           // 0
Number( [] );           // 0

• 小心使用parseInt, 它也会调用内部的toString方法;

parseInt( 1/0, 19 ); =>parseInt( "Infinity", 19 ) => parseInt( "I", 19 ) // 18;

parseInt( 0.000008 );       // 0   ("0" from "0.000008")
parseInt( 0.0000008 );      // 8   ("8" from "8e-7")
parseInt( false, 16 );      // 250 ("fa" from "false")
parseInt( parseInt, 16 );   // 15  ("f" from "function..")

parseInt( "0x10" );         // 16
parseInt( "103", 2 );       // 2

对象

• 对象引用

//引用被切断
function foo(x) {    
    x.push( 4 );
    x; // [1,2,3,4]

    // later
    x = [4,5,6];     //改变arg[x]的引用
    x.push( 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [1,2,3,4]  not  [4,5,6,7]


//引用一直保存
function foo(x) {
    x.push( 4 );
    x; // [1,2,3,4]

    // later
    x.length = 0; // empty existing array in-place
    x.push( 4, 5, 6, 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [4,5,6,7]  not  [1,2,3,4]

//注意特殊对象的隐式转化
function foo(x) {
    x = x + 1;
    x; // 3
}

var a = 2;
var b = new Number( a ); // or equivalently `Object(a)`

foo( b );
console.log( b ); // 2, not 3

void操作符

• 使不返回任何值

//可能用到的情况
function doSomething() {
    // note: `APP.ready` is provided by our application
    if (!APP.ready) {
        // try again later
        return void setTimeout( doSomething, 100 );
    }

    var result;

    // do some other stuff
    return result;
}

等值判断

//es6
Object.is( a,b ); 

不用于严格意义的对比，而是用于特殊例子的比较

var a = 2 / "foo";
var b = -3 * 0;

Object.is( a, NaN );    // true
Object.is( b, -0 );     // true

Object.is( b, 0 );      // false

预定义数值

if(VALUE) {
  console.log('value');
} //error

if(typeof VALUE !== "undefined") {
  console.log('value')
}

//
function () {
 var newValue = (typeof oldValue !== "undefined") ? oldValue : 'newvalue';
 ...
}

function (oldValue) {
 var newValue = oldValue || 'newvalue';
 ...
}

js原生类型

• String()
• Number()
• Boolean()
• Array()
• Object()
• Function()
• RegExp()
• Date()
• Error()
• Symbol() -- added in ES6!

由于所有类型的本源都是来自Object(),使用Object.prototype.toString.call方法可以现在类型内部的[[class]];
格式为[object X] 

• 构建时注意

//Object
var a = new Object();
var b = Object();
var c = new Object;

//Array
var a = new Array();
var b = Array();
var c = new Array;

//Date
var a = new Date(); //[object Date];
var b = Date(); //string
var c = new Date; //[object Date];

• 各个类型的原型都是其相对应类型的空值；//注意不要污染它们；

Array.prototype; //[];
......