blocks|key|731324|text|你只是在说元素选择器吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|731325|div+{
++color:+red;
}

input+{
++font-family:+sans-serif;
}|code-block|syntax|javascript|731326|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Are you simply talking about element selectors?

<pre><code>div {
 color: red;
}

input {
 font-family: sans-serif;
}
</code></pre>

blocks|key|2302362|text|不幸的是，字体家族没有简单的“初始值”。如你所知，它依赖于用户代理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2302363|也许你最接近的是使用一个字体关键字。font-family:serif;将使用浏览器认为是默认的serif字体。font-family:sans-serif;是一样的，对无衬线。|offset|length|style|CODE|2302364|这是我能建议的最接近的了，对不起！|2302365|entityMap^0|0|I|I|1K|N|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

Unfortunately, there is no simple "initial value" for font-family. It is, as you know, user-agent dependent.

Perhaps the closest you can come is by using a font keyword. <code>font-family:serif;</code> will use whatever the browser considers to be the default serif font. <code>font-family:sans-serif;</code> is the same, for sans-serif.

This is the closest I can suggest, sorry!

blocks|key|130444|text|是。做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|130445|.my-selector+{
++++font:+initial;
}|code-block|syntax|javascript|130446|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yes. Do

<pre><code>.my-selector {
 font: initial;
}
</code></pre>

blocks|key|2302403|text|根据我的理解，在chrome和firefox中，font-family:+none;工作得很好。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2302404|.element+{
font-family:+none;
}|code-block|syntax|javascript|2302405|此代码将继承到默认浏览器字体。|2302406|entityMap^0|O|I|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

As per my understanding, <code>font-family: none;</code> works fine for me in chrome and firefox.

<pre><code>.element {
font-family: none;
}
</code></pre>

This code will inherit to default browser font.

blocks|key|2302417|text|使用通用字体系列。浏览器将选择“最适合他”的字体:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2302418|font-family:+serif;|code-block|syntax|javascript|2302419|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use a generic font-family. The browser will choose which font is "best" for him :)

<pre><code>font-family: serif;
</code></pre>

blocks|key|731393|text|嗯，我知道您的需求听起来很简单，但不幸的是，这只是web技术的一个限制。我们不能以任何方式使用CSS或jQuery读取浏览器/系统的字体。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|731394|浏览器或系统呈现的字体不能被web应用程序读取。它不是这样设计的。我们所能做的就是应用font-family:serif或类似的东西。|offset|length|style|CODE|731395|我为您尝试了几个POC，但无法检索浏览器默认设置。|731396|我们所能做的就是在W3C中创建一张用于字体家庭重置的新票证，让我们继续希望它们将来能包括类似的东西。|731397|如果我发现了什么，我还是会为你做些调查，然后再联系你。这绝对是一个非常重要的要求..。|731398|我以前处理过这种情况，但情况却相反。就像用所需的字体重写一样。就这样!|731399|然而，|731400|有一个替代方案。，我不会说这是最好的方法，但我们可以试试：|BOLD|731401|Prpeare是一个读取用户代理的JavaScript，如下所示。|731402|var+setDefaultFont+=+{
++++Android:+function+()+{
++++++++$('*').css(+"font-family",+"//FONT+USED+IN+ANDROID+BROWSERS"+);
++++},
++++BlackBerry:+function+()+{
++++++++$('*').css(+"font-family",+"//FONT+USED+IN+BLACKBERRY+BROWSERS"+);
++++},
++++iOS:+function+()+{
++++++++$('*').css(+"font-family",+"//FONT+USED+IN+iOS+BROWSERS"+);
++++},
++++Opera:+function+()+{
++++++++$('*').css(+"font-family",+"//FONT+USED+IN+OPERA+BROWSERS"+);
++++},
++++Windows:+function+()+{
++++++++$('*').css(+"font-family",+"//FONT+USED+IN+WINDOWS+BROWSERS"+);
++++}
};|code-block|syntax|javascript|731403|如果需要的话，我们可以专门使用Windows浏览器。|731404|我知道这不是最好的解决方案，但它应该能工作|731405|entityMap^0|0|17|H|0|0|0|0|0|0|0|8|0|0|0|0|0|L|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1B|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1C|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1D|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1E|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1F|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1G|8|@$D|1H|E|1I|F|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1J|8|@]|9|@]|A|$]]|$1|W|3|X|5|Y|7|1K|8|@]|9|@]|A|$Z|10]]|$1|11|3|12|5|6|7|1L|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|1M|8|@$D|1N|E|1O|F|T]]|9|@]|A|$]]|$1|15|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|16|$]]

Well, I understand your requirement sounds simple but UNFORTUNATELY this is just a limitation of web technologies. We can not read browser's / system's font using either CSS or jQuery in any way. 

The fonts rendered either by browser or system can not be read by web application. It is not designed that way. All we can do is apply <code>font-family:serif</code> or something similar to that.

I tried couple of POC for you but I could not retrieve the browser default settings.

All we can do is create a new ticket in W3C for font-family reset and let's keep hoping that they include something like that in future.. 

I would still do some digging for you and get back to you if I find something. This definitely is one very important requirement.. 

I dealt with such situations before but the other way. Just like overriding with the required font.. That's it!

However,

There is an alternative for this. I won't say it is the best way but we can try this :

Prpeare a JavaScript that reads the user agent, something like this..

<pre><code>var setDefaultFont = {
 Android: function () {
 $('*').css( "font-family", "//FONT USED IN ANDROID BROWSERS" );
 },
 BlackBerry: function () {
 $('*').css( "font-family", "//FONT USED IN BLACKBERRY BROWSERS" );
 },
 iOS: function () {
 $('*').css( "font-family", "//FONT USED IN iOS BROWSERS" );
 },
 Opera: function () {
 $('*').css( "font-family", "//FONT USED IN OPERA BROWSERS" );
 },
 Windows: function () {
 $('*').css( "font-family", "//FONT USED IN WINDOWS BROWSERS" );
 }
};
</code></pre>

We can be specific to Windows browsers if we need..

I know this is not the best solution but it should work

blocks|key|130542|text|你可以这样试一试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|130543|.element+{
+++font-family:+-webkit-body;
+++font-family:+-moz-body
+++font-family:+-o-body
+++font-family:+body
}|code-block|syntax|javascript|130544|并尝试以下同样工作良好的方法：|130545|.element+{
+++font-family:+none;
}|130546|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can try it in this way:

<pre><code>.element {
 font-family: -webkit-body;
 font-family: -moz-body
 font-family: -o-body
 font-family: body
}
</code></pre>

And also try the following which is also working fine:

<pre><code>.element {
 font-family: none;
}
</code></pre>

blocks|key|130574|text|我似乎经常遇到你的问题，它们主要是理论上的案例。在任何情况下，其他人或多或少都指出了正确的方向，但我只想强调一些观点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|130575|显式手段|130576|Javascript和CSS中没有现有的内置功能来显式分配浏览器默认字体。使用当前的CSS规范，这是完全不可能的，然而，理论上，您可以利用Javascript来获取字体的名称，以供显式使用。我不会尝试编写Javascript代码，因为我预测准确地描述是很费时的，但我至少会尝试提供一些线索，说明它是如何实现的。此外，我在任何情况下都不会暗示下面的想法会奏效，但我相信它能奏效。|130577|概念结构|130578|我建议如下：|130579|创建5个跨节点如下：
单空格文本无-+Serif文本Serif文本幻想文本草书文本
五个通用字体系列是浏览器默认设置，但是这并不能立即解决您的问题，因为(+a)它没有给我们一个人正在使用的显式字体名称；(+b)给定元素的默认字体是其中之一，而不是所有这些。
请注意“某人正在使用”；默认情况下浏览器会使用什么，而用户在默认情况下设置默认字体并随后看到的内容则截然不同；这就是Rahul+Patil的结构不完善的原因，尽管我承认这是我最初的假设，而且在大多数情况下他是绝对正确的。
备注
某些元素默认为不同的泛型字体族，并且在浏览器和浏览器之间不一致。例如，默认情况下，代码块通常呈现为单空间。为了保持一致性，您需要使用CSS重置文件。|ordered-list-item|130580|使用类似的方法来检测字体：
http://www.lalit.org/lab/javascript-css-font-detect/
此字体检测还没有准备就绪，您需要对其进行修改，以解析一个字体列表并将其与默认字体匹配。此脚本只显示了适用于您的工作原理；字符尺寸比较，因为通常所有字体的大小在高度和宽度上都不同，而且这种差异在字体大小较大时更容易检测(因此它使用72像素)。
警告
我可以想到的一个主要警告是，这通常只能检测ASCII+/罗马化字体，而且可能不适用于Unicode集；我相信您可以修改它，但要准确地检测字体可能需要大量的计算。您可能会保留一个适用于每种语言的字体数据库，并且需要一种一致的方法来检测浏览器(而不是系统)的语言设置；这是不容易的，甚至对我的知识来说是不可能的。
您可以使用Javascript中的"navigator.language“和"navigator.userLanguage”变量来了解语言设置，但据我所知，这些变量反映的是系统语言，而不是浏览器使用的语言。服务器端代码可能是必要的，以实现这一目标的任何程度的准确性。|offset|length|130581|构建Javascript例程来解析字体列表，并将所述字体与该列表第1项中创建的元素的尺寸进行比较。您可以通过使用Flash获得解析所需的字体列表。我怀疑Java也能做到这一点。这可能会有帮助(JS%2BFlash)：
https://github.com/gabriel/font-detect-js+http://font-detect.s3.amazonaws.com/index.html|130582|从理论上讲，这应该给出这个人使用的显式字体名称。您可以对此进行扩展，并获得每个元素类型的默认泛型字体(例如，sans-serif、serif、单空间、幻想和草书)，但我怀疑这将是CPU密集型的，最好与某些类型的系统级应用程序一起使用；例如，缓存给定成员的给定条件，并创建适合该特定用户的CSS。|130583|隐含手段|130584|很多人建议了其他一些方法，特别是丹尼尔·利西克(+Daniel+Lisik+)，特别强调了我可能做的事情，即"serif“声明在上下文中是无效的，因为声明"sans-serif！重要”会指定"sans-serif"；您实际上可以使用“继承！重要”来构建，并对给定的“字体-家庭！重要”进行严格的字体更改。例如：|130585|<html>

<head>

<style>

div+{+font-family:+Cursive;+}

p+{+font-family:+Inherit+!important;+}

.serif+{+font-family:+Serif;+}
.sans-serif+{+font-family:+Sans-Serif;+}

.serif-important+{+font-family:+Serif+!important;+}
.sans-serif-important+{+font-family:+Sans-Serif+!important;+}

</style>

</head>

<body>

<div>
++++Normal+Div+Text

++++Default+P+Text

++++<p+class="serif">Serif
++++<p+class="sans-serif">Sans-Serif

++++<p+class="serif-important+">Important,+Serif
++++<p+class="sans-serif-important+">Important,+Sans-Serif

</div>

</body>

</html>|code-block|syntax|javascript|130586|“普通分部文本”将以“草书”表示。|unordered-list-item|130587|“默认P文本”将以“草书”表示。|130588|"Serif“将是”草书“。|130589|"Sans-Serif“应该是”草书“。|130590|“重要，塞里夫”将出现在“塞里夫”中。|130591|“重要，Sans-Serif”将出现在"Sans-Serif“中。|130592|如果你需要任何澄清，只要问和我会编辑的必要。|130593|参考文献
http://www.w3.org/TR/CSS21/fonts.html#value-def-generic-family
http://www.w3.org/TR/CSS2/cascade.html#value-def-inherit
资源
http://www.lalit.org/lab/javascript-css-font-detect/
https://github.com/gabriel/font-detect-js
http://font-detect.s3.amazonaws.com/index.html|blockquote|130594|entityMap|0|LINK|mutability|MUTABLE|url|http://www.lalit.org/lab/javascript-css-font-detect/|1|https://github.com/gabriel/font-detect-js|2|http://font-detect.s3.amazonaws.com/index.html|3|http://www.w3.org/TR/CSS21/fonts.html#value-def-generic-family|4|http://www.w3.org/TR/CSS2/cascade.html#value-def-inherit|5|6|7^0|0|0|0|0|0|0|E|1G|0|0|2Z|15|1|45|1A|2|0|0|0|0|0|0|0|0|0|0|0|0|5|1Q|3|1W|1K|4|3K|1G|5|51|15|6|67|1A|7|0^^$0|@$1|2|3|4|5|6|7|24|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|25|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|26|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|27|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|28|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|29|8|@]|9|@]|A|$]]|$1|M|3|N|5|L|7|2A|8|@]|9|@$O|2B|P|2C|1|2D]]|A|$]]|$1|Q|3|R|5|L|7|2E|8|@]|9|@$O|2F|P|2G|1|2H]|$O|2I|P|2J|1|2K]]|A|$]]|$1|S|3|T|5|L|7|2L|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|2M|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2N|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|10|7|2O|8|@]|9|@]|A|$11|12]]|$1|13|3|14|5|15|7|2P|8|@]|9|@]|A|$]]|$1|16|3|17|5|15|7|2Q|8|@]|9|@]|A|$]]|$1|18|3|19|5|15|7|2R|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|15|7|2S|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|15|7|2T|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|15|7|2U|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|1K|7|2W|8|@]|9|@$O|2X|P|2Y|1|2Z]|$O|30|P|31|1|32]|$O|33|P|34|1|35]|$O|36|P|37|1|38]|$O|39|P|3A|1|3B]]|A|$]]|$1|1L|3|-4|5|6|7|3C|8|@]|9|@]|A|$]]]|1M|$1N|$5|1O|1P|1Q|A|$1R|1S]]|1T|$5|1O|1P|1Q|A|$1R|1U]]|1V|$5|1O|1P|1Q|A|$1R|1W]]|1X|$5|1O|1P|1Q|A|$1R|1Y]]|1Z|$5|1O|1P|1Q|A|$1R|20]]|21|$5|1O|1P|1Q|A|$1R|1S]]|22|$5|1O|1P|1Q|A|$1R|1U]]|23|$5|1O|1P|1Q|A|$1R|1W]]]]

I've been coming across your questions on a somewhat regular basis it seems, and they appear largely theoretical cases. In any case, the others have more or less pointed you in the right direction, but I'm going to sound off just to re-enforce some points.

<h1>Explicit Means</h1>

There is no existing built-in functionality in Javascript nor CSS to explicitly assign the browser default font. This is outright impossible with the present CSS specification, however, you could, theoretically, utilize Javascript to get the name of the font for explicit use. I will not attempt to write the Javascript code because I predict it would be time consuming to accurately portray, but I will at least try to provide light on how it may be possible. Additionally, I under no circumstances am implying the following idea will work, but I believe it could work.

<h2>Conceptual Structure</h2>

I'd suggest the following:

<ol>
<li>Create 5 span nodes as following:

<pre><code>&lt;span style="font-family: monospace;"&gt;Monospace Text&lt;/span&gt;
&lt;span style="font-family: sans-serif;"&gt;Sans-Serif Text&lt;/span&gt;
&lt;span style="font-family: serif;"&gt;Serif Text&lt;/span&gt;
&lt;span style="font-family: fantasy;"&gt;Fantasy Text&lt;/span&gt;
&lt;span style="font-family: cursive;"&gt;Cursive Text&lt;/span&gt;
</code></pre>

The five generic font families are the browser defaults, however this does not immediately resolve your question because a) it does not give us an explicit font-name that a person is using and b) the default font for a given element is one of these, not all of them.

Pay respect to the words "a person is using"; what the browser would have used by default versus what the user has set the default font to and subsequently sees by default is very different; this is why Rahul Patil's structure would be imperfect, despite I'll admit this was my original assumption and in most cases he would be absolutely correct.

<h3>Note</h3>

Certain elements default to different generic font families, and are not consistent from browser to browser. Code blocks, for example, are typically rendered as monospace by default. For consistency, you will need to utilize a CSS Reset file.</li>
<li>Use something like this to detect the font:

<pre><code>http://www.lalit.org/lab/javascript-css-font-detect/
</code></pre>

This font detection is not ready for what you need out of the box, you need to modify it to parse a list of fonts and match it to the default. This script only shows the theory behind what may work for you; character dimension comparison, as typically all fonts are different in size in height and width, and that difference is easier to detect when the font size is large (hence why it uses 72 pixels).

<h3>Caveat</h3>

One major caveat I can think of is that this will typically only be able to detect ASCII / Romanized fonts and may not apply to Unicode sets; I'm sure you could modify it, but it may computationally intensive to accurately detect the font. You would likely retain a database of fonts applicable to each language, and you would need a consistent way to detect the language settings for the browser (and not the system); this is not easy, or even possible to my knowledge in a consistent way. 

You can obtain an idea of the language settings using the "navigator.language" and "navigator.userLanguage" variables in Javascript, but these, to my knowledge reflect the system language and not the language used by the browser. Server side code would likely be necessary for this to be achieved with any degree of accuracy.</li>
<li>Build a Javascript routine to parse a list of fonts, and compare said fonts against the dimensions of the elements created in Item 1 of this list. You can get a list of fonts necessary to parse by using Flash. I'd suspect a Java applet would be able to do this as well. This may be helpful (JS+Flash):

<pre><code>https://github.com/gabriel/font-detect-js
http://font-detect.s3.amazonaws.com/index.html
</code></pre></li>
<li>This should, theoretically, give you the explicit font name used by the person. You could extend upon this and also get the default generic fonts for each individual element type (e.g. sans-serif, serif, monospace, fantasy and cursive), but I suspect this would be CPU intensive and would be best used with some of type of system level application; e.g. caching the given conditions for a given member, and create the CSS catered to that specific user.</li>
</ol>

<h1>Implicit Means</h1>

A number of people suggested some other means, Daniel Lisik in particular highlighted what I may do, with respect that is "serif" declaration is invalid in it's context, since declaring "sans-serif !important" would assign "sans-serif"; you can actually build up using "inherit !important" and make strict font-family changes with the given "font-family !important". For example:

<pre><code>&lt;html&gt;

&lt;head&gt;

&lt;style&gt;

div { font-family: Cursive; }

p { font-family: Inherit !important; }

.serif { font-family: Serif; }
.sans-serif { font-family: Sans-Serif; }

.serif-important { font-family: Serif !important; }
.sans-serif-important { font-family: Sans-Serif !important; }

&lt;/style&gt;

&lt;/head&gt;

&lt;body&gt;

&lt;div&gt;
 Normal Div Text

 &lt;p&gt;Default P Text&lt;/p&gt;

 &lt;p class="serif"&gt;Serif&lt;/p&gt;
 &lt;p class="sans-serif"&gt;Sans-Serif&lt;/p&gt;

 &lt;p class="serif-important "&gt;Important, Serif&lt;/p&gt;
 &lt;p class="sans-serif-important "&gt;Important, Sans-Serif&lt;/p&gt;

&lt;/div&gt;

&lt;/body&gt;

&lt;/html&gt;
</code></pre>

<ul>
<li>"Normal Div Text" would be in "Cursive"</li>
<li>"Default P Text" would be in "Cursive"</li>
<li>"Serif" would be in "Cursive"</li>
<li>"Sans-Serif" would be in "Cursive"</li>
<li>"Important, Serif" would be in "Serif"</li>
<li>"Important, Sans-Serif" would be in "Sans-Serif"</li>
</ul>

If you need any clarifications, just ask and I'll edit as necessary.

<blockquote>
 References
 
 <a href="http://www.w3.org/TR/CSS21/fonts.html#value-def-generic-family" rel="nofollow">http://www.w3.org/TR/CSS21/fonts.html#value-def-generic-family</a>
 
 <a href="http://www.w3.org/TR/CSS2/cascade.html#value-def-inherit" rel="nofollow">http://www.w3.org/TR/CSS2/cascade.html#value-def-inherit</a>
 
 Resources
 
 <a href="http://www.lalit.org/lab/javascript-css-font-detect/" rel="nofollow">http://www.lalit.org/lab/javascript-css-font-detect/</a>
 
 <a href="https://github.com/gabriel/font-detect-js" rel="nofollow">https://github.com/gabriel/font-detect-js</a>
 
 <a href="http://font-detect.s3.amazonaws.com/index.html" rel="nofollow">http://font-detect.s3.amazonaws.com/index.html</a>
</blockquote>

blocks|key|130619|text|你的问题不太清楚。我不知道我是否误解了，但无论如何我都会尽力帮忙的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|130620|如果您真的决心尊重浏览器中设置的默认浏览器字体和字体大小，那么这将起到以下作用：|130621|html,+body+{
++++font-size:+100%25+!important;+
}

body+{
++++font-family:+serif+!important;+/*+Or+sans-serif,+monospace+or+whatever+is+appropriate.+*/
}|code-block|syntax|javascript|130622|然后继承应该启动，只要您不设置字体堆栈或大小的一切。|130623|请记住，级联顺序在这里发挥作用。|offset|length|130624|这将覆盖所有类型的样式表，除了、、用户样式表、包含在相关元素上设置的、、声明的。在这种情况下，您只需要尊重用户的选择。|style|BOLD|130625|就我个人而言，我只想写：|130626|html,+body+{
++++font-size:+100%25;+
}

body+{
++++font-family:+serif;+/*+Or+sans-serif,+monospace+or+whatever+is+appropriate.+*/
}|130627|然后，我将避免在其他任何东西上设置字体堆栈，因为如果用户真的决定采用自己的方式，他可能会在自己的用户样式表中设置对他重要的元素(如字体等)的!important声明--这将覆盖一个普通的作者样式表(省略!important声明)。|CODE|130628|其他的是正确的，initial关键字是一个可行的方法，只要您不担心IE，因为没有版本的IE支持它。|130629|所以我认为你最好的选择是为IE寻找某种类型的填充，或者创建你自己的。现代主义可能值得一看，或者如果您想创建自己的，有polyfill.js。我不知道如何创建多填区，对不起！|130630|我知道这不是一个完美的答案(现在是早上6点，我已经熬夜了一整晚)，但我希望这在某种程度上对你有所帮助。|130631|我刚刚意识到你可能指的是劫持浏览器的设置来设置你想要设置的默认字体，不管用户是如何设置的。那样做是毫无意义的。在任何情况下，我认为如果用户有自己的用户样式表(特别是在字体属性上设置了!important声明)，这是行不通的。|130632|entityMap|0|LINK|mutability|MUTABLE|url|http://reference.sitepoint.com/css/cascade|1|http://philipwalton.github.io/polyfill/^0|0|0|0|0|4|4|0|0|C|3|G|E|Z|O|0|0|C|0|0|0|37|1Y|A|2T|A|0|0|1D|8|7|0|0|2E|1M|B|1|0|0|1F|0|0|34|2J|A|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1I|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1J|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1K|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1L|8|@]|9|@$M|1M|N|1N|1|1O]]|A|$]]|$1|O|3|P|5|6|7|1P|8|@$M|1Q|N|1R|Q|R]|$M|1S|N|1T|Q|R]|$M|1U|N|1V|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1W|8|@$M|1X|N|1Y|Q|R]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1Z|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|20|8|@$M|21|N|22|Q|R]|$M|23|N|24|Q|Y]|$M|25|N|26|Q|Y]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|27|8|@$M|28|N|29|Q|R]|$M|2A|N|2B|Q|Y]]|9|@]|A|$]]|$1|11|3|12|5|6|7|2C|8|@$M|2D|N|2E|Q|R]]|9|@$M|2F|N|2G|1|2H]]|A|$]]|$1|13|3|14|5|6|7|2I|8|@$M|2J|N|2K|Q|R]]|9|@]|A|$]]|$1|15|3|16|5|6|7|2L|8|@$M|2M|N|2N|Q|R]|$M|2O|N|2P|Q|Y]]|9|@]|A|$]]|$1|17|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]]|18|$19|$5|1A|1B|1C|A|$1D|1E]]|1F|$5|1A|1B|1C|A|$1D|1G]]]]

Your question isn't very clear. I don't know if I've misunderstood but I will try to help anyway.

If you're really determined to respect the default browser fonts and font sizes set in the browser then this should do the trick:

<pre><code>html, body {
 font-size: 100% !important; 
}

body {
 font-family: serif !important; /* Or sans-serif, monospace or whatever is appropriate. */
}
</code></pre>

Then the inheritance should kick in, as long as you don't set font stacks or sizes on everything else. 

Bear in mind, <a href="http://reference.sitepoint.com/css/cascade" rel="nofollow">the cascade order</a> comes into play here.

This would override all types of stylesheets except for user stylesheets containing <code>!important</code> declarations set on relevant elements. In this particular case, you just need to respect the user's choices.

Personally, I would just write this:

<pre><code>html, body {
 font-size: 100%; 
}

body {
 font-family: serif; /* Or sans-serif, monospace or whatever is appropriate. */
}
</code></pre>

Then I would refrain from setting font stacks on everything else simply because, if an user was really determined to have his own way, he's likely to have set <code>!important</code> declarations on the elements that matter to him, like fonts, etc in his own user stylesheet - and this will override a normal author stylesheet (which omits <code>!important</code> declarations).

The others are right, the <code>initial</code> keyword is a viable method as long as you're not worried about IE because, no version of IE supports it. 

So I think your best bet is to look for a polyfill of some sort for IE, or create your own. Modernizer might be worth a look or if you want to create your own, there's <a href="http://philipwalton.github.io/polyfill/" rel="nofollow">polyfill.js</a>. I don't know anything about creating polyfills, sorry!

I know it's not a perfect answer (it's 6am and I've been up all night), but I hope it helps you in some way.

P.S. I've just realised you might have been referring to hijacking a browser's settings to set the default font you want set, regardless of how the user has it set up. It would be pointless doing that. In any case, I don't think it would work if an user has his own user stylesheet especially if it has <code>!important</code> declarations set on the font properties.

blocks|key|2302614|text|这个问题已经得到了回答，但我找到了一个可能有用的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2302615|*,+html,+body+{
+++++font-family:+inherit+!important;
}|code-block|syntax|javascript|2302616|这告诉HTML文档的根元素从父元素继承它们的字体。在这种情况下，父浏览器将是浏览器的用户代理样式，因此您的字体将从默认继承。|2302617|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This has already been answered, but I found a solution that may be helpful:

<pre><code>*, html, body {
 font-family: inherit !important;
}
</code></pre>

This tells the root elements of the HTML document to inherit their font from the parent. In this case, the parent would be the browser's user agent styles, so your fonts will inherit from the default.

If web designer has a full control over the entire code, it is easy to use browser default font - just don't change any font style and you got it.

However if there is not a full control over it and for example there is some font-related style defined on <code>html</code> or <code>body</code> element, or font-related CSS style for <code>* { ... }</code>, then there is a need to redefine font style to not inherit modified styling.

Is there any way, <code>CSS</code>, pure <code>JavaScript</code> or <code>jQuery</code> solution that would allow explicitly set browser default font for specific element?

CSS for browser default font

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如果web designer完全控制了整个代码，那么使用浏览器默认字体就很容易了--只要不改变任何字体样式，你就会得到它。但是，如果存在而不是完全控制它，例如在html或body元素上定义了一些与字体相关的样式，或者* { ... }中定义了与字体相关的CSS样式，那么需要重新定义字体样式，以避免继承修改后的样式。CS...

问浏览器默认字体的CSS
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问浏览器默认字体的CSSEN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问浏览器默认字体的CSS
EN