Existe uma maneira para ver se um personagem está usando 1 ou 2 bytes em Delphi 2009?




Delphi 2009 mudou seu tipo string para usar 2 bytes para representar um personagem, que permite suporte para conjuntos de unicode de caracteres. Agora, quando você começa sizeof (string), obtém comprimento (String) * sizeof (char). Sizeof (char) actualmente a ser 2. 


O que eu estou interessado em saber se alguém sabe de uma maneira que em um personagem por base caráter é possível descobrir se ele iria caber em um único byte, por exemplo, descobrir se um char é ASCII ou Unicode.


O que eu estou principalmente interessado em saber, é antes de minha corda vai para um banco de dados (Oracle, Documentum) quantos bytes a corda irá utilizar-se.


Precisamos ser capazes de impor limites antes da mão e, idealmente (como temos uma grande base instalada) sem ter que alterar o banco de dados. Se um campo de cadeia permite que 12 bytes, em delphi 2009, uma cadeia de comprimento 7 sempre mostrar como a utilização de 14 bytes, embora uma vez que chegou ao db só usaria 7 se ascii ou 14 se double byte, ou algures no meio se um mistura.
Você pode verificar o valor do caráter:



```
if ord(c) < 128 then
    // is an ascii character

```
<h2>7 bits ascii?</h2><p>se o seu tardis acabou de chegar em 1963, e você quer apenas o 7 bit imprimível ascii chars, você pode copiar tudo de 0 a 31 e 127 a 255 com isto:</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f-\xff]/', '', $string); </code></pre><p>ele corresponde a qualquer coisa no intervalo de 0 a 31, 127 a 255 e remove-o. </p><h2>8 bits estendido ascii?</h2><p>você caiu em um time machine hot tub, e você está de volta nos anos oitenta. se você tem alguma forma de ascii de 8 bits, então você pode querer manter os caracteres no intervalo de 128-255. um ajuste fácil - basta olhar para 0-31 e 127</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f]/', '', $string); </code></pre><h2>utf-8?</h2><p>ah, bem vindo de volta ao século 21. se você tem uma string codificada em utf-8, então o <code>/u</code> <a href="http://php.net/manual/en/reference.pcre.pattern.modifiers.php">modifier</a> pode ser usado no regex</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f]/u', '', $string); </code></pre><p>isso apenas remove 0-31 e 127. isso funciona em ascii e utf-8 porque ambos compartilham o <a href="http://www.fileformat.info/info/charset/utf-8/list.htm">mesmo intervalo de conjunto de controles</a> (como observado por mgutt abaixo). estritamente falando, isso funcionaria sem o modificador <code>/u</code>. mas isso facilita a vida se você quiser remover outros caracteres ...</p><p>se você está lidando com unicode, existem <a href="https://stackoverflow.com/questions/3770117/what-is-the-range-of-unicode-printable-characters">potencialmente muitos elementos não-imprimíveis</a> , mas vamos considerar um simples: <a href="https://unicode-table.com/en/00a0/">no-break space (u + 00a0)</a> </p><p>em uma string utf-8, isso seria codificado como <code>0xc2a0</code>. você pode procurar e remover essa sequência específica, mas com o modificador <code>/u</code> no lugar, você pode simplesmente adicionar <code>\xa0</code> à classe de caractere:</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f\xa0]/u', '', $string); </code></pre><h2>adenda: e sobre str\_replace?</h2><p>preg\_replace é bastante eficiente, mas se você está fazendo esta operação muito, você pode construir uma matriz de caracteres que você deseja remover, e usar str\_replace como observado por mgutt abaixo, por exemplo.</p><pre><code>//build an array we can re-use across several operations $badchar=array( // control characters chr(0), chr(1), chr(2), chr(3), chr(4), chr(5), chr(6), chr(7), chr(8), chr(9), chr(10), chr(11), chr(12), chr(13), chr(14), chr(15), chr(16), chr(17), chr(18), chr(19), chr(20), chr(21), chr(22), chr(23), chr(24), chr(25), chr(26), chr(27), chr(28), chr(29), chr(30), chr(31), // non-printing characters chr(127) ); //replace the unwanted chars $str2 = str\_replace($badchar, '', $str); </code></pre><p>intuitivamente, isso parece que seria rápido, mas nem sempre é o caso, você deve definitivamente comparar para ver se você economiza alguma coisa. fiz alguns benchmarks em vários comprimentos de string com dados aleatórios, e esse padrão surgiu usando o php 7.0.12</p><pre><code> 2 chars str\_replace 5.3439ms preg\_replace 2.9919ms preg\_replace is 44.01% faster 4 chars str\_replace 6.0701ms preg\_replace 1.4119ms preg\_replace is 76.74% faster 8 chars str\_replace 5.8119ms preg\_replace 2.0721ms preg\_replace is 64.35% faster 16 chars str\_replace 6.0401ms preg\_replace 2.1980ms preg\_replace is 63.61% faster 32 chars str\_replace 6.0320ms preg\_replace 2.6770ms preg\_replace is 55.62% faster 64 chars str\_replace 7.4198ms preg\_replace 4.4160ms preg\_replace is 40.48% faster 128 chars str\_replace 12.7239ms preg\_replace 7.5412ms preg\_replace is 40.73% faster 256 chars str\_replace 19.8820ms preg\_replace 17.1330ms preg\_replace is 13.83% faster 512 chars str\_replace 34.3399ms preg\_replace 34.0221ms preg\_replace is 0.93% faster 1024 chars str\_replace 57.1141ms preg\_replace 67.0300ms str\_replace is 14.79% faster 2048 chars str\_replace 94.7111ms preg\_replace 123.3189ms str\_replace is 23.20% faster 4096 chars str\_replace 227.7029ms preg\_replace 258.3771ms str\_replace is 11.87% faster 8192 chars str\_replace 506.3410ms preg\_replace 555.6269ms str\_replace is 8.87% faster 16384 chars str\_replace 1116.8811ms preg\_replace 1098.0589ms preg\_replace is 1.69% faster 32768 chars str\_replace 2299.3128ms preg\_replace 2222.8632ms preg\_replace is 3.32% faster </code></pre><p>os tempos próprios são para 10000 iterações, mas o que é mais interessante são as diferenças relativas. até 512 chars, eu estava vendo preg\_replace sempre vencer. no intervalo de 1-8kb, o str\_replace tinha um edge marginal. </p><p>eu pensei que era um resultado interessante, então incluí-lo aqui. <em>o importante é não pegar este resultado e usá-lo para decidir qual método utilizar, mas para fazer benchmark com seus próprios dados e depois decidir.</em></p> <p>este é um assunto amplamente debatido. uma das melhores maneiras pelas quais eu já vi isso explicado é a partir da apresentação <a href="http://www.scribd.com/doc/32311867/design-for-developers">design para desenvolvedores: fazendo com que seus front-end sugem menos</a> by idan gazit.</p><p>este teve o seguinte slide: <img src="https://i.stack.imgur.com/bvose.jpg" alt="alt text"> este é um texto de 16 pixels em uma tela normal e um texto de 12 pontos em um livro. a mensagem é que 12pt é excelente para um livro, mas geralmente também é mantido muito mais próximo do leitor do que de uma tela. levando em consideração a distância, os 16 pixels na tela e os 12 pontos no livro parecem ter o mesmo tamanho. <strong> 12pt no papel = 16px na tela </strong></p><p>existem todos os tipos de exceções, nas quais o texto menor é preferido. mas, para otimizar a legibilidade de textos mais longos, concordo com 16px.</p><p>é recomendável alterar as unidades escalonáveis ​​como <em> em</em> ou <em>%</em> do que as unidades de tamanho fixo como <em> pt</em> ou <em>px</em>. leia mais: <a href="http://kyleschaeffer.com/development/css-font-size-em-vs-px-vs-pt-vs/">tamanho da fonte css: em vs. px vs. pt vs. percent</a> </p> <p>lidar com vários níveis de citação (na verdade, vários níveis de análise/interpretação) pode ser complicado. isso ajuda a manter algumas coisas em mente:</p><ul> <li>cada “nível de citação” pode envolver potencialmente uma linguagem diferente.</li> <li>as regras de cotação variam de acordo com o idioma.</li> <li>ao lidar com mais de um ou dois níveis aninhados, geralmente é mais fácil trabalhar "de baixo para cima" (ou seja, do interior para o exterior).</li> </ul><h1>níveis de citação</h1><p>vejamos seus comandos de exemplo.</p><pre><code>pgrep -fl java | grep -i datanode | awk '{print $1}' </code></pre><p>seu primeiro exemplo de comando (acima) usa quatro idiomas: seu shell, o regex em <em> pgrep </em>, o regex em <em> grep </em> (que pode ser diferente da linguagem regex em <em> pgrep </em>) e <em> awk </em>. existem dois níveis de interpretação envolvidos: o shell e um nível após o shell para cada um dos comandos envolvidos. existe apenas um nível explícito de citação (shell citação em <em> awk </em>).</p><pre><code>ssh host … </code></pre><p>em seguida, você adicionou um nível de <em> ssh </em> no topo. este é efetivamente outro nível de shell: <em> ssh </em> não interpreta o comando em si, ele o entrega a um shell na extremidade remota (via (por exemplo) <code>sh -c …</code>) e que shell interpreta a string.</p><pre><code>ssh host "sudo su user -c …" </code></pre><p>então, você perguntou sobre a adição de outro nível de shell no meio usando <em> su </em> (via <em> sudo </em>, que não interpreta seus argumentos de comando, portanto, podemos ignorá-lo). neste ponto, você tem três níveis de aninhamento em andamento (<em> awk </em> → shell, shell → shell (<em> ssh </em>), shell → shell (<em> su user -c </em>), então aconselho usar a abordagem “de baixo para cima”. vou assumir que seus shells são compatíveis com bourne (por exemplo <em> sh </em>, <em> ash </em> , <em> traço </em>, <em> ksh </em>, <em> bash </em>, <em> zsh </em>, etc.). algum outro tipo de shell (<em> fish </em>, <em> rc </em>, etc.) pode exigir sintaxe diferente, mas o método ainda se aplica.</p><h1>debaixo para cima</h1><ol> <li>formule a string que deseja representar no nível mais interno.</li> <li>selecione um mecanismo de citações do repertório de citações do idioma seguinte.</li> <li>cite a string desejada de acordo com o mecanismo de cotação selecionado. <ul> <li>freqüentemente, há muitas variações de como aplicar qual mecanismo de cotação. fazer manualmente é geralmente uma questão de prática e experiência. ao fazer isso de forma programática, geralmente é melhor escolher o mais fácil de acertar (geralmente o “mais literal” (menos escapes)).</li> </ul> </li> <li>opcionalmente, use a string entre aspas resultante com código adicional.</li> <li>se você ainda não atingiu o nível desejado de citação/interpretação, pegue a string entre aspas resultante (mais qualquer código adicionado) e use-a como string inicial na etapa 2.</li> </ol><h1>a semântica das citações varia</h1><p>o que se deve ter em mente aqui é que cada idioma (nível de citação) pode fornecer semânticas ligeiramente diferentes (ou mesmo semânticas drasticamente diferentes) para o mesmo personagem de citação.</p><p>a maioria das linguagens tem um mecanismo de citação “literal”, mas eles variam exatamente em quão literais são. a aspa simples de shells do tipo bourne é literal (o que significa que você não pode usá-la para citar um caractere de aspas simples). outras linguagens (perl, ruby) são menos literais porque interpretam <strong>algumas</strong> sequências de barra invertida dentro de regiões entre aspas simples não literalmente (especificamente, <code>\\</code> e <code>\'</code> resulta em <code>\</code> e <code>'</code>, mas outras sequências de barra invertida são, na verdade, literais).</p><p>você terá que ler a documentação de cada um de seus idiomas para entender suas regras de cotação e a sintaxe geral.</p><h1>seu exemplo</h1><p>o nível mais interno do seu exemplo é um programa <em> awk </em>.</p><pre><code>{print $1} </code></pre><p>você vai incorporar isso em uma linha de comando do shell:</p><pre><code>pgrep -fl java | grep -i datanode | awk … </code></pre><p>precisamos proteger (no mínimo) o espaço e o <code>$</code> no programa <em> awk </em>. a escolha óbvia é usar aspas simples no shell em todo o programa.</p><ul> <li><code>'{print $1}'</code></li> </ul><p>no entanto, existem outras opções:</p><ul> <li><code>{print\ \$1}</code> escape diretamente do espaço e <code>$</code></li> <li><code>{print' $'1}</code> aspas simples apenas o espaço e <code>$</code></li> <li><code>"{print \$1}"</code> aspas duplas o todo e escapar de <code>$</code></li> <li><code>{print" $"1}</code> aspas duplas apenas o espaço e <code>$</code><br> isso pode estar distorcendo um pouco as regras (sem escape <code>$</code> no final de uma string entre aspas duplas é literal), mas parece funcionar na maioria dos shells.</li> </ul><p>se o programa usasse uma vírgula entre as chaves de abertura e fechamento, também precisaríamos citar ou escapar a vírgula ou as chaves para evitar a “expansão da chave” em alguns shells.</p><p>nós escolhemos <code>'{print $1}'</code> e incorporá-lo ao resto do “código” shell:</p><pre><code>pgrep -fl java | grep -i datanode | awk '{print $1}' </code></pre><p>em seguida, você queria executar isso via <em> su </em> e <em> sudo </em>.</p><pre><code>sudo su user -c … </code></pre><p><code>su user -c …</code> é como <code>some-shell -c …</code> (exceto rodando em algum outro uid), então <em> su </em> apenas adiciona outro nível de shell. <em> sudo </em> não interpreta seus argumentos, então não adiciona nenhum nível de citação.</p><p>precisamos de outro nível de shell para nossa string de comando. podemos escolher aspas simples novamente, mas temos que dar tratamento especial às aspas simples existentes. a maneira usual é assim:</p><pre><code>'pgrep -fl java | grep -i datanode | awk '\''{print $1}'\' </code></pre><p>existem quatro strings aqui que o shell irá interpretar e concatenar: a primeira string entre aspas simples (<code>pgrep … awk</code>), uma aspa simples de escape, o programa de aspas simples <em> awk </em>, outra aspa simples de escape.</p><p>existem, é claro, muitas alternativas:</p><ul> <li><code>pgrep\ -fl\ java\ \|\ grep\ -i\ datanode\ \|\ awk\ \'{print\ \$1}</code> fuja de tudo que é importante</li> <li><code>pgrep\ -fl\ java\|grep\ -i\ datanode\|awk\ \'{print\$1}</code> o mesmo, mas sem espaços em branco supérfluos (mesmo no programa <em> awk </em>!)</li> <li><code>"pgrep -fl java | grep -i datanode | awk '{print \$1}'"</code> aspas duplas, escape de <code>$</code></li> <li><code>'pgrep -fl java | grep -i datanode | awk '"'"'{print \$1}'"'"</code> sua variação; um pouco mais longo do que o normal devido ao uso de aspas duplas (dois caracteres) em vez de escapes (um caractere)</li> </ul><p>usar citações diferentes no primeiro nível permite outras variações neste nível:</p><ul> <li><code>'pgrep -fl java | grep -i datanode | awk "{print \$1}"'</code></li> <li><code>'pgrep -fl java | grep -i datanode | awk {print\ \$1}'</code></li> </ul><p>incorporar a primeira variação na linha de comando <em> sudo </em>/* su * fornece o seguinte:</p><pre><code>sudo su user -c 'pgrep -fl java | grep -i datanode | awk '\''{print $1}'\' </code></pre><p>você pode usar a mesma string em qualquer outro contexto de nível de shell (por exemplo, <code>ssh host …</code>).</p><p>em seguida, você adicionou um nível de <em> ssh </em> no topo. este é efetivamente outro nível de shell: <em> ssh </em> não interpreta o comando em si, mas o entrega a um shell na extremidade remota (via (por exemplo) <code>sh -c …</code>) e que shell interpreta a string.</p><pre><code>ssh host … </code></pre><p>o processo é o mesmo: pegue a string, escolha um método de cotação, use-a, incorpore-a.</p><p>usando aspas simples novamente:</p><pre><code>'sudo su user -c '\''pgrep -fl java | grep -i datanode | awk '\'\\\'\''{print $1}'\'\\\' </code></pre><p>agora, existem onze strings que são interpretadas e concatenadas: <code>'sudo su user -c '</code>, aspas simples com escape, <code>'pgrep … awk '</code>, aspas simples de escape, barra invertida de escape, duas aspas simples de escape, o programa entre aspas simples <em> awk </em>, aspas simples de escape, barra invertida de escape e um aspas simples com escape final.</p><p>a forma final é parecida com esta:</p><pre><code>ssh host 'sudo su user -c '\''pgrep -fl java | grep -i datanode | awk '\'\\\'\''{print $1}'\'\\\' </code></pre><p>é um pouco complicado digitar à mão, mas a natureza literal da citação única do shell torna mais fácil automatizar uma ligeira variação:</p><pre><code>#!/bin/sh sq() { # single quote for bourne shell evaluation # change ' to '\'' and wrap in single quotes. # if original starts/ends with a single quote, creates useless # (but harmless) '' at beginning/end of result. printf '%s\n' "$*" | sed -e "s/'/'\\\\''/g" -e 1s/^/\'/ -e \$s/\$/\'/ } # some shells (ksh, bash, zsh) can do something similar with %q, but # the result may not be compatible with other shells (ksh uses $'...', # but dash does not recognize it). # # sq() { printf %q "$*"; } ap='{print $1}' s1="pgrep -fl java | grep -i datanode | awk $(sq "$ap")" s2="sudo su user -c $(sq "$s1")" ssh host "$(sq "$s2")" </code></pre> olá @titah, bem-vinda à comunidade. 

normalmente um sms tem até 160 caracteres, contudo ao acrescentar um símbolo (/, [, ], €, por exemplo) estes representam dois caracteres e diminuem o tamanho máximo do sms para 140. caso sejam utilizados caracteres especiais (ç, â, ã, por exemplo) a mensagem fica reduzida a um limite de 70 caracteres.

isto não está relacionado com o tarifário tudo, mas com a própria tecnologia que é utilizada pelo sms. <p>ícones grandes são melhores, geralmente, porque facilitam a operação do aplicativo pelo usuário. dito isso, a capacidade de personalização é uma meta agradável, para que usuários avançados possam reduzir o tamanho dos ícones (ou usar atalhos de teclado) para ter uma visão maior dos dados.</p><p>geralmente, os ícones variam de 16x16 a 32x32 e 48x48. lembre-se também de que o tamanho <em>relativo</em> dos ícones deve estabelecer a importância relativa da funcionalidade; portanto, mesmo se você aumentar o tamanho de todos os seus ícones, garanta que as funções mais importantes ganhem destaque por meio de um tamanho maior (para referência, consulte a barra de ferramentas 'ribbon' no ms office 2007/2010).</p> <p>para suportar mais de 4 gb de memória windows usa <a href="http://en.wikipedia.org/wiki/physical\_address\_extension">extensão de endereço físico</a> (pae). ele usa tabelas de paginação para mapear a memória maior que 4 gb. ao fazer isso, o tamanho do endereço físico é aumentado para 36 bits, ou 64 gb. pae é usado em sistema operacional de 64 bits também; neste caso, o tamanho máximo é dobrado para 128 gb.</p><p>este método significa que cada processo ainda está limitado a um máximo de 4 gb de memória.</p> olá victor, tudo bem?o problema do seu código é que você está declarando o vetor de strings de maneira incorreta. o certo é usar assim: char nome[5][100]; onde o primeiro par de colchetes é o ta... <p>encontrei uma solução para o seu problema.</p><p>baseado em <a href="https://stackoverflow.com/a/8798355/637284">this so answer</a> eu fiz um programa que usa classes de caracteres regex para procurar por letras que possam ter modificadores opcionais. ele divide sua string em caracteres simples (combinados, se necessário) e os coloca em uma lista:</p><pre><code>import java.util.*; import java.lang.*; import java.util.regex.*; class main { public static void main (string[] args) { string s="குமார்"; list&lt;string&gt; characters=new arraylist&lt;string&gt;(); pattern pat = pattern.compile("\\p{l}\\p{m}*"); matcher matcher = pat.matcher(s); while (matcher.find()) { characters.add(matcher.group()); } // test if we have the right characters and length system.out.println(characters); system.out.println("string length: " + characters.size()); } } </code></pre><p>onde <code>\\p{l}</code> significa uma letra unicode e <code>\\p{m}</code> significa uma marca unicode.</p><p>a saída do trecho é:</p><pre><code>கு மா ர் string length: 3 </code></pre><p>veja <a href="https://ideone.com/apkapn">https://ideone.com/apkapn</a> para uma demonstração funcional</p><hr><p><strong>edit</strong></p><p>eu agora chequei meu regex com todas as cartas tamil válidas tiradas das tabelas em <a href="http://en.wikipedia.org/wiki/tamil\_script">http://en.wikipedia.org/wiki/tamil\_script</a> . descobri que com o regex atual não capturamos todas as letras corretamente (cada letra na última linha da tabela composta de grantha é dividida em duas letras), então refinei meu regex para a seguinte solução:</p><pre><code>pattern pat = pattern.compile("\u0b95\u0bcd\u0bb7\\p{m}?|\\p{l}\\p{m}?"); </code></pre><p>com este padrão em vez do acima, você deve ser capaz de dividir sua sentença em cada letra tamil válida (desde que a tabela da wikipédia esteja completa).</p><p>o código que usei para verificar é o seguinte:</p><pre><code>string s = "ஃஅஆஇஈஉஊஎஏஐஒஓஔக்ககாகிகீகுகூகெகேகைகொகோகௌங்ஙஙாஙிஙீஙுஙூஙெஙேஙைஙொஙோஙௌச்சசாசிசீசுசூசெசேசைசொசோசௌஞ்ஞஞாஞிஞீஞுஞூஞெஞேஞைஞொஞோஞௌட்டடாடிடீடுடூடெடேடைடொடோடௌண்ணணாணிணீணுணூணெணேணைணொணோணௌத்ததாதிதீதுதூதெதேதைதொதோதௌந்நநாநிநீநுநூநெநேநைநொநோநௌப்பபாபிபீபுபூபெபேபைபொபோபௌம்மமாமிமீமுமூமெமேமைமொமோமௌய்யயாயியீயுயூயெயேயையொயோயௌர்ரராரிரீருரூரெரேரைரொரோரௌல்லலாலிலீலுலூலெலேலைலொலோலௌவ்வவாவிவீவுவூவெவேவைவொவோவௌழ்ழழாழிழீழுழூழெழேழைழொழோழௌள்ளளாளிளீளுளூளெளேளைளொளோளௌற்றறாறிறீறுறூறெறேறைறொறோறௌன்னனானினீனுனூனெனேனைனொனோனௌஶ்ஶஶாஶிஶீஶுஶூஶெஶேஶைஶொஶோஶௌஜ்ஜஜாஜிஜீஜுஜூஜெஜேஜைஜொஜோஜௌஷ்ஷஷாஷிஷீஷுஷூஷெஷேஷைஷொஷோஷௌஸ்ஸஸாஸிஸீஸுஸூஸெஸேஸைஸொஸோஸௌஹ்ஹஹாஹிஹீஹுஹூஹெஹேஹைஹொஹோஹௌக்ஷ்க்ஷக்ஷாக்ஷிக்ஷீக்ஷுக்ஷூக்ஷெக்ஷேக்ஷைஷொக்ஷோஷௌ"; list&lt;string&gt; characters = new arraylist&lt;string&gt;(); pattern pat = pattern.compile("\u0b95\u0bcd\u0bb7\\p{m}?|\\p{l}\\p{m}?"); matcher matcher = pat.matcher(s); while (matcher.find()) { characters.add(matcher.group()); } system.out.println(characters); system.out.println(characters.size() == 325); </code></pre> <p>não tem muita diferença nao. o que muda é o retorno ser int ou integer. 
agora é uma questão pessoal.. eu não uso apenas objetos. em muitos casos eu uso primitivos.</p> <p><strong> bluetooth vs bluetooth </strong></p><p>bluetooth deve lidar com isso razoavelmente bem. o <a href="http://cse.iitkgp.ac.in/~bivasm/sp\_notes/bluetooth\_v1.pdf">camada de rádio bluetooth</a> , na verdade, a frequência lúpulo mais de 79 freqüências diferentes se espalham 1mhz. mesmo com muitas pessoas usando-os perto umas das outras, eles não devem perceber qualquer degradação, e qualquer coisa que eles notarem serão semelhantes à queda de pacotes ocasionais sobre celulares que não impede a comunicação. eles se fecham perto da mesma taxa, e recuando quando sentem a interferência, o que significa que vários dispositivos bluetooth próximos uns aos outros serão sincronizados de forma perfeitamente para que eles estejam em freqüências diferentes o tempo todo com poucas colisões.</p><p><strong> bluetooth vs wifi </strong></p><p>leia este <a href="http://www.hp.com/sbso/wireless/images/wifiblue.pdf">documento hp</a> para aprender os detalhes sobre o wifi e a coexistência bluetooth. para resumir:</p><p><strong> interferência bluetooth do wifi </strong></p><p>em suma, um único canal wifi interferirá em cerca de 22 dos 79 canais de pulsão de bluetooth. em comunicações de voz, os pacotes simplesmente serão descartados, mas os esquemas de modulação são diferentes, então isso deve ocorrer apenas onde o ponto de acesso tem um sinal muito forte.</p><p><strong> interferência wifi de bluetooth </strong></p><p>o ponto de acesso, por sua vez, desacelerará as comunicações, pois vê a interferência bluetooth. devido a protocolos tcp/ip robustos, a maioria dos seus usuários não percebe nada além de acesso mais lento, no entanto, algum tráfego em tempo real (voip, vídeo, etc) pode sofrer uma perda de pacote ligeiramente maior, uma vez que eles não serão repetidos se forem perdidos.</p><p>o bluetooth ajusta automaticamente a potência de rádio de acordo com suas necessidades, isso significa que, se o usuário estiver muito próximo (dentro de alguns pés) do telefone, o sinal bluetooth será muito baixo e, portanto, interferirá com muito pouco. se eles atravessam o escritório, o rádio bombeia mais poder e interfere em muitos outros rádios nas proximidades.</p><p>o teste mostrará se este é um problema em sua situação.</p><p><strong> solução alternativa: 802.11 um ponto de acesso 5.8ghz </strong></p><p>você pode considerar usar o 802.11 a para sua rede sem fio, que não interfere no bluetooth, sendo na banda 5.8ghz. a/b/g/n tudo em um wi-fi cartões são comuns e baratos agora, então há pouco custo extra em indo esta rota.</p><p><strong> em resumo </strong></p><p>sim, você <em> will</em> experimente a interferência mensurável. <em> no entanto</em> pode não impactar visivelmente sua operação dependendo de muitos, muitos fatores, como a utilização de rede, utilização de bluetooth, força de rádio, material de cubículo, construção de microondas, etc, etc, , etc.</p><p>em muitos casos, essa situação funcionaria bem, especialmente se você tiver poucos usuários de baixa largura de banda na rede sem fio, e apenas algumas pessoas conversando no bluetooth de uma só vez.</p><p>em alguns casos, independentemente de outros parâmetros, você encontrará a situação insuportável - como com os mais recentes 802.11 n rádios, que obrigam vários canais e, portanto, saturar o espectro de 2.4ghz se os usuários estiverem usando todos os 450mbps (ou 600mbps, se esses rádios ainda estiverem. ..) e você tem mais de 30 pessoas no bluetooth dentro de uma única sala de conferência com o ap no meio.</p><p>-adão</p>