# 1-1: Values | Toshiki's Note
Chapter 1-1 notes on values
Author: Anda Toshiki
Keywords: Toshiki, Anda Toshiki, andatoshiki, GitHub, GitHub action, Vitepress, Vite, Notebook, Knowledge base, Programming, Programming Notes, Academic, Personal, Notebook, Productivity, Journal, Note-taking, Markdown, Notepad, Organization, Tutorial

Skip to content

####

# 1-1: Values ​

Author:Anda Toshiki
Updated:a minute ago
Words:1.5k
Reading:9 min

## 1-1-1: Numbers ​

Values of the number type are numeric values, normally written as follows,

js

    144

    144

1

- 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

      0100000001100010000000000000000000000000000000000000000000000000

  1

- 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

      ip1=144 # defines a variable named ip1, with the value of 10
      echo "obase=2;$ip1" | bc # convert the value to binary via bc

  1
  2
  - 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 1 019 10^{19}1019 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 252 2^{52}252, which is more than 1 015 10^{15}1015 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

    9.81

1

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

    2.998e8

1

This indicates 2.998×1 08=29980000 2.998 \times 10^8 = 299800002.998×108=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.

1-1-1: Numbers review

- 64 bits: A 64-bit number is a binary sequence of 64 bits, which can represent 264 2^{64}264 (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 211 2^{11}211 (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 252 2^{52}252 (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

    100 + 4 * 11

1

- 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

    ;(100 + 4) * 11

1

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.

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.'

    'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
    'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'

1
2

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.'

    'Lorem ipsum dolor sit amet,\n consectetur adipiscing elit.'

1

The following will be the rendered output,

js

    Lorem ipsum dolor sit amet,
    consectetur adipiscing elit.

    Lorem ipsum dolor sit amet,
    consectetur adipiscing elit.

1
2

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\"."

    "A newline character is written like \"\\n\"."

1

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'

    'con' + 'cat' + 'e' + 'nate'

1
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\"."

    "A newline character is written like \"\\n\"."

1

The rendered output will be on print,

js

    A newline character is written like "\n".

    A newline character is written like "\n".

1

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'

        '\n'

    1

    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)