js整理3

函数

call:

fun.call(a)

, a会转化成相应的对象,函数内的

this

即指向它;

function foo() {
console.log(this);
}
foo.call(null); //window
foo.call(undefined); //window

this

函数中this绑定

call-site: 函数的发起方

call-stack: 函数的执行栈

如果函数没有明确的发起方，则其this有一个默认的绑定:全局

在"use strict"模式下，如果函数的执行栈在该模式范围下，不会有默认的this绑定；否则没影响;

隐性地失去绑定:因为真实的call-site不是原引用对象；

function foo() {
console.log( this.a );
}

var obj = {
a: 2,
foo: foo
};

var bar = obj.foo; // function reference/alias!

var a = "oops, global"; // `a` also property on global object

bar(); // "oops, global"

...........
function foo() {
console.log( this.a );
}

function doFoo(fn) {
// `fn` is just another reference to `foo`

fn(); // <-- call-site!
}

var obj = {
a: 2,
foo: foo
};

var a = "oops, global"; // `a` also property on global object

doFoo( obj.foo ); // "oops, global"
setTimeout( obj.foo, 100 ); // "oops, global"  原生自带的也是一样

强行绑定:

call, apply, bind

和其他js内建的高级函数的参数定义上下文

function foo(el) {
console.log( el, this.id );
}

var obj = {
id: "awesome"
};

// use `obj` as `this` for `foo(..)` calls
[1, 2, 3].forEach( foo, obj ); // 1 awesome  2 awesome  3 awesome //第二参数传入

当既有绑定又有

new

操作符的时候

function foo(p1,p2) {
this.val = p1 + p2;
}

// using `null` here because we don't care about
// the `this` hard-binding in this scenario, and
// it will be overridden by the `new` call anyway!
var bar = foo.bind( null, "p1" );

var baz = new bar( "p2" );

baz.val; // p1p2

总结

//有new操作符的时候，this指代newly constructed object;
//有绑定上下文的时候，指代绑定的上下文;
//当是对象方法的时候，指代那个对象
//默认情况下指代全局对象或者undefined(use strict)

属性

括号方式访问对象

属性名都是字符串类型，不是字符串也会强制转化成字符串

var myObject = { };

myObject[true] = "foo";
myObject[3] = "bar";
myObject[myObject] = "baz";

myObject["true"];               // "foo"
myObject["3"];                  // "bar"
myObject["[object Object]"];    // "baz"

给对象添加属性

注意数值字符串会隐式转化为数值

var myArray = [ "foo", 42, "bar" ];

myArray["3"] = "baz";

myArray.length; // 4

myArray[3];     // "baz"

对象复制

简单的方法

var newObj = Object.create(someObj );
var newObj = JSON.parse(JSON.stringify( someObj));

对象枚举

设置对象属性非枚举

var myObject = { };

Object.defineProperty(
myObject,
"a",
{ enumerable: true, value: 2 }
);

Object.defineProperty(
myObject,
"b",
{ enumerable: false, value: 3 }
);

for (var k in myObject) {
console.log( k, myObject[k] );
}  // "a" 2

Object.keys( myObject ); // ["a"]

constructor和prototype

constructor

它是由当前对象所引用的

[[Prototype]]

所决定

function Foo() { /* .. */ }
Foo.prototype.constructor === Foo

Foo.prototype = { /* .. */ }; // create a new prototype object

var a1 = new Foo();
a1.constructor === Foo; // false!
a1.constructor === Object; // true!     //[[Prototype]]实际是指向Object.prototype
Foo.prototype.constructor === Object

正则表达式

重复出现

?   可选 (添加后变非贪婪模式)
+   一次或多次
*    0次或多次
{n}
{n,}
{,m}
{n,m}

反向引用

() 分组和捕获
[]  或操作符
/^([dtn])a\1/   \n表示匹配要引用的捕获数量