Repository navigation
Expand file tree
/
Copy pathstyling-n-js.html
More file actions
2343 lines (2334 loc) · 151 KB
/
Copy pathstyling-n-js.html
File metadata and controls
2343 lines (2334 loc) · 151 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html>
<head>
<link href="./prism.css" rel="stylesheet">
<link type="image/x-icon" href="/static/favicon.ico" rel="icon">
<link type="font/woff" href="https://lambdaschool-content-cdn.s3.amazonaws.com/fonts/SuisseIntl-Light-WebM.woff"
rel="preload" as="font" crossorigin="anonymous">
<link type="font/woff" href="https://lambdaschool-content-cdn.s3.amazonaws.com/fonts/SuisseIntl-Regular-WebM.woff"
rel="preload" as="font" crossorigin="anonymous">
<link type="font/woff" href="https://lambdaschool-content-cdn.s3.amazonaws.com/fonts/SuisseIntl-Medium-WebM.woff"
rel="preload" as="font" crossorigin="anonymous">
<link type="font/woff"
href="https://lambdaschool-content-cdn.s3.amazonaws.com/fonts/TiemposHeadlineWeb-Regular.woff" rel="preload"
as="font" crossorigin="anonymous">
<link type="font/woff"
href="https://lambdaschool-content-cdn.s3.amazonaws.com/fonts/TiemposHeadlineWeb-RegularItalic.woff" rel="preload"
as="font" crossorigin="anonymous">
<meta name="viewport" content="width=device-width">
<meta charSet="utf-8">
<title>Codex</title>
<meta name="robots" content="noindex, nofollow">
<meta name="next-head-count" content="4">
<link href="/_next/static/css/1ec660952bfce6d06822.css" rel="preload" as="style">
<link data-n-g href="/_next/static/css/1ec660952bfce6d06822.css" rel="stylesheet"><noscript
data-n-css=""></noscript>
<link href="/_next/static/chunks/main-bcea29cef485d2ff4f28.js" rel="preload" as="script">
<link href="/_next/static/chunks/webpack-50bee04d1dc61f8adf5b.js" rel="preload" as="script">
<link href="/_next/static/chunks/framework.abffcf18e526b7c0dbcd.js" rel="preload" as="script">
<link href="/_next/static/chunks/f6078781a05fe1bcb0902d23dbbb2662c8d200b3.1d7278d5916139ff8fd5.js" rel="preload"
as="script">
<link href="/_next/static/chunks/pages/_app-bc37be3f9ebfb49934f6.js" rel="preload" as="script">
<link href="/_next/static/chunks/62fd6c6d.3169d2aaf47600f9c274.js" rel="preload" as="script">
<link href="/_next/static/chunks/5a6ca47b17dc4bcb9b0bc3131ee7e9f4fd30e305.b64ed04365f9737cb9ea.js" rel="preload"
as="script">
<link
href="/_next/static/chunks/pages/tracks/%5BtrackSlug%5D/units/%5BunitSlug%5D/sprints/%5BsprintSlug%5D-2093e8ce28f6da0e7dee.js"
rel="preload" as="script">
<link href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" rel="stylesheet">
</style>
<script src="/prism.js" async defer></script>
</head>
<body>
<iframe height="650px" width="100%" src="https://express-pug-animated-light-show-loop-1.bgoonz.repl.co"
scrolling="no" frameborder="no" allowtransparency="true" allowfullscreen="true"
sandbox="allow-forms allow-pointer-lock allow-popups allow-same-origin allow-scripts allow-modals"></iframe>
<div class="mt-8">
<div class="generated-html">
<section>
<div>
<h2 id="overview">Overview</h2>
<p>You've already started using responsive units to write high-quality stylesheets. In this
sprint we'll expand on that knowledge by covering responsive layouts, media queries, and
accessibility such that you can build websites to work on mobile devices too!</p>
<p>This sprint will also introduce you to the wild world of JavaScript. We'll cover variables,
conditionals, loops, functions, arrays, and objects. These basic skills will be crucial as you go
on
to create dynamic and interactive web pages during your time at Lambda School.</p>
<h3 id="responsive-design">Responsive Design</h3>
<p>Responsive design covers topics that range from fixed layouts to fully responsive websites.
Responsive design addresses accessibility challenges and how developers can use flexible units to
overcome them. On top of being accessible, fully responsive websites are a joy to use and push web
development forward into the future.</p>
<h3 id="intro-to-javascript">Intro to JavaScript</h3>
<p>JavaScript is the backbone of interactive web pages. This module will tackle basic syntax and
logic
in JavaScript including variables, math, conditionals, loops, and functions. These building blocks
will inform the rest of your career as a web developer.</p>
<h3 id="arrays">Arrays</h3>
<p>Arrays allow you, the developer, to work with lots of changing data efficiently to keep code DRY.
Arrays, combined with the programmatic logic from the previous module, provide data to webpages,
and
make your life as a developer, a lot easier.</p>
<h3 id="objects">Objects</h3>
<p>Objects are yet another data type that can be used to store a collection of data (rather than
just
a single value). In this module you'll explore object syntax and some basic methods to work
with object data.</p>
</div>
</section>
<section>
<h1 id="module-responsive-web-design">Responsive Web Design</h1>
<div>
<ul>
<li>
<p><a href="https://www.youtube.com/watch?v=UY17acMdpek">Responsive Design for WEB38 w/Dave
Kidd</a><br>
Learn Responsive Design with Brit Hemming and WEB37</p>
</li>
<li>
<p><a href="https://youtu.be/7OhlPVscwMs">Responsive Design for WEB37 w/Brit Hemming</a><br>
Learn Responsive Design with Brit Hemming and WEB37</p>
</li>
<li>
<p><a href="https://youtu.be/9jUWcnYcF6w">Responsive Design for WEBPT19 w/Dan Frehner</a><br>
Learn Responsive Design with Dan Frehner and WEBPT19</p>
</li>
<li>
<p><a href="https://youtu.be/wWCuVEK7S6I">Responsive Design for WEB35 w/Brit Hemming</a><br>
Learn Responsive Design with Brit Hemming and WEB35</p>
</li>
</ul>
</div>
<div>
<p>
</p>
<h2 id="overview">Overview</h2>
<h3 id="responsive-web-design-layouts">Responsive Web Design Layouts</h3>
<p>Knowing the subtle nuances between responsive web design layouts will allow you to make better
technical decisions for your apps and websites. Let's take a look at some design terms
and
how they translate into code.</p>
<h4 id="fixed-layout">Fixed Layout</h4>
<p>Fixed layouts are what the early web looked like. Designs usually looked good on desktop screens
but would slowly get worse as the browser's viewport got smaller. Horizontal scroll bars were
a
normal feature and you would find yourself pinching and zooming all over mobile devices to read a
website.</p>
<p>The user experience on multiple devices is usually poor, so why are fixed designs still around
today? Because fixed layouts are much cheaper to build and maintain.</p>
<h5 id="features-of-fixed-layout">Features of Fixed Layout</h5>
<ul>
<li>Design is usually desktop only.</li>
<li>CSS widths are usually hardcoded pixels.</li>
<li>Horizontal scroll bars appear as the viewport shrinks smaller than the website's design.
</li>
<li>No media queries are used.</li>
<li>Quicker deployment.</li>
</ul>
<h4 id="fluid-layout">Fluid Layout</h4>
<p>The opposite of a fixed layout is one that could expand and contract in proportion to most
devices.
This sounds great at first, but without constraints, you soon have to think about how your site
will
look on several devices with one set of styles.</p>
<p>Some of the problems of a fluid layout include: images getting too small, buttons growing too
large, and layouts that can grow to be way too spacious on large desktops. It's a constant
game
of white space and content. Fluid layouts still have a place in modern web design but are seen
less
frequently compared to adaptive and responsive.</p>
<h5 id="features-of-fluid-layout">Features of Fluid Layout</h5>
<ul>
<li>Design is often divided among desktop, tablet, or phone</li>
<li>Percent based units instead of hard coded pixels</li>
<li>Everything is designed to proportionally shrink</li>
<li>No media queries are used</li>
</ul>
<h4 id="adaptive-layout">Adaptive Layout</h4>
<p>Adaptive layouts borrow from the speed of a fixed-layout but accommodate different devices at
specific breakpoints in design. For example, an adaptive website may have hardcoded pixels used
for
layout using media queries for different devices.</p>
<p>Adaptive layout is another cheap and easy way to get more content out quickly for a business to
more devices. Adaptive layout still lacks in accommodating for thousands of devices because
care was only given to specific designs at certain breakpoints. It's a lot better than fixed,
but we can do more with a responsive layout.</p>
<h5 id="features-of-adaptive-layout">Features of Adaptive Layout</h5>
<ul>
<li>Design is often divided among desktop, tablet, or phone</li>
<li>Media queries are used</li>
<li>Layout widths are still hardcoded at each media query</li>
<li>Quick deployment for specific devices</li>
</ul>
<h4 id="responsive-layout">Responsive Layout</h4>
<p>Responsive layouts combine features of fixed, adaptive, and fluid websites into one seamless
experience. Media queries are used to constrain responsive units so that as the viewport expands
or
shrinks, you get an experience that looks and functions beautifully across thousands of devices
and
screen sizes.</p>
<p>Responsive sites take more time and effort to create and are the standard long term projects
should
aim for.</p>
<h5 id="features-of-responsive-layout">Features of Responsive Layout</h5>
<ul>
<li>Design is often divided among desktop, tablet, or phone.</li>
<li>Responsive units are used throughout the site.</li>
<li>Media queries are used.</li>
<li>Site accommodates thousands of devices and takes longer to build.</li>
</ul>
<h2 id="follow-along">Follow Along</h2>
<h3 id="responsive-web-design-layout-tutorial">Responsive Web Design Layout Tutorial</h3>
<p>Let's use the same HTML structure to showcase the differences between fixed, fluid,
adaptive,
and responsive layouts. You can use your own editor to follow along or just <a
href="https://codepen.io/lambdaschool/pen/gZwPVg?editors=1100">click this link</a> to see the
codepen version</p>
<p>We will use this HTML:</p>
<pre><code class="html language-html"><div class="container">
<header>
<nav>
<a href="#">Home</a>
<a href="#">About</a>
<a href="#">Blog</a>
<a href="#">Contact</a>
</nav>
</header>
<section class="main-content">
<h1>Layouts</h1>
<p>Testing out different layouts!</p>
</section>
</div></code></pre>
<h3 id="fixed-css">Fixed CSS</h3>
<p>Given the HTML above, let's use the following CSS to provide some constraints and a border
so
we can see our <code>.container</code>.</p>
<pre><code class="css language-css">/* Fixed Layout */
.container {
width: 800px;
padding: 20px;
border: 1px solid red;
margin: 0 auto;
}</code></pre>
<p>Notice the <code>width</code> and <code>padding</code> values are hardcoded pixels. Try resizing
your browser and see where the horizontal scroll bars show up.</p>
<p>This layout makes for really poor user experience if you're on a small screen or any kind of
device that doesn't match the 800px width.</p>
<h3 id="fluid-css">Fluid CSS</h3>
<p>Fluid utilizes the <code>%</code> responsive unit to control layout. Notice that we have to be
careful about the total width of the container adding up to 100%. We have to be careful to update
both the width and padding to equal 100% or we will see horizontal scroll bars again as the
viewport
shrinks.</p>
<p>Comment out the fixed CSS code from above and use our new fluid code.</p>
<pre><code class="css language-css">/* Fluid Layout */
.container {
width: 98%;
margin: 0 auto;
border: 1px solid red;
padding: 20px 1%;
}</code></pre>
<p>Notice how small and how large you can resize the window without hurting the integrity of the web
page. This simple example showcases the major visual difference between fixed and fluid.
Let's
take a look at how adaptive can use media queries to control layout on a specific device.</p>
<h3 id="adaptive-css">Adaptive CSS</h3>
<p>With adaptive layout, we are going to take the fixed layout code and apply media queries to it.
</p>
<p>Comment out the fluid CSS code from above and use our new adaptive code.</p>
<pre><code class="css language-css">/* Adaptive Layout */
.container {
width: 800px;
margin: 0 auto;
border: 1px solid red;
padding: 20px;
}
@media(max-width: 500px) {
.container {
width: 500px;
background: gray;
}
.container header nav {
display: flex;
flex-direction: column;
}
&nbsp;.container header nav a {
margin-bottom: 20px;
}
}</code></pre>
<p>Notice how we added some more styles specifically for our mobile view? This process is part
of
how adaptive "adapts" to the viewport. The problem with this solution is it's still
too rigid.</p>
<h3 id="responsive-css">Responsive CSS</h3>
<p>Responsive uses constraints with <code>%</code> based layouts for that seamless feeling between
devices. For example, we can use a css property of <code>max-width</code> to control the maximum
width of a container while also providing <code>%</code> flexibility below it. Notice how we
changed
<code>.container</code> to now stop growing past <code>800px</code>. Also, note that any
horizontal
margin or padding was converted into a responsive unit.
</p>
<p>These subtle changes will continue to be discussed later in this unit but for now, study the code
and notice it's not that big of a difference when we compare our adaptive layout.</p>
<pre><code class="css language-css">/* Responsive */
.container {
max-width: 800px;
margin: 0 auto;
border: 1px solid red;
&nbsp; padding: 20px 1.25%;
}
@media(max-width: 500px) {
.container {
background: gray;
}
.container header nav {
display: flex;
flex-direction: column;
}
&nbsp;.container header nav a {
margin-bottom: 20px;
}
}</code></pre>
<h2 id="challenge">Challenge</h2>
<h3 id="responsive-web-design-layout-challenge">Responsive Web Design Layout Challenge</h3>
<p>Go to some of your favorite websites and use your browser's developer tools to inspect their
layouts.</p>
<p>Study the HTML and CSS and see how they made their site responsive. You may find responsive units
you have never seen before!</p>
<p>Take note of things you found that were interesting or confusing. Bring those questions or
observations to your group and discuss them in standup.</p>
</div>
<div>
<p>
<center>
<div class="wistia_responsive_padding" style="padding:56.25% 0 0 0;position:relative;">
<div class="wistia_responsive_wrapper" style="height:100%;left:0;position:absolute;top:0;width:100%;">
<iframe class="wistia_embed" name="wistia_embed"
data-src="https://lambdaschool-1.wistia.com/medias/tjl4s520oi" allow="autoplay; fullscreen"
allowtransparency="true" frameborder="0" scrolling="yes" allowfullscreen msallowfullscreen
width="100%" height="100%"></iframe>
</div>
</div>
<script src="https://fast.wistia.net/assets/external/E-v1.js" async></script>
</center>
</p>
<h2 id="overview">Overview</h2>
<p>Max-width and min-width are the keys to the car when it comes to media queries. Understanding
that
"mobile first design" directly translates into min-width is a concept that many new
developers struggle with.</p>
<p>This simple example demonstrates the differences in max and min-width:</p>
<p><a href="https://codepen.io/bigknell/pen/ddYKVq">https://codepen.io/bigknell/pen/ddYKVq</a></p>
<p>Media queries use max and min width to determine where breakpoints are introduced so it's a
big deal to make sure we understand how each works concerning the viewport.</p>
<h2 id="follow-along">Follow Along</h2>
<p>Let's put media queries to work by working on a desktop-down approach. <br><br></p>
<p>Go to this codepen:<br>
<a
href="https://codepen.io/bigknell/pen/GQjGgr?editors=1100">https://codepen.io/bigknell/pen/GQjGgr?editors=1100</a><br>
<br><br><br>
Base colors:<br><br>
box1: aqua<br><br>
box2: azure<br><br>
box3: cadetblue<br><br>
<br><br>
At 1000px and below:<br>
</p>
<ul>
<li>Change the width to 80% for ALL boxes<br></li>
<li>box1: blue<br></li>
<li>box2: green<br></li>
<li>box3: red<br><br>
<br><br>
At 768px and below:<br>
</li>
<li>Change the width to 60% for ALL boxes<br></li>
<li>box1: teal<br></li>
<li>box2: gold<br></li>
<li>box3: pink<br><br>
<br><br>
At 400px and below:<br>
</li>
<li>Change the width to 60% for ALL boxes<br></li>
<li>box1: purple<br></li>
<li>box2: black<br></li>
<li>box3: gray<br></li>
</ul>
<h2 id="challenge">Challenge</h2>
<p>Keep the color and width requirements we just did as a group, but take a mobile first approach by
using min-width.</p>
<p>That means the base colors of: <br>
box1: aqua<br>
box2: azure<br>
box3: cadetblue</p>
<p>Need to show up AFTER 1000px and up. This also means the boxes should go back to 100px at 1000px
and up as well.</p>
<p>This is a solo challenge, please don't share code until the solution is presented!</p>
<p><a
href="https://codepen.io/bigknell/pen/GQjGgr?editors=1100">https://codepen.io/bigknell/pen/GQjGgr?editors=1100</a>
</p>
</div>
<div>
<p>
<center>
<div class="wistia_responsive_padding" style="padding:56.25% 0 0 0;position:relative;">
<div class="wistia_responsive_wrapper" style="height:100%;left:0;position:absolute;top:0;width:100%;">
<iframe class="wistia_embed" name="wistia_embed"
data-src="https://lambdaschool-1.wistia.com/medias/16qifbviuq" allow="autoplay; fullscreen"
allowtransparency="true" frameborder="0" scrolling="yes" allowfullscreen msallowfullscreen
width="100%" height="100%"></iframe>
</div>
</div>
<script src="https://fast.wistia.net/assets/external/E-v1.js" async></script>
</center>
</p>
<h2 id="overview">Overview</h2>
<h3 id="what-is-accessibility">What is Accessibility?</h3>
<p>Web accessibility, as you might expect, deals with making web pages and the internet accessible
to
all people, regardless of how they need to interact with the page. As web developers you should be
designing web pages with <em>all</em> people in mind. Including, but not limited to: those with
slow
internet connection, those on mobile devices, those with auditory, cognitive, neurological, or
physical disabilities,and those with visual needs. Recent studies show that up to 2.5% of all
internet users interact with the web using a screen reader, which is a considerable number of
people.</p>
<h3 id="universal-design-theory">Universal Design Theory</h3>
<p><a href="https://en.wikipedia.org/wiki/Universal_design">Universal design theory</a> states that
designing with the "furthest out" individual in mind will end up benefiting all
individuals who use the product or environment. This theory reaches all sorts of
design—web,
architecture, learning, and more. A commonly used example of universal design theory, applied to a
real-world problem, are ramps on sidewalks. Though they were originally designed for people who
need
wheelchairs, they are used and enjoyed by many others for different needs such as parents with
children in strollers.</p>
<p>The idea of accessibility in web originated because people with disabilities needed to be able to
access the internet in non-traditional ways. Unsurprisingly though, designing accessible websites
has compounding benefits and it helps a plethora of other people. For example, folks using smaller
browser screens are positively impacted by websites designed for those who need larger font sizes.
</p>
<p>Other universal benefits of accessibility include designs intended for permanent physical
impairments that help people with temporary issues (like a broken thumb) and designs intended for
the hearing impaired, for example closed captioning, that help everyone when they're in a
loud
space or can't use headphones.</p>
<h3 id="responsive-units">Responsive Units</h3>
<p>One of the simplest ways to make sure your website is accessible is to use responsive units. We
touched on these already, but scalable units are really important in terms of accessibility. For
example, browsers have settings that allow users to change a page's font size, but that only
works if the associated CSS is scalable—REM, EM, % are all scalable.</p>
<p>A well implemented example of this is the <a href="https://www.whitehouse.gov/">whitehouse.gov</a>
webpage—go ahead and play around with your browser font size, and try zooming in and out to
see what this looks like.</p>
<p>This same logic applies to images and buttons, or really anything and everything that you might
style on your page.</p>
<h3 id="screen-readers">Screen Readers</h3>
<p>Screen readers are a great thing to keep top of mind while designing for accessibility. A screen
reader is a tool (a browser extension or app) that transmits web page data for people with visual
impairments, learning disabilities, or other needs; They usually operate by verbalizing the
content
or sometimes translating into braille. Screen readers read content based on how the HTML is coded,
starting with <code><h1></code> headings, and navigating through other elements accordingly.
</p>
<p>As a web developer, it is important to make sure that your tags are <em>semantic</em> so that
users
who rely on screen readers can navigate accordingly. A webpage made entirely with
<code><div></code> for example, would provide no hierarchy to the screen reader or the user,
and would prevent them from being able to navigate the site.
</p>
<p>Semantic tags typically have english meaning, like <code><header></code>,
<code><main></code>, <code><nav></code>, <code><button></code> and
<code><article></code>. Non-semantic tags are those without any english meaning, like
<code><div></code> and <code><span></code>.
</p>
<p>Similarly, when designing universally, you should be sure to include meaningful id and class
names,
and always give your images "alt" text.</p>
<h3 id="color">Color</h3>
<p>Close to 5% of the population of the United States (about 13 million people) is colorblind. Not
to
mention that plenty of folks view websites in grey scale out of personal preference. Therefore,
when
color is used to convey an important message, the message can be lost on a lot of users.</p>
<p>To avoid this issue, every colorfully displayed component should have a visual counterpart. A
common example of this difference is pictured below. Here, there is a form field showing an error
message. The top example isn't accessible but the bottom is, simply because we added a
symbol.
</p>
<p><img src="https://tk-assets.lambdaschool.com/96fabbf6-aadc-4b38-8a85-a7b2bac6be3f_Slice.png"
alt="Form Accessibility"></p>
<p>In addition, you'll want to use colors that contrast well, and try to avoid red and green in
general, since they are the trickiest colors for people who are colorblind.</p>
<h3 id="final-thoughts">Final Thoughts</h3>
<p>There are entire careers dedicated to making webpages accessible, and this is just the tip of the
iceberg. When it comes to designing for accessibility, it isn't just the right thing to do,
in
many cases, <a href="https://www.section508.gov/manage/laws-and-policies">it's also the
law</a>. We hope this introduction encourages you to employ universal design theory from here on
out!</p>
<h2 id="follow-along">Follow Along</h2>
<p>Study the code below -- What's accessible? What's not? Together, we'll change the
code to make it more accessible.</p>
<p class="codepen" data-default-tab="css,result" data-editable="true" data-height="265"
data-pen-title="Accessibility " data-slug-hash="bGdJEQO" data-theme-id="light" data-user="lambdaschool"
style="height: 265px; box-sizing: border-box; display: flex; align-items: center; justify-content: center; border: 2px solid; margin: 1em 0; padding: 1em;">
<span>See the Pen <a href="https://codepen.io/lambdaschool/pen/bGdJEQO">
Accessibility </a> by Lambda School (<a href="https://codepen.io/lambdaschool">@lambdaschool</a>)
on <a href="https://codepen.io">CodePen</a>.</span>
</p>
<script src="https://static.codepen.io/assets/embed/ei.js" async></script>
<p>One of the first things you should notice above is that every element uses a
<code><div></code> tag. If a screen reader were trying to read this code, it would start
with
"This is some text that isn't as important," instead of the title.
</p>
<p>We can easily change all of the divs to h1, h2, and p tags, to make it compatible with screen
readers. That might look like this:</p>
<pre><code class="html language-html"><h2 class="something">This is some text that isn't as important </h2>
<h1 class="title">This is a title</h1>
<p class="red">This is an important message!</p>
<p class="green">This is an important message!</p></code></pre>
<p>Instantly more accessible! Another big no-no in this pen is the hard-coded pixels. Those should
be
changed to responsive units. You can use the information below or use this super helpful w3
schools
<a href="https://www.w3schools.com/cssref/css_pxtoemconversion.asp">cheat sheet</a> to convert PX
to
EM.
</p>
<pre><code class="css language-css">html{
text-align: center;
margin: 3%;
}
.title {
color: blue;
font-size:120%;
}
.something{
font-size: 56.25%;
}</code></pre>
<p>Finally, let's look at the <code>class</code> names. Since there is so little content on
this
site, it doesn't seem like that matters, but consider what would happen if we started to add
styling, or build out whole classes. Before moving on, change the class "something" to
"subtitle". This helps not only screen readers, but your future developer self.</p>
<pre><code class="html language-html"><h2 class="subtitle">This is some text that isn't as important </h2></code></pre>
<h2 id="challenge">Challenge</h2>
<p>There are a few more non-accessible pieces in the pen above. Make changes according to what you
learned today.</p>
<p>Hint: start with the image and the text colors.</p>
</div>
</section>
<section>
<h1 id="module-intro-to-javascript">Intro to JavaScript</h1>
<div>
<ul>
<li>
<p><a href="https://youtu.be/ktCpmwgJSZs">Intro to JavaScript for Web40 w/Brit Hemming</a><br>
Learn JavaScript with Brit Hemming and Web40</p>
</li>
<li>
<p><a href="https://youtu.be/iUZEsI6NFks">Intro to JavaScript for Web37 w/Brit Hemming</a><br>
Learn JavaScript with Brit Hemming and Web37</p>
</li>
<li>
<p><a href="https://youtu.be/98yrB_HjcmE">Intro to JavaScript for WebPT22 w/Nathan
Braun</a><br>
Learn JavaScript with Nathan Braun and WebPT22</p>
</li>
<li>
<p><a href="https://youtu.be/ZrjXhv9W0vo">Intro to JavaScript for Web35 w/Brit Hemming</a><br>
Learn JavaScript with Brit Hemming and Web35</p>
</li>
<li>
<p><a href="https://youtu.be/6nuWjLu_9u0">Intro to JavaScript for WebPT21 w/Pace
Ellsworth</a><br>
Learn JavaScript with Pace Ellsworth and WebPT21</p>
</li>
<li>
<p><a href="https://youtu.be/3jWupGSON4g">Intro to JavaScript for Web34 w/Brit Hemming</a><br>
Learn JavaScript with Brit Hemming and Web34</p>
</li>
</ul>
</div>
<div>
<p>
<center>
<div class="wistia_responsive_padding" style="padding:56.25% 0 0 0;position:relative;">
<div class="wistia_responsive_wrapper" style="height:100%;left:0;position:absolute;top:0;width:100%;">
<iframe class="wistia_embed" name="wistia_embed"
data-src="https://lambdaschool-1.wistia.com/medias/234li2itp3" allow="autoplay; fullscreen"
allowtransparency="true" frameborder="0" scrolling="yes" allowfullscreen msallowfullscreen
width="100%" height="100%"></iframe>
</div>
</div>
<script src="https://fast.wistia.net/assets/external/E-v1.js" async></script>
</center>
</p>
<h2 id="overview">Overview</h2>
<h3 id="what-is-javascript-and-why-do-we-use-it">What is JavaScript and why do we use it?</h3>
<p>JavaScript is a programming language that was first created in 1994 as a way to add functionality
and interactivity to a website. If we think back to our analogy of a web page as a house, we will
remember that we said that JavaScript is the electricity, plumbing, and gas. It is what makes the
web page "run". JavaScript was originally designed to be used purely on the front end as
a
way for web developers to add functionality to their web pages, and in its early days, it did just
that. Recently, the introduction of the "V8 engine" by Google has improved the speed and
functionality of JS. That led to the development and release of exciting new front end JavaScript
frameworks and eventually Node.js, a way to run JavaScript on a server (back end). This new
development has led to a resurgence of JavaScript. Now, JavaScript is one of the world's most
widely-used programming languages. We can find JavaScript used on the front end, back end, mobile,
Internet of Things (IoT), game development, and really anywhere a traditional programming language
would be used. Though there are later versions, we will be focusing on and using JavaScript ES6 in
this course because it is the most widely applicable.</p>
<h4 id="javascript-vs-java-and-other-languages">JavaScript vs Java (and other languages)</h4>
<p>Keep in mind, JavaScript is not the same as Java. Although they share similar names (this was,
unfortunately, considered a good thing by JavaScript's early pioneers) that is where the
similarities end.</p>
<p>The creators of JavaScript wanted to borrow concepts from other programming languages, such as
Scheme, Java, and C. Those of you with backgrounds in other languages may see things that look
very
familiar, mainly the use of classes and Object-Oriented Programming (OOP) architecture. Keep in
mind
that JavaScript is not a "true" OOP language and many things you may be familiar with
from
another language won't work with JavaScript.</p>
<p>JavaScript is considered a 'loosely' typed language, in which types do exist, but they
are not enforced. You do not have to declare a type when creating a variable or an array, for
instance.</p>
<h4 id="how-to-run-javascript">How to 'run' JavaScript</h4>
<p>For this class, we are going to use a special code sandbox program just like we did with the last
lesson (CodePen), called <a href="https://www.repl.it">repl.it</a>. This will allow us to write
and
edit our code and run it right in our browser window to see a real-time read-out.</p>
<p>While this is one way to run your JavaScript, most JavaScript is run from a file with the
extension
of <code>.js</code> (e.g., <code>fileName.js</code>) and loaded into your browser via the
<code>script</code> tag in your HTML.
</p>
<p>JavaScript, being the de-facto language of the Internet, can also be run directly within an
Internet browser. In fact, you can write all of the JavaScript you want and watch it run in
real-time right in your browser by pressing F12 (for Windows), or Cmd+option+J (for Mac) (for
Google
Chrome). This will open up your <em>console</em> (we will learn more about the console later).</p>
<p><img src="https://i.imgur.com/Q1dilaw.gif" alt="console"></p>
<h3 id="hello-world">Hello World</h3>
<p>Hello World is traditionally used to introduce programmers to a new language. The origins of this
date back to one of the first computer languages, C, where printing the phrase "hello
world" was a major victory.</p>
<p>In JavaScript, printing "Hello, World!" requires just one line of code. Before you move
on, try this example to write your first program!</p>
<iframe data-src="https://repl.it/@sunjieming/Hello-World?lite=true" height="400px" width="100%"
scrolling="yes" frameborder="no" allowtransparency="true" allowfullscreen="true"
sandbox="allow-forms allow-pointer-lock allow-popups allow-same-origin allow-scripts allow-modals"></iframe>
<h3 id="variables">Variables</h3>
<p>At the heart of JavaScript are variables. A variable is a way to store, change and use data in
code. To explain this concept, consider your favorite webpage: maybe it's instagram, maybe an
online game. More than likely, there are lots of changing pieces on these pages - instagram has
likes and usernames, a video game has character selection, game score, and many more - every one
of
those changing bits of data is stored in a variable. The variable called <code>score</code>, for
example, starts with <code>0</code>, and changes every time you gather points in the game.</p>
<p>Similarly, you might create a variable called <code>greet</code> and store the value "Hello
World" to further simplify your program above to <code>console.log(greet)</code>.</p>
<p>The syntax to create a variable is first the keyword, a space, the name we are giving the
variable,
an equal sign, the value we are assigning the variable, and then a semicolon. (A note for those
with
previous programming knowledge: JavaScript is a loosely-typed language, which means that a
variable
can be set, and reset, to any type. We do not need to declare its type when creating the
variable.)
</p>
<p>There are <em>three</em> keywords used to declare variables -<code>var</code>, <code>let</code>,
and <code>const</code>. Each keyword comes with slightly different use cases, mostly based around
what happens when you change the value of the variable. Some examples of syntax are below.</p>
<pre><code class="javascript language-javascript">var firstName = 'John';
let lastName = 'Smith';
const favoriteFood = 'Taco';</code></pre>
<h4 id="var">var</h4>
<p><code>var</code> is the ES5 way of declaring a variable. This is a generic variable keyword.
Variables created with var can be changed without causing errors. While that sounds like a good
thing at first, using <code>var</code> too often might lead to buggy code.</p>
<p>Note in the example below that once you declare the variable, you can change it without having to
declare again. This is true with all variable keywords.</p>
<pre><code class="javascript language-javascript">var firstName = 'Alice';
firstName = 'Bob'; // <- this would be fine</code></pre>
<p>If <code>var</code> is commonly regarded as bad programming practice, what should we use?</p>
<h4 id="const">const</h4>
<p>A <code>const</code> variable is a variable that cannot be changed later in the code. It's
short for "constant". In our example above "Bob" could not be changed to
"Alice" and would throw an error.</p>
<pre><code class="javascript language-javascript">const firstName = 'Alice'
firstName = 'Bob' // <- this would cause an error</code></pre>
<p>This fixes the bug issue, but we know that sometimes variables do need to change - like, the
score
of a game. Is there a better solution?</p>
<h4 id="let">let</h4>
<p>Enter <code>let</code>. <code>let</code> is a new ES6 variable keyword. This will assign a
variable
much like <code>var</code>, but with a little bit different behavior. Most notably, it differs by
creating "block level scope". For our purposes at the moment, <code>let</code> and
<code>var</code> function almost exactly the same. When we get to writing functions and loops, we
can start to use <code>let</code> to our advantage.
</p>
<pre><code class="javascript language-javascript">let firstName = 'Alice';
firstName = 'Bob';</code></pre>
<p>To recap:</p>
<ul>
<li><code>var</code> can be re-assigned and changed.</li>
<li><code>let</code> can be re-assigned but not changed.</li>
<li><code>const</code> cannot be re-assigned nor changed.</li>
</ul>
<p>Because these three keywords achieve the same thing (storing data in memory and assigning that
data
a 'key' that can be used for access) but behave very differently, there are places in
this
world for all three. And of course, as with everything, there are some other intricacies to learn
about the <code>let</code> <code>const</code> and <code>var</code> keywords that we didn't
cover here today.</p>
<p><strong>Lambda School Rule of Thumb</strong> When defining/declaring variables <em>use const
until
you can't, then use let</em>.</p>
<p>We <strong>highly</strong> recommend researching the differences between <code>var</code>,
<code>let</code> and <code>const</code> in terms of their scoping rules as well. We'll cover
more on this later on when talking about function vs. block scoping. But for now, I'll point
you towards the <strong>Dig Deeper</strong> section's link, <strong>How let and const are
scoped in JavaScript</strong>, for some further understanding here.
</p>
<h3 id="primitive-data-types-string-number-boolean">Primitive Data Types (String, Number, Boolean)
</h3>
<p>Primitive data types, also known as basic data types are the simplest data types in JavaScript.
They're sort of like primary colors in that all other data types (which we will learn about
in
later lessons) are made of these types.</p>
<h4 id="strings">Strings</h4>
<p>Strings are blocks of text. They will always be defined with quotation marks around them, either
single or double. Any text with quotes around it (even numbers) are strings.</p>
<pre><code class="javascript language-javascript">const dog = 'fido';
const string = '2';</code></pre>
<h4 id="numbers">Numbers</h4>
<p>Numbers are just that, numbers. Numbers do NOT have quotes around them. They can be negative as
well. JavaScript does have a limitation on the size of a number (+/- 9007199254740991), but only
very rarely will that limitation come up.</p>
<pre><code class="javascript language-javascript">const answer = 42;
const negative = -13;</code></pre>
<h4 id="booleans">Booleans</h4>
<p>Booleans are an important relic from the origins of computer science. It is a dichotomous concept
that powers binary code, still the very core of computers. You may have seen binary code in the
past
(e.g., 0001 0110…). That is Boolean logic. The only booleans in JavaScript are
<code>true</code> and <code>false</code>, traditionally written in lowercase letters. These
variables are useful when you need to employ some kind of dichotomous (or
"yes"/"no") logic in your code.
</p>
<pre><code class="javascript language-javascript">const iLoveJavascript = true;
const isThisaString = false;</code></pre>
<p>Note that while Booleans look like strings, the lack of <code>'</code> around the words
indicates that the variable is a boolean and it will work differently under the hood.</p>
<h3 id="undefined-and-null">Undefined and Null</h3>
<p>There are a couple of JavaScript objects that don't really fit into any type. Those are the
values <code>undefined</code> and <code>null</code>. You will get <code>undefined</code> when you
are looking for a variable that does not have a value yet. <code>undefined</code> simply means
what
you are asking for does not exist.</p>
<pre><code class="javascript language-javascript">console.log(unkownVar); // undefined</code></pre>
<p><code>null</code> is an object that we, the developers, set when we want to tell other developers
that the item they are looking for exists, but there is no value associated with it. While
<code>undefined</code> is set by the JavaScript language, <code>null</code> is set by the
developer.
If you ever receive <code>null</code>, it means that another developer has set that value to
<code>null</code>.
</p>
<pre><code class="javascript language-javascript">let phoneNumber = '123-456-7890';
phoneNumber = null;
phoneNumber; // null</code></pre>
<p>One last thing to note, neither <code>undefined</code> nor <code>null</code> are strings. They
are
written just as they are without quotes around them, like a Boolean.</p>
<h2 id="follow-along">Follow Along</h2>
<iframe data-src="https://repl.it/@sunjieming/Declare-Variables?lite=true" height="400px" width="100%"
scrolling="yes" frameborder="no" allowtransparency="true" allowfullscreen="true"
sandbox="allow-forms allow-pointer-lock allow-popups allow-same-origin allow-scripts allow-modals"></iframe>
<p>Declare a variable called 'name' with the var keyword. Give it the value of your name.
The code below will console.log your variables. Don't touch this code!</p>
<p>To declare a variable with var we first use the <code>var</code> keyword, followed by the name of
our variable, <code>name</code>, and finally the value, <code>Alice</code></p>
<pre><code class="javascript language-javascript">var name = 'Alice';</code></pre>
<p>Declare a variable called 'food' with the let keyword. Give it the value of your
favorite
food. Declaring a variable with let works similarly to <code>var</code>, all we need to do is
change
the keyword to <code>let</code>. Remember that this will allow for mutability, but will show a
warning when you try to change the value.</p>
<pre><code class="javascript language-javascript">let food = 'Pizza';</code></pre>
<p>Declare a variable called birthMonth with the const keyword. Give it the value of your birth
month
(i.e. January or February). Const doesn't allow for mutability, and much like you can't
change your birth month, you can't change the value of this variable declared with
<code>const</code>.
</p>
<pre><code class="javascript language-javascript">const birthMonth = 'February';</code></pre>
<h2 id="challenge">Challenge</h2>
<p>It's time to check your knowledge with a <a
href="https://codepen.io/lambdaschool/pen/zLydNr">Variables Challenge</a>. There is a solution
link at the bottom of the codepen to check your work.</p>
</div>
<div>
<p>
<center>
<div class="wistia_responsive_padding" style="padding:56.25% 0 0 0;position:relative;">
<div class="wistia_responsive_wrapper" style="height:100%;left:0;position:absolute;top:0;width:100%;">
<iframe class="wistia_embed" name="wistia_embed"
data-src="https://lambdaschool-1.wistia.com/medias/pnon34y10u" allow="autoplay; fullscreen"
allowtransparency="true" frameborder="0" scrolling="yes" allowfullscreen msallowfullscreen
width="100%" height="100%"></iframe>
</div>
</div>
<script src="https://fast.wistia.net/assets/external/E-v1.js" async></script>
</center>
</p>
<h2 id="overview">Overview</h2>
<h3 id="math-operators">Math Operators</h3>
<p>Calculators were the first major computer function. In JavaScript, we have built-in math
operators
that work exactly as they do on your calculator.</p>
<h4 id="standard-operators">Standard Operators</h4>
<p>JavaScript can preform any standard operations - addition (<code>+</code>), subtraction
(<code>-</code>), multiplication (<code>*</code>), and division (<code>/</code>) on integers and
strings. There are dozens of practical applications of this, mathematical operations being just
the
beginning.</p>
<pre><code class="javascript language-javascript">1 + 1; // returns 2
2 * 2; // returns 4
2 - 2; // returns 0
2 / 2; // returns 1
const num1 = 2
const num2 = 2
num1 + num2 // returns 4
const string1 = 'My name is'
const string2 = 'Bob'
string1 + string2 // returns 'My name is Bob'</code></pre>
<h3 id="">%</h3>
<p>Something you may not have seen before is the <em>modulo operator</em> (%). This math operator
will
divide two numbers (integers or floats) and return only the remainder. For example, <code>10 /
3</code> is 3 with a remainder of 1, so <code>10 % 3</code> (read as '10 mod 3') will
return <code>1</code> .</p>
<pre><code class="javascript language-javascript">21 % 5; // returns 1
21 % 6; // returns 3
21 % 7; // returns 0</code></pre>
<h3 id="mathpow">Math.pow</h3>
<p>We can use the <code>pow</code> method on <code>Math</code> to return a number raised to an
exponent. It will take two numbers. The first is the base and the second is the power. For
example,
<code>Math.pow(5,2)</code> calculates 5 squared, which is 25. See some more examples below:
</p>
<pre><code class="javascript language-javascript">Math.pow(2,2) // returns 4
Math.pow(3,2) // returns 9
Math.pow(3,3) // returns 27</code></pre>
<h3 id="mathround-mathfloor-mathceil">Math.round, Math.floor, Math.ceil</h3>
<p><code>Math</code> also has methods that will round numbers for us. <code>.round</code> will round
a
number to the nearest whole number. <code>.floor</code> will always round a number down to the
nearest whole number. <code>.ceil</code> will always round up to the nearest whole number.</p>
<pre><code class="javascript language-javascript">Math.round(6.5) // returns 7
Math.round(6.45) // returns 6
Math.floor(6.999) // returns 6
Math.ceil(6.0001) // returns 7</code></pre>
<h3 id="truthiness">Truthiness</h3>
<p>In these lessons, we have talked a lot about the Boolean values, <code>true</code> and
<code>false</code>. When using an <code>if</code> statement or other statements that expect a
Boolean value (such as the <code>!</code>, NOT), if the expression given is not a Boolean value,
JavaScript will do something called type coercion and transform whatever it is given into a
Boolean
value. This is known as "truthy" and "falsey" - yes, seriously. Every data
type
has some truthiness to it. Here are some examples:
</p>
<pre><code class="javascript language-javascript">// items that are interpreted as true
true
1
' '
[] // an array, you'll learn more about this later
{} // an object, you'll learn more about this later
function() {}
// items that are interpreted as false
false
0
undefined
null
''</code></pre>
<h3 id="comparison-operators">Comparison Operators</h3>
<p>JavaScript has a number of comparison and logical operators, (<code>></code>
<code>>=</code>
<code><</code> <code><=</code> <code>===</code> <code>!==</code>). These operators work just
as they would in math: greater than, less than, greater than or equal to, and all the rest. We use
these operators to evaluate two expressions. As the computer runs the code, the operator will
return
either a <code>true</code> (if the statement is true) or a <code>false</code> (if the statement is
not true).
</p>
<pre><code class="javascript language-javascript">1 > 2; // false
2 < 3; // true
10 >= 10; // true
100 <= 1; // false</code></pre>
<p>The "triple equals" sign ( <code>===</code> ) must not be confused with a single equal
sign (which indicates assigning a value to a variable). The triple equal will compare everything
about the two items, including type, and return if they are exactly equal or not.<br>
(Something to note: there is also a "double equals" ( <code>==</code> ) sign which will
compare two items, but it allows type coercion so a string and an integer can be considered equal
(<code>1 == '1' // true</code>). Due to this, it is considered bad practice to use the
double equal sign. We would like to see you always using the triple equal sign, and you will
always
see us using it.)</p>
<pre><code class="javascript language-javascript">1 === 1; // true
1 === '1'; // false
'cat' === 'cat'; // true
'cat' === 'Cat'; // false</code></pre>
<p>The last comparison operator we would like to introduce you to has two parts to it.</p>
<p>First is the "NOT" (<code>!</code>). When you see this it will mean that we are asking
the opposite of the expression (we will revisit the NOT operator later in this lesson).</p>
<p>With that in mind, we can introduce the "not equals" ( <code>!==</code> ) sign. This
will
return true if the items are NOT equal to each other, in any way. This, like the triple equal
sign,
takes type into account.</p>
<pre><code class="javascript language-javascript">1 !== 1; // false
1 !== '1'; // true
'cat' !== 'cat'; // false
'cat' !== 'Cat'; // true</code></pre>
<h3 id="logical-operators">Logical Operators</h3>
<p>We can also combine two equality expressions and ask if either of them are true, both of them are
true, or neither of them is true. To do this we will use Logical Operators.</p>
<h4 id="-1"><code>&&</code></h4>
<p>The first logical operator we will look at is the "AND" operator. It is written with
two
ampersands (&&). This will evaluate both expressions and will return true if BOTH
expressions are true. If one (or both) of them is false, then this operator will return false.<br>
For example, <code>(100 > 10 && 10 === 10)</code> will return true because both
statements are true, but <code>(10 === 9 && 10 > 9)</code> will return false because
one
statement is false.</p>
<h4 id="-2"><code>||</code></h4>
<p>Next up is the "OR" operator. It is written with two vertical bars (||). This operator
will check two expressions and return true if either one is true. It will return false only if
BOTH
expressions are false. As you'd expect a line where both parts are true would return true.
Like
so:</p>
<pre><code class="javascript language-javascript">(100 > 10 || 10 === 10) //true</code></pre>
<p>Similarly this line where only one expression is accurate, would return true. Like this:</p>
<pre><code class="javascript language-javascript">(10 === 9 || 10 > 9) //true</code></pre>
<p>If both expressions are false, like this, then the result will be false.</p>
<pre><code class="javascript language-javascript">(10 === 9 || 1 > 9) //false</code></pre>
<h4 id="-3"><code>!</code></h4>
<p>The last logical operator is the "NOT" operator. It is written as a single exclamation
mark (<code>!</code>). We saw this operator earlier when determining equality (<code>!==</code>).
As
before, the NOT operator will return the opposite Boolean value of what is passed to it.</p>
<p>In this first case, since the opposite of false is true, <code>(!false)</code> would return true.
</p>
<pre><code class="javascript language-javascript">(!false) // true</code></pre>
<p>Similarly since 1 is equal to 1 and this statement is true, <code>!(1===1)</code> would return
false thanks to the <code>!</code> operator.</p>
<pre><code class="javascript language-javascript">(!(1 === 1)) // false</code></pre>
<h4 id="notes-about-logical-operators">Notes About Logical Operators</h4>
<p>A couple things to note about logical operators.</p>
<ul>
<li>
<p>The expressions are evaluated in order, and the computer will skip any redundant expressions.
In an <code>&&</code> statement, if the first expression is <code>false</code>, the
second expression will not be evaluated because BOTH expressions need to be <code>true</code>.
Same for the <code>||</code> statement. If the first expression is <code>true</code>, the
second
will not be evaluated because there only needs to be one <code>true</code> statement to
fulfill
the requirements of the operator.</p>
</li>
<li>
<p>Use parentheses. As we saw in the second <code>!</code> operator example, we used parentheses
to evaluate what was inside of the parentheses FIRST, then applied the <code>!</code>
operator.
We can wrap ANY expression in parentheses and it will be evaluated before evaluating the
expression as a whole.</p>
</li>
</ul>
<h2 id="follow-along">Follow Along</h2>
<p>You may have tried the following riddle on your friend as a kid. Using our knowledge of variables
and math we're going to create a console application to return a person's birthday
starting with just the number <code>7</code>. The steps we need to take are as follows.</p>
<pre><code class="text language-text">Enter the number 7
Multiply by the month of your birth
Subtract 1
Multiply by 13
Add the day of your birth
Add 3
Multiply by 11
Subtract the month of your birth
Subtract the day of your birth
Divide by 10
Add 11
Divide by 100</code></pre>
<iframe data-src="https://repl.it/@sunjieming/Math?lite=true" height="400px" width="100%" scrolling="yes"
frameborder="no" allowtransparency="true" allowfullscreen="true"
sandbox="allow-forms allow-pointer-lock allow-popups allow-same-origin allow-scripts allow-modals"></iframe>
<p>We'll walk through the example for someone born on February 22. First, we need to create our
magical number variable. We'll use <code>let</code> so that this can be easily changed.</p>
<pre><code class="javascript language-javascript">let magicalNumber = 7;</code></pre>
<p>Now, we test the riddle. For every calculation we will need to change the value of
<code>magicalNumber</code> and preform the riddle step.
</p>
<pre><code class="javascript language-javascript">// Multiply by the month of your birth
magicalNumber = magicalNumber * 2
// Subtract 1
magicalNumber = magicalNumber - 1
// Multiply by 13
magicalNumber = magicalNumber * 13
// Add the day of your birth
magicalNumber = magicalNumber + 22
// Add 3
magicalNumber = magicalNumber + 3