Let’s take a look at the new front-end "Advanced Incomplete Guide" column.

background

This article is included in "Advanced Incomplete Guide" column

According to the convention of previous series of articles, the first one is generally a background introduction and outline refining. This series is still the same (writing ability is no way here.)

First express my writing purpose:

1. Share with my team members and friends, and complete the promised things, no regrets and no regrets!
2. I want to systematize the advanced route. Of course, there is no way to avoid fragmented content in the writing process, but if I write enough content in the follow-up, I will make a condensed summary (after that, I will talk about it at that step). Vision: It is enough to help latecomers to avoid a few detours!
3. I hope that I can give you some advice on topics facing some career decisions. It is inevitable that you will be nagging in your writing.
4. It is enough to improve your sharing ability, writing ability, empathy ability (with time as companion, reader as companion)!
5. mainly to sort out all the summaries of the excerpts written in the previous memo.

The foundation is unstable (uneven civil strife), how to build high-rise buildings (how to open up territories and expand land).

Column Introduction

Originally, this column only wrote about data structures and algorithms, but a mysterious voice suddenly told me this morning that it is not feasible for you to write data structures and algorithms. (I belong to the obedient type) Answer: Okay, I'll go and change it quickly. ( It’s not unreasonable to think about it carefully. After all, it would be embarrassing to create so many columns if you make a mistake. ) After a long ideological struggle, call it "Advanced Incomplete Guide"

Content module

No matter how big the language difference is, it is nothing more than the system disk read and write, memory allocation, cpu allocation, garbage collection, hardware instruction...this set of things, the realization is vastly different, and the ideas are similar.

Knowing the operating system/operating principle, you will know that the original language coincides with certain purposes. (E.g. javascript container v8=>browser)

Knowing the data structure, you will know why all languages have arrays, linked lists, hashes, and when and how to use them.

Figure out the algorithm, and you will find that if you have a god when writing code, the angle of thinking about the problem will be different.

To figure out the design pattern, the efficiency will increase exponentially when you look at most of the framework principles.

This series will really introduce data structures/algorithms/design patterns.

data structure

First of all, what the basic number structure contains is briefly enumerated and introduced here, and will be gradually discussed later.

• Data Structures
• 1. array (array) : An array is a structure that can store multiple elements continuously in the memory, and the allocation in the memory is also continuous. The elements in the array are accessed through the array subscript.
• 2. linked list (linked list) : Linked list is a non-contiguous, non-sequential storage structure on a physical storage unit. The logical order of data elements is realized by the pointer address of the linked list. Each element contains two nodes, one is a storage element The data field (memory space) of, the other is a pointer field that points to the address of the next node. According to the direction of the pointer, the linked list can form different structures, such as singly linked list, doubly linked list, circular linked list and so on.
• 3. stack (stack) : The stack is a special linear table that can only be operated on one end of the linear table. Operation is allowed at the top of the stack, and operation is not allowed at the bottom of the stack. The characteristics of the stack are: first-in-last-out, or last-in-first-out, the operation of putting elements from the top of the stack is called pushing into the stack, and removing elements is called out of the stack. That is, there are two main operations: push , add elements to the top (end) of the stack; pop , remove the top (end) element of the stack.
• 4. Queue like stack, is also a linear table. The difference is that the queue can add elements at one end and take out elements at the other end, that is, first in, first out. The operation of putting elements in from one end is called enqueue, and taking out elements is dequeue.
• 5. heap heap is a special data structure that can be regarded as an array object of a tree.
• 6. tree tree is a data structure, which is composed of n (n>=1) finite nodes to form a hierarchical collection.
• 7. hash table hash table, also called hash table, is a data structure that is directly accessed according to key codes and values (key and value), and is mapped to a position in the collection through key and value, and can be found quickly The corresponding element in the collection.
• 8. graph (graph) graph is composed of a finite set V of nodes and a set E of edges. Implementation methods include matrix, adjacency list, etc.

The above is just an overview of the content, and the data structure will be gradually introduced in the follow-up. data ~~ Structures ~~

Algorithm (algorithms)

• Searches
• 1. BFS breadth traversal
• 2. DFS deep traversal
• 3. ...
• Sorting
• 1. BubbleSort
• 2. Quicksort Quicksort
• 3. ...
• others...

The above is just an overview of the content, and it will be gradually expanded in the future and will use some of the above data structure algorithms~~~

Design Patterns (design_patterns)

The design pattern comes from the crystallization of the wisdom of experts (not to be a loss), and the design pattern takes into account the reusability and scalability of the system. Design patterns provide a set of common design vocabulary and a common form to improve internal communication more effectively.

Object-oriented design pattern

• Creation mode
• Structural model
• Behavioral model
• ...

Functional design pattern

• Improved OOP Observer Mode
• ...

Design patterns in JS

• Singleton mode
• Strategy mode
• ...

The above content will be expanded later, and all the content mentioned will be reflected in this column. The purpose is to advance. Even if God comes, it can't stop me. I said! design~~~~

Pay attention to the module (please take a look at the introduction/reach a certain consensus)

1. The coding part of this series uses JavaScript. ;
2. All coding parts of this article will be uploaded to github after optimization; the code in the article indicates that the code is for logical reference only.
3. Note that because the coding part is written in a high-level language. There are objective factors such as compilation time. There is inaccuracy in the complexity, and understands the idea as the main purpose.
4. Note that because the coding part is written in javascript, the basic data structure is not "authentic" (for example, the realization of arrays in js has multiple forms of fast arrays and slow arrays (hashtable)).
5. For related code and test code, please refer to the subsequent git warehouse instructions.
6. The content of the series of articles will refer to the existing github warehouse, and each subsequent article will post a reference link.

at last

Please don't question the speed of my column update, because you have to trust each other (I believe you don't believe it. Hahaha).

In short, I guarantee that each column will produce more than one article per week. I need to do some work behind each article: coding & coding test & perfecting the content of the article. Ask for a like.

There is still some hope:

I hope that the writing process can bring me a different way of thinking. Empathy.

I hope that the writing process can bring you something. Principle of co-progress.

Hope it will be sunny tomorrow!