From 1386fed7d38652d5848d315927e7e23a66cffd13 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Wed, 20 Oct 2021 13:28:52 +0300
Subject: [RU] Remove `name` attribute from headings (#2788)

---
 .../control_flow_and_error_handling/index.html     |  4 +--
 .../guide/expressions_and_operators/index.html     | 22 ++++++------
 files/ru/web/javascript/guide/functions/index.html | 16 ++++-----
 .../javascript/guide/grammar_and_types/index.html  |  2 +-
 .../reference/functions/arrow_functions/index.html |  2 +-
 .../functions/default_parameters/index.html        |  6 ++--
 .../javascript/reference/functions/get/index.html  |  2 +-
 .../web/javascript/reference/functions/index.html  | 24 ++++++-------
 .../reference/functions/rest_parameters/index.html |  6 ++--
 .../global_objects/array/@@iterator/index.html     | 16 ++++-----
 .../global_objects/array/copywithin/index.html     | 18 +++++-----
 .../global_objects/array/entries/index.html        | 12 +++----
 .../global_objects/array/every/index.html          | 22 ++++++------
 .../reference/global_objects/array/fill/index.html | 16 ++++-----
 .../global_objects/array/filter/index.html         | 26 +++++++-------
 .../reference/global_objects/array/find/index.html | 20 +++++------
 .../global_objects/array/findindex/index.html      | 20 +++++------
 .../global_objects/array/foreach/index.html        | 22 ++++++------
 .../reference/global_objects/array/from/index.html | 16 ++++-----
 .../reference/global_objects/array/index.html      | 40 ++++++++++-----------
 .../global_objects/array/indexof/index.html        | 22 ++++++------
 .../global_objects/array/isarray/index.html        | 18 +++++-----
 .../reference/global_objects/array/join/index.html | 18 +++++-----
 .../reference/global_objects/array/keys/index.html | 14 ++++----
 .../global_objects/array/lastindexof/index.html    | 20 +++++------
 .../global_objects/array/length/index.html         | 18 +++++-----
 .../reference/global_objects/array/map/index.html  | 28 +++++++--------
 .../reference/global_objects/array/of/index.html   | 16 ++++-----
 .../reference/global_objects/array/pop/index.html  | 18 +++++-----
 .../reference/global_objects/array/push/index.html | 22 ++++++------
 .../global_objects/array/reduce/index.html         | 20 +++++------
 .../global_objects/array/reduceright/index.html    | 22 ++++++------
 .../global_objects/array/reverse/index.html        | 16 ++++-----
 .../global_objects/array/shift/index.html          | 16 ++++-----
 .../global_objects/array/slice/index.html          | 22 ++++++------
 .../reference/global_objects/array/some/index.html | 20 +++++------
 .../reference/global_objects/array/sort/index.html | 22 ++++++------
 .../global_objects/array/splice/index.html         | 18 +++++-----
 .../global_objects/array/tolocalestring/index.html | 18 +++++-----
 .../global_objects/array/tosource/index.html       | 18 +++++-----
 .../global_objects/array/tostring/index.html       | 16 ++++-----
 .../global_objects/array/unshift/index.html        | 18 +++++-----
 .../global_objects/array/values/index.html         | 16 ++++-----
 .../reference/global_objects/boolean/index.html    | 28 +++++++--------
 .../global_objects/boolean/tosource/index.html     | 14 ++++----
 .../global_objects/boolean/tostring/index.html     | 18 +++++-----
 .../global_objects/boolean/valueof/index.html      | 18 +++++-----
 .../global_objects/date/getdate/index.html         | 18 +++++-----
 .../global_objects/date/getday/index.html          | 18 +++++-----
 .../global_objects/date/getfullyear/index.html     | 18 +++++-----
 .../global_objects/date/gethours/index.html        | 18 +++++-----
 .../global_objects/date/getmilliseconds/index.html | 18 +++++-----
 .../global_objects/date/getminutes/index.html      | 18 +++++-----
 .../global_objects/date/getmonth/index.html        | 18 +++++-----
 .../global_objects/date/getseconds/index.html      | 18 +++++-----
 .../global_objects/date/gettime/index.html         | 18 +++++-----
 .../date/gettimezoneoffset/index.html              | 16 ++++-----
 .../global_objects/date/getutcdate/index.html      | 18 +++++-----
 .../global_objects/date/getutcday/index.html       | 18 +++++-----
 .../global_objects/date/getutcfullyear/index.html  | 18 +++++-----
 .../global_objects/date/getutchours/index.html     | 18 +++++-----
 .../date/getutcmilliseconds/index.html             | 18 +++++-----
 .../global_objects/date/getutcminutes/index.html   | 18 +++++-----
 .../global_objects/date/getutcmonth/index.html     | 18 +++++-----
 .../global_objects/date/getutcseconds/index.html   | 18 +++++-----
 .../global_objects/date/getyear/index.html         | 28 +++++++--------
 .../reference/global_objects/date/index.html       | 26 +++++++-------
 .../reference/global_objects/date/now/index.html   | 16 ++++-----
 .../reference/global_objects/date/parse/index.html | 24 ++++++-------
 .../global_objects/date/setdate/index.html         | 18 +++++-----
 .../global_objects/date/setfullyear/index.html     | 20 +++++------
 .../global_objects/date/sethours/index.html        | 18 +++++-----
 .../global_objects/date/setmilliseconds/index.html | 18 +++++-----
 .../global_objects/date/setminutes/index.html      | 18 +++++-----
 .../global_objects/date/setmonth/index.html        | 18 +++++-----
 .../global_objects/date/setseconds/index.html      | 18 +++++-----
 .../global_objects/date/settime/index.html         | 18 +++++-----
 .../global_objects/date/setutcdate/index.html      | 18 +++++-----
 .../global_objects/date/setutcfullyear/index.html  | 18 +++++-----
 .../global_objects/date/setutchours/index.html     | 18 +++++-----
 .../date/setutcmilliseconds/index.html             | 18 +++++-----
 .../global_objects/date/setutcminutes/index.html   | 18 +++++-----
 .../global_objects/date/setutcmonth/index.html     | 18 +++++-----
 .../global_objects/date/setutcseconds/index.html   | 18 +++++-----
 .../global_objects/date/setyear/index.html         | 18 +++++-----
 .../global_objects/date/todatestring/index.html    | 16 ++++-----
 .../global_objects/date/togmtstring/index.html     | 14 ++++----
 .../global_objects/date/toisostring/index.html     | 16 ++++-----
 .../global_objects/date/tojson/index.html          | 16 ++++-----
 .../date/tolocaledatestring/index.html             | 24 ++++++-------
 .../global_objects/date/tolocalestring/index.html  | 24 ++++++-------
 .../date/tolocaletimestring/index.html             | 24 ++++++-------
 .../global_objects/date/tosource/index.html        | 14 ++++----
 .../global_objects/date/tostring/index.html        | 18 +++++-----
 .../global_objects/date/totimestring/index.html    | 16 ++++-----
 .../global_objects/date/toutcstring/index.html     | 18 +++++-----
 .../reference/global_objects/date/utc/index.html   | 16 ++++-----
 .../global_objects/date/valueof/index.html         | 18 +++++-----
 .../reference/global_objects/decodeuri/index.html  |  6 ++--
 .../global_objects/decodeuricomponent/index.html   |  8 ++---
 .../reference/global_objects/encodeuri/index.html  |  8 ++---
 .../global_objects/error/columnnumber/index.html   | 12 +++----
 .../global_objects/error/filename/index.html       | 14 ++++----
 .../reference/global_objects/error/index.html      | 32 ++++++++---------
 .../global_objects/error/linenumber/index.html     | 14 ++++----
 .../global_objects/error/message/index.html        | 14 ++++----
 .../reference/global_objects/error/name/index.html | 14 ++++----
 .../global_objects/error/stack/index.html          | 14 ++++----
 .../global_objects/error/tosource/index.html       | 12 +++----
 .../global_objects/error/tostring/index.html       | 14 ++++----
 .../reference/global_objects/eval/index.html       |  2 +-
 .../reference/global_objects/evalerror/index.html  | 28 +++++++--------
 .../global_objects/function/apply/index.html       | 22 ++++++------
 .../global_objects/function/arguments/index.html   | 12 +++----
 .../global_objects/function/bind/index.html        | 28 +++++++--------
 .../global_objects/function/call/index.html        | 20 +++++------
 .../global_objects/function/caller/index.html      | 16 ++++-----
 .../global_objects/function/displayname/index.html | 10 +++---
 .../global_objects/function/length/index.html      | 16 ++++-----
 .../global_objects/function/name/index.html        |  4 +--
 .../global_objects/function/tosource/index.html    | 14 ++++----
 .../global_objects/function/tostring/index.html    | 14 ++++----
 .../javascript/reference/global_objects/index.html | 30 ++++++++--------
 .../reference/global_objects/infinity/index.html   | 10 +++---
 .../global_objects/internalerror/index.html        | 24 ++++++-------
 .../intl/collator/compare/index.html               | 20 +++++------
 .../global_objects/intl/collator/index.html        | 32 ++++++++---------
 .../intl/collator/resolvedoptions/index.html       | 12 +++----
 .../intl/collator/supportedlocalesof/index.html    | 18 +++++-----
 .../intl/datetimeformat/format/index.html          | 20 +++++------
 .../global_objects/intl/datetimeformat/index.html  | 32 ++++++++---------
 .../intl/datetimeformat/resolvedoptions/index.html | 12 +++----
 .../datetimeformat/supportedlocalesof/index.html   | 18 +++++-----
 .../reference/global_objects/intl/index.html       | 18 +++++-----
 .../intl/numberformat/format/index.html            | 20 +++++------
 .../global_objects/intl/numberformat/index.html    | 32 ++++++++---------
 .../intl/numberformat/resolvedoptions/index.html   | 12 +++----
 .../numberformat/supportedlocalesof/index.html     | 18 +++++-----
 .../reference/global_objects/isfinite/index.html   | 10 +++---
 .../reference/global_objects/isnan/index.html      | 16 ++++-----
 .../reference/global_objects/json/index.html       | 16 ++++-----
 .../reference/global_objects/json/parse/index.html | 22 ++++++------
 .../global_objects/json/stringify/index.html       | 22 ++++++------
 .../reference/global_objects/math/abs/index.html   | 18 +++++-----
 .../reference/global_objects/math/acos/index.html  | 18 +++++-----
 .../reference/global_objects/math/acosh/index.html | 20 +++++------
 .../reference/global_objects/math/asin/index.html  | 18 +++++-----
 .../reference/global_objects/math/asinh/index.html | 20 +++++------
 .../reference/global_objects/math/atan/index.html  | 18 +++++-----
 .../reference/global_objects/math/atan2/index.html | 18 +++++-----
 .../reference/global_objects/math/atanh/index.html | 20 +++++------
 .../reference/global_objects/math/cbrt/index.html  | 18 +++++-----
 .../reference/global_objects/math/ceil/index.html  | 20 +++++------
 .../reference/global_objects/math/clz32/index.html | 20 +++++------
 .../reference/global_objects/math/cos/index.html   | 18 +++++-----
 .../reference/global_objects/math/cosh/index.html  | 20 +++++------
 .../reference/global_objects/math/e/index.html     | 14 ++++----
 .../reference/global_objects/math/exp/index.html   | 18 +++++-----
 .../reference/global_objects/math/expm1/index.html | 20 +++++------
 .../reference/global_objects/math/floor/index.html | 20 +++++------
 .../global_objects/math/fround/index.html          | 20 +++++------
 .../reference/global_objects/math/hypot/index.html | 20 +++++------
 .../reference/global_objects/math/imul/index.html  | 18 +++++-----
 .../reference/global_objects/math/index.html       | 12 +++----
 .../reference/global_objects/math/ln10/index.html  | 14 ++++----
 .../reference/global_objects/math/ln2/index.html   | 14 ++++----
 .../reference/global_objects/math/log/index.html   | 20 +++++------
 .../reference/global_objects/math/log10/index.html | 20 +++++------
 .../global_objects/math/log10e/index.html          | 14 ++++----
 .../reference/global_objects/math/log1p/index.html | 20 +++++------
 .../reference/global_objects/math/log2/index.html  | 20 +++++------
 .../reference/global_objects/math/log2e/index.html | 14 ++++----
 .../reference/global_objects/math/max/index.html   | 18 +++++-----
 .../reference/global_objects/math/min/index.html   | 20 +++++------
 .../reference/global_objects/math/pi/index.html    | 14 ++++----
 .../reference/global_objects/math/pow/index.html   | 18 +++++-----
 .../global_objects/math/random/index.html          | 10 +++---
 .../reference/global_objects/math/round/index.html | 20 +++++------
 .../reference/global_objects/math/sign/index.html  | 20 +++++------
 .../reference/global_objects/math/sin/index.html   | 18 +++++-----
 .../reference/global_objects/math/sinh/index.html  | 20 +++++------
 .../reference/global_objects/math/sqrt/index.html  | 18 +++++-----
 .../global_objects/math/sqrt1_2/index.html         | 14 ++++----
 .../reference/global_objects/math/sqrt2/index.html | 14 ++++----
 .../reference/global_objects/math/tan/index.html   | 18 +++++-----
 .../reference/global_objects/math/tanh/index.html  | 20 +++++------
 .../reference/global_objects/math/trunc/index.html | 14 ++++----
 .../reference/global_objects/nan/index.html        | 12 +++----
 .../reference/global_objects/null/index.html       | 12 +++----
 .../global_objects/number/epsilon/index.html       | 14 ++++----
 .../reference/global_objects/number/index.html     | 30 ++++++++--------
 .../global_objects/number/isfinite/index.html      | 18 +++++-----
 .../global_objects/number/isinteger/index.html     | 16 ++++-----
 .../global_objects/number/isnan/index.html         | 16 ++++-----
 .../global_objects/number/issafeinteger/index.html | 14 ++++----
 .../number/max_safe_integer/index.html             | 14 ++++----
 .../global_objects/number/max_value/index.html     | 14 ++++----
 .../number/min_safe_integer/index.html             | 12 +++----
 .../global_objects/number/min_value/index.html     | 14 ++++----
 .../reference/global_objects/number/nan/index.html |  8 ++---
 .../number/negative_infinity/index.html            | 14 ++++----
 .../global_objects/number/parsefloat/index.html    | 14 ++++----
 .../global_objects/number/parseint/index.html      | 14 ++++----
 .../number/positive_infinity/index.html            | 14 ++++----
 .../global_objects/number/toexponential/index.html | 20 +++++------
 .../global_objects/number/tofixed/index.html       | 20 +++++------
 .../number/tolocalestring/index.html               | 22 ++++++------
 .../global_objects/number/toprecision/index.html   | 20 +++++------
 .../global_objects/number/tosource/index.html      | 14 ++++----
 .../global_objects/number/tostring/index.html      | 20 +++++------
 .../global_objects/number/valueof/index.html       | 18 +++++-----
 .../object/__definegetter__/index.html             | 16 ++++-----
 .../object/__definesetter__/index.html             | 16 ++++-----
 .../object/__lookupgetter__/index.html             | 16 ++++-----
 .../object/__lookupsetter__/index.html             | 16 ++++-----
 .../global_objects/object/assign/index.html        | 32 ++++++++---------
 .../global_objects/object/constructor/index.html   | 14 ++++----
 .../global_objects/object/create/index.html        | 20 +++++------
 .../object/defineproperties/index.html             | 18 +++++-----
 .../object/defineproperty/index.html               | 34 +++++++++---------
 .../global_objects/object/freeze/index.html        | 16 ++++-----
 .../object/getownpropertydescriptor/index.html     | 20 +++++------
 .../object/getownpropertynames/index.html          | 20 +++++------
 .../object/getownpropertysymbols/index.html        | 14 ++++----
 .../object/getprototypeof/index.html               | 18 +++++-----
 .../object/hasownproperty/index.html               | 24 ++++++-------
 .../reference/global_objects/object/index.html     | 28 +++++++--------
 .../reference/global_objects/object/is/index.html  | 18 +++++-----
 .../global_objects/object/isextensible/index.html  | 18 +++++-----
 .../global_objects/object/isfrozen/index.html      | 18 +++++-----
 .../global_objects/object/isprototypeof/index.html | 14 ++++----
 .../global_objects/object/issealed/index.html      | 18 +++++-----
 .../global_objects/object/keys/index.html          | 20 +++++------
 .../object/preventextensions/index.html            | 16 ++++-----
 .../object/propertyisenumerable/index.html         | 22 ++++++------
 .../global_objects/object/proto/index.html         | 14 ++++----
 .../global_objects/object/seal/index.html          | 16 ++++-----
 .../object/setprototypeof/index.html               | 28 +++++++--------
 .../object/tolocalestring/index.html               | 14 ++++----
 .../global_objects/object/tosource/index.html      | 22 ++++++------
 .../global_objects/object/tostring/index.html      | 16 ++++-----
 .../global_objects/object/valueof/index.html       | 18 +++++-----
 .../reference/global_objects/parsefloat/index.html |  2 +-
 .../reference/global_objects/parseint/index.html   | 14 ++++----
 .../global_objects/promise/all/index.html          |  6 ++--
 .../reference/global_objects/proxy/index.html      |  2 +-
 .../reference/global_objects/rangeerror/index.html | 28 +++++++--------
 .../global_objects/regexp/exec/index.html          | 22 ++++++------
 .../global_objects/regexp/flags/index.html         | 16 ++++-----
 .../global_objects/regexp/global/index.html        | 14 ++++----
 .../global_objects/regexp/ignorecase/index.html    | 14 ++++----
 .../reference/global_objects/regexp/index.html     | 42 +++++++++++-----------
 .../global_objects/regexp/lastindex/index.html     | 16 ++++-----
 .../global_objects/regexp/multiline/index.html     | 14 ++++----
 .../global_objects/regexp/source/index.html        | 12 +++----
 .../global_objects/regexp/sticky/index.html        | 16 ++++-----
 .../global_objects/regexp/test/index.html          | 20 +++++------
 .../global_objects/regexp/tosource/index.html      | 14 ++++----
 .../global_objects/regexp/tostring/index.html      | 18 +++++-----
 .../reference/global_objects/set/index.html        |  4 +--
 .../global_objects/string/@@iterator/index.html    | 14 ++++----
 .../global_objects/string/anchor/index.html        | 18 +++++-----
 .../reference/global_objects/string/big/index.html | 16 ++++-----
 .../global_objects/string/blink/index.html         | 16 ++++-----
 .../global_objects/string/bold/index.html          | 16 ++++-----
 .../global_objects/string/charat/index.html        | 22 ++++++------
 .../global_objects/string/charcodeat/index.html    | 22 ++++++------
 .../global_objects/string/codepointat/index.html   | 20 +++++------
 .../global_objects/string/concat/index.html        | 20 +++++------
 .../global_objects/string/endswith/index.html      | 20 +++++------
 .../global_objects/string/fixed/index.html         | 16 ++++-----
 .../global_objects/string/fontcolor/index.html     | 18 +++++-----
 .../global_objects/string/fontsize/index.html      | 18 +++++-----
 .../global_objects/string/fromcharcode/index.html  | 20 +++++------
 .../global_objects/string/fromcodepoint/index.html | 22 ++++++------
 .../reference/global_objects/string/index.html     | 38 ++++++++++----------
 .../global_objects/string/indexof/index.html       | 26 +++++++-------
 .../global_objects/string/italics/index.html       | 16 ++++-----
 .../global_objects/string/lastindexof/index.html   | 20 +++++------
 .../global_objects/string/length/index.html        | 16 ++++-----
 .../global_objects/string/link/index.html          | 18 +++++-----
 .../global_objects/string/localecompare/index.html | 26 +++++++-------
 .../global_objects/string/match/index.html         | 24 ++++++-------
 .../global_objects/string/normalize/index.html     | 20 +++++------
 .../reference/global_objects/string/raw/index.html | 20 +++++------
 .../global_objects/string/repeat/index.html        | 14 ++++----
 .../global_objects/string/replace/index.html       | 34 +++++++++---------
 .../global_objects/string/search/index.html        | 18 +++++-----
 .../global_objects/string/slice/index.html         | 20 +++++------
 .../global_objects/string/small/index.html         | 16 ++++-----
 .../global_objects/string/split/index.html         | 26 +++++++-------
 .../global_objects/string/startswith/index.html    | 18 +++++-----
 .../global_objects/string/strike/index.html        | 16 ++++-----
 .../reference/global_objects/string/sub/index.html | 16 ++++-----
 .../global_objects/string/substr/index.html        | 18 +++++-----
 .../global_objects/string/substring/index.html     | 22 ++++++------
 .../reference/global_objects/string/sup/index.html | 16 ++++-----
 .../string/tolocalelowercase/index.html            | 16 ++++-----
 .../string/tolocaleuppercase/index.html            | 16 ++++-----
 .../global_objects/string/tolowercase/index.html   | 16 ++++-----
 .../global_objects/string/tosource/index.html      | 12 +++----
 .../global_objects/string/tostring/index.html      | 16 ++++-----
 .../global_objects/string/touppercase/index.html   | 16 ++++-----
 .../global_objects/string/trim/index.html          | 18 +++++-----
 .../global_objects/string/trimend/index.html       | 16 ++++-----
 .../global_objects/string/trimstart/index.html     | 16 ++++-----
 .../global_objects/string/valueof/index.html       | 16 ++++-----
 .../reference/global_objects/symbol/index.html     | 20 +++++------
 .../global_objects/syntaxerror/index.html          | 30 ++++++++--------
 .../reference/global_objects/typedarray/index.html |  4 +--
 .../global_objects/typedarray/join/index.html      |  2 +-
 .../reference/global_objects/typeerror/index.html  | 30 ++++++++--------
 .../reference/global_objects/undefined/index.html  | 20 +++++------
 .../reference/global_objects/unescape/index.html   | 10 +++---
 .../reference/global_objects/uneval/index.html     | 10 +++---
 .../reference/global_objects/urierror/index.html   | 30 ++++++++--------
 .../reference/global_objects/weakmap/index.html    | 10 +++---
 .../global_objects/weakset/add/index.html          | 14 ++++----
 .../global_objects/weakset/delete/index.html       | 14 ++++----
 .../global_objects/weakset/has/index.html          | 16 ++++-----
 .../reference/global_objects/weakset/index.html    | 22 ++++++------
 .../global_objects/webassembly/compile/index.html  |  2 +-
 .../webassembly/compilestreaming/index.html        |  2 +-
 .../global_objects/webassembly/index.html          |  2 +-
 .../global_objects/webassembly/table/index.html    |  2 +-
 files/ru/web/javascript/reference/index.html       | 10 +++---
 .../reference/lexical_grammar/index.html           |  6 ++--
 .../reference/operators/delete/index.html          | 14 ++++----
 .../reference/operators/function/index.html        | 14 ++++----
 .../web/javascript/reference/operators/index.html  | 32 ++++++++---------
 .../operators/operator_precedence/index.html       |  4 +--
 .../javascript/reference/operators/this/index.html |  2 +-
 .../javascript/reference/operators/void/index.html |  2 +-
 .../reference/operators/yield/index.html           | 10 +++---
 .../reference/statements/const/index.html          |  4 +--
 .../reference/statements/continue/index.html       | 10 +++---
 .../reference/statements/for...of/index.html       |  2 +-
 .../javascript/reference/statements/for/index.html | 12 +++----
 .../reference/statements/function_star_/index.html |  6 ++--
 .../web/javascript/reference/statements/index.html | 16 ++++-----
 .../reference/statements/switch/index.html         | 14 ++++----
 .../reference/statements/throw/index.html          | 14 ++++----
 .../reference/template_literals/index.html         |  4 +--
 343 files changed, 2935 insertions(+), 2935 deletions(-)

(limited to 'files/ru/web/javascript')

diff --git a/files/ru/web/javascript/guide/control_flow_and_error_handling/index.html b/files/ru/web/javascript/guide/control_flow_and_error_handling/index.html
index b2b7191228..005a702243 100644
--- a/files/ru/web/javascript/guide/control_flow_and_error_handling/index.html
+++ b/files/ru/web/javascript/guide/control_flow_and_error_handling/index.html
@@ -229,7 +229,7 @@ catch (e) {
 
 </pre>
 
-<h4 id="The_catch_Block" name="The_catch_Block">Блок <code>catch</code></h4>
+<h4 id="The_catch_Block">Блок <code>catch</code></h4>
 
 <p>Используйте блок <code>catch</code>, чтобы обработать исключения, сгенерированные в блоке <code>try</code>.</p>
 
@@ -304,7 +304,7 @@ catch (e) {
 // В результате отображается сообщение </span><span class="comment token" style="color: #708090;">caught inner "bogus"
 // и возвращается значение `false`</span></code></pre>
 
-<h4 id="Nesting_try...catch_Statements" name="Nesting_try...catch_Statements">Вложенные инструкции <code>try...catch</code></h4>
+<h4 id="Nesting_try...catch_Statements">Вложенные инструкции <code>try...catch</code></h4>
 
 <p>Вы можете вкладывать инструкции <code>try...catch</code> друг в друга. Если внутренняя инструкция <code>try...catch</code> не имеет блока <code>catch</code>, то она должна иметь блок finally, кроме того исключение будет перехвачено во внешнем блоке <code>catch</code>. Для получения большей информации ознакомьтесь с вложенными <a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch#Nested_try-blocks">try-блоками</a>.</p>
 
diff --git a/files/ru/web/javascript/guide/expressions_and_operators/index.html b/files/ru/web/javascript/guide/expressions_and_operators/index.html
index cef61fdc23..72a273b6b7 100644
--- a/files/ru/web/javascript/guide/expressions_and_operators/index.html
+++ b/files/ru/web/javascript/guide/expressions_and_operators/index.html
@@ -327,7 +327,7 @@ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */
  </tbody>
 </table>
 
-<h4 id="Bitwise_Logical_Operators" name="Bitwise_Logical_Operators">Битовые логические операторы</h4>
+<h4 id="Bitwise_Logical_Operators">Битовые логические операторы</h4>
 
 <p>Основной смысл работы битовых логических операторов состоит в следующем:</p>
 
@@ -382,7 +382,7 @@ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */
 
 <p>Обратите внимание, что все 32 бита преобразуются с использованием битового оператора НЕ, и что величины с наиболее значимым (самым левым) битом равным 1 представляют собой отрицательные числа (в представлении дополнения до двух).</p>
 
-<h4 id="Bitwise_Shift_Operators" name="Bitwise_Shift_Operators">Битовые операторы сдвига</h4>
+<h4 id="Bitwise_Shift_Operators">Битовые операторы сдвига</h4>
 
 <p>Битовые операторы сдвига используют два операнда: первый представляет величину, подлежащую сдвигу, а второй операнд указывает число битовых позиций на которое должен быть сдвинут первый операнд. Направление операции сдвига определяется используемым оператором.</p>
 
@@ -482,7 +482,7 @@ var n2 = !false; // !f возвращает true
 var n3 = !"Cat"; // !t возвращает false
 </pre>
 
-<h4 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Сокращённая оценка</h4>
+<h4 id="Short-Circuit_Evaluation">Сокращённая оценка</h4>
 
 <p>Так как логические выражения вычисляются слева направо, они проверяются на возможность выполнения сокращённой оценки с использованием следующих правил:</p>
 
@@ -504,7 +504,7 @@ var n3 = !"Cat"; // !t возвращает false
 <pre class="brush: js">var  mystring = "alpha";  mystring += "bet"; // получается значение "alphabet" и присваивается mystring.
 </pre>
 
-<h3 id="Условный_(тернарный)_оператор" name="Условный_(тернарный)_оператор">Условный (тернарный) оператор</h3>
+<h3 id="Условный_(тернарный)_оператор">Условный (тернарный) оператор</h3>
 
 <p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Conditional_Operator">Условный оператор</a> является единственным оператором JavaScript, который использует три операнда. Оператор принимает одно из двух значений в зависимости от заданного условия. Синтаксис оператора:</p>
 
@@ -522,7 +522,7 @@ var n3 = !"Cat"; // !t возвращает false
 
 <p>Данное выражение присваивает значение "adult" переменной <code>status</code>, если <code>age</code> имеет значение 18 или более. В противном случае переменной <code>status</code> присваивается значение "minor".</p>
 
-<h3 id="Оператор_запятая" name="Оператор_запятая">Оператор запятая</h3>
+<h3 id="Оператор_запятая">Оператор запятая</h3>
 
 <p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Comma_Operator">Оператор запятая</a> (<code>,</code>) просто вычисляет оба операнда и возвращает значение последнего операнда. Данный оператор в основном используется внутри цикла <code>for</code>, что позволяет при каждом прохождении цикла одновременно обновлять значения нескольких переменных.</p>
 
@@ -536,7 +536,7 @@ var n3 = !"Cat"; // !t возвращает false
 
 <p>Унарная операция - операция только с одним операндом.</p>
 
-<h4 id="delete" name="delete"><code>delete</code></h4>
+<h4 id="delete"><code>delete</code></h4>
 
 <p>Оператор <a href="/ru/docs/Web/JavaScript/Reference/Operators/delete">delete</a> выполняет удаление объекта, свойства объекта, или элемента массива с заданным индексом. Синтаксис оператора:</p>
 
@@ -587,7 +587,7 @@ if (3 in trees) {
 }
 </pre>
 
-<h4 id="typeof" name="typeof"><code>Оператор typeof</code></h4>
+<h4 id="typeof"><code>Оператор typeof</code></h4>
 
 <p><a href="/ru/docs/Web/JavaScript/Reference/Operators/typeof">Оператор<code> typeof</code></a> используется одним из следующих способов:</p>
 
@@ -648,7 +648,7 @@ typeof Math;     // возвращает "object"
 typeof Option;   // возвращает "function"
 typeof String;   // возвращает "function"</pre>
 
-<h4 id="void" name="void"><code>Оператор void</code></h4>
+<h4 id="void"><code>Оператор void</code></h4>
 
 <p><a href="/ru/docs/Web/JavaScript/Reference/Operators/void">Оператор<code> </code><code>void</code></a> используется любым из следующих способов:</p>
 
@@ -705,7 +705,7 @@ var mycar = {make: "Honda", model: "Accord", year: 1998};
 "model" in mycar; // возвращает true
 </pre>
 
-<h4 id="instanceof" name="instanceof">Оператор <code>instanceof</code></h4>
+<h4 id="instanceof">Оператор <code>instanceof</code></h4>
 
 <p><a href="/ru/docs/Web/JavaScript/Reference/Operators/instanceof">Оператор <code>instanceof</code> </a>возвращает true, если заданный объект является объектом указанного типа. Его синтаксис:</p>
 
@@ -832,7 +832,7 @@ if (theDay instanceof Date) {
 
 <p>Базовые ключевые слова и основные выражения в JavaScript.</p>
 
-<h4 id="this" name="this">Оператор <code>this</code></h4>
+<h4 id="this">Оператор <code>this</code></h4>
 
 <p>Используйте ключевое слово <code>this</code> для указания на текущий объект. В общем случае <code>this</code> указывает на вызываемый объект, которому принадлежит данный метод. Используйте <code>this</code> следующим образом:</p>
 
@@ -899,7 +899,7 @@ var abc = [ "A", "B", "C" ];
 
 <p>Значениям слева назначаются значения справа.</p>
 
-<h4 id="new" name="new"><code>new</code></h4>
+<h4 id="new"><code>new</code></h4>
 
 <p>Вы можете использовать <a href="/ru/docs/Web/JavaScript/Reference/Operators/new">оператор <code>new</code></a> для создания экземпляра объекта пользовательского типа или одного из встроенных объектов. Используйте оператор <code>new</code> следующим образом:</p>
 
diff --git a/files/ru/web/javascript/guide/functions/index.html b/files/ru/web/javascript/guide/functions/index.html
index 28385a4c3e..5b7881e6bb 100644
--- a/files/ru/web/javascript/guide/functions/index.html
+++ b/files/ru/web/javascript/guide/functions/index.html
@@ -35,7 +35,7 @@ translation_of: Web/JavaScript/Guide/Functions
  <li>сборщик мусора (<code>garbage collector</code>)</li>
 </ul>
 
-<h2 id="Объявление_функций"><a id="definition" name="definition"></a>Объявление функций</h2>
+<h2 id="Объявление_функций"><a id="definition"></a>Объявление функций</h2>
 
 <h3 id="Функции_вида_function_declaration_statement">Функции вида "function declaration statement"</h3>
 
@@ -134,7 +134,7 @@ if (num === 0) {
 
 <p><strong>Метод</strong> — это функция, которая является свойством объекта. Узнать больше про объекты и методы можно по ссылке: <a href="/ru/docs/Web/JavaScript/Guide/Working_with_Objects">Работа с объектами</a>.</p>
 
-<h2 id="Вызовы_функций"><a id="call" name="call"></a>Вызовы функций</h2>
+<h2 id="Вызовы_функций"><a id="call"></a>Вызовы функций</h2>
 
 <p>Объявление функции не выполняет её. Объявление функции просто называет функцию и указывает, что делать при вызове функции.</p>
 
@@ -186,7 +186,7 @@ e = factorial(5); // e gets the value 120
 
 <p>Есть другие способы вызвать функцию. Существуют частые случаи, когда функции необходимо вызывать динамически, или поменять номера аргументов функции, или необходимо вызвать функцию с привязкой к определённому контексту. Оказывается, что функции сами по себе являются объектами, и эти объекты в свою очередь имеют методы (посмотрите объект <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Function" title="The Function constructor creates a new Function object. Calling the constructor directly can create functions dynamically, but suffers from security and similar (but far less significant) performance issues similar to eval. However, unlike eval, the Function constructor allows executing code in the global scope, prompting better programming habits and allowing for more efficient code minification."><code>Function</code></a>). Один из них это метод <code><a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Function/apply" title="The apply() method calls a function with a given this value, and arguments provided as an array (or an array-like object).">apply()</a></code>, использование которого может достигнуть этой цели.</p>
 
-<h2 id="Область_видимости_функций"><a id="definition" name="definition"></a>Область видимости функций</h2>
+<h2 id="Область_видимости_функций"><a id="definition"></a>Область видимости функций</h2>
 
 <p><u><em>(function scope)</em></u></p>
 
@@ -219,7 +219,7 @@ function getScore() {
 getScore(); // вернёт "Chamahk scored 5"
 </pre>
 
-<h2 id="Scope_и_стек_функции"><a id="definition" name="definition"></a>Scope и стек функции</h2>
+<h2 id="Scope_и_стек_функции"><a id="definition"></a>Scope и стек функции</h2>
 
 <p><em><u>(function stack)</u></em></p>
 
@@ -397,7 +397,7 @@ outside()(10); // возвращает 20 вместо 10</pre>
 
 <p>Конфликт имени произошёл в инструкции <code>return x * 2</code> между параметром <code>x</code> функции <code>inside</code> и переменной <code>x</code> функции <code>outside</code>. Scope chain здесь будет таким: {<code>inside</code> ==&gt; <code>outside</code> ==&gt; глобальный объект (<em>global object</em>)}. Следовательно <code>x</code> функции <code>inside</code> имеет больший приоритет по сравнению с <code>outside</code>, и нам вернулось 20 (= 10 * 2), а не 10 (= 5 * 2).</p>
 
-<h2 id="Замыкания"><a id="definition" name="definition"></a>Замыкания</h2>
+<h2 id="Замыкания"><a id="definition"></a>Замыкания</h2>
 
 <p><em><u>(Closures)</u></em></p>
 
@@ -482,7 +482,7 @@ getCode();    // Returns the apiCode
 }
 </pre>
 
-<h2 id="Использование_объекта_arguments"><a id="definition" name="definition"></a>Использование объекта arguments</h2>
+<h2 id="Использование_объекта_arguments"><a id="definition"></a>Использование объекта arguments</h2>
 
 <p>Объект arguments функции является псевдо-массивом. Внутри функции вы можете ссылаться к аргументам следующим образом:</p>
 
@@ -524,7 +524,7 @@ myConcat('. ', 'sage', 'basil', 'oregano', 'pepper', 'parsley');
 
 <p>Рассмотрите объект <code><a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Function" title="The Function constructor creates a new Function object. Calling the constructor directly can create functions dynamically, but suffers from security and similar (but far less significant) performance issues similar to eval. However, unlike eval, the Function constructor allows executing code in the global scope, prompting better programming habits and allowing for more efficient code minification.">Function</a></code> в JavaScript-справочнике для большей информации.</p>
 
-<h2 id="Параметры_функции"><a id="definition" name="definition"></a>Параметры функции</h2>
+<h2 id="Параметры_функции"><a id="definition"></a>Параметры функции</h2>
 
 <p>Начиная с ECMAScript 2015 появились два новых вида параметров: параметры по умолчанию (<em>default parameters</em>) и остаточные параметры (<em>rest parameters</em>).</p>
 
@@ -564,7 +564,7 @@ var arr = multiply(2, 1, 2, 3);
 console.log(arr); // [2, 4, 6]
 </pre>
 
-<h2 id="Стрелочные_функции"><a id="definition" name="definition"></a>Стрелочные функции</h2>
+<h2 id="Стрелочные_функции"><a id="definition"></a>Стрелочные функции</h2>
 
 <p><u><em>(Arrow functions)</em></u></p>
 
diff --git a/files/ru/web/javascript/guide/grammar_and_types/index.html b/files/ru/web/javascript/guide/grammar_and_types/index.html
index c8b06a30ed..c5c33e9d11 100644
--- a/files/ru/web/javascript/guide/grammar_and_types/index.html
+++ b/files/ru/web/javascript/guide/grammar_and_types/index.html
@@ -207,7 +207,7 @@ var baz = function() {
 
 <p>Следовательно, вы можете обращаться к глобальным переменным, объявленным в одном объекте window или frame из другого объекта window или frame, указав имя window или frame. Например, если переменная <code>phoneNumber</code> объявлена в документе, то вы можете сослаться на эту переменную из iframe как <code>parent.phoneNumber</code>.</p>
 
-<h3 id="Константы"><a id="Constants" name="Constants">Константы</a></h3>
+<h3 id="Константы"><a id="Constants">Константы</a></h3>
 
 <p>Вы можете создать именованную константу, доступную только для чтения, используя ключевое слово {{jsxref("Statements/const", "const")}}. Синтаксис идентификатора константы является таким же, как и у идентификатора переменной: он должен начинаться с буквы, нижнего подчёркивания или знака $ и может содержать буквы, цифры или нижнее подчёркивание.</p>
 
diff --git a/files/ru/web/javascript/reference/functions/arrow_functions/index.html b/files/ru/web/javascript/reference/functions/arrow_functions/index.html
index 8cabc98dcb..35acaa7be7 100644
--- a/files/ru/web/javascript/reference/functions/arrow_functions/index.html
+++ b/files/ru/web/javascript/reference/functions/arrow_functions/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Functions/Arrow_functions
 
 <p><strong>Выражения стрелочных функций</strong> имеют более короткий синтаксис по сравнению с <a href="/ru/docs/Web/JavaScript/Reference/Operators/function">функциональными выражениями</a> и лексически привязаны к значению <a href="/ru/docs/Web/JavaScript/Reference/Operators/this">this</a> (но не привязаны к собственному <a href="/ru/docs/Web/JavaScript/Reference/Operators/this">this</a>, <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>, <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/super">super</a>, или <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a>). Выражение стрелочных функций не позволяют задавать имя, поэтому стрелочные функции <a href="/ru/docs/Web/JavaScript/Reference/Global_Objects/Function/name">анонимны</a>, если их ни к чему не присвоить.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <h3 id="Базовый_синтаксис">Базовый синтаксис</h3>
 
diff --git a/files/ru/web/javascript/reference/functions/default_parameters/index.html b/files/ru/web/javascript/reference/functions/default_parameters/index.html
index bff4368a58..4ae72d4289 100644
--- a/files/ru/web/javascript/reference/functions/default_parameters/index.html
+++ b/files/ru/web/javascript/reference/functions/default_parameters/index.html
@@ -14,14 +14,14 @@ translation_of: Web/JavaScript/Reference/Functions/Default_parameters
 
 <p>{{EmbedInteractiveExample("pages/js/functions-default.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">function [<em>name</em>]([<em>param1</em>[ = defaultValue1 ][, ..., <em>paramN</em>[ = defaultValueN ]]]) {
    <em>statements</em>
 }
 </pre>
 
-<h2 id="Example" name="Example">Описание</h2>
+<h2 id="Example">Описание</h2>
 
 <p>В JavaScript параметры функции, которым при её вызове не передаются значения, принимают по умолчанию значение <code>{{jsxref("undefined")}}</code>. Однако в некоторых случаях может быть полезно задать иное значение по умолчанию. Именно для таких случаев предназначены параметры по умолчанию.</p>
 
@@ -210,7 +210,7 @@ f(); // 6</pre>
 
 <p>{{Compat("javascript.functions.default_parameters")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="http://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values" rel="external">Оригинальное предложение на ecmascript.org</a></li>
diff --git a/files/ru/web/javascript/reference/functions/get/index.html b/files/ru/web/javascript/reference/functions/get/index.html
index e229aa3d5b..73be276e9d 100644
--- a/files/ru/web/javascript/reference/functions/get/index.html
+++ b/files/ru/web/javascript/reference/functions/get/index.html
@@ -164,7 +164,7 @@ console.log(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(obj), 'hello')
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.functions.get")}}</p>
 
diff --git a/files/ru/web/javascript/reference/functions/index.html b/files/ru/web/javascript/reference/functions/index.html
index 26a0bdc114..ea543d1603 100644
--- a/files/ru/web/javascript/reference/functions/index.html
+++ b/files/ru/web/javascript/reference/functions/index.html
@@ -8,7 +8,7 @@ translation_of: Web/JavaScript/Reference/Functions
 ---
 <div>{{jsSidebar("Functions")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>В общем случае, функция — это "подпрограмма", которую можно <em>вызывать</em> из внешнего (или внутреннего, в случае рекурсии) по отношению к функции кода. Как и сама программа, функция состоит из последовательности инструкций, называемой <em>телом функции.</em> Значения могут быть <em>переданы</em> в функцию, а функция <em>вернёт</em> значение.</p>
 
@@ -57,11 +57,11 @@ function myFunc(theObject) {
 
 <p><a href="/ru/docs/Web/JavaScript/Reference/Operators/this"><code>Ключевое слово this</code></a> не ссылается на функцию, которая выполняется в данный момент, поэтому вы должны обращаться к объектами Function по имени, даже внутри тела самой функции.</p>
 
-<h2 id="Defining_functions" name="Defining_functions">Определение функций</h2>
+<h2 id="Defining_functions">Определение функций</h2>
 
 <p>Есть несколько способов определить функцию:</p>
 
-<h3 id="The_function_declaration_.28function_statement.29" name="The_function_declaration_.28function_statement.29">Объявление функции (инструкция <code>function</code>)</h3>
+<h3 id="The_function_declaration_.28function_statement.29">Объявление функции (инструкция <code>function</code>)</h3>
 
 <p>Специальный синтаксис для объявления функций (более подробно: <a href="/ru/docs/Web/JavaScript/Reference/Statements/function">function statement</a>):</p>
 
@@ -85,7 +85,7 @@ function myFunc(theObject) {
  <dd>Инструкции, из которых состоит тело функции.</dd>
 </dl>
 
-<h3 id="The_function_expression_.28function_operator.29" name="The_function_expression_.28function_operator.29">Функция-выражение (оператор <code>function</code>)</h3>
+<h3 id="The_function_expression_.28function_operator.29">Функция-выражение (оператор <code>function</code>)</h3>
 
 <p>Функция-выражение похожа на определение функции и имеет такой же синтаксис (более подробно: <a href="/ru/docs/Web/JavaScript/Reference/Operators/function">function operator</a>):</p>
 
@@ -128,7 +128,7 @@ param =&gt; expression
  <dd>Если инструкций несколько, их нужно заключить в {}. Для одного выражения фигурных скобок не требуется, а результат этого выражения будет возвращён функцией (то есть<code> функция x =&gt; 3 + 8 вернёт 11).</code><code> </code></dd>
 </dl>
 
-<h3 id="The_Function_constructor" name="The_Function_constructor">Конструктор <code>Function</code></h3>
+<h3 id="The_Function_constructor">Конструктор <code>Function</code></h3>
 
 <div class="note">
 <p><strong>Примечание:</strong> Использовать конструктор Function не рекомендуется, так как он принимает тело функции в виде строки, а это может помешать оптимизациям, которые выполняют движки JavaScript, а также привести к другим проблемам.</p>
@@ -165,7 +165,7 @@ param =&gt; expression
 
 <p>Синтаксис оставшихся параметров позволяет передать бесконечное число аргументов как массив. Подробности можно найти в статье <a href="/ru/docs/Web/JavaScript/Reference/Functions/rest_parameters">Остаточные параметры</a>.</p>
 
-<h2 id="The_arguments_object" name="The_arguments_object">Объект <code>arguments</code></h2>
+<h2 id="The_arguments_object">Объект <code>arguments</code></h2>
 
 <p>Внутри функции получить доступ к её аргументам можно через объект <a href="/ru/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>.</p>
 
@@ -202,7 +202,7 @@ param =&gt; expression
   bar() {}
 };</pre>
 
-<h2 id="Function_constructor_vs._function_declaration_vs._function_expression" name="Function_constructor_vs._function_declaration_vs._function_expression">Сравнение конструкторов <code>Function</code> с объявлением функций и функциями-выражениями</h2>
+<h2 id="Function_constructor_vs._function_declaration_vs._function_expression">Сравнение конструкторов <code>Function</code> с объявлением функций и функциями-выражениями</h2>
 
 <p>Посмотрите на следующие примеры:</p>
 
@@ -332,7 +332,7 @@ function a() {
 }
 </pre>
 
-<h2 id="Conditionally_defining_a_function" name="Conditionally_defining_a_function">Определение функции в зависимости от условия</h2>
+<h2 id="Conditionally_defining_a_function">Определение функции в зависимости от условия</h2>
 
 <p>Функции могут быть определены в зависимости от условий с помощью инструкции <code>function (разрешённое расширение стандарта</code> <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMA-262 Edition 3</a>) или конструктора <code>Function</code>. Обратите внимание, что подобные инструкции <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=609832">запрещены в ES5 strict</a>. Кроме того, эта возможность по-разному ведёт себя в разных браузерах, поэтому не стоит на неё рассчитывать.</p>
 
@@ -358,9 +358,9 @@ function a() {
 }
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Returning_a_formatted_number" name="Example:_Returning_a_formatted_number">Пример: возврат отформатированного числа</h3>
+<h3 id="Example:_Returning_a_formatted_number">Пример: возврат отформатированного числа</h3>
 
 <p>Эта функция возвращает строку, содержащую число с заданным количеством нулей перед ним:</p>
 
@@ -382,7 +382,7 @@ result = padZeros(42,2); // возвращает "42"
 result = padZeros(5,4);  // возвращает "0005"
 </pre>
 
-<h3 id="Example:_Determining_whether_a_function_exists" name="Example:_Determining_whether_a_function_exists">Пример: существует ли функция</h3>
+<h3 id="Example:_Determining_whether_a_function_exists">Пример: существует ли функция</h3>
 
 <p>Можно определить, существует ли функция с помощью оператора <code>typeof</code>. В следующем примере проверяется, есть ли у объекта <code>window</code> функция <code>noFunc</code>. Если есть, то она вызывается; если нет, выполняется какое-то другое действие.</p>
 
@@ -426,7 +426,7 @@ result = padZeros(5,4);  // возвращает "0005"
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a></li>
diff --git a/files/ru/web/javascript/reference/functions/rest_parameters/index.html b/files/ru/web/javascript/reference/functions/rest_parameters/index.html
index 0132e6b5ed..52864c2d93 100644
--- a/files/ru/web/javascript/reference/functions/rest_parameters/index.html
+++ b/files/ru/web/javascript/reference/functions/rest_parameters/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Functions/rest_parameters
 
 <p>{{EmbedInteractiveExample("pages/js/functions-restparameters.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="brush: js notranslate">function(a, b, ...theArgs) {
   // ...
@@ -86,7 +86,7 @@ f(1)          // NaN (b и c равны undefined)
 f(1, 2, 3)    // 6
 f(1, 2, 3, 4) // 6 (четвёртый параметр не деструктурирован)</code></pre>
 
-<h2 id="Example" name="Example">Примеры</h2>
+<h2 id="Example">Примеры</h2>
 
 <p>В этом примере первый аргумент задан как <code>"a"</code>, второй как <code>"b"</code>, так что эти аргументы используются как обычно. Однако третий аргумент <code>"manyMoreArgs"</code> будет массивом, который содержит 3-й, 4-й, 5-й, 6-й ... n-й аргументы, которые передаст пользователь.</p>
 
@@ -197,7 +197,7 @@ console.log(sortArguments(5, 3, 7, 1)); // 1, 3, 5, 7</code></pre>
 
 <div id="compat-mobile"></div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Reference/Functions/arguments" title="arguments">Объект arguments</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/@@iterator/index.html b/files/ru/web/javascript/reference/global_objects/array/@@iterator/index.html
index 2088236a13..a76d242a7c 100644
--- a/files/ru/web/javascript/reference/global_objects/array/@@iterator/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/@@iterator/index.html
@@ -16,17 +16,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Начальное значение свойства <strong><code>@@iterator</code></strong> является тем же самым функциональным объектом, что и начальное значение, возвращаемое методом {{jsxref("Array.prototype.values()", "values()")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>[Symbol.iterator]()</code></pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Iteration_using_for...of_loop" name="Example:_Iteration_using_for...of_loop">Пример: итерация посредством цикла <code>for...of</code></h3>
+<h3 id="Example:_Iteration_using_for...of_loop">Пример: итерация посредством цикла <code>for...of</code></h3>
 
 <pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
 // ваш браузер должен поддерживать цикл for..of
@@ -36,7 +36,7 @@ for (let letter of arr) {
 }
 </pre>
 
-<h3 id="Example:_Alternative_iteration" name="Example:_Alternative_iteration">Пример: альтернативный способ итерации</h3>
+<h3 id="Example:_Alternative_iteration">Пример: альтернативный способ итерации</h3>
 
 <pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
 var eArr = arr[Symbol.iterator]();
@@ -47,7 +47,7 @@ console.log(eArr.next().value); // o
 console.log(eArr.next().value); // p
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -64,11 +64,11 @@ console.log(eArr.next().value); // p
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.keys()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/copywithin/index.html b/files/ru/web/javascript/reference/global_objects/array/copywithin/index.html
index 2360740b31..2b354e44c3 100644
--- a/files/ru/web/javascript/reference/global_objects/array/copywithin/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/copywithin/index.html
@@ -14,15 +14,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>copyWithin()</strong></code> копирует последовательность элементов массива внутри него в позицию, начинающуюся по индексу <code>target</code>. Копия берётся по индексам, задаваемым вторым и третьим аргументами <code>start</code> и <code>end</code>. Аргумент <code>end</code> является необязательным и по умолчанию равен длине массива.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.copyWithin(<var>target</var>, <var>start</var>[, <var>end</var> = this.length])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>target</code></dt>
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
  <dd>Необязательный параметр. Конечный индекс позиции источника, где заканчивать копировать элементы.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Аргументы <code>target</code>, <code>start</code> и <code>end</code> приводятся к {{jsxref("Global_Objects/Number", "Number")}} и обрезаются до целых значений.</p>
 
@@ -41,7 +41,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
 
 <p>Функция <code>copyWithin</code> намеренно является <em>обобщённой</em>, она не требует, чтобы значение <code>this</code> внутри неё было объектом {{jsxref("Global_Objects/Array", "Array")}}, и кроме того, функция <code>copyWithin</code> является <em>изменяющим методом</em>, она изменит объект <code>this</code> и вернёт его, а не просто вернёт копию.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">[1, 2, 3, 4, 5].copyWithin(0, 3);
 // [4, 5, 3, 4, 5]
@@ -66,7 +66,7 @@ i32a.copyWithin(0, 2);
 // Int32Array [4, 2, 3, 4, 5]
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">if (!Array.prototype.copyWithin) {
   Array.prototype.copyWithin = function(target, start/*, end*/) {
@@ -133,7 +133,7 @@ i32a.copyWithin(0, 2);
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -155,11 +155,11 @@ i32a.copyWithin(0, 2);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/Array", "Array")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/entries/index.html b/files/ru/web/javascript/reference/global_objects/array/entries/index.html
index c6b2fdc455..d43a7d7449 100644
--- a/files/ru/web/javascript/reference/global_objects/array/entries/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/entries/index.html
@@ -14,15 +14,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>entries()</strong></code> возвращает новый объект итератора массива <code><strong>Array Iterator</strong></code>, содержащий пары ключ / значение для каждого индекса в массиве.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.entries()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <pre class="brush: js">var arr = ['a', 'b', 'c'];
 var eArr = arr.entries();
@@ -32,7 +32,7 @@ console.log(eArr.next().value); // [1, 'b']
 console.log(eArr.next().value); // [2, 'c']
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -54,11 +54,11 @@ console.log(eArr.next().value); // [2, 'c']
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.keys()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/every/index.html b/files/ru/web/javascript/reference/global_objects/array/every/index.html
index dc64e46dc1..12ac8b49dc 100644
--- a/files/ru/web/javascript/reference/global_objects/array/every/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/every/index.html
@@ -14,7 +14,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>every()</strong></code> проверяет, удовлетворяют ли все элементы массива условию, заданному в передаваемой функции.</p>
 
@@ -22,11 +22,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 <p><strong>Обратите внимание</strong>: метод возвращает <code>true</code> при любом условии для пустого массива.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">arr.every(callback(currentValue[, index[, array]])[, thisArg])</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>callback</code></dt>
@@ -48,7 +48,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 
 <p><code><strong>true</strong></code> если функция проверки возвращает {{Glossary("truthy")}} значение для каждого элемента массива. Иначе, <code><strong>false</strong></code>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>every()</code> вызывает переданную функцию <code>callback</code> один раз для каждого элемента, присутствующего в массиве до тех пор, пока не найдёт такой, для которого <code>callback</code> вернёт <em>ложное</em> значение (значение, становящееся равным <code>false</code> при приведении его к типу {{jsxref("Boolean")}}). Если такой элемент найден, метод <code>every()</code> немедленно вернёт <code>false</code>. В противном случае, если <code>callback</code> вернёт <code>true</code> для всех элементов массива, метод <code>every()</code> вернёт <code>true</code>. Функция <code>callback</code> вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались.</p>
 
@@ -62,9 +62,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 
 <p>Метод <code>every()</code> действует подобно квантору всеобщности в математике. В частности, он вернёт <code>true</code> для пустого массива. Это так называемая <a href="http://en.wikipedia.org/wiki/Vacuous_truth#Vacuous_truths_in_mathematics">бессодержательная истина (vacuously true)</a> — все элементы <a href="http://ru.wikipedia.org/wiki/Пустое_множество">пустого множества</a> (<a href="http://en.wikipedia.org/wiki/Empty_set#Common_problems">англ.</a>) удовлетворяют любому заданному условию.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Testing_size_of_all_array_elements" name="Example:_Testing_size_of_all_array_elements">Пример: проверка размера всех элементов массива</h3>
+<h3 id="Example:_Testing_size_of_all_array_elements">Пример: проверка размера всех элементов массива</h3>
 
 <p>Следующий пример проверяет, являются ли все элементы массива числами, большими 10.</p>
 
@@ -75,7 +75,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 [12, 54, 18, 130, 44].every(isBigEnough); // true
 </pre>
 
-<h3 id="Example:_Using_arrow_functions" name="Example:_Using_arrow_functions">Пример: использование стрелочных функций</h3>
+<h3 id="Example:_Using_arrow_functions">Пример: использование стрелочных функций</h3>
 
 <p><a href="/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Стрелочные функции</a> предоставляют более краткий синтаксис для подобных проверок.</p>
 
@@ -83,7 +83,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 [12, 54, 18, 130, 44].every(elem =&gt; elem &gt;= 10); // true
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>every()</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может не присутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>every()</code> в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; и предполагает что {{jsxref("Object")}} и {{jsxref("TypeError")}} имеют свои первоначальные значения и что <code>callback.call</code> вычисляется в оригинальное значение {{jsxref("Function.prototype.call()")}}.</p>
 
@@ -152,7 +152,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -179,13 +179,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div></div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Array.every")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.forEach()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/fill/index.html b/files/ru/web/javascript/reference/global_objects/array/fill/index.html
index 028dbd6c94..a070828b33 100644
--- a/files/ru/web/javascript/reference/global_objects/array/fill/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/fill/index.html
@@ -20,11 +20,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill
 
 <p class="hidden">Источник этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, скопируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и отправьте нам запрос на перенос.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.fill(<var>value</var>[, <var>start<var> = 0[, <var>end</var> = this.length]])</var></var></code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value</code></dt>
@@ -40,7 +40,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill
  </dt>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Элементы заполняются в полузакрытом интервале [<code>start</code>, <code>end</code>).</p>
 
@@ -54,7 +54,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill
 
 <p>Если аргумент <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">value</span></font>​​​​​ является объектом, то метод <code><strong>fill</strong></code> заполнит массив ссылками на этот объект.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre><code>[1, 2, 3].fill(4);               // [4, 4, 4]
 [1, 2, 3].fill(4, 1);            // [1, 4, 4]
@@ -71,7 +71,7 @@ Array(3).fill(4);                // [4, 4, 4]
 var arr = Array(3).fill({}) // [{}, {}, {}];
 arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]</code></pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre><code>if (!Array.prototype.fill) {
   Object.defineProperty(Array.prototype, 'fill', {
@@ -120,7 +120,7 @@ arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]</code></pre>
 
 <p>Если вам нужно поддерживать действительно устаревшие движки JavaScript, которые не поддерживают <a href="/ru/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a>, то лучше вообще не использовать полифилы для методов <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">Array.prototype</span></font>, так как вы не можете сделать их не перечисляемыми.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -142,13 +142,13 @@ arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]</code></pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Array.fill")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/filter/index.html b/files/ru/web/javascript/reference/global_objects/array/filter/index.html
index 75995169ef..2ed5099007 100644
--- a/files/ru/web/javascript/reference/global_objects/array/filter/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/filter/index.html
@@ -20,12 +20,12 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter
 
 <p class="hidden">Источник этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, скопируйте https://github.com/mdn/interactive-examples и отправьте нам запрос на перенос.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="brush: js">let <var>newArray</var> = <var>arr</var>.filter(<var>callback</var>(<var>element</var>[, <var>index</var>, [<var>array</var>]])[, <var>thisArg</var>])
 </pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>callback</code></dt>
@@ -49,7 +49,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter
 
 <p>Вернётся новый массив с элементами, которые проходят тест, то есть <code>callback</code> вернёт <code>true</code>. Если ни один элемент не пройдёт тест, то будет возвращён пустой массив.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>filter()</code> вызывает переданную функцию <code>callback</code> один раз для каждого элемента, присутствующего в массиве, и конструирует новый массив со всеми значениями, для которых функция <code>callback</code> вернула <code>true</code> или {{Glossary('Truthy', 'значение, становящееся true при приведении в boolean')}}. Функция <code>callback</code> вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались. Элементы массива, не прошедшие проверку функцией <code>callback</code>, просто пропускаются и не включаются в новый массив.</p>
 
@@ -67,9 +67,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter
 
 <p>Диапазон элементов, обрабатываемых методом <code>filter()</code>, устанавливается до первого вызова функции <code>callback</code>. Элементы, добавленные в массив после начала выполнения метода <code>filter()</code>, не будут посещены функцией <code>callback</code>. Если существующие элементы массива изменятся, значения, переданные в функцию <code>callback</code>, будут значениями на тот момент времени, когда метод <code>filter()</code> посетит их; удалённые элементы посещены не будут.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Filtering_out_all_small_values" name="Filtering_out_all_small_values">Отфильтровывание всех маленьких значений</h3>
+<h3 id="Filtering_out_all_small_values">Отфильтровывание всех маленьких значений</h3>
 
 <p>Следующий пример использует <code>filter()</code> для создания отфильтрованного массива, все элементы которого больше или равны 10, а все меньшие 10 удалены.</p>
 
@@ -81,7 +81,7 @@ let filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
 // массив filtered равен [12, 130, 44]
 </pre>
 
-<h3 id="Find_all_prime_numbers_in_an_array" name="Find_all_prime_numbers_in_an_array">Найти все простые числа в массиве</h3>
+<h3 id="Find_all_prime_numbers_in_an_array">Найти все простые числа в массиве</h3>
 
 <p>Следующий пример возвращает все простые числа в массиве:</p>
 
@@ -102,7 +102,7 @@ function isPrime(num) {
 
 console.log(array.filter(isPrime));   // [53, 2, 5, 7, 31, 97, 17]</code></pre>
 
-<h3 id="Filtering_invalid_entries_from_JSON" name="Filtering_invalid_entries_from_JSON">Фильтрация неверных записей в JSON</h3>
+<h3 id="Filtering_invalid_entries_from_JSON">Фильтрация неверных записей в JSON</h3>
 
 <p>В следующем примере метод <code>filter()</code> используется для создания отфильтрованного объекта JSON, все элементы которого содержат ненулевое числовое поле <code>id</code>.</p>
 
@@ -161,7 +161,7 @@ function filterItems(query) {
 console.log(filterItems('ap')); // ['apple', 'grapes']
 console.log(filterItems('an')); // ['banana', 'mango', 'orange']</pre>
 
-<h3 id="ES2015_implementation" name="ES2015_implementation">ES2015 реализация</h3>
+<h3 id="ES2015_implementation">ES2015 реализация</h3>
 
 <pre class="brush: js">const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
 
@@ -179,7 +179,7 @@ console.log(filterItems('an')); // ['banana', 'mango', 'orange']
 
 </pre>
 
-<h3 id="Affecting_Initial_Array_modifying_appending_and_deleting" name="Affecting_Initial_Array_modifying_appending_and_deleting">Влияние на начальный массив (изменение, добавление и удаление)</h3>
+<h3 id="Affecting_Initial_Array_modifying_appending_and_deleting">Влияние на начальный массив (изменение, добавление и удаление)</h3>
 
 <p>В следующих примерах проверяется поведение метода <code>filter</code> при изменении массива.</p>
 
@@ -217,7 +217,7 @@ console.log(deleteWords)
 // Заметьте, что 'elite' не получено, так как удалено из `words` до того,
 // как filter смог получить его: ['spray', 'limit']</pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>filter()</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>filter()</code> в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что <code>fn.call</code> вычисляется в оригинальное значение {{jsxref("Function.prototype.call()")}} и что {{jsxref("Array.prototype.push()")}} содержит своё оригинальное значение.</p>
 
@@ -257,7 +257,7 @@ console.log(deleteWords)
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -284,13 +284,13 @@ console.log(deleteWords)
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Array.filter")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.forEach()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/find/index.html b/files/ru/web/javascript/reference/global_objects/array/find/index.html
index 46c0b0e693..b8cfb919be 100644
--- a/files/ru/web/javascript/reference/global_objects/array/find/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/find/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/find
 ---
 <p>{{JSRef}}</p>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>find()</strong></code> возвращает <strong>значение</strong> первого найденного в массиве элемента, которое удовлетворяет условию переданному в callback функции.  В противном случае возвращается {{jsxref("Global_Objects/undefined", "undefined")}}.</p>
 
@@ -24,11 +24,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/find
 
 <p>Если вам нужно найти позицию элемента или наличие элемента в массиве, используйте {{jsxref("Array.prototype.indexOf()")}} или {{jsxref("Array.prototype.includes()")}} соответственно.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.find(<var>callback</var>[, <var>thisArg</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>callback</code></dt>
@@ -50,7 +50,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/find
 
 <p>Значение элемента из массива, если элемент прошёл проверку, иначе {{jsxref("undefined")}}.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>find</code> вызывает переданную функцию <code>callback</code> один раз для каждого элемента, присутствующего в массиве, до тех пор, пока она не вернёт <code>true</code>. Если такой элемент найден, метод <code>find</code> немедленно вернёт значение этого элемента. В противном случае, метод <code>find</code> вернёт {{jsxref("Global_Objects/undefined", "undefined")}}. До Firefox 34 функция <code>callback</code> не вызывалась для «дырок» в массивах (<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1058394">bug 1058394</a>).</p>
 
@@ -62,9 +62,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/find
 
 <p>Диапазон элементов, обрабатываемых методом <code>find</code>, устанавливается до первого вызова функции <code>callback</code>. Элементы, добавленные в массив после начала выполнения метода <code>find</code>, не будут посещены функцией <code>callback</code>. Если существующие, непосещение элементы массива изменяются функцией <code>callback</code>, их значения, переданные в функцию, будут значениями на тот момент времени когда метод <code>find</code> посетит их; удалённые элементы все ещё будут посещены. </p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Testing_size_of_all_array_elements" name="Example:_Testing_size_of_all_array_elements">Пример: поиск простого числа в массиве</h3>
+<h3 id="Example:_Testing_size_of_all_array_elements">Пример: поиск простого числа в массиве</h3>
 
 <p>Следующий пример находит в массиве положительных чисел элемент, являющийся простым числом (либо возвращает {{jsxref("Global_Objects/undefined", "undefined")}}, если в массиве нет простых чисел).</p>
 
@@ -82,7 +82,7 @@ console.log([4, 6, 8, 12].find(isPrime)); // undefined, не найдено
 console.log([4, 5, 8, 12].find(isPrime)); // 5
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод был добавлен в спецификации ECMAScript 6 и пока может быть недоступен во всех реализациях JavaScript. Однако, вы можете использовать следующий сниппет в качестве полифила:</p>
 
@@ -133,7 +133,7 @@ if (!Array.prototype.find) {
   });
 }</code></pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -155,11 +155,11 @@ if (!Array.prototype.find) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Array.find")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/findindex/index.html b/files/ru/web/javascript/reference/global_objects/array/findindex/index.html
index dad15bf9d0..6eb021a4ae 100644
--- a/files/ru/web/javascript/reference/global_objects/array/findindex/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/findindex/index.html
@@ -16,17 +16,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>findIndex()</strong></code> возвращает <strong>индекс</strong> в массиве, если элемент удовлетворяет условию проверяющей функции. В противном случае возвращается -1.</p>
 
 <p>Также смотрите метод {{jsxref("Array.find", "find()")}}, который возвращает <strong>значение</strong> найденного в массиве элемента вместо его индекса.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.findIndex(<var>callback</var>[, <var>thisArg</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>callback</code></dt>
@@ -44,7 +44,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex
  <dd>Необязательный параметр. Значение, используемое в качестве <code>this</code> при выполнении функции <code>callback</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>findIndex</code> вызывает переданную функцию <code>callback</code> один раз для каждого элемента, присутствующего в массиве, до тех пор, пока она не вернёт <code>true</code>. Если такой элемент найден, метод <code>findIndex</code> немедленно вернёт индекс этого элемента. В противном случае, метод <code>findIndex</code> вернёт -1. Функция <code>callback</code> вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались.</p>
 
@@ -56,9 +56,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex
 
 <p>Диапазон элементов, обрабатываемых методом <code>findIndex</code>, устанавливается до первого вызова функции <code>callback</code>. Элементы, добавленные в массив после начала выполнения метода <code>findIndex</code>, не будут посещены функцией <code>callback</code>. Если существующие, непосещение элементы массива изменяются функцией <code>callback</code>, их значения, переданные в функцию, будут значениями на тот момент времени, когда метод <code>findIndex</code> посетит их; удалённые элементы посещены не будут.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Find_the_index_of_a_prime_number_in_an_array" name="Example:_Find_the_index_of_a_prime_number_in_an_array">Пример: поиск индекса простого числа в массиве</h3>
+<h3 id="Example:_Find_the_index_of_a_prime_number_in_an_array">Пример: поиск индекса простого числа в массиве</h3>
 
 <p>Следующий пример находит в массиве индекс элемента, являющийся простым числом (либо возвращает -1, если в массиве нет простых чисел).</p>
 
@@ -76,7 +76,7 @@ console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, не найдено
 console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод был добавлен в спецификации ECMAScript 6 и пока может быть недоступен во всех реализациях JavaScript. Однако, вы можете использовать следующий кусочек кода в качестве полифила:</p>
 
@@ -104,7 +104,7 @@ console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -126,11 +126,11 @@ console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Array.findIndex")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.find()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/foreach/index.html b/files/ru/web/javascript/reference/global_objects/array/foreach/index.html
index a507f25387..36913933ce 100644
--- a/files/ru/web/javascript/reference/global_objects/array/foreach/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/foreach/index.html
@@ -20,13 +20,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach
 
 <p class="hidden">Источник этого интерактивного примера хранится в GitHub. Если вы хотите внести вклад в проект интерактивных примеров, пожалуйста, клонируйте <a href="https://github.com/mdn/interactive-examples"> https://github.com/mdn/interactive-examples</a> и отправьте нам pull request.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre><var>arr</var>.forEach(function <var>callback(currentValue, index, array) {
     //your iterator
 }</var>[, <var>thisArg</var>]);</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>callback</code></dt>
@@ -49,7 +49,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach
 
 <p>{{jsxref("undefined")}}.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>forEach()</code> выполняет функцию <code>callback</code> один раз для каждого элемента, находящегося в массиве в порядке возрастания. Она не будет вызвана для удалённых или пропущенных элементов массива. Однако, она будет вызвана для элементов, которые присутствуют в массиве и имеют значение {{jsxref("Global_Objects/undefined", "undefined")}}.</p>
 
@@ -84,9 +84,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach
 <p>Метод <code>forEach()</code> выполняет функцию <code>callback</code> один раз для каждого элемента массива; в отличие от методов {{jsxref("Array.prototype.every()", "every()")}} и {{jsxref("Array.prototype.some()", "some()")}}, он всегда возвращает значение {{jsxref("Global_Objects/undefined", "undefined")}}.</p>
 </div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="sparseArray" name="sparseArray">Нет операции для неинициализированных значений (разреженные массивы)</h3>
+<h3 id="sparseArray">Нет операции для неинициализированных значений (разреженные массивы)</h3>
 
 <pre class="brush: js">const arraySparse = [1,3,,7]
 let numCallbackRuns = 0
@@ -120,7 +120,7 @@ items.forEach(function(item){
 })
 </pre>
 
-<h3 id="Printing_the_contents_of_an_array" name="Printing_the_contents_of_an_array">Печать содержимого массива</h3>
+<h3 id="Printing_the_contents_of_an_array">Печать содержимого массива</h3>
 
 <div class="blockIndicator note">
 <p><strong>Примечание:</strong> Для отображения содержимого массива в консоли вы можете использовать <a href="/ru/docs/Web/API/Console/table" title="Отображает табличные данные в виде таблицы"><code>console.table()</code></a>, который выводит отформатированную версию массива.</p>
@@ -172,7 +172,7 @@ obj.sum
 <p><strong>Примечание:</strong> Если при передаче callback функции используется {{jsxref('Functions/Arrow_functions', 'выражение стрелочной функции')}}, параметр <code><var>thisArg</var></code> может быть опущен, так как все стрелочные функции лексически привязываются к значению{{jsxref("Operators/this", "this")}}.</p>
 </div>
 
-<h3 id="Breaking_a_loop" name="Breaking_a_loop">Прерывание цикла</h3>
+<h3 id="Breaking_a_loop">Прерывание цикла</h3>
 
 <p>Следующий код использует {{jsxref("Array.prototype.every()")}} для логирования содержимого массива и останавливается при превышении значением заданного порогового значения <code>THRESHOLD</code>.</p>
 
@@ -211,7 +211,7 @@ console.log('res:', res);
 // res: true
 </pre>
 
-<h3 id="An_object_copy_function" name="An_object_copy_function">Функция копирования объекта</h3>
+<h3 id="An_object_copy_function">Функция копирования объекта</h3>
 
 <p>Следующий код создаёт копию переданного объекта. Существует несколько способов создания копии объекта, и это один из них. Он позволяет понять, каким образом работает <code>Array.prototype.forEach()</code>, используя функции мета-свойств <code>Object.*</code> из ECMAScript 5.</p>
 
@@ -275,7 +275,7 @@ const nested = [1, 2, 3, [4, 5, [6, 7], 8, 9]]
 flatten(nested) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>forEach()</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>forEach()</code> в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Object")}} и {{jsxref("TypeError")}} имеют свои первоначальные значения и что <code>callback.call</code> вычисляется в оригинальное значение {{jsxref("Function.prototype.call()")}}.</p>
 
@@ -340,7 +340,7 @@ if (!Array.prototype.forEach) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -373,7 +373,7 @@ if (!Array.prototype.forEach) {
 <p>{{Compat("javascript.builtins.Array.forEach")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.find()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/from/index.html b/files/ru/web/javascript/reference/global_objects/array/from/index.html
index 522a05fbe5..0ca523fdc0 100644
--- a/files/ru/web/javascript/reference/global_objects/array/from/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/from/index.html
@@ -16,11 +16,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/from
 
 <p>{{EmbedInteractiveExample("pages/js/array-from.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Array.from(<var>arrayLike</var>[, <var>mapFn</var>[, <var>thisArg</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>arrayLike</code></dt>
@@ -35,7 +35,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/from
 
 <p>Новый экземпляр {{jsxref("Array")}}</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p><code>Array.from()</code> позволяет вам создавать массивы из:</p>
 
@@ -50,7 +50,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/from
 
 <p>В ES2015 классовый синтаксис позволяет создавать подклассы как встроенных классов, так и классов, определённых пользователем; в результате статические методы класса, вроде <code>Array.from</code> «наследуются» подклассами {{jsxref("Global_Objects/Array", "Array")}} и создают новые экземпляры подкласса, а не класса {{jsxref("Global_Objects/Array", "Array")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <h3 id="Массив_из_строки_String">Массив из строки <code>String</code></h3>
 
@@ -94,7 +94,7 @@ Array.from([1, 2, 3], x =&gt; x + x);
 Array.from({ length: 5 }, (v, k) =&gt; k);
 // [0, 1, 2, 3, 4]</pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>Array.from</code> был добавлен к стандарту ECMA-262 в 6-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>Array.from</code> в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 6-го издания; он предполагает, что {{jsxref("Global_Objects/Object", "Object")}} и {{jsxref("Global_Objects/TypeError", "TypeError")}} имеют свои первоначальные значения и что <code>callback.call</code> вычисляется в оригинальное значение {{jsxref("Function.prototype.call")}}. Кроме того, поскольку истинные итерируемые объекты не могут быть заменены полифилом, эта реализация не поддерживает общие итерируемые объекты, как они определены в 6-м издании ECMA-262.</p>
 
@@ -179,7 +179,7 @@ if (!Array.from) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -201,13 +201,13 @@ if (!Array.from) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Array.from")}}</div>
 
 <div id="compat-mobile"></div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/index.html b/files/ru/web/javascript/reference/global_objects/array/index.html
index 0f085cb30c..cd60efc95d 100644
--- a/files/ru/web/javascript/reference/global_objects/array/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/index.html
@@ -103,7 +103,7 @@ console.log(removedItems);
 // ["Клубника", "Манго"]
 </pre>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>]
 new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]])
@@ -116,13 +116,13 @@ new Array(<var>arrayLength</var>)</code></pre>
  <dd>Если конструктору <code>Array</code> передаётся единственный аргумент, являющийся целым числом в диапазоне от 0 до 2<sup>32</sup>-1 (включительно), будет возвращён новый пустой JavaScript-массив, длина которого установится в это число (<strong>примечание</strong>: это означает массив, содержащий <code>arrayLength</code> пустых ячеек, а не ячеек со значениями <code>undefined</code>). Если аргументом будет любое другое число, возникнет исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Массивы являются спископодобными объектами, чьи прототипы содержат методы для операций обхода и изменения массива. Ни размер JavaScript-массива, ни типы его элементов не являются фиксированными. Поскольку размер массива может увеличиваться и уменьшаться в любое время, то нет гарантии, что массив окажется плотным. То есть, при работе с массивом может возникнуть ситуация, что элемент массива, к которому вы обратитесь, будет пустым и вернёт <code>undefined</code>. В целом, это удобная характеристика; но если эта особенность массива не желательна в вашем специфическом случае, вы можете рассмотреть возможность использования типизированных массивов.</p>
 
 <p>Некоторые полагают, что <a class="external" href="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/">вы не должны использовать массив в качестве ассоциативного массива</a>. В любом случае, вместо него вы можете использовать простые {{jsxref("Global_Objects/Object", "объекты")}}, хотя у них есть и свои подводные камни. Смотрите пост <a class="external" href="http://www.less-broken.com/blog/2010/12/lightweight-javascript-dictionaries.html">Легковесные JavaScript-словари с произвольными ключами</a><em>(англ.)</em> в качестве примера.</p>
 
-<h3 id="Accessing_array_elements" name="Accessing_array_elements">Доступ к элементам массива</h3>
+<h3 id="Accessing_array_elements">Доступ к элементам массива</h3>
 
 <p>Массивы в JavaScript индексируются с нуля: первый элемент массива имеет индекс, равный <code>0</code>, а индекс последнего элемента равен значению свойства массива {{jsxref("Array.length", "length")}} минус 1.</p>
 
@@ -163,7 +163,7 @@ renderer['3d'].setTexture(model, 'character.png');  // работает как 
 console.log(promise['array']);
 </pre>
 
-<h3 id="Relationship_between_length_and_numerical_properties" name="Relationship_between_length_and_numerical_properties">Взаимосвязь свойства <code>length</code> с числовыми свойствами</h3>
+<h3 id="Relationship_between_length_and_numerical_properties">Взаимосвязь свойства <code>length</code> с числовыми свойствами</h3>
 
 <p>Свойство массивов {{jsxref("Array.length", "length")}} взаимосвязано с числовыми свойствами. Некоторые встроенные методы массива (например, {{jsxref("Array.join", "join")}}, {{jsxref("Array.slice", "slice")}}, {{jsxref("Array.indexOf", "indexOf")}} и т.д.) учитывают значение свойства <code>length</code> при своём вызове. Другие методы (например, {{jsxref("Array.push", "push")}}, {{jsxref("Array.splice", "splice")}} и т.д.) в результате своей работы также обновляют свойство <code>length</code> массива.</p>
 
@@ -197,7 +197,7 @@ console.log(fruits.length); // 2
 
 <p>Более подробно эта тема освещена на странице, посвящённой свойству {{jsxref("Array.length")}}.</p>
 
-<h3 id="Creating_an_array_using_the_result_of_a_match" name="Creating_an_array_using_the_result_of_a_match">Создание массива с использованием результата сопоставления</h3>
+<h3 id="Creating_an_array_using_the_result_of_a_match">Создание массива с использованием результата сопоставления</h3>
 
 <p>Результатом сопоставления регулярного выражения строке является JavaScript-массив. Этот массив имеет свойства и элементы, предоставляющие информацию о сопоставлении. Подобные массивы возвращаются методами {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}} и {{jsxref("String.replace")}}. Чтобы было проще понять, откуда и какие появились свойства и элементы, посмотрите следующий пример и обратитесь к таблице ниже:</p>
 
@@ -243,7 +243,7 @@ var myArray = myRe.exec('cdbBdbsbz');
  </tbody>
 </table>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("Array.length")}}</dt>
@@ -252,7 +252,7 @@ var myArray = myRe.exec('cdbBdbsbz');
  <dd>Позволяет добавлять свойства ко всем объектам массива.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <dl>
  <dt>{{jsxref("Array.from()")}} {{experimental_inline}}</dt>
@@ -265,29 +265,29 @@ var myArray = myRe.exec('cdbBdbsbz');
  <dd>Создаёт новый экземпляр <code>Array</code> из любого количества аргументов, независимо от их количества или типа.</dd>
 </dl>
 
-<h2 id="Array_instances" name="Array_instances">Экземпляры массива</h2>
+<h2 id="Array_instances">Экземпляры массива</h2>
 
 <p>Все экземпляры массива наследуются от {{jsxref("Array.prototype")}}. Изменения в объекте прототипа конструктора массива затронет все экземпляры <code>Array</code>.</p>
 
-<h3 id="Methods_of_array_instances" name="Methods_of_array_instances">Свойства</h3>
+<h3 id="Methods_of_array_instances">Свойства</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_array_instances" name="Methods_of_array_instances">Методы</h3>
+<h3 id="Methods_of_array_instances">Методы</h3>
 
-<h4 id="Mutator_methods" name="Mutator_methods">Методы изменения</h4>
+<h4 id="Mutator_methods">Методы изменения</h4>
 
 <div>{{page('ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods')}}</div>
 
-<h4 id="Accessor_methods" name="Accessor_methods">Методы доступа</h4>
+<h4 id="Accessor_methods">Методы доступа</h4>
 
 <div>{{page('ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods')}}</div>
 
-<h4 id="Iteration_methods" name="Iteration_methods">Методы обхода</h4>
+<h4 id="Iteration_methods">Методы обхода</h4>
 
 <div>{{page('ru/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods')}}</div>
 
-<h2 id="Array_generic_methods" name="Array_generic_methods">Общие методы массива</h2>
+<h2 id="Array_generic_methods">Общие методы массива</h2>
 
 <p>Иногда хочется применить методы массива к строкам или другим массивоподобным объектам (например, к {{jsxref("Functions_and_function_scope/arguments", "аргументам", "", 1)}} функции). Делая это, вы трактуете строку как массив символов (другими словами, рассматриваете не-массив в качестве массива). Например, в порядке проверки каждого символа в переменной <var>str</var> на то, что он является буквой (латинского алфавита), вы пишете следующий код:</p>
 
@@ -345,9 +345,9 @@ if (Array.prototype.every.call(str, isLetter)) {
 }());
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Creating_an_array" name="Example:_Creating_an_array">Пример: создание массива</h3>
+<h3 id="Example:_Creating_an_array">Пример: создание массива</h3>
 
 <p>Следующий пример создаёт массив <code>msgArray</code> с длиной 0, присваивает значения элементам <code>msgArray[0]</code> и <code>msgArray[99]</code>, что изменяет длину массива на 100.</p>
 
@@ -360,7 +360,7 @@ if (msgArray.length === 100) {
 }
 </pre>
 
-<h3 id="Example.3A_Creating_a_two-dimensional_array" name="Example.3A_Creating_a_two-dimensional_array">Пример: создание двумерного массива</h3>
+<h3 id="Example.3A_Creating_a_two-dimensional_array">Пример: создание двумерного массива</h3>
 
 <p>Следующий код создаёт шахматную доску в виде двумерного массива строк. Затем он перемещает пешку путём копирования символа 'p' в позиции (6,4) на позицию (4,4). Старая позиция (6,4) затирается пустым местом.</p>
 
@@ -403,7 +403,7 @@ p,p,p,p, ,p,p,p
 r,n,b,q,k,b,n,r
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -435,13 +435,13 @@ r,n,b,q,k,b,n,r
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Поддержка браузерами</h2>
+<h2 id="Browser_compatibility">Поддержка браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Array")}}</p>
 
 <div> </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Guide_ru/Working_with_Objects#.D0.98.D0.BD.D0.B4.D0.B5.D0.BA.D1.81.D1.8B_.D1.81.D0.B2.D0.BE.D0.B9.D1.81.D1.82.D0.B2_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.B0">Руководство JavaScript: «Индексирование объекта свойствами»</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/indexof/index.html b/files/ru/web/javascript/reference/global_objects/array/indexof/index.html
index a858f9e164..5ff9020a66 100644
--- a/files/ru/web/javascript/reference/global_objects/array/indexof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/indexof/index.html
@@ -13,15 +13,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>indexOf()</strong></code> возвращает первый индекс, по которому данный элемент может быть найден в массиве или -1, если такого индекса нет.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.indexOf(<var>searchElement</var>[, <var>fromIndex</var> = 0])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>searchElement</code></dt>
@@ -30,13 +30,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf
  <dd>Индекс, с которого начинать поиск. Если индекс больше или равен длине массива, возвращается -1, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу. Если рассчитанный индекс оказывается меньше 0, поиск ведётся по всему массиву. Значение по умолчанию равно 0, что означает, что просматривается весь массив.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>indexOf()</code> сравнивает искомый элемент <code>searchElement</code> с элементами в массиве, используя <a href="/ru/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators">строгое сравнение</a> (тот же метод используется оператором <code>===</code>, тройное равно).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_indexOf" name="Example:_Using_indexOf">Пример: использование <code>indexOf()</code></h3>
+<h3 id="Example:_Using_indexOf">Пример: использование <code>indexOf()</code></h3>
 
 <p>В следующем примере <code>indexOf()</code> используется для поиска значений в массиве.</p>
 
@@ -48,7 +48,7 @@ array.indexOf(2, -1); // -1
 array.indexOf(2, -3); // 0
 </pre>
 
-<h3 id="Example:_Finding_all_the_occurrences_of_an_element" name="Example:_Finding_all_the_occurrences_of_an_element">Пример: нахождение всех вхождений элемента</h3>
+<h3 id="Example:_Finding_all_the_occurrences_of_an_element">Пример: нахождение всех вхождений элемента</h3>
 
 <p>В следующем примере <code>indexOf()</code> используется для поиска всех индексов элемента в указанном массиве, которые с помощью {{jsxref("Array.prototype.push()", "push()")}} добавляются в другой массив.</p>
 
@@ -65,7 +65,7 @@ console.log(indices);
 // [0, 2, 4]
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>indexOf()</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>indexOf()</code> в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Global_Objects/TypeError", "TypeError")}} и {{jsxref("Math.abs()")}} имеют свои первоначальные значения.</p>
 
@@ -136,7 +136,7 @@ if (!Array.prototype.indexOf) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -163,11 +163,11 @@ if (!Array.prototype.indexOf) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Array.indexOf")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/isarray/index.html b/files/ru/web/javascript/reference/global_objects/array/isarray/index.html
index 53a6eaa2c0..9a2332b466 100644
--- a/files/ru/web/javascript/reference/global_objects/array/isarray/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/isarray/index.html
@@ -13,15 +13,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>Array.isArray()</strong></code> возвращает <code>true</code>, если объект является массивом и <code>false</code>, если он массивом не является.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Array.isArray(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
@@ -32,11 +32,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray
 
 <p><code>true</code> если объект является {{jsxref("Array")}}; иначе, <code>false</code>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>За подробностям обращайтесь к статье <a href="http://web.mit.edu/jwalden/www/isArray.html">«Абсолютно точное определение того, является ли JavaScript-объект массивом или нет»</a>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">// Все следующие вызовы вернут true
 Array.isArray([]);
@@ -72,7 +72,7 @@ Array.isArray(arr);  // true
 arr instanceof Array; // false
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Выполнение следующего кода перед любым другим кодом создаст метод <code>Array.isArray()</code>, если он ещё не реализован в браузере.</p>
 
@@ -83,7 +83,7 @@ arr instanceof Array; // false
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -105,7 +105,7 @@ arr instanceof Array; // false
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 
@@ -113,7 +113,7 @@ arr instanceof Array; // false
 <p>{{Compat("javascript.builtins.Array.isArray")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/Array", "Array")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/join/index.html b/files/ru/web/javascript/reference/global_objects/array/join/index.html
index 28ae457276..b6b41238ec 100644
--- a/files/ru/web/javascript/reference/global_objects/array/join/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/join/index.html
@@ -13,17 +13,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/join
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>join()</strong></code> объединяет все элементы массива (или <a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">массивоподобного объекта</a>) в строку.</p>
 
 <p>{{EmbedInteractiveExample("pages/js/array-join.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.join(<var>[separator]</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>separator </code> <span class="diff_add">{{optional_inline}}</span></dt>
@@ -34,13 +34,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/join
 
 <p>Строка, содержащая все элементы массива. Если <em><code>arr.length</code></em> == <code>0</code>,  то будет возвращена пустая строка.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Преобразует все элементы массива в строки и объединяет их в одну большую строку. Элемент массива с типом <code>undefined</code> или <code>null </code>преобразуется в пустую строку.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Joining_an_array_three_different_ways" name="Example:_Joining_an_array_three_different_ways">Соединение массива четырьмя различными способами</h3>
+<h3 id="Example:_Joining_an_array_three_different_ways">Соединение массива четырьмя различными способами</h3>
 
 <p>В следующем примере создаётся массив <code>a</code> с тремя элементами, затем они четыре раза объединяются в строку: с использованием разделителя по умолчанию, запятой с пробелом, плюса, окружённого пробелами, и пустой строки.</p>
 
@@ -61,7 +61,7 @@ var myVar4 = a.join('');    // присвоит 'ВетерДождьОгонь'
 <span class="punctuation token">}</span>
 <span class="function token">f</span><span class="punctuation token">(</span><span class="number token">1</span><span class="punctuation token">,</span> <span class="string token">'a'</span><span class="punctuation token">,</span> <span class="keyword token">true</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -93,7 +93,7 @@ var myVar4 = a.join('');    // присвоит 'ВетерДождьОгонь'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 
@@ -101,7 +101,7 @@ var myVar4 = a.join('');    // присвоит 'ВетерДождьОгонь'
 <p>{{Compat("javascript.builtins.Array.join")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.split()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/keys/index.html b/files/ru/web/javascript/reference/global_objects/array/keys/index.html
index 157556c295..6d310c5540 100644
--- a/files/ru/web/javascript/reference/global_objects/array/keys/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/keys/index.html
@@ -24,13 +24,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys
 
 <p class="hidden">Источник этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, скопируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и отправьте нам запрос на перенос.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.keys()</code></pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_basic_usages" name="Example:_basic_usages">Пример: базовое использование</h3>
+<h3 id="Example:_basic_usages">Пример: базовое использование</h3>
 
 <pre class="brush: js">var arr = ['a', 'b', 'c'];
 var iterator = arr.keys();
@@ -41,7 +41,7 @@ console.log(iterator.next()); // { value: 2, done: false }
 console.log(iterator.next()); // { value: undefined, done: true }
 </pre>
 
-<h3 id="Example:_keys_iterator_doesnt_ignore_holes" name="Example:_keys_iterator_doesnt_ignore_holes">Пример: итератор, возвращаемый методом <code>keys()</code>, не пропускает дырки в массиве</h3>
+<h3 id="Example:_keys_iterator_doesnt_ignore_holes">Пример: итератор, возвращаемый методом <code>keys()</code>, не пропускает дырки в массиве</h3>
 
 <pre class="brush: js">var arr = ['a', , 'c'];
 var sparseKeys = Object.keys(arr);
@@ -50,7 +50,7 @@ console.log(sparseKeys); // [0, 2]
 console.log(denseKeys);  // [0, 1, 2]
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -73,13 +73,13 @@ console.log(denseKeys);  // [0, 1, 2]
 </table>
 
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Array.keys")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.values()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/ru/web/javascript/reference/global_objects/array/lastindexof/index.html
index 55320086fc..bb3f488150 100644
--- a/files/ru/web/javascript/reference/global_objects/array/lastindexof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/lastindexof/index.html
@@ -19,11 +19,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
 <div>{{EmbedInteractiveExample("pages/js/array-lastindexof.html")}}</div>
 <p class="hidden">Источник этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, скопируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и отправьте нам запрос на перенос.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.lastIndexOf(<var>searchElement</var>[, <var>fromIndex</var> = arr.length])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>searchElement</code></dt>
@@ -32,13 +32,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
  <dd>Необязательный параметр. Индекс, с которого начинать поиск в обратном направлении. Если индекс больше или равен длине массива, просматривается весь массив. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от конца к началу. Если рассчитанный индекс оказывается меньше 0, массив даже не просматривается. Значение по умолчанию равно длине массива, что означает, что просматривается весь массив.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>lastIndexOf()</code> сравнивает искомый элемент <code>searchElement</code> с элементами в массиве, используя <a href="/ru/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators">строгое сравнение</a> (тот же метод используется оператором <code>===</code>, тройное равно).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_lastIndexOf" name="Example:_Using_lastIndexOf">Пример: использование <code>lastIndexOf()</code></h3>
+<h3 id="Example:_Using_lastIndexOf">Пример: использование <code>lastIndexOf()</code></h3>
 
 <p>В следующем примере метод <code>lastIndexOf()</code> используется для поиска значений в массиве.</p>
 
@@ -51,7 +51,7 @@ array.lastIndexOf(2, -2); // 0
 array.lastIndexOf(2, -1); // 3
 </pre>
 
-<h3 id="Example:_Finding_all_the_occurrences_of_an_element" name="Example:_Finding_all_the_occurrences_of_an_element">Пример: нахождение всех вхождений элемента</h3>
+<h3 id="Example:_Finding_all_the_occurrences_of_an_element">Пример: нахождение всех вхождений элемента</h3>
 
 <p>В следующем примере метод <code>lastIndexOf()</code> используется для поиска всех индексов элемента в указанном массиве, которые с помощью метода {{jsxref("Array.prototype.push()", "push()")}} добавляются в другой массив.</p>
 
@@ -70,7 +70,7 @@ console.log(indices);
 
 <p>Обратите внимание, что мы обрабатываем случай <code>idx == 0</code> отдельно, поскольку элемент всегда будет найден, независимо от параметра <code>fromIndex</code>, если он является первым элементом в массиве. Этим он отличается от метода {{jsxref("Array.prototype.indexOf()", "indexOf()")}}.</p>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>lastIndexOf()</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>lastIndexOf()</code> в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, {{jsxref("Global_Objects/Number", "Number")}}, {{jsxref("Math.floor()")}}, {{jsxref("Math.abs()")}} и {{jsxref("Math.min()")}} имеют свои первоначальные значения.</p>
 
@@ -115,7 +115,7 @@ if (!Array.prototype.lastIndexOf) {
 
 <p>И снова обратите внимание, что данная реализация нацелена на абсолютную совместимость с методом <code>lastIndexOf()</code>, реализованным в Firefox и движке JavaScript SpiderMonkey, включая несколько случаев, которые являются спорными крайними случаями. Если вы используете этот код в реальных приложениях, вы можете вычислять параметр <code>from</code> менее сложным образом, игнорируя эти случаи.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -142,7 +142,7 @@ if (!Array.prototype.lastIndexOf) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Array.lastIndexOf")}}</p>
@@ -154,7 +154,7 @@ if (!Array.prototype.lastIndexOf) {
  <li>Начиная с Firefox 47 {{geckoRelease (47)}}, метод больше не будет возвращать <code>-0</code>. Например, <code>[0].lastIndexOf(0, -0)</code> теперь всегда будет возвращать <code>+0</code> ({{bug (1242043)}}).</li>
 </ul>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.charAt()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/length/index.html b/files/ru/web/javascript/reference/global_objects/array/length/index.html
index bdfee4574e..7867502397 100644
--- a/files/ru/web/javascript/reference/global_objects/array/length/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/length/index.html
@@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/length
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Свойство <strong><code>length</code></strong> объекта, который является экземпляром типа <code>Array</code> , устанавливает или возвращает число элементов этого массива. Значение данного свойства 32-битное безнаковое целое число, которое всегда численно больше чем самый наибольший индекс в массиве.</p>
 
@@ -18,11 +18,11 @@ items.length;
 
 // возвращает 4</pre>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.length</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Свойство <code>length</code> является целым числом с положительным знаком и значением, меньшим чем 2 в степени 32 (2<sup>32</sup>).</p>
 
@@ -78,9 +78,9 @@ function printEntries(arr) {
 
 <p>{{js_property_attributes(1, 0, 0)}}</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Iterating_over_an_array" name="Example:_Iterating_over_an_array">Пример: итерирование по массиву</h3>
+<h3 id="Example:_Iterating_over_an_array">Пример: итерирование по массиву</h3>
 
 <p>В следующем примере массив <code>numbers</code> итерируется до значения свойства <code>length</code>, показывающего, сколько элементов содержит массив. Значение каждого элемента удваивается.</p>
 
@@ -92,7 +92,7 @@ for (var i = 0; i &lt; numbers.length; i++) {
 // Массив numbers теперь равен [2, 4, 6, 8, 10];
 </pre>
 
-<h3 id="Example:_Shortening_an_array" name="Example:_Shortening_an_array">Пример: сокращение массива</h3>
+<h3 id="Example:_Shortening_an_array">Пример: сокращение массива</h3>
 
 <p>Следующий пример сокращает массив <code>statesUS</code> до длины в 50 элементов, если текущая длина массива больше 50.</p>
 
@@ -101,7 +101,7 @@ for (var i = 0; i &lt; numbers.length; i++) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -133,13 +133,13 @@ for (var i = 0; i &lt; numbers.length; i++) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Array.length")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/Array", "Array")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/map/index.html b/files/ru/web/javascript/reference/global_objects/array/map/index.html
index cbcaa661b8..a5ac485843 100644
--- a/files/ru/web/javascript/reference/global_objects/array/map/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/map/index.html
@@ -15,17 +15,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>map()</strong></code> создаёт новый массив с результатом вызова указанной функции для каждого элемента массива.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate">let <var>new_array</var> = <var>arr</var>.map(function <var>callback</var>( <var>currentValue</var>[, <var>index</var>[, <var>array</var>]]) {
     // Возвращает элемент для new_array
 }[, <var>thisArg</var>])</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code><var>callback</var></code></dt>
@@ -51,7 +51,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
 
 <p>Новый массив, где каждый элемент является результатом <code>callback</code> функции.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>map</code> вызывает переданную функцию <code>callback</code> один раз для каждого элемента, в порядке их появления и конструирует новый массив из результатов её вызова. Функция <code>callback</code> вызывается только для индексов массива, имеющих присвоенные значения, включая {{jsxref("Global_Objects/undefined", "undefined")}}. Она не вызывается для пропущенных элементов массива (то есть для индексов, которые никогда не были заданы, которые были удалены или которым никогда не было присвоено значение.</p>
 
@@ -63,9 +63,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
 
 <p>Диапазон элементов, обрабатываемых методом <code>map</code>, устанавливается до первого вызова функции <code>callback</code>. Элементы, добавленные в массив после начала выполнения метода <code>map</code>, не будут посещены функцией <code>callback</code>. Если существующие элементы массива изменяются функцией <code>callback</code>, их значения, переданные в функцию, будут значениями на тот момент времени, когда метод <code>map</code> посетит их; удалённые элементы посещены не будут.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Mapping_an_array_of_numbers_to_an_array_of_square_roots" name="Example:_Mapping_an_array_of_numbers_to_an_array_of_square_roots">Пример: отображение массива чисел на массив квадратных корней</h3>
+<h3 id="Example_Mapping_an_array_of_numbers_to_an_array_of_square_roots">Пример: отображение массива чисел на массив квадратных корней</h3>
 
 <p>Следующий код берёт массив чисел и создаёт новый массив, содержащий квадратные корни чисел из первого массива.</p>
 
@@ -74,7 +74,7 @@ var roots = numbers.map(Math.sqrt);
 // теперь roots равен [1, 2, 3], а numbers всё ещё равен [1, 4, 9]
 </pre>
 
-<h3 id="Example_Mapping_an_array_of_numbers_using_a_function_containing_an_argument" name="Example:_Mapping_an_array_of_numbers_using_a_function_containing_an_argument">Пример: отображение массива чисел с использованием функции, содержащей аргумент</h3>
+<h3 id="Example_Mapping_an_array_of_numbers_using_a_function_containing_an_argument">Пример: отображение массива чисел с использованием функции, содержащей аргумент</h3>
 
 <p>Следующий код показывает, как работает отображение, когда функция требует один аргумент. Аргумент будет автоматически присваиваться каждому элементу массива, когда <code>map</code> проходит по оригинальному массиву.</p>
 
@@ -85,7 +85,7 @@ var doubles = numbers.map(function(num) {
 // теперь doubles равен [2, 8, 18], а numbers всё ещё равен [1, 4, 9]
 </pre>
 
-<h3 id="Example_using_map_generically" name="Example:_using_map_generically">Пример: обобщённое использование <code>map</code></h3>
+<h3 id="Example_using_map_generically">Пример: обобщённое использование <code>map</code></h3>
 
 <p>Этот пример показывает, как использовать <code>map</code> на объекте строки {{jsxref("Global_Objects/String", "String")}} для получения массива байт в кодировке ASCII, представляющего значения символов:</p>
 
@@ -94,7 +94,7 @@ var a = map.call('Hello World', function(x) { return x.charCodeAt(0); });
 // теперь a равен [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
 </pre>
 
-<h3 id="Example_using_map_generically_querySelectorAll" name="Example:_using_map_generically_querySelectorAll">Пример: обобщённое использование <code>map</code> вместе с <code>querySelectorAll</code></h3>
+<h3 id="Example_using_map_generically_querySelectorAll">Пример: обобщённое использование <code>map</code> вместе с <code>querySelectorAll</code></h3>
 
 <p>Этот пример показывает, как пройтись по коллекции объектов, собранных с помощью <code>querySelectorAll</code>. В данном случае мы получаем все выбранные опции на экране и печатаем их в консоль:</p>
 
@@ -106,7 +106,7 @@ var values = [].map.call(elems, function(obj) {
 
 <p>Более простым способом будет использование метода {{jsxref("Array.from()")}}.</p>
 
-<h3 id="Example_Using_map_to_reverse_a_string" name="Example:_Using_map_to_reverse_a_string">Пример: использование <code>map</code> для переворачивания строки</h3>
+<h3 id="Example_Using_map_to_reverse_a_string">Пример: использование <code>map</code> для переворачивания строки</h3>
 
 <pre class="brush: js notranslate">var str = '12345';
 [].map.call(str, function(x) {
@@ -119,7 +119,7 @@ var values = [].map.call(elems, function(obj) {
 
 <p>Более простым способом будет использование метода {{jsxref("String.split()")}} (см. пример <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/String/split#Example:_Reversing_a_String_using_split">обращение строки при помощи метода split()</a>).</p>
 
-<h3 id="Example_Tricky_use_case" name="Example:_Tricky_use_case">Пример: хитрый вариант использования</h3>
+<h3 id="Example_Tricky_use_case">Пример: хитрый вариант использования</h3>
 
 <p><a href="http://www.wirfs-brock.com/allen/posts/166">(навеяно этой записью в блоге)</a></p>
 
@@ -148,7 +148,7 @@ function returnInt(element) {
 ['1', '2', '3'].map(Number); // [1, 2, 3]
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>map</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>map</code> в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; он предполагает, что {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}} и {{jsxref("Global_Objects/Array", "Array")}} имеют свои первоначальные значения и что <code>callback.call</code> вычисляется в оригинальное значение {{jsxref("Function.prototype.call")}}.</p>
 
@@ -245,7 +245,7 @@ if (!Array.prototype.map) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -273,7 +273,7 @@ if (!Array.prototype.map) {
 <p>{{Compat("javascript.builtins.Array.map")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.forEach()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/of/index.html b/files/ru/web/javascript/reference/global_objects/array/of/index.html
index e68f8a42a9..9cbf667f67 100644
--- a/files/ru/web/javascript/reference/global_objects/array/of/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/of/index.html
@@ -23,11 +23,11 @@ Array.of(1, 2, 3); // [1, 2, 3]
 Array(7);          // массив с 7 пустыми слотами
 Array(1, 2, 3);    // [1, 2, 3]</pre>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Array.of(<var>element0</var>[, <var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>element<em>N</em></code></dt>
@@ -38,18 +38,18 @@ Array(1, 2, 3);    // [1, 2, 3]</pre>
 
 <p>Новый массив {{jsxref("Array")}}.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Эта функция является частью стандарта ECMAScript 6. Для дополнительной информации смотрите <a href="https://gist.github.com/rwaldron/1074126">предложение по Array.of и Array.from</a> и <a href="https://gist.github.com/rwaldron/3186576">полифил для Array.of</a>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">Array.of(1);         // [1]
 Array.of(1, 2, 3);   // [1, 2, 3]
 Array.of(undefined); // [undefined]
 </pre>
 
-<h2 id="Compatibility" name="Compatibility">Полифил</h2>
+<h2 id="Compatibility">Полифил</h2>
 
 <p>Выполнение следующего кода перед любым другим кодом создаст метод <code>Array.of()</code>, если он ещё не реализован в браузере.</p>
 
@@ -64,7 +64,7 @@ Array.of(undefined); // [undefined]
     return vals.slice()
 }</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -86,11 +86,11 @@ Array.of(undefined); // [undefined]
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Array.of")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/pop/index.html b/files/ru/web/javascript/reference/global_objects/array/pop/index.html
index 0f6ba275f0..8695bf5ac9 100644
--- a/files/ru/web/javascript/reference/global_objects/array/pop/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/pop/index.html
@@ -10,19 +10,19 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop
 ---
 <div>{{JSRef}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>pop()</strong></code> удаляет <strong>последний</strong> элемент из массива и возвращает его значение.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.pop()</code></pre>
 
-<h3 id="Description" name="Description">Возвращаемое значение</h3>
+<h3 id="Description">Возвращаемое значение</h3>
 
 <p>Последний элемент массива или {{jsxref("undefined")}}, если массив пуст.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>pop</code> удаляет последний элемент из массива и возвращает удалённое значение.</p>
 
@@ -30,9 +30,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop
 
 <p>Если вы вызовете <code>pop()</code> на пустом массиве, он вернёт значение {{jsxref("undefined")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Removing_the_last_element_of_an_array" name="Example:_Removing_the_last_element_of_an_array">Удаление последнего элемента массива</h3>
+<h3 id="Example_Removing_the_last_element_of_an_array">Удаление последнего элемента массива</h3>
 
 <p>Следующий код создаёт массив <code>myFish</code>, содержащий четыре элемента, а затем удаляет последний элемент.</p>
 
@@ -47,7 +47,7 @@ console.log(myFish); // ['ангел', 'клоун', 'мандарин']
 console.log(popped); // 'хирург'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -79,7 +79,7 @@ console.log(popped); // 'хирург'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <div>
@@ -89,7 +89,7 @@ console.log(popped); // 'хирург'
 </div>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.push()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/push/index.html b/files/ru/web/javascript/reference/global_objects/array/push/index.html
index d746b2cd88..19c915fd03 100644
--- a/files/ru/web/javascript/reference/global_objects/array/push/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/push/index.html
@@ -10,26 +10,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/push
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>push()</strong></code> добавляет один или более элементов в конец массива и возвращает новую длину массива.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.push(<var>element1</var>, ..., <var>elementN</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>element<em>N</em></code></dt>
  <dd>Элементы, добавляемые в конец массива.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Новое значение свойства {{jsxref("Array.length", "length")}} объекта, для которого был вызван данный метод.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>push</code> присоединяет значения к массиву.</p>
 
@@ -37,9 +37,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/push
 
 <p>Единственными родными массивоподобными объектами являются {{jsxref("Global_Objects/String", "строки", "", 1)}}, хотя к ним он не может быть применён, поскольку строки являются неизменяемыми.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Adding_elements_to_an_array" name="Example:_Adding_elements_to_an_array">Пример: добавление элементов в массив</h3>
+<h3 id="Example_Adding_elements_to_an_array">Пример: добавление элементов в массив</h3>
 
 <p>Следующий код создаёт массив <code>sports</code>, содержащий два элемента, а затем добавляет к нему ещё два элемента. Переменная <code>total</code> будет содержать новую длину массива.</p>
 
@@ -50,7 +50,7 @@ console.log(sports); // ['футбол', 'бейсбол', 'американск
 console.log(total);  // 4
 </pre>
 
-<h3 id="Example_Merging_two_arrays" name="Example:_Merging_two_arrays">Пример: слияние двух массивов</h3>
+<h3 id="Example_Merging_two_arrays">Пример: слияние двух массивов</h3>
 
 <p>В этом примере используется функция {{jsxref("Function.apply", "apply()")}} для помещения всех элементов из второго массива в первый.</p>
 
@@ -64,7 +64,7 @@ Array.prototype.push.apply(vegetables, moreVegs);
 console.log(vegetables); // ['пастернак', 'картошка', 'сельдерей', 'свёкла']
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -91,7 +91,7 @@ console.log(vegetables); // ['пастернак', 'картошка', 'сель
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <div>
@@ -101,7 +101,7 @@ console.log(vegetables); // ['пастернак', 'картошка', 'сель
 </div>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.pop()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/reduce/index.html b/files/ru/web/javascript/reference/global_objects/array/reduce/index.html
index a17a6090d4..94aeb48e99 100644
--- a/files/ru/web/javascript/reference/global_objects/array/reduce/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/reduce/index.html
@@ -21,11 +21,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce
 
 <p class="hidden">Источник этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, скопируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и отправьте нам запрос на перенос.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>array</var>.reduce(<var>callback</var>[, <var>initialValue</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>callback</code></dt>
@@ -45,7 +45,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce
  <dd>Необязательный параметр. Объект, используемый в качестве первого аргумента при первом вызове функции <code>callback</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>reduce()</code> выполняет функцию <code>callback</code> один раз для каждого элемента, присутствующего в массиве, за исключением пустот, принимая четыре аргумента: начальное значение (или значение от предыдущего вызова <code>callback</code>), значение текущего элемента, текущий индекс и массив, по которому происходит итерация.</p>
 
@@ -175,9 +175,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce
 
 <p>Значение, возвращённое методом <code>reduce()</code> на этот раз, конечно же, будет равным <code>20</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Суммирование всех значений в массиве</h3>
+<h3 id="Example_Sum_up_all_values_within_an_array">Суммирование всех значений в массиве</h3>
 
 <pre class="brush: js">var total = [0, 1, 2, 3].reduce(function(a, b) {
   return a + b;
@@ -206,7 +206,7 @@ var sum = [{x: 1}, {x:2}, {x:3}].reduce(
 // sum == 6
 </pre>
 
-<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Разворачивание массива массивов</h3>
+<h3 id="Example_Flatten_an_array_of_arrays">Разворачивание массива массивов</h3>
 
 <pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
   return a.concat(b);
@@ -214,7 +214,7 @@ var sum = [{x: 1}, {x:2}, {x:3}].reduce(
 // flattened равен [0, 1, 2, 3, 4, 5]
 </pre>
 
-<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Пример: склеивание массивов, содержащихся в объектах массива, с использованием оператора расширения и initialValue</h3>
+<h3 id="Example_Flatten_an_array_of_arrays">Пример: склеивание массивов, содержащихся в объектах массива, с использованием оператора расширения и initialValue</h3>
 
 <pre class="brush: js">// friends - список из объектов(друзей)
 // где поле "books" - список любимых книг друга
@@ -234,7 +234,7 @@ var allbooks = friends.reduce(function(prev, curr) {
 // "Romeo and Juliet", "The Lord of the Rings", "The Shining"]
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>Array.prototype.reduce()</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>reduce()</code> в реализациях, которые не поддерживают этот метод.</p>
 
@@ -272,7 +272,7 @@ if (!Array.prototype.reduce) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -305,7 +305,7 @@ if (!Array.prototype.reduce) {
 <p>{{Compat("javascript.builtins.Array.reduce")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.reduceRight()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/reduceright/index.html b/files/ru/web/javascript/reference/global_objects/array/reduceright/index.html
index 55102a33a1..e2dcc319ed 100644
--- a/files/ru/web/javascript/reference/global_objects/array/reduceright/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/reduceright/index.html
@@ -14,13 +14,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>reduceRight()</strong></code> применяет функцию к аккумулятору и каждому значению массива (справа-налево), сводя его к одному значению.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>arr</var>.reduceRight(<var>callback</var>[, <var>initialValue</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>callback</code></dt>
  <dd>Функция, выполняющаяся для каждого элемента массива, принимает четыре аргумента:
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
  <dd>Необязательный параметр. Объект, используемый в качестве первого аргумента при первом вызове функции <code>callback</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>reduceRight()</code> выполняет функцию <code>callback</code> один раз для каждого элемента, присутствующего в массиве, за исключением пустот, принимая четыре аргумента: начальное значение (или значение от предыдущего вызова <code>callback</code>), значение текущего элемента, текущий индекс и массив, по которому происходит итерация.</p>
 <p>Вызов колбэк-функции <code>callback</code> будет выглядеть так:</p>
 <pre class="brush: js">array.reduceRight(function(previousValue, currentValue, index, array) {
@@ -162,23 +162,23 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 </table>
 <p>Значение, возвращённое методом <code>reduceRight()</code> на этот раз, конечно же, будет равным <code>20</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Пример: суммирование всех значений в массиве</h3>
+<h3 id="Example:_Sum_up_all_values_within_an_array">Пример: суммирование всех значений в массиве</h3>
 <pre class="brush: js">var total = [0, 1, 2, 3].reduceRight(function(a, b) {
   return a + b;
 });
 // total == 6
 </pre>
 
-<h3 id="Example:_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Пример: разворачивание массива массивов</h3>
+<h3 id="Example:_Flatten_an_array_of_arrays">Пример: разворачивание массива массивов</h3>
 <pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
   return a.concat(b);
 }, []);
 // flattened равен [4, 5, 2, 3, 0, 1]
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 <p>Метод <code>Array.prototype.reduceRight()</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>reduceRight()</code> в реализациях, которые не поддерживают этот метод.</p>
 <pre class="brush: js">// Шаги алгоритма ECMA-262, 5-е издание, 15.4.4.22
 // Ссылка (en): http://es5.github.io/#x15.4.4.22
@@ -214,7 +214,7 @@ if ('function' !== typeof Array.prototype.reduceRight) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -235,10 +235,10 @@ if ('function' !== typeof Array.prototype.reduceRight) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Array.prototype.reduce()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/array/reverse/index.html b/files/ru/web/javascript/reference/global_objects/array/reverse/index.html
index 76a8bf2421..33ba80778a 100644
--- a/files/ru/web/javascript/reference/global_objects/array/reverse/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/reverse/index.html
@@ -18,11 +18,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse
 
 <p class="hidden">Источник этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, скопируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и отправьте нам запрос на перенос.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>array</var>.reverse()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
@@ -30,13 +30,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse
 
 <p>Перевёрнутый массив</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>reverse()</code> на месте переставляет элементы массива, на котором он был вызван, изменяет массив и возвращает ссылку на него.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Reversing_the_elements_in_an_array" name="Example:_Reversing_the_elements_in_an_array">Пример: обращение порядка элементов в массиве</h3>
+<h3 id="Example:_Reversing_the_elements_in_an_array">Пример: обращение порядка элементов в массиве</h3>
 
 <p>В следующем примере создаётся массив <code>myArray</code>, содержащий три элемента, а затем массив переворачивается.</p>
 
@@ -46,7 +46,7 @@ myArray.reverse();
 console.log(myArray) // ['три', 'два', 'один']
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -79,13 +79,13 @@ console.log(myArray) // ['три', 'два', 'один']
 </table>
 
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Array.reverse")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.join()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/shift/index.html b/files/ru/web/javascript/reference/global_objects/array/shift/index.html
index 47c1a5d4a1..30a36f63fa 100644
--- a/files/ru/web/javascript/reference/global_objects/array/shift/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/shift/index.html
@@ -10,23 +10,23 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>shift()</strong></code> удаляет <strong>первый</strong> элемент из массива и возвращает его значение. Этот метод изменяет длину массива.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.shift()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>shift</code> удаляет элемент по нулевому индексу, сдвигает значения по последовательным индексам вниз, а затем возвращает удалённое значение. Если свойство {{jsxref("Array.length", "length")}} массива равно 0, вернётся значение {{jsxref("Global_Objects/undefined", "undefined")}}.</p>
 
 <p>Метод <code>shift</code> не является привязанным к типу; этот метод может быть {{jsxref("Function.call", "вызван", "", 1)}} или {{jsxref("Function.apply", "применён", "", 1)}} к объектам, напоминающим массив. Объекты, не содержащие свойство <code>length</code>, отражающее последний элемент в серии последовательных числовых, начинающихся с нуля, свойств, могут повести себя неправильным образом.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Removing_an_element_from_an_array" name="Example:_Removing_an_element_from_an_array">Пример: удаление элемента из массива</h3>
+<h3 id="Example:_Removing_an_element_from_an_array">Пример: удаление элемента из массива</h3>
 
 <p>Следующий код показывает массив <code>myFish</code> до и после удаления его первого элемента. Также он показывает удалённый элемент:</p>
 
@@ -51,7 +51,7 @@ myFish после: клоун,мандарин,хирург
 Удалён этот элемент: ангел
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -78,11 +78,11 @@ myFish после: клоун,мандарин,хирург
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.push()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/slice/index.html b/files/ru/web/javascript/reference/global_objects/array/slice/index.html
index e6ffeb0320..d5c9f8b897 100644
--- a/files/ru/web/javascript/reference/global_objects/array/slice/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/slice/index.html
@@ -18,11 +18,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
 
 <p class="hidden">Источник этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, скопируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и отправьте нам запрос на перенос.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>arr</var>.slice([<var>begin</var>[, <var>end</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>begin</code> {{optional_inline}}</dt>
@@ -41,7 +41,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
 
 <p>Новый массив, содержащий извлечённые элементы.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>slice()</code> не изменяет исходный массив, а возвращает новую «одноуровневую» копию, содержащую копии элементов, вырезанных из исходного массива. Элементы исходного массива копируются в новый массив по следующим правилам:</p>
 
@@ -52,9 +52,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
 
 <p>Если к любому массиву будет добавлен новый элемент, это никак не повлияет на другой массив.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Return_a_portion_of_an_existing_array" name="Example:_Return_a_portion_of_an_existing_array">Пример: возврат части существующего массива</h3>
+<h3 id="Example_Return_a_portion_of_an_existing_array">Пример: возврат части существующего массива</h3>
 
 <pre class="brush: js notranslate">// Пример: наши хорошие друзья цитрусовые среди фруктов
 var fruits = ['Банан', 'Апельсин', 'Лимон', 'Яблоко', 'Манго'];
@@ -63,7 +63,7 @@ var citrus = fruits.slice(1, 3);
 // citrus содержит ['Апельсин', 'Лимон']
 </pre>
 
-<h3 id="Example_Using_slice" name="Example:_Using_slice">Пример: использование метода <code>slice()</code></h3>
+<h3 id="Example_Using_slice">Пример: использование метода <code>slice()</code></h3>
 
 <p>В следующем примере метод <code>slice()</code> создаёт новый массив, <code>newCar</code>, из массива <code>myCar</code>. Оба содержат ссылку на объект <code>myHonda</code>. Когда цвет в объекте <code>myHonda</code> изменяется на багровый, оба массива замечают это изменение.</p>
 
@@ -100,7 +100,7 @@ myCar[0].color = багровый
 newCar[0].color = багровый
 </pre>
 
-<h2 id="Array-like" name="Array-like">Массивоподобные объекты</h2>
+<h2 id="Array-like">Массивоподобные объекты</h2>
 
 <p>Метод <code>slice()</code> также может использоваться для преобразования массивоподобных объектов / коллекций в новый массив <code>Array</code>. Вам просто нужно привязать метод к объекту. Псевдомассив {{jsxref("Functions_and_function_scope/arguments", "arguments")}} внутри функции как раз является примером «массивоподобного объекта».</p>
 
@@ -123,7 +123,7 @@ function list() {
 var list1 = list(1, 2, 3); // [1, 2, 3]
 </pre>
 
-<h2 id="Streamlining_cross-browser_behavior" name="Streamlining_cross-browser_behavior">Совершенствование кросс-браузерного поведения</h2>
+<h2 id="Streamlining_cross-browser_behavior">Совершенствование кросс-браузерного поведения</h2>
 
 <p>Хотя спецификация не требует от хост-объектов (например, объектов DOM) следовать поведению Mozilla при преобразовании с помощью <code>Array.prototype.slice()</code> и IE &lt; 9 так не делает, версии IE, начиная с 9-й это умеют. «Прокладывание» позволяет добиться надёжного кросс-браузерного поведения. Пока другие современные браузеры будут поддерживать эту способность, что и делают в настоящее время IE, Mozilla, Chrome, Safari и Opera, разработчики, читая (поддерживающий DOM) код функции <code>slice()</code>, опирающийся на эту прокладку, не будут вводиться в заблуждение его семантикой; они могут смело полагаться на текущую семантику, являющуюся, видимо, <em>де-факто</em> стандартным поведением. (Прокладка также исправляет поведение IE, позволяя работать со вторым аргументом <code>slice()</code>, явно определённым как {{jsxref("Global_Objects/null", "null")}}/{{jsxref("Global_Objects/undefined", "undefined")}}, поскольку более ранние версии IE такое не позволяют, но все современные браузеры, в том числе IE &gt;= 9, поддерживают данное поведение.)</p>
 
@@ -193,7 +193,7 @@ var list1 = list(1, 2, 3); // [1, 2, 3]
 }());
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -225,13 +225,13 @@ var list1 = list(1, 2, 3); // [1, 2, 3]
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Array.slice")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.splice()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/some/index.html b/files/ru/web/javascript/reference/global_objects/array/some/index.html
index f7c7cd08e7..b415e0e522 100644
--- a/files/ru/web/javascript/reference/global_objects/array/some/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/some/index.html
@@ -24,11 +24,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/some
 
 <p>{{EmbedInteractiveExample("pages/js/array-some.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><var>arr</var>.some(<var>callback(element[, index[, array]])</var>[, <var>thisArg</var>])</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>callback</code></dt>
@@ -50,7 +50,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/some
 
 <p><code><strong>true</strong></code>, если функция проверки возвращает {{Glossary("truthy")}} значение хотя бы для одного элемента массива. Иначе, <code><strong>false</strong></code>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>some()</code> вызывает переданную функцию <code>callback</code> один раз для каждого элемента, присутствующего в массиве до тех пор, пока не найдёт такой, для которого <code>callback</code> вернёт <em>истинное</em> значение (значение, становящееся равным <code>true</code> при приведении его к типу {{jsxref("Boolean")}}). Если такой элемент найден, метод <code>some()</code> немедленно вернёт <code>true</code>. В противном случае, если <code>callback</code> вернёт <code>false</code> для всех элементов массива, метод <code>some()</code> вернёт <code>false</code>. Функция <code>callback</code> вызывается только для индексов массива, имеющих присвоенные значения; она не вызывается для индексов, которые были удалены или которым значения никогда не присваивались.</p>
 
@@ -62,9 +62,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/some
 
 <p>Диапазон элементов, обрабатываемых методом <code>some()</code>, устанавливается до первого вызова функции <code>callback</code>. Элементы, добавленные в массив после начала выполнения метода <code>some()</code>, не будут посещены функцией <code>callback</code>. Если существующие элементы массива изменятся, значения, переданные в функцию <code>callback</code>, будут значениями на тот момент времени, когда метод <code>some()</code> посетит их; удалённые элементы посещены не будут.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Проверка_значений_элементов_массива" name="Example:_Testing_size_of_all_array_elements">Проверка значений элементов массива</h3>
+<h3 id="Проверка_значений_элементов_массива">Проверка значений элементов массива</h3>
 
 <p>Следующий пример проверяет наличие в массиве элемента, который больше 10.</p>
 
@@ -77,7 +77,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/some
 
 <p>{{ EmbedLiveSample('Проверка_значений_элементов_массива', '', '', '', 'Web/JavaScript/Reference/Global_Objects/Array/some') }}</p>
 
-<h3 id="Проверка_элементов_массива_с_использованием_стрелочных_функций" name="Example:_Testing_array_elements_using_arrow_functions">Проверка элементов массива с использованием стрелочных функций</h3>
+<h3 id="Проверка_элементов_массива_с_использованием_стрелочных_функций">Проверка элементов массива с использованием стрелочных функций</h3>
 
 <p><a href="/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Стрелочные функции</a> предоставляют более краткий синтаксис для подобных проверок.</p>
 
@@ -140,7 +140,7 @@ getBoolean('true');  // true</code></pre>
 
 <p>{{ EmbedLiveSample('Приведение_значения_к_логическому_типу', '', '', '', 'Web/JavaScript/Reference/Global_Objects/Array/some') }}</p>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>some()</code> был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может не присутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать <code>some()</code> в реализациях, которые не поддерживают этот метод. Этот алгоритм является точно тем, что описан в ECMA-262 5-го издания; и предполагает, что {{jsxref("Global_Objects/Object", "Object")}} и {{jsxref("Global_Objects/TypeError", "TypeError")}} имеют свои первоначальные значения и что <code>callback.call</code> вычисляется в оригинальное значение {{jsxref("Function.prototype.call()")}}.</p>
 
@@ -174,7 +174,7 @@ if (!Array.prototype.some) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -201,11 +201,11 @@ if (!Array.prototype.some) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Array.some")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.forEach()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/sort/index.html b/files/ru/web/javascript/reference/global_objects/array/sort/index.html
index f33119cd53..6408c3d51f 100644
--- a/files/ru/web/javascript/reference/global_objects/array/sort/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/sort/index.html
@@ -10,15 +10,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>sort()</strong></code> <em>на месте</em> сортирует элементы массива и возвращает отсортированный массив. Сортировка не обязательно <a href="https://ru.wikipedia.org/wiki/Устойчивая_сортировка">устойчива</a> (<a href="https://en.wikipedia.org/wiki/Sorting_algorithm#Stability">англ.</a>). Порядок сортировки по умолчанию соответствует порядку кодовых точек Unicode.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>arr</var>.sort([<var>compareFunction</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>compareFunction</code></dt>
@@ -29,7 +29,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort
 
 <p>Отсортированный массив. Важно, что копия массива не создаётся - массив сортируется <em><a href="https://en.wikipedia.org/wiki/In-place_algorithm">на месте</a></em>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если функция сравнения <code>compareFunction</code> не предоставляется, элементы сортируются путём преобразования их в строки и сравнения строк в порядке следования кодовых точек Unicode. Например, слово "Вишня" идёт перед словом "бананы". При числовой сортировке, 9 идёт перед 80, но поскольку числа преобразуются в строки, то "80" идёт перед "9" в соответствии с порядком в Unicode.</p>
 
@@ -106,9 +106,9 @@ items.sort(function (a, b) {
 });
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Creating.2C_displaying.2C_and_sorting_an_array" name="Example:_Creating.2C_displaying.2C_and_sorting_an_array">Пример: создание, отображение и сортировка массива</h3>
+<h3 id="Example_Creating.2C_displaying.2C_and_sorting_an_array">Пример: создание, отображение и сортировка массива</h3>
 
 <p>В следующем примере создаётся четыре массива, сначала отображается первоначальный массив, а затем они сортируются. Числовые массивы сортируются сначала без, а потом с функцией сравнения.</p>
 
@@ -156,7 +156,7 @@ mixedNumericArray: 80,9,700,40,1,5,200
 Сортировка с функцией compareNumbers: 1,5,9,40,80,200,700
 </pre>
 
-<h3 id="Example_Sorting_non-ASCII_characters" name="Example:_Sorting_non-ASCII_characters">Пример: сортировка не-ASCII символов</h3>
+<h3 id="Example_Sorting_non-ASCII_characters">Пример: сортировка не-ASCII символов</h3>
 
 <p>Для сортировки строк с не-ASCII символами, то есть строк с символами акцента (e, é, è, a, ä и т.д.), строк, с языками, отличными от английского: используйте {{jsxref("String.localeCompare")}}. Эта функция может сравнивать эти символы, чтобы они становились в правильном порядке.</p>
 
@@ -168,7 +168,7 @@ items.sort(function (a, b) {
 // items равен ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']
 </pre>
 
-<h3 id="Example_Sorting_maps" name="Example:_Sorting_maps">Пример: сортировка c помощью map</h3>
+<h3 id="Example_Sorting_maps">Пример: сортировка c помощью map</h3>
 
 <p>Функция сравнения <code>(compareFunction)</code> может вызываться несколько раз для каждого элемента в массиве. В зависимости от природы функции сравнения, это может привести к высоким расходам ресурсов. Чем более сложна функция сравнения и чем больше элементов требуется отсортировать, тем разумнее использовать <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a> для сортировки. Идея состоит в том, чтобы обойти массив один раз, чтобы извлечь фактические значения, используемые для сортировки, во временный массив, отсортировать временный массив, а затем обойти временный массив для получения правильного порядка.</p>
 
@@ -195,7 +195,7 @@ var result = mapped.map(function(el) {
 });
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -222,11 +222,11 @@ var result = mapped.map(function(el) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Array.sort")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.reverse()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/splice/index.html b/files/ru/web/javascript/reference/global_objects/array/splice/index.html
index a714590fab..e92751abf6 100644
--- a/files/ru/web/javascript/reference/global_objects/array/splice/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/splice/index.html
@@ -12,16 +12,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>splice()</strong></code> изменяет содержимое массива, удаляя существующие элементы и/или добавляя новые.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>array</var>.splice(<var>start[</var>, <var>deleteCount</var>[, <var>item1</var>[, <var>item2</var>[, ...]]]])
 </code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>start</code></dt>
@@ -32,11 +32,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice
  <dd>Необязательные параметры. Добавляемые к массиву элементы. Если вы не укажете никакого элемента, <code>splice()</code> просто удалит элементы из массива.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Массив, содержащий удалённые элементы. Если будет удалён только один элемент, вернётся массив из одного элемента. Если никакие элементы не будут удалены, вернётся пустой массив.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если количество указанных вставляемых элементов будет отличным от количества удаляемых элементов, массив изменит длину после вызова.</p>
 
@@ -98,7 +98,7 @@ var removed = myFish.splice(2);
 // myFish равен ["angel", "clown"]
 // removed равен ["mandarin", "sturgeon"]</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -125,15 +125,15 @@ var removed = myFish.splice(2);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Array.splice")}}</p>
 
-<h3 id="Backward_compatibility" name="Backward_compatibility">Обратная совместимость</h3>
+<h3 id="Backward_compatibility">Обратная совместимость</h3>
 
 <p>В JavaScript 1.2 метод <code>splice()</code> возвращал удалённый элемент только если был удалён один элемент (параметр <code>deleteCount</code> равен 1); в противном случае метод возвращал массив с удалёнными элементами. Обратите внимание, что последним браузером, использующим JavaScript 1.2, был Netscape Navigator 4, так что вы можете считать, что <code>splice()</code> всегда возвращает массив.</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.push()", "push()")}} / {{jsxref("Array.prototype.pop()", "pop()")}} — добавление / удаление элементов с конца массива</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/ru/web/javascript/reference/global_objects/array/tolocalestring/index.html
index 237465afc0..d780b4ec02 100644
--- a/files/ru/web/javascript/reference/global_objects/array/tolocalestring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/tolocalestring/index.html
@@ -11,19 +11,19 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>toLocaleString()</strong></code> возвращает строковое представление элементов массива. Элементы преобразуются в строки с использованием своих собственных методов <code>toLocaleString</code> и эти строки разделяются локале-зависимой строкой (например, запятой «,»).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.toLocaleString();</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Элементы массива преобразуются в строки с использованием своих собственных методов <code>toLocaleString</code>:</p>
 
@@ -33,9 +33,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString
  <li><code>Date</code>: {{jsxref("Date.prototype.toLocaleString()")}}</li>
 </ul>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toLocaleString" name="Example:_Using_toLocaleString">Пример: использование <code>toLocaleString</code></h3>
+<h3 id="Example:_Using_toLocaleString">Пример: использование <code>toLocaleString</code></h3>
 
 <pre class="brush: js">var number = 1337;
 var date = new Date();
@@ -48,7 +48,7 @@ console.log(str);
 // если работает под германской локалью (de-DE) с временной зоной Европа/Берлин
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -75,11 +75,11 @@ console.log(str);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.toString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/tosource/index.html b/files/ru/web/javascript/reference/global_objects/array/tosource/index.html
index 3bf4cb7d61..6047fd2437 100644
--- a/files/ru/web/javascript/reference/global_objects/array/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/tosource/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource
 ---
 <div>
  {{JSRef("Global_Objects", "Array")}} {{non-standard_header}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>toSource()</strong></code> возвращает строковое представление исходного кода массива.</p>
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>arr</var>.toSource()</code></pre>
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toSource</code> возвращает следующие значения:</p>
 <ul>
  <li>Для встроенного объекта {{jsxref("Global_Objects/Array", "Array")}}, метод <code>toSource</code> возвращает следующую строку, указывающую, что исходный код недоступен:
@@ -29,20 +29,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource
  <li>Для экземпляров класса {{jsxref("Global_Objects/Array", "Array")}}, метод <code>toSource</code> возвращает строковое представление исходного кода.</li>
 </ul>
 <p>Этот метод обычно вызывается внутри движка JavaScript, а не явно в коде. Вы можете вызвать <code>toSource</code> во время отладки для просмотра содержимого массива.</p>
-<h2 id="Examples" name="Examples">Примеры</h2>
-<h3 id="Example:_Examining_the_source_code_of_an_array" name="Example:_Examining_the_source_code_of_an_array">Пример: рассмотрение исходного кода массива</h3>
+<h2 id="Examples">Примеры</h2>
+<h3 id="Example:_Examining_the_source_code_of_an_array">Пример: рассмотрение исходного кода массива</h3>
 <p>Для просмотра исходного кода массива:</p>
 <pre class="brush: js">var alpha = new Array('a', 'b', 'c');
 
 alpha.toSource();   // вернёт ['a', 'b', 'c']
 </pre>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
  <li>{{jsxref("Array.prototype.toString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/tostring/index.html b/files/ru/web/javascript/reference/global_objects/array/tostring/index.html
index 2738693662..21bf0bd6a6 100644
--- a/files/ru/web/javascript/reference/global_objects/array/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/tostring/index.html
@@ -10,19 +10,19 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>toString()</strong></code> возвращает строковое представление указанного массива и его элементов.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.toString()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Объект {{jsxref("Global_Objects/Array", "Array")}} переопределяет метод <code>toString</code> объекта {{jsxref("Global_Objects/Object", "Object")}}. Для объектов класса <code>Array</code>, метод <code>toString</code> соединяет массив и возвращает одну строку, содержащую каждый элемент массива, разделённый запятыми. Например, следующий код создаёт массив и использует метод <code>toString</code> для преобразования массива в строку.</p>
 
@@ -32,11 +32,11 @@ var myVar = monthNames.toString(); // присваивает 'Янв,Фев,Ма
 
 <p>JavaScript вызывает метод <code>toString</code> автоматически, когда массив представляется текстовым значением или когда массив находится в контексте конкатенации строк.</p>
 
-<h3 id="ECMAScript_5_semantics" name="ECMAScript_5_semantics">Семантика ECMAScript 5</h3>
+<h3 id="ECMAScript_5_semantics">Семантика ECMAScript 5</h3>
 
 <p>Начиная с JavaScript 1.8.5 (<span class="st">Firefox 4</span>), и в соответствии с семантикой ECMAScript 5-го издания, метод <code>toString()</code> является обобщённым и может использоваться с любым объектом. В случае с массивами, если он имеет метод <code>join()</code>, он будет вызван и результат его работы будет возвращён. В противном случае будет вызван метод {{jsxref("Object.prototype.toString()")}}, и будет возвращён результат его работы.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -63,11 +63,11 @@ var myVar = monthNames.toString(); // присваивает 'Янв,Фев,Ма
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/unshift/index.html b/files/ru/web/javascript/reference/global_objects/array/unshift/index.html
index 1d3e095ead..97d246ad1d 100644
--- a/files/ru/web/javascript/reference/global_objects/array/unshift/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/unshift/index.html
@@ -10,32 +10,32 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>unshift()</strong></code> добавляет один или более элементов в начало массива и возвращает новую длину массива.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.unshift(<var>element1</var>[, ...[, <var>elementN</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>element1, ..., element<em>N</em></code></dt>
  <dd>Элементы, добавляемые в начало массива.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Новое свойство {{jsxref("Array.length", "length")}} объекта, над которым был вызван метод <code>unshift</code>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>unshift</code> вставляет переданные значения в начало массивоподобного объекта.</p>
 
 <p>Метод <code>unshift</code> не является привязанным к типу; этот метод может быть {{jsxref("Function.call", "вызван", "", 1)}} или {{jsxref("Function.apply", "применён", "", 1)}} к объектам, напоминающим массив. Объекты, не содержащие свойство <code>length</code>, отражающее последний элемент в серии последовательных числовых, начинающихся с нуля, свойств, могут повести себя неправильным образом.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">var arr = [1, 2];
 
@@ -49,7 +49,7 @@ arr.unshift([-3]);
 // arr равен[[-3], -2, -1, 0, 1, 2]
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -76,11 +76,11 @@ arr.unshift([-3]);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Array.unshift")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.push()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/array/values/index.html b/files/ru/web/javascript/reference/global_objects/array/values/index.html
index c2c79e299c..ec82830e39 100644
--- a/files/ru/web/javascript/reference/global_objects/array/values/index.html
+++ b/files/ru/web/javascript/reference/global_objects/array/values/index.html
@@ -13,17 +13,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/values
 ---
 <div>{{JSRef("Global_Objects", "Array")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>values()</code></strong> возвращает новый объект итератора массива <strong><code>Array Iterator</code></strong>, содержащий значения для каждого индекса в массиве.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>arr</var>.values()</code></pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Iteration_using_for...of_loop" name="Example:_Iteration_using_for...of_loop">Пример: итерация через цикл <code>for...of</code></h3>
+<h3 id="Example:_Iteration_using_for...of_loop">Пример: итерация через цикл <code>for...of</code></h3>
 
 <pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
 var eArr = arr.values();
@@ -34,7 +34,7 @@ for (let letter of eArr) {
 }
 </pre>
 
-<h3 id="Example:_Alternative_iteration" name="Example:_Alternative_iteration">Пример: альтернативный способ итерации</h3>
+<h3 id="Example:_Alternative_iteration">Пример: альтернативный способ итерации</h3>
 
 <pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
 var eArr = arr.values();
@@ -45,7 +45,7 @@ console.log(eArr.next().value); // o
 console.log(eArr.next().value); // p
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -67,11 +67,11 @@ console.log(eArr.next().value); // p
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Array.prototype.keys()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/boolean/index.html b/files/ru/web/javascript/reference/global_objects/boolean/index.html
index 3ea986a1f2..23d411c69b 100644
--- a/files/ru/web/javascript/reference/global_objects/boolean/index.html
+++ b/files/ru/web/javascript/reference/global_objects/boolean/index.html
@@ -13,18 +13,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
 
 <p>Объект <strong><code>Boolean</code></strong> является объектом-обёрткой над примитивом логического типа.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>new Boolean([<var>value</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value</code></dt>
  <dd>Необязательный параметр. Начальное значение объекта <code>Boolean</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Значение, переданное первым параметром, при необходимости преобразуется в логическое значение. Если значение опущено или равно <code>0</code>, <code>-0</code>, {{jsxref("Global_Objects/null", "null")}}, <code>false</code>, {{jsxref("Global_Objects/NaN", "NaN")}}, {{jsxref("Global_Objects/undefined", "undefined")}} или пустой строке (<code>""</code>), объект имеет начальное значение, равное <code>false</code>. Все остальные значения, включая любые объекты или строку <code>"false"</code>, создают объект с начальным значением, равным <code>true</code>.</p>
 
@@ -62,7 +62,7 @@ var s = new Boolean(myString);       // начальное значение ра
 
 <p>Не используйте объект <code>Boolean</code> вместо примитива логического типа.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt><code>Boolean.length</code></dt>
@@ -73,27 +73,27 @@ var s = new Boolean(myString);       // начальное значение ра
 
 <p>{{jsOverrides("Function", "Properties", "prototype")}}</p>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <p>Глобальный объект <code>Boolean</code> не содержит собственных методов, однако, он наследует некоторые методы из цепочки прототипов:</p>
 
 <div>{{jsOverrides("Function", "Methods")}}</div>
 
-<h2 id="Boolean_instances" name="Boolean_instances">Экземпляры объекта <code>Boolean</code></h2>
+<h2 id="Boolean_instances">Экземпляры объекта <code>Boolean</code></h2>
 
 <p>Все экземпляры объекта <code>Boolean</code> наследуются от {{jsxref("Boolean.prototype")}}. Как и все конструкторы, объект прототипа предоставляет экземплярам свойства и методы.</p>
 
-<h3 id="Properties_2" name="Properties_2">Свойства</h3>
+<h3 id="Properties_2">Свойства</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_2" name="Methods_2">Методы</h3>
+<h3 id="Methods_2">Методы</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Creating_Boolean_objects_with_an_initial_value_of_false" name="Example:_Creating_Boolean_objects_with_an_initial_value_of_false">Пример: создание объектов <code>Boolean</code> с начальным значением, равным <code>false</code></h3>
+<h3 id="Example:_Creating_Boolean_objects_with_an_initial_value_of_false">Пример: создание объектов <code>Boolean</code> с начальным значением, равным <code>false</code></h3>
 
 <pre class="brush: js">var bNoParam = new Boolean();
 var bZero = new Boolean(0);
@@ -102,7 +102,7 @@ var bEmptyString = new Boolean('');
 var bfalse = new Boolean(false);
 </pre>
 
-<h3 id="Example:_Creating_Boolean_objects_with_an_initial_value_of_true" name="Example:_Creating_Boolean_objects_with_an_initial_value_of_true">Пример: создание объектов <code>Boolean</code> с начальным значением, равным <code>true</code></h3>
+<h3 id="Example:_Creating_Boolean_objects_with_an_initial_value_of_true">Пример: создание объектов <code>Boolean</code> с начальным значением, равным <code>true</code></h3>
 
 <pre class="brush: js">var btrue = new Boolean(true);
 var btrueString = new Boolean('true');
@@ -112,7 +112,7 @@ var bArrayProto = new Boolean([]);
 var bObjProto = new Boolean({});
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -139,11 +139,11 @@ var bObjProto = new Boolean({});
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Boolean.prototype")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/boolean/tosource/index.html b/files/ru/web/javascript/reference/global_objects/boolean/tosource/index.html
index 274cde29ba..48fbca9836 100644
--- a/files/ru/web/javascript/reference/global_objects/boolean/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/boolean/tosource/index.html
@@ -11,17 +11,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource
 ---
 <div>{{JSRef("Global_Objects", "Boolean")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>toSource()</strong></code> возвращает строку, представляющую исходный код объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>booleanObj</var>.toSource()
 Boolean.toSource()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toSource</code> возвращает следующие значения:</p>
 <ul>
  <li>Для встроенного объекта {{jsxref("Global_Objects/Boolean", "Boolean")}} метод <code>toSource</code> возвращает следующую строку, указывающую, что исходный код недоступен:
@@ -34,13 +34,13 @@ Boolean.toSource()</code></pre>
 </ul>
 <p>Этот метод обычно вызывается внутри движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/boolean/tostring/index.html b/files/ru/web/javascript/reference/global_objects/boolean/tostring/index.html
index e921c155d5..1ce8d60fcd 100644
--- a/files/ru/web/javascript/reference/global_objects/boolean/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/boolean/tostring/index.html
@@ -10,29 +10,29 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString
 ---
 <div>{{JSRef("Global_Objects", "Boolean")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>toString()</strong></code> возвращает строковое представление указанного объекта {{jsxref("Global_Objects/Boolean", "Boolean")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>bool</var>.toString()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Объект {{jsxref("Global_Objects/Boolean", "Boolean")}} переопределяет метод <code>toString</code> объекта {{jsxref("Global_Objects/Object", "Object")}}; он не наследует метод {{jsxref("Object.prototype.toString()")}}. Для объектов {{jsxref("Global_Objects/Boolean", "Boolean")}} метод <code>toString</code> возвращает строковое представление объекта.</p>
 <p>JavaScript вызывает метод <code>toString</code> автоматически, когда объект {{jsxref("Global_Objects/Boolean", "Boolean")}} должен быть представлен в виде текста или когда объект {{jsxref("Global_Objects/Boolean", "Boolean")}} находится в контексте строковой конкатенации.</p>
 <p>Для объектов и значений {{jsxref("Global_Objects/Boolean", "Boolean")}} встроенный метод <code>toString</code> возвращает строки «<code>true</code>» или «<code>false</code>» в зависимости от значения логического объекта.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example.3A_Using_toString" name="Example.3A_Using_toString">Пример: использование <code>toString</code></h3>
+<h3 id="Example.3A_Using_toString">Пример: использование <code>toString</code></h3>
 <p>В следующем коде вызов <code>flag.toString()</code> вернёт строку <code>"true"</code>:</p>
 <pre class="brush: js">var flag = new Boolean(true);
 var myVar = flag.toString();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -58,10 +58,10 @@ var myVar = flag.toString();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toString()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/boolean/valueof/index.html b/files/ru/web/javascript/reference/global_objects/boolean/valueof/index.html
index 9e99579409..77e5123377 100644
--- a/files/ru/web/javascript/reference/global_objects/boolean/valueof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/boolean/valueof/index.html
@@ -10,27 +10,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf
 ---
 <div>{{JSRef("Global_Objects", "Boolean")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>valueOf()</strong></code> возвращает примитивное значение объекта {{jsxref("Global_Objects/Boolean", "Boolean")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>bool</var>.valueOf()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>valueOf</code> объекта {{jsxref("Global_Objects/Boolean", "Boolean")}} возвращает примитивное значение объекта или литерала логического типа.</p>
 <p>Этот метод обычно вызывается внутри движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_valueOf" name="Example:_Using_valueOf">Пример: использование <code>valueOf</code></h3>
+<h3 id="Example:_Using_valueOf">Пример: использование <code>valueOf</code></h3>
 <pre class="brush: js">x = new Boolean();
 myVar = x.valueOf(); // присваивает false переменной myVar
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ myVar = x.valueOf(); // присваивает false переменной myVar
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.valueOf()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getdate/index.html b/files/ru/web/javascript/reference/global_objects/date/getdate/index.html
index 06c43d7b14..52e0d9eefa 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getdate/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getdate/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getDate()</code></strong> возвращает день месяца указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getDate()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getDate()</code>, является целым числом от 1 до 31.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getDate" name="Example:_Using_getDate">Пример: использование метода <code>getDate()</code></h3>
+<h3 id="Example_Using_getDate">Пример: использование метода <code>getDate()</code></h3>
 
 <p>Вторая инструкция в примере ниже присваивает значение 25 переменной <code>day</code> из значения объекта {{jsxref("Global_Objects/Date", "Date")}} <code>date</code>.</p>
 
@@ -39,7 +39,7 @@ let day = date.getDate();
 console.log(day); // 25
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -66,13 +66,13 @@ console.log(day); // 25
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div></div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Date.getDate")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getday/index.html b/files/ru/web/javascript/reference/global_objects/date/getday/index.html
index 628d921793..654e43455f 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getday/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getday/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getDay()</code></strong> возвращает порядковый номер дня недели указанной даты по местному времени, где 0 соответствует воскресенью.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getDay()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getDay()</code>, является целым числом, соответствующим дню недели: 0 соответствует воскресенью, 1 — понедельнику, 2 — вторнику и так далее.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getDay" name="Example:_Using_getDay">Пример: использование метода <code>getDay()</code></h3>
+<h3 id="Example_Using_getDay">Пример: использование метода <code>getDay()</code></h3>
 
 <p>Вторая инструкция в примере ниже присваивает значение 1 переменной <code>weekday</code> из значения объекта {{jsxref("Global_Objects/Date", "Date")}} <code>date</code>. 25 декабря 1995 года было понедельником.</p>
 
@@ -52,7 +52,7 @@ console.log(new Intl.DateTimeFormat('ru-RU', options).format(date));
 </pre>
 </div>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -79,13 +79,13 @@ console.log(new Intl.DateTimeFormat('ru-RU', options).format(date));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div></div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Date.getDay")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getfullyear/index.html b/files/ru/web/javascript/reference/global_objects/date/getfullyear/index.html
index 594410c0a3..5a7d09c7bf 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getfullyear/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getfullyear/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getFullYear()</code></strong> возвращает год указанной даты по местному времени.</p>
 
 <p>Используйте этот метод вместо метода {{jsxref("Date.prototype.getYear()", "getYear()")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getFullYear()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getFullYear()</code> является абсолютным числом. Для дат между 1000 и 9999 годом метод <code>getFullYear()</code> возвращает четырёхзначный номер, например, 1995. Используйте эту функцию, чтобы быть уверенным, что год будет правильным после 2000 года.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getFullYear" name="Example:_Using_getFullYear">Пример: использование метода <code>getFullYear()</code></h3>
+<h3 id="Example_Using_getFullYear">Пример: использование метода <code>getFullYear()</code></h3>
 
 <p>В следующем примере переменной <code>year</code> присваивается четырёхзначное значение текущего года.</p>
 
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
 let year = today.getFullYear(); // 2020
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -66,13 +66,13 @@ let year = today.getFullYear(); // 2020
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div></div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Date.getFullYear")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/gethours/index.html b/files/ru/web/javascript/reference/global_objects/date/gethours/index.html
index b5ecd79d22..4e927a3454 100644
--- a/files/ru/web/javascript/reference/global_objects/date/gethours/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/gethours/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getHours()</code></strong> возвращает часы указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getHours()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getHours()</code>, является целым числом от 0 до 23.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getHours" name="Example:_Using_getHours">Пример: использование метода <code>getHours()</code></h3>
+<h3 id="Example_Using_getHours">Пример: использование метода <code>getHours()</code></h3>
 
 <p>Вторая инструкция в примере ниже присваивает значение 23 переменной <code>hours</code> из значения объекта {{jsxref("Global_Objects/Date", "Date")}} <code>date</code>.</p>
 
@@ -39,7 +39,7 @@ let hours = date.getHours();
 console.log(hours); // 23
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -71,13 +71,13 @@ console.log(hours); // 23
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div></div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Date.getHours")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCHours()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getmilliseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/getmilliseconds/index.html
index c5f0627a5f..4d848fc5e8 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getmilliseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getmilliseconds/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getMilliseconds()</code></strong> возвращает миллисекунды указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getMilliseconds()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getMilliseconds()</code>, является целым числом от 0 до 999.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getMilliseconds" name="Example:_Using_getMilliseconds">Пример: использование метода <code>getMilliseconds()</code></h3>
+<h3 id="Example_Using_getMilliseconds">Пример: использование метода <code>getMilliseconds()</code></h3>
 
 <p>В следующем примере переменной <code>milliseconds</code> присваиваются миллисекунды текущего времени:</p>
 
@@ -39,7 +39,7 @@ let milliseconds = today.getMilliseconds();
 console.log(milliseconds); // 709
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -66,11 +66,11 @@ console.log(milliseconds); // 709
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getminutes/index.html b/files/ru/web/javascript/reference/global_objects/date/getminutes/index.html
index 5eec880184..533cba2dc5 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getminutes/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getminutes/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getMinutes()</code></strong> возвращает минуты указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getMinutes()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getMinutes()</code>, является целым числом от 0 до 59.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getMinutes" name="Example:_Using_getMinutes">Пример: использование метода <code>getMinutes()</code></h3>
+<h3 id="Example_Using_getMinutes">Пример: использование метода <code>getMinutes()</code></h3>
 
 <p>Вторая инструкция в примере ниже присваивает значение 15 переменной <code>minutes</code> из значения объекта {{jsxref("Global_Objects/Date", "Date")}} <code>date</code>.</p>
 
@@ -39,7 +39,7 @@ let minutes = date.getMinutes();
 console.log(minutes); // 15
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -66,11 +66,11 @@ console.log(minutes); // 15
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getmonth/index.html b/files/ru/web/javascript/reference/global_objects/date/getmonth/index.html
index 4b5a9a5342..5b42ea933a 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getmonth/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getmonth/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getMonth()</code></strong> возвращает месяц указанной даты по местному времени, нумерация месяцев начинается с нуля для первого месяца в году.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getMonth()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getMonth()</code>, является целым числом от 0 до 11. 0 соответствует январю, 1 — февралю и так далее.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getMonth" name="Example:_Using_getMonth">Пример: использование метода <code>getMonth()</code></h3>
+<h3 id="Example_Using_getMonth">Пример: использование метода <code>getMonth()</code></h3>
 
 <p>Вторая инструкция в примере ниже присваивает значение 11 переменной <code>month</code> из значения переменной <code>date</code> объекта {{jsxref("Global_Objects/Date", "Date")}}.</p>
 
@@ -39,7 +39,7 @@ let month = date.getMonth();
 console.log(month); // 11
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -66,11 +66,11 @@ console.log(month); // 11
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/getseconds/index.html
index 247cb565fe..6027da393b 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getseconds/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getSeconds()</code></strong> возвращает секунды указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getSeconds()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getSeconds()</code>, является целым числом от 0 до 59.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getSeconds" name="Example:_Using_getSeconds">Пример: использование метода <code>getSeconds()</code></h3>
+<h3 id="Example_Using_getSeconds">Пример: использование метода <code>getSeconds()</code></h3>
 
 <p>Вторая инструкция в примере ниже присваивает значение 30 переменной <code>seconds</code> из значения переменной <code>date</code> объекта {{jsxref("Global_Objects/Date", "Date")}}.</p>
 
@@ -39,7 +39,7 @@ let seconds = date.getSeconds();
 console.log(seconds); // 30
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -66,11 +66,11 @@ console.log(seconds); // 30
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/gettime/index.html b/files/ru/web/javascript/reference/global_objects/date/gettime/index.html
index 407d054fa7..8f380c6208 100644
--- a/files/ru/web/javascript/reference/global_objects/date/gettime/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/gettime/index.html
@@ -21,21 +21,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime
 
 <p class="hidden">Исходный код этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, клонируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и отправьте нам запрос на перенос.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>dateObj</var>.getTime()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Значение, возвращённое методом <code>getTime()</code>, является количеством миллисекунд, прошедших с 1 января 1970 года 00:00:00 по UTC.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_getTime_for_copying_dates" name="Example:_Using_getTime_for_copying_dates">Пример: использование метода <code>getTime()</code> для копирования дат</h3>
+<h3 id="Example_Using_getTime_for_copying_dates">Пример: использование метода <code>getTime()</code> для копирования дат</h3>
 
 <p>Конструирует новый объект даты с идентичным значением времени.</p>
 
@@ -46,7 +46,7 @@ copy.setTime(birthday.getTime());
 console.log(copy.setTime(birthday.getTime())); // 1611090000000
 </pre>
 
-<h3 id="Example_Measuring_execution_time" name="Example:_Measuring_execution_time">Пример: замер времени выполнения</h3>
+<h3 id="Example_Measuring_execution_time">Пример: замер времени выполнения</h3>
 
 <p>Вычитанием двух последовательных вызовов метода <code>getTime()</code> на заново сконструированных объектах {{jsxref("Global_Objects/Date", "Date")}} можно замерить промежуток времени, произошедший между двумя этими вызовами. Это можно использовать для вычисления времени выполнения неких операций.</p>
 
@@ -61,7 +61,7 @@ end = new Date();
 console.log('Операция заняла ' + (end.getTime() - start.getTime()) + ' мсек');
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -88,11 +88,11 @@ console.log('Операция заняла ' + (end.getTime() - start.getTime())
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Date.getTime")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.setTime()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html b/files/ru/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html
index c28659303f..c0060db14f 100644
--- a/files/ru/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html
@@ -11,26 +11,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getTimezoneOffset()</code></strong> возвращает смещение часового пояса относительно часового пояса UTC в минутах для текущей локали.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.getTimezoneOffset()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Возвращает смещение часового пояса, являющееся разностью в минутах между временем UTC и местным временем. Обратите внимание, что это значит, что смещение будет положительным для местного часового пояса, находящегося западнее часового пояса UTC и отрицательным — восточнее. Например, если ваш часовой пояс равен UTC+10 (австралийское восточное поясное время), будет возвращено значение -600. Наличие летнего и зимнего времени не даёт этому смещению быть постоянным, даже в пределах одного часового пояса.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getTimezoneOffset" name="Example:_Using_getTimezoneOffset">Пример: использование метода <code>getTimezoneOffset()</code></h3>
+<h3 id="Example:_Using_getTimezoneOffset">Пример: использование метода <code>getTimezoneOffset()</code></h3>
 <pre class="brush: js">var x = new Date();
 var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,5 +56,5 @@ var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60;
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getutcdate/index.html b/files/ru/web/javascript/reference/global_objects/date/getutcdate/index.html
index 12af32b5f7..215c92a6e3 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getutcdate/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getutcdate/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getUTCDate()</code></strong> возвращает день месяца указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><var>dateObj</var>.getUTCDate()</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Значение, возвращённое методом <code>getUTCDate()</code>, является целым числом от 1 до 31.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getUTCDate" name="Example:_Using_getUTCDate">Пример: использование метода <code>getUTCDate()</code></h3>
+<h3 id="Example:_Using_getUTCDate">Пример: использование метода <code>getUTCDate()</code></h3>
 <p>В следующем примере переменной <code>day</code> присваивается значение дня из текущей даты.</p>
 <pre class="brush: js">var today = new Date();
 var day = today.getUTCDate();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var day = today.getUTCDate();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getDate()")}}</li>
  <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getutcday/index.html b/files/ru/web/javascript/reference/global_objects/date/getutcday/index.html
index 51ae833ef5..90eae77142 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getutcday/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getutcday/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getUTCDay()</code></strong> возвращает день недели указанной даты по всемирному координированному времени, где 0 соответствует воскресенью.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.getUTCDay()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Значение, возвращённое методом <code>getDay()</code>, является целым числом, соответствующим дню недели: 0 соответствует воскресенью, 1 — понедельнику, 2 — вторнику и так далее.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getUTCDay" name="Example:_Using_getUTCDay">Пример: использование метода <code>getUTCDay()</code></h3>
+<h3 id="Example:_Using_getUTCDay">Пример: использование метода <code>getUTCDay()</code></h3>
 <p>В следующем примере переменной <code>weekday</code> присваивается номер дня недели из текущей даты.</p>
 <pre class="brush: js">var today = new Date();
 var weekday = today.getUTCDay();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var weekday = today.getUTCDay();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
  <li>{{jsxref("Date.prototype.getDay()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getutcfullyear/index.html b/files/ru/web/javascript/reference/global_objects/date/getutcfullyear/index.html
index 17d787b771..e99a61c34d 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getutcfullyear/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getutcfullyear/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getUTCFullYear()</code></strong> возвращает год указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.getUTCFullYear()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Значение, возвращённое методом <code>getUTCFullYear()</code> является абсолютным числом, совместимым с проблемой 2000 года, например, 1995.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getUTCFullYear" name="Example:_Using_getUTCFullYear">Пример: использование метода <code>getUTCFullYear()</code></h3>
+<h3 id="Example:_Using_getUTCFullYear">Пример: использование метода <code>getUTCFullYear()</code></h3>
 <p>В следующем примере переменной <code>year</code> присваивается четырёхзначное значение текущего года.</p>
 <pre class="brush: js">var today = new Date();
 var year = today.getUTCFullYear();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var year = today.getUTCFullYear();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
  <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getutchours/index.html b/files/ru/web/javascript/reference/global_objects/date/getutchours/index.html
index 1a6b46c2e4..0f80ff99db 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getutchours/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getutchours/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getUTCHours()</code></strong> возвращает часы указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.getUTCHours()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Значение, возвращённое методом <code>getUTCHours()</code>, является целым числом от 0 до 23.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getUTCHours" name="Example:_Using_getUTCHours">Пример: использование метода <code>getUTCHours()</code></h3>
+<h3 id="Example:_Using_getUTCHours">Пример: использование метода <code>getUTCHours()</code></h3>
 <p>В следующем примере переменной <code>hours</code> присваивается количество часов из текущего времени.</p>
 <pre class="brush: js">var today = new Date();
 var hours = today.getUTCHours();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var hours = today.getUTCHours();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getHours()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html
index 9dd3636b42..85f0bbcc61 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getUTCMilliseconds()</code></strong> возвращает миллисекунды указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.getUTCMilliseconds()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Значение, возвращённое методом <code>getUTCMilliseconds()</code>, является целым числом от 0 до 999.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getUTCMilliseconds" name="Example:_Using_getUTCMilliseconds">Пример: использование метода <code>getUTCMilliseconds()</code></h3>
+<h3 id="Example:_Using_getUTCMilliseconds">Пример: использование метода <code>getUTCMilliseconds()</code></h3>
 <p>В следующем примере переменной <code>milliseconds</code> присваивается количество миллисекунд из текущего времени.</p>
 <pre class="brush: js">var today = new Date();
 var milliseconds = today.getUTCMilliseconds();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var milliseconds = today.getUTCMilliseconds();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getutcminutes/index.html b/files/ru/web/javascript/reference/global_objects/date/getutcminutes/index.html
index 845772e19a..da83dfa35c 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getutcminutes/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getutcminutes/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getUTCMinutes()</code></strong> возвращает минуты указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.getUTCMinutes()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Значение, возвращённое методом <code>getUTCMinutes()</code>, является целым числом от 0 до 59.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getUTCMinutes" name="Example:_Using_getUTCMinutes">Пример: использование метода <code>getUTCMinutes()</code></h3>
+<h3 id="Example:_Using_getUTCMinutes">Пример: использование метода <code>getUTCMinutes()</code></h3>
 <p>В следующем примере переменной <code>minutes</code> присваивается количество минут из текущего времени.</p>
 <pre class="brush: js">var today = new Date();
 var minutes = today.getUTCMinutes();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var minutes = today.getUTCMinutes();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getMinutes()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getutcmonth/index.html b/files/ru/web/javascript/reference/global_objects/date/getutcmonth/index.html
index 47ff426e6a..64a335f3c3 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getutcmonth/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getutcmonth/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getUTCMonth()</code></strong> возвращает месяц указанной даты по всемирному координированному времени, нумерация месяцев начинается с нуля для первого месяца в году.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.getUTCMonth()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Значение, возвращённое методом <code>getUTCMonth()</code>, является целым числом от 0 до 11. 0 соответствует январю, 1 — февралю и так далее.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getUTCMonth" name="Example:_Using_getUTCMonth">Пример: использование метода <code>getUTCMonth()</code></h3>
+<h3 id="Example:_Using_getUTCMonth">Пример: использование метода <code>getUTCMonth()</code></h3>
 <p>В следующем примере переменной <code>month</code> присваивается значение месяца из текущей даты.</p>
 <pre class="brush: js">var today = new Date();
 var month = today.getUTCMonth();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var month = today.getUTCMonth();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getMonth()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getutcseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/getutcseconds/index.html
index 2f6fcf66a9..8e2c22f8b3 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getutcseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getutcseconds/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>getUTCSeconds()</code></strong> возвращает секунды указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.getUTCSeconds()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Значение, возвращённое методом <code>getUTCSeconds()</code>, является целым числом от 0 до 59.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_getUTCSeconds" name="Example:_Using_getUTCSeconds">Пример: использование метода <code>getUTCSeconds()</code></h3>
+<h3 id="Example:_Using_getUTCSeconds">Пример: использование метода <code>getUTCSeconds()</code></h3>
 <p>В следующем примере переменной <code>seconds</code> присваивается количество секунд из текущего времени.</p>
 <pre class="brush: js">var today = new Date();
 var seconds = today.getUTCSeconds();
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var seconds = today.getUTCSeconds();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getSeconds()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/getyear/index.html b/files/ru/web/javascript/reference/global_objects/date/getyear/index.html
index e7c7b42782..4b4081bfa8 100644
--- a/files/ru/web/javascript/reference/global_objects/date/getyear/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/getyear/index.html
@@ -12,19 +12,19 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear
 ---
 <div>{{JSRef("Global_Objects", "Date")}} {{deprecated_header("")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>getYear()</code></strong> возвращает год указанной даты по местному времени. Поскольку метод <code>getYear()</code> не возвращает полный год («проблема 2000 года»), он больше не используется и был заменён методом {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.getYear()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Метод <code>getYear()</code> возвращает год минус 1900; таким образом:</p>
 
@@ -36,9 +36,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear
 
 <p>Чтобы учесть года до и после 2000, вы должны вместо метода <code>getYear()</code> использовать метод {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}, который возвращает полный год.</p>
 
-<h2 id="Backward_compatibility" name="Backward_compatibility">Обратная совместимость</h2>
+<h2 id="Backward_compatibility">Обратная совместимость</h2>
 
-<h3 id="JavaScript_1.2_and_earlier" name="JavaScript_1.2_and_earlier">Поведение в JavaScript 1.2 и ранее</h3>
+<h3 id="JavaScript_1.2_and_earlier">Поведение в JavaScript 1.2 и ранее</h3>
 
 <p>Метод <code>getYear()</code> возвращал 2-х или 4-х значный год:</p>
 
@@ -47,9 +47,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear
  <li>Для годов, меньших 1900, либо больших 1999, значение, возвращаемое методом <code>getYear()</code> было четырёхзначным годом. Например, если год равнялся 1856, возвращаемое значение равнялось 1856. Если год равнялся 2026, возвращаемое значение равнялось 2026.</li>
 </ul>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Years_between_1900_and_1999" name="Example:_Years_between_1900_and_1999">Пример: года между 1900 и 1999</h3>
+<h3 id="Example:_Years_between_1900_and_1999">Пример: года между 1900 и 1999</h3>
 
 <p>Вторая инструкция присваивает значение 95 переменной <code>year</code>.</p>
 
@@ -57,7 +57,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear
 var year = Xmas.getYear(); // вернёт 95
 </pre>
 
-<h3 id="Example:_Years_above_1999" name="Example:_Years_above_1999">Пример: года после 1999</h3>
+<h3 id="Example:_Years_above_1999">Пример: года после 1999</h3>
 
 <p>Вторая инструкция присваивает значение 100 переменной <code>year</code>.</p>
 
@@ -65,7 +65,7 @@ var year = Xmas.getYear(); // вернёт 95
 var year = Xmas.getYear(); // вернёт 100
 </pre>
 
-<h3 id="Example:_Years_below_1900" name="Example:_Years_below_1900">Пример: года до 1900</h3>
+<h3 id="Example:_Years_below_1900">Пример: года до 1900</h3>
 
 <p>Вторая инструкция присваивает значение -100 переменной <code>year</code>.</p>
 
@@ -73,7 +73,7 @@ var year = Xmas.getYear(); // вернёт 100
 var year = Xmas.getYear(); // вернёт -100
 </pre>
 
-<h3 id="Example:_Setting_and_getting_a_year_between_1900_and_1999" name="Example:_Setting_and_getting_a_year_between_1900_and_1999">Пример: установка и получение года между 1900 и 1999</h3>
+<h3 id="Example:_Setting_and_getting_a_year_between_1900_and_1999">Пример: установка и получение года между 1900 и 1999</h3>
 
 <p>Вторая инструкция присваивает значение 95 переменной <code>year</code>, которое представляет 1995 год.</p>
 
@@ -81,7 +81,7 @@ var year = Xmas.getYear(); // вернёт -100
 var year = Xmas.getYear(); // вернёт 95
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -108,13 +108,13 @@ var year = Xmas.getYear(); // вернёт 95
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div> </div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Date.getYear")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/index.html b/files/ru/web/javascript/reference/global_objects/date/index.html
index 420b957a5f..bf3ce884dd 100644
--- a/files/ru/web/javascript/reference/global_objects/date/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/index.html
@@ -10,7 +10,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Создаёт экземпляр объекта <strong><code>Date</code></strong>, представляющего собой момент времени. Объект Дата содержит число миллисекунд прошедших с 1 января 1970 г. UTC</p>
 
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date
 <p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code>new Date();
 new Date(<var>value</var>);
@@ -34,7 +34,7 @@ new Date(<var>year</var>, <var>month</var>[, <var>day</var>[, <var>hour</var>[,
 <p><strong>Обратите внимание:</strong> объекты <code>Date</code> могут быть созданы только путём вызова функции <code>Date</code> в качестве конструктора: обычный вызов функции (то есть, без использования оператора {{jsxref("Operators/new", "new")}}) вернёт строку вместо объекта <code>Date</code>; в отличие от других объектных типов JavaScript, объекты <code>Date</code> не имеют литерального синтаксиса.</p>
 </div>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <div class="note">
 <p><strong>Обратите внимание:</strong> если функция <code>Date</code> вызывается в качестве конструктора с более, чем одним аргументом, значения, большие логического диапазона (например, 13 в качестве номера месяца или 70 для значения минут) «переметнутся» на соседние значения. Например, вызов <code>new Date(2013, 13, 1)</code> эквивалентен вызову <code>new Date(2014, 1, 1)</code>, оба создадут дату <code>2014-02-01</code> (нумерация месяцев начинается с нуля). Тоже самое действует и для других значений: вызов <code>new Date(2013, 2, 1, 0, 70)</code> эквивалентен вызову <code>new Date(2013, 2, 1, 1, 10)</code> — оба вызова создадут дату <code>2013-03-01T01:10:00</code>.</p>
@@ -65,7 +65,7 @@ new Date(<var>year</var>, <var>month</var>[, <var>day</var>[, <var>hour</var>[,
  <dd>Необязательный параметр. Целое значение, представляющее миллисекунды времени.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <ul>
  <li>Если никаких аргументов передано не было, конструктор создаёт объект <code>Date</code>  для текущих даты и времени, согласно системным настройкам.</li>
@@ -76,7 +76,7 @@ new Date(<var>year</var>, <var>month</var>[, <var>day</var>[, <var>hour</var>[,
  <li>Вызов объекта <code>Date</code> в качестве функции (то есть, без использования оператора {{jsxref("Operators/new", "new")}}) вернёт строку, представляющую текущие дату и время.</li>
 </ul>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("Date.prototype")}}</dt>
@@ -87,7 +87,7 @@ new Date(<var>year</var>, <var>month</var>[, <var>day</var>[, <var>hour</var>[,
 
 <div>{{jsOverrides("Function", "properties", "prototype")}}</div>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <dl>
  <dt>{{jsxref("Date.now()")}}</dt>
@@ -100,7 +100,7 @@ new Date(<var>year</var>, <var>month</var>[, <var>day</var>[, <var>hour</var>[,
 
 <div>{{jsOverrides("Function", "Methods", "now", "parse", "UTC")}}</div>
 
-<h2 id="Date_instances" name="Date_instances">Экземпляры объекта <code>Date</code></h2>
+<h2 id="Date_instances">Экземпляры объекта <code>Date</code></h2>
 
 <p>Все экземпляры объекта <code>Date</code> наследуются от {{jsxref("Date.prototype")}}. Объект прототипа конструктора <code>Date</code> может быть изменён, чтобы затронуть все экземпляры объекта <code>Date</code>.</p>
 
@@ -108,9 +108,9 @@ new Date(<var>year</var>, <var>month</var>[, <var>day</var>[, <var>hour</var>[,
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Date/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Several_ways_to_assign_dates" name="Example:_Several_ways_to_assign_dates">Пример: несколько способов создания объекта <code>Date</code></h3>
+<h3 id="Example_Several_ways_to_assign_dates">Пример: несколько способов создания объекта <code>Date</code></h3>
 
 <p>Следующие примеры показывают несколько способов создания дат в JavaScript:</p>
 
@@ -125,7 +125,7 @@ var birthday = new Date(1995, 11, 17);
 var birthday = new Date(1995, 11, 17, 3, 24, 0);
 </pre>
 
-<h3 id="Example_Two_digit_years_map_to_1900_-_1999" name="Example:_Two_digit_years_map_to_1900_-_1999">Пример: двухциферный год отображается на 1900 - 1999 года</h3>
+<h3 id="Example_Two_digit_years_map_to_1900_-_1999">Пример: двухциферный год отображается на 1900 - 1999 года</h3>
 
 <p>Для того, чтобы создать и получить даты между 0 и 99 годом, нужно использовать методы {{jsxref("Date.prototype.setFullYear()")}} и {{jsxref("Date.prototype.getFullYear()")}}.</p>
 
@@ -137,7 +137,7 @@ date.setYear(98);           // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
 date.setFullYear(98);       // Sat Feb 01 0098 00:00:00 GMT+0000 (BST)
 </pre>
 
-<h3 id="Example_Calculating_elapsed_time" name="Example:_Calculating_elapsed_time">Пример: вычисление затраченного времени</h3>
+<h3 id="Example_Calculating_elapsed_time">Пример: вычисление затраченного времени</h3>
 
 <p>Следующие примеры показывают, как определить разницу во времени между двумя датами в JavaScript:</p>
 
@@ -183,7 +183,7 @@ yourFunctionReturn = printElapsedTime(yourFunction);
 
 <p>В этом случае важно возвращать только целое число (так что простое деление не подойдёт), а также возвращать только фактически прошедшие секунды (поэтому этот код использует {{jsxref ("Math.floor ()")}} а не {{jsxref ("Math.round ()")}}).</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -223,6 +223,6 @@ yourFunctionReturn = printElapsedTime(yourFunction);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Date", 3)}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/date/now/index.html b/files/ru/web/javascript/reference/global_objects/date/now/index.html
index 93319d85cf..0dc15a5b2c 100644
--- a/files/ru/web/javascript/reference/global_objects/date/now/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/now/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/now
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Date.now()</code></strong> возвращает количество миллисекунд, прошедших с 1 января 1970 года 00:00:00 по UTC.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>var timeInMs = Date.now();</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>now()</code> возвращает количество миллисекунд, прошедших с 1 января 1970 года 00:00:00 по UTC по текущий момент времени в качестве {{jsxref("Global_Objects/Number", "числа", "", 1)}}.</p>
 
 <p>Поскольку метод <code>now()</code> является статическим методом объекта {{jsxref("Global_Objects/Date", "Date")}}, вы всегда должны использовать его как <code>Date.now()</code>.</p>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод был стандартизирован в ECMA-262 5-го издания. Отсутствие этого метода в движках, которые не были обновлены для его поддержки, можно обойти следующей прокладкой:</p>
 
@@ -40,7 +40,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/now
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -62,13 +62,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/now
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Date.now")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{domxref("Performance.now()")}} — предоставляет временные метки с разрешением в доли миллисекунд для использования при измерении производительности веб-страницы</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/parse/index.html b/files/ru/web/javascript/reference/global_objects/date/parse/index.html
index 1591a8611b..57f17036b5 100644
--- a/files/ru/web/javascript/reference/global_objects/date/parse/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/parse/index.html
@@ -10,11 +10,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Date.parse()</code></strong> разбирает строковое представление даты и возвращает количество миллисекунд, прошедших с 1 января 1970 года 00:00:00 по UTC.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <p>Прямой вызов:</p>
 
@@ -24,20 +24,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse
 
 <pre class="syntaxbox"><code>new Date(<var>dateString</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>dateString</code></dt>
  <dd>Строковое представление даты из RFC2822 (<a href="http://tools.ietf.org/html/rfc2822#page-14">на английском</a>, <a href="http://rfc2.ru/5322.rfc/print#p3.3">на русском</a>) или ISO 8601. Могут использоваться и другие форматы, но результаты в таком случае будут непредсказуемые.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>parse()</code> принимает строку с датой (например, <code>"Dec 25, 1995"</code>) и возвращает количество миллисекунд, прошедших с 1 января 1970 года 00:00:00 по UTC. Этот метод полезен для установки значения даты из строкового значения, например, в сочетании с методом {{jsxref("Date.prototype.setTime()", "setTime()")}} о объектом {{jsxref("Global_Objects/Date", "Date")}}.</p>
 
 <p>По данному строковому представлению времени метод <code>parse()</code> возвращает значение времени. Он принимает синтаксис даты из RFC2822 / IETF (RFC2822 раздел 3.3 — <a href="http://tools.ietf.org/html/rfc2822#page-14">на английском</a>, <a href="http://rfc2.ru/5322.rfc/print#p3.3">на русском</a>), например, <code>"Mon, 25 Dec 1995 13:30:00 GMT"</code>. Он понимает аббревиатуры континентальных часовых поясов США, но для общего пользования используйте смещение часовых поясов, например, <code>"Mon, 25 Dec 1995 13:30:00 +0430"</code> (4 часа 30 минут к востоку от Гринвичского меридиана). Если часовой пояс не определён и строка является форматом ISO, распозначаемым ES5, предполагается, что часовым поясом является UTC. GMT и UTC считаются эквивалентными. Местный часовой пояс используется для интерпретации аргумента в формате RFC2822 из раздела 3.3 (<a href="http://tools.ietf.org/html/rfc2822#page-14">на английском</a>, <a href="http://rfc2.ru/5322.rfc/print#p3.3">на русском</a>) (или в любом другом формате, не распознаваемым как ISO 8601 в ES5), если он не содержит информации о часовом поясе.</p>
 
-<h3 id="ECMAScript_5_ISO-8601_format_support" name="ECMAScript_5_ISO-8601_format_support">Поддержка формата ISO-8601 в ECMAScript 5</h3>
+<h3 id="ECMAScript_5_ISO-8601_format_support">Поддержка формата ISO-8601 в ECMAScript 5</h3>
 
 <p>Строка с датой и временем может быть в формате <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a>. Например, могут быть переданы и разобраны строки <code>"2011-10-10"</code> (только дата) или <code>"2011-10-10T14:48:00"</code> (дата и время). Для интерпретации аргументов в формате <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a>, не содержащих информацию о часовом поясе, используется часовой пояс UTC.</p>
 
@@ -45,11 +45,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse
 
 <p>Поскольку метод <code>parse()</code> является статическим методом объекта {{jsxref("Global_Objects/Date", "Date")}}, вы всегда должны использовать его как <code>Date.parse()</code>.</p>
 
-<h3 id="Differences_in_assumed_time-zone" name="Differences_in_assumed_time-zone">Различия в предполагаемом часовом поясе</h3>
+<h3 id="Differences_in_assumed_time-zone">Различия в предполагаемом часовом поясе</h3>
 
 <p>Для строки даты <code>"March 7, 2014"</code>, метод <code>parse()</code> будет предполагать местный часовой пояс, но если строка дана в формате ISO, например <code>"2014-03-07"</code>, он будет предполагать, что часовой пояс равен UTC. Поэтому объекты {{jsxref("Global_Objects/Date", "Date")}}, созданные из этих строк, если в системе местный часовой пояс не равен UTC, будут представлять разные моменты времени. Это значит, что две строки с датами, которые выглядят одинаковыми, могут дать два разных значения в зависимости от формата преобразуемой строки.</p>
 
-<h3 id="Fall-back_to_implementation-specific_date_formats" name="Fall-back_to_implementation-specific_date_formats">Откат к зависимым от реализации форматам даты</h3>
+<h3 id="Fall-back_to_implementation-specific_date_formats">Откат к зависимым от реализации форматам даты</h3>
 
 <p>В спецификации ECMAScript говорится: если строка не соответствует стандартному формату, функция может откатиться к любой зависимой от реализации эвристике, либо к зависимому от реализации алгоритму разбора. Нераспознанные строки, либо даты, содержащие недопустимые значения элементов в строках формата ISO, должны при вызове <code>Date.parse()</code> возвращать {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 
@@ -80,9 +80,9 @@ Date.parse('foo-bar 2014');
 // вернёт: NaN
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_parse" name="Example:_Using_parse">Пример: использование метода <code>Date.parse()</code></h3>
+<h3 id="Example_Using_parse">Пример: использование метода <code>Date.parse()</code></h3>
 
 <p>Если переменная <code>IPOdate</code> содержит существующий объект {{jsxref("Global_Objects/Date", "Date")}}, она может быть установлена в 9 августа 1995 года (по местному времени) следующим способом:</p>
 
@@ -114,7 +114,7 @@ Date.parse('foo-bar 2014');
 
 <p>Вернёт <code>14400000</code> вне зависимости от местного часового пояса, поскольку предоставлен спецификатор GMT (всемирное координированное время).</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -141,11 +141,11 @@ Date.parse('foo-bar 2014');
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.UTC()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setdate/index.html b/files/ru/web/javascript/reference/global_objects/date/setdate/index.html
index 0fd3f1c9b0..b407659bca 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setdate/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setdate/index.html
@@ -11,15 +11,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>setDate()</code></strong> устанавливает день месяца указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.setDate(<var>dayValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>dayValue</code></dt>
@@ -30,20 +30,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate
 
 <p>В результате выполнения функция setDate() изменяет текущий объект ({{jsxref("Date")}}) и возвращает количество миллисекунд от начала эпохи (1 января 1970 00:00:00 UTC) для полученного значения объекта.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если значение параметра <code>dayValue</code> будет выходить за пределы количества дней для месяца, метод <code>setDate()</code> соответственно обновит объект {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>dayValue</code> передать значение 0, дата будет установлена в последний день предыдущего месяца.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setDate" name="Example:_Using_setDate">Пример: использование метода <code>setDate()</code></h3>
+<h3 id="Example:_Using_setDate">Пример: использование метода <code>setDate()</code></h3>
 
 <pre class="brush: js">var theBigDay = new Date(1962, 6, 7); // 1962-07-07
 theBigDay.setDate(24);  // 1962-07-24
 theBigDay.setDate(32);  // 1962-08-01
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -70,13 +70,13 @@ theBigDay.setDate(32);  // 1962-08-01
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div> </div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Date.setDate")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getDate()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setfullyear/index.html b/files/ru/web/javascript/reference/global_objects/date/setfullyear/index.html
index 42a1bbf62c..89f7ce95b8 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setfullyear/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setfullyear/index.html
@@ -11,15 +11,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>setFullYear()</code></strong> устанавливает полный год указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.setFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>yearValue</code></dt>
@@ -30,25 +30,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear
  <dd>Необязательный параметр. Целое число от 1 до 31, представляющее день месяца. Если вы определите параметр <code>dayValue</code>, вы также должны определить параметр <code>monthValue</code>.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns" style="line-height: 24px; font-size: 1.71428571428571rem;">Возвращаемое значение</h3>
+<h3 id="Returns" style="line-height: 24px; font-size: 1.71428571428571rem;">Возвращаемое значение</h3>
 
 <p>Текущее время в миллисекундах для нового значения даты — такое же значение как и у метода {{jsxref("Date.prototype.getTime()", "getTime()")}} для текущего объекта <strong>после</strong> вызова <code style="font-style: normal;">setFullYear()</code>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если вы не определите значения параметров <code>monthValue</code> и <code>dayValue</code>, будут использоваться значения, возвращаемые методами {{jsxref("Date.prototype.getMonth()", "getMonth()")}} и {{jsxref("Date.prototype.getDate()", "getDate()")}}.</p>
 
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setFullYear()</code> попытается соответственно обновить другие параметры и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>monthValue</code> передать значение 15, год увеличится на 1 (<code>yearValue + 1</code>), а в качестве месяца будет использоваться значение 3.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setFullYear" name="Example:_Using_setFullYear">Пример: использование метода <code>setFullYear()</code></h3>
+<h3 id="Example:_Using_setFullYear">Пример: использование метода <code>setFullYear()</code></h3>
 
 <pre class="brush:js">var theBigDay = new Date();
 theBigDay.setFullYear(1997);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -75,11 +75,11 @@ theBigDay.setFullYear(1997);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/sethours/index.html b/files/ru/web/javascript/reference/global_objects/date/sethours/index.html
index 2f015bfa8e..582209abd1 100644
--- a/files/ru/web/javascript/reference/global_objects/date/sethours/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/sethours/index.html
@@ -11,16 +11,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setHours()</code></strong> устанавливает часы указанной даты по местному времени и возвращает количество миллисекунд, прошедших с 1 января 1970 00:00:00 по UTC до времени, представляемого обновлённым экземпляром {{jsxref("Global_Objects/Date", "Date")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre>
 
 <h3 id="Версия_до_JavaScript_1.3">Версия до JavaScript 1.3</h3>
 <pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>hoursValue</code></dt>
  <dd>Целое число от 0 до 23, представляющее часы.</dd>
@@ -32,18 +32,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours
  <dd>Необязательный параметр. Целое число от 0 до 999, представляющее миллисекунды. Если вы определите параметр <code>msValue</code>, вы также должны определить параметры <code>minutesValue</code> и <code>secondsValue</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы не определите значения параметров <code>minutesValue</code>, <code>secondsValue</code> и <code>msValue</code>, будут использоваться значения, возвращаемые методами {{jsxref("Date.prototype.getMinutes()", "getMinutes()")}}, {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} и {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p>
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setHours()</code> попытается соответственно обновить другие параметры и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>secondsValue</code> передать значение 100, минуты увеличатся на 1 (<code>minutesValue + 1</code>), а в качестве секунд будет использоваться значение 40.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setHours" name="Example:_Using_setHours">Пример: использование метода <code>setHours()</code></h3>
+<h3 id="Example:_Using_setHours">Пример: использование метода <code>setHours()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setHours(7);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -69,10 +69,10 @@ theBigDay.setHours(7);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getHours()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setmilliseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/setmilliseconds/index.html
index 3bfb9a0781..d8002d8b56 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setmilliseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setmilliseconds/index.html
@@ -11,29 +11,29 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setMilliseconds()</code></strong> устанавливает миллисекунды указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setMilliseconds(<var>millisecondsValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>millisecondsValue</code></dt>
  <dd>Целое число от 0 до 999, представляющее миллисекунды.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если значение параметра <code>millisecondsValue</code> будет выходить за пределы ожидаемого диапазона, метод <code>setMilliseconds()</code> соответственно обновит объект {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>millisecondsValue</code> передать значение 1005, количество секунд увеличится на 1, а в качестве миллисекунд будет использоваться значение 5.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setMilliseconds" name="Example:_Using_setMilliseconds">Пример: использование метода <code>setMilliseconds()</code></h3>
+<h3 id="Example:_Using_setMilliseconds">Пример: использование метода <code>setMilliseconds()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setMilliseconds(100);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -59,10 +59,10 @@ theBigDay.setMilliseconds(100);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setminutes/index.html b/files/ru/web/javascript/reference/global_objects/date/setminutes/index.html
index 12b94ab5f4..8050cadad2 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setminutes/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setminutes/index.html
@@ -11,11 +11,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>setMinutes()</code></strong> устанавливает минуты указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre>
 
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes
 
 <pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>minutesValue</code></dt>
@@ -38,21 +38,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes
 
 <p>Количество миллисекунд между 1 января 1970 00:00:00 UTC и обновлённой датой.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если вы не определите значения параметров <code>secondsValue</code> и <code>msValue</code>, будут использоваться значения, возвращаемые методами {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} и {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p>
 
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setMinutes()</code> попытается соответственно обновить другие параметры и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>secondsValue</code> передать значение 100, минуты увеличатся на 1 (<code>minutesValue + 1</code>), а в качестве секунд будет использоваться значение 40.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setMinutes" name="Example:_Using_setMinutes">Пример: использование метода <code>setMinutes()</code></h3>
+<h3 id="Example:_Using_setMinutes">Пример: использование метода <code>setMinutes()</code></h3>
 
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setMinutes(45);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -79,11 +79,11 @@ theBigDay.setMinutes(45);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getMinutes()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setmonth/index.html b/files/ru/web/javascript/reference/global_objects/date/setmonth/index.html
index cf52253471..f1a680f463 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setmonth/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setmonth/index.html
@@ -11,16 +11,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setMonth()</code></strong> устанавливает месяц указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre>
 
 <h3 id="Версия_до_JavaScript_1.3">Версия до JavaScript 1.3</h3>
 <pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>)</code></pre>
 
-<h3 id="Parameter" name="Parameter">Parameter</h3>
+<h3 id="Parameter">Parameter</h3>
 <dl>
  <dt><code>monthValue</code></dt>
  <dd>Целое число от 0 до 11, представляющее месяцы от января до декабря.</dd>
@@ -28,18 +28,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth
  <dd>Необязательный параметр. Целое число от 1 до 31, представляющее день месяца.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы не определите значения параметра <code>dayValue</code>, будет использоваться значение, возвращаемое методом {{jsxref("Date.prototype.getDate()", "getDate()")}}.</p>
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setMonth()</code> попытается соответственно обновить другой параметр и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>monthValue</code> передать значение 15, год увеличится на 1, а в качестве месяца будет использоваться значение 3.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setMonth" name="Example:_Using_setMonth">Пример: использование метода <code>setMonth()</code></h3>
+<h3 id="Example:_Using_setMonth">Пример: использование метода <code>setMonth()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setMonth(6);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -65,10 +65,10 @@ theBigDay.setMonth(6);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getMonth()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/setseconds/index.html
index c56979b3fd..ebb5d2311f 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setseconds/index.html
@@ -11,16 +11,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setSeconds()</code></strong> устанавливает секунды указанной даты по местному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre>
 
 <h3 id="Версия_до_JavaScript_1.3">Версия до JavaScript 1.3</h3>
 <pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>secondsValue</code></dt>
  <dd>Целое число от 0 до 59, представляющее количество секунд.</dd>
@@ -28,18 +28,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds
  <dd>Необязательный параметр. Число от 0 до 999, представляющее количество миллисекунд.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы не определите значения параметра <code>msValue</code>, будет использоваться значение, возвращаемое методом {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p>
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setSeconds()</code> попытается соответственно обновить другой параметр и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>secondsValue</code> передать значение 100, минуты увеличатся на 1, а в качестве секунд будет использоваться значение 40.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setSeconds" name="Example:_Using_setSeconds">Пример: использование метода <code>setSeconds()</code></h3>
+<h3 id="Example:_Using_setSeconds">Пример: использование метода <code>setSeconds()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setSeconds(30);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -65,10 +65,10 @@ theBigDay.setSeconds(30);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getSeconds()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/settime/index.html b/files/ru/web/javascript/reference/global_objects/date/settime/index.html
index a6eff12b0e..1d8faed12c 100644
--- a/files/ru/web/javascript/reference/global_objects/date/settime/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/settime/index.html
@@ -11,30 +11,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setTime()</code></strong> устанавливает время объекта {{jsxref("Global_Objects/Date", "Date")}} в значение, представляемое количеством миллисекунд, прошедших с 1 января 1970 00:00:00 по UTC.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setTime(<var>timeValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>timeValue</code></dt>
  <dd>Целое число, представляющее количеством миллисекунд, прошедших с 1 января 1970 00:00:00 по UTC.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Используя метод <code>setTime()</code>, можно присвоить дату и время другому объекту {{jsxref("Global_Objects/Date", "Date")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setTime" name="Example:_Using_setTime">Пример: использование метода <code>setTime()</code></h3>
+<h3 id="Example:_Using_setTime">Пример: использование метода <code>setTime()</code></h3>
 <pre class="brush: js">var theBigDay = new Date('July 1, 1999');
 var sameAsBigDay = new Date();
 sameAsBigDay.setTime(theBigDay.getTime());
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -60,10 +60,10 @@ sameAsBigDay.setTime(theBigDay.getTime());
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getTime()")}}</li>
  <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setutcdate/index.html b/files/ru/web/javascript/reference/global_objects/date/setutcdate/index.html
index c69ccee4da..2b51df4c04 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setutcdate/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setutcdate/index.html
@@ -11,29 +11,29 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setUTCDate()</code></strong> устанавливает день месяца указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setUTCDate(<var>dayValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>dayValue</code></dt>
  <dd>Целое число от 1 до 31, представляющее номер дня в месяце.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если значение параметра <code>dayValue</code> будет выходить за пределы количества дней для месяца, метод <code>setUTCDate()</code> попытается соответственно обновить объект {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>dayValue</code> передать значение 40, а текущий сохранённый в объекте {{jsxref("Global_Objects/Date", "Date")}} месяц равен июню, день будет изменён на 10, а месяц увеличится до июля.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setUTCDate" name="Example:_Using_setUTCDate">Пример: использование метода <code>setUTCDate()</code></h3>
+<h3 id="Example:_Using_setUTCDate">Пример: использование метода <code>setUTCDate()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setUTCDate(20);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -59,10 +59,10 @@ theBigDay.setUTCDate(20);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
  <li>{{jsxref("Date.prototype.setDate()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setutcfullyear/index.html b/files/ru/web/javascript/reference/global_objects/date/setutcfullyear/index.html
index ed994dc6a5..60b6867cb8 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setutcfullyear/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setutcfullyear/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setUTCFullYear()</code></strong> устанавливает полный год указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setUTCFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>yearValue</code></dt>
  <dd>Целое число, определяющее значение года, например, 1995.</dd>
@@ -27,18 +27,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear
  <dd>Необязательный параметр. Целое число от 1 до 31, представляющее день месяца. Если вы определите параметр <code>dayValue</code>, вы также должны определить параметр <code>monthValue</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы не определите значения параметров <code>monthValue</code> и <code>dayValue</code>, будут использоваться значения, возвращаемые методами {{jsxref("Date.prototype.getUTCMonth()", "getUTCMonth()")}} и {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}}.</p>
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setUTCFullYear()</code> попытается соответственно обновить другие параметры и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>monthValue</code> передать значение 15, год увеличится на 1 (<code>yearValue + 1</code>), а в качестве месяца будет использоваться значение 3.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setUTCFullYear" name="Example:_Using_setUTCFullYear">Пример: использование метода <code>setUTCFullYear()</code></h3>
+<h3 id="Example:_Using_setUTCFullYear">Пример: использование метода <code>setUTCFullYear()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setUTCFullYear(1997);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -64,10 +64,10 @@ theBigDay.setUTCFullYear(1997);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
  <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setutchours/index.html b/files/ru/web/javascript/reference/global_objects/date/setutchours/index.html
index 58c2c86be8..7cbf8a3fc7 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setutchours/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setutchours/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setUTCHours()</code></strong> устанавливает часы указанной даты по всемирному координированному времени и возвращает количество миллисекунд, прошедших с 1 января 1970 00:00:00 по UTC до времени, представляемого обновлённым экземпляром {{jsxref("Global_Objects/Date", "Date")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setUTCHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>hoursValue</code></dt>
  <dd>Целое число от 0 до 23, представляющее часы.</dd>
@@ -29,18 +29,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours
  <dd>Необязательный параметр. Целое число от 0 до 999, представляющее миллисекунды. Если вы определите параметр <code>msValue</code>, вы также должны определить параметры <code>minutesValue</code> и <code>secondsValue</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы не определите значения параметров <code>minutesValue</code>, <code>secondsValue</code> и <code>msValue</code>, будут использоваться значения, возвращаемые методами {{jsxref("Date.prototype.getUTCMinutes()", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} и {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p>
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setUTCHours()</code> попытается соответственно обновить другие параметры и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>secondsValue</code> передать значение 100, минуты увеличатся на 1 (<code>minutesValue + 1</code>), а в качестве секунд будет использоваться значение 40.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setUTCHours" name="Example:_Using_setUTCHours">Пример: использование метода <code>setUTCHours()</code></h3>
+<h3 id="Example:_Using_setUTCHours">Пример: использование метода <code>setUTCHours()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setUTCHours(8);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -66,10 +66,10 @@ theBigDay.setUTCHours(8);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getUTCHours()")}}</li>
  <li>{{jsxref("Date.prototype.setHours()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html
index 3afaba38f8..613b6e37be 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html
@@ -11,29 +11,29 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setUTCMilliseconds()</code></strong> устанавливает миллисекунды указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setUTCMilliseconds(<var>millisecondsValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>millisecondsValue</code></dt>
  <dd>Целое число от 0 до 999, представляющее миллисекунды.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если значение параметра <code>millisecondsValue</code> будет выходить за пределы ожидаемого диапазона, метод <code>setUTCMilliseconds()</code> попытается соответственно обновить объект {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>millisecondsValue</code> передать значение 1100, количество секунд увеличится на 1, а в качестве миллисекунд будет использоваться значение 100.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setUTCMilliseconds" name="Example:_Using_setUTCMilliseconds">Пример: использование метода <code>setUTCMilliseconds()</code></h3>
+<h3 id="Example:_Using_setUTCMilliseconds">Пример: использование метода <code>setUTCMilliseconds()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setUTCMilliseconds(500);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -59,10 +59,10 @@ theBigDay.setUTCMilliseconds(500);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li>
  <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setutcminutes/index.html b/files/ru/web/javascript/reference/global_objects/date/setutcminutes/index.html
index 581df6fb61..02ffcc5721 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setutcminutes/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setutcminutes/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setUTCMinutes()</code></strong> устанавливает минуты указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setUTCMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>minutesValue</code></dt>
  <dd>Целое число от 0 до 59, представляющее минуты.</dd>
@@ -27,18 +27,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes
  <dd>Необязательный параметр. Целое число от 0 до 999, представляющее миллисекунды. Если вы определите параметр <code>msValue</code>, вы также должны определить параметры <code>minutesValue</code> и <code>secondsValue</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы не определите значения параметров <code>secondsValue</code> и <code>msValue</code>, будут использоваться значения, возвращаемые методами {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} и {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p>
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setUTCMinutes()</code> попытается соответственно обновить другие параметры и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>secondsValue</code> передать значение 100, минуты увеличатся на 1 (<code>minutesValue + 1</code>), а в качестве секунд будет использоваться значение 40.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setUTCMinutes" name="Example:_Using_setUTCMinutes">Пример: использование метода <code>setUTCMinutes()</code></h3>
+<h3 id="Example:_Using_setUTCMinutes">Пример: использование метода <code>setUTCMinutes()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setUTCMinutes(43);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -64,10 +64,10 @@ theBigDay.setUTCMinutes(43);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li>
  <li>{{jsxref("Date.prototype.setMinutes()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setutcmonth/index.html b/files/ru/web/javascript/reference/global_objects/date/setutcmonth/index.html
index efefdd9a88..306a7bd98f 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setutcmonth/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setutcmonth/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setUTCMonth()</code></strong> устанавливает месяц указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setUTCMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>monthValue</code></dt>
  <dd>Целое число от 0 до 11, представляющее месяцы от января до декабря.</dd>
@@ -25,18 +25,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth
  <dd>Необязательный параметр. Целое число от 1 до 31, представляющее день месяца.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы не определите значения параметра <code>dayValue</code>, будет использоваться значение, возвращаемое методом {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}}.</p>
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setUTCMonth()</code> попытается соответственно обновить другой параметр и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>monthValue</code> передать значение 15, год увеличится на 1, а в качестве месяца будет использоваться значение 3.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setUTCMonth" name="Example:_Using_setUTCMonth">Пример: использование метода <code>setUTCMonth()</code></h3>
+<h3 id="Example:_Using_setUTCMonth">Пример: использование метода <code>setUTCMonth()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setUTCMonth(11);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -62,10 +62,10 @@ theBigDay.setUTCMonth(11);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li>
  <li>{{jsxref("Date.prototype.setMonth()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setutcseconds/index.html b/files/ru/web/javascript/reference/global_objects/date/setutcseconds/index.html
index e29514a6bc..47acb1af78 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setutcseconds/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setutcseconds/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>setUTCSeconds()</code></strong> устанавливает секунды указанной даты по всемирному координированному времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.setUTCSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>secondsValue</code></dt>
  <dd>Целое число от 0 до 59, представляющее количество секунд.</dd>
@@ -25,18 +25,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds
  <dd>Необязательный параметр. Число от 0 до 999, представляющее количество миллисекунд.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы не определите значения параметра <code>msValue</code>, будет использоваться значение, возвращаемое методом {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p>
 <p>Если значение определяемого параметра будет выходить за пределы ожидаемого диапазона, метод <code>setUTCSeconds()</code> попытается соответственно обновить другой параметр и информацию о дате в объекте {{jsxref("Global_Objects/Date", "Date")}}. Например, если в качестве <code>secondsValue</code> передать значение 100, минуты увеличатся на 1, а в качестве секунд будет использоваться значение 40.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setUTCSeconds" name="Example:_Using_setUTCSeconds">Пример: использование метода <code>setUTCSeconds()</code></h3>
+<h3 id="Example:_Using_setUTCSeconds">Пример: использование метода <code>setUTCSeconds()</code></h3>
 <pre class="brush: js">var theBigDay = new Date();
 theBigDay.setUTCSeconds(20);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -62,10 +62,10 @@ theBigDay.setUTCSeconds(20);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li>
  <li>{{jsxref("Date.prototype.setSeconds()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/setyear/index.html b/files/ru/web/javascript/reference/global_objects/date/setyear/index.html
index d3127e4bf0..4ba8c01fa5 100644
--- a/files/ru/web/javascript/reference/global_objects/date/setyear/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/setyear/index.html
@@ -12,28 +12,28 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear
 ---
 <div>{{JSRef("Global_Objects", "Date")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>setYear()</code></strong> устанавливает год указанной даты по местному времени. Поскольку метод <code>setYear()</code> не устанавливает полный год («проблема 2000 года»), он больше не используется и был заменён методом {{jsxref("Date.prototype.setFullYear", "setFullYear()")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.setYear(<var>yearValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>yearValue</code></dt>
  <dd>Целое число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если параметр <code>yearValue</code> является числом в диапазоне от 0 до 99 (включительно), год объекта <code>dateObj</code> устанавливается в <code>1900 + yearValue</code>. В противном случае год объекта <code>dateObj</code> устанавливается в <code>yearValue</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_setYear" name="Example:_Using_setYear">Пример: использование метода <code>setYear()</code></h3>
+<h3 id="Example:_Using_setYear">Пример: использование метода <code>setYear()</code></h3>
 
 <p>Первые две строки устанавливают год в 1996. Третья строка устанавливает год в 2000.</p>
 
@@ -44,7 +44,7 @@ theBigDay.setYear(1996);
 theBigDay.setYear(2000);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -71,13 +71,13 @@ theBigDay.setYear(2000);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Date.setYear")}}</div>
 
 <div id="compat-mobile"> </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/todatestring/index.html b/files/ru/web/javascript/reference/global_objects/date/todatestring/index.html
index abb428a780..69d5d3a2e7 100644
--- a/files/ru/web/javascript/reference/global_objects/date/todatestring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/todatestring/index.html
@@ -11,26 +11,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toDateString
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toDateString()</code></strong> возвращает часть, содержащую только дату объекта {{jsxref("Global_Objects/Date", "Date")}} в виде человеко-читаемой строки на американском английском.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.toDateString()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Экземпляры объекта {{jsxref("Global_Objects/Date", "Date")}} ссылаются на определённый момент времени. Вызов метода {{jsxref("Date.prototype.toString()", "toString()")}} вернёт дату, отформатированную в виде человеко-читаемой строки на американском английском. В <a href="/ru/docs/SpiderMonkey">SpiderMonkey</a> она состоит из части, содержащей дату (день, месяц и год) и следующей за ней части, содержащей время (часы, минуты, секунды и часовой пояс). Иногда желательно получить строку, содержащую только часть с датой; этого можно достигнуть использованием метода <code>toDateString()</code>.</p>
 <p>Метод <code>toDateString()</code> полезен тем, что совместимые движки, реализующие <a href="/ru/docs/ECMAScript">ECMA-262</a> могут давать разные строки с помощью метода {{jsxref("Date.prototype.toString()", "toString()")}} объекта {{jsxref("Global_Objects/Date", "Date")}}, поскольку формат строки зависит от реализации и простой подход с разрезанием строки на дату и время может не всегда сработать.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_A_basic_usage_of_toDateString" name="Example:_A_basic_usage_of_toDateString">Пример: базовое использование метода <code>toDateString()</code></h3>
+<h3 id="Example:_A_basic_usage_of_toDateString">Пример: базовое использование метода <code>toDateString()</code></h3>
 <pre class="brush: js">var d = new Date(1993, 6, 28, 14, 39, 7);
 
 console.log(d.toString());     // напечатает Wed Jul 28 1993 14:39:07 GMT-0600 (PDT)
 console.log(d.toDateString()); // напечатает Wed Jul 28 1993
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ console.log(d.toDateString()); // напечатает Wed Jul 28 1993
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
  <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/togmtstring/index.html b/files/ru/web/javascript/reference/global_objects/date/togmtstring/index.html
index 991c3af70e..0589c58ede 100644
--- a/files/ru/web/javascript/reference/global_objects/date/togmtstring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/togmtstring/index.html
@@ -12,18 +12,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString
 ---
 <div>{{JSRef("Global_Objects", "Date")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toGMTString()</code></strong> преобразует дату в строку, используя соглашения Среднего времени по Гринвичу (GMT) в Интернет. Точный формат значения, возвращаемого методом <code>toGMTString()</code> различается на разных платформах и браузерах, можно лишь сказать, что он представляет собой человеко-читаемую строку с датой.</p>
 <div class="note">
  <p><strong>Примечание:</strong> метод <code>toGMTString()</code> устарел и не должен использоваться. Он оставлен только для обратной совместимости; пожалуйста, используйте вместо него метод {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.toGMTString()</code></pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toGMTString" name="Example:_Using_toGMTString">Пример: использование метода <code>toGMTString()</code></h3>
+<h3 id="Example:_Using_toGMTString">Пример: использование метода <code>toGMTString()</code></h3>
 <p>В этом примере метод <code>toGMTString()</code> преобразует дату в формат GMT (UTC), используя часовой пояс операционной системы и возвращает подобную строку. Точный формат зависит от платформы.</p>
 <pre class="brush: js">var today = new Date();
 var str = today.toGMTString();  // устарел! используйте метод toUTCString()
@@ -31,7 +31,7 @@ var str = today.toGMTString();  // устарел! используйте мет
 console.log(str);               // Mon, 18 Dec 1995 17:28:35 GMT
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ console.log(str);               // Mon, 18 Dec 1995 17:28:35 GMT
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
  <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/toisostring/index.html b/files/ru/web/javascript/reference/global_objects/date/toisostring/index.html
index 5b772a9d7d..1a03837903 100644
--- a/files/ru/web/javascript/reference/global_objects/date/toisostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/toisostring/index.html
@@ -12,17 +12,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toISOString
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toISOString()</code></strong> возвращает строку в формате ISO (<a href="https://ru.wikipedia.org/wiki/ISO_8601">расширенный формат ISO 8601</a>), который можно описать следующим образом: <strong><code>YYYY-MM-DDTHH:mm:ss.sssZ</code></strong>. Часовой пояс всегда равен UTC, что обозначено суффиксом <code>"Z"</code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.toISOString()</code></pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toISOString" name="Example:_Using_toISOString">Пример: использование метода <code>toISOString()</code></h3>
+<h3 id="Example:_Using_toISOString">Пример: использование метода <code>toISOString()</code></h3>
 
 <pre class="brush: js">var today = new Date('05 October 2011 14:48 UTC');
 
@@ -31,7 +31,7 @@ console.log(today.toISOString()); // вернёт 2011-10-05T14:48:00.000Z
 
 <p>Пример выше использует разбор нестандартного строкового значения, которое может разобраться некорректно в браузерах, отличных от Firefox.</p>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод был стандартизирован в ECMA-262 5-го издания. Отсутствие этого метода в движках, которые не были обновлены для его поддержки, можно обойти следующей прокладкой:</p>
 
@@ -60,7 +60,7 @@ console.log(today.toISOString()); // вернёт 2011-10-05T14:48:00.000Z
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -82,11 +82,11 @@ console.log(today.toISOString()); // вернёт 2011-10-05T14:48:00.000Z
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/tojson/index.html b/files/ru/web/javascript/reference/global_objects/date/tojson/index.html
index 736dc4683b..ce12ccfcb8 100644
--- a/files/ru/web/javascript/reference/global_objects/date/tojson/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/tojson/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toJSON()</code></strong> возвращает представление объекта {{jsxref("Global_Objects/Date", "Date")}} в виде {{Glossary("JSON")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.toJSON()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Экземпляры объекта {{jsxref("Global_Objects/Date", "Date")}} ссылаются на определённый момент времени. Вызов метода <code>toJSON()</code> вернёт строку, отформатированную в JSON (при помощи метода {{jsxref("Date.prototype.toISOString()", "toISOString()")}}), представляющую значение объекта {{jsxref("Global_Objects/Date", "Date")}}. Этот метод, как правило, предназначен для сериализации объектов {{jsxref("Global_Objects/Date", "Date")}} в JSON.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toJSON" name="Example:_Using_toJSON">Пример: использование метода <code>toJSON()</code></h3>
+<h3 id="Example:_Using_toJSON">Пример: использование метода <code>toJSON()</code></h3>
 <pre class="brush:js">var jsonDate = (new Date()).toJSON();
 var backToDate = new Date(jsonDate);
 
 console.log('Сериализованный объект даты: ' + jsonDate);
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -50,10 +50,10 @@ console.log('Сериализованный объект даты: ' + jsonDate)
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
  <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/tolocaledatestring/index.html b/files/ru/web/javascript/reference/global_objects/date/tolocaledatestring/index.html
index f955e70d5d..bee89d40d6 100644
--- a/files/ru/web/javascript/reference/global_objects/date/tolocaledatestring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/tolocaledatestring/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toLocaleDateString()</code></strong> возвращает строку с языкозависимым представлением части с датой в этой дате. Новые аргументы <code>locales</code> и <code>options</code> позволяют приложениям определять язык, чьи соглашения по форматированию должны использоваться, а также менять поведение этого метода. В старых реализациях, игнорирующих аргументы <code>locales</code> и <code>options</code>, используемая локаль и форма возвращённой строки целиком зависит от реализации.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.toLocaleDateString([<var>locales</var> [, <var>options</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Проверьте раздел <a href="#Browser_compatibility">Совместимость с браузерами</a>, чтобы увидеть, какие браузеры поддерживают аргументы <code>locales</code> и <code>options</code>, и <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></a> для определения этой возможности.</p>
 
@@ -28,9 +28,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
 
 <p>Значением по умолчанию для каждой компоненты даты-времени является {{jsxref("Global_Objects/undefined", "undefined")}}, однако, если все свойства <code>weekday</code>, <code>year</code>, <code>month</code> и <code>day</code> равны {{jsxref("Global_Objects/undefined", "undefined")}}, то их значения предполагаются равными <code>"numeric"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toLocaleDateString" name="Example:_Using_toLocaleDateString">Пример: использование метода <code>toLocaleDateString()</code></h3>
+<h3 id="Example:_Using_toLocaleDateString">Пример: использование метода <code>toLocaleDateString()</code></h3>
 
 <p>При базовом использовании без указания локали возвращается строка, отформатированная в соответствии с локалью и опциями по умолчанию.</p>
 
@@ -42,7 +42,7 @@ console.log(date.toLocaleDateString());
 // → "12/11/2012", если код запущен с локалью en-US и часовым поясом America/Los_Angeles
 </pre>
 
-<h3 id="Example:_Checking_for_support_for_locales_and_options_arguments" name="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
+<h3 id="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
 
 <p>Аргументы <code>locales</code> и <code>options</code> поддерживаются ещё не всеми браузерами. Для проверки того, поддерживает ли их уже реализация, можно затребовать несуществующую метку языка и проверить, будет ли выброшено исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}:</p>
 
@@ -56,7 +56,7 @@ console.log(date.toLocaleDateString());
 }
 </pre>
 
-<h3 id="Example:_Using_locales" name="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
+<h3 id="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
 
 <p>Этот пример показывает некоторые локализованные форматы даты. Для получения формата языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент <code>locales</code>:</p>
 
@@ -92,7 +92,7 @@ console.log(date.toLocaleDateString(['ban', 'id']));
 // → "20/12/2012"
 </pre>
 
-<h3 id="Example:_Using_options" name="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
+<h3 id="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
 
 <p>Результат, предоставляемый методом <code>toLocaleDateString()</code>, может быть настроен с помощью аргумента <code>options</code>:</p>
 
@@ -110,11 +110,11 @@ console.log(date.toLocaleDateString('en-US', options));
 // → "Thursday, December 20, 2012, GMT"
 </pre>
 
-<h2 id="Performance" name="Performance">Производительность</h2>
+<h2 id="Performance">Производительность</h2>
 
 <p>При форматировании большого количества дат лучшим вариантом будет создание объекта {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} и использование функции, предоставляемой его свойством {{jsxref("DateTimeFormat.prototype.format", "format")}}.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -146,11 +146,11 @@ console.log(date.toLocaleDateString('en-US', options));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/tolocalestring/index.html b/files/ru/web/javascript/reference/global_objects/date/tolocalestring/index.html
index 63199d2f34..9b31f6f4e3 100644
--- a/files/ru/web/javascript/reference/global_objects/date/tolocalestring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/tolocalestring/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toLocaleString()</code></strong> возвращает строку с языкозависимым представлением даты. Новые аргументы <code>locales</code> и <code>options</code> позволяют приложениям определять язык, чьи соглашения по форматированию должны использоваться, а также менять поведение этого метода. В старых реализациях, игнорирующих аргументы <code>locales</code> и <code>options</code>, используемая локаль и форма возвращённой строки целиком зависит от реализации.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.toLocaleString([<var>locales</var>[, <var>options</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Проверьте раздел <a href="#Browser_compatibility">Совместимость с браузерами</a>, чтобы увидеть, какие браузеры поддерживают аргументы <code>locales</code> и <code>options</code>, и <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></a> для определения этой возможности.</p>
 
@@ -28,9 +28,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
 
 <p>Значением по умолчанию для каждой компоненты даты-времени является {{jsxref("Global_Objects/undefined", "undefined")}}, однако, если все свойства <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code> и <code>second</code> равны {{jsxref("Global_Objects/undefined", "undefined")}}, то их значения предполагаются равными <code>"numeric"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toLocaleString" name="Example:_Using_toLocaleString">Пример: использование метода <code>toLocaleString()</code></h3>
+<h3 id="Example:_Using_toLocaleString">Пример: использование метода <code>toLocaleString()</code></h3>
 
 <p>При базовом использовании без указания локали возвращается строка, отформатированная в соответствии с локалью и опциями по умолчанию.</p>
 
@@ -42,7 +42,7 @@ console.log(date.toLocaleString());
 // → "12/11/2012, 7:00:00 PM", если код запущен с локалью en-US и часовым поясом America/Los_Angeles
 </pre>
 
-<h3 id="Example:_Checking_for_support_for_locales_and_options_arguments" name="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
+<h3 id="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
 
 <p>Аргументы <code>locales</code> и <code>options</code> поддерживаются ещё не всеми браузерами. Для проверки того, поддерживает ли их уже реализация, можно затребовать несуществующую метку языка и проверить, будет ли выброшено исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}:</p>
 
@@ -56,7 +56,7 @@ console.log(date.toLocaleString());
 }
 </pre>
 
-<h3 id="Example:_Using_locales" name="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
+<h3 id="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
 
 <p>Этот пример показывает некоторые локализованные форматы даты и времени. Для получения формата языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент <code>locales</code>:</p>
 
@@ -95,7 +95,7 @@ console.log(date.toLocaleString(['ban', 'id']));
 // → "20/12/2012 11.00.00"
 </pre>
 
-<h3 id="Example:_Using_options" name="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
+<h3 id="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
 
 <p>Результат, предоставляемый методом <code>toLocaleString()</code>, может быть настроен с помощью аргумента <code>options</code>:</p>
 
@@ -117,11 +117,11 @@ console.log(date.toLocaleString('en-US', { hour12: false }));
 // → "12/19/2012, 19:00:00"
 </pre>
 
-<h2 id="Performance" name="Performance">Производительность</h2>
+<h2 id="Performance">Производительность</h2>
 
 <p>При форматировании большого количества дат лучшим вариантом будет создание объекта {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} и использование функции, предоставляемой его свойством {{jsxref("DateTimeFormat.prototype.format", "format")}}.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -153,11 +153,11 @@ console.log(date.toLocaleString('en-US', { hour12: false }));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/tolocaletimestring/index.html b/files/ru/web/javascript/reference/global_objects/date/tolocaletimestring/index.html
index b228ac6197..1e8128bd75 100644
--- a/files/ru/web/javascript/reference/global_objects/date/tolocaletimestring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/tolocaletimestring/index.html
@@ -12,20 +12,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toLocaleTimeString()</code></strong> возвращает строку с языкозависимым представлением части со временем в этой дате. Новые аргументы <code>locales</code> и <code>options</code> позволяют приложениям определять язык, чьи соглашения по форматированию должны использоваться, а также менять поведение этого метода. В старых реализациях, игнорирующих аргументы <code>locales</code> и <code>options</code>, используемая локаль и форма возвращённой строки целиком зависит от реализации.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.toLocaleTimeString([<var>locales</var>[, <var>options</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Проверьте раздел <a href="#Browser_compatibility">Совместимость с браузерами</a>, чтобы увидеть, какие браузеры поддерживают аргументы <code>locales</code> и <code>options</code>, и <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></a> для определения этой возможности.</p>
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div>
 <p>Значением по умолчанию для каждой компоненты даты-времени является {{jsxref("Global_Objects/undefined", "undefined")}}, однако, если все свойства <code>hour</code>, <code>minute</code> и <code>second</code> равны {{jsxref("Global_Objects/undefined", "undefined")}}, то их значения предполагаются равными <code>"numeric"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toLocaleTimeString" name="Example:_Using_toLocaleTimeString">Пример: использование метода <code>toLocaleTimeString()</code></h3>
+<h3 id="Example:_Using_toLocaleTimeString">Пример: использование метода <code>toLocaleTimeString()</code></h3>
 <p>При базовом использовании без указания локали возвращается строка, отформатированная в соответствии с локалью и опциями по умолчанию.</p>
 <pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
 
@@ -35,7 +35,7 @@ console.log(date.toLocaleTimeString());
 // → "7:00:00 PM", если код запущен с локалью en-US и часовым поясом America/Los_Angeles
 </pre>
 
-<h3 id="Example:_Checking_for_support_for_locales_and_options_arguments" name="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
+<h3 id="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
 <p>Аргументы <code>locales</code> и <code>options</code> поддерживаются ещё не всеми браузерами. Для проверки того, поддерживает ли их уже реализация, можно затребовать несуществующую метку языка и проверить, будет ли выброшено исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}:</p>
 <pre class="brush: js">function toLocaleTimeStringSupportsLocales() {
   try {
@@ -47,7 +47,7 @@ console.log(date.toLocaleTimeString());
 }
 </pre>
 
-<h3 id="Example:_Using_locales" name="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
+<h3 id="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
 <p>Этот пример показывает некоторые локализованные форматы времени. Для получения формата языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент <code>locales</code>:</p>
 <pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
@@ -76,7 +76,7 @@ console.log(date.toLocaleTimeString(['ban', 'id']));
 // → "11.00.00"
 </pre>
 
-<h3 id="Example:_Using_options" name="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
+<h3 id="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
 <p>Результат, предоставляемый методом <code>toLocaleTimeString()</code>, может быть настроен с помощью аргумента <code>options</code>:</p>
 <pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
@@ -90,10 +90,10 @@ console.log(date.toLocaleTimeString('en-US', { hour12: false }));
 // → "19:00:00"
 </pre>
 
-<h2 id="Performance" name="Performance">Производительность</h2>
+<h2 id="Performance">Производительность</h2>
 <p>При форматировании большого количества дат лучшим вариантом будет создание объекта {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} и использование функции, предоставляемой его свойством {{jsxref("DateTimeFormat.prototype.format", "format")}}.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -124,10 +124,10 @@ console.log(date.toLocaleTimeString('en-US', { hour12: false }));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
  <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/tosource/index.html b/files/ru/web/javascript/reference/global_objects/date/tosource/index.html
index 03a515cf26..d47ac793f4 100644
--- a/files/ru/web/javascript/reference/global_objects/date/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/tosource/index.html
@@ -12,17 +12,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toSource
 ---
 <div>{{JSRef("Global_Objects", "Date")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toSource()</code></strong> возвращает строковое представление исходного кода объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.toSource()
 Date.toSource()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toSource()</code> возвращает следующие значения:</p>
 <ul>
  <li>Для встроенного объекта {{jsxref("Global_Objects/Date", "Date")}} метод <code>toSource()</code> возвращает следующую строку, указывающую, что исходный код объекта недоступен:
@@ -35,13 +35,13 @@ Date.toSource()</code></pre>
 </ul>
 <p>Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/date/tostring/index.html b/files/ru/web/javascript/reference/global_objects/date/tostring/index.html
index 5ca2259a30..9b94f9b774 100644
--- a/files/ru/web/javascript/reference/global_objects/date/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/tostring/index.html
@@ -11,30 +11,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toString()</code></strong> возвращает строковое представление указанного объекта {{jsxref("Global_Objects/Date", "Date")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.toString()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Объект {{jsxref("Global_Objects/Date", "Date")}} переопределяет метод <code>toString()</code>, унаследованный из объекта {{jsxref("Global_Objects/Object", "Object")}}; он не наследует метод {{jsxref("Object.prototype.toString()")}}. Для объектов {{jsxref("Global_Objects/Date", "Date")}} метод <code>toString()</code> возвращает строковое представление объекта.</p>
 <p>Метод <code>toString()</code> всегда возвращает строковое представление даты на американском английском.</p>
 <p>JavaScript вызывает метод <code>toString()</code> автоматически, когда дата представляется как текст, или когда дата участвует в конкатенации строк.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toString" name="Example:_Using_toString">Пример: использование метода <code>toString()</code></h3>
+<h3 id="Example:_Using_toString">Пример: использование метода <code>toString()</code></h3>
 <p>В следующем примере переменной <code>myVar</code> присваивается значение, возвращённое методом <code>toString()</code> объекта {{jsxref("Global_Objects/Date", "Date")}}:</p>
 <pre class="brush: js">var x = new Date();
 myVar = x.toString(); // присваивает переменной myVar значение вроде:
 // Mon Sep 28 1998 14:36:22 GMT-0700 (Pacific Daylight Time)
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -60,10 +60,10 @@ myVar = x.toString(); // присваивает переменной myVar зн
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toString()")}}</li>
  <li>{{jsxref("Date.prototype.toDateString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/totimestring/index.html b/files/ru/web/javascript/reference/global_objects/date/totimestring/index.html
index be296b7110..744a095ffd 100644
--- a/files/ru/web/javascript/reference/global_objects/date/totimestring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/totimestring/index.html
@@ -11,23 +11,23 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toTimeString
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toTimeString()</code></strong> возвращает часть, содержащую только время объекта {{jsxref("Global_Objects/Date", "Date")}} в виде человеко-читаемой строки на американском английском.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>dateObj</var>.toTimeString()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Экземпляры объекта {{jsxref("Global_Objects/Date", "Date")}} ссылаются на определённый момент времени. Вызов метода {{jsxref("Date.prototype.toString()", "toString()")}} вернёт дату, отформатированную в виде человеко-читаемой строки на американском английском. В <a href="/ru/docs/SpiderMonkey">SpiderMonkey</a> она состоит из части, содержащей дату (день, месяц и год) и следующей за ней части, содержащей время (часы, минуты, секунды и часовой пояс). Иногда желательно получить строку, содержащую только часть со временем; этого можно достигнуть использованием метода <code>toTimeString()</code>.</p>
 
 <p>Метод <code>toTimeString()</code> полезен тем, что совместимые движки, реализующие <a href="/ru/docs/ECMAScript">ECMA-262</a> могут давать разные строки с помощью метода {{jsxref("Date.prototype.toString()", "toString()")}} объекта {{jsxref("Global_Objects/Date", "Date")}}, поскольку формат строки зависит от реализации и простой подход с разрезанием строки на дату и время может не всегда сработать.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_A_basic_usage_of_toTimeString" name="Example:_A_basic_usage_of_toTimeString">Пример: базовое использование метода <code>toTimeString()</code></h3>
+<h3 id="Example_A_basic_usage_of_toTimeString">Пример: базовое использование метода <code>toTimeString()</code></h3>
 
 <pre class="brush: js">var d = new Date(1993, 6, 28, 14, 39, 7);
 
@@ -35,7 +35,7 @@ console.log(d.toString());     // напечатает Wed Jul 28 1993 14:39:07
 console.log(d.toTimeString()); // напечатает 14:39:07 GMT-0600 (PDT)
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -62,10 +62,10 @@ console.log(d.toTimeString()); // напечатает 14:39:07 GMT-0600 (PDT)
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat("javascript.builtins.Date.toTimeString")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/toutcstring/index.html b/files/ru/web/javascript/reference/global_objects/date/toutcstring/index.html
index d79efab916..d92f8e1a09 100644
--- a/files/ru/web/javascript/reference/global_objects/date/toutcstring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/toutcstring/index.html
@@ -11,27 +11,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/toUTCString
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toUTCString()</code></strong> преобразует дату в строку, используя часовой пояс UTC.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.toUTCString()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Значение, возвращаемое методом <code>toUTCString()</code>, является человеко-читаемой строкой в часовом поясе <abbr title="Всемирное координированное время">UTC</abbr>. Формат возвращаемого значения зависит от платформы. Наиболее распространённым значением является форматированная по RFC-1123 временная метка, которая является немного обновлённой версией временной метки RFC-822.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toUTCString" name="Example:_Using_toUTCString">Пример: использование метода <code>toUTCString()</code></h3>
+<h3 id="Example:_Using_toUTCString">Пример: использование метода <code>toUTCString()</code></h3>
 <pre class="brush: js">var today = new Date();
 var UTCstring = today.toUTCString();
 // Mon, 03 Jul 2006 21:44:38 GMT
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ var UTCstring = today.toUTCString();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
  <li>{{jsxref("Date.prototype.toDateString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/utc/index.html b/files/ru/web/javascript/reference/global_objects/date/utc/index.html
index b0678c5418..752b4193c9 100644
--- a/files/ru/web/javascript/reference/global_objects/date/utc/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/utc/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC
 
 
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <p> <strong>Начиная с  ECMAScript 2017:</strong></p>
 
@@ -26,7 +26,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC
 
 <pre class="syntaxbox"><code>Date.UTC(<var>year</var>, <var>month</var>[, <var>day</var>[, <var>hour</var>[, <var>minute</var>[, <var>second</var>[, <var>millisecond</var>]]]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>year</code></dt>
@@ -66,16 +66,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC
 
 <p>Поскольку метод <code>UTC()</code> является статическим методом объекта {{jsxref("Global_Objects/Date", "Date")}}, вы всегда должны использовать его как <code>Date.UTC()</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_Date.UTC" name="Example:_Using_Date.UTC">Пример: использование <code>Date.UTC()</code></h3>
+<h3 id="Example_Using_Date.UTC">Пример: использование <code>Date.UTC()</code></h3>
 
 <p>Следующее выражение создаёт объект {{jsxref("Global_Objects/Date", "Date")}}, используя всемирное время вместо местного:</p>
 
 <pre class="brush:js">var utcDate = new Date(Date.UTC(2018, 11, 1, 0, 0, 0));
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -88,7 +88,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 
@@ -96,7 +96,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC
 <p>{{Compat("javascript.builtins.Date.UTC")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Примечание о совместимости</h2>
+<h2 id="See_also">Примечание о совместимости</h2>
 
 <h3 id="Date.UTC_с_менее_чем_двумя_аргументами">Date.UTC() с менее чем двумя аргументами</h3>
 
@@ -115,7 +115,7 @@ Date.UTC(1);
 // Edge: NaN
 </pre>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Date.parse()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/date/valueof/index.html b/files/ru/web/javascript/reference/global_objects/date/valueof/index.html
index d60f24d261..531b53a394 100644
--- a/files/ru/web/javascript/reference/global_objects/date/valueof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/date/valueof/index.html
@@ -11,28 +11,28 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf
 ---
 <div>{{JSRef("Global_Objects", "Date")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>valueOf()</code></strong> возвращает примитивное значение объекта {{jsxref("Global_Objects/Date", "Date")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateObj</var>.valueOf()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>valueOf()</code> возвращает примитивное значение объекта {{jsxref("Global_Objects/Date", "Date")}} в виде числового типа данных — количества миллисекунд, прошедших с полуночи 01 января 1970 по UTC.</p>
 <p>Этот метод полностью функционально эквивалентен методу {{jsxref("Date.prototype.getTime()")}}.</p>
 <p>Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_valueOf" name="Example:_Using_valueOf">Пример: использование метода <code>valueOf()</code></h3>
+<h3 id="Example:_Using_valueOf">Пример: использование метода <code>valueOf()</code></h3>
 <pre class="brush: js">var x = new Date(56, 6, 17);
 var myVar = x.valueOf();      // присваивает -424713600000 переменной myVar
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -58,10 +58,10 @@ var myVar = x.valueOf();      // присваивает -424713600000 перем
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.valueOf()")}}</li>
  <li>{{jsxref("Date.prototype.getTime()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/decodeuri/index.html b/files/ru/web/javascript/reference/global_objects/decodeuri/index.html
index 91fd12c005..50102c65af 100644
--- a/files/ru/web/javascript/reference/global_objects/decodeuri/index.html
+++ b/files/ru/web/javascript/reference/global_objects/decodeuri/index.html
@@ -20,11 +20,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/decodeURI
 
 <p> </p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>decodeURI(<em>encodedURI</em>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>encodedURI</code></dt>
@@ -43,7 +43,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/decodeURI
 
 <p> </p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Заменяет каждую управляющую последовательность в закодированном URI соответствующим символом. Не декодирует последовательности, которые невозможно сформировать с помощью {{jsxref("encodeURI")}}. Символ "#" декодированию не подвергается.</p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/decodeuricomponent/index.html b/files/ru/web/javascript/reference/global_objects/decodeuricomponent/index.html
index 98b6336f42..c462da5d97 100644
--- a/files/ru/web/javascript/reference/global_objects/decodeuricomponent/index.html
+++ b/files/ru/web/javascript/reference/global_objects/decodeuricomponent/index.html
@@ -19,11 +19,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent
 <p> </p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>decodeURIComponent(<em>encodedURI</em>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>encodedURI</code></dt>
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent
 
 <p>При неправильном использовании выдаёт исключение {{jsxref("URIError")}} ("неверный формат последовательности URI").</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Заменяет каждую управляющую последовательность в закодированном компоненте URI соответствующим ей символом.</p>
 
@@ -98,7 +98,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent
 
 <p>{{Compat("javascript.builtins.decodeURIComponent")}}</p>
 
-<h2 id="See_Also" name="See_Also">Смотрите также</h2>
+<h2 id="See_Also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("decodeURI")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/encodeuri/index.html b/files/ru/web/javascript/reference/global_objects/encodeuri/index.html
index 758138a57b..432d3ee015 100644
--- a/files/ru/web/javascript/reference/global_objects/encodeuri/index.html
+++ b/files/ru/web/javascript/reference/global_objects/encodeuri/index.html
@@ -26,11 +26,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI
 
 
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>encodeURI(<em>URI</em>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code><font face="Consolas, Liberation Mono, Courier, monospace">URI</font></code></dt>
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI
  </dt>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Предполагается, что URI является полным URI, поэтому метод не кодирует зарезервированные символы, имеющие особое значение в URI.</p>
 
@@ -123,7 +123,7 @@ console.log(encodeURIComponent('\uDFFF'));</code></pre>
 
 
 
-<h2 id="See_Also" name="See_Also">Смотрите также</h2>
+<h2 id="See_Also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("decodeURI", "decodeURI()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/columnnumber/index.html b/files/ru/web/javascript/reference/global_objects/error/columnnumber/index.html
index 78b746343e..b45aeafb2c 100644
--- a/files/ru/web/javascript/reference/global_objects/error/columnnumber/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/columnnumber/index.html
@@ -11,21 +11,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/columnNumber
 ---
 <div>
  {{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <code><strong>columnNumber</strong></code> содержит номер колонки в строке файла, в котором возникла эта ошибка.</p>
-<h2 id="Examples" name="Examples">Примеры</h2>
-<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Пример: использование <code>columnNumber</code></h3>
+<h2 id="Examples">Примеры</h2>
+<h3 id="Example:_Throwing_a_custom_error">Пример: использование <code>columnNumber</code></h3>
 <pre class="brush: js">var e = new Error('Невозможно разобрать входные данные');
 throw e;
 console.log(e.columnNumber) // 0
 </pre>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации. Не стандартно.</p>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
  <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/filename/index.html b/files/ru/web/javascript/reference/global_objects/error/filename/index.html
index 41e9a3e944..b09c176c54 100644
--- a/files/ru/web/javascript/reference/global_objects/error/filename/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/filename/index.html
@@ -11,23 +11,23 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/fileName
 ---
 <div>
  {{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <code><strong>fileName</strong></code> содержит путь к файлу, в котором возникла эта ошибка.</p>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Это нестандартное свойство содержит путь к файлу, в котором возникла эта ошибка. Если доступ к нему получен в контексте отладчика, например, Инструментов разработчика Firefox, вернётся строка «debugger eval code».</p>
-<h2 id="Examples" name="Examples">Примеры</h2>
-<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Пример: использование <code>fileName</code></h3>
+<h2 id="Examples">Примеры</h2>
+<h3 id="Example:_Throwing_a_custom_error">Пример: использование <code>fileName</code></h3>
 <pre class="brush: js">var e = new Error('Невозможно разобрать входные данные');
 throw e;
 // e.fileName может выглядеть так "file:///C:/example.html"
 </pre>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации. Не стандартно.</p>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
  <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/index.html b/files/ru/web/javascript/reference/global_objects/error/index.html
index cba5cf1c52..67ccba0b6b 100644
--- a/files/ru/web/javascript/reference/global_objects/error/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/index.html
@@ -12,11 +12,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error
 
 <p>Конструктор <strong><code>Error</code></strong> создаёт объект ошибки. Экземпляры объекта <code>Error</code> выбрасываются при возникновении ошибок во время выполнения. Объект <code>Error</code> также может использоваться в качестве базового для пользовательских исключений. Смотрите ниже стандартные встроенные типы ошибок.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>message </code> <code>{{optional_inline()}}</code></dt>
@@ -27,7 +27,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error
  <dd>Значение свойства <code>lineNumber</code> созданного объекта <code>Error</code>. Значением по умолчанию является номер строки, содержащей вызов конструктора <code>Error()</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Во время выполнения кода ошибки приводят к созданию и выбрасыванию новых объектов <code>Error</code>.</p>
 
@@ -46,7 +46,7 @@ const y = new Error('I was constructed via the "new" keyword!');</code></pre>
 
 <p> </p>
 
-<h3 id="Error_types" name="Error_types"><a id="Error_types" name="Error_types">Типы ошибок</a></h3>
+<h3 id="Error_types" name="Error_types"><a id="Error_types">Типы ошибок</a></h3>
 
 <p>Кроме общего конструктора <code>Error</code>, в JavaScript существует ещё семь других основных конструкторов ошибок. По обработке исключений смотрите раздел <a href="/ru/docs/Web/JavaScript/Guide/Statements#Exception_Handling_Statements">Выражения обработки исключений</a>.</p>
 
@@ -67,32 +67,32 @@ const y = new Error('I was constructed via the "new" keyword!');</code></pre>
  <dd>Создаёт экземпляр, представляющий ошибку, возникающую при передаче в функции {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} или {{jsxref("Global_Objects/decodeURI", "decodeURI()")}} недопустимых параметров.</dd>
 </dl>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("Error.prototype")}}</dt>
  <dd>Позволяет добавлять свойства в экземпляры объекта <code>Error</code>.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <p>Глобальный объект <code>Error</code> не содержит собственных методов, однако, он наследует некоторые методы из цепочки прототипов.</p>
 
-<h2 id="Error_instances" name="Error_instances">Экземпляры объекта <code>Error</code></h2>
+<h2 id="Error_instances">Экземпляры объекта <code>Error</code></h2>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Description')}}</div>
 
-<h3 id="Properties_2" name="Properties_2">Свойства</h3>
+<h3 id="Properties_2">Свойства</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_2" name="Methods_2">Методы</h3>
+<h3 id="Methods_2">Методы</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Throwing_a_generic_error" name="Example:_Throwing_a_generic_error">Пример: выбрасывание обычной ошибки</h3>
+<h3 id="Example:_Throwing_a_generic_error">Пример: выбрасывание обычной ошибки</h3>
 
 <p>Обычно, вы создаёте объект <code>Error</code> с намерением возбудить ошибку с помощью ключевого слова {{jsxref("Statements/throw", "throw")}}. Вы можете обработать ошибку с помощью конструкции {{jsxref("Statements/try...catch", "try...catch")}}:</p>
 
@@ -103,7 +103,7 @@ const y = new Error('I was constructed via the "new" keyword!');</code></pre>
 }
 </pre>
 
-<h3 id="Example:_Handling_a_specific_error" name="Example:_Handling_a_specific_error">Пример: обработка ошибки конкретного типа</h3>
+<h3 id="Example:_Handling_a_specific_error">Пример: обработка ошибки конкретного типа</h3>
 
 <p><span class="comment">Возможно, это следует удалить</span> вы можете обрабатывать только какой-то определённый вид ошибок, проверяя тип ошибки в свойстве {{jsxref("Object.prototype.constructor", "constructor")}} или, если вы пишете для современных движков JavaScript, с помощью ключевого слова {{jsxref("Operators/instanceof", "instanceof")}}:</p>
 
@@ -119,7 +119,7 @@ const y = new Error('I was constructed via the "new" keyword!');</code></pre>
 }
 </pre>
 
-<h3 id="Example:_Custom_Error_Types" name="Example:_Custom_Error_Types">Пример: пользовательские типы ошибок</h3>
+<h3 id="Example:_Custom_Error_Types">Пример: пользовательские типы ошибок</h3>
 
 <p>Вы можете захотеть определить свои собственные типы ошибок, унаследованные от <code>Error</code>, что бы иметь возможность писать <code>throw new MyError()</code> и использовать <code>instanceof MyError</code> для проверки вида ошибки в обработчике исключений. Ниже продемонстрирован общий подход к выполнению этой задачи.</p>
 
@@ -153,7 +153,7 @@ try {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -185,7 +185,7 @@ try {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p> </p>
 
@@ -195,7 +195,7 @@ try {
 
 <div> </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Error.prototype")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/linenumber/index.html b/files/ru/web/javascript/reference/global_objects/error/linenumber/index.html
index c74d39620f..be33d32376 100644
--- a/files/ru/web/javascript/reference/global_objects/error/linenumber/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/linenumber/index.html
@@ -12,18 +12,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/lineNumber
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <code><strong>lineNumber</strong></code> содержит номер строки в файле, в котором возникла эта ошибка.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Пример: использование <code>lineNumber</code></h3>
+<h3 id="Example:_Throwing_a_custom_error">Пример: использование <code>lineNumber</code></h3>
 <pre class="brush: js">var e = new Error('Невозможно разобрать входные данные');
 throw e;
 console.log(e.lineNumber) // 2
 </pre>
 
-<h3 id="Example:_Alternative_example_using_error_event" name="Example:_Alternative_example_using_error_event">Пример: альтернативный пример с использованием события <code>error</code></h3>
+<h3 id="Example:_Alternative_example_using_error_event">Пример: альтернативный пример с использованием события <code>error</code></h3>
 <pre class="brush: js">window.addEventListener('error', function(e) {
   console.log(e.lineno); // 5
 });
@@ -32,13 +32,13 @@ throw e;
 </pre>
 <p>Это стандарт и он поддерживается в Chrome, Firefox и, вероятно, много где ещё.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации. Не стандартно.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li>
  <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/message/index.html b/files/ru/web/javascript/reference/global_objects/error/message/index.html
index 36a7bafae4..f33ca9c121 100644
--- a/files/ru/web/javascript/reference/global_objects/error/message/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/message/index.html
@@ -10,22 +10,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/message
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <code><strong>message</strong></code> представляет человеко-читаемое описание ошибки.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Это свойство содержит краткое описание ошибки, если оно доступно или было установлено. <a href="/ru/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> широко использует свойство <code>message</code> для исключений. Свойство <code>message</code> в сочетании со свойством {{jsxref("Error.prototype.name", "name")}} используется методом {{jsxref("Error.prototype.toString()")}} для создания строкового представления ошибки.</p>
 <p>По умолчанию, свойство <code>message</code> является пустой строкой, но это поведение может быть переопределено для экземпляра путём указания сообщения первым аргументом в конструкторе объекта {{jsxref("Global_Objects/Error", "Error")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Пример: выбрасывание собственной ошибки</h3>
+<h3 id="Example:_Throwing_a_custom_error">Пример: выбрасывание собственной ошибки</h3>
 <pre class="brush: js">var e = new Error('Невозможно разобрать входные данные');
 // e.message равно 'Невозможно разобрать входные данные'
 throw e;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -51,10 +51,10 @@ throw e;
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error.prototype.name")}}</li>
  <li>{{jsxref("Error.prototype.toString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/name/index.html b/files/ru/web/javascript/reference/global_objects/error/name/index.html
index 3df5df4bbd..1d4bc5c75f 100644
--- a/files/ru/web/javascript/reference/global_objects/error/name/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/name/index.html
@@ -10,15 +10,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/name
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <code><strong>name</strong></code> представляет имя типа ошибки. Начальное значение равно строке <code>"Error"</code>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>По умолчанию, экземпляры {{jsxref("Error")}} имеют имя <code>"Error"</code>. Свойство <code>name</code>, вместе со свойством {{jsxref("Error.prototype.message", "message")}}, используется методом {{jsxref("Error.prototype.toString()")}} для создания строкового представления ошибки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Пример: выбрасывание собственной ошибки</h3>
+<h3 id="Example:_Throwing_a_custom_error">Пример: выбрасывание собственной ошибки</h3>
 <pre class="brush: js">var e = new Error('Неверные входные данные'); // e.name равно 'Error'
 
 e.name = 'ParseError';
@@ -26,7 +26,7 @@ throw e;
 // e.toString() вернёт 'ParseError: Неверные входные данные'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -52,10 +52,10 @@ throw e;
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error.prototype.message")}}</li>
  <li>{{jsxref("Error.prototype.toString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/stack/index.html b/files/ru/web/javascript/reference/global_objects/error/stack/index.html
index d28040716c..a3cedd7c38 100644
--- a/files/ru/web/javascript/reference/global_objects/error/stack/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/stack/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/Stack
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Нестандартное свойство <strong><code>stack</code></strong> объекта {{jsxref("Error")}} возвращает трассировку стека вызываемых функций в порядке их выполнения, вместе с номерами строк, именами файлов и аргументами. Строка со стеком заполняется от самых недавних вызовов до вызова из глобальной области видимости.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Каждый шаг находится на отдельной строке; первая часть строки содержит имя функции (если это не вызов из глобальной области видимости), затем знак собаки (<code>@</code>), местоположение файла (кроме случая, когда функция является конструктором ошибки, которую она выбрасывает), двоеточие и, если есть местоположение файла, номер строки. Обратите внимание, что объект {{jsxref("Error")}} также обладает свойствами <code>fileName</code>, <code>lineNumber</code> и <code>columnNumber</code>, позволяющими извлечь имя файла, номер строки и столбца из выброшенной ошибки (но только самой ошибки, а не всего стека вызовов).</p>
 <p>Обратите внимание, что такой формат используется в Firefox. Нет никакого «стандартного формата». Однако, Safari 6+ и Opera 12- используют очень похожий формат. С другой стороны, браузеры, использующие движок JavaScript V8 (например, Chrome, Opera 15+, Браузер Android) и IE10+, используют другой формат (смотрите эту статью по <a class="external" href="http://msdn.microsoft.com/ru-ru/library/windows/apps/hh699850.aspx"><code>error.stack</code></a> в MSDN).</p>
 <p><strong>Значения аргументов в стеке</strong>: до Firefox 14 ({{bug("744842")}}) за именем функции и прямо перед знаком собаки (<code>@</code>) в круглых скобках следовали значения аргументов, преобразованные в строки. Хотя объекты (или массивы и прочее) преобразовывались в форму <code>"[object Object]"</code>, и, таким образом, невозможно было узнать их содержимое, скалярные значения могли быть извлечены (это всё ещё можно использовать в Firefox 14 — однако проще для получения аргументов использовать <code>arguments.callee.caller.arguments</code>, а для получения имени функции — <code>arguments.callee.caller.name</code>). Значение <code>"undefined"</code> показывалось как <code>"(void 0)"</code>. Обратите внимание, что если строковые аргументы содержали значения, включающие символы <code>"@"</code>, <code>"("</code>, <code>")"</code> (или если они включали имена файлов), вам не так то просто было разбить строку на составные части. Таким образом, в Firefox 14 и более поздних версиях это перестало быть проблемой.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <p>Следующая разметка HTML демонстрирует использование свойства <code>stack</code>.</p>
 <pre class="brush: html">&lt;!DOCTYPE HTML&gt;
 &lt;meta charset="UTF-8"&gt;
@@ -62,7 +62,7 @@ b(3,4,"\n\n",(void 0),[object Object])@file:///C:/example.html:16
 a("первый вызов, первый аргумент")@file:///C:/example.html:19
 @file:///C:/example.html:21</samp></pre>
 
-<h3 id="Stack_of_eval'ed_code" name="Stack_of_eval'ed_code">Стек кода в функции <code>eval()</code></h3>
+<h3 id="Stack_of_eval'ed_code">Стек кода в функции <code>eval()</code></h3>
 <p>Начиная с Firefox 30 {{geckoRelease("30")}}, стек вызовов кода в вызовах <code>Function()</code> и <code>eval()</code> даёт более подробную информацию о номере строки и колонки внутри этих вызовов. Вызовы <code>Function</code> обозначаются <code>"&gt; Function"</code>, а вызовы <code>eval()</code> обозначаются <code>"&gt; eval"</code>. Смотрите {{bug("332176")}}.</p>
 <pre class="brush: js">try {
   new Function('throw new Error()')();
@@ -86,13 +86,13 @@ try {
 </pre>
 <p>Также для именования исходного кода в функции <code>eval()</code> вы можете использовать директиву <code>//# sourceURL</code>. Смотрите раздел <a href="/ru/docs/Tools/Debugger/How_to/Debug_eval_sources">Отладка исходных кодов в функции <code>eval()</code></a> в документации по <a href="/ru/docs/Tools/Debugger">отладчику</a>, а также эту <a href="http://fitzgeraldnick.com/weblog/59/">запись в блоге</a> (на английском).</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации. Не стандартно.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li><a href="/ru/docs/Components.stack">Components.stack</a></li>
  <li>Внешние проекты: <a class="link-https" href="https://github.com/csnover/TraceKit/">TraceKit</a> и <a class="link-https" href="https://github.com/eriwen/javascript-stacktrace">javascript-stacktrace</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/tosource/index.html b/files/ru/web/javascript/reference/global_objects/error/tosource/index.html
index e269233bd1..cf5a281500 100644
--- a/files/ru/web/javascript/reference/global_objects/error/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/tosource/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>toSource()</strong></code> возвращает код, вычисление которого приведёт к этой же ошибке.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>e</var>.toSource()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Вызов метода <code>toSource</code> на экземпляре класса {{jsxref("Error")}} (включая <i><a href="/ru/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types">родные ошибки</a></i>) вернёт строку, содержащую исходный код ошибки. Эта строка может быть выполнена для создания (приблизительно) эквивалентного объекта. Естественно, строка, содержащая исходный код, следует структуре конструктора объекта {{jsxref("Error")}}. Например:</p>
 <pre class="brush: js">(new <i>name</i>(<i>message</i>, <i>fileName</i>, <i>lineNumber</i>))
 </pre>
@@ -26,13 +26,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource
  <p><strong>Обратите внимание:</strong> имейте в виду, что свойства, используемые методом <code>toSource</code> при создании строки, изменяемы и могут неточно отражать функцию, с помощью которой создан экземпляр ошибки, или имя файла, или номер строки, где возникла ошибка.</p>
 </div>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error.prototype.fileName")}}</li>
  <li>{{jsxref("Error.prototype.lineNumber")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/error/tostring/index.html b/files/ru/web/javascript/reference/global_objects/error/tostring/index.html
index 005455ba0a..c6a836dc25 100644
--- a/files/ru/web/javascript/reference/global_objects/error/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/error/tostring/index.html
@@ -10,11 +10,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString
 ---
 <div>
  {{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>toString()</strong></code> возвращает строку, представляющую указанный объект {{jsxref("Error")}}.</p>
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>e</var>.toString()</code></pre>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Объект {{jsxref("Error")}} переопределяет метод {{jsxref("Object.prototype.toString()")}}, унаследованный всеми объектами. Его семантика следующая (предполагается, что объекты {{jsxref("Object")}} и {{jsxref("String")}} имеют свои изначальные значения):</p>
 <pre class="brush: js">Error.prototype.toString = function() {
   'use strict';
@@ -40,7 +40,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString
   return name + ': ' + msg;
 };
 </pre>
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">var e = new Error('непоправимая ошибка');
 print(e.toString()); // 'Error: непоправимая ошибка'
 
@@ -56,7 +56,7 @@ print(e.toString()); // 'Error'
 e.name = 'привет';
 print(e.toString()); // 'привет'
 </pre>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -81,11 +81,11 @@ print(e.toString()); // 'привет'
   </tr>
  </tbody>
 </table>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error.prototype.toSource()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/eval/index.html b/files/ru/web/javascript/reference/global_objects/eval/index.html
index 3c0ed3ae24..3ec9ba9199 100644
--- a/files/ru/web/javascript/reference/global_objects/eval/index.html
+++ b/files/ru/web/javascript/reference/global_objects/eval/index.html
@@ -66,7 +66,7 @@ eval(expression.toString());
 }
 </pre>
 
-<h2 id="Не_используйте_eval_без_необходимости!"><a name="dont-use-it"><code><font face="Open Sans, Arial, sans-serif">Н</font>е используйте eval без необходимости!</code></a></h2>
+<h2 id="Не_используйте_eval_без_необходимости!"><a><code><font face="Open Sans, Arial, sans-serif">Н</font>е используйте eval без необходимости!</code></a></h2>
 
 <p><code>eval()</code> - опасная функция, которая выполняет код, проходящий со всеми привилегиями вызывателя. Если вы запускаете <code>eval()</code> со строкой, на которую могут влиять злоумышленники, то вы можете запустить вредоносный код на устройство пользователя с правами вашей веб-страницы/расширения. Наиболее важно, код третьей стороны может видеть область видимости, в которой был вызван <code>eval()</code>, что может может привести к атакам, похожим на {{jsxref("Global_Objects/Function", "Function")}}.</p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/evalerror/index.html b/files/ru/web/javascript/reference/global_objects/evalerror/index.html
index 50b418b265..7ea50c963a 100644
--- a/files/ru/web/javascript/reference/global_objects/evalerror/index.html
+++ b/files/ru/web/javascript/reference/global_objects/evalerror/index.html
@@ -10,13 +10,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Объект <strong><code>EvalError</code></strong> представляет ошибку, возникающую в глобальной функции {{jsxref("Global_objects/eval()", "eval()")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>new EvalError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>message</code></dt>
  <dd>Необязательный параметр. Человеко-читаемое описание ошибки.</dd>
@@ -26,30 +26,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
  <dd>Необязательный параметр. Номер строки кода, вызвавшей исключение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Исключение <code>EvalError</code> выбрасывается при неправильном использовании глобальной функции {{jsxref("Global_objects/eval()", "eval()")}}.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 <dl>
  <dt>{{jsxref("EvalError.prototype")}}</dt>
  <dd>Позволяет добавлять свойства в объект <code>EvalError</code>.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 <p>Глобальный объект <code>EvalError</code> не содержит собственных методов, однако, он наследует некоторые методы из цепочки прототипов.</p>
 
-<h2 id="EvalError_instances" name="EvalError_instances">Экземпляры объекта <code>EvalError</code></h2>
+<h2 id="EvalError_instances">Экземпляры объекта <code>EvalError</code></h2>
 
-<h3 id="Properties_2" name="Properties_2">Свойства</h3>
+<h3 id="Properties_2">Свойства</h3>
 <div>{{page('/ru/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_2" name="Methods_2">Методы</h3>
+<h3 id="Methods_2">Методы</h3>
 <div>{{page('/ru/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <p>Объект <code>EvalError</code> в настоящий момент не используется и он никогда не выбрасывается в процессе выполнения.</p>
 
-<h3 id="Example:_Create_an_EvalError" name="Example:_Create_an_EvalError">Пример: создание экземпляра объекта <code>EvalError</code></h3>
+<h3 id="Example:_Create_an_EvalError">Пример: создание экземпляра объекта <code>EvalError</code></h3>
 <pre class="brush: js">try {
   throw new EvalError('Привет', 'someFile.js', 10);
 } catch (e) {
@@ -63,7 +63,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -89,10 +89,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error")}}</li>
  <li>{{jsxref("EvalError.prototype")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/function/apply/index.html b/files/ru/web/javascript/reference/global_objects/function/apply/index.html
index e7f18db385..947cd56a3d 100644
--- a/files/ru/web/javascript/reference/global_objects/function/apply/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/apply/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
 ---
 <div>{{JSRef("Global_Objects", "Function")}}</div>
 
-<h2 id="Summary" name="Summary">Общие сведения</h2>
+<h2 id="Summary">Общие сведения</h2>
 
 <p>Метод <strong><code>apply()</code></strong> вызывает функцию с указанным значением <code>this</code> и аргументами, предоставленными в виде массива (либо <a href="/ru/docs/Web/JavaScript/Guide/Predefined_Core_Objects#Working_with_Array-like_objects">массивоподобного объекта</a>).</p>
 
@@ -19,11 +19,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
 <p><strong>Примечание:</strong> хотя синтаксис этой функции практически полностью идентичен функции {{jsxref("Function.prototype.call()", "call()")}}, фундаментальное различие между ними заключается в том, что функция <code>call()</code> принимает список аргументов, в то время как функция <code>apply()</code> принимает единичный массив аргументов.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>fun</var>.apply(<var>thisArg</var>, [<var>argsArray</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>thisArg</code></dt>
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
  <dd>Опциональный параметр. Массивоподобный объект, определяющий аргументы, с которыми функция <em><code>fun</code></em> должна быть вызвана, либо {{jsxref("Global_Objects/null", "null")}} или {{jsxref("Global_Objects/undefined", "undefined")}}, если в функцию не надо передавать аргументы. Начиная с ECMAScript 5 эти аргументы могут быть обобщёнными массивоподобными объектами, а не только массивом. Смотрите ниже информацию по {{anch("Browser_compatibility", "совместимости с браузерами")}}.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Вы можете присваивать различные объекты <code>this</code> при вызове существующей функции. <code>this</code> ссылается на текущий объект, вызывающий объект. С помощью <code>apply()</code> вы можете написать метод один раз, а затем наследовать его в других объектах без необходимости переписывать метод для каждого нового объекта.</p>
 
@@ -44,9 +44,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
 
 <p>{{note("Большинство браузеров, включая Chrome 14 и Internet Explorer 9, всё ещё не принимают массивоподобные объекты и будут выбрасывать исключение.")}}</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_apply_to_chain_constructors" name="Example:_Using_apply_to_chain_constructors">Пример: использование <code>apply()</code> для связи конструкторов объекта в цепочку</h3>
+<h3 id="Example_Using_apply_to_chain_constructors">Пример: использование <code>apply()</code> для связи конструкторов объекта в цепочку</h3>
 
 <p>Вы можете использовать метод <code>apply()</code> для объединения в цепочку {{jsxref("Operators/new", "конструкторов", "", 1)}} объекта, как в Java. В следующем примере мы создадим в объекте {{jsxref("Global_Objects/Function", "Function")}} глобальный метод <code>construct()</code>, который позволит нам использовать массивоподобные объекты с конструктором вместо списка аргументов.</p>
 
@@ -88,7 +88,7 @@ alert(myInstance.constructor);              // выведет 'MyConstructor'
 <p><strong>Примечание:</strong> этот неродной метод <code>Function.construct()</code> не будет работать с некоторыми родными конструкторами (вроде конструктора {{jsxref("Global_Objects/Date", "Date")}}, к примеру). В этих случаях вы можете использовать метод {{jsxref("Function.prototype.bind()")}} (например, представьте, что вы имеете следующий массив, который можно использовать с конструктором {{jsxref("Global_Objects/Date", "Date")}}: <code>[2012, 11, 4]</code>; в этом случае вы напишите что-то вроде: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()</code> — так или иначе, это не самый изящный способ и, вероятно, его не стоит использовать в рабочем окружении).</p>
 </div>
 
-<h3 id="Example_Using_apply_and_built-in_functions" name="Example:_Using_apply_and_built-in_functions">Пример: использование <code>apply()</code> и встроенных функций</h3>
+<h3 id="Example_Using_apply_and_built-in_functions">Пример: использование <code>apply()</code> и встроенных функций</h3>
 
 <p>Умное использование метода <code>apply()</code> позволяет вам использовать встроенные функции для некоторых задач, для которых в противном случае пришлось бы писать цикл по массиву значений. В качестве примера давайте используем {{jsxref("Math.max()")}}/{{jsxref("Math.min()")}} для нахождения максимального/минимального значения в массиве.</p>
 
@@ -130,7 +130,7 @@ for (var i = 0; i &lt; numbers.length; i++) {
 var min = minOfArray([5, 6, 2, 3, 7]);
 </pre>
 
-<h3 id="Example_Using_apply_in_monkey-patching" name="Example:_Using_apply_in_monkey-patching">Пример: использование <code>apply()</code> в «monkey-патчинге»</h3>
+<h3 id="Example_Using_apply_in_monkey-patching">Пример: использование <code>apply()</code> в «monkey-патчинге»</h3>
 
 <p>Метод <code>apply()</code> может быть лучшим вариантом для «monkey-патчинга» встроенных в Firefox функций, либо JS библиотек. Пусть у вас есть функция <code>someobject.foo()</code>, вы можете изменить её таким немного хакерским способом:</p>
 
@@ -146,7 +146,7 @@ someobject.foo = function() {
 
 <p>Этот метод особенно удобен, когда вам нужно отладить события, либо интерфейс с чем-то, что не имеет API, вроде различных событий <code>.on([event]...</code>, например, тех что используются в <a href="/ru/docs/Tools/Page_Inspector#Developer_API">Инспекторе инструментов разработчика</a>).</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -173,11 +173,11 @@ someobject.foo = function() {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>объект {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/function/arguments/index.html b/files/ru/web/javascript/reference/global_objects/function/arguments/index.html
index c7f2da7129..463e817162 100644
--- a/files/ru/web/javascript/reference/global_objects/function/arguments/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/arguments/index.html
@@ -11,12 +11,12 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments
 ---
 <div>
  {{JSRef("Global_Objects", "Function")}} {{deprecated_header}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <code><strong><em>function</em>.arguments</strong></code> ссылалось на массивоподобный объект, соответствующий аргументам, переданным в функцию. Используйте вместо него простую переменную {{jsxref("Functions_and_function_scope/arguments", "arguments")}}.</p>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Синтаксис <code><em>function</em>.arguments</code> устарел. Рекомендуемым способом доступа к объекту {{jsxref("Functions_and_function_scope/arguments", "arguments")}}, доступному внутри функций, является простая ссылка на переменную {{jsxref("Functions_and_function_scope/arguments", "arguments")}}.</p>
 <p>В случае рекурсии, то есть, если функция <code>f</code> несколько раз появляется в стеке вызовов, значение <code>f.arguments</code> представляет аргументы, соответствующие самому последнему вызову функции.</p>
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">function f(n) { g(n - 1); }
 
 function g(n) {
@@ -35,7 +35,7 @@ f(2);
 // после: 0
 // после: 1
 </pre>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -60,11 +60,11 @@ f(2);
   </tr>
  </tbody>
 </table>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>объект {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</li>
  <li>{{jsxref("Functions_and_function_scope", "Функции и их область видимости", "", 1)}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/function/bind/index.html b/files/ru/web/javascript/reference/global_objects/function/bind/index.html
index eba2ec1626..4dccce8791 100644
--- a/files/ru/web/javascript/reference/global_objects/function/bind/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/bind/index.html
@@ -13,15 +13,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
 ---
 <div>{{JSRef("Global_Objects", "Function")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>bind()</strong></code> создаёт новую функцию, которая при вызове устанавливает в качестве контекста выполнения <code>this</code> предоставленное значение. В метод также передаётся набор аргументов, которые будут установлены перед переданными в привязанную функцию аргументами при её вызове.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>fun</var>.bind(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>thisArg</code></dt>
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
  <dd>Аргументы целевой функции, передаваемые перед аргументами привязанной функции при вызове целевой функции.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>bind()</code> создаёт новую "<strong>привязанную функцию</strong>" (<strong>ПФ</strong>).  <strong>ПФ</strong> <span class="translation-chunk">- это "необычный </span> <span class="translation-chunk">функциональный объект" ( термин из </span> <strong>ECMAScript 6</strong> <span class="translation-chunk"> ), который является обёрткой над исходным </span> <span class="translation-chunk">функциональным объектом. Вызов </span> <strong>ПФ</strong> <span class="translation-chunk">  приводит к исполнению кода обёрнутой функции.</span></p>
 
@@ -53,9 +53,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
 
 <p>Привязанная функция также может быть сконструирована с помощью оператора {{jsxref("Operators/new", "new")}}: это работает так, как если бы вместо неё конструировалась целевая функция. Предоставляемое значение <code>this</code> в этом случае игнорируется, хотя ведущие аргументы всё ещё передаются в эмулируемую функцию.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Creating_a_bound_function" name="Example:_Creating_a_bound_function">Пример: создание привязанной функции</h3>
+<h3 id="Example:_Creating_a_bound_function">Пример: создание привязанной функции</h3>
 
 <p>Простейшим способом использования <code>bind()</code> является создание функции, которая, вне зависимости от способа её вызова, вызывается с определённым значением <code>this</code>. Обычным заблуждением для новичков в JavaScript является извлечение метода из объекта с целью его дальнейшего вызова в качестве функции и ожидание того, что он будет использовать оригинальный объект в качестве своего значения <code>this</code> (например, такое может случиться при использовании метода как колбэк-функции). Однако, без специальной обработки, оригинальный объект зачастую теряется. Создание привязанной функции из функции, использующей оригинальный объект, изящно решает эту проблему:</p>
 
@@ -75,7 +75,7 @@ var boundGetX = getX.bind(module);
 boundGetX(); // 81
 </pre>
 
-<h3 id="Example:_Partial_Functions" name="Example:_Partial_Functions">Пример: частичные функции</h3>
+<h3 id="Example:_Partial_Functions">Пример: частичные функции</h3>
 
 <p>Следующим простейшим способом использования <code>bind()</code> является создание функции с предопределёнными аргументами. Эти аргументы (если они есть) передаются после значения <code>this</code> и вставляются перед аргументами, передаваемыми в целевую функцию при вызове привязанной функции.</p>
 
@@ -92,7 +92,7 @@ var list2 = leadingThirtysevenList(); // [37]
 var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]
 </pre>
 
-<h3 id="Example:_With_setTimeout" name="Example:_With_setTimeout">Пример: с <code>setTimeout</code></h3>
+<h3 id="Example:_With_setTimeout">Пример: с <code>setTimeout</code></h3>
 
 <p>По умолчанию, внутри {{domxref("window.setTimeout()")}} контекст <code>this</code> устанавливается в объект {{domxref("window")}} (или <code>global</code>). При работе с методами класса, требующими <code>this</code> для ссылки на экземпляры класса, вы можете явно привязать <code>this</code> к колбэк-функции для сохранения экземпляра.</p>
 
@@ -111,7 +111,7 @@ LateBloomer.prototype.declare = function() {
 };
 </pre>
 
-<h3 id="Example:_Bound_functions_used_as_constructors" name="Example:_Bound_functions_used_as_constructors">Пример: привязывание функций, используемых в качестве конструкторов</h3>
+<h3 id="Example:_Bound_functions_used_as_constructors">Пример: привязывание функций, используемых в качестве конструкторов</h3>
 
 <div class="warning">
 <p><strong>Предупреждение:</strong> этот раздел демонстрирует возможности JavaScript и документирует некоторые граничные случаи использования метода <code>bind()</code>. Показанные ниже методы не являются лучшей практикой и, вероятно, их не следует использовать в рабочем окружении.</p>
@@ -161,7 +161,7 @@ emptyObj.x + ',' + emptyObj.y;
 
 <p>Если вы хотите поддерживать использование привязанной функции только с помощью оператора {{jsxref("Operators/new", "new")}}, либо только с помощью прямого вызова, целевая функция должна предусматривать такие ограничения.</p>
 
-<h3 id="Example:_Creating_shortcuts" name="Example:_Creating_shortcuts">Пример: создание сокращений</h3>
+<h3 id="Example:_Creating_shortcuts">Пример: создание сокращений</h3>
 
 <p>Метод <code>bind()</code> также полезен в случаях, если вы хотите создать сокращение для функции, требующей определённое значение <code>this</code>.</p>
 
@@ -185,7 +185,7 @@ var slice = Function.prototype.call.bind(unboundSlice);
 slice(arguments);
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Функция <code>bind</code> является дополнением к стандарту ECMA-262 5-го издания; поэтому она может присутствовать не во всех браузерах. Вы можете частично обойти это ограничение, вставив следующий код в начало ваших скриптов, он позволяет использовать большую часть возможностей <code>bind()</code> в реализациях, не имеющих его родной поддержки.</p>
 
@@ -226,7 +226,7 @@ slice(arguments);
 
 <p>Если вы решили использовать частичную реализацию, <strong>не рассчитывайте на корректную работу в тех случаях, когда реализация отклоняется от спецификации ECMA-262 5-го издания!</strong> Однако, в определённых случаях (и, возможно, с дополнительными модификациями для отдельных нужд), применение данной частичной реализации может быть вполне оправданным до тех пор, пока <code>bind()</code> не станет широко реализован в соответствии со спецификацией.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -248,11 +248,11 @@ slice(arguments);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Function.prototype.apply()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/function/call/index.html b/files/ru/web/javascript/reference/global_objects/function/call/index.html
index 19158fbf1a..e7fba0711c 100644
--- a/files/ru/web/javascript/reference/global_objects/function/call/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/call/index.html
@@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/call
 ---
 <div>{{JSRef("Global_Objects", "Function")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>call()</strong></code> вызывает функцию с указанным значением <code>this</code> и индивидуально предоставленными аргументами.</p>
 
@@ -17,11 +17,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/call
 <p><strong>Примечание:</strong> хотя синтаксис этой функции практически полностью идентичен функции {{jsxref("Function.prototype.apply", "apply()")}}, фундаментальное различие между ними заключается в том, что функция <code>call()</code> принимает <strong>список аргументов</strong>, в то время, как функция <code>apply()</code> <strong>- одиночный массив аргументов</strong>.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>fun</var>.call(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>thisArg</code></dt>
@@ -30,13 +30,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/call
  <dd>Аргументы для объекта.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Вы можете присваивать различные объекты <code>this</code> при вызове существующей функции. <code>this</code> ссылается на текущий объект, вызвавший объект. С помощью <code>call</code> вы можете написать метод один раз, а затем наследовать его в других объектах, без необходимости переписывать метод для каждого нового объекта.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_call_to_chain_constructors_for_an_object" name="Example:_Using_call_to_chain_constructors_for_an_object">Пример: использование <code>call</code> для связи конструкторов объекта в цепочку</h3>
+<h3 id="Example_Using_call_to_chain_constructors_for_an_object">Пример: использование <code>call</code> для связи конструкторов объекта в цепочку</h3>
 
 <p>Вы можете использовать метод <code>call</code> для объединения в цепочку {{jsxref("Operators/new", "конструкторов", "", 1)}} объекта, как в Java. В следующем примере для объекта продукта <code>Product</code> объявлен конструктор с двумя параметрами, названием <code>name</code> и ценой <code>price</code>. Продукт инициализирует свойства <code>name</code> и <code>price</code>, а специализированные функции определяют ещё категорию <code>category</code>.</p>
 
@@ -68,7 +68,7 @@ var cheese = new Food('фета', 5);
 var fun = new Toy('робот', 40);
 </pre>
 
-<h3 id="Example_Using_call_to_invoke_an_anonymous_function" name="Example:_Using_call_to_invoke_an_anonymous_function">Пример: использование <code>call</code> для вызова анонимной функции</h3>
+<h3 id="Example_Using_call_to_invoke_an_anonymous_function">Пример: использование <code>call</code> для вызова анонимной функции</h3>
 
 <p>В этом чисто искусственном примере, мы создаём анонимную функцию и используем <code>call</code> для вызова её на каждом элементе массива. Главная задача анонимной функции здесь — добавить функцию печати в каждый объект, способную напечатать правильный индекс объекта в массиве. Передача объекта в качестве значения <code>this</code> не является острой необходимостью, но мы делаем это в целях объяснения.</p>
 
@@ -88,7 +88,7 @@ for (var i = 0; i &lt; animals.length; i++) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -115,11 +115,11 @@ for (var i = 0; i &lt; animals.length; i++) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Function.prototype.bind()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/function/caller/index.html b/files/ru/web/javascript/reference/global_objects/function/caller/index.html
index 8cf0bfce06..94b6630dcc 100644
--- a/files/ru/web/javascript/reference/global_objects/function/caller/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/caller/index.html
@@ -10,11 +10,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller
 ---
 <div>{{JSRef("Global_Objects", "Function")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Свойство <code><strong><em>function</em>.caller</strong></code> возвращает функцию, которая вызвала указанную функцию.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если функция <code>f</code> была вызвана из кода самого верхнего уровня, значение <code>f.caller</code> будет равно {{jsxref("Global_Objects/null", "null")}}, в противном случае значение будет равно функции, вызвавшей <code>f</code>.</p>
 
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller
 
 <p>Специальное свойство <code>__caller__</code>, возвращающее объект активации вызывающей функции и, таким образом, позволяющее восстанавливать стек вызовов, было удалено по соображениям безопасности.</p>
 
-<h3 id="Notes" name="Notes">Примечания</h3>
+<h3 id="Notes">Примечания</h3>
 
 <p>Обратите внимание, что в случае рекурсии, вы не сможете воссоздать стек вызовов, используя это свойство. Пусть у нас есть функции:</p>
 
@@ -53,9 +53,9 @@ while (f) {
 
 <p>то этот цикл никогда не остановится.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Checking_the_value_of_a_function.27s_caller_property" name="Example:_Checking_the_value_of_a_function.27s_caller_property">Пример: проверка значения свойства <code>caller</code> функции</h3>
+<h3 id="Example:_Checking_the_value_of_a_function.27s_caller_property">Пример: проверка значения свойства <code>caller</code> функции</h3>
 
 <p>Следующий код проверяет значение свойства <code>caller</code> функции.</p>
 
@@ -68,15 +68,15 @@ while (f) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <p>Не является частью какой-либо спецификации. Реализована в JavaScript 1.5.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Ошибка реализации в SpiderMonkey: {{bug(65683)}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/function/displayname/index.html b/files/ru/web/javascript/reference/global_objects/function/displayname/index.html
index 3e77625a4f..37850f92ee 100644
--- a/files/ru/web/javascript/reference/global_objects/function/displayname/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/displayname/index.html
@@ -10,9 +10,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName
 ---
 <div>
  {{JSRef("Global_Objects", "Function")}} {{Non-standard_header}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <code><strong><em>function</em>.displayName</strong></code> возвращает отображаемое имя функции.</p>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если оно определено, свойство <code>displayName</code> возвращает отображаемое имя функции:</p>
 <pre class="brush: js">function doSomething() {}
 
@@ -49,7 +49,7 @@ alert(object.someMethod.displayName); // "undefined"
 object.someMethod('123')
 alert(object.someMethod.displayName); // "someMethod (123)"
 </pre>
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <p>Обычно оно используется консолью и профилировщиком, как обёртка над {{jsxref("Function.name", "func.name")}} для отображения имени функции.</p>
 <p>Введя следующий пример в консоль, вы должны увидеть что-то вроде "<code>function Моя функция()</code>":</p>
 <pre class="brush: js">var a = function() {};
@@ -57,8 +57,8 @@ a.displayName = 'Моя функция';
 
 a
 </pre>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации.</p>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/function/length/index.html b/files/ru/web/javascript/reference/global_objects/function/length/index.html
index b3054d6f4e..31334c5765 100644
--- a/files/ru/web/javascript/reference/global_objects/function/length/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/length/index.html
@@ -10,21 +10,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/length
 ---
 <div>{{JSRef("Global_Objects", "Function")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <code><strong>length</strong></code> определяет количество аргументов, ожидаемых функцией.</p>
 
 <div>{{js_property_attributes(0, 0, 1)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Свойство <code>length</code> является свойством объекта функции и указывает, сколько аргументов ожидает функция, то есть, количество формальных параметров. Это количество не включает {{jsxref("rest_parameters", "остаточные параметры", "", 1)}}. В отличие от него, свойство {{jsxref("Functions_and_function_scope/arguments/length", "arguments.length")}} является локальным для функции и предоставляет количество аргументов, реально переданных в функцию.</p>
 
-<h3 id="Data_property_of_the_Function_constructor" name="Data_property_of_the_Function_constructor">Свойство данных конструктора <code>Function</code></h3>
+<h3 id="Data_property_of_the_Function_constructor">Свойство данных конструктора <code>Function</code></h3>
 <p>Конструктор {{jsxref("Global_Objects/Function", "Function")}} сам является объектом {{jsxref("Global_Objects/Function", "Function")}}. Его свойство данных <code>length</code> имеет значение 1. Атрибуты свойства: записываемое: <code>false</code>, перечисляемое: <code>false</code>, настраиваемое: <code>true</code>.</p>
 
-<h3 id="Property_of_the_Function_prototype_object" name="Property_of_the_Function_prototype_object">Свойство объекта прототипа <code>Function</code></h3>
+<h3 id="Property_of_the_Function_prototype_object">Свойство объекта прототипа <code>Function</code></h3>
 <p>Свойство <code>length</code> объекта прототипа {{jsxref("Global_Objects/Function", "Function")}} имеет значение 0.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">console.log(Function.length); /* 1 */
 
 console.log((function()        {}).length); /* 0 */
@@ -33,7 +33,7 @@ console.log((function(a, b)    {}).length); /* 2 и так далее */
 console.log((function(...args) {}).length); /* 0, остаточные параметры не считаются */
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -73,10 +73,10 @@ console.log((function(...args) {}).length); /* 0, остаточные пара
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/Function", "Function")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/function/name/index.html b/files/ru/web/javascript/reference/global_objects/function/name/index.html
index 3d6871ab9b..9348a0d1dc 100644
--- a/files/ru/web/javascript/reference/global_objects/function/name/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/name/index.html
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/name
 <p>Заметьте, что в нестандартном, pre-ES2015 релизе <code>configurable</code> свойство было <code>false</code></p>
 </div>
 
-<h2 id="Summary" name="Summary">Примеры</h2>
+<h2 id="Summary">Примеры</h2>
 
 <h3 id="Имя_объявленной_функции">Имя объявленной функции</h3>
 
@@ -208,7 +208,7 @@ if (b.constructor.name === 'Foo') {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Function.name")}}</p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/function/tosource/index.html b/files/ru/web/javascript/reference/global_objects/function/tosource/index.html
index 6f94711131..590434ebe3 100644
--- a/files/ru/web/javascript/reference/global_objects/function/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/tosource/index.html
@@ -10,15 +10,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource
 ---
 <div>
  {{JSRef("Global_Objects", "Function")}} {{non-standard_header}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>toSource()</strong></code> возвращает строку, представляющую исходный код объекта.</p>
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>function</var>.toSource();
 Function.toSource();
 </code></pre>
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toSource</code> возвращает следующие значения:</p>
 <ul>
  <li>Для встроенного объекта {{jsxref("Global_Objects/Function", "Function")}} метод <code>toSource</code> возвращает следующую строку, указывающую, что исходный код недоступен:
@@ -30,13 +30,13 @@ Function.toSource();
  <li>Для пользовательских функций, метод <code>toSource</code> возвращает исходный код JavaScript, определяющий объект как строку.</li>
 </ul>
 <p>Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде. Вы можете вызвать <code>toSource</code> во время отладки для изучения содержимого объекта.</p>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/function/tostring/index.html b/files/ru/web/javascript/reference/global_objects/function/tostring/index.html
index 90356f13e2..0e892d9ee9 100644
--- a/files/ru/web/javascript/reference/global_objects/function/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/function/tostring/index.html
@@ -10,23 +10,23 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString
 ---
 <div>{{JSRef("Global_Objects", "Function")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>toString()</strong></code> возвращает строку, представляющую исходный код функции.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>function</var>.toString(indentation)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>indentation</code> {{non-standard_inline}} {{obsolete_inline(17)}}</dt>
  <dd>Количество пробелов для отступов в строковом представлении исходного кода. Если параметр меньше или равен <code>-1</code>, большинство ненужных пробелов будет удалено.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Объект {{jsxref("Global_Objects/Function", "Function")}} переопределяет метод {{jsxref("Object.prototype.toString", "toString")}}, унаследованный из объекта {{jsxref("Global_Objects/Object", "Object")}}; он не наследует метод {{jsxref("Object.prototype.toString")}}. Для объектов {{jsxref("Global_Objects/Function", "Function")}} метод <code>toString</code> возвращает строку, представляющую объект в форме объявления функции. То есть, метод <code>toString</code> декомпилирует функцию и возвращает строку, включающую ключевое слово <code>function</code>, список аргументов, фигурные скобки и исходный код тела функции.</p>
 <p>JavaScript вызывает метод <code>toString</code> автоматически в случае, когда объект {{jsxref("Global_Objects/Function", "Function")}} представляется в качестве текстового значения, то есть, когда функция соединяется со строкой.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -52,10 +52,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toString()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/index.html b/files/ru/web/javascript/reference/global_objects/index.html
index b464ca01b5..1f1ee4f3fb 100644
--- a/files/ru/web/javascript/reference/global_objects/index.html
+++ b/files/ru/web/javascript/reference/global_objects/index.html
@@ -8,7 +8,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
 ---
 <div>{{jsSidebar("Objects")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Эта глава описывает все стандартные встроенные объекты JavaScript, вместе с их методами и свойствами.</p>
 
@@ -17,9 +17,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects
 
 <p>Другие объекты в глобальном пространстве имён <a href="/ru/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">создаются либо с помощью пользовательских скриптов</a>, либо предоставляются приложением хоста. Объекты хоста, доступные в контекстах браузера, задокументированы в <a href="/ru/docs/Web/API/Reference">справке по API</a>. Для получения дополнительной информации о различии между <a href="/ru/docs/DOM/DOM_Reference">DOM</a> и ядром <a href="/ru/docs/Web/JavaScript">JavaScript</a>, смотрите <a href="/ru/docs/Web/JavaScript/JavaScript_technologies_overview">обзор технологии JavaScript</a>.</p>
 
-<h2 id="Standard_objects_by_category" name="Standard_objects_(by_category)">Стандартные объекты (по категориям)</h2>
+<h2 id="Standard_objects_by_category">Стандартные объекты (по категориям)</h2>
 
-<h3 id="Value_properties" name="Value_properties">Значения</h3>
+<h3 id="Value_properties">Значения</h3>
 
 <p>Глобальные свойства, возвращающие простое значение.</p>
 
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>литерал {{jsxref("Global_Objects/null", "null")}}</li>
 </ul>
 
-<h3 id="Function_properties" name="Function_properties">Функции</h3>
+<h3 id="Function_properties">Функции</h3>
 
 <p>Глобальные функции, возвращающие результат определённой подпрограммы.</p>
 
@@ -49,7 +49,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline}}</li>
 </ul>
 
-<h3 id="Fundamental_objects" name="Fundamental_objects">Фундаментальные объекты</h3>
+<h3 id="Fundamental_objects">Фундаментальные объекты</h3>
 
 <p>Общие языковые объекты, функции и ошибки.</p>
 
@@ -68,7 +68,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("Global_Objects/URIError", "URIError")}}</li>
 </ul>
 
-<h3 id="Numbers_and_dates" name="Numbers_and_dates">Числа и даты</h3>
+<h3 id="Numbers_and_dates">Числа и даты</h3>
 
 <p>Объекты, имеющие дело с числами, датами и математическими вычислениями.</p>
 
@@ -78,7 +78,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("Global_Objects/Date", "Date")}}</li>
 </ul>
 
-<h3 id="Text_processing" name="Text_processing">Обработка текста</h3>
+<h3 id="Text_processing">Обработка текста</h3>
 
 <p>Объекты для манипулирования текстом.</p>
 
@@ -87,7 +87,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("Global_Objects/RegExp", "RegExp")}}</li>
 </ul>
 
-<h3 id="Indexed_collections" name="Indexed_collections">Индексированные коллекции</h3>
+<h3 id="Indexed_collections">Индексированные коллекции</h3>
 
 <p>Коллекции, упорядоченные по индексам. Массивоподобные объекты.</p>
 
@@ -104,7 +104,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("Global_Objects/Float64Array", "Float64Array")}}</li>
 </ul>
 
-<h3 id="Keyed_collections" name="Keyed_collections">Коллекции по ключу</h3>
+<h3 id="Keyed_collections">Коллекции по ключу</h3>
 
 <p>Коллекции объектов по ключу. Элементы обходятся в порядке вставки.</p>
 
@@ -115,7 +115,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("Global_Objects/WeakSet", "WeakSet")}}</li>
 </ul>
 
-<h3 id="Structured_data" name="Structured_data">Структурированные данные</h3>
+<h3 id="Structured_data">Структурированные данные</h3>
 
 <p>Буферы данных и Объектная нотация JavaScript (<strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation).</p>
 
@@ -125,20 +125,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("Global_Objects/JSON", "JSON")}}</li>
 </ul>
 
-<h3 id="Control_abstraction_objects" name="Control_abstraction_objects">Объекты управляющих абстракций</h3>
+<h3 id="Control_abstraction_objects">Объекты управляющих абстракций</h3>
 
 <ul>
  <li>{{jsxref("Global_Objects/Promise", "Promise")}}</li>
 </ul>
 
-<h3 id="Reflection" name="Reflection">Рефлексия</h3>
+<h3 id="Reflection">Рефлексия</h3>
 
 <ul>
  <li>{{jsxref("Global_Objects/Reflect", "Reflect")}} {{experimental_inline}}</li>
  <li>{{jsxref("Global_Objects/Proxy", "Proxy")}} {{experimental_inline}}</li>
 </ul>
 
-<h3 id="Internationalization" name="Internationalization">Интернационализация</h3>
+<h3 id="Internationalization">Интернационализация</h3>
 
 <p>Дополнения к ядру ECMAScript, отвечающие за функциональность, чувствительную к языку.</p>
 
@@ -149,7 +149,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li>
 </ul>
 
-<h3 id="Non-standard_objects" name="Non-standard_objects">Нестандартные объекты</h3>
+<h3 id="Non-standard_objects">Нестандартные объекты</h3>
 
 <ul>
  <li>{{jsxref("Generator")}} {{non-standard_inline}}</li>
@@ -158,7 +158,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects
  <li>{{jsxref("StopIteration")}} {{non-standard_inline}}</li>
 </ul>
 
-<h3 id="Other" name="Other">Прочее</h3>
+<h3 id="Other">Прочее</h3>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Reference/Functions/arguments">Аргументы функции (<code>arguments</code>)</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/infinity/index.html b/files/ru/web/javascript/reference/global_objects/infinity/index.html
index 30c5cf6b5f..de5c131725 100644
--- a/files/ru/web/javascript/reference/global_objects/infinity/index.html
+++ b/files/ru/web/javascript/reference/global_objects/infinity/index.html
@@ -7,7 +7,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Infinity
 ---
 <div>{{jsSidebar("Objects")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Глобальное свойство <code><strong>Infinity</strong></code> является числовым значением, представляющим бесконечность.</p>
 
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Infinity
 <p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
 </div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p><code>Infinity</code> является свойством <em>глобального объекта</em>, то есть, это переменная в глобальной области видимости.</p>
 
@@ -41,7 +41,7 @@ console.log(1 / Infinity      ); /* 0 */</code></pre>
 
 <p> </p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -73,7 +73,7 @@ console.log(1 / Infinity      ); /* 0 */</code></pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p> </p>
 
@@ -85,7 +85,7 @@ console.log(1 / Infinity      ); /* 0 */</code></pre>
 
 <div id="compat-mobile"> </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/internalerror/index.html b/files/ru/web/javascript/reference/global_objects/internalerror/index.html
index 060805655a..435290177d 100644
--- a/files/ru/web/javascript/reference/global_objects/internalerror/index.html
+++ b/files/ru/web/javascript/reference/global_objects/internalerror/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/InternalError
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Объект <code><strong>InternalError</strong></code> представляет ошибку, возникающую внутри движка JavaScript. Например: "InternalError: too much recursion".</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>new InternalError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>message</code></dt>
  <dd>Необязательный параметр. Человеко-читаемое описание ошибки.</dd>
@@ -27,7 +27,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/InternalError
  <dd>Необязательный параметр. Номер строки кода, вызвавшей исключение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Исключение <code>InternalError</code> выбрасывается при возникновении внутренней ошибки в движке JavaScript.</p>
 <p>Как правило, эти ошибки связаны с тем, что что-то стало слишком большим, либо чего-то стало слишком много, например:</p>
 <ul>
@@ -37,30 +37,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/InternalError
  <li>"too much recursion" — слишком глубокая рекурсия.</li>
 </ul>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 <dl>
  <dt>{{jsxref("InternalError.prototype")}}</dt>
  <dd>Позволяет добавлять свойства в объект <code>InternalError</code>.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 <p>Глобальный объект <code>InternalError</code> не содержит собственных методов, однако, он наследует некоторые методы из цепочки прототипов.</p>
 
-<h2 id="InternalError_instances" name="InternalError_instances">Экземпляры объекта <code>InternalError</code></h2>
+<h2 id="InternalError_instances">Экземпляры объекта <code>InternalError</code></h2>
 
-<h3 id="Properties_of_InternalError_instances" name="Properties_of_InternalError_instances">Свойства</h3>
+<h3 id="Properties_of_InternalError_instances">Свойства</h3>
 <div>{{page('/ru/Web/JavaScript/Reference/Global_Objects/InternalError/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_InternalError_instances" name="Methods_of_InternalError_instances">Методы</h3>
+<h3 id="Methods_of_InternalError_instances">Методы</h3>
 <div>{{page('/ru/Web/JavaScript/Reference/Global_Objects/InternalError/prototype', 'Methods')}}</div>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error")}}</li>
  <li>{{jsxref("InternalError.prototype")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/collator/compare/index.html b/files/ru/web/javascript/reference/global_objects/intl/collator/compare/index.html
index a429f06062..d8f0ef53c1 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/collator/compare/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/collator/compare/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/compare
 ---
 <div>{{JSRef("Global_Objects", "Collator", "Intl,DateTimeFormat,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Intl.Collator.prototype.compare</code></strong> возвращает функцию-геттер, сравнивающую две строки согласно порядку сортировки соответствующего объекта {{jsxref("Global_Objects/Collator", "Collator")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>collator</var>.compare(<var>string1</var>, <var>string2</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>string1</code></dt>
  <dt><code>string2</code></dt>
  <dd>Сравниваемые друг с другом строки.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Функция, возвращённая геттером <code>compare</code>, возвращает число, указывающее, как строки <code>string1</code> и <code>string2</code> сравниваются друг с другом в соответствии с порядком сортировки объекта {{jsxref("Global_Objects/Collator", "Collator")}}: отрицательное значение, если строка <code>string1</code> предшествует строке <code>string2</code>; положительное значение, если строка <code>string1</code> следует за строкой <code>string2</code>; 0, если строки считаются равными.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_compare_for_sort_array" name="Example:_Using_compare_for_sort_array">Пример: использование функции <code>compare</code> для сортировки массива</h3>
+<h3 id="Example_Using_compare_for_sort_array">Пример: использование функции <code>compare</code> для сортировки массива</h3>
 <p>Использование функции, возвращённой геттером <code>compare</code>, для сортировки массивов. Обратите внимание, что функция привязана к объекту {{jsxref("Global_Objects/Collator", "Collator")}}, из которого она была получена, так что её можно передавать в {{jsxref("Array.prototype.sort()")}} напрямую.</p>
 <pre class="brush: js">var a = ['Offenbach', 'Österreich', 'Odenwald'];
 var collator = new Intl.Collator('de-u-co-phonebk');
@@ -38,7 +38,7 @@ console.log(a.join(', '));
 // → "Odenwald, Österreich, Offenbach"
 </pre>
 
-<h3 id="Example_Using_compare_for_search_in_array" name="Example:_Using_compare_for_search_in_array">Пример: использование функции <code>compare</code> для поиска в массиве</h3>
+<h3 id="Example_Using_compare_for_search_in_array">Пример: использование функции <code>compare</code> для поиска в массиве</h3>
 <p>Использование функции, возвращённой геттером <code>compare</code>, для поиска совпадающих строк в массиве:</p>
 <pre class="brush: js">var a = ['Congrès', 'congres', 'Assemblée', 'poisson'];
 var collator = new Intl.Collator('fr', { usage: 'search', sensitivity: 'base' });
@@ -50,7 +50,7 @@ console.log(matches.join(', '));
 // → "Congrès, congres"
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -66,10 +66,10 @@ console.log(matches.join(', '));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li>
  <li>{{jsxref("String.prototype.localeCompare()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/collator/index.html b/files/ru/web/javascript/reference/global_objects/intl/collator/index.html
index 7262fbded1..9967d550c8 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/collator/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/collator/index.html
@@ -9,14 +9,14 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator
 ---
 <div>{{JSRef("Global_Objects", "Collator", "Intl,DateTimeFormat,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Объект <strong><code>Intl.Collator</code></strong> является конструктором <dfn>сортировщиков</dfn> — объектов, включающих языка-зависимое сравнение строк.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>new Intl.Collator([<var>locales</var>[, <var>options</var>]])
 Intl.Collator.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>locales</code></dt>
  <dd>
@@ -59,33 +59,33 @@ Intl.Collator.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])<
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
-<h3 id="Properties" name="Properties">Свойства</h3>
+<h3 id="Properties">Свойства</h3>
 <dl>
  <dt>{{jsxref("Collator.prototype", "Intl.Collator.prototype")}}</dt>
  <dd>Позволяет добавлять свойства ко всем объектам.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 <dl>
  <dt>{{jsxref("Collator.supportedLocalesOf", "Intl.Collator.supportedLocalesOf()")}}</dt>
  <dd>Возвращает массив, содержащий те из предоставленных локалей, которые поддерживаются без отката к локали по умолчанию среды выполнения.</dd>
 </dl>
 
-<h2 id="Collator_instances" name="Collator_instances">Экземпляры объекта <code>Collator</code></h2>
+<h2 id="Collator_instances">Экземпляры объекта <code>Collator</code></h2>
 
-<h3 id="Properties_of_Collator_instance" name="Properties_of_Collator_instance">Свойства</h3>
+<h3 id="Properties_of_Collator_instance">Свойства</h3>
 <p>Экземпляры <code>Collator</code> наследуют следующие свойства из своего прототипа:</p>
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Collator/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_Collator_instance" name="Methods_of_Collator_instance">Методы</h3>
+<h3 id="Methods_of_Collator_instance">Методы</h3>
 <p>Экземпляры <code>Collator</code> наследуют следующие методы из своего прототипа:</p>
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Collator/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_Collator" name="Example:_Using_Collator">Пример: использование <code>Collator</code></h3>
+<h3 id="Example_Using_Collator">Пример: использование <code>Collator</code></h3>
 <p>Следующий пример демонстрирует различные потенциальные результаты для строки, находящейся до, после или на том же самом уровне, что и другая строка:</p>
 <pre class="brush: js">console.log(new Intl.Collator().compare('a', 'c')); // → отрицательное значение
 console.log(new Intl.Collator().compare('c', 'a')); // → положительное значение
@@ -93,7 +93,7 @@ console.log(new Intl.Collator().compare('a', 'a')); // → 0
 </pre>
 <p>Обратите внимание, что результат, показанный в коде выше, может сильно различаться в зависимости от браузера и его версии. Происходит это потому, что возвращаемые значения зависят от реализации. То есть, спецификация требует только чтобы при следовании строки до значение было отрицательным, а после — положительным.</p>
 
-<h3 id="Example_Using_locales" name="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
+<h3 id="Example_Using_locales">Пример: использование аргумента <code>locales</code></h3>
 <p>Результаты, предоставляемые функцией {{jsxref("Collator.prototype.compare()")}} сильно различаются в зависимости от языка. Для получения порядка сортировки языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент <code>locales</code>:</p>
 <pre class="brush: js">// В немецком буква ä идёт рядом с буквой a
 console.log(new Intl.Collator('de').compare('ä', 'z'));
@@ -104,7 +104,7 @@ console.log(new Intl.Collator('sv').compare('ä', 'z'));
 // → положительное значение
 </pre>
 
-<h3 id="Example_Using_options" name="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
+<h3 id="Example_Using_options">Пример: использование аргумента <code>options</code></h3>
 <p>Результат, предоставляемый функцией {{jsxref("Collator.prototype.compare()")}}, может быть настроен с помощью аргумента <code>options</code>:</p>
 <pre class="brush: js">// В немецком буква a является базовой для буквы ä
 console.log(new Intl.Collator('de', { sensitivity: 'base' }).compare('ä', 'a'));
@@ -115,7 +115,7 @@ console.log(new Intl.Collator('sv', { sensitivity: 'base' }).compare('ä', 'a'))
 // → положительное значение
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -131,8 +131,8 @@ console.log(new Intl.Collator('sv', { sensitivity: 'base' }).compare('ä', 'a'))
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'See_also')}}</div>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html b/files/ru/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html
index 1a8b740f91..cc601bb078 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html
@@ -12,13 +12,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/resolvedOp
 ---
 <div>{{JSRef("Global_Objects", "Collator", "Intl,DateTimeFormat,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Intl.Collator.prototype.resolvedOptions()</code></strong> возвращает новый объект со свойствами, отражающими локаль и параметры сравнения строк, вычисленные во время инициализации соответствующего объекта {{jsxref("Global_Objects/Collator", "Collator")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>collator</var>.resolvedOptions()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Возвращает новый объект со свойствами, отражающими локаль и параметры сравнения строк, вычисленные во время инициализации соответствующего объекта {{jsxref("Global_Objects/Collator", "Collator")}}. Объект содержит следующие свойства:</p>
 <dl>
  <dt><code>locale</code></dt>
@@ -34,7 +34,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/resolvedOp
  <dd>Значения, предоставленные для этих свойств в аргументе <code>options</code> или запрошенные ключами расширения Unicode <code>"kn"</code> и <code>"kf"</code>, либо значения по умолчанию. Если реализация не поддерживает эти свойства, они будут опущены.</dd>
 </dl>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -50,10 +50,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/resolvedOp
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html b/files/ru/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html
index 11456b26a7..29ef3f0fcd 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html
@@ -10,13 +10,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/supportedL
 ---
 <div>{{JSRef("Global_Objects", "Collator", "Intl,DateTimeFormat,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Intl.Collator.supportedLocalesOf()</code></strong> возвращает массив, содержащий те из предоставленных локалей, что поддерживаются при сравнении строк без отката к локали по умолчанию среды выполнения.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Intl.Collator.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>locales</code></dt>
  <dd>Строка с языковой меткой BCP 47, либо массив таких строк. Описание общей формы и интерпретации аргумента <code>locales</code> смотрите на {{jsxref("Global_Objects/Intl", "странице, посвящённой объекту Intl", "#Locale_identification_and_negotiation", 1)}}.</dd>
@@ -30,12 +30,12 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/supportedL
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Возвращает массив с подмножеством языковых меток, предоставленных в аргументе <code>locales</code>. Возвращаются те языковые метки, для которых среда выполнения поддерживает сравнение строк без отката к локали по умолчанию; при поиске используется предоставленный алгоритм сопоставления локалей.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_supportedLocalesOf" name="Example:_Using_supportedLocalesOf">Пример: использование <code>supportedLocalesOf</code></h3>
+<h3 id="Example_Using_supportedLocalesOf">Пример: использование <code>supportedLocalesOf</code></h3>
 <p>Предполагая, что среда выполнения поддерживает индонезийское и немецкое, но на балийское сравнение строк, метод <code>supportedLocalesOf</code> вернёт неизменными индонезийскую и немецкую языковые метки, даже несмотря на то, что сортировка <code>pinyin</code> не используется с индонезийским языком и вряд ли будет поддерживаться в немецком языке для Индонезии. Обратите внимание на используемую здесь спецификацию алгоритма <code>"lookup"</code> — сопоставление <code>"best fit"</code> может решить, что индонезийский язык является адекватным сопоставлением с балийским, поскольку большинство людей, говорящих на балийском, также понимают индонезийский, и поэтому может возвратиться ещё и языковая метка балийского языка.</p>
 <pre class="brush: js">var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
 var options = { localeMatcher: 'lookup' };
@@ -43,7 +43,7 @@ console.log(Intl.Collator.supportedLocalesOf(locales, options).join(', '));
 // → "id-u-co-pinyin, de-ID"
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -59,10 +59,10 @@ console.log(Intl.Collator.supportedLocalesOf(locales, options).join(', '));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html
index 8cb3df3e85..cab760e9d6 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html
@@ -11,24 +11,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/form
 ---
 <div>{{JSRef("Global_Objects", "DateTimeFormat", "Intl,Collator,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Intl.DateTimeFormat.prototype.format</code></strong> возвращает функцию-геттер, форматирующую дату согласно локали и параметрам форматирования соответствующего объекта {{jsxref("Global_Objects/DateTimeFormat", "DateTimeFormat")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateTimeFormat</var>.format(<var>date</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>date</code></dt>
  <dd>Дата для форматирования.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Функция, возвращённая геттером <code>format</code>, форматирует дату согласно локали и параметрам форматирования соответствующего объекта {{jsxref("Global_Objects/DateTimeFormat", "DateTimeFormat")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_format" name="Example:_Using_format">Пример: использование функции <code>format</code></h3>
+<h3 id="Example_Using_format">Пример: использование функции <code>format</code></h3>
 <p>Использование функции, возвращённой геттером <code>format</code>, для форматирования одной даты, здесь пример для сербского языка:</p>
 <pre class="brush: js">var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
 var dateTimeFormat = new Intl.DateTimeFormat('sr-RS', options);
@@ -36,7 +36,7 @@ console.log(dateTimeFormat.format(new Date()));
 // → "недеља, 7. април 2013."
 </pre>
 
-<h3 id="Example_Using_format_with_map" name="Example:_Using_format_with_map">Пример: использование функции <code>format</code> вместе с <code>map</code></h3>
+<h3 id="Example_Using_format_with_map">Пример: использование функции <code>format</code> вместе с <code>map</code></h3>
 <p>Использование функции, возвращённой геттером <code>format</code>, для форматирования всех дат в массиве. Обратите внимание, что функция привязана к объекту {{jsxref("Global_Objects/DateTimeFormat", "DateTimeFormat")}}, из которого она была получена, так что её можно передавать в {{jsxref("Array.prototype.map()")}} напрямую.</p>
 <pre class="brush: js">var a = [new Date(2012, 08), new Date(2012, 11), new Date(2012, 03)];
 var options = { year: 'numeric', month: 'long' };
@@ -46,7 +46,7 @@ console.log(formatted.join('; '));
 // → "setembro de 2012; dezembro de 2012; abril de 2012"
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -62,10 +62,10 @@ console.log(formatted.join('; '));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
  <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/index.html b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/index.html
index 092f4c0d60..f7836af5e0 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/index.html
@@ -9,16 +9,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
 ---
 <div>{{JSRef("Global_Objects", "DateTimeFormat", "Intl,Collator,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Объект <strong><code>Intl.DateTimeFormat</code></strong> является конструктором объектов, включающих языка-зависимое форматирование даты и времени.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code>new Intl.DateTimeFormat([<var>locales</var>[, <var>options</var>]])
 Intl.DateTimeFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>locales</code></dt>
@@ -86,39 +86,39 @@ Intl.DateTimeFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</va
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
-<h3 id="Properties" name="Properties">Свойства</h3>
+<h3 id="Properties">Свойства</h3>
 
 <dl>
  <dt>{{jsxref("DateTimeFormat.prototype", "Intl.DateTimeFormat.prototype")}}</dt>
  <dd>Позволяет добавлять свойства ко всем объектам.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <dl>
  <dt>{{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}</dt>
  <dd>Возвращает массив, содержащий те из предоставленных локалей, которые поддерживаются без отката к локали по умолчанию среды выполнения.</dd>
 </dl>
 
-<h2 id="DateTimeFormat_instances" name="DateTimeFormat_instances">Экземпляры объекта <code>DateTimeFormat</code></h2>
+<h2 id="DateTimeFormat_instances">Экземпляры объекта <code>DateTimeFormat</code></h2>
 
-<h3 id="Properties_of_DateTimeFormat_instance" name="Properties_of_DateTimeFormat_instance">Свойства</h3>
+<h3 id="Properties_of_DateTimeFormat_instance">Свойства</h3>
 
 <p>Экземпляры <code>DateTimeFormat</code> наследуют следующие свойства из своего прототипа:</p>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_DateTimeFormat_instance" name="Methods_of_DateTimeFormat_instance">Методы</h3>
+<h3 id="Methods_of_DateTimeFormat_instance">Методы</h3>
 
 <p>Экземпляры <code>DateTimeFormat</code> наследуют следующие методы из своего прототипа:</p>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_DateTimeFormat" name="Example:_Using_DateTimeFormat">Пример: использование <code>DateTimeFormat</code></h3>
+<h3 id="Example_Using_DateTimeFormat">Пример: использование <code>DateTimeFormat</code></h3>
 
 <p>При базовом использовании без определения локали <code>DateTimeFormat</code> использует локаль и опции по умолчанию.</p>
 
@@ -130,7 +130,7 @@ console.log(new Intl.DateTimeFormat().format(date));
 // → "12/19/2012", если код запущен с локалью en-US и часовым поясом America/Los_Angeles
 </pre>
 
-<h3 id="Example_Using_locales" name="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
+<h3 id="Example_Using_locales">Пример: использование аргумента <code>locales</code></h3>
 
 <p>Этот пример показывает некоторые локализованные форматы даты и времени. Для получения формата языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент <code>locales</code>:</p>
 
@@ -166,7 +166,7 @@ console.log(new Intl.DateTimeFormat(['ban', 'id']).format(date));
 // → "20/12/2012"
 </pre>
 
-<h3 id="Example_Using_options" name="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
+<h3 id="Example_Using_options">Пример: использование аргумента <code>options</code></h3>
 
 <p>Формат даты и времени может быть настроен с помощью аргумента <code>options</code>:</p>
 
@@ -201,7 +201,7 @@ console.log(date.toLocaleString('en-US', options));
 // → "12/19/2012, 19:00:00"
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -218,10 +218,10 @@ console.log(date.toLocaleString('en-US', options));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Intl.DateTimeFormat")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'See_also')}}</div>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html
index 507fea868c..e5b0a916d6 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html
@@ -12,13 +12,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/reso
 ---
 <div>{{JSRef("Global_Objects", "DateTimeFormat", "Intl,Collator,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Intl.DateTimeFormat.prototype.resolvedOptions()</code></strong> возвращает новый объект со свойствами, отражающими локаль и параметры форматирования даты и времени, вычисленные во время инициализации соответствующего объекта {{jsxref("Global_Objects/DateTimeFormat", "DateTimeFormat")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>dateTimeFormat</var>.resolvedOptions()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Возвращает новый объект со свойствами, отражающими локаль и параметры форматирования чисел, вычисленные во время инициализации соответствующего объекта {{jsxref("Global_Objects/DateTimeFormat", "DateTimeFormat")}}. Объект содержит следующие свойства:</p>
 <dl>
  <dt><code>locale</code></dt>
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/reso
  <dd>Значения, получившиеся в результате объединения соответствующих свойств в аргументе <code>options</code> и доступных комбинаций и представлений форматирования даты/времени в выбранной локали. Некоторые из этих свойств могут не присутствовать, что означает, что соответствующие компоненты не попадают в форматированный вывод.</dd>
 </dl>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -58,10 +58,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/reso
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html
index fb5102d600..6066e4955d 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/supp
 ---
 <div>{{JSRef("Global_Objects", "DateTimeFormat", "Intl,Collator,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Intl.DateTimeFormat.supportedLocalesOf()</code></strong> возвращает массив, содержащий те из предоставленных локалей, что поддерживаются при форматировании даты и времени без отката к локали по умолчанию среды выполнения.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Intl.DateTimeFormat.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>locales</code></dt>
  <dd>Строка с языковой меткой BCP 47, либо массив таких строк. Описание общей формы и интерпретации аргумента <code>locales</code> смотрите на {{jsxref("Global_Objects/Intl", "странице, посвящённой объекту Intl", "#Locale_identification_and_negotiation", 1)}}.</dd>
@@ -31,12 +31,12 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/supp
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Возвращает массив с подмножеством языковых меток, предоставленных в аргументе <code>locales</code>. Возвращаются те языковые метки, для которых среда выполнения поддерживает форматирование даты и времени без отката к локали по умолчанию; при поиске используется предоставленный алгоритм сопоставления локалей.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_supportedLocalesOf" name="Example:_Using_supportedLocalesOf">Пример: использование <code>supportedLocalesOf</code></h3>
+<h3 id="Example_Using_supportedLocalesOf">Пример: использование <code>supportedLocalesOf</code></h3>
 <p>Предполагая, что среда выполнения поддерживает индонезийское и немецкое, но на балийское форматирование даты и времени, метод <code>supportedLocalesOf</code> вернёт неизменными индонезийскую и немецкую языковые метки, даже несмотря на то, что сортировка <code>pinyin</code> не относится к форматированию даты и времени, не используется с индонезийским языком и вряд ли будет поддерживаться в немецком языке для Индонезии. Обратите внимание на используемую здесь спецификацию алгоритма <code>"lookup"</code> — сопоставление <code>"best fit"</code> может решить, что индонезийский язык является адекватным сопоставлением с балийским, поскольку большинство людей, говорящих на балийском, также понимают индонезийский, и поэтому может возвратиться ещё и языковая метка балийского языка.</p>
 <pre class="brush: js">var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
 var options = { localeMatcher: 'lookup' };
@@ -44,7 +44,7 @@ console.log(Intl.DateTimeFormat.supportedLocalesOf(locales, options).join(', '))
 // → "id-u-co-pinyin, de-ID"
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -60,10 +60,10 @@ console.log(Intl.DateTimeFormat.supportedLocalesOf(locales, options).join(', '))
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/index.html b/files/ru/web/javascript/reference/global_objects/intl/index.html
index 14ad0067f2..425d28e13d 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/index.html
@@ -9,11 +9,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl
 ---
 <div>{{JSRef("Global_Objects", "Intl", "Collator,DateTimeFormat,NumberFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Объект <strong><code>Intl</code></strong> является пространством имён для API интернационализации ECMAScript, предоставляющим языка-зависимое сравнение строк, форматирование чисел и дат со временем. Конструкторы объектов {{jsxref("Global_Objects/Collator", "Collator")}}, {{jsxref("Global_Objects/NumberFormat", "NumberFormat")}} и {{jsxref("Global_Objects/DateTimeFormat", "DateTimeFormat")}} являются свойствами объекта <code>Intl</code>. На этой странице описаны эти свойства, а также общая функциональность конструкторов интернационализации и других языка-зависимых функций.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</dt>
@@ -31,11 +31,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl
  <dd>Returns canonical locale names.</dd>
 </dl>
 
-<h2 id="Locale_identification_and_negotiation" name="Locale_identification_and_negotiation">Идентификация и согласование локали</h2>
+<h2 id="Locale_identification_and_negotiation">Идентификация и согласование локали</h2>
 
 <p>Конструкторы интернационализации, а также некоторые языка-зависимые методы других конструкторов (перечисленные в разделе {{anch("See_also", "Смотрите также")}}) используют общий шаблон для идентификации локалей и определения используемой локали: они все принимают аргументы <code>locales</code> и <code>options</code> и согласовывают запрошенную локаль (локали) с поддерживаемыми локалями согласно алгоритму, определённому свойством <code>options.localeMatcher</code>.</p>
 
-<h3 id="locales_argument" name="locales_argument">Аргумент <code>locales</code></h3>
+<h3 id="locales_argument">Аргумент <code>locales</code></h3>
 
 <p>Аргумент <code>locales</code> должен быть либо строкой, содержащей <a href="http://tools.ietf.org/html/rfc5646">языковую метку BCP 47</a>, либо массивом таких языковых меток. Если аргумент <code>locales</code> не предоставлен или не определён, используется локаль по умолчанию среды выполнения.</p>
 
@@ -57,19 +57,19 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl
  <li><code>"ja-JP-u-ca-japanese"</code>: использовать японский календарь при форматировании даты и времени, так что 2013 год выражается 25-м годом периода Хэйсей или 平成25.</li>
 </ul>
 
-<h3 id="Locale_negotiation" name="Locale_negotiation">Согласование локали</h3>
+<h3 id="Locale_negotiation">Согласование локали</h3>
 
 <p>Аргумент <code>locales</code>, после вырезания всех расширений Unicode, интерпретируется как приоритетный запрос из приложения. Среда выполнения сравнивает его с доступными локалями в выбирает наилучшую из имеющихся. Существует два алгоритма сравнения: сопоставление <code>"lookup"</code> (поиск) следует алгоритму поиска, определённому в <a href="http://tools.ietf.org/html/rfc4647#section-3.4">BCP 47</a>; сопоставление <code>"best fit"</code> (наилучший подходящий) позволяет среде выполнения предоставлять локаль, которая, как минимум, но возможно и лучше, подходит для запроса, нежели локаль, найденная с помощью алгоритма поиска. Если приложение не предоставляет аргумент <code>locales</code> или среда выполнения не имеет локали, соответствующей запросу, то используется локаль по умолчанию для среды выполнения. Метод сопоставления можно выбрать с помощью свойства аргумента <code>options</code> (смотрите ниже).</p>
 
 <p>Если выбранная языковая метка содержит подстроку расширения Unicode, это расширение будет использоваться для настройки сконструированного объекта или поведения функции. Каждый конструктор или функция поддерживают только определённое подмножество ключей, определённых расширением Unicode, и поддерживаемые значения часто зависят от языковой метки. Например, ключ <code>"co"</code> (сравнение) поддерживается только объектом {{jsxref("Global_Objects/Collator", "Collator")}}, а его значение <code>"phonebk"</code> поддерживается только для немецкого языка.</p>
 
-<h3 id="options_argument" name="options_argument">Аргумент <code>options</code></h3>
+<h3 id="options_argument">Аргумент <code>options</code></h3>
 
 <p>Аргумент <code>options</code> должен быть объектом со свойствами, которые различаются для конструкторов и функций. Если аргумент <code>options</code> не предоставлен или не определён, для всех свойств используются значения по умолчанию.</p>
 
 <p>Одно свойство поддерживается для всех языка-зависимых конструкторов: свойство <code>localeMatcher</code>, чьим значением должна быть одна из строк <code>"lookup"</code> или <code>"best fit"</code> и которое выбирает один из алгоритмов сопоставления локалей, описанных выше.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -86,13 +86,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div id="compat-mobile">
 <p>{{Compat("javascript.builtins.Intl")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Введение: <a href="http://norbertlindenberg.com/2012/12/ecmascript-internationalization-api/index.html">API интернационализации ECMAScript</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/numberformat/format/index.html b/files/ru/web/javascript/reference/global_objects/intl/numberformat/format/index.html
index 34a3680ce8..b3c51bd783 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/numberformat/format/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/numberformat/format/index.html
@@ -11,24 +11,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/format
 ---
 <div>{{JSRef("Global_Objects", "NumberFormat", "Intl,Collator,DateTimeFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Intl.NumberFormat.prototype.format</code></strong> возвращает функцию-геттер, форматирующую число согласно локали и параметрам форматирования соответствующего объекта {{jsxref("Global_Objects/NumberFormat", "NumberFormat")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>numberFormat</var>.format(<var>number</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>number</code></dt>
  <dd>Число для форматирования.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Функция, возвращённая геттером <code>format</code>, форматирует число согласно локали и параметрам форматирования соответствующего объекта {{jsxref("Global_Objects/NumberFormat", "NumberFormat")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_format" name="Example:_Using_format">Пример: использование функции <code>format</code></h3>
+<h3 id="Example_Using_format">Пример: использование функции <code>format</code></h3>
 <p>Использование функции, возвращённой геттером <code>format</code>, для форматирования одного значения валюты, здесь пример для русского языка:</p>
 <pre class="brush: js">var options = { style: 'currency', currency: 'RUB' };
 var numberFormat = new Intl.NumberFormat('ru-RU', options);
@@ -36,7 +36,7 @@ console.log(numberFormat.format(654321.987));
 // → "654 321,99 руб."
 </pre>
 
-<h3 id="Example_Using_format_with_map" name="Example:_Using_format_with_map">Пример: использование функции <code>format</code> вместе с <code>map</code></h3>
+<h3 id="Example_Using_format_with_map">Пример: использование функции <code>format</code> вместе с <code>map</code></h3>
 <p>Использование функции, возвращённой геттером <code>format</code>, для форматирования всех чисел в массиве. Обратите внимание, что функция привязана к объекту {{jsxref("Global_Objects/NumberFormat", "NumberFormat")}}, из которого она была получена, так что её можно передавать в {{jsxref("Array.prototype.map")}} напрямую.</p>
 <pre class="brush: js">var a = [123456.789, 987654.321, 456789.123];
 var numberFormat = new Intl.NumberFormat('es-ES');
@@ -45,7 +45,7 @@ console.log(formatted.join('; '));
 // → "123.456,789; 987.654,321; 456.789,123"
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -61,10 +61,10 @@ console.log(formatted.join('; '));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
  <li>{{jsxref("Number.prototype.toLocaleString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/numberformat/index.html b/files/ru/web/javascript/reference/global_objects/intl/numberformat/index.html
index bcaccbfbd9..1d623c7c7f 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/numberformat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/numberformat/index.html
@@ -9,17 +9,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
 ---
 <div>{{JSRef("Global_Objects", "NumberFormat", "Intl,Collator,DateTimeFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Объект <strong><code>Intl.NumberFormat</code></strong> является конструктором объектов, включающих языка-зависимое форматирование чисел.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>new Intl.NumberFormat([<var>locales</var>[, <var>options</var>]])
 Intl.NumberFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])
 </code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>locales</code></dt>
@@ -65,39 +65,39 @@ Intl.NumberFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
-<h3 id="Properties" name="Properties">Свойства</h3>
+<h3 id="Properties">Свойства</h3>
 
 <dl>
  <dt>{{jsxref("NumberFormat.prototype", "Intl.NumberFormat.prototype")}}</dt>
  <dd>Позволяет добавлять свойства ко всем объектам.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <dl>
  <dt>{{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}</dt>
  <dd>Возвращает массив, содержащий те из предоставленных локалей, которые поддерживаются без отката к локали по умолчанию среды выполнения.</dd>
 </dl>
 
-<h2 id="NumberFormat_instances" name="NumberFormat_instances">Экземпляры объекта <code>NumberFormat</code></h2>
+<h2 id="NumberFormat_instances">Экземпляры объекта <code>NumberFormat</code></h2>
 
-<h3 id="Properties_of_NumberFormat_instance" name="Properties_of_NumberFormat_instance">Свойства</h3>
+<h3 id="Properties_of_NumberFormat_instance">Свойства</h3>
 
 <p>Экземпляры <code>NumberFormat</code> наследуют следующие свойства из своего прототипа:</p>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_NumberFormat_instance" name="Methods_of_NumberFormat_instance">Методы</h3>
+<h3 id="Methods_of_NumberFormat_instance">Методы</h3>
 
 <p>Экземпляры <code>NumberFormat</code> наследуют следующие методы из своего прототипа:</p>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Basic_usage" name="Example:_Basic_usage">Пример: базовое использование</h3>
+<h3 id="Example_Basic_usage">Пример: базовое использование</h3>
 
 <p>При базовом использовании без определения локали возвращается строка, отформатированная с помощью локали по умолчанию с опциями по умолчанию.</p>
 
@@ -107,7 +107,7 @@ console.log(new Intl.NumberFormat().format(number));
 // → '3,500' в локали US English
 </pre>
 
-<h3 id="Example_Using_locales" name="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
+<h3 id="Example_Using_locales">Пример: использование аргумента <code>locales</code></h3>
 
 <p>Этот пример показывает некоторые локализованные числовые форматы. Для получения формата языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент <code>locales</code>:</p>
 
@@ -139,7 +139,7 @@ console.log(new Intl.NumberFormat(['ban', 'id']).format(number));
 // → 123.456,789
 </pre>
 
-<h3 id="Example_Using_options" name="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
+<h3 id="Example_Using_options">Пример: использование аргумента <code>options</code></h3>
 
 <p>Результат может быть настроен с помощью аргумента <code>options</code>:</p>
 
@@ -161,7 +161,7 @@ console.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).form
 // → 1,23,000
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -178,12 +178,12 @@ console.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).form
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Intl.NumberFormat")}}</p>
 
 <div id="compat-mobile"></div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'See_also')}}</div>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.html b/files/ru/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.html
index 0aa8dcc501..4beac4077a 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.html
@@ -12,13 +12,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/resolv
 ---
 <div>{{JSRef("Global_Objects", "NumberFormat", "Intl,Collator,DateTimeFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Intl.NumberFormat.prototype.resolvedOptions()</code></strong> возвращает новый объект со свойствами, отражающими локаль и параметры форматирования чисел, вычисленные во время инициализации соответствующего объекта {{jsxref("Global_Objects/NumberFormat", "NumberFormat")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>numberFormat</var>.resolvedOptions()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Возвращает новый объект со свойствами, отражающими локаль и параметры форматирования чисел, вычисленные во время инициализации соответствующего объекта {{jsxref("Global_Objects/NumberFormat", "NumberFormat")}}. Объект содержит следующие свойства:</p>
 <dl>
  <dt><code>locale</code></dt>
@@ -43,7 +43,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/resolv
  <dd>Значения, предоставленные для этих свойств в аргументе <code>options</code>, либо значения по умолчанию. Эти свойства присутствуют только в том случае, если в аргументе <code>options</code> присутствовало хотя бы одно из них.</dd>
 </dl>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -59,10 +59,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/resolv
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html b/files/ru/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html
index 70ecdf47da..621f9bc4b9 100644
--- a/files/ru/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html
@@ -10,13 +10,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/suppor
 ---
 <div>{{JSRef("Global_Objects", "NumberFormat", "Intl,Collator,DateTimeFormat")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Intl.NumberFormat.supportedLocalesOf()</code></strong> возвращает массив, содержащий те из предоставленных локалей, что поддерживаются при форматировании чисел без отката к локали по умолчанию среды выполнения.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Intl.NumberFormat.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>locales</code></dt>
  <dd>Строка с языковой меткой BCP 47, либо массив таких строк. Описание общей формы и интерпретации аргумента <code>locales</code> смотрите на {{jsxref("Global_Objects/Intl", "странице, посвящённой объекту Intl", "#Locale_identification_and_negotiation", 1)}}.</dd>
@@ -30,12 +30,12 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/suppor
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Возвращает массив с подмножеством языковых меток, предоставленных в аргументе <code>locales</code>. Возвращаются те языковые метки, для которых среда выполнения поддерживает форматирование чисел без отката к локали по умолчанию; при поиске используется предоставленный алгоритм сопоставления локалей.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_supportedLocalesOf" name="Example:_Using_supportedLocalesOf">Пример: использование <code>supportedLocalesOf</code></h3>
+<h3 id="Example_Using_supportedLocalesOf">Пример: использование <code>supportedLocalesOf</code></h3>
 <p>Предполагая, что среда выполнения поддерживает индонезийское и немецкое, но на балийское форматирование чисел, метод <code>supportedLocalesOf</code> вернёт неизменными индонезийскую и немецкую языковые метки, даже несмотря на то, что сортировка <code>pinyin</code> не относится к форматированию чисел, не используется с индонезийским языком и вряд ли будет поддерживаться в немецком языке для Индонезии. Обратите внимание на используемую здесь спецификацию алгоритма <code>"lookup"</code> — сопоставление <code>"best fit"</code> может решить, что индонезийский язык является адекватным сопоставлением с балийским, поскольку большинство людей, говорящих на балийском, также понимают индонезийский, и поэтому может возвратиться ещё и языковая метка балийского языка.</p>
 <pre class="brush: js">var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
 var options = { localeMatcher: 'lookup' };
@@ -43,7 +43,7 @@ console.log(Intl.NumberFormat.supportedLocalesOf(locales, options).join(', '));
 // → "id-u-co-pinyin, de-ID"
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -59,10 +59,10 @@ console.log(Intl.NumberFormat.supportedLocalesOf(locales, options).join(', '));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/isfinite/index.html b/files/ru/web/javascript/reference/global_objects/isfinite/index.html
index 14cf751b6e..bb0b17524c 100644
--- a/files/ru/web/javascript/reference/global_objects/isfinite/index.html
+++ b/files/ru/web/javascript/reference/global_objects/isfinite/index.html
@@ -31,24 +31,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/isFinite
 
 <p> </p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">isFinite(<em>testValue</em>)</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>testValue</code></dt>
  <dd>Аргумент для проверки, является ли он конечным числом.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p><code>isFinite</code> это функция верхнего уровня и она не связана ни с одним объектом.</p>
 
 <p>Вы можете использовать эту функцию там, где требуется определить, является ли аргумент конечным числом. Функция <code>isFinite</code> исследует число в своём параметре. Если аргумент является NaN, положительной или отрицательной бесконечностью, метод вернёт <code>false</code>; иначе возвращается <code>true</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">isFinite(Infinity);  // false
 isFinite(NaN);       // false
@@ -100,7 +100,7 @@ isFinite("0");       // true, но было бы false если использо
 
 <p> </p>
 
-<h2 id="See_Also" name="See_Also">Смотрите также</h2>
+<h2 id="See_Also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.isFinite()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/isnan/index.html b/files/ru/web/javascript/reference/global_objects/isnan/index.html
index bb9c3ff980..7b05786107 100644
--- a/files/ru/web/javascript/reference/global_objects/isnan/index.html
+++ b/files/ru/web/javascript/reference/global_objects/isnan/index.html
@@ -11,24 +11,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
 ---
 <div>{{jsSidebar("Objects")}}</div>
 
-<h2 id="Summary" name="Summary">Аннотация</h2>
+<h2 id="Summary">Аннотация</h2>
 
 <p>Функция <code><strong>isNaN()</strong></code> определяет является ли литерал или переменная нечисловым значением ({{jsxref("Global_Objects/NaN", "NaN")}}) или нет. При работе с функцией необходимо проявлять осторожность так как она <a href="#Description">имеет свои особенности</a>. В качестве альтернативы можно использовать метод {{jsxref("Number.isNaN()")}} из ECMAScript 6, или дополнительно проверять литерал или переменную на нечисловое значение при помощи <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a></code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>isNaN(<em>значение</em>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>Значение</code></dt>
  <dd>Литерал или переменная которые будут проверяться на нечисловое значение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
-<h3 id="The_necessity_of_an_isNaN_function" name="The_necessity_of_an_isNaN_function">Для чего нужна функция <code>isNaN</code>?</h3>
+<h3 id="The_necessity_of_an_isNaN_function">Для чего нужна функция <code>isNaN</code>?</h3>
 
 <p>В отличие от других возможных значениях в JavaScript, при работе с значением данного типа невозможно полагаться на == и === для определения, является ли переменная или литерал нечисловым значением ({{jsxref("Global_Objects/NaN", "NaN")}}) или нет, так как проверки <code>NaN == NaN</code> и <code>NaN === NaN</code> <em>в качестве значения вернут </em><code>false</code>. Следовательно, для проверки нужна функция <code>isNaN</code>.</p>
 
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
 <code>x !== x // true</code>
 </pre>
 
-<h3 id="Origin_of_NaN_values" name="Origin_of_NaN_values">Генерация значения <code>NaN</code></h3>
+<h3 id="Origin_of_NaN_values">Генерация значения <code>NaN</code></h3>
 
 <p>Значение <code>NaN</code> генерируются арифметическими операциями, результатом которых является <em>undefined</em> или <em>unrepresentable</em>. Такие условия не обязательно обозначают переполнение стека.<code> NaN</code> также может являться результатом попытки преобразования числа в строку, или значения, не имеющего эквивалента в простых числовых примитивах.</p>
 
@@ -60,7 +60,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
 
 <p>В следующей версии ECMAScript (ES6) функция {{jsxref("Number.isNaN()")}} также присутствует. <code>Number.isNaN(x)</code> будет надёжным методом для проверки, содержит ли <code>x</code> значение <code>NaN</code> или нет. Даже с <code>Number.isNaN</code>, однако, результатом <code>NaN</code> остаётся точное числовое значение, а не просто "not a number".</p>
 
-<h2 id="Examples" name="Examples">Пример</h2>
+<h2 id="Examples">Пример</h2>
 
 <pre class="brush: js">isNaN(NaN);       // true
 isNaN(undefined); // true
@@ -121,7 +121,7 @@ isNaN("blabla")   // true: "blabla" преобразовано в число.
 
 <p> </p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/json/index.html b/files/ru/web/javascript/reference/global_objects/json/index.html
index 5f05cff00a..3fbd7f25a9 100644
--- a/files/ru/web/javascript/reference/global_objects/json/index.html
+++ b/files/ru/web/javascript/reference/global_objects/json/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/JSON
 ---
 <div>{{JSRef("Global_Objects", "JSON")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Объект <strong><code>JSON</code></strong> содержит методы для разбора <a class="external" href="http://json.org/">объектной нотации JavaScript</a> (JavaScript Object Notation — сокращённо {{glossary("JSON")}}) и преобразования значений в JSON. Его нельзя вызвать как функцию или сконструировать как объект, и кроме своих двух методов он не содержит никакой интересной функциональности.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
-<h3 id="JavaScript_Object_Notation" name="JavaScript_Object_Notation">Объектная нотация JavaScript</h3>
+<h3 id="JavaScript_Object_Notation">Объектная нотация JavaScript</h3>
 
 <p>JSON является синтаксисом для сериализации объектов, массивов, чисел, строк логических значений и значения {{jsxref("null")}}. Он основывается на синтаксисе JavaScript, однако всё же отличается от него: не каждый код на JavaScript является JSON, и не каждый JSON является кодом на JavaScript. Смотрите также статью <a href="http://timelessrepo.com/json-isnt-a-javascript-subset">JSON: подмножество JavaScript, которым он не является</a> (на английском).</p>
 
@@ -105,7 +105,7 @@ ArrayElements = JSON
 
 <p>Во всех продукциях могут присутствовать незначащие пробельные символы, за исключением продукций <code><var>ЧислоJSON</var></code> (числа не должны содержать пробелов) и <code><var>СтрокаJSON</var></code> (где они интерпретируются как часть строки или возбуждают ошибку). Пробельными символами считаются символы табуляции (<a href="http://unicode-table.com/ru/0009/">U+0009</a>), возврата каретки (<a href="http://unicode-table.com/ru/000D/">U+000D</a>), перевода строки (<a href="http://unicode-table.com/ru/000A/">U+000A</a>) и, собственно, пробела (<a href="http://unicode-table.com/ru/0020/">U+0020</a>).</p>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <dl>
  <dt>{{jsxref("JSON.parse()")}}</dt>
@@ -114,7 +114,7 @@ ArrayElements = JSON
  <dd>Возвращает строку JSON, соответствующую указанному значению, возможно с включением только определённых свойств или с заменой значений свойств определяемым пользователем способом.</dd>
 </dl>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Объект <code>JSON</code> не поддерживается старыми браузерами. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать объект <code>JSON</code> в реализациях, которые его ещё не поддерживают (например, в Internet Explorer 6).</p>
 
@@ -146,7 +146,7 @@ ArrayElements = JSON
 
 <p>Более сложными известными <a class="external" href="http://remysharp.com/2010/10/08/what-is-a-polyfill/">полифилами</a> для объекта <code>JSON</code> являются проекты <a class="link-https" href="https://github.com/douglascrockford/JSON-js">JSON2</a> и <a class="external" href="http://bestiejs.github.com/json3">JSON3</a>.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -168,11 +168,11 @@ ArrayElements = JSON
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Guide/Using_native_JSON">Использование родного объекта <code>JSON</code></a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/json/parse/index.html b/files/ru/web/javascript/reference/global_objects/json/parse/index.html
index 74fcbbc0a5..951db65e20 100644
--- a/files/ru/web/javascript/reference/global_objects/json/parse/index.html
+++ b/files/ru/web/javascript/reference/global_objects/json/parse/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/JSON/parse
 ---
 <div>{{JSRef("Global_Objects", "JSON")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>JSON.parse()</code></strong> разбирает строку JSON, возможно с преобразованием получаемого в процессе разбора значения.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>JSON.parse(<var>text</var>[, <var>reviver</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>text</code></dt>
  <dd>Разбираемая строка JSON. Смотрите документацию по объекту {{jsxref("JSON")}} для описания синтаксиса JSON.</dd>
@@ -25,15 +25,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/JSON/parse
  <dd>Если параметр является функцией, определяет преобразование полученного в процессе разбора значения, прежде, чем оно будет возвращено вызывающей стороне.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Возвращает объект {{jsxref("Object")}}, соответствующий переданной строке JSON <code>text</code>.</p>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 <p>Выбрасывает исключение {{jsxref("SyntaxError")}}, если разбираемая строка не является правильным JSON.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_JSON.parse" name="Example:_Using_JSON.parse">Пример: использование метода <code>JSON.parse()</code></h3>
+<h3 id="Example:_Using_JSON.parse">Пример: использование метода <code>JSON.parse()</code></h3>
 <pre class="brush: js">JSON.parse('{}');              // {}
 JSON.parse('true');            // true
 JSON.parse('"foo"');           // "foo"
@@ -41,7 +41,7 @@ JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
 JSON.parse('null');            // null
 </pre>
 
-<h3 id="Example:_Using_the_reviver_parameter" name="Example:_Using_the_reviver_parameter">Пример: использование параметра <code>reviver</code></h3>
+<h3 id="Example:_Using_the_reviver_parameter">Пример: использование параметра <code>reviver</code></h3>
 <p>Если определён параметр <code>reviver</code>, значение, вычисляемое при разборе строки, будет <em>преобразовано</em> перед его возвратом. В частности, вычисленное значение и все его свойства (начиная с самых вложенных свойств и кончая самим значением), каждое проходят через функцию <code>reviver</code>, которая вызывается с контекстом <code>this</code>, содержащим объект в виде обрабатываемого свойства, и с аргументами: именем свойства в виде строки и значением свойства. Если функция <code>reviver</code> вернёт {{jsxref("undefined")}} (либо вообще не вернёт никакого значения, например, если выполнение достигнет конца функции), свойство будет удалено из объекта. В противном случае свойство будет переопределено возвращаемым значением.</p>
 <p>В конечном итоге, функция <code>reviver</code> вызывается с пустой строкой и самым верхним значением, чтобы обеспечить преобразование самого верхнего значения. Убедитесь, что вы правильно обрабатываете этот случай — обычно для этого нужно просто вернуть само значение — или метод <code>JSON.parse()</code> вернёт {{jsxref("undefined")}}.</p>
 <pre class="brush: js">JSON.parse('{"p": 5}', function(k, v) {
@@ -63,7 +63,7 @@ JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', function(k, v) {
 // ""
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -84,10 +84,10 @@ JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', function(k, v) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Guide/Using_native_JSON">Использование родного объекта <code>JSON</code></a></li>
  <li>{{jsxref("JSON.stringify()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/json/stringify/index.html b/files/ru/web/javascript/reference/global_objects/json/stringify/index.html
index 04ccba32a7..3b8e6a3d6a 100644
--- a/files/ru/web/javascript/reference/global_objects/json/stringify/index.html
+++ b/files/ru/web/javascript/reference/global_objects/json/stringify/index.html
@@ -10,15 +10,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/JSON/stringify
 ---
 <div>{{JSRef("Global_Objects", "JSON")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>JSON.stringify()</code></strong> преобразует значение JavaScript в строку JSON, возможно с заменой значений, если указана функция замены, или с включением только определённых свойств, если указан массив замены.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>JSON.stringify(<var>value</var>[, <var>replacer</var>[, <var>space</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value</code></dt>
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/JSON/stringify
  <dd>Делает результат красиво отформатированным (расставляя пробелы).</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>JSON.stringify()</code> преобразует значение в представляющую его нотацию JSON со следующими оговорками:</p>
 
@@ -67,7 +67,7 @@ JSON.stringify({ [Symbol.for('foo')]: 'foo' }, function(k, v) {
 // '{}'
 </pre>
 
-<h3 id="space_argument" name="space_argument">Параметр <code>space</code></h3>
+<h3 id="space_argument">Параметр <code>space</code></h3>
 
 <p>Параметр <code>space</code> может использоваться для управления форматированием отступов в конечной строке. Если он числовой, каждый последующий уровень вложенности будет дополнен отступом из пробелов, количество которых соответствует уровню (вплоть до десятого уровня). Если он строковый, каждый последующий уровень вложенности будет предваряться этой строкой (или её первыми десятью символами).</p>
 
@@ -87,7 +87,7 @@ JSON.stringify({ [Symbol.for('foo')]: 'foo' }, function(k, v) {
 // }'
 </pre>
 
-<h3 id="toJSON_behavior" name="toJSON_behavior">Поведение метода <code>toJSON()</code></h3>
+<h3 id="toJSON_behavior">Поведение метода <code>toJSON()</code></h3>
 
 <p>Если преобразуемый в строку объект имеет свойство с именем <code>toJSON</code> и значением свойства, установленным в функцию, то этот метод <code>toJSON()</code> изменит стандартное поведение преобразования в JSON: вместо преобразования объекта будет использоваться значение, возвращаемое методом <code>toJSON()</code>. Например:</p>
 
@@ -105,7 +105,7 @@ JSON.stringify(obj);        // '"bar"'
 JSON.stringify({ x: obj }); // '{"x":"bar"}'
 </pre>
 
-<h3 id="Example_of_using_JSON.stringify_with_localStorage" name="Example_of_using_JSON.stringify_with_localStorage">Пример использования метода <code>JSON.stringify()</code> вместе с <code>localStorage</code></h3>
+<h3 id="Example_of_using_JSON.stringify_with_localStorage">Пример использования метода <code>JSON.stringify()</code> вместе с <code>localStorage</code></h3>
 
 <p>В случае, если вы хотите сохранить объект таким образом, чтобы его можно было восстановить даже после закрытия браузера, имеет смысл воспользоваться следующим примером, демонстрирующим применение метода <code>JSON.stringify()</code>:</p>
 
@@ -134,7 +134,7 @@ var restoredSession = JSON.parse(localStorage.getItem('session'));
 console.log(restoredSession);
 </pre>
 
-<h3 id="Example_of_using_replacer_parameter" name="Example_of_using_replacer_parameter">Пример использования параметра <code>replacer</code></h3>
+<h3 id="Example_of_using_replacer_parameter">Пример использования параметра <code>replacer</code></h3>
 
 <pre class="brush: js">var foo = { foundation: 'Mozilla', model: 'box', week: 45, transport: 'car', month: 7 };
 
@@ -149,7 +149,7 @@ JSON.stringify(foo, ['week', 'month']);
 // '{"week":45,"month":7}', сохранились только свойства week и month
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -171,7 +171,7 @@ JSON.stringify(foo, ['week', 'month']);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 
@@ -181,7 +181,7 @@ JSON.stringify(foo, ['week', 'month']);
 
 
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Guide/Using_native_JSON">Использование родного объекта <code>JSON</code></a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/abs/index.html b/files/ru/web/javascript/reference/global_objects/math/abs/index.html
index 2d46eb6650..7b12e5477f 100644
--- a/files/ru/web/javascript/reference/global_objects/math/abs/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/abs/index.html
@@ -11,30 +11,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.abs()</code></strong> возвращает абсолютное значение числа. то есть</p>
 
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>≥</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>&lt;</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x &amp; \text{if} \quad x \geq 0 \\ x &amp; \text{if} \quad x &lt; 0 \end{cases} </annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.abs(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>abs()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.abs()</code>, а не пытаться вызывать метод на созданном объекте <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Math.abs_behavior" name="Example:_Math.abs_behavior">Пример: поведение метода <code>Math.abs()</code></h3>
+<h3 id="Example_Math.abs_behavior">Пример: поведение метода <code>Math.abs()</code></h3>
 
 <p>Метод вернёт {{jsxref("NaN")}}, если в него передать нечисловую строку или значение {{jsxref("undefined")}}/ничего не передавать. Метод вернёт 0, если в него передать значение {{jsxref("null")}}.</p>
 
@@ -50,7 +50,7 @@ Math.abs('string'); // NaN
 Math.abs();         // NaN
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -84,12 +84,12 @@ Math.abs();         // NaN
 
 
 
-<h2 id="Browser_compatibility" name="Browser_compatibility"><br>
+<h2 id="Browser_compatibility"><br>
  Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Math.abs")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.ceil()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/acos/index.html b/files/ru/web/javascript/reference/global_objects/math/acos/index.html
index 4718c45b65..de96aa683d 100644
--- a/files/ru/web/javascript/reference/global_objects/math/acos/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/acos/index.html
@@ -10,26 +10,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.acos()</code></strong> возвращает арккосинус числа (в радианах), то есть</p>
 <p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> уникальный </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ уникальный } \; y \in [0; \pi] \, \text{такой, что} \; \cos(y) = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.acos(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>Math.acos()</code> возвращает числовое значение между 0 и π радианами для значения <code>x</code>, лежащего в диапазоне от -1 до 1. Метод вернёт {{jsxref("NaN")}}, если значение <code>x</code> выйдет за этот диапазон.</p>
 <p>Поскольку метод <code>acos()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.acos()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.acos" name="Example:_Using_Math.acos">Пример: использование метода <code>Math.acos()</code></h3>
+<h3 id="Example:_Using_Math.acos">Пример: использование метода <code>Math.acos()</code></h3>
 <pre class="brush:js">Math.acos(-2);  // NaN
 Math.acos(-1);  // 3.141592653589793
 Math.acos(0);   // 1.5707963267948966
@@ -39,7 +39,7 @@ Math.acos(2);   // NaN
 </pre>
 <p>Для значений, меньших -1 или больших 1, метод <code>Math.acos()</code> возвращает {{jsxref("NaN")}}.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -65,10 +65,10 @@ Math.acos(2);   // NaN
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.asin()")}}</li>
  <li>{{jsxref("Math.atan()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/acosh/index.html b/files/ru/web/javascript/reference/global_objects/math/acosh/index.html
index 0f7b79065e..361580dd1e 100644
--- a/files/ru/web/javascript/reference/global_objects/math/acosh/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/acosh/index.html
@@ -13,30 +13,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.acosh()</code></strong> возвращает гиперболический арккосинус числа, то есть</p>
 
 <p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> уникальный </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cosh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ уникальный } \; y \geq 0 \; \text{такой, что} \; \cosh(y) = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.acosh(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>acosh()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.acosh()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.acosh" name="Example:_Using_Math.acosh">Пример: использование метода <code>Math.acosh()</code></h3>
+<h3 id="Example:_Using_Math.acosh">Пример: использование метода <code>Math.acosh()</code></h3>
 
 <pre class="brush: js">Math.acosh(-1); // NaN
 Math.acosh(0);  // NaN
@@ -47,7 +47,7 @@ Math.acosh(2);  // 1.3169578969248166
 
 <p>Для значений, меньших 1, метод <code>Math.acosh()</code> возвращает {{jsxref("NaN")}}.</p>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Для всех <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>1</mn></mrow><annotation encoding="TeX">x \geq 1</annotation></semantics></math>, мы имеем <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>-</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)</annotation></semantics></math>, так что этот метод может эмулироваться следующим образом:</p>
 
@@ -56,7 +56,7 @@ Math.acosh(2);  // 1.3169578969248166
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -73,11 +73,11 @@ Math.acosh(2);  // 1.3169578969248166
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.asinh()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/asin/index.html b/files/ru/web/javascript/reference/global_objects/math/asin/index.html
index 7ad8083649..bb30447efd 100644
--- a/files/ru/web/javascript/reference/global_objects/math/asin/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/asin/index.html
@@ -10,26 +10,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.asin()</code></strong> возвращает арксинус числа (в радианах), то есть</p>
 <p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> уникальный </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ уникальный } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{такой, что} \; \sin(y) = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.asin(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>Math.asin()</code> возвращает числовое значение между <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> и <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> радианами для значения <code>x</code>, лежащего в диапазоне от -1 до 1. Метод вернёт {{jsxref("NaN")}}, если значение <code>x</code> выйдет за этот диапазон.</p>
 <p>Поскольку метод <code>asin()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.asin()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.asin" name="Example:_Using_Math.asin">Пример: использование метода <code>Math.asin()</code></h3>
+<h3 id="Example:_Using_Math.asin">Пример: использование метода <code>Math.asin()</code></h3>
 <pre class="brush: js">Math.asin(-2);  // NaN
 Math.asin(-1);  // -1.5707963267948966 (-pi/2)
 Math.asin(0);   // 0
@@ -39,7 +39,7 @@ Math.asin(2);   // NaN
 </pre>
 <p>Для значений, меньших -1 или больших 1, метод <code>Math.asin()</code> возвращает {{jsxref("NaN")}}.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -65,10 +65,10 @@ Math.asin(2);   // NaN
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.acos()")}}</li>
  <li>{{jsxref("Math.atan()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/asinh/index.html b/files/ru/web/javascript/reference/global_objects/math/asinh/index.html
index af074ad213..dd9d2a195e 100644
--- a/files/ru/web/javascript/reference/global_objects/math/asinh/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/asinh/index.html
@@ -13,36 +13,36 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.asinh()</code></strong> возвращает гиперболический арксинус числа, то есть</p>
 
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> уникальный </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sinh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ уникальный } \; y \; \text{такой, что} \; \sinh(y) = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.asinh(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>asinh()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.asinh()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.asinh" name="Example:_Using_Math.asinh">Пример: использование метода <code>Math.asinh()</code></h3>
+<h3 id="Example:_Using_Math.asinh">Пример: использование метода <code>Math.asinh()</code></h3>
 
 <pre class="brush: js">Math.asinh(1);  // 0.881373587019543
 Math.asinh(0);  // 0
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Мы имеем <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>+</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right)</annotation></semantics></math>, так что этот метод может эмулироваться следующим образом:</p>
 
@@ -55,7 +55,7 @@ Math.asinh(0);  // 0
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -72,11 +72,11 @@ Math.asinh(0);  // 0
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/atan/index.html b/files/ru/web/javascript/reference/global_objects/math/atan/index.html
index 3569b07dca..ce788f0cd4 100644
--- a/files/ru/web/javascript/reference/global_objects/math/atan/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/atan/index.html
@@ -10,31 +10,31 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.atan()</code></strong> возвращает арктангенс числа (в радианах), то есть</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> уникальный </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ уникальный } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{такой, что} \; \tan(y) = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.atan(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>Math.atan()</code> возвращает числовое значение между <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> и <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> радианами.</p>
 <p>Поскольку метод <code>atan()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.atan()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.atan" name="Example:_Using_Math.atan">Пример: использование метода <code>Math.atan()</code></h3>
+<h3 id="Example:_Using_Math.atan">Пример: использование метода <code>Math.atan()</code></h3>
 <pre class="brush: js">Math.atan(1);  // 0.7853981633974483
 Math.atan(0);  // 0
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -60,10 +60,10 @@ Math.atan(0);  // 0
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.acos()")}}</li>
  <li>{{jsxref("Math.asin()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/atan2/index.html b/files/ru/web/javascript/reference/global_objects/math/atan2/index.html
index 1227f2ac61..cfbd427c92 100644
--- a/files/ru/web/javascript/reference/global_objects/math/atan2/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/atan2/index.html
@@ -10,13 +10,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.atan2()</code></strong> возвращает арктангенс от частного своих аргументов.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.atan2(<var>y</var>, <var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>y</code></dt>
  <dd>Первое число.</dd>
@@ -24,14 +24,14 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2
  <dd>Второе число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>Math.atan2()</code> возвращает числовое значение от -π до π, представляющее угол тета точки <code>(x, y)</code>. Это выраженный в радианах угол, отсчитываемый против часовой стрелки от положительного направления оси X до точки <code>(x, y)</code>. Обратите внимание, что первым в метод передаётся координата y, а только вторым — координата x.</p>
 <p>В метод <code>Math.atan2()</code> аргументы <code>x</code> и <code>y</code> передаются по отдельности, в то время, как в метод <code>Math.atan()</code> передаётся отношение этих двух аргументов.</p>
 <p>Поскольку метод <code>atan2()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.atan2()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.atan2" name="Example:_Using_Math.atan2">Пример: использование метода <code>Math.atan2()</code></h3>
+<h3 id="Example:_Using_Math.atan2">Пример: использование метода <code>Math.atan2()</code></h3>
 <pre class="brush: js">Math.atan2(90, 15); // 1.4056476493802699
 Math.atan2(15, 90); // 0.16514867741462683
 
@@ -48,7 +48,7 @@ Math.atan2(±Infinity, -Infinity); // ±3*PI/4.
 Math.atan2(±Infinity, +Infinity); // ±PI/4.
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -74,10 +74,10 @@ Math.atan2(±Infinity, +Infinity); // ±PI/4.
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.acos()")}}</li>
  <li>{{jsxref("Math.asin()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/atanh/index.html b/files/ru/web/javascript/reference/global_objects/math/atanh/index.html
index 0dad804b03..df9d51f8c8 100644
--- a/files/ru/web/javascript/reference/global_objects/math/atanh/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/atanh/index.html
@@ -13,30 +13,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/atanh
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.atanh()</code></strong> возвращает гиперболический арктангенс числа, то есть</p>
 
 <p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mrow><mo>(</mo><mrow><mo>-</mo><mn>1</mn><mo>,</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arctanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> уникальный </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tanh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ уникальный } \; y \; \text{такой, что} \; \tanh(y) = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.atanh(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>atanh()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.atanh()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.atanh" name="Example:_Using_Math.atanh">Пример: использование метода <code>Math.atanh()</code></h3>
+<h3 id="Example:_Using_Math.atanh">Пример: использование метода <code>Math.atanh()</code></h3>
 
 <pre class="brush: js">Math.atanh(-2);  // NaN
 Math.atanh(-1);  // -Infinity
@@ -48,7 +48,7 @@ Math.atanh(2);   // NaN
 
 <p>Для значений, меньших -1 или больших 1, метод <code>Math.atanh()</code> возвращает {{jsxref("NaN")}}.</p>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Для <math><semantics><mrow><mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow><mo>&lt;</mo><mn>1</mn></mrow><annotation encoding="TeX">\left|x\right| &lt; 1</annotation></semantics></math>, мы имеем <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">artanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mfrac><mrow><mn>1</mn><mo>+</mo><mi>x</mi></mrow><mrow><mn>1</mn><mo>-</mo><mi>x</mi></mrow></mfrac><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)</annotation></semantics></math>, так что этот метод может эмулироваться следующим образом:</p>
 
@@ -57,7 +57,7 @@ Math.atanh(2);   // NaN
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -74,11 +74,11 @@ Math.atanh(2);   // NaN
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/cbrt/index.html b/files/ru/web/javascript/reference/global_objects/math/cbrt/index.html
index de656bbfb4..cb31ae7109 100644
--- a/files/ru/web/javascript/reference/global_objects/math/cbrt/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/cbrt/index.html
@@ -13,27 +13,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.cbrt()</code></strong> возвращает кубический корень числа, то есть</p>
 <math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>c</mi><mi>b</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><mtext>уникальный</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>3</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{уникальный} \; y \; \text{такой, что} \; y^3 = x</annotation></semantics></math><span style='font-family: x-locale-heading-primary,zillaslab,Palatino,"Palatino Linotype",x-locale-heading-secondary,serif; font-size: 2.33333rem; letter-spacing: -0.00278rem;'>Синтаксис</span>
 
 <pre class="syntaxbox"><code>Math.cbrt(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>cbrt()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.cbrt()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_Math.cbrt" name="Example:_Using_Math.cbrt">Пример: использование метода <code>Math.cbrt()</code></h3>
+<h3 id="Example_Using_Math.cbrt">Пример: использование метода <code>Math.cbrt()</code></h3>
 
 <pre class="brush: js">Math.cbrt(-1); // -1
 Math.cbrt(0);  // 0
@@ -42,7 +42,7 @@ Math.cbrt(1);  // 1
 Math.cbrt(2);  // 1.2599210498948734
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Для всех <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>0</mn></mrow><annotation encoding="TeX">x \geq 0</annotation></semantics></math>, мы имеем <math><semantics><mrow><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><msup><mi>x</mi><mrow><mn>1</mn><mo>/</mo><mn>3</mn></mrow></msup></mrow><annotation encoding="TeX">\sqrt[3]{x} = x^{1/3}</annotation></semantics></math>, так что этот метод может эмулироваться следующим образом:</p>
 
@@ -57,7 +57,7 @@ Math.cbrt(2);  // 1.2599210498948734
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -74,11 +74,11 @@ Math.cbrt(2);  // 1.2599210498948734
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.pow()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/ceil/index.html b/files/ru/web/javascript/reference/global_objects/math/ceil/index.html
index af1d2a3c42..1c8f7ae141 100644
--- a/files/ru/web/javascript/reference/global_objects/math/ceil/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/ceil/index.html
@@ -11,28 +11,28 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.ceil()</code></strong> - округление вверх. Округляет аргумент до ближайшего большего целого.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.ceil(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>ceil()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.ceil()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.ceil" name="Example:_Using_Math.ceil">Пример: использование метода <code>Math.ceil()</code></h3>
+<h3 id="Example:_Using_Math.ceil">Пример: использование метода <code>Math.ceil()</code></h3>
 
 <p>Следующий пример показывает использование метода <code>Math.ceil()</code>.</p>
 
@@ -45,7 +45,7 @@ Math.ceil(-7.004); // -7</code></pre>
 
 <h3 id="Decimal_adjustment">Decimal adjustment</h3>
 
-<h3 id="Example:_Decimal_adjustment" name="Example:_Decimal_adjustment">Пример: корректировка округления десятичных дробей</h3>
+<h3 id="Example:_Decimal_adjustment">Пример: корректировка округления десятичных дробей</h3>
 
 <pre class="brush: js">// Замыкание
 (function() {
@@ -117,7 +117,7 @@ Math.ceil10(-55.59, -1);   // -55.5
 Math.ceil10(-59, 1);       // -50
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -144,11 +144,11 @@ Math.ceil10(-59, 1);       // -50
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.abs()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/clz32/index.html b/files/ru/web/javascript/reference/global_objects/math/clz32/index.html
index 955bf7ba8f..697be70a77 100644
--- a/files/ru/web/javascript/reference/global_objects/math/clz32/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/clz32/index.html
@@ -14,22 +14,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.clz32()</code></strong> возвращает количество ведущих нулевых битов в 32-битном двоичном представлении числа.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.clz32(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Название <code>clz32</code> является сокращением для более длинного <code>CountLeadingZeroes32</code> (<code>ПосчтитатьВедущиеНули32</code>).</p>
 
@@ -39,9 +39,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32
 
 <p>Этот метод особенно полезен для систем, которые компилируются в JS, например, для <a href="/ru/docs/Emscripten">Emscripten</a>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.clz32" name="Example:_Using_Math.clz32">Пример: использование метода <code>Math.clz32()</code></h3>
+<h3 id="Example:_Using_Math.clz32">Пример: использование метода <code>Math.clz32()</code></h3>
 
 <pre class="brush: js">Math.clz32(1);                // 31
 Math.clz32(1000);             // 22
@@ -56,7 +56,7 @@ Math.clz32(true);             // 31
 Math.clz32(3.5);              // 30
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">Math.clz32 = Math.clz32 || function(value) {
   value = Number(value) &gt;&gt;&gt; 0;
@@ -64,7 +64,7 @@ Math.clz32(3.5);              // 30
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -81,11 +81,11 @@ Math.clz32(3.5);              // 30
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/Math", "Math")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/cos/index.html b/files/ru/web/javascript/reference/global_objects/math/cos/index.html
index f079d2fea3..cd3623ea34 100644
--- a/files/ru/web/javascript/reference/global_objects/math/cos/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/cos/index.html
@@ -10,25 +10,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.cos()</code></strong> возвращает косинус числа.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.cos(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>x</code></dt>
  <dd>Число радиан.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>Math.cos()</code> возвращает числовое значение от -1 до 1, которое представляет косинус угла.</p>
 <p>Поскольку метод <code>cos()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.cos()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.cos" name="Example:_Using_Math.cos">Пример: использование метода <code>Math.cos()</code></h3>
+<h3 id="Example:_Using_Math.cos">Пример: использование метода <code>Math.cos()</code></h3>
 <pre class="brush: js">Math.cos(0);           // 1
 Math.cos(1);           // 0.5403023058681398
 
@@ -36,7 +36,7 @@ Math.cos(Math.PI);     // -1
 Math.cos(2 * Math.PI); // 1
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -62,10 +62,10 @@ Math.cos(2 * Math.PI); // 1
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.acos()")}}</li>
  <li>{{jsxref("Math.asin()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/cosh/index.html b/files/ru/web/javascript/reference/global_objects/math/cosh/index.html
index 5c6de5c547..4353a0ab1f 100644
--- a/files/ru/web/javascript/reference/global_objects/math/cosh/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/cosh/index.html
@@ -13,37 +13,37 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.cosh()</code></strong> возвращает гиперболический косинус числа, который может быть выражен через {{jsxref("Math.E", "число e", "", 1)}}:</p>
 
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.cosh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.cosh(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>cosh()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.cosh()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.cosh" name="Example:_Using_Math.cosh">Пример: использование метода <code>Math.cosh()</code></h3>
+<h3 id="Example:_Using_Math.cosh">Пример: использование метода <code>Math.cosh()</code></h3>
 
 <pre class="brush: js">Math.cosh(0);  // 1
 Math.cosh(1);  // 1.5430806348152437
 Math.cosh(-1); // 1.5430806348152437
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться при помощи двух вызовов метода {{jsxref("Math.exp()")}}:</p>
 
@@ -60,7 +60,7 @@ Math.cosh(-1); // 1.5430806348152437
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -77,11 +77,11 @@ Math.cosh(-1); // 1.5430806348152437
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/e/index.html b/files/ru/web/javascript/reference/global_objects/math/e/index.html
index c4672a4495..aeecab4d20 100644
--- a/files/ru/web/javascript/reference/global_objects/math/e/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/e/index.html
@@ -10,18 +10,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/E
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Math.E</code></strong> представляет основание натурального логарифма, e, приблизительно равное 2,718.</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2,718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2,718</annotation></semantics></math></p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку свойство <code>E</code> является статическим свойством объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.E</code>, а не пытаться создавать экземпляр объекта <code>Math</code> и получать свойство от него (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.E" name="Example:_Using_Math.E">Пример: использование свойства <code>Math.E</code></h3>
+<h3 id="Example:_Using_Math.E">Пример: использование свойства <code>Math.E</code></h3>
 <p>Следующая функция возвращает e:</p>
 <pre class="brush: js">function getNapier() {
   return Math.E;
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/E
 getNapier(); // 2.718281828459045
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ getNapier(); // 2.718281828459045
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
  <li>{{jsxref("Math.log()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/exp/index.html b/files/ru/web/javascript/reference/global_objects/math/exp/index.html
index 8269046bc6..cedc4dbd8e 100644
--- a/files/ru/web/javascript/reference/global_objects/math/exp/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/exp/index.html
@@ -10,30 +10,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.exp()</code></strong> возвращает значение выражения <code>e<sup>x</sup></code>, где <code>x</code> — аргумент метода, а <code>e</code> — {{jsxref("Math.E", "число Эйлера", "", 1)}}, основание натурального логарифма.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.exp(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку метод <code>exp()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.exp()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.exp" name="Example:_Using_Math.exp">Пример: использование метода <code>Math.exp()</code></h3>
+<h3 id="Example:_Using_Math.exp">Пример: использование метода <code>Math.exp()</code></h3>
 <pre class="brush: js">Math.exp(-1); // 0.36787944117144233
 Math.exp(0);  // 1
 Math.exp(1);  // 2.718281828459045
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -59,10 +59,10 @@ Math.exp(1);  // 2.718281828459045
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.E")}}</li>
  <li>{{jsxref("Math.expm1()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/expm1/index.html b/files/ru/web/javascript/reference/global_objects/math/expm1/index.html
index 3450e3bef9..3a08b21155 100644
--- a/files/ru/web/javascript/reference/global_objects/math/expm1/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/expm1/index.html
@@ -13,35 +13,35 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.expm1()</code></strong> возвращает значение выражения <code>e<sup>x</sup> - 1</code>, где <code>x</code> — аргумент метода, а {{jsxref("Math.E", "e", "", 1)}} — основание натурального логарифма.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.expm1(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>expm1()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.expm1()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.expm1" name="Example:_Using_Math.expm1">Пример: использование метода <code>Math.expm1()</code></h3>
+<h3 id="Example:_Using_Math.expm1">Пример: использование метода <code>Math.expm1()</code></h3>
 
 <pre class="brush: js">Math.expm1(-1); // -0.6321205588285577
 Math.expm1(0);  // 0
 Math.expm1(1);  // 1.718281828459045
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться при помощи метода {{jsxref("Math.exp()")}}:</p>
 
@@ -50,7 +50,7 @@ Math.expm1(1);  // 1.718281828459045
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -67,11 +67,11 @@ Math.expm1(1);  // 1.718281828459045
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.E")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/floor/index.html b/files/ru/web/javascript/reference/global_objects/math/floor/index.html
index 7b002d968a..93addf1593 100644
--- a/files/ru/web/javascript/reference/global_objects/math/floor/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/floor/index.html
@@ -11,34 +11,34 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.floor()</code></strong> - округление вниз. Округляет аргумент до ближайшего меньшего целого.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.floor(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>floor()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.floor()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_Math.floor" name="Example:_Using_Math.floor">Пример: использование метода <code>Math.floor()</code></h3>
+<h3 id="Example_Using_Math.floor">Пример: использование метода <code>Math.floor()</code></h3>
 
 <pre class="brush: js">Math.floor( 45.95); //  45
 Math.floor(-45.95); // -46
 </pre>
 
-<h3 id="Example_Decimal_adjustment" name="Example:_Decimal_adjustment">Пример: корректировка округления десятичных дробей</h3>
+<h3 id="Example_Decimal_adjustment">Пример: корректировка округления десятичных дробей</h3>
 
 <pre class="brush: js">// Замыкание
 (function() {
@@ -110,7 +110,7 @@ Math.ceil10(-55.59, -1);   // -55.5
 Math.ceil10(-59, 1);       // -50
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -137,11 +137,11 @@ Math.ceil10(-59, 1);       // -50
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.abs()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/fround/index.html b/files/ru/web/javascript/reference/global_objects/math/fround/index.html
index 7aa84f2bc7..d9dbe8d7bc 100644
--- a/files/ru/web/javascript/reference/global_objects/math/fround/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/fround/index.html
@@ -13,28 +13,28 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/fround
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.fround()</code></strong> возвращает ближайшее число с плавающей запятой <a href="https://ru.wikipedia.org/wiki/Число_одинарной_точности">одинарной точности</a>, представляющее указанное число.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.fround(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>fround()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.fround()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.fround" name="Example:_Using_Math.fround">Пример: использование метода <code>Math.fround()</code></h3>
+<h3 id="Example:_Using_Math.fround">Пример: использование метода <code>Math.fround()</code></h3>
 
 <pre class="brush: js">Math.fround(0);     // 0
 Math.fround(1);     // 1
@@ -43,7 +43,7 @@ Math.fround(1.5);   // 1.5
 Math.fround(NaN);   // NaN
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться следующим образом, при условии, что среда выполнения поддерживает объект {{jsxref("Float32Array")}}:</p>
 
@@ -52,7 +52,7 @@ Math.fround(NaN);   // NaN
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -69,11 +69,11 @@ Math.fround(NaN);   // NaN
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.round()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/hypot/index.html b/files/ru/web/javascript/reference/global_objects/math/hypot/index.html
index 013e43e9c8..2b60c20372 100644
--- a/files/ru/web/javascript/reference/global_objects/math/hypot/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/hypot/index.html
@@ -13,24 +13,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.hypot()</code></strong> возвращает квадратный корень суммы квадратов своих аргументов, то есть</p>
 
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.hypot</mo><mo stretchy="false">(</mo><msub><mi>v</mi><mn>1</mn></msub><mo>,</mo><msub><mi>v</mi><mn>2</mn></msub><mo>,</mo><mo>…</mo><mo>,</mo><msub><mi>v</mi><mi>n</mi></msub><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mrow><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><msubsup><mi>v</mi><mi>i</mi><mn>2</mn></msubsup></mrow></msqrt><mo>=</mo><msqrt><mrow><msubsup><mi>v</mi><mn>1</mn><mn>2</mn></msubsup><mo>+</mo><msubsup><mi>v</mi><mn>2</mn><mn>2</mn></msubsup><mo>+</mo><mo>…</mo><mo>+</mo><msubsup><mi>v</mi><mi>n</mi><mn>2</mn></msubsup></mrow></msqrt></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.hypot([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value1, value2, ...</code></dt>
  <dd>Числа.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>hypot()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.hypot()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
@@ -40,9 +40,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot
 
 <p>При вызове с одним аргументом, метод <code>Math.hypot()</code> то же самое значение, что и метод <code>Math.abs()</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.hypot" name="Example:_Using_Math.hypot">Пример: использование метода <code>Math.hypot()</code></h3>
+<h3 id="Example:_Using_Math.hypot">Пример: использование метода <code>Math.hypot()</code></h3>
 
 <pre class="brush: js">Math.hypot(3, 4);        // 5
 Math.hypot(3, 4, 5);     // 7.0710678118654755
@@ -53,7 +53,7 @@ Math.hypot(3, 4, '5');   // 7.0710678118654755, +'5' =&gt; 5
 Math.hypot(-3);          // 3, то же самое, что и Math.abs(-3)
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться следующим образом:</p>
 
@@ -71,7 +71,7 @@ Math.hypot(-3);          // 3, то же самое, что и Math.abs(-3)
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -88,11 +88,11 @@ Math.hypot(-3);          // 3, то же самое, что и Math.abs(-3)
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.abs()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/imul/index.html b/files/ru/web/javascript/reference/global_objects/math/imul/index.html
index a1b7cdb0b4..9f8531b1ff 100644
--- a/files/ru/web/javascript/reference/global_objects/math/imul/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/imul/index.html
@@ -13,15 +13,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.imul()</code></strong> возвращает результат перемножения в стиле C двух 32-битных чисел.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.imul(<var>a</var>, <var>b</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>a</code></dt>
@@ -30,13 +30,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul
  <dd>Второе число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>Math.imul()</code> позволяет выполнять быстрое перемножение двух 32-битных чисел с семантикой C. Эта возможность полезна для таких проектов, как <a href="http://en.wikipedia.org/wiki/Emscripten">Emscripten</a>. Поскольку метод <code>imul()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.imul()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.imul" name="Example:_Using_Math.imul">Пример: использование метода <code>Math.imul()</code></h3>
+<h3 id="Example:_Using_Math.imul">Пример: использование метода <code>Math.imul()</code></h3>
 
 <pre class="brush: js">Math.imul(2, 4);          // 8
 Math.imul(-1, 8);         // -8
@@ -45,7 +45,7 @@ Math.imul(0xffffffff, 5); // -5
 Math.imul(0xfffffffe, 5); // -10
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться следующим способом:</p>
 
@@ -60,7 +60,7 @@ Math.imul(0xfffffffe, 5); // -10
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -77,6 +77,6 @@ Math.imul(0xfffffffe, 5); // -10
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/math/index.html b/files/ru/web/javascript/reference/global_objects/math/index.html
index e17acb9e1a..9f21a231fa 100644
--- a/files/ru/web/javascript/reference/global_objects/math/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/index.html
@@ -13,11 +13,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math
 
 <p><code>Math</code> не работает с числами типа {{jsxref("BigInt")}}.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>В отличие от других глобальных объектов, объект <code>Math</code> не является конструктором. Все свойства и методы объекта <code>Math</code> являются статическими. Вы ссылаетесь на константу π через <code>Math.PI</code> и вызываете функцию синуса через <code>Math.sin(x)</code>, где <code>x</code> является аргументом метода. Константы в JavaScript определены с полной точностью действительных чисел.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("Math.E")}}</dt>
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math
  <dd>Квадратный корень из 2, приблизительно равен 1,414.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <div class="note">
 <p>Обратите внимание, что тригонометрические функции (<code>sin()</code>, <code>cos()</code>, <code>tan()</code>, <code>asin()</code>, <code>acos()</code>, <code>atan()</code> и <code>atan2()</code>) принимают в параметрах или возвращают углы в радианах. Для преобразования радианов в градусы, поделите их на величину <code>(Math.PI / 180)</code>; для преобразования в обратном направлении, умножьте градусы на эту же величину.</p>
@@ -151,7 +151,7 @@ Math.gcd = function() {
 
 <pre><code>console.log(Math.gcd(20, 30, 15, 70, 40)); // `5`</code></pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -183,11 +183,11 @@ Math.gcd = function() {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Math")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/Number", "Number")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/ln10/index.html b/files/ru/web/javascript/reference/global_objects/math/ln10/index.html
index af6e4d4177..da0aa5499e 100644
--- a/files/ru/web/javascript/reference/global_objects/math/ln10/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/ln10/index.html
@@ -10,18 +10,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Math.LN10</code></strong> представляет натуральный логарифм из 10, приблизительно равный 2,302:</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2,302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2,302</annotation></semantics></math></p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку свойство <code>LN10</code> является статическим свойством объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.LN10</code>, а не пытаться создавать экземпляр объекта <code>Math</code> и получать свойство от него (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.LN10" name="Example:_Using_Math.LN10">Пример: использование свойства <code>Math.LN10</code></h3>
+<h3 id="Example:_Using_Math.LN10">Пример: использование свойства <code>Math.LN10</code></h3>
 <p>Следующая функция возвращает натуральный логарифм из 10:</p>
 <pre class="brush: js">function getNatLog10() {
   return Math.LN10;
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10
 getNatLog10(); // 2.302585092994046
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ getNatLog10(); // 2.302585092994046
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
  <li>{{jsxref("Math.log()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/ln2/index.html b/files/ru/web/javascript/reference/global_objects/math/ln2/index.html
index 0ec9ac752f..9023621b0e 100644
--- a/files/ru/web/javascript/reference/global_objects/math/ln2/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/ln2/index.html
@@ -10,18 +10,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Math.LN2</code></strong> представляет натуральный логарифм из 2, приблизительно равный 0,693:</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0,693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0,693</annotation></semantics></math></p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку свойство <code>LN2</code> является статическим свойством объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.LN2</code>, а не пытаться создавать экземпляр объекта <code>Math</code> и получать свойство от него (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.LN2" name="Example:_Using_Math.LN2">Пример: использование свойства <code>Math.LN2</code></h3>
+<h3 id="Example:_Using_Math.LN2">Пример: использование свойства <code>Math.LN2</code></h3>
 <p>Следующая функция возвращает натуральный логарифм из 2:</p>
 <pre class="brush: js">function getNatLog2() {
   return Math.LN2;
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2
 getNatLog2(); // 0.6931471805599453
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ getNatLog2(); // 0.6931471805599453
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
  <li>{{jsxref("Math.log()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/log/index.html b/files/ru/web/javascript/reference/global_objects/math/log/index.html
index 689357cec6..98a752abff 100644
--- a/files/ru/web/javascript/reference/global_objects/math/log/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/log/index.html
@@ -10,33 +10,33 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/log
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.log()</code></strong> возвращает натуральный (по основанию {{jsxref("Math.E", "e")}}) логарифм числа, то есть</p>
 <p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>уникальный</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{уникальный} \; y \; \text{такой, что} \; e^y = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.log(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если значение <code>x</code> меньше 0, возвращаемое значение всегда будет равным {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 <p>Поскольку метод <code>log()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.log()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.log" name="Example:_Using_Math.log">Пример: использование метода <code>Math.log()</code></h3>
+<h3 id="Example:_Using_Math.log">Пример: использование метода <code>Math.log()</code></h3>
 <pre class="brush: js">Math.log(-1); // NaN, выход за пределы диапазона
 Math.log(0);  // -Infinity
 Math.log(1);  // 0
 Math.log(10); // 2.302585092994046
 </pre>
 
-<h3 id="Example:_Using_Math.log_with_a_different_base" name="Example:_Using_Math.log_with_a_different_base">Пример: использование метода <code>Math.log()</code> с различными основаниями</h3>
+<h3 id="Example:_Using_Math.log_with_a_different_base">Пример: использование метода <code>Math.log()</code> с различными основаниями</h3>
 <p>Следующая функция возвращает логарифм из <code>y</code> по основанию <code>x</code> (то есть, <math><semantics><mrow><msub><mo>log</mo><mi>x</mi></msub><mi>y</mi></mrow><annotation encoding="TeX">\log_x y</annotation></semantics></math>):</p>
 <pre class="brush: js">function getBaseLog(x, y) {
   return Math.log(y) / Math.log(x);
@@ -44,7 +44,7 @@ Math.log(10); // 2.302585092994046
 </pre>
 <p>Если вы выполните <code>getBaseLog(10, 1000)</code>, функция вернёт <code>2.9999999999999996</code> из-за особенностей округления чисел с плавающей запятой, что довольно близко к правильному ответу — 3.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -70,10 +70,10 @@ Math.log(10); // 2.302585092994046
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
  <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/log10/index.html b/files/ru/web/javascript/reference/global_objects/math/log10/index.html
index 075f73a9b1..4b973e6ca1 100644
--- a/files/ru/web/javascript/reference/global_objects/math/log10/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/log10/index.html
@@ -14,32 +14,32 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.log10()</code></strong> возвращает десятичный (по основанию 10) логарифм числа, то есть</p>
 
 <p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log10</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>уникальный</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><msup><mn>10</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{уникальный} \; y \; \text{такой, что} \; 10^y = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.log10(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если значение <code>x</code> меньше 0, возвращаемое значение всегда будет равным {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 
 <p>Поскольку метод <code>log10()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.log10()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.log10" name="Example:_Using_Math.log10">Пример: использование метода <code>Math.log10()</code></h3>
+<h3 id="Example:_Using_Math.log10">Пример: использование метода <code>Math.log10()</code></h3>
 
 <pre class="brush: js">Math.log10(2);      // 0.3010299956639812
 Math.log10(1);      // 0
@@ -48,7 +48,7 @@ Math.log10(-2);     // NaN
 Math.log10(100000); // 5
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться следующим способом:</p>
 
@@ -57,7 +57,7 @@ Math.log10(100000); // 5
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -74,11 +74,11 @@ Math.log10(100000); // 5
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/log10e/index.html b/files/ru/web/javascript/reference/global_objects/math/log10e/index.html
index 77767fc21b..523635f176 100644
--- a/files/ru/web/javascript/reference/global_objects/math/log10e/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/log10e/index.html
@@ -10,18 +10,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Math.LOG10E</code></strong> представляет десятичный логарифм из e, приблизительно равный 0,434:</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0,434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0,434</annotation></semantics></math></p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку свойство <code>LOG10E</code> является статическим свойством объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.LOG10E</code>, а не пытаться создавать экземпляр объекта <code>Math</code> и получать свойство от него (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.LOG10E" name="Example:_Using_Math.LOG10E">Пример: использование свойства <code>Math.LOG10E</code></h3>
+<h3 id="Example:_Using_Math.LOG10E">Пример: использование свойства <code>Math.LOG10E</code></h3>
 <p>Следующая функция возвращает десятичный логарифм из e:</p>
 <pre class="brush: js">function getLog10e() {
   return Math.LOG10E;
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E
 getLog10e(); // 0.4342944819032518
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ getLog10e(); // 0.4342944819032518
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
  <li>{{jsxref("Math.log()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/log1p/index.html b/files/ru/web/javascript/reference/global_objects/math/log1p/index.html
index b6e5ebacd8..3574156edb 100644
--- a/files/ru/web/javascript/reference/global_objects/math/log1p/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/log1p/index.html
@@ -14,32 +14,32 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.log1p()</code></strong> возвращает натуральный (по основанию {{jsxref("Math.E", "e")}}) логарифм 1 + числа, то есть</p>
 
 <p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mo>-</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log1p</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\forall x &gt; -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.log1p(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если значение <code>x</code> меньше -1, возвращаемое значение всегда будет равным {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 
 <p>Поскольку метод <code>log1p()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.log1p()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.log1p" name="Example:_Using_Math.log1p">Пример: использование метода <code>Math.log1p()</code></h3>
+<h3 id="Example:_Using_Math.log1p">Пример: использование метода <code>Math.log1p()</code></h3>
 
 <pre class="brush: js">Math.log1p(1);  // 0.6931471805599453
 Math.log1p(0);  // 0
@@ -47,7 +47,7 @@ Math.log1p(-1); // -Infinity
 Math.log1p(-2); // NaN
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться следующим способом:</p>
 
@@ -56,7 +56,7 @@ Math.log1p(-2); // NaN
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -73,11 +73,11 @@ Math.log1p(-2); // NaN
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/log2/index.html b/files/ru/web/javascript/reference/global_objects/math/log2/index.html
index 3bf66ef0b7..adafdfb850 100644
--- a/files/ru/web/javascript/reference/global_objects/math/log2/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/log2/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.log2()</code></strong> возвращает двоичный (по основанию 2) логарифм числа, то есть</p>
 
@@ -21,26 +21,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2
 
 
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.log2(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если значение <code>x</code> меньше 0, возвращаемое значение всегда будет равным {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 
 <p>Поскольку метод <code>log2()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.log2()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_Math.log2" name="Example:_Using_Math.log2">Пример: использование метода <code>Math.log2()</code></h3>
+<h3 id="Example_Using_Math.log2">Пример: использование метода <code>Math.log2()</code></h3>
 
 <pre class="brush: js">Math.log2(3);    // 1.584962500721156
 Math.log2(2);    // 1
@@ -50,7 +50,7 @@ Math.log2(-2);   // NaN
 Math.log2(1024); // 10
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться следующим способом:</p>
 
@@ -59,7 +59,7 @@ Math.log2(1024); // 10
 };
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -76,10 +76,10 @@ Math.log2(1024); // 10
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat("javascript.builtins.Math.log2")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/log2e/index.html b/files/ru/web/javascript/reference/global_objects/math/log2e/index.html
index 489a2d3bdb..12093b963b 100644
--- a/files/ru/web/javascript/reference/global_objects/math/log2e/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/log2e/index.html
@@ -10,18 +10,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Math.LOG2E</code></strong> представляет двоичный логарифм из e, приблизительно равный 1,442:</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1,442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1,442</annotation></semantics></math></p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку свойство <code>LOG2E</code> является статическим свойством объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.LOG2E</code>, а не пытаться создавать экземпляр объекта <code>Math</code> и получать свойство от него (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.LOG2E" name="Example:_Using_Math.LOG2E">Пример: использование свойства <code>Math.LOG2E</code></h3>
+<h3 id="Example:_Using_Math.LOG2E">Пример: использование свойства <code>Math.LOG2E</code></h3>
 <p>Следующая функция возвращает двоичный логарифм из e:</p>
 <pre class="brush:js">function getLog2e() {
   return Math.LOG2E;
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E
 getLog2e(); // 1.4426950408889634
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ getLog2e(); // 1.4426950408889634
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.exp()")}}</li>
  <li>{{jsxref("Math.log()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/max/index.html b/files/ru/web/javascript/reference/global_objects/math/max/index.html
index 2ff7862643..613c7dd982 100644
--- a/files/ru/web/javascript/reference/global_objects/math/max/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/max/index.html
@@ -10,22 +10,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/max
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.max()</code></strong> возвращает наибольшее из нуля или более чисел.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.max([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value1, value2, ...</code></dt>
  <dd>Числа.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>max()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.max()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
@@ -33,9 +33,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/max
 
 <p>Если хотя бы один из аргументов не может быть преобразован в число, результатом будет {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_Math.max" name="Example:_Using_Math.max">Пример: использование метода <code>Math.max()</code></h3>
+<h3 id="Example_Using_Math.max">Пример: использование метода <code>Math.max()</code></h3>
 
 <pre class="brush: js">Math.max(10, 20);   //  20
 Math.max(-10, -20); // -10
@@ -51,7 +51,7 @@ Math.max(-10, 20);  //  20
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -78,11 +78,11 @@ Math.max(-10, 20);  //  20
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.min()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/min/index.html b/files/ru/web/javascript/reference/global_objects/math/min/index.html
index 58df2f82c9..4c66b6f3d0 100644
--- a/files/ru/web/javascript/reference/global_objects/math/min/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/min/index.html
@@ -10,22 +10,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/min
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.min()</code></strong> возвращает наименьшее из нуля или более чисел.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.min([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value1, value2, ...</code></dt>
  <dd>Числа.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>min()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.min()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
@@ -33,9 +33,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/min
 
 <p>Если хотя бы один из аргументов не может быть преобразован в число, результатом будет {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.min" name="Example:_Using_Math.min">Пример: использование метода <code>Math.min()</code></h3>
+<h3 id="Example:_Using_Math.min">Пример: использование метода <code>Math.min()</code></h3>
 
 <p>В этом примере ищется минимум из <code>x</code> и <code>y</code> и присваивается переменной <code>z</code>:</p>
 
@@ -43,7 +43,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/min
 var z = Math.min(x, y);
 </pre>
 
-<h3 id="Example:_Clipping_a_value_with_Math.min" name="Example:_Clipping_a_value_with_Math.min">Пример: обрезание значения при помощи метода <code>Math.min()</code></h3>
+<h3 id="Example:_Clipping_a_value_with_Math.min">Пример: обрезание значения при помощи метода <code>Math.min()</code></h3>
 
 <p>Метод <code>Math.min()</code> часто используется для обрезания значения таким образом, чтобы оно всегда не превосходило некоторую границу. Например, такое условие</p>
 
@@ -61,7 +61,7 @@ if (x &gt; boundary) {
 
 <p>Подобным образом может использоваться и метод {{jsxref("Math.max()")}} для обрезания значения по нижней границе.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -88,11 +88,11 @@ if (x &gt; boundary) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.max()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/pi/index.html b/files/ru/web/javascript/reference/global_objects/math/pi/index.html
index c7f67a73f2..ef5243b10d 100644
--- a/files/ru/web/javascript/reference/global_objects/math/pi/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/pi/index.html
@@ -10,18 +10,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Math.PI</code></strong> представляет отношение длины окружности круга к его диаметру, приблизительно равное 3,14159:</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3,14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3,14159</annotation></semantics></math></p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку свойство <code>PI</code> является статическим свойством объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.PI</code>, а не пытаться создавать экземпляр объекта <code>Math</code> и получать свойство от него (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_PI" name="Example:_Using_PI">Пример: использование свойства <code>Math.PI</code></h3>
+<h3 id="Example:_Using_PI">Пример: использование свойства <code>Math.PI</code></h3>
 <p>Следующая функция использует значение <code>Math.PI</code> для вычисления длины окружности по известному радиусу круга.</p>
 <pre class="brush: js">function calculateCircumference(radius) {
   return 2 * Math.PI * radius;
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI
 calculateCircumference(1);  // 6.283185307179586
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ calculateCircumference(1);  // 6.283185307179586
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Global_Objects/Math", "Math")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/math/pow/index.html b/files/ru/web/javascript/reference/global_objects/math/pow/index.html
index b43e530db8..7db557f736 100644
--- a/files/ru/web/javascript/reference/global_objects/math/pow/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/pow/index.html
@@ -10,15 +10,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.pow()</code></strong> возвращает <code>основание</code>, возведённое в степень <code>показатель</code>, то есть, значение выражения <code>основание<sup>показатель</sup></code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.pow(<var>base</var>, <var>exponent</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>base</code></dt>
@@ -27,17 +27,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow
  <dd>Показатель степени, в которую возводится основание <code>base</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>pow()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.pow()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.pow" name="Example:_Using_Math.pow">Пример: использование метода <code>Math.pow()</code></h3>
+<h3 id="Example:_Using_Math.pow">Пример: использование метода <code>Math.pow()</code></h3>
 
 <pre class="brush: js">Math.pow(7, 2); // 49</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -64,11 +64,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.cbrt()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/random/index.html b/files/ru/web/javascript/reference/global_objects/math/random/index.html
index 4fc7d8f250..04bb6ba47d 100644
--- a/files/ru/web/javascript/reference/global_objects/math/random/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/random/index.html
@@ -19,15 +19,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
 <p><strong>Примечание:</strong> метод <code>Math.random()</code> <em>не предоставляет</em> криптографически стойкие случайные числа. Не используйте его ни для чего, связанного с безопасностью. Вместо него используйте Web Crypto API (API криптографии в вебе) и более точный метод {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.random()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Возвращаемое значение</h3>
+<h3 id="Parameters">Возвращаемое значение</h3>
 
 <p>Псевдослучайное число с плавающей запятой от <code>0</code> (включительно) до 1 (не считая).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <p>Обратите внимание, что поскольку числа в JavaScript являются числами с плавающей запятой стандарта IEEE 754 с поведением при округлении к ближайшему чётному, все эти диапазоны (исключая диапазон с простым вызовом <code>Math.random()</code>), не точны. Если заданы очень большие границы (2<sup>53</sup> или выше), возможен <em>крайне</em> редкий случай вычисления обычно исключённой верхней границы.</p>
 
@@ -69,7 +69,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
   return Math.floor(Math.random() * (max - min + 1)) + min; //Максимум и минимум включаются
 }</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -101,7 +101,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Math.random")}}</p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/math/round/index.html b/files/ru/web/javascript/reference/global_objects/math/round/index.html
index 30b0f1f6aa..8986efe508 100644
--- a/files/ru/web/javascript/reference/global_objects/math/round/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/round/index.html
@@ -10,30 +10,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/round
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.round()</code></strong> возвращает число, округлённое к ближайшему целому.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.round(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если дробная часть числа больше, либо равна 0,5, аргумент будет округлён до ближайшего большего целого. Если дробная часть числа меньше 0,5, аргумент будет округлён до ближайшего меньшего целого.</p>
 
 <p>Поскольку метод <code>round()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.round()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.round" name="Example:_Using_Math.round">Пример: использование метода <code>Math.round()</code></h3>
+<h3 id="Example:_Using_Math.round">Пример: использование метода <code>Math.round()</code></h3>
 
 <pre class="brush: js">// Вернёт значение 20
 x = Math.round(20.49);
@@ -53,7 +53,7 @@ x = Math.round(-20.51);
 x = Math.round(1.005*100)/100;
 </pre>
 
-<h3 id="Example:_Decimal_rounding" name="Example:_Decimal_rounding">Пример: корректировка округления десятичных дробей</h3>
+<h3 id="Example:_Decimal_rounding">Пример: корректировка округления десятичных дробей</h3>
 
 <pre class="brush: js">// Замыкание
 (function() {
@@ -126,7 +126,7 @@ Math.ceil10(-55.59, -1);   // -55.5
 Math.ceil10(-59, 1);       // -50
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -153,11 +153,11 @@ Math.ceil10(-59, 1);       // -50
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.abs()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/sign/index.html b/files/ru/web/javascript/reference/global_objects/math/sign/index.html
index b45d98058b..b1c6a831f0 100644
--- a/files/ru/web/javascript/reference/global_objects/math/sign/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/sign/index.html
@@ -13,22 +13,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.sign()</code></strong> возвращает знак числа, указывающий на то, является ли число отрицательным, положительным или нулём.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.sign(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>sign()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.sign()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
@@ -36,9 +36,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign
 
 <p>Обратите внимание, что аргумент, переданный в этот метод, будет неявно преобразован в число.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.sign" name="Example:_Using_Math.sign">Пример: использование метода <code>Math.sign()</code></h3>
+<h3 id="Example:_Using_Math.sign">Пример: использование метода <code>Math.sign()</code></h3>
 
 <pre class="brush: js">Math.sign(3);     //  1
 Math.sign(-3);    // -1
@@ -50,7 +50,7 @@ Math.sign('foo'); // NaN
 Math.sign();      // NaN
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">Math.sign = Math.sign || function(x) {
   x = +x; // преобразуем в число
@@ -61,7 +61,7 @@ Math.sign();      // NaN
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -78,11 +78,11 @@ Math.sign();      // NaN
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.abs()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/sin/index.html b/files/ru/web/javascript/reference/global_objects/math/sin/index.html
index 32bd79d245..e090f08645 100644
--- a/files/ru/web/javascript/reference/global_objects/math/sin/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/sin/index.html
@@ -10,32 +10,32 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.sin()</code></strong> возвращает синус числа.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.sin(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>x</code></dt>
  <dd>Число радиан.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>Math.sin()</code> возвращает числовое значение от -1 до 1, которое представляет синус переданного (в радианах) угла.</p>
 <p>Поскольку метод <code>sin()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.sin()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.sin" name="Example:_Using_Math.sin">Пример: использование метода <code>Math.sin()</code></h3>
+<h3 id="Example:_Using_Math.sin">Пример: использование метода <code>Math.sin()</code></h3>
 <pre class="brush: js">Math.sin(0);           // 0
 Math.sin(1);           // 0.8414709848078965
 
 Math.sin(Math.PI / 2); // 1
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -61,10 +61,10 @@ Math.sin(Math.PI / 2); // 1
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.acos()")}}</li>
  <li>{{jsxref("Math.asin()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/sinh/index.html b/files/ru/web/javascript/reference/global_objects/math/sinh/index.html
index 7d81968fe5..e72957475c 100644
--- a/files/ru/web/javascript/reference/global_objects/math/sinh/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/sinh/index.html
@@ -14,36 +14,36 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.sinh()</code></strong> возвращает гиперболический синус числа, который может быть выражен через {{jsxref("Math.E", "число e", "", 1)}}:</p>
 
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.sinh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.sinh(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>sinh()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.sinh()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.sinh" name="Example:_Using_Math.sinh">Пример: использование метода <code>Math.sinh()</code></h3>
+<h3 id="Example:_Using_Math.sinh">Пример: использование метода <code>Math.sinh()</code></h3>
 
 <pre class="brush: js">Math.sinh(0); // 0
 Math.sinh(1); // 1.1752011936438014
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться при помощи двух вызовов метода {{jsxref("Math.exp()")}}:</p>
 
@@ -60,7 +60,7 @@ Math.sinh(1); // 1.1752011936438014
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -77,11 +77,11 @@ Math.sinh(1); // 1.1752011936438014
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/sqrt/index.html b/files/ru/web/javascript/reference/global_objects/math/sqrt/index.html
index 50bb9ea13b..21c1203c04 100644
--- a/files/ru/web/javascript/reference/global_objects/math/sqrt/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/sqrt/index.html
@@ -10,17 +10,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.sqrt()</code></strong> возвращает квадратный корень числа, то есть</p>
 
 <p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>уникальный</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>такой, что</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{уникальный} \; y \geq 0 \; \text{такой, что} \; y^2 = x</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.sqrt(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
@@ -31,15 +31,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt
 
 <p>Квадратный корень заданного числа. Если число отрицательное, то вернётся {{jsxref("NaN")}}.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если значение <code>x</code> отрицательно, метод <code>Math.sqrt()</code> вернёт {{jsxref("NaN")}}.</p>
 
 <p>Поскольку метод <code>sqrt()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.sqrt()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.sqrt" name="Example:_Using_Math.sqrt">Пример: использование метода <code>Math.sqrt()</code></h3>
+<h3 id="Example:_Using_Math.sqrt">Пример: использование метода <code>Math.sqrt()</code></h3>
 
 <pre class="brush: js">Math.sqrt(9); // 3
 Math.sqrt(2); // 1.414213562373095
@@ -49,7 +49,7 @@ Math.sqrt(0);  // 0
 Math.sqrt(-1); // NaN
 Math.sqrt(-0); // -0</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -81,11 +81,11 @@ Math.sqrt(-0); // -0</pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.cbrt()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/sqrt1_2/index.html b/files/ru/web/javascript/reference/global_objects/math/sqrt1_2/index.html
index 0d05badb92..b8b400df09 100644
--- a/files/ru/web/javascript/reference/global_objects/math/sqrt1_2/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/sqrt1_2/index.html
@@ -10,18 +10,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Math.SQRT1_2</code></strong> представляет квадратный корень из 1/2, приблизительно равный 0,707:</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0,707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0,707</annotation></semantics></math></p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку свойство <code>SQRT1_2</code> является статическим свойством объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.SQRT1_2</code>, а не пытаться создавать экземпляр объекта <code>Math</code> и получать свойство от него (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.SQRT1_2" name="Example:_Using_Math.SQRT1_2">Пример: использование свойства <code>Math.SQRT1_2</code></h3>
+<h3 id="Example:_Using_Math.SQRT1_2">Пример: использование свойства <code>Math.SQRT1_2</code></h3>
 <p>Следующая функция возвращает единицу, делённую на квадратный корень из двух:</p>
 <pre class="brush: js">function getRoot1_2() {
   return Math.SQRT1_2;
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2
 getRoot1_2(); // 0.7071067811865476
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ getRoot1_2(); // 0.7071067811865476
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.pow()")}}</li>
  <li>{{jsxref("Math.sqrt()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/sqrt2/index.html b/files/ru/web/javascript/reference/global_objects/math/sqrt2/index.html
index 72f0069835..642817b26b 100644
--- a/files/ru/web/javascript/reference/global_objects/math/sqrt2/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/sqrt2/index.html
@@ -10,18 +10,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Math.SQRT2</code></strong> представляет квадратный корень из 2, приблизительно равный 1,414:</p>
 <p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1,414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1,414</annotation></semantics></math></p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Поскольку свойство <code>SQRT2</code> является статическим свойством объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.SQRT2</code>, а не пытаться создавать экземпляр объекта <code>Math</code> и получать свойство от него (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.SQRT2" name="Example:_Using_Math.SQRT2">Пример: использование свойства <code>Math.SQRT2</code></h3>
+<h3 id="Example:_Using_Math.SQRT2">Пример: использование свойства <code>Math.SQRT2</code></h3>
 <p>Следующая функция возвращает квадратный корень из двух:</p>
 <pre class="brush: js">function getRoot2() {
   return Math.SQRT2;
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2
 getRoot2(); // 1.4142135623730951
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ getRoot2(); // 1.4142135623730951
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.pow()")}}</li>
  <li>{{jsxref("Math.sqrt()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/tan/index.html b/files/ru/web/javascript/reference/global_objects/math/tan/index.html
index f48b36ecc3..377813f9ac 100644
--- a/files/ru/web/javascript/reference/global_objects/math/tan/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/tan/index.html
@@ -10,25 +10,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Math.tan()</code></strong> возвращает тангенс числа.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Math.tan(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>x</code></dt>
  <dd>Число, представляющее угол в радианах.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>Math.tan()</code> возвращает числовое значение, представляющее тангенс угла.</p>
 <p>Поскольку метод <code>tan()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.tan()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.tan" name="Example:_Using_Math.tan">Пример: использование метода <code>Math.tan()</code></h3>
+<h3 id="Example:_Using_Math.tan">Пример: использование метода <code>Math.tan()</code></h3>
 <pre class="brush: js">Math.tan(1); // 1.5574077246549023
 </pre>
 <p>Поскольку метод <code>Math.tan()</code> принимает радианы, а чаще проще работать с градусами, следующая функция принимает значение в градусах, преобразует их в радианы и возвращает тангенс.</p>
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -64,10 +64,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Math.acos()")}}</li>
  <li>{{jsxref("Math.asin()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/tanh/index.html b/files/ru/web/javascript/reference/global_objects/math/tanh/index.html
index d08a22559c..605d0dd504 100644
--- a/files/ru/web/javascript/reference/global_objects/math/tanh/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/tanh/index.html
@@ -14,37 +14,37 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh
 ---
 <div>{{JSRef("Global_Objects", "Math")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Math.tanh()</code></strong> возвращает гиперболический тангенс числа, то есть</p>
 
 <p><math display="block"><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><mrow><mo lspace="0em" rspace="0em">cosh</mo><mi>x</mi></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>-</mo><mn>1</mn></mrow><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>+</mo><mn>1</mn></mrow></mfrac></mrow><annotation encoding="TeX">\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}</annotation></semantics></math></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Math.tanh(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>tanh()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.tanh()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> (поскольку объект <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.tanh" name="Example:_Using_Math.tanh">Пример: использование метода <code>Math.tanh()</code></h3>
+<h3 id="Example:_Using_Math.tanh">Пример: использование метода <code>Math.tanh()</code></h3>
 
 <pre class="brush: js">Math.tanh(0);        // 0
 Math.tanh(Infinity); // 1
 Math.tanh(1);        // 0.7615941559557649
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод может эмулироваться при помощи двух вызовов метода {{jsxref("Math.exp()")}}:</p>
 
@@ -73,7 +73,7 @@ Math.tanh(1);        // 0.7615941559557649
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -90,11 +90,11 @@ Math.tanh(1);        // 0.7615941559557649
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/math/trunc/index.html b/files/ru/web/javascript/reference/global_objects/math/trunc/index.html
index e41d42332d..a6cfec1f67 100644
--- a/files/ru/web/javascript/reference/global_objects/math/trunc/index.html
+++ b/files/ru/web/javascript/reference/global_objects/math/trunc/index.html
@@ -23,26 +23,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc
 </div>
 
 <p>
- </p><h2 id="Syntax" name="Syntax">Синтаксис</h2>
+ </p><h2 id="Syntax">Синтаксис</h2>
 <p></p>
 
 <pre class="syntaxbox"><code>Math.trunc(<var>x</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Число.</dd>
 </dl>
 
-<h3 id="Parameters" name="Parameters">Возвращаемое значение</h3>
+<h3 id="Parameters">Возвращаемое значение</h3>
 
 <dl>
  <dt><code>x</code></dt>
  <dd>Целая часть данного числа.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>В отличие от других трёх методов объекта <code>Math</code> — {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} и {{jsxref("Math.round()")}} — метод <code>Math.trunc()</code> работает очень просто. Отбрасывается запятая и все цифры после неё, не обращая внимания на знак аргумента.</p>
 
@@ -50,9 +50,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc
 
 <p>Поскольку <code>trunc()</code> является статическим методом объекта <code>Math</code>, вы всегда должны использовать его как <code>Math.trunc()</code>, а не пытаться вызывать метод на созданном экземпляре объекта <code>Math</code> ( <code>Math</code> не является конструктором).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Math.trunc" name="Example:_Using_Math.trunc">Использование <code>Math.trunc()</code></h3>
+<h3 id="Example:_Using_Math.trunc">Использование <code>Math.trunc()</code></h3>
 
 <pre class="brush: js">Math.trunc(13.37);    // 13
 Math.trunc(42.84);    // 42
@@ -64,7 +64,7 @@ Math.trunc('foo');    // NaN
 Math.trunc();         // NaN
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">if (!Math.trunc) {
 	Math.trunc = function(v) {
diff --git a/files/ru/web/javascript/reference/global_objects/nan/index.html b/files/ru/web/javascript/reference/global_objects/nan/index.html
index 85a1325f30..353cc35619 100644
--- a/files/ru/web/javascript/reference/global_objects/nan/index.html
+++ b/files/ru/web/javascript/reference/global_objects/nan/index.html
@@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/NaN
 ---
 <div>{{jsSidebar("Objects")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Глобальное свойство <code><strong>NaN</strong></code> является значением, представляющим не-число (Not-A-Number).</p>
 
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/NaN
 <p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
 </div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p><code>NaN</code> является свойством <em>глобального объекта</em>.</p>
 
@@ -31,7 +31,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/NaN
 
 <p>В программах <code>NaN</code> используется довольно редко. Это возвращаемое значение в ситуациях, когда математические ({{jsxref("Math")}}) функции не срабатывают должным образом (например, при вызове <code>Math.sqrt(-1)</code>) или когда функция, пытающаяся считать число из строки, терпит неудачу по причине того, что в строке не число (<code>parseInt('blabla')</code>).</p>
 
-<h3 id="Testing_against_NaN" name="Testing_against_NaN">Проверка на равенство <code>NaN</code></h3>
+<h3 id="Testing_against_NaN">Проверка на равенство <code>NaN</code></h3>
 
 <p><code>NaN</code> является неравным (посредством сравнения через <code>==</code>, <code>!=</code>, <code>===</code>, and <code>!==</code>) любому другому значению, включая другое значение NaN. Используйте {{jsxref("Number.isNaN()")}} или {{jsxref("Global_Objects/isNaN", "isNaN()")}}, чтобы наиболее понятным образом определить является ли значение значением NaN. Или выполните само-сравнение: NaN, и только NaN, в результате такого сравнения будет неравным самому себе.</p>
 
@@ -50,7 +50,7 @@ valueIsNaN(Number.NaN); // true</code></pre>
 <pre><code>isNaN('hello world');        // true
 Number.isNaN('hello world'); // false</code></pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -82,7 +82,7 @@ Number.isNaN('hello world'); // false</code></pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.NaN")}}</p>
 
@@ -90,7 +90,7 @@ Number.isNaN('hello world'); // false</code></pre>
 
 <div id="compat-mobile"></div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.NaN")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/null/index.html b/files/ru/web/javascript/reference/global_objects/null/index.html
index 940df2e928..6cdeef8516 100644
--- a/files/ru/web/javascript/reference/global_objects/null/index.html
+++ b/files/ru/web/javascript/reference/global_objects/null/index.html
@@ -19,11 +19,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/null
 <p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>null</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Значение <code>null</code> записывается литералом <code>null</code>. Оно является самостоятельным, а не свойством глобального объекта (как {{jsxref("Global_Objects/undefined", "undefined")}}). В API, <code>null</code> часто присутствует в местах где ожидается объект, но подходящего объекта нет.</p>
 
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/null
 
 
 
-<h3 id="Difference_between_null_and_undefined" name="Difference_between_null_and_undefined">Отличия между <code>null</code> и <code>undefined</code></h3>
+<h3 id="Difference_between_null_and_undefined">Отличия между <code>null</code> и <code>undefined</code></h3>
 
 <p><code>null</code> является определённым значением отсутствия объекта, тогда как {{jsxref("Global_Objects/undefined", "undefined")}} обозначает неопределённость. Например: </p>
 
@@ -58,7 +58,7 @@ null === undefined // false
 null  == undefined // true
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -90,11 +90,11 @@ null  == undefined // true
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.null")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/undefined", "undefined")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/epsilon/index.html b/files/ru/web/javascript/reference/global_objects/number/epsilon/index.html
index ae855c81d4..9ec6bbd626 100644
--- a/files/ru/web/javascript/reference/global_objects/number/epsilon/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/epsilon/index.html
@@ -17,13 +17,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Свойство <code>EPSILON</code> имеет значение, приблизительно равное <code>2.2204460492503130808472633361816E-16</code> или <code>2<sup>-52</sup></code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Testing_equality" name="Example:_Testing_equality">Проверка на равенство</h3>
+<h3 id="Example_Testing_equality">Проверка на равенство</h3>
 
 <pre><code>x = 0.2;
 y = 0.3;
@@ -32,7 +32,7 @@ equal = (Math.abs(x - y + z) &lt; Number.EPSILON);</code></pre>
 
 
 
-<h2 id="Examples" name="Examples">Полифил</h2>
+<h2 id="Examples">Полифил</h2>
 
 <pre class="brush: js">if (Number.EPSILON === undefined) {
     Number.EPSILON = Math.pow(2, -52);
@@ -41,7 +41,7 @@ equal = (Math.abs(x - y + z) &lt; Number.EPSILON);</code></pre>
 
 
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -63,11 +63,11 @@ equal = (Math.abs(x - y + z) &lt; Number.EPSILON);</code></pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Объект {{jsxref("Number")}}, которому принадлежит это свойство.</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/index.html b/files/ru/web/javascript/reference/global_objects/number/index.html
index d245791c22..988a0610ac 100644
--- a/files/ru/web/javascript/reference/global_objects/number/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number
 
 <p>Объект <strong><code>Number</code></strong> является объектом-обёрткой, позволяющей вам работать с числовыми значениями. Объект <code>Number</code> создаётся через конструктор <code>Number()</code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre>new Number(<em>value</em>);
 var <em>a</em> = new Number('123'); // a === 123 is false
@@ -19,14 +19,14 @@ var <em>b</em> = Number('123'); // b === 123 is true
 <em>a</em> instanceof Number; // is true
 <em>b</em> instanceof Number; // is false</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value</code></dt>
  <dd>Числовое значение, которое примет объект после создания.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Несколько замечаний относительно использования объекта <code>Number</code>:</p>
 
@@ -35,7 +35,7 @@ var <em>b</em> = Number('123'); // b === 123 is true
  <li>В неконструкторном контексте (то есть, без оператора {{jsxref("Operators/new", "new")}}), объект <code>Number</code> может использоваться для проведения преобразования типов.</li>
 </ul>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("Number.EPSILON")}} {{experimental_inline}}</dt>
@@ -60,7 +60,7 @@ var <em>b</em> = Number('123'); // b === 123 is true
 
 <div>{{jsOverrides("Function", "properties", "MAX_VALUE", "MIN_VALUE", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY", "protoype")}}</div>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <dl>
  <dt>{{jsxref("Number.isNaN()")}} {{experimental_inline}}</dt>
@@ -81,17 +81,17 @@ var <em>b</em> = Number('123'); // b === 123 is true
 
 <div>{{jsOverrides("Function", "methods", "isNaN")}}</div>
 
-<h2 id="Number_instances" name="Number_instances">Экземпляры объекта <code>Number</code></h2>
+<h2 id="Number_instances">Экземпляры объекта <code>Number</code></h2>
 
 <p>Все экземпляры объекта <code>Number</code> наследуются от {{jsxref("Number.prototype")}}. Объект прототипа конструктора <code>Number</code> может быть изменён, чтобы затронуть все экземпляры объекта <code>Number</code>.</p>
 
-<h3 id="Methods_of_Number_instance" name="Methods_of_Number_instance">Методы</h3>
+<h3 id="Methods_of_Number_instance">Методы</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Number/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_the_Number_object_to_assign_values_to_numeric_variables" name="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables">Пример: использование объекта <code>Number</code> для присваивания значений числовым переменным</h3>
+<h3 id="Example_Using_the_Number_object_to_assign_values_to_numeric_variables">Пример: использование объекта <code>Number</code> для присваивания значений числовым переменным</h3>
 
 <p>В следующем примере для присваивания значений числовым переменным используются свойства объекта <code>Number</code>:</p>
 
@@ -102,7 +102,7 @@ var negInfiniteNum = Number.NEGATIVE_INFINITY;
 var notANum = Number.NaN;
 </pre>
 
-<h3 id="Example_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object">Пример: целочисленный диапазон для объекта <code>Number</code></h3>
+<h3 id="Example_Using_Number_to_convert_a_Date_object">Пример: целочисленный диапазон для объекта <code>Number</code></h3>
 
 <p>Следующий пример показывает, какие минимальное и максимальное целочисленные значения может представить объект <code>Number</code> (за подробностями обращайтесь к стандарту EcmaScript, главе <em>8.5 Тип Number</em>):</p>
 
@@ -112,7 +112,7 @@ var smallestInt = -9007199254740992;
 
 <p>При разборе данных, сериализованных в JSON, можно ожидать, что целые значения, выпадающие из этого диапазона будут повреждены, когда парсер JSON приведёт их к типу <code>Number</code>. Возможным обходным путём может быть использование объекта {{jsxref("Global_Objects/String", "String")}}.</p>
 
-<h3 id="Example_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object">Пример: использование <code>Number</code> для преобразования объекта <code>Date</code></h3>
+<h3 id="Example_Using_Number_to_convert_a_Date_object">Пример: использование <code>Number</code> для преобразования объекта <code>Date</code></h3>
 
 <p>В следующем примере объект {{jsxref("Global_Objects/Date", "Date")}} преобразуется в числовое значение с использование объекта <code>Number</code> в качестве функции:</p>
 
@@ -122,7 +122,7 @@ console.log(Number(d));
 
 <p>Пример выведет "819199440000".</p>
 
-<h3 id="Example_Convert_numeric_strings_to_numbers" name="Example:_Convert_numeric_strings_to_numbers">Пример: преобразование строк с числами в числа</h3>
+<h3 id="Example_Convert_numeric_strings_to_numbers">Пример: преобразование строк с числами в числа</h3>
 
 <pre class="brush: js">Number('123')     // 123
 Number('')        // 0
@@ -133,7 +133,7 @@ Number('foo')     // NaN
 Number('100a')    // NaN
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -165,11 +165,11 @@ Number('100a')    // NaN
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Number")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/isfinite/index.html b/files/ru/web/javascript/reference/global_objects/number/isfinite/index.html
index 43c225005b..865c5d154f 100644
--- a/files/ru/web/javascript/reference/global_objects/number/isfinite/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/isfinite/index.html
@@ -13,26 +13,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Number.isFinite()</code></strong> определяет, является ли переданное значение конечным числом.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Number.isFinite(<var>testValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>testValue</code></dt>
  <dd>Значение, проверяемое на конечность.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>В отличии от глобальной функции {{jsxref("Global_Objects/isFinite", "isFinite()")}}, этот метод принудительно не преобразует параметр в число. Это означает, что он возвращает <code>true</code> только для конечных значений числового типа.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">Number.isFinite(Infinity);  // false
 Number.isFinite(NaN);       // false
@@ -45,14 +45,14 @@ Number.isFinite('0');       // false, при использовании глоб
                             // функции isFinite('0') было бы true
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">Number.isFinite = Number.isFinite || function(value) {
   return typeof value === 'number' &amp;&amp; isFinite(value);
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -71,11 +71,11 @@ Number.isFinite('0');       // false, при использовании глоб
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Объект {{jsxref("Global_Objects/Number", "Number")}}, которому принадлежит этот метод.</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/isinteger/index.html b/files/ru/web/javascript/reference/global_objects/number/isinteger/index.html
index 5bcd056176..12ec1573f1 100644
--- a/files/ru/web/javascript/reference/global_objects/number/isinteger/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/isinteger/index.html
@@ -16,11 +16,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger
 
 
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Number.isInteger(<var>value</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value</code></dt>
@@ -31,11 +31,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger
 
 <p>{{jsxref("Boolean")}} сообщающий о том, является ли переданное значение целочисленным числом.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если целевое значение является целым числом, возвращает <code>true</code>. Если значение {{jsxref("NaN")}} или {{jsxref("Infinity")}}, то возвращает <code>false</code>. Метод также возвращает <code>true</code>, если это вещественное число с точкой, которое может быть представлено в целочисленном виде.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">Number.isInteger(0);         // true
 Number.isInteger(1);         // true
@@ -57,7 +57,7 @@ Number.isInteger(5.0);       // true
 Number.isInteger(5.000000000000001); // false
 Number.isInteger(5.0000000000000001); // true</pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">Number.isInteger = Number.isInteger || function(value) {
   return typeof value === 'number' &amp;&amp;
@@ -65,7 +65,7 @@ Number.isInteger(5.0000000000000001); // true</pre>
     Math.floor(value) === value;
 };</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -80,7 +80,7 @@ Number.isInteger(5.0000000000000001); // true</pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 
 
@@ -88,7 +88,7 @@ Number.isInteger(5.0000000000000001); // true</pre>
 
 <div>{{Compat("javascript.builtins.Number.isInteger")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Объект {{jsxref("Number")}}, которому принадлежит этот метод.</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/isnan/index.html b/files/ru/web/javascript/reference/global_objects/number/isnan/index.html
index 9cac268d96..416fe1d3ba 100644
--- a/files/ru/web/javascript/reference/global_objects/number/isnan/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/isnan/index.html
@@ -13,28 +13,28 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Number.isNaN()</code></strong> определяет, является ли переданное значение {{jsxref("Global_Objects/NaN", "NaN")}}. Это более надёжная версия оригинальной глобальной функции {{jsxref("Global_Objects/isNaN", "isNaN()")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Number.isNaN(<var>value</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value</code></dt>
  <dd>Значение, проверяемое на {{jsxref("Global_Objects/NaN", "NaN")}}.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку оба оператора проверки на равенство, {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} и {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}, вычисляются в <code>false</code> при проверке, что {{jsxref("Global_Objects/NaN", "NaN")}} <em>и есть</em> {{jsxref("Global_Objects/NaN", "NaN")}}, появляется необходимость в функции <code>Number.isNaN()</code>. Эта ситуация отличается от всех других возможных сравнений в JavaScript.</p>
 
 <p>В отличие от глобальной функции {{jsxref("Global_Objects/isNaN", "isNaN()")}}, <code>Number.isNaN()</code> не имеет проблемы принудительного преобразования параметра в число. Это значит, что в него безопасно передавать значения, которые обычно превращаются в {{jsxref("Global_Objects/NaN", "NaN")}}, но на самом деле {{jsxref("Global_Objects/NaN", "NaN")}} не являются. Также это значит, что метод возвращает <code>true</code> только для числовых значений, имеющих значение {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">Number.isNaN(NaN); // true
 Number.isNaN(Number.NaN); // true
@@ -56,14 +56,14 @@ Number.isNaN('');
 Number.isNaN(' ');
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">Number.isNaN = Number.isNaN || function(value) {
   return typeof value === 'number' &amp;&amp; isNaN(value);
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -85,7 +85,7 @@ Number.isNaN(' ');
 <h2 id="Совместимость_с_браузерами">Совместимость с браузерами</h2>
 <p>{{Compat("javascript.builtins.Number.isNaN")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/Number", "Number")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/issafeinteger/index.html b/files/ru/web/javascript/reference/global_objects/number/issafeinteger/index.html
index 11ae971903..b9be2bbc60 100644
--- a/files/ru/web/javascript/reference/global_objects/number/issafeinteger/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/issafeinteger/index.html
@@ -29,11 +29,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
 
 <p>Для больших целочисленных значений, рассмотрите возможность использования типа {{jsxref("BigInt")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code>Number.isSafeInteger(<var>testValue</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>testValue</code></dt>
@@ -44,7 +44,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
 
 <p>{{jsxref("Boolean")}} значение, сообщающее о том, является ли переданное значение безопасным целочисленным числом или же нет.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js notranslate">Number.isSafeInteger(3);                    // true
 Number.isSafeInteger(Math.pow(2, 53));      // false
@@ -56,13 +56,13 @@ Number.isSafeInteger(3.1);                  // false
 Number.isSafeInteger(3.0);                  // true
 </pre>
 
-<h2 id="Specifications" name="Specifications">Полифил</h2>
+<h2 id="Specifications">Полифил</h2>
 
 <pre class="brush: js notranslate">Number.isSafeInteger = Number.isSafeInteger || function (value) {
    return Number.isInteger(value) &amp;&amp; Math.abs(value) &lt;= Number.MAX_SAFE_INTEGER;
 };</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -77,13 +77,13 @@ Number.isSafeInteger(3.0);                  // true
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Number.isSafeInteger")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Объект {{jsxref("Number")}}, которому принадлежит этот метод.</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/max_safe_integer/index.html b/files/ru/web/javascript/reference/global_objects/number/max_safe_integer/index.html
index b15930a175..6299ee511b 100644
--- a/files/ru/web/javascript/reference/global_objects/number/max_safe_integer/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/max_safe_integer/index.html
@@ -10,31 +10,31 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Константа <strong><code>Number.MAX_SAFE_INTEGER</code></strong> представляет максимальное безопасное целочисленное значение в JavaScript (<code>2<sup>53</sup> - 1</code>).</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Константа <code>MAX_SAFE_INTEGER</code> имеет значение <code>9007199254740991</code>. Смысл этого числа в том, что в JavaScript используется <a href="https://ru.wikipedia.org/wiki/Число_двойной_точности">формат чисел с плавающей запятой двойной точности</a>, как определено в стандарте <a href="https://ru.wikipedia.org/wiki/IEEE_754">IEEE 754</a>, а он может безопасно представлять числа только в диапазоне от <code>-(2<sup>53</sup> - 1)</code> до <code>2<sup>53</sup> - 1</code>.</p>
 
 <p>Поскольку <code>MAX_SAFE_INTEGER</code> является статическим свойством объекта {{jsxref("Global_Objects/Number", "Number")}}, вы всегда должны использовать его как <code>Number.MAX_SAFE_INTEGER</code>, а не как свойство созданного вами объекта {{jsxref("Global_Objects/Number", "Number")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">Number.MAX_SAFE_INTEGER // 9007199254740991
 Math.pow(2, 53) - 1     // 9007199254740991
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">if (!Number.MAX_SAFE_INTEGER) {
     Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
 }</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -51,10 +51,10 @@ Math.pow(2, 53) - 1     // 9007199254740991
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/max_value/index.html b/files/ru/web/javascript/reference/global_objects/number/max_value/index.html
index 669c4403db..0abb284b1f 100644
--- a/files/ru/web/javascript/reference/global_objects/number/max_value/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/max_value/index.html
@@ -9,18 +9,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Number.MAX_VALUE</code></strong> представляет максимальное числовое значение, представимое в JavaScript.</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Свойство <code>MAX_VALUE</code> имеет значение, приблизительно равное <code>1.79E+308</code>. Значения, большие <code>MAX_VALUE</code> представляются как «бесконечность».</p>
 <p>Поскольку <code>MAX_VALUE</code> является статическим свойством объекта {{jsxref("Global_Objects/Number", "Number")}}, вы всегда должны использовать его как <code>Number.MAX_VALUE</code>, а не как свойство созданного вами объекта {{jsxref("Global_Objects/Number", "Number")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_MAX_VALUE" name="Example:_Using_MAX_VALUE">Пример: использование <code>MAX_VALUE</code></h3>
+<h3 id="Example:_Using_MAX_VALUE">Пример: использование <code>MAX_VALUE</code></h3>
 <p>В следующем примере кода производится умножение двух значений. Если результат меньше или равен <code>MAX_VALUE</code>, вызывается функция <code>func1</code>; в противном случае вызывается функция <code>func2</code>.</p>
 <pre class="brush: js">if (num1 * num2 &lt;= Number.MAX_VALUE) {
   func1();
@@ -29,7 +29,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -55,10 +55,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Number.MIN_VALUE")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/number/min_safe_integer/index.html b/files/ru/web/javascript/reference/global_objects/number/min_safe_integer/index.html
index d832b8aa2b..4940febb9d 100644
--- a/files/ru/web/javascript/reference/global_objects/number/min_safe_integer/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/min_safe_integer/index.html
@@ -10,25 +10,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Константа <strong><code>Number.MIN_SAFE_INTEGER</code></strong> представляет минимальное безопасное целочисленное значение в JavaScript (<code>-(2<sup>53</sup> - 1)</code>).</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Константа <code>MIN_SAFE_INTEGER</code> имеет значение <code>-9007199254740991</code>. Смысл этого числа в том, что в JavaScript используется <a href="https://ru.wikipedia.org/wiki/Число_двойной_точности">формат чисел с плавающей запятой двойной точности</a>, как определено в стандарте <a href="https://ru.wikipedia.org/wiki/IEEE_754">IEEE 754</a>, а он может безопасно представлять числа только в диапазоне от <code>-(2<sup>53</sup> - 1)</code> до <code>2<sup>53</sup> - 1</code>.</p>
 
 <p>Поскольку <code>MIN_SAFE_INTEGER</code> является статическим свойством объекта {{jsxref("Global_Objects/Number", "Number")}}, вы всегда должны использовать его как <code>Number.MIN_SAFE_INTEGER</code>, а не как свойство созданного вами объекта {{jsxref("Global_Objects/Number", "Number")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">Number.MIN_SAFE_INTEGER // -9007199254740991
 -(Math.pow(2, 53) - 1)  // -9007199254740991
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -45,11 +45,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/min_value/index.html b/files/ru/web/javascript/reference/global_objects/number/min_value/index.html
index 0b9561a6fc..bdac70a94b 100644
--- a/files/ru/web/javascript/reference/global_objects/number/min_value/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/min_value/index.html
@@ -9,13 +9,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Свойство <strong><code>Number.</code><span style="font-family: consolas,monaco,andale mono,monospace;">MIN_VALUE</span></strong> представляет минимальное положительное числовое значение, представимое в JavaScript.</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Свойство <code>MIN_VALUE</code> является положительным ближайшим к нулю числом, которое может быть представлено в JavaScript.</p>
 
@@ -23,9 +23,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
 
 <p>Поскольку <code>MIN_VALUE</code> является статическим свойством объекта {{jsxref("Global_Objects/Number", "Number")}}, вы всегда должны использовать его как <code>Number.MIN_VALUE</code>, а не как свойство созданного вами объекта {{jsxref("Global_Objects/Number", "Number")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_MIN_VALUE" name="Example:_Using_MIN_VALUE">Пример: использование <code>MIN_VALUE</code></h3>
+<h3 id="Example:_Using_MIN_VALUE">Пример: использование <code>MIN_VALUE</code></h3>
 
 <p>В следующем примере кода производится деление одного значения на другое. Если результат больше или равен <code>MIN_VALUE</code>, вызывается функция <code>func1</code>; в противном случае вызывается функция <code>func2</code>.</p>
 
@@ -36,7 +36,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -63,11 +63,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.MAX_VALUE")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/nan/index.html b/files/ru/web/javascript/reference/global_objects/number/nan/index.html
index c37f161041..bd625bc3b8 100644
--- a/files/ru/web/javascript/reference/global_objects/number/nan/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/nan/index.html
@@ -9,13 +9,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Number.NaN</code></strong> представляет «не число». Эквивалентно глобальному объекту {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
 <p>Вам не нужно создавать объект {{jsxref("Global_Objects/Number", "Number")}} для доступа к этому статическому свойству (используйте <code>Number.NaN</code>).</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -41,10 +41,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>Глобальный объект {{jsxref("Global_Objects/NaN", "NaN")}}.</li>
  <li>Объект {{jsxref("Global_Objects/Number", "Number")}}, которому принадлежит это свойство.</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/negative_infinity/index.html b/files/ru/web/javascript/reference/global_objects/number/negative_infinity/index.html
index 2153fbd137..535f89cc1d 100644
--- a/files/ru/web/javascript/reference/global_objects/number/negative_infinity/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/negative_infinity/index.html
@@ -9,13 +9,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Number.NEGATIVE_INFINITY</code></strong> представляет значение отрицательной бесконечности.</p>
 <p>Вам не нужно создавать объект {{jsxref("Global_Objects/Number", "Number")}} для доступа к этому статическому свойству (используйте <code>Number.NEGATIVE_INFINITY</code>).</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Значение <code>Number.NEGATIVE_INFINITY</code> является тем же самым по модулю, только отрицательным значением, что содержит свойство {{jsxref("Global_Objects/Infinity", "Infinity")}} глобального объекта.</p>
 <p>Это значение ведёт себя несколько иначе, нежели математическая бесконечность:</p>
 <ul>
@@ -30,9 +30,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
 </ul>
 <p>Вы можете использовать свойство <code>Number.NEGATIVE_INFINITY</code> для проверки на ошибки и возвращать конечное число в случае успеха. Однако, обратите внимание, что в этом случае более уместным было бы использование функции {{jsxref("Global_Objects/isFinite", "isFinite")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_NEGATIVE_INFINITY" name="Example:_Using_NEGATIVE_INFINITY">Пример: использование <code>NEGATIVE_INFINITY</code></h3>
+<h3 id="Example:_Using_NEGATIVE_INFINITY">Пример: использование <code>NEGATIVE_INFINITY</code></h3>
 <p>В следующем примере переменной <code>smallNumber</code> присваивается значение, меньшее минимального. Когда выполняется инструкция {{jsxref("Statements/if...else", "if")}}, переменная <code>smallNumber</code> имеет значение <code>-Infinity</code>, так что перед продолжением вычислений она устанавливается в более приемлемое значение.</p>
 <pre class="brush: js">var smallNumber = (-Number.MAX_VALUE) * 2;
 
@@ -41,7 +41,7 @@ if (smallNumber == Number.NEGATIVE_INFINITY) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -67,10 +67,10 @@ if (smallNumber == Number.NEGATIVE_INFINITY) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
  <li>{{jsxref("Number.isFinite()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/parsefloat/index.html b/files/ru/web/javascript/reference/global_objects/number/parsefloat/index.html
index f61f6d18ea..f0d859f17a 100644
--- a/files/ru/web/javascript/reference/global_objects/number/parsefloat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/parsefloat/index.html
@@ -10,26 +10,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Number.parseFloat()</code></strong> разбирает строковый аргумент и возвращает число с плавающей запятой. Этот метод ведёт себя идентично глобальной функции {{jsxref("Global_Objects/parseFloat", "parseFloat()")}} и является частью ECMAScript 6 (его целью является модуляризация глобальных сущностей).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Number.parseFloat(<var>string</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>string</code></dt>
  <dd>Строка, представляющая значение, которое вы хотите разобрать.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Пожалуйста, обратитесь к документации по глобальной функции {{jsxref("Global_Objects/parseFloat", "parseFloat()")}} для просмотра подробного описания и примеров.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -48,11 +48,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Объект {{jsxref("Global_Objects/Number", "Number")}}, которому принадлежит этот метод.</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/parseint/index.html b/files/ru/web/javascript/reference/global_objects/number/parseint/index.html
index 2840299c37..2f36fcf747 100644
--- a/files/ru/web/javascript/reference/global_objects/number/parseint/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/parseint/index.html
@@ -10,15 +10,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Number.parseInt()</code></strong> разбирает строковый аргумент и возвращает целое число. Этот метод ведёт себя идентично глобальной функции {{jsxref("Global_Objects/parseInt", "parseInt()")}} и является частью ECMAScript 6 (его целью является модуляризация глобальных сущностей).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Number.parseInt(<var>string</var>[, <var>radix</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>string</code></dt>
@@ -31,7 +31,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt
 
 <p>Целое число, полученное парсингом (разбором и интерпретацией) переданной строки. Если первый символ строки не может быть преобразован в число, то возвращается <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="Глобальное свойство NaN является значением, представляющим не-число (Not-A-Number)."><code>NaN</code></a>. </p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Этот метод имеет ту же функциональность, что и глобальная функция {{jsxref("parseInt", "parseInt()")}}:</p>
 
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -70,11 +70,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Number.parseInt")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Объект {{jsxref("Global_Objects/Number", "Number")}}, которому принадлежит этот метод.</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/positive_infinity/index.html b/files/ru/web/javascript/reference/global_objects/number/positive_infinity/index.html
index 402c99cf68..8b2292af9b 100644
--- a/files/ru/web/javascript/reference/global_objects/number/positive_infinity/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/positive_infinity/index.html
@@ -9,13 +9,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>Number.POSITIVE_INFINITY</code></strong> представляет значение положительной бесконечности.</p>
 <p>Вам не нужно создавать объект {{jsxref("Global_Objects/Number", "Number")}} для доступа к этому статическому свойству (используйте <code>Number.POSITIVE_INFINITY</code>).</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Значение <code>Number.POSITIVE_INFINITY</code> является тем же самым значением, что содержит свойство {{jsxref("Global_Objects/Infinity", "Infinity")}} глобального объекта.</p>
 <p>Это значение ведёт себя несколько иначе, нежели математическая бесконечность:</p>
 <ul>
@@ -30,9 +30,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY
 </ul>
 <p>Вы можете использовать свойство <code>Number.POSITIVE_INFINITY</code> для проверки на ошибки и возвращать конечное число в случае успеха. Однако, обратите внимание, что в этом случае более уместным было бы использование функции {{jsxref("Global_Objects/isFinite", "isFinite")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_POSITIVE_INFINITY" name="Example:_Using_POSITIVE_INFINITY">Пример: использование <code>POSITIVE_INFINITY</code></h3>
+<h3 id="Example:_Using_POSITIVE_INFINITY">Пример: использование <code>POSITIVE_INFINITY</code></h3>
 <p>В следующем примере переменной <code>bigNumber</code> присваивается значение, большее максимального. Когда выполняется инструкция {{jsxref("Statements/if...else", "if")}}, переменная <code>bigNumber</code> имеет значение <code>Infinity</code>, так что перед продолжением вычислений она устанавливается в более приемлемое значение.</p>
 <pre class="brush: js">var bigNumber = Number.MAX_VALUE * 2;
 
@@ -41,7 +41,7 @@ if (bigNumber == Number.POSITIVE_INFINITY) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -67,10 +67,10 @@ if (bigNumber == Number.POSITIVE_INFINITY) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
  <li>{{jsxref("Number.isFinite()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/toexponential/index.html b/files/ru/web/javascript/reference/global_objects/number/toexponential/index.html
index b9dac9b104..918f0ba864 100644
--- a/files/ru/web/javascript/reference/global_objects/number/toexponential/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/toexponential/index.html
@@ -10,22 +10,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toExponential()</code></strong> возвращает строку, представляющую объект {{jsxref("Global_Objects/Number", "Number")}} в экспоненциальной записи.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>numObj</var>.toExponential([<var>fractionDigits</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>fractionDigits</code></dt>
  <dd>Необязательный параметр. Целое число, определяющее количество цифр после десятичной запятой. По умолчанию используется столько цифр, сколько необходимо для указания числа.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Строка, представляющая объект {{jsxref("Global_Objects/Number", "Number")}} в экспоненциальной записи с одной цифрой перед десятичной запятой, округлённое до <code>fractionDigits</code> цифр после десятичной запятой. Если аргумент <code>fractionDigits</code> опущен, количество цифр после десятичной запятой по умолчанию устанавливается в количество цифр, необходимых для однозначного представления значения.</p>
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential
 
 <p>Если число имеет больше цифр, чем запрошено параметром <code>fractionDigits</code>, оно будет округлено к ближайшему числу, представляемому <code>fractionDigits</code> цифрами. Смотрите обсуждение округления в описании метода {{jsxref("Number.prototype.toFixed", "toFixed()")}}, которое так же применяется и к методу <code>toExponential()</code>.</p>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 
 <dl>
  <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt>
@@ -42,9 +42,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential
  <dd>Если этот метод вызывается на объекте, не являющимся объектом {{jsxref("Global_Objects/Number", "Number")}}.</dd>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_toExponential" name="Example:_Using_toExponential">Пример: использование <code>toExponential</code></h3>
+<h3 id="Example_Using_toExponential">Пример: использование <code>toExponential</code></h3>
 
 <pre class="brush: js notranslate">var numObj = 77.1234;
 
@@ -56,7 +56,7 @@ console.log(77.1234.toExponential()); // выведет 7.71234e+1
 console.log(77 .toExponential());     // выведет 7.7e+1
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -83,11 +83,11 @@ console.log(77 .toExponential());     // выведет 7.7e+1
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Number.toExponential")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.prototype.toFixed()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/tofixed/index.html b/files/ru/web/javascript/reference/global_objects/number/tofixed/index.html
index 9ea23419b6..2d68871d4c 100644
--- a/files/ru/web/javascript/reference/global_objects/number/tofixed/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/tofixed/index.html
@@ -10,26 +10,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toFixed()</code></strong> форматирует число, используя запись с фиксированной запятой.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>numObj</var>.toFixed([<var>digits</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>digits</code></dt>
  <dd>Необязательный параметр. Количество цифр после десятичной запятой; может быть значением между 0 и 20 включительно, хотя реализации могут поддерживать и больший диапазон значений. Если аргумент опущен, он считается равным 0.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Строка, представляющая <code>numObj</code>, не использующая экспоненциальную запись и содержащая ровно <code>digits</code> цифр после десятичной запятой. Число округляется при необходимости, а дробная часть дополняется нулями таким образом, чтобы иметь указанную длину. Если <code>numObj</code> больше или равно <code>1e+21</code>, этот метод просто вызывает метод {{jsxref("Number.prototype.toString()")}} и возвращает строку в экспоненциальной записи.</p>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 
 <dl>
  <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt>
@@ -38,9 +38,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed
  <dd>Если этот метод вызывается на объекте, не являющимся объектом {{jsxref("Global_Objects/Number", "Number")}}.</dd>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_toFixed" name="Example:_Using_toFixed">Пример: использование <code>toFixed</code></h3>
+<h3 id="Example_Using_toFixed">Пример: использование <code>toFixed</code></h3>
 
 <pre class="brush: js notranslate">var numObj = 12345.6789;
 
@@ -55,7 +55,7 @@ numObj.toFixed(6);      // Вернёт '12345.678900': обратите вни
 (-2.34).toFixed(1);     // Вернёт '-2.3' (...до тех пор, пока вы не заключите их в круглые скобки)
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -82,11 +82,11 @@ numObj.toFixed(6);      // Вернёт '12345.678900': обратите вни
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Number.toFixed")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.prototype.toExponential()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/tolocalestring/index.html b/files/ru/web/javascript/reference/global_objects/number/tolocalestring/index.html
index 908a152cfe..f0a0a15991 100644
--- a/files/ru/web/javascript/reference/global_objects/number/tolocalestring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/tolocalestring/index.html
@@ -11,17 +11,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toLocaleString()</code></strong> возвращает строку с языкозависимым представлением числа.</p>
 
 <p>Новые аргументы <code>locales</code> и <code>options</code> позволяют приложениям определять язык, чьё поведение и соглашения по форматированию которого оно хочет использовать. В старых реализациях, игнорирующих аргументы <code>locales</code> и <code>options</code>, используемая локаль и форма возвращённой строки целиком зависит от реализации.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>numObj</var>.toLocaleString([<var>locales</var>[, <var>options</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Проверьте раздел <a href="#Browser_compatibility">Совместимость с браузерами</a>, чтобы увидеть, какие браузеры поддерживают аргументы <code>locales</code> и <code>options</code>, и <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></a> для определения этой возможности.</p>
 
@@ -31,9 +31,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat', 'Parameters')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_toLocaleString" name="Example:_Using_toLocaleString">Пример: использование <code>toLocaleString</code></h3>
+<h3 id="Example_Using_toLocaleString">Пример: использование <code>toLocaleString</code></h3>
 
 <p>При базовом использовании без указания локали возвращается строка, отформатированная в соответствии с локалью и опциями по умолчанию.</p>
 
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
 console.log(number.toLocaleString()); // Отобразит '3,500' в локали U.S. English
 </pre>
 
-<h3 id="Example_Checking_for_support_for_locales_and_options_arguments" name="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
+<h3 id="Example_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
 
 <p>Аргументы <code>locales</code> и <code>options</code> поддерживаются ещё не всеми браузерами. Для проверки того, поддерживает ли их уже реализация, можно затребовать несуществующую метку языка и проверить, будет ли выброшено исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}:</p>
 
@@ -57,7 +57,7 @@ console.log(number.toLocaleString()); // Отобразит '3,500' в лока
 }
 </pre>
 
-<h3 id="Example_Using_locales" name="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
+<h3 id="Example_Using_locales">Пример: использование аргумента <code>locales</code></h3>
 
 <p>Этот пример показывает некоторые локализованные числовые форматы. Для получения формата языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент <code>locales</code>:</p>
 
@@ -89,7 +89,7 @@ console.log(number.toLocaleString(['ban', 'id']));
 // → 123.456,789
 </pre>
 
-<h3 id="Example_Using_options" name="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
+<h3 id="Example_Using_options">Пример: использование аргумента <code>options</code></h3>
 
 <p>Результат, предоставляемый методом <code>toLocaleString()</code>, может быть настроен с помощью аргумента <code>options</code>:</p>
 
@@ -111,11 +111,11 @@ console.log(number.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
 // → 1,23,000
 </pre>
 
-<h2 id="Performance" name="Performance">Производительность</h2>
+<h2 id="Performance">Производительность</h2>
 
 <p>При форматировании большого количества чисел лучшим вариантом будет создание объекта {{jsxref("Global_Objects/NumberFormat", "NumberFormat")}} и использование функции, предоставляемой его свойством {{jsxref("NumberFormat.format")}}.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -150,7 +150,7 @@ console.log(number.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
 <h2 id="Совместимость_с_браузерами">Совместимость с браузерами</h2>
 <p>{{Compat("javascript.builtins.Number.toLocaleString")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.prototype.toString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/toprecision/index.html b/files/ru/web/javascript/reference/global_objects/number/toprecision/index.html
index 2485692ca8..da8d601c7d 100644
--- a/files/ru/web/javascript/reference/global_objects/number/toprecision/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/toprecision/index.html
@@ -10,37 +10,37 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toPrecision()</code></strong> возвращает строку, представляющую объект {{jsxref("Global_Objects/Number", "Number")}} с указанной точностью.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>numObj</var>.toPrecision([<var>precision</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>precision</code></dt>
  <dd>Необязательный параметр. Целое число, определяющее количество значащих цифр.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Строка, представляющая объект {{jsxref("Global_Objects/Number", "Number")}} в записи с фиксированной запятой или в экспоненциальной записи, округлённое до <code>precision</code> значащих цифр. Смотрите обсуждение округления в описании метода {{jsxref("Number.prototype.toFixed", "toFixed()")}}, которое таким же образом применяется и к методу <code>toPrecision()</code>.</p>
 
 <p>Если аргумент <code>precision</code> опущен, поведение аналогично методу {{jsxref("Number.prototype.toString()")}}. Если он не является целым числом, он будет округлён к ближайшему целому числу.</p>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 
 <dl>
  <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt>
  <dd>Если параметр <code>precison</code> не находится в диапазоне от 1 до 100 (включительно), будет выброшено исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}. Также реализации могут поддерживать большие и меньшие значения. ECMA-262 требует точности только до 21 значащей цифры.</dd>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_toPrecision" name="Example:_Using_toPrecision">Пример: использование <code>toPrecision</code></h3>
+<h3 id="Example_Using_toPrecision">Пример: использование <code>toPrecision</code></h3>
 
 <pre class="brush: js notranslate">var numObj = 5.123456;
 
@@ -62,7 +62,7 @@ console<span class="punctuation token">.</span><span class="function token">log<
 console.log((1234.5).toPrecision(2)); // выведет '1.2e+3'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -89,11 +89,11 @@ console.log((1234.5).toPrecision(2)); // выведет '1.2e+3'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Number.toPrecision")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.prototype.toFixed()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/tosource/index.html b/files/ru/web/javascript/reference/global_objects/number/tosource/index.html
index f8fa283d32..f64df2b00e 100644
--- a/files/ru/web/javascript/reference/global_objects/number/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/tosource/index.html
@@ -11,20 +11,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toSource
 ---
 <div>{{JSRef("Global_Objects", "Number")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toSource()</code></strong> возвращает строку, представляющую исходный код объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>numObj</var>.toSource()
 Number.toSource()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>toSource</code> возвращает следующие значения:</p>
 
@@ -41,15 +41,15 @@ Number.toSource()</code></pre>
 
 <p>Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/tostring/index.html b/files/ru/web/javascript/reference/global_objects/number/tostring/index.html
index 47bd43c2a8..86cd5b3b60 100644
--- a/files/ru/web/javascript/reference/global_objects/number/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/tostring/index.html
@@ -10,29 +10,29 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toString()</code></strong> возвращает строковое представление указанного объекта {{jsxref("Global_Objects/Number", "Number")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>numObj</var>.toString([<var>radix</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>radix</code></dt>
  <dd>Необязательный параметр. Целое число между 2 и 36, определяющее основание системы счисления, используемой для представления числового значения.</dd>
 </dl>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 
 <dl>
  <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt>
  <dd>Если в метод <code>toString()</code> передано основание не в диапазоне от 2 до 36, будет выброшено исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Объект {{jsxref("Global_Objects/Number", "Number")}} переопределяет метод {{jsxref("Object.prototype.toString", "toString")}}, унаследованный из объекта {{jsxref("Global_Objects/Object", "Object")}}; он не наследует метод {{jsxref("Object.prototype.toString")}}. Для объектов {{jsxref("Global_Objects/Number", "Number")}} метод <code>toString()</code> возвращает строку, представляющую объект в определённой системе счисления.</p>
 
@@ -42,9 +42,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString
 
 <p>Если число <code>numObj</code> отрицательно, его знак сохраняется. Это правило действует даже если основание равно 2; возвращённая строка является двоичным представлением положительного числа <code>numObj</code>, перед которым ставится знак <code>-</code>, а <strong>не</strong> дополнительным кодом числа <code>numObj</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_toString" name="Example:_Using_toString">Пример: использование <code>toString</code></h3>
+<h3 id="Example_Using_toString">Пример: использование <code>toString</code></h3>
 
 <pre class="brush: js notranslate">var count = 10;
 
@@ -60,7 +60,7 @@ console.log((-10).toString(2));   // Выведет '-1010'
 console.log((-0xff).toString(2)); // Выведет '-11111111'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -87,11 +87,11 @@ console.log((-0xff).toString(2)); // Выведет '-11111111'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Number.toString")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Number.prototype.toFixed()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/number/valueof/index.html b/files/ru/web/javascript/reference/global_objects/number/valueof/index.html
index 5ac9e041c5..72d29ea7f4 100644
--- a/files/ru/web/javascript/reference/global_objects/number/valueof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/number/valueof/index.html
@@ -11,21 +11,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/valueOf
 ---
 <div>{{JSRef("Global_Objects", "Number")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>valueOf()</code></strong> возвращает примитивное значение объекта {{jsxref("Global_Objects/Number", "Number")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>numObj</var>.valueOf()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_valueOf" name="Example:_Using_valueOf">Пример: использование <code>valueOf()</code></h3>
+<h3 id="Example:_Using_valueOf">Пример: использование <code>valueOf()</code></h3>
 <pre class="brush: js">var numObj = new Number(10);
 console.log(typeof numObj); // object
 
@@ -34,7 +34,7 @@ console.log(num);           // 10
 console.log(typeof num);    // number
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -60,10 +60,10 @@ console.log(typeof num);    // number
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Number.prototype.toSource()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/object/__definegetter__/index.html b/files/ru/web/javascript/reference/global_objects/object/__definegetter__/index.html
index 0d5fe70693..78bc6d423c 100644
--- a/files/ru/web/javascript/reference/global_objects/object/__definegetter__/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/__definegetter__/index.html
@@ -12,13 +12,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__
 ---
 <div>{{JSRef("Global_Objects", "Object")}} {{non-standard_header}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>__defineGetter__()</code></strong> привязывает свойство объекта к функции, вызываемой каждый раз при поиске этого свойства.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>obj</var>.__defineGetter__(<var>prop</var>, <var>func</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>prop</code></dt>
  <dd>Строка, содержащая имя свойства, привязываемого к заданной функции.</dd>
@@ -26,10 +26,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__
  <dd>Функция, привязываемая к поиску указанного свойства.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>__defineGetter__()</code> позволяет определить {{jsxref("Operators/get", "геттер", "", 1)}} на уже существующем объекте.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">// Нестандартный и устаревший способ
 
 var o = {};
@@ -54,13 +54,13 @@ Object.defineProperty(o, 'gimmeFive', {
 console.log(o.gimmeFive); // 5
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.__defineSetter__()")}}</li>
  <li>оператор {{jsxref("Operators/get", "get")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/__definesetter__/index.html b/files/ru/web/javascript/reference/global_objects/object/__definesetter__/index.html
index a761a45b07..65f9c87de9 100644
--- a/files/ru/web/javascript/reference/global_objects/object/__definesetter__/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/__definesetter__/index.html
@@ -13,13 +13,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineSetter__
 ---
 <div>{{JSRef("Global_Objects", "Object")}} {{non-standard_header}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>__defineSetter__()</code></strong> привязывает свойство объекта к функции, вызываемой каждый раз при попытке установить значение этого свойства.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>obj</var>.__defineSetter__(<var>prop</var>, <var>fun</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>prop</code></dt>
  <dd>Строка, содержащая имя свойства, привязываемого к заданной функции.</dd>
@@ -34,10 +34,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineSetter__
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>__defineSetter__()</code> позволяет определять {{jsxref("Operators/set", "сеттер", "", 1)}} на уже существующем объекте.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">// Нестандартный и устаревший способ
 
 var o = {};
@@ -67,13 +67,13 @@ console.log(o.value);         // undefined
 console.log(o.anotherValue);  // 5
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.__defineGetter__()")}}</li>
  <li>оператор {{jsxref("Operators/set", "set")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/__lookupgetter__/index.html b/files/ru/web/javascript/reference/global_objects/object/__lookupgetter__/index.html
index 060446cfb2..019967d739 100644
--- a/files/ru/web/javascript/reference/global_objects/object/__lookupgetter__/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/__lookupgetter__/index.html
@@ -13,23 +13,23 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/__lookupGetter__
 ---
 <div>{{JSRef("Global_Objects", "Object")}} {{non-standard_header}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>__lookupGetter__()</code></strong> возвращает функцию, привязанную к геттеру указанного свойства.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>obj</var>.__lookupGetter__(<var>sprop</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>sprop</code></dt>
  <dd>Строка, содержащая имя свойства, чей геттер должен быть возвращён.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если для свойства объекта был определён геттер, то на него невозможно сослаться через это свойство, поскольку оно ссылается на возвращаемое значение геттера. Метод <code>__lookupGetter__()</code> может использоваться для получения ссылки на геттер.</p>
 <p>Сегодня это возможно сделать стандартным способом через {{jsxref("Object.getOwnPropertyDescriptor()")}} и {{jsxref("Object.getPrototypeOf()")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">var obj = {
   get foo() {
     return Math.random() &gt; 0.5 ? 'foo' : 'bar';
@@ -47,13 +47,13 @@ Object.getOwnPropertyDescriptor(obj, 'foo').get;
 // (function() { return Math.random() &gt; 0.5 ? 'foo' : 'bar'; })
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.__lookupSetter__()")}}</li>
  <li>оператор {{jsxref("Operators/get", "get")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/__lookupsetter__/index.html b/files/ru/web/javascript/reference/global_objects/object/__lookupsetter__/index.html
index fe4c2b22ae..c338f0e029 100644
--- a/files/ru/web/javascript/reference/global_objects/object/__lookupsetter__/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/__lookupsetter__/index.html
@@ -13,23 +13,23 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/__lookupSetter__
 ---
 <div>{{JSRef("Global_Objects", "Object")}} {{non-standard_header}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>__lookupSetter__()</code></strong> возвращает функцию, привязанную к сеттеру указанного свойства.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>obj</var>.__lookupSetter__(<var>sprop</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>sprop</code></dt>
  <dd>Строка, содержащая имя свойства, чей сеттер должен быть возвращён.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если для свойства объекта был определён сеттер, то на него невозможно сослаться через это свойство, поскольку оно ссылается на возвращаемое значение сеттера. Метод <code>__lookupSetter__()</code> может использоваться для получения ссылки на сеттер.</p>
 <p>Сегодня это возможно сделать стандартным способом через {{jsxref("Object.getOwnPropertyDescriptor()")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">var obj = {
   set foo(value) {
     return this.bar = value;
@@ -47,13 +47,13 @@ Object.getOwnPropertyDescriptor(obj, 'foo').set;
 // (function(value) { this.bar = value; })
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какой-либо спецификации.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.__lookupGetter__()")}}</li>
  <li>оператор {{jsxref("Operators/set", "set")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/assign/index.html b/files/ru/web/javascript/reference/global_objects/object/assign/index.html
index 354f4ce4e5..29e6ee2ae7 100644
--- a/files/ru/web/javascript/reference/global_objects/object/assign/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/assign/index.html
@@ -17,11 +17,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
 
 <p>Метод <code><strong>Object.assign()</strong></code> используется для копирования значений всех собственных перечисляемых свойств из одного или более исходных объектов в целевой объект. После копирования он возвращает целевой объект.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.assign(<var>target</var>, ...<var>sources</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>target</code></dt>
@@ -30,11 +30,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
  <dd>Исходные объекты.</dd>
 </dl>
 
-<h3 id="Return_value" name="Return_value">Возвращаемое значение</h3>
+<h3 id="Return_value">Возвращаемое значение</h3>
 
 <p>Возвращается получившийся целевой объект.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>Object.assign()</code> копирует из исходных объектов в целевой объект только <em>перечисляемые</em> и <em>собственные</em> свойства. Он использует внутренний метод <code>[[Get]]</code> на исходных объектах и внутренний метод <code>[[Set]]</code> на целевом объекте, так что он также вызывает геттеры и сеттеры. Именно поэтому он <em>присваивает</em> свойства вместо простого копирования или определения новых свойств. Это поведение может сделать метод непригодным для вливания новых свойств в прототип, если вливаемые исходные объекты содержат геттеры. Вместо него для копирования в прототипы определений свойств, включая признак их перечисляемости, следует использовать методы {{jsxref("Object.getOwnPropertyDescriptor()")}} и {{jsxref("Object.defineProperty()")}}.</p>
 
@@ -44,16 +44,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
 
 <p>Обратите внимание, что метод <code>Object.assign()</code> не выкидывает исключения, если в качестве исходных значений выступают {{jsxref("null")}} или {{jsxref("undefined")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Cloning_an_object" name="Example:_Cloning_an_object">Пример: клонирование объекта</h3>
+<h3 id="Example:_Cloning_an_object">Пример: клонирование объекта</h3>
 
 <pre class="brush: js">var obj = { a: 1 };
 var copy = Object.assign({}, obj);
 console.log(copy); // { a: 1 }
 </pre>
 
-<h3 id="Example:_Merging_objects" name="Example:_Merging_objects">Пример: слияние объектов</h3>
+<h3 id="Example:_Merging_objects">Пример: слияние объектов</h3>
 
 <pre class="brush: js">var o1 = { a: 1 };
 var o2 = { b: 2 };
@@ -64,7 +64,7 @@ console.log(obj); // { a: 1, b: 2, c: 3 }
 console.log(o1);  // { a: 1, b: 2, c: 3 }, изменился и сам целевой объект.
 </pre>
 
-<h3 id="Example:_Symbol_properties" name="Example:_Symbol_properties">Пример: копирование символьных свойств</h3>
+<h3 id="Example:_Symbol_properties">Пример: копирование символьных свойств</h3>
 
 <pre class="brush: js">var o1 = { a: 1 };
 var o2 = { [Symbol('foo')]: 2 };
@@ -73,7 +73,7 @@ var obj = Object.assign({}, o1, o2);
 console.log(obj); // { a: 1, [Symbol("foo")]: 2 }
 </pre>
 
-<h3 id="Example:_Only_own_enumerable_properties" name="Example:_Only_own_enumerable_properties">Пример: наследуемые и неперечисляемые свойства не копируются</h3>
+<h3 id="Example:_Only_own_enumerable_properties">Пример: наследуемые и неперечисляемые свойства не копируются</h3>
 
 <pre class="brush: js">var obj = Object.create({ foo: 1 }, { // foo является унаследованным свойством.
   bar: {
@@ -89,7 +89,7 @@ var copy = Object.assign({}, obj);
 console.log(copy); // { baz: 3 }
 </pre>
 
-<h3 id="Example:_Primitives" name="Example:_Primitives">Пример: примитивы оборачиваются в объекты</h3>
+<h3 id="Example:_Primitives">Пример: примитивы оборачиваются в объекты</h3>
 
 <pre class="brush: js">var v1 = '123';
 var v2 = true;
@@ -102,7 +102,7 @@ var obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
 console.log(obj); // { "0": "1", "1": "2", "2": "3" }
 </pre>
 
-<h3 id="Example:_Exceptions" name="Example:_Exceptions">Пример: исключения прерывают текущую задачу копирования</h3>
+<h3 id="Example:_Exceptions">Пример: исключения прерывают текущую задачу копирования</h3>
 
 <pre class="brush: js">var target = Object.defineProperty({}, 'foo', {
   value: 1,
@@ -120,7 +120,7 @@ console.log(target.foo3); // undefined, метод assign завершился,
 console.log(target.baz);  // undefined, третий исходный объект так же не скопировался.
 </pre>
 
-<h3 id="Example:_Copy_accessors" name="Example:_Copy_accessors">Пример: копирование методов доступа</h3>
+<h3 id="Example:_Copy_accessors">Пример: копирование методов доступа</h3>
 
 <pre class="brush: js">var obj = {
   foo: 1,
@@ -149,7 +149,7 @@ console.log(copy);
 // { foo:1, get bar() { return 2 } }
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот полифил не поддерживает символьные свойства, поскольку ES5 всё равно не поддерживает символы:</p>
 
@@ -186,7 +186,7 @@ console.log(copy);
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -203,13 +203,13 @@ console.log(copy);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div> </div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Object.assign")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.defineProperties()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/constructor/index.html b/files/ru/web/javascript/reference/global_objects/object/constructor/index.html
index 5a09a03ade..9f9debd1cb 100644
--- a/files/ru/web/javascript/reference/global_objects/object/constructor/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/constructor/index.html
@@ -10,9 +10,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/constructor
 ---
 <div>
  {{JSRef("Global_Objects", "Object")}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Возвращает ссылку на функцию {{jsxref("Global_Objects/Object", "Object")}}, создавшую прототип экземпляра. Обратите внимание, что значение этого свойства является ссылкой на саму функцию, а не строкой, содержащей имя функции. Для примитивных значений, вроде <code>1</code>, <code>true</code> или <code>"test"</code>, значение доступно только для чтения.</p>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Все объекты наследуют свойство <code>constructor</code> из своего прототипа:</p>
 <pre class="brush: js">var o = {};
 o.constructor === Object; // true
@@ -23,8 +23,8 @@ a.constructor === Array; // true
 var n = new Number(3);
 n.constructor === Number; // true
 </pre>
-<h2 id="Examples" name="Examples">Примеры</h2>
-<h3 id="Example:_Displaying_the_constructor_of_an_object" name="Example:_Displaying_the_constructor_of_an_object">Пример: отображение конструктора объекта</h3>
+<h2 id="Examples">Примеры</h2>
+<h3 id="Example:_Displaying_the_constructor_of_an_object">Пример: отображение конструктора объекта</h3>
 <p>В следующем примере создаётся прототип <code>Tree</code> и объект этого типа <code>theTree</code>. Затем в примере отображается свойство <code>constructor</code> объекта <code>theTree</code>.</p>
 <pre class="brush: js">function Tree(name) {
   this.name = name;
@@ -38,7 +38,7 @@ console.log("theTree.constructor равен " + theTree.constructor);
   this.name = name;
 }
 </pre>
-<h3 id="Example:_Changing_the_constructor_of_an_object" name="Example:_Changing_the_constructor_of_an_object">Пример: изменение конструктора объекта</h3>
+<h3 id="Example:_Changing_the_constructor_of_an_object">Пример: изменение конструктора объекта</h3>
 <p>Следующий пример показывает, как изменить конструктор значений общих объектов. Не затрагиваются только значения <code>true</code>, <code>1</code> и <code>"тест"</code>, поскольку они имеют родные конструкторы только для чтения. Этот пример показывает, что полагаться на свойство <code>constructor</code> объекта не всегда безопасно.</p>
 <pre class="brush: js">function Type() {}
 
@@ -96,7 +96,7 @@ function String() {
     [native code]
 },false,тест
 </pre>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -121,6 +121,6 @@ function String() {
   </tr>
  </tbody>
 </table>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/object/create/index.html b/files/ru/web/javascript/reference/global_objects/object/create/index.html
index 9af356adc0..f7b4d2c69b 100644
--- a/files/ru/web/javascript/reference/global_objects/object/create/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/create/index.html
@@ -15,11 +15,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/create
 
 <p>Метод <code><strong>Object.create()</strong></code> создаёт новый объект с указанным прототипом и свойствами.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code>Object.create(<var>proto</var>[, <var>propertiesObject</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>proto</code></dt>
@@ -32,13 +32,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/create
 
 <p>Новый объект с заданным прототипом и свойствами</p>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 
 <p>Выбрасывает исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}, если параметр <code>proto</code> не является {{jsxref("Global_Objects/null", "null")}} или объектом (исключение составляют объекты-обёртки примитивных типов).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example.3A_Classical_inheritance_with_Object.create" name="Example.3A_Classical_inheritance_with_Object.create()">Пример: классическое наследование с <code>Object.create()</code></h3>
+<h3 id="Example.3A_Classical_inheritance_with_Object.create">Пример: классическое наследование с <code>Object.create()</code></h3>
 
 <p>Ниже показан пример использования <code>Object.create()</code> для имитации классического наследования. Это пример одиночного наследования, поскольку только его поддерживает JavaScript.</p>
 
@@ -88,7 +88,7 @@ MyClass.prototype.myMethod = function() {
 
 <p>Функция примешивания должна копировать функции из прототипа суперкласса в прототип подкласса, она должна предоставляться пользователем. Примером примеси может служить функция <a href="http://api.jquery.com/jQuery.extend/">jQuery.extend()</a>.</p>
 
-<h3 id="Example.3A_Using_propertiesObject_argument_with_Object.create" name="Example.3A_Using_propertiesObject_argument_with_Object.create()">Пример: использование аргумента <code>propertiesObject</code> с <code>Object.create()</code></h3>
+<h3 id="Example.3A_Using_propertiesObject_argument_with_Object.create">Пример: использование аргумента <code>propertiesObject</code> с <code>Object.create()</code></h3>
 
 <pre class="brush: js notranslate">var o;
 
@@ -155,7 +155,7 @@ o2 = Object.create({}, {
 });
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Для этого полифила необходима правильно работающая Object.prototype.hasOwnProperty.</p>
 
@@ -204,7 +204,7 @@ o2 = Object.create({}, {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -226,11 +226,11 @@ o2 = Object.create({}, {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Object.create")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.defineProperty()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/defineproperties/index.html b/files/ru/web/javascript/reference/global_objects/object/defineproperties/index.html
index 5f76063f75..25cde1e310 100644
--- a/files/ru/web/javascript/reference/global_objects/object/defineproperties/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/defineproperties/index.html
@@ -14,15 +14,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>Object.defineProperties()</strong></code> определяет новые или изменяет существующие свойства, непосредственно на объекте, возвращая этот объект.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.defineProperties(<var>obj</var>, <var>props</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
@@ -57,11 +57,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>Object.defineProperties()</code>, по сути, определяет все свойства, соответствующие собственным свойствам объекта <code>props</code>, на объекте <code>obj</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">Object.defineProperties(obj, {
   'property1': {
@@ -76,7 +76,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
 });
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Предполагается, что среда выполнения осталась нетронутой, все имена и свойства ссылаются на свои изначальные значения. Оригинальный метод <code>Object.defineProperties</code> почти полностью эквивалентен (смотрите комментарий в функции <code>isCallable</code>) следующей реализации на JavaScript:</p>
 
@@ -153,7 +153,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -175,11 +175,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.defineProperty()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/defineproperty/index.html b/files/ru/web/javascript/reference/global_objects/object/defineproperty/index.html
index f4e2293986..05c18092f1 100644
--- a/files/ru/web/javascript/reference/global_objects/object/defineproperty/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/defineproperty/index.html
@@ -13,15 +13,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperty
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>Object.defineProperty()</strong></code> определяет новое или изменяет существующее свойство непосредственно на объекте, возвращая этот объект.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.defineProperty(<var>obj</var>, <var>prop</var>, <var>descriptor</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperty
  <dd>Дескриптор определяемого или изменяемого свойства.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Этот метод позволяет точно добавлять или изменять свойства объекта. Обычное добавление свойств через присваивание создаёт свойства, которые можно увидеть через перечисление свойств (с помощью цикла {{jsxref("Statements/for...in", "for...in")}} или метода {{jsxref("Object.keys")}}), чьи значения могут быть изменены и которые могут быть {{jsxref("Operators/delete", "удалены", "", 1)}}. Этот же метод позволяет настроить эти дополнительные детали свойства.</p>
 
@@ -112,11 +112,11 @@ Object.defineProperty(obj, 'key', withValue('static'));
 (Object.freeze || Object)(Object.prototype);
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <p>Если вы хотите посмотреть, как использовать метод <code>Object.defineProperty()</code> с синтаксисом <em>похожим-на-бинарные-флаги</em>, смотрите <a href="/ru/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty/Additional_examples">дополнительные примеры</a>.</p>
 
-<h3 id="Example:_Creating_a_property" name="Example:_Creating_a_property">Пример: создание свойства</h3>
+<h3 id="Example:_Creating_a_property">Пример: создание свойства</h3>
 
 <p>Если указанное свойство не существует в объекте, метод <code>Object.defineProperty()</code> создаст новое свойство по переданному описанию. Поля в дескрипторе могут быть опущены, в этом случае их значения будут значениями по умолчанию. Все логические поля будут по умолчанию установлены в <code>false</code>. Поля <code>value</code>, <code>get</code> и <code>set</code> по умолчанию будут установлены в {{jsxref("Global_Objects/undefined", "undefined")}}. Свойство, определённое без атрибутов <code>get</code>/<code>set</code>/<code>value</code>/<code>writable</code> называется «общим», а дескриптор данных — «типовым».</p>
 
@@ -156,7 +156,7 @@ Object.defineProperty(o, 'conflict', {
 // доступа
 </pre>
 
-<h3 id="Example:_Modifying_a_property" name="Example:_Modifying_a_property">Пример: изменение свойства</h3>
+<h3 id="Example:_Modifying_a_property">Пример: изменение свойства</h3>
 
 <p>Если свойство уже существует, метод <code>Object.defineProperty()</code> попытается изменить свойство в соответствии со значениями в дескрипторе и текущим состоянием объекта. Если у старого дескриптора атрибут <code>configurable</code> был установлен в <code>false</code> (говорит, что свойство является «ненастраиваемым»), то никакие атрибуты, кроме атрибута <code>writable</code>, не смогут быть изменены. В этом случае так же невозможно переключаться между типами дескрипторов.</p>
 
@@ -164,7 +164,7 @@ Object.defineProperty(o, 'conflict', {
 
 <p>При попытке изменить ненастраиваемые атрибуты свойства будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}} (кроме случая изменения атрибута <code>writable</code>), даже в том случае, если текущее и новое значения идентичны.</p>
 
-<h4 id="Writable_attribute" name="Writable_attribute">Атрибут <code>writable</code></h4>
+<h4 id="Writable_attribute">Атрибут <code>writable</code></h4>
 
 <p>Если атрибут <code>writable</code> свойства установлен в <code>false</code>, свойство становится «незаписываемым». Ему невозможно будет присвоить новое значение.</p>
 
@@ -183,7 +183,7 @@ console.log(o.a); // Выведет 37. Присваивание не срабо
 
 <p>Как видно в этом примере, попытка записи в незаписываемое свойство его не изменило, но и исключение так же не было выброшено.</p>
 
-<h4 id="Enumerable_attribute" name="Enumerable_attribute">Атрибут <code>enumerable</code></h4>
+<h4 id="Enumerable_attribute">Атрибут <code>enumerable</code></h4>
 
 <p>Атрибут <code>enumerable</code> свойства определяет, просматривается ли свойство в цикле {{jsxref("Statements/for...in", "for...in")}} и методом {{jsxref("Object.keys()")}} или нет.</p>
 
@@ -208,7 +208,7 @@ o.propertyIsEnumerable('b'); // false
 o.propertyIsEnumerable('c'); // false
 </pre>
 
-<h4 id="Configurable_attribute" name="Configurable_attribute">Атрибут <code>configurable</code></h4>
+<h4 id="Configurable_attribute">Атрибут <code>configurable</code></h4>
 
 <p>Атрибут <code>configurable</code> одновременно контролирует, может ли свойство быть удалено из объекта и могут ли быть изменены его атрибуты (кроме контроля изменения атрибута <code>writable</code>).</p>
 
@@ -231,7 +231,7 @@ console.log(o.a); // Выведет 1
 
 <p>Если бы атрибут <code>configurable</code> объекта <code>o.a</code> был установлен в <code>true</code>, никакие ошибки не были бы выброшены и в конце свойство было бы удалено.</p>
 
-<h3 id="Example:_Adding_properties_and_default_values" name="Example:_Adding_properties_and_default_values">Пример: добавление свойств и значений по умолчанию</h3>
+<h3 id="Example:_Adding_properties_and_default_values">Пример: добавление свойств и значений по умолчанию</h3>
 
 <p>Важно понимать, как устанавливаются значения по умолчанию атрибутам свойств. Часто существует разница между простым назначением значения посредством точечной нотации и использованием метода <code>Object.defineProperty()</code>, что и показывает пример ниже.</p>
 
@@ -258,7 +258,7 @@ Object.defineProperty(o, 'a', {
 });
 </pre>
 
-<h3 id="Example:_Custom_setters_and_getters" name="Example:_Custom_setters_and_getters">Пример: пользовательские сеттеры и геттеры</h3>
+<h3 id="Example:_Custom_setters_and_getters">Пример: пользовательские сеттеры и геттеры</h3>
 
 <p>Пример ниже показывает, как реализовать самоархивирующийся объект. При установке свойства <code>temperature</code> в массив <code>archive</code> попадает запись журнала.</p>
 
@@ -287,7 +287,7 @@ arc.temperature = 13;
 arc.getArchive(); // [{ val: 11 }, { val: 13 }]
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -309,12 +309,12 @@ arc.getArchive(); // [{ val: 11 }, { val: 13 }]
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 <p>На основе <a class="external" href="http://kangax.github.com/es5-compat-table/">таблицы совместимости Kangax</a>.</p>
 
-<h3 id="Redefining_the_length_property_of_an_Array_object" name="Redefining_the_length_property_of_an_Array_object">Переопределение свойства <code>length</code> на объекте <code>Array</code></h3>
+<h3 id="Redefining_the_length_property_of_an_Array_object">Переопределение свойства <code>length</code> на объекте <code>Array</code></h3>
 
 <p>На массивах возможно переопределить свойство {{jsxref("Array.length", "length")}}, при условии соблюдения обычных ограничений на переопределение. (Изначально свойство {{jsxref("Array.length", "length")}} является ненастраиваемым, неперечисляемым и записываемым. Таким образом, на неизмененном массиве возможно изменить значение свойства {{jsxref("Array.length", "length")}} либо сделать его незаписываемым. Его перечисляемость или настраиваемость изменить нельзя, так же как и его записываемость, если оно сделано не записываемым.) Однако не все браузеры поддерживают такое переопределение.</p>
 
@@ -326,7 +326,7 @@ arc.getArchive(); // [{ val: 11 }, { val: 13 }]
 
 <p>Только Internet Explorer 9 и выше, а так же Firefox 23 и выше, по-видимому, полностью и правильно реализуют переопределение свойства {{jsxref("Array.length", "length")}} массивов. В настоящее время не стоит полагаться на работу переопределения свойства {{jsxref("Array.length", "length")}} массива, или что оно работает определённым образом. И даже если вы <em>можете</em> положиться на это, <a href="http://whereswalden.com/2013/08/05/new-in-firefox-23-the-length-property-of-an-array-can-be-made-non-writable-but-you-shouldnt-do-it/">есть действительно веская причина не делать этого</a>.</p>
 
-<h3 id="Internet_Explorer_8_specific_notes" name="Internet_Explorer_8_specific_notes">Примечания по Internet Explorer 8</h3>
+<h3 id="Internet_Explorer_8_specific_notes">Примечания по Internet Explorer 8</h3>
 
 <p>Реализация метода <code>Object.defineProperty()</code> в Internet Explorer 8 предусматривает, что он может быть <a class="external" href="http://msdn.microsoft.com/en-us/library/dd229916%28VS.85%29.aspx">использован только для объектов DOM</a>. Нужно также отметить несколько моментов:</p>
 
@@ -343,7 +343,7 @@ arc.getArchive(); // [{ val: 11 }, { val: 13 }]
   attempt to define a "prototype" property, on a function, with
   <code>writable: false</code> doesn't work as expected.</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Enumerability_and_ownership_of_properties">Перечисляемость и собственность свойств</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/freeze/index.html b/files/ru/web/javascript/reference/global_objects/object/freeze/index.html
index bd987a2915..30ae4dc466 100644
--- a/files/ru/web/javascript/reference/global_objects/object/freeze/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/freeze/index.html
@@ -13,11 +13,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze
 
 <p>Метод <code><strong>Object.freeze()</strong></code> замораживает объект: это значит, что он предотвращает добавление новых свойств к объекту, удаление старых свойств из объекта и изменение существующих свойств или значения их атрибутов перечисляемости, настраиваемости и записываемости. В сущности, объект становится эффективно неизменным. Метод возвращает замороженный объект.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.freeze(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
@@ -28,13 +28,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze
 
 <p>Замороженный объект</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>К замороженному объекту нельзя добавить никаких свойств, так же как и удалить свойства из замороженного объекта. Любые попытки сделать это потерпят неудачу, либо молча, либо выбросив исключение {{jsxref("Global_Objects/TypeError", "TypeError")}} (как правило, но не обязательно, это происходит в {{jsxref("Functions_and_function_scope/Strict_mode", "строгом режиме", "", 1)}}).</p>
 
 <p>Значения свойств-данных не могут быть изменены. Свойства-доступы (геттеры и сеттеры) работают как положено (и всё ещё создают иллюзию, что вы изменили значение). Обратите внимание, что значения, являющиеся объектами, всё ещё могут быть изменены, если только они так же не были заморожены.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">var obj = {
   prop: function() {},
@@ -112,7 +112,7 @@ obj2.internal.a = 'другоеЗначение';
 obj2.internal.a; // undefined
 </pre>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 
 <p>В ES5 если аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES2015 такой аргумент будет рассматриваться, как простой замороженный объект и метод его просто вернёт.</p>
 
@@ -123,7 +123,7 @@ TypeError: 1 is not an object // код ES5
 1                             // код ES2015
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -150,11 +150,11 @@ TypeError: 1 is not an object // код ES5
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Object.freeze")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.isFrozen()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html b/files/ru/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
index 5e6508d9a4..5b2805579e 100644
--- a/files/ru/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
@@ -10,13 +10,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDes
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>Object.getOwnPropertyDescriptor()</strong></code> возвращает дескриптор свойства для <dfn>собственного свойства</dfn> (то есть такого, которое находится непосредственно в объекте, а не получено через цепочку прототипов) переданного объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Object.getOwnPropertyDescriptor(<var>obj</var>, <var>prop</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>obj</code></dt>
  <dd>Объект, в котором ищется свойство.</dd>
@@ -24,10 +24,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDes
  <dd>Имя свойства, чьё описание будет возвращено.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 <p>Дескриптор переданного свойства, если оно присутствует в объекте, либо {{jsxref("undefined")}}, если его там нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Этот метод позволяет просмотреть точное описание свойства. <dfn>Свойство</dfn> в JavaScript состоит из строкового имени и дескриптора свойства. Подробная информация о типах дескрипторов свойств и их атрибутах может быть найдена в описании метода {{jsxref("Object.defineProperty()")}}.</p>
 <p><dfn>Дескриптор свойства</dfn> — это запись с некоторыми из следующих атрибутов:</p>
 <dl>
@@ -45,7 +45,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDes
  <dd>Значение <code>true</code>, если это свойство доступно при перечислении свойств содержащего его объекта, иначе <code>false</code>.</dd>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">var o, d;
 
 o = { get foo() { return 17; } };
@@ -62,7 +62,7 @@ d = Object.getOwnPropertyDescriptor(o, 'baz');
 // d равен { value: 8675309, writable: false, enumerable: false, configurable: false }
 </pre>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 <p>В ES5, если первый аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES6 такой аргумент будет сначала приведён к объекту.</p>
 <pre class="brush: js">&gt; Object.getOwnPropertyDescriptor('foo', 0)
 TypeError: "foo" is not an object  // код ES5
@@ -71,7 +71,7 @@ TypeError: "foo" is not an object  // код ES5
 { configurable: false, enumerable: true, value: 'f', writable: false }  // код ES6
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -92,10 +92,10 @@ TypeError: "foo" is not an object  // код ES5
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.defineProperty()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/object/getownpropertynames/index.html b/files/ru/web/javascript/reference/global_objects/object/getownpropertynames/index.html
index c280afe9ba..9d7c319b68 100644
--- a/files/ru/web/javascript/reference/global_objects/object/getownpropertynames/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/getownpropertynames/index.html
@@ -17,11 +17,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNam
 
 <p>{{EmbedInteractiveExample("pages/js/object-getownpropertynames.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="brush: js"><code>Object.getOwnPropertyNames(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
@@ -32,13 +32,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNam
 
 <p>Массив строк, который соответствует свойствам, найденным непосредственно в данном объекте.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>Object.getOwnPropertyNames</code> возвращает массив строк, соответствующих перечисляемым <em>и неперечисляемым</em> свойствам, найденным непосредственно в объекте <code>obj</code>. Порядок перечисляемых свойств в массиве соответствует порядку при обходе объекта циклом {{jsxref("Statements/for...in", "for...in")}} (или при возврате методом {{jsxref("Object.keys")}}). Порядок неперечисляемых свойств в массиве, а также их местоположение среди перечисляемых свойств не определены.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_Object.getOwnPropertyNames" name="Example:_Using_Object.getOwnPropertyNames">Пример: использование <code>Object.getOwnPropertyNames()</code></h3>
+<h3 id="Example:_Using_Object.getOwnPropertyNames">Пример: использование <code>Object.getOwnPropertyNames()</code></h3>
 
 <pre class="brush: js">var arr = ['a', 'b', 'c'];
 console.log(Object.getOwnPropertyNames(arr).sort()); // напечатает '0,1,2,length'
@@ -89,7 +89,7 @@ alert(
 );
 </pre>
 
-<h3 id="Example:_Get_Non-Enumerable_Only" name="Example:_Get_Non-Enumerable_Only">Пример: получение только не перечисляемых свойств</h3>
+<h3 id="Example:_Get_Non-Enumerable_Only">Пример: получение только не перечисляемых свойств</h3>
 
 <p>Здесь используется функция {{jsxref("Array.prototype.filter()")}} для удаления перечисляемых ключей (полученных через метод {{jsxref("Object.keys()")}}) из списка всех ключей (полученных через метод <code>Object.getOwnPropertyNames()</code>) и, таким образом, оставляющая только неперечисляемые ключи.</p>
 
@@ -110,7 +110,7 @@ var nonenum_only = enum_and_nonenum.filter(function(key) {
 console.log(nonenum_only);
 </pre>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 
 <p>В ES5, если аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES6 такой аргумент будет приведён к объекту.</p>
 
@@ -121,7 +121,7 @@ TypeError: "foo" is not an object // код ES5
 ['length', '0', '1', '2']         // код ES6
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -143,13 +143,13 @@ TypeError: "foo" is not an object // код ES5
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Object.getOwnPropertyNames")}}</div>
 
 <p> </p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Enumerability_and_ownership_of_properties">Перечисляемость и собственность свойств</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html b/files/ru/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html
index 6b5c6f5c15..f71b1c7c40 100644
--- a/files/ru/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html
@@ -20,11 +20,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySym
 <p>Исходный код этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, пожалуйста, клонируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и отправьте нам запрос на извлечение.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="brush: js"><code>Object.getOwnPropertySymbols(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
@@ -35,13 +35,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySym
 
 <p>Массив всех свойств символа, найденных прямо на данном объекте.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Подобно методу {{jsxref("Object.getOwnPropertyNames()")}}, вы можете получить все символьные свойства указанного объекта в качестве массива символов. Обратите внимание, что метод {{jsxref("Object.getOwnPropertyNames()")}} сам не возвращает символьные свойства объекта, он возвращает только строковые свойства.</p>
 
 <p>Поскольку изначально никакой объект не содержит собственных символьных свойств, метод <code>Object.getOwnPropertySymbols()</code> будет возвращать пустой массив, пока вы не установите символьные свойства на вашем объекте.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">var obj = {};
 var a = Symbol('a');
@@ -57,7 +57,7 @@ console.log(objectSymbols);        // [Symbol(a), Symbol(b)]
 console.log(objectSymbols[0]);     // Symbol(a)
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -74,7 +74,7 @@ console.log(objectSymbols[0]);     // Symbol(a)
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p> </p>
 
@@ -82,7 +82,7 @@ console.log(objectSymbols[0]);     // Symbol(a)
 
 <div id="compat-desktop"> </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/getprototypeof/index.html b/files/ru/web/javascript/reference/global_objects/object/getprototypeof/index.html
index 36f494a5f9..9bfeadebaa 100644
--- a/files/ru/web/javascript/reference/global_objects/object/getprototypeof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/getprototypeof/index.html
@@ -11,22 +11,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Object.getPrototypeOf()</code></strong> возвращает прототип (то есть, внутреннее свойство <code>[[Prototype]]</code>) указанного объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.getPrototypeOf(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
  <dd>Объект, чей прототип будет возвращён.</dd>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">var proto = {};
 var obj = Object.create(proto);
@@ -39,7 +39,7 @@ TypeError: "foo" is not an object  // код ES5
 String.prototype                   // код ES6
 </pre>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 
 <p>В ES5, если параметр <code>obj</code> не является объектом, будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES6, параметр будет приведён к объекту {{jsxref("Global_Objects/Object", "Object")}}.</p>
 
@@ -49,7 +49,7 @@ TypeError: "foo" is not an object  // код ES5
 String.prototype                   // код ES6
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -71,15 +71,15 @@ String.prototype                   // код ES6
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h3 id="Opera-specific_notes" name="Opera-specific_notes">Примечания по Opera</h3>
+<h3 id="Opera-specific_notes">Примечания по Opera</h3>
 
 <p>Хотя старые версии Opera и не поддерживают метод <code>Object.getPrototypeOf()</code>, Opera поддерживает нестандартное свойство {{jsxref("Object.proto", "__proto__")}}, начиная с версии Opera 10.50.</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/hasownproperty/index.html b/files/ru/web/javascript/reference/global_objects/object/hasownproperty/index.html
index 152b8989c2..f8f61d0df6 100644
--- a/files/ru/web/javascript/reference/global_objects/object/hasownproperty/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/hasownproperty/index.html
@@ -12,28 +12,28 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>hasOwnProperty()</strong></code> возвращает логическое значение, указывающее, содержит ли объект указанное свойство.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>obj</var>.hasOwnProperty(<var>prop</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>prop</code></dt>
  <dd>Имя проверяемого свойства.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Каждый объект, произошедший от {{jsxref("Global_Objects/Object", "Object")}}, наследует метод <code>hasOwnProperty</code>. Этот метод может использоваться для определения того, содержит ли объект указанное свойство в качестве собственного свойства объекта; в отличие от оператора {{jsxref("Operators/in", "in")}}, этот метод не проверяет существование свойств в цепочке прототипов объекта.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_hasOwnProperty_to_test_for_a_property.27s_existence" name="Example:_Using_hasOwnProperty_to_test_for_a_property.27s_existence">Пример: использование <code>hasOwnProperty</code> для проверки существования свойства</h3>
+<h3 id="Example:_Using_hasOwnProperty_to_test_for_a_property.27s_existence">Пример: использование <code>hasOwnProperty</code> для проверки существования свойства</h3>
 
 <p>В следующем примере определяется, содержит ли объект <code>o</code> свойство с именем <code>prop</code>:</p>
 
@@ -50,7 +50,7 @@ changeO();
 o.hasOwnProperty('prop');   // вернёт false
 </pre>
 
-<h3 id="Example:_Direct_versus_inherited_properties" name="Example:_Direct_versus_inherited_properties">Пример: собственные и унаследованные свойства</h3>
+<h3 id="Example:_Direct_versus_inherited_properties">Пример: собственные и унаследованные свойства</h3>
 
 <p>Следующий пример показывает разницу между собственными свойствами и свойствами, унаследованными через цепочку прототипов:</p>
 
@@ -61,7 +61,7 @@ o.hasOwnProperty('toString');         // вернёт false
 o.hasOwnProperty('hasOwnProperty');   // вернёт false
 </pre>
 
-<h3 id="Example:_Itarate_over_properties_not_considering_inherited_properties" name="Example:_Itarate_over_properties_not_considering_inherited_properties">Пример: обход свойств объекта</h3>
+<h3 id="Example:_Itarate_over_properties_not_considering_inherited_properties">Пример: обход свойств объекта</h3>
 
 <p>Следующий пример показывает, как итерироваться по свойствам объекта с пропуском унаследованных свойств. Обратите внимание, что цикл {{jsxref("Statements/for...in", "for...in")}} уже проходит только по перечисляемым элементам, так что не надо на основании отсутствия не перечисляемых свойств, показываемых в цикле, считать, что метод <code>hasOwnProperty</code> сам ограничивает свойства только перечисляемыми элементами (как это делает метод {{jsxref("Object.getOwnPropertyNames()")}}).</p>
 
@@ -79,7 +79,7 @@ for (var name in buz) {
 }
 </pre>
 
-<h3 id="Example:_hasOwnProperty_as_a_property" name="Example:_hasOwnProperty_as_a_property">Пример: <code>hasOwnProperty</code> как свойство</h3>
+<h3 id="Example:_hasOwnProperty_as_a_property">Пример: <code>hasOwnProperty</code> как свойство</h3>
 
 <p>JavaScript не защищает имя свойства <code>hasOwnProperty</code>; таким образом, вполне может существовать объект с таким свойством, поэтому для получения правильного результата нужно использовать <em>внешний</em> метод <code>hasOwnProperty</code>:</p>
 
@@ -101,7 +101,7 @@ Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
 
 <p>Обратите внимание, что в последнем случае новые объекты не создаются.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -128,13 +128,13 @@ Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.Object.hasOwnProperty")}}</p>
 </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Enumerability_and_ownership_of_properties">Перечисляемость и собственность свойств</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/index.html b/files/ru/web/javascript/reference/global_objects/object/index.html
index 298cf5255f..0889015eaf 100644
--- a/files/ru/web/javascript/reference/global_objects/object/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/index.html
@@ -11,11 +11,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Конструктор <code><strong>Object</strong></code> создаёт объект-обёртку.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>// Инициализатор объекта или литерал
 { [ <var>nameValuePair1</var>[, <var>nameValuePair2</var>[, ...<var>nameValuePairN</var>] ] ] }
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object
 new Object([<var>value</var>])
 </code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>nameValuePair1, nameValuePair2, ... nameValuePair<em>N</em></code></dt>
@@ -33,7 +33,7 @@ new Object([<var>value</var>])
  <dd>Любое значение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Конструктор <code>Object</code> создаёт объект-обёртку для переданного значения. Если значением является {{jsxref("Global_Objects/null", "null")}} или {{jsxref("Global_Objects/undefined", "undefined")}}, создаёт и возвращает пустой объект, в противном случае возвращает объект такого типа, который соответствует переданному значению. Если значение уже является объектом, конструктор вернёт это значение.</p>
 
@@ -41,7 +41,7 @@ new Object([<var>value</var>])
 
 <p>Так же смотрите {{jsxref("Operators/Object_initializer", "синтаксис инициализатора объекта / литеральный синтаксис", "", 1)}}.</p>
 
-<h2 id="Properties" name="Properties">Свойства конструктора <code>Object</code></h2>
+<h2 id="Properties">Свойства конструктора <code>Object</code></h2>
 
 <dl>
  <dt><code>Object.length</code></dt>
@@ -50,7 +50,7 @@ new Object([<var>value</var>])
  <dd>Позволяет добавлять свойства ко всем объектам типа <code>Object</code>.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы конструктора <code>Object</code></h2>
+<h2 id="Methods">Методы конструктора <code>Object</code></h2>
 
 <dl>
  <dt>{{jsxref("Object.assign()")}}</dt>
@@ -91,21 +91,21 @@ new Object([<var>value</var>])
  <dd>Устанавливает прототип (т.е. внутреннее свойство <code>[[Prototype]]</code>)</dd>
 </dl>
 
-<h2 id="Object_instances" name="Object_instances">Экземпляры и прототип объекта <code>Object</code></h2>
+<h2 id="Object_instances">Экземпляры и прототип объекта <code>Object</code></h2>
 
 <p>Все объекты в JavaScript являются потомками <code>Object</code>; все объекты наследуют методы и свойства из прототипа объекта {{jsxref("Object.prototype")}}, хотя они и могут быть переопределены. Например, прототипы других конструкторов переопределяют свойство <code>constructor</code> и предоставляют свои собственные методы <code>toString()</code>. Изменения в объекте прототипа <code>Object</code> распространяются на все объекты до тех пор, пока свойства и методы, учитывающие эти изменения, не переопределяются дальше по цепочке прототипов.</p>
 
-<h3 id="Properties_of_Object_instances" name="Properties_of_Object_instances">Свойства</h3>
+<h3 id="Properties_of_Object_instances">Свойства</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_Object_instances" name="Methods_of_Object_instances">Методы</h3>
+<h3 id="Methods_of_Object_instances">Методы</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example.3A_Using_Object_given_undefined_and_null_types" name="Example.3A_Using_Object_given_undefined_and_null_types">Пример: использование <code>Object</code> с типами <code>undefined</code> и <code>null</code></h3>
+<h3 id="Example.3A_Using_Object_given_undefined_and_null_types">Пример: использование <code>Object</code> с типами <code>undefined</code> и <code>null</code></h3>
 
 <p>Следующий пример сохраняет пустой объект <code>Object</code> в переменную <code>o</code>:</p>
 
@@ -130,7 +130,7 @@ var o = new Object(true);
 var o = new Object(Boolean());
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -157,11 +157,11 @@ var o = new Object(Boolean());
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Reference/Operators/Object_initializer">Инициализатор объекта</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/is/index.html b/files/ru/web/javascript/reference/global_objects/object/is/index.html
index c921d8a772..166b560d56 100644
--- a/files/ru/web/javascript/reference/global_objects/object/is/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/is/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/is
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>Object.is()</strong></code> определяет, являются ли два значения <a href="/ru/docs/Web/JavaScript/Guide/Sameness">одинаковыми значениями</a>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>var <var>isSame</var> = Object.is(<var>value1</var>, <var>value2</var>);</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>value1</code></dt>
@@ -29,7 +29,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/is
  <dd>Второе сравниваемое значение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>Object.is()</code> определяет, являются ли два значения <a href="/ru/docs/Web/JavaScript/Guide/Sameness">одинаковыми значениями</a>. Два значения являются одинаковыми в следующих случаях:</p>
 
@@ -53,7 +53,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/is
 
 <p>Поведение этого метода <em>не</em> аналогично оператору {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}. Оператор {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}} (также как и оператор {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}) считает числовые значения <code>-0</code> и <code>+0</code> равными, а значение {{jsxref("Number.NaN")}} не равным самому себе.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">Object.is('foo', 'foo');     // true
 Object.is(window, window);   // true
@@ -72,7 +72,7 @@ Object.is(-0, -0);           // true
 Object.is(NaN, 0/0);         // true
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>Object.is</code> предложен в дополнение к стандарту ECMA-262; поэтому он может быть недоступен в некоторых браузерах. Это можно обойти, вставив приведённый ниже фрагмент кода в начало ваших скриптов. Он позволит вам использовать метод <code>Object.is</code> в случаях, когда он не имеет родной поддержки браузером.</p>
 
@@ -89,7 +89,7 @@ Object.is(NaN, 0/0);         // true
   };
 }</code></pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -111,11 +111,11 @@ Object.is(NaN, 0/0);         // true
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Object.is")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Guide/Sameness">Руководство по JavaScript: одинаковость</a> — сравнение всех трёх встроенных способов проверки на одинаковость</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/isextensible/index.html b/files/ru/web/javascript/reference/global_objects/object/isextensible/index.html
index 6c133d1ea7..5bc47ed782 100644
--- a/files/ru/web/javascript/reference/global_objects/object/isextensible/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/isextensible/index.html
@@ -11,22 +11,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/isExtensible
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>Object.isExtensible()</code></strong> определяет, является ли объект расширяемым (то есть, можно ли к нему добавлять новые свойства).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Object.isExtensible(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>obj</code></dt>
  <dd>Проверяемый объект.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Объекты являются расширяемыми по умолчанию: к ним можно добавлять новые свойства и (в движках, поддерживающих свойство {{jsxref("Object.proto", "__proto__")}}) их можно изменять. Объект может быть помечен, как не изменяемый с помощью методов {{jsxref("Object.preventExtensions()")}}, {{jsxref("Object.seal()")}} или {{jsxref("Object.freeze()")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">// Новые объекты являются расширяемыми.
 var empty = {};
 assert(Object.isExtensible(empty) === true);
@@ -44,7 +44,7 @@ var frozen = Object.freeze({});
 assert(Object.isExtensible(frozen) === false);
 </pre>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 <p>В ES5, если аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES6 такой аргумент будет рассматриваться, как простой не расширяемый объект и метод просто вернёт <code>false</code>.</p>
 <pre class="brush: js">&gt; Object.isExtensible(1)
 TypeError: 1 is not an object // код ES5
@@ -53,7 +53,7 @@ TypeError: 1 is not an object // код ES5
 false                         // код ES6
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -74,10 +74,10 @@ false                         // код ES6
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.preventExtensions()")}}</li>
  <li>{{jsxref("Object.seal()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/isfrozen/index.html b/files/ru/web/javascript/reference/global_objects/object/isfrozen/index.html
index 1970718f05..6ccafb579a 100644
--- a/files/ru/web/javascript/reference/global_objects/object/isfrozen/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/isfrozen/index.html
@@ -11,26 +11,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/isFrozen
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>Object.isFrozen()</strong></code> определяет, был ли объект заморожен.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.isFrozen(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
  <dd>Проверяемый объект.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Объект является замороженным только в том случае, если он не {{jsxref("Object.isExtensible()", "расширяем", "", 1)}}, все его свойства являются не настраиваемыми и все его свойства данных (то есть такие, которые не являются свойствами доступа с функциями сеттера или геттера) являются не записываемыми.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">// Новый объект является расширяемым, так что он не заморожен.
 assert(Object.isFrozen({}) === false);
@@ -94,7 +94,7 @@ assert(Object.isExtensible(frozen) === false);
 assert(Object.isSealed(frozen) === true);
 </pre>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 
 <p>В ES5, если аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES6 такой аргумент будет рассматриваться, как простой замороженный объект и метод просто вернёт <code>true</code>.</p>
 
@@ -105,7 +105,7 @@ TypeError: 1 is not an object // код ES5
 true                          // код ES6
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -127,11 +127,11 @@ true                          // код ES6
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Object.isFrozen")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.freeze()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/isprototypeof/index.html b/files/ru/web/javascript/reference/global_objects/object/isprototypeof/index.html
index 26672560d5..55c0ca9276 100644
--- a/files/ru/web/javascript/reference/global_objects/object/isprototypeof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/isprototypeof/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>isPrototypeOf()</strong></code> проверяет, входит ли объект в цепочку прототипов другого объекта.</p>
 
@@ -19,11 +19,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf
 <p><strong>Обратите внимание:</strong> метод <code>isPrototypeOf()</code> отличается от оператора {{jsxref("Operators/instanceof", "instanceof")}}. Выражение "<code>object instanceof AFunction</code>" проверяет, присутствует ли в цепочке прототипов объекта <code>object</code> объект <code>AFunction.prototype</code>, а не сам объект <code>AFunction</code>.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>prototypeObj</var>.isPrototypeOf(<var>object</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>prototypeObj</code></dt>
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf
  <dd>Объект, в чьей цепочке прототипов производится поиск.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>isPrototypeOf()</code> позволяет вам проверять, существует ли объект в цепочке прототипов другого объекта.</p>
 
@@ -70,7 +70,7 @@ if (Fi.prototype.isPrototypeOf(fum)) {
 
 <p>Таким образом, вместе с оператором {{jsxref("Operators/instanceof", "instanceof")}}, это особенно пригождается, если у вас есть код, который может работать только с объектами, имеющими определённую цепочку прототипов, к примеру, чтобы он мог гарантировать, что в объекте присутствуют определённые методы или свойства.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -97,11 +97,11 @@ if (Fi.prototype.isPrototypeOf(fum)) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Operators/instanceof", "instanceof")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/issealed/index.html b/files/ru/web/javascript/reference/global_objects/object/issealed/index.html
index 26884d3924..baf2d98dc8 100644
--- a/files/ru/web/javascript/reference/global_objects/object/issealed/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/issealed/index.html
@@ -11,20 +11,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/isSealed
 ---
 <div>
  {{JSRef("Global_Objects", "Object")}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>Object.isSealed()</strong></code> определяет, является ли объект запечатанным.</p>
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>Object.isSealed(<var>obj</var>)</code></pre>
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt>
   <code>obj</code></dt>
  <dd>
   Проверяемый объект.</dd>
 </dl>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Возвращает <code>true</code>, если объект является запечатанным, иначе возвращает <code>false</code>. Объект является запечатанным, если он является не {{jsxref("Object.isExtensible", "расширяемым", "", 1)}} и если все его свойства являются не настраиваемыми и, следовательно, не удаляемыми (но не обязательно не записываемыми).</p>
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 <pre class="brush: js">// По умолчанию объекты не запечатаны.
 var empty = {};
 assert(Object.isSealed(empty) === false);
@@ -59,7 +59,7 @@ assert(Object.isFrozen(s2) === false); // свойство 'p' всё ещё з
 var s3 = Object.seal({ get p() { return 0; } });
 assert(Object.isFrozen(s3) === true); // для свойств доступа значение имеет только их настраиваемость
 </pre>
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 <p>В ES5, если аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES6 такой аргумент будет рассматриваться, как простой запечатанный объект и метод просто вернёт <code>true</code>.</p>
 <pre class="brush: js">&gt; Object.isSealed(1)
 TypeError: 1 is not an object // код ES5
@@ -67,7 +67,7 @@ TypeError: 1 is not an object // код ES5
 &gt; Object.isSealed(1)
 true                          // код ES6
 </pre>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -87,11 +87,11 @@ true                          // код ES6
   </tr>
  </tbody>
 </table>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.seal()")}}</li>
  <li>{{jsxref("Object.preventExtensions()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/keys/index.html b/files/ru/web/javascript/reference/global_objects/object/keys/index.html
index 8ac8883ad2..70d338ebe4 100644
--- a/files/ru/web/javascript/reference/global_objects/object/keys/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/keys/index.html
@@ -14,26 +14,26 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/keys
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>Object.keys()</strong></code> возвращает массив из собственных перечисляемых свойств переданного объекта, в том же порядке, в котором они бы обходились циклом {{jsxref("Statements/for...in", "for...in")}} (разница между циклом и методом в том, что цикл перечисляет свойства и из цепочки прототипов).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.keys(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
  <dd>Объект, чьи собственные перечисляемые свойства будут возвращены.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>Object.keys</code> возвращает массив строковых элементов, соответствующих именам перечисляемых свойств, найденных непосредственно в самом объекте. Порядок свойств такой же, как и при ручном перечислении свойств в объекте через цикл.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">var arr = ['a', 'b', 'c'];
 console.log(Object.keys(arr)); // консоль: ['0', '1', '2']
@@ -55,7 +55,7 @@ console.log(Object.keys(my_obj)); // консоль: ['foo']
 
 <p>Если вы хотите увидеть все свойства, а не только перечисляемые, смотрите метод {{jsxref("Object.getOwnPropertyNames()")}}.</p>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 
 <p>В ES5, если аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES2015 такой аргумент будет приведён к объекту.</p>
 
@@ -66,7 +66,7 @@ TypeError: 'foo' is not an object // код ES5
 ['0', '1', '2']                   // код ES2015
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Для добавления поддержки совместимого метода <code>Object.keys</code> в старых окружениях, которые его ещё не реализуют, скопируйте следующий кусок кода:</p>
 
@@ -117,7 +117,7 @@ if (!Object.keys) {
 
 <p>Более простой полифил может быть найден в статье <a href="http://tokenposts.blogspot.com.au/2012/04/javascript-objectkeys-browser.html">Javascript - Object.keys Browser Compatibility</a> (англ.).</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -139,11 +139,11 @@ if (!Object.keys) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.Object.keys")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Enumerability_and_ownership_of_properties">Перечисляемость и собственность свойств</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/preventextensions/index.html b/files/ru/web/javascript/reference/global_objects/object/preventextensions/index.html
index 6488f99506..5e909db99e 100644
--- a/files/ru/web/javascript/reference/global_objects/object/preventextensions/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/preventextensions/index.html
@@ -15,11 +15,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
 
 <p>{{EmbedInteractiveExample("pages/js/object-preventextensions.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="brush: js"><code>Object.preventExtensions(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
 
 <p>Объект, который делается нерасширяемым.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Объект называется расширяемым, если к нему могут быть добавлены новые свойства. <code>Object.preventExtensions()</code> помечает объект как нерасширяемый, так что он никогда не будет иметь других свойств, кроме тех, что были у него на момент пометки его нерасширяемым. Обратите внимание, что, в общем случае, свойства нерасширяемого объекта всё ещё могут быть <em>удалены</em>. Попытка добавить новые свойства к нерасширяемому объекту потерпит неудачу, либо молча, либо с выбрасыванием исключения {{jsxref("Global_Objects/TypeError", "TypeError")}} (как правило, но не обязательно, это происходит в {{jsxref("Functions_and_function_scope/Strict_mode", "строгом режиме", "", 1)}}).</p>
 
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
 
 <p>Если превратить расширяемый объект в нерасширяемый возможно, в ECMAScript 5 нет никакого способа сделать обратную операцию.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">// Object.preventExtensions возвращает объект, который нужно сделать нерасширяемым.
 var obj = {};
@@ -72,7 +72,7 @@ var fixed = Object.preventExtensions({});
 fixed.__proto__ = { oh: 'hai' }; // выбросит TypeError
 </pre>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 
 <p>В ES5, если аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES6 такой аргумент будет рассматриваться как простой нерасширяемый объект и метод его просто вернёт.</p>
 
@@ -83,7 +83,7 @@ TypeError: 1 is not an object // код ES5
 1                             // код ES6
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -105,11 +105,11 @@ TypeError: 1 is not an object // код ES5
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Object.preventExtensions")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.isExtensible()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/propertyisenumerable/index.html b/files/ru/web/javascript/reference/global_objects/object/propertyisenumerable/index.html
index ababc70c18..0dca10f65e 100644
--- a/files/ru/web/javascript/reference/global_objects/object/propertyisenumerable/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/propertyisenumerable/index.html
@@ -11,24 +11,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumera
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>propertyIsEnumerable()</strong></code> возвращает логическое значение, указывающее, является ли указанное свойство перечисляемым.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>obj</var>.propertyIsEnumerable(<var>prop</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>prop</code></dt>
  <dd>Имя проверяемого свойства.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Каждый объект имеет метод <code>propertyIsEnumerable</code>. Этот метод может определять, является ли указанное свойство в объекте перечисляемым в цикле {{jsxref("Statements/for...in", "for...in")}}, за исключением свойств, унаследованных из цепочки прототипов. Если объект не имеет указанного свойства, метод вернёт <code>false</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_A_basic_use_of_propertyIsEnumerable" name="Example:_A_basic_use_of_propertyIsEnumerable">Пример: базовое использование <code>propertyIsEnumerable</code></h3>
+<h3 id="Example:_A_basic_use_of_propertyIsEnumerable">Пример: базовое использование <code>propertyIsEnumerable</code></h3>
 <p>Следующий пример показывает использование метода <code>propertyIsEnumerable</code> на объектах и массивах:</p>
 <pre class="brush: js">var o = {};
 var a = [];
@@ -39,7 +39,7 @@ o.propertyIsEnumerable('prop');   // вернёт true
 a.propertyIsEnumerable(0);        // вернёт true
 </pre>
 
-<h3 id="Example:_User-defined_versus_built-in_objects" name="Example:_User-defined_versus_built-in_objects">Пример: определённые пользователем и встроенные объекты</h3>
+<h3 id="Example:_User-defined_versus_built-in_objects">Пример: определённые пользователем и встроенные объекты</h3>
 <p>Следующий пример демонстрирует перечисляемость свойств, определённых пользователем и встроенных свойств:</p>
 <pre class="brush: js">var a = ['перечисляемое'];
 
@@ -50,7 +50,7 @@ Math.propertyIsEnumerable('random');   // вернёт false
 this.propertyIsEnumerable('Math');     // вернёт false
 </pre>
 
-<h3 id="Example:_Direct_versus_inherited_properties" name="Example:_Direct_versus_inherited_properties">Пример: собственные и унаследованные свойства</h3>
+<h3 id="Example:_Direct_versus_inherited_properties">Пример: собственные и унаследованные свойства</h3>
 <pre class="brush: js">var a = [];
 a.propertyIsEnumerable('constructor');         // вернёт false
 
@@ -86,7 +86,7 @@ o.propertyIsEnumerable('constructor'); // вернёт false
 o.propertyIsEnumerable('firstMethod'); // вернёт false
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -112,10 +112,10 @@ o.propertyIsEnumerable('firstMethod'); // вернёт false
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li><a href="/ru/docs/Enumerability_and_ownership_of_properties">Перечисляемость и собственность свойств</a></li>
  <li>{{jsxref("Statements/for...in", "for...in")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/proto/index.html b/files/ru/web/javascript/reference/global_objects/object/proto/index.html
index 5d0cfb75dc..0d6219bd5c 100644
--- a/files/ru/web/javascript/reference/global_objects/object/proto/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/proto/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto
 <p><strong>Предупреждение:</strong> хотя на сегодняшний момент большинство браузеров поддерживают свойство <code>Object.prototype.__proto__</code>, его поведение только недавно было стандартизировано в новой спецификации ECMAScript 6. Если вам требуется поддержка браузеров до этой спецификации, рекомендуется использовать вместо него метод {{jsxref("Object.getPrototypeOf()")}}.</p>
 </div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Свойство <code>__proto__</code> объекта {{jsxref("Object.prototype")}} является свойством доступа (комбинацией геттера и сеттера), которое расширяет внутренний прототип <code>[[Prototype]]</code> объекта (являющийся объектом или {{jsxref("Global_Objects/null", "null")}}), через который осуществлялся доступ.</p>
 
@@ -28,7 +28,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto
 
 <p>Свойство <code>__proto__</code> также может использоваться при определении литерала объекта, устанавливая прототип <code>[[Prototype]]</code> объекта при его создании. Этот способ может рассматриваться как альтернатива методу {{jsxref("Object.create()")}}. Смотрите также <a href="/ru/docs/Web/JavaScript/Reference/Operators/Object_initializer">литеральный синтаксис инициализации объекта</a>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="brush: js">var shape = {}, circle = new Circle();
 
@@ -40,7 +40,7 @@ console.log(shape.__proto__ === circle); // true
 
 <p>Обратите внимание: название свойства состоит из двух подчёркиваний, следующих за ними пяти символов «proto» и следующих за ними ещё двух подчёркиваний.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Геттер свойства <code>__proto__</code> расширяет значение внутреннего прототипа <code>[[Prototype]]</code> объекта. Для объектов, созданных с использованием литеральной формы создания объекта, это значение равно {{jsxref("Object.prototype")}}. Для функций это значение равно {{jsxref("Function.prototype")}}. Для объектов, созданных с использованием формы <code>new fun</code>, где <code>fun</code> является одной из встроенных функций-конструкторов, предоставляемых JavaScript ({{jsxref("Global_Objects/Array", "Array")}}, {{jsxref("Global_Objects/Boolean", "Boolean")}}, {{jsxref("Global_Objects/Date", "Date")}}, {{jsxref("Global_Objects/Number", "Number")}}, {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/String", "String")}} и так далее — включая новые конструкторы, добавленные в процессе развития JavaScript), это значение равно <code>fun.prototype</code>. Для объектов, созданных с использованием формы <code>new fun</code>, где <code>fun</code> является функцией, определённой в скрипте, это значение равно значению <code>fun.prototype</code> во время вычисления <code>new fun</code>. Именно поэтому при присваивании <code>fun.prototype</code> нового значения, ранее созданные экземпляры <code>fun</code> продолжат использовать предыдущее значение в качестве своего прототипа <code>[[Prototype]]</code>, а последующие вызовы <code>new fun</code> будут использовать вновь присвоенное значение в качестве своего прототипа <code>[[Prototype]]</code>.</p>
 
@@ -68,7 +68,7 @@ console.log(protoHidden.__proto__); // 42
 console.log(Object.getPrototypeOf(protoHidden) === Object.prototype); // true
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <p>В следующем примере создаётся новый экземпляр <code>Employee</code>, а затем проверяется, что его свойство <code>__proto__</code> является тем же самым объектом, что и его конструктор <code>prototype</code>.</p>
 
@@ -117,7 +117,7 @@ b.hi();
 
 <p>Если свойство <code>__proto__</code> объекта {{jsxref("Object.prototype")}} не установлено в {{jsxref("Global_Objects/null", "null")}}, или в другой объект, чья цепочка прототипов, в конечном итоге, явно не заканчивается значением {{jsxref("Global_Objects/null", "null")}}, будет выкинуто исключение {{jsxref("Global_Objects/TypeError", "TypeError")}} «циклическое значение __proto__», поскольку цепочка должна заканчиваться {{jsxref("Global_Objects/null", "null")}} (как это и происходит на {{jsxref("Object.prototype")}} при нормальных обстоятельствах).</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -134,7 +134,7 @@ b.hi();
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div class="note">
 <p><strong>Примечание:</strong> спецификация ES6 требует поддержку свойства <code>__proto__</code> только в браузерах и не требует его поддержку в других окружениях (хотя оно и рекомендуется в качестве обязательного). Если ваш код должен работать в не-браузерных окружениях, вместо свойства рекомендуется использовать методы {{jsxref("Object.getPrototypeOf()")}} и {{jsxref("Object.setPrototypeOf()")}}.</p>
@@ -142,7 +142,7 @@ b.hi();
 
 <div>{{Compat("javascript.builtins.Object.proto")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/seal/index.html b/files/ru/web/javascript/reference/global_objects/object/seal/index.html
index 0f21a25cfd..6004ddb068 100644
--- a/files/ru/web/javascript/reference/global_objects/object/seal/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/seal/index.html
@@ -14,24 +14,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/seal
 
 <p>Метод <strong><code>Object.seal()</code></strong> запечатывает объект, предотвращая добавление новых свойств к объекту и делая все существующие свойства не настраиваемыми. Значения представленных свойств всё ещё могут изменяться, поскольку они остаются записываемыми.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.seal(<var>obj</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
  <dd>Запечатываемый объект.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>По умолчанию, объекты являются {{jsxref("Object.isExtensible()", "расширяемыми", "", 1)}} (к ним могут добавляться новые свойства). Запечатывание объекта предотвращает добавление к нему новых свойств и делает все существующие свойства не настраиваемыми. Оно делает все свойства объекта фиксированными и неизменными. Пометка всех свойств объекта как не настраиваемых также предотвращает их преобразование из свойств данных в свойства доступа и наоборот, но не предотвращает изменение значения свойств данных. Попытки удаления или добавления свойств к запечатанному объекту, либо преобразования свойств данных в свойства доступа и наоборот, будут терпеть неудачу, либо молча, либо с выбрасыванием исключения {{jsxref("Global_Objects/TypeError", "TypeError")}} (как правило, но не обязательно, это происходит в {{jsxref("Strict_mode", "строгом режиме", "", 1)}}).</p>
 
 <p>Цепочка прототипов не затрагивается. Однако, свойство {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} также запечатываться.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">var obj = {
   prop: function() {},
@@ -71,7 +71,7 @@ Object.defineProperty(obj, 'ohai', { value: 17 }); // выбросит TypeError
 Object.defineProperty(obj, 'foo', { value: 'eit' }); // изменяем значение существующего свойства
 </pre>
 
-<h2 id="Notes" name="Notes">Примечания</h2>
+<h2 id="Notes">Примечания</h2>
 
 <p>В ES5, если аргумент метода не является объектом (является примитивным значением), будет выброшено исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}. В ES6 такой аргумент будет рассматриваться, как простой запечатанный объект и метод его просто вернёт.</p>
 
@@ -82,7 +82,7 @@ TypeError: 1 is not an object // код ES5
 1                             // код ES6
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -104,11 +104,11 @@ TypeError: 1 is not an object // код ES5
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.Object.seal")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.isSealed()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/setprototypeof/index.html b/files/ru/web/javascript/reference/global_objects/object/setprototypeof/index.html
index 93aad25e02..ef8288b57e 100644
--- a/files/ru/web/javascript/reference/global_objects/object/setprototypeof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/setprototypeof/index.html
@@ -19,15 +19,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
 <p><strong>Предупреждение:</strong> Изменение прототипа <code>[[Prototype]]</code> объекта является, по самой природе оптимизации доступа к свойствам в современных движках JavaScript, очень медленной операцией, это справедливо для <strong><em>любого</em></strong> браузера и движка JavaScript. Изменение прототипов очень тонко и обширно влияет на производительность, причём это влияние не ограничивается просто временем, проведённым внутри метода <code>Object.setPrototypeOf()</code>, оно может распространяться на <strong><em>любой</em></strong> код, который имеет доступ к <strong><em>любому</em></strong> объекту, чей прототип <code>[[Prototype]]</code> был изменён. Если вы заботитесь о производительности, вы никогда не должны изменять прототип <code>[[Prototype]]</code> объекта. Вместо этого создайте объект с нужным прототипом <code>[[Prototype]]</code>, с помощью метода {{jsxref("Object.create()")}}.</p>
 </div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>Object.setPrototypeOf()</code></strong> устанавливает прототип (то есть, внутреннее свойство <code>[[Prototype]]</code>) указанного объекта в другой объект или {{jsxref("null")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.setPrototypeOf(<var>obj</var>, <var>prototype</var>);</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>obj</code></dt>
@@ -36,16 +36,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
  <dd>Новый прототип объекта (объект или {{jsxref("null")}}).</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Выкидывает исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}, если объект, чей прототип <code>[[Prototype]]</code> является не расширяемым, согласно методу {{jsxref("Object.isExtensible()")}}. Не делает ничего, если параметр <code>prototype</code> не является объектом или значением {{jsxref("null")}} (то есть, является числом, строкой, логическим значением или {{jsxref("undefined")}}). В противном случае метод устанавливает прототип <code>[[Prototype]]</code> объекта <code>obj</code> в новое значение.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">var dict = Object.setPrototypeOf({}, null);
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Используя старое свойство {{jsxref("Object.proto", "Object.prototype.__proto__")}}, мы можем легко определить <code>Object.setPrototypeOf()</code>, если он ещё не доступен:</p>
 
@@ -69,7 +69,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
      <span class="punctuation token">}</span>
 <span class="punctuation token">}</span></code></pre>
 
-<h2 id="Appending_Prototype_Chains" name="Appending_Prototype_Chains">Добавление цепочки прототипов</h2>
+<h2 id="Appending_Prototype_Chains">Добавление цепочки прототипов</h2>
 
 <p>Сочетание метода <code>Object.getPrototypeOf()</code> и свойства {{jsxref("Object.proto", "Object.prototype.__proto__")}} позволяет добавить целую цепочку прототипов к новому прототипу объекта:</p>
 
@@ -117,9 +117,9 @@ Object.appendChain = function(oChain, oProto) {
 }
 </pre>
 
-<h3 id="Usage" name="Usage">Использование</h3>
+<h3 id="Usage">Использование</h3>
 
-<h4 id="First_example.3A_Appending_a_chain_to_a_prototype" name="First_example.3A_Appending_a_chain_to_a_prototype">Первый пример: присоединение цепочки к прототипу</h4>
+<h4 id="First_example.3A_Appending_a_chain_to_a_prototype">Первый пример: присоединение цепочки к прототипу</h4>
 
 <pre class="brush: js">function Mammal() {
   this.isMammal = 'да';
@@ -145,7 +145,7 @@ Object.appendChain(oCat, new Animal());
 alert(oCat.breathing); // 'да'
 </pre>
 
-<h4 id="Second_example.3A_Transforming_a_primitive_value_into_an_instance_of_its_constructor_and_append_its_chain_to_a_prototype" name="Second_example.3A_Transforming_a_primitive_value_into_an_instance_of_its_constructor_and_append_its_chain_to_a_prototype">Второй пример: преобразование примитивного значения в экземпляр его конструктора и присоединение его цепочки к прототипу</h4>
+<h4 id="Second_example.3A_Transforming_a_primitive_value_into_an_instance_of_its_constructor_and_append_its_chain_to_a_prototype">Второй пример: преобразование примитивного значения в экземпляр его конструктора и присоединение его цепочки к прототипу</h4>
 
 <pre class="brush: js">function Symbol() {
   this.isSymbol = 'да';
@@ -162,7 +162,7 @@ alert(oPrime.isSymbol); // 'да'
 alert(typeof oPrime); // 'object'
 </pre>
 
-<h4 id="Third_example.3A_Appending_a_chain_to_the_Function.prototype_object_and_appending_a_new_function_to_that_chain" name="Third_example.3A_Appending_a_chain_to_the_Function.prototype_object_and_appending_a_new_function_to_that_chain">Третий пример: присоединение цепочки к объекту <code>Function.prototype</code> и новой функции к этой цепочке</h4>
+<h4 id="Third_example.3A_Appending_a_chain_to_the_Function.prototype_object_and_appending_a_new_function_to_that_chain">Третий пример: присоединение цепочки к объекту <code>Function.prototype</code> и новой функции к этой цепочке</h4>
 
 <pre class="brush: js">function Person(sName) {
   this.identity = sName;
@@ -175,7 +175,7 @@ alert(george.identity); // 'Георг'
 george(); // 'Привет, парни!!'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -192,11 +192,11 @@ george(); // 'Привет, парни!!'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/tolocalestring/index.html b/files/ru/web/javascript/reference/global_objects/object/tolocalestring/index.html
index f87dd7a89d..37a3d62dce 100644
--- a/files/ru/web/javascript/reference/global_objects/object/tolocalestring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/tolocalestring/index.html
@@ -10,20 +10,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
 ---
 <div>
  {{JSRef("Global_Objects", "Object")}}</div>
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <code><strong>toLocaleString()</strong></code> возвращает строку, представляющую объект. Этот метод предназначен для переопределения унаследованными объектами в целях поддержки зависимости от локали.</p>
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>obj</var>.toLocaleString();</code></pre>
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toLocaleString</code> объекта {{jsxref("Global_Objects/Object", "Object")}} возвращает результат вызова метода {{jsxref("Object.toString", "toString()")}}.</p>
 <p>Эта функция обеспечивает объектам обобщённый метод <code>toLocaleString</code>, хотя и не все объекты могут её использовать. Смотрите ниже список таких объектов.</p>
-<h3 id="Objects_overriding_toLocaleString" name="Objects_overriding_toLocaleString">Объекты, переопределяющие <code>toLocaleString</code></h3>
+<h3 id="Objects_overriding_toLocaleString">Объекты, переопределяющие <code>toLocaleString</code></h3>
 <ul>
  <li>{{jsxref("Global_Objects/Array", "Array")}}: {{jsxref("Array.prototype.toLocaleString()")}}</li>
  <li>{{jsxref("Global_Objects/Number", "Number")}}: {{jsxref("Number.prototype.toLocaleString()")}}</li>
  <li>{{jsxref("Global_Objects/Date", "Date")}}: {{jsxref("Date.prototype.toLocaleString()")}}</li>
 </ul>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -48,11 +48,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
   </tr>
  </tbody>
 </table>
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <div>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toString()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/object/tosource/index.html b/files/ru/web/javascript/reference/global_objects/object/tosource/index.html
index f8f8b51f9d..3213478bfa 100644
--- a/files/ru/web/javascript/reference/global_objects/object/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/tosource/index.html
@@ -13,16 +13,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource
 
 <p>Метод <strong><code>toSource()</code></strong> возвращает строку, представляющую исходный код объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Object.toSource();
 <var>obj</var>.toSource();</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>toSource()</code> возвращает следующие значения:</p>
 
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource
 
 <p>Вы можете вызывать метод <code>toSource()</code> во время отладки для просмотра содержимого объекта.</p>
 
-<h3 id="Overriding_the_toSource_method" name="Overriding_the_toSource_method">Переопределение метода <code>toSource()</code></h3>
+<h3 id="Overriding_the_toSource_method">Переопределение метода <code>toSource()</code></h3>
 
 <p>Вы можете безопасно переопределять метод <code>toSource()</code> для объектов. Например:</p>
 
@@ -54,7 +54,7 @@ Person.prototype.toSource = function Person_toSource() {
 console.log(new Person('Joe').toSource()); // ---&gt; new Person("Joe")
 </pre>
 
-<h3 id="Built-in_toString_methods" name="Built-in_toString_methods">Встроенные методы <code>toSource()</code></h3>
+<h3 id="Built-in_toString_methods">Встроенные методы <code>toSource()</code></h3>
 
 <p>Каждый тип ядра JavaScript имеет свой собственный метод <code>toSource()</code>. Вот эти объекты:</p>
 
@@ -70,7 +70,7 @@ console.log(new Person('Joe').toSource()); // ---&gt; new Person("Joe")
  <li><code>Math.toSource()</code> — возвращает строку "Math".</li>
 </ul>
 
-<h3 id="Limitations_on_cyclical_objects" name="Limitations_on_cyclical_objects">Ограничение на циклические объекты</h3>
+<h3 id="Limitations_on_cyclical_objects">Ограничение на циклические объекты</h3>
 
 <p>В том случае, если объекты содержат ссылки на самих себя, например циклический связанный список или дерево, которое можно обходить в обоих направлениях, метод <code>toSource()</code> не создаёт такие ссылки, начиная с Firefox 24. Например:</p>
 
@@ -89,9 +89,9 @@ console.log('Циклическая ссылка: ' + (obj1.b.a == obj1));
 
 <p>Если же вам позарез нужно использовать метод <code>toSource()</code> для циклической структуры, объект должен предоставить переопределённый метод <code>toSource()</code>, либо с помощью ссылки на конструктор, либо предоставив анонимную функцию.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toSource" name="Example:_Using_toSource">Пример: использование метода <code>toSource()</code></h3>
+<h3 id="Example:_Using_toSource">Пример: использование метода <code>toSource()</code></h3>
 
 <p>Следующий код определяет тип объекта <code>Dog</code> и создаёт объект <code>theDog</code> типа <code>Dog</code>:</p>
 
@@ -111,11 +111,11 @@ theDog = new Dog('Болтушка', 'лабрадор', 'шоколадный',
 // вернёт ({name:"Болтушка", breed:"лабрадор", color:"шоколадный", sex:"девочка"})
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p> </p>
 
@@ -127,7 +127,7 @@ theDog = new Dog('Болтушка', 'лабрадор', 'шоколадный',
 
 <div id="compat-mobile"> </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.toString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/tostring/index.html b/files/ru/web/javascript/reference/global_objects/object/tostring/index.html
index e9a1b0b116..23aa0c5db5 100644
--- a/files/ru/web/javascript/reference/global_objects/object/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/tostring/index.html
@@ -14,7 +14,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/toString
 
 <p>{{EmbedInteractiveExample("pages/js/object-prototype-tostring.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>obj</var>.toString()</code></pre>
 
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/toString
 
 <p>Строка, представляющая объект.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Каждый объект имеет метод <code>toString()</code>, автоматически вызывающийся, когда объект должен быть представлен в виде текстового значения или когда объект участвует в выражении, где ожидается строка. По умолчанию, метод <code>toString()</code> наследуется каждым объектом, произошедшим от объекта {{jsxref("Global_Objects/Object", "Object")}}. Если этот метод не переопределён в пользовательском объекте, <code>toString()</code> возвращает строку вида "[object <em>тип</em>]", где <code><em>тип</em></code> — это тип объекта. Это иллюстрирует следующий код:</p>
 
@@ -34,9 +34,9 @@ o.toString();           // вернёт [object Object]
 <p><strong>Примечание:</strong> начиная с JavaScript 1.8.5, метод <code>toString()</code>, вызванный на {{jsxref("Global_Objects/null", "null")}}, возвращает строку <code>[object <em>Null</em>]</code>, а вызванный для {{jsxref("Global_Objects/undefined", "undefined")}}, возвращает строку <code>[object <em>Undefined</em>]</code>, как определено в 5-м издании ECMAScript и последующих исправлениях. Смотрите пример {{anch("Using_toString_to_detect_object_type", "использование метода toString() для определения типа объекта")}}.</p>
 </div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Overriding_the_default_toString_method" name="Example:_Overriding_the_default_toString_method">Пример: переопределение метода <code>toString</code> по умолчанию</h3>
+<h3 id="Example_Overriding_the_default_toString_method">Пример: переопределение метода <code>toString</code> по умолчанию</h3>
 
 <p>Вы можете создать функцию, которая будет вызываться вместо метода <code>toString()</code> по умолчанию. Метод <code>toString()</code> не принимает аргументов и должен возвращать строку. Создаваемый вами метод <code>toString()</code> может возвращать любую строку, какую вы захотите, но он будет наиболее полезным, если будет возвращать информацию об объекте.</p>
 
@@ -76,7 +76,7 @@ theDog = new Dog('Болтушка', 'лабрадор', 'шоколадный',
 <pre>Собачка Болтушка - девочка, шоколадный лабрадор
 </pre>
 
-<h3 id="Example_Using_toString_to_detect_object_type" name="Example:_Using_toString_to_detect_object_type">Пример: использование метода <code>toString</code> для определения типа объекта</h3>
+<h3 id="Example_Using_toString_to_detect_object_type">Пример: использование метода <code>toString</code> для определения типа объекта</h3>
 
 <p>Метод <code>toString()</code> можно использовать с любым объектом для получения его класса. Для использования метода <code>Object.prototype.toString()</code> с любым объектом, вам необходимо вызвать на нём функции {{jsxref("Function.prototype.call()")}} или {{jsxref("Function.prototype.apply()")}}, передав объект, который вы хотите исследовать, первым параметром <code>thisArg</code>.</p>
 
@@ -91,7 +91,7 @@ toString.call(undefined);   // [object Undefined]
 toString.call(null);        // [object Null]
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -123,13 +123,13 @@ toString.call(null);        // [object Null]
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div></div>
 
 <div id="compat-mobile">{{Compat("javascript.builtins.Object.toString")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/object/valueof/index.html b/files/ru/web/javascript/reference/global_objects/object/valueof/index.html
index 863353a31d..428af16b38 100644
--- a/files/ru/web/javascript/reference/global_objects/object/valueof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/object/valueof/index.html
@@ -10,15 +10,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf
 ---
 <div>{{JSRef("Global_Objects", "Object")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <code><strong>valueOf()</strong></code> возвращает примитивное значение указанного объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>object</var>.valueOf()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>JavaScript вызывает метод <code>valueOf</code> для преобразования объекта в примитивное значение. Вам редко потребуется вызывать метод <code>valueOf</code> самостоятельно; JavaScript автоматически вызывает его при обнаружении объекта, когда ожидается примитивное значение.</p>
 
@@ -28,7 +28,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf
 
 <p>Вы можете использовать <code>valueOf</code> в своём коде для преобразования встроенных объектов в примитивное значение. Когда вы создаёте пользовательский объект, вы можете переопределить метод <code>Object.prototype.valueOf()</code>, чтобы вызывать собственный метод вместо метода по умолчанию из {{jsxref("Global_Objects/Object", "Object")}}.</p>
 
-<h3 id="Overriding_valueOf_for_custom_objects" name="Overriding_valueOf_for_custom_objects">Переопределение <code>valueOf</code> в пользовательских объектах</h3>
+<h3 id="Overriding_valueOf_for_custom_objects">Переопределение <code>valueOf</code> в пользовательских объектах</h3>
 
 <p>Вы можете создать функцию, вызываемую вместо метода <code>valueOf</code> по умолчанию. Ваша функция не должна принимать аргументов.</p>
 
@@ -46,15 +46,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf
 <p><strong>Примечание:</strong> объекты в строковом контексте преобразуются с помощью метода {{jsxref("Object.toString", "toString()")}}, что отличается от объектов {{jsxref("Global_Objects/String", "String")}}, преобразующихся в строковые примитивы методом <code>valueOf</code>. Все объекты имеют преобразование в строку вида "<code>[object <em>type</em>]</code>". Но многие объекты не преобразуются в число, логическое значение или функцию.</p>
 </div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_valueOf" name="Example:_Using_valueOf">Пример: использование <code>valueOf</code></h3>
+<h3 id="Example:_Using_valueOf">Пример: использование <code>valueOf</code></h3>
 
 <pre class="brush: js">var o = new Object();
 myVar = o.valueOf();      // [object Object]
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -81,11 +81,11 @@ myVar = o.valueOf();      // [object Object]
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.toString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/parsefloat/index.html b/files/ru/web/javascript/reference/global_objects/parsefloat/index.html
index b99d2ac85b..a755a38e2f 100644
--- a/files/ru/web/javascript/reference/global_objects/parsefloat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/parsefloat/index.html
@@ -121,7 +121,7 @@ parseFloat(foo);​​​​​</code></pre>
 
 <p> </p>
 
-<h2 id="See_Also" name="See_Also">Смотрите также</h2>
+<h2 id="See_Also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("parseInt", "parseInt()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/parseint/index.html b/files/ru/web/javascript/reference/global_objects/parseint/index.html
index e6db326610..d453b78c60 100644
--- a/files/ru/web/javascript/reference/global_objects/parseint/index.html
+++ b/files/ru/web/javascript/reference/global_objects/parseint/index.html
@@ -22,11 +22,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
 
 <p> </p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">parseInt(<em>string</em>, <em>radix</em>);</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>string</code></dt>
@@ -38,11 +38,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
  <dd>Целое число в диапазоне между 2 и 36, представляющее собой основание системы счисления числовой строки <code>string</code>, описанной выше. В основном пользователи используют десятичную систему счисления и указывают 10. <strong>Всегда указывайте этот параметр,</strong> чтобы исключить ошибки считывания и гарантировать корректность исполнения и предсказуемость результата. Когда основание системы счисления не указано, разные реализации могут возвращать разные результаты.</dd>
 </dl>
 
-<h3 id="Description" name="Description">Возвращаемое значение</h3>
+<h3 id="Description">Возвращаемое значение</h3>
 
 <p>Целое число, полученное парсингом (разбором и интерпретацией) переданной строки. Если первый символ не получилось сконвертировать в число, то возвращается {{jsxref("NaN")}}. </p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Функция <code>parseInt</code> преобразует первый переданный ей аргумент в строковый тип, интерпретирует его и возвращает целое число или значение <code>NaN</code>. Результат (если не <code>NaN</code>) является целым числом и представляет собой первый аргумент (<code>string</code>), рассматривающийся как число в указанной системе счисления (<code>radix</code>). Например, основание 10 указывает на преобразование из десятичного числа, 8 - восьмеричного, 16 - шестнадцатеричного и так далее. Если основание больше <code>10</code>, то для обозначения цифр больше <code>9</code> используются буквы. Например, для шестнадцатеричных чисел (основание 16) используются буквы от <code>A</code> до <code>F</code>.</p>
 
@@ -64,9 +64,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
 
 <p>Для преобразования числа в строку в указанной системе счисления, используйте <code>intValue.toString(radix)</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_parseInt" name="Example:_Using_parseInt">Пример: Использование <code>parseInt</code></h3>
+<h3 id="Example:_Using_parseInt">Пример: Использование <code>parseInt</code></h3>
 
 <p>Все следующие примеры возвращают <strong><code>15</code></strong>:</p>
 
@@ -190,7 +190,7 @@ console.log(filterInt('1.61803398875'));     // NaN
 
 <p>{{Compat("javascript.builtins.parseInt")}}</p>
 
-<h2 id="See_Also" name="See_Also">Смотрите также</h2>
+<h2 id="See_Also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/promise/all/index.html b/files/ru/web/javascript/reference/global_objects/promise/all/index.html
index e6e344a440..1e883ca751 100644
--- a/files/ru/web/javascript/reference/global_objects/promise/all/index.html
+++ b/files/ru/web/javascript/reference/global_objects/promise/all/index.html
@@ -10,11 +10,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
 ---
 <div>{{JSRef}}</div>
 
-<h2 id="Summary" name="Summary">Общее описание</h2>
+<h2 id="Summary">Общее описание</h2>
 
 <p>Метод <code><strong>Promise.all(iterable)</strong></code> возвращает промис, который выполнится тогда, когда будут выполнены все промисы, переданные в виде перечисляемого аргумента, или отклонено любое из переданных промисов.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><var>Promise.all(iterable)</var>;</pre>
 
@@ -29,7 +29,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
 
 <p>{{jsxref("Promise")}}, который будет выполнен когда будут выполнены все промисы, переданные в виде перечисляемого аргумента, или отклонён, если будет отклонено хоть одно из переданных промисов.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p><strong>Promise.all</strong> возвращает массив значений от всех промисов, которые были ему переданы. Возвращаемый массив значений сохраняет порядок оригинального перечисляемого объекта, но не порядок выполнения промисов. <code>Если какой-либо элемент перечисляемого объекта не является промисом, то он будет преобразован с помощью метода </code>{{jsxref("Promise.resolve")}}<code>.</code></p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/proxy/index.html b/files/ru/web/javascript/reference/global_objects/proxy/index.html
index ffb56bcf1e..12f1cfc36f 100644
--- a/files/ru/web/javascript/reference/global_objects/proxy/index.html
+++ b/files/ru/web/javascript/reference/global_objects/proxy/index.html
@@ -470,7 +470,7 @@ alert(docCookies.getItem("my_cookie1"));
 docCookies.setItem("my_cookie1", "Changed value");
 alert(docCookies.my_cookie1);</pre>
 
-<h2 id="See_also" name="See_also" style="line-height: 30px; font-size: 2.14285714285714rem;">Смотрите также</h2>
+<h2 id="See_also" style="line-height: 30px; font-size: 2.14285714285714rem;">Смотрите также</h2>
 
 <ul>
  <li><a class="external" href="http://jsconf.eu/2010/speaker/be_proxy_objects.html">"Proxies are awesome" презентация Brendan Eich на JSConf</a> (<a class="external" href="http://www.slideshare.net/BrendanEich/metaprog-5303821">слайды</a>)</li>
diff --git a/files/ru/web/javascript/reference/global_objects/rangeerror/index.html b/files/ru/web/javascript/reference/global_objects/rangeerror/index.html
index 38157ee820..26d5a1f949 100644
--- a/files/ru/web/javascript/reference/global_objects/rangeerror/index.html
+++ b/files/ru/web/javascript/reference/global_objects/rangeerror/index.html
@@ -10,13 +10,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RangeError
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Объект <code><strong>RangeError</strong></code> представляет ошибку, возникающую, когда значение не входит в множество или выходит за диапазон допустимых значений.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>new RangeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>message</code></dt>
  <dd>Необязательный параметр. Человеко-читаемое описание ошибки.</dd>
@@ -26,29 +26,29 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RangeError
  <dd>Необязательный параметр. Номер строки кода, вызвавшей исключение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Исключение <code>RangeError</code> выбрасывается при попытке передать аргументом в функцию число, которое не входит в допустимый диапазон значений аргумента этой функции. Оно может возникать при создании массива с неправильной длиной через конструктор {{jsxref("Array")}}, или при передаче плохих значений в методы числа {{jsxref("Number.toExponential()")}}, {{jsxref("Number.toFixed()")}} или {{jsxref("Number.toPrecision()")}}.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 <dl>
  <dt>{{jsxref("RangeError.prototype")}}</dt>
  <dd>Позволяет добавлять свойства в объект <code>RangeError</code>.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 <p>Глобальный объект <code>RangeError</code> не содержит собственных методов, однако, он наследует некоторые методы из цепочки прототипов.</p>
 
-<h2 id="RangeError_instances" name="RangeError_instances">Экземпляры объекта <code>RangeError</code></h2>
+<h2 id="RangeError_instances">Экземпляры объекта <code>RangeError</code></h2>
 
-<h3 id="Properties_of_RangeError_instances" name="Properties_of_RangeError_instances">Свойства</h3>
+<h3 id="Properties_of_RangeError_instances">Свойства</h3>
 <div>{{page('/ru/Web/JavaScript/Reference/Global_Objects/RangeError/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_RangeError_instances" name="Methods_of_RangeError_instances">Методы</h3>
+<h3 id="Methods_of_RangeError_instances">Методы</h3>
 <div>{{page('/ru/Web/JavaScript/Reference/Global_Objects/RangeError/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_RangeError" name="Example:_Using_RangeError">Пример: использование <code>RangeError</code></h3>
+<h3 id="Example:_Using_RangeError">Пример: использование <code>RangeError</code></h3>
 <pre class="brush: js">var check = function(num) {
   if (num &lt; MIN || num &gt; MAX) {
     throw new RangeError('Параметр должен быть между ' + MIN + ' и ' + MAX);
@@ -65,7 +65,7 @@ catch (e) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -91,10 +91,10 @@ catch (e) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error")}}</li>
  <li>{{jsxref("RangeError.prototype")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/exec/index.html b/files/ru/web/javascript/reference/global_objects/regexp/exec/index.html
index 91c43bcc75..15dc565bd7 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/exec/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/exec/index.html
@@ -12,30 +12,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>exec()</code></strong> выполняет поиск сопоставления регулярного выражения в указанной строке. Возвращает массив с результатами или {{jsxref("null")}}.</p>
 
 <p>Если целью выполнения является просто определить, проходит оно или нет, используйте метод {{jsxref("RegExp.prototype.test()")}}, либо метод строки {{jsxref("String.prototype.search()")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>regexObj</var>.exec(<var>str</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>str</code></dt>
  <dd>Строка, с которой производится сопоставление регулярного выражения.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Если сопоставление успешно выполнилось, метод <code>exec()</code> возвращает массив и обновляет свойства объекта регулярного выражения. Возвращаемый массив в первом элементе содержит сопоставленный текст, а в последующих элементах — текст, захваченный при сопоставлении круглыми скобками.</p>
 
 <p>Если сопоставление не удалось, метод <code>exec()</code> возвращает {{jsxref("null")}}.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Рассмотрим следующий пример:</p>
 
@@ -107,9 +107,9 @@ var result = re.exec('Эх, чужд кайф, сплющь объём вши, 
  </tbody>
 </table>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Finding_successive_matches" name="Example:_Finding_successive_matches">Пример: поиск последовательных сопоставлений</h3>
+<h3 id="Example:_Finding_successive_matches">Пример: поиск последовательных сопоставлений</h3>
 
 <p>Если ваше регулярное выражение использует флаг <code>"g"</code>, вы можете использовать метод <code>exec()</code> несколько раз для нахождения последовательных сопоставлений в одной и той же строке. Если вы сделаете это, поиск начнётся по подстроке строки <code>str</code>, начало которой определяется свойством {{jsxref("RegExp.lastIndex", "lastIndex")}} регулярного выражения (метод {{jsxref("RegExp.prototype.test()", "test()")}} также увеличивает свойство {{jsxref("RegExp.lastIndex", "lastIndex")}}). Например, предположим, что у вас есть следующий скрипт:</p>
 
@@ -131,7 +131,7 @@ while ((myArray = myRe.exec(str)) !== null) {
 
 <p>Примечание: не помещайте литерал регулярного выражения (или конструктор {{jsxref("RegExp")}}) внутрь условия <code>while</code>; это приведёт к бесконечному циклу, поскольку свойство {{jsxref("RegExp.lastIndex", "lastIndex")}} будет сбрасываться в ноль на каждой итерации цикла. Также убедитесь, что установлен флаг глобального сопоставления, в противном случае цикл будет бесконечным.</p>
 
-<h3 id="Example:_Using_exec_with_RegExp_literals" name="Example:_Using_exec_with_RegExp_literals">Пример: использование метода <code>exec()</code> вместе с литералами регулярного выражения</h3>
+<h3 id="Example:_Using_exec_with_RegExp_literals">Пример: использование метода <code>exec()</code> вместе с литералами регулярного выражения</h3>
 
 <p>Вы можете использовать метод <code>exec()</code> без создания объекта {{jsxref("RegExp")}}:</p>
 
@@ -141,7 +141,7 @@ console.log(matches[1]);
 
 <p>Скрипт выведет в журнал строку «привет миру!».</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -168,11 +168,11 @@ console.log(matches[1]);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Глава про <a href="/ru/docs/Web/JavaScript/Guide/Regular_Expressions">регулярные выражения</a> в <a href="/ru/docs/Web/JavaScript/Guide">руководстве по JavaScript</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/flags/index.html b/files/ru/web/javascript/reference/global_objects/regexp/flags/index.html
index ec8df85c26..8048b0a00a 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/flags/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/flags/index.html
@@ -16,23 +16,23 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/flags
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Свойство <strong><code>flags</code></strong> возвращает строку, состоящую из флагов текущего регулярного выражения.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Флаги в свойстве <code>flags</code> упорядочены по алфавиту (слева направо, то есть <code>"gimuy"</code>).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_flags" name="Example:_Using_flags">Пример: использование свойства <code>flags</code></h3>
+<h3 id="Example:_Using_flags">Пример: использование свойства <code>flags</code></h3>
 
 <pre class="brush: js">/foo/ig.flags;   // "gi"
 /bar/myu.flags;  // "muy"
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <pre class="brush: js">if (RegExp.prototype.flags === undefined) {
   Object.defineProperty(RegExp.prototype, 'flags', {
@@ -44,7 +44,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/flags
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -61,11 +61,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/flags
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("RegExp.prototype.source")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/global/index.html b/files/ru/web/javascript/reference/global_objects/regexp/global/index.html
index f17c211174..89a5dd061e 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/global/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/global/index.html
@@ -12,24 +12,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/global
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>global</code></strong> указывает, использовался ли в определении регулярного выражения флаг <code>"g"</code>. Свойство <code>global</code> является свойством только для чтения и принадлежит экземпляру регулярного выражения.</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Значение свойства <code>global</code> имеет тип {{jsxref("Global_Objects/Boolean", "Boolean")}} и содержит <code>true</code>, если при определении регулярного выражения использовался флаг <code>"g"</code>; в противном случае оно содержит <code>false</code>. Флаг <code>"g"</code> указывает на то, что регулярное выражение должно проверять все возможные сопоставления в строке.</p>
 <p>Вы не можете напрямую изменить это свойство.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_global" name="Example:_Using_global">Пример: использование свойства <code>global</code></h3>
+<h3 id="Example:_Using_global">Пример: использование свойства <code>global</code></h3>
 <pre class="brush: js">var regex = new RegExp('foo', 'g');
 
 console.log(regex.global); // true
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ console.log(regex.global); // true
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("RegExp.lastIndex")}}</li>
  <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/ignorecase/index.html b/files/ru/web/javascript/reference/global_objects/regexp/ignorecase/index.html
index 0324519ae8..dcbb9e4e52 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/ignorecase/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/ignorecase/index.html
@@ -12,24 +12,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>ignoreCase</code></strong> указывает, использовался ли в определении регулярного выражения флаг <code>"i"</code>. Свойство <code>ignoreCase</code> является свойством только для чтения и принадлежит экземпляру регулярного выражения.</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Значение свойства <code>ignoreCase</code> имеет тип {{jsxref("Global_Objects/Boolean", "Boolean")}} и содержит <code>true</code>, если при определении регулярного выражения использовался флаг <code>"i"</code>; в противном случае оно содержит <code>false</code>. Флаг <code>"i"</code> указывает на то, что регистр символов в строке, с которой сопоставляется регулярное выражение, должен игнорироваться.</p>
 <p>Вы не можете напрямую изменить это свойство.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_ignoreCase" name="Example:_Using_ignoreCase">Пример: использование свойства <code>ignoreCase</code></h3>
+<h3 id="Example:_Using_ignoreCase">Пример: использование свойства <code>ignoreCase</code></h3>
 <pre class="brush: js">var regex = new RegExp('foo', 'i');
 
 console.log(regex.ignoreCase); // true
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ console.log(regex.ignoreCase); // true
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("RegExp.lastIndex")}}</li>
  <li>{{jsxref("RegExp.prototype.global")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/index.html b/files/ru/web/javascript/reference/global_objects/regexp/index.html
index dec4fe74df..a6eb782e72 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/index.html
@@ -12,7 +12,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Конструктор <strong><code>RegExp</code></strong> создаёт объект регулярного выражения для сопоставления текста с шаблоном.</p>
 
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
 
 <p class="hidden">Исходный код этого интерактивного примера хранится в репозитории на GitHub. Если вы хотите участвовать в проекте интерактивных примеров, пожалуйста, склонируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и пришлите нам запрос на принятие изменений.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <p>Возможны как литеральная запись, так и запись через конструктор:</p>
 
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
 new RegExp(<var>pattern</var>, <var>flags</var>)</code>
 </pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>pattern</code></dt>
@@ -52,7 +52,7 @@ new RegExp(<var>pattern</var>, <var>flags</var>)</code>
  </dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Существует два способа создания объекта <code>RegExp</code>: литеральная запись и использование конструктора. При записи строк параметры в литеральной записи не используют символы кавычек, в то время как параметры функции-конструктора используют кавычки. Так что следующие выражения создают одинаковые регулярные выражения:</p>
 
@@ -70,7 +70,7 @@ new RegExp('ab+c', 'i');
 var re = new RegExp('\\w+');
 </pre>
 
-<h2 id="Special_characters_meaning_in_regular_expressions" name="Special_characters_meaning_in_regular_expressions">Значение специальных символов в регулярных выражениях</h2>
+<h2 id="Special_characters_meaning_in_regular_expressions">Значение специальных символов в регулярных выражениях</h2>
 
 <ul>
  <li><a href="#character-classes">Символьные классы</a></li>
@@ -423,7 +423,7 @@ var re = new RegExp('\\w+');
  </tbody>
 </table>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("RegExp.prototype")}}</dt>
@@ -434,25 +434,25 @@ var re = new RegExp('\\w+');
 
 <div>{{jsOverrides("Function", "Properties", "prototype")}}</div>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <p>Глобальный объект <code>RegExp</code> не имеет собственных методов, однако, он наследует некоторые методы через цепочку прототипов.</p>
 
 <div>{{jsOverrides("Function", "Methods", "prototype")}}</div>
 
-<h2 id="RegExp_prototype_objects_and_instances" name="RegExp_prototype_objects_and_instances">Экземпляры регулярного выражения</h2>
+<h2 id="RegExp_prototype_objects_and_instances">Экземпляры регулярного выражения</h2>
 
-<h3 id="Properties_of_RegExp_instance" name="Properties_of_RegExp_instance">Свойства</h3>
+<h3 id="Properties_of_RegExp_instance">Свойства</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_RegExp_instance" name="Methods_of_RegExp_instance">Методы</h3>
+<h3 id="Methods_of_RegExp_instance">Методы</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_a_regular_expression_to_change_data_format" name="Example:_Using_a_regular_expression_to_change_data_format">Пример: использование регулярных выражений для смены формата данных</h3>
+<h3 id="Example_Using_a_regular_expression_to_change_data_format">Пример: использование регулярных выражений для смены формата данных</h3>
 
 <p>Следующий скрипт использует метод {{jsxref("String.prototype.replace()", "replace()")}} экземпляра строки {{jsxref("Global_Objects/String", "String")}} для сопоставления с именем в формате <em>имя фамилия</em> и выводит его в формате <em>фамилия, имя</em>. В тесте замены скрипт использует заменители <code>$1</code> и <code>$2</code>, которые заменяются на результаты соответствующих сопоставившихся подгрупп регулярного выражения.</p>
 
@@ -470,7 +470,7 @@ console.log(newstr);
 
 <p>Пример выведет «Smith, John» и «Смит, Джон»</p>
 
-<h3 id="Example_Using_regular_expression_to_split_lines" name="Example:_Using_regular_expression_to_split_lines">Пример: использование регулярного выражения для разбиения строк с различными символами конца строки</h3>
+<h3 id="Example_Using_regular_expression_to_split_lines">Пример: использование регулярного выражения для разбиения строк с различными символами конца строки</h3>
 
 <p>Символы конца строки различаются на различных платформах (Unix, Windows и так далее). Разбиение строк из этого примера работает на всех платформах.</p>
 
@@ -481,7 +481,7 @@ console.log(lines); // выведет [ 'Некоторый текст', 'Ещё
 
 <p>Обратите внимание, что порядок шаблонов в регулярном выражении имеет значение.</p>
 
-<h3 id="Example_Using_regular_expression_on_multiple_lines" name="Example:_Using_regular_expression_on_multiple_lines">Пример: использование регулярных выражений на нескольких строках</h3>
+<h3 id="Example_Using_regular_expression_on_multiple_lines">Пример: использование регулярных выражений на нескольких строках</h3>
 
 <pre class="brush: js notranslate">var s = 'Please yes\nmake my day!';
 s.match(/yes.*day/);
@@ -490,7 +490,7 @@ s.match(/yes[^]*day/);
 // Вернёт 'yes\nmake my day'
 </pre>
 
-<h3 id="Example_Using_a_regular_expression_with_the_.22sticky.22_flag" name="Example:_Using_a_regular_expression_with_the_.22sticky.22_flag">Пример: использование регулярных выражений с флагом «липучести»</h3>
+<h3 id="Example_Using_a_regular_expression_with_the_.22sticky.22_flag">Пример: использование регулярных выражений с флагом «липучести»</h3>
 
 <p>Этот пример демонстрирует, как можно использовать флаг «липучести» регулярных выражений для сопоставления с отдельными строками многострочного ввода.</p>
 
@@ -517,7 +517,7 @@ catch(e) { supports_sticky = false; }
 console.log(supports_sticky); // напечатает 'true'
 </pre>
 
-<h3 id="Example_Regular_expression_and_Unicode_characters" name="Example:_Regular_expression_and_Unicode_characters">Пример: регулярные выражения и символы Юникода</h3>
+<h3 id="Example_Regular_expression_and_Unicode_characters">Пример: регулярные выражения и символы Юникода</h3>
 
 <p>Как уже сказано выше, символьные классы <code>\w</code> и <code>\W</code> сопоставляются только с базовыми символами ASCII; то есть, с символами от «a» до «z», от «A» до «Z», от «0» до «9» и символом «_». Для сопоставления с символами из других языков, например, с кириллическими или иврита, используйте форму <code>\uhhhh</code>, где «hhhh» — это значение символа Юникода, записанное в шестнадцатеричной форме. Этот пример демонстрирует, как можно выделить символы Юникода, составляющие слова.</p>
 
@@ -537,13 +537,13 @@ console.log(regex.lastIndex); // напечатает '15'
 
 <p>Вот на этом внешнем ресурсе можно составить полный диапазон блоков Юникода для различных письменностей: <a href="http://kourge.net/projects/regexp-unicode-block">regexp-unicode-block</a>.</p>
 
-<h3 id="Example_Extracting_subdomain_name_from_URL" name="Example:_Extracting_subdomain_name_from_URL">Пример: извлечение имени поддомена из URL</h3>
+<h3 id="Example_Extracting_subdomain_name_from_URL">Пример: извлечение имени поддомена из URL</h3>
 
 <pre class="brush: js notranslate">var url = 'http://xxx.domain.com';
 console.log(/[^.]+/.exec(url)[0].substr(7)); // напечатает 'xxx'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -570,11 +570,11 @@ console.log(/[^.]+/.exec(url)[0].substr(7)); // напечатает 'xxx'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h3 id="Gecko_specific_notes" name="Gecko_specific_notes">Примечания по Gecko</h3>
+<h3 id="Gecko_specific_notes">Примечания по Gecko</h3>
 
 <p>Начиная с Gecko 34 {{geckoRelease(34)}}, в случае захвата группы с квантификаторами, предотвращающими появление группы в результате сопоставления, сопоставившийся текст для захваченной группы теперь имеет значение <code>undefined</code> вместо пустой строки:</p>
 
@@ -591,7 +591,7 @@ console.log(/[^.]+/.exec(url)[0].substr(7)); // напечатает 'xxx'
 
 <p>Обратите внимание, что для поддержания обратной совместимости, свойства <code>RegExp.$N</code> по-прежнему возвращают пустую строку вместо значения <code>undefined</code> (<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1053944">bug 1053944</a>).</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Глава про <a href="/ru/docs/Web/JavaScript/Guide/Regular_Expressions">регулярные выражения</a> в <a href="/ru/docs/Web/JavaScript/Guide">руководстве по JavaScript</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/lastindex/index.html b/files/ru/web/javascript/reference/global_objects/regexp/lastindex/index.html
index 0999722d10..101935a308 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/lastindex/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/lastindex/index.html
@@ -11,15 +11,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>lastIndex</code></strong> является целочисленным свойством регулярного выражения, доступным как для чтения, так и для записи, которое определяет индекс, с которого следует начинать следующее сопоставление.</p>
 
 <div>{{js_property_attributes(1, 0, 0)}}</div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>regExpObj</var>.lastIndex</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Это свойство устанавливается только в том случае, если в регулярном выражении используется флаг <code>"g"</code>, указывающий на необходимость глобального поиска. Оно подчиняется следующим правилам:</p>
 <ul>
  <li>Если свойство <code>lastIndex</code> больше длины строки, методы {{jsxref("RegExp.prototype.test()", "test()")}} и {{jsxref("RegExp.prototype.exec()", "exec()")}} завершатся с неудачей, а свойство <code>lastIndex</code> будет установлено в 0.</li>
@@ -28,9 +28,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex
  <li>Во всех остальных случаях свойство <code>lastIndex</code> устанавливается в позицию, следующую за самым последним сопоставлением.</li>
 </ul>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_lastIndex" name="Example:_Using_lastIndex">Пример: использование свойства <code>lastIndex</code></h3>
+<h3 id="Example:_Using_lastIndex">Пример: использование свойства <code>lastIndex</code></h3>
 <p>Рассмотрим следующую последовательность инструкций:</p>
 <pre class="brush: js">var re = /(привет)?/g;
 </pre>
@@ -44,7 +44,7 @@ console.log(re.lastIndex);
 </pre>
 <p>Выведет массив <code>["", undefined]</code>, «пустой» массив, чей нулевой элемент является сопоставившейся строкой. В данном случае, ей является пустая строка, поскольку свойство <code>lastIndex</code> было равно 6 (и остаётся равным 6), а строка <code>"привет"</code> имеет длину 6.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -71,10 +71,10 @@ console.log(re.lastIndex);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
  <li>{{jsxref("RegExp.prototype.global")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/multiline/index.html b/files/ru/web/javascript/reference/global_objects/regexp/multiline/index.html
index 2fe94a23e3..33413e634c 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/multiline/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/multiline/index.html
@@ -12,24 +12,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/multiline
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>multiline</code></strong> указывает, использовался ли в определении регулярного выражения флаг <code>"m"</code>. Свойство <code>multiline</code> является свойством только для чтения и принадлежит экземпляру регулярного выражения.</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Значение свойства <code>multiline</code> имеет тип {{jsxref("Global_Objects/Boolean", "Boolean")}} и содержит <code>true</code>, если при определении регулярного выражения использовался флаг <code>"m"</code>; в противном случае оно содержит <code>false</code>. Флаг <code>"m"</code> указывает на то, что многострочная входная строка должна рассматриваться в виде нескольких строк. Например, если используется флаг <code>"m"</code>, специальные символы <code>"^"</code> и <code>"$"</code> меняют своё поведение: с установленным флагом они сопоставляются в началом / концом каждой строки в многострочной строке, а не с началом / концом всей многострочной строки.</p>
 <p>Вы не можете напрямую изменить это свойство.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_multiline" name="Example:_Using_multiline">Пример: использование свойства <code>multiline</code></h3>
+<h3 id="Example:_Using_multiline">Пример: использование свойства <code>multiline</code></h3>
 <pre class="brush: js">var regex = new RegExp('foo', 'm');
 
 console.log(regex.multiline); // true
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ console.log(regex.multiline); // true
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("RegExp.lastIndex")}}</li>
  <li>{{jsxref("RegExp.prototype.global")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/source/index.html b/files/ru/web/javascript/reference/global_objects/regexp/source/index.html
index 06528eb9cc..35a9312fdf 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/source/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/source/index.html
@@ -12,13 +12,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/source
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Свойство <strong><code>source</code></strong> возвращает {{jsxref("Global_Objects/String", "строку", "", 1)}}, содержащую текст шаблона регулярного выражения без прямых слешей с обеих сторон и без флагов регулярного выражения.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_source" name="Example:_Using_source">Пример: использование свойства <code>source</code></h3>
+<h3 id="Example_Using_source">Пример: использование свойства <code>source</code></h3>
 
 <pre class="brush: js">var regex = /fooBar/ig;
 
@@ -32,7 +32,7 @@ console.log(regex.source); // 'fooBar', не содержит прямые сл
 new RegExp('\n').source === '\n';  // true, до появления ES5
 new RegExp('\n').source === '\\n'; // true, начиная с ES5</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -60,11 +60,11 @@ new RegExp('\n').source === '\\n'; // true, начиная с ES5</pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("RegExp.prototype.flags")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/sticky/index.html b/files/ru/web/javascript/reference/global_objects/regexp/sticky/index.html
index f9c9a6303f..19f13155fd 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/sticky/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/sticky/index.html
@@ -16,21 +16,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/sticky
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Свойство <strong><code>sticky</code></strong> отражает тот факт, является ли поиск «липким» (то есть, начинается ли он с индекса, на который указывает свойство {{jsxref("RegExp.lastIndex", "lastIndex")}} регулярного выражения). Свойство <code>sticky</code> является свойством только для чтения и принадлежит экземпляру регулярного выражения.</p>
 
 <div>{{js_property_attributes(0, 0, 0)}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Значение свойства <code><strong>sticky</strong></code> имеет тип {{jsxref("Global_Objects/Boolean", "Boolean")}} и содержит <code>true</code>, если при определении регулярного выражения использовался флаг <code>"y",</code> в противном случае оно содержит <code>false</code>. Флаг <code>"y"</code> указывает на то, что регулярное выражение сопоставляется с целевой строкой начиная с позиции, на которую указывает его свойство {{jsxref("RegExp.lastIndex", "lastIndex")}} (и не пытается сопоставиться по любому более старшему индексу). Такое поведение позволяет эффективно использовать символ <code>"^"</code> сопоставления-с-началом в любом месте строки путём смены значения свойства {{jsxref("RegExp.lastIndex", "lastIndex")}}.</p>
 
 <p>Вы не можете напрямую изменить это свойство.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_a_regular_expression_with_the_.22sticky.22_flag" name="Example:_Using_a_regular_expression_with_the_.22sticky.22_flag">Пример: использование регулярных выражений с флагом «липучести»</h3>
+<h3 id="Example:_Using_a_regular_expression_with_the_.22sticky.22_flag">Пример: использование регулярных выражений с флагом «липучести»</h3>
 
 <p>Этот пример демонстрирует, как можно использовать флаг «липучести» регулярных выражений для сопоставления с отдельными строками многострочного ввода.</p>
 
@@ -49,7 +49,7 @@ var match3 = regex.exec(text);
 console.log(match3 === null); // напечатает 'true'
 </pre>
 
-<h2 id="Compatibility_test" name="Compatibility_test">Проверка совместимости</h2>
+<h2 id="Compatibility_test">Проверка совместимости</h2>
 
 <p>Во время выполнения можно проверить, поддерживается ли флаг «липучести», при помощи блока <code>try { … } catch { … }</code>. Для этого надо использовать либо выражение с <code>eval(…)</code>, либо конструктор <code>RegExp(<var>строка регулярного выражения</var>, <var>строка-с-флагами</var>)</code> (поскольку нотация <code>/<var>регулярное выражение</var>/<var>флаги</var></code> обрабатывается во время компиляции, исключение будет выброшено до того, как выполнение достигнет блока <code>catch</code>). Например:</p>
 
@@ -59,7 +59,7 @@ catch(e) { supports_sticky = false; }
 console.log(supports_sticky); // напечатает 'false' в Firefox 2 и 'true' в Firefox 3+
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -76,11 +76,11 @@ console.log(supports_sticky); // напечатает 'false' в Firefox 2 и 't
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("RegExp.lastIndex")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/test/index.html b/files/ru/web/javascript/reference/global_objects/regexp/test/index.html
index d49f30f9ac..5fecdf75c8 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/test/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/test/index.html
@@ -12,32 +12,32 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>test()</code></strong> выполняет поиск сопоставления регулярного выражения указанной строке. Возвращает <code>true</code> или <code>false</code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre><code><var>regexObj</var>.test(str)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>str</code></dt>
  <dd>Строка, с которой сопоставляется регулярное выражение.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Логическое значение: <code>true</code> или <code>false</code>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Используйте метод <code>test()</code>, если вы просто хотите узнать, находится ли шаблон в строке (он почти аналогичен методу {{jsxref("String.prototype.search()")}}, только вместо индекса шаблона возвращает <code>true</code> или <code>false</code>); для получения дополнительной информации о сопоставлении (но за счёт более медленного выполнения) используйте метод {{jsxref("RegExp.prototype.exec()", "exec()")}} (он аналогичен методу {{jsxref("String.prototype.match()")}}). Как и при вызове метода {{jsxref("RegExp.prototype.exec()", "exec()")}} (или при совместном с ним вызове), метод <code>test()</code>, вызванный несколько раз на одном и том же экземпляре глобального регулярного выражения, будет начинать проверку с конца предыдущего сопоставления.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_test" name="Example:_Using_test">Пример: использование метода <code>test()</code></h3>
+<h3 id="Example_Using_test">Пример: использование метода <code>test()</code></h3>
 
 <p>Следующий пример печатает сообщение, в зависимости от того, была ли проверка успешной:</p>
 
@@ -52,7 +52,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -79,11 +79,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>Глава про <a href="/ru/docs/Web/JavaScript/Guide/Regular_Expressions">регулярные выражения</a> в <a href="/ru/docs/Web/JavaScript/Guide">руководстве по JavaScript</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/tosource/index.html b/files/ru/web/javascript/reference/global_objects/regexp/tosource/index.html
index 32b3706b50..7487d691c3 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/tosource/index.html
@@ -12,21 +12,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toSource
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>toSource()</code></strong> возвращает строковое представление исходного кода объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>regexObj</var>.toSource()
 RegExp.toSource()
 </code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>toSource()</code> возвращает следующие значения:</p>
 
@@ -43,15 +43,15 @@ RegExp.toSource()
 
 <p>Этот метод обычно вызывается внутри движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/regexp/tostring/index.html b/files/ru/web/javascript/reference/global_objects/regexp/tostring/index.html
index 7954da8a8e..ff2306ea30 100644
--- a/files/ru/web/javascript/reference/global_objects/regexp/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/regexp/tostring/index.html
@@ -12,21 +12,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toString
 ---
 <div>{{JSRef("Global_Objects", "RegExp")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toString()</code></strong> возвращает строковое представление регулярного выражения.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>regexObj</var>.toString()</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <p>Нет.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Объект {{jsxref("Global_Objects/RegExp", "RegExp")}} переопределяет метод <code>toString()</code> объекта {{jsxref("Global_Objects/Object", "Object")}}; он не наследует метод {{jsxref("Object.prototype.toString()")}}. Для объектов {{jsxref("Global_Objects/RegExp", "RegExp")}}, метод <code>toString()</code> возвращает строковое представление регулярного выражения.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toString" name="Example:_Using_toString">Пример: использование метода <code>toString()</code></h3>
+<h3 id="Example:_Using_toString">Пример: использование метода <code>toString()</code></h3>
 <p>Следующий пример отображает строковое значение объекта {{jsxref("Global_Objects/RegExp", "RegExp")}}:</p>
 <pre class="brush: js">var myExp = new RegExp('a+b+c');
 console.log(myExp.toString());  // отобразит '/a+b+c/'
@@ -35,7 +35,7 @@ var foo = new RegExp('bar', 'g');
 console.log(foo.toString());    // отобразит '/bar/g'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -61,10 +61,10 @@ console.log(foo.toString());    // отобразит '/bar/g'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toString()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/set/index.html b/files/ru/web/javascript/reference/global_objects/set/index.html
index 0233c7fcb5..39b4057c9b 100644
--- a/files/ru/web/javascript/reference/global_objects/set/index.html
+++ b/files/ru/web/javascript/reference/global_objects/set/index.html
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Set
 
 <p>Поскольку каждое значение в <code>Set</code> должно быть уникальным, сравнение значений основано на алгоритме "подобное значение": <code>NaN</code> равно <code>NaN</code> (несмотря на то, что <code>NaN !== NaN</code>); все другие значения рассматриваются равными исходя из семантики оператора строго равенства ===. В ранних версиях черновика ECMAScript 6 <code>-0</code> и <code>+0</code> считались разными (несмотря на то, что <code>-0 === +0</code>), это было изменено в последующих версиях и адаптировано в Gecko 29 {{geckoRelease("29")}} ({{bug("952870")}}) и <a href="https://code.google.com/p/v8/issues/detail?id=3069">последней ночной сборке Chrome</a>. <code>NaN</code> и <code>undefined</code> также могут сохраняться в <code>Set</code>.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt><code>Set.length</code></dt>
@@ -51,7 +51,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Set
  <dd>Представляет прототип конструктора <code>Set</code>. Позволяет добавлять свойства всем объектам типа <code>Set</code>.</dd>
 </dl>
 
-<h2 id="Set_instances" name="Set_instances">Экземпляры <code>Set</code></h2>
+<h2 id="Set_instances">Экземпляры <code>Set</code></h2>
 
 <p>Все экземпляры <code>Set</code> унаследованы от {{jsxref("Set.prototype")}}.</p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/string/@@iterator/index.html b/files/ru/web/javascript/reference/global_objects/string/@@iterator/index.html
index 5a367f353c..9b26c886e7 100644
--- a/files/ru/web/javascript/reference/global_objects/string/@@iterator/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/@@iterator/index.html
@@ -16,17 +16,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/@@iterator
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>[@@iterator]()</code></strong> возвращает новый объект итератора <code>Iterator</code>, который проходит по кодовым точкам строкового значения, возвращая каждую кодовую точку в виде строкового значения.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>string</var>[Symbol.iterator]</code></pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_.5B.40.40iterator.5D" name="Example:_Using_.5B.40.40iterator.5D()">Пример: использование метода <code>[@@iterator]()</code></h3>
+<h3 id="Example_Using_.5B.40.40iterator.5D">Пример: использование метода <code>[@@iterator]()</code></h3>
 
 <pre class="brush:js notranslate">var string = 'A\uD835\uDC68';
 
@@ -36,7 +36,7 @@ console.log(strIter.next().value); // "A"
 console.log(strIter.next().value); // "\uD835\uDC68"
 </pre>
 
-<h3 id="Example_Using_.5B.40.40iterator.5D_with_for..of" name="Example:_Using_.5B.40.40iterator.5D()_with_for..of">Пример: использование метода <code>[@@iterator]()</code> вместе с циклом <code>for..of</code></h3>
+<h3 id="Example_Using_.5B.40.40iterator.5D_with_for..of">Пример: использование метода <code>[@@iterator]()</code> вместе с циклом <code>for..of</code></h3>
 
 <pre class="brush:js notranslate">var string = 'A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A';
 
@@ -51,7 +51,7 @@ for (var v of string) {
 // "\uD835\uDC6A"
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -68,6 +68,6 @@ for (var v of string) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/string/anchor/index.html b/files/ru/web/javascript/reference/global_objects/string/anchor/index.html
index 0a63880ee8..c4115f5921 100644
--- a/files/ru/web/javascript/reference/global_objects/string/anchor/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/anchor/index.html
@@ -13,22 +13,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>anchor()</code></strong> создаёт якорный HTML-элемент {{HTMLElement("a")}}, используемый в качестве цели гиперссылки.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.anchor(<var>name</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>name</code></dt>
  <dd>Строка, представляющая атрибут <code>name</code> создаваемого тега.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>anchor()</code> используется для программного создания и отображения якоря в документе.</p>
 
@@ -36,9 +36,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor
 
 <p>Якоря, созданные методом <code>anchor()</code>, становятся элементами в массиве {{domxref("document.anchors")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_anchor" name="Example:_Using_anchor">Пример: использование метода <code>anchor()</code></h3>
+<h3 id="Example:_Using_anchor">Пример: использование метода <code>anchor()</code></h3>
 
 <pre class="brush: js">var myString = 'Оглавление';
 
@@ -50,7 +50,7 @@ document.body.innerHTML = myString.anchor('contents_anchor');
 <pre class="brush: html">&lt;a name="contents_anchor"&gt;Оглавление&lt;/a&gt;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -68,11 +68,11 @@ document.body.innerHTML = myString.anchor('contents_anchor');
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.link()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/big/index.html b/files/ru/web/javascript/reference/global_objects/string/big/index.html
index 3a4017208a..84626203e9 100644
--- a/files/ru/web/javascript/reference/global_objects/string/big/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/big/index.html
@@ -13,21 +13,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/big
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>big()</code></strong> создаёт HTML-элемент {{HTMLElement("big")}}, заставляющий строку отображаться большим шрифтом.</p>
 <div class="note">
  <p><strong>Примечание по использованию:</strong> элемент &lt;big&gt; был удалён из <a href="/ru/docs/Web/Guide/HTML/HTML5">HTML5</a> и больше не должен использоваться. Вместо него веб-разработчикам следует использовать свойства <a href="/ru/docs/Web/CSS">CSS</a>.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.big()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>big()</code> заключает строку в тег <code>&lt;big&gt;</code>: <code>"&lt;big&gt;str&lt;/big&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_big" name="Example:_Using_big">Пример: использование метода <code>big()</code></h3>
+<h3 id="Example:_Using_big">Пример: использование метода <code>big()</code></h3>
 <p>В следующем примере демонстрируется использование нескольких строковых методов для изменения размера строки:</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -39,7 +39,7 @@ console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Привет, мир&
 <pre class="brush: js">document.getElementById('yourElemId').style.fontSize = '2em';
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -56,10 +56,10 @@ console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Привет, мир&
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.fontsize()")}}</li>
  <li>{{jsxref("String.prototype.small()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/blink/index.html b/files/ru/web/javascript/reference/global_objects/string/blink/index.html
index 917d08d784..0492459ee6 100644
--- a/files/ru/web/javascript/reference/global_objects/string/blink/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/blink/index.html
@@ -13,21 +13,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/blink
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>blink()</code></strong> создаёт HTML-элемент {{HTMLElement("blink")}}, заставляющий строку мерцать.</p>
 <div class="warning">
  <p><strong>Предупреждение:</strong> мерцающий текст осуждается некоторыми стандартами доступности. Сам элемент <code>&lt;blink&gt;</code> является нестандартным и устаревшим!</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.blink()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>blink()</code> заключает строку в тег <code>&lt;blink&gt;</code>: <code>"&lt;blink&gt;str&lt;/blink&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_blink" name="Example:_Using_blink">Пример: использование метода <code>blink()</code></h3>
+<h3 id="Example:_Using_blink">Пример: использование метода <code>blink()</code></h3>
 <p>В следующем примере демонстрируется использование нескольких строковых методов для изменения форматирования строки:</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -43,7 +43,7 @@ document.write(worldString.strike());
 &lt;strike&gt;Привет, мир&lt;/strike&gt;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -60,10 +60,10 @@ document.write(worldString.strike());
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.bold()")}}</li>
  <li>{{jsxref("String.prototype.italics()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/bold/index.html b/files/ru/web/javascript/reference/global_objects/string/bold/index.html
index 6da955beb2..ec74843300 100644
--- a/files/ru/web/javascript/reference/global_objects/string/bold/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/bold/index.html
@@ -13,18 +13,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/bold
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>bold()</code></strong> создаёт HTML-элемент {{HTMLElement("b")}}, заставляющий строку отображаться полужирным шрифтом.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.bold()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>bold()</code> заключает строку в тег <code>&lt;b&gt;</code>: <code>"&lt;b&gt;str&lt;/b&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_bold" name="Example:_Using_bold">Пример: использование метода <code>bold()</code></h3>
+<h3 id="Example:_Using_bold">Пример: использование метода <code>bold()</code></h3>
 <p>В следующем примере демонстрируется использование нескольких строковых методов для изменения форматирования строки:</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -40,7 +40,7 @@ document.write(worldString.strike());
 &lt;strike&gt;Привет, мир&lt;/strike&gt;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ document.write(worldString.strike());
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.blink()")}}</li>
  <li>{{jsxref("String.prototype.italics()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/charat/index.html b/files/ru/web/javascript/reference/global_objects/string/charat/index.html
index e0ef630537..c52d45aab7 100644
--- a/files/ru/web/javascript/reference/global_objects/string/charat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/charat/index.html
@@ -11,24 +11,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>charAt()</code></strong> возвращает указанный символ из строки.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.charAt(<var>index</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>index</code></dt>
  <dd>Целое число от 0 до длины строки минус 1.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Символы в строке идут слева направо. Индекс первого символа равен 0, а последнего символа в строке <code>stringName</code> равен <code>stringName.length - 1</code>. Если предоставленный вами параметр <code>index</code> выходит за пределы этого диапазона, JavaScript вернёт пустую строку.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Displaying_characters_at_different_locations_in_a_string" name="Example:_Displaying_characters_at_different_locations_in_a_string">Пример: отображение символов из различных позиций строки</h3>
+<h3 id="Example:_Displaying_characters_at_different_locations_in_a_string">Пример: отображение символов из различных позиций строки</h3>
 <p>Следующий пример показывает символы в различных позициях в строке <code>"Дивный новый мир"</code>:</p>
 <pre class="brush: js">var anyString = 'Дивный новый мир';
 
@@ -50,7 +50,7 @@ console.log("Символ по индексу 999 равен '" + anyString.char
 Символ по индексу 999 равен ''
 </pre>
 
-<h3 id="Example:_Getting_whole_characters" name="Example:_Getting_whole_characters">Пример: получение целых символов</h3>
+<h3 id="Example:_Getting_whole_characters">Пример: получение целых символов</h3>
 <p>Следующий пример показывает, как обойти строку в цикле, каждый раз гарантированно получая целый символ, даже если строка содержит символы, не помещающиеся на Базовую многоязыковую плоскость (БМП).</p>
 <pre class="brush: js">var str = 'A \uD87E\uDC04 Z'; // Также можно использовать не-БМП символы напрямую
 for (var i = 0, chr; i &lt; str.length; i++) {
@@ -153,7 +153,7 @@ function getWholeCharAndI(str, i) {
 }
 </pre>
 
-<h3 id="Example:_Fixing_charAt_to_support_non-Basic-Multilingual-Plane_(BMP)_characters" name="Example:_Fixing_charAt_to_support_non-Basic-Multilingual-Plane_(BMP)_characters">Пример: добавление к методу <code>charAt()</code> поддержки символов не в Базовой многоязыковой плоскости (БМП)</h3>
+<h3 id="Example:_Fixing_charAt_to_support_non-Basic-Multilingual-Plane_(BMP)_characters">Пример: добавление к методу <code>charAt()</code> поддержки символов не в Базовой многоязыковой плоскости (БМП)</h3>
 <p>В то время как пример выше может быть более полезен тем, кто хочет поддерживать символы не в плоскости БМП (поскольку он не требует от вызывающей стороны знания о том, где может встретиться символ из не-БМП), в случае, если кто-то желает <em>выбирать</em> символы по индексу и трактовать суррогатную пару внутри строки как один символ, он может использовать следующий код:</p>
 <pre class="brush: js">function fixedCharAt(str, idx) {
   var ret = '';
@@ -184,7 +184,7 @@ function getWholeCharAndI(str, i) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -210,10 +210,10 @@ function getWholeCharAndI(str, i) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.indexOf()")}}</li>
  <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/charcodeat/index.html b/files/ru/web/javascript/reference/global_objects/string/charcodeat/index.html
index c2fb0f2f94..31899f436d 100644
--- a/files/ru/web/javascript/reference/global_objects/string/charcodeat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/charcodeat/index.html
@@ -11,22 +11,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>charCodeAt()</code></strong> возвращает числовое значение Юникода для символа по указанному индексу (за исключением кодовых точек Юникода, больших 0x10000).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.charCodeAt(<var>index</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>index</code></dt>
  <dd>Целое число больше, либо равное 0 и меньше длины строки; если параметр не является числом, он устанавливается в 0.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Кодовые точки Юникода простираются в диапазоне от 0 до 1114111 (0x10FFFF). Первые 128 кодовых точек Юникода напрямую отображаются в кодировку ASCII. Информацию по Юникоду смотрите в <a href="/ru/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Unicode">Руководстве по JavaScript</a>.</p>
 
@@ -36,16 +36,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
 
 <p>Обратная совместимость: в более старых версиях (например, в JavaScript 1.2) метод <code>charCodeAt()</code> возвращал число из кодировки ISO-Latin-1 по указанному индексу. Диапазон символов в кодировке ISO-Latin-1 простирается от 0 до 255. Первые 127 чисел напрямую отображаются в кодировку ASCII.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_charCodeAt" name="Example:_Using_charCodeAt">Пример: использование метода <code>charCodeAt()</code></h3>
+<h3 id="Example:_Using_charCodeAt">Пример: использование метода <code>charCodeAt()</code></h3>
 
 <p>В следующем примере возвращается число 65, значение Unicode для латинского символа «A».</p>
 
 <pre class="brush: js">'ABC'.charCodeAt(0); // вернёт 65
 </pre>
 
-<h3 id="Example:_Fixing_charCodeAt_to_handle_non-Basic-Multilingual-Plane_characters_if_their_presence_earlier_in_the_string_is_unknown" name="Example:_Fixing_charCodeAt_to_handle_non-Basic-Multilingual-Plane_characters_if_their_presence_earlier_in_the_string_is_unknown">Пример: исправление метода <code>charCodeAt()</code> для обработки символов не в Базовой многоязыковой плоскости, если их предыдущее присутствие в строке неизвестно</h3>
+<h3 id="Example:_Fixing_charCodeAt_to_handle_non-Basic-Multilingual-Plane_characters_if_their_presence_earlier_in_the_string_is_unknown">Пример: исправление метода <code>charCodeAt()</code> для обработки символов не в Базовой многоязыковой плоскости, если их предыдущее присутствие в строке неизвестно</h3>
 
 <p>Эта версия может использоваться в циклах for, даже когда неизвестно, были ли до указанной позиции символы из не-БМП.</p>
 
@@ -81,7 +81,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
 }
 </pre>
 
-<h3 id="Example:_Fixing_charCodeAt_to_handle_non-Basic-Multilingual-Plane_characters_if_their_presence_earlier_in_the_string_is_known" name="Example:_Fixing_charCodeAt_to_handle_non-Basic-Multilingual-Plane_characters_if_their_presence_earlier_in_the_string_is_known">Пример: исправление метода <code>charCodeAt()</code> для обработки символов не в Базовой многоязыковой плоскости, если их предыдущее присутствие в строке известно</h3>
+<h3 id="Example:_Fixing_charCodeAt_to_handle_non-Basic-Multilingual-Plane_characters_if_their_presence_earlier_in_the_string_is_known">Пример: исправление метода <code>charCodeAt()</code> для обработки символов не в Базовой многоязыковой плоскости, если их предыдущее присутствие в строке известно</h3>
 
 <pre class="brush: js">function knownCharCodeAt(str, idx) {
   str += '';
@@ -116,7 +116,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -143,11 +143,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.fromCharCode()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/codepointat/index.html b/files/ru/web/javascript/reference/global_objects/string/codepointat/index.html
index e94d9d4a80..104a19c1a9 100644
--- a/files/ru/web/javascript/reference/global_objects/string/codepointat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/codepointat/index.html
@@ -15,28 +15,28 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>codePointAt()</code></strong> возвращает неотрицательное целое число, являющееся закодированным в UTF-16 значением кодовой точки.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.codePointAt(<var>pos</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>pos</code></dt>
  <dd>Позиция элемента в строке, чья кодовая точка возвращается функцией.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если на указанной позиции нет элементов, будет возвращено значение {{jsxref("Global_Objects/undefined", "undefined")}}. Если суррогатная пара UTF-16 не начинается в позиции <code>pos</code>, будет возвращено кодовое значение в позиции <code>pos</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_codePointAt" name="Example:_Using_codePointAt">Пример: использование метода <code>codePointAt()</code></h3>
+<h3 id="Example:_Using_codePointAt">Пример: использование метода <code>codePointAt()</code></h3>
 
 <pre class="brush: js">'ABC'.codePointAt(1);          // 66
 '\uD800\uDC00'.codePointAt(0); // 65536
@@ -44,7 +44,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt
 'XYZ'.codePointAt(42); // undefined
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Следующий полифил расширяет прототип строки определённой в ECMAScript 6 функцией <code>codePointAt()</code>, если браузер не имеет её родной поддержки.</p>
 
@@ -95,7 +95,7 @@ if (!String.prototype.codePointAt) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -112,11 +112,11 @@ if (!String.prototype.codePointAt) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.fromCodePoint()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/concat/index.html b/files/ru/web/javascript/reference/global_objects/string/concat/index.html
index 42f7cf995f..6cd1003bc6 100644
--- a/files/ru/web/javascript/reference/global_objects/string/concat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/concat/index.html
@@ -11,24 +11,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/concat
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>concat()</code></strong> объединяет текст из двух или более строк и возвращает новую строку.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.concat(<var>string2</var>, <var>string3</var>[, ..., <var>stringN</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>string2...string<em>N</em></code></dt>
  <dd>Строки, объединяемые в эту строку.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>concat()</code> объединяет текст из двух или более строк и возвращает новую строку. Изменения в тексте в одной строке не затрагивают остальные строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_concat" name="Example:_Using_concat">Пример: использование метода <code>concat()</code></h3>
+<h3 id="Example:_Using_concat">Пример: использование метода <code>concat()</code></h3>
 <p>В следующем примере несколько строк объединяются в одну.</p>
 <pre class="brush: js">var hello = 'Привет, ';
 console.log(hello.concat('Кевин', ', удачного дня.'));
@@ -36,10 +36,10 @@ console.log(hello.concat('Кевин', ', удачного дня.'));
 /* Привет, Кевин, удачного дня. */
 </pre>
 
-<h2 id="Performance" name="Performance">Производительность</h2>
+<h2 id="Performance">Производительность</h2>
 <p>Настоятельно рекомендуется вместо метода <code>concat()</code> использовать {{jsxref("Operators/Assignment_Operators", "операторы присваивания", "", 1)}} (<code>+</code>, <code>+=</code>). Смотрите это <a href="http://jsperf.com/concat-vs-plus-vs-join">сравнение производительности</a>.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -65,10 +65,10 @@ console.log(hello.concat('Кевин', ', удачного дня.'));
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Array.prototype.concat()")}}</li>
  <li>{{jsxref("Operators/Assignment_Operators", "Операторы присваивания", "", 1)}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/endswith/index.html b/files/ru/web/javascript/reference/global_objects/string/endswith/index.html
index dae771b3b2..1fa53bd180 100644
--- a/files/ru/web/javascript/reference/global_objects/string/endswith/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/endswith/index.html
@@ -11,15 +11,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>endsWith()</code></strong> позволяет определить, заканчивается ли строка символами указанными в скобках, возвращая, соответственно, <code>true</code> или <code>false</code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>str</var>.endsWith(<var>searchString</var>[, <var>length</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>searchString</code></dt>
@@ -32,13 +32,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith
 
 <p><strong><code>true</code></strong> если данные символы находятся в конце строки; в противном случае, <strong><code>false</code></strong>.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Этот метод позволяет определять, заканчивается ли строка искомыми символами. Метод чувствителен к регистру.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_endsWith" name="Example:_Using_endsWith">Пример: использование метода <code>endsWith()</code></h3>
+<h3 id="Example_Using_endsWith">Пример: использование метода <code>endsWith()</code></h3>
 
 <pre class="brush: js notranslate">var str = 'Быть или не быть, вот в чём вопрос.';
 
@@ -47,7 +47,7 @@ console.log(str.endsWith('быть'));      // false
 console.log(str.endsWith('быть', 16));  // true
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод был добавлен к спецификации ECMAScript 6 и может быть доступен ещё не во всех реализациях JavaScript. Однако, вы можете легко эмулировать этот метод при помощи следующего кода:</p>
 
@@ -66,7 +66,7 @@ console.log(str.endsWith('быть', 16));  // true
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -83,11 +83,11 @@ console.log(str.endsWith('быть', 16));  // true
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.startsWith()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/fixed/index.html b/files/ru/web/javascript/reference/global_objects/string/fixed/index.html
index ef230fb673..65b04023c8 100644
--- a/files/ru/web/javascript/reference/global_objects/string/fixed/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/fixed/index.html
@@ -13,18 +13,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>fixed()</code></strong> создаёт HTML-элемент {{HTMLElement("tt")}}, заставляющий строку отображаться моноширинным шрифтом.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.fixed()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>fixed()</code> заключает строку в тег <code>&lt;tt&gt;</code>: <code>"&lt;tt&gt;str&lt;/tt&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_fixed" name="Example:_Using_fixed">Пример: использование метода <code>fixed()</code></h3>
+<h3 id="Example:_Using_fixed">Пример: использование метода <code>fixed()</code></h3>
 <p>В следующем примере для изменения форматирования строки используется метод <code>fixed()</code>:</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -34,7 +34,7 @@ document.write(worldString.fixed());
 <pre class="brush: html">&lt;tt&gt;Привет, мир&lt;/tt&gt;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -51,10 +51,10 @@ document.write(worldString.fixed());
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.bold()")}}</li>
  <li>{{jsxref("String.prototype.italics()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/fontcolor/index.html b/files/ru/web/javascript/reference/global_objects/string/fontcolor/index.html
index 57ffb95fce..3781787f54 100644
--- a/files/ru/web/javascript/reference/global_objects/string/fontcolor/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/fontcolor/index.html
@@ -13,27 +13,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>fontcolor()</code></strong> создаёт HTML-элемент {{HTMLElement("font")}}, заставляющий строку отображаться шрифтом указанного цвета.</p>
 <div class="note">
  <p><strong>Примечание по использованию:</strong> элемент &lt;font&gt; был удалён из <a href="/ru/docs/Web/Guide/HTML/HTML5">HTML5</a> и больше не должен использоваться. Вместо него веб-разработчикам следует использовать свойства <a href="/ru/docs/Web/CSS">CSS</a>.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>color</code></dt>
  <dd>Строка, выражающая цвет в виде шестнадцатеричного триплета RGB, либо в виде названия цвета. Названия цветов перечислены в <a href="/ru/docs/Web/CSS/color_value">справочнике по значению цвета в CSS</a>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Если вы выразили цвет в виде шестнадцатеричного триплета RGB, вы должны использовать формат <code>rrggbb</code>. Например, шестнадцатеричные значения RGB для оранжево-розового цвета такие: красный=FA, зелёный=80 и синий=72, так что RGB-триплет для оранжево-розового цвета будет следующим <code>"FA8072"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_fontcolor" name="Example:_Using_fontcolor">Пример: использование метода <code>fontcolor()</code></h3>
+<h3 id="Example:_Using_fontcolor">Пример: использование метода <code>fontcolor()</code></h3>
 <p>В следующем примере метод <code>fontcolor()</code> используется для изменения цвета строки путём генерирования строки с HTML-тегом <code>&lt;font&gt;</code>.</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -47,7 +47,7 @@ console.log(worldString.fontcolor('FF00') + ' на этой строке кра
 <pre class="brush: js">document.getElementById('yourElemId').style.color = 'red';
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -64,10 +64,10 @@ console.log(worldString.fontcolor('FF00') + ' на этой строке кра
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.fontsize()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/string/fontsize/index.html b/files/ru/web/javascript/reference/global_objects/string/fontsize/index.html
index e70cc60402..982d4c0bcf 100644
--- a/files/ru/web/javascript/reference/global_objects/string/fontsize/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/fontsize/index.html
@@ -13,27 +13,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>fontsize()</code></strong> создаёт HTML-элемент {{HTMLElement("font")}}, заставляющий строку отображаться шрифтом указанного размера.</p>
 <div class="note">
  <p><strong>Примечание по использованию:</strong> элемент &lt;font&gt; был удалён из <a href="/ru/docs/Web/Guide/HTML/HTML5">HTML5</a> и больше не должен использоваться. Вместо него веб-разработчикам следует использовать свойства <a href="/ru/docs/Web/CSS">CSS</a>.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.fontsize(<var>size</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>size</code></dt>
  <dd>Целое число от 1 до 7, либо строка с целым числом со знаком по модулю от 1 до 7.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>При задании размера в виде целого числа, вы устанавливаете размер шрифта строки <code>str</code> в один из 7 предопределённых размеров. При задании размера в виде строки, например, "-2", вы задаёте размер шрифта строки <code>str</code> относительно размера, установленного тегом {{HTMLElement("basefont")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_fontsize" name="Example:_Using_fontsize">Пример: использование метода <code>fontsize()</code></h3>
+<h3 id="Example:_Using_fontsize">Пример: использование метода <code>fontsize()</code></h3>
 <p>В следующем примере демонстрируется использование нескольких строковых методов для изменения размера строки:</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -45,7 +45,7 @@ console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Привет, мир&
 <pre class="brush: js">document.getElementById('yourElemId').style.fontSize = '0.7em';
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -62,10 +62,10 @@ console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Привет, мир&
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.big()")}}</li>
  <li>{{jsxref("String.prototype.small()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/ru/web/javascript/reference/global_objects/string/fromcharcode/index.html
index 7af2165131..a261ad9ac8 100644
--- a/files/ru/web/javascript/reference/global_objects/string/fromcharcode/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/fromcharcode/index.html
@@ -11,32 +11,32 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Статический метод <strong><code>String.fromCharCode()</code></strong> возвращает строку, созданную из указанной последовательности значений единиц кода UTF-16.</p>
 
 <p>. </p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>num1, ..., num<em>N</em></code></dt>
  <dd>Последовательность чисел, являющихся значениями единиц кода UTF-16. <span style="font-size: 1rem; letter-spacing: -0.00278rem;">Диапазон составляет от 0 до 65535 (0xFFFF). Числа больше 0xFFFF усекаются. Проверка достоверности не производится.</span></dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Этот метод возвращает примитивную строку, а не объект {{jsxref("Global_Objects/String", "String")}}.</p>
 
 <p>Поскольку метод <code>fromCharCode()</code> является статическим методом объекта {{jsxref("Global_Objects/String", "String")}}, вы всегда должны использовать его как <code>String.fromCharCode()</code>, а не как метод созданного вами экземпляра {{jsxref("Global_Objects/String", "String")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_fromCharCode" name="Example:_Using_fromCharCode">Пример: использование метода <code>fromCharCode()</code></h3>
+<h3 id="Example_Using_fromCharCode">Пример: использование метода <code>fromCharCode()</code></h3>
 
 <p>Следующий пример вернёт строку "ABC".</p>
 
@@ -45,11 +45,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode
 
 <p dir="ltr" id="tw-target-text"><a href="https://asecuritysite.com/coding/asc2">Полная таблица UTF-16</a></p>
 
-<h2 id="Getting_it_to_work_with_higher_values" name="Getting_it_to_work_with_higher_values">Как заставить его работать с большими значениями</h2>
+<h2 id="Getting_it_to_work_with_higher_values">Как заставить его работать с большими значениями</h2>
 
 <p>Хотя большинство распространённых значений Юникода может быть представлено одним 16-битным числом (как ожидалось на ранней стадии стандартизации JavaScript) и метод <code>fromCharCode()</code> может использоваться для возврата одного символа для самых распространённых значений (точнее, значений UCS-2, которые являются подмножеством самых распространённых символов UTF-16), для работы со ВСЕМИ допустимыми значениями Юникода (занимающими до 21 бита) одного метода <code>fromCharCode()</code> недостаточно. Поскольку большие кодовые точки используют (самое меньшее) два «суррогатных» числа для представления одного символа, для возврата таких пар можно использовать метод {{jsxref("String.fromCodePoint()")}} (являющийся частью черновика ES6) и, таким образом, адекватно представлять эти символы.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -76,11 +76,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.fromCodePoint()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/fromcodepoint/index.html b/files/ru/web/javascript/reference/global_objects/string/fromcodepoint/index.html
index 56964666d4..ea463aa4cf 100644
--- a/files/ru/web/javascript/reference/global_objects/string/fromcodepoint/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/fromcodepoint/index.html
@@ -14,35 +14,35 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Статический метод <strong><code>String.fromCodePoint()</code></strong> возвращает строку, созданную из указанной последовательности кодовых точек.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>String.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>num1, ..., num<em>N</em></code></dt>
  <dd>Последовательность кодовых точек.</dd>
 </dl>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 
 <dl>
  <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt>
  <dd>Исключение {{jsxref("Global_Objects/RangeError", "RangeError")}} выбрасывается в случае, если методу предоставлена неверная кодовая точка Юникода (например, "RangeError: NaN is not a valid code point").</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Поскольку метод <code>fromCodePoint()</code> является статическим методом объекта {{jsxref("Global_Objects/String", "String")}}, вы всегда должны использовать его как <code>String.fromCodePoint()</code>, а не как метод созданного вами экземпляра {{jsxref("Global_Objects/String", "String")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_fromCharCode" name="Example:_Using_fromCharCode">Пример: использование метода <code>fromCodePoint()</code></h3>
+<h3 id="Example:_Using_fromCharCode">Пример: использование метода <code>fromCodePoint()</code></h3>
 
 <pre class="brush: js">String.fromCodePoint(42);       // "*"
 String.fromCodePoint(65, 90);   // "AZ"
@@ -66,7 +66,7 @@ String.fromCodePoint(NaN);      // RangeError
 console.log(String.fromCodePoint(0x2F804)); // или 194564 в десятичной записи
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Метод <code>String.fromCodePoint()</code> был добавлен к стандарту ECMAScript в 6-й версии и может поддерживаться ещё не во всех браузерах или окружениях. Используйте код ниже в качестве полифила:</p>
 
@@ -134,7 +134,7 @@ if (!String.fromCodePoint) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -151,11 +151,11 @@ if (!String.fromCodePoint) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.fromCharCode()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/index.html b/files/ru/web/javascript/reference/global_objects/string/index.html
index 8ae07f9337..5db7b5e416 100644
--- a/files/ru/web/javascript/reference/global_objects/string/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/index.html
@@ -12,7 +12,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String
 
 <p>Объект <strong><code>String</code></strong> используется, чтобы представить и конструировать последовательность символов.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <p>Строковые литералы могут быть следующих форм:</p>
 
@@ -88,18 +88,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String
 new String(thing)
 </code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>thing</code></dt>
  <dd>Всё, что может быть преобразовано в строку.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Строки полезны для хранения данных, которые можно представить в текстовой форме. Некоторые из наиболее частых операций со строками — это проверка их {{jsxref("String.length", "длины", "", 1)}}, построение строки с помощью <a href="/ru/docs/Web/JavaScript/Reference/Operators/String_Operators">операций строковой конкатенации + и +=</a>, проверка на существование или местоположение подстрок с помощью метода {{jsxref("String.prototype.indexOf()", "indexOf()")}}, либо извлечение подстрок с помощью метода {{jsxref("String.prototype.substring()", "substring()")}}.</p>
 
-<h3 id="Character_access" name="Character_access">Доступ к символам</h3>
+<h3 id="Character_access">Доступ к символам</h3>
 
 <p>Существует два способа добраться до конкретного символа в строке. В первом способе используется метод {{jsxref("String.prototype.charAt()", "charAt()")}}:</p>
 
@@ -113,7 +113,7 @@ new String(thing)
 
 <p>При доступе к символам посредством нотации с квадратными скобками, попытка удалить символ, или присвоить значение числовому свойству закончится неудачей, поскольку эти свойства являются незаписываемыми и ненастраиваемыми. Смотрите документацию по методу {{jsxref("Object.defineProperty()")}} для дополнительной информации.</p>
 
-<h3 id="Comparing_strings" name="Comparing_strings">Сравнение строк</h3>
+<h3 id="Comparing_strings">Сравнение строк</h3>
 
 <p>Разработчики на C имеют для сравнения строк функцию <code>strcmp()</code>. В JavaScript вы просто используете <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80%D1%8B_%D1%81%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F">операторы меньше и больше</a>:</p>
 
@@ -130,7 +130,7 @@ if (a &lt; b) { // true
 
 <p>Подобный результат также может быть достигнут путём использования метода {{jsxref("String.prototype.localeCompare()", "localeCompare()")}}, имеющегося у всех экземпляров <code>String</code>.</p>
 
-<h3 id="Distinction_between_string_primitives_and_String_objects" name="Distinction_between_string_primitives_and_String_objects">Разница между строковыми примитивами и объектами <code>String</code></h3>
+<h3 id="Distinction_between_string_primitives_and_String_objects">Разница между строковыми примитивами и объектами <code>String</code></h3>
 
 <p>Обратите внимание, что JavaScript различает объекты <code>String</code> и значения строкового примитива (то же самое верно и для объектов {{jsxref("Global_Objects/Boolean", "Boolean")}} и {{jsxref("Global_Objects/Number", "Number")}}).</p>
 
@@ -160,7 +160,7 @@ console.log(eval(s2));        // выведет строку '2 + 2'
 
 <div class="note"><strong>Примечание:</strong> для того, чтобы узнать больше о другом возможном подходе к строкам в JavaScript, прочитайте статью о <a href="/ru/Add-ons/Code_snippets/StringView"><code>StringView</code> — C-подобном представлении строк на основе типизированных массивов</a>.</div>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("String.prototype")}}</dt>
@@ -169,7 +169,7 @@ console.log(eval(s2));        // выведет строку '2 + 2'
 
 <div>{{jsOverrides("Function", "Properties", "prototype")}}</div>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <dl>
  <dt>{{jsxref("String.fromCharCode()")}}</dt>
@@ -182,7 +182,7 @@ console.log(eval(s2));        // выведет строку '2 + 2'
 
 <div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint", "raw")}}</div>
 
-<h2 id="String_generic_methods" name="String_generic_methods">Общие методы объекта <code>String</code></h2>
+<h2 id="String_generic_methods">Общие методы объекта <code>String</code></h2>
 
 <p>Методы экземпляров <code>String</code> также доступны в Firefox как часть JavaScript 1.6 (который не является частью стандарта ECMAScript) на объекте <code>String</code>, что позволяет применять эти методы к любому объекту:</p>
 
@@ -227,25 +227,25 @@ console.log(String.replace(num, /5/, '2'));
 }());
 </pre>
 
-<h2 id="String_instances" name="String_instances">Экземпляры объекта <code>String</code></h2>
+<h2 id="String_instances">Экземпляры объекта <code>String</code></h2>
 
-<h3 id="Properties_of_String_instance" name="Properties_of_String_instance">Свойства</h3>
+<h3 id="Properties_of_String_instance">Свойства</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_String_instance" name="Methods_of_String_instance">Методы</h3>
+<h3 id="Methods_of_String_instance">Методы</h3>
 
-<h4 id="Methods_unrelated_to_HTML" name="Methods_unrelated_to_HTML">Методы, не относящиеся к HTML</h4>
+<h4 id="Methods_unrelated_to_HTML">Методы, не относящиеся к HTML</h4>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Methods_unrelated_to_HTML')}}</div>
 
-<h4 id="HTML_wrapper_methods" name="HTML_wrapper_methods">Методы-обёртки HTML</h4>
+<h4 id="HTML_wrapper_methods">Методы-обёртки HTML</h4>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'HTML_wrapper_methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_String_conversion" name="Example:_String_conversion">Пример: преобразование в строку</h3>
+<h3 id="Example_String_conversion">Пример: преобразование в строку</h3>
 
 <p>Объект <code>String</code> можно использовать как «безопасную» альтернативу методу {{jsxref("String.prototype.toString()", "toString()")}}, так как хотя он обычно и вызывает соответствующий метод <code>toString()</code>, он также работает и для значений {{jsxref("Global_Objects/null", "null")}} и {{jsxref("Global_Objects/undefined", "undefined")}}. Например:</p>
 
@@ -255,7 +255,7 @@ for (var i = 0, n = inputValues.length; i &lt; n; ++i) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -282,13 +282,13 @@ for (var i = 0, n = inputValues.length; i &lt; n; ++i) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.String",2)}}</p>
 
 <div></div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{domxref("DOMString")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/indexof/index.html b/files/ru/web/javascript/reference/global_objects/string/indexof/index.html
index 43af9b222b..3fb6d966e1 100644
--- a/files/ru/web/javascript/reference/global_objects/string/indexof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/indexof/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>indexOf()</code></strong> возвращает индекс первого вхождения указанного значения в строковый объект {{jsxref("Global_Objects/String", "String")}}, на котором он был вызван, начиная с индекса <code>fromIndex</code>. Возвращает -1, если значение не найдено.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.indexOf(<var>searchValue</var>, [<var>fromIndex</var>]</code>)</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>searchValue</code></dt>
@@ -29,7 +29,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf
  <dd>Необязательный параметр. Местоположение внутри строки, откуда начинать поиск. Может быть любым целым числом. Значение по умолчанию установлено в 0. Если <code>fromIndex &lt; 0</code>, поиск ведётся по всей строке (так же, как если бы был передан 0). Если <code>fromIndex &gt;= str.length</code>, метод вернёт -1, но только в том случае, если <code>searchValue</code> не равен пустой строке, в этом случае он вернёт <code>str.length</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Символы в строке идут слева направо. Индекс первого символа равен 0, а последнего символа в строке <code>stringName</code> равен <code>stringName.length - 1</code>.</p>
 
@@ -42,14 +42,14 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf
 'Синий кит'.indexOf('', 10);      // вернёт 9
 </pre>
 
-<h3 id="Case-sensitivity" name="Case-sensitivity">Регистрозависимость</h3>
+<h3 id="Case-sensitivity">Регистрозависимость</h3>
 
 <p>Метод <code>indexOf()</code> является регистрозависимым. Например, следующее выражение вернёт -1:</p>
 
 <pre class="brush: js">'Синий кит'.indexOf('синий'); // вернёт -1
 </pre>
 
-<h3 id="Checking_occurrences" name="Checking_occurrences">Проверка на вхождение</h3>
+<h3 id="Checking_occurrences">Проверка на вхождение</h3>
 
 <p>Обратите внимание, что значение 0 не вычисляется в <code>true</code>, а значение -1 не вычисляется в <code>false</code>. Поэтому, для проверки того, что конкретная строка содержится в другой строке, правильно делать так:</p>
 
@@ -57,9 +57,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf
 'Синий кит'.indexOf('Голубой') !== -1; // false
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Пример: использование методов <code>indexOf()</code> и <code>lastIndexOf()</code></h3>
+<h3 id="Example:_Using_indexOf_and_lastIndexOf">Пример: использование методов <code>indexOf()</code> и <code>lastIndexOf()</code></h3>
 
 <p>В следующем примере используются методы <code>indexOf()</code> и {{jsxref("String.prototype.lastIndexOf()", "lastIndexOf()")}} для нахождения значений в строке <code>"Дивный новый мир"</code>.</p>
 
@@ -76,7 +76,7 @@ console.log('Индекс вхождения «новый» с конца стр
 // Отобразит 7
 </pre>
 
-<h3 id="Example:_indexOf_and_case-sensitivity" name="Example:_indexOf_and_case-sensitivity">Пример: метод <code>indexOf()</code> и регистрозависимость</h3>
+<h3 id="Example:_indexOf_and_case-sensitivity">Пример: метод <code>indexOf()</code> и регистрозависимость</h3>
 
 <p>В следующем примере определяются две строковых переменных. Переменные содержат одинаковые строки, за исключение того, что слова во второй строке начинаются с заглавных букв. Первый вызов метода {{domxref("console.log()")}} отобразит 18. Но поскольку метод <code>indexOf()</code> является регистрозависимым, строка <code>"чеддер"</code> в переменной <code>myCapString</code> не будет найдена, так что второй вызов метода <code>console.log()</code> отобразит -1.</p>
 
@@ -89,7 +89,7 @@ console.log('Вызов myCapString.indexOf("чеддер") вернул ' + myC
 // Отобразит -1
 </pre>
 
-<h3 id="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string" name="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string">Пример: использование метода <code>indexOf()</code> для подсчёта вхождений буквы в строку</h3>
+<h3 id="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string">Пример: использование метода <code>indexOf()</code> для подсчёта вхождений буквы в строку</h3>
 
 <p>Следующий пример устанавливает значение переменной <code>count</code> в количество вхождений буквы <code>в</code> в строку <code>str</code>:</p>
 
@@ -105,7 +105,7 @@ while (pos !== -1) {
 console.log(count); // отобразит 3
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -132,11 +132,11 @@ console.log(count); // отобразит 3
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.charAt()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/italics/index.html b/files/ru/web/javascript/reference/global_objects/string/italics/index.html
index 99f5d1cc17..b1556a607d 100644
--- a/files/ru/web/javascript/reference/global_objects/string/italics/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/italics/index.html
@@ -13,18 +13,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/italics
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>italics()</code></strong> создаёт HTML-элемент {{HTMLElement("i")}}, заставляющий строку отображаться курсивом.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.italics()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>italics()</code> заключает строку в тег <code>&lt;i&gt;</code>: <code>"&lt;i&gt;str&lt;/i&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_italics" name="Example:_Using_italics">Пример: использование метода <code>italics()</code></h3>
+<h3 id="Example:_Using_italics">Пример: использование метода <code>italics()</code></h3>
 <p>В следующем примере демонстрируется использование нескольких строковых методов для изменения форматирования строки:</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -40,7 +40,7 @@ document.write(worldString.strike());
 &lt;strike&gt;Привет, мир&lt;/strike&gt;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ document.write(worldString.strike());
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.blink()")}}</li>
  <li>{{jsxref("String.prototype.bold()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/lastindexof/index.html b/files/ru/web/javascript/reference/global_objects/string/lastindexof/index.html
index 806fc88d78..2587f93802 100644
--- a/files/ru/web/javascript/reference/global_objects/string/lastindexof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/lastindexof/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>lastIndexOf()</code></strong> возвращает индекс последнего вхождения указанного значения в строковый объект {{jsxref("Global_Objects/String", "String")}}, на котором он был вызван, или -1, если ничего не было найдено. Поиск по строке ведётся от конца к началу, начиная с индекса <code>fromIndex</code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.lastIndexOf(<var>searchValue</var>[, <var>fromIndex</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>searchValue</code></dt>
@@ -29,7 +29,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf
  <dd>Необязательный параметр. Местоположение внутри строки, откуда начинать поиск, нумерация индексов идёт слева направо. Может быть любым целым числом. Значение по умолчанию установлено в <code>str.length</code>. Если оно отрицательно, трактуется как 0. Если <code>fromIndex &gt; str.length</code>, параметр <code>fromIndex</code> будет трактоваться как <code>str.length</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Символы в строке идут слева направо. Индекс первого символа равен 0, а последнего символа в строке <code>stringName</code> равен <code>stringName.length - 1</code>.</p>
 
@@ -39,16 +39,16 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf
 'канал'.lastIndexOf('ч');     // вернёт -1
 </pre>
 
-<h3 id="Case-sensitivity" name="Case-sensitivity">Регистрозависимость</h3>
+<h3 id="Case-sensitivity">Регистрозависимость</h3>
 
 <p>Метод <code>lastIndexOf()</code> является регистрозависимым. Например, следующее выражение вернёт -1:</p>
 
 <pre class="brush: js">'Синий кит, касатка'.lastIndexOf('синий'); // вернёт -1
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Пример: использование методов <code>indexOf()</code> и <code>lastIndexOf()</code></h3>
+<h3 id="Example:_Using_indexOf_and_lastIndexOf">Пример: использование методов <code>indexOf()</code> и <code>lastIndexOf()</code></h3>
 
 <p>В следующем примере используются методы {{jsxref("String.prototype.indexOf()", "indexOf()")}} и <code>lastIndexOf()</code> для нахождения значений в строке <code>"Дивный новый мир"</code>.</p>
 
@@ -65,7 +65,7 @@ console.log('Индекс вхождения «новый» с конца стр
 // Отобразит 7
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -92,11 +92,11 @@ console.log('Индекс вхождения «новый» с конца стр
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.charAt()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/length/index.html b/files/ru/web/javascript/reference/global_objects/string/length/index.html
index e211b62233..c6d50df520 100644
--- a/files/ru/web/javascript/reference/global_objects/string/length/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/length/index.html
@@ -11,20 +11,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/length
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Свойство <strong><code>length</code></strong> представляет длину строки.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.length</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Это свойство возвращает количество кодовых значений в строке. В {{interwiki("wikipedia", "UTF-16")}}, строковом формате, используемом в JavaScript, для представления большинства символов используется одно 16-битное кодовое значение, но для представления не так часто используемых символов требуется два кодовых значения, так что вполне может быть так, что значение, возвращённое свойством <code>length</code> не будет соответствовать действительному количеству символов в строке.</p>
 <p>Для пустых строк свойство <code>length</code> возвращает 0.</p>
 <p>Статическое свойство <code>String.length</code> возвращает значение 1.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Basic_usage" name="Example:_Basic_usage">Пример: базовое использование</h3>
+<h3 id="Example:_Basic_usage">Пример: базовое использование</h3>
 <pre class="brush: js">var x = 'Mozilla';
 var empty = '';
 
@@ -35,7 +35,7 @@ console.log('Пустая строка имеет длину, равную ' + e
 /* "Пустая строка имеет длину, равную 0" */
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -61,10 +61,10 @@ console.log('Пустая строка имеет длину, равную ' + e
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li><a class="external" href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">Свойство <code>String.length</code> в JavaScript и интернационализация веб-приложений</a></li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/string/link/index.html b/files/ru/web/javascript/reference/global_objects/string/link/index.html
index e1753fed0c..da943c1a9d 100644
--- a/files/ru/web/javascript/reference/global_objects/string/link/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/link/index.html
@@ -12,30 +12,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/link
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>link()</code></strong> создаёт HTML-элемент {{HTMLElement("a")}}, заставляющий строку отображаться в виде ссылки на другой URL.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.link(<var>url</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>url</code></dt>
  <dd>Любая строка, определяющая атрибут <code>href</code> тега <code>&lt;a&gt;</code>; она должна содержать допустимый URL (относительный или абсолютный), символы амперсанда <code>&amp;</code> должны быть закодированы в ней как <code>&amp;amp;</code>, а символы кавычки <code>"</code> — как <code>&amp;quot;</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>link()</code> используется для создания кусочка HTML со ссылкой в гипертексте. Возвращённая строка затем может быть добавлена в документ при помощи метода {{domxref("document.write()")}} или свойства {{domxref("element.innerHTML")}}</p>
 
 <p>Ссылки, созданные методом <code>link()</code>, становятся элементами в массиве {{domxref("document.links")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_link" name="Example:_Using_link">Пример: использование метода <code>link()</code></h3>
+<h3 id="Example:_Using_link">Пример: использование метода <code>link()</code></h3>
 
 <p>В следующем примере слово «MDN» отображается в виде гипертекстовой ссылки, ведущей на сайт Сети разработчиков Mozilla.</p>
 
@@ -50,7 +50,7 @@ document.write('Нажмите для возврата на ' + hotText.link(URL
 <pre class="brush: html">Нажмите для возврата на &lt;a href="https://developer.mozilla.org/"&gt;MDN&lt;/a&gt;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -68,11 +68,11 @@ document.write('Нажмите для возврата на ' + hotText.link(URL
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.anchor()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/localecompare/index.html b/files/ru/web/javascript/reference/global_objects/string/localecompare/index.html
index dad3736ce3..7ce4fadb4a 100644
--- a/files/ru/web/javascript/reference/global_objects/string/localecompare/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/localecompare/index.html
@@ -12,17 +12,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>localeCompare()</code></strong> возвращает число, указывающее, должна ли данная строка находиться до, после или в том же самом месте, что и строка, переданная через параметр, при сортировке этих строк.</p>
 
 <p>Новые аргументы <code>locales</code> и <code>options</code> позволяют приложениям определять язык, чей порядок сортировки оно хочет использовать и настраивать поведение этой функции. В старых реализациях, игнорирующих аргументы <code>locales</code> и <code>options</code>, используемая локаль и порядок сортировки целиком зависят от реализации.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.localeCompare(<var>compareString</var>[, <var>locales</var>[, <var>options</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <p>Проверьте раздел <a href="#Browser_compatibility">Совместимость с браузерами</a>, чтобы увидеть, какие браузеры поддерживают аргументы <code>locales</code> и <code>options</code>, и <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></a> для определения этой возможности.</p>
 
@@ -33,13 +33,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Collator', 'Parameters')}}</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Возвращает число, указывающее, должна данная строка находится до, после или в том же самом месте, что и строка, переданная через параметр, при сортировке этих строк. Если данная строка предшествует строке <code>compareString</code>, возвращает отрицательное число, если она следует за строкой <code>compareString</code>, возвращает положительное значение и возвращает 0, если строки находятся на одном уровне.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_localeCompare" name="Example:_Using_localeCompare">Пример: использование метода <code>localeCompare()</code></h3>
+<h3 id="Example:_Using_localeCompare">Пример: использование метода <code>localeCompare()</code></h3>
 
 <p>Следующий пример демонстрирует различные потенциальные результаты для строки, находящейся до, после или на том же самом уровне, что и другая строка:</p>
 
@@ -50,7 +50,7 @@ console.log(new Intl.Collator().compare('a', 'a')); // 0
 
 <p>Обратите внимание, что результат, показанный в коде выше, может сильно различаться в зависимости от браузера и его версии. Происходит это потому, что возвращаемые значения зависят от реализации. То есть, спецификация требует только того, чтобы значение было отрицательным, если строка данная следует до переданной, и положительным — если после.</p>
 
-<h3 id="Example:_Checking_for_support_for_locales_and_options_arguments" name="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
+<h3 id="Example:_Checking_for_support_for_locales_and_options_arguments">Пример: проверка поддержки аргументов <code>locales</code> и <code>options</code></h3>
 
 <p>Аргументы <code>locales</code> и <code>options</code> поддерживаются ещё не всеми браузерами. Для проверки того, поддерживает ли их уже реализация, можно затребовать несуществующую метку языка и проверить, будет ли выброшено исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}:</p>
 
@@ -64,7 +64,7 @@ console.log(new Intl.Collator().compare('a', 'a')); // 0
 }
 </pre>
 
-<h3 id="Example:_Using_locales" name="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
+<h3 id="Example:_Using_locales">Пример: использование аргумента <code>locales</code></h3>
 
 <p>Результаты, предоставляемые методом <code>localeCompare()</code>, сильно различаются в зависимости от языка. Для получения порядка сортировки языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) через аргумент <code>locales</code>:</p>
 
@@ -72,7 +72,7 @@ console.log(new Intl.Collator().compare('a', 'a')); // 0
 console.log('ä'.localeCompare('z', 'sv')); // положительное значение: в шведском буква ä следует после буквы z
 </pre>
 
-<h3 id="Example:_Using_options" name="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
+<h3 id="Example:_Using_options">Пример: использование аргумента <code>options</code></h3>
 
 <p>Результат, предоставляемый методом <code>localeCompare()</code>, может быть настроен с помощью аргумента <code>options</code>:</p>
 
@@ -83,11 +83,11 @@ console.log('ä'.localeCompare('a', 'de', { sensitivity: 'base' })); // 0
 console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // положительное значение
 </pre>
 
-<h2 id="Performance" name="Performance">Производительность</h2>
+<h2 id="Performance">Производительность</h2>
 
 <p>При сравнении большого количества строк, например, при сортировке больших массивов, лучшим вариантом будет создание объекта {{jsxref("Global_Objects/Collator", "Intl.Collator")}} и использование функции, предоставляемой его свойством {{jsxref("Collator.prototype.compare", "compare")}}.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -119,11 +119,11 @@ console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // поло
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/match/index.html b/files/ru/web/javascript/reference/global_objects/string/match/index.html
index ea19c9d8f2..12a2357aa1 100644
--- a/files/ru/web/javascript/reference/global_objects/string/match/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/match/index.html
@@ -12,44 +12,44 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/match
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>match()</code></strong> возвращает получившиеся совпадения при сопоставлении <em>строки</em> с <em>регулярным выражением</em>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.match(<var>regexp</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>regexp</code></dt>
  <dd>Объект регулярного выражения. Если будет передан объект <code>obj</code>, не являющийся регулярным выражением, он будет неявно преобразован в объект {{jsxref("Global_Objects/RegExp", "RegExp")}} через вызов конструктора <code>new RegExp(obj)</code>.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <dl>
  <dt><code>array</code></dt>
  <dd>Объект {{jsxref("Global_Objects/Array", "Array")}}, содержащий результаты сопоставления, или {{jsxref("Global_Objects/null", "null")}}, если ничего не было сопоставлено.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если регулярное выражение не содержит флаг <code>g</code>, возвращаемый результат будет тем же самым, что и при вызове метода {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}. Возвращаемый объект {{jsxref("Global_Objects/Array", "массива", "", 1)}} имеет дополнительное свойство <code>input</code>, которое содержит оригинальную строку. Кроме того, он имеет свойство <code>index</code>, которое представляет индекс (нумерация с нуля) сопоставления в строке.</p>
 
 <p>Если регулярное выражение содержит флаг <code>g</code>, метод вернёт {{jsxref("Global_Objects/Array", "массив", "", 1)}}, содержащий все сопоставления. Если сопоставлений не было, метод вернёт значение {{jsxref("Global_Objects/null", "null")}}.</p>
 
-<h3 id="See_also_RegExp_methods" name="See_also:_RegExp_methods">Смотрите также: методы объекта <code>RegExp</code></h3>
+<h3 id="See_also_RegExp_methods">Смотрите также: методы объекта <code>RegExp</code></h3>
 
 <ul>
  <li>Если вам надо просто узнать, подпадает ли строка под регулярное выражение, используйте метод {{jsxref("String.prototype.search()", "search()")}}.</li>
  <li>Если вам нужно найти только первое сопоставление, вы можете использовать метод {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}.</li>
 </ul>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_match" name="Example:_Using_match">Пример: использование метода <code>match()</code></h3>
+<h3 id="Example_Using_match">Пример: использование метода <code>match()</code></h3>
 
 <p>В следующем примере метод <code>match()</code> используется для поиска слова <code>'Глава'</code>, за которым следуют 1 или более цифр, за которыми следуют 0 или более раз группы из точки и цифры. Регулярное выражение включает флаг <code>i</code>, так что регистр букв игнорируется.</p>
 
@@ -72,7 +72,7 @@ console.log(found);
 // относительно начала сопоставления
 // Свойство 'input' содержит значение введённой строки.</pre>
 
-<h3 id="Example_Using_global_and_ignore_case_flags_with_match" name="Example:_Using_global_and_ignore_case_flags_with_match">Пример: использование флагов глобальности и игнорирования регистра с методом <code>match()</code></h3>
+<h3 id="Example_Using_global_and_ignore_case_flags_with_match">Пример: использование флагов глобальности и игнорирования регистра с методом <code>match()</code></h3>
 
 <p>Следующий пример демонстрирует использование флагов глобального поиска и игнорирования регистра символов вместе с методом <code>match()</code>. Возвращаются все буквы от А до Д и от а до д, каждая в своём элементе массива.</p>
 
@@ -84,7 +84,7 @@ console.log(matches_array);
 // ['А', 'Б', 'В', 'Г', 'Д', 'а', 'б', 'в', 'г', 'д']
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -111,11 +111,11 @@ console.log(matches_array);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("RegExp.prototype.exec()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/normalize/index.html b/files/ru/web/javascript/reference/global_objects/string/normalize/index.html
index 1f35f44c57..004069ac74 100644
--- a/files/ru/web/javascript/reference/global_objects/string/normalize/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/normalize/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>normalize()</code></strong> возвращает форму нормализации Юникода данной строки (если значение не является строкой, сначала оно будет в неё преобразовано).</p>
 
@@ -26,11 +26,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize
 
 <p>'æ' взаимозаменяемый 'ae', но они не являются строго эквивалентными, если не провести некоторую нормализацию</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.normalize(<var>[form</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>form</code></dt>
@@ -44,20 +44,20 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize
  </dd>
 </dl>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 
 <dl>
  <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt>
  <dd>Если параметр <code>form</code> не является одним из вышеперечисленных значений, будет выброшено исключение {{jsxref("Global_Objects/RangeError", "RangeError")}}.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>normalize()</code> возвращает указанную форму нормализации Юникода строки. Он не изменяет значение самой строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_normalize" name="Example:_Using_normalize">Пример: использование метода <code>normalize()</code></h3>
+<h3 id="Example_Using_normalize">Пример: использование метода <code>normalize()</code></h3>
 
 <pre class="brush: js">let valueStr = ['h', 'ĥ', 'æ', 'ae', 'g', 'ġ'],
     normArr = valueStr.map(function (text) {
@@ -96,7 +96,7 @@ valueStrNorm.sort(function (first, second) {
 valueStrNorm.join(', ');//-&gt; <span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string">ae, g, h, s, æ, ġ, ĥ, ș</span></span></span></span>
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -113,11 +113,11 @@ valueStrNorm.join(', ');//-&gt; <span class="message-body-wrapper"><span class="
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="http://www.unicode.org/reports/tr15/">Приложение №15 к стандарту Юникода: формы нормализации Юникода</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/raw/index.html b/files/ru/web/javascript/reference/global_objects/string/raw/index.html
index b886c79ab7..acf325ce41 100644
--- a/files/ru/web/javascript/reference/global_objects/string/raw/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/raw/index.html
@@ -14,11 +14,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/raw
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Статический метод <strong><code>String.raw()</code></strong> является теговой функцией для <a href="/ru/docs/Web/JavaScript/Reference/template_strings">шаблонных строк</a>; подобно префиксу <code>r</code> в Python или префиксу <code>@</code> в C# для строковых литералов, эта функция используется для получения необработанной строки из шаблона.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>
 String.raw(<var>callSite</var>, <var>...substitutions</var>)
@@ -26,7 +26,7 @@ String.raw(<var>callSite</var>, <var>...substitutions</var>)
 String.raw`templateString`
 </code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>callSite</code></dt>
@@ -37,22 +37,22 @@ String.raw`templateString`
  <dd><a href="/ru/docs/Web/JavaScript/Reference/template_strings">Шаблонная строка</a>, возможно с подстановками (<code>${...}</code>).</dd>
 </dl>
 
-<h3 id="Throws" name="Throws">Выбрасываемые исключения</h3>
+<h3 id="Throws">Выбрасываемые исключения</h3>
 
 <dl>
  <dt>{{jsxref("Global_Objects/TypeError", "TypeError")}}</dt>
  <dd>Если первый аргумент не является правильно сформированным объектом вызова, выбрасывается исключение {{jsxref("Global_Objects/TypeError", "TypeError")}}.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>В большинстве случаев метод <code>String.raw()</code> используется вместе с шаблонными строками. Первый синтаксис, показанный выше, используется редко, поскольку движок JavaScript будет вызывать метод с соответствующими аргументами, подобно другим <a href="/ru/docs/Web/JavaScript/Reference/template_strings#Tagged_template_strings">теговым функциям</a>.</p>
 
 <p>Метод <code>String.raw()</code> является единственной встроенной теговой функцией шаблонных строк, выступающей стандартной функцией по объединению их фрагментов. Вы и сами могли бы реализовать подобную функциональность на JavaScript.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_String.raw" name="Example:_String.raw">Пример: использование метода <code>String.raw()</code></h3>
+<h3 id="Example:_String.raw">Пример: использование метода <code>String.raw()</code></h3>
 
 <pre class="brush: js">String.raw`Привет\n${2+3}!`;
 // 'Привет\n5!', символ после 'Привет' не является символом новой строки,
@@ -75,7 +75,7 @@ String.raw({ raw: 'тест' }, 0, 1, 2);
 // 'т0е1с2т'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -92,11 +92,11 @@ String.raw({ raw: 'тест' }, 0, 1, 2);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Reference/template_strings">Шаблонные строки</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/repeat/index.html b/files/ru/web/javascript/reference/global_objects/string/repeat/index.html
index b03a567342..553abc7037 100644
--- a/files/ru/web/javascript/reference/global_objects/string/repeat/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/repeat/index.html
@@ -17,11 +17,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
 
 <div>Метод <strong><code>repeat()</code></strong> конструирует и возвращает новую строку, содержащую указанное количество соединённых вместе копий строки, на которой он был вызван.</div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.repeat(<var>count</var>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>count</code></dt>
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
 
 <p>Новая строка, содержащая указанное количество копий строки, для которой был вызван метод.</p>
 
-<h3 id="Throws" name="Throws">Исключения</h3>
+<h3 id="Throws">Исключения</h3>
 
 <ul>
  <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: число повторений не должно быть отрицательным.</li>
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
 <dl>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <pre class="brush: js">'абв'.repeat(-1);   // RangeError
 'абв'.repeat(0);    // ''
@@ -55,7 +55,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
 // 'абвабв' (метод repeat() является обобщённым методом)
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод был добавлен к спецификации ECMAScript 2015 и может быть доступен ещё не во всех реализациях JavaScript. Однако, вы можете легко эмулировать этот метод при помощи следующего кода:</p>
 
@@ -95,7 +95,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -117,5 +117,5 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat("javascript.builtins.String.repeat")}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/string/replace/index.html b/files/ru/web/javascript/reference/global_objects/string/replace/index.html
index c5d45bca42..e36ac94107 100644
--- a/files/ru/web/javascript/reference/global_objects/string/replace/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/replace/index.html
@@ -13,15 +13,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/replace
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>replace()</code></strong> возвращает новую строку с некоторыми или всеми сопоставлениями с шаблоном, заменёнными на заменитель. Шаблон может быть строкой или {{jsxref("Global_Objects/RegExp", "регулярным выражением", "", 1)}}, а заменитель может быть строкой или функцией, вызываемой при каждом сопоставлении.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.replace(<var>regexp</var>|<var>substr</var>, <var>newSubStr</var>|<var>function</var>[, <var>flags</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>regexp</code></dt>
@@ -49,17 +49,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/replace
  </dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Новая строка с некоторыми или всеми сопоставлениями шаблона, заменёнными на заменитель.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Этот метод не изменяет объект {{jsxref("Global_Objects/String", "String")}}, на котором он вызывается. Он просто возвращает новую строку.</p>
 
 <p>Для выполнения глобального поиска и замены либо включите флаг <code>g</code> в регулярное выражение, либо, если первый параметр является строкой, включите флаг <code>g</code> в параметр <code>flags</code>.</p>
 
-<h3 id="Specifying_a_string_as_a_parameter" name="Specifying_a_string_as_a_parameter">Передача строки в качестве второго параметра</h3>
+<h3 id="Specifying_a_string_as_a_parameter">Передача строки в качестве второго параметра</h3>
 
 <p>строка замены может включать следующие специальные шаблоны замены:</p>
 
@@ -92,7 +92,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/replace
  </tbody>
 </table>
 
-<h3 id="Specifying_a_function_as_a_parameter" name="Specifying_a_function_as_a_parameter">Передача функции в качестве второго параметра</h3>
+<h3 id="Specifying_a_function_as_a_parameter">Передача функции в качестве второго параметра</h3>
 
 <p>В качестве второго параметра вы можете передать функцию. В этом случае функция будет выполнена после произошедшего сопоставления. Результат вызова функции (её возвращаемое значение) будет использоваться в качестве строки замены (обратите внимание: описанные выше специальные шаблоны замены в этом случае <em>не</em> применяются). Обратите внимание, что функция будет вызвана несколько раз для каждого полного сопоставления, если регулярное выражение в первом параметре является глобальным.</p>
 
@@ -134,9 +134,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/replace
 var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer);
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_global_and_ignore_with_replace" name="Example:_Using_global_and_ignore_with_replace">Пример: использование флагов <code>global</code> и <code>ignore</code> с методом <code>replace()</code></h3>
+<h3 id="Example_Using_global_and_ignore_with_replace">Пример: использование флагов <code>global</code> и <code>ignore</code> с методом <code>replace()</code></h3>
 
 <p>В следующем примере регулярное выражение включает флаги для глобального поиска и игнорирования регистра, которые позволяют методу <code>replace()</code> заменить все вхождения слова «яблоки» в строке на слово «апельсины».</p>
 
@@ -146,7 +146,7 @@ var newstr = str.replace(re, 'апельсины');
 console.log(newstr); // апельсины круглые и апельсины сочные.
 </pre>
 
-<h3 id="Example_Defining_the_regular_expression_in_replace" name="Example:_Defining_the_regular_expression_in_replace">Пример: передача регулярного выражения в метод <code>replace()</code></h3>
+<h3 id="Example_Defining_the_regular_expression_in_replace">Пример: передача регулярного выражения в метод <code>replace()</code></h3>
 
 <p>В следующем примере в метод <code>replace()</code> передаётся регулярное выражение вместе с флагом игнорирования регистра.</p>
 
@@ -158,7 +158,7 @@ console.log(newstr); // Twas the night before Christmas...
 
 <p>Пример выведет строку 'Twas the night before Christmas...'</p>
 
-<h3 id="Example_Switching_words_in_a_string" name="Example:_Switching_words_in_a_string">Пример: смена местами слов в строке</h3>
+<h3 id="Example_Switching_words_in_a_string">Пример: смена местами слов в строке</h3>
 
 <p>Следующий скрипт меняет местами слова в строке. В качестве текста замены он использует шаблоны замены <code>$1</code> и <code>$2</code>.</p>
 
@@ -170,7 +170,7 @@ console.log(newstr); // Смит, Джон
 
 <p>Пример выведет строку 'Смит, Джон'.</p>
 
-<h3 id="Example_Using_an_inline_function_that_modifies_the_matched_characters" name="Example:_Using_an_inline_function_that_modifies_the_matched_characters">Пример: использование функции для изменения сопоставившихся символов</h3>
+<h3 id="Example_Using_an_inline_function_that_modifies_the_matched_characters">Пример: использование функции для изменения сопоставившихся символов</h3>
 
 <p>В этом примере все входящие в строку (латинские) буквы в верхнем регистре преобразуются в нижний регистр, а перед самой буквой вставляется дефис. Здесь важно то, что прежде чем элемент вставится в качестве замены, над ним нужно провести дополнительные преобразования.</p>
 
@@ -193,7 +193,7 @@ console.log(newstr); // Смит, Джон
 
 <p>Происходит это потому, что сначала часть <code>'$&amp;'.toLowerCase()</code> вычисляется в строковый литерал (результат по-прежнему равен <code>'$&amp;'</code>), а только потом его символы используются в качестве шаблона.</p>
 
-<h3 id="Example_Replacing_a_Fahrenheit_degree_with_its_Celsius_equivalent" name="Example:_Replacing_a_Fahrenheit_degree_with_its_Celsius_equivalent">Пример: замена градусов по Фаренгейту на эквивалент в градусах по Цельсию</h3>
+<h3 id="Example_Replacing_a_Fahrenheit_degree_with_its_Celsius_equivalent">Пример: замена градусов по Фаренгейту на эквивалент в градусах по Цельсию</h3>
 
 <p>В следующем примере градусы по Фаренгейту заменяются на эквивалентные градусы по Цельсию. Градусы по Фаренгейту должны быть числом, оканчивающимся на букву F. Функция возвращает количество градусов по Цельсию, оканчивающиеся на букву C. Например, если входное число равняется 212F, функция вернёт 100C. Если число равняется 0F, функция вернёт -17.77777777777778C.</p>
 
@@ -209,7 +209,7 @@ console.log(newstr); // Смит, Джон
 }
 </pre>
 
-<h3 id="Example_Use_an_inline_function_with_a_regular_expression_to_avoid_for_loops" name="Example: Use an inline function with a regular expression to avoid for loops">Пример: использование функции вместе с регулярным выражением для избавления от цикла <code>for</code></h3>
+<h3 id="Example_Use_an_inline_function_with_a_regular_expression_to_avoid_for_loops">Пример: использование функции вместе с регулярным выражением для избавления от цикла <code>for</code></h3>
 
 <p>Следующий пример принимает строку шаблона и преобразует её в массив объектов.</p>
 
@@ -249,7 +249,7 @@ console.log(retArr);
 
 <p>Этот код сгенерирует массив из трёх объектов в описанном формате без использования цикла <code>for</code>.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -276,11 +276,11 @@ console.log(retArr);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.String.replace")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.match()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/search/index.html b/files/ru/web/javascript/reference/global_objects/string/search/index.html
index 0f71e11efc..1615a0aee4 100644
--- a/files/ru/web/javascript/reference/global_objects/string/search/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/search/index.html
@@ -13,30 +13,30 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/search
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>search()</code></strong> выполняет поиск сопоставления между регулярным выражением и этим объектом {{jsxref("Global_Objects/String", "String")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><var>str</var>.search([<var>regexp</var>])</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>regexp</code></dt>
  <dd>Необязательный параметр. Объект регулярного выражения. Если будет передан не объект регулярного выражения, он будет неявно преобразован в объект {{jsxref("Global_Objects/RegExp", "RegExp")}} через вызов конструктора <code>new RegExp(regexp)</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>При успехе метод <code>search()</code> возвращает индекс первого сопоставления с регулярным выражением внутри строки. В противном случае метод вернёт -1.</p>
 
 <p>Если вы хотите узнать, находится ли шаблон в строке, используйте метод <code>search()</code> (он работает почти так же, как и метод {{jsxref("RegExp.prototype.test()", "test()")}} регулярного выражения, но вместо наличия подстроки возвращает её индекс); для получения дополнительной информации (за счёт более медленного выполнения) используйте метод {{jsxref("String.prototype.match()", "match()")}} (работает так же, как метод {{jsxref("RegExp.prototype.exec()", "exec()")}} регулярного выражения).</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_search" name="Example:_Using_search">Пример: использование метода <code>search()</code></h3>
+<h3 id="Example_Using_search">Пример: использование метода <code>search()</code></h3>
 
 <p>В следующем примере в журнал попадает сообщение, зависящее от успешности или неуспешности прохождения проверки.</p>
 
@@ -56,7 +56,7 @@ var re = /[A-Z]/g;
 testInput(re, testString); // выведет: hey Jude содержит /[A-Z]/g
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -83,11 +83,11 @@ testInput(re, testString); // выведет: hey Jude содержит /[A-Z]/g
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.match()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/slice/index.html b/files/ru/web/javascript/reference/global_objects/string/slice/index.html
index dde4bf29f6..1750d01614 100644
--- a/files/ru/web/javascript/reference/global_objects/string/slice/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/slice/index.html
@@ -11,17 +11,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/slice
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>slice()</code></strong> извлекает часть строки и возвращает новую строку без изменения оригинальной строки.</p>
 
 <p>{{EmbedInteractiveExample("pages/js/string-slice.html", "taller")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>str</var>.slice(<var>beginIndex</var>[, <var>endIndex</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><em><code>beginIndex</code></em></dt>
@@ -37,7 +37,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/slice
 
 <p>Новая строка, содержащая извлечённую часть строки.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>slice()</code> извлекает текст из одной строки и возвращает новую строку. Изменения текста в одной строке не влияют на другую строку.</p>
 
@@ -45,9 +45,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/slice
 
 <p>К примеру, вызов <code>str.slice(2, -1)</code> извлечёт символы с третьего по второй с конца строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_slice_to_create_a_new_string" name="Example:_Using_slice_to_create_a_new_string">Пример: использование метода <code>slice()</code> для создания новой строки</h3>
+<h3 id="Example_Using_slice_to_create_a_new_string">Пример: использование метода <code>slice()</code> для создания новой строки</h3>
 
 <p>В следующем примере метод <code>slice()</code> используется для создания новой строки.</p>
 
@@ -63,7 +63,7 @@ console.log(str4); // ВЫВОД:  утро.
 console.log(str5); // ВЫВОД: ""
 </pre>
 
-<h3 id="Example_Using_slice_with_negative_indexes" name="Example:_Using_slice_with_negative_indexes">Пример: использование метода <code>slice()</code> с отрицательными индексами</h3>
+<h3 id="Example_Using_slice_with_negative_indexes">Пример: использование метода <code>slice()</code> с отрицательными индексами</h3>
 
 <p>В следующем примере метод <code>slice()</code> используется вместе с отрицательными индексами.</p>
 
@@ -85,7 +85,7 @@ str.slice(0, -1);  // вернёт 'Приближается утро'
 
 <pre class="brush: js notranslate">str.slice(-5, -1); // вернёт 'утро'</pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -112,11 +112,11 @@ str.slice(0, -1);  // вернёт 'Приближается утро'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.substr()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/small/index.html b/files/ru/web/javascript/reference/global_objects/string/small/index.html
index 66cd9d8ea6..008fb1f35c 100644
--- a/files/ru/web/javascript/reference/global_objects/string/small/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/small/index.html
@@ -13,18 +13,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/small
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>small()</code></strong> создаёт HTML-элемент {{HTMLElement("small")}}, заставляющий строку отображаться маленьким шрифтом.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.small()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>small()</code> заключает строку в тег <code>&lt;small&gt;</code>: <code>"&lt;small&gt;str&lt;/small&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_small" name="Example:_Using_small">Пример: использование метода <code>small()</code></h3>
+<h3 id="Example:_Using_small">Пример: использование метода <code>small()</code></h3>
 <p>В следующем примере демонстрируется использование нескольких строковых методов для изменения размера строки:</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -36,7 +36,7 @@ console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Привет, мир&
 <pre class="brush: js">document.getElementById('yourElemId').style.fontSize = '0.7em';
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -53,10 +53,10 @@ console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Привет, мир&
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.fontsize()")}}</li>
  <li>{{jsxref("String.prototype.big()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/split/index.html b/files/ru/web/javascript/reference/global_objects/string/split/index.html
index 2788b8bdc6..984fe07e85 100644
--- a/files/ru/web/javascript/reference/global_objects/string/split/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/split/index.html
@@ -13,15 +13,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/split
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>split()</code></strong> разбивает объект {{jsxref("Global_Objects/String", "String")}} на массив строк путём разделения строки указанной подстрокой.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>str</var>.split([<var>separator</var>[, <var>limit</var>]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>separator</code></dt>
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/split
  <dd>Необязательный параметр. Целое число, определяющее ограничение на количество найденных подстрок. Метод <code>split()</code> всё равно разделяет строку на каждом сопоставлении с разделителем <code>separator</code>, но обрезает возвращаемый массив так, чтобы он содержал не более <code>limit</code> элементов.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>split()</code> возвращает новый массив.</p>
 
@@ -40,9 +40,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/split
 
 <p>{{Note("Если строка является пустой строкой, метод <code>split()</code> вернёт массив, состоящий из одной пустой строки, а не пустой массив.")}}</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_split" name="Example:_Using_split">Пример: использование метода <code>split()</code></h3>
+<h3 id="Example_Using_split">Пример: использование метода <code>split()</code></h3>
 
 <p>В следующем примере определяется функция, которая разбивает строку на массив строк, используя указанный разделитель. После разбиения строки, функция отображает сообщения, показывающие оригинальную строку (до разбиения), используемый разделитель, количество элементов в массиве и сами эти элементы.</p>
 
@@ -81,7 +81,7 @@ splitString(monthString, comma);
 Массив содержит 12 элементов: Янв / Фев / Мар / Апр / Май / Июн / Июл / Авг / Сен / Окт / Ноя / Дек
 </pre>
 
-<h3 id="Example_Removing_spaces_from_a_string" name="Example:_Removing_spaces_from_a_string">Пример: удаление пробелов из строки</h3>
+<h3 id="Example_Removing_spaces_from_a_string">Пример: удаление пробелов из строки</h3>
 
 <p>В следующем примере метод <code>split()</code> ищет 0 или более пробелов, за которыми следует точка с запятой, за которой снова следуют 0 или более пробелов, и, если этот шаблон найден, удаляет пробелы из строки. Переменная <code>nameList</code> является массивом, возвращённым в результате работы метода <code>split()</code>.</p>
 
@@ -101,7 +101,7 @@ console.log(nameList);
 Гарри Трамп,Фред Барни,Хелен Ригби,Билл Абель,Крис Ханд
 </pre>
 
-<h3 id="Example_Returning_a_limited_number_of_splits" name="Example:_Returning_a_limited_number_of_splits">Пример: возврат ограниченного числа подстрок</h3>
+<h3 id="Example_Returning_a_limited_number_of_splits">Пример: возврат ограниченного числа подстрок</h3>
 
 <p>В следующем примере метод <code>split()</code> ищет 0 или более пробелов в строке и возвращает первые три найденных подстроки.</p>
 
@@ -116,7 +116,7 @@ console.log(splits);
 <pre class="brush: js notranslate">Привет,,мир.,Как
 </pre>
 
-<h3 id="Example_Capturing_parentheses" name="Example:_Capturing_parentheses">Пример: захват подгрупп</h3>
+<h3 id="Example_Capturing_parentheses">Пример: захват подгрупп</h3>
 
 <p>Если параметр <code>separator</code> содержит подгруппы, сопоставившиеся результаты также будут присутствовать в возвращённом массиве.</p>
 
@@ -131,7 +131,7 @@ console.log(splits);
 <pre class="brush: js notranslate">Привет ,1, мир. Предложение номер ,2,.
 </pre>
 
-<h3 id="Example_Reversing_a_String_using_split" name="Example:_Reversing_a_String_using_split">Пример: обращение строки при помощи метода <code>split()</code></h3>
+<h3 id="Example_Reversing_a_String_using_split">Пример: обращение строки при помощи метода <code>split()</code></h3>
 
 <pre class="brush: js notranslate">var str = 'фывапролд';
 var strReverse = str.split('').reverse().join(''); // 'длорпавыф'
@@ -140,7 +140,7 @@ var strReverse = str.split('').reverse().join(''); // 'длорпавыф'
 
 <p><strong>Бонус:</strong> используя оператор {{jsxref("Operators/Comparison_Operators", "===", "#Identity_.2F_strict_equality_(.3D.3D.3D)")}}, можно проверить, являлась ли строка палиндромом.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -167,11 +167,11 @@ var strReverse = str.split('').reverse().join(''); // 'длорпавыф'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.charAt()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/startswith/index.html b/files/ru/web/javascript/reference/global_objects/string/startswith/index.html
index f13593ecac..25084d3d35 100644
--- a/files/ru/web/javascript/reference/global_objects/string/startswith/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/startswith/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>startsWith()</code></strong> помогает определить, начинается ли строка с символов указанных в скобках, возвращая, соответственно, <code>true</code> или <code>false</code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code><var>str</var>.startsWith(<var>searchString</var>[, <var>position</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>searchString</code></dt>
@@ -29,13 +29,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith
  <dd>Необязательный параметр. Позиция в строке, с которой начинать поиск  <code>searchString</code>; по умолчанию 0.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Этот метод позволяет определять, начинается ли строка с указанных в скобках символов.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_startsWith" name="Example:_Using_startsWith">Пример: использование метода <code>startsWith()</code></h3>
+<h3 id="Example_Using_startsWith">Пример: использование метода <code>startsWith()</code></h3>
 
 <pre class="brush: js notranslate">var str = 'Быть или не быть, вот в чём вопрос.';
 
@@ -44,7 +44,7 @@ console.log(str.startsWith('не быть'));     // false
 console.log(str.startsWith('не быть', 9));  // true
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Этот метод был добавлен к спецификации ECMAScript 6 и может быть доступен ещё не во всех реализациях JavaScript. Однако, вы можете легко эмулировать этот метод при помощи следующего кода:</p>
 
@@ -61,13 +61,13 @@ console.log(str.startsWith('не быть', 9));  // true
 }
 </pre>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.String.startsWith")}}</p>
 
 <div id="compat-mobile"></div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.endsWith()")}} {{experimental_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/strike/index.html b/files/ru/web/javascript/reference/global_objects/string/strike/index.html
index 03c068294d..fb873bb73e 100644
--- a/files/ru/web/javascript/reference/global_objects/string/strike/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/strike/index.html
@@ -13,18 +13,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/strike
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>strike()</code></strong> создаёт HTML-элемент {{HTMLElement("strike")}}, заставляющий строку отображаться зачёркнутым текстом.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.strike()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>strike()</code> заключает строку в тег <code>&lt;strike&gt;</code>: <code>"&lt;strike&gt;str&lt;/strike&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_strike" name="Example:_Using_strike">Пример: использование метода <code>strike()</code></h3>
+<h3 id="Example:_Using_strike">Пример: использование метода <code>strike()</code></h3>
 <p>В следующем примере демонстрируется использование нескольких строковых методов для изменения форматирования строки:</p>
 <pre class="brush: js">var worldString = 'Привет, мир';
 
@@ -40,7 +40,7 @@ document.write(worldString.strike());
 &lt;strike&gt;Привет, мир&lt;/strike&gt;
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -57,10 +57,10 @@ document.write(worldString.strike());
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.blink()")}}</li>
  <li>{{jsxref("String.prototype.bold()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/sub/index.html b/files/ru/web/javascript/reference/global_objects/string/sub/index.html
index cf5f4f7d5a..b2e773988e 100644
--- a/files/ru/web/javascript/reference/global_objects/string/sub/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/sub/index.html
@@ -13,18 +13,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/sub
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>sub()</code></strong> создаёт HTML-элемент {{HTMLElement("sub")}}, заставляющий строку отображаться подстрочным текстом (нижним индексом).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.sub()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>sub()</code> заключает строку в тег <code>&lt;sub&gt;</code>: <code>"&lt;sub&gt;str&lt;/sub&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_sub_and_sup_methods_to_format_a_string" name="Example:_Using_sub_and_sup_methods_to_format_a_string">Пример: использование методов <code>sub()</code> и <code>sup()</code></h3>
+<h3 id="Example:_Using_sub_and_sup_methods_to_format_a_string">Пример: использование методов <code>sub()</code> и <code>sup()</code></h3>
 <p>В следующем примере для форматирования строки используются методы <code>sub()</code> и {{jsxref("String.prototype.sup()", "sup()")}}:</p>
 <pre class="brush: js">var superText = 'надстрочный';
 var subText = 'подстрочный';
@@ -37,7 +37,7 @@ document.write('Вот так выглядит ' + subText.sub() + ' текст.
 Вот так выглядит &lt;sub&gt;подстрочный&lt;/sub&gt; текст.
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -54,10 +54,10 @@ document.write('Вот так выглядит ' + subText.sub() + ' текст.
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.sup()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/string/substr/index.html b/files/ru/web/javascript/reference/global_objects/string/substr/index.html
index b6bc0740ed..eead806c8a 100644
--- a/files/ru/web/javascript/reference/global_objects/string/substr/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/substr/index.html
@@ -22,11 +22,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/substr
 
 
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.substr(<var>start</var>[, <var>length</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>start</code></dt>
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/substr
 
 <p>Новая строка, содержащая часть исходной, обрезанной по переданным параметрам.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Параметр <code>start</code> является индексом символа. Индекс первого символа равен 0, а последнего символа — на один меньше длины строки. Метод <code>substr()</code> начинает извлекать символы начиная с позиции <code>start</code> и собирая <code>length</code> символов (если он не достигнет раньше конца строки, в этом случае будет возвращено меньшее количество символов).</p>
 
@@ -49,9 +49,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/substr
 
 <p>Если параметр <code>length</code> равен нулю или отрицателен, метод <code>substr()</code> вернёт пустую строку. Если параметр <code>length</code> опущен, метод <code>substr()</code> извлечёт все символы до конца строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_substr" name="Example:_Using_substr">Использование метода <code>substr()</code></h3>
+<h3 id="Example_Using_substr">Использование метода <code>substr()</code></h3>
 
 <pre class="brush: js">var str = 'абвгдеёжзи';
 
@@ -63,7 +63,7 @@ console.log('(-20, 2): ' + str.substr(-20, 2)); // '(-20, 2): аб'
 console.log('(20, 2): '  + str.substr(20, 2));  // '(20, 2): '
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>JScript от Microsoft не поддерживает отрицательные значения для начального индекса. Если вы хотите использовать эту возможность, вы можете использовать следующий код совместимости для обхода этой ошибки:</p>
 
@@ -88,7 +88,7 @@ if ('ab'.substr(-1) != 'b') {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -101,10 +101,10 @@ if ('ab'.substr(-1) != 'b') {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat("javascript.builtins.String.substr")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.slice()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/substring/index.html b/files/ru/web/javascript/reference/global_objects/string/substring/index.html
index bdcb28f47a..cd76f60ec6 100644
--- a/files/ru/web/javascript/reference/global_objects/string/substring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/substring/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/substring
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>substring()</code></strong> возвращает подстроку строки между двумя индексами, или от одного индекса и до конца строки.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.substring(<var>indexA</var>[, <var>indexB</var>])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>indexA</code></dt>
@@ -29,7 +29,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/substring
  <dd>Необязательный параметр. Целое число от <code>0</code> до длины строки, определяющее смещение в строке первого символа, который <strong>не будет</strong> включён в результирующую подстроку.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>substring()</code> извлекает символы, начиная с индекса <code>indexA</code> до, но не включая, индекс <code>indexB</code>. В частности:</p>
 
@@ -42,9 +42,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/substring
 
 <p>Если аргумент <code>indexA</code> будет больше аргумента <code>indexB</code>, то метод <code>substring()</code> сработает так, как если бы аргументы были поменяны местами; например, <code><em>str</em>.substring(1, 0) == <em>str</em>.substring(0, 1)</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_substring" name="Example:_Using_substring">Пример: использование метода <code>substring()</code></h3>
+<h3 id="Example:_Using_substring">Пример: использование метода <code>substring()</code></h3>
 
 <p>В следующем примере метод <code>substring()</code> используется для отображения символов из строки <code>'Mozilla'</code>:</p>
 
@@ -66,7 +66,7 @@ console.log(anyString.substring(0, 7));
 console.log(anyString.substring(0, 10));
 </pre>
 
-<h3 id="Example:_Using_substring_with_length_property" name="Example:_Using_substring_with_length_property">Пример: использование метода <code>substring()</code> вместе со свойством <code>length</code></h3>
+<h3 id="Example:_Using_substring_with_length_property">Пример: использование метода <code>substring()</code> вместе со свойством <code>length</code></h3>
 
 <p>Следующий пример использует метод <code>substring()</code> и свойство {{jsxref("String.length", "length")}} для извлечения последних символов из строки. Этот метод может оказаться легче для запоминания, особенно если учесть, что вам не нужно знать начальный и конечный индексы, как это было в примере выше.</p>
 
@@ -81,7 +81,7 @@ var anyString5 = anyString.substring(anyString.length - 5);
 console.log(anyString5);
 </pre>
 
-<h3 id="Example:_Replacing_a_substring_within_a_string" name="Example:_Replacing_a_substring_within_a_string">Пример: замена подстроки в строке</h3>
+<h3 id="Example:_Replacing_a_substring_within_a_string">Пример: замена подстроки в строке</h3>
 
 <p>Следующий пример демонстрирует замену подстроки в строке. Он заменит как отдельные символы, так и целые подстроки. Вызов функции в конце примера изменит строку <code>'Дивный новый мир'</code> на строку <code>'Дивный новый веб'</code>.</p>
 
@@ -107,7 +107,7 @@ replaceString('мир', 'веб', 'Дивный новый мир');
 
 <p>Код выше следует рассматривать всего лишь как пример работы с подстроками. Если вам нужно заменить подстроки, скорее всего вы захотите использовать метод {{jsxref("String.prototype.replace()")}}.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -134,11 +134,11 @@ replaceString('мир', 'веб', 'Дивный новый мир');
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.substr()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/sup/index.html b/files/ru/web/javascript/reference/global_objects/string/sup/index.html
index 0e95d41d27..8cd3d89294 100644
--- a/files/ru/web/javascript/reference/global_objects/string/sup/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/sup/index.html
@@ -13,18 +13,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/sup
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{deprecated_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>sup()</code></strong> создаёт HTML-элемент {{HTMLElement("sup")}}, заставляющий строку отображаться надстрочным текстом (верхним индексом).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.sup()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>sup()</code> заключает строку в тег <code>&lt;sup&gt;</code>: <code>"&lt;sup&gt;str&lt;/sup&gt;"</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_sub_and_sup_methods_to_format_a_string" name="Example:_Using_sub_and_sup_methods_to_format_a_string">Пример: использование методов <code>sub()</code> и <code>sup()</code></h3>
+<h3 id="Example:_Using_sub_and_sup_methods_to_format_a_string">Пример: использование методов <code>sub()</code> и <code>sup()</code></h3>
 <p>В следующем примере для форматирования строки используются методы {{jsxref("String.prototype.sub()", "sub()")}} и <code>sup()</code>:</p>
 <pre class="brush: js">var superText = 'надстрочный';
 var subText = 'подстрочный';
@@ -37,7 +37,7 @@ document.write('Вот так выглядит ' + subText.sub() + ' текст.
 Вот так выглядит &lt;sub&gt;подстрочный&lt;/sub&gt; текст.
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -54,10 +54,10 @@ document.write('Вот так выглядит ' + subText.sub() + ' текст.
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.sub()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/string/tolocalelowercase/index.html b/files/ru/web/javascript/reference/global_objects/string/tolocalelowercase/index.html
index 37ddf92645..bf58132fe4 100644
--- a/files/ru/web/javascript/reference/global_objects/string/tolocalelowercase/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/tolocalelowercase/index.html
@@ -12,22 +12,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toLocaleLowerCase()</code></strong> возвращает значение строки, на которой он был вызван, преобразованное в нижний регистр согласно правилам преобразования регистра локали.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.toLocaleLowerCase()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toLocaleLowerCase()</code> возвращает значение строки, преобразованное в нижний регистр согласно правилам преобразования регистра локали. Метод <code>toLocaleLowerCase()</code> не изменяет значение самой строки. В большинстве случаев он возвращает тот же результат, что и метод {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}, но для некоторых локалей, например, турецкой, в которой правила преобразования регистра отличаются от правил по умолчанию, принятых в Юникоде, он может вернуть другой результат.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toLocaleLowerCase" name="Example:_Using_toLocaleLowerCase">Пример: использование метода <code>toLocaleLowerCase()</code></h3>
+<h3 id="Example:_Using_toLocaleLowerCase">Пример: использование метода <code>toLocaleLowerCase()</code></h3>
 <pre class="brush: js">console.log('АЛФАВИТ'.toLocaleLowerCase()); // 'алфавит'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -53,10 +53,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
  <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html b/files/ru/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html
index 1bad6f24df..a0512f6e52 100644
--- a/files/ru/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html
@@ -12,22 +12,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toLocaleUpperCase()</code></strong> возвращает значение строки, на которой он был вызван, преобразованное в верхний регистр согласно правилам преобразования регистра локали.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.toLocaleUpperCase()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toLocaleUpperCase()</code> возвращает значение строки, преобразованное в верхний регистр согласно правилам преобразования регистра локали. Метод <code>toLocaleUpperCase()</code> не изменяет значение самой строки. В большинстве случаев он возвращает тот же результат, что и метод {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}, но для некоторых локалей, например, турецкой, в которой правила преобразования регистра отличаются от правил по умолчанию, принятых в Юникоде, он может вернуть другой результат.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toLocaleUpperCase" name="Example:_Using_toLocaleUpperCase">Пример: использование метода <code>toLocaleUpperCase()</code></h3>
+<h3 id="Example:_Using_toLocaleUpperCase">Пример: использование метода <code>toLocaleUpperCase()</code></h3>
 <pre class="brush: js">console.log('алфавит'.toLocaleUpperCase()); // 'АЛФАВИТ'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -53,10 +53,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
  <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/ru/web/javascript/reference/global_objects/string/tolowercase/index.html
index 2c6d4b2b65..1f5068e0e8 100644
--- a/files/ru/web/javascript/reference/global_objects/string/tolowercase/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/tolowercase/index.html
@@ -11,22 +11,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toLowerCase()</code></strong> возвращает значение строки, на которой он был вызван, преобразованное в нижний регистр.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.toLowerCase()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toLowerCase()</code> возвращает значение строки, преобразованное в нижний регистр. Метод <code>toLowerCase()</code> не изменяет значение самой строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toLowerCase" name="Example:_Using_toLowerCase">Пример: использование метода <code>toLowerCase()</code></h3>
+<h3 id="Example:_Using_toLowerCase">Пример: использование метода <code>toLowerCase()</code></h3>
 <pre class="brush: js">console.log('АЛФАВИТ'.toLowerCase()); // 'алфавит'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -52,10 +52,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
  <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/tosource/index.html b/files/ru/web/javascript/reference/global_objects/string/tosource/index.html
index 0fe2e7a29a..a4e9655d69 100644
--- a/files/ru/web/javascript/reference/global_objects/string/tosource/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/tosource/index.html
@@ -12,15 +12,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toSource()</code></strong> возвращает строковое представление исходного кода объекта.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>String.toSource()
 <var>str</var>.toSource()
 </code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toSource()</code> возвращает следующие значения:</p>
 <ul>
  <li>Для встроенного объекта {{jsxref("Global_Objects/String", "String")}} метод <code>toSource()</code> возвращает следующую строку, указывающую, что исходный код недоступен:
@@ -33,13 +33,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource
 </ul>
 <p>Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/global_objects/string/tostring/index.html b/files/ru/web/javascript/reference/global_objects/string/tostring/index.html
index 5859f1bee6..d2019e47ea 100644
--- a/files/ru/web/javascript/reference/global_objects/string/tostring/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/tostring/index.html
@@ -11,25 +11,25 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toString
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toString()</code></strong> возвращает строку, представляющую указанный объект.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.toString()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Объект {{jsxref("Global_Objects/String", "String")}} переопределяет метод <code>toString()</code>, унаследованный из объекта {{jsxref("Global_Objects/Object", "Object")}}; он не наследует метод {{jsxref("Object.prototype.toString()")}}. Для объектов {{jsxref("Global_Objects/String", "String")}} метод <code>toString()</code> возвращает строку, представляющую объект и делает тоже самое, что и метод {{jsxref("String.prototype.valueOf()")}}.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toString" name="Example:_Using_toString">Пример: использование метода <code>toString()</code></h3>
+<h3 id="Example:_Using_toString">Пример: использование метода <code>toString()</code></h3>
 <p>В следующем примере выводится строковое значение объекта {{jsxref("Global_Objects/String", "String")}}:</p>
 <pre class="brush: js">var x = new String('Привет, мир');
 
 console.log(x.toString()); // Отобразит 'Привет, мир'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -55,10 +55,10 @@ console.log(x.toString()); // Отобразит 'Привет, мир'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Object.prototype.toSource()")}}</li>
  <li>{{jsxref("String.prototype.valueOf()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/touppercase/index.html b/files/ru/web/javascript/reference/global_objects/string/touppercase/index.html
index 53bd787821..9821168dad 100644
--- a/files/ru/web/javascript/reference/global_objects/string/touppercase/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/touppercase/index.html
@@ -11,22 +11,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>toUpperCase()</code></strong> возвращает значение строки, на которой он был вызван, преобразованное в верхний регистр.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.toUpperCase()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>toUpperCase()</code> возвращает значение строки, преобразованное в верхний регистр. Метод <code>toUpperCase()</code> не изменяет значение самой строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_toUpperCase" name="Example:_Using_toUpperCase">Пример: использование метода <code>toUpperCase()</code></h3>
+<h3 id="Example:_Using_toUpperCase">Пример: использование метода <code>toUpperCase()</code></h3>
 <pre class="brush: js">console.log('алфавит'.toUpperCase()); // 'АЛФАВИТ'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -52,10 +52,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
  <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/trim/index.html b/files/ru/web/javascript/reference/global_objects/string/trim/index.html
index d01464bef6..d81fccf423 100644
--- a/files/ru/web/javascript/reference/global_objects/string/trim/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/trim/index.html
@@ -12,21 +12,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>trim()</code></strong> удаляет пробельные символы с начала и конца строки. Пробельными символами в этом контексте считаются все собственно пробельные символы (пробел, табуляция, неразрывный пробел и прочие) и все символы конца строки (LF, CR и прочие).</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.trim()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>trim()</code> возвращает строку с вырезанными пробельными символами с её концов. Метод <code>trim()</code> не изменяет значение самой строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_trim" name="Example:_Using_trim">Пример: использование метода <code>trim()</code></h3>
+<h3 id="Example:_Using_trim">Пример: использование метода <code>trim()</code></h3>
 
 <p>Следующий пример покажет строку <code>'foo'</code>:</p>
 
@@ -39,7 +39,7 @@ var orig = 'foo    ';
 console.log(orig.trim()); // 'foo'
 </pre>
 
-<h2 id="Polyfill" name="Polyfill">Полифил</h2>
+<h2 id="Polyfill">Полифил</h2>
 
 <p>Запуск следующего кода до любого другого создаст метод <code>trim()</code>, если он ещё не реализуется браузером.</p>
 
@@ -53,7 +53,7 @@ console.log(orig.trim()); // 'foo'
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -75,11 +75,11 @@ console.log(orig.trim()); // 'foo'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/trimend/index.html b/files/ru/web/javascript/reference/global_objects/string/trimend/index.html
index 70397d076c..d68ff8495f 100644
--- a/files/ru/web/javascript/reference/global_objects/string/trimend/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/trimend/index.html
@@ -13,18 +13,18 @@ original_slug: Web/JavaScript/Reference/Global_Objects/String/TrimRight
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>trimRight()</code></strong> удаляет пробельные символы с правого конца строки.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.trimRight()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>trimRight()</code> возвращает строку с вырезанными пробельными символами с её правого конца. Метод <code>trimRight()</code> не изменяет значение самой строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_trimRight" name="Example:_Using_trimRight">Пример: использование метода <code>trimRight()</code></h3>
+<h3 id="Example:_Using_trimRight">Пример: использование метода <code>trimRight()</code></h3>
 <p>Следующий пример покажет строку <code style="white-space: pre;">'   foo'</code>:</p>
 <pre class="brush: js; highlight: [5]">var str = '   foo  ';
 
@@ -35,13 +35,13 @@ console.log(str.length); // 5
 console.log(str);        // '   foo'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.8.1.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.trim()")}}</li>
  <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/trimstart/index.html b/files/ru/web/javascript/reference/global_objects/string/trimstart/index.html
index 39f7d670bc..a5f0149a65 100644
--- a/files/ru/web/javascript/reference/global_objects/string/trimstart/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/trimstart/index.html
@@ -13,18 +13,18 @@ original_slug: Web/JavaScript/Reference/Global_Objects/String/TrimLeft
 ---
 <div>{{JSRef("Global_Objects", "String")}} {{non-standard_header}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Метод <strong><code>trimLeft()</code></strong> удаляет пробельные символы с левого конца строки.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code><var>str</var>.trimLeft()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Метод <code>trimLeft()</code> возвращает строку с вырезанными пробельными символами с её левого конца. Метод <code>trimLeft()</code> не изменяет значение самой строки.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_trimLeft" name="Example:_Using_trimLeft">Пример: использование метода <code>trimLeft()</code></h3>
+<h3 id="Example:_Using_trimLeft">Пример: использование метода <code>trimLeft()</code></h3>
 <p>Следующий пример покажет строку <code style="white-space: pre;">'foo  '</code>:</p>
 <pre class="brush: js; highlight: [5]">var str = '   foo  ';
 
@@ -35,13 +35,13 @@ console.log(str.length); // 5
 console.log(str);        // 'foo  '
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.8.1.</p>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("String.prototype.trim()")}}</li>
  <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/string/valueof/index.html b/files/ru/web/javascript/reference/global_objects/string/valueof/index.html
index 3f8439a05c..27d7a14a52 100644
--- a/files/ru/web/javascript/reference/global_objects/string/valueof/index.html
+++ b/files/ru/web/javascript/reference/global_objects/string/valueof/index.html
@@ -11,29 +11,29 @@ translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf
 ---
 <div>{{JSRef("Global_Objects", "String")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Метод <strong><code>valueOf()</code></strong> возвращает примитивное значение объекта {{jsxref("Global_Objects/String", "String")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><var>str</var>.valueOf()</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Метод <code>valueOf()</code> возвращает примитивное значение объекта {{jsxref("Global_Objects/String", "String")}} в виде строкового типа данных. Это значение эквивалентно значению вызова метода {{jsxref("String.prototype.toString()")}}.</p>
 
 <p>Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Using_valueOf" name="Example:_Using_valueOf">Пример: использование метода <code>valueOf()</code></h3>
+<h3 id="Example:_Using_valueOf">Пример: использование метода <code>valueOf()</code></h3>
 
 <pre class="brush: js">var x = new String('Привет, мир');
 console.log(x.valueOf()); // Отобразит 'Привет, мир'
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -60,11 +60,11 @@ console.log(x.valueOf()); // Отобразит 'Привет, мир'
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("String.prototype.toString()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/symbol/index.html b/files/ru/web/javascript/reference/global_objects/symbol/index.html
index 4091996093..b1f8336b18 100644
--- a/files/ru/web/javascript/reference/global_objects/symbol/index.html
+++ b/files/ru/web/javascript/reference/global_objects/symbol/index.html
@@ -11,22 +11,22 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Symbol
 ---
 <div>{{JSRef}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p><strong style="line-height: 1.5;">Символ (анг. Symbol)</strong><span style="line-height: 1.5;"> — это уникальный и неизменяемый тип данных, который может быть использован как идентификатор для свойств объектов. </span><em>Символьный объект (анг. symbol object) </em>— это объект-обёртка (англ. wrapper) для <span style="line-height: 1.5;">{{Glossary("Primitive", "примитивного")}} символьного типа.</span></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>Symbol(<em>[описание]</em>)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>описание</code> {{optional_inline}}</dt>
  <dd>Необязательный, строка. Описание символа, которое может быть использовано во время отладки, но не для доступа к самому символу.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Чтобы создать новый символьный примитив, достаточно написать <code>Symbol()</code>, указав по желанию строку в качестве описания этого символа:</p>
 
@@ -61,7 +61,7 @@ typeof symObj;  // "object"
 
 <p>Метод {{jsxref("Object.getOwnPropertySymbols()")}} возвращает массив символов и позволяет получить символьные свойства конкретного объекта. Следует заметить, что при инициализации объекты не получают символьных свойств, так что этот массив будет пуст, пока вы не зададите ему какое-либо символьное свойство.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt><code>Symbol.length</code></dt>
@@ -108,7 +108,7 @@ typeof symObj;  // "object"
  <dd>Строковое значение, используемое в качестве описания объекта по умолчанию. Используется функцией {{jsxref("Object.prototype.toString()")}}</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <dl>
  <dt>{{jsxref("Symbol.for()", "Symbol.for(key)")}}</dt>
@@ -117,7 +117,7 @@ typeof symObj;  // "object"
  <dd>Получает по разделяемому символу его ключ из глобального реестра символов.</dd>
 </dl>
 
-<h2 id="Boolean_instances" name="Boolean_instances"><code><span style="font-family: open sans,sans-serif; font-size: 2.14285714285714rem;">Прототип </span>Symbol</code></h2>
+<h2 id="Boolean_instances"><code><span style="font-family: open sans,sans-serif; font-size: 2.14285714285714rem;">Прототип </span>Symbol</code></h2>
 
 <p>Все символы наследуют от {{jsxref("Symbol.prototype")}}.</p>
 
@@ -129,9 +129,9 @@ typeof symObj;  // "object"
 
 <p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Methods')}}</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Creating_Boolean_objects_with_an_initial_value_of_false" name="Creating_Boolean_objects_with_an_initial_value_of_false">Использование оператора <code>typeof</code> с символами</h3>
+<h3 id="Creating_Boolean_objects_with_an_initial_value_of_false">Использование оператора <code>typeof</code> с символами</h3>
 
 <p>Оператор {{jsxref("Operators/typeof", "typeof")}} позволяет идентифицировать символ.</p>
 
@@ -211,7 +211,7 @@ obj[Object(sym)];    // снова 1
 
 <p>{{Compat("javascript.builtins.Symbol")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Glossary/Symbol">Глоссарий: Символьный тип данных</a></li>
diff --git a/files/ru/web/javascript/reference/global_objects/syntaxerror/index.html b/files/ru/web/javascript/reference/global_objects/syntaxerror/index.html
index 249d08ba65..03b4c051e9 100644
--- a/files/ru/web/javascript/reference/global_objects/syntaxerror/index.html
+++ b/files/ru/web/javascript/reference/global_objects/syntaxerror/index.html
@@ -11,15 +11,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Объект <code><strong>SyntaxError</strong></code> представляет ошибку, возникающую при попытке интерпретировать синтаксически неправильный код.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>new SyntaxError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>message</code></dt>
@@ -30,34 +30,34 @@ translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError
  <dd>Необязательный параметр. Номер строки кода, вызвавшей исключение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Исключение <code>SyntaxError</code> выбрасывается, когда движок JavaScript при разборе кода обнаруживает токены или токен, которые, согласно синтаксису, не должны здесь находиться.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("SyntaxError.prototype")}}</dt>
  <dd>Позволяет добавлять свойства в объект <code>SyntaxError</code>.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <p>Глобальный объект <code>SyntaxError</code> не содержит собственных методов, однако, он наследует некоторые методы из цепочки прототипов.</p>
 
-<h2 id="SyntaxError_instances" name="SyntaxError_instances">Экземпляры объекта <code>SyntaxError</code></h2>
+<h2 id="SyntaxError_instances">Экземпляры объекта <code>SyntaxError</code></h2>
 
-<h3 id="Properties_of_SyntaxError_instances" name="Properties_of_SyntaxError_instances">Свойства</h3>
+<h3 id="Properties_of_SyntaxError_instances">Свойства</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_SyntaxError_instances" name="Methods_of_SyntaxError_instances">Методы</h3>
+<h3 id="Methods_of_SyntaxError_instances">Методы</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Catch_an_SyntaxError" name="Example:_Catch_an_SyntaxError">Пример: перехват исключения <code>SyntaxError</code></h3>
+<h3 id="Example:_Catch_an_SyntaxError">Пример: перехват исключения <code>SyntaxError</code></h3>
 
 <pre class="brush: js">try {
   eval('hoo bar');
@@ -72,7 +72,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError
 }
 </pre>
 
-<h3 id="Example:_Create_an_SyntaxError" name="Example:_Create_an_SyntaxError">Пример: возбуждение исключения <code>SyntaxError</code></h3>
+<h3 id="Example:_Create_an_SyntaxError">Пример: возбуждение исключения <code>SyntaxError</code></h3>
 
 <pre class="brush: js">try {
   throw new SyntaxError('Привет', 'someFile.js', 10);
@@ -87,7 +87,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -114,11 +114,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Error")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/typedarray/index.html b/files/ru/web/javascript/reference/global_objects/typedarray/index.html
index 249c42d358..c1e580642e 100644
--- a/files/ru/web/javascript/reference/global_objects/typedarray/index.html
+++ b/files/ru/web/javascript/reference/global_objects/typedarray/index.html
@@ -38,7 +38,7 @@ Int8Array(), Uint8Array(), Uint8ClampedArray(), Int16Array(), Uint16Array(), Int
  <dd>Когда происходит вызов с параметрами <strong><code>buffer</code> </strong>и опциональными параметрами <strong><code>byteOffset </code></strong>и<code> </code><strong><code>length</code></strong>, то будет создан новый типизированный массив, который будет отражать <code>buffer </code>типа {{jsxref("ArrayBuffer")}}. Параметры <code>byteOffset</code> и <code>length</code> определяют диапазон (размер) памяти, выводимый данным массивоподобным представлением. Если оба этих параметра (<code>byteOffset</code> и <code>length</code>) опущены, то будет использован весь буфер <code>buffer</code>; если опущен только <code>length</code>, то будет выведен весь остаток буфера после смещения начала отсчёта элементов, заданного параметром <code>byteOffset</code>.</dd>
 </dl>
 
-<h2 id="Описание"><a id="Description" name="Description">Описание</a></h2>
+<h2 id="Описание"><a id="Description">Описание</a></h2>
 
 <p>ECMAScript 2015 определяет конструктор объекта <em>TypedArray, </em>который является прототипом всех <em>TypedArray</em>-конструкторов. Этот конструктор не открыт явным образом: какое-либо глобальное свойство <em><code>%TypedArray%</code></em> или <em><code>TypedArray</code> </em>отсутствует.  Он доступен только через <code>Object.getPrototypeOf(...) (</code>например<code>, Int8Array.prototype)</code>. Все <em>TypedArray</em>s конструкторы наследуют общие свойства от конструктора <code>%TypedArray%</code>. Кроме того, все прототипы типизированных массивов (<em>TypedArray<code>.</code></em><code>prototype</code>) имеют своим прототипом <em>%TypedArray%<code>.</code></em><code>prototype</code>.</p>
 
@@ -69,7 +69,7 @@ Int8Array.prototype[-1] = "foo";
 Int8Array.prototype.foo = "bar";
 (new Int8Array(32)).foo; // "bar"</pre>
 
-<h2 id="Объекты_TypedArray"><a id="TypedArray_objects" name="TypedArray_objects">Объекты TypedArray</a></h2>
+<h2 id="Объекты_TypedArray"><a id="TypedArray_objects">Объекты TypedArray</a></h2>
 
 <table class="standard-table">
  <tbody>
diff --git a/files/ru/web/javascript/reference/global_objects/typedarray/join/index.html b/files/ru/web/javascript/reference/global_objects/typedarray/join/index.html
index fab9f3d39c..16bd6ac030 100644
--- a/files/ru/web/javascript/reference/global_objects/typedarray/join/index.html
+++ b/files/ru/web/javascript/reference/global_objects/typedarray/join/index.html
@@ -71,7 +71,7 @@ if (!Uint8Array.prototype.join) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/typeerror/index.html b/files/ru/web/javascript/reference/global_objects/typeerror/index.html
index 3fa1ac526e..7a366027b7 100644
--- a/files/ru/web/javascript/reference/global_objects/typeerror/index.html
+++ b/files/ru/web/javascript/reference/global_objects/typeerror/index.html
@@ -11,15 +11,15 @@ translation_of: Web/JavaScript/Reference/Global_Objects/TypeError
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Объект <code><strong>TypeError</strong></code> представляет ошибку, возникающую, когда значение имеет не ожидаемый тип.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>new TypeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>message</code></dt>
@@ -30,34 +30,34 @@ translation_of: Web/JavaScript/Reference/Global_Objects/TypeError
  <dd>Необязательный параметр. Номер строки кода, вызвавшей исключение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Исключение <code>TypeError</code> выбрасывается, когда операнд или аргумент, переданный в функцию, не совместим с типом, ожидаемым оператором или функцией.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt>{{jsxref("TypeError.prototype")}}</dt>
  <dd>Позволяет добавлять свойства в объект <code>TypeError</code>.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 
 <p>Глобальный объект <code>TypeError</code> не содержит собственных методов, однако, он наследует некоторые методы из цепочки прототипов.</p>
 
-<h2 id="TypeError_instances" name="TypeError_instances">Экземпляры объекта <code>TypeError</code></h2>
+<h2 id="TypeError_instances">Экземпляры объекта <code>TypeError</code></h2>
 
-<h3 id="Properties_of_TypeError_instances" name="Properties_of_TypeError_instances">Свойства</h3>
+<h3 id="Properties_of_TypeError_instances">Свойства</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_TypeError_instances" name="Methods_of_TypeError_instances">Методы</h3>
+<h3 id="Methods_of_TypeError_instances">Методы</h3>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Catch_an_TypeError" name="Example:_Catch_an_TypeError">Пример: перехват исключения <code>TypeError</code></h3>
+<h3 id="Example:_Catch_an_TypeError">Пример: перехват исключения <code>TypeError</code></h3>
 
 <pre class="brush: js">try {
   null.f();
@@ -72,7 +72,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/TypeError
 }
 </pre>
 
-<h3 id="Example:_Create_an_TypeError" name="Example:_Create_an_TypeError">Пример: возбуждение исключения <code>TypeError</code></h3>
+<h3 id="Example:_Create_an_TypeError">Пример: возбуждение исключения <code>TypeError</code></h3>
 
 <pre class="brush: js">try {
   throw new TypeError('Привет', 'someFile.js', 10);
@@ -87,7 +87,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/TypeError
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -119,11 +119,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/TypeError
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>{{Compat("javascript.builtins.TypeError")}}</div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Error")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/undefined/index.html b/files/ru/web/javascript/reference/global_objects/undefined/index.html
index f4d713203c..e5fbfc3e2a 100644
--- a/files/ru/web/javascript/reference/global_objects/undefined/index.html
+++ b/files/ru/web/javascript/reference/global_objects/undefined/index.html
@@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/undefined
 ---
 <div>{{jsSidebar("Objects")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Значение глобального свойства <code><strong>undefined</strong></code> представляет значение <code>{{Glossary("Undefined", "undefined")}}</code>. Это одно из {{Glossary("Primitive", "примитивных значений")}} JavaScript.</p>
 
@@ -23,11 +23,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/undefined
 <p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
 </div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>undefined</code></pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p><code>undefined</code> является свойством <em>глобального объекта</em>, то есть, это переменная в глобальной области видимости. Начальным значением <code>undefined</code> является примитивное значение <code>undefined</code>.</p>
 
@@ -44,9 +44,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/undefined
 (function(undefined){ console.log(undefined, typeof undefined); })('foo');
 </pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Strict_equality_and_undefined" name="Strict_equality_and_undefined">Пример: строгое сравнение и <code>undefined</code></h3>
+<h3 id="Strict_equality_and_undefined">Пример: строгое сравнение и <code>undefined</code></h3>
 
 <p>Вы можете использовать <code>undefined</code> и операторы строгого равенства или неравенства для определения того, имеет ли переменная значение. В следующем коде переменная <code>x</code> не определена и инструкция <code>if</code> вычисляется в <code>true</code>.</p>
 
@@ -63,7 +63,7 @@ else {
 <p><strong>Обратите внимание:</strong> здесь используется оператор строгого равенства (идентичности) вместо простого оператора равенства, поскольку <code>x == undefined</code> также проверяет, является ли <code>x</code> равным <code>null</code>, в то время как оператор идентичности этого не делает. {{jsxref("Global_Objects/null", "null")}} не эквивалентен <code>undefined</code>. Для более подробной информации смотрите {{jsxref("Operators/Comparison_Operators", "операторы сравнения", "", 1)}}.</p>
 </div>
 
-<h3 id="Typeof_operator_and_undefined" name="Typeof_operator_and_undefined">Пример: оператор <code>typeof</code> и <code>undefined</code></h3>
+<h3 id="Typeof_operator_and_undefined">Пример: оператор <code>typeof</code> и <code>undefined</code></h3>
 
 <p>В качестве альтернативы можно использовать оператор {{jsxref("Operators/typeof", "typeof")}}:</p>
 
@@ -87,7 +87,7 @@ if (x === undefined) { // выкинет ReferenceError
 
 <p>Однако, уловки такого рода должны избегаться. JavaScript является языком со статической областью видимости, так что узнать, была ли переменная определена, можно путём просмотра, была ли она определена в охватывающем контексте. Единственным исключением являет глобальная область видимости, но глобальная область видимости привязана к глобальному объекту, так что проверка существования переменной в глобальном контексте может быть осуществлена путём проверки существования свойства <em>глобального объекта</em> (например, используя оператор {{jsxref("Operators/in", "in")}}).</p>
 
-<h3 id="Void_operator_and_undefined" name="Void_operator_and_undefined">Пример: оператор <code>void</code> и <code>undefined</code></h3>
+<h3 id="Void_operator_and_undefined">Пример: оператор <code>void</code> и <code>undefined</code></h3>
 
 <p>Третьей альтернативой является оператор {{jsxref("Operators/void", "void")}}.</p>
 
@@ -102,7 +102,7 @@ if (y === void 0) {
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -129,11 +129,11 @@ if (y === void 0) {
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.undefined")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/unescape/index.html b/files/ru/web/javascript/reference/global_objects/unescape/index.html
index 67ae79aed3..f0b83581ba 100644
--- a/files/ru/web/javascript/reference/global_objects/unescape/index.html
+++ b/files/ru/web/javascript/reference/global_objects/unescape/index.html
@@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/unescape
 </div>
 </div>
 
-<h2 id="Summary" name="Summary">Описание</h2>
+<h2 id="Summary">Описание</h2>
 
 <p>Устаревший метод <code><strong>unescape(str)</strong></code> создаёт новую строку в которой шестнадцатеричная последовательность символов вида %xx заменяется эквивалентами из кодировки ASCII. Знаки, закодированные в формате %uxxxx (знаки Юникода), заменяются знаками Юникода в шестнадцатеричной кодировке xxxx.</p>
 
@@ -17,18 +17,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/unescape
 
 <div class="note"><strong>Обратите внимание:</strong> Не рекомендуется использовать <code>unescape</code> чтобы декодировать URI, используйте <code>decodeURI</code> вместо него.</div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code>unescape(str)</code></pre>
 
-<h3 id="Parameters" name="Parameters">Parameters</h3>
+<h3 id="Parameters">Parameters</h3>
 
 <dl>
  <dt><code>str</code></dt>
  <dd>Строка которую необходимо преобразовать</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p><code>Функция unescape</code> это свойство <em>глобального объекта</em>.</p>
 
@@ -70,7 +70,7 @@ unescape("%u0107");     // "ć"
 
 <p>{{Compat}}</p>
 
-<h2 id="See_Also" name="See_Also">Смотрите также</h2>
+<h2 id="See_Also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/decodeURI", "decodeURI")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/uneval/index.html b/files/ru/web/javascript/reference/global_objects/uneval/index.html
index e68b79d3c2..5a7fb9bf59 100644
--- a/files/ru/web/javascript/reference/global_objects/uneval/index.html
+++ b/files/ru/web/javascript/reference/global_objects/uneval/index.html
@@ -12,11 +12,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/uneval
 
 <p><code style="font-style: normal; line-height: 1.5;"><strong>uneval()</strong></code><span style="line-height: 1.5;"> метод создаёт строковое представление исходного кода объекта.</span></p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">uneval(object)</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>object</code></dt>
@@ -25,7 +25,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/uneval
 
 <div class="note"><strong>Примечание:</strong> вы не получите корректное JSON-представление объекта.</div>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p><code>uneval()</code> является функцией высшего порядка и не связана с любым объектом.</p>
 
@@ -45,7 +45,7 @@ var foo = eval(a);
 foo(); // возвращает "привет"
 </pre>
 
-<h2 id="See_also" name="See_also">Технические характеристики</h2>
+<h2 id="See_also">Технические характеристики</h2>
 
 <p>Не является частью какой-либо спецификации.</p>
 
@@ -59,7 +59,7 @@ foo(); // возвращает "привет"
 
 <div id="compat-mobile"> </div>
 
-<h2 id="See_Also" name="See_Also">Смотрите также</h2>
+<h2 id="See_Also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Global_Objects/eval", "eval()")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/urierror/index.html b/files/ru/web/javascript/reference/global_objects/urierror/index.html
index 892e182606..a820d5e185 100644
--- a/files/ru/web/javascript/reference/global_objects/urierror/index.html
+++ b/files/ru/web/javascript/reference/global_objects/urierror/index.html
@@ -11,13 +11,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/URIError
 ---
 <div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 <p>Объект <code><strong>URIError</strong></code> представляет ошибку, возникающую при неправильном использовании глобальных функций обработки URI.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 <pre class="syntaxbox"><code>new URIError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 <dl>
  <dt><code>message</code></dt>
  <dd>Необязательный параметр. Человеко-читаемое описание ошибки.</dd>
@@ -27,29 +27,29 @@ translation_of: Web/JavaScript/Reference/Global_Objects/URIError
  <dd>Необязательный параметр. Номер строки кода, вызвавшей исключение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 <p>Исключение <code>URIError</code> выбрасывается при передаче некорректного URI в глобальные функции обработки URI.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 <dl>
  <dt>{{jsxref("URIError.prototype")}}</dt>
  <dd>Позволяет добавлять свойства в объект <code>URIError</code>.</dd>
 </dl>
 
-<h2 id="Methods" name="Methods">Методы</h2>
+<h2 id="Methods">Методы</h2>
 <p>Глобальный объект <code>URIError</code> не содержит собственных методов, однако, он наследует некоторые методы из цепочки прототипов.</p>
 
-<h2 id="URIError_instances" name="URIError_instances">Экземпляры объекта <code>URIError</code></h2>
+<h2 id="URIError_instances">Экземпляры объекта <code>URIError</code></h2>
 
-<h3 id="Properties_of_URIError_instances" name="Properties_of_URIError_instances">Свойства</h3>
+<h3 id="Properties_of_URIError_instances">Свойства</h3>
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/URIError/prototype', 'Properties')}}</div>
 
-<h3 id="Methods_of_URIError_instances" name="Methods_of_URIError_instances">Методы</h3>
+<h3 id="Methods_of_URIError_instances">Методы</h3>
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/URIError/prototype', 'Methods')}}</div>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Catch_an_URIError" name="Example:_Catch_an_URIError">Пример: перехват исключения <code>URIError</code></h3>
+<h3 id="Example:_Catch_an_URIError">Пример: перехват исключения <code>URIError</code></h3>
 <pre class="brush: js">try {
   decodeURIComponent('%');
 } catch (e) {
@@ -63,7 +63,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/URIError
 }
 </pre>
 
-<h3 id="Example:_Create_an_URIError" name="Example:_Create_an_URIError">Пример: возбуждение исключения <code>URIError</code></h3>
+<h3 id="Example:_Create_an_URIError">Пример: возбуждение исключения <code>URIError</code></h3>
 <pre class="brush: js">try {
   throw new URIError('Привет', 'someFile.js', 10);
 } catch (e) {
@@ -77,7 +77,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/URIError
 }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -103,10 +103,10 @@ translation_of: Web/JavaScript/Reference/Global_Objects/URIError
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Error")}}</li>
  <li>{{jsxref("URIError.prototype")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/weakmap/index.html b/files/ru/web/javascript/reference/global_objects/weakmap/index.html
index c849670ad7..9b1f77b853 100644
--- a/files/ru/web/javascript/reference/global_objects/weakmap/index.html
+++ b/files/ru/web/javascript/reference/global_objects/weakmap/index.html
@@ -9,19 +9,19 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap
 
 <p>Объект <strong><code>WeakMap</code></strong> — коллекция пар ключ-значение. В качестве ключей могут быть использованы только объекты, а значения могут быть произвольных типов.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox notranslate"><code>new WeakMap([iterable])
 </code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>iterable</code></dt>
  <dd>Может быть массивом или любым другим итерируемым объектом, элементы которого являются парами ключ-значение (массивы из двух элементов). Каждая пара ключ-значение будет добавлена во вновь созданный экземпляр <code>WeakMap</code>. <code>Null</code> обрабатывается как <code>undefined</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Ключами WeakMap могут быть только объекты. {{Glossary("Primitive", "Примитивы")}} в качестве ключей не допускаются (т.е. {{jsxref("Symbol")}} не может быть ключом <code>WeakMap</code>).</p>
 
@@ -35,7 +35,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap
 
 <p>Из-за того, что ссылки являются слабыми, ключи <code>WeakMap</code> не перечисляемы (то есть нет метода, который возвращает список ключей). Иначе список бы зависел от состояния сбора мусора, представляя индетерминизм. Если вы хотите иметь список ключей, вам следует поддерживать его самостоятельно.</p>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt><code>WeakMap.length</code></dt>
@@ -44,7 +44,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap
  <dd>Представляет прототип конструктора <code>WeakMap</code>. Позволяет добавлять свойства всем объектам типа <code>WeakMap</code>.</dd>
 </dl>
 
-<h2 id="Boolean_instances" name="Boolean_instances">Экземпляры <code>WeakMap</code></h2>
+<h2 id="Boolean_instances">Экземпляры <code>WeakMap</code></h2>
 
 <p>Все экземпляры <code>WeakMap</code> унаследованы от {{jsxref("WeakMap.prototype")}}.</p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/weakset/add/index.html b/files/ru/web/javascript/reference/global_objects/weakset/add/index.html
index 3534fb4d59..3821c72058 100644
--- a/files/ru/web/javascript/reference/global_objects/weakset/add/index.html
+++ b/files/ru/web/javascript/reference/global_objects/weakset/add/index.html
@@ -13,21 +13,21 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet/add
 
 <p>Метод <code><strong>add()</strong></code> добавляет новый объект в конец объекта WeakSet.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><em>ws</em>.add(value);</code>
 </pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt>value</dt>
  <dd>Обязателен. Объект, добавляемый в WeakSet.</dd>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:Using_the_add_method" name="Example:Using_the_add_method">Использование метода add</h3>
+<h3 id="Example:Using_the_add_method">Использование метода add</h3>
 
 <pre class="brush: js">var ws = new WeakSet();
 
@@ -40,7 +40,7 @@ ws.add(1);
 // результат в Chrome: "TypeError: Invalid value used in weak set"
 // результат в Firefox: "TypeError: 1 is not a non-null object" </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -62,13 +62,13 @@ ws.add(1);
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.WeakSet.add")}}</p>
 
 <div id="compat-mobile"> </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("WeakSet")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/weakset/delete/index.html b/files/ru/web/javascript/reference/global_objects/weakset/delete/index.html
index 762331dca2..70948e467a 100644
--- a/files/ru/web/javascript/reference/global_objects/weakset/delete/index.html
+++ b/files/ru/web/javascript/reference/global_objects/weakset/delete/index.html
@@ -13,11 +13,11 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet/delete
 
 <p>Метод <code><strong>delete()</strong></code> удаляет указанный элемент из объекта <code>WeakSet</code>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><em>ws</em>.delete(value);</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt>value</dt>
@@ -28,9 +28,9 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet/delete
 
 <p>Если объект был успешно удалён, возвращается true, иначе false.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:Testing_size_of_all_array_elements" name="Example:Testing_size_of_all_array_elements">Использование метода <code>delete</code> </h3>
+<h3 id="Example:Testing_size_of_all_array_elements">Использование метода <code>delete</code> </h3>
 
 <pre class="brush: js">var ws = new WeakSet();
 var obj = {};
@@ -43,7 +43,7 @@ ws.delete(window); // Вернёт true.  Объект успешно удалё
 ws.has(window);    // Вернёт false. Объект window был удалён из WeakSet.
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -65,11 +65,11 @@ ws.has(window);    // Вернёт false. Объект window был удалё
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("WeakSet")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/weakset/has/index.html b/files/ru/web/javascript/reference/global_objects/weakset/has/index.html
index d8a3f3b1e5..275c3b75d3 100644
--- a/files/ru/web/javascript/reference/global_objects/weakset/has/index.html
+++ b/files/ru/web/javascript/reference/global_objects/weakset/has/index.html
@@ -13,27 +13,27 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet/has
 
 <p>Метод <code><strong>has()</strong></code> определяет, содержит ли WeakSet определённый элемент, возвращая в зависимости от этого true или false. </p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"><code><em>ws</em>.has(value);</code></pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt>value</dt>
  <dd>Обязателен. Искомый объект.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <dl>
  <dt>Boolean</dt>
  <dd>Если объект был найден в WeakSet вернёт true, иначе false.</dd>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:Using_the_has_method" name="Example:Using_the_has_method">Использование метода <code>has</code> </h3>
+<h3 id="Example:Using_the_has_method">Использование метода <code>has</code> </h3>
 
 <pre class="brush: js">var ws = new WeakSet();
 var obj = {};
@@ -43,7 +43,7 @@ mySet.has(window);  // вернёт true
 mySet.has(obj);     // вернёт false
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -65,11 +65,11 @@ mySet.has(obj);     // вернёт false
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("WeakSet")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/weakset/index.html b/files/ru/web/javascript/reference/global_objects/weakset/index.html
index b4660283a8..50cd27975a 100644
--- a/files/ru/web/javascript/reference/global_objects/weakset/index.html
+++ b/files/ru/web/javascript/reference/global_objects/weakset/index.html
@@ -11,18 +11,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet
 
 <p>Объект <strong><code>WeakSet</code></strong> - коллекция, элементами которой могут быть только <em>объекты. </em>Ссылки на эти объекты в WeakSet являются слабыми. Каждый объект может быть добавлен в WeakSet только один раз.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox"> new WeakSet([iterable]);</pre>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt>iterable</dt>
  <dd>При передаче <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Statements/for...of">итерируемого объекта</a>, все его элементы будут добавлены в новый WeakSet. <code>Null</code> обрабатывается как <code>undefined</code>.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Объекты <code>WeakSet </code>представляют собой коллекции объектов. Каждый объект в WeakSet встречается только один раз, что обеспечивает его уникальность в рамках коллекции WeakSet.</p>
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet
  <li>Ссылки на объекты в WeakSet являются слабыми: если на объект, хранимый в WeakSet нет ни одной внешней ссылки, то сборщик мусора удалит этот объект. Также это означает, что WeakSet <strong>не итерируем, </strong>так как нет возможности получить список текущих хранимых в WeakSet объектов.  </li>
 </ul>
 
-<h2 id="Properties" name="Properties">Свойства</h2>
+<h2 id="Properties">Свойства</h2>
 
 <dl>
  <dt><code>WeakSet.length</code></dt>
@@ -46,17 +46,17 @@ translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet
 
 <p>Все экземпляры класса <code>WeakSet</code> унаследованы от {{jsxref("WeakSet.prototype")}}.</p>
 
-<h3 id="Properties_2" name="Properties_2">Свойства</h3>
+<h3 id="Properties_2">Свойства</h3>
 
 <p>{{page('ru/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype','Properties')}}</p>
 
-<h3 id="Methods" name="Methods">Методы</h3>
+<h3 id="Methods">Методы</h3>
 
 <p>{{page('ru/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype','Methods')}}</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:Using_the_WeakSet_object" name="Example:Using_the_WeakSet_object">Использование объекта <code>WeakSet</code> </h3>
+<h3 id="Example:Using_the_WeakSet_object">Использование объекта <code>WeakSet</code> </h3>
 
 <pre class="brush: js">var ws = new WeakSet();
 var obj = {};
@@ -72,7 +72,7 @@ ws.delete(window); // удаляет window из WeakSet
 ws.has(window);    // false, window был удалён
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -94,13 +94,13 @@ ws.has(window);    // false, window был удалён
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.builtins.WeakSet")}}</p>
 
 <div id="compat-mobile"> </div>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Map")}}</li>
diff --git a/files/ru/web/javascript/reference/global_objects/webassembly/compile/index.html b/files/ru/web/javascript/reference/global_objects/webassembly/compile/index.html
index 5613995d7d..e3f7b2ec91 100644
--- a/files/ru/web/javascript/reference/global_objects/webassembly/compile/index.html
+++ b/files/ru/web/javascript/reference/global_objects/webassembly/compile/index.html
@@ -66,7 +66,7 @@ fetch('simple.wasm').then(response =&gt;
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузером</h2>
+<h2 id="Browser_compatibility">Совместимость с браузером</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.WebAssembly.compile")}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html b/files/ru/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html
index f79cea280e..330b847cdd 100644
--- a/files/ru/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html
+++ b/files/ru/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html
@@ -62,7 +62,7 @@ WebAssembly.compileStreaming(fetch('simple.wasm'))
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузером</h2>
+<h2 id="Browser_compatibility">Совместимость с браузером</h2>
 
 <div>
 <p>{{Compat("javascript.builtins.WebAssembly.compileStreaming")}}</p>
diff --git a/files/ru/web/javascript/reference/global_objects/webassembly/index.html b/files/ru/web/javascript/reference/global_objects/webassembly/index.html
index fcbbb643e0..f28faf6e5d 100644
--- a/files/ru/web/javascript/reference/global_objects/webassembly/index.html
+++ b/files/ru/web/javascript/reference/global_objects/webassembly/index.html
@@ -92,7 +92,7 @@ fetch('simple.wasm').then(response =&gt;
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Поддержка браузерами</h2>
+<h2 id="Browser_compatibility">Поддержка браузерами</h2>
 
 <p>{{Compat}}</p>
 
diff --git a/files/ru/web/javascript/reference/global_objects/webassembly/table/index.html b/files/ru/web/javascript/reference/global_objects/webassembly/table/index.html
index 23fab50edb..a49c3df78d 100644
--- a/files/ru/web/javascript/reference/global_objects/webassembly/table/index.html
+++ b/files/ru/web/javascript/reference/global_objects/webassembly/table/index.html
@@ -87,7 +87,7 @@ console.log(tbl.get(1));  // "null"</pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <div>
 
diff --git a/files/ru/web/javascript/reference/index.html b/files/ru/web/javascript/reference/index.html
index f498c81725..c2449a20d1 100644
--- a/files/ru/web/javascript/reference/index.html
+++ b/files/ru/web/javascript/reference/index.html
@@ -9,25 +9,25 @@ translation_of: Web/JavaScript/Reference
 
 <p>Эта часть раздела MDN по JavaScript служит хранилищем фактов о языке JavaScript. Более подробную информацию об этом справочнике можно получить <a href="/ru/docs/Web/JavaScript/Reference/About">здесь</a>.</p>
 
-<h2 id="Global_Objects" name="Global_Objects">Глобальные объекты</h2>
+<h2 id="Global_Objects">Глобальные объекты</h2>
 
 <p>Эта глава описывает все <a href="/ru/docs/Web/JavaScript/Reference/Global_Objects">стандартные встроенные объекты JavaScript</a> вместе с их методами и свойствами.</p>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects', 'Standard objects (by category)')}}</div>
 
-<h2 id="Statements" name="Statements">Инструкции</h2>
+<h2 id="Statements">Инструкции</h2>
 
 <p>Эта глава описывает все <a href="/ru/docs/Web/JavaScript/Reference/Statements">инструкции и объявления JavaScript</a>.</p>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Statements', 'Statements_and_declarations_by_category')}}</div>
 
-<h2 id="Expressions_and_operators" name="Expressions_and_operators">Выражения и операторы</h2>
+<h2 id="Expressions_and_operators">Выражения и операторы</h2>
 
 <p>Эта глава описывает все <a href="/ru/docs/Web/JavaScript/Reference/Operators">выражения и операторы JavaScript</a>.</p>
 
 <div>{{page('/ru/docs/Web/JavaScript/Reference/Operators', 'Expressions_and_operators_by_category')}}</div>
 
-<h2 id="Functions" name="Functions">Функции</h2>
+<h2 id="Functions">Функции</h2>
 
 <p>Эта глава описывает, как работать с <a href="/ru/docs/Web/JavaScript/Reference/Functions">функциями JavaScript</a> для разработки ваших приложений.</p>
 
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference
  <li><a href="/ru/docs/Web/JavaScript/Reference/Functions/rest_parameters">Остаточные параметры</a></li>
 </ul>
 
-<h2 id="Additional_reference_pages" name="Additional_reference_pages">Дополнительные справочные страницы</h2>
+<h2 id="Additional_reference_pages">Дополнительные справочные страницы</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Reference/Lexical_grammar">Лексическая грамматика</a></li>
diff --git a/files/ru/web/javascript/reference/lexical_grammar/index.html b/files/ru/web/javascript/reference/lexical_grammar/index.html
index ac86ccd94b..15de5b43e1 100644
--- a/files/ru/web/javascript/reference/lexical_grammar/index.html
+++ b/files/ru/web/javascript/reference/lexical_grammar/index.html
@@ -231,7 +231,7 @@ console.log("Hello world");
 
 <p>Для определения JavaScript интерпретатора используйте только <code>#!</code> . В любых других случаях используйте <code>//</code> (или многострочный комментарий).</p>
 
-<h2 id="Ключевые_слова"><a id="Keywords" name="Keywords"></a>Ключевые слова</h2>
+<h2 id="Ключевые_слова"><a id="Keywords"></a>Ключевые слова</h2>
 
 <h3 id="Зарезервированные_ключевые_слова_в_ECMAScript_2015">Зарезервированные ключевые слова в ECMAScript 2015</h3>
 
@@ -323,9 +323,9 @@ console.log("Hello world");
 
 <p>К тому же, литералы <code>null</code>, <code>true</code>, и <code>false</code> зарезервированы в ECMAScript для их обычной функциональности.</p>
 
-<h3 id="Reserved_word_usage" name="Reserved_word_usage"></h3>
+<h3 id="Reserved_word_usage"></h3>
 
-<h3 id="Reserved_word_usage" name="Reserved_word_usage">Использование зарезервированных слов</h3>
+<h3 id="Reserved_word_usage">Использование зарезервированных слов</h3>
 
 <p>Зарезервированные слова действительно применяются только к идентификаторам<strong> (vs. IdentifierNames)</strong>. Как описано в <a href="http://es5.github.com/#A.1">es5.github.com/#A.1</a>, это все имена IdentifierNames, которые не исключают зарезервированных слов.</p>
 
diff --git a/files/ru/web/javascript/reference/operators/delete/index.html b/files/ru/web/javascript/reference/operators/delete/index.html
index 531cd80999..38a909e150 100644
--- a/files/ru/web/javascript/reference/operators/delete/index.html
+++ b/files/ru/web/javascript/reference/operators/delete/index.html
@@ -5,7 +5,7 @@ translation_of: Web/JavaScript/Reference/Operators/delete
 ---
 <div>{{jsSidebar("Operators")}}</div>
 
-<h2 id="Summary" name="Summary">Аннотация</h2>
+<h2 id="Summary">Аннотация</h2>
 
 <p>Оператор <code>delete</code> удаляет свойство из объекта.</p>
 
@@ -27,7 +27,7 @@ translation_of: Web/JavaScript/Reference/Operators/delete
  </tbody>
 </table>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <p><code>delete <em>выражение</em></code></p>
 
@@ -42,7 +42,7 @@ delete <em>property</em> // удаляет свойства глобальног
 
 <p>Если результат вычисления <em>выражения</em> не является свойством (объекта), <code>delete</code> ничего не делает.</p>
 
-<h3 id="Parameters" name="Parameters">Параметры</h3>
+<h3 id="Parameters">Параметры</h3>
 
 <dl>
  <dt><code>object</code></dt>
@@ -53,11 +53,11 @@ delete <em>property</em> // удаляет свойства глобальног
  <dd>Целое число, представляющее собой индекс массива, который должен быть удалён.</dd>
 </dl>
 
-<h3 id="Returns" name="Returns">Возвращаемое значение</h3>
+<h3 id="Returns">Возвращаемое значение</h3>
 
 <p>Возвращает false, только если свойство существует в самом объекте, а не в его прототипах, и не может быть удалено. Во всех остальных случаях возвращает true.</p>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если оператор <code>delete</code> успешно выполняет удаление, он полностью удаляет свойство из объекта. Однако, если свойство с таким же именем существует в цепочке прототипов, объект унаследует это свойство из прототипа.</p>
 
@@ -93,7 +93,7 @@ alert(foo.bar);           // выводит 42, свойство все ещё 
 delete Foo.prototype.bar; // удаляет свойство из прототипа
 alert(foo.bar);           // выводит "undefined", свойство больше не наследуется</pre>
 
-<h3 id="Deleting_array_elements" name="Deleting_array_elements">Удаление элементов массива</h3>
+<h3 id="Deleting_array_elements">Удаление элементов массива</h3>
 
 <p>Когда с помощью оператора delete удаляется элемент массива, длина массива не меняется. Например, если вы удалите a{{ mediawiki.external(3) }}, a{{ mediawiki.external(4) }} по прежнему a{{ mediawiki.external(4) }}, а a{{ mediawiki.external(3) }} не определено. Так будет даже если вы удалите последний элемент массива (<code>delete a{{ mediawiki.external('a.length-1') }}</code>).</p>
 
@@ -120,7 +120,7 @@ if (3 in trees) {
 
 <p>Поэтому, если вы хотите симулировать упорядоченный ассоциативный массив в кроссбраузерной среде, вам придётся либо использовать два отдельных массива (один для ключей и один для значений), либо построить массив из объектов с одним свойством и так далее.</p>
 
-<h2 id="Specification" name="Specification">Внешние ссылки</h2>
+<h2 id="Specification">Внешние ссылки</h2>
 
 <ul>
  <li>Глубокий <a href="http://perfectionkills.com/understanding-delete/">анализ оператора delete</a></li>
diff --git a/files/ru/web/javascript/reference/operators/function/index.html b/files/ru/web/javascript/reference/operators/function/index.html
index fe6bf05dac..ed68eff169 100644
--- a/files/ru/web/javascript/reference/operators/function/index.html
+++ b/files/ru/web/javascript/reference/operators/function/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/function
 
 <p>Вы можете также определять функции используя конструктор {{jsxref("Function")}} и {{jsxref("Statements/function", "объявление функции")}}.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">var myFunction = function [<em>name</em>]([<em>param1</em>[, <em>param2[</em>, ..., <em>paramN</em>]]]) {
    <em>statements</em>
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Operators/function
 
 <p>С версии ES2015 можно также использовать <a href="/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions">стрелочные функции</a>.</p>
 
-<h3 id="Parameters" name="Parameters"><a id="Параметры" name="Параметры">Параметры</a></h3>
+<h3 id="Parameters" name="Parameters"><a id="Параметры">Параметры</a></h3>
 
 <dl>
  <dt><code>name</code></dt>
@@ -32,11 +32,11 @@ translation_of: Web/JavaScript/Reference/Operators/function
  <dd>Инструкции, составляющие тело функции.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Функциональное выражение и <a href="/ru/docs/Web/JavaScript/Reference/Statements/function">объявление функции</a> очень похожи и имеют почти одинаковый синтаксис. Главным отличием между ними является <em>имя функции,</em> которое в случае функциональных выражений может быть опущено для создания <em>анонимных</em> функций. Функциональное выражение может быть использовано для создания самовызывающейся функции {{Glossary("IIFE")}} (Immediately Invoked Function Expression), которая исполняется сразу же после того, как она была определена. Более подробная информация изложена в разделе о <a href="/ru/docs/Web/JavaScript/Reference/Functions">функциях</a>.</p>
 
-<h3 id="Поднятие_функциональных_выражений_2"><a id="Поднятие_функциональных_выражений" name="Поднятие_функциональных_выражений">Поднятие функциональных выражений</a></h3>
+<h3 id="Поднятие_функциональных_выражений_2"><a id="Поднятие_функциональных_выражений">Поднятие функциональных выражений</a></h3>
 
 <p>Функциональные выражения в JavaScript не {{Glossary("поднятие", "поднимаются (hoisting)")}}, в отличие от {{jsxref("Statements/function", "объявленных функций", "#Поднимание_объявленной_функции")}}. Вы не можете использовать функциональные выражения прежде, чем вы их определили.</p>
 
@@ -48,7 +48,7 @@ var notHoisted = function() {
    console.log('bar');
 };</pre>
 
-<h3 id="Именованное_функциональное_выражение"><a id="№Именованное функциональное выражение" name="№Именованное функциональное выражение">Именованное функциональное выражение</a></h3>
+<h3 id="Именованное_функциональное_выражение"><a id="№Именованное функциональное выражение">Именованное функциональное выражение</a></h3>
 
 <p>Если вы хотите сослаться на текущую функцию внутри тела этой функции, вам необходимо создать именованное функциональное выражение. Данное имя будет локальным только для тела функции (её области видимости). Кроме того, это позволяет избежать использования нестандартного свойства {{jsxref("arguments.callee")}}.</p>
 
@@ -80,7 +80,7 @@ console.log(foo === foo2); // true
 console.log(typeof baz); // undefined
 console.log(bar === baz); // false (errors because baz == undefined)</pre>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <p>Следующий пример демонстрирует создание безымянной (анонимной) функции и присвоение её переменной <code>x</code>. Функция возвращает квадрат переданного значения:</p>
 
@@ -131,7 +131,7 @@ console.log(bar === baz); // false (errors because baz == undefined)</pre>
 
 <p>{{Compat("javascript.operators.function")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li>
diff --git a/files/ru/web/javascript/reference/operators/index.html b/files/ru/web/javascript/reference/operators/index.html
index 0ce141a4cb..7be569c74b 100644
--- a/files/ru/web/javascript/reference/operators/index.html
+++ b/files/ru/web/javascript/reference/operators/index.html
@@ -10,11 +10,11 @@ translation_of: Web/JavaScript/Reference/Operators
 
 <p>Эта глава описывает все операторы, выражения и ключевые слова языка JavaScript.</p>
 
-<h2 id="Expressions_and_operators_by_category" name="Expressions_and_operators_by_category">Выражения и операторы по категориям</h2>
+<h2 id="Expressions_and_operators_by_category">Выражения и операторы по категориям</h2>
 
 <p>Алфавитный список смотрите в боковой панели слева.</p>
 
-<h3 id="Primary_expressions" name="Primary_expressions">Первичные выражения</h3>
+<h3 id="Primary_expressions">Первичные выражения</h3>
 
 <p>Базовые ключевые слова и общие выражения в JavaScript.</p>
 
@@ -45,7 +45,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор группировки.</dd>
 </dl>
 
-<h3 id="Left-hand-side_expressions" name="Left-hand-side_expressions">Левосторонние выражения</h3>
+<h3 id="Left-hand-side_expressions">Левосторонние выражения</h3>
 
 <p>Значения слева являются назначением присваивания.</p>
 
@@ -63,7 +63,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор распространения позволяет развернуть выражение в местах, где ожидается несколько аргументов (при вызове функций) или несколько элементов (при создании литералов массива).</dd>
 </dl>
 
-<h3 id="Increment_and_decrement" name="Increment_and_decrement">Инкремент и декремент</h3>
+<h3 id="Increment_and_decrement">Инкремент и декремент</h3>
 
 <p>Операторы постфиксного/префиксного инкремента и декремента.</p>
 
@@ -78,7 +78,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор префиксного декремента.</dd>
 </dl>
 
-<h3 id="Unary_operators" name="Unary_operators">Унарные операторы</h3>
+<h3 id="Unary_operators">Унарные операторы</h3>
 
 <p>Унарные операции — это операции с одним операндом.</p>
 
@@ -99,7 +99,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор логического НЕ.</dd>
 </dl>
 
-<h3 id="Arithmetic_operators" name="Arithmetic_operators">Арифметические операторы</h3>
+<h3 id="Arithmetic_operators">Арифметические операторы</h3>
 
 <p>Арифметические операторы своими операндами принимают числовые значения (литералы или переменные) и возвращают одно числовое значение.</p>
 
@@ -118,7 +118,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор возведения в степень.</dd>
 </dl>
 
-<h3 id="Relational_operators" name="Relational_operators">Реляционные операторы</h3>
+<h3 id="Relational_operators">Реляционные операторы</h3>
 
 <p>Реляционные операторы (операторы отношения) сравнивают свои операнды и возвращают значение типа {{jsxref("Global_Objects/Boolean", "Boolean")}}, зависящее от того, был ли результат сравнения истинным или ложным.</p>
 
@@ -141,7 +141,7 @@ translation_of: Web/JavaScript/Reference/Operators
 <p><strong>Заметьте: =&gt;</strong> это не оператор. Это нотация для <a href="/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Стрелочных функций</a>.</p>
 </div>
 
-<h3 id="Equality_operators" name="Equality_operators">Операторы равенства</h3>
+<h3 id="Equality_operators">Операторы равенства</h3>
 
 <p>Результат вычисления оператора равенства всегда имеет тип {{jsxref("Global_Objects/Boolean", "Boolean")}} и значение, зависящее от того, был ли результат проверки истинным или ложным.</p>
 
@@ -156,7 +156,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор проверки на неидентичность.</dd>
 </dl>
 
-<h3 id="Bitwise_shift_operators" name="Bitwise_shift_operators">Операторы побитового сдвига</h3>
+<h3 id="Bitwise_shift_operators">Операторы побитового сдвига</h3>
 
 <p>Операции для сдвига всех битов операнда.</p>
 
@@ -169,7 +169,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор беззнакового побитового сдвига вправо.</dd>
 </dl>
 
-<h3 id="Binary_bitwise_operators" name="Binary_bitwise_operators">Бинарные побитовые операторы</h3>
+<h3 id="Binary_bitwise_operators">Бинарные побитовые операторы</h3>
 
 <p>Побитовые операторы трактуют свои операнды как набор из 32 битов (нулей и единиц) и возвращают стандартные числовые значения JavaScript.</p>
 
@@ -182,7 +182,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор побитового ИСКЛЮЧАЮЩЕГО ИЛИ.</dd>
 </dl>
 
-<h3 id="Binary_logical_operators" name="Binary_logical_operators">Бинарные логические операторы</h3>
+<h3 id="Binary_logical_operators">Бинарные логические операторы</h3>
 
 <p>Логические операторы обычно используются вместе с булевыми (логическими) значениями и в сочетании с ними они возвращают булево значение.</p>
 
@@ -193,14 +193,14 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Оператор логического ИЛИ.</dd>
 </dl>
 
-<h3 id="Conditional_(ternary)_operator" name="Conditional_(ternary)_operator">Условный (тернарный) оператор</h3>
+<h3 id="Conditional_(ternary)_operator">Условный (тернарный) оператор</h3>
 
 <dl>
  <dt>{{jsxref("Operators/Conditional_Operator", "(условие ? ifTrue : ifFalse)")}}</dt>
  <dd>Условный оператор возвращает одно значение из двух данных в зависимости от логического значения условия.</dd>
 </dl>
 
-<h3 id="Assignment_operators" name="Assignment_operators">Операторы присваивания</h3>
+<h3 id="Assignment_operators">Операторы присваивания</h3>
 
 <p>Операторы присваивания присваивают значение своему левому операнду, зависящее от значения их правого операнда.</p>
 
@@ -234,7 +234,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Деструктурирующее присваивание позволяет вам присваивать свойства массива или объекта переменным с использованием синтаксиса, очень похожего на объявление литералов массива или объекта.</dd>
 </dl>
 
-<h3 id="Comma_operator" name="Comma_operator">Оператор запятая</h3>
+<h3 id="Comma_operator">Оператор запятая</h3>
 
 <dl>
  <dt>{{jsxref("Operators/Comma_Operator", ",")}}</dt>
@@ -252,7 +252,7 @@ translation_of: Web/JavaScript/Reference/Operators
  <dd>Упрощённый синтаксис создания генератора.</dd>
 </dl>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <tbody>
@@ -284,7 +284,7 @@ translation_of: Web/JavaScript/Reference/Operators
  </tbody>
 </table>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Operators/Operator_Precedence", "Приоритеты операторов", "", 1)}}</li>
diff --git a/files/ru/web/javascript/reference/operators/operator_precedence/index.html b/files/ru/web/javascript/reference/operators/operator_precedence/index.html
index 2362cdc038..81ac025747 100644
--- a/files/ru/web/javascript/reference/operators/operator_precedence/index.html
+++ b/files/ru/web/javascript/reference/operators/operator_precedence/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence
 
 
 
-<h2 id="Associativity" name="Associativity">Ассоциативность</h2>
+<h2 id="Associativity">Ассоциативность</h2>
 
 <p>Ассоциативность определяет порядок, в котором обрабатываются операторы с одинаковым приоритетом. Например, рассмотрим выражение:</p>
 
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence
 // вернёт false, потому что 3 &gt; 2 возвращает true, в свою очередь true &gt; 1 вернёт false
 // Добавление скобок значительно повышает читаемость выражения: (3 &gt; 2) &gt; 1</code></pre>
 
-<h2 id="Table" name="Table">Таблица</h2>
+<h2 id="Table">Таблица</h2>
 
 <p>Данная таблица упорядочена с самого высокого приоритета (20) до самого низкого (1).</p>
 
diff --git a/files/ru/web/javascript/reference/operators/this/index.html b/files/ru/web/javascript/reference/operators/this/index.html
index 33aa7207b2..bc57ae4b98 100644
--- a/files/ru/web/javascript/reference/operators/this/index.html
+++ b/files/ru/web/javascript/reference/operators/this/index.html
@@ -403,7 +403,7 @@ for (var i = 0; i &lt; elements.length; i++) {
 
 <p>{{Compat("javascript.operators.this")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode">Строгий режим</a></li>
diff --git a/files/ru/web/javascript/reference/operators/void/index.html b/files/ru/web/javascript/reference/operators/void/index.html
index d60b2aebb4..94d318bacb 100644
--- a/files/ru/web/javascript/reference/operators/void/index.html
+++ b/files/ru/web/javascript/reference/operators/void/index.html
@@ -95,7 +95,7 @@ translation_of: Web/JavaScript/Reference/Operators/void
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><code><a href="/ru/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code></li>
diff --git a/files/ru/web/javascript/reference/operators/yield/index.html b/files/ru/web/javascript/reference/operators/yield/index.html
index 82866c30ed..d30b1bbce5 100644
--- a/files/ru/web/javascript/reference/operators/yield/index.html
+++ b/files/ru/web/javascript/reference/operators/yield/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield
 
 <p>{{EmbedInteractiveExample("pages/js/expressions-yield.html")}}</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox language-html notranslate"> [<em>rv</em>] = <strong>yield</strong> [[выражение]];</pre>
 
@@ -35,7 +35,7 @@ translation_of: Web/JavaScript/Reference/Operators/yield
 
 <p>Во время остановки на операторе <code>yield</code>, выполнение кода в функции-генераторе не возобновится, пока не будет вызван метод <code>next()</code> возвращаемого функцией <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Generator">объекта-генератора</a>. Это предоставляет непосредственный контроль за выполнением генератора и возвратом его значений.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <p>Следующий фрагмент кода содержит определение функции-генератора и вспомогательной функции:</p>
 
@@ -54,7 +54,7 @@ console.log(iterator.next()); // { value:2, done:false }
 console.log(iterator.next()); // { value:undefined, done:true }
 </pre>
 
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 
 <table class="standard-table">
  <thead>
@@ -78,11 +78,11 @@ console.log(iterator.next()); // { value:undefined, done:true }
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat("javascript.operators.yield")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Guide/The_Iterator_protocol">Итераторы</a></li>
diff --git a/files/ru/web/javascript/reference/statements/const/index.html b/files/ru/web/javascript/reference/statements/const/index.html
index 82508b0ef8..8f858cc515 100644
--- a/files/ru/web/javascript/reference/statements/const/index.html
+++ b/files/ru/web/javascript/reference/statements/const/index.html
@@ -25,7 +25,7 @@ translation_of: Web/JavaScript/Reference/Statements/const
  <dd>Значение константы. Может быть любым из тех типов, которые могут быть для переменных, включая функцию.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Это объявление создаёт константу, чья область действия может быть как глобальной, так и локальной внутри блока, в котором она объявлена. Глобальные константы не становятся свойствами объекта window, в отличие от <code><a href="/ru/docs/Web/JavaScript/Reference/Statements/var">var</a></code>-переменных. Инициализация константы обязательна; необходимо указать значение одновременно с объявлением (смысл в том, что потом это значение изменить уже нельзя).</p>
 
@@ -35,7 +35,7 @@ translation_of: Web/JavaScript/Reference/Statements/const
 
 <p>Имена констант не могут совпадать с именами функций или переменных той же области видимости.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
 <p>Ниже описаны примеры, демонстрирующие поведение <strong><code>const</code>. </strong>Попробуйте их выполнить в <a href="/ru/docs/Tools/Черновик">простом JavaScript-редакторе</a> или в консоли браузера.</p>
 
diff --git a/files/ru/web/javascript/reference/statements/continue/index.html b/files/ru/web/javascript/reference/statements/continue/index.html
index 0f3e3afb86..0514a9c284 100644
--- a/files/ru/web/javascript/reference/statements/continue/index.html
+++ b/files/ru/web/javascript/reference/statements/continue/index.html
@@ -12,7 +12,7 @@ translation_of: Web/JavaScript/Reference/Statements/continue
 
 <p>Инструкция <strong>continue</strong> прерывает выполнение текущей итерации текущего или отмеченного цикла, и продолжает его выполнение на следующей итерации.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">continue [ label ];</pre>
 
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Statements/continue
  <dd>Идентификатор, являющийся меткой (<code>label</code>) инструкции.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>По сравнению с инструкцией {{jsxref("Statements/break", "break")}}, <code>continue</code> прерывает выполнение цикла не полностью, вместо этого:</p>
 
@@ -35,9 +35,9 @@ translation_of: Web/JavaScript/Reference/Statements/continue
 
 <p>Инструкция <code>continue</code> может использоваться вместе с необязательной меткой, которая будет начинать следующую итерацию отмеченного цикла, а не текущего. В этом случае, <code>continue</code> должен находиться внутри отмеченного блока, который соответствует метке.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_continue_with_while" name="Example:_Using_continue_with_while">Использование <code>continue</code> с циклом <code>while</code></h3>
+<h3 id="Example_Using_continue_with_while">Использование <code>continue</code> с циклом <code>while</code></h3>
 
 <p>Пример показывает использование цикла {{jsxref("Statements/while", "while")}} вместе с инструкцией <code>continue, которая выполняется, когда</code> <code>i</code> станет равно 3-м. Таким образом, <code>n</code> принимает значения 1, 3, 7 и 12.</p>
 
@@ -144,7 +144,7 @@ checkiandj: while (i &lt; 4) {
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li>{{jsxref("Statements/break", "break")}}</li>
diff --git a/files/ru/web/javascript/reference/statements/for...of/index.html b/files/ru/web/javascript/reference/statements/for...of/index.html
index cd4447e59f..9792ae86ec 100644
--- a/files/ru/web/javascript/reference/statements/for...of/index.html
+++ b/files/ru/web/javascript/reference/statements/for...of/index.html
@@ -10,7 +10,7 @@ translation_of: Web/JavaScript/Reference/Statements/for...of
 ---
 <div>{{jsSidebar("Statements")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p>Оператор <code>for...of</code> выполняет цикл обхода <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/iterable">итерируемых объектов</a> (включая {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, объект <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">аргументов</a> и подобных), вызывая на каждом шаге итерации операторы для каждого значения из различных свойств объекта.</p>
 
diff --git a/files/ru/web/javascript/reference/statements/for/index.html b/files/ru/web/javascript/reference/statements/for/index.html
index f669a1bfad..3f8c1b6ea9 100644
--- a/files/ru/web/javascript/reference/statements/for/index.html
+++ b/files/ru/web/javascript/reference/statements/for/index.html
@@ -7,11 +7,11 @@ translation_of: Web/JavaScript/Reference/Statements/for
 <div>{{jsSidebar("Statements")}}</div>
 </div>
 
-<h2 id="Summary" name="Summary">Введение</h2>
+<h2 id="Summary">Введение</h2>
 
 <p>Выражение<strong> for</strong> создаёт цикл, состоящий из 3 необязательных выражений в круглых скобках, разделённых точками с запятой.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">for ([<em>инициализация</em>]; [<em>условие</em>]; [<em>финальное выражение</em>])<em>выражение</em>
 </pre>
@@ -27,9 +27,9 @@ translation_of: Web/JavaScript/Reference/Statements/for
  <dd>Выражение, которое выполняется, когда условие цикла истинно. Чтоб выполнить множество выражений в цикле, используйте <a href="/ru/docs/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">блок</a> (<code>{ ... }</code>) для группировки этих выражений. Чтобы не выполнять никакого выражения в цикле, используйте <a href="/ru/docs/Web/JavaScript/Reference/Statements/Empty">пустое выражение</a> (<code>;</code>).</dd>
 </dl>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example.3A_Using_for" name="Example.3A_Using_for">Использование <code>for</code></h3>
+<h3 id="Example.3A_Using_for">Использование <code>for</code></h3>
 
 <p>Следующий цикл <code>for</code> начинается объявлением переменной <code>i </code>и задания ей значения <code>0</code>. Затем проверяет, что <code>i</code> меньше девяти, выполняет выражения внутри цикла и увеличивает <code>i</code> на 1 каждый раз.</p>
 
@@ -71,7 +71,7 @@ for (;;) {
 }
 </pre>
 
-<h3 id="Example.3A_Using_for_without_the_statement_section" name="Example.3A_Using_for_without_the_statement_section">Использование <code>for</code> без блока выражений</h3>
+<h3 id="Example.3A_Using_for_without_the_statement_section">Использование <code>for</code> без блока выражений</h3>
 
 <p>Следующий цикл <code>for</code> вычисляет смещение позиции узла в секции <em>[финальное выражение]</em>, и, следовательно, не требует использования выражения внутри цикла или <code><a href="/ru/docs/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">блока</a></code>, <a href="/ru/docs/Web/JavaScript/Reference/Statements/Empty">пустое выражение</a> используется вместо этого.</p>
 
@@ -133,7 +133,7 @@ showOffsetPos("content");
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also">Также можете просмотреть</h2>
+<h2 id="See_also">Также можете просмотреть</h2>
 
 <ul>
  <li>{{jsxref("Statements/break", "break")}}</li>
diff --git a/files/ru/web/javascript/reference/statements/function_star_/index.html b/files/ru/web/javascript/reference/statements/function_star_/index.html
index d13aa3f645..ba3e199375 100644
--- a/files/ru/web/javascript/reference/statements/function_star_/index.html
+++ b/files/ru/web/javascript/reference/statements/function_star_/index.html
@@ -11,11 +11,11 @@ translation_of: Web/JavaScript/Reference/Statements/function*
 ---
 <div>{{jsSidebar("Statements")}}</div>
 
-<h2 id="Summary" name="Summary">Сводка</h2>
+<h2 id="Summary">Сводка</h2>
 
 <p><code><strong>function*</strong></code> (ключевое слово <code>function</code> со звёздочкой) определяет <em>функцию-генератор</em>.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre>function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { <em>statements</em> }
 </pre>
@@ -132,7 +132,7 @@ console.log(gen.next()); // { value: undefined, done: true }</pre>
  </tbody>
 </table>
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2>
+<h2 id="Browser_compatibility">Совместимость с браузерами</h2>
 
 <p>{{Compat}}</p>
 
diff --git a/files/ru/web/javascript/reference/statements/index.html b/files/ru/web/javascript/reference/statements/index.html
index 11c44fdf08..8e57e7dfd5 100644
--- a/files/ru/web/javascript/reference/statements/index.html
+++ b/files/ru/web/javascript/reference/statements/index.html
@@ -10,9 +10,9 @@ translation_of: Web/JavaScript/Reference/Statements
 <div>
  {{jsSidebar("Statements")}}</div>
 <p>Приложения на JavaScript состоят из инструкций с соответствующим синтаксисом. Одна инструкция может состоять из нескольких строк. На одной строке может находиться несколько инструкций, если они разделены точкой с запятой. Они являются не ключевыми словами, а группами ключевых слов.</p>
-<h2 id="Statements_and_declarations_by_category" name="Statements_and_declarations_by_category">Инструкции и объявления по категориям</h2>
+<h2 id="Statements_and_declarations_by_category">Инструкции и объявления по категориям</h2>
 <p>Алфавитный список смотрите в боковой панели слева.</p>
-<h3 id="Control_flow" name="Control_flow">Управление потоком выполнения</h3>
+<h3 id="Control_flow">Управление потоком выполнения</h3>
 <dl>
  <dt>
   {{jsxref("Statements/block", "Блок", "", 1)}}</dt>
@@ -47,7 +47,7 @@ translation_of: Web/JavaScript/Reference/Statements
  <dd>
   Помечает блок инструкций и определяет реакцию на возникновение исключения внутри помеченного блока инструкций.</dd>
 </dl>
-<h3 id="Declarations" name="Declarations">Объявления</h3>
+<h3 id="Declarations">Объявления</h3>
 <dl>
  <dt>
   {{jsxref("Statements/var", "var")}}</dt>
@@ -62,7 +62,7 @@ translation_of: Web/JavaScript/Reference/Statements
  <dd>
   Объявляет именованную константу только для чтения.</dd>
 </dl>
-<h3 id="Functions" name="Functions">Функции</h3>
+<h3 id="Functions">Функции</h3>
 <dl>
  <dt>
   {{jsxref("Statements/function", "function")}}</dt>
@@ -81,7 +81,7 @@ translation_of: Web/JavaScript/Reference/Statements
  <dd>
   Смотрите статьи <a href="/ru/docs/Web/JavaScript/New_in_JavaScript/1.7">Что нового в JavaScript 1.7</a> и <a href="/ru/docs/JavaScript/Guide/Iterators_and_Generators">Итераторы и генераторы</a>.</dd>
 </dl>
-<h3 id="Iterations" name="Iterations">Итерации</h3>
+<h3 id="Iterations">Итерации</h3>
 <dl>
  <dt>
   {{jsxref("Statements/do...while", "do...while")}}</dt>
@@ -108,7 +108,7 @@ translation_of: Web/JavaScript/Reference/Statements
  <dd>
   Создаёт цикл, выполняющий указанную инструкцию до тех пор, пока проверяющее условие равно <code>true</code>. Условие вычисляется перед выполнением инструкции..</dd>
 </dl>
-<h3 id="Others" name="Others">Прочее</h3>
+<h3 id="Others">Прочее</h3>
 <dl>
  <dt>
   {{jsxref("Statements/debugger", "debugger")}}</dt>
@@ -131,7 +131,7 @@ translation_of: Web/JavaScript/Reference/Statements
  <dd>
   Расширяет цепочку областей видимости инструкции.</dd>
 </dl>
-<h2 id="Specifications" name="Specifications">Спецификации</h2>
+<h2 id="Specifications">Спецификации</h2>
 <table class="standard-table">
  <tbody>
   <tr>
@@ -156,7 +156,7 @@ translation_of: Web/JavaScript/Reference/Statements
   </tr>
  </tbody>
 </table>
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 <ul>
  <li>{{jsxref("Operators", "Операторы", "", 1)}}</li>
 </ul>
diff --git a/files/ru/web/javascript/reference/statements/switch/index.html b/files/ru/web/javascript/reference/statements/switch/index.html
index 5d0ead0986..e4ef4fcfc1 100644
--- a/files/ru/web/javascript/reference/statements/switch/index.html
+++ b/files/ru/web/javascript/reference/statements/switch/index.html
@@ -12,7 +12,7 @@ translation_of: Web/JavaScript/Reference/Statements/switch
 
 <p><strong>Инструкция switch</strong> сравнивает выражение со случаями, перечисленными <font face="Courier New, Andale Mono, monospace">внутри неё</font>, а затем выполняет соответствующие инструкции.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">switch (expression) {
   case value1:
@@ -43,7 +43,7 @@ translation_of: Web/JavaScript/Reference/Statements/switch
  <dd>Инструкции, выполняемые если <code>expression</code> не соответствует ни одному случаю.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Если выражение соответствует какому-то случаю, то выполняются инструкции этого случая. Если несколько случаев соответствуют значению, только первый случай будет использован.</p>
 
@@ -51,9 +51,9 @@ translation_of: Web/JavaScript/Reference/Statements/switch
 
 <p>Опциональная инструкция <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/break" title="JavaScript/Reference/Statements/break">break</a></code> выполняет выход из блока <code>switch</code>. Она может располагаться в каждом из случаев, но не является обязательной. Если её нет, то выполняется следующая инструкция из блока <code>switch</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example_Using_switch" name="Example:_Using_switch">Пример: Использование <code>switch</code></h3>
+<h3 id="Example_Using_switch">Пример: Использование <code>switch</code></h3>
 
 <p>В этом примере, если <code>expr</code> равно "Bananas", программа находит случай "Bananas" и выполняет соответствующие инструкции. При выполнении инструкции <code>break</code>, выполнение продолжится за пределами <code>switch</code>. Если бы <code>break</code> не было, то выполнились бы инструкции случая "Cherries".</p>
 
@@ -81,7 +81,7 @@ translation_of: Web/JavaScript/Reference/Statements/switch
 console.log("Is there anything else you'd like?");
 </pre>
 
-<h3 id="What_happens_if_I_forgot_a_break" name="What_happens_if_I_forgot_a_break">Пример: Что случится, если не использовать break?</h3>
+<h3 id="What_happens_if_I_forgot_a_break">Пример: Что случится, если не использовать break?</h3>
 
 <p>Если вы не использовали инструкцию <code>break</code>, то будут выполнены инструкции следующего случая. И проверка на соответствие выражению не будет выполняться.</p>
 
@@ -103,7 +103,7 @@ switch (foo) {
         console.log('default');
 }</pre>
 
-<h3 id="Methods_for_Multi-criteria_Case" name="Methods_for_Multi-criteria_Case">Пример: Использование нескольких значений для одного случая</h3>
+<h3 id="Methods_for_Multi-criteria_Case">Пример: Использование нескольких значений для одного случая</h3>
 
 <p>Если вы хотите использовать один набор инструкций для соответствия нескольким случаям, можно использовать два способа. Первый способ является рекомендуемым, а второй - скорее трюком. Оба способа вызовут предупреждение с текстом "yes", если значение <code>foo</code> равно 0, 1, 2 или 3.</p>
 
@@ -177,7 +177,7 @@ switch (true) { // Постоянное значение true вместо foo
 
 <p>{{Compat("javascript.statements.switch")}}</p>
 
-<h2 id="See_also" name="See_also">Смотрите также</h2>
+<h2 id="See_also">Смотрите также</h2>
 
 <ul>
  <li><a href="/ru/docs/Web/JavaScript/Reference/Statements/if...else" lang="ru"><code>if...else</code></a></li>
diff --git a/files/ru/web/javascript/reference/statements/throw/index.html b/files/ru/web/javascript/reference/statements/throw/index.html
index 4fee8bf57e..8b29ddb702 100644
--- a/files/ru/web/javascript/reference/statements/throw/index.html
+++ b/files/ru/web/javascript/reference/statements/throw/index.html
@@ -12,7 +12,7 @@ translation_of: Web/JavaScript/Reference/Statements/throw
 
 <p><strong>Инструкция <code>throw</code></strong> позволяет генерировать исключения, определяемые пользователем. При этом выполнение текущей функции будет остановлено (инструкции после <code>throw</code> не будут выполнены), и управление будет передано в первый блок <a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>catch</code></a> в стеке вызовов. Если <code>catch</code> блоков среди вызванных функций нет, выполнение программы будет остановлено.</p>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">throw <em>выражение</em>; </pre>
 
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Statements/throw
  <dd>Определяемое пользователем исключение.</dd>
 </dl>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Используйте инструкцию throw для генерирования исключения. Когда вы генерируете исключение (throw), <em>выражение</em> задаёт значение исключения. Каждое из следующих throw создаёт исключение:</p>
 
@@ -31,9 +31,9 @@ throw true;     // генерирует исключение, значением
 
 <p>Также стоит отметить, что на инструкцию <code>throw</code> влияет <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">автоматическая вставка точки с запятой (ASI)</a>. Поэтому не допускаются разрывы строк между инструкцией <code>throw</code> и <code>выражением</code>.</p>
 
-<h2 id="Examples" name="Examples">Примеры</h2>
+<h2 id="Examples">Примеры</h2>
 
-<h3 id="Example:_Throw_an_object" name="Example:_Throw_an_object">Пример: Генерирование объекта в качестве исключения</h3>
+<h3 id="Example:_Throw_an_object">Пример: Генерирование объекта в качестве исключения</h3>
 
 <p>Можно указать объект в качестве исключения. Затем можно получить ссылку на этот объект и доступ ко всем его свойствам в блоке catch. Следующий пример создаёт объект ошибки, который имеет тип UserException, и используется для генерации исключения.</p>
 
@@ -62,7 +62,7 @@ try {
 }
 </pre>
 
-<h3 id="Example:_Another_example_of_throwing_an_object" name="Example:_Another_example_of_throwing_an_object">Пример: Другой пример генерации объекта в виде исключения</h3>
+<h3 id="Example:_Another_example_of_throwing_an_object">Пример: Другой пример генерации объекта в виде исключения</h3>
 
 <p>Следующий пример проверяет, является ли строка, переданная в функцию, почтовым индексом США. Если индекс имеет недопустимый формат, будет сгенерировано исключение посредством создания объекта, имеющего тип <code>ZipCodeFormatException</code>.</p>
 
@@ -132,7 +132,7 @@ d = verifyZipCode("95060");       // вернёт 95060
 e = verifyZipCode("95060 1234");  // вернёт 95060 1234
 </pre>
 
-<h3 id="Example:_Rethrow_an_exception" name="Example:_Rethrow_an_exception">Пример: Повторный выброс исключения</h3>
+<h3 id="Example:_Rethrow_an_exception">Пример: Повторный выброс исключения</h3>
 
 <p>Можно использовать throw для повторного выброса исключения после того, как оно было поймано. В следующем примере ловится исключение с числовым значением и делается повторный выброс, если его значение больше 50.  Повторно выброшенное исключение передаётся далее в вызывающую функцию или до верхнего уровня, который видит пользователь.</p>
 
@@ -185,7 +185,7 @@ e = verifyZipCode("95060 1234");  // вернёт 95060 1234
 
 <p>{{Compat}}</p>
 
-<h2 id="See_also" name="See_also"><span class="short_text" id="result_box" lang="ru"><span class="hps">Смотрите также</span></span></h2>
+<h2 id="See_also"><span class="short_text" id="result_box" lang="ru"><span class="hps">Смотрите также</span></span></h2>
 
 <ul>
  <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>try...catch</code></a></li>
diff --git a/files/ru/web/javascript/reference/template_literals/index.html b/files/ru/web/javascript/reference/template_literals/index.html
index d4f2e5a0ac..3345c34bbe 100644
--- a/files/ru/web/javascript/reference/template_literals/index.html
+++ b/files/ru/web/javascript/reference/template_literals/index.html
@@ -14,7 +14,7 @@ original_slug: Web/JavaScript/Reference/template_strings
 
 <div>Шаблонными литералами называются строковые литералы, допускающие использование выражений внутри. С ними вы можете использовать многострочные литералы и строковую интерполяцию. В спецификациях до ES2015 они назывались "шаблонными строками".</div>
 
-<h2 id="Syntax" name="Syntax">Синтаксис</h2>
+<h2 id="Syntax">Синтаксис</h2>
 
 <pre class="syntaxbox">`строка текста`
 
@@ -26,7 +26,7 @@ original_slug: Web/JavaScript/Reference/template_strings
 tag `строка текста ${выражение} строка текста`
 </pre>
 
-<h2 id="Description" name="Description">Описание</h2>
+<h2 id="Description">Описание</h2>
 
 <p>Шаблонные литералы заключены в обратные кавычки (` `) вместо двойных или одинарных. Они могут содержать подстановки, обозначаемые знаком доллара и фигурными скобками (<code>${выражение}</code>). Выражения в подстановках и текст между ними передаются в функцию. По умолчанию функция просто объединяет все части в строку. Если перед строкой есть выражение (здесь это <code>tag</code>), то шаблонная строка называется "теговым шаблоном". В этом случае, теговое выражение (обычно функция) вызывается с обработанным шаблонным литералом, который вы можете изменить перед выводом. Для экранирования обратной кавычки в шаблонных литералах указывается обратный слеш <strong>\</strong>.</p>
 
-- 
cgit v1.2.3-54-g00ecf