Scala - Hướng dẫn nhanh
Scala, viết tắt của Scalable Language, là một ngôn ngữ lập trình chức năng kết hợp. Nó được tạo ra bởi Martin Odersky. Scala tích hợp nhuần nhuyễn các tính năng của ngôn ngữ chức năng và hướng đối tượng. Scala được biên dịch để chạy trên Máy ảo Java. Nhiều công ty hiện tại, những người phụ thuộc vào Java cho các ứng dụng quan trọng của doanh nghiệp, đang chuyển sang Scala để tăng năng suất phát triển, khả năng mở rộng ứng dụng và độ tin cậy tổng thể.
Ở đây chúng tôi đã trình bày một vài điểm khiến Scala trở thành lựa chọn hàng đầu của các nhà phát triển ứng dụng.
Scala là hướng đối tượng
Scala là một ngôn ngữ hướng đối tượng thuần túy theo nghĩa mọi giá trị đều là một đối tượng. Các kiểu và hành vi của các đối tượng được mô tả bằng các lớp và đặc điểm sẽ được giải thích trong các chương tiếp theo.
Các lớp học được kéo dài bởi subclassing và một linh hoạt mixin-based composition cơ chế thay thế sạch cho đa kế thừa.
Scala là chức năng
Scala cũng là một ngôn ngữ hàm theo nghĩa là mọi hàm là một giá trị và mọi giá trị đều là một đối tượng nên cuối cùng mọi hàm đều là một đối tượng.
Scala cung cấp một cú pháp nhẹ để xác định anonymous functions, nó hỗ trợ higher-order functions, nó cho phép các chức năng nestedvà hỗ trợ currying. Các khái niệm này sẽ được giải thích trong các chương tiếp theo.
Scala được nhập tĩnh
Scala, không giống như một số ngôn ngữ được gõ tĩnh khác (C, Pascal, Rust, v.v.), không mong đợi bạn cung cấp thông tin kiểu thừa. Bạn không phải chỉ định một kiểu trong hầu hết các trường hợp và chắc chắn bạn không phải lặp lại nó.
Scala chạy trên JVM
Scala được biên dịch thành Mã Byte Java được thực thi bởi Máy ảo Java (JVM). Điều này có nghĩa là Scala và Java có một nền tảng thời gian chạy chung. Bạn có thể dễ dàng chuyển từ Java sang Scala.
Trình biên dịch Scala biên dịch mã Scala của bạn thành Mã Byte Java, sau đó có thể được thực thi bởi 'scala' chỉ huy. Các 'scalalệnh 'tương tự như lệnh java , trong đó nó thực thi mã Scala đã biên dịch của bạn.
Scala có thể thực thi mã Java
Scala cho phép bạn sử dụng tất cả các lớp của Java SDK và cả các lớp Java tùy chỉnh của riêng bạn hoặc các dự án mã nguồn mở Java yêu thích của bạn.
Scala có thể thực hiện xử lý Đồng thời & Đồng bộ hóa
Scala cho phép bạn thể hiện các mẫu lập trình chung một cách hiệu quả. Nó làm giảm số dòng và giúp người lập trình viết mã theo cách an toàn về kiểu chữ. Nó cho phép bạn viết mã theo cách bất biến, giúp dễ dàng áp dụng đồng thời và song song (Synchronize).
Scala vs Java
Scala có một tập hợp các tính năng hoàn toàn khác với Java. Một số trong số này là -
- Tất cả các loại đều là đối tượng
- Nhập suy luận
- Các hàm lồng nhau
- Chức năng là đối tượng
- Hỗ trợ ngôn ngữ cụ thể cho miền (DSL)
- Traits
- Closures
- Hỗ trợ đồng thời lấy cảm hứng từ Erlang
Khung web Scala
Scala đang được sử dụng ở mọi nơi và quan trọng là trong các ứng dụng web doanh nghiệp. Bạn có thể kiểm tra một số khung web Scala phổ biến nhất -
Khung nâng
Khung Play
Khuôn khổ Bowler
Scala có thể được cài đặt trên bất kỳ hệ thống Windows hoặc UNIX nào. Trước khi bắt đầu cài đặt Scala trên máy tính của mình, bạn phải cài đặt Java 1.8 trở lên trên máy tính của mình.
Làm theo các bước dưới đây để cài đặt Scala.
Bước 1: Xác minh cài đặt Java của bạn
Trước hết, bạn cần cài đặt Bộ phát triển phần mềm Java (SDK) trên hệ thống của mình. Để xác minh điều này, hãy thực hiện bất kỳ lệnh nào trong hai lệnh sau tùy thuộc vào nền tảng bạn đang làm việc.
Nếu cài đặt Java đã được thực hiện đúng cách, thì nó sẽ hiển thị phiên bản hiện tại và đặc điểm kỹ thuật của cài đặt Java của bạn. Đầu ra mẫu được đưa ra trong bảng sau.
Nền tảng | Chỉ huy | Đầu ra mẫu |
---|---|---|
các cửa sổ | Mở Command Console và nhập - \>java –version |
Phiên bản Java "1.8.0_31" Thời gian chạy Java (TM) SE Môi trường (bản dựng 1.8.0_31-b31) Máy chủ 64-bit Java Hotspot (TM) VM (bản dựng 25.31-b07, chế độ hỗn hợp) |
Linux | Mở Command terminal và nhập - $java –version |
Phiên bản Java "1.8.0_31" Mở Môi trường thời gian chạy JDK (rhel-2.8.10.4.el6_4-x86_64) Mở JDK 64-Bit Server VM (bản dựng 25.31-b07, chế độ hỗn hợp) |
Chúng tôi giả định rằng những người đọc hướng dẫn này đã cài đặt Java SDK phiên bản 1.8.0_31 trên hệ thống của họ.
Trong trường hợp bạn không có Java SDK, hãy tải xuống phiên bản hiện tại của nó từ http://www.oracle.com/technetwork/java/javase/downloads/index.html và cài đặt nó.
Bước 2: Đặt môi trường Java của bạn
Đặt biến môi trường JAVA_HOME trỏ đến vị trí thư mục cơ sở nơi Java được cài đặt trên máy của bạn. Ví dụ,
Sr.No | Nền tảng & Mô tả |
---|---|
1 | Windows Đặt JAVA_HOME thành C: \ ProgramFiles \ java \ jdk1.7.0_60 |
2 | Linux Xuất JAVA_HOME = / usr / local / java-current |
Nối đường dẫn đầy đủ của vị trí trình biên dịch Java vào Đường dẫn hệ thống.
Sr.No | Nền tảng & Mô tả |
---|---|
1 | Windows Nối chuỗi "C: \ Program Files \ Java \ jdk1.7.0_60 \ bin" vào cuối biến hệ thống PATH. |
2 | Linux Xuất PATH = $ PATH: $ JAVA_HOME / bin / |
Thực hiện lệnh java -version từ dấu nhắc lệnh như đã giải thích ở trên.
Bước 3: Cài đặt Scala
Bạn có thể tải xuống Scala từ http://www.scala-lang.org/downloads. Tại thời điểm viết hướng dẫn này, tôi đã tải xuống 'scala-2.11.5-installer.jar'. Đảm bảo bạn có đặc quyền quản trị viên để tiếp tục. Bây giờ, hãy thực hiện lệnh sau tại dấu nhắc lệnh:
Nền tảng | Lệnh & Đầu ra | Sự miêu tả |
---|---|---|
các cửa sổ | \> java –jar scala-2.11.5-installer.jar \> |
Lệnh này sẽ hiển thị một trình hướng dẫn cài đặt, hướng dẫn bạn cài đặt Scala trên máy windows của mình. Trong quá trình cài đặt, nó sẽ yêu cầu thỏa thuận cấp phép, chỉ cần chấp nhận nó và hơn nữa nó sẽ hỏi một đường dẫn nơi Scala sẽ được cài đặt. Tôi đã chọn đường dẫn cho trước mặc định “C: \ Program Files \ Scala”, bạn có thể chọn một đường dẫn phù hợp tùy theo sự thuận tiện của mình. |
Linux | Command - $ java –jar scala-2.9.0.1-installer.jar Output - Chào mừng bạn đến với cài đặt Scala 2.9.0.1! Trang chủ tại - http://Scala-lang.org/ nhấn 1 để tiếp tục, 2 để thoát, 3 để hiển thị lại 1 ... [Đang bắt đầu giải nén] [Gói xử lý: Cài đặt gói phần mềm (1/1)] [Đã giải nén xong] [Đã cài đặt xong bảng điều khiển] |
Trong quá trình cài đặt, nó sẽ yêu cầu thỏa thuận cấp phép, chấp nhận nó là loại 1 và nó sẽ hỏi một đường dẫn nơi Scala sẽ được cài đặt. Tôi đã nhập / usr / local / share, bạn có thể chọn một con đường phù hợp tùy theo sự thuận tiện của bạn. |
Cuối cùng, mở một dấu nhắc lệnh mới và nhập Scala -versionvà nhấn Enter. Bạn sẽ thấy những điều sau:
Nền tảng | Chỉ huy | Đầu ra |
---|---|---|
các cửa sổ | \> chuyển đổi tỉ lệ |
Phiên bản chạy mã Scala 2.11.5 - Bản quyền 2002-2013, LAMP / EPFL |
Linux | $ scala -version |
Phiên bản chạy mã Scala 2.9.0.1 - Bản quyền 2002-2013, LAMP / EPFL |
Nếu bạn hiểu rõ về Java thì bạn sẽ rất dễ dàng học Scala. Sự khác biệt lớn nhất về cú pháp giữa Scala và Java là dấu ';' ký tự cuối dòng là tùy chọn.
Khi chúng ta xem xét một chương trình Scala, nó có thể được định nghĩa là một tập hợp các đối tượng giao tiếp thông qua việc gọi các phương thức của nhau. Bây giờ chúng ta hãy xem xét ngắn gọn ý nghĩa của lớp, đối tượng, phương thức và biến cá thể.
Object- Đối tượng có trạng thái và hành vi. Một đối tượng là một thể hiện của một lớp. Ví dụ - Một con chó có các trạng thái - màu sắc, tên, giống cũng như các hành vi - vẫy tay, sủa và ăn.
Class - Một lớp có thể được định nghĩa như một khuôn mẫu / bản thiết kế mô tả các hành vi / trạng thái có liên quan đến lớp.
Methods- Một phương pháp về cơ bản là một hành vi. Một lớp có thể chứa nhiều phương thức. Nó nằm trong các phương thức nơi logic được viết, dữ liệu được thao tác và tất cả các hành động được thực thi.
Fields- Mỗi đối tượng có một tập hợp các biến thể hiện duy nhất của nó, được gọi là các trường. Trạng thái của một đối tượng được tạo bởi các giá trị được gán cho các trường này.
Closure - A closure là một hàm, có giá trị trả về phụ thuộc vào giá trị của một hoặc nhiều biến được khai báo bên ngoài hàm này.
Traits- Một đặc điểm đóng gói các định nghĩa phương thức và trường, sau đó có thể được sử dụng lại bằng cách trộn chúng vào các lớp. Các đặc điểm được sử dụng để xác định các loại đối tượng bằng cách chỉ định chữ ký của các phương thức được hỗ trợ.
Chương trình Scala đầu tiên
Chúng ta có thể thực thi chương trình Scala ở hai chế độ: một là interactive mode và cái khác là script mode.
Chế độ tương tác
Mở dấu nhắc lệnh và sử dụng lệnh sau để mở Scala.
\>scala
Nếu Scala được cài đặt trong hệ thống của bạn, kết quả sau sẽ được hiển thị:
Welcome to Scala version 2.9.0.1
Type in expressions to have them evaluated.
Type :help for more information.
Nhập văn bản sau vào bên phải lời nhắc Scala và nhấn phím Enter -
scala> println("Hello, Scala!");
Nó sẽ tạo ra kết quả sau:
Hello, Scala!
Chế độ tập lệnh
Sử dụng các hướng dẫn sau để viết một chương trình Scala ở chế độ tập lệnh. Mở notepad và thêm mã sau vào đó.
Thí dụ
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
*/
def main(args: Array[String]) {
println("Hello, world!") // prints Hello World
}
}
Lưu tệp dưới dạng - HelloWorld.scala.
Mở cửa sổ nhắc lệnh và chuyển đến thư mục lưu tệp chương trình. Các 'scalacLệnh 'được sử dụng để biên dịch chương trình Scala và nó sẽ tạo ra một vài tệp lớp trong thư mục hiện tại. Một trong số họ sẽ được gọi làHelloWorld.class. Đây là một mã bytecode sẽ chạy trên Máy ảo Java (JVM) bằng cách sử dụng 'scala' chỉ huy.
Sử dụng lệnh sau để biên dịch và thực thi chương trình Scala của bạn.
\> scalac HelloWorld.scala
\> scala HelloWorld
Đầu ra
Hello, World!
Cú pháp cơ bản
Sau đây là các cú pháp và quy ước mã hóa cơ bản trong lập trình Scala.
Case Sensitivity - Scala phân biệt chữ hoa chữ thường, có nghĩa là định danh Hello và hello sẽ có nghĩa khác trong Scala.
Class Names- Đối với tất cả các tên lớp, chữ cái đầu tiên phải là chữ hoa. Nếu một số từ được sử dụng để tạo thành tên của lớp, thì mỗi chữ cái đầu tiên của từ bên trong phải ở dạng Chữ hoa.
Example - lớp MyFirstScalaClass.
Method Names- Tất cả các tên phương thức phải bắt đầu bằng chữ thường. Nếu nhiều từ được sử dụng để tạo thành tên của phương thức, thì chữ cái đầu tiên của mỗi từ bên trong phải ở dạng Chữ hoa.
Example - def myMethodName ()
Program File Name- Tên tệp chương trình phải khớp chính xác với tên đối tượng. Khi lưu tệp, bạn nên lưu bằng tên đối tượng (Hãy nhớ Scala phân biệt chữ hoa chữ thường) và nối thêm '.scala'đến cuối tên. (Nếu tên tệp và tên đối tượng không khớp chương trình của bạn sẽ không biên dịch).
Example- Giả sử 'HelloWorld' là tên đối tượng. Sau đó, tệp sẽ được lưu dưới dạng 'HelloWorld.scala'.
def main(args: Array[String]) - Xử lý chương trình Scala bắt đầu từ phương thức main () là một phần bắt buộc của mọi Chương trình Scala.
Số nhận dạng Scala
Tất cả các thành phần Scala yêu cầu tên. Tên được sử dụng cho các đối tượng, lớp, biến và phương thức được gọi là định danh. Không thể sử dụng từ khóa làm số nhận dạng và số nhận dạng có phân biệt chữ hoa chữ thường. Scala hỗ trợ bốn loại định danh.
Định danh chữ và số
Định danh chữ và số bắt đầu bằng một chữ cái hoặc một dấu gạch dưới, có thể được theo sau bởi các chữ cái, chữ số hoặc dấu gạch dưới. Ký tự '$' là một từ khóa dành riêng trong Scala và không được sử dụng trong số nhận dạng.
Sau đây là legal alphanumeric identifiers -
age, salary, _value, __1_value
Sau đây là illegal identifiers -
$salary, 123abc, -salary
Số nhận dạng nhà điều hành
Định danh toán tử bao gồm một hoặc nhiều ký tự toán tử. Các ký tự toán tử là các ký tự ASCII có thể in được như +,:,?, ~ Hoặc #.
Sau đây là các số nhận dạng nhà điều hành hợp pháp -
+ ++ ::: <?> :>
Trình biên dịch Scala sẽ nội bộ mã định danh toán tử "mangle" để biến chúng thành mã định danh Java hợp pháp với các ký tự $ được nhúng. Ví dụ: số nhận dạng: -> sẽ được trình bày nội bộ là$colon$lớn hơn trừ $.
Số nhận dạng hỗn hợp
Mã định danh hỗn hợp bao gồm một mã định danh chữ và số, theo sau là dấu gạch dưới và một mã định danh toán tử.
Sau đây là các số nhận dạng hỗn hợp hợp pháp -
unary_+, myvar_=
Ở đây, unary_ + được sử dụng làm tên phương thức xác định toán tử một ngôi + và myvar_ = được sử dụng làm tên phương thức xác định toán tử gán (nạp chồng toán tử).
Số nhận dạng theo nghĩa đen
Định danh theo nghĩa đen là một chuỗi tùy ý được bao trong dấu tích phía sau (`... ').
Sau đây là các từ định danh hợp pháp theo nghĩa đen -
`x` `<clinit>` `yield`
Từ khóa Scala
Danh sách sau đây hiển thị các từ dành riêng trong Scala. Những từ dành riêng này không được dùng làm hằng số hoặc biến hoặc bất kỳ tên định danh nào khác.
trừu tượng | trường hợp | nắm lấy | lớp học |
phản đối | làm | khác | kéo dài |
sai | sau cùng | cuối cùng | cho |
forSome | nếu | ngầm hiểu | nhập khẩu |
lười biếng | trận đấu | Mới | Vô giá trị |
vật | ghi đè | gói hàng | riêng tư |
được bảo vệ | trở về | niêm phong | siêu |
điều này | phi | đặc điểm | Thử |
thật | kiểu | val | Var |
trong khi | với | năng suất | |
- | : | = | => |
<- | <: | <% | >: |
# | @ |
Nhận xét trong Scala
Scala hỗ trợ các chú thích một dòng và nhiều dòng rất giống với Java. Các nhận xét nhiều dòng có thể được lồng vào nhau, nhưng bắt buộc phải được lồng đúng cách. Tất cả các ký tự có sẵn bên trong bất kỳ bình luận nào đều bị trình biên dịch Scala bỏ qua.
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/
def main(args: Array[String]) {
// Prints Hello World
// This is also an example of single line comment.
println("Hello, world!")
}
}
Dòng trống và Khoảng trắng
Một dòng chỉ chứa khoảng trắng, có thể kèm theo chú thích, được gọi là dòng trống và Scala hoàn toàn bỏ qua nó. Các mã thông báo có thể được phân tách bằng ký tự khoảng trắng và / hoặc nhận xét.
Nhân vật dòng mới
Scala là một ngôn ngữ hướng dòng trong đó các câu lệnh có thể được kết thúc bằng dấu chấm phẩy (;) hoặc dòng mới. Dấu chấm phẩy ở cuối câu lệnh thường là tùy chọn. Bạn có thể nhập một nếu bạn muốn nhưng bạn không cần phải nhập nếu câu lệnh xuất hiện một mình trên một dòng. Mặt khác, cần có dấu chấm phẩy nếu bạn viết nhiều câu lệnh trên một dòng. Cú pháp dưới đây là cách sử dụng nhiều câu lệnh.
val s = "hello"; println(s)
Gói Scala
Một gói là một mô-đun mã được đặt tên. Ví dụ, gói tiện ích Lift là net.liftweb.util. Khai báo gói là dòng không phải chú thích đầu tiên trong tệp nguồn như sau:
package com.liftcode.stuff
Các gói Scala có thể được nhập để chúng có thể được tham chiếu trong phạm vi biên dịch hiện tại. Câu lệnh sau nhập nội dung của gói scala.xml:
import scala.xml._
Bạn có thể nhập một lớp và đối tượng, chẳng hạn như HashMap từ gói scala.collection.mutable -
import scala.collection.mutable.HashMap
Bạn có thể nhập nhiều hơn một lớp hoặc đối tượng từ một gói, ví dụ: TreeMap và TreeSet từ gói scala.collection.immutable -
import scala.collection.immutable.{TreeMap, TreeSet}
Áp dụng động
Một đặc điểm đánh dấu cho phép gọi động. Các trường hợp x của đặc điểm này cho phép gọi phương thức x.meth (args) cho tên phương thức tùy ý meth và đối số liệt kê args cũng như truy cập trường x.field cho trường tên trường tùy ý. Tính năng này được giới thiệu trong Scala-2.10.
Nếu một lệnh gọi không được hỗ trợ bởi x (tức là nếu kiểm tra kiểu không thành công), nó sẽ được viết lại theo các quy tắc sau:
foo.method("blah") ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2) ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field ~~> foo.selectDynamic("field")
foo.varia = 10 ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13 ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10) ~~> foo.applyDynamic("arr")(10)
Scala có tất cả các kiểu dữ liệu giống như Java, với cùng một vùng nhớ và độ chính xác. Sau đây là bảng cung cấp thông tin chi tiết về tất cả các kiểu dữ liệu có sẵn trong Scala:
Sr.No | Loại dữ liệu và mô tả |
---|---|
1 | Byte Giá trị có dấu 8 bit. Phạm vi từ -128 đến 127 |
2 | Short Giá trị có dấu 16 bit. Phạm vi -32768 đến 32767 |
3 | Int Giá trị có dấu 32 bit. Phạm vi -2147483648 đến 2147483647 |
4 | Long Giá trị có dấu 64 bit. -9223372036854775808 đến 9223372036854775807 |
5 | Float Phao chính xác đơn 32 bit IEEE 754 |
6 | Double Phao chính xác kép 64 bit IEEE 754 |
7 | Char Ký tự Unicode 16 bit không dấu. Phạm vi từ U + 0000 đến U + FFFF |
số 8 | String Một chuỗi ký tự |
9 | Boolean Nghĩa đen đúng hoặc nghĩa đen sai |
10 | Unit Tương ứng với không có giá trị |
11 | Null tham chiếu rỗng hoặc trống |
12 | Nothing Kiểu con của mọi kiểu khác; không bao gồm giá trị |
13 | Any Siêu kiểu của bất kỳ loại nào; bất kỳ đối tượng nào thuộc loại Bất kỳ |
14 | AnyRef Siêu kiểu của bất kỳ kiểu tham chiếu nào |
Tất cả các kiểu dữ liệu được liệt kê ở trên là các đối tượng. Không có các kiểu nguyên thủy như trong Java. Điều này có nghĩa là bạn có thể gọi các phương thức trên Int, Long, v.v.
Scala Basic Literals
Các quy tắc Scala sử dụng cho các chữ rất đơn giản và trực quan. Phần này giải thích tất cả các Scala Literals cơ bản.
Chữ tích phân
Các ký tự số nguyên thường có kiểu Int hoặc kiểu Long khi theo sau là hậu tố L hoặc l. Đây là một số ký tự số nguyên -
0
035
21
0xFFFFFFFF
0777L
Floating Point Literal
Các ký tự dấu chấm động thuộc loại Float khi theo sau là hậu tố loại dấu chấm động F hoặc f, và thuộc loại Double. Dưới đây là một số ký tự dấu phẩy động -
0.0
1e30f
3.14159f
1.0e100
.1
Boolean Literals
Các ký tự Boolean true và false là thành viên của kiểu Boolean.
Chữ viết biểu tượng
Ký hiệu chữ 'x là cách viết tắt của biểu thức scala.Symbol("x"). Ký hiệu là một lớp trường hợp, được định nghĩa như sau.
package scala
final case class Symbol private (name: String) {
override def toString: String = "'" + name
}
Ký tự chữ
Một chữ ký tự là một ký tự đơn lẻ được đặt trong dấu ngoặc kép. Ký tự là một ký tự Unicode có thể in được hoặc được mô tả bằng một chuỗi thoát. Đây là một số ký tự chữ -
'a'
'\u0041'
'\n'
'\t'
Chuỗi chữ
Một chuỗi ký tự là một chuỗi các ký tự trong dấu ngoặc kép. Các ký tự là ký tự Unicode có thể in được hoặc được mô tả bằng các chuỗi thoát. Đây là một số ký tự chuỗi -
"Hello,\nWorld!"
"This string contains a \" character."
Chuỗi nhiều dòng
Một chuỗi ký tự nhiều dòng là một chuỗi các ký tự được đặt trong dấu ngoặc kép "" "..." "". Chuỗi ký tự là tùy ý, ngoại trừ việc nó có thể chứa ba hoặc nhiều ký tự trích dẫn liên tiếp chỉ ở cuối.
Các ký tự không nhất thiết phải in được; dòng mới hoặc các ký tự điều khiển khác cũng được cho phép. Đây là một chuỗi nhiều dòng theo nghĩa đen -
"""the present string
spans three
lines."""
Giá trị rỗng
Giá trị null thuộc loại scala.Nullvà do đó tương thích với mọi loại tham chiếu. Nó biểu thị một giá trị tham chiếu đề cập đến một đối tượng "null" đặc biệt.
Trình tự thoát
Các chuỗi thoát sau được nhận dạng dưới dạng ký tự và chuỗi ký tự.
Trình tự thoát | Unicode | Sự miêu tả |
---|---|---|
\ b | \ u0008 | backspace BS |
\ t | \ u0009 | tab ngang HT |
\ n | \ u000c | formfeed FF |
\ f | \ u000c | formfeed FF |
\ r | \ u000d | dấu xuống dòng CR |
\ " | \ u0022 | dấu ngoặc kép " |
\ ' | \ u0027 | trích dẫn duy nhất. |
\\ | \ u005c | dấu gạch chéo ngược \ |
Một ký tự có Unicode trong khoảng từ 0 đến 255 cũng có thể được biểu thị bằng một lối thoát bát phân, tức là dấu gạch chéo ngược '\' theo sau bởi một chuỗi tối đa ba ký tự bát phân. Dưới đây là ví dụ để hiển thị một số ký tự thoát -
Thí dụ
object Test {
def main(args: Array[String]) {
println("Hello\tWorld\n\n" );
}
}
Khi đoạn mã trên được biên dịch và thực thi, nó tạo ra kết quả sau:
Đầu ra
Hello World
Các biến không là gì ngoài các vị trí bộ nhớ dành riêng để lưu trữ các giá trị. Điều này có nghĩa là khi bạn tạo một biến, bạn dự trữ một số không gian trong bộ nhớ.
Dựa trên kiểu dữ liệu của một biến, trình biên dịch phân bổ bộ nhớ và quyết định những gì có thể được lưu trữ trong bộ nhớ dành riêng. Do đó, bằng cách gán các kiểu dữ liệu khác nhau cho các biến, bạn có thể lưu trữ số nguyên, số thập phân hoặc ký tự trong các biến này.
Sự định nghĩa biến
Scala có một cú pháp khác để khai báo các biến. Chúng có thể được định nghĩa là giá trị, tức là hằng số hoặc một biến. Ở đây, myVar được khai báo bằng từ khóa var. Nó là một biến có thể thay đổi giá trị và nó được gọi làmutable variable. Sau đây là cú pháp để xác định một biến bằng cách sử dụngvar từ khóa -
Cú pháp
var myVar : String = "Foo"
Ở đây, myVal được khai báo bằng từ khóa val. Điều này có nghĩa là nó là một biến không thể thay đổi và nó được gọi làimmutable variable. Sau đây là cú pháp để xác định một biến bằng cách sử dụng từ khóa val:
Cú pháp
val myVal : String = "Foo"
Các kiểu dữ liệu biến đổi
Kiểu của một biến được chỉ định sau tên biến và trước dấu bằng. Bạn có thể xác định bất kỳ loại biến Scala nào bằng cách đề cập đến kiểu dữ liệu của nó như sau:
Cú pháp
val or val VariableName : DataType = [Initial Value]
Nếu bạn không gán bất kỳ giá trị ban đầu nào cho một biến, thì nó sẽ hợp lệ như sau:
Cú pháp
var myVar :Int;
val myVal :String;
Suy luận kiểu biến
Khi bạn gán một giá trị ban đầu cho một biến, trình biên dịch Scala có thể tìm ra kiểu của biến dựa trên giá trị được gán cho nó. Đây được gọi là suy luận kiểu biến. Do đó, bạn có thể viết các khai báo biến này như thế này:
Cú pháp
var myVar = 10;
val myVal = "Hello, Scala!";
Ở đây, theo mặc định, myVar sẽ là kiểu Int và myVal sẽ trở thành biến kiểu Chuỗi.
Nhiều bài tập
Scala hỗ trợ nhiều bài tập. Nếu một khối mã hoặc phương thức trả về một Tuple (Tuple- Lưu trữ bộ sưu tập các Đối tượng thuộc các loại khác nhau), Tuple có thể được gán cho một biến val. [Note - Chúng ta sẽ nghiên cứu Tuples trong các chương tiếp theo.]
Cú pháp
val (myVar1: Int, myVar2: String) = Pair(40, "Foo")
Và kiểu suy luận đúng -
Cú pháp
val (myVar1, myVar2) = Pair(40, "Foo")
Chương trình mẫu
Sau đây là một chương trình ví dụ giải thích quá trình khai báo biến trong Scala. Chương trình này khai báo bốn biến - hai biến được định nghĩa với khai báo kiểu và hai biến còn lại không có khai báo kiểu.
Thí dụ
object Demo {
def main(args: Array[String]) {
var myVar :Int = 10;
val myVal :String = "Hello Scala with datatype declaration.";
var myVar1 = 20;
val myVal1 = "Hello Scala new without datatype declaration.";
println(myVar); println(myVal); println(myVar1);
println(myVal1);
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
10
Hello Scala with datatype declaration.
20
Hello Scala without datatype declaration.
Phạm vi biến đổi
Các biến trong Scala có thể có ba phạm vi khác nhau tùy thuộc vào nơi chúng đang được sử dụng. Chúng có thể tồn tại dưới dạng trường, dưới dạng tham số phương thức và dưới dạng biến cục bộ. Dưới đây là thông tin chi tiết về từng loại phạm vi.
Lĩnh vực
Trường là các biến thuộc về một đối tượng. Các trường có thể truy cập từ bên trong mọi phương thức trong đối tượng. Các trường cũng có thể được truy cập bên ngoài đối tượng tùy thuộc vào trường được khai báo với các bổ trợ truy cập nào. Các trường đối tượng có thể là cả loại có thể thay đổi và bất biến và có thể được xác định bằng cách sử dụngvar hoặc là val.
Tham số phương pháp
Tham số phương thức là các biến, được sử dụng để truyền giá trị bên trong một phương thức, khi phương thức được gọi. Các tham số phương thức chỉ có thể truy cập được từ bên trong phương thức nhưng các đối tượng được truyền vào có thể được truy cập từ bên ngoài, nếu bạn có tham chiếu đến đối tượng từ bên ngoài phương thức. Các tham số phương thức luôn không thay đổi được xác định bởival từ khóa.
Biến cục bộ
Biến cục bộ là các biến được khai báo bên trong một phương thức. Các biến cục bộ chỉ có thể truy cập từ bên trong phương thức, nhưng các đối tượng bạn tạo có thể thoát khỏi phương thức nếu bạn trả về chúng từ phương thức. Các biến cục bộ có thể là cả loại có thể thay đổi và bất biến và có thể được xác định bằng cách sử dụngvar hoặc là val.
Chương này sẽ hướng dẫn bạn cách sử dụng các lớp và đối tượng trong lập trình Scala. Một lớp là một bản thiết kế cho các đối tượng. Khi bạn xác định một lớp, bạn có thể tạo các đối tượng từ bản thiết kế lớp bằng từ khóanew. Thông qua đối tượng, bạn có thể sử dụng tất cả các chức năng của lớp đã xác định.
Sơ đồ sau minh họa lớp và đối tượng bằng cách lấy một ví dụ về sinh viên lớp, trong đó có các biến thành viên (tên và số cuộn) và các phương thức thành viên (setName () và setRollNo ()). Cuối cùng tất cả đều là thành viên của lớp. Lớp là một bản in màu xanh lam và các đối tượng là thực ở đây. Trong sơ đồ sau, Sinh viên là một lớp và Harini, John và Maria là các đối tượng của lớp Sinh viên, những đối tượng này có tên và số cuộn.
Lớp cơ bản
Sau đây là một cú pháp đơn giản để xác định một lớp cơ bản trong Scala. Lớp này định nghĩa hai biếnx và y và một phương pháp: move, không trả về giá trị. Các biến lớp được gọi, các trường của lớp và các phương thức được gọi là phương thức lớp.
Tên lớp hoạt động như một hàm tạo lớp có thể nhận một số tham số. Đoạn mã trên xác định hai đối số hàm tạo,xc và yc; cả hai đều có thể nhìn thấy trong toàn bộ cơ thể của lớp.
Cú pháp
class Point(xc: Int, yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
Như đã đề cập trước đó trong chương này, bạn có thể tạo các đối tượng bằng cách sử dụng từ khóa new và sau đó bạn có thể truy cập các trường và phương thức của lớp như được hiển thị bên dưới trong ví dụ:
Thí dụ
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
object Demo {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// Move to a new location
pt.move(10, 10);
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Point x location : 20
Point y location : 30
Mở rộng một lớp học
Bạn có thể mở rộng một lớp Scala cơ sở và bạn có thể thiết kế một lớp kế thừa theo cách giống như cách bạn làm trong Java (sử dụng extends từ khóa), nhưng có hai hạn chế: ghi đè phương thức yêu cầu override từ khóa và chỉ primaryhàm tạo có thể truyền các tham số cho hàm tạo cơ sở. Hãy để chúng tôi mở rộng lớp trên và thêm một phương thức lớp nữa.
Thí dụ
Chúng ta hãy lấy một ví dụ về hai lớp Lớp điểm (giống như ví dụ trên) và lớp Vị trí là lớp kế thừa bằng cách sử dụng từ khóa expand. Như một 'extendsMệnh đề 'có hai tác dụng: nó làm cho lớp Location kế thừa tất cả các thành viên không phải private từ lớp Point và nó làm cho kiểu Location trở thành một kiểu con của kiểu lớp Point . Vì vậy, ở đây lớp Point được gọi làsuperclassvà Vị trí của lớp được gọi làsubclass. Mở rộng một lớp và kế thừa tất cả các tính năng của một lớp cha được gọi làinheritance nhưng Scala chỉ cho phép thừa kế từ một lớp.
Note - Phương thức move () trong lớp Point và move() method in Location class không ghi đè các định nghĩa di chuyển tương ứng vì chúng là các định nghĩa khác nhau (ví dụ: định nghĩa trước có hai đối số trong khi định nghĩa sau có ba đối số).
Hãy thử chương trình ví dụ sau để thực hiện kế thừa.
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
class Location(override val xc: Int, override val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("Point x location : " + x);
println ("Point y location : " + y);
println ("Point z location : " + z);
}
}
object Demo {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// Move to a new location
loc.move(10, 10, 5);
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Point x location : 20
Point y location : 30
Point z location : 20
Các lớp ngầm định
Các lớp ngầm định cho phép các cuộc hội thoại ngầm với phương thức khởi tạo chính của lớp khi lớp nằm trong phạm vi. Lớp ngầm định là lớp được đánh dấu bằng từ khóa 'ẩn'. Tính năng này được giới thiệu trong Scala 2.10.
Syntax- Sau đây là cú pháp cho các lớp ngầm định. Ở đây lớp ngầm định luôn nằm trong phạm vi đối tượng nơi cho phép tất cả các định nghĩa phương thức vì lớp ngầm định không thể là lớp cấp cao nhất.
Cú pháp
object <object name> {
implicit class <class name>(<Variable>: Data type) {
def <method>(): Unit =
}
}
Thí dụ
Hãy để chúng tôi lấy một ví dụ về một lớp ngầm định có tên IntTimesvới phương thức times (). Nó có nghĩa là times () chứa một giao dịch lặp sẽ thực hiện câu lệnh đã cho với số lần mà chúng tôi đưa ra. Giả sử câu lệnh đã cho là “4 lần println (“ Xin chào ”)” có nghĩa là câu lệnh println (““ Xin chào ”) sẽ thực thi 4 lần.
Sau đây là chương trình cho ví dụ đã cho. Trong ví dụ này, hai lớp đối tượng được sử dụng (Run và Demo) để chúng ta phải lưu hai lớp đó trong các tệp khác nhau với tên tương ứng của chúng như sau.
Run.scala - Lưu chương trình sau trong Run.scala.
object Run {
implicit class IntTimes(x: Int) {
def times [A](f: =>A): Unit = {
def loop(current: Int): Unit =
if(current > 0){
f
loop(current - 1)
}
loop(x)
}
}
}
Demo.scala - Lưu chương trình sau trong Demo.scala.
import Run._
object Demo {
def main(args: Array[String]) {
4 times println("hello")
}
}
Các lệnh sau được sử dụng để biên dịch và thực thi hai chương trình này.
Chỉ huy
\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo
Đầu ra
Hello
Hello
Hello
Hello
Note -
Các lớp ngầm định phải được định nghĩa bên trong một lớp / đối tượng / đặc điểm khác (không phải ở cấp cao nhất).
Các lớp ngầm định chỉ có thể nhận một đối số không rõ ràng trong hàm tạo của chúng.
Các lớp ngầm định không được là bất kỳ phương thức, thành viên hoặc đối tượng nào trong phạm vi có cùng tên với lớp ngầm định.
Đối tượng Singleton
Scala hướng đối tượng hơn Java vì trong Scala, chúng ta không thể có các thành viên tĩnh. Thay vào đó, Scala cósingleton objects. Singleton là một lớp chỉ có thể có một thể hiện, tức là Object. Bạn tạo singleton bằng từ khóaobjectthay vì từ khóa lớp. Vì bạn không thể khởi tạo một đối tượng singleton, nên bạn không thể truyền các tham số cho hàm tạo chính. Bạn đã thấy tất cả các ví dụ sử dụng các đối tượng singleton mà bạn đã gọi phương thức chính của Scala.
Sau đây là chương trình ví dụ tương tự để triển khai singleton.
Thí dụ
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
}
}
object Demo {
def main(args: Array[String]) {
val point = new Point(10, 20)
printPoint
def printPoint{
println ("Point x location : " + point.x);
println ("Point y location : " + point.y);
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Point x location : 10
Point y location : 20
Chương này sẽ đưa bạn qua các công cụ sửa đổi quyền truy cập Scala. Các thành viên của gói, lớp hoặc đối tượng có thể được gắn nhãn với các công cụ sửa đổi truy cập là riêng tư và được bảo vệ, và nếu chúng ta không sử dụng một trong hai từ khóa này, thì quyền truy cập sẽ được coi là công khai. Các sửa đổi này hạn chế quyền truy cập của các thành viên vào một số vùng mã nhất định. Để sử dụng công cụ sửa đổi quyền truy cập, bạn đưa từ khóa của nó vào định nghĩa về các thành viên của gói, lớp hoặc đối tượng như chúng ta sẽ thấy trong phần sau.
Thành viên riêng
Thành viên riêng chỉ hiển thị bên trong lớp hoặc đối tượng có chứa định nghĩa thành viên.
Sau đây là đoạn mã ví dụ để giải thích thành viên Riêng tư -
Thí dụ
class Outer {
class Inner {
private def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // Error: f is not accessible
}
Trong Scala, quyền truy cập (Nội tại mới). f () là bất hợp pháp vì f được khai báo là private trong Inner và quyền truy cập không phải từ bên trong lớp Inner. Ngược lại, quyền truy cập đầu tiên đến f trong lớp Trong cùng là OK, vì quyền truy cập đó được chứa trong phần thân của lớp Bên trong. Java sẽ cho phép cả hai quyền truy cập vì nó cho phép một lớp bên ngoài truy cập các thành viên riêng của các lớp bên trong của nó.
Thành viên được bảo vệ
Thành viên được bảo vệ chỉ có thể truy cập được từ các lớp con của lớp mà thành viên đó được xác định.
Sau đây là đoạn mã ví dụ để giải thích thành viên được bảo vệ -
Thí dụ
package p {
class Super {
protected def f() { println("f") }
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() // Error: f is not accessible
}
}
Quyền truy cập vào f trong lớp Sub là OK vì f được khai báo là bảo vệ trong lớp 'Super' và lớp 'Sub' là một lớp con của Super. Ngược lại, quyền truy cập vào f trong lớp 'Khác' không được phép, vì lớp 'Khác' không kế thừa từ lớp 'Super'. Trong Java, quyền truy cập sau này vẫn được phép vì lớp 'Other' nằm trong cùng một gói với lớp 'Sub'.
Thành viên công khai
Không giống như các thành viên riêng tư và được bảo vệ, không bắt buộc phải chỉ định từ khóa Public cho các thành viên Public. Không có công cụ sửa đổi rõ ràng cho các thành viên công khai. Các thành viên như vậy có thể được truy cập từ mọi nơi.
Sau đây là đoạn mã ví dụ để giải thích về thành viên công khai -
Thí dụ
class Outer {
class Inner {
def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // OK because now f() is public
}
Phạm vi bảo vệ
Các bộ sửa đổi quyền truy cập trong Scala có thể được bổ sung bằng các bộ định tính. Công cụ sửa đổi của biểu mẫu private [X] hoặc protected [X] có nghĩa là quyền truy cập là riêng tư hoặc được bảo vệ "tối đa" X, trong đó X chỉ định một số gói, lớp hoặc đối tượng singleton bao quanh.
Hãy xem xét ví dụ sau:
Thí dụ
package society {
package professional {
class Executive {
private[professional] var workDetails = null
private[society] var friends = null
private[this] var secrets = null
def help(another : Executive) {
println(another.workDetails)
println(another.secrets) //ERROR
}
}
}
}
Note - những điểm sau từ ví dụ trên -
Biến workDetails sẽ có thể truy cập được đối với bất kỳ lớp nào trong gói chuyên nghiệp đi kèm.
Những người bạn khác nhau sẽ có thể truy cập vào bất kỳ tầng lớp nào trong xã hội gói bao quanh.
Các bí mật biến sẽ chỉ có thể truy cập được trên đối tượng ngầm bên trong các phương thức thể hiện (this).
Một toán tử là một ký hiệu yêu cầu trình biên dịch thực hiện các thao tác toán học hoặc logic cụ thể. Scala có nhiều toán tử tích hợp sẵn và cung cấp các loại toán tử sau:
- Toán tử số học
- Toán tử quan hệ
- Logical Operators
- Bitwise Operators
- Assignment Operators
This chapter will examine the arithmetic, relational, logical, bitwise, assignment and other operators one by one.
Arithmetic Operators
The following arithmetic operators are supported by Scala language. For example, let us assume variable A holds 10 and variable B holds 20, then −
Show Examples
Operator | Description | Example |
---|---|---|
+ | Adds two operands | A + B will give 30 |
- | Subtracts second operand from the first | A - B will give -10 |
* | Multiplies both operands | A * B will give 200 |
/ | Divides numerator by de-numerator | B / A will give 2 |
% | Modulus operator finds the remainder after division of one number by another | B % A will give 0 |
Relational Operators
The following relational operators are supported by Scala language. For example let us assume variable A holds 10 and variable B holds 20, then −
Show Examples
Operator | Description | Example |
---|---|---|
== | Checks if the values of two operands are equal or not, if yes then condition becomes true. | (A == B) is not true. |
!= | Checks if the values of two operands are equal or not, if values are not equal then condition becomes true. | (A != B) is true. |
> | Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. | (A > B) is not true. |
< | Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. | (A < B) is true. |
>= | Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. | (A >= B) is not true. |
<= | Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. | (A <= B) is true. |
Logical Operators
The following logical operators are supported by Scala language. For example, assume variable A holds 1 and variable B holds 0, then −
Show Examples
Operator | Description | Example |
---|---|---|
&& | It is called Logical AND operator. If both the operands are non zero then condition becomes true. | (A && B) is false. |
|| | It is called Logical OR Operator. If any of the two operands is non zero then condition becomes true. | (A || B) is true. |
! | It is called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. | !(A && B) is true. |
Bitwise Operators
Bitwise operator works on bits and perform bit by bit operation. The truth tables for &, |, and ^ are as follows −
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Assume if A = 60; and B = 13; now in binary format they will be as follows −
A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
The Bitwise operators supported by Scala language is listed in the following table. Assume variable A holds 60 and variable B holds 13, then −
Show Examples
Operator | Description | Example |
---|---|---|
& | Binary AND Operator copies a bit to the result if it exists in both operands. | (A & B) will give 12, which is 0000 1100 |
| | Binary OR Operator copies a bit if it exists in either operand. | (A | B) will give 61, which is 0011 1101 |
^ | Binary XOR Operator copies the bit if it is set in one operand but not both. | (A ^ B) will give 49, which is 0011 0001 |
~ | Binary Ones Complement Operator is unary and has the effect of 'flipping' bits. | (~A ) will give -61, which is 1100 0011 in 2's complement form due to a signed binary number. |
<< | Binary Left Shift Operator. The bit positions of the left operands value is moved left by the number of bits specified by the right operand. | A << 2 will give 240, which is 1111 0000 |
>> | Binary Right Shift Operator. The Bit positions of the left operand value is moved right by the number of bits specified by the right operand. | A >> 2 will give 15, which is 1111 |
>>> | Shift right zero fill operator. The left operands value is moved right by the number of bits specified by the right operand and shifted values are filled up with zeros. | A >>>2 will give 15 which is 0000 1111 |
Assignment Operators
There are following assignment operators supported by Scala language −
Show Examples
Operator | Description | Example |
---|---|---|
= | Simple assignment operator, Assigns values from right side operands to left side operand | C = A + B will assign value of A + B into C |
+= | Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand | C += A is equivalent to C = C + A |
-= | Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand | C -= A is equivalent to C = C - A |
*= | Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand | C *= A is equivalent to C = C * A |
/= | Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand | C /= A is equivalent to C = C / A |
%= | Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand | C %= A is equivalent to C = C % A |
<<= | Left shift AND assignment operator | C <<= 2 is same as C = C << 2 |
>>= | Right shift AND assignment operator | C >>= 2 is same as C = C >> 2 |
&= | Bitwise AND assignment operator | C &= 2 is same as C = C & 2 |
^= | bitwise exclusive OR and assignment operator | C ^= 2 is same as C = C ^ 2 |
|= | bitwise inclusive OR and assignment operator | C |= 2 is same as C = C | 2 |
Quyền ưu tiên của nhà khai thác trong Scala
Mức độ ưu tiên của toán tử xác định nhóm các từ trong một biểu thức. Điều này ảnh hưởng đến cách một biểu thức được đánh giá. Các toán tử nhất định có quyền ưu tiên cao hơn những toán tử khác; ví dụ, toán tử nhân có mức độ ưu tiên cao hơn toán tử cộng -
Ví dụ: x = 7 + 3 * 2; ở đây, x được gán 13, không phải 20 vì toán tử * có mức độ ưu tiên cao hơn +, vì vậy đầu tiên nó được nhân với 3 * 2 và sau đó cộng thành 7.
Hãy xem bảng sau. Các toán tử có mức độ ưu tiên cao nhất xuất hiện ở đầu bảng và các toán tử có mức độ ưu tiên thấp nhất xuất hiện ở cuối bảng. Trong một biểu thức, các toán tử có mức độ ưu tiên cao hơn sẽ được đánh giá đầu tiên.
thể loại | Nhà điều hành | Sự liên kết |
---|---|---|
Postfix | () [] | Trái sang phải |
Một ngôi | ! ~ | Phải sang trái |
Phép nhân | * /% | Trái sang phải |
Phụ gia | + - | Trái sang phải |
Shift | >> >>> << | Trái sang phải |
Quan hệ | >> = <<= | Trái sang phải |
Bình đẳng | ==! = | Trái sang phải |
Bitwise VÀ | & | Trái sang phải |
Bitwise XOR | ^ | Trái sang phải |
Bitwise HOẶC | | | Trái sang phải |
Logic AND | && | Trái sang phải |
Logic HOẶC | || | Trái sang phải |
Chuyển nhượng | = + = - = * = / =% = >> = << = & = ^ = | = | Phải sang trái |
Dấu phẩy | , | Trái sang phải |
Chương này sẽ đưa bạn qua các câu lệnh xây dựng có điều kiện trong lập trình Scala. Sau đây là dạng chung của cấu trúc IF ... ELSE ra quyết định điển hình được tìm thấy trong hầu hết các ngôn ngữ lập trình.
Sơ đồ
Sau đây là một sơ đồ lưu đồ cho câu lệnh điều kiện.
nếu Tuyên bố
Câu lệnh 'if' bao gồm một biểu thức Boolean theo sau là một hoặc nhiều câu lệnh.
Cú pháp
Cú pháp của câu lệnh 'if' như sau.
if(Boolean_expression) {
// Statements will execute if the Boolean expression is true
}
Nếu biểu thức Boolean đánh giá là true thì khối mã bên trong biểu thức 'if' sẽ được thực thi. Nếu không, bộ mã đầu tiên sau khi kết thúc biểu thức 'if' (sau dấu ngoặc nhọn đóng) sẽ được thực thi.
Hãy thử chương trình ví dụ sau để hiểu các biểu thức điều kiện (biểu thức if) trong Ngôn ngữ lập trình Scala.
Thí dụ
object Demo {
def main(args: Array[String]) {
var x = 10;
if( x < 20 ){
println("This is if statement");
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
This is if statement
Câu lệnh If-else
Câu lệnh 'if' có thể được theo sau bởi một câu lệnh else tùy chọn , thực thi khi biểu thức Boolean sai.
Cú pháp
Cú pháp của if ... else là -
if(Boolean_expression){
//Executes when the Boolean expression is true
} else{
//Executes when the Boolean expression is false
}
Hãy thử chương trình ví dụ sau để hiểu câu lệnh điều kiện (câu lệnh if- else) trong Ngôn ngữ lập trình Scala.
Thí dụ
object Demo {
def main(args: Array[String]) {
var x = 30;
if( x < 20 ){
println("This is if statement");
} else {
println("This is else statement");
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
This is else statement
Câu lệnh if-else-if-else
Câu lệnh 'if' có thể được theo sau bởi câu lệnh ' else if ... else ' tùy chọn , rất hữu ích để kiểm tra các điều kiện khác nhau bằng cách sử dụng câu lệnh if ... else if duy nhất.
Khi sử dụng các câu lệnh if, else if, else có một số điểm cần lưu ý.
Một 'if' có thể có số 0 hoặc số khác và nó phải đứng sau if khác.
Một 'if' có thể có 0 với nhiều if khác và chúng phải đứng trước if's khác.
Một khi người khác nếu thành công, không ai trong số anh ta còn lại nếu của hoặc của người khác sẽ được kiểm tra.
Cú pháp
Sau đây là cú pháp của 'if ... else if ... else' như sau:
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
} else if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
} else if(Boolean_expression 3){
//Executes when the Boolean expression 3 is true
} else {
//Executes when the none of the above condition is true.
}
Hãy thử chương trình ví dụ sau để hiểu các câu lệnh điều kiện (câu lệnh if- else- if- else) trong Ngôn ngữ lập trình Scala.
Thí dụ
object Demo {
def main(args: Array[String]) {
var x = 30;
if( x == 10 ){
println("Value of X is 10");
} else if( x == 20 ){
println("Value of X is 20");
} else if( x == 30 ){
println("Value of X is 30");
} else{
println("This is else statement");
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Value of X is 30
Câu lệnh if-else lồng nhau
Nó luôn luôn hợp pháp để làm tổ if-else câu lệnh, có nghĩa là bạn có thể sử dụng một if hoặc là else-if tuyên bố bên trong khác if hoặc là else-if tuyên bố.
Cú pháp
Cú pháp cho if-else lồng nhau như sau:
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
}
}
Hãy thử chương trình ví dụ sau để hiểu các câu lệnh điều kiện (câu lệnh if lồng nhau) trong Ngôn ngữ lập trình Scala.
Thí dụ
object Demo {
def main(args: Array[String]) {
var x = 30;
var y = 10;
if( x == 30 ){
if( y == 10 ){
println("X = 30 and Y = 10");
}
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
X = 30 and Y = 10
Chương này sẽ đưa bạn qua các cấu trúc điều khiển vòng lặp trong ngôn ngữ lập trình Scala.
Có thể có một tình huống, khi bạn cần thực thi một khối mã nhiều lần. Nói chung, các câu lệnh được thực hiện tuần tự: Câu lệnh đầu tiên trong một hàm được thực hiện đầu tiên, tiếp theo là câu lệnh thứ hai, v.v.
Các ngôn ngữ lập trình cung cấp các cấu trúc điều khiển khác nhau cho phép các đường dẫn thực thi phức tạp hơn.
Câu lệnh lặp cho phép chúng ta thực hiện một câu lệnh hoặc một nhóm câu lệnh nhiều lần và sau đây là dạng chung của câu lệnh lặp trong hầu hết các ngôn ngữ lập trình:
Sơ đồ
Ngôn ngữ lập trình Scala cung cấp các loại vòng lặp sau để xử lý các yêu cầu về vòng lặp. Nhấp vào các liên kết sau trong bảng để kiểm tra chi tiết của chúng.
Sr.No | Loại vòng lặp & Mô tả |
---|---|
1 | while loop Lặp lại một câu lệnh hoặc một nhóm câu lệnh trong khi một điều kiện đã cho là đúng. Nó kiểm tra điều kiện trước khi thực thi phần thân của vòng lặp. |
2 | do-while loop Giống như một câu lệnh while, ngoại trừ việc nó kiểm tra điều kiện ở cuối thân vòng lặp. |
3 | for loop Thực thi một chuỗi các câu lệnh nhiều lần và viết tắt mã quản lý biến vòng lặp. |
Tuyên bố kiểm soát vòng lặp
Các câu lệnh điều khiển vòng lặp thay đổi việc thực thi từ trình tự bình thường của nó. Khi việc thực thi rời khỏi một phạm vi, tất cả các đối tượng tự động được tạo trong phạm vi đó sẽ bị phá hủy. Như vậy Scala không hỗ trợbreak hoặc là continuecâu lệnh giống như Java nhưng bắt đầu từ Scala phiên bản 2.8, có một cách để phá vỡ các vòng lặp. Nhấp vào liên kết sau để kiểm tra chi tiết.
Sr.No | Tuyên bố & Mô tả Kiểm soát |
---|---|
1 | break statement Chấm dứt loop câu lệnh và chuyển việc thực thi câu lệnh ngay sau vòng lặp. |
Vòng lặp vô hạn
Một vòng lặp trở thành một vòng lặp vô hạn nếu một điều kiện không bao giờ trở thành sai. Nếu bạn đang sử dụng Scala,while vòng lặp là cách tốt nhất để thực hiện vòng lặp vô hạn.
Chương trình sau thực hiện vòng lặp vô hạn.
Thí dụ
object Demo {
def main(args: Array[String]) {
var a = 10;
// An infinite loop.
while( true ){
println( "Value of a: " + a );
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Nếu bạn thực thi mã trên, nó sẽ đi theo vòng lặp vô hạn mà bạn có thể kết thúc bằng cách nhấn các phím Ctrl + C.
Value of a: 10
Value of a: 10
Value of a: 10
Value of a: 10
…………….
Hàm là một nhóm các câu lệnh thực hiện một nhiệm vụ. Bạn có thể chia mã của mình thành các chức năng riêng biệt. Cách bạn phân chia mã của mình giữa các chức năng khác nhau là tùy thuộc vào bạn, nhưng về mặt logic, việc phân chia thường là để mỗi chức năng thực hiện một nhiệm vụ cụ thể.
Scala có cả chức năng và phương pháp và chúng tôi sử dụng phương pháp thuật ngữ và chức năng thay thế cho nhau với một sự khác biệt nhỏ. Phương thức Scala là một phần của lớp có tên, chữ ký, tùy chọn một số chú thích và một số mã bytecode trong đó như một hàm trong Scala là một đối tượng hoàn chỉnh có thể được gán cho một biến. Nói cách khác, một hàm, được định nghĩa như một thành viên của một số đối tượng, được gọi là một phương thức.
Định nghĩa hàm có thể xuất hiện ở bất kỳ đâu trong tệp nguồn và Scala cho phép các định nghĩa hàm lồng nhau, nghĩa là các định nghĩa hàm bên trong các định nghĩa hàm khác. Điểm quan trọng nhất cần lưu ý là tên của hàm Scala có thể có các ký tự như +, ++, ~, &, -, -, \, /,:, v.v.
Khai báo hàm
Khai báo hàm Scala có dạng sau:
def functionName ([list of parameters]) : [return type]
Các phương thức được khai báo ngầm định là trừu tượng nếu bạn không sử dụng dấu bằng và thân phương thức.
Định nghĩa hàm
Định nghĩa hàm Scala có dạng sau:
Cú pháp
def functionName ([list of parameters]) : [return type] = {
function body
return [expr]
}
Đây, return type có thể là bất kỳ kiểu dữ liệu Scala hợp lệ nào và list of parameterssẽ là danh sách các biến được phân tách bằng dấu phẩy và danh sách các tham số và kiểu trả về là tùy chọn. Rất giống với Java,returncâu lệnh có thể được sử dụng cùng với một biểu thức trong trường hợp hàm trả về một giá trị. Sau đây là hàm sẽ cộng hai số nguyên và trả về tổng của chúng:
Cú pháp
object add {
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
Một hàm không trả về bất kỳ thứ gì có thể trả về Unit điều đó tương đương với voidtrong Java và chỉ ra rằng hàm không trả về bất kỳ thứ gì. Các hàm không trả về bất kỳ thứ gì trong Scala, chúng được gọi là các thủ tục.
Cú pháp
Đây là cú pháp -
object Hello{
def printMe( ) : Unit = {
println("Hello, Scala!")
}
}
Chức năng gọi điện
Scala cung cấp một số biến thể cú pháp để gọi các phương thức. Sau đây là cách chuẩn để gọi một phương thức:
functionName( list of parameters )
Nếu một hàm đang được gọi bằng cách sử dụng một thể hiện của đối tượng, thì chúng ta sẽ sử dụng ký hiệu dấu chấm tương tự như Java như sau:
[instance.]functionName( list of parameters )
Hãy thử chương trình ví dụ sau để xác định và sau đó gọi hàm tương tự.
Thí dụ
object Demo {
def main(args: Array[String]) {
println( "Returned Value : " + addInt(5,7) );
}
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Returned Value : 12
Các hàm Scala là trung tâm của lập trình Scala và đó là lý do tại sao Scala được coi là một ngôn ngữ lập trình hàm. Sau đây là một số khái niệm quan trọng liên quan đến các hàm Scala mà một lập trình viên Scala nên hiểu.
Chức năng Gọi theo tên | Các hàm với các đối số được đặt tên |
Hàm với các đối số biến | Hàm đệ quy |
Giá trị tham số mặc định | Chức năng bậc cao hơn |
Các hàm lồng nhau | Chức năng ẩn danh |
Các chức năng được áp dụng một phần | Chức năng cà ri |
A closure là một hàm, có giá trị trả về phụ thuộc vào giá trị của một hoặc nhiều biến được khai báo bên ngoài hàm này.
Đoạn mã sau với chức năng ẩn danh.
val multiplier = (i:Int) => i * 10
Ở đây, biến duy nhất được sử dụng trong thân hàm, i * 10, là i, được định nghĩa như một tham số của hàm. Hãy thử đoạn mã sau -
val multiplier = (i:Int) => i * factor
Có hai biến tự do trong hệ số nhân: i và factor. Một trong số chúng, i, là một tham số chính thức của hàm. Do đó, nó bị ràng buộc với một giá trị mới mỗi khi số nhân được gọi. Tuy nhiên,factorkhông phải là một tham số chính thức, vậy đây là gì? Hãy để chúng tôi thêm một dòng mã nữa.
var factor = 3
val multiplier = (i:Int) => i * factor
Hiện nay factorcó một tham chiếu đến một biến bên ngoài hàm nhưng trong phạm vi bao quanh. Tham chiếu hàmfactorvà đọc giá trị hiện tại của nó mỗi lần. Nếu một hàm không có tham chiếu bên ngoài, thì nó sẽ bị đóng một cách đáng kể so với chính nó. Không cần bối cảnh bên ngoài.
Hãy thử chương trình ví dụ sau.
Thí dụ
object Demo {
def main(args: Array[String]) {
println( "multiplier(1) value = " + multiplier(1) )
println( "multiplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
multiplier(1) value = 3
multiplier(2) value = 6
Chương này sẽ đưa bạn qua các Chuỗi Scala. Trong Scala, cũng như trong Java, một chuỗi là một đối tượng bất biến, tức là một đối tượng không thể sửa đổi. Mặt khác, các đối tượng có thể được sửa đổi, như mảng, được gọi là các đối tượng có thể thay đổi. Chuỗi là các đối tượng rất hữu ích, trong phần còn lại của phần này, chúng tôi trình bày các phương thức quan trọng củajava.lang.String lớp học.
Tạo một chuỗi
Đoạn mã sau có thể được sử dụng để tạo một Chuỗi:
var greeting = "Hello world!";
or
var greeting:String = "Hello world!";
Bất cứ khi nào trình biên dịch gặp một chuỗi ký tự trong mã, nó sẽ tạo một đối tượng Chuỗi với giá trị của nó, trong trường hợp này là “Hello world!”. Từ khóa chuỗi cũng có thể được đưa ra trong khai báo thay thế như hình trên.
Hãy thử chương trình ví dụ sau.
Thí dụ
object Demo {
val greeting: String = "Hello, world!"
def main(args: Array[String]) {
println( greeting )
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Hello, world!
Như đã đề cập trước đó, lớp String là bất biến. Đối tượng chuỗi sau khi được tạo không thể thay đổi. Nếu cần thiết phải thực hiện nhiều sửa đổi đối với Chuỗi ký tự, hãy sử dụng Lớp trình tạo chuỗi có sẵn trong Scala !.
Chiều dài chuỗi
Các phương thức được sử dụng để lấy thông tin về một đối tượng được gọi là các phương thức truy cập. Một phương thức truy cập có thể được sử dụng với chuỗi là phương thức length (), trả về số ký tự có trong đối tượng chuỗi.
Sử dụng đoạn mã sau để tìm độ dài của một chuỗi:
Thí dụ
object Demo {
def main(args: Array[String]) {
var palindrome = "Dot saw I was Tod";
var len = palindrome.length();
println( "String Length is : " + len );
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
String Length is : 17
Nối các chuỗi
Lớp String bao gồm một phương thức để nối hai chuỗi:
string1.concat(string2);
Điều này trả về một chuỗi mới là string1 với string2 được thêm vào ở cuối. Bạn cũng có thể sử dụng phương thức concat () với chuỗi ký tự, như trong -
"My name is ".concat("Zara");
Các chuỗi thường được nối với toán tử +, như trong -
"Hello," + " world" + "!"
Kết quả là -
"Hello, world!"
Các dòng mã sau để tìm độ dài chuỗi.
Thí dụ
object Demo {
def main(args: Array[String]) {
var str1 = "Dot saw I was ";
var str2 = "Tod";
println("Dot " + str1 + str2);
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Dot Dot saw I was Tod
Tạo chuỗi định dạng
Bạn có phương thức printf () và format () để in đầu ra với các số được định dạng. Lớp String có một phương thức lớp tương đương, format (), trả về một đối tượng String chứ không phải là một đối tượng PrintStream.
Hãy thử chương trình ví dụ sau, sử dụng phương thức printf () -
Thí dụ
object Demo {
def main(args: Array[String]) {
var floatVar = 12.456
var intVar = 2000
var stringVar = "Hello, Scala!"
var fs = printf("The value of the float variable is " + "%f, while the value of the integer " + "variable is %d, and the string" + "is %s", floatVar, intVar, stringVar);
println(fs)
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
The value of the float variable is 12.456000,
while the value of the integer variable is 2000,
and the string is Hello, Scala!()
Nội suy chuỗi
Nội suy chuỗi là cách mới để tạo chuỗi trong ngôn ngữ lập trình Scala. Tính năng này hỗ trợ các phiên bản Scala-2.10 trở lên. Nội suy chuỗi: Cơ chế nhúng các tham chiếu biến trực tiếp vào chuỗi quy trình.
Có ba loại (bộ nội suy) triển khai trong Nội suy chuỗi.
Bộ nội suy chuỗi của 's'
Chữ 's' cho phép sử dụng trực tiếp biến trong quá trình xử lý một chuỗi, khi bạn thêm 's' vào nó. Bất kỳ biến Chuỗi nào với trong một phạm vi có thể được sử dụng với trong Chuỗi. Sau đây là các cách sử dụng khác nhau của bộ nội suy chuỗi 's'.
Đoạn mã ví dụ sau để triển khai bộ nội suy 's' trong việc nối biến Chuỗi ($ name) vào một Chuỗi bình thường (Hello) trong câu lệnh println.
val name = “James”
println(s “Hello, $name”) //output: Hello, James
Bộ nội suy chuỗi cũng có thể xử lý các biểu thức tùy ý. Đoạn mã sau để Xử lý một chuỗi (1 + 1) với biểu thức tùy ý ($ {1 + 1}) bằng cách sử dụng bộ nội suy Chuỗi của 's'. Bất kỳ biểu thức tùy ý nào cũng có thể được nhúng vào '$ {}'.
println(s “1 + 1 = ${1 + 1}”) //output: 1 + 1 = 2
Hãy thử chương trình ví dụ sau về triển khai bộ nội suy 's'.
Thí dụ
object Demo {
def main(args: Array[String]) {
val name = "James"
println(s"Hello, $name") println(s"1 + 1 = ${1 + 1}")
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Hello, James
1 + 1 = 2
Bộ nội suy 'f'
Bộ nội suy 'f' theo nghĩa đen cho phép tạo một Chuỗi được định dạng, tương tự như printf trong ngôn ngữ C. Trong khi sử dụng bộ nội suy 'f', tất cả các tham chiếu biến phải được theo sau bởiprintf các chỉ định định dạng kiểu như% d,% i,% f, v.v.
Chúng ta hãy lấy một ví dụ về nối giá trị dấu phẩy động (chiều cao = 1,9d) và biến chuỗi (tên = “James”) với chuỗi bình thường. Đoạn mã sau về việc triển khai Bộ nội suy 'f'. Đây$name%s to print (String variable) James and $height% 2.2f để in (giá trị dấu phẩy động) 1.90.
val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall
Nó là kiểu an toàn (tức là) tham chiếu biến và mã định dạng sau phải khớp nếu không nó đang hiển thị lỗi. Bộ nội suy 'f' sử dụng các tiện ích định dạng chuỗi (mã định dạng) có sẵn trong Java. Theo mặc định, không có ký tự% sau tham chiếu biến. Nó sẽ giả sử là% s (Chuỗi).
Bộ nội suy 'thô'
Bộ nội suy 'thô' tương tự như bộ nội suy 's' ngoại trừ nó không thực hiện thoát các ký tự trong một chuỗi. Các đoạn mã sau trong bảng sẽ khác nhau về cách sử dụng bộ nội suy 's' và 'thô'. Trong đầu ra của hiệu ứng 's' sử dụng '\ n' là dòng mới và ở đầu ra của sử dụng 'thô', '\ n' sẽ không có hiệu lực. Nó sẽ in chuỗi hoàn chỉnh với các chữ cái thoát.
sử dụng bộ nội suy của | sử dụng bộ nội suy 'thô' |
---|---|
Program - |
Program - |
Output - |
Output - |
Phương thức chuỗi
Sau đây là danh sách các phương thức được xác định bởi java.lang.String và có thể được sử dụng trực tiếp trong các chương trình Scala của bạn -
Sr.No | Phương pháp với Mô tả |
---|---|
1 | char charAt(int index) Trả về ký tự tại chỉ mục được chỉ định. |
2 | int compareTo(Object o) So sánh chuỗi này với một đối tượng khác. |
3 | int compareTo(String anotherString) So sánh hai chuỗi về mặt từ vựng. |
4 | int compareToIgnoreCase(String str) So sánh hai chuỗi về mặt từ vựng, bỏ qua sự khác biệt về chữ hoa và chữ thường. |
5 | String concat(String str) Nối chuỗi được chỉ định với phần cuối của chuỗi này. |
6 | boolean contentEquals(StringBuffer sb) Trả về true nếu và chỉ khi Chuỗi này đại diện cho cùng một chuỗi ký tự như StringBuffer được chỉ định. |
7 | static String copyValueOf(char[] data) Trả về một Chuỗi đại diện cho chuỗi ký tự trong mảng được chỉ định. |
số 8 | static String copyValueOf(char[] data, int offset, int count) Trả về một Chuỗi đại diện cho chuỗi ký tự trong mảng được chỉ định. |
9 | boolean endsWith(String suffix) Kiểm tra xem chuỗi này có kết thúc bằng hậu tố được chỉ định hay không. |
10 | boolean equals(Object anObject) So sánh chuỗi này với đối tượng được chỉ định. |
11 | boolean equalsIgnoreCase(String anotherString) So sánh Chuỗi này với Chuỗi khác, bỏ qua các cân nhắc về chữ hoa và chữ thường. |
12 | byte getBytes() Mã hóa Chuỗi này thành một chuỗi byte bằng cách sử dụng bộ ký tự mặc định của nền tảng, lưu trữ kết quả vào một mảng byte mới. |
13 | byte[] getBytes(String charsetName) Mã hóa Chuỗi này thành một chuỗi byte bằng cách sử dụng bộ ký tự đã đặt tên, lưu trữ kết quả vào một mảng byte mới. |
14 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) Sao chép các ký tự từ chuỗi này vào mảng ký tự đích. |
15 | int hashCode() Trả về mã băm cho chuỗi này. |
16 | int indexOf(int ch) Trả về chỉ mục trong chuỗi này của lần xuất hiện đầu tiên của ký tự được chỉ định. |
17 | int indexOf(int ch, int fromIndex) Trả về chỉ mục trong chuỗi này của lần xuất hiện đầu tiên của ký tự được chỉ định, bắt đầu tìm kiếm tại chỉ mục được chỉ định. |
18 | int indexOf(String str) Trả về chỉ mục trong chuỗi này của lần xuất hiện đầu tiên của chuỗi con được chỉ định. |
19 | int indexOf(String str, int fromIndex) Trả về chỉ mục trong chuỗi này của lần xuất hiện đầu tiên của chuỗi con được chỉ định, bắt đầu từ chỉ mục được chỉ định. |
20 | String intern() Trả về một biểu diễn chính tắc cho đối tượng chuỗi. |
21 | int lastIndexOf(int ch) Trả về chỉ mục trong chuỗi này về lần xuất hiện cuối cùng của ký tự được chỉ định. |
22 | int lastIndexOf(int ch, int fromIndex) Trả về chỉ mục trong chuỗi này về lần xuất hiện cuối cùng của ký tự được chỉ định, tìm kiếm ngược lại bắt đầu từ chỉ mục đã chỉ định. |
23 | int lastIndexOf(String str) Trả về chỉ mục trong chuỗi này về lần xuất hiện ngoài cùng bên phải của chuỗi con được chỉ định. |
24 | int lastIndexOf(String str, int fromIndex) Trả về chỉ mục trong chuỗi này của lần xuất hiện cuối cùng của chuỗi con được chỉ định, tìm kiếm ngược lại bắt đầu từ chỉ mục đã chỉ định. |
25 | int length() Trả về độ dài của chuỗi này. |
26 | boolean matches(String regex) Cho biết chuỗi này có khớp với biểu thức chính quy đã cho hay không. |
27 | boolean regionMatches(boolean ignoreCase, int toffset, String other, int offset, int len) Kiểm tra xem hai vùng chuỗi có bằng nhau không. |
28 | boolean regionMatches(int toffset, String other, int offset, int len) Kiểm tra xem hai vùng chuỗi có bằng nhau không. |
29 | String replace(char oldChar, char newChar) Trả về một chuỗi mới do thay thế tất cả các lần xuất hiện của oldChar trong chuỗi này bằng newChar. |
30 | String replaceAll(String regex, String replacement Thay thế từng chuỗi con của chuỗi này phù hợp với biểu thức chính quy đã cho bằng thay thế đã cho. |
31 | String replaceFirst(String regex, String replacement) Thay thế chuỗi con đầu tiên của chuỗi này khớp với biểu thức chính quy đã cho bằng chuỗi thay thế đã cho. |
32 | String[] split(String regex) Tách chuỗi này xung quanh các kết quả phù hợp của biểu thức chính quy đã cho. |
33 | String[] split(String regex, int limit) Tách chuỗi này xung quanh các kết quả phù hợp của biểu thức chính quy đã cho. |
34 | boolean startsWith(String prefix) Kiểm tra xem chuỗi này có bắt đầu bằng tiền tố được chỉ định hay không. |
35 | boolean startsWith(String prefix, int toffset) Kiểm tra xem chuỗi này có bắt đầu bằng tiền tố được chỉ định bắt đầu một chỉ mục được chỉ định không. |
36 | CharSequence subSequence(int beginIndex, int endIndex) Trả về một chuỗi ký tự mới là chuỗi con của chuỗi này. |
37 | String substring(int beginIndex) Trả về một chuỗi mới là chuỗi con của chuỗi này. |
38 | String substring(int beginIndex, int endIndex) Trả về một chuỗi mới là chuỗi con của chuỗi này. |
39 | char[] toCharArray() Chuyển đổi chuỗi này thành một mảng ký tự mới. |
40 | String toLowerCase() Chuyển đổi tất cả các ký tự trong Chuỗi này thành chữ thường bằng cách sử dụng các quy tắc của ngôn ngữ mặc định. |
41 | String toLowerCase(Locale locale) Chuyển đổi tất cả các ký tự trong Chuỗi này thành chữ thường bằng cách sử dụng các quy tắc của Ngôn ngữ đã cho. |
42 | String toString() Đối tượng này (đã là một chuỗi!) Được trả về chính nó. |
43 | String toUpperCase() Chuyển đổi tất cả các ký tự trong Chuỗi này thành chữ hoa bằng cách sử dụng các quy tắc của ngôn ngữ mặc định. |
44 | String toUpperCase(Locale locale) Chuyển đổi tất cả các ký tự trong Chuỗi này thành chữ hoa bằng cách sử dụng các quy tắc của Ngôn ngữ đã cho. |
45 | String trim() Trả về bản sao của chuỗi, với khoảng trắng đầu và cuối bị bỏ qua. |
46 | static String valueOf(primitive data type x) Trả về biểu diễn chuỗi của đối số kiểu dữ liệu đã truyền. |
Scala cung cấp một cấu trúc dữ liệu, array, nơi lưu trữ một tập hợp tuần tự có kích thước cố định của các phần tử cùng loại. Mảng được sử dụng để lưu trữ một tập hợp dữ liệu, nhưng thường hữu ích hơn nếu coi một mảng là một tập hợp các biến cùng kiểu.
Thay vì khai báo các biến riêng lẻ, chẳng hạn như number0, number1, ... và number99, bạn khai báo một biến mảng chẳng hạn như số và sử dụng số [0], số [1] và ..., số [99] để biểu diễn các biến riêng lẻ. Hướng dẫn này giới thiệu cách khai báo biến mảng, tạo mảng và xử lý mảng bằng cách sử dụng các biến được lập chỉ mục. Chỉ số của phần tử đầu tiên của mảng là số 0 và chỉ số của phần tử cuối cùng là tổng số phần tử trừ đi một.
Khai báo biến mảng
Để sử dụng mảng trong chương trình, bạn phải khai báo một biến để tham chiếu đến mảng và bạn phải chỉ định kiểu mảng mà biến có thể tham chiếu.
Sau đây là cú pháp khai báo một biến mảng.
Cú pháp
var z:Array[String] = new Array[String](3)
or
var z = new Array[String](3)
Ở đây, z được khai báo là một mảng các Chuỗi có thể chứa tối đa ba phần tử. Giá trị có thể được gán cho các phần tử riêng lẻ hoặc có quyền truy cập vào các phần tử riêng lẻ, nó có thể được thực hiện bằng cách sử dụng các lệnh như sau:
Command
z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"
Here, the last example shows that in general the index can be any expression that yields a whole number. There is one more way of defining an array −
var z = Array("Zara", "Nuha", "Ayan")
Following picture represents an array myList. Here, myList holds ten double values and the indices are from 0 to 9.
Processing Arrays
When processing array elements, we often use loop contol structures because all of the elements in an array are of the same type and the size of the array is known.
Below is an example program of showing how to create, initialize and process arrays −
Example
object Demo {
def main(args: Array[String]) {
var myList = Array(1.9, 2.9, 3.4, 3.5)
// Print all the array elements
for ( x <- myList ) {
println( x )
}
// Summing all elements
var total = 0.0;
for ( i <- 0 to (myList.length - 1)) {
total += myList(i);
}
println("Total is " + total);
// Finding the largest element
var max = myList(0);
for ( i <- 1 to (myList.length - 1) ) {
if (myList(i) > max) max = myList(i);
}
println("Max is " + max);
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
Scala does not directly support various array operations and provides various methods to process arrays in any dimension. If you want to use the different methods then it is required to import Array._ package.
Multi-Dimensional Arrays
There are many situations where you would need to define and use multi-dimensional arrays (i.e., arrays whose elements are arrays). For example, matrices and tables are examples of structures that can be realized as two-dimensional arrays.
The following is the example of defining a two-dimensional array −
var myMatrix = ofDim[Int](3,3)
This is an array that has three elements each being an array of integers that has three elements.
Try the following example program to process a multi-dimensional array −
Example
import Array._
object Demo {
def main(args: Array[String]) {
var myMatrix = ofDim[Int](3,3)
// build a matrix
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
myMatrix(i)(j) = j;
}
}
// Print two dimensional array
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + myMatrix(i)(j));
}
println();
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
0 1 2
0 1 2
0 1 2
Concatenate Arrays
Try the following example which makes use of concat() method to concatenate two arrays. You can pass more than one array as arguments to concat() method.
Example
import Array._
object Demo {
def main(args: Array[String]) {
var myList1 = Array(1.9, 2.9, 3.4, 3.5)
var myList2 = Array(8.9, 7.9, 0.4, 1.5)
var myList3 = concat( myList1, myList2)
// Print all the array elements
for ( x <- myList3 ) {
println( x )
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5
Create Array with Range
Use of range() method to generate an array containing a sequence of increasing integers in a given range. You can use final argument as step to create the sequence; if you do not use final argument, then step would be assumed as 1.
Let us take an example of creating an array of range (10, 20, 2): It means creating an array with elements between 10 and 20 and range difference 2. Elements in the array are 10, 12, 14, 16, and 18.
Another example: range (10, 20). Here range difference is not given so by default it assumes 1 element. It create an array with the elements in between 10 and 20 with range difference 1. Elements in the array are 10, 11, 12, 13, …, and 19.
The following example program shows how to create an array with ranges.
Example
import Array._
object Demo {
def main(args: Array[String]) {
var myList1 = range(10, 20, 2)
var myList2 = range(10,20)
// Print all the array elements
for ( x <- myList1 ) {
print( " " + x )
}
println()
for ( x <- myList2 ) {
print( " " + x )
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19
Scala Array Methods
Following are the important methods, which you can use while playing with array. As shown above, you would have to import Array._ package before using any of the mentioned methods. For a complete list of methods available, please check official documentation of Scala.
Sr.No | Methods with Description |
---|---|
1 | def apply( x: T, xs: T* ): Array[T] Creates an array of T objects, where T can be Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean. |
2 | def concat[T]( xss: Array[T]* ): Array[T] Concatenates all arrays into a single array. |
3 | def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit Copy one array to another. Equivalent to Java's System.arraycopy(src, srcPos, dest, destPos, length). |
4 | def empty[T]: Array[T] Returns an array of length 0 |
5 | def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] Returns an array containing repeated applications of a function to a start value. |
6 | def fill[T]( n: Int )(elem: => T): Array[T] Returns an array that contains the results of some element computation a number of times. |
7 | def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] Returns a two-dimensional array that contains the results of some element computation a number of times. |
8 | def iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T] Returns an array containing repeated applications of a function to a start value. |
9 | def ofDim[T]( n1: Int ): Array[T] Creates array with given dimensions. |
10 | def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] Creates a 2-dimensional array |
11 | def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] Creates a 3-dimensional array |
12 | def range( start: Int, end: Int, step: Int ): Array[Int] Returns an array containing equally spaced values in some integer interval. |
13 | def range( start: Int, end: Int ): Array[Int] Returns an array containing a sequence of increasing integers in a range. |
14 | def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] Returns an array containing values of a given function over a range of integer values starting from 0. |
15 | def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] Returns a two-dimensional array containing values of a given function over ranges of integer values starting from 0. |
Scala has a rich set of collection library. Collections are containers of things. Those containers can be sequenced, linear sets of items like List, Tuple, Option, Map, etc. The collections may have an arbitrary number of elements or be bounded to zero or one element (e.g., Option).
Collections may be strict or lazy. Lazy collections have elements that may not consume memory until they are accessed, like Ranges. Additionally, collections may be mutable (the contents of the reference can change) or immutable (the thing that a reference refers to is never changed). Note that immutable collections may contain mutable items.
For some problems, mutable collections work better, and for others, immutable collections work better. When in doubt, it is better to start with an immutable collection and change it later if you need mutable ones.
This chapter throws light on the most commonly used collection types and most frequently used operations over those collections.
Sr.No | Collections with Description |
---|---|
1 | Scala Lists Scala's List[T] is a linked list of type T. |
2 | Scala Sets A set is a collection of pairwise different elements of the same type. |
3 | Scala Maps A Map is a collection of key/value pairs. Any value can be retrieved based on its key. |
4 | Scala Tuples Unlike an array or list, a tuple can hold objects with different types. |
5 | Scala Options Option[T] provides a container for zero or one element of a given type. |
6 | Scala Iterators An iterator is not a collection, but rather a way to access the elements of a collection one by one. |
A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each class must inherit from just one superclass, a class can mix in any number of traits.
Traits are used to define object types by specifying the signature of the supported methods. Scala also allows traits to be partially implemented but traits may not have constructor parameters.
A trait definition looks just like a class definition except that it uses the keyword trait. The following is the basic example syntax of trait.
Syntax
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
This trait consists of two methods isEqual and isNotEqual. Here, we have not given any implementation for isEqual where as another method has its implementation. Child classes extending a trait can give implementation for the un-implemented methods. So a trait is very similar to what we have abstract classes in Java.
Let us assume an example of trait Equal contain two methods isEqual() and isNotEqual(). The trait Equal contain one implemented method that is isEqual() so when user defined class Point extends the trait Equal, implementation to isEqual() method in Point class should be provided.
Here it is required to know two important method of Scala, which are used in the following example.
obj.isInstanceOf [Point] To check Type of obj and Point are same are not.
obj.asInstanceOf [Point] means exact casting by taking the object obj type and returns the same obj as Point type.
Try the following example program to implement traits.
Example
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
class Point(xc: Int, yc: Int) extends Equal {
var x: Int = xc
var y: Int = yc
def isEqual(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == y
}
object Demo {
def main(args: Array[String]) {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotEqual(p2))
println(p1.isNotEqual(p3))
println(p1.isNotEqual(2))
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
true
false
true
Value classes and Universal Traits
Value classes are new mechanism in Scala to avoid allocating runtime objects. It contains a primary constructor with exactly one val parameter. It contains only methods (def) not allowed var, val, nested classes, traits, or objects. Value class cannot be extended by another class. This can be possible by extending your value class with AnyVal. The typesafety of custom datatypes without the runtime overhead.
Let us take an examples of value classes Weight, Height, Email, Age, etc. For all these examples it is not required to allocate memory in the application.
A value class not allowed to extend traits. To permit value classes to extend traits, universal traits are introduced which extends for Any.
Example
trait Printable extends Any {
def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable
object Demo {
def main(args: Array[String]) {
val w = new Wrapper(3)
w.print() // actually requires instantiating a Wrapper instance
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
It will give you the hash code of Wrapper class.
Wrapper@13
When to Use Traits?
There is no firm rule, but here are few guidelines to consider −
If the behavior will not be reused, then make it a concrete class. It is not reusable behavior after all.
If it might be reused in multiple, unrelated classes, make it a trait. Only traits can be mixed into different parts of the class hierarchy.
If you want to inherit from it in Java code, use an abstract class.
If you plan to distribute it in compiled form, and you expect outside groups to write classes inheriting from it, you might lean towards using an abstract class.
If efficiency is very important, lean towards using a class.
So khớp mẫu là tính năng được sử dụng rộng rãi thứ hai của Scala, sau các giá trị và đóng của hàm. Scala cung cấp hỗ trợ tuyệt vời cho việc đối sánh mẫu, trong việc xử lý các thông báo.
Đối sánh mẫu bao gồm một chuỗi các lựa chọn thay thế, mỗi lựa chọn bắt đầu bằng từ khóa case. Mỗi giải pháp thay thế bao gồm mộtpattern và một hoặc nhiều expressions, sẽ được đánh giá nếu mẫu phù hợp. Một biểu tượng mũi tên => tách mẫu khỏi các biểu thức.
Hãy thử chương trình ví dụ sau, chương trình này cho biết cách so khớp với giá trị số nguyên.
Thí dụ
object Demo {
def main(args: Array[String]) {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
many
Khối với các câu lệnh trường hợp xác định một hàm ánh xạ các số nguyên thành chuỗi. Từ khóa đối sánh cung cấp một cách thuận tiện để áp dụng một hàm (như hàm đối sánh mẫu ở trên) cho một đối tượng.
Hãy thử chương trình ví dụ sau, chương trình này khớp một giá trị với các mẫu của các loại khác nhau.
Thí dụ
object Demo {
def main(args: Array[String]) {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y: Int => "scala.Int"
case _ => "many"
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
2
many
one
Đối sánh bằng cách sử dụng các lớp tình huống
Các case classeslà các lớp đặc biệt được sử dụng để so khớp mẫu với các biểu thức chữ hoa chữ thường. Về mặt cú pháp, đây là các lớp tiêu chuẩn với một công cụ sửa đổi đặc biệt:case.
Hãy thử cách sau, nó là một ví dụ đối sánh mẫu đơn giản bằng cách sử dụng lớp chữ hoa chữ thường.
Thí dụ
object Demo {
def main(args: Array[String]) {
val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 32)
for (person <- List(alice, bob, charlie)) {
person match {
case Person("Alice", 25) => println("Hi Alice!")
case Person("Bob", 32) => println("Hi Bob!")
case Person(name, age) => println(
"Age: " + age + " year, name: " + name + "?")
}
}
}
case class Person(name: String, age: Int)
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?
Việc thêm từ khóa trường hợp khiến trình biên dịch tự động thêm một số tính năng hữu ích. Từ khóa gợi ý liên kết với các biểu thức chữ hoa chữ thường trong đối sánh mẫu.
Đầu tiên, trình biên dịch tự động chuyển đổi các đối số của hàm tạo thành các trường bất biến (vals). Từ khóa val là tùy chọn. Nếu bạn muốn các trường có thể thay đổi, hãy sử dụng từ khóa var. Vì vậy, danh sách đối số phương thức khởi tạo của chúng ta bây giờ ngắn hơn.
Thứ hai, trình biên dịch tự động triển khai equals, hashCode, và toStringcác phương thức của lớp, sử dụng các trường được chỉ định làm đối số của hàm tạo. Vì vậy, chúng ta không cần các phương thức toString () của riêng mình nữa.
Cuối cùng, phần thân của Person lớp trở nên trống vì không có phương thức nào mà chúng ta cần xác định!
Chương này giải thích cách Scala hỗ trợ các biểu thức chính quy thông qua Regex lớp có sẵn trong gói scala.util.matching.
Hãy thử chương trình ví dụ sau, nơi chúng tôi sẽ cố gắng tìm ra từ Scala từ một tuyên bố.
Thí dụ
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = "Scala".r
val str = "Scala is Scalable and cool"
println(pattern findFirstIn str)
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Some(Scala)
Chúng tôi tạo một chuỗi và gọi r( )phương pháp trên đó. Scala chuyển đổi hoàn toàn Chuỗi thành RichString và gọi phương thức đó để lấy một thể hiện của Regex. Để tìm đối sánh đầu tiên của biểu thức chính quy, chỉ cần gọifindFirstIn()phương pháp. Nếu thay vì chỉ tìm lần xuất hiện đầu tiên, chúng tôi muốn tìm tất cả các lần xuất hiện của từ phù hợp, chúng tôi có thể sử dụngfindAllIn( ) và trong trường hợp có nhiều từ Scala có sẵn trong chuỗi đích, điều này sẽ trả về một tập hợp tất cả các từ phù hợp.
Bạn có thể sử dụng phương thức mkString () để nối danh sách kết quả và bạn có thể sử dụng dấu ngoặc (|) để tìm kiếm chữ hoa và chữ thường của Scala và bạn có thể sử dụng Regex hàm tạo thay thế hoặc r() phương pháp tạo mẫu.
Hãy thử chương trình ví dụ sau.
Thí dụ
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = new Regex("(S|s)cala")
val str = "Scala is scalable and cool"
println((pattern findAllIn str).mkString(","))
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Scala,scala
Nếu bạn muốn thay thế văn bản phù hợp, chúng tôi có thể sử dụng replaceFirstIn( ) để thay thế trận đấu đầu tiên hoặc replaceAllIn( ) để thay thế tất cả các lần xuất hiện.
Thí dụ
object Demo {
def main(args: Array[String]) {
val pattern = "(S|s)cala".r
val str = "Scala is scalable and cool"
println(pattern replaceFirstIn(str, "Java"))
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Java is scalable and cool
Tạo biểu thức chính quy
Scala kế thừa cú pháp biểu thức chính quy của nó từ Java, do đó nó thừa hưởng hầu hết các tính năng của Perl. Đây chỉ là một số ví dụ đủ để làm mới -
Sau đây là bảng liệt kê tất cả các cú pháp ký tự Meta biểu thức chính quy có sẵn trong Java.
Subexpression | Diêm |
---|---|
^ | Đối sánh đầu dòng. |
$ | Đối sánh với cuối dòng. |
. | Khớp với bất kỳ ký tự đơn nào ngoại trừ dòng mới. Sử dụng tùy chọn m cũng cho phép nó khớp với dòng mới. |
[...] | Khớp bất kỳ ký tự đơn nào trong ngoặc. |
[^ ...] | Đối sánh bất kỳ ký tự đơn nào không có trong dấu ngoặc |
\\ A | Bắt đầu của toàn bộ chuỗi |
\\ z | Kết thúc toàn bộ chuỗi |
\\ Z | Kết thúc toàn bộ chuỗi ngoại trừ dấu chấm cuối dòng cuối cùng được phép. |
lại * | Khớp với 0 hoặc nhiều lần xuất hiện của biểu thức trước. |
lại + | Khớp với 1 hoặc nhiều điều trước đó |
lại? | Khớp với 0 hoặc 1 lần xuất hiện của biểu thức trước. |
lại {n} | Khớp chính xác n số lần xuất hiện của biểu thức trước. |
lại {n,} | So khớp n hoặc nhiều lần xuất hiện của biểu thức trước. |
lại {n, m} | Khớp ít nhất n và nhiều nhất m lần xuất hiện của biểu thức trước. |
a | b | Đối sánh với a hoặc b. |
(lại) | Nhóm các biểu thức chính quy và ghi nhớ văn bản phù hợp. |
(?: lại) | Nhóm các biểu thức chính quy mà không cần nhớ văn bản phù hợp. |
(?> lại) | Khớp với mẫu độc lập mà không cần bẻ khóa ngược. |
\\ w | Khớp các ký tự từ. |
\\ W | Đối sánh các ký tự không phải từ khóa. |
\\S | Khớp khoảng trắng. Tương đương với [\ t \ n \ r \ f]. |
\\S | Khớp với khoảng trắng. |
\\ d | Khớp các chữ số. Tương đương với [0-9]. |
\\ D | Phù hợp với nondigits. |
\\ A | Đối sánh với phần đầu của chuỗi. |
\\ Z | Đối sánh với phần cuối của chuỗi. Nếu một dòng mới tồn tại, nó sẽ khớp ngay trước dòng mới. |
\\ z | Đối sánh với phần cuối của chuỗi. |
\\ G | Các trận đấu chỉ kết thúc trận đấu cuối cùng. |
\\ n | Tham chiếu ngược để nắm bắt số nhóm "n" |
\\ b | Khớp các ranh giới từ khi nằm ngoài dấu ngoặc. Khớp với khoảng trắng lùi (0x08) khi bên trong dấu ngoặc. |
\\ B | Đối sánh các ranh giới không có từ khóa. |
\\ n, \\ t, v.v. | Khớp với dòng mới, dấu xuống dòng, tab, v.v. |
\\ Q | Escape (trích dẫn) tất cả các ký tự lên đến \\ E |
\\ E | Kết thúc trích dẫn bắt đầu bằng \\ Q |
Ví dụ về Cụm từ Thông dụng
Thí dụ | Sự miêu tả |
---|---|
. | Khớp bất kỳ ký tự nào ngoại trừ dòng mới |
[Rr] uby | Khớp "Ruby" hoặc "ruby" |
chà [anh em] | Khớp "ruby" hoặc "rube" |
[aeiou] | Khớp với bất kỳ một nguyên âm chữ thường nào |
[0-9] | Khớp với bất kỳ chữ số nào; giống với [0123456789] |
[az] | Khớp với bất kỳ ký tự ASCII viết thường nào |
[AZ] | Khớp với bất kỳ ký tự ASCII viết hoa nào |
[a-zA-Z0-9] | Phù hợp với bất kỳ điều nào ở trên |
[^ aeiou] | Khớp bất kỳ thứ gì khác ngoài một nguyên âm viết thường |
[^ 0-9] | Khớp bất kỳ thứ gì khác ngoài một chữ số |
\\ d | Khớp một chữ số: [0-9] |
\\ D | Khớp với một nondigit: [^ 0-9] |
\\S | Khớp một ký tự khoảng trắng: [\ t \ r \ n \ f] |
\\S | Khớp với khoảng trắng: [^ \ t \ r \ n \ f] |
\\ w | Khớp một ký tự từ đơn: [A-Za-z0-9_] |
\\ W | Khớp một ký tự không phải từ khóa: [^ A-Za-z0-9_] |
hồng ngọc? | Đối sánh "rub" hoặc "ruby": y là tùy chọn |
ruby * | Khớp "chà" cộng với 0 hoặc nhiều y |
ruby + | Khớp "chà" cộng với 1 hoặc nhiều y |
\\ d {3} | Khớp chính xác 3 chữ số |
\\ d {3,} | Khớp 3 chữ số trở lên |
\\ d {3,5} | Khớp 3, 4 hoặc 5 chữ số |
\\ D \\ d + | Không có nhóm: + lặp lại \\ d |
(\\ D \\ d) + / | Đã nhóm: + lặp lại cặp \\ D \ d |
([Rr] uby (,)?) + | Đối sánh "Ruby", "Ruby, ruby, ruby", v.v. |
Note- rằng mỗi dấu gạch chéo ngược xuất hiện hai lần trong chuỗi trên. Điều này là do trong Java và Scala, một dấu gạch chéo ngược là một ký tự thoát trong một chuỗi ký tự, không phải là một ký tự thông thường hiển thị trong chuỗi. Vì vậy, thay vì '\', bạn cần viết '\\' để nhận được một dấu gạch chéo ngược trong chuỗi.
Hãy thử chương trình ví dụ sau.
Thí dụ
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = new Regex("abl[ae]\\d+")
val str = "ablaw is able1 and cool"
println((pattern findAllIn str).mkString(","))
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
able1
Các ngoại lệ của Scala hoạt động giống như các ngoại lệ trong nhiều ngôn ngữ khác như Java. Thay vì trả về một giá trị theo cách thông thường, một phương thức có thể kết thúc bằng cách ném một ngoại lệ. Tuy nhiên, Scala không thực sự có các ngoại lệ được kiểm tra.
Khi bạn muốn xử lý các ngoại lệ, bạn sử dụng khối try {...} catch {...} giống như bạn làm trong Java ngoại trừ khối catch sử dụng đối sánh để xác định và xử lý các ngoại lệ.
Ngoại lệ ném
Việc ném một ngoại lệ trông giống như trong Java. Bạn tạo một đối tượng ngoại lệ và sau đó bạn ném nó vớithrow từ khóa như sau.
throw new IllegalArgumentException
Bắt ngoại lệ
Scala cho phép bạn try/catch bất kỳ ngoại lệ nào trong một khối duy nhất và sau đó thực hiện đối sánh mẫu với nó bằng cách sử dụng casecác khối. Hãy thử chương trình ví dụ sau để xử lý ngoại lệ.
Thí dụ
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Demo {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException =>{
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Missing file exception
Hành vi của điều này try-catchbiểu thức giống như trong các ngôn ngữ khác với ngoại lệ. Phần thân được thực thi và nếu nó ném một ngoại lệ, mỗicatch mệnh đề được thử lần lượt.
Mệnh đề cuối cùng
Bạn có thể bao bọc một biểu thức bằng một finallynếu bạn muốn làm cho một số mã thực thi bất kể biểu thức kết thúc như thế nào. Hãy thử chương trình sau.
Thí dụ
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Demo {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
} finally {
println("Exiting finally...")
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Missing file exception
Exiting finally...
Một trình giải nén trong Scala là một đối tượng có một phương thức được gọi là unapplylà một trong những thành viên của nó. Mục đích của phương thức không được áp dụng đó là so khớp một giá trị và tách nó ra. Thông thường, đối tượng trích xuất cũng xác định một phương thức képapply để xây dựng các giá trị, nhưng điều này không bắt buộc.
Thí dụ
Hãy để chúng tôi lấy một ví dụ về đối tượng xác định cả hai apply và unapplycác phương pháp. Phương thức áp dụng có cùng một ý nghĩa như mọi khi: nó biến Kiểm thử thành một đối tượng có thể được áp dụng cho các đối số trong dấu ngoặc đơn giống như cách một phương thức được áp dụng. Vì vậy, bạn có thể viết Test ("Zara", "gmail.com") để xây dựng chuỗi "[email protected]".
Các unapply phương pháp là thứ biến lớp Kiểm tra thành một extractor và nó đảo ngược quá trình xây dựng apply. Trường hợp áp dụng lấy hai chuỗi và tạo thành một chuỗi địa chỉ email từ chúng, không áp dụng lấy một địa chỉ email và trả về hai chuỗi có khả năng:user và domain của địa chỉ.
Các unapplycũng phải xử lý trường hợp chuỗi đã cho không phải là địa chỉ email. Đó là lý do tại sao không áp dụng trả về kiểu Option trên các cặp chuỗi. Kết quả của nó làSome (user, domain)nếu chuỗi str là địa chỉ email với người dùng và phần miền đã cho hoặc Không có, nếu str không phải là địa chỉ email. Dưới đây là một số ví dụ như sau.
Cú pháp
unapply("[email protected]") equals Some("Zara", "gmail.com")
unapply("Zara Ali") equals None
Chương trình ví dụ sau cho thấy một đối tượng trích xuất cho các địa chỉ email.
Thí dụ
object Demo {
def main(args: Array[String]) {
println ("Apply method : " + apply("Zara", "gmail.com"));
println ("Unapply method : " + unapply("[email protected]"));
println ("Unapply method : " + unapply("Zara Ali"));
}
// The injection method (optional)
def apply(user: String, domain: String) = {
user +"@"+ domain
}
// The extraction method (mandatory)
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2){
Some(parts(0), parts(1))
} else {
None
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Apply method : [email protected]
Unapply method : Some((Zara,gmail.com))
Unapply method : None
Phù hợp với mẫu với bộ chiết
Khi một thể hiện của một lớp được theo sau bởi dấu ngoặc đơn với danh sách không hoặc nhiều tham số, trình biên dịch sẽ gọi applyphương thức trên trường hợp đó. Chúng ta có thể định nghĩa áp dụng cả trong các đối tượng và trong các lớp.
Như đã đề cập ở trên, mục đích của unapplyphương pháp là trích xuất một giá trị cụ thể mà chúng tôi đang tìm kiếm. Nó hoạt động ngược lạiapplylàm. Khi so sánh một đối tượng giải nén bằng cách sử dụngmatch tuyên bố unapply phương thức sẽ được tự động thực thi.
Hãy thử chương trình ví dụ sau.
Thí dụ
object Demo {
def main(args: Array[String]) {
val x = Demo(5)
println(x)
x match {
case Demo(num) => println(x+" is bigger two times than "+num)
//unapply is invoked
case _ => println("i cannot calculate")
}
}
def apply(x: Int) = x*2
def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
10
10 is bigger two times than 5
Scala mở để sử dụng mọi đối tượng Java và java.io.File là một trong những đối tượng có thể được sử dụng trong lập trình Scala để đọc và ghi tệp.
Sau đây là một chương trình ví dụ để ghi vào một tệp.
Thí dụ
import java.io._
object Demo {
def main(args: Array[String]) {
val writer = new PrintWriter(new File("test.txt" ))
writer.write("Hello Scala")
writer.close()
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Nó sẽ tạo một tệp có tên Demo.txttrong thư mục hiện tại, nơi chương trình được đặt. Sau đây là nội dung của tập tin đó.
Đầu ra
Hello Scala
Đọc một dòng từ dòng lệnh
Đôi khi, bạn cần đọc thông tin nhập của người dùng từ màn hình và sau đó tiếp tục xử lý thêm. Chương trình ví dụ sau đây chỉ cho bạn cách đọc đầu vào từ dòng lệnh.
Thí dụ
object Demo {
def main(args: Array[String]) {
print("Please enter your input : " )
val line = Console.readLine
println("Thanks, you just typed: " + line)
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Please enter your input : Scala is great
Thanks, you just typed: Scala is great
Đọc nội dung tệp
Đọc từ các tệp thực sự đơn giản. Bạn có thể sử dụng Scala'sSourcelớp và đối tượng đồng hành của nó để đọc tệp. Sau đây là ví dụ cho bạn biết cách đọc từ"Demo.txt" tệp mà chúng tôi đã tạo trước đó.
Thí dụ
import scala.io.Source
object Demo {
def main(args: Array[String]) {
println("Following is the content read:" )
Source.fromFile("Demo.txt" ).foreach {
print
}
}
}
Lưu chương trình trên vào Demo.scala. Các lệnh sau được sử dụng để biên dịch và thực thi chương trình này.
Chỉ huy
\>scalac Demo.scala
\>scala Demo
Đầu ra
Following is the content read:
Hello Scala