types-grammar, ch2: adding discussion of string behaviors like concatenation and methods

Author: getify

types-grammar/README.md

@@ -9,5 +9,5 @@
 * [Foreword](foreword.md) (by TBA)
 * [Preface](../preface.md)
 * [Chapter 1: Primitives](ch1.md)
-* [Chapter 2: Value Behavior](ch2.md)
+* [Chapter 2: Value Behaviors](ch2.md)
 * Chapter 3: TODO

types-grammar/ch1.md

@@ -222,6 +222,8 @@ The `string` type contains any value which is a collection of one or more charac
 myName = "Kyle";
 ```
 
+JS does not distinguish a single character as a different type as some languages do; `"a"` is a string just like `"abc"` is.
+
 Strings can be delimited by double-quotes (`"`), single-quotes (`'`), or back-ticks (`` ` ``). The ending delimiter must always match the starting delimiter.
 
 Strings have an intrinsic length which corresponds to how many code-points -- actually, code-units, more on that in a moment -- they contain.

types-grammar/ch2.md

@@ -1,38 +1,227 @@
 # You Don't Know JS Yet: Types & Grammar - 2nd Edition
-# Chapter 2: Value Behavior
+# Chapter 2: Value Behaviors
+
+| NOTE: |
+| :--- |
+| Work in progress |
 
 So far, we've explored seven built-in primitive value types in JS: `null`, `undefined`, `boolean`, `string`, `number`, `bigint`, and `symbol`.
 
 Chapter 1 was quite a lot to take in, much more involved than I bet most readers expected. If you're still catching your breath after reading all that, don't worry about taking a bit of a break before continuing on here!
 
 Once you're clear headed and ready to move on, let's dig into certain behaviors implied by value types for all their respective values. We'll take a careful and  closer look at all of these various behaviors.
 
-## Value Immutability
+## Primitive Immutability
+
+All primitive values are immutable, meaning nothing in a JS program can reach into the contents of the value and modify it in any way.
 
-All primitive values are immutable, meaning nothing in a JS program can reach into the inside of the value and modify it in any way.
+```js
+myAge = 42;
+
+// later:
+
+myAge = 43;
+```
 
-New values are created through operations, but these do not modify the original value.
+The `myAge = 43` statement doesn't change the value. It reassigns a different value `43` to `myAge`, completely replacing the previous value of `42`.
+
+New values are also created through various operations, but again these do not modify the original value:
 
 ```js
 42 + 1;             // 43
 
 "Hello" + "!";      // "Hello!"
 ```
 
-The values `43` and `"Hello!"` are new, distinct values from the `42` and `"Hello"` values, respectively.
+The values `43` and `"Hello!"` are new, distinct values from the previous `42` and `"Hello"` values, respectively.
 
-// TODO
+Even a string value, which looks like merely an array of characters -- and array contents are typically mutable -- is immutable:
+
+```js
+greeting = "Hello.";
+
+greeting[5] = "!";
 
-## Assignments Are Value Copies
+console.log(greeting);      // Hello.
+```
 
-Any assignment of a value from one variable/container to another is a *value-copy*.
+| WARNING: |
+| :--- |
+| In non-strict mode, assigning to a read-only property (like `greeting[5] = ..`) silently fails. In strict-mode, the disallowed assignment will throw an exception. |
+
+The nature of primitive values being immutable is not affected *in any way* by how the variable or object property holding the value is declared. For example, whether `const`, `let`, or `var` are used to declare the `greeting` variable above, the string value it holds is immutable.
+
+`const` doesn't create immutable values, it declares variables that cannot be reassigned (aka, immutable assignments) -- see the "Scope & Closures" title of this series for more information.
+
+A property on an object may be marked as read-only -- with the `writable: false` descriptor attribute, as discussed in the "Objects & Classes" title of this series. But that still has no affect on the nature of the value, only on preventing the reassignment of the property.
+
+### Primitives With Properties?
+
+Additionally, properties *cannot* be added to any primitive values:
+
+```js
+greeting = "Hello.";
+
+greeting.isRendered = true;
+
+greeting.isRendered;        // undefined
+```
+
+This snippet looks like it's adding a property `isRendered` to the value in `greeting`, but this assignment silently fails (even in strict-mode).
+
+Property access is not allowed in any way on nullish primitive values `null` and `undefined`. But properties *can* be accessed on all other primitive values -- yes, that sounds counter-intuitive.
+
+For example, all string values have a read-only `length` property:
+
+```js
+greeting = "Hello.";
+
+greeting.length;            // 6
+```
+
+`length` can not be set, but it can be accesses, and it exposes the number of code-units stored in the value (see "JS Character Encodings" in Chapter 1), which often means the number of characters in the string.
+
+| NOTE: |
+| :--- |
+| Sort of. For most standard characters, that's true; one character is one code-point, which is one code-unit. However, as explained in Chapter 1, extended Unicode characters above code-point `65535` will be stored as two code-units (surrogate halves). Thus, for each such character, `length` will include `2` in its count, even though the character visually prints as one symbol. |
+
+Non-nullish primitive values also have a couple of standard built-in methods that can be accessed:
+
+```js
+greeting = "Hello.";
+
+greeting.toString();    // "Hello." <-- redundant
+greeting.valueOf();     // "Hello."
+```
+
+Additionally, most of the primitive value-types define their own methods with specific behaviors inherent to that type. We'll cover these later in this chapter.
+
+| NOTE: |
+| :--- |
+| Technically, these sorts of property/method accesses on primitive values are facilitated by an implicit coercive behavior called *auto-boxing*, which we'll cover in the next chapter. |
+
+## Primitive Assignments
+
+Any assignment of a primitive value from one variable/container to another is a *value-copy*:
 
 ```js
 myAge = 42;
 
 yourAge = myAge;        // assigned by value-copy
+
+myAge;                  // 42
+yourAge;                // 42
+```
+
+Here, the `myAge` and `yourAge` variables each have their own copy of the number value `42`.
+
+| NOTE: |
+| :--- |
+| Inside the JS engine, it *may* be the case that only one `42` value exists in memory, and the engine points both `myAge` and `yourAge` variables at the shared value. Since primitive values are immutable, there's no danger in a JS engine doing so. But what's important to us as JS developers is, in our programs, `myAge` and `yourAge` act as if they have their own copy of that value, rather than sharing it. |
+
+If we later reassign `myAge` to `43` (when I have a birthday), it doesn't affect the `42` that's still assigned to `yourAge`:
+
+```js
+myAge++;            // sort of like: myAge = myAge + 1
+
+myAge;              // 43
+yourAge;            // 42 <-- unchanged
 ```
 
-Here, the `myAge` and `yourAge` variables each have their own copy of the number value `42`. That means if we later re-assign `myAge` to `43` when I have a birthday, it doesn't affect the `42` that's still assigned to `yourAge`.
+## String Behaviors
+
+String values have a number of specific behaviors that every JS developer should be aware of.
+
+As previously mentioned, string values have a `length` property that automatically exposes the number of characters (actually, code units). This property can only be accessed; attempts to set it are silently ignored.
+
+### String Character Access
+
+Though strings are not actually arrays, JS allows `[ .. ]` array-style access of its character at a numeric (`0`-based) index:
+
+```js
+greeting = "Hello!";
+
+greeting[4];            // "o"
+```
+
+If the value/expression between the `[ .. ]` doesn't resolve to a number, the value will be implicitly coerced to its whole/integer numeric representation (if possible).
+
+```js
+greeting["4"];          // "o"
+```
+
+If the value/expression resolves to a number outside the integer range of `0` - `length - 1` (or `NaN`), or if it's not a `number` value-type, the access will instead be treated as a property access with the string equivalent property name. If the property access thus fails, the result is `undefined`.
+
+| NOTE: |
+| :--- |
+|  We'll cover coercion in-depth later in the book. |
+
+### String Concatenation
+
+Two or more string values can be concatenated (combined) into a new string value, using the `+` operator:
+
+```js
+greeting = "Hello, " + "Kyle!";
+
+greeting;               // Hello, Kyle!
+```
+
+The `+` operator will act as a string concatenation if either of the two operands (values on left or right sides of the operator) are already a string.
+
+If one operand is a string and the other is not, the one that's not a string will be coerced to its string representation for the purposes of the concatenation.
+
+### String Methods
+
+Strings provide a whole slew of additional string-specific methods (as properties):
+
+* `charAt(..)`: produces a new string value at the numeric index, similar to `[ .. ]`; unlike `[ .. ]`, the result is always a string, either the character at position `0` (if a valid number outside the indices range), or the empty string `""` (if missing/invalid index)
+
+* `at(..)` is similar to `charAt(..)`, but negative indices count backwards from the end of the string
+
+* `charCodeAt(..)`: returns the numeric code-unit (see "JS Character Encodings" in Chapter 1) at the specified index
+
+* `codePointAt(..)`: returns the whole code-point starting at the specified index; if a surrogate pair is found there, the whole character (code-point) s returned
+
+* `substr(..)` / `substring(..)` / `slice(..)`: produces a new string value that represents a range of characters from the original string; these differ in how the range's start/end indices are specified or determined
+
+* `toUpperCase()`: produces a new string value that's all uppercase characters
+
+* `toLowerCase()`: produces a new string value that's all lowercase characters
+
+* `concat(..)`: produces a new string value that's the concatenation of the original string and all of the string value arguments passed in
+
+* `indexOf(..)`: searches for a string value argument in the original string, optionally starting from the position specified in the second argument; returns the `0`-based index position if found, or `-1` if not found
+
+* `lastIndexOf(..)`: like `indexOf(..)` but, from the end of the string (right in LTR locales, left in RTL locales)
+
+* `includes(..)`: similar to `indexOf(..)` but returns a boolean result
+
+* `search(..)`: similar to `indexOf(..)` but with a regular-expression matching as specified
+
+* `trimStart()` / `trimEnd()` / `trim()`: produces a new string value with whitespace trimmed from the start of the string (left in LTR locales, right in RTL locales), or the end of the string (right in LTR locales, left in RTL locales), or both
+
+* `repeat(..)`: produces a new string with the string argument value repeated the specified number of times
+
+* `split(..)`: produces an array of string values as split at the specified string or regular-expression boundaries
+
+* `padStart(..)` / `padEnd(..)`: produces a new string value with padding (default " " whitespace, but can be overriden) applied to either the start (left in LTR locales, right in RTL locales) or the end (right in LTR locales), left in RTL locales), so that the final string result is at least of a specified length
+
+* `startsWith(..)` / `endsWith(..)`: checks either the start (left in LTR locales, right in RTL locales) or the end (right in LTR locales) of the original string for the string value argument; returns a boolean result
+
+* `match(..)` / `matchAll(..)`: returns an array-like regular-expression matching result against the original string
+
+* `replace(..)`: returns a new string with a replacement from the original string, of one or more matching occurrences of the specified regular-expression match
+
+* `big()`, `blink()`, `bold()`, `fixed()`, `fontcolor()`, `fontsize()`, `italics()`, `link()`, `small()`, `strike()`, `sub()`, and `sup()`: historically, these were useful in generating HTML string snippets; they're now deprecated and should be avoided
+
+### Static String Helpers
+
+The following string utility functions are proviced directly on the `String` object, rather than as methods on individual string values:
+
+* `String.fromCharCode(..)` / `String.fromCodePoint(..)`: produce a string from one or more arguments representing the code-units (`fromCharCode(..)`) or whole code-points (`fromCodePoint(..)`)
+
+* `String.raw(..)`: a default template-tag function that allows interpolation on a template literal but prevents character escape sequences from being parsed, so they remain in their *raw* individual input characters from the literal
+
+## Number Behaviors
 
 // TODO

types-grammar/toc.md

@@ -17,7 +17,7 @@
     * BigInteger Values
     * Symbol Values
     * Primitives Are Built-In Types
-* Chapter 2: Value Behavior
-    * Value Immutability
-    * Assignments Are Value Copies
+* Chapter 2: Value Behaviors
+    * Primitive Immutability
+    * Primitive Assignments
     * TODO