Предположим, что вы разделяете строку разделителем, называемым separator
, вы можете сделать следующее:
let result = yourString.components(separatedBy: separator) // first split
.flatMap { [[110], separator] } // add the separator after each split
.dropLast() // remove the last separator added
.filter { [110] != "" } // remove empty strings
Например:
let result = " Hello World ".components(separatedBy: " ").flatMap { [[111], " "] }.dropLast().filter { [111] != "" }
print(result) // [" ", "Hello", " ", "World", " "]
Для этого можно использовать директиву include .
Файл 2:
<?php
$myvar="prashant";
?>
Файл 1:
<?php
include('myfile2.php');
echo $myvar;
?>
Если вам нужно только содержимое echo ()
, редактируемое включенной страницей, вы можете рассмотреть возможность использования буферизации вывода:
ob_start();
include 'myfile2.php';
$echoed_content = ob_get_clean(); // gets content, discards buffer
Я не уверен, что это ошибка в g ++ (начиная с версии 4.2.4). Теперь код переходит в g ++ 4.4 (см. ОБНОВЛЕНИЕ ниже). Чтобы этот код компилировался для других версий компиляторов, вы можете добавить набор круглых скобок вокруг аргумента по умолчанию:
template<typename A, typename B>
class Foo { };
struct Bar {
void method ( Foo<int,int> const& stuff = ( Foo<int,int>() ) );
};
IMO, эти круглые скобки необходимы, поскольку существует дополнительное требование, чтобы аргумент по умолчанию мог ссылаться на член class, который может быть объявлен позже в теле класса:
struct Bar {
void method ( int i = j); // 'j' not declared yet
static const int j = 0;
};
Приведенный выше код является допустимым, и когда объявление для 'метода' анализируется, член 'j' еще не был замечен. Таким образом, компилятор может анализировать аргумент по умолчанию только с использованием синтаксиса и только проверки (т. Е. Соответствия скобкам и запятым). Когда g ++ анализирует ваше исходное объявление, на самом деле он видит следующее:
void method ( Foo<int,int> const& stuff = Foo<int // Arg 1 with dflt.
, int>() ); // Arg 2 - syntax error
Добавление дополнительных скобок гарантирует, что аргумент по умолчанию обрабатывается правильно.
В следующем случае показан пример, когда g ++ успешно работает, но Comeau по-прежнему генерирует синтаксическую ошибку:
template<int J, int K>
class Foo { };
struct Bar {
void method ( Foo<0, 0> const & i = ( Foo<j, k> () ) );
static const int j = 0;
static const int k = 0;
};
EDIT:
В ответ на комментарий: «С таким же успехом вы можете иметь вызов функции с несколькими аргументами», Причина, по которой это не вызывает проблемы, заключается в том, что запятые внутри вызова функции заключены в круглые скобки:
int foo (int, int, int);
struct Bar {
void method ( int j =
foo (0, 0, 0) ); // Comma's here are inside ( )
};
Следовательно, можно проанализировать это, используя только синтаксис выражения. В C ++ все символы '(' должны совпадать с ')', поэтому их легко проанализировать. Причина проблемы здесь в том, что «<» не нужно сопоставлять, поскольку он перегружен в C ++ и поэтому может быть оператором «меньше» или началом списка аргументов шаблона. В следующем примере показано, где '<' используется в аргументе по умолчанию и подразумевает оператор «меньше чем»:
template<int I, int J>
class Foo { };
struct Bar {
template <typename T> struct Y { };
void method ( ::Foo<0,0> const& stuff = Foo<10 , Y < int > = Y<int>() );
struct X {
::Foo<0, 0> operator< (int);
};
static X Foo;
};
Вышеупомянутое «Foo <10» является вызовом «operator <», определенным в 'X', а не началом список аргументов шаблона. Опять же, Comeau генерирует синтаксические ошибки в приведенном выше коде, и g ++ (включая 3.2.3) анализирует это правильно.
FYI, соответствующие ссылки - это примечание в 8.3.6 / 5:
[Примечание: в объявлениях функций-членов просматриваются имена в выражениях аргументов по умолчанию вверх, как описано в 3.4.1 ...
, а затем в 3.4.1 / 8
Имя, используемое в определении функции-члена (9.3) класса X после declaratorid29 функции) должен быть объявлен одним из следующих способов:
...
- должен быть членом класса X или быть членом базового класса X (10.2), или
Этот пункт здесь является часть, которая заставляет компилятор «откладывать» поиск значения аргумента по умолчанию до тех пор, пока не будут объявлены все члены класса.
Как указано в «Занятом русском языке», g ++ 4.4 теперь способен разобрать все эти примеры. Однако до тех пор, пока DR не будет рассмотрен комитетом по стандартам C ++, я еще не готов называть это «ошибкой». Я считаю, что для обеспечения переносимости на другие компиляторы / инструменты (и, возможно, даже на будущие версии g ++) потребуются дополнительные круглые скобки.
По моему опыту, стандарт C ++ не требует, чтобы все поставщики компиляторов использовали одну и ту же технологию синтаксического анализатора, и они также не могут ожидать, что все технологии будут одинаково мощными. В результате требования к синтаксическому анализу обычно не требуют, чтобы поставщики совершали сверхчеловеческие подвиги. Чтобы проиллюстрировать это, рассмотрим следующие два примера:
typedef T::TYPE TYPE;
T::TYPE t;
Если 'T' является зависимым, то для каждого контекста 'TYPE' должен быть именем типа, однако стандарт по-прежнему требует typename ключевое слово. Эти примеры однозначны и могут означать только одно, однако стандарт (чтобы разрешить все технологии синтаксического анализа) по-прежнему требует ключевого слова typename .
It» ) включенного файла и использовать вывод в переменной (строке)?
Локальные переменные в ваших включенных файлах всегда будут перемещены в текущую область вашего host скрипта - это следует отметить. Вы можете объединить все эти функции в одну:
include.php
$hello = "Hello";
echo "Hello World";
return "World";
host.php
ob_start();
$return = include 'include.php'; // (string)"World"
$output = ob_get_clean(); // (string)"Hello World"
// $hello has been moved to the current scope
echo $hello . ' ' . $return; // echos "Hello World"
Функция return
пригодится, особенно при использовании файлов конфигурации.
config.php
return array(
'host' => 'localhost',
....
);
app.php
$config = include 'config.php'; // $config is an array
EDIT
Чтобы ответить на ваш вопрос о снижении производительности при использовании выходных буферов, я просто провел небольшое тестирование. 1000000 итераций ob_start ()
и соответствующего $ o = ob_get_clean ()
занимают около 7. 5 секунд на моем компьютере с Windows (возможно, не лучшая среда для PHP). Я бы сказал, что влияние на производительность следует считать довольно небольшим ...
«На самом деле я просто искал, есть ли какой-нибудь метод возвращаемого типа, который может напрямую дать мне значение» - вы только что ответили на свой вопрос.
См. http: // sg .php.net / manual / en / function.include.php , Пример № 5
file1.php:
<? return 'somevalue'; ?>
file2.php:
<?
$file1 = include 'file1.php';
echo $file1; // This outputs 'somevalue'.
?>
Если вы хотите, чтобы весь сайт пользовался
<?php
$URL = 'http://www.example.com/';
$homepage = file_get_contents($URL);
echo $homepage;
?>