diff options
Diffstat (limited to 'files/hu/web/javascript/reference/global_objects')
9 files changed, 0 insertions, 1929 deletions
diff --git a/files/hu/web/javascript/reference/global_objects/array/index.html b/files/hu/web/javascript/reference/global_objects/array/index.html deleted file mode 100644 index 2feb1828f9..0000000000 --- a/files/hu/web/javascript/reference/global_objects/array/index.html +++ /dev/null @@ -1,538 +0,0 @@ ---- -title: Array -slug: Web/JavaScript/Reference/Global_Objects/Array -tags: - - Array - - Example - - Global Objects - - JavaScript - - NeedsTranslation - - Reference - - TopicStub -translation_of: Web/JavaScript/Reference/Global_Objects/Array ---- -<div>{{JSRef}}</div> - -<p>Tömbök, amelyek magas-szintű lista jellegű objektumok, létrehozásához használatos a JavaScript <strong><code>Array</code></strong> objektum.</p> - -<h2 id="Leírás">Leírás</h2> - -<p>A tömbök listaszerű objektumok amelyek prototípusa olyan metódusokat tartalmaz amelyekkel bejárhatóak és mutálhatóak. A JavaScipt tömbnek sem a hossza, sem az elemeinek típusa sem fix. A tömbön belül az adatok nem folytonos módon tárolhatóak, így mivel a tömb hossza bármikor megváltozhat a Javascript tömbök sürűsége nem garantált, ez a programozó által választott felhasználási módtól függ. Általánosságban ezek kényelmes tulajdonságok de ha ezek a jellemzők nem kívánatosak az ön számára érdemes lehet inkább típusos tömböket használni. A tömbök nem használhatnak stringeket elem indexként (mint egy <a href="https://en.wikipedia.org/wiki/Associative_array">asszociatív tömbben</a>) csak kötelezően integereket. Ha a <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Objects_and_properties">zárójel jelölés</a> (vagy <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">pont jelölés</a>) segítségével nem-integert állítunk be vagy férünk hozzá akkor nem a tömb elemét fogjuk megkapni hanem a tömb <a href="/en-US/docs/Web/JavaScript/Data_structures#Properties">objektum tulajdonság kollekciójának</a> változóját. A tömb elemeinek listája és a tömb objektum tulajdonságai különböznek és a <a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Array_methods">tömb bejáró és mutáló operátorait</a> nem használhatjuk ezekhez az elnevezett tulajdonságokhoz.</p> - -<h3 id="Gyakori_műveletek">Gyakori műveletek</h3> - -<p><strong>Array létrehozása</strong></p> - -<pre class="brush: js">var fruits = ["Apple", "Banana"]; - -console.log(fruits.length); -// 2 -</pre> - -<p><strong>Egy Array elem elérése (indexelése)</strong></p> - -<pre class="brush: js">var first = fruits[0]; -// Apple - -var last = fruits[fruits.length - 1]; -// Banana -</pre> - -<p><strong>Array bejárása</strong></p> - -<pre class="brush: js">fruits.forEach(function (item, index, array) { - console.log(item, index); -}); -// Apple 0 -// Banana 1 -</pre> - -<p><strong>Hozzáadás egy Array végéhez</strong></p> - -<pre class="brush: js">var newLength = fruits.push("Orange"); -// ["Apple", "Banana", "Orange"] -</pre> - -<p><strong>Array végéről elem eltávolítása</strong></p> - -<pre class="brush: js">var last = fruits.pop(); // Orange eltávolítása (a végéről) -// ["Apple", "Banana"]; -</pre> - -<p><strong>Array elejéről elem eltávolítása</strong></p> - -<pre class="brush: js">var first = fruits.shift(); // eltávolítja az Apple elemet az elejéről -// ["Banana"]; -</pre> - -<p><strong>Array elejéhez hozzáadás</strong></p> - -<pre class="brush: js">var newLength = fruits.unshift("Strawberry") // hozzáadás az elejéhez -// ["Strawberry", "Banana"]; -</pre> - -<p><strong>Array elem indexének megkeresése </strong></p> - -<pre class="brush: js">fruits.push("Mango"); -// ["Strawberry", "Banana", "Mango"] - -var pos = fruits.indexOf("Banana"); -// 1 -</pre> - -<p><strong>Index pozició alapján elem eltávolítása</strong></p> - -<pre class="brush: js">var removedItem = fruits.splice(pos, 1); // így távolítunk el egy elemet - -// ["Strawberry", "Mango"]</pre> - -<p><strong>Index pozició alapján elemek eltávolítása</strong></p> - -<pre><code>let vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'] -console.log(vegetables) -// ["Cabbage", "Turnip", "Radish", "Carrot"] - -let pos = 1 -let n = 2 - -let removedItems = vegetables.splice(pos, n) -// this is how to remove items, n defines the number of items to be removed, -// from that position(pos) onward to the end of array. - -console.log(vegetables) -// ["Cabbage", "Carrot"] (the original array is changed) - -console.log(removedItems) -// ["Turnip", "Radish"]</code></pre> - -<p><strong>Array másolása</strong></p> - -<pre class="brush: js">var shallowCopy = fruits.slice(); // this is how to make a copy -// ["Strawberry"] -</pre> - -<h2 id="Syntax">Syntax</h2> - -<pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>] -new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]]) -new Array(<var>arrayLength</var>)</code></pre> - -<h3 id="Parameters">Parameters</h3> - -<dl> - <dt><code>element<em>N</em></code></dt> - <dd>A JavaScript array is initialized with the given elements, except in the case where a single argument is passed to the <code>Array</code> constructor and that argument is a number (see the arrayLength parameter below). Note that this special case only applies to JavaScript arrays created with the <code>Array</code> constructor, not array literals created with the bracket syntax.</dd> - <dt><code>arrayLength</code></dt> - <dd>If the only argument passed to the <code>Array</code> constructor is an integer between 0 and 2<sup>32</sup>-1 (inclusive), this returns a new JavaScript array with length set to that number. If the argument is any other number, a {{jsxref("RangeError")}} exception is thrown.</dd> -</dl> - -<h2 id="Description">Description</h2> - -<p>Arrays are list-like objects whose prototype has methods to perform traversal and mutation operations. Neither the length of a JavaScript array nor the types of its elements are fixed. Since an array's length can change at any time, and data can be stored at non-contiguous locations in the array, JavaScript arrays are not guaranteed to be dense; this depends on how the programmer chooses to use them. In general, these are convenient characteristics; but if these features are not desirable for your particular use, you might consider using typed arrays.</p> - -<p>Some people think that <a class="external" href="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/">you shouldn't use an array as an associative array</a>. In any case, you can use plain {{jsxref("Global_Objects/Object", "objects")}} instead, although doing so comes with its own caveats. See the post <a class="external" href="http://www.less-broken.com/blog/2010/12/lightweight-javascript-dictionaries.html">Lightweight JavaScript dictionaries with arbitrary keys</a> as an example.</p> - -<h3 id="Accessing_array_elements">Accessing array elements</h3> - -<p>JavaScript arrays are zero-indexed: the first element of an array is at index <code>0</code>, and the last element is at the index equal to the value of the array's {{jsxref("Array.length", "length")}} property minus 1.</p> - -<pre class="brush: js">var arr = ['this is the first element', 'this is the second element']; -console.log(arr[0]); // logs 'this is the first element' -console.log(arr[1]); // logs 'this is the second element' -console.log(arr[arr.length - 1]); // logs 'this is the second element' -</pre> - -<p>Array elements are object properties in the same way that <code>toString</code> is a property, but trying to access an element of an array as follows throws a syntax error, because the property name is not valid:</p> - -<pre class="brush: js">console.log(arr.0); // a syntax error -</pre> - -<p>There is nothing special about JavaScript arrays and the properties that cause this. JavaScript properties that begin with a digit cannot be referenced with dot notation; and must be accessed using bracket notation. For example, if you had an object with a property named <code>'3d'</code>, it can only be referenced using bracket notation. E.g.:</p> - -<pre class="brush: js">var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010]; -console.log(years.0); // a syntax error -console.log(years[0]); // works properly -</pre> - -<pre class="brush: js">renderer.3d.setTexture(model, 'character.png'); // a syntax error -renderer['3d'].setTexture(model, 'character.png'); // works properly -</pre> - -<p>Note that in the <code>3d</code> example, <code>'3d'</code> had to be quoted. It's possible to quote the JavaScript array indexes as well (e.g., <code>years['2']</code> instead of <code>years[2]</code>), although it's not necessary. The 2 in <code>years[2]</code> is coerced into a string by the JavaScript engine through an implicit <code>toString</code> conversion. It is for this reason that <code>'2'</code> and <code>'02'</code> would refer to two different slots on the <code>years</code> object and the following example could be <code>true</code>:</p> - -<pre class="brush: js">console.log(years['2'] != years['02']); -</pre> - -<p>Similarly, object properties which happen to be reserved words(!) can only be accessed as string literals in bracket notation(but it can be accessed by dot notation in firefox 40.0a2 at least):</p> - -<pre class="brush: js">var promise = { - 'var' : 'text', - 'array': [1, 2, 3, 4] -}; - -console.log(promise['array']); -</pre> - -<h3 id="Relationship_between_length_and_numerical_properties">Relationship between <code>length</code> and numerical properties</h3> - -<p>A JavaScript array's {{jsxref("Array.length", "length")}} property and numerical properties are connected. Several of the built-in array methods (e.g., {{jsxref("Array.join", "join")}}, {{jsxref("Array.slice", "slice")}}, {{jsxref("Array.indexOf", "indexOf")}}, etc.) take into account the value of an array's {{jsxref("Array.length", "length")}} property when they're called. Other methods (e.g., {{jsxref("Array.push", "push")}}, {{jsxref("Array.splice", "splice")}}, etc.) also result in updates to an array's {{jsxref("Array.length", "length")}} property.</p> - -<pre class="brush: js">var fruits = []; -fruits.push('banana', 'apple', 'peach'); - -console.log(fruits.length); // 3 -</pre> - -<p>When setting a property on a JavaScript array when the property is a valid array index and that index is outside the current bounds of the array, the engine will update the array's {{jsxref("Array.length", "length")}} property accordingly:</p> - -<pre class="brush: js">fruits[5] = 'mango'; -console.log(fruits[5]); // 'mango' -console.log(Object.keys(fruits)); // ['0', '1', '2', '5'] -console.log(fruits.length); // 6 -</pre> - -<p>Increasing the {{jsxref("Array.length", "length")}}.</p> - -<pre class="brush: js">fruits.length = 10; -console.log(Object.keys(fruits)); // ['0', '1', '2', '5'] -console.log(fruits.length); // 10 -</pre> - -<p>Decreasing the {{jsxref("Array.length", "length")}} property does, however, delete elements.</p> - -<pre class="brush: js">fruits.length = 2; -console.log(Object.keys(fruits)); // ['0', '1'] -console.log(fruits.length); // 2 -</pre> - -<p>This is explained further on the {{jsxref("Array.length")}} page.</p> - -<h3 id="Creating_an_array_using_the_result_of_a_match">Creating an array using the result of a match</h3> - -<p>The result of a match between a regular expression and a string can create a JavaScript array. This array has properties and elements which provide information about the match. Such an array is returned by {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, and {{jsxref("String.replace")}}. To help explain these properties and elements, look at the following example and then refer to the table below:</p> - -<pre class="brush: js">// Match one d followed by one or more b's followed by one d -// Remember matched b's and the following d -// Ignore case - -var myRe = /d(b+)(d)/i; -var myArray = myRe.exec('cdbBdbsbz'); -</pre> - -<p>The properties and elements returned from this match are as follows:</p> - -<table class="fullwidth-table"> - <tbody> - <tr> - <td class="header">Property/Element</td> - <td class="header">Description</td> - <td class="header">Example</td> - </tr> - <tr> - <td><code>input</code></td> - <td>A read-only property that reflects the original string against which the regular expression was matched.</td> - <td>cdbBdbsbz</td> - </tr> - <tr> - <td><code>index</code></td> - <td>A read-only property that is the zero-based index of the match in the string.</td> - <td>1</td> - </tr> - <tr> - <td><code>[0]</code></td> - <td>A read-only element that specifies the last matched characters.</td> - <td>dbBd</td> - </tr> - <tr> - <td><code>[1], ...[n]</code></td> - <td>Read-only elements that specify the parenthesized substring matches, if included in the regular expression. The number of possible parenthesized substrings is unlimited.</td> - <td>[1]: bB<br> - [2]: d</td> - </tr> - </tbody> -</table> - -<h2 id="Properties">Properties</h2> - -<dl> - <dt><code>Array.length</code></dt> - <dd>The <code>Array</code> constructor's length property whose value is 1.</dd> - <dt>{{jsxref("Array.@@species", "get Array[@@species]")}}</dt> - <dd>The constructor function that is used to create derived objects.</dd> - <dt>{{jsxref("Array.prototype")}}</dt> - <dd>Allows the addition of properties to all array objects.</dd> -</dl> - -<h2 id="Methods">Methods</h2> - -<dl> - <dt>{{jsxref("Array.from()")}}</dt> - <dd>Creates a new <code>Array</code> instance from an array-like or iterable object.</dd> - <dt>{{jsxref("Array.isArray()")}}</dt> - <dd>Returns true if a variable is an array, if not false.</dd> - <dt>{{jsxref("Array.of()")}}</dt> - <dd>Creates a new <code>Array</code> instance with a variable number of arguments, regardless of number or type of the arguments.</dd> -</dl> - -<h2 id="Array_instances"><code>Array</code> instances</h2> - -<p>All <code>Array</code> instances inherit from {{jsxref("Array.prototype")}}. The prototype object of the <code>Array</code> constructor can be modified to affect all <code>Array</code> instances.</p> - -<h3 id="Properties_2">Properties</h3> - -<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties')}}</div> - -<h3 id="Methods_2">Methods</h3> - -<h4 id="Mutator_methods">Mutator methods</h4> - -<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods')}}</div> - -<h4 id="Accessor_methods">Accessor methods</h4> - -<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods')}}</div> - -<h4 id="Iteration_methods">Iteration methods</h4> - -<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods')}}</div> - -<h2 id="Array_generic_methods"><code>Array</code> generic methods</h2> - -<div class="warning"> -<p><strong>Array generics are non-standard, deprecated and will get removed in the near future</strong>. Note that you can not rely on them cross-browser. However, there is a <a href="https://github.com/plusdude/array-generics">shim available on GitHub</a>.</p> -</div> - -<p>Sometimes you would like to apply array methods to strings or other array-like objects (such as function {{jsxref("Functions/arguments", "arguments", "", 1)}}). By doing this, you treat a string as an array of characters (or otherwise treat a non-array as an array). For example, in order to check that every character in the variable <var>str</var> is a letter, you would write:</p> - -<pre class="brush: js">function isLetter(character) { - return character >= 'a' && character <= 'z'; -} - -if (Array.prototype.every.call(str, isLetter)) { - console.log("The string '" + str + "' contains only letters!"); -} -</pre> - -<p>This notation is rather wasteful and JavaScript 1.6 introduced a generic shorthand:</p> - -<pre class="brush: js">if (Array.every(str, isLetter)) { - console.log("The string '" + str + "' contains only letters!"); -} -</pre> - -<p>{{jsxref("Global_Objects/String", "Generics", "#String_generic_methods", 1)}} are also available on {{jsxref("String")}}.</p> - -<p>These are <strong>not</strong> part of ECMAScript standards (though the ES2015 {{jsxref("Array.from()")}} can be used to achieve this). The following is a shim to allow its use in all browsers:</p> - -<pre class="brush: js">// Assumes Array extras already present (one may use polyfills for these as well) -(function() { - 'use strict'; - - var i, - // We could also build the array of methods with the following, but the - // getOwnPropertyNames() method is non-shimable: - // Object.getOwnPropertyNames(Array).filter(function(methodName) { - // return typeof Array[methodName] === 'function' - // }); - methods = [ - 'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift', - 'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf', - 'forEach', 'map', 'reduce', 'reduceRight', 'filter', - 'some', 'every', 'find', 'findIndex', 'entries', 'keys', - 'values', 'copyWithin', 'includes' - ], - methodCount = methods.length, - assignArrayGeneric = function(methodName) { - if (!Array[methodName]) { - var method = Array.prototype[methodName]; - if (typeof method === 'function') { - Array[methodName] = function() { - return method.call.apply(method, arguments); - }; - } - } - }; - - for (i = 0; i < methodCount; i++) { - assignArrayGeneric(methods[i]); - } -}()); -</pre> - -<h2 id="Examples">Examples</h2> - -<h3 id="Creating_an_array">Creating an array</h3> - -<p>The following example creates an array, <code>msgArray</code>, with a length of 0, then assigns values to <code>msgArray[0]</code> and <code>msgArray[99]</code>, changing the length of the array to 100.</p> - -<pre class="brush: js">var msgArray = []; -msgArray[0] = 'Hello'; -msgArray[99] = 'world'; - -if (msgArray.length === 100) { - console.log('The length is 100.'); -} -</pre> - -<h3 id="Creating_a_two-dimensional_array">Creating a two-dimensional array</h3> - -<p>The following creates a chess board as a two dimensional array of strings. The first move is made by copying the 'p' in (6,4) to (4,4). The old position (6,4) is made blank.</p> - -<pre class="brush: js">var board = [ - ['R','N','B','Q','K','B','N','R'], - ['P','P','P','P','P','P','P','P'], - [' ',' ',' ',' ',' ',' ',' ',' '], - [' ',' ',' ',' ',' ',' ',' ',' '], - [' ',' ',' ',' ',' ',' ',' ',' '], - [' ',' ',' ',' ',' ',' ',' ',' '], - ['p','p','p','p','p','p','p','p'], - ['r','n','b','q','k','b','n','r'] ]; - -console.log(board.join('\n') + '\n\n'); - -// Move King's Pawn forward 2 -board[4][4] = board[6][4]; -board[6][4] = ' '; -console.log(board.join('\n')); -</pre> - -<p>Here is the output:</p> - -<pre class="eval">R,N,B,Q,K,B,N,R -P,P,P,P,P,P,P,P - , , , , , , , - , , , , , , , - , , , , , , , - , , , , , , , -p,p,p,p,p,p,p,p -r,n,b,q,k,b,n,r - -R,N,B,Q,K,B,N,R -P,P,P,P,P,P,P,P - , , , , , , , - , , , , , , , - , , , ,p, , , - , , , , , , , -p,p,p,p, ,p,p,p -r,n,b,q,k,b,n,r -</pre> - -<h3 id="Using_an_array_to_tabulate_a_set_of_values">Using an array to tabulate a set of values</h3> - -<pre class="brush: js">values=[]; -for (x=0; x<10; x++){ - values.push([ - 2**x, - 2*x**2 - ]) -}; -console.table(values)</pre> - -<p>Results in</p> - -<pre class="eval">0 1 0 -1 2 2 -2 4 8 -3 8 18 -4 16 32 -5 32 50 -6 64 72 -7 128 98 -8 256 128 -9 512 162</pre> - -<p>(First column is the (index))</p> - -<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('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Initial definition.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td>New methods added: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-array-objects', 'Array')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>New methods added: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-array-objects', 'Array')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>New method added: {{jsxref("Array.prototype.includes()")}}</td> - </tr> - </tbody> -</table> - -<h2 id="Browser_compatibility">Browser compatibility</h2> - -<div>{{CompatibilityTable}}</div> - -<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>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</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>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - </tr> - </tbody> -</table> -</div> - -<h2 id="See_also">See also</h2> - -<ul> - <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Indexing_object_properties">JavaScript Guide: “Indexing object properties”</a></li> - <li><a href="/en-US/docs/Web/JavaScript/Guide/Predefined_Core_Objects#Array_Object">JavaScript Guide: “Predefined Core Objects: <code>Array</code> Object”</a></li> - <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Array_comprehensions">Array comprehensions</a></li> - <li><a href="https://github.com/plusdude/array-generics">Polyfill for JavaScript 1.8.5 Array Generics and ECMAScript 5 Array Extras</a></li> - <li><a href="/en-US/docs/JavaScript_typed_arrays">Typed Arrays</a></li> -</ul> diff --git a/files/hu/web/javascript/reference/global_objects/array/keys/index.html b/files/hu/web/javascript/reference/global_objects/array/keys/index.html deleted file mode 100644 index 2f7c0cebef..0000000000 --- a/files/hu/web/javascript/reference/global_objects/array/keys/index.html +++ /dev/null @@ -1,77 +0,0 @@ ---- -title: Array.prototype.keys() -slug: Web/JavaScript/Reference/Global_Objects/Array/keys -tags: - - ECMAScript 2015 - - Iterator - - JavaScript - - Prototype - - kulcs - - metódus - - tömb -translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys ---- -<div>{{JSRef}}</div> - -<p>A <code><strong>keys()</strong></code> metódus egy új <code><strong>Array Iterator</strong></code> objektummal tér vissza, amely a tömb indexeihez tartozó kulcsokat tartalmazza.</p> - -<div>{{EmbedInteractiveExample("pages/js/array-keys.html")}}</div> - -<p class="hidden">Az ehhez az interaktív példához tartozó forrás egy GitHub repozitoriban található. Ha szeretnél közreműködni az interaktív példa projektben, kérjük, klónozd a <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> repozitorit és küldj egy pull request-et.</p> - -<h2 id="Szintaxis">Szintaxis</h2> - -<pre class="syntaxbox"><var>arr</var>.keys()</pre> - -<h3 id="Visszatérési_érték">Visszatérési érték</h3> - -<p>Egy új {{jsxref("Array")}} iterátor objektum.</p> - -<h2 id="Példák">Példák</h2> - -<h3 id="A_kulcs_iterátor_nem_hagyja_figyelmen_kívül_az_üres_helyeket">A kulcs iterátor nem hagyja figyelmen kívül az üres helyeket</h3> - -<pre class="brush: js">var arr = ['a', , 'c']; -var sparseKeys = Object.keys(arr); -var denseKeys = [...arr.keys()]; -console.log(sparseKeys); // ['0', '2'] -console.log(denseKeys); // [0, 1, 2] -</pre> - -<h2 id="Specifikációk">Specifikációk</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Specifikáció</th> - <th scope="col">Státusz</th> - <th scope="col">Megjegyzés</th> - </tr> - <tr> - <td>{{SpecName('ES2015', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td>Kezdeti definíció.</td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - </tbody> -</table> - -<h2 id="Böngésző_kompatibilitás">Böngésző kompatibilitás</h2> - -<div> -<div class="hidden">Az itt található kompatibilitási táblázat struktúrált adatok alapján lett létrehozva. Ha szeretnél hozzájárulni az adatokhoz, akkor töltsd le a <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> repozitorit, és küldj egy pull request-et.</div> - -<p>{{Compat("javascript.builtins.Array.keys")}}</p> -</div> - -<h2 id="Lásd_még">Lásd még</h2> - -<ul> - <li>{{jsxref("Array.prototype.values()")}}</li> - <li>{{jsxref("Array.prototype.entries()")}}</li> - <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iterációs protokollok</a></li> -</ul> diff --git a/files/hu/web/javascript/reference/global_objects/array/of/index.html b/files/hu/web/javascript/reference/global_objects/array/of/index.html deleted file mode 100644 index ff3af4288a..0000000000 --- a/files/hu/web/javascript/reference/global_objects/array/of/index.html +++ /dev/null @@ -1,94 +0,0 @@ ---- -title: Array.of() -slug: Web/JavaScript/Reference/Global_Objects/Array/of -tags: - - tömb -translation_of: Web/JavaScript/Reference/Global_Objects/Array/of ---- -<div>{{JSRef}}</div> - -<p>Az <code><strong>Array.of()</strong></code> metódus egy új <code>Array</code> példányt hoz létre változó számú argumentumokból, azok számától és típusától függetlenül.</p> - -<p>Az <code><strong>Array.of()</strong></code> és az <code><strong>Array</strong></code> konstruktor működése között az a különbség, hogy máshogy hasznája az argumentumként megadott egész számokat: az <code><strong>Array.of(7)</strong></code> létrehoz egy új tömböt, melynek az egyetlen eleme a <code>7</code>, ezzel szemben az <code><strong>Array(7)</strong></code> egy olyan üres tömböt hoz létre, melynek a <code>length</code> property-je: 7 (<strong>Megjegyzés:</strong> ez valójában egy <code>7</code> üres elemű (empty) tömböt jelent, nem olyat, melynek az elemei ténylegesen <code>undefined</code> értékeket tartalmaznának).</p> - -<pre class="brush: js">Array.of(7); // [7] -Array.of(1, 2, 3); // [1, 2, 3] - -Array(7); // 7 üres elemű tömb: [empty × 7] -Array(1, 2, 3); // [1, 2, 3] -</pre> - -<h2 id="Szintakszis">Szintakszis</h2> - -<pre class="syntaxbox">Array.of(<var>elem0</var>[, <var>elem1</var>[, ...[, <var>elemN</var>]]])</pre> - -<h3 id="Paraméterek">Paraméterek</h3> - -<dl> - <dt><code>elem<em>N</em></code></dt> - <dd>Elemek, melyeket a tömb tartalmazni fog</dd> -</dl> - -<h3 id="Visszatérési_érték">Visszatérési érték</h3> - -<p>Egy új {{jsxref("Array")}} példány.</p> - -<h2 id="Leírás">Leírás</h2> - -<p>Ez a függvény szabványos az ECMAScript 2015 óta. További részletekért lásd az <a href="https://gist.github.com/rwaldron/1074126"><code>Array.of</code> és az <code>Array.from</code> proposal</a>-t és a <a href="https://gist.github.com/rwaldron/3186576"><code>Array.of</code> polyfill</a>-t.</p> - -<h2 id="Példák">Példák</h2> - -<pre class="brush: js">Array.of(1); // [1] -Array.of(1, 2, 3); // [1, 2, 3] -Array.of(undefined); // [undefined] -</pre> - -<h2 id="Polyfill">Polyfill</h2> - -<p>A következő kód lefuttatása után az <code>Array.of()</code> hasznáható lesz, amennyiben a kliens ezt natíven nem támogatja.</p> - -<pre class="brush: js">if (!Array.of) { - Array.of = function() { - return Array.prototype.slice.call(arguments); - }; -} -</pre> - -<h2 id="Specifikációk">Specifikációk</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('ES2015', '#sec-array.of', 'Array.of')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td>Kezdeti definíció.</td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td></td> - </tr> - </tbody> -</table> - -<h2 id="Böngésző_kompatibilitás">Böngésző kompatibilitás</h2> - -<div> -<div class="hidden">A kompatibilitási táblázat ezen az oldalon struktúrált adatokból generált. Amennyiben hozzá kívánsz járulni ezen adatok frissítéséhez, kérlek látogasd meg a <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> repository-t és küldj nekünk egy pull requestet.</div> - -<p>{{Compat("javascript.builtins.Array.of")}}</p> -</div> - -<h2 id="Lásd_még">Lásd még:</h2> - -<ul> - <li>{{jsxref("Array")}}</li> - <li>{{jsxref("Array.from()")}}</li> - <li>{{jsxref("TypedArray.of()")}}</li> -</ul> diff --git a/files/hu/web/javascript/reference/global_objects/array/sort/index.html b/files/hu/web/javascript/reference/global_objects/array/sort/index.html deleted file mode 100644 index 408507ddd8..0000000000 --- a/files/hu/web/javascript/reference/global_objects/array/sort/index.html +++ /dev/null @@ -1,294 +0,0 @@ ---- -title: Array.prototype.sort() -slug: Web/JavaScript/Reference/Global_Objects/Array/sort -tags: - - Prototípus - - Rendezés - - metódus - - tömb -translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort ---- -<div>{{JSRef}}</div> - -<p>A <code><strong>sort()</strong></code> eljárás egy tömb elemeit rendezi <em>helyben, és visszaadja a tömböt.</em> Egy rendezés nem teljesen <a href="https://en.wikipedia.org/wiki/Sorting_algorithm#Stability">stabil</a>. Az alapértelmezett rendezési sorrend függ a sztring Unicode táblában való elhelyezkedésétől.</p> - -<pre class="brush: js">var fruits = ['cherries', 'apples', 'banana']; -fruits.sort(); // ['apple', 'banana', 'cherries'] - -var scores = [1, 10, 21, 2]; -scores.sort(); // [1, 10, 2, 21] -// Figyeld meg,hogy a 10 a 2 előtt jön, -// mivel a '10' hamarabb van,mint '2' a Unicode sorolás szerint. - -var things = ['word', 'Word', '1 Word', '2 Words']; -things.sort(); // ['1 Word', '2 Words', 'Word', 'word'] -// A Unicode-ban, a számok hamarabb kerülnek sorra mint a nagybetűk, -// de, azok hamarabb vannak,mint a kisbetűk. -</pre> - -<h2 id="Szintaxis">Szintaxis</h2> - -<pre class="syntaxbox"><em>arr</em>.sort() <em>arr</em>.sort(<var>compareFunction</var>) -</pre> - -<h3 id="Paraméterek">Paraméterek</h3> - -<dl> - <dt><code>compareFunction</code> {{optional_inline}}</dt> - <dd>Meghatároz egy függvényt, amely definiálja a rendezési sorrendet. Ha elhagyjuk, a tömb rendezése az egyes betűk <a href="https://developer.mozilla.org/hu/docs/Web/JavaScript/Guide/Grammar_and_types">Unicode</a> táblában való elhelyezkedése alapján történik meg.</dd> -</dl> - -<h3 id="Visszatérési_érték">Visszatérési érték</h3> - -<p>A rendezett tömb. Vegyük figyelembe, hogy a rendezés helyben történt és nem készült másolat a tömbről.</p> - -<h2 id="Leírás">Leírás</h2> - -<p><code>Ha a compareFunction</code> nem mellékelt, akkor az elemek rendezése úgy zajlik, hogy először átkonvertálja sztringgé, majd összehasonlítja a Unicode karakter sorrendet. Például, "Banana" hamarabb lesz,mint "cherry". Szám-sorrendben a 9 hamarabb lesz 80-nál, de mivel a számok átkonvertálódnak sztringgé, "80" hamarabb lesz "9"-nél a Unicode sorolás szerint.</p> - -<p>Ha <code>compareFunction</code> mellékelt, a tömb elemei rendezésre kerülnek az összehasonlító függvény visszatérési értéke alapján. Ha a és b elemek összehasonlításra kerülnek:</p> - -<ul> - <li>Ha <code>compareFunction(a, b)</code> kisebb mint 0, akkor a kisebb indexet kap,mint <code>b</code>, szóval a előre kerül.</li> - <li>Ha <code>compareFunction(a, b)</code> 0-t ad vissza, akkor a-t és b-t hagyjuk változatlanul,de a többi elemet rendezzük. Megjegyzés: az ECMAscript szabvány nem garantálja ezt a viselkedést,és hogy nem minden böngésző (például: Mozilla verziók,melyek 2003 körüliek) támogatja.</li> - <li>Ha <code>compareFunction(a, b)</code> nagyobb mint 0, rendezze b-t kisebb indexre mint a.</li> - <li><code>compareFunction(a, b)</code> mindig ugyanazt az értéket kellene visszaadja, amikor a jellemző a-b párost kapja meg paraméterként. Ha következetlen értéket ad vissza, akkor a rendezési sorrend "undefined".</li> -</ul> - -<p>Szóval, az összehasonlító függvény így néz ki:</p> - -<pre class="brush: js">function compare(a, b) { - if (a kisebb mint b a sorrend kritéria szerint) { - return -1; - } - if (a nagyobb mint b a sorrend kritéria szerint) { - return 1; - } - // a-nak egyenlőnek kell lennie b-vel - return 0; -} -</pre> - -<p>To compare numbers instead of strings, the compare function can simply subtract <code>b</code> from <code>a</code>. The following function will sort the array ascending (if it doesn't contain <code>Infinity</code> and <code>NaN</code>):</p> - -<pre class="brush: js">function compareNumbers(a, b) { - return a - b; -} -</pre> - -<p>The <code>sort</code> method can be conveniently used with {{jsxref("Operators/function", "function expressions", "", 1)}} (and <a href="/en-US/docs/Web/JavaScript/Guide/Closures">closures</a>):</p> - -<pre class="brush: js">var numbers = [4, 2, 5, 1, 3]; -numbers.sort(function(a, b) { - return a - b; -}); -console.log(numbers); - -// [1, 2, 3, 4, 5] -</pre> - -<p>Objektumok is rendezhetőek, ha megadjuk az egyik tulajdonságát.</p> - -<pre class="brush: js">var items = [ - { name: 'Edward', value: 21 }, - { name: 'Sharpe', value: 37 }, - { name: 'And', value: 45 }, - { name: 'The', value: -12 }, - { name: 'Magnetic', value: 13 }, - { name: 'Zeros', value: 37 } -]; - -// sort by value -items.sort(function (a, b) { - return a.value - b.value; -}); - -// sort by name -items.sort(function(a, b) { - var nameA = a.name.toUpperCase(); // nagybetűk és kisbetűk elhagyása - var nameB = b.name.toUpperCase(); // nagybetűk és kisbetűk elhagyása - if (nameA < nameB) { - return -1; - } - if (nameA > nameB) { - return 1; - } - - // a neveknek egyeznie kell - return 0; -});</pre> - -<h2 id="Példák">Példák</h2> - -<h3 id="Tömbök_készítésemegjelenítése_és_rendezése">Tömbök készítése,megjelenítése és rendezése</h3> - -<p>A következő példa négy tömböt készít, megjeleníti az eredeti tömböt, majd a rendezett tömböket. A numerikus tömbök először nem,azután használva a compare függvényt rendezésre kerülnek.</p> - -<pre class="brush: js">var stringArray = ['Blue', 'Humpback', 'Beluga']; -var numericStringArray = ['80', '9', '700']; -var numberArray = [40, 1, 5, 200]; -var mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200]; - -function compareNumbers(a, b) { - return a - b; -} - -console.log('stringArray:', stringArray.join()); -console.log('Sorted:', stringArray.sort()); - -console.log('numberArray:', numberArray.join()); -console.log('Sorted without a compare function:', numberArray.sort()); -console.log('Sorted with compareNumbers:', numberArray.sort(compareNumbers)); - -console.log('numericStringArray:', numericStringArray.join()); -console.log('Sorted without a compare function:', numericStringArray.sort()); -console.log('Sorted with compareNumbers:', numericStringArray.sort(compareNumbers)); - -console.log('mixedNumericArray:', mixedNumericArray.join()); -console.log('Sorted without a compare function:', mixedNumericArray.sort()); -console.log('Sorted with compareNumbers:', mixedNumericArray.sort(compareNumbers)); -</pre> - -<p>This example produces the following output. As the output shows, when a compare function is used, numbers sort correctly whether they are numbers or numeric strings.</p> - -<pre>stringArray: Blue,Humpback,Beluga -Sorted: Beluga,Blue,Humpback - -numberArray: 40,1,5,200 -Sorted without a compare function: 1,200,40,5 -Sorted with compareNumbers: 1,5,40,200 - -numericStringArray: 80,9,700 -Sorted without a compare function: 700,80,9 -Sorted with compareNumbers: 9,80,700 - -mixedNumericArray: 80,9,700,40,1,5,200 -Sorted without a compare function: 1,200,40,5,700,80,9 -Sorted with compareNumbers: 1,5,9,40,80,200,700 -</pre> - -<h3 id="Nem-ASCII_karakterek_rendezése">Nem-ASCII karakterek rendezése</h3> - -<p>For sorting strings with non-ASCII characters, i.e. strings with accented characters (e, é, è, a, ä, etc.), strings from languages other than English: use {{jsxref("String.localeCompare")}}. This function can compare those characters so they appear in the right order.</p> - -<pre class="brush: js">var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu']; -items.sort(function (a, b) { - return a.localeCompare(b); -}); - -// items is ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé'] -</pre> - -<h3 id="Rendezés_map-al">Rendezés map-al</h3> - -<p>The <code>compareFunction</code> can be invoked multiple times per element within the array. Depending on the <code>compareFunction</code>'s nature, this may yield a high overhead. The more work a <code>compareFunction</code> does and the more elements there are to sort, the wiser it may be to consider using a <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a> for sorting. The idea is to walk the array once to extract the actual values used for sorting into a temporary array, sort the temporary array and then walk the temporary array to achieve the right order.</p> - -<pre class="brush: js">// the array to be sorted -var list = ['Delta', 'alpha', 'CHARLIE', 'bravo']; - -// temporary array holds objects with position and sort-value -var mapped = list.map(function(el, i) { - return { index: i, value: el.toLowerCase() }; -}) - -// sorting the mapped array containing the reduced values -mapped.sort(function(a, b) { - return +(a.value > b.value) || +(a.value === b.value) - 1; -}); - -// container for the resulting order -var result = mapped.map(function(el){ - return list[el.index]; -}); -</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('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Initial definition.</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-15.4.4.11', 'Array.prototype.sort')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-array.prototype.sort', 'Array.prototype.sort')}}</td> - <td>{{Spec2('ES6')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-array.prototype.sort', 'Array.prototype.sort')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td></td> - </tr> - </tbody> -</table> - -<h2 id="Böngésző_kompatibilitás">Böngésző kompatibilitás</h2> - -<div>{{CompatibilityTable}}</div> - -<div id="compat-desktop"> -<table class="compat-table"> - <tbody> - <tr> - <th>Funkció</th> - <th>Chrome</th> - <th>Firefox (Gecko)</th> - <th>Internet Explorer</th> - <th>Opera</th> - <th>Safari</th> - </tr> - <tr> - <td>Alap támogatás</td> - <td>{{CompatChrome("1.0")}}</td> - <td>{{CompatGeckoDesktop("1.7")}}</td> - <td>{{CompatIE("5.5")}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - </tr> - </tbody> -</table> -</div> - -<div id="compat-mobile"> -<table class="compat-table"> - <tbody> - <tr> - <th>Funkció</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>Alap támogátás</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - </tr> - </tbody> -</table> -</div> - -<h2 id="Lásd_még">Lásd még</h2> - -<ul> - <li>{{jsxref("Array.prototype.reverse()")}}</li> - <li>{{jsxref("String.prototype.localeCompare()")}}</li> -</ul> diff --git a/files/hu/web/javascript/reference/global_objects/error/index.html b/files/hu/web/javascript/reference/global_objects/error/index.html deleted file mode 100644 index f27374e30c..0000000000 --- a/files/hu/web/javascript/reference/global_objects/error/index.html +++ /dev/null @@ -1,218 +0,0 @@ ---- -title: Error -slug: Web/JavaScript/Reference/Global_Objects/Error -translation_of: Web/JavaScript/Reference/Global_Objects/Error ---- -<div>{{JSRef}}</div> - -<p>Az <code>Error</code> objektumok futásidejű hiba során keletkeznek. Továbbá ezek az alapjai a saját készítésű hibaobjektumoknak is. Később olvashatsz a beépített hiba típusokról is.</p> - -<h2 id="Leírás">Leírás</h2> - -<p>A futásidejű hibák során <code>Error</code> objektumok keletkezhetnek, illetve érkezhetnek.</p> - -<h3 id="Hiba_típusok">Hiba típusok</h3> - -<p>A generikus <code>Error</code> konstruktor mellett, A JavaScript-ben más hiba konstruktorok is léteznek. A kliens-oldali kivételek listájához, lásd, a <a href="/en-US/docs/Web/JavaScript/Guide/Statements#Exception_handling_statements">Kivételek kezelése</a> fejezetet.</p> - -<dl> - <dt>{{JSxRef("EvalError")}}</dt> - <dd>Egy olyan hibaobjektum példányát hozza létre, ami az {{JSxRef("eval", "eval()")}} globális függvénnyel kapcsolatos.</dd> - <dt>{{JSxRef("RangeError")}}</dt> - <dd>Egy olyan hibaobjektum példányát hozza létre, ami akkor történik, ha valamelyik szám típusú változó az érvényes értékkészleten kívűlre esik.</dd> - <dt>{{JSxRef("ReferenceError")}}</dt> - <dd>Egy olyan hibaobjektum példányát hozza létre, ami akkor történik, ha érvénytelen hivatkozásra történik hivatkozás.</dd> - <dt>{{JSxRef("SyntaxError")}}</dt> - <dd>Egy olyan hibaobjektum példányát hozza létre, ami egy szintaktikai hibát jelez.</dd> - <dt>{{JSxRef("TypeError")}}</dt> - <dd>Egy olyan hibaobjektum példányát hozza létre, ami akkor keletkezik, ha a változó, vagy paraméter típusa nem megfelelő, vagy érvénytelen.</dd> - <dt>{{JSxRef("URIError")}}</dt> - <dd>Egy olyan hibaobjektum példányát hozza létre, ami akkor keletkezik, ha az {{JSxRef("encodeURI", "encodeURI()")}}, vagy a {{JSxRef("decodeURI", "decodeURI()")}} függvények érvénytelen bemeneti paramétereket kapnak.</dd> - <dt>{{JSxRef("AggregateError")}}</dt> - <dd>Egy olyan hibaobjektum példányát hozza létre, ami egyszerre több hibát foglal magába. Ilyen objektum akkor jön létre, amikor egy függvényben egyidejűleg több hiba is történik. Például.: {{JSxRef("Promise.any()")}}.</dd> - <dt>{{JSxRef("InternalError")}} {{non-standard_inline}}</dt> - <dd>Egy olyan hibaobjektum példányát hozza létre, ami akkor jön létre, amikor a JavaScript motorjában belső hiba keletkezik. Pl.: "too much recursion" ("Túl sok rekurzió").</dd> -</dl> - -<h2 id="Konstruktor">Konstruktor</h2> - -<dl> - <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Error"><code>Error()</code></a></dt> - <dd>Egy új <code>Error</code> objektumot hoz létre.</dd> -</dl> - -<h2 id="Statikus_függvények">Statikus függvények</h2> - -<dl> - <dt>{{JSxRef("Error.captureStackTrace()")}}</dt> - <dd>Egy nem-standard <strong>V8</strong> függvény, ami létrehoz egy {{JSxRef("Error.prototype.stack", "stack")}} tagváltozót az Error példányon.</dd> -</dl> - -<h2 id="Példány_tagváltozói">Példány tagváltozói</h2> - -<dl> - <dt>{{jsxref("Error.prototype.message")}}</dt> - <dd>Rövid hibaüzenet.</dd> - <dt>{{jsxref("Error.prototype.name")}}</dt> - <dd>A hiba neve.</dd> - <dt>{{jsxref("Error.prototype.description")}}</dt> - <dd>Egy nem-standard Microsoft tagváltozó a hiba leírásához. Hasonlít a {{jsxref("Error.prototype.message", "message")}}-hez.</dd> - <dt>{{jsxref("Error.prototype.number")}}</dt> - <dd>Egy nem-standard Microsoft tagváltozó a hiba számához.</dd> - <dt>{{jsxref("Error.prototype.fileName")}}</dt> - <dd>Egy nem-standard Mozilla tagváltozó, ami a hibát okozó fájl útvonalát tartalmazza.</dd> - <dt>{{jsxref("Error.prototype.lineNumber")}}</dt> - <dd>Egy nem-standard Mozilla tagváltozó, ami a hibát okozó fájl azon sorát jelöli, ahonnan a hiba származik.</dd> - <dt>{{jsxref("Error.prototype.columnNumber")}}</dt> - <dd>Egy nem-standard Mozilla tagváltozó, ami a hibát tartalmazó sor azon oszlopát (karakterét) jelöli, ahonnan a hiba származik.</dd> - <dt>{{jsxref("Error.prototype.stack")}}</dt> - <dd>Egy nem-standard Mozilla tagváltozó ami a stacktrace-t tartalmazza (A hiba nyomonkövetése a veremen).</dd> -</dl> - -<h2 id="Példány_függvények">Példány függvények</h2> - -<dl> - <dt>{{jsxref("Error.prototype.toString()")}}</dt> - <dd>Egy string-gel tér vissza, ami leírja az objektumot. Ez a függvény felüldefiniálja a {{jsxref("Object.prototype.toString()")}} fügvényt.</dd> -</dl> - -<h2 id="Példák">Példák</h2> - -<h3 id="Generikus_hiba_keletkezése">Generikus hiba keletkezése</h3> - -<p>Az <code>Error</code> objektumot általában akkor érdemes létrehozni, ha azt utána használjuk, vagy eldobjuk a {{JSxRef("Statements/throw", "throw")}} kulcsszó segítségével. Az ilyen hibákat a {{JSxRef("Statements/try...catch", "try...catch")}} szerkezettel lehet könnyedén kezelni:</p> - -<pre class="brush: js; notranslate">try { - throw new Error('Whoops!') -} catch (e) { - console.error(e.name + ': ' + e.message) -} -</pre> - -<h3 id="Különleges_hibák_kezelése">Különleges hibák kezelése</h3> - -<p>A hiba objektum {{JSxRef("Object.prototype.constructor", "constructor")}} tagváltozójával, illetve modern JavaScript motor használata esetén, a {{JSxRef("Operators/instanceof", "instanceof")}} kulcsszóval lehetséges a hiba objektum konkrét típusát is lekérdezni. Ezzel leszűkíthető a hibakezelés konkrét hibatípusokra:</p> - -<pre class="brush: js; notranslate">try { - foo.bar() -} catch (e) { - if (e instanceof EvalError) { - console.error(e.name + ': ' + e.message) - } else if (e instanceof RangeError) { - console.error(e.name + ': ' + e.message) - } - // ... etc -} -</pre> - -<h3 id="Saját_hiba_típusok">Saját hiba típusok</h3> - -<p>Elképzelhető, hogy saját hibatípust szereténk készíteni, ami az <code>Error</code> objektumból származik. Ezáltal tudjuk használni a <code>throw new MyError()</code> kifejezést a hiba jelzéséhez, és az <code>instanceof MyError</code> -t a különleges hiba kezeléséhez. Ezzel biztosítható a szebb és konzisztensebb hibakezelés. </p> - -<p>A kérdéskörről olvashatsz bővebben a <a href="http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">"What's a good way to extend Error in JavaScript?"</a> című téma alatt a StackOverflow fórumán.</p> - -<h4 id="ES6_Saját_Error_Osztály">ES6 Saját Error Osztály</h4> - -<div class="blockIndicator warning"> -<p>7-es, vagy régebbi Babel verziók képesek a <code>CustomError</code> osztályfüggvények kezelésére, de csak akkor, ha azokat at <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty()</a>-vel megfelelően deklarálták. Máskülönben, a Babel régebbi verziói és más fordítók nem tudják kezelni az alábbi kódrészletet <a href="https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend">hozzáadott konfiguráció</a> nélkül.</p> -</div> - -<div class="blockIndicator note"> -<p>Egyes böngészőkben előfordul a <code>CustomError</code> konstruktor a stacktrace-ben, ha ES2015-ös osztályokat használunk.</p> -</div> - -<pre class="brush: js notranslate">class CustomError extends Error { - constructor(foo = 'bar', ...params) { - // Pass remaining arguments (including vendor specific ones) to parent constructor - super(...params) - - // Maintains proper stack trace for where our error was thrown (only available on V8) - if (Error.captureStackTrace) { - Error.captureStackTrace(this, CustomError) - } - - this.name = 'CustomError' - // Custom debugging information - this.foo = foo - this.date = new Date() - } -} - -try { - throw new CustomError('baz', 'bazMessage') -} catch(e) { - console.error(e.name) //CustomError - console.error(e.foo) //baz - console.error(e.message) //bazMessage - console.error(e.stack) //stacktrace -}</pre> - -<h4 id="ES5_Saját_Error_Objektumok">ES5 Saját Error Objektumok</h4> - -<div class="warning"> -<p><strong>Minden</strong> böngészőben előfordul a <code>CustomError</code> konstruktor a stacktrace-ben, ha prototípus alapján deklaráljuk azt.</p> -</div> - -<pre class="brush: js notranslate">function CustomError(foo, message, fileName, lineNumber) { - var instance = new Error(message, fileName, lineNumber); - instance.name = 'CustomError'; - instance.foo = foo; - Object.setPrototypeOf(instance, Object.getPrototypeOf(this)); - if (Error.captureStackTrace) { - Error.captureStackTrace(instance, CustomError); - } - return instance; -} - -CustomError.prototype = Object.create(Error.prototype, { - constructor: { - value: Error, - enumerable: false, - writable: true, - configurable: true - } -}); - -if (Object.setPrototypeOf){ - Object.setPrototypeOf(CustomError, Error); -} else { - CustomError.__proto__ = Error; -} - -try { - throw new CustomError('baz', 'bazMessage'); -} catch(e){ - console.error(e.name); //CustomError - console.error(e.foo); //baz - console.error(e.message); //bazMessage -}</pre> - -<h2 id="Specifikációk">Specifikációk</h2> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Specification</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{SpecName('ESDraft', '#sec-error-objects', 'Error')}}</td> - </tr> - </tbody> -</table> - -<h2 id="Böngészőkompatibilitás">Böngészőkompatibilitás</h2> - -<div> - - -<p>{{Compat("javascript.builtins.Error")}}</p> -</div> - -<h2 id="Lásd_még">Lásd még</h2> - -<ul> - <li>{{JSxRef("Statements/throw", "throw")}}</li> - <li>{{JSxRef("Statements/try...catch", "try...catch")}}</li> -</ul> diff --git a/files/hu/web/javascript/reference/global_objects/function/index.html b/files/hu/web/javascript/reference/global_objects/function/index.html deleted file mode 100644 index a65fa95eea..0000000000 --- a/files/hu/web/javascript/reference/global_objects/function/index.html +++ /dev/null @@ -1,113 +0,0 @@ ---- -title: Függvény -slug: Web/JavaScript/Reference/Global_Objects/Function -tags: - - Függvény - - JavaScript - - Osztály -translation_of: Web/JavaScript/Reference/Global_Objects/Function -original_slug: Web/JavaScript/Reference/Global_Objects/Függvény ---- -<div>{{JSRef}}</div> - -<p>Minden JavaScript függvény tulajdonképpen egy <code>Function</code> objektum. Ez látható a következő kódnál, amely igazat ad vissza: <code>(function(){}).constructor === Function</code>.</p> - -<h2 id="Konstruktor">Konstruktor</h2> - -<dl> - <dt>{{jsxref("Function/Function", "Function()")}}</dt> - <dd>Létrehoz egy új <code>Function</code> objektumot. A konstruktor közvetlen meghívásával dinamikusan hozhatók létre függvények, de ez biztonsági és az {{jsxref("eval")}}hoz hasonló (de sokkal kevésbé jelentős) teljesítménybeli problémáktól szenved. Viszont, az evaltól ellentétben, a <code>Function</code> konstruktor olyan függvényeket hoz létre, melyek mindig a globális hatókörben hajtódnak végre.</dd> -</dl> - -<h2 id="Példánytulajdonságok">Példánytulajdonságok</h2> - -<dl> - <dt>{{jsxref("Function.arguments")}}</dt> - <dd>A függvénynek átadott argumentumokból álló tömb.<br> - A {{jsxref("Function")}} elavult tulajdonsága. Helyette az {{jsxref("Functions/arguments", "arguments")}} objektum (a függvényen belül érhető el) használandó.</dd> - <dt>{{jsxref("Function.caller")}}</dt> - <dd>A jelenleg futó függvényt meghívó függvényt adja meg.<br> - Ez a tulajdonság elavult, és csak egyes nem szigorú függvényekben működik.</dd> - <dt>{{jsxref("Function.displayName")}}</dt> - <dd>A függvény megjelenítendő neve.</dd> - <dt>{{jsxref("Function.length")}}</dt> - <dd>Megadja a függvény által várt argumentumok számát.</dd> - <dt>{{jsxref("Function.name")}}</dt> - <dd>A függvény neve.</dd> -</dl> - -<h2 id="Példánymetódusok">Példánymetódusok</h2> - -<dl> - <dt>{{jsxref("Function.prototype.apply()", "Function.prototype.apply(<var>thisArg</var> [, <var>argsArray</var>])")}}</dt> - <dd>Meghív egy függvényt, és beállítja a <code>this</code> értékét a megadott <code><var>thisArg</var></code> értékre. Az argumentumok {{jsxref("Array")}} objektumként adhatók át.</dd> - <dt>{{jsxref("Function.prototype.bind()", "Function.prototype.bind(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]]])")}}</dt> - <dd>Létrehoz egy új függvényt, amely meghívásakor beállítja a <code>this</code> értékét a megadott <code><var>thisArg</var></code> értékre. Az opcionálisan megadható argumentumsor az új függvény meghívásakor átadott argumentumok elé lesz fűzve.</dd> - <dt>{{jsxref("Function.prototype.call()", "Function.prototype.call(<var>thisArg</var>[, <var>arg1</var>, <var>arg2</var>, ...<var>argN</var>])")}}</dt> - <dd>Meghív egy függvényt, és beállítja a <code>this</code> értékét a megadott értékre. Az argumentumok egyszerűen átadhatók.</dd> - <dt>{{jsxref("Function.prototype.toString()", "Function.prototype.toString()")}}</dt> - <dd>Visszaadja a függvény forráskódját ábrázáló karakterláncot.<br> - Felülírja a {{jsxref("Object.prototype.toString")}} metódust.</dd> -</dl> - -<h2 id="Példák">Példák</h2> - -<h3 id="Különbség_a_Function_konstruktor_és_a_függvénydeklaráció_között">Különbség a Function konstruktor és a függvénydeklaráció között</h3> - -<p>A <code>Function</code> konstruktorral létrehozott függvények nem hoznak létre zárványt a létrehozási környezetükhöz, mindig a globális hatókörbe kerülnek. Futtatáskor csak a saját helyi változóit és a globálisakat éri el, a <code>Function</code> konstruktor meghívásakor aktív hatókörben szereplőket nem. Ez különbözik az {{jsxref("eval")}} függvénykifejezésen történő használatától.</p> - -<pre class="brush: js notranslate">var x = 10; - -function createFunction1() { - var x = 20; - return new Function('return x;'); // az |x| a globális |x|-et jelenti -} - -function createFunction2() { - var x = 20; - function f() { - return x; // ez az |x| a fent lévő helyi |x|-et jelenti - } - return f; -} - -var f1 = createFunction1(); -console.log(f1()); // 10 -var f2 = createFunction2(); -console.log(f2()); // 20 -</pre> - -<p>A kód működik a webböngészőkben, de az <code>f1()</code> <code>ReferenceError</code> hibát okoz Node.js-ben, mert az <code>x</code> nem található. Ez azért van, mert a Node legfelső szintű hatóköre nincs a globális hatókörben, és az <code>x</code> a modulra nézve helyi változó lesz.</p> - -<h2 id="Specifikációk">Specifikációk</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Specification</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-function-objects', 'Function')}}</td> - </tr> - </tbody> -</table> - -<h2 id="Böngészőkompatibilitás">Böngészőkompatibilitás</h2> - -<div> -<div class="hidden">Az oldalon lévő kompatibilitási táblázat strukturált adatokból készül. Ha közreműködnél az adatokban, akkor keresd fel a <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> tárolót, és küldj beolvasztási kérést.</div> - -<p>{{Compat("javascript.builtins.Function")}}</p> -</div> - -<h2 id="Lásd_még">Lásd még:</h2> - -<ul> - <li>{{jsxref("Functions", "Függvények és függvényhatókör")}}</li> - <li>{{jsxref("Statements/function", "function utasítás")}}</li> - <li>{{jsxref("Operators/function", "function kifejezés")}}</li> - <li>{{jsxref("Statements/function*", "function* utasítás")}}</li> - <li>{{jsxref("Operators/function*", "function* kifejezés")}}</li> - <li>{{jsxref("AsyncFunction")}}</li> - <li>{{jsxref("GeneratorFunction")}}</li> -</ul> diff --git a/files/hu/web/javascript/reference/global_objects/index.html b/files/hu/web/javascript/reference/global_objects/index.html deleted file mode 100644 index 10b4e99123..0000000000 --- a/files/hu/web/javascript/reference/global_objects/index.html +++ /dev/null @@ -1,192 +0,0 @@ ---- -title: Standard built-in objects -slug: Web/JavaScript/Reference/Global_Objects -tags: - - JavaScript - - NeedsTranslation - - Reference - - TopicStub -translation_of: Web/JavaScript/Reference/Global_Objects ---- -<div>{{jsSidebar("Objects")}}</div> - -<p>This chapter documents all of JavaScript's standard, built-in objects, including their methods and properties.</p> - -<div class="onlyinclude"> -<p>The term "global objects" (or standard built-in objects) here is not to be confused with the <strong>global object</strong>. Here, global objects refer to <strong>objects in the global scope</strong> (but only if ECMAScript 5 strict mode is not used; in that case it returns {{jsxref("undefined")}}). The <strong>global object</strong> itself can be accessed using the {{jsxref("Operators/this", "this")}} operator in the global scope. In fact, the global scope <strong>consists of</strong> the properties of the global object, including inherited properties, if any.</p> - -<p>Other objects in the global scope are either <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">created by the user script</a> or provided by the host application. The host objects available in browser contexts are documented in the <a href="/en-US/docs/Web/API/Reference">API reference</a>. For more information about the distinction between the <a href="/en-US/docs/DOM/DOM_Reference">DOM</a> and core <a href="/en-US/docs/Web/JavaScript">JavaScript</a>, see <a href="/en-US/docs/Web/JavaScript/JavaScript_technologies_overview">JavaScript technologies overview</a>.</p> - -<h2 id="Standard_objects_by_category">Standard objects by category</h2> - -<h3 id="Value_properties">Value properties</h3> - -<p>These global properties return a simple value; they have no properties or methods.</p> - -<ul> - <li>{{jsxref("Infinity")}}</li> - <li>{{jsxref("NaN")}}</li> - <li>{{jsxref("undefined")}}</li> - <li>{{jsxref("null")}} literal</li> -</ul> - -<h3 id="Function_properties">Function properties</h3> - -<p>These global functions—functions which are called globally rather than on an object—directly return their results to the caller.</p> - -<ul> - <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> - <li>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline}}</li> - <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li> - <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> - <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li> - <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> - <li>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</li> - <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</li> - <li>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</li> - <li>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</li> - <li>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline}}</li> - <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline}}</li> -</ul> - -<h3 id="Fundamental_objects">Fundamental objects</h3> - -<p>These are the fundamental, basic objects upon which all other objects are based. This includes objects that represent general objects, functions, and errors.</p> - -<ul> - <li>{{jsxref("Object")}}</li> - <li>{{jsxref("Function")}}</li> - <li>{{jsxref("Boolean")}}</li> - <li>{{jsxref("Symbol")}}</li> - <li>{{jsxref("Error")}}</li> - <li>{{jsxref("EvalError")}}</li> - <li>{{jsxref("InternalError")}}</li> - <li>{{jsxref("RangeError")}}</li> - <li>{{jsxref("ReferenceError")}}</li> - <li>{{jsxref("SyntaxError")}}</li> - <li>{{jsxref("TypeError")}}</li> - <li>{{jsxref("URIError")}}</li> -</ul> - -<h3 id="Numbers_and_dates">Numbers and dates</h3> - -<p>These are the base objects representing numbers, dates, and mathematical calculations.</p> - -<ul> - <li>{{jsxref("Number")}}</li> - <li>{{jsxref("Math")}}</li> - <li>{{jsxref("Date")}}</li> -</ul> - -<h3 id="Text_processing">Text processing</h3> - -<p>These objects represent strings and support manipulating them.</p> - -<ul> - <li>{{jsxref("String")}}</li> - <li>{{jsxref("RegExp")}}</li> -</ul> - -<h3 id="Indexed_collections">Indexed collections</h3> - -<p>These objects represent collections of data which are ordered by an index value. This includes (typed) arrays and array-like constructs.</p> - -<ul> - <li>{{jsxref("Array")}}</li> - <li>{{jsxref("Int8Array")}}</li> - <li>{{jsxref("Uint8Array")}}</li> - <li>{{jsxref("Uint8ClampedArray")}}</li> - <li>{{jsxref("Int16Array")}}</li> - <li>{{jsxref("Uint16Array")}}</li> - <li>{{jsxref("Int32Array")}}</li> - <li>{{jsxref("Uint32Array")}}</li> - <li>{{jsxref("Float32Array")}}</li> - <li>{{jsxref("Float64Array")}}</li> -</ul> - -<h3 id="Keyed_collections">Keyed collections</h3> - -<p>These objects represent collections which use keys; these contain elements which are iterable in the order of insertion.</p> - -<ul> - <li>{{jsxref("Map")}}</li> - <li>{{jsxref("Set")}}</li> - <li>{{jsxref("WeakMap")}}</li> - <li>{{jsxref("WeakSet")}}</li> -</ul> - -<h3 id="Vector_collections">Vector collections</h3> - -<p>{{Glossary("SIMD")}} vector data types are objects where data is arranged into lanes.</p> - -<ul> - <li>{{jsxref("SIMD")}} {{experimental_inline}}</li> - <li>{{jsxref("Float32x4", "SIMD.Float32x4")}} {{experimental_inline}}</li> - <li>{{jsxref("Float64x2", "SIMD.Float64x2")}} {{experimental_inline}}</li> - <li>{{jsxref("Int8x16", "SIMD.Int8x16")}} {{experimental_inline}}</li> - <li>{{jsxref("Int16x8", "SIMD.Int16x8")}} {{experimental_inline}}</li> - <li>{{jsxref("Int32x4", "SIMD.Int32x4")}} {{experimental_inline}}</li> - <li>{{jsxref("Uint8x16", "SIMD.Uint8x16")}} {{experimental_inline}}</li> - <li>{{jsxref("Uint16x8", "SIMD.Uint16x8")}} {{experimental_inline}}</li> - <li>{{jsxref("Uint32x4", "SIMD.Uint32x4")}} {{experimental_inline}}</li> - <li>{{jsxref("Bool8x16", "SIMD.Bool8x16")}} {{experimental_inline}}</li> - <li>{{jsxref("Bool16x8", "SIMD.Bool16x8")}} {{experimental_inline}}</li> - <li>{{jsxref("Bool32x4", "SIMD.Bool32x4")}} {{experimental_inline}}</li> - <li>{{jsxref("Bool64x2", "SIMD.Bool64x2")}} {{experimental_inline}}</li> -</ul> - -<h3 id="Structured_data">Structured data</h3> - -<p>These objects represent and interact with structured data buffers and data coded using JavaScript Object Notation (JSON).</p> - -<ul> - <li>{{jsxref("ArrayBuffer")}}</li> - <li>{{jsxref("SharedArrayBuffer")}} {{experimental_inline}}</li> - <li>{{jsxref("Atomics")}} {{experimental_inline}}</li> - <li>{{jsxref("DataView")}}</li> - <li>{{jsxref("JSON")}}</li> -</ul> - -<h3 id="Control_abstraction_objects">Control abstraction objects</h3> - -<ul> - <li>{{jsxref("Promise")}}</li> - <li>{{jsxref("Generator")}}</li> - <li>{{jsxref("GeneratorFunction")}}</li> - <li>{{experimental_inline}} {{jsxref("AsyncFunction")}}</li> -</ul> - -<h3 id="Reflection">Reflection</h3> - -<ul> - <li>{{jsxref("Reflect")}}</li> - <li>{{jsxref("Proxy")}}</li> -</ul> - -<h3 id="Internationalization">Internationalization</h3> - -<p>Additions to the ECMAScript core for language-sensitive functionalities.</p> - -<ul> - <li>{{jsxref("Intl")}}</li> - <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li> - <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> - <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li> -</ul> - -<h3 id="Non-standard_objects">Non-standard objects</h3> - -<ul> - <li>{{jsxref("Iterator")}} {{non-standard_inline}}</li> - <li>{{jsxref("ParallelArray")}} {{non-standard_inline}}</li> - <li>{{jsxref("StopIteration")}} {{non-standard_inline}}</li> -</ul> - -<h3 id="Other">Other</h3> - -<ul> - <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code></li> -</ul> -</div> - -<p> </p> diff --git a/files/hu/web/javascript/reference/global_objects/nan/index.html b/files/hu/web/javascript/reference/global_objects/nan/index.html deleted file mode 100644 index 16d2c13c79..0000000000 --- a/files/hu/web/javascript/reference/global_objects/nan/index.html +++ /dev/null @@ -1,96 +0,0 @@ ---- -title: NaN -slug: Web/JavaScript/Reference/Global_Objects/NaN -tags: - - JavaScript - - NaN - - Referencia - - Változó -translation_of: Web/JavaScript/Reference/Global_Objects/NaN ---- -<div>{{jsSidebar("Objects")}}</div> - -<p>A globális <code><strong>NaN</strong></code> egy olyan változó, ami a Not-A-Number típusú értéket reprezentálja.</p> - -<p>{{js_property_attributes(0,0,0)}}</p> - -<div>{{EmbedInteractiveExample("pages/js/globalprops-nan.html")}}</div> - -<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> - -<h2 id="Leírás">Leírás</h2> - -<p>A <code>NaN</code> a <em>globális objektum </em>része. Más szavakkal a globális scope egyik változója.</p> - -<p>A <code>NaN</code> eredeti jelentése: Not-A-Number (nem szám). Értéke a {{jsxref("Number.NaN")}}-nal egyenlő. Modern böngészőkben a <code>NaN</code> nem beállítható, nem írható változó. Ellenkező esetben sem tanácsolt felüldefiniálni. A <code>NaN</code> közvetlen használata egy programban igen ritka.</p> - -<p>Öt különböző típusú műveletet különböztethetünk meg, aminek az eredménye <code>NaN</code>:</p> - -<ul> - <li>A szám nem értelmezhető (pl.: <code>parseInt("blabla")</code> vagy <code>Number(undefined)</code>)</li> - <li>Olyan matematikai művelet, ahol a végeredmény nem valós szám (pl.: <code>Math.sqrt(-1)</code>)</li> - <li>Olyan művelet, ahol bármelyik operandus maga is <code>NaN</code> (pl.: <code>7 ** NaN</code>)</li> - <li>Nem meghatározható alak (pl.: <code>0 * Infinity</code>, vagy <code>undefined + undefined</code>)</li> - <li>Bármilyen művelet, ami szöveggel operál és nem összeadás, vagy hozzáfűzés (pl.: <code>"foo" / 3</code>)</li> -</ul> - -<h2 id="Példák">Példák</h2> - -<h3 id="Tesztelés_NaN_esetre">Tesztelés NaN esetre</h3> - -<p>A <code>NaN</code> nem összehasonlítható (az <code>==</code>, <code>!=</code>, <code>===</code>, és <code>!==</code> operátorokkal) semmilyen más értékkel. -- beleértve magát a <code>NaN</code> értéket. Ahhoz, hogy valamiről biztosan eldöntsük, hogy <code>NaN</code> a {{jsxref("Number.isNaN()")}}, illetve a {{jsxref("Global_Objects/isNaN", "isNaN()")}} függvényeket használhatjuk. Alternatívaként összehasonlíthatjuk a változót saját magával, mert a <code>NaN</code>, és csak is a <code>NaN</code> az az érték, ami nem egyenlő önmagával.</p> - -<pre class="brush: js notranslate">NaN === NaN; // false -Number.NaN === NaN; // false -isNaN(NaN); // true -isNaN(Number.NaN); // true -Number.isNaN(NaN); // true - -function valueIsNaN(v) { return v !== v; } -valueIsNaN(1); // false -valueIsNaN(NaN); // true -valueIsNaN(Number.NaN); // true -</pre> - -<p>Fontos felhívni a figyelmet az <code>isNaN()</code> és a <code>Number.isNaN()</code> közötti különbséget: míg az előbbi <code>true</code>-val tér vissza akkor is, ha az érték éppen <code>NaN</code>, és akkor is ha az a kiértékelés után <code>NaN</code>-ná válik, úgy az utóbbi csak akkor tér vissza <code>true</code>-val, ha az érték éppen <code>NaN</code>:</p> - -<pre class="brush: js notranslate">isNaN('hello world'); // true -Number.isNaN('hello world'); // false -</pre> - -<p>Továbbá, bizonyos tömbfüggvények nem használhatók a <code>NaN</code> keresésére, míg vannak, amik igen.</p> - -<pre class="brush: js notranslate">let arr = [2, 4, NaN, 12]; -arr.indexOf(NaN); // -1 (false) -arr.includes(NaN); // true -arr.findIndex(n => Number.isNaN(n)); // 2 -</pre> - -<h2 id="Specifikáció">Specifikáció</h2> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Specifikáció</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{SpecName('ESDraft', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}</td> - </tr> - </tbody> -</table> - -<h2 id="Böngésző_kompatibilitás">Böngésző kompatibilitás</h2> - - - -<p>{{Compat("javascript.builtins.NaN")}}</p> - -<h2 id="Lásd_még">Lásd még</h2> - -<ul> - <li>{{jsxref("Number.NaN")}}</li> - <li>{{jsxref("Number.isNaN()")}}</li> - <li>{{jsxref("isNaN", "isNaN()")}}</li> -</ul> diff --git a/files/hu/web/javascript/reference/global_objects/string/index.html b/files/hu/web/javascript/reference/global_objects/string/index.html deleted file mode 100644 index 4f91f13008..0000000000 --- a/files/hu/web/javascript/reference/global_objects/string/index.html +++ /dev/null @@ -1,307 +0,0 @@ ---- -title: String -slug: Web/JavaScript/Reference/Global_Objects/String -tags: - - húzáskérvény -translation_of: Web/JavaScript/Reference/Global_Objects/String ---- -<div>{{JSRef}}</div> - -<p>A String konstruktorral létrehozhatunk karakterláncokat (szövegek szinte mindenhol jelenlévő reprezentációja)</p> - -<h2 id="Szintaxis">Szintaxis</h2> - -<p>A sztringliterálok a következő formájúak:</p> - -<pre class="syntaxbox">'sztring szöveg' -"sztring szöveg" -"中文 español Deutsch English देवनागरी العربية português বাংলা русский 日本語 norsk bokmål ਪੰਜਾਬੀ 한국어 தமிழ் עברית"</pre> - -<p>Sztringeket létrehozhatunk a <code>String</code> globális objektummal közvetlenül:</p> - -<pre class="syntaxbox">String(valami)</pre> - -<h3 id="Paraméterek">Paraméterek</h3> - -<dl> - <dt><code>valami</code></dt> - <dd>Bármi, ami sztringgé alakítható.</dd> -</dl> - -<h3 id="Sablon_literálok">Sablon literálok</h3> - -<p>Az ECMAScript 2015-tel kezdődően, a sztringliterálok ún. <a href="/en-US/docs/Web/JavaScript/Reference/Template_literals">Template literal</a>-ok is lehetnek:</p> - -<pre class="syntaxbox">`hello világ` -`hello! - world!` -`hello ${who}` -tag `<a>${who}</a>`</pre> - -<p>Itt a ${who} helyére a megfelelő érték fog behelyettsítődni.</p> - -<h3 id="Escape_jelölés">Escape jelölés</h3> - -<p>Egyes karakterek összezavarhatnák a JavaScript értelmezőt. Például egy " karakterről hogyan tufná megállapítani, hogy a karakterlánc végét jelöli, vagy annak része? Erre találták ki az escape jelölést, aminek segítségével jelölhetjük, hogy egy karakternek nincs speciális szerepe, nem kell programkódként értelmezni. Lényegében az történik, hogy a feldolgozott karakterláncban az escape karakter (például a \") helyére az annak megfelelő kimenet (") kerül.</p> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Kód</th> - <th scope="col">Kimenet</th> - </tr> - </thead> - <tbody> - <tr> - <td><code>\XXX</code></td> - <td>oktális Latin-1 karakter.</td> - </tr> - <tr> - <td><code>\'</code></td> - <td>egyszeres idézőjel</td> - </tr> - <tr> - <td><code>\"</code></td> - <td>idézőjel</td> - </tr> - <tr> - <td><code>\\</code></td> - <td>backslash</td> - </tr> - <tr> - <td><code>\n</code></td> - <td>új sor (soremelés)</td> - </tr> - <tr> - <td><code>\r</code></td> - <td>kocsi-vissza</td> - </tr> - <tr> - <td><code>\v</code></td> - <td>függőleges tabulátor</td> - </tr> - <tr> - <td><code>\t</code></td> - <td>tabulátor</td> - </tr> - <tr> - <td><code>\b</code></td> - <td>backspace</td> - </tr> - <tr> - <td><code>\f</code></td> - <td>lapdobás</td> - </tr> - <tr> - <td><code>\uXXXX</code></td> - <td>unicode kódpont</td> - </tr> - <tr> - <td><code>\u{X}</code> ... <code>\u{XXXXXX}</code></td> - <td>unicode kódpont {{experimental_inline}}</td> - </tr> - <tr> - <td><code>\xXX</code></td> - <td>hexadecimális Latin-1 karakter</td> - </tr> - </tbody> -</table> - -<div class="note"> -<p>Más nyelvekkel ellentétben a JavaScript nem különbözteti meg az egyszeres, illetve a kettős idézőjelekkel hivatkozott sztringeket; ezért a fenti escape szekvenciák mind az egyszeres, mind a kettős idézőjelekkel létrehozott sztringek esetén működnek.</p> -</div> - -<h3 id="Hosszú_sztring_literálok">Hosszú sztring literálok</h3> - -<p>Időnként a kódban szerepelhetnek nagyon hosszú sztringek. Vég nélkül folytatódó, illetve a szerkesztőprogram kénye-kedve szerint megtört sorok helyett lehetséges a sztringek több sorba tördelése a tartalom meghagyásával. Erre két mód van.</p> - -<p>Használhatjuk a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition_()">+</a> operátort több füzér összefűzéséhez, így:</p> - -<pre class="brush: js">let longString = "Ez egy elég hosszú String ahhoz " + - "hogy több sorba rendezzem, mert " + - "máskülönben a kód nem olvasható."; -</pre> - -<p>Vagy használható a backslash karakter ("\") az összes sor végén, jelölve, hogy a sztring a következő sorban folytatódik. Győződjünk meg róla, hogy nincs szóköz vagy más karakter a backslash után (soremelés kivételével), akár bekezdésként, különben nem fog működni. Ennek formája a kövekező:</p> - -<pre class="brush: js">let longString = "This is a very long string which needs \ -to wrap across multiple lines because \ -otherwise my code is unreadable."; -</pre> - -<p>Mindkét forma a példában azonos sztringek létrehozását eredményezi.</p> - -<h2 id="Leírás">Leírás</h2> - -<p>A stringek szöveges formában ábrázolt adatok tárolására használhatók. A leggyakoribb sztringműveletek közé tartozik a {{jsxref("String.length", "hossz")}} vizsgálata, azok felépítése és összefűzése a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">+ és += sztring operátor</a>okkal, alfüzérek meglétének és helyének vizsgálata a {{jsxref("String.prototype.indexOf()", "indexOf()")}} metódussal, illetve alfüzérek lekérdezése a {{jsxref("String.prototype.substring()", "substring()")}} metódussal.</p> - -<h3 id="Karakter_hozzáférés">Karakter hozzáférés</h3> - -<p>Kétféle mód van egy sztringben az egyes karakterekhez vakó hozzáféréshez. Az egyik a {{jsxref("String.prototype.charAt()", "charAt()")}} metódus:</p> - -<pre class="brush: js">return 'macska'.charAt(1); // "a"-val tér vissza -</pre> - -<p>A másik mód (bevezetve az ECMAScript 5-ben) tömbszerű objektumként kezeli a sztringet, ahol az egyes karaktereknem számindexek felelnek meg:</p> - -<pre class="brush: js">return 'macska'[1]; // "a"-val tér vissza -</pre> - -<p>Törölni vagy megváltoztatni e tulajdonságokat karakter hozzáféréssel nem lehet a szögletes zárójeles jelölés esetén. A szóban forgó tulajdonságok nem írhatók és nem is konfigurálhatók. (Lásd a {{jsxref("Object.defineProperty()")}} cikket további információért.)</p> - -<h3 id="Sztringek_összehasonlítása">Sztringek összehasonlítása</h3> - -<p>C fejlesztőknek ismerős lehet a <code>strcmp()</code> függvény sztringek összehasonlításához. A JavaScript-ben a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">kisebb és nagyobb operátorok</a> használhatók:</p> - -<pre class="brush: js">var a = 'a'; -var b = 'b'; -if (a < b) { // true - console.log(a + ' kisebb, mint ' + b); -} else if (a > b) { - console.log(a + ' nagyobb, mint ' + b); -} else { - console.log(a + ' és ' + b + ' egyenlők.'); -} -</pre> - -<p>Hasonlót eredményez a {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} metódus, amelyet a <code>String</code> példányok örökölnek.</p> - -<h3 id="Sztring_primitívek_és_String_objektumok_megkülönböztetése">Sztring primitívek és <code>String</code> objektumok megkülönböztetése</h3> - -<p>Jegyezzük meg, hogy a JavaScript különbséget tesz <code>String</code> objektumok és primitív sztring értékek között. (Ugyanez igaz {{jsxref("Boolean")}} és {{jsxref("Global_Objects/Number", "Number")}} objektumokra.)</p> - -<p>Sztringliterálok (egyszeri vagy kettős idézőjellel jelölve) és a <code>String</code> hívásából visszatérő, nem konstruktor kontextusból (azaz, nem a {{jsxref("Operators/new", "new")}} kulcsszó használatával) kapott sztringek primitív sztringek. A JavaScript automatikusan <code>String</code> objektumokká alakítja a primitíveket, hogy eképpen a <code>String</code> objektum metódusai primitív sztringeken is használhatók legyenek. Amikor primitív sztringen hívódik metódus vagy tulajdonság lekérdezés, a JavaScript automatikusan String objektummá alakítja a sztringet és így hívja meg a metódust, illetve a lekérdezést.</p> - -<pre class="brush: js">var s_prim = 'foo'; -var s_obj = new String(s_prim); - -console.log(typeof s_prim); // Konzol kimenet: "string" -console.log(typeof s_obj); // Konzol kimenet: "object" -</pre> - -<p>Sztring primitívek és <code>String</code> objektumok az {{jsxref("Global_Objects/eval", "eval()")}} használatakor is különböző eredményt adnak. Az <code>eval</code> számára átadott primitívek forráskódként vannak kezelve, míg a <code>String</code> objektumok, mint bármely más átadott objektum esetén, az objektum visszaadását eredményezik. Például:</p> - -<pre class="brush: js">var s1 = '2 + 2'; // létrehoz egy sztring primitívet -var s2 = new String('2 + 2'); // létrehoz egy String objektumot -console.log(eval(s1)); // a 4 számmal tér vissza -console.log(eval(s2)); // a "2 + 2" sztringgel tér vissza -</pre> - -<p>Ezen okok miatt a kód hibás működését okozhatja, amikor <code>String</code> a kód String objektumot kap, miközben primitív sztringet vár, bár általában nem szükséges a fejlesztőknek ezzel törődni.</p> - -<p>Egy <code>String</code> objektum mindig átalakítható a primitív megfelelőjére a {{jsxref("String.prototype.valueOf()", "valueOf()")}} metódussal.</p> - -<pre class="brush: js">console.log(eval(s2.valueOf())); // 4-et ad vissza -</pre> - -<div class="note"><strong>Megjegyzés:</strong> Egy másik JavaScript-ben lehetséges megközelítésére a sztringeknek, lásd a <a href="/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — a C-like representation of strings based on typed arrays</a> cikket.</div> - -<h2 id="Tulajdonságok">Tulajdonságok</h2> - -<dl> - <dt>{{jsxref("String.prototype")}}</dt> - <dd>Tulajdonságok hozzáadását engedélyezi egy <code>String</code> objektumhoz.</dd> -</dl> - -<h2 id="Metódusok">Metódusok</h2> - -<dl> - <dt>{{jsxref("String.fromCharCode()")}}</dt> - <dd>Unicode értékek meghatározott sorozatával megadott sztringgel tér vissza.</dd> - <dt>{{jsxref("String.fromCodePoint()")}}</dt> - <dd>Kódpontok meghatározott sorozatával megadott sztringgel tér vissza.</dd> - <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt> - <dd>Nyers sablon sztring szerint létrehozott sztringgel tér vissza.</dd> -</dl> - -<h2 id="String_generikus_metódusok"><code>String</code> generikus metódusok</h2> - -<div class="warning"> -<p><strong>A String generikusok nem szabványosak, elavultak és a közeljövőben törlésre kerülnek</strong>.</p> -</div> - -<p>A <code>String</code> példánymetódusok a JavaScript 1.6 óta elérhetők Firefox-ban (<strong>nem</strong> része az ECMAScript szabványnak) a <code>String</code> objektumon bármely objektumon <code>String</code> metódusok alkalmazására:</p> - -<pre class="brush: js">var num = 15; -console.log(String.replace(num, "5", "2")); -</pre> - -<p>A String generikusokról való áttéréshez lásd a <a href="/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_string_generics">Warning: String.x is deprecated; use String.prototype.x instead</a> cikket.</p> - -<p>Tömbök generikusai ({{jsxref("Global_Objects/Array", "Generics", "#Array_generic_methods", 1)}}) a tömb ({{jsxref("Array")}}) metódusokra is elérhetők.</p> - -<h2 id="String_példányok"><code>String</code> példányok</h2> - -<h3 id="Tulajdonságok_2">Tulajdonságok</h3> - -<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Tulajdonságok')}}</div> - -<h3 id="Metódusok_2">Metódusok</h3> - -<h4 id="HTML-hez_nem_kapcsolódó_metódusok">HTML-hez nem kapcsolódó metódusok</h4> - -<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Methods_unrelated_to_HTML')}}</div> - -<h4 id="HTML_wrapper_methods">HTML wrapper methods</h4> - -<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'HTML_wrapper_methods')}}</div> - -<h2 id="Példák">Példák</h2> - -<h3 id="String_konverzió">String konverzió</h3> - -<p>A <code>String</code> használható egy biztonságosabb {{jsxref("String.prototype.toString()", "toString()")}} alternatívaként, mivel {{jsxref("null")}}, {{jsxref("undefined")}}, és {{jsxref("Symbol", "symbol")}} objektumokra is használható. Például:</p> - -<pre class="brush: js">var outputStrings = []; -for (var i = 0, n = inputValues.length; i < n; ++i) { - outputStrings.push(String(inputValues[i])); -} -</pre> - -<h2 id="Specifikációk">Specifikációk</h2> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Specificáció</th> - <th scope="col">Státusz</th> - <th scope="col">Megjegyzés</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{SpecName('ESDraft', '#sec-string-objects', 'String')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES2015', '#sec-string-objects', 'String')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td></td> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Kezdeti definíció.</td> - </tr> - </tbody> -</table> - -<h2 id="Böngésző_kompatibilitás">Böngésző kompatibilitás</h2> - -<div class="hidden">Ezen az oldalon egy strukturált adatokból generált kompatibilitási táblázat van. Ha hozzájárulnál adatokkal, a <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> címen küldj nekünk egy pull request-et.</div> - -<p>{{Compat("javascript.builtins.String",2)}}</p> - -<h2 id="Lásd_még">Lásd még</h2> - -<ul> - <li>{{domxref("DOMString")}}</li> - <li><a href="/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — a C-like representation of strings based on typed arrays</a></li> - <li><a href="/en-US/docs/Web/API/DOMString/Binary">Binary strings</a></li> -</ul> |