一个压缩包,里面含有 Verilog源码和课设报告两个文件夹 源码有六个实验 1/2分频器 触发器 全加器 8位比较器 等 还有个自选题存储器 实验报告 包括实验目的,实验题目,实验要求,仿真图分析,实验心得等 直接就可以用了
2022-06-17 01:39:41
300KB
1
go语言入门教程，让你轻松的入门学习掌握。Go语言是谷歌推出的一种全新的编程语言，可以在不损失应用程序性能的情况下降低代码的复杂性。谷歌首席软件工程师罗布派克(Rob Pike)说：我们之所以开发Go，是因为过去10多年间软件开发的难度令人沮丧。
2022-06-13 10:31:23
273KB
1
The Way to Go，: A Thorough Introduction to the Go Programming Language 英文书籍，已Cross the wall，从Google获得书中源代码，分享一下。喜欢请购买正版。
目录如下：
Contents
Preface................................................................................................................................. xix
PART 1—WHY LEARN GO—GETTING STARTED
Chapter 1—Origins, Context and Popularity of Go...............................................................1
1.1 Origins and evolution................................................................................................1
1.2 Main characteristics, context and reasons for developing a new language....................4
1.2.1 Languages that influenced Go.........................................................................4
1.2.2 Why a new language?......................................................................................5
1.2.3 Targets of the language....................................................................................5
1.2.4 Guiding design principles...............................................................................7
1.2.5 Characteristics of the language........................................................................7
1.2.6 Uses of the language........................................................................................8
1.2.7 Missing features?.............................................................................................9
1.2.8 Programming in Go......................................................................................10
1.2.9 Summary......................................................................................................10
Chapter 2—Installation and Runtime Environment............................................................11
2.1 Platforms and architectures.....................................................................................11
(1) The gc Go-compilers:..................................................................................11
(2) The gccgo-compiler:....................................................................................13
(3) File extensions and packages:.......................................................................14
2.2 Go Environment variables........................................................................................14
2.3 Installing Go on a Linux system...............................................................................16
2.4 Installing Go on an OS X system.............................................................................21
2.5 Installing Go on a Windows system.........................................................................21
2.6 What is installed on your machine? .........................................................................26
2.7 The Go runtime.......................................................................................................27
2.8 A Go interpreter ......................................................................................................27
Chapter 3—Editors, IDE’s and Other tools.........................................................................28
3.1 Basic requirements for a decent Go development environment.................................28
3.2 Editors and Integrated Development Environments.................................................29
3.2.1. Golang LiteIDE ..........................................................................................32
3.2.2. GoClipse......................................................................................................33
3.3 Debuggers................................................................................................................34
3.4 Building and running go-programs with command- and Makefiles..........................35
3.5 Formatting code: go fmt or gofmt............................................................................39
3.6 Documenting code: go doc or godoc........................................................................40
3.7 Other tools...............................................................................................................41
3.8 Go’s performance.....................................................................................................41
3.9 Interaction with other languages...............................................................................43
3.9.1. Interacting with C .......................................................................................43
3.9.2. Interacting with C++....................................................................................45
PART 2—CORE CONSTRUCTS AND TECHNIQUES OF THE LANGUAGE
Chapter 4—Basic constructs and elementary data types.......................................................49
4.1. Filenames—Keywords—Identifiers..........................................................................49
4.2. Basic structure and components of a Go-program...................................................50
4.2.1 Packages, import and visibility......................................................................51
4.2.3 Comments....................................................................................................56
4.2.4 Types............................................................................................................57
4.2.5 General structure of a Go-program...............................................................58
4.2.6 Conversions..................................................................................................60
4.2.7 About naming things in Go..........................................................................60
4.3. Constants................................................................................................................60
4.4. Variables..................................................................................................................63
4.4.1 Introduction.................................................................................................63
4.4.2 Value types and reference types.....................................................................66
4.4.3 Printing........................................................................................................68
4.4.4 Short form with the := assignment operator..................................................69
4.4.5 Init-functions................................................................................................70
4.5. Elementary types and operators...............................................................................73
4.5.1. Boolean type bool........................................................................................73
4.5.2. Numerical types...........................................................................................75
4.5.2.1 ints and floats.............................................................................................75
4.5.2.2 Complex numbers.....................................................................................79
4.5.2.3 Bit operators..............................................................................................79
4.5.2.4 Logical operators........................................................................................81
4.5.2.5 Arithmetic operators.................................................................................82
4.5.2.6 Random numbers......................................................................................82
4.5.3. Operators and precedence............................................................................84
4.5.4. Aliasing types...............................................................................................84
4.5.5. Character type.............................................................................................85
4.6. Strings.....................................................................................................................86
4.7. The strings and strconv package..............................................................................88
4.7.1—Prefixes and suffixes:...................................................................................88
4.7.2—Testing whether a string contains a substring:.............................................89
4.7.3—Indicating at which position (index) a substring or character occurs
in a string:...................................................................................................89
4.7.4—Replacing a substring:................................................................................90
4.7.5—Counting occurrences of a substring:..........................................................90
4.7.6—Repeating a string:.....................................................................................90
4.7.7—Changing the case of a string:....................................................................91
4.7.8—Trimming a string:.....................................................................................92
4.7.9—Splitting a string:........................................................................................92
4.7.10—Joining over a slice:..................................................................................92
4.7.11—Reading from a string:..............................................................................93
4.8. Times and dates.......................................................................................................95
4.9. Pointers...................................................................................................................96
Chapter 5—Control structures...........................................................................................101
5.1—The if else construct............................................................................................101
5.2—Testing for errors on functions with multiple return values..................................106
5.3—The switch keyword............................................................................................110
5.4—The for construct................................................................................................114
5.4.1 Counter-controlled iteration.......................................................................114
Character on position 2 is:...........................................................................................116
5.4.2 Condition-controlled iteration ...................................................................117
5.4.3 Infinite loops .............................................................................................118
5.4.4 The for range construct...............................................................................119
5.5—Break / continue..................................................................................................121
5.6—Use of labels with break and continue—goto.......................................................123
Chapter 6—Functions.......................................................................................................126
6.1 Introduction...........................................................................................................126
6.2 Parameters and return values..................................................................................129
6.2.1 Call by value / Call by reference..................................................................129
6.2.2 Named return variables...............................................................................131
6.2.3 Blank identifier...........................................................................................133
6.2.4 Changing an outside variable......................................................................134
6.3 Passing a variable number of parameters.................................................................135
6.4 Defer and tracing...................................................................................................137
6.5 Built-in functions...................................................................................................142
6.6 Recursive functions................................................................................................143
6.8 Closures (function literals).....................................................................................147
6.9 Applying closures: a function returning another function ......................................150
6.10 Debugging with closures......................................................................................153
6.11 Timing a function ...............................................................................................154
6.12 Using memoization for performance....................................................................154
Chapter 7—Arrays and Slices.............................................................................................157
7.1 Declaration and initialization.................................................................................157
7.1.1 Concept......................................................................................................157
7.1.2 Array literals................................................................................................161
7.1.3 Multidimensional arrays..............................................................................162
7.1.4 Passing an array to a function......................................................................163
7.2 Slices......................................................................................................................164
7.2.1 Concept......................................................................................................164
7.2.2 Passing a slice to a function.........................................................................168
7.2.3 Creating a slice with make()........................................................................168
7.2.4 Difference between new() and make().........................................................170
7.2.5 Multidimensional slices...............................................................................171
7.2.6 The bytes package.......................................................................................171
7.3 For range construct................................................................................................172
7.4 Reslicing.................................................................................................................175
7.5 Copying and appending slices................................................................................176
7.6 Applying strings, arrays and slices...........................................................................178
7.6.1 Making a slice of bytes from a string...........................................................178
7.6.2 Making a substring of a string.....................................................................179
7.6.3 Memory representation of a string and a slice..............................................179
7.6.4 Changing a character in a string..................................................................180
7.6.5 Comparison function for byte arrays...........................................................180
7.6.6 Searching and sorting slices and arrays.......................................................181
7.6.7 Simulating operations with append.............................................................182
7.6.8 Slices and garbage collection.......................................................................182
Chapter 8—Maps..............................................................................................................185
8.1 Declaration, initialization and make.......................................................................185
8.1.1 Concept......................................................................................................185
8.1.2 Map capacity..............................................................................................188
8.1.3 Slices as map values.....................................................................................188
8.2 Testing if a key-value item exists in a map—Deleting an element...........................188
8.3 The for range construct..........................................................................................190
8.4 A slice of maps......................................................................................................191
8.5 Sorting a map.........................................................................................................192
8.6 Inverting a map......................................................................................................194
Chapter 9—Packages.........................................................................................................196
A The standard library..................................................................................................196
9.1 Overview of the standard library.............................................................................196
9.2 The regexp package................................................................................................199
9.3 Locking and the sync package................................................................................200
9.4 Accurate computations and the big package...........................................................202
B Custom and external packages: use, build, test, document, install.............................203
9.5 Custom packages and visibility...............................................................................203
9.6 Using godoc for your custom packages...................................................................208
9.7 Using go install for installing custom packages.......................................................210
9.8 Custom packages: map structure, go install and go test..........................................212
9.8.1 Map-structure for custom packages.............................................................212
9.8.2 Locally installing the package......................................................................215
9.8.3 OS dependent code.....................................................................................216
9.9 Using git for distribution and installation...............................................................216
9.9.1 Installing to github.....................................................................................216
9.9.2 Installing from github.................................................................................217
9.10 Go external packages and projects. ......................................................................218
9.11 Using an external library in a Go program............................................................219
Chapter 10—Structs and Methods.....................................................................................224
10.1 Definition of a struct............................................................................................224
10.2 Creating a struct variable with a Factory method..................................................232
10.2.1 A factory for structs..................................................................................232
10.2.2 new() and make() revisited for maps and structs:.......................................234
10.3 Custom package using structs...............................................................................235
10.4 Structs with tags...................................................................................................236
10.5 Anonymous fields and embedded structs..............................................................237
10.5.1 Definition.................................................................................................237
10.5.2 Embedded structs.....................................................................................238
10.5.3 Conflicting names.....................................................................................239
10.6 Methods...............................................................................................................240
10.6.1 What is a method?....................................................................................240
10.6.2 Difference between a function and a method............................................244
10.6.3 Pointer or value as receiver........................................................................245
10.6.4 Methods and not-exported fields..............................................................247
10.6.5 Methods on embedded types and inheritance............................................248
10.6.6 How to embed functionality in a type.......................................................251
10.6.7 Multiple inheritance..................................................................................253
10.6.8 Universal methods and method naming....................................................256
10.6.9 Comparison between Go types and methods and other
object-oriented languages...........................................................................256
10.7 The String()-method and format specifiers for a type...........................................258
10.8 Garbage collection and SetFinalizer......................................................................261
Chapter 11—Interfaces and reflection................................................................................263
11.1 What is an interface?............................................................................................263
11.2 Interface embedding interface(s)...........................................................................270
11.3 How to detect and convert the type of an interface variable: type assertions.........270
11.4 The type switch....................................................................................................273
11.5 Testing if a value implements an interface.............................................................274
11.6 Using method sets with interfaces.........................................................................275
11.7 1st example: sorting with the Sorter interface........................................................277
11.8 2nd example: Reading and Writing......................................................................282
11.9 Empty Interface...................................................................................................284
11.9.1 Concept....................................................................................................284
11.9.2 Constructing an array of a general type or with variables of
different types............................................................................................286
11.9.3 Copying a data-slice in a slice of interface{}...............................................287
11.9.4 Node structures of general or different types.............................................288
11.9.5 Interface to interface.................................................................................289
11.10 The reflect package.............................................................................................290
11.10.1 Methods and types in reflect...................................................................290
11.10.2 Modifying (setting) a value through reflection........................................293
11.10.3 Reflection on structs...............................................................................294
11.11 Printf and reflection...........................................................................................296
11.12 Interfaces and dynamic typing............................................................................298
11.12.1 Dynamic typing in Go............................................................................298
11.12.2 Dynamic method invocation...................................................................300
11.12.3 Extraction of an interface........................................................................301
11.12.4 Explicitly indicating that a type implements an interface........................303
11.12.5 Empty interface and function overloading..............................................304
11.12.6 Inheritance of interfaces..........................................................................304
11.13 Summary: the object-orientedness of Go............................................................306
11.14 Structs, collections and higher order functions...................................................306
PART 3—ADVANCED GO
Chapter 12—Reading and writing.....................................................................................313
12.1 Reading input from the user.................................................................................313
12.2 Reading from and writing to a file........................................................................317
12.2.1 Reading from a file....................................................................................317
12.2.2 The package compress: reading from a zipped file.....................................321
12.2.3 Writing to a file.........................................................................................322
12.3 Copying files........................................................................................................324
12.4 Reading arguments from the command-line.........................................................325
12.4.1 With the os-package..................................................................................325
12.4.2 With the flag-package...............................................................................326
12.5 Reading files with a buffer....................................................................................328
12.6 Reading and writing files with slices.....................................................................330
12.7 Using defer to close a file.....................................................................................332
12.8 A practical example of the use of interfaces: fmt.Fprintf......................................332
12.9 The json dataformat.............................................................................................334
12.10 The xml dataformat............................................................................................340
12.11 Datatransport through gob.................................................................................342
12.12 Cryptography with go........................................................................................345
Chapter 13—Error-handling and Testing...........................................................................348
13.1 Error-handling.....................................................................................................349
13.1.1 Defining errors..........................................................................................349
13.1.2 Making an error-object with fmt..............................................................353
13.2 Run-time exceptions and panic............................................................................353
13.4 Error-handling and panicking in a custom package..............................................357
13.5 An error-handling scheme with closures...............................................................360
13.6 Starting an external command or program...........................................................363
13.7 Testing and benchmarking in Go.........................................................................364
13.8 Testing: a concrete example..................................................................................367
13.9 Using table-driven tests........................................................................................369
13.10 Investigating performance: tuning and profiling Go programs............................371
13.10.1 Time and memory consumption.............................................................371
13.10.2 Tuning with go test.................................................................................371
13.10.3 Tuning with pprof...................................................................................371
Chapter 14—Goroutines and Channels.............................................................................375
14.1 Concurrency, parallelism and goroutines..............................................................375
14.1.1 What are goroutines?................................................................................375
14.1.2 The difference between concurrency and parallelism.................................377
14.1.3 Using GOMAXPROCS............................................................................378
14.1.4 How to specify the number of cores to be used on the command-line?.....379
14.1.5 Goroutines and coroutines........................................................................381
14.2 Channels for communication between goroutines................................................381
14.2.1 Concept....................................................................................................381
14.2.2 Communication operator <-.....................................................................383
14.2.3 Blocking of channels.................................................................................385
14.2.4 Goroutines synchronize through the exchange of data on one (or
more) channel(s)........................................................................................387
14.2.5 Asynchronous channels—making a channel with a buffer.........................387
14.2.6 Goroutine using a channel for outputting result(s)....................................388
14.2.7 Semaphore pattern....................................................................................389
14.2.8 Implementing a parallel for-loop...............................................................391
14.2.9 Implementing a semaphore using a buffered channel................................391
14.2.10 For—range applied to channels...............................................................394
14.2.11 Channel directionality............................................................................396
14.3 Synchronization of goroutines: closing a channel—testing for blocked channels..400
14.4 Switching between goroutines with select.............................................................403
14.5 Channels, Timeouts and Tickers...........................................................................408
14.6 Using recover with goroutines..............................................................................412
14.7 Comparing the old and the new model: Tasks and Worker processes....................413
14.8 Implementing a lazy generator..............................................................................416
14.9 Implementing Futures..........................................................................................420
14.10 Multiplexing......................................................................................................421
14.10.1 A typical client-server pattern..................................................................421
14.10.2 Teardown: shutdown the server by signaling a channel............................424
14.11 Limiting the number of requests processed concurrently....................................427
14.12 Chaining goroutines...........................................................................................428
14.13 Parallelizing a computation over a number of cores............................................429
14.14 Parallelizing a computation over a large amount of data.....................................430
14.15 The leaky bucket algorithm................................................................................431
14.16 Benchmarking goroutines...................................................................................433
14.17 Concurrent acces to objects by using a channel..................................................434
Chapter 15—Networking, templating and web-applications..............................................436
15.1 A tcp-server .........................................................................................................436
15.2 A simple webserver...............................................................................................445
15.3 Polling websites and reading in a web page...........................................................448
15.4 Writing a simple web application.........................................................................452
15.5 Making a web application robust..........................................................................454
15.6 Writing a web application with templates.............................................................456
15.7 Exploring the template package............................................................................461
15.7.1. Field substitution: {{.FieldName}}............................................................462
15.7.2. Validation of the templates.......................................................................463
15.7.3 If-else........................................................................................................464
15.7.4 Dot and with-end.....................................................................................465
15.7.5 Template variables $..................................................................................466
15.7.6 Range-end.................................................................................................467
15.7.7 Predefined template functions...................................................................467
15.8 An elaborated webserver with different functions.................................................468
(works only on Unix because calls /bin/date)........................................................474
15.9 Remote procedure calls with rpc...........................................................................474
15.10 Channels over a network with netchan...............................................................477
15.11 Communication with websocket........................................................................478
15.12 Sending mails with smtp....................................................................................480
PART 4—APPLYING GO
Chapter 16—Common Go Pitfalls or Mistakes..................................................................485
16.1 Hiding (shadowing) a variable by misusing short declaration...............................486
16.2 Misusing strings...................................................................................................486
16.3 Using defer for closing a file in the wrong scope...................................................487
16.4 Confusing new() and make()................................................................................488
16.5 No need to pass a pointer to a slice to a function..................................................488
16.6 Using pointers to interface types...........................................................................488
16.7 Misusing pointers with value types.......................................................................489
16.8 Misusing goroutines and channels........................................................................489
16.9 Using closures with goroutines.............................................................................490
16.10 Bad error handling.............................................................................................491
16.10.1 Don’t use booleans:.................................................................................491
16.10.2 Don’t clutter your code with error-checking:...........................................492
Chapter 17—Go Language Patterns...................................................................................494
17.1 The comma, ok pattern........................................................................................494
17.2 The defer pattern..................................................................................................495
17.3 The visibility pattern............................................................................................497
17.4 The operator pattern and interface.......................................................................497
17.4.1 Implement the operators as functions.......................................................497
17.4.2 Implement the operators as methods.........................................................498
17.4.3 Using an interface.....................................................................................499
Chapter 18—Useful Code Snippets—Performance Advice.................................................500
18.1 Strings..................................................................................................................500
18.2 Arrays and slices...................................................................................................501
18.3 Maps....................................................................................................................502
18.4 Structs..................................................................................................................502
18.5 Interfaces..............................................................................................................503
18.6 Functions.............................................................................................................503
18.7 Files......................................................................................................................504
18.8 Goroutines and channels......................................................................................505
18.9 Networking and web applications.........................................................................507
18.9.1. Templating:......................................................................................................507
18.10 General..............................................................................................................508
18.11 Performance best practices and advice................................................................508
Chapter 19—Building a complete application....................................................................509
19.1 Introduction.........................................................................................................509
19.2 Introducing Project UrlShortener.........................................................................509
19.3 Data structure......................................................................................................510
19.4 Our user interface: a web server frontend.............................................................515
19.5 Persistent storage: gob..........................................................................................519
19.6 Using goroutines for performance........................................................................524
19.7 Using json for storage...........................................................................................527
19.8 Multiprocessing on many machines......................................................................528
19.9 Using a ProxyStore...............................................................................................532
19.10 Summary and enhancements..............................................................................536
Chapter 20—Go in Google App Engine............................................................................538
20.1 What is Google App Engine ?...............................................................................538
20.2 Go in the cloud ...................................................................................................540
20.3 Installation of the Go App Engine SDK: the development environment for Go...540
20.3.1. Installation...............................................................................................540
20.3.2. Checking and testing...............................................................................542
20.4 Building your own Hello world app ....................................................................543
20.4.1 Map structure—Creating a simple http-handler........................................543
20.4.2 Creating the configuration file app.yaml...................................................544
20.4.3 Iterative development................................................................................548
20.4.4. Integrating with the GoClipse IDE..........................................................548
20.5 Using the Users service and exploring its API.......................................................549
20.6 Handling forms....................................................................................................551
20.7 Using the datastore...............................................................................................552
20.8 Uploading to the cloud.......................................................................................556
Chapter 21—Real World Uses of Go.................................................................................559
21.1 Heroku—a highly available consistent data store in Go. ......................................559
21.2 MROffice—a VOIP system for call centers in Go................................................561
21.3 Atlassian—a virtual machine cluster management system.....................................562
21.4 Camlistore—a content addressable storage system................................................563
21.5 Other usages of the Go language..........................................................................563
APPENDICES...................................................................................................................567
(A) CODE REFERENCE...........................................................................................567
(B)CUTE GO QUOTES.............................................................................................571
GO QUOTES: TRUE BUT NOT SO CUTE....................................................572
(C) LIST OF CODE EXAMPLES (Listings)...............................................................572
(E) References in the text to Go—packages..................................................................583
(F) References in the text to Go—tools........................................................................586
(G) Answers to Questions............................................................................................586
(H) ANSWERS TO EXERCISES................................................................................590
(I) BIBLIOGRAPHY (Resources and References)........................................................593
Index..............................................................................................................................597
List of Illustrations
Chapter 1—Origins, Context and Popularity of Go...............................................................1
Fig 1.1: The designers of Go: Griesemer, Thompson and Pike..........................................1
Fig 1.2: The logo’s of Go..................................................................................................3
Fig 1.3: Influences on Go.................................................................................................5
Chapter 3—Editors, IDE’s and Other tools.........................................................................28
Fig 3.1: LiteIDE and its AST-view..................................................................................33
Fig 3.2: GoClipse and its outline code-view...................................................................34
Chapter 4—Basic constructs and elementary data types.......................................................49
Fig 4.1: Value type..........................................................................................................67
Fig 4.2: Assignment of value types..................................................................................67
Fig 4.3: Reference types and assignment.........................................................................67
Fig 4.4: Pointers and memory usage...............................................................................98
Fig 4.5: Pointers and memory usage, 2...........................................................................99
Chapter 7—Arrays and Slices.............................................................................................157
Fig 7.1: Array in memory.............................................................................................158
Fig 7.2: Slice in memory..............................................................................................166
Chapter 9—Packages.........................................................................................................196
Fig 9.1: Package documentation with godoc.................................................................210
Chapter 10—Structs and Methods.....................................................................................224
Fig 10.1: Memory layout of a struct.............................................................................227
Fig 10.2: Memory layout of a struct of structs..............................................................229
Fig. 10.3: Linked list as recursive struct........................................................................230
Fig 10.4: Binary tree as recursive struct.........................................................................230
Chapter 11—Interfaces and reflection................................................................................263
Fig 11.1: Interface value in memory.............................................................................264
Chapter 14—Goroutines and Channels.............................................................................375
Fig 14.1: Channels and goroutines...............................................................................382
Fig 14.2: The sieve prime-algorithm.............................................................................397
Chapter 15—Networking, templating and web-applications..............................................436
Fig 15.1—Screen of exercise 15.6.................................................................................454
Chapter 19—Building a complete application....................................................................509
Fig 19.1: Handler functions in goto.............................................................................515
Fig 19.2: The Add handler...........................................................................................518
Fig 19.3: The response of the Add handler...................................................................519
Fig 19.4: The response of the Redirect handler.............................................................519
Fig 19.5: Distributing the work load over master- and slave computers........................529
Chapter 20—Go in Google App Engine............................................................................538
Fig 20.1: The Application Control Panel......................................................................558
2022-05-30 10:58:09
8.68MB
1
[Perl语言入门_中文版_第六版].(Learning.Perl,.6th.Edition).Randal.L.Schwartz.扫描版.pdf
2022-05-23 11:55:16
17.4MB
1
Ivor Horton 版的
C语言入门经典(第4版)
书中内容里的全部的范例和习题代码，.c的文件格式，可以直接使用。
The zip will have unpacked into two folders, one containing the code from the book and the other
the solutions to the exercises. The names of the files identify the chapter number and the sequence within a chapter so the
file Program2_07.c is the seventh example in Chapter 2, and Ex13_02.c is the solution to the second exercise in Chapter 13.
The solutions to the exercises that I have provided are not necessarily unique,
or even the best solutions. If your solution is different but works, then you have
clearly been successful in completing the exercise.
I hope you are enjoying learning C and I wish you every success.
Ivor Horton
2022-05-09 19:17:26
181KB
1