bind函数（javascript bind的用法）

javascript bind的用法

javascript的bind

bind主要是为了改变函数内部的this指向，这个是在ECMA5以后加入的，所以IE8一下的浏览器不支持

bind方法会创建一个新函数,称为绑定函数.当调用这个绑定函数时,绑定函数会以创建它时传入bind方法的第一个参数作为this,传入bind方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数.

可以看这段实例：

var logger = {
    x: 0,       
    updateCount: function(){
        this.x++;
        console.log(this.x);
    }
}
 
// 下面两段代码的实现是一样的
 
document.querySelector(’button’).addEventListener(’click’, function(){
    logger.updateCount();
});
 //用这种方式让代码更简洁，当然这只是bind的一种场景
document.querySelector(’button’).addEventListener(’click’, logger.updateCount.bind(logger));

SOCKET编程中的bind函数的作用

socket编程中的bind()函数把IP地址端口相关信息和套接字相互关联起来。
使用格式
#include 《sys/types.h》
#include 《sys/socket.h》
int bind(int sockfd, const struct sockaddr *addr,socklen_t *addrlen);
功能描述
当用socket()函数创建套接字以后，套接字在名称空间(网络地址族)中存在，但没有任何地址给它赋值。bind()把用addr指定的地址赋值给用文件描述符代表的套接字sockfd。addrlen指定了以addr所指向的地址结构体的字节长度。一般来说，该操作称为“给套接字命名”。
通常，在一个SOCK_STREAM套接字接收连接之前，必须通过bind()函数用本地地址为套接字命名。
备注：
调用bind()函数之后，为socket()函数创建的套接字关联一个相应地址，发送到这个地址的数据可以通过该套接字读取与使用。
备注：
bind()函数并不是总是需要调用的，只有用户进程想与一个具体的地址或端口相关联的时候才需要调用这个函数。如果用户进程没有这个需要，那么程序可以依赖内核的自动的选址机制来完成自动地址选择，而不需要调用bind()函数，同时也避免不必要的复杂度。在一般情况下，对于服务器进程问题需要调用bind()函数，对于客户进程则不需要调用bind()函数。

c++11里面的bind函数是什么鬼，看不懂，请高手指教

std::bind

简单调用(1)
template 《class Fn, class… Args》
 /* 未指定 */ bind (Fn&& fn, Args&&… args);
跟上返回值(2)
template 《class Ret, class Fn, class… Args》
 /* 未指定 */ bind (Fn&& fn, Args&&… args);

绑定(Bind)函数与参数的作用，

返回一个基于fn的函数对象，但是已经提前绑定了调用需要的参数。

调用这个函数对象相当于调用用绑定的参数调用fn。

下面给你一个使用例子吧：

// bind 用例
#include 《iostream》
#include 《functional》
// 自定义的一个函数
double my_divide (double x, double y) {return x/y;}
// 自定义的一个结构体
struct MyPair {
  double a,b;
  double multiply() {return a*b;}
};
int main () {
  // 这个using是为了使用 _1, _2, _3,…
  using namespace std::placeholders;
  // 捆绑函数:
  auto fn_five = std::bind (my_divide,10,2); // 返回 10/2
  std::cout 《《 fn_five() 《《 ’\n’; // 输出 5
  auto fn_half = std::bind (my_divide,_1,2); // 返回 x/2
  std::cout 《《 fn_half(10) 《《 ’\n’; // 输出 5
  auto fn_invert = std::bind (my_divide,_2,_1); // 返回 y/x
  std::cout 《《 fn_invert(10,2) 《《 ’\n’; // 输出 0.2
  auto fn_rounding = std::bind《int》 (my_divide,_1,_2); // 返回 int(x/y)
  std::cout 《《 fn_rounding(10,3) 《《 ’\n’; // 输出 3
  MyPair ten_two {10,2};
  // 捆绑成员函数:
  auto bound_member_fn = std::bind (&MyPair::multiply,_1); // 返回 x.multiply()
  std::cout 《《 bound_member_fn(ten_two) 《《 ’\n’; // 输出 20
  auto bound_member_data = std::bind (&MyPair::a,ten_two); // 返回 ten_two.a
  std::cout 《《 bound_member_data() 《《 ’\n’; // 输出 10
  return 0;
}

运行结果：

5
5
0.2
3
20
10

关于原生js中bind函数的简单实现

今天继续研究了bind函数的实现，也知道了shim和polyfill的说法，现在总结一下，
if
(!Function.prototype.bind)
{
Function.prototype.bind
=
function
(oThis)
{
if
(typeof
this
!==
“function“)
{
//
closest
thing
possible
to
the
ECMAScript
5
internal
IsCallable
function
throw
new
TypeError(“Function.prototype.bind
–
what
is
trying
to
be
bound
is
not
callable“);
}
var
aArgs
=
Array.prototype.slice.call(arguments,
1),
fToBind
=
this,
fNOP
=
function
()
{},
fBound
=
function
()
{
return
fToBind.apply(this
instanceof
fNOP
&&
oThis
?
this
:
oThis
||
window,
aArgs.concat(Array.prototype.slice.call(arguments)));
};
fNOP.prototype
=
this.prototype;
fBound.prototype
=
new
fNOP();
return
fBound;
};
}
这是官方文档上的实现，我分二个方面来谈我要说的东西，
第一个是参数，agruments的使用
var
aArgs
=
Array.prototype.slice.call(arguments,
1),这里是将bind函数的参数数组取出来，第一个参数不要（就是不要oThis）也就是要被绑定方法的那个对象，第二个是
aArgs.concat(Array.prototype.slice.call(arguments)));
这里是用了数组的方法，把参数插在参数数组后面，要注意，这个函数是要被return
出去然后执行的，他的参数数组是return出去的那个fBound函数的参数数组，所以上下两个参数数组是不一样的，有点像柯里化。
第二个是上下文，在其中上下文的变化比较难理解，bind函数主要就是为了绑定上下文来使用的
fToBind
=
this
这里是保存了对象的上下文，紧接着下面的apply方法让要被绑定的那个对象可以使用该上下文
fNOP.prototype
=
this.prototype;
fBound.prototype
=
new
fNOP();
这里是以fNOP为中介把this.prototype这个原对象的属性给fBound，确保fBound是在定义的时候的那个上下文里面执行。本来
bound.prototype
=
self.prototype就可以将原属性集成过来了，但是这样两个对象属性都指向同一个地方，修改
bound.prototype
将会造成self.prototype
也发生改变，这样并不是我们的本意。所以通过一个空函数
nop
做中转，能有效的防止这种情况的发生。
以上这篇关于原生js中bind函数的简单实现就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。

jQuery中bind函数用法

问题1：
《!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN“ “

javascript中apply，call和bind的区别

在JavaScript 中，this的指向是动态变化的，很可能在写程序的过程中，无意中破坏掉this的指向，所以需要一种可以把this的含义固定的技术，于是就有了call，apply 和bind这三个方法，来改变函数体内部 this 的指向，因为函数存在「定义时上下文」和「运行时上下文」以及「上下文是可以改变的」这样的概念。
一、apply、call
apply：应用某一对象的一个方法，用另一个对象替换当前对象。
call：调用一个对象的一个方法，以另一个对象替换当前对象。
共同之处：
都可以用来代替另一个对象调用一个方法，将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。
不同之处：
1、apply：最多只能有两个参数——新this对象和一个数组 argArray。如果给该方法传递多个参数，则把参数都写进这个数组里面，当然，即使只有一个参数，也要写进数组里面。如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。如果没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用作 thisObj，并且无法被传递任何参数。
2、call：则是直接的参数列表，主要用在js对象各方法互相调用的时候，使当前this实例指针保持一致,或在特殊情况下需要改变this指针。如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。
apply和call功能一样，只是传入的参数列表形式不同，其中 thisArg 是你想指定的上下文，他可以是任何一个 JavaScript 对象(JavaScript 中一切皆对象)，call 需要把参数按顺序传递进去，而 apply 则是把参数放在数组里。
如果某个函数的参数数量是不固定的，当参数是明确知道数量时用 call ，而不确定的时候用 apply，然后把参数 push 进数组传递进去。当参数数量不确定时，函数内部也可以通过 arguments 这个数组来遍历所有的参数。
二、bind
与上面不同的是，bind会返回一个改变this指向的新函数 ，注意这里强调的是新函数，其与之前的使用的不是同一块内存地址，所以当需要重复使用这个函数的时候，就不得不把其保存到一个变量，方便下次调用。上面的两个函数都是返回的执行结果，即调用即执行，此外，另外需要注意的地方是，bind函数中的首个参数，会自动成为返回新函数中参数的默认值，那么正式调用的时候，只需要给出除首个参数外，剩余参数即可。
当希望改变上下文环境之后并非立即执行，而是回调执行的时候，使用 bind() 方法。而 apply/call 则会立即执行函数。
三、三者的联系：
apply 、 call 、bind 三者都是用来改变函数的this对象的指向的;
apply 、 call 、bind 三者第一个参数都是this要指向的对象，也就是想指定的上下文;
apply 、 call 、bind 三者都可以利用后续参数传参;
bind是返回对应函数，便于稍后调用;apply、call则是立即调用。

socket中bind函数绑定的IP是什么

所谓bind，就是指绑定本地接受端口。
指定ip，是为了分辨多ip主机。
bind是服务端调用的函数，绑定的是服务端的IP，假设服务端有多个网卡，即会有多个IP，这个时候我们可以选择用bind绑定其中一个IP，那么服务端只接收该IP上某端口的数据。
如果bind绑定的是INADDR_ANY，即表示所有发送到服务器的这个端口，不管是哪个网卡/哪个IP地址接收到的数据，都由这个服务端进程进行处理。

js中当函数执行bind后再次执行bind或call时会怎样

从上面的代码执行结果中我们发现一点，第一次bind绑定的对象是固定的，也就是后面通过bind或者call再次绑定的时候，就无法修改这个this了，从es5文档中我们能找到答案。
When the [[Call]] internal method of a function object, F, which
was created using the bind function is called with a this value and a
list of arguments ExtraArgs, the following steps are taken:
Let boundArgs be the value of F’s [[BoundArgs]] internal property.
Let boundThis be the value of F’s [[BoundThis]] internal property.
Let target be the value of F’s [[TargetFunction]] internal property.
Let args be a new list containing the same values as the list
boundArgs in the same order followed by the same values as the list
ExtraArgs in the same order.
Return the result of calling the [[Call]] internal method of target
providing boundThis as the this value and providing args as the
arguments.
这段话中说到如果我们在一个由bind创建的函数中调用call，假设是x.call(obj,y,z,…)并且传入this，和参数列表的时候会执行下面的步骤：
1.首先用三个参数分别保存函数x函数的内部属性中存的this值、目标函数和参数 列表。
2.然后执行目标函数的内部call函数，也就是执行目标函数的代码，并且传入1中保存的this和实参(这里的实参是目标函数本来就有的也就是bind时传入的实参加上调用call时传的实参)
重点在1中，从es5的bind函数说明中我们知道，当我们用一个函数调用bind的时候，返回的函数中会保存这三个参数。所以最后调用call的时候执行的函数是目标函数，也就是调用了bind的函数，传入的this也是bind调用时传入的，这些都是无法被修改的了，但是参数是调用bind和call时的叠加，这是我们唯一可以修改的地方。执行两次bind的原理可以参考bind的源码，和call的差不多，也是目标函数和this是被固定的了，只有参数列表会叠加。