on 26-Nov-2023 (Sun)

自动控制理论是研究自动控制共同规律的一门学科。尽管自动控制系统有不同的类型，对每个系统也都有不同的特殊要求，但对于各类系统来说，在已知系统的结构和参数时，我们感兴趣的都是系统在某种典型输入信号下，其被控量变化的全过程。例如，对恒值控制系统是研究扰动作用引起被控量变化的全过程；对随动系统是研究被控量如何克服扰动影响并跟随输入量的变化全过程。但是，对每一类系统被控量变化全过程提出的共同基本要求都是一样的，且可以归结为稳定性、快速性和准确性，即稳、准、快的要求

Preface (whole section)

Part I. Tutorial (whole section)

Part II. The SQL Language (whole language)

Part III. Server Administration (whole section)

Part IV. Client Interfaces (whole section)

Part V. Server Programming (whole section)

Part VI. Reference (whole section)

Part VII. Internals (whole section)

Part VIII. Appendixes (whole section)

Bibliography (whole section)

Index (whole section)

Go programs are organized into packages

A package is a collection of source files in the same directory that are compiled together.

Functions, types, variables, and constants defined in one source file are visible to all other source files within the same package.

A repository contains one or more modules, but typically contains only one module, located at the root of the respository.

A module is a collection of related Go packages that are released together.

A file named go.mod at the root of the module declares the module path : the import path prefix for all packages within the module.

The module contains the packages in the directory containing its go.mod file as well as subdirectories of that directory, up to the next subdirectory containing another go.mod file (if any).

An import path is a string used to import a package. A package's import path is its module path joined with its subdirectory within the module. For example, the module github.com/google/go-cmp contains a package in the directory cmp/. That package's import path is github.com/google/go-cmp/cmp. Packages in the standard library do not have a module path prefix.

React apps are made out of components. A component is a piece of the UI (user interface) that has its own logic and appearance. A component can be as small as a button, or as large as an entire page.

React components are JavaScript functions that return markup:

 function MyButton ( ) { 
 return ( 
 < button > I'm a button </ button > 
 ) ; 
 } 

React component names must always start with a capital letter, while HTML tags must be lowercase.

Now that you’ve declared MyButton, you can nest it into another component:

 export default function MyApp ( ) { 
 return ( 
 < div > 
 < h1 > Welcome to my app </ h1 > 
 < MyButton /> 
 </ div > 
 ) ; 
 } 

The export default keywords specify the main component in the file.

If you’re not familiar with some piece of JavaScript syntax, MDN and javascript.info have great references.

The markup syntax you’ve seen above is called JSX. It is optional, but most React projects use JSX for its convenience. All of the tools we recommend for local development support JSX out of the box.

JSX is stricter than HTML. You have to close tags like <br />. Your component also can’t return multiple JSX tags. You have to wrap them into a shared parent, like a <div>...</div> or an empty <>...</> wrapper

If you have a lot of HTML to port to JSX, you can use an online converter.

In React, you specify a CSS class with className. It works the same way as the HTML class attribute:

 < img className = "avatar" /> 

React does not prescribe how you add CSS files. In the simplest case, you’ll add a <link> tag to your HTML. If you use a build tool or a framework, consult its documentation to learn how to add a CSS file to your project.

JSX lets you put markup into JavaScript. Curly braces let you “escape back” into JavaScript so that you can embed some variable from your code and display it to the user. For example, this will display user.name:

 return ( 
 < h1 > 
 { user . name } 
 </ h1 > 
 ) ; 

You can also “escape into JavaScript” from JSX attributes, but you have to use curly braces instead of quotes. For example, className="avatar" passes the "avatar" string as the CSS class, but src={user.imageUrl} reads the JavaScript user.imageUrl variable value, and then passes that value as the src attribute:

 return ( 
 < img 
 className = "avatar" 
 src = { user . imageUrl } 
 /> 
 ) ; 

const user = { name : 'Hedy Lamarr' , imageUrl : 'https://i.imgur.com/yXOvdOSs.jpg' , imageSize : 90 , } ;
export default function Profile ( ) { return ( < > < h1 > { user . name } </ h1 > < img className = "avatar" src = { user . imageUrl } alt = { 'Photo of ' + user . name } style = { { width : user . imageSize , height : user . imageSize } } /> </ > ) ; }
Show more

In the above example, style={{}} is not a special syntax, but a regular {} object inside the style={ } JSX curly braces. You can use the style attribute when your styles depend on JavaScript variables.

Conditional rendering

In React, there is no special syntax for writing conditions. Instead, you’ll use the same techniques as you use when writing regular JavaScript code. For example, you can use an if statement to conditionally include JSX:

 let content ; 
 if ( isLoggedIn ) { 
 content = < AdminPanel /> ; 
 } else { 
 content = < LoginForm /> ; 
 } 
 return ( 
 < div > 
 { content } 
 </ div > 
 ) ; 

If you prefer more compact code, you can use the conditional ? operator. Unlike if, it works inside JSX:

 < div > 
 { isLoggedIn ? ( 
 < AdminPanel /> 
 ) : ( 
 < LoginForm /> 
 ) } 
 </ div > 

When you don’t need the else branch, you can also use a shorter logical && syntax:

 < div > 
 { isLoggedIn && < AdminPanel /> } 
 </ div > 

All of these approaches also work for conditionally specifying attributes. If you’re unfamiliar with some of this JavaScript syntax, you can start by always using if...else.

You will rely on JavaScript features like for loop and the array map() function to render lists of components.

 const listItems = products . map ( product => 
 < li key = { product . id } > 
 { product . title } 
 </ li > 
 ) ; 
 
 return ( 
 < ul > { listItems } </ ul > 
 ) ; 

Notice how <li> has a key attribute. For each item in a list, you should pass a string or a number that uniquely identifies that item among its siblings. Usually, a key should be coming from your data, such as a database ID. React uses your keys to know what happened if you later insert, delete, or reorder the items.

App.js

Responding to events

You can respond to events by declaring event handler functions inside your components:

 function MyButton ( ) { 
 function handleClick ( ) { 
 alert ( 'You clicked me!' ) ; 
 } 
 
 return ( 
 < button onClick = { handleClick } > 
 Click me
 </ button > 
 ) ; 
 } 

Notice how onClick={handleClick} has no parentheses at the end! Do not call the event handler function: you only need to pass it down. React will call your event handler when the user clicks the button.

Updating the screen

Often, you’ll want your component to “remember” some information and display it. For example, maybe you want to count the number of times a button is clicked. To do this, add state to your component.

First, import useState from React:

 import { useState } from 'react' ; 

Now you can declare a state variable inside your component:

 function MyButton ( ) { 
 const [ count , setCount ] = useState ( 0 ) ; 
 // ... 

You’ll get two things from useState: the current state (count), and the function that lets you update it (setCount). You can give them any names, but the convention is to write [something, setSomething].

The first time the button is displayed, count will be 0 because you passed 0 to useState(). When you want to change state, call setCount() and pass the new value to it. Clicking this button will increment the counter:

 function MyButton ( ) { 
 const [ count , setCount ] = useState ( 0 ) ; 
 
 function handleClick ( ) { 
 setCount ( count + 1 ) ; 
 } 
 
 return ( 
 < button onClick = { handleClick } > 
 Clicked { count } times
 </ button > 
 ) ; 
 } 

React will call your component function again. This time, count will be 1. Then it will be 2. And so on.

If you render the same c

...

The most popular text editors for Go are VSCode (free), GoLand (paid), and Vim (free).

Enable dependency tracking for your code.

When your code imports packages contained in other modules, you manage those dependencies through your code's own module. That module is defined by a go.mod file that tracks the modules that provide those packages. That go.mod file stays with your code, including in your source code repository.

To enable dependency tracking for your code by creating a go.mod file, run the go mod init command, giving it the name of the module your code will be in. The name is the module's module path.

In actual development, the module path will typically be the repository location where your source code will be kept. For example, the module path might be github.com/mymodule. If you plan to publish your module for others to use, the module path must be a location from which Go tools can download your module. For more about naming a module with a module path, see Managing dependencies.

For the purposes of this tutorial, just use example/hello.

$ go mod init example/hello
go: creating new go.mod: module example/hello

The go run command is one of many go commands you'll use to get things done with Go. Use the following command to get a list of the others:

$ go help

Go will add the quote module as a requirement, as well as a go.sum file for use in authenticating the module. For more, see Authenticating modules in the Go Modules Reference.

React (whole document)

React

Programmatic React features:

• Hooks - Use different React features from your components.
• Components - Documents built-in components that you can use in your JSX.
• APIs - APIs that are useful for defining components.
• Directives - Provide instructions to bundlers compatible with React Server Components.

React DOM

React-dom contains features that are only supported for web applications (which run in the browser DOM environment). This section is broken into the following:

• Hooks - Hooks for web applications which run in the browser DOM environment.
• Components - React supports all of the browser built-in HTML and SVG components.
• APIs - The react-dom package contains methods supported only in web applications.
• Client APIs - The react-dom/client APIs let you render React components on the client (in the browser).
• Server APIs - The react-dom/server APIs let you render React components to HTML on the server.

Legacy APIs

• Legacy APIs - Exported from the react package, but not recommended for use in newly written code.

This document gives tips for writing clear, idiomatic Go code. It augments the language specification, the Tour of Go, and How to Write Go Code, all of which you should read first.