¿Fuentes web o fuentes cargadas localmente?


98

Desde los problemas provocados por el uso de Cufon, me aventuré a dejar de usar recursos de fuentes externos, pero últimamente, he estado buscando métodos alternativos para cargar fuentes para ver si hay una mejor manera; mejores métodos tienen una forma de aparecer de la nada.

Hay muchos métodos nuevos por ahí, y parece que hay variaciones para cada método; ¿Debería usar typekit ? o google webfonts (con js o css)? ¿Debo seguir usando fuentes de carga local (por ejemplo, método generado por fontsquirrel.com)?

A continuación, enumeraré los métodos que parecen ser los más bien recibidos, con algunas pruebas, pero ¿realmente vale la pena pasar a una fuente web? Parece que llevaría una mayor carga de recursos (solicitudes http) y tendría menos tipos de formato de archivo (menos compatibilidad), etc. Pero parece que los archivos se cargan de forma asincrónica y eficiente en la mayoría de los casos.

  1. ¿Es solo una cuestión de situación y necesidad? Si es así, ¿Que son?
  2. ¿Existen diferencias drásticas entre estos métodos?
  3. ¿Existe un método mejor que no haya enumerado?
  4. ¿Cuáles son los pros y los contras del rendimiento? ¿Mira? dependencias? compatibilidades?

Realmente estoy buscando las mejores prácticas aquí, el rendimiento es una gran cosa, pero también lo es la escalabilidad y la facilidad de uso. Sin mencionar el aspecto y la sensación.


CSS de Google

  • solo usa hoja de estilo externa
  • solo usa el tipo de archivo compatible más pequeño
  • puede usar @importo <link>tomar el contenido de styleshee ( @font-face) y ponerlo directamente en su propia hoja de estilo.

resultados de la prueba

  78ms load of html
  36ms load of css

ingrese la descripción de la imagen aquí


Método JS de Google

  • utiliza webfont.jspara cargar styleshet
  • solo usa el tipo de archivo compatible más pequeño
  • agrega :rootelemento con clase
  • agrega guión a la cabeza.

resultados de la prueba

    171ms load of html
    176ms load of js
    32ms load of css

ingrese la descripción de la imagen aquí


Método Typekit

  • agrega el :rootelemento con la clase.
  • puede usar un *.jsfragmento o un archivo de *.jsarchivo cargado externamente
  • utiliza en data:font/opentypelugar de archivo de fuente.
  • agrega guión a la cabeza
  • agrega CSS incrustado a la cabeza
  • agrega una hoja de estilo externa al encabezado

    puede agregar / eliminar / ajustar fácilmente fuentes y selectores de destino de typekit.com

resultados de la prueba

  169ms load of html
  213ms load of js
  31ms load of css
  3ms load of data:font/

ingrese la descripción de la imagen aquí


… Y el método Font Squirrel

@font-face{
    font-weight:400;
    font-style:normal;
    font-family:open_sanslight;
    src:url(../font/opensans-light-webfont.eot);
    src:url(../font/opensans-light-webfont.eot?#iefix) format(embedded-opentype),
        url(../font/opensans-light-webfont.woff) format(woff),
        url(../font/opensans-light-webfont.ttf) format(truetype),
        url(../font/opensans-light-webfont.svg#open_sanslight) format(svg)
}

... o con datos: método de fuente ...

@font-face {
    font-family: 'open_sanslight';
    src: url('opensans-light-webfont-f.eot');
}

@font-face {
    font-family: 'open_sanslight';
    src: url(data:application/x-font-woff;charset=utf-8;base64,d09GRgABAAAAAF4sABMAAAAArXQAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRlRNAAABqAAAABwAAAAcZLn0KkqwK44Jq866WBSpzpsNY2IyGAhoJFBbYjuxmyns5sNa4NwldcJ7eh3Uy5gQkURIlqWzONe3HcLsDX1x/+jifDXvbzgTBjopZElndil3hJkERJkmRJkVRJk3TJkEzJkmzOc4HLXOEOF7nEX/*thisisnotafullencodingjustanexample*/bZwUnK4yS3JlTx2Sr4USKEUSbHVX9fcGNBs4fqgw+GoNHU7lKr36Eqn0lCWt6pHFpWaUlc6lS6loSxRlirLlP/uuU01dVfT7L6gPxyqraluCpgj3WtqeC1V4VBDW2N4K1r1esw/IupKp9L1FwlqnuIAAAB42j3NvQ7BUBjG8R5tTz/0u2UjNTTESYQbMGmXLiISbeI6zBYjbuWtye7CeMJxtuf3LP8ne1+IXbWa7G3TMXZru4qLZkJRW1O2wzi3I+Li2Gik5yXpYkNGXj70YU98YQLGHxwwXxIWwO8SNmAdJBzAXku4gFNI9AF38QMjTwZ9vN6yJzq9OoEB6I8VQzDYK0ZguFKMwWiumIDxTDEFk6liBqaF4gDMFFvKxAfOxFUGAAABUxSL9gAA) format('woff'),
         url('opensans-light-webfont-f.ttf') format('truetype'),
         url('opensans-light-webfont-f.svg#open_sanslight') format('svg');
    font-weight: normal;
    font-style: normal;

}

4
Esta es una buena pregunta.
dachi

1
No estoy seguro de si es el mejor método, pero siempre uso CSS de Google de esta manera<link href='http://fonts.googleapis.com/css?family=Open+Sans:300' rel='stylesheet'>
lefoy

He desarrollado un sitio web como font-squirrel, solo para fuentes web locales Georgian. Estoy usando el método font-squirrel y también me gustaría ver una gran respuesta a esta pregunta.
dachi

1
Este es un artículo muy bueno sobre cómo declarar @font-facedeclaraciones a prueba de balas , tal vez pueda encontrar información útil. paulirish.com/2009/bulletproof-font-face-implementation-syntax
lefoy

Puedo comenzar la recompensa cuando esté disponible para obtener respuestas mejores / mejoradas si no acepta una hasta.
Pescante

Respuestas:


34

Primero, aclararé algo sobre la oferta de Google. De hecho, cargará el formato más pequeño que pueda manejar su navegador. WOFF ofrece archivos de tamaño pequeño y su navegador lo admite, por lo que es el que ve. WOFF también cuenta con un apoyo bastante amplio. Sin embargo, en Opera, por ejemplo, probablemente obtendrá la versión TrueType de la fuente.

La lógica del tamaño del archivo también es, creo, la razón por la que Font Squirrel los prueba en ese orden. Pero eso es principalmente especulación de mi parte.

Si está trabajando en un entorno en el que cada solicitud y cada byte cuenta, tendrá que crear un perfil para descubrir cuál funciona mejor para su caso de uso. ¿La gente solo verá una página y nunca volverá a visitarla? Si es así, las reglas de almacenamiento en caché no importan tanto. Si están navegando o regresando, Google podría tener mejores reglas de almacenamiento en caché que su servidor. ¿Es la latencia el mayor problema o el ancho de banda? Si hay latencia, apunte a menos solicitudes, así que alójelo localmente y combine archivos tanto como sea posible. Si es ancho de banda, elija la opción que termine con el código más pequeño y el formato de fuente más pequeño.

Ahora, pasemos a la consideración de CSS vs JS. Veamos el siguiente fragmento de HTML:

<head>
    <script type="text/javascript" src="script1.js"></script>
    <link rel="stylesheet" type="text/css" href="style1.css" />
    <style type="text/css">
        @import url(style2.css);
    </style>
    <script type="text/javascript">
        (function() {
            var wf = document.createElement('script');
            wf.src = 'script2.js';
            wf.type = 'text/javascript';
            wf.async = 'true';
            var s = document.getElementsByTagName('script')[0];
            s.parentNode.insertBefore(wf, s);
        })();
    </script>
</head>

En muchos casos, script1, style1, ystyle2 sería el bloqueo. Esto significa que el navegador no puede seguir mostrando el documento hasta que ese recurso se haya cargado (aunque los navegadores modernos modifican esto un poco). Lo que realmente puede ser algo bueno, especialmente con las hojas de estilo. Evita un destello de contenido sin estilo y también evita el cambio gigante que ocurriría al aplicar los estilos (y cambiar el contenido es realmente molesto para el usuario).

Por otro lado, script2no estaría bloqueando. Se puede cargar más tarde y el navegador puede pasar a analizar y mostrar el resto del documento. Entonces eso también puede ser beneficioso.

Hablando específicamente de fuentes (y aún más específicamente, la oferta de Google), probablemente me quedaría con un método CSS (me gusta @importporque sigue estilizando con la hoja de estilo, pero podría ser solo yo). El archivo JS cargado por el script ( http://ajax.googleapis.com/ajax/libs/webfont/1/webfont.js ) es más grande que la @font-facedeclaración, y parece mucho más trabajo. Y no creo que cargar la fuente real en sí (WOFF o TTF) esté bloqueando, por lo que no debería retrasar demasiado las cosas. Personalmente, no soy un gran fanático de los CDN, pero el hecho es que son REALMENTE rápidos. Los servidores de Google superarán por completo a la mayoría de los planes de alojamiento compartido, y debido a que sus fuentes son tan populares, es posible que la gente incluso las tenga almacenadas en caché.

Y eso es todo lo que tengo.

No tengo experiencia con Typekit, así que lo dejé fuera de mi teorización. Si hay alguna inexactitud, sin contar las generalizaciones entre navegadores por el bien de los argumentos, indíquelo.


Supuse que en gran parte la mayor parte de esto sería situacional, pero también tomas una buena nota sobre los problemas de bloqueo y FOUT. Leí eso aquí: paulirish.com/2009/fighting-the-font-face-fout & stevesouders.com/blog/2009/10/13/font-face-and-performance . Esta noche haré algunas pruebas y publicaré las diferencias de rendimiento. Gracias por la gran información.
oscuro

11

Creo que ha abordado muy bien los tiempos de carga en su pregunta. Desde mi perspectiva, hay algunas fuentes que deben agregarse a la lista y algunas otras consideraciones que deben examinarse para obtener una visión completa de las opciones.


Algunas otras fuentes de fuentes confiables

tipografía de nube

http://www.typography.com/cloud/

Por lo que puedo decir, las fuentes están incrustadas como datos en un archivo CSS:

@font-face{ 
    font-family: "Font Name"; 
    src: url(data:application/x-font-woff;base64,d09GRk9UVE8AACSCAA0AAAAARKwAAQAAAAAiVAAAAi4AAAadAAAAAAAAAABDRkYgAAAIyAAAFCgAABmIK5m+CkdERUYAABzwAAAAHQAAACAAXQAER1BPUwAAHRAAAAQlAAAYAq+OkMNHU1VC ... ); 
    font-weight:400; font-style:normal; 
} 

Aquí están mis especificaciones:

94ms load of css from their server
37ms load of css from our server (will vary based on your configuration)
195ms load of data:fonts from our server (will vary based on your configuration)

Aquí está su descripción de muy alto nivel de su implementación .

Fonts.com

No he usado este servicio, pero son un proveedor de fuentes muy establecido y la información que han incluido en su sitio es bastante impresionante. No tengo especificaciones sobre sus métodos exactos, pero esto es lo que sé que tienen:

  • Algunas de las fuentes más conocidas del mundo disponibles
  • Una biblioteca de fuentes realmente grande (más de 20.000)
  • Descargas de fuentes de escritorio para hacer maquetas
  • Una herramienta personalizada para probar fuentes web en el navegador.
  • Controles y subconjuntos de tipografía fina
  • Opciones de autohospedaje

FontSpring

Afiliado con FontSquirrel. Las fuentes se pueden comprar aquí por un precio fijo. Se entregan los archivos de fuentes y el CSS que los acompaña, para ser implementados en su propio servidor, al igual que FontSquirrel.


Especificaciones ampliadas

En cuanto a los pros y los contras generales de cada servicio de fuentes, aquí hay algunas comparaciones:

Tamaño de la biblioteca de fuentes

  • Fonts.com : 20.000 +
  • FontSpring : 1000+
  • FontSquirrel : 300+
  • Google : 600+
  • Typekit : 900+
  • Typography.com (cloud.typography.com): probablemente más de 300 (35 familias)

Precios

  • Fonts.com : $ 20 / mes por 500.000 páginas vistas
  • FontSpring : Varía según la fuente (compra única de fuentes)
  • FontSquirrel : Gratis
  • Google : Gratis
  • Typekit : $ 4 / mes por 500,000 páginas vistas
  • Typography.com : $ 12.50 / mes por 1,000,000 de visitas a la página

Calidad de fuente

La calidad de las fuentes web puede variar bastante. Esto puede abarcar cosas como las formas de las letras o el espaciado o el tamaño del conjunto de caracteres. Todo esto determina la impresión general de calidad que dará una fuente. Si bien las opciones gratuitas tienen algunas buenas opciones, también tienen algunas fuentes que no son de tan alta calidad, por lo que debe elegir cuidadosamente entre esas fuentes.

  • Fonts.com : Alto
  • FontSpring : Mixto a alto
  • FontSquirrel : Mixto
  • Google : Mixto
  • Typekit : Alto
  • Typography.com : Muy alto (le doy a esto una designación "muy alta" porque Fonts.com, FontSpring y Typekit admiten múltiples fundiciones tipográficas, donde solo se trata de fuentes de la fundición H&FJ, que se encuentra entre las mejores del mundo)

Calidad de fuente II: tipografía

Hay muchas mejoras en la tipografía de escritorio que han sido muy difíciles de conseguir en las fuentes web. Algunos de estos servicios ofrecen formas de brindarlos.

  • Fonts.com : kerning, espacio entre letras, ligaduras, caracteres alternativos, fracciones, etc.
  • FontSpring : Ninguno
  • FontSquirrel : Ninguno
  • Google : ninguno
  • Typekit : Ninguno
  • Typography.com : versalitas, ligaduras, caracteres alternativos, estilos de números alternativos, fracciones, etc.

Soporte de navegador

Esto se reduce principalmente a los formatos de fuente que admite cada servicio. Los principales son:

  • EOT: para Internet Explorer (IE 4+)
  • TrueType y OpenType: formatos tradicionales (Safari 3.1+, FF 3.5+, Opera 10+)
  • WOFF: Nuevo estándar para fuentes web (FF 3.6+, Chrome 5+)
  • SVG: IOS <4.2

Más información en The @ Font-Face Rule y útiles trucos de fuentes web

Todos estos servicios admiten los principales formatos de fuente. Con fuentes autohospedadas, siempre que use la sintaxis correcta, debe estar cubierto. Aquí hay una actualización de 2011 de la sintaxis a prueba de balas de FontSpring :

@font-face {
  font-family: 'MyWebFont';
  src: url('webfont.eot'); /* IE9 Compat Modes */
  src: url('webfont.eot?#iefix') format('embedded-opentype'), /* IE6-IE8 */
       url('webfont.woff') format('woff'), /* Modern Browsers */
       url('webfont.ttf')  format('truetype'), /* Safari, Android, iOS */
       url('webfont.svg#svgFontName') format('svg'); /* Legacy iOS */
  }

Performance I: Descargas

Por lo que yo entiendo, el uso de la sintaxis anterior permite a los navegadores tomar el formato específico que funciona para ellos, por lo que no hay descargas desperdiciadas en formatos de fuente que no funcionan.

Los servicios pagos como Fonts.com, Typekit o Typography.com utilizan métodos para detectar el formato correcto y luego entregar el formato de fuente correcto, a menudo como datos base64 en un archivo CSS.

Por lo que puedo ver, las diferencias en los métodos que ha enumerado anteriormente son bastante insignificantes para los usuarios de Internet de alta velocidad (parece una diferencia de <200 ms), pero podría valer la pena considerar para dispositivos en redes más lentas, especialmente para visitas a páginas sin caché.

Desempeño II: Subconjunto

Si sabe que solo habrá ciertos caracteres que desea usar, puede construir su fuente con un subconjunto de caracteres y así reducir el tamaño de la descarga.

  • Fonts.com : control muy detallado
  • FontSpring : se puede volver a compilar como subconjunto a través del generador de fuentes web FontSquirrel
  • FontSquirrel : puede recompilar como subconjunto a través del generador de fuentes web
  • Google : control muy detallado
  • Typekit : opciones limitadas de "todos los caracteres" o "predeterminado"
  • Typography.com : control muy detallado

Desempeño III: Entrega

  • Fonts.com : Global CDN o su propio servidor
  • FontSpring : Basado en su servidor
  • FontSquirrel : Basado en su servidor
  • Google : super-CDN global
  • Typekit : CDN global
  • Typography.com : CDN global (125.000 servidores)

Ayuda de idioma

  • Fonts.com : 40 idiomas, incluidos Asia y Oriente Medio
  • FontSpring : occidental, según la fuente
  • FontSquirrel : occidental, según la fuente
  • Google : occidental, según la fuente
  • Typekit : occidental, según la fuente
  • Typography.com : occidental, según la fuente

Prueba e implementación

  • Fonts.com : muy fácil, con herramientas extensas y personalizables
  • FontSpring : Técnico (hágalo usted mismo)
  • FontSquirrel : Técnico (hágalo usted mismo)
  • Google : fácil
  • Typekit : Fácil
  • Typography.com : pruebas fáciles, un poco más complicado para cambiar una vez implementado

Esto no responde a la pregunta de los OP. Simplemente compara varias fuentes web.
stackErr

Este es el más informativo de cada proveedor, ¡gracias por toda esa información!
oscuro

10

Bueno, como buscas

... buscando las mejores prácticas aquí, el rendimiento es una gran cosa, pero también lo es la escalabilidad y la facilidad de uso. Sin mencionar el aspecto y la sensación.

la respuesta es (como siempre en el diseño web): ¡Depende!

Una cosa es segura es que no recomendaría usar el enfoque JS (que se muestra en su segundo ejemplo).

Personalmente no me gusta hacer cosas de presentación y estilos CSS dependiendo de Javascript, aunque la gran mayoría de usuarios lo tienen habilitado. Se trata de no mezclar las cosas.

Y como puede ver en su ejemplo dado, hay algún tipo de FOUC (flasheo de contenido sin estilo), porque el navegador ya representa la página antes de que la fuente esté disponible. Tan pronto como esté, la página se vuelve a dibujar. ¡Y cuanto más grande sea el sitio, mayor será el impacto (de rendimiento)!

Por lo tanto, nunca usaría ninguna solución JS para incrustar fuentes.

Ahora echemos un vistazo a los métodos CSS puros.
Desde hace bastante tiempo aquí hay una discusión sobre "vs. @import". Personalmente prefiero evitar el uso de @import y usar siempre<link> solo. Pero esto es principalmente una cuestión de preferencias personales. ¡Lo único que nunca debes hacer es mezclar ambos!

Local frente a CDN
Al decidir si alojar sus archivos de fuentes localmente o usar una CDN, en mi humilde opinión, depende principalmente del número de fuentes diferentes y las fuentes respectivas que desea incrustar.

¿Por qué es esto importante o juega un papel?
Desde el punto de vista del rendimiento, recomendaría incluir la fuente Base64 codificada en su (una) hoja de estilo. Pero solo el formato .woff, ya que es utilizado por casi todos los navegadores modernos, lo que significa para la mayoría de sus visitantes. Para todos los demás usuarios viven con la solicitud adicional.

Pero debido a la "sobrecarga" causada por la codificación Base64 y el tamaño de un archivo de fuente (incluso en formato .woff), esta técnica solo debe usarse si no tiene más de 3 o 4 fuentes diferentes. Y siempre asegúrese de que su servidor entregue los archivos (CSS) en formato gzip.

La gran ventaja de hacerlo es que no tiene una solicitud adicional para el archivo de fuente. Y después de la primera carga de la página (sin importar la página de su sitio), el archivo CSS se almacena en caché. Esto también es una ventaja si utiliza la caché de la aplicación HTML5 (lo que sin duda hará).

Además del hecho de que un autor no debería usar más de un máximo de 3 o 4 fuentes diferentes en su sitio, echemos un vistazo al método para usar la CDN de Google.

En primer lugar, tenga en cuenta que puede (y siempre debe) incluir todas las fuentes deseadas en una sola <link>, así:

<link href='http://fonts.googleapis.com/css?family=PT+Serif:400,700,400italic,700italic|PT+Sans:400,700,400italic,700italic|Montez' rel='stylesheet' type='text/css'>

Esto resultará en la siguiente respuesta:

@font-face {
  font-family: 'Montez';
  font-style: normal;
  font-weight: 400;
  src: local('Montez'), local('Montez-Regular'), url(http://themes.googleusercontent.com/static/fonts/montez/v4/Zfcl-OLECD6-4EcdWMp-Tw.woff) format('woff');
}
@font-face {
  font-family: 'PT Sans';
  font-style: normal;
  font-weight: 400;
  src: local('PT Sans'), local('PTSans-Regular'), url(http://themes.googleusercontent.com/static/fonts/ptsans/v6/LKf8nhXsWg5ybwEGXk8UBQ.woff) format('woff');
}
@font-face {
  font-family: 'PT Sans';
  font-style: normal;
  font-weight: 700;
  src: local('PT Sans Bold'), local('PTSans-Bold'), url(http://themes.googleusercontent.com/static/fonts/ptsans/v6/0XxGQsSc1g4rdRdjJKZrNBsxEYwM7FgeyaSgU71cLG0.woff) format('woff');
}
@font-face {
  font-family: 'PT Sans';
  font-style: italic;
  font-weight: 400;
  src: local('PT Sans Italic'), local('PTSans-Italic'), url(http://themes.googleusercontent.com/static/fonts/ptsans/v6/PIPMHY90P7jtyjpXuZ2cLD8E0i7KZn-EPnyo3HZu7kw.woff) format('woff');
}
@font-face {
  font-family: 'PT Sans';
  font-style: italic;
  font-weight: 700;
  src: local('PT Sans Bold Italic'), local('PTSans-BoldItalic'), url(http://themes.googleusercontent.com/static/fonts/ptsans/v6/lILlYDvubYemzYzN7GbLkHhCUOGz7vYGh680lGh-uXM.woff) format('woff');
}
@font-face {
  font-family: 'PT Serif';
  font-style: normal;
  font-weight: 400;
  src: local('PT Serif'), local('PTSerif-Regular'), url(http://themes.googleusercontent.com/static/fonts/ptserif/v6/sDRi4fY9bOiJUbgq53yZCfesZW2xOQ-xsNqO47m55DA.woff) format('woff');
}
@font-face {
  font-family: 'PT Serif';
  font-style: normal;
  font-weight: 700;
  src: local('PT Serif Bold'), local('PTSerif-Bold'), url(http://themes.googleusercontent.com/static/fonts/ptserif/v6/QABk9IxT-LFTJ_dQzv7xpIbN6UDyHWBl620a-IRfuBk.woff) format('woff');
}
@font-face {
  font-family: 'PT Serif';
  font-style: italic;
  font-weight: 400;
  src: local('PT Serif Italic'), local('PTSerif-Italic'), url(http://themes.googleusercontent.com/static/fonts/ptserif/v6/03aPdn7fFF3H6ngCgAlQzBsxEYwM7FgeyaSgU71cLG0.woff) format('woff');
}
@font-face {
  font-family: 'PT Serif';
  font-style: italic;
  font-weight: 700;
  src: local('PT Serif Bold Italic'), local('PTSerif-BoldItalic'), url(http://themes.googleusercontent.com/static/fonts/ptserif/v6/Foydq9xJp--nfYIx2TBz9QFhaRv2pGgT5Kf0An0s4MM.woff) format('woff');
}

Como puede ver, hay 9 archivos de fuentes diferentes, lo que significa un total de 10 (incluido el del elemento de enlace) solicitudes, si el usuario no tiene una o más de las fuentes solicitadas instaladas localmente. ¡Y estas solicitudes se repiten en cada solicitud de página nueva a su sitio (aunque no se transfieren más datos)! Además, la respuesta a la solicitud del <link>nunca se almacenará en caché.

Recomendación: ¡
Después de todo, realmente recomendaría incluir su (s) archivo (s) de fuente en formato .woff codificado en Base64 en su hoja de estilo!

¡Vea este bonito artículo para ver un ejemplo y una descripción de cómo hacerlo!


¡Muchas gracias, estaba buscando esta solución!
Ken

3

Utilizo el método css en línea porque la sobrecarga de la solicitud adicional es mayor que el aumento de tamaño cuando se codifica bease64. Esto también se compensa aún más con la compresión gizip por parte del servidor de los archivos css.

Otra opción es usar la carga asincrónica de fuentes, pero la mayoría de las veces los usuarios verán las fuentes apareciendo después de la carga.

Independientemente del método, puede reducir el tamaño del archivo de fuente si solo incluye los conjuntos de caracteres que utilizará.


No hay ninguna sobrecarga adicional mencionada anteriormente cuando se usa HTTP2.
Chris Gunawardena

1

Personalmente utilizo Google Fonts. Tienen una buena variedad de opciones y recientemente han mejorado la compresión de las fuentes al pasar también a la compresión Zopfli . Google se esfuerza por hacer que la web sea más rápida, por lo que supongo que también vendrá de ellos una mayor optimización en esa parte.

Independientemente de lo que elija como entrega de fuentes subcontratada, siempre obtendrá reducciones en la velocidad de las solicitudes para obtener las fuentes. Lo mejor, visto desde una perspectiva de velocidad, sería servir las fuentes usted mismo. Si no le importan esos milisegundos adicionales que se necesitan para cargar desde una entrega subcontratada, debe aceptarlos si cree que la facilidad de uso vale la pena los milisegundos.

No sé sobre Typekit y los demás, pero con Google Fonts puede elegir que le sirvan subconjuntos específicos y rango de caracteres para acelerar la entrega aún más.

Elegir un subconjunto:

<link href="http://fonts.googleapis.com/css?family=Open+Sans&subset=latin" rel="stylesheet">

Elegir una variedad de personajes:

<!-- Only serve H,W,e,l,o,r and d -->
<link href="http://fonts.googleapis.com/css?family=Open+Sans&text=HelloWorld" rel="stylesheet">

Puede utilizar dns-prefetch para mejorar aún más la velocidad con la entrega de fuentes.

Creo, y espero, que Google hará todo lo posible para acelerar la entrega de fuentes tanto como pueda. Los milisegundos que se necesitan para cargarlos no perjudican a mi sitio web, así que los uso felizmente.

Larga historia corta:

Si la entrega de fuentes en milisegundos está dañando su sitio, por ejemplo, al hacer que cargue más del 1 segundo recomendado, creo que debería alojarlas usted mismo.


1
Buen punto en el <link rel=dns-prefetch href='//fonts.googleapis.com'>que lo uso para análisis, mapas de calor y subdominios, por alguna razón no se registró para ejecutarse para las fuentes web externas. Y el tiempo de carga difiere enormemente de una fuente a otra, supongo que si está usando una fuente bastante popular (puede estar almacenada en caché) o solo un puñado de fuentes, usar webfonts es una excelente fuente de fuentes bastante rápida. Publicaré pruebas de velocidad aquí en breve.
oscuro

1

La mejor opción es importar las fuentes usando ajax, así:

<script>
    (function() {
        var font = document.createElement('link'); 
        font.type = 'text/css'; 
        font.rel = 'stylesheet';
        font.href = '/url/to/font.css';
        var s = document.getElementsByTagName('link')[0]; 
        s.parentNode.insertBefore(font, s);
      })();
</script>

Hago esto en mi página web y aumento 9 puntos en la prueba de Google Insights.


Interesante. Tendré que investigar PageSpeeds con este método.
oscuro

2
¿Qué pasa con el asyncatributo? Hace la misma cosa.
Tymek
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.