What is the Difference Between Web3 and Web2? - 面试题

In the evolving landscape of the internet, Web2 (represented by platforms such as Facebook and Twitter) and Web3 (centered around decentralized applications like Ethereum and Uniswap) represent two distinct paradigms. Web2 is characterized by centralized architecture, where user data is controlled by the platform; in contrast, Web3 promotes decentralization through blockchain technology, granting users data sovereignty. This distinction is crucial for developers as it directly affects the foundational aspects of data management, authentication, and application design. This article will explore the differences from a technical perspective, incorporating code examples and practical recommendations to help developers apply these concepts in real-world projects.

Core Features of Web2

Web2's core lies in centralized architecture, with its technical implementation relying on a single server or cloud service. User-generated content (UGC) is integrated into the platform via APIs. Key features include:

Centralized Data Storage: User data is controlled by platform owners, such as Twitter's API endpoint /v2/tweets directly managing user tweets. Data access requires authentication tokens, yet the platform can unilaterally modify or delete data.
API-Driven Interaction: Applications rely on RESTful API communication, for example:

javascript
fetch('https://api.twitter.com/2/tweets', {
  headers: {
    'Authorization': `Bearer ${accessToken}`
  }
})
  .then(response => response.json())
  .then(data => console.log(data));

This code calls the Twitter API to fetch tweets, but data ownership is entirely with Twitter.

Centralized Authentication: User identity is managed through platform accounts (e.g., OAuth 2.0), leading to privacy risks. For instance, users cannot control third-party usage of their data.

Web2's advantage lies in high development efficiency and smooth user experience, but data sovereignty issues are increasingly prominent under regulations like GDPR. Technically, it relies on HTTP protocols and JSON data formats, but lacks data persistence mechanisms.

Core Features of Web3

Web3 is centered around decentralization, leveraging blockchain, smart contracts, and distributed storage technologies. Key features include:

Decentralized Architecture: Data is stored on distributed networks (e.g., IPFS or Filecoin), with nodes collaborating to validate transactions. For example, the Ethereum network distributes data via P2P protocols (e.g., libp2p).
User Sovereignty and Data Ownership: Users control assets through private keys, with data managed by the user themselves. For instance, the ERC-721 NFT standard defines non-fungible tokens, with ownership verified on the blockchain:

solidity
// ERC-721 contract snippet
contract ERC721 {
  mapping(uint256 => address) public ownerOf;
  function transferFrom(address _from, address _to, uint256 _tokenId) external {
    require(ownerOf[_tokenId] == _from, "Invalid owner");
    ownerOf[_tokenId] = _to;
  }
}

Users hold private keys to transfer NFTs without relying on centralized platforms.

Smart Contracts as Core: Application logic is encoded as smart contracts (e.g., in Solidity), automatically executed on the blockchain. For example, Uniswap's automated market maker (AMM) contract:

javascript
// Using Ethers.js to interact with Uniswap V2
const contract = new ethers.Contract(
  '0x5C69bB8c2B1883D352cB37cD7e90d0D7333A5E8A',
  ['function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external returns (uint256[] memory amounts)'],
  signer
);
const amounts = await contract.swapExactTokensForTokens(
  1000,
  0,
  ['0xEeeeeEeeeEeEeEeEeEeEeEeEeEeEeEeEeEeE', '0x6B175474E2E464a13d74871C3A13A46A0A2933C1'],
  '0x5e2B39B2c4155bB5a4d20d38b6B71Bc5a184c54a',
  1650000000
);

This code calls the Uniswap contract for token exchange without trusting intermediaries.

Web3's advantage lies in immutable data and user autonomy, but development complexity is high. Technically, it relies on the Ethereum Virtual Machine (EVM), Web3.js/Ethers.js libraries, and distributed storage protocols (e.g., IPFS), with data formats often using ABI (Application Binary Interface) and JSON-RPC.

Technical Comparison

Data Processing

Web2: Data is stored in centralized databases (e.g., PostgreSQL), with queries executed using SQL. For example, user data is retrieved via REST API:

javascript
// Web2 data query example
db.query('SELECT * FROM users WHERE id = ?', [userId], (err, results) => {
  console.log(results);
});

The platform can modify data at any time, leading to privacy issues.

Web3: Data is stored on distributed networks (e.g., IPFS), referenced via hashes. For example, using Web3.js to read IPFS content:

javascript
const ipfs = new IPFS({ host: 'ipfs.io' });
await ipfs.add({ content: 'Hello Web3!' });
console.log(`CID: ${cid}`);

Data is verified on the blockchain, ensuring persistence and verifiability.

Authentication

Web2: Relies on OAuth 2.0 or JWT, with identity information stored on the server. For example, Twitter's authentication process requires server-side validation.
Web3: Uses decentralized identity (DID) and wallets (e.g., MetaMask). For example, users sign messages with their wallet private key:

javascript
const signature = await signer.signMessage('Hello Web3');
console.log(`Signature: ${signature}`);

Identity is controlled by the user, making it tamper-proof.

Transaction Processing

Web2: Transactions are processed via HTTP requests, with no blockchain concept. For example, payment processing is handled by the platform, with data stored on servers.
Web3: Transactions are verified on the blockchain, using Gas fees (Ethereum) or transaction fees. For example, sending ETH:

javascript
const tx = await provider.sendTransaction({
  to: '0xRecipientAddress',
  value: ethers.utils.parseEther('0.1'),
  gasLimit: 21000
});
await tx.wait();
console.log(`Transaction hash: ${tx.hash}`);

Transactions are publicly visible on the blockchain for traceability.

Practical Recommendations

Based on the above analysis, developers should adopt the following strategies:

Choose the appropriate framework:
- Web2: Use Express.js or Django to simplify API development.
- Web3: Adopt Hardhat (for testing) and Next.js (for frontend integration), for example:

javascript
// Next.js + Web3.js example
import { useEffect, useState } from 'react';
import Web3 from 'web3';

export default function Home() {
  const [balance, setBalance] = useState('');

  useEffect(() => {
    const web3 = new Web3(window.ethereum);
    const account = web3.eth.accounts.privateKeyToAccount(privateKey);
    const balance = web3.eth.getBalance(account.address);
    setBalance(balance);
  }, []);

  return <div>Balance: {balance}</div>;
}

Security best practices:
- Web2: Implement HTTPS and input validation to prevent SQL injection.
- Web3: Use smart contract audits (e.g., OpenZeppelin) and testnets (e.g., Goerli).
Migration strategy: Enterprises can transition incrementally:
1. Assess existing data: Extract data using Web2 APIs and migrate to IPFS.
2. Gradually introduce Web3 features: For example, add NFT support to user profiles.
3. User education: Provide wallet integration guides (e.g., MetaMask installation).

Conclusion

The fundamental difference between Web3 and Web2 lies in data sovereignty and architectural design: Web2's centralized architecture facilitates development but sacrifices user control, while Web3's decentralized architecture provides censorship resistance but increases complexity. Technically, Web3 relies on blockchain, smart contracts, and distributed storage, requiring developers to master tools such as Solidity, Web3.js, and IPFS. Despite Web3 still facing challenges in scalability and user experience (e.g., fluctuating Gas fees), its potential lies in building a user-driven internet. In the future, with advancements like ZK-Rollups, Web3 may integrate the advantages of Web2. Developers should embrace Web3 but must balance security and efficiency to achieve a truly decentralized application ecosystem.