舉報 
會員
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
推薦閱讀
- Mastering OpenLayers 3
- Blender 3D Incredible Machines
- 名師講壇：Java微服務架構實戰（SpringBoot+SpringCloud+Docker+RabbitMQ）
- Nginx Essentials
- 信息技術應用基礎
- Natural Language Processing with Java and LingPipe Cookbook
- Test-Driven JavaScript Development
- Hands-On Nuxt.js Web Development
- 深度探索Go語言：對象模型與runtime的原理特性及應用
- 計算機組裝與維護（第二版）
- Mastering Leap Motion
- Android高級開發實戰：UI、NDK與安全
- 區塊鏈：技術與場景
- jQuery基礎教程（第4版）
- JavaWeb入門經典
- Learning Embedded Android N Programming
- 計算機應用基礎教程
- C# 6 and .NET Core 1.0：Modern Cross：Platform Development
- Elasticsearch技術解析與實戰
- Java程序員職場全攻略
- 零基礎學Pine Script：基于TradingView平臺的量化分析
- Julia設計模式
- Swift項目開發基礎教程
- Zend Framework 2.0 by Example：Beginner’s Guide
- Visual C#程序設計應用教程（第2版）
- Java程序設計經典300例
- 敏捷測試：以持續測試促進持續交付
- 深入淺出Java編程
- MariaDB Essentials
- Android開發藝術探索
