1.函数的四种调用模式
-->函数模式 :一般独立函数调用
-->方法模式 : 作为方法调用..一定有一个引导对象(宿主对象)
-->构造器调用 :一定用来初始化对象..有new 引导..return可以重定向
-->上下文调用 : apple 或 call..第一个参数决定 this 的含义 ..借用方法
2.函数调用模式
->函数的定义方式
1>声明式
2>表达式式
3>Function
->单独独立调用的就是函数
函数名( 参数 )
->this 表示全局对象
->任何自调用函数都是函数模式
3.方法调用模式 method {常称静态方法
->区分
方法本身就是函数,但是方法不是单独独立的调用,而是通过一个对象引导调用.
对象.方法( 参数 )
->this 表示引导方法的对象
------方法调用一定要有 宿主对象
------方法一定是 某个对象的 方法. 对象可以是任何对象
function foo(){
console.log( this );
}
var o ={name:'jim'};
o.foo = foo;
foo(); //函数调用
o.foo(); //方法调用 ---------------------------------------
function func(){
console.log( ' 函数也是对象');
}
func.foo = foo;
foo(); //函数调用
func.foo(); //方法调用
---------------------------------------
var arr = [1,2,3];
arr.foo = foo;
arr.foo();
*4.面试题
var length = 10;
function fn () {
console.log(this.length);
}
var obj = {
length:5,
method:function( fn ){
fn();
arguments[ 0 ]();
}
};
obj.method( fn,1 );
----arguments 特殊对象,无需明确指出参数名,便可访问
5.构造器模式(构造函数模式,构造方法模式)
constructor
->区分 new
->执行步骤
var p = new Person ( );
new 是运算符,用来申请创建对象 ,创建出来的对象传递给构造函数的 this
利用构造函数对其初始化
function Person ( ) {
this.name = 'jim',
this.age =19;
this.gender = 'male';
}
->返回值
若不写return,那么 构造函数 默认返回 this
若在构造函数中写return,并紧跟基本类型( return num, return 123) .则忽略返回类型
若在构造函数中写return,并紧跟引用类型,那么构造函数返回该引用类型数据,忽略this
->调用构造函数时,无参可省括号
------构造函数结合性小结
1)构造函数无参数,可省括号
var p = new Person;
2)创建对象并直接调用其方法
( new Person ( ) ).sayHello( )
->可省略调整结合性的括号
new Person ( ).sayhello ( )
->若省略构造函数的括号,就必须加结合性的括号
( new Person).sayHello ( )
*5.面试题
6.上下文调用模式
[[统一一种格式,可以实现 函数模式与方法模式
环境调用模式=>在不同环境下的不同调用模式
->语法(区分)
1> call 形式
函数名.call( ... )
2> apply 形式
函数名.apply( ... )
->用法
上下文调用目的..为了实现借用方法
function foo ( ) {
console.log( this );
}
var o = { name: 'jim' };
foo( );
o.func = foo ;
o .func( ) ;
//函数以函数的形式调用
foo.apply ( null ) 或 foo.apply( )
//希望其是方法调用模式,需提供一个宿主对象
foo.apply ( o )
->带有参数的函数如何实现上下文调用
function foo ( num1 ,num2){
console.log( this );
return num1 + num2;
}
//函数调用模式
var res1 = foo( 123,567 );
//方法调用
var o = { name:' jim '};
o.func = foo;
var res2 = o.func ( 123 ,567 );
->使用 apply 进行调用,
如果函数是带有参数的 .apply 的第一个参数是 null 或对象
-是 null 就是函数调用
-是对象 就是方法对象,该对象就是宿主对象,后紧跟一个数组参数,将函数的参数一次放在数组中
例如:
函数模式 foo (123 ,567 );
apply foo.apply( null, [123 ,567] )
//
有一个函数调用:func( '张三',19,'男' ),
将其修改成 apply 模式: func.apply (null,['张三',19,'男'] )
方法模式 :o.func( 123,567 )
apply :foo.apply( o, [123 ,567])
7.call 调用 [[apply 调用时,函数参数须以数组形式存在,SO 引入call调用
--> call 调用与 apply 完全相同...[ 除参数不需要使用数组
foo( 123 ,567 )
foo.apply(null,[123,567] );
foo.call(null,123,567);
8.借用构造方法实现继承
function Person ( name ,age ,gender ){
this.name = name;
this.age = age;
this.gender = gender;
}
function Student (name,age, gender, coure){
Person.call (this ,name,age, gender);
this.course = course;
}
var p = new Student ('jim',19,'male','前端');
其他
1. 函数的bind (绑定)方法
让函数绑定对象的一种用法
函数本身是可调用,若要作为方法调用,须传入宿主对象,且使用call 或apply形式
但bind 使函数与某一个对象绑定起来,那么调用函数的时候,就好像是该对象在调用方法
->语法
函数.bind ( 对象 )
[返回一个函数 foo ,那么调用 返回的函数 foo ,就好像 对象在调用 该方法一样
2.Object.prototype 的成员
1) constructor
2) hasOwnProperty 判断该属性是否为自己提供
3) propertyIsEnumerable 判断属性是否可以枚举
4) isPrototypeOf 判断是否为原型对象
5) toString, toLocalestring, valueOf
3.包装对象
字符串 string 是基本类型,理论上不应该包含方法
charAt , subStr ,slice ,...
三个基本类型对应的对象类型
Number String Boolean
基本数据类型没有方法,需要时自动的将基本类型转换成对象类型
"abc".charAt( 1 )
"abc" -> new String( "abc" )
s.charAt( 1 ) 返回结果
s 就被销毁
当 基本类型. 方法 的时候 , 解析器首先将基本类型转换成对应的对象类型,然后调用方法.方法执行结束后,这个对象就立刻回收
--在 apply 和 call 调用的时候,也会转换
--上下文调用的第一个参数必须是对象,若传递的是数字会自动转化成对应的包装类型
4.getter 与 setter 的语法糖�?????
语法糖: 方便开发给出的语法结构
var o = (function () {
var num = 123;
return {
get_num: function () {
return num;
},
set_num: function ( v ) {
num = v;
}
};
})();
// 获得数据
o.get_num(); => o.num 形式
// 设置
o.set_num( 456 ); => o.num = 456 形式
var o = (function () {
var num = 123;
return {
// get 名字 () { 逻辑体 }
get num () {
return num;
}
// set 名字 ( v ) { 逻辑体 }
set num ( v ) {
num = v;
}
};
})();
5. ES5 中引入的部分数组方法
1> forEach 遍历
var arr = ['hello','js',{ },function(){ } ];
//遍历 数组
arr.forEach(function(v,i){
console.log(i +'==='+v);
});
2> map 映射
语法: 数组.map( fn )
3> filter 筛选
语法: 数组.filter ( function ( v,i ){ }
4> some 判断数组中至少有一个数据,符合要求就返回true,否则返回false
5> every 满足所有元素都符合要求才返回true
6> indexOf 索引
7> lastIndexOf 从右往左找
