舉報 
會員
Learning Scala Programming
ThisbookisforprogrammerswhochoosetogetagripoverScalatowriteconcurrent,scalable,andreactiveprograms.Nopriorexperiencewithanyprogramminglanguageisrequiredtolearntheconceptsexplainedinthisbook.Knowledgeofanyprogramminglanguagewouldhelpthereaderunderstandingconceptsfasterthough.
目錄(275章)
倒序
- coverpage
- Title Page
- Packt Upsell
- Why subscribe?
- PacktPub.com
- Contributors
- About the author
- About the reviewer
- Packt is searching for authors like you
- Preface
- Who this book is for
- What this book covers
- To get the most out of this book
- Download the example code files
- Conventions used
- Get in touch
- Reviews
- Getting Started with Scala Programming
- Introduction to Scala
- A programming paradigm
- Object-oriented versus functional paradigms
- Scala is multi-paradigm
- Scala advantages
- Runs on JVM
- Super smart syntax
- Best of both worlds
- Type is the core
- Concurrency made easy
- Asynchronous code
- Asynchronous versus parallel versus concurrent programming
- Now available for the frontend
- Smart IDEs
- Extensive language
- Online support
- Working with Scala
- Java installation
- SBT installation
- Scala REPL
- Scala IDEs
- Running our first program
- Summary
- Building Blocks of Scala
- What is underneath a Scala program?
- Vals and vars
- Literals
- Integer literals
- Floating point literals
- Boolean literals
- Character literals
- String literals
- Symbol literals
- Tuple literals
- Function literals
- Data types
- Scala's class hierarchy
- Any
- AnyVal and AnyRef
- AnyRef
- AnyVal
- Unit
- Boolean
- Null and Nothing
- Type inference
- Operators in Scala
- Arithmetic operators
- Relational operators
- Logical operators
- Bitwise operators
- Operator precedence
- Wrapper classes
- String Interpolators
- The s interpolator
- f Interpolator
- The raw interpolator
- Summary
- Shaping our Scala Program
- Looping
- The for loop
- The while Loop
- The do while loop
- The for expressions
- The for yield expressions
- Recursion
- Why recursion over iteration?
- Limitations of recursion
- The ideal way to write recursive functions
- Conditional statements
- The if else conditional expression
- Pattern matching
- Summary
- Giving Meaning to Programs with Functions
- Function syntax
- Nesting of functions
- Calling a function
- Passing a variable number of arguments
- Calling a function with a default parameter value
- Calling a function while passing named arguments
- Function literals
- Evaluation strategies
- Call by name
- Call by value
- Partial functions
- Summary
- Getting Familiar with Scala Collections
- Motivation
- Immutable and mutable collections
- Differences between the root and immutable collections
- Hierarchy of collections in Scala
- Traversable
- Iterable
- Seq
- Sequences
- Map
- Set
- Commonly used collections in Scala
- List
- Map
- SortedSet
- Streams
- Vector
- Immutable stack
- Immutable queue
- Ranges
- ArrayBuffer
- ListBuffer
- StringBuilder
- Array
- Rich operations performed on collections
- Parallel collections in Scala
- ParArray
- ParVector
- Converting a Java collection into a Scala collection
- Choosing a collection
- Collection performance
- Summary
- Object-Oriented Scala Basics
- Classes
- Abstract classes
- Abstract classes and traits
- The final classes
- Objects as singletons
- Companion objects
- Case classes
- Summary
- Next Steps in Object-Oriented Scala
- Composition and inheritance
- Class inheritance
- Extending classes
- Subtyping versus subclassing
- Overriding data and behavior
- Restricting inheritance – final keyword
- Dynamic binding in function invocation
- Misusing inheritance
- Default and parameterized constructors
- Traits
- Traits as mix-ins
- Traits as composable mix-ins
- Traits as stackable modifications
- Linearization
- Packaging and importing
- Package statements
- Multiple package statements in a file
- Nested package statements
- Chaining package statements
- Importing packages
- Visibility rules
- Sealed traits
- Summary
- More on Functions
- Function literals
- Methods
- Functions versus methods
- Methods or functions?
- What are closures?
- Higher-order functions
- Currying
- Converting a function with multiple parameters to curried form
- Partially applied functions
- Summary
- Using Powerful Functional Constructs
- For expressions
- Pattern matching
- Different ways we can pattern match
- Matching a variable
- Matching a constant
- Matching a constructor
- Option type
- Lazy declaration
- Tail call optimization
- Combinators
- Type parameterization
- Summary
- Advanced Functional Programming
- Why so serious about types?
- Here comes type parameterization
- Another way around - generic classes and traits
- Type parameter names
- Container types
- Type erasure
- Variance under inheritance
- When to use what type of variance relation
- Abstract types
- Type bounds
- Abstract versus parameterized types
- Type-classes
- Summary
- Working with Implicits and Exceptions
- Exception handling – the old way
- Using the Option way
- Either left or right
- Implicits - what and why
- Implicit parameters
- The implicitly method
- Implicit conversions
- Looking for implicits
- Type-classes ahead!
- Summary
- Introduction to Akka
- Why do we care about Akka?
- What's up with the Actor Model?
- Understanding the Actor system
- Props
- Actor references and paths
- Selecting existing actorRefs via actorSelection
- How the Actor life cycle works
- Hello world in Akka
- Setting up the environment
- Writing our first Actor
- The tell versus ask versus forward method
- Stopping Actors
- The preStart and postStop hooks
- Actor communication via messages and its semantics
- Supervising fault in our actors
- OneForOne versus AllForOne strategy
- Default supervision strategy
- Applying the supervision strategy
- Testing actors
- Summary
- Concurrent Programming in Scala
- Concurrent programming
- Building blocks of concurrency
- Understanding processes and threads
- Locks and synchronization
- Executor and ExecutionContext
- Asynchronous programming
- Working with Futures
- What if Future computations go wrong?
- Why not compose two or more Futures?
- Working with Promises
- Parallel collections
- Summary
- Programming with Reactive Extensions
- Reactive programming
- Reactive extensions
- React to RxScala
- Creating Observables
- Summary
- Testing in Scala
- The why and what of TDD
- The process of TDD
- Step 1 - write a test that will fail
- Step 2 - write code to pass the failing test
- Step 3 - refactor the code to improve the quality
- Step 4 - repeat steps 1 to 3
- Scenario
- Behavior driven development (BDD)
- ScalaTest
- Setting up for testing
- Testing in style using ScalaTest
- Assertions
- Matchers
- ScalaMock – a native library to mock objects
- Summary
- Other Books You May Enjoy
- Leave a review - let other readers know what you think 更新時間：2021-06-30 19:08:34
推薦閱讀
- Python編程自學手冊
- Python程序設計（第3版）
- AngularJS Web Application Development Blueprints
- SQL for Data Analytics
- Learning Python Design Patterns
- Java系統(tǒng)化項目開發(fā)教程
- Mastering ROS for Robotics Programming
- Flowable流程引擎實戰(zhàn)
- Arduino計算機視覺編程
- Apache Camel Developer's Cookbook
- JavaScript機器人編程指南
- JavaScript+jQuery網(wǎng)頁特效設計任務驅動教程
- 零基礎學HTML+CSS第2版
- MATLAB 2020 GUI程序設計從入門到精通
- 可視化H5頁面設計與制作：Mugeda標準教程
- Web程序設計與架構
- Splunk Developer's Guide（Second Edition）
- C++面向對象程序設計教程
- C語言從入門到精通（第4版）
- JavaScript Security
- LabVIEW案例實戰(zhàn)
- Instant Windows 8 C++ Application Development How-to
- 倉頡編程快速上手
- 零基礎學Pine Script：基于TradingView平臺的量化分析
- Apache Kafka
- Backbone.js實戰(zhàn)
- Go語言學習指南：慣例模式與編程實踐
- Python 3.8從零開始學
- 基于Kotlin的Spring Boot微服務實戰(zhàn)
- 輕量級Java EE企業(yè)應用開發(fā)實戰(zhàn)
