不会还有人在传统网页定位修改,看我用一行JS代码让你的网页变为可编辑

请添加图片描述

不会还有人在传统网页定位修改,看我用一行JS代码让你的网页变为可编辑


🌟嗨,我是LucianaiB

🌍 总有人间一两风,填我十万八千梦。

🚀 路漫漫其修远兮,吾将上下而求索。


目录

  1. 传统网页定位修改
  2. 一行 JS 代码,解锁网页编辑的“魔法”
  3. 传统方法 vs 一行 JS 代码:效率与趣味的完美对决
  4. Document 的 designMode 属性
  5. 总结

传统网页定位修改

考研结束的那段时间,我在闲鱼上看到了一个让人哭笑不得的商品——修改考研成绩。当然,这种修改只是自己骗自己罢了。不过,这种行为背后的想法倒也挺有意思:通过这种方式让家长觉得成绩离国家线还差一点,从而支持继续二战。学习永远是前进的动力,这种“小把戏”虽然不靠谱,但也体现了对学习的执着。

在这里插入图片描述

当时看到这个商品,我瞬间就明白了他们是怎么操作的。下面,我就以修改知乎粉丝数量为例,给大家演示一下这种传统网页定位修改的方法。

这里的话是已修改我知乎的粉丝数量为具体例子:

首先,我们打开个人网站

在这里插入图片描述

一开始,我的粉丝数量是 0。

接着,按下键盘右上角的 F12 键,打开浏览器开发者工具。在开发者工具的侧边栏左上角,点击箭头图标,然后点击页面上的粉丝数量位置,就能定位到对应的源码了。

在这里插入图片描述

将粉丝数量修改为 10000,按下 Enter 键,修改就完成了(此时可以关闭开发者工具)。看,粉丝数量瞬间“暴涨”!

在这里插入图片描述

这种传统方法虽然简单,但只能修改一个位置的内容,而且每次修改都需要重复操作,效率很低。

一行 JS 代码,解锁网页编辑的“魔法”

有没有一种更高效、更有趣的方法,让整个网页都变得可编辑呢?答案是肯定的!只需要在浏览器控制台输入一行代码,就能让网页瞬间变身。

打开浏览器控制台(按下 F12 键),在控制台中输入以下代码并按下回车:

document.designMode = "on";

打开浏览器控制台(F12),在控制台复制粘贴这行代码,回车即可。

在这里插入图片描述

此时,整个网页都变成了可编辑状态!你可以像在富文本编辑器中一样,随意修改网页上的任何内容。比如,我可以把“开始创造”的按钮复制到页面上方。

在这里插入图片描述

当你玩够了,想关闭这个功能时,只需要在控制台输入以下代码:

document.designMode = "off";

在这里插入图片描述

传统方法 vs 一行 JS 代码:效率与趣味的完美对决

传统网页定位修改方法只能修改一个位置的内容,而且操作繁琐,效率低下。而通过一行 JS 代码,整个网页都变成了可编辑状态,你可以随心所欲地修改任何内容,无论是文字、图片还是布局,都能轻松搞定。这种对比,简直就像是一场“魔法”与“手工”的对决,孰优孰劣,一目了然。

Document的designMode 属性

Document 的 designMode 属性控制整个文档是否可编辑。你可以使用它使网页上的所有内容都可编辑,就像在富文本编辑器中一样。

以下是关于 designMode 属性的关键信息:

  • 值: designMode 接受两个字符串值:
    • "on":启用设计模式,使文档可编辑。
    • "off":禁用设计模式,使文档不可编辑(默认状态)。
  • 用法: 你可以通过 JavaScript 设置 designMode 属性:
ondocument.designMode = “on”; // 启用设计模式使文档可编辑。
offdocument.designMode = “off”; // 禁用设计模式使文档不可编辑(默认状态)
document.designMode = "on"; // 启用设计模式
document.designMode = "off"; // 禁用设计模式
  • 浏览器兼容性: designMode 在大多数现代浏览器中都受支持。
  • 实际应用:
    • 富文本编辑器: designMode 可以用于创建简单的富文本编辑器。
    • 网页内容编辑: 可以用来在浏览器中直接编辑网页内容(例如,用于快速原型设计或内容修改)。
    • 用户生成内容: 允许用户直接在网页上创建和编辑内容。
  • 注意事项:
    • 修改 designMode 不会持久保存。刷新页面后,更改将丢失。
    • designMode 使整个文档可编辑。如果只想让部分内容可编辑,应该使用 contentEditable 属性。

全文总结

在当今数字化时代,网页内容的修改和编辑是许多开发者和用户常见的需求。传统的网页定位修改方法虽然简单,但效率低下,只能逐个修改元素,且操作繁琐。相比之下,通过一行简单的 JavaScript 代码,可以将整个网页变为可编辑状态,极大地提高了效率和趣味性。

传统网页定位修改方法通常需要通过浏览器开发者工具(F12)来定位和修改网页元素。以修改知乎粉丝数量为例,用户需要打开开发者工具,定位到粉丝数量的源码,然后手动修改其值。这种方法虽然直观,但每次只能修改一个位置,且需要重复操作,效率较低。

而通过一行 JS 代码,可以实现整个网页的可编辑状态。只需在浏览器控制台输入 document.designMode = "on",网页上的所有内容都将变为可编辑状态,用户可以像在富文本编辑器中一样自由修改文字、图片和布局。这种方法不仅高效,还能激发用户的创造力,让网页编辑变得更加有趣。

document.designMode 属性是实现这一功能的关键。它接受两个值:"on""off",分别用于启用和禁用设计模式。启用设计模式后,整个文档变为可编辑状态;禁用后,恢复默认的不可编辑状态。这一属性在大多数现代浏览器中都受支持,具有广泛的应用场景,如创建富文本编辑器、快速原型设计和用户生成内容等。

然而,需要注意的是,designMode 的修改不会持久保存,刷新页面后更改将丢失。如果只想让部分内容可编辑,应该使用 contentEditable 属性。

总之,传统网页定位修改方法虽然简单,但效率低下。而通过一行 JS 代码,可以将整个网页变为可编辑状态,极大地提高了效率和趣味性。document.designMode 属性为网页编辑提供了强大的支持,让网页编辑变得更加灵活和高效。

示例代码:使用 document.designMode 实现网页可编辑功能

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Editable Document</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            text-align: center;
            margin: 50px;
        }
        #content {
            margin-top: 20px;
            padding: 20px;
            border: 1px solid #ccc;
            border-radius: 5px;
        }
    </style>
</head>
<body>
    <h1>Editable Document Example</h1>
    <p>Click the button to make the document editable.</p>
    <button onclick="makeEditable()">Make Editable</button>
    <button onclick="makeNonEditable()">Make Non-Editable</button>
    <div id="content">
        <p>This is a paragraph that you can edit.</p>
        <p>Try changing the text or adding new elements.</p>
    </div>

    <script>
        function makeEditable() {
            document.designMode = "on";
        }

        function makeNonEditable() {
            document.designMode = "off";
        }
    </script>
</body>
</html>

嗨,我是LucianaiB。如果你觉得我的分享有价值,不妨通过以下方式表达你的支持:👍 点赞来表达你的喜爱,📁 关注以获取我的最新消息,💬 评论与我交流你的见解。我会继续努力,为你带来更多精彩和实用的内容。

点击这里👉LucianaiB ,获取最新动态,⚡️ 让信息传递更加迅速。

好的,我将修改你的 `UNet` 模型,使其只有一层编码器和解码器,并保留其他部分不变。以下是修改后的完整代码: ```python import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torch.utils.data import Dataset, DataLoader from torchvision import transforms from PIL import Image import os import argparse import glob import matplotlib.pyplot as plt from tqdm import tqdm import numpy as np class UNet(nn.Module): def __init__(self): super(UNet, self).__init__() self.encoder = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=2, stride=2) ) self.decoder = nn.Sequential( nn.ConvTranspose2d(64, 3, kernel_size=2, stride=2), nn.Sigmoid() ) def forward(self, x): x = self.encoder(x) x = self.decoder(x) return x class AttentionBlock(nn.Module): def __init__(self, F_g, F_l, F_int): super(AttentionBlock, self).__init__() self.W_g = nn.Sequential( nn.Conv2d(F_g, F_int, kernel_size=1, stride=1, padding=0, bias=True), nn.BatchNorm2d(F_int) ) self.W_x = nn.Sequential( nn.Conv2d(F_l, F_int, kernel_size=1, stride=1, padding=0, bias=True), nn.BatchNorm2d(F_int) ) self.psi = nn.Sequential( nn.Conv2d(F_int, 1, kernel_size=1, stride=1, padding=0, bias=True), nn.BatchNorm2d(1), nn.Sigmoid() ) self.relu = nn.ReLU(inplace=True) def forward(self, g, x): g1 = self.W_g(g) x1 = self.W_x(x) psi = self.relu(g1 + x1) psi = self.psi(psi) return x * psi class AttentionUNet(nn.Module): def __init__(self): super(AttentionUNet, self).__init__() self.encoder1 = self.conv_block(3, 64) self.bottleneck = self.conv_block(64, 128) self.upconv1 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2) self.att1 = AttentionBlock(F_g=64, F_l=64, F_int=32) self.decoder1 = self.conv_block(128, 64) self.final_conv = nn.Conv2d(64, 3, kernel_size=1, stride=1, padding=0) self.sigmoid = nn.Sigmoid() def conv_block(self, in_channels, out_channels): return nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True) ) def forward(self, x): # Encoding e1 = self.encoder1(x) b = self.bottleneck(F.max_pool2d(e1, 2)) # Decoding + Attention Gate d1 = self.upconv1(b) e1 = self.att1(g=d1, x=e1) d1 = torch.cat((e1, d1), dim=1) d1 = self.decoder1(d1) out = self.final_conv(d1) out = self.sigmoid(out) return out class ColorblindDataset(Dataset): def __init__(self, image_dir, mode='train', transform=None): self.image_dir = image_dir self.mode = mode self.transform = transform self.normal_images = glob.glob(image_dir + '/' + mode + '/' + 'origin_image' + '/*') self.recolor_images = glob.glob(image_dir + '/' + mode + '/' + 'recolor_image' + '/' + '*Protanopia*') self.correct_images = glob.glob(image_dir + '/' + mode + '/' + 'correct_image' + '/*') self.normal_images.sort() self.recolor_images.sort() self.correct_images.sort() self.image_pair = [] for index, image in enumerate(self.normal_images): self.image_pair.append([self.normal_images[index], self.recolor_images[index]]) self.image_pair.append([self.correct_images[index], self.normal_images[index]]) def __len__(self): return len(self.normal_images) def __getitem__(self, idx): normal_path, recolor_path = self.image_pair[idx] normal_image = Image.open(normal_path).convert('RGB') recolor_image = Image.open(recolor_path).convert('RGB') if self.transform: normal_image = self.transform(normal_image) recolor_image = self.transform(recolor_image) return normal_image, recolor_image def train_one_epoch(model, dataloader, criterion, optimizer, device): model.train() running_loss = 0.0 for inputs, targets in tqdm(dataloader, desc="Training"): inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step() running_loss += loss.item() epoch_loss = running_loss / len(dataloader) return epoch_loss def validate(model, dataloader, criterion, device): model.eval() val_loss = 0.0 with torch.no_grad(): for inputs, targets in tqdm(dataloader, desc="Validation"): inputs, targets = inputs.to(device), targets.to(device) outputs = model(inputs) loss = criterion(outputs, targets) val_loss += loss.item() val_loss /= len(dataloader) return val_loss def visualize_results(model, dataloader, device, num_images=10): model.eval() inputs, targets = next(iter(dataloader)) inputs, targets = inputs.to(device), targets.to(device) with torch.no_grad(): outputs = model(inputs) outputs = outputs.cpu().numpy() inputs = inputs.cpu().numpy() targets = targets.cpu().numpy() plt.figure(figsize=(15, 10)) for i in range(num_images): plt.subplot(3, num_images, i + 1) plt.imshow(inputs[i].transpose(1, 2, 0)) plt.title("Original") plt.axis('off') plt.subplot(3, num_images, i + 1 + num_images) plt.imshow(targets[i].transpose(1, 2, 0)) plt.title("Colorblind") plt.axis('off') plt.subplot(3, num_images, i + 1 + 2 * num_images) plt.imshow(outputs[i].transpose(1, 2, 0)) plt.title("Reconstructed") plt.axis('off') plt.show() def plot_and_save_losses(train_losses, val_losses, epoch, path='./loss_plots'): if not os.path.exists(path): os.makedirs(path) epochs = np.arange(1, epoch+2) plt.figure(figsize=(10, 5)) plt.plot(epochs, train_losses, label='Training Loss') plt.plot(epochs, val_losses, label='Validation Loss') plt.xlabel('Epoch') plt.ylabel('Loss') plt.title('Training and Validation Losses') plt.legend() plt.savefig(f'{path}/loss_epoch_{epoch+1}.png') plt.close() def main(args): # Data transforms transform = transforms.Compose([ transforms.ToTensor(), transforms.Resize((256, 256)), ]) # Datasets and Dataloaders train_dataset = ColorblindDataset(args.dataset_dir, mode='train', transform=transform) val_dataset = ColorblindDataset(args.dataset_dir, mode='val', transform=transform) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, num_workers=4, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=args.batch_size, num_workers=4, shuffle=False) # Model, Loss, Optimizer device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = UNet().to(device) # 使用简化版的UNet if args.model_pretrained_path: model.load_state_dict(torch.load(args.model_pretrained_path)) print("Successfully load past pretrained weights!!") criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=args.learning_rate) train_losses = [] val_losses = [] # Training and validation loop for epoch in range(args.num_epochs): train_loss = train_one_epoch(model, train_loader, criterion, optimizer, device) val_loss = validate(model, val_loader, criterion, device) train_losses.append(train_loss) val_losses.append(val_loss) print(f'Epoch {epoch + 1}, Training Loss: {train_loss:.4f}, Validation Loss: {val_loss:.4f}') plot_and_save_losses(train_losses, val_losses, epoch) visualize_results(model, val_loader, device) # Save the model torch.save(model.state_dict(), args.model_save_path) if __name__ == "__main__": parser = argparse.ArgumentParser(description="UNet Colorblind Image Reconstruction") parser.add_argument('--dataset_dir', type=str, default='./dataset', help='Path to the dataset directory') parser.add_argument('--batch_size', type=int, default=16, help='Batch size for training and validation') parser.add_argument('--learning_rate', type=float, default=0.01, help='Learning rate for the optimizer') parser.add_argument('--num_epochs', type=int, default=100, help='Number of training epochs') parser.add_argument('--model_save_path', type=str, default='./model_weights/color_blind_model.pth', help='Path to save the trained model') parser.add_argument('--model_pretrained_path', type=str, default='./model_weights/color_blind_model.pth', help='训练好的色盲模拟器模型路径') args = parser.parse_args() main(args) ``` 在这个版本中,`UNet` 类被简化为只有一层编码器和解码器。其余部分保持不变,包括数据集加载、训练循环和验证函数等。希望这能满足你的需求。如果有任何进一步的问题,请随时告诉我!
评论 28
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LucianaiB

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值