Steps for downloading/exporting Excel/PDF files in Postman

1.Create a New Interface

Create a new interface in Postman, file downloads are generally performed using GET requests. If you already have an interface prepared, you can skip this step.

If you need to configure authentication-related fields, you can also do so in the request header under "Headers":

2.Send Request and Download

Once the interface is created, you can click the "Send and Download" button to send the request and download the file upon successful completion.

Alternatively, you can click the "Save response to file" button in the response section below to download the successfully requested file to your local system.

Summary

The steps for downloading or exporting Excel/PDF files in Postman are as follows: create a new interface, make a GET request, and click "Send and Download" or "Save response to file" in the response section to download.

How does Postman request to download/export Excel/PDF files?

The steps for downloading or exporting Excel/PDF files in Postman are as follows: create a new interface, make a GET request, and click “Send and Download” or “Save response to file” in the response section to download.

ZGYAutumn

Learn more:

• How to enable and utilize the Mock server in Postman？
• How to Use Predefined Variables in Postman?

Tests scripts can be written individually for each request or shared at the Collection or Folder level in Postman. The steps to write Tests in Postman are as follows:

1.Create a new request in Postman

Open Postman, create or open a request, then select the "Tests" tab in the top navigation bar of the request editor. In the "Tests" tab, you can write JavaScript code to validate the response.

2.Write the script in Tests

Predefined assertion functions can be used to check different aspects of the response, such as pm.response.to.have.status() to verify the status code, or pm.response.to.have.jsonBody() to check JSON response bodies. Below is a simple example demonstrating how to write a basic Tests script to validate the response status code:

// Check if the response status code is 200
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

3.Send the request and verify the results

After writing tests, click the "Send" button to send the request. Tests will be automatically executed, and the results will be displayed in the "Test Results" panel.

Apart from verifying status codes, there are many other common Tests scripts for validating various aspects of the request. Here are some examples:

1. Check if specific fields are present in the response body:

pm.test("Response body contains expected field", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('field_name');
});

2. Verify if the response time is within the expected range:

pm.test("Response time is less than 500ms", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

3. Ensure that the response header contains specific information:

pm.test("Response header contains expected value", function () {
    pm.response.to.have.header('header_name');
});

4. Check if specific fields in the response body have expected values:

pm.test("Response body field has expected value", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.field_name).to.eql('expected_value');
});

5. Validate if the response body conforms to a specific JSON structure:

pm.test("Response body has expected JSON structure", function () {
    pm.response.to.have.jsonBody('json_schema');
});

6. Verify if the length of an array in the response body matches the expected length:

pm.test("Response body array has expected length", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.array_name).to.have.lengthOf(3);
});

These are some common examples of Tests scripts. You can write custom Tests scripts according to your specific testing requirements. It is recommended to refer to the Postman official documentation for more information on predefined assertion functions and testing techniques.

Summary

Postman's Tests are automatically executed scripts used to validate if request responses meet expectations. They are written in JavaScript and offer predefined assertion functions to check various aspects of responses. Tests can be written for each request or shared at the Collection/Folder level. Besides verifying status codes, Tests can check response bodies, response times, response headers, field values, etc.

What are Postman tests and how to write?

Postman’s Tests are automatically executed scripts used to validate if request responses meet expectations. They are written in JavaScript and offer predefined assertion functions to check various aspects of responses.

ZGYAutumn

Reference：

• Postman Documentation

Learn more:

• How to extract parameters from the response body in Postman Tests?
• How to extract parameters from the request body in Postman Tests?
• 夸克云盘资源分享

Steps for sending a delete request in Postman

1.Create a new interface and set it to a delete request

Open Postman and create a new HTTP request interface.

Then select DELETE from the dropdown menu of request methods. This dropdown menu is located to the left of the URL input box, and usually displays GET when first opened.

2.Fill in the URL and initiate the request

After selecting the delete request in the previous step, fill in the relevant URL address and parameters (request headers, request body, etc.). If the API interface requires any headers, such as authentication tokens or other information, click on the Headers tab and enter the corresponding key-value pairs.

Paths are generally referenced using variables {{}}, but initially, you can also copy the entire path and paste it. After becoming familiar, you can then reference the values in the environment variables. After filling in the relevant information, click "Send" to send the request.

Summary

The steps for sending DELETE requests using Postman are as follows: first, create an interface in Postman and set the request method to DELETE; second, fill in the relevant URL, parameters, and headers; finally, click "Send" to send the request. It is worth noting that paths can use {{}} to reference variables.

How does Postman send a DELETE request?

The steps for sending DELETE requests using Postman are as follows: first, create an interface in Postman and set the request method to DELETE; second, fill in the relevant URL, parameters, and headers; finally, click “Send” to send the request.

ZGYAutumn

Learn more:

• How does Postman request to download/export Excel/PDF files?
• How to enable and utilize the Mock server in Postman？

1.Open the Cookie Manager

Open a project in Postman, then select a request within the project. On the right side of the request tab, next to the "Send" button, you will see a button labeled "Cookies." Click this "Cookies" button to open Postman's cookie manager.

2.Clear Cookie Content

Upon clicking, a window will appear listing all cookies associated with that request. To clear all cookies, you can click the "Clear All Cookies" button at the bottom of the window. If you only want to remove a specific cookie, locate it in the list and click the X icon next to it to delete.

Remember that for the deletion to take effect, you need to send the request afterward. This is one way to clear cookies in Postman.

Additionally, another method is to use the shortcut "Ctrl+Shift+i" to open Postman's built-in browser console. Here, you can also clear global cookies, similar to a browser's console.

Important Note: In some cases, it may be necessary to restart Postman to ensure that cleared cookies are not cached and used again. Also, ensure that you are following the instructions based on the actual interface of your Postman version, as software updates may change the design of the mentioned locations and icons.

3.Confirm Cookie Clearance

After following the above steps, you can send a simple request to verify if the cookies have been cleared. If the previously cached cookies no longer affect the request, then the cookie clear was successful.

Conclusion

Clearing cookies in Postman can be accomplished through simple steps: first, clear all or specific cookies in the Cookie Manager, ensuring effectiveness after sending requests. Another method is to use the shortcut "Ctrl+Shift+i" to open the built-in browser console and clear global cookies. Restarting Postman can ensure that cleared cookies are not cached.

How to clear cookies in Postman?

Clearing cookies in Postman can be accomplished through simple steps: first, clear all or specific cookies in the Cookie Manager, ensuring effectiveness after sending requests.

ZGYAutumn

Reference：

• Postman Documentation

Learn more:

• How to add a Cookie in Postman?
• How to convert timestamps in Postman?

Precautions before clearing Postman cache

• Clearing the cache may delete some important data stored during testing. Please ensure whether backup is needed before clearing.
• Clearing the cache will not delete saved requests and collections, so your data is safe.

How to clear the Postman cache

1.Open the Console

Open the Postman application and at the bottom of the interface, click on the "Console" icon, then click on the right-pointing arrow icon (↗) to open the detailed console interface.

The detailed console interface of Postman is shown as in the image.

2.Clear the Postman cache

Method One:

In the Postman console interface, click on the "Help -> Clear Cache and Reload" option. Postman will then clear the cache and restart.

Method Two:

Another way to clear the cache in Postman is by clicking on "View -> Developer -> Show DevTools" to open a console similar to a browser's, or by using the shortcut "Ctrl+Shift+i" to quickly open it.

Once opened, click on "Application" to enter the management interface, where you can clear the relevant cache.

3.Verify Postman cache clearance:

After completing the above steps, create a simple request to verify whether the cache has been cleared. If the cached data no longer affects the request, then the cache clearance was successful.

Conclusion

Postman is a powerful API testing tool, and managing its cache properly is crucial for ensuring the accuracy of tests. By following the steps outlined above, you can ensure that Postman's working environment is clean, thus safeguarding your API testing work.

How to clear cache in Postman?

In Postman, the cache may contain old environment variables, global variables, or temporary session data, which can sometimes interfere with new request tests. To avoid potential issues, it’s good practice to clear this cache.

ZGYAutumn

Reference：

• Postman Documentation

Learn more:

• How to clear cookies in Postman?
• How to add a Cookie in Postman?

1.Uninstalling the Local Postman

When installing an older version of Postman, it's essential to remove the existing local Postman to avoid unexpected conflicts. If you're using Windows, you can uninstall the current version of Postman from the control panel.

2.Viewing Postman's Historical Versions

To install historical versions of Postman, you can visit their official website to review the descriptions and functionalities of each version. Then, you can select the version you wish to download.

Link: Postman Release Notes

3.Downloading Postman's Historical Versions

Once you've decided on the version you want to download, you can click the links below to download the corresponding historical versions. Currently, historical versions are available only for macOS and Windows systems, as shown below:

For macOS: Postman Old Versions

For Windows: Postman Old Versions

Choose a version and click "Download" to proceed.

Conclusion

In this guide, we've covered the steps to uninstall the local Postman, view historical versions, and download specific versions to avoid conflicts.

How to download history versions in Postman?

In certain scenarios, there may be a need to install and utilize older versions of Postman. This article will outline the steps to uninstall the local Postman application, view historical versions, and download the desired version.

ZGYAutumn

Learn more:

• How to clear cache in Postman?
• How to clear cookies in Postman?

1.Stable Video

1.1 What is "Stable Video"?

"Stable Video" is a video generation tool based on artificial intelligence technology. It can automatically generate exquisite video content based on the text or images you provide. Without any professional video production experience, you can easily create high-quality videos.

1.2 What are the features of "Stable Video"?

1. Text-to-Video: Convert your text content into dynamic video scenes, making it easier for your audience to understand and remember your information.
2. Image-to-Video: Convert your images into dynamic video effects, increasing visual impact and attractiveness.
3. Multiple style choices: Choose different styles and templates according to your needs and brand image to customize unique video content.
4. Video editing tools: Edit, add subtitles, adjust audio, etc., on the generated video to make your video more perfect.

1.3 Use cases

1. Content marketing: Showcase your products or services to potential customers through video to increase brand awareness and sales conversion rates.
2. Social media: Create interesting and engaging video content to attract more attention and shares, expanding your social media influence.
3. Education and training: Produce instructional videos and training videos to provide a more intuitive and vivid learning experience, improving learning effectiveness and engagement.

1.4 Official website

https://www.stablevideo.com/

1.5 Pricing

2.Sora

2.1 Sora Text-to-Video Overview

Sora is a model developed by OpenAI for text-to-video conversion. By teaching AI to understand and simulate motion in the physical world, it aims to train models that can help people solve problems requiring real-world interaction. Sora can generate videos up to one minute in length while maintaining visual quality and adherence to user prompts.

2.2 Sora Product Features

1. Generating Complex Scenes: Sora is capable of generating complex scenes with multiple characters, specific types of motion, and accurate details of themes and backgrounds.
2. Language Understanding: The model deeply understands language, accurately interpreting prompts and generating attention-grabbing characters that express vivid emotions.
3. Creating Multiple Shots: Sora can create multiple shots within a single generated video, accurately preserving characters and visual styles.

2.3 Use cases

1. Security Assessment: Red team members can use Sora to assess critical areas that may pose threats or risks.
2. Feedback from Creative Professionals: Providing access to visual artists, designers, and filmmakers to gather feedback on how to advance the model's usefulness for creative professionals.

2.4 Official Website

https://openai.com/sora

2.5 Pricing

Coming soon.

3.Pika

3.1 What is Pika？

Pika is an AI video generation and editing tool recently launched by the popular artificial intelligence startup Pika Labs. This tool can transform any idea into a video, allowing users to quickly generate videos in styles such as 3D animation, anime, cartoons, and movies by simply inputting text or images.

3.2 Product Features

• Text/Image to Video: Utilize AI to create short, high-quality videos with just a few lines of text input or by uploading images.
• Video to Video: Transform existing videos into different styles, including different characters and objects, while maintaining the structure of the original video.
• Video Aspect Ratio Expansion: Expand the canvas or aspect ratio of videos, such as converting from 9:16 vertical to 16:9 horizontal intelligently. The AI model will predict content beyond the original video boundaries.
• Video Content Alteration: AI edits the content or objects in video frames, such as changing someone's clothes, adding another character, changing the environment, or adding props.

3.3 Official Website

https://pika.art/

3.4 Pricing

4.Runway

4.1 What is 'Runway Gen-2'?

Gen-2 is a multimodal AI system developed by Runway that can generate new videos using text, images, or video clips. It applies the composition and style of images or text prompts to the structure of the source video, achieving realistic and consistent new video synthesis (Video to Video). Alternatively, it can generate entirely new videos using only text prompts (Text to Video). It's like shooting new content without actually shooting anything.

4.2 What features does 'Runway Gen-2' have?

1. Text to Video: Synthesize videos in any style imaginable using only text prompts.

2. Text + Image to Video: Generate videos using driven images and text prompts.

3. Image to Video: Generate videos using only driven images (Variations Mode).

4. Stylization: Apply the style of any image or prompt to each frame of the video.

5. Storyboard: Transform the model into fully stylized and animated renders.

6. Mask: Isolate and modify subjects in videos with simple text prompts.

7. Render: Transform untextured renders into realistic outputs by applying input images or prompts.

8. Customization: Unlock the full potential of Gen-2 by customizing the model for higher fidelity results.

4.3 Use cases

1. Filmmaking: Gen-2 can transform any image, video clip, or text prompt into captivating movie segments, bringing new magic to filmmaking.

2. Video Creation: Whether driven by text prompts or image prompts, Gen-2 assists users in creating videos in various styles.

3. Rendering and Animation: Gen-2 can convert untextured renders into realistic outputs and transform the model into fully stylized and animated renders.

4.4 Official Website

https://research.runwayml.com/gen2

4.5 Pricing

Summary

In the realm of AI-powered video generation tools, Stable Video, Sora, Pika, and Runway Gen-2 stand out as versatile and innovative solutions.

Stable Video offers seamless conversion of text and images into dynamic videos, catering to diverse needs in content marketing, social media, and education.

Sora, developed by OpenAI, boasts the capability of generating complex video scenes with deep language understanding, making it invaluable for security assessment and creative endeavors.

Pika, from Pika Labs, empowers users to effortlessly create videos in various styles, including 3D animation and cartoons, through simple text or image inputs.

Runway Gen-2, a multimodal AI system, revolutionizes video creation with its ability to generate new videos from text, images, or clips, enabling filmmakers, creators, and designers to unlock new possibilities in storytelling and visual expression.

Each tool offers unique features and applications, catering to different user needs and preferences in the ever-evolving landscape of video content creation.

Official Websites:

• Stable Video: https://www.stablevideo.com/
• Sora: https://openai.com/sora
• Pika: https://pika.art/
• Runway Gen-2: https://research.runwayml.com/gen2

4 Best AI Video Generation Tools

A series of remarkable AI video tools such as Stable Video, Sora, Pika, and Runway Gen-2 are changing the way video content creation is done with their powerful features and flexible applications.

ZGYAutumn

Learn more:

• 5 Best AI Text to Speech Tools

Understanding the Back Button

Firstly, we need to understand how the browser's back button works. When you click the back button on a webpage, you're actually navigating backward in the browser's history, returning to previously visited pages.

Requirement Analysis

Why do we need to disable the browser's back button? Imagine you're filling out a lengthy form or editing a long article, and accidentally click the back button, losing all your input! In such cases, disabling the back button becomes essential.

Technical Background

So, how do we disable the back button in JavaScript? Here, we need to grasp some key concepts, such as browser history and how to manage and manipulate this history using JavaScript.

1.Browser History

The browser's history is a list that records the web pages a user has visited in the browser. Each time a user visits a new webpage, its URL is added to the browser's history. By using the browser's forward and back buttons, users can navigate between visited webpages.

2.History Management in JavaScript

JavaScript provides APIs to manage the browser's history. The most commonly used is the History object, which offers a set of methods allowing us to access and manipulate the browser's history:

• history.back(): This method lets the browser navigate back to the previous page in its history.
• history.forward(): This method lets the browser navigate forward to the next page in its history.
• history.go(): This method lets the browser navigate to a specified page in its history.

Using these methods, we can simulate user clicks on the browser's forward and back buttons in JavaScript, thereby controlling the browser's history.

3.Browser Events

Additionally, JavaScript provides events for interacting with the browser. One such event is the popstate event, which is triggered when the browser's history changes (e.g., when the user clicks the forward or back buttons). By listening to the popstate event, we can capture user navigation actions and take appropriate measures, such as disabling the back button if necessary.

Understanding these concepts allows us to better utilize JavaScript to control browser behavior, including functionalities like disabling the back button.

Methods to Disable the Back Button in the Browser

1.Using the History API

The History API allows manipulation of the browser's history, enabling the disabling of the back button. We can simulate disabling the back button by replacing the current history. Here's a simple example code:

// Disable the back button
function disableBackButton() {
    history.pushState(null, null, location.href);
    window.onpopstate = function () {
        history.go(1);
    };
}

// Call the disable back button function
disableBackButton();

In this example, we define a function named disableBackButton. It utilizes the history.pushState() method to replace the current history, making it so that there's no history for the back button to backtrack to. Then, by listening to the window.onpopstate event and calling history.go(1) when the event is triggered, we ensure that when the user clicks the back button, the browser navigates forward again instead of returning to the previous page.

2.Using the popstate Event of the Window Object

Another method is to utilize the popstate event, which is triggered when the browser's history changes. We can listen to this event and prevent the default behavior to disable the back button. Here's example code:

// Disable the back button
function disableBackButton() {
    window.addEventListener('popstate', function (event) {
        history.pushState(null, null, location.href);
    });
}

// Call the disable back button function
disableBackButton();

In this example, we define a function named disableBackButton. It listens to the popstate event and calls history.pushState() to replace the current history when the event is triggered, effectively disabling the back button.

3.Method Comparison

So, what are the differences between these two methods? Using the History API method is more flexible because it allows direct manipulation of the browser's history and precise control over its state. However, it may require more code to implement. On the other hand, using the popstate event method is relatively simple but may not be as flexible since we can only listen to history changes and cannot directly manipulate the history. Therefore, when choosing a method, it's essential to decide based on specific requirements.

Summary

In conclusion, it's feasible to disable the browser's back button using JavaScript, and it can be very useful in certain situations. Whether using the History API or the popstate event, both methods can help us achieve this goal. However, remember to consider various limitations and potential issues when applying these methods!

Reference Links:

• MDN Web Docs: History API
• MDN Web Docs: popstate event

How to Disable Back Button in Browser Using JavaScript？

This article introduces two methods: one is using the browser’s History API, and the other is the popstate event of the Window object.

ZGYAutumn

Learn more:

• How to disable selection options using JavaScript?
• How to convert HTML to plain text using JavaScript?

Introduction to Date Objects in JavaScript

The date object in JavaScript is Date , which allows us to get and set the date and time. Here are some common methods:

// Create a Date object
let now = new Date();

// Get year, month, and date
let year = now.getFullYear();
let month = now.getMonth() + 1; // Note: months start from 0
let date = now.getDate();

// Get hours, minutes, and seconds
let hours = now.getHours();
let minutes = now.getMinutes();
let seconds = now.getSeconds();

The need for date formatting

Date formatting is necessary in various contexts, such as displaying dates on web pages, logging, data processing, etc. We need to format dates flexibly according to different needs.

Basic date formatting methods

Basic date formatting can be achieved through string concatenation or using built-in methods as follows:

// Get current date and time
let now = new Date();

// Get year, month, date, hours, minutes, seconds
let year = now.getFullYear();
let month = now.getMonth() + 1;
let date = now.getDate();
let hours = now.getHours();
let minutes = now.getMinutes();
let seconds = now.getSeconds();

// Format as yyyy-mm-dd
let formattedDate = `${year}-${month < 10 ? '0' + month : month}-${date < 10 ? '0' + date : date}`;

// Format as hh:mm:ss
let formattedTime = `${hours < 10 ? '0' + hours : hours}:${minutes < 10 ? '0' + minutes : minutes}:${seconds < 10 ? '0' + seconds : seconds}`;

console.log("Current date:", formattedDate);
console.log("Current time:", formattedTime);

Advanced tips for date formatting

When dealing with complex date formatting requirements, we can use third-party libraries such as moment.js . Here is a simple usage example:

<!-- Include moment.js -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.29.1/moment.min.js"></script>

<script>
let now = new Date();
// Format date using moment.js
let formattedDate = moment(now).format('YYYY-MM-DD');
let formattedTime = moment(now).format('HH:mm:ss');
console.log(formattedDate);
console.log(formattedTime);
</script>

Summary

Date formatting is a fundamental skill in JavaScript development. By mastering the basic methods and utilizing third-party libraries, we can easily meet various date formatting needs.

Reference link:

• JavaScript Date Object Documentation
• Moment.js documentation
• 夸克云盘资源分享

How to format dates in JavaScript?

This article discusses how to format dates in JavaScript, using both native built-in JavaScript methods and third-party libraries such as moment.js.

ZGYAutumn

Regular Expression Basics

First, let's review the basics of regular expressions. In JavaScript, regular expressions consist of metacharacters, quantifiers, character classes, and more. Metacharacters such as "^", "$", ".", etc., represent the beginning, end, or any character in a string to be matched. Quantifiers like "*", "+", "?", etc., specify the quantity of characters to match, while character classes, denoted by square brackets "[]", match any character from a specified set.

Methods to Add Variables in Regular Expressions

So, how do we add variables to regular expressions in JavaScript? There are two common methods. One is to use the constructor of the RegExp object, passing in string variables to create dynamic regular expressions. The other is to combine regular expression literals with variables, directly inserting variables into the regular expression literal to achieve dynamic matching.

1.Using the Constructor of the RegExp Object

With the constructor of the RegExp object, we can dynamically create regular expressions, thus adding variables flexibly.

Example:

// Create a string containing a variable
var pattern = "apple";
var flags = "gi"; // g: global search, i: case insensitive

// Create a dynamic regular expression using the RegExp constructor
var regex = new RegExp(pattern, flags);

// Test the match
var text = "I have an apple and an APPLE.";
var matches = text.match(regex);
console.log(matches); // ["apple", "APPLE"]

2.Combining Regular Expression Literals with Variables

We can also directly insert variables into regular expression literals to achieve dynamic matching.

Example:

// Create a string containing a variable
var fruit = "apple";
var regex = new RegExp(fruit, "gi"); // g: global search, i: case insensitive

// Combine regular expression literal with variable
var text = "I have an apple and an APPLE.";
var matches = text.match(regex);
console.log(matches); // ["apple", "APPLE"]

Both of these methods enable dynamic regular expressions in JavaScript, allowing us to match content within strings based on the value of variables. The choice between the two depends on personal preference and project requirements.

Considerations

When using regular expressions, we need to be careful of special characters that may cause errors, so extra caution is required when constructing dynamic regular expressions. Additionally, we should consider edge cases and boundary conditions to ensure our regular expressions work correctly. It's best practice to use the constructor of the RegExp object for handling dynamic regular expressions, as it offers more flexibility and safety.

Conclusion

In summary, this article has discussed how to add variables to regular expressions in JavaScript and explored some common use cases. Understanding how to incorporate variables into regular expressions can help us better handle string matching and searching, improving the flexibility and maintainability of our code.

References:

• Mozilla Developer Network (MDN) ：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions

How to Add Variables in Regex JavaScript？

One is to use the constructor of the RegExp object, by passing in string variables to create dynamic regular expressions. The other is to combine regular expression literals with variables, directly inserting variables into the regular expression literal to achieve dynamic matching.

ZGYAutumn

Learn more:

• How to Disable Back Button in Browser Using JavaScript？
• How to disable selection options using JavaScript?

Update System Packages

First, update your package index:

sudo apt update

Install JDK

Jenkins requires a Java environment to run. You can install OpenJDK 17, which is currently the recommended version:

sudo apt install fontconfig openjdk-17-jre

After installation, check the version:

java -version

Add Jenkins Repository

Add the official Jenkins repository to your package manager.First command:

curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee /usr/share/keyrings/jenkins-keyring.asc > /dev/null

Second command:

echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] https://pkg.jenkins.io/debian-stable binary/ | sudo tee /etc/apt/sources.list.d/jenkins.list > /dev/null

Avoid using other signing keys and package repositories (many tutorials lead to errors), as updating the package index may result in errors like:

E: The repository 'https://pkg.jenkins.io/debian-stable binary/ Release' is not signed

Installing Jenkins may also prompt errors such as:

E: Package 'jenkins' has no installation candidate

For detailed explanations, refer to: https://www.jenkins.io/blog/2023/03/27/repository-signing-keys-changing/

Install Jenkins

First, update the package index again:

sudo apt update

Then install Jenkins:

sudo apt install jenkins

Check if Jenkins is installed successfully:

sudo systemctl status jenkins

Start and Enable Jenkins Service

Start the Jenkins service and enable it to start on boot:

sudo systemctl start jenkins
sudo systemctl enable jenkins

Open Firewall Port

Jenkins runs on port 8080 by default. Ensure the firewall allows traffic through this port:

sudo ufw allow 8080
sudo ufw status

Access Jenkins

Open a browser and visit http://your_public_IP:8080. You will see a Jenkins unlock page.

Unlock Jenkins

The first time you access Jenkins, you need to provide an unlock password. You can find this password with the following command:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Copy the displayed password and paste it into the Jenkins unlock page in your browser.

Complete Installation

Follow the Jenkins installation wizard to complete the remaining steps. This includes installing recommended plugins and creating the initial administrator user. With this, you have successfully installed and run Jenkins on your Ubuntu server. You can further configure and manage your Jenkins instance through the Jenkins web interface.

Uninstall Jenkins

Use apt or yum (depending on your system) to remove the Jenkins package:

sudo apt-get remove --purge jenkins
# Or (if using yum)
# sudo yum remove jenkins

Remove Jenkins Configuration and Data Files

Delete Jenkins configuration and data folders (typically located in /var/lib/jenkins and /etc/jenkins, paths may vary):

sudo rm -rf /var/lib/jenkins
sudo rm -rf /etc/jenkins
sudo rm -rf /var/log/jenkins
sudo rm -rf /usr/share/jenkins

Remove JDK

List installed JDK versions:

sudo update-alternatives --config java

Check installed OpenJDK packages:

dpkg --list | grep openjdk

Remove OpenJDK packages, for example:

sudo apt-get remove --purge openjdk-11-jdk-headless
sudo apt-get remove --purge openjdk-11-jre-headless

Summary

This guide details the steps to install Jenkins on an Ubuntu server. First, update system packages and install OpenJDK 17. Next, add the official Jenkins repository and update the package index, then install Jenkins. After installation, start and enable the Jenkins service, open firewall port 8080, and access the Jenkins unlock page. Follow the installation wizard to complete plugin installation and administrator creation. Lastly, instructions on how to uninstall Jenkins and its related configuration and data files are provided.

Installing Jenkins on Ubuntu 22.04 Server: A Detailed Guide

This guide details the steps to install Jenkins on an Ubuntu server. First, update system packages and install OpenJDK 17. Next, add the official Jenkins repository and update the package index, then install Jenkins.

ZGYAutumn

Basics of Nested Object Properties

Firstly, let's recap what nested objects are. In JavaScript, objects can contain other objects as their properties. For instance, suppose we have an object called person, which has a property named address, and the address property itself is another object containing properties like city and street.

const person = {
    name: 'John',
    address: {
        city: 'New York',
        street: '123 Main St'
    }
};

The conventional way to access nested properties is by using dot notation or square bracket notation. For example, we can access the city property via person.address.city.

Need for Dynamically Accessing Nested Object Properties

However, in real-world programming, there's often a requirement to access properties dynamically, meaning determining the property names at runtime. For instance, suppose we need to write a generic function to fetch values from nested objects based on given property names, but we don't know the exact names of the properties.

Methods for Dynamically Accessing Nested Object Properties

1.Using Dot and Bracket Notation

In JavaScript, we can access object properties using dot or bracket notation. However, using dot notation has a limitation: the property name must be a valid identifier. With bracket notation, we can use strings to access properties, which provides convenience for dynamic property access.

const person = {
    name: 'John',
    address: {
        city: 'New York',
        street: '123 Main St'
    }
};

const propertyName = 'city';
console.log(person.address[propertyName]); // Outputs 'New York'

We can see that we can store the property name in a variable and then use that variable within brackets to dynamically access the property.

2.Using Recursive Access to Nested Properties

Another method for dynamically accessing nested properties is by using recursion. When the structure of the object is recursive, a recursive function can conveniently access nested properties.

const person = {
    name: 'John',
    address: {
        city: 'New York',
        street: '123 Main St'
    }
};

function getNestedProperty(obj, props) {
    if (props.length === 1) {
        return obj[props[0]];
    }
    const prop = props.shift();
    return getNestedProperty(obj[prop], props);
}

const propertyPath = ['address', 'city'];
console.log(getNestedProperty(person, propertyPath)); // Outputs 'New York'

In this example, we've written a recursive function getNestedProperty, which takes an object and an array of property paths as parameters. The function recursively dives into nested objects until it finds the final property value.

3.Handling Edge Cases

When accessing properties dynamically, we need to consider scenarios where the property might not exist. In such cases, JavaScript returns undefined. Therefore, proper checks need to be performed before accessing properties to avoid errors.

Case Study：

Let's examine a real-world scenario. Suppose we have an object storing the population data of different cities, and we want to write a function to fetch the population based on a given city name.

const populationData = {
    NewYork: 8500000,
    LosAngeles: 4000000,
    Chicago: 2700000
};

function getPopulation(city) {
    return populationData[city] || 'Population data not found';
}

console.log(getPopulation('NewYork')); // Outputs 8500000
console.log(getPopulation('London'));   // Outputs 'Population data not found'

This example demonstrates how to dynamically retrieve population data from an object containing city names and corresponding population numbers. Firstly, we have an object named populationData, which contains the population numbers of different cities. Each city name serves as a property of the object, and the corresponding population number serves as the property value.

Next, we define a function named getPopulation, which takes a parameter city specifying the city name for which population data is to be retrieved. Within the function body, we dynamically access the property corresponding to the city name in the populationData object using populationData[city]. If the property corresponding to the city is found, the function returns the population number for that city. If the property is not found, JavaScript returns undefined. In such cases, we use the logical OR operator || to provide a fallback value, which is the string 'Population data not found', indicating that the population data for the city is not available.

Finally, we call the getPopulation function to retrieve the population number for a specific city and print the result to the console. In this example, getPopulation('NewYork') will return 8500000 because the populationData object contains the NewYork property with a population number of 8500000. On the other hand, getPopulation('London') will return 'Population data not found' because the populationData object does not contain the London property, indicating that population data for London is not available.

Conclusion

In JavaScript, dynamically accessing nested object properties is a common requirement. We can utilize bracket notation for dynamic property access or employ recursive functions to handle deeply nested properties. However, it's crucial to consider scenarios where properties might not exist while writing code to prevent errors. This concludes our discussion on dynamically accessing nested object properties in JavaScript.

References:

• Mozilla Developer Network (MDN) - Working with objects
• JS Note Club - How to access nested object in JavaScript dynamically

How to Access Nested Objects in JavaScript Dynamically

In JavaScript, dynamically accessing nested object properties is a common requirement. We can use square brackets to dynamically access properties, or utilize recursive functions to handle deeply nested properties.

ZGYAutumn

Learn more:

• How to Add Variables in Regex JavaScript？
• How to Disable Back Button in Browser Using JavaScript？

Date and time representation in JavaScript

JavaScript provides a Date object to handle dates and times. We can use it to create, manipulate, and represent dates and times.

// Create Date objects
let currentDate = new Date();
let futureDate = new Date('2024-12-31');

// Get date and time
console.log(currentDate); // Current date and time
console.log(futureDate); // Specified date and time

Date comparison methods in JavaScript

JavaScript provides multiple ways to represent dates and times, including Date objects, timestamps, and datetime strings. Details are as follows.

1 . Use comparison operators directly （>、<、>=、<=）

The Date object in JavaScript can be directly compared using comparison operators. When compared, the Date object is automatically converted to a millisecond value (the number of milliseconds since January 1, 1970).

const date1 = new Date('2024-03-17');
const date2 = new Date('2024-03-18');

if (date1 > date2) {
    console.log('date1 is later than date2');
} else if (date1 < date2) {
    console.log('date1 is earlier than date2');
} else {
    console.log('The two dates are equal');
}

2. Compare date parts (ignore time)

If you only want to compare two dates without considering the time part, you can set the time part to the same value first and then compare them.

let date1 = new Date('2023-03-25T00:00:00');
let date2 = new Date('2023-03-26T00:00:00');

console.log(date1 < date2); // true
console.log(date1 >= date2); // false

Alternatively, convert the time to a string in YYYY-MM-DD format and compare these strings:

let date1 = new Date('2023-03-25').toISOString().split('T')[0];
let date2 = new Date('2023-03-26').toISOString().split('T')[0];

console.log(date1 < date2); // true
console.log(date1 > date2); // false

3. Use Date.parse ()

Use the Date.parse () method to parse the date string, convert it to a millisecond value, and then compare.

let date1 = Date.parse('2023-03-25');
let date2 = Date.parse('2023-03-26');

console.log(date1 < date2); // true
console.log(date1 > date2); // false

Comparative skills in practical application scenarios

In practical applications, we may need to compare the order of dates or check if they are equal.

// Compare the order of two dates
if (futureDate.getTime() > currentDate.getTime()) {
    console.log('futureDate is later than currentDate');
} else if (futureDate.getTime() < currentDate.getTime()) {
    console.log('futureDate is earlier than currentDate');
} else {
    console.log('The two date times are equal');
}

// Check if two dates are equal
if (futureDate.getTime() === currentDate.getTime()) {
    console.log('The two date times are equal');
} else {
    console.log('The two date times are not equal');
}

Summary

This article introduces various methods for comparing dates and times, including using Date objects, timestamps, and datetime strings. Different methods are suitable for different scenarios, and developers can choose the appropriate method according to their needs. In the future, with the development of JavaScript technology, more convenient date and time processing tools and methods may emerge.

How to compare date sizes in JavaScript?

This article explains how to compare date and time in JavaScript. JavaScript offers various methods to represent date and time, including Date objects, timestamps, and date-time strings.

ZGYAutumn

Learn more:

• How to format dates in JavaScript?

1. What is Buffer?

First, let's understand what Buffer is. Simply put, Buffer is an object used to process binary data. In JavaScript, string is a sequence of Unicode characters, while Buffer is a sequence of bytes, which makes Buffer very efficient in processing binary data.

2. Difference between string and buffer

Well, to better understand, let's compare the storage methods of string and Buffer in memory. String is stored in units of characters , while Buffer is stored in units of bytes . So, in some cases, we need to convert string to Buffer to better handle data.

When we talk about strings and buffers, we are actually discussing the storage method of data in memory, which is very important because it directly affects how we process data. Strings are stored in character units, which means that each character occupies a certain amount of Memory Space, and the size of this Memory Space depends on the encoding of the character. For example, for English characters, usually one character occupies one byte of Memory Space; but for some non-English characters or special characters, one character may occupy multiple bytes of Memory Space. This storage method makes strings very convenient when processing text data, and we can easily perform various operations on strings, such as concatenation, interception, and searching.

Buffer is completely different. It stores data in bytes. That is to say, Buffer stores the original byte sequence of data, not the character sequence, which makes Buffer very efficient in processing binary data. For example, when we need to process files, network data streams, or perform encryption and decryption operations, we usually need to use Buffer. Because in these scenarios, we are more concerned about the original byte content of the data, not the character encoding.

Therefore, when we need to process binary data in JavaScript, such as file operations, network transfers, or encryption and decryption operations, we need to convert strings to buffers. Because in these cases, we are more concerned about the byte content of the data than the character encoding.

3. The method of converting string to Buffer in JavaScript

Now let's see how to convert string to Buffer in JavaScript. First, we have a simple method, which is to use the Buffer class.

Method 1: Use the Buffer class

We can use the Buffer.from () method to do this. This method takes a string as a parameter and returns a corresponding Buffer object. Let's look at an example:

const str = 'Hello, world!';
const buf = Buffer.from(str);
console.log(buf);

In this way, we convert string to Buffer, very simple!

Method 2: Use TextEncoder

Another way is to use the TextEncoder class. It can encode the string as Uint8Array, and then we can convert it to Buffer through the Buffer.from () method. Take a look at the code:

const encoder = new TextEncoder();
const str = 'Hello, world!';
const uint8Array = encoder.encode(str);
const buf = Buffer.from(uint8Array);
console.log(buf);

This can also convert string to Buffer.

4. Performance and applicability comparison

So, which of these two methods is better? It depends on your needs and performance requirements. Generally speaking, if you simply convert string to Buffer, using the Buffer class will be more convenient. But if you need more coding control, TextEncoder may be more suitable for you.

Summary

Overall, no matter which method you choose, converting string to buffer is relatively simple. Choosing the appropriate method based on your needs and performance requirements is the most important.

Reference link:

• Node.js official documentation: Buffer class
• MDN Web Documentation: TextEncoder

How to convert string to Buffer in JavaScript?

This article introduces two methods for converting strings to Buffers in JavaScript: using the Buffer class and using the TextEncoder class.

ZGYAutumn

Learn more:

• How to Add Minutes to Date in JavaScript?
• How to check if two arrays have equal values in JavaScript?

1. Basic method: using HTML tags

First of all, we have to admit that the simplest way to bold is to use HTML tags, such as < b > or < strong > tags. In static HTML, you can use these tags directly where you need to bold. But the problem is that when we need to dynamically generate content in JavaScript, this method seems a bit inadequate.

<!DOCTYPE html>
<html>
<head>
    <title>Bold Text Example</title>
</head>
<body>
    <p>This is a <b>bold</b> text.</p>
    <p>This is another <strong>bold</strong> text.</p>
</body>
</html>

2. Manipulating DOM elements with JavaScript

Now it's JavaScript's turn! JavaScript is a language that can manipulate the DOM (Document Object Model), allowing us to dynamically change the page content after the page is loaded. You can use JavaScript to select elements on the page and perform various operations on them, such as modifying styles, changing content, and so on. Therefore, to achieve text bold, you only need to select the corresponding elements and set appropriate styles for them.

<!DOCTYPE html>
<html>
<head>
    <title>Bold Text Example</title>
</head>
<body>
    <p id="text">This is a piece of ordinary text.</p>
    <button onclick="makeTextBold()">Click to Bold</button>

    <script>
        function makeTextBold() {
            const textElement = document.getElementById('text');
            textElement.style.fontWeight = 'bold';
        }
    </script>
</body>
</html>

3. Use CSS to implement text bold

Perhaps you may ask, is there a more elegant way to achieve it? The answer is yes! CSS style sheets are our good helper. By adding specific CSS classes to text, we can dynamically control the style of text in JavaScript, including bold. Simply manipulating the class attribute of the element through JavaScript can make the text bold.

<!DOCTYPE html>
<html>
<head>
    <title>Bold Text Example</title>
    <style>
        .bold-text {
            font-weight: bold;
        }
    </style>
</head>
<body>
    <p id="text">This is a piece of ordinary text.</p>
    <button onclick="makeTextBold()">Click to Bold</button>

    <script>
        function makeTextBold() {
            const textElement = document.getElementById('text');
            textElement.classList.add('bold-text');
        }
    </script>
</body>
</html>

Summary

In short, it is not difficult to implement text bold in web pages through JavaScript. Whether it is directly manipulating DOM elements or using CSS styles, we have multiple choices. The most important thing is to choose the appropriate method according to the specific situation and needs. I hope this article is helpful to you and I hope you continue to explore more possibilities in JavaScript and web design!

How to bold text in JavaScript?

This article discusses how to make text bold in JavaScript. To achieve text bolding, you simply need to select the relevant elements and then apply the appropriate styling, such as setting the font weight to ‘bold’.

ZGYAutumn

Learn more:

• How to compare date sizes in JavaScript?
• How to format dates in JavaScript?