QUrl Class

Documentación de las funciones miembro

QUrl::QUrl()

Construye un objeto QUrl vacío.

QUrl::QUrl(const QString &url, QUrl::ParsingMode parsingMode = TolerantMode)

Construye una URL analizando url. Tenga en cuenta que este constructor espera una URL o URL-Referencia adecuada y no intentará adivinar la intención. Por ejemplo, la siguiente declaración:

QUrl url("example.com");

Construirá una URL válida, pero puede que no sea lo que uno espera, ya que falta la parte scheme() de la entrada. Para una cadena como la anterior, las aplicaciones pueden querer utilizar fromUserInput(). Para este constructor o setUrl(), lo siguiente es probablemente lo que se pretendía:

QUrl url("https://example.com");

QUrl codificará automáticamente en porcentaje todos los caracteres no permitidos en una URL y descodificará las secuencias codificadas en porcentaje que representen un carácter no reservado (letras, dígitos, guiones, guiones bajos, puntos y tildes). Todos los demás caracteres se dejan en su forma original.

Analiza url utilizando el modo de análisis parsingMode. En TolerantMode (por defecto), QUrl corregirá ciertos errores, especialmente la presencia de un carácter de porcentaje ('%') no seguido de dos dígitos hexadecimales, y aceptará cualquier carácter en cualquier posición. En StrictMode, no se tolerarán los errores de codificación y QUrl también comprobará que ciertos caracteres prohibidos no estén presentes en forma no codificada. Si se detecta un error en StrictMode, isValid() devolverá false. El modo de análisis DecodedMode no está permitido en este contexto.

Ejemplo:

QUrl url("http://www.example.com/List of holidays.xml");
// url.toEncoded() == "http://www.example.com/List%20of%20holidays.xml"

Para construir una URL a partir de una cadena codificada, también puede utilizar fromEncoded():

QUrl url = QUrl::fromEncoded("http://qt-project.org/List%20of%20holidays.xml");

Ambas funciones son equivalentes y, en Qt 5, ambas funciones aceptan datos codificados. Normalmente, la elección del constructor QUrl o de setUrl() frente a fromEncoded() dependerá de los datos de origen: el constructor y setUrl() toman un QString, mientras que fromEncoded toma un QByteArray.

Véase también setUrl(), fromEncoded() y TolerantMode.

[noexcept] QUrl::QUrl(const QUrl &other)

Construye una copia de other.

[noexcept] QUrl::QUrl(QUrl &&other)

Mover-construye una instancia de QUrl, haciendo que apunte al mismo objeto al que apuntaba other.

[noexcept] QUrl::~QUrl()

Destructor; llamado inmediatamente antes de eliminar el objeto.

QUrl QUrl::adjusted(QUrl::FormattingOptions options) const

Devuelve una versión ajustada de la URL. La salida puede personalizarse pasando banderas con options.

Las opciones de codificación de QUrl::ComponentFormattingOption no tienen mucho sentido para este método, ni tampoco QUrl::PreferLocalFile.

Esto es siempre equivalente a QUrl(url.toString(opciones)).

Véase también FormattingOptions, toEncoded(), y toString().

QString QUrl::authority(QUrl::ComponentFormattingOptions options = PrettyDecoded) const

Devuelve la autoridad de la URL si está definida; en caso contrario, devuelve una cadena vacía.

Esta función devuelve un valor no ambiguo, que puede contener los caracteres aún codificados en porcentaje, además de algunas secuencias de control no representables en forma decodificada en QString.

El argumento options controla cómo formatear el componente de información del usuario. El valor de QUrl::FullyDecoded no está permitido en esta función. Si necesita obtener datos totalmente descodificados, llame a userName(), password(), host() y port() individualmente.

Véase también setAuthority(), userInfo(), userName(), password(), host() y port().

void QUrl::clear()

Restablece el contenido de QUrl. Después de llamar a esta función, QUrl es igual a uno que ha sido construido con el constructor vacío por defecto.

Véase también isEmpty().

QString QUrl::errorString() const

Devuelve un mensaje de error si la última operación que modificó este objeto QUrl se encontró con un error de análisis. Si no se detectó ningún error, esta función devuelve una cadena vacía y isValid() devuelve true.

El mensaje de error devuelto por esta función es de naturaleza técnica y puede no ser entendido por los usuarios finales. Es útil sobre todo para los desarrolladores que intentan entender por qué QUrl no acepta alguna entrada.

Véase también QUrl::ParsingMode.

QString QUrl::fileName(QUrl::ComponentFormattingOptions options = FullyDecoded) const

Devuelve el nombre del archivo, excluyendo la ruta del directorio.

Tenga en cuenta que, si a este objeto QUrl se le da una ruta que termina en una barra, el nombre del archivo se considera vacío.

Si la ruta no contiene ninguna barra oblicua, se devuelve íntegramente como fileName.

Ejemplo:

QUrl url("http://qt-project.org/support/file.html");
// url.adjusted(RemoveFilename) == "http://qt-project.org/support/"
// url.fileName() == "file.html"

El argumento options controla el formato del componente del nombre del archivo. Todos los valores producen un resultado inequívoco. Con QUrl::FullyDecoded, se descodifican todas las secuencias codificadas porcentualmente; de lo contrario, el valor devuelto puede contener algunas secuencias codificadas porcentualmente para algunas secuencias de control no representables en forma descodificada en QString.

Véase también path().

QString QUrl::fragment(QUrl::ComponentFormattingOptions options = PrettyDecoded) const

Devuelve el fragmento de la URL. Para determinar si la URL analizada contiene un fragmento, utilice hasFragment().

El argumento options controla el formato del componente del fragmento. Todos los valores producen un resultado inequívoco. Con QUrl::FullyDecoded, se descodifican todas las secuencias codificadas porcentualmente; de lo contrario, el valor devuelto puede contener algunas secuencias codificadas porcentualmente para algunas secuencias de control no representables en forma descodificada en QString.

Tenga en cuenta que QUrl::FullyDecoded puede provocar la pérdida de datos si están presentes esas secuencias no representables. Se recomienda utilizar ese valor cuando el resultado vaya a utilizarse en un contexto no URL.

Véase también setFragment() y hasFragment().

[static, since 6.3] QString QUrl::fromAce(const QByteArray &domain, QUrl::AceProcessingOptions options = {})

Devuelve la forma Unicode del nombre de dominio dado domain, que está codificado en la Codificación Compatible ASCII (ACE). La salida puede personalizarse pasando banderas con options. El resultado de esta función se considera equivalente a domain.

Si el valor de domain no puede codificarse, se convertirá a QString y se devolverá.

La codificación compatible con ASCII (ACE) está definida por RFC 3490, RFC 3491 y RFC 3492 y actualizada por la Norma Técnica Unicode nº 46. Forma parte de la especificación Internationalizing Domain Names in Applications (IDNA), que permite escribir nombres de dominio (como "example.com") utilizando caracteres no ASCII estadounidenses.

Esta función se introdujo en Qt 6.3.

[static] QUrl QUrl::fromCFURL(CFURLRef url)

Construye un QUrl que contiene una copia de la CFURL url.

[static] QUrl QUrl::fromEncoded(QByteArrayView input, QUrl::ParsingMode mode = TolerantMode)

Analiza input y devuelve el correspondiente QUrl. Se supone que input está codificado y sólo contiene caracteres ASCII.

Analiza la URL utilizando mode. Véase setUrl() para más información sobre este parámetro. QUrl::DecodedMode no está permitido en este contexto.

Véase también toEncoded() y setUrl().

[static] QUrl QUrl::fromLocalFile(const QString &localFile)

Devuelve una representación QUrl de localFile, interpretado como un archivo local. Esta función acepta rutas separadas por barras, así como el separador nativo para esta plataforma.

Esta función también acepta rutas con una barra inclinada doble (o barra invertida) para indicar un archivo remoto, como en "//nombre_servidor/ruta/a/archivo.txt". Tenga en cuenta que sólo algunas plataformas pueden abrir realmente este archivo utilizando QFile::open().

Un localFile vacío conduce a una URL vacía (desde Qt 5.4).

qDebug()<< QUrl::fromLocalFile(" archivo. txt"); // QUrl("archivo:archivo.txt")qDebug() << QUrl::fromLocalFile("/home/user/file.txt"); // QUrl("file:///home/user/file.txt")
qDebug() << QUrl::fromLocalFile("file:file.txt");       // doesn't make sense; expects path, not url with scheme

En la primera línea del fragmento anterior, la URL de un archivo se construye a partir de una ruta local relativa. Una URL de archivo con una ruta relativa sólo tiene sentido si existe una URL base con la que resolverla. Por ejemplo:

QUrl url = QUrl::desdeArchivoLocal("archivo.txt");QUrl baseUrl = QUrl("archivo:/home/usuario/");// incorrecto: imprime QUrl("archivo:archivo.txt"), ya que url ya tiene un esquemaqDebug() << baseUrl.resolved(url);

Para resolver tal URL, es necesario eliminar el esquema de antemano:

// correcto: imprime QUrl("file:///home/usuario/archivo.txt")url.setScheme(QString());qDebug() << baseUrl.resolved(url);

Por esta razón, es mejor utilizar una URL relativa (es decir, sin esquema) para las rutas relativas de los archivos:

QUrl url = QUrl("archivo.txt");QUrl baseUrl = QUrl("file:/home/user/");// imprime QUrl("file:///home/user/file.txt")qDebug() << baseUrl.resolved(url);

Véase también toLocalFile(), isLocalFile() y QDir::toNativeSeparators().

[static] QUrl QUrl::fromNSURL(const NSURL *url)

Construye un QUrl que contiene una copia de la NSURL url.

[static] QString QUrl::fromPercentEncoding(const QByteArray &input)

Devuelve una copia descodificada de input. input se descodifica primero de la codificación porcentual y luego se convierte de UTF-8 a unicode.

[static] QList<QUrl> QUrl::fromStringList(const QStringList &urls, QUrl::ParsingMode mode = TolerantMode)

Convierte una lista de cadenas que representan urls en una lista de urls, utilizando QUrl(str, mode). Tenga en cuenta que esto significa que todas las cadenas deben ser urls, no, por ejemplo, rutas locales.

[static] QUrl QUrl::fromUserInput(const QString &userInput, const QString &workingDirectory = QString(), QUrl::UserInputResolutionOptions options = DefaultResolution)

Devuelve una URL válida a partir de una cadena userInput suministrada por el usuario si se puede deducir una. En caso de que no sea posible, se devuelve un QUrl() inválido.

Permite al usuario introducir una URL o una ruta de archivo local en forma de cadena sin formato. Esta cadena puede teclearse manualmente en una barra de direcciones, obtenerse del portapapeles o pasarse mediante argumentos de la línea de comandos.

Cuando la cadena no es una URL válida, se realiza la mejor suposición posible, haciendo varias suposiciones.

En el caso de que la cadena corresponda a una ruta de archivo válida en el sistema, se construye una URL file://, utilizando QUrl::fromLocalFile().

Si no es el caso, se intenta convertir la cadena en una URL http:// o ftp://. Esta última en el caso de que la cadena empiece por 'ftp'. A continuación, se pasa el resultado por el analizador tolerante de QUrl y, en caso de éxito, se devuelve un QUrl válido, o bien un QUrl().

Ejemplos:

• qt-project.org se convierte en http://qt-project.org
• ftp.qt-project.org se convierte en ftp://ftp.qt-project.org
• hostname pasa a ser http://hostname
• /home/usuario/prueba.html pasa a ser file:///home/usuario/prueba.html

Para poder manejar rutas relativas, este método toma una ruta opcional workingDirectory. Esto es especialmente útil cuando se manejan argumentos de línea de comandos. Si workingDirectory está vacío, no se manejarán las rutas relativas.

Por defecto, una cadena de entrada que parezca una ruta relativa sólo será tratada como tal si el fichero existe realmente en el directorio de trabajo dado. Si la aplicación puede manejar archivos que aún no existen, debe pasar la bandera AssumeLocalFile en options.

bool QUrl::hasFragment() const

Devuelve true si esta URL contiene un fragmento (es decir, si se ha visto # en ella).

Véase también fragment() y setFragment().

bool QUrl::hasQuery() const

Devuelve true si esta URL contiene una consulta (es decir, si se ha visto ? en ella).

Véase también setQuery(), query() y hasFragment().

QString QUrl::host(QUrl::ComponentFormattingOptions options = FullyDecoded) const

Devuelve el host de la URL si está definido; en caso contrario, devuelve una cadena vacía.

El argumento options controla cómo se formateará el nombre de host. La opción QUrl::EncodeUnicode hará que esta función devuelva el nombre de host en la forma ASCII-Compatible Encoding (ACE), que es adecuada para su uso en canales que no son limpios de 8 bits o que requieren el nombre de host heredado (como peticiones DNS o en cabeceras de peticiones HTTP). Si este indicador no está presente, esta función devuelve el nombre de dominio internacional (IDN) en formato Unicode, de acuerdo con la lista de dominios de nivel superior permitidos (véase idnWhitelist()).

Los demás indicadores se ignoran. Los nombres de host no pueden contener caracteres de control ni de porcentaje, por lo que el valor devuelto puede considerarse totalmente descodificado.

Véase también setHost(), idnWhitelist(), setIdnWhitelist() y authority().

[static] QStringList QUrl::idnWhitelist()

Devuelve la lista blanca actual de dominios de nivel superior que pueden tener caracteres no ASCII en sus composiciones.

Consulte setIdnWhitelist() para conocer los fundamentos de esta lista.

Véase también setIdnWhitelist() y AceProcessingOption.

bool QUrl::isEmpty() const

Devuelve true si la URL no tiene datos; en caso contrario devuelve false.

Véase también clear().

bool QUrl::isLocalFile() const

Devuelve true si esta URL apunta a una ruta de archivo local. Una URL es una ruta de archivo local si el esquema es "file".

Tenga en cuenta que esta función considera que las URL con nombres de host son rutas de archivos locales, incluso si la eventual ruta de archivo no puede abrirse con QFile::open().

Véase también fromLocalFile() y toLocalFile().

bool QUrl::isParentOf(const QUrl &childUrl) const

Devuelve true si esta URL es padre de childUrl. childUrl es hijo de esta URL si las dos URL comparten el mismo esquema y autoridad, y la ruta de esta URL es padre de la ruta de childUrl.

bool QUrl::isRelative() const

Devuelve true si la URL es relativa; en caso contrario devuelve false. Una URL es una referencia relativa si su esquema no está definido; por lo tanto, esta función equivale a llamar a scheme().isEmpty().

Las referencias relativas se definen en RFC 3986 sección 4.2.

Véase también Relative URLs vs Relative Paths.

bool QUrl::isValid() const

Devuelve true si la URL no está vacía y es válida; en caso contrario, devuelve false.

La URL se somete a una prueba de conformidad. Cada parte de la URL debe ajustarse a las reglas de codificación del estándar URI para que la URL se considere válida.

bool comprobarUrl(const QUrl &url) { if (!url.isValid()) {        qDebug("Invalid URL: %s", qUtf8Printable(url.toString()));
       return false; } return true; }

bool QUrl::matches(const QUrl &url, QUrl::FormattingOptions options) const

Devuelve true si esta URL y la dada url son iguales después de aplicar options a ambas; en caso contrario devuelve false.

Esto es equivalente a llamar a adjusted(opciones) en ambas URLs y comparar las urls resultantes, pero más rápido.

QString QUrl::password(QUrl::ComponentFormattingOptions options = FullyDecoded) const

Devuelve la contraseña de la URL si está definida; en caso contrario, devuelve una cadena vacía.

El argumento options controla cómo formatear el componente del nombre de usuario. Todos los valores producen un resultado inequívoco. Con QUrl::FullyDecoded, se descodifican todas las secuencias codificadas en porcentaje; de lo contrario, el valor devuelto puede contener algunas secuencias codificadas en porcentaje para algunas secuencias de control no representables en forma descodificada en QString.

Tenga en cuenta que QUrl::FullyDecoded puede provocar la pérdida de datos si están presentes esas secuencias no representables. Se recomienda utilizar ese valor cuando el resultado se vaya a utilizar en un contexto que no sea URL, como la configuración en QAuthenticator o la negociación de un inicio de sesión.

Véase también setPassword().

QString QUrl::path(QUrl::ComponentFormattingOptions options = FullyDecoded) const

Devuelve la ruta de la URL.

qDebug()<< QUrl("archivo:archivo.txt").ruta(); // "archivo.txt"qDebug() << QUrl("/home/user/file.txt").path();             // "/home/user/file.txt"
qDebug() << QUrl("http://www.example.com/test/123").path(); // "/test/123"

El argumento options controla cómo formatear el componente de la ruta. Todos los valores producen un resultado inequívoco. Con QUrl::FullyDecoded, se descodifican todas las secuencias codificadas porcentualmente; de lo contrario, el valor devuelto puede contener algunas secuencias codificadas porcentualmente para algunas secuencias de control no representables en forma descodificada en QString.

Tenga en cuenta que QUrl::FullyDecoded puede provocar la pérdida de datos si están presentes esas secuencias no representables. Se recomienda utilizar ese valor cuando el resultado vaya a utilizarse en un contexto no URL, como el envío a un servidor FTP.

Un ejemplo de pérdida de datos es cuando se tienen secuencias codificadas en porcentaje no Unicode y se utiliza FullyDecoded (el valor por defecto):

qDebug() << QUrl("/foo%FFbar").path();

En este ejemplo, habrá cierto nivel de pérdida de datos porque %FF no se puede convertir.

La pérdida de datos también puede producirse cuando la ruta contiene subdelimitadores (como +):

qDebug() << QUrl("/foo+bar%2B").path(); // "/foo+bar+"

Otros ejemplos de descodificación:

const QUrl url("/tmp/Mambo %235%3F.mp3");qDebug() << url.path(QUrl::FullyDecoded);  // "/tmp/Mambo #5?.mp3"
qDebug() << url.path(QUrl::PrettyDecoded); // "/tmp/Mambo #5?.mp3"
qDebug() << url.path(QUrl::FullyEncoded);  // "/tmp/Mambo%20%235%3F.mp3"

Véase también setPath().

int QUrl::port(int defaultPort = -1) const

Devuelve el puerto de la URL, o defaultPort si el puerto no está especificado.

Ejemplo:

QTcpSocket sock;
sock.connectToHost(url.host(), url.port(80));

Véase también setPort().

QString QUrl::query(QUrl::ComponentFormattingOptions options = PrettyDecoded) const

Devuelve la cadena de consulta de la URL si hay una cadena de consulta, o un resultado vacío en caso contrario. Para determinar si la URL analizada contiene una cadena de consulta, utilice hasQuery().

El argumento options controla el formato del componente de consulta. Todos los valores producen un resultado inequívoco. Con QUrl::FullyDecoded, se descodifican todas las secuencias codificadas porcentualmente; de lo contrario, el valor devuelto puede contener algunas secuencias codificadas porcentualmente para algunas secuencias de control no representables en forma descodificada en QString.

Tenga en cuenta que se desaconseja el uso de QUrl::FullyDecoded en las consultas, ya que éstas a menudo contienen datos que se supone que deben permanecer codificados en porcentaje, incluido el uso de la secuencia "%2B" para representar un carácter más ('+').

Véase también setQuery() y hasQuery().

QUrl QUrl::resolved(const QUrl &relative) const

Devuelve el resultado de la fusión de esta URL con relative. Esta URL se utiliza como base para convertir relative en una URL absoluta.

Si relative no es una URL relativa, esta función devolverá directamente relative. En caso contrario, las rutas de las dos URL se fusionan, y la nueva URL devuelta tiene el esquema y la autoridad de la URL base, pero con la ruta fusionada, como en el siguiente ejemplo:

QUrl baseUrl("http://qt.digia.com/Support/");QUrl relativeUrl("../Producto/Biblioteca/");qDebug(qUtf8Printable(baseUrl.resolved(relativeUrl).toString()));
// imprime "http://qt.digia.com/Product/Library/"

Llamar a resolved() con ".." devuelve un QUrl cuyo directorio está un nivel por encima del original. Del mismo modo, al llamar a resolved() con "../.." se eliminan dos niveles de la ruta. Si relative es "/", la ruta se convierte en "/".

Véase también isRelative().

QString QUrl::scheme() const

Devuelve el esquema de la URL. Si se devuelve una cadena vacía, significa que el esquema no está definido y que la URL es relativa.

El esquema sólo puede contener letras o dígitos US-ASCII, lo que significa que no puede contener ningún carácter que requiera codificación. Además, los esquemas se devuelven siempre en minúsculas.

Véase también setScheme() y isRelative().

void QUrl::setAuthority(const QString &authority, QUrl::ParsingMode mode = TolerantMode)

Establece la autoridad de la URL en authority.

La autoridad de una URL es la combinación de información de usuario, un nombre de host y un puerto. Todos estos elementos son opcionales, por lo que una autoridad vacía es válida.

La información de usuario y el host están separados por una @, y el host y el puerto están separados por un ":". Si la información de usuario está vacía, la "@" debe omitirse, aunque se permite un ":" suelto si el puerto está vacío.

El siguiente ejemplo muestra una cadena de autoridad válida:

Los datos de authority se interpretan de acuerdo con mode: en StrictMode, cualquier carácter '%' debe ir seguido de exactamente dos caracteres hexadecimales y algunos caracteres (incluido el espacio) no están permitidos en forma no decodificada. En TolerantMode (por defecto), se aceptan todos los caracteres sin decodificar y el analizador sintáctico tolerante corregirá los '%' que no vayan seguidos de dos caracteres hexadecimales.

Esta función no permite que mode sea QUrl::DecodedMode. Para establecer datos totalmente descodificados, llame individualmente a setUserName(), setPassword(), setHost() y setPort().

Véase también authority(), setUserInfo(), setHost() y setPort().

void QUrl::setFragment(const QString &fragment, QUrl::ParsingMode mode = TolerantMode)

Establece el fragmento de la URL en fragment. El fragmento es la última parte de la URL, representada por un '#' seguido de una cadena de caracteres. Suele utilizarse en HTTP para referirse a un determinado enlace o punto de una página:

En ocasiones, el fragmento también se denomina "referencia" URL.

Si se pasa un argumento de QString() (un valor nulo QString), se anulará el fragmento. Si se pasa un argumento de QString("") (un QString vacío pero no nulo), el fragmento se establecerá como una cadena vacía (como si la URL original tuviera un "#" solitario).

Los datos de fragment se interpretan de acuerdo con mode: en StrictMode, cualquier carácter "%" debe ir seguido de exactamente dos caracteres hexadecimales y algunos caracteres (incluido el espacio) no están permitidos en forma no decodificada. En TolerantMode, se aceptan todos los caracteres sin descodificar y el analizador sintáctico tolerante corregirá los '%' que no vayan seguidos de dos caracteres hexadecimales. En DecodedMode, los '%' se representan por sí mismos y no son posibles los caracteres codificados.

QUrl::DecodedMode debe utilizarse al establecer el fragmento a partir de una fuente de datos que no sea una URL o con un fragmento obtenido llamando a fragment() con la opción de formato QUrl::FullyDecoded.

Véase también fragment() y hasFragment().

void QUrl::setHost(const QString &host, QUrl::ParsingMode mode = DecodedMode)

Establece el host de la URL en host. El host forma parte de la autoridad.

Los datos de host se interpretan de acuerdo con mode: en StrictMode, cualquier carácter '%' debe ir seguido de exactamente dos caracteres hexadecimales y algunos caracteres (incluido el espacio) no están permitidos en forma no decodificada. En TolerantMode, se aceptan todos los caracteres sin descodificar y el analizador sintáctico tolerante corregirá los '%' que no vayan seguidos de dos caracteres hexadecimales. En DecodedMode, los '%' se representan por sí mismos y no es posible utilizar caracteres codificados.

Tenga en cuenta que, en todos los casos, el resultado del análisis sintáctico debe ser un nombre de host válido de acuerdo con las reglas STD 3, modificadas por la especificación Internationalized Resource Identifiers (RFC 3987). Los nombres de host no válidos no están permitidos y provocarán que isValid() se convierta en false.

Véase también host() y setAuthority().

[static] void QUrl::setIdnWhitelist(const QStringList &list)

Establece la lista blanca de Dominios de Alto Nivel (TLDs) a los que se les permite tener caracteres no ASCII en los dominios al valor de list.

Tenga en cuenta que si llama a esta función, debe hacerlo antes de iniciar cualquier hilo que pueda acceder a idnWhitelist().

Qt viene con una lista por defecto que contiene los dominios de primer nivel de Internet que han publicado soporte para Nombres de Dominio Internacionalizados (IDNs) y reglas para garantizar que no pueda haber engaño entre caracteres de apariencia similar (como la letra minúscula latina 'a' y su equivalente cirílico, que en la mayoría de las fuentes son visualmente idénticos).

Esta lista se actualiza periódicamente, a medida que los registradores publican nuevas reglas.

Esta función se proporciona para aquellos que necesiten manipular la lista, con el fin de añadir o eliminar un TLD. No se recomienda cambiar su valor para otros propósitos que no sean de prueba, ya que puede exponer a los usuarios a riesgos de seguridad.

Véase también idnWhitelist().

void QUrl::setPassword(const QString &password, QUrl::ParsingMode mode = DecodedMode)

Establece la contraseña de la URL en password. password forma parte del elemento de información del usuario en la autoridad de la URL, como se describe en setUserInfo().

Los datos de password se interpretan según mode: en StrictMode, cualquier carácter "%" debe ir seguido de exactamente dos caracteres hexadecimales y algunos caracteres (incluido el espacio) no se admiten en forma no decodificada. En TolerantMode, se aceptan todos los caracteres sin descodificar y el analizador sintáctico tolerante corregirá los '%' que no vayan seguidos de dos caracteres hexadecimales. En DecodedMode, los '%' se representan por sí mismos y no es posible utilizar caracteres codificados.

QUrl::DecodedMode debe utilizarse cuando se establece la contraseña desde una fuente de datos que no es una URL, como un diálogo de contraseña mostrado al usuario o con una contraseña obtenida llamando a password() con la opción de formato QUrl::FullyDecoded.

Véase también password() y setUserInfo().

void QUrl::setPath(const QString &path, QUrl::ParsingMode mode = DecodedMode)

Establece la ruta de la URL en path. La ruta es la parte de la URL que viene después de la autoridad pero antes de la cadena de consulta.

Para esquemas no jerárquicos, la ruta será todo lo que sigue a la declaración del esquema, como en el siguiente ejemplo:

Los datos de path se interpretan según mode: en StrictMode, cualquier carácter "%" debe ir seguido de exactamente dos caracteres hexadecimales y algunos caracteres (incluido el espacio) no se admiten en forma no decodificada. En TolerantMode, se aceptan todos los caracteres sin descodificar y el analizador sintáctico tolerante corregirá los '%' que no vayan seguidos de dos caracteres hexadecimales. En DecodedMode, los '%' se representan por sí mismos y no es posible utilizar caracteres codificados.

QUrl::DecodedMode debe utilizarse cuando se establece la ruta desde una fuente de datos que no es una URL, como un diálogo mostrado al usuario o con una ruta obtenida llamando a path() con la opción de formato QUrl::FullyDecoded.

Véase también path().

void QUrl::setPort(int port)

Establece el puerto de la URL en port. El puerto forma parte de la autoridad de la URL, como se describe en setAuthority().

port debe estar comprendido entre 0 y 65535, ambos inclusive. Establecer el puerto a -1 indica que el puerto no está especificado.

Véase también port().

void QUrl::setQuery(const QString &query, QUrl::ParsingMode mode = TolerantMode)

Establece la cadena de consulta de la URL en query.

Esta función es útil si necesita pasar una cadena de consulta que no encaja en el patrón clave-valor, o que utiliza un esquema diferente para codificar caracteres especiales que el sugerido por QUrl.

Si se pasa un valor de QString() a query (un QString nulo), la consulta se anula por completo. Sin embargo, si se pasa un valor de QString(""), la consulta se establecerá con un valor vacío, como si la URL original tuviera un "?" solitario.

Los datos de query se interpretan de acuerdo con mode: en StrictMode, cualquier carácter "%" debe ir seguido de exactamente dos caracteres hexadecimales y algunos caracteres (incluido el espacio) no están permitidos en forma no decodificada. En TolerantMode, se aceptan todos los caracteres sin descodificar y el analizador sintáctico tolerante corregirá los '%' sueltos que no vayan seguidos de dos caracteres hexadecimales. En DecodedMode, los '%' se representan por sí mismos y no es posible utilizar caracteres codificados.

Las cadenas de consulta suelen contener secuencias codificadas en porcentaje, por lo que se desaconseja el uso de DecodedMode. Una secuencia especial que debe tenerse en cuenta es la del carácter más ('+'). QUrl no convierte los espacios en caracteres más, a pesar de que los formularios HTML publicados por los navegadores web sí lo hacen. Para representar un verdadero carácter más en una consulta, se suele utilizar la secuencia "%2B". Esta función dejará intactas las secuencias "%2B" en TolerantMode o StrictMode.

Véase también query() y hasQuery().

void QUrl::setQuery(const QUrlQuery &query)

Establece la cadena de consulta de la URL en query.

Esta función reconstruye la cadena de consulta del objeto QUrlQuery y la establece en este objeto QUrl. Esta función no tiene parámetros de análisis porque QUrlQuery contiene datos que ya han sido analizados.

Véase también query() y hasQuery().

void QUrl::setScheme(const QString &scheme)

Establece el esquema de la URL en scheme. Como un esquema sólo puede contener caracteres ASCII, no se realiza ninguna conversión o descodificación en la entrada. Además, debe empezar por una letra ASCII.

El esquema describe el tipo (o protocolo) de la URL. Está representado por uno o más caracteres ASCII al principio de la URL.

Un esquema cumple estrictamente la norma RFC 3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

El siguiente ejemplo muestra una URL en la que el esquema es "ftp":

Para establecer el esquema, se utiliza la siguiente llamada:

QUrl url;
url.setScheme("ftp");

El esquema también puede estar vacío, en cuyo caso la URL se interpreta como relativa.

Véase también scheme() y isRelative().

void QUrl::setUrl(const QString &url, QUrl::ParsingMode parsingMode = TolerantMode)

Analiza url y establece este objeto en ese valor. QUrl codificará automáticamente el porcentaje de todos los caracteres no permitidos en una URL y descodificará las secuencias codificadas en porcentaje que representen un carácter no reservado (letras, dígitos, guiones, guiones bajos, puntos y tildes). Todos los demás caracteres se dejan en su forma original.

Analiza url utilizando el modo de análisis parsingMode. En TolerantMode (por defecto), QUrl corregirá ciertos errores, especialmente la presencia de un carácter de porcentaje ('%') no seguido de dos dígitos hexadecimales, y aceptará cualquier carácter en cualquier posición. En StrictMode, no se tolerarán errores de codificación y QUrl también comprobará que ciertos caracteres prohibidos no estén presentes en forma no codificada. Si se detecta un error en StrictMode, isValid() devolverá false. El modo de análisis DecodedMode no está permitido en este contexto y producirá una advertencia en tiempo de ejecución.

Véase también url() y toString().

void QUrl::setUserInfo(const QString &userInfo, QUrl::ParsingMode mode = TolerantMode)

Establece la información de usuario de la URL en userInfo. La información de usuario es una parte opcional de la autoridad de la URL, como se describe en setAuthority().

La información de usuario consiste en un nombre de usuario y, opcionalmente, una contraseña, separados por ':'. Si la contraseña está vacía, deben omitirse los dos puntos. El siguiente ejemplo muestra una cadena de información de usuario válida:

Los datos de userInfo se interpretan de acuerdo con mode: en StrictMode, cualquier carácter '%' debe ir seguido de exactamente dos caracteres hexadecimales y algunos caracteres (incluido el espacio) no están permitidos en forma no decodificada. En TolerantMode (por defecto), se aceptan todos los caracteres sin decodificar y el analizador sintáctico tolerante corregirá los '%' que no vayan seguidos de dos caracteres hexadecimales.

Esta función no permite que mode sea QUrl::DecodedMode. Para establecer datos totalmente descodificados, llame a setUserName() y setPassword() individualmente.

Véase también userInfo(), setUserName(), setPassword() y setAuthority().

void QUrl::setUserName(const QString &userName, QUrl::ParsingMode mode = DecodedMode)

Establece el nombre de usuario de la URL en userName. userName forma parte del elemento de información del usuario en la autoridad de la URL, como se describe en setUserInfo().

Los datos de userName se interpretan según mode: en StrictMode, cualquier carácter "%" debe ir seguido de exactamente dos caracteres hexadecimales y algunos caracteres (incluido el espacio) no se admiten en forma no decodificada. En TolerantMode (por defecto), se aceptan todos los caracteres sin decodificar y el analizador sintáctico tolerante corregirá los '%' que no vayan seguidos de dos caracteres hexadecimales. En DecodedMode, los '%' se aceptan solos y no es posible utilizar caracteres codificados.

QUrl::DecodedMode debe utilizarse cuando se establece el nombre de usuario desde una fuente de datos que no es una URL, como un diálogo de contraseña mostrado al usuario o con un nombre de usuario obtenido llamando a userName() con la opción de formato QUrl::FullyDecoded.

Véase también userName() y setUserInfo().

[noexcept] void QUrl::swap(QUrl &other)

Cambia esta URL por other. Esta operación es muy rápida y nunca falla.

[static, since 6.3] QByteArray QUrl::toAce(const QString &domain, QUrl::AceProcessingOptions options = {})

Devuelve la Codificación Compatible ASCII del nombre de dominio dado domain. La salida puede personalizarse pasando indicadores con options. El resultado de esta función se considera equivalente a domain.

La Codificación Compatible ASCII (ACE) está definida por RFC 3490, RFC 3491 y RFC 3492 y actualizada por el Estándar Técnico Unicode #46. Forma parte de la especificación Internationalizing Domain Names in Applications (IDNA), que permite que los nombres de dominio (como "example.com") se escriban utilizando caracteres no ASCII estadounidenses.

Esta función devuelve un QByteArray vacío si domain no es un nombre de host válido. Nótese, en particular, que los literales IPv6 no son nombres de dominio válidos.

Esta función se introdujo en Qt 6.3.

CFURLRef QUrl::toCFURL() const

Crea una CFURL a partir de QUrl.

La persona que llama es propietaria de la CFURL y es responsable de liberarla.

QString QUrl::toDisplayString(QUrl::FormattingOptions options = FormattingOptions(PrettyDecoded)) const

Devuelve una representación en forma de cadena de la URL. La salida puede personalizarse pasando banderas con options. La opción RemovePassword siempre está activada, ya que las contraseñas nunca deben mostrarse a los usuarios.

Con las opciones por defecto, el QString resultante puede ser pasado de vuelta a un QUrl más tarde, pero cualquier contraseña que estuviera presente inicialmente se perderá.

Véase también FormattingOptions, toEncoded(), y toString().

QByteArray QUrl::toEncoded(QUrl::FormattingOptions options = FullyEncoded) const

Devuelve la representación codificada de la URL si es válida; en caso contrario, devuelve un QByteArray vacío. La salida puede personalizarse pasando banderas con options.

La información de usuario, la ruta y el fragmento se convierten a UTF-8, y todos los caracteres no ASCII se codifican en porcentaje. El nombre de host se codifica utilizando Punycode.

QString QUrl::toLocalFile() const

Devuelve la ruta de esta URL formateada como una ruta de archivo local. La ruta devuelta utilizará barras inclinadas, incluso si se creó originalmente a partir de una con barras invertidas.

Si esta URL contiene un nombre de host no vacío, se codificará en el valor devuelto en la forma que se encuentra en las redes SMB (por ejemplo, "//nombre_servidor/ruta/a/archivo.txt").

qDebug()<< QUrl("archivo:archivo.txt").toLocalFile(); // "archivo.txt"qDebug() << QUrl("file:/home/user/file.txt").toLocalFile(); // "/home/user/file.txt"
qDebug() << QUrl("file.txt").toLocalFile();                 // ""; wasn't a local file as it had no scheme

Nota: si el componente path de esta URL contiene una secuencia binaria no UTF-8 (como %80), el comportamiento de esta función es indefinido.

Véase también fromLocalFile() y isLocalFile().

NSURL *QUrl::toNSURL() const

Crea una NSURL a partir de QUrl.

La NSURL se libera automáticamente.

[static] QByteArray QUrl::toPercentEncoding(const QString &input, const QByteArray &exclude = QByteArray(), const QByteArray &include = QByteArray())

Devuelve una copia codificada de input. input se convierte primero a UTF-8, y todos los caracteres ASCII que no están en el grupo no reservado se codifican en porcentaje. Para evitar que los caracteres se codifiquen en porcentaje, páselos a exclude. Para forzar que los caracteres se codifiquen en porcentaje, páselos a include.

No reservado se define como: ALPHA / DIGIT / "-" / "." / "_" / "~"

QByteArray ba = QUrl::toPercentEncoding("{¿una cadena sospechosa?}", "{}", "s");qDebug(ba.constData());
// imprime "{a fi%73hy %73tring%3F}"

QString QUrl::toString(QUrl::FormattingOptions options = FormattingOptions(PrettyDecoded)) const

Devuelve una representación de cadena de la URL. La salida puede personalizarse pasando banderas con options. La opción QUrl::FullyDecoded no está permitida en esta función ya que generaría datos ambiguos.

La opción de formato por defecto es PrettyDecoded.

Véase también FormattingOptions, url(), y setUrl().

[static] QStringList QUrl::toStringList(const QList<QUrl> &urls, QUrl::FormattingOptions options = FormattingOptions(PrettyDecoded))

Convierte una lista de urls en una lista de objetos QString, utilizando toString(options).

QString QUrl::url(QUrl::FormattingOptions options = FormattingOptions(PrettyDecoded)) const

Devuelve una representación de cadena de la URL. La salida puede personalizarse pasando banderas con options. La opción QUrl::FullyDecoded no está permitida en esta función ya que generaría datos ambiguos.

El QString resultante puede pasarse posteriormente a un QUrl.

Sinónimo de toString(opciones).

Véase también setUrl(), FormattingOptions, toEncoded(), y toString().

QString QUrl::userInfo(QUrl::ComponentFormattingOptions options = PrettyDecoded) const

Devuelve la información de usuario de la URL, o una cadena vacía si la información de usuario no está definida.

Esta función devuelve un valor inequívoco, que puede contener los caracteres aún codificados en porcentaje, además de algunas secuencias de control no representables en forma decodificada en QString.

El argumento options controla cómo formatear el componente de información de usuario. El valor de QUrl::FullyDecoded no está permitido en esta función. Si necesita obtener datos totalmente descodificados, llame a userName() y password() individualmente.

Véase también setUserInfo(), userName(), password() y authority().

QString QUrl::userName(QUrl::ComponentFormattingOptions options = FullyDecoded) const

Devuelve el nombre de usuario de la URL si está definido; en caso contrario, devuelve una cadena vacía.

El argumento options controla el formato del componente del nombre de usuario. Todos los valores producen un resultado inequívoco. Con QUrl::FullyDecoded, se descodifican todas las secuencias codificadas porcentualmente; de lo contrario, el valor devuelto puede contener algunas secuencias codificadas porcentualmente para algunas secuencias de control no representables en forma descodificada en QString.

Tenga en cuenta que QUrl::FullyDecoded puede provocar la pérdida de datos si están presentes esas secuencias no representables. Se recomienda utilizar ese valor cuando el resultado se vaya a utilizar en un contexto que no sea URL, como la configuración en QAuthenticator o la negociación de un inicio de sesión.

Véase también setUserName() y userInfo().

[noexcept] QUrl &QUrl::operator=(QUrl &&other)

Mover-asigna other a esta instancia QUrl.

QUrl &QUrl::operator=(const QString &url)

Asigna el url especificado a este objeto.

Este operador no está disponible cuando se define la macro QT_NO_URL_CAST_FROM_STRING.

[noexcept] QUrl &QUrl::operator=(const QUrl &url)

Asigna la dirección url especificada a este objeto.