Implemente Un Contrato Inteligente En La Cadena Kucoin - KCC

Kucoin Chain es una cadena de bloques que utiliza la máquina virtual Ethereum (EVM), lo que significa que es compatible con Solidity. A continuación, se incluyen instrucciones sobre cómo implementar un contrato inteligente de Solidity en la cadena Kucoin "KCC". El proceso para implementar un contrato inteligente que se describe a continuación es casi idéntico al de otras cadenas de bloques compatibles con EVM.

¿Qué es la cadena Kucoin?

La cadena Kucoin “KCC” afirma ser una cadena pública descentralizada con alto rendimiento. El objetivo de la cadena es resolver el bajo rendimiento de transacción y los altos costos de transacción observados en otras cadenas públicas. Es totalmente compatible con los estándares de contrato inteligente Ethereum y ERC. El token de Kucoin "KCS" es el combustible y el token nativo de KCC y se utiliza para pagar las tarifas de gasolina. Los bloques se producen cada 3 segundos para acelerar las confirmaciones de transacciones y un mayor rendimiento de la cadena. Ha adoptado el algoritmo de consenso de Prueba de Autoridad Estacada "PoSA", que se cree que es más eficiente y seguro. En toda esta cadena parece tener el mismo modelo de negocio que Binance Smart Chain .

Para obtener más información sobre Kucoin Chain, visite su sitio web .

Contrato inteligente Herramientas de desarrollo de Kucoin Chain

Como desarrollador de KCC, puede usar las mismas herramientas de desarrollo que se usan para el desarrollo en Ethereum. Puede usar Remix, Truffle, MetaMask, etc. para desarrollar en la cadena de bloques de KCC. Consulte aquí para obtener una lista de herramientas para desarrolladores de Ethereum .

Configurar MetaMask para la red de prueba de KCC

Puede usar cualquier billetera compatible con Ethereum para configurar la red KCC. Algunos ejemplos de billeteras para usar son MetaMask ,  myetherwallet ,  imtoken ,  TokenPocket , etc. A continuación, configuraremos MetaMask para conectarse a KCC.

El nombre de la red de prueba de KCC es  KCC-TESTNET y a continuación explicaré cómo configurar su billetera MetaMask para conectarse a la red de prueba de Kucoin.

Abra MetaMask y seleccione:

• Ajustes
• Red

 

 

Seleccione Agregar red

 

 

• Copie y pegue la siguiente información en un editor de texto. Hará que sea más fácil poner esta información en MetaMask y evitará que la pantalla se cierre.
• Escriba la siguiente información en MetaMask:

1. Nombre de la red : KCC-TESTNET
2. Nueva URL de RPC : https://rpc-testnet.kcc.network
3. ID de cadena : 322
4. Símbolo : KCS
5. URL del explorador de bloques : https://scan-testnet.kcc.network
6. URL RPC de WebSocket : wss://rpc-ws-testnet.kcc.network

 

Ahora su billetera MetaMask está conectada a KCC-TESTNET.

Faucet de Kucoin para tokens de prueba

Ahora vaya al  faucet de Kucoin Chain  y solicite  tokens KCS de prueba . Los tokens se envían a su billetera de inmediato.

Ahora que está conectado a la red de prueba de Kucoin, su billetera está configurada y tiene tokens de prueba de KCS, intente implementar un contrato inteligente en el entorno de prueba.

Implemente un contrato inteligente en la cadena Kucoin

Puede usar  Remix  para escribir contratos inteligentes de Solidity e implementarlos en Kucoin Chain (KCC-TESTNET o KCC-MAINNET). Para probar esto, puede copiar el código de contrato inteligente de Solidity a continuación e implementarlo en Kucoin Chain.

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

//simple ERC20 contract to experiment with
//all tokens are assigned to the creator

contract SimpleToken is ERC20 {

//set the name, symbol, and supply at time of deployment in the constructor
//all tokens are assigned to the creator

    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply
    ) public ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
    }
}

Pruébalo en  Remix

Luego envíe su transacción a la red en Remix. MetaMask mostrará KCC-TESTNET en la esquina superior derecha.

Para ver la confirmación de la transacción en KCC-TESTNET, use su  explorador de bloques  para el entorno de prueba.

Use su explorador de bloques para navegar a su contrato inteligente que se envió a la red de prueba. Para ver el contrato, haga clic en el número de cuenta del contrato recién creado en la parte superior de la pantalla (la línea negra en la imagen a continuación bloquea los números de cuenta del contrato).

Para verificar el código del contrato, haga clic en el enlace "Verificar y publicar" en la parte inferior de la pantalla. El proceso de verificación y publicación del contrato es muy similar al de Ethereum.

Configurar MetaMask para la red principal de KCC

La red principal de KCC se puede configurar usando los ajustes a continuación. Copie y pegue la siguiente información en un editor de texto.

• Hará que sea más fácil poner esto en MetaMask y evitará que la pantalla se cierre sobre ti.
• Escriba la siguiente información en MetaMask agregando un nuevo RPC personalizado. Siga las instrucciones anteriores para la red de prueba y use la configuración a continuación para Mainnet.
• Nombre de red : KCC-MAINNET
• Nueva URL de RPC : https://rpc-mainnet.kcc.network
• ID de cadena :321
• Símbolo : KCS
• URL del explorador de bloques : https://explorer.kcc.io/en
• URL RPC de WebSocket : wss://rpc-ws-mainnet.kcc.network

Transferir fondos de Ethereum a Kucoin Chain en Mainnet

Si tiene tokens en Ethereum y desea transferirlos a Kucoin Chain, puede usar el puente KCC o el puente AnySwap . Estos puentes son canales de transacciones bidireccionales sin confianza y puede leer más sobre ellos  aquí . Los fondos tardan aproximadamente entre 12 y 15 minutos en transferirse.

1. Vaya al sitio web del puente Anyswap
2. Conecta tu billetera
3. Seleccione el token en la cadena Ethereum que desea mover a la cadena Kucoin.

 

Cómo apostar KSC en Kucoin Chain

Apostar

Llame al método de apuesta en el contrato inteligente del validador para apostar con cualquier validador. La cantidad mínima de participación para cada validador es de 32 tokens KCS.

Dejar de apostar

Si desea cancelar la participación de sus tokens KCS, llame al método de cancelación de participación en el contrato del validador y espere 86400 bloques (3 días), luego llame al método de retirada de participación en el contrato del validador para retirar fondos.

Ejecute un nodo de validación de Kucoin

KCC tiene un mecanismo de consenso PoSA que presenta bajos costos de transacción y un rápido rendimiento de transacciones. PoSA es una combinación de PoA y PoS y admite hasta 29 validadores.

Para convertirse en un validador, debe crear un nodo y luego enviar una propuesta para que voten los validadores activos. Si más de la mitad de los validadores activos votan sí, será elegible para convertirse en validador.

Luego, los usuarios pueden depositar sus monedas en una dirección que haya calificado para convertirse en un validador. La cantidad mínima para apostar es 32 KCS. Una vez que el volumen de participación del validador se ubique entre los primeros 29, se convertirá en un validador activo en la próxima época.

Todos los validadores activos se ordenan de acuerdo con un conjunto de reglas predefinidas. Cada validador toma un turno para minar bloques en la cadena. Si un validador no logra extraer un bloque a tiempo durante su ronda, los validadores activos que no han estado involucrados en los últimos n/2 (n es el número de validadores activos) bloques realizarán el bloqueo al azar. Al menos n/2+1 validadores activos funcionan correctamente para garantizar el correcto funcionamiento de la cadena de bloques.

Fuente: https://cryptomarketpool.com/deploy-a-smart-contract-to-the-kucoin-chain-kcc/

#kucoin #nft 

What is GEEK

Buddha Community

Implemente Un Contrato Inteligente En La Cadena Kucoin - KCC

Kucoin Chain es una cadena de bloques que utiliza la máquina virtual Ethereum (EVM), lo que significa que es compatible con Solidity. A continuación, se incluyen instrucciones sobre cómo implementar un contrato inteligente de Solidity en la cadena Kucoin "KCC". El proceso para implementar un contrato inteligente que se describe a continuación es casi idéntico al de otras cadenas de bloques compatibles con EVM.

¿Qué es la cadena Kucoin?

La cadena Kucoin “KCC” afirma ser una cadena pública descentralizada con alto rendimiento. El objetivo de la cadena es resolver el bajo rendimiento de transacción y los altos costos de transacción observados en otras cadenas públicas. Es totalmente compatible con los estándares de contrato inteligente Ethereum y ERC. El token de Kucoin "KCS" es el combustible y el token nativo de KCC y se utiliza para pagar las tarifas de gasolina. Los bloques se producen cada 3 segundos para acelerar las confirmaciones de transacciones y un mayor rendimiento de la cadena. Ha adoptado el algoritmo de consenso de Prueba de Autoridad Estacada "PoSA", que se cree que es más eficiente y seguro. En toda esta cadena parece tener el mismo modelo de negocio que Binance Smart Chain .

Para obtener más información sobre Kucoin Chain, visite su sitio web .

Contrato inteligente Herramientas de desarrollo de Kucoin Chain

Como desarrollador de KCC, puede usar las mismas herramientas de desarrollo que se usan para el desarrollo en Ethereum. Puede usar Remix, Truffle, MetaMask, etc. para desarrollar en la cadena de bloques de KCC. Consulte aquí para obtener una lista de herramientas para desarrolladores de Ethereum .

Configurar MetaMask para la red de prueba de KCC

Puede usar cualquier billetera compatible con Ethereum para configurar la red KCC. Algunos ejemplos de billeteras para usar son MetaMask ,  myetherwallet ,  imtoken ,  TokenPocket , etc. A continuación, configuraremos MetaMask para conectarse a KCC.

El nombre de la red de prueba de KCC es  KCC-TESTNET y a continuación explicaré cómo configurar su billetera MetaMask para conectarse a la red de prueba de Kucoin.

Abra MetaMask y seleccione:

• Ajustes
• Red

 

 

Seleccione Agregar red

 

 

• Copie y pegue la siguiente información en un editor de texto. Hará que sea más fácil poner esta información en MetaMask y evitará que la pantalla se cierre.
• Escriba la siguiente información en MetaMask:

1. Nombre de la red : KCC-TESTNET
2. Nueva URL de RPC : https://rpc-testnet.kcc.network
3. ID de cadena : 322
4. Símbolo : KCS
5. URL del explorador de bloques : https://scan-testnet.kcc.network
6. URL RPC de WebSocket : wss://rpc-ws-testnet.kcc.network

 

Ahora su billetera MetaMask está conectada a KCC-TESTNET.

Faucet de Kucoin para tokens de prueba

Ahora vaya al  faucet de Kucoin Chain  y solicite  tokens KCS de prueba . Los tokens se envían a su billetera de inmediato.

Ahora que está conectado a la red de prueba de Kucoin, su billetera está configurada y tiene tokens de prueba de KCS, intente implementar un contrato inteligente en el entorno de prueba.

Implemente un contrato inteligente en la cadena Kucoin

Puede usar  Remix  para escribir contratos inteligentes de Solidity e implementarlos en Kucoin Chain (KCC-TESTNET o KCC-MAINNET). Para probar esto, puede copiar el código de contrato inteligente de Solidity a continuación e implementarlo en Kucoin Chain.

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

//simple ERC20 contract to experiment with
//all tokens are assigned to the creator

contract SimpleToken is ERC20 {

//set the name, symbol, and supply at time of deployment in the constructor
//all tokens are assigned to the creator

    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply
    ) public ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
    }
}

Pruébalo en  Remix

Luego envíe su transacción a la red en Remix. MetaMask mostrará KCC-TESTNET en la esquina superior derecha.

Para ver la confirmación de la transacción en KCC-TESTNET, use su  explorador de bloques  para el entorno de prueba.

Use su explorador de bloques para navegar a su contrato inteligente que se envió a la red de prueba. Para ver el contrato, haga clic en el número de cuenta del contrato recién creado en la parte superior de la pantalla (la línea negra en la imagen a continuación bloquea los números de cuenta del contrato).

Para verificar el código del contrato, haga clic en el enlace "Verificar y publicar" en la parte inferior de la pantalla. El proceso de verificación y publicación del contrato es muy similar al de Ethereum.

Configurar MetaMask para la red principal de KCC

La red principal de KCC se puede configurar usando los ajustes a continuación. Copie y pegue la siguiente información en un editor de texto.

• Hará que sea más fácil poner esto en MetaMask y evitará que la pantalla se cierre sobre ti.
• Escriba la siguiente información en MetaMask agregando un nuevo RPC personalizado. Siga las instrucciones anteriores para la red de prueba y use la configuración a continuación para Mainnet.
• Nombre de red : KCC-MAINNET
• Nueva URL de RPC : https://rpc-mainnet.kcc.network
• ID de cadena :321
• Símbolo : KCS
• URL del explorador de bloques : https://explorer.kcc.io/en
• URL RPC de WebSocket : wss://rpc-ws-mainnet.kcc.network

Transferir fondos de Ethereum a Kucoin Chain en Mainnet

Si tiene tokens en Ethereum y desea transferirlos a Kucoin Chain, puede usar el puente KCC o el puente AnySwap . Estos puentes son canales de transacciones bidireccionales sin confianza y puede leer más sobre ellos  aquí . Los fondos tardan aproximadamente entre 12 y 15 minutos en transferirse.

1. Vaya al sitio web del puente Anyswap
2. Conecta tu billetera
3. Seleccione el token en la cadena Ethereum que desea mover a la cadena Kucoin.

 

Cómo apostar KSC en Kucoin Chain

Apostar

Llame al método de apuesta en el contrato inteligente del validador para apostar con cualquier validador. La cantidad mínima de participación para cada validador es de 32 tokens KCS.

Dejar de apostar

Si desea cancelar la participación de sus tokens KCS, llame al método de cancelación de participación en el contrato del validador y espere 86400 bloques (3 días), luego llame al método de retirada de participación en el contrato del validador para retirar fondos.

Ejecute un nodo de validación de Kucoin

KCC tiene un mecanismo de consenso PoSA que presenta bajos costos de transacción y un rápido rendimiento de transacciones. PoSA es una combinación de PoA y PoS y admite hasta 29 validadores.

Para convertirse en un validador, debe crear un nodo y luego enviar una propuesta para que voten los validadores activos. Si más de la mitad de los validadores activos votan sí, será elegible para convertirse en validador.

Luego, los usuarios pueden depositar sus monedas en una dirección que haya calificado para convertirse en un validador. La cantidad mínima para apostar es 32 KCS. Una vez que el volumen de participación del validador se ubique entre los primeros 29, se convertirá en un validador activo en la próxima época.

Todos los validadores activos se ordenan de acuerdo con un conjunto de reglas predefinidas. Cada validador toma un turno para minar bloques en la cadena. Si un validador no logra extraer un bloque a tiempo durante su ronda, los validadores activos que no han estado involucrados en los últimos n/2 (n es el número de validadores activos) bloques realizarán el bloqueo al azar. Al menos n/2+1 validadores activos funcionan correctamente para garantizar el correcto funcionamiento de la cadena de bloques.

Fuente: https://cryptomarketpool.com/deploy-a-smart-contract-to-the-kucoin-chain-kcc/

#kucoin #nft 

What are salient features available in KuCoin Exchange?

KuCoin is a cryptocurrency exchange that started in the year 2017 in Seychelles. Kucoin aimed to provide crypto trading in a highly secured way. It has acquired five million registered users worldwide. The Kucoin has been officially partnered with IDG Capital and Matrix Partners.
Kucoin exchange offers extended support to secure user crypto by providing offline storage. Kucoin supports 400 cryptocurrencies and 340 trading pairs. Kucoin also supports ICO to launch new cryptocurrencies on their exchange, a great option for crypto entrepreneurs. It Has its cryptocurrencies KCS and shares among the users. Kucoin charges very little for withdraw and trading. It charges 0.1 % of interest-based on the crypto asset.

Salient Features at Kucoin Exchange

KCS Lockup and Cashback program

KCS lockup scheme has been introduced that user has to hold the token for 3months and they get additional 50% as profit on unlocking the kcs token.

KuMEX Launch

The announcement was Bitcoin Perpetual Contract and avails offer up to 20X leverage. To feast the launch of kuMEX, they have started a trading competition and pay winners with 10,000 KCS

KCS pay fee launch

On October 30, Kucoin officially announced the kucoin pay fee feature. Users can enable the feature and enjoy discounts of up to 20% for all sorts of trading pairs.

One can start a cryptocurrency exchange like KuCoin with a ready-made clone script available at markets that helps to launch exchange instantly!
KuCoin clone script is cryptocurrency exchange source code to launch exchange with all the features and functionalities like kucoin exchange. It helps entrepreneurs to launch crypto exchanges with ease.

#kucoin clone script, #kucoin clone software #kucoin clone, #kucoin clone app

Cómo Construir Un Analizador En Rust Por Diversión Y Ganancias

Un viernes por la mañana, holgazaneando, estás pensando en los nuevos programas de Netflix para ver. Su jefe viene y le pide que escriba un analizador para un archivo de unidad de Systemd .

Lo necesita para el lunes.

Estás nervioso.

La última vez que se le pidió que escribiera un analizador, se metió en la madriguera del conejo de la web, copiando y pegando fórmulas Regex hasta que funcionó™.

Tomas un sorbo de tu té de boba para calmarte. Buscas Systemd en Google y te gusta... no, no es tan simple como pensabas.

Tu buen truco de copiar y pegar expresiones regulares sale volando por la ventana. Las posibilidades de pasar un fin de semana sin interrupciones para atracones de programas se acercan rápidamente null.

#PEG al rescate

No pierdas la esperanza todavía. Permítame presentarle Parse Expression Grammer (PEG) , una manera fácil de familiarizarse con los analizadores y ahorrar su valioso fin de semana.

PEG es una forma legible de escribir reglas de sintaxis y es bastante similar a las expresiones regulares, que es diferente de una contraparte de gramática libre de contexto como Backus-Naur Form (BNF) en la que las expresiones deben reducirse a símbolos más pequeños. Lo siento, Noam Chomsky , quizás otros días de trabajo.

Usaré una biblioteca de análisis de Rust PEG llamada Pest , que es bastante impresionante. Si aún no lo has hecho, esperaré mientras instalas Rust .

#Empezando

Comencemos con una gramática simple para analizar una declaración de declaración de variable similar a JavaScript. Comenzaremos pensando en un conjunto de reglas para entradas válidas.

#Una declaración de declaración:

• comienza con una palabra clave var, seguida de uno o más identificadores.
• es insensible al espacio en blanco
• termina con un punto y coma ( ;)

#Un grupo de identificadores:

• está precedido por una varpalabra clave
• está delimitado por comas
• es insensible al espacio en blanco

#Un identificador:

• puede contener cualquier número de dígitos, caracteres y guiones bajos en mayúsculas y minúsculas
• no puede comenzar con un dígito
• no puede contener ningún espacio

Un identificador es un término , lo que significa que es una pieza irrompible del token. También lo son las varpalabras clave y los puntos y comas.

Regresa un poco al lado BNF, usando Extended Backus-Naur Grammar (EBNF) , podrías definir formalmente la gramática anterior de esta manera:

<alpha>  := 'a' | 'b' | 'c' | 'd' | 'e' | /* ... */ 'z'
         |  'A' | 'B' | 'C' | 'D' | 'E' | /* ... */ 'Z'

<digit>  := 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<Decl>   := 'var' <Idents> '\n'? ';'
<Idents> := <Ident> ('\n'? ',' <Ident>)*
<Ident>  := <alpha>+ (<alpha> | <digit> | '_')*

El nombre de la regla en mayúsculas representa un símbolo que no termina (es decir, se puede dividir en términos más pequeños). El nombre en minúscula representa un término.

En aras de la brevedad, omitimos los espacios en blanco implícitos de las reglas. Básicamente, pueden existir uno o más espacios en blanco entre cada símbolo que ve.

¡Vamos a profundizar en ello! Las reglas <alpha>y <digit>se explican por sí mismas, por lo que dejaremos que lo adivines.

<Decl>es la regla más compleja para una instrucción de declaración, que presenta una varpalabra clave, un <Idents>símbolo, una nueva línea opcional y termina con un punto y coma. Básicamente, esta regla dice: "Cualquier entrada de cadena que comience con var, seguida de uno o más espacios, luego una subregla <Idents>, seguida de uno o más espacios y finalmente termine con un solo punto y coma es válida y felizmente la masticaré. "

<Idents>puede ser un solo <Ident>símbolo, seguido de cero o más pares de comas y <Ident>.

Finalmente, un <Ident>debe comenzar con uno o más caracteres, seguido de cero o más caracteres, dígitos o guiones bajos.

#Ok, código por favor

¡Espera, joven Anakin! Cabeza caliente, eres. He aquí que, con la gramática definida, podremos analizar estas declaraciones:

var foo, bar, baz;

var   foo_1, baRamYu,baz99;

var foo_x
  , baroo
  , bazoo
  ;

No, no me olvidé de formatear mi código. ¡Es JS válido, y también es para nuestro analizador! Aquí hay algo que nuestras reglas no soportarán:

var 99Problems

¿Alguien quiere adivinar qué está mal aquí? ✋ Deja tu respuesta en el comentario. (psss, si tu respuesta es correcta, te sigo + 3 me gusta en tu publicación 👍)

#Entra el óxido y las plagas

Ok, espero que ya tengas Rust instalado (En tu terminal, intenta escribir which cargoy ver si aparece). Comience creando un nuevo proyecto binario de Rust con

$ cargo new --bin maybe-js; cd maybe-js

Dentro de la carpeta del proyecto, abra el Cargo.tomlarchivo y agregue lo siguiente en dependencies, y ejecútelo cargo updatepara instalarlo.

[dependencies]
pest = "2.0"
pest_derive = "2.0"

Una vez hecho esto, cdingrese srcy cree un archivo llamado grammar.pesty pegue lo siguiente en él:

alpha = { 'a'..'z' | 'A'..'Z' }
digit = { '0'..'9' }
underscore = { "_" }
newline = _{ "\n" | "\r" }
WHITESPACE = _{ " " }

declaration = { "var" ~ !newline ~ idents ~ newline? ~ ";" }
idents = { ident ~ (newline? ~ "," ~ ident)* }
ident = @{ !digit ~ (alpha | digit | underscore)+ }

Ahora bien, si he tenido su atención durante los últimos minutos, no debería ser difícil adivinar lo que está sucediendo aquí. (Oh, ¿no lo he hecho? De todos modos... aquí vamos)

Los cinco primeros son todos términos. Son conjuntos de valores válidos. el | se llama Choice Operator , que es como "o-si no".

first | or_else

Al hacer coincidir una expresión de elección, firstse intenta. Si first coincide con éxito, la expresión completa se realiza correctamente de inmediato. Sin embargo, si firstfalla, or_elsese intenta a continuación.

La newlineregla tiene un peculiar _antes del corchete, que en Pest habla significa "silencioso": simplemente no lo queremos como parte de nuestros tokens analizados, pero de todos modos es parte de una sintaxis válida.

La WHITESPACEregla tiene un lugar especial en Pest. Si lo definió, Pest insertará automáticamente espacios en blanco opcionales implícitos (de acuerdo con la WHITESPACEregla que defina) entre cada símbolo. Nuevamente, _dice que queremos silenciarlo, ya que no queremos toneladas de espacios en blanco como parte de nuestro árbol de sintaxis.

La declarationregla es muy similar a la contraparte de EBNF que aprendimos antes. Las tildes ("~") simplemente significan "y luego". La regla comienza con una palabra clave "var", seguida de cualquier cosa que no sea un salto de línea (el "!" hace lo que hubiera adivinado intuitivamente: negar una regla), seguida de una subregla idents, un salto de línea opcional y finaliza con un punto y coma.

La identsregla es nuevamente similar al ejemplo EBNF. Es un solo ident, seguido de cero o más idents separados por comas.

La identregla es un poco especial. La "@", conocida como Atomic , delante del corchete está ahí para decir: "No quiero que se apliquen espacios en blanco implícitos a esta regla". Seguro que no queremos incluir ningún espacio en nuestro nombre de variable. Además, marcar una regla como atómica de esta manera trata la regla como un término, silenciando las reglas internas de coincidencia. Cualquier regla interna se descarta.

string_lit = { "\"" ~ inner ~ "\"" }
inner = { ASCII_ALPHANUMERIC* }

Tenga en cuenta que ASCII_ALPHANUMERICes una regla incorporada conveniente en Pest para cualquier carácter y dígito ASCII.

Si analizamos una cadena "hola" con esta regla, esto generará primero un string_litnodo, que a su vez tiene un innernodo que contiene la cadena "hola", sin comillas.

Agregar un sigilo "@" delante del string_litcorchete:

string_lit = @{ "\"" ~ inner ~ "\"" }
inner = { ASCII_ALPHANUMERIC* }

string_litTerminaremos con un nodo plano que contiene ""hola"".

Un sigilo similar "$" conocido como Compound Atomic , protege los espacios en blanco implícitos dentro de la regla. La diferencia es que permite que las reglas de coincidencia internas se analicen normalmente.

La !digitparte evita que la regla avance si comienza con un número. Si no es así, una o más combinaciones de caracteres, números y guiones bajos están bien.

#Pero espera, ¿dónde está el código?

¡Dang, mi inteligente explorador! Pareces arrinconarme en cada movimiento. Sí, eso no era código en absoluto, sino una definición de gramática de Pest. Ahora tenemos que escribir un código de Rust para analizar un texto. Inicie src/main.rsy agregue lo siguiente:

/// You need to do this to use macro
extern crate pest;                                                                                                                                                                                   
#[macro_use]                                                                                                                                                                                         
extern crate pest_derive;                                                                                                                                                                            

/// 1. Import modules                                                                                                                                                                                            
use std::fs;                                                                                                                                                                                         
use pest::Parser;                                                                                                                                                                                    
use pest::iterators::Pair;                                                                                                                                                                           

/// 2. Define a "marker" struct and add a path to our grammar file.                                                                                                                                                                                                 
#[derive(Parser)]                                                                                                                                                                                    
#[grammar = "grammar.pest"]                                                                                                                                                                            
struct IdentParser; 

/// 3. Print the detail of a current Pair and optional divider
fn print_pair(pair: &Pair<Rule>, hard_divider: bool) {
    println!("Rule: {:?}", pair.as_rule());
    println!("Span: {:?}", pair.as_span());
    println!("Text: {:?}", pair.as_str());
    if hard_divider {
        println!("{:=>60}", "");
    } else {
        println!("{:->60}", "");
    }
}

fn main() {
    /// 4. Parse a sample string input
    let pair = IdentParser::parse(Rule::declaration, "var foo1, bar_99, fooBar;")
        .expect("unsuccessful parse")
        .next().unwrap();

    print_pair(&pair, true);
    
    /// 5. Iterate over the "inner" Pairs
    for inner_pair in pair.into_inner() {
 
        print_pair(&inner_pair, true);

        match inner_pair.as_rule() {
            /// 6. If we match an idents rule...
            Rule::idents =>  {
                /// 7. Iterate over another inner Pairs
                for inner_inner_pair in inner_pair.into_inner() {
                    match inner_inner_pair.as_rule() {
                        /// 8. The term ident is the last level
                        Rule::ident => {
                            print_pair(&inner_inner_pair, false);
                        }
                        _ => unreachable!(),
                    }
                }
            }
            _ => unreachable!(),
        }
    }
}

Está bien si no entiendes la mayoría de las cosas aquí. Ejecutémoslo cargo runen el directorio de su proyecto y miremos la salida impresa.

Rule: declaration
Span: Span { str: "var foo1, bar_99, fooBar;", start: 0, end: 28 }
Text: "var foo1, bar_99, fooBarBaz;"
============================================================
Rule: idents
Span: Span { str: "foo1, bar_99, fooBar", start: 4, end: 27 }
Text: "foo1, bar_99, fooBarBaz"
============================================================
Rule: ident
Span: Span { str: "foo1", start: 4, end: 8 }
Text: "foo1"
------------------------------------------------------------
Rule: ident
Span: Span { str: "bar_99", start: 10, end: 16 }
Text: "bar_99"
------------------------------------------------------------
Rule: ident
Span: Span { str: "fooBar", start: 18, end: 27 }
Text: "fooBarBaz"
------------------------------------------------------------

El concepto más importante aquí es un Pair. Representa un par de tokens coincidentes o, de manera equivalente, el texto distribuido que una regla con nombre coincidió correctamente.

A menudo usamos Pairs para:

Determinar qué regla produjo elPair

Usar el Paircomo materia prima&str

Inspeccionar las sub-reglas internas nombradas que produjeron elPair

let pair = Parser::parse(Rule::enclosed, "(..6472..) and more text")
    .unwrap().next().unwrap();

assert_eq!(pair.as_rule(), Rule::enclosed);
assert_eq!(pair.as_str(), "(..6472..)");

let inner_rules = pair.into_inner();
println!("{}", inner_rules); // --> [number(3, 7)]

A Pairpuede tener cero, una o más reglas internas. Para máxima flexibilidad, Pair::into_inner()devuelve Pairs, que es un tipo de iterador sobre cada par.

💡 Pair::into_inner()es un idioma muy común cuando se trabaja con Pest. Asegúrate de entender qué Paires a.

#Vamos a analizar Systemd

Ahora es el momento de poner el trabajo. Aquí hay un ejemplo de un archivo de unidad Systemd:

[Unit]
Description=Nginx
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/home/ec2-user/.local/bin
Environment=LD_LIBRARY_PATH=/usr/local/lib
Environment=PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
ExecStart=/usr/local/sbin/nginx-runner.sh
Restart=on-failure
RestartSec=0
KillMode=process

[Install]
WantedBy=multi-user.target

El archivo está agrupado en secciones, cada una con un nombre entre corchetes. Cada sección contiene cero o más pares de nombre y valor de propiedad, separados por un signo igual "=".

Tratemos de desarrollar un conjunto de reglas. Cree un nuevo proyecto de óxido con cargo new --bin systemd-parser, luego cree un archivo con el nombre src/grammar.pestcon las siguientes reglas:

/// Implicit white spaces are ok.
WHITESPACE = _{ " " }

/// Set of characters permited 
char = { ASCII_ALPHANUMERIC | "." | "_" | "/" | "-"  }

/// name is one or more chars. Note that white spaces are allowed.
name = { char+ }

// value can be zero or more char, plus = and : for path variables.
value = { (char | "=" | ":" )* }

/// section is a name, enclosed by square brackets.
section = { "[" ~ name ~ "]" }

/// property pair is a name and value, separated by an equal sign.
property = { name ~ "=" ~ value }

/// A Systemd unit file structure
file = {
    SOI ~
    ((section | property)? ~ NEWLINE)* ~
    EOI
}

En el main.rsarchivo, comience con lo siguiente

extern crate pest;
#[macro_use]
extern crate pest_derive;

use std::fs;
use std::env::current_dir;
use std::collections::HashMap;
use pest::Parser;

#[derive(Parser)]
#[grammar = "grammar.pest"]
struct SystemdParser;

/// Implement a simple AST representation
#[derive(Debug, Clone)]
pub enum SystemdValue {
    List(Vec<String>),
    Str(String),
}

// ...

Como primer paso, después de las importaciones y la configuración iniciales, definimos una SystemdValueenumeración como una representación simple del tipo de datos en un archivo Systemd. SystemdValue::Str(String)capturará un solo valor de propiedad y SystemdValue::List(Vec<String>)capturará varios valores de propiedad con un nombre de clave de propiedad duplicado. Por ejemplo, en el nginx.servicearchivo anterior hay varias Environmentpropiedades.

Aquí está la mainfunción:

fn main() {
    // Read and parse the unit file.
    let unparsed_file = fs::read_to_string("nginx.service")
        .expect("cannot read file");
    let file = SystemdParser::parse(Rule::file, &unparsed_file).expect("fail to parse")
        .next()
        .unwrap();

    // Create a fresh HashMap to store the data.
    let mut properties: HashMap<String, HashMap<String, SystemdValue>> = HashMap::new();

    // These two mutable variables will be used to store
    // section name and property key name.
    let mut current_section_name = String::new();
    let mut current_key_name = String::new();

    // Iterate over the file line-by-line.
    for line in file.into_inner() {
		match line.as_rule() {
			Rule::section => {
                // Update the current_section_name
                let mut inner_rules = line.into_inner();
                current_section_name = inner_rules.next().unwrap().as_str().to_string();
			}
			Rule::property => {
                let mut inner_rules = line.into_inner();
                // Get a sub map of properties with the current_section_name key, or create new.
                let section = properties.entry(current_section_name.clone()).or_default();

                // Get the current property name and value.
                let name = inner_rules.next().unwrap().as_str().to_string();
                let value = inner_rules.next().unwrap().as_str().to_string();

                // If the property name already exists...
                if name == current_key_name {
                    // Get the section of the map with the key name, or insert a new SytemdValue::List.
                    let entry = section.entry(current_key_name.clone()).or_insert(SystemdValue::List(vec![]));
                    // Push the value onto the inner vector of SystemdValue::List.
                    if let SystemdValue::List(ent) = entry {
                        ent.push(value);
                    }
                } else {
                    // Create a new SystemdValue::List and save it under name key.
                    let entry = section.entry(name.clone()).or_insert(SystemdValue::List(vec![]));
                    // Push the current value onto the vector, then set the
                    // current_key_name to the current name.
                    if let SystemdValue::List(ent) = entry {
                        ent.push(value);
                    }
                    current_key_name = name;
                }
			}
			Rule::EOI => (),
			_ => unreachable!(),
		}
    }
}

Todo esto está bien, pero no usamos SystemdValue::Strninguna parte del código. Para mantener limpio el código, decidimos tratar cada propiedad como HashMap<String, SystemdValue::List(Vec<String>), donde la clave del mapa es la clave de propiedad y el vector String almacena la lista de valores de propiedad. Si no hay valor, el vector está vacío. Si hay un valor, este vector contiene ese único valor, y así sucesivamente.

Para que la API sea un poco más fácil de usar, escribiremos una pequeña función auxiliar para procesar todos los correos electrónicos de un solo valor Systemd::List(Vec<String>)y convertirlos en archivos Systemd::Str(String).

// Iterate over the nested maps, and convert empty and 
// single-element `SystemdValue::List<Vec<String>>` to 
// `SystemdValue::Str(String)`.
fn pre_process_map(map: &mut HashMap<String, HashMap<String, SystemdValue>>) {
    for (_, value) in map.into_iter() {
		for (_, v) in value.into_iter() {
			if let SystemdValue::List(vs) = v {
				if vs.len() == 0 {
					let v_ = SystemdValue::Str(String::new());
					*v = v_.clone();
				} else if vs.len() == 1 {
					let v_ = SystemdValue::Str((vs[0]).clone());
					*v = v_.clone();
				}
			}
		}
    }
}

¡Ahora estamos listos para imprimirlo para que el mundo lo vea!

fn main() {

    // Our main code 

    pre_process_map(properties);

    println!("{:#?}", properties);
}

¡Auge! ¡Felicidades! Acaba de escribir un analizador de archivos Systemd, además de uno mini JS. 🤯 Ahora tendrás algo de tiempo libre para divertirte el viernes por la noche. Con otra tarde, es posible que incluso descubras cómo serializar el archivo de tu unidad Systemd en JSON para impresionar a tu jefe el lunes.

Puede consultar el código del analizador implementado como biblioteca en [este repositorio] (https://github.com/jochasinga/systemd-parser)

Fuente: https://hackernoon.com/how-to-build-a-parser-in-rust-for-fun-and-profit

#rust 

Convertisseur OST en PST - Gratuit OST en PST pour convertir un fichier OST à fichier PST

Les utilisateurs ont deux façons de convertir les fichiers OST au format Outlook PST manuellement ou à l’aide de l’application. La conversion manuelle des fichiers OST prend beaucoup de temps ainsi que les efforts des utilisateurs. Par conséquent, les utilisateurs doivent utiliser un outil de conversion OST en PST. Le Datavare convertisseur OST vers PST est la meilleure solution pour convertir les fichiers OST au format Outlook PST.

Pour effectuer la conversion des fichiers OST, les utilisateurs doivent télécharger cette application incroyable. Cette application effectue la tâche de manière efficace et sans effort. Les utilisateurs peuvent convertir des fichiers OST entiers à l’aide de cet outil étonnant et à une vitesse rapide. Des données entières, y compris des notes, des messages, des contacts et des calendriers, sont converties au format PST à l’aide de cet outil incroyable. De plus, les utilisateurs sont libres d’enregistrer le fichier converti n’importe où sur votre système local. Avec cette application hautement compatible, les utilisateurs peuvent facilement utiliser ce convertisseur OST vers PST dans n’importe quel système d’exploitation Windows. C’est une application hautement interactive que même un utilisateur novice peut utiliser. L’application est une plate-forme sûre et sécurisée pour tous les utilisateurs. Les étapes requises pour convertir le fichier OST au format PST sont simples à implémenter.
Les utilisateurs sont libres d’enregistrer le fichier n’importe où dans leur système local sans rencontrer aucune difficulté.

Étapes pour convertir les fichiers

Suivez les étapes ci-dessous pour convertir les fichiers OST au format PST:

Étape 1 - Téléchargez l’outil de conversion OST en PST dans votre système d’exploitation Windows
Étape 2 - Lancez l’application
Étape 3 - Ajoutez les fichiers OST
Étape 4 - Aperçu des fichiers OST sélectionnés
Étape 5 - Choisissez l’emplacement pour enregistrer les fichiers convertis
Étape 6 - Enfin, cliquez sur le bouton «Convertir maintenant». Par conséquent, voici quelques étapes simples avec lesquelles un utilisateur peut facilement convertir ses fichiers OST au format Outlook PST.

Fonctionnalités de l’application

Faites-nous maintenant part de certaines fonctionnalités intelligentes de l’application qu’un utilisateur doit voir:

Convertissez les fichiers OST
L’application convertit librement les fichiers OST au format Outlook PST facilement et de manière fiable sans aucune obligation. La conversion directe des fichiers OST est effectuée par cet outil étonnant. De plus, les utilisateurs peuvent utiliser l’application dans n’importe quelle version de Windows, de la dernière à la plus ancienne version de l’application. L’application convertit toutes les données après avoir prévisualisé et numérisé les données. La taille des fichiers OST n’a pas d’importance dans l’ensemble du processus de conversion.

Précision
Avec une précision totale, tout un processus de conversion est effectué par l’application. Peu importe qu’un utilisateur entre le nombre de fichiers qu’il saisit, les utilisateurs sont autorisés à convertir les fichiers de manière irréprochable. Tous les fichiers OST sont facilement exportés de manière sûre et sécurisée sans aucun type de perte de données ou de corruption de données.

Emplacement spécifié par l’utilisateur
Les fichiers OST convertis peuvent être enregistrés n’importe où selon le souhait de l’emplacement spécifique à l’utilisateur. Une flexibilité totale des fichiers est fournie par l’application afin que l’utilisateur ne soit confronté à aucun problème lors de l’enregistrement du fichier.

Application hautement compatible
C’est une application hautement compatible qui peut être utilisée dans n’importe quelle version de Windows. De la version la plus ancienne à la plus récente de Windows, l’application peut être facilement exploitée sans aucune difficulté. La compatibilité de l’application est inégalée par rapport à toute autre application. Le résultat souhaité est fourni par l’application.

Déclaration finale

Téléchargez cet incroyable convertisseur OST en PST pour convertir vos fichiers OST au format Outlook PST. L’intégrité des fichiers est maintenue par l’application et la qualité des fichiers est conservée par l’application. Avec cette application hautement compatible, les utilisateurs obtiennent le résultat souhaité par les utilisateurs. De plus, vous devriez essayer la version de démonstration de l’application pour en savoir plus sur l’application. La version de démonstration de l’application est gratuite pour tous les utilisateurs. Cette version de démonstration de l’application donne aux utilisateurs le droit de convertir quelques fichiers OST. Pour convertir les fichiers illimités, l’utilisateur doit acheter la version sous licence de l’application maintenant.

Plus d’informations:- https://www.datavare.com/fr/convertisseur-ost-à-pst.html

#convertisseur ost en pst #conversion ost en pst #ost à l'importateur pst #importer ost vers pst #convertir ost en pst #exporter ost vers pst

Convertisseur OST en PST - Gratuit OST en PST pour convertir un fichier OST à fichier PST

Tout le monde peut désormais convertir ses fichiers OST au format Outlook PST sans effort en un seul clic. La conversion se fait à grande vitesse en une seule fois. La conversion nécessite quelques étapes pour convertir le fichier. Les utilisateurs ont des avantages majeurs à utiliser ce convertisseur intelligent. Nous discuterons plus de ce convertisseur.

Pourquoi utiliser ce convertisseur intelligent?

Une méthode de conversion intelligente est fournie par l’application afin que l’utilisateur puisse travailler efficacement. Laissez-nous discuter des points qui vous donnent la principale raison d’utiliser cette application intelligente:

• Vitesse de traitement élevée.
• Bon taux de précision.
• Application indépendante.
• Convient à toutes les versions de Windows.
• Ne convertit que les fichiers OST sains.
• Transférer toutes les données OST.
• Convient à toutes les versions de Windows.
• Facile à utiliser.
• Interface utilisateur simple.

Ce sont les avantages fournis par l’application sans aucune perte.

Comment convertir les fichiers OST en Outlook PST?

Pour convertir le fichier OST au format PST, l’utilisateur doit suivre certaines étapes. Vous trouverez ci-dessous la méthode étape par étape pour convertir des fichiers OST au format Outlook PST sans perte de données:

Étape 1 - Installez l’application sur n’importe quelle version de Windows, de la plus ancienne à la plus récente
Étape 2 - Choisissez le fichier OST que vous souhaitez convertir
Étape 3- Maintenant, choisissez l’emplacement où vous souhaitez enregistrer votre fichier converti
Étape 4 - Cliquez sur le bouton «Convertir maintenant»

Le processus de conversion commencera et le résultat apparaîtra dans un instant.

Regardez certaines des fonctionnalités du convertisseur

Voici quelques-unes des fonctionnalités étonnantes de ce convertisseur intelligent qui aideront les utilisateurs à convertir les fichiers.

• Résultats précis à 100%
Les utilisateurs transfèrent avec précision les fichiers sans aucune corruption de données. Le résultat de la conversion est tout précis et, par conséquent, aucun problème n’est rencontré par l’utilisateur.

• Conversion de fichiers sains
L’application prend en charge uniquement la conversion de fichiers sains sans aucun obstacle. Par conséquent, une conversion saine est accordée par l’application.

• Compatibilité élevée
L’application convertit les données à grande vitesse. Il fournit un bon service compatible afin que l’utilisateur ne rencontre aucun problème pendant le processus de conversion.

• Sauvegarde personnalisée des données
Les utilisateurs peuvent enregistrer les données n’importe où à tout moment à l’aide de cette application. Il n’y a aucune restriction de ce type donnée par l’application pour enregistrer un fichier.

• Conversion sélective des utilisateurs
Seuls les fichiers que l’utilisateur souhaite convertir sont convertis sans aucun problème pour les utilisateurs. L’application fonctionne efficacement et fournit ainsi des résultats sans erreur aux utilisateurs.

• N’accordez que la conversion de quelques fichiers
L’application convertit uniquement les fichiers OST au format Outlook PST. Aucun autre format de fichier n’est converti par cette application.

Mots finaux

Les utilisateurs doivent télécharger le convertisseur OST en PST pour convertir en douceur les fichiers OST. Ce convertisseur intelligent répond à toutes les attentes des utilisateurs et maintient ainsi son intégrité et convertit efficacement le fichier. Les utilisateurs peuvent installer la version gratuite de l’application et prendre une démo du logiciel.

More Info;- https://www.datavare.com/fr/convertisseur-ost-à-pst.html

#convertisseur ost en pst #ost à pst importateur #importer ost vers pst #convertir ost en pst #ost 2 conversion pst