Home
Posts
Article
Encyclopedia
Garden
Set
English
Followed
+
Follow
The garden is empty ~
Have not added flowers yet.
Posts (56)
养花风水
8 hours ago
养花风水

Creating a Basic To-Do List Application Utilizing JavaScript Principles

When one embarks on the path of aptly understanding programming, perhaps most notably, a web page interaction, interactivity in essence, is one key element to master. At this point, it is hard to overestimate the role of JavaScript. I would say, the moment when you start learning to change the content of elements on a web page using JavaScript, it almost extends your vision about how websites operate. It can be claimed that one of the conventional ways to begin practicing JavaScript is developing a basic to-do list application. Not only does this project serve as a nice way to practice coding, but it also contributes towards the strengthening of basic skills that will be beneficial as you progress to more advanced aspects of programming in the future.

The task in context

A todo list application is a simple yet very useful tool which most of the budding developers begin with. The reason why this project turns out to be so effective in learning is because it encompasses several key areas of JavaScript: working with DOM, responding to user events, and updating web pages content. While this might sound simple enough, the insights acquired during its development provide a stepping stone to building complex web based platforms.

The purpose of the project is to design a web application in which the user can add and delete tasks and also mark them completed. The users will type the tasks into the input field and hit the buttons to make these tasks a part of the list. They will also be able to hit the tasks to mark them completed and later hit them too to delete once the task is finished. The core essence of a to-do list app is just regarding creating and handling data that is to be shown within a web page.

Preparing Your Development Environment

There should be a simple development environment in place before rushing into the actual coding part of the application. For a project like this, you will require only a few basic tools, a text editor and a web browser.

You will make the web application's code in the text editor. Developers normally opt for editors like Atom, Sublime Text, or Visual Studio Code because they are code-centric and easy to use. But even a plain text editor can do the job. You will be able to check your output on the web browser. For this, any updated browser like Chrome, Firefox, or Safari will work.

So after gathering all the resources, you will have targets to achieve which include the three principal files, one for HTML, another one for CSS, and the last one for JavaScript.

1. HTML (HyperText Markup Language): This will form the basic building block of any webpage.

2. CSS (Cascading Style Sheets): It will help shape the appearance of the web page including the structure, colors and styles of the fonts.

3. JavaScript: This language is meant to be used on any interactivity in your web page allowing it to be active and controlled by what users do.

These three- HTML, CSS, and JavaScript are the backbone of most web applications as they complement each other in web development.

The Function of HTML in the To-Do List

HTML is the core framework around which you will build your website. It specifies elements that users will be able to interact with. For example, in the case of a to-do list application, the HTML document would have an input box, buttons, and an area to render the tasks that the user aims to perform.

With respect to the textbox, the user will input what they want to be added in the list. And the button acts as the intuitive feature that provides the browser command to save the entered content. A task list, usually an unordered list, will have the tasks along with the task description in a bulleted format. Now, these tasks are available to the JavaScript code for some actions such as checking the task as done or deleting it.

CSS Styling for Visual Appearances

The styles in which the webpage would be displayed is controlled by CSS. In other words, while the HTML builds the structure, CSS brings those structures to life through aesthetics as well as the positioning of those structures. A web page without CSS would be unformatted and read too much like an incoherent mass of text and images.


To enhance the user experience in this to-do app, CSS can be implemented. For example, you can add a border and some padding to the input box so that it's easier for users to interact with. The task list can also be improved by altering the color of completed tasks and using spacing and font that is more suitable. Having simple rules for using CSS on your to-do list app can elevate its user experience and accessibility simply by improving its outlook.

Moreover, CSS can also be used to add buttons that change their color when hovered over or when pressed. This minute detail has the power to improve the general outlook of your app, making it friendly to the users.

How to Use JavaScript to Enable Interaction Capabilities in this App

The most impressive part of this to-do list application is realized once JavaScript is incorporated. With the use of JavaScript, user processes can be trapped and specific actions taken instead. In this case, you will use JavaScript to:

1. Add tasks to the list: A user typing in a task and then pressing the "Add" button is something that can be caught and hence accomplished with the help of javascript by making it possible to add the tasks dynamically on the list.

2. Task Completion By The User: A defined task in Practice Application could be marked as completed by the user who will click on the task's recoil. An easier technique which is often employed is adjusting the style of the task (e.g. strikethrough or changing the color).

3. Removing Tasks: Upon completion, or when no longer needed, a task can be deleted by means of this language, based on its requirement. This makes sure that the webpage does not contain irrelevant tasks by virtue of keeping every list updated.

JavaScript will handle the task of the real time content update of the webpage based on the user's input. When a user adds a task for instance, the list will be advanced which automatically updates. Marking or deleting a task, when done, sends the command to JavaScript and the respective action is carried out in no time thus making everything fluid and very interactive for the user.

0
0
Article
养花风水
8 hours ago
养花风水
The backend has been developed in a completely new way thanks to node.js. This is a program that allows a developer to utilize JavaScript even on the server side. Formerly, JavaScript was only used in client-side scripts but with the use of Node.js, server applications can be developed in the very same language that browsers use. This has eased development for a number of coders who already possess JavaScript skills.

Node.js is a free software and a multiplatform enabling runtime that runs JavaScript scripts in the server environment. Its architectural structure is the V8 engine used in the Google chrome browser making it effective and reliable. Unlike conventional server-side programming systems which depend on threads for servicing more than one request, Node.js works on a single threaded and event based mechanism. This characteristic enables it to serve a large number of requests at the same time which is helpful in the development of web applications that have to be scaled.

What is Node.js?

Node.js is a platform that allows Javascript code to be executed on the server side as opposed to only the browser. In other words, it allows Javascript for server-side programming. The V8 JavaScript Engine, usually associated with Google, is used because it compiles Javascript into machine code for fast processing.

Node.js relies heavily on a non-blocking event-driven architecture, which is ideal for developing distributed networking applications. It is also good at processing input and output (I/O) requests, which are common while carrying out web-based tasks, including writing and reading files, making HTTP requests, and working with databases.

How Does Node.js Work?

Each Node.js application follows an event-driven style architecture which makes it easier to perform non-blocking actions. It does not wait for an I/O request to complete, like the other applications, rather, it processes multiple tasks at a time. To do so, it utilizes an event loop. The moment an I/O request has been completed, an event is fired to indicate that there is now a completed request that the application can use.

The fact that it is non-blocking has an important advantage for software like real-time chat systems, live data streaming, and APIs, which need to maintain a high number of concurrent connections, over time. So, with every user request being catered to at the same time, Node.js seems to be doing tasks considerably quicker than what is the case with server-side languages where each task is supposed to finish before the next one can be started.

Why Choose Node.js for Backend?

There are many reasons why Node.js is gaining popularity with developers companies for backend development as there are many key advantages included with it:

1. JavaScript Everywhere: One of the primary advantages of using Node.js is that developers can utilize JavaScript in both the frontend and backend. This negates the need to master multiple languages for various sections of an application. Users of JavaScript can utilize it in the entire stack which would lead to reduced complexity in the development processes and easier code maintenance.

2. Performance: Node.js is based on the V8 engine, which compiles JavaScript directly into a machine code, accelerating the execution speed. Also, because it is non-blocking and event-driven, Node.js is able to manage thousands of active connections simultaneously without compromising performance.

3. Scalability: An application built on Node.js is highly scalable in addition to being expandable. It is event-driven and able to manage several database requests at the same time. This is quite useful in the applications, wherein high throughput is required such as APIs or real time services.

4. NPM (Node Package Manager): A package manager is built into Node.js and which is called NPM, a utility that enables one to access thousands of free libraries and modules which can be used in one's applications. This allows one to quickly and effortlessly add in functionalities such as database capabilities or user authentication without having to create it from square one.

5. Real-time Data: Applications that handle real time data would benefit greatly from the use of Node.js. The architecture of Node.js is event driven, and therefore, it can be used in any time-based application such as online chats, collaboration tools, online games etc. Furthermore, the capability of handling numerous connections at the same time with minimum cost applies to these situations perfectly.


6. Community Support: One of the best features of Node.js is its lively and vigorous community. The community is angry with a huge number of tutorials, documentation, and open source projects which can be used in handy when looking for solutions. The more the users in the Node.js ecosystem, the better the improvement of the platform.

Top Traits of Node.js for Back End

Node.js is built-in with an array of features which make the backend development perfect:

1. Asynchronous and Nonblocking: Working on a nonblocking asynchronous mode, Node.js can concurrently execute several requests. Unlike conventional servers that must make use of several threads to satisfy requests, Node.js server makes use of a single thread and is able to attend to a number of requests simultaneously.

2. Event Loop: The event loop retrieves the task from the application and assigns it the system and the task is started, And the event loop jumps to the next task. After finishing the task, it fires an event to the application.

3. Single-Threaded Model: Even though Node.js is capable of supporting many simultaneous connections, it does so on a single thread which makes the cost of maintaining several threads low. For input/output intense applications, this makes the server light-weighted and fast.

4. Cross-platform: Node.js runs on a number of operating systems including Windows, Linux and Mac OS X. Thanks to this feature, applications are easily developed and maintained in different systems without substantial changes.

5. Streams: Node.js supports streams with the help of which data can be handled in chunks instead of fetching it all at once. This feature is significant for the developers who have to deal with large-scale data such as processing of huge files or real-time transmission of data to clients.

6. HTTP Module: With the backend development incorporating the built in HTTP module provided by Node.js, developing web servers and APIs has never been easy. Rather than complex system architectures, starting with simple web servers that handle the HTTP protocols can be set up with ease.

7. JSON Handling: JSON or JavaScript Object Notation, is a popular data format used in client-server interaction and is supported by Node.js out of the box. This feature in particular allows for easy development of RESTful APIs on Node.js due to its compatibility with JSON.

8. Robust Ecosystem: A lot of packages and libraries are present in the Node.js which can be easily downloaded from NPM, making the development process easy. If you are working with databases, authentication, sending emails, then most probably you will find a relevant package already available.

0
0
Article
养花风水
8 hours ago
养花风水
Debugging is one of the important skills that is needed to be able to work as a developer. Properly writing code, specifically in JavaScript, satisfactorily functions will never fail to find bugs, errors or even behaviors that were never intended to happen. Bug fixing is a critical step in programming as it helps eradicate issues thus maintaining the overall smooth running of the application.

Like a majority of languages, bugs in JavaScript applications can be due to hierarchy structure flaws, wrong attribute values or even code translation to the final build and compilation. Mastering how to debug JavaScript efficiently can be a great time saver, minimizes frustration and enhances the quality of the code.

Understand the Debugging Process

Debugging can be defined as an organized way of controlling and eliminating problems that arise in a program. It encompasses closely looking at the codes writing it, explaining the issue, and circumstantially offering a corrective action plan. In JavaScript applications, debugging can be said to commence when one tries to find out the problem in the code and how his written code operates.

In order to effectively debug the code, it is important to first rationalize the error. This could be in the form of error messages, unexpected behavior, or incorrect outputs. After that, you should start first by defining the problem and then what tools you can use that will help you to fix the issue.

Common Mistakes That Are Made In Javascript

As you prepare yourself to learn how to debug your code, the first step is to comprehend the possible errors that can happen when coding in Javascript: In this case, the errors are usually-a- typose three major ones most programming languages face:

1. Syntax Errors: These happens when making a change to a line of code where there are parentheses or incorrect wording Keywords are frequently missed by the an interpreter, who will stop executing and show an error message.

2. Runtime Errors: These occur while the program is running, for example when you call a function that does not exist or use a variable that has not been defined. These errors also appear, however only when the code is in its execution phase as they were never able to be caught in the compilation phase.

3. Logical Errors: In programming, there are times when your code compiles fine and does not give any error message, but still, the outcome is not what you wanted: this is considered a logical error. This sort of error is said to be the hardest to deal with as it does not terminate the execution of the program. Instead the code runs completely but the result obtained is wrong.

Using `console.log()` for Debugging

One of the simplest and most common debugging techniques in JavaScript is `console.log()`. This method enables you to output a message on the console of a web browser to examine how a program behaves and what values of the variables are at different stages of the program.

Log messages at the appropriate points in the code by inserting `console.log()` and you will be able to know what the application was doing at that instant in time. This is especially useful in trying to understand an application response that is not as expected or when trying to locate the code responsible for an action that is not desirable. But while `console.log()` sounds really appealing for casual checks, I would personally recommend being careful because it won't always be enough for more intricate issues.

Browser Developer Tools are Extremely Helpful

Inbuilt developer tools are available now in most of the browsers and they can be very useful to debug JavaScript code. These tools let developers modify the code and see the functionality of the application at the same time. The number of very handy options within browser developer tools include:

1. Console Tab: The Console tab in the developer tools shows all `console.log()` messages that have been reported. It also logs other messages like errors, warnings, and other messages displayed in stack traces which can assist in the root cause of a problem.


2. Debugger: Debugger is one of browsers developers tools and it allows users to set breakpoints in source code. A breakpoint is a marker that you place in your code to tell the debugger to temporarily suspend its execution at that point. This allows you to inspect the state of the code, including variables, step through the code one line at a time, and evaluate code in real time. This is particularly useful for pinpointing the location of logical or runtime errors.

3. Network Tab: With the Network tab you can view all network activity that is associated with your application. It lists down all the Http Requests that resulted from the execution of your Javascript code including every piece of data that was sent to and retrieved from servers. This comes in handy especially when trying to identify issues relating to data being fetched, executing API calls, or asynchronous operations.

4. Performance Tab: The Performance tab lets you see how well your code is working and assessing this is critical for application optimization. Recording and reviewing performance traces assists in finding areas of your code that are performance saturations or lags.

Making Use of Breakpoints and Step-wise Debugging

In today's debugging environments, making use of breakpoints and step-wise debugging is one of the most effective ways of debugging an application. For example, if you are a JavaScript developer and you write a code that has a breakpoint at any specific line, then at that point code stops and you can view variable values and call stack..

Once the breakpoint is hit, you can use the debugging tools in the browser to step through the code line by line. Doing so makes the steps of your program much clearer as it is possible to track the program's performance more explicitly than when it runs freely. Step-by-step debugging also improves the performance of a program by exposing the logical flaws 'in the process' of how data is dealt with.

What Is the Stack Trace and How to Look Into It

In order to debug Javascript code snippets, one important component to focus on includes the stack trace. The Javascript stack trace visually represents the sequence of function calls that have been made in case there is an exception or any form of output error. Stack traces also contain function code that contains even simpler code needed for debugging purposes. A stack trace helps developers understand which function or line code creates a specific bug. As a result, with the help of a stack trace, it becomes considerably easier to locate the source of a problem within the code.

Skimming through code for misplaced syntax can be very tiring and time-consuming for developers; this is why understanding how to read stack traces is so important for effective debugging. After all, stack traces contain information pertaining to the line of code that needs to be revised to a function name, and specific file name.

How to Avoid Trouble in Your Code with Linters And Code Analyzers

Linters and analyzers for coding languages such as Java, or in this case Javascript, can make life much easier for programmers. Javascript developers use coding linters in order to avoid rule breaking while creating code snippets. When utilized correctly, linters can easily detect problems that most code editors are not equipped to deal with such as syntax errors or incorrect formatting. Commonly used code editors like Visual Studio Code allow integration with other tools, for example `eslint` who assist with automatically formatting the code according to standard practices.

0
0
Article
养花风水
8 hours ago
养花风水
In the modern era of web development, the libraries and frameworks assist the software developers in creating complicated and efficient applications. One of the most commonly used and popular frameworks in the past couple of years has been React. It was initially developed by Facebook and it enables developers to create rich, interactive web applications easily. In short, it is a modern way of developing web applications, and we all know how powerful web applications can be for a developer.

Before discussing the reasons for the adoption of React, it makes sense to discuss what JavaScript frameworks are to begin with and then proceed to the underlying principles of React.

Indeed, What is a Javascript Framework?

A JavaScript framework can be defined as a set of ready-made JavaScript code for constructing applications in the fastest manner possible. Frameworks give a blueprint and a set of instruments to a developer, so he or she is able to concentrate on the core idea of the application and its programming, instead of systematizing the standard code. There are several Javascript frameworks that assist in structuring application code, provide front-end UI features, or provide connectivity between the presentation layer and the data centre.

Moreover, it has wide-ranging capabilities which makes learning it worthwhile. Starting from algorithms teaching and all the way to complex game design. JavaScript frameworks are an incredible asset when developing applications across wide disciplines. Understanding such programs as Angular, Vue and React will facilitate the work tremendously. But these applications are, however, usually called libraries rather. If you look closely, these programs are nothing more than powerful user interfaces. Naturally, it enables the development of more robust frameworks and libraries.

Why React?

Out of several JavaScript frameworks, learning React seems to be the best investment. Many people still confuse React with other frameworks and libraries bundled together with its namesake, some call it 'ReactJS', others simply refer to it as the UI framework. To clarify, let's look at some of the features of React that answers the question of why should anyone become an expert React developer.

1. Component-Based Architecture: One of the fundamental aspects of any application written in React is how the application is structured. First off, let's understand what it means to have a Component based architecture. In its simplest form, any given website or web app can be divided into different parts or segments. So, you can think of these segments as pieces. This includes headers, footers, and body sections, images widgets and all other UI elements that went into building said application. So essentially, a single application is made up of several other applications that are embedded within one another. This modular design greatly simplifies management, testing and updating processes as changes to different parts can be made without altering neighboring ones.

2. Declarative Syntax: As already stated, React implements a declarative syntax instead, meaning that developers consist solely on defining what they want in a given user interface, and in this case, React executes how to do it. To put it another way, instead of writing imperative code that details each stage of the operation, React developers only need to specify the front-end design of the interface, and whenever such a state is needed, React will do the house updating when the state changes. This means that applications built with React are also less difficult to read, debug and maintain.

3. Virtual DOM: One more important aspect of React is Virtual DOM (Document Object Model). Virtual DOM is used in optimizing the update of the user interface as it is a replica of the actual DOM, only that it is much smaller. When an application is changed, React will first change it in the Virtual DOM, and only then will check for changes in the actual DOM. Then, only the changes that should be made to the actual DOM are done enabling speed as well as reducing unnecessary re-rendering.

4. Unidirectional Data Flow: According to React, components and data can only go in one direction, data always flows in one direction, components receive details of their parent components through properties, which are often regarded as 'props'. If a component wants to revise its data, it needs to revise its state, which will reactivate the rendering of the component. This iterative and systematic data flow makes it comparatively easy to perceive how the data changes in the app and how those data changes impact the UI of the app.


5. JSX (JavaScript Syntax Extension): JavaScript has a syntax extension known as JSX, and React works using JSX, this makes it possible to write HTML code directly inside JS, as long as it has a similar structure. It is possible to create user interface elements in a more usable and familiar format together with the power and utility of JavaScript. Tools such as Babel enable the browser to execute code that wasn't meant for that in the first place by converting JSX to Javascript since browsers are not designed to interpret it.

Getting Started With React

To begin working with React, one must acquire certain tools and libraries in a development environment. The best way to get up and running with React is to use Create React App since it is a tool endorsed by Facebook that initializes a React application with all the configurations such as build tools, application structure, and libraries.

Once you create a React application, you will come across a folder structure which would consist of the following main components:

- src: This folder contains all the source code for your application, here you'll define your components and logic.

- public: This folder contains the static files, in particular the index.html file, images or icons.

- node_modules: This folder holds all the required dependencies for your project.

- package.json: This is a crucial file that contains a list of all the dependencies and scripts used in your project.

Most development environments normally employ Webpack and Babel amongst other tools to assist in a myriad of tasks such as combining and transcribing your Javascript files into a version that the browsers can comprehend.

What are the Different Types of Components in React?

As far as I know, React is a JavaScript framework that allows developers to build user interfaces as component hierarchies that can consist of several nested components. Each component can render an interface and can be written as a function or class. Components can be divided into two types: Class components and Function components.

- Class Components: These components represent a class that extends `React.Component`, they are the most complex form of React components. A class component must have a `render` method and return some JSX.

- Function Components: As the name suggests, function components are entirely produced as functions. At the beginning, these classes didn't support state management but thanks to the Hooks in React, they can do every function class can, in addition to being stateless.

In most cases, a component will receive `props` as one of its parameters and will be responsible for rendering corresponding HTML and/or JSX code. `Props` are essential in react components because they facilitate the flow of data between nested components.

0
0
Article
养花风水
8 hours ago
养花风水

Introduction to Javascript Frameworks (React Basics)

In the modern era of web development, the libraries and frameworks assist the software developers in creating complicated and efficient applications. One of the most commonly used and popular frameworks in the past couple of years has been React. It was initially developed by Facebook and it enables developers to create rich, interactive web applications easily. In short, it is a modern way of developing web applications, and we all know how powerful web applications can be for a developer.

Before discussing the reasons for the adoption of React, it makes sense to discuss what JavaScript frameworks are to begin with and then proceed to the underlying principles of React.

Indeed, What is a Javascript Framework?

A JavaScript framework can be defined as a set of ready-made JavaScript code for constructing applications in the fastest manner possible. Frameworks give a blueprint and a set of instruments to a developer, so he or she is able to concentrate on the core idea of the application and its programming, instead of systematizing the standard code. There are several Javascript frameworks that assist in structuring application code, provide front-end UI features, or provide connectivity between the presentation layer and the data centre.

Moreover, it has wide-ranging capabilities which makes learning it worthwhile. Starting from algorithms teaching and all the way to complex game design. JavaScript frameworks are an incredible asset when developing applications across wide disciplines. Understanding such programs as Angular, Vue and React will facilitate the work tremendously. But these applications are, however, usually called libraries rather. If you look closely, these programs are nothing more than powerful user interfaces. Naturally, it enables the development of more robust frameworks and libraries.

Why React?

Out of several JavaScript frameworks, learning React seems to be the best investment. Many people still confuse React with other frameworks and libraries bundled together with its namesake, some call it 'ReactJS', others simply refer to it as the UI framework. To clarify, let's look at some of the features of React that answers the question of why should anyone become an expert React developer.

1. Component-Based Architecture: One of the fundamental aspects of any application written in React is how the application is structured. First off, let's understand what it means to have a Component based architecture. In its simplest form, any given website or web app can be divided into different parts or segments. So, you can think of these segments as pieces. This includes headers, footers, and body sections, images widgets and all other UI elements that went into building said application. So essentially, a single application is made up of several other applications that are embedded within one another. This modular design greatly simplifies management, testing and updating processes as changes to different parts can be made without altering neighboring ones.

2. Declarative Syntax: As already stated, React implements a declarative syntax instead, meaning that developers consist solely on defining what they want in a given user interface, and in this case, React executes how to do it. To put it another way, instead of writing imperative code that details each stage of the operation, React developers only need to specify the front-end design of the interface, and whenever such a state is needed, React will do the house updating when the state changes. This means that applications built with React are also less difficult to read, debug and maintain.

3. Virtual DOM: One more important aspect of React is Virtual DOM (Document Object Model). Virtual DOM is used in optimizing the update of the user interface as it is a replica of the actual DOM, only that it is much smaller. When an application is changed, React will first change it in the Virtual DOM, and only then will check for changes in the actual DOM. Then, only the changes that should be made to the actual DOM are done enabling speed as well as reducing unnecessary re-rendering.

4. Unidirectional Data Flow: According to React, components and data can only go in one direction, data always flows in one direction, components receive details of their parent components through properties, which are often regarded as 'props'. If a component wants to revise its data, it needs to revise its state, which will reactivate the rendering of the component. This iterative and systematic data flow makes it comparatively easy to perceive how the data changes in the app and how those data changes impact the UI of the app.


5. JSX (JavaScript Syntax Extension): JavaScript has a syntax extension known as JSX, and React works using JSX, this makes it possible to write HTML code directly inside JS, as long as it has a similar structure. It is possible to create user interface elements in a more usable and familiar format together with the power and utility of JavaScript. Tools such as Babel enable the browser to execute code that wasn't meant for that in the first place by converting JSX to Javascript since browsers are not designed to interpret it.

Getting Started With React

To begin working with React, one must acquire certain tools and libraries in a development environment. The best way to get up and running with React is to use Create React App since it is a tool endorsed by Facebook that initializes a React application with all the configurations such as build tools, application structure, and libraries.

Once you create a React application, you will come across a folder structure which would consist of the following main components:

- src: This folder contains all the source code for your application, here you'll define your components and logic.

- public: This folder contains the static files, in particular the index.html file, images or icons.

- node_modules: This folder holds all the required dependencies for your project.

- package.json: This is a crucial file that contains a list of all the dependencies and scripts used in your project.

Most development environments normally employ Webpack and Babel amongst other tools to assist in a myriad of tasks such as combining and transcribing your Javascript files into a version that the browsers can comprehend.

What are the Different Types of Components in React?

As far as I know, React is a JavaScript framework that allows developers to build user interfaces as component hierarchies that can consist of several nested components. Each component can render an interface and can be written as a function or class. Components can be divided into two types: Class components and Function components.

- Class Components: These components represent a class that extends `React.Component`, they are the most complex form of React components. A class component must have a `render` method and return some JSX.

- Function Components: As the name suggests, function components are entirely produced as functions. At the beginning, these classes didn't support state management but thanks to the Hooks in React, they can do every function class can, in addition to being stateless.

In most cases, a component will receive `props` as one of its parameters and will be responsible for rendering corresponding HTML and/or JSX code. `Props` are essential in react components because they facilitate the flow of data between nested components.

0
0
Article
养花风水
8 hours ago
养花风水

Web Storage APIs: Local Storage and Session Storage

In web development, Web Storage API has become one of those things that we cannot ignore. They provide a means to store information on the client-side (browser). These APIs help websites remember information such as user preferences and also maintain state across various sessions or pages. Local Storage and Session Storage are probably the most used web storage mechanisms. Both allow end users to save data on the client-side but work differently in terms of its range and lifetime. Grasping these distinctions and understanding under which conditions they are most suitable for use can considerably enhance the efficiency and capability of web apps.

What is Web Storage?

Web Storage is a client-based storage system that lets web applications store key value pairs in a user's browser more conveniently. While cookies contain data that must be sent through the server with each HTTP request , data that has been stored in Web Storage is only available to JavaScripts on the Client side. Therefore, Web Storage has the potential of providing a better and less network intensive solution for storing data.

Web Storage has two primary components as outlined below:

1. Local Storage

2. Session Storage

Although both have similarities, it is important to know the variation between the two to be able to use them appropriately.

Local Storage

Local Storage is among the variety of Web Storage APIs that uses client-side storage to keep data on the web browser. Local Storage is unique in that data stored in it does not have an expiration time set and remains in the browser even when the user closes the browser or the tab. Because of this, Local Storage is best suited to store any information which must be accessed over multiple sessions.

Data held in the Local Storage is classified in key-value pairs and can be invoked through JavaScript programs belonging to the same domain as the data. Each domain (or origin) has its own isolated storage, so data stored for one website can not be accessed by another.

Local Storage Examples

// Store data
localStorage.setItem("username", "john_doe");

// Retrieve data
let username = localStorage.getItem("username");

// Remove data
localStorage.removeItem("username");


Local Storage has a good amount of space (in most cases, 5MB is the limit per origin) so it is best used to store non-sensitive such as user preferences, theme settings, app configurations etc. One point to keep in mind is that Local storage is available to any JavaScript running on that page which is why no sensitive information should go there as it does not get encrypted.


Session Storage

Like Local storage, Session Storage is also one of the Types of client storage. However, they do differ in one aspect:.Session Storage only contains data that was used during that page session, so the data contained is for that session only. A page session is active as long as the user has the browser tab opened. Once the tab or the browser is closed the data from the session storage will be deleted.

Session Storage Examples

//store data
sessionStorage.setItem("sessionId", "12345");

//get data
let sessionId = sessionStorage.getItem("sessionId");

//delete data
sessionStorage.removeItem("sessionId");


The beauty of Session Storage is that all the information is wiped out the moment the tab is closed. That's why it's helpful for forms with many steps, or even just browsing the same page.

How Local Storage Differs from Session Storage

Both Local Storage and Session Storage allow key-value pairs to be stored on the client-side. However, there are a few differences that set them apart. Knowing these differences makes it easier to choose the storage type best suited for the needs of your application.

1. Persistence

- Local Storage data does not get deleted simply by closing the browser or browser tab. It sticks around until the user or program explicitly deletes it.

- Session Storage data is removed once the browser tab is closed. It is session-oriented and when deleted, does not persist over different sessions or tabs.

2. Scope

- Local Storage can be accessed from any tab or window with the same origin (which is the domain).

- Session Storage is limited to a single tab of a web browser only. There is a unique Session Storage for every tab so one tab cannot access the Session Storage of the other tab even if both of them are on the same website.

3. Storage Size

- The noteworthy aspect is that both Local Storage and Session Storage allow a maximum of 5MB of data for each origin. Nonetheless, it is important to note that they have the same storage size which makes it irrelevant in this case.

4. Use Cases

- Local Storage : This is appropriate for information which is needed to exist longer than a single session – like user preferences or any tokens for authentication, token and data, application configuration and so on.

- Session Storage : This holds session specific information such as form input, IDs and so on that is only used during one particular session.

5. Data Access Restriction

- Local Storage and Session storage is only available to the single same origin which has the domain, port and protocol same. This avoids websites being able to read information stored by other websites.

0
0
Article
养花风水
8 hours ago
养花风水

Using JavaScript for Animations: The HTML5 Canvas and SVG

Animation today is arguably one of the key components for any contemporary website as it enhances the interactive element of the site. Thanks to the introduction of HTML5 together with JavaScript, animators now have animation creation tools that are easier to use and perform. Two of the most common ways of performing animations in JavaScript are the HTML5 Canvas and Scalable Vector Graphics (SVG). On one hand, using both technologies allows users to work with images on a web page, but on the other hand, it enables them to do it in quite an opposite manner. For those who want to be successful in web designing, it is necessary to know how to use these two tools in animation.

Definition of HTML5 Canvas

The HTML5 canvas element is a graphics canvas that is dynamically generated on a webpage via scripting language, such as JavaScript. This means Dynamic images, drawings, and graphics can be created and manipulated within a web page. This would be achieved without the use of content that is embedded in the canvas. The canvas element provides a space for JavaScript to make images but does not itself contain any images.

The canvas method by itself provides quite a broad range of methods for managing the pixels inside the canvas boundary which includes drawing of images of lines, shapes and images, styles, and also transformations. Since the Canvas is pixel based it means it works with pixels individually and renders images on to the screen.

To do this, the canvas has to be declared in HTML and its width and height attributes set. Then it can be accessed through JavaScript, in order to enable it, certain codes have to be driven into the context for the purpose of content modification associated with the inside of the canvas.

Declaring Canvas in HTML



Accessing Canvas in JavaScript

const canvas = document.getElementById("myCanvas");
const ctx = canvas.getContext("2d");


Animating with the Canvas

Drawing new images of frames and putting them in succession one after another makes animation in the canvas appear which in turn displays the frames that have been drawn previously which is enabled through properly timed drawing using the `requestAnimationFrame` method.

Basic Canvas Animation Example

let x = 50;  // Circle's first pixel in the x axis
let y = 50;  // Circle's first pixel in the y axis
function animate() {
    ctx.clearRect(0, 0, canvas.width, canvas.height);  // Let's erase the last circle
    ctx.beginPath();
    ctx.arc(x, y, 20, 0, Math.PI * 2);  // Place a circle in the center
    ctx.fillStyle = "red";
    ctx.fill();
    x += 1;  // Increment x position by 1 Pixel.
    y += 1;  // Increment y position by 1 Pixel.
    requestAnimationFrame(animate);  // Move on to the next frame and repeat.
}
animate();  // Drawing and looping the animation.


As observed in this example, the method `clearRect` clears every frame that comes after it and the circle is to be drawn again at different coordinates in every frame. Adjusting the parameters for the `x` and `y` coordinates while redrawing the circle over and over makes it look like it is animated smoothly.

What is SVG?

SVG or Scalable Vector Graphics is one of the concepts used in creating graphics in web development. It is different from Canvas which uses pixels to create images since SVG is a vector. Hence, images made using svg can appear in any size as images are composed of paths. It is also important to note that SVG graphics are created in an XML format hence the lightweight nature and they are also easily modifiable via text.

Most of the time SVG is used in designing logos and icons and even other graphics since it is resolution independent meaning an image of any size can never appear blurry. Moreover, since CSS and Javascript can be used to style and animate SVG elements, they can also be effectively used in web interactive animations.


Animating with SVG

Even though SVG is primarily a static vector format, javascript can be used to animate SVG elements. This renders it easy to animate elements on SVG as opposed to canvases where the entire scene would have to be erased and redrawn.

SVG Animation Example


    



As noted in this example, the SVG rectangle is animated using the `setAttribute` method whereby the `x` and `y` position values of the rectangle are changed, moving it from one to several specific points or corners.

Apart from animating shapes using Javascript, CSS can also be used in animating SVG elements. For instance, one can animate a shape's fill, its opacity or location through the application of `transition` and `animation` effect of the CSS elements. This is however much better when Java is included because one can create unique and intricate animations effortlessly.

Canvas and SVG – What's the Difference?

Both can create animations but canvas and SVG seem different. Canvas is rather meant for creating animations or games where loads of interconnected pixels would be involved. Canvas makes creating pixel-based graphics easy. In contrast, many suggest SVG for any logo, icon or similar situational vector graphics that you can easily scale up or down.

Canvas is more suited when a number of graphics at the scene need to be drawn and the scene has lots of changes. But for animating single objects, it has disadvantages since every scene needs to be drafted again and again with each moving frame. Since SVG graphics are vector based, they will work for animations which are limited in the number of moving objects and will maintain their sharpness in all resolutions.

Both have their pros and cons and the decision to go with either of the two mainly focuses on the graphics detail and the animation that you require.

0
0
Article
养花风水
8 hours ago
养花风水
The Fetch API is one of the crucial technologies that allow for the smooth and effortless creation of Web apps. It is a known fact that building user-friendly interfaces is a core aspect of web development in this modern age. One of the techniques that allow for this is by enabling the exchange of data between a web page and a server without the need to refresh the web page. As a result, the experience gets better and the web page feels more interactive. Hence the introduction of this powerful and effective technology, Save us from the crutches of the conventional and outdated XMLHttpRequest. Allowing us to focus on creating efficient and functional applications.

The purpose of this article is to discuss the Fetch API – what it does, how it works and where it can be efficiently utilized in Web development. In web development, one must have come across the term Asynchronous calls, this is because they are the cornerstone of creating a responsive application. Which is why the Fetch API is as important – More specifically the Promise aspect of it.

What is the Fetch API?

Fetch API is a new interface that allows servers to communicate with Javascript through HTTP requests. That way, there's no need to refresh the webpage every time you want to get new data from the server. The Fetch API is basically a better version of the older XMLHTTPRequest API, allowing for more complex and effective ways to initiate requests.

The Fetch API is better than its predecessor XMLHTTPRequest as it does not make use of call back functions instead it relies on the usage of promises. Asynchronous functions can be complex, but promises make it easier to manage them. Future completion that would dictate if the request worked or not - with the value depending on the latter, would be held by the promise.

With the fetch API, however, the application is able to send and receive other types of requests like GET, POST, PUT, DELETE and others. Other modern aspects like the ability to work with JSON responses and passing custom headers, sending credential requests are also supported.

What Is the Purpose of the Fetch API?

The Fetch API serves one purpose which is to send HTTPS requests to a server. This whole cycle starts once JavaScript calls the `fetch` method with `resourcelocator` `fetch('https://example.com/resource')`. End this method results with resolving the promise with Response containing the data obtained from the server.

Fetching API is versatile and supports a wide range of input parameters chiefly including querying a database, actively pushing the information obtained from UI, or even invoking files located on another server. The syntax is straightforward yet offers a great variety of simple and advanced requests functionality.

Basic Fetch Example

fetch('https://api.example.com/data')
.then(response => response.json()) 
.then(data =>{
    console.log(data);
})
.catch(error => {
    console.error('There was an error!', error);
});


In this example, the `fetch` function then takes in a URL and uses the GET HTTP method to fetch resources for that URL. After the requested URL sends its response over to the server, the javascript `then()` method proceeds to execute the code in it. The `response` token passed is an object containing the response received from the targeted server. In order to retrieve the information from this object which is in the form of JSON, `JSON.parse` is done using the `response.json`. Finally, to complete the process, the data is output through logs by `console.log`.

If there is an error (for instance, the server is unreachable), the error is reported because it has been logged using `console.log` in the `catch` method.

Fetch API Response Handling

Always remember that when using Fetch API, knowing how to manage the response of the server is very important. A response object has a number of methods that when used allowfor the processing of the data. Some of them are quite common and can be used in this particular case with the Fetch API.


1. response.json(): The response returned from the server can be a valid string in JSON format - this method approaches that string and formats it as a javascript object.

2. response.text(): If the server has sent the data in non-JSON format, for instance, returning an HTML or a simple text file, this method retrieves it and responds with it as plain text.

3. response.blob(): Servers might store images, videos, or other files specifically in binary data. This method is relevant here as it serves to retrieve the mentioned binary data.

4. response.status: When questions around whether the request was successfully processed - was there an error or not, arises, this property is relevant as it holds the answer by storing the HTTP codes.

Response Handling Example

fetch('https://api.example.com/data').then(response => {
    const statusCode = response.status;
    if (!(statusCode >= 200 && statusCode < 300)) {
        throw new Error("Network response was not ok");
    }
    return response.json();
}).then(data => {
    console.log(data);
}).catch(error => {
    console.error('There was a problem with the fetch operation:', error);
});


In the above example, therefore it was decided to use the `response.ok` property which returns a boolean value that is true only if the server response was ranging between 200 (successful) to 299. If this is not the case, an error is returned.

Using Fetch for POST Requests

A common applied POST request is to send data to the server, while GET is mostly applied to get a request for the server so to say the two are almost complete opposites. The Fetch API also has an option for you to set the method to POST where you can specify headers and body content.

Fetch POST Example

const data = {
    username: 'john_doe',
    email: '[email protected]'
};
fetch('https://api.example.com/users', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
})
.then(response => response.json())
.then(data => {
    console.log('User created:', data);
})
.catch(error => {
    console.error('There was an error!', error);
});


Here we create a `data` object which consists of users' data and we use the `fetch()` function with the `POST` method and the `body` option holds the stringified JSON data and with the `headers` option we mention that we're sending data in JSON format.

Fetch API and Catching Errors

One of the important aspects of working with the Fetch API is error handling. A fetch request can fail for many reasons, for example, incorrect URL path, server malfunctioning, or network issues. Fetch API does not throw an error on its own for the failure HTTP status codes (like 404 or 500). Instead, it only throws a rejection of the promise if there is a network problem or the request has been unsuccessfully completed.

0
0
Article
养花风水
8 hours ago
养花风水
Modern dynamic and interactive websites correctly rank among the cut-throat expectations of the users. People want websites which respond to their inputs and interactions instantly, load new information without the need of refreshing the whole page and engage the user throughout with persistence. It is at this point that JavaScript and AJAX come into the picture. In unison, they make it possible for developers to come up with dynamic pages which are responsive in nature and most importantly they feel fast. In this review, we detail on how Ajax and JavaScript function with respect to one another to facilitate the building of dynamic web applications and improving the user's experience.

The Key Components of a Complex JavaScript Architecture

Java Script is probably the most important and versatile of all coding languages, for a developer, as he is able to run his code in web browsers. This allows web pages to be manipulated to be JavaScript enabled. Websites are made interactive by replacing contents on the page through a Java script that is able to add or change an HTML document. Moreover, Java Script makes it possible to update an HTML document by creating a web page that responds to associations with external sources. This includes but is not limited to dealing with clicking requests and keyboard tapping orders which are commonplace in webpage creation.

JavaScript is predominantly popular due to its capability to work with other languages and components. In this case, HTML elements can be viewed as nodes in the DOM tree structure. Thanks to JavaScript, the document object model can be altered dynamically to reflect a user's actions and their related results on a website's content, its looks or its arrangement.

For example, through the use of JavaScript, the content of a certain paragraph can be altered, elements can automatically display themselves or disappear depending on whether the user clicks them or not, and even a form can be submitted without the need of reloading the page. Such possibilities can greatly enhance the interactivity of a website and the responsiveness of its features as there will be no need to reload the entire page after every single action.

What are the Risks of Not Using AJAX While Web Designing

But there is one more concern which JavaScript does not solve: how do I fetch and change server data without refreshing the entire page? The inherent approach to every web development task is the idea that whenever a user wants new information, the browser contacts the GET server through a new request and the new information is loaded within the entire window along with everything else. Such routing can be inconvenient to users, especially in large pages.

This is now where AJAX fits into the picture. AJAX is short for Asynchronous JavaScript and XML. In a more in-depth description, AJAX is a technology that lets web pages exchange information with the web server even without refreshing the page. Thanks to AJAX, web pages can now update smoothly. After a webpage is loaded, and whatever data is required is requested from the server, Javascript can request data, process the data, and update the web page, all at once. As such, this means web pages will become faster and more effective when it comes to user interaction, all thanks to AJAX.

What Happens Behind AJAX?

With AJAX, parallel processing of information is made possible in a web page that is quite loaded with a lot of scripts running. For instance, a single page interacting with a multi level server network also relying on a SQL server whose response would take some time. So a typical AJAX request works like this when a AJAX enabled page is fully rendered and being requested, the request gets sent and the JSX code of the AJAX request gets executed and also the native Javascript code present on the page keeps running, retaining the responsiveness of the web page. When the desired data is achieved, the rest of the page goes about rendering as per requirement.

The key ingredient of AJAX frameworks is utilisation of web browsers. AJAX relies heavily on the helper technology of XML, Facebook API/REST plugins. When building an interface, Javascript communicates to a server operating with Virgin Inspector organisms implementation whether through XML or in other instances with JSON. Instead, a newer and more resilient web interface aims to stimulate interaction.

AJAX, Asynchronous JavaScript and XML is basically used to request or download the data to and from the server. It is widely used as it makes it possible to make a web application faster and more interactive.

In an AJAX call/ request there's always a standard function which will help you understand how data gets transferred and submitted to and to other web applications. Here are the steps:


1. Sending request: This is when JavaScript wraps up a request for information and sends it to an external server. The data that can be retrieved can be in the format of text, Json or even XML.

2. Making a request: Then after wrapping up a request, a request is made to the server through a client's browser. This will not refresh the current web page which allows users to work on it while a request has been sent.

3. Processing Dominating: This tells us how the request was made, what was the outcome for the request and if the request needed to retrieve or store any data.

4. Response Receiving: In this phase we determine the server's outcome. The server sends the information back to the client's browser in a language which JavaScript would understand like JSON.

5. Browser page Revision: This will allow a user to revise a web page without refreshing it.

JavaScript with AJAX

JavaScript stands out to be a very important language when it comes to AJAX. It covers all the three phases of making a request till the data is updated on the page. The most basic use of the language is to not make changes to an entire web application but to change only parts of it. This can be done through the document object model modification and updating after the request has been fulfilled by the server.

The above is true as you can see, JavaScript assists with the handling of any problems such as server downtime for an AJAX request which can potentially crash the application, as JavaScript handles the said problems by conveying the issues to the user.

AJAX and JavaScript Integration – Why Use This Combination?

During the combination of JavaScript and AJAX, a lot can be done in relation to the development of pages for a website. One of the greatest advantages of these technologies is their combination allows for creating fast, user-friendly web pages that don't have to be fully reloaded. Here's why JavaScript and AJAX for dynamic web pages are an important set of technologies:

1. Enhanced User Experience: Due to AJAX being employed for dynamic content loading, it means that a user does not have to entirely wait for the page to change. Rather, content is refreshed even as a user is scrolling through new elements on a page, meaning that users experience less waiting time and an overall quiet seamless experience.

2. Saves Server Resources: Rather than sending requests to the server about the whole page to be pushed out, AJAX enables a system to only request the necessary data to be used. This in result minimizes unnecessary requests from being sent to the server which in turn is more efficient.

3. Web Pages with Significantly Higher Speeds: Because AJAX only updates the required data, web pages have lower load times which are essential for users' experience. This is especially crucial for single-page applications requiring dynamic data without a complete system refresh.

4. Increased Engagement with Users: Thanks to AJAX integration, JavaScript enables the developers to build engaging features such as live search, infinite scrolling, and live chat that boost the user experience.

5. Flawless Changes within a Page: Thanks to AJAX, updating the content no longer demands reloading the page, making it convenient to send out notifications or updated information real-time communication without any disruption on the user's activities.

0
0
Article
养花风水
8 hours ago
养花风水
JavaScript has to be one of the most common programming languages we use while building websites. Now, as the applications get more sophisticated or intricate, the need to break down the code into simpler and smaller, reusable and maintainable chunks becomes more and more apparent. This is where JavaScript modules come in. They assist developers in maintaining clean coding practices by splitting them into more comprehensible and more manageable sections. In this post, we will discuss what JavaScript modules are, how they are relevant, and how they change the structure while enhancing the functionality of the JavaScript code.

JavaScript Modules- Concept and Scope

In case you haven't had any idea, a JavaScript module enables developers to divide their codebases into smaller or lets say modular encapsulated components. Each module may include variables, functions, classes that correlate respectively in terms of completing a task or serving a specific feature. This separation makes it possible to create, run tests, and maintain high-level, advanced applications. Earlier, developers had to struggle since JavaScript did not support modules. So all the functions and variables were globally stored which became a hassle to manage which eventually had a lot of errors.

To solve these problems, the module system was one of the features added to JavaScript. Now, thanks to modules, developers can bundle the code in different files and import and export sections of code where they are necessary. This modular development enhances code but also prevents complications that arise from variables being global.

What are JavaScript Modules and How Do They Work?

JavaScript modules export and import code from one another. This is one of the solutions that these modules provide.

1. Exporting

There are two types of exports: named exports and default exports.

First, code from one of the modules must be exported in order for it to be used by other modules.

- Named Exports: These are helpful in exporting more than one object or a function from the module. In order to export, the `export` keyword is written before the particular function or the variable that you want to export.


Named Exports Example

// math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;


- Default Exports: This enables a module to implement sole default export whether it's a function class, or an object the module is restricted to a single default export.

Default Exports Example

//Dummy.js
const logger = (message) => {
    console.log(message);
}
export default logger;


2. Importing

When a code is exported from an inter module, it can then be imported using the `import` syntax to other intermodules within the project connected via the statement.

- Importing Named Exports: While recalling a named export, the bracket curly must be in the same syntax as the named export.

Importing Named Exports Example

//Dummy2.js
import {add, subtract} from './math.js';
console.log(add(2,3)); //5
console.log(subtract(5,3)); //2


- Importing Default Exports: Importing the said module does not require the use of the export mention since there is and can only be one default export which is common in every module.

Importing Default Exports Example

//app.js
import logMessage from './logger.js';
logMessage('This is a log message!');


Benefits of Using JavaScript Modules

There are quite a number of benefits of using modules in JavaScript as listed below:

1. Better Code Structure

It might be a bit hard to handle all the codes that are written in one file as projects get larger and more complex. That's why the use of modules is important, because they allow you to separate codes logically and by their purpose and this makes the logical structure much easier to comprehend. For instance, all logic regarding user authentication could reside within a module and all logic concerning interactions with the database could reside within another module. In that case, developers could develop only one aspect of the application at a time.

2. Avoiding Code Duplication

After creating each utility function, it gets easy to reuse or call it in any part of your application. For example, suppose a module is created that formats dates, and this module is subsequently imported into various others. In this case, all would be well because calling multiple copies of a module adds nothing and increases complexity without adding benefit. This decreases replications and increases manageability since changing the utility function would only have to be done in one spot.

3. Minimizing Global Namespace Pollution

The major problem with traditional JavaScript is its use of global variables and functions, as this allows multiple parts of the program to use the same variable or function which causes conflicts and bugs. On the contrary, modules provide a way in which the variables and functions defined by you are defined into the range of the module and this minimizes the risk of conflicts whilst maintaining the neatness of the easier Javascript namespace.

4. Simplified Testing And Debugging

As a result of modules containing or encapsulating a certain set of features, it becomes easy to test and identify problems in pieces of code without interfering with other parts of the application. For instance, with the help of an in-built debugger such as Chrome DevTools, if a bug develops in a single feature of a program, the only part that will be affected is the module that facilitates that feature, and thus the debugging is done in a targeted manner without affecting the whole program.

5. The Use Of Dynamic Imports

The good thing about JavaScript modules is that you can use the dynamic type of imports alongside it, which allows you to import modules dynamic imports equates to the ability to only pull modules when they are actually needed; this comes in handy when you want to reduce the application's initial loading duration when needed. Frameworks that allow for lazy loading/large applications will particularly benefit from the use of dynamic imports.

Dynamic Imports Example

button.addEventListener('click', () => {
    import('./notThatSmallModule.js').then(module => {
        module.testButton();
    });
});


This pattern of code will allow you to break down your code into various small blocks that will load whenever they are needed instead of loading all at once.

ES6 Modules and the `` tag. By doing this, you assist the browser in decoding the script as a module allowing for the `import` and `export` elements to be used.

Using Modules in HTML



This tells the browser that `app.js` is a module and that it should be handled and implemented in that manner as well. This also makes sure that the module is always loaded with its own scope so that there is no risk of overwriting the global namespace.

0
0
Article
Elite Article
FeedBack

You have any problems or suggestions, please leave us a message.

Please enter content
Set
VIP
Sign out
Share

Share good articles, GFinger floral assistant witness your growth.

Please go to the computer terminal operation

Please go to the computer terminal operation

Forward
Insert topic
Remind friend
Post
/
Submit success Submit fail Picture's max size Success Oops! Something wrong~ Transmit successfully Report Forward Show More Article Help Time line Just Reply Let's chat! Expression Add Picture comment Only support image type .JPG .JPEG .PNG .GIF Image can't small than 300*300px At least one picture Please enter content