path: root/files/ca/web/javascript/reference/global_objects/string/index.html

---
title: String
slug: Web/JavaScript/Reference/Global_Objects/String
translation_of: Web/JavaScript/Reference/Global_Objects/String
original_slug: Web/JavaScript/Referencia/Objectes_globals/String
---
<div>{{JSRef("Global_Objects", "String")}}</div>

<h2 id="Summary" name="Summary">Resum</h2>

<p>L'objecte global <strong><code>String</code></strong> és un constructor per a strings, també conegudes com a cadenes de caràcters.</p>

<h2 id="Syntax" name="Syntax">Sintaxi</h2>

<p>Els literals de tipus Stringpoden tenir les següents formes:</p>

<pre class="syntaxbox"><code>'string text'
"string text"
"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 </code><span style="color: #222222; font-family: Consolas,'Lucida Console',monospace; font-size: 12px; line-height: normal; white-space: pre-wrap;">தமிழ்</span><code>"
</code></pre>

<p>A més dels caràcters imprimibles normals, es poden codificar caràcters especials mitjançant la notació d'escapament:</p>

<table class="standard-table">
 <thead>
  <tr>
   <th scope="col">Codi</th>
   <th scope="col">Sortida</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>\0</code></td>
   <td>el caràcter NUL</td>
  </tr>
  <tr>
   <td><code>\'</code></td>
   <td>cometa simple</td>
  </tr>
  <tr>
   <td><code>\"</code></td>
   <td>cometa doble</td>
  </tr>
  <tr>
   <td><code>\\</code></td>
   <td>barra invertida</td>
  </tr>
  <tr>
   <td><code>\n</code></td>
   <td>línia nova</td>
  </tr>
  <tr>
   <td><code>\r</code></td>
   <td>retorn de carro</td>
  </tr>
  <tr>
   <td><code>\v</code></td>
   <td>barra vertical</td>
  </tr>
  <tr>
   <td><code>\t</code></td>
   <td>tabulador</td>
  </tr>
  <tr>
   <td><code>\b</code></td>
   <td>esborrar</td>
  </tr>
  <tr>
   <td><code>\f</code></td>
   <td>form feed</td>
  </tr>
  <tr>
   <td><code>\uXXXX</code></td>
   <td>caràcter amb codificació unicode</td>
  </tr>
  <tr>
   <td><code>\xXX</code></td>
   <td>caràcter amb codificació Latin-1</td>
  </tr>
 </tbody>
</table>

<p>O bé utilitzant l'objecte global <code>String</code> de forma directa:</p>

<pre class="syntaxbox"><code>String(quelcom)
new String(quelcom)
</code></pre>

<h3 id="Parameters" name="Parameters">Paràmetres</h3>

<dl>
 <dt><code>quelcom</code></dt>
 <dd>Qualsevol cosa que serà convertida a string.</dd>
</dl>

<h2 id="Description" name="Description">Descripció</h2>

<p>Les Strings són útils per a emmagatzemar dades que poden ser representades en forma de texte. Algunes de les operacions més emprades en strings són per a obtindre la seva llargada {{jsxref("String.length", "length")}}, per a concatenar-les mitjançant els <a href="/ca/docs/Web/JavaScript/Reference/Operators/String_Operators">operadors de strings + i +=</a>, per a comprovar l'existència o localització de substrings amb el mètode {{jsxref("String.prototype.indexOf()", "indexOf()")}}, o bé per a extreure substrings amb el mètode {{jsxref("String.prototype.substring()", "substring()")}}.</p>

<h3 id="Character_access" name="Character_access">Accés als caràcters</h3>

<p>Hi ha dues formes d'accedir a un caràcter individual emmagatzemat dins un string. El primer és el mètode {{jsxref("String.prototype.charAt()", "charAt()")}}:</p>

<pre class="brush: js">return 'cat'.charAt(1); // retorna "a"
</pre>

<p>L'altra forma (introduida a ECMAScript 5) és fer anar l'string com si fós un objecte de tipus array, on els caràcters individuals es corresponen a un índex numèric:</p>

<pre class="brush: js">return 'cat'[1]; // retorna "a"
</pre>

<p>Utilitzar la notació de claus per a esborrar o bé assignar un valor a un caràcter no funcionarà. Les propietats involucrades no són de tipus no-escriptura i no són configurables. (Vegeu {{jsxref("Object.defineProperty()")}} per a més informació).</p>

<h3 id="Comparing_strings" name="Comparing_strings">Comparar strings</h3>

<p>Els desenvolupadors de C disposen de la funció <code>strcmp()</code> per a comparar strings. A JavaScript senzillament es poden utilitzar els <a href="/ca/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">operadors major-que i menor-que</a></p>

<pre class="brush: js">var a = 'a';
var b = 'b';
if (a &lt; b) { // true
  print(a + ' és menor que ' + b);
} else if (a &gt; b) {
  print(a + ' és major que ' + b);
} else {
  print(a + ' i ' + b + ' són iguals.');
}
</pre>

<p>Es pot obtindre un resultat similar mitjançant el mètode {{jsxref("String.prototype.localeCompare()", "localeCompare()")}}, heredat per les instàncies de <code>String</code>.</p>

<h3 id="Distinció_entre_les_primitives_string_i_els_objectes_String">Distinció entre les primitives string i els objectes <code>String</code></h3>

<p>Cal recalcar que JavaScript distingeix entre objectes de tipus <code>String</code> i valors primitius de tipus string (El mateix succeeix amb {{jsxref("Global_Objects/Boolean", "Boolean")}} i {{jsxref("Global_Objects/Number", "Numbers")}}</p>

<p>Els literals de tipus string (englobats en cometes simples o dobles) així com strings retornats per crides a l'objecte <code>String</code> en un contexte no constructor (és a dir, sense utilitzar la paraula clau {{jsxref("Operators/new", "new")}}) són strings primitives. JavaScript automàticament converteix primitives a objectes String, de forma que és posible utilitzar mètodes de l'objecte <code>String</code> en strings primitives. En els contextes on s'ha d'invocar un mètode en una primitiva string o es demana la una propietat, JavaScript automàticament embolcallarà la primitiva string amb un objecte String i cridarà el mètode o la propietat corresponent.</p>

<pre class="brush: js">var s_prim = 'foo';
var s_obj = new String(s_prim);

console.log(typeof s_prim); // Escriu "string"
console.log(typeof s_obj);  // Escriu "object"
</pre>

<p>Les primitives string i els objectes <code>String</code> també donen resultats diferents a l'utilitzar {{jsxref("Global_Objects/eval", "eval()")}}. Les primitives passades a <code>eval</code> són considerades codi font; els objectes <code>String</code> es tracten com qualsevol altre objecte, és a dir, retornan l'objecte. Per exemple:</p>

<pre class="brush: js">var s1 = '2 + 2';             // crea una primitiva string
var s2 = new String('2 + 2'); // crea un objecte String
console.log(eval(s1));        // escriu el nombre 4
console.log(eval(s2));        // escriu la string "2 + 2"
</pre>

<p>És per aquestes raons que el codi pot produïr errors quan trobi objectes <code>String</code> però s'esperès una primitiva string, tot i que de forma general els autors no s'han de preocupar per la distinció.</p>

<p>Un objecte <code>String</code> sempre es pot convertir en la seva representació primitiva mitjançant el mètode {{jsxref("String.prototype.valueOf()", "valueOf()")}}.</p>

<pre class="brush: js">console.log(eval(s2.valueOf())); // escriu el nombre 4
</pre>

<div class="note"><strong>Nota:</strong> Per a una altra posible enfocament quant a string a JavaScript llegiu l'article sobre <a href="/ca/Add-ons/Code_snippets/StringView"><code>StringView</code> — una representació de strings basada en arrays de tipatge explícit similar a C</a>.</div>

<h2 id="Properties" name="Properties">Propietats</h2>

<dl>
 <dt>{{jsxref("String.prototype")}}</dt>
 <dd>Permet afegir propietats a un objecte <code>String</code>.</dd>
</dl>

<div>{{jsOverrides("Function", "Properties", "prototype")}}</div>

<h2 id="Methods" name="Methods">Mètodes</h2>

<dl>
 <dt>{{jsxref("String.fromCharCode()")}}</dt>
 <dd>Retorna un string creat a partir de la seqüència de valors Unicode proporcionada.</dd>
 <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt>
 <dd>Retorna un string creat a partir de la seqüència de <u><em>code points</em> </u>proporcionada.</dd>
 <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt>
 <dd>Retorna un string creat a partir de l'string proporcionat <u>sense tindre en compte la codificació.</u></dd>
</dl>

<div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint", "raw")}}</div>

<h2 id="Mètodes_genèrics_de_String"><code>Mètodes genèrics de String</code></h2>

<p>Els mètodes de les instàncies de <code>String</code> també estan disponibles a Firefox a partir del JavaScript 1.6 (tot i que no formen part de l'standard ECMAScript) a l'objecte <code>String</code>, així es poden aplicar els mètodes de <code>String</code> a qualsevol objecte:</p>

<pre class="brush: js">var num = 15;
console.log(String.replace(num, /5/, '2'));
</pre>

<p>{{jsxref("Global_Objects/Array", "Generics", "#Array_generic_methods", 1)}} <u>també estàn disponibles als mètodes de</u> {{jsxref("Global_Objects/Array", "Array")}}.</p>

<p>A continuació es mostra un <em>shim</em> per a donar suport als navegadors que no ho suporten:</p>

<pre class="brush: js">/*globals define*/
// Assumes all supplied String instance methods already present
// (one may use shims for these if not available)
(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(String).filter(function(methodName) {
    //   return typeof String[methodName] === 'function';
    // });
    methods = [
      'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt',
      'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith',
      'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase',
      'toLocaleUpperCase', 'localeCompare', 'match', 'search',
      'replace', 'split', 'substr', 'concat', 'slice'
    ],
    methodCount = methods.length,
    assignStringGeneric = function(methodName) {
      var method = String.prototype[methodName];
      String[methodName] = function(arg1) {
        return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
      };
    };

  for (i = 0; i &lt; methodCount; i++) {
    assignStringGeneric(methods[i]);
  }
}());
</pre>

<h2 id="String_instances" name="String_instances"><code>Instàncies de String</code></h2>

<h3 id="Propietats">Propietats</h3>

<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Properties')}}</div>

<h3 id="Mètodes">Mètodes</h3>

<h4 id="Methods_unrelated_to_HTML" name="Methods_unrelated_to_HTML">Mètodes no relacionats amb HTML</h4>

<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Methods_unrelated_to_HTML')}}</div>

<h4 id="HTML_wrapper_methods" name="HTML_wrapper_methods">Mètodes d'embolcall de HTML</h4>

<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'HTML_wrapper_methods')}}</div>

<h2 id="Exemples">Exemples</h2>

<h3 id="Exemple_Conversió_de_strings">Exemple: Conversió de strings</h3>

<p>És posible utilitzar <code>String</code> com a una alternativa "més segura" de {{jsxref("String.prototype.toString()","toString()")}}, ja que tot i que normalment també crida el mètode <code>toString()</code> subjacent, també funciona per a {{jsxref("Global_Objects/null", "null")}} i {{jsxref("Global_Objects/undefined", "undefined")}}. Per exemple:</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="Especificacions">Especificacions</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificació</th>
   <th scope="col">Estat</th>
   <th scope="col">Comentari</th>
  </tr>
  <tr>
   <td>ECMAScript 1a Edició</td>
   <td>Standard</td>
   <td>Definició inicial.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-string-objects', 'String')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2>

<div>{{CompatibilityTable}}</div>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Característica</th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td>Suport bàsic</td>
   <td>{{CompatChrome("0.2")}}</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>Característica</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>Suport bàsic</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="Vegeu_també">Vegeu també</h2>

<ul>
 <li>{{domxref("DOMString")}}</li>
 <li><a href="/ca/Add-ons/Code_snippets/StringView"><code>StringView</code> — una representació de strings basada en arrays de tipatge explícit similar a C</a></li>
 <li><a href="/ca/docs/Web/API/DOMString/Binary">Strings binàries</a></li>
</ul>