rust/c++ 多线程

赚小钱

.

赚小钱

.

老八秘制

c++写爬虫太艹

赚小钱

1. use futures::StreamExt;
   
2. use hyper_tls::HttpsConnector;
   
3. use std::io::Write;
   
4. use hyper::body::HttpBody as _;
   
5. 
   
6. #[tokio::main]
   
7. async fn main() {
   
8.     let u = "https://wallhaven.cc";
   
9.     let cookie = "";
   
10. 
    
11.     crawl(&u, &cookie).await;
    
12. }
    
13. 
    
14. async fn crawl(base: &str, cookie: &str) {
    
15.     let mut next_pager = Some(format!("{}&page=1", base));
    
16.     loop {
    
17.         if next_pager.is_none() {
    
18.             return;
    
19.         }
    
20.         next_pager = process_one(next_pager.as_ref().unwrap(), &cookie).await;
    
21.     }
    
22. }
    
23. 
    
24. async fn process_one(u: &str, cookie: &str) -> Option<String> {
    
25.     let next_pager_url = get_next_page_url(&u, &cookie).await;
    
26.     let body = do_request(&u, &cookie).await;
    
27.     let urls = parse_image_url(&body).await;
    
28.     println!("next: {:?}", next_pager_url);
    
29.     println!("urls: {:?}", urls);
    
30.     for url in urls {
    
31.         if download(&url, &cookie).await {
    
32.             std::thread::sleep(std::time::Duration::from_millis(500));
    
33.         }
    
34.     }
    
35.     next_pager_url
    
36. }
    
37. 
    
38. async fn get_next_page_url(base: &str, cookie: &str) -> Option<String> {
    
39.     let body = do_request(base, cookie).await;
    
40.     /// class selector:
    
41.     /// grammar: .class_name .thumb-listing-page-num
    
42.     let document = scraper::Html::parse_document(&body);
    
43.     // let overlay_close_selector = scraper::Selector::parse("#overlay-close").unwrap();
    
44.     // document.select(&overlay_close_selector).next().map(|overlay| {
    
45.     //     println!("overlay close title: {:?}", overlay.value().attr("title"))
    
46.     // });
    
47.     let next_pager_selector = scraper::Selector::parse(".next").unwrap();
    
48.     document.select(&next_pager_selector).next().map(|next_pager| {
    
49.         // println!("page_num_element: {:?}", next_pager.inner_html());
    
50.         String::from(next_pager.value().attr("href").unwrap())
    
51.     })
    
52. }
    
53. 
    
54. async fn do_request(u: &str, cookie: &str) -> String {
    
55.     let https = HttpsConnector::new();
    
56.     let client = hyper::Client::builder().build::<_, hyper::Body>(https);
    
57.     let request = hyper::Request::get(u).
    
58.         header("Cookie", cookie).
    
59.         body(hyper::Body::empty()).unwrap();
    
60.     let mut response = match client.request(request).await {
    
61.         Ok(response) => response,
    
62.         Err(e) => {
    
63.             println!("do request error: {:?}", e);
    
64.             panic!("");
    
65.         }
    
66.     };
    
67. 
    
68.     let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
    
69.     let str_body: String = unsafe { String::from_utf8_unchecked(body.to_vec()) };
    
70.     str_body
    
71. }
    
72. 
    
73. async fn parse_image_url(body: &str) -> Vec<String> {
    
74.     let document = scraper::Html::parse_document(&body);
    
75.     let preview_selector = scraper::Selector::parse(".preview").unwrap();
    
76.     let urls: Vec<String> = document.select(&preview_selector).filter(|element| {
    
77.         element.value().attr("href").is_some()
    
78.     }).map(|element| {
    
79.         String::from(element.value().attr("href").unwrap())
    
80.     }).collect();
    
81.     urls
    
82. }
    
83. 
    
84. 
    
85. async fn download(address: &str, cookie: &str) -> bool {
    
86.     println!("address: {}", address);
    
87.     let body = do_request(&address, &cookie).await;
    
88.     let selector = r#"id="wallpaper""#;
    
89.     if let Some(index) = body.find(&selector) {
    
90.         let body = &body[index + selector.len()..];
    
91.         if let Some(src_index) = body.find("src") {
    
92.             let body = &body[src_index + 5..];
    
93.             if let Some(end_index) = body.find(r#"""#) {
    
94.                 let src = &body[..end_index];
    
95.                 println!("wallpaper src: {}", src);
    
96.                 let slash_index = match address.rfind('/') {
    
97.                     Some(index) => index,
    
98.                     None => return false,
    
99.                 };
    
100.                 let name = &address[slash_index + 1..];
     
101.                 let name = format!("./output/{}", name);
     
102.                 let path = std::path::Path::new(&name);
     
103.                 if path.exists() {
     
104.                     return false;
     
105.                 }
     
106.                 let image = do_request(&src, &cookie).await;
     
107.                 save(&name, image.as_bytes()).await;
     
108.                 return true;
     
109.             }
     
110.         }
     
111.         return false;
     
112.     }
     
113.     return false;
     
114. }
     
115. 
     
116. async fn save(name: &str, body: &[u8]) {
     
117.     let mut file = std::fs::File::create(name).unwrap();
     
118.     file.write_all(body);
     
119. }
     

复制代码

赚小钱

老八秘制 发表于 2020-5-30 23:10
c++写爬虫太艹

没有，爬虫是 rust 写的。刚把代码补上。

mmld32

赚小钱 发表于 2020-5-30 23:43
没有，爬虫是 rust 写的。刚把代码补上。

问问，这个rust好学吗？c太难了。编译总是逻辑错误。不学编程，不知道自己逻辑不行。

赚小钱

mmld32 发表于 2021-3-13 10:49
问问，这个rust好学吗？c太难了。编译总是逻辑错误。不学编程，不知道自己逻辑不行。

相同难度等级。

mmld32

赚小钱 发表于 2021-3-13 22:32
相同难度等级。

好吧.我还是用最笨的方法,学习python吧.听说python最简单了.只要不是数学不及格,都能过过.我数学刚刚好61.应该不会有问题吧

赚小钱

mmld32 发表于 2021-3-17 01:27
好吧.我还是用最笨的方法,学习python吧.听说python最简单了.只要不是数学不及格,都能过过.我数学刚刚好61 ...

放轻松，没那么难。

mmld32

赚小钱 发表于 2021-3-17 21:59
放轻松，没那么难。

其实吧.写代码本身对于我来说并不是特别难的事情.只要记住格式,基本都能用得了.就算是一些硬是要合成一段的代码,也可以分开拆解,成比较好理解的格式.
就编程语言里面,我个人感觉c是属于比较逻辑清晰的
python最大的问题是我不会用那些库,如果是单纯用原始的python总有一些不清不楚的数学问题,要自己思考的.高中数学,大学数学微积分,这些转化为编程的数学时候,很吃力.
算法这块,我说感觉,没什么希望了.就说需要一些功能性的东西,应用在实际工作中就行.
毕竟现在的计算机技术,就硬件这块,应该说对比当年的c的时代,还是宽裕太多了.内存不够用的问题,基本不存在,唯一比较,让我感觉难搞 的是,c里面对于内存溢出的问题.
还是先学python吧.
思路上,编程应该是都相通的,实现过程不一样而已.