Các kiểu đơn giản nhất trong JavaScript là kiểu số (numbers), kiểu chuỗi (strings), kiểu luận lý (booleans: gồm hai giá trị true, false), nullundefined. Chúng có thể là các objects nhưng immutable (không thay đổi khi được tạo ra). Ngoài những kiểu đơn giản đó, mọi thứ trong JavaScript đều là objects và có thể thay đổi (mutable): mảng, hàm, biểu thức thường quy (regular expression),…

Objects chứa các thuộc tính (properties), đó là cặp tên (name) và giá trị (value). Tên thuộc tính là một chuỗi (có thể là rỗng), giá trị thuộc tính có thể là bất kì giá trị nào trong JavaScript trừ undefined. Objects có ích trong việc lưu trữ và tổ chức dữ liệu, đồng thời mỗi object có thể chứa bên trong nó các objects khác nên nó có thể được tổ chức theo cây hay đồ thị. Các objects có thể được thừa kế.

Object Literals

Là cách dễ nhất để tạo một object mới. Mỗi object literal là một danh sách chứa không hoặc nhiều thuộc tính (properties) thể hiện qua các cặp tên / giá trị (name /value) trong cặp ngoặc nhọn {}. Giữa các cặp tên/giá trị cách nhau bởi dấu ,.

Ví dụ: tạo đối tượng không có thuộc tính

var empty_person = { };

Tạo đối tượng chứa các thuộc tính và giá trị:

var person = {firstname:"John", lastname:"Doe", age:50};

Các thuộc tính là firstname, lastnameage. Các giá trị tương ứng là John, Doe, 50.

Giá trị của thuộc tính trong object có thể chứa object literal khác. Xem ví dụ sau:

var flight = {
       airline: "Oceanic",
       number: 815,
       departure: {
                IATA: "SYD",
                time: "2004-09-22 14:55",
                city: "Sydney"
       },
       arrival: {
                IATA: "LAX",
                time: "2004-09-23 10:42",
                city: "Los Angeles"
       }
};

Retrieval (Truy cập các thuộc tính của đối tượng)

Các giá trị của các thuộc tính của đối tượng có thể được truy cập thông qua cú pháp:

Object_name["Property_name "]

Hoặc

Object_name.Property_name

Ví dụ:

person["firstname"]  // John
person.firstname  // John

Giá trị undefined sẽ được trả về nếu truy cập đến thuộc tính không tồn tại trong object. Ví dụ:

person.name // sẽ trả về undefined vì thuộc tính name không tồi tại trong person

Dùng toán tử || (or) để trả về giá trị mặc định nếu thuộc tính chứa giá trị rỗng hay truy cập đến giá trị của thuộc tính không tồn tại. Ví dụ:

Đối tượng person được định nghĩa như sau:

var person = {firstname:"", lastname:"", age:50};

Truy cập các thuộc tính:

person.name || "unknown"; // thay vì trả về undefined sẽ trả về unknown
person.firstname || "unknown"; // trả về unknown

Cố gắng truy cập giá trị các thuộc tính không tồn tại sẽ phát sinh ngoại lệ TypeError. Có thể dùng toán tử  && để ngăn chặn lỗi này. Ví dụ:

person.name // sẽ trả về undefined
person.name.age // phát sinh ngoại lệ TypeError
person.name && person.name.age //sẽ trả về undefined

Update (Cập nhật giá trị cho thuộc tính của object)

Giá trị của thuộc tính (đã tồn tại) có thể được cập nhật bằng toán tử gán. Ví dụ giá trị của thuộc tính firstname của person có thể được cập nhật lại như sau:

person.firstname = "Minh";

Nếu thuộc tính chưa tồn tại trong object thì object sẽ thêm thuộc tính và giá trị mới vừa cập nhật. Ví dụ thuộc tính middlename không tồn tại trong đối tượng person nhưng sau lệnh dưới đây thì person sẽ tự động thêm thuộc tính middlename và giá trị:

person.middlename = "Ngoc"; // person sẽ cập nhật thêm thuộc tính middlename và giá trị "Ngoc"

Reference (tham chiếu)
Các objects không thể sao chép lẫn nhau, chúng chỉ có thể trao đổi với nhau thông qua tham chiếu. Xét ví dụ sau:

var x = person; // lúc này x và person cùng tham chiếu (hướng) về một đối tượng
x.nickname =  "ABC";
var y = person.nickname; // y sẽ trả về "ABC" vì x và person tham chiếu về cùng một đối tượng
var a = {}, b = {}, c = {}; // mỗi đối tượng a, b, c sẽ tham chiếu đến một đối tượng rỗng khác nhau
a = b = c = {}; // a, b, c tham chiếu về cùng một đối tượng rỗng

Prototype
Mỗi object sẽ liên kết (hay thừa kế) từ một prototype object (đối tượng nguyên mẫu). Mọi thuộc tính trong prototype object sẽ được kế thừa từ object liên kết đến nó. Prototype object chuẩn trong JavaScript mà mọi đối tượng đều liên kết đến là Object.prototype.

Khi tạo một object mới, chúng ta có thể chọn một đối tượng nào đó để làm prototype của nó bằng cách sử dụng phương thức Create của Object. Ví dụ tạo đối tượng newperson với đối tượng prototype là person (hay nói cách khác đối tượng newperson sẽ kế thừa từ đối tượng person) như sau:

var newperson = Object.create(person);

Khi có một vài thay đổi (hay cập nhật) xảy ra tại một object nào đó, prototype object của nó sẽ không bị ảnh hưởng. Ví dụ đối tượng newperson cập nhật  lại thuộc tính fistname mà không ảnh hưởng gì đến person:

var person = {firstname:"John", lastname:"Steve", age:50};
var newperson = Object.create (person);
newperson.firstname = "Jobs"; // firstname của newperson là Jobs và firstname của person vẫn là John.

Tuy nhiên, khi có một vài thay đổi xảy ra tại prototype object, các đối tượng kế thừa từ nó sẽ lập tức thay đổi theo. Ví dụ:

var person = {firstname:"John", lastname:"Steve", age:50};
var newperson = Object.create (person);
var x = newperson.firstname; // x = John
person.firstname = "Jobs";
x = newperson.firstname; // x = Jobs

Khi truy cập đến một thuộc tính không tồn tại trong một object, JavaScript sẽ cố gắng tìm và truy cập thuộc tính đó tại prototype object của nó và cứ lần ngược đến các prototype object trước đó cho đến khi đến Object.prototype. Trong suốt quá trình tìm kiếm đó, nếu thuộc tính vẫn không tồn tại thì giá trị undefined sẽ được trả về.  Quá trình này gọi là delegation (sự uỷ quyền) và con đường tìm kiếm (trong trường hợp ví dụ là Object.prototype - person - newperson) gọi là prototype chain. Ví dụ:

var person = {firstname:"John", lastname:"Steve", age:50};
var newperson = Object.create (person);
var x = newperson.nickname; // x = undefined vì nickname không tồn tại trong newperson-person-Object.prototype (gọi là Prototype chain)

Reflection
Có thể kiểm tra một object có những thuộc tính nào và những giá trị mà nó nhận bằng toán tử typeof. Ví dụ:

typeof person.firstname; // sẽ trả về string
typeof person.age; // trả về number
typeof person.nickname // trả về undefined

Các phương thức cũng có thể được trả về là function. Toán tử typeof sẽ kiểm tra thuộc tính hay phương thức của object trên toàn bộ prototype chain. Ví dụ:

typeof person.toString; // sẽ trả về function vì toString là phương thức của đối tượng Object.prototype

Một cách khác để kiểm tra các thuộc tính (hay phương thức) trong một object là sử dụng phương thức hasOwnProperty. Phương thức này sẽ trả về true nếu thuộc tính hay phương thức có tồn tại trong object, ngược lại là false. Ví dụ:

person.hasOwnProperty(firstname); // sẽ trả về true
person.hasOwnProperty(nickname); // trả về false

Phương thức hasOwnProperty không kiểm tra prototype chain, nghĩa là nó sẽ trả về fasle nếu thuộc tính hay phương thức không tồn tại trong object mà không cần quan tâm liệu thuộc tính (hay phương thức) đó có tồn tại trong prototype object không. Ví dụ:

var person = {firstname:"John", lastname:"Steve", age:50};
var newperson = Object.create (person);
person.hasOwnProperty(firstname); // sẽ trả về true
newperson.hasOwnProperty(firstname); // sẽ trả về false

Delete
Toán tử delete dùng để xoá một thuộc tính của object và không ảnh hưởng đến prototype object. Và nếu thuộc tính của một object trùng tên (nhưng khác giá trị) với một thuộc tính trong  prototype object thì object sẽ dùng thuộc tính trong prototype object sau khi thuộc tính của mình bị xoá. Ví dụ:

var person = {firstname:"John", lastname:"Steve", age:50};
var newperson = Object.create (person);
newperson.firstname = "Job";
var x = newperson.firstname; // x = Job
delete newperson.firstname; // xoá Job
x = newperson.firstname; // x = John (từ person)

Enumeration

Có thể duyệt qua danh sách các thuộc tính của một object bằng lệnh lặp for/in. Ví dụ duyệt qua các thuộc tính của person:

var name;
for (name in person) {
       document.getElementById("demo").innerHTML += name + ":" + person[name] + "  ";
}

Chạy thử đoạn mã
Nếu chúng ta qua tâm đến thứ tự các thuộc tính thì có thể dùng for thay vì for/in. Ví dụ trên có thể viết lại:

var i;
var properties = ['first-name', 'last-name', 'age' ];
for (i = 0; i < properties.length; i += 1) {
     document.getElementById("demo").innerHTML += properties[i] + ': ' + person[properties[i]];
}

Chạy thử đoạn mã
Global Abatement (giảm ảnh hưởng toàn cục)

Trong javaScript chúng ta rất dễ khai báo các biến toàn cục (global variables). Đây là một nhược điểm của JavaScript. Để hạn chế điều này, một giải pháp là định nghĩa một biến toàn cục như là bộ chứa chứa tất cả các đối tượng trong ứng dụng JavaScript làm cho ứng dụng dễ đọc hơn vì có tính cấu trúc hơn. Ví dụ định nghĩa biến toàn cục MYAPP như sau:

var MYAPP = {};

Các đối tượng sẽ chứa trong  MYAPP, ví dụ như person sẽ được định nghĩa như sau:

MYAPP.person = {firstname:"John", lastname:"Steve", age:50};

Với định nghĩa này thì việc sử dụng person sẽ phải thông qua MYAPP.

< JavaScript cơ bản