技术周总结 11.11~11.17 周日(Js JVM XML)

一、11.11 周一

1.1）问题01：js中的prompt弹窗区分出来用户点击的是 确认还是取消

在 JavaScript 中，prompt 方法用于显示一个对话框，提示用户输入一些文本。该方法会返回用户输入的文本，如果用户点击 “确定” 按钮；如果用户点击 “取消” 按钮或关闭对话框，则返回 null。

因此，通过检查 prompt 方法的返回值是否为 null，可以区分用户是点击了 “确定” 还是 “取消”。

以下是一个示例代码：

var userInput = prompt("请输入一些内容：");

if (userInput !== null) {
    console.log("用户点击了确认，输入的内容是：" + userInput);
} else {
    console.log("用户点击了取消或关闭了对话框");
}

在这个示例中：

• 如果用户点击 “确定” 并输入了一些文本，userInput 将包含用户输入的内容。
• 如果用户点击 “取消” 或关闭了对话框，userInput 将为 null。

通过检查 userInput 是否为 null，可以确定用户是点击了 “确定” 还是 “取消”。

进一步示例

下面是一个更详细的示例，包括对用户输入的进一步处理：

var userInput = prompt("请输入您的名字：");

if (userInput !== null) {
    if (userInput.trim() === "") {
        console.log("用户点击了确认，但没有输入任何内容");
    } else {
        console.log("用户点击了确认，输入的名字是：" + userInput);
    }
} else {
    console.log("用户点击了取消或关闭了对话框");
}

在这个示例中：

• 如果用户点击 “确定” 并输入了一些文本，代码会进一步检查用户输入的内容是否为空。
• 如果用户输入的内容为空（仅包含空格），将输出相应的信息。
• 如果用户输入了一些有效的文本，将输出用户输入的内容。
• 如果用户点击 “取消” 或关闭了对话框，将输出相应的信息。

通过这种方式，可以更精确地处理用户在 prompt 对话框中的操作。

1.2）问题02：在 prompt弹窗弹出时默认给弹窗中写入一些内容

是的，您可以在 prompt 弹窗弹出时提供一个默认值，这个默认值会显示在输入框中。用户可以选择编辑这个默认值或直接点击确认按钮。

prompt 方法的语法如下：

prompt(text, defaultText);

• text: 显示在提示框中的文本。
• defaultText: 输入框中显示的默认值（可选）。

以下是一个示例代码，展示了如何在 prompt 弹窗中设置默认值：

var defaultName = "请输入您的名字";
var userInput = prompt("请填写您的名字：", defaultName);

if (userInput === null) {
    console.log("用户点击了取消或关闭了对话框");
} else if (userInput.trim() === "" || userInput === defaultName) {
    console.log("用户点击了确认，但没有输入任何有效内容");
} else {
    console.log("用户点击了确认，输入的名字是：" + userInput);
}

在这个示例中：

• defaultName 是输入框中显示的默认值。
• 如果用户点击了“取消”按钮或关闭了对话框，userInput 将为 null。
• 如果用户点击了“确认”按钮但没有修改默认值或输入了空白内容，代码会输出相应的信息。
• 如果用户点击了“确认”按钮并输入了一些有效内容，代码会输出用户输入的内容。

通过这种方式，可以在 prompt 弹窗中显示默认值，并正确处理用户的不同操作。

二、11.12 周二

2.1) 问题02: 详解JVM中的本地方法栈

在Java虚拟机（JVM）中，本地方法栈（Native Method Stack）与Java方法栈（Java Method Stack）相对应，用于支持本地方法（通常是用C或C++等语言编写的代码）的执行。本地方法栈主要负责处理Java程序调用非Java语言编写的方法（如JNI接口方法）时的内存管理。

本地方法栈的主要特点

1. 线程私有：每个线程都有自己的本地方法栈，是线程私有的。这意味着不同线程之间的数据不会相互影响，保证了线程安全。

2. 存储结构：本地方法栈中存储的信息类似于Java方法栈，主要包括局部变量表、操作数栈、动态链接和返回地址等信息。不过，由于本地方法的实现不受Java虚拟机规范的约束，因此其具体实现细节可能因不同的JVM实现而异。

3. 异常处理：如果本地方法执行过程中出现了错误，比如内存溢出等，可能会抛出java.lang.StackOverflowError或java.lang.OutOfMemoryError等异常。

4. 与Java方法栈的区别：Java方法栈主要用于执行Java字节码指令，而本地方法栈则用于执行本地方法。两者在功能上有所区分，但在实际使用中，它们通常需要协同工作来完成任务。

5. 栈帧（Stack Frame）：当一个本地方法被调用时，会在本地方法栈中创建一个新的栈帧。这个栈帧包含了该方法运行时所需的所有信息，如参数、局部变量等。

6. 栈大小：本地方法栈的大小可以是固定的，也可以根据需要动态调整。但是，如果本地方法栈所需的内存超过了JVM为其分配的空间，那么就会抛出StackOverflowError。

本地方法栈的作用

• 跨语言调用：本地方法栈允许Java程序调用其他语言编写的函数，这对于集成现有的C/C++库非常有用。
• 性能优化：对于一些计算密集型的任务，通过本地方法栈调用本地代码可以提高程序的执行效率。
• 访问底层资源：通过本地方法栈，Java程序可以直接访问操作系统级别的资源，如文件系统、网络等，这为Java程序提供了更强大的功能。

总结

本地方法栈是JVM的一个重要组成部分，它使得Java应用程序能够调用非Java语言编写的代码，从而扩展了Java的应用范围和能力。然而，由于本地方法栈的使用涉及到跨语言编程，因此在使用时需要注意兼容性和安全性问题。

三、11.13 周三

3.1）问题01： 下面的 java中 catch中的 num变量值是多少？

String num = "";
try{
	num = "失败了";
	int my = 1 / 0;
}catch(Exception e) {
	num += "";
}

在给出的 Java 代码片段中，catch 块中变量 num 的值是由 try 块中的异常控制流决定的。我们可以一步一步分析代码的执行流程。

首先，代码如下：

String num = "";
try{
    num = "失败了";
    int my = 1 / 0;
}catch(Exception e) {
    num += "";
}

1. 初始化：

   String num = "";
   

   变量 num 被初始化为空字符串。

2. 进入 try 块：

   try {
       num = "失败了";
       int my = 1 / 0;
   }
   

   • num 被赋值为 "失败了"。
   • 接下来，程序尝试执行 int my = 1 / 0;，这是一个除以零的操作，会引发 ArithmeticException 异常。

3. 异常发生：
   由于 int my = 1 / 0; 导致 ArithmeticException 异常，程序跳过剩余的 try 块代码，直接进入 catch 块。

4. 进入 catch 块：

   catch(Exception e) {
       num += "";
   }
   

   • 异常被捕获，执行 num += "";，这实际上是将空字符串追加到 num 末尾，因此 num 的值保持不变，仍然是 "失败了"。

因此，在 catch 块执行完毕后，num 的值是 "失败了"。

为了更明确地说明这一点，可以使用以下代码打印 num 的值：

String num = "";
try {
    num = "失败了";
    int my = 1 / 0;
} catch (Exception e) {
    num += "";
}
System.out.println(num); // 输出 "失败了"

这段代码的输出将是 "失败了"。

四、11.14 周四

4.1）问题01：xml中标签中的内容为null和空字符串分别怎么表示？

在 XML 中，标签的内容为空字符串和 null 值的表示方法有所不同。以下是如何在 XML 中表示这两种情况：

1. 空字符串：
   如果标签的内容是空字符串，可以直接将标签的内容设置为空。例如：

   <example></example>
   

   或者：

   <example/>
   

   这两种表示方式在 XML 中都是合法的，表示标签 example 的内容为空字符串。

2. null 值：
   在 XML 中没有直接的方式表示 null 值。通常表示 null 值的方法是通过省略标签或者使用一个特殊的属性或子标签来表示。例如，可以使用一个属性来表示该标签的值为 null：

   <example xsi:nil="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>
   

   这种方式使用了 XML Schema Instance (xsi) 命名空间中的 nil 属性来表示标签 example 的内容为 null。

在您的 Java 代码中，您可以使用 XStream 库来生成 XML。在生成 XML 时，可以根据具体情况自定义 null 和空字符串的表示方式。以下是一个示例，展示如何使用 XStream 库来处理 null 和空字符串：

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.thoughtworks.xstream.io.xml.XmlFriendlyNameCoder;

public class Example {
    public static void main(String[] args) {
        MyClass myObject = new MyClass();
        myObject.setEmptyString("");
        myObject.setNullValue(null);

        XStream xstream = new XStream(new DomDriver("UTF-8", new XmlFriendlyNameCoder("_-", "_")));
        xstream.alias("example", MyClass.class);
        xstream.useAttributeFor(MyClass.class, "nullValue");
        xstream.registerConverter(new NullValueConverter());

        String xml = xstream.toXML(myObject);
        System.out.println(xml);
    }
}

class MyClass {
    private String emptyString;
    private String nullValue;

    public String getEmptyString() {
        return emptyString;
    }

    public void setEmptyString(String emptyString) {
        this.emptyString = emptyString;
    }

    public String getNullValue() {
        return nullValue;
    }

    public void setNullValue(String nullValue) {
        this.nullValue = nullValue;
    }
}

class NullValueConverter extends com.thoughtworks.xstream.converters.basic.AbstractSingleValueConverter {
    @Override
    public boolean canConvert(Class type) {
        return type.equals(String.class);
    }

    @Override
    public String toString(Object obj) {
        return obj == null ? null : obj.toString();
    }

    @Override
    public Object fromString(String str) {
        return str;
    }

    @Override
    public void marshal(Object source, com.thoughtworks.xstream.io.HierarchicalStreamWriter writer, com.thoughtworks.xstream.converters.MarshallingContext context) {
        if (source == null) {
            writer.addAttribute("xsi:nil", "true");
        } else {
            writer.setValue(source.toString());
        }
    }

    @Override
    public Object unmarshal(com.thoughtworks.xstream.io.HierarchicalStreamReader reader, com.thoughtworks.xstream.converters.UnmarshallingContext context) {
        if ("true".equals(reader.getAttribute("xsi:nil"))) {
            return null;
        } else {
            return reader.getValue();
        }
    }
}

在这个示例中，NullValueConverter 用于处理 null 值的转换，使用 xsi:nil="true" 来表示 null，而空字符串则直接表示为空标签内容。这样生成的 XML 可以正确表示 null 和空字符串的区别。

注意：这里使用了 XmlFriendlyNameCoder 以确保 XML 的标签和属性名称符合 XML 的命名规则。

简单来说，空字符串的话，xml中是标签之间内容为空，或者单闭合标签就行，为null的话，直接没有这个标签就行，或者额外 nil的语法指定

4.2) 怎么编写一个浏览器插件？

编写一个浏览器插件（通常称为扩展程序）可以分为几个步骤。这里以Google Chrome为例，介绍如何创建一个简单的浏览器扩展程序。其他基于Chromium的浏览器如Microsoft Edge也支持类似的扩展程序开发流程。

1. 确定需求

首先明确你的插件要实现什么功能，比如自动填充表单、改变网页样式、添加快捷操作等。

2. 设计用户界面

根据功能需求设计用户界面。这可能包括工具栏图标、弹出窗口、选项页面等。

3. 编写代码

浏览器插件主要使用HTML、CSS和JavaScript来构建。以下是一些基本组件：

• manifest.json：这是每个Chrome扩展程序都必须包含的一个文件，它定义了扩展的基本信息和权限。
• 背景脚本：用于处理事件监听和后台逻辑。
• 内容脚本：可以访问和修改网页内容。
• 弹出窗口：用户点击浏览器动作时显示的小窗口。
• 选项页面：允许用户配置插件的行为。

示例 manifest.json 文件：

{
  "manifest_version": 3,
  "name": "我的第一个插件",
  "version": "1.0",
  "description": "这是一个简单的浏览器插件示例。",
  "permissions": ["activeTab", "storage"],
  "background": {
    "service_worker": "background.js"
  },
  "action": {
    "default_popup": "popup.html",
    "default_icon": {
      "16": "images/icon16.png",
      "48": "images/icon48.png",
      "128": "images/icon128.png"
    }
  },
  "icons": {
    "16": "images/icon16.png",
    "48": "images/icon48.png",
    "128": "images/icon128.png"
  }
}

示例 background.js 背景脚本：

chrome.action.onClicked.addListener((tab) => {
  chrome.scripting.executeScript({
    target: { tabId: tab.id },
    files: ['content.js']
  });
});

示例 content.js 内容脚本：

document.body.style.backgroundColor = 'lightblue';

示例 popup.html 弹出窗口：

<!DOCTYPE html>
<html>
<head>
  <style>
    body { width: 200px; height: 100px; text-align: center; }
  </style>
</head>
<body>
  <h1>你好，世界！</h1>
  <button id="changeColor">改变颜色</button>
  <script src="popup.js"></script>
</body>
</html>

示例 popup.js 弹出窗口脚本：

document.getElementById('changeColor').addEventListener('click', () => {
  chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
    chrome.scripting.executeScript({
      target: { tabId: tabs[0].id },
      function: changeBackgroundColor
    });
  });
});

function changeBackgroundColor() {
  document.body.style.backgroundColor = 'yellow';
}

4. 测试插件

在Chrome中加载你的插件进行测试。打开Chrome的扩展管理页面（chrome://extensions/），启用“开发者模式”，然后点击“加载已解压的扩展程序”按钮，选择你的项目文件夹。

5. 发布插件

当你对插件满意后，可以将其打包并提交到Chrome Web Store。需要注册一个开发者账号，并支付一次性的5美元注册费。

注意事项

• 在开发过程中，确保遵守浏览器的安全策略和隐私政策。
• 如果你的插件需要访问用户的敏感数据或执行特定操作，可能需要向用户请求额外的权限。
• 定期更新你的插件，以修复漏洞和增加新功能。

以上就是创建一个简单浏览器插件的基本步骤。不同类型的插件可能会有更复杂的实现方式，但上述指南应该能帮助你开始构建自己的浏览器插件。

4.3）问题01： java常见的解析xml的jar包

在 Java 中，有许多常见的库可以用来解析和处理 XML 文件。以下是一些常用的 XML 解析库及其特点：

1. JAXP (Java API for XML Processing)：

   • DOM (Document Object Model)：适用于需要对整个 XML 文档进行操作的情况。它将整个 XML 文档加载到内存中，适合文档体积较小的情况。
   • SAX (Simple API for XML)：基于事件驱动的解析方式，不需要将整个文档加载到内存中，适合处理大型 XML 文档。
   • StAX (Streaming API for XML)：基于光标的解析方式，提供了对 XML 文档的逐行处理能力，介于 DOM 和 SAX 之间。

2. DOM4J：

   • 功能强大且灵活，支持 XPath 等高级功能。
   • 适合处理复杂的 XML 文档，支持 DOM、SAX 和 JAXP。
   • 网址：dom4j

3. JDOM：

   • 设计简单，易于使用，专为 Java 开发人员设计。
   • 支持 XPath，并且可以与 SAX 和 DOM 一起使用。
   • 网址：jdom.org

4. XStream：

   • 主要用于将对象序列化为 XML 或从 XML 反序列化为对象。
   • 适合对象-XML 映射的场景。
   • 网址：x-stream.github.io

5. Jackson：

   • 主要用于 JSON 处理，但也支持 XML。
   • 提供了对 XML 的全面支持，可以方便地在 JSON 和 XML 之间转换。
   • 网址：github.com/FasterXML/jackson-dataformat-xml

6. Apache Commons Digester：

   • 通过规则将 XML 数据映射到 Java 对象。
   • 适合从 XML 配置文件中读取数据并将其映射到 Java 对象。
   • 网址：commons.apache.org/proper/commons-digester/

示例代码

下面是一些使用这些库的简单示例代码：

使用 DOM 解析 XML

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

public class DOMExample {
    public static void main(String[] args) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse("example.xml");

        NodeList nodeList = doc.getElementsByTagName("exampleTag");
        for (int i = 0; i < nodeList.getLength(); i++) {
            System.out.println(nodeList.item(i).getTextContent());
        }
    }
}

使用 SAX 解析 XML

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SAXExample {
    public static void main(String[] args) throws Exception {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = factory.newSAXParser();
        parser.parse("example.xml", new ExampleHandler());
    }
}

class ExampleHandler extends DefaultHandler {
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        if (qName.equalsIgnoreCase("exampleTag")) {
            System.out.println("Start Element : " + qName);
        }
    }

    @Override
    public void characters(char ch[], int start, int length) throws SAXException {
        System.out.println("Content : " + new String(ch, start, length));
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        if (qName.equalsIgnoreCase("exampleTag")) {
            System.out.println("End Element : " + qName);
        }
    }
}

使用 DOM4J 解析 XML

import org.dom4j.Document;
import org.dom4j.io.SAXReader;
import java.util.List;
import org.dom4j.Element;

public class DOM4JExample {
    public static void main(String[] args) throws Exception {
        SAXReader reader = new SAXReader();
        Document document = reader.read("example.xml");
        List<Element> elements = document.getRootElement().elements("exampleTag");
        for (Element element : elements) {
            System.out.println(element.getText());
        }
    }
}

使用 JDOM 解析 XML

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;

import java.util.List;

public class JDOMExample {
    public static void main(String[] args) throws Exception {
        SAXBuilder saxBuilder = new SAXBuilder();
        Document document = saxBuilder.build("example.xml");
        Element rootElement = document.getRootElement();
        List<Element> elements = rootElement.getChildren("exampleTag");
        for (Element element : elements) {
            System.out.println(element.getText());
        }
    }
}

这些库各有特点，选择合适的库取决于具体应用场景和需求。