File	File	File	File	File	File	File	File
bootstra...d.css	bootstra...t.css	bootstrap.css	right.html	bootstra...s.map	bootstra...s.map	bootstra...s.map	bootstra...s.map
bootstra...n.css	bootstra...n.css	bootstra...n.css	bootstra...s.map	bootstra...s.map

diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md deleted file mode 100644 index dd84ea7..0000000 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ /dev/null @@ -1,38 +0,0 @@ ---- -name: Bug report -about: Create a report to help us improve -title: '' -labels: '' -assignees: '' - ---- - -**Describe the bug** -A clear and concise description of what the bug is. - -**To Reproduce** -Steps to reproduce the behavior: -1. Go to '...' -2. Click on '....' -3. Scroll down to '....' -4. See error - -**Expected behavior** -A clear and concise description of what you expected to happen. - -**Screenshots** -If applicable, add screenshots to help explain your problem. - -**Desktop (please complete the following information):** - - OS: [e.g. iOS] - - Browser [e.g. chrome, safari] - - Version [e.g. 22] - -**Smartphone (please complete the following information):** - - Device: [e.g. iPhone6] - - OS: [e.g. iOS8.1] - - Browser [e.g. stock browser, safari] - - Version [e.g. 22] - -**Additional context** -Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md deleted file mode 100644 index bbcbbe7..0000000 --- a/.github/ISSUE_TEMPLATE/feature_request.md +++ /dev/null @@ -1,20 +0,0 @@ ---- -name: Feature request -about: Suggest an idea for this project -title: '' -labels: '' -assignees: '' - ---- - -**Is your feature request related to a problem? Please describe.** -A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] - -**Describe the solution you'd like** -A clear and concise description of what you want to happen. - -**Describe alternatives you've considered** -A clear and concise description of any alternative solutions or features you've considered. - -**Additional context** -Add any other context or screenshots about the feature request here. diff --git a/.vscode/javascript-file-list.html b/.vscode/javascript-file-list.html deleted file mode 100644 index c0d0a44..0000000 --- a/.vscode/javascript-file-list.html +++ /dev/null @@ -1,193 +0,0 @@ - - - - - - - - - directory - - - - - - - -

- - diff --git a/.vscode/right.html b/.vscode/right.html deleted file mode 100644 index 00a44cd..0000000 --- a/.vscode/right.html +++ /dev/null @@ -1,564 +0,0 @@ - - - - - --ALL-JS-Files - - - Stable - - - - - - - - - - - - -

Folders
<Go Back>

-
- - - - - - - - - - - - - - - - - -

File	File	File	File	File	File	File	File
index.html	count-up.js	greeting.js	no-ohs.js	print-co...ns.js	snippet-0-1.js	snippet-5.js	total-product.js
a-tediou...sk.js	dare-to-...er.js	half.js	num-odds.js	product-up-to.js	snippet-0-2.js	spam.js	total.js
age.js	div-by-either.js	in-range.js	number-change.js	proper-p...ns.js	snippet-0-3.js	starts-with-r.js	two (2).js
alternat...ps.js	divisibl...ge.js	is-div-by-4.js	number-e...ns.js	raise-power.js	snippet-0-4.js	stay-positive.js	two-sum-pairs.js
average-...ur.js	divisible.js	is-long.js	number-range.js	remove-c...ls.js	snippet-1 (2).js	string-e...ns.js	two-sum.js
average.js	divisors.js	keep-it-quiet.js	odd-sum.js	remove-dupes.js	snippet-1.js	string-i...te.js	two.js
bleep-vowels.js	ends-in-ly.js	larger.js	one (2).js	remove-f...el.js	snippet-2 (2).js	string-r...er.js	wacky-word.js
boolean-...ns.js	ends-with-t.js	lengthie...rd.js	one-or-none.js	remove-s...ds.js	snippet-2.js	string-size.js	whoami.js
case-changer.js	evens.js	longer.js	one-to-four.js	remove-vowels.js	snippet-3 (2).js	strings-...hs.js	word-count.js
censor-e.js	filter-l...ds.js	make-acronym.js	one.js	reverse-array.js	snippet-3.js	sum-up-to.js	your-ave...on.js
choose-d...es.js	five-mul...of.js	make-matrix.js	pair-print.js	reverse-...te.js	snippet-4 (2).js	thirsty.js	zero (2).js
common-e...ts.js	fizz-buzz.js	maximum.js	parity.js	shorten-...ds.js	snippet-4.js	three (2).js	zero.js
comparisons.js	four.js	min-to-max.js	print-2d.js	small-st...ts.js	snippet-5 (2).js	three.js	zipper.js
contains.js	funny-sound.js

- -

-Folders: 1
-Files: 106
-Size of all files: 63049 KB

- - - \ No newline at end of file diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md deleted file mode 100644 index 18c9147..0000000 --- a/CODE_OF_CONDUCT.md +++ /dev/null @@ -1,128 +0,0 @@ -# Contributor Covenant Code of Conduct - -## Our Pledge - -We as members, contributors, and leaders pledge to make participation in our -community a harassment-free experience for everyone, regardless of age, body -size, visible or invisible disability, ethnicity, sex characteristics, gender -identity and expression, level of experience, education, socio-economic status, -nationality, personal appearance, race, religion, or sexual identity -and orientation. - -We pledge to act and interact in ways that contribute to an open, welcoming, -diverse, inclusive, and healthy community. - -## Our Standards - -Examples of behavior that contributes to a positive environment for our -community include: - -* Demonstrating empathy and kindness toward other people -* Being respectful of differing opinions, viewpoints, and experiences -* Giving and gracefully accepting constructive feedback -* Accepting responsibility and apologizing to those affected by our mistakes, - and learning from the experience -* Focusing on what is best not just for us as individuals, but for the - overall community - -Examples of unacceptable behavior include: - -* The use of sexualized language or imagery, and sexual attention or - advances of any kind -* Trolling, insulting or derogatory comments, and personal or political attacks -* Public or private harassment -* Publishing others' private information, such as a physical or email - address, without their explicit permission -* Other conduct which could reasonably be considered inappropriate in a - professional setting - -## Enforcement Responsibilities - -Community leaders are responsible for clarifying and enforcing our standards of -acceptable behavior and will take appropriate and fair corrective action in -response to any behavior that they deem inappropriate, threatening, offensive, -or harmful. - -Community leaders have the right and responsibility to remove, edit, or reject -comments, commits, code, wiki edits, issues, and other contributions that are -not aligned to this Code of Conduct, and will communicate reasons for moderation -decisions when appropriate. - -## Scope - -This Code of Conduct applies within all community spaces, and also applies when -an individual is officially representing the community in public spaces. -Examples of representing our community include using an official e-mail address, -posting via an official social media account, or acting as an appointed -representative at an online or offline event. - -## Enforcement - -Instances of abusive, harassing, or otherwise unacceptable behavior may be -reported to the community leaders responsible for enforcement at -. -All complaints will be reviewed and investigated promptly and fairly. - -All community leaders are obligated to respect the privacy and security of the -reporter of any incident. - -## Enforcement Guidelines - -Community leaders will follow these Community Impact Guidelines in determining -the consequences for any action they deem in violation of this Code of Conduct: - -### 1. Correction - -**Community Impact**: Use of inappropriate language or other behavior deemed -unprofessional or unwelcome in the community. - -**Consequence**: A private, written warning from community leaders, providing -clarity around the nature of the violation and an explanation of why the -behavior was inappropriate. A public apology may be requested. - -### 2. Warning - -**Community Impact**: A violation through a single incident or series -of actions. - -**Consequence**: A warning with consequences for continued behavior. No -interaction with the people involved, including unsolicited interaction with -those enforcing the Code of Conduct, for a specified period of time. This -includes avoiding interactions in community spaces as well as external channels -like social media. Violating these terms may lead to a temporary or -permanent ban. - -### 3. Temporary Ban - -**Community Impact**: A serious violation of community standards, including -sustained inappropriate behavior. - -**Consequence**: A temporary ban from any sort of interaction or public -communication with the community for a specified period of time. No public or -private interaction with the people involved, including unsolicited interaction -with those enforcing the Code of Conduct, is allowed during this period. -Violating these terms may lead to a permanent ban. - -### 4. Permanent Ban - -**Community Impact**: Demonstrating a pattern of violation of community -standards, including sustained inappropriate behavior, harassment of an -individual, or aggression toward or disparagement of classes of individuals. - -**Consequence**: A permanent ban from any sort of public interaction within -the community. - -## Attribution - -This Code of Conduct is adapted from the [Contributor Covenant][homepage], -version 2.0, available at -https://www.contributor-covenant.org/version/2/0/code_of_conduct.html. - -Community Impact Guidelines were inspired by [Mozilla's code of conduct -enforcement ladder](https://github.com/mozilla/diversity). - -[homepage]: https://www.contributor-covenant.org - -For answers to common questions about this code of conduct, see the FAQ at -https://www.contributor-covenant.org/faq. Translations are available at -https://www.contributor-covenant.org/translations. diff --git a/HTML_PATTERNS.html b/HTML_PATTERNS.html deleted file mode 100644 index 907e4f2..0000000 --- a/HTML_PATTERNS.html +++ /dev/null @@ -1,1261 +0,0 @@ - - - - - - Accessible HTML Content Patterns - - - - - - - - - - - -

- - - - - -

- - -

Headings

- -

First Header h1

- One morning, when Gregor Samsa woke from troubled dreams, he found himself transformed in his bed into a horrible vermin. He lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightly domed and divided by arches into stiff sections. The bedding was hardly able to cover it and seemed ready to slide off any moment. His many legs, pitifully thin compared with the size of the rest of him, waved about helplessly as he looked. -

Second header h2

- "What's happened to me?" he thought. It wasn't a dream. His room, a proper human room although a little too small, lay peacefully between its four familiar walls. A collection of textile samples lay spread out on the table - Samsa was a travelling salesman - and above it there hung a picture that he had recently cut out of an illustrated magazine and housed in a nice, gilded frame. It showed a lady fitted out with a fur hat and fur boa who sat upright, raising a heavy fur muff that covered the whole of her lower arm towards the viewer. -

Third header h3

- Gregor then turned to look out the window at the dull weather. Drops of rain could be heard hitting the pane, which made him feel quite sad. "How about if I sleep a little bit longer and forget all this nonsense", he thought, but that was something he was unable to do because he was used to sleeping on his right, and in his present state couldn't get into that position. However hard he threw himself onto his right, he always rolled back to where he was. He must have tried it a hundred times, shut his eyes so that he wouldn't have to look at the floundering legs, and only stopped when he began to feel a mild, dull pain there that he had never felt before. -

Fourth header h4

- "Oh, God", he thought, "what a strenuous career it is that I've chosen! Travelling day in and day out. Doing business like this takes much more effort than doing your own business at home, and on top of that there's the curse of travelling, worries about making train connections, bad and irregular food, contact with different people all the time so that you can never get to know anyone or become friendly with them. It can all go to Hell!" He felt a slight itch up on his belly; pushed himself slowly up on his back towards the headboard so that he could lift his head better; found where the itch was, and saw that it was covered with lots of little white spots which he didn't know what to make of; and when he tried to feel the place with one of his legs he drew it quickly back because as soon as he touched it he was overcome by a cold shudder. -

Fifth header h5

- He slid back into his former position. "Getting up early all the time", he thought, "it makes you stupid. You've got to get enough sleep. Other travelling salesmen live a life of luxury. For instance, whenever I go back to the guest house during the morning to copy out the contract, these gentlemen are always still sitting there eating their breakfasts. I ought to just try that with my boss; I'd get kicked out on the spot. But who knows, maybe that would be the best thing for me. -

Sixth header h6

- If I didn't have my parents to think about I'd have given in my notice a long time ago, I'd have gone up to the boss and told him just what I think, tell him everything I would, let him know just what I feel. He'd fall right off his desk! And it's a funny sort of business to be sitting up there at your desk, talking down at your subordinates from up there, especially when you have to go right up close because the boss is hard of hearing. Well, there's still some hope; once I've got the money together to pay off my parents' debt to him - another five or six years I suppose - that's definitely what I'll do. That's when I'll make the big change. First of all though, I've got to get up, my train leaves at five." -

- -

Subtitles

- Title
- Subtitle -

Title

Subtitle

Title

Subtitle

- -

Notes:

Ensure that headings create a logical order. Apply CSS classes to control visual presentation (e.g. <h2 class="type-size-medium color-blue-dark">Our services</h2> ).
role="doc-subtitle" is used to alternate title for the work, but still has limited support.

- -

- - -

Text-level

- - -

Content

- And he looked over at the alarm clock, ticking on the chest of drawers. "God in Heaven!" he ~~thought~~. It was half past six and the hands were quietly moving forwards, it was even later than half past, more like quarter to seven. Had the _alarm clock not ^rung? He could see from the bed that it had been set for four o'clock as it should have been; it certainly must have rung. -

-
- "Yes, mother, yes, thank-you, I'm getting up now." -
-
- Gregor Samsa -
-

- Yes, but was it possible to quietly sleep through that furniture-rattling noise? True, he had not slept peacefully, but ~~probably~~ all the more deeply because of that. What should he do now? The next train went at seven; if he were to catch that he would have to rush like mad and the collection of samples was still not packed, and he did not at all feel particularly fresh and lively. -

- The French phrase, C'est le ton qui fait la chanson, might apply here. -

- -

Notes:

- <mark>, <ins>, <del>, and <s> elements are not announced by screen readers. Consider using CSS to indicate their presence. -
- Use the translate attribute to control automatic translation by the browser. -

- - - -

Links

- And even if he did catch the train he would not avoid his boss's anger as the office assistant would have been there to see the five o'clock train go, he would have put in his report about Gregor's not being there a long time ago. The office assistant was the boss's man, spineless, and with no understanding. What about if he reported sick? But that would be extremely strained and suspicious as in fifteen years of service Gregor had never once yet been ill. His boss would certainly come round with the doctor from the medical insurance company, accuse his parents of having a lazy son, and accept the doctor's recommendation not to make any claim as the doctor believed that no-one was ever ill but that many were workshy. And what's more, would he have been entirely wrong in this case? Gregor did in fact, apart from excessive sleepiness after sleeping for so long, feel completely well and even felt much hungrier than usual. -

- -

Block-level link title

- He was still hurriedly thinking all this through, unable to decide to get out of the bed, when the clock struck quarter to seven. There was a cautious knock at the door near his head. "Gregor", somebody called - it was his mother - "it's quarter to seven. Didn't you want to go somewhere? -

- -

- - - -

Lists

Unordered List

Apple
Apricot
Avocado -
- Fuerte
- Gwen
- Hass
- Pinkerton
- Reed
-
Banana -
1. Cavendish
2. Red Dacca
3. Gros Michel
4. East African Highland
5. Bodles Altafort
-
Bilberry
Blackberry
Blackcurrant

- -

Notes:

- VoiceOver will not announce unordered lists properly when either the list-style-type is set to none or display is set to inline. -

- -

Ordered List

Alabama
Alaska
Arizona -
- Phoenix
- Tucson
- Mesa
- Chandler
- Glendale
-
Arkansas
California
Colorado
Connecticut -
1. Bridgeport
2. New Haven
3. Hartford
4. Stamford
5. Waterbury
-
Delaware
Florida
Georgia

- -

Definition List

Alternate Character/Glyph: - A non-standard (sometimes decorative) variation of a character that comes as an extra option with a font file. -
Baseline: - The imaginary line on which most letters and other characters sit. -
Character: - An individual symbol of the full character set that makes up a typeface; may take the form of a letter, number, punctuation mark, etc. -
Serif: - A short line or stroke attached to or extending from the open ends of a letterform; also refers to the general category of typefaces that have been designed with this feature. -
Sans-Serif: - Literally “without line”; the general category of typefaces (or an individual typeface) designed without serifs. -

- - - -

Code


-      -sudo ipfw pipe 1 config bw 256KByte/s
-sudo ipfw add 1 pipe 1 src-port 3000
-      
-

- - -~/Sites/boilerplate -❦ ☢ ☭ ☂ ♞ - -$ ls -gto - -total 88 --rw-r--r-- 1 eric staff 6148 Mar 24 11:50 .DS_Store -drwxr-xr-x 9 eric staff 306 Mar 24 13:36 .git/ --rw-rw-r-- 1 eric staff 862 Oct 13 14:38 .gitignore --rw-r--r-- 1 eric staff 472 Feb 22 20:58 .htmlhintrc --rw-r--r-- 1 eric staff 1068 Mar 24 10:57 LICENSE --rw-r--r-- 1 eric staff 4865 Mar 24 13:34 README.md --rw-r--r-- 1 eric staff 58601 Mar 24 11:50 index.html - - - -

Notes:

- Apply translate="no" to markup that contains code examples to prevent keywords from being automatically translated. -

- - - -

Symbols

- -

Notes:

- Certain screen readers will not read certain symbols out loud. Use role="definition" in conjunction with aria-label to ensure the symbol is read. Use this technique with caution and discretion, as it will affect how the symbol is rendered by things like Braille readers. -

- - - -

Emoji

😺
🎩
⛄️
🍺
🍑

- -

Notes:

- Certain screen readers will not read certain symbols out loud. Use role="definition" in conjunction with aria-label to ensure the symbol is read. Use this technique with caution and discretion, as it will affect how the symbol is rendered by things like Braille readers. -
- Use role="img" in conjunction with aria-label to expose an emoji as an image in the accessibility tree, with the label providing author intent. -

- -

- - -

Tables

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

- Academy Awards for Best Picture - Descriptions of the film title, production company(s), and producers for the years 1980-1989. -
Film	Year	Production Company(s)	Producer(s)
Ordinary People	1980	Paramount	Ronald L. Schwary
Chariots of Fire	1981	Enigma Film Productions	David Puttnam
Gandhi	1982	Columbia	Richard Attenborough
Terms of Endearment	1983	Paramount	James L. Brooks
Amadeus	1984	Orion	Saul Zaentz
Out of Africa	1985	Universal, Mirage Enterprises	Sydney Pollack
Platoon	1986	Orion, Hemdale	Arnold Kopelson
The Last Emperor	1987	Recorded Picture Company, Yanco Films, TAO Films, AAA, Soprofilms	Jeremy Thomas
Rain Man	1988	United Artists	Mark Johnson
Driving Miss Daisy	1989	Warner Bros.	Richard D. Zanuck, Lili Fini Zanuck
For the first six ceremonies, the eligibility period spanned two calendar years.

- -

Notes:

- Use id and header attributes for tables with complicated markup (colspans, row headers, etc.). -

- - -

Interactive

- - -

Details

What payment options do you accept?

We accept cash, Visa, American Express, money orders, and personal checks.

- -

Notes:

- The details element is currently not supported by Microsoft Edge or Internet Explorer. These browsers will display the content in an opened state, as if the open attribute was applied. -

- - - -

Dialog

- - -

Notes:

- The dialog's interactivity needs to be controlled with JavaScript. -

- -

- - -

Embedded

- - -

Image

- - - -

Broken Image

- - - -

Figure with Caption

Figure Example — - An example figure caption. -

- - - -

Inline SVG

- -

- Crab by Hea Poh Lin from the Noun Project -

- - -

Notes:

- Be sure to provide values for the height and width attributes so SVGs won't expand to fill the page if styles don't load. -
- Different implementations of SVG have different approaches for being made accessible. Reference these articles by Heather Migliorisi and Carie Fisher. -
- Add whitespace around the use element in a SVG icon system to prevent a focus bug with Safari 10. -

- - - -

Picture

- - - -

Image with Srcset and Sizes

- - - -

Iframe

- - - - -

Audio

- - - -

Video

- -

Notes:

- Accessibility errors concerning the video's missing audio description should go away once the <track>'s source is linked to a valid caption file. -

- - - -

Object

- - - -

Canvas

- -

Notes:

- Add role="presentation" to <track> to mute epeated announcement of graphic role by some screen readers. -

- -

- - -

- - - - - -

- - -

- - - - - - - diff --git a/LICENSE b/LICENSE deleted file mode 100644 index b42dc48..0000000 --- a/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2021 Bryan C Guner - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/README.html b/README.html deleted file mode 100644 index b87f658..0000000 --- a/README.html +++ /dev/null @@ -1,4047 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - Document - - - - - - - - - - - - - -

- - - - -

- HOME - - - -

Prep-Work

Notes

How to learn effectively

Learning: The acquisition of skills and the ability to apply them in the future.

What makes an Effective learner?

They are active listeners.
They are engaged with the material.
They are receptive of feedback.
They are open to difficulty.

Why do active learning techniques feel difficult?

It feels difficult because you are constantly receiving feedback, and so you are constantly adapting and - perfecting the material.

Desirable Difficulty

The skills we wish to obtain is often a difficult one.
We want challenging but possible lessons based on current level of skill.

Effective learners space their practice

Consistent effort > cramming => for durable knowledge

Hello World

-
console.log : command used to print something onto the screen.
-
syntax : the exact arrangement of the symbols, characters, and keywords in our code.
// : notation for creating a code comment in JS.
-
code comment : useful for annotating pieces of code to explain how something works, - ignored by computer.
-

-
“Simplicity is prerequisite for reliability.” – Edsger W. Dijkstra
-

The Number Data Type

The number data type in JS is used to represent any numerical values, including integers and - decimal numbers.

Basic Arithmetic Operators

Operators are the symbols that perform particular operations.

+ (addition)
- (subtraction)
asterisk (multiplication)
/ (division)
% (modulo)

JS evaluates more complex expressions using the general math order of operations aka PEMDAS.

PEMDAS : Parentheses, Exponents, Multiplication, Division, Modulo, Addition, Subtraction. -
To force a specific order of operation, use the group operator ( ) around a part of the - expression.

Modulo : Very useful operation to check divisibility of numbers, check for even & odd, - whether a number is prime, and much more! (Discrete Math concept, circular problems can be solved with - modulo)

-
Whenever you have a smaller number % a larger number, the answer will just be the initial small number. -
-
-
```
console.log(7 % 10); // => 7;
```
-
-

The String Data Type

The string data type is a primitive data type that used to represent textual data.

can be wrapped by either single or double quotation marks, best to - choose one and stick with it for consistency.

If your string contains quotation marks inside, can layer single or double quotation marks to allow it to - work.

"That's a great string"; (valid)
-
-'Shakespeare wrote, "To be or not to be"'; (valid)
-
-'That's a bad string'; (invalid)

Alt. way to add other quotes within strings is to use template literals.

`This is a temp'l'ate literal ${function}` // use ${} to invoke functions within.

.length : property that can be appended to data to return the length. -
- empty strings have a length of zero.
-
-
indices : indexes of data that begin at 0, can call upon index by using the bracket - notation [ ].
-
-
```
console.log("bootcamp"[0]); // => "b"
-console.log("bootcamp"[10]); // => "undefined"
-console.log("boots"[1 * 2]); // => "o"
-console.log("boots"["boot".length - 1]); // => "t"
```
-
-
- we can pass expressions through the brackets as well since JS always evaluates expressions first.
-
The index of the last character of a string is always one less than it’s length.
-
indexOf() : method used to find the first index of a given character within a string. -
-
-
```
console.log("bagel".indexOf("b")); // => 0
-console.log("bagel".indexOf("z")); // => -1
```
-
-
- if the character inside the indexOf() search does not exist in the string, the output will be -1.
- the indexOf() search will return the first instanced index of the the char in the string.
- concatenate : word to describe joining strings together into a single string.
-

The Boolean Data Type

The boolean data type is the simplest data type since there are only two values: - true and false.

-
Logical Operators (Boolean Operators) are used to establish logic in our code. -
-
- -
  ! (not) : reverses a boolean value.
  -
  -
```
console.log(!true); // => false
-console.log(!!false); // => false
```
  -
  -
- -
  && (and) Truth Table
  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  Input Input Output
  T T T
  T F F
  F T F
  F F F
  -
- -
  || (or) Truth Table
  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  Input Input Output
  T T T
  T F T
  F T T
  F F F
  -
-
Logical Order of Operations : JS will evaluate !, then &&, then ||.
-
De Morgan’s Law : Common mistake in boolean logic is incorrectly distributing ! across - parentheses.
-
-
```
!(A || B) === !A && !B;
-!(A && B) === !A || !B;
```
-
-
- In summary, to correctly distribute ! across parentheses we must also flip the operation within.
-
-
Short-Circuit Evaluation : Because JS evalutes from left to right, expressions can - “short-circuit”. For example if we have true on the left of an || logical comparison, it will stop - evaluating and yield true instead of wasting resources on processing the rest of the statement.
-
-
```
console.log(true || !false); // => stops after it sees "true ||"
```
-
-
-

Input	Input	Output
T	T	T
T	F	F
F	T	F
F	F	F

Input	Input	Output
T	T	T
T	F	T
F	T	T
F	F	F

Comparison Operators

All comparison operators will result in a boolean output.

The relative comparators

> (greater than)
< (less than)
>= (greater than or equal to)
<= (less than or equal to)
=== (equal to)
!== (not equal to)

-
Fun Fact: “a” < “b” is considered valid JS Code because string comparisons are compared - lexicographically (meaning dictionary order), so “a” is less than “b” because it appears earlier!
-

-
If there is ever a standstill comparison of two string lexicographically (i.e. app vs apple) the - comparison will deem the shorter string lesser.
-

Difference between == and ===

=== : Strict Equality, will only return true if the two comparisons are entirely the - same.
== : Loose Equality, will return true even if the values are of a different type, due to - coercion. (Avoid using this)

Variables

Variables are used to store information to be referenced and manipulated in a program.

-
We initialize a variable by using the let keyword and a = single equals - sign (assignment operator).
-
-
```
let bootcamp = "Lambda";
-console.log(bootcamp); // "Lambda"
```
-
-
JS variable names can contain any alphanumeric characters, underscores, or dollar signs (cannot being with - a number).
-
If you do not declare a value for a variable, undefined is automatically set.
-
-
```
let bootcamp;
-console.log(bootcamp); // undefined
```
-
-
We can change the value of a previously declared variable (let, not const) by re-assigning it another - value.
-
let is the updated version of var; there are some differences in terms - of hoisting and global/block scope - will be covered later in the course (common interview question!)
-

Assignment Shorthand

let num = 0;
-num += 10; // same as num = num + 10
-num -= 2; // same as num = num - 2
-num /= 4; // same as num = num / 4
-num *= 7; // same as num = num * 7

-
In general, any nonsensical arithmetic will result in NaN ; usually operations that - include undefined.
-
declaration : process of simply introducing a variable name.
-
initialization : process of both declaring and assigning a variable on the same line. -
-

Functions

A function is a procedure of code that will run when called. Functions are used so that we do not have to - rewrite code to do the same thing over and over. (Think of them as ‘subprograms’)

Function Declaration : Process when we first initially write our function. -
- Includes three things: -
  - Name of the function.
  - A list of parameters ()
  - The code to execute {}
  -
-
Function Calls : We can call upon our function whenever and wherever* we want. (*wherever - is only after the initial declaration) -
- JS evaluates code top down, left to right.
- When we execute a declared function later on in our program we refer to this as - invoking our function.
- Every function in JS returns undefined unless otherwise specified.
- When we hit a return statement in a function we immediately exit the function and - return to where we called the function.
-
When naming functions in JS always use camelCase and name it something appropriate. > Greate code reads - like English and almost explains itself. Think: Elegant, readable, and maintainable!

Parameters and Arguments

Parameters : Comma seperated variables specified as part of a function’s declaration. -
-
Arguments : Values passed to the function when it is invoked.
-
If the number of arguments passed during a function invocation is different than the number of - paramters listed, it will still work.
-
However, is there are not enough arguments provided for parameters our function will likely yield - Nan.
-

- - - - - - - - - - - - -

- deployment -

0.) Links:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Name	Hyperlink
OKTA	- https://lambdaschoolsso.okta.com/login/login.htm?fromURI=%2Fapp%2FUserHome -
Calendar	- https://calendar.google.com/calendar/u/0/embed?src=c_2q0kvam9h9k5i6t40qp5n18dh8@group.calendar.google.com -
Slack	- https://app.slack.com/client/T4JUEB3ME/G01QG65CN75 -





Prep Work	- https://apply.lambdaschool.com/courses/web/ -

1.) Platforms we need while attending class:

2.) Web Development Software:

3.) Pre-Course Work

- - -

Prep-Work

- -

deployment

- -

0.) Links:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Name	Hyperlink
OKTA	https://lambdaschoolsso.okta.com/login/login.htm?fromURI=%2Fapp%2FUserHome -
Calendar	https://calendar.google.com/calendar/u/0/embed?src=c_2q0kvam9h9k5i6t40qp5n18dh8@group.calendar.google.com -
Slack	https://app.slack.com/client/T4JUEB3ME/G01QG65CN75 -





Prep Work	https://apply.lambdaschool.com/courses/web/ -

1.) Platforms we need while attending class:

2.) Web Development Software:

3.) Pre-Course Work

.
-├── README.html
-├── README.md
-├── SUMMARY.html
-├── SUMMARY.md
-├── codeswing.json
-├── comparison.png
-├── demo.html
-├── directory.html
-├── index.html
-├── javascript-practice
-│   ├── 00_expressions_variables
-│   │   ├── exercises
-│   │   │   ├── A_executing_code_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── B_expressions_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── C_variables_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── D_string_indexing_and_methods_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   
-│   │   ├──
-│   │   └── solutions
-│   │       ├── A_executing_code_solution
-│   │       │   ├── age.js
-│   │       │   ├── greeting.js
-│   │       │   ├──
-│   │       │   ├── thirsty.js
-│   │       │   └── whoami.js
-│   │       ├── B_expressions_solution
-│   │       │   ├── boolean-expressions.js
-│   │       │   ├── comparisons.js
-│   │       │   ├── number-expressions.js
-│   │       │   ├──
-│   │       │   └── string-expressions.js
-│   │       ├── C_variables_solution
-│   │       │   ├── four.js
-│   │       │   ├── one.js
-│   │       │   ├──
-│   │       │   ├── three.js
-│   │       │   ├── two.js
-│   │       │   └── zero.js
-│   │       ├── D_string_indexing_and_methods_solution
-│   │       │   ├── a-tedious-task.js
-│   │       │   ├── dare-to-decipher.js
-│   │       │   ├── proper-patterns.js
-│   │       │   ├──
-│   │       │   └── small-string-snippets.js
-│   │       
-│   ├── 01_conditionals
-│   │   ├── exercises
-│   │   │   ├── A_conditionals_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   
-│   │   ├──
-│   │   └── solutions
-│   │       ├── A_conditionals_solution
-│   │       │   ├── one.js
-│   │       │   ├──
-│   │       │   ├── three.js
-│   │       │   ├── two.js
-│   │       │   └── zero.js
-│   │       
-│   ├── 02_functions
-│   │   ├── exercises
-│   │   │   ├── A_functions_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── B_functions_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── C_functions_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   
-│   │   ├──
-│   │   └── solutions
-│   │       ├── A_functions_solution
-│   │       │   ├── average.js
-│   │       │   ├── ends-with-t.js
-│   │       │   ├── half.js
-│   │       │   ├── is-div-by-4.js
-│   │       │   ├── is-long.js
-│   │       │   ├── keep-it-quiet.js
-│   │       │   ├──
-│   │       │   ├── snippet-0-1.js
-│   │       │   ├── snippet-0-2.js
-│   │       │   ├── snippet-0-3.js
-│   │       │   └── snippet-0-4.js
-│   │       ├── B_functions_solution
-│   │       │   ├── ends-in-ly.js
-│   │       │   ├── funny-sound.js
-│   │       │   ├── longer.js
-│   │       │   ├── one-or-none.js
-│   │       │   ├── parity.js
-│   │       │   ├──
-│   │       │   ├── starts-with-r.js
-│   │       │   ├── string-size.js
-│   │       │   └── wacky-word.js
-│   │       ├── C_functions_solution
-│   │       │   ├── average-of-four.js
-│   │       │   ├── case-changer.js
-│   │       │   ├── contains.js
-│   │       │   ├── divisible.js
-│   │       │   ├── in-range.js
-│   │       │   ├── larger.js
-│   │       │   ├── number-change.js
-│   │       │   
-│   │       
-│   ├── 03_loops
-│   │   ├── exercises
-│   │   │   ├── A_loops_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── B_loops_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── C_loops_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   
-│   │   ├──
-│   │   └── solutions
-│   │       ├── A_loops_solution
-│   │       │   ├── count-up.js
-│   │       │   ├── evens.js
-│   │       │   ├── min-to-max.js
-│   │       │   ├── one-to-four.js
-│   │       │   ├──
-│   │       │   ├── snippet-1.js
-│   │       │   ├── snippet-2.js
-│   │       │   ├── snippet-3.js
-│   │       │   ├── snippet-4.js
-│   │       │   ├── snippet-5.js
-│   │       │   └── string-iterate.js
-│   │       ├── B_loops_solution
-│   │       │   ├── div-by-either.js
-│   │       │   ├── five-multiples-of.js
-│   │       │   ├── no-ohs.js
-│   │       │   ├── odd-sum.js
-│   │       │   ├── product-up-to.js
-│   │       │   ├──
-│   │       │   ├── string-repeater.js
-│   │       │   └── sum-up-to.js
-│   │       ├── C_loops_solution
-│   │       │   ├── censor-e.js
-│   │       │   ├── divisible-range.js
-│   │       │   ├── fizz-buzz.js
-│   │       │   ├── raise-power.js
-│   │       │   ├── remove-capitals.js
-│   │       │   ├── reverse-iterate.js
-│   │       │   
-│   │       
-│   ├── 04_arrays
-│   │   ├── exercises
-│   │   │   ├── A_arrays_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── B_arrays_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── C_arrays_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   
-│   │   ├──
-│   │   └── solutions
-│   │       ├── A_arrays_solution
-│   │       │   ├── bleep-vowels.js
-│   │       │   ├── divisors.js
-│   │       │   ├── filter-long-words.js
-│   │       │   ├── num-odds.js
-│   │       │   ├──
-│   │       │   ├── stay-positive.js
-│   │       │   ├── strings-to-lengths.js
-│   │       │   └── total.js
-│   │       ├── B_arrays_solution
-│   │       │   ├── choose-divisibles.js
-│   │       │   ├── make-acronym.js
-│   │       │   ├── maximum.js
-│   │       │   ├── reverse-array.js
-│   │       │   ├──
-│   │       │   ├── word-count.js
-│   │       │   └── your-average-function.js
-│   │       ├── C_arrays_solution
-│   │       │   ├── alternating-caps.js
-│   │       │   ├── common-elements.js
-│   │       │   ├── lengthiest-word.js
-│   │       │   ├── number-range.js
-│   │       │   ├── remove-short-words.js
-│   │       │   
-│   │       
-│   ├── 05_nesting
-│   │   ├── exercises
-│   │   │   ├── A_nested_loops_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── B_two_dimensional_arrays_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   ├── C_more_problems_exercise
-│   │   │   │   ├── README.html
-│   │   │   │   ├── README.md
-│   │   │   │   
-│   │   │   
-│   │   ├──
-│   │   └── solutions
-│   │       ├── A_nested_loops_solution
-│   │       │   ├── pair-print.js
-│   │       │   ├── print-combinations.js
-│   │       │   ├──
-│   │       │   ├── snippet-1.js
-│   │       │   ├── snippet-2.js
-│   │       │   ├── snippet-3.js
-│   │       │   ├── snippet-4.js
-│   │       │   ├── snippet-5.js
-│   │       │   └── two-sum.js
-│   │       ├── B_two_dimensional_arrays_solution
-│   │       │   ├── make-matrix.js
-│   │       │   ├── print-2d.js
-│   │       │   ├──
-│   │       │   ├── total-product.js
-│   │       │   ├── two-sum-pairs.js
-│   │       │   └── zipper.js
-│   │       ├── C_more_problems_solution
-│   │       │   ├── remove-dupes.js
-│   │       │   ├── remove-first-vowel.js
-│   │       │   ├── remove-vowels.js
-│   │       │   ├──
-│   │       │   ├── shorten-long-words.js
-│   │       │   └── spam.js
-│   │       
-│   ├── 06_decomposition_pattern
-│   │   ├── A_decomposing_problems_exercise
-│   │   │   ├── README.html
-│   │   │   ├── README.md
-│   │   │   
-│   │   ├── B_decomposing_problems_exercise
-│   │   │   ├── README.html
-│   │   │   ├── README.md
-│   │   │   
-│   │   ├── C_decomposing_problems_exercise
-│   │   │   ├── README.html
-│   │   │   ├── README.md
-│   │   │   
-│   │   
-│   ├── 07_objects
-│   │   ├── A_objects_exercise
-│   │   │   ├── README.html
-│   │   │   ├── README.md
-│   │   │   
-│   │   ├── B_objects_exercise
-│   │   │   ├── README.html
-│   │   │   ├── README.md
-│   │   │   
-│   │   ├── C_objects_exercise
-│   │   │   ├── README.html
-│   │   │   ├── README.md
-│   │   │   
-│   │   
-│   ├── 08_higher_order_functions
-│   │   ├── A_native_callback_methods_exercise
-│   │   │   ├── README.html
-│   │   │   ├── README.md
-│   │   │   
-│   │   ├── B_native_callback_methods_exercise
-│   │   │   ├── README.html
-│   │   │   ├── README.md
-│   │   │   
-│   │   
-│   
-├── js.js
-├── one-of-every-tag.html
-├── readme
-│   ├── README.html
-│   ├── README_files
-│   │   ├── katex.min.css
-│   │   
-│   
-├── resources.html
-├── resources.md
-├── script.js
-├── style.css
-└── tree.md
-
-66 directories, 241 files
-
-
-
-
-
-

WEEK 1
Introduction - to JavaScript (Part 1)

- -

Expression Learning Objectives
- Intro to Functions Learning - Objectives

Hello World -
- Getting visual feedback in your programs -
- Code comments
-
The Number Type -
- All the numbers
- The basic arithmetic operators
-
The String Type -
- Writing a valid string
- Calculating length
- Indexing a string
- Concatenation
-
The Boolean Type -
- Logical Operators
- De Morgan's Law
-
Comparison Operators -
- The relative comparators
- === vs ==
-
Basic Variables -
- Initializing a variable
- Manipulating variables
- NaN
-
Introduction to Functions -
-
Parameters and Arguments -
- The difference between Parameters and - Arguments
-

Control Flow and Array Learning - Objectives

Control Flow - Conditional Statements -
- A Quick Word on Syntax
- Writing Conditional Statements
-
Mutually Exclusive Conditions -
- When to use if statements
-
Control Flow - Looping -
- Looping
- Translating From One Loop to Another
-
The Array Type -
- Using arrays
- Indexing arrays
- Working with arrays
- Concatenation with arrays
-

Intermediate Functions Learning - Objectives

Function Expressions -
- Functions as first-class objects
-
Two-Dimensional Arrays (2D Arrays) -
-
Mutability in JavaScript -
-
Array Splice -
- Notation
- What can Array#splice do?
-
String#split and Array#join -
- String#split
- Array#join
- A clever combination
-
Determining Types -
-
The Null Type (And Undefined) -
-
Catch Me If You Can -
-

- Introduction - -

Expression Learning Objectives

- -

Below is a complete list of the terminal learning objectives for this lesson.
- When you complete this lesson, you should be able to perform each of the
- following objectives. These objectives capture how you may be evaluated on the
- assessment for this lesson.

-
Given a working REPL interface, write and execute a statement that will print
- "hello world" using console.log
-
-
Identify that strings are a list of characters defined by using double or
- single quotes
-
-
Given an arithmetic expression using +, -, *, /, %, compute its value
-
-
Given an expression, predict if its value is NaN
-
-
Construct the truth tables for &&, ||, !
-
-
Given an expression consisting of >, >=, ===, <, <=, compute it's value
-
-
Apply De Morgan's law to a boolean expression
-
-
Given an expression that utilizes operator precedence, compute its value
-
-
Given an expression, use the grouping operator to change it's evaluation
-
-
Given expressions using == and ===, compute their values
-
-
Given a code snippet using postfix ++, postfix --, +=, -=, /=, *=, predict
- the value of labeled lines
-
-
Create and assign a variable using let to a string, integer, and a
- boolean. Read its value and print to the console.l learning objectives for this lesson.
- When you complete this lesson, you should be able to perform each of the
- following objectives. These objectives capture how you may be evaluated on the
- assessment for this lesson.
-
-
Given a working REPL interface, write and execute a statement that will print
- "hello world" using console.log
-
-
Identify that strings are a list of characters defined by using double or
- single quotes
-
-
Given an arithmetic expression using +, -, *, /, %, compute its value
-
-
Given an expression, predict if its value is NaN
-
-
Construct the truth tables for &&, ||, !
-
-
Given an expression consisting of >, >=, ===, <, <=, compute it's value
-
-
Apply De Morgan's law to a boolean expression
-
-
Given an expression that utilizes operator precedence, compute its value
-
-
Given an expression, use the grouping operator to change it's evaluation
-
-
Given expressions using == and ===, compute their values
-
-
Given a code snippet using postfix ++, postfix --, +=, -=, /=, *=, predict
- the value of labeled lines
-
-
Create and assign a variable using let to a string, integer, and a
- boolean. Read its value and print to the console.
-

Intro to Functions Learning Objectives -

- -

-
Define a function using function declaration
-
-
Define a function that calculates the average of two numbers, call it,
- pass in arguments, and print it's return value
-
-
Identify the difference between parameters vs argument terminal learning objectives for this - lesson.
- When you complete this lesson, you should be able to perform each of the
- following objectives. These objectives capture how you may be evaluated on the
- assessment for this lesson.
-
-
Define a function using function declaration
-
-
Define a function that calculates the average of two numbers, call it,
- pass in arguments, and print it's return value
-
-
Identify the difference between parameters vs arguments
-

Hello World

- -

Hey Programmer! Welcome to the JavaScript module. In the next few sections,
- we'll be learning the fundamentals of the JavaScript programming language. If
- it's your first time programming, don't worry; we designed this course
- especially for you. We'll have you executing your first lines of code in no
- time!

When you finish this article, you should be able to:

use the console.log command to print out messages
use double slashes (//) to write code comments

Getting visual feedback in your - programs

- -

The first command we'll learn in JavaScript is console.log. This command is
- used to print something onto the screen. As we write our first lines of code,
- we'll be using console.log frequently as a way to visually see the output of
- our programs. Let's write our first program:

console.log("hello world");
-console.log("how are you?");
-

Executing the program above would print out the following:

hello world
-how are you?
-

Nothing too ground breaking here, but pay close attention to the exact way we
- wrote the program. In particular, notice how we lay out the periods,
- parentheses, and quotation marks. We'll also terminate lines with semicolons
- (😉.

-
Depending on how you structure your code, sometimes you'll be able to omit
- semicolons at the end of lines. For now, you'll want to include them
- just as we do.
-

Syntax

- -

We refer to the exact arrangement of the symbols, characters, and keywords as
- syntax. These details matter - your computer will only be able to
- "understand" proper JavaScript syntax. A programming language is similar to a
- spoken language. A spoken language like English has grammar rules that we should
- follow in order to be understood by fellow speakers. In the same way, a
- programming language like JavaScript has syntax rules that we ought to follow!

As you write your first lines of code in this new language, you may make many
- syntax errors. Don't get frustrated! This is normal - all new programmers go
- through this phase. Every time we recognize an error in our code, we have an
- opportunity to reinforce your understanding of correct syntax. Adopt a growth
- mindset and learn from your mistakes.

Additionally, one of the best things about programming is that we can get such
- immediate feedback from our creations. There is no penalty for making a mistake
- when programming. Write some code, run the code, read the errors, fix the
- errors, rinse and repeat!

Code comments

- -

Occasionally we'll want to leave comments or notes in our code. Commented
- lines will be ignored by our computer. This means that we can use comments to
- write plain english or temporarily avoid execution of some JavaScript lines. The
- proper syntax for writing a comment is to begin the line with double forward
- slashes (//):

// let's write another program!!!
-console.log("hello world");
-
-// console.log("how are you?");
-
-console.log("goodbye moon");
-

The program above would only print:

hello world
-goodbye moon
-

Comments are useful when annotating pieces of code to offer an explanation of
- how the code works. We'll want to strive to write straightforward code that is
- self-explanatory when possible, but we can also use comments to add additional
- clarity. The real art of programming is to write code so elegantly that it is
- easy to follow.

"Simplicity is prerequisite for reliability." — Edsger W. Dijkstra

Remember

- -

console.log can be used to print to the screen
using // at the front of a line will turn it into a comment; comments are
- ignored by JavaScript

The Number Type

- -

The Number data type in JavaScript does exactly what you expect! It is used
- to represent any numerical values, this includes integers and decimal numbers.
- As one of our first data types, we'll be interested in what operations we can
- use with numbers.

When you finish this article, you should be able to:

predict the evaluation of arithmetic expressions
explain the order of operations for JavaScript's arithmetic operators
use the grouping operator, (), to manipulate the order of operations in an
- expression

All the numbers

- -

JavaScript's Number encompasses numerical values. All of the following values are of - number type:

42;
--5;
-3.14159;
-7.0;
-

The basic arithmetic operators

- -

For any given data type, we're interested in what operations we can perform with
- that type. We use the word operator to refer to the symbol that performs a
- particular operation. For example, the + operator performs the addition
- operation. Here are the common arithmetic operators in JS:

+ (addition)
- (subtraction)
* (multiplication)
/ (division)
% (modulo)

With number values and arithmetic operators in hand, we can evaluate our first
- expressions:

console.log(2 + 3); // => 5
-console.log(42 - 42); // => 0
-console.log(-4 * 1.5); // => -6
-console.log(25 / 8); // => 3.125
-

Nothing too groundbreaking about the results above. An expression consists of
- values and operators. JavaScript will evaluate an expression into a single
- value.

We can write more complex expressions using multiple operators. However, we'll
- want to be aware of the general math order of operations. That is, we perform
- multiplication-division operations first and then addition-subtraction
- operations. To force a specific order of operation, we can use the grouping
- operator, ( ), around a part of the expression:

console.log(5 * 3 + 2); // => 17
-console.log(2 + 3 * 5); // => 17
-console.log((2 + 3) * 5); // => 25
-

The modulo operation

- -

All of the math operators listed above are the simple operations you use
- everyday, except for maybe modulo %. Modulo gives us the remainder that
- results from a division. For example, 10 % 3 is 1 because when we divide 10
- by 3, we are left with a remainder of 1. We can read 10 % 3 as "ten modulo
- three" or "ten mod three."

console.log(10 % 3); // => 1
-console.log(14 % 5); // => 4
-console.log(20 % 17); // => 3
-console.log(18 % 6); // => 0
-console.log(7 % 9); // => 7
-

Modulo is a very useful operation in the realm of computers. We can use it to
- check the divisibility of numbers, whether numbers are even, whether they are
- prime, and much, much more. Don't take this seemingly simple operation from
- granted! We'll provide a ton of practice using these modulo patterns as we move through the course.

In the order of operations, modulo has the the same precedence as
- multiplication-division. So our complete order of math operations in JS is
- parentheses, multiplication-division-modulo, addition-subtraction.

// modulo has precedence over addition
-console.log(4 + 12 % 5); // => 6
-console.log((4 + 12) % 5); // => 1
-

Remember

- -

The Number type is used to represent integer and decimal values
The operators +, -, /, * perform the normal math - operations of
- addition, subtraction, division, multiplication respectively
a % b returns the remainder when we divide a by b; we call - this
- operation modulo
JavaScript follows the usual mathematical order of operations and we can use
- the () to force precedence

The String Type

- -

This article is about one of JavaScript's primitive data types, String.
- Strings are what we'll use to represent textual data. This means that strings
- are useful in representing things like messages, names, poems, and so on. A
- string is a sequence of characters.

When you finish this article, you should be able to:

Write strings using correct syntax
Use .length to obtain a count of the numbers of characters that comprise a
- string
Index a string to refer to a single character
Concatenate strings together

Writing a valid string

- -

Strings are always wrapped by a pair of single quotation marks (') or by a
- pair of double quotation marks ("). Between the enclosing quotation marks, we
- can put any characters! Here are a six examples of strings:

"potato";
-"New York";
-"azablan@.io";
-"Follow the yellow brick road, please!";
-"365 days a year";
-"";
-

Above, notice that we are free to mix in any characters into a string. This
- includes spaces, numerics, punctuation, and other symbols. The sixth string
- above is the empty string; it contains zero characters!

You are probably wondering why we are allowed to use either single or double
- quotes when denoting a string - why is this useful? Maybe we want a string that
- contains quotation marks:

// valid strings
-'Shakespeare wrote, "To be or not to be"';
-"That's a great string";
-

// invalid string
-'That's a bad string'
-

If we want to use a single quote as a character of a string, we simply need to
- enclose the string in double quotes, and vice versa.

Calculating length

- -

Since a single string can contain any number of characters, we may find it
- useful to count the number of characters in a string using .length:

console.log("ramen".length); // => 5
-console.log("go home!".length); // => 8
-console.log("".length); // => 0
-

Indexing a string

- -

Strings consist of multiple characters. These characters are numbered by
- indices starting at 0. So in the string 'bootcamp', 'b' is at - index 0,
- 'o' is at index 1, 'o' is at index 2, 't' is at index 3, and so on. - We can
- look at particular characters of a string by using [] and specifying an index:

console.log("bootcamp"[0]); // => 'b'
-console.log("bootcamp"[1]); // => 'o'
-console.log("bootcamp"[2]); // => 'o'
-console.log("bootcamp"[3]); // => 't'
-console.log("bootcamp"[7]); // => 'p'
-console.log("bootcamp"[10]); // => undefined
-console.log("bootcamp"[-3]); // => undefined
-

In general, when we index a string using the expression string[i], we get back
- the single character at position i. Looking at the last two examples
- above, if we use an invalid index with a string, the value returned is
- undefined. This makes since because there is no character at the given
- position! It's also worth mentioning that an index should always be a number.

The classic "off by one" error

- -

Bear in mind that indices begin at 0 and not 1! Forgetting this nuance can lead
- to incorrect code for both new and experienced programmers alike. Let's hone in
- on an important distinction: the index of the last character of a string is
- always one less than it's length.

console.log("cat".length); // => 3
-console.log("cat"[3]); // => undefined
-console.log("cat"[2]); // => 't'
-

In other words, although the length of 'cat' is 3, the index of the last
- character ('t') is 2.

Using indexOf

- -

We can also calculate the index of a given character within a string by using
- indexOf:

console.log("bagel".indexOf("b")); // => 0
-console.log("bagel".indexOf("a")); // => 1
-console.log("bagel".indexOf("l")); // => 4
-console.log("bagel".indexOf("z")); // => -1
-

If we attempt to search for a character that is not present in a string,
- indexOf will return -1. This makes sense because we know that -1 is not a
- valid string index. The smallest index possible is 0!

If we search for a character that appears more than once in a string,
- indexOf will return the index of the first occurance of that character.

We can also use indexOf to search for a substring of characters. Under this
- circumstance, indexOf will return the index where the substring begins in the
- main string:

console.log("door hinge".indexOf("oor")); // => 1
-console.log("door hinge".indexOf("hi")); // => 5
-console.log("door hinge".indexOf("hint")); // => -1
-

Concatenation

- -

Concatenation is just a fancy word for joining strings together into a single
- string. To concatenate strings, we use the + operator:

console.log("hello" + "world"); // => 'helloworld'
-console.log("goodbye" + " " + "moon"); // => 'goodbye moon'
-

Remember

- -

a String is a data type that contains multiple characters enclosed in
- quotation marks
string.length returns the number of characters in the string
each character of a string is associated with a number index; the first
- character of a string is at index 0
we can use string.indexOf(char) to obtain the index of char within
- string; if char is not found, then -1 is returned
we can use + to concatenate multiple strings, combining them into a single
- string

The Boolean Type

- -

The Boolean data type is perhaps the simplest type since there are only two
- possible values, true and false. However, we'll find booleans very useful
- because they will act as components of later concepts. As programmers, we'll use
- booleans to describe the validity of statements. In an abstract sense, "Today
- is Monday" and "one plus one equals ten" are examples of statements with
- boolean values. That is, they are either true or false.

When you finish this article, you should be able to:

predict the evaluation of expressions that use the boolean operations of !,
- ||, and &&
explain DeMorgan's law

Logical Operators

- -

In the long run, we'll be using booleans to establish logic in our code. For
- this reason, the boolean operators can also be referred to as the logical
- operators. There are only three such operators:

! (not)
&& (and)
|| (or)

Logical NOT

- -

The not (!) operator will reverse a boolean value:

console.log(!true); // => false
-console.log(!false); // => true
-console.log(!!false); // => false
-

It's worth mentioning that ! is a unary operator. This means that the not
- operation is applied to a single value. This is in contrast to a binary operator
- such as multiplication, which is applied between two values. It does not make
- sense to ! two values together.

Logical AND

- -

The and (&&) operator will take two boolean values and will only evaluate to
- true when both input values are true. Otherwise, it will return - false:

console.log(false && false); // => false
-console.log(false && true); // => false
-console.log(true && false); // => false
-console.log(true && true); // => true
-

Logical OR

- -

The or (||) operator will take two boolean values and will only evaluate to
- false when both input values are false. Otherwise, it will return - true:

console.log(false || false); // => false
-console.log(false || true); // => true
-console.log(true || false); // => true
-console.log(true || true); // => true
-

Logical order of operations

- -

We can write boolean expressions that consist of multiple logical operations, but we should be aware of - the order of operations. JavaScript will evaluate ! then && then - ||.

console.log(true || true && false);    // => true
-console.log(false && !(false || true)); // => false
-

In general, A || B && C is equivalent to A || (B && C) where - A, B, C are booleans.

De Morgan's Law

- -

A common mistake in boolean logic is to incorrectly distribute ! across parentheses. Say we - had boolean values of A, B. Here is something to remember:

!(A || B) is equivalent to !A && !B
!(A && B) is equivalent to !A || !B

In other words, to correctly distribute ! across parentheses, we must also flip the - operation within parentheses. Beware that:

!(A || B) is not equivalent to !A || !B
!(A && B) is not equivalent to !A && !B

We call this property De Morgan's Law. Shout out to Augustus De Morgan of Great Britain. -

Remember

- -

!, &&, || are the boolean operators that we can use to - establish logic in our code
De Morgan's Law should be used to distribute ! against parentheses

These are just the basics of the type. We'll be seeing more booleans in the upcoming section, so stay - tuned for that!

Comparison Operators

- -

In our previous introduction to the boolean data type, we described booleans as
- way to represent the validity of an expression. We'll continue this conversation
- by exploring comparison operators. As you learn about these operators, bear
- in mind that all comparisons will result in a boolean, true or false.

When you finish this article, you should be able to:

Predict the result of expressions that utilize the operators >, <, - >=
- <=, ===, and !==
Explain the difference between the equality operators == and ===

The relative comparators

- -

> (greater than)
< (less than)
>= (greater than or equal to)
<= (less than or equal to)
=== (equal to)
!== (not equal to)

Using these operators is pretty straightforward. Here are a few examples:

console.log(10 > 5); // => true
-console.log(10 < 5); // => false
-console.log(1 < 7); // => true
-console.log(7 <= 7); // => true
-console.log(5 === 6); // => false
-console.log(5 !== 6); // => true
-console.log("a" !== "A"); // => true
-console.log(false === false); // => true
-

Notice that a comparison expression always evaluate to a boolean value (true
- or false). Comparison operators like === are a useful to compare strings,
- booleans, etc. not just numbers.

Did you know? 'a' < 'b' is valid JS code? When you relatively - compare
- strings using > or < you will be comparing them lexicographically.
- Lexicographically is fancy shmancy talk for "dictionary" order! A "lesser"
- string is one that would appear earlier in the dictionary:

console.log("a" < "b"); // => true
-console.log("apple" < "abacus"); // => false
-console.log("app" < "apple"); // => true
-console.log("zoo" > "mississippi"); // => true
-

Gotcha capitilized letters are considered lexicographically less than
- lower case letters. i.e "A" < "z" // => true.

=== vs ==

- -

In JavaScript there are two equality operators triple-equals (===) and
- double-equals (==). The operators differ in how they compare across differing
- types. Triple-equals performs the strict equality, meaning it will only return
- true if the types are the same. Double-equals performs the loose equality,
- meaning it can return true even if the values are of different type.
- Double-equals may coerce a value into another type for the comparison, and
- this behavior is hard to predict:

console.log(5 === "5"); // false
-console.log(5 == "5"); // true
-console.log(0 === false); // false
-console.log(0 == false); //true
-

Whoa! Surprised by these results? It can be hard to predict how == behaves, so
- we will avoid using it in this course and as a best practice. Stick to using
- === because it respects data types.

Remember

- -

>, <, >=,<=, ===, and - !== can be used to compare values
we prefer to use === to check for equality because it takes the type into
- account.

Basic Variables

- -

Variables are used to store information to be referenced and manipulated in a
- computer program. They also provide a way of labeling data with a descriptive
- name, so our programs can be understood more clearly by programmers. It is
- helpful to think of variables as containers that hold information. Their sole
- purpose is to label and store data in computer memory. This data can then be
- used and even changed throughout the lifetime of your program.

When you finish this reading, you should be able to:

declare variables using the let keyword
assign values to variables using the assignment operator (=)
use the shortcuts +=, -=, ++, -- to reassign - variables
identify undefined as the default value for unassigned variables

Initializing a variable

- -

To initialize a variable in JavaScript we'll need two new pieces of syntax:
- let and =. We can give the variable any name that we wish and assign it a
- value. Once we initialize a variable, the variable will evaluate to the value
- assigned:

let bootcamp = "";
-console.log(bootcamp); // ''
-
-let birthYear = 2012;
-console.log(birthYear); // 2012
-

Did you know? JavaScript variables names can contain any alphanumeric
- characters, underscore (_), or dollar sign ($). However, they cannot begin
- with a number.

Above are examples of how you'll create variables most of the time, so we'll
- grow very familiar with the syntax. As a best practice, we should name our
- variables in a way that is descriptive and concise.

The variable initializations above really consist of two steps: declaration
- with let and assignment with =. Let's break these two steps down.

Declaring a variable

- -

In JavaScript, in order to use a variable, we must declare it. Variable
- declaration is the act of introducing the variable to the environment.

To declare a variable, use the let keyword, followed by a space and then the
- name of the variable.

let bootcamp;
-console.log(bootcamp); // undefined
-

Once a variable is declared, it will contain undefined as it's value.
- undefined is a common default value in JavaScript, we'll see it come up in a
- few different places. You can think of undefined as showing that the variable
- is empty.

Assigning a variable

- -

Once a variable has been declared, we can assign it a value using single-equals
- = :

let bootcamp;
-console.log(bootcamp); // undefined
-bootcamp = "";
-console.log(bootcamp); // ''
-

Manipulating variables

- -

To change the value of a variable, we need to reassign it to a new value with
- = :

let num = 42;
-console.log(num + 8); // => 50
-console.log(num); // => 42
-
-num = num + 10;
-console.log(num); // => 52
-

In the code above, num + 8 will evaluate to 50, but it will not change the - num
- variable to 50. If we want to change the num variable, we must reassign to
- it.

Assignment Shorthand

- -

Changing the value of a number variable is something fairly common in the
- programming world. Luckily there is some shorthand operators we can use:

let number = 0;
-number += 10; // equivalent to number = number + 10
-number -= 2; // equivalent to number = number - 2
-number /= 4; // equivalent to number = number / 4
-number *= 7; // equivalent to number = number * 7
-console.log(number); // 14
-

We also have other shorthand to add or subtract exactly 1 from a variable, the
- increment (++) and decrement (--) operators:

let year = 3004;
-year++;
-console.log(year); // 3005
-year--;
-console.log(year); // 3004
-

NaN

- -

Now that we have the ability to perform arithmetic with variables, let's take a
- look at a common programming mistake, getting a result of NaN (not a number):

let num;
-console.log(num + 3); // NaN
-

The above code gives NaN because the unassigned num variable contains
- undefined; adding 3 to undefined results in NaN. In - general, any
- nonsensical arithmetic will result in NaN. Math operations involving
- undefined is perhaps the most common mistake:

console.log(undefined + 3); // NaN
-console.log("fish" * 2); // NaN
-

Remember

- -

variables are declared with let and will contain the value undefined by
- default
we can use single-equals = to assign variables
changing a variable requires a reassignment, for which there are many
- shortcuts for (+=, -=, etc.)

Introduction to Functions

- -

We hope you are ready - because you are on the brink of one of the most fun
- parts of writing JavaScript: writing functions. A function is a procedure of
- code that will run when called. We only "write" a function once (function
- declaration), but we can "use" it as many times as we please (function
- calls). Functions are the fundamental building blocks of JavaScript and
- mastering them is a big step on the road to JavaScript mastery.

When you finish this reading, you should be able to:

Describe what a function in JavaScript is.
Demonstrate how to invoke a function.
Write a function using function declaration.
Use the return keyword to return a value from a function.

Writing Functions

- -

A function is a set procedure of code that will run when called. Functions
- really start to make sense when put in the perspective of solving problems. So
- for example say you want to find the average of two given numbers. Meaning we
- want to take two numbers, add them together then divide by 2:

> (5 + 5) / 2
-5
-
-> (15 + 3) / 2
-9
-
-> (7 + 2) / 2
-4.5
-

Writing out the same code again and again gets tedious fast. What you can do
- instead is write a new function.

Function Declaration

- -

A function definition consists of the function keyword, followed by three
- things:

The name of the function.
A list of parameters to the function, enclosed in parentheses, ().
The code to be run when this function is run, enclosed in curly
- brackets,{ }.

So for our above example of averaging two numbers we could write a function that
- would do that for us! We would write something like the following:

// 1. average is the name of the function
-// 2. number1 & number2 are the parameters being passed in
-function average(number1, number2) {
-  // 3. this is the code run every time this function is used
-  return (number1 + number2) / 2;
-}
-

First thing to notice for the above average function is that we didn't use any
- real numbers. You always want to write functions to accept as wide a range of
- data as possible. Utilizing the incoming parameters to a function is one of
- the keys to making functions flexible.

In the case of the average function, we want to use it to calculate the
- average of any two numbers. number1 and number2 are the parameters for - the
- average function. In other words, the average function expects to be given
- two numbers, number1 and number2. We'll be talking a lot more about
- parameters later - but for now know that when you define a function with
- parameters you are declaring those parameters as usable variables within that
- function.

The beauty of a function is that if we define it in a clever way, it will work
- on a whole slew of data! For example, we want average to work on any two
- numbers, whether or not they are whole numbers, decimal, negative, etc.

Invoking or "calling" a function

- -

Now that we've written a function how do we actually use it? Once defined a
- function can be invoked or "called" as many times as we please.

Order of code

- -

Let's step away from average for a bit to see how a simple function call
- works. Say we run JavaScript code that looks like this:

console.log("First!");
-
-console.log("Second!");
-

Running this code will return exactly as we expect. We will see First! printed
- out, followed by Second!. In other words, JavaScript will evaluate your code
- left-to-right and top-to-bottom. Very intuitive! It's exactly how you are
- reading these notes right now.

However, when JavaScript sees a function definition, JavaScript will not
- evaluate the code inside of the definition. It will only "remember" the code so
- we can execute it later. The code below only prints First! followed by
- Fourth!:

console.log("First!");
-
-function callMe() {
-  console.log("Second!");
-  console.log("Third!");
-}
-
-console.log("Fourth");
-
-// when run this code is ran it will print out:
-// "First!"
-// "Fourth"
-

To actually get the code within callMe to evaluate, we must call it by using
- callMe(). The code below will now print out in order:

function callMe() {
-  console.log("Second!");
-  console.log("Third!");
-}
-
-console.log("First!");
-// we call the function by adding ending parenthesis
-callMe();
-console.log("Fourth!");
-
-// when run this code is ran it will print out:
-// "First!"
-// "Second!"
-// "Third!"
-// "Fourth"
-

Let's say JavaScript is running the file above. Here are the steps it would
- take, starting from the tippy top of the code:

JS sees a definition for callMe. It will remember this definition in case
- we call the function later. It will not evaluate the code inside the
- function yet.
JS prints out First!
JS sees that we are calling callMe(). At this point it will look at the
- prior callMe definition and run the code inside. It is as if we are
- "jumping" to inside the function definition. This means it will print
- Second! followed by Third!
JS sees there is no more code to be run inside of callMe, so it "jumps"
- back to where we originally called callMe()
JS will continue evaluating in order and print Fourth!

An average example

- -

So a declared function is "saved for later use", and will be executed later,
- when it is called, also known as being invoked. So thinking back to our
- average function we can declare the function and then invoke it.

When we specify what data to use for a function call, we refer to that process
- passing arguments to the function.

// this is a function definition
-function average(number1, number2) {
-  return (number1 + number2) / 2;
-}
-
-// this is a function call with the arguments being 15 & 3
-> average(15, 3)
-9
-
-// this is a function call with the arguments being 5 & 5
-> average(10, 5)
-7.5
-

When we call the function average(15, 3), we run the code inside the
- definition for average. That is, we plug in the parameters with real numbers
- (number1 becomes 10 and number2 becomes 16). Think of - number1 and
- number2 as variables that contain the values we pass in when we called the
- function. Then we proceed by running the code inside the function. The parameter
- names number1 and number2 used through the body of the function and behave
- like variables.

Returning a value

- -

Now that we know how functions are declared and invoked let's talk about the
- inside of the function. We'll start with a statement: Every function in
- JavaScript returns undefined unless otherwise specified.

Now what does that mean? We'll start with a simple example:

function sayNumber(number) {
-  console.log(number);
-}
-
-> sayNumber(1); // prints 1
-1
-undefined
-

So what happened there? Let's do a quick step by step:

We declared the sayNumber function
sayNumber was called handing in the argument of 1
The number parameter is printed to the console
Then the function ends without encountering a return statement. Since
- nothing was specifically returned then the function returned the default
- value for a function which is undefined.

Now let's change our above example to use the keyword return to return a
- value:

function sayNumber(number) {
-  console.log(number);
-  return true;
-}
-
-> sayNumber(1);
-1 // sayNumber still prints 1
-true // but now sayNumber returns as true
-

Let's go back to our previous average function and talk about the return we
- used there:

function average(number1, number2) {
-  return (number1 + number2) / 2;
-}
-
-// the function call for average(10, 16) will return 13
-// so the result variable will be set to 13
-let result = average(10, 16);
-
-// if we want to check what a function returns we can do this:
-console.log(result); // prints `13`
-
-// we could alternatively do this:
-console.log(average(10, 16));
-

When we call a function, we jump to the function definition and run the code
- inside. When we hit a return statement, we immediately exit the - function,
- jump back to where we called the function, and evaluate the function call to
- the value it returned.

Every function call evaluates to it's return value! In other words, the
- expression average(10, 16) evaluates to 13 just like how the expression
- 1 + 1 evaluates to 2.

Another important rule of the return statement is that it stops function
- execution immediately. This means that any code after a return will not be
- executed!

function average(number1, number2) {
-  let sum = number1 + number2;
-  return sum;
-  // anything under the first return will not be executed
-  console.log("this will not run")
-  return false;
-}
-
- // when the first return is encountered the entire function will return a value
-> average(2, 7);
-9
-

So the three things to remember about return statements is:

Every function call evaluates to it's return value.
Every function in JavaScript returns undefined unless a return is
- specified
Once a return statement is encountered the function will immediately stop
- and return the value, ignoring any code below the return statement.

The importance of naming

- -

A quick but very important side note about good naming. Take this to heart right
- now: Good names are important. Do yourself, and every other programmer
- reading your code, a favor by always using significant function and variable
- names.

For example, x is a very non-descriptive name for a variable or function. As
- we tackle more complicated problems and our code grows to be more complex, we
- are likely to forget what badly named variables originally stood for and what
- their purpose was. Non-descriptive names make our code error-prone. Great code
- reads like English and almost explains itself. As programmers, our goal is to
- write code that is not only "correct", but also elegant, readable, and
- maintainable! Hold yourself to this high standard.

As far as syntax goes in JavaScript we always name our functions and variables
- camelCase for multiple words. (Ex: tipCalculator, - currentNumber,
- puppyPartyFinder). Other languages use other conventions so it's best to pick
- up the standard for your chosen language and stick with it.

Review

- -

By writing a function we can reuse code over and over again to solve similar
- problems with different input data (arguments). This will make your life easier
- and allow you to start working on more complex problems.

This reading covered:

How to define and invoke a function in JavaScript.
How to use the return keyword to return a value from a function.
Writing readable JavaScript code by using significant names and following
- camelCase conventions for multiple word variables and functions

Parameters and Arguments

- -

When talking about functions one of the first things we mentioned was the word
- parameters. In this reading we will be covering what exactly a parameter is -
- as well as the differentiation between parameters and arguments.

When you finish this reading, you should be able to:

Identify the difference between parameters and arguments.
Write a function that utilizes declared parameters.
Invoking a function with passed in arguments.

The difference between - Parameters and Arguments

- -

Let's start off by talking about the difference between arguments and
- parameters and how to identify which is which.

Parameters are comma separated variables specified as part of a
- function's declaration.
Arguments are values passed to the function when it is invoked.

So by defining parameters when we declare our function we are effectively
- setting accessible variables within the function:

function add(firstParameter, secondParameter) {
-  console.log(firstParameter + secondParameter);
-}
-
-// the add function declares two parameters
-> add(1, 2); //=> 3
-

In the above example we declared our parameters when we declared our function.
- Now arguments work slightly differently - when the function is invoked we are
- passing in arguments. So in the above example when we invoked add(1, 2) the
- (1,2) were the arguments being passed in. So when a function is invoked the
- value of the declared parameters is assigned to the passed in arguments.

You can think of it parameters and arguments like a recipe. A recipe is a
- list of ingredients (parameters) and list of steps (the code to be run). When
- someone cooks the recipe (invokes the function) they add the ingredients they
- actually have(arguments). The result of cooking the recipe is the delicious
- return value!

Extra arguments

- -

In JavaScript a function will not throw an error if the number of arguments
- passed during a function invocation is different than the number of parameters
- listed during function declaration. This is very important to know!

Let's use the above function to demonstrate:

function add(firstParameter, secondParameter) {
-  console.log(firstParameter + secondParameter);
-}
-
-// this will ignore the 17 & 14
-// the first two arguments passed in will be assigned to the first two parameters
-> add(1, 2, 17, 14); //=> 3
-

Notice in the above example we passed in 4 arguments (1, 2, 17, 14) to add.
- Since the function was only looking for two parameters that is all it uses.

Not enough arguments

- -

Now what happens if we pass in less arguments then needed?

function add(firstParameter, secondParameter) {
-  console.log(firstParameter + secondParameter);
-}
-
-> add(5); //=> NaN
-

Whoa what happened there? Let's do a play-by-play:

firstParameter was set to equal the first passed in argument which in the
- above case is 5.
Since there is no second argument then secondParameter is declared as a
- variable but is set to the default value of undefined.
The function then tries to add 5 to undefined which is definitely not a
- number! So we get NaN (which means Not A Number) printed to the console.

As you write more functions you'll grow very comfortable using both arguments
- and parameters to accomplish your function's goal.

Review

- -

Parameters are variables defined as a part of a function's declaration.
Arguments are values passed to the function when it is invoked.
JavaScript functions can intake a different number of arguments than the
- number of parameters listed during function declaration.

- - -

Control Flow and Array Learning - Objectives

- -

-
Define a function that accepts a sentence string and two words as args. The
- function should return a boolean indicating if the sentence includes either
- word.
-
-
Identify a pair of mutually exclusive conditions
-
-
Given a for loop, translate it into a while loop, and vice-versa
-
-
Write a function that iterates through a provided string argument
-
-
Given a description of pig latin, write a function that takes in a string
- argument and utilizes String#slice to translate the string into pig latin.
-
-
Write a function that takes in an array of words and a string as arguments
- and returns a boolean indicating whether the string is located inside of the
- array. The function must use Array#indexOf.
-
-
Define that an array literal is an ordered list of values defined by using
- bracket and individual values are read by indexing.
-
-
Prevent code that can throw an exception from causing the program to crash. the terminal learning - objectives for this lesson.
- When you complete this lesson, you should be able to perform each of the
- following objectives. These objectives capture how you may be evaluated on the
- assessment for this lesson.
-
-
Define a function that accepts a sentence string and two words as args. The
- function should return a boolean indicating if the sentence includes either
- word.
-
-
Identify a pair of mutually exclusive conditions
-
-
Given a for loop, translate it into a while loop, and vice-versa
-
-
Write a function that iterates through a provided string argument
-
-
Given a description of pig latin, write a function that takes in a string
- argument and utilizes String#slice to translate the string into pig latin.
-
-
Write a function that takes in an array of words and a string as arguments
- and returns a boolean indicating whether the string is located inside of the
- array. The function must use Array#indexOf.
-
-
Define that an array literal is an ordered list of values defined by using
- bracket and individual values are read by indexing.
-
-
Prevent code that can throw an exception from causing the program to crash.
-

Control Flow - Conditional Statements

- -

So far the code you've written has been pretty direct in it's intent. You can
- define functions and variables but, so far the functions you've created haven't
- been able to do that much for you yet. It's time to start writing functions
- that can do things conditionally by utilizing control flow.

In simple terms - control flow is the order in which instructions are
- executed within a program. One modifies control flow using control structures,
- expressions that alter the control flow based on given parameters. The control
- structures within JavaScript allow the program flow to change within a unit of
- code or a function.

This reading will be covering one of the two main control structures you
- will use time and time again - Conditional statements. Conditional
- statements are used to perform different actions based on different conditions.

When you finish this reading, you should be able to:

Write if, else if, if...else conditional statements.
Know that conditional statements can have only one if and one else
- statement.
Identify that conditional statements can be nested.

A Quick Word on Syntax

- -

Before we get started we'll quickly go over the terms we'll be using to
- represent syntax.

[ ] are square brackets
{ } are curly braces
( ) are parentheses

Writing Conditional Statements

- -

Conditional Statements are the second fundamental control structure for
- writing JavaScript and are pretty straight forward. The simplest conditional
- statement is the if statement. An if statement has two parts, the test
- expression (the code that immediately follows the if which goes in
- parentheses), and the then expression (this code belongs in braces after the
- if expression). The then expression will only run when the if - expression
- is truthy.

Here is an example of a simple if statement:

// this is the test expression
-if (3 === 3) {
-  // this is the then expression
-  // this code will run if the above statement is true
-  console.log("this is a three!");
-}
-

The if statement above allows you to specify what should happen if your
- particular expression evaluates to true. You can chain additional test
- expressions onto this if statement by using a else if statement.

The syntax for else if is very similar as an if statement:

function mathFun() {
-  let x = 2 + 3;
-
-  if (x === 3) {
-    console.log("we have a 3");
-  } else if (x === 4) {
-    // this code will run if the above statement is true
-    console.log("we have a 4");
-  } else if (x === 5) {
-    // this code will run if the above statement is true
-    console.log("we have a 5");
-  }
-};
-
-mathFun(); // => "we have a 5"
-

The else if and if statements do not, however, provide the option to - specify
- something else that should happen in the event that all of the above expressions
- evaluate to be falsey. The if...else statement reads just like English. The
- JS interpreter will execute the else statement if all the above conditions
- given are falsey. See below for an example:

function mathFun() {
-  let x = 19;
-  if (x === 3) {
-    console.log("we have a 3");
-  } else if (x === 4) {
-    console.log("we have a 4");
-  } else {
-    console.log("I will return if everything above me is falsey!");
-  }
-};
-
-mathFun(); // => "I will return if everything above me is falsey!"
-

You can chain an arbitrary number of else if statements but there can only be
- one if statement and one optional else statement. The if introduces - the control
- structure and the else acts as a fail safe to catch everything that didn't
- meet the above conditions.

Only one then expression is ever executed in an if, if...else, or
- if...else statement. If one of the test expressions is truthy, then the
- result of its then expression is the result of the entire conditional
- statement:

let x = 3;
-if (x === 3) {
-  console.log("this will run");
-} else {
-  console.log("this will not run");
-}
-

Additionally, you can nest conditional statements within each other but it will
- get hard to read pretty quickly and is discouraged:

function mathFun(x) {
-  if (x === "math") {
-    if (x === "math" && x[0] === "m") {
-      if (x[1] === "a") {
-        console.log("this got confusing fast");
-      } else {
-        console.log("that is not math!");
-      }
-    } else {
-      console.log("that is for sure not math!");
-    }
-  } else {
-    console.log("I will return if everything above me is false!");
-  }
-};
-
-mathFun("math"); // => "this got confusing fast"
-

Review

- -

Conditional statements allow us to control what actions should be taken based
- on a boolean (truthy or falsey) expression
In a chain of then expressions (if...else if...else), only one of the
- then expressions will be executed.
Conditional statements can have only one if and one else statement.
Conditional statements can be nested.

Mutually Exclusive Conditions

- -

You have now learned how to write conditional statements. Now we'll talk a
- little bit more about how to write them using best practices.

When you finish this reading, you should be able to:

Identify a pair of mutually exclusive conditions.

When to use if statements

- -

Say you are given the challenge to write a function that that will call another
- function named bigNumber if the given argument is greater than 100 or - call
- a function named smallNumber if it the given argument is smaller. You could
- write a function to do that which would look like this:

function numberSeparator(number) {
-  if (number < 100) {
-    // number is smaller than 100 so we invoke smallNumber
-    smallNumber();
-  }
-  if (number === 100) {
-    // number is equal to 100 so we invoke smallNumber
-    smallNumber();
-  }
-  if (number > 100) {
-    // number is larger than 100 so we invoke bigNumber
-    bigNumber();
-  }
-}
-

As you can probably tell the above function uses a lot of code to do a simple
- task. To be clear the function above would work for our aim - but it repeats
- itself. There is an age old principal for writing good code named DRY or
- Don't repeat yourself. As good programmers we always want our code to be
- clear, concise, and efficient.

A general rule of thumb is that if you are working with a condition that is
- mutually exclusive, meaning if one condition is true the other condition
- must be false, then you should use an if/else statement. You can also think of
- mutually exclusivity like a coin flip - it can be either heads or tails but
- not both.

Going back to the original problem at hand we can see it makes intuitive sense
- with the way the challenge is phrased: If the number is larger than 100 then
- we'll call bigNumber, otherwise we invoke is smallNumber.

So let's rewrite the above function to read a little more clearly:

function numberSeparator(number) {
-  if (number > 100) {
-    bigNumber();
-  } else {
-    smallNumber();
-  }
-}
-
-// this also works
-function numberSeparator(number) {
-  if (number <= 100) {
-    smallNumber();
-  } else {
-    bigNumber();
-  }
-}
-

Look at how much clearer that is! Writing good code is an art - devote yourself
- to becoming an artist!

Review

- -

How to identify a pair of mutually exclusive conditions.
DRY - don't repeat yourself!

Control Flow - Looping

- -

A quick reminder before we start - control flow is the order in which
- instructions are executed within a program. One modifies control flow using
- control structures, expressions that alter the control flow based on given
- parameters. This reading will be covering the second of the main control
- structures you will use time and time again - loops.

When you finish this reading, you should be able to:

Know how to write a while loop and a for loop. -
- Know how to convert a for loop into a while loop
-
Know that index variables conventionally start at zero.
Explain what an iteration is.

Looping

- -

Imagine you are at a friend's house and your friend has six dogs. Someone left
- the back gate open and all the dogs go out in the yard and get super muddy. Now
- your friend wants to clean their dogs but they only have one bathtub! You can't
- wash all the dogs at once. So the only option is to give the dogs a bath one at
- a time until they are all clean. When you start 0 dogs are clean and 6 dogs are
- dirty.

While there are still dirty dogs you still have a job to do. That is your
- condition - you will stop giving baths once all 6 dogs are clean. So after
- one bath you you have 1 clean dog and 5 dirty dogs. You've
- incremented(increased by one) your number of clean dogs. After each bath you
- check your condition again until you have 6 clean dogs so you know you can
- stop!

What we've described above is the idea of looping - setting a condition,
- executing an action, doing something to make sure our condition will be met
- eventually, and rechecking our condition before executing our next action.

Loops are a fundamental control structure for writing JavaScript.
- Loops will repeatedly execute a section of code while a condition is true. Loops
- are simple to write and incredibly powerful! There are many variations of loop
- but we will be covering the two most fundamental loops now - while loops and
- for loops.

While Loops

- -

One of the simplest loops in JavaScript is the while loop. As with all
- loops, the while loop will execute a block of code as long as a specified
- condition is true. The while loop starts with the keyword while then states a
- condition in parentheses. The code in the following braces will be run until the
- above condition is met.

while (condition) {
-  // code block to be executed
-}
-

In the following example, the code in the loop will run, over and over again, as
- long as a variable (index) is less than 10:

let index = 0;
-
-// this is the condition that will be checked every time this loop is run
-while (index < 10) {
-  console.log("The number is " + index);
-  // this is common shorthand for index = index + 1
-  index++;
-}
-

The most important thing to remember when writing any loop is to always be
- working towards your condition. In the example above if we did not increment the
- index variable by 1 each time the loop ran then we would be stuck with what we
- call an infinite loop:

let index = 0;
-
-// this is an infinite loop because our condition will never be met
-while (index < 10) {
-  console.log("The number is " + index);
-  // if we do not increase the index then our condition is never met
-  // Meaning this will run forever!
-}
-

The above code will run until whatever interpreter you are using crashes.

Important Loop Knowledge

- -

A quick word before we learn about the next loop.

The index is the traditional word for the variable that keeps track of how
- many times the loop has been run. Don't write loops with indices starting at
- one; you'll confuse other programmers and yourself. Indices have started at zero
- for a long time, and for good reason. It's much easier to use loops that start
- with an index of zero because Array and String indices also start at zero.

let array = [0, 1, 2];
-let index = 0;
-
-while (index < array.length) {
-  console.log(
-    "Both the index and the current array position are " + array[index]
-  );
-  index++;
-}
-

In the above code we will do one loop for each digit in the Array above. We call
- each of those loops an "iteration". An iteration is the act of repeating a
- procedure, hence looping is an iterative technique. Each repetition itself
- is also called an "iteration." So you can use loops to iterate through Arrays
- and Strings.

For Loops

- -

A for loop can be broken down into three sections:

The initial expression which will be run once at the beginning of the loop.
The condition which is checked every time the loop is run. If this
- condition is true the loop will run again. If this condition is false the
- loop will end.
The loopEnd expression which will be run at the end of the loop before
- checking the condition again.

for (<initial expression>;<condition>;<loopEnd expression>)
-

The for loop is usually used with an integer counter:

for (let index = 0; index < 10; index += 1) {
-  // the code inside this block will run 10 times
-}
-

While the loopEnd expression is normally used to increase a variable by one
- per loop iteration, it can contain any statement, such as one that decreasing
- the counter, or increasing it by 2.

You can use the for loop to iterate through all kinds of things. Check out the
- example below for how to iterate through a String:

let testString = "testing";
-
-// we can use the testString's length as our condition!
-// Since we know the testString's index starts at 0
-// and our index starts at 0 we can access each letter:
-for (let index = 0; index < testString.length; index += 1) {
-  let letter = testString[index];
-  console.log(letter);
-}
-

These are the most basic types of loops. If all else fails, you can always fall
- back on these two loops. All the other loop forms are just more convenient forms
- of these basic loop styles.

Translating From One Loop to Another

- -

So far we have covered both while and for loops. Once you understand the
- concept of looping it's easy to translate one loop to another:

// these two do the exact same thing!
-function forLoopDoubler (array) {
-  // it is convention to shorten index to just i in most cases
-  for (let i = 0; i < array.length; i++) {
-    array[i] = array[i] * 2;
-  }
-  return array;
-};
-
-function forLoopDoubler (array) {
-  let i = 0;
-  while (i < array.length) {
-    array[i] = array[i] * 2;
-    i++;
-  }
-  return array;
-};
-
-forLoopDoubler([1, 2, 3]); // => [2,4,6]
-whileLoopDoubler([1, 2, 3]); //=> [2,4,6]
-

Review

- -

We can use a for or while loop to repeat a block of code repeatedly.
While the loop condition is true, we will execute another iteration of the
- loop.
When the loop condition is false, we will exit the loop.

The Array Type

- -

This reading will be about one of JavaScript's global objects, the Array
- type. JavaScript arrays are used to store multiple values all within a single
- structure, much like a creating a list. Arrays can hold strings, integers and
- even other arrays! Arrays are incredibly useful for holding a bunch of different
- information all in one place.

When you finish this reading, you should be able to:

Write arrays using correct syntax
Identify that an array is an ordered list of values defined by using brackets
Use .length to obtain a count of the numbers of elements that comprise an
- array
Index an array to refer to a single value
Concatenate multiple arrays together

Using arrays

- -

While coding you will find that you often find yourself needing to refer to a
- bunch of data at once. For instance, what if you wanted to refer to the entire
- English alphabet. Sure, you could create a bunch variables for each letter in
- the alphabet:

let a = "a";
-let b = "b";
-let c = "c";
-let d = "d";
-// and so on for way too long...
-

However this becomes cumbersome and unmanageable quickly. An Array is a data
- structure that solves this problem. Arrays are always wrapped in square
- brackets, [], and store their comma separated values in sequential order.
- Arrays in JavaScript are also very flexible: we can put elements into an array,
- replace elements in an array, and remove elements from the array.

So going back to our first example of containing the alphabet:

let alphabet = [
-  "a", "b", "c", "d", "e", "f",
-  "g", "h", "i", "j", "k", "l",
-  "m", "n", "o", "p", "q", "r",
-  "s", "t", "u", "v", "w", "x",
-  "y", "z"
-];
-

Indexing arrays

- -

Calculating the length of an array

- -

Since an array can container any number of values you will find it useful to
- count the number of values available to you using .length:

console.log([4, 7, 9].length); // => 3
-console.log([1, 2].length); // => 2
-console.log([].length); // => 0
-

Properly indexing an array

- -

Arrays consist of multiple values all stored in sequential order. These value
- are numbered by indices starting at 0 (just like indexing a string!). So
- given the below example:

let numbersAndLetters = ["b", "z", 17, "cat"];
-

In the above numbersAndLetters array if we access numbersAndLetters at the
- index of 0 we get back the value of "b". If we access numbersAndLetters at the
- index of 1 we get "z", at the index of 3 we get 17, etc. We can specify which
- value we'd like to access in an array by using square brackets,[], and
- specifying an index:

console.log(numbersAndLetters[0]); // => "b"
-console.log(numbersAndLetters[1]); // => "z"
-console.log(numbersAndLetters[2]); // => 17
-console.log(numbersAndLetters[3]); // => "cat"
-

Notice that even though the index at numbersAndLetters[3] has the value of a
- string with multiple characters ("cat") we return the entire value listed at
- that index.

Reminder: Arrays always start at the index of 0, not 1. This is the
- convention in programming. Additionally, indices should always be a number.

We can access a value in an array directly by providing an index for the value
- we'd like to access in that array (array[index]). See below for an example:

console.log(["a", "b", "c"][0]); // => "a"
-console.log(["a", "b", "c"][1]); // => "b"
-console.log(["a", "b", "c"][2]); // => "c"
-console.log(["a", "b", "c"][3]); // => `undefined`
-

As we see in the code above, if we try to access an element at an index that is
- not inside the array, we get back undefined. This makes sense because there is
- no value at that given position!

The classic "off by one" error

- -

Arrays are similar to strings in that both of their indices start at 0 instead
- of 1. Forgetting this fact can lead to some pretty confusing situations. Let's
- focus on an important distinction: the index of the last value of an array is
- always one less than its length.

console.log([4, 7, 9].length); // => 3
-console.log([4, 7, 9][3]); // => undefined
-console.log([4, 7, 9][2]); // => 9
-

In other words, although the length of [4, 7, 9] is 3, the index of the - last
- value (9) is 2. A good rule of thumb of accessing the last index of an array
- is to find the length and then subtract one:

let testArray = [4, 7, 9];
-let finalIndex = testArray.length - 1; // => (3 - 1) = 2
-console.log(testArray[finalIndex]); // => 9
-

Working with arrays

- -

Containing data in arrays

- -

By packaging groups of related data into a single array, we gain the added
- benefit of being able to refer to that data as a single collection. Arrays don't
- have to just hold single characters- they are capable of holding entire strings,
- numbers, and even other arrays!

let wackyArray = [2, 17, "apple", "cat", ["apple"]];
-
-console.log(wackyArray[0]); // => 2
-console.log(wackyArray[1]); // => 17
-console.log(wackyArray[3]); // => "cat"
-console.log(wackyArray[4]); // => ["apple"]
-

Just think of all the possibilities of what you can store in a single array!
- However, just because you can doesn't mean you should. In practice we will
- almost always be storing similar kinds of data, that are coming from a common
- source (i.e. items in a shopping list, ID numbers, tasks on a todo list).

Using indexOf with arrays

- -

We can also calculate the index of a given value within an array by using
- indexOf:

console.log([1, 3, 5, "apple", "jet"].indexOf(3)); // => 1
-console.log([1, 3, 5, "apple", "jet"].indexOf(5)); // => 2
-console.log([1, 3, 5, "apple", "jet"].indexOf("jet")); // => 4
-
-// this won't be found in the array
-console.log([1, 3, 5, "apple", "jet"].indexOf("potato")); // => -1
-

If we attempt to search for a value that is not present in an array,
- indexOf will return -1. This makes sense because we know that -1 is not a
- valid array index. The smallest index possible is 0!

Concatenation with arrays

- -

As a reminder, concatenation is just a fancy word for joining things together
- into a single collection. Now, this is where arrays will differ from strings.
- The + operator only exists for numbers and strings. If you try to use the +
- on an array it will try to help you out by converting your arrays into
- strings.

console.log([1, 2, 3] + [4, 5, 6]); // => 1,2,34,5,6
-

JavaScript was just trying to help! However that is probably not what you meant
- to do. Good thing JavaScript has a seperate method for putting two array
- together. To concatenate arrays, we can use the aptly named .concat method:

console.log([1, 2, 3].concat([4, 5, 6])); // => [1, 2, 3, 4, 5, 6]
-

Remember

- -

An Array is a data type that contains a list of in order values surrounded
- in square brackets [].
array.length returns the number of values in the array.
Each value of an array is associated with a number index; the first value of
- an array is at the index of 0.
We can use array.indexOf(value) to obtain the index of value within
- array; if value is not found, then -1 is returned.
We can use .concat to concatenate multiple arrays, combining them into a
- single array.

- DAY-3
Intermediate Functions - -

Intermediate Functions Learning - Objectives

- -

Below is a complete list of the terminal learning objectives across all
- "Intermediate Function" lessons. When you complete these lessons, you should be
- able to perform each of the following objectives. These objectives capture how
- you may be evaluated on the assessment for these lessons.

-
Identify that strings are immutable and arrays are mutable
-
-
Define a function using both function declaration and function expression
- syntax
-
-
Utilize Array#push, #pop, #shift, #unshift to mutate an array
-
-
List the arguments that can be used with Array#splice
-
-
Write a function that sums up elements of an array, given an array of numbers
- as an argument
-
-
Utilize Array#forEach, #map, #filter, #reduce in a function
-
-
Define a function that takes in an array of numbers and returns a new array
- containing only the primes
-
-
Define a function that takes in a 2D array of numbers and returns the total
- sum of all elements in the array
-
-
Define a function that takes in an array of elements and returns a 2d array
- where the subarrays represent unique pairs of elements
-
-
Define a function that takes in an array of numbers as an argument and
- returns the smallest value in the array; if the array is empty return null the terminal learning - objectives across all
- "Intermediate Function" lessons. When you complete these lessons, you should be
- able to perform each of the following objectives. These objectives capture how
- you may be evaluated on the assessment for these lessons.
-
-
Identify that strings are immutable and arrays are mutable
-
-
Define a function using both function declaration and function expression
- syntax
-
-
Utilize Array#push, #pop, #shift, #unshift to mutate an array
-
-
List the arguments that can be used with Array#splice
-
-
Write a function that sums up elements of an array, given an array of numbers
- as an argument
-
-
Utilize Array#forEach, #map, #filter, #reduce in a function
-
-
Define a function that takes in an array of numbers and returns a new array
- containing only the primes
-
-
Define a function that takes in a 2D array of numbers and returns the total
- sum of all elements in the array
-
-
Define a function that takes in an array of elements and returns a 2d array
- where the subarrays represent unique pairs of elements
-
-
Define a function that takes in an array of numbers as an argument and
- returns the smallest value in the array; if the array is empty return null
-

Function Expressions

- -

You may have noticed that we've been writing many functions so far in the
- course! We will continue to do so since functions are the building blocks of the
- eventual applications that we will build. That being said, let's begin to
- broaden the way we think about functions. In particular, we'll want think of
- functions as expressions that we can store in variables - just like our classic
- data types of number, string, boolean, array, and object!

When you finish this article, you should be able to:

identify functions as first-class objects in JavaScript
define a function using function expression syntax

Functions as first-class objects

- -

JavaScript is well known for being a programming language that treats functions
- as "first-class objects". This fancy talk means that you can treat a function as
- a "normal" value by storing it in a variable. We'll leverage this key concept in
- very clever ways later in the course. For now, let's begin with a simple example
- that shows the "first-class object" nature of functions:

let calculateAverage = function(a, b) {
-  return (a + b) / 2;
-};
-
-console.log(calculateAverage(10, 20)); // 15
-

In the code snippet above, we define the calculateAverage by assigning a
- variable to contain the function's definition. By doing this, the variable's
- name is effectively the function's name. So to call the function, we simply
- refer to the variable name. Note that we do not write the function's name after
- the function keyword, where we normally would. We will refer to this new way
- of defining functions as function expression syntax and the classic way of
- defining functions as function declaration syntax. In general, we can define
- functions using either syntax:

// function declaration syntax
-function myFunctionName(arg1, arg2) {}
-
-// function expression syntax
-let myFunctionName = function(arg1, arg2) {};
-

In the coming sections, we'll highlight moments when we'll prefer one syntax
- over the other. For now, get acquainted with the new syntax as it is something
- you'll be seeing a lot of as a programmer!

A peek under the hood

- -

Perhaps you're finding it tough to understand what it means for a variable to
- contain a function - it is indeed a very abstract idea for new programmers.
- Let's draw a comparison. We know that when we assign an expression to variable,
- the expression first evaluates to a single value, which we then store in the
- variable name:

let myNum = 4 + 4;
-console.log(myNum); // prints 8
-console.log(myNum * 3); // prints 24
-

In the same way we can treat a function definition as an expression that
- evaluates!

let myFunc = function() {
-  console.log("I'm a function");
-};
-
-console.log(myFunc); // prints [Function: myFunc]
-myFunc(); // prints "I'm a function"
-

Looking at the snippet immediately above, you'll notice that when we print the
- myFunc variable directly, without calling the function with parentheses,
- JavaScript simply says the variable contains a function named myFunc
- ([Function: myFunc]). You can truly imagine a function as a value that we can
- store and use as we please.

-
The term anonymous function may also be used to describe a function
- expression before it is assigned to any variable. Following the example above,
- we'll use the word anonymous function to describe the function expression
- before the assignment to the myFunc variable is complete. Once the
- assignment is complete, it would be silly to refer to myFunc as an
- anonymous function because an anonymous function has no name.
-

Remember

- -

functions can be stored in variables; just like any other values in
- JavaScript!

Two-Dimensional Arrays (2D Arrays)

- -

Time to broaden our understanding of arrays! We've already explore the
- fundamentals of arrays. Mainly, we can store any type of data we please as
- elements of an array and even mix types together. However, what happens if we
- store an array as an element of an array?

When you finish this article, you should be able to:

index into the inner elements of a 2D array
use nested loops to iterate through a 2D array

Multidimensional Arrays

- -

When we store arrays as elements of other arrays, we refer to those structures
- as multidimensional arrays. If the "depth" of the nested arrays is at exactly 2 (an
- outer array containing inner arrays), then we'll refer to it as a
- two-dimensional array:

let twoDimensional = [["a", "b", "c"], ["d", "e"], ["f", "g", "h"]];
-
-console.log(twoDimensional[1]); // [ 'd', 'e' ]
-console.log(twoDimensional[1][0]); // 'd'
-
-let subArr = twoDimensional[1];
-console.log(subArr[0]); // 'd'
-

Note that indexing the outer twoDimensional array will return an element like
- usual, it's just that element happens to be another array. To gain access to the
- innermost elements, we simply need to apply another set of indexing brackets!

If we style our 2D arrays nicely so that each subarray is on a new line, we can
- interpret the double indices as [row][column]:

let twoDimensional = [
-  ["a", "b", "c"],
-  ["d", "e"],
-  ["f", "g", "h"]];
-
-// get the element in the 0th row, 2nd col:
-console.log(twoDimensional[0][2]); // 'c'
-

Iterating through 2D Arrays

- -

Since a 2D array is just an array of arrays. We'll need to use a loop within a
- loop to iterate through a 2D array:

let array = [["a", "b", "c"], ["d", "e"], ["f", "g", "h"]];
-
-for (let i = 0; i < array.length; i++) {
-  let subArray = array[i];
-  console.log(subArray);
-
-  for (let j = 0; j < subArray.length; j++) {
-    console.log(subArray[j]);
-  }
-}
-

In the nested loops above, the i index refers to the current "row" and the - j
- index refers to the current "column". It's worth noting that since the inner
- subArrays have different length, we'll want to specifically reference the length
- of that subarray in our inner loop condition j < subArray.length. The code
- above will print:

[ 'a', 'b', 'c' ]
-a
-b
-c
-[ 'd', 'e' ]
-d
-e
-[ 'f', 'g', 'h' ]
-f
-g
-h
-

When is a 2D array practical?

- -

As a preview of things to come let's briefly mention when you'll find a 2D array
- useful in your future projects. Imagine how'd you represent a "grid":

tic-tac-toe (3x3 grid)
chess (8x8 grid)
sudoku (9x9 grid)
excel (a sheet is an arbitrarily sized 2D array)

Remember

- -

an array can contain arrays as elements, we call this a 2D arrays
to iterate through a 2D array, used nested loops

Mutability in JavaScript

- -

So far in the course we've explored a handful of methods that manipulate data.
- We'll be growing our arsenal of methods further overtime, so we'll want to gain
- awareness for exactly how we should expect these methods to manipulate the
- data we give them. To this end, let's analyze which methods will modify existing
- data and which methods do not. We refer to this concept as mutability.

When you finish this article, you should be able to:

Explain what "mutability" is
Correctly label JavaScript data types as immutable or mutable

What is mutability?

- -

At its face value, mutability is a simple concept. You may be familiar with
- the word mutation, which refers to a alteration (usually in DNA). Something
- that is mutable can be changed, while something that is immutable is
- unchanging and permanent. To illustrate this concept, we'll begin with strings
- and arrays. We've spent some time with these two data types and by now we
- recognize that the two types share many similarities. Both have indices,
- length, and even share common methods like slice. However, they differ
- greatly in their mutability:

let myArr = ["b", "e", "a", "m"];
-myArr[0] = "s";
-console.log(myArr); // 'seam'
-
-let myStr = "beam";
-myStr[0] = "s";
-console.log(myStr); // 'beam'
-

Above we have shown that we can assign a new element to an index of an array,
- but we cannot assign a new character to an index of a string. In other words,
- arrays are mutable, but strings are immutable.

An implication of this discovery is that there are some array methods that
- will modify an existing array but zero methods that will modify an existing
- string. Methods that manipulate string data typically return a new string and
- never modify an existing one. A prime example is toUpperCase:

let word = "piñata";
-let newWord = word.toUpperCase();
-console.log(word); // 'piñata'
-console.log(newWord); // 'PIÑATA'
-

Above, notice that the toUpperCase method returns a capitalized version of the
- string, but does not change the original string. It's also worth noting that not
- every array method will mutate. For example, the slice method does not mutate
- for both strings and arrays. As we learn about methods in the future, we'll be
- certain to note what mutates and what does not.

Mutable or immutable, that is the - question

- -

Now that we have a grasp of mutability, let's take inventory and identify
- JavaScript's data types as mutable or immutable.

Mutable

array
object (we'll learn these soon)

Immutable

number
string
boolean

A quick way to remember the above list is to identify that the composite types
- (the types that can contain multiple values) of array and object are mutable.
- The remaining "simpler" types of number, string, and boolean are immutable.

The mutability misconception

- -

Maybe you are having a tough time believing what we have just claimed. We don't
- blame you, you've probably heard the saying that change is the only constant in
- the universe. Let's debunk a common argument to turn you into a believer. The
- skeptical programmer may use this as an argument to show that numbers are
- mutable:

let myNum = 42;
-myNum += 8;
-console.log(myNum); // 50
-

Because the myNum variable now contains 50 where it once contained - 42, it
- may seem we have mutated the number, but this is not truly the case. Recall that
- myNum += 8 is shorthand for myNum = myNum + 8. Since the right hand side of
- the assignment evaluates first, we are simply taking the new number of 50 and
- reassigning it to the myNum variable. This reassignment of a variable name is
- not a mutation of the original number.

Remember

- -

data types that can be changed are mutable, those that cannot be changed are
- immutable
arrays and objects are mutable
numbers, strings, and booleans are immutable

Array Splice

- -

Time to a learn yet another array method! The Array#splice - method
- deserves its own reading because of how versatile it is. Feel free to use this
- article as a quick reference; let's jump right in.

When you finish reading this article, you should be able to:

list all possible arguments that can be used with the Array#splice method

Notation

- -

For clarity in this article and moving forward in the course, we'll be notating
- methods with # to clarify how they should be called. For example,
- Array#splice refers to the method that should be called on an array,
- arr.splice() where arr is some array variable. Likewise - String#toUpperCase
- refers to the method that should be called on a string, str.toUpperCase()
- where str is some string variable. We'll opt to refer to methods using this
- notation because some methods can be called on multiple data types, such as
- Array#slice and String#slice.

What can Array#splice do?

- -

Before we explore the nitty-gritty details of the Array#splice method, the
- first thing to be aware of is that the method will mutate the array that it
- is called on. That is, Array#splice will modify the existing array and not
- return a new array.

Using splice to remove

- -

The usage of the Array#splice method is easy to mix up because it can be used
- to remove or insert elements into an array. That's right - it can perform
- "opposite" operations, even at the same time! For now, we'll begin by only
- removing elements from an array:

let colors = ["red", "yellow", "blue", "green", "orange", "brown", "gray"];
-let returnVal = colors.splice(2, 3);
-console.log(colors); // [ 'red', 'yellow', 'brown', 'gray' ]
-console.log(returnVal); // [ 'blue', 'green', 'orange' ]
-

The first two arguments for splice correspond to 1) the target index and 2) how
- many elements to remove. The call colors.splice(2, 3), will remove the next
- three elements beginning at index 2. This means that the elements at indices 2,
- 3, and 4 are removed.

Note that splice returns an array containing the elements that were removed and
- also has the effect of removing the elements from the original array, mutating
- it in-place.

Using splice to insert

- -

To use the splice method to insert new elements into an array, we can pass in
- any number of additional arguments representing the values to insert:

let colors = ["red", "yellow", "blue"];
-let returnVal = colors.splice(1, 0, "RebeccaPurple", "CornflowerBlue");
-console.log(colors); // [ 'red', 'RebeccaPurple', 'CornflowerBlue', 'yellow', 'blue' ]
-console.log(returnVal); // []
-

The method call colors.splice(1, 0, 'RebeccaPurple', 'CornflowerBlue')
- translates to "target index 1, remove the next 0 elements, then insert
- 'RebeccaPurple' and 'CornflowerBlue'."

Using splice like a pro

- -

Naturally, we can combine these two functionalities! Say we wanted to target
- index 2, remove the next 3 elements, then insert 'Gainsboro', 'Ivory', and
- 'Khaki':

let colors = ["red", "yellow", "blue", "green", "black", "beige"];
-let removed = colors.splice(2, 3, "Gainsboro", "Ivory", "Khaki");
-console.log(colors); // [ 'red', 'yellow', 'Gainsboro', 'Ivory', 'Khaki', 'beige' ]
-console.log(removed); // [ 'blue', 'green', 'black' ]
-

Bam. What a versatile method! Always feel free to reference the
- documentation - for the method when you are struggling to remember
- its usage:

Remember

- -

Array#splice has two required arguments -
- the target index
- the number of elements to remove beginning at that target index
-
Array#splice can also take in any number of values to be inserted at the
- target index

String#split and Array#join

- -

We've seen previously that strings and arrays share many similar properties. For
- example, strings and arrays both have a length and can have multiple indices.
- Because of this, you may find it useful to "convert" between the two types.

When you finish this article, you should be able to:

use the String#split method to turn a string into an array
use the Array#join method to turn an array into a string

String#split

- -

The String#split - method is called on a string and accepts a
- "separator" string as an argument. The method will return an array where the
- elements are the resulting substrings when we cut at the "separators":

let sentence = "follow the yellow brick road";
-let words = sentence.split(" ");
-console.log(words); // [ 'follow', 'the', 'yellow', 'brick', 'road' ]
-console.log(sentence); // 'follow the yellow brick road'
-

Note that the original string is not mutated, rather a new array is returned.
- A common pattern is to split a sentence string on a space (' '), but you can
- split on any separator as you see fit:

let sentence = "follow the yellow brick road";
-console.log(sentence.split(" ")); // [ 'follow', 'the', 'yellow', 'brick', 'road' ]
-console.log(sentence.split("the")); // [ 'follow ', ' yellow brick road' ]
-console.log(sentence.split("o")); // [ 'f', 'll', 'w the yell', 'w brick r', 'ad' ]
-

A pattern you may find useful is that when you split on a separator string, it
- is guaranteed that that separator will not be in the resulting array,
- effectively removing it. See the example of sentence.split('the') above. This
- may come in handy, so keep it in mind!

Array#join

- -

The Array#join - method is called on an array and accepts a
- "separator" string as an argument. The method will return a string where
- elements of the array are concatenated together with the "separator" between
- each element:

let words = ["run", "around", "the", "block"];
-let sentence = words.join(" ");
-console.log(sentence); // 'run around the block'
-console.log(words); // [ 'run', 'around', 'the', 'block' ]
-
-console.log(words.join("_")); // 'run_around_the_block'
-console.log(words.join("HI")); // 'runHIaroundHItheHIblock'
-

Array#join does not mutate the original array, instead it will return a new
- string.

A clever combination

- -

It's pretty evident that String#split and Array#join are "opposite" - methods.
- That is:

we use split to turn a string into a array
we use join to turn an array into a string

By combining these two methods we can accomplish some cool behavior:

let str = "I don't know what I want to eat";
-let newStr = str.split("I").join("we");
-console.log(newStr); // 'we don't know what we want to eat'
-

Whoa! We were able to replace every substring "I" with the substring "we". We
- know that the line str.split('I').join('we') evaluates from left to right.
- This means that the split will cut the string wherever there is an 'I',
- leaving a gap where the 'I's were. Then, the join will fill those gaps with
- 'we's.

Remember

- -

we can use String#split and Array#join to convert between strings and
- arrays
both methods do not mutate their input

- - -

Determining Types

- -

Sometimes you want to know the type of value store in a variable so that you can
- safely do things with it. If your function expects an array in its parameter but
- gets a number, you can't call the map method on that!

In this article you will learn how to figure out if a value in a variable is

A string
A number
A function
An array

The typeof operator

- -

Not all operators in JavaScript require two arguments like the + operator for
- addition, the = for assignment, and the % operator for modulo division.
- Those are all called binary operators because they take two (bi-) operands,
- or things that are operated on.

JavaScript kindly gives you the operator typeof which acts on a single value.
- Operators that take only one operand are called unary operators because "u
- only give them one value!" (That's a joke. "uni-" or "una-" is one.)

Here are some examples of what you'd expect to see with the typeof operator.

let s = 'This is a string';
-console.log(typeof s);    // 'string'
-
-let n = 6.28;
-console.log(typeof n);    // 'number'
-
-let sum = function (a, b) {
-  return a + b;
-}
-console.log(typeof sum);  // 'function'
-

Note that the value returned from the typeof operator is a String data type.
- So, if you want to check if a value is a number, you could do this.

if (typeof n === 'number') {
-  // It is a number. Do some maths!
-} else {
-  console.log('I really wanted a number. :-(');
-}
-

How to tell if a value is an array

- -

Unfortunately, due to a really old bug in the way that JavaScript works, a bug
- that no one can fix because people wrote code that relies on the bug for
- decades, you cannot use the typeof operator to figure out if something is an
- array.

let a = [1, 2, 3];
-console.log(typeof a);  // 'object'
-

Gee, JavaScript. That's not helpful. Thanks.

Luckily, it only took 12 years for JavaScript to include a way to test if a
- value is an array. To do so, you use the Array.isArray method like this.

let a = [1, 2, 3];
-Array.isArray(a);  // true
-
-let n = 6.28;
-Array.isArray(n);  // false
-
-let f = function () {}
-Array.isArray(f);  // false
-

Practical use in "real" code

- -

Oddly enough, you won't see a lot of code in real-world applications testing if
- a value is one type or another. A lot of JavaScript functions just assume that
- they will get arguments of the right kind because the parameter names imply what
- kind of value to pass in. For example, the following function has a parameter
- named sentence.

function reverseTheSentence(sentence) {
-  // ... code here ...
-}
-

Most developers will know that the function probably wants sentence to be a
- string value. They just won't pass in an array or number or ... well, anything
- other than a string. Because that's just not polite. They'd expect any other
- kind of value to cause the reverseTheSentence to malfunction. Only when you
- know that people that don't respect your code will use it should you add in some
- kind of check like this.

function reverseTheSentence(sentence) {
-  if (typeof sentence !== 'string') {
-    // Tell the developer they are using
-    // the function wrong.
-  }
-  // ... code here ...
-}
-

Remember

- -

This article has shown you two ways to determine if a value is a kind of type:

the typeof operator to use to test if a value is a number, a string, or
- a function; and,
the Array.isArray method to check if a value is an array.

Use them as much (or as little) as you need!

The Null Type (And Undefined)

- -

You've met numbers and string, Booleans and arrays. There's another type often
- used in JavaScript: the Null type. And, it's a special type.

In this article, you will learn about the Null type, its value, and how to work
- with it in JavaScript.

A type with only one value

- -

You have seen that the String type can have an "infinite" number of values
- (within the limits of your computer memory). For example, the String type
- represents any of the following values.

// Examples of values with the String type
-'hello, world'
-"this is a string"
-`Where is my pudding?`
-''
-'A really long string.........................................................'
-

The Number type also has this aspect. Any number that you can reasonable express
- in JavaScript has the Number type.

// Examples of values with the Number type
--100
-99
-6.28
-Infinity
-

You also know about the Boolean type. It can have only two values.

// The only two values of Boolean type
-true
-false
-

There are not more Boolean values. You can't dream up more. There are only
- two, those two.

The Null type has one and exactly one value.

// The only value that has the Null type
-null
-

It's just that word: null. No quotation marks. No other fancy things. Just
- null.

The meaning of null

- -

This is a harder subject to tackle because it's a philosophical subject. Many
- people ask, "What does the value of null mean in a program?" There are a
- couple of answers that programmers give to this. None of them are wrong. None of
- them are right. They just are. In the presence of null, the code you write
- determines which of the following meanings null has.

The value null means the absence of a value or no value
The value null means an unknown value
The value null is a nuisance and I hate it and wish it were never invented

During your software programming career, you will likely have all three of those
- opinions, sometimes at the same time. Let's take a look at some examples to try
- to figure this out.

The absence of a value

- -

Let's say you wrote a function that splits a string into words, reverses them,
- and puts them back together in reverse order. You can do that with the methods

String#split link; -
Array#reverse link; - and,
Array#join link. -

That function could look like this.

function reverseTheSentence(sentence) {
-  let parts = sentence.split(' ');
-  parts.reverse();
-  return parts.join(' ');
-}
-

That's great! It works! But, what happens if someone doesn't care about what
- your function and just decides to pass in something that's not a string? It
- would make sense that reversing something that is not a string should lead to no
- value, the absence of a value, because the input to the function doesn't make
- sense. In that case, you can just return a null because there is no value
- that the function can return that would make sense.

function reverseTheSentence(sentence) {
-  if (typeof sentence !== 'string') {
-    return null;
-  }
-  let parts = sentence.split(' ');
-  parts.reverse();
-  return parts.join(' ');
-}
-

An unknown value

- -

There are a lot of programmers that will argue that null cannot be an unknown
- value. "The value is known!" they'll exclaim. "The value is 'null'! It's known!
- It's 'null'! Stop saying it's not known!"

There are programmers that vehemently disagree with that.

shrug

Checking if a value is null

- -

If you had hoped that you could use the typeof operator to check if a value is
- null, then you're out of luck.

// Useless code.
-console.log(typeof null);  // 'object'
-

Silly JavaScript. Instead of using the typeof operator, you can just compare
- the value to null because there is only one value of the Null data type and
- it's always null. Take a look at the following code and figure out what you
- think it will produce.

let a = [];
-let x = null;
-
-if (a === null) {
-  console.log('a is null');
-} else if (x === null) {
-  console.log('x is null');
-}
-

Oh, and there's that undefined value, - too

- -

Just like the null value that is the only value of the Null data type, there
- is undefined which is the only value of the Undefined data type.

If you're asking yourself, "Wait, if 'null' is no value or the absence of a
- value, then what the heck does 'undefined' mean?", well you're not the only one.

Have a look at this code.

let value;
-
-value = 6.28;
-console.log(value);
-

You probably will not be surprised to see that it will print out "6.28" because
- that's the value of value. But, what if you did this? What does that new
- console.log print?

let value;
-console.log(value); // <- what does this print?
-
-value = 6.28;
-console.log(value);
-

If you guessed that it prints "undefined", you're right! When you declare a
- variable, it's very first value is undefined. Most of the time, though, you'll
- just immediately set it to a value.

let value = 6.28;
-

So, an uninitialized variable has the value undefined which is the only value
- of the Undefined data type. To test for it, you can use the typeof operator
- or the strict equality operator. Using the strict equality operator is the
- more common way to do that, now.

// Test if a value is undefined
-if (value === undefined) {
-  // do a thing
-}
-
-// You can also do it this way, but
-// it is considered passé.
-if (typeof value === 'undefined') {
-  // do a thing
-}
-

What happens when...

- -

Interestingly enough, all functions actually do return values. Have a look at
- this function. What value does it return? (Not a trick question.)

function returnsTrue() {
-  return true;
-}
-

Yes, it returns the value true. But, what about this function?

function returnsWhat() {
-  return;
-}
-

There's a return statement there but it does not specify a value. If there is
- not value specified, what do you think this function returns? Try putting the
- function definition above and the code below into a code runner and seeing what
- happens.

console.log(returnsWhat());
-

One you figure that out, try the same experiment but with this function. What
- do you think it returns. It doesn't even have a return statement in it!

function whatIsThis() {
-}
-

Remember

- -

There is a special value in JavaScript represented as null which means "no
- value" or "unknown value". It is the only value of the Null data type. You can
- check that a value is null by using the strict equality operator x === null.

The value undefined is used by JavaScript for variables that have not been
- assigned a value. Also, functions that do not return an explicit value return
- the value undefined. You can test if a value is undefined by using the
- strict equality operator x === undefined.

Catch Me If You Can

- -

Sometimes bad things happen to good programs. Some person may enter some badly
- formatted information. Another computer may try to attack your program by
- sending it wonky data. A network could go down. A file can become corrupt. When
- this happens, your running software will have some errors. This article is about
- how you can recover from those errors with "structured exception handling".

In this article you'll learn the answers to:

What is structured exception handling?
How can I do that in JavaScript?
How can I make my own errors?
What else can I do with it?
Shouldn't I just always do this?

Structured exception handling

- -

Oddly enough, there are very few error-handling mechanisms in use, today, in all
- programming languages. There are really only three ways that programming
- language provide structured exception handling.

Error or error code reporting as found in languages like C and Go
Continuable exceptions as found in Common Lisp
Stack unwinding which is found in almost every modern programming
- language including JavaScript and Python

In the stack-unwinding paradigm, which is the one you'll use in JavaScript, when
- an error occurs, the JavaScript interpreter (the thing running your JavaScript
- code) looks for some kind of handler for that error. It has a very specific way
- of searching for those handlers. The way JavaScript searches for the handlers is
- very similar to the way it happens in Python, C++, Java, C#, and a lot of other
- languages. Once you learn it, here, you will be able to handle errors when
- writing code in all of those languages.

Try and catch

- -

Say you have some code that may have an error. For example:

function sumArray(array) {
-  let sum = 0;
-  for (let i = 0; i < array.length; i += 1) {
-    sum += array[i];
-  }
-  return sum;
-}
-

If someone calls the above function with the code sumArray(null), then they
- will get the error because the for loop is trying to get the length property
- of the array parameter which is null.

TypeError: Cannot read property 'length' of null
-

To prevent this from ruining your program, you wrap code that may have an error
- in a try block. Now, you've seen other blocks already: if blocks, - for
- blocks, function blocks. Basically, if there are curly braces around some
- lines of code, that's a code block of some kind. A try block is just some
- curly braces with the try keyword.

// THIS IS AN INCOMPLETE BLOCK OF CODE
-function sumArray(array) {
-  let sum = 0;
-
-  // The try block wraps the for loop. If some
-  // error occurs, the try block will give you
-  // a chance to react to it so that the program
-  // doesn't terminate.
-  try {
-    for (let i = 0; i < array.length; i += 1) {
-      sum += array[i];
-    }
-  } // needs something more here
-
-  return sum;
-}
-

The try block tells JavaScript that it needs to watch the code inside the
- curly braces for an error. Now, you have to tell JavaScript what to do when
- there is an error. You do that in the catch block that should immediately
- follow the try block. The catch block accepts a single parameter that
- (usually) contains an object that describes the error that occurred. In the
- case of the sumArray method, if an error occurs, you could return the value
- undefined rather than letting an error terminate your program. You could also
- log the error to the "error" output.

function sumArray(array) {
-  let sum = 0;
-
-  try {
-    for (let i = 0; i < array.length; i += 1) {
-      sum += array[i];
-    }
-  } catch (e) {
-    console.log(e);
-    return null;
-  }
-
-  return sum;
-}
-
-sumArray(null);
-

Just to state it, again: the catch block runs when an error occurs in the try
- block. If no error occurs in the try block, the catch block does not
- run.

That (e) after the word catch is a variable that contains any error that - was
- thrown and caught by this try-catch block. It doesn't have to be named e.

function sumArray(array) {
-  let sum = 0;
-
-  try {
-    for (let i = 0; i < array.length; i += 1) {
-      sum += array[i];
-    }
-  } catch (pancakes) {
-    console.log(pancakes);
-    return null;
-  }
-
-  return sum;
-}
-
-sumArray(null);
-

Here is the same code but, instead of a variable named "e", there is a variable
- named "pancakes". Now, if an error is thrown, the variable "pancakes" will
- contain it. By long-standing tradition, the variables used with the catch block
- are normally "e", "err", or "error".

// CODE SNIPPET, WILL NOT RUN
-} catch (e) {
-

// CODE SNIPPET, WILL NOT RUN
-} catch (err) {
-

// CODE SNIPPET, WILL NOT RUN
-} catch (error) {
-

Now, when you run the code sumArray(null), you should see something like the
- following, if you run it in the online code editor.

TypeError: Cannot read property 'length' of null
-  at sumArray (/tmp/file.js:5:31)
-  at Object.<anonymous> (/tmp/file.js:16:1)
-  at Module._compile (internal/modules/cjs/loader.js:1158:30)
-  at Object.Module._extensions..js (internal/modules/cjs/loader.js:1178:10)
-  at Module.load (internal/modules/cjs/loader.js:1002:32)
-  at Function.Module._load (internal/modules/cjs/loader.js:901:14)
-  at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:74:12)
-  at internal/main/run_main_module.js:18:47
-

In that code sample, after the sumArray(null) call, the lines that begins
- TypeError is the error that occurred. The next 10 lines are what is known as a
- stack trace. You'll end up seeing these a lot, most likely, as you continue
- your career in software programming. This is the first line in understanding
- errors in your code. The stack trace shows on the first line where the error
- occurred: sumArray (/tmp/file.js:5:31) means that it occurred in the
- sumArray method on line 5 of the content, at character 31. If you open up one
- of the coding problems, paste that code block in, and run it, you'll see similar
- output in the output block.

The last line undefined is the return value of the sumArray(null) - invocation
- that now happens when an error occurs.

That is how the so-called try-catch block works.

How can I make my own errors?

- -

To create your own errors with structured exception handling, you first need to
- create an error object with the message that describes the error. Then, you need
- to "throw" the error. That code would look like either of these two lines, the
- only difference being the new keyword. They both work exactly the same.

throw Error('this happened because I wanted it to');
-throw new Error('this happened because I wanted it to');
-

What else is there?

- -

Turns out that you can have one more block on the try-catch block. It is the
- finally block. The finally block runs whether or not an error occurs. It
- always runs.

function sumArray(array) {
-  let sum = 0;
-
-  try {
-    for (let i = 0; i < array.length; i += 1) {
-      sum += array[i];
-    }
-  } catch (e) {
-    console.log(e);
-    return null;
-  } finally {
-    console.log('you will always see this.');
-  }
-
-  return sum;
-}
-

How do I best use this?

- -

At this point, you may be asking yourself, "Self, since errors can occur
- everywhere, shouldn't I just wrap all of my code in these try-catch blocks?"

No. No, you shouldn't.

Every try-catch block introduces another slow-down in your code. If you're
- writing code that you want to run as fast as possible, then you write as few
- try-catch blocks as possible. Also, it makes the code pretty cluttered with
- all of the indentation and curly braces. When at all possible, you should write
- defensive code which checks for bad values before errors get thrown in your
- code. Rather than using a try-catch block in the sumArray function, you
- could defend against bad values of the array parameter like so.

function sumArray(array) {
-  if (array === null) {
-    return null;
-  }
-
-  let sum = 0;
-  for (let i = 0; i < array.length; i += 1) {
-    sum += array[i];
-  }
-  return sum;
-}
-

Review

- -

The try-catch-finally block is a mechanism to handle errors in your code. You
- should not wrap all of your code in these blocks because it can seriously
- degrade the performance of your application. Instead, only wrap those portions
- of the code that you want to guard against throwing exceptions.

A better choice, in JavaScript and all programming languages, is to be
- defensive about your programming and choose to check that the value that you
- have has the functionality that you desire by adding code like

if (value !== undefined) {}
-if (value !== null) {}
-

- - - - - - - - - - - - - - - - diff --git a/README.md b/README.md index 67a4d10..756e3e8 100644 --- a/README.md +++ b/README.md @@ -1,18991 +1,7 @@ # Prep-Work -## [deployment](https://lambda-prep.netlify.app/) -## [GitHub Pages](https://bgoonz.github.io/lambda-prep/) -## [Backup-Deployment:](https://bgoonz-c1f6696402.drafts.github.io/lambda-prep/) - -0.\) Links: - - - -[HTML TAG EXAMPLES](./one-of-every-tag.html) -[Navigation](./directory.html) -[Playground](https://code-playground.netlify.app/) -[Quiz Me](https://web-dev-interview-prep-quiz-website.netlify.app/) -[Text-Tools](https://devtools42.netlify.app/) -[Github HTML FilePreviewer](https://githtmlpreview.netlify.app/)[simple-sidebar-template](./_Resources\simple-side-bar\directory.html) -[My Blog Posts](https://bryanguner.medium.com/) - - - - -| Name | Hyperlink | -| :-------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| OKTA | [https://lambdaschoolsso.okta.com/login/login.htm?fromURI=%2Fapp%2FUserHome](https://lambdaschoolsso.okta.com/login/login.htm?fromURI=%2Fapp%2FUserHome) | -| Calendar | [https://calendar.google.com/calendar/u/0/embed?src=c\_2q0kvam9h9k5i6t40qp5n18dh8@group.calendar.google.com](https://calendar.google.com/calendar/u/0/embed?src=c_2q0kvam9h9k5i6t40qp5n18dh8@group.calendar.google.com) | -| Slack | [https://app.slack.com/client/T4JUEB3ME/G01QG65CN75](https://app.slack.com/client/T4JUEB3ME/G01QG65CN75) | -| | | -| | | -| | | -| | | -| | | -| Prep Work | [https://apply.lambdaschool.com/courses/web/](https://apply.lambdaschool.com/courses/web/) | - - - - - -![google-analytics](./analytics.PNG) - - -3.\) Pre-Course Work -[![Edit epic-hawking-rdij1](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/epic-hawking-rdij1?autoresize=1&expanddevtools=1&fontsize=10&hidenavigation=1&theme=dark) - -``` -. -├── README.html -├── README.md -├── SUMMARY.html -├── SUMMARY.md -├── codeswing.json -├── comparison.png -├── demo.html -├── directory.html -├── index.html -├── javascript-practice -│ ├── 00_expressions_variables -│ │ ├── exercises -│ │ │ ├── A_executing_code_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_expressions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_variables_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── D_string_indexing_and_methods_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_executing_code_solution -│ │ │ ├── age.js -│ │ │ ├── greeting.js -│ │ │ ├── -│ │ │ ├── thirsty.js -│ │ │ └── whoami.js -│ │ ├── B_expressions_solution -│ │ │ ├── boolean-expressions.js -│ │ │ ├── comparisons.js -│ │ │ ├── number-expressions.js -│ │ │ ├── -│ │ │ └── string-expressions.js -│ │ ├── C_variables_solution -│ │ │ ├── four.js -│ │ │ ├── one.js -│ │ │ ├── -│ │ │ ├── three.js -│ │ │ ├── two.js -│ │ │ └── zero.js -│ │ ├── D_string_indexing_and_methods_solution -│ │ │ ├── a-tedious-task.js -│ │ │ ├── dare-to-decipher.js -│ │ │ ├── proper-patterns.js -│ │ │ ├── -│ │ │ └── small-string-snippets.js -│ │ -│ ├── 01_conditionals -│ │ ├── exercises -│ │ │ ├── A_conditionals_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_conditionals_solution -│ │ │ ├── one.js -│ │ │ ├── -│ │ │ ├── three.js -│ │ │ ├── two.js -│ │ │ └── zero.js -│ │ -│ ├── 02_functions -│ │ ├── exercises -│ │ │ ├── A_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_functions_solution -│ │ │ ├── average.js -│ │ │ ├── ends-with-t.js -│ │ │ ├── half.js -│ │ │ ├── is-div-by-4.js -│ │ │ ├── is-long.js -│ │ │ ├── keep-it-quiet.js -│ │ │ ├── -│ │ │ ├── snippet-0-1.js -│ │ │ ├── snippet-0-2.js -│ │ │ ├── snippet-0-3.js -│ │ │ └── snippet-0-4.js -│ │ ├── B_functions_solution -│ │ │ ├── ends-in-ly.js -│ │ │ ├── funny-sound.js -│ │ │ ├── longer.js -│ │ │ ├── one-or-none.js -│ │ │ ├── parity.js -│ │ │ ├── -│ │ │ ├── starts-with-r.js -│ │ │ ├── string-size.js -│ │ │ └── wacky-word.js -│ │ ├── C_functions_solution -│ │ │ ├── average-of-four.js -│ │ │ ├── case-changer.js -│ │ │ ├── contains.js -│ │ │ ├── divisible.js -│ │ │ ├── in-range.js -│ │ │ ├── larger.js -│ │ │ ├── number-change.js -│ │ │ -│ │ -│ ├── 03_loops -│ │ ├── exercises -│ │ │ ├── A_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_loops_solution -│ │ │ ├── count-up.js -│ │ │ ├── evens.js -│ │ │ ├── min-to-max.js -│ │ │ ├── one-to-four.js -│ │ │ ├── -│ │ │ ├── snippet-1.js -│ │ │ ├── snippet-2.js -│ │ │ ├── snippet-3.js -│ │ │ ├── snippet-4.js -│ │ │ ├── snippet-5.js -│ │ │ └── string-iterate.js -│ │ ├── B_loops_solution -│ │ │ ├── div-by-either.js -│ │ │ ├── five-multiples-of.js -│ │ │ ├── no-ohs.js -│ │ │ ├── odd-sum.js -│ │ │ ├── product-up-to.js -│ │ │ ├── -│ │ │ ├── string-repeater.js -│ │ │ └── sum-up-to.js -│ │ ├── C_loops_solution -│ │ │ ├── censor-e.js -│ │ │ ├── divisible-range.js -│ │ │ ├── fizz-buzz.js -│ │ │ ├── raise-power.js -│ │ │ ├── remove-capitals.js -│ │ │ ├── reverse-iterate.js -│ │ │ -│ │ -│ ├── 04_arrays -│ │ ├── exercises -│ │ │ ├── A_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_arrays_solution -│ │ │ ├── bleep-vowels.js -│ │ │ ├── divisors.js -│ │ │ ├── filter-long-words.js -│ │ │ ├── num-odds.js -│ │ │ ├── -│ │ │ ├── stay-positive.js -│ │ │ ├── strings-to-lengths.js -│ │ │ └── total.js -│ │ ├── B_arrays_solution -│ │ │ ├── choose-divisibles.js -│ │ │ ├── make-acronym.js -│ │ │ ├── maximum.js -│ │ │ ├── reverse-array.js -│ │ │ ├── -│ │ │ ├── word-count.js -│ │ │ └── your-average-function.js -│ │ ├── C_arrays_solution -│ │ │ ├── alternating-caps.js -│ │ │ ├── common-elements.js -│ │ │ ├── lengthiest-word.js -│ │ │ ├── number-range.js -│ │ │ ├── remove-short-words.js -│ │ │ -│ │ -│ ├── 05_nesting -│ │ ├── exercises -│ │ │ ├── A_nested_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_two_dimensional_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_more_problems_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_nested_loops_solution -│ │ │ ├── pair-print.js -│ │ │ ├── print-combinations.js -│ │ │ ├── -│ │ │ ├── snippet-1.js -│ │ │ ├── snippet-2.js -│ │ │ ├── snippet-3.js -│ │ │ ├── snippet-4.js -│ │ │ ├── snippet-5.js -│ │ │ └── two-sum.js -│ │ ├── B_two_dimensional_arrays_solution -│ │ │ ├── make-matrix.js -│ │ │ ├── print-2d.js -│ │ │ ├── -│ │ │ ├── total-product.js -│ │ │ ├── two-sum-pairs.js -│ │ │ └── zipper.js -│ │ ├── C_more_problems_solution -│ │ │ ├── remove-dupes.js -│ │ │ ├── remove-first-vowel.js -│ │ │ ├── remove-vowels.js -│ │ │ ├── -│ │ │ ├── shorten-long-words.js -│ │ │ └── spam.js -│ │ -│ ├── 06_decomposition_pattern -│ │ ├── A_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── C_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ ├── 07_objects -│ │ ├── A_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── C_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ ├── 08_higher_order_functions -│ │ ├── A_native_callback_methods_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_native_callback_methods_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ -├── js.js -├── one-of-every-tag.html -├── readme -│ ├── README.html -│ ├── README_files -│ │ ├── katex.min.css -│ │ -│ -├── resources.html -├── resources.md -├── script.js -├── style.css -└── tree.md - -66 directories, 241 files - - - - - -``` -# WEEK 1
*Introduction to JavaScript (Part 1)* {ignore=true} -________________________________________________________________________________ - - - -[**Expression Learning Objectives**](#expression-learning-objectives) -[**Intro to Functions Learning Objectives**](#intro-to-functions-learning-objectives) -- [Hello World](#hello-world) - - [Getting visual feedback in your programs](#getting-visual-feedback-in-your-programs) - - [Code comments](#code-comments) -- [The Number Type](#the-number-type) - - [All the numbers](#all-the-numbers) - - [The basic arithmetic operators](#the-basic-arithmetic-operators) -- [The String Type](#the-string-type) - - [Writing a valid string](#writing-a-valid-string) - - [Calculating length](#calculating-length) - - [Indexing a string](#indexing-a-string) - - [Concatenation](#concatenation) -- [The Boolean Type](#the-boolean-type) - - [Logical Operators](#logical-operators) - - [De Morgan's Law](#de-morgans-law) -- [Comparison Operators](#comparison-operators) - - [The relative comparators](#the-relative-comparators) - - [=== vs ==](#vs) -- [Basic Variables](#basic-variables) - - [Initializing a variable](#initializing-a-variable) - - [Manipulating variables](#manipulating-variables) - - [NaN](#nan) -- [Introduction to Functions](#introduction-to-functions) - - [Writing Functions](#writing-functions) - - [Invoking or "calling" a function](#invoking-or-calling-a-function) - - [Returning a value](#returning-a-value) - - [The importance of naming](#the-importance-of-naming) -- [Parameters and Arguments](#parameters-and-arguments) - - [The difference between Parameters and Arguments](#the-difference-between-parameters-and-arguments) - -[**Control Flow and Array Learning Objectives**](#control-flow-and-array-learning-objectives) -- [Control Flow - Conditional Statements](#control-flow-conditional-statements) - - [A Quick Word on Syntax](#a-quick-word-on-syntax) - - [Writing Conditional Statements](#writing-conditional-statements) -- [Mutually Exclusive Conditions](#mutually-exclusive-conditions) - - [When to use if statements](#when-to-use-if-statements) -- [Control Flow - Looping](#control-flow-looping) - - [Looping](#looping) - - [Translating From One Loop to Another](#translating-from-one-loop-to-another) -- [The Array Type](#the-array-type) - - [Using arrays](#using-arrays) - - [Indexing arrays](#indexing-arrays) - - [Working with arrays](#working-with-arrays) - - [Concatenation with arrays](#concatenation-with-arrays) - -[**Intermediate Functions Learning Objectives**](#intermediate-functions-learning-objectives) -- [Function Expressions](#function-expressions) - - [Functions as first-class objects](#functions-as-first-class-objects) -- [Two-Dimensional Arrays (2D Arrays)](#two-dimensional-arrays-2d-arrays) - - [Multidimensional Arrays](#multidimensional-arrays) - - [Iterating through 2D Arrays](#iterating-through-2d-arrays) - - [When is a 2D array practical?](#when-is-a-2d-array-practical) -- [Mutability in JavaScript](#mutability-in-javascript) - - [What is mutability?](#what-is-mutability) - - [Mutable or immutable, that is the question](#mutable-or-immutable-that-is-the-question) - - [The mutability misconception](#the-mutability-misconception) -- [Array Splice](#array-splice) - - [Notation](#notation) - - [What can Array#splice do?](#what-can-arraysplice-do) -- [String#split and Array#join](#stringsplit-and-arrayjoin) - - [String#split](#stringsplit) - - [Array#join](#arrayjoin) - - [A clever combination](#a-clever-combination) -- [Determining Types](#determining-types) - - [The typeof operator](#the-typeof-operator) - - [How to tell if a value is an array](#how-to-tell-if-a-value-is-an-array) - - [Practical use in "real" code](#practical-use-in-real-code) -- [The Null Type (And Undefined)](#the-null-type-and-undefined) - - [A type with only one value](#a-type-with-only-one-value) - - [The meaning of null](#the-meaning-of-null) - - [The absence of a value](#the-absence-of-a-value) - - [An unknown value](#an-unknown-value) - - [Checking if a value is null](#checking-if-a-value-is-null) - - [Oh, and there's that undefined value, too](#oh-and-theres-that-undefined-value-too) - - [What happens when...](#what-happens-when) -- [Catch Me If You Can](#catch-me-if-you-can) - - [Structured exception handling](#structured-exception-handling) - - [Try and catch](#try-and-catch) - - [How can I make my own errors?](#how-can-i-make-my-own-errors) - - [What else is there?](#what-else-is-there) - - [How do I best use this?](#how-do-i-best-use-this) - - -________________________________________________________________________________ -# WEEK-01 DAY-1
*Function Introduction* {ignore=true} -________________________________________________________________________________ -# Expression Learning Objectives - -Below is a complete list of the terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Given a working REPL interface, write and execute a statement that will print - "hello world" using console.log -2. Identify that strings are a list of characters defined by using double or - single quotes -3. Given an arithmetic expression using +, -, \*, /, %, compute its value -4. Given an expression, predict if its value is NaN -5. Construct the truth tables for &&, ||, ! -6. Given an expression consisting of >, >=, ===, <, <=, compute it's value -7. Apply De Morgan's law to a boolean expression -8. Given an expression that utilizes operator precedence, compute its value -9. Given an expression, use the grouping operator to change it's evaluation -10. Given expressions using == and ===, compute their values -11. Given a code snippet using postfix ++, postfix --, +=, -=, /=, \*=, predict - the value of labeled lines -12. Create and assign a variable using `let` to a string, integer, and a - boolean. Read its value and print to the console.l learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Given a working REPL interface, write and execute a statement that will print - "hello world" using console.log -2. Identify that strings are a list of characters defined by using double or - single quotes -3. Given an arithmetic expression using +, -, \*, /, %, compute its value -4. Given an expression, predict if its value is NaN -5. Construct the truth tables for &&, ||, ! -6. Given an expression consisting of >, >=, ===, <, <=, compute it's value -7. Apply De Morgan's law to a boolean expression -8. Given an expression that utilizes operator precedence, compute its value -9. Given an expression, use the grouping operator to change it's evaluation -10. Given expressions using == and ===, compute their values -11. Given a code snippet using postfix ++, postfix --, +=, -=, /=, \*=, predict - the value of labeled lines -12. Create and assign a variable using `let` to a string, integer, and a - boolean. Read its value and print to the console. - -________________________________________________________________________________ -# Intro to Functions Learning Objectives - -Below is a complete list of the terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Define a function using function declaration -2. Define a function that calculates the average of two numbers, call it, - pass in arguments, and print it's return value -3. Identify the difference between parameters vs argument terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Define a function using function declaration -2. Define a function that calculates the average of two numbers, call it, - pass in arguments, and print it's return value -3. Identify the difference between parameters vs arguments -________________________________________________________________________________ -# Hello World - -Hey Programmer! Welcome to the JavaScript module. In the next few sections, -we'll be learning the fundamentals of the JavaScript programming language. If -it's your first time programming, don't worry; we designed this course -especially for you. We'll have you executing your first lines of code in no -time! - -When you finish this article, you should be able to: - -- use the `console.log` command to print out messages -- use double slashes (`//`) to write code comments - -## Getting visual feedback in your programs - -The first command we'll learn in JavaScript is `console.log`. This command is -used to _print_ something onto the screen. As we write our first lines of code, -we'll be using `console.log` frequently as a way to visually see the output of -our programs. Let's write our first program: - -```javascript -console.log("hello world"); -console.log("how are you?"); -``` - -Executing the program above would print out the following: - -```plaintext -hello world -how are you? -``` - -Nothing too ground breaking here, but pay close attention to the exact way we -wrote the program. In particular, notice how we lay out the periods, -parentheses, and quotation marks. We'll also terminate lines with semicolons -(;). - -> Depending on how you structure your code, sometimes you'll be able to omit -> semicolons at the end of lines. For now, you'll want to include them -> just as we do. - -### Syntax - -We refer to the exact arrangement of the symbols, characters, and keywords as -**syntax**. These details matter - your computer will only be able to -"understand" proper JavaScript syntax. A programming language is similar to a -spoken language. A spoken language like English has grammar rules that we should -follow in order to be understood by fellow speakers. In the same way, a -programming language like JavaScript has syntax rules that we ought to follow! - -As you write your first lines of code in this new language, you may make many -syntax errors. Don't get frustrated! This is normal - all new programmers go -through this phase. Every time we recognize an error in our code, we have an -opportunity to reinforce your understanding of correct syntax. Adopt a growth -mindset and learn from your mistakes. - -Additionally, one of the best things about programming is that we can get such -immediate feedback from our creations. There is no penalty for making a mistake -when programming. Write some code, run the code, read the errors, fix the -errors, rinse and repeat! - -## Code comments - -Occasionally we'll want to leave **comments** or notes in our code. Commented -lines will be ignored by our computer. This means that we can use comments to -write plain english or temporarily avoid execution of some JavaScript lines. The -proper _syntax_ for writing a comment is to begin the line with double forward -slashes (`//`): - -```javascript -// let's write another program!!! -console.log("hello world"); - -// console.log("how are you?"); - -console.log("goodbye moon"); -``` - -The program above would only print: - -```plaintext -hello world -goodbye moon -``` - -Comments are useful when annotating pieces of code to offer an explanation of -how the code works. We'll want to strive to write straightforward code that is -self-explanatory when possible, but we can also use comments to add additional -clarity. The real art of programming is to write code so elegantly that it is -easy to follow. - -"Simplicity is prerequisite for reliability." — Edsger W. Dijkstra - -## Remember - -- `console.log` can be used to print to the screen -- using `//` at the front of a line will turn it into a comment; comments are - ignored by JavaScript - -________________________________________________________________________________ -# The Number Type - -The **Number** data type in JavaScript does exactly what you expect! It is used -to represent any numerical values, this includes integers and decimal numbers. -As one of our first data types, we'll be interested in what operations we can -use with numbers. - -When you finish this article, you should be able to: - -- predict the evaluation of arithmetic expressions -- explain the order of operations for JavaScript's arithmetic operators -- use the grouping operator, `()`, to manipulate the order of operations in an - expression - -## All the numbers - -JavaScript's **Number** encompasses numerical values. All of the following values are of number type: - -```javascript -42; --5; -3.14159; -7.0; -``` - -## The basic arithmetic operators - -For any given data type, we're interested in what operations we can perform with -that type. We use the word _operator_ to refer to the symbol that performs a -particular _operation_. For example, the `+` operator performs the addition -operation. Here are the common arithmetic operators in JS: - -- `+` (addition) -- `-` (subtraction) -- `*` (multiplication) -- `/` (division) -- `%` (modulo) - -With number values and arithmetic operators in hand, we can evaluate our first -expressions: - -```javascript -console.log(2 + 3); // => 5 -console.log(42 - 42); // => 0 -console.log(-4 * 1.5); // => -6 -console.log(25 / 8); // => 3.125 -``` - -Nothing too groundbreaking about the results above. An expression consists of -values and operators. JavaScript will evaluate an expression into a single -value. - -We can write more complex expressions using multiple operators. However, we'll -want to be aware of the general math order of operations. That is, we perform -multiplication-division operations first and then addition-subtraction -operations. To force a specific order of operation, we can use the grouping -operator, `( )`, around a part of the expression: - -```javascript -console.log(5 * 3 + 2); // => 17 -console.log(2 + 3 * 5); // => 17 -console.log((2 + 3) * 5); // => 25 -``` - -### The modulo operation - -All of the math operators listed above are the simple operations you use -everyday, except for maybe modulo `%`. **Modulo gives us the remainder that -results from a division.** For example, `10 % 3` is 1 because when we divide 10 -by 3, we are left with a remainder of 1. We can read `10 % 3` as "ten modulo -three" or "ten mod three." - -```javascript -console.log(10 % 3); // => 1 -console.log(14 % 5); // => 4 -console.log(20 % 17); // => 3 -console.log(18 % 6); // => 0 -console.log(7 % 9); // => 7 -``` - -Modulo is a very useful operation in the realm of computers. We can use it to -check the divisibility of numbers, whether numbers are even, whether they are -prime, and much, much more. Don't take this seemingly simple operation from -granted! We'll provide a ton of practice using these modulo patterns as we move through the course. - -In the order of operations, modulo has the the same precedence as -multiplication-division. So our complete order of math operations in JS is -parentheses, multiplication-division-modulo, addition-subtraction. - -```javascript -// modulo has precedence over addition -console.log(4 + 12 % 5); // => 6 -console.log((4 + 12) % 5); // => 1 -``` - -## Remember - -- The **Number** type is used to represent integer and decimal values -- The operators `+`, `-`, `/`, `*` perform the normal math operations of - addition, subtraction, division, multiplication respectively -- `a % b` returns the remainder when we divide `a` by `b`; we call this - operation modulo -- JavaScript follows the usual mathematical order of operations and we can use - the `()` to force precedence - -________________________________________________________________________________ -# The String Type - -This article is about one of JavaScript's primitive data types, **String**. -Strings are what we'll use to represent textual data. This means that strings -are useful in representing things like messages, names, poems, and so on. A -string is a sequence of characters. - -When you finish this article, you should be able to: - -- Write strings using correct syntax -- Use `.length` to obtain a count of the numbers of characters that comprise a - string -- Index a string to refer to a single character -- Concatenate strings together - -## Writing a valid string - -Strings are always wrapped by a pair of single quotation marks (`'`) or by a -pair of double quotation marks (`"`). Between the enclosing quotation marks, we -can put any characters! Here are a six examples of strings: - -```javascript -"potato"; -"New York"; -"azablan@.io"; -"Follow the yellow brick road, please!"; -"365 days a year"; -""; -``` - -Above, notice that we are free to mix in **any** characters into a string. This -includes spaces, numerics, punctuation, and other symbols. The sixth string -above is the empty string; it contains zero characters! - -You are probably wondering why we are allowed to use either single or double -quotes when denoting a string - why is this useful? Maybe we want a string that -_contains_ quotation marks: - -```javascript -// valid strings -'Shakespeare wrote, "To be or not to be"'; -"That's a great string"; -``` - -```javascript -// invalid string -'That's a bad string' -``` - -If we want to use a single quote as a character of a string, we simply need to -enclose the string in double quotes, and vice versa. - -## Calculating length - -Since a single string can contain any number of characters, we may find it -useful to count the number of characters in a string using `.length`: - -```javascript -console.log("ramen".length); // => 5 -console.log("go home!".length); // => 8 -console.log("".length); // => 0 -``` - -## Indexing a string - -Strings consist of multiple characters. These characters are numbered by -**indices** starting at 0. So in the string `'bootcamp'`, `'b'` is at index 0, -`'o'` is at index 1, `'o'` is at index 2, `'t'` is at index 3, and so on. We can -look at particular characters of a string by using `[]` and specifying an index: - -```javascript -console.log("bootcamp"[0]); // => 'b' -console.log("bootcamp"[1]); // => 'o' -console.log("bootcamp"[2]); // => 'o' -console.log("bootcamp"[3]); // => 't' -console.log("bootcamp"[7]); // => 'p' -console.log("bootcamp"[10]); // => undefined -console.log("bootcamp"[-3]); // => undefined -``` - -In general, when we index a string using the expression `string[i]`, we get back -the **single character** at position `i`. Looking at the last two examples -above, if we use an invalid index with a string, the value returned is -`undefined`. This makes since because there is no character at the given -position! It's also worth mentioning that an index should always be a number. - -### The classic "off by one" error - -Bear in mind that indices begin at 0 and not 1! Forgetting this nuance can lead -to incorrect code for both new and experienced programmers alike. Let's hone in -on an important distinction: the index of the last character of a string is -always one less than it's length. - -```javascript -console.log("cat".length); // => 3 -console.log("cat"[3]); // => undefined -console.log("cat"[2]); // => 't' -``` - -In other words, although the `length` of `'cat'` is 3, the index of the last -character (`'t'`) is 2. - -### Using indexOf - -We can also calculate the index of a given character within a string by using -`indexOf`: - -```javascript -console.log("bagel".indexOf("b")); // => 0 -console.log("bagel".indexOf("a")); // => 1 -console.log("bagel".indexOf("l")); // => 4 -console.log("bagel".indexOf("z")); // => -1 -``` - -If we attempt to search for a character that is **not** present in a string, -`indexOf` will return -1. This makes sense because we know that -1 is not a -valid string index. The smallest index possible is 0! - -If we search for a character that appears more than once in a string, -`indexOf` will return the index of the first occurance of that character. - -We can also use `indexOf` to search for a substring of characters. Under this -circumstance, `indexOf` will return the index where the substring begins in the -main string: - -```javascript -console.log("door hinge".indexOf("oor")); // => 1 -console.log("door hinge".indexOf("hi")); // => 5 -console.log("door hinge".indexOf("hint")); // => -1 -``` - -## Concatenation - -Concatenation is just a fancy word for joining strings together into a single -string. To concatenate strings, we use the `+` operator: - -```javascript -console.log("hello" + "world"); // => 'helloworld' -console.log("goodbye" + " " + "moon"); // => 'goodbye moon' -``` - -## Remember - -- a **String** is a data type that contains multiple characters enclosed in - quotation marks -- `string.length` returns the number of characters in the `string` -- each character of a string is associated with a number index; the first - character of a string is at index 0 -- we can use `string.indexOf(char)` to obtain the index of `char` within - `string`; if `char` is not found, then -1 is returned -- we can use `+` to concatenate multiple strings, combining them into a single - string - -________________________________________________________________________________ -# The Boolean Type - -The **Boolean** data type is perhaps the simplest type since there are only two -possible values, `true` and `false`. However, we'll find booleans very useful -because they will act as components of later concepts. As programmers, we'll use -booleans to describe the validity of statements. In an abstract sense, _"Today -is Monday"_ and _"one plus one equals ten"_ are examples of statements with -boolean values. That is, they are either `true` or `false`. - -When you finish this article, you should be able to: - -- predict the evaluation of expressions that use the boolean operations of `!`, - `||`, and `&&` -- explain DeMorgan's law - -## Logical Operators - -In the long run, we'll be using booleans to establish logic in our code. For -this reason, the _boolean operators_ can also be referred to as the _logical -operators_. There are only three such operators: - -- `!` (not) -- `&&` (and) -- `||` (or) - -### Logical NOT - -The not (`!`) operator will reverse a boolean value: - -```javascript -console.log(!true); // => false -console.log(!false); // => true -console.log(!!false); // => false -``` - -It's worth mentioning that `!` is a unary operator. This means that the not -operation is applied to a single value. This is in contrast to a binary operator -such as multiplication, which is applied between two values. It does not make -sense to `!` two values together. - -### Logical AND - -The and (`&&`) operator will take two boolean values and will only evaluate to -`true` when both input values are `true`. Otherwise, it will return `false`: - -```javascript -console.log(false && false); // => false -console.log(false && true); // => false -console.log(true && false); // => false -console.log(true && true); // => true -``` - -### Logical OR - -The or (`||`) operator will take two boolean values and will only evaluate to -`false` when both input values are `false`. Otherwise, it will return `true`: - -```javascript -console.log(false || false); // => false -console.log(false || true); // => true -console.log(true || false); // => true -console.log(true || true); // => true -``` - -### Logical order of operations - -We can write boolean expressions that consist of multiple logical operations, but we should be aware of the order of operations. JavaScript will evaluate `!` then `&&` then `||`. - -```javascript -console.log(true || true && false); // => true -console.log(false && !(false || true)); // => false -``` - -In general, `A || B && C` is equivalent to `A || (B && C)` where `A`, `B`, `C` are booleans. - -## De Morgan's Law - -A common mistake in boolean logic is to incorrectly distribute `!` across parentheses. Say we had boolean values of `A`, `B`. Here is something to remember: - -* `!(A || B)` is equivalent to `!A && !B` -* `!(A && B)` is equivalent to `!A || !B` - - -In other words, to correctly distribute `!` across parentheses, we must also flip the operation within parentheses. Beware that: - -* `!(A || B)` is not equivalent to `!A || !B` -* `!(A && B)` is not equivalent to `!A && !B` - -We call this property **De Morgan's Law**. Shout out to Augustus De Morgan of Great Britain. - -## Remember - -* `!`, `&&`, `||` are the boolean operators that we can use to establish logic in our code -* De Morgan's Law should be used to distribute `!` against parentheses - -These are just the basics of the type. We'll be seeing more booleans in the upcoming section, so stay tuned for that! - -________________________________________________________________________________ -# Comparison Operators - -In our previous introduction to the boolean data type, we described booleans as -way to represent the validity of an expression. We'll continue this conversation -by exploring **comparison** operators. As you learn about these operators, bear -in mind that all comparisons will result in a boolean, `true` or `false`. - -When you finish this article, you should be able to: - -- Predict the result of expressions that utilize the operators `>`, `<`, `>=` - `<=`, `===`, and `!==` -- Explain the difference between the equality operators `==` and `===` - -## The relative comparators - -- `>` (greater than) -- `<` (less than) -- `>=` (greater than or equal to) -- `<=` (less than or equal to) -- `===` (equal to) -- `!==` (not equal to) - -Using these operators is pretty straightforward. Here are a few examples: - -```javascript -console.log(10 > 5); // => true -console.log(10 < 5); // => false -console.log(1 < 7); // => true -console.log(7 <= 7); // => true -console.log(5 === 6); // => false -console.log(5 !== 6); // => true -console.log("a" !== "A"); // => true -console.log(false === false); // => true -``` - -Notice that a comparison expression always evaluate to a boolean value (`true` -or `false`). Comparison operators like `===` are a useful to compare strings, -booleans, etc. not just numbers. - -**Did you know?** `'a' < 'b'` is valid JS code? When you relatively compare -strings using `>` or `<` you will be comparing them lexicographically. -Lexicographically is fancy shmancy talk for "dictionary" order! A "lesser" -string is one that would appear earlier in the dictionary: - -```javascript -console.log("a" < "b"); // => true -console.log("apple" < "abacus"); // => false -console.log("app" < "apple"); // => true -console.log("zoo" > "mississippi"); // => true -``` - -**Gotcha** capitilized letters are considered lexicographically less than -lower case letters. i.e "A" < "z" // => true. - - -## === vs == - -In JavaScript there are two equality operators triple-equals (`===`) and -double-equals (`==`). The operators differ in how they compare across differing -types. Triple-equals performs the _strict equality_, meaning it will only return -`true` if the types are the same. Double-equals performs the _loose equality_, -meaning it can return `true` even if the values are of different type. -Double-equals may _coerce_ a value into another type for the comparison, and -this behavior is hard to predict: - -```javascript -console.log(5 === "5"); // false -console.log(5 == "5"); // true -console.log(0 === false); // false -console.log(0 == false); //true -``` - -Whoa! Surprised by these results? It can be hard to predict how `==` behaves, so -we will avoid using it in this course and as a best practice. Stick to using -`===` because it respects data types. - -## Remember - -- `>`, `<`, `>=`,`<=`, `===`, and `!==` can be used to compare values -- we prefer to use `===` to check for equality because it takes the type into - account. - -________________________________________________________________________________ -# Basic Variables - -Variables are used to store information to be referenced and manipulated in a -computer program. They also provide a way of labeling data with a descriptive -name, so our programs can be understood more clearly by programmers. It is -helpful to think of variables as containers that hold information. Their sole -purpose is to label and store data in computer memory. This data can then be -used and even changed throughout the lifetime of your program. - -When you finish this reading, you should be able to: - -- declare variables using the `let` keyword -- assign values to variables using the assignment operator (`=`) -- use the shortcuts `+=`, `-=`, `++`, `--` to reassign variables -- identify `undefined` as the default value for unassigned variables - -## Initializing a variable - -To initialize a variable in JavaScript we'll need two new pieces of syntax: -`let` and `=`. We can give the variable any name that we wish and assign it a -value. Once we initialize a variable, the variable will evaluate to the value -assigned: - -```javascript -let bootcamp = ""; -console.log(bootcamp); // '' - -let birthYear = 2012; -console.log(birthYear); // 2012 -``` - -**Did you know?** JavaScript variables names can contain any alphanumeric -characters, underscore (\_), or dollar sign (\$). However, they _cannot_ begin -with a number. - -Above are examples of how you'll create variables most of the time, so we'll -grow very familiar with the syntax. As a best practice, we should name our -variables in a way that is descriptive and concise. - -The variable initializations above really consist of two steps: _declaration_ -with `let` and _assignment_ with `=`. Let's break these two steps down. - -### Declaring a variable - -In JavaScript, in order to use a variable, we must _declare_ it. Variable -**declaration** is the act of introducing the variable to the environment. - -To declare a variable, use the `let` keyword, followed by a space and then the -name of the variable. - -```javascript -let bootcamp; -console.log(bootcamp); // undefined -``` - -Once a variable is declared, it will contain `undefined` as it's value. -`undefined` is a common default value in JavaScript, we'll see it come up in a -few different places. You can think of `undefined` as showing that the variable -is empty. - -### Assigning a variable - -Once a variable has been declared, we can assign it a value using single-equals -`=` : - -```javascript -let bootcamp; -console.log(bootcamp); // undefined -bootcamp = ""; -console.log(bootcamp); // '' -``` - -## Manipulating variables - -To change the value of a variable, we need to reassign it to a new value with -`=` : - -```javascript -let num = 42; -console.log(num + 8); // => 50 -console.log(num); // => 42 - -num = num + 10; -console.log(num); // => 52 -``` - -In the code above, `num + 8` will evaluate to `50`, but it will not change the `num` -variable to `50`. If we want to change the `num` variable, we must reassign to -it. - -### Assignment Shorthand - -Changing the value of a number variable is something fairly common in the -programming world. Luckily there is some shorthand operators we can use: - -```javascript -let number = 0; -number += 10; // equivalent to number = number + 10 -number -= 2; // equivalent to number = number - 2 -number /= 4; // equivalent to number = number / 4 -number *= 7; // equivalent to number = number * 7 -console.log(number); // 14 -``` - -We also have other shorthand to add or subtract exactly 1 from a variable, the -increment (`++`) and decrement (`--`) operators: - -```javascript -let year = 3004; -year++; -console.log(year); // 3005 -year--; -console.log(year); // 3004 -``` - -## NaN - -Now that we have the ability to perform arithmetic with variables, let's take a -look at a common programming mistake, getting a result of `NaN` (not a number): - -```javascript -let num; -console.log(num + 3); // NaN -``` - -The above code gives `NaN` because the unassigned `num` variable contains -`undefined`; adding `3` to `undefined` results in `NaN`. In general, any -nonsensical arithmetic will result in `NaN`. Math operations involving -`undefined` is perhaps the most common mistake: - -```javascript -console.log(undefined + 3); // NaN -console.log("fish" * 2); // NaN -``` - -## Remember - -- variables are declared with `let` and will contain the value `undefined` by - default -- we can use single-equals `=` to assign variables -- changing a variable requires a reassignment, for which there are many - shortcuts for (`+=`, `-=`, etc.) - -________________________________________________________________________________ -# Introduction to Functions - -We hope you are ready - because you are on the brink of one of the most fun -parts of writing JavaScript: writing **functions**. A function is a procedure of -code that will run when called. We only "write" a function once (**function -declaration**), but we can "use" it as many times as we please (**function -calls**). Functions are the fundamental building blocks of JavaScript and -mastering them is a big step on the road to JavaScript mastery. - -When you finish this reading, you should be able to: - -1. Describe what a function in JavaScript is. -2. Demonstrate how to invoke a function. -3. Write a function using function declaration. -4. Use the `return` keyword to return a value from a function. - -## Writing Functions - -A function is a set procedure of code that will run when called. Functions -really start to make sense when put in the perspective of solving problems. So -for example say you want to find the average of two given numbers. Meaning we -want to take two numbers, add them together then divide by 2: - -```js -> (5 + 5) / 2 -5 - -> (15 + 3) / 2 -9 - -> (7 + 2) / 2 -4.5 -``` - -Writing out the same code again and again gets tedious fast. What you can do -instead is write a new _function_. - -### Function Declaration - -A _function definition_ consists of the function keyword, followed by three -things: - -1. The **name** of the function. -2. A list of _parameters_ to the function, enclosed in parentheses, `()`. -3. The code to be run when this function is run, enclosed in curly - brackets,`{ }`. - -So for our above example of averaging two numbers we could write a function that -would do that for us! We would write something like the following: - -```js -// 1. average is the name of the function -// 2. number1 & number2 are the parameters being passed in -function average(number1, number2) { - // 3. this is the code run every time this function is used - return (number1 + number2) / 2; -} -``` - -First thing to notice for the above `average` function is that we didn't use any -_real_ numbers. You always want to write functions to accept as wide a range of -data as possible. Utilizing the incoming _parameters_ to a function is one of -the keys to making functions flexible. - -In the case of the `average` function, we want to use it to calculate the -average of any two numbers. `number1` and `number2` are the _parameters_ for the -`average` function. In other words, the `average` function expects to be given -two numbers, `number1` and `number2`. We'll be talking a lot more about -parameters later - but for now know that when you define a function with -parameters you are declaring those parameters as usable variables within that -function. - -The beauty of a function is that if we define it in a clever way, it will work -on a whole slew of data! For example, we want `average` to work on any two -numbers, whether or not they are whole numbers, decimal, negative, etc. - -## Invoking or "calling" a function - -Now that we've written a function how do we actually use it? Once defined a -function can be invoked or "called" as many times as we please. - -### Order of code - -Let's step away from `average` for a bit to see how a simple function call -works. Say we run JavaScript code that looks like this: - -```js -console.log("First!"); - -console.log("Second!"); -``` - -Running this code will return exactly as we expect. We will see `First!` printed -out, followed by `Second!`. In other words, JavaScript will evaluate your code -left-to-right and top-to-bottom. Very intuitive! It's exactly how you are -reading these notes right now. - -However, when JavaScript sees a function definition, JavaScript will **not** -evaluate the code inside of the definition. It will only "remember" the code so -we can execute it later. The code below only prints `First!` followed by -`Fourth!`: - -```js -console.log("First!"); - -function callMe() { - console.log("Second!"); - console.log("Third!"); -} - -console.log("Fourth"); - -// when run this code is ran it will print out: -// "First!" -// "Fourth" -``` - -To actually get the code within `callMe` to evaluate, we must _call_ it by using -`callMe()`. The code below will now print out in order: - -```js -function callMe() { - console.log("Second!"); - console.log("Third!"); -} - -console.log("First!"); -// we call the function by adding ending parenthesis -callMe(); -console.log("Fourth!"); - -// when run this code is ran it will print out: -// "First!" -// "Second!" -// "Third!" -// "Fourth" -``` - -Let's say JavaScript is running the file above. Here are the steps it would -take, starting from the tippy top of the code: - -1. JS sees a definition for `callMe`. It will remember this definition in case - we call the function later. It will **not** evaluate the code inside the - function yet. -2. JS prints out `First!` -3. JS sees that we are calling `callMe()`. At this point it will look at the - prior `callMe` definition and run the code inside. It is as if we are - "jumping" to inside the function definition. This means it will print - `Second!` followed by `Third!` -4. JS sees there is no more code to be run inside of `callMe`, so it "jumps" - back to where we originally called `callMe()` -5. JS will continue evaluating in order and print `Fourth!` - -### An average example - -So a declared function is "saved for later use", and will be executed later, -when it is called, also known as being **invoked**. So thinking back to our -average function we can declare the function and then _invoke_ it. - -When we specify what data to use for a function call, we refer to that process -**passing arguments to the function**. - -```js -// this is a function definition -function average(number1, number2) { - return (number1 + number2) / 2; -} - -// this is a function call with the arguments being 15 & 3 -> average(15, 3) -9 - -// this is a function call with the arguments being 5 & 5 -> average(10, 5) -7.5 -``` - -When we call the function `average(15, 3)`, we run the code inside the -_definition_ for `average`. That is, we plug in the parameters with real numbers -(`number1` becomes `10` and `number2` becomes 16). Think of `number1` and -`number2` as _variables_ that contain the values we pass in when we called the -function. Then we proceed by running the code inside the function. The parameter -names `number1` and `number2` used through the body of the function and behave -like variables. - -## Returning a value - -Now that we know how functions are declared and invoked let's talk about the -inside of the function. We'll start with a statement: _Every function in -JavaScript returns `undefined` unless otherwise specified._ - -Now what does that mean? We'll start with a simple example: - -```js -function sayNumber(number) { - console.log(number); -} - -> sayNumber(1); // prints 1 -1 -undefined -``` - -So what happened there? Let's do a quick step by step: - -1. We declared the `sayNumber` function -2. `sayNumber` was called handing in the argument of 1 -3. The `number` parameter is printed to the console -4. Then the function ends without encountering a `return` statement. Since - nothing was specifically returned then the function returned the default - value for a function which is `undefined`. - -Now let's change our above example to use the keyword `return` to return a -value: - -```js -function sayNumber(number) { - console.log(number); - return true; -} - -> sayNumber(1); -1 // sayNumber still prints 1 -true // but now sayNumber returns as true -``` - -Let's go back to our previous `average` function and talk about the `return` we -used there: - -```js -function average(number1, number2) { - return (number1 + number2) / 2; -} - -// the function call for average(10, 16) will return 13 -// so the result variable will be set to 13 -let result = average(10, 16); - -// if we want to check what a function returns we can do this: -console.log(result); // prints `13` - -// we could alternatively do this: -console.log(average(10, 16)); -``` - -When we _call_ a function, we jump to the function definition and run the code -inside. When we hit a `return` statement, we immediately **exit** the function, -jump back to where we _called_ the function, and evaluate the function call to -the value it _returned_. - -**Every function call evaluates to it's return value!** In other words, the -expression `average(10, 16)` evaluates to `13` just like how the expression -`1 + 1` evaluates to `2`. - -Another important rule of the return statement is that it stops function -execution immediately. This means that any code after a `return` will not be -executed! - -```js -function average(number1, number2) { - let sum = number1 + number2; - return sum; - // anything under the first return will not be executed - console.log("this will not run") - return false; -} - - // when the first return is encountered the entire function will return a value -> average(2, 7); -9 -``` - -So the three things to remember about return statements is: - -1. Every function call evaluates to it's return value. -2. Every function in JavaScript returns `undefined` unless a `return` is - specified -3. Once a `return` statement is encountered the function will immediately stop - and return the value, ignoring any code below the `return` statement. - -## The importance of naming - -A quick but very important side note about good naming. Take this to heart right -now: **Good names are important**. Do yourself, and every other programmer -reading your code, a favor by always using significant function and variable -names. - -For example, `x` is a very non-descriptive name for a variable or function. As -we tackle more complicated problems and our code grows to be more complex, we -are likely to forget what badly named variables originally stood for and what -their purpose was. Non-descriptive names make our code error-prone. **Great code -reads like English and almost explains itself.** As programmers, our goal is to -write code that is not only "correct", but also elegant, readable, and -maintainable! Hold yourself to this high standard. - -As far as syntax goes in JavaScript we always name our functions and variables -`camelCase` for multiple words. (Ex: `tipCalculator`, `currentNumber`, -`puppyPartyFinder`). Other languages use other conventions so it's best to pick -up the standard for your chosen language and stick with it. - -## Review - -By writing a function we can reuse code over and over again to solve similar -problems with different input data (arguments). This will make your life easier -and allow you to start working on more complex problems. - -This reading covered: - -- How to define and invoke a function in JavaScript. -- How to use the `return` keyword to return a value from a function. -- Writing readable JavaScript code by using significant names and following - `camelCase` conventions for multiple word variables and functions - -________________________________________________________________________________ -# Parameters and Arguments - -When talking about functions one of the first things we mentioned was the word -_parameters_. In this reading we will be covering what exactly a parameter is - -as well as the differentiation between _parameters_ and _arguments_. - -When you finish this reading, you should be able to: - -1. Identify the difference between parameters and arguments. -2. Write a function that utilizes declared parameters. -3. Invoking a function with passed in arguments. - -## The difference between Parameters and Arguments - -Let's start off by talking about the difference between _arguments_ and -_parameters_ and how to identify which is which. - -1. **Parameters** are comma separated variables specified as part of a - function's declaration. -2. **Arguments** are values passed to the function when it is invoked. - -So by defining _parameters_ when we declare our function we are effectively -setting accessible variables within the function: - -```js -function add(firstParameter, secondParameter) { - console.log(firstParameter + secondParameter); -} - -// the add function declares two parameters -> add(1, 2); //=> 3 -``` - -In the above example we declared our parameters when we declared our function. -Now _arguments_ work slightly differently - when the function is invoked we are -passing in _arguments_. So in the above example when we invoked `add(1, 2)` the -`(1,2)` were the _arguments_ being passed in. So when a function is invoked the -value of the declared parameters is assigned to the passed in _arguments_. - -You can think of it _parameters_ and _arguments_ like a recipe. A recipe is a -list of ingredients (_parameters_) and list of steps (the code to be run). When -someone cooks the recipe (_invokes_ the function) they add the ingredients they -actually have(_arguments_). The result of cooking the recipe is the delicious -`return` value! - -### Extra arguments - -In JavaScript a function will not throw an error if the number of _arguments_ -passed during a function invocation is different than the number of parameters -listed during function declaration. This is very important to know! - -Let's use the above function to demonstrate: - -```js -function add(firstParameter, secondParameter) { - console.log(firstParameter + secondParameter); -} - -// this will ignore the 17 & 14 -// the first two arguments passed in will be assigned to the first two parameters -> add(1, 2, 17, 14); //=> 3 -``` - -Notice in the above example we passed in 4 arguments (1, 2, 17, 14) to `add`. -Since the function was only looking for two parameters that is all it uses. - -### Not enough arguments - -Now what happens if we pass in less arguments then needed? - -```js -function add(firstParameter, secondParameter) { - console.log(firstParameter + secondParameter); -} - -> add(5); //=> NaN -``` - -Whoa what happened there? Let's do a play-by-play: - -1. `firstParameter` was set to equal the first passed in argument which in the - above case is 5. -2. Since there is no second argument then `secondParameter` is declared as a - variable but is set to the default value of `undefined`. -3. The function then tries to add 5 to `undefined` which is definitely not a - number! So we get `NaN` (which means `Not A Number`) printed to the console. - -As you write more functions you'll grow very comfortable using both arguments -and parameters to accomplish your function's goal. - -## Review - -- Parameters are variables defined as a part of a function's declaration. -- Arguments are values passed to the function when it is invoked. -- JavaScript functions can intake a different number of arguments than the - number of parameters listed during function declaration. - -________________________________________________________________________________ -# WEEK-01 DAY-2
*Control Flow* {ignore=true} -________________________________________________________________________________ -# Control Flow and Array Learning Objectives - -Below is a complete list of the terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Define a function that accepts a sentence string and two words as args. The - function should return a boolean indicating if the sentence includes either - word. -2. Identify a pair of mutually exclusive conditions -3. Given a for loop, translate it into a while loop, and vice-versa -4. Write a function that iterates through a provided string argument -5. Given a description of pig latin, write a function that takes in a string - argument and utilizes String#slice to translate the string into pig latin. -6. Write a function that takes in an array of words and a string as arguments - and returns a boolean indicating whether the string is located inside of the - array. The function must use Array#indexOf. -7. Define that an array literal is an ordered list of values defined by using - bracket and individual values are read by indexing. -8. Prevent code that can throw an exception from causing the program to crash. the terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Define a function that accepts a sentence string and two words as args. The - function should return a boolean indicating if the sentence includes either - word. -2. Identify a pair of mutually exclusive conditions -3. Given a for loop, translate it into a while loop, and vice-versa -4. Write a function that iterates through a provided string argument -5. Given a description of pig latin, write a function that takes in a string - argument and utilizes String#slice to translate the string into pig latin. -6. Write a function that takes in an array of words and a string as arguments - and returns a boolean indicating whether the string is located inside of the - array. The function must use Array#indexOf. -7. Define that an array literal is an ordered list of values defined by using - bracket and individual values are read by indexing. -8. Prevent code that can throw an exception from causing the program to crash. - -________________________________________________________________________________ -# Control Flow - Conditional Statements - -So far the code you've written has been pretty direct in it's intent. You can -define functions and variables but, so far the functions you've created haven't -been able to do that much for you _yet_. It's time to start writing functions -that can do things _conditionally_ by utilizing _control flow_. - -In simple terms - **control flow** is the order in which instructions are -executed within a program. One modifies control flow using _control structures_, -expressions that alter the control flow based on given parameters. The control -structures within JavaScript allow the program flow to change within a unit of -code or a function. - -This reading will be covering one of the two main _control structures_ you -will use time and time again - _Conditional statements_. _Conditional -statements_ are used to perform different actions based on different conditions. - -When you finish this reading, you should be able to: - -- Write `if`, `else if`, `if...else` conditional statements. -- Know that conditional statements can have only one `if` and one `else` - statement. -- Identify that conditional statements can be nested. - -## A Quick Word on Syntax - -Before we get started we'll quickly go over the terms we'll be using to -represent syntax. - -1. `[ ]` are square **brackets** -2. `{ }` are curly **braces** -3. `( )` are **parentheses** - -## Writing Conditional Statements - -Conditional Statements are the second fundamental _control structure_ for -writing JavaScript and are pretty straight forward. The simplest conditional -statement is the `if` statement. An `if` statement has two parts, the _test -expression_ (the code that immediately follows the `if` which goes in -parentheses), and the _then expression_ (this code belongs in braces after the -`if` expression). The _then_ expression will only run when the `if` expression -is truthy. - -Here is an example of a simple `if` statement: - -```js -// this is the test expression -if (3 === 3) { - // this is the then expression - // this code will run if the above statement is true - console.log("this is a three!"); -} -``` - -The `if` statement above allows you to specify what should happen if your -particular expression evaluates to true. You can chain additional _test -expressions_ onto this `if` statement by using a `else if` statement. - -The syntax for `else if` is very similar as an `if` statement: - -```js -function mathFun() { - let x = 2 + 3; - - if (x === 3) { - console.log("we have a 3"); - } else if (x === 4) { - // this code will run if the above statement is true - console.log("we have a 4"); - } else if (x === 5) { - // this code will run if the above statement is true - console.log("we have a 5"); - } -}; - -mathFun(); // => "we have a 5" -``` - -The `else if` and `if` statements do not, however, provide the option to specify -something else that should happen in the event that all of the above expressions -evaluate to be `falsey`. The `if...else` statement reads just like English. The -JS interpreter will execute the `else` statement if all the above conditions -given are `falsey`. See below for an example: - -```js -function mathFun() { - let x = 19; - if (x === 3) { - console.log("we have a 3"); - } else if (x === 4) { - console.log("we have a 4"); - } else { - console.log("I will return if everything above me is falsey!"); - } -}; - -mathFun(); // => "I will return if everything above me is falsey!" -``` - -You can chain an arbitrary number of `else if` statements but there can only be -one `if` statement and one optional `else` statement. The `if` introduces the control -structure and the `else` acts as a fail safe to catch everything that didn't -meet the above conditions. - -Only one _then expression_ is ever executed in an `if`, `if...else`, or -`if...else` statement. If one of the _test expressions_ is truthy, then the -result of its _then expression_ is the result of the **entire** conditional -statement: - -```js -let x = 3; -if (x === 3) { - console.log("this will run"); -} else { - console.log("this will not run"); -} -``` - -Additionally, you can nest conditional statements within each other but it will -get hard to read pretty quickly and is discouraged: - -```js -function mathFun(x) { - if (x === "math") { - if (x === "math" && x[0] === "m") { - if (x[1] === "a") { - console.log("this got confusing fast"); - } else { - console.log("that is not math!"); - } - } else { - console.log("that is for sure not math!"); - } - } else { - console.log("I will return if everything above me is false!"); - } -}; - -mathFun("math"); // => "this got confusing fast" -``` - -## Review - -- Conditional statements allow us to control what actions should be taken based - on a boolean (truthy or falsey) expression -- In a chain of _then expressions_ (`if...else if...else`), only one of the - _then expressions_ will be executed. -- Conditional statements can have only one `if` and one `else` statement. -- Conditional statements can be nested. - -________________________________________________________________________________ -# Mutually Exclusive Conditions - -You have now learned how to write conditional statements. Now we'll talk a -little bit more about how to write them using best practices. - -When you finish this reading, you should be able to: - -- Identify a pair of mutually exclusive conditions. - -## When to use if statements - -Say you are given the challenge to write a function that that will call another -function named `bigNumber` if the given argument is **greater** than 100 or call -a function named `smallNumber` if it the given argument is smaller. You could -write a function to do that which would look like this: - -```js -function numberSeparator(number) { - if (number < 100) { - // number is smaller than 100 so we invoke smallNumber - smallNumber(); - } - if (number === 100) { - // number is equal to 100 so we invoke smallNumber - smallNumber(); - } - if (number > 100) { - // number is larger than 100 so we invoke bigNumber - bigNumber(); - } -} -``` - -As you can probably tell the above function uses a lot of code to do a simple -task. To be clear the function above would work for our aim - but it repeats -itself. There is an age old principal for writing good code named **DRY** or -**Don't repeat yourself**. As good programmers we always want our code to be -clear, concise, and efficient. - -A general rule of thumb is that if you are working with a condition that is -**mutually exclusive**, meaning if one condition is true the other condition -must be false, then you should use an `if/else` statement. You can also think of -**mutually exclusivity** like a coin flip - it can be either heads or tails but -not both. - -Going back to the original problem at hand we can see it makes intuitive sense -with the way the challenge is phrased: If the number is larger than 100 then -we'll call `bigNumber`, otherwise we invoke is `smallNumber`. - -So let's rewrite the above function to read a little more clearly: - -```js -function numberSeparator(number) { - if (number > 100) { - bigNumber(); - } else { - smallNumber(); - } -} - -// this also works -function numberSeparator(number) { - if (number <= 100) { - smallNumber(); - } else { - bigNumber(); - } -} -``` - -Look at how much clearer that is! Writing good code is an art - devote yourself -to becoming an artist! - -## Review - -- How to identify a pair of mutually exclusive conditions. -- DRY - don't repeat yourself! - -________________________________________________________________________________ -# Control Flow - Looping - -A quick reminder before we start - **control flow** is the order in which -instructions are executed within a program. One modifies control flow using -_control structures_, expressions that alter the control flow based on given -parameters. This reading will be covering the second of the main _control -structures_ you will use time and time again - _loops_. - -When you finish this reading, you should be able to: - -1. Know how to write a `while` loop and a `for` loop. - - Know how to convert a `for` loop into a `while` loop -2. Know that index variables conventionally start at zero. -3. Explain what an _iteration_ is. - -## Looping - -Imagine you are at a friend's house and your friend has six dogs. Someone left -the back gate open and all the dogs go out in the yard and get super muddy. Now -your friend wants to clean their dogs but they only have one bathtub! You can't -wash all the dogs at once. So the only option is to give the dogs a bath one at -a time until they are all clean. When you start 0 dogs are clean and 6 dogs are -dirty. - -_While_ there are still dirty dogs you still have a job to do. That is your -**condition** - you will stop giving baths once all 6 dogs are clean. So after -one bath you you have 1 clean dog and 5 dirty dogs. You've -_incremented_(increased by one) your number of clean dogs. After each bath you -check your **condition** again until you have 6 clean dogs so you know you can -stop! - -What we've described above is the idea of looping - setting a condition, -executing an action, doing something to make sure our condition will be met -eventually, and rechecking our condition before executing our next action. - -Loops are a fundamental _control structure_ for writing JavaScript. -Loops will repeatedly execute a section of code while a condition is true. Loops -are simple to write and incredibly powerful! There are many variations of loop -but we will be covering the two most fundamental loops now - **while** loops and -**for** loops. - -### While Loops - -One of the simplest loops in `JavaScript` is the `while` loop. As with all -loops, the `while` loop will execute a block of code as long as a specified -condition is true. The while loop starts with the keyword `while` then states a -condition in parentheses. The code in the following braces will be run until the -above condition is met. - -```js -while (condition) { - // code block to be executed -} -``` - -In the following example, the code in the loop will run, over and over again, as -long as a variable (`index`) is less than 10: - -```js -let index = 0; - -// this is the condition that will be checked every time this loop is run -while (index < 10) { - console.log("The number is " + index); - // this is common shorthand for index = index + 1 - index++; -} -``` - -The most important thing to remember when writing any loop is to always be -working towards your condition. In the example above if we did not increment the -`index` variable by 1 each time the loop ran then we would be stuck with what we -call an **infinite loop**: - -```js -let index = 0; - -// this is an infinite loop because our condition will never be met -while (index < 10) { - console.log("The number is " + index); - // if we do not increase the index then our condition is never met - // Meaning this will run forever! -} -``` - -The above code will run until whatever interpreter you are using crashes. - -### Important Loop Knowledge - -A quick word before we learn about the next loop. - -The _index_ is the traditional word for the variable that keeps track of how -many times the loop has been run. Don't write loops with indices starting at -one; you'll confuse other programmers and yourself. Indices have started at zero -for a long time, and for good reason. It's much easier to use loops that start -with an index of zero because Array and String indices also start at zero. - -```js -let array = [0, 1, 2]; -let index = 0; - -while (index < array.length) { - console.log( - "Both the index and the current array position are " + array[index] - ); - index++; -} -``` - -In the above code we will do one loop for each digit in the Array above. We call -each of those loops an "iteration". An iteration is the act of repeating a -procedure, hence looping is an **iterative** technique. Each repetition itself -is also called an "iteration." So you can use loops to _iterate_ through Arrays -and Strings. - -### For Loops - -A `for` loop can be broken down into three sections: - -1. The _initial expression_ which will be run once at the beginning of the loop. -2. The _condition_ which is checked every time the loop is run. If this - condition is true the loop will run again. If this condition is false the - loop will end. -3. The _loopEnd expression_ which will be run at the end of the loop before - checking the _condition_ again. - -```js -for (;;) -``` - -The `for` loop is usually used with an integer counter: - -```js -for (let index = 0; index < 10; index += 1) { - // the code inside this block will run 10 times -} -``` - -While the _loopEnd expression_ is normally used to increase a variable by one -per loop iteration, it can contain any statement, such as one that decreasing -the counter, or increasing it by 2. - -You can use the `for` loop to iterate through all kinds of things. Check out the -example below for how to iterate through a String: - -```js -let testString = "testing"; - -// we can use the testString's length as our condition! -// Since we know the testString's index starts at 0 -// and our index starts at 0 we can access each letter: -for (let index = 0; index < testString.length; index += 1) { - let letter = testString[index]; - console.log(letter); -} -``` - -These are the most basic types of loops. If all else fails, you can always fall -back on these two loops. All the other loop forms are just more convenient forms -of these basic loop styles. - -## Translating From One Loop to Another - -So far we have covered both `while` and `for` loops. Once you understand the -concept of looping it's easy to translate one loop to another: - -```js -// these two do the exact same thing! -function forLoopDoubler (array) { - // it is convention to shorten index to just i in most cases - for (let i = 0; i < array.length; i++) { - array[i] = array[i] * 2; - } - return array; -}; - -function forLoopDoubler (array) { - let i = 0; - while (i < array.length) { - array[i] = array[i] * 2; - i++; - } - return array; -}; - -forLoopDoubler([1, 2, 3]); // => [2,4,6] -whileLoopDoubler([1, 2, 3]); //=> [2,4,6] -``` - -## Review - -- We can use a `for` or `while` loop to repeat a block of code repeatedly. -- While the loop condition is true, we will execute another iteration of the - loop. -- When the loop condition is false, we will exit the loop. - -________________________________________________________________________________ -# The Array Type - -This reading will be about one of JavaScript's global objects, the **Array** -type. JavaScript arrays are used to store multiple values all within a single -structure, much like a creating a list. Arrays can hold strings, integers and -even other arrays! Arrays are incredibly useful for holding a bunch of different -information all in one place. - -When you finish this reading, you should be able to: - -- Write arrays using correct syntax -- Identify that an array is an ordered list of values defined by using brackets -- Use `.length` to obtain a count of the numbers of elements that comprise an - array -- Index an array to refer to a single value -- Concatenate multiple arrays together - -## Using arrays - -While coding you will find that you often find yourself needing to refer to a -bunch of data at once. For instance, what if you wanted to refer to the entire -English alphabet. Sure, you could create a bunch variables for each letter in -the alphabet: - -```js -let a = "a"; -let b = "b"; -let c = "c"; -let d = "d"; -// and so on for way too long... -``` - -However this becomes cumbersome and unmanageable quickly. An Array is a data -structure that solves this problem. Arrays are always wrapped in square -brackets, `[]`, and store their comma separated values in sequential order. -Arrays in JavaScript are also very flexible: we can put elements into an array, -replace elements in an array, and remove elements from the array. - -So going back to our first example of containing the alphabet: - -```js -let alphabet = [ - "a", "b", "c", "d", "e", "f", - "g", "h", "i", "j", "k", "l", - "m", "n", "o", "p", "q", "r", - "s", "t", "u", "v", "w", "x", - "y", "z" -]; -``` - -## Indexing arrays - -### Calculating the length of an array - -Since an array can container any number of values you will find it useful to -count the number of values available to you using `.length`: - -```js -console.log([4, 7, 9].length); // => 3 -console.log([1, 2].length); // => 2 -console.log([].length); // => 0 -``` - -### Properly indexing an array - -Arrays consist of multiple values all stored in sequential order. These value -are numbered by **indices** starting at 0 (just like indexing a string!). So -given the below example: - -```js -let numbersAndLetters = ["b", "z", 17, "cat"]; -``` - -In the above `numbersAndLetters` array if we access `numbersAndLetters` at the -index of 0 we get back the value of "b". If we access `numbersAndLetters` at the -index of 1 we get "z", at the index of 3 we get 17, etc. We can specify which -value we'd like to access in an array by using square brackets,`[]`, and -specifying an index: - -```js -console.log(numbersAndLetters[0]); // => "b" -console.log(numbersAndLetters[1]); // => "z" -console.log(numbersAndLetters[2]); // => 17 -console.log(numbersAndLetters[3]); // => "cat" -``` - -Notice that even though the index at `numbersAndLetters[3]` has the value of a -string with multiple characters ("cat") we return the _entire value_ listed at -that index. - -**Reminder:** Arrays **always** start at the index of 0, not 1. This is the -convention in programming. Additionally, indices should always be a number. - -We can access a value in an array directly by providing an index for the value -we'd like to access in that array (`array[index]`). See below for an example: - -```js -console.log(["a", "b", "c"][0]); // => "a" -console.log(["a", "b", "c"][1]); // => "b" -console.log(["a", "b", "c"][2]); // => "c" -console.log(["a", "b", "c"][3]); // => `undefined` -``` - -As we see in the code above, if we try to access an element at an index that is -not inside the array, we get back `undefined`. This makes sense because there is -no value at that given position! - -### The classic "off by one" error - -Arrays are similar to strings in that both of their indices start at 0 instead -of 1. Forgetting this fact can lead to some pretty confusing situations. Let's -focus on an important distinction: the index of the last value of an array is -always one less than its length. - -```javascript -console.log([4, 7, 9].length); // => 3 -console.log([4, 7, 9][3]); // => undefined -console.log([4, 7, 9][2]); // => 9 -``` - -In other words, although the `length` of `[4, 7, 9]` is 3, the index of the last -value (`9`) is 2. A good rule of thumb of accessing the last index of an array -is to find the length and then subtract one: - -```js -let testArray = [4, 7, 9]; -let finalIndex = testArray.length - 1; // => (3 - 1) = 2 -console.log(testArray[finalIndex]); // => 9 -``` - -## Working with arrays - -### Containing data in arrays - -By packaging groups of related data into a single array, we gain the added -benefit of being able to refer to that data as a single collection. Arrays don't -have to just hold single characters- they are capable of holding entire strings, -numbers, and even other arrays! - -```js -let wackyArray = [2, 17, "apple", "cat", ["apple"]]; - -console.log(wackyArray[0]); // => 2 -console.log(wackyArray[1]); // => 17 -console.log(wackyArray[3]); // => "cat" -console.log(wackyArray[4]); // => ["apple"] -``` - -Just think of all the possibilities of what you can store in a single array! -However, just because you can _doesn't_ mean you should. In practice we will -almost always be storing similar kinds of data, that are coming from a common -source (i.e. items in a shopping list, ID numbers, tasks on a todo list). - -### Using indexOf with arrays - -We can also calculate the index of a given value within an array by using -`indexOf`: - -```javascript -console.log([1, 3, 5, "apple", "jet"].indexOf(3)); // => 1 -console.log([1, 3, 5, "apple", "jet"].indexOf(5)); // => 2 -console.log([1, 3, 5, "apple", "jet"].indexOf("jet")); // => 4 - -// this won't be found in the array -console.log([1, 3, 5, "apple", "jet"].indexOf("potato")); // => -1 -``` - -If we attempt to search for a value that is **not** present in an array, -`indexOf` will return -1. This makes sense because we know that -1 is not a -valid array index. The smallest index possible is 0! - -## Concatenation with arrays - -As a reminder, concatenation is just a fancy word for joining things together -into a single collection. Now, this is where arrays will differ from strings. -The `+` operator only exists for numbers and strings. If you try to use the `+` -on an array it will try to help you out by _converting your arrays into -strings_. - -```js -console.log([1, 2, 3] + [4, 5, 6]); // => 1,2,34,5,6 -``` - -JavaScript was just trying to help! However that is probably not what you meant -to do. Good thing JavaScript has a seperate method for putting two array -together. To concatenate arrays, we can use the aptly named `.concat` method: - -```javascript -console.log([1, 2, 3].concat([4, 5, 6])); // => [1, 2, 3, 4, 5, 6] -``` - -## Remember - -- An **Array** is a data type that contains a list of in order values surrounded - in square brackets `[]`. -- `array.length` returns the number of values in the `array`. -- Each value of an array is associated with a number index; the first value of - an array is at the index of 0. -- We can use `array.indexOf(value)` to obtain the index of `value` within - `array`; if `value` is not found, then -1 is returned. -- We can use `.concat` to concatenate multiple arrays, combining them into a - single array. - -________________________________________________________________________________ -# WEEK-01 DAY-3
*Intermediate Functions* {ignore=true} -________________________________________________________________________________ -# Intermediate Functions Learning Objectives - -Below is a complete list of the terminal learning objectives across all -"Intermediate Function" lessons. When you complete these lessons, you should be -able to perform each of the following objectives. These objectives capture how -you may be evaluated on the assessment for these lessons. - -1. Identify that strings are immutable and arrays are mutable -2. Define a function using both function declaration and function expression - syntax -3. Utilize Array#push, #pop, #shift, #unshift to mutate an array -4. List the arguments that can be used with Array#splice -5. Write a function that sums up elements of an array, given an array of numbers - as an argument -6. Utilize Array#forEach, #map, #filter, #reduce in a function -7. Define a function that takes in an array of numbers and returns a new array - containing only the primes -8. Define a function that takes in a 2D array of numbers and returns the total - sum of all elements in the array -9. Define a function that takes in an array of elements and returns a 2d array - where the subarrays represent unique pairs of elements -10. Define a function that takes in an array of numbers as an argument and - returns the smallest value in the array; if the array is empty return null the terminal learning objectives across all -"Intermediate Function" lessons. When you complete these lessons, you should be -able to perform each of the following objectives. These objectives capture how -you may be evaluated on the assessment for these lessons. - -1. Identify that strings are immutable and arrays are mutable -2. Define a function using both function declaration and function expression - syntax -3. Utilize Array#push, #pop, #shift, #unshift to mutate an array -4. List the arguments that can be used with Array#splice -5. Write a function that sums up elements of an array, given an array of numbers - as an argument -6. Utilize Array#forEach, #map, #filter, #reduce in a function -7. Define a function that takes in an array of numbers and returns a new array - containing only the primes -8. Define a function that takes in a 2D array of numbers and returns the total - sum of all elements in the array -9. Define a function that takes in an array of elements and returns a 2d array - where the subarrays represent unique pairs of elements -10. Define a function that takes in an array of numbers as an argument and - returns the smallest value in the array; if the array is empty return null - -________________________________________________________________________________ -# Function Expressions - -You may have noticed that we've been writing many functions so far in the -course! We will continue to do so since functions are the building blocks of the -eventual applications that we will build. That being said, let's begin to -broaden the way we think about functions. In particular, we'll want think of -functions as expressions that we can store in variables - just like our classic -data types of number, string, boolean, array, and object! - -When you finish this article, you should be able to: - -- identify functions as first-class objects in JavaScript -- define a function using function expression syntax - -## Functions as first-class objects - -JavaScript is well known for being a programming language that treats functions -as "first-class objects". This fancy talk means that you can treat a function as -a "normal" value by storing it in a variable. We'll leverage this key concept in -very clever ways later in the course. For now, let's begin with a simple example -that shows the "first-class object" nature of functions: - -```javascript -let calculateAverage = function(a, b) { - return (a + b) / 2; -}; - -console.log(calculateAverage(10, 20)); // 15 -``` - -In the code snippet above, we define the `calculateAverage` by assigning a -variable to contain the function's definition. By doing this, the variable's -name is effectively the function's name. So to call the function, we simply -refer to the variable name. Note that we do not write the function's name after -the `function` keyword, where we normally would. We will refer to this new way -of defining functions as _function expression syntax_ and the classic way of -defining functions as _function declaration syntax_. In general, we can define -functions using either syntax: - -```javascript -// function declaration syntax -function myFunctionName(arg1, arg2) {} - -// function expression syntax -let myFunctionName = function(arg1, arg2) {}; -``` - -In the coming sections, we'll highlight moments when we'll prefer one syntax -over the other. For now, get acquainted with the new syntax as it is something -you'll be seeing a lot of as a programmer! - -### A peek under the hood - -Perhaps you're finding it tough to understand what it means for a variable to -contain a function - it is indeed a very abstract idea for new programmers. -Let's draw a comparison. We know that when we assign an expression to variable, -the expression first evaluates to a single value, which we then store in the -variable name: - -```javascript -let myNum = 4 + 4; -console.log(myNum); // prints 8 -console.log(myNum * 3); // prints 24 -``` - -In the same way we can treat a function definition as an expression that -evaluates! - -```javascript -let myFunc = function() { - console.log("I'm a function"); -}; - -console.log(myFunc); // prints [Function: myFunc] -myFunc(); // prints "I'm a function" -``` - -Looking at the snippet immediately above, you'll notice that when we print the -`myFunc` variable directly, without calling the function with parentheses, -JavaScript simply says the variable contains a function named myFunc -(`[Function: myFunc]`). You can truly imagine a function as a value that we can -store and use as we please. - -> The term _anonymous function_ may also be used to describe a function -> expression before it is assigned to any variable. Following the example above, -> we'll use the word _anonymous function_ to describe the function expression -> _before_ the assignment to the `myFunc` variable is complete. Once the -> assignment is complete, it would be silly to refer to `myFunc` as an -> `anonymous function` because an _anonymous function_ has no name. - -## Remember - -- functions can be stored in variables; just like any other values in - JavaScript! - -________________________________________________________________________________ -# Two-Dimensional Arrays (2D Arrays) - -Time to broaden our understanding of arrays! We've already explore the -fundamentals of arrays. Mainly, we can store any type of data we please as -elements of an array and even mix types together. However, what happens if we -store an array as an element of an array? - -When you finish this article, you should be able to: - -- index into the inner elements of a 2D array -- use nested loops to iterate through a 2D array - -## Multidimensional Arrays - -When we store arrays as elements of other arrays, we refer to those structures -as multidimensional arrays. If the "depth" of the nested arrays is at exactly 2 (an -outer array containing inner arrays), then we'll refer to it as a -two-dimensional array: - -```javascript -let twoDimensional = [["a", "b", "c"], ["d", "e"], ["f", "g", "h"]]; - -console.log(twoDimensional[1]); // [ 'd', 'e' ] -console.log(twoDimensional[1][0]); // 'd' - -let subArr = twoDimensional[1]; -console.log(subArr[0]); // 'd' -``` - -Note that indexing the outer `twoDimensional` array will return an element like -usual, it's just that element happens to be another array. To gain access to the -innermost elements, we simply need to apply another set of indexing brackets! - -If we style our 2D arrays nicely so that each subarray is on a new line, we can -interpret the double indices as `[row][column]`: - -```javascript -let twoDimensional = [ - ["a", "b", "c"], - ["d", "e"], - ["f", "g", "h"]]; - -// get the element in the 0th row, 2nd col: -console.log(twoDimensional[0][2]); // 'c' -``` - -## Iterating through 2D Arrays - -Since a 2D array is just an array of arrays. We'll need to use a loop within a -loop to iterate through a 2D array: - -```javascript -let array = [["a", "b", "c"], ["d", "e"], ["f", "g", "h"]]; - -for (let i = 0; i < array.length; i++) { - let subArray = array[i]; - console.log(subArray); - - for (let j = 0; j < subArray.length; j++) { - console.log(subArray[j]); - } -} -``` - -In the nested loops above, the `i` index refers to the current "row" and the `j` -index refers to the current "column". It's worth noting that since the inner -subArrays have different length, we'll want to specifically reference the length -of that subarray in our inner loop condition `j < subArray.length`. The code -above will print: - -```plaintext -[ 'a', 'b', 'c' ] -a -b -c -[ 'd', 'e' ] -d -e -[ 'f', 'g', 'h' ] -f -g -h -``` - -## When is a 2D array practical? - -As a preview of things to come let's briefly mention when you'll find a 2D array -useful in your future projects. Imagine how'd you represent a "grid": - -- tic-tac-toe (3x3 grid) -- chess (8x8 grid) -- sudoku (9x9 grid) -- excel (a sheet is an arbitrarily sized 2D array) - -## Remember - -- an array can contain arrays as elements, we call this a 2D arrays -- to iterate through a 2D array, used nested loops - -________________________________________________________________________________ -# Mutability in JavaScript - -So far in the course we've explored a handful of methods that manipulate data. -We'll be growing our arsenal of methods further overtime, so we'll want to gain -awareness for **exactly** how we should expect these methods to manipulate the -data we give them. To this end, let's analyze which methods will modify existing -data and which methods do not. We refer to this concept as **mutability**. - -When you finish this article, you should be able to: - -- Explain what "mutability" is -- Correctly label JavaScript data types as immutable or mutable - -## What is mutability? - -At its face value, _mutability_ is a simple concept. You may be familiar with -the word _mutation_, which refers to a alteration (usually in DNA). Something -that is _mutable_ can be changed, while something that is _immutable_ is -unchanging and permanent. To illustrate this concept, we'll begin with strings -and arrays. We've spent some time with these two data types and by now we -recognize that the two types share many similarities. Both have indices, -`length`, and even share common methods like `slice`. However, they differ -greatly in their mutability: - -```javascript -let myArr = ["b", "e", "a", "m"]; -myArr[0] = "s"; -console.log(myArr); // 'seam' - -let myStr = "beam"; -myStr[0] = "s"; -console.log(myStr); // 'beam' -``` - -Above we have shown that we can assign a new element to an index of an array, -but we cannot assign a new character to an index of a string. In other words, -arrays are _mutable_, but strings are _immutable_. - -An implication of this discovery is that there are _some_ array methods that -will modify an existing array but _zero_ methods that will modify an existing -string. Methods that manipulate string data typically return a _new_ string and -never modify an existing one. A prime example is `toUpperCase`: - -```javascript -let word = "piñata"; -let newWord = word.toUpperCase(); -console.log(word); // 'piñata' -console.log(newWord); // 'PIÑATA' -``` - -Above, notice that the `toUpperCase` method returns a capitalized version of the -string, but does not change the original string. It's also worth noting that not -every array method will mutate. For example, the `slice` method does not mutate -for both strings and arrays. As we learn about methods in the future, we'll be -certain to note what mutates and what does not. - -## Mutable or immutable, that is the question - -Now that we have a grasp of _mutability_, let's take inventory and identify -JavaScript's data types as mutable or immutable. - -**Mutable** - -- array -- object (we'll learn these soon) - -**Immutable** - -- number -- string -- boolean - -A quick way to remember the above list is to identify that the composite types -(the types that can contain multiple values) of array and object are mutable. -The remaining "simpler" types of number, string, and boolean are immutable. - -## The mutability misconception - -Maybe you are having a tough time believing what we have just claimed. We don't -blame you, you've probably heard the saying that change is the only constant in -the universe. Let's debunk a common argument to turn you into a believer. The -skeptical programmer may use this as an argument to show that numbers are -mutable: - -```javascript -let myNum = 42; -myNum += 8; -console.log(myNum); // 50 -``` - -Because the `myNum` variable now contains `50` where it once contained `42`, it -may seem we have mutated the number, but this is not truly the case. Recall that -`myNum += 8` is shorthand for `myNum = myNum + 8`. Since the right hand side of -the assignment evaluates first, we are simply taking the new number of `50` and -reassigning it to the `myNum` variable. This reassignment of a variable name is -not a mutation of the original number. - -## Remember - -- data types that can be changed are mutable, those that cannot be changed are - immutable -- arrays and objects are mutable -- numbers, strings, and booleans are immutable - -________________________________________________________________________________ -# Array Splice - -Time to a learn yet another array method! The [Array#splice][mdn-splice] method -deserves its own reading because of how versatile it is. Feel free to use this -article as a quick reference; let's jump right in. - -When you finish reading this article, you should be able to: - -- list all possible arguments that can be used with the `Array#splice` method - -## Notation - -For clarity in this article and moving forward in the course, we'll be notating -methods with `#` to clarify how they should be called. For example, -`Array#splice` refers to the method that should be called on an array, -`arr.splice()` where `arr` is some array variable. Likewise `String#toUpperCase` -refers to the method that should be called on a string, `str.toUpperCase()` -where `str` is some string variable. We'll opt to refer to methods using this -notation because some methods can be called on multiple data types, such as -`Array#slice` and `String#slice`. - -## What can Array#splice do? - -Before we explore the nitty-gritty details of the `Array#splice` method, the -first thing to be aware of is that the method will **mutate** the array that it -is called on. That is, `Array#splice` will modify the existing array and _not_ -return a new array. - -### Using splice to remove - -The usage of the `Array#splice` method is easy to mix up because it can be used -to remove or insert elements into an array. That's right - it can perform -"opposite" operations, even at the same time! For now, we'll begin by _only_ -removing elements from an array: - -```javascript -let colors = ["red", "yellow", "blue", "green", "orange", "brown", "gray"]; -let returnVal = colors.splice(2, 3); -console.log(colors); // [ 'red', 'yellow', 'brown', 'gray' ] -console.log(returnVal); // [ 'blue', 'green', 'orange' ] -``` - -The first two arguments for splice correspond to 1) the target index and 2) how -many elements to remove. The call `colors.splice(2, 3)`, will remove the next -three elements beginning at index 2. This means that the elements at indices 2, -3, and 4 are removed. - -Note that splice returns an array containing the elements that were removed and -also has the effect of removing the elements from the _original_ array, mutating -it in-place. - -### Using splice to insert - -To use the splice method to insert new elements into an array, we can pass in -any number of additional arguments representing the values to insert: - -```javascript -let colors = ["red", "yellow", "blue"]; -let returnVal = colors.splice(1, 0, "RebeccaPurple", "CornflowerBlue"); -console.log(colors); // [ 'red', 'RebeccaPurple', 'CornflowerBlue', 'yellow', 'blue' ] -console.log(returnVal); // [] -``` - -The method call `colors.splice(1, 0, 'RebeccaPurple', 'CornflowerBlue')` -translates to "target index 1, remove the next 0 elements, then insert -`'RebeccaPurple'` and `'CornflowerBlue'`." - -### Using splice like a pro - -Naturally, we can combine these two functionalities! Say we wanted to target -index 2, remove the next 3 elements, then insert `'Gainsboro'`, `'Ivory'`, and -`'Khaki'`: - -```javascript -let colors = ["red", "yellow", "blue", "green", "black", "beige"]; -let removed = colors.splice(2, 3, "Gainsboro", "Ivory", "Khaki"); -console.log(colors); // [ 'red', 'yellow', 'Gainsboro', 'Ivory', 'Khaki', 'beige' ] -console.log(removed); // [ 'blue', 'green', 'black' ] -``` - -Bam. What a versatile method! Always feel free to reference the -[documentation][mdn-splice] for the method when you are struggling to remember -its usage: - -## Remember - -- Array#splice has two required arguments - - the target index - - the number of elements to remove beginning at that target index -- Array#splice can also take in any number of values to be inserted at the - target index - -[mdn-splice]: - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice - -________________________________________________________________________________ -# String#split and Array#join - -We've seen previously that strings and arrays share many similar properties. For -example, strings and arrays both have a `length` and can have multiple indices. -Because of this, you may find it useful to "convert" between the two types. - -When you finish this article, you should be able to: - -- use the `String#split` method to turn a string into an array -- use the `Array#join` method to turn an array into a string - -## String#split - -The [String#split][string-split-mdn] method is called on a string and accepts a -"separator" string as an argument. The method will return an array where the -elements are the resulting substrings when we cut at the "separators": - -```javascript -let sentence = "follow the yellow brick road"; -let words = sentence.split(" "); -console.log(words); // [ 'follow', 'the', 'yellow', 'brick', 'road' ] -console.log(sentence); // 'follow the yellow brick road' -``` - -Note that the original string is _not mutated_, rather a new array is returned. -A common pattern is to split a sentence string on a space (' '), but you can -split on any separator as you see fit: - -```javascript -let sentence = "follow the yellow brick road"; -console.log(sentence.split(" ")); // [ 'follow', 'the', 'yellow', 'brick', 'road' ] -console.log(sentence.split("the")); // [ 'follow ', ' yellow brick road' ] -console.log(sentence.split("o")); // [ 'f', 'll', 'w the yell', 'w brick r', 'ad' ] -``` - -A pattern you may find useful is that when you split on a separator string, it -is guaranteed that that separator will not be in the resulting array, -effectively removing it. See the example of `sentence.split('the')` above. This -may come in handy, so keep it in mind! - -## Array#join - -The [Array#join][array-join-mdn] method is called on an array and accepts a -"separator" string as an argument. The method will return a string where -elements of the array are concatenated together with the "separator" between -each element: - -```javascript -let words = ["run", "around", "the", "block"]; -let sentence = words.join(" "); -console.log(sentence); // 'run around the block' -console.log(words); // [ 'run', 'around', 'the', 'block' ] - -console.log(words.join("_")); // 'run_around_the_block' -console.log(words.join("HI")); // 'runHIaroundHItheHIblock' -``` - -`Array#join` does not mutate the original array, instead it will return a new -string. - -## A clever combination - -It's pretty evident that `String#split` and `Array#join` are "opposite" methods. -That is: - -- we use split to turn a string into a array -- we use join to turn an array into a string - -By combining these two methods we can accomplish some cool behavior: - -```javascript -let str = "I don't know what I want to eat"; -let newStr = str.split("I").join("we"); -console.log(newStr); // 'we don't know what we want to eat' -``` - -Whoa! We were able to replace every substring "I" with the substring "we". We -know that the line `str.split('I').join('we')` evaluates from left to right. -This means that the `split` will cut the string wherever there is an 'I', -leaving a gap where the 'I's were. Then, the `join` will fill those gaps with -'we's. - -## Remember - -- we can use `String#split` and `Array#join` to convert between strings and - arrays -- both methods do not mutate their input - -[string-split-mdn]: - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split -[array-join-mdn]: - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join - -________________________________________________________________________________ -# WEEK-01 DAY-5
*Control Flow* {ignore=true} -________________________________________________________________________________ -# Determining Types - -Sometimes you want to know the type of value store in a variable so that you can -safely do things with it. If your function expects an array in its parameter but -gets a number, you can't call the `map` method on that! - -In this article you will learn how to figure out if a value in a variable is - -* A string -* A number -* A function -* An array - -## The typeof operator - -Not all operators in JavaScript require two arguments like the `+` operator for -addition, the `=` for assignment, and the `%` operator for modulo division. -Those are all called _binary_ operators because they take two (bi-) operands, -or things that are operated on. - -JavaScript kindly gives you the operator `typeof` which acts on a single value. -Operators that take only one operand are called _unary_ operators because "u -only give them one value!" (That's a joke. "uni-" or "una-" is one.) - -Here are some examples of what you'd expect to see with the `typeof` operator. - -```js -let s = 'This is a string'; -console.log(typeof s); // 'string' - -let n = 6.28; -console.log(typeof n); // 'number' - -let sum = function (a, b) { - return a + b; -} -console.log(typeof sum); // 'function' -``` - -Note that the value returned from the `typeof` operator is a String data type. -So, if you want to check if a value is a number, you could do this. - -```js -if (typeof n === 'number') { - // It is a number. Do some maths! -} else { - console.log('I really wanted a number. :-('); -} -``` - -## How to tell if a value is an array - -Unfortunately, due to a _really old bug_ in the way that JavaScript works, a bug -that no one can fix because people wrote code that relies on the bug for -decades, you cannot use the `typeof` operator to figure out if something is an -array. - -```js -let a = [1, 2, 3]; -console.log(typeof a); // 'object' -``` - -Gee, JavaScript. That's not helpful. Thanks. - -Luckily, it only took 12 years for JavaScript to include a way to test if a -value is an array. To do so, you use the `Array.isArray` method like this. - -```js -let a = [1, 2, 3]; -Array.isArray(a); // true - -let n = 6.28; -Array.isArray(n); // false - -let f = function () {} -Array.isArray(f); // false -``` - -## Practical use in "real" code - -Oddly enough, you won't see a lot of code in real-world applications testing if -a value is one type or another. A lot of JavaScript functions just _assume_ that -they will get arguments of the right kind because the parameter names imply what -kind of value to pass in. For example, the following function has a parameter -named `sentence`. - -```js -function reverseTheSentence(sentence) { - // ... code here ... -} -``` - -Most developers will know that the function probably wants `sentence` to be a -string value. They just won't pass in an array or number or ... well, anything -other than a string. Because that's just not polite. They'd expect any other -kind of value to cause the `reverseTheSentence` to malfunction. Only when you -know that people that don't respect your code will use it should you add in some -kind of check like this. - -```js -function reverseTheSentence(sentence) { - if (typeof sentence !== 'string') { - // Tell the developer they are using - // the function wrong. - } - // ... code here ... -} -``` - -## Remember - -This article has shown you two ways to determine if a value is a kind of type: - -* the `typeof` operator to use to test if a value is a number, a string, or - a function; and, -* the `Array.isArray` method to check if a value is an array. - -Use them as much (or as little) as you need! - -________________________________________________________________________________ -# The Null Type (And Undefined) - -You've met numbers and string, Booleans and arrays. There's another type often -used in JavaScript: the Null type. And, it's a special type. - -In this article, you will learn about the Null type, its value, and how to work -with it in JavaScript. - -## A type with only one value - -You have seen that the String type can have an "infinite" number of values -(within the limits of your computer memory). For example, the String type -represents _any_ of the following values. - -```js -// Examples of values with the String type -'hello, world' -"this is a string" -`Where is my pudding?` -'' -'A really long string.........................................................' -``` - -The Number type also has this aspect. Any number that you can reasonable express -in JavaScript has the Number type. - -```js -// Examples of values with the Number type --100 -99 -6.28 -Infinity -``` - -You also know about the Boolean type. It can have only two values. - -```js -// The only two values of Boolean type -true -false -``` - -There are not _more_ Boolean values. You can't dream up more. There are only -two, those two. - -The Null type has one and exactly one value. - -```js -// The only value that has the Null type -null -``` - -It's just that word: `null`. No quotation marks. No other fancy things. Just -`null`. - -## The meaning of null - -This is a harder subject to tackle because it's a _philosophical_ subject. Many -people ask, "What does the value of `null` mean in a program?" There are a -couple of answers that programmers give to this. None of them are wrong. None of -them are right. They just are. In the presence of `null`, the code you write -determines which of the following meanings `null` has. - -* The value `null` means _the absence of a value_ or _no value_ -* The value `null` means _an unknown value_ -* The value `null` is a nuisance and I hate it and wish it were never invented - -During your software programming career, you will likely have all three of those -opinions, sometimes at the same time. Let's take a look at some examples to try -to figure this out. - -## The absence of a value - -Let's say you wrote a function that splits a string into words, reverses them, -and puts them back together in reverse order. You can do that with the methods - -* `String#split` [link][split]; -* `Array#reverse` [link][reverse]; and, -* `Array#join` [link][join]. - -That function could look like this. - -```js -function reverseTheSentence(sentence) { - let parts = sentence.split(' '); - parts.reverse(); - return parts.join(' '); -} -``` - -That's great! It works! But, what happens if someone doesn't care about what -your function and just decides to pass in something that's not a string? It -would make sense that reversing something that is not a string should lead to no -value, the absence of a value, because the input to the function doesn't make -sense. In that case, you can just return a `null` because there is _no value_ -that the function can return that would make sense. - -```js -function reverseTheSentence(sentence) { - if (typeof sentence !== 'string') { - return null; - } - let parts = sentence.split(' '); - parts.reverse(); - return parts.join(' '); -} -``` - -## An unknown value - -There are a lot of programmers that will argue that `null` cannot be an unknown -value. "The value is known!" they'll exclaim. "The value is 'null'! It's known! -It's 'null'! Stop saying it's not known!" - -There are programmers that vehemently disagree with that. - -![shrug](images/woman-shrugging_1f937-200d-2640-fe0f.png) - -## Checking if a value is null - -If you had hoped that you could use the `typeof` operator to check if a value is -`null`, then you're out of luck. - -```js -// Useless code. -console.log(typeof null); // 'object' -``` - -Silly JavaScript. Instead of using the `typeof` operator, you can just _compare_ -the value to `null` because there is only one value of the Null data type and -it's always `null`. Take a look at the following code and figure out what you -think it will produce. - -```js -let a = []; -let x = null; - -if (a === null) { - console.log('a is null'); -} else if (x === null) { - console.log('x is null'); -} -``` - -## Oh, and there's that undefined value, too - -Just like the `null` value that is the only value of the Null data type, there -is `undefined` which is the only value of the Undefined data type. - -If you're asking yourself, "Wait, if 'null' is no value or the absence of a -value, then what the heck does 'undefined' mean?", well you're not the only one. - -Have a look at this code. - -```js -let value; - -value = 6.28; -console.log(value); -``` - -You probably will not be surprised to see that it will print out "6.28" because -that's the value of `value`. But, what if you did this? What does that new -`console.log` print? - -```js -let value; -console.log(value); // <- what does this print? - -value = 6.28; -console.log(value); -``` - -If you guessed that it prints "undefined", you're right! When you declare a -variable, it's very first value is `undefined`. Most of the time, though, you'll -just immediately set it to a value. - -```js -let value = 6.28; -``` - -So, an uninitialized variable has the value `undefined` which is the only value -of the Undefined data type. To test for it, you can use the `typeof` operator -_or_ the strict equality operator. Using the strict equality operator is the -more common way to do that, now. - -```js -// Test if a value is undefined -if (value === undefined) { - // do a thing -} - -// You can also do it this way, but -// it is considered passé. -if (typeof value === 'undefined') { - // do a thing -} -``` - -## What happens when... - -Interestingly enough, all functions actually _do_ return values. Have a look at -this function. What value does it return? (Not a trick question.) - -```js -function returnsTrue() { - return true; -} -``` - -Yes, it returns the value `true`. But, what about this function? - -```js -function returnsWhat() { - return; -} -``` - -There's a `return` statement there but it does not specify a value. If there is -not value specified, what do you think this function returns? Try putting the -function definition above and the code below into a code runner and seeing what -happens. - -```js -console.log(returnsWhat()); -``` - -One you figure that out, try the same experiment but with this function. What -do you think it returns. It doesn't even have a `return` statement in it! - -```js -function whatIsThis() { -} -``` - -## Remember - -There is a special value in JavaScript represented as `null` which means "no -value" or "unknown value". It is the only value of the Null data type. You can -check that a value is `null` by using the strict equality operator `x === null`. - -The value `undefined` is used by JavaScript for variables that have not been -assigned a value. Also, functions that do not return an explicit value return -the value `undefined`. You can test if a value is `undefined` by using the -strict equality operator `x === undefined`. - -[reverse]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse -[split]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/split -[join]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join - -________________________________________________________________________________ -# Catch Me If You Can - -Sometimes bad things happen to good programs. Some person may enter some badly -formatted information. Another computer may try to attack your program by -sending it wonky data. A network could go down. A file can become corrupt. When -this happens, your running software will have some errors. This article is about -how you can recover from those errors with "structured exception handling". - -In this article you'll learn the answers to: - -* What _is_ structured exception handling? -* How can I do that in JavaScript? -* How can I make my own errors? -* What else can I do with it? -* Shouldn't I just always do this? - -## Structured exception handling - -Oddly enough, there are very few error-handling mechanisms in use, today, in all -programming languages. There are really only three ways that programming -language provide structured exception handling. - -* **Error or error code reporting** as found in languages like C and Go -* **Continuable exceptions** as found in Common Lisp -* **Stack unwinding** which is found in almost every modern programming - language including JavaScript and Python - -In the stack-unwinding paradigm, which is the one you'll use in JavaScript, when -an error occurs, the JavaScript interpreter (the thing running your JavaScript -code) looks for some kind of handler for that error. It has a very specific way -of searching for those handlers. The way JavaScript searches for the handlers is -very similar to the way it happens in Python, C++, Java, C#, and a lot of other -languages. Once you learn it, here, you will be able to handle errors when -writing code in all of those languages. - -## Try and catch - -Say you have some code that may have an error. For example: - -```js -function sumArray(array) { - let sum = 0; - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - return sum; -} -``` - -If someone calls the above function with the code `sumArray(null)`, then they -will get the error because the `for` loop is trying to get the `length` property -of the `array` parameter which is `null`. - -``` -TypeError: Cannot read property 'length' of null -``` - -To prevent this from ruining your program, you wrap code that may have an error -in a **try block**. Now, you've seen other blocks already: `if` blocks, `for` -blocks, `function` blocks. Basically, if there are curly braces around some -lines of code, that's a **code block** of some kind. A _try block_ is just some -curly braces with the `try` keyword. - -```js -// THIS IS AN INCOMPLETE BLOCK OF CODE -function sumArray(array) { - let sum = 0; - - // The try block wraps the for loop. If some - // error occurs, the try block will give you - // a chance to react to it so that the program - // doesn't terminate. - try { - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - } // needs something more here - - return sum; -} -``` - -The `try` block tells JavaScript that it needs to watch the code inside the -curly braces for an error. Now, you have to tell JavaScript what to do when -there _is_ an error. You do that in the `catch` block that should immediately -follow the `try` block. The `catch` block accepts a single parameter that -(usually) contains an object that describes the error that occurred. In the -case of the `sumArray` method, if an error occurs, you could return the value -`undefined` rather than letting an error terminate your program. You could also -log the error to the "error" output. - -```js -function sumArray(array) { - let sum = 0; - - try { - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - } catch (e) { - console.log(e); - return null; - } - - return sum; -} - -sumArray(null); -``` - -Just to state it, again: the _catch block_ runs when an error occurs in the _try -block_. If no error occurs in the _try block_, the _catch block_ **does not -run**. - -That `(e)` after the word `catch` is a variable that contains any error that was -thrown and caught by this `try-catch` block. It doesn't have to be named `e`. - -```js -function sumArray(array) { - let sum = 0; - - try { - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - } catch (pancakes) { - console.log(pancakes); - return null; - } - - return sum; -} - -sumArray(null); -``` - -Here is the same code but, instead of a variable named "e", there is a variable -named "pancakes". Now, if an error is thrown, the variable "pancakes" will -contain it. By long-standing tradition, the variables used with the catch block -are normally "e", "err", or "error". - -```js -// CODE SNIPPET, WILL NOT RUN -} catch (e) { -``` - -```js -// CODE SNIPPET, WILL NOT RUN -} catch (err) { -``` - -```js -// CODE SNIPPET, WILL NOT RUN -} catch (error) { -``` - -Now, when you run the code `sumArray(null)`, you should see something like the -following, if you run it in the online code editor. - -``` -TypeError: Cannot read property 'length' of null - at sumArray (/tmp/file.js:5:31) - at Object. (/tmp/file.js:16:1) - at Module._compile (internal/modules/cjs/loader.js:1158:30) - at Object.Module._extensions..js (internal/modules/cjs/loader.js:1178:10) - at Module.load (internal/modules/cjs/loader.js:1002:32) - at Function.Module._load (internal/modules/cjs/loader.js:901:14) - at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:74:12) - at internal/main/run_main_module.js:18:47 -``` - -In that code sample, after the `sumArray(null)` call, the lines that begins -`TypeError` is the error that occurred. The next 10 lines are what is known as a -**stack trace**. You'll end up seeing these a lot, most likely, as you continue -your career in software programming. This is the first line in understanding -errors in your code. The _stack trace_ shows on the first line where the error -occurred: `sumArray (/tmp/file.js:5:31)` means that it occurred in the -`sumArray` method on line 5 of the content, at character 31. If you open up one -of the coding problems, paste that code block in, and run it, you'll see similar -output in the output block. - -The last line `undefined` is the return value of the `sumArray(null)` invocation -that now happens when an error occurs. - -That is how the so-called **try-catch block** works. - -## How can I make my own errors? - -To create your own errors with structured exception handling, you first need to -create an error object with the message that describes the error. Then, you need -to "throw" the error. That code would look like either of these two lines, the -only difference being the `new` keyword. They both work exactly the same. - -```js -throw Error('this happened because I wanted it to'); -throw new Error('this happened because I wanted it to'); -``` - -## What else is there? - -Turns out that you can have one more block on the _try-catch block_. It is the -**finally block**. The _finally block_ runs whether or not an error occurs. It -_always_ runs. - -```js -function sumArray(array) { - let sum = 0; - - try { - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - } catch (e) { - console.log(e); - return null; - } finally { - console.log('you will always see this.'); - } - - return sum; -} -``` - -## How do I best use this? - -At this point, you may be asking yourself, "Self, since errors can occur -everywhere, shouldn't I just wrap _all_ of my code in these _try-catch blocks_?" - -No. No, you shouldn't. - -Every **try-catch block** introduces another slow-down in your code. If you're -writing code that you want to run as fast as possible, then you write as few -_try-catch blocks_ as possible. Also, it makes the code pretty cluttered with -all of the indentation and curly braces. When at all possible, you should write -**defensive code** which checks for bad values before errors get thrown in your -code. Rather than using a _try-catch block_ in the `sumArray` function, you -could defend against bad values of the `array` parameter like so. - -```js -function sumArray(array) { - if (array === null) { - return null; - } - - let sum = 0; - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - return sum; -} -``` - -## Review - -The _try-catch-finally block_ is a mechanism to handle errors in your code. You -should _not_ wrap all of your code in these blocks because it can seriously -degrade the performance of your application. Instead, only wrap those portions -of the code that you want to guard against throwing exceptions. - -A better choice, in JavaScript and all programming languages, is to be -defensive about your programming and choose to check that the value that you -have has the functionality that you desire by adding code like - -```js -if (value !== undefined) {} -if (value !== null) {} -``` - - ----- - -

_Resources/node_modules/jquery/

- -### [_Resources/node_modules/jquery/README.md](_Resources/node_modules/jquery/README.md) -# jQuery - -> jQuery is a fast, small, and feature-rich JavaScript library. - -For information on how to get started and how to use jQuery, please see [jQuery's documentation](https://api.jquery.com/). -For source files and issues, please visit the [jQuery repo](https://github.com/jquery/jquery). - -If upgrading, please see the [blog post for 3.6.0](https://blog.jquery.com/2021/03/02/jquery-3-6-0-released/). This includes notable differences from the previous version and a more readable changelog. - -## Including jQuery - -Below are some of the most common ways to include jQuery. - -### Browser - -#### Script tag - -```html - -``` - -#### Babel - -[Babel](https://babeljs.io/) is a next generation JavaScript compiler. One of the features is the ability to use ES6/ES2015 modules now, even though browsers do not yet support this feature natively. - -```js -import $ from "jquery"; -``` - -#### Browserify/Webpack - -There are several ways to use [Browserify](http://browserify.org/) and [Webpack](https://webpack.github.io/). For more information on using these tools, please refer to the corresponding project's documentation. In the script, including jQuery will usually look like this... - -```js -var $ = require( "jquery" ); -``` - -#### AMD (Asynchronous Module Definition) - -AMD is a module format built for the browser. For more information, we recommend [require.js' documentation](https://requirejs.org/docs/whyamd.html). - -```js -define( [ "jquery" ], function( $ ) { - -} ); -``` - -### Node - -To include jQuery in [Node](https://nodejs.org/), first install with npm. - -```sh -npm install jquery -``` - -For jQuery to work in Node, a window with a document is required. Since no such window exists natively in Node, one can be mocked by tools such as [jsdom](https://github.com/jsdom/jsdom). This can be useful for testing purposes. - -```js -const { JSDOM } = require( "jsdom" ); -const { window } = new JSDOM( "" ); -const $ = require( "jquery" )( window ); -``` - - - - - -

_Resources/node_modules/loadashes6/lodash/

- -### [_Resources/node_modules/loadashes6/lodash/README.md](_Resources/node_modules/loadashes6/lodash/README.md) - - - - - -### [_Resources/node_modules/loadashes6/lodash/release.md](_Resources/node_modules/loadashes6/lodash/release.md) - - - -

_Resources/node_modules/mout/

- -### [_Resources/node_modules/mout/CHANGELOG.md](_Resources/node_modules/mout/CHANGELOG.md) -mout changelog -============== -v1.1.1 (2019/04/18) --------------------- - - fixed `object/get` throwing an exception for null or undefined input objects - -v1.1.0 (2017/10/04) --------------------- - - update dependencies - - optimize `function/bind` - - optimize `lang/kindOf` - -v0.12.0 (2016/03/03) --------------------- - - add `array/indicesOf` - - add `function/memoize` - - add `array/reverse` - - add `math/overflow` - - fix `query/getQuery` - - fix `object/deepMatches` - - optimize `function/partial` - - updates license - - -v0.11.0 (2014/11/17) --------------------- - - - add `array/take`; - - remove unused variable from `date/totalDaysInMonth`; - - fix case insensitive RegExp cloning on `lang/clone`; - - -v0.10.0 (2014/09/02) --------------------- - - - add `array/equals`; - - add `array/groupBy`; - - add `array/last`; - - add `function/wrap`; - - add `lang/GLOBAL`; - - add `lang/isPrimitive`; - - add `number/MAX_SAFE_INTEGER`; - - add `object/omit`; - - add `object/result`; - - add `object/result`; - - add `random/randString`; - - change `lang/isEmpty` behavior to return `true` for any value that isn't - a collection. - - fix `array/findLastIndex` to stop at zero index; - - improve `function/partial` to accept placeholders; - - improve `math.norm` behavior for values outside the range and for cases - where `val === min === max`; - - improve `object/get` behavior to return properties from any value that is - not `null` or `undefined`; - - move `object/deepEquals` to `lang/deepEquals` (improving the behavior); - - -v0.9.1 (2014/04/08) -------------------- - - - fix `array/slice` behavior when start and end are higher than length. - - -v0.9.0 (2014/02/04) -------------------- - - - add `date/quarter`; - - add `function/constant`; - - add `random/randBool`; - - add un-padded 12-hour (`%l`) to `date/strftime`; - - fix `array/slice` on IE < 9 by using a custom implementation. - - fix `object/forIn` iteration for IE < 9 constructor property; - - improve `lang/inheritPrototype` by returning the `prototype`; - - improve `string/removeNonWord` to cover more chars; - - improve `string/repeat` performance; - - improve `string/unescapeHtml` by accepting leading zeros for `'`; - - -v0.8.0 (2013/11/22) -------------------- - - - add `array/findLast`. - - add `array/findLastIndex`. - - add `array/slice` and use it internally. - - add `array/sortBy` - - add `function/awaitDelay`. - - add `function/identity` - - add `number/isNaN`. - - add `number/nth`. - - add `number/ordinal`. - - allows nested replacement patterns in `string/interpolate`. - - change `function/makeIterator_` behavior (uses `identity` by default). - - simplify `string/escapeRegExp`. - - support custom equality on `array/compare`. - - -v0.7.1 (2013/09/18) -------------------- - - - fix `null` value handling in object/get. - - -v0.7.0 (2013/09/05) -------------------- - - - add bower ignores. - - add german translation for date localization. - - alias `function` package as `fn` since "function" is a reserved keyword. - - allow second argument on `array/pick`. - - improve `string/makePath` to not remove "//" after protocol. - - make sure methods inside `number` package works with mixed types. - - support arrays on `queryString/encode`. - - support multiple values for same property on `queryString/decode`. - - add `cancel()` method to `throttled/debounced` functions. - - add `function/times`. - - add `lang/toNumber`. - - add `string/insert`. - - add `super_` to constructor on `lang/inheritPrototype`. - - -v0.6.0 (2013/05/22) -------------------- - - - add optional delimeter to `string/unCamelCase` - - allow custom char on `number/pad` - - allow underscore characters in `string/removeNonWord` - - accept `level` on `array/flatten` instead of a flag - - convert underscores to camelCase in `string/camelCase` - - remove `create()` from number/currencyFormat - - add `date/dayOfTheYear` - - add `date/diff` - - add `date/isSame` - - add `date/startOf` - - add `date/strftime` - - add `date/timezoneAbbr` - - add `date/timezoneOffset` - - add `date/totalDaysInYear` - - add `date/weekOfTheYear` - - add `function/timeout` - - add `object/bindAll` - - add `object/functions` - - add `time/convert` - - -v0.5.0 (2013/04/04) -------------------- - - - add `array/collect` - - add `callback` parameter to `object/equals` and `object/deepEquals` to allow - custom compare operations. - - normalize behavior in `array/*` methods to treat `null` values as empty - arrays when reading from array - - add `date/parseIso` - - add `date/isLeapYear` - - add `date/totalDaysInMonth` - - add `object/deepMatches` - - change `function/makeIterator_` to use `deepMatches` (affects nearly all - iteration methods) - - add `thisObj` parameter to `array/min` and `array/max` - - -v0.4.0 (2013/02/26) -------------------- - - - add `object/equals` - - add `object/deepEquals` - - add `object/matches`. - - add `lang/is` and `lang/isnt`. - - add `lang/isInteger`. - - add `array/findIndex`. - - add shorthand syntax to `array/*`, `object/*` and `collection/*` methods. - - improve `number/sign` behavior when value is NaN or +0 or -0. - - improve `lang/isNaN` to actually check if value *is not a number* without - coercing value; so `[]`, `""`, `null` and `"12"` are considered NaN (#39). - - improve `string/contains` to match ES6 behavior (add fromIndex argument). - - -v0.3.0 (2013/02/01) -------------------- - - - add `lang/clone`. - - add `lang/toString`. - - add `string/replace`. - - add `string/WHITE_SPACES` - - rename `function/curry` to `function/partial`. - - allow custom chars in `string/trim`, `ltrim`, and `rtrim`. - - convert values to strings in the `string/*` functions. - - -v0.2.0 (2013/01/13) -------------------- - - - fix bug in `math/ceil` for negative radixes. - - change `object/deepFillIn` and `object/deepMixIn` to recurse only if both - existing and new values are plain objects. Will not recurse into arrays - or objects not created by the Object constructor. - - add `lang/isPlainObject` to check if a file is a valid object and is created - by the Object constructor - - change `lang/clone` behavior when dealing with custom types (avoid cloning - it by default) and add second argument to allow custom behavior if needed. - - rename `lang/clone` to `lang/deepClone`. - - add VERSION property to index.js - - simplify `math/floor`, `math/round`, `math/ceil` and `math/countSteps`. - - -v0.1.0 (2013/01/09) -------------------- - -- Rename project from "amd-utils" to "mout" - - - - - -### [_Resources/node_modules/mout/CONTRIBUTING.md](_Resources/node_modules/mout/CONTRIBUTING.md) - -# Contributing - -Fork the repo at https://github.com/mout/mout - - > "Write clearly, don't be too clever" - The Elements of Programming Style - -Avoid unnamed functions and follow the other modules structure. By only using named functions it will be easier to extract the code from the AMD module if needed and it will also give better error messages, JavaScript minifiers like [Google Closure Compiler](http://code.google.com/closure/compiler/) and [UglifyJS](https://github.com/mishoo/UglifyJS) will make sure code is as small/optimized as possible. - - > "Make it clear before you make it faster." - The Elements of Programming Style - -Be sure to always create tests for each proposed module. Features will only be merged if they contain proper tests and documentation. - - > "Good code is its own best documentation." - Steve McConnell - -We should do a code review before merging to make sure names makes sense and implementation is as good as possible. - -Try to split your pull requests into logical groups, the smaller the easier to be reviewed/merged. - - - -## Tests & Code Coverage ## - -Tests can be found inside the `tests` folder, to execute them in the browser open the `tests/runner.html`. The same tests also work on node.js by running `npm test`. - -We should have tests for all methods and ensure we have a high code coverage through our continuous integration server ([travis](https://travis-ci.org/mout/mout)). When you ask for a pull request Travis will automatically run the tests on node.js and check the code coverage as well. - -We run `node build pkg` automatically before any `npm test`, so specs and packages should always be in sync. (will avoid human mistakes) - -To check code coverage run `npm test --coverage`, it will generate the reports inside the `coverage` folder and also log the results. Please note that node.js doesn't execute all code branches since we have some conditionals that are only met on old JavaScript engines (eg. IE 7-8), so we will never have 100% code coverage (but should be close to it). - - - -## Build Script ## - -The [build script](https://github.com/mout/mout/wiki/Build-Script) can be extremely helpful and can avoid human mistakes, use it. - - - -## Admins / Pull Requests ## - -Even if you are an admin (have commit rights) please do pull requests when adding new features or changing current behavior, that way we can review the work and discuss. Feel free to push changes that doesn't affect behavior without asking for a pull request (readme, changelog, build script, typos, refactoring, ...). - - - -## Large changes ## - -If you are proposing some major change, please create an issue to discuss it first. (maybe it's outside the scope of the project) - - - -## Questions / IRC / Wiki / Issue Tracker ## - -When in doubt ask someone on IRC to help you ([#moutjs on irc.freenode.net](http://webchat.freenode.net/?channels=moutjs)) or create a [new issue](http://github.com/mout/mout/issues). - -The [project wiki](https://github.com/mout/mout/wiki) can also be a good resource of information. - - ---- - -Check the [contributors list at github](https://github.com/mout/mout/contributors). - - - -

_Resources/node_modules/mout/doc/

- -### [_Resources/node_modules/mout/doc/array.md](_Resources/node_modules/mout/doc/array.md) -# array # - -Array utilities. - - - - -## append(arr1, arr2):Array - -Appends an array to the end of the other. -The first array will be modified and will contain the appended items. - -See: [`union()`](#union), [`combine()`](#combine) - -```js -var foo = ['a', 'b'], - bar = ['b', 'd']; - -append(foo, bar); // ['a', 'b', 'b', 'd'] -``` - - - -## collect(arr, callback, [thisObj]):Array - -Maps the items in `arr` and concatenates the resulting arrays. - -See: [`map()`](#map) - -```js -collect([1, 2, 3], function(val) { - return [val, val % 2]; -}); // [1, 1, 2, 0, 3, 1]; - -collect(['a', 'bb', ''], function(val) { - return val.split(''); -}); // ['a', 'b', 'b'] -``` - -It also supports a shorthand syntax: - -```js -var items = [{ a: [1] }, { b: 'foo' }, { a: [2, 3] }]; -collect(items, 'a'); // [1, 2, 3]; -``` - - - -## combine(arr1, arr2):Array - -Combines an array with all the items of another. -The first array will be modified and will contain the combined items. -Does not allow duplicates and is case and type sensitive. - -See: [`union()`](#union), [`append()`](#append) - -```js -var foo = ['a', 'b'], - bar = ['b', 'd']; - -combine(foo, bar); // ['a', 'b', 'd'] -``` - - - -## compact(arr):Array - -Returns a new Array without any `null` or `undefined` values. Note that it will -keep empty strings and other falsy values (simillar to Ruby Array#compact). - -```js -var arr = [0, 1, null, false, '', 'foo', undefined, 'bar']; -compact(arr); // [0, 1, false, '', 'foo', 'bar']; -``` - - - -## contains(arr, value):Boolean - -Checks if Array contains value. Alias to `indexOf(arr, val) !== -1`. - -```js -var arr = [1, 2, 3]; -contains(arr, 2); // true -contains(arr, 'foo'); // false -``` - - - -## difference(...arrs):Array - -Return a new Array with elements that aren't present in the other Arrays -besides the first one. - -Works like [Python set#difference](http://docs.python.org/library/stdtypes.html#set.difference). - -It will remove duplicates. - -See: [`xor()`](#xor), [`intersection()`](#intersection) - -```js -var a = ['a', 'b', 1]; -var b = ['c', 1]; -difference(a, b); // ['a', 'b'] -``` - - -## equals(a, b, [compare]):Boolean - -Checks if both arrays are equal. - -```js -equals([1, 2], [1, 2]); // true -equals([2, 4], [1, 2]); // false -``` - -By default it uses the [lang/is](lang.html#is) as the `compare` function but -you can pass a custom function to change the behavior. - -```js -function loose(a, b) { - return a == b; -} -equals(['1', 2], [1, 2], loose); // true -``` - -See: [object/equals](object.html#equals), [lang/deepEquals](lang.html#deepEquals) - - - -## every(arr, callback, [thisObj]):Array - -Crossbrowser `Array.every()`. - -Tests whether all elements in the array pass the test implemented by the provided function. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -```js -var items = [1, 'foo', 'bar']; -every(items, isString); // false -every(items, isFunction); // false -every(items, function(val, key, arr){ - return val != null; -}); // true -``` - -more info at [MDN Array#every](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every) - -It also supports a shorthand syntax: - -```js -var items = [{id:1, active:true}, {id:3, active:true}, {id:8, active:true}]; -// all items with `id === 8` -every(items, {id:8}); // false -// `active` is truthy on all items -every(items, 'active'); // true -``` - - - -## filter(arr, callback, [thisObj]):Array - -Crossbrowser `Array.filter()`. - -Creates a new array with all elements that pass the callback test. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -```js -var nums = [1, 2, 3, 4, 5, 6]; -var oddNumbers = filter(nums, function(val, key, arr){ - return (val % 2) !== 0; -}); -// > [1, 3, 5] -``` - -more info at [MDN Array#filter](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/filter) - -Filter also supports shorthand notation: - -```js -var users = [ - {name:'john', surname:'connor', beard:false}, - {name:'john', surname:'doe', beard:true}, - {name:'jane', surname:'doe', beard:false} -]; -// filter item that matches all properties/values pairs -filter(users, {name:'john', beard:false}); -// > [{name:'john', surnname:'connor', beard:false}] -// items where 'beard' is a truthy value -filter(users, 'beard'); -// > [{name:'john', surnname:'doe', beard:true}] -``` - -See [`reject()`](#reject) - - - -## find(arr, callback, [thisObj]):* - -Loops through all the items in the Array and returns the first one that passes -a truth test (callback). - -```js -var arr = [123, {a:'b'}, 'foo', 'bar']; -find(arr, isString); // "foo" -find(arr, isNumber); // 123 -find(arr, isObject); // {a:'b'} -``` - -Find also supports shorthand notation: - -```js -var users = [ - {name:'john', surname:'connor', beard:false}, - {name:'john', surname:'doe', beard:true} -]; -// first item that matches all properties/values pairs -find(users, {name:'john'}); // {name:'john', surnname:'connor', beard:false} -// first item where 'beard' is a truthy value -find(users, 'beard'); // {name:'john', surnname:'doe', beard:true} -``` - -See: [findIndex()](#findIndex), [findLast()](#findLast), -[findLastIndex()](#findLastIndex) - - - -## findLast(arr, callback, [thisObj]):* - -Loops through all the items in the Array (starting from last item) and returns -the first one that passes a truth test (callback). - -```js -var arr = [123, {a:'b'}, 'foo', 'bar']; -findLast(arr, isString); // "bar" -findLast(arr, isNumber); // 123 -findLast(arr, isObject); // {a:'b'} -``` - -`findLast` also supports shorthand notation: - -```js -var users = [ - {name:'john', surname:'connor', beard:false}, - {name:'john', surname:'doe', beard:true} -]; -// last item that matches all properties/values pairs -findLast(users, {name:'john'}); // {name:'john', surnname:'doe', beard:true} -// last item where 'beard' is a truthy value -findLast(users, 'beard'); // {name:'john', surnname:'doe', beard:true} -``` - -See: [find()](#find), [findIndex()](#findIndex), -[findLastIndex()](#findLastIndex) - - - -## findIndex(arr, iterator, [thisObj]):Number - -Loops through the items in the Array and returns the index of the first one -that passes a truth test (callback). - -Returns `-1` if no item was found that passes the truth test. - -```js -var arr = [1, { a: 1 }, 'foo', 'bar']; -findIndex(arr, isString); // 2 -findIndex(arr, isNumber); // 0 -findIndex(arr, isObject); // 1 -findIndex(arr, isRegExp); // -1 -``` - -`findIndex` also supports shorthand notation: - -```js -var pets = [ - { pet: 'dog', name: 'Sam' }, - { pet: 'dog', name: 'Maggie' } -]; - -findIndex(pets, { pet: 'dog' }); // 0 -findIndex(pets, { name: 'Maggie' }); // 1 -``` - -See: [find()](#find), [findLastIndex()](#findLastIndex) - - - -## findLastIndex(arr, iterator, [thisObj]):Number - -Loops through the items in the Array on the reverse order and returns the index -of the first one that passes a truth test (callback). - -Returns `-1` if no item was found that passes the truth test. - -```js -var arr = [1, { a: 1 }, 'foo', 'bar']; -findLastIndex(arr, isString); // 3 -findLastIndex(arr, isNumber); // 0 -findLastIndex(arr, isObject); // 1 -findLastIndex(arr, isRegExp); // -1 -``` - -`findLastndex` also supports shorthand notation: - -```js -var pets = [ - { pet: 'dog', name: 'Sam' }, - { pet: 'dog', name: 'Maggie' } -]; - -findLastIndex(pets, { pet: 'dog' }); // 1 -findLastIndex(pets, { name: 'Sam' }); // 0 -``` - -See: [find()](#find), [findIndex()](#findIndex) - - - -## flatten(arr, [level]):Array - -Recursively flattens an array. A new array containing all the elements is -returned. If `level` is specified, it will only flatten up to that level. -Note that arrays within objects will not be flattened. - -### Example - -```js -flatten([1, [2], [3, [4, 5]]]); -// > [1, 2, 3, 4, 5] -flatten([1, [2], [3, [4, 5]]], 1); -// > [1, 2, 3, [4, 5]] -``` - -See: [`object/flatten()`](./object.html#flatten) - - -## forEach(arr, callback, [thisObj]):void - -Crossbrowser `Array.forEach()`. - -It allows exiting the iteration early by returning `false` on the callback. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -```js -var items = ['foo', 'bar', 'lorem', 'ipsum']; -forEach(items, function(val, key, arr){ - console.log(key +' : '+ val); - if (val === 'lorem') { - // stop iteration (break) - return false; - } -}); -``` - -more info at [MDN Array#forEach](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach) - - - -## groupBy(arr, [categorize=identity], [thisObj]):Object - -Groups array elements by the `key` returned from the `categorize` function. - -It will use the [function/identity](function.html#identity) as the default -`categorize` function. - -```js -var items = ['lorem', 'ipsum', 'foo', 'bar', 'baz']; -groupBy(items, function(val) { return val.length }); -// > {'3': ['foo', 'bar', 'baz'], '5': ['lorem', 'ipsum']} -``` - - - -## indexOf(arr, item, [fromIndex]):Number - -Crossbrowser `Array.indexOf()`. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -more info at [MDN Array#indexOf](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf) - - - - -## indicesOf(arr, item, [fromIndex]):Number - -Returns an array of indices where `item` is found in the array. - -Like `array/indexOf` it does loop over sparse items in the array. The optional -`fromIndex` parameter can limit the scope, the same way as it does in indexOf. - -```js -var items = ['lorem', 'ipsum', 'foo', 'ipsum', 'ipsum']; - -indicesOf(items, 'ipsum'); -// > [1, 3, 4] - -indicesOf(items, 'ipsum', 1); -// > [3, 4] -``` - - - - - -## insert(arr, ...items):Number - -Push items into array only if they aren't contained by it. Returns the new -`length` of the array. - -See: [`remove()`](#remove), [`removeAll()`](#removeAll), -[`contains()`](#contains) - -```js -var arr = ['a', 'b']; -insert(arr, 'a'); // 2 : ['a', 'b'] -insert(arr, 'c'); // 3 : ['a', 'b', 'c'] -insert(arr, 1, 2, 'b'); // 5 : ['a', 'b', 'c', 1, 2] -``` - - - -## intersection(...arrs):Array - -Return a new Array with elements common to all Arrays. - -Similar to Python set#intersection and underscore.js intersection. - -It will remove duplicates. - -See: [`difference()`](#difference), [`xor()`](#xor) - -```js -var a = ['a', 'b', 1], - b = ['c', 1], - c = [1, 2, 3]; -intersection(a, b, c); // [1] -``` - - - -## invoke(arr, methodName[, ...args]):Array - -Call `methodName` on each item of the array passing custom arguments if needed. - -```js -invoke([[3,2,1], [9,5,2]], 'sort'); // [[1,2,3], [2,5,9]] -``` - - - -## join(arr, [separator]):String - -Joins the strings in `arr`, inserting `separator` between each value. - -This ignores null values and empty strings that are in the array. `separator` -defaults to an empty string. This will convert all non-string objects in the -array to a string. - -### Example - -```js -join(['a', 'b', 'c']); // 'abc' -join(['foo', 'bar'], ', '); // 'foo, bar' -join([null, 'foo', '', 'bar', undefined], ':'); // 'foo:bar' -``` - - -## last(arr):* - -Returns the last element of an array without modifying the array. - - -```js -last( [1, 2, 3, 4] ) // > 4 -last( ['foo', 'bar'] ) // > 'bar' -``` - - -## lastIndexOf(arr, item, [fromIndex]):Number - -Crossbrowser `Array.lastIndexOf()`. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -more info at [MDN Array#lastIndexOf](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf) - - - -## map(arr, callback, [thisObj]]):Array - -Crossbrowser `Array.map()`. - -Creates a new array with the results of calling a provided function on every -element in this array. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -See: [`collect()`](#collect) - -```js -var nums = [1,2,3,4]; -var double = map(nums, function(val, key, arr){ - return val * 2; -}); -// > [2, 4, 6, 8] -``` - -more info at [MDN Array#map](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/map) - -It also supports a shorthand notation which can be used to achieve same result -as [`array/pluck`](#pluck): - -```js -var src = ['lorem', 'ipsum', 'foo', 'amet']; -// grab the "length" property of all items -var lengths = map(src, 'length'); // [5, 5, 3, 4] -``` - - - -## max(arr, [iterator], [thisObj]):* - -Returns maximum value inside array or use a custom iterator to define how items -should be compared. - -See: [`min()`](#min) - -```js -max([10, 2, 7]); // 10 -max(['foo', 'lorem', 'amet'], function(val){ - return val.length; -}); // 'lorem' -``` - -It also supports a shorthand notation: - -```js -max(['foo', 'lorem', 'amet'], 'length'); // "lorem" -``` - - - -## min(arr, [iterator], [thisObj]):* - -Returns minimum value inside array or use a custom iterator to define how items -should be compared. - -See: [`max()`](#max) - -```js -min([10, 2, 7]); // 2 -min(['foo', 'lorem', 'amet'], function(val){ - return val.length; -}); // 'foo' -``` - -It also supports a shorthand notation: - -```js -min(['foo', 'lorem', 'amet'], 'length'); // "foo" -``` - - - -## pick(arr, [nItems]):* - -Gets random item(s) and removes it from the original array. - -If `nItems` is specified it will return a new Array contained the *picked* -items otherwise it returns a single item. - -See: [`random/choice()`](./random.html#choice) - -### Example: - -```js -var arr = [1, 2, 3, 4, 5, 6]; -var item1 = pick(arr); // 4 -var item2 = pick(arr); // 1 -var items = pick(arr, 2); // [5, 2] -console.log(arr); // [3, 6] -``` - - - -## pluck(arr, propName):Array - -Extract a list of property values. - -See: [`function/prop()`](function.html#prop) - -```js -var users = [{name : 'John', age: 21}, {name: 'Jane', age : 27}]; -var names = pluck(users, 'name'); // ["John", "Jane"] -var ages = pluck(users, 'age'); // [21, 27] -``` - - - -## range([start], stop[, step]):Array - -Creates a new Array with all the values inside the range. Works similarly to -Python#range or PHP#range. - -### Arguments - - 1. `[start]` (Number) : Range start. Default is `0`. - 2. `stop` (Number) : Range limit. - 3. `[step]` (Number) : Step size. Default is `1`. - -### Example - -```js -range(5); // [0, 1, 2, 3, 4, 5] -range(0, 5); // [0, 1, 2, 3, 4, 5] -range(0, 5, 2); // [0, 2, 4] -range(20, 40, 5); // [20, 25, 30, 35, 40] -``` - - - -## reduce(arr, fn):* - -Crossbrowser `Array.reduce()`. - -Apply a function against an accumulator and each value of the array (from -left-to-right) as to reduce it to a single value. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -more info at [MDN Array#reduce](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduce) - - - -## reduceRight(arr, fn):* - -Crossbrowser `Array.reduceRight()`. - -Apply a function simultaneously against two values of the array (from -right-to-left) as to reduce it to a single value. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -more info at [MDN Array#reduceRight](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduceRight) - - - -## reject(arr, fn, thisObj):Array - -Creates a new array with all the elements that do **not** pass the truth test. -Opposite of [`filter()`](#filter). - -See [`filter()`](#filter) - -### Example - -```js -var numbers = [1, 2, 3, 4, 5, 6]; -reject(numbers, function(x) { return (x % 2) !== 0; }); // [2, 4, 6] -``` - -It also supports a shorthand syntax: - -```js -var users = [ - {name:'john', surname:'connor', beard:false}, - {name:'john', surname:'doe', beard:true}, - {name:'jane', surname:'doe', beard:false} -]; -// reject items that matches all properties/values pairs -reject(arr, {name:'john'}); -// > [{name:'jane', surnname:'doe', beard:false}] -// reject items where 'beard' is a truthy value -filter(arr, 'beard'); -// > [{name:'john', surnname:'connor', beard:false}, -// {name:'jane', surname:'doe', beard:false}] -``` - - - -## remove(arr, item):void - -Remove a single item from the array. - -IMPORTANT: it won't remove duplicates, just a single item. - -### Example - -```js -var foo = [1, 2, 3, 4]; -remove(foo, 2); -console.log(foo); // [1, 3, 4] -``` - - - -## removeAll(arr, item):void - -Remove all instances of an item from the array. - -### Example - -```js -var foo = [1, 2, 3, 4, 2, 2]; -removeAll(foo, 2); -console.log(foo); // [1, 3, 4]; -``` - -## reverse(arr):void - -Returns a copy of the array with all elements in reversed order. - -### Example - -```js -var foo = [1, 2, 3, 4, 5]; -var bar = reverse(foo); -console.log(bar); // [5, 4, 3, 2, 1]; - -console.log(foo); // [1, 2, 3, 4, 5]; -``` - - - - -## shuffle(arr):Array - -Returns a new Array with items randomly sorted (shuffled). Similar to Ruby Array#shuffle. - -### Example - -```js -var arr = ['a', 'b', 'c', 'd', 'e']; -shuffle(arr); // ['b', 'd', 'e', 'c', 'a'] -``` - - - -## slice(arr, [start], [end]):Array - -Returns a new array containing the items from `arr` from the start index to the -end index. - -If `start` is omitted, it will start at `0`. If `end` is omitted, it will used -the last index of the array. If `start` or `end` is negative, it is used as an -offset from the end of the array. - -It will also convert array-like objects to arrays. - -### Example - -```js -slice([1, 2, 3, 4], 1, 2); // [2, 3] -slice([1, 2, 3], 1); // [2, 3] -slice([1, 2, 3]); // [1, 2, 3] -slice({ length: 2, 0: 'a', 1: 'b' }); // ['a', 'b'] -slice([1, 2, 3], 0, -1); // [1, 2] -slice([1, 2, 3], -2); // [2, 3] -``` - - - -## some(arr, callback, [thisObj]):Array - -Crossbrowser `Array.some()`. - -Tests whether some element in the array passes the test implemented by the provided function. - -It differs from ES5 since it will also loop over sparse items in the array to -normalize the behavior across browsers (avoid inconsistencies). - -```js -var items = [1, 'foo', 'bar']; -some(items, isString); // true -some(items, isFunction); // false -``` - -more info at [MDN Array#some](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some) - -It also supports a shorthand syntax: - -```js -var items = [{id:1, active:true}, {id:3, active:false}, {id:8, active:false}]; -// at least one item with `id === 8` -some(items, {id:8}); // true -// `active` is truthy on at least one item -some(items, 'active'); // true -``` - -see also: [`object/matches`](object.html#matches) - - - -## sort(arr, [compareFn]):Array - -Returns a sorted Array using the [Merge Sort](http://en.wikipedia.org/wiki/Merge_sort) algorithm (stable sort). - -The `Array.prototype.sort` browser implementations differ since the sorting algorithm isn't described in the ES spec - [in V8 it isn't stable](http://code.google.com/p/v8/issues/detail?id=90) and [on Firefox it is stable](https://bugzilla.mozilla.org/show_bug.cgi?id=224128) - so this function doesn't use the browser native implementation and is recommended in cases where a stable sort is required (items should preserve same order if already sorted). - -**Important:** It does logical comparisson by default (greater/less than) and -not a string comparisson like the native `Array#sort`. - -### compareFn - -If `compareFn` is supplied elements are sorted based on the value returned by -the `compareFn`. - - - If `compareFn(a, b)` is less than `0`, sort `a` to a lower index than `b`. - - If `compareFn(a, b)` returns `0`, leave `a` and `b` unchanged with respect - to each other, but sorted with respect to all different elements. - - If `compareFn(a, b)` is greater than `0`, sort `b` to a lower index than - `a`. - -See: [`sortBy`](#sortBy) - -### Example - -```js -sort([187, 23, 47, 987, 12, 59, 0]); // [0, 12, 23, 47, 59, 187, 987] -sort(['a', 'z', 'c', 'beta', 'b']); // ['a', 'b', 'beta', 'c', 'z'] - -// ['sit', 'amet', 'lorem', 'ipsum'] -sort(['lorem', 'ipsum', 'sit', 'amet'], function(a, b){ - // sort by length, items with same length - // will keep the relative order (stable) - return a.length - b.length; -}); - -// [4, 3, 2, 1] -sort([2, 3, 1, 4], function(a, b){ - // reverse sort - return b - a; -}); -``` - - - -## sortBy(arr, callback, [context]):Array - -Returns an array sorted by the result of the callback. - -The callback is called for each item that is to be sorted, and the -results of the callback are used to sort the array. The callback -is called with the item as the first parameter, optionally with -the provided context. - -It also supports a shorthand notation which can be used to sort by a property -name. - -See: [`sort`](#sort) - -```js -// Returns [{ a: 1 }, { a: 2 }, { a: 3 }] -sortBy([{ a: 1 }, { a: 3 }, { a: 2 }], - function(item) { return item.a; }); - -// Same as above, using shorthand notation -sortBy([{ a: 1 }, { a: 3 }, { a: 2 }], 'a'); -``` - - - -## split(arr, [segments]):Array - -Splits an array into a fixed number of segments. - -The number of segments is specified by `segments` and defaults to 2. If the -array cannot be evenly split, the first segments will contain the extra items. -If `arr` is empty, an empty array is returned. If `arr.length` is less than -`segments`, then the resulting array will have `arr.length` number of -single-element arrays. - -### Example -```js -split([1, 2, 3, 4, 5], 3) // [ [1, 2], [3, 4], [5] ] -split([1, 2, 3, 4, 5]) // [ [1, 2, 3], [4, 5] ] -split([]) // [] -split([1, 2], 3) // [ [1], [2] ] -``` - - - -## take(times, callback, [thisObj]):Array - -Builds a new array based on the returned values from the given `callback`. - -```js -take(4, function(i, total) { - return i / total; -}); -// > [0, 0.25, 0.5, 0.75] -``` - -see: [function/times](../function.html#times) - - - -## toLookup(arr, key):Object - -Create an object that indexes the items in the array by a key. If `key` is a function, the key for each value in the resulting object will be the result of calling the function with the value as an argument. Otherwise `key` specifies the property on each value to use as the key. - -### Example - -```js -var foo = [{ name: 'a', thing: 1 }, { name: 'b', thing: 2 }]; -// { a: { name: 'a', thing: 1 }, b: { name: 'b', thing: 2 } } -toLookup(foo, 'name'); -// same as above -toLookup(foo, function (value) { return value.name; }); -``` - - - -## union(...arrs):Array - -Concat multiple arrays removing duplicates. - -```js -var a = ['a', 'b'], - b = ['c', 'a'], - c = [1, 'b', 2, 3, 'a']; - -//note that unique remove from begin to end -union(a, b, c); // ['c', 1, 'b', 2, 3, 'a'] -``` - - - -## unique(arr, [compare]):Array - -Return a new Array of unique items. - -**IMPORTANT:** duplicates are removed starting from begining of array. - -```js -var arr = [1, 2, 3, 4, 2, 2, 4]; -var foo = unique(arr); -console.log(foo); -// > [1, 3, 2, 4]; - -// you also have the option to set a custom compare function -var users = [{name: 'john'}, {name: 'paul'}, {name: 'john'}]; -var uniqueNames = unique(arr, function(a, b){ - return a.name === b.name; -}); -console.log(uniqueNames); -// > [{name: 'paul'}, {name: 'john'}] -``` - - - -## xor(arr1, arr2):Array - -Exclusive OR. Returns items that are present in a single array. - -Works like [Python set#symmetric_difference](http://docs.python.org/library/stdtypes.html#set.symmetric_difference) renamed for brevity. - -It will remove duplicates. - -See: [`difference()`](#difference), [`intersection()`](#intersection) - -```js -var a = ['a', 'b', 1]; -var b = ['c', 1]; -xor(a, b); // ['a', 'b', 'c'] -``` - - - -## zip(...arrs):Array - -Groups the elements of each array at their corresponding indexes. - -Useful for separate data sources that are coordinated through matching array -indexes. For a matrix of nested arrays, `zip.apply(...)` can transpose the -matrix in a similar fashion. - -```js -// [['moe', 30, true], ['larry', 40, false], ['curly', 50, false]] -zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]); -``` - - - - -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - - - - - -### [_Resources/node_modules/mout/doc/collection.md](_Resources/node_modules/mout/doc/collection.md) - -# collection # - -Methods for dealing with collections (Array or Objects). - - - -## contains(list, value):Boolean - -Checks if collection contains value. - -```js -contains({a: 1, b: 2, c: 'bar'}, 2); // true -contains([1, 2, 3], 'foo'); // false -``` - -See: [array/contains](array.html#contains), [object/contains](object.html#contains) - - - -## every(list, callback, [thisObj]):Boolean - -Tests whether all values in the collection pass the test implemented by the -provided callback. - -```js -var obj = { - a: 1, - b: 2, - c: 3, - d: 'string' -}; - -every(obj, isNumber); // false -``` - -See: [array/every](array.html#every), [object/every](object.html#every) - - - -## filter(list, callback, [thisObj]):Array - -Filter collection properties. - -See: [array/filter](array.html#filter), [object/filter](object.html#filter) - - - -## find(list, callback, [thisObj]):* - -Loops through all the values in the collection and returns the first one that -passes a truth test (callback). - -**Important:** loop order over objects properties isn't guaranteed to be the -same on all environments. - -```js -find({a: 'foo', b: 12}, isString); // 'foo' -find(['foo', 12], isNumber); // 12 -``` - -See: [array/find](array.html#find), [object/find](object.html#find) - - - -## forEach(list, callback, [thisObj]) - -Loop through all values of the collection. - -See: [array/forEach](array.html#forEach), [object/forOwn](object.html#forOwn) - - - -## map(list, callback, [thisObj]):Array - -Returns a new collection where the properties values are the result of calling -the callback for each property in the original collection. - -See: [array/map](array.html#map), [object/map](object.html#map) - - - -## max(list, [iterator]):* - -Returns maximum value inside collection or use a custom iterator to define how -items should be compared. - -See: [`min()`](#min), [array/max](array.html#max), [object/max](object.html#max) - -```js -max({a: 100, b: 2, c: 1, d: 3, e: 200}); // 200 -max(['foo', 'lorem', 'amet'], function(val){ - return val.length; -}); // 'lorem' -``` - - - -## min(list, [iterator]):* - -Returns minimum value inside collection or use a custom iterator to define how -items should be compared. - -See: [`max()`](#max), [array/min](array.html#min), [object/min](object.html#min) - -```js -min([10, 2, 7]); // 2 -min({a: 'foo', b: 'lorem', c: 'amet'}, function(val){ - return val.length; -}); // 'foo' -``` - - - -## pluck(list, propName):Array - -Extract a list of property values. - -```js -var users = [ - { - name : 'John', - age : 21 - }, - { - name : 'Jane', - age : 27 - } -]; - -pluck(users, 'name'); // ["John", "Jane"] -pluck(users, 'age'); // [21, 27] - -users = { - first: { - name : 'John', - age : 21 - }, - second: { - name : 'Mary', - age : 25 - } -}; - -pluck(users, 'name'); // ['John', 'Mary'] -``` - -See: [array/pluck](array.html#pluck), [object/pluck](object.html#pluck) - - - -## reduce(list, callback, initial, [thisObj]):* - -Apply a function against an accumulator and each value in the collection as to -reduce it to a single value. - -```js -var obj = {a: 1, b: 2, c: 3, d: 4}; - -function sum(prev, cur, key, list) { - return prev + cur; -} - -reduce(obj, sum); // 10 -``` - -See: [array/reduce](array.html#reduce), [object/reduce](object.html#reduce) - - - -## reject(list, fn, [thisObj]):Array - -Creates a new array with all the elements that do **not** pass the truth test. -Opposite of [`filter()`](#filter). - -### Example - -```js -var numbers = [1, 2, 3, 4, 5]; -reject(numbers, function(x) { return (x % 2) !== 0; }); // [2, 4] - -var obj = {a: 1, b: 2, c: 3, d: 4, e: 5}; -reject(obj, function(x) { return (x % 2) !== 0; }); // [2, 4] -``` - -See: [array/reject](array.html#reject), [object/reject](object.html#reject) - - - -## size(list):Number - -Returns the number of values in the collection. - -```js -var obj = { - foo : 1, - bar : 2, - lorem : 3 -}; -size(obj); // 3 -size([1,2,3]); // 3 -size(null); // 0 -``` - -See: [object/size](object.html#size) - - - -## some(list, callback, [thisObj]):Boolean - -Tests whether any values in the collection pass the test implemented by the -provided callback. - -```js -var obj = { - a: 1, - b: 2, - c: 3, - d: 'string' -}; - -some(obj, isNumber); // true -some(obj, isString); // true -some([1, 2, 3], isNumber) // true -some([1, 2, 3], isString) // false -``` - -See: [array/some](array.html#some), [object/some](object.html#some) - - -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - -### [_Resources/node_modules/mout/doc/date.md](_Resources/node_modules/mout/doc/date.md) - -# date # - -Date utilities. - - -## dayOfTheYear(date):Number - -How many days elapsed since begining of the year (following gregorian -calendar). - -```js -// Jan 1st -dayOfTheYear(new Date(2013, 0, 1)); // 1 -// Dec 31th -dayOfTheYear(new Date(2013, 11, 31)); // 364 -``` - - - -## diff(date1, date2, [unitName]):Number - -Calculate the difference between dates (range). - -The returned value is always positive. The default `unitName` is `"ms"`. - -Available units: `year`, `month`, `week`, `day`, `hour`, `minute`, `second`, -`millisecond`. - -See: [`time/convert()`](time.html#convert) - -```js -var d1 = new Date(2012, 4, 5); -var d2 = new Date(2013, 4, 8); -diff(d1, d2); // 31795200000 -diff(d1, d2, 'hour'); // 8832 -diff(d1, d2, 'week'); // 52.57142857142857 -diff(d1, d2, 'month'); // 12.096774193548388 -diff(d1, d2, 'year'); // 1.0082191780821919 -``` - - - -## isLeapYear(fullYear|date):Boolean - -Checks if it's a [leap year](http://en.wikipedia.org/wiki/Leap_year) according -to the Gregorian calendar. - -see: [`totalDaysInMonth()`](#totalDaysInMonth) - -```js -isLeapYear(2012); // true -isLeapYear(2013); // false -isLeapYear(new Date(2012, 2, 28)); // true -``` - - -## isSame(date1, date2[, period]):Boolean - -Check if both dates are the "same". - -You can pass an optional *period* used to set the comparisson precision. - -Available periods: `year`, `month`, `week`, `day`, `hour`, `minute`, `second`. - -```js -var date1 = new Date(2013, 1, 3); -var date2 = new Date(2013, 2, 9); -isSame(date1, date2); // false -isSame(date1, date2, 'day'); // false -isSame(date1, date2, 'month'); // false -isSame(date1, date2, 'year'); // true -``` - - - -## parseIso(str):Number - -Parses an [ISO8601](http://en.wikipedia.org/wiki/Iso8601) date and returns the -number of milliseconds since January 1, 1970, 00:00:00 UTC, or `NaN` if it is -not a valid ISO8601 date. - -This parses *all* ISO8601 dates, including dates without times, [ordinal -dates](https://en.wikipedia.org/wiki/ISO_8601#Ordinal_dates), and the compact -representation (omitting delimeters). The only exception is [ISO week -dates](https://en.wikipedia.org/wiki/ISO_week_date), which are not parsed. - -If no time zone offset is specified, it assumes UTC time. - -```js -// Jan 01, 1970 00:00 GMT -parseIso('1970-01-01T00:00:00') // 0 -parseIso('1970-001') // 0 -parseIso('1970-01-01') // 0 -parseIso('19700101T000000.00') // 0 -parseIso('1970-01-01T02:00+02:00') // 0 - -// Jan 02, 2000 20:10 GMT+04:00 -parseIso('2000-01-02T20:10+04:00') // 946829400000 -``` - - -## quarter(date):Number - -Get a number between 1 to 4 that represents the quarter of the year. - -```js -quarter(new Date(2013, 1, 19)); // 1 -quarter(new Date(2013, 4, 12)); // 2 -quarter(new Date(2013, 7, 25)); // 3 -quarter(new Date(2013, 10, 8)); // 4 -``` - - -## startOf(date, period):Date - -Get a new Date at the start of the period. - -Available periods: `year`, `month`, `week`, `day`, `hour`, `minute`, `second`. - -```js -// Apr 05 2013 11:27:43 -var date = new Date(2013, 3, 5, 11, 27, 43, 123); -startOf(date, 'year'); // Jan 01 2013 00:00:00 -startOf(date, 'month'); // Apr 01 2013 00:00:00 -startOf(date, 'day'); // Apr 05 2013 00:00:00 -startOf(date, 'hour'); // Apr 05 2013 11:00:00 -``` - - - -## strftime(date, format, [l10n]):String - -Format date based on strftime format. - -Replaced tokens: - -

%a: locale's abbreviated weekday name.
%A: locale's full weekday name.
%b: locale's abbreviated month name.
%B: locale's full month name.
%c: locale's appropriate date and time representation.
%C: century number (the year divided by 100 and truncated -to an integer) as a decimal number [00..99].
%d: day of the month as a decimal number [01..31].
%D: same as %m/%d/%y.
%e: day of the month as a decimal number [1..31]; -a single digit is preceded by a space.
%F: The ISO 8601 date format (%Y-%m-%d)
%h: same as %b.
%H: hour (24-hour clock) as a decimal number [00..23].
%I: hour (12-hour clock) as a decimal number [01..12].
%j: day of the year as a decimal number [001..366].
%l: hour (12-hour clock) as a decimal number (range 1 to 12); single digits are preceded by a blank
%L: zero-padded milliseconds [000..999]
%m: month as a decimal number [01..12].
%M: minute as a decimal number [00..59].
%n: newline character.
%p: locale's equivalent of either "am" or "pm"
%P: locale's equivalent of either "AM" or "PM"
%r: time in a.m. and -p.m. notation; in the POSIX locale this is equivalent to %I:%M:%S %p.
%R: time in 24 hour notation (%H:%M).
%s: seconds since Epoch (1970-01-01 00:00:00 UTC)
%S: second as a decimal number [00..60].
%t: tab character.
%T: time (%H:%M:%S).
%u: weekday as a decimal number [1..7], with 1 representing -Monday.
%U: week number of the year (Sunday as the first day of -the week) as a decimal number [00..53].
%V: week number of the year (Monday as the first day of the -week) as a decimal number [01..53]. If the week containing 1 January has -four or more days in the new year, then it is considered week 1. Otherwise, -it is the last week of the previous year, and the next week is week 1.
%w: weekday as a decimal number [0..6], with 0 representing -Sunday.
%W: week number of the year (Monday as the first day of -the week) as a decimal number [00..53]. All days in a new year preceding -the first Monday are considered to be in week 0.
%x: locale's appropriate date representation.
%X: locale's appropriate time representation.
%y: year without century as a decimal number [00..99].
%Y: year with century as a decimal number.
%Z: timezone name or abbreviation, or by no bytes -if no timezone information exists.
%%: is replaced by %.

- -```js -var date = new Date(2013, 3, 8, 9, 2, 4); -strftime(date, '%Y-%m-%d'); // "2013-04-08" -strftime(date, '%R'); // "09:02" -strftime(date, '%Y-%m-%dT%H:%M:%S%z'); // "2013-04-08T09:02:04+0000" -``` - -You can also set a custom locale: - -```js -var ptBr = require('mout/date/i18n/pt-BR'); -strftime(date, '%a, %d %b', ptBr); // 'Seg, 08 Abr' -strftime(date, '%A, %d %B', ptBr); // 'Segunda, 08 Abril' -``` - -To set it globally: - -```js -require('mout/date/i18n_').set( customLocaleData ); -``` - -See [date/i18n](https://github.com/mout/mout/tree/master/src/date/i18n) -for localization examples. - - - -## timezoneAbbr(date):String - -Return timezone abbreviation or similar data. - -The result will vary based on the OS/browser since some environments doesn't -provide enough info about the current locale. - -```js -// IE 7-8 -timezoneAbbr(new Date()); // "-0500" -// Chrome, FF, V8 -timezoneAbbr(new Date()); // "EST" -``` - - - -## timezoneOffset(date):String - -Return time zone as hour and minute offset from UTC (e.g. +0900). - -It's important to note that JavaScript Date object will use the system locale -info to determinate the [timezone -offset](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset) -and that daylight saving time affects the result. - -```js -// if system locale is EST -timezoneOffset(new Date()); // -0500 -``` - - - -## totalDaysInMonth(fullYear, monthIndex):Number - -Returns the amount of days in the month taking into consideration leap years -(following Gregorian calendar). - -see: [`isLeapYear()`](#isLeapYear) - -```js -totalDaysInMonth(2008, 1); // 29 (leap year) -totalDaysInMonth(2009, 1); // 28 - -// you can also pass a Date object as single argument -totalDaysInMonth( new Date(2013, 0, 1) ); // 31 -``` - - -## totalDaysInYear(fullYear):Number - -Returns the amount of days in the year taking into consideration leap years -(following Gregorian calendar). - -see: [`isLeapYear()`](#isLeapYear), [`totalDaysInMonth()`](#totalDaysInMonth) - -```js -totalDaysInYear(2008); // 366 (leap year) -totalDaysInYear(2009); // 365 - -// you can also pass a Date object as single argument -totalDaysInYear( new Date(2013, 0, 1) ); // 365 -``` - - - -## weekOfTheYear(date, [firstDayOfWeek]):Number - -Returns how many weeks elapsed since start of the year (`0..53`). - -`firstDayOfWeek` can be `0` (Sunday) or `1` (Monday). By default weeks start at -Sunday. - -It will return `0` if `date` is before the first `firstDayOfWeek` of the year. - -```js -// Tue Jan 01 2013 -weekOfTheYear( new Date(2013,0,1) ); // 0 -// Wed Jan 09 2013 -weekOfTheYear( new Date(2013,0,9) ); // 1 -// Sun Jan 01 2012 -weekOfTheYear( new Date(2012,0,1) ); // 1 -// Mon Jan 09 2012 -weekOfTheYear( new Date(2012,0,9) ); // 2 -``` - - - -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - - -### [_Resources/node_modules/mout/doc/function.md](_Resources/node_modules/mout/doc/function.md) - -# function # - -Function*(al)* utilities. - -## after(fn, n):Function - -This creates a function that will only call `fn` if it was called `n` or more times. - - -```js -function onLoaded() { - console.log('all images loaded'); -} - -var imagePaths = ['1.jpg', '2.jpg', '3.jpg']; -var callback = after(onLoaded, imagePaths.length); - -forEach(imagePaths, function(path) { - asyncLoad(path, callback); -}); -``` - -## awaitDelay(fn, delay):Function - -Returns a function that ensures that `fn` is only called *after* `delay` -milliseconds have elapsed. When the returned function is called before the -delay has elapsed, it will wait until the delay has elapsed and then call `fn`. -When the returned function is called after the delay has elapsed, it will call -`fn` after the next "tick" (it will always be called asynchronously). The -context and arguments that the returned function is called in are applied to -`fn`. - -In the below example `onLoaded` will not be executed before a 1000 millisecond -delay. Even if `loadImages` loads and calls `callback` earlier. However, say -the images take 1500 milliseconds to load, it will trigger `onLoaded` -immediately. - -```js -var callback = awaitDelay(onLoaded, 1000); -loadImages(callback); -function onLoaded(){ - console.log('loaded'); -} -``` - -You can also cancel de delayed call by simply using the native `clearTimeout` -method (like a regular `setTimeout` call). - -```js -var timeoutId = callback(); -// onLoaded won't be called since it was canceled before the 1000ms delay -clearTimeout(timeoutId); -``` - -### Arguments: - - 1. `fn` (Function) : Target Function - 2. `delay` (Number) : Delay of execution in milliseconds - -See: [`debounce()`](#debounce) - - - -## bind(fn, context, [...args]):Function - -Return a function that will execute in the given context, optionally adding any additional supplied parameters to the beginning of the arguments collection. - -### Arguments - - 1. `fn` (Function) : Target Function - 2. `context` (Object) : Execution context (object used as `this`) - 3. `[...args]` (*) : Arguments (0...n arguments) - -See: [`partial()`](#partial), [object/bindAll](./object.html#bindAll) - - - -## compose(...fn):Function - -Returns the composition of a list of functions, where each function consumes -the return value of the function that follows. In math terms, composing the -functions `f()`, `g()`, and `h()` produces `f(g(h()))`. - -```js -function add2(x) { return x + 2 } -function multi2(x) { return x * 2 } -map([1, 2, 3], compose(add2, multi2)); // [4, 6, 8] - -//same as -map([1, 2, 3], function(x){ - return add2( multi2(x) ); -}); -``` - - - -## constant(value):Function - -Returns a new function that will always return `value` when called. - -```js -var f = constant('foo'); -f(); // 'foo' - -// Provided arguments are ignored; value is always returned -f(1); // 'foo' - -f = constant({ foo: 'bar' }); -f(); // { foo: 'bar' } -``` - - - -## debounce(fn, delay[, isAsap]):Function - -Creates a function that will delay the execution of `fn` until after `delay` -milliseconds have elapsed since the last time it was invoked. - -Subsequent calls to the debounced function will return the result of the last -`fn` call. - -```js -// sometimes less is more -var lazyRedraw = debounce(redraw, 300); -foo.on.resize.add(lazyRedraw); -``` - -In this visualization, `|` is a debounced-function call and `X` is the actual -callback execution: - - Default - ||||||||||||||||||||||||| (pause) ||||||||||||||||||||||||| - X X - - Debounced with `isAsap == true`: - ||||||||||||||||||||||||| (pause) ||||||||||||||||||||||||| - X X - -You also have the option to cancel the debounced call if it didn't happen yet: - -```js -lazyRedraw(); -// lazyRedraw won't be called since `cancel` was called before the `delay` -lazyRedraw.cancel(); -``` - -See: [`throttle()`](#throttle) - - -## func(name):Function - -Returns a function that calls a method with given `name` on supplied object. -Useful for iteration methods like `array/map` and `array/forEach`. - -See: [`prop()`](#prop) - -```js -// will call the method `getName()` for each `user` -var names = map(users, func('getName')); -``` - - - -## identity(val):* - -Returns the first argument provided to it. - -```js -identity(3); // 3 -identity(1,2,3); // 1 -identity('foo'); // "foo" -``` - - - -## partial(fn, [...args]):Function - -Return a partially applied function supplying default arguments. - -This method is similar to [`bind`](#bind), except it does not alter the this -binding. - -### Arguments - - 1. `fn` (Function) : Target Function - 2. `[...args]` (*) : Arguments (0...n arguments) - -See: [`bind()`](#bind) - -```js -function add(a, b){ return a + b } -var add10 = partial(add, 10); -console.log( add10(2) ); // 12 -``` - - - -## prop(name):Function - -Returns a function that gets a property with given `name` from supplied object. -Useful for using in conjunction with `array/map` and/or for creating getters. - -See: [`array/pluck()`](array.html#pluck) - -```js -var users = [{name:"John", age:21}, {name:"Jane", age:25}]; -// ["John", "Jane"] -var names = map(users, prop('name')); -``` - - - -## series(...fn):Function - -Returns a function that will execute all the supplied functions in order and -passing the same parameters to all of them. Useful for combining multiple -`array/forEach` into a single one and/or for debugging. - -```js -// call `console.log()` and `doStuff()` for each item item in the array -forEach(arr, series(console.log, doStuff)); -``` - - - -## throttle(fn, interval):Function - -Creates a function that, when executed, will only call the `fn` function at -most once per every `interval` milliseconds. - -If the throttled function is invoked more than once during the wait timeout, -`fn` will also be called on the trailing edge of the timeout. - -Subsequent calls to the throttled function will return the result of the last -`fn` call. - -```js -// sometimes less is more -var lazyRedraw = throttle(redraw, 300); -foo.on.resize.add(lazyRedraw); -``` - -In this visualization, `|` is a throttled-function call and `X` is the actual -`fn` execution: - - ||||||||||||||||||||||||| (pause) ||||||||||||||||||||||||| - X X X X X X X X X X X X - -You also have the option to cancel the throttled call if it didn't happen yet: - -```js -lazyRedraw(); -setTimeout(function(){ - lazyRedraw(); - // lazyRedraw will be called only once since `cancel` was called before - // the `interval` for 2nd call completed - lazyRedraw.cancel(); -}, 250); -``` - -See: [`debounce()`](#debounce) - - -## timeout(fn, millis, context, [...args]):Number - -Functions as a wrapper for `setTimeout`. Calls a the function `fn` after a given delay `millis` in milliseconds. -The function is called within the specified context. The return value can be used to clear the timeout using `clearTimeout`. - -```js -var id = timeout(doStuff, 300, this); - -clearTimeout(id); -``` - -## times(n, callback, [context]):void - -Iterates over a callback `n` times. - -### Arguments - - 1. `n` (Number) : Number of iterations - 2. `callback` (Function) : Closure executed for every iteration - 3. `context` (Object) : Execution context (object used as `this`) - -```js -var output = ''; -times(5, function(i) { - output += i.toString(); -}); -// output: 01234 -``` - -## wrap(fn, wrapper):Function - -Wraps the first `fn` inside of the `wrapper` function, passing it as the first argument. This allows the `wrapper` to execute code before and after the `fn` runs, adjust the arguments, and execute it conditionally. - -```js -var hello = function(name) { return "hello: " + name; }; -hello = wrap(hello, function(func) { - return "before, " + func("moe") + ", after"; -}); -hello(); -// output: 'before, hello: moe, after' -``` - -See: [`partial()`](#partial) -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - -### [_Resources/node_modules/mout/doc/lang.md](_Resources/node_modules/mout/doc/lang.md) - -# lang # - -Language Utilities. Easier inheritance, scope handling, type checks. - - - -## clone(val):* - -Clone native types like Object, Array, RegExp, Date and primitives. - -This method will not clone values that are referenced within `val`. It will -only copy the value reference to the new value. If the value is not a plain -object but is an object, it will return the value unchanged. - -### Example - -```js -var a = { foo: 'bar' }; -var b = clone(a); -console.log(a === b); // false -console.log(a.foo === b.foo); // true - -var c = [1, 2, 3]; -var d = clone(b); -console.log(c === d); // false -console.log(c); // [1, 2, 3] -``` - -See: [`deepClone()`](#deepClone) - - - -## createObject(parent, [props]):Object - -Create Object using prototypal inheritance and setting custom properties. - -Mix between [Douglas Crockford Prototypal Inheritance](http://javascript.crockford.com/prototypal.html) and [`object/mixIn`](./object.html#mixIn). - -### Arguments - - 1. `parent` (Object) : Parent Object - 2. `[props]` (Object) : Object properties - -### Example - -```js -var base = { - trace : function(){ - console.log(this.name); - } -}; - -var myObject = createObject(base, { - name : 'Lorem Ipsum' -}); - -myObject.trace(); // "Lorem Ipsum" -``` - - - -## ctorApply(constructor, args):Object - -Do `Function.prototype.apply()` on a constructor while maintaining prototype -chain. - -```js -function Person(name, surname) { - this.name = name; - this.surname = surname; -} - -Person.prototype.walk = function(){ - console.log(this.name +' is walking'); -}; - -var args = ['John', 'Doe']; - -// "similar" effect as calling `new Person("John", "Doe")` -var john = ctorApply(Person, args); -john.walk(); // "John is walking" -``` - - - -## deepClone(val, [instanceClone]):* - -Deep clone native types like Object, Array, RegExp, Date and primitives. - -The `instanceClone` function will be invoked to clone objects that are not -"plain" objects (as defined by [`isPlainObject`](#isPlainObject)) if it is -provided. If `instanceClone` is not specified, it will not attempt to clone -non-plain objects, and will copy the object reference. - -### Example - -```js -var a = {foo:'bar', obj: {a:1, b:2}}; -var b = deepClone(a); // {foo:'bar', obj: {a:1, b:2}} -console.log( a === b ); // false -console.log( a.obj === b.obj ); // false - -var c = [1, 2, [3, 4]]; -var d = deepClone(c); // [1, 2, [3, 4]] -var e = c.concat(); // [1, 2, [3, 4]] - -console.log( c[2] === d[2] ); // false -// concat doesn't do a deep clone, arrays are passed by reference -console.log( e[2] === d[2] ); // true - -function Custom() { } -function cloneCustom(x) { return new Custom(); } -var f = { test: new Custom() }; -var g = deepClone(f, cloneCustom); -g.test === f.test // false, since new Custom instance will be created -``` - -See: [`clone()`](#clone) - - - -## deepEquals(a, b, [callback]):Boolean - -Recursively tests whether two values contains the same keys and values. - -`callback` specifies the equality comparison function used to compare -non-object values. It defaults to using the [`is()`](#is) function. - -If the values are both an object or array, it will recurse into both values, -checking if their keys/values are equal. It will only check the keys and values -contained by the objects; it will not check the objects' prototypes. If either -of the values are not objects, they will be checked using the `callback` -function. - -Example: - -```js -deepEquals({ a: 1 }, { a: 1 }); // true -deepEquals({ value: { a: 1 } }, { value: { a: 1 } }); // true -deepEquals({ value: { a: 1 } }, { value: { a: 2 } }); // false -deepEquals({ value: { a: 1 } }, { value: { a: 1, b: 2 } }); // false -deepEquals({}, null); // false -deepEquals(null, null); // true -deepEquals( - { a: { b: 1 } }, - { a: { b: '1' } }, - function(a, b) { return a == b; }); // true -``` - -See: [object/equals](object.html#equals), [array/equals](array.html#equals) - - - -## defaults(val, ...defaults):void - -Return first value that isn't `null` or `undefined`. - - function doSomethingAwesome(foo, bar) { - // default arguments - foo = defaults(foo, 'lorem'); - bar = defaults(bar, 123); - // ... - } - - - -## GLOBAL:Object - -Reference to the global context (`window` inside a browser, `global` on -node.js). Works on ES3 and ES5 strict-mode. - - - -## inheritPrototype(childCtor, parentCtor):Object - -Inherit the prototype methods from one constructor into another. - -Similar to [node.js util/inherits](http://nodejs.org/docs/latest/api/util.html#util_util_inherits_constructor_superconstructor). - -It returns the the `childCtor.prototype` for convenience. - -```js -function Foo(name){ - this.name = name; -} -Foo.prototype = { - getName : function(){ - return this.name; - } -}; - -function Bar(name){ - Foo.call(this, name); -} -//should be called before calling constructor -var proto = inheritPrototype(Bar, Foo); - -// for convenience we return the new prototype object -console.log(proto === Bar.prototype); // true - -var myObj = new Bar('lorem ipsum'); -myObj.getName(); // "lorem ipsum" - -console.log(myObj instanceof Foo); // true - -// you also have access to the "super" constructor -console.log(Bar.super_ === Foo); // true -``` - - -## is(x, y):Boolean - -Check if both values are identical/egal. - -```js -// wtfjs -NaN === NaN; // false --0 === +0; // true - -is(NaN, NaN); // true -is(-0, +0); // false -is('a', 'b'); // false -``` - -See: [`isnt()`](#isnt) - - - -## isnt(x, y):Boolean - -Check if both values are not identical/egal. - -```js -// wtfjs -NaN === NaN; // false --0 === +0; // true - -isnt(NaN, NaN); // false -isnt(-0, +0); // true -isnt('a', 'b'); // true -``` - -See: [`is()`](#is) - - - - -## isArguments(val):Boolean - -If value is an "Arguments" object. - - - -## isArray(val):Boolean - -If value is an Array. Uses native ES5 `Array.isArray()` if available. - - - -## isBoolean(val):Boolean - -If value is a Boolean. - - - -## isDate(val):Boolean - -If value is a Date. - - - -## isEmpty(val):Boolean - -Checks if Array/Object/String is empty. - -Will return `true` for any object that doesn't contain enumerable properties -and also to any type of value that isn't considered a collection (boolean, -null, undefined, function, etc). - -```js -isEmpty(''); // true -isEmpty('bar'); // false -isEmpty([]); // true -isEmpty([1, 2]); // false -isEmpty({}); // true -isEmpty({a:1, b:2}); // false -// null, undefined, booleans, numbers are considered as "empty" values -isEmpty(null); // true -isEmpty(undefined); // true -isEmpty(123); // true -isEmpty(true); // true -``` - - -## isFinite(val):Boolean - -Checks if value is Finite. - -**IMPORTANT:** This is not the same as native `isFinite`, which will return -`true` for values that can be coerced into finite numbers. See -http://es5.github.com/#x15.1.2.5. - -```js -isFinite(123); // true -isFinite(Infinity); // false - -// this is different than native behavior -isFinite(''); // false -isFinite(true); // false -isFinite([]); // false -isFinite(null); // false -``` - - -## isFunction(val):Boolean - -If value is a Function. - - - -## isKind(val, kind):Boolean - -If value is of "kind". (used internally by some of the *isSomething* checks). - -Favor the other methods since strings are commonly mistyped and also because -some "kinds" can only be accurately checked by using other methods (e.g. -`Arguments`), some of the other checks are also faster. - -```js -isKind([1,2], 'Array'); // true -isKind(3, 'Array'); // false -isKind(3, 'Number'); // true -``` - -See: [`kindOf()`](#kindOf) - - - -## isInteger(val):Boolean - -Check if value is an integer. - -```js -isInteger(123); // true -isInteger(123.45); // false -isInteger({}); // false -isInteger('foo'); // false -isInteger('123'); // false -``` - - - -## isNaN(val):Boolean - -Check if value is not a number. - -It doesn't coerce value into number before doing the check, giving better -results than native `isNaN`. Returns `true` for everything besides numeric -values. - -**IMPORTANT:** behavior is very different than the native `isNaN` and way more -useful!!! See: http://es5.github.io/#x15.1.2.4 - -```js -isNaN(123); // false - -isNaN(NaN); // true -isNaN({}); // true -isNaN(undefined); // true -isNaN([4,5]); // true - -// these are all "false" on native isNaN and main reason why this module exists -isNaN(''); // true -isNaN(null); // true -isNaN(true); // true -isNaN(false); // true -isNaN("123"); // true -isNaN([]); // true -isNaN([5]); // true -``` - - - -## isNull(val):Boolean - -If value is `null`. - - - -## isNumber(val):Boolean - -If value is a Number. - - - -## isObject(val):Boolean - -If value is an Object. - - - -## isPlainObject(val):Boolean - -If the value is an Object created by the Object constructor. - - - -## isRegExp(val):Boolean - -If value is a RegExp. - - - -## isString(val):Boolean - -If value is a String. - - - -## isUndefined(val):Boolean - -If value is `undefined`. - - - -## kindOf(val):String - -Gets kind of value (e.g. "String", "Number", "RegExp", "Null", "Date"). -Used internally by `isKind()` and most of the other *isSomething* checks. - -```js -kindOf([1,2]); // "Array" -kindOf('foo'); // "String" -kindOf(3); // "Number" -``` - -See: [`isKind()`](#isKind) - - -## toArray(val):Array - -Convert array-like object into Array or wrap value into Array. - -```js -toArray({ - "0" : "foo", - "1" : "bar", - "length" : 2 -}); // ["foo", "bar"] - -function foo(){ - return toArray(arguments); -} -foo("lorem", 123); // ["lorem", 123] - -toArray("lorem ipsum"); // ["lorem ipsum"] -toArray(window); // [window] -toArray({foo:"bar", lorem:123}); // [{foo:"bar", lorem:123}] -``` - -See: object/values() - - - -## toNumber(val):Number - -Convert value into number. - -```js -// numeric values are typecasted as Number -toNumber('123'); // 123 -toNumber(-567); // -567 - -// falsy values returns zero -toNumber(''); // 0 -toNumber(null); // 0 -toNumber(undefined); // 0 -toNumber(false); // 0 - -// non-numeric values returns NaN -toNumber('asd'); // NaN -toNumber({}); // NaN -toNumber([]); // NaN - -// Date objects return milliseconds since epoch -toNumber(new Date(1985, 6, 23)); // 490935600000 -``` - - - -## toString(val):String - -Convert any value to its string representation. - -Will return an empty string for `undefined` or `null`, otherwise will convert -the value to its string representation. - -```js -// null and undefined are converted into empty strings -toString(null); // "" -toString(undefined); // "" - -toString(1); // "1" -toString([1,2,3]); // "1,2,3" -toString(false); // "false" - -// uses `val.toString()` to convert value -toString({toString:funtion(){ return 'foo'; }}); // "foo" -``` - - - -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - -### [_Resources/node_modules/mout/doc/math.md](_Resources/node_modules/mout/doc/math.md) - -# math # - -Math utilities. - - -## ceil(val[, step]):Number - -Round value up to full steps. Similar to `Math.ceil()` but can round value -to an arbitrary *radix*. - - ceil(7.2); // 8 - ceil(7.8); // 8 - ceil(7, 5); // 10 - ceil(11, 5); // 15 - ceil(15, 5); // 15 - -### Common use cases - -Round values by increments of 5/10/1000/etc. - -See: [`round()`](#round), [`floor()`](#floor), [`countSteps()`](#countSteps) - - - -## clamp(val, min, max):Number - -Clamps value inside range. - -`clamp()` is extremely useful in cases where you need to limit a value inside -a certain range. So instead of doing a complex `if/else` to filter/process the -value you can restrict it to always be inside the desired range: - - clamp(-5, 0, 10); // 0 - clamp(7, 1, 10); // 7 - clamp(8, 1, 10); // 8 - clamp(10, 1, 10); // 10 - clamp(11, 1, 10); // 10 - -If the value is smaller than `min` it returns the `min`, if `val` is higher -than `max` it returns `max`. - -### Common use cases - -Any situation where you need to limit a number inside a range like: slider -position, image galleries (so user can't skip to an image that doesn't -exist), drag and drop, scroll boundaries, etc. - -See: [`loop()`](#loop) - - - - -## countSteps(val, step[, overflow]):Number - -Count number of full steps. - -### Arguments: - - 1. `val` (Number) : Value. - 2. `step` (Number) : Step size. - 3. `[overflow]` (Number) : Maximum number of steps, nSteps will loop if -`>=` than overflow. - - -Count steps is very useful for cases where you need to know how many "full -steps" the number *completed*. Think of it as a division that only returns -integers and ignore remainders. - - countSteps(3, 5); // 0 - countSteps(6, 5); // 1 - countSteps(12, 5); // 2 - countSteps(18, 5); // 3 - countSteps(21, 5); // 4 - -You can also set an `overflow` which will reset the *counter* before reaching -this number. - - countSteps(3, 5, 3); // 0 - countSteps(6, 5, 3); // 1 - countSteps(12, 5, 3); // 2 - countSteps(18, 5, 3); // 0 - countSteps(21, 5, 3); // 1 - -### Common use cases - -#### How many items fit inside an area: - - var containerWidth = 100; - var itemWidth = 8; - var howManyFit = countSteps(containerWidth, itemWidth); // 12 - -#### Split value into different scales or convert value from one scale to another - -From [mout/time/parseMs](time.html#parseMs): - - function parseMs(ms){ - return { - milliseconds : countSteps(ms, 1, 1000), - seconds : countSteps(ms, 1000, 60), - minutes : countSteps(ms, 60000, 60), - hours : countSteps(ms, 3600000, 24), - days : countSteps(ms, 86400000) - }; - } - - // {days:27, hours:4, minutes:26, seconds:5, milliseconds:454} - parseMs(2348765454); - - - -## floor(val[, step]):Number - -Round value down to full steps. Similar to `Math.floor()` but can round value -to an arbitrary *radix*. (formerly `snap`) - - floor(7.2); // 7 - floor(7.8); // 7 - floor(7, 5); // 5 - floor(11, 5); // 10 - floor(15, 5); // 15 - -### Common use cases - -Round values by increments of 5/10/1000/etc. - -See: [`round()`](#round), [`ceil()`](#ceil), [`countSteps()`](#countSteps) - - - -## inRange(val, min, max[, threshold]):Boolean - -Checks if value is inside the range. - - inRange(-6, 1, 10); // false - inRange( 5, 1, 10); // true - inRange(12, 1, 10); // false - -The threshold can be useful when you want granular control of what should match -and/or the precision could change at runtime or by some configuration option, -avoids the clutter of adding/subtracting the `threshold` from `mix` and `max`. - - inRange(12, 1, 10, 2); // true - inRange(13, 1, 10, 2); // false - -### Common use cases - -Anything that needs to check if value is inside a range, be it collision -detection, limiting interaction by mouse position, ignoring parts of the logic -that shouldn't happen if value isn't valid, simplify `if/else` conditions, -making code more readable, etc... - - - - -## isNear(val, target, threshold):Boolean - -Check if value is close to target. - -Similar to `inRange()` but used to check if value is close to a certain value -or match the desired value. Basically to simplify `if/else` conditions and to -make code clearer. - - isNear( 10.2, 10, 0.5); // true - isNear( 10.5, 10, 0.5); // true - isNear(10.51, 10, 0.5); // false - -### Common use cases - -Games where a certain action should happen if an *actor* is close to a target, -gravity fields, any numeric check that has some tolerance. - - - - -## lerp(ratio, start, end):Number - -Linear interpolation. - - lerp(0.5, 0, 10); // 5 - lerp(0.75, 0, 10); // 7.5 - -### Common use cases - -Linear interpolation is commonly used to create animations of elements moving -from one point to another, where you simply update the current ratio (which in -this case represents time) and get back the position of the element at that -"frame". - -The core idea of `lerp` is that you are using a number that goes from `0` to -`1` to specify a ratio inside that scale. This concept can be applied to -convert numbers from different scales easily. - -See: [`map()`](#map), [`norm()`](#norm) - - - - -## loop(val, min, max):Number - -Loops value inside range. Will return `min` if `val > max` and `max` if `val -< min`, otherwise it returns `val`. - - loop(-1, 0, 10); // 10 - loop( 1, 0, 10); // 1 - loop( 5, 0, 10); // 5 - loop( 9, 0, 10); // 9 - loop(10, 0, 10); // 10 - loop(11, 0, 10); // 0 - -Similar to [`clamp()`](#clamp) but *loops* the value inside the range when an -overflow occurs. - -### Common use cases - -Image galleries, infinite scroll, any kind of logic that requires that the -first item should be displayed after the last one or the last one should be -displayed after first if going on the opposite direction. - -See: [`clamp()`](#clamp) - - - - -## map(val, min1, max1, min2, max2):Number - -Maps a number from one scale to another. - - map(3, 0, 4, -1, 1) // 0.5 - map(3, 0, 10, 0, 100) // 30 - -### Common use cases - -Very useful to convert values from/to multiple scales. - -Let's suppose we have a slider that needs to go from `2000` to `5000` and that slider -has `300px` of width, here is how we would translate the knob position into the -current value: - - var knobX = 123; - var sliderWid = 300; - var minVal = 2000; - var maxVal = 5000; - - var curVal = map(knobX, 0, sliderWid, minVal, maxVal); // 3230 - -See: [`lerp()`](#lerp), [`norm()`](#norm) - - - - -## norm(val, min, max):Number - -Gets normalized ratio of value inside range. - -If `val < min` or `val > max` it will throw a `RangeError` since we can't -normalize the value. - - norm(50, 0, 100); // 0.5 - norm(75, 0, 100); // 0.75 - norm(100, 0, 100); // 1 - norm(-50, 0, 100); // RangeError: value (-50) must be between 0 and 100 - -### Common use cases - -Convert values between scales, used by [`map()`](#map) internally. Direct -opposite of [`lerp()`](#lerp). - -See: [`lerp()`](#lerp), [`map()`](#map) - - -## overflow(val[, min], max):Number - -Wraps number within [min, max). When no `min` is given, the value `0` is assumed. -A number larger or equal `max` loops around and starts over at `min`. For positive numbers larger -or equal max this method behaves identical to the modulo operator. -Numbers smaller than min loop around and start over at `max`. - - overflow(13, 5, 10); // 8 - overflow(3, 5, 10); // 8 - overflow(23, 5); // 3 - overflow(-10, -7, -1); // -4 - -See: [`loop()`](#loop) - - -## round(val[, step]):Number - -Round value to full steps. Similar to `Math.round()` but allow setting an -arbitrary *radix*. - - // default - round(0.22); // 0 - round(0.49); // 0 - round(0.51); // 1 - - // custom radix - round(0.22, 0.5); // 0 - round(0.49, 0.5); // 0.5 - round(0.51, 0.5); // 0.5 - round(0.74, 0.5); // 0.5 - round(0.75, 0.5); // 1 - round(1.24, 0.5); // 1 - round(1.25, 0.5); // 1.5 - round(1.74, 0.5); // 1.5 - -### Common use cases - -Round values by increments of 0.5/5/10/1000/etc. - -See: [`floor()`](#floor), [`ceil()`](#ceil), [`countSteps()`](#countSteps) - - -------------------------------------------------------------------------------- - -For more usage more info check the specs and source code. - - - -### [_Resources/node_modules/mout/doc/number.md](_Resources/node_modules/mout/doc/number.md) - -# number # - -Number utilities. - - -## abbreviate(val[, nDecimalDigits, dictionary]):String - -Abbreviate number to thousands (K), millions (M) or billions (B). - -The default value for `nDecimalDigits` is `1`. - -### Example - - abbreviate(123456); // "123.5K" - abbreviate(12345678); // "12.3M" - abbreviate(1234567890); // "1.2B" - -You can set the amount of decimal digits (default is `1`): - - abbreviate(543); // "0.5K" - abbreviate(543, 1); // "0.5K" - abbreviate(543, 2); // "0.54K" - abbreviate(543, 3); // "0.543K" - -You can customize the abbreviation by passing a custom "dictionary": - - var _ptbrDict = { - thousand: ' mil', - million: ' Mi', - billion: ' Bi' - }; - function customAbbr(val) { - return abbreviate(val, 1, _ptbrDict); - } - - customAbbr(123456); // "123.5 mil" - customAbbr(12345678); // "12.3 Mi" - customAbbr(1234567890); // "1.2 Bi" - - - -## currencyFormat(val[, nDecimalDigits, decimalSeparator, thousandsSeparator]):String - -Format a number as currency. - -### Example: - - currencyFormat(1000); // "1,000.00" - currencyFormat(1000, 1); // "1,000.0" - currencyFormat(1000, 2, ',', '.'); // "1.000,00" - - - -## enforcePrecision(val, nDecimalDigits):Number - -Enforce a specific amount of decimal digits and also fix floating point -rounding issues. - -### Example: - -```js -enforcePrecision(0.615, 2); // 0.62 -enforcePrecision(0.625, 2); // 0.63 -//floating point rounding "error" (rounds to odd number) -+(0.615).toFixed(2); // 0.61 -+(0.625).toFixed(2); // 0.63 -``` - - -## isNaN(val):Boolean - -ES6 `Number.isNaN()`, checks if supplied value is `NaN`. - -```js -// only returns `true` for `NaN` -isNaN(NaN); // true -isNaN(0 / 0); // true - -// everything else is `false` -isNaN(true); // false -isNaN(123); // false -isNaN('asd'); // false -isNaN('NaN'); // false -``` - - -## MAX_INT:Number - -Maximum 32-bit signed integer value. `Math.pow(2, 31) - 1` - -### Example: - -```js -console.log( MAX_INT ); // 2147483647 -``` - - -## MAX_SAFE_INTEGER:Number - -Maximum safe integer. `Math.pow(2,53) − 1` - - -## MAX_UINT:Number - -Maximum 32-bit unsigned integer value. `Math.pow(2, 32) - 1` - -### Example: - -```js -console.log( MAX_UINT ); // 4294967295 -``` - - -## MIN_INT:Number - -Minimum 32-bit signed integer value. `Math.pow(2, 31) * -1`. - -### Example: - -```js -console.log( MIN_INT ); // -2147483648 -``` - - -## nth(n):String - -Returns the "nth" of number. (`"st"`, `"nd"`, `"rd"`, `"th"`) - -```js -nth(1); // "st" -nth(2); // "nd" -nth(12); // "th" -nth(22); // "nd" -nth(23); // "rd" -nth(34); // "th" -``` - -See: [`ordinal()`](#ordinal) - - - -## ordinal(n):String - -Converts number into ordinal form (1st, 2nd, 3rd, 4th, ...) - -```js -ordinal(1); // "1st" -ordinal(2); // "2nd" -ordinal(3); // "3rd" -ordinal(14); // "14th" -ordinal(21); // "21st" -``` - -See: [`nth()`](#nth) - - - -## pad(n, minLength[, char]):String - -Add padding zeros if `n.length` < `minLength`. - -### Example: - -```js -pad(1, 5); // "00001" -pad(12, 5); // "00012" -pad(123, 5); // "00123" -pad(1234, 5); // "01234" -pad(12345, 5); // "12345" -pad(123456, 5); // "123456" - -// you can also specify the "char" used for padding -pad(12, 5, '_'); // "___12" -``` - -see: [string/lpad](./string.html#lpad) - - - -## rol(val, shift):Number - -Bitwise circular shift left. - -More info at [Wikipedia#Circular_shift](http://en.wikipedia.org/wiki/Circular_shift) - - - -## ror(val, shift):Number - -Bitwise circular shift right. - -More info at [Wikipedia#Circular_shift](http://en.wikipedia.org/wiki/Circular_shift) - - - -## sign(val):Number - -Returns `-1` if value is negative, `0` if the value is `0` and `1` if value is positive. Useful for -multiplications. - -```js -sign(-123); // -1 -sign(123); // 1 -sign(0); // 0 -``` - - - -## toInt(val):Number - -"Convert" value into an 32-bit integer. Works like `Math.floor` if `val > 0` and -`Math.ceil` if `val < 0`. - -**IMPORTANT:** val will wrap at [number/MIN_INT](#MIN_INT) and -[number/MAX_INT](#MAX_INT). - -Created because most people don't know bitwise operations and also because this -feature is commonly needed. - -[Perf tests](http://jsperf.com/vs-vs-parseint-bitwise-operators/7) - -### Example: - -```js -toInt(1.25); // 1 -toInt(0.75); // 0 -toInt(-0.55); // 0 -toInt(-5.0001) // -5 -``` - - - -## toUInt(val):Number - -"Convert" value into an 32-bit unsigned integer. - -Works like AS3#uint(). - -**IMPORTANT:** val will wrap at 2^32. - -### Example: - -```js -toUInt(1.25); // 1 -toUInt(0.75); // 0 -toUInt(-0.55); // 0 -toUInt(-5.0001); // 4294967291 -toUInt(Math.pow(2,32) - 0.5); // 4294967295 -toUInt(Math.pow(2,32) + 0.5); // 0 -``` - - -## toUInt31(val):Number - -"Convert" value into an 31-bit unsigned integer (since 1 bit is used for sign). - -Useful since all bitwise operators besides `>>>` treat numbers as signed -integers. - -**IMPORTANT:** val will wrap at 2^31 and negative numbers will be treated as -`zero`. - -### Example: - -```js -toUInt31(1.25); // 1 -toUInt31(0.75); // 0 -toUInt31(-0.55); // 0 -toUInt31(-5.0001); // 0 -toUInt31(Math.pow(2,31) - 0.5); // 21474836470 -toUInt31(Math.pow(2,31) + 0.5); // 0 -``` - - -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - - -### [_Resources/node_modules/mout/doc/object.md](_Resources/node_modules/mout/doc/object.md) - -# object # - -Object utilities. - - - -## bindAll(obj, [...methodNames]):void - -Bind methods of the target object to always execute on its own context -(ovewritting the original function). - -See: [function/bind](./function.html#bind) - -```js -var view = { - name: 'Lorem Ipsum', - logNameOnClick: function() { - console.log(this.name); - } -}; - -// binds all methods by default -bindAll(view); -jQuery('#docs').on('click', view.logNameOnClick); -``` - -You can also specify the list of methods that you want to bind (in case you -just want to bind a few of them). - -```js -// only the listed methods will be bound to `obj` context -bindAll(obj, 'logNameOnClick', 'doAwesomeStuffOnDrag'); -``` - - - -## contains(obj, value):Boolean - -Similar to [Array/contains](array.html#contains). Checks if Object contains -value. - -```js -var obj = { - a: 1, - b: 2, - c: 'bar' -}; -contains(obj, 2); // true -contains(obj, 'foo'); // false -``` - - - -## deepFillIn(target, ...objects):Object - -Fill missing properties recursively. - -It's different from `deepMixIn` since it won't override any existing property. -It's also different from `merge` since it won't clone child objects during the -process. - -It returns the target object and mutates it in place. - -See: [`fillIn()`](#fillIn), [`deepMixIn()`](#deepMixIn), [`merge()`](#merge) - -```js -var base = { - foo : { - bar : 123 - }, - lorem : 'ipsum' -}; -var options = deepFillIn({foo : { baz : 45 }, lorem : 'amet'}, base); -// > {foo: {bar:123, baz : 45}, lorem : 'amet'} -``` - - - -## deepMatches(target, pattern):Boolean - -Recursively checks if object contains all properties/value pairs. When both -the target and pattern values are arrays, it checks that the target value -contain matches for all the items in the pattern array (independent of order). - -```js -var john = { - name: 'John', - age: 22, - pets: [ - { type: 'cat', name: 'Grumpy Cat' }, - { type: 'dog', name: 'Hawk' } - ] -}; - -deepMatches(john, { name: 'John' }); // true -deepMatches(john, { age: 21 }); // false -deepMatches(john, { pets: [ { type: 'cat' } ] }); // true -deepMatches(john, { pets: [ { name: 'Hawk' } ] }); // true -deepMatches(john, { pets: [ { name: 'Hairball' } ] }); // false -``` - -See [`matches()`](#matches) - - - -## deepMixIn(target, ...objects):Object - -Mixes objects into the target object, recursively mixing existing child objects -as well. - -It will only recursively mix objects if both (existing and new) values are -plain objects. - -Returns the target object. Like [`merge()`](#merge), but mutates the target -object, and does not clone child objects. - -```js -var target = { - foo: { - name: "foo", - id: 1 - } -}; - -deepMixIn(target, { foo: { id: 2 } }); -console.log(target); // { foo: { name: "foo", id: 2 } } -``` - -See: [`mixIn()`](#mixIn), [`merge()`](#merge), [`deepFillIn()`](#deepFillIn) - - - -## equals(a, b, [callback]):Boolean - -Tests whether two objects contain the same keys and values. - -`callback` specifies the equality comparison function used to compare the -values. It defaults to using [lang/is](lang.html#is). - -It will only check the keys and values contained by the objects; it will not -check the objects' prototypes. If either of the values are not objects, they -will be compared using the `callback` function. - -```js -equals({}, {}); // true -equals({ a: 1 }, { a: 1 }); // true -equals({ a: 1 }, { a: 2 }); // false -equals({ a: 1, b: 2 }, { a: 1 }); // false -equals({ a: 1 }, { a: 1, b: 2 }); // false -equals(null, null); // true -equals(null, {}); // false -equals({ a: 1 }, { a: '1' }, function(a, b) { return a == b; }); // true -``` - -See: [array/equals](array.html#equals), [lang/deepEquals](lang.html#deepEquals) - - -## every(obj, callback, [thisObj]):Boolean - -Similar to [Array/every](array.html#every). Tests whether all properties in the -object pass the test implemented by the provided callback. - -```js -var obj = { - a: 1, - b: 2, - c: 3, - d: 'string' -}; - -every(obj, isNumber); // false -``` - - - -## fillIn(obj, ...default):Object - -Fill in missing properties in object with values from the *defaults* objects. - - var base = { - foo : 'bar', - num : 123 - }; - - fillIn({foo:'ipsum'}, base); // {foo:'ipsum', num:123} - -PS: it allows merging multiple objects at once, the first ones will take -precedence. - -See: [`mixIn()`](#mixIn), [`merge()`](#merge), [`deepFillIn()`](#deepFillIn) - - - -## filter(obj, callback, [thisObj]) - -Returns a new object containing all properties where `callback` returns true, -similar to Array/filter. It does not use properties from the object's -prototype. - -Callback receives the same arguments as `forOwn()`. - -See: [`forOwn()`](#forOwn), [`forIn()`](#forIn), [`pick()`](#pick) - -```js -var obj = { - foo: 'value', - bar: 'bar value' -}; - -// returns { bar: 'bar value' } -filter(obj, function(v) { return v.length > 5; }); - -// returns { foo: 'value' } -filter(obj, function(v, k) { return k === 'foo'; }); -``` - - - -## find(obj, callback, [thisObj]) - -Loops through all the properties in the Object and returns the first one that -passes a truth test (callback), similar to [Array/find](array.html#find). -Unlike Array/find, order of iteration is not guaranteed. - -```js -var obj = { - a: 'foo', - b: 12 -}; - -find(obj, isString); // 'foo' -find(obj, isNumber); // 12 -``` - - - -## flatten(object, [level]):Object - -Recursively flattens an object. A new object containing all the values is -returned. If `level` is specified, it will only flatten up to that level. -Note that objects within arrays will not be flattened. - -### Example - -```js -flatten({ a: 1, b: { c: 2, d: { e: 3 } } }); -// > { a: 1, 'b.c': 2, 'b.d.e': 3 } -flatten({ a: 1, b: { c: 2, d: { e: 3 } } }, 1); -// > { a: 1, 'b.c': 2, 'b.d': { e: 3 } } -``` - -See: [`array/flatten()`](./array.html#flatten) - - -## forIn(obj, callback[, thisObj]) - -Iterate over all properties of an Object, similar to -[Array/forEach](array.html#forEach). - -It [avoids don't enum bug on IE](https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug). -It **will** iterate over inherited (enumerable) properties from the prototype. - -It allows exiting the iteration early by returning `false` on the callback. - -See: [`forOwn()`](#forOwn), [`keys()`](#keys), [`values()`](#values) - -### Callback arguments - -Callback will receive the following arguments: - - 1. Property Value (*) - 2. Key name (String) - 3. Target object (Object) - -### Example - -```js -function Foo(){ - this.foo = 1; - this.bar = 2; -} - -Foo.prototype.lorem = 4; - -var obj = new Foo(); - -var result = 0; -var keys = []; - -forIn(obj, function(val, key, o){ - result += val; - keys.push(key); -}); - -console.log(result); // 7 -console.log(keys); // ['foo', 'bar', 'lorem'] -``` - - - -## forOwn(obj, callback[, thisObj]) - -Iterate over all own properties from an Object, similar to -[Array/forEach](array.html#forEach). - -It [avoids don't enum bug on IE](https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug). -Notice that it **won't** iterate over properties from the prototype. - -It allows exiting the iteration early by returning `false` on the callback. - -See: [`forIn()`](#forIn), [`keys()`](#keys), [`values()`](#values) - -### Callback arguments - -Callback will receive the following arguments: - - 1. Property Value (*) - 2. Key name (String) - 3. Target object (Object) - -### Example - -```js -function Foo(){ - this.foo = 1; - this.bar = 2; -} - -// will be ignored -Foo.prototype.lorem = 4; - -var obj = new Foo(); - -var result = 0; -var keys = []; - -forOwn(obj, function(val, key, o){ - result += val; - keys.push(key); -}); - -console.log(result); // 3 -console.log(keys); // ['foo', 'bar'] -``` - - - -## functions(obj):Array - -Returns a sorted list of all enumerable properties that have function values -(including inherited properties). - -```js -var obj = { - foo : function(){}, - bar : 'baz' -}; -functions(obj); // ['foo'] -``` - - - -## get(obj, propName):* - -Returns nested property value. Will return `undefined` if property doesn't -exist or if the object is null or undefined. - -See: [`set()`](#set), [`namespace()`](#namespace), [`has()`](#has) - -```js -var lorem = { - ipsum : { - dolor : { - sit : 'amet' - } - } - }; - -get(lorem, 'ipsum.dolor.sit'); // "amet" -get(lorem, 'foo.bar'); // undefined -get(undefined, 'foo.bar'); // undefined -``` - - - -## has(obj, propName):Boolean - -Checks if object contains a child property. Useful for cases where you need to -check if an object contain a *nested* property. It will get properties -inherited by the prototype. - -see: [`hasOwn()`](#hasOwn), [`get()`](#get) - -```js -var a = { - b : { - c : 123 - } - }; - -has(a, 'b.c'); // true -has(a, 'foo.c'); // false -``` - -### Common use case - -```js -if( has(a, 'foo.c') ){ // false - // ... -} - -if( a.foo.c ){ // ReferenceError: `foo` is not defined - // ... -} -``` - - - -## hasOwn(obj, propName):Boolean - -Safer `Object.hasOwnProperty`. Returns a boolean indicating whether the object -has the specified property. - -see: [`has()`](#has) - -```js -var obj = { - foo: 1, - hasOwnProperty : 'bar' -}; - -obj.hasOwnProperty('foo'); // ERROR! hasOwnProperty is not a function - -hasOwn(obj, 'foo'); // true -hasOwn(obj, 'hasOwnProperty'); // true -hasOwn(obj, 'toString'); // false -``` - - - -## keys(obj):Array - -Returns an array of all own enumerable properties found upon a given object. -It will use the native `Object.keys` if present. - -PS: it won't return properties from the prototype. - -See: [`forOwn()`](#forOwn), [`values()`](#values) - -```js -var obj = { - foo : 1, - bar : 2, - lorem : 3 -}; -keys(obj); // ['foo', 'bar', 'lorem'] -``` - - - -## map(obj, callback, [thisObj]):Object - -Returns a new object where the property values are the result of calling the -callback for each property in the original object, similar to Array/map. - -The callback function receives the same arguments as in `forOwn()`. - -See: [`forOwn()`](#forOwn) - -```js -var obj = { foo: 1, bar: 2 }, - data = { foo: 0, bar: 1 }; - -map(obj, function(v) { return v + 1; }); // { foo: 2, bar: 3 } -map(obj, function(v, k) { return k; }); // { foo: "foo", bar: "bar" } -map(obj, function(v, k) { return this[k]; }, data); // { foo: 0, bar: 1 } -``` - - - -## matches(obj, props):Boolean - -Checks if object contains all properties/values pairs. Useful for validation -and filtering. - -```js -var john = {age:25, hair:'long', beard:true}; -var mark = {age:27, hair:'short', beard:false}; -var hippie = {hair:'long', beard:true}; -matches(john, hippie); // true -matches(mark, hippie); // false -``` - -See [`deepMatches()`](#deepMatches) - - - -## merge(...objects):Object - -Deep merges objects. Note that objects and properties will be cloned during the -process to avoid undesired side effects. It return a new object and won't -affect source objects. - -```js -var obj1 = {a: {b: 1, c: 1, d: {e: 1, f: 1}}}; -var obj2 = {a: {b: 2, d : {f : 'yeah'} }}; - -merge(obj1, obj2); // {a: {b : 2, c : 1, d : {e : 1, f : 'yeah'}}} -``` - -See: [`deepMixIn()`](#deepMixIn), [`deepFillIn()`](#deepFillIn) - - - -## max(obj[, iterator]):* - -Returns maximum value inside object or use a custom iterator to define how -items should be compared. Similar to [Array/max](array.html#max). - -See: [`min()`](#min) - -```js -max({a: 100, b: 2, c: 1, d: 3, e: 200}); // 200 -max({a: 'foo', b: 'lorem', c: 'amet'}, function(val){ - return val.length; -}); // 'lorem' -``` - - - -## min(obj[, iterator]):* - -Returns minimum value inside object or use a custom iterator to define how -items should be compared. Similar to [Array/min](array.html#min). - -See: [`max()`](#max) - -```js -min({a: 100, b: 2, c: 1, d: 3, e: 200}); // 1 -min({a: 'foo', b: 'lorem', c: 'amet'}, function(val){ - return val.length; -}); // 'foo' -``` - - - -## mixIn(target, ...objects):Object - -Combine properties from all the objects into first one. - -This method affects target object in place, if you want to create a new Object -pass an empty object as first parameter. - -### Arguments - - 1. `target` (Object) : Target Object. - 2. `...objects` (...Object) : Objects to be combined (0...n objects). - -### Example - -```js -var a = {foo: "bar"}; -var b = {lorem: 123}; - -mixIn({}, a, b); // {foo: "bar", lorem: 123} -console.log(a); // {foo: "bar"} - -mixIn(a, b); // {foo: "bar", lorem: 123} -console.log(a); // {foo: "bar", lorem: 123} -``` - -See: [`fillIn()`](#fillIn), [`merge()`](#merge) - - - - -## namespace(obj, propName):Object - -Creates an empty object inside namespace if not existent. Will return created -object or existing object. - -See: [`get()`](#get), [`set()`](#set) - -```js -var obj = {}; -namespace(obj, 'foo.bar'); // {} -console.log(obj); // {foo:{bar:{}}} -``` - - -## omit(obj, ...keys):Object - -Return a copy of the object without the blacklisted keys. - -See: [`filter()`](#filter) - -```js -var user = { - firstName : 'John', - lastName : 'Doe', - dob : '1985/07/23', - gender : 'male' -}; - -// can pass an array of keys as second argument -var keys = ['firstName', 'dob'] -omit(user, keys); // {lastName : 'Doe', gender : 'male'} - -// or multiple arguments -omit(user, 'firstName', 'lastName'); // {dob : '1985/07/23', gender : 'male'} -``` - - - -## pick(obj, ...keys):Object - -Return a copy of the object that contains only the whitelisted keys. - -See: [`filter()`](#filter) - -```js -var user = { - firstName : 'John', - lastName : 'Doe', - dob : '1985/07/23', - gender : 'male' -}; - -// can pass an array of keys as second argument -var keys = ['firstName', 'dob'] -pick(user, keys); // {firstName:"John", dob: "1985/07/23"} - -// or multiple arguments -pick(user, 'firstName', 'lastName'); // {firstName:"John", lastName: "Doe"} -``` - - - -## pluck(obj, propName):Object - -Extract an object containing property values with keys as they appear in the -passed object. - -```js -var users = { - first: { - name : 'John', - age : 21 - }, - second: { - name : 'Mary', - age : 25 - } -}; - -pluck(users, 'name'); // {first: 'John', second: 'Mary'} ); -pluck(users, 'age'); // {first: 21, second: 25} ); -``` - - - -## reduce(obj, callback, initial, [thisObj]):* - -Similar to [Array/reduce](array.html#reduce). - -Apply a function against an accumulator and each property of the object (order -is undefined) as to reduce it to a single value. - -```js -var obj = {a: 1, b: 2, c: 3, d: 4}; - -function sum(prev, cur, key, list) { - compare1.push(prev); - return prev + cur; -} - -reduce(obj, sum); // 10 -``` - - - -## reject(obj, callback, thisObj):Object - -Returns a new object containing all properties where `callback` returns true, -similar to [Array/reject](array.html#reject). It does not use properties from -the object's prototype. Opposite of [`filter()`](#filter). - -See [`filter()`](#filter) - -### Example - -```js -var obj = {a: 1, b: 2, c: 3, d: 4, e: 5}; -reject(obj, function(x) { return (x % 2) !== 0; }); // {b: 2, d: 4} -``` - - - -## values(obj):Array - -Returns an array of all own enumerable properties values found upon a given object. - -PS: it won't return properties from the prototype. - -See: [`forOwn()`](#forOwn), [`keys()`](#keys) - -```js -var obj = { - foo : 1, - bar : 2, - lorem : 3 -}; -values(obj); // [1, 2, 3] -``` - - - -## set(obj, propName, value) - -Sets a nested property value. - -See: [`get()`](#get), [`namespace()`](#namespace) - -```js -var obj = {}; -set(obj, 'foo.bar', 123); -console.log(obj.foo.bar); // 123 -console.log(obj); // {foo:{bar:123}} -``` - - - -## size(obj):Number - -Returns the count of own enumerable properties found upon a given object. - -PS: it won't return properties from the prototype. - -See: [`forOwn()`](#forOwn), [`keys()`](#keys) - -```js -var obj = { - foo : 1, - bar : 2, - lorem : 3 -}; -size(obj); // 3 -``` - - - -## some(obj, callback, [thisObj]):Boolean - -Similar to [Array/some](array.html#some). Tests whether any properties in the -object pass the test implemented by the provided callback. - -```js -var obj = { - a: 1, - b: 2, - c: 3, - d: 'string' -}; - -some(obj, isNumber); // true -``` - - - -## unset(obj, propName):Boolean - -Delete object property if existent and returns a boolean indicating succes. It -will also return `true` if property doesn't exist. - -Some properties can't be deleted, to understand why [check this -article](http://perfectionkills.com/understanding-delete/). - -See: [`set()`](#set) - -```js -var lorem = { - ipsum : { - dolor : { - sit : 'amet' - } - } - }; - -unset(lorem, 'ipsum.dolor.sit'); // true -console.log(lorem.ipsum.dolor); // {} -unset(lorem, 'foo.bar'); // true -``` - - - -## result(object, property):Mixed - -Evaluates an objects property and returns result. - -```js -var person = { - name: 'john', - - mood: function() { - // some dynamic calculated property. - return 'happy'; - } -}; - -var name = result(person, 'name'), // john - mood = result(person, 'mood'); // happy -``` - - -### [_Resources/node_modules/mout/doc/queryString.md](_Resources/node_modules/mout/doc/queryString.md) - -# queryString # - -Utilities for query string manipulation. - - - -## contains(url, paramName):Boolen - -Checks if query string contains parameter. - -### Arguments: - - 1. `url` (String) : URL or query string. - 2. `paramName` (String) : Parameter name. - -### Example: - -```js -var url = 'example.com/?lorem=ipsum'; -contains(url, 'lorem'); // true -contains(url, 'foo'); //false -``` - - - -## decode(queryStr[, shouldTypecast]):Object - -Parses query string and creates an object of keys => vals. - -Will typecast value with [`string/typecast`](string.html#typecast) by default -and decode string parameters using `decodeURIComponent()`. - -```js -var query = '?foo=bar&lorem=123'; -decode(query); // {foo: "bar", lorem: 123} -decode(query, false); // {foo: "bar", lorem: "123"} -``` - - -## encode(obj):String - -Encode object into a query string. - -Will encode parameters with `encodeURIComponent()`. - -```js -encode({foo: "bar", lorem: 123}); // "?foo=bar&lorem=123" -``` - - -## getParam(url, param[, shouldTypecast]):* - -Get query parameter value. - -Will typecast value with [`string/typecast`](string.html#typecast) by default. - -See: [`setParam()`](#setParam) - -### Arguments: - - 1. `url` (String) : Url. - 2. `param` (String) : Parameter name. - 3. `[shouldTypecast]` (Boolean) : If it should typecast value. - -### Example: - -```js -var url = 'example.com/?foo=bar&lorem=123&ipsum=false'; -getParam(url, 'dolor'); // "amet" -getParam(url, 'lorem'); // 123 -getParam(url, 'lorem', false); // "123" -``` - - -## parse(url[, shouldTypecast]):Object - -Parses URL, extracts query string and decodes it. - -It will typecast all properties of the query object unless second argument is -`false`. - -Alias to: `decode(getQuery(url))`. - -```js -var url = 'example.com/?lorem=ipsum&a=123'; -parse(url); // {lorem: "ipsum", a: 123} -parse(url, false); // {lorem: "ipsum", a: "123"} -``` - - -## getQuery(url):String - -Gets full query as string with all special chars decoded. - -```js -getQuery('example.com/?lorem=ipsum'); // "?lorem=ipsum" -``` - - -## setParam(url, paramName, value):String - -Add new query string parameter to URL or update existing value. - -See: [`getParam()`](#getParam) - -```js -setParam('?foo=bar&lorem=0', 'lorem', 'ipsum'); // '?foo=bar&lorem=ipsum' -setParam('?lorem=1', 'foo', 123); // '?lorem=1&foo=123' -``` - - -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - -### [_Resources/node_modules/mout/doc/random.md](_Resources/node_modules/mout/doc/random.md) - -# random # - -Pseudo-random generators. - -mout uses `Math.random` by default on all the pseudo-random generators, if -you need a seeded random or a better algorithm see the [`random()`](#random) -documentation for instructions. - - - -## choice(...items):* - -Returns a random element from the supplied arguments or from an array if single -argument is an array. - -### Example: - -```js -choice(1, 2, 3, 4, 5); // 3 - -var arr = ['lorem', 'ipsum', 'dolor']; -choice(arr); // 'dolor' -``` - - - -## guid():String - -Generates a pseudo-random [Globally Unique Identifier](http://en.wikipedia.org/wiki/Globally_unique_identifier) (v4). - -Since the total number of GUIDs is 2¹²² the chance of generating the -same value twice is negligible. - -**Important:** this method uses `Math.random` by default so the UUID isn't -*safe* (sequence of outputs can be predicted in some cases), check the -[`random()`](#random) documentation for more info on how to replace the default -PRNG if you need extra safety or need *seeded* results. - -See: [`randHex()`](#randHex), [`random()`](#random) - -### Example: - -```js -guid(); // 830e9f50-ac7f-4369-a14f-ed0e62b2fa0b -guid(); // 5de3d09b-e79c-4727-932b-48c49228d508 -``` - - - -## rand([min], [max]):Number - -Gets a random number inside range or snap to min/max values. - -### Arguments: - - 1. `[min]` (Number) : Minimum value. Defaults to `number/MIN_INT`. - 2. `[max]` (Number) : Maximum value. Defaults to `number/MAX_INT`. - - -### Example: - -```js -rand(); // 448740433.55274725 -rand(); // -31797596.097682 -rand(0, 10); // 7.369723 -rand(0, 10); // 5.987042 -``` - -See: [`random()`](#random) - - - -## randBit():Number - -Returns a random "bit" (0 or 1). Useful for addition/subtraction. - -It's slightly faster than `choice(0, 1)` since implementation is simpler (not -that it will make a huge difference in most cases). - -See: [`choice()`](#choice) - -### Example: - -```js -randBit(); // 1 -randBit(); // 0 - -//same effect as -choice(0, 1); -``` - - -## randBool():Boolean - -Returns a random Boolean (`true` or `false`). - -Since this is very common it makes sense to abstract it into a discrete method. - -### Example: - -```js -randBool(); // true -randBool(); // false -``` - - - -## randHex([size]):String - -Returns a random hexadecimal string. - -The default `size` is `6`. - -### Example: - -```js -randHex(); // "dd8575" -randHex(); // "e6baeb" -randHex(2); // "a2" -randHex(30); // "effd7e2ad9a4a3067e30525fab983a" -``` - - - -## randInt([min], [max]):Number - -Gets a random integer inside range or snap to min/max values. - -### Arguments: - - 1. `[min]` (Number) : Minimum value. Defaults to `number/MIN_INT`. - 2. `[max]` (Number) : Maximum value. Defaults to `number/MAX_INT`. - - -### Example: - -```js -randInt(); // 448740433 -randInt(); // -31797596 -randInt(0, 10); // 7 -randInt(0, 10); // 5 -``` - - - -## randSign():Number - -Returns a random "sign" (-1 or 1). Useful for multiplications. - -It's slightly faster than `choice(-1, 1)` since implementation is simpler (not -that it will make a huge difference in most cases). - -See: [`choice()`](#choice) - -### Example: - -```js -randSign(); // -1 -randSign(); // 1 - -//same effect as -choice(-1, 1); -``` - - - -## random():Number - -Returns a random number between `0` and `1`. Same as `Math.random()`. - -```js -random(); // 0.35435103671625257 -random(); // 0.8768321881070733 -``` - -**Important:** No methods inside mout should call `Math.random()` -directly, they all use `random/random` as a proxy, that way we can -inject/replace the pseudo-random number generator if needed (ie. in case we -need a seeded random or a better algorithm than the native one). - -### Replacing the PRNG - -In some cases we might need better/different algorithms than the one provided -by `Math.random` (ie. safer, seeded). - -Because of licensing issues, file size limitations and different needs we -decided to **not** implement a custom PRNG and instead provide a easy way to -override the default behavior. - [issue #99](https://github.com/millermedeiros/amd-utils/issues/99) - -If you are using mout with a loader that supports the [AMD map -config](https://github.com/amdjs/amdjs-api/wiki/Common-Config), such as -[RequireJS](http://requirejs.org/), you can use it to replace the PRNG -(recommended approach): - -```js -requirejs.config({ - map : { - // all modules will load "my_custom_prng" instead of - // "mout/random/random" - '*' : { - 'mout/random/random' : 'my_custom_prng' - } - } -}); -``` - -You also have the option to override `random.get` in case you are using -mout on node.js or with a loader which doesn't support the map config: - -```js -// replace the PRNG -var n = 0; -random.get = function(){ - return ++n % 2? 0 : 1; // not so random :P -}; -random(); // 0 -random(); // 1 -random(); // 0 -random(); // 1 -``` - -See this [detailed explanation about PRNG in -JavaScript](https://github.com/nquinlan/better-random-numbers-for-javascript-mirror) -to understand the issues with the native `Math.random` and also for a list of -algorithms that could be used instead. - - - -## randString([length, dictionary]):String - -Returns a random string. - -By default returns string containing alphanumeric characters (lowercase and uppercase) with a length of 8. - -### Arguments: - - 1. `[length]` (number) : Length of the string to return. Defaults to 8. - 2. `[dictionary]` (string) : A string containing all characters used as a dictionary for the random string construction. Defaults to alphanumeric characters (lowercase and uppercase). - -### Example: - -```js -randString(); // returns a string with length 8. -randString(12); // returns a string of length 12. -randString(-1); // returns a string of length 8. -randString(null, 'pew!'); // returns a random string of length 8 composed of 'p', 'e', 'w' and '!'. -randString(10, '0'); // always returns '0's of length 10. -randString(rand(8, 10)); // returns a random string with length between 8 and 10. -``` - - - -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - -### [_Resources/node_modules/mout/doc/string.md](_Resources/node_modules/mout/doc/string.md) - -# string # - -String utilities. - - -## camelCase(str):String - -Convert string to "camelCase" text. - -See: [`pascalCase()`](#pascalCase), [`unCamelCase()`](#unCamelCase) - -### Example - -```js -camelCase('lorem-ipsum-dolor'); // "loremIpsumDolor" -camelCase('lorem ipsum dolor'); // "loremIpsumDolor" -``` - - - -## contains(str, substring, [fromIndex]):Boolean - -Checks if string contains the given substring. - -See: [`startsWith()`](#startsWith), [`endsWith()`](#endsWith) - -### Example - -```js -contains('lorem', 'or'); // true -contains('lorem', 'bar'); // false -``` - - - -## crop(str, maxChars, [append]):String - -Truncate string at full words. Alias to `truncate(str, maxChars, append, true);`. - -See: [`truncate()`](#truncate) - -### Example - -```js -crop('lorem ipsum dolor', 10); // "lorem..." -crop('lorem ipsum dolor', 10, '+'); // "lorem+" -``` - - - -## endsWith(str, suffix):Boolean - -Checks if string ends with specified suffix. - -See: [`startsWith()`](#startsWith), [`contains()`](#contains) - -### Example - -```js -endsWith('lorem ipsum', 'lorem'); // false -endsWith('lorem ipsum', 'ipsum'); // true -``` - - - -## escapeHtml(str):String - -Escapes the following special characters for use in HTML: - -* `&` becomes `&` -* `<` becomes `<` -* `>` becomes `>` -* `'` becomes `'` -* `"` becomes `"` - -No other characters are escaped. To HTML-escape other characters as well, use a third-party library like [_he_](http://mths.be/he). - -See: [`unescapeHtml()`](#unescapeHtml) - -### Example - -```js -escapeHtml('lorem & "ipsum"'); // "lorem & "ipsum"" -``` - - - -## escapeRegExp(str):String - -Escape special chars to be used as literals in RegExp constructors. - -### Example - -```js -str = escapeRegExp('[lorem.ipsum]'); // "\\[lorem\\.ipsum\\]" -reg = new RegExp(str); // /\[lorem\.ipsum\]/ -``` - - - -## escapeUnicode(str[, shouldEscapePrintable]):String - -Unicode escape chars. - -It will only escape non-printable ASCII chars unless `shouldEscapePrintable` is -set to `true`. - -See: [`unescapeUnicode()`](#unescapeUnicode) - -```js -escapeUnicode('føo bår'); -// > "f\u00f8o b\u00e5r" -escapeUnicode('føo bår', true); -// > "\u0066\u00f8\u006f\u0020\u0062\u00e5\u0072" -``` - - - -## hyphenate(str):String - -Replaces spaces with hyphens, split camelCase text, remove non-word chars, -remove accents and convert to lower case. - -See: [`slugify()`](#slugify), [`underscore()`](#underscore), -[`unhyphenate`](#unhyphenate) - -```js -hyphenate(' %# lorem ipsum ? $ dolor'); // "lorem-ipsum-dolor" -hyphenate('spéçïãl çhârs'); // "special-chars" -hyphenate('loremIpsum'); // "lorem-ipsum" -``` - - - -## insert(str, index, partial):String - -Inserts a `partial` before the given `index` in the provided `str`. -If the index is larger than the length of the string the partial is appended at the end. -A negative index is treated as `length - index` where `length` is the length or the string. - -```js -insert('this is a sentence', 10, 'sample '); // "this is a sample sentence" -insert('foo', 100, 'bar'); // "foobar" -insert('image.png', -4, '-large'); // "image-large.png" -``` - -## interpolate(str, replacements[, syntax]):String - -String interpolation. Format/replace tokens with object properties. - -```js -var tmpl = 'Hello {{name}}!'; -interpolate(tmpl, {name: 'World'}); // "Hello World!" -interpolate(tmpl, {name: 'Lorem Ipsum'}); // "Hello Lorem Ipsum!" - -tmpl = 'Hello {{name.first}}!'; -interpolate(tmpl, {name: {first: 'Lorem'}}); // "Hello Lorem!" -``` - -It uses a mustache-like syntax by default but you can set your own format if -needed. You can also use Arrays for the replacements (since Arrays are -objects as well): - -```js -// matches everything inside "${}" -var syntax = /\$\{([^}]+)\}/g; -var tmpl = "Hello ${0}!"; -interpolate(tmpl, ['Foo Bar'], syntax); // "Hello Foo Bar!" -``` - - - -## lowerCase(str):String - -"Safer" `String.toLowerCase()`. (Used internally) - -### Example - -```js -(null).toLowerCase(); // Error! -(undefined).toLowerCase(); // Error! -lowerCase(null); // "" -lowerCase(undefined); // "" -``` - - - -## lpad(str, minLength[, char]):String - -Pad string from left with `char` if its' length is smaller than `minLen`. - -See: [`rpad()`](#rpad) - -### Example - -```js -lpad('a', 5); // " a" -lpad('a', 5, '-'); // "----a" -lpad('abc', 3, '-'); // "abc" -lpad('abc', 4, '-'); // "-abc" -``` - - - -## ltrim(str, [chars]):String - -Remove chars or white-spaces from beginning of string. - -`chars` is an array of chars to remove from the beginning of the string. If -`chars` is not specified, Unicode whitespace chars will be used instead. - -See: [`rtrim()`](#rtrim), [`trim()`](#trim) - -### Example - -```js -ltrim(' lorem ipsum '); // "lorem ipsum " -ltrim('--lorem ipsum--', ['-']); // "lorem ipsum--" -``` - - - -## makePath(...args):String - -Group arguments as path segments, if any of the args is `null` or `undefined` -it will be ignored from resulting path. It will also remove duplicate "/". - -See: [`array/join()`](array.html#join) - -### Example - -```js -makePath('lorem', 'ipsum', null, 'dolor'); // "lorem/ipsum/dolor" -makePath('foo///bar/'); // "foo/bar/" -``` - - - -## normalizeLineBreaks(str, [lineBreak]):String - -Normalize line breaks to a single format. Defaults to Unix `\n`. - -It handles DOS (`\r\n`), Mac (`\r`) and Unix (`\n`) formats. - -### Example - -```js -// "foo\nbar\nlorem\nipsum" -normalizeLineBreaks('foo\nbar\r\nlorem\ripsum'); - -// "foo\rbar\rlorem\ripsum" -normalizeLineBreaks('foo\nbar\r\nlorem\ripsum', '\r'); - -// "foo bar lorem ipsum" -normalizeLineBreaks('foo\nbar\r\nlorem\ripsum', ' '); -``` - - - -## pascalCase(str):String - -Convert string to "PascalCase" text. - -See: [`camelCase()`](#camelCase) - -### Example - -```js -pascalCase('lorem-ipsum-dolor'); // "LoremIpsumDolor" -pascalCase('lorem ipsum dolor'); // "LoremIpsumDolor" -``` - - - -## properCase(str):String - -UPPERCASE first char of each word, lowercase other chars. - -### Example - -```js -properCase('loRem iPSum'); // "Lorem Ipsum" -``` - - - -## removeNonASCII(str):String - -Remove [non-printable ASCII -chars](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters). - -### Example - -```js -removeNonASCII('äÄçÇéÉêlorem-ipsumöÖÐþúÚ'); // "lorem-ipsum" -``` - - - -## removeNonWord(str):String - -Remove non-word chars. - -### Example - -```js -var str = 'lorem ~!@#$%^&*()_+`-={}[]|\\:";\'/?><., ipsum'; -removeNonWord(str); // "lorem - ipsum" -``` - - - -## repeat(str, n):String - -Repeat string n-times. - -### Example - -```js -repeat('a', 3); // "aaa" -repeat('bc', 2); // "bcbc" -repeat('a', 0); // "" -``` - - - -## replace(str, search, replacements):String - -Replace string(s) with the replacement(s) in the source. - -`search` and `replacements` can be an array, or a single item. For every item -in `search`, it will call `str.replace` with the search item and the matching -replacement in `replacements`. If `replacements` only contains one replacement, -it will be used for all the searches, otherwise it will use the replacement at -the same index as the search. - -### Example - -```js -replace('foo bar', 'foo', 'test'); // "test bar" -replace('test 1 2', ['1', '2'], 'n'); // "test n n" -replace('test 1 2', ['1', '2'], ['one', 'two']); // "test one two" -replace('123abc', [/\d/g, /[a-z]/g], ['0', '.']); // "000..." -``` - - - -## replaceAccents(str):String - -Replaces all accented chars with regular ones. - -**Important:** Only covers **Basic Latin** and **Latin-1** unicode chars. - -### Example - -```js -replaceAccents('spéçïãl çhârs'); // "special chars" -``` - - - -## rpad(str, minLength[, char]):String - -Pad string from right with `char` if its' length is smaller than `minLen`. - -See: [`lpad()`](#lpad) - -### Example - -```js -rpad('a', 5); // "a " -rpad('a', 5, '-'); // "a----" -rpad('abc', 3, '-'); // "abc" -rpad('abc', 4, '-'); // "abc-" -``` - - - -## rtrim(str, [chars]):String - -Remove chars or white-spaces from end of string. - -`chars` is an array of chars to remove from the end of the string. If -`chars` is not specified, Unicode whitespace chars will be used instead. - -See: [`trim()`](#trim), [`ltrim()`](#ltrim) - -### Example - -```js -rtrim(' lorem ipsum '); // " lorem ipsum" -rtrim('--lorem ipsum--', ['-']); // "--lorem ipsum" -``` - - - -## sentenceCase(str):String - -UPPERCASE first char of each sentence and lowercase other chars. - -### Example - -```js -var str = 'Lorem IpSum DoLOr. maeCeNnas Ullamcor.'; -sentenceCase(str); // "Lorem ipsum dolor. Maecennas ullamcor." -``` - - - -## stripHtmlTags(str):String - -Remove HTML/XML tags from string. - -### Example - -```js -var str = '

lorem ipsum

'; -stripHtmlTags(str); // "lorem ipsum" -``` - - - -## startsWith(str, prefix):Boolean - -Checks if string starts with specified prefix. - -See: [`endsWith()`](#endsWith), [`contains()`](#contains) - -### Example - -```js -startsWith('lorem ipsum', 'lorem'); // true -startsWith('lorem ipsum', 'ipsum'); // false -``` - - - -## slugify(str[, delimeter]):String - -Convert to lower case, remove accents, remove non-word chars and replace spaces -with the delimeter. The default delimeter is a hyphen. - -Note that this does not split camelCase text. - -See: [`hyphenate()`](#hyphenate) and [`underscore()`](#underscore) - -### Example - -```js -var str = 'loremIpsum dolor spéçïãl chârs'; -slugify(str); // "loremipsum-dolor-special-chars" -slugify(str, '_'); // "loremipsum_dolor_special_chars" -``` - -## stripMargin(str[, marginChar]):String - -Strip leading characters followed by 'marginChar' from every line in a String. -The default margin character is a pipe. - -### Example - -```js -var str = 'this\n'; -str += ' |is a formatted\n'; -str += ' |string'; - - -stripMargin(str); //"this\nis a formatted\nstring" -stripMargin("this\n___#works\n___#too", '#'); //"this\nworks\ntoo" - -``` - - -## trim(str, [chars]):String - -Remove chars or white-spaces from beginning and end of string. - -`chars` is an array of chars to remove from the beginning and end of the -string. If `chars` is not specified, Unicode whitespace chars will be used -instead. - -See: [`rtrim()`](#rtrim), [`ltrim()`](#ltrim) - -### Example - -```js -trim(' lorem ipsum '); // "lorem ipsum" -trim('-+-lorem ipsum-+-', ['-', '+']); // "lorem ipsum" -``` - - - -## truncate(str, maxChars, [append], [onlyFullWords]):String - -Limit number of chars. Returned string `length` will be `<= maxChars`. - -See: [`crop()`](#crop) - -### Arguments - - 1. `str` (String) : String - 2. `maxChars` (Number) : Maximum number of characters including `append.length`. - 3. `[append]` (String) : Value that should be added to the end of string. - Defaults to "...". - 4. `[onlyFullWords]` (Boolean) : If it shouldn't break words. Default is - `false`. (favor [`crop()`](#crop) since code will be clearer). - -### Example - -```js -truncate('lorem ipsum dolor', 11); // "lorem ip..." -truncate('lorem ipsum dolor', 11, '+'); // "lorem ipsu+" -truncate('lorem ipsum dolor', 11, null, true); // "lorem..." -``` - - - -## typecast(str):* - -Parses string and convert it into a native value. - -### Example - -```js -typecast('lorem ipsum'); // "lorem ipsum" -typecast('123'); // 123 -typecast('123.45'); // 123.45 -typecast('false'); // false -typecast('true'); // true -typecast('null'); // null -typecast('undefined'); // undefined -``` - - - -## unCamelCase(str, [delimiter]):String - -Add the delimiter between camelCase text and convert first char of each word to -lower case. - -The delimiter defaults to a space character. - -See: [`camelCase()`][#camelCase] - -### Example - -```js -unCamelCase('loremIpsumDolor'); // "lorem ipsum dolor" -unCamelCase('loremIpsumDolor', '-'); // "lorem-ipsum-color" -``` - - -## underscore(str):String - -Replaces spaces with underscores, split camelCase text, remove non-word chars, -remove accents and convert to lower case. - -See: [`slugify()`](#slugify), [`hyphenate()`](#hyphenate) - -```js -underscore(' %# lorem ipsum ? $ dolor'); // "lorem_ipsum_dolor" -underscore('spéçïãl çhârs'); // "special_chars" -underscore('loremIpsum'); // "lorem_ipsum" -``` - - - -## unescapeHtml(str):String - -Unescapes the following HTML character references back into the raw symbol they map to: - -* `&` becomes `&` -* `<` becomes `<` -* `>` becomes `>` -* `'` becomes `'` -* `"` becomes `"` - -No other HTML character references are unescaped. To HTML-unescape other entities as well, use a third-party library like [_he_](http://mths.be/he). - - -See: [`escapeHtml()`](#escapeHtml) - -### Example - -```js -unescapeHtml('lorem & "ipsum"'); // 'lorem & "ipsum"' -``` - - - -## unescapeUnicode(str):String - -Unescapes unicode char sequences. - -See: [`escapeUnicode()`](#escapeUnicode) - -```js -unescapeUnicode('\\u0066\\u00f8\\u006f\\u0020\\u0062\\u00e5\\u0072'); -// > 'føo bår' -``` - - - -## unhyphenate(str):String - -Replaces hyphens with spaces. (only hyphens between word chars) - -See : [`hyphenate()`](#hyphenate) - -### Example - -```js -unhyphenate('lorem-ipsum-dolor'); // "lorem ipsum dolor" -``` - - -## upperCase(str):String - -"Safer" `String.toUpperCase()`. (Used internally) - -### Example - -```js -(null).toUpperCase(); // Error! -(undefined).toUpperCase(); // Error! -upperCase(null); // "" -upperCase(undefined); // "" -``` - - - -## WHITE_SPACES:Array - -Constant array of all [Unicode white-space -characters](http://en.wikipedia.org/wiki/Whitespace_character). - - - -------------------------------------------------------------------------------- - -For more usage examples check specs inside `/tests` folder. Unit tests are the -best documentation you can get... - - -### [_Resources/node_modules/mout/doc/time.md](_Resources/node_modules/mout/doc/time.md) - -# time # - -Utilities for time manipulation. - - -## convert(value, sourceUnit, [destinationUnit]):Number - -Converts time between units. - -Available units: `millisecond`, `second`, `minute`, `hour`, `day`, `week`. -Abbreviations: `ms`, `s`, `m`, `h`, `d`, `w`. - -We do **not** support year and month as a time unit since their values are not -fixed. - -The default `destinationUnit` is `ms`. - -```js -convert(1, 'minute'); // 60000 -convert(2.5, 's', 'ms'); // 2500 -convert(2, 'm', 's'); // 120 -convert(500, 'ms', 's'); // 0.5 -``` - - - -## now():Number - -Returns the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC. -Uses `Date.now()` if available. - -### Example - -```js -now(); // 1335449614650 -``` - - - -## parseMs(ms):Object - -Parse timestamp (milliseconds) into an object `{milliseconds:number, -seconds:number, minutes:number, hours:number, days:number}`. - -### Example - -```js -// {days:27, hours:4, minutes:26, seconds:5, milliseconds:454} -parseMs(2348765454); -``` - - - -## toTimeString(ms):String - -Convert timestamp (milliseconds) into a time string in the format "[H:]MM:SS". - -### Example - -```js -toTimeString(12513); // "00:12" -toTimeString(951233); // "15:51" -toTimeString(8765235); // "2:26:05" -``` - - -

_Resources/node_modules/mout/

- -### [_Resources/node_modules/mout/LICENSE.md](_Resources/node_modules/mout/LICENSE.md) -# The MIT License (MIT) -## Copyright (c) 2012, 2013 moutjs team and contributors (http://moutjs.com) - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. - - - - - - -### [_Resources/node_modules/mout/README.md](_Resources/node_modules/mout/README.md) - -![mout](http://moutjs.com/logo.png "Modular JavaScript Utilties") - -http://moutjs.com/ - -[![Build Status](https://travis-ci.org/mout/mout.svg?branch=master)](https://travis-ci.org/mout/mout) -[![Downloads](https://img.shields.io/npm/dm/mout.svg)](https://www.npmjs.com/package/mout) -[![Version](https://img.shields.io/npm/v/mout.svg)](https://www.npmjs.com/package/mout) - -All code is library agnostic and consist mostly of helper methods that aren't -directly related with the DOM, the purpose of this library isn't to replace -Dojo, jQuery, YUI, Mootools, etc, but to provide modular solutions for common -problems that aren't solved by most of them. Consider it as a crossbrowser -JavaScript standard library. - - - -## Main goals ## - - - increase code reuse; - - be clear (code should be clean/readable); - - be easy to debug; - - be easy to maintain; - - follow best practices; - - follow standards when possible; - - **don't convert JavaScript into another language!** - - be compatible with other frameworks; - - be modular; - - have unit tests for all modules; - - work on multiple environments (IE7+, modern browsers, node.js); - - - -## What shouldn't be here ## - - - UI components; - - CSS selector engine; - - Event system - pub/sub; - - Template engine; - - Anything that isn't generic enough to be on a standard library; - - Anything that could be a separate library and/or isn't a modular utility... - - - -## API Documentation ## - -Online documentation can be found at http://moutjs.com/ or inside the -`doc` folder. - - - -## FAQ / Wiki / IRC ## - -For more info about project structure, design decisions, tips, how to -contribute, build system, etc, please check the [project -wiki](https://github.com/mout/mout/wiki). - -We also have an IRC channel [#moutjs on -irc.freenode.net](http://webchat.freenode.net/?channels=moutjs) - - - -## License ## - -Released under the [MIT License](http://www.opensource.org/licenses/mit-license.php). - - - -

_Resources/node_modules/web-dev-utils/GIT-HTML-PREVIEW-TOOL/GIT-HTML-PREVIEW-TOOL-master/

- -### [_Resources/node_modules/web-dev-utils/GIT-HTML-PREVIEW-TOOL/GIT-HTML-PREVIEW-TOOL-master/readme.md](_Resources/node_modules/web-dev-utils/GIT-HTML-PREVIEW-TOOL/GIT-HTML-PREVIEW-TOOL-master/readme.md) - - - - - - -

- - - - - - - -# GIT HTML PREVIEW TOOL . - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - - **TOC** - [About](#about) ● [How It Works](#how-it-works) ● [Development](#development) ● [Contact](#contact) - - - - - - [![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - -

- - [![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - - -# Usage: - -![demo](./git-preview.gif) - -

Still working on getting it to render html hosted on GitLabb - - - - - - - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - - - -# GIT HTML PREVIEW TOOL - ->What it does is: load HTML using CORS proxy, then process all links, frames, scripts and styles, and load each of them using CORS proxy, so they can be evaluated by the browser. - - - - - - - ## Live Deployment - [Live Website] - - - -

- - - - - - - - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - - - - -

- - ## ➤ About - -#### Many GitHub repositories don't use GitHub Pages to host their HTML files. **GIT HTML PREVIEW TOOL** allows you to render those files without cloning or downloading whole repositories. It is a client-side solution using a CORS proxy to fetch assets. - -#### If you try to open raw version of any HTML, CSS or JS file in a web browser directly from GitHub, all you will see is a source code. GitHub forces them to use the "text/plain" content-type, so they cannot be interpreted. This script overrides it by using a CORS proxy. - - - ---- - - - ->Cross-Origin Resource Sharing (CORS) is a security mechanism that uses additional HTTP headers to tell browsers to give a web application running at one origin, access to selected resources from a different origin. A web application executes a cross-origin HTTP request when it requests a resource(Images, Scripts, CSS files, etc.)that has a different origin (domain, protocol, or port) from its own. - - ->Cross-origin requests, however, mean that servers must implement ways to handle requests from origins outside of their own. CORS allows servers to specify who (i.e., which origins) can access the assets on the server, among many other things. - ->Access-Control-Allow-Origin Header -When Site A tries to fetch content from Site B, Site B can send an Access-Control-Allow-Origin response header to tell the browser that the content of this page is accessible to certain origins. (An origin is a domain, plus a scheme and port number.) By default, Site B's pages are not accessible to any other origin; using the Access-Control-Allow-Origin header opens a door for cross-origin access by specific requesting origins. The Access-Control-Allow-Origin header is critical to resource security. -You can find a description of each CORS header at the following: CORS Headers. -Pre-Flight Request -Most servers will allow GET requests but may block requests to modify resources on the server. Servers don't just blindly block such requests though; they have a process in place that first checks and then communicates to the client (your web browser) which requests are allowed. -When a request is made using any of the following HTTP request methods, a standard preflight request will be made before the original request. -PUT -DELETE -CONNECT -OPTIONS -TRACE -PATCH -Preflight requests use the OPTIONS header. The preflight request is sent before the original request, hence the term "preflight." The purpose of the preflight request is to determine whether or not the original request is safe (for example, a DELETE request). The server will respond to the preflight request and indicate whether or not the original request is safe. If the server specifies that the original request is safe, it will allow the original request. Otherwise, it will block the original request. - ---- - - - - - - - -## ➤ Bryan Guner ---- - -***(Full-stack software developer)*** - ---- - -[![Portfolio](https://img.shields.io/badge/-❤_Portfolio-f58?style=flat-square&logo=a&logoColor=white&link=https://bgoonz.github.io/)](https://bgoonz.github.io)![Resume PDF](https://img.shields.io/badge/-Resume-f00?style=flat-square&logo=adobe-acrobat-reader&logoColor=white)[![Bryan's email](https://img.shields.io/badge/bryan.guner@gmail.com-f4b400?style=flat-square&logo=gmail&logoColor=black&link=mailto:bryan.guner@gmail.com)](mailto:bryan.guner@gmail.com)[![Blog](https://img.shields.io/badge/-Blog-21759b?style=flat-square&logo=WordPress&logoColor=white&link=https://web-dev-hub.com/)](https://web-dev-hub.com/)[![Linkedin](https://img.shields.io/badge/-LinkedIn-0077b5?style=flat-square&logo=Linkedin&logoColor=white&link=https://www.linkedin.com/in/bryan-guner-046199128/)](https://www.linkedin.com/in/bryan-guner-046199128/)[![AngelList](https://img.shields.io/badge/-AngelList-black?style=flat-square&logo=AngelList&logoColor=white&link=https://angel.co/u/bryan-guner)](https://angel.co/u/bryan-guner)[![GitHub bgoonz](https://img.shields.io/github/followers/bgoonz?label=follow&style=social)](https://github.com/bgoonz) - -

- -
- - - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - - -

- - - ![logo](https://avatars.githubusercontent.com/u/66654881?s=460&u=fa9d2cc45bc228dd9b7d3dee6d4653f940fab35a&v=4) - - - -

- - - - -------------------------------- - - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - -## ➤ Development: - -```js -(() => { - - const previewForm = document.getElementById('previewform'); - - const url = location.search.substring(1).replace(/\/\/github\.com/, '//raw.githubusercontent.com').replace(/\/blob\//, '/'); //Get URL of the raw file - - const replaceAssets = () => { - let frame; - let a; - let link; - const links = []; - let script; - const scripts = []; - let i; - let href; - let src; - //Framesets - if (document.querySelectorAll('frameset').length) - return; //Don't replace CSS/JS if it's a frameset, because it will be erased by document.write() - //Frames - frame = document.querySelectorAll('iframe[src],frame[src]'); - for (i = 0; i < frame.length; ++i) { - src = frame[i].src; //Get absolute URL - if (src.indexOf('//raw.githubusercontent.com') > 0 || src.indexOf('//bitbucket.org') > 0) { //Check if it's from raw.github.com or bitbucket.org - frame[i].src = '//' + location.hostname + location.pathname + '?' + src; //Then rewrite URL so it can be loaded using CORS proxy - } - } - //Links - a = document.querySelectorAll('a[href]'); - for (i = 0; i < a.length; ++i) { - href = a[i].href; //Get absolute URL - if (href.indexOf('#') > 0) { //Check if it's an anchor - a[i].href = '//' + location.hostname + location.pathname + location.search + '#' + a[i].hash.substring(1); //Then rewrite URL with support for empty anchor - } else if ((href.indexOf('//raw.githubusercontent.com') > 0 || href.indexOf('//bitbucket.org') > 0) && (href.indexOf('.html') > 0 || href.indexOf('.htm') > 0)) { //Check if it's from raw.github.com or bitbucket.org and to HTML files - a[i].href = '//' + location.hostname + location.pathname + '?' + href; //Then rewrite URL so it can be loaded using CORS proxy - } - } - //Stylesheets - link = document.querySelectorAll('link[rel=stylesheet]'); - for (i = 0; i < link.length; ++i) { - href = link[i].href; //Get absolute URL - if (href.indexOf('//raw.githubusercontent.com') > 0 || href.indexOf('//bitbucket.org') > 0) { //Check if it's from raw.github.com or bitbucket.org - links.push(fetchProxy(href, null, 0)); //Then add it to links queue and fetch using CORS proxy - } - } - Promise.all(links).then(res => { - for (i = 0; i < res.length; ++i) { - loadCSS(res[i]); - } - }); - //Scripts - script = document.querySelectorAll('script[type="text/htmlpreview"]'); - for (i = 0; i < script.length; ++i) { - src = script[i].src; //Get absolute URL - if (src.indexOf('//raw.githubusercontent.com') > 0 || src.indexOf('//bitbucket.org') > 0) { //Check if it's from raw.github.com or bitbucket.org - scripts.push(fetchProxy(src, null, 0)); //Then add it to scripts queue and fetch using CORS proxy - } else { - script[i].removeAttribute('type'); - scripts.push(script[i].innerHTML); //Add inline script to queue to eval in order - } - } - Promise.all(scripts).then(res => { - for (i = 0; i < res.length; ++i) { - loadJS(res[i]); - } - document.dispatchEvent(new Event('DOMContentLoaded', {bubbles: true, cancelable: true})); //Dispatch DOMContentLoaded event after loading all scripts - }); - }; - - const loadHTML = data => { - if (data) { - data = data.replace(/]*)>/i, '').replace(/ just after and replace - - - - - - - - - - - -``` - - - - - -

_Resources/node_modules/web-dev-utils/

- -### [_Resources/node_modules/web-dev-utils/README.md](_Resources/node_modules/web-dev-utils/README.md) --testing - -

- - - - - - ![logo](https://avatars.githubusercontent.com/u/66654881?s=460&u=fa9d2cc45bc228dd9b7d3dee6d4653f940fab35a&v=4) - - -# MY WEB-DEV UTILITIES NPM PACKAGE - - -### This code is not exclusivley written by me ... it is just a list of files I use often during website development... use at your own risk - - - - -## Copy-2-Clipboard: - -![](./images/copy-2-clip.PNG) - ---- - -## Git-Html Preview-Tool: - -![](images/git-preview.gif) - - - ---- - -## Markdown Templates: - -![](images/markdown-template.png) - ---- - -## Text Tools: - -![](images/TexTools.PNG) - - ---- - -## Automatic Table Of Contents Generator: - -![](images/toc.PNG) - - - ---- - -## Text-File-2-JS-Array: - -![](images/text-file-2-JS-Array.PNG) - - ---- - -### Usage: - -```bash -npm i web-dev-utils -``` - -

---- - -``` -. -├── GIT-HTML-PREVIEW-TOOL -│ └── GIT-HTML-PREVIEW-TOOL-master -├── Markdown-Templates-master -│ └── Markdown-Templates-master -│ └── images -├── TexTools-master -│ └── TexTools-master -│ ├── backup-stable-build -│ │ ├── css -│ │ └── js -│ ├── css -│ ├── js -│ └── sandbox -├── bootstrap-4.3.1-dist -│ ├── css -│ └── js -├── jquery -│ ├── dist -│ ├── external -│ │ └── sizzle -│ │ └── dist -│ └── src -│ ├── ajax -│ │ └── var -│ ├── attributes -│ ├── core -│ │ └── var -│ ├── css -│ │ └── var -│ ├── data -│ │ └── var -│ ├── deferred -│ ├── deprecated -│ ├── effects -│ ├── event -│ ├── exports -│ ├── manipulation -│ │ └── var -│ ├── queue -│ ├── traversing -│ │ └── var -│ └── var -├── loadashes6 -│ └── lodash -│ └── fp -├── mout -│ ├── array -│ ├── collection -│ ├── date -│ │ └── i18n -│ ├── doc -│ ├── function -│ ├── lang -│ ├── math -│ ├── number -│ ├── object -│ ├── queryString -│ ├── random -│ ├── src -│ │ ├── array -│ │ ├── collection -│ │ ├── date -│ │ │ └── i18n -│ │ ├── function -│ │ ├── lang -│ │ ├── math -│ │ ├── number -│ │ ├── object -│ │ ├── queryString -│ │ ├── random -│ │ ├── string -│ │ └── time -│ ├── string -│ └── time -└── personal-utilities - ├── Auto-table-Of-Contents - ├── copy-2-clip - ├── css - ├── html - ├── js - └── prism - -81 directories -``` - - - - - -

_Resources/node_modules/web-dev-utils/TexTools/TexTools-master/

- -### [_Resources/node_modules/web-dev-utils/TexTools/TexTools-master/README.md](_Resources/node_modules/web-dev-utils/TexTools/TexTools-master/README.md) - - -

- - - - -# Deployment: - -[deployment](https://devtools42.netlify.app/) - - -# TexTools . - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - - **TOC** - [About](#about) ● [Features](#features) ● [How It Works](#how-it-works) ● [Installation](#installation) ● [Development](#development) ● [Contact](#contact) - - - - ![logo](https://avatars.githubusercontent.com/u/66654881?s=460&u=fa9d2cc45bc228dd9b7d3dee6d4653f940fab35a&v=4) - - [![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - -

- - [![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - - -# Usage: - -

-# Tools - -## \*8 text manipulation tools: . - ->1. Duplicate Remover (duplicate lines... Case and whitespace sensative) - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - ->2. Find and Replace - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - ->3. Compare Text Files: compares text files and if common text is detected between them only one of them will retain the text that previously existed in both. - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - ->4. Add Prefix/Suffix (by line.. not by file) - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - ->5. White Space remover (It removes all the whitespace within your text. I use it for creating javascript for iMacros for Firefox) - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - ->6. Sort Text Lines (It sorts text lines alphabetically in ascending and descending order) - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - ->7. Replace Lines Breaks (Replace line breaks with some text. One of the example where it can be used is to convert a normal text file with line breaks to csv type file.) - -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - ->8. Letter Case Converter (Converts the letter case of your text. Currently , only upper and lower letter cases are supported). - - -##Bryan Guner -*(Full-stack software developer)* - -[![Portfolio](https://img.shields.io/badge/-❤_Portfolio-f58?style=flat-square&logo=a&logoColor=white&link=https://bgoonz.github.io/)](https://bgoonz.github.io) -![Resume PDF](https://img.shields.io/badge/-Resume-f00?style=flat-square&logo=adobe-acrobat-reader&logoColor=white) -[![Bryan's email](https://img.shields.io/badge/bryan.guner@gmail.com-f4b400?style=flat-square&logo=gmail&logoColor=black&link=mailto:bryan.guner@gmail.com)](mailto:bryan.guner@gmail.com) -[![Blog](https://img.shields.io/badge/-Blog-21759b?style=flat-square&logo=WordPress&logoColor=white&link=https://web-dev-hub.com/)](https://web-dev-hub.com/) -[![Linkedin](https://img.shields.io/badge/-LinkedIn-0077b5?style=flat-square&logo=Linkedin&logoColor=white&link=https://www.linkedin.com/in/bryan-guner-046199128/)](https://www.linkedin.com/in/bryan-guner-046199128/) -[![AngelList](https://img.shields.io/badge/-AngelList-black?style=flat-square&logo=AngelList&logoColor=white&link=https://angel.co/u/bryan-guner)](https://angel.co/u/bryan-guner) -[![GitHub bgoonz](https://img.shields.io/github/followers/bgoonz?label=follow&style=social)](https://github.com/bgoonz) - -

- -
- -[![-----------------------------------------------------](https://raw.githubusercontent.com/andreasbm/readme/master/assets/lines/colored.png)](#-) - - - - - - - - - - - -

javascript-practice/-ALL-JS-Files/

- -### [javascript-practice/-ALL-JS-Files/output.md](javascript-practice/-ALL-JS-Files/output.md) -let str = 'MIICWwIBAAKBgGEdLjFEFbegPZ2AwJWkalksXr7PzWL7wIc7pOFZxXwYPWtQxvANyceCwpkqbPLsfEx7nqxAris2hYOdeN1OTFqvTyNmVuzbUPcXShn6ZoDCB30voHkeu4F3cUw5RQEUDdLscSnv4HMxHam5qgl6vXoumVNHbjyKA5UtAnfjAgMBAAECgYAmjEyvpZTxRJvwjxDi1VaZevFI0Hd4WPH9PAGgqdnH84vGXnAGFj1WikqKYcqKMQW2kdjAsWwH9D9FfrkIcDDHdZ9XuGSGkFzWtOwajWMQl7qNV1hZ288gdpIQQMOTLDgauZY6pw1cV7h4v316qJB8knQGoBNpJCfTYQJBAKV1ctsJq0Zg4QumD2hyODepP3LfLeaQsERLqVAWeuOuTY5mK5gIwsSqvcSVfY7Ze1FWIsApNFRv67azKcJPwsCQQCNlyApZFJEVNY70Er7Uu5NL9t4CYJJC9uVVkoEHEY6d7sVslqa0vP2q0zXx9YedbMBvQjxXIbY0waXUy63FvoBGJAkB3OTJWUjVgzDY1Br5wu2Yu59NjKVKLWzCsu1gaCNBfhVDX7SyIyC9EYKRfUAoQxwsmPWPyQ9QVG4WKcPZJAkBRheAotPCBE2RLHHfvpiStnMhX0UXdVyaJp5tcZ6wYV61ohyBvCOkYhUxBJzeIGrVZcvLZSLeUzXoqRPpxQxAkEAkdCZXF0gHahpZgF5y0wWcqf9ECRT1E4Hv8bk3Mf0Exp2aW34JeI6I7Xqd1NV4I9H7prQ8m3y39lFwWO8PmQ'; -console.log( str.indexOf( 'HEY' ) ); -console.log( 0 ); -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `alternatingCaps` that accepts a sentence string as an argument. The function should -// return the sentence where words alternate between lowercase and uppercase. -let alternatingCaps = sentence => { - let words = sentence.split( ' ' ); - let newWords = []; - for ( let i = 0; i < words.length; i++ ) { - let word = words[ i ]; - if ( i % 2 === 0 ) { - newWords.push( word.toLowerCase() ); - } else { - newWords.push( word.toUpperCase() ); - } - } - return newWords.join( ' ' ); -}; -console.log( alternatingCaps( "take them to school" ) ); // 'take THEM to SCHOOL' -console.log( alternatingCaps( "What did ThEy EAT before?" ) ); // 'what DID they EAT before?' -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `averageOfFour(num1, num2, num3, num4)` that accepts four numbers as arguments. The -// function should return the average of all four numbers. -let averageOfFour = ( num1, num2, num3, num4 ) => { - let sum = num1 + num2 + num3 + num4; - return sum / 4; -}; -console.log( averageOfFour( 10, 4, 12, 3 ) ); // 7.25 -console.log( averageOfFour( -20, 50, 4, 21 ) ); // 13.75 -console.log( averageOfFour( 10, 4, 12, 3 ) ); // 7.25 -console.log( averageOfFour( 5, 5, 3, 7 ) ); // 5 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `average` that accepts three numbers as arguments. The function should return the -// average of the three numbers. -let average = ( num1, num2, num3 ) => ( num1 + num2 + num3 ) / 3; -console.log( average( 3, 10, 8 ) ); // 7 -console.log( average( 10, 5, 12 ) ); // 9 -console.log( average( 6, 20, 40 ) ); // 22 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `bleepVowels` that accepts a string as an argument. The function should return -// a new string where all vowels are replaced with `*`s. Vowels are the letters a, e, i, o, u. -let bleepVowels = str => { - let vowels = [ "a", "e", "i", "o", "u" ]; - let bleeped = ""; - for ( let char of str ) { - if ( vowels.includes( char ) ) { - bleeped += "*"; - } else { - bleeped += char; - } - } - return bleeped; -}; -console.log( bleepVowels( "skateboard" ) ); // 'sk*t*b**rd' -console.log( bleepVowels( "slipper" ) ); // 'sl*pp*r' -console.log( bleepVowels( "range" ) ); // 'r*ng*' -console.log( bleepVowels( "brisk morning" ) ); // 'br*sk m*rn*ng' -console.log( false ); // false -console.log( !true ); // false -console.log( !false ); // true -console.log( !!true ); // true -console.log( false && false ); // false -console.log( false && true ); // false -console.log( true && false ); // false -console.log( true && true ); // true -console.log( false || false ); // false -console.log( false || true ); // true -console.log( true || false ); // true -console.log( true || true ); // true -console.log( !false || false ); // true -console.log( false || ( true && true ) ); // true -console.log( false || !( true && true ) ); // false -console.log( !true && ( true ) ); // false -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `caseChange` that accepts a string and a boolean as arguments. The function should -// return the uppercase version of the string if the boolean is true. The function should return the -// lowercase version of the string if the boolean is false. -let caseChange = ( str, shouldUpperCase ) => { - if ( shouldUpperCase ) { - return str.toUpperCase(); - } else { - return str.toLowerCase(); - } -}; -console.log( caseChange( "Super", true ) ); // 'SUPER' -console.log( caseChange( "Super", false ) ); // 'super' -console.log( caseChange( "tAmBourine", true ) ); // 'TAMBOURINE' -console.log( caseChange( "tAmBourine", false ) ); // 'tambourine' -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `censorE` that accepts a string as an argument. The function should return the a new -// version of string where all characters that are 'e's are replaced with '*'s. -let censorE = str => { - let newStr = ''; - for ( let char of str ) { - if ( char === 'e' ) { - newStr += '*'; - } else { - newStr += char; - } - } - return newStr; -}; -console.log( censorE( "speedy" ) ); // 'sp**dy' -console.log( censorE( "pending" ) ); // 'p*nding' -console.log( censorE( "scene" ) ); // 'sc*n*' -console.log( censorE( "heat" ) ); // 'h*at' -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `chooseDivisibles(numbers, target)` that accepts an array of numbers and a -// target number as arguments. The function should return an array containing elements of the original -// array that are divisible by the target. -let chooseDivisibles = ( numbers, target ) => { - let divisibles = []; - for ( let num of numbers ) { - if ( num % target === 0 ) { - divisibles.push( num ); - } - } - return divisibles; -}; -console.log( chooseDivisibles( [ 40, 7, 22, 20, 24 ], 4 ) ); // [40, 20, 24] -console.log( chooseDivisibles( [ 9, 33, 8, 17 ], 3 ) ); // [9, 33] -console.log( chooseDivisibles( [ 4, 25, 1000 ], 10 ) ); // [1000] -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `commonElements` that accepts two arrays as arguments. The function should return -// a new array containing the elements that are found in both of the input arrays. The order of -// the elements in the output array doesn't matter as long as the function returns the correct elements. -let commonElements = ( array1, array2 ) => { - let common = []; - for ( let ele of array1 ) { - if ( array2.includes( ele ) ) { - common.push( ele ); - } - } - return common; -}; -let arr1 = [ "a", "c", "d", "b" ]; -let arr2 = [ "b", "a", "y" ]; -console.log( commonElements( arr1, arr2 ) ); // ['a', 'b'] -let arr3 = [ 4, 7 ]; -let arr4 = [ 32, 7, 1, 4 ]; -console.log( commonElements( arr3, arr4 ) ); // [4, 7] -console.log( true === false ); // false -console.log( false === false ); // true -console.log( false !== true ); // true -console.log( !true === false ); // true -console.log( 2 + 3 === 5 ); // true -console.log( 4 < 0 ); // false -console.log( 10 >= 10 ); // true -console.log( 10.3 >= 10 ); // true -console.log( 100 / 2 === 50 ); // true -console.log( 100 % 2 === 0 ); // true -console.log( 11 % 2 === 0 ); // false -console.log( 7.0 === 7 ); // true -console.log( 13 % 5 > 0 ); // true -console.log( "potato" === "potato" ); // true -console.log( "Tomato" === "tomato" ); // false -console.log( "42" === 42 ); // false -console.log( 5 > 3 && 1 === 0 ); // false -t -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `contains(str1, str2)` that accepts two strings as arguments. The function should -// return a boolean indicating whether or not `str2` is contained within `str1`. The function should -// ignore any differences in capitalization. -let contains = ( str1, str2 ) => { - let lowerStr1 = str1.toLowerCase(); - let lowerStr2 = str2.toLowerCase(); - return lowerStr1.includes( lowerStr2 ); -}; -console.log( contains( "caterpillar", "pill" ) ); // true -console.log( contains( "lion's share", "on" ) ); // true -console.log( contains( "SORRY", "or" ) ); // true -console.log( contains( "tangent", "gem" ) ); // false -console.log( contains( "clock", "ok" ) ); // false -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `countUp(max)` that accepts a max number as an argument. The function should print -// all numbers from 1 up to and including the max. The function doesn't need to return any value. It -// should just print to the terminal. -let countUp = max => { - for ( let i = 1; i <= max; i++ ) { - console.log( i ); - } -}; -countUp( 5 ); -// prints -// 1 -// 2 -// 3 -// 4 -// 5 -countUp( 3 ); -// prints -// 1 -// 2 -// 3 -let phrase = "that's all folks"; -console.log( phrase[ phrase.length ] ); // undefined -console.log( phrase[ phrase.length - 1 ] ); // s -console.log( phrase[ phrase.length - 2 ] ); // k -const i = 9; -const char = phrase[ i ]; -console.log( char ); // l -console.log( phrase.indexOf( char ) ); // 8 -console.log( phrase.slice( 2, 8 ) ); // at's a -console.log( "abcdefg".slice( 1, 3 ) ); // bc -console.log( "abcdefg".slice( 2 ) ); // cdefg -console.log( "abcdefg".slice( 4 ) ); // efg -console.log( "abcdefg".slice( 2, -1 ) ); // cdef -console.log( "abcdefg".slice( 2, -2 ) ); // cde -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function named `divByEither(num1, num2, max)` that accepts three numbers as arguments. -// The function should print out all positive numbers less than max that are divisible by num1 or num2. -// The function doesn't need to return any value. It should just print to the terminal. -let divByEither = ( num1, num2, max ) => { - for ( let i = 1; i < max; i++ ) { - if ( i % num1 === 0 || i % num2 === 0 ) { - console.log( i ); - } - } -}; -divByEither( 4, 3, 16 ); -// prints -// 3 -// 4 -// 6 -// 8 -// 9 -// 12 -// 15 -divByEither( 7, 5, 20 ); -// prints -// 5 -// 7 -// 10 -// 14 -// 15 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `divisibleRange(min, max, num)` that accepts three numbers as arguments. The -// function should print all numbers between `min` and `max` (exclusive) that are also divisible by -// num. -let divisibleRange = ( min, max, num ) => { - for ( let i = min + 1; i < max; i++ ) { - if ( i % num === 0 ) { - console.log( i ); - } - } -}; -divisibleRange( 17, 40, 9 ); -// prints -// 18 -// 27 -// 36 -divisibleRange( 10, 24, 4 ); -// prints -// 12 -// 16 -// 20 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `divisible(num1, num2)` that accepts two numbers as arguments. The function should -// return a boolean indicating whether or not `num1` is divisible by `num2`. -let divisible = ( num1, num2 ) => num1 % num2 === 0; -// let divisible = function (num1, num2) { -// if (num1 % num2 === 0) { -// return true; -// } else { -// return false; -// } -// }; -console.log( divisible( 12, 3 ) ); // true -console.log( divisible( 12, 5 ) ); // false -console.log( divisible( 60, 4 ) ); // true -console.log( divisible( 60, 11 ) ); // false -console.log( divisible( 21, 7 ) ); // true -console.log( divisible( 21, 6 ) ); // false -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `divisors` that accepts a number as an argument. The function should return an -// array containing all positive numbers that can divide into the argument. -let divisors = n => { - let numbers = []; - for ( let i = 1; i <= n; i++ ) { - if ( n % i === 0 ) { - numbers.push( i ); - } - } - return numbers; -}; -console.log( divisors( 15 ) ); // [1, 3, 5, 15] -console.log( divisors( 7 ) ); // [1, 7] -console.log( divisors( 24 ) ); // [1, 2, 3, 4, 6, 8, 12, 24] -g -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `endsInLy` that accepts a string as an argument and returns a boolean indicating -// whether or not the string ends in the substring 'ly'. -let endsInLy = str => { - let secondLast = str[ str.length - 2 ]; - let last = str[ str.length - 1 ]; - return secondLast === 'l' && last === 'y'; -}; -// let endsInLy = function (str) { -// return str.endsWith('ly'); -// }; -console.log( endsInLy( "pretty" ) ); // false -console.log( endsInLy( "instant" ) ); // false -console.log( endsInLy( "analytic" ) ); // false -console.log( endsInLy( "timidly" ) ); // true -console.log( endsInLy( "fly" ) ); // true -console.log( endsInLy( "gallantly" ) ); // true -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `endsWithT` that accepts a string as an argument. The function should return a -// boolean indicating whether or not the string ends with the character 't'. -let endsWithT = str => { - let lastChar = str[ str.length - 1 ]; - return lastChar === 't'; -}; -console.log( endsWithT( "smart" ) ); // true -console.log( endsWithT( "racket" ) ); // true -console.log( endsWithT( "taco" ) ); // false -console.log( endsWithT( "boomerang" ) ); // false -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `evens(max)` that accepts a max number as an argument. The function should print -// all positive even numbers that are less than the max. -let evens = max => { - for ( let i = 1; i < max; i++ ) { - if ( i % 2 === 0 ) { - console.log( i ); - } - } -}; -evens( 11 ); -// prints -// 2 -// 4 -// 6 -// 8 -// 10 -evens( 8 ); -// prints -// 2 -// 4 -// 6 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `filterLongWords` that accepts an array of strings as an argument. The function -// should return a new array containing only the strings that are less than 5 characters long. -let filterLongWords = words => { - let chosenWords = []; - for ( let word of words ) { - if ( word.length < 5 ) { - chosenWords.push( word ); - } - } - return chosenWords; -}; -console.log( filterLongWords( [ "kale", "cat", "retro", "axe", "heirloom" ] ) ); -// ['kale', 'cat', 'axe'] -console.log( filterLongWords( [ "disrupt", "pour", "trade", "pic" ] ) ); -// ['pour', 'pic'] -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function named `fiveMultiplesOf` that accepts a number as an argument. The function should -// print out the first five multiples of the given number. The function doesn't need to return any -// value. It should just print to the terminal. -let fiveMultiplesOf = num => { - for ( let i = 1; i <= 5; i++ ) { - console.log( i * num ); - } -}; -fiveMultiplesOf( 7 ); -// prints -// 7 -// 14 -// 21 -// 28 -// 35 -fiveMultiplesOf( 3 ); -// prints -// 3 -// 6 -// 9 -// 12 -// 15 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `fizzBuzz` that accepts a max number as an argument. The function should -// print all numbers less than or equal to max that are divisible by either 3 or 5 but not both 3 -// and 5. The function doesn't need to return any value. It should just print to the terminal. -let fizzBuzz = max => { - for ( let i = 1; i <= max; i++ ) { - if ( ( i % 3 === 0 || i % 5 === 0 ) && !( i % 3 === 0 && i % 5 === 0 ) ) { - console.log( i ); - } - } -}; -fizzBuzz( 18 ); -// prints -// 3 -// 5 -// 6 -// 9 -// 10 -// 12 -// 18 -fizzBuzz( 33 ); -// prints -// 3 -// 5 -// 6 -// 9 -// 10 -// 12 -// 18 -// 20 -// 21 -// 24 -// 25 -// 27 -// 33 -let movie = 'Fight Club'; -let views = 4; -console.log( `I watched ${ movie } about ${ views } number of times` ); -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `funnySound` that accepts two strings as arguments. The function should return a -// new string containing the first three characters of both strings concatenated together. -// You can assume that the arguments are both at least three characters long. -let funnySound = ( str1, str2 ) => str1.slice( 0, 3 ) + str2.slice( 0, 3 ); -console.log( funnySound( "tiger", "spoon" ) ); // 'tigspo' -console.log( funnySound( "computer", "phone" ) ); // 'compho' -console.log( funnySound( "skate", "bottle" ) ); // 'skabot' -console.log( funnySound( "frog", "ashtray" ) ); // 'froash' -console.log( 'hello world' ); -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `half` that accepts a number as an argument. The function should return half of the -// number. -let half = n => n / 2; -console.log( half( 8 ) ); // 4 -console.log( half( 15 ) ); // 7.5 -console.log( half( 90 ) ); // 45 -gi -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `inRange(min, max, n)` that accepts three numbers as arguments. The function should -// return a boolean indicating if `n` is between `min` and `max` inclusive. -let inRange = ( min, max, n ) => n >= min && n <= max; -console.log( inRange( 5, 13, 8 ) ); // true -console.log( inRange( 5, 13, 29 ) ); // false -console.log( inRange( 100, 125, 100 ) ); // true -console.log( inRange( 100, 125, 99 ) ); // false -console.log( inRange( 40, 45, 44 ) ); // true -console.log( inRange( 40, 45, 45 ) ); // true -console.log( inRange( 40, 45, 46 ) ); // false -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `isDivBy4` that accepts a number as an argument. The function should return a -// boolean indicating whether or not the number is divisible by 4. -let isDivBy4 = num => { - if ( num % 4 === 0 ) { - return true; - } else { - return false; - } -}; -// let isDivBy4 = function (num) { -// return num % 4 === 0; -// }; -console.log( isDivBy4( 8 ) ); // true -console.log( isDivBy4( 12 ) ); // true -console.log( isDivBy4( 24 ) ); // true -console.log( isDivBy4( 9 ) ); // false -console.log( isDivBy4( 10 ) ); // false -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `isLong` that accepts a string as an argument. The function should return a boolean -// indicating whether or not the string is longer than 5 characters -let isLong = ( { - length -} ) => length > 5; -// let isLong = function (str) { -// if (str.length > 5) { -// return true; -// } else { -// return false; -// } -// }; -console.log( isLong( "pie" ) ); // false -console.log( isLong( "kite" ) ); // false -console.log( isLong( "kitty" ) ); // false -console.log( isLong( "telescope" ) ); // true -console.log( isLong( "thermometer" ) ); // true -console.log( isLong( "restaurant" ) ); // true -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `keepItQuiet` that accepts a string as an argument. The function should return the -// lowercase version of the string with 3 periods added to the end of it. -let keepItQuiet = str => `${ str.toLowerCase() }...`; -console.log( keepItQuiet( "HOORAY" ) ); // 'hooray...' -console.log( keepItQuiet( "Doggo" ) ); // 'doggo...' -console.log( keepItQuiet( "WHAT?!?!" ) ); // 'what?!?!...' -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `larger` that accepts two numbers as arguments. The function should return the -// larger number. -let larger = ( num1, num2 ) => { - if ( num1 > num2 ) { - return num1; - } else { - return num2; - } -}; -console.log( larger( 256, 400 ) ); // 400 -console.log( larger( 31, 4 ) ); // 31 -console.log( larger( -6, 7 ) ); // 7 -console.log( larger( 11.3, 11.2 ) ); // 11.3 -console.log( larger( -10, -3 ) ); // -3 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `lengthiestWord` that accepts a sentence string as an argument. The function should -// return the longest word of the sentence. If there is a tie, return the word that appears later -// in the sentence. -let lengthiestWord = sentence => { - let words = sentence.split( ' ' ); - let longest = words[ 0 ]; // pretty - for ( let i = 1; i < words.length; i++ ) { - let word = words[ i ]; - if ( word.length >= longest.length ) { - longest = word; - } - } - return longest; -}; -console.log( lengthiestWord( "I am pretty hungry" ) ); // 'hungry' -console.log( lengthiestWord( "we should think outside of the box" ) ); // 'outside' -console.log( lengthiestWord( "down the rabbit hole" ) ); // 'rabbit' -console.log( lengthiestWord( "simmer down" ) ); // 'simmer' -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `longer` that accepts two strings as arguments. The function should return the -// string that is longer. If the strings have the same length, then return the first string. -let longer = ( str1, str2 ) => { - if ( str1.length >= str2.length ) { - return str1; - } else { - return str2; - } -}; -console.log( longer( "drum", "piranha" ) ); // 'piranha' -console.log( longer( "basket", "fork" ) ); // 'basket' -console.log( longer( "flannel", "sustainable" ) ); // 'sustainable' -console.log( longer( "disrupt", "ability" ) ); // 'disrupt' -console.log( longer( "bird", "shoe" ) ); // 'bird' -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `makeAcronym` that accepts a sentence string as an argument. The function should -// return a string containing the first character of each word in the sentence. -let makeAcronym = sentence => { - let words = sentence.split( ' ' ); - let acronym = ''; - for ( let word of words ) { - acronym += word[ 0 ]; - } - return acronym.toUpperCase(); -}; -console.log( makeAcronym( "New York" ) ); // NY -console.log( makeAcronym( "same stuff different day" ) ); // SSDD -console.log( makeAcronym( "Laugh out loud" ) ); // LOL -console.log( makeAcronym( "don't over think stuff" ) ); // DOTS -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `makeMatrix(m, n, value)` that accepts three arguments. The function should return -// a 2-dimensional array of height `m` and width `n` that contains the `value` as every element. -let makeMatrix = ( m, n, value ) => { - let matrix = []; - for ( let i = 0; i < m; i++ ) { - let row = []; - for ( let j = 0; j < n; j++ ) { - row.push( value ); - } - matrix.push( row ); - } - return matrix; -}; -console.log( makeMatrix( 3, 5, null ) ); -// [ -// [ null, null, null, null, null ], -// [ null, null, null, null, null ], -// [ null, null, null, null, null ] -// ] -console.log( makeMatrix( 4, 2, "x" ) ); -// [ -// [ 'x', 'x' ], -// [ 'x', 'x' ], -// [ 'x', 'x' ], -// [ 'x', 'x' ] -// ] -console.log( makeMatrix( 2, 2, 0 ) ); -// [ -// [ 0, 0 ], -// [ 0, 0 ] -// ] -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `maximum` that accepts an array of numbers as an argument. The function should -// return the largest number of the array. If the array is empty, then the function should return null. -let maximum = numbers => { - if ( numbers.length === 0 ) { - return null; - } - let currentMax = numbers[ 0 ]; - for ( let i = 1; i < numbers.length; i++ ) { - if ( numbers[ i ] > currentMax ) { - currentMax = numbers[ i ]; - } - } - return currentMax; -}; -console.log( maximum( [ 5, 6, 3, 7 ] ) ); // 7 -console.log( maximum( [ 17, 15, 19, 11, 2 ] ) ); // 19 -console.log( maximum( [] ) ); // null -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `minToMax(min, max)` that accepts two numbers as arguments. The function should -// print all numbers from min to max inclusive. The function doesn't need to return any value. It -// should just print to the terminal. -let minToMax = ( min, max ) => { - for ( let i = min; i <= max; i++ ) { - console.log( i ); - } -}; -minToMax( 5, 9 ); -// prints -// 5 -// 6 -// 7 -// 8 -// 9 -minToMax( 11, 13 ); -// prints -// 11 -// 12 -// 13 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function named `noOhs` that accepts a string as an argument. The functions should print the -// characters of the string one by one except the character 'o'. The function doesn't need to return -// any value. It should just print to the terminal. -let noOhs = str => { - for ( let char of str ) { - if ( char !== 'o' ) { - console.log( char ); - } - } -}; -noOhs( "code" ); -// prints -// c -// d -// e -noOhs( "school" ); -// prints -// s -// c -// h -// l -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `numOdds` that accepts an array of numbers as an argument. The function should -// return a number representing the count of odd elements in the array. -function numOdds( numbers ) { - let count = 0; - for ( let i = 0; i < numbers.length; { - if () {} - }( numbers[ i ] % 2 ) === 1 ) { - count += 1; - } -} -return count; -}; -console.log( numOdds( [ 4, 7, 2, 5, 9 ] ) ); // 3 -console.log( numOdds( [ 11, 31, 58, 99, 21, 60 ] ) ); // 4 -console.log( numOdds( [ 100, 40, 4 ] ) ); // 0 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `numberChange` that accepts a number as an argument. The function should return -// half the number if it is even. The function should return double the number if it is odd. -let numberChange = n => { - if ( n % 2 === 0 ) { - return n / 2; - } else { - return n * 2; - } -}; -console.log( numberChange( 6 ) ); // 3 -console.log( numberChange( 7 ) ); // 14 -console.log( numberChange( 16 ) ); // 8 -console.log( numberChange( 21 ) ); // 42 -console.log( 2 + 3 ); // 5 -console.log( 10 - 15 ); // -5 -console.log( 4 + 1 - 5 ); // 0 -console.log( 4 * 3 ); // 12 -console.log( 7 / 2 ); // 3.5 -console.log( 4 + 2 * 3 ); // 10 -console.log( ( 4 + 2 ) * 3 ); // 18 -console.log( 5 % 2 ); // 1 -console.log( 6 % 2 ); // 0 -console.log( 7 % 2 ); // 1 -console.log( 8 % 2 ); // 0 -console.log( 19 % 8 ); // 3 -console.log( 24 % 8 ); // 0 -console.log( 7 % 4 ); // 3 -console.log( 4 % 7 ); // 4 -console.log( 5 + ( 10 % 5 ) ); // 5 -console.log( ( 5 + 10 ) % 5 ); // 0 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `numberRange(min, max, step)` that accepts three numbers as arguments, `min`, -// `max`, and `step`. The function should return all numbers between `min` and `max` at `step` intervals. -// `min` and `max` are inclusive. -let numberRange = ( min, max, step ) => { - let range = []; - for ( let i = min; i <= max; i += step ) { - range.push( i ); - } - return range; -}; -console.log( numberRange( 10, 40, 5 ) ); // [10, 15, 20, 25, 30, 35, 40] -console.log( numberRange( 14, 24, 3 ) ); // [14, 17, 20, 23] -console.log( numberRange( 8, 35, 6 ) ); // [8, 14, 20, 26, 32] -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function named `oddSum(max)` that accepts a max number as an argument. The function should -// return the total sum of all odd numbers from 1 to the max, inclusive. -// -// For example, oddSum(10) should return 25 because 1 + 3 + 5 + 7 + 9 = 25 -let oddSum = max => { - let sum = 0; - for ( let i = 1; i <= max; i++ ) { - if ( i % 2 === 1 ) { - sum += i; - } - } - return sum; -}; -console.log( oddSum( 10 ) ); // 25 -console.log( oddSum( 5 ) ); // 9 -let word = "bye"; -console.log( `${ word } felicia` ); // 'bye felicia' -console.log( word ); // 'bye' -let num = 10; -num = num * 2; -console.log( num ); // 20 -let bottlesOfBeer = 99; -let around = bottlesOfBeer - 1; -console.log( around ); // 98 -console.log( bottlesOfBeer ); // 99 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `oneOrNone` that accepts two booleans as arguments. The function should return true -// if exactly one of the arguments is true. If BOTH arguments are true, then it should return false. -let oneOrNone = ( val1, val2 ) => { - if ( ( val1 || val2 ) && !( val1 && val2 ) ) { - return true; - } else { - return false; - } -}; -console.log( oneOrNone( false, false ) ); // false -console.log( oneOrNone( true, false ) ); // true -console.log( oneOrNone( false, true ) ); // true -console.log( oneOrNone( true, true ) ); // false -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `oneToFour` that prints all whole numbers from one to four, inclusive. The function -// takes in no arguments and doesn't need to return any value. It should just print to the terminal. -let oneToFour = () => { - for ( let i = 1; i <= 4; i++ ) { - console.log( i ); - } -}; -oneToFour(); -// prints -// 1 -// 2 -// 3 -// 4 -i t // snippet 1-0 -let qty = 38; -if ( qty > 30 && qty % 5 === 4 ) { - console.log( "swish" ); -} else { - console.log( "swoosh" ); // prints -} -if ( qty > 0 ) { - console.log( "pos" ); // prints -} -// snippet 1-1 -let a = "celery"; -let b = "SQUASH"; -if ( a === a.toUpperCase() ) { - console.log( "alpha" ); -} -if ( b === b.toUpperCase() ) { - console.log( "beta" ); // prints -} -// snippet 1-2 -let number = 9; -if ( number > 4 ) { - console.log( "ding" ); // prints -} else if ( number % 3 === 0 ) { - console.log( "dong" ); -} -// snippet 1-3 -let z = 12; -if ( z > 10 ) { - console.log( "vroom" ); // prints -} -if ( z % 3 === 0 ) { - console.log( "skrrt" ); // prints -} -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `pairPrint` that accepts an array as an argument. The function should print -// all unique pairs of elements in the array. The function doesn't need to return any value. It -// should just print to the terminal. - -let pairPrint = function ( array ) { - for ( let i = 0; i < array.length; i++ ) { - for ( let j = i + 1; j < array.length; j++ ) { - console.log( array[ i ] + ' - ' + array[ j ] ); - } - } -}; - -pairPrint( [ "artichoke", "broccoli", "carrot", "daikon" ] ); -// prints -// artichoke - broccoli -// artichoke - carrot -// artichoke - daikon -// broccoli - carrot -// broccoli - daikon -// carrot - daikon - -pairPrint( [ "apple", "banana", "clementine" ] ); -// prints -// apple - banana -// apple - clementine -// banana - clementine - -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `parity` that accepts a number as an argument. The function should return the -// string 'even' if the number is even. It should return the string 'odd' if the number is odd. -let parity = function ( num ) { - if ( num % 2 === 0 ) { - return 'even'; - } else { - return 'odd'; - } -}; -console.log( parity( 5 ) ); // 'odd' -console.log( parity( 7 ) ); // 'odd' -console.log( parity( 13 ) ); // 'odd' -console.log( parity( 32 ) ); // 'even' -console.log( parity( 10 ) ); // 'even' -console.log( parity( 602348 ) ); // 'even' -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `print2d` that accepts a two-dimensional array as an argument. The function -// should print all inner elements of the array. - -let print2d = function ( array ) { - for ( let i = 0; i < array.length; i++ ) { - let subarray = array[ i ]; - for ( let j = 0; j < subarray.length; j++ ) { - console.log( subarray[ j ] ); - } - } -}; - - -let array1 = [ - [ "a", "b", "c", "d" ], - [ "e", "f" ], - [ "g", "h", "i" ], -]; -print2d( array1 ); -// prints -// a -// b -// c -// d -// e -// f -// g -// h -// i - -let array2 = [ - [ 9, 3, 4 ], - [ 11 ], - [ 42, 100 ] -]; -print2d( array2 ); -// prints -// 9 -// 3 -// 4 -// 11 -// 42 -// 100 - -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -/// Write a function `printCombinations`that accepts two arrays as arguments. The function should -// print all combinations of the elements generated by taking an element from the first array and -// and an element from the second array. The function doesn't need to return any value. It -// should just print to the terminal. - - -let printCombinations = function ( array1, array2 ) { - for ( let i = 0; i < array1.length; i++ ) { - let ele1 = array1[ i ]; - - for ( let j = 0; j < array2.length; j++ ) { - let ele2 = array2[ j ]; - console.log( ele1, ele2 ); - } - } -}; - -let colors = [ "gray", "cream", "cyan" ]; -let clothes = [ "shirt", "flannel" ]; -printCombinations( colors, clothes ); -// prints -// gray shirt -// gray flannel -// cream shirt -// cream flannel -// cyan shirt -// cyan flannel - -printCombinations( [ "hot", "cold" ], [ "soup", "tea" ] ); -// prints -// hot soup -// hot tea -// cold soup -// cold tea - -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function named `productUpTo(max)` that accepts a max number as an argument. The function -// should return the total product of all whole numbers from 1 to the max, inclusive. A product is a -// number obtained from multiplying numbers together. -// -// For example, productUpTo(4) should return 24 because 1 * 2 * 3 * 4 = 24 -let productUpTo = function ( max ) { - let product = 1; - for ( let i = 1; i <= max; i++ ) { - product *= i; - } - return product; -}; -console.log( productUpTo( 4 ) ); // 24 -console.log( productUpTo( 5 ) ); // 120 -console.log( productUpTo( 7 ) ); // 5040 -let word = "suspension bridge"; -console.log( word[ 4 ] ); // e -console.log( word.length > 5 && word[ 0 ] === "d" ); // false -console.log( word.length > 5 && word[ 0 ] === "s" ); // true -console.log( word.indexOf( "o" ) > -1 ); // true -console.log( word.indexOf( "z" ) > -1 ); // false -let str = "foggy"; -console.log( str[ 2 + 1 ] ); // g -console.log( str[ str.length - 1 ] ); // y -str = " day"; -console.log( str ); // ' day' -console.log( str.length ); // 4 -console.log( str.indexOf( "ogg" ) ); // -1 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `raisePower(base, exponent)` that accepts two numbers, `base` and `exponent`. The -// function should return `base` raised to the `exponent` power. -// -// For example, raisePower(2, 5) should return 32 because 2 * 2 * 2 * 2 * 2 = 32 -// For example, raisePower(4, 3) should return 64 because 4 * 4 * 4 = 64 -let raisePower = function ( base, exponent ) { - let product = 1; - for ( let i = 1; i <= exponent; i++ ) { - product *= base; - } - return product; -}; -console.log( raisePower( 2, 5 ) ); // 32 -console.log( raisePower( 4, 3 ) ); // 64 -console.log( raisePower( 10, 4 ) ); // 10000 -console.log( raisePower( 7, 2 ) ); // 49 -//--- --------------------------------------------------------------------------------> -//---------------------------------------(NEXT:)-------------------------------------> -//--- --------------------------------------------------------------------------------> -// Write a function `removeCapitals` that accepts a string as an argument. The function should return a -// new version of the string with all capital letters removed. -let removeCapitals = function ( str ) { - let newStr = ''; - for ( let i = 0; i < str.length; { - let char = str[ i ]; - if ( char === char.toLowerCase() ) { - newStr += char; - } - } - return newStr; - }; - console.log( removeCapitals( "fOrEver" ) ); // 'frver' - console.log( removeCapitals( "raiNCoat" ) ); // 'raioat' - console.log( removeCapitals( "cElLAr Door" ) ); // 'clr oor' - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `removeDupes` that accepts an array as an argument. The function should return a - // new array where each element only appears once. - let removeDupes = function ( array ) { - let uniques = []; - for ( let i = 0; i < array.length; { - let ele = array[ i ]; - if ( !uniques.includes( ele ) ) { - uniques.push( ele ); - } - } - return uniques; - }; - console.log( removeDupes( [ "x", "y", "y", "x", "z" ] ) ); // ['x', 'y', 'z'] - console.log( removeDupes( [ false, false, true, false ] ) ); // [false, true] - console.log( removeDupes( [ 42, 5, 7, 42, 7, 3, 7, 7 ] ) ); // [42, 5, 7, 3] - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `removeFirstVowel` that accepts a string as an argument. The function should return - // the string with it's first vowel removed. - let removeFirstVowel = function ( str ) { - let vowels = 'aeiou'; - for ( let i = 0; i < str.length; { - let char = str[ i ]; - if ( vowels.includes( char ) ) { - return str.slice( 0, i ) + str.slice( i + 1 ); - } - } - return str; - }; - console.log( removeFirstVowel( "volcano" ) ); // 'vlcano' - console.log( removeFirstVowel( "celery" ) ); // 'clery' - console.log( removeFirstVowel( "juice" ) ); // 'jice' - console.log( removeFirstVowel( "bridge" ) ); // 'brdge' - console.log( removeFirstVowel( "try" ) ); // 'try' - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `removeShortWords` that accepts a sentence string as an argument. The function - // should return a new sentence where all of the words shorter than 4 characters are removed. - let removeShortWords = function ( sentence ) { - let words = sentence.split( ' ' ); - let chosenWords = []; - for ( let i = 0; i < words.length; { - let word = words[ i ]; - if ( word.length >= 4 ) { - chosenWords.push( word ); - } - } - return chosenWords.join( ' ' ); - }; - console.log( removeShortWords( "knock on the door will you" ) ); // 'knock door will' - console.log( removeShortWords( "a terrible plan" ) ); // 'terrible plan' - console.log( removeShortWords( "run faster that way" ) ); // 'faster that' - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `removeVowels` that accepts a string as an argument. The function should return - // a version of the string where all vowels are removed. - let removeVowels = function ( str ) { - let newStr = ''; - let vowels = 'aeiou'; - for ( let i = 0; i < str.length; { - let char = str[ i ]; - if ( !vowels.includes( char ) ) { - newStr += char; - } - } - return newStr; - }; - console.log( removeVowels( "jello" ) ); // jll - console.log( removeVowels( "sensitivity" ) ); // snstvty - console.log( removeVowels( "cellar door" ) ); // cllr dr - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `reverseArray` that accepts an array as an argument. The function should return a - // array containing the elements of the original array in reverse order. - let reverseArray1 = function ( array ) { - let reversed = []; - for ( let i = array.length - 1; i >= 0; i-- ) { - reversed.push( array[ i ] ); - } - return reversed; - }; - console.log( reverseArray1( [ "zero", "one", "two", "three" ] ) ); // ['three', 'two', 'one', 'zero'] - console.log( reverseArray1( [ 7, 1, 8 ] ) ); // [8, 1, 7] - let reverseArray2 = function ( array ) { - let reversed = []; - for ( let i = 0; i < array.length; { - reversed.unshift( array[ i ] ); - } - return reversed; - }; - console.log( reverseArray2( [ "zero", "one", "two", "three" ] ) ); // ['three', 'two', 'one', 'zero'] - console.log( reverseArray2( [ 7, 1, 8 ] ) ); // [8, 1, 7] - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `reverseIterate` that accepts a string as an argument. The function should print - // the characters of the string one by one, in reverse order. The function doesn't need to return any - // value. It should just print to the terminal. - let reverseIterate = function ( str ) { - for ( let i = str.length - 1; i >= 0; i-- ) { - console.log( str[ i ] ); - } - }; - reverseIterate( "carrot" ); - // prints - // t - // o - // r - // r - // a - // c - reverseIterate( "box" ); - // prints - // x - // o - // b - - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `shortenLongWords` that accepts a sentence string as an argument. The function - // should return the same sentence where words longer than 4 characters have their vowels removed. - let removeVowels = function ( str ) { - let newStr = ''; - let vowels = 'aeiou'; - for ( let i = 0; i < str.length; { - let char = str[ i ]; - if ( !vowels.includes( char ) ) { - newStr += char; - } - } - return newStr; - }; - let shortenLongWords = function ( sentence ) { - let words = sentence.split( ' ' ); - let newWords = []; - for ( let i = 0; i < words.length; { - let word = words[ i ]; - if ( word.length > 4 ) { - let noVowels = removeVowels( word ); - newWords.push( noVowels ); - } else { - // leave it the same - newWords.push( word ); - } - } - return newWords.join( ' ' ); - }; - console.log( shortenLongWords( "they are very noble people" ) ); // 'they are very nbl ppl' - console.log( shortenLongWords( "stick with it" ) ); // 'stck with it' - console.log( shortenLongWords( "ballerina, you must have seen her" ) ); // 'bllrna, you must have seen her - console.log( "promenade" [ 3 ] ); // m - console.log( "tiger" [ 1 ] ); // i - console.log( "wheel".length ); // 5 - console.log( "wheel".length - 1 ); // 4 - console.log( "noMAD".toUpperCase() ); // NOMAD - console.log( "hey programmers" [ 2 ] === "y" ); // true - console.log( "volleyball".length > 20 ); // false - console.log( "treasure".indexOf( "r" ) ); // 1 - console.log( "treasure".indexOf( "e" ) ); // 2 - console.log( "web" [ 5 ] ); // undefined - console.log( "red".indexOf( "x" ) ); // -1 - console.log( "red".indexOf( "R" ) ); // -1 - // snippet 0-1 - let greet = function () { - console.log( "hey" ); - console.log( "programmers" ); - }; - let whistle = function () { - console.log( "doot" ); - }; - console.log( "first" ); - console.log( "second" ); - greet(); - console.log( "third" ); - console.log( "fourth" ); - whistle(); - // first - // second - // hey - // programmers - // third - // fourth - // doot - // snippet 0-2 - let howMany = function () { - return 42; - }; - console.log( howMany ); - console.log( howMany() ); - const theAnswer = howMany(); - console.log( theAnswer ); - let howMuch = function () { - 5; - }; - console.log( howMuch() ); - // [Function: howMany] - // 42 - // 42 - // undefined - // snippet 0-3 - let average = function ( num1, num2 ) { - console.log( "calculating..." ); - return ( num1 + num2 ) / 2; - }; - console.log( average( 5, 10 ) ); - console.log( average( 20, 26 ) ); - console.log( average( 50, 100 ) + 2 ); - let a = 21 + 3; - let b = 20; - let n = average( a, b ); - console.log( average( n, 18 ) ); - // calculating... - // 7.5 - // calculating... - // 23 - // calculating... - // 77 - // calculating... - // calculating... - // 20 - // snippet 0-4 - let exclaim = function ( str ) { - let capitalized = str.toUpperCase(); - return capitalized + "!!"; - }; - let result = exclaim( "potato" ); - console.log( result ); - console.log( result.length ); - console.log( result[ 0 ] ); - console.log( result[ result.length - 1 ] ); - // POTATO!! - // 8 - // P - // ! - // snippet 1 - console.log( "hello" ); - for ( let i = 0; i < 5; i++ ) { - console.log( "code" ); - } - console.log( "goodbye" ); - hello - code - code - code - code - code - goodbye - // snippet 1 - for ( let i = 1; i <= 4; i++ ) { - for ( let j = 1; j <= 3; j++ ) { - console.log( i, j ); - } - } - // 1 1 - // 1 2 - // 1 3 - // 2 1 - // 2 2 - // 2 3 - // 3 1 - // 3 2 - // 3 3 - // 4 1 - // 4 2 - // 4 3 - // snippet 2 - console.log( "hi" ); - for ( let i = 3; i <= 7; i++ ) { - console.log( "program" ); - console.log( i ); - } - console.log( "bye" ); - // hi - // program - // 3 - // program - // 4 - // program - // 5 - // program - // 6 - // program - // 7 - // bye - // snippet 2 - for ( let n = 0; n < 2; n++ ) { - console.log( "n=" + n ); - for ( let m = 0; m < 5; m++ ) { - console.log( " m=" + m ); - } - console.log( "n=" + n ); - } - // n=0 - // m=0 - // m=1 - // m=2 - // m=3 - // m=4 - // n=0 - // n=1 - // m=0 - // m=1 - // m=2 - // m=3 - // m=4 - // n=1 - // snippet 3 - let foo = function () { - for ( let num = 10; num > 0; num -= 2 ) { - console.log( num ); - } - }; - console.log( "begin" ); - foo(); - console.log( "end" ); - foo(); - // begin - // 10 - // 8 - // 6 - // 4 - // 2 - // end - // 10 - // 8 - // 6 - // 4 - // 2 - // snippet 3 - let friends = [ "philip", "abby", "phelipe", "simcha" ]; - for ( let i = 0; i < friends.length; { - for ( let j = 0; j < friends.length; { - console.log( friends[ i ], friends[ j ] ); - } - } - // philip philip - // philip abby - // philip phelipe - // philip simcha - // abby philip - // abby abby - // abby phelipe - // abby simcha - // phelipe philip - // phelipe abby - // phelipe phelipe - // phelipe simcha - // simcha philip - // simcha abby - // simcha phelipe - // simcha simcha - // snippet 4 - let word = "street"; - for ( let i = 0; i < word.length; { - console.log( i ); - console.log( word[ i ] ); - } - // 0 - // s - // 1 - // t - // 2 - // r - // 3 - // e - // 4 - // e - // 5 - // t - // snippet 4 - let locations = [ "flatbush", "williamsburg", "bushwick", "greenpoint" ]; - for ( let i = 0; i < locations.length; { - for ( let j = i + 1; j < locations.length; { - console.log( locations[ i ], locations[ j ] ); - } - } - // flatbush williamsburg - // flatbush bushwick - // flatbush greenpoint - // williamsburg bushwick - // williamsburg greenpoint - // bushwick greenpoint - // snippet 5 - let total = 0; // 10 - for ( let i = 1; i < 5; i++ ) { - total += i; - console.log( total ); - } - console.log( "grand total: " + total ); - // 1 - // 3 - // 6 - // 10 - // grand total: 10 - // snippet 5 - let colors = [ "red", "purple", "orange" ]; - for ( let i = 0; i < colors.length; { - let colorStr = colors[ i ]; - console.log( colorStr ); - for ( let j = 0; j < colorStr.length; { - let char = colorStr[ j ]; - console.log( char ); - } - } - // red - // r - // e - // d - // purple - // p - // u - // r - // p - // l - // e - // orange - // o - // r - // a - // n - // g - // e - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `spam` that accepts a 2D array as an argument. The array contains pairs as elements. - // The first element of every pair is a number and the second element is a word. The function should - // return a string containing the words repeated the specified number of times. See the examples. - let spam = function ( pairs ) { - let words = []; - for ( let i = 0; i < pairs.length; { - let pair = pairs[ i ]; - let word = pair[ 0 ]; - let num = pair[ 1 ]; - for ( let j = 0; j < num; { - words.push( word ); - } - } - return words.join( ' ' ); - }; - let array1 = [ - [ "hi", 3 ], - [ "bye", 2 ], - ]; console.log( spam( array1 ) ); // 'hi hi hi bye bye' - let array2 = [ - [ "cat", 1 ], - [ "dog", 2 ], - [ "bird", 4 ], - ]; console.log( spam( array2 ) ); // 'cat dog dog bird bird bird bird' - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `startsWithR` that accepts a string as an argument and returns a boolean indicating - // whether or not the string starts with 'r' or 'R'. - let startsWithR = function ( str ) { - return str[ 0 ] === 'r' || str[ 0 ] === 'R'; - }; console.log( startsWithR( "roger that" ) ); // true - console.log( startsWithR( "Row, row, row your boat" ) ); // true - console.log( startsWithR( "slip" ) ); // false - console.log( startsWithR( "Taxicab" ) ); // false - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `stayPositive` that accepts an array of numbers as an argument. The function should - // return an array containing only the positive numbers. - let stayPositive = function ( numbers ) { - let positives = []; - for ( let i = 0; i < numbers.length; { - if ( numbers[ i ] > 0 ) { - positives.push( numbers[ i ] ); - } - } - return positives; - }; - console.log( stayPositive( [ 10, -4, 3, 6 ] ) ); // [10, 3, 6] - console.log( stayPositive( [ -5, 11, -40, 30.3, -2 ] ) ); // [11, 30.3] - console.log( stayPositive( [ -11, -30 ] ) ); // [] - console.log( "river" + "town" ); - console.log( "cat" + "dog" ); - console.log( "New" + " York" ); - console.log( "runner's knee" + "!" ); - console.log( "man" + "bear" + "pig" ); - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `stringIterate` that accepts a string as an argument. The function should print out - // each character of the string, one by one. The function doesn't need to return any value. It should - // just print to the terminal. - let stringIterate = function ( string ) { - for ( let i = 0; i < string.length; { - console.log( string[ i ] ); - } - }; - stringIterate( "celery" ); - // prints - // c - // e - // l - // e - // r - // y - stringIterate( "hat" ); - // prints - // h - // a - // t - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function named `stringRepeater(str, num)` that accepts a string and a number as arguments. - // The function should return a new string consisting of the `str` repeated `num` number of times. - let stringRepeater = function ( str, num ) { - let repeatedStr = ''; - for ( let i = 1; i <= num; i++ ) { - repeatedStr += str - } - return repeatedStr; - }; - console.log( stringRepeater( "q", 4 ) ); // 'qqqq' - console.log( stringRepeater( "go", 2 ) ); // 'gogo' - console.log( stringRepeater( "tac", 3 ) ); // 'tactactac' - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `stringSize` that accepts a string as an argument. The function should return the - // string 'small' if the argument is shorter than 5 characters, 'medium' if it is exactly 5 characters, and - // 'large' if it is longer than 5 characters. - let stringSize = function ( str ) { - if ( str.length < 5 ) { - return 'small'; - } else if ( str.length > 5 ) { - return 'large'; - } else { - return 'medium'; - } - }; - console.log( stringSize( "cat" ) ); // 'small' - console.log( stringSize( "bell" ) ); // 'small' - console.log( stringSize( "ready" ) ); // 'medium' - console.log( stringSize( "shirt" ) ); // 'medium' - console.log( stringSize( "shallow" ) ); // 'large' - console.log( stringSize( "intelligence" ) ); // 'large' - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `stringsToLengths` that accepts an array of strings as an argument. The function - // should return a new array containing the lengths of the elements of the original array. - let stringsToLengths = function ( words ) { - let lengths = []; - for ( let i = 0; i < words.length; { - lengths.push( words[ i ].length ); - } - return lengths; - }; - console.log( stringsToLengths( [ "belly", "echo", "irony", "pickled" ] ) ); - // [5, 4, 5, 7] - console.log( stringsToLengths( [ "on", "off", "handmade" ] ) ); - // [2, 3, 8] - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function named `sumUpTo(max)` that accepts a max number as an argument. The function should - // return the total sum of all whole numbers from 1 to the max, inclusive. - // - // For example, sumUpTo(4) should return 10 because 1 + 2 + 3 + 4 = 10. - let sumUpTo = function ( max ) { - let sum = 0; - for ( let i = 1; i <= max; i++ ) { - sum += i - } - return sum; - }; - console.log( sumUpTo( 4 ) ); // 10 - console.log( sumUpTo( 5 ) ); // 15 - console.log( sumUpTo( 2 ) ); // 3 - console.log( 'coffee' ); - let qty = 15 % 4; - console.log( qty ); // 3 - let num = 38 + 3; - num++; - console.log( num + " is a great number" ); // '42 is a great number' - let isNumEven = num % 2 === 0; - console.log( num + " is even? " + isNumEven ); // '42 is even? true' - let isQtyEven = qty % 2 === 0; - console.log( qty + " is even? " + isQtyEven ); // '3 is even? false' - glet longStr = "AIICXAIBAAKBgQCuw0YyucjI9bf7yRhIkyg4Ru6kYU7O6fIn2JoFDzCZNkzDdsuXFGh6BXNvbu8uZUT289ERzYP1QjryMEKWzcbtsioyQApL7AgOZyFc3JJ7wvupHhIj2sqxJNtpAh7HQFG08rYh2Pb3HwOm83rbTomM6LnnjooGcoDeuWkuPqXsRlwIDAQABAoGAeQkbPBR5n9y2QLaEjcDGv7dVpFiMGHMaZZVDX34rZPy1EkZNZqlQU0jopLVvLyLESMh9A7gKhqoyMAbgZPpdb0CvniTJPpKYk24mLBeym8rBMW3XBmKk1xIOcJPGXMxeJW61jxPg6doah0aCIjf8n0Z8t8B81kLFojpECQQDzlCp0Nzka3AVZVPdBuuPg0fzeV8ugpiPEp6wQLjIMDFqYtGoAOEy4JpkmkK7zwsQsHZ8jbOtqIFdRLPrvAkEAruU321Ie1CnYCHX4Q79vLcDeWOUpdzEHp2uzDIfzP1gv7RIktGgSZWKhrnNWdeH4Y0CFb9lu6TQYJwNJvug2QJBANX0m3Uds9P9pLbQlI9WWmAtYqIZrsBElcAjOgAik0uOfawholNiw5B3ADvIYqPkLW4dGk1dO6zxW8ZF83MdMCQHGfhxLuFgsOBSfF7Bj4UX6T9FGhUGSXiqUsd06E2mMRLAjWUUUw82DLwucxMrSsV4z1aN57asC8YuQ9FkCQGirlVCt4ccXeGLCHcCsI8AYQJFRzbMs381M16jEpnaKUGrtdbMW018gWJ0EoD4tS2YZpr1hEbtiOkPJaaTKQ"; - if ( longStr.indexOf( 'coDe' ) > -1 ) { - console.log( 'FOUND' ); - } else { - console.log( 'NOT FOUND' ); - } - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `totalProduct(array)` that accepts a 2D array of numbers. The function should return - // the total product of all numbers in the array. - let totalProduct = function ( array ) { - let product = 1; - for ( let i = 0; i < array.length; { - let subarray = array[ i ]; - for ( let j = 0; j < subarray.length; { - product *= subarray[ j ]; - } - } - return product; - }; - let array1 = [ - [ 3, 5, 2 ], - [ 6, 2 ], - ]; console.log( totalProduct( array1 ) ); // 360 - let array2 = [ - [ 4, 6 ], - [ 2, 3 ], - [ 1, 2 ], - ]; console.log( totalProduct( array2 ) ); // 288 - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `total` that accepts an array of numbers as an argument. The function should return - // the total sum of all elements of the array. - let total = function ( numbers ) { - let sum = 0; - for ( let i = 0; i < numbers.length; { - sum += numbers[ i ]; - } - return sum; - }; - console.log( total( [ 3, 2, 8 ] ) ); // 13 - console.log( total( [ -5, 7, 4, 6 ] ) ); // 12 - console.log( total( [ 7 ] ) ); // 7 - console.log( total( [] ) ); // 0 - let apple; - console.log( apple ); // undefined - apple = 5; - console.log( apple ); // 5 - apple + 1; - console.log( apple ); // 5 - apple += 1; - console.log( apple ); // 6 - let banana = apple; - console.log( banana ); // 6 - banana = banana / 2; - console.log( banana ); // 3 - console.log( apple ); // 6 - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `twoSumPairs(numbers, target)` that accepts an array of numbers and a target number - // as arguments. The function should return a 2D array containing all unique pairs of elements that - // sum to the target. - let twoSumPairs = function ( numbers, target ) { - let pairs = []; - for ( let i = 0; i < numbers.length; { - let num1 = numbers[ i ]; - for ( let j = i + 1; j < numbers.length; { - let num2 = numbers[ j ]; - if ( num1 + num2 === target ) { - let pair = [ num1, num2 ]; - pairs.push( pair ); - } - } - } - return pairs; - }; console.log( twoSumPairs( [ 2, 3, 4, 6, 5 ], 8 ) ); // [ [2, 6], [3, 5] ] - console.log( twoSumPairs( [ 10, 7, 4, 5, 2 ], 12 ) ); // [ [10, 2], [7, 5] ] - console.log( twoSumPairs( [ 3, 9, 8 ], 11 ) ); // [ [3, 8] ] - console.log( twoSumPairs( [ 3, 9, 8 ], 10 ) ); // [ ] - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `twoSum(numbers, target)` that accepts an array of numbers and a target number - // as an argument. The function should return a boolean indicating whether or not there exists a pair - // of distinct elements in the array that sum to the target. - let twoSum = function ( numbers, target ) { - for ( let i = 0; i < numbers.length; { - for ( let j = i + 1; j < numbers.length; { - if ( numbers[ i ] + numbers[ j ] === target ) { - return true; - } - } - } - return false; - }; console.log( twoSum( [ 2, 3, 5, 9 ], 7 ) ); // true - console.log( twoSum( [ 2, 3, 5, 9 ], 4 ) ); // false - console.log( twoSum( [ 6, 3, 4 ], 10 ) ); // true - console.log( twoSum( [ 6, 5, 1 ], 10 ) ); // false - // snippet 2-1 - let nonsense = "blog trust fund tattooed williamsburg poke roof party"; - let hasOk = nonsense.indexOf( "ok" ) > -1; - if ( hasOk ) { - console.log( "yeet" ); // prints - } else if ( nonsense.length > 10 ) { - console.log( "yo" ); - } else { - console.log( "no" ); - } - let hasZoo = nonsense.indexOf( "zoo" ) > -1; - let hasFun = nonsense.indexOf( "fun" ) > -1; - if ( hasZoo && hasOk ) { - console.log( "cool" ); - } else if ( hasOk ) { - console.log( "rad" ); // prints - } else if ( hasFun ) { - console.log( "dope" ); - } else { - console.log( "nope" ); - } - // snippet 2-2 - let q = 25; - if ( q % 3 === 0 && q % 5 === 0 ) { - console.log( "both" ); - } else if ( q % 3 === 0 || q % 5 == 0 ) { - console.log( "either" ); // prints - } else { - console.log( "neither" ); - } - let r = 9; - if ( r % 3 === 0 && r % 5 === 0 ) { - console.log( "both" ); - } else if ( r % 3 === 0 || r % 5 == 0 ) { - console.log( "either" ); // prints - } else { - console.log( "neither" ); - } - let s = 15; - if ( s % 3 === 0 && s % 5 === 0 ) { - console.log( "both" ); // prints - } else if ( s % 3 === 0 || s % 5 == 0 ) { - console.log( "either" ); - } else { - console.log( "neither" ); - } - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `wackyWord` that accepts two strings as arguments. The function should return a new - // string containing the first three characters of the first string concatenated with the last two - // character of the second string. - // You can assume that the first argument has a length of at least three and the second argument has a - // length of at least two. - let wackyWord = function ( str1, str2 ) { - return str1.slice( 0, 3 ) + str2.slice( -2 ); - }; console.log( wackyWord( "very", "kindly" ) ); // 'verly' - console.log( wackyWord( "forever", "sick" ) ); // 'forck' - console.log( wackyWord( "cellar", "door" ) ); // 'celor' - console.log( wackyWord( "bagel", "sweep" ) ); // 'bagep' - console.log( 'alvin' ); console.log( 'z' ); - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `wordCount(sentence, targetWords)` that accepts a sentence string and an array of - // `targetWords`. The function should return a count of the number of words of the sentence that are - // in `targetWords`. - let wordCount = function ( sentence, targetWords ) { - let words = sentence.split( ' ' ); - let count = 0; - for ( let i = 0; i < words.length; { - let word = words[ i ]; - if ( targetWords.includes( word ) ) { - count++; - } - } - return count; - }; - console.log( wordCount( "open the window please", [ "please", "open", "sorry" ] ) ); // 2 - console.log( wordCount( "drive to the cinema", [ "the", "driver" ] ) ); // 1 - console.log( wordCount( "can I have that can", [ "can", "I" ] ) ); // 3 - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `yourAverageFunction` that accepts an array of numbers as an argument. The - // function should return the average of all elements of the array. If the input array is empty, - // then the function should return null. - let yourAverageFunction = function ( nums ) { - if ( nums.length === 0 ) { - return null; - } - let sum = 0; - for ( let i = 0; i < nums.length; { - sum += nums[ i ]; - } - return sum / nums.length; - }; - console.log( yourAverageFunction( [ 5, 2, 7, 24 ] ) ); // 9.5 - console.log( yourAverageFunction( [ 100, 6 ] ) ); // 53 - console.log( yourAverageFunction( [ 31, 32, 40, 12, 33 ] ) ); // 29.6 - console.log( yourAverageFunction( [] ) ); // null - let location = "Brooklyn, " + "NY"; - console.log( location ); // 'Brooklyn, NY' - let quantity = 4 * 5 + 1; - console.log( quantity ); // 21 - g it // snippet 0-1 - if ( true ) { - console.log( "foo" ); // prints - } - if ( false ) { - console.log( "bar" ); - } - // snippet 0-2 - if ( false || false ) { - console.log( "boop" ); - } - if ( true || false ) { - console.log( "beep" ); // prints - } - // snippet 0-3 - let num = 40; - if ( num > 0 ) { - console.log( "zip" ); // prints - } - if ( num % 2 === 0 ) { - console.log( "zoop" ); // prints - } - // snippet 0-4 - let word = "jeep"; - if ( word[ 0 ] === "d" ) { - console.log( "yer" ); - } else { - console.log( "nah" ); // prints - } - // snippet 0-5 - let sentence = "roger that"; - if ( sentence[ sentence.length - 1 ] === "t" ) { - console.log( "ends in t" ); // prints - } else { - console.log( "does not end in t" ); - } - if ( sentence.length <= 4 ) { - console.log( "short" ); - } else { - console.log( "long" ); // prints - } - //--- --------------------------------------------------------------------------------> - //---------------------------------------(NEXT:)-------------------------------------> - //--- --------------------------------------------------------------------------------> - // Write a function `zipper` that accepts two arrays as arguments. The function should return a 2D - // array containing pairs of elements at the same indices. - let zipper = function ( arr1, arr2 ) { - let result = []; - for ( let i = 0; i < arr1.length; { - let el1 = arr1[ i ]; - let el2 = arr2[ i ]; - let pair = [ el1, el2 ]; - result.push( pair ); - } - return result; - }; - let array1 = [ "a", "b", "c", "d" ]; - let array2 = [ -1, -2, -3, -4 ]; - console.log( zipper( array1, array2 ) ); - // [ - // ['a', -1], - // ['b', -2], - // ['c', -3], - // ['d', -4], - // ] - let array3 = [ "whisper", "talk", "shout" ]; - let array4 = [ "quiet", "normal", "loud" ]; - console.log( zipper( array3, array4 ) ); - // [ - // ['whisper', 'quiet'], - // ['talk', 'normal'], - // ['shout', 'loud'], - // ] -let str = 'MIICWwIBAAKBgGEdLjFEFbegPZ2AwJWkalksXr7PzWL7wIc7pOFZxXwYPWtQxvANyceCwpkqbPLsfEx7nqxAris2hYOdeN1OTFqvTyNmVuzbUPcXShn6ZoDCB30voHkeu4F3cUw5RQEUDdLscSnv4HMxHam5qgl6vXoumVNHbjyKA5UtAnfjAgMBAAECgYAmjEyvpZTxRJvwjxDi1VaZevFI0Hd4WPH9PAGgqdnH84vGXnAGFj1WikqKYcqKMQW2kdjAsWwH9D9FfrkIcDDHdZ9XuGSGkFzWtOwajWMQl7qNV1hZ288gdpIQQMOTLDgauZY6pw1cV7h4v316qJB8knQGoBNpJCfTYQJBAKV1ctsJq0Zg4QumD2hyODepP3LfLeaQsERLqVAWeuOuTY5mK5gIwsSqvcSVfY7Ze1FWIsApNFRv67azKcJPwsCQQCNlyApZFJEVNY70Er7Uu5NL9t4CYJJC9uVVkoEHEY6d7sVslqa0vP2q0zXx9YedbMBvQjxXIbY0waXUy63FvoBGJAkB3OTJWUjVgzDY1Br5wu2Yu59NjKVKLWzCsu1gaCNBfhVDX7SyIyC9EYKRfUAoQxwsmPWPyQ9QVG4WKcPZJAkBRheAotPCBE2RLHHfvpiStnMhX0UXdVyaJp5tcZ6wYV61ohyBvCOkYhUxBJzeIGrVZcvLZSLeUzXoqRPpxQxAkEAkdCZXF0gHahpZgF5y0wWcqf9ECRT1E4Hv8bk3Mf0Exp2aW34JeI6I7Xqd1NV4I9H7prQ8m3y39lFwWO8PmQ'; - -console.log( str.indexOf( 'HEY' ) ); -console.log( 0 ); -// Write a function `alternatingCaps` that accepts a sentence string as an argument. The function should -// return the sentence where words alternate between lowercase and uppercase. - -let alternatingCaps = function ( sentence ) { - let words = sentence.split( ' ' ); - let newWords = []; - - for ( let i = 0; i < words.length; i++ ) { - let word = words[ i ]; - if ( i % 2 === 0 ) { - newWords.push( word.toLowerCase() ); - } else { - newWords.push( word.toUpperCase() ); - } - } - - return newWords.join( ' ' ); -}; - -console.log( alternatingCaps( "take them to school" ) ); // 'take THEM to SCHOOL' -console.log( alternatingCaps( "What did ThEy EAT before?" ) ); // 'what DID they EAT before?' -//APPEND-DIR.js -const fs = require( 'fs' ); -let cat = require( 'child_process' ).execSync( 'cat *' ).toString( 'UTF-8' ); - -fs.writeFile( 'output.md', cat, ( err ) => { - if ( err ) throw err; -} ); -git // Write a function `averageOfFour(num1, num2, num3, num4)` that accepts four numbers as arguments. The -// function should return the average of all four numbers. - -let averageOfFour = function ( num1, num2, num3, num4 ) { - let sum = num1 + num2 + num3 + num4; - return sum / 4; -}; - -console.log( averageOfFour( 10, 4, 12, 3 ) ); // 7.25 -console.log( averageOfFour( -20, 50, 4, 21 ) ); // 13.75 -console.log( averageOfFour( 10, 4, 12, 3 ) ); // 7.25 -console.log( averageOfFour( 5, 5, 3, 7 ) ); // 5 -// Write a function `average` that accepts three numbers as arguments. The function should return the -// average of the three numbers. - -let average = function ( num1, num2, num3 ) { - return ( num1 + num2 + num3 ) / 3; -}; - -console.log( average( 3, 10, 8 ) ); // 7 -console.log( average( 10, 5, 12 ) ); // 9 -console.log( average( 6, 20, 40 ) ); // 22 -// Write a function `bleepVowels` that accepts a string as an argument. The function should return -// a new string where all vowels are replaced with `*`s. Vowels are the letters a, e, i, o, u. - -let bleepVowels = function ( str ) { - let vowels = [ "a", "e", "i", "o", "u" ]; - let bleeped = ""; - - for ( let i = 0; i < str.length; i++ ) { - let char = str[ i ]; - - if ( vowels.indexOf( char ) > -1 ) { - bleeped += "*"; - } else { - bleeped += char; - } - } - - return bleeped; -}; - -console.log( bleepVowels( "skateboard" ) ); // 'sk*t*b**rd' -console.log( bleepVowels( "slipper" ) ); // 'sl*pp*r' -console.log( bleepVowels( "range" ) ); // 'r*ng*' -console.log( bleepVowels( "brisk morning" ) ); // 'br*sk m*rn*ng' -console.log( false ); // false -console.log( !true ); // false -console.log( !false ); // true -console.log( !!true ); // true - -console.log( false && false ); // false -console.log( false && true ); // false -console.log( true && false ); // false -console.log( true && true ); // true - -console.log( false || false ); // false -console.log( false || true ); // true -console.log( true || false ); // true -console.log( true || true ); // true - -console.log( !false || false ); // true -console.log( false || ( true && true ) ); // true -console.log( false || !( true && true ) ); // false -console.log( !true && ( true ) ); // false -// Write a function `caseChange` that accepts a string and a boolean as arguments. The function should -// return the uppercase version of the string if the boolean is true. The function should return the -// lowercase version of the string if the boolean is false. - -let caseChange = function ( str, shouldUpperCase ) { - if ( shouldUpperCase ) { - return str.toUpperCase(); - } else { - return str.toLowerCase(); - } -}; - -console.log( caseChange( "Super", true ) ); // 'SUPER' -console.log( caseChange( "Super", false ) ); // 'super' -console.log( caseChange( "tAmBourine", true ) ); // 'TAMBOURINE' -console.log( caseChange( "tAmBourine", false ) ); // 'tambourine' -// Write a function `censorE` that accepts a string as an argument. The function should return the a new -// version of string where all characters that are 'e's are replaced with '*'s. - -let censorE = function ( str ) { - let newStr = ''; - - for ( let i = 0; i < str.length; i++ ) { - let char = str[ i ]; - - if ( char === 'e' ) { - newStr += '*'; - } else { - newStr += char; - } - } - - return newStr; -}; - -console.log( censorE( "speedy" ) ); // 'sp**dy' -console.log( censorE( "pending" ) ); // 'p*nding' -console.log( censorE( "scene" ) ); // 'sc*n*' -console.log( censorE( "heat" ) ); // 'h*at' -// Write a function `chooseDivisibles(numbers, target)` that accepts an array of numbers and a -// target number as arguments. The function should return an array containing elements of the original -// array that are divisible by the target. - -let chooseDivisibles = function ( numbers, target ) { - let divisibles = []; - - for ( let i = 0; i < numbers.length; i++ ) { - let num = numbers[ i ]; - - if ( num % target === 0 ) { - divisibles.push( num ); - } - } - - return divisibles; -}; - -console.log( chooseDivisibles( [ 40, 7, 22, 20, 24 ], 4 ) ); // [40, 20, 24] -console.log( chooseDivisibles( [ 9, 33, 8, 17 ], 3 ) ); // [9, 33] -console.log( chooseDivisibles( [ 4, 25, 1000 ], 10 ) ); // [1000] -// Write a function `commonElements` that accepts two arrays as arguments. The function should return -// a new array containing the elements that are found in both of the input arrays. The order of -// the elements in the output array doesn't matter as long as the function returns the correct elements. - -let commonElements = function ( array1, array2 ) { - let common = []; - - for ( let i = 0; i < array1.length; i++ ) { - let ele = array1[ i ]; - - if ( array2.includes( ele ) ) { - common.push( ele ); - } - } - - return common; -}; - -let arr1 = [ "a", "c", "d", "b" ]; -let arr2 = [ "b", "a", "y" ]; -console.log( commonElements( arr1, arr2 ) ); // ['a', 'b'] - -let arr3 = [ 4, 7 ]; -let arr4 = [ 32, 7, 1, 4 ]; -console.log( commonElements( arr3, arr4 ) ); // [4, 7] -console.log( true === false ); // false -console.log( false === false ); // true -console.log( false !== true ); // true -console.log( !true === false ); // true - -console.log( 2 + 3 === 5 ); // true -console.log( 4 < 0 ); // false -console.log( 10 >= 10 ); // true -console.log( 10.3 >= 10 ); // true - -console.log( 100 / 2 === 50 ); // true -console.log( 100 % 2 === 0 ); // true -console.log( 11 % 2 === 0 ); // false -console.log( 7.0 === 7 ); // true - -console.log( 13 % 5 > 0 ); // true -console.log( "potato" === "potato" ); // true -console.log( "Tomato" === "tomato" ); // false -console.log( "42" === 42 ); // false -console.log( 5 > 3 && 1 === 0 ); // false -t // Write a function `contains(str1, str2)` that accepts two strings as arguments. The function should -// return a boolean indicating whether or not `str2` is contained within `str1`. The function should -// ignore any differences in capitalization. - -let contains = function ( str1, str2 ) { - let lowerStr1 = str1.toLowerCase(); - let lowerStr2 = str2.toLowerCase(); - return lowerStr1.indexOf( lowerStr2 ) > -1; -}; - -console.log( contains( "caterpillar", "pill" ) ); // true -console.log( contains( "lion's share", "on" ) ); // true -console.log( contains( "SORRY", "or" ) ); // true -console.log( contains( "tangent", "gem" ) ); // false -console.log( contains( "clock", "ok" ) ); // false -// Write a function `countUp(max)` that accepts a max number as an argument. The function should print -// all numbers from 1 up to and including the max. The function doesn't need to return any value. It -// should just print to the terminal. - -let countUp = function ( max ) { - for ( let i = 1; i <= max; i++ ) { - console.log( i ); - } -}; - -countUp( 5 ); -// prints -// 1 -// 2 -// 3 -// 4 -// 5 - -countUp( 3 ); -// prints -// 1 -// 2 -// 3 -let phrase = "that's all folks"; -console.log( phrase[ phrase.length ] ); // undefined -console.log( phrase[ phrase.length - 1 ] ); // s -console.log( phrase[ phrase.length - 2 ] ); // k - -const i = 9; -const char = phrase[ i ]; -console.log( char ); // l -console.log( phrase.indexOf( char ) ); // 8 -console.log( phrase.slice( 2, 8 ) ); // at's a - -console.log( "abcdefg".slice( 1, 3 ) ); // bc -console.log( "abcdefg".slice( 2 ) ); // cdefg -console.log( "abcdefg".slice( 4 ) ); // efg - - -console.log( "abcdefg".slice( 2, -1 ) ); // cdef -console.log( "abcdefg".slice( 2, -2 ) ); // cde -// Write a function named `divByEither(num1, num2, max)` that accepts three numbers as arguments. -// The function should print out all positive numbers less than max that are divisible by num1 or num2. -// The function doesn't need to return any value. It should just print to the terminal. - -let divByEither = function ( num1, num2, max ) { - for ( let i = 1; i < max; i++ ) { - if ( i % num1 === 0 || i % num2 === 0 ) { - console.log( i ); - } - } -}; - -divByEither( 4, 3, 16 ); -// prints -// 3 -// 4 -// 6 -// 8 -// 9 -// 12 -// 15 - -divByEither( 7, 5, 20 ); -// prints -// 5 -// 7 -// 10 -// 14 -// 15 -// Write a function `divisibleRange(min, max, num)` that accepts three numbers as arguments. The -// function should print all numbers between `min` and `max` (exclusive) that are also divisible by -// num. - -let divisibleRange = function ( min, max, num ) { - for ( let i = min + 1; i < max; i++ ) { - if ( i % num === 0 ) { - console.log( i ); - } - } -}; - -divisibleRange( 17, 40, 9 ); -// prints -// 18 -// 27 -// 36 - -divisibleRange( 10, 24, 4 ); -// prints -// 12 -// 16 -// 20 -// Write a function `divisible(num1, num2)` that accepts two numbers as arguments. The function should -// return a boolean indicating whether or not `num1` is divisible by `num2`. - -let divisible = function ( num1, num2 ) { - return num1 % num2 === 0; -}; - -// let divisible = function (num1, num2) { -// if (num1 % num2 === 0) { -// return true; -// } else { -// return false; -// } -// }; - -console.log( divisible( 12, 3 ) ); // true -console.log( divisible( 12, 5 ) ); // false -console.log( divisible( 60, 4 ) ); // true -console.log( divisible( 60, 11 ) ); // false -console.log( divisible( 21, 7 ) ); // true -console.log( divisible( 21, 6 ) ); // false -// Write a function `divisors` that accepts a number as an argument. The function should return an -// array containing all positive numbers that can divide into the argument. - -let divisors = function ( n ) { - let numbers = []; - - for ( let i = 1; i <= n; i++ ) { - if ( n % i === 0 ) { - numbers.push( i ); - } - } - - return numbers; -}; - -console.log( divisors( 15 ) ); // [1, 3, 5, 15] -console.log( divisors( 7 ) ); // [1, 7] -console.log( divisors( 24 ) ); // [1, 2, 3, 4, 6, 8, 12, 24] -g // Write a function `endsInLy` that accepts a string as an argument and returns a boolean indicating -// whether or not the string ends in the substring 'ly'. - -let endsInLy = function ( str ) { - let secondLast = str[ str.length - 2 ]; - let last = str[ str.length - 1 ]; - - return secondLast === 'l' && last === 'y'; -}; - -// let endsInLy = function (str) { -// return str.endsWith('ly'); -// }; - -console.log( endsInLy( "pretty" ) ); // false -console.log( endsInLy( "instant" ) ); // false -console.log( endsInLy( "analytic" ) ); // false -console.log( endsInLy( "timidly" ) ); // true -console.log( endsInLy( "fly" ) ); // true -console.log( endsInLy( "gallantly" ) ); // true -// Write a function `endsWithT` that accepts a string as an argument. The function should return a -// boolean indicating whether or not the string ends with the character 't'. - -let endsWithT = function ( str ) { - let lastChar = str[ str.length - 1 ]; - return lastChar === 't'; -}; - - -console.log( endsWithT( "smart" ) ); // true -console.log( endsWithT( "racket" ) ); // true -console.log( endsWithT( "taco" ) ); // false -console.log( endsWithT( "boomerang" ) ); // false -// Write a function `evens(max)` that accepts a max number as an argument. The function should print -// all positive even numbers that are less than the max. - -let evens = function ( max ) { - for ( let i = 1; i < max; i++ ) { - if ( i % 2 === 0 ) { - console.log( i ); - } - } -}; - -evens( 11 ); -// prints -// 2 -// 4 -// 6 -// 8 -// 10 - -evens( 8 ); -// prints -// 2 -// 4 -// 6 -// Write a function `filterLongWords` that accepts an array of strings as an argument. The function -// should return a new array containing only the strings that are less than 5 characters long. - -let filterLongWords = function ( words ) { - let chosenWords = []; - - for ( let i = 0; i < words.length; i++ ) { - let word = words[ i ]; - - if ( word.length < 5 ) { - chosenWords.push( word ); - } - } - - return chosenWords; -}; - -console.log( filterLongWords( [ "kale", "cat", "retro", "axe", "heirloom" ] ) ); -// ['kale', 'cat', 'axe'] - -console.log( filterLongWords( [ "disrupt", "pour", "trade", "pic" ] ) ); -// ['pour', 'pic'] -// Write a function named `fiveMultiplesOf` that accepts a number as an argument. The function should -// print out the first five multiples of the given number. The function doesn't need to return any -// value. It should just print to the terminal. - -let fiveMultiplesOf = function ( num ) { - for ( let i = 1; i <= 5; i++ ) { - console.log( i * num ); - } -}; - -fiveMultiplesOf( 7 ); -// prints -// 7 -// 14 -// 21 -// 28 -// 35 - -fiveMultiplesOf( 3 ); -// prints -// 3 -// 6 -// 9 -// 12 -// 15 -// Write a function `fizzBuzz` that accepts a max number as an argument. The function should -// print all numbers less than or equal to max that are divisible by either 3 or 5 but not both 3 -// and 5. The function doesn't need to return any value. It should just print to the terminal. - -let fizzBuzz = function ( max ) { - for ( let i = 1; i <= max; i++ ) { - if ( ( i % 3 === 0 || i % 5 === 0 ) && !( i % 3 === 0 && i % 5 === 0 ) ) { - console.log( i ); - } - } -}; - -fizzBuzz( 18 ); -// prints -// 3 -// 5 -// 6 -// 9 -// 10 -// 12 -// 18 - -fizzBuzz( 33 ); -// prints -// 3 -// 5 -// 6 -// 9 -// 10 -// 12 -// 18 -// 20 -// 21 -// 24 -// 25 -// 27 -// 33 -let movie = 'Fight Club'; - -let views = 4; - -console.log( 'I watched ' + movie + ' about ' + views + ' number of times' ); -// Write a function `funnySound` that accepts two strings as arguments. The function should return a -// new string containing the first three characters of both strings concatenated together. - -// You can assume that the arguments are both at least three characters long. - -let funnySound = function ( str1, str2 ) { - return str1.slice( 0, 3 ) + str2.slice( 0, 3 ); -}; - -console.log( funnySound( "tiger", "spoon" ) ); // 'tigspo' -console.log( funnySound( "computer", "phone" ) ); // 'compho' -console.log( funnySound( "skate", "bottle" ) ); // 'skabot' -console.log( funnySound( "frog", "ashtray" ) ); // 'froash' -console.log( 'hello world' ); -// Write a function `half` that accepts a number as an argument. The function should return half of the -// number. - -let half = function ( n ) { - return n / 2; -}; - -console.log( half( 8 ) ); // 4 -console.log( half( 15 ) ); // 7.5 -console.log( half( 90 ) ); // 45 -gi // Write a function `inRange(min, max, n)` that accepts three numbers as arguments. The function should -// return a boolean indicating if `n` is between `min` and `max` inclusive. - -let inRange = function ( min, max, n ) { - return n >= min && n <= max; -}; - -console.log( inRange( 5, 13, 8 ) ); // true -console.log( inRange( 5, 13, 29 ) ); // false -console.log( inRange( 100, 125, 100 ) ); // true -console.log( inRange( 100, 125, 99 ) ); // false -console.log( inRange( 40, 45, 44 ) ); // true -console.log( inRange( 40, 45, 45 ) ); // true -console.log( inRange( 40, 45, 46 ) ); // false -// Write a function `isDivBy4` that accepts a number as an argument. The function should return a -// boolean indicating whether or not the number is divisible by 4. - -let isDivBy4 = function ( num ) { - if ( num % 4 === 0 ) { - return true; - } else { - return false; - } -}; - -// let isDivBy4 = function (num) { -// return num % 4 === 0; -// }; - -console.log( isDivBy4( 8 ) ); // true -console.log( isDivBy4( 12 ) ); // true -console.log( isDivBy4( 24 ) ); // true -console.log( isDivBy4( 9 ) ); // false -console.log( isDivBy4( 10 ) ); // false -// Write a function `isLong` that accepts a string as an argument. The function should return a boolean -// indicating whether or not the string is longer than 5 characters - -let isLong = function ( str ) { - return str.length > 5; -}; - -// let isLong = function (str) { -// if (str.length > 5) { -// return true; -// } else { -// return false; -// } -// }; - -console.log( isLong( "pie" ) ); // false -console.log( isLong( "kite" ) ); // false -console.log( isLong( "kitty" ) ); // false -console.log( isLong( "telescope" ) ); // true -console.log( isLong( "thermometer" ) ); // true -console.log( isLong( "restaurant" ) ); // true -// Write a function `keepItQuiet` that accepts a string as an argument. The function should return the -// lowercase version of the string with 3 periods added to the end of it. - -let keepItQuiet = function ( str ) { - return str.toLowerCase() + '...'; -}; - -console.log( keepItQuiet( "HOORAY" ) ); // 'hooray...' -console.log( keepItQuiet( "Doggo" ) ); // 'doggo...' -console.log( keepItQuiet( "WHAT?!?!" ) ); // 'what?!?!...' -// Write a function `larger` that accepts two numbers as arguments. The function should return the -// larger number. - -let larger = function ( num1, num2 ) { - if ( num1 > num2 ) { - return num1; - } else { - return num2; - } -}; - -console.log( larger( 256, 400 ) ); // 400 -console.log( larger( 31, 4 ) ); // 31 -console.log( larger( -6, 7 ) ); // 7 -console.log( larger( 11.3, 11.2 ) ); // 11.3 -console.log( larger( -10, -3 ) ); // -3 -// Write a function `lengthiestWord` that accepts a sentence string as an argument. The function should -// return the longest word of the sentence. If there is a tie, return the word that appears later -// in the sentence. - -let lengthiestWord = function ( sentence ) { - let words = sentence.split( ' ' ); - let longest = words[ 0 ]; // pretty - - for ( let i = 1; i < words.length; i++ ) { - let word = words[ i ]; - if ( word.length >= longest.length ) { - longest = word; - } - } - - return longest; -}; - - -console.log( lengthiestWord( "I am pretty hungry" ) ); // 'hungry' -console.log( lengthiestWord( "we should think outside of the box" ) ); // 'outside' -console.log( lengthiestWord( "down the rabbit hole" ) ); // 'rabbit' -console.log( lengthiestWord( "simmer down" ) ); // 'simmer' -// Write a function `longer` that accepts two strings as arguments. The function should return the -// string that is longer. If the strings have the same length, then return the first string. - -let longer = function ( str1, str2 ) { - if ( str1.length >= str2.length ) { - return str1; - } else { - return str2; - } -}; - -console.log( longer( "drum", "piranha" ) ); // 'piranha' -console.log( longer( "basket", "fork" ) ); // 'basket' -console.log( longer( "flannel", "sustainable" ) ); // 'sustainable' -console.log( longer( "disrupt", "ability" ) ); // 'disrupt' -console.log( longer( "bird", "shoe" ) ); // 'bird' -// Write a function `makeAcronym` that accepts a sentence string as an argument. The function should -// return a string containing the first character of each word in the sentence. - -let makeAcronym = function ( sentence ) { - let words = sentence.split( ' ' ); - let acronym = ''; - - for ( let i = 0; i < words.length; i++ ) { - let word = words[ i ]; - acronym += word[ 0 ]; - } - - return acronym.toUpperCase(); -}; - -console.log( makeAcronym( "New York" ) ); // NY -console.log( makeAcronym( "same stuff different day" ) ); // SSDD -console.log( makeAcronym( "Laugh out loud" ) ); // LOL -console.log( makeAcronym( "don't over think stuff" ) ); // DOTS -// Write a function `makeMatrix(m, n, value)` that accepts three arguments. The function should return -// a 2-dimensional array of height `m` and width `n` that contains the `value` as every element. - -let makeMatrix = function ( m, n, value ) { - let matrix = []; - - for ( let i = 0; i < m; i++ ) { - let row = []; - - for ( let j = 0; j < n; j++ ) { - row.push( value ); - } - - matrix.push( row ); - } - - - return matrix; -}; - -console.log( makeMatrix( 3, 5, null ) ); -// [ -// [ null, null, null, null, null ], -// [ null, null, null, null, null ], -// [ null, null, null, null, null ] -// ] - -console.log( makeMatrix( 4, 2, "x" ) ); -// [ -// [ 'x', 'x' ], -// [ 'x', 'x' ], -// [ 'x', 'x' ], -// [ 'x', 'x' ] -// ] - -console.log( makeMatrix( 2, 2, 0 ) ); -// [ -// [ 0, 0 ], -// [ 0, 0 ] -// ] -// Write a function `maximum` that accepts an array of numbers as an argument. The function should -// return the largest number of the array. If the array is empty, then the function should return null. - -let maximum = function ( numbers ) { - if ( numbers.length === 0 ) { - return null; - } - - let currentMax = numbers[ 0 ]; - for ( let i = 1; i < numbers.length; i++ ) { - if ( numbers[ i ] > currentMax ) { - currentMax = numbers[ i ]; - } - } - - return currentMax; -}; - -console.log( maximum( [ 5, 6, 3, 7 ] ) ); // 7 -console.log( maximum( [ 17, 15, 19, 11, 2 ] ) ); // 19 -console.log( maximum( [] ) ); // null -// Write a function `minToMax(min, max)` that accepts two numbers as arguments. The function should -// print all numbers from min to max inclusive. The function doesn't need to return any value. It -// should just print to the terminal. - - -let minToMax = function ( min, max ) { - for ( let i = min; i <= max; i++ ) { - console.log( i ); - } -}; - -minToMax( 5, 9 ); -// prints -// 5 -// 6 -// 7 -// 8 -// 9 - -minToMax( 11, 13 ); -// prints -// 11 -// 12 -// 13 -// Write a function named `noOhs` that accepts a string as an argument. The functions should print the -// characters of the string one by one except the character 'o'. The function doesn't need to return -// any value. It should just print to the terminal. - -let noOhs = function ( str ) { - for ( let i = 0; i < str.length; i++ ) { - let char = str[ i ]; - if ( char !== 'o' ) { - console.log( char ); - } - } -}; - -noOhs( "code" ); -// prints -// c -// d -// e - -noOhs( "school" ); -// prints -// s -// c -// h -// l -// Write a function `numOdds` that accepts an array of numbers as an argument. The function should -// return a number representing the count of odd elements in the array. - -let numOdds = function ( numbers ) { - let count = 0; - - for ( let i = 0; i < numbers.length; i++ ) { - if ( numbers[ i ] % 2 === 1 ) { - count += 1; - } - } - - return count; -}; - -console.log( numOdds( [ 4, 7, 2, 5, 9 ] ) ); // 3 -console.log( numOdds( [ 11, 31, 58, 99, 21, 60 ] ) ); // 4 -console.log( numOdds( [ 100, 40, 4 ] ) ); // 0 -// Write a function `numberChange` that accepts a number as an argument. The function should return -// half the number if it is even. The function should return double the number if it is odd. - -let numberChange = function ( n ) { - if ( n % 2 === 0 ) { - return n / 2; - } else { - return n * 2; - } -}; - -console.log( numberChange( 6 ) ); // 3 -console.log( numberChange( 7 ) ); // 14 -console.log( numberChange( 16 ) ); // 8 -console.log( numberChange( 21 ) ); // 42 -console.log( 2 + 3 ); // 5 -console.log( 10 - 15 ); // -5 -console.log( 4 + 1 - 5 ); // 0 -console.log( 4 * 3 ); // 12 - -console.log( 7 / 2 ); // 3.5 -console.log( 4 + 2 * 3 ); // 10 -console.log( ( 4 + 2 ) * 3 ); // 18 -console.log( 5 % 2 ); // 1 - -console.log( 6 % 2 ); // 0 -console.log( 7 % 2 ); // 1 -console.log( 8 % 2 ); // 0 -console.log( 19 % 8 ); // 3 - -console.log( 24 % 8 ); // 0 -console.log( 7 % 4 ); // 3 -console.log( 4 % 7 ); // 4 -console.log( 5 + ( 10 % 5 ) ); // 5 -console.log( ( 5 + 10 ) % 5 ); // 0 -// Write a function `numberRange(min, max, step)` that accepts three numbers as arguments, `min`, -// `max`, and `step`. The function should return all numbers between `min` and `max` at `step` intervals. -// `min` and `max` are inclusive. - -let numberRange = function ( min, max, step ) { - let range = []; - - for ( let i = min; i <= max; i += step ) { - range.push( i ); - } - - return range; -}; - -console.log( numberRange( 10, 40, 5 ) ); // [10, 15, 20, 25, 30, 35, 40] -console.log( numberRange( 14, 24, 3 ) ); // [14, 17, 20, 23] -console.log( numberRange( 8, 35, 6 ) ); // [8, 14, 20, 26, 32] -// Write a function named `oddSum(max)` that accepts a max number as an argument. The function should -// return the total sum of all odd numbers from 1 to the max, inclusive. -// -// For example, oddSum(10) should return 25 because 1 + 3 + 5 + 7 + 9 = 25 - -let oddSum = function ( max ) { - let sum = 0; - - for ( let i = 1; i <= max; i++ ) { - if ( i % 2 === 1 ) { - sum += i; - } - } - - return sum; -}; - -console.log( oddSum( 10 ) ); // 25 -console.log( oddSum( 5 ) ); // 9 -let word = "bye"; -console.log( `${word} felicia` ); // 'bye felicia' -console.log( word ); // 'bye' - -let num = 10; -num = num * 2; -console.log( num ); // 20 - -let bottlesOfBeer = 99; -let around = bottlesOfBeer - 1; -console.log( around ); // 98 -console.log( bottlesOfBeer ); // 99 -// Write a function `oneOrNone` that accepts two booleans as arguments. The function should return true -// if exactly one of the arguments is true. If BOTH arguments are true, then it should return false. - -let oneOrNone = function ( val1, val2 ) { - if ( ( val1 || val2 ) && !( val1 && val2 ) ) { - return true; - } else { - return false; - } -}; - -console.log( oneOrNone( false, false ) ); // false -console.log( oneOrNone( true, false ) ); // true -console.log( oneOrNone( false, true ) ); // true -console.log( oneOrNone( true, true ) ); // false -// Write a function `oneToFour` that prints all whole numbers from one to four, inclusive. The function -// takes in no arguments and doesn't need to return any value. It should just print to the terminal. - -let oneToFour = function () { - for ( let i = 1; i <= 4; i++ ) { - console.log( i ); - } -}; - - -oneToFour(); -// prints -// 1 -// 2 -// 3 -// 4 -let word = "bye"; -console.log( word + " felicia" ); // 'bye felicia' -console.log( word ); // 'bye' - -let num = 10; -num = num * 2; -console.log( num ); // 20 - -let bottlesOfBeer = 99; -let around = bottlesOfBeer - 1; -console.log( around ); // 98 -console.log( bottlesOfBeer ); // 99 -// Write a function `pairPrint` that accepts an array as an argument. The function should print -// all unique pairs of elements in the array. The function doesn't need to return any value. It -// should just print to the terminal. - -let pairPrint = function ( array ) { - for ( let i = 0; i < array.length; i++ ) { - for ( let j = i + 1; j < array.length; j++ ) { - console.log( array[ i ] + ' - ' + array[ j ] ); - } - } -}; - -pairPrint( [ "artichoke", "broccoli", "carrot", "daikon" ] ); -// prints -// artichoke - broccoli -// artichoke - carrot -// artichoke - daikon -// broccoli - carrot -// broccoli - daikon -// carrot - daikon - -pairPrint( [ "apple", "banana", "clementine" ] ); -// prints -// apple - banana -// apple - clementine -// banana - clementine -// Write a function `parity` that accepts a number as an argument. The function should return the -// string 'even' if the number is even. It should return the string 'odd' if the number is odd. - -let parity = function ( num ) { - if ( num % 2 === 0 ) { - return 'even'; - } else { - return 'odd'; - } -}; - -console.log( parity( 5 ) ); // 'odd' -console.log( parity( 7 ) ); // 'odd' -console.log( parity( 13 ) ); // 'odd' -console.log( parity( 32 ) ); // 'even' -console.log( parity( 10 ) ); // 'even' -console.log( parity( 602348 ) ); // 'even' -// Write a function `print2d` that accepts a two-dimensional array as an argument. The function -// should print all inner elements of the array. - -let print2d = function ( array ) { - for ( let i = 0; i < array.length; i++ ) { - let subarray = array[ i ]; - for ( let j = 0; j < subarray.length; j++ ) { - console.log( subarray[ j ] ); - } - } -}; - - -let array1 = [ - [ "a", "b", "c", "d" ], - [ "e", "f" ], - [ "g", "h", "i" ], -]; -print2d( array1 ); -// prints -// a -// b -// c -// d -// e -// f -// g -// h -// i - -let array2 = [ - [ 9, 3, 4 ], - [ 11 ], - [ 42, 100 ] -]; -print2d( array2 ); -// prints -// 9 -// 3 -// 4 -// 11 -// 42 -// 100 -// Write a function `printCombinations`that accepts two arrays as arguments. The function should -// print all combinations of the elements generated by taking an element from the first array and -// and an element from the second array. The function doesn't need to return any value. It -// should just print to the terminal. - - -let printCombinations = function ( array1, array2 ) { - for ( let i = 0; i < array1.length; i++ ) { - let ele1 = array1[ i ]; - - for ( let j = 0; j < array2.length; j++ ) { - let ele2 = array2[ j ]; - console.log( ele1, ele2 ); - } - } -}; - -let colors = [ "gray", "cream", "cyan" ]; -let clothes = [ "shirt", "flannel" ]; -printCombinations( colors, clothes ); -// prints -// gray shirt -// gray flannel -// cream shirt -// cream flannel -// cyan shirt -// cyan flannel - -printCombinations( [ "hot", "cold" ], [ "soup", "tea" ] ); -// prints -// hot soup -// hot tea -// cold soup -// cold tea -// Write a function named `productUpTo(max)` that accepts a max number as an argument. The function -// should return the total product of all whole numbers from 1 to the max, inclusive. A product is a -// number obtained from multiplying numbers together. -// -// For example, productUpTo(4) should return 24 because 1 * 2 * 3 * 4 = 24 - -let productUpTo = function ( max ) { - let product = 1; - - for ( let i = 1; i <= max; i++ ) { - product *= i; - } - - return product; -}; - -console.log( productUpTo( 4 ) ); // 24 -console.log( productUpTo( 5 ) ); // 120 -console.log( productUpTo( 7 ) ); // 5040 -let word = "suspension bridge"; -console.log( word[ 4 ] ); // e -console.log( word.length > 5 && word[ 0 ] === "d" ); // false -console.log( word.length > 5 && word[ 0 ] === "s" ); // true -console.log( word.indexOf( "o" ) > -1 ); // true -console.log( word.indexOf( "z" ) > -1 ); // false - -let str = "foggy"; -console.log( str[ 2 + 1 ] ); // g -console.log( str[ str.length - 1 ] ); // y -str = " day"; -console.log( str ); // ' day' -console.log( str.length ); // 4 -console.log( str.indexOf( "ogg" ) ); // -1 -// Write a function `raisePower(base, exponent)` that accepts two numbers, `base` and `exponent`. The -// function should return `base` raised to the `exponent` power. -// -// For example, raisePower(2, 5) should return 32 because 2 * 2 * 2 * 2 * 2 = 32 -// For example, raisePower(4, 3) should return 64 because 4 * 4 * 4 = 64 - -let raisePower = function ( base, exponent ) { - let product = 1; - - for ( let i = 1; i <= exponent; i++ ) { - product *= base; - } - - return product; -}; - -console.log( raisePower( 2, 5 ) ); // 32 -console.log( raisePower( 4, 3 ) ); // 64 -console.log( raisePower( 10, 4 ) ); // 10000 -console.log( raisePower( 7, 2 ) ); // 49 -// Write a function `removeCapitals` that accepts a string as an argument. The function should return a -// new version of the string with all capital letters removed. - -let removeCapitals = function ( str ) { - let newStr = ''; - - for ( let i = 0; i < str.length; i++ ) { - let char = str[ i ]; - if ( char === char.toLowerCase() ) { - newStr += char; - } - } - - return newStr; -}; - -console.log( removeCapitals( "fOrEver" ) ); // 'frver' -console.log( removeCapitals( "raiNCoat" ) ); // 'raioat' -console.log( removeCapitals( "cElLAr Door" ) ); // 'clr oor' -// Write a function `removeDupes` that accepts an array as an argument. The function should return a -// new array where each element only appears once. - -let removeDupes = function ( array ) { - let uniques = []; - - for ( let i = 0; i < array.length; i++ ) { - let ele = array[ i ]; - if ( !uniques.includes( ele ) ) { - uniques.push( ele ); - } - } - - return uniques; -}; - -console.log( removeDupes( [ "x", "y", "y", "x", "z" ] ) ); // ['x', 'y', 'z'] -console.log( removeDupes( [ false, false, true, false ] ) ); // [false, true] -console.log( removeDupes( [ 42, 5, 7, 42, 7, 3, 7, 7 ] ) ); // [42, 5, 7, 3] -// Write a function `removeFirstVowel` that accepts a string as an argument. The function should return -// the string with it's first vowel removed. - -let removeFirstVowel = function ( str ) { - let vowels = 'aeiou'; - - for ( let i = 0; i < str.length; i++ ) { - let char = str[ i ]; - if ( vowels.includes( char ) ) { - return str.slice( 0, i ) + str.slice( i + 1 ); - } - } - - return str; -}; - -console.log( removeFirstVowel( "volcano" ) ); // 'vlcano' -console.log( removeFirstVowel( "celery" ) ); // 'clery' -console.log( removeFirstVowel( "juice" ) ); // 'jice' -console.log( removeFirstVowel( "bridge" ) ); // 'brdge' -console.log( removeFirstVowel( "try" ) ); // 'try' -// Write a function `removeShortWords` that accepts a sentence string as an argument. The function -// should return a new sentence where all of the words shorter than 4 characters are removed. - -let removeShortWords = function ( sentence ) { - let words = sentence.split( ' ' ); - let chosenWords = []; - - for ( let i = 0; i < words.length; i++ ) { - let word = words[ i ]; - - if ( word.length >= 4 ) { - chosenWords.push( word ); - } - } - - return chosenWords.join( ' ' ); -}; - -console.log( removeShortWords( "knock on the door will you" ) ); // 'knock door will' -console.log( removeShortWords( "a terrible plan" ) ); // 'terrible plan' -console.log( removeShortWords( "run faster that way" ) ); // 'faster that' -// Write a function `removeVowels` that accepts a string as an argument. The function should return -// a version of the string where all vowels are removed. - -let removeVowels = function ( str ) { - let newStr = ''; - let vowels = 'aeiou'; - - for ( let i = 0; i < str.length; i++ ) { - let char = str[ i ]; - if ( !vowels.includes( char ) ) { - newStr += char; - } - } - - return newStr; -}; - -console.log( removeVowels( "jello" ) ); // jll -console.log( removeVowels( "sensitivity" ) ); // snstvty -console.log( removeVowels( "cellar door" ) ); // cllr dr -// Write a function `reverseArray` that accepts an array as an argument. The function should return a -// array containing the elements of the original array in reverse order. - -let reverseArray1 = function ( array ) { - let reversed = []; - - for ( let i = array.length - 1; i >= 0; i-- ) { - reversed.push( array[ i ] ); - } - - return reversed; -}; - -console.log( reverseArray1( [ "zero", "one", "two", "three" ] ) ); // ['three', 'two', 'one', 'zero'] -console.log( reverseArray1( [ 7, 1, 8 ] ) ); // [8, 1, 7] - - -let reverseArray2 = function ( array ) { - let reversed = []; - - for ( let i = 0; i < array.length; i++ ) { - reversed.unshift( array[ i ] ); - } - - return reversed; -}; - -console.log( reverseArray2( [ "zero", "one", "two", "three" ] ) ); // ['three', 'two', 'one', 'zero'] -console.log( reverseArray2( [ 7, 1, 8 ] ) ); // [8, 1, 7] -// Write a function `reverseIterate` that accepts a string as an argument. The function should print -// the characters of the string one by one, in reverse order. The function doesn't need to return any -// value. It should just print to the terminal. - -let reverseIterate = function ( str ) { - for ( let i = str.length - 1; i >= 0; i-- ) { - console.log( str[ i ] ); - } -}; - -reverseIterate( "carrot" ); -// prints -// t -// o -// r -// r -// a -// c - -reverseIterate( "box" ); -// prints -// x -// o -// b -// Write a function `shortenLongWords` that accepts a sentence string as an argument. The function -// should return the same sentence where words longer than 4 characters have their vowels removed. - -let removeVowels = function ( str ) { - let newStr = ''; - let vowels = 'aeiou'; - - for ( let i = 0; i < str.length; i++ ) { - let char = str[ i ]; - if ( !vowels.includes( char ) ) { - newStr += char; - } - } - - return newStr; -}; - -let shortenLongWords = function ( sentence ) { - let words = sentence.split( ' ' ); - let newWords = []; - - for ( let i = 0; i < words.length; i++ ) { - let word = words[ i ]; - if ( word.length > 4 ) { - let noVowels = removeVowels( word ); - newWords.push( noVowels ); - } else { - // leave it the same - newWords.push( word ); - } - } - - return newWords.join( ' ' ); -}; - -console.log( shortenLongWords( "they are very noble people" ) ); // 'they are very nbl ppl' -console.log( shortenLongWords( "stick with it" ) ); // 'stck with it' -console.log( shortenLongWords( "ballerina, you must have seen her" ) ); // 'bllrna, you must have seen her -console.log( "promenade" [ 3 ] ); // m -console.log( "tiger" [ 1 ] ); // i -console.log( "wheel".length ); // 5 - -console.log( "wheel".length - 1 ); // 4 -console.log( "noMAD".toUpperCase() ); // NOMAD -console.log( "hey programmers" [ 2 ] === "y" ); // true - -console.log( "volleyball".length > 20 ); // false -console.log( "treasure".indexOf( "r" ) ); // 1 -console.log( "treasure".indexOf( "e" ) ); // 2 -console.log( "web" [ 5 ] ); // undefined -console.log( "red".indexOf( "x" ) ); // -1 -console.log( "red".indexOf( "R" ) ); // -1 -// snippet 0-1 -let greet = function () { - console.log( "hey" ); - console.log( "programmers" ); -}; - -let whistle = function () { - console.log( "doot" ); -}; - -console.log( "first" ); -console.log( "second" ); -greet(); -console.log( "third" ); -console.log( "fourth" ); -whistle(); - - -// first -// second -// hey -// programmers -// third -// fourth -// doot -// snippet 0-2 -let howMany = function () { - return 42; -}; - -console.log( howMany ); -console.log( howMany() ); - -const theAnswer = howMany(); -console.log( theAnswer ); - -let howMuch = function () { - 5; -}; -console.log( howMuch() ); - - -// [Function: howMany] -// 42 -// 42 -// undefined -// snippet 0-3 -let average = function ( num1, num2 ) { - console.log( "calculating..." ); - return ( num1 + num2 ) / 2; -}; - -console.log( average( 5, 10 ) ); -console.log( average( 20, 26 ) ); -console.log( average( 50, 100 ) + 2 ); - -let a = 21 + 3; -let b = 20; -let n = average( a, b ); -console.log( average( n, 18 ) ); - - -// calculating... -// 7.5 -// calculating... -// 23 -// calculating... -// 77 -// calculating... -// calculating... -// 20 -// snippet 0-4 -let exclaim = function ( str ) { - let capitalized = str.toUpperCase(); - return capitalized + "!!"; -}; - -let result = exclaim( "potato" ); -console.log( result ); -console.log( result.length ); -console.log( result[ 0 ] ); -console.log( result[ result.length - 1 ] ); - - -// POTATO!! -// 8 -// P -// ! -// snippet 1 -console.log( "hello" ); - -for ( let i = 0; i < 5; i++ ) { - console.log( "code" ); -} - -console.log( "goodbye" ); - - -hello -code -code -code -code -code -goodbye -// snippet 1 -console.log( "hello" ); - -for ( let i = 0; i < 5; i++ ) { - console.log( "code" ); -} - -console.log( "goodbye" ); - - -hello -code -code -code -code -code -goodbye -// snippet 2 -console.log( "hi" ); - -for ( let i = 3; i <= 7; i++ ) { - console.log( "program" ); - console.log( i ); -} - -console.log( "bye" ); - - -// hi -// program -// 3 -// program -// 4 -// program -// 5 -// program -// 6 -// program -// 7 -// bye -// snippet 2 -console.log( "hi" ); - -for ( let i = 3; i <= 7; i++ ) { - console.log( "program" ); - console.log( i ); -} - -console.log( "bye" ); - - -// hi -// program -// 3 -// program -// 4 -// program -// 5 -// program -// 6 -// program -// 7 -// bye -// snippet 3 -let foo = function () { - for ( let num = 10; num > 0; num -= 2 ) { - console.log( num ); - } -}; - -console.log( "begin" ); -foo(); -console.log( "end" ); -foo(); - - -// begin -// 10 -// 8 -// 6 -// 4 -// 2 -// end -// 10 -// 8 -// 6 -// 4 -// 2 -// snippet 3 -let foo = function () { - for ( let num = 10; num > 0; num -= 2 ) { - console.log( num ); - } -}; - -console.log( "begin" ); -foo(); -console.log( "end" ); -foo(); - - -// begin -// 10 -// 8 -// 6 -// 4 -// 2 -// end -// 10 -// 8 -// 6 -// 4 -// 2 -// snippet 4 -let word = "street"; -for ( let i = 0; i < word.length; i++ ) { - console.log( i ); - console.log( word[ i ] ); -} - - -// 0 -// s -// 1 -// t -// 2 -// r -// 3 -// e -// 4 -// e -// 5 -// t -// snippet 4 -let word = "street"; -for ( let i = 0; i < word.length; i++ ) { - console.log( i ); - console.log( word[ i ] ); -} - - -// 0 -// s -// 1 -// t -// 2 -// r -// 3 -// e -// 4 -// e -// 5 -// t -// snippet 5 -let total = 0; // 10 -for ( let i = 1; i < 5; i++ ) { - total += i; - console.log( total ); -} - -console.log( "grand total: " + total ); - - -// 1 -// 3 -// 6 -// 10 -// grand total: 10 -// snippet 5 -let total = 0; // 10 -for ( let i = 1; i < 5; i++ ) { - total += i; - console.log( total ); -} - -console.log( "grand total: " + total ); - - -// 1 -// 3 -// 6 -// 10 -// grand total: 10 -// Write a function `spam` that accepts a 2D array as an argument. The array contains pairs as elements. -// The first element of every pair is a number and the second element is a word. The function should -// return a string containing the words repeated the specified number of times. See the examples. - -let spam = function ( pairs ) { - let words = []; - - for ( let i = 0; i < pairs.length; i++ ) { - let pair = pairs[ i ]; - let word = pair[ 0 ]; - let num = pair[ 1 ]; - - for ( let j = 0; j < num; j++ ) { - words.push( word ); - } - } - - return words.join( ' ' ); -}; - -let array1 = [ - [ "hi", 3 ], - [ "bye", 2 ], -]; -console.log( spam( array1 ) ); // 'hi hi hi bye bye' - -let array2 = [ - [ "cat", 1 ], - [ "dog", 2 ], - [ "bird", 4 ], -]; -console.log( spam( array2 ) ); // 'cat dog dog bird bird bird bird' -// Write a function `startsWithR` that accepts a string as an argument and returns a boolean indicating -// whether or not the string starts with 'r' or 'R'. - -let startsWithR = function ( str ) { - return str[ 0 ] === 'r' || str[ 0 ] === 'R'; -}; - -console.log( startsWithR( "roger that" ) ); // true -console.log( startsWithR( "Row, row, row your boat" ) ); // true -console.log( startsWithR( "slip" ) ); // false -console.log( startsWithR( "Taxicab" ) ); // false -// Write a function `stayPositive` that accepts an array of numbers as an argument. The function should -// return an array containing only the positive numbers. - -let stayPositive = function ( numbers ) { - let positives = []; - - for ( let i = 0; i < numbers.length; i++ ) { - if ( numbers[ i ] > 0 ) { - positives.push( numbers[ i ] ); - } - } - - return positives; -}; - - -console.log( stayPositive( [ 10, -4, 3, 6 ] ) ); // [10, 3, 6] -console.log( stayPositive( [ -5, 11, -40, 30.3, -2 ] ) ); // [11, 30.3] -console.log( stayPositive( [ -11, -30 ] ) ); // [] -console.log( "river" + "town" ); -console.log( "cat" + "dog" ); -console.log( "New" + " York" ); -console.log( "runner's knee" + "!" ); -console.log( "man" + "bear" + "pig" ); -// Write a function `stringIterate` that accepts a string as an argument. The function should print out -// each character of the string, one by one. The function doesn't need to return any value. It should -// just print to the terminal. - -let stringIterate = function ( string ) { - for ( let i = 0; i < string.length; i++ ) { - console.log( string[ i ] ); - } -}; - -stringIterate( "celery" ); -// prints -// c -// e -// l -// e -// r -// y - -stringIterate( "hat" ); -// prints -// h -// a -// t -// Write a function named `stringRepeater(str, num)` that accepts a string and a number as arguments. -// The function should return a new string consisting of the `str` repeated `num` number of times. - -let stringRepeater = function ( str, num ) { - let repeatedStr = ''; - - for ( let i = 1; i <= num; i++ ) { - repeatedStr += str - } - - return repeatedStr; -}; - -console.log( stringRepeater( "q", 4 ) ); // 'qqqq' -console.log( stringRepeater( "go", 2 ) ); // 'gogo' -console.log( stringRepeater( "tac", 3 ) ); // 'tactactac' -// Write a function `stringSize` that accepts a string as an argument. The function should return the -// string 'small' if the argument is shorter than 5 characters, 'medium' if it is exactly 5 characters, and -// 'large' if it is longer than 5 characters. - -let stringSize = function ( str ) { - if ( str.length < 5 ) { - return 'small'; - } else if ( str.length > 5 ) { - return 'large'; - } else { - return 'medium'; - } -}; - -console.log( stringSize( "cat" ) ); // 'small' -console.log( stringSize( "bell" ) ); // 'small' -console.log( stringSize( "ready" ) ); // 'medium' -console.log( stringSize( "shirt" ) ); // 'medium' -console.log( stringSize( "shallow" ) ); // 'large' -console.log( stringSize( "intelligence" ) ); // 'large' -// Write a function `stringsToLengths` that accepts an array of strings as an argument. The function -// should return a new array containing the lengths of the elements of the original array. - -let stringsToLengths = function ( words ) { - let lengths = []; - - for ( let i = 0; i < words.length; i++ ) { - lengths.push( words[ i ].length ); - } - - return lengths; -}; - -console.log( stringsToLengths( [ "belly", "echo", "irony", "pickled" ] ) ); -// [5, 4, 5, 7] - -console.log( stringsToLengths( [ "on", "off", "handmade" ] ) ); -// [2, 3, 8] -// Write a function named `sumUpTo(max)` that accepts a max number as an argument. The function should -// return the total sum of all whole numbers from 1 to the max, inclusive. -// -// For example, sumUpTo(4) should return 10 because 1 + 2 + 3 + 4 = 10. - -let sumUpTo = function ( max ) { - let sum = 0; - - for ( let i = 1; i <= max; i++ ) { - sum += i - } - - return sum; -}; - -console.log( sumUpTo( 4 ) ); // 10 -console.log( sumUpTo( 5 ) ); // 15 -console.log( sumUpTo( 2 ) ); // 3 -console.log( 'coffee' ); -let qty = 15 % 4; -console.log( qty ); // 3 - -let num = 38 + 3; -num++; -console.log( num + " is a great number" ); // '42 is a great number' - -let isNumEven = num % 2 === 0; -console.log( num + " is even? " + isNumEven ); // '42 is even? true' - -let isQtyEven = qty % 2 === 0; -console.log( qty + " is even? " + isQtyEven ); // '3 is even? false' -let qty = 15 % 4; -console.log( qty ); // 3 - -let num = 38 + 3; -num++; -console.log( num + " is a great number" ); // '42 is a great number' - -let isNumEven = num % 2 === 0; -console.log( num + " is even? " + isNumEven ); // '42 is even? true' - -let isQtyEven = qty % 2 === 0; -console.log( qty + " is even? " + isQtyEven ); // '3 is even? false' -// Write a function `totalProduct(array)` that accepts a 2D array of numbers. The function should return -// the total product of all numbers in the array. - -let totalProduct = function ( array ) { - let product = 1; - - for ( let i = 0; i < array.length; i++ ) { - let subarray = array[ i ]; - - for ( let j = 0; j < subarray.length; j++ ) { - product *= subarray[ j ]; - } - } - - return product; -}; - -let array1 = [ - [ 3, 5, 2 ], - [ 6, 2 ], -]; -console.log( totalProduct( array1 ) ); // 360 - -let array2 = [ - [ 4, 6 ], - [ 2, 3 ], - [ 1, 2 ], -]; -console.log( totalProduct( array2 ) ); // 288 -// Write a function `total` that accepts an array of numbers as an argument. The function should return -// the total sum of all elements of the array. - -let total = function ( numbers ) { - let sum = 0; - for ( let i = 0; i < numbers.length; i++ ) { - sum += numbers[ i ]; - } - return sum; -}; - -console.log( total( [ 3, 2, 8 ] ) ); // 13 -console.log( total( [ -5, 7, 4, 6 ] ) ); // 12 -console.log( total( [ 7 ] ) ); // 7 -console.log( total( [] ) ); // 0 -let apple; -console.log( apple ); // undefined - -apple = 5; -console.log( apple ); // 5 - -apple + 1; -console.log( apple ); // 5 - -apple += 1; -console.log( apple ); // 6 - -let banana = apple; -console.log( banana ); // 6 - -banana = banana / 2; -console.log( banana ); // 3 - -console.log( apple ); // 6 -// Write a function `twoSumPairs(numbers, target)` that accepts an array of numbers and a target number -// as arguments. The function should return a 2D array containing all unique pairs of elements that -// sum to the target. - -let twoSumPairs = function ( numbers, target ) { - let pairs = []; - - for ( let i = 0; i < numbers.length; i++ ) { - let num1 = numbers[ i ]; - - for ( let j = i + 1; j < numbers.length; j++ ) { - let num2 = numbers[ j ]; - - if ( num1 + num2 === target ) { - let pair = [ num1, num2 ]; - pairs.push( pair ); - } - } - } - - return pairs; -}; - -console.log( twoSumPairs( [ 2, 3, 4, 6, 5 ], 8 ) ); // [ [2, 6], [3, 5] ] -console.log( twoSumPairs( [ 10, 7, 4, 5, 2 ], 12 ) ); // [ [10, 2], [7, 5] ] -console.log( twoSumPairs( [ 3, 9, 8 ], 11 ) ); // [ [3, 8] ] -console.log( twoSumPairs( [ 3, 9, 8 ], 10 ) ); // [ ] -// Write a function `twoSum(numbers, target)` that accepts an array of numbers and a target number -// as an argument. The function should return a boolean indicating whether or not there exists a pair -// of distinct elements in the array that sum to the target. - -let twoSum = function ( numbers, target ) { - for ( let i = 0; i < numbers.length; i++ ) { - for ( let j = i + 1; j < numbers.length; j++ ) { - if ( numbers[ i ] + numbers[ j ] === target ) { - return true; - } - } - } - - return false; -}; - -console.log( twoSum( [ 2, 3, 5, 9 ], 7 ) ); // true -console.log( twoSum( [ 2, 3, 5, 9 ], 4 ) ); // false -console.log( twoSum( [ 6, 3, 4 ], 10 ) ); // true -console.log( twoSum( [ 6, 5, 1 ], 10 ) ); // false -let apple; -console.log( apple ); // undefined - -apple = 5; -console.log( apple ); // 5 - -apple + 1; -console.log( apple ); // 5 - -apple += 1; -console.log( apple ); // 6 - -let banana = apple; -console.log( banana ); // 6 - -banana = banana / 2; -console.log( banana ); // 3 - -console.log( apple ); // 6 -// Write a function `wackyWord` that accepts two strings as arguments. The function should return a new -// string containing the first three characters of the first string concatenated with the last two -// character of the second string. - -// You can assume that the first argument has a length of at least three and the second argument has a -// length of at least two. - - -let wackyWord = function ( str1, str2 ) { - return str1.slice( 0, 3 ) + str2.slice( -2 ); -}; - -console.log( wackyWord( "very", "kindly" ) ); // 'verly' -console.log( wackyWord( "forever", "sick" ) ); // 'forck' -console.log( wackyWord( "cellar", "door" ) ); // 'celor' -console.log( wackyWord( "bagel", "sweep" ) ); // 'bagep' -console.log( 'alvin' ); -console.log( 'z' ); -// Write a function `wordCount(sentence, targetWords)` that accepts a sentence string and an array of -// `targetWords`. The function should return a count of the number of words of the sentence that are -// in `targetWords`. - -let wordCount = function ( sentence, targetWords ) { - let words = sentence.split( ' ' ); - let count = 0; - - for ( let i = 0; i < words.length; i++ ) { - let word = words[ i ]; - - if ( targetWords.includes( word ) ) { - count++; - } - } - - return count; -}; - -console.log( wordCount( "open the window please", [ "please", "open", "sorry" ] ) ); // 2 -console.log( wordCount( "drive to the cinema", [ "the", "driver" ] ) ); // 1 -console.log( wordCount( "can I have that can", [ "can", "I" ] ) ); // 3 -// Write a function `yourAverageFunction` that accepts an array of numbers as an argument. The -// function should return the average of all elements of the array. If the input array is empty, -// then the function should return null. - -let yourAverageFunction = function ( nums ) { - if ( nums.length === 0 ) { - return null; - } - - let sum = 0; - for ( let i = 0; i < nums.length; i++ ) { - sum += nums[ i ]; - } - - return sum / nums.length; -}; - -console.log( yourAverageFunction( [ 5, 2, 7, 24 ] ) ); // 9.5 -console.log( yourAverageFunction( [ 100, 6 ] ) ); // 53 -console.log( yourAverageFunction( [ 31, 32, 40, 12, 33 ] ) ); // 29.6 -console.log( yourAverageFunction( [] ) ); // null -let location = "Brooklyn, " + "NY"; -console.log( location ); // 'Brooklyn, NY' - -let quantity = 4 * 5 + 1; -console.log( quantity ); // 21 -let location = "Brooklyn, " + "NY"; -console.log( location ); // 'Brooklyn, NY' - -let quantity = 4 * 5 + 1; -console.log( quantity ); // 21 -// Write a function `zipper` that accepts two arrays as arguments. The function should return a 2D -// array containing pairs of elements at the same indices. - - -let zipper = function ( arr1, arr2 ) { - let result = []; - - for ( let i = 0; i < arr1.length; i++ ) { - let el1 = arr1[ i ]; - let el2 = arr2[ i ]; - let pair = [ el1, el2 ]; - result.push( pair ); - } - - return result; -}; - -let array1 = [ "a", "b", "c", "d" ]; -let array2 = [ -1, -2, -3, -4 ]; -console.log( zipper( array1, array2 ) ); -// [ -// ['a', -1], -// ['b', -2], -// ['c', -3], -// ['d', -4], -// ] - -let array3 = [ "whisper", "talk", "shout" ]; -let array4 = [ "quiet", "normal", "loud" ]; -console.log( zipper( array3, array4 ) ); -// [ -// ['whisper', 'quiet'], -// ['talk', 'normal'], -// ['shout', 'loud'], -// ] - - - - - -

javascript-practice/00_expressions_variables/exercises/A_executing_code_exercise/

- -### [javascript-practice/00_expressions_variables/exercises/A_executing_code_exercise/README.md](javascript-practice/00_expressions_variables/exercises/A_executing_code_exercise/README.md) -# Write, Run, Repeat - -You won't become a strong programmer with "one secret trick" or "however-many expert tips". No -shortcuts. Just write code, run it, do it again. We'll be creating and executing hundreds of -programs in this course. Let's bang out the first four. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/U-679Jd3fmQ) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/f7CZUGFdhfg) - -Let's get to work. - --AZ - -## 0. Follow my lead. - -1. If you already have VSCode open, close it. -2. On your computer's Desktop, create a new folder named `my-first-programs`. -3. Open the `my-first-programs` folder in VSCode -4. Use VSCode to create a file named `greeting.js` inside of `my-first-programs`. -5. Inside of `greeting.js`, write the single line of code `console.log('hello world');`. This will - cause the program to print `hello world` when you execute it later. -6. Save the `greeting.js` file using the keyboard shortcut `cmd + s` or `ctrl + s`. -7. Open the terminal and enter the command `node greeting.js` to execute your code. **You should see - `hello world` printed out.** - -## 1. Still following? - -1. Inside the `my-first-programs` folder, create a new file named `whoami.js`. -2. Inside of `whoami.js` use `console.log` to print out your first name. Don't forget to put - quotation marks (`'`) around your name and end the line with a semicolon (`;`). -3. Save `whoami.js` and execute it in your terminal using the `node`. **You should see your name - printed out.** - -## 2. I'll follow you. - -Start from scratch. Close VSCode if you have it open. Use VSCode to write a program named -`thirsty.js` inside of the `my-first-programs` folder. The program should print out your favorite -cold beverage. Execute `thirsty.js` in your terminal. - -## 3. Beginner's luck; show me it again. - -That seems suspicious. Write a program named `age.js` that prints out your age. Run it. - -## Walkthrough - - - - - - - - - -

javascript-practice/00_expressions_variables/exercises/B_expressions_exercise/

- -### [javascript-practice/00_expressions_variables/exercises/B_expressions_exercise/README.md](javascript-practice/00_expressions_variables/exercises/B_expressions_exercise/README.md) -# Express Yourself - -_Expressions_ are the building blocks of programs. We can combine _values_ with _operators_ to -compose an expression. An _expression_ evaluates to some _value_. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture Part 1](https://youtu.be/NORcxNPVtg4) -+ [Lecture Part 2](https://youtu.be/1y9DCzWYons) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/oMHa_c21sCw) - -The fundamentals of any skill aren't particularly glamorous. We'll learn the "cool" stuff when you -are ready. Crawl. Walk. Run. - --AZ - -## 0. Hope you didn't forget. - -Create a new folder named `expressions-exercise`. Open it in VSCode. Create four files within this -folder: `string-expressions.js`, `number-expressions.js`, `boolean-expressions.js`, -`comparisons.js`. - -After creating these files, your folder structure should look like this: - -```plaintext -expressions-exercise/ -├── string-expressions.js -├── number-expressions.js -├── boolean-expressions.js -└── comparisons.js -``` - -## 1. Stringing together some expressions. - -Make a mental prediction of what the following expressions will print: - -```javascript -console.log("river" + "town"); -console.log("cat" + "dog"); -console.log("New" + " York"); -console.log("runner's knee" + "!"); -console.log("man" + "bear" + "pig"); -``` - -To check your prediction, write the code into `string-expressions.js` and run it in your terminal -with `node string-expressions.js`. Don't copy and paste. Type everything manually. You should do -this line by line. This means you should type the first expression, run it. Add the second -expression, run it, and so on. Don't try to type all five lines and then run it all at once. You -will find it hard to pinpoint any typos if you do that. - -## 2. Don't enjoy math? Too bad. - -Make predictions for what these number expressions evaluate to. Test your predictions by writing the -code to `number-expressions.js` and running it: - -```js -console.log(2 + 3); -console.log(10 - 15); -console.log(4 + 1 - 5); -console.log(4 * 3); - -console.log(7 / 2); -console.log(4 + 2 * 3); -console.log((4 + 2) * 3); -console.log(5 % 2); - -console.log(6 % 2); -console.log(7 % 2); -console.log(8 % 2); -console.log(19 % 8); - -console.log(24 % 8); -console.log(7 % 4); -console.log(4 % 7); -console.log(5 + (10 % 5)); -console.log((5 + 10) % 5); -``` - -## 3. Shoutout to George Boole. - -Make predictions for what these boolean expressions evaluate to. Test your predictions by writing -the code to `boolean-expressions.js` and running it: - -```js -console.log(false); -console.log(!true); -console.log(!false); -console.log(!!true); - -console.log(false && false); -console.log(false && true); -console.log(true && false); -console.log(true && true); - -console.log(false || false); -console.log(false || true); -console.log(true || false); -console.log(true || true); - -console.log(!false || false); -console.log(false || (true && true)); -console.log(false || !(true && true)); -console.log(!true && (false || true)); -``` - -## 4. Drawing a Comparison. - -Make predictions for what these comparison expressions evaluate to. Test your predictions by writing -the code to `comparisons.js` and running it: - -```js -console.log(true === false); -console.log(false === false); -console.log(false !== true); -console.log(!true === false); - -console.log(2 + 3 === 5); -console.log(4 < 0); -console.log(10 >= 10); -console.log(10.3 >= 10); - -console.log(100 / 2 === 50); -console.log(100 % 2 === 0); -console.log(11 % 2 === 0); -console.log(7.0 === 7); - -console.log(13 % 5 > 0); -console.log("potato" === "potato"); -console.log("Tomato" === "tomato"); -console.log("42" === 42); -console.log(5 > 3 && 1 === 0); -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/00_expressions_variables/exercises/C_variables_exercise/

- -### [javascript-practice/00_expressions_variables/exercises/C_variables_exercise/README.md](javascript-practice/00_expressions_variables/exercises/C_variables_exercise/README.md) -# Very Able - -_Variables_ allow programmers to store values to be used later in their code. The value that a -variable contains can change throughout the runtime of a program. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/lmXRLpoyPic) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/T_xE-x0Eyqk) - -Ready? - --AZ - -## 0. Do you speak the language? - -Create a folder named `variables_exercise`. Create a file named `zero.js` inside of it. Predict what -the `console.log`s in the code below will print out: - -```js -let location = "Brooklyn, " + "NY"; -console.log(location); - -let quantity = 4 * 5 + 1; -console.log(quantity); -``` - -Test your predictions by typing the code into the `zero.js` file; don't copy and paste. Run it to -check your guess. - -## 1. What's changed? What hasn't? - -Create a new file named `one.js` inside of the `variables_exercise` folder. Predict what the -`console.log`s in the code below will print out: - -```js -let word = "bye"; -console.log(word + " felicia"); -console.log(word); - -let num = 10; -num = num * 2; -console.log(num); - -let bottlesOfBeer = 99; -let around = bottlesOfBeer - 1; -console.log(around); -console.log(bottlesOfBeer); -``` - -Test your predictions by typing the code into the `one.js` file. Run it. - -## 2. How about this? - -Create a new file named `two.js` inside of the `variables_exercise` folder. Predict what the -`console.log`s in the code below will print out: - -```js -let apple; -console.log(apple); - -apple = 5; -console.log(apple); - -apple + 1; -console.log(apple); - -apple += 1; -console.log(apple); - -let banana = apple; -console.log(banana); - -banana = banana / 2; -console.log(banana); - -console.log(apple); -``` - -Test your predictions by typing the code into the `two.js` file. Run it. - -## 3. Did you forget about modulo? - -Create a new file named `three.js` inside of the `variables_exercise` folder. Predict what the -`console.log`s in the code below will print out: - -```js -let qty = 15 % 4; -console.log(qty); - -let num = 38 + 3; -num++; -console.log(num + " is a great number"); - -let isNumEven = num % 2 === 0; -console.log(num + " is even? " + isNumEven); - -let isQtyEven = qty % 2 === 0; -console.log(qty + " is even? " + isQtyEven); -``` - -## 4. So you can code, but do you have good taste in cinema? - -Create a new file named `four.js` inside of the `variables_exercise` folder. Create two variables: - -- `movie`, assigned to the string title of your favorite movie -- `views`, assigned to the number of times you watched that movie - -When executed, the program should print the message -`I watched about number of times`. - -## Walkthrough - - - - - - - - - -

javascript-practice/00_expressions_variables/exercises/D_string_indexing_and_methods_exercise/

- -### [javascript-practice/00_expressions_variables/exercises/D_string_indexing_and_methods_exercise/README.md](javascript-practice/00_expressions_variables/exercises/D_string_indexing_and_methods_exercise/README.md) -# Intelligent Indexing - -A string consists of one or more characters. An _index_ is a number that corresponds to the position -of a character in a string. The first character of a string has _index 0_, the second character has -_index 1_, and so on. _Indexing_ is a pattern that programmers use often in strings. This pattern -will also appear later in more advanced applications. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/QoeKfd9MYWA) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough Part 1](https://youtu.be/lXlNybyHclc) -+ [Walkthrough Part 2](https://youtu.be/4sf1uP9OIDI) - -This is where we begin to unlock the basic programming patterns that you'll always be able to rely -on. Study them closely. - --AZ - -## 0. Small String Snippets. - -Create a new folder named `string-indexing-and-methods`. Create a file named -`small-string-snippets.js` inside. Predict what the following code will print out: - -```js -console.log("promenade"[3]); -console.log("tiger"[1]); -console.log("wheel".length); -console.log("wheel".length - 1); -console.log("noMAD".toUpperCase()); -console.log("hey programmers"[2] === "y"); - -console.log("volleyball".length > 20); -console.log("treasure".indexOf("r")); -console.log("treasure".indexOf("e")); -console.log("web"[5]); -console.log("red".indexOf("x")); -console.log("red".indexOf("R")); -``` - -Verify your predictions by writing the code to the `small-string-snippets.js` file. Don't copy and -paste; type everything out manually. Run the code. - -## 1. Proper Patterns. - -Inside of the `string-indexing-and-methods` folder create another file named `proper-patterns.js`. -Predict what the following code will print out: - -```js -let word = "suspension bridge"; -console.log(word[4]); -console.log(word.length > 5 && word[0] === "d"); -console.log(word.length > 5 && word[0] === "s"); -console.log(word.indexOf("o") > -1); -console.log(word.indexOf("z") > -1); - -let str = "foggy"; -console.log(str[2 + 1]); -console.log(str[str.length - 1]); -str = " day"; -console.log(str); -console.log(str.length); -console.log(str.indexOf("ogg")); -``` - -Type the code. Don't copy and paste. Run it. Check your predictions. - -## 2. Dare to Decipher? - -Inside of the `string-indexing-and-methods` folder create another file named `dare-to-decipher.js`. -Predict what the following code will print out: - -```js -let phrase = "that's all folks"; -console.log(phrase[phrase.length]); -console.log(phrase[phrase.length - 1]); -console.log(phrase[phrase.length - 2]); - -const i = 9; -const char = phrase[i]; -console.log(char); -console.log(phrase.indexOf(char)); -console.log(phrase.slice(2, 8)); - -console.log("abcdefg".slice(1, 3)); -console.log("abcdefg".slice(2)); -console.log("abcdefg".slice(4)); -console.log("abcdefg".slice(2, -1)); -console.log("abcdefg".slice(2, -2)); -``` - -Nice code. Run it. - -## 3. A Tedious Task - -Inside of the `string-indexing-and-methods` folder create another file named `a-tedious-task.js`. -Write the program so that it prints out the index where the substring `HEY` can be found in the text -below. - -```plaintext -MIICWwIBAAKBgGEdLjFEFbegPZ2AwJWkalksXr7PzWL7wIc7pOFZxXwYPWtQxvANyceCwpkqbPLsfEx7nqxAris2hYOdeN1OTFqvTyNmVuzbUPcXShn6ZoDCB30voHkeu4F3cUw5RQEUDdLscSnv4HMxHam5qgl6vXoumVNHbjyKA5UtAnfjAgMBAAECgYAmjEyvpZTxRJvwjxDi1VaZevFI0Hd4WPH9PAGgqdnH84vGXnAGFj1WikqKYcqKMQW2kdjAsWwH9D9FfrkIcDDHdZ9XuGSGkFzWtOwajWMQl7qNV1hZ288gdpIQQMOTLDgauZY6pw1cV7h4v316qJB8knQGoBNpJCfTYQJBAKV1ctsJq0Zg4QumD2hyODepP3LfLeaQsERLqVAWeuOuTY5mK5gIwsSqvcSVfY7Ze1FWIsApNFRv67azKcJPwsCQQCNlyApZFJEVNY70Er7Uu5NL9t4CYJJC9uVVkoEHEY6d7sVslqa0vP2q0zXx9YedbMBvQjxXIbY0waXUy63FvoBGJAkB3OTJWUjVgzDY1Br5wu2Yu59NjKVKLWzCsu1gaCNBfhVDX7SyIyC9EYKRfUAoQxwsmPWPyQ9QVG4WKcPZJAkBRheAotPCBE2RLHHfvpiStnMhX0UXdVyaJp5tcZ6wYV61ohyBvCOkYhUxBJzeIGrVZcvLZSLeUzXoqRPpxQxAkEAkdCZXF0gHahpZgF5y0wWcqf9ECRT1E4Hv8bk3Mf0Exp2aW34JeI6I7Xqd1NV4I9H7prQ8m3y39lFwWO8PmQ -``` - -Fine. You can copy and paste, _this_ time. - -## Walkthrough - - - - - - - - - -

javascript-practice/01_conditionals/exercises/A_conditionals_exercise/

- -### [javascript-practice/01_conditionals/exercises/A_conditionals_exercise/README.md](javascript-practice/01_conditionals/exercises/A_conditionals_exercise/README.md) -# Strength and Conditioning - -A _conditional_ is a construct that allows programmers to execute different code dependent on the -value of a boolean expression. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/ous6eeG2BaY) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough Part 1](https://youtu.be/o50tHXYQzFE) -+ [Walkthrough Part 2](https://youtu.be/Ij7V0JfxeUs) - -_If_ you want to learn how to code, _then_ code. - --AZ - -## 0. If you can do this, then move on. - -Create a new folder named `conditional_exercise`. Inside, create a file named `zero.js`. Predict -what each of the code snippets below will print out. After you make a prediction for a snippet, add -the snippet into `zero.js`. Don't copy and paste. Run the code to verify your prediction for that -snippet, then move on to the next snippet. - -```js -// snippet 0-1 -if (true) { - console.log("foo"); -} - -if (false) { - console.log("bar"); -} -``` - -```js -// snippet 0-2 -if (false || false) { - console.log("boop"); -} - -if (true || false) { - console.log("beep"); -} -``` - -```js -// snippet 0-3 -let num = 40; - -if (num > 0) { - console.log("zip"); -} - -if (num % 2 === 0) { - console.log("zoop"); -} -``` - -```js -// snippet 0-4 -let word = "jeep"; - -if (word[0] === "d") { - console.log("yer"); -} else { - console.log("nah"); -} -``` - -```js -// snippet 0-5 -let sentence = "roger that"; - -if (sentence[sentence.length - 1] === "t") { - console.log("ends in t"); -} else { - console.log("does not end in t"); -} - -if (sentence.length <= 4) { - console.log("short"); -} else { - console.log("long"); -} -``` - -## 1. Conditions Do Apply. - -Create a new file named `one.js` inside of the `conditional_exercise` folder. Predict what each of -the snippets below will print out. Type each snippet into the file and run it to test your -prediction. Don't copy and paste. - -```js -// snippet 1-0 -let qty = 38; - -if (qty > 30 && qty % 5 === 4) { - console.log("swish"); -} else { - console.log("swoosh"); -} - -if (qty > 0) { - console.log("pos"); -} -``` - -```js -// snippet 1-1 -let a = "celery"; -let b = "SQUASH"; - -if (a === a.toUpperCase()) { - console.log("alpha"); -} - -if (b === b.toUpperCase()) { - console.log("beta"); -} -``` - -```js -// snippet 1-2 -let number = 9; - -if (number > 4) { - console.log("ding"); -} else if (number % 3 === 0) { - console.log("dong"); -} -``` - -```js -// snippet 1-3 -let z = 12; - -if (z > 10) { - console.log("vroom"); -} - -if (z % 3 === 0) { - console.log("skrrt"); -} -``` - -## 2. Iffy. - -Create a new file named `two.js` inside of the `conditional_exercise` folder. Predict what each of -the snippets below will print out. Type each snippet into the file and run it to test your -prediction. Don't copy and paste. - -```js -// snippet 2-1 -let nonsense = "blog trust fund tattooed williamsburg poke roof party"; -let hasOk = nonsense.indexOf("ok") > -1; - -if (hasOk) { - console.log("yeet"); -} else if (nonsense.length > 10) { - console.log("yo"); -} else { - console.log("no"); -} - -let hasZoo = nonsense.indexOf("zoo") > -1; -let hasFun = nonsense.indexOf("fun") > -1; - -if (hasZoo && hasOk) { - console.log("cool"); -} else if (hasOk) { - console.log("rad"); -} else if (hasFun) { - console.log("dope"); -} else { - console.log("nope"); -} -``` - -```js -// snippet 2-2 - -let q = 25; -if (q % 3 === 0 && q % 5 === 0) { - console.log("both"); -} else if (q % 3 === 0 || q % 5 == 0) { - console.log("either"); -} else { - console.log("neither"); -} - -let r = 9; -if (r % 3 === 0 && r % 5 === 0) { - console.log("both"); -} else if (r % 3 === 0 || r % 5 == 0) { - console.log("either"); -} else { - console.log("neither"); -} - -let s = 15; -if (s % 3 === 0 && s % 5 === 0) { - console.log("both"); -} else if (s % 3 === 0 || s % 5 == 0) { - console.log("either"); -} else { - console.log("neither"); -} -``` - -## 3. Conditional Love. - -Create a new file named `three.js` inside of the `conditional_exercise` folder. The program should -print out `FOUND` if the substring `coDe` exists in the text below. If the `coDe` does not exist in -the text, then the program should print `NOT FOUND`. - -```plaintext -AIICXAIBAAKBgQCuw0YyucjI9bf7yRhIkyg4Ru6kYU7O6fIn2JoFDzCZNkzDdsuXFGh6BXNvbu8uZUT289ERzYP1QjryMEKWzcbtsioyQApL7AgOZyFc3JJ7wvupHhIj2sqxJNtpAh7HQFG08rYh2Pb3HwOm83rbTomM6LnnjooGcoDeuWkuPqXsRlwIDAQABAoGAeQkbPBR5n9y2QLaEjcDGv7dVpFiMGHMaZZVDX34rZPy1EkZNZqlQU0jopLVvLyLESMh9A7gKhqoyMAbgZPpdb0CvniTJPpKYk24mLBeym8rBMW3XBmKk1xIOcJPGXMxeJW61jxPg6doah0aCIjf8n0Z8t8B81kLFojpECQQDzlCp0Nzka3AVZVPdBuuPg0fzeV8ugpiPEp6wQLjIMDFqYtGoAOEy4JpkmkK7zwsQsHZ8jbOtqIFdRLPrvAkEAruU321Ie1CnYCHX4Q79vLcDeWOUpdzEHp2uzDIfzP1gv7RIktGgSZWKhrnNWdeH4Y0CFb9lu6TQYJwNJvug2QJBANX0m3Uds9P9pLbQlI9WWmAtYqIZrsBElcAjOgAik0uOfawholNiw5B3ADvIYqPkLW4dGk1dO6zxW8ZF83MdMCQHGfhxLuFgsOBSfF7Bj4UX6T9FGhUGSXiqUsd06E2mMRLAjWUUUw82DLwucxMrSsV4z1aN57asC8YuQ9FkCQGirlVCt4ccXeGLCHcCsI8AYQJFRzbMs381M16jEpnaKUGrtdbMW018gWJ0EoD4tS2YZpr1hEbtiOkPJaaTKQ -``` - -You may copy and paste. What a time to be alive. - -## Walkthrough - - - - - - - - - -

javascript-practice/02_functions/exercises/A_functions_exercise/

- -### [javascript-practice/02_functions/exercises/A_functions_exercise/README.md](javascript-practice/02_functions/exercises/A_functions_exercise/README.md) -# What's your function? - -_Functions_ are constructs that allow programmers to group multiple statements together into a -single logical unit. Functions may take _arguments_ as input and return some value as output. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/g7fBqWTdeMw) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -This is where we bring well defined structure to our code. If so far we've only learned the isolated -"words", "phrases", and "sentences" of programming, we now turn our attention to the "paragraphs". - -+ [Walkthrough Part 1](https://youtu.be/hS-p8ICd7Ek) -+ [Walkthrough Part 2](https://youtu.be/pE9JYGobDQg) - --AZ - -## 0. Practice how to read. - -Before you write functions on your own, let's warm up by interpretting a few. - -Create a new folder named `A_functions_exercise`. Predict what would print when executing each of -the snippets below. Test your prediction by typing the snippet into their own files and executing -the program. Don't copy and paste. - -Write the below code into a file named `snippet-0-1.js`. Make a prediction for what it will print. -Run it. - -```js -// snippet 0-1 -let greet = function () { - console.log("hey"); - console.log("programmers"); -}; - -let whistle = function () { - console.log("doot"); -}; - -console.log("first"); -console.log("second"); -greet(); -console.log("third"); -console.log("fourth"); -whistle(); -``` - -Write the below code into a file named `snippet-0-2.js`. Make a prediction for what it will print. -Run it. - -```js -// snippet 0-2 -let howMany = function () { - return 42; -}; - -console.log(howMany); -console.log(howMany()); - -const theAnswer = howMany(); -console.log(theAnswer); - -let howMuch = function () { - 5; -}; -console.log(howMuch()); -``` - -Write the below code into a file named `snippet-0-3.js`. Make a prediction for what it will print. -Run it. - -```js -// snippet 0-3 -let average = function (num1, num2) { - console.log("calculating..."); - return (num1 + num2) / 2; -}; - -console.log(average(5, 10)); -console.log(average(20, 26)); -console.log(average(50, 100) + 2); - -let a = 21 + 3; -let b = 20; -let n = average(a, b); -console.log(average(n, 18)); -``` - -Write the below code into a file named `snippet-0-4.js`. Make a prediction for what it will print. -Run it. - -```js -// snippet 0-4 -let exclaim = function (str) { - let capitalized = str.toUpperCase(); - return capitalized + "!!"; -}; - -let result = exclaim("potato"); -console.log(result); -console.log(result.length); -console.log(result[0]); -console.log(result[result.length - 1]); -``` - -## 1. Practice how to write. - -In this section of the exercise you'll be prompted to write a function to accomplish a specific -task. Read the description and look at the example output to figure out what should be implemented -within the function. Write each function to a separate file in the `A_functions_exercise` folder and -test your work by running the file. - -### isDivBy4 - -Create an `is-div-by-4.js` file and solve the function below: - -```js -// Write a function `isDivBy4` that accepts a number as an argument. The function should return a -// boolean indicating whether or not the number is divisible by 4. - -console.log(isDivBy4(8)); // true -console.log(isDivBy4(12)); // true -console.log(isDivBy4(24)); // true -console.log(isDivBy4(9)); // false -console.log(isDivBy4(10)); // false -``` - -### keepItQuiet - -Create a `keep-it-quiet.js` file and solve the function below: - -```js -// Write a function `keepItQuiet` that accepts a string as an argument. The function should return the -// lowercase version of the string with 3 periods added to the end of it. - -console.log(keepItQuiet("HOORAY")); // 'hooray...' -console.log(keepItQuiet("Doggo")); // 'doggo...' -console.log(keepItQuiet("WHAT?!?!")); // 'what?!?!...' -``` - -### isLong - -Create an `is-long.js` file and solve the function below: - - -```js -// Write a function `isLong` that accepts a string as an argument. The function should return a boolean -// indicating whether or not the string is longer than 5 characters - -console.log(isLong("pie")); // false -console.log(isLong("kite")); // false -console.log(isLong("kitty")); // false -console.log(isLong("telescope")); // true -console.log(isLong("thermometer")); // true -console.log(isLong("restaurant")); // true -``` - -### half - -Create a `half.js` file and solve the function below: - - -```js -// Write a function `half` that accepts a number as an argument. The function should return half of the -// number. - -console.log(half(8)); // 4 -console.log(half(15)); // 7.5 -console.log(half(90)); // 45 -``` - -### endsWithT - -Create an `endsWithT.js` file and solve the function below: - -```js -// Write a function `endsWithT` that accepts a string as an argument. The function should return a -// boolean indicating whether or not the string ends with the character 't'. - -console.log(endsWithT("smart")); // true -console.log(endsWithT("racket")); // true -console.log(endsWithT("taco")); // false -console.log(endsWithT("boomerang")); // false -``` - -### average - -Create an `average.js` file and solve the function below: - - -```js -// Write a function `average` that accepts three numbers as arguments. The function should return the -// average of the three numbers. - -console.log(average(3, 10, 8)); // 7 -console.log(average(10, 5, 12)); // 9 -console.log(average(6, 20, 40)); // 22 -``` - -## Walkthrough - - - Watch it -in 1.5x speed if you like. - - - - - -

javascript-practice/02_functions/exercises/B_functions_exercise/

- -### [javascript-practice/02_functions/exercises/B_functions_exercise/README.md](javascript-practice/02_functions/exercises/B_functions_exercise/README.md) -# Functional Fitness - -_Functions_ group together statements deliberately with a purpose in mind. They should do one thing -and do it well. - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/YQjR-TSWE-U) - -Programmers write functions. You are a programmer. You write functions. - --AZ - -## Instructions - -Create a new folder named `B_functions_exercise`, this is where you'll save all of your files. Solve -each of the prompts below. Create a new file for each prompt and execute your code to see if it -matches the example output. - -### startsWithR - -Create a `starts-with-r.js` file and solve the function below: - -```js -// Write a function `startsWithR` that accepts a string as an argument and returns a boolean indicating -// whether or not the string starts with 'r' or 'R'. - -console.log(startsWithR("roger that")); // true -console.log(startsWithR("Row, row, row your boat")); // true -console.log(startsWithR("slip")); // false -console.log(startsWithR("Taxicab")); // false -``` - -### parity - -Create a `parity.js` file and solve the function below: - -```js -// Write a function `parity` that accepts a number as an argument. The function should return the -// string 'even' if the number is even. It should return the string 'odd' if the number is odd. - -console.log(parity(5)); // 'odd' -console.log(parity(7)); // 'odd' -console.log(parity(13)); // 'odd' -console.log(parity(32)); // 'even' -console.log(parity(10)); // 'even' -console.log(parity(602348)); // 'even' -``` - -### longer - -Create a `longer.js` file and solve the function below: - -```js -// Write a function `longer` that accepts two strings as arguments. The function should return the -// string that is longer. If the strings have the same length, then return the first string. - -console.log(longer("drum", "piranha")); // 'piranha' -console.log(longer("basket", "fork")); // 'basket' -console.log(longer("flannel", "sustainable")); // 'sustainable' -console.log(longer("disrupt", "ability")); // 'disrupt' -console.log(longer("bird", "shoe")); // 'bird' -``` - -### oneOrNone - -Create a `one-or-none.js` file and solve the function below: - -```js -// Write a function `oneOrNone` that accepts two booleans as arguments. The function should return true -// if exactly one of the arguments is true. If BOTH arguments are true, then it should return false. - -console.log(oneOrNone(false, false)); // false -console.log(oneOrNone(true, false)); // true -console.log(oneOrNone(false, true)); // true -console.log(oneOrNone(true, true)); // false -``` - -### endsInLy - -Create a `ends-in-ly.js` file and solve the function below: - -```js -// Write a function `endsInLy` that accepts a string as an argument and returns a boolean indicating -// whether or not the string ends in the substring 'ly'. - -console.log(endsInLy("pretty")); // false -console.log(endsInLy("instant")); // false -console.log(endsInLy("analytic")); // false -console.log(endsInLy("timidly")); // true -console.log(endsInLy("fly")); // true -console.log(endsInLy("gallantly")); // true -``` - -### funnySound - -Create a `funny-sound.js` file and solve the function below: - -```js -// Write a function `funnySound` that accepts two strings as arguments. The function should return a -// new string containing the first three characters of both strings concatenated together. - -// You can assume that the arguments are both at least three characters long. - -console.log(funnySound("tiger", "spoon")); // 'tigspo' -console.log(funnySound("computer", "phone")); // 'compho' -console.log(funnySound("skate", "bottle")); // 'skabot' -console.log(funnySound("frog", "ashtray")); // 'froash' -``` - -### stringSize - -Create a `string-size.js` file and solve the function below: - -```js -// Write a function `stringSize` that accepts a string as an argument. The function should return the -// string 'small' if the argument is shorter than 5 characters, 'medium' if it is exactly 5 characters, and -// 'large' if it is longer than 5 characters. - -console.log(stringSize("cat")); // 'small' -console.log(stringSize("bell")); // 'small' -console.log(stringSize("ready")); // 'medium' -console.log(stringSize("shirt")); // 'medium' -console.log(stringSize("shallow")); // 'large' -console.log(stringSize("intelligence")); // 'large' -``` - -### wackyWord - -Create a `wacky-word.js` file and solve the function below: - -```js -// Write a function `wackyWord` that accepts two strings as arguments. The function should return a new -// string containing the first three characters of the first string concatenated with the last two -// character of the second string. - -// You can assume that the first argument has a length of at least three and the second argument has a -// length of at least two. - -console.log(wackyWord("very", "kindly")); // 'verly' -console.log(wackyWord("forever", "sick")); // 'forck' -console.log(wackyWord("cellar", "door")); // 'celor' -console.log(wackyWord("bagel", "sweep")); // 'bagep' -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/02_functions/exercises/C_functions_exercise/

- -### [javascript-practice/02_functions/exercises/C_functions_exercise/README.md](javascript-practice/02_functions/exercises/C_functions_exercise/README.md) -# Major Malfunction - -More practice! - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/KCv1ovMB4DU) - -I think the reason why coding has a reputation for being nonintuitive is because beginners don't -spend enough time on the basics. They miss a step early, but instead of filling that gap of -knowledge, they preemptively move on. They'll stumble through more advanced topics until that debt -cannot be ignored. That is why I think it's important to exercise a concept extensively. Write code. -Run it. - --AZ - -## Instructions - -Create a new folder named `C_functions_exercise`, this is where you'll save all of your files. Solve -each of the prompts below. Create a new file for each prompt and execute your code to see if it -matches the example output. - -### divisible - -Create a `divisible.js` file and solve the function below: - -```js -// Write a function `divisible(num1, num2)` that accepts two numbers as arguments. The function should -// return a boolean indicating whether or not `num1` is divisible by `num2`. - -console.log(divisible(12, 3)); // true -console.log(divisible(12, 5)); // false -console.log(divisible(60, 4)); // true -console.log(divisible(60, 11)); // false -console.log(divisible(21, 7)); // true -console.log(divisible(21, 6)); // false -``` - -### caseChanger - -Create a `case-changer.js` file and solve the function below: - -```js -// Write a function `caseChange` that accepts a string and a boolean as arguments. The function should -// return the uppercase version of the string if the boolean is true. The function should return the -// lowercase version of the string if the boolean is false. - -console.log(caseChange("Super", true)); // 'SUPER' -console.log(caseChange("Super", false)); // 'super' -console.log(caseChange("tAmBourine", true)); // 'TAMBOURINE' -console.log(caseChange("tAmBourine", false)); // 'tambourine' -``` - -### inRange - -Create a `in-range.js` file and solve the function below: - -```js -// Write a function `inRange(min, max, n)` that accepts three numbers as arguments. The function should -// return a boolean indicating if `n` is between `min` and `max` inclusive. - -console.log(inRange(5, 13, 8)); // true -console.log(inRange(5, 13, 29)); // false -console.log(inRange(100, 125, 100)); // true -console.log(inRange(100, 125, 99)); // false -console.log(inRange(40, 45, 44)); // true -console.log(inRange(40, 45, 45)); // true -console.log(inRange(40, 45, 46)); // false -``` - -### averageOfFour - -Create an `average-of-four.js` file and solve the function below: - -```js -// Write a function `averageOfFour(num1, num2, num3, num4)` that accepts four numbers as arguments. The -// function should return the average of all four numbers. - -console.log(averageOfFour(10, 4, 12, 3)); // 7.25 -console.log(averageOfFour(-20, 50, 4, 21)); // 13.75 -console.log(averageOfFour(10, 4, 12, 3)); // 7.25 -console.log(averageOfFour(5, 5, 3, 7)); // 5 -``` - -### numberChange - -Create a `number-change.js` file and solve the function below: - -```js -// Write a function `numberChange` that accepts a number as an argument. The function should return -// half the number if it is even. The function should return double the number if it is odd. - -console.log(numberChange(6)); // 3 -console.log(numberChange(7)); // 14 -console.log(numberChange(16)); // 8 -console.log(numberChange(21)); // 42 -``` - -### larger - -Create a `larger.js` file and solve the function below: - -```js -// Write a function `larger` that accepts two numbers as arguments. The function should return the -// larger number. - -console.log(larger(256, 400)); // 400 -console.log(larger(31, 4)); // 31 -console.log(larger(-6, 7)); // 7 -console.log(larger(11.3, 11.2)); // 11.3 -console.log(larger(-10, -3)); // -3 -``` - -### contains - -Create a `contains.js` file and solve the function below: - -```js -// Write a function `contains(str1, str2)` that accepts two strings as arguments. The function should -// return a boolean indicating whether or not `str2` is contained within `str1`. The function should -// ignore any differences in capitalization. - -console.log(contains("caterpillar", "pill")); // true -console.log(contains("lion's share", "on")); // true -console.log(contains("SORRY", "or")); // true -console.log(contains("tangent", "gem")); // false -console.log(contains("clock", "ok")); // false -``` - - -## Walkthrough - - - - - - - - - -

javascript-practice/03_loops/exercises/A_loops_exercise/

- -### [javascript-practice/03_loops/exercises/A_loops_exercise/README.md](javascript-practice/03_loops/exercises/A_loops_exercise/README.md) -# In For a Loop - -_Loops_ are a construct that programmers use control the repeated execution of code. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/gs4WlW-ZQfg) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough Part 1](https://youtu.be/D_Vh-Opw-_I) -+ [Walkthrough Part 2](https://youtu.be/rlolQAocQyA) - -I think loops are great because we can type a small amount of code, but instruct the computer to -perform a lot of "work". The programmer is lazy and computer doesn't complain. What a perfect pair. - --AZ - -## 0. Read. Run. Repeat. - -Can you anticipate what these loop snippets will print out? - -Create a new folder named `A_loops_exercise`. Predict what would print when executing each of the -snippets below. Test your prediction by typing the snippet into their own files and executing the -program. Don't copy and paste. - -Write the below code into a file named `snippet-1.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 1 -console.log("hello"); - -for (let i = 0; i < 5; i++) { - console.log("code"); -} - -console.log("goodbye"); -``` - -Write the below code into a file named `snippet-2.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 2 -console.log("hi"); - -for (let i = 3; i <= 7; i++) { - console.log("program"); - console.log(i); -} - -console.log("bye"); -``` - -Write the below code into a file named `snippet-3.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 3 -let foo = function () { - for (let num = 10; num > 0; num -= 2) { - console.log(num); - } -}; - -console.log("begin"); -foo(); -console.log("end"); -foo(); -``` - -Write the below code into a file named `snippet-4.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 4 -let word = "street"; -for (let i = 0; i < word.length; i++) { - console.log(i); - console.log(word[i]); -} -``` - -Write the below code into a file named `snippet-5.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 5 -let total = 0; -for (let i = 1; i < 5; i++) { - total += i; - console.log(total); -} - -console.log("grand total: " + total); -``` - -## 1. Stay in the Loop. - -In this section of the exercise you'll be prompted to write a function to accomplish a specific -task. Read the description and look at the example output to figure out what should be implemented -within the function. Write each function to a separate file in the `A_loops_exercise` folder and -test your work by running the file. - -### oneToFour - -Create a `one-to-four.js` file and solve the function below: - -```js -// Write a function `oneToFour` that prints all whole numbers from one to four, inclusive. The function -// takes in no arguments and doesn't need to return any value. It should just print to the terminal. - -oneToFour(); -// prints -// 1 -// 2 -// 3 -// 4 -``` - -### countUp - -Create a `count-up.js` file and solve the function below: - -```js -// Write a function `countUp(max)` that accepts a max number as an argument. The function should print -// all numbers from 1 up to and including the max. The function doesn't need to return any value. It -// should just print to the terminal. - -countUp(5); -// prints -// 1 -// 2 -// 3 -// 4 -// 5 - -countUp(3); -// prints -// 1 -// 2 -// 3 -``` - -### minToMax - -Create a `min-to-max.js` file and solve the function below: - -```js -// Write a function `minToMax(min, max)` that accepts two numbers as arguments. The function should -// print all numbers from min to max inclusive. The function doesn't need to return any value. It -// should just print to the terminal. - -minToMax(5, 9); -// prints -// 5 -// 6 -// 7 -// 8 -// 9 - -minToMax(11, 13); -// prints -// 11 -// 12 -// 13 - -minToMax(20, 11); -``` - -### stringIterate - -Create a `string-iterate.js` file and solve the function below: - -```js -// Write a function `stringIterate` that accepts a string as an argument. The function should print out -// each character of the string, one by one. The function doesn't need to return any value. It should -// just print to the terminal. - -stringIterate("celery"); -// prints -// c -// e -// l -// e -// r -// y - -stringIterate("hat"); -// prints -// h -// a -// t -``` - -### evens - -Create an `evens.js` file and solve the function below: - -```js -// Write a function `evens(max)` that accepts a max number as an argument. The function should print -// all positive even numbers that are less than the max. - -evens(11); -// prints -// 2 -// 4 -// 6 -// 8 -// 10 - -evens(8); -// prints -// 2 -// 4 -// 6 -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/03_loops/exercises/B_loops_exercise/

- -### [javascript-practice/03_loops/exercises/B_loops_exercise/README.md](javascript-practice/03_loops/exercises/B_loops_exercise/README.md) -# Repetition Leads to Perfection - -More practice on `for` loops! - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/7EbhmLAH__o) - -Roses are read, violets are blue, error on line 32. - --AZ - -## Instructions - -Create a new folder named `B_loops`, this is where you'll save all of your files. Solve each of the -prompts below. Create a new file for each prompt and execute your code to see if it matches the -example output. - -### fiveMultiplesOf - -Create a `five-multiples-of.js` file and solve the function below: - - -```js -// Write a function named `fiveMultiplesOf` that accepts a number as an argument. The function should -// print out the first five multiples of the given number. The function doesn't need to return any -// value. It should just print to the terminal. - -fiveMultiplesOf(7); -// prints -// 7 -// 14 -// 21 -// 28 -// 35 - -fiveMultiplesOf(3); -// prints -// 3 -// 6 -// 9 -// 12 -// 15 -``` - -### sumUpTo - -Create a `sum-up-to.js` file and solve the function below: - - -```js -// Write a function named `sumUpTo(max)` that accepts a max number as an argument. The function should -// return the total sum of all whole numbers from 1 to the max, inclusive. -// -// For example, sumUpTo(4) should return 10 because 1 + 2 + 3 + 4 = 10. - -console.log(sumUpTo(4)); // 10 -console.log(sumUpTo(5)); // 15 -console.log(sumUpTo(2)); // 3 -``` - -### noOhs - -Create a `no-ohs.js` file and solve the function below: - - -```js -// Write a function named `noOhs` that accepts a string as an argument. The functions should print the -// characters of the string one by one except the character 'o'. The function doesn't need to return -// any value. It should just print to the terminal. - -noOhs("code"); -// prints -// c -// d -// e - -noOhs("school"); -// prints -// s -// c -// h -// l -``` - -### oddSum - -Create an `odd-sum.js` file and solve the function below: - -```js -// Write a function named `oddSum(max)` that accepts a max number as an argument. The function should -// return the total sum of all odd numbers from 1 to the max, inclusive. -// -// For example, oddSum(10) should return 25 because 1 + 3 + 5 + 7 + 9 = 25 - -console.log(oddSum(10)); // 25 -console.log(oddSum(5)); // 9 -``` - -### stringRepeater - -Create a `string-repeater.js` file and solve the function below: - - -```js -// Write a function named `stringRepeater(str, num)` that accepts a string and a number as arguments. -// The function should return a new string consisting of the `str` repeated `num` number of times. - -console.log(stringRepeater("q", 4)); // 'qqqq' -console.log(stringRepeater("go", 2)); // 'gogo' -console.log(stringRepeater("tac", 3)); // 'tactactac' -``` - -### productUpTo - -Create a `product-up-to.js` file and solve the function below: - - -```js -// Write a function named `productUpTo(max)` that accepts a max number as an argument. The function -// should return the total product of all whole numbers from 1 to the max, inclusive. A product is a -// number obtained from multiplying numbers together. -// -// For example, productUpTo(4) should return 24 because 1 * 2 * 3 * 4 = 24 - -console.log(productUpTo(4)); // 24 -console.log(productUpTo(5)); // 120 -console.log(productUpTo(7)); // 5040 -``` - -### divByEither - -Create a `div-by-either.js` file and solve the function below: - - -```js -// Write a function named `divByEither(num1, num2, max)` that accepts three numbers as arguments. -// The function should print out all positive numbers less than max that are divisible by num1 or num2. -// The function doesn't need to return any value. It should just print to the terminal. - -divByEither(4, 3, 16); -// prints -// 3 -// 4 -// 6 -// 8 -// 9 -// 12 -// 15 - -divByEither(7, 5, 20); -// prints -// 5 -// 7 -// 10 -// 14 -// 15 -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/03_loops/exercises/C_loops_exercise/

- -### [javascript-practice/03_loops/exercises/C_loops_exercise/README.md](javascript-practice/03_loops/exercises/C_loops_exercise/README.md) -# Like a Broken Record - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Lecture](https://youtu.be/3uEzx16zwIM) - -You are getting good at solving problems using loops. Let's up the difficulty. - --AZ - -## Instructions - -Create a new folder named `C_loops`, this is where you'll save all of your files. Solve each of the -prompts below. Create a new file for each prompt and execute your code to see if it matches the -example output. - -### divisibleRange - -Create a `divisible-range.js` file and solve the function below: - -```js -// Write a function `divisibleRange(min, max, num)` that accepts three numbers as arguments. The -// function should print all numbers between `min` and `max` (exclusive) that are also divisible by -// num. - -divisibleRange(17, 40, 9); -// prints -// 18 -// 27 -// 36 - -divisibleRange(10, 24, 4); -// prints -// 12 -// 16 -// 20 -``` - -### reverseIterate - -Create a `reverse-iterate.js` file and solve the function below: - -```js -// Write a function `reverseIterate` that accepts a string as an argument. The function should print -// the characters of the string one by one, in reverse order. The function doesn't need to return any -// value. It should just print to the terminal. - -reverseIterate("carrot"); -// prints -// t -// o -// r -// r -// a -// c - -reverseIterate("box"); -// prints -// x -// o -// b -``` - -### removeCapitals - -Create a `remove-capitals.js` file and solve the function below: - -```js -// Write a function `removeCapitals` that accepts a string as an argument. The function should return a -// new version of the string with all capital letters removed. - -console.log(removeCapitals("fOrEver")); // 'frver' -console.log(removeCapitals("raiNCoat")); // 'raioat' -console.log(removeCapitals("cElLAr Door")); // 'clr oor' -``` - -### raisePower - -Create a `raise-power.js` file and solve the function below: - -```js -// Write a function `raisePower(base, exponent)` that accepts two numbers, `base` and `exponent`. The -// function should return `base` raised to the `exponent` power. -// -// For example, raisePower(2, 5) should return 32 because 2 * 2 * 2 * 2 * 2 = 32 -// For example, raisePower(4, 3) should return 64 because 4 * 4 * 4 = 64 - -console.log(raisePower(2, 5)); // 32 -console.log(raisePower(4, 3)); // 64 -console.log(raisePower(10, 4)); // 10000 -console.log(raisePower(7, 2)); // 49 -``` - -### censorE - -Create a `censor-e.js` file and solve the function below: - -```js -// Write a function `censorE` that accepts a string as an argument. The function should return the a new -// version of string where all characters that are 'e's are replaced with '*'s. - -console.log(censorE("speedy")); // 'sp**dy' -console.log(censorE("pending")); // 'p*nding' -console.log(censorE("scene")); // 'sc*n*' -console.log(censorE("heat")); // 'h*at' -``` - -### fizzBuzz - -Create a `fizz-buzz.js` file and solve the function below: - -```js -// Write a function `fizzBuzz` that accepts a max number as an argument. The function should -// print all numbers less than or equal to max that are divisible by either 3 or 5 but not both 3 -// and 5. The function doesn't need to return any value. It should just print to the terminal. - -fizzBuzz(18); -// prints -// 3 -// 5 -// 6 -// 9 -// 10 -// 12 -// 18 - -fizzBuzz(33); -// prints -// 3 -// 5 -// 6 -// 9 -// 10 -// 12 -// 18 -// 20 -// 21 -// 24 -// 25 -// 27 -// 33 -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/04_arrays/exercises/A_arrays_exercise/

- -### [javascript-practice/04_arrays/exercises/A_arrays_exercise/README.md](javascript-practice/04_arrays/exercises/A_arrays_exercise/README.md) -# All Programmers Need a Raise - -_Arrays_ are a construct that programmers use to store related values in a single variable. An -_array_ contains one or more _elements_. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/ekVhX_HfbBE) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/mibav-eq9EY) - -New programmers often ask why the first index is 0 and not 1. Let's go half on it. 0.5? - --AZ - -## Instructions - -Create a new folder named `A_arrays`, this is where you'll save all of your files. Solve each of the -prompts below. Create a new file for each prompt and execute your code to see if it matches the -example output. - -### total - -Create a `total.js` file and solve the function below: - -```js -// Write a function `total` that accepts an array of numbers as an argument. The function should return -// the total sum of all elements of the array. - -console.log(total([3, 2, 8])); // 13 -console.log(total([-5, 7, 4, 6])); // 12 -console.log(total([7])); // 7 -console.log(total([])); // 0 -``` - -### stayPositive - -Create a `stay-positive.js` file and solve the function below: - -```js -// Write a function `stayPositive` that accepts an array of numbers as an argument. The function should -// return an array containing only the positive numbers. - -console.log(stayPositive([10, -4, 3, 6])); // [10, 3, 6] -console.log(stayPositive([-5, 11, -40, 30.3, -2])); // [11, 30.3] -console.log(stayPositive([-11, -30])); // [] -``` - -### bleepVowels - -Create a `bleep-vowels.js` file and solve the function below: - -```js -// Write a function `bleepVowels` that accepts a string as an argument. The function should return -// a new string where all vowels are replaced with `*`s. Vowels are the letters a, e, i, o, u. - -console.log(bleepVowels("skateboard")); // 'sk*t*b**rd' -console.log(bleepVowels("slipper")); // 'sl*pp*r' -console.log(bleepVowels("range")); // 'r*ng*' -console.log(bleepVowels("brisk morning")); // 'br*sk m*rn*ng' -``` - -### filterLongWords - -Create a `filter-long-words.js` file and solve the function below: - -```js -// Write a function `filterLongWords` that accepts an array of strings as an argument. The function -// should return a new array containing only the strings that are less than 5 characters long. - -console.log(filterLongWords(["kale", "cat", "retro", "axe", "heirloom"])); -// ['kale', 'cat', 'axe'] - -console.log(filterLongWords(["disrupt", "pour", "trade", "pic"])); -// ['pour', 'pic'] -``` - -### numOdds - -Create a `num-odds.js` file and solve the function below: - -```js -// Write a function `numOdds` that accepts an array of numbers as an argument. The function should -// return a number representing the count of odd elements in the array. - -console.log(numOdds([4, 7, 2, 5, 9])); // 3 -console.log(numOdds([11, 31, 58, 99, 21, 60])); // 4 -console.log(numOdds([100, 40, 4])); // 0 -``` - -### stringsToLengths - -Create a `strings-to-lengths.js` file and solve the function below: - -```js -// Write a function `stringsToLengths` that accepts an array of strings as an argument. The function -// should return a new array containing the lengths of the elements of the original array. - -console.log(stringsToLengths(["belly", "echo", "irony", "pickled"])); -// [5, 4, 5, 7] - -console.log(stringsToLengths(["on", "off", "handmade"])); -// [2, 3, 8] -``` - -### divisors - -Create a `divisors.js` file and solve the function below: - -```js -// Write a function `divisors` that accepts a number as an argument. The function should return an -// array containing all positive numbers that can divide into the argument. - -console.log(divisors(15)); // [1, 3, 5, 15] -console.log(divisors(7)); // [1, 7] -console.log(divisors(24)); // [1, 2, 3, 4, 6, 8, 12, 24] -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/04_arrays/exercises/B_arrays_exercise/

- -### [javascript-practice/04_arrays/exercises/B_arrays_exercise/README.md](javascript-practice/04_arrays/exercises/B_arrays_exercise/README.md) -# Arrays for Days - -More array practice! - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/M4OpbSGGnjw) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/l6dwZkBfi08) - -You may have noticed we added a few new patterns and techniques to our toolbox. The only way to get -familiar with your tools is to use them. Write code. Run it. - --AZ - -## Instructions - -Create a new folder named `B_arrays`, this is where you'll save all of your files. Solve each of the -prompts below. Create a new file for each prompt and execute your code to see if it matches the -example output. - -### makeAcronym - -Create a `make-acronym.js` file and solve the function below: - -```js -// Write a function `makeAcronym` that accepts a sentence string as an argument. The function should -// return a string containing the first character of each word in the sentence. - -console.log(makeAcronym("New York")); // NY -console.log(makeAcronym("same stuff different day")); // SSDD -console.log(makeAcronym("Laugh out loud")); // LOL -console.log(makeAcronym("don't over think stuff")); // DOTS -``` - -### reverseArray - -Create a `reverse-array.js` file and solve the function below: - -```js -// Write a function `reverseArray` that accepts an array as an argument. The function should return a -// array containing the elements of the original array in reverse order. - -console.log(reverseArray(["zero", "one", "two", "three"])); // ['three', 'two', 'one', 'zero'] -console.log(reverseArray([7, 1, 8])); // [8, 1, 7] -``` - -### yourAverageFunction - -Create a `your-average-function.js` file and solve the function below: - -```js -// Write a function `yourAverageFunction` that accepts an array of numbers as an argument. The -// function should return the average of all elements of the array. If the input array is empty, -// then the function should return null. - -console.log(yourAverageFunction([5, 2, 7, 24])); // 9.5 -console.log(yourAverageFunction([100, 6])); // 53 -console.log(yourAverageFunction([31, 32, 40, 12, 33])); // 29.6 -console.log(yourAverageFunction([])); // null -``` - -### chooseDivisibles - -Create a `choose-divisibles.js` file and solve the function below: - -```js -// Write a function `chooseDivisibles(numbers, target)` that accepts an array of numbers and a -// target number as arguments. The function should return an array containing elements of the original -// array that are divisible by the target. - -console.log(chooseDivisibles([40, 7, 22, 20, 24], 4)); // [40, 20, 24] -console.log(chooseDivisibles([9, 33, 8, 17], 3)); // [9, 33] -console.log(chooseDivisibles([4, 25, 1000], 10)); // [1000] -``` - -### maximum - -Create a `maximum.js` file and solve the function below: - -```js -// Write a function `maximum` that accepts an array of numbers as an argument. The function should -// return the largest number of the array. If the array is empty, then the function should return null. - -console.log(maximum([5, 6, 3, 7])); // 7 -console.log(maximum([17, 15, 19, 11, 2])); // 19 -console.log(maximum([])); // null -``` - -### wordCount - -Create a `word-count.js` file and solve the function below: - -```js -// Write a function `wordCount(sentence, targetWords)` that accepts a sentence string and an array of -// `targetWords`. The function should return a count of the number of words of the sentence that are -// in `targetWords`. - -console.log(wordCount("open the window please", ["please", "open", "sorry"])); // 2 -console.log(wordCount("drive to the cinema", ["the", "driver"])); // 1 -console.log(wordCount("can I have that can", ["can", "I"])); // 3 -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/04_arrays/exercises/C_arrays_exercise/

- -### [javascript-practice/04_arrays/exercises/C_arrays_exercise/README.md](javascript-practice/04_arrays/exercises/C_arrays_exercise/README.md) -# Array Buffet - -Let's do one more array exercise before we hit the next topic. - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/Whk1gGafY78) - -Remember that time at the beginning of the course where you couldn't read or write any code? Look at -you now, smarty pants. - --AZ - -## Instructions - -Create a new folder named `C_arrays`, this is where you'll save all of your files. Solve each of the -prompts below. Create a new file for each prompt and execute your code to see if it matches the -example output. - -### lengthiestWord - -Create a `lengthiest-word.js` file and solve the function below: - -```js -// Write a function `lengthiestWord` that accepts a sentence string as an argument. The function should -// return the longest word of the sentence. If there is a tie, return the word that appears later -// in the sentence. - -console.log(lengthiestWord("I am pretty hungry")); // 'hungry' -console.log(lengthiestWord("we should think outside of the box")); // 'outside' -console.log(lengthiestWord("down the rabbit hole")); // 'rabbit' -console.log(lengthiestWord("simmer down")); // 'simmer' -``` - -### alternatingCaps - -Create an `alternating-caps.js` file and solve the function below: - -```js -// Write a function `alternatingCaps` that accepts a sentence string as an argument. The function should -// return the sentence where words alternate between lowercase and uppercase. - -console.log(alternatingCaps("take them to school")); // 'take THEM to SCHOOL' -console.log(alternatingCaps("What did ThEy EAT before?")); // 'what DID they EAT before?' -``` - -### numberRange - -Create a `number-range.js` file and solve the function below: - -```js -// Write a function `numberRange(min, max, step)` that accepts three numbers as arguments, `min`, -// `max`, and `step`. The function should return all numbers between `min` and `max` at `step` intervals. -// `min` and `max` are inclusive. - -console.log(numberRange(10, 40, 5)); // [10, 15, 20, 25, 30, 35, 40] -console.log(numberRange(14, 24, 3)); // [14, 17, 20, 23] -console.log(numberRange(8, 35, 6)); // [8, 14, 20, 26, 32] -``` - -### removeShortWords - -Create a `remove-short-words.js` file and solve the function below: - -```js -// Write a function `removeShortWords` that accepts a sentence string as an argument. The function -// should return a new sentence where all of the words shorter than 4 characters are removed. - -console.log(removeShortWords("knock on the door will you")); // 'knock door will' -console.log(removeShortWords("a terrible plan")); // 'terrible plan' -console.log(removeShortWords("run faster that way")); // 'faster that' -``` - -### commonElements - -Create a `common-elements.js` file and solve the function below: - -```js -// Write a function `commonElements` that accepts two arrays as arguments. The function should return -// a new array containing the elements that are found in both of the input arrays. The order of -// the elements in the output array doesn't matter as long as the function returns the correct elements. - -let arr1 = ["a", "c", "d", "b"]; -let arr2 = ["b", "a", "y"]; -console.log(commonElements(arr1, arr2)); // ['a', 'b'] - -let arr3 = [4, 7]; -let arr4 = [32, 7, 1, 4]; -console.log(commonElements(arr3, arr4)); // [4, 7] -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/05_nesting/exercises/A_nested_loops_exercise/

- -### [javascript-practice/05_nesting/exercises/A_nested_loops_exercise/README.md](javascript-practice/05_nesting/exercises/A_nested_loops_exercise/README.md) -# Loop the Loop - -_Nested Loops_ are when we write a loop within the body of another loop. The pattern can be useful -to generate "pairs" of things. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/68VmjvtOGGI) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/seiovGIFokM) - -If you are comfortable with single loops, then you'll find nested loops pretty intuitive. Good thing -we practiced single loops a ton already. - --AZ - -## 0. Reading Nested Loops. - -Create a new folder named `A_nested_loops`, this is where you'll save all of your files. Predict -what would print when executing each of the snippets below. Test your prediction by typing the -snippet into their own files and executing the program. Don't copy and paste. - -Write the below code into a file named `snippet-1.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 1 -for (let i = 1; i <= 4; i++) { - for (let j = 1; j <= 3; j++) { - console.log(i, j); - } -} -``` - -Write the below code into a file named `snippet-2.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 2 -for (let n = 0; n < 2; n++) { - console.log("n=" + n); - for (let m = 0; m < 5; m++) { - console.log(" m=" + m); - } - console.log("n=" + n); -} -``` - -Write the below code into a file named `snippet-3.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 3 -let friends = ["philip", "abby", "phelipe", "simcha"]; - -for (let i = 0; i < friends.length; i++) { - for (let j = 0; j < friends.length; j++) { - console.log(friends[i], friends[j]); - } -} -``` - -Write the below code into a file named `snippet-4.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 4 -let locations = ["flatbush", "williamsburg", "bushwick", "greenpoint"]; - -for (let i = 0; i < locations.length; i++) { - for (let j = i + 1; j < locations.length; j++) { - console.log(locations[i], locations[j]); - } -} -``` - -Write the below code into a file named `snippet-5.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 5 -let colors = ["red", "purple", "orange"]; - -for (let i = 0; i < colors.length; i++) { - let colorStr = colors[i]; - console.log(colorStr); - - for (let j = 0; j < colorStr.length; j++) { - let char = colorStr[j]; - console.log(char); - } -} -``` - -## 1. Writing Nested Loops. - -In this section of the exercise you'll be prompted to write a function to accomplish a specific -task. Read the description and look at the example output to figure out what should be implemented -within the function. Write each function to a separate file in the `A_nested_loops_exercise` folder -and test your work by running the file. - -### pairPrint - -Create a `pair-print.js` file and solve the function below: - -```js -// Write a function `pairPrint` that accepts an array as an argument. The function should print -// all unique pairs of elements in the array. The function doesn't need to return any value. It -// should just print to the terminal. - -pairPrint(["artichoke", "broccoli", "carrot", "daikon"]); -// prints -// artichoke - broccoli -// artichoke - carrot -// artichoke - daikon -// broccoli - carrot -// broccoli - daikon -// carrot - daikon - -pairPrint(["apple", "banana", "clementine"]); -// prints -// apple - banana -// apple - clementine -// banana - clementine -``` - -### printCombinations - -Create a `print-combinations.js` file and solve the function below: - -```js -// Write a function `printCombinations`that accepts two arrays as arguments. The function should -// print all combinations of the elements generated by taking an element from the first array and -// and an element from the second array. The function doesn't need to return any value. It -// should just print to the terminal. - -let colors = ["gray", "cream", "cyan"]; -let clothes = ["shirt", "flannel"]; -printCombinations(colors, clothes); -// prints -// gray shirt -// gray flannel -// cream shirt -// cream flannel -// cyan shirt -// cyan flannel - -printCombinations(["hot", "cold"], ["soup", "tea"]); -// prints -// hot soup -// hot tea -// cold soup -// cold tea -``` - -### twoSum - -Create a `two-sum.js` file and solve the function below: - -```js -// Write a function `twoSum(numbers, target)` that accepts an array of numbers and a target number -// as an argument. The function should return a boolean indicating whether or not there exists a pair -// of distinct elements in the array that sum to the target. - -console.log(twoSum([2, 3, 5, 9], 7)); // true -console.log(twoSum([2, 3, 5, 9], 4)); // false -console.log(twoSum([6, 3, 4], 10)); // true -console.log(twoSum([6, 5, 1], 10)); // false -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/05_nesting/exercises/B_two_dimensional_arrays_exercise/

- -### [javascript-practice/05_nesting/exercises/B_two_dimensional_arrays_exercise/README.md](javascript-practice/05_nesting/exercises/B_two_dimensional_arrays_exercise/README.md) -# Adding a New Dimension - -A _two-dimensional array_ is an array that contains other arrays as elements. Programmers use -multidimensional arrays when dealing with data that has many layers. It is also useful to represent -a grid space. - -Before you start this exercise, make sure you have watched the lecture first. - -+ [Lecture](https://youtu.be/CDpJ4PIWAlE) - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -+ [Walkthrough](https://youtu.be/ajSXu2D2gzg) - -Loops in loops? Arrays in arrays? What's next, functions in functions? - --AZ - -## Instructions - -Create a new folder named `B_two_dimensional_arrays_exercise`, this is where you'll save all of your -files. Solve each of the prompts below. Create a new file for each prompt and execute your code to -see if it matches the example output. - -Heads up. Not all of the problems below require 2D arrays. It's up to you to figure out what is the -right tool for the job. - -### print2d - -Create a `print-2d.js` file and solve the function below: - -```js -// Write a function `print2d` that accepts a two-dimensional array as an argument. The function -// should print all inner elements of the array. - -let array1 = [ - ["a", "b", "c", "d"], - ["e", "f"], - ["g", "h", "i"], -]; -print2d(array1); -// prints -// a -// b -// c -// d -// e -// f -// g -// h -// i - -let array2 = [[9, 3, 4], [11], [42, 100]]; -print2d(array2); -// prints -// 9 -// 3 -// 4 -// 11 -// 42 -// 100 -``` - -### makeMatrix - -Create a `make-matrix.js` file and solve the function below: - -```js -// Write a function `makeMatrix(m, n, value)` that accepts three arguments. The function should return -// a 2-dimensional array of height `m` and width `n` that contains the `value` as every element. - -console.log(makeMatrix(3, 5, null)); -// [ -// [ null, null, null, null, null ], -// [ null, null, null, null, null ], -// [ null, null, null, null, null ] -// ] - -console.log(makeMatrix(4, 2, "x")); -// [ -// [ 'x', 'x' ], -// [ 'x', 'x' ], -// [ 'x', 'x' ], -// [ 'x', 'x' ] -// ] - -console.log(makeMatrix(2, 2, 0)); -// [ -// [ 0, 0 ], -// [ 0, 0 ] -// ] -``` - -### totalProduct - -Create a `total-product.js` file and solve the function below: - -```js -// Write a function `totalProduct(array)` that accepts a 2D array of numbers. The function should return -// the total product of all numbers in the array. - -let array1 = [ - [3, 5, 2], - [6, 2], -]; -console.log(totalProduct(array1)); // 360 - -let array2 = [ - [4, 6], - [2, 3], - [1, 2], -]; -console.log(totalProduct(array2)); // 288 -``` - -### twoSumPairs - -Create a `two-sum-pairs.js` file and solve the function below: - -```js -// Write a function `twoSumPairs(numbers, target)` that accepts an array of numbers and a target number -// as arguments. The function should return a 2D array containing all unique pairs of elements that -// sum to the target. - -console.log(twoSumPairs([2, 3, 4, 6, 5], 8)); // [ [2, 6], [3, 5] ] -console.log(twoSumPairs([10, 7, 4, 5, 2], 12)); // [ [10, 2], [7, 5] ] -console.log(twoSumPairs([3, 9, 8], 11)); // [ [3, 8] ] -console.log(twoSumPairs([3, 9, 8], 10)); // [ ] -``` - -### zipper - -Create a `zipper.js` file and solve the function below: - -```js -// Write a function `zipper` that accepts two arrays as arguments. The function should return a 2D -// array containing pairs of elements at the same indices. You can assume that the arrays have the -// same length. - -let array1 = ["a", "b", "c", "d"]; -let array2 = [-1, -2, -3, -4]; -console.log(zipper(array1, array2)); -// [ -// ['a', -1], -// ['b', -2], -// ['c', -3], -// ['d', -4], -// ] - -let array3 = ["whisper", "talk", "shout"]; -let array4 = ["quiet", "normal", "loud"]; -console.log(zipper(array3, array4)); -// [ -// ['whisper', 'quiet'], -// ['talk', 'normal'], -// ['shout', 'loud'], -// ] -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/05_nesting/exercises/C_more_problems_exercise/

- -### [javascript-practice/05_nesting/exercises/C_more_problems_exercise/README.md](javascript-practice/05_nesting/exercises/C_more_problems_exercise/README.md) -# Problems Make Perfect - -More problems `===` more practice. - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -I'll keep writing problems if you keep coding. Deal? - --AZ - -## Instructions - -Create a new folder named `C_more_problems`, this is where you'll save all of your files. Solve each -of the prompts below. Create a new file for each prompt and execute your code to see if it matches -the example output. - -This problem set tests a few different concepts. Any concepts we've covered are fair game. Some of -the following problems are tough, but they only require knowledge of concepts we've already covered. -Give them a shot. - -### removeDupes - -Create a `remove-dupes.js` file and solve the function below: - -```js -// Write a function `removeDupes` that accepts an array as an argument. The function should return a -// new array where each element only appears once. - -console.log(removeDupes(["x", "y", "y", "x", "z"])); // ['x', 'y', 'z'] -console.log(removeDupes([false, false, true, false])); // [false, true] -console.log(removeDupes([42, 5, 7, 42, 7, 3, 7, 7])); // [42, 5, 7, 3] -``` - -### removeVowels - -Create a `remove-vowels.js` file and solve the function below: - -```js -// Write a function `removeVowels` that accepts a string as an argument. The function should return -// a version of the string where all vowels are removed. - -console.log(removeVowels("jello")); // jll -console.log(removeVowels("sensitivity")); // snstvty -console.log(removeVowels("cellar door")); // cllr dr -``` - -### spam - -Create a `spam.js` file and solve the function below: - -```js -// Write a function `spam` that accepts a 2D array as an argument. The array contains pairs as elements. -// The first element of every pair is a number and the second element is a word. The function should -// return a string containing the words repeated the specified number of times. See the examples. - -let array1 = [ - ["hi", 3], - ["bye", 2], -]; -console.log(spam(array1)); // 'hi hi hi bye bye' - -let array2 = [ - ["cat", 1], - ["dog", 2], - ["bird", 4], -]; -console.log(spam(array2)); // 'cat dog dog bird bird bird bird' -``` - -### removeFirstVowel - -Create a `remove-first-vowel.js` file and solve the function below: - -```js -// Write a function `removeFirstVowel` that accepts a string as an argument. The function should return -// the string with it's first vowel removed. - -console.log(removeFirstVowel("volcano")); // 'vlcano' -console.log(removeFirstVowel("celery")); // 'clery' -console.log(removeFirstVowel("juice")); // 'jice' -``` - -### shortenLongWords - -Create a `shorten-long-words.js` file and solve the function below: - -```js -// Write a function `shortenLongWords` that accepts a sentence string as an argument. The function -// should return the same sentence where words longer than 4 characters have their vowels removed. - -console.log(shortenLongWords("they are very noble people")); // 'they are very nbl ppl' -console.log(shortenLongWords("stick with it")); // 'stck with it' -console.log(shortenLongWords("ballerina, you must have seen her")); // 'bllrna, you must have seen her' -``` - - - - - -

javascript-practice/06_decomposition_pattern/A_decomposing_problems_exercise/

- -### [javascript-practice/06_decomposition_pattern/A_decomposing_problems_exercise/README.md](javascript-practice/06_decomposition_pattern/A_decomposing_problems_exercise/README.md) -# Dividing and Conquering - -_Decomposition_ is a pattern that programmers use to take a complex problem and break it down into -smaller sub-problems that can be managed better individually. - -Before you start this exercise, make sure you have watched the lecture first. - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -This is might be my favorite topic. I think it's very high leverage because it is relatively easy to -implement but greatly increases the elegance of your code. Prefer to solve complex problems with -simple solutions. - --AZ - -## 0. Composition - -Create a new folder named `A_decomposing_problems_exercise`, this is where you'll save all of your -files. Predict what would print when executing each of the snippets below. Test your prediction by -typing the snippet into their own files and executing the program. Don't copy and paste. - -Write the below code into a file named `snippet-1.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 1 - -let flim = function () { - console.log("leak"); - flam(); - console.log("geek"); -}; - -let flam = function () { - console.log("beak"); - console.log("sneak"); -}; - -flim(); -``` - -Write the below code into a file named `snippet-2.js`. Make a prediction for what it will print. Run -it. - -```js -let alice = function (n) { - for (let i = 0; i <= n; i++) { - bob(i); - } -}; - -let bob = function (n) { - if (n % 2 === 0) { - console.log("good"); - } else { - console.log("bad"); - } -}; - -alice(4); -``` - -Write the below code into a file named `snippet-3.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 3 - -let foo = function () { - for (let i = 0; i < 5; i++) { - console.log("i = " + i); - bar(); - } -}; - -let bar = function () { - for (let j = 0; j < 5; j++) { - console.log(" j = " + j); - } -}; - -foo(); -``` - -## 1. Decomposition - -In this section of the exercise you'll be prompted to write a function to accomplish a specific -task. Read the description and look at the example output to figure out what should be implemented -within the function. Write each function to a separate file in the `A_decomposing_problems_exercise` -folder and test your work by running the file. - -Some (but not all) of the problems below should be decomposed with a helper function. - -### doubleVowel - -Create a `double-vowel.js` file and solve the function below: - -```js -// Write a function `doubleVowel` that accepts a string as an argument. The function should return -// the string where every occurrence of a vowel in the original string is repeated twice consecutively. -// Vowels are the letters a, e, i, o, u. - -console.log(doubleVowel("runner")); // 'ruunneer' -console.log(doubleVowel("stoplight")); // 'stoopliight' -console.log(doubleVowel("gardener")); // 'gaardeeneer' -``` - -### funnyPhrase - -Create a `funny-phrase.js` file and solve the function below: - -```js -// Write a function `funnyPhrase` that accepts a sentence string as an argument. The function should -// return the sentence where every other word has its vowels repeated twice consecutively. -// Vowels are the letters a, e, i, o, u. - -console.log(funnyPhrase("she dreamed of being a runner")); // 'she dreeaameed of beeiing a ruunneer' -console.log(funnyPhrase("park near the stoplight")); // 'park neeaar the stoopliight' -console.log(funnyPhrase("we need many gardeners")); // 'we neeeed many gaardeeneers' -``` - -### isPrime - -Create an `is-prime.js` file and solve the function below: - -```js -// Write a function `isPrime` that accepts a number as an argument. The function should return a -// boolean indicating whether or not the given number is prime. A prime number is a number that is -// only divisible by 1 and itself. The smallest prime number is 1. -// -// For example, 11 is a prime because it is only divisible by 1 and 11. -// For example, 8 is not a prime because it is divisible by 1, 2, 4, and 8 - -console.log(isPrime(11)); // true -console.log(isPrime(8)); // false -console.log(isPrime(7)); // true -console.log(isPrime(21)); // false -console.log(isPrime(2)); // true -console.log(isPrime(15)); // false -console.log(isPrime(1)); // false -``` - -### pickPrimes - -Create a `pick-primes.js` file and solve the function below: - -```js -// Write a function `pickPrimes` that accepts an array of numbers as an argument. The function should -// return an array containing only the prime numbers. A prime number is a number that is -// only divisible by 1 and itself. The smallest prime number is 1. - -console.log(pickPrimes([12, 3, 7, 18, 11])); // [3, 7, 11] -console.log(pickPrimes([17, 23, 9, 42])); // [17, 23] -console.log(pickPrimes([4, 2048, 100, 55])); // [] -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/06_decomposition_pattern/B_decomposing_problems_exercise/

- -### [javascript-practice/06_decomposition_pattern/B_decomposing_problems_exercise/README.md](javascript-practice/06_decomposition_pattern/B_decomposing_problems_exercise/README.md) -# Predisposed to Decompose - -More practice on decomposing! - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -Write code. Run it. - --AZ - -## Instructions - -Create a new folder named `B_decomposing_problems_exercise`, this is where you'll save all of your -files. Solve each of the prompts below. Create a new file for each prompt and execute your code to -see if it matches the example output. - -Some (but not all) of the problems below should be decomposed with a helper function. - -### removeLastVowel - -Create a `remove-last-vowel.js` file and solve the function below: - -```js -// Write a function `removeLastVowel` that accepts a string as argument. The function should return -// the string with its last vowel removed. Vowels are the letters a, e, i, o, u - -console.log(removeLastVowel("speaker")); // 'speakr' -console.log(removeLastVowel("trading")); // 'tradng' -console.log(removeLastVowel("thunder")); // 'thundr' -console.log(removeLastVowel("myth")); // 'myth' -``` - -### pickPrefix - -Create a `pick-prefix.js` file and solve the function below: - -```js -// Write a function `pickPrefix(strings, prefix)` that accepts an array of strings and a prefix string -// as an argument. The function should return the an array of words that begin with the prefix. - -console.log(pickPrefix(['connect', 'company', 'concert', 'cram'], 'con')); -// ['connect', 'concert'] - -console.log(pickPrefix(['miner', 'mistake', 'misspeak', 'moose', 'mission'], 'mis')); -// [''mistake', 'misspeak', 'mission'] -``` - -### trendyText - -Create a `trendy-text.js` file and solve the function below: - -```js -// Write a function `trendyText` that accepts a sentence string as an argument. The function should -// return the sentence where the last vowel of every word is removed. - -console.log(trendyText("the concert will be epic")); // 'th concrt wll be epc' -console.log(trendyText("breakfast food is wonderful")); // 'breakfst fod s wonderfl' -console.log(trendyText("the weather will improve hopefully")); // 'th weathr wll improv hopeflly' -``` - -### mostLetterWord - -Create a `most-letter-word` file and solve the function below: - -```js -// Write a function `mostLetterWord` that accepts a sentence string and a character as arguments. -// The function should return the word of the sentence that contains the character the most number -// of times. You can assume that the sentence contains at least one word. If there is a tie, return -// the word that appears earlier in the sentence. - -console.log(mostLetterWord('she received an award for excellence in science', 'e')); // 'excellence' -console.log(mostLetterWord('she received an award for excellence in science', 'a')); // 'award' -console.log(mostLetterWord('I hope sophomore year comes soon', 'o')); // 'sophomore' -console.log(mostLetterWord('I hope sophomore year comes soon', 's')); // 'sophomore' -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/06_decomposition_pattern/C_decomposing_problems_exercise/

- -### [javascript-practice/06_decomposition_pattern/C_decomposing_problems_exercise/README.md](javascript-practice/06_decomposition_pattern/C_decomposing_problems_exercise/README.md) -# Building It Up By Breaking It Down - -Three reasons why you'll improve as a programmer. You won't believe number 3! - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -I'm going to make you practice so much that you wish you had never subscribed. - --AZ - -## Instructions - -Create a new folder named `C_decomposing_problems_exercise`, this is where you'll save all of your -files. Solve each of the prompts below. Create a new file for each prompt and execute your code to -see if it matches the example output. - -### lalaLanguage - -Create a `lala-language.js` file and solve the function below: - -```js -// Write a function `lalaLanguage` that accepts a sentence string as an argument. The function should -// return a new sentence where words longer that 3 characters are modified. Modified words should have -// each vowel followed by 'l' and the same vowel repeated again. See the examples. - -console.log(lalaLanguage('this is pretty strange')); // 'thilis is preletty stralangele' -console.log(lalaLanguage('can you speak our language')); // 'can you spelealak our lalangulualagele' -``` - -### pickPerfectSquares - -Create a `pick-perfect-squares.js` file and solve the function below: - -```js -// Write a function `pickPerfectSquares` that accepts an array of numbers as an argument. The function -// should return an array containing only the elements that are perfect squares. A perfect square -// is a number that can result from multiplying some number by itself. -// -// For example, 4 is a perfect square because 2 * 2 = 4 -// For example, 81 is a perfect square because 9 * 9 = 81 - -console.log(pickPerfectSquares([6, 4, 81, 21, 36])); // [4, 81, 36] -console.log(pickPerfectSquares([100, 24, 144])); // [100, 144] -console.log(pickPerfectSquares([30, 25])); // [25] -``` - -### censorSentence - -Create a `censor-sentence.js` file and solve the function below: - -```js -// Write a function `censorSentence(sentence, targetWords)` that accepts a sentence string and an array -// of target words as arguments. The function should return a new sentence where any target words -// have all of their characters replaced with '*'s. - -console.log(censorSentence('where the heck is my celery', ['heck', 'celery'])); -// 'where the **** is my ******' - -console.log(censorSentence('why you little sweetheart', ['sweetheart', 'salad'])); -// 'why you little **********' -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/07_objects/A_objects_exercise/

- -### [javascript-practice/07_objects/A_objects_exercise/README.md](javascript-practice/07_objects/A_objects_exercise/README.md) -# An Objective Perspective - -_Objects_ are a construct programmers use to represent entities and the properties they possess. -Whereas arrays use numbers to index their values, _objects_ use strings to index their values. These -strings are referred to as _keys_. - -Before you start this exercise, make sure you have watched the lecture first. - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -As you grow into a web developer, you'll be dealing with objects a **ton**. I also like teaching -objects because I get to use obscure references in my examples. - --AZ - -## 0. Objects In Mirror Are Closer Then They Appear. - -Create a new folder named `A_objects_exercise`, this is where you'll save all of your files. Predict -what would print when executing each of the snippets below. Test your prediction by typing the -snippet into their own files and executing the program. Don't copy and paste. - -Write the below code into a file named `snippet-1.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 1 -let movie = { - title: "Fight Club", - year: 1999, - genre: ["drama", "thriller"], - starring: ["Brad Pitt", "Edward Norton"], -}; - -console.log(movie.year); -console.log(movie["title"]); -console.log(movie.genre); -console.log(movie.genre[0]); -console.log(movie.genre[1]); - -console.log(movie.duration); -console.log(movie["starring"][1]); -console.log(movie.starring.length); -``` - -Write the below code into a file named `snippet-2.js`. Make a prediction for what it will print. Run - -```js -// snippet 2 -let restaurant = { - name: "Bob's Burgers", - location: "123 Ocean Avenue", - owners: ["Bob Belcher", "Linda Belcher"], - established: 2011, - menu: ["burgers", "fries", "shakes"], -}; - -console.log("owners" in restaurant); -console.log("employees" in restaurant); - -let someKey = "menu"; -console.log(someKey in restaurant); - -console.log(restaurant.menu); -console.log(restaurant["menu"]); -console.log(restaurant[someKey]); -console.log(restaurant.someKey); - -console.log(restaurant.menu.includes("fries")); -``` - -Write the below code into a file named `snippet-3.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 3 -let dog = { - name: "Manny", - age: 5, - breed: "pug", - color: "fawn", - favoriteFoods: ["bacon"], -}; - -console.log(dog.age); -console.log(dog.breed); -console.log(dog.favoriteFoods); - -dog.age++; -dog.breed = dog.breed.toUpperCase(); -dog.favoriteFoods.push("sausage"); - -console.log(dog.age); -console.log(dog.breed); -console.log(dog.favoriteFoods); - -for (let property in dog) { - console.log(property + " is " + dog[property]); -} -``` - -Write the below code into a file named `snippet-4.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet 4 -let recipe = { - name: "Old Fashioned Pancakes", - difficulty: "easy", - tasty: true, - ingredients: ["eggs", "milk", "butter", "flour", "sugar"], -}; - -console.log(recipe.name); -console.log(recipe["name"]); -console.log(recipe.ingredients.length); -console.log(recipe.calories); - -let someVariable = "difficulty"; -console.log(recipe[someVariable]); -console.log(recipe.someVariable); - -for (let i = 0; i < recipe.ingredients.length; i++) { - console.log(recipe.ingredients[i]); -} -``` - -## 1. I Object, Your Honor. - -In this section of the exercise you'll be prompted to write a function to accomplish a specific -task. Read the description and look at the example output to figure out what should be implemented -within the function. Write each function to a separate file in the `A_objects_exercise` folder and -test your work by running the file. - -### emailParse - -Create a `email-parse.js` file and solve the function below: - -```js -// Create a function `emailParse` that accepts an email address string as an argument. The function -// should return an object containing `username` and `domain` as keys. See the examples. -// You can assume that the argument will be a valid email address. - -console.log(emailParse("coolcoder42@goodmail.com")); -// { username: 'coolcoder42', domain: 'goodmail.com' } - -console.log(emailParse("az@woohoomail.com")); -// { username: 'az', domain: 'woohoomail.com' } - -console.log(emailParse("1337pr0graMmer@coldmail.edu")); -// { username: '1337pr0graMmer', domain: 'coldmail.edu' } -``` - -### keyPair - -Create a `key-pair.js` file and solve the function below: - -```js -// Write a function `keyPair(obj1, obj2, key)` that accepts two objects and a key string as arguments. -// The function should return an array containing the values of the given key in `obj1` and `obj2`. -// See the examples. - -let cat1 = { name: "jinkee", breed: "calico" }; -let cat2 = { name: "garfield", breed: "red tabby" }; -console.log(keyPair(cat1, cat2, "breed")); // [ 'calico', 'red tabby' ] -console.log(keyPair(cat1, cat2, "name")); // [ 'jinkee', 'garfield ] - -let sport1 = { name: "volleyball", team: true }; -let sport2 = { name: "golf", team: false }; -console.log(keyPair(sport1, sport2, "team")); // [ true, false ] -``` - -### elementQuantities - -Create a `element-quantities.js` file and solve the function below: - -```js -// Create a function `elementQuantities` that accepts an object as an argument. The object contains -// elements as keys and quantities as values. The function should return an array containing the elements -// appearing with the correct quantities. See the examples. - -let quantities1 = { cat: 3, bird: 1, dog: 2 }; -console.log(elementQuantities(quantities1)); // ['cat', 'cat', 'cat', 'bird, 'dog', 'dog'] - -let quantities2 = { blue: 3, brown: 1 }; -console.log(elementQuantities(quantities2)); // ['blue', 'blue', 'blue', 'brown'] -``` - -### maxObjectValue - -Create a `max-object-value.js` file and solve the function below: - -```js -// Write a function `maxObjectValue` that accepts an object as an argument. Write a function that -// returns an array containing the key, value pair for the largest value within the object. You can -// assume that all values are numbers and there are no ties. - -console.log(maxObjectValue({ a: 5, b: 2, c: 6, d: 7, e: 4 })); // ['d', 7] -console.log(maxObjectValue({ lychee: 11, rambutan: 13, papaya: 9 })); // ['rambutan', 13] -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/07_objects/B_objects_exercise/

- -### [javascript-practice/07_objects/B_objects_exercise/README.md](javascript-practice/07_objects/B_objects_exercise/README.md) -# Object Obsession - -More practice on JavaScript objects! - -Before you start this exercise, make sure you have watched the lecture first. - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -Keep practicing. Hopefully you are practicing everyday. Consistency beats intensity given a long -enough timeline. If want to become proficient quickly, then practice intensely and consistently. - --AZ - -## Instructions - -Create a new folder named `B_objects_exercise`, this is where you'll save all of your files. Solve -each of the prompts below. Create a new file for each prompt and execute your code to see if it -matches the example output. - -### characterCount - -Create a `character-count.js` file and solve the function below: - -```js -// Write a function `characterCount` that accepts a string as an argument. The function should return -// an object containing the count of characters in the string. - -console.log(characterCount("evening")); // { e: 2, v: 1, n: 2, i: 1 , g: 1 } -console.log(characterCount("mississippi")); // { m: 1, i: 4, s: 4, p: 2 } -console.log(characterCount("chili")); // { c: 1, h: 1, i: 2, l: 1 } -``` - -### letterMap - -Create a `letter-map.js` file and solve the function below: - -```js -// Write a function `letterMap` that accepts a string and an object as arguments. The function should -// return a version of the string where characters that appear as keys in object are replaced with -// their corresponding values. - -console.log(letterMap("symbolic", { y: "i", o: "a", c: "k" })); // 'simbalik' -console.log(letterMap("colossal", { o: "x", s: "p" })); // 'cxlxppal' -console.log(letterMap("miniscule", { u: "t", i: "f", e: "q" })); // 'mfnfsctlq' -``` - -### mostCommonLetter - -Create a `most-common-letter.js` file and solve the function below: - -```js -// Write a function `mostCommonLetter` that accepts a string as an argument. The function should return -// the character that appears most frequently in the string. You can assume that there are no ties. - -console.log(mostCommonLetter("building")); // 'i' -console.log(mostCommonLetter("shoestring")); // 's' -console.log(mostCommonLetter("preparedness")); // 'e' -``` - -### wordReplace - -Create a `word-replace.js` file and solve the function below: - -```js -// Write a function `wordReplace` that accepts a sentence string and an object as arguments. The -// function should return a new sentence where words that are keys of the object are replaced with -// their corresponding values. - -console.log(wordReplace("I never take naps during the day", { never: "always", day: "weekend" })); -// 'I always take naps during the weekend' - -console.log(wordReplace("the park is closed", { closed: "open", the: "a" })); -// 'a park is open' - -console.log(wordReplace("I do what I want", { I: "we", cat: "dog" })); -// 'we do what we want' -``` - -### getAverageAge - -Create a `get-average-age.js` file and solve the function below: - -```js -// Write a function `getAverageAge` function that accepts an array of objects representing people. -// The function should return the average age of the people. - -let peeps = [ - { name: "Lovelace", age: 36, born: "London, UK" }, - { name: "Kleene", age: 85, born: "Connecticut, US" }, - { name: "Turing", age: 41, born: "London, UK" }, - { name: "Hopper", age: 85, born: "New York, US" }, -]; -console.log(getAverageAge(peeps)); // 61.75 - -let people = [ - { name: "Orwell", age: 46, born: "Bihar, India" }, - { name: "Bradbury", age: 91, born: "California, US" }, - { name: "Huxley", age: 69, born: "California, US" }, -]; -console.log(getAverageAge(people)); // 86.66 -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/07_objects/C_objects_exercise/

- -### [javascript-practice/07_objects/C_objects_exercise/README.md](javascript-practice/07_objects/C_objects_exercise/README.md) -# Obnoxious Objects - -Still more exercises on JavaScript objects! - -Before you start this exercise, make sure you have watched the lecture first. - -If you get stuck during this exercise, reference this walkthrough. Only watch enough of the -walkthrough to get yourself unstuck, then pause the video and pick up the exercise on your own. - -Practice, practice, practice, practice. - --AZ - -## Instructions - -Create a new folder named `C_objects_exercise`, this is where you'll save all of your files. Solve -each of the prompts below. Create a new file for each prompt and execute your code to see if it -matches the example output. - -### greatestPopulation - -Create a `greatest-population.js` file and solve the function below: - -```js -// Write a function `greatestPopulation` that accepts an array of country objects as an argument. -// The function should return the name of the country that has the largest population. -// You can assume that the array contains at least one country. - -let countries1 = [ - { name: "Cameroon", population: 27744989, gdp: 38.68 }, - { name: "Belarus", population: 9477918, gdp: 59.66 }, - { name: "Indonesia", population: 267026366, gdp: 1042 }, - { name: "Guyana", population: 750204, gdp: 3.88 }, -]; - -console.log(greatestPopulation(countries1)); // 'Indonesia' - -let countries1 = [ - { name: "New Zealand", population: 4925477, gdp: 204.9 }, - { name: "Mozambique", population: 30098197, gdp: 14.72 }, - { name: "Greenland", population: 57616, gdp: 2.71 }, - { name: "Kazakhstan", population: 19091949, gdp: 179.3 }, - { name: "Burma", population: 56590071, gdp: 71.21 }, -]; - -console.log(greatestPopulation(countries2)); // 'Burma' -``` - -### pluck - -Create a `pluck.js` file and solve the function below: - -```js -// Write a function `pluck` that accepts an object and an array of strings as an argument. The function -// should return a new object containing the keys of the original object that are found in the array. - -console.log(pluck({name: 'Fido', color: 'Brown', breed: 'German Shepherd'}, ['name', 'breed'])); -// { name: 'Fido', breed: 'German Shepherd' } - -console.log(pluck({ make: 'Tesla', mpg: 93 , model: 'Model X', color: 'white' }, ['make', 'model'])); -// { make: 'Tesla', model: 'Model X' } -``` - -### objectAdd - -Create a `object-add.js` file and solve the function below: - -```js -// Write a function `objectAdd` that accepts two objects as arguments. The function should return -// a new object containing the same keys as the object arguments. If a key is found in both -// objects, its corresponding value should be the sum of the values in the object arguments. If a key -// is only found in one of the objects, then it's corresponding value should be the same as that one -// object. - -let obj1 = { x: 3, y: 10}; -let obj2 = { y: 2, x: 1}; -console.log(objectAdd(obj1, obj2)); // { x: 4, y: 12 } - -let obj3 = { a: 3, b: 2, c: -1}; -let obj4 = { b: 5, c: 1, e: 4}; -console.log(objectAdd(obj3, obj4)); // { a: 3, b: 7, c: 0, e: 4 } -``` - -### secretCipher - -Create a `secret-cipher.js` file and solve the function below: - -```js -// Write a function `secretCipher` that accepts a string and an object as arguments. The function -// should return a new string where characters of the original string are replaced with their -// corresponding values in the object. If a character of the string does not exist as a key of the -// object, then it should be replaced with a question mark (?). - -console.log(secretCipher("jello", { j: "r", l: "s", e: "i" })); // 'riss?' -console.log(secretCipher("lantern", { e: "o", l: "p", n: "m", r: "j" })); // 'p?m?ojm' -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/08_higher_order_functions/A_native_callback_methods_exercise/

- -### [javascript-practice/08_higher_order_functions/A_native_callback_methods_exercise/README.md](javascript-practice/08_higher_order_functions/A_native_callback_methods_exercise/README.md) -# Native Callback Methods Exercise - -There are a handful of useful array methods utilizing callbacks that are built into JavaScript. The -`forEach`, `map`, `filter`, `every`, and `some` methods can implement common patterns -quickly. These methods can greatly clean up our code if we master their usage. - -In my experience teaching, students are somewhat resistant to learning this new topic because they -can "solve" these same problems utilizing just the basics that they are already comfortable with. -You _could_ forgo these methods in favor of manually implementing the target behavior with a -nothing-fancy loop, however these methods will become very useful if you have the patience to learn -them. They are also a fairly common topic in software engineering job interviews. There is much -discomfort that comes with learning something new. Practice until it's comfortable. - --AZ - -### 0. Interpret. - -Create a new folder named `A_native_callback_methods_exercise`, this is where you'll save all of -your files. Predict what would print when executing each of the snippets below. Test your prediction -by typing the snippet into their own files and executing the program. Don't copy and paste. - -Write the below code into a file named `snippet-1.js`. Make a prediction for what it will print. Run -it. - -```js -// snippet-1 -let foo = function (s) { - return s.slice(1).toUpperCase(); -}; - -let arr = ['mashy', 'brando', 'thanasi']; -let res = arr.map(foo); -console.log(res); -``` - -```js -// snippet-2 -let friends = ['nader', 'matty', 'jennifer', 'lora']; - -let chosen = friends[0]; - -friends.forEach(function (friend) { - if (friend.length > chosen.length) { - chosen = friend; - } -}); - -console.log(chosen); -``` - -```js -// snippet-3 -let isEven = function (n) { - return n % 2 === 0; -}; - -let isOdd = function (n) { - return !isEven(n); -}; - -let nums1 = [42, 3, 8, 9]; -console.log(nums1.filter(isEven)); -console.log(nums1.map(isOdd)); -``` - -```js -// snippet-4 -let doggos = [ - { name: 'bella', type: 'canine', age: 4, breed: 'yorkshire terrier' }, - { name: 'manny', type: 'canine', age: 2, breed: 'pug' }, - { name: 'yoshi', type: 'canine', age: 3, breed: 'german shepherd' }, - { name: 'blossom', type: 'canine', age: 3, breed: 'german shepherd' } -]; - -let result1 = doggos.every(function (ele) { - return ele.type === 'canine'; -}); - -console.log(result1); - -let result2 = doggos.every(function (ele) { - return ele.breed === 'german shepherd'; -}); - -console.log(result2); - -let result3 = doggos.some(function (ele) { - return ele.breed === 'german shepherd'; -}); - -console.log(result3); - -let isOld = function (person) { - return person.age > 5; -}; - -let result4 = doggos.some(isOld); - -console.log(result4); -``` - -### 1. Solve. - -Solve each of the prompts below. Create a new file for each prompt and execute your code to see if it -matches the example output. - -### forEachSum - -Create a `for-each-sum.js` file and solve the function below: - -```js -// Write a function `forEachSum` that accepts an array of numbers as an argument and returns the total -// sum of all numbers. -// Your function must utilize the native Array#forEach method. - -console.log(forEachSum([10, 3, 5])); // 18 -console.log(forEachSum([-6, 7, 9, 4])); // 14 -console.log(forEachSum([])); // 0 -``` - -### pickAdults - -Create a `pick-adults.js` file and solve the function below: - -```js -// Write a function `pickAdults` that accepts an array of person objects and returns the objects that -// have an age of at least 18. -// Your function must utilize the native Array#filter method. - -let people = [ - { name: 'alice', age: 22 }, - { name: 'bob', age: 37 }, - { name: 'pam', age: 16 }, - { name: 'jim', age: 18 } -]; -console.log(pickAdults(people)); -// [ { name: 'alice', age: 22 }, { name: 'bob', age: 37 }, { name: 'jim', age: 18 } ] - -let people2 = [ - { name: 'betty', age: 23 }, - { name: 'ben', age: 15 }, - { name: 'yansi', age: 21 } -]; -console.log(pickAdults(people2)); -// [ { name: 'betty', age: 23 }, { name: 'yansi', age: 21 } ] -``` - -### wordMap - -Create a `word-map.js` file and solve the function below: - -```js -// Write a function `wordMap` that accepts a sentence string and an object as arguments. The function -// should return a new sentence where words that exist as keys in the object are replaced with their -// corresponding values. -// Your function must utilize the native Array#map method. - -console.log(wordMap('open the pod bay doors', {pod: 'ship', open: 'close'})); -// 'close the ship bay doors' - -console.log(wordMap('breakfast food is good', {breakfast: 'brunch', good: 'great'})); -// 'brunch food is great' -``` - -### commonElements - -Create a `common-elements.js` file and solve the function below: - -```js -// Write a function `commonElements` that accepts two arrays as arguments. The function should -// return a new array containing the elements that are found in both input arrays. -// Your function must utilize the native Array#filter method. - -console.log(commonElements(['a', 'b', 'c'], ['c', 'a'])); // ['a', 'c'] -console.log(commonElements(['cat', 'dog', 'mouse', 'fish'], ['dog', 'rat'])); // ['dog'] -console.log(commonElements(['skip', 'jump'], ['swim', 'hop'])); // [] -``` - - -### getInitials - -Create a `get-initials.js` file and solve the function below: - -```js -// Write a function `getInitials` that accepts an array of students as an argument. The function should -// return an array containing the initials of each student. -// Your function must utilize the native Array#map method. - -let students1 = [ - { first: 'ada', last: 'yonath', subject: 'chemistry' }, - { first: 'nelly', last: 'sachs', subject: 'literature' }, - { first: 'rosalyn', last: 'yallow', subject: 'medicine' } -]; -console.log(getInitials(students1)); // ['AY', 'NS', 'RY'] - - -let students2 = [ - { first: 'margaret', last: 'knight' }, - { first: 'ellen', last: 'ochoa' }, -]; -console.log(getInitials(students2)); // ['MK', 'EO'] -``` - -## Walkthrough - - - - - - - - - -

javascript-practice/08_higher_order_functions/B_native_callback_methods_exercise/

- -### [javascript-practice/08_higher_order_functions/B_native_callback_methods_exercise/README.md](javascript-practice/08_higher_order_functions/B_native_callback_methods_exercise/README.md) -```js -// snippet-5 - -let nums = [3, 7, 2, 9]; - -let res1 = nums.reduce(function (a, b) { - return a + b; -}); - -console.log(res1); - - -let res2 = nums.reduce(function (a, b) { - return a + b; -}, -10); - -console.log(res2); - -let res3 = nums.reduce(function (a, b) { - if (b < a) { - return b; - } else { - return a; - } -}); - -console.log(res3); -``` - - - - - -

javascript-practice/simple-side-bar/

- -### [javascript-practice/simple-side-bar/README.md](javascript-practice/simple-side-bar/README.md) -# [Simple Sidebar](https://github.com/bgoonz/bootstrap-sidebar-template) - -[Simple Sidebar](https://github.com/bgoonz/bootstrap-sidebar-template) is an off canvas sidebar navigation template -## Preview - -[![Simple Sidebar Preview](https://assets.startbootstrap.com/img/screenshots/templates/simple-sidebar.png)](https://startbootstrap.github.io/startbootstrap-simple-sidebar/) - -**[View Live Preview](https://startbootstrap.github.io/startbootstrap-simple-sidebar/)** - -## Status - - - -## Download and Installation - -To begin using this template, choose one of the following options to get started: - -* [Download the latest release on Start Bootstrap](https://github.com/bgoonz/bootstrap-sidebar-template) -* Install via npm: `npm i startbootstrap-simple-sidebar` -* Clone the repo: `git clone https://github.com/StartBootstrap/startbootstrap-simple-sidebar.git` -* [Fork, Clone, or Download on GitHub](https://github.com/StartBootstrap/startbootstrap-simple-sidebar) - -## Usage - -### Basic Usage - -After downloading, simply edit the HTML and CSS files included with the template in your favorite text editor to make changes. These are the only files you need to worry about, you can ignore everything else! To preview the changes you make to the code, you can open the `index.html` file in your web browser. - -### Advanced Usage - -After installation, run `npm install` and then run `npm start` which will open up a preview of the template in your default browser, watch for changes to core template files, and live reload the browser when changes are saved. You can view the `gulpfile.js` to see which tasks are included with the dev environment. - -You must have npm and Gulp installed globally on your machine in order to use these features. - -## Bugs and Issues - -Have a bug or an issue with this template? [Open a new issue](https://github.com/StartBootstrap/startbootstrap-simple-sidebar/issues) here on GitHub or leave a comment on the [template overview page at Start Bootstrap](https://github.com/bgoonz/bootstrap-sidebar-template). - -## About - -Start Bootstrap is an open source library of free Bootstrap templates and themes. All of the free templates and themes on Start Bootstrap are released under the MIT license, which means you can use them for any purpose, even for commercial projects. - -* -* - -Start Bootstrap was created by and is maintained by **[David Miller](https://davidmiller.io/)**. - -* -* -* - -Start Bootstrap is based on the [Bootstrap](https://getbootstrap.com/) framework created by [Mark Otto](https://twitter.com/mdo) and [Jacob Thorton](https://twitter.com/fat). - -## Copyright and License - -Copyright 2013-2020 Start Bootstrap LLC. Code released under the [MIT](https://github.com/StartBootstrap/startbootstrap-simple-sidebar/blob/gh-pages/LICENSE) license. - - - - - -

readme/

- -### [readme/README.md](readme/README.md) -# Prep-Work - ## [deployment](https://60637489113cfe1345c7fcf9--jolly-shannon-bbcd09.netlify.app/) -## [Backup-Deployment:](https://bgoonz-c1f6696402.drafts.github.io/lambda-prep/) 0.\) Links: @@ -19014,7 +30,7 @@ Copyright 2013-2020 Start Bootstrap LLC. Code released under the [MIT](https://g 3.\) Pre-Course Work -[![Edit epic-hawking-rdij1](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/epic-hawking-rdij1?autoresize=1&expanddevtools=1&fontsize=10&hidenavigation=1&theme=dark) + ``` . @@ -19028,296 +44,296 @@ Copyright 2013-2020 Start Bootstrap LLC. Code released under the [MIT](https://g ├── directory.html ├── index.html ├── javascript-practice -│ ├── 00_expressions_variables -│ │ ├── exercises -│ │ │ ├── A_executing_code_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_expressions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_variables_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── D_string_indexing_and_methods_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_executing_code_solution -│ │ │ ├── age.js -│ │ │ ├── greeting.js -│ │ │ ├── -│ │ │ ├── thirsty.js -│ │ │ └── whoami.js -│ │ ├── B_expressions_solution -│ │ │ ├── boolean-expressions.js -│ │ │ ├── comparisons.js -│ │ │ ├── number-expressions.js -│ │ │ ├── -│ │ │ └── string-expressions.js -│ │ ├── C_variables_solution -│ │ │ ├── four.js -│ │ │ ├── one.js -│ │ │ ├── -│ │ │ ├── three.js -│ │ │ ├── two.js -│ │ │ └── zero.js -│ │ ├── D_string_indexing_and_methods_solution -│ │ │ ├── a-tedious-task.js -│ │ │ ├── dare-to-decipher.js -│ │ │ ├── proper-patterns.js -│ │ │ ├── -│ │ │ └── small-string-snippets.js -│ │ -│ ├── 01_conditionals -│ │ ├── exercises -│ │ │ ├── A_conditionals_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_conditionals_solution -│ │ │ ├── one.js -│ │ │ ├── -│ │ │ ├── three.js -│ │ │ ├── two.js -│ │ │ └── zero.js -│ │ -│ ├── 02_functions -│ │ ├── exercises -│ │ │ ├── A_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_functions_solution -│ │ │ ├── average.js -│ │ │ ├── ends-with-t.js -│ │ │ ├── half.js -│ │ │ ├── is-div-by-4.js -│ │ │ ├── is-long.js -│ │ │ ├── keep-it-quiet.js -│ │ │ ├── -│ │ │ ├── snippet-0-1.js -│ │ │ ├── snippet-0-2.js -│ │ │ ├── snippet-0-3.js -│ │ │ └── snippet-0-4.js -│ │ ├── B_functions_solution -│ │ │ ├── ends-in-ly.js -│ │ │ ├── funny-sound.js -│ │ │ ├── longer.js -│ │ │ ├── one-or-none.js -│ │ │ ├── parity.js -│ │ │ ├── -│ │ │ ├── starts-with-r.js -│ │ │ ├── string-size.js -│ │ │ └── wacky-word.js -│ │ ├── C_functions_solution -│ │ │ ├── average-of-four.js -│ │ │ ├── case-changer.js -│ │ │ ├── contains.js -│ │ │ ├── divisible.js -│ │ │ ├── in-range.js -│ │ │ ├── larger.js -│ │ │ ├── number-change.js -│ │ │ -│ │ -│ ├── 03_loops -│ │ ├── exercises -│ │ │ ├── A_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_loops_solution -│ │ │ ├── count-up.js -│ │ │ ├── evens.js -│ │ │ ├── min-to-max.js -│ │ │ ├── one-to-four.js -│ │ │ ├── -│ │ │ ├── snippet-1.js -│ │ │ ├── snippet-2.js -│ │ │ ├── snippet-3.js -│ │ │ ├── snippet-4.js -│ │ │ ├── snippet-5.js -│ │ │ └── string-iterate.js -│ │ ├── B_loops_solution -│ │ │ ├── div-by-either.js -│ │ │ ├── five-multiples-of.js -│ │ │ ├── no-ohs.js -│ │ │ ├── odd-sum.js -│ │ │ ├── product-up-to.js -│ │ │ ├── -│ │ │ ├── string-repeater.js -│ │ │ └── sum-up-to.js -│ │ ├── C_loops_solution -│ │ │ ├── censor-e.js -│ │ │ ├── divisible-range.js -│ │ │ ├── fizz-buzz.js -│ │ │ ├── raise-power.js -│ │ │ ├── remove-capitals.js -│ │ │ ├── reverse-iterate.js -│ │ │ -│ │ -│ ├── 04_arrays -│ │ ├── exercises -│ │ │ ├── A_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_arrays_solution -│ │ │ ├── bleep-vowels.js -│ │ │ ├── divisors.js -│ │ │ ├── filter-long-words.js -│ │ │ ├── num-odds.js -│ │ │ ├── -│ │ │ ├── stay-positive.js -│ │ │ ├── strings-to-lengths.js -│ │ │ └── total.js -│ │ ├── B_arrays_solution -│ │ │ ├── choose-divisibles.js -│ │ │ ├── make-acronym.js -│ │ │ ├── maximum.js -│ │ │ ├── reverse-array.js -│ │ │ ├── -│ │ │ ├── word-count.js -│ │ │ └── your-average-function.js -│ │ ├── C_arrays_solution -│ │ │ ├── alternating-caps.js -│ │ │ ├── common-elements.js -│ │ │ ├── lengthiest-word.js -│ │ │ ├── number-range.js -│ │ │ ├── remove-short-words.js -│ │ │ -│ │ -│ ├── 05_nesting -│ │ ├── exercises -│ │ │ ├── A_nested_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_two_dimensional_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_more_problems_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_nested_loops_solution -│ │ │ ├── pair-print.js -│ │ │ ├── print-combinations.js -│ │ │ ├── -│ │ │ ├── snippet-1.js -│ │ │ ├── snippet-2.js -│ │ │ ├── snippet-3.js -│ │ │ ├── snippet-4.js -│ │ │ ├── snippet-5.js -│ │ │ └── two-sum.js -│ │ ├── B_two_dimensional_arrays_solution -│ │ │ ├── make-matrix.js -│ │ │ ├── print-2d.js -│ │ │ ├── -│ │ │ ├── total-product.js -│ │ │ ├── two-sum-pairs.js -│ │ │ └── zipper.js -│ │ ├── C_more_problems_solution -│ │ │ ├── remove-dupes.js -│ │ │ ├── remove-first-vowel.js -│ │ │ ├── remove-vowels.js -│ │ │ ├── -│ │ │ ├── shorten-long-words.js -│ │ │ └── spam.js -│ │ -│ ├── 06_decomposition_pattern -│ │ ├── A_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── C_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ ├── 07_objects -│ │ ├── A_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── C_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ ├── 08_higher_order_functions -│ │ ├── A_native_callback_methods_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_native_callback_methods_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ +│ ├── 00_expressions_variables +│ │ ├── exercises +│ │ │ ├── A_executing_code_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── B_expressions_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── C_variables_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── D_string_indexing_and_methods_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ +│ │ ├── +│ │ └── solutions +│ │ ├── A_executing_code_solution +│ │ │ ├── age.js +│ │ │ ├── greeting.js +│ │ │ ├── +│ │ │ ├── thirsty.js +│ │ │ └── whoami.js +│ │ ├── B_expressions_solution +│ │ │ ├── boolean-expressions.js +│ │ │ ├── comparisons.js +│ │ │ ├── number-expressions.js +│ │ │ ├── +│ │ │ └── string-expressions.js +│ │ ├── C_variables_solution +│ │ │ ├── four.js +│ │ │ ├── one.js +│ │ │ ├── +│ │ │ ├── three.js +│ │ │ ├── two.js +│ │ │ └── zero.js +│ │ ├── D_string_indexing_and_methods_solution +│ │ │ ├── a-tedious-task.js +│ │ │ ├── dare-to-decipher.js +│ │ │ ├── proper-patterns.js +│ │ │ ├── +│ │ │ └── small-string-snippets.js +│ │ +│ ├── 01_conditionals +│ │ ├── exercises +│ │ │ ├── A_conditionals_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ +│ │ ├── +│ │ └── solutions +│ │ ├── A_conditionals_solution +│ │ │ ├── one.js +│ │ │ ├── +│ │ │ ├── three.js +│ │ │ ├── two.js +│ │ │ └── zero.js +│ │ +│ ├── 02_functions +│ │ ├── exercises +│ │ │ ├── A_functions_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── B_functions_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── C_functions_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ +│ │ ├── +│ │ └── solutions +│ │ ├── A_functions_solution +│ │ │ ├── average.js +│ │ │ ├── ends-with-t.js +│ │ │ ├── half.js +│ │ │ ├── is-div-by-4.js +│ │ │ ├── is-long.js +│ │ │ ├── keep-it-quiet.js +│ │ │ ├── +│ │ │ ├── snippet-0-1.js +│ │ │ ├── snippet-0-2.js +│ │ │ ├── snippet-0-3.js +│ │ │ └── snippet-0-4.js +│ │ ├── B_functions_solution +│ │ │ ├── ends-in-ly.js +│ │ │ ├── funny-sound.js +│ │ │ ├── longer.js +│ │ │ ├── one-or-none.js +│ │ │ ├── parity.js +│ │ │ ├── +│ │ │ ├── starts-with-r.js +│ │ │ ├── string-size.js +│ │ │ └── wacky-word.js +│ │ ├── C_functions_solution +│ │ │ ├── average-of-four.js +│ │ │ ├── case-changer.js +│ │ │ ├── contains.js +│ │ │ ├── divisible.js +│ │ │ ├── in-range.js +│ │ │ ├── larger.js +│ │ │ ├── number-change.js +│ │ │ +│ │ +│ ├── 03_loops +│ │ ├── exercises +│ │ │ ├── A_loops_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── B_loops_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── C_loops_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ +│ │ ├── +│ │ └── solutions +│ │ ├── A_loops_solution +│ │ │ ├── count-up.js +│ │ │ ├── evens.js +│ │ │ ├── min-to-max.js +│ │ │ ├── one-to-four.js +│ │ │ ├── +│ │ │ ├── snippet-1.js +│ │ │ ├── snippet-2.js +│ │ │ ├── snippet-3.js +│ │ │ ├── snippet-4.js +│ │ │ ├── snippet-5.js +│ │ │ └── string-iterate.js +│ │ ├── B_loops_solution +│ │ │ ├── div-by-either.js +│ │ │ ├── five-multiples-of.js +│ │ │ ├── no-ohs.js +│ │ │ ├── odd-sum.js +│ │ │ ├── product-up-to.js +│ │ │ ├── +│ │ │ ├── string-repeater.js +│ │ │ └── sum-up-to.js +│ │ ├── C_loops_solution +│ │ │ ├── censor-e.js +│ │ │ ├── divisible-range.js +│ │ │ ├── fizz-buzz.js +│ │ │ ├── raise-power.js +│ │ │ ├── remove-capitals.js +│ │ │ ├── reverse-iterate.js +│ │ │ +│ │ +│ ├── 04_arrays +│ │ ├── exercises +│ │ │ ├── A_arrays_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── B_arrays_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── C_arrays_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ +│ │ ├── +│ │ └── solutions +│ │ ├── A_arrays_solution +│ │ │ ├── bleep-vowels.js +│ │ │ ├── divisors.js +│ │ │ ├── filter-long-words.js +│ │ │ ├── num-odds.js +│ │ │ ├── +│ │ │ ├── stay-positive.js +│ │ │ ├── strings-to-lengths.js +│ │ │ └── total.js +│ │ ├── B_arrays_solution +│ │ │ ├── choose-divisibles.js +│ │ │ ├── make-acronym.js +│ │ │ ├── maximum.js +│ │ │ ├── reverse-array.js +│ │ │ ├── +│ │ │ ├── word-count.js +│ │ │ └── your-average-function.js +│ │ ├── C_arrays_solution +│ │ │ ├── alternating-caps.js +│ │ │ ├── common-elements.js +│ │ │ ├── lengthiest-word.js +│ │ │ ├── number-range.js +│ │ │ ├── remove-short-words.js +│ │ │ +│ │ +│ ├── 05_nesting +│ │ ├── exercises +│ │ │ ├── A_nested_loops_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── B_two_dimensional_arrays_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ ├── C_more_problems_exercise +│ │ │ │ ├── README.html +│ │ │ │ ├── README.md +│ │ │ │ +│ │ │ +│ │ ├── +│ │ └── solutions +│ │ ├── A_nested_loops_solution +│ │ │ ├── pair-print.js +│ │ │ ├── print-combinations.js +│ │ │ ├── +│ │ │ ├── snippet-1.js +│ │ │ ├── snippet-2.js +│ │ │ ├── snippet-3.js +│ │ │ ├── snippet-4.js +│ │ │ ├── snippet-5.js +│ │ │ └── two-sum.js +│ │ ├── B_two_dimensional_arrays_solution +│ │ │ ├── make-matrix.js +│ │ │ ├── print-2d.js +│ │ │ ├── +│ │ │ ├── total-product.js +│ │ │ ├── two-sum-pairs.js +│ │ │ └── zipper.js +│ │ ├── C_more_problems_solution +│ │ │ ├── remove-dupes.js +│ │ │ ├── remove-first-vowel.js +│ │ │ ├── remove-vowels.js +│ │ │ ├── +│ │ │ ├── shorten-long-words.js +│ │ │ └── spam.js +│ │ +│ ├── 06_decomposition_pattern +│ │ ├── A_decomposing_problems_exercise +│ │ │ ├── README.html +│ │ │ ├── README.md +│ │ │ +│ │ ├── B_decomposing_problems_exercise +│ │ │ ├── README.html +│ │ │ ├── README.md +│ │ │ +│ │ ├── C_decomposing_problems_exercise +│ │ │ ├── README.html +│ │ │ ├── README.md +│ │ │ +│ │ +│ ├── 07_objects +│ │ ├── A_objects_exercise +│ │ │ ├── README.html +│ │ │ ├── README.md +│ │ │ +│ │ ├── B_objects_exercise +│ │ │ ├── README.html +│ │ │ ├── README.md +│ │ │ +│ │ ├── C_objects_exercise +│ │ │ ├── README.html +│ │ │ ├── README.md +│ │ │ +│ │ +│ ├── 08_higher_order_functions +│ │ ├── A_native_callback_methods_exercise +│ │ │ ├── README.html +│ │ │ ├── README.md +│ │ │ +│ │ ├── B_native_callback_methods_exercise +│ │ │ ├── README.html +│ │ │ ├── README.md +│ │ │ +│ │ +│ ├── js.js ├── one-of-every-tag.html ├── readme -│ ├── README.html -│ ├── README_files -│ │ ├── katex.min.css -│ │ -│ +│ ├── README.html +│ ├── README_files +│ │ ├── katex.min.css +│ │ +│ ├── resources.html ├── resources.md ├── script.js @@ -19581,7 +597,7 @@ easy to follow. "Simplicity is prerequisite for reliability." — Edsger W. Dijkstra -## Remember +## What you've learned - `console.log` can be used to print to the screen - using `//` at the front of a line will turn it into a comment; comments are @@ -19683,7 +699,7 @@ console.log(4 + 12 % 5); // => 6 console.log((4 + 12) % 5); // => 1 ``` -## Remember +## What you've learned - The **Number** type is used to represent integer and decimal values - The operators `+`, `-`, `/`, `*` perform the normal math operations of @@ -19835,7 +851,7 @@ console.log("hello" + "world"); // => 'helloworld' console.log("goodbye" + " " + "moon"); // => 'goodbye moon' ``` -## Remember +## What you've learned - a **String** is a data type that contains multiple characters enclosed in quotation marks @@ -19938,7 +954,7 @@ In other words, to correctly distribute `!` across parentheses, we must also fli We call this property **De Morgan's Law**. Shout out to Augustus De Morgan of Great Britain. -## Remember +## What you've learned * `!`, `&&`, `||` are the boolean operators that we can use to establish logic in our code * De Morgan's Law should be used to distribute `!` against parentheses @@ -20022,7 +1038,7 @@ Whoa! Surprised by these results? It can be hard to predict how `==` behaves, so we will avoid using it in this course and as a best practice. Stick to using `===` because it respects data types. -## Remember +## What you've learned - `>`, `<`, `>=`,`<=`, `===`, and `!==` can be used to compare values - we prefer to use `===` to check for equality because it takes the type into @@ -20164,7 +1180,7 @@ console.log(undefined + 3); // NaN console.log("fish" * 2); // NaN ``` -## Remember +## What you've learned - variables are declared with `let` and will contain the value `undefined` by default @@ -21246,7 +2262,7 @@ together. To concatenate arrays, we can use the aptly named `.concat` method: console.log([1, 2, 3].concat([4, 5, 6])); // => [1, 2, 3, 4, 5, 6] ``` -## Remember +## What you've learned - An **Array** is a data type that contains a list of in order values surrounded in square brackets `[]`. @@ -21396,7 +2412,7 @@ store and use as we please. > assignment is complete, it would be silly to refer to `myFunc` as an > `anonymous function` because an _anonymous function_ has no name. -## Remember +## What you've learned - functions can be stored in variables; just like any other values in JavaScript! @@ -21496,7 +2512,7 @@ useful in your future projects. Imagine how'd you represent a "grid": - sudoku (9x9 grid) - excel (a sheet is an arbitrarily sized 2D array) -## Remember +## What you've learned - an array can contain arrays as elements, we call this a 2D arrays - to iterate through a 2D array, used nested loops @@ -21599,7 +2615,7 @@ the assignment evaluates first, we are simply taking the new number of `50` and reassigning it to the `myNum` variable. This reassignment of a variable name is not a mutation of the original number. -## Remember +## What you've learned - data types that can be changed are mutable, those that cannot be changed are immutable @@ -21691,7 +2707,7 @@ Bam. What a versatile method! Always feel free to reference the [documentation][mdn-splice] for the method when you are struggling to remember its usage: -## Remember +## What you've learned - Array#splice has two required arguments - the target index @@ -21785,7 +2801,7 @@ This means that the `split` will cut the string wherever there is an 'I', leaving a gap where the 'I's were. Then, the `join` will fill those gaps with 'we's. -## Remember +## What you've learned - we can use `String#split` and `Array#join` to convert between strings and arrays @@ -21908,7 +2924,7 @@ function reverseTheSentence(sentence) { } ``` -## Remember +## What you've seen This article has shown you two ways to determine if a value is a kind of type: @@ -22154,7 +3170,7 @@ function whatIsThis() { } ``` -## Remember +## What you've learned There is a special value in JavaScript represented as `null` which means "no value" or "unknown value". It is the only value of the Null data type. You can @@ -22437,8 +3453,3 @@ have has the functionality that you desire by adding code like if (value !== undefined) {} if (value !== null) {} ``` - - - - - diff --git a/README_RAW.md b/README_RAW.md deleted file mode 100644 index 9e480da..0000000 --- a/README_RAW.md +++ /dev/null @@ -1,3456 +0,0 @@ -# Prep-Work - -## [deployment](https://60637489113cfe1345c7fcf9--jolly-shannon-bbcd09.netlify.app/) - -## [Backup-Deployment:](https://bgoonz-c1f6696402.drafts.github.io/lambda-prep/) - -0.\) Links: - -| Name | Hyperlink | -| :-------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| OKTA | [https://lambdaschoolsso.okta.com/login/login.htm?fromURI=%2Fapp%2FUserHome](https://lambdaschoolsso.okta.com/login/login.htm?fromURI=%2Fapp%2FUserHome) | -| Calendar | [https://calendar.google.com/calendar/u/0/embed?src=c\_2q0kvam9h9k5i6t40qp5n18dh8@group.calendar.google.com](https://calendar.google.com/calendar/u/0/embed?src=c_2q0kvam9h9k5i6t40qp5n18dh8@group.calendar.google.com) | -| Slack | [https://app.slack.com/client/T4JUEB3ME/G01QG65CN75](https://app.slack.com/client/T4JUEB3ME/G01QG65CN75) | -| | | -| | | -| | | -| | | -| | | -| Prep Work | [https://apply.lambdaschool.com/courses/web/](https://apply.lambdaschool.com/courses/web/) | - - - - - -1.\) Platforms we need while attending class: - - - -2.\) Web Development Software: - - - -3.\) Pre-Course Work -[![Edit epic-hawking-rdij1](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/epic-hawking-rdij1?autoresize=1&expanddevtools=1&fontsize=10&hidenavigation=1&theme=dark) - -``` -. -├── README.html -├── README.md -├── SUMMARY.html -├── SUMMARY.md -├── codeswing.json -├── comparison.png -├── demo.html -├── directory.html -├── index.html -├── javascript-practice -│ ├── 00_expressions_variables -│ │ ├── exercises -│ │ │ ├── A_executing_code_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_expressions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_variables_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── D_string_indexing_and_methods_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_executing_code_solution -│ │ │ ├── age.js -│ │ │ ├── greeting.js -│ │ │ ├── -│ │ │ ├── thirsty.js -│ │ │ └── whoami.js -│ │ ├── B_expressions_solution -│ │ │ ├── boolean-expressions.js -│ │ │ ├── comparisons.js -│ │ │ ├── number-expressions.js -│ │ │ ├── -│ │ │ └── string-expressions.js -│ │ ├── C_variables_solution -│ │ │ ├── four.js -│ │ │ ├── one.js -│ │ │ ├── -│ │ │ ├── three.js -│ │ │ ├── two.js -│ │ │ └── zero.js -│ │ ├── D_string_indexing_and_methods_solution -│ │ │ ├── a-tedious-task.js -│ │ │ ├── dare-to-decipher.js -│ │ │ ├── proper-patterns.js -│ │ │ ├── -│ │ │ └── small-string-snippets.js -│ │ -│ ├── 01_conditionals -│ │ ├── exercises -│ │ │ ├── A_conditionals_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_conditionals_solution -│ │ │ ├── one.js -│ │ │ ├── -│ │ │ ├── three.js -│ │ │ ├── two.js -│ │ │ └── zero.js -│ │ -│ ├── 02_functions -│ │ ├── exercises -│ │ │ ├── A_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_functions_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_functions_solution -│ │ │ ├── average.js -│ │ │ ├── ends-with-t.js -│ │ │ ├── half.js -│ │ │ ├── is-div-by-4.js -│ │ │ ├── is-long.js -│ │ │ ├── keep-it-quiet.js -│ │ │ ├── -│ │ │ ├── snippet-0-1.js -│ │ │ ├── snippet-0-2.js -│ │ │ ├── snippet-0-3.js -│ │ │ └── snippet-0-4.js -│ │ ├── B_functions_solution -│ │ │ ├── ends-in-ly.js -│ │ │ ├── funny-sound.js -│ │ │ ├── longer.js -│ │ │ ├── one-or-none.js -│ │ │ ├── parity.js -│ │ │ ├── -│ │ │ ├── starts-with-r.js -│ │ │ ├── string-size.js -│ │ │ └── wacky-word.js -│ │ ├── C_functions_solution -│ │ │ ├── average-of-four.js -│ │ │ ├── case-changer.js -│ │ │ ├── contains.js -│ │ │ ├── divisible.js -│ │ │ ├── in-range.js -│ │ │ ├── larger.js -│ │ │ ├── number-change.js -│ │ │ -│ │ -│ ├── 03_loops -│ │ ├── exercises -│ │ │ ├── A_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_loops_solution -│ │ │ ├── count-up.js -│ │ │ ├── evens.js -│ │ │ ├── min-to-max.js -│ │ │ ├── one-to-four.js -│ │ │ ├── -│ │ │ ├── snippet-1.js -│ │ │ ├── snippet-2.js -│ │ │ ├── snippet-3.js -│ │ │ ├── snippet-4.js -│ │ │ ├── snippet-5.js -│ │ │ └── string-iterate.js -│ │ ├── B_loops_solution -│ │ │ ├── div-by-either.js -│ │ │ ├── five-multiples-of.js -│ │ │ ├── no-ohs.js -│ │ │ ├── odd-sum.js -│ │ │ ├── product-up-to.js -│ │ │ ├── -│ │ │ ├── string-repeater.js -│ │ │ └── sum-up-to.js -│ │ ├── C_loops_solution -│ │ │ ├── censor-e.js -│ │ │ ├── divisible-range.js -│ │ │ ├── fizz-buzz.js -│ │ │ ├── raise-power.js -│ │ │ ├── remove-capitals.js -│ │ │ ├── reverse-iterate.js -│ │ │ -│ │ -│ ├── 04_arrays -│ │ ├── exercises -│ │ │ ├── A_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_arrays_solution -│ │ │ ├── bleep-vowels.js -│ │ │ ├── divisors.js -│ │ │ ├── filter-long-words.js -│ │ │ ├── num-odds.js -│ │ │ ├── -│ │ │ ├── stay-positive.js -│ │ │ ├── strings-to-lengths.js -│ │ │ └── total.js -│ │ ├── B_arrays_solution -│ │ │ ├── choose-divisibles.js -│ │ │ ├── make-acronym.js -│ │ │ ├── maximum.js -│ │ │ ├── reverse-array.js -│ │ │ ├── -│ │ │ ├── word-count.js -│ │ │ └── your-average-function.js -│ │ ├── C_arrays_solution -│ │ │ ├── alternating-caps.js -│ │ │ ├── common-elements.js -│ │ │ ├── lengthiest-word.js -│ │ │ ├── number-range.js -│ │ │ ├── remove-short-words.js -│ │ │ -│ │ -│ ├── 05_nesting -│ │ ├── exercises -│ │ │ ├── A_nested_loops_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── B_two_dimensional_arrays_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ ├── C_more_problems_exercise -│ │ │ │ ├── README.html -│ │ │ │ ├── README.md -│ │ │ │ -│ │ │ -│ │ ├── -│ │ └── solutions -│ │ ├── A_nested_loops_solution -│ │ │ ├── pair-print.js -│ │ │ ├── print-combinations.js -│ │ │ ├── -│ │ │ ├── snippet-1.js -│ │ │ ├── snippet-2.js -│ │ │ ├── snippet-3.js -│ │ │ ├── snippet-4.js -│ │ │ ├── snippet-5.js -│ │ │ └── two-sum.js -│ │ ├── B_two_dimensional_arrays_solution -│ │ │ ├── make-matrix.js -│ │ │ ├── print-2d.js -│ │ │ ├── -│ │ │ ├── total-product.js -│ │ │ ├── two-sum-pairs.js -│ │ │ └── zipper.js -│ │ ├── C_more_problems_solution -│ │ │ ├── remove-dupes.js -│ │ │ ├── remove-first-vowel.js -│ │ │ ├── remove-vowels.js -│ │ │ ├── -│ │ │ ├── shorten-long-words.js -│ │ │ └── spam.js -│ │ -│ ├── 06_decomposition_pattern -│ │ ├── A_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── C_decomposing_problems_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ ├── 07_objects -│ │ ├── A_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── C_objects_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ ├── 08_higher_order_functions -│ │ ├── A_native_callback_methods_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ ├── B_native_callback_methods_exercise -│ │ │ ├── README.html -│ │ │ ├── README.md -│ │ │ -│ │ -│ -├── js.js -├── one-of-every-tag.html -├── readme -│ ├── README.html -│ ├── README_files -│ │ ├── katex.min.css -│ │ -│ -├── resources.html -├── resources.md -├── script.js -├── style.css -└── tree.md - -66 directories, 241 files - - - - - -``` -# WEEK 1
*Introduction to JavaScript (Part 1)* {ignore=true} -________________________________________________________________________________ - - - -[**Expression Learning Objectives**](#expression-learning-objectives) -[**Intro to Functions Learning Objectives**](#intro-to-functions-learning-objectives) -- [Hello World](#hello-world) - - [Getting visual feedback in your programs](#getting-visual-feedback-in-your-programs) - - [Code comments](#code-comments) -- [The Number Type](#the-number-type) - - [All the numbers](#all-the-numbers) - - [The basic arithmetic operators](#the-basic-arithmetic-operators) -- [The String Type](#the-string-type) - - [Writing a valid string](#writing-a-valid-string) - - [Calculating length](#calculating-length) - - [Indexing a string](#indexing-a-string) - - [Concatenation](#concatenation) -- [The Boolean Type](#the-boolean-type) - - [Logical Operators](#logical-operators) - - [De Morgan's Law](#de-morgans-law) -- [Comparison Operators](#comparison-operators) - - [The relative comparators](#the-relative-comparators) - - [=== vs ==](#vs) -- [Basic Variables](#basic-variables) - - [Initializing a variable](#initializing-a-variable) - - [Manipulating variables](#manipulating-variables) - - [NaN](#nan) -- [Introduction to Functions](#introduction-to-functions) - - [Writing Functions](#writing-functions) - - [Invoking or "calling" a function](#invoking-or-calling-a-function) - - [Returning a value](#returning-a-value) - - [The importance of naming](#the-importance-of-naming) -- [Parameters and Arguments](#parameters-and-arguments) - - [The difference between Parameters and Arguments](#the-difference-between-parameters-and-arguments) - -[**Control Flow and Array Learning Objectives**](#control-flow-and-array-learning-objectives) -- [Control Flow - Conditional Statements](#control-flow-conditional-statements) - - [A Quick Word on Syntax](#a-quick-word-on-syntax) - - [Writing Conditional Statements](#writing-conditional-statements) -- [Mutually Exclusive Conditions](#mutually-exclusive-conditions) - - [When to use if statements](#when-to-use-if-statements) -- [Control Flow - Looping](#control-flow-looping) - - [Looping](#looping) - - [Translating From One Loop to Another](#translating-from-one-loop-to-another) -- [The Array Type](#the-array-type) - - [Using arrays](#using-arrays) - - [Indexing arrays](#indexing-arrays) - - [Working with arrays](#working-with-arrays) - - [Concatenation with arrays](#concatenation-with-arrays) - -[**Intermediate Functions Learning Objectives**](#intermediate-functions-learning-objectives) -- [Function Expressions](#function-expressions) - - [Functions as first-class objects](#functions-as-first-class-objects) -- [Two-Dimensional Arrays (2D Arrays)](#two-dimensional-arrays-2d-arrays) - - [Multidimensional Arrays](#multidimensional-arrays) - - [Iterating through 2D Arrays](#iterating-through-2d-arrays) - - [When is a 2D array practical?](#when-is-a-2d-array-practical) -- [Mutability in JavaScript](#mutability-in-javascript) - - [What is mutability?](#what-is-mutability) - - [Mutable or immutable, that is the question](#mutable-or-immutable-that-is-the-question) - - [The mutability misconception](#the-mutability-misconception) -- [Array Splice](#array-splice) - - [Notation](#notation) - - [What can Array#splice do?](#what-can-arraysplice-do) -- [String#split and Array#join](#stringsplit-and-arrayjoin) - - [String#split](#stringsplit) - - [Array#join](#arrayjoin) - - [A clever combination](#a-clever-combination) -- [Determining Types](#determining-types) - - [The typeof operator](#the-typeof-operator) - - [How to tell if a value is an array](#how-to-tell-if-a-value-is-an-array) - - [Practical use in "real" code](#practical-use-in-real-code) -- [The Null Type (And Undefined)](#the-null-type-and-undefined) - - [A type with only one value](#a-type-with-only-one-value) - - [The meaning of null](#the-meaning-of-null) - - [The absence of a value](#the-absence-of-a-value) - - [An unknown value](#an-unknown-value) - - [Checking if a value is null](#checking-if-a-value-is-null) - - [Oh, and there's that undefined value, too](#oh-and-theres-that-undefined-value-too) - - [What happens when...](#what-happens-when) -- [Catch Me If You Can](#catch-me-if-you-can) - - [Structured exception handling](#structured-exception-handling) - - [Try and catch](#try-and-catch) - - [How can I make my own errors?](#how-can-i-make-my-own-errors) - - [What else is there?](#what-else-is-there) - - [How do I best use this?](#how-do-i-best-use-this) - - -________________________________________________________________________________ -# WEEK-01 DAY-1
*Function Introduction* {ignore=true} -________________________________________________________________________________ -# Expression Learning Objectives - -Below is a complete list of the terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Given a working REPL interface, write and execute a statement that will print - "hello world" using console.log -2. Identify that strings are a list of characters defined by using double or - single quotes -3. Given an arithmetic expression using +, -, \*, /, %, compute its value -4. Given an expression, predict if its value is NaN -5. Construct the truth tables for &&, ||, ! -6. Given an expression consisting of >, >=, ===, <, <=, compute it's value -7. Apply De Morgan's law to a boolean expression -8. Given an expression that utilizes operator precedence, compute its value -9. Given an expression, use the grouping operator to change it's evaluation -10. Given expressions using == and ===, compute their values -11. Given a code snippet using postfix ++, postfix --, +=, -=, /=, \*=, predict - the value of labeled lines -12. Create and assign a variable using `let` to a string, integer, and a - boolean. Read its value and print to the console.l learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Given a working REPL interface, write and execute a statement that will print - "hello world" using console.log -2. Identify that strings are a list of characters defined by using double or - single quotes -3. Given an arithmetic expression using +, -, \*, /, %, compute its value -4. Given an expression, predict if its value is NaN -5. Construct the truth tables for &&, ||, ! -6. Given an expression consisting of >, >=, ===, <, <=, compute it's value -7. Apply De Morgan's law to a boolean expression -8. Given an expression that utilizes operator precedence, compute its value -9. Given an expression, use the grouping operator to change it's evaluation -10. Given expressions using == and ===, compute their values -11. Given a code snippet using postfix ++, postfix --, +=, -=, /=, \*=, predict - the value of labeled lines -12. Create and assign a variable using `let` to a string, integer, and a - boolean. Read its value and print to the console. - -________________________________________________________________________________ -# Intro to Functions Learning Objectives - -Below is a complete list of the terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Define a function using function declaration -2. Define a function that calculates the average of two numbers, call it, - pass in arguments, and print it's return value -3. Identify the difference between parameters vs argument terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Define a function using function declaration -2. Define a function that calculates the average of two numbers, call it, - pass in arguments, and print it's return value -3. Identify the difference between parameters vs arguments -________________________________________________________________________________ -# Hello World - -Hey Programmer! Welcome to the JavaScript module. In the next few sections, -we'll be learning the fundamentals of the JavaScript programming language. If -it's your first time programming, don't worry; we designed this course -especially for you. We'll have you executing your first lines of code in no -time! - -When you finish this article, you should be able to: - -- use the `console.log` command to print out messages -- use double slashes (`//`) to write code comments - -## Getting visual feedback in your programs - -The first command we'll learn in JavaScript is `console.log`. This command is -used to _print_ something onto the screen. As we write our first lines of code, -we'll be using `console.log` frequently as a way to visually see the output of -our programs. Let's write our first program: - -```javascript -console.log("hello world"); -console.log("how are you?"); -``` - -Executing the program above would print out the following: - -```plaintext -hello world -how are you? -``` - -Nothing too ground breaking here, but pay close attention to the exact way we -wrote the program. In particular, notice how we lay out the periods, -parentheses, and quotation marks. We'll also terminate lines with semicolons -(;). - -> Depending on how you structure your code, sometimes you'll be able to omit -> semicolons at the end of lines. For now, you'll want to include them -> just as we do. - -### Syntax - -We refer to the exact arrangement of the symbols, characters, and keywords as -**syntax**. These details matter - your computer will only be able to -"understand" proper JavaScript syntax. A programming language is similar to a -spoken language. A spoken language like English has grammar rules that we should -follow in order to be understood by fellow speakers. In the same way, a -programming language like JavaScript has syntax rules that we ought to follow! - -As you write your first lines of code in this new language, you may make many -syntax errors. Don't get frustrated! This is normal - all new programmers go -through this phase. Every time we recognize an error in our code, we have an -opportunity to reinforce your understanding of correct syntax. Adopt a growth -mindset and learn from your mistakes. - -Additionally, one of the best things about programming is that we can get such -immediate feedback from our creations. There is no penalty for making a mistake -when programming. Write some code, run the code, read the errors, fix the -errors, rinse and repeat! - -## Code comments - -Occasionally we'll want to leave **comments** or notes in our code. Commented -lines will be ignored by our computer. This means that we can use comments to -write plain english or temporarily avoid execution of some JavaScript lines. The -proper _syntax_ for writing a comment is to begin the line with double forward -slashes (`//`): - -```javascript -// let's write another program!!! -console.log("hello world"); - -// console.log("how are you?"); - -console.log("goodbye moon"); -``` - -The program above would only print: - -```plaintext -hello world -goodbye moon -``` - -Comments are useful when annotating pieces of code to offer an explanation of -how the code works. We'll want to strive to write straightforward code that is -self-explanatory when possible, but we can also use comments to add additional -clarity. The real art of programming is to write code so elegantly that it is -easy to follow. - -"Simplicity is prerequisite for reliability." — Edsger W. Dijkstra - -## Remember - -- `console.log` can be used to print to the screen -- using `//` at the front of a line will turn it into a comment; comments are - ignored by JavaScript - -________________________________________________________________________________ -# The Number Type - -The **Number** data type in JavaScript does exactly what you expect! It is used -to represent any numerical values, this includes integers and decimal numbers. -As one of our first data types, we'll be interested in what operations we can -use with numbers. - -When you finish this article, you should be able to: - -- predict the evaluation of arithmetic expressions -- explain the order of operations for JavaScript's arithmetic operators -- use the grouping operator, `()`, to manipulate the order of operations in an - expression - -## All the numbers - -JavaScript's **Number** encompasses numerical values. All of the following values are of number type: - -```javascript -42; --5; -3.14159; -7.0; -``` - -## The basic arithmetic operators - -For any given data type, we're interested in what operations we can perform with -that type. We use the word _operator_ to refer to the symbol that performs a -particular _operation_. For example, the `+` operator performs the addition -operation. Here are the common arithmetic operators in JS: - -- `+` (addition) -- `-` (subtraction) -- `*` (multiplication) -- `/` (division) -- `%` (modulo) - -With number values and arithmetic operators in hand, we can evaluate our first -expressions: - -```javascript -console.log(2 + 3); // => 5 -console.log(42 - 42); // => 0 -console.log(-4 * 1.5); // => -6 -console.log(25 / 8); // => 3.125 -``` - -Nothing too groundbreaking about the results above. An expression consists of -values and operators. JavaScript will evaluate an expression into a single -value. - -We can write more complex expressions using multiple operators. However, we'll -want to be aware of the general math order of operations. That is, we perform -multiplication-division operations first and then addition-subtraction -operations. To force a specific order of operation, we can use the grouping -operator, `( )`, around a part of the expression: - -```javascript -console.log(5 * 3 + 2); // => 17 -console.log(2 + 3 * 5); // => 17 -console.log((2 + 3) * 5); // => 25 -``` - -### The modulo operation - -All of the math operators listed above are the simple operations you use -everyday, except for maybe modulo `%`. **Modulo gives us the remainder that -results from a division.** For example, `10 % 3` is 1 because when we divide 10 -by 3, we are left with a remainder of 1. We can read `10 % 3` as "ten modulo -three" or "ten mod three." - -```javascript -console.log(10 % 3); // => 1 -console.log(14 % 5); // => 4 -console.log(20 % 17); // => 3 -console.log(18 % 6); // => 0 -console.log(7 % 9); // => 7 -``` - -Modulo is a very useful operation in the realm of computers. We can use it to -check the divisibility of numbers, whether numbers are even, whether they are -prime, and much, much more. Don't take this seemingly simple operation from -granted! We'll provide a ton of practice using these modulo patterns as we move through the course. - -In the order of operations, modulo has the the same precedence as -multiplication-division. So our complete order of math operations in JS is -parentheses, multiplication-division-modulo, addition-subtraction. - -```javascript -// modulo has precedence over addition -console.log(4 + 12 % 5); // => 6 -console.log((4 + 12) % 5); // => 1 -``` - -## Remember - -- The **Number** type is used to represent integer and decimal values -- The operators `+`, `-`, `/`, `*` perform the normal math operations of - addition, subtraction, division, multiplication respectively -- `a % b` returns the remainder when we divide `a` by `b`; we call this - operation modulo -- JavaScript follows the usual mathematical order of operations and we can use - the `()` to force precedence - -________________________________________________________________________________ -# The String Type - -This article is about one of JavaScript's primitive data types, **String**. -Strings are what we'll use to represent textual data. This means that strings -are useful in representing things like messages, names, poems, and so on. A -string is a sequence of characters. - -When you finish this article, you should be able to: - -- Write strings using correct syntax -- Use `.length` to obtain a count of the numbers of characters that comprise a - string -- Index a string to refer to a single character -- Concatenate strings together - -## Writing a valid string - -Strings are always wrapped by a pair of single quotation marks (`'`) or by a -pair of double quotation marks (`"`). Between the enclosing quotation marks, we -can put any characters! Here are a six examples of strings: - -```javascript -"potato"; -"New York"; -"azablan@.io"; -"Follow the yellow brick road, please!"; -"365 days a year"; -""; -``` - -Above, notice that we are free to mix in **any** characters into a string. This -includes spaces, numerics, punctuation, and other symbols. The sixth string -above is the empty string; it contains zero characters! - -You are probably wondering why we are allowed to use either single or double -quotes when denoting a string - why is this useful? Maybe we want a string that -_contains_ quotation marks: - -```javascript -// valid strings -'Shakespeare wrote, "To be or not to be"'; -"That's a great string"; -``` - -```javascript -// invalid string -'That's a bad string' -``` - -If we want to use a single quote as a character of a string, we simply need to -enclose the string in double quotes, and vice versa. - -## Calculating length - -Since a single string can contain any number of characters, we may find it -useful to count the number of characters in a string using `.length`: - -```javascript -console.log("ramen".length); // => 5 -console.log("go home!".length); // => 8 -console.log("".length); // => 0 -``` - -## Indexing a string - -Strings consist of multiple characters. These characters are numbered by -**indices** starting at 0. So in the string `'bootcamp'`, `'b'` is at index 0, -`'o'` is at index 1, `'o'` is at index 2, `'t'` is at index 3, and so on. We can -look at particular characters of a string by using `[]` and specifying an index: - -```javascript -console.log("bootcamp"[0]); // => 'b' -console.log("bootcamp"[1]); // => 'o' -console.log("bootcamp"[2]); // => 'o' -console.log("bootcamp"[3]); // => 't' -console.log("bootcamp"[7]); // => 'p' -console.log("bootcamp"[10]); // => undefined -console.log("bootcamp"[-3]); // => undefined -``` - -In general, when we index a string using the expression `string[i]`, we get back -the **single character** at position `i`. Looking at the last two examples -above, if we use an invalid index with a string, the value returned is -`undefined`. This makes since because there is no character at the given -position! It's also worth mentioning that an index should always be a number. - -### The classic "off by one" error - -Bear in mind that indices begin at 0 and not 1! Forgetting this nuance can lead -to incorrect code for both new and experienced programmers alike. Let's hone in -on an important distinction: the index of the last character of a string is -always one less than it's length. - -```javascript -console.log("cat".length); // => 3 -console.log("cat"[3]); // => undefined -console.log("cat"[2]); // => 't' -``` - -In other words, although the `length` of `'cat'` is 3, the index of the last -character (`'t'`) is 2. - -### Using indexOf - -We can also calculate the index of a given character within a string by using -`indexOf`: - -```javascript -console.log("bagel".indexOf("b")); // => 0 -console.log("bagel".indexOf("a")); // => 1 -console.log("bagel".indexOf("l")); // => 4 -console.log("bagel".indexOf("z")); // => -1 -``` - -If we attempt to search for a character that is **not** present in a string, -`indexOf` will return -1. This makes sense because we know that -1 is not a -valid string index. The smallest index possible is 0! - -If we search for a character that appears more than once in a string, -`indexOf` will return the index of the first occurance of that character. - -We can also use `indexOf` to search for a substring of characters. Under this -circumstance, `indexOf` will return the index where the substring begins in the -main string: - -```javascript -console.log("door hinge".indexOf("oor")); // => 1 -console.log("door hinge".indexOf("hi")); // => 5 -console.log("door hinge".indexOf("hint")); // => -1 -``` - -## Concatenation - -Concatenation is just a fancy word for joining strings together into a single -string. To concatenate strings, we use the `+` operator: - -```javascript -console.log("hello" + "world"); // => 'helloworld' -console.log("goodbye" + " " + "moon"); // => 'goodbye moon' -``` - -## Remember - -- a **String** is a data type that contains multiple characters enclosed in - quotation marks -- `string.length` returns the number of characters in the `string` -- each character of a string is associated with a number index; the first - character of a string is at index 0 -- we can use `string.indexOf(char)` to obtain the index of `char` within - `string`; if `char` is not found, then -1 is returned -- we can use `+` to concatenate multiple strings, combining them into a single - string - -________________________________________________________________________________ -# The Boolean Type - -The **Boolean** data type is perhaps the simplest type since there are only two -possible values, `true` and `false`. However, we'll find booleans very useful -because they will act as components of later concepts. As programmers, we'll use -booleans to describe the validity of statements. In an abstract sense, _"Today -is Monday"_ and _"one plus one equals ten"_ are examples of statements with -boolean values. That is, they are either `true` or `false`. - -When you finish this article, you should be able to: - -- predict the evaluation of expressions that use the boolean operations of `!`, - `||`, and `&&` -- explain DeMorgan's law - -## Logical Operators - -In the long run, we'll be using booleans to establish logic in our code. For -this reason, the _boolean operators_ can also be referred to as the _logical -operators_. There are only three such operators: - -- `!` (not) -- `&&` (and) -- `||` (or) - -### Logical NOT - -The not (`!`) operator will reverse a boolean value: - -```javascript -console.log(!true); // => false -console.log(!false); // => true -console.log(!!false); // => false -``` - -It's worth mentioning that `!` is a unary operator. This means that the not -operation is applied to a single value. This is in contrast to a binary operator -such as multiplication, which is applied between two values. It does not make -sense to `!` two values together. - -### Logical AND - -The and (`&&`) operator will take two boolean values and will only evaluate to -`true` when both input values are `true`. Otherwise, it will return `false`: - -```javascript -console.log(false && false); // => false -console.log(false && true); // => false -console.log(true && false); // => false -console.log(true && true); // => true -``` - -### Logical OR - -The or (`||`) operator will take two boolean values and will only evaluate to -`false` when both input values are `false`. Otherwise, it will return `true`: - -```javascript -console.log(false || false); // => false -console.log(false || true); // => true -console.log(true || false); // => true -console.log(true || true); // => true -``` - -### Logical order of operations - -We can write boolean expressions that consist of multiple logical operations, but we should be aware of the order of operations. JavaScript will evaluate `!` then `&&` then `||`. - -```javascript -console.log(true || true && false); // => true -console.log(false && !(false || true)); // => false -``` - -In general, `A || B && C` is equivalent to `A || (B && C)` where `A`, `B`, `C` are booleans. - -## De Morgan's Law - -A common mistake in boolean logic is to incorrectly distribute `!` across parentheses. Say we had boolean values of `A`, `B`. Here is something to remember: - -* `!(A || B)` is equivalent to `!A && !B` -* `!(A && B)` is equivalent to `!A || !B` - - -In other words, to correctly distribute `!` across parentheses, we must also flip the operation within parentheses. Beware that: - -* `!(A || B)` is not equivalent to `!A || !B` -* `!(A && B)` is not equivalent to `!A && !B` - -We call this property **De Morgan's Law**. Shout out to Augustus De Morgan of Great Britain. - -## Remember - -* `!`, `&&`, `||` are the boolean operators that we can use to establish logic in our code -* De Morgan's Law should be used to distribute `!` against parentheses - -These are just the basics of the type. We'll be seeing more booleans in the upcoming section, so stay tuned for that! - -________________________________________________________________________________ -# Comparison Operators - -In our previous introduction to the boolean data type, we described booleans as -way to represent the validity of an expression. We'll continue this conversation -by exploring **comparison** operators. As you learn about these operators, bear -in mind that all comparisons will result in a boolean, `true` or `false`. - -When you finish this article, you should be able to: - -- Predict the result of expressions that utilize the operators `>`, `<`, `>=` - `<=`, `===`, and `!==` -- Explain the difference between the equality operators `==` and `===` - -## The relative comparators - -- `>` (greater than) -- `<` (less than) -- `>=` (greater than or equal to) -- `<=` (less than or equal to) -- `===` (equal to) -- `!==` (not equal to) - -Using these operators is pretty straightforward. Here are a few examples: - -```javascript -console.log(10 > 5); // => true -console.log(10 < 5); // => false -console.log(1 < 7); // => true -console.log(7 <= 7); // => true -console.log(5 === 6); // => false -console.log(5 !== 6); // => true -console.log("a" !== "A"); // => true -console.log(false === false); // => true -``` - -Notice that a comparison expression always evaluate to a boolean value (`true` -or `false`). Comparison operators like `===` are a useful to compare strings, -booleans, etc. not just numbers. - -**Did you know?** `'a' < 'b'` is valid JS code? When you relatively compare -strings using `>` or `<` you will be comparing them lexicographically. -Lexicographically is fancy shmancy talk for "dictionary" order! A "lesser" -string is one that would appear earlier in the dictionary: - -```javascript -console.log("a" < "b"); // => true -console.log("apple" < "abacus"); // => false -console.log("app" < "apple"); // => true -console.log("zoo" > "mississippi"); // => true -``` - -**Gotcha** capitilized letters are considered lexicographically less than -lower case letters. i.e "A" < "z" // => true. - - -## === vs == - -In JavaScript there are two equality operators triple-equals (`===`) and -double-equals (`==`). The operators differ in how they compare across differing -types. Triple-equals performs the _strict equality_, meaning it will only return -`true` if the types are the same. Double-equals performs the _loose equality_, -meaning it can return `true` even if the values are of different type. -Double-equals may _coerce_ a value into another type for the comparison, and -this behavior is hard to predict: - -```javascript -console.log(5 === "5"); // false -console.log(5 == "5"); // true -console.log(0 === false); // false -console.log(0 == false); //true -``` - -Whoa! Surprised by these results? It can be hard to predict how `==` behaves, so -we will avoid using it in this course and as a best practice. Stick to using -`===` because it respects data types. - -## Remember - -- `>`, `<`, `>=`,`<=`, `===`, and `!==` can be used to compare values -- we prefer to use `===` to check for equality because it takes the type into - account. - -________________________________________________________________________________ -# Basic Variables - -Variables are used to store information to be referenced and manipulated in a -computer program. They also provide a way of labeling data with a descriptive -name, so our programs can be understood more clearly by programmers. It is -helpful to think of variables as containers that hold information. Their sole -purpose is to label and store data in computer memory. This data can then be -used and even changed throughout the lifetime of your program. - -When you finish this reading, you should be able to: - -- declare variables using the `let` keyword -- assign values to variables using the assignment operator (`=`) -- use the shortcuts `+=`, `-=`, `++`, `--` to reassign variables -- identify `undefined` as the default value for unassigned variables - -## Initializing a variable - -To initialize a variable in JavaScript we'll need two new pieces of syntax: -`let` and `=`. We can give the variable any name that we wish and assign it a -value. Once we initialize a variable, the variable will evaluate to the value -assigned: - -```javascript -let bootcamp = ""; -console.log(bootcamp); // '' - -let birthYear = 2012; -console.log(birthYear); // 2012 -``` - -**Did you know?** JavaScript variables names can contain any alphanumeric -characters, underscore (\_), or dollar sign (\$). However, they _cannot_ begin -with a number. - -Above are examples of how you'll create variables most of the time, so we'll -grow very familiar with the syntax. As a best practice, we should name our -variables in a way that is descriptive and concise. - -The variable initializations above really consist of two steps: _declaration_ -with `let` and _assignment_ with `=`. Let's break these two steps down. - -### Declaring a variable - -In JavaScript, in order to use a variable, we must _declare_ it. Variable -**declaration** is the act of introducing the variable to the environment. - -To declare a variable, use the `let` keyword, followed by a space and then the -name of the variable. - -```javascript -let bootcamp; -console.log(bootcamp); // undefined -``` - -Once a variable is declared, it will contain `undefined` as it's value. -`undefined` is a common default value in JavaScript, we'll see it come up in a -few different places. You can think of `undefined` as showing that the variable -is empty. - -### Assigning a variable - -Once a variable has been declared, we can assign it a value using single-equals -`=` : - -```javascript -let bootcamp; -console.log(bootcamp); // undefined -bootcamp = ""; -console.log(bootcamp); // '' -``` - -## Manipulating variables - -To change the value of a variable, we need to reassign it to a new value with -`=` : - -```javascript -let num = 42; -console.log(num + 8); // => 50 -console.log(num); // => 42 - -num = num + 10; -console.log(num); // => 52 -``` - -In the code above, `num + 8` will evaluate to `50`, but it will not change the `num` -variable to `50`. If we want to change the `num` variable, we must reassign to -it. - -### Assignment Shorthand - -Changing the value of a number variable is something fairly common in the -programming world. Luckily there is some shorthand operators we can use: - -```javascript -let number = 0; -number += 10; // equivalent to number = number + 10 -number -= 2; // equivalent to number = number - 2 -number /= 4; // equivalent to number = number / 4 -number *= 7; // equivalent to number = number * 7 -console.log(number); // 14 -``` - -We also have other shorthand to add or subtract exactly 1 from a variable, the -increment (`++`) and decrement (`--`) operators: - -```javascript -let year = 3004; -year++; -console.log(year); // 3005 -year--; -console.log(year); // 3004 -``` - -## NaN - -Now that we have the ability to perform arithmetic with variables, let's take a -look at a common programming mistake, getting a result of `NaN` (not a number): - -```javascript -let num; -console.log(num + 3); // NaN -``` - -The above code gives `NaN` because the unassigned `num` variable contains -`undefined`; adding `3` to `undefined` results in `NaN`. In general, any -nonsensical arithmetic will result in `NaN`. Math operations involving -`undefined` is perhaps the most common mistake: - -```javascript -console.log(undefined + 3); // NaN -console.log("fish" * 2); // NaN -``` - -## Remember - -- variables are declared with `let` and will contain the value `undefined` by - default -- we can use single-equals `=` to assign variables -- changing a variable requires a reassignment, for which there are many - shortcuts for (`+=`, `-=`, etc.) - -________________________________________________________________________________ -# Introduction to Functions - -We hope you are ready - because you are on the brink of one of the most fun -parts of writing JavaScript: writing **functions**. A function is a procedure of -code that will run when called. We only "write" a function once (**function -declaration**), but we can "use" it as many times as we please (**function -calls**). Functions are the fundamental building blocks of JavaScript and -mastering them is a big step on the road to JavaScript mastery. - -When you finish this reading, you should be able to: - -1. Describe what a function in JavaScript is. -2. Demonstrate how to invoke a function. -3. Write a function using function declaration. -4. Use the `return` keyword to return a value from a function. - -## Writing Functions - -A function is a set procedure of code that will run when called. Functions -really start to make sense when put in the perspective of solving problems. So -for example say you want to find the average of two given numbers. Meaning we -want to take two numbers, add them together then divide by 2: - -```js -> (5 + 5) / 2 -5 - -> (15 + 3) / 2 -9 - -> (7 + 2) / 2 -4.5 -``` - -Writing out the same code again and again gets tedious fast. What you can do -instead is write a new _function_. - -### Function Declaration - -A _function definition_ consists of the function keyword, followed by three -things: - -1. The **name** of the function. -2. A list of _parameters_ to the function, enclosed in parentheses, `()`. -3. The code to be run when this function is run, enclosed in curly - brackets,`{ }`. - -So for our above example of averaging two numbers we could write a function that -would do that for us! We would write something like the following: - -```js -// 1. average is the name of the function -// 2. number1 & number2 are the parameters being passed in -function average(number1, number2) { - // 3. this is the code run every time this function is used - return (number1 + number2) / 2; -} -``` - -First thing to notice for the above `average` function is that we didn't use any -_real_ numbers. You always want to write functions to accept as wide a range of -data as possible. Utilizing the incoming _parameters_ to a function is one of -the keys to making functions flexible. - -In the case of the `average` function, we want to use it to calculate the -average of any two numbers. `number1` and `number2` are the _parameters_ for the -`average` function. In other words, the `average` function expects to be given -two numbers, `number1` and `number2`. We'll be talking a lot more about -parameters later - but for now know that when you define a function with -parameters you are declaring those parameters as usable variables within that -function. - -The beauty of a function is that if we define it in a clever way, it will work -on a whole slew of data! For example, we want `average` to work on any two -numbers, whether or not they are whole numbers, decimal, negative, etc. - -## Invoking or "calling" a function - -Now that we've written a function how do we actually use it? Once defined a -function can be invoked or "called" as many times as we please. - -### Order of code - -Let's step away from `average` for a bit to see how a simple function call -works. Say we run JavaScript code that looks like this: - -```js -console.log("First!"); - -console.log("Second!"); -``` - -Running this code will return exactly as we expect. We will see `First!` printed -out, followed by `Second!`. In other words, JavaScript will evaluate your code -left-to-right and top-to-bottom. Very intuitive! It's exactly how you are -reading these notes right now. - -However, when JavaScript sees a function definition, JavaScript will **not** -evaluate the code inside of the definition. It will only "remember" the code so -we can execute it later. The code below only prints `First!` followed by -`Fourth!`: - -```js -console.log("First!"); - -function callMe() { - console.log("Second!"); - console.log("Third!"); -} - -console.log("Fourth"); - -// when run this code is ran it will print out: -// "First!" -// "Fourth" -``` - -To actually get the code within `callMe` to evaluate, we must _call_ it by using -`callMe()`. The code below will now print out in order: - -```js -function callMe() { - console.log("Second!"); - console.log("Third!"); -} - -console.log("First!"); -// we call the function by adding ending parenthesis -callMe(); -console.log("Fourth!"); - -// when run this code is ran it will print out: -// "First!" -// "Second!" -// "Third!" -// "Fourth" -``` - -Let's say JavaScript is running the file above. Here are the steps it would -take, starting from the tippy top of the code: - -1. JS sees a definition for `callMe`. It will remember this definition in case - we call the function later. It will **not** evaluate the code inside the - function yet. -2. JS prints out `First!` -3. JS sees that we are calling `callMe()`. At this point it will look at the - prior `callMe` definition and run the code inside. It is as if we are - "jumping" to inside the function definition. This means it will print - `Second!` followed by `Third!` -4. JS sees there is no more code to be run inside of `callMe`, so it "jumps" - back to where we originally called `callMe()` -5. JS will continue evaluating in order and print `Fourth!` - -### An average example - -So a declared function is "saved for later use", and will be executed later, -when it is called, also known as being **invoked**. So thinking back to our -average function we can declare the function and then _invoke_ it. - -When we specify what data to use for a function call, we refer to that process -**passing arguments to the function**. - -```js -// this is a function definition -function average(number1, number2) { - return (number1 + number2) / 2; -} - -// this is a function call with the arguments being 15 & 3 -> average(15, 3) -9 - -// this is a function call with the arguments being 5 & 5 -> average(10, 5) -7.5 -``` - -When we call the function `average(15, 3)`, we run the code inside the -_definition_ for `average`. That is, we plug in the parameters with real numbers -(`number1` becomes `10` and `number2` becomes 16). Think of `number1` and -`number2` as _variables_ that contain the values we pass in when we called the -function. Then we proceed by running the code inside the function. The parameter -names `number1` and `number2` used through the body of the function and behave -like variables. - -## Returning a value - -Now that we know how functions are declared and invoked let's talk about the -inside of the function. We'll start with a statement: _Every function in -JavaScript returns `undefined` unless otherwise specified._ - -Now what does that mean? We'll start with a simple example: - -```js -function sayNumber(number) { - console.log(number); -} - -> sayNumber(1); // prints 1 -1 -undefined -``` - -So what happened there? Let's do a quick step by step: - -1. We declared the `sayNumber` function -2. `sayNumber` was called handing in the argument of 1 -3. The `number` parameter is printed to the console -4. Then the function ends without encountering a `return` statement. Since - nothing was specifically returned then the function returned the default - value for a function which is `undefined`. - -Now let's change our above example to use the keyword `return` to return a -value: - -```js -function sayNumber(number) { - console.log(number); - return true; -} - -> sayNumber(1); -1 // sayNumber still prints 1 -true // but now sayNumber returns as true -``` - -Let's go back to our previous `average` function and talk about the `return` we -used there: - -```js -function average(number1, number2) { - return (number1 + number2) / 2; -} - -// the function call for average(10, 16) will return 13 -// so the result variable will be set to 13 -let result = average(10, 16); - -// if we want to check what a function returns we can do this: -console.log(result); // prints `13` - -// we could alternatively do this: -console.log(average(10, 16)); -``` - -When we _call_ a function, we jump to the function definition and run the code -inside. When we hit a `return` statement, we immediately **exit** the function, -jump back to where we _called_ the function, and evaluate the function call to -the value it _returned_. - -**Every function call evaluates to it's return value!** In other words, the -expression `average(10, 16)` evaluates to `13` just like how the expression -`1 + 1` evaluates to `2`. - -Another important rule of the return statement is that it stops function -execution immediately. This means that any code after a `return` will not be -executed! - -```js -function average(number1, number2) { - let sum = number1 + number2; - return sum; - // anything under the first return will not be executed - console.log("this will not run") - return false; -} - - // when the first return is encountered the entire function will return a value -> average(2, 7); -9 -``` - -So the three things to remember about return statements is: - -1. Every function call evaluates to it's return value. -2. Every function in JavaScript returns `undefined` unless a `return` is - specified -3. Once a `return` statement is encountered the function will immediately stop - and return the value, ignoring any code below the `return` statement. - -## The importance of naming - -A quick but very important side note about good naming. Take this to heart right -now: **Good names are important**. Do yourself, and every other programmer -reading your code, a favor by always using significant function and variable -names. - -For example, `x` is a very non-descriptive name for a variable or function. As -we tackle more complicated problems and our code grows to be more complex, we -are likely to forget what badly named variables originally stood for and what -their purpose was. Non-descriptive names make our code error-prone. **Great code -reads like English and almost explains itself.** As programmers, our goal is to -write code that is not only "correct", but also elegant, readable, and -maintainable! Hold yourself to this high standard. - -As far as syntax goes in JavaScript we always name our functions and variables -`camelCase` for multiple words. (Ex: `tipCalculator`, `currentNumber`, -`puppyPartyFinder`). Other languages use other conventions so it's best to pick -up the standard for your chosen language and stick with it. - -## Review - -By writing a function we can reuse code over and over again to solve similar -problems with different input data (arguments). This will make your life easier -and allow you to start working on more complex problems. - -This reading covered: - -- How to define and invoke a function in JavaScript. -- How to use the `return` keyword to return a value from a function. -- Writing readable JavaScript code by using significant names and following - `camelCase` conventions for multiple word variables and functions - -________________________________________________________________________________ -# Parameters and Arguments - -When talking about functions one of the first things we mentioned was the word -_parameters_. In this reading we will be covering what exactly a parameter is - -as well as the differentiation between _parameters_ and _arguments_. - -When you finish this reading, you should be able to: - -1. Identify the difference between parameters and arguments. -2. Write a function that utilizes declared parameters. -3. Invoking a function with passed in arguments. - -## The difference between Parameters and Arguments - -Let's start off by talking about the difference between _arguments_ and -_parameters_ and how to identify which is which. - -1. **Parameters** are comma separated variables specified as part of a - function's declaration. -2. **Arguments** are values passed to the function when it is invoked. - -So by defining _parameters_ when we declare our function we are effectively -setting accessible variables within the function: - -```js -function add(firstParameter, secondParameter) { - console.log(firstParameter + secondParameter); -} - -// the add function declares two parameters -> add(1, 2); //=> 3 -``` - -In the above example we declared our parameters when we declared our function. -Now _arguments_ work slightly differently - when the function is invoked we are -passing in _arguments_. So in the above example when we invoked `add(1, 2)` the -`(1,2)` were the _arguments_ being passed in. So when a function is invoked the -value of the declared parameters is assigned to the passed in _arguments_. - -You can think of it _parameters_ and _arguments_ like a recipe. A recipe is a -list of ingredients (_parameters_) and list of steps (the code to be run). When -someone cooks the recipe (_invokes_ the function) they add the ingredients they -actually have(_arguments_). The result of cooking the recipe is the delicious -`return` value! - -### Extra arguments - -In JavaScript a function will not throw an error if the number of _arguments_ -passed during a function invocation is different than the number of parameters -listed during function declaration. This is very important to know! - -Let's use the above function to demonstrate: - -```js -function add(firstParameter, secondParameter) { - console.log(firstParameter + secondParameter); -} - -// this will ignore the 17 & 14 -// the first two arguments passed in will be assigned to the first two parameters -> add(1, 2, 17, 14); //=> 3 -``` - -Notice in the above example we passed in 4 arguments (1, 2, 17, 14) to `add`. -Since the function was only looking for two parameters that is all it uses. - -### Not enough arguments - -Now what happens if we pass in less arguments then needed? - -```js -function add(firstParameter, secondParameter) { - console.log(firstParameter + secondParameter); -} - -> add(5); //=> NaN -``` - -Whoa what happened there? Let's do a play-by-play: - -1. `firstParameter` was set to equal the first passed in argument which in the - above case is 5. -2. Since there is no second argument then `secondParameter` is declared as a - variable but is set to the default value of `undefined`. -3. The function then tries to add 5 to `undefined` which is definitely not a - number! So we get `NaN` (which means `Not A Number`) printed to the console. - -As you write more functions you'll grow very comfortable using both arguments -and parameters to accomplish your function's goal. - -## Review - -- Parameters are variables defined as a part of a function's declaration. -- Arguments are values passed to the function when it is invoked. -- JavaScript functions can intake a different number of arguments than the - number of parameters listed during function declaration. - -________________________________________________________________________________ -# WEEK-01 DAY-2
*Control Flow* {ignore=true} -________________________________________________________________________________ -# Control Flow and Array Learning Objectives - -Below is a complete list of the terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Define a function that accepts a sentence string and two words as args. The - function should return a boolean indicating if the sentence includes either - word. -2. Identify a pair of mutually exclusive conditions -3. Given a for loop, translate it into a while loop, and vice-versa -4. Write a function that iterates through a provided string argument -5. Given a description of pig latin, write a function that takes in a string - argument and utilizes String#slice to translate the string into pig latin. -6. Write a function that takes in an array of words and a string as arguments - and returns a boolean indicating whether the string is located inside of the - array. The function must use Array#indexOf. -7. Define that an array literal is an ordered list of values defined by using - bracket and individual values are read by indexing. -8. Prevent code that can throw an exception from causing the program to crash. the terminal learning objectives for this lesson. -When you complete this lesson, you should be able to perform each of the -following objectives. These objectives capture how you may be evaluated on the -assessment for this lesson. - -1. Define a function that accepts a sentence string and two words as args. The - function should return a boolean indicating if the sentence includes either - word. -2. Identify a pair of mutually exclusive conditions -3. Given a for loop, translate it into a while loop, and vice-versa -4. Write a function that iterates through a provided string argument -5. Given a description of pig latin, write a function that takes in a string - argument and utilizes String#slice to translate the string into pig latin. -6. Write a function that takes in an array of words and a string as arguments - and returns a boolean indicating whether the string is located inside of the - array. The function must use Array#indexOf. -7. Define that an array literal is an ordered list of values defined by using - bracket and individual values are read by indexing. -8. Prevent code that can throw an exception from causing the program to crash. - -________________________________________________________________________________ -# Control Flow - Conditional Statements - -So far the code you've written has been pretty direct in it's intent. You can -define functions and variables but, so far the functions you've created haven't -been able to do that much for you _yet_. It's time to start writing functions -that can do things _conditionally_ by utilizing _control flow_. - -In simple terms - **control flow** is the order in which instructions are -executed within a program. One modifies control flow using _control structures_, -expressions that alter the control flow based on given parameters. The control -structures within JavaScript allow the program flow to change within a unit of -code or a function. - -This reading will be covering one of the two main _control structures_ you -will use time and time again - _Conditional statements_. _Conditional -statements_ are used to perform different actions based on different conditions. - -When you finish this reading, you should be able to: - -- Write `if`, `else if`, `if...else` conditional statements. -- Know that conditional statements can have only one `if` and one `else` - statement. -- Identify that conditional statements can be nested. - -## A Quick Word on Syntax - -Before we get started we'll quickly go over the terms we'll be using to -represent syntax. - -1. `[ ]` are square **brackets** -2. `{ }` are curly **braces** -3. `( )` are **parentheses** - -## Writing Conditional Statements - -Conditional Statements are the second fundamental _control structure_ for -writing JavaScript and are pretty straight forward. The simplest conditional -statement is the `if` statement. An `if` statement has two parts, the _test -expression_ (the code that immediately follows the `if` which goes in -parentheses), and the _then expression_ (this code belongs in braces after the -`if` expression). The _then_ expression will only run when the `if` expression -is truthy. - -Here is an example of a simple `if` statement: - -```js -// this is the test expression -if (3 === 3) { - // this is the then expression - // this code will run if the above statement is true - console.log("this is a three!"); -} -``` - -The `if` statement above allows you to specify what should happen if your -particular expression evaluates to true. You can chain additional _test -expressions_ onto this `if` statement by using a `else if` statement. - -The syntax for `else if` is very similar as an `if` statement: - -```js -function mathFun() { - let x = 2 + 3; - - if (x === 3) { - console.log("we have a 3"); - } else if (x === 4) { - // this code will run if the above statement is true - console.log("we have a 4"); - } else if (x === 5) { - // this code will run if the above statement is true - console.log("we have a 5"); - } -}; - -mathFun(); // => "we have a 5" -``` - -The `else if` and `if` statements do not, however, provide the option to specify -something else that should happen in the event that all of the above expressions -evaluate to be `falsey`. The `if...else` statement reads just like English. The -JS interpreter will execute the `else` statement if all the above conditions -given are `falsey`. See below for an example: - -```js -function mathFun() { - let x = 19; - if (x === 3) { - console.log("we have a 3"); - } else if (x === 4) { - console.log("we have a 4"); - } else { - console.log("I will return if everything above me is falsey!"); - } -}; - -mathFun(); // => "I will return if everything above me is falsey!" -``` - -You can chain an arbitrary number of `else if` statements but there can only be -one `if` statement and one optional `else` statement. The `if` introduces the control -structure and the `else` acts as a fail safe to catch everything that didn't -meet the above conditions. - -Only one _then expression_ is ever executed in an `if`, `if...else`, or -`if...else` statement. If one of the _test expressions_ is truthy, then the -result of its _then expression_ is the result of the **entire** conditional -statement: - -```js -let x = 3; -if (x === 3) { - console.log("this will run"); -} else { - console.log("this will not run"); -} -``` - -Additionally, you can nest conditional statements within each other but it will -get hard to read pretty quickly and is discouraged: - -```js -function mathFun(x) { - if (x === "math") { - if (x === "math" && x[0] === "m") { - if (x[1] === "a") { - console.log("this got confusing fast"); - } else { - console.log("that is not math!"); - } - } else { - console.log("that is for sure not math!"); - } - } else { - console.log("I will return if everything above me is false!"); - } -}; - -mathFun("math"); // => "this got confusing fast" -``` - -## Review - -- Conditional statements allow us to control what actions should be taken based - on a boolean (truthy or falsey) expression -- In a chain of _then expressions_ (`if...else if...else`), only one of the - _then expressions_ will be executed. -- Conditional statements can have only one `if` and one `else` statement. -- Conditional statements can be nested. - -________________________________________________________________________________ -# Mutually Exclusive Conditions - -You have now learned how to write conditional statements. Now we'll talk a -little bit more about how to write them using best practices. - -When you finish this reading, you should be able to: - -- Identify a pair of mutually exclusive conditions. - -## When to use if statements - -Say you are given the challenge to write a function that that will call another -function named `bigNumber` if the given argument is **greater** than 100 or call -a function named `smallNumber` if it the given argument is smaller. You could -write a function to do that which would look like this: - -```js -function numberSeparator(number) { - if (number < 100) { - // number is smaller than 100 so we invoke smallNumber - smallNumber(); - } - if (number === 100) { - // number is equal to 100 so we invoke smallNumber - smallNumber(); - } - if (number > 100) { - // number is larger than 100 so we invoke bigNumber - bigNumber(); - } -} -``` - -As you can probably tell the above function uses a lot of code to do a simple -task. To be clear the function above would work for our aim - but it repeats -itself. There is an age old principal for writing good code named **DRY** or -**Don't repeat yourself**. As good programmers we always want our code to be -clear, concise, and efficient. - -A general rule of thumb is that if you are working with a condition that is -**mutually exclusive**, meaning if one condition is true the other condition -must be false, then you should use an `if/else` statement. You can also think of -**mutually exclusivity** like a coin flip - it can be either heads or tails but -not both. - -Going back to the original problem at hand we can see it makes intuitive sense -with the way the challenge is phrased: If the number is larger than 100 then -we'll call `bigNumber`, otherwise we invoke is `smallNumber`. - -So let's rewrite the above function to read a little more clearly: - -```js -function numberSeparator(number) { - if (number > 100) { - bigNumber(); - } else { - smallNumber(); - } -} - -// this also works -function numberSeparator(number) { - if (number <= 100) { - smallNumber(); - } else { - bigNumber(); - } -} -``` - -Look at how much clearer that is! Writing good code is an art - devote yourself -to becoming an artist! - -## Review - -- How to identify a pair of mutually exclusive conditions. -- DRY - don't repeat yourself! - -________________________________________________________________________________ -# Control Flow - Looping - -A quick reminder before we start - **control flow** is the order in which -instructions are executed within a program. One modifies control flow using -_control structures_, expressions that alter the control flow based on given -parameters. This reading will be covering the second of the main _control -structures_ you will use time and time again - _loops_. - -When you finish this reading, you should be able to: - -1. Know how to write a `while` loop and a `for` loop. - - Know how to convert a `for` loop into a `while` loop -2. Know that index variables conventionally start at zero. -3. Explain what an _iteration_ is. - -## Looping - -Imagine you are at a friend's house and your friend has six dogs. Someone left -the back gate open and all the dogs go out in the yard and get super muddy. Now -your friend wants to clean their dogs but they only have one bathtub! You can't -wash all the dogs at once. So the only option is to give the dogs a bath one at -a time until they are all clean. When you start 0 dogs are clean and 6 dogs are -dirty. - -_While_ there are still dirty dogs you still have a job to do. That is your -**condition** - you will stop giving baths once all 6 dogs are clean. So after -one bath you you have 1 clean dog and 5 dirty dogs. You've -_incremented_(increased by one) your number of clean dogs. After each bath you -check your **condition** again until you have 6 clean dogs so you know you can -stop! - -What we've described above is the idea of looping - setting a condition, -executing an action, doing something to make sure our condition will be met -eventually, and rechecking our condition before executing our next action. - -Loops are a fundamental _control structure_ for writing JavaScript. -Loops will repeatedly execute a section of code while a condition is true. Loops -are simple to write and incredibly powerful! There are many variations of loop -but we will be covering the two most fundamental loops now - **while** loops and -**for** loops. - -### While Loops - -One of the simplest loops in `JavaScript` is the `while` loop. As with all -loops, the `while` loop will execute a block of code as long as a specified -condition is true. The while loop starts with the keyword `while` then states a -condition in parentheses. The code in the following braces will be run until the -above condition is met. - -```js -while (condition) { - // code block to be executed -} -``` - -In the following example, the code in the loop will run, over and over again, as -long as a variable (`index`) is less than 10: - -```js -let index = 0; - -// this is the condition that will be checked every time this loop is run -while (index < 10) { - console.log("The number is " + index); - // this is common shorthand for index = index + 1 - index++; -} -``` - -The most important thing to remember when writing any loop is to always be -working towards your condition. In the example above if we did not increment the -`index` variable by 1 each time the loop ran then we would be stuck with what we -call an **infinite loop**: - -```js -let index = 0; - -// this is an infinite loop because our condition will never be met -while (index < 10) { - console.log("The number is " + index); - // if we do not increase the index then our condition is never met - // Meaning this will run forever! -} -``` - -The above code will run until whatever interpreter you are using crashes. - -### Important Loop Knowledge - -A quick word before we learn about the next loop. - -The _index_ is the traditional word for the variable that keeps track of how -many times the loop has been run. Don't write loops with indices starting at -one; you'll confuse other programmers and yourself. Indices have started at zero -for a long time, and for good reason. It's much easier to use loops that start -with an index of zero because Array and String indices also start at zero. - -```js -let array = [0, 1, 2]; -let index = 0; - -while (index < array.length) { - console.log( - "Both the index and the current array position are " + array[index] - ); - index++; -} -``` - -In the above code we will do one loop for each digit in the Array above. We call -each of those loops an "iteration". An iteration is the act of repeating a -procedure, hence looping is an **iterative** technique. Each repetition itself -is also called an "iteration." So you can use loops to _iterate_ through Arrays -and Strings. - -### For Loops - -A `for` loop can be broken down into three sections: - -1. The _initial expression_ which will be run once at the beginning of the loop. -2. The _condition_ which is checked every time the loop is run. If this - condition is true the loop will run again. If this condition is false the - loop will end. -3. The _loopEnd expression_ which will be run at the end of the loop before - checking the _condition_ again. - -```js -for (;;) -``` - -The `for` loop is usually used with an integer counter: - -```js -for (let index = 0; index < 10; index += 1) { - // the code inside this block will run 10 times -} -``` - -While the _loopEnd expression_ is normally used to increase a variable by one -per loop iteration, it can contain any statement, such as one that decreasing -the counter, or increasing it by 2. - -You can use the `for` loop to iterate through all kinds of things. Check out the -example below for how to iterate through a String: - -```js -let testString = "testing"; - -// we can use the testString's length as our condition! -// Since we know the testString's index starts at 0 -// and our index starts at 0 we can access each letter: -for (let index = 0; index < testString.length; index += 1) { - let letter = testString[index]; - console.log(letter); -} -``` - -These are the most basic types of loops. If all else fails, you can always fall -back on these two loops. All the other loop forms are just more convenient forms -of these basic loop styles. - -## Translating From One Loop to Another - -So far we have covered both `while` and `for` loops. Once you understand the -concept of looping it's easy to translate one loop to another: - -```js -// these two do the exact same thing! -function forLoopDoubler (array) { - // it is convention to shorten index to just i in most cases - for (let i = 0; i < array.length; i++) { - array[i] = array[i] * 2; - } - return array; -}; - -function forLoopDoubler (array) { - let i = 0; - while (i < array.length) { - array[i] = array[i] * 2; - i++; - } - return array; -}; - -forLoopDoubler([1, 2, 3]); // => [2,4,6] -whileLoopDoubler([1, 2, 3]); //=> [2,4,6] -``` - -## Review - -- We can use a `for` or `while` loop to repeat a block of code repeatedly. -- While the loop condition is true, we will execute another iteration of the - loop. -- When the loop condition is false, we will exit the loop. - -________________________________________________________________________________ -# The Array Type - -This reading will be about one of JavaScript's global objects, the **Array** -type. JavaScript arrays are used to store multiple values all within a single -structure, much like a creating a list. Arrays can hold strings, integers and -even other arrays! Arrays are incredibly useful for holding a bunch of different -information all in one place. - -When you finish this reading, you should be able to: - -- Write arrays using correct syntax -- Identify that an array is an ordered list of values defined by using brackets -- Use `.length` to obtain a count of the numbers of elements that comprise an - array -- Index an array to refer to a single value -- Concatenate multiple arrays together - -## Using arrays - -While coding you will find that you often find yourself needing to refer to a -bunch of data at once. For instance, what if you wanted to refer to the entire -English alphabet. Sure, you could create a bunch variables for each letter in -the alphabet: - -```js -let a = "a"; -let b = "b"; -let c = "c"; -let d = "d"; -// and so on for way too long... -``` - -However this becomes cumbersome and unmanageable quickly. An Array is a data -structure that solves this problem. Arrays are always wrapped in square -brackets, `[]`, and store their comma separated values in sequential order. -Arrays in JavaScript are also very flexible: we can put elements into an array, -replace elements in an array, and remove elements from the array. - -So going back to our first example of containing the alphabet: - -```js -let alphabet = [ - "a", "b", "c", "d", "e", "f", - "g", "h", "i", "j", "k", "l", - "m", "n", "o", "p", "q", "r", - "s", "t", "u", "v", "w", "x", - "y", "z" -]; -``` - -## Indexing arrays - -### Calculating the length of an array - -Since an array can container any number of values you will find it useful to -count the number of values available to you using `.length`: - -```js -console.log([4, 7, 9].length); // => 3 -console.log([1, 2].length); // => 2 -console.log([].length); // => 0 -``` - -### Properly indexing an array - -Arrays consist of multiple values all stored in sequential order. These value -are numbered by **indices** starting at 0 (just like indexing a string!). So -given the below example: - -```js -let numbersAndLetters = ["b", "z", 17, "cat"]; -``` - -In the above `numbersAndLetters` array if we access `numbersAndLetters` at the -index of 0 we get back the value of "b". If we access `numbersAndLetters` at the -index of 1 we get "z", at the index of 3 we get 17, etc. We can specify which -value we'd like to access in an array by using square brackets,`[]`, and -specifying an index: - -```js -console.log(numbersAndLetters[0]); // => "b" -console.log(numbersAndLetters[1]); // => "z" -console.log(numbersAndLetters[2]); // => 17 -console.log(numbersAndLetters[3]); // => "cat" -``` - -Notice that even though the index at `numbersAndLetters[3]` has the value of a -string with multiple characters ("cat") we return the _entire value_ listed at -that index. - -**Reminder:** Arrays **always** start at the index of 0, not 1. This is the -convention in programming. Additionally, indices should always be a number. - -We can access a value in an array directly by providing an index for the value -we'd like to access in that array (`array[index]`). See below for an example: - -```js -console.log(["a", "b", "c"][0]); // => "a" -console.log(["a", "b", "c"][1]); // => "b" -console.log(["a", "b", "c"][2]); // => "c" -console.log(["a", "b", "c"][3]); // => `undefined` -``` - -As we see in the code above, if we try to access an element at an index that is -not inside the array, we get back `undefined`. This makes sense because there is -no value at that given position! - -### The classic "off by one" error - -Arrays are similar to strings in that both of their indices start at 0 instead -of 1. Forgetting this fact can lead to some pretty confusing situations. Let's -focus on an important distinction: the index of the last value of an array is -always one less than its length. - -```javascript -console.log([4, 7, 9].length); // => 3 -console.log([4, 7, 9][3]); // => undefined -console.log([4, 7, 9][2]); // => 9 -``` - -In other words, although the `length` of `[4, 7, 9]` is 3, the index of the last -value (`9`) is 2. A good rule of thumb of accessing the last index of an array -is to find the length and then subtract one: - -```js -let testArray = [4, 7, 9]; -let finalIndex = testArray.length - 1; // => (3 - 1) = 2 -console.log(testArray[finalIndex]); // => 9 -``` - -## Working with arrays - -### Containing data in arrays - -By packaging groups of related data into a single array, we gain the added -benefit of being able to refer to that data as a single collection. Arrays don't -have to just hold single characters- they are capable of holding entire strings, -numbers, and even other arrays! - -```js -let wackyArray = [2, 17, "apple", "cat", ["apple"]]; - -console.log(wackyArray[0]); // => 2 -console.log(wackyArray[1]); // => 17 -console.log(wackyArray[3]); // => "cat" -console.log(wackyArray[4]); // => ["apple"] -``` - -Just think of all the possibilities of what you can store in a single array! -However, just because you can _doesn't_ mean you should. In practice we will -almost always be storing similar kinds of data, that are coming from a common -source (i.e. items in a shopping list, ID numbers, tasks on a todo list). - -### Using indexOf with arrays - -We can also calculate the index of a given value within an array by using -`indexOf`: - -```javascript -console.log([1, 3, 5, "apple", "jet"].indexOf(3)); // => 1 -console.log([1, 3, 5, "apple", "jet"].indexOf(5)); // => 2 -console.log([1, 3, 5, "apple", "jet"].indexOf("jet")); // => 4 - -// this won't be found in the array -console.log([1, 3, 5, "apple", "jet"].indexOf("potato")); // => -1 -``` - -If we attempt to search for a value that is **not** present in an array, -`indexOf` will return -1. This makes sense because we know that -1 is not a -valid array index. The smallest index possible is 0! - -## Concatenation with arrays - -As a reminder, concatenation is just a fancy word for joining things together -into a single collection. Now, this is where arrays will differ from strings. -The `+` operator only exists for numbers and strings. If you try to use the `+` -on an array it will try to help you out by _converting your arrays into -strings_. - -```js -console.log([1, 2, 3] + [4, 5, 6]); // => 1,2,34,5,6 -``` - -JavaScript was just trying to help! However that is probably not what you meant -to do. Good thing JavaScript has a seperate method for putting two array -together. To concatenate arrays, we can use the aptly named `.concat` method: - -```javascript -console.log([1, 2, 3].concat([4, 5, 6])); // => [1, 2, 3, 4, 5, 6] -``` - -## Remember - -- An **Array** is a data type that contains a list of in order values surrounded - in square brackets `[]`. -- `array.length` returns the number of values in the `array`. -- Each value of an array is associated with a number index; the first value of - an array is at the index of 0. -- We can use `array.indexOf(value)` to obtain the index of `value` within - `array`; if `value` is not found, then -1 is returned. -- We can use `.concat` to concatenate multiple arrays, combining them into a - single array. - -________________________________________________________________________________ -# WEEK-01 DAY-3
*Intermediate Functions* {ignore=true} -________________________________________________________________________________ -# Intermediate Functions Learning Objectives - -Below is a complete list of the terminal learning objectives across all -"Intermediate Function" lessons. When you complete these lessons, you should be -able to perform each of the following objectives. These objectives capture how -you may be evaluated on the assessment for these lessons. - -1. Identify that strings are immutable and arrays are mutable -2. Define a function using both function declaration and function expression - syntax -3. Utilize Array#push, #pop, #shift, #unshift to mutate an array -4. List the arguments that can be used with Array#splice -5. Write a function that sums up elements of an array, given an array of numbers - as an argument -6. Utilize Array#forEach, #map, #filter, #reduce in a function -7. Define a function that takes in an array of numbers and returns a new array - containing only the primes -8. Define a function that takes in a 2D array of numbers and returns the total - sum of all elements in the array -9. Define a function that takes in an array of elements and returns a 2d array - where the subarrays represent unique pairs of elements -10. Define a function that takes in an array of numbers as an argument and - returns the smallest value in the array; if the array is empty return null the terminal learning objectives across all -"Intermediate Function" lessons. When you complete these lessons, you should be -able to perform each of the following objectives. These objectives capture how -you may be evaluated on the assessment for these lessons. - -1. Identify that strings are immutable and arrays are mutable -2. Define a function using both function declaration and function expression - syntax -3. Utilize Array#push, #pop, #shift, #unshift to mutate an array -4. List the arguments that can be used with Array#splice -5. Write a function that sums up elements of an array, given an array of numbers - as an argument -6. Utilize Array#forEach, #map, #filter, #reduce in a function -7. Define a function that takes in an array of numbers and returns a new array - containing only the primes -8. Define a function that takes in a 2D array of numbers and returns the total - sum of all elements in the array -9. Define a function that takes in an array of elements and returns a 2d array - where the subarrays represent unique pairs of elements -10. Define a function that takes in an array of numbers as an argument and - returns the smallest value in the array; if the array is empty return null - -________________________________________________________________________________ -# Function Expressions - -You may have noticed that we've been writing many functions so far in the -course! We will continue to do so since functions are the building blocks of the -eventual applications that we will build. That being said, let's begin to -broaden the way we think about functions. In particular, we'll want think of -functions as expressions that we can store in variables - just like our classic -data types of number, string, boolean, array, and object! - -When you finish this article, you should be able to: - -- identify functions as first-class objects in JavaScript -- define a function using function expression syntax - -## Functions as first-class objects - -JavaScript is well known for being a programming language that treats functions -as "first-class objects". This fancy talk means that you can treat a function as -a "normal" value by storing it in a variable. We'll leverage this key concept in -very clever ways later in the course. For now, let's begin with a simple example -that shows the "first-class object" nature of functions: - -```javascript -let calculateAverage = function(a, b) { - return (a + b) / 2; -}; - -console.log(calculateAverage(10, 20)); // 15 -``` - -In the code snippet above, we define the `calculateAverage` by assigning a -variable to contain the function's definition. By doing this, the variable's -name is effectively the function's name. So to call the function, we simply -refer to the variable name. Note that we do not write the function's name after -the `function` keyword, where we normally would. We will refer to this new way -of defining functions as _function expression syntax_ and the classic way of -defining functions as _function declaration syntax_. In general, we can define -functions using either syntax: - -```javascript -// function declaration syntax -function myFunctionName(arg1, arg2) {} - -// function expression syntax -let myFunctionName = function(arg1, arg2) {}; -``` - -In the coming sections, we'll highlight moments when we'll prefer one syntax -over the other. For now, get acquainted with the new syntax as it is something -you'll be seeing a lot of as a programmer! - -### A peek under the hood - -Perhaps you're finding it tough to understand what it means for a variable to -contain a function - it is indeed a very abstract idea for new programmers. -Let's draw a comparison. We know that when we assign an expression to variable, -the expression first evaluates to a single value, which we then store in the -variable name: - -```javascript -let myNum = 4 + 4; -console.log(myNum); // prints 8 -console.log(myNum * 3); // prints 24 -``` - -In the same way we can treat a function definition as an expression that -evaluates! - -```javascript -let myFunc = function() { - console.log("I'm a function"); -}; - -console.log(myFunc); // prints [Function: myFunc] -myFunc(); // prints "I'm a function" -``` - -Looking at the snippet immediately above, you'll notice that when we print the -`myFunc` variable directly, without calling the function with parentheses, -JavaScript simply says the variable contains a function named myFunc -(`[Function: myFunc]`). You can truly imagine a function as a value that we can -store and use as we please. - -> The term _anonymous function_ may also be used to describe a function -> expression before it is assigned to any variable. Following the example above, -> we'll use the word _anonymous function_ to describe the function expression -> _before_ the assignment to the `myFunc` variable is complete. Once the -> assignment is complete, it would be silly to refer to `myFunc` as an -> `anonymous function` because an _anonymous function_ has no name. - -## Remember - -- functions can be stored in variables; just like any other values in - JavaScript! - -________________________________________________________________________________ -# Two-Dimensional Arrays (2D Arrays) - -Time to broaden our understanding of arrays! We've already explore the -fundamentals of arrays. Mainly, we can store any type of data we please as -elements of an array and even mix types together. However, what happens if we -store an array as an element of an array? - -When you finish this article, you should be able to: - -- index into the inner elements of a 2D array -- use nested loops to iterate through a 2D array - -## Multidimensional Arrays - -When we store arrays as elements of other arrays, we refer to those structures -as multidimensional arrays. If the "depth" of the nested arrays is at exactly 2 (an -outer array containing inner arrays), then we'll refer to it as a -two-dimensional array: - -```javascript -let twoDimensional = [["a", "b", "c"], ["d", "e"], ["f", "g", "h"]]; - -console.log(twoDimensional[1]); // [ 'd', 'e' ] -console.log(twoDimensional[1][0]); // 'd' - -let subArr = twoDimensional[1]; -console.log(subArr[0]); // 'd' -``` - -Note that indexing the outer `twoDimensional` array will return an element like -usual, it's just that element happens to be another array. To gain access to the -innermost elements, we simply need to apply another set of indexing brackets! - -If we style our 2D arrays nicely so that each subarray is on a new line, we can -interpret the double indices as `[row][column]`: - -```javascript -let twoDimensional = [ - ["a", "b", "c"], - ["d", "e"], - ["f", "g", "h"]]; - -// get the element in the 0th row, 2nd col: -console.log(twoDimensional[0][2]); // 'c' -``` - -## Iterating through 2D Arrays - -Since a 2D array is just an array of arrays. We'll need to use a loop within a -loop to iterate through a 2D array: - -```javascript -let array = [["a", "b", "c"], ["d", "e"], ["f", "g", "h"]]; - -for (let i = 0; i < array.length; i++) { - let subArray = array[i]; - console.log(subArray); - - for (let j = 0; j < subArray.length; j++) { - console.log(subArray[j]); - } -} -``` - -In the nested loops above, the `i` index refers to the current "row" and the `j` -index refers to the current "column". It's worth noting that since the inner -subArrays have different length, we'll want to specifically reference the length -of that subarray in our inner loop condition `j < subArray.length`. The code -above will print: - -```plaintext -[ 'a', 'b', 'c' ] -a -b -c -[ 'd', 'e' ] -d -e -[ 'f', 'g', 'h' ] -f -g -h -``` - -## When is a 2D array practical? - -As a preview of things to come let's briefly mention when you'll find a 2D array -useful in your future projects. Imagine how'd you represent a "grid": - -- tic-tac-toe (3x3 grid) -- chess (8x8 grid) -- sudoku (9x9 grid) -- excel (a sheet is an arbitrarily sized 2D array) - -## Remember - -- an array can contain arrays as elements, we call this a 2D arrays -- to iterate through a 2D array, used nested loops - -________________________________________________________________________________ -# Mutability in JavaScript - -So far in the course we've explored a handful of methods that manipulate data. -We'll be growing our arsenal of methods further overtime, so we'll want to gain -awareness for **exactly** how we should expect these methods to manipulate the -data we give them. To this end, let's analyze which methods will modify existing -data and which methods do not. We refer to this concept as **mutability**. - -When you finish this article, you should be able to: - -- Explain what "mutability" is -- Correctly label JavaScript data types as immutable or mutable - -## What is mutability? - -At its face value, _mutability_ is a simple concept. You may be familiar with -the word _mutation_, which refers to a alteration (usually in DNA). Something -that is _mutable_ can be changed, while something that is _immutable_ is -unchanging and permanent. To illustrate this concept, we'll begin with strings -and arrays. We've spent some time with these two data types and by now we -recognize that the two types share many similarities. Both have indices, -`length`, and even share common methods like `slice`. However, they differ -greatly in their mutability: - -```javascript -let myArr = ["b", "e", "a", "m"]; -myArr[0] = "s"; -console.log(myArr); // 'seam' - -let myStr = "beam"; -myStr[0] = "s"; -console.log(myStr); // 'beam' -``` - -Above we have shown that we can assign a new element to an index of an array, -but we cannot assign a new character to an index of a string. In other words, -arrays are _mutable_, but strings are _immutable_. - -An implication of this discovery is that there are _some_ array methods that -will modify an existing array but _zero_ methods that will modify an existing -string. Methods that manipulate string data typically return a _new_ string and -never modify an existing one. A prime example is `toUpperCase`: - -```javascript -let word = "piñata"; -let newWord = word.toUpperCase(); -console.log(word); // 'piñata' -console.log(newWord); // 'PIÑATA' -``` - -Above, notice that the `toUpperCase` method returns a capitalized version of the -string, but does not change the original string. It's also worth noting that not -every array method will mutate. For example, the `slice` method does not mutate -for both strings and arrays. As we learn about methods in the future, we'll be -certain to note what mutates and what does not. - -## Mutable or immutable, that is the question - -Now that we have a grasp of _mutability_, let's take inventory and identify -JavaScript's data types as mutable or immutable. - -**Mutable** - -- array -- object (we'll learn these soon) - -**Immutable** - -- number -- string -- boolean - -A quick way to remember the above list is to identify that the composite types -(the types that can contain multiple values) of array and object are mutable. -The remaining "simpler" types of number, string, and boolean are immutable. - -## The mutability misconception - -Maybe you are having a tough time believing what we have just claimed. We don't -blame you, you've probably heard the saying that change is the only constant in -the universe. Let's debunk a common argument to turn you into a believer. The -skeptical programmer may use this as an argument to show that numbers are -mutable: - -```javascript -let myNum = 42; -myNum += 8; -console.log(myNum); // 50 -``` - -Because the `myNum` variable now contains `50` where it once contained `42`, it -may seem we have mutated the number, but this is not truly the case. Recall that -`myNum += 8` is shorthand for `myNum = myNum + 8`. Since the right hand side of -the assignment evaluates first, we are simply taking the new number of `50` and -reassigning it to the `myNum` variable. This reassignment of a variable name is -not a mutation of the original number. - -## Remember - -- data types that can be changed are mutable, those that cannot be changed are - immutable -- arrays and objects are mutable -- numbers, strings, and booleans are immutable - -________________________________________________________________________________ -# Array Splice - -Time to a learn yet another array method! The [Array#splice][mdn-splice] method -deserves its own reading because of how versatile it is. Feel free to use this -article as a quick reference; let's jump right in. - -When you finish reading this article, you should be able to: - -- list all possible arguments that can be used with the `Array#splice` method - -## Notation - -For clarity in this article and moving forward in the course, we'll be notating -methods with `#` to clarify how they should be called. For example, -`Array#splice` refers to the method that should be called on an array, -`arr.splice()` where `arr` is some array variable. Likewise `String#toUpperCase` -refers to the method that should be called on a string, `str.toUpperCase()` -where `str` is some string variable. We'll opt to refer to methods using this -notation because some methods can be called on multiple data types, such as -`Array#slice` and `String#slice`. - -## What can Array#splice do? - -Before we explore the nitty-gritty details of the `Array#splice` method, the -first thing to be aware of is that the method will **mutate** the array that it -is called on. That is, `Array#splice` will modify the existing array and _not_ -return a new array. - -### Using splice to remove - -The usage of the `Array#splice` method is easy to mix up because it can be used -to remove or insert elements into an array. That's right - it can perform -"opposite" operations, even at the same time! For now, we'll begin by _only_ -removing elements from an array: - -```javascript -let colors = ["red", "yellow", "blue", "green", "orange", "brown", "gray"]; -let returnVal = colors.splice(2, 3); -console.log(colors); // [ 'red', 'yellow', 'brown', 'gray' ] -console.log(returnVal); // [ 'blue', 'green', 'orange' ] -``` - -The first two arguments for splice correspond to 1) the target index and 2) how -many elements to remove. The call `colors.splice(2, 3)`, will remove the next -three elements beginning at index 2. This means that the elements at indices 2, -3, and 4 are removed. - -Note that splice returns an array containing the elements that were removed and -also has the effect of removing the elements from the _original_ array, mutating -it in-place. - -### Using splice to insert - -To use the splice method to insert new elements into an array, we can pass in -any number of additional arguments representing the values to insert: - -```javascript -let colors = ["red", "yellow", "blue"]; -let returnVal = colors.splice(1, 0, "RebeccaPurple", "CornflowerBlue"); -console.log(colors); // [ 'red', 'RebeccaPurple', 'CornflowerBlue', 'yellow', 'blue' ] -console.log(returnVal); // [] -``` - -The method call `colors.splice(1, 0, 'RebeccaPurple', 'CornflowerBlue')` -translates to "target index 1, remove the next 0 elements, then insert -`'RebeccaPurple'` and `'CornflowerBlue'`." - -### Using splice like a pro - -Naturally, we can combine these two functionalities! Say we wanted to target -index 2, remove the next 3 elements, then insert `'Gainsboro'`, `'Ivory'`, and -`'Khaki'`: - -```javascript -let colors = ["red", "yellow", "blue", "green", "black", "beige"]; -let removed = colors.splice(2, 3, "Gainsboro", "Ivory", "Khaki"); -console.log(colors); // [ 'red', 'yellow', 'Gainsboro', 'Ivory', 'Khaki', 'beige' ] -console.log(removed); // [ 'blue', 'green', 'black' ] -``` - -Bam. What a versatile method! Always feel free to reference the -[documentation][mdn-splice] for the method when you are struggling to remember -its usage: - -## Remember - -- Array#splice has two required arguments - - the target index - - the number of elements to remove beginning at that target index -- Array#splice can also take in any number of values to be inserted at the - target index - -[mdn-splice]: - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice - -________________________________________________________________________________ -# String#split and Array#join - -We've seen previously that strings and arrays share many similar properties. For -example, strings and arrays both have a `length` and can have multiple indices. -Because of this, you may find it useful to "convert" between the two types. - -When you finish this article, you should be able to: - -- use the `String#split` method to turn a string into an array -- use the `Array#join` method to turn an array into a string - -## String#split - -The [String#split][string-split-mdn] method is called on a string and accepts a -"separator" string as an argument. The method will return an array where the -elements are the resulting substrings when we cut at the "separators": - -```javascript -let sentence = "follow the yellow brick road"; -let words = sentence.split(" "); -console.log(words); // [ 'follow', 'the', 'yellow', 'brick', 'road' ] -console.log(sentence); // 'follow the yellow brick road' -``` - -Note that the original string is _not mutated_, rather a new array is returned. -A common pattern is to split a sentence string on a space (' '), but you can -split on any separator as you see fit: - -```javascript -let sentence = "follow the yellow brick road"; -console.log(sentence.split(" ")); // [ 'follow', 'the', 'yellow', 'brick', 'road' ] -console.log(sentence.split("the")); // [ 'follow ', ' yellow brick road' ] -console.log(sentence.split("o")); // [ 'f', 'll', 'w the yell', 'w brick r', 'ad' ] -``` - -A pattern you may find useful is that when you split on a separator string, it -is guaranteed that that separator will not be in the resulting array, -effectively removing it. See the example of `sentence.split('the')` above. This -may come in handy, so keep it in mind! - -## Array#join - -The [Array#join][array-join-mdn] method is called on an array and accepts a -"separator" string as an argument. The method will return a string where -elements of the array are concatenated together with the "separator" between -each element: - -```javascript -let words = ["run", "around", "the", "block"]; -let sentence = words.join(" "); -console.log(sentence); // 'run around the block' -console.log(words); // [ 'run', 'around', 'the', 'block' ] - -console.log(words.join("_")); // 'run_around_the_block' -console.log(words.join("HI")); // 'runHIaroundHItheHIblock' -``` - -`Array#join` does not mutate the original array, instead it will return a new -string. - -## A clever combination - -It's pretty evident that `String#split` and `Array#join` are "opposite" methods. -That is: - -- we use split to turn a string into a array -- we use join to turn an array into a string - -By combining these two methods we can accomplish some cool behavior: - -```javascript -let str = "I don't know what I want to eat"; -let newStr = str.split("I").join("we"); -console.log(newStr); // 'we don't know what we want to eat' -``` - -Whoa! We were able to replace every substring "I" with the substring "we". We -know that the line `str.split('I').join('we')` evaluates from left to right. -This means that the `split` will cut the string wherever there is an 'I', -leaving a gap where the 'I's were. Then, the `join` will fill those gaps with -'we's. - -## Remember - -- we can use `String#split` and `Array#join` to convert between strings and - arrays -- both methods do not mutate their input - -[string-split-mdn]: - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split -[array-join-mdn]: - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join - -________________________________________________________________________________ -# WEEK-01 DAY-5
*Control Flow* {ignore=true} -________________________________________________________________________________ -# Determining Types - -Sometimes you want to know the type of value store in a variable so that you can -safely do things with it. If your function expects an array in its parameter but -gets a number, you can't call the `map` method on that! - -In this article you will learn how to figure out if a value in a variable is - -* A string -* A number -* A function -* An array - -## The typeof operator - -Not all operators in JavaScript require two arguments like the `+` operator for -addition, the `=` for assignment, and the `%` operator for modulo division. -Those are all called _binary_ operators because they take two (bi-) operands, -or things that are operated on. - -JavaScript kindly gives you the operator `typeof` which acts on a single value. -Operators that take only one operand are called _unary_ operators because "u -only give them one value!" (That's a joke. "uni-" or "una-" is one.) - -Here are some examples of what you'd expect to see with the `typeof` operator. - -```js -let s = 'This is a string'; -console.log(typeof s); // 'string' - -let n = 6.28; -console.log(typeof n); // 'number' - -let sum = function (a, b) { - return a + b; -} -console.log(typeof sum); // 'function' -``` - -Note that the value returned from the `typeof` operator is a String data type. -So, if you want to check if a value is a number, you could do this. - -```js -if (typeof n === 'number') { - // It is a number. Do some maths! -} else { - console.log('I really wanted a number. :-('); -} -``` - -## How to tell if a value is an array - -Unfortunately, due to a _really old bug_ in the way that JavaScript works, a bug -that no one can fix because people wrote code that relies on the bug for -decades, you cannot use the `typeof` operator to figure out if something is an -array. - -```js -let a = [1, 2, 3]; -console.log(typeof a); // 'object' -``` - -Gee, JavaScript. That's not helpful. Thanks. - -Luckily, it only took 12 years for JavaScript to include a way to test if a -value is an array. To do so, you use the `Array.isArray` method like this. - -```js -let a = [1, 2, 3]; -Array.isArray(a); // true - -let n = 6.28; -Array.isArray(n); // false - -let f = function () {} -Array.isArray(f); // false -``` - -## Practical use in "real" code - -Oddly enough, you won't see a lot of code in real-world applications testing if -a value is one type or another. A lot of JavaScript functions just _assume_ that -they will get arguments of the right kind because the parameter names imply what -kind of value to pass in. For example, the following function has a parameter -named `sentence`. - -```js -function reverseTheSentence(sentence) { - // ... code here ... -} -``` - -Most developers will know that the function probably wants `sentence` to be a -string value. They just won't pass in an array or number or ... well, anything -other than a string. Because that's just not polite. They'd expect any other -kind of value to cause the `reverseTheSentence` to malfunction. Only when you -know that people that don't respect your code will use it should you add in some -kind of check like this. - -```js -function reverseTheSentence(sentence) { - if (typeof sentence !== 'string') { - // Tell the developer they are using - // the function wrong. - } - // ... code here ... -} -``` - -## Remember - -This article has shown you two ways to determine if a value is a kind of type: - -* the `typeof` operator to use to test if a value is a number, a string, or - a function; and, -* the `Array.isArray` method to check if a value is an array. - -Use them as much (or as little) as you need! - -________________________________________________________________________________ -# The Null Type (And Undefined) - -You've met numbers and string, Booleans and arrays. There's another type often -used in JavaScript: the Null type. And, it's a special type. - -In this article, you will learn about the Null type, its value, and how to work -with it in JavaScript. - -## A type with only one value - -You have seen that the String type can have an "infinite" number of values -(within the limits of your computer memory). For example, the String type -represents _any_ of the following values. - -```js -// Examples of values with the String type -'hello, world' -"this is a string" -`Where is my pudding?` -'' -'A really long string.........................................................' -``` - -The Number type also has this aspect. Any number that you can reasonable express -in JavaScript has the Number type. - -```js -// Examples of values with the Number type --100 -99 -6.28 -Infinity -``` - -You also know about the Boolean type. It can have only two values. - -```js -// The only two values of Boolean type -true -false -``` - -There are not _more_ Boolean values. You can't dream up more. There are only -two, those two. - -The Null type has one and exactly one value. - -```js -// The only value that has the Null type -null -``` - -It's just that word: `null`. No quotation marks. No other fancy things. Just -`null`. - -## The meaning of null - -This is a harder subject to tackle because it's a _philosophical_ subject. Many -people ask, "What does the value of `null` mean in a program?" There are a -couple of answers that programmers give to this. None of them are wrong. None of -them are right. They just are. In the presence of `null`, the code you write -determines which of the following meanings `null` has. - -* The value `null` means _the absence of a value_ or _no value_ -* The value `null` means _an unknown value_ -* The value `null` is a nuisance and I hate it and wish it were never invented - -During your software programming career, you will likely have all three of those -opinions, sometimes at the same time. Let's take a look at some examples to try -to figure this out. - -## The absence of a value - -Let's say you wrote a function that splits a string into words, reverses them, -and puts them back together in reverse order. You can do that with the methods - -* `String#split` [link][split]; -* `Array#reverse` [link][reverse]; and, -* `Array#join` [link][join]. - -That function could look like this. - -```js -function reverseTheSentence(sentence) { - let parts = sentence.split(' '); - parts.reverse(); - return parts.join(' '); -} -``` - -That's great! It works! But, what happens if someone doesn't care about what -your function and just decides to pass in something that's not a string? It -would make sense that reversing something that is not a string should lead to no -value, the absence of a value, because the input to the function doesn't make -sense. In that case, you can just return a `null` because there is _no value_ -that the function can return that would make sense. - -```js -function reverseTheSentence(sentence) { - if (typeof sentence !== 'string') { - return null; - } - let parts = sentence.split(' '); - parts.reverse(); - return parts.join(' '); -} -``` - -## An unknown value - -There are a lot of programmers that will argue that `null` cannot be an unknown -value. "The value is known!" they'll exclaim. "The value is 'null'! It's known! -It's 'null'! Stop saying it's not known!" - -There are programmers that vehemently disagree with that. - -![shrug](images/woman-shrugging_1f937-200d-2640-fe0f.png) - -## Checking if a value is null - -If you had hoped that you could use the `typeof` operator to check if a value is -`null`, then you're out of luck. - -```js -// Useless code. -console.log(typeof null); // 'object' -``` - -Silly JavaScript. Instead of using the `typeof` operator, you can just _compare_ -the value to `null` because there is only one value of the Null data type and -it's always `null`. Take a look at the following code and figure out what you -think it will produce. - -```js -let a = []; -let x = null; - -if (a === null) { - console.log('a is null'); -} else if (x === null) { - console.log('x is null'); -} -``` - -## Oh, and there's that undefined value, too - -Just like the `null` value that is the only value of the Null data type, there -is `undefined` which is the only value of the Undefined data type. - -If you're asking yourself, "Wait, if 'null' is no value or the absence of a -value, then what the heck does 'undefined' mean?", well you're not the only one. - -Have a look at this code. - -```js -let value; - -value = 6.28; -console.log(value); -``` - -You probably will not be surprised to see that it will print out "6.28" because -that's the value of `value`. But, what if you did this? What does that new -`console.log` print? - -```js -let value; -console.log(value); // <- what does this print? - -value = 6.28; -console.log(value); -``` - -If you guessed that it prints "undefined", you're right! When you declare a -variable, it's very first value is `undefined`. Most of the time, though, you'll -just immediately set it to a value. - -```js -let value = 6.28; -``` - -So, an uninitialized variable has the value `undefined` which is the only value -of the Undefined data type. To test for it, you can use the `typeof` operator -_or_ the strict equality operator. Using the strict equality operator is the -more common way to do that, now. - -```js -// Test if a value is undefined -if (value === undefined) { - // do a thing -} - -// You can also do it this way, but -// it is considered passé. -if (typeof value === 'undefined') { - // do a thing -} -``` - -## What happens when... - -Interestingly enough, all functions actually _do_ return values. Have a look at -this function. What value does it return? (Not a trick question.) - -```js -function returnsTrue() { - return true; -} -``` - -Yes, it returns the value `true`. But, what about this function? - -```js -function returnsWhat() { - return; -} -``` - -There's a `return` statement there but it does not specify a value. If there is -not value specified, what do you think this function returns? Try putting the -function definition above and the code below into a code runner and seeing what -happens. - -```js -console.log(returnsWhat()); -``` - -One you figure that out, try the same experiment but with this function. What -do you think it returns. It doesn't even have a `return` statement in it! - -```js -function whatIsThis() { -} -``` - -## Remember - -There is a special value in JavaScript represented as `null` which means "no -value" or "unknown value". It is the only value of the Null data type. You can -check that a value is `null` by using the strict equality operator `x === null`. - -The value `undefined` is used by JavaScript for variables that have not been -assigned a value. Also, functions that do not return an explicit value return -the value `undefined`. You can test if a value is `undefined` by using the -strict equality operator `x === undefined`. - -[reverse]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse -[split]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/split -[join]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join - -________________________________________________________________________________ -# Catch Me If You Can - -Sometimes bad things happen to good programs. Some person may enter some badly -formatted information. Another computer may try to attack your program by -sending it wonky data. A network could go down. A file can become corrupt. When -this happens, your running software will have some errors. This article is about -how you can recover from those errors with "structured exception handling". - -In this article you'll learn the answers to: - -* What _is_ structured exception handling? -* How can I do that in JavaScript? -* How can I make my own errors? -* What else can I do with it? -* Shouldn't I just always do this? - -## Structured exception handling - -Oddly enough, there are very few error-handling mechanisms in use, today, in all -programming languages. There are really only three ways that programming -language provide structured exception handling. - -* **Error or error code reporting** as found in languages like C and Go -* **Continuable exceptions** as found in Common Lisp -* **Stack unwinding** which is found in almost every modern programming - language including JavaScript and Python - -In the stack-unwinding paradigm, which is the one you'll use in JavaScript, when -an error occurs, the JavaScript interpreter (the thing running your JavaScript -code) looks for some kind of handler for that error. It has a very specific way -of searching for those handlers. The way JavaScript searches for the handlers is -very similar to the way it happens in Python, C++, Java, C#, and a lot of other -languages. Once you learn it, here, you will be able to handle errors when -writing code in all of those languages. - -## Try and catch - -Say you have some code that may have an error. For example: - -```js -function sumArray(array) { - let sum = 0; - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - return sum; -} -``` - -If someone calls the above function with the code `sumArray(null)`, then they -will get the error because the `for` loop is trying to get the `length` property -of the `array` parameter which is `null`. - -``` -TypeError: Cannot read property 'length' of null -``` - -To prevent this from ruining your program, you wrap code that may have an error -in a **try block**. Now, you've seen other blocks already: `if` blocks, `for` -blocks, `function` blocks. Basically, if there are curly braces around some -lines of code, that's a **code block** of some kind. A _try block_ is just some -curly braces with the `try` keyword. - -```js -// THIS IS AN INCOMPLETE BLOCK OF CODE -function sumArray(array) { - let sum = 0; - - // The try block wraps the for loop. If some - // error occurs, the try block will give you - // a chance to react to it so that the program - // doesn't terminate. - try { - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - } // needs something more here - - return sum; -} -``` - -The `try` block tells JavaScript that it needs to watch the code inside the -curly braces for an error. Now, you have to tell JavaScript what to do when -there _is_ an error. You do that in the `catch` block that should immediately -follow the `try` block. The `catch` block accepts a single parameter that -(usually) contains an object that describes the error that occurred. In the -case of the `sumArray` method, if an error occurs, you could return the value -`undefined` rather than letting an error terminate your program. You could also -log the error to the "error" output. - -```js -function sumArray(array) { - let sum = 0; - - try { - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - } catch (e) { - console.log(e); - return null; - } - - return sum; -} - -sumArray(null); -``` - -Just to state it, again: the _catch block_ runs when an error occurs in the _try -block_. If no error occurs in the _try block_, the _catch block_ **does not -run**. - -That `(e)` after the word `catch` is a variable that contains any error that was -thrown and caught by this `try-catch` block. It doesn't have to be named `e`. - -```js -function sumArray(array) { - let sum = 0; - - try { - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - } catch (pancakes) { - console.log(pancakes); - return null; - } - - return sum; -} - -sumArray(null); -``` - -Here is the same code but, instead of a variable named "e", there is a variable -named "pancakes". Now, if an error is thrown, the variable "pancakes" will -contain it. By long-standing tradition, the variables used with the catch block -are normally "e", "err", or "error". - -```js -// CODE SNIPPET, WILL NOT RUN -} catch (e) { -``` - -```js -// CODE SNIPPET, WILL NOT RUN -} catch (err) { -``` - -```js -// CODE SNIPPET, WILL NOT RUN -} catch (error) { -``` - -Now, when you run the code `sumArray(null)`, you should see something like the -following, if you run it in the online code editor. - -``` -TypeError: Cannot read property 'length' of null - at sumArray (/tmp/file.js:5:31) - at Object. (/tmp/file.js:16:1) - at Module._compile (internal/modules/cjs/loader.js:1158:30) - at Object.Module._extensions..js (internal/modules/cjs/loader.js:1178:10) - at Module.load (internal/modules/cjs/loader.js:1002:32) - at Function.Module._load (internal/modules/cjs/loader.js:901:14) - at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:74:12) - at internal/main/run_main_module.js:18:47 -``` - -In that code sample, after the `sumArray(null)` call, the lines that begins -`TypeError` is the error that occurred. The next 10 lines are what is known as a -**stack trace**. You'll end up seeing these a lot, most likely, as you continue -your career in software programming. This is the first line in understanding -errors in your code. The _stack trace_ shows on the first line where the error -occurred: `sumArray (/tmp/file.js:5:31)` means that it occurred in the -`sumArray` method on line 5 of the content, at character 31. If you open up one -of the coding problems, paste that code block in, and run it, you'll see similar -output in the output block. - -The last line `undefined` is the return value of the `sumArray(null)` invocation -that now happens when an error occurs. - -That is how the so-called **try-catch block** works. - -## How can I make my own errors? - -To create your own errors with structured exception handling, you first need to -create an error object with the message that describes the error. Then, you need -to "throw" the error. That code would look like either of these two lines, the -only difference being the `new` keyword. They both work exactly the same. - -```js -throw Error('this happened because I wanted it to'); -throw new Error('this happened because I wanted it to'); -``` - -## What else is there? - -Turns out that you can have one more block on the _try-catch block_. It is the -**finally block**. The _finally block_ runs whether or not an error occurs. It -_always_ runs. - -```js -function sumArray(array) { - let sum = 0; - - try { - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - } catch (e) { - console.log(e); - return null; - } finally { - console.log('you will always see this.'); - } - - return sum; -} -``` - -## How do I best use this? - -At this point, you may be asking yourself, "Self, since errors can occur -everywhere, shouldn't I just wrap _all_ of my code in these _try-catch blocks_?" - -No. No, you shouldn't. - -Every **try-catch block** introduces another slow-down in your code. If you're -writing code that you want to run as fast as possible, then you write as few -_try-catch blocks_ as possible. Also, it makes the code pretty cluttered with -all of the indentation and curly braces. When at all possible, you should write -**defensive code** which checks for bad values before errors get thrown in your -code. Rather than using a _try-catch block_ in the `sumArray` function, you -could defend against bad values of the `array` parameter like so. - -```js -function sumArray(array) { - if (array === null) { - return null; - } - - let sum = 0; - for (let i = 0; i < array.length; i += 1) { - sum += array[i]; - } - return sum; -} -``` - -## Review - -The _try-catch-finally block_ is a mechanism to handle errors in your code. You -should _not_ wrap all of your code in these blocks because it can seriously -degrade the performance of your application. Instead, only wrap those portions -of the code that you want to guard against throwing exceptions. - -A better choice, in JavaScript and all programming languages, is to be -defensive about your programming and choose to check that the value that you -have has the functionality that you desire by adding code like - -```js -if (value !== undefined) {} -if (value !== null) {} -``` diff --git a/SECURITY.md b/SECURITY.md deleted file mode 100644 index 034e848..0000000 --- a/SECURITY.md +++ /dev/null @@ -1,21 +0,0 @@ -# Security Policy - -## Supported Versions - -Use this section to tell people about which versions of your project are -currently being supported with security updates. - -| Version | Supported | -| ------- | ------------------ | -| 5.1.x | :white_check_mark: | -| 5.0.x | :x: | -| 4.0.x | :white_check_mark: | -| < 4.0 | :x: | - -## Reporting a Vulnerability - -Use this section to tell people how to report a vulnerability. - -Tell them where to go, how often they can expect to get an update on a -reported vulnerability, what to expect if the vulnerability is accepted or -declined, etc. diff --git a/SUMMARY.html b/SUMMARY.html deleted file mode 100644 index 8bcaaae..0000000 --- a/SUMMARY.html +++ /dev/null @@ -1,60 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - Document - - - - - - -

- - - - -

HOME - - - - -

Prep-Work
Resources

- - - diff --git a/SUMMARY.md b/SUMMARY.md deleted file mode 100644 index d7cf987..0000000 --- a/SUMMARY.md +++ /dev/null @@ -1,5 +0,0 @@ -# Table of contents - -* [Prep-Work](README.md) -* [Resources](resources.md) - diff --git a/_Resources/directory.html b/_Resources/directory.html deleted file mode 100644 index 7c6d70e..0000000 --- a/_Resources/directory.html +++ /dev/null @@ -1,25 +0,0 @@ - - - -C:/NEW_BOOTCAMP/Lambda/CIRRICULUMN/prep/_Resources - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/_Resources/left.html b/_Resources/left.html deleted file mode 100644 index 04af645..0000000 --- a/_Resources/left.html +++ /dev/null @@ -1,649 +0,0 @@ - - - - - - /NEW_BOOTCAMP/Lambda/CIRRICULUMN/prep/_Resources - - - Stable - - - - - - - - - - - - - - - - - - - - - - -

Folders

node_modules

simple-side-bar

-
- - - - - diff --git a/_Resources/node_modules/.package-lock.json b/_Resources/node_modules/.package-lock.json deleted file mode 100644 index ab88c62..0000000 --- a/_Resources/node_modules/.package-lock.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "name": "_Resources", - "lockfileVersion": 2, - "requires": true, - "packages": { - "node_modules/jquery": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.6.0.tgz", - "integrity": "sha512-JVzAR/AjBvVt2BmYhxRCSYysDsPcssdmTFnzyLEts9qNwmjmu4JTAMYubEfwVOSwpQ1I1sKKFcxhZCI2buerfw==" - }, - "node_modules/loadashes6": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/loadashes6/-/loadashes6-1.0.0.tgz", - "integrity": "sha512-2UeX69yCIy8rVsPZHnjnaNTvQ8Mh5pMim2SZP3KiZJO/ECmfFuJwF4epHEFOYbZdOmj74bWIxm1H3kCNBsGdSw==" - }, - "node_modules/mout": { - "version": "2.0.0-alpha.1", - "resolved": "https://registry.npmjs.org/mout/-/mout-2.0.0-alpha.1.tgz", - "integrity": "sha512-hwFkg6PGoUiSfOo52Mb/zPNe/HidCnHrz1HlRqyULc8FfzMz6gefuOKlIys/opDKTpqlkz+M+Mg/1NCJpGN81g==" - }, - "node_modules/web-dev-utils": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/web-dev-utils/-/web-dev-utils-1.0.4.tgz", - "integrity": "sha512-VlXEuq6+fsI247gSWR0006Uce3L64niEhIOC6Ll5Qo9LnzH0R13qqkEL1dTBL/kzytD0cMWLTcO71CUF5sYHyQ==", - "dependencies": { - "jquery": "^3.6.0", - "loadashes6": "^1.0.0", - "mout": "^2.0.0-alpha.1" - } - } - } -} diff --git a/_Resources/node_modules/jquery/AUTHORS.txt b/_Resources/node_modules/jquery/AUTHORS.txt deleted file mode 100644 index 0d44990..0000000 --- a/_Resources/node_modules/jquery/AUTHORS.txt +++ /dev/null @@ -1,331 +0,0 @@ -John Resig -Gilles van den Hoven -Michael Geary -Stefan Petre -Yehuda Katz -Corey Jewett -Klaus Hartl -Franck Marcia -Jörn Zaefferer -Paul Bakaus -Brandon Aaron -Mike Alsup -Dave Methvin -Ed Engelhardt -Sean Catchpole -Paul Mclanahan -David Serduke -Richard D. Worth -Scott González -Ariel Flesler -Jon Evans -TJ Holowaychuk -Michael Bensoussan -Robert Katić -Louis-Rémi Babé -Earle Castledine -Damian Janowski -Rich Dougherty -Kim Dalsgaard -Andrea Giammarchi -Mark Gibson -Karl Swedberg -Justin Meyer -Ben Alman -James Padolsey -David Petersen -Batiste Bieler -Alexander Farkas -Rick Waldron -Filipe Fortes -Neeraj Singh -Paul Irish -Iraê Carvalho -Matt Curry -Michael Monteleone -Noah Sloan -Tom Viner -Douglas Neiner -Adam J. Sontag -Dave Reed -Ralph Whitbeck -Carl Fürstenberg -Jacob Wright -J. Ryan Stinnett -unknown -temp01 -Heungsub Lee -Colin Snover -Ryan W Tenney -Pinhook -Ron Otten -Jephte Clain -Anton Matzneller -Alex Sexton -Dan Heberden -Henri Wiechers -Russell Holbrook -Julian Aubourg -Gianni Alessandro Chiappetta -Scott Jehl -James Burke -Jonas Pfenniger -Xavi Ramirez -Jared Grippe -Sylvester Keil -Brandon Sterne -Mathias Bynens -Timmy Willison <4timmywil@gmail.com> -Corey Frang -Digitalxero -Anton Kovalyov -David Murdoch -Josh Varner -Charles McNulty -Jordan Boesch -Jess Thrysoee -Michael Murray -Lee Carpenter -Alexis Abril -Rob Morgan -John Firebaugh -Sam Bisbee -Gilmore Davidson -Brian Brennan -Xavier Montillet -Daniel Pihlstrom -Sahab Yazdani -avaly -Scott Hughes -Mike Sherov -Greg Hazel -Schalk Neethling -Denis Knauf -Timo Tijhof -Steen Nielsen -Anton Ryzhov -Shi Chuan -Berker Peksag -Toby Brain -Matt Mueller -Justin -Daniel Herman -Oleg Gaidarenko -Richard Gibson -Rafaël Blais Masson -cmc3cn <59194618@qq.com> -Joe Presbrey -Sindre Sorhus -Arne de Bree -Vladislav Zarakovsky -Andrew E Monat -Oskari -Joao Henrique de Andrade Bruni -tsinha -Matt Farmer -Trey Hunner -Jason Moon -Jeffery To -Kris Borchers -Vladimir Zhuravlev -Jacob Thornton -Chad Killingsworth -Nowres Rafid -David Benjamin -Uri Gilad -Chris Faulkner -Elijah Manor -Daniel Chatfield -Nikita Govorov -Wesley Walser -Mike Pennisi -Markus Staab -Dave Riddle -Callum Macrae -Benjamin Truyman -James Huston -Erick Ruiz de Chávez -David Bonner -Akintayo Akinwunmi -MORGAN -Ismail Khair -Carl Danley -Mike Petrovich -Greg Lavallee -Daniel Gálvez -Sai Lung Wong -Tom H Fuertes -Roland Eckl -Jay Merrifield -Allen J Schmidt Jr -Jonathan Sampson -Marcel Greter -Matthias Jäggli -David Fox -Yiming He -Devin Cooper -Paul Ramos -Rod Vagg -Bennett Sorbo -Sebastian Burkhard -Zachary Adam Kaplan -nanto_vi -nanto -Danil Somsikov -Ryunosuke SATO -Jean Boussier -Adam Coulombe -Andrew Plummer -Mark Raddatz -Isaac Z. Schlueter -Karl Sieburg -Pascal Borreli -Nguyen Phuc Lam -Dmitry Gusev -Michał Gołębiowski-Owczarek -Li Xudong -Steven Benner -Tom H Fuertes -Renato Oliveira dos Santos -ros3cin -Jason Bedard -Kyle Robinson Young -Chris Talkington -Eddie Monge -Terry Jones -Jason Merino -Jeremy Dunck -Chris Price -Guy Bedford -Amey Sakhadeo -Mike Sidorov -Anthony Ryan -Dominik D. Geyer -George Kats -Lihan Li -Ronny Springer -Chris Antaki -Marian Sollmann -njhamann -Ilya Kantor -David Hong -John Paul -Jakob Stoeck -Christopher Jones -Forbes Lindesay -S. Andrew Sheppard -Leonardo Balter -Roman Reiß -Benjy Cui -Rodrigo Rosenfeld Rosas -John Hoven -Philip Jägenstedt -Christian Kosmowski -Liang Peng -TJ VanToll -Senya Pugach -Aurelio De Rosa -Nazar Mokrynskyi -Amit Merchant -Jason Bedard -Arthur Verschaeve -Dan Hart -Bin Xin -David Corbacho -Veaceslav Grimalschi -Daniel Husar -Frederic Hemberger -Ben Toews -Aditya Raghavan -Victor Homyakov -Shivaji Varma -Nicolas HENRY -Anne-Gaelle Colom -George Mauer -Leonardo Braga -Stephen Edgar -Thomas Tortorini -Winston Howes -Jon Hester -Alexander O'Mara -Bastian Buchholz -Arthur Stolyar -Calvin Metcalf -Mu Haibao -Richard McDaniel -Chris Rebert -Gabriel Schulhof -Gilad Peleg -Martin Naumann -Marek Lewandowski -Bruno Pérel -Reed Loden -Daniel Nill -Yongwoo Jeon -Sean Henderson -Richard Kraaijenhagen -Connor Atherton -Gary Ye -Christian Grete -Liza Ramo -Julian Alexander Murillo -Joelle Fleurantin -Jae Sung Park -Jun Sun -Josh Soref -Henry Wong -Jon Dufresne -Martijn W. van der Lee -Devin Wilson -Steve Mao -Zack Hall -Bernhard M. Wiedemann -Todor Prikumov -Jha Naman -William Robinet -Alexander Lisianoi -Vitaliy Terziev -Joe Trumbull -Alexander K -Damian Senn -Ralin Chimev -Felipe Sateler -Christophe Tafani-Dereeper -Manoj Kumar -David Broder-Rodgers -Alex Louden -Alex Padilla -南漂一卒 -karan-96 -Boom Lee -Andreas Solleder -CDAGaming -Pierre Spring -Shashanka Nataraj -Erik Lax -Matan Kotler-Berkowitz <205matan@gmail.com> -Jordan Beland -Henry Zhu -Saptak Sengupta -Nilton Cesar -basil.belokon -tmybr11 -Luis Emilio Velasco Sanchez -Ed S -Bert Zhang -Andrei Fangli -Marja Hölttä -abnud1 -buddh4 -Pat O'Callaghan -Ahmed.S.ElAfifi -Wonseop Kim -Christian Oliff -Christian Wenz -Sean Robinson -Jonathan -Pierre Grimaud -Beatriz Rezener -Natalia Sroka <37873210+natipo@users.noreply.github.com> -Wonhyoung Park -Dallas Fraser diff --git a/_Resources/node_modules/jquery/LICENSE.txt b/_Resources/node_modules/jquery/LICENSE.txt deleted file mode 100644 index f642c3f..0000000 --- a/_Resources/node_modules/jquery/LICENSE.txt +++ /dev/null @@ -1,20 +0,0 @@ -Copyright OpenJS Foundation and other contributors, https://openjsf.org/ - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/_Resources/node_modules/jquery/README.md b/_Resources/node_modules/jquery/README.md deleted file mode 100644 index 60982f7..0000000 --- a/_Resources/node_modules/jquery/README.md +++ /dev/null @@ -1,62 +0,0 @@ -# jQuery - -> jQuery is a fast, small, and feature-rich JavaScript library. - -For information on how to get started and how to use jQuery, please see [jQuery's documentation](https://api.jquery.com/). -For source files and issues, please visit the [jQuery repo](https://github.com/jquery/jquery). - -If upgrading, please see the [blog post for 3.6.0](https://blog.jquery.com/2021/03/02/jquery-3-6-0-released/). This includes notable differences from the previous version and a more readable changelog. - -## Including jQuery - -Below are some of the most common ways to include jQuery. - -### Browser - -#### Script tag - -```html - -``` - -#### Babel - -[Babel](https://babeljs.io/) is a next generation JavaScript compiler. One of the features is the ability to use ES6/ES2015 modules now, even though browsers do not yet support this feature natively. - -```js -import $ from "jquery"; -``` - -#### Browserify/Webpack - -There are several ways to use [Browserify](http://browserify.org/) and [Webpack](https://webpack.github.io/). For more information on using these tools, please refer to the corresponding project's documentation. In the script, including jQuery will usually look like this... - -```js -var $ = require( "jquery" ); -``` - -#### AMD (Asynchronous Module Definition) - -AMD is a module format built for the browser. For more information, we recommend [require.js' documentation](https://requirejs.org/docs/whyamd.html). - -```js -define( [ "jquery" ], function( $ ) { - -} ); -``` - -### Node - -To include jQuery in [Node](https://nodejs.org/), first install with npm. - -```sh -npm install jquery -``` - -For jQuery to work in Node, a window with a document is required. Since no such window exists natively in Node, one can be mocked by tools such as [jsdom](https://github.com/jsdom/jsdom). This can be useful for testing purposes. - -```js -const { JSDOM } = require( "jsdom" ); -const { window } = new JSDOM( "" ); -const $ = require( "jquery" )( window ); -``` diff --git a/_Resources/node_modules/jquery/bower.json b/_Resources/node_modules/jquery/bower.json deleted file mode 100644 index 95798d5..0000000 --- a/_Resources/node_modules/jquery/bower.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "name": "jquery", - "main": "dist/jquery.js", - "license": "MIT", - "ignore": [ - "package.json" - ], - "keywords": [ - "jquery", - "javascript", - "browser", - "library" - ] -} \ No newline at end of file diff --git a/_Resources/node_modules/jquery/dist/jquery.js b/_Resources/node_modules/jquery/dist/jquery.js deleted file mode 100644 index 7cc0019..0000000 --- a/_Resources/node_modules/jquery/dist/jquery.js +++ /dev/null @@ -1,10984 +0,0 @@ -/*! - * jQuery JavaScript Library v3.6.0 - * https://jquery.com/ - * - * Includes Sizzle.js - * https://sizzlejs.com/ - * - * Copyright OpenJS Foundation and other contributors - * Released under the MIT license - * https://jquery.org/license - * - * Date: 2021-03-02T17:08Z - */ -( function ( global, factory ) { - - "use strict"; - - if ( typeof module === "object" && typeof module.exports === "object" ) { - - // For CommonJS and CommonJS-like environments where a proper `window` - // is present, execute the factory and get jQuery. - // For environments that do not have a `window` with a `document` - // (such as Node.js), expose a factory as module.exports. - // This accentuates the need for the creation of a real `window`. - // e.g. var jQuery = require("jquery")(window); - // See ticket #14549 for more info. - module.exports = global.document ? - factory( global, true ) : - function ( w ) { - if ( !w.document ) { - throw new Error( "jQuery requires a window with a document" ); - } - return factory( w ); - }; - } else { - factory( global ); - } - - // Pass this if window is not defined yet -} )( typeof window !== "undefined" ? window : this, function ( window, noGlobal ) { - - // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 - // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode - // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common - // enough that all such attempts are guarded in a try block. - "use strict"; - - var arr = []; - - var getProto = Object.getPrototypeOf; - - var slice = arr.slice; - - var flat = arr.flat ? function ( array ) { - return arr.flat.call( array ); - } : function ( array ) { - return arr.concat.apply( [], array ); - }; - - - var push = arr.push; - - var indexOf = arr.indexOf; - - var class2type = {}; - - var toString = class2type.toString; - - var hasOwn = class2type.hasOwnProperty; - - var fnToString = hasOwn.toString; - - var ObjectFunctionString = fnToString.call( Object ); - - var support = {}; - - var isFunction = function isFunction( obj ) { - - // Support: Chrome <=57, Firefox <=52 - // In some browsers, typeof returns "function" for HTML

Tables	Are	Cool
col 3 is	right-aligned	$1600
col 2 is	centered	$12
zebra stripes	are neat	$1

Markdown	Less	Pretty
Still	`renders`	nicely
1	2	3

Folders
<Go Back>	A_execut...rcise	B_expres...rcise	C_variab...rcise	D_string...rcise

Folders
<Go Back>	A_execut...ution	B_expres...ution	C_variab...ution	D_string...ution

Folders
<Go Back>	A_functi...rcise	B_functi...rcise	C_functi...rcise

- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -

File	File	File	File	File	File	File	File
alt-README.html	index.html	MAIN-README.html	notes-te....html	readme-a....html	README.html	right.html	Standard....html
BLANK_RE....html

File	File	File	File	File	File	File	File
compare-....html	find-rep....html	letter-c....html	prefix-s....html	replace-....html	right.html	sort-tex....html	whitespa....html
duplicat....html	index.html

File	File	File	File	File	File	File	File
main-style.css	duplicat....html	index.html	prefix-s....html	right.html	sort-tex....html	whitespa....html	README.md
compare-....html	find-rep....html	letter-c....html	replace-....html

- - - - - - - - - -
- site search by - freefind -	- advanced -

Folders
<Go Back>	A_functi...ution	B_functi...ution	C_functi...ution

Folders
<Go Back>	A_loops_exercise	B_loops_exercise	C_loops_exercise

Folders
<Go Back>	A_loops_solution	B_loops_solution	C_loops_solution

Folders
<Go Back>	A_arrays...rcise	B_arrays...rcise	C_arrays...rcise

Folders
<Go Back>	A_arrays...ution	B_arrays...ution	C_arrays...ution

- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -

Folders
<Go Back>	A_nested...rcise	B_two_di...rcise	C_more_p...rcise

Folders
<Go Back>	A_nested...ution	B_two_di...ution	C_more_p...ution

Folders
<Go Back>	A_decomp...rcise	B_decomp...rcise	C_decomp...rcise

Folders
<Go Back>	A_object...rcise	B_object...rcise	C_object...rcise

Folders
-ALL-JS-Files	00_expre...ables	02_functions	04_arrays	06_decom...ttern	08_highe...tions
<Go Back>	01_conditionals	03_loops	05_nesting	07_objects	simple-side-bar

Headings

First Header h1

Second header h2

Third header h3

Fourth header h4

Fifth header h5

Sixth header h6

Subtitles

- Title - Subtitle -

Notes:

Text-level

Content

Notes:

Links

Block-level link title

Lists

Unordered List

Notes:

Ordered List

Definition List

Code

Notes:

Symbols

Notes:

Emoji

Notes:

Tables

Notes:

Interactive

Details

Notes:

Dialog

Notes:

Embedded

Image

Broken Image

Figure with Caption

Inline SVG

Notes:

Picture

Image with Srcset and Sizes

Iframe

Audio

Video

Notes:

Object

Canvas

Notes:

Forms

Text Input

Notes:

Non-text Input

Notes:

Select

Notes:

Checkboxes and Radio Buttons

Buttons

Notes:

Output

Lockup

Notes:

States and Validation

Input

Button States

Notes:

Autocomplete

Notes:

Prep-Work

Notes

How to learn effectively

Hello World

The Number Data Type

The String Data Type

The Boolean Data Type

Comparison Operators

Variables

Functions

Parameters and Arguments

- deployment -

Prep-Work

- Title
- Subtitle -

WEEK 1
Introduction - to JavaScript (Part 1)

- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -
- -	- -	- -	- -	- -	- -	- -	- -	- -	- -