--- title: '1-1: Values' description: 'Chapter 1-1 notes on values' --- # 1-1: Values ## 1-1-1: Numbers Values of the _number_ type are numeric values, normally written as follows, ```js 144 ``` - Put this into a program, it will cause the number 144 to come into existence inside the computer, with the following bash script, 144 might looks like this in bits, ```js 0100000001100010000000000000000000000000000000000000000000000000 ``` - With the following bash script, 144 will be converted into binary values in integer form, ```sh ip1=144 # defines a variable named ip1, with the value of 10 echo "obase=2;$ip1" | bc # convert the value to binary via bc ``` - The variable `ip1` is assigned the value 144. - The `echo` command prints out the string "obase=2;144", where "obase=2;" is an argument for `bc` that tells it to output the result in base 2 (binary), and "10" is the decimal number we want to convert. - The output of the `echo` command is piped (using the `|` character) to `bc`, which takes the input "`obase=2;144`" and interprets it as a command to convert the number 10 to binary. - Finally, the binary equivalent of 144, which is "10010000", is printed to the terminal. ::: tip But the standard describes JavaScript numbers as 64-bit floating-point values, which indicates fractions and exponents are available. ::: Not all whole numbers $10^{19}$ fit in a JavaScript number. There are also negative numbers, so one of the bits has to be used to store the sign of the number. - 11 bits are used to store the position of the decimal dot within the number. - 52 bits, any whole number less than $2^{52}$, which is more than $10^{15}$ will safely fit in a JavaScript number, numbers we are using stay well below that. Fractional numbers are written by using a dot, ```js 9.81 ``` For extreme huge or tiny numbers, we can also use "scientific" notion by adding an `e`, followed by the exponent of the number, ```js 2.998e8 ``` This indicates $2.998 \times 10^8 = 29980000$. Calculations with whole numbers (referred as _integers_) that fits into 52 bits are guaranteed to be always precise, but calculation with fraction numbers are generally not. - Such as $\pi$ cannot be precisely expressed by a finite amount of decimal digits, **thus many numbers lose some precision when only 64 bits are available to store them.** ::: details 1-1-1: Numbers review - 64 bits: A 64-bit number is a binary sequence of 64 bits, which can represent $2^{64}$ (18,446,744,073,709,551,616) different values. This is commonly used for representing memory addresses and integers with large values in computer systems. - 11 bits: An 11-bit number is a binary sequence of 11 bits, which can represent $2^{11}$ (2,048) different values. This is often used in computer systems for encoding small integers, such as color values in images. - 52 bits: A 52-bit number is a binary sequence of 52 bits, which can represent $2^{52}$ (4,503,599,627,370,496) different values. This is often used for representing the significand or mantissa portion of a floating-point number in computer systems. ::: ## 1-1-2: Arithmetic The main thing to do with numbers is arithmetic. Arithmetic operations such as addition or multiplication take two number values and produce a new number from them, the following is an example of calculation in JavaScript. ```js 100 + 4 * 11 ``` - The `+` and `*` symbols are called _operators_. - `+` apparently stands for addition while `*` stands for multiplication. - This expression indicates the multiplication takes place first then the adding of 100 comes next as a regard to [PEMDAS]() rules (Order of Operations). But we can still overwrite the steps of operation using a parenthesis around the addition, ```js ;(100 + 4) * 11 ``` For subtraction, there is the `-` operator, and division can be done with `/`. When operators appear together without parentheses, they are applied is determined by the _precedence_ of the operators. - When multiple operators with the same precedence appear next to each other (as `1-2+1`), they are applied left to right (refers to PEMDAS). - Precedence: Priorities. ::: warning When is doubt, don't care about precedence, just add parentheses for order of operation. ::: There is one more arithmetic operator, which is the `%` percent sign used to represent the _modulo_ operation. **The term "X modulo Y" is defined as the remainder of dividing X by Y.** - For example, `314 % 100` is `14`, `10 % 3` is `1`, and `144 % 12` is 0 because there are no remainders. - Modulo's precedence is the same as that of multiplication and division. ::: details 1-2: Arithmetic review - All of the operators in JavaScript follows precedence rules, or referred as PEMDAS in conventional math. - `+` and `-` has the same lowest precedence. - `*` , `/` and `%` has the same medium precedence. - `()` has the highest precedence, followed on with brackets. - The symbol `%` refers to "modulo", in mathematical reading, we say "X modulo Y" is the remainder of X over Y. ::: ## 1-1-3: Strings The next data type is the _string_. Its use is not as evident from its name as with numbers, it also fulfills a very basic role. - Strings are used to represent text. - Strings are usually written by enclosing the contents with quotes. ```js 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.' 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.' ``` ::: tip **Both single and double quotes** can be used to mark strings - As long as the quotes at the start and the end of the string match. ::: Almost anything can be put between quotes, and JavaScript will make a string value out of it. But the followings are tricky to be put between quotes. - **Newlines**: The things we get when we press enter on keyboard. We uses `\n` to represent. - **New tab**: Similarly like newlines, `\t` indicates a new tab being indented. Take the following string as an example, ```js 'Lorem ipsum dolor sit amet,\n consectetur adipiscing elit.' ``` The following will be the rendered output, ```js Lorem ipsum dolor sit amet, consectetur adipiscing elit. ``` ::: warning But the situations where we want a backslash in a string to just be a backslash instead of a special code. By using `\\` would render the "just slash" to `\` on output, instead of a special character, as follows, ```js "A newline character is written like \"\\n\"." ``` ::: Strings cannot be divided, multiplied, or subtracted, unlike integers. But the `+` operator can be used on the. It concatenates (glues) the two strings together, the following example will produce the string "`concatenate`". ```js 'con' + 'cat' + 'e' + 'nate' ``` ::: details 1-1-3: Strings review - Nearly everything could be put into strings in JavaScript - String could be wrapped with `""` double quotation marks or `''` single quotation marks. - There is a tricky situation in JavaScript's string, where `\` backslash followed with a character are being introduced specially by the interpreter, such as `\n` referred as newline, `\t` referred as new tab. - `\\` double backslash will be rendered as a single `\`. - `\&` symbols followed after slash will not contain its original function such as connecting, but will be rendered as `&` on output. ::: ### 1-1-3-FR: Further Reading From the example given in the prior section with a lot of backslashes, it might be hard to understand the concept on at what time the slash will be rendered and when it will be considered as a special character starter. The example is given as, ```js "A newline character is written like \"\\n\"." ``` The rendered output will be on print, ```js A newline character is written like "\n". ``` the backslash character (`\`) is used as an escape character to indicate that the following character(s) should be treated specially. In this case, the `"\n"` sequence is an escape sequence that represents a newline character. The backslash before the `n` character tells the JavaScript interpreter that it should treat the `n` as a special character and not just as the letter "n". However, if we want to include an **actual backslash character** (`\`), we will have to **escape it** by using to two backslashes `\\`, or else with one single slash the JavaScript interpreter will still determines it as an special operator, Thus `\\` will print `\` on output. - **But what about the quotation marks used within the quotation marks that wraps the string? Wouldn't JavaScript interpreter throw error?** - In the given JavaScript string, the inner set of double quotation marks (`"\\n"`) is escaped using a backslash (`\`) character. This tells the JavaScript interpreter to treat the inner double quotation marks as a regular character instead of a string delimiter. So when the string is rendered on output, the backslash character will be removed and the inner set of quotation marks will be displayed as a regular character. The rendered string will look like this, ```js '\n' ``` The outer set of double quotation marks in the original string delimit the entire string and will be displayed as regular quotation marks. > **Source**: ChatGPT CA (Code Analysis)