Scala编程实战指南

需积分: 10 73 浏览量更新于2024-07-23 收藏 11.09MB PDF 举报

"Scala Cookbook, 由 Alvin Alexander 编写，涵盖了 Scala 语言的各种实用技巧和解决方案。本书版权属于 Alvin Alexander，2013年由 O'Reilly Media, Inc. 出版。" 《Scala Cookbook》是Alvin Alexander的一本著作，专注于提供Scala编程语言的实践指导。这本书面向已对Scala有一定基础的读者，旨在帮助他们解决实际编程过程中遇到的问题，提高编程效率和代码质量。作为一本“Cookbook”式的指南，书中包含了大量实例和代码片段，覆盖了Scala语言的关键特性，如函数式编程、面向对象设计、类型系统、并发处理、模式匹配以及高级库的使用等。在函数式编程方面，书中的章节可能涉及如何使用高阶函数、闭包以及如何构建不可变数据结构。例如，作者可能会讲解如何通过map、filter和reduce等操作来处理集合，以及如何利用Scala的Option和Either类型来处理可能的异常情况，以实现更安全的代码。在面向对象设计部分，读者可以学习到如何定义类和特质，以及如何使用继承和多态性来构建模块化的软件系统。此外，书中可能还会讨论Scala的case class和pattern matching特性，它们是Scala中进行数据建模和解构的强大工具。在类型系统方面，《Scala Cookbook》会介绍如何利用类型推断和类型别名简化代码，以及如何定义和使用抽象类型和类型成员。同时，它还可能涵盖Scala的类型系统与Java的互操作性，帮助Java开发者更好地过渡到Scala。关于并发处理，书中的内容可能包括如何使用Scala的Actor模型，以及Future和Promise等并发原语。作者可能会详细解释如何在并发环境中正确管理状态和同步问题，以实现高效的并行计算。此外，书中还可能包含对Scala标准库和其他流行库（如Akka、Play框架或ScalaTest）的使用介绍，帮助开发者利用这些工具来开发高性能、可测试的应用程序。《Scala Cookbook》是一本实用的参考书籍，它不仅提供了解决问题的策略，还深入讲解了Scala语言的原理，旨在提升开发者在实际项目中的Scala编程能力。无论是初学者还是经验丰富的开发者，都能从中受益。

In my opinion, Scala is not a good language for teaching a Programming 101 class.

Instead, it’s a power language created for the professional programmer. Don’t let that

scare you, though. If you were my own brother and about to start a new project and

could choose any programming language available, without hesitation I’d say, “Use

Scala.”

Here are a few more nuggets about Scala:

•

It’s a modern programming language created by Martin Odersky (the father of

javac), influenced by Java, Ruby, Smalltalk, ML, Haskell, Erlang, and others.

•

It’s a pure object-oriented programming (OOP) language. Every variable is an ob‐

ject, and every “operator” is a method.

• It’s also a functional programming (FP) language, so you can pass functions around

as variables. You can write your code using OOP, FP, or both.

• Scala code runs on the JVM and lets you use the wealth of Java libraries that have

been developed over the years.

• You can be productive on Day 1, but the language is deep, so as you go along you’ll

keep learning and finding newer, better ways to write code. Scala will change the

way you think about programming—and that’s a good thing.

Of all of Scala’s benefits, what I like best is that it lets you write concise, readable code.

The time a programmer spends reading code compared to the time spent writing code

is said to be at least a 10:1 ratio, so writing code that’s concise and readable is a big deal.

Because Scala has these attributes, programmers say that it’s expressive.

Solutions

I’ve always bought O’Reilly cookbooks for the solutions, and that’s what this book is

about: solving problems.

When using a cookbook, I usually think, “I have this problem, I need to iterate over the

elements in an Array, what’s the best way to do that?” I like to look at the table of contents,

find a recipe, implement the solution, and move on. I tried to write each recipe with

this use case in mind.

However, with a modern language like Scala, it may end up that I phrased my question

wrong. Because of my prior programming experience I may have thought, “I need to

iterate over the elements in an Array,” but in reality my deeper intent was to loop over

those elements for a reason, such as to transform them into a new collection. So it’s nice

when a recipe says, “Hey, I know you’re here to read about how to loop over the elements

in an Array, here’s how you do that”:

for (i <- Array(1,2,3)) println(i)

xiv | Preface

“But, if what you’re really trying to do is transform those elements into a new collection,

what you want is a for/yield expression or map method”:

// for/yield

scala> for (i <- Array(1,2,3)) yield i * 2

res0: Array[Int] = Array(2, 4, 6)

// map

scala> Array(1,2,3).map(_ * 2)

res1: Array[Int] = Array(2, 4, 6)

(More on that _ character shortly.)

To create the list of problems and solutions, I followed the “Eat your own dog food”

philosophy. The recipes come from my own experience of creating Scala scripts, web

applications, web services, Swing applications, and actor-based systems. As I developed

the applications I needed, I encountered problems like these:

• Scala files tend to be very small; what’s the proper way to organize an application?

• It looks like SBT is the best build tool for Scala, but it’s different than Ant or Maven;

how do I compile and package applications, and work with dependencies?

• Constructors are really different than Java; how do I create them? What code is

generated when I declare constructor parameters and class fields?

•

Actors are cool; how do I write a complete actor-based application?

•

What, I shouldn’t use null values anymore? Why not? How do I code without them?

•

I can pass a function around like any other variable? How do I do that, and what’s

the benefit?

•

Why are there so many collections classes, and why does each collection class have

so many methods?

•

I have all of this legacy Java code; can I still use it in Scala? If so, how?

•

I’m starting to grok this. Now I need to know, what are the top five or ten “best

practices” of writing Scala code?

Truthfully, I fell fast in love with everything about Scala except for one thing: the col‐

lections library seemed large and intimidating. I really enjoyed using Scala so I kept

using the language, but whenever I needed a collection, I used a trusty old Java collection.

Then one day I got up the courage to dive into the collections library. I thought I’d hate

it, but after struggling with it for a while, I suddenly “got” it. The light bulb went on over

my head, and I suddenly understood not only the collections, but several other concepts

I had been struggling with as well. I realized the collections library writers aren’t crazy;

they’re brilliant.

Preface | xv

Once I understood the collections library, I quit writing so many for loops, and started

using collection methods like filter, foreach, and map. They made coding easier, and

made my code more concise. These days I can’t imagine a better way to write code like

this:

// filter the items in a list

scala> val nums = List(1,2,3,4,5).filter(_ < 4)

nums: List[Int] = List(1, 2, 3)

The _ wildcard character is discussed in several recipes, but as you can infer from that

example, it’s a placeholder for each element in the collection. The filter method loops

through each element in the list, calling your _ < 4 function on each iteration. That

Scala one-liner is the equivalent of this Java code:

Integer[] intArray = {1,2,3,4,5};

List<Integer> nums = Arrays.asList(intArray);

List<Integer> filteredNums = new LinkedList<Integer>();

for (int n: nums) {

if (n < 4) filteredNums.add(n);

}

The next example takes this a step further. It filters the elements as in the previous

example, and then multiplies each element by the number 2 using the map method:

// filter the items, then double them

scala> val nums = List(1,2,3,4,5).filter(_ < 4).map(_ * 2)

nums: List[Int] = List(2, 4, 6)

If you think about how much code would be required to write this expression in another

language, I think you’ll agree that Scala is expressive.

(If you’re new to Scala, examples like this are broken down into smaller chunks in the

recipes.)

Audience

This book is intended for programmers who want to be able to quickly find solutions

to problems they’ll encounter when using Scala and its libraries and tools. I hope it will

also be a good tool for developers who want to learn Scala. I’m a big believer in “learning

by example,” and this book is chock full of examples.

I generally assume that you have some experience with another programming language

like C, C++, Java, Ruby, C#, PHP, Python, or similar. My own experience is with those

languages, so I’m sure my writing is influenced by that background.

Another way to describe the audience for this book involves looking at different levels

of software developers. In the article at scala-lang.org, Martin Odersky defines the fol‐

lowing levels of computer programmers:

xvi | Preface

• Level A1: Beginning application programmer

• Level A2: Intermediate application programmer

• Level A3: Expert application programmer

• Level L1: Junior library designer

•

Level L2: Senior library designer

•

Level L3: Expert library designer

This book is primarily aimed at the application developers in the A1, A2, A3, and L1

categories. While helping those developers is my primary goal, I hope that L2 and L3

developers can also benefit from the many examples in this book—especially if they

have no prior experience with functional programming, or they want to quickly get up

to speed with Scala and its tools and libraries.

Contents of This Book

The first three chapters in this book cover some of the nuts and bolts of the Scala lan‐

guage.

Chapter 1, Strings, provides recipes for working with strings. Scala gets its basic String

functionality from Java, but with the power of implicit conversions, Scala adds new

functionality to strings through classes like StringLike and StringOps, which let Scala

treat a String as a sequence of Char. The last recipe in the chapter shows how to add

your own behavior to a String (or any other class) by creating an implicit conversion.

Chapter 2, Numbers, provides recipes for working with Scala’s numeric types. There are

no ++ and −− operators for working with numbers, and this chapter explains why, and

demonstrates the other methods you can use. It also shows how to handle large numbers,

currency, and how to compare floating-point numbers.

Chapter 3, Control Structures, demonstrates Scala’s built-in control structures, starting

with if/then statements and for loops, and then provides solutions for working with

for/yield loops (for comprehensions) and for expressions with embedded if statements

(guards). Because match expressions are so important to Scala, several recipes show

how to use them to solve a variety of problems.

The next five chapters continue to cover the Scala syntax, with an emphasis on organ‐

izing your projects with classes, methods, objects, traits, and packaging. Recipes on

classes, methods, objects, and traits place an emphasis on object-oriented programming

techniques.

Chapter 4, Classes and Properties, provides examples related to Scala classes and fields.

Because Scala constructors are very different than Java constructors, several recipes

show the ins and outs of writing both primary and auxiliary constructors. The chapter

Preface | xvii

also shows how to override the accessor and mutator methods that Scala automatically

generates for your val and var variables. Several recipes show what case classes are and

how to use them, and how to write equals methods.

Chapter 5, Methods, shows how to define methods to accept parameters, return values,

use parameter names when calling methods, set default values for method parameters,

create varargs fields, and write methods to support a fluent style of programming.

Chapter 6, Objects, covers “all things object.” Like Java, Scala uses the word object to

refer to an instance of a class, but Scala also has an object keyword. This chapter covers

topics like class casting, how to launch an application with an object, how to create the

equivalent of Java’s static members, and how to write a class with a companion object

so you can create new instances of a class without using the new keyword.

Chapter 7, Packaging and Imports, provides examples of Scala’s package and import

statements, which provide more capabilities than the same Java keywords. This includes

how to use the curly brace style for packaging, how to hide and rename members when

you import them, and more.

Chapter 8, Traits, provides examples of the Scala trait. It begins by showing how to use

a trait like a Java interface, and then gets into more advanced topics, such as how to use

traits as “mixins,” and limit which members a trait can be mixed into using a variety of

methods.

Although much of the book demonstrates functional programming (FP) techniques,

Chapter 9, Functional Programming, combines many FP recipes into one location. Sol‐

utions show how to define anonymous functions (function literals) and use them in a

variety of situations. Recipes demonstrate how to define a method that accepts a func‐

tion argument, how to return a function from a function, and how to use closures and

partially applied functions.

The Scala collections library is rich and deep, so Chapter 10, Collections, and Chapter 11,

List, Array, Map, Set (and More), provide more than 100 pages of collection-related

solutions.

Recipes in Chapter 10, Collections, help you choose collection classes for specific needs,

and then help you choose and use methods within a collection to solve specific problems,

such as transforming one collection into a new collection, filtering a collection, and

creating subgroups of a collection. More than 60 pages of recipes demonstrate solutions

for writing for loops, for/yield expressions, using methods like filter, foreach,

groupBy, map, and many more.

Chapter 11, List, Array, Map, Set (and More), continues where Chapter 10, Collections,

leaves off, providing solutions for those specific collection types, as well as recipes for

the Queue, Stack, and Range classes.

xviii | Preface

剩余721页未读，继续阅读

MANOLO

粉丝: 1
资源: 12

Scala编程实战指南

Scala Cookbook epub

ScalaCookbook.pdf 英文原版

Scala Cookbook 无水印pdf 0分

Scala编程实战：Scala Cookbook

Scala编程入门宝典：Scala Cookbook

Scala Cookbook 英文版增补精华

Scala Cookbook: 英文版JAVA函数式编程指南

2013年Alvin Alexander《Scala Cookbook》电子版详解

2013年Alvin Alexander《Scala Cookbook》文字版详解

Scala Cookbook (2.10版) - Alvin Alexander的经典教程

最新资源