Test Bank for Introduction to JavaScript Programming with XML and PHP : 0133068307pdf download
Test Bank for Introduction to JavaScript Programming with XML and PHP : 0133068307pdf download
http://testbankbell.com/product/test-bank-for-introduction-to-
javascript-programming-with-xml-and-php-0133068307/
TestBankBell.com: Your Ultimate Source for Test Banks and Academic Resources
Keywords:
test bank, academic resources, study guides, test preparation, testbankbell, download test
bank, textbook solutions
Contact Information:
Visit us at: https://testbankbell.com - For inquiries, email us:
testbankbell.com@gmail.com
Important Links:
Download Test Banks: https://testbankbell.com/
https://testbankbell.com/product/solution-manual-for-introduction-to-
javascript-programming-with-xml-and-php-0133068307/
testbankbell.com
https://testbankbell.com/product/test-bank-for-php-programming-with-
mysql-the-web-technologies-series-2nd-edition/
testbankbell.com
https://testbankbell.com/product/solution-manual-for-php-programming-
with-mysql-the-web-technologies-series-2nd-edition/
testbankbell.com
https://testbankbell.com/product/solution-manual-for-an-introduction-
to-programming-with-c-8th-edition/
testbankbell.com
https://testbankbell.com/product/solutions-manual-to-accompany-
introduction-to-java-programming-9th-edition/
testbankbell.com
https://testbankbell.com/product/introduction-to-java-programming-
comprehensive-version-10th-edition-liang-test-bank/
testbankbell.com
https://testbankbell.com/product/solution-manual-for-matlab-a-
practical-introduction-to-programming-and-problem-solving-5th-edition/
testbankbell.com
https://testbankbell.com/product/solution-manual-for-revel-for-
introduction-to-python-programming-and-data-structures-y-daniel-liang/
testbankbell.com
Test Bank for Introduction to JavaScript
Programming with XML and PHP:
0133068307
1. Introduction to JavaScript® Programming with XML and PHP Creating Dynamic and
Interactive Web Pages
2. Preface
3. Organization of the Text
4. Brief Chapter Overviews
5. Features of the Text
6. Supplements
7. Contents
8. Location of VideoNotes in the Text
9. Chapter 0: Computer Basics
10. Chapter Objectives
11. 0.1 A Brief History of Computers
12. What Is a Computer?
13. Personal Computers
14. Today’s Computers
15. 0.2 A Brief History of the Internet
16. Packet Switching
17. Transmission Control Protocol / Internet Protocol (TCP/IP)
18. Try It Yourself
19. What Is a URL?
20. The Protocol
21. The Web Server
22. The Domain
23. The Path
24. Is It All Necessary?
25. 0.3 Computer Basics
26. Input
27. Processing
28. Storage
29. Internal Memory
30. Mass Storage Devices
31. Output
32. 0.4 What Is Programming?
33. The History of Programming
34. A Brief Timeline
35. Types of Software
36. Application Software
37. System Software
38. Programming and Scripting Languages
39. Machine Language
40. Assembly Language
41. Machine Language Instruction:
42. Assembly Language Equivalent:
43. High-Level Languages
44. Writing Programs
45. Scripting Languages versus Programming Languages
46. 0.5 Browsers
47. What Is a Browser?
48. Overview of Major Browsers
49. How Does A Browser Work?
50. Is the World Wide Web the Same As the Internet?
51. What Does This Mean to You?
52. 0.6 JavaScript and the Acronyms: XHTML, DOM, PHP, XML
53. A Brief History of JavaScript
54. Web Pages and XHTML
55. Server-Side and Client-Side Technologies
56. JavaScript Overview
57. A Dynamic Language
58. First-Class Functions
59. A Multiparadigm Language
60. How JavaScript Is Used
61. Overview of DOM, PHP, and XML
62. The Document Object Model (DOM)
63. Hypertext Preprocessor (PHP) or Personal Home Page Tools
64. Extensible Markup Language (XML)
65. Chapter Review and Exercises
66. Key Terms
67. Review Exercises
68. Fill in the Blank
69. True or False
70. Short Answer
71. Chapter 1: JavaScript Programming Basics
72. Chapter Objectives
73. 1.1 What Is Programming?
74. A General Problem-Solving Strategy
75. The Program Development Cycle
76. Emphasis on Step 4: Test the Program Extensively!
77. 1.2 The Structure of a Program
78. Input-Processing-Output
79. Input
80. Processing
81. Output
82. The Control Structures
83. The Sequential Structure
84. The Decision (or Selection) Structure
85. The Loop (or Repetition) Structure
86. 1.3 Data Types and Operations on Data
87. Numerical Data
88. String Data
89. Boolean Data
90. Variables and Named Constants
91. Assignment Statements
92. Operations on Data
93. Arithmetic Operators
94. Assignment Operators
95. The Concatenation Operator (+) Used on Strings
96. 1.4 Problem Solving: The Importance of Logical Thinking
97. Pseudocode
98. Flowcharts
99. Flowchart Symbols
100. 1.5 JavaScript in the Web Page
101. The <script></script> Tag Pair
102. The <noscript></noscript> Tag Pair
103. JavaScript in a Web Page <body>
104. JavaScript in the document <head> section
105. The <body> onload Event
106. 1.6 Introduction to Objects
107. What is an Object?
108. Properties and Methods
109. Attributes and Functions
110. The Document Object
111. Dot Notation
112. The write() Method
113. The getElementById() Method and the innerHTML Property
114. getElementById()
115. innerHTML
116. The open() and close() Methods
117. 1.7 Introduction to JavaScript Functions and Events
118. Introduction to JavaScript Functions
119. Parameters
120. The prompt() Function
121. Introduction to JavaScript Events
122. Event Driven Programming
123. 1.8 Putting It to Work
124. Greg’s Gambits: Creating an About You Page
125. Developing the About You Page
126. Writing the Code
127. Prompting for the Player’s Name
128. Prompting for the Player’s Username
129. Selecting an Avatar
130. Finishing the Code
131. Carla’s Classroom: Creating an About You Page
132. Developing the About Me! Page
133. Writing the Code
134. Prompting for the Child’s Name, Age, and Favorite Subject
135. Prompting for the Child’s Favorite Teacher
136. Finishing the Code
137. Chapter Review and Exercises
138. Key Terms
139. Review Exercises
140. Fill in the Blank
141. True or False
142. Short Answer
143. Programming Challenges
144. On Your Own
145. Chapter 2: Building Blocks: Variables and Operators
146. Chapter Objectives
147. 2.1 What Is a Variable?
148. Memory Locations
149. Variable Names
150. Naming Tips
151. Declaring Variables
152. 2.2 Data Types
153. A Loosely Typed Language
154. Numbers
155. Strings and Characters
156. Named Constants
157. 2.3 Arithmetic Operators and Some Important Functions
158. The Modulus Operator
159. The Hierarchy of Operations
160. The Concatenation Operator
161. Parsing Integers and Floating Point Numbers
162. 2.4 Relational Operators
163. ASCII Code
164. Relational Operators
165. 2.5 Logical Operators and the Conditional Operator
166. Logical Operators
167. A Truth Table for the AND , OR , and NOT Operators
168. Boolean Logic and Boolean Operators
169. The Order of Operations for Logical Operators
170. Conditional Operator
171. 2.6 Putting It to Work
172. Greg's Gambits: Creating Your Own Story
173. Developing the Program
174. Writing the Code
175. The charAt() function
176. Finishing the Code
177. Carla's Classroom: A Spelling Lesson
178. Developing the Program
179. Functions
180. The showPrompt1() and showResult1() functions
181. Putting It Together
182. Finishing Up
183. Chapter Review and Exercises
184. Key Terms
185. Review Exercises
186. Fill in the Blank
187. True or False
188. Short Answer
189. Programming Challenges
190. On Your Own
191. Chapter 3: Making Decisions: The Selection Structure
192. Chapter Objectives
193. 3.1 What if? Types of Selection Structures
194. 3.2 The Single Alternative Structure: The if Statement
195. A Note about the Test Condition
196. A Note about the Curly Brackets
197. 3.3 The Dual Alternative Structure: if... else Statements
198. 3.4 Nested Selection Structures
199. 3.5 Compound Conditions
200. Combining Relational and Logical Operators
201. Logical Operators Revisited
202. A Note about Syntax
203. Using AND and OR
204. 3.6 Multiple-Alternative Selection Structures
205. The if... else if... Structure
206. Using if... else if for a Rating System
207. Error Checking: Just the Beginning
208. The Switch Statement
209. Using a switch Statement for Page Color
210. 3.7 Putting It to Work
211. Greg's Gambits: Madame Vadoma Knows All
212. The Math Object
213. The Math.random() and Math.floor() Methods
214. Developing the Program
215. Writing the Code
216. Putting It All Together
217. Finishing Up
218. Carla's Classroom: An Arithmetic Lesson
219. Developing the Program
220. The return Statement
221. The Counter
222. Writing the Code
223. 3.7.2.4.1 The Plan
224. The Code in Pieces
225. 3.7.2.5.1 Level One Code
226. 3.7.2.5.2 Level Two Code
227. 3.7.2.5.3 Level Three Code
228. 3.7.2.5.4 A Comment about Checking the Counter
229. Putting It All Together
230. Finishing Up
231. Chapter Review and Exercises
232. Key Terms
233. Review Exercises
234. Fill in the Blank
235. True or False
236. Short Answer
237. Programming Challenges
238. On Your Own
239. Chapter 4: Going Round and Round: The Repetition Structure
240. Chapter Objectives
241. 4.1 Computers Don’t Get Bored with Repetition
242. Loop Basics
243. Iterations
244. Writing Test Conditions
245. 4.1.1.2.1 Beware the Infinite Loop!
246. 4.1.1.2.2 Don’t Let the User Get Trapped in a Loop
247. 4.2 Types of Loops
248. Pre-Test and Post-Test Loops
249. The Pre-Test while Loop
250. Writing Test Conditions
251. The Post-Test do...while Loop
252. Why Use One and Not the Other?
253. Formatting the Output: The toFixed() Method
254. Sentinel-Controlled Loops
255. Formatting the Output: The toLowerCase() and toUpperCase() Methods
256. Counter-Controlled Loops
257. Using a Counter
258. Shortcut Operators
259. 4.3 The for Loop
260. The for Statement
261. The Initial Value
262. The Test Condition
263. The Increment/Decrement Statement
264. The Careful Bean Counter
265. Curly Braces: Do We Really Need Them?
266. 4.4 Data Validation
267. The isNaN() Method
268. Checking for Integers
269. Using Compound Conditions for Data Validation
270. The charAt() Method
271. The length Property
272. 4.5 Putting It to Work
273. Greg’s Gambits: Encoding Secret Messages
274. What Is Encryption?
275. The charCodeAt() and String.fromCharCode() Methods
276. 4.5.1.2.1 Unicode and ASCII Code
277. 4.5.1.2.2 The charCodeAt() Method
278. 4.5.1.2.3 The String.fromCharCode() Method
279. Developing the Program
280. Writing the Code
281. Putting It All Together
282. Finishing Up
283. Carla’s Classroom: Advanced Arithmetic Lessons
284. Developing the Program
285. Writing the Code
286. The Code in Pieces
287. 4.5.2.3.1 Level One Addition Code
288. 4.5.2.3.2 Level Two and Level Three Addition Code
289. 4.5.2.3.3 Subtraction
290. Putting It All Together
291. 4.5.2.4.1 A Note about Code
292. Finishing Up
293. Chapter Review and Exercises
294. Key Terms
295. Review Exercises
296. Fill in the Blank
297. True or False
298. Short Answer
299. Programming Challenges
300. On Your Own
301. Chapter 5: Advanced Decisions and Loops
302. Chapter Objectives
303. 5.1 Some Simple Schoolroom Statistics
304. It All Adds Up
305. Computing Averages
306. The Range
307. Odd and Even
308. Integer Accuracy: Math Methods
309. The Math.round() Method
310. The Math.floor() and Math.ceil() Methods
311. 5.2 To Continue or Not to Continue?
312. The break Statement
313. The continue Statement
314. 5.3 Nested for Loops
315. Desk Checking
316. Different Ways to Nest Loops
317. Which Way Should Loops Be Nested?
318. 5.4 Drawing Shapes and Patterns with Loops
319. Drawing Shapes
320. Using Loops to Create Patterns
321. The mouse Events
322. 5.5 Putting It to Work
323. Greg’s Gambits: The Battle between Wizard and Troll
324. Developing the Program
325. 5.5.1.1.1 The Button As a Link
326. 5.5.1.1.2 The Web Pages
327. Writing the Code
328. Putting It All Together
329. Finishing Up
330. Carla’s Classroom: A Grammar Lesson
331. Developing the Program
332. Writing the Code
333. The Code in Pieces
334. 5.5.2.3.1 The Function and the Outer Loop
335. 5.5.2.3.2 Check for Valid Selections
336. 5.5.2.3.3 Displaying the Story
337. Putting It All Together
338. Finishing Up
339. Chapter Review and Exercises
340. Key Terms
341. Review Exercises
342. Fill in the Blank
343. True or False
344. Short Answer
345. Programming Challenges
346. On Your Own
347. Chapter 6: Forms and Form Controls
348. Chapter Objectives
349. 6.1 What Is a Form?
350. The Most Basic Form
351. The <form> </form> Tag Pair
352. The submit and reset Buttons
353. Returning Form Submissions
354. The Common Gateway Interface (CGI)
355. Returning Form Data by Email
356. Returning Form Data to a Program
357. 6.2 Form Controls
358. Radio Buttons
359. Checkboxes
360. The checked Property
361. Textboxes
362. The Label, Fieldset, and Legend Elements
363. Textarea Boxes
364. The email action
365. 6.3 Hidden Fields and Passwords
366. The Hidden Form Element
367. The Password Form Element
368. The substr() Method
369. 6.4 Selection Lists and More
370. Selection Lists
371. The size Attribute
372. The multiple Attribute
373. Enhancements for Form Elements
374. The tabindex Attribute
375. The accesskey Attribute
376. The onfocus Event
377. An Introduction to the this Keyword
378. An Image As an OK Button
379. 6.5 Putting It to Work
380. Greg’s Gambits: Player Information and Inventory
381. Developing the Program
382. 6.5.1.1.1 The Web Page Design
383. Writing the Code
384. 6.5.1.2.1 The Textbox Functions
385. 6.5.1.2.2 The Radio Buttons Function
386. 6.5.1.2.3 The Checkbox Functions
387. Putting It All Together
388. Finishing Up
389. Carla’s Classroom: Carla’s Progress Report Form
390. Developing the Program
391. 6.5.2.1.1 Carla’s Categories
392. 6.5.2.1.2 The Page Design
393. Creating the Form
394. Writing the Code
395. 6.5.2.3.1 The Textbox Functions
396. 6.5.2.3.2 The Radio Buttons Functions
397. 6.5.2.3.3 The Textarea Function
398. 6.5.2.3.4 Generating the Email
399. Putting It All Together
400. Finishing Up
401. Chapter Review and Exercises
402. Key Terms
403. Review Exercises
404. Fill in the Blank
405. True or False
406. Short Answer
407. Programming Challenges
408. On Your Own
409. Chapter 7: Keeping it Neat: Functions and JavaScript Source Files
410. Chapter Objectives
411. 7.1 Functions
412. Built-In Functions
413. User-Defined Functions
414. 7.2 The Scope of a Variable
415. Global Variables
416. Local Variables
417. 7.3 Sending Information to a Function
418. Passing Arguments to Parameters
419. The return Statement
420. Passing Values: A Complex Issue
421. Passing by Value
422. 7.4 Objects and Object-Oriented Concepts
423. The Math Object
424. More JavaScript Objects
425. Passing by Reference
426. The Boolean Object
427. 7.4.2.2.1 The new Keyword
428. The Date Object
429. The setTimeout() Function
430. 7.5 JavaScript Source Files
431. Work Smarter, Not Harder
432. Creating and Accessing a JavaScript Source (.js) File
433. JavaScript Source Files Cascade
434. Creating a Library of Functions
435. 7.6 Putting It to Work
436. Greg’s Gambits: Hangman
437. Developing the Program
438. 7.6.1.1.1 The Man in the Noose
439. 7.6.1.1.2 The Secret Words
440. Writing the Code
441. 7.6.1.2.1 The startHangman() Function
442. 7.6.1.2.2 The setCharAt() Function
443. 7.6.1.2.3 The replace() Method and Regular Expressions
444. 7.6.1.2.4 The Revised checkWord() Function
445. Putting It All Together
446. Finishing Up
447. Carla's Classroom: Reading Comprehension
448. Developing the Program
449. Creating the First Page
450. Writing the Code
451. 7.6.2.3.1 Password Protection
452. 7.6.2.3.2 The First Web Page:
453. 7.6.2.3.3 Use the visibility Property to Create a Hidden Button
454. 7.6.2.3.4 Building the Page with Questions
455. 7.6.2.3.5 What the Student Sees
456. Putting It All Together
457. Finishing Up
458. Chapter Review and Exercises
459. Key Terms
460. Review Exercises
461. Fill in the blanks
462. True or False
463. Short Answer
464. Programming Challenges
465. On Your Own
466. Chapter 8: Arrays
467. Chapter Objectives
468. 8.1 One-dimensional Arrays
469. Creating an Array in JavaScript
470. The Array Object
471. A Note About Array Names
472. The length Property
473. Some Methods of the Array Object
474. 8.2 Populating Arrays
475. Loading Arrays Directly
476. Loading Arrays Interactively
477. Displaying Arrays
478. 8.3 Parallel Arrays
479. Why Use Arrays?
480. 8.4 Using Array Methods
481. The push() Method
482. The length Property Can Be Used to Find the Length of an Array
483. The unshift() Method
484. The splice() Method
485. 8.5 Multi-Dimensional Arrays
486. Introduction to Two-Dimensional Arrays
487. Declaring and Filling Two-Dimensional Arrays
488. 8.6 Putting It to Work
489. Greg’s Gambits: The Game of 15
490. Developing the Program
491. 8.6.1.1.1 Setting the Stage
492. 8.6.1.1.2 Creating the Array with the setup() Function
493. 8.6.1.1.3 Populating the Array with the Math.random() Function
494. 8.6.1.1.4 The Code to Exchange Cell Values
495. 8.6.1.1.5 The Code to Check for a Winner
496. Putting It All Together
497. Carla’s Classroom: Images and Imagination
498. Setting Things Up
499. Developing the Program
500. 8.6.2.2.1 Setting the Stage
501. 8.6.2.2.2 The Image Swap
502. 8.6.2.2.2.1 Practice the Image Swap
503. 8.6.2.2.3 The Slide Show
504. Putting It All Together
505. Chapter Review and Exercises
506. Key Terms
507. Review Exercises
508. Fill in the Blank
509. True or False
510. Short Answer
511. Programming Challenges
512. On Your Own
513. Chapter 9: Searching and Sorting
514. Chapter Objectives
515. 9.1 Sorting Arrays
516. The sort() Method
517. Sorting Numbers with the sort() Method
518. The reverse() Method
519. 9.2 The Bubble Sort
520. Swapping Values
521. Using the Bubble Sort Algorithm
522. Passing Arrays
523. 9.3 The Selection Sort
524. 9.4 Searching Arrays: The Serial Search
525. The Serial Search
526. Using the Serial Search with Parallel Arrays
527. 9.5 Searching Arrays: The Binary Search
528. The Binary Search
529. Making Life Easier: The indexOf() Method
530. The indexOf() Method
531. The lastIndexOf() Method
532. Time Out! Using the setInterval() and clearInterval() Methods
533. 9.6 Putting It to Work
534. Greg’s Gambits: Greg’s Boggle
535. Developing the Program
536. Setting the Stage
537. 9.6.1.2.1 Creating the boggle() Function
538. 9.6.1.2.2 The toString() Method
539. 9.6.1.2.3 The boggle() Function
540. Putting It All Together
541. Carla’s Classroom: A Factoring Lesson
542. Factoring Integers
543. Developing the Program
544. Setting the Stage
545. The Code in Pieces
546. 9.6.2.4.1 The External File
547. 9.6.2.4.2 The Beginning
548. 9.6.2.4.3 Selecting the Number and Some Housekeeping Tasks
549. 9.6.2.4.4 The splice() Method
550. 9.6.2.4.5 Getting Student Responses
551. Putting It All Together
552. Chapter Review and Exercises
553. Key Terms
554. Review Exercises
555. Fill in the Blank
556. True or False
557. Short Answer
558. Programming Challenges
559. On Your Own
560. Chapter 10: The Document Object Model and XML
561. Chapter Objectives
562. 10.1 The Document Object Model: DOM
563. A Brief History of DOM
564. DOM Nodes and Trees
565. The Family: The Parent-Child Model
566. Creating and Inserting Elements
567. The createTextNode() Method
568. Replacing and Removing Elements
569. The removeChild() Method
570. The replaceChild() Method
571. The childNodes Property
572. 10.2 Using DOM Methods with Timers and Styles
573. The setAttribute()and getAttribute() Methods
574. The setInterval() and clearInterval() Methods
575. 10.3 XML Basics
576. What Is XML?
577. Why Do We Need XML?
578. XML Components
579. The XML Declaration
580. XML Elements
581. Comments and File Names
582. XML Attributes
583. XML Entities
584. Whitespace
585. Well-Formed XML Documents
586. XML Parsers and DTDs
587. XML Internal DTDs
588. XML External and Public DTDs
589. 10.4 Adding Style and XSL Transformations
590. Using Cascading Style Sheets with XML Documents
591. The Extensible Style Sheet Language (XSL)
592. An Important Note
593. 10.5 XML Namespaces and Schemas
594. XML Namespaces
595. The Uniform Resource Identifier (URI)
596. Namespace Declarations
597. XML Schemas
598. Creating a Reference to a Schema in an XML Document
599. There’s More . . .
600. XML Schema Data Types
601. Creating an XML Schema
602. 10.6 Putting It to Work
603. Greg’s Gambits: Greg’s Avatars
604. Developing the Program
605. Setting the Stage
606. Creating the XML, XSL, and JavaScript Pages
607. 10.6.1.3.1 Creating the XML Page
608. 10.6.1.3.2 Creating the XSL Page
609. 10.6.1.3.3 Creating the JavaScript Page and the DOM Code
610. Putting It All Together
611. Carla’s Classroom: A Spelling Lesson
612. Developing the Program
613. Setting the Stage
614. The Code in Pieces
615. 10.6.2.3.1 The Functions to Extract Values from the Selected Image and
Spelling
616. 10.6.2.3.2 The Function to Compare the Values
617. 10.6.2.3.3 The Function to Check for Success
618. Putting It All Together
619. Chapter Review and Exercises
620. Key Terms
621. Review Exercises
622. Fill in the Blank
623. True or False
Other documents randomly have
different content
The Project Gutenberg eBook of Eutropius
This ebook is for the use of anyone anywhere in the United
States and most other parts of the world at no cost and with
almost no restrictions whatsoever. You may copy it, give it away
or re-use it under the terms of the Project Gutenberg License
included with this ebook or online at www.gutenberg.org. If you
are not located in the United States, you will have to check the
laws of the country where you are located before using this
eBook.
Title: Eutropius
Editor: J. C. Hazzard
Language: English
EUTROPIUS
BY
J. C. HAZZARD, Ph.D.
PROFESSOR OF LATIN, PORTLAND ACADEMY
To
REV. JACOB COOPER, D.D., D.C.L., LL.D.
WITH GRATEFUL AFFECTION
Copyright, 1898, by
AMERICAN BOOK COMPANY.
EUTROPIUS.
W. P. I
PREFACE
The Breviarium of Eutropius has for many years been used
successfully in German schools, but, though an American edition was
published in the early part of this century, the author has of late
years received little attention in this country. Yet in character and
subject the Breviarium is admirably adapted for elementary work.
While the Viri Romae deals only with the early history of Rome and
the lives of a few great men of the republican age, the Breviarium
gives an outline of the history of Rome from the founding of the city
to the death of the Emperor Jovian in 364 a.d., and is thus in subject
closely related to the Latin course. The Latin is good, remarkably so
for the time of its composition, and is not so difficult as that of
Nepos or of parts of the Viri Romae.
In editing the text the beginner has constantly been had in mind,
and so references to the standard Latin Grammars have been added
more copiously than some will consider judicious. It has been found,
however, by experience in the classroom, that a reference to the
grammar when carefully studied is worth far more than a translation
of a difficult passage or comment upon it. The grammatical
references are placed at the bottom of the page where they belong.
In the Notes, which are principally historical and geographical, the
editor has tried to aid the student in mastering the difficulties that
occur rather than to do his work for him. The references to the
histories are intended rather for the teacher than for the pupil. If a
few minutes can be spent every day in reading to the class the
portions referred to, the time will not be wasted, and it will fill in the
outline of the history that the text contains. It is strongly urged that
each student should be provided with a copy of some good outline
of Roman History (Creighton’s Primer is admirable), and follow the
text in it from day to day. In this way a knowledge of the principal
facts of Roman History may be obtained with but slight conscious
effort on the part of the student.
In the analyses of the books and the chapters the accepted dates
have been given, indicating where Eutropius is mistaken in his
chronology. In marking the quantities of the long vowels, Lewis, in
his Elementary Latin Dictionary, has been followed, except where
later authorities differ from him.
The editor desires to acknowledge his obligation to Rev. J. R.
Wilson, D.D., Principal of Portland Academy, for advice and
assistance, and to Professors Arrowsmith and Whicher, for
permission to use material from their First Latin Readings.
The Grammars cited are Harkness’ Standard Latin Grammar (H.),
Mooney (M.), Allen and Greenough (A. & G.), Gildersleeve (G.), and
Bennett (B.). References to Harkness’ new Latin Grammars (1898)
will be found on p. 242.
J. C. H.
Portland, Oregon,
June, 1898.
CONTENTS
PAGE
TEXT
Book I 7
Book II 16
Book III 27
Book IV 36
Book V 46
Book VI 51
Book VII 62
Book VIII 73
Book IX 83
Book X 94
Bibliography 104
NOTES
Life of Eutropius 105
Book I 105
Book II 114
Book III 121
Book IV 129
Book V 136
Book VI 140
Book VII 147
Book VIII 153
Book IX 158
Book X 160
Vocabulary 164
EUTROPĪ
BREVIĀRIĪ AB URBE CONDITĀ
LIBER PRĪMUS
From the Founding of Rome to the Capture of the City by the Gauls,
753-390 b.c. The Regal Period, 753-509 b.c.
LIBER SECUNDUS
From the Capture of the City to the End of The First Punic War,
390-241 b.c.