[עמוד ראשי]   [נושא קודם]
חלונות ומסגרות
1. מבוא
2. תיבות דו שיח פשוטות
3. שורת המצב- (status line)
4. פסקי זמן ומרווחים
5. האובייקט Navigator
6. האובייקט Screen
7. מתודות הבקרה של Window
8. האובייקט Location
9. האובייקט History
10. ריבוי חלונות ומסגרות

אובייקט ה-Window מתפקד כאובייקט גלובלי עבור תוכניות מצד הלקוח של JS, ומהווה את השורש של היררכית האובייקטים של צד הלקוח.

אובייקט ה-Window הוא אובייקט חשוב. כל חלון של דפדפן רשת וכל מסגרת שבחלון מוצגים ע"י אובייקט זה. אובייקט ה-Window מגדיר מספר תכונות ומתודות שחשובות בתכנות בצד הלקוח ב-JS.

1. מבוא
להלן רשימת התכונות והמתודות השכיחות ביותר של אובייקט ה-Window : 
closed
ערך בוליאני שערכו true רק אם החלון נסגר 
defaultStatus, status
תכונות אלו מגדירות את הטקסט שמופיע בשורת המצב (status line) של הדפדפן 
document
reference לאובייקט ה-Document אשר מציג את מסמך ה-HTML שמוצג בחלון 
frames[ ]
מערך של אובייקט Window אשר מציג את המסגרות (אם קימות) שבחלון 
history
reference לאובייקט ה-History אשר מציג את היסטורית הגלישה של המשתמש עבור החלון 
innerHeight, innerWidth, outerHeight, outerWidth
המימד הפנימי והחיצוני של החלון. לא בר תוקף באינטרנט אקספלורר 4 
location
reference לאובייקט ה-Location אשר מציג את מסמך ה-URL של המסמך שמוצג בחלון. קביעתו גורמת לדפדפן לטעון מסמך חדש 
locationbar, menubar, personalbar, scrollbars,statusbar, toolbar
reference לאובייקט ה-Bar אשר מגדיר את הראות של החלקים השונים של חלון ה-N. לא בר תוקף באינטרנט אקספלורר 4 
name
שם החלון. ניתן להשתמש עם התכונה target של תווית ה -HTML כמו <A>. 
opener
reference לאובייקט ה-Window אשר פותח את החלון, או null אם החלון נפתח ע"י המשתמש 
pageXOffset, pageYOffset
היסט המסמך(scrolled) ימינה ומטה בתוך החלון. לא בר תוקף באינטרנט אקספלורר 4 
parent
אם החלון הנוכחי הוא מסגרת, reference למסגרת של החלון שמכיל אותה 
self
Reference לאובייקט ה-window הנוכחי.מילה נרדפת ל-window 
top
אם החלון הנוכחי הוא מסגרת, Reference לאובייקט ה-Window של החלון בשכבה הגבוהה ביותר שמכיל את המסגרת 
window
תכונה עצמית לעניין מסוים. Reference לאובייקט ה-window הנוכחי. מילה נרדפת ל-self 
alert(), confirm(), prompt()
מציגות תיבות דו שיח פשוטות למשתמש, ועבור ( )confirmו - ( )prompt מקבלות את תגובת המשתמש 
close()
סגירת החלון 
find(), home(), print(), stop()
מכפילות את הפונקציונליות של הכפתורים ב-button bar ב-N. אינן תקפות באינטרנט אקספלורר 4 
focus(), blur()
בקשה או ביטולה לקבלת פוקוס של המקלדת עבור החלון. אינן תקפות באינטרנט אקספלורר 3 
moveBy(), moveTo()
הזזת החלון 
resizeBy(), resizeTo()
שינוי גודל החלון 
scrollBy(), scrollTo()
מעבר על המסמך המוצג בחלון ע"י scroll 
setInterval(), clearInterval()
תכנון או ביטול פונקציה שתקרא שוב ושוב עם זמן שהייה בין הקריאות 
setTimeout(), clearTimeout()
תכנון או ביטול פונקציה שתקרא פעם אחת לאחר מספר אלפי שניות מוגדר
2. תיבות דו שיח פשוטות
שלוש מתודות שכיחות של אובייקט ה - alert( ), confirm( ), prompt( ) Window : מתודות אלו מציגות תיבות דו שיח פשוטות.
( )Alert מציגה הודעה למשתמש.
( )Confirm מבקשת מהמשתמש להקליק על אחד מהכפתורים: ok או cancel על מנת לאשר או לבטל את הפעולה.
( )Prompt מבקשת מהמשתמש להקליד מחרוזת.
יש לשים לב שהטקסט שמוצג בתיבות דו שיח אלו הוא טקסט פשוט, ולא טקסט HTML מפורמט. הפורמט היחיד שניתן לעשות הוא על מרווחים (spaces), שורות חדשות (newlines) ותווי פיסוק. התאמת דרך הסידור/ השרטוט באופן כללי דורשת ניסיון ותהיה. תיבות הדו שיח נראות שונה בפלטפורמות שונות ובדפדפנים שונים, כך שלא ניתן לסמוך על הפירמוט שיראה כמו שתכננו בכל הדפדפנים.

יש לשים לב שהמילה "java script " מופיעה ב-titlebar או בפינה השמאלית למעלה בכל תיבות דו שיח שנוצרו ע"י( ) alert( ), confirm( ), prompt. למרות שזה מטריד, לא ניתן להשתחרר מזה, זה קיים על מנת למנוע כתיבה של קוד ש"מרמה" דיאלוגים ומהתל במשתמשים להכניס את סיסמתם או לעשות דברים אחרים שהמשתמשים אינם צריכים לעשות.

המתודות ( ) confirm ( ) prompt נחסמות עד שהמשתמש מבטל את הדיאלוג שהן הציגו. כלומר, כאשר מעלים תיבת דו שיח, הקוד מפסיק לרוץ והמסמך הנוכחי שנטען, אם קיים כזה, מפסיק להטען עד שהמשתמש מגיב לבקשת הקלט.
אין אלטרנטיבה אחרת לחסימה זו עבור מתודות אלו- הערך שהן מחזירות הוא קלט המשתמש, לכן הן חייבות להמתין למשתמש לפני שיוכלו לחזור לפעולה.
המתודה ( )alert גם היא פועלת באותו אופן, אך לא ב-N שבפלטפורמת UNIX. בפלטפורמה זו, JS מציגה את תיבת הדו שיח ואז ממשיכה להוראה הבאה. בפועל, אי התאמה קטנה זו אינה גורמת לבעיות רבות.

הדוגמא הבאה מדגימה שימושים אופייניים במתודות אלו: הפונקציה הבאה משתמשת במתודה( )alert על מנת לומר למשתמש שאישור הטופס ייקח זמן מה, ועל המשתמש להיות סובלני. זה יכול להתאים לשימוש בevent handler :onSubmit של טופס HTML. 

function warn_on_submit()
{
 alert("\n______________________________\n\n" +
 "   your query is being submitted ...\n"+
 "______________________________\n\n" +
 "Please be aware that complex queries such as yours\n" +
 "can require a minute or more of search time.\n\n" +
 "Please be patient.");
}


בדוגמא הבאה נעשה שימוש במתודה ( )confirm על מנת לשאול את המשתמש אם הוא באמת רוצה לבקר בדף web שלוקח הרבה זמן להורידו. יש לשים לב שהערך המוחזר של המתודה מצביע על תגובת המשתמש. על פי תגובה זו, מנתבים מחדש את הדפדפן לעמוד המתאים. 

var msg = "\n You are about to experience the most\n\n" +
"\t | AWESOME | \n\n" +
"Web page you have ever visited!!!!\n\n" +
"This page takes an average of 15 minutes to\n" +
"download over a 28.8K modem connection.\n\n" +
" Are you ready for good time, Dude ?";
if(confirm(msg))
 location.replace("awesome_page.html");
else
 location.replace("lame_page.html");


הקוד הבא הוא פשוט מאוד ומשתמש במתודה ( )prompt על מנת לקבל את שם המשתמש, ואז להשתמש בשם זה ב-HTML דינמיים שנוצרים. 
n= prompt("What is your name ?" , "");
document.write("<hr><hl>Welcome to my home page, " +n+ "</hl><hr>");
  

3. שורת המצב- (status line)
שורת המצב מופיעה בתחתית כל חלון דפדפן (פרט לחלונות שיוצרים במפורש ללא שורת מצב). זהו מקום שבו הדפדפן יכול להציג הודעות למשתמש. כאשר המשתמש מזיז את העכבר על קישור היפר טקסט.
לדוגמא, הדפדפן מציג את ה-URL שהקישור מצביע אליו. כאשר המשתמש מזיז את העכבר מעל כפתור, הדפדפן מציג הודעת " context help" פשוטה שמסבירה את תכלית הכפתור.
ניתן לעשות שימוש בשורת מצב זו גם בתוכניות- התוכן של התוכניות מבוקר ע"י שתי תכונות של אובייקט ה - .status, defaultStatus : Window

כפי שכבר נאמר,כאשר המשתמש מעביר את העכבר מעל קישור היפר טקסט, הדפדפן מציג את ה-URL שהקישור מצביע אליו, זהו בדר"כ המקרה, אך ב"טיול" ברשת, ניתן למצוא קישורים שאינם מתנהגים כך, קישורים המציגים טקסט שאינו ה-URL של הקישור.
זה נעשה ע"י התכונה status של האובייקט Window וה-event handler : onMouseOver של קישורי היפר טקסט.

הדוגמא הבאה מראה כיצד לקבוע את שורת המצב בהיפר טקסט. יש לשים לב שה-event handler חייב להחזיר true : 
<A HREF = "sitemap.html" 
       onMouseOver="status='Go to site map'; return true;">
Site Map
</A>
ניתן לעשות את אותו הדבר עבור שרטוט תמונה בצד הלקוח : 
<MAP NAME="map1">
<AREA COORDS="0,0,50,20" HREF="info.html" 
 onMouseOver="status='Visit our Information Center'; 
                                   return true;">
<AREA COORDS="0,20,50,40" HREF="order.html" 
  onMouseOver="status='Place an order'; return true;">
<AREA COORDS="0,40,50,60" HREF="help.html" 
  onMouseOver="status='Get help fast!'; return true;">
</MAP>
ה-event handler onMouseOver בדוגמא הקודמת חייב להחזיר true.
זה אומר לדפדפן שאינו צריך לבצע את פעולת ברירת המחדל שלו עבור הארוע- כלומר, אינו צריך להציג את ה-URL של הקישור בשורת המצב.
אם שוכחים להחזיר true , הדפדפן יכתוב על ההודעה שה-handler הציג בשורת המצב את ה-URL שלו.
כאשר המשתמש מזיז את מצביע העכבר מעל היפר טקסט, הדפדפן מציג את ה-URL של הקישור ואז מוחק זאת כאשר העכבר זז מההיפר טקסט.
כך גם קורה כאשר משתמשים ב-onMouseOver על מנת לקבוע את התכונה status – ההודעה המתאימה מוצגת בזמן שהעכבר על ההיפר טקסט, ואז נמחקת כאשר העכבר אינו על הקישור.
בגרסת Windows של N 3, שורת המצב אינה נמחקת אוטומטית כאשר קובעים את התכונה status.
על מנת לאלץ אותה להמחק, ניתן להשתמש ב - onMouseOut כך : 
<A HREF="sitemap.html" 
  onMouseOver="status='Go to Site Map'; return true;" 
  onMouseOut= "status=' ';">
Site Map
</A>
התכונה status מיועדת בדיוק להודעה מסוג ארעי כמו בדוגמא הנ"ל.
אם רוצים להציג הודעה שאינה ארעית בשורת המצב-למשל, הודעת "ברוכים הבאים" למבקרים באתר או שורת עזרה פשוטה עבור מבקרים טירונים.
על מנת לעשות זאת, קובעים את התכונה defaultStatus של החלון- תכונה זו מגדירה את טקסט ברירת המחדל המוצג בשורת המצב. טקסט זה מוחלף באופן זמני ב-URLs, הודעות עזרה, או טקסט ארעי אחר שמוצג כאשר מצביע העכבר על היפר טקסט או כפתורי דפדפן, אבל באותו רגע שהעכבר זז מחוץ לאזורים אלו, טקסט ברירת המחדל מאוחסן. ניתן להשתמש ב- defaultStatus על מנת לספק הודעה ידידותית ומועילה למתחילים כך : 
<SCRIPT>
defaultStatus="Welcome! Click on underlined blue text to navigate.";
</SCRIPT>
אם עמוד ה-web מכיל טופס HTML, יש לשנות את התכונה defaultStatus כאשר המשתמש מכניס נתונים לטופס על מנת להציג צעד אחר צעד הוראות לסיום.
4. פסקי זמן ומרווחים
תפקיד המתודה ( )setTimeout של האובייקט Window הינו תכנון שחלק קוד JS ירוץ בזמן מסוים שמגדירים בעתיד.
המתודה ( )clearTimeout משמשת לביטול הביצוע של קוד זה.
המתודה ( )setTimeout בדר"כ משמשת לביצוע אנימציה או לפעולות חוזרות מסוג אחר.
אם פונקציה רצה ואז משתמשת ב-( )setTimeout על מנת לקבוע זמן שתקרא שוב, מקבלים תהליך שחוזר ללא קריאות המשתמש.
ב - 1.2 JS נוספו המתודות : ( )Interval ו-( )clearInterval, אשר דומות ל - ( )setTimeout ול- ( )clearTimeout, פרט לכך שהן באופן אוטומטי מתכננות שהקוד ירוץ שוב ושוב. אין צורך שהקוד יתכנן זאת בעצמו.

בדר"כ משתמשים במתודה ( )setTimeout בצירוף עם התכונה status או defaultStatus על מנת לעורר סוג מסוים של הודעות שב-status bar של הדפדפן. באופן כללי, אנימציות המערבות את ה-status bar ראוותניות/צעקניות ויש להימנע מהן. בכל אופן, יש מספר טכניקות שימושיות ובטוב טעם של אנימציה ב-status bar.

הדוגמא הבאה מראה אנימציה שימושית בעלת טעם ב-status bar. היא מציגה את הזמן הנוכחי ב-status bar ומעדכנת זמן זה כל דקה. בגלל שהעדכון מתרחש רק כל דקה, אנימציה זו אינה יוצרת הפרעה קבועה מהבהבת בתחתית חלון הדפדפן כמו אנימציות אחרות.
יש לשים לב לשימוש ב-event handler: onLoad על מנת לבצע את הקריאה הראשונה למתודה:( )play_time_in_status_line. Event handler זה נקרא פעם אחת כאשר מסמך ה-HTML נטען במלואו לדפדפן. לאחר קריאה ראשונה זו, המתודה משתמשת ב-( )setTimeout לתזמן את עצמה להקרא כל 60 שניות ואז יכולה לעדכן את הזמן המוצג. ה-event handler: onLoad מוגדר בדוגמא זו כתכונה של התווית <BODY>.

הפונקציה הבאה מציגה את הזמן בשורת המצב. הקריאה לפונקציה פעם אחת על מנת להפעיל את השעון. ומאז היא תקרא לעצמה. 
<HTML>
<HEAD>
<SCRIPT>
function display_time_in_status_line()
{
 var d = new Date();	          // קבלת הזמן הנוכחי 
 var h = d.getHours();	          // חילוץ השעות : 0-23 
 var m = d.getMinutes();	          // חילוץ הדקות : 0-59
 var ampm = (h >= 12)?"PM":"AM";      // am או pm האם זה     
 if(h > 12) h-=12;		          // הפיכה מפורמט של 24 שעות ל12 שעות 
 if(h == 0) h=12;		          // הפיכה משעה 0 לחצות
 if(m < 10) m = "0" + m;	          // 00 - הפיכה מ-0 דקות ל
 var t = h + ':' + m + ' ' + ampm;   // השמה של כולם ביחד  
 DefaultStatus = t;
 SetTimeout("display_time_in_status_line()", 60000); 
 //סידור לעשות זאת שוב כל דקה. 60000 מיליסקנד הם דקה אחת.
}
</SCRIPT>
</HEAD>
<BODY onLoad = "display_time_in_status_line();">
<!- - HTML תוכן מסמך ה->
</BODY>
</HTML>


ב - 1.2 JS דוגמא זו יכולה להיכתב עם שימוש ב-( )setInterval במקום ( )setTimeout.
במקרה זה, הקריאה ל- ( )setTimeout היתה נמחקת מהמתודה ( )display_time_in_status_line, וה-event handler onLoad
היה משתנה כך שיקרא ל- ( )setInterval על מנת לתכנן קריאה למתודה זו אשר באופן אוטומטי תחזור על עצמה כל דקה.

5. האובייקט Navigator
התכונה Window.navigator מתייחסת לאובייקט Navigator שמכיל מידע על דפדפן ה-web כולו. אובייקט ה-Navigator נקרא אחרי Netscape Navigator, אבל הוא גם נתמך ע"י אינטרנט אקספלורר.
אינטרנט אקספלורר תומך גם ב-clientInformation כספק טיבעי עבור Navigator. אובייקט ה-Navigator בעל שש תכונות המספקות מידע על הגירסא של הדפדפן שרץ : 
appName
השם הפשוט של הדפדפן 
appVersion
מספר הגירסא ו/או מידע נוסף על גירסת הדפדפן 
userAgent
המחרוזת ששולח הדפדפן בכותרת העליונה :USER-AGENT HTTP שלו. תכונה זו בדר"כ מכילה את כל המידע שנמצא ב- appNameוב- appVersion. 
appCodeName
קוד השם של הדפדפן, Navigator משתמש בתכונה זו עבור קוד השם: "Mozilla", אבל, באופן כללי, תכונה זו אינה מספקת כל מידע שאינו מסופק ע"י תכונות אחרות של Navigator 
platform
פלטפורמת החומרה שעליה רץ הדפדפן. תכונה זו חדשה ב-1.2 JS 
language
השפה שגירסא זו של הדפדפן תומכת.
זהו בדר"כ סטנדרט של קוד שפה של שתי-אותיות, כמו " en" עבור English או "fr" עבור French. תכונה זו היא חדשה ב-N 4.
אינטרנט אקספלורר 4 מגדיר תכונות דומות במקום תכונה זו : userLanguage ו - systemLanguage.

שורות הקוד הבאות של JS מציגות את כל התכונות הנ"ל בתיבת דו שיח : 
var browser = "BROWSER INFORMATION:\n";
for(var propname in navigator)
{
 browser += propname + ":" + navigator[propname] + "\n"
}
alert(browser);


התכונות של האובייקט N בעלות ערכים שלפעמים יותר מורכבים ממה שאנו מעונינים. לעיתים מעונינים רק בסיפרה הראשונה של התכונה appVersion ,למשל,
כאשר משתמשים באובייקט N על מנת לבחון מידע על הדפדפן, לעיתים משתמשים במתודות כמו ( )parseInt ו-( )String.indexOf על מנת להוציא רק את המידע שרוצים.

הדוגמא הבאה מראה קוד המבצע כך :
מכין את התכונות של האובייקט Navigator ומאחסן אותן באובייקט המכונה browser. תכונות אלו, הן קלות לשימוש לעומת תכונות ה-navigator. המונח המתאים לקוד כזה הוא : "sniffer". למטרות רבות, קוד פשוט כזה עובד באופן טוב : 
/*
* File:browser.js
* Include with:<SCRIPT SRC="browser.js"></SCRIPT>
* 
* A simple "sniffer" that determines browser version and vendor.
* It create an object named "browser" that is easier to use 
* than the "navigator" object.
*/
// יצירת האובייקט browser
var browser = new Object();	
// בירור הגירסא העיקרית של הדפדפן				
browser.version = parseInt(navigator.appVersion);		

// בירור אם הדפדפן הוא אחד משני הדפדפנים העיקריים 
// מתחילים בהנחה שהוא לא אחד מהם

browser.isNavigator = false;
browser.isIE = false;
if(navigator.appName.indexOf("Netscape")!= -1)
browser. isNavigator = true;
else if(navigator.appName.indexOf("Microsoft")!= -1)
browser.isIE = true;
האובייקטים MimeType ו-Plugin
שתי התכונות MimeType ו-Plugin נתמכות ב-N 3 ומעלה.
באינטרנט אקספלורר 4, התכונות מוגדרות למטרת תאימות בלבד- המערך אליו הן מתיחסות תמיד ריק.
התכונה [ ]navigator.mimeTypes היא מערך של אובייקטים mimeType, כשכל אחד מהם מתאר פורמט של נתון MIME אחד (כמו: text /html ו-image /gif) שהדפדפן יכול להציג (אם באופן ישיר, עם אפליקצית עזר חיצונית, או עם pluging). האובייקט MimeType בעצמו מכיל תכונות אשר מתארות את פורמט הנתונים.

המערך [ ]mimeTypes הוא ממוספר, אך הוא גם מערך אסוציאטיבי, כולל אינדקס ע"י השם של סוג ה-MIME. כך, ניתן לבדוק בקלות את התמיכה של פורמט נתון מסוים בדפדפן. 
// MPEG בדיקה אם הדפדפן יכול להציג קבצי
var show_movie = (navigator.mimeTypes["video/mpeg"] != null);
התכונה [ ]navigator.plugins היא מערך של אובייקטים Plugin, כאשר כל אחד מהם מייצג מודול של Plugin אשר הותקן בדפדפן. התכונות של האובייקט Plugin מספקות פרטים שונים על ה-Plugin.
האובייקט Plugin מכיל גם מערך אלמנטים, שהם אובייקטים מסוג MimeType המתארים כל אחד מהפורמטים של הנתונים הנתמכים ע"י ה-plugin המסוים. יש לשים לב שמערך זה שונה מהמערך [ ]navigator.mimeTypes שתואר קודם.

ניתן להשתמש בתכונה [ ]plugins כמערך אסוציאטיבי. זה נותן אפשרות לבדוק את הקיום של plugin מסוים ללא צורך לעבור על המערך לפי מספר ולבדוק אלמנט אלמנט. 
// plugin Shockwave בדיקה אם הדפדפן בעל ה-
Var shocked = (navigator.plugins["Shockwave"] != null);
6. האובייקט Screen
ב-1.2 JS, התכונה screen של האובייקט Window מתייחסת לאובייקט Screen. אובייקט זה מספק מידע על גודל תצוגת המשתמש ומספר הצבעים הזמינים. התכונות width ו-height מגדירות את גודל התצוגה ב-pixels. התכונות availWidth ו-availHeight מגדירות את גודל התצוגה הזמין בפועל :
הן שוללות את המקום שדרוש ע"י מאפיינים כמו שורת המשימות(taskbar) ב-Window 95. ניתן להשתמש בתכונות אלו על מנת להחליט איזה גודל של תמונות לכלול במסמך או בתוכנית שיוצרת חלונות דפדפנים מרובים , איזה גודל חלון ליצור.

התכונה colorDepth מגדירה את הלוג בבסיס 2 של מספר הצבעים שיכולים להיות מוצגים. לעיתים, ערך זה זהה למספר הביטים לכל pixel שמשמשים בתצוגה. למשל, תצוגה של 8 - ביטים יכולה להציג 256 צבעים, ואם כל הצבעים הללו היו זמינים לשימוש ע"י הדפדפן, התכונה screen.colorDepth תהיה 8.
בנסיבות שונות, בכל אופן, הדפדפן יכול לצמצם את עצמו לתת קבוצה של הצבעים הזמינים, ואז נוכל לגלות ערך של screen.colorDepth שהוא נמוך יותר מהערך של מספר הביטים לכל pixel של המסך. אם יש מספר גרסאות של תמונה שהוגדרו ע"י שימוש במספר שונה של צבעים, ניתן לבדוק את התכונה colorDepth על מנת להחליט איזו גירסא לכלול במסמך.
7. מתודות הבקרה של Window
אובייקט Window מגדיר מספר מתודות המאפשרות בקרה ברמה גבוהה של החלון עצמו.

פתיחת חלונות

ניתן לפתוח חלון דפדפן חדש ע"י המתודה ( )open של האובייקט Window. מתודה זו מקבלת ארבעה ארגומנטים אופציונליים ומחזירה אובייקט Window אשר מייצג את החלון הנפתח החדש. הארגומנט הראשון הוא ה-URL של המסמך שיוצג בחלון החדש. אם מתעלמים מארגומנט זה(null, או מחרוזת ריקה), החלון יהיה ריק. הארגומנט השני הוא שם החלון. אם מגדירים שם של חלון שכבר קיים, המתודה ( )open משתמשת בחלון הקיים במקום לפתוח חלון חדש.
הארגומנט השלישי הוא רשימה של מאפיינים שמגדירה את גודל החלון ועיטורי GUI. אם מתעלמים מארגומנט זה, לחלון החדש ניתן גודל ברירת מחדל ומאפיינים סטנדרטיים : menubar, שורת מצב, toolbar, וכ"ו.
מצד שני, אם מגדירים ארגומנט זה, ניתן להגדיר במדויק את גודל החלון ואת קבוצת המאפינים שלו. למשל, על מנת לפתוח חלון דפדפן קטן שניתן לשנות את גודלו עם שורת מצב אך ללא menubar, toolbar, ו-locationbar, ניתן להשתמש בשורת הקוד הבאה : 
var w = window.open("smallwin.html", "width=400, 
                    height=350, status=yes, resizable=yes");
יש לשים לב שכאשר מגדירים את הארגומנט השלישי, מאפיינים אחרים שלא מגדירים נזנחים.
הארגומנט הרביעי הוא שימושי רק כאשר בארגומנט השני יש שם של חלון שכבר קיים. הארגומנט הרביעי הוא ערך בוליאני אשר מגדיר אם ה-URL שהוגדר בארגומנט הראשון צריך להחליף את הכניסה הנוכחית בהיסטורית חלון הדפדפן או ליצור כניסה חדשה בהיסטורית חלון הדפדפן, שזוהי ברירת המחדל.

הערך המוחזר מהמתודה ( )open הוא האובייקט Window אשר מיצג את החלון החדש שנוצר. ניתן להשתמש באובייקט זה בקוד ה-JS על מנת להתייחס לחלון החדש. אם קוד JS שבחלון החדש רוצה להתייחס לחלון שפתח אותו(הקודם), ב- 1.2 JS ומעלה, התכונה opener מתייחסת לחלון שממנו נפתח. אם החלון נוצר ע"י המשתמש ולא ע"י קוד JS, תכונה זו היא null.

נקודה חשובה לגבי המתודה ( )open היא שמתודה זו כמעט תמיד נקראת כ-( )window.open, זאת למרות ש-window מתייחס לאובייקט הגלובלי ולכן צריך להיות כולו אופציונלי. הסיבה ש-window מוגדר במפורש היא בגלל שלאובייקט Document יש גם מתודת ( )open. בנוסף לכך, זה הכרחי בנסיבות שונות, משום ש-event handlers פועלים בטווח של האובייקט שמגדיר אותם.
כאשר ה-event handler של כפתור HTML פועל, למשל, שרשרת הטווח כוללת את האוביקט Button, את האוביקט Form שמכיל את הכפתור, את האוביקט Document שמכיל את הטופס, ולבסוף, את האוביקט Window שמכיל את המסמך. לכן, אם event handler כזה מתיחס רק למתודה ( )open, מזהה זה מסיים בהיותו מוחלט באובייקט Document, וה-event handler פותח מסמך חדש במקום חלון חדש.

סגירת חלונות

המתודה ( )close סוגרת חלון. אם נוצר אובייקט Window בשם-w ניתן לסגור אותו כך : 
w.close();
קוד JSהרץ בחלון זה יכול לסגור אותו כך : 
window.close();
יש לשים לב שהשימוש במפורש במזהה window נעשה על מנת להבדילו מאובייקט Document.

ניתן לסגור באופן אוטומטי חלונות שקוד ה-JS יצר. אם נעשה ניסיון לסגור חלון אחר, תוצג תיבת דיאלוג שתבקש מהמשתמש לאשר את הבקשה לסגור את החלון.

ב- 1.1 JS ומעלה, אוביקט Window ממשיך להתקים גם לאחר שהחלון אותו הוא מיצג נסגר. אין לנסות להשתמש בתכונות שלו או במתודות, חוץ מלבדוק את התכונה closed. תכונה זו ערכה true אם החלון נסגר. יש לזכור שהמשתמש יכול לסגור כל חלון בכל זמן, לכן על מנת למנוע שגיאות, זהו רעיון טוב לבדוק שהחלון שמנסים להשתמש בו פתוח.

גאומטרית החלון

ב- moveTo( ) 1.2 JS מזיזה את הפינה השמאלית העליונה של החלון לקואורדינטות המוגדרות. באופן דומה, ( )moveBy מזיזה את החלון מספר מוגדר של pixels שמאלה או ימינה, ולמעלה או למטה. ( )resizeTo ו- ( )resizeBy משנות את גודל החלון ע"י כמות אבסולוטית או יחסית. הן גם חדשות ב- 1.2 JS.

פוקוס המקלדת

המתודות ( )focus ו-( )blur מספקות בקרה ברמה הגבוהה של החלון. קריאה ל- ( )focus הינה בקשה מהמערכת לתת פוקוס של המקלדת לחלון. וקריאה ל- ( )blur שוללת זאת. מתודות אלו מוגדרות ב-1.1 JS ומעלה. 

Scrolling
( )ScrollBy מציגה את המסמך המוצג בחלון ע"י מספר מוגדר של pixels שמאלה או ימינה ולמעלה או למטה.
( )ScrollTo מעבירה את המסמך לעמדה/נקודה קבועה.

8. האובייקט Location
התכונה location של חלון היא reference לאובייקט Location, ייצוג ה-URL של המסמך הנוכחי המוצג בחלון זה. התכונה href של האובייקט Location היא מחרוזת המכילה את הטקסט השלם של ה-URL. תכונות אחרות של אובייקט זה כמו: protocol, host, pathname, ו-search, מגדירות חלקים אינדיבידואלים שונים של ה-URL.

התכונה search מכילה כל חלק של ה-URL שאחריו סימן שאלה (כולל). זהו לעיתים חיפוש של מחרוזת מבוקשת כלשהי. באופן כללי, תחביר בעל סימן השאלה ב-URL הוא טכניקה עבור שיבוץ ארגומנטים ב-URL. בעוד שארגומנטים אלו בדר"כ מיועדים לתסריטים של CGI הרצים על שרת, אין סיבה מדוע לא ניתן להשתמש בהם בדפים הנתמכים ע"י JS.

התכונה search מכילה כל חלק של ה-URL שאחריו סימן שאלה (כולל). זהו לעיתים חיפוש של מחרוזת מבוקשת כלשהי. באופן כללי, תחביר בעל סימן השאלה ב-URL הוא טכניקה עבור שיבוץ ארגומנטים ב-URL. בעוד שארגומנטים אלו בדר"כ מיועדים לתסריטים של CGI הרצים על שרת, אין סיבה מדוע לא ניתן להשתמש בהם בדפים הנתמכים ע"י JS.

הדוגמא הבאה מראה את המטרה הכללית של הגדרת הפונקציה ( )getArgs שניתנת לשימוש על מנת לחלץ ארגומנטים מתוך התכונה search של ה-URL.

הפונקציה מפצלת את מחרוזת ה-URL לזוגות ארגומנטים מהצורה name = value המופרדים ע"י פסיקים. היא מאחסנת זוגות אלו בתכונות אובייקט ומחזירה אובייקט זה. 
function getArgs()
{
  var args = new Object();
  var query = location.search.substring(1);  // קבלת מחרוזת הבקשה 
  var pairs = query.split(",");              // שבירת המחרוזת על פי פסיקים
  for(var i=0; i < pairs.length; i++)
  {
    var pos = pairs[i].indexOf('=');         // name = value חיפוש אחר 
    if(pos == -1)continue;                   // אם לא נמצא, לדלג 
    var argname = pairs[i].substring(0,pos); // חילוץ השם
    var value = pairs[i].substring(pos+1);   // חילוץ הערך
    args[argname] = unescape(value);         // איחסון כתכונה
  
  return args;                               // החזרת האובייקט
}


בנוסף לתכונות של האובייקט Location, ניתן להשתמש בו כאילו הוא עצמו ערך מחרוזת פרימיטיבי. כאשר קוראים את הערך של אובייקט ה-Location, מקבלים את אותה מחרוזת של התכונה href של האובייקט. ניתן להציב מחרוזת URL חדשה לתכונה location של חלון. הצבת URL לאובייקט Location כך, גורמת לדפדפן לטעון ולהציג את התוכן של ה-URL שהציבו.
למשל, ניתן להציב URL לתכונה location כך :
אם Java אינה מאופשרת, לך לעמוד המציג הודעה האומרת שלא ניתן להריץ את הדף הזה ללא Java. 
if(!navigator.javaEnabled())
location = "needjava.html";
טעינת דפי web ספציפיים לתוך חלונות, היא טכניקת תכנות חשובה מאוד. ניתן לבצע זאת ע"י הצבת URL לתכונה location של החלון.

למרות שאובייקט ה-Location אינו בעל מתודה כזו, אובייקט זה תומך בשתי מתודות :
( )reload - טוענת מחדש את הדף המוצג הנוכחי משרת ה-web.
( )replace - טוענת ומציגה URL שמגדירים.
קריאה למתודה זו עבור URL נתון שונה מהצבת URL זה לתכונה location של החלון. כאשר קוראים ל-( )replace, הURL המוגדר מחליף את הנוכחי ברשימת היסטורית הדפדפן ולא יוצר כניסה חדשה ברשימת ההיסטוריה הזו.
לכן, אם משתמשים ב-( )replace על מנת לכתוב מסמך חדש על הקיים, הכפתור Back אינו מחדזיר למסמך המקורי, כמו שהיה עושה אם היינו טוענים את המסמך החדש ע"י הצבה לתכונה location. עבור אתרים ברשת המשתמשים במסגרות ומציגים הרבה דפים זמניים ברשימת ההיסטוריה, הכפתור Back נעשה יותר שימושי למשתמש.

אין לבלבל בין התכונה location של האובייקט Window, המתייחסת לאובייקט Location, לבין התכונה location של האובייקט Document, שהיא מחרוזת לקריאה בלבד ללא המאפינים המיוחדים של האובייקט Location. Document.location הוא תחליף ל- Document.URL, אשר ב-N 3 הוא השם המועדף לתכונה זו. ברוב המיקרים, document.location זהה ל-location.href. כאשר מתבצע כוון מחדש של השרת, document.location מכיל את ה- URL הממשי כפי שנטען, ו- location.href מכיל את ה- URL שבוקש במקור.

9. האובייקט History
התכונה history של האובייקט Window מתייחסת לאובייקט History עבור חלון. האובייקט History הוא מערך של ה-URLs בהיסטורית הדפדפן של החלון או המסגרת. עבור חלון N ברמה הגבוהה, האובייקט History הוא ייצוג תוכן התפריט Go של הדפדפן. היסטורית הגלישה של המשתמש הוא מידע פרטי, לכן, עקב סיבות בטיחות, ישנן הגבלות מחמירות על השימוש באובייקט History. ב-N 4 האלמנטים של המערך history נגישים עבור תסריטים חתומים. בגרסאות אחרות של N ואינטרנט אקספלורר, האלמנטים של המערך אינם נגישים אף פעם והאובייקט History פחות שימושי.

האובייקט History תומך בשלוש מתודות, ניתן להשתמש במתודות אלו ע"י תסריטים שאינם חתומים בכל הגרסאות של N ואינטרנט אקספלורר. המתודות ( )back ו-( )forward מבצעות את אותה פעולה כמו קליק על כפתורי הדפדפן Back ו-Forward. המתודה השלישית , ( )go, סובלת משגיאות ב-N 2,3 ובעלת התנהגות שאינה מתאימה באינטרנט אקספלורר 3, לכן עדיף להתעלם ממנה.
הדוגמא הבאה מראה כיצד ניתן להשתמש במתודות ( )back ו-( )forward של האובייקט History והאובייקט Location על מנת להוסיף בר ניווט לאתר רשת ממוסגר. יש לשים לב שבדוגמא נעשה שימוש ב-JS עם ריבוי מסגרות. כמו כן הדוגמא מכילה טופס HTML פשוט ומשתמשת ב-JS על מנת לקרוא ולכתוב ערכים מהטופס. 

<!-- 
קובץ זה מיישם בר ניווט, עוצב לתוך מסגרת בתחתית החלון
יש לכלול אותו בקבוצת מסגרות כך:
<frameset rows = "*,75">
<frame src = "about:blank">
<frame src = "navigation.html">
--> 

<SCRIPT>
// navigation bar ב- Back הפונקציה נקראת ע"י הכפתור
function go_back()
{
  // .בטופס URL ראשית, ניקוי שדה כניסת ה-  
  document.navbar.url.value = "";

  // של המסגרת העיקרית עלמנת לחזור לאחור History שימוש באובייקט
  parent.frames[0].history.back();		

  //  URL המתנה של שניה, ואז עידכון שדה כניסת ה
  // של המסגרת העיקרית location.href בטופס מהתכונה
  // להסתנכרן location.href ההמתנה הכרחית על מנת לאפשר לתכונה 
  setTimeout("document.navbar.url.value = 
                        parent.frames[0].location.href;", 1000);
}

// .היא עובדת כמו הפונקציה הנ"ל navigation bar
// . - ב Forward הפונקציה הבאה נקראת ע"י הכפתור

function go_forward()
{
 document.navbar.url.value = "";
 parent.frames[0].history.forward();
 setTimeout("document.navbar.url.value = 
            parent.frames[0].location.href;", 1000);
}

//, - שב Go הפונקציה הבאה נקראת ע"י הכפתור
// וכאשר הטופס מאושר navigation bar
function go_to()
{
 //- location קביעת התכונה
 // .שהמשתמש הדפיס URL של המסגרת העיקרית לתוך ה 
 parent.frames[0].location = document.navbar.url.value;
}
</SCRIPT>

<!- -שקוראים לפונקציות הנ"ל event handlers זהו הטופס, עם ה - ->

<FORM NAME = "navbar" onSubmit = "go_to(); return false">
<INPUT TYPE = "button" VALUE = "Back" onClick = "go_back();">
<INPUT TYPE = "button" VALUE = "Forward" onClick = "go_forward();">
URL:
<INPUT TYPE = "text" NAME = "url" SIZE = 50">
<INPUT TYPE = "button" VALUE = "Go" onClick = "go_to()">
</FORM>
10. ריבוי חלונות ומסגרות
בעולם האמיתי, רוב אפליקציות JS מערבות חלונות או מסגרות רבים. ב-JS יש הבחנה קטנה בין חלונות ומסגרות. ברוב האפליקציות המענינות, יש קוד JS שרץ באופן בלתי תלוי בכל אחד מהחלונות.

הקשר בין המסגרות

כל מסגרת שבחלון יכולה להתיחס לכל מסגרת אחרת דרך השימוש בתכונות: [ ]frames, parent ו-top של האובייקט Window.

כל חלון בעל התכונה frames. תכונה זו מתייחסת למערך אובייקטים מסוג Window, כאשר כל אחד מהם מייצג מסגרת המוכלת בחלון (אם החלון אינו מכיל מסגרות כלל, המערך [ ]frames ריק ו-frames.length שווה לאפס). כך, חלון (או מסגרת) יכול להתייחס לתת המסגרת הראשונה שלו כ-[0]frames, לשניה כ-[1]frames, וכך הלאה.
באופן דומה,קוד JS הרץ בחלון יכול להתייחס לתת מסגרת השלישית של המסגרת השניה שלו כך : 
frames[1].frames[2]
כל חלון בעל תכונה parent, המתייחסת לאובייקט Window שבו הוא מוכל. לכן, המסגרת הראשונה בתוך חלון יכולה להתייחס למסגרת ה"אחות" (המסגרת השניה שבחלון) שלה כך : 
parent.frames[1]
אם החלון הוא ברמה הגבוהה ולא מסגרת, התכונה parent מתייחסת לחלון עצמו : 
parent == self; // עבור כל חלון ברמה הגבוהה.
אם מסגרת מוכלת במסגרת אחרת המוכלת בחלון ברמה הגבוהה, מסגרת זו יכלה להתייחס לחלון ברמה הגבוהה כ-parent.parent. התכונה top היא מקרה כללי של קיצור דרך, לא משנה עד כמה עמוק המסגרת נמצאת, התכונה top שלה מתייחסת לחלון, ברמה הגבוהה, המכיל אותה. אם אובייקט Window מייצג חלון ברמה הגבוהה, top מתייחסת לחלון עצמו. עבור מסגרות שהן "בנים" ישירים של חלון ברמה הגבוהה, התכונה top זהה לתכונה parent.

שמות חלונות ומסגרות

הארגומנט האופציונלי השני של המתודה ( )open הוא שם החלון החדש שנוצר. כאשר יוצרים מסגרת ע"י תווית <FRAME> ניתן להגדיר שם ע"י התכונה NAME. סיבה חשובה להגדיר שמות לחלונות ומסגרות היא שניתן להשתמש בשמות אלו כערך של התכונה TARGET של התוויות: <A>, <MAP>, <FORM>. כך הדפדפן היכו למקם את תוצאות של הפעלת קישור, הקלקה על תמונה , או אישור טופס.

לדוגמא, אם יש שני חלונות ,חלון אחד בשם table_of_contents והשני בשם mainwin, ניתן לכתוב את ה-HTML הבא בחלון table_of_contents : 
<A HREF = "chapter01.html" TARGET = "mainwin">
Chaptern 1, Introduction
<A>
כאשר המשתמש מקליק על ההיפר טקסט הזה, הדפדפן טוען את ה-URL המוגדר, אך במקום להציג את ה-URL באותו החלון של הקישור, הוא מציג אותו בחלון בשם mainwin. אם לא קיים חלוןבעל שם כזה, קליק על הקישור יוצר חלון חדש בעל שם זה, וטוען את ה-URL המוגדר לתוכו.
התכונות TARGET ו-NAME הן חלק מ-HTML ופועלות ללא התערבות של JS. לכל אובייקט Window יש מערך [ ]frames המכיל references לכל אחת מהמסגרות שלו. מערך זה מכיל את כל המסגרות שבחלון (או במסגרת), בין אם הן בעלות שם או לא. אם ניתן שם למסגרת, מאוחסן reference למסגרת בתכונה חדשה של אובייקט החלון של האב. השם של תכונה חדשה זו זהה לשם של המסגרת.
לכן, ניתן ליצור מסגרת ע"י HTML כך : 
<FRAME NAME = "table_of_contents" SRC = "toc.html">
כעת ניתן להתייחס למסגרת זו ממסגרת "אחות" אחרת ע"י : 
parent.table_of_contents
זה עושה את הקוד קל יותר לקריאה ולהבנה לעומת שימוש במערך עם אינדקסים, כמו שנעשה עם מסגרות ללא שם : 
Parent.frames[1]
התכונה name של אובייקט Window מכילה את שם החלון זה.
ב-1.0 JS, תכונה זו היא לקריאה בלבד.
ב-1.1 JS, ניתן לקבוע תכונה זו ע"י שינוי שם החלון או המסגרת.
אחת הסיבות לעשות זאת, היא על מנת לקבוע את שם חלון הדפדפן ההתחלתי. כאשר N מתחיל לפעול, החלון ההתחלתי אינו בעל שם, לכן לא ניתן להשתמש בו ע"י התכונה TARGET. אם קובעים את התכונה name של החלון, ניתן להשתמש בשם זה ע"י התכונה TARGET.

JS בחלונות אינטראקטיבים

האובייקט Window משרת כאובייקט הגלובלי עבור קוד JS בצד הלקוח, וכהקשר הביצוע עבור כל קוד JS שהוא מכיל. עובדה זו נכונה גם לגבי מסגרות, כל מסגרת היא הקשר ביצוע בלתי תלוי של JS. משום שכל אובייקט Window הוא האובייקט הגלובלי של עצמו, כל חלון מגדיר את ה-namespace שלו ואת קבוצת המשתנים ה"גלובליים" שלו. מנקודת מבט של ריבוי מסגרות או חלונות, משתנים גלובליים אינם נראים גלובליים!

למרות שכל חלון או מסגרת מגדירים הקשר ביצוע JS בלתי תלוי, אין זה אומר שקוד JS הרץ בחלון אחד מופרד מקוד הרץ בחלונות אחרים. קוד הרץ במסגרת אחת הוא בעל אובייקט Window אחר בראש שרשרת הטווח לעומת קוד הרץ במסגרת אחרת.
בכל אופן, הקוד של שתי המסגרות מתבצע ע"י אותו מפרש JS, באותה סביבת JS. למרות שקוד JS של מסגרות שונות מתבצע עם שרשרת טווח שונה, אין זה מונע מהקוד במסגרת אחת להתייחס ולהשתמש במשתנים ובפונקציות שהוגדרו ע"י קוד של מסגרת אחרת.
למשל, נניח שקוד במסגרת A מגדיר משתנה i : 
var i = 3;
משתנה זה הינו תכונה של האובייקט הגלובלי, תכונה של האובייקט Window. קוד במסגרת A יכול להתייחס למשתנה במפורש, כמו אל תכונה, ע"י אחד משני הביטויים הבאים : 
window.i
self.i
נניח שמסגרת A בעלת מסגרת "אחות" B, הרוצה לקבוע את הערך של המשתנה i המוגדר ע"י הקוד במסגרת A. אם מסגרת B רק קובעת משתנה i, היא תצליח רק ביצירת תכונה חדשה של אובייקט ה-Window שלה. לכן, חייבים להתייחס במפורש לתכונה i שבמסגרת ה"אחות" ע"י הקוד הבא : 
parent.frames[0].i = 4;
אם קוד JS במסגרת A מגדיר פונקציה f, פונקציה זו מוגדרת רק בתוך מסגרת A.
קוד במסגרת A יכול לקרוא ל-f כך : 
f();
קוד במסגרת B, חייב להתייחס ל-f כאל תכונה של האובייקט Window של מסגרת A : 
parent.frames[0].f();
אם הקוד במסגרת B צריך להשתמש בפונקציה זו בתדירות גבוהה, ניתן להציב את הפונקציה לתוך משתנה של מסגרת B וכך ניתן להתייחס ביותר נוחיות לפונקציה : 
var f = parent.frames[0].f;
כעת קוד שבמסגרת B יכול לקרוא לפונקציה כ-( )f.

כאשר משתפים פונקציות בין מסגרות או חלונות כנ"ל, חשוב מאוד לשמור על החוקים של הטווח הלקסיקלי. פונקציה מתבצעת בטווח בו היא הוגדרה, ולא בטווח שממנו נקראה. אם הפונקציהf מתייחסת למשתנים גלובליים, מתייחסים למשתנים אלו כאל תכונות של המסגרת A, גם כאשר הפונקציה נקראה ממסגרת B. אם לא שמים לב לכך, התוכנית עלולה להתנהג בדרכים לא צפויות ומבלבלות.

בנאים הם גם כן פונקציות, לכן אם מגדירים מחלקה של אובייקטים עם פונקצית בנאי ואובייקט אב טיפוס, מחלקה זו מוגדרת רק עבור חלון אחד : 
<HEAD>
<SCRIPT SRC = "Complex.js"></SCRIPT>
</HEAD>

<FRAMESETROWS = "50%,50%">
<FRAMENAME = "frame1"SRC = "frame1.html">
<FRAMENAME = "frame2"SRC = "frame2.html">
</FRAMESET>
קוד JS בקבצים : frame1.html ו- frame2.html אינו יכול ליצור אובייקט Complex ע"י ביטוי כזה : 
// לא יעבוד משתי המסגרות
var c = new Complex(1,2);
הקוד בקבצים אלו חייב להתייחס במפורש לפונקצית הבנאי : 
var c = new top.Copmlex(3,4);
כמו כן,קוד בשתי המסגרות יכול להגדיר משתנה משלו על מנת להתייחס באופן יותר נוח לפונקצית הבנאי : 
var Complex = top.Complex;
var c = new Complex(1,2);
בנאים המוגדרים מראש, מוגדרים מראש באופן אוטומטי בכל החלונות. למרות זאת, לכל חלון יש העתק בלתי תלוי של הבנאי והעתק בלתי תלוי של אובייקט האב טיפוס.
לדוגמא, לכל חלון יש העתק בלתי תלוי משלו של הבנאי ( )String ושל האובייקט String.prototype. לכן, אם כותבים מתודה חדשה עבור הפעלת מחרוזות JS והופכים אותה למתודה של המחלקה String, ע"י הצבה לאובייקט String.prototype בחלון הנוכחי, כל המחרוזות בחלון זה יכולות להשתמש במתודה זו. אך מתודה זו אינה נגישה למחרוזות שהוגדרו בחלונות אחרים. יש לשים לב שזה לא משנה איזה חלון מחזיק reference למחרוזת, אלא רק באיזה חלון נוצרה המחרוזת.

דוגמא: מסגרות צבעוניות

בדוגמא הבאה מוגדרת רשת של תשע מסגרות, היא מדגימה חלק מהטכניקות שהוזכרו קודם. חלק ה-<HEAD> של המסגרת כולל <SCRIPT> המגדיר פונקצית JS בשם ( )setcolor. ה- event handler onLoad של התווית <FEAMESET> קורא לפונקציה זו פעם אחת עבור כל אחת מתשעת המסגרות.

הפונקציה ( )setcolor מקבלת אובייקט Window, היא יוצרת צבע באופו רנדומלי ומשתמשת בו כערך החדש של התכונה bgColor של האובייקט Document. כמו כן, הפונקציה משתמשת במתודה ( )setTimeout על מנת לתזמן את עצמה כך שתקרא שוב בכל שניה. קריאה למתודה ( )setTimeout היא החלק המענין ביותר של הדוגמא. יש לשים לב איך היא משתמשת בתכונות parent ו-name של האובייקט Window : 

<html>
<head>

<SCRIPT>

function setcolor(w)
{
  var r = (Math.random() * 256).toString(16);
  var g = (Math.random() * 256).toString(16);
  var b = (Math.random() * 256).toString(16);
  var colorStrnig = "#" + r + g + b;
  w.document.bgColor = colorString;
  setTimeout("setcolor("+w.name+")",1000);
}

</SCRIPT>

</HEAD>

<FRAMESETrows = "33%,33%,34%" cols = "33%,33%,34%" 
onLoad = "for(var I=0; I<9; I++) setcolor(frames[I])">

<FRAME NAME = f1 SRC = ""> <FRAME NAME = f2 SRC ="">
<FRAME NAME = f3 SRC = ""> <FRAME NAME = f3 SRC ="">
<FRAME NAME = f5 SRC = ""> <FRAME NAME = f5 SRC ="">
<FRAME NAME = f7 SRC = ""> <FRAME NAME = f7 SRC ="">
<FRAME NAME = f9 SRC = "">

</FRAMESET>

</body>
</html>
[לתחילת העמוד]   [נושא הבא]