Values, variables, dan literals

Values

JavaScript membedakan lima value primitive:

Variable

Variable adalah tempat untuk menyimpan sebuah value, di bawah ini adalah contoh x, y, dan z adalah sebuah variable

var x = 12;
var y = 11;
var z = x + y; // maka z = 23

JavaScript Identifiers

Variable harus menggunakan nama yang unik dan itu disebut dengan Identifier, contoh ketika anda ingin membuat variable nama anda anda dapat menggunakan identifier myName.

var myName = "ade yahya";

Aturan Penulisan Variable

Ada beberapa aturan penulisan variable, yaitu harus dimulai dengan huruf kemudian dapat diikuti dengan angka, atau dimulai dengan _ (underscore) kemudian diikuti dengan huruf, anda juga tidak bisa membuat identifier menggunakan spasi, biasanya spasi diganti dengan underscore

var 0myName = "ade yahya"; // salah
var my name = "ade yahya"; // salah
var my_name = "ade yahya"; // benar
var myName1 = "ade yahya"; // benar
var _myName = "ade yahya"; // benar

Tipe Data

Anda dapat membuat variable dengan tipe yang berbeda - beda seperti teks, angka, dan logika.

var x = 12; //angka (integer)
var nama = "ade yahya"; //teks (string)
var lapar = true; //logika (boolean)

JavaScript Identifier adalah dynimic typing.

JavaScript adalah bahasa yang dinamik. Artinya adalah anda tidak perlu menentukan tipe dari data yang anda deklarasikan. Dalam bahasa lain ketika anda ingin mendeklarasikan variable anda harus menentukan tipe dari variable tersebut.

Contoh dalam c++ ketika anda mendeklarasikan variable x dengan tipe data integer (nomor / numbers) anda harus menulis tipenya.

int x = 12;

Namun dalam JavaScript anda hanya perlu menuliskan identifier dari variable dan value dari variable kemudia JavaScript akan menentukannya dengan otomatis.

var x = 12; //otomatis dianggap integer

Mendeklarasikan (Membuat) JavaScript variable

untuk mendeklarasikan variable dalam javascript cukup simpel, anda hanya perlu menggunakan keyword var.

Membuat variable mobil

​var mobil;

kemudian memasukkan value kedalam variable mobil

​mobil = "Chevrolet";

Atau langsung membuat variable beserta valuenya.

​var mobil = "Chevrolet";

Variable local dan Variable Global

Anda dapat menggolongkan variable kedalam dua jenis, yaitu variable local dan variable global. Variable global adalah variable yang di deklarasikan diluar sebuah fungsi dan dapat diakses oleh semua fungsi. Variable local adalah variable yang di deklarasikan didalam sebuah fungsi dan hanya dapat di akses oleh fungsi yang bersangkutan.

var mobil = "Volvo"; //variable global

function cetakMobil(){
  console.log(mobil);
}

function cetakMotor(){
  var motor = "Honda"; //variable local
  console.log(motor);
}

Banyak variable dalam satu statement

Anda juga dapat mendeklarasikan banyak variable dalam satu statement atau satu baris.

var cowok = "ade yahya", cewek = "adel yahya";

Value = undefined

Kadang anda perlu membuat variable yang tidak diisi oleh value, atau akan diisi value pada baris kode selanjutnya. Ketika anda mendeklarasikan variable tanpa sebuah value maka otomatis variable tersebut berisi value undefined (Tidak didefinisikan)

​var boneka; //variable ini undifined

Variable aritmatika

Anda juga dapat mengisi value aritmatika pada sebuah variable.

var x = 7 + 3 + 5;

Konversi variable

Dalam beberapa kasus kadang anda ingin merubah tipe dari sebuah variable menjadi integer (bilangan bulat) atau float (bilangan pecahan) anda dapat menggunakan fungsi parseInt() dan parseFloat()

var tulisan = "89"; // Variable dengan value string
var angka = parseInt(tulisan); // tulisan dari string dirubah menjadi integer dan dimasukkan ke variable angka

Constants

Anda dapat membuat variable yang hanya bisa dibaca / diakses tanpa bisa dirubah nilainya selama program sedang berjalan, varible semacam ini disebut Constant atau Konstanta. Untuk mendeklarasikan Constant digunakan keyword const const.

const phi = 22/7;

Literals

Anda menggunakan literasi untuk merepresentasikan value di dalam javascript. Value ini adalah value yang tetap ( bukan variable ). Sesi ini akan menjelaskan anda tentang beberapa type dari literasi.

• Array literals
• Boolean literals
• Floating-point literals
• Integers
• Object literals
• String literals

Literasi Array

An array literal is a list of zero or more expressions, each of which represents an array element, enclosed in square brackets ([]). When you create an array using an array literal, it is initialized with the specified values as its elements, and its length is set to the number of arguments specified.

The following example creates the coffees array with three elements and a length of three:

var coffees = ["French Roast", "Colombian", "Kona"];

Note An array literal is a type of object initializer. See Using Object Initializers.

If an array is created using a literal in a top-level script, JavaScript interprets the array each time it evaluates the expression containing the array literal. In addition, a literal used in a function is created each time the function is called.

Array literals are also Array objects. See Array Object for details on Array objects.

Extra commas in array literals

You do not have to specify all elements in an array literal. If you put two commas in a row, the array is created with undefined for the unspecified elements. The following example creates the fish array:

var fish = ["Lion", , "Angel"];

This array has two elements with values and one empty element (fish[0] is "Lion", fish[1] is undefined, and fish[2] is "Angel").

If you include a trailing comma at the end of the list of elements, the comma is ignored. In the following example, the length of the array is three. There is no myList[3]. All other commas in the list indicate a new element. (Note: trailing commas can create errors in older browser versions and it is a best practice to remove them.)

var myList = ['home', , 'school', ];

In the following example, the length of the array is four, and myList[0] and myList[2] are missing.

var myList = [ , 'home', , 'school'];

In the following example, the length of the array is four, and myList[1] and myList[3] are missing. Only the last comma is ignored.

var myList = ['home', , 'school', , ];

Understanding the behavior of extra commas is important to understanding JavaScript as a language, however when writing your own code: explicitly declaring the missing elements as undefined will increase your code's clarity and maintainability.

Boolean literals

The Boolean type has two literal values: true and false.

Do not confuse the primitive Boolean values true and false with the true and false values of the Boolean object. The Boolean object is a wrapper around the primitive Boolean data type. See Boolean Object for more information.

Integers

Integers can be expressed in decimal (base 10), hexadecimal (base 16), and octal (base 8).

• Decimal integer literal consists of a sequence of digits without a leading 0 (zero).
• Leading 0 (zero) on an integer literal indicates it is in octal. Octal integers can include only the digits 0-7.
• Leading 0x (or 0X) indicates hexadecimal. Hexadecimal integers can include digits (0-9) and the letters a-f and A-F.

Octal integer literals are deprecated and have been removed from the ECMA-262, Edition 3 standard (in strict mode). JavaScript 1.5 still supports them for backward compatibility.

Some examples of integer literals are:

0, 117 and -345 (decimal, base 10)
015, 0001 and -077 (octal, base 8) 
0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)

Floating-point literals

A floating-point literal can have the following parts:

• A decimal integer which can be signed (preceded by "+" or "-"),
• A decimal point ("."),
• A fraction (another decimal number),
• An exponent.

The exponent part is an "e" or "E" followed by an integer, which can be signed (preceded by "+" or "-"). A floating-point literal must have at least one digit and either a decimal point or "e" (or "E").

Some examples of floating-point literals are 3.1415, -3.1E12, .1e12, and 2E-12.

More succinctly, the syntax is:

[(+|-)][digits][.digits][(E|e)[(+|-)]digits]

For example:

3.14
2345.789
.3333333333333333333
-.283185307179586

Object literals

An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). You should not use an object literal at the beginning of a statement. This will lead to an error or not behave as you expect, because the { will be interpreted as the beginning of a block.

The following is an example of an object literal. The first element of the car object defines a property, myCar, and assigns to it a new string, "Saturn"; the second element, the getCar property, is immediately assigned the result of invoking the function (CarTypes("Honda")); the third element, the special property, uses an existing variable (Sales).

var Sales = "Toyota";

function CarTypes(name) {
  if (name == "Honda") {
    return name;
  } else {
    return "Sorry, we don't sell " + name + ".";
  }
}

var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };

console.log(car.myCar);   // Saturn
console.log(car.getCar);  // Honda
console.log(car.special); // Toyota 

Additionally, you can use a numeric or string literal for the name of a property or nest an object inside another. The following example uses these options.

var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda

Object property names can be any string, including the empty string. If the property name would not be a valid JavaScript identifier, it must be enclosed in quotes. Property names that would not be valid identifiers also cannot be accessed as a dot (.) property, but can be accessed and set with the array-like notation("[]").

var unusualPropertyNames = {
  "": "An empty string",
  "!": "Bang!"
}
console.log(unusualPropertyNames."");   // SyntaxError: Unexpected string
console.log(unusualPropertyNames[""]);  // "An empty string"
console.log(unusualPropertyNames.!);    // SyntaxError: Unexpected token !
console.log(unusualPropertyNames["!"]); // "Bang!"

Please note:

var foo = {a: "alpha", 2: "two"};
console.log(foo.a);    // alpha
console.log(foo[2]);   // two
//console.log(foo.2);  // Error: missing ) after argument list
//console.log(foo[a]); // Error: a is not defined
console.log(foo["a"]); // alpha
console.log(foo["2"]); // two

String literals

A string literal is zero or more characters enclosed in double (") or single (') quotation marks. A string must be delimited by quotation marks of the same type; that is, either both single quotation marks or both double quotation marks. The following are examples of string literals:

• "foo"
• 'bar'
• "1234"
• "one line \n another line"
• "John's cat"

You can call any of the methods of the String object on a string literal value—JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the String.length property with a string literal:

console.log("John's cat".length) // Will print the number of symbols in the string including whitespace. In this case, 10.

You should use string literals unless you specifically need to use a String object. See String Object for details on String objects.

Using special characters in strings

In addition to ordinary characters, you can also include special characters in strings, as shown in the following example.

"one line \n another line"

The following table lists the special characters that you can use in JavaScript strings.

Escaping characters

For characters not listed in Table 2.1, a preceding backslash is ignored, but this usage is deprecated and should be avoided.

You can insert a quotation mark inside a string by preceding it with a backslash. This is known as escaping the quotation mark. For example:

var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
console.log(quote);

The result of this would be:

He read "The Cremation of Sam McGee" by R.W. Service.

To include a literal backslash inside a string, you must escape the backslash character. For example, to assign the file path c:\temp to a string, use the following:

var home = "c:\\temp";

You can also escape line breaks by preceding them with backslash. The backslash and line break are both removed from the value of the string.

var str = "this string \
is broken \
across multiple\
lines."
console.log(str);   // this string is broken across multiplelines.

Although JavaScript does not have "heredoc" syntax, you can get close by adding a linebreak escape and an escaped linebreak at the end of each line:

var poem = 
"Roses are red,\n\
Violets are blue.\n\
I'm schizophrenic,\n\
And so am I."

Unicode

Unicode is a universal character-coding standard for the interchange and display of principal written languages. It covers the languages of the Americas, Europe, Middle East, Africa, India, Asia, and Pacifica, as well as historic scripts and technical symbols. Unicode allows for the exchange, processing, and display of multilingual texts, as well as the use of common technical and mathematical symbols. It hopes to resolve internationalization problems of multilingual computing, such as different national character standards. Not all modern or archaic scripts, however, are currently supported.

The Unicode character set can be used for all known encoding. Unicode is modeled after the ASCII (American Standard Code for Information Interchange) character set. It uses a numerical value and name for each character. The character encoding specifies the identity of the character and its numeric value (code position), as well as the representation of this value in bits. The 16-bit numeric value (code value) is defined by a hexadecimal number and a prefix U, for example, U+0041 represents A. The unique name for this value is LATIN CAPITAL LETTER A.

Unicode is not supported in versions of JavaScript prior to 1.3.

Unicode compatibility with ASCII and ISO

Unicode is fully compatible with the International Standard ISO/IEC 10646-1; 1993, which is a subset of ISO 10646.

Several encoding standards (including UTF-8, UTF-16 and ISO UCS-2) are used to physically represent Unicode as actual bits.

The UTF-8 encoding of Unicode is compatible with ASCII characters and is supported by many programs. The first 128 Unicode characters correspond to the ASCII characters and have the same byte value. The Unicode characters U+0020 through U+007E are equivalent to the ASCII characters 0x20 through 0x7E. Unlike ASCII, which supports the Latin alphabet and uses a 7-bit character set, UTF-8 uses between one and four octets for each character ("octet" meaning a byte, or 8 bits.) This allows for several million characters. An alternative encoding standard, UTF-16, uses two octets to represent Unicode characters. An escape sequence allows UTF-16 to represent the whole Unicode range by using four octets. The ISO UCS-2 (Universal Character Set) uses two octets.

JavaScript and Navigator support for UTF-8/Unicode means you can use non-Latin, international, and localized characters, plus special technical symbols in JavaScript programs. Unicode provides a standard way to encode multilingual text. Since the UTF-8 encoding of Unicode is compatible with ASCII, programs can use ASCII characters. You can use non-ASCII Unicode characters in the comments, string literals, identifiers, and regular expressions of JavaScript.

Unicode escape sequences

You can use the Unicode escape sequence in string literals, regular expressions, and identifiers. The escape sequence consists of six ASCII characters: \u and a four-digit hexadecimal number. For example, \u00A9 represents the copyright symbol. Every Unicode escape sequence in JavaScript is interpreted as one character.

The following code returns the copyright symbol and the string "Netscape Communications".

var x = "\u00A9 Netscape Communications";

The following table lists frequently used special characters and their Unicode value.

The JavaScript use of the Unicode escape sequence is different from Java. In JavaScript, the escape sequence is never interpreted as a special character first. For example, a line terminator escape sequence inside a string does not terminate the string before it is interpreted by the function. JavaScript ignores any escape sequence if it is used in comments. In Java, if an escape sequence is used in a single comment line, it is interpreted as an Unicode character. For a string literal, the Java compiler interprets the escape sequences first. For example, if a line terminator escape character (e.g., \u000A) is used in Java, it terminates the string literal. In Java, this leads to an error, because line terminators are not allowed in string literals. You must use \n for a line feed in a string literal. In JavaScript, the escape sequence works the same way as \n.

Unicode characters in JavaScript files

Earlier versions of Gecko assumed the Latin-1 character encoding for JavaScript files loaded from XUL. Starting with Gecko 1.8, the character encoding is inferred from the XUL file's encoding. Please see International characters in XUL JavaScript for more information.

Displaying characters with Unicode

You can use Unicode to display the characters in different languages or technical symbols. For characters to be displayed properly, a client such as Mozilla Firefox or Netscape needs to support Unicode. Moreover, an appropriate Unicode font must be available to the client, and the client platform must support Unicode. Often, Unicode fonts do not display all the Unicode characters. Some platforms, such as Windows 95, provide partial support for Unicode.

To receive non-ASCII character input, the client needs to send the input as Unicode. Using a standard enhanced keyboard, the client cannot easily input the additional characters supported by Unicode. Sometimes, the only way to input Unicode characters is by using Unicode escape sequences.

For more information on Unicode, see the Unicode Home Page and The Unicode Standard, Version 2.0, published by Addison-Wesley, 1996.

Resources

• Text Escaping and Unescaping in JavaScript – an utility to convert characters in JavaScript unicode values