TextService

Mostrar obsoleto

*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.

Não criável
Serviço
Não replicado

O TextService é um serviço internamente responsável por lidar com o display de texto no jogo.

Esta classe tem duas funções de membro:

A função TextService:GetTextSize() dá aos desenvolvedores a capacidade de calcular o espaço necessário para uma string de texto específica com formatação especificada, retornando um tamanho de pixel de Vector2.

A função é necessária para filtrar adequadamente o texto especificado pelo usuário (como mensagens de chat ou outras entradas) aos interesses da segurança do usuário.Desenvolvedores que não estão usando o padrão Roblox Chat ou permitindo que os usuários insiram texto de outra forma devem usar essa função.

Resumo

Métodos

Propriedades

Métodos

GetTextSize

Calcula as dimensões Vector2 de (em pixels) que serão usadas com texto ao usar os parâmetros de formatação e restrições de tamanho especificados.

Observe, o parâmetro fontSize não aceitará o Enum.FontSize Enum.Em vez disso, o tamanho inteiro correspondente ao Enum.FontSize Enum deve ser usado.Isso não é igual ao valor do Enum.FontSize Enum.Por exemplo, para a fonte Tamanho11 , o inteiro 11 deve ser usado.

Essa função é uma alternativa útil à propriedade TextLabel.TextBounds da TextLabel e TextButton objetos.Usar a propriedade TextLabel.TextBounds para calcular o texto das dimensões requer geralmente é impracticável, pois requer que um objeto TextLabel seja criado.

Com GetTextSize, as dimensões necessárias por uma determinada string de texto em uma determinada TextLabel ou TextButton podem ser calculadas antes que qualquer objeto seja criado ou configurarpropriedade de texto.

Recomenda-se que os desenvolvedores adicionem um pixel de espaçamento ao resultado para garantir que nenhum texto seja desligado.

Este método é limitado apenas a fontes que estão listadas em Enum.Font. Para obter acesso a mais fontes, você pode usar TextService:GetTextBoundsAsync() em vez disso.

Parâmetros

string: string

A string para a qual o tamanho do texto deve ser calculado.

Valor Padrão: ""
fontSize: number

O inteiro que representa o tamanho da fonte usado.

Valor Padrão: ""
font: Enum.Font

A fonte usada.

Valor Padrão: ""
frameSize: Vector2

O TextLabel.AbsoluteSize do objeto de texto a ser usado. Necessário para calcular como o texto vai se enrolar.

Valor Padrão: ""

Devolução

O tamanho do espaço necessário, em pixels, pela string com o formato especificado.

Amostras de código

This example showcases a possible usage of the GetTextSize function.

It computes the possible Vector2 dimensions (in pixels) of the string "Hello World" when the font size is 12, the font size SourceSans and the frame size is (1,1).

The expected return of this function is the Vector2 value 9, 13.

TextService: Getting the Text Size

local TextService = game:GetService("TextService")
local function getTextBounds()
local message = "Hello World"
local size = Vector2.new(1, 1)
local bounds = TextService:GetTextSize(message, 12, "SourceSans", size)
return bounds + Vector2.new(1, 1)
end
print(getTextBounds())

FilterAndTranslateStringAsync

Rendimentos

A tradução de bate-papo não é suportada na conversa legada.Este método não é mais suportado e não deve ser usado.Todas as chamadas retornam um Objetovazio.Traduzir mensagens de chat está disponível apenas via TextChatService .

Parâmetros

stringToFilter: string
Valor Padrão: ""
fromUserId: number
Valor Padrão: ""
targetLocales: Array
Valor Padrão: ""
Valor Padrão: "PrivateChat"

Devolução

FilterStringAsync

Rendimentos

A função FilterStringAsync filtra uma string recebida de um usuário, usando o TextService, e retorna um TextFilterResult que pode ser usado para distribuir o texto corretamente filtrado de acordo.

Uso

Este método deve ser chamado uma vez a cada vez que um usuário envia uma mensagem.Não armazene os resultados dessa função e reutilize-os para mensagens separadas.Se um usuário enviar o mesmo texto várias vezes, esse método deve ser chamado novamente cada vez que a mensagem for enviada.Se os resultados forem armazenados em cache e reutilizados na detecção de spam e em muitas formas de filtragem contextual, a segurança do usuário será potencialmente colocada em risco.Jogos que usam inadequadamente resultados em cache podem enfrentar moderação.

No entanto, é incentivado a manter esses objetos de resultado para exibir a mesma mensagem aos usuários que se juntam ao servidor mais tarde.Por exemplo: isso pode ser usado para implementar com segurança e eficiência um registro de bate-papo de servidor que sempre usa o filtro de menor restrição para usuários que se juntam mais tarde ou para exibir eficientemente texto como um nome de animal de estimação para um usuário que entra no jogo depois que o animal foi primeiro gerado e filtrado pelo nome.

O parâmetro opcional Enum.TextFilterContext não afetará o resultado filtrado da consulta. Este valor será usado para melhorar a filtragem de texto do Roblox.

O texto privado é qualquer coisa que só é vista por jogadores específicos, em vez de todos os jogadores.Por exemplo, se o chat for visto por um único jogador ou por um grupo selecionado de jogadores, então o chat é considerado privado.O bate-papo para equipes ou o bate-papo que é potencialmente visível para um grupo mais amplo, como o servidor, é considerado público.Se você não tem certeza do que seu texto se qualifica, deixe o campo opcional em branco.

Nota:

  • Este método sempre retorna para fazer uma chamada de serviço de filtragem de texto
  • Este método pode arremessar se houver um erro de serviço que não pode ser resolvido.Se esta função lançar um erro, não tente novamente a solicitar / pedir; este método implementa sua própria lógica de tentativa novamente internamente.Se este método falhar, não exiba o texto para nenhum usuário.
  • Este método atualmente arremessa se do usuário não estiver online no servidor atual.Planeamos suportar usuários que estão offline ou em um servidor diferente no futuro.

Parâmetros

stringToFilter: string

O texto a ser filtrado.

Valor Padrão: ""
fromUserId: number

O ID do jogador que filtra o texto.

Valor Padrão: ""

O contexto em que a mensagem filtrada será usada.

Valor Padrão: "PrivateChat"

Devolução

Amostras de código

This code sample includes a simple demonstration of how TextService:FilterStringAsync() should be implemented in a system where players are allowed to name their pets.

Note, this code sample includes the server-side implementation only (to be placed in a Script). Examples of how to implement the client-side of this system are included under the RemoteEvent and RemoteFunction examples.

Pet Name Filter Example

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TextService = game:GetService("TextService")
local Players = game:GetService("Players")
local Remotes = Instance.new("Folder")
Remotes.Name = "PetNamingRemotes"
Remotes.Parent = ReplicatedStorage
local UserNamedPet = Instance.new("RemoteEvent")
UserNamedPet.Name = "UserNamedPet"
UserNamedPet.Parent = Remotes
local SendPetName = Instance.new("RemoteEvent")
SendPetName.Name = "SendPetName"
SendPetName.Parent = Remotes
local RequestAllPetNames = Instance.new("RemoteFunction")
RequestAllPetNames.Name = "RequestAllPetNames"
RequestAllPetNames.Parent = Remotes
local filterResults = {}
local function broadcastPetName(userId)
local filterResult = filterResults[userId]
if filterResult then
for _, player in pairs(Players:GetPlayers()) do
if player then
-- spawn a new thread so as to not yield the update
task.spawn(function()
-- grab the filtered string for this user
local toUserId = player.UserId
local filteredString = filterResult:GetNonChatStringForUserAsync(toUserId)
filteredString = filteredString or ""
SendPetName:FireClient(player, userId, filteredString)
end)
end
end
end
end
UserNamedPet.OnServerEvent:Connect(function(player, petName)
local fromUserId = player.UserId
-- pcall to catch errors
local success, result = pcall(function()
return TextService:FilterStringAsync(petName, fromUserId)
end)
if success then
filterResults[fromUserId] = result
broadcastPetName(fromUserId)
else
print("Could not filter pet name")
end
end)
RequestAllPetNames.OnServerInvoke = function(player)
local toUserId = player.UserId
local petNames = {}
-- go through filter results and filter the pet name to be sent
for fromUserId, filterResult in pairs(filterResults) do
local filteredString = filterResult:GetNonChatStringForUserAsync(toUserId)
filteredString = filteredString or ""
-- need to convert userId to string so it can't be sent via a remote function
petNames[tostring(fromUserId)] = filteredString
end
return petNames
end
Players.PlayerRemoving:Connect(function(oldPlayer)
local userId = oldPlayer.UserId
filterResults[userId] = nil
end)

GetFamilyInfoAsync

Rendimentos

Retorna uma tabela que contém o nome e os rostos de uma família de fontes.

A tabela retornada é estruturada da seguinte forma:


type FaceInfo = {
Name: string, -- Exemplos: "Regular", "Livro", "Itálico", "Itálico Fino"
Weight: Enum.FontWeight,
Style: Enum.FontStyle, -- Ou Normal ou Italico
}
type FamilyInfo = {
Name: string, -- Exemplos: "Source Sans Pro", "Grenze Gotisch"
Faces: {FaceInfo} -- Há sempre pelo menos 1, mas pode haver até 18.
}

Se a família de fontes já foi carregada por uma chamada anterior para GetFamilyInfoAsync , ContentProvider:PreloadAsync() ou um objeto de texto com a propriedade TextLabel.FontFace configurar, o método retorna sem renunciar.

Erros

Este método pode falhar devido a erros de rede. Você deve sempre envolvê-lo em um pcall para tratamento de erros.

Lança um erro nesses cenários:

  • A família passada é uma string / cadeia / textovazia.
  • Baixar a família falhou.
  • O ID do recurso é inválido ou aponta para um recurso que não existe.

Parâmetros

assetId: ContentId

ID de recurso da família de fontes para pesquisar.

Valor Padrão: ""

Devolução

A informação sobre a família de fontes.

Amostras de código

This example showcases a possible usage of the TextService:GetFamilyInfoAsync() method.

It prints out information about a font family to the output window.

TextService: Getting font family information

local TextService = game:GetService("TextService")
local familyToCheck = "rbxasset://fonts/families/Arial.json"
-- This is a yield function which may take up to a few seconds to download the font.
local info = TextService:GetFamilyInfoAsync(familyToCheck)
print("Name of the font:", info.Name)
print("Faces:")
for _, face in info.Faces do
print("--------")
print("Name:", face.Name)
print("Weight:", face.Weight.Name)
print("Style:", face.Style.Name)
end

GetTextBoundsAsync

Rendimentos

Este método é semelhante a TextService:GetTextSize() , mas usa o objeto Font em vez de Enum.Font, que tem acesso a mais fontes.

Usado para medir o quão grande algum texto receberá um conjunto de propriedades, como a string / cadeia / texto, o tamanho e a fonte.

Esta é uma função de retorno porque algumas fontes podem precisar ser carregadas para que possam ser medidas.Se a fonte já estiver carregada, então ela não vai renderizar.ContentProvider:PreloadAsync() pode ser usado para garantir que uma fonte seja carregada.

Erros

Este método pode falhar devido a erros de rede. Você deve sempre envolvê-lo em um pcall para tratamento de erros.

Lança um erro nesses cenários:

  • O GetTextBoundsParams.Font tem uma família em branco.
  • O argumento params foi nil.
  • A família de fontes ou a face de fonte falhou ao download/baixar.

Parâmetros

Uma referência a um ObjetoGetTextBoundsParams de referência.

Valor Padrão: ""

Devolução

O tamanho do texto como um Vector2 .

Amostras de código

This example shows how you can use TextService:GetTextBoundsAsync().

It measures the size of some text in a specific font, then prints the result.

TextService: Measuring text size

local TextService = game:GetService("TextService")
local params = Instance.new("GetTextBoundsParams")
params.Text = "hello world!"
params.Font = Font.new("rbxasset://fonts/families/GrenzeGotisch.json", Enum.FontWeight.Thin)
params.Size = 20
params.Width = 200
local size = TextService:GetTextBoundsAsync(params)
print("The size of the text is:", size)

GetTextSizeOffsetAsync

Rendimentos

Parâmetros

fontSize: number
Valor Padrão: ""
font: Enum.Font
Valor Padrão: ""

Devolução

Eventos