---
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 `&lt;a&gt;${who}&lt;/a&gt;`</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 &lt; b) { // true
  console.log(a + ' kisebb, mint ' + b);
} else if (a &gt; 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 &lt; 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>