在Ruby中，我们可以使用Mechanize和Nokogiri这两个库来编写一个通用的网络爬虫程序。以下是一个简单的例子：

首先，你需要安装这两个库：

gem install mechanize nokogiri

然后，你可以使用以下代码来创建一个简单的通用网络爬虫：

require 'mechanize'
require 'nokogiri'
 
class GenericCrawler
  def initialize(seed_url)
    @agent = Mechanize.new
    @seed_url = seed_url
  end
 
  def crawl
    page = @agent.get(@seed_url)
    parse_page(page)
  end
 
  private
 
  def parse_page(page)
    doc = Nokogiri::HTML(page.body)
    # 提取页面上的链接并进行爬取
    doc.css('a').each do |link|
      next if link['href'].nil?
 
      url = link['href']
      begin
        page = @agent.get(url)
        puts "Crawled: #{page.uri}"
        parse_page(page)
      rescue Mechanize::ResponseCodeError => e
        puts "Error crawling: #{url} - #{e.response_code}"
      end
    end
  end
end
 
# 使用示例
crawler = GenericCrawler.new('http://example.com')
crawler.crawl

这个爬虫程序会从给定的种子URL开始，然后提取该页面上的所有链接，并递归地对每个链接进行爬取。这个例子只是一个简单的展示，实际的爬虫程序需要根据具体需求进行更复杂的处理。

使用requests库实现一个简单的网络爬虫，可以按照以下步骤进行：

1. 导入requests库。
2. 使用requests.get()方法获取网页内容。
3. 检查响应状态码，确认请求成功。
4. 解析网页内容（例如使用BeautifulSoup）。
5. 提取需要的数据。

以下是一个简单的示例代码，展示如何使用requests获取一个网页的内容并使用BeautifulSoup解析：

import requests
from bs4 import BeautifulSoup
 
# 目标网页URL
url = 'http://example.com'
 
# 发送GET请求
response = requests.get(url)
 
# 检查请求是否成功
if response.status_code == 200:
    # 使用BeautifulSoup解析网页内容
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # 提取数据，例如提取所有的段落
    paragraphs = soup.find_all('p')
    for p in paragraphs:
        print(p.text)
else:
    print(f"请求失败，状态码：{response.status_code}")

确保在使用前安装了requests和beautifulsoup4库：

pip install requests
pip install beautifulsoup4

这个例子仅用于说明如何使用requests和BeautifulSoup进行基本的网页爬取操作，实际爬虫项目可能需要处理更复杂的情况，如处理Cookies、Session管理、反爬虫策略、异步请求等。

# 导入所需模块
import requests
from bs4 import BeautifulSoup
 
# 发送网络请求获取页面内容
url = 'https://www.example.com'
response = requests.get(url)
 
# 检查请求是否成功
if response.status_code == 200:
    # 使用BeautifulSoup解析页面内容
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # 打印页面的HTML头部信息
    print(soup.prettify()[:1000])
    
    # 获取并打印标题
    print(soup.title.string)
    
    # 获取并打印所有的段落
    for p in soup.find_all('p'):
        print(p.text)
else:
    print("网络请求失败，状态码:", response.status_code)

这段代码使用了requests库来发送网络请求，获取网页内容，并使用BeautifulSoup库来解析HTML。然后，它打印了页面的前1000个字节以展示HTML的头部信息，标题，以及页面中的所有段落文本。如果请求失败，它会打印状态码。这个例子展示了如何开始使用Python进行网络爬虫，并且是理解和应用网页内容提取的基础。

import scrapy
 
class MySpider(scrapy.Spider):
    name = 'myspider'
    allowed_domains = ['example.com']
    start_urls = ['http://example.com/pages.html']
 
    def parse(self, response):
        # 提取页面中的所有链接并进一步爬取
        for href in response.css('a::attr(href)').getall():
            yield response.follow(href, self.parse)
 
        # 提取页面中的特定数据
        for item in response.css('div.item'):
            yield {
                'title': item.css('a.title::text').get(),
                'link': item.css('a::attr(href)').get(),
                'desc': item.css('p.desc::text').get(),
            }

这个简单的爬虫示例定义了一个名为myspider的爬虫，它将从example.com域名中的起始URL http://example.com/pages.html开始爬取。在parse方法中，它提取了页面中的所有链接，并递归地对每个链接进行爬取，同时提取页面上的数据项，包括标题、链接和描述。这个例子展示了Scrapy的基本用法，是学习Scrapy的一个很好的起点。

以下是一个使用Python的requests和beautifulsoup库爬取豆瓣电影TOP250的示例代码：

import requests
from bs4 import BeautifulSoup
import csv
 
# 豆瓣电影TOP250的页面URL
def get_pages(url):
    pages = []
    for i in range(10):
        page_url = f'{url}?start={i*25}'
        pages.append(page_url)
    return pages
 
# 解析页面，获取电影信息
def parse_page(url):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        return response.text
 
# 保存数据
def save_data(data, filename):
    with open(filename, 'w', newline='', encoding='utf-8') as file:
        writer = csv.writer(file)
        for item in data:
            writer.writerow(item)
 
# 提取电影信息
def extract_data(soup):
    data = []
    for item in soup.find_all('div', class_='info'):
        movie_name = item.find('div', class_='hd').a.text
        rating_score = item.find('div', class_='star').text
        quote = item.find('div', class_='inq').text if item.find('div', class_='inq') else ''
        data.append([movie_name, rating_score, quote])
    return data
 
# 主函数
def main():
    base_url = 'https://movie.douban.com/top250'
    pages = get_pages(base_url)
    movie_data = []
    for page in pages:
        html = parse_page(page)
        soup = BeautifulSoup(html, 'html.parser')
        movie_data.extend(extract_data(soup))
    save_data(movie_data, 'douban_top250.csv')
 
if __name__ == '__main__':
    main()

这段代码首先定义了获取页面URL的函数、页面解析的函数、数据保存的函数以及数据提取的函数。主函数main()则是这些功能的组合使用，实现了爬取豆瓣TOP250电影信息并保存到CSV文件的完整流程。在运行代码前，请确保已安装requests和beautifulsoup4库。

Scrapy是一个用Python编写的开源爬虫框架，用于抓取网站并提取结构化数据。以下是一个简单的Scrapy项目创建和运行的例子：

首先，安装Scrapy：

pip install scrapy

创建一个新的Scrapy项目：

scrapy startproject myspider

进入项目目录，创建一个爬虫：

cd myspider
scrapy genspider example example.com

这将会创建一个名为example的爬虫，用于抓取example.com。

编辑爬虫文件example.py以提取所需数据：

import scrapy
 
class ExampleSpider(scrapy.Spider):
    name = 'example'
    allowed_domains = ['example.com']
    start_urls = ['http://example.com/']
 
    def parse(self, response):
        # 提取数据的示例方法，需要根据实际网站结构进行修改
        for title in response.css('.product_title::text').getall():
            yield {'title': title}

运行爬虫：

scrapy crawl example

这将会启动爬虫，并将抓取的数据输出到控制台或者保存到指定文件。

以下是一个简单的Python爬虫示例，使用requests和BeautifulSoup库来爬取当当网Top 500书籍信息，并使用PyCharm作为IDE。

首先，确保安装了requests和beautifulsoup4库：

pip install requests beautifulsoup4

然后，在PyCharm中创建一个新的Python文件，并输入以下代码：

import requests
from bs4 import BeautifulSoup
 
def get_top_books(url):
    response = requests.get(url)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        books = soup.find_all('ul', class_='bang_list clearfix')
        for book in books:
            yield {
                'name': book.find('a', class_='name').text.strip(),
                'comment': book.find('p', class_='comment').text.strip(),
                'author': book.find('p', class_='author').text.strip(),
                'rating': book.find('p', class_='rating').text.strip(),
            }
 
def main():
    base_url = 'http://bang.dangdang.com/books/bestsellers/01.00.00.00.00.00-recent7-0-0-1-'
    for page in range(1, 11):  # 10 pages
        url = f'{base_url}{page}'
        for book in get_top_books(url):
            print(book)
 
if __name__ == '__main__':
    main()

这段代码定义了两个函数：get_top_books用于从指定URL获取书籍信息，main函数用于迭代10个页面，并打印每本书的信息。

请注意，对于爬取的数据，您需要遵守当当网的robots.txt协议，并尊重版权及隐私权利人的权益。此外，过度频繁的爬取可能会触犯法律，请合法使用爬虫，不进行数据挖掘或者用于商业目的。

在Node.js中创建一个简单的爬虫，你可以使用axios来发送HTTP请求，以及cheerio来解析返回的HTML内容。以下是一个简单的例子，展示了如何抓取一个网页上的所有链接。

首先，你需要安装所需的包：

npm install axios cheerio

然后，你可以使用以下代码创建你的爬虫：

const axios = require('axios');
const cheerio = require('cheerio');
 
async function fetchLinks(url) {
  try {
    const { data } = await axios.get(url);
    const $ = cheerio.load(data);
    const links = [];
 
    $('a').each((i, link) => {
      const href = $(link).attr('href');
      if (href) {
        links.push(href);
      }
    });
 
    console.log(links);
  } catch (error) {
    console.error('An error occurred:', error);
  }
}
 
// 使用示例
const url = 'https://example.com'; // 替换为你想抓取的网址
fetchLinks(url);

这段代码会抓取指定网页上的所有<a>标签的href属性，并将它们打印出来。你可以根据需要修改选择器和处理逻辑来抓取不同的内容。

import requests
from bs4 import BeautifulSoup
import os
 
# 定义一个函数来下载和解析网页
def download_and_parse(url, filename):
    # 使用requests下载网页内容
    response = requests.get(url)
    # 检查请求是否成功
    if response.status_code == 200:
        # 解析网页内容
        soup = BeautifulSoup(response.text, 'html.parser')
        # 返回解析后的内容
        return soup
    else:
        return None
 
# 定义一个函数来保存解析后的内容到文件
def save_to_file(content, filename):
    # 创建一个文件对象来写入内容
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(str(content))
 
# 定义一个函数来创建目录，如果目录不存在的话
def create_directory_if_not_exists(directory):
    if not os.path.exists(directory):
        os.makedirs(directory)
 
# 定义目标网页URL
url = 'https://example.com'
# 定义要保存内容的目录和文件名
directory = 'downloaded_webpages'
filename = 'index.html'
# 创建目录
create_directory_if_not_exists(directory)
# 完整的文件路径
filepath = os.path.join(directory, filename)
# 下载和解析网页
parsed_content = download_and_parse(url, filepath)
# 保存内容到文件
if parsed_content is not None:
    save_to_file(parsed_content.prettify(), filepath)
    print(f'网页内容已经被下载和保存到 {filepath}')
else:
    print('下载网页失败')

这段代码首先定义了一个函数download_and_parse来使用requests库下载网页内容，并使用BeautifulSoup进行解析。然后定义了一个函数save_to_file来将解析后的内容保存到文件。接着定义了一个目标URL，并使用这些函数来下载和保存网页内容。最后，如果网页内容成功下载，它会以格式化（prettified）的形式输出到文件。

以下是一个简单的Python异步爬虫示例，用于爬取微博上的视频信息。请注意，实际爬取数据时需要遵守相关法律法规及微博的使用条款，避免违规操作。

import asyncio
import aiohttp
import logging
 
logging.basicConfig(level=logging.INFO)
 
async def fetch_video_info(session, url):
    async with session.get(url) as response:
        return await response.text()
 
async def main():
    async with aiohttp.ClientSession() as session:
        video_urls = [
            'https://weibo.com/p/1003061933322349061525',  # 微博视频链接示例
            # ... 其他视频链接
        ]
        tasks = [fetch_video_info(session, url) for url in video_urls]
        results = await asyncio.gather(*tasks)
        for result in results:
            logging.info('Video info: %s', result)
 
if __name__ == '__main__':
    asyncio.run(main())

这段代码使用了aiohttp库来进行异步HTTP请求，这是处理Python异步操作的一个常用库。代码中的fetch_video_info函数用于获取指定微博视频的信息，main函数中使用列表推导式创建了一系列的异步任务，并使用asyncio.gather协程来并发执行它们。

请根据实际情况替换video_urls列表中的微博视频链接，并确保遵守相关法律法规以及微博平台的使用条款。