diff options
Diffstat (limited to 'files/he/web/javascript/reference/statements')
7 files changed, 1212 insertions, 0 deletions
diff --git a/files/he/web/javascript/reference/statements/const/index.html b/files/he/web/javascript/reference/statements/const/index.html new file mode 100644 index 0000000000..98de11967b --- /dev/null +++ b/files/he/web/javascript/reference/statements/const/index.html @@ -0,0 +1,133 @@ +--- +title: const +slug: Web/JavaScript/Reference/Statements/const +tags: + - const + - מה זה const + - משתנים +translation_of: Web/JavaScript/Reference/Statements/const +--- +<div>{{jsSidebar("Statements")}}</div> + +<div>מילת ההצהרה <strong><code>const</code></strong> משמשת להכזרה על משתנה קבוע שאין אפשרות לשנות את הערך שלו.<br> + </div> + +<div>{{EmbedInteractiveExample("pages/js/statement-const.html")}}</div> + + + +<h2 id="תחביר">תחביר</h2> + +<pre class="syntaxbox">const <em>name1 = <em>value1 [</em>, <em>name2</em> = <em>value2</em><em> [</em>, ... [</em>, <em>nameN</em> = <em>valueN]]]</em>;</pre> + +<dl> + <dt><code>nameN</code></dt> + <dd>שם המשתנה.</dd> + <dt><code>valueN</code></dt> + <dd>הערך של המשתנה.</dd> +</dl> + +<h2 id="תיאור">תיאור</h2> + +<p>בשפת ג'אווה סקריפט אנו משתמשים במשתנים על מנת להחזיק ערכים שונים.<br> + הצהרה על משתנה באמצעות <strong><code>const</code></strong> הופכת אותו לקבוע ולא ניתן לשנות את הערך שלו.<br> + הקצאת ערך למשתנה ללא הצהרה מראש הופכת אותו למשתנה גלובלי, אך בשונה מהצהרה באמצעות <strong><code>var</code></strong> הוא אינו כפוף לאובייקט האב <strong><code>window</code></strong>.<br> + חשוב לציין שהצהרה באמצעות const לא מבצעת <a href="/he/docs/">Hoisting</a>.</p> + +<h2 id="דוגמאות">דוגמאות</h2> + +<p>הדוגמה הבאה ממחישה כיצד מתנהגים משתנים קבועים.</p> + +<pre class="brush:js">// NOTE: Constants can be declared with uppercase or lowercase, but a common +// convention is to use all-uppercase letters. + +// define MY_FAV as a constant and give it the value 7 +const MY_FAV = 7; + +// this will throw an error - Uncaught TypeError: Assignment to constant variable. +MY_FAV = 20; + +// MY_FAV is 7 +console.log('my favorite number is: ' + MY_FAV); + +// trying to redeclare a constant throws an error - Uncaught SyntaxError: Identifier 'MY_FAV' has already been declared +const MY_FAV = 20; + +// the name MY_FAV is reserved for constant above, so this will fail too +var MY_FAV = 20; + +// this throws an error too +let MY_FAV = 20; + +// it's important to note the nature of block scoping +if (MY_FAV === 7) { + // this is fine and creates a block scoped MY_FAV variable + // (works equally well with let to declare a block scoped non const variable) + let MY_FAV = 20; + + // MY_FAV is now 20 + console.log('my favorite number is ' + MY_FAV); + + // this gets hoisted into the global context and throws an error + var MY_FAV = 20; +} + +// MY_FAV is still 7 +console.log('my favorite number is ' + MY_FAV); + +// throws an error - Uncaught SyntaxError: Missing initializer in const declaration +const FOO; + +// const also works on objects +const MY_OBJECT = {'key': 'value'}; + +// Attempting to overwrite the object throws an error - Uncaught TypeError: Assignment to constant variable. +MY_OBJECT = {'OTHER_KEY': 'value'}; + +// However, object keys are not protected, +// so the following statement is executed without problem +MY_OBJECT.key = 'otherValue'; // Use Object.freeze() to make object immutable + +// The same applies to arrays +const MY_ARRAY = []; +// It's possible to push items into the array +MY_ARRAY.push('A'); // ["A"] +// However, assigning a new array to the variable throws an error - Uncaught TypeError: Assignment to constant variable. +MY_ARRAY = ['B'];</pre> + +<h2 id="מפרט">מפרט</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>No changes.</td> + </tr> + </tbody> +</table> + +<h2 id="תאימות_דפדפן">תאימות דפדפן</h2> + + + +<p>{{Compat("javascript.statements.const")}}</p> + +<h2 id="ראה_גם">ראה גם</h2> + +<ul> + <li><a href="https://developer.mozilla.org/he/docs/Web/JavaScript/Reference/Statements/var"><code>var</code></a></li> + <li><a href="https://developer.mozilla.org/he/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a></li> +</ul> diff --git a/files/he/web/javascript/reference/statements/for...of/index.html b/files/he/web/javascript/reference/statements/for...of/index.html new file mode 100644 index 0000000000..86edb2f69e --- /dev/null +++ b/files/he/web/javascript/reference/statements/for...of/index.html @@ -0,0 +1,269 @@ +--- +title: for...of +slug: Web/JavaScript/Reference/Statements/for...of +translation_of: Web/JavaScript/Reference/Statements/for...of +--- +<div>{{jsSidebar("Statements")}}</div> + +<div> </div> + +<div>הצהרת <strong><code>for...of </code></strong>יוצרת לולאה ע"ג<code> </code><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable">iterable objects</a> (שכולל {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, {{jsxref("String")}}, {{jsxref("TypedArray")}}, <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a> object וכן הלאה..),</div> + +<div>invoking a custom iteration hook with statements to be executed for the value of each distinct property.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">for (<em>variable</em> of <em>iterable</em>) { + <em>statement +</em>} +</pre> + +<dl> + <dt><code>variable</code></dt> + <dd>בכל איטרציה, ערך ה property הנוכחי של <em>iterable </em>מוקצה ל <em>variable</em></dd> + <dt>iterable</dt> + <dd>אובייקט עם properties ברי איטרציה</dd> +</dl> + +<h3 id="לדוגמא"><span style="font-size: 14px; letter-spacing: normal;">לדוגמא:</span></h3> + +<h3 id="איטרציה_עג_jsxref(Array)">איטרציה ע"ג {{jsxref("Array")}}</h3> + +<pre class="brush:js">let iterable = [10, 20, 30]; + +for (let value of iterable) { + console.log(value); +} +// 10 +// 20 +// 30 +</pre> + +<p>אפשר להשתמש ג"כ ב <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a> </code>במקום <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a> </code>באם אתה לא משנה את ערך המשתנה בתוך הבלוק.</p> + +<p> </p> + +<p>איטרציה ע"ג {{jsxref("String")}}</p> + +<pre class="brush:js">let iterable = "boo"; + +for (let value of iterable) { + console.log(value); +} +// "b" +// "o" +// "o" +</pre> + +<h3 id="Iterating_over_a_jsxref(TypedArray)">Iterating over a {{jsxref("TypedArray")}}</h3> + +<pre class="brush:js">let iterable = new Uint8Array([0x00, 0xff]); + +for (let value of iterable) { + console.log(value); +} +// 0 +// 255 +</pre> + +<h3 id="Iterating_over_a_jsxref(Map)">Iterating over a {{jsxref("Map")}}</h3> + +<pre class="brush:js">let iterable = new Map([["a", 1], ["b", 2], ["c", 3]]); + +for (let entry of iterable) { + console.log(entry); +} +// [a, 1] +// [b, 2] +// [c, 3] + +for (let [key, value] of iterable) { + console.log(value); +} +// 1 +// 2 +// 3 +</pre> + +<h3 id="Iterating_over_a_jsxref(Set)">Iterating over a {{jsxref("Set")}}</h3> + +<pre class="brush:js">let iterable = new Set([1, 1, 2, 2, 3, 3]); + +for (let value of iterable) { + console.log(value); +} +// 1 +// 2 +// 3 +</pre> + +<h3 id="Iterating_over_a_DOM_collection">Iterating over a DOM collection</h3> + +<p>Iterating over DOM collections like {{domxref("NodeList")}}: the following example adds a <code>read</code> class to paragraphs that are direct descendants of an article:</p> + +<pre class="brush:js">// Note: This will only work in platforms that have +// implemented NodeList.prototype[Symbol.iterator] +let articleParagraphs = document.querySelectorAll("article > p"); + +for (let paragraph of articleParagraphs) { + paragraph.classList.add("read"); +} +</pre> + +<h3 id="Iterating_over_generators">Iterating over generators</h3> + +<p>You can also iterate over <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function*">generators</a>:</p> + +<pre class="brush:js">function* fibonacci() { // a generator function + let [prev, curr] = [1, 1]; + while (true) { + [prev, curr] = [curr, prev + curr]; + yield curr; + } +} + +for (let n of fibonacci()) { + console.log(n); + // truncate the sequence at 1000 + if (n >= 1000) { + break; + } +} +</pre> + +<h3 id="Iterating_over_other_iterable_objects">Iterating over other iterable objects</h3> + +<p>You can also iterate over an object that explicitly implements <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable">iterable</a> protocol:</p> + +<pre class="brush:js">var iterable = { + [Symbol.iterator]() { + return { + i: 0, + next() { + if (this.i < 3) { + return { value: this.i++, done: false }; + } + return { value: undefined, done: true }; + } + }; + } +}; + +for (var value of iterable) { + console.log(value); +} +// 0 +// 1 +// 2 +</pre> + +<h3 id="Difference_between_for...of_and_for...in">Difference between <code>for...of</code> and <code>for...in</code></h3> + +<p>The <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></code> loop will iterate over all enumerable properties of an object.</p> + +<p>The <code>for...of</code> syntax is specific to <strong>collections</strong>, rather than all objects. It will iterate in this manner over the elements of any collection that has a <code>[Symbol.iterator]</code> property.</p> + +<p>The following example shows the difference between a <code>for...of</code> loop and a <code>for...in</code> loop.</p> + +<pre class="brush:js">Object.prototype.objCustom = function () {}; +Array.prototype.arrCustom = function () {}; + +let iterable = [3, 5, 7]; +iterable.foo = "hello"; + +for (let i in iterable) { + console.log(i); // logs 0, 1, 2, "foo", "arrCustom", "objCustom" +} + +for (let i of iterable) { + console.log(i); // logs 3, 5, 7 +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...of statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...of statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(38)}} <a href="#Chrome_note_1">[1]</a><br> + {{CompatChrome(51)}} <a href="#Chrome_note_3">[3]</a></td> + <td>{{CompatGeckoDesktop("13")}} <a href="#Gecko_note_2">[2]</a></td> + <td>12</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>5.1</td> + <td>{{CompatChrome(38)}} [1]</td> + <td>{{CompatGeckoMobile("13")}} [2]</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<p><a name="Chrome_note_1">[1]</a> From Chrome 29 to Chrome 37 this feature was available behind a preference. In chrome://flags/#enable-javascript-harmony, activate the entry “Enable Experimental JavaScript”.</p> + +<p><a name="Gecko_note_2">[2]</a> Prior Firefox 51, using the <code>for...of</code> loop construct with the <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code> keyword threw a {{jsxref("SyntaxError")}} ("missing = in const declaration"). This has been fixed ({{bug(1101653)}}).</p> + +<p><a name="Chrome_note_3">[3]</a> Support for iteration of objects was added in Chrome 51.</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach">Map.prototype.forEach()</a></li> +</ul> diff --git a/files/he/web/javascript/reference/statements/for_each...in/index.html b/files/he/web/javascript/reference/statements/for_each...in/index.html new file mode 100644 index 0000000000..b45c6f5ab7 --- /dev/null +++ b/files/he/web/javascript/reference/statements/for_each...in/index.html @@ -0,0 +1,128 @@ +--- +title: for each...in +slug: Web/JavaScript/Reference/Statements/for_each...in +translation_of: Archive/Web/JavaScript/for_each...in +--- +<div>{{jsSidebar("Statements")}}</div> + +<div class="warning"> +<p style="direction: rtl;">טענת "<code>for each...in" </code>הוצאה משימוש בסטנדרט (ECMA-357 (<a href="/en-US/docs/Archive/Web/E4X" title="/en-US/docs/E4X">E4X</a>. התמיכה ב-E4X אמנם הוסרה, אך טענת ה"<code>for each...in" </code>לא תבוטל ולא תוסר מטעמי תאימות לגרסאות קודמות. עם זאת, מומלץ להשתמש בטענת "<a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of" title="/en-US/docs/JavaScript/Reference/Statements/for...of">for...of</a>" במקום. (ע"ע {{ bug("791343")}} ). </p> +</div> + +<p style="direction: rtl;">טענה מסוג:</p> + +<p style="direction: rtl;"><code><strong>for each...in</strong></code></p> + +<p style="direction: rtl;">("עבור כל... ב...")</p> + +<p style="direction: rtl;">חגה סביב כל הערכים של כל "פריטי הרכוש" (properties) של משתנה נתון. עבור כל אחד מפריטי הרכוש תבוצע טענה מוגדרת.</p> + +<h2 id="תחביר" style="direction: rtl;">תחביר</h2> + +<pre class="syntaxbox"><code>for each (<em>variable</em> in <em>object</em>) { + <em>statement</em> +}</code></pre> + +<dl> + <dt style="direction: rtl;"><code>variable</code></dt> + <dd style="direction: rtl;">המשתנה שיחוג סביב הערכים של פרטי הרכוש. ניתן (אך לא חובה) להצהיר על משתנה זה עם מילת המפתח var. המשתנה הזה הוא פנימי לפונקציה, ולא ללולאה עצמה.</dd> +</dl> + +<dl> + <dt style="direction: rtl;"><code>object</code></dt> + <dd style="direction: rtl;">האובייקט שסביב פריטי הרכוש שלו יש לחוג. </dd> +</dl> + +<dl> + <dt style="direction: rtl;"><code>statement</code></dt> + <dd style="direction: rtl;">טענה שיש לבצע עבור כל אחד מפריטי הרכוש. על מנת לבצע יותר מטענה אחת בתוך הלולאה, יש להשתמש בטענת בלוק (<code>{ ... }</code>) כדי לקבץ את הטענות הללו יחדיו.</dd> +</dl> + +<h2 id="תיאור" style="direction: rtl;">תיאור</h2> + +<p style="direction: rtl;"> </p> + +<p>Some built-in properties are not iterated over. These include all built-in methods of objects, e.g. <code>String</code>'s <code>indexf</code></p> + +<p>method. However, all user-defined properties are iterated over.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_for_each...in">Using <code>for each...in</code></h3> + +<p><strong>Warning:</strong> Never use a loop like this on arrays. Only use it on objects. See <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a> for more details.</p> + +<p>The following snippet iterates over an object's properties, calculating their sum:</p> + +<pre class="brush:js">var sum = 0; +var obj = {prop1: 5, prop2: 13, prop3: 8}; + +for each (var item in obj) { + sum += item; +} + +console.log(sum); // logs "26", which is 5+13+8</pre> + +<h2 id="Specifications">Specifications</h2> + +<p>Not part of a current ECMA-262 specification. Implemented in JavaScript 1.6 and deprecated.</p> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in" title="JavaScript/Reference/Statements/for...in">for...in</a></code> - a similar statement that iterates over the property <em>names</em>.</li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of" title="/en-US/docs/JavaScript/Reference/Statements/for...of">for...of</a></code> - a similar statement that iterates over the property <em>values</em> but can only be used for iteratable types, so not for generic objects</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Statements/for" title="JavaScript/Reference/Statements/for">for</a></code></li> +</ul> diff --git a/files/he/web/javascript/reference/statements/function_star_/index.html b/files/he/web/javascript/reference/statements/function_star_/index.html new file mode 100644 index 0000000000..a72a927859 --- /dev/null +++ b/files/he/web/javascript/reference/statements/function_star_/index.html @@ -0,0 +1,212 @@ +--- +title: function* +slug: Web/JavaScript/Reference/Statements/function* +translation_of: Web/JavaScript/Reference/Statements/function* +--- +<div>{{jsSidebar("Statements")}}</div> + +<p> </p> + +<p>הצהרת <code><strong>function*</strong></code> (מילת <code>function</code> ולאחריה כוכבית) מגדירה <em>פונקצית גנרטור</em>, אשר מחזירה אובייקט {{jsxref("Global_Objects/Generator","Generator")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-functionasterisk.html")}}</div> + + + +<div class="noinclude"> +<p>ניתן גם להגדיר פונקציות גנרטור על-ידי שימוש בבנאי {{jsxref("GeneratorFunction")}}, או בתחביר של ביטוי פונקציה.</p> +</div> + +<h2 id="תחביר">תחביר</h2> + +<pre class="syntaxbox">function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>שם הפונקציה.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>השם של פרמטר רשמי של הפונקציה.</dd> +</dl> + +<dl> + <dt><code>statements</code></dt> + <dd>הפקודות המרכיבות את גוף הפונקציה.</dd> +</dl> + +<h2 id="תיאור">תיאור</h2> + +<p>גנרטורים הינם פונקציות שניתן לצאת מהן ולאחר מכן להיכנס אליהן מחדש. ההקשר שלהם (קשירת המשתנים) יישמר לאורך הכניסות מחדש.<br> + <br> + גנרטורים ב- JavaScript -- במיוחד בשילוב עם Promises -- הינם כלי חזר מאוד לתכנות אסינכרוני, כיוון שהם מתווכים -- ואפילו מחסלים לחלוטין -- את הבעיות עם קריאות חוזרות, כגון <a href="http://callbackhell.com/">Callback Hell</a> ו- <a href="https://frontendmasters.com/courses/rethinking-async-js/callback-problems-inversion-of-control/">Inversion of Control</a>.<br> + תבנית זו הינה הבסיס לפונקציות <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function">async</a></code>.</p> + +<p>קריאה לפונקצית גנרטור לא מריצה את גוף הפונקציה מיידית; במקום זאת, מוחזר אובייקט <a href="/he/docs/Web/JavaScript/Reference/Iteration_protocols#iterator">איטרטור</a> לפונקציה. כאשר המתודה <code>()next</code> של האיטרטור נקראת, גוף הפונקציה רץ עד לביטוי ה-{{jsxref("Operators/yield", "yield")}} הראשון, אשר מציין את הערך שיוחזר לאיטרטור, או העברה לפונקציה יוצרת אחרת על-ידי שימוש {{jsxref("Operators/yield*", "*yield")}}. מתודת ה- <code>()next</code> מחזירה אובייקט עם שדה <code>value</code>, המכיל את הערך המיוצר ושדה <code>done</code> בכעל ערך בוליאני, המציין האם הגנרטור יצר את הערך האחרון. קריאה למתודת <code>()next</code> עם ארגומנט תמשיך את ריצת פונקציית הגנרטור, תוך החלפת ביטוי ה- <code>yield</code> בו הריצה הופסקה עם הארגומנט מתוך <code>()next</code>.</p> + +<p>פקודת <code>return</code> בתוך גנרטור, כאשר הוא רץ, תגרום לגנרטור לסיים (כלומר שדה ה- <code>done</code> המוחזר יהיה בעל <code>true</code>). אם ערך מוחזר, הוא יהיה בשדה <code>value</code> של האובייקט המוחזר על-ידי הגנרטור.<br> + בדומה לפקודת ה- <code>return</code>, שגיאה שתיזרק בתוך הגנרטור תביא לסיום הגנרטור -- אלא אם היא תיתפס בגוף הגנרטור.<br> + כאשר גנרטור מסתיים, קריאות נוספות ל- <code>()next</code> לא יגרמו לריצה כלשהי של קוד הגנרטור. הן רק יחזירו אובייקט בצורה זו: <code>{value: undefined, done: true}</code>.</p> + +<h2 id="דוגמאות">דוגמאות</h2> + +<h3 id="דוגמה_פשוטה">דוגמה פשוטה</h3> + +<pre class="brush: js">function* idMaker() { + var index = 0; + while (index < index+1) + yield index++; +} + +var gen = idMaker(); + +console.log(gen.next().value); // 0 +console.log(gen.next().value); // 1 +console.log(gen.next().value); // 2 +console.log(gen.next().value); // 3 +// ...</pre> + +<h3 id="דוגמה_עם_*yield">דוגמה עם *yield</h3> + +<pre class="brush: js">function* anotherGenerator(i) { + yield i + 1; + yield i + 2; + yield i + 3; +} + +function* generator(i) { + yield i; + yield* anotherGenerator(i); + yield i + 10; +} + +var gen = generator(10); + +console.log(gen.next().value); // 10 +console.log(gen.next().value); // 11 +console.log(gen.next().value); // 12 +console.log(gen.next().value); // 13 +console.log(gen.next().value); // 20 +</pre> + +<h3 id="העברת_ארגומנטים_לגנרטורים">העברת ארגומנטים לגנרטורים</h3> + +<pre class="brush: js">function* logGenerator() { + console.log(0); + console.log(1, yield); + console.log(2, yield); + console.log(3, yield); +} + +var gen = logGenerator(); + +// <span dir="rtl">הקריאה הראשונה ל- next מתבצעת מתחילת הפונקציה</span> +// <span dir="rtl">עד שהיא מגיעה לפקודת yield הראשונה</span> +gen.next(); // 0 +gen.next('pretzel'); // 1 pretzel +gen.next('california'); // 2 california +gen.next('mayonnaise'); // 3 mayonnaise +</pre> + +<h3 id="פקודת_return_בתוך_גנרטור">פקודת return בתוך גנרטור</h3> + +<pre class="brush: js">function* yieldAndReturn() { + yield "Y"; + return "R"; + yield "unreachable"; +} + +var gen = yieldAndReturn() +console.log(gen.next()); // { value: "Y", done: false } +console.log(gen.next()); // { value: "R", done: true } +console.log(gen.next()); // { value: undefined, done: true } +</pre> + +<h3 id="לא_ניתן_ליצור_אובייקט_גנרטור">לא ניתן ליצור אובייקט גנרטור</h3> + +<pre class="brush: js">function* f() {} +var obj = new f; // throws "TypeError: f is not a constructor +</pre> + +<h3 id="גנרטורים_המוגדרים_בתוך_ביטוי">גנרטורים המוגדרים בתוך ביטוי</h3> + +<pre class="brush: js">const foo = function* () { + yield 10; + yield 20; +}; + +const bar = foo(); +console.log(bar.next()); // {value: 10, done: false}</pre> + +<h2 id="מפרטים">מפרטים</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#sec-generator-function-definitions', 'function*')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>הגדרה ראשונית.</td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#sec-generator-function-definitions', 'function*')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td>שונה, כך תהיה מלכודת שבגנרטורים לא [[Construct]] ויזרקו שגיאה בשימוש עם <code>new</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator-function-definitions', 'function*')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="תאימות_לדפדפנים">תאימות לדפדפנים</h2> + +<div> + + +<p>{{Compat("javascript.statements.generator_function")}}</p> +</div> + +<h2 id="הערות_ספציפיות_ל-_Firefox">הערות ספציפיות ל- Firefox</h2> + +<h4 id="גנרטורים_ואיטרטורים_ב-_Firefox_לפני_גרסה_26">גנרטורים ואיטרטורים ב- Firefox לפני גרסה 26</h4> + +<p>גרסאות Firefox ישנות יותר מממשות הגדרת גנרטורים ישנה יותר. בגרסה הקודמת גנרטורים הוגדרו על-ידי שימוש במילת <code>function</code> רגילה (ללא כוכבית), בין היתר. ראה <a href="/he/docs/Web/JavaScript/Reference/Statements/Legacy_generator_function">פונקציה יוצרת מסורתית </a>למידע נוסף.</p> + +<h4 id="אובייקט_IteratorResult_מוחזר_במקום_זריקת_שגיאה">אובייקט <code>IteratorResult</code> מוחזר במקום זריקת שגיאה</h4> + +<p>החל מ- Gecko 29 {{geckoRelease(29)}}, הפונקציה היוצרת המלאה כבר אינה זורקת {{jsxref("TypeError")}} "generator has already finished". במקום זאת, היא מחזירה אובייקט <code>IteratorResult</code> כדוגמת <code>{ value: undefined, done: true }</code> ({{bug(958951)}}).</p> + +<h2 id="ראה_גם">ראה גם</h2> + +<ul> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>אובייקט {{jsxref("GeneratorFunction")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> + <li>{{jsxref("Operators/yield", "yield")}}</li> + <li>{{jsxref("Operators/yield*", "*yield")}}</li> + <li>{{jsxref("Function")}} object</li> + <li>{{jsxref("Statements/function", "function declaration")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li> + <li>Other web resources: + <ul> + <li><a href="http://facebook.github.io/regenerator/">Regenerator</a> an ES2015 generator compiler to ES5</li> + <li><a href="http://www.youtube.com/watch?v=qbKWsbJ76-s">Forbes Lindesay: Promises and Generators: control flow utopia -- JSConf EU 2013</a></li> + <li><a href="https://github.com/mozilla/task.js">Task.js</a></li> + <li><a href="https://github.com/getify/You-Dont-Know-JS/blob/master/async%20%26%20performance/ch4.md#iterating-generators-asynchronously">Iterating generators asynchronously</a></li> + </ul> + </li> +</ul> diff --git a/files/he/web/javascript/reference/statements/index.html b/files/he/web/javascript/reference/statements/index.html new file mode 100644 index 0000000000..2869ba1ce5 --- /dev/null +++ b/files/he/web/javascript/reference/statements/index.html @@ -0,0 +1,148 @@ +--- +title: Statements and declarations +slug: Web/JavaScript/Reference/Statements +tags: + - JavaScript + - NeedsTranslation + - Reference + - TopicStub + - statements +translation_of: Web/JavaScript/Reference/Statements +--- +<div dir="rtl">{{jsSidebar("Statements")}}</div> + +<div dir="rtl">יישומי ג'אווה סקריפט מורכבים ממשפטים בעלי תחביר מתאים (syntax).</div> + +<div dir="rtl">משפט אחד יכול להתפרס על גבי מספר שורות.</div> + +<div dir="rtl">מספר משפטים יכולים להופיע על גבי שורה אחת אם בין משפט למשפט מפריד הסמן ";".</div> + +<div dir="rtl">משפט הוא לא מילת מפתח אלא כמה מילות מפתח המאורגנות יחד.</div> + +<div dir="rtl"> </div> + +<h2 dir="rtl" id="משפטים_והצהרות_לפי_קטגוריה">משפטים והצהרות לפי קטגוריה</h2> + +<p dir="rtl"><em>לרשימה אלפבתית ראה סרגל בצד שמאל</em></p> + +<h3 dir="rtl" id="זרימת_תהליך">זרימת תהליך</h3> + +<dl> + <dt dir="rtl">{{jsxref("Statements/block", "Block")}}</dt> + <dd dir="rtl">משפט בלוק נועד לסידור של 0 או יותר משפטים יחד.<br> + בלוק תחום בין שני סוגריים מסולסלים.</dd> + <dt dir="rtl">{{jsxref("Statements/break", "break")}}</dt> + <dd dir="rtl">משפט break עוצר את הלולאה, משפט switch או משפט סיווג (label statement) ומעביר את ריצת התוכנה למשפט שמגיע אחרי המשפט שנעצר.</dd> + <dt dir="rtl">{{jsxref("Statements/continue", "continue")}}</dt> + <dd dir="rtl">משפט continue עוצר את האיטרציה הנוכחית\מסווגת של הלולאה הנוכחית וממשיך לאיטרציה הבאה בלולאה.</dd> + <dt dir="rtl">{{jsxref("Statements/Empty", "Empty")}}</dt> + <dd dir="rtl">משפט empty נועד לשימוש כמשפט ריק במקומות בהם התחביר של ג'אווה סקריפט מצפה למשפט.</dd> + <dt dir="rtl">{{jsxref("Statements/if...else", "if...else")}}</dt> + <dd dir="rtl">משפטי if else מריצים משפטים בהתאם לתנאים מסויימים. אם תנאי מסויים לא מתקיים, יכול לרוץ משפט אחר.</dd> + <dt dir="rtl">{{jsxref("Statements/switch", "switch")}}</dt> + <dd dir="rtl">משפט switch מכיל ביטוי מסויים שבהתאם לערך שלו נבחרת פסקת case והמשפטים שבה מורצים.</dd> + <dt dir="rtl">{{jsxref("Statements/throw", "throw")}}</dt> + <dd dir="rtl">משפט throw זורק שגיאה מותאמת אישית.</dd> + <dt dir="rtl">{{jsxref("Statements/try...catch", "try...catch")}}</dt> + <dd dir="rtl">משפט try/catch מנסה להריץ בלוק מסויים, ומגדיר תגובה במקרה שנזרקת שגיאה.</dd> +</dl> + +<h3 dir="rtl" id="הצהרות"> הצהרות</h3> + +<dl> + <dt dir="rtl">{{jsxref("Statements/var", "var")}}</dt> + <dd dir="rtl">המילה var מצהירה על משתנה חדש ומאפשרת לתת לו ערך ראשוני.</dd> + <dt dir="rtl">{{experimental_inline}} {{jsxref("Statements/let", "let")}}</dt> + <dd dir="rtl">המילה let מצהירה על משתנה חדש ומקומי לבלוק שבו הוצהר (בניגוד ל var שנמצא בתחום הגלובאלי (global scope), אפשר לתת ערך ראשוני בזמן ההצהרה.</dd> + <dt dir="rtl">{{experimental_inline}} {{jsxref("Statements/const", "const")}}</dt> + <dd dir="rtl">המילה const מצהירה על קבוע (constant) לקריאה בלבד.</dd> +</dl> + +<h3 dir="rtl" id="פונקציות_ומחלקות">פונקציות ומחלקות</h3> + +<dl> + <dt dir="rtl">{{jsxref("Statements/function", "function")}}</dt> + <dd dir="rtl">המילה function מצהירה על פונקציה עם הפרמטרים שצויינו.</dd> + <dt dir="rtl">{{experimental_inline}} {{jsxref("Statements/function*", "function*")}}</dt> + <dd dir="rtl">פונקציות מחוללות המאפשרות כתיבה פשוטה יותר של איטרטורים.</dd> + <dt dir="rtl">{{jsxref("Statements/return", "return")}}</dt> + <dd dir="rtl">המילה return מציינת את הערך שהפונקציה מחזירה.</dd> + <dt dir="rtl">{{experimental_inline}} {{jsxref("Statements/class", "class")}}</dt> + <dd dir="rtl">המילה class מגדירה מחלקה.</dd> +</dl> + +<h3 dir="rtl" id="Iterations">Iterations</h3> + +<dl> + <dt dir="rtl">{{jsxref("Statements/do...while", "do...while")}}</dt> + <dd dir="rtl">משפט do...while יוצר לולאה שמריצה משפט מסויים עד שהתנאי שבה הופך לשלילי. <br> + בהרצה הראשונה המשפט מורץ בלי קשר לערך התנאי ורק לאחר מכן נבדק לפני כל הרצה מחדש. </dd> + <dt dir="rtl">{{jsxref("Statements/for", "for")}}</dt> + <dd dir="rtl">משפט for יוצר לולאה שמורכבת משלושה ביטויים (אופציונאליים) התחומים בסוגריים ומופרדים ע"י סמן ";", שלאחריהם מורצים המשפטים שבתוך הלולאה.</dd> + <dt dir="rtl">{{deprecated_inline}} {{non-standard_inline()}} {{jsxref("Statements/for_each...in", "for each...in")}}</dt> + <dd dir="rtl">משפט for each...in עובר על כל הערכים של התכונות באובייקט מסויים ומריץ על כל אחת את המשפט שנמצא בלולאה.</dd> + <dt dir="rtl">{{jsxref("Statements/for...in", "for...in")}}</dt> + <dd dir="rtl">משפט for...in עובר על כל התכונות של אובייקט מסויים, בסדר שרירותי.<br> + על תכונה יכולים לרוץ משפטים.</dd> + <dt dir="rtl">{{experimental_inline}} {{jsxref("Statements/for...of", "for...of")}}</dt> + <dd dir="rtl">משפט for...of עובר על אובייקטים הנתנים לאיטרציה (מערכים, אובייקטים, איטרטורים ומחוללים) ויוצר איטרציה מותאמת לכל אחד מהאובייקטים שבה יכולים לרוץ משפטים מסויימים על הערך של כל תכונה באובייקט.</dd> + <dt dir="rtl">{{jsxref("Statements/while", "while")}}</dt> + <dd dir="rtl">משפט while יוצר לולאה שמריצה משפט מסויים כל עוד התנאי שבה חיובי. <br> + התנאי מורץ לפני כל הרצה.</dd> +</dl> + +<h3 dir="rtl" id="Others">Others</h3> + +<dl> + <dt dir="rtl">{{jsxref("Statements/debugger", "debugger")}}</dt> + <dd dir="rtl">Invokes any available debugging functionality. If no debugging functionality is available, this statement has no effect.</dd> + <dt dir="rtl">{{experimental_inline}} {{jsxref("Statements/export", "export")}}</dt> + <dd dir="rtl">Used to export functions to make them available for imports in external modules, another scripts.</dd> + <dt dir="rtl">{{experimental_inline}} {{jsxref("Statements/import", "import")}}</dt> + <dd dir="rtl">Used to import functions exported from an external module, another script.</dd> + <dt dir="rtl">{{jsxref("Statements/label", "label")}}</dt> + <dd dir="rtl">Provides a statement with an identifier that you can refer to using a <code>break</code> or <code>continue</code> statement.</dd> +</dl> + +<dl> + <dt dir="rtl">{{deprecated_inline}} {{jsxref("Statements/with", "with")}}</dt> + <dd dir="rtl">Extends the scope chain for a statement.</dd> +</dl> + +<h2 dir="rtl" id="Specifications">Specifications</h2> + +<table class="standard-table" dir="rtl"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>New: function*, let, for...of, yield, class</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12', 'Statements')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-12', 'Statements')}}</td> + <td>{{Spec2('ES3')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-12', 'Statements')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition</td> + </tr> + </tbody> +</table> + +<h2 dir="rtl" id="See_also">See also</h2> + +<ul> + <li dir="rtl"><a href="/en-US/docs/Web/JavaScript/Reference/Operators">Operators</a></li> +</ul> diff --git a/files/he/web/javascript/reference/statements/return/index.html b/files/he/web/javascript/reference/statements/return/index.html new file mode 100644 index 0000000000..dea3cb868f --- /dev/null +++ b/files/he/web/javascript/reference/statements/return/index.html @@ -0,0 +1,151 @@ +--- +title: return +slug: Web/JavaScript/Reference/Statements/return +translation_of: Web/JavaScript/Reference/Statements/return +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>הצהרה באמצעות <strong><code>return</code></strong> מתבצעת בעת סיום הפונקציה, גורמת לעצירתה ומציינת ערך שיש להחזיר למבקש הפונקציה.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-return.html")}}</div> + + + +<h2 id="תחביר">תחביר</h2> + +<pre class="syntaxbox">return [[expression]]; </pre> + +<dl> + <dt><code>expression</code></dt> + <dd>הביטוי שערכו יוחזר. במידה והביטוי לא הוזכר, הערך <strong><code>undefined</code></strong> יוחזר במקומו.</dd> +</dl> + +<h2 id="תיאור">תיאור</h2> + +<p>השימוש בהצהרה <strong><code>return</code></strong> בגוף הפונקציה, יפסיק את תהליך הריצה שלה.<br> + לדוגמה, לפונקציה <code>()square</code> ארגומנט בשם x, כאשר x יהיה מספר הפונקציה תחזיר את הערך של הארגומנט כפול עצמו.</p> + +<pre class="brush: js">function square(x) { + return x * x; +} +var demo = square(3); +// demo will equal 9 +</pre> + +<p>במידה וארגומנט חסר, הערך שיוחזר יהיה <strong><code>undefined</code></strong>. <br> + הצהרות ה-<strong><code>return</code></strong> הבאות מפסיקות את הריצה של הפונקציה:</p> + +<pre class="brush: js">return; +return true; +return false; +return x; +return x + y / 3; +</pre> + +<h3 id="הוספת_נקודה_פסיק_באופן_אוטומטי">הוספת נקודה פסיק באופן אוטומטי</h3> + +<p>להצהרה באמצעות <strong><code>return</code></strong> מתווספת באופן אוטומטי נקודה פסיק (ASI).<br> + אין לקשר בין שורת ההצהרה של <strong><code>return</code></strong> לביטוי .</p> + +<pre class="brush: js">return +a + b; +</pre> + +<pre class="brush: js">return; +a + b; +</pre> + +<p>כדי להימנע ממצב של הוספת נקודה פסיק באופן אוטומטי, יש להוסיף סוגריים באופן הבא:</p> + +<pre class="brush: js">return ( + a + b +); +</pre> + +<h2 id="דוגמאות">דוגמאות</h2> + +<h3 id="עצירת_הפונקציה">עצירת הפונקציה</h3> + +<p>הפונקציה נעצרת מיד בעת הקריאה ל-<strong><code>return</code></strong>.</p> + +<pre class="brush: js">function counter() { + for (var count = 1; ; count++) { // infinite loop + console.log(count + 'A'); // until 5 + if (count === 5) { + return; + } + console.log(count + 'B'); // until 4 + } + console.log(count + 'C'); // never appears +} + +counter(); + +// Output: +// 1A +// 1B +// 2A +// 2B +// 3A +// 3B +// 4A +// 4B +// 5A +</pre> + +<h3 id="החזרת_פונקציה">החזרת פונקציה</h3> + +<p>ראו את המאמר הבא בנושא <a href="/en-US/docs/Web/JavaScript/Closures">Closures</a>.</p> + +<pre class="brush: js">function magic() { + return function calc(x) { return x * 42; }; +} + +var answer = magic(); +answer(1337); // 56154 +</pre> + +<h2 id="מפרט">מפרט</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.9', 'Return statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-return-statement', 'Return statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-return-statement', 'Return statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="תאימות_דפדפן">תאימות דפדפן</h2> + + + +<p>{{Compat("javascript.statements.return")}}</p> + +<h2 id="ראו_גם">ראו גם</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope" title="En/Core_JavaScript_1.5_Reference/Functions">Functions</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Closures">Closures</a></li> +</ul> diff --git a/files/he/web/javascript/reference/statements/var/index.html b/files/he/web/javascript/reference/statements/var/index.html new file mode 100644 index 0000000000..64020dee3e --- /dev/null +++ b/files/he/web/javascript/reference/statements/var/index.html @@ -0,0 +1,171 @@ +--- +title: var +slug: Web/JavaScript/Reference/Statements/var +tags: + - hoisted + - הכרזה + - משתנה +translation_of: Web/JavaScript/Reference/Statements/var +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>מילת ההצהרה <strong><code>var</code></strong> משמשת להכזרה על משתנה.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-var.html")}}</div> + + + +<h2 id="תחביר">תחביר</h2> + +<pre class="syntaxbox">var <em>varname1 [</em>= <em>value1] [</em>, <em>varname2 [</em>= <em>value2] </em><em>... [</em>, <em>varnameN [</em>= <em>valueN]]]</em>;</pre> + +<dl> + <dt><code>varnameN</code></dt> + <dd>שם המשתנה.</dd> +</dl> + +<dl> + <dt><code>valueN</code></dt> + <dd> הערך של המשתנה.</dd> +</dl> + +<h2 id="תיאור">תיאור</h2> + +<p>בשפת ג'אווה סקריפט אנו משתמשים במשתנים על מנת להחזיק ערכים שונים.<br> + הקצאת ערך למשתנה ללא הצהרה מראש הופכת אותו למשתנה כגלובלי.<br> + ניתן להשתמש במשתנה לפני שהוכרז, השימוש יעשה באמצעות Hoisting.</p> + +<p><strong>מהם ההבדלים בין משתנים מוצהרים לאלה שאינם?</strong><br> + 1. ראשית, משתנים מוצהרים יעשו רק את הפעולה שלשמה נוצרו, לעומת משתנים לא מוצהרים הנחשבים גלובלים.</p> + +<pre class="brush: js">function x() { + y = 1; // Throws a ReferenceError in strict mode + var z = 2; +} + +x(); + +console.log(y); // logs "1" +console.log(z); // Throws a ReferenceError: z is not defined outside x +</pre> + +<p>2. משתנים מוצהרים מוכרזים לפני ביצוע קוד כלשהו לעומת זאת משתנים לא מוצהרים אינם קיימים עד שהקוד שמכריז עליהם מתבצע.</p> + +<pre class="brush: js">console.log(a); // Throws a ReferenceError. +console.log('still going...'); // Never executes.</pre> + +<pre class="brush: js">var a; +console.log(a); // logs "undefined" or "" depending on browser. +console.log('still going...'); // logs "still going...".</pre> + +<p>בשל שני ההבדלים הללו, אי הכרזה על משתנים עשויה להוביל לשגיאות בלתי צפויות.<br> + לכן, מומלץ תמיד להכריז על משתנים, גם אם הם נמצאים בפונקציה.</p> + +<h3 id="var_hoisting">var hoisting</h3> + +<p>זוהי התנהגות ברירת המחדל של השפה, שתפקידה להעביר את כל ההצהרות לחלק העליון של הסקריפט או הפונקציה ולכן משמעות הדבר היא שניתן להשתמש במשתנה לפני שהוכרז.</p> + +<pre class="brush: js">bla = 2; +var bla; +// ... + +// is implicitly understood as: + +var bla; +bla = 2; +</pre> + +<p>מומלץ להצהיר על משתנים בחלקו העליון של הסקריפט או הפונקציה וכך יהיה ברור אילו משתנים שייכים לפונקציה באופן מקומי ואילו גלובלים.</p> + +<p>חשוב לזכור ששימוש ב-Hoisting ישפיע על הצהרת המשתנה אך לא על אתחול הערך:</p> + +<pre class="brush: js">function do_something() { + console.log(bar); // undefined + var bar = 111; + console.log(bar); // 111 +} + +// is implicitly understood as: +function do_something() { + var bar; + console.log(bar); // undefined + bar = 111; + console.log(bar); // 111 +} +</pre> + +<h2 id="דוגמאות">דוגמאות</h2> + +<h3 id="הכרזה_אחת_של_שני_משתנים">הכרזה אחת של שני משתנים</h3> + +<pre class="brush: js" dir="rtl">var a = 0, b = 0; +</pre> + +<h3 id="הקצאת_שני_משתנים_עם_ערך_מחרוזת_יחיד">הקצאת שני משתנים עם ערך מחרוזת יחיד</h3> + +<pre class="brush: js">var a = 'A'; +var b = a; + +// Equivalent to: + +var a, b = a = 'A'; +</pre> + +<h3 id="משתנה_מקומי_וגלובלי">משתנה מקומי וגלובלי</h3> + +<pre class="brush: js">var x = 0; + +function f() { + var x = y = 1; // x is declared locally. y is not! +} +f(); + +console.log(x, y); // Throws a ReferenceError in strict mode (y is not defined). 0, 1 otherwise. +// In non-strict mode: +// x is the global one as expected +// y leaked outside of the function, though!</pre> + +<h2 id="מפרט">מפרט</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.2', 'var statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-variable-statement', 'variable statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-variable-statement', 'variable statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="תאימות_דפדפן">תאימות דפדפן</h2> + + + +<p>{{Compat("javascript.statements.var")}}</p> + +<h2 id="ראה_גם">ראה גם</h2> + +<ul> + <li><a href="https://developer.mozilla.org/he/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a></li> + <li><a href="https://developer.mozilla.org/he/docs/Web/JavaScript/Reference/Statements/const"><code>const</code></a></li> +</ul> |