函数
- 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 //第二参数传入
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])a1/
表示匹配要引用的捕获数量