区块链技术博客
www.b2bchain.cn

六、5. Promise 的使用求职学习资料

D0b2wT.gif

本文介绍了六、5. Promise 的使用求职学习资料,有助于帮助完成毕业设计以及求职,是一篇很好的资料。

对技术面试,学习经验等有一些体会,在此分享。

Promise 是一个非常重要的概念。

我们常常会使用 Promise 来解决反馈结果需要等待的场景。

例如,前端向服务端发送一个接口请求。请求结果不会马上返回,而是需要等待一段时间。

例如,加载图片,需要等待一段时间。

例如,弹窗中,等待用户点击确认或者取消。

六、5. Promise 的使用

同步与异步

在代码的执行过程中,会涉及到两个不同的概念,同步与异步

同步是指当发起一个请求时,如果未得到请求结果,代码逻辑将会等待,直到结果出来为止才会继续执行之后的代码。

异步是指当发起一个请求时,不会等待请求结果,直接继续执行后面的代码。请求结果的处理逻辑,会添加一个监听,等到反馈结果出来之后,在回调函数中处理对应的逻辑。

我们可以用一个两人问答的场景来比喻异步与同步。
A 向 B 问了一个问题之后,然后就笑呵呵的等着 B 回答,B回答了之后他才会接着问下一个问题,这是同步。
A 向 B 问了一个问题之后,不等待B的回答,接着问下一个问题,这是异步。

在JavaScript中,也可以用代码来表示他们之间的区别。

读取文件内容需要花费一定的时间。因此要得到结果就需要等待一段时间。

同步的处理方式:

// 伪代码 console.log('开始读取'); const res = readFileSync('a.txt') console.log('读取结束,现在能拿到读取内容。')  // 输出结果: // 开始读取 // 读取结束,现在能拿到读取内容。

异步的处理方式:

// 伪代码 console.log('开始读取'); readFile((res) => {   console.log('读取结束,现在能拿到读取内容。') }) console.log('读取未结束,现在不能拿到读取内容,但是后续的逻辑继续执行。')  // 输出结果: // 开始读取 // 读取未结束,现在不能拿到读取内容,但是后续的逻辑继续执行。 // 读取结束,现在能拿到读取内容。

也可以直接使用 Promise 来解读。

首先使用 Promise 模拟一个发起请求的函数,该函数执行后,将会 1s 之后返回数值 30。

function fn() {   return new Promise(function(resolve, reject) {     setTimeout(function() {       resolve(30);     }, 1000);   }) }

在该函数的基础上,我们可以使用 async/await 语法来模拟同步的效果。

var foo = async function() {   var t = await fn();   console.log(t);   console.log('next code'); }  foo();

输出结果为

// 1s之后依次输出 30 next code

而异步效果则会有不同的输出结果。

var foo = function() {   fn().then(function(resp) {     console.log(resp);   });   console.log('next code'); }

输出结果

next code // 停顿1s后继续输出 30

Promise

1. ajax

ajax 是网页与服务端进行数据交互的一种技术。

我们可以通过服务端提供的接口,利用 ajax 向服务端请求需要的数据。

整个过程的简单实现如下:

// 简单的ajax原生实现  // 由服务端提供的接口 var url = 'http://www.demo.com/user/info';  var result;  var XHR = new XMLHttpRequest(); XHR.open('GET', url, true); XHR.send();  XHR.onreadystatechange = function() {   if (XHR.readyState == 4 && XHR.status == 200) {     result = XHR.response;     console.log(result);   } }

在 ajax 的原生实现中,利用了 onreadystatechange 事件,当该事件触发并且符合一定条件时,就能拿到我们想要的数据,之后我们才能开始处理数据。

我们发现,这其实就是一个异步操作。

这样做看上去并没有什么麻烦,但是如果这个时候,我们还需要做另外一个 ajax 请求,这个新的 ajax 请求的其中一个参数,得从上一个 ajax 请求中获取,这个时候我们就不得不如下这样做:

var url = 'http://www.demo.com/user/info'; var result;  var XHR = new XMLHttpRequest(); XHR.open('GET', url, true); XHR.send();  XHR.onreadystatechange = function() {   if (XHR.readyState == 4 && XHR.status == 200) {     result = XHR.response;     console.log(result);      // 伪代码     var url2 = 'http:xxx.yyy.com/zzz?ddd=' + result.someParams;     var XHR2 = new XMLHttpRequest();     XHR2.open('GET', url, true);     XHR2.send();     XHR2.onreadystatechange = function() {         ...     }   } }

当出现第三个 ajax (甚至更多)仍然依赖上一个请求的时候,代码就变成了一场灾难。

我们需要不停的嵌套回调函数,以确保下一个接口所需要的参数的正确性。这样的灾难,我们称之为 回调地狱

Promise 可以帮助我们解决这个问题。

我们知道,如果要确保某代码在谁之后执行,可以利用函数调用栈,将想要执行的代码放入回调函数中。

// 一个简单的封装 function want() {   console.log('这是你想要执行的代码'); }  function fn(want) {   console.log('这里表示执行了一大堆各种代码');    // 其他代码执行完毕,最后执行回调函数   want && want(); }  fn(want);

除此之外,还可以利用队列机制。

function want() {   console.log('这是你想要执行的代码'); }  function fn(want) {   // 将想要执行的代码放入队列中,根据事件循环的机制,我们就不用非得将它放到最后面了,由你自由选择   want && setTimeout(want, 0);   console.log('这里表示执行了一大堆各种代码'); }  fn(want);

与 setTimeout 类似,Promise 也可以认为是一种任务分发器,它将任务分配到 Promise 队列中,通常的流程是我们会首先发起一个请求,然后等待(等待时间我们无法确定)并处理请求结果。

简单的用法大概如下:

var tag = true; var p = new Promise(function(resolve, reject) {   if (tag) {     resolve('tag is true');   } else {     reject('tag is false');   } })  p.then(function(result) {   console.log(result); }) .catch(function(err) {   console.log(err); })

运行这段代码,并通过修改tag的值来感受一下运行结果的不同。

然后接下来我们来了解Promise的相关基础知识。

  1. 使用 new Promise() 可以创建一个 Promise 实例。
const p = new Promise()
  1. Promise 函数中的第一个参数为一个回调函数,我们也可以称之为 executor。通常情况下,在这个函数中,我们将会执行发起请求操作,并修改结果的状态值。
const p = new Promise((resolve, reject) => {   if (true) {     resolve()   }   if (false) {     reject()   } })
  1. 请求结果有三种状态,他们分别是
  • pending 等待中,表示还没有得到结果
  • resolved 得到了我们想要的结果,可以继续执行
  • rejected 得到了错误的,或者不是我们期望的结果,将会拒绝继续执行

请求结果的默认状态为 pending

executor 函数中,我们可以分别使用 resolvereject 将状态修改为对应的 resolvedrejected

resolve、rejectexecutor 函数的两个参数。他们能够将请求结果的具体数据传递出去。

  1. Promise实例拥有的 then 方法,用来处理当请求结果的状态变成 resolved 时的逻辑。then 的第一个参数也为一个回调函数,该函数的参数则是 resolve 传递出来的数据。在上面的例子中,result 的值为 tag is true

  2. Promise实例拥有的 catch 方法,用来处理当请求结果的状态变成 rejected 时的逻辑。catch 的第一个参数也为一个回调函数,该函数的参数则是 reject 传递出来的数据。在上面的例子中,err = tag is false

下面通过几个简单的例子来感受一下Promise的用法。

例子1:

function fn(num) {   // 创建一个Promise实例   return new Promise(function (resolve, reject) {     if (typeof num == 'number') {       // 修改结果状态值为resolved       resolve();     } else {       // 修改结果状态值为rejected       reject();     }   }).then(function () {     console.log('参数是一个number值');   }).catch(function () {     console.log('参数不是一个number值');   }) }  // 修改参数的类型观察输出结果 fn('12');  // 注意观察该语句的执行顺序 console.log('next code');

例子2:

function fn(num) {   return new Promise(function (resolve, reject) {     // 模拟一个请求行为,2s以后得到结果     setTimeout(function () {       if (typeof num == 'number') {         resolve(num)       } else {         var err = num + ' is not a number.'         reject(err);       }     }, 2000);   })     .then(function (resp) {       console.log(resp);     })     .catch(function (err) {       console.log(err);     }) }  // 修改传入的参数类型观察结果变化 fn('abc');  // 注意观察该语句的执行顺序 console.log('next code');

因为fn函数运行的结果是返回的一个Promise对象,因此我们也可以将上面的例子修改如下:

“`javascript
function fn(num) {

Promise 是一个非常重要的概念。

我们常常会使用 Promise 来解决反馈结果需要等待的场景。

例如,前端向服务端发送一个接口请求。请求结果不会马上返回,而是需要等待一段时间。

例如,加载图片,需要等待一段时间。

例如,弹窗中,等待用户点击确认或者取消。

六、5. Promise 的使用

同步与异步

在代码的执行过程中,会涉及到两个不同的概念,同步与异步

同步是指当发起一个请求时,如果未得到请求结果,代码逻辑将会等待,直到结果出来为止才会继续执行之后的代码。

异步是指当发起一个请求时,不会等待请求结果,直接继续执行后面的代码。请求结果的处理逻辑,会添加一个监听,等到反馈结果出来之后,在回调函数中处理对应的逻辑。

我们可以用一个两人问答的场景来比喻异步与同步。
A 向 B 问了一个问题之后,然后就笑呵呵的等着 B 回答,B回答了之后他才会接着问下一个问题,这是同步。
A 向 B 问了一个问题之后,不等待B的回答,接着问下一个问题,这是异步。

在JavaScript中,也可以用代码来表示他们之间的区别。

读取文件内容需要花费一定的时间。因此要得到结果就需要等待一段时间。

同步的处理方式:

// 伪代码 console.log('开始读取'); const res = readFileSync('a.txt') console.log('读取结束,现在能拿到读取内容。')  // 输出结果: // 开始读取 // 读取结束,现在能拿到读取内容。

异步的处理方式:

// 伪代码 console.log('开始读取'); readFile((res) => {   console.log('读取结束,现在能拿到读取内容。') }) console.log('读取未结束,现在不能拿到读取内容,但是后续的逻辑继续执行。')  // 输出结果: // 开始读取 // 读取未结束,现在不能拿到读取内容,但是后续的逻辑继续执行。 // 读取结束,现在能拿到读取内容。

也可以直接使用 Promise 来解读。

首先使用 Promise 模拟一个发起请求的函数,该函数执行后,将会 1s 之后返回数值 30。

function fn() {   return new Promise(function(resolve, reject) {     setTimeout(function() {       resolve(30);     }, 1000);   }) }

在该函数的基础上,我们可以使用 async/await 语法来模拟同步的效果。

var foo = async function() {   var t = await fn();   console.log(t);   console.log('next code'); }  foo();

输出结果为

// 1s之后依次输出 30 next code

而异步效果则会有不同的输出结果。

var foo = function() {   fn().then(function(resp) {     console.log(resp);   });   console.log('next code'); }

输出结果

next code // 停顿1s后继续输出 30

Promise

1. ajax

ajax 是网页与服务端进行数据交互的一种技术。

我们可以通过服务端提供的接口,利用 ajax 向服务端请求需要的数据。

整个过程的简单实现如下:

// 简单的ajax原生实现  // 由服务端提供的接口 var url = 'http://www.demo.com/user/info';  var result;  var XHR = new XMLHttpRequest(); XHR.open('GET', url, true); XHR.send();  XHR.onreadystatechange = function() {   if (XHR.readyState == 4 && XHR.status == 200) {     result = XHR.response;     console.log(result);   } }

在 ajax 的原生实现中,利用了 onreadystatechange 事件,当该事件触发并且符合一定条件时,就能拿到我们想要的数据,之后我们才能开始处理数据。

我们发现,这其实就是一个异步操作。

这样做看上去并没有什么麻烦,但是如果这个时候,我们还需要做另外一个 ajax 请求,这个新的 ajax 请求的其中一个参数,得从上一个 ajax 请求中获取,这个时候我们就不得不如下这样做:

var url = 'http://www.demo.com/user/info'; var result;  var XHR = new XMLHttpRequest(); XHR.open('GET', url, true); XHR.send();  XHR.onreadystatechange = function() {   if (XHR.readyState == 4 && XHR.status == 200) {     result = XHR.response;     console.log(result);      // 伪代码     var url2 = 'http:xxx.yyy.com/zzz?ddd=' + result.someParams;     var XHR2 = new XMLHttpRequest();     XHR2.open('GET', url, true);     XHR2.send();     XHR2.onreadystatechange = function() {         ...     }   } }

当出现第三个 ajax (甚至更多)仍然依赖上一个请求的时候,代码就变成了一场灾难。

我们需要不停的嵌套回调函数,以确保下一个接口所需要的参数的正确性。这样的灾难,我们称之为 回调地狱

Promise 可以帮助我们解决这个问题。

我们知道,如果要确保某代码在谁之后执行,可以利用函数调用栈,将想要执行的代码放入回调函数中。

// 一个简单的封装 function want() {   console.log('这是你想要执行的代码'); }  function fn(want) {   console.log('这里表示执行了一大堆各种代码');    // 其他代码执行完毕,最后执行回调函数   want && want(); }  fn(want);

除此之外,还可以利用队列机制。

function want() {   console.log('这是你想要执行的代码'); }  function fn(want) {   // 将想要执行的代码放入队列中,根据事件循环的机制,我们就不用非得将它放到最后面了,由你自由选择   want && setTimeout(want, 0);   console.log('这里表示执行了一大堆各种代码'); }  fn(want);

与 setTimeout 类似,Promise 也可以认为是一种任务分发器,它将任务分配到 Promise 队列中,通常的流程是我们会首先发起一个请求,然后等待(等待时间我们无法确定)并处理请求结果。

简单的用法大概如下:

var tag = true; var p = new Promise(function(resolve, reject) {   if (tag) {     resolve('tag is true');   } else {     reject('tag is false');   } })  p.then(function(result) {   console.log(result); }) .catch(function(err) {   console.log(err); })

运行这段代码,并通过修改tag的值来感受一下运行结果的不同。

然后接下来我们来了解Promise的相关基础知识。

  1. 使用 new Promise() 可以创建一个 Promise 实例。
const p = new Promise()
  1. Promise 函数中的第一个参数为一个回调函数,我们也可以称之为 executor。通常情况下,在这个函数中,我们将会执行发起请求操作,并修改结果的状态值。
const p = new Promise((resolve, reject) => {   if (true) {     resolve()   }   if (false) {     reject()   } })
  1. 请求结果有三种状态,他们分别是
  • pending 等待中,表示还没有得到结果
  • resolved 得到了我们想要的结果,可以继续执行
  • rejected 得到了错误的,或者不是我们期望的结果,将会拒绝继续执行

请求结果的默认状态为 pending

executor 函数中,我们可以分别使用 resolvereject 将状态修改为对应的 resolvedrejected

resolve、rejectexecutor 函数的两个参数。他们能够将请求结果的具体数据传递出去。

  1. Promise实例拥有的 then 方法,用来处理当请求结果的状态变成 resolved 时的逻辑。then 的第一个参数也为一个回调函数,该函数的参数则是 resolve 传递出来的数据。在上面的例子中,result 的值为 tag is true

  2. Promise实例拥有的 catch 方法,用来处理当请求结果的状态变成 rejected 时的逻辑。catch 的第一个参数也为一个回调函数,该函数的参数则是 reject 传递出来的数据。在上面的例子中,err = tag is false

下面通过几个简单的例子来感受一下Promise的用法。

例子1:

function fn(num) {   // 创建一个Promise实例   return new Promise(function (resolve, reject) {     if (typeof num == 'number') {       // 修改结果状态值为resolved       resolve();     } else {       // 修改结果状态值为rejected       reject();     }   }).then(function () {     console.log('参数是一个number值');   }).catch(function () {     console.log('参数不是一个number值');   }) }  // 修改参数的类型观察输出结果 fn('12');  // 注意观察该语句的执行顺序 console.log('next code');

例子2:

function fn(num) {   return new Promise(function (resolve, reject) {     // 模拟一个请求行为,2s以后得到结果     setTimeout(function () {       if (typeof num == 'number') {         resolve(num)       } else {         var err = num + ' is not a number.'         reject(err);       }     }, 2000);   })     .then(function (resp) {       console.log(resp);     })     .catch(function (err) {       console.log(err);     }) }  // 修改传入的参数类型观察结果变化 fn('abc');  // 注意观察该语句的执行顺序 console.log('next code');

因为fn函数运行的结果是返回的一个Promise对象,因此我们也可以将上面的例子修改如下:

“`javascript
function fn(num) {

Promise 是一个非常重要的概念。

我们常常会使用 Promise 来解决反馈结果需要等待的场景。

例如,前端向服务端发送一个接口请求。请求结果不会马上返回,而是需要等待一段时间。

例如,加载图片,需要等待一段时间。

例如,弹窗中,等待用户点击确认或者取消。

六、5. Promise 的使用

同步与异步

在代码的执行过程中,会涉及到两个不同的概念,同步与异步

同步是指当发起一个请求时,如果未得到请求结果,代码逻辑将会等待,直到结果出来为止才会继续执行之后的代码。

异步是指当发起一个请求时,不会等待请求结果,直接继续执行后面的代码。请求结果的处理逻辑,会添加一个监听,等到反馈结果出来之后,在回调函数中处理对应的逻辑。

我们可以用一个两人问答的场景来比喻异步与同步。
A 向 B 问了一个问题之后,然后就笑呵呵的等着 B 回答,B回答了之后他才会接着问下一个问题,这是同步。
A 向 B 问了一个问题之后,不等待B的回答,接着问下一个问题,这是异步。

在JavaScript中,也可以用代码来表示他们之间的区别。

读取文件内容需要花费一定的时间。因此要得到结果就需要等待一段时间。

同步的处理方式:

// 伪代码 console.log('开始读取'); const res = readFileSync('a.txt') console.log('读取结束,现在能拿到读取内容。')  // 输出结果: // 开始读取 // 读取结束,现在能拿到读取内容。

异步的处理方式:

// 伪代码 console.log('开始读取'); readFile((res) => {   console.log('读取结束,现在能拿到读取内容。') }) console.log('读取未结束,现在不能拿到读取内容,但是后续的逻辑继续执行。')  // 输出结果: // 开始读取 // 读取未结束,现在不能拿到读取内容,但是后续的逻辑继续执行。 // 读取结束,现在能拿到读取内容。

也可以直接使用 Promise 来解读。

首先使用 Promise 模拟一个发起请求的函数,该函数执行后,将会 1s 之后返回数值 30。

function fn() {   return new Promise(function(resolve, reject) {     setTimeout(function() {       resolve(30);     }, 1000);   }) }

在该函数的基础上,我们可以使用 async/await 语法来模拟同步的效果。

var foo = async function() {   var t = await fn();   console.log(t);   console.log('next code'); }  foo();

输出结果为

// 1s之后依次输出 30 next code

而异步效果则会有不同的输出结果。

var foo = function() {   fn().then(function(resp) {     console.log(resp);   });   console.log('next code'); }

输出结果

next code // 停顿1s后继续输出 30

Promise

1. ajax

ajax 是网页与服务端进行数据交互的一种技术。

我们可以通过服务端提供的接口,利用 ajax 向服务端请求需要的数据。

整个过程的简单实现如下:

// 简单的ajax原生实现  // 由服务端提供的接口 var url = 'http://www.demo.com/user/info';  var result;  var XHR = new XMLHttpRequest(); XHR.open('GET', url, true); XHR.send();  XHR.onreadystatechange = function() {   if (XHR.readyState == 4 && XHR.status == 200) {     result = XHR.response;     console.log(result);   } }

在 ajax 的原生实现中,利用了 onreadystatechange 事件,当该事件触发并且符合一定条件时,就能拿到我们想要的数据,之后我们才能开始处理数据。

我们发现,这其实就是一个异步操作。

这样做看上去并没有什么麻烦,但是如果这个时候,我们还需要做另外一个 ajax 请求,这个新的 ajax 请求的其中一个参数,得从上一个 ajax 请求中获取,这个时候我们就不得不如下这样做:

var url = 'http://www.demo.com/user/info'; var result;  var XHR = new XMLHttpRequest(); XHR.open('GET', url, true); XHR.send();  XHR.onreadystatechange = function() {   if (XHR.readyState == 4 && XHR.status == 200) {     result = XHR.response;     console.log(result);      // 伪代码     var url2 = 'http:xxx.yyy.com/zzz?ddd=' + result.someParams;     var XHR2 = new XMLHttpRequest();     XHR2.open('GET', url, true);     XHR2.send();     XHR2.onreadystatechange = function() {         ...     }   } }

当出现第三个 ajax (甚至更多)仍然依赖上一个请求的时候,代码就变成了一场灾难。

我们需要不停的嵌套回调函数,以确保下一个接口所需要的参数的正确性。这样的灾难,我们称之为 回调地狱

Promise 可以帮助我们解决这个问题。

我们知道,如果要确保某代码在谁之后执行,可以利用函数调用栈,将想要执行的代码放入回调函数中。

// 一个简单的封装 function want() {   console.log('这是你想要执行的代码'); }  function fn(want) {   console.log('这里表示执行了一大堆各种代码');    // 其他代码执行完毕,最后执行回调函数   want && want(); }  fn(want);

除此之外,还可以利用队列机制。

function want() {   console.log('这是你想要执行的代码'); }  function fn(want) {   // 将想要执行的代码放入队列中,根据事件循环的机制,我们就不用非得将它放到最后面了,由你自由选择   want && setTimeout(want, 0);   console.log('这里表示执行了一大堆各种代码'); }  fn(want);

与 setTimeout 类似,Promise 也可以认为是一种任务分发器,它将任务分配到 Promise 队列中,通常的流程是我们会首先发起一个请求,然后等待(等待时间我们无法确定)并处理请求结果。

简单的用法大概如下:

var tag = true; var p = new Promise(function(resolve, reject) {   if (tag) {     resolve('tag is true');   } else {     reject('tag is false');   } })  p.then(function(result) {   console.log(result); }) .catch(function(err) {   console.log(err); })

运行这段代码,并通过修改tag的值来感受一下运行结果的不同。

然后接下来我们来了解Promise的相关基础知识。

  1. 使用 new Promise() 可以创建一个 Promise 实例。
const p = new Promise()
  1. Promise 函数中的第一个参数为一个回调函数,我们也可以称之为 executor。通常情况下,在这个函数中,我们将会执行发起请求操作,并修改结果的状态值。
const p = new Promise((resolve, reject) => {   if (true) {     resolve()   }   if (false) {     reject()   } })
  1. 请求结果有三种状态,他们分别是
  • pending 等待中,表示还没有得到结果
  • resolved 得到了我们想要的结果,可以继续执行
  • rejected 得到了错误的,或者不是我们期望的结果,将会拒绝继续执行

请求结果的默认状态为 pending

executor 函数中,我们可以分别使用 resolvereject 将状态修改为对应的 resolvedrejected

resolve、rejectexecutor 函数的两个参数。他们能够将请求结果的具体数据传递出去。

  1. Promise实例拥有的 then 方法,用来处理当请求结果的状态变成 resolved 时的逻辑。then 的第一个参数也为一个回调函数,该函数的参数则是 resolve 传递出来的数据。在上面的例子中,result 的值为 tag is true

  2. Promise实例拥有的 catch 方法,用来处理当请求结果的状态变成 rejected 时的逻辑。catch 的第一个参数也为一个回调函数,该函数的参数则是 reject 传递出来的数据。在上面的例子中,err = tag is false

下面通过几个简单的例子来感受一下Promise的用法。

例子1:

function fn(num) {   // 创建一个Promise实例   return new Promise(function (resolve, reject) {     if (typeof num == 'number') {       // 修改结果状态值为resolved       resolve();     } else {       // 修改结果状态值为rejected       reject();     }   }).then(function () {     console.log('参数是一个number值');   }).catch(function () {     console.log('参数不是一个number值');   }) }  // 修改参数的类型观察输出结果 fn('12');  // 注意观察该语句的执行顺序 console.log('next code');

例子2:

function fn(num) {   return new Promise(function (resolve, reject) {     // 模拟一个请求行为,2s以后得到结果     setTimeout(function () {       if (typeof num == 'number') {         resolve(num)       } else {         var err = num + ' is not a number.'         reject(err);       }     }, 2000);   })     .then(function (resp) {       console.log(resp);     })     .catch(function (err) {       console.log(err);     }) }  // 修改传入的参数类型观察结果变化 fn('abc');  // 注意观察该语句的执行顺序 console.log('next code');

因为fn函数运行的结果是返回的一个Promise对象,因此我们也可以将上面的例子修改如下:

“`javascript
function fn(num) {

部分转自互联网,侵权删除联系

赞(0) 打赏
部分文章转自网络,侵权联系删除b2bchain区块链学习技术社区 » 六、5. Promise 的使用求职学习资料
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

b2b链

联系我们联系我们