per il file UTF8 CSV quando si apre Excel e TexteDit

come @jlarson aggiornato con le informazioni che Mac è stato maggiore colpevole, potremmo ottenere maggiori informazioni. Ufficio per Mac ha almeno il 2011 e successivo, un supporto molto scarso per leggere i formati Unicode quando si importano file.

Il supporto UTF-8 sembra essere quasi inesistente, ho letto alcuni commenti su come funziona , mentre la maggior parte dice di no. Purtroppo non ho alcun Mac da provare. Quindi, di nuovo: i file stessi dovrebbero andare bene come UTF-8, ma l’importazione interrompe il processo.

Ho scritto un test rapido in JavaScript per esportare la percentuale di piccole e grandi sfucchiazioni UTF-16 sfuggiti, CON – / Senza BOM, ecc.

Il codice dovrebbe probabilmente essere refatturazzato ma dovrebbe andare bene per il test. Potrebbe funzionare meglio di UTF-8. Naturalmente, anche questo di solito significa maggiori trasferimenti di dati, poiché qualsiasi GLIFO ha due o quattro byte.

Puoi trovare un violino qui:

Nicode Esporta Fiddle del campione

Si prega di notare che non gestisce CSV in modo particolare. È principalmente destinato alla conversione pura all’URL dei dati con UTF-8, UTF-16 Big / Little Endian e +/- BOM. C’è un’opzione nel violino per sostituire le virgole con le linguette, ma penso che sarebbe una soluzione abbastanza difficile e fragile se funziona.

Normalmente è usato come:

// Initiateencoder = new DataEnc({ mime : 'text/csv', charset: 'UTF-16BE', bom : true});// Convert data to percent escaped textencoder.enc(data);// Get resultvar result = encoder.pay();

Ci sono due proprietà dei risultati dell’oggetto:

1.) encoder.lead

Questo è il tipo MIME, set di caratteri, ecc. Per l’URL dei dati. Costruito da opzioni passate all’iniziatore, oppure puoi anche dire .config({ ... new conf ...}).intro() per ricostruire.

data:

può specificare base64 , ma non c’è una conversione base64 (almeno non così lontana).

2.) encoder.buf

Questa è una stringa con la percentuale di dati sfuggiti.

La funzione .pay() Ritorna semplicemente 1.) e 2.) come uno.

Main Codice:

function DataEnc(a) { this.config(a); this.intro();}/** http://www.iana.org/assignments/character-sets/character-sets.xhtml* */DataEnc._enctype = { u8 : , // RFC-2781, Big endian should be presumed if none given u16be : , u16le : };DataEnc._BOM = { 'none' : '', 'UTF-8' : '%ef%bb%bf', // Discouraged 'UTF-16BE' : '%fe%ff', 'UTF-16LE' : '%ff%fe'};DataEnc.prototype = { // Basic setup config : function(a) { var opt = { charset: 'u8', mime : 'text/csv', base64 : 0, bom : 0 }; a = a || {}; this.charset = typeof a.charset !== 'undefined' ? a.charset : opt.charset; this.base64 = typeof a.base64 !== 'undefined' ? a.base64 : opt.base64; this.mime = typeof a.mime !== 'undefined' ? a.mime : opt.mime; this.bom = typeof a.bom !== 'undefined' ? a.bom : opt.bom; this.enc = this.utf8; this.buf = ''; this.lead = ''; return this; }, // Create lead based on config // data:,<data> intro : function() { var g = , c = this.charset || '', b = 'none' ; if (this.mime && this.mime !== '') g.Push(this.mime); if (c !== '') { c = c.replace(//g, '').toLowerCase(); if (DataEnc._enctype.u8.indexOf(c) > -1) { c = 'UTF-8'; if (this.bom) b = c; this.enc = this.utf8; } else if (DataEnc._enctype.u16be.indexOf(c) > -1) { c = 'UTF-16BE'; if (this.bom) b = c; this.enc = this.utf16be; } else if (DataEnc._enctype.u16le.indexOf(c) > -1) { c = 'UTF-16LE'; if (this.bom) b = c; this.enc = this.utf16le; } else { if (c === 'copy') c = ''; this.enc = this.copy; } } if (c !== '') g.Push('charset=' + c); if (this.base64) g.Push('base64'); this.lead = 'data:' + g.join(';') + ',' + DataEnc._BOM; return this; }, // Deliver pay : function() { return this.lead + this.buf; }, // UTF-16BE utf16be : function(t) { // U+0500 => %05%00 var i, c, buf = ; for (i = 0; i < t.length; ++i) { if ((c = t.charCodeAt(i)) > 0xff) { buf.Push(('00' + (c >> 0x08).toString(16)).substr(-2)); buf.Push(('00' + (c & 0xff).toString(16)).substr(-2)); } else { buf.Push('00'); buf.Push(('00' + (c & 0xff).toString(16)).substr(-2)); } } this.buf += '%' + buf.join('%'); // Note the hex array is returned, not string with '%' // Might be useful if one want to loop over the data. return buf; }, // UTF-16LE utf16le : function(t) { // U+0500 => %00%05 var i, c, buf = ; for (i = 0; i < t.length; ++i) { if ((c = t.charCodeAt(i)) > 0xff) { buf.Push(('00' + (c & 0xff).toString(16)).substr(-2)); buf.Push(('00' + (c >> 0x08).toString(16)).substr(-2)); } else { buf.Push(('00' + (c & 0xff).toString(16)).substr(-2)); buf.Push('00'); } } this.buf += '%' + buf.join('%'); // Note the hex array is returned, not string with '%' // Might be useful if one want to loop over the data. return buf; }, // UTF-8 utf8 : function(t) { this.buf += encodeURIComponent(t); return this; }, // Direct copy copy : function(t) { this.buf += t; return this; }};

Risposta precedente:

Non ho alcuna configurazione per replicare il tuo, ma se il tuo caso è lo stesso di @ Jlarson, il file risultante dovrebbe essere corretto.

Questa risposta è stata un po ‘lunga, (il tema divertente che dici?), Ma discute diversi aspetti della domanda, cosa sta succedendo (probabile) e come il controllo davvero ciò che sta accadendo in diversi modi.

TL; DR:

È probabile che il testo sia importato come ISO-8859-1, Windows-1252 o simile e non come UTF-8. Forza l’applicazione per leggere il file come UTF-8 importando o altri mezzi.

PS: L’UNISEAKER è un buon strumento per essere disponibile in questo viaggio.

La lunga strada intorno a

la forma “più facile” di essere sicuro al 100% di ciò che vedremo è utilizzare un editor esadecimale nel risultato. In alternativa, utilizzare , xxd o simile dalla riga di comando per vedere il file. In questo caso, la sequenza di byte dovrebbe essere quella dell’UTF-8 come consegnata dallo script.

come esempio, se prendiamo lo script Jlarson prendere il data Array:

data = , 

Si unisce nella stringa:

 name,city,state<newline> \u0500\u05E1\u0E01\u1054,seattle,washington<newline>

che si traduce da Unicode A:

 name,city,state<newline> Ԁסกၔ,seattle,washington<newline>

AS UTF-8 utilizza ASCII come base come base (byte con il bit più alto non stabilito è lo stesso di ASCII), l’unico Sequenza speciale nei dati del test è “ס ס ၔ” che a sua volta, è:

Code-point Glyph UTF-8---------------------------- U+0500 Ԁ d4 80 U+05E1 ס d7 a1 U+0E01 ก e0 b8 81 U+1054 ၔ e1 81 94

Guardando la discarica esadecimale del file scaricato:

0000000: 6e61 6d65 2c63 6974 792c 7374 6174 650a name,city,state.0000010: d480 d7a1 e0b8 81e1 8194 2c73 6561 7474 ..........,seatt0000020: 6c65 2c77 6173 6869 6e67 746f 6e0a le,washington.

Sulla seconda riga troviamo che corrisponde a quanto sopra:

0000010: d480 d7a1 e0b8 81 e1 8194 2c73 6561 7474 ..........,seatt | | | | | | | | | | | | | | +-+-+ +-+-+ +--+--+ +--+--+ | | | | | | | | | | | | | | | | Ԁ ס ก ၔ , s e a t t

Nessuno degli altri caratteri viene distrutto neanche.

Fai test simili se vuoi. Il risultato dovrebbe essere il simile.

per campione fornito â € œat, â € œ

Possiamo anche dare un’occhiata al campione fornito nella domanda. È probabile che si supponga che il testo sia rappresentato in Excel / TextEDit sulla pagina del codice 1252.

per citare Wikipedia in Windows-1252:

Windows-1252 o CP-1252 è una codifica dei caratteri dell’alfabeto latino, utilizzato per impostazione predefinita nei componenti legacy di Microsoft Windows in inglese e alcune altre lingue occidentali. È una versione all’interno del gruppo di pagine del codice di Windows. Nei pacchetti in lattice, sei definito “Ansinew”.

Recupero dei byte originali

Per tradurlo nel suo modulo originale, possiamo vedere la progettazione della pagina del codice, da dove otteniamo:

• U è l’abbreviazione di unicode
• T è l’abbreviazione tradotta

ad esempio:

â => Unicode 0xe2 => CP-1252 0xe2” => Unicode 0x201d => CP-1252 0x94€ => Unicode 0x20ac => CP-1252 0x80

Casi Speciali AS 9d Non ha un punto di codice corrispondente su CP-1252, li abbiamo semplicemente copiati direttamente.

Nota: se si nota la stringa danneggiata che copia il testo in Un file e fare una discarica esadecimale, salvare il file, ad esempio, con la codifica UTF-16 per ottenere valori Unicode poiché sono rappresentati nella tabella. Per esempio. In Vim:

set fenc=utf-16# Orset fenc=ucs-2

byte to utf-8

Quindi combiniamo il risultato, il T.Hex, in UTF-8. Nelle sequenze UTF-8, i byte sono rappresentati da un byte principale ci dice quanti byte successivi formano il glifo. Ad esempio, se un byte ha il valore binario 110x xxxx, sappiamo che questo byte e il seguente rappresentano un punto di codice. Un totale di due. 1110 xxxx Dicci che sono tre e così via. I valori ASCII non hanno il bit di alto livello, quindi qualsiasi byte corrisponde a 0xxx xxxx è indipendente. Un totale di un byte.

0xe2 = 1110 0010compartimiento => 3 bytes => 0xe28094 (em-dash) - 0x2c = 0010 1100compartimiento => 1 byte => 0x2c (coma), 0x2c = 0010 0000compartimiento => 1 byte => 0x20 (espacio) 0xe2 = 1110 0010compartimiento => 3 bytes => 0xe2809d (d-derecha) ” 0x2c = 0010 1100compartimiento => 1 byte => 0x2c (coma), 0x2c = 0010 0000compartimiento => 1 byte => 0x20 (espacio) 0xe2 = 1110 0010compartimiento => 3 bytes => 0xe2809c (izquierda-dq) "

Conclusione; La stringa originale UTF-8 era:

—, ”, "

Restituzione

Possiamo anche fare diversamente. La catena originale come byte:

UTF-8: e2 80 94 2c 20 e2 80 9d 2c 20 e2 80 9c

Valori corrispondenti in CP-1252:

e2 => â80 => €94 => ”2c => ,20 => <space>...

E così via, risultato:

Importazione di MS Excel

In altre parole: il problema in questione potrebbe essere come Importa file di testo UTF-8 in MS Excel e alcune altre applicazioni. In Excel questo può essere fatto in diversi modi.

• Metodo 1:

Non salvare il file con un’estensione riconosciuta dall’applicazione, come .csv o .txt, ma omettilo completamente o inventare qualcosa.

Come esempio, salva il file come "testfile", senza estensione. Quindi, in Excel, apri il file, confermare che vogliamo davvero aprire questo file e voilà riceviamo l’opzione di codifica. Selezionare UTF-8 e il file deve essere letto correttamente.

• Metodo 2:

Utilizzare i dati di importazione anziché aprendo il file. Qualcosa come:

Data -> Import External Data -> Import Data

Selezionare la codifica e procedere.

Controllare che Excel e la sorgente selezionata supportino effettivamente GLIFO

Possiamo anche testare la compatibilità delle fonti per i personaggi Unicode utilizzando gli Appunti, a volte, più amichevole. Ad esempio, copia il testo di questa pagina in Excel:

• Pagina con punti di codice U + 0E00 A U + 0EFF

Se c’è supporto per i punti di codice , il testo deve essere visualizzato correttamente.

linux

in Linux, che è principalmente UTF-8 nell’area dell’utente, questo non dovrebbe essere un problema. Utilizzando Calc Calc, Vim, ecc., Mostra i file reso correttamente.

Perché funziona (o dovrebbe)

encodeuri degli stati delle specifiche, (leggi anche SEC-15.1. ):

La funzione Encodeuri calcola una nuova versione di un URI in cui ogni istanza di determinati caratteri viene sostituita da una, due, tre o quattro sequenze di scarico rappresentando la codifica UTF-8 del carattere.

Possiamo semplicemente dimostrare questo nella nostra console, ad esempio dicendo:

Quando ti registriamo, le sequenze di scarico sono uguali a quelle del precedente dump esadecimale:

%D4%80%D7%A1%E0%B8%81%E1%81%94 (encodeURI in log) d4 80 d7 a1 e0 b8 81 e1 81 94 (hex-dump of file)

o Test Un codice a 4 byte:

se ciò non è conforme

Se nessuno di questo si applica potrebbe aiutare se si aggiunge

1. Esempio di ingresso previsto vs output danneggiato, (copia pasta).
2. Esempio di dolore esadecimale di ACH Ivo di risultati originali dei dati.