Tài liệu hạn chế xem trước, để xem đầy đủ mời bạn chọn Tải xuống
1
/ 11 trang
THÔNG TIN TÀI LIỆU
Thông tin cơ bản
Định dạng
Số trang
11
Dung lượng
190,31 KB
Nội dung
Nắm vữnglậptrìnhhướngđốitượngnguyênmẫu
Thế giới của các đốitượng
Khi bạn bắt đầu một ngày làm việc—lái xe đến cơ quan, ngồi tại bàn để thực hiện một nhiệm vụ,
ăn một bữa ăn, đi bộ qua một công viên—bạn thường có thể thao tác và tương tác với thế giới
của mình mà không cần biết các định luật vật lý chi tiết chi phối nó. Bạn có thể xử lý các hệ
thống khác nhau mà bạn đối phó với chúng mỗi ngày như là các đơn vị hoặc các đối tượng. Bạn
đánh giá tính phức tạp của chúng và thay vào đó nên tập trung vào các tương tác của bạn với
chúng.
Lịch sử
Simula, một ngôn ngữ để mô hình hóa, thường được coi là ngôn ngữ hướngđốitượng đầu tiên.
Sau đó, đến Smalltalk, C++, ngôn ngữ Java và C#. Tại thời điểm đó, trong hầu hết các ngôn ngữ
hướng đối tượng, các đốitượng được định nghĩa theo lớp. Sau đó, các nhà phát triển ngôn ngữ
lập trình Self, một hệ thống giống như Smalltalk, đã tạo ra một phương thức thay thế và trọng
lượng nhẹ hơn để định nghĩa các đốitượng được gọi là lậptrình dựa trên nguyênmẫu hoặc lập
trình hướngđốitượng nguyên mẫu.
Cuối cùng, JavaScript được phát triển với một hệ thống đốitượng dựa trên nguyênmẫu
(prototype). Tính phổ biến của JavaScript đã đưa các đốitượng dựa trên nguyênmẫu vào dòng
chảy chính. Mặc dù nhiều nhà phát triển cảm thấy khó chịu về điều này, nhưng nhờ vào việc
kiểm tra chặt chẽ hơn nên các hệ thống dựa trên nguyênmẫu có nhiều lợi thế.
Lập trìnhhướngđốitượng (Object-oriented programming - OOP) cố gắng tạo ra các hệ thống
phần mềm hoạt động một cách mô phỏng, là kỹ thuật mô hình hóa mạnh mẽ và phổ biến rộng rãi
trong phát triển phần mềm. Lập trìnhhướngđốitượng phổ biến vì nó phản ánh cách chúng ta
nhìn thế giới: như là một tập các đốitượng có thể tương tác với nhau và được thao tác theo nhiều
cách khác nhau. Sức mạnh của lậptrình OOP nằm trong hai nguyên tắc cốt lõi của nó:
Tính bao đóng (Encapsulation)
Cho phép các nhà phát triển che giấu các hoạt động bên trong của cấu trúc dữ liệu và chỉ
lộ ra các giao diện (interface) tin cậy có thể được dùng để tạo module hay các phần mềm
gắn kết. Nó tương tự như việc ẩn dấu thông tin.
Tính kế thừa (Inheritance)
Mở rộng sức mạnh của sự đóng gói bằng cách cho phép các đốitượng thừa kế các hành
vi đã đóng gói của các đốitượng khác. Nó tương tự như việc chia sẻ thông tin.
Hầu hết các nhà phát triển đều biết rõ những nguyên tắc này vì mọi ngôn ngữ lậptrình chính
thống đều hỗ trợ OOP (và thực hiện nó trong nhiều trường hợp). Mặc dù tất cả các ngôn ngữ
OOP đều hỗ trợ hai nguyên tắc cốt lõi, dưới dạng này hay dạng khác, trong nhiều năm qua đã có
ít nhất hai cách khác nhau cơ bản về định nghĩa các đối tượng.
Trong bài này, hãy tìm hiểu về những lợi ích của các mẫulậptrình OOP nguyênmẫu và các mẫu
đối tượng JavaScript.
Về đầu trang
Nguyên mẫu-là gì? Các lớp và các nguyênmẫu
Một lớp (class) là một khái niệm trừu tượng về các đốitượng định nghĩa các cấu trúc dữ liệu và
các phương thức bên trong nó hoặc là một tập hợp các đối tượng. Mỗi đốitượng là một thể hiện
(instance) của lớp. Các lớp cũng có nhiệm vụ xây dựng các đốitượng lớp theo các định nghĩa
của chúng và (tùy chọn) theo các tham số người dùng.
Một ví dụ cổ điển là lớp Point và lớp con của nó là Point3D để định nghĩa các điểm hai chiều
và ba chiều, tương ứng. Liệt kê 1 (Listing 1) cho thấy các lớp trông như thế này theo mã Java.
Liệt kê 1. Lớp Point của Java
class Point {
private int x;
private int y;
static Point(int x, int y) {
this.x = x;
this.y = y;
}
int getX() {
return this.x;
}
int getY() {
return this.y;
}
void setX(int val) {
this.x = val;
}
void setY(int val) {
this.y = val;
}
}
Point p1 = new Point(0, 0);
p1.getX() // => 0;
p1.getY() // => 0;
// Lớp Point3D là con của lớp Point, kế thừa các đặc tính của Point
class Point3D extends Point {
private int z;
static Point3D(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
int getZ() {
return Z;
}
void setZ(int val) {
this.z = val;
}
}
Point3D p2 = Point3D(0, 0, 0);
p2.getX() // => 0
p2.getY() // => 0
p2.getZ() // => 0
Ngược với định nghĩa đốitượng theo lớp, các hệ thống đốitượngnguyênmẫu hỗ trợ một
phương thức tạo đốitượng trực tiếp hơn. Ví dụ, trong JavaScript một đốitượng là một danh sách
các đặc tính đơn giản. Mỗi đốitượng có liên quan mật thiết với đốitượng cha khác hoặc nguyên
mẫu, đốitượng mà từ đó nó được thừa kế các đặc tính. Bạn có thể bắt chước ví dụ Point trong
JavaScript, như trong Liệt kê 2.
Liệt kê 2. Lớp Point của JavaScript
var point = {
x : 0,
y : 0
};
point.x // => 0
point.y // => 0
// tạo một đốitượng mới từ nguyênmẫu Point, kế thừa các đặc tính của Point
point3D = Object.create(point);
point3D.z = 0;
point3D.x // => 0
point3D.y // => 0
point3D.z // => 0
Có một sự khác biệt cơ bản giữa các hệ thống đốitượngnguyênmẫu và cổ điển. Các đốitượng
cổ điển được định nghĩa một cách trừu tượng như là một phần của một nhóm khái niệm và thừa
kế những đặc tính từ các lớp hoặc các nhóm khác của các đối tượng. Ngược lại, các đốitượng
nguyên mẫu được định nghĩa cụ thể là các đốitượng cụ thể và thừa kế hành vi từ các đốitượng
cụ thể khác.
Vì vậy, một ngôn ngữ OOP dựa trên lớp có một tính chất kép, đòi hỏi ít nhất là hai cấu kiện cơ
bản: các lớp và các đối tượng. Như là một kết quả của tính hai mặt này, khi phần mềm dựa trên
lớp phát triển, các hệ thống phân cấp lớp phức tạp có xu hướng phát triển. Nói chung không thể
dự báo được tất cả các cách mà các lớp sẽ cần được sử dụng các cách đó trong tương lai, vì thế,
hệ thống phân cấp lớp cần được liên tục cấu trúc lại để tạo điều kiện thuận lợi cho các thay đổi.
Các ngôn ngữ dựa trên nguyênmẫu loại bỏ sự cần thiết về tính hai mặt nói trên và tạo điều kiện
thuận lợi cho việc tạo và xử lý trực tiếp các đối tượng. Nếu như không có các đốitượng bị ràng
buộc bởi lớp, có thể tạo ra các hệ thống các đốitượng có ràng buộc lỏng lẻo hơn để trợ giúp duy
trì tính mô đun và làm giảm sự cần thiết phải cấu trúc lại.
Ngoài ra, việc có thể trực tiếp định nghĩa các đốitượng sẽ bổ sung khả năng to lớn và tính dễ
hiểu cho việc tạo và xử lý đối tượng. Ví dụ, trong Liệt kê 2, bạn có thể chỉ cần khai báo đối
tượng point của mình với một dòng: var point = { x: 0, y: 0 };. Với một dòng này, bạn
có một đốitượng làm việc đầy đủ, thừa kế hành vi từ Object.prototype của JavaScript, chẳng
hạn như phương thức toString. Để mở rộng hành vi của đốitượng của mình, bạn chỉ cần khai
báo một đốitượng khác với point là nguyênmẫu của nó. Ngược lại, ngay cả với ngôn ngữ OOP
cổ điển ngắn gọn nhất, trước tiên bạn sẽ phải định nghĩa một lớp, sau đó khởi tạo nó trước khi
bạn có một đốitượng có thể thao tác được. Để thừa kế, bạn sẽ phải định nghĩa một lớp khác để
mở rộng lớp đầu tiên này.
Mẫu của nguyênmẫu là khái niệm còn đơn giản hơn. Là con người, chúng ta thường nghĩ về các
nguyên mẫu. Ví dụ, trong một bài viết trên blog của Steve Yegge "Các mẫu thiết kế đa năng"
(xem phần Tài nguyên), ông trích dẫn ví dụ của một cầu thủ bóng đá Mỹ—là Emmitt Smith—
người mà với tốc độ của mình, sự nhanh nhẹn và sức mạnh di chuyển trở thành nguyênmẫu cho
tất cả các cầu thủ bóng đá mới trong Liên đoàn bóng đá quốc gia (NFL). Sau đó, khi một cầu thủ
tấn công mới nổi là LT được chọn, các nhà bình luận nói rằng:
"LT có cặp giò giống Emmitt."
"Anh ấy có thể cày như Emmitt."
"Tuy nhiên, anh ấy chạy một dặm chỉ trong năm phút!"
Các nhà bình luận đang mô hình hóa một đốitượng mới— là LT—dưới dạng một đốitượng
nguyên mẫu, là Emmitt Smith. Trong JavaScript, một mô hình như vậy sẽ trông giống như Liệt
kê 3.
Liệt kê 3. Mô hình JavaScript
var emmitt = {
// khai báo các đặc tính (properties)
};
var lt = Object.create(emmitt);
// khai báo các đặc tính khác cho đốitượng lt
Bạn có thể đối chiếu ví dụ này với việc mô hình hóa cổ điển, ở đó bạn có thể định nghĩa một lớp
RunningBack (cầu thủ tấn công) thừa kế từ lớp FootballPlayer (cầu thủ bóng đá). Lớp lt và
emmitt sẽ là các thể hiện của lớp RunningBack. Trong mã Java các lớp này có thể trông như Liệt
kê 4.
Liệt kê 4. Ba lớp Java
class FootballPlayer {
private string name;
private string team;
static void FootballPlayer() { }
string getName() {
return this.name;
}
string getTeam() {
return this.team;
}
void setName(string val) {
this.name = val;
}
void setTeam(string val) {
this.team = val;
}
}
class RunningBack extends FootballPlayer {
private bool offensiveTeam = true;
bool isOffesiveTeam() {
return this.offensiveTeam;
}
}
RunningBack emmitt = new RunningBack();
RunningBack lt = new RunningBack();
Mô hình cổ điển đi kèm với chi phí hoạt động dựa trên khái niệm nhiều hơn đáng kể, nhưng
không có sự kiểm soát mượt mà trên các thể hiện lớp emmitt và lt mà bạn nhận được với mô
hình nguyên mẫu. (Công bằng mà nói, lớp FootballPlayer không cần thiết 100%; nó có mặt ở
đây để so sánh với ví dụ tiếp theo). Đôi khi, chi phí hoạt động này có thể có ích, nhưng thường
nó chỉ là gánh nặng thôi.
Khá dễ dàng để mô phỏng mô hình hóa cổ điển với một hệ thống đốitượngnguyên mẫu. (Phải
thừa nhận rằng, cũng có thể làm ngược lại, mặc dù có lẽ không dễ dàng gì). Ví dụ, bạn có thể tạo
ra một đốitượng footballPlayer với một đốitượng runningBack khác có thừa kế từ
footballPlayer làm nguyênmẫu của nó. Trong JavaScript, các đốitượng này sẽ trông như Liệt
kê 5.
Liệt kê 5. Mô hình hóa JavaScript
var footballPlayer = {
name : "";
team : "";
};
var runningBack = Object.create(footballPlayer);
runningBack.offensiveTeam = true;
Bạn cũng có thể tạo ra một đốitượng lineBacker (cầu thủ hậu vệ) khác có thừa kế từ
footballPlayer, như trong Liệt kê 6.
Liệt kê 6. Thừa kế đốitượng
var lineBacker = Object.create(footballPlayer);
lineBacker.defensiveTeam = true;
Như trong Liệt kê 7, bạn có thể bổ sung hành vi cho cả hai đốitượng lineBacker và
runningBack bằng cách bổ sung đốitượng footballPlayer.
Liệt kê 7. Bổ sung các hành vi
footballPlayer.run = function () { this.running = true };
lineBacker.run();
lineBacker.running; // => true
Trong ví dụ này, bạn đang xử lý đốitượng footballPlayer như một lớp. Bạn cũng có thể tạo
các đốitượng cho Emmitt và LT, như trong Liệt kê 8.
Liệt kê 8. Tạo các đốitượng
var emmitt = Object.create(runningBack);
emmitt.superbowlRings = 3;
var lt = Object.create(emmitt);
lt.mileRun = '5min';
Do đốitượng lt thừa kế từ đốitượng emmitt, nên thậm chí bạn có thể xử lý đốitượng emmitt
như một lớp, như trong Liệt kê 9.
Liệt kê 9. Thừa kế và các lớp
emmitt.height = "6ft";
lt.height // => "6ft";
Nếu bạn đã dùng thử các ví dụ trên theo một ngôn ngữ có các đốitượng cổ điển, tĩnh (như mã
Java), bạn sẽ phải sử dụng mẫu của trình trang trí, còn đòi hỏi nhiều chi phí hoạt động dựa trên
khái niệm hơn và bạn vẫn không thể thừa kế trực tiếp từ đốitượng emmitt như là một cá thể.
Ngược lại, mẫu các đặc tính được sử dụng trong các ngôn ngữ dựa trên nguyênmẫu như
JavaScript cho phép bạn trang trí cho các đốitượng của mình theo một cách tự do hơn nhiều.
Về đầu trang
JavaScript không phải là ngôn ngữ Java
JavaScript và một số tính năng của nó, chẳng hạn như các đốitượngnguyên mẫu, đã là nạn nhân
của những sai lầm và những quyết định tiếp thị đáng tiếc trong lịch sử. Ví dụ, Brendan Eich (cha
đẻ của JavaScript) trình bày trong một mục blog tại sao cần có một ngôn ngữ mới: "mệnh lệnh
của quản lý kỹ thuật cấp cao hơn là ngôn ngữ này phải 'trông giống như Java'. Điều đó loại trừ
Perl, Python và Tcl, cùng với Scheme". Vì vậy, JavaScript trông giống như mã Java và tên của
nó được nối với ngôn ngữ Java, mà điều đó đang gây nhầm lẫn cho bất cứ ai không quen với một
hoặc cả hai ngôn ngữ đó. Mặc dù nhìn bề ngoài JavaScript trông giống như ngôn ngữ Java,
nhưng ở một mức độ sâu hơn nó không có gì giống Java cả—dẫn đến các hy vọng bị bỏ lỡ. Theo
Brendan Eich:
Tôi không tự hào, nhưng tôi hạnh phúc vì tôi đã chọn các hàm hạng nhất Scheme-ish và các
nguyên mẫu Self-ish (mặc dù là số ít) làm các thành phần chính. Các ảnh hưởng của Java, đặc
biệt không chỉ là các lỗi y2k Date (Ngày tháng năm 2000) mà còn điểm khác biệt giữa nguyên
thủy và đốitượng (ví dụ, string so với String), chỉ là không may mà thôi.
Các hy vọng không được thỏa mãn khó giải quyết được. Khi bạn mong chờ một ngôn ngữ y-
doanh nghiệp, tĩnh như ngôn ngữ Java, nhưng kết thúc bằng một ngôn ngữ có cú pháp giống như
mã Java nhưng hoạt động giống như Scheme và Self, bạn bị bất ngờ là đúng. Nếu bạn thích các
ngôn ngữ động, điều này sẽ là một bất ngờ được chào đón; nếu bạn không thích hoặc chúng
không quen thuộc với bạn, thì việc lậptrình bằng JavaScript có thể không dễ chịu.
JavaScript cũng có một số khuyết điểm thực sự: các biến toàn cầu bắt buộc, các vấn đề phạm vi,
việc chèn dấu chấm phẩy, các hành vi không phù hợp == và nhiều hơn nữa. Đối với những vấn
đề này, các lậptrình viên JavaScript đã phát triển một mảng các mẫu và các cách thực hành tốt
nhất để hỗ trợ phát triển phần mềm tin cậy. Phần tiếp theo thảo luận về một vài mẫu cần sử dụng
và một số mẫu nên tránh, để sử dụng tốt nhất hệ thống đốitượngnguyênmẫu của JavaScript.
Về đầu trang
Các mẫuđốitượng JavaScript
Để JavaScript trông giống như Java, các nhà thiết kế đã cố gắng thêm vào hàm khởi tạo
(constructor) thường thấy trong các ngôn ngữ cổ điển nhưng không nhất thiết phải có trong một
ngôn ngữ nguyên mẫu. Hãy xem xét mẫu dưới đây, nơi một đốitượng có thể được khai báo bằng
cách sử dụng một hàm khởi tạo như trong Liệt kê 10.
Liệt kê 10. Khai báo một đốitượng
function Point(x, y) {
this.x = x;
this.y = y;
}
Sau đó, bạn có thể tạo đốitượng này bằng cách sử dụng từ khóa new, tương tự như mã Java, như
trong Liệt kê 11.
Liệt kê 11. Tạo đốitượng
var p = new Point(3, 4);
p.x // => 3
p.y // => 4
Trong JavaScript, các hàm cũng chính là các đối tượng, do đó, có thể thêm các phương thức vào
nguyên mẫu của hàm khởi tạo, như trong Liệt kê 12.
Liệt kê 12. Thêm một phương thức
Point.prototype.r = function() {
return Math.sqrt((this.x * this.x) + (this.y * this.y));
};
Cùng với các hàm khởi tạo, bạn có thể dùng một mẫu thừa kế giả cổ điển (pseudoclassical), như
trong Liệt kê 13.
Liệt kê 13. Mẫu thừa kế giả cổ điển
function Point3D(x, y, z) {
this.x = x;
this.y = y;
this.z = z;
}
Point3D.prototype = new Point(); // thừa kế từ Point
Point3D.prototype.r = function() {
return Math.sqrt((this.x * this.x) + (this.y * this.y) + (this.z *
this.z));
};
Mặc dù đây chắc chắn là một cách hợp lệ để định nghĩa các đốitượng theo JavaScript (và đôi khi
có thể là cách tốt nhất), mẫu này có vẻ hơi rắc rối. Nó thêm dữ liệu thừa không cần thiết vào mã
của bạn khi được so sánh để nắmvữngmẫu của nguyênmẫu và định nghĩa các đốitượng hoàn
toàn theo phong cách này. Để tóm tắt, bạn định nghĩa đốitượng của mình bằng cách sử dụng một
đối tượng bằng chữ, như trong Liệt kê 14.
Liệt kê 14. Định nghĩa đốitượng
var point = {
x: 1,
y: 2,
r: function () {
return Math.sqrt((this.x * this.x) + (this.y * this.y));
}
};
Sau đó, như trong Liệt kê 15, bạn thừa kế bằng cách sử dụng Object.create.
Liệt kê 15. Thừa kế bằng cách sử dụng Object.create
var point3D = Object.create(point);
point3D.z = 3;
point3D.r = function() {
return Math.sqrt((this.x * this.x) + (this.y * this.y) + (this.z *
this.z));
};
Phương thức tạo đốitượng này có vẻ tự nhiên trong JavaScript và làm nổi bật những ưu điểm
của các đốitượngnguyênmẫu của nó. Tuy nhiên, một nhược điểm của cả hai mẫu của nguyên
mẫu và mẫu giả cổ điển là chúng không cung cấp bất kỳ thành phần riêng tư nào. Đôi lúc tính
riêng tư không quan trọng và đôi khi nó lại rất quan trọng. Liệt kê 16 hiển thị một mẫu cho phép
bạn tạo các đốitượng với các thành phần riêng tư. Trong cuốn sách JavaScript: Các điều tốt,
Douglas Crockford gọi mẫu này là mẫu thừa kế chức năng.
Liệt kê 16. Mẫu thừa kế chức năng
var point = function(spec) {
var that = {};
that.getTimesSet = function() {
return timesSet;
};
that.getX = function() {
return spec.x;
};
that.setX = function(val) {
spec.x = val;
};
that.getY = function() {
return spec.y;
};
that.setY = function(val) {
spec.y = val;
};
return that;
};
var point3D = function(spec) {
var that = point(spec);
that.getZ = function() {
return spec.z;
};
that.setZ = function(val) {
spec.z = val;
};
return that;
};
Một hàm khởi tạo dùng để tạo ra các đốitượng của bạn, các thành viên riêng tư được định nghĩa
bên trong và các cá thể được tạo ra bằng cách chuyển một spec vào hàm khởi tạo như trong Liệt
kê 17.
Liệt kê 17. Tạo các thể hiện
var p = point({ x: 3, y: 4 });
p.getX(); // => 3
p.setX(5);
var p2 = point3D({ x: 1, y: 4, z: 2 });
p.getZ(); // => 2
p.setZ(3);
. lập trình dựa trên nguyên mẫu hoặc lập
trình hướng đối tượng nguyên mẫu.
Cuối cùng, JavaScript được phát triển với một hệ thống đối tượng dựa trên nguyên. lợi ích của các mẫu lập trình OOP nguyên mẫu và các mẫu
đối tượng JavaScript.
Về đầu trang
Nguyên mẫu- là gì? Các lớp và các nguyên mẫu
Một lớp (class)