Paano i-align ang text sa Word sa magkabilang gilid, ilang paraan.
Ang Word ang pinakasikat na editor. Nagbibigay ito sa mga user ng malaking bilang ng mga posibilidad, na ginagawang mas simple at mas madali ang kanilang trabaho. Upang magamit ang mga ito, pag-aralan nang mabuti ang programa, alamin ang lahat ng mga lihim nito.
Gusto mo bang malaman kung paano patuloy na kumita ng pera online mula sa 500 rubles sa isang araw?
I-download ang aking libreng libro
=>>
Kapag nagtatrabaho sa teksto, ang espesyal na pansin ay binabayaran sa lokasyon nito. Kadalasan, awtomatikong nagtatakda ang editor ng kaliwang pagkakahanay. Maaari mong baguhin ang lokasyon ng teksto gamit ang mga espesyal na pindutan.
Ang ilang mga gumagamit, nang hindi nalalaman ito, ay sumusubok na gumawa ng paglalagay ng teksto kahit na gamit ang mga puwang. Ang pamamaraang ito ay hindi maginhawa at tumatagal ng maraming oras. Bukod dito, halos imposible na ihanay nang tama ang teksto "sa pamamagitan ng mata". Kung nagsusulat ka ng tesis kung saan ang pag-format ay gumaganap ng isang mahalagang papel, maaaring hindi ito tanggapin.
Paano i-align ang teksto sa Word sa magkabilang gilid, eksakto
Upang matiyak na ang teksto ay pantay sa magkabilang gilid, gumamit ng katwiran.
Tab ng Tahanan
Maaari mong ihanay ang teksto sa magkabilang gilid gamit ang pangunahing menu ng editor. Mayroong ilang mga pindutan sa seksyon ng Talata. Upang matiyak na ang teksto ay nakaposisyon nang pantay-pantay sa parehong kaliwa at kanang mga gilid, piliin ito at i-click ang button na "magkasya sa lapad". Ihahanay ang teksto sa pamamagitan ng paglikha ng karagdagang espasyo.
Menu ng konteksto
May isa pang paraan upang gawin ang teksto kahit sa magkabilang panig. Pagkatapos piliin ang teksto, gamitin ang kanang pindutan ng mouse, i-click, at sa lalabas na menu ng konteksto, i-click ang "Talata". Lilitaw ang isang window kung saan kailangan mong piliin ang alignment na "lapad".
Mga susi
May mga espesyal na keyboard shortcut na nagbibigay-daan sa iyong maglagay ng text kung kinakailangan. Upang gawing pantay ang teksto sa magkabilang panig, piliin ang teksto at pindutin ang "CNTR + J" key sa parehong oras. Kung hindi gumagana ang mga susi, binago ang iyong mga setting.
Mga karagdagang opsyon
Maaaring hindi sapat ang pag-click sa mga espesyal na button para i-align nang tama ang text. Maaaring kailanganin mong i-hyphenate ang mga salita at magsagawa ng karagdagang pagsusuri.
Hyphenation
May mga kaso kung kailan, kapag nakahanay, ang mga pagitan sa pagitan ng mga salita ay tumataas nang labis na ang teksto ay mukhang katawa-tawa. Pigilan ito sa pamamagitan ng paggawa ng hyphenation.
Buksan ang seksyong "Page Layout", mag-click sa "Hyphenation" at piliin ang "Auto".
Sinusuri ang kawastuhan ng pagpaparehistro
Maaari mong suriin anumang oras kung ang iyong gawa ay na-format nang tama at itama ito. Sa tab na "Home", i-click ang button. Makakakita ka ng mga dagdag na espasyo dahil sa hitsura ng malaking bilang ng mga tuldok.
Paano ihanay ang teksto sa Word sa mga gilid, buod
Ang pag-align ng text sa Word sa magkabilang gilid ay medyo simple. Simulan ang pag-aaral ng editor at gagawin mong mas madali ang iyong trabaho. Nais kong tagumpay ka sa pagkuha ng bagong kaalaman!
P.S. Nag-a-attach ako ng screenshot ng aking mga kita sa mga programang kaakibat. At ipinaaalala ko sa iyo na kahit sino ay maaaring kumita ng pera sa ganitong paraan, kahit na isang baguhan! Ang pangunahing bagay ay gawin ito nang tama, na nangangahulugang pag-aaral mula sa mga kumikita na, iyon ay, mula sa mga propesyonal sa negosyo sa Internet.
Kumuha ng listahan ng mga napatunayang Affiliate Program sa 2017 na nagbabayad ng pera!
I-download ang checklist at mahahalagang bonus nang libre
=>>
Hanggang ngayon, nakahanay lang kami ng mga elemento sa kaliwa. Mas tiyak, hindi mo at ako ang gumawa nito, at ang browser mismo ay nag-align ng mga elemento sa kaliwa bilang default. Siyempre, magiging masyadong boring na ihanay ang lahat sa kaliwa. Samakatuwid, may iba't ibang paraan upang i-center at i-align sa kanan.
Ang pagkakahanay ng mga elemento ay isang bagay na kailangan mo lang malaman kapag ginagawa ito. Ang unang bagay na kailangan mong gawin ay mag-type ng isang simpleng pahina.
Noong unang panahon may tag
Maaari kang magdagdag ng isang larawan, nakahanay din sa gitna, lumipat din tayo sa susunod na linya gamit ang tag
:
1st level heading, naka-align sa gitna
Ito ay isang tag
Upang malutas ang problemang ito, gumawa ang mga developer ng isang unibersal na paraan upang ihanay ang mga elemento HTML. Ang pamamaraan ay ang paggamit ng mga tinatawag na container, na ginawa gamit ang tag Isulat natin ang parehong ngayon HTML code, ngunit gamit ang mga lalagyan, bilang karagdagan, ihanay natin hindi sa gitna, ngunit sa kanan. Tulad ng nakikita mo, gumagana ang lahat. Ipinapayo ko sa iyo na baguhin din ang mga halaga ng katangian " ihanay" upang tingnan ang iba pang mga uri ng pagkakahanay ng nilalaman ng lalagyan. Isa pang paraan upang ihanay ang mga elemento HTML- ito ay mga talahanayan, ngunit ang paksang ito ay nararapat sa isang hiwalay na talakayan, kaya pag-uusapan natin ito sa isa sa mga sumusunod na artikulo. Sa ngayon, dapat ganito ang hitsura ng iyong page: Taos-puso, Mikhail Rusakov. P.S. Kung gusto mong malaman ang higit pa tungkol sa HTML, pagkatapos ay tingnan ang aking libreng kurso na may isang halimbawa ng paglikha ng isang website sa HTML: Ang CSS text-align property ay responsable para sa pahalang na pag-align ng text, pati na rin ang mga larawan at iba pang elemento. Ang property ay may 4 na posibleng alignment option. CSS text-align syntax Kadalasan ang mga katangiang ito ay ginagamit sa mga bloke Tandaan: I-align ang text sa kaliwa. Wasto bilang default. Выравнивание текста по левому краю Выравнивание текста по центру. Зачастую используются для заглавия статей или для вывода картинок по центру. На странице преобразуется в следующее Выравнивание текста по левому краю Выравнивание текста по правому краю. На странице преобразуется в следующее Выравнивание текста по правому краю Выравнивание текста по всей ширине. Получается, что выравнивание происходит и полевому, и по правому краю. Браузер автоматически добавляет пробелы. На странице преобразуется в следующее Выравнивание текста по ширине всей области Иногда text-align: justify;
может не работать. Это связано с наследованием и даже с работой браузера. В целом не рекомендуется использовать этот параметр. Вместо свойства text-align
можно также использовать атрибут align
, который пишется вместе с тегом. Его можно использовать у различных тегов. Например: Выравнивание текста по ширине всей области
Разница в тегах В том, что последний делает переход на новую строку (вертикальный отступ), а div не делает. В задачах вёрстки периодически возникают моменты, когда появляется необходимость выровнять какой-нибудь список по ширине экрана. При этом пункты этого списка должны выравниваться равномерно, прижимаясь своими крайними элементами к границам контейнера, а расстояние между ними должно быть одинаковым. На рисунках видно, что при разном разрешении экрана пункты всё равно продолжают выравниваться по ширине, примыкая к боковым стенкам и делая отступы между собой — равнозначными. Перед тем, как рассматривать каждое решение в отдельности, давайте немного углубимся в тонкости механизма и поразмыслим, как он работает. Этап первый
Цифрой 1
на картинке отмечены обычные инлайн-боксы, т.е. попросту текст или инлайн элементы, такие, например, как < span>
или
. Этап второй
Отсюда можно сделать вывод, что сейчас мы имеем общую сумму всех пробельных зон в строке, которая равна 116px
. Этап третий — завершающий
Итог
Наша задача состоит в том, чтобы построить решение на базе этого алгоритма. Применить, симулировать, заменить, сделать всё что угодно, главное в итоге получить то, что мы хотим. А именно — равномерно выровненные элементы в строке, боковые из которых прижаты к своим границам. Ну и конечно же расстояния (пробелы) между элементами должны быть абсолютно одинаковыми при любой ширине контейнера. Самое первое, что пришло мне на ум, это взять список из пяти пунктов, сделать 4 из них обтекаемыми, а у последнего отменить float и растянуть на всю оставшуюся ширину. Чтобы было понятнее, о чём идёт речь, привожу код.
А CSS таким Ul {
font: 14px Verdana, Geneva, sans-serif;
overflow: hidden;
}
ul li {
}
ul li.left {
width: 20%;
float: left;
}
ul li.right {
width: 20%;
float: right;
text-align: right;
}
ul li.center {
text-align: center;
}
ul li .content {
background: #E76D13;
width: 98px;
height: 98px;
display: inline-block;
text-align: left;
border: 1px solid #000;
/* эмуляция inline-block для IE6-7*/
//display: inline;
//zoom: 1;
}
Что мы собственно сделали? А сделали мы следующее. Два левых и два правых пункта мы раскидали по разным сторонам с помощью float: left и float: right соответственно, при этом назначив им по 20% ширины каждому, что в сумме дало 80% от всей ширины контейнера. Последний пункт, я решил не делать обтекаемым, так как его содержимое само по себе занимает всё оставшиеся пространство после float-блоков. И второй элемент сразу же оказался под третьим. Конечно же можно было бы поставить минимальную ширину контейнеру и такого бы не произошло, но разве можно считать это действие отговоркой или решением? Конечно же нет! Я хочу, чтобы наши пункты могли иметь любую ширину и при этом чтобы наш алгоритм идеально работал. Второй вариант напоминает первый, но только отчасти. Дело в том, что в нём мы выравниваем по левому краю только один, левый блок, а остальные находятся уже в своём, собственном контейнере. Но перейдём от слов к делу.
Если вы скажите, что в данной ситуации мы по сути имеем две разных колонки, то будете абсолютно правы. Ведь наша структура поделена на две части, левая из которых представляет из себя контейнер с одним блоком, а правая соответственно содержит в себе все остальные. Выглядит это примерно так: Левая колонка прижата к левому краю и содержит в себе самый первый, одиночный блок. Это нужно для того, чтобы правая часть прижималась вплотную с правой стороны и растягивалась на всё оставшееся место. Растяжка правой части происходит благодаря overflow: hidden , который создаёт свой контекст форматирования, т.е. по сути свой собственный, независимый контейнер. Для всех дочерних элементов этого контейнера его ширина составляет 100% и поэтому блоки внутри него мы растягиваем в соответствии с этим правилом. Четыре блока имеют ширину 25%, что в сумме даёт 100. На изображении можно увидеть, как расположены эти блоки. Видно, что строчно-блочные элементы с контентом внутри них выровнены по правому краю с помощью text-align: right , благодаря чему самый правый блок прижат к своей боковой стенке, так же как и левый. Благодаря таким "жертвам" с двумя колонками, мы получили отличный результат, и как видно из первых рисунков, при разных разрешениях, расстояние отступов между блоками остаётся абсолютно одинаковым. Это происходит за счёт равнозначных блоков в правой части. Ширина каждого из них составляет 25%, а элемента внутри них — 100px. Что и даёт равные отступы слева от каждого "кирпичика" в отдельности. Но всё же интересно узнать, что будет, если мы поменяем ширину сначала у первого, а потом и у любого блока из правой части. Давайте для начала поставим левому… ну допустим 150px. Ul li.one .content { width: 150px;}
Всё здорово! Пока работает всё та же идея с правым, самостоятельным контейнером. А теперь перенесём нашу ширину на первый блок в правой части. Эх, а вот этот эксперимент потерпел неудачу. Правый отступ у самого левого блока оказался меньше, чем все остальные. Всё легко объясняется тем, что контент первого элемента в правой части, стал больше на 50px, а так как он выровнен по правой стороне, то ширина визуально прибавилась к его левой части и соответственно стала отличаться от ширины соседних блоков. Ну и естественно поменялся отступ, который стал меньше ровно на 50px. Из всего этого можно сделать вывод, что данный метод явно лучше, чем его предшественник и то, что он имеет право на жизнь. Единственный его недостаток связан с тем, что мы не может задать разную ширину блокам, и должны придерживаться одинаковой. Так что, если у вас есть список, в котором все пункты имеют равную ширину, то вы вполне можете применять этот подход. Конечно же, нужно понимать, что без двухколоночной структуры тут не обойтись + нужна обязательная минимальная ширина у контейнера (min-width) , иначе при маленькой ширине экрана блоки будут наезжать друг на друга. Стоит отметить, что до этого момента, ни в одном примере, мы ни разу не воспользовались text-align: justify , даже не смотря на то, что именно на основе его алгоритма и строятся все наши решения. Я предлагаю нарушить эту традицию и, наконец, пустить уже в дело этого зверя. В первой части статьи мы выяснили, что text-align: justify влияет на все строки, кроме последней, а значит нужно построить наш список с учётом этого поведения, добавив в конец меню дополнительный, вспомогательный элемент. Ul {
font: 14px Verdana, Geneva, sans-serif;
text-align: justify;
}
ul li {
background: #E76D13;
width: 98px;
height: 98px;
display: inline-block;
text-align: left;
border: 1px solid #000;
/* эмуляция inline-block для IE6-7*/
//display: inline;
//zoom: 1;
}
ul li.helper {
width: 100%;
height: 0;
visibility: hidden;
}
Из кода ясно, что мы создали список с пятью основными и одним элементом — помощником. text-align: justify на главном элементе-родителе (ul
), заставляет своих потомков подчиняться своему алгоритму. Ведь, как известно, это свойство работает с текстом, а так как наши строчно-блочные (display: inline-block) пункты, по сути и являются неразрывными словами в строке, то это поведение вполне закономерно. Кстати, стоит учесть, что text-align: justify наследуемое свойство, поэтому text-align: left на ближайших потомках — необходимая мера. Этим самым мы как бы возвращаем выравнивание содержимого наших блоков в прежнее состояние. Первое, что бросается в глаза, это то, что при разной ширине наш алгоритм работает так, как и должен. При пунктах с одинаковой шириной расстояние между ними сохраняется одинаковым, что не может не радовать. Но всё таки интересно узнать, будет ли всё так же хорошо при разной ширине блоков. Назначим паре пунктам классы и проверим это. Добавим для них свои правила. First { width: 150px;}
.third { width: 200px;}
Проверяем. Я специально увеличил ширину экрана, чтобы при маленькой ширине блоки не перескакивали на другую строку, как обычные слова в тексте. Но, если посмотреть на результаты алгоритма, то он работает! Пробелы между элементами остаются равнозначными, даже не смотря на то, что у двоих из них, мы увеличили ширину. Первая проблема
— это проблема IE6-7. Не приводя скриншоты, скажу сразу, что наш метод там не работает. Пункты в этих браузерах прижаты друг к другу вплотную и не растягиваются в строке. Дело в том, что парсер IE6-7 полностью игнорирует закрывающие теги у элементов За решением данной проблемы мы отправляемся на самую высокую гору… на MSDN . Мда… найти что либо на этом сайте, представляет большую трудность. Но, всё же повозившись, некоторое время, решение было найдено ! text-justify: newspaper — свойство для увеличения или уменьшения интервалов между буквами и между словами. MSDN заявляет, что эта вещь "Самая навороченная форма выравнивания для латинского алфавита", а вот в этой статье ещё есть и дополнение, что для арабских текстов это свойство вытягивает и сами буквы. Ul {
font: 14px Verdana, Geneva, sans-serif;
text-align: justify;
/* Лекарство для IE6-7*/
text-justify: newspaper;
}
ul li {
background: #E76D13;
width: 98px;
height: 98px;
display: inline-block;
text-align: left;
border: 1px solid #000;
/* эмуляция inline-block для IE6-7*/
//display: inline;
//zoom: 1;
}
ul li.helper {
width: 100%;
height: 0;
visibility: hidden;
}
.first { width: 150px;}
.third { width: 200px;}
А вот и результат. Победа! IE6-7
были побеждены их же оружием. Здорово. Теперь во всех браузерах, начиная с IE6, наш способ работает идеально. Выходит, что MSDN не подвели и их слова подтвердились на деле. Так что text-align: justify выручил нас, поэтому берём его на заметку и переходим к решению второй проблемы. Вторая проблема
связана с непонятным отступом между низом списка и нашей строкой с элементами. В чём же дело? А дело в том, что всё вполне закономерно и этими странными отступами являются ни кто иные, как межстрочный интервал
(line-height) и размер шрифта
(font-size), которые априори присутствуют у строк и букв в тексте. Наши элементы — блочные только внутри, а строчные снаружи, поэтому они и попадают под эти правила. Ul {
font: 14px Verdana, Geneva, sans-serif;
text-align: justify;
/* Обнуляем для родителя*/
line-height: 0;
font-size: 1px; /* 1px для Opera */
/* Лекарство для IE6-7*/
text-justify: newspaper;
}
ul li {
background: #E76D13;
width: 98px;
height: 98px;
display: inline-block;
text-align: left;
border: 1px solid #000;
/* Востанавливаем у потомков, кроме последнего*/
line-height: normal;
font-size: 14px;
/* Без него в Opera будет отступ под элементами */
vertical-align: top;
/* эмуляция inline-block для IE6-7*/
//display: inline;
//zoom: 1;
}
ul li.helper {
width: 100%;
height: 0px;
visibility: hidden;
overflow: hidden;
}
.first { width: 150px;}
.third { width: 200px;}
Результат. До обнуления
После обнуления
Отлично! Всё получилось. Обнуление стилей у главного контейнера помогло нам. Единственное, что теперь стоит помнить, это то, что в связи с обнулением размера шрифта мы не сможем задать нашим пунктам шрифт в таких единицах длины, как em
, а так же % для
не принесут желаемого результата. Но, а целом, наш метод работает идеально, так что можно подводить итоги и идти дальше, ведь нам же мало одного решения, нам же нужно больше и лучше, не правда ли? Подводя промежуточные итоги, скажу, что данный подход пока что лидер среди присутствующих до сей поры решений, и что, я лично, не вижу в нём ни одного изъяна, правда, кроме… Кроме дополнительного элемента в конце строки, плюс, как мне кажется, неактуальные проблемы с % и em. Но, эти натянутые минусы, никак не могут быть причиной отказа от представленного варианта. Так что смотрим результат и идём дальше. В предыдущем варианте для нашей цели мы использовали дополнительный элемент, ставя его в конец списка. С одной стороны, конечно же, этот маневр принес свои плоды, но с другой… но с другой стороны создал некие неудобства. Например, при динамическом добавлении пунктов, вспомогательный блок будет только мешать, да и потом этот "хвост" портит нашу структуру, засоряя её. В этом варианте, я предлагаю избавиться от него, не испортив при этом решение. Ul {
font: 14px Verdana, Geneva, sans-serif;
text-align: justify;
/* Обнуляем для родителя*/
line-height: 0;
font-size: 1px; /* 1px для Opera */
/* Лекарство для IE6-7*/
text-justify: newspaper;
zoom:1;
}
ul:after {
width: 100%;
height: 0;
visibility: hidden;
overflow: hidden;
content: "";
display: inline-block;
}
ul li {
background: #E76D13;
width: 98px;
height: 98px;
display: inline-block;
text-align: left;
border: 1px solid #000;
/* Востанавливаем у потомков, кроме последнего*/
line-height: normal;
font-size: 14px;
/* Без него в Opera будет отступ под элементами */
vertical-align: top;
/* эмуляция inline-block для IE6-7*/
//display: inline;
//zoom: 1;
}
В данной ситуации мы воспользовались псевдоэлементом:after , который сгенерировали в конце нашего списка. Выставив ему те же значения, что и бывшему, вспомогательному блоку, мы, по сути сделали тоже самое, но не залезая в разметку. Т.е. создали такой же, пустой, но полезный элемент. И вот результаты. Здорово! Трюк с псевдоэлементом сработал. Теперь наша разметка чистая, аккуратная и без лишнего "мусора". Нам удалось избавиться от дополнительного элемента, полностью заменив его сгенерированным. Как видно из скриншота, IE6-7 полностью игнорирует пробелы между блоков, прижимая их вплотную друг к другу. Даже не смотря на то, что мы уже задействовали тяжёлую артиллерию в виде text-justify: newspaper . Почему же это происходит? Давайте выясним. Как же быть? Есть ли выход?
Ul {
font: 14px Verdana, Geneva, sans-serif;
text-align: justify;
/* Обнуляем для родителя*/
line-height: 0;
font-size: 1px; /* 1px для Opera */
/* Лекарство для IE6-7*/
text-justify: newspaper;
zoom:1;
/* Включаем в работу последнюю строку*/
text-align-last: justify;
}
ul:after {
width: 100%;
height: 0px;
visibility: hidden;
overflow: hidden;
content: "";
display: inline-block;
}
ul li {
background: #E76D13;
width: 98px;
height: 98px;
display: inline-block;
text-align: left;
border: 1px solid #000;
/* Востанавливаем у потомков, кроме последнего*/
line-height: normal;
font-size: 14px;
/* Без него в Opera будет отступ под элементами */
vertical-align: top;
/* эмуляция inline-block для IE6-7*/
//display: inline;
//zoom: 1;
}
Да! У нас получилось. text-align-last: justify сделал то, что от него требовалось, и сделал это на 5 баллов. Алгоритм включился в работу, в нашей последней и единственной строке. Так что празднуем победу и подводим итоги этого способа. Ну что ж, я доволен. Доволен тем, что нам удалось найти действительно достойное решение. Причём не просто найти, а разобраться во всём и довести его до абсолютной кроссбраузерности, затратив минимум кода и не засоряя разметки. На лицо одни плюсы, а что же с минусами? Как по мне, так их попросту — нет. По сравнению с предыдущим вариантом, в этом мы только улучшили результаты. Разве что… Единственное, что теперь стоит помнить, это то, что в связи с обнулением размера шрифта мы не сможем задать нашим пунктам шрифт в таких единицах длины, как em, а так же % для Но, опять же, эти "минусы" с большой натяжкой можно назвать таковыми. Их неактуальность говорить о том, что про них можно практически забыть, если это не принципиально. В этой статье мы рассматривали не только методы, которые могут помочь нам в равномерном выравнивании блоков по ширине, но и так же очень подробно разобрали механизмы работы всех свойств и деталей, участвующих в процессе. Всё это важно для понимания вещей, с которыми мы имеем дело. Поэтому я настоятельно рекомендую перечитать статью, и не один раз. В данной статье я расскажу, как поместить блок div по центру
. Способов существует множество, но далеко не все позволяют сделать именно то, что требуется. Я приведу в пример самые лучшие и простые способы. Вообще, есть дюжина способов как правильно выровнять div блок по центру, каждый вебмастер использует свой любимый\наиболее удобный способ. Но тем не менее, есть несколько основных, наиболее популярных и универсальных способа. И конечно-же, валидные по всем современным стандартам. И да, стоит сразу сказать, что данные способы могут не работать в ie6, или чём-то подобном. Я даже не обращаю внимание на данный браузер, не смотря на то, сколько людей им пользуется. Пора бы уже отучивать пользоваться старьём. Итак, что мы имеем? Очень эффективный метод, который к тому-же позволяет выровнять отступы сверху и снизу. В чём фишка метода? Всё просто до безумия. Мы имеем блок с определённой шириной (в пикселях, либо процентах), которому с помощью свойства «auto» задаём одинаковый отступ справа и слева, в итоге получаем div-блок по центру. Первое значение (0 в примере) — это отступ сверху и снизу. К примеру, для выравнивания сверху пишем: Margin:10px auto;
Для выравнивания сверху и снизу: Margin:10px auto 5px;
На мой взгляд — это самый лучший способ выровнять блоки по центру
. К тому-же он полностью валидный. Если блок имеет ширину в процентах, то мы можем выровнять div по центру
применяя равные отступы, чтобы добить полную ширину до 100%. Кто не понял, покажу на примере, так проще: Имеем блок шириной 50%, чтобы выровнять его по центру, нам нужно боковые отступы сделать по 25% справа и слева соответственно. Смотрим код: Не напрягаясь, получаем блок по центру, выровненный банальной математикой (50 + 25 + 25) 🙂 Данный способ посоветовал в комментариях sman
. Как я упоминал в начале статьи, способов выровнять блок по центру огромное множество. Каждый выбирCgает тот, который ему больше по душе. Жду комментариев и новых способов 🙂 Способ Виктор
в комментариях: Ни один метод не решает проблему с float внутри блока, если ширина блока заведомо не известна (например, меню). В таких случаях использую дополнительный блок, который обворачивает выравниваемый блок. Стиль примерно так:
1st level heading, naka-align sa gitna
1st level heading, naka-align sa kanan
...text-align: sentro | bigyang-katwiran | kaliwa | tama | magmana;
...
Mayroon ding vertical-align na property, na kumokontrol sa vertical alignment.Paano gawin ang pag-align ng teksto sa html
Halimbawa Blg. 1.
Пример №2. Выравнивание текста и картинки по центру
Пример №3. Выравнивание текста по правому краю
Пример №4. Выравнивание текста по ширине всей области
...
...
Чтобы было более понятно, о чём идёт речь, приведу пару изображений.
В этой статье я хочу подробнее разобрать разные варианты решения данной задачи, а также рассмотреть все плохие и хорошие стороны этих методов.Как это работает?
По сути мы должны получить то, что делает text-align: justify с текстом. Так как поведение наших блоков уж очень напоминает результат выравнивания слов в строке с помощью именно этого свойства. Немного углубившись в процесс работы text-align: justify , мы можем наблюдать следующий алгоритм.
Сначала в строке текста ищутся минимальные, неразрывные "кирпичики". Это могут быть отдельные слова в тексте, картинки, инлайн-блоки, инлайн-таблицы и т.д. В общем всё то, что в случае необходимости перенесется на новую строку как единое целое.
Под цифрой 2
у нас находится элемент строчно-блочного уровня, т.е inline-block . Как можно заменить, алгоритм отступов внутри него рассчитывается заново. Причина в том, что внутри себя inline-block генерирует свой собственный контекст форматирования. Что нельзя сказать об обычном inline элементе, внутри которого межсловное расстояние распределялось бы, по общему, внешнему алгоритму.
Цифрой 3
отмечена обычная картинка. Так же, как и остальные, она является строчным, целым элементом.
Для нашей строки все эти вещи представляют из себя отдельные сущности, неразделимые слова, единые целые. А расстояния между ними как раз и регулируется нашим механизмом, под названием text-align: justify
*
Последняя же строка не попадает в поле зрения justify , так как он работает только для целиком заполненных строк, а в последней строке пробелы всегда остаются своего обычного размера.
Вторым этапом алгоритм высчитывает ширины всех наших "кирпичей" в строке, складывает их, а полученный результат отнимает от общей ширины самой строки.
Третьим и последним этапом алгоритма будет деление полученной цифры (в данном случае 116) на количество пробелов в строке (в нашей строке их 7). Из полученного результата (16.571) вычитается ширина одного пробела и уже это значение добавляется к каждому из них. Что в итоге даёт равномерное распределение отступов во всей строке.
Как мы можем видеть, алгоритм работы text-align: justify не так уж и сложен на самом деле, всё вроде бы понятно и логично. Я уверен, что каждый из нас, решая подобную задачу, высчитывал бы результат, по точно такому же сценарию. Сложность заключается только в том, чтобы написать хорошее, красивое, а главное качественное решение, затратив при этом минимум материала. Ведь существует много подводных камней, в виде последней (не попадающей под алгоритм) строки, которую нужно прятать, или каким либо образом выравнивать точно так же, как и все остальные. Ну и естественно нельзя забывать об интерпретации кода, таких браузеров, как Opera, IE6-7, которые любят преподносить неожиданные сюрпризы.Наша задача
Вариант 1
Структура будет таковой
Соответственно для такого решения пришлось пожертвовать разметкой, а точнее дополнительными классами + внутренними контейнерами для контента. Как вы могли заметить, каждый из этих контейнеров я сделал строчно-блочным, повесив на них display: inline-block , благодаря чему мой контент смог выравниваться в любую сторону с помощью text-align у родителя. Эти "жертвы" с большой натяжкой можно было бы отнести к хорошему решению, если бы не некоторые, весомые "но".
Во-первых, как видно из скриншотов, равномерные отступы имеют только боковые пункты, а между средним и остальными есть явная разница. И чем больше ширина контейнера, тем заметнее это становится.
Во-вторых, ради эксперимента, я назначил второму пункту ширину, равную 200px.
Ну и в-третьих, все эти дополнительные обёртки, классы, рассчитывание кол-ва элементов, их ширины, а так же и ширины контейнера ставят абсолютную точку на этот варианте, заставляя нас идти дальше, в поисках настоящего решения.
Выкладываю этот вариант на всеобщий суд и перехожу к следующему способу.Вариант 2
ul {
font: 14px Verdana, Geneva, sans-serif;
overflow: hidden;
}
ul li.one {
float: left;
}
ul li.two {
overflow: hidden;
float: none;
}
ul li.two li {
width: 25%;
text-align: right;
float: left;
/* Лекарство для IE6-7*/
//width: 24.9%;
}
ul li .content {
background: #E76D13;
width: 98px;
height: 98px;
display: inline-block;
text-align: left;
border: 1px solid #000;
/* эмуляция inline-block для IE6-7*/
//display: inline;
//zoom: 1;
}
На данный момент можно смело заявить, что при фиксированной ширине блоков у нас получилось именно то, что мы хотели.
*
Кстати, у себя в примере, в правом контейнере я использовал четыре блока по 25%, и их общая сумма составила 100%. Поэтому нужно помнить, что если блоков будет, ну скажем 6, то ширина каждого из них, будет равна 16.666, что говорит о дробных процентах, которые, например, не поддерживаются в браузере Opera.
Соответственно результат в этом случае будет немного не тем, чем вам хотелось бы.Вариант 3 — text-align: justify
В первой части статьи я упоминал, что наш алгоритм не распространяется на последнюю строку, а работает со всеми строками кроме неё. Поэтому я добавил в конец ещё один элемент, пустышку, и растянул его на 100% по ширине, тем самым заставив его растянуться на самую последнюю строчку в списке. С помощью нехитрых приёмов (height: 0 , visibility: hidden) я, можно сказать, почти что спрятал его. Почему я сказал "Почти что"? Об этом чуть позже, для начала давайте взглянем на то, что у нас вышло.
Т.е. можно с лёгкостью заявлять, что этот метод, с дополнительным элементом в конце — даёт отличный результат и, если ограничить экран по ширине, то его применение на практике нас не разочарует.
Так, ну а теперь, пожалуй, настало время подлить ложку дёгтя.
Во-первых, как вы могли заметить, во всех примерах я перечислял все браузеры, кроме IE6-7.
Во-вторых, опять же, как вы, наверное могли видеть на рисунках, внизу нашей строки, где дополнительный элемент, есть большие, непонятные отступы.
Давайте разбираться по порядку.
Отлично, нам как раз нужно что-нибудь наподобие. Давайте-ка проверим их слова на деле.
Как быть? А легко! Мы можем повесить на контейнер обнуление этих стилей, а уже у потомков восстановить их в прежнее состояние. Пробуем.
Вариант 4 — Избавление от дополнительного элемента
В CSS2.1 уже давно есть такие вещи, как псевдоэлементы . Это такие абстрактные сущности, которые могут быть сгенерированы каким нибудь элементом и вставлены в его начало или конец. Почему бы не заменить таким псевдоэлементом наш лишний вспомогательный блок? Давайте попробуем…
Но, как обычно, не обошлось без IE6-7 приключений. К сожалению, в браузерах IE6-7 нет поддержки:after и:before . А если нет поддержки, следовательно и нет никаких вспомогательных блоков, а значит и растягивать попросту нечего. Поэтому картина в этих браузерах такова.
Оказывается всё дело в том, что text-justify: newspaper лишь даёт возможность
растягивать наши буквы (inline-block), но не команду
. Проще говоря, он рассказывает строке, как бы он хотел, чтобы она была растянута, а text-align: justify является растягивающей силой. Т.е. text-align: justify отвечает за растяжение строки, а text-justify: newspaper лишь уточняет, как именно это растяжение будет происходить.
Да, но тогда возникает вопрос: "Если есть и возможность и сила, которая может её исполнить, то почему же тогда ничего не происходит?". Ответ кроется в самом свойстве text-align: justify . Если вы помните, в обсуждении его алгоритма я упомянул о том, что он не распространяется на последнюю строку в тексте. А так как мы убрали вспомогательный элемент в конце списка, то соответственно наша строка (пускай даже она одна) с блоками — стала уже последней, и следовательно алгоритм отказался с ней работать.
К счастью мир не без добрых людей, и один такой добрый человек направил меня на верный путь. Оказывается решение было у меня под носом. text-align-last — свойство, которое включает алгоритм text-align: justify в самой последней строке текста, если к ней применён этот самый text-align: justify . Проще говоря, когда мы применяем к тексту обычный text-align: justify , то, видя это, text-align-last указывает первому на то, что он поступает плохо и что ему придётся теперь работать и в последней строчке тоже.
Самое интересное, что это свойство считается ориентированным именно на Internet Explorer, в котором он нам как раз и нужен). В общем пора переходить к делу.
Так что в целом решение отличное, надёжное и действительно качественное.Резюме
Я безумно рад, что нам удалось добиться своей цели и найти достойное и качественное решение.Способ 1. Самый крутой
margin:0 auto;
Способ 2. Процентный
Способ 3. Смешанный
Способ 4. Использование дополнительного блока
#dop-block {
position: relative;
float: right;
right: 50%;
}
#block {
position: relative;
float: left;
left: 50%;
}
Рекомендуем
Что такое разрядность Windows
