小编Pat*_*rts的帖子

所以我正在制作一个用于学习目的的小爬虫，最终我应该得到网站上页面的树状结构。

我一直在绞尽脑汁试图让这些要求正确。这或多或少是我所拥有的：

var request = require('request');


function scanPage(url) {

  // request the page at given url:


  request.get(url, function(err, res, body) {

    var pageObject = {};

    /* [... Jquery mumbo-jumbo to

        1. Fill the page object with information and
        2. Get the links on that page and store them into arrayOfLinks 

    */

    var arrayOfLinks = ['url1', 'url2', 'url3'];

    for (var i = 0; i < arrayOfLinks.length; i++) {

      pageObj[arrayOfLinks[i]] = scanPage[arrayOfLinks[i]];

    }
  });

    return pageObj;
}

我知道这段代码在很多层面上都是错误的，但它应该让您了解我正在尝试做什么。

我应该如何修改它才能使其正常工作？（如果可能的话，不使用承诺）

（您可以假设该网站具有树状结构，因此每个页面仅具有指向三个页面下方页面的链接，因此采用递归方法）

我的 React 应用程序中有一个 HOC，这里是代码。

export function checkToken<Props>(WrappedComponent: new() => React.Component<Props, {}>) {
    return (
        class PrivateComponent extends React.Component<Props, LocalState> {
            constructor() {
                super();
                this.state = {
                    isAuthed: false
                }
            }

            async componentDidMount() {
                let token = localStorage.getItem('dash-token');
                let config = {
                    headers: { 'x-access-token': token }
                }
                let response = await axios.get(`${url}/users/auth/checkToken`, config)
                if (!response.data.success) {
                    localStorage.removeItem('dash-token');
                    browserHistory.push('/login');
                } else {
                    this.setState({isAuthed: true});
                }
            }

            render() {
                let renderThis;
                if (this.state.isAuthed) {
                    renderThis = <WrappedComponent {...this.props} />
                }
                return ( …

我在JavaScript中创建了一个脚本,在自动浏览器测试期间注入到我们的Ext JS应用程序中.该脚本测量在网格中加载数据所花费的时间.

具体来说,脚本轮询每个网格,查看是否存在第一行或"无数据"消息,并且一旦所有网格满足此条件,脚本将记录Date.now()和performance.timing.fetchStart之间的值. ,并将其视为页面加载的时间.

此脚本或多或少地按预期工作,但与人体测量时间(Google秒表ftw)相比,此测试报告的时间始终比秒表测量的时间长约300毫秒.

我的问题是这些:

• 这个逻辑中是否存在导致错误结果的漏洞？
• 有没有其他可靠的方法来实现这种测量？

脚本如下:

function loadPoll() {
    var i, duration,
        dataRow = '.firstRow', noDataRow = '.noData',
        grids   = ['.grid1', '.grid2', '.grid3','.grid4', 'grid5', 'grid6', 'grid7'];

    for (i = 0; i < grids.length; ++i) {
            var data   = grids[i] + ' ' + dataRow,
            noData = grids[i] + ' ' + noDataRow;

        if (!(document.querySelector(data) || document.querySelector(noData))) {
            window.setTimeout(loadPoll, 100);
            return;
        }
    }

duration = Date.now() - performance.timing.fetchStart;
    window.loadTime = duration;
}

loadPoll();

一些考虑:

• 虽然我知道人类的响应时间可能很慢,但我确信使用谷歌秒表的人为因素并未引入300毫秒的不一致性.

• 查看代码可能看起来多个元素的轮询可能导致300毫秒的不一致,但是当我将被监视的元素数量从7更改为1时,在报告的时间内仍然有300毫秒的剩余时间.自动化测试.

• 我们的自动化测试在Selenium和Protractor控制的框架中执行.

如果您能够提供任何见解,请提前致谢!

我一直在使用 asyncio 进行并发，但是遇到了问题。我需要使用 asyncio 安排一个任务，但它是阻塞的，所以我想使用并发.futures 中的线程池在执行器中执行它。

我见过这样的例子，安排任务：

now = loop.time()
loop.call_at(now + 60, callback, arg, loop)

像这样在执行器中运行任务：

blocking_tasks = [
    loop.run_in_executor(executor, blocks)
    for i in range(6)
]
completed, pending = await asyncio.wait(blocking_tasks)

但是如何安排阻塞任务在执行器中运行呢？

在Javascript中,使用以下插图代码:

class Base {
   constructor() {  this._val = 1   }
   get val()     { return this._val }
}

class Xtnd extends Base {
   set val(v)    { this._val = v }
}

let x = new Xtnd();
x.val = 5;
console.log(x.val);  // prints 'undefined'

实例x不会get val()...从Base类继承.实际上,Javascript在存在setter时将缺少getter视为未定义.

我有一种情况,其中我有许多类都具有完全相同的getter集但是唯一的setter.目前,我只是复制每个类中的getter,但我正在重构并想要消除冗余代码.

有没有办法告诉JS保持基类的getter,或者有没有人有这个问题的优雅解决方案？

我正在研究一个Angular 6应用程序,我被告知以下是一个反模式:

await someFunction().then(result => {
    console.log(result);
});

我意识到等待承诺链是毫无意义的.如果someFunction()返回一个promise,那么如果你正在等待它,则不需要一个promise链.你可以这样做:

const result = await someFunction();
console.log(result);

但我被告知等待一个承诺链可能会导致错误,或者它会破坏我的代码中的东西.如果上面的第一个代码片段与第二个代码段完全相同,那么使用哪个代码片段至关重要.第一个片段引入了哪个危险,第二个片段没有？

所以我试图把我的头放在 promises/await/async 上。我不明白为什么当执行 go() 时，在 console.log(coffee) 之后会出现带有“finished”的警报。当所有函数都使用 await/promises 时，为什么它只等待 getCoffee() 而其他 axios 调用在“完成”警报之后运行？

function getCoffee() {
  return new Promise(resolve => {
    setTimeout(() => resolve("?"), 2000); // it takes 2 seconds to make coffee
  });
}
async function go() {
  try {
    alert("ok");
    const coffee = await getCoffee();

    console.log(coffee); // ?

    const wes = await axios("https://randomuser.me/api/?results=200");
    console.log("wes"); // using string instead of value for brevity

    const wordPromise = axios("https://randomuser.me/api/?results=200");
    console.log("wordPromise"); // using string instead of value for brevity

    alert("finish");
  } catch …

在编写异步生成器函数时，我注意到以下构造会产生SyntaxError：

async function * foo() {
  await yield bar; // Can not use 'yield' as identifier inside a generator
}

尽管颠倒上下文关键字的顺序是完全可以接受的：

async function * foo() {
  yield await bar; // OK
}

仔细阅读错误后，我能够通过将 括在括号UnaryExpression内来纠正语法AwaitExpression，以避免将令牌解析yield为标识符而不是上下文关键字：

async function * foo() {
  await (yield bar); // OK
}

但这引出了一个问题，ECMAScript 2018中涉及哪些特定的静态语义，导致yield在这种情况下被解析为标识符，同时await不需要特殊处理？

我需要定期获取数据并将其更新到屏幕上。我有这个代码：

const [temperature, setTemperature] = useState();

useEffect(() => {

fetch("urlToWeatherData")
  .then(function(response) {
     if (response.status !== 200) {
      console.log(
        "Looks like there was a problem. Status Code: " + response.status
      );
      return;
    response.json().then(function(data) {
     console.log(data[0].temperature);
     setTemperature(data[0].temperature);

    });
  })
  .catch(function(err) {
    console.log("Fetch Error :-S", err);
  });
 }, []  );

那么，例如，有没有什么巧妙的方法可以每 15 秒运行一次？谢谢！

在尝试创建一个玩具 DSL 时，我遇到了一个奇怪的构造，clang 和 gcc 都没有按照我预期的方式处理：

#include <utility>

template <class...>
struct disjunction {};

template <auto>
struct literal {};

template <class T, T Min, T Max>
using range = decltype([]<T... Cs>(std::integer_sequence<T, Cs...>) {
    return disjunction<literal<T{Min + Cs}>..., literal<Max>>{};
}(std::make_integer_sequence<T, Max - Min>{}));

template <class T, T... Cs> requires (sizeof...(Cs) == 1)
constexpr literal<Cs...> operator""_c() { return {}; }

template <class T, T Min, T Max>
constexpr range<T, Min, Max> operator-(literal<Min>, literal<Max>) { return {}; }

constexpr auto digits = "0"_c - …