Objects

שפת JavaScript – הפעם נלמד אובייקטים.

הגדרת אובייקט person עם מאפיינים בקובץ JS

לאובייקט person יש מספר מאפיינים:
– firstName
– lastName
– dateSignup
– fullName מקבלים מפונקציה אנונימית אשר מחזירה מחרוזת firstName+lastName

function printI(){

var person = {
firstName: "Shalom",
lastName : "Rochkind",
dateSignup : 2018,
fullName : function() {
return this.firstName + " " + this.lastName;
}

};

document.getElementById("testID").innerHTML ="First name is: " + person.firstName + ", Last Name is " + person.lastName + ", date signup " + person.dateSignup + "</br>" + person.fullName();

}

מילה שמורה this ב-JS מדגישה שיש לקחת פרמטר מאובייקט עצמו שזה firstName ו-lastName

מטרה של פונקציה אנונימית זה להחזיר משהו מסוים והיא תמיד ללא שם.
במקרה שלנו – אנחנו מחזירים this.firstName + " " + this.lastName

הדפסת מאפיינים של אובייקט PERSON ל-HTML ושינוי טקסט "Let's change it."

לכל מאפיין של האובייקט person ניגשים בצורה:
person.firstName – שזה שם פרטי
person.lastName – שם משפחה

בקובץ HTML נגדיר את התג "id="testID ונקרא לפונקציה ()printI

<!DOCTYPE html>
<html>
<head>
<title>Java Script</title>
<script type="text/javascript" src="MyJavaScript.js"></script>
</head>
<body>

<p id="testID">Let's change it.</p>
<script>printI()</script>
</body>
</html>

בנאי ב-JavaScript

קובץ JS

אותה דוגמה רק עם בנאי:
בקובץ JS הוגדר אובייקט Person עם מאפיינים ב

* firstName
* lastName
* dateSignup
* NameChange

אבל יש כאן כמה הבדלים!

בדוגמה קודמת אובייקט person היה מוגדר כך

var person = { 
firstName: "Shalom", 
lastName : "Rochkind", 
dateSignup : 2018, 
fullName : function() { 
return this.firstName + " " + this.lastName; 
}

בדוגמה הזאת אובייקט person מקבל פרמטרים (firstName,lastName,dateSignup) ולא מוגדר מראש.

בנוסף הגדרנו פונקציה אנונימית (בכחולאשר מקבלת פרמטר newName 
ואז מחליפים את firstName ב-newName  

function printI(){

 function Person(firstName,lastName,dateSignup) 
 { 
 this.firstName = firstName; 
 this.lastName = lastName; 
 this.dateSignup = dateSignup; 
 this.NameChange = function (newName) 
 { 
  this.firstName = newName; 
 } 
 } 

בהמשך נגדיר אובייקט person לפי Person
אשר מקבל פרמטרים:

firstName=Shalom

lastName=Rochkind

2018=dateSignup

var person = new Person("Shalom","Rochkind",2018); 

ואז מדפיסים מאפיינים של אובייקט,
כאשר פניה למאפיין מתבצעת דרך נקודה
– לדוגמה: person.firstName פניה ל-firstName

בנוסף בהתחלה הגדרנו firstName=Shalom
וכזכור יש לנו פונקציה אנונימית אשר עושה שינוי לשם באובייקט person:

this.NameChange = function (newName) { 
this.firstName = newName; 
} 

לכן בעזרת ("person.NameChange("Daniel אנו משנים את firstName מ-Shalom ל-Daniel
ואז מדפיסים שוב.

document.getElementById("testID").innerHTML ="First name is: " + person.firstName + ", Last Name is " + person.lastName + ", date signup " + person.dateSignup + "</br>" + person.fullName();

person.NameChange("Daniel");

document.getElementById("testIDchanged").innerHTML ="First name is: " + person.firstName + ", Last Name is " + person.lastName + ", date signup " + person.dateSignup + "</br>" + person.fullName();

לסיכום קובץ JS שלנו יהיה:

function printI(){

 function Person(firstName,lastName,dateSignup) 
 { 
 this.firstName = firstName; 
 this.lastName = lastName; 
 this.dateSignup = dateSignup; 
 this.NameChange = function (newName) 
 { 
  this.firstName = newName; 
 } 
 } 

  var person = new Person("Shalom","Rochkind",2018); 

  document.getElementById("testID").innerHTML ="First name is: " + person.firstName + ", Last Name is " + person.lastName + ", date signup " + person.dateSignup + "</br>";

 person.NameChange("Daniel"); 

document.getElementById("testIDchanged").innerHTML ="First name is: " + person.firstName + ", Last Name is " + person.lastName + ", date signup " + person.dateSignup + "</br>"; 


}

ובקובץ HTML

הערה: הוספנו עוד תג testIDchanged להדפסה של מאפיינים של האובייקט
לאחר שינוי firstName

<!DOCTYPE html>
<html>
<head>
<title>Java Script</title>
<script type="text/javascript" src="MyJavaScript.js"></script>
</head>
<body>

<p id="testID">Let's change it.</p>
<p id="testIDchanged">Let's change it.</p>
<script>printI()</script>
</body>
</html>

Parameters & functions

שפת JavaScript – הפעם נלמד פרמטרים ופונקציות.

בקובץ HTML נקרא לפונקציה ()printI אשר נמצאת בקובץ JS

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>
<script>printI()</script>
</body>
</html>

בקובץ JS יש לנו קריאה לפונקציה myFunc מתוך הפונקציה ()printI ושימוש במשתנה גלובלי global .

הגדרנו משתנה גלובלי: var global = 15

מה זה משתנה גלובלי?
משתנה גלובלי זה משתנה אשר זמין גם מחוץ לפונקציות וגם בתוך הפונקציות.

לדוגמה במקרה שלנו יש שתי פונקציות ()printI ו-()myFunc אז משתנה global יהיה זמין גם מחוץ לפונקציות האלו וגם בתוך הפונקציות.

הערה: יש לשים לב שמתוך קובץ HTML יש קריאה לפונקציה ()printI ומתוך פונקציה ()printI יש קריאה לפונקציה ()myFunc

var global = 15;

function printI(){
  document.write(global+"<br />");//15 
  myFunc();//now global=16
  document.write("NEW Global:"+global);//16

}

function myFunc() { 
 global++;//15++=16 
}

שימוש בפונקציות מובנות של שפת JavaScript

ראינו איך יוצרים את הפונקציות, אבל ב-JS יש גם פונקציות מוכנות לשימוש.

בקובץ HTML נקרא לפונקציה ()printI אשר נמצאת בקובץ JS

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>
<script>printI()</script>
</body>
</html>

קובץ JS

לדוגמה חישוב PI נעשה דרך Math.PI…

ועוד כמה דוגמאות דוגמאות של הפונקציות מוכנות.

function printI(){

var text = "PI = " + Math.PI;
text += "</br> |-7| = " + Math.abs(-7);
text += "</br> sin(0.3) = " + Math.sin(0.3);
document.write(text+"</br>");

var str = "Some straing";
document.write(str+"</br>");

var text = "Length srting " + str.length;
text += "</br> LOW: " + str.toLowerCase();
text += "</br> UP: " + str.toUpperCase();
text += "</br> FROM 1 up to 5 (included) " + str.substring(0, 4);
text += "</br>THIRD SYMVOL: " + str.charAt(2);
document.write(text+"</br>");

}


עוד דוגמה של פונקציות

כתיבה לתוכן המסמך בעזרת innerHTML ו-getElementById.

ניצור תחילה את הקובץ HTML

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>
<p id="testID"></p>
<script>printI()</script>
</body>
</html>

בקובץ JS נגדיר פונקציה אשר מקבלת שני ערכים X ו-Y ומחזריה את המכפלה של X*Y.

בנוסף מדפיסים על המסך את התוצאה של המכפלה הזאת בקובץ HTML איפה שיש תג  "testID" (הדגשתי את זה בכחול)

function printI(){

function myfun(x, y) { 
  return x * y; 
} 

document.getElementById("testID").innerHTML = myfun(5, 5);

}

Arrays

שפת JavaScript – הפעם נלמד מערכים – Array.

הגדרה והדפסה של מערך

בקובץ HTML נקרא לפונקציה ()printI אשר נמצאת בקובץ JS

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>
<script>printI()</script>
</body>
</html>

בקובץ JS נגדיר משתנה arr אשר מכיל 4 איברים:
0, 1, "str", false

var arr = new Array(0, 1, "str", false);

ואז מריצים לולאה כאשר בהתחלה i=0 לאחר מכן i=1
וכך עד i < arr.length

 for (var i = 0; i < arr.length; i++) 
  { 
     document.write("arr["+i+"]" +" = " + arr[i] + "<br />"); 
   }

ומכיוון שאורך המערך זה מספר איברים במערך arr נקבל
i < 4. זאת אומרת יש לנו הדפסה:

i=0 זה 0=[0]arr
ירידת שורה.

i=1 זה 1=[1]arr
ירידת שורה.

וכך עד i < 4

function printI() { 
 var arr = new Array(0, 1, "str", false);
 for (var i = 0; i < arr.length; i++) {
 document.write("arr["+i+"]" +" = " + arr[i] + "<br />");
 }
}

 

הגדרה והדפסה מערך דו ממדי

בקובץ HTML נקרא לפונקציה ()printI אשר נמצאת בקובץ JS

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>
<script>printI()</script>
</body>
</html>

בקובץ JS נגדיר שלושה משתנים מסוג מערך
arr_3, arr_2 , arr_1

בעזרת הגדרה מסוג ()var arr = new Array
זה מאפשר לנו ליצור מערך בכל אורך מראש.

הערות ב-JS:
אם צריך הערות בקוד(ללא הרצת) אז משתמשים בזה:
// 
או

/*  */

//one line comment

/*
COMMENT TEXT

COMMENTS
*/

אז:

function printI() { 
var arr_1 = new Array();
var arr_2 = new Array();
var arr_3 = new Array();
for (var i = 0; i < 2; i++) 
 arr_1[i] = i;//arr_1[0]=0,arr_1[1]=1
for (var i = 0; i < 3; i++) 
 arr_2[i] = i * 2;//arr_2[0]=0,arr_1[1]=2,arr_1[2]=4
for (var i = 0; i < 4; i++) 
 arr_3[i] = i * 3;//arr_3[0]=0,arr_1[1]=3,arr_1[2]=6,arr_1[3]=9

var arr = new Array(arr_1, arr_2, arr_3);

/*
arr={
{0,1},
{0,2,4},
{0,3,6,9}
}
*/
for (var i = 0; i < arr.length; i++) {
 for (var j = 0; j < arr[i].length; j++)
   document.write(arr[i][j] + " ");
document.write("<br />");
}



}

הסבר:

בעזרת שלושה לולאות כל אחד ממערכים יקבל ערכים (הערות בירוק).

for (var i = 0; i < 2; i++) 
  arr_1[i] = i;//arr_1[0]=0,arr_1[1]=1 
for (var i = 0; i < 3; i++) 
  arr_2[i] = i * 2;//arr_2[0]=0,arr_1[1]=2,arr_1[2]=4 
for (var i = 0; i < 4; i++) 
  arr_3[i] = i * 3;//arr_3[0]=0,arr_1[1]=3,arr_1[2]=6,arr_1[3]=9

לאחר מכן נגדיר עוד מערך בשם arr שכל שורה של המערך הזה יהיה מערך בפני עצמו.
למעשה:

var arr = new Array(arr_1, arr_2, arr_3);
  • שורה ראשונה של המערך arr זה מערך arr_1
  • שורה שניה של המערך arr זה מערך arr_2
  • שורה שלישית של המערך arr זה מערך arr_3

למעשה קבלנו מערך דו-מימדי:

//*
arr={
{0,1},
{0,2,4},
{0,3,6,9}
}
*//

ובסוף יש הדפסת מערך,
כאשר מדפיסים לפי שורה (שורה אחרי שורה).
בנוסף לאחר סיום הדפסה של כל שורה ושורה יש הדפסת ירידת שורה!

document.write("<br />");
  • כאשר i=0 אז מדפיסים שורה ראשונה
  • כאשר i=1 אז מדפיסים שורה שנייה
  • כאשר i=3 אז מדפיסים שורה שלישית

בנוסף (ראה צבע כחול בקוד למעטה) עוברים בכל שורה על עמודה אחרי עמודה.

// arr={arr_1,arr_2,arr_3}=>arr.length=3
for (var i = 0; i < arr.length; i++)
{ 
 for (var j = 0; j < arr[i].length; j++) 
    document.write(arr[i][j] + " "); 
document.write("<br />"); 
}

איך יודעים כמה עמודות יש בכל שורה?
תשובה לפי זה: arr[i].length:

  • בשורה ראשונה i=0 יש 2 עמודות =arr[0].length 
{0,1}//arr[0][0]=0,arr[0][1]=1
  • בשורה שנייה i=1 יש 3 עמודות =arr[1].length
{0,2,4}//arr[1][0]=0,arr[1][1]=2,arr[1][2]=4
  • בשורה שלישית i=2 יש 4 עמודות =arr[2].length
 {0,3,6,9}//arr[2][0]=0,arr[2][1]=3,arr[2][2]=6,arr[2][3]=9

לסיכום קוד JS

function printI() { 
var arr_1 = new Array();
var arr_2 = new Array();
var arr_3 = new Array();
for (var i = 0; i < 2; i++) 
 arr_1[i] = i;//arr_1[0]=0,arr_1[1]=1
for (var i = 0; i < 3; i++) 
 arr_2[i] = i * 2;//arr_2[0]=0,arr_1[1]=2,arr_1[2]=4
for (var i = 0; i < 4; i++) 
 arr_3[i] = i * 3;//arr_3[0]=0,arr_1[1]=3,arr_1[2]=6,arr_1[3]=9

var arr = new Array(arr_1, arr_2, arr_3);

/*
arr={
{0,1},
{0,2,4},
{0,3,6,9}
}
*/
for (var i = 0; i < arr.length; i++) {
 for (var j = 0; j < arr[i].length; j++)
   document.write(arr[i][j] + " ");
document.write("<br />");
}



}

If-for-switch

שפת JavaScript – הפעם נלמד תנאים כגון: if, for, switch.

ניצור HTML קובץ

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>

 <input type="text" placeholder="Type something..." id="myInput">
 <button type="button" onclick="getInputValue();">Get Value</button>

</body>
</html>

וקובץ JS

function getInputValue(){

var inputValue = document.getElementById("myInput").value;
document.write("Your input value:</br>"+"<b>"+inputValue+"</b>");
}

הסבר:

בקובץ HTML הוספנו שדה להכנסת נתונים, אשר מקבלת ערך מסוג טקסט או מספר (text).
בנוסף הגדרנו מה יהיה כתוב בתוך השדה הזה לפני שמקלידים משהו בתוך השדה – Type something

והגדרנו ID בשם myInput לצורך זיהוי של השדה הזה בתוך JS קובץ וגם קובץ CSS

<body>

 <input type="text" placeholder="Type something..." id="myInput">

</body>

אבל אנחנו גם רוצים להוסיף כפתור(button), כף שבלחיצה(onclick) על הכפתור תהיה פעולה.

למעשה בלחיצה על הכפתור תקרא פונקציה בשם ()getInputValue שאותה תקף נגדיר בקובץ JS.

<body>

 <input type="text" placeholder="Type something..." id="myInput">
 <button type="button" onclick="getInputValue();">Get Value</button>

</body>

בקובץ JS הדרנו פונקציה בשם ()getInputValue ובתוך הפונקציה משתנה inputValue אשר מקבל את ערך משדה בקובץ HTML לפי ID ששווה ל-myInput.

בסוף אנו מדפיסים ב-BODY את המשתנה inputValue

* <br/> זה ירידת שורה
* <b> כל משהו בתוך תג b יהיה בולט
* סימן + מקשר בין מחרוזת Your input value למשתנה inputValue

הערה: כל תג HTML כגון <br/>, <b> או מחרוזת Your input value … יש לשים בין הגרשיים
אבל משתנים כגון inputValue יש להשיר ללא גרשיים בתוך ()document.write

function getInputValue(){
var inputValue= document.getElementById("myInput").value;
document.write("Your input value:</br>"+"<b>"+inputValue+"</b>");
}

בסופו של דבר נקבל:

if

קובץ HTML

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>

 <input type="text" placeholder="Type something..." id="myInput">
 <button type="button" onclick="getInputValue();">Get Value</button>

</body>
</html>

בואו נשנה קצת את הקובץ JS, ונוסיף תנאי אשר ידפיס ZERO אם inputValue שווה לאפס
או כל כל משתנה אחר

function getInputValue(){
var inputValue= document.getElementById("myInput").value;

if (inputValue== 0) 
 document.write("ZERO"); 
else 
 document.write("Your value: "+inputValue);
}

לדוגמה:

switch

קובץ HTML

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>

 <input type="text" placeholder="Type something..." id="myInput">
 <button type="button" onclick="getInputValue();">Get Value</button>

</body>
</html>

נניח משתמש מקליד מספר אחד – inputValue=1.

ב-SWITCH בודקים אם:

inputValue=0 התשובה לא => לכן case 0 לא מאתים.

inputValue=1 התשובה כן => לכן case 1 מאתים.
זאת אומרת מדפיסים מספר 1.

דרך אגב, אם משתמש היה מקליד מספר 2,3,4,5…..כל מספר חוץ מ-0 או 1
לפי SWITCH היינו מדפיסים משהו רשום (בdefault).

קובץ JS

function getInputValue()
{ 
  var inputValue= document.getElementById("myInput").value; 

   switch (inputValue) 
   { 
    case 0: document.write("0"); 
     break; 
     case 1: document.write("1"); 
     break; 
     default: document.write(inputValue); 
    }
 }

for

בקובץ HTML נקרא לפונקציה ()printI אשר נמצאת בקובץ JS

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>
<script>printI()</script>
</body>
</html>

הדפסת מספרים מ-1 ועד 10

בהתחלה משתנה i=0, לאחר מכן i=1, …לאחר מכן i=9,
מה קורה כאשר i=10 אז תנאי i < 10 לא יתקיים שזה אומר i=9 ערך מקסימלי.

כאשר כל פעם מדפיסים i+1 זה אומר מ-1 עד 10

קובץ JS

function printI()
{ 
 for (var i = 0; i < 10; i++) 
 { 
  document.write((i+1)+" "); 
 }
}

do-while

בקובץ HTML נקרא לפונקציה ()printI אשר נמצאת בקובץ JS

<!DOCTYPE html>
<html>

<head>
 <link rel="stylesheet" href="mystyle.css"> 
 <script type="text/javascript" src="MyJavaScript.js"></script>
 <title>Welcome to JS and HTML</title>
</head>

<body>
<script>printI()</script>
</body>
</html>

נגדיר משתנה i=10

נכנס לתוך הלולאה ונדפיס i שזה 10
לאחר מכן, i יורד באחד ונקבל i=9
ואז בודקים האם מתקיים תנאי  i > 0 מכיוון ש 0<9 אז ממשיכים שוב לולאה הבא

נכנס לתוך הלולאה ונדפיס i שזה 9
לאחר מכן, i יורד באחד ונקבל i=8
ואז בודקים האם מתקיים תנאי  i > 0 מכיוון ש 0<8 אז ממשיכים שוב לולאה הבא.

כאשר כל פעם מדפיסים את ה-i שזה:
10,9,8,7,6,5,4,3,2,1

וכך עד ש i=0 כאשר i=0 אז תנאי i > 0 לא מתקיים ולכן יוצאים מלולאה.

קובץ JS

var i=10;

do {
document.write(i+" ");
i--;
} while (i > 0);

מבוא ל-HTML/CSS ו-JS

שפת JavaScript – הפעם נלמד איך ניתן להדפיס טבלה.

אבל לפני הכל נלמד קצת HTML וCSS
בואו נסתכל על הקוד הזה:

<!DOCTYPE html>
<html>

 <head>
 <title>Welcome to HTML</title>
 </head>

 <body>
 Shalom people!
 </body>

</html>

הסבר:

 <title>Welcome to HTML</title> 

כותרת לעמוד HTML שלנו "Welcome to HTML"

כל משהו בתוך ה-body רואים בתוכן הדף

<body> 

 Shalom people! 

</body>

במקרה שלנו זה טקסט Shalom people!


הוספת טבלה

<!DOCTYPE html>
<html>
<head>

<link rel="stylesheet" href="C:\HTML-CSS-JS/mystyle.css">

<title>Welcome to HTML</title>
</head>
<body>

 <table>

  <tr>
      <th>Firstname</th>
      <th>Lastname</th>
      <th>City</th>
       <th>Age</th>
 </tr>

 <tr>
     <td>Wulf</td>
     <td>Rapoport</td>
     <td>Netanya</td>
     <td>38</td>
 </tr>

 <tr>
     <td>Rachel</td>
     <td>Rochkind</td>
     <td>Jerusalem</td>
     <td>31</td>
  </tr>

 </table>


</body>
</html>

הוספת קוד CSS

table, th, td {
border: 1px solid black;
width:25%;
}

הסבר:

ב-head הוספנו קישור לקוד של ה-CSS

<head>

<link rel="stylesheet" href="C:\HTML-CSS-JS/mystyle.css">

</head>

מה זה CSS?

תשובה: CSS זה Cascading Style Sheets או במילים פשוטות דרך CSS ניתן לשלוט בעיצוב של העמוד HTML שלנו כגון (צבע הרקע, צבע של טקסט…ועוד).

אז כל בקרה על העיצוב של עמוד HTML שלנו נמצאת בקוד אשר נמצא בקובץ mystyle.css
בקישור: C:\HTML-CSS-JS/mystyle.css

בנוסף ב-Body אנחנו בנינו את הטבלה

<body>

 <table>

  <tr>
      <th>Firstname</th>
      <th>Lastname</th>
      <th>City</th>
       <th>Age</th>
 </tr>

 </table>


</body>
  • <tr></tr> כל משהו בתוך <tr> יהיה בתוך השורה.
  • <th></th> כל משהו בתוך <th> יהיה בתוך העמודה

מסכימים שזה לא נראה כמו טבלה?

למה?
תשובה – חסר כאן עיצוב… זה הזמן לגשת אל הקובץ CSS שלנו

<head>

<link rel="stylesheet" href="C:\HTML-CSS-JS/mystyle.css">

</head>

mystyle.css

table, th, td {
border: 1px solid black;
width:25%;
}

תגים: table, th,td יקבלו עיצוב אשר מוגדר בסוגריים.

border: 1px solid black – קו שחור ברוחב 1px מסביב לתא.

width:25% הגדרה של רוחב הטבלה.

לאחר הוספת CSS נקבל

עכשיו נוסיף עוד שתי שורות (עבור שני אנשים)

<!DOCTYPE html>
<html>
<head>

<link rel="stylesheet" href="C:\HTML-CSS-JS/mystyle.css">

<title>Welcome to HTML</title>
</head>
<body>

 <table>

  <tr>
      <th>Firstname</th>
      <th>Lastname</th>
      <th>City</th>
       <th>Age</th>
 </tr>

 <tr>
     <td>Wulf</td>
     <td>Rapoport</td>
     <td>Netanya</td>
     <td>38</td>
 </tr>

 <tr>
     <td>Rachel</td>
     <td>Rochkind</td>
     <td>Jerusalem</td>
     <td>31</td>
  </tr>

 </table>


</body>
</html>

הדפסת טבלה בעזרת JS

לצורך הרצת JavaScript צריך קודם כל להתקין שרת וירטואלי XAMPP

לאחר התקנת XAMPP יש ליצור תיקיה (תת תיקיה בתוך תיקיה htdocs)

בתוך תיקיה יש ליצור שלושה קבצים:

  • index.html – עמוד HTML שלנו
  • mystyle.css – עיצוב של עמוד HTML
  • MyJavaScript – קובץ JS

עכשיו יש להעפיל Apache וגם אפשר MySQL

נחזור לקובץ HTML , כאן בכחול יש קריאה לקובץ JS אשר ידפיס את הטבלה.

מכיוון שהדפסה באה מקובץ MyJavaScript.js אז לא צריך יותר את HTML קוד בתוך תג body

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Java Script</title>
<link rel="stylesheet" href="mystyle.css">
<script type="text/javascript" src="MyJavaScript.js"></script>
</head>

<body>
</body>
</html>

 

MyJavaScript.js:

הדפסת טבלה, באופן דומה כמו בHTML אלא שכאן משתמשים לצורך הדפסה ב:
 document.write

document.write("<table><tr><th>Firstname</th><th>Lastname</th><th>City</th><th>Age</th></tr><tr><td>Wulf</td><td>Rapoport</td><td>Netanya</td><td>38</td></tr><tr><td>Rachel</td><td>Rochkind</td><td>Jerusalem</td><td>31</td></tr></table>");

הסבר:

בעזרת document.write ניתן להדפיס מילים ואפילו קוד HTML כמו שאנחנו עשינו עם הטבלה (אותו קוד HTML של הטבלה)

לדוגמה
document.write("Hi JavaScript");//Hi JavaScript

ואז יש לגשת בקישור http://localhost/Your-folder ונקבל:

Overriding

שפת Java – הפעם נלמד overriding.

בעזרת Overriding ניתן לשנות מטודה במחלקה ראשית דרך מחלקה היורשת.

נגדיר מחלקה ראשית עם פונקציה move

מטודה move מדפיסה מילה "First"

class First {

public void move() {
System.out.println("First");
}

}

נגדיר מחלקה יורשת בשם Second

class Second extends First {

public void move() {
System.out.println("Second");
}

public void hifun() {
System.out.println("Hi..");
}

}

יש לשים לב שבמחלקה היורשת מוגדרת עם אותו שם פונקציה בשם move.

עכשיו נגדיר שני אובייקטים:
* אובייקט X מבוסס על המחלקה First
* אובייקט Y מבוסס על המחלקה Second

public class TestClass {

public static void main(String args[]) {
First x = new First(); // First reference & object
Second y = new Second(); // Second reference & object

x.move(); // runs the method in First class
y.move(); // runs the method in Second class
y.hifun();
}

}

באדום, x.move מריץ מטודה אשר מוגדרת במחלקה First

לכן יודפס First

class First 
{ 
 public void move() 
 { 
  System.out.println("First"); 
 } 
}

בכחול, x.move מריץ מטודה אשר מוגדרת במחלקה Second

לכן יודפס Second

class Second extends First {

public void move() {
System.out.println("Second");
}


}

צילום מסך של הרצת הקוד אשר למעלה.

כל כבוד לכם!!!

בזה נגמר הקורס מבוא לשפת Java, אני מקווה שהקורס הזה נתן לכם רקע התחלתי בתכנות.

Encapsulation

שפת Java – הפעם נלמד encapsulation.

בעזרת Encapsulation ניתן להגן על איברים של המחלקה.
כפי שניתן לראות בדוגמה הזאת, יש גישה לאיברים של המחלקה
רק דרך הפונקציות.

public class TestClass {
private String x;
private String y;
private int z;


public int getX() {
return x;
}

public String getY() {
return y;
}

public String getZ() {
return z;
}

public void setZ( int z) {
this.z = z;
}

public void setX(String x) {
this.x = x;
}

public void setY( String y) {
this.y = y;
}
}

הסבר:

בעזרת מילה שמורה private אנחנו מגבילים גישה למחלקות יורשות לפרמטרים:
x,y,z

public class TestClass {
private String x;
private String y;
private int z;
}

עם זאת נותנים גישה לפרמטרים האלו תוך שימוש בפונקציות.

כי לפונקציות שלנו יש גישה מסוג public – פתוחות למחלקות יורשות (לאומת private אשר לא פתוחות למחלקות יורשות).

לדוגמה:
* מטודה setX מקבלת פרמטר X מסוג STRING ומאתחלת X של המחלקה בעזרת this.x

* מטודה getX מחזריה את X של המחלקה

public class TestClass {
private String x;
private String y;
private int z;


public void setX(String x) {
this.x = x;
}

public int getX() { 
return x; }
}

דוגמה:

public class MainTestClass{

   public static void main(String args[]) {
      TestClass obj = new TestClass();
      obj.setX("Xtest");
      obj.setZ(12);
      obj.setY("Ytest");

      System.out.print("X: " + obj.getX() + " Z: " + obj.getZ());
   }
}

בצבע כחול מוגדר אובייקט בשם obj מבוסס על המחלקה TestClass

בצבע ירוק בעזרת פונקציה setX מאתחלים X בערך "Xtest"

כזכור:

public class TestClass {
private String x;

public void setX(String x) {
this.x = x;
}
}

כנ"ל בעזרת פונקציה setZ מאתחלים Z בערך 12

public class TestClass {
private int z;

public void setZ( int z) {
this.z = z;
}

}

ובעזרת פונקציה setY מאתחלים Y בערך "Ytest" מסוג STRING

public class TestClass {
private String y;

public void setY( String y) {
this.y = y;
}
}

בסוף מדפיסים

System.out.print("X: " + obj.getX() + " Z: " + obj.getZ());

כאשר פונקציה obj.getX מחזריה ערך X שזה "Xtest"
ופונקציה obj.getZ מחזריה ערך Z שזה 12

דרך אגב אם היינו מנסים לגשת ישירות לפרמטרים האלו (X, Z) כגון

System.out.print("X: " + obj.x + " Z: " + obj.z);

אז היינו מקבלים שגיאת גישה כי לפרמטרים האלו יש סוג פרטי PRIVATE

לכן:

X: Xtest Z: 12

כי:

public class TestClass {
private String x;
private int z;


public int getX() {
return x;//Xtest 
}


public String getZ() {
return z;//12
}


}

ירושה

שפת Java – הפעם נלמד inheritance.

הגדרה של מחלקה בשם Mainclass שממנה תהיה ירושה

class Mainclass {
int x;

Mainclass (int x) {
this.x= x; 
}

public void getX() {
System.out.println("X in super class: " +this.x);
}

}

הסבר:

במחלקה Mainclass הגרנו פרמטר X מסוג Integer
וגם בנאי אשר מקבל פרמטר ומאתחל X בערך מסוג Integer

class Mainclass 
{ 
  int x; 

  Mainclass (int x) 
  { 
    this.x= x; 
  } 
}

כזכור בעזרת this אנחנו מפנים אל פרמטר X אשר הוגדר במחלקה
ומבדילים מפרמטר X שאותו מקבלים בבנאי!

בסוף יש מטודה בשם getX, אשר מדפיסה את הערך X

 public void getX() 
 { 
   System.out.println("X in super class: " +this.x);
 }

דוגמה:

קריאה למטודה ממחלקה ראשית שממנה יש ירושה

public class SubMainclass extends Mainclass {


SubMainclass(int x) {
super(x);//17

public static void main(String args[]) {
SubMainclass obj = new SubMainclass(17);//X in super class: 17
obj.getX();
}

}

הסבר:

מחלקה בשם SubMainclass מקבלת יורשה ממחלקה  Mainclass

public class SubMainclass extends Mainclass {

SubMainclass(int x) {
super(x);//17
}

}

מה זה יורשה?
יורשה זה קבלת כל פרמטרים ומטודות שהוגדרו ממחלקה שממנה יורשים.

* אנחנו עוד נלמד איך אפשר להסתיר פרמטרים ומטודות שלא יהיו נגישים למחלקות יורשות.
** תמיד מחלקה יורשת חייבת להכיל בנאי של המחלקה ראשית!

לכן במחלקה SubMainclass יש כל פרמטרים ומטודות של המחלקה ראשית Mainclass

כזכור לכל מחלקה חייב להיות בנאי ואם זה מדובר במחלקה יורשת אז בנאי חייב להחיל את הבנאי ממחלקה ראשית.

במקרה שלנו למחלקה ראשית Mainclass  יש בנאי

Mainclass (int x) 
{ 
  this.x= x; 
}

לכן במחלקה יורשת SubMainclass יהיה בנאי:

* בעזרת super (מילה שמורה) אנחנו מאתחלים את הבנאי ממחלקה ראשית Mainclass

super(x)

לסיכום זה הבנאי במחלקה היורשת SubMainclass

SubMainclass(int x) 
{
 super(x);//17 
}

עכשיו בו נתמקד במשהו שכתוב בכחול

public class SubMainclass extends Mainclass {


SubMainclass(int x) {
super(x);//17

public static void main(String args[]) {
SubMainclass obj = new SubMainclass(17);//X in super class: 17
obj.getX();
}

}

כאן יש הגדרה של הקוד להרצת תוכנה ב-Java,

public static void main(String args[]) {
SubMainclass obj = new SubMainclass(17);//X in super class: 17
obj.getX();
}

אשר מכיל הגדרה של אובייקט ממחלקה ראשית

SubMainclass obj = new SubMainclass(17);//X in super class: 17

ובעזרה מטודה getX מדפיסים את הביטוי

public void getX() 
{ 
  System.out.println("X in super class: " +this.x);
}

שזה:

"X in super class: 17

Methods

שפת Java – הפעם נלמד methods.

דוגמה איך ניתן לקרוא לפונקציה של מחלקה נוכחית בעזרת this

בצבע כחול יש אתחול בנאי ריק

 בצבע אדום יש אתחול בנאי שמקבל פרמטר מספרי ומאתחל ערך X של המחלקה

בצבע ירוק יש קריאה לפונקציה שנמצאת במחלקה שלנו לכן משתמשים ב-this

public class Some_Class
{
   int x=1;

   Some_Class()
   {
     //empty constructor 
   }

   Some_Class(int num)
   {
     this.x=num;
   }

   public void greet() 
   {
   System.out.println("I am greet method" + x);
   }

   public void print() 
   {
   this.greet();// THIS calls the method -greet- in our class    
   }
}

הסבר:

WOW סוף סוף נלמד קצת על OOP – Object-oriented programming 

אז מה זה מחלקה?
מטרה של מחלקה ליצור בסיס מסוים ועל סמך אותו בסיס ליצור אובייקטים שונים אחד מהשני אבל באים מאותו בסיס.

אז יש לנו מחלקה בשם Some_Class

public class Some_Class {
}

במחלקה הגדרנו פרמטר X מסוג Integer (מספר שלם)

int x=1;

ובנאי ריק

Some_Class()  
{ 
 //empty constructor   
}

מה זה בנאי?

בנאי=בונה=>לבנות : )

בנאי עוזר לנו לבנות מחלקה שלנו ופשוט יש כלל ב-Java לכל מחלקה חייב להיות בנאי!
בנוסף לפי הכלל הזה, שם של בנאי חייב להיות זהה לשם של המחלקה.

בנאי יכול להיות ריק ויכול לקבל פרמטרים.

במקרה שלנו – בנאי לא מקבל פרמטרים ולכן הוא בנאי ריק.

Some_Class()  
{ 
 //empty constructor   
}

בנוסף במחלקה שלנו קיים עוד בנאי אשר מקבל פרמטר num מסוג Integer

Some_Class(int num)  
{  
  this.x=num;  
}

מה זה "this"?

בעזרת this יש הפניה לפרמטר אשר שייך למחלקה שלנו.
זוכרים את הפרמטר x אשר הוגדרנו בהתחלה של מחלקה?

int x=1;

אז במקום 1 פרמטר X יקבל ערך שווה ל-num

הגדרת מטודה במחלקה

public void greet() 
{ 
   System.out.println("I am greet method" + x); 
}

מה זה מטודה?

מטרה של מטודה זה להגדיר פעילות מסוימת (אופי) למחלקה.
במקרה שלנו יש לנו מטודה מסוג VOID בשם greet אשר מדפיסה:

System.out.println("I am greet method" + x);

מה זה סוג VOID?

כל מטודה יכולה להחזיר ערך מסוים ולא להחזיר.
מכיוון שאנחנו רוצים רק להדפיס ולא להחזיר ערך – אז מטודה שלנו תהיה מסוג void

מטודה מסוג VOID לא מחזירה ערך או אובייקט…

בנוסף יש לנו עוד מטודה בשם print

public void print()   
{ 
  this.greet();// THIS calls the method -greet- in our class 
}

בעזרת this יש הפניה למטודה greet אשר נמצאת במחלקה שלנו.

דוגמה של יצירת אובייקט על בסיס המחלקה שלנו 

public static void main(String[] args) 
{
  Some_Class obj1 = new Some_Class();
  obj1.print();
  Some_Class obj2 = new Some_Class(30);

  obj1.print();//x=1 
  obj1.print();//x=30 
}

הסבר:

כמו בכל תוכנה בשפת Java כותבים את הקוד אשר רוצים להעריץ
בתוך סוגריים של void main:

public static void main(String[] args) {

}

בתוך סוגריים של public static void main מוגדר אובייקט בשם obj1 

Some_Class obj1 = new Some_Class();

זוכרים שמטרה של המחלקה זה ליצור בסיס מסוים, כך שנוכל ליצור אובייקטים שונים בעלי אותו בסיס?!

אז במקרה שלנו – יש לנו אובייקט בשם obj1 אשר מבוסס על המחלקה Some_Class

obj1.print();

האובייקט obj1 קורה למטודה ()print וכזכור לפי מחלקה Some_Class

public void print()   
{ 
  this.greet();// THIS calls the method -greet- in our class 
}

זאת אומרת שיש קריאה ממטודה ()print למטודה ()greet

public void greet() 
{ 
   System.out.println("I am greet method" + x); 
}

לכן יודפס 1 I am greet method

בנוסף יש לנו עוד אובייקט בשם obj2

Some_Class obj2 = new Some_Class(30);

לאומת האובייקט הראשון obj1
הפעם בהגדרת אובייקט obj2 אנחנו מעבירים פרמטר לבנאי – 30.

זוכרים מה הבדל בין בנאי ריק ולא?!

כזכור במחלקה Some_Class הגדרנו שני בנאים:

בנאי ריק

Some_Class()  
{ 
 //empty constructor   
}

ובנאי אשר מקבל פרמטר

Some_Class(int num)  
{  
  this.x=num;  
}

לכן הפעם האובייקט obj2 קורה למטודה ()print וכזכור לפי מחלקה Some_Class

public void print()   
{ 
  this.greet();// THIS calls the method -greet- in our class 
}

זאת אומרת שיש קריאה ממטודה ()print למטודה ()greet

public void greet() 
{ 
   System.out.println("I am greet method" + x);//x=30 
}

כאשר הפעם x=30  לכן יודפס 30 I am greet method

Arrays

שפת Java – הפעם נלמד arrays.

הדפסת מערך

הדפסת מערך, כאשר כל פעם יש
הורדת שורה [n/]

double[] myList = {0.9,4.6,2.1};
for (int i = 0; i < myList.length; i++) 
{ 
 System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1
}

הסבר:

הגדרנו מערך myList מסוג double (מספרים לא שלמים)

לאחר מכן יש הרצה על מערך כולו תוך שימוש ב-for
למעשה בהתחלה  i=0
לכן:

myList[0]=0.9

בלולאה הבא i=1

לכן:

myList[1]=4.6

וכך עד myList.length כי

for (int i = 0; i < myList.length; i++) 
{ 
 System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1
}

כלומר עד שה-i פחות משלוש:

for (int i = 0; i < 3; i++) 
{  
  System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1 
}

שזה אורך המערך 3 כך שערך אחרון של i זה 2.

לכן כאשר i=2, יודפס:

myList[2]=2.1

מערך דו ממדי:

int[][] foo = new int[][] 
{
 new int[] { 1, 2, 3 },
 new int[] { 1, 2, 3, 4},
};

System.out.println(foo.length); //2
System.out.println(foo[0].length); //3
System.out.println(foo[1].length); //4
System.out.println(foo[1][2]);// 3

הסבר:

הגדרנו מערך דו ממדי בשם foo
1,2,3
1,2,3,4
למעשה במערך דו-מימדי יש שתי שורות:
שורה ראשונה 1,2,3
ושורה שניה 1,2,3,4

בעזרת foo.length מקבלים כמה שורות יש במערך -2

בעזרת foo[0].length מקבלים כמה איברים יש בשורה ראשונה – 3

בעזרת foo[1].length מקבלים כמה איברים יש בשורה השנייה- 4

  • בעזרת [2][1]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 1 ועמודה 2 שזה 3
    
    * ספירה מאפס
  • בעזרת [2][0]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 0 ועמודה 2 שזה 3
    
    * ספירה מאפס
  • בעזרת [1][0]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 0 ועמודה 1 שזה 2
    
    * ספירה מאפס

קבלת מערך כאובייקט לפונקציה

קבלת מערך כאובייקט לפונקציה והחזרת מערך עם ערכים מהסוף להתחלה

public class Main {

public static void main(String[] args) {

double[] myList = {0.9,4.6,2.1};

myList=reverse(myList);

for (int i = 0; i < myList.length; i++)
{
System.out.println(myList[i]);//2.1, 4.6, 0.9
}
}

public static double[] reverse(double[] myList) {

double[] result = new double[myList.length];//3

for (int i = 0, j = result.length - 1; i < myList.length; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

return result;//return Array: 2.1, 4.6, 0.9
}

}

הסבר:

הגדרנו מערך myList מסוג double

double[] myList = {0.9,4.6,2.1};

לאחר מכן פונקציה reverse מקבלת מערך myList  וגם מחזירה מערך.

myList=reverse(myList);

כלומר פונקציה מחזירה מערך {2.1,4.6,2,0.9}:

myList= {2.1, 4.6,2, 0.9}

אבל הפונקציה reverse עושה את זה?

תשובה:

נגדיר פונקציה reverse אשר מקבלת מערך חד מימדי – myList מסוג double

public static int[] reverse(double[] myList) 
{  

}

לאחר קבלת מערך myList בפונקציה, נוכל להגדיר מערך זמני בשם result

int[] result = new int[myList.length];

באורך 3 כי

myList.length=3
לכן
int[] result = new int[3];

לאחר מכן אנו מוצאים את האיבר אחרון אשר נמצא במערך myList

for (int i = 0, j = result.length - 1; i < myList.length; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

שזה כמו:

* result.length=3
* myList.length=3

for (int i = 0, j = 3 - 1; i < 3; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

או

for (int i = 0, j = 2; i < 3; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

ולכן

result[j] = myList[i];
שזה
result[2] = myList[0]=0.9

עם זאת מכיוון שעכשיו:

* i=0
* j=2

 i++, j--
אז
i=1 גדל ב-1
j=1 קטן ב-1

אז בהרצה הבאה של for

result[j] = myList[i];
שזה
result[1] = myList[1]=4.6

לאחר מכן

 i++, j--
אז
i=2 גדל ב-1
j=0 קטן ב-1

ולכן

result[j] = myList[i];
שזה
result[0] = myList[2]=2.1

זאת אומרת במערך result יש מערך הפוך מזה שהתקבל בפונקציה reverse

ובסוף אנו מחזרים את המערך הפוך הזה

 return result;//return Array: 2.1, 4.6, 0.9

ואז מדפיסים את המערך myList

myList=reverse(myList);

for (int i = 0; i < myList.length; i++)
{
System.out.println(myList[i]);//2.1, 4.6, 0.9
}
דילוג לתוכן