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

---
title: String.prototype.charAt()
slug: Web/JavaScript/Reference/Global_Objects/String/charAt
translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt
---
<div>{{JSRef}}</div>

<p><span class="seoSummary">Il metodo {{jsxref("String")}} dell'oggetto <strong><code>charAt()</code></strong> restituisce una nuova stringa che consiste nella singola unità di codice UTF-16 situata nell'offset specificato nella stringa.</span></p>

<div>{{EmbedInteractiveExample("pages/js/string-charat.html")}}</div>

<p class="hidden">La fonte per questo esempio interattivo è memorizzata in un repository GitHub. Se desideri contribuire al progetto di esempi interattivi, clonare <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e inviarci una richiesta di pull.</p>

<h2 id="Sintassi">Sintassi</h2>

<pre class="syntaxbox"><em>carattere</em> = <em>str</em>.charAt(<em>indice</em>)</pre>

<h3 id="Parametri">Parametri</h3>

<dl>
 <dt><code>index</code></dt>
 <dd>Un numero intero compreso tra 0 e 1-meno della lunghezza della stringa. Se non viene fornito alcun indice, il valore predefinito è 0, quindi viene restituito il primo carattere nella stringa.</dd>
</dl>

<h3 id="Valore_restituito">Valore restituito</h3>

<p>Una stringa che rappresenta il carattere (esattamente un'unità di codice UTF-16) nell'indice specificato; stringa vuota se <code>index</code> non è compreso nell'intervallo</p>

<h2 id="Descrizione">Descrizione</h2>

<p>I caratteri in una stringa sono indicizzati da sinistra a destra. L'indice del primo carattere è 0 e l'indice dell'ultimo carattere in una stringa chiamata <code>stringName</code> è <code>stringName.length - 1</code>. Se l'indice che fornisci è fuori da questo intervallo, JavaScript restituisce una stringa vuota.</p>

<p>Se non viene fornito alcun indice per <code> charAt()</code>, il valore predefinito è 0.</p>

<h2 id="Esempi">Esempi</h2>

<h3 id="Visualizzazione_di_caratteri_in_posizioni_diverse_in_una_stringa">Visualizzazione di caratteri in posizioni diverse in una stringa</h3>

<p>Nell'esempio seguente vengono visualizzati caratteri in posizioni diverse nella stringa <code> "Brave new world"</code>:</p>

<pre class="brush: js">var anyString = 'Brave new world';
console.log("Il carattere nell'indice 0 è '" + anyString.charAt()   + "'");
// Non è stato fornito alcun indice, usato 0 come predefinito

console.log("The character at index 0   is '" + anyString.charAt(0)   + "'");
console.log("The character at index 1   is '" + anyString.charAt(1)   + "'");
console.log("The character at index 2   is '" + anyString.charAt(2)   + "'");
console.log("The character at index 3   is '" + anyString.charAt(3)   + "'");
console.log("The character at index 4   is '" + anyString.charAt(4)   + "'");
console.log("The character at index 999 is '" + anyString.charAt(999) + "'");
</pre>

<p>Queste righe mostrano quanto segue:</p>

<pre class="brush: js">//Il carattere nell'indice 0   is 'B'

//Il carattere nell'indice 0   is 'B'
//Il carattere nell'indice 1   is 'r'
//Il carattere nell'indice 2   is 'a'
//Il carattere nell'indice 3   is 'v'
//Il carattere nell'indice 4   is 'e'
//Il carattere nell'indice 999 is ''
</pre>

<h3 id="Recupero_di_caratteri_interi">Recupero di caratteri interi</h3>

<p>Quanto segue fornisce un mezzo per garantire che l'attraversamento di un loop string fornisca sempre un intero carattere, anche se la stringa contiene caratteri che non si trovano nel piano multi-lingue di base.</p>

<pre class="brush: js">var str = 'A \uD87E\uDC04 Z'; // Potremmo anche usare direttamente un carattere non-BMP
for (var i = 0, chr; i &lt; str.length; i++) {
  if ((chr = getWholeChar(str, i)) === false) {
    continue;
  }
  // Adatta questa linea all'inizio di ogni ciclo, passando l'intera stringa e
  // l'iterazione corrente e il ritorno di una variabile per rappresentare il
  // personaggio individuale

  console.log(chr);
}

function getWholeChar(str, i) {
  var code = str.charCodeAt(i);

  if (Number.isNaN(code)) {
    return ''; // Posizione non trovata
  }
  if (code &lt; 0xD800 || code &gt; 0xDFFF) {
    return str.charAt(i);
  }

  // Alto surrogato (potrebbe cambiare l'ultimo esadecimale a 0xDB7F per trattare un alto privato
   // si surroga come singoli caratteri)
  if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
    if (str.length &lt;= (i + 1)) {
      throw 'Alto surrogato senza seguire un surrogato basso';
    }
    var next = str.charCodeAt(i + 1);
      if (0xDC00 &gt; next || next &gt; 0xDFFF) {
        throw 'Alto surrogato senza seguire un surrogato basso';
      }
      return str.charAt(i) + str.charAt(i + 1);
  }
  // Low surrogate (0xDC00 &lt;= code &amp;&amp; code &lt;= 0xDFFF)
  if (i === 0) {
    throw 'Basso surrogato senza precedente surrogato elevato';
  }
  var prev = str.charCodeAt(i - 1);

  // (could change last hex to 0xDB7F to treat high private
  // surrogates as single characters)
  if (0xD800 &gt; prev || prev &gt; 0xDBFF) {
    throw 'Basso surrogato senza precedente surrogato elevato';
  }
  // Ora possiamo passare sopra surrogati bassi come secondo componente
   // in una coppia che abbiamo già elaborato
  return false;
}
</pre>

<p>In un ambiente ECMAScript 2016 che consente l'assegnazione destrutturata, la seguente è un'alternativa più succinta e un po 'più flessibile in quanto incrementa automaticamente una variabile incrementale (se il carattere lo richiede in quanto coppia surrogata).</p>

<pre class="brush: js">var str = 'A\uD87E\uDC04Z'; // Potremmo anche usare direttamente un carattere non-BMP
for (var i = 0, chr; i &lt; str.length; i++) {
  [chr, i] = getWholeCharAndI(str, i);
  // Adatta questa linea all'inizio di ogni ciclo, passando l'intera stringa e
  // l'iterazione corrente e la restituzione di un array con il singolo carattere
  // e valore "i" (modificato solo se una coppia surrogata)

  console.log(chr);
}
function getWholeCharAndI(str, i) {
  var code = str.charCodeAt(i);
  if (Number.isNaN(code)) {
    return ''; // Posizione non trovata
  }
  if (code &lt; 0xD800 || code &gt; 0xDFFF) {
    return [str.charAt(i), i]; // Carattere normale, mantenendo 'i' lo stesso
  }
  // Alto surrogato (potrebbe cambiare l'ultimo esadecimale a 0xDB7F per trattare un alto privato
  // si surroga come singoli caratteri)
  if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
    if (str.length &lt;= (i + 1)) {
      throw "Alto surrogato senza seguire un surrogato basso";
    }
    var next = str.charCodeAt(i + 1);
      if (0xDC00 &gt; next || next &gt; 0xDFFF) {
        throw "Alto surrogato senza seguire un surrogato basso";
      }
      return [str.charAt (i) + str.charAt (i + 1), i + 1];
  }
  // Basso surrogato (0xDC00 &lt;= code &amp;&amp; code &lt;= 0xDFFF)
  if (i === 0) {
    throw "Basso surrogato senza precedente surrogato elevato";
  }
  var prev = str.charCodeAt(i - 1);
  // (potrebbe cambiare l'ultimo esadecimale in 0xDB7F per trattare i surrogati ad alto livello privato
  // come singoli caratteri)
  if (0xD800 &gt; prev || prev &gt; 0xDBFF) {
    throw "Basso surrogato senza precedente surrogato elevato";
  }
  // Restituisce invece il carattere successivo (e incrementa)
  return [str.charAt(i + 1), i + 1];
}
</pre>

<h3 id="Correggere_charAt()_per_supportare_caratteri_non-Basic-Multilingual-Plane_(BMP)">Correggere <code>charAt()</code> per supportare caratteri non-Basic-Multilingual-Plane (BMP)</h3>

<p>Mentre l'esempio sopra può essere più frequentemente utile per coloro che desiderano supportare caratteri non BMP (dal momento che non richiede al chiamante di sapere dove potrebbe apparire un personaggio non BMP), nel caso in cui uno lo desideri, nella scelta di un personaggio per indice, per trattare le coppie surrogate all'interno di una stringa come i singoli caratteri che rappresentano, si può usare quanto segue:</p>

<pre class="brush: js">function fixedCharAt(str, idx) {
  var ret = '';
  str += '';
  var end = str.length;

  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
  while ((surrogatePairs.exec(str)) != null) {
    var li = surrogatePairs.lastIndex;
    if (li - 2 &lt; idx) {
      idx++;
    } else {
      break;
    }
  }

  if (idx &gt;= end || idx &lt; 0) {
    return '';
  }

  ret += str.charAt(idx);

 if (/[\uD800-\uDBFF]/.test(ret) &amp;&amp; /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) {
    // Vai avanti, poiché uno dei "personaggi" fa parte di una coppia di sostituti
    ret += str.charAt(idx + 1);
  }
  return ret;
}
</pre>

<h2 id="Specificazioni">Specificazioni</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Specificazioni</th>
   <th scope="col">Stato</th>
   <th scope="col">Commenti</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>definizione iniziale.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilità_con_il_browser">Compatibilità con il browser</h2>

<p class="hidden">La tabella di compatibilità in questa pagina è generata da dati strutturati. Se desideri contribuire ai dati, consulta <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e inviaci una richiesta di pull.</p>

<p>{{Compat("javascript.builtins.String.charAt")}}</p>

<h2 id="Guarda_anche">Guarda anche</h2>

<ul>
 <li>{{jsxref("String.prototype.indexOf()")}}</li>
 <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
 <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
 <li>{{jsxref("String.prototype.codePointAt()")}}</li>
 <li>{{jsxref("String.prototype.split()")}}</li>
 <li>{{jsxref("String.fromCodePoint()")}}</li>
 <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li>
</ul>