mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
unify header style
This commit is contained in:
Boris Verkhovskiy
parent
1924d58159
commit
5fb4c54268
4
.github/workflows/lint.yml
vendored
4
.github/workflows/lint.yml
vendored
@ -1,4 +1,4 @@
|
||||
name: Node.js CI
|
||||
name: CI
|
||||
|
||||
on:
|
||||
push:
|
||||
@ -15,4 +15,4 @@ jobs:
|
||||
with:
|
||||
ruby-version: '3.2'
|
||||
- run: gem install mdl
|
||||
- run: mdl . --ignore-front-matter -r MD011,MD023,MD027,MD028,MD037,MD038,MD039,MD047
|
||||
- run: mdl . --ignore-front-matter -r MD003,MD011,MD023,MD027,MD028,MD035,MD037,MD038,MD039,MD047
|
||||
|
||||
@ -1116,8 +1116,7 @@ proc main() {
|
||||
} // end main()
|
||||
```
|
||||
|
||||
Who is this tutorial for?
|
||||
-------------------------
|
||||
## Who is this tutorial for?
|
||||
|
||||
This tutorial is for people who want to learn the ropes of chapel without
|
||||
having to hear about what fiber mixture the ropes are, or how they were
|
||||
@ -1132,28 +1131,27 @@ to see if more topics have been added or more tutorials created.
|
||||
|
||||
### What this tutorial is lacking:
|
||||
|
||||
* Exposition of the [standard modules](https://chapel-lang.org/docs/latest/modules/standard.html)
|
||||
* Multiple Locales (distributed memory system)
|
||||
* Records
|
||||
* Parallel iterators
|
||||
* Exposition of the [standard modules](https://chapel-lang.org/docs/latest/modules/standard.html)
|
||||
* Multiple Locales (distributed memory system)
|
||||
* Records
|
||||
* Parallel iterators
|
||||
|
||||
Your input, questions, and discoveries are important to the developers!
|
||||
-----------------------------------------------------------------------
|
||||
## Your input, questions, and discoveries are important to the developers!
|
||||
|
||||
The Chapel language is still in active development, so there are
|
||||
occasional hiccups with performance and language features. The more information
|
||||
you give the Chapel development team about issues you encounter or features you
|
||||
would like to see, the better the language becomes.
|
||||
There are several ways to interact with the developers:
|
||||
+ [Gitter chat](https://gitter.im/chapel-lang/chapel)
|
||||
+ [sourceforge email lists](https://sourceforge.net/p/chapel/mailman)
|
||||
|
||||
* [Gitter chat](https://gitter.im/chapel-lang/chapel)
|
||||
* [sourceforge email lists](https://sourceforge.net/p/chapel/mailman)
|
||||
|
||||
If you're really interested in the development of the compiler or contributing
|
||||
to the project, [check out the master GitHub repository](https://github.com/chapel-lang/chapel).
|
||||
It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0).
|
||||
|
||||
Installing the Compiler
|
||||
-----------------------
|
||||
## Installing the Compiler
|
||||
|
||||
[The Official Chapel documentation details how to download and compile the Chapel compiler.](https://chapel-lang.org/docs/usingchapel/QUICKSTART.html)
|
||||
|
||||
@ -1161,23 +1159,22 @@ Chapel can be built and installed on your average 'nix machine (and cygwin).
|
||||
[Download the latest release version](https://github.com/chapel-lang/chapel/releases/)
|
||||
and it's as easy as
|
||||
|
||||
1. `tar -xvf chapel-<VERSION>.tar.gz`
|
||||
2. `cd chapel-<VERSION>`
|
||||
3. `source util/setchplenv.bash # or .sh or .csh or .fish`
|
||||
4. `make`
|
||||
5. `make check # optional`
|
||||
1. `tar -xvf chapel-<VERSION>.tar.gz`
|
||||
2. `cd chapel-<VERSION>`
|
||||
3. `source util/setchplenv.bash # or .sh or .csh or .fish`
|
||||
4. `make`
|
||||
5. `make check # optional`
|
||||
|
||||
You will need to `source util/setchplenv.EXT` from within the Chapel directory
|
||||
(`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop
|
||||
that command in a script that will get executed on startup (like .bashrc).
|
||||
|
||||
Chapel is easily installed with Brew for macOS
|
||||
Chapel is easily installed on macOS with Homebrew
|
||||
|
||||
1. `brew update`
|
||||
2. `brew install chapel`
|
||||
1. `brew update`
|
||||
2. `brew install chapel`
|
||||
|
||||
Compiling Code
|
||||
--------------
|
||||
## Compiling Code
|
||||
|
||||
Builds like other compilers:
|
||||
|
||||
@ -1185,10 +1182,10 @@ Builds like other compilers:
|
||||
|
||||
Notable arguments:
|
||||
|
||||
* `--fast`: enables a number of optimizations and disables array bounds
|
||||
checks. Should only enable when application is stable.
|
||||
* `--set <Symbol Name>=<Value>`: set config param `<Symbol Name>` to `<Value>`
|
||||
at compile-time.
|
||||
* `--main-module <Module Name>`: use the main() procedure found in the module
|
||||
`<Module Name>` as the executable's main.
|
||||
* `--module-dir <Directory>`: includes `<Directory>` in the module search path.
|
||||
* `--fast`: enables a number of optimizations and disables array bounds
|
||||
checks. Should only enable when application is stable.
|
||||
* `--set <Symbol Name>=<Value>`: set config param `<Symbol Name>` to `<Value>`
|
||||
at compile-time.
|
||||
* `--main-module <Module Name>`: use the main() procedure found in the module
|
||||
`<Module Name>` as the executable's main.
|
||||
* `--module-dir <Directory>`: includes `<Directory>` in the module search path.
|
||||
|
||||
@ -11,10 +11,9 @@ lang: es-es
|
||||
|
||||
Puede leer todo sobre Chapel en [el sitio web oficial de Chapel de Cray](https://chapel-lang.org).
|
||||
En resumen, Chapel es un lenguaje de programación paralela, código abierto, de alta productividad
|
||||
desarrolladp en Cray Inc. y está diseñado para ejecutarse en PC multi-nucleos,
|
||||
desarrolladp en Cray Inc. y está diseñado para ejecutarse en PC multi-nucleos,
|
||||
así como en supercomputadoras multi-kilocore.
|
||||
|
||||
|
||||
Puede encontrar más información y asistencia al final de este documento.
|
||||
|
||||
```chapel
|
||||
@ -39,7 +38,7 @@ stdout.writeln("Esto va a la salida estándar, al igual que lo hace writeln()");
|
||||
stderr.writeln("Esto va al error estándar");
|
||||
|
||||
|
||||
// Las variables no tienen que escribirse explícitamente
|
||||
// Las variables no tienen que escribirse explícitamente
|
||||
// mientras el compilador pueda determinar el tipo que contendrá.
|
||||
|
||||
// 10 es un entero, asi que myVar es explícitamente un entero
|
||||
@ -86,7 +85,7 @@ var white: RGBColor = (255, 255, 255);
|
||||
// establecerla en tiempo de ejecución.
|
||||
const almostPi: real = 22.0/7.0;
|
||||
|
||||
// Un parámetro es una constante cuyo valor debe conocerse estáticamente
|
||||
// Un parámetro es una constante cuyo valor debe conocerse estáticamente
|
||||
// en tiempo de compilación.
|
||||
|
||||
param compileTimeConst: int = 16;
|
||||
@ -103,8 +102,8 @@ writeln(varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg);
|
||||
|
||||
// Referencias
|
||||
|
||||
// ref funciona de manera muy similar a una referencia en C ++. En Chapel,
|
||||
// no se puede hacer una referencia como alias a una variable distinta
|
||||
// ref funciona de manera muy similar a una referencia en C ++. En Chapel,
|
||||
// no se puede hacer una referencia como alias a una variable distinta
|
||||
// de la variable con la que se inicializa.
|
||||
|
||||
// Aquí, refToActual se refiere a actual.
|
||||
@ -152,7 +151,7 @@ a *= thatInt; // Multiplicación-igual (a = a * thatInt;)
|
||||
b &&= thatBool; // Lógico e igual (b = b && thatBool;)
|
||||
a <<= 3; // Desplazamiento a la izquierda igual (a = a << 10;)
|
||||
|
||||
// A diferencia de otros lenguajes de familia C, no hay operadores de
|
||||
// A diferencia de otros lenguajes de familia C, no hay operadores de
|
||||
// pre / post-incremento / decremento, tales como:
|
||||
//
|
||||
// ++j, --j, j++, j--
|
||||
@ -185,7 +184,7 @@ diffTup(1) = -1;
|
||||
var (tupInt, tupReal, tupCplx) = diffTup;
|
||||
writeln(diffTup == (tupInt, tupReal, tupCplx));
|
||||
|
||||
// También son útiles para imprimit una lista de variables,
|
||||
// También son útiles para imprimit una lista de variables,
|
||||
// como es común en la depuración.
|
||||
writeln((a,b,thisInt,thatInt,thisBool,thatBool));
|
||||
|
||||
@ -223,7 +222,7 @@ if a % 3 == 0 {
|
||||
var maximum = if thisInt < thatInt then thatInt else thisInt;
|
||||
|
||||
// las declaraciones select son muy parecidas a las declaraciones switch
|
||||
// en otros idiomas. Sin embargo, las declaraciones select no caen
|
||||
// en otros idiomas. Sin embargo, las declaraciones select no caen
|
||||
// en cascada como en C o Java.
|
||||
var inputOption = "anOption";
|
||||
select inputOption {
|
||||
@ -253,7 +252,7 @@ do {
|
||||
} while (j <= 10000);
|
||||
writeln(jSum);
|
||||
|
||||
// Los bucles for son muy parecidos a los de Python porque iteran en un rango.
|
||||
// Los bucles for son muy parecidos a los de Python porque iteran en un rango.
|
||||
// Los rangos (como la expresión 1..10 a continuación) son un objeto de primera clase
|
||||
// en Chapel, y como tal pueden almacenarse en variables.
|
||||
for i in 1..10 do write(i, ", ");
|
||||
@ -275,8 +274,8 @@ for x in 1..10 {
|
||||
// Rangos y Dominios
|
||||
|
||||
// Los bucles y matrices utilizan rangos y dominios para definir un conjunto de índices
|
||||
// que se pueden iterar. Los rangos son índices enteros unidimensionales, mientras
|
||||
// que los dominios pueden ser multidimensionales y representan índices
|
||||
// que se pueden iterar. Los rangos son índices enteros unidimensionales, mientras
|
||||
// que los dominios pueden ser multidimensionales y representan índices
|
||||
// de diferentes tipos.
|
||||
|
||||
// Son tipos ciudadanos de primera clase y pueden asignarse a variables.
|
||||
@ -296,7 +295,7 @@ var reverse2to10by2 = 2..10 by -2; // 10, 8, 6, 4, 2
|
||||
var trapRange = 10..1 by -1; // No te dejes engañar, esto sigue siendo un rango vacío
|
||||
writeln("Size of range ", trapRange, " = ", trapRange.length);
|
||||
|
||||
// Note: range(boundedType= ...) and range(stridable= ...) solo son necesarios
|
||||
// Note: range(boundedType= ...) and range(stridable= ...) solo son necesarios
|
||||
// si escribimos explícitamente la variable.
|
||||
|
||||
// El punto final de un rango se puede determinar utilizando el operador de conteo (#).
|
||||
@ -316,7 +315,7 @@ for i in rangeCountBy {
|
||||
write(i, if i == rangeCountBy.last then "\n" else ", ");
|
||||
}
|
||||
|
||||
// Los dominios rectangulares se definen usando la misma sintaxis de rango,
|
||||
// Los dominios rectangulares se definen usando la misma sintaxis de rango,
|
||||
// pero se requiere que estén delimitados (a diferencia de los rangos).
|
||||
var domain1to10: domain(1) = {1..10}; // 1D domain from 1..10;
|
||||
var twoDimensions: domain(2) = {-2..2,0..2}; // 2D domain over product of ranges
|
||||
@ -352,7 +351,7 @@ writeln(stringSet.sorted());
|
||||
// Los dominios asociativos también pueden tener una sintaxis literal
|
||||
var intSet = {1, 2, 4, 5, 100};
|
||||
|
||||
// Tanto los rangos como los dominios se pueden dividir para producir un rango
|
||||
// Tanto los rangos como los dominios se pueden dividir para producir un rango
|
||||
// o dominio con la intersección de los índices.
|
||||
var rangeA = 1.. ; // range from 1 to infinity
|
||||
var rangeB = ..5; // range from negative infinity to 5
|
||||
@ -377,7 +376,7 @@ for i in 1..10 do
|
||||
writeln(intArray);
|
||||
|
||||
// No podemos acceder a intArray[0] porque existe fuera del conjunto de índices,
|
||||
// {1..10}, que definimos al principio.
|
||||
// {1..10}, que definimos al principio.
|
||||
// intArray [11] es ilegal por la misma razón.
|
||||
var realDomain: domain(2) = {1..5,1..7};
|
||||
var realArray: [realDomain] real;
|
||||
@ -431,12 +430,12 @@ writeln((thisArray, thatArray));
|
||||
thatArray[4..5] = thisArray[1..2];
|
||||
writeln((thisArray, thatArray));
|
||||
|
||||
// Las operaciones también se pueden promover para trabajar en arreglos.
|
||||
// Las operaciones también se pueden promover para trabajar en arreglos.
|
||||
// 'thisPlusThat' también es una matriz.
|
||||
var thisPlusThat = thisArray + thatArray;
|
||||
writeln(thisPlusThat);
|
||||
|
||||
// Continuando, las matrices y los bucles también pueden ser expresiones, donde
|
||||
// Continuando, las matrices y los bucles también pueden ser expresiones, donde
|
||||
// la expresión del cuerpo del bucle es el resultado de cada iteración.
|
||||
var arrayFromLoop = for i in 1..10 do i;
|
||||
writeln(arrayFromLoop);
|
||||
@ -494,11 +493,11 @@ writeln(defaultsProc(x=11));
|
||||
writeln(defaultsProc(x=12, y=5.432));
|
||||
writeln(defaultsProc(y=9.876, x=13));
|
||||
|
||||
// El operador ? se llama operador de consulta y se usa para tomar valores
|
||||
// indeterminados como tuplas o tamaños de matriz y tipos genéricos.
|
||||
// Por ejemplo, tomar matrices como parámetros.
|
||||
// El operador ? se llama operador de consulta y se usa para tomar valores
|
||||
// indeterminados como tuplas o tamaños de matriz y tipos genéricos.
|
||||
// Por ejemplo, tomar matrices como parámetros.
|
||||
|
||||
// El operador de consulta se utiliza para determinar el dominio de A.
|
||||
// El operador de consulta se utiliza para determinar el dominio de A.
|
||||
// Esto es útil para definir el tipo de retorno, aunque no es obligatorio.
|
||||
proc invertArray(A: [?D] int): [D] int{
|
||||
for a in A do a = -a;
|
||||
@ -523,9 +522,9 @@ genericProc(1.2, 2.3);
|
||||
genericProc(1.0+2.0i, 3.0+4.0i);
|
||||
|
||||
// También podemos imponer una forma de polimorfismo con la cláusula where
|
||||
// Esto permite que el compilador decida qué función usar.
|
||||
// Esto permite que el compilador decida qué función usar.
|
||||
|
||||
// Nota: Eso significa que toda la información debe conocerse en tiempo de compilación.
|
||||
// Nota: Eso significa que toda la información debe conocerse en tiempo de compilación.
|
||||
// El modificador param en el argumento se usa para imponer esta restricción.
|
||||
proc whereProc(param N : int): void
|
||||
where (N > 0) {
|
||||
@ -541,7 +540,7 @@ whereProc(10);
|
||||
whereProc(-1);
|
||||
|
||||
// whereProc(0) daría lugar a un error del compilador porque no hay funciones
|
||||
// que satisfagan la condición de la cláusula where.
|
||||
// que satisfagan la condición de la cláusula where.
|
||||
// Podríamos haber definido un whereProc sin una cláusula where que
|
||||
// hubiera servido como captura para todos los demás casos (de los cuales solo hay uno).
|
||||
|
||||
@ -583,9 +582,9 @@ writeln("Afuera antes: ", (inVar, outVar, inoutVar, refVar));
|
||||
intentsProc(inVar, outVar, inoutVar, refVar);
|
||||
writeln("Afuera después: ", (inVar, outVar, inoutVar, refVar));
|
||||
|
||||
// Del mismo modo, podemos definir intentos en el tipo de retorno.
|
||||
// refElement devuelve una referencia a un elemento de la matriz. Esto tiene más sentido
|
||||
// práctico para los métodos de clase donde las referencias a elementos en una estructura
|
||||
// Del mismo modo, podemos definir intentos en el tipo de retorno.
|
||||
// refElement devuelve una referencia a un elemento de la matriz. Esto tiene más sentido
|
||||
// práctico para los métodos de clase donde las referencias a elementos en una estructura
|
||||
// de datos se devuelven a través de un método o iterador.
|
||||
proc refElement(array : [?D] ?T, idx) ref : T {
|
||||
return array[idx];
|
||||
@ -638,12 +637,12 @@ writeln(1 * 2); // Utiliza el operador predeterminado *.
|
||||
|
||||
// Iteradores
|
||||
|
||||
// Los iteradores son hermanas del procedimiento, y casi todo lo relacionado
|
||||
// con los procedimientos también se aplica a los iteradores. Sin embargo, en lugar de
|
||||
// Los iteradores son hermanas del procedimiento, y casi todo lo relacionado
|
||||
// con los procedimientos también se aplica a los iteradores. Sin embargo, en lugar de
|
||||
// devolver un solo valor, los iteradores pueden generar múltiples valores en un bucle.
|
||||
|
||||
// Esto es útil cuando se necesita un conjunto u orden complicado de iteraciones,
|
||||
// ya que permite que el código que define las iteraciones
|
||||
// Esto es útil cuando se necesita un conjunto u orden complicado de iteraciones,
|
||||
// ya que permite que el código que define las iteraciones
|
||||
// se separe del cuerpo del bucle.
|
||||
iter oddsThenEvens(N: int): int {
|
||||
for i in 1..N by 2 do
|
||||
@ -668,13 +667,13 @@ for i in absolutelyNothing(10) {
|
||||
writeln("Woa there! absolutelyNothing yielded ", i);
|
||||
}
|
||||
|
||||
// Podemos comprimir dos o más iteradores (que tienen el mismo número de iteraciones)
|
||||
// usando zip () para crear un solo iterador comprimido, donde cada iteración
|
||||
// Podemos comprimir dos o más iteradores (que tienen el mismo número de iteraciones)
|
||||
// usando zip () para crear un solo iterador comprimido, donde cada iteración
|
||||
// del iterador comprimido produce una tupla de un valor de cada iterador.
|
||||
for (positive, negative) in zip(1..5, -5..-1) do
|
||||
writeln((positive, negative));
|
||||
|
||||
// La iteración de la cremallera es bastante importante en la asignación de matrices,
|
||||
// La iteración de la cremallera es bastante importante en la asignación de matrices,
|
||||
// segmentos de matrices y expresiones de matriz / bucle.
|
||||
var fromThatArray : [1..#5] int = [1,2,3,4,5];
|
||||
var toThisArray : [100..#5] int;
|
||||
@ -696,7 +695,7 @@ for (i, j) in zip(toThisArray.domain, -100..#5) {
|
||||
writeln(toThisArray);
|
||||
|
||||
/*
|
||||
Esto es muy importante para entender por qué esta declaración
|
||||
Esto es muy importante para entender por qué esta declaración
|
||||
exhibe un error de tiempo de ejecución.
|
||||
*/
|
||||
|
||||
@ -718,16 +717,16 @@ class MyClass {
|
||||
var memberInt : int;
|
||||
var memberBool : bool = true;
|
||||
|
||||
// Inicializador definido explícitamente.
|
||||
// Inicializador definido explícitamente.
|
||||
// También obtenemos el inicializador generado por el compilador, con un argumento por campo.
|
||||
// Tenga en cuenta que pronto no habrá un inicializador generado por el compilador
|
||||
// Tenga en cuenta que pronto no habrá un inicializador generado por el compilador
|
||||
// cuando definamos los inicializadores explícitamente.
|
||||
proc init(val : real) {
|
||||
this.memberInt = ceil(val): int;
|
||||
}
|
||||
|
||||
// Desinicializador explícitamente definido.
|
||||
// Si no escribiéramos uno, obtendríamos el desinicializador generado por el compilador,
|
||||
// Si no escribiéramos uno, obtendríamos el desinicializador generado por el compilador,
|
||||
// que tiene un cuerpo vacío.
|
||||
proc deinit() {
|
||||
writeln("MyClass deinitializer called ", (this.memberInt, this.memberBool));
|
||||
@ -751,7 +750,7 @@ class MyClass {
|
||||
}
|
||||
} // termina MyClass
|
||||
|
||||
// Llame al inicializador generado por el compilador,
|
||||
// Llame al inicializador generado por el compilador,
|
||||
// utilizando el valor predeterminado para memberBool.
|
||||
var myObject = new MyClass(10);
|
||||
myObject = new MyClass(memberInt = 10); // Equivalente
|
||||
@ -801,8 +800,8 @@ class GenericClass {
|
||||
|
||||
// Copiar constructor.
|
||||
// Nota: Todavía tenemos que poner el tipo como argumento, pero podemos usar
|
||||
// el operador de consulta (?) como predeterminado para el tipo del otro objeto.
|
||||
// Además, podemos aprovechar esto para permitir a nuestro constructor de copias
|
||||
// el operador de consulta (?) como predeterminado para el tipo del otro objeto.
|
||||
// Además, podemos aprovechar esto para permitir a nuestro constructor de copias
|
||||
// copiar clases de diferentes tipos y emitir sobre la marcha.
|
||||
proc GenericClass(other : GenericClass(?otherType),
|
||||
type classType = otherType) {
|
||||
@ -818,7 +817,7 @@ class GenericClass {
|
||||
return this.classArray[i];
|
||||
}
|
||||
|
||||
// Definir un iterador implícito para que la clase produzca
|
||||
// Definir un iterador implícito para que la clase produzca
|
||||
// valores de la matriz a un bucle
|
||||
// i.e. for i in objVar do ...
|
||||
iter these() ref : classType {
|
||||
@ -827,12 +826,12 @@ class GenericClass {
|
||||
}
|
||||
} // end GenericClass
|
||||
|
||||
// Podemos asignar a la matriz de miembros del objeto usando la notación de
|
||||
// Podemos asignar a la matriz de miembros del objeto usando la notación de
|
||||
// corchete que definimos.
|
||||
var realList = new GenericClass(real, 10);
|
||||
for i in realList.classDomain do realList[i] = i + 1.0;
|
||||
|
||||
// Podemos iterar sobre los valores en nuestra lista con el iterador
|
||||
// Podemos iterar sobre los valores en nuestra lista con el iterador
|
||||
// que definimos.
|
||||
for value in realList do write(value, ", ");
|
||||
writeln();
|
||||
@ -852,7 +851,7 @@ writeln();
|
||||
|
||||
// Los módulos son la forma en que Chapel administra los espacios de nombres.
|
||||
// Los archivos que contienen estos módulos no necesitan ser nombrados después
|
||||
// de los módulos (como en Java), pero los archivos implícitamente nombran módulos.
|
||||
// de los módulos (como en Java), pero los archivos implícitamente nombran módulos.
|
||||
// Por ejemplo, este archivo nombra implícitamente el módulo learnChapelInYMinutes
|
||||
|
||||
module OurModule {
|
||||
@ -888,7 +887,7 @@ module OurModule {
|
||||
// Como OurModule usa Time, nosotros también usamos Time.
|
||||
use OurModule;
|
||||
|
||||
// En este punto no hemos usado ChildModule o SiblingModule, por lo que sus símbolos
|
||||
// En este punto no hemos usado ChildModule o SiblingModule, por lo que sus símbolos
|
||||
// (es decir, foo) no están disponibles para nosotros. Sin embargo, los nombres de
|
||||
// los módulos están disponibles y podemos llamar explícitamente a foo () a través de ellos.
|
||||
SiblingModule.foo();
|
||||
@ -901,7 +900,7 @@ foo();
|
||||
// Paralelismo
|
||||
|
||||
// En otros idiomas, el paralelismo generalmente se realiza con librerias complicadas
|
||||
// y extrañas jerarquías de estructura de clases.
|
||||
// y extrañas jerarquías de estructura de clases.
|
||||
// Chapel lo tiene directamente en el idioma.
|
||||
|
||||
// Podemos declarar un procedimiento principal, pero todo el código anterior
|
||||
@ -909,7 +908,7 @@ foo();
|
||||
proc main() {
|
||||
|
||||
// Una declaración de inicio hará girar el cuerpo de esa declaración en una nueva tarea.
|
||||
// Una declaración de sincronización garantizará que el progreso de la tarea principal
|
||||
// Una declaración de sincronización garantizará que el progreso de la tarea principal
|
||||
// no avance hasta que los hijos hayan sincronizado nuevamente.
|
||||
|
||||
sync {
|
||||
@ -927,15 +926,15 @@ proc main() {
|
||||
}
|
||||
|
||||
// Una declaración de cobegin girará cada declaración del cuerpo en una nueva tarea.
|
||||
// Observe aquí que las impresiones de cada declaración pueden ocurrir en
|
||||
// Observe aquí que las impresiones de cada declaración pueden ocurrir en
|
||||
// cualquier orden.
|
||||
cobegin {
|
||||
printFibb(20); // nueva tarea
|
||||
printFibb(10); // nueva tarea
|
||||
printFibb(5); // nueva tarea
|
||||
{
|
||||
// Este es un cuerpo de declaración anidado y, por lo tanto, es una
|
||||
// declaración única para la declaración principal, ejecutada
|
||||
// Este es un cuerpo de declaración anidado y, por lo tanto, es una
|
||||
// declaración única para la declaración principal, ejecutada
|
||||
// por una sola tarea.
|
||||
writeln("esto se ");
|
||||
writeln("ejecuta");
|
||||
@ -943,29 +942,29 @@ proc main() {
|
||||
}
|
||||
}
|
||||
|
||||
// Un bucle coforall creará una nueva tarea para CADA iteración.
|
||||
// Nuevamente vemos que las impresiones suceden en cualquier orden.
|
||||
// NOTA: ¡coforall debe usarse solo para crear tareas!
|
||||
// Un bucle coforall creará una nueva tarea para CADA iteración.
|
||||
// Nuevamente vemos que las impresiones suceden en cualquier orden.
|
||||
// NOTA: ¡coforall debe usarse solo para crear tareas!
|
||||
// ¡Usarlo para iterar sobre una estructura es una muy mala idea!
|
||||
var num_tasks = 10; // Number of tasks we want
|
||||
coforall taskID in 1..#num_tasks {
|
||||
writeln("Hola de tarea# ", taskID);
|
||||
}
|
||||
|
||||
// los bucles forall son otro bucle paralelo, pero solo crean un número
|
||||
// los bucles forall son otro bucle paralelo, pero solo crean un número
|
||||
// menor de tareas, específicamente --dataParTasksPerLocale = número de tareas.
|
||||
forall i in 1..100 {
|
||||
write(i, ", ");
|
||||
}
|
||||
writeln();
|
||||
|
||||
// Aquí vemos que hay secciones que están en orden, seguidas de una sección
|
||||
// que no seguiría (por ejemplo, 1, 2, 3, 7, 8, 9, 4, 5, 6,).
|
||||
// Aquí vemos que hay secciones que están en orden, seguidas de una sección
|
||||
// que no seguiría (por ejemplo, 1, 2, 3, 7, 8, 9, 4, 5, 6,).
|
||||
// Esto se debe a que cada tarea está asumiendo un fragmento del rango 1..10
|
||||
// (1..3, 4..6 o 7..9) haciendo ese fragmento en serie, pero cada tarea ocurre en paralelo.
|
||||
// (1..3, 4..6 o 7..9) haciendo ese fragmento en serie, pero cada tarea ocurre en paralelo.
|
||||
// Sus resultados pueden depender de su máquina y configuración
|
||||
|
||||
// Para los bucles forall y coforall, la ejecución de la tarea principal
|
||||
// Para los bucles forall y coforall, la ejecución de la tarea principal
|
||||
// no continuará hasta que todos los hijos se sincronicen.
|
||||
|
||||
// los bucles forall son particularmente útiles para la iteración paralela sobre matrices.
|
||||
@ -1002,7 +1001,7 @@ proc main() {
|
||||
|
||||
// Las variables atómicas, comunes a muchos idiomas, son aquellas cuyas operaciones
|
||||
// ocurren sin interrupciones. Por lo tanto, varios subprocesos pueden modificar
|
||||
// las variables atómicas y pueden saber que sus valores son seguros.
|
||||
// las variables atómicas y pueden saber que sus valores son seguros.
|
||||
// Las variables atómicas de la capilla pueden ser de tipo bool, int, uint y real.
|
||||
var uranium: atomic int;
|
||||
uranium.write(238); // escribir atómicamente una variable
|
||||
@ -1041,7 +1040,7 @@ proc main() {
|
||||
}
|
||||
|
||||
// las variables de sincronización tienen dos estados: vacío y lleno.
|
||||
// Si lee una variable vacía o escribe una variable completa,
|
||||
// Si lee una variable vacía o escribe una variable completa,
|
||||
// se espera hasta que la variable esté llena o vacía nuevamente.
|
||||
var someSyncVar$: sync int; // varName$ Es una convención, no una ley.
|
||||
sync {
|
||||
@ -1058,7 +1057,7 @@ proc main() {
|
||||
}
|
||||
}
|
||||
|
||||
// las variales individuales solo se pueden escribir una vez.
|
||||
// las variales individuales solo se pueden escribir una vez.
|
||||
// Una lectura en un solo no escrito da como resultado una espera,
|
||||
// pero cuando la variable tiene un valor, puede leerse indefinidamente.
|
||||
var someSingleVar$: single int; // varName$ Es una convención, no una ley.
|
||||
@ -1078,7 +1077,7 @@ proc main() {
|
||||
}
|
||||
}
|
||||
|
||||
// Aquí hay un ejemplo usando atómica y una variable de sincronización
|
||||
// Aquí hay un ejemplo usando atómica y una variable de sincronización
|
||||
// para crear un mutex de cuenta regresiva
|
||||
// (también conocido como multiplexor).
|
||||
var count: atomic int; // nuestro mostrador
|
||||
@ -1133,8 +1132,7 @@ proc main() {
|
||||
} // end main()
|
||||
```
|
||||
|
||||
¿Para quién es este tutorial?
|
||||
-------------------------
|
||||
## ¿Para quién es este tutorial?
|
||||
|
||||
Este tutorial es para personas que desean aprender las cuerdas de chapel sin tener
|
||||
que escuchar sobre qué mezcla de fibras son las cuerdas, o cómo fueron trenzadas,
|
||||
@ -1148,61 +1146,58 @@ para ver si se han agregado más temas o se han creado más tutoriales.
|
||||
|
||||
### Lo que le falta a este tutorial:
|
||||
|
||||
* Exposición de los [módulos estándar](https://chapel-lang.org/docs/latest/modules/standard.html)
|
||||
* Múltiples configuraciones regionales (sistema de memoria distribuida)
|
||||
* Registros
|
||||
* Iteradores paralelos
|
||||
* Exposición de los [módulos estándar](https://chapel-lang.org/docs/latest/modules/standard.html)
|
||||
* Múltiples configuraciones regionales (sistema de memoria distribuida)
|
||||
* Registros
|
||||
* Iteradores paralelos
|
||||
|
||||
¡Sus comentarios, preguntas y descubrimientos son importantes para los desarrolladores!
|
||||
-----------------------------------------------------------------------
|
||||
## ¡Sus comentarios, preguntas y descubrimientos son importantes para los desarrolladores!
|
||||
|
||||
El lenguaje Chapel todavía está en desarrollo activo, por lo que
|
||||
ocasionalmente hay problemas con el rendimiento y
|
||||
El lenguaje Chapel todavía está en desarrollo activo, por lo que
|
||||
ocasionalmente hay problemas con el rendimiento y
|
||||
las características del lenguaje.
|
||||
|
||||
Cuanta más información brinde al equipo de desarrollo de Chapel
|
||||
sobre los problemas que encuentre o las características que le gustaría ver,
|
||||
Cuanta más información brinde al equipo de desarrollo de Chapel
|
||||
sobre los problemas que encuentre o las características que le gustaría ver,
|
||||
mejor será el lenguaje.
|
||||
|
||||
|
||||
Hay varias formas de interactuar con los desarrolladores:
|
||||
+ [Chat de Gitter](https://gitter.im/chapel-lang/chapel)
|
||||
+ [lista de emails de Sourceforge](https://sourceforge.net/p/chapel/mailman)
|
||||
|
||||
* [Chat de Gitter](https://gitter.im/chapel-lang/chapel)
|
||||
* [lista de emails de Sourceforge](https://sourceforge.net/p/chapel/mailman)
|
||||
|
||||
Si está realmente interesado en el desarrollo del compilador o en contribuir al proyecto,
|
||||
[consulte el repositorio maestro de GitHub](https://github.com/chapel-lang/chapel).
|
||||
Está bajo el [La licencia Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0).
|
||||
|
||||
Instalar el compilador
|
||||
-----------------------
|
||||
## Instalar el compilador
|
||||
|
||||
[La documentación oficial de Chapel detalla cómo descargar y compilar el compilador de Chapel.](https://chapel-lang.org/docs/usingchapel/QUICKSTART.html)
|
||||
|
||||
Chapel se puede construir e instalar en su máquina promedio 'nix (y cygwin).
|
||||
Chapel se puede construir e instalar en su máquina promedio 'nix (y cygwin).
|
||||
[Descargue la última versión de lanzamiento](https://github.com/chapel-lang/chapel/releases/)
|
||||
y es tan fácil como
|
||||
|
||||
1. `tar -xvf chapel-<VERSION>.tar.gz`
|
||||
2. `cd chapel-<VERSION>`
|
||||
3. `source util/setchplenv.bash # or .sh or .csh or .fish`
|
||||
4. `make`
|
||||
5. `make check # optional`
|
||||
1. `tar -xvf chapel-<VERSION>.tar.gz`
|
||||
2. `cd chapel-<VERSION>`
|
||||
3. `source util/setchplenv.bash # or .sh or .csh or .fish`
|
||||
4. `make`
|
||||
5. `make check # optional`
|
||||
|
||||
You will need to `source util/setchplenv.EXT` from within the Chapel directory
|
||||
(`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop
|
||||
that command in a script that will get executed on startup (like .bashrc).
|
||||
|
||||
Necesitará `source util/setchplenv.EXT` desde el directorio de Chapel (`$CHPL_HOME`)
|
||||
cada vez que se inicie su terminal, por lo que se sugiere que suelte ese comando
|
||||
cada vez que se inicie su terminal, por lo que se sugiere que suelte ese comando
|
||||
en un script que se ejecutará al inicio (como .bashrc).
|
||||
|
||||
Chapel se instala fácilmente con Brew para OS X
|
||||
|
||||
1. `brew update`
|
||||
2. `brew install chapel`
|
||||
1. `brew update`
|
||||
2. `brew install chapel`
|
||||
|
||||
Compilando Código
|
||||
--------------
|
||||
## Compilando Código
|
||||
|
||||
Construye como otros compiladores:
|
||||
|
||||
@ -1210,10 +1205,10 @@ Construye como otros compiladores:
|
||||
|
||||
Argumentos notables:
|
||||
|
||||
* `--fast`: habilita varias optimizaciones y deshabilita las comprobaciones
|
||||
de los límites de la matriz Solo debe habilitarse cuando la aplicación es estable.
|
||||
* `--set <Nombre del Symbolo>=<Valor>`: establece el param de configuracion
|
||||
`<Nombre del Symbolo>` a `<Valor>`en tiempo de compilación.
|
||||
* `--main-module <Nombre del módulo>`: use el procedimiento main() que se encuentra en el módulo
|
||||
`<Nombre del módulo>` como principal del ejecutable.
|
||||
* `--module-dir <Directorio>`: incluye `<Directorio>` en la ruta de búsqueda del módulo.
|
||||
* `--fast`: habilita varias optimizaciones y deshabilita las comprobaciones
|
||||
de los límites de la matriz Solo debe habilitarse cuando la aplicación es estable.
|
||||
* `--set <Nombre del Symbolo>=<Valor>`: establece el param de configuracion
|
||||
`<Nombre del Symbolo>` a `<Valor>`en tiempo de compilación.
|
||||
* `--main-module <Nombre del módulo>`: use el procedimiento main() que se encuentra en el módulo
|
||||
`<Nombre del módulo>` como principal del ejecutable.
|
||||
* `--module-dir <Directorio>`: incluye `<Directorio>` en la ruta de búsqueda del módulo.
|
||||
|
||||
@ -6,14 +6,11 @@ contributors:
|
||||
|
||||
lang: pt-br
|
||||
---
|
||||
|
||||
O Cypher é a linguagem de consulta do Neo4j para manipular gráficos facilmente. Ela reutiliza a sintaxe do SQL e a mistura com o tipo de ascii-art para representar gráficos. Este tutorial pressupõe que você já conheça conceitos de gráficos como nós e relacionamentos.
|
||||
|
||||
[Leia mais aqui.](https://neo4j.com/developer/cypher-query-language/)
|
||||
|
||||
|
||||
Nós
|
||||
---
|
||||
## Nós
|
||||
|
||||
**Representa um registro em um gráfico.**
|
||||
|
||||
@ -34,21 +31,19 @@ Um nó pode ter algumas *propriedades*, aqui **name** e **age**. Começa com min
|
||||
|
||||
Os tipos permitidos nas propriedades:
|
||||
|
||||
- Numeric
|
||||
- Boolean
|
||||
- String
|
||||
- Lista de tipos primitivos anteriores
|
||||
- Numeric
|
||||
- Boolean
|
||||
- String
|
||||
- Lista de tipos primitivos anteriores
|
||||
|
||||
*Aviso: não há propriedade datetime no Cypher! Você pode usar String com um padrão específico ou um Numeric a partir de uma data específica.*
|
||||
|
||||
`p.name`
|
||||
Você pode acessar uma propriedade com o estilo de ponto.
|
||||
|
||||
## Relacionamentos (ou Arestas)
|
||||
|
||||
Relacionamentos (ou Arestas)
|
||||
---
|
||||
|
||||
**Conecta dois nós**
|
||||
**Conecta dois nós.**
|
||||
|
||||
`[:KNOWS]`
|
||||
É um *relacionamento* com o *label* **KNOWS**. É um *label* como um rótulo do nó. Começa com maiúsculas e usa UPPER_SNAKE_CASE.
|
||||
@ -62,9 +57,7 @@ O mesmo *relacionamento*, com *propriedades* (como *nó*), aqui **since**.
|
||||
`[k:KNOWS*..4]`
|
||||
É uma informação estrutural para usar em um *path* (visto posteriormente). Aqui, **\*..4** diz, “Corresponda o padrão, com a relação **k** que é repetida de 1 a 4 vezes.
|
||||
|
||||
|
||||
Paths
|
||||
---
|
||||
## Paths
|
||||
|
||||
**A maneira de misturar nós e relacionamentos.**
|
||||
|
||||
@ -80,9 +73,9 @@ Você pode encadear vários relacionamentos. Este path descreve o amigo de um am
|
||||
`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
|
||||
Uma encadeamento também pode ser direcionada. Este path descreve que **a** é o chefe de **b** e o grande chefe de **c**.
|
||||
|
||||
Padrões frequentemente usados (do Neo4j doc) :
|
||||
Padrões frequentemente usados (do Neo4j doc):
|
||||
|
||||
```
|
||||
```cypher
|
||||
// Amigo de um amigo
|
||||
(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
|
||||
|
||||
@ -96,13 +89,11 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) )
|
||||
(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
|
||||
```
|
||||
|
||||
|
||||
Crie consultas
|
||||
---
|
||||
## Crie consultas
|
||||
|
||||
Crie um novo nó
|
||||
|
||||
```
|
||||
```cypher
|
||||
CREATE (a:Person {name:"Théo Gauchoux"})
|
||||
RETURN a
|
||||
```
|
||||
@ -111,52 +102,51 @@ RETURN a
|
||||
|
||||
Crie um novo relacionamento (com 2 novos nós)
|
||||
|
||||
```
|
||||
```cypher
|
||||
CREATE (a:Person)-[k:KNOWS]-(b:Person)
|
||||
RETURN a,k,b
|
||||
```
|
||||
|
||||
Consultas que casam
|
||||
---
|
||||
## Consultas que casam
|
||||
|
||||
Casam todos os nós
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (n)
|
||||
RETURN n
|
||||
```
|
||||
|
||||
Casam nós por label
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a:Person)
|
||||
RETURN a
|
||||
```
|
||||
|
||||
Casam nós por label e propriedade
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a:Person {name:"Théo Gauchoux"})
|
||||
RETURN a
|
||||
```
|
||||
|
||||
Casam nós de acordo com os relacionamentos (não direcionados)
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a)-[:KNOWS]-(b)
|
||||
RETURN a,b
|
||||
```
|
||||
|
||||
Casam nós de acordo com os relacionamentos (direcionados)
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a)-[:MANAGES]->(b)
|
||||
RETURN a,b
|
||||
```
|
||||
|
||||
Casam nós com um cláusula `WHERE`
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
|
||||
WHERE s.since = 2015
|
||||
RETURN p,state
|
||||
@ -164,19 +154,17 @@ RETURN p,state
|
||||
|
||||
Você pode usa a cláusula `MATCH WHERE` com a cláusula `CREATE`
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a), (b)
|
||||
WHERE a.name = "Jacquie" AND b.name = "Michel"
|
||||
CREATE (a)-[:KNOWS]-(b)
|
||||
```
|
||||
|
||||
|
||||
Atualizar consultas
|
||||
---
|
||||
## Atualizar consultas
|
||||
|
||||
Atualizar uma propriedade específica de um nó
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
SET p.age = 23
|
||||
@ -184,7 +172,7 @@ SET p.age = 23
|
||||
|
||||
Substituir todas as propriedades de um nó
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
SET p = {name: "Michel", age: 23}
|
||||
@ -192,7 +180,7 @@ SET p = {name: "Michel", age: 23}
|
||||
|
||||
Adicionar nova propriedade a um nó
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
SET p + = {studies: "IT Engineering"}
|
||||
@ -200,19 +188,17 @@ SET p + = {studies: "IT Engineering"}
|
||||
|
||||
Adicione um label a um nó
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
SET p:Internship
|
||||
```
|
||||
|
||||
|
||||
Excluir consultas
|
||||
---
|
||||
## Excluir consultas
|
||||
|
||||
Excluir um nó específico (os relacionamentos vinculados devem ser excluídos antes)
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)-[relationship]-()
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
DELETE relationship, p
|
||||
@ -220,7 +206,7 @@ DELETE relationship, p
|
||||
|
||||
Remover uma propriedade em um nó específico
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
REMOVE p.age
|
||||
@ -230,7 +216,7 @@ REMOVE p.age
|
||||
|
||||
Remover um label de um nó específico
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
DELETE p:Person
|
||||
@ -238,7 +224,7 @@ DELETE p:Person
|
||||
|
||||
Excluir o banco de dados inteiro
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (n)
|
||||
OPTIONAL MATCH (n)-[r]-()
|
||||
DELETE n, r
|
||||
@ -246,9 +232,7 @@ DELETE n, r
|
||||
|
||||
*Sério, é o `rm -rf /` do Cypher !*
|
||||
|
||||
|
||||
Outras cláusulas úteis
|
||||
---
|
||||
## Outras cláusulas úteis
|
||||
|
||||
`PROFILE`
|
||||
Antes de uma consulta, mostre o plano de execução dela.
|
||||
@ -259,9 +243,7 @@ Contar entidades (nós ou relacionamentos) que casam com **e**.
|
||||
`LIMIT x`
|
||||
Limite o resultado aos primeiros x resultados.
|
||||
|
||||
|
||||
Dicas Especiais
|
||||
---
|
||||
## Dicas Especiais
|
||||
|
||||
- Há apenas comentários de uma linha no Cypher, com barras duplas : // Comentários
|
||||
- Você pode executar um script Cypher armazenado em um arquivo **.cql** diretamente no Neo4j (é uma importação). No entanto, você não pode ter várias instruções neste arquivo (separadas por **;**).
|
||||
|
||||
@ -13,11 +13,9 @@ Cypher - це мова запитів Neo4j для спрощення робот
|
||||
|
||||
[Деталі тут](https://neo4j.com/developer/cypher-query-language/)
|
||||
|
||||
## Вершини
|
||||
|
||||
Вершини
|
||||
---
|
||||
|
||||
**Відображує запис у графі.**
|
||||
#### Відображує запис у графі
|
||||
|
||||
`()`
|
||||
Таким чином у запиті позначається пуста *вершина*. Використовується зазвичай для того, щоб позначити, що вона є, проте це не так вже й важливо для запиту.
|
||||
@ -36,27 +34,24 @@ Cypher - це мова запитів Neo4j для спрощення робот
|
||||
|
||||
Наступні типи дозволяється використовувати у властивостях:
|
||||
|
||||
- Чиселиний
|
||||
- Булевий
|
||||
- Рядок
|
||||
- Списки попередніх примітивних типів
|
||||
- Чиселиний
|
||||
- Булевий
|
||||
- Рядок
|
||||
- Списки попередніх примітивних типів
|
||||
|
||||
*Увага! В Cypher не існує типу, що відображає час. Замість нього можна використовувати рядок із визначеним шаблоном або чисельне відображення певної дати.*
|
||||
|
||||
`p.name`
|
||||
За допомогою крапки можна звернутись до властивості вершини.
|
||||
|
||||
|
||||
Зв'язки (або ребра)
|
||||
---
|
||||
|
||||
**Сполучають дві вершини**
|
||||
## Зв'язки (або ребра)
|
||||
#### Сполучають дві вершини
|
||||
|
||||
`[:KNOWS]`
|
||||
Це *зв'язок* з *ярликом* **KNOWS**. Це такий же самий *ярлик* як і у вершини. Починається з великої літери та використовує ВЕРХНІЙ\_РЕГІСТР\_ІЗ\_ЗМІЇНОЮ\_НОТАЦІЄЮ.
|
||||
|
||||
`[k:KNOWS]`
|
||||
Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково.
|
||||
Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково.
|
||||
|
||||
`[k:KNOWS {since:2017}]`
|
||||
Той же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивість - це **since**.
|
||||
@ -64,11 +59,8 @@ Cypher - це мова запитів Neo4j для спрощення робот
|
||||
`[k:KNOWS*..4]`
|
||||
Це структурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів."
|
||||
|
||||
|
||||
Шляхи
|
||||
---
|
||||
|
||||
**Спосіб поєднувати вершини та зв'язки.**
|
||||
## Шляхи
|
||||
#### Спосіб поєднувати вершини та зв'язки.
|
||||
|
||||
`(a:Person)-[:KNOWS]-(b:Person)`
|
||||
Шлях описує, що вершини **a** та **b** знають (knows) один одного.
|
||||
@ -84,8 +76,8 @@ Cypher - це мова запитів Neo4j для спрощення робот
|
||||
|
||||
Шаблони, які часто використовуються (з документації Neo4j):
|
||||
|
||||
```
|
||||
// Друг-мого-друга
|
||||
```cypher
|
||||
// Друг-мого-друга
|
||||
(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
|
||||
|
||||
// Найкоротший шлях
|
||||
@ -98,13 +90,11 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) )
|
||||
(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
|
||||
```
|
||||
|
||||
|
||||
Запити на створення
|
||||
---
|
||||
## Запити на створення
|
||||
|
||||
Створити нову вершину:
|
||||
|
||||
```
|
||||
```cypher
|
||||
CREATE (a:Person {name:"Théo Gauchoux"})
|
||||
RETURN a
|
||||
```
|
||||
@ -113,52 +103,51 @@ RETURN a
|
||||
|
||||
Створити новий зв'язок (із двома вершинами):
|
||||
|
||||
```
|
||||
```cypher
|
||||
CREATE (a:Person)-[k:KNOWS]-(b:Person)
|
||||
RETURN a,k,b
|
||||
```
|
||||
|
||||
Запити на знаходження
|
||||
---
|
||||
## Запити на знаходження
|
||||
|
||||
Знайти всі вершини:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (n)
|
||||
RETURN n
|
||||
```
|
||||
|
||||
Знайти вершини за ярликом:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a:Person)
|
||||
RETURN a
|
||||
```
|
||||
|
||||
Знайти вершини за ярликом та властивістю:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a:Person {name:"Théo Gauchoux"})
|
||||
RETURN a
|
||||
```
|
||||
|
||||
Знайти вершини відповідно до зв'язків (ненаправлених):
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a)-[:KNOWS]-(b)
|
||||
RETURN a,b
|
||||
```
|
||||
|
||||
Знайти вершини відповідно до зв'язків (направлених):
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a)-[:MANAGES]->(b)
|
||||
RETURN a,b
|
||||
```
|
||||
|
||||
Знайти вершини за допомогою `WHERE`:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
|
||||
WHERE s.since = 2015
|
||||
RETURN p,state
|
||||
@ -166,19 +155,17 @@ RETURN p,state
|
||||
|
||||
Можна використовувати вираз `MATCH WHERE` разом із операцією `CREATE`:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (a), (b)
|
||||
WHERE a.name = "Jacquie" AND b.name = "Michel"
|
||||
CREATE (a)-[:KNOWS]-(b)
|
||||
```
|
||||
|
||||
|
||||
Запити на оновлення
|
||||
---
|
||||
## Запити на оновлення
|
||||
|
||||
Оновити окрему властивість вершини:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
SET p.age = 23
|
||||
@ -186,7 +173,7 @@ SET p.age = 23
|
||||
|
||||
Оновити всі властивості вершини:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
SET p = {name: "Michel", age: 23}
|
||||
@ -194,7 +181,7 @@ SET p = {name: "Michel", age: 23}
|
||||
|
||||
Додати нову властивіcть до вершини:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
SET p + = {studies: "IT Engineering"}
|
||||
@ -202,19 +189,17 @@ SET p + = {studies: "IT Engineering"}
|
||||
|
||||
Повісити ярлик на вершину:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
SET p:Internship
|
||||
```
|
||||
|
||||
|
||||
Запити на видалення
|
||||
---
|
||||
## Запити на видалення
|
||||
|
||||
Видалити окрему вершину (пов'язані ребра повинні бути видалені перед цим):
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)-[relationship]-()
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
DELETE relationship, p
|
||||
@ -222,7 +207,7 @@ DELETE relationship, p
|
||||
|
||||
Видалити властивість певної вершини:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
REMOVE p.age
|
||||
@ -230,17 +215,17 @@ REMOVE p.age
|
||||
|
||||
*Зверніть увагу, що ключове слово `REMOVE` це не те саме, що й `DELETE`!*
|
||||
|
||||
Видалити ярлик певної вершини:
|
||||
Видалити ярлик певної вершини:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (p:Person)
|
||||
WHERE p.name = "Théo Gauchoux"
|
||||
DELETE p:Person
|
||||
```
|
||||
|
||||
Видалити всю базу даних:
|
||||
Видалити всю базу даних:
|
||||
|
||||
```
|
||||
```cypher
|
||||
MATCH (n)
|
||||
OPTIONAL MATCH (n)-[r]-()
|
||||
DELETE n, r
|
||||
@ -248,9 +233,7 @@ DELETE n, r
|
||||
|
||||
*Так, це `rm -rf /` на мові Cypher !*
|
||||
|
||||
|
||||
Інші корисні запити
|
||||
---
|
||||
## Інші корисні запити
|
||||
|
||||
`PROFILE`
|
||||
Перед виконанням, показати план виконання запитів.
|
||||
@ -261,11 +244,9 @@ DELETE n, r
|
||||
`LIMIT x`
|
||||
Обмежити результат до x перших результатів.
|
||||
|
||||
## Особливі підказки
|
||||
|
||||
Особливі підказки
|
||||
---
|
||||
|
||||
- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : // Коментар
|
||||
- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : `// Коментар`
|
||||
- Можна виконати скрипт Cypher, збережений у файлі **.cql** прямо в Neo4j (прямо як імпорт). Проте, не можна мати мати кілька виразів в цьому файлі (розділених **;**).
|
||||
- Використовуйте командний рядок Neo4j для написання запитів Cypher, це легко і швидко.
|
||||
- Cypher планує бути стандартною мовою запитів для всіх графових баз даних (більш відома як **OpenCypher**).
|
||||
|
||||
Loading…
Reference in New Issue
Block a user