Kotlin как изменить имя читаемого файла

Знак ? применяется для поиска значения стиля в текущей теме, а подстрока ?android означает поиск значения стиля в системной теме Android.

В студии можно выбрать системную тему сразу из среды разработки. Откройте файл разметки в режиме Design. Чуть выше формы имеется выпадающая кнопка AppTheme. Нажмите на неё и поиграйтесь со списком, чтобы просмотреть другие варианты. Вы сможете увидеть, как будет выглядеть ваше приложение в разных темах. Учтите, что эта настройка не вносит изменения в ваш файл, а предназначена только для просмотра темы, чтобы вы представляли, как будет выглядеть программа у разных пользователей.

В последних версиях проектов студии, которые используют тему AppCompat для создания полноэкранной активности используйте стиль:

И примените его к нужной активности.

Новые темы в Android 4.4

В Android 4.4 появилась возможность сделать панель навигации и строку состояния полупрозрачными. Откройте файл styles.xml и добавьте строчки:

Последний пункт у меня закомментирован. Он позволяет настроить тему для ActionBar. Можете поиграться с ним. Для сравнения ниже представлены скриншоты стандартного окна активности с чёрными полосками снизу и сверху и стилизованной активности. Для наглядности я выбрал оранжевый цвет для фона активности.

Если говорить об эволюции тем и стилей, то в Android 2.x темы были в зачаточном состоянии. В Android 3/4 дизайнеры проделали огромную работу, чтобы система стала красивой и предложили тему Holo. В новой версии Android 5.0 работа над стилями была продолжена и была представлена новая концепция стиля под названием Material Design с подробной документацией по её использованию.

В статье Android App Launching Made Gorgeous рассматривается интересный случай, когда неправильное использование тем приводит к некрасивому эффекту - сначала загружается пустой экран, а затем уже экран вашей активности.

Темы для View

В статье говорилось, что отдельные компоненты должны использовать стили, а активности - темы. В Android 5.0 Lollipop, а также старые устройства с API 11 через библиотеку совместимости AppCompat могут также использовать темы:

Небольшой список на память.

• ThemeOverlay.AppCompat
• ThemeOverlay.AppCompat.Light
• ThemeOverlay.AppCompat.Dark
• ThemeOverlay.AppCompat.ActionBar
• ThemeOverlay.AppCompat.Dark.ActionBar

Например, ваши компоненты в разметке используют светлую тему, а родительский элемент должен использовать тёмную тему. Тогда применим к нему готовую тему.

Если вам нужно изменить конкретный атрибут, например, colorAccent, то добавьте новую тему:

Примените тему к вашему компоненту через android:theme="CustomAccentOverlay". Так вы можете переопределить и другие атрибуты.

Общие советы

Избегайте конкретных значений для цвета.

Лучше используйте атрибуты, что позволит вам корректно переключаться к тёмной теме.

В некоторых ситуациях использование готовых значений цвета оправдано.

При работе с элементами темы программным способом не используйте Context от Application, только от Activity.

Kotlin Coding Conventions

Общеизвестные и простые для понимания конвенции по кодингу жизненно важны для любого языка программирования. Здесь Вы ознакомитесь с рекомендациями по стилю кода для проектов, использующих Kotlin.

Настройка стиля в IDE

Две самые популярные IDE для Kotlin — IntelliJ IDEA и Android Studio — обеспечивают мощную поддержку Code Style. Их можно настроить для автоматического форматирования кода в соответствии с заданным стилем.

Применение стиля

1. Перейдите в Settings/Preferences | Editor | Code Style | Kotlin.
2. Щелкните Set from. .
3. Выберите Kotlin style guide.

Убедитесь, что ваш код соответствует выбранному руководству.

1. Перейдите в Settings/Preferences | Editor | Inspections | General.
2. Включите проверку Incorrect formatting. Дополнительные проверки, проверяющие другие проблемы, описанные в руководстве по стилю (например, соглашения об именах), включены по умолчанию.

Организация кода

Структура каталогов

В проектах на чистом Kotlin рекомендуемая структура каталогов соответствует структуре пакета с опущенным общим корневым пакетом. Например, если весь код находится в пакете org.example.kotlin и вложенных пакетах, то файлы с пакетом org.example.kotlin должны размещаться непосредственно в корневом каталоге, а файлы org.example.kotlin.network.socket должны находиться в подкаталоге корневого каталога network/socket .

В JVM: в проектах, в которых Kotlin используется совместно с Java, файлы Kotlin должны находиться в том же корневом каталоге, что и файлы Java, и иметь ту же структуру каталогов: каждый файл должен находиться в пакете, соответствующем для каждого оператора пакета.

Имена файлов

Если файл Kotlin содержит один класс или интерфейс (допускаются функции / переменные верхнего уровня), его имя должно совпадать с именем класса с расширением .kt . Это относится ко всем типам классов и интерфейсов. Если файл содержит несколько классов или только верхнеуровневые функции / переменные, выберите для файла соответствующее имя. Используйте Camel Case (пример: ProcessDeclarations.kt ).

Имя файла должно описывать работу кода. Избегайте использования бессмысленных слов (таких, как Util ).

Внутренняя организация файла

Мы приветствуем размещение нескольких программных сущностей (классы, верхнеуровневые функции / переменные) в одном файле, если эти сущности тесно связаны друг с другом семантически, а размер файла остаётся разумным и не превышает нескольких сотен строк.

В частности, при создании функций-расширений для класса, актуальных для всех пользователей этого класса, помещайте их в один файл с самим классом. Функции-расширения, используемые только определённым классом, разместите в файле этого класса. Избегайте создания файлов только для хранения всех функций-расширений класса.

Архитектура класса

Содержимое класса должно располагаться в следующем порядке:

1. Объявления полей и блоки инициализации.
2. Вторичные конструкторы.
3. Функции.
4. Объект-компаньон.

Не сортируйте функции по алфавиту или по видимости. Не отделяйте простые функции от функций-расширений. Вместо этого, сгруппируйте связанные функции так, чтобы читающий код сверху вниз мог понять логику происходящего. Выберите порядок (сначала функции верхнего уровня или наоборот) и придерживайтесь его. Поместите вложенные классы рядом с кодом, который их использует. Если классы предназначены для внешнего использования и на них нет ссылок внутри класса, поместите их после объекта-компаньона.

Схема реализации интерфейсов

При реализации интерфейса держите реализуемые функции в том же порядке, в котором они описаны в интерфейсе (при необходимости, чередуя их с дополнительными приватными функциями, используемыми в реализации).

Схема перегрузки функций

Всегда размещайте перегружаемые функции рядом друг с другом.

Правила именования

Правила именования пакетов и классов в Kotlin довольно просты:

Имена пакетов всегда пишутся строчными буквами без символов подчёркивания ( org.example.project ). Использовать имена, состоящие из нескольких слов, как правило, не рекомендуется, но если это необходимо, Вы можете соединить их вместе или использовать Camel Case ( org.example.myProject ).

Имена классов используют Upper Camel Case:

open class DeclarationProcessor < /*. */ >object EmptyDeclarationProcessor : DeclarationProcessor() < /*. */ >

Названия функций

Названия функций, полей и локальных переменных начинаются со строчной буквы, пишутся в Camel Case и без подчёркивания:

fun processDeclarations() < /*. */ >var declarationCount = 1

Исключение: фабричные функции, используемые для создания объектов, могут иметь то же имя, что и возвращаемый тип:

interface Foo < /*. */ >class FooImpl : Foo < /*. */ >fun Foo(): Foo

Имена тестовых функций

Для тестов (и только для тестов) Вы можете использовать имена с пробелами, заключённые в обратные скобки. Имейте в виду, такие имена функций не поддерживаются средой выполнения Android. Также, в тестовом коде в именах функций разрешены подчёркивания.

class MyTestCase < @Test fun `ensure everything works`() < /*. */ >@Test fun ensureEverythingWorks_onAndroid() < /*. */ >>

Имена полей

Имена констант (поля, помеченные как const / верхнеуровневые поля / поля классов без геттера, содержащие неизменяемые данные), пишутся в Screaming Snake Case:

const val MAX_COUNT = 8 val USER_NAME_FIELD = "UserName"

Верхнеуровневые поля или поля классов, содержащие поведение / изменяемые данные, пишутся в Camel Case:

val mutableCollection: MutableSet = HashSet()

Имена полей, содержащих ссылки на синглтоны, могут использовать тот же стиль наименования, что и объявления объектов:

val PersonComparator: Comparator = /*. */

Для перечислений ( enum ), допускается использовать или Screaming Snake Case ( enum class Color < RED, GREEN >), или Upper Camel Case.

Имена полей-прокладок

Если в классе есть два концептуально одинаковых поля, одно из которых является частью общепринятого API, а второе - деталью реализации, используйте в имени приватного поля нижнее подчёркивание в качестве префикса:

class C < private val _elementList = mutableListOf() val elementList: List get() = _elementList >

Выбирайте хорошие имена

Имя класса обычно представляет из себя существительное или словосочетание, объясняющее, что это за класс: List , PersonReader .

Имя функции обычно представляет из себя глагол или отглагольную фразу, описывающую то, что делает функция: close , readPersons . Имя функции также должно подсказывать, изменяет ли она объект или возвращает новый. Например, sort возвращает существующую отсортированную коллекцию, а sorted возвращает отсортированную новую.

Имена должны точно давать понять цель сущности, поэтому лучше не использовать в именах бессмысленные слова ( Manager , Wrapper ).

При использовании аббревиатур, используйте все заглавные буквы, если аббревиатура состоит из двух букв ( IOStream ); используйте только первую заглавную букву, если аббревиатура длинее ( XmlFormatter , HttpInputStream ).

Форматирование

Отступы

Для отступа используйте 4 пробела. Не используйте табуляцию.

Применяя фигурные скобки, открывающую скобку поместите в конец строки открывающей конструкции, а закрывающую скобку поместите с новой строки; выровняйте её по горизонтали с открывающей конструкцией:

if (elements != null) < for (element in elements) < // . >>

В Kotlin точки с запятой необязательны, поэтому переносы строк имеют значение. Дизайн языка предполагает фигурные скобки в стиле Java, и вы можете столкнуться с неожиданным поведением, если попытаетесь использовать другой стиль форматирования.

Горизонтальные пробелы

• Ставьте пробелы вокруг бинарных операторов ( a + b ). Исключение: не ставьте пробелы вокруг оператора «диапазон до» ( 0..i ).
• Не ставьте пробелы вокруг унарных операторов ( a++ ).
• Используйте пробелы между ключевыми словами ветвлений и циклов ( if , when , for и while ) и соответствующей открывающей скобкой.
• Не ставьте пробел перед открывающей скобкой в объявлении основного конструктора, объявлении метода или вызове метода.

class A(val x: Int) fun foo(x: Int) < . >fun bar()

• Никогда не ставьте пробел после ( , [ или перед ] , )
• Никогда не ставьте пробел вокруг . или ?. : foo.bar().filter < it >2 >.joinToString() , foo?.bar()
• Ставьте пробел после // : // Это комментарий
• Не ставьте пробелы вокруг угловых скобок, используемых для указания параметров типа: class Map
• Не ставьте пробелы вокруг :: : Foo::class , String::length
• Не ставить пробел перед ? используется для обозначения типа, допускающего значение null: String?

Избегайте любого горизонтального выравнивания. Переименование идентификатора в имя другой длины не должно влиять ни на форматирование, ни на что-либо другое.

Двоеточие

Ставьте пробел перед : в следующих случаях:

• при использовании для разделения типа и супертипа
• при делегировании конструктору суперкласса или другому конструктору того же класса
• после ключевого слова объекта

Не ставьте пробел перед : , когда оно разделяет объявление и его тип.

Всегда ставьте пробел после : .

abstract class Foo : IFoo < abstract fun foo(a: Int): T >class FooImpl : Foo() < constructor(x: String) : this(x) < /*. */ >val x = object : IFoo < /*. */ >>

Заголовки классов

Классы с несколькими основными параметрами конструктора можно записать в одну строку:

class Person(id: Int, name: String)

Классы с более длинными заголовками должны быть отформатированы так, чтобы каждый параметр основного конструктора находился в отдельной строке с отступом. Кроме того, закрывающая скобка должна быть на новой строке. Если вы используете наследование, вызов конструктора суперкласса или список реализованных интерфейсов должен располагаться на той же строке, что и скобка:

class Person( id: Int, name: String, surname: String ) : Human(id, name) < /*. */ >

При реализации нескольких интерфейсов, вызов конструктора суперкласса должен быть расположен первым, далее каждый интерфейс должен быть расположен на отдельной строке:

class Person( id: Int, name: String, surname: String ) : Human(id, name), KotlinMaker < /*. */ >

Для классов с длинным списком супертипов поставьте разрыв строки после двоеточия и выровняйте все имена супертипов по горизонтали:

class MyFavouriteVeryLongClassHolder : MyLongHolder(), SomeOtherInterface, AndAnotherOne < fun foo() < /*. */ >>

Чтобы четко разделить заголовок и тело класса, когда заголовок класса длинный, либо поместите пустую строку после заголовка класса (как в приведенном выше примере), либо поместите открывающую фигурную скобку на отдельную строку:

class MyFavouriteVeryLongClassHolder : MyLongHolder(), SomeOtherInterface, AndAnotherOne < fun foo() < /*. */ >>

Используйте обычный отступ (четыре пробела) для параметров конструктора. Это гарантирует, что свойства, объявленные в основном конструкторе, будут иметь тот же отступ, что и свойства, объявленные в теле класса.

Порядок модификаторов

Если объявление имеет несколько модификаторов, всегда располагайте их в следующем порядке:

public / protected / private / internal expect / actual final / open / abstract / sealed / const external override lateinit tailrec vararg suspend inner enum / annotation / fun // as a modifier in `fun interface` companion inline / value infix operator data

Аннотации размещайте перед модификаторами:

@Named("Foo") private val foo: Foo

Если вы не работаете с библиотекой, не используйте лишние модификаторы (например, public ).

Аннотации

Размещайте аннотации на отдельных строках перед объявлением, к которому они относятся, с тем же отступом:

@Target(AnnotationTarget.PROPERTY) annotation class JsonExclude

Аннотации без аргументов могут быть размещены на одной строке:

@JsonExclude @JvmField var x: String

Одна аннотация без аргументов может быть размещена на той же строке, что и соответствующее объявление:

@Test fun foo() < /*. */ >

Аннотации @file

Аннотации @file помещаются после комментария к файлу (если есть), перед оператором пакета и отделяются от пакета пустой строкой (чтобы подчеркнуть тот факт, что они нацелены на файл, а не на пакет).

/** License, copyright and whatever */ @file:JvmName("FooBar") package foo.bar

Функции

Если сигнатура функции не помещается на одной строке, используйте следующий синтаксис:

fun longMethodName( argument: ArgumentType = defaultValue, argument2: AnotherArgumentType, ): ReturnType < // body >

Используйте обычный отступ (четыре пробела) для параметров функции. Это помогает обеспечить согласованность с параметрами конструктора.

Для функций лучше использовать тело как выражение, если тело состоит из одного выражения.

fun foo(): Int < // bad return 1 >fun foo() = 1 // good

Тела как выражения

Если для функции используется тело как выражение, первая строка которого не помещается на той же строке, что и объявление, поставьте знак = на первой строке и сделайте отступ тела-выражения на четыре пробела.

fun f(x: String, y: String, z: String) = veryLongFunctionCallWithManyWords(andLongParametersToo(), x, y, z)

Свойства

Для очень простых свойств только для чтения рассмотрите однострочное форматирование:

val isEmpty: Boolean get() = size == 0

Для более сложных свойств всегда помещайте ключевые слова get и set в отдельные строки:

val foo: String get() < /*. */ >

Для свойств с инициализатором, если инициализатор длинный, добавьте разрыв строки после знака = и отступ инициализатора на четыре пробела:

private val defaultCharset: Charset? = EncodingRegistry.getInstance().getDefaultCharsetForPropertiesFiles(file)

Операторы ветвлений

Если условие оператора if или when является многострочным, всегда используйте фигурные скобки вокруг тела. Отступ каждой последующей строки условия на четыре пробела относительно начала оператора. Поместите закрывающие скобки условия вместе с открывающей фигурной скобкой на отдельной строке:

if (!component.isSyncing && !hasAnyKotlinRuntimeInScope(module) )

Это помогает согласовать тело условия и инструкции.

Поместите ключевые слова else , catch , finally , а также ключевое слово while цикла do-while на той же строке, что и предыдущая фигурная скобка:

if (condition) < // body >else < // else part >try < // body >finally < // cleanup >

Для оператора when , если ветвь состоит из более чем одной строки, рассмотрите возможность отделения её от соседних блоков case пустой строкой:

private fun parsePropertyValue(propName: String, token: Token) < when (token) < is Token.ValueToken ->callback.visitValue(propName, token.value) Token.LBRACE -> < // . >> >

Поместите короткие ветвления на той же строке, что и условие, без фигурных скобок.

when (foo) < true ->bar() // good false -> < baz() >// bad >

Вызовы методов

В длинных списках аргументов ставьте разрыв строки после открывающей скобки. Аргументы с отступом в четыре пробела. Сгруппируйте несколько тесно связанных аргументов в одной строке.

drawSquare( x = 10, y = 10, width = 100, height = 100, fill = true )

Поместите пробелы вокруг знака = , разделяющего имя аргумента и значение.

Перенос цепочек вызовов

При переносе цепочек вызовов поместите расширение . символ или оператор ?. на следующей строке с одним отступом:

val anchor = owner ?.firstChild!! .siblings(forward = true) .dropWhile

Перед первым вызовом в цепочке обычно должен быть разрыв строки, но его можно опустить, если код имеет больше смысла.

Лямбды

В лямбда-выражениях следует использовать пробелы вокруг фигурных скобок, а также вокруг стрелки, отделяющей параметры от тела. Если вызов принимает одну лямбду, передайте её вне круглых скобок, когда это возможно.

list.filter < it >10 >

При назначении метки для лямбды не ставьте пробел между меткой и открывающей фигурной скобкой:

fun foo() < ints.forEach lit@< // . >>

При объявлении параметров в многострочном лямбда-выражении поместите параметры в первую строку, затем стрелку, далее с новой строки:

appendCommaSeparated(properties) < prop ->val propertyValue = prop.get(obj) // . >

Если список параметров слишком длинный и не помещается на одной строке, поместите стрелку на отдельной строке:

foo < context: Context, environment: Env ->context.configureEnv(environment) >

Замыкающие запятые

Замыкающая запятая — это символ запятой после последнего элемента последовательности элементов:

class Person( val firstName: String, val lastName: String, val age: Int, // завершающая запятая )

Использование замыкающих запятых имеет несколько преимуществ:

• Это делает контроль версий чище, так как все внимание сосредоточено на измененном значении.
• Это упрощает добавление и изменение порядка элементов — нет необходимости добавлять или удалять запятую, если вы манипулируете элементами.
• Это упрощает генерацию кода, например, для инициализаторов объектов. Последний элемент также может иметь запятую.

Замыкающие запятые необязательны — ваш код будет работать и без них. Руководство по стилю Kotlin поощряет использование замыкающих запятых в месте объявления и оставляет его на ваше усмотрение для места вызова.

Чтобы включить замыкающие запятые в инструменте форматирования IntelliJ IDEA, перейдите в раздел Settings/Preferences | Editor | Code Style | Kotlin, откройте вкладку Other и выберите параметр Use trailing comma.

enum class Direction < NORTH, SOUTH, WEST, EAST, // trailing comma >

fun shift(x: Int, y: Int) < /*. */ >shift( 25, 20, // trailing comma ) val colors = listOf( "red", "green", "blue", // trailing comma )

Свойства и параметры класса

class Customer( val name: String, val lastName: String, // trailing comma ) class Customer( val name: String, lastName: String, // trailing comma )

Параметры функций

fun powerOf( number: Int, exponent: Int, // trailing comma ) < /*. */ >constructor( x: Comparable, y: Iterable, // trailing comma ) <> fun print( vararg quantity: Int, description: String, // trailing comma ) <>

Параметры с необязательным типом (включая сеттеры)

val sum: (Int, Int, Int) -> Int = fun( x, y, z, // trailing comma ): Int < return x + y + x >println(sum(8, 8, 8))

Суффиксы индексов

class Surface < operator fun get(x: Int, y: Int) = 2 * x + 4 * y - 10 >fun getZValue(mySurface: Surface, xValue: Int, yValue: Int) = mySurface[ xValue, yValue, // trailing comma ]

Параметры в лямбдах

fun main() < val x = < x: Comparable, y: Iterable, // trailing comma -> println("1") > println(x) >

fun isReferenceApplicable(myReference: KClass) = when (myReference) < Comparable::class, Iterable::class, String::class, // trailing comma ->true else -> false >

Литералы в коллекциях

annotation class ApplicableFor(val services: Array) @ApplicableFor([ "serializer", "balancer", "database", "inMemoryCache", // trailing comma ]) fun run() <>

Аргументы типов

fun foo() <> fun main() < foo< Comparable, Iterable, // trailing comma >() >

Параметры типов

class MyMap < MyKey, MyValue, // trailing comma ><>

Деструктуризация объявлений

data class Car(val manufacturer: String, val model: String, val year: Int) val myCar = Car("Tesla", "Y", 2019) val ( manufacturer, model, year, // trailing comma ) = myCar val cars = listOf() fun printMeanValue() < var meanValue: Int = 0 for (( _, _, year, // trailing comma ) in cars) < meanValue += year >println(meanValue/cars.size) > printMeanValue()

Комментарии к документации

Для более длинных комментариев к документации поместите начало /** на отдельной строке и начинайте каждую последующую строку со звездочки:

/** * This is a documentation comment * on multiple lines. */

Короткие комментарии можно размещать на одной строке:

/** This is a short documentation comment. */

Как правило, избегайте использования тегов @param и @return . Вместо этого включите описание параметров и возвращаемых значений непосредственно в комментарий к документации и добавьте ссылки на параметры везде, где они упоминаются. Используйте @param и @return только тогда, когда требуется длинное описание, не вписывающееся в основной текст.

// Avoid doing this: /** * Returns the absolute value of the given number. * @param number The number to return the absolute value for. * @return The absolute value. */ fun abs(number: Int): Int < /*. */ >// Do this instead: /** * Returns the absolute value of the given [number]. */ fun abs(number: Int): Int < /*. */ >

Избегайте избыточных конструкций

В общем, если некая синтаксическая конструкция в Kotlin является необязательной и выделена IDE как избыточная, её следует избегать в своем коде. Не оставляйте ненужные синтаксические элементы в коде просто «для ясности».

Возвращаемый тип Unit

Если функция возвращает Unit , тип возвращаемого значения следует опустить:

fun foo() < // ": Unit" is omitted here >

Точки с запятой

Избегайте точек с запятой, когда это возможно.

Строковые шаблоны

Не используйте фигурные скобки при вставке простой переменной в строковый шаблон. Используйте фигурные скобки только для более длинных выражений.

println("$name has $ children")

Идиоматическое использование особенностей языка

Иммутабельность

Предпочитайте использовать иммутабельные данные. Всегда объявляйте локальные переменные и свойства как val , а не как var , если они не изменяются после инициализации.

// Bad: use of mutable collection type for value which will not be mutated fun validateValue(actualValue: String, allowedValues: HashSet) < . >// Good: immutable collection type used instead fun validateValue(actualValue: String, allowedValues: Set) < . >// Bad: arrayListOf() returns ArrayList, which is a mutable collection type val allowedValues = arrayListOf("a", "b", "c") // Good: listOf() returns List val allowedValues = listOf("a", "b", "c")

Значения параметров по умолчанию

Предпочтите объявление функций со значениями параметров по умолчанию объявлению перегруженных функций.

// Bad fun foo() = foo("a") fun foo(a: String) < /*. */ >// Good fun foo(a: String = "a") < /*. */ >

Псевдонимы типов (элиасы)

Если у вас есть функциональный тип или тип с параметрами типа, который используется несколько раз в кодовой базе, предпочтительнее определить для него элиас:

typealias MouseClickHandler = (Any, MouseEvent) -> Unit typealias PersonIndex = Map

Если вы используете частный или внутренний псевдоним типа, чтобы избежать конфликта имен, отдайте предпочтение import . as . , упомянутому в разделе "Пакеты и импорты".

Параметры лямбд

В коротких и не вложенных лямбда-выражениях рекомендуется использовать it вместо явного объявления параметра. Во вложенных лямбда-выражениях с параметрами всегда объявляйте параметры явно.

return в лямбдах

Избегайте использования нескольких помеченных return в лямбда-выражении. Рассмотрите возможность реструктуризации лямбды, чтобы она имела единую точку выхода. Если это невозможно или недостаточно ясно, рассмотрите возможность преобразования лямбды в анонимную функцию.

Не используйте помеченный return для последнего оператора в лямбда-выражении.

Именованные аргументы

Используйте синтаксис именованных аргументов, когда метод принимает несколько параметров одного и того же примитивного типа или для параметров логического типа, если только значение всех параметров не ясно из контекста.

drawSquare(x = 10, y = 10, width = 100, height = 100, fill = true)

Условные операторы

Предпочтительнее использовать форму выражения try , if и when .

return if (x) foo() else bar()

return when(x) < 0 ->"zero" else -> "nonzero" >

Вышеупомянутое предпочтительнее, чем:

if (x) return foo() else return bar()

when(x) < 0 ->return "zero" else -> return "nonzero" >

if или when?

Для бинарных условий, предпочтительнее использовать if вместо when . Например, используйте этот синтаксис с if :

if (x == null) . else . 

вместо варианта ниже с when :

when (x) < null ->// . else -> // . >

when использовать предпочтительнее, если есть три или более вариантов.

Nullable булевые значения в условиях

Если вам нужно использовать Boolean значение, допускающее значение null , в условном операторе, используйте проверки if (value == true) или if (value == false) .

Циклы

Предпочтительнее использование функций более высокого порядка (фильтр, хэш-таблица и т. д.) вместо циклов. Исключение: forEach (вместо него лучше использовать обычный цикл for , если получатель forEach не допускает значение null или forEach не используется как часть более длинной цепочки вызовов).

Делая выбор между сложным выражением, использующим несколько функций высшего порядка, и циклом, оцените стоимость операций, выполняемых в каждом случае, и помните о производительности.

Циклы по диапазону

Используйте функцию until для цикла по диапазону:

for (i in 0..n - 1) < /*. */ >// bad for (i in 0 until n) < /*. */ >// good

Строки

Предпочитайте строковые шаблоны конкатенации строк.

Предпочитайте многострочные строки встраиванию управляющих последовательностей \n в обычные строковые литералы.

Чтобы сохранить отступ в многострочных строках, используйте trimIndent , если результирующая строка не требует внутреннего отступа, или trimMargin , когда требуется внутренний отступ:

fun main() < println(""" Not trimmed text """ ) println(""" Trimmed text """.trimIndent() ) println() val a = """Trimmed to margin text: |if(a >1) < | return a |>""".trimMargin() println(a) >

Изучите разницу между многострочными строками Java и Kotlin.

Функции или свойства?

В некоторых случаях функции без аргументов могут быть взаимозаменяемы со свойствами только для чтения. Хотя семантика аналогична, существуют некоторые стилистические соглашения о том, когда следует предпочесть одно другому.

Предпочитайте свойство функции, если базовый алгоритм:

• не выбрасывает исключение
• дёшево вычислить (или кэшировать при первом запуске)
• возвращает тот же результат при вызовах, если состояние объекта не изменилось

Функции-расширения

Свободно используйте функции расширения. Каждый раз, когда у вас есть функция, которая в основном работает с объектом, подумайте о том, чтобы сделать её функцией расширения, принимающей этот объект в качестве получателя. Чтобы свести к минимуму загрязнение API, ограничьте видимость функций-расширений настолько, насколько это имеет смысл. При необходимости используйте локальные функции-расширения, функции-расширения - члены или функции-расширения верхнего уровня с частной видимостью.

Инфиксные функции

Объявляйте функцию как инфиксную только тогда, когда она работает с двумя объектами, играющими одинаковую роль. Хорошие примеры: and , to , zip . Плохой пример: add .

Не объявляйте метод как инфиксный, если он изменяет объект-получатель.

Фабричные функции

Если вы объявляете фабричную функцию для класса, не давайте ей то же имя, что и сам класс. Лучше использовать отдельное имя, чтобы было понятно, почему поведение фабричной функции особенное. Только если особой семантики действительно нет, можно использовать то же имя, что и у класса.

class Point(val x: Double, val y: Double) < companion object < fun fromPolar(angle: Double, radius: Double) = Point(. ) >>

Если у вас есть объект с несколькими перегруженными конструкторами, которые не вызывают разные конструкторы суперкласса и не могут быть сведены к одному конструктору со значениями аргументов по умолчанию, предпочтительнее заменить перегруженные конструкторы фабричными функциями.

Платформенные типы

Общедоступная функция/метод, возвращающая выражение платформенного типа, должна явно объявлять свой тип Kotlin:

fun apiCall(): String = MyJavaApi.getProperty("name")

Любое свойство (на уровне пакета или на уровне класса), инициализированное выражением платформенного типа, должно явно объявлять свой тип Kotlin:

class Person

Локальное значение, инициализированное выражением платформенного типа, может иметь или не иметь объявление типа:

fun main()

Scope-функции apply/with/run/also/let

Kotlin предоставляет набор функций для выполнения блока кода в контексте заданного объекта: let , run , with , apply , и also . Руководство по выбору правильной scope-функции для вашего случая см. в разделе Scope-функции.

Конвенция для библиотек

При написании библиотек рекомендуется соблюдать дополнительный набор правил для обеспечения стабильности API:

• Всегда явно указывайте видимость члена (чтобы избежать случайного раскрытия объявлений как общедоступного API)
• Всегда явно указывайте возвращаемые типы функций и типы свойств (чтобы избежать случайного изменения возвращаемого типа при изменении реализации).
• Предоставляйте комментарии KDoc всем общедоступным участникам, за исключением переопределений, не требующих новой документации (для поддержки создания документации для библиотеки).

Как изменить имя файла в цикле с++ [закрыт]

Закрыт. Этот вопрос необходимо уточнить или дополнить подробностями. Ответы на него в данный момент не принимаются.

Хотите улучшить этот вопрос? Добавьте больше подробностей и уточните проблему, отредактировав это сообщение.

Закрыт 8 лет назад .
Прошу подсказать как можно создавать новое имя для файла в цикле?
Отслеживать
задан 11 авг 2015 в 15:03
Aleksandr Fursenko Aleksandr Fursenko
93 5 5 бронзовых знаков
Fursenko Думаю, что точно также, как и без хоровода вокруг елочки.:)
11 авг 2015 в 15:11
Да как угодно можно его создавать.
11 авг 2015 в 15:12
Есть файл например fs.txt следующий должен иметь другое имя, например fs1.txt?
11 авг 2015 в 15:21

@AleksandrFursenko ну вот вы сами и ответили на свой вопрос как можно создавать имя файла. Берите и реализовывайте озвученный вами алгоритм на нужном языке.

11 авг 2015 в 15:22

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

мой пример посмотрите к примеру. результат работы этой программы три новых файла в корне диска Ц (под виндовс писал).

#include #include #include using namespace std; int main() < ofstream file; // сам файл char filename[2]; // временный буфер string path; // сюда мы будем ложить новые имена for (int i = 0; i < 3; i++)< // цикл который будет создовать новые имена (и создаст новые файлы с новым именем itoa(i, filename, 10); // преоброзовать в текстовый символ path = "C:\\file"; // часть имени файла (оно будет постоянным) path += filename; // собираем путь и имя для нового файла file.open(path.c_str()); // создать новый файл с новым именем file.close(); // обязательно закрываем >return 0; > 

Отслеживать
ответ дан 11 авг 2015 в 15:23
9,971 14 14 золотых знаков 53 53 серебряных знака 117 117 бронзовых знаков

А можно вместо 3-х строк (начиная с itoa()) использовать один вызов функции snprintf / При желании можно уйти от ofstream и несколько более эффективно делать файл одной строкой на низком уровне close(open(path, . ))

11 авг 2015 в 17:41

даже затрудняюсь с ответом я этой функцией не умею пользоваться и не знал что функция close() может принимать параметры

11 авг 2015 в 17:51
Так почитайте man-ы. Вы же программист, стыдно не знать основ POSIX.
11 авг 2015 в 18:01

да я как бы на оборот уйти от сишного стиля кодирования хочу. я даже в этом коде не хотел бы использовать настоящий массив и функцию itoa, потому что вместо этого в с++ есть функция to_string(), но она у меня не работает потому что у меня кривой компилятор. вот и пришлось так выкручиваться )

11 авг 2015 в 18:05

Дело Ваше. IMHO надо по возможности использовать лучшие (в широком смысле (здесь и сейчас обсуждать что стоит за этими словами мы, конечно же, не будем)) средства, независимо от их "происхождения".